file_name large_stringlengths 4 140 | prefix large_stringlengths 0 12.1k | suffix large_stringlengths 0 12k | middle large_stringlengths 0 7.51k | fim_type large_stringclasses 4
values |
|---|---|---|---|---|
BratsCRFNeighborWhole.py | Counter
from CRFUtils import *
from BratsCheckPredictions import *
import math
from math import *
train_path="/media/bmi/MyPassport/new_n4/Recon_2013_data/N4_zscore_training_t1_t1c_hist_match"
test_path="/media/bmi/MyPassport/new_n4/Recon_2013_data/N4_zscore_testing_t1_t1c_hist_match"
#train_path="/media/bmi/MyPassport/n4_entire/Recon_2013_data/training_longitudnal"
#test_path="/media/bmi/MyPassport/n4_entire/Recon_2013_data/testing_longitudnal"
#train_path="/home/rsk/Documents/PyStruct/data/train"
#test_path="/home/rsk/Documents/PyStruct/data/test"
#%%
#################################################################################################
#Training the model
def trainModel_Neighbor(num_iter=5,inference="qpbo",trainer="NSlack",num_train=2,num_test=1,C=0.1,edges="180x180_dist1_diag0",inputs=[1,1,1,1,1,1],features="post+img+pred",neighbor=-1,directed=False,savePred=False):
| [trainLayers,trainTruth,sliceShape] = train
print "Training slices loaded in %f" % (train_load_time)
n_features= len(trainLayers[0][0,0])
print "Layer shape is : "
print trainLayers[0].shape
print "Training the model"
edges= np.load("/home/bmi/CRF/edges/"+edges+".npy")
G = [edges for x in trainLayers]
print trainLayers[0].shape
trainLayers = np.array( [x.reshape((sliceShape[0]*sliceShape[1],n_features)) for x in trainLayers] )
trainTruth = np.array( [x.reshape((sliceShape[0]*sliceShape[1],)).astype(int) for x in trainTruth] )
if inference=='ogm':
crf = GraphCRF(inference_method=('ogm',{'alg':'fm'}),directed=directed)
else:
crf = GraphCRF(inference_method=inference,directed=directed)
if trainer=="Frank":
svm = FrankWolfeSSVM(model = crf,max_iter=num_iter,C=C,n_jobs=6,verbose=1)
elif trainer=="NSlack":
svm = NSlackSSVM(model = crf,max_iter=num_iter,C=C,n_jobs=-1,verbose=1)
else:
svm = OneSlackSSVM(model = crf,max_iter=num_iter,C=C,n_jobs=-1,verbose=1)
start = time.clock()
asdf = zip(trainLayers,G)
svm.fit(asdf,trainTruth)
end = time.clock()
train_time = (end-start)/60.0
print "The training took %f" % (train_time)
print "Model parameter size :"
print svm.w.shape
print "making predictions on train data"
predTrain = svm.predict(asdf)
trainDice=[]
for i in range(len(trainLayers)):
diceScore = accuracy(predTrain[i],trainTruth[i])
trainDice.append(diceScore)
meanTrainDice = sum(trainDice)/len(trainLayers)
del trainLayers,trainTruth
################################################################################################
overallDicePerPatient=[] # For overall test Dice
extDicePerPatient=[]
PatientTruthLayers=[]
PatientPredLayers=[]
PREC=[]
RECALL=[]
F1=[]
LayerwiseDiceTotal=[]
testResultFile = open(os.getcwd()+"/CRFResults/"+filename+".csv",'a')
testResultFile.write("folderName,numLayers, Overall Dice, precision , recall, extDice"+"\n")
counter=0
print "Loading the test slices"
for folder in os.listdir(test_path):
path = test_path + "/" + folder
layerDiceScores=''
data = extractTestSlices2(path,padding,neighbor=neighbor,inputs=inputs)
if data!=0:
[testLayers,testTruth,sliceShape,startSlice,endSlice] = data
# trueTestLayers=testLayers
GTest = [edges for x in testLayers]
testLayers = np.array( [x.reshape((sliceShape[0]*sliceShape[1],n_features)) for x in testLayers] )
testTruth = np.array( [x.reshape((sliceShape[0]*sliceShape[1],)).astype(int) for x in testTruth] )
asdfTest = zip(testLayers,GTest)
predTest = svm.predict(asdfTest)
LayerwiseDice=[]
for i in range(len(testLayers)):
diceScore = accuracy(predTest[i],testTruth[i])
layerDiceScores+=","+str(diceScore)
if math.isnan(diceScore):
if sum(predTest[i])==0 and sum(testTruth[i])==0:
LayerwiseDice.append(1.0)
continue
LayerwiseDice.append(diceScore)
LayerwiseDiceTotal.append(LayerwiseDice)
### Imputing the predicted pixels into full volume
if savePred==True:
finalPatientPred = np.zeros((240,240,150))
finalPatientTruth = np.zeros((240,240,150))
predInsert = np.dstack(tuple([x.reshape(180,180) for x in predTest]))
truthInsert = np.dstack(tuple([x.reshape(180,180) for x in testTruth]))
finalPatientPred[30:(240-30),30:(240-30),startSlice:endSlice] = predInsert
finalPatientTruth[30:(240-30),30:(240-30),startSlice:endSlice] = truthInsert
finalPatientPred = finalPatientPred.astype('int')
# print "saving at "+ path+"/"+filename+"whole"
np.save(path+"/"+folder+filename+"whole",finalPatientPred)
# print "predInsert shape"
# print predInsert.shape
# finalPatientPred = np.reshape(finalPatientPred,(240*240*150,)).astype('int')
# finalPatientTruth = np.reshape(finalPatientTruth,(240*240*150,)).astype('int')
#
# print "Counters"
# print Counter(list(np.hstack(testTruth)))
# print Counter(list(finalPatientTruth))
# print confusion_matrix(np.hstack(predTest),np.hstack(testTruth))
# print confusion_matrix(finalPatientPred,finalPatientTruth)
overallTestDice = accuracy(np.hstack(predTest),np.hstack(testTruth))
extDice = np.mean ( np.array(LayerwiseDice)[ range(10) + range(len(LayerwiseDice)-10, len(LayerwiseDice)) ] )
prec,recall,f1 = precision_score(np.hstack(testTruth),np.hstack(predTest)) , recall_score(np.hstack(testTruth),np.hstack(predTest)) , f1_score(np.hstack(testTruth),np.hstack(predTest))
print "Patient %d : Overall test DICE for %s is : %f and extDice is %f"%(counter,folder,overallTestDice,extDice)
print "Precision : %f Recall : %f F1 : %f " %(prec,recall,f1)
print "__________________________________________"
# testResultFile.write(folder+","+str(len(testLayers))+","+str(meanTestDice)+","+str(overallTestDice) ","+str(np.max(testDice)) +","+ str(np.min(testDice))+"\n" )
testResultFile.write(folder+","+str(len(testLayers)) + ","+ str(overallTestDice) + ","+str(prec)+","+str(recall)+","+str(extDice)+layerDiceScores+"\n" )
overallDicePerPatient.append(overallTestDice)
extDicePerPatient.append(extDice)
PREC.append(prec), RECALL.append(recall) , F1.append(f1)
PatientTruthLayers.append(testTruth)
PatientPredLayers.append(predTest)
counter+=1
if counter==num_test and num_test!=-1:
break
######################################################################################################
print "Done testing slices"
overallDice = sum(overallDicePerPatient)/len(PatientTruthLayers)
overallPrec = sum(PREC)/len(PatientTruthLayers)
overallRecall = sum(RECALL)/len(PatientTruthLayers)
overallExtDice = np.mean(extDicePer | padding=(30,30,30,30)
if directed==True:
features +="+directed"
resultsDir = os.getcwd()+'/CRFResults'
nameLen = len(os.listdir(resultsDir))
edgeFeature = edges
filename=str(nameLen)+"_CRF_iter_"+str(num_iter)+"_"+inference+"_"+trainer+"_"+features+"_"+str(num_train)+"_"+str(num_test)+"_"+edgeFeature
print "Loading training slices"
start = time.clock()
train =extractSlices2(train_path,num_train,padding,neighbor=neighbor,inputs=inputs)
end= time.clock()
train_load_time = (end-start)/60.0
| identifier_body |
BratsCRFNeighborWhole.py | Counter
from CRFUtils import *
from BratsCheckPredictions import *
import math
from math import *
train_path="/media/bmi/MyPassport/new_n4/Recon_2013_data/N4_zscore_training_t1_t1c_hist_match"
test_path="/media/bmi/MyPassport/new_n4/Recon_2013_data/N4_zscore_testing_t1_t1c_hist_match"
#train_path="/media/bmi/MyPassport/n4_entire/Recon_2013_data/training_longitudnal"
#test_path="/media/bmi/MyPassport/n4_entire/Recon_2013_data/testing_longitudnal"
#train_path="/home/rsk/Documents/PyStruct/data/train"
#test_path="/home/rsk/Documents/PyStruct/data/test"
#%%
#################################################################################################
#Training the model
def | (num_iter=5,inference="qpbo",trainer="NSlack",num_train=2,num_test=1,C=0.1,edges="180x180_dist1_diag0",inputs=[1,1,1,1,1,1],features="post+img+pred",neighbor=-1,directed=False,savePred=False):
padding=(30,30,30,30)
if directed==True:
features +="+directed"
resultsDir = os.getcwd()+'/CRFResults'
nameLen = len(os.listdir(resultsDir))
edgeFeature = edges
filename=str(nameLen)+"_CRF_iter_"+str(num_iter)+"_"+inference+"_"+trainer+"_"+features+"_"+str(num_train)+"_"+str(num_test)+"_"+edgeFeature
print "Loading training slices"
start = time.clock()
train =extractSlices2(train_path,num_train,padding,neighbor=neighbor,inputs=inputs)
end= time.clock()
train_load_time = (end-start)/60.0
[trainLayers,trainTruth,sliceShape] = train
print "Training slices loaded in %f" % (train_load_time)
n_features= len(trainLayers[0][0,0])
print "Layer shape is : "
print trainLayers[0].shape
print "Training the model"
edges= np.load("/home/bmi/CRF/edges/"+edges+".npy")
G = [edges for x in trainLayers]
print trainLayers[0].shape
trainLayers = np.array( [x.reshape((sliceShape[0]*sliceShape[1],n_features)) for x in trainLayers] )
trainTruth = np.array( [x.reshape((sliceShape[0]*sliceShape[1],)).astype(int) for x in trainTruth] )
if inference=='ogm':
crf = GraphCRF(inference_method=('ogm',{'alg':'fm'}),directed=directed)
else:
crf = GraphCRF(inference_method=inference,directed=directed)
if trainer=="Frank":
svm = FrankWolfeSSVM(model = crf,max_iter=num_iter,C=C,n_jobs=6,verbose=1)
elif trainer=="NSlack":
svm = NSlackSSVM(model = crf,max_iter=num_iter,C=C,n_jobs=-1,verbose=1)
else:
svm = OneSlackSSVM(model = crf,max_iter=num_iter,C=C,n_jobs=-1,verbose=1)
start = time.clock()
asdf = zip(trainLayers,G)
svm.fit(asdf,trainTruth)
end = time.clock()
train_time = (end-start)/60.0
print "The training took %f" % (train_time)
print "Model parameter size :"
print svm.w.shape
print "making predictions on train data"
predTrain = svm.predict(asdf)
trainDice=[]
for i in range(len(trainLayers)):
diceScore = accuracy(predTrain[i],trainTruth[i])
trainDice.append(diceScore)
meanTrainDice = sum(trainDice)/len(trainLayers)
del trainLayers,trainTruth
################################################################################################
overallDicePerPatient=[] # For overall test Dice
extDicePerPatient=[]
PatientTruthLayers=[]
PatientPredLayers=[]
PREC=[]
RECALL=[]
F1=[]
LayerwiseDiceTotal=[]
testResultFile = open(os.getcwd()+"/CRFResults/"+filename+".csv",'a')
testResultFile.write("folderName,numLayers, Overall Dice, precision , recall, extDice"+"\n")
counter=0
print "Loading the test slices"
for folder in os.listdir(test_path):
path = test_path + "/" + folder
layerDiceScores=''
data = extractTestSlices2(path,padding,neighbor=neighbor,inputs=inputs)
if data!=0:
[testLayers,testTruth,sliceShape,startSlice,endSlice] = data
# trueTestLayers=testLayers
GTest = [edges for x in testLayers]
testLayers = np.array( [x.reshape((sliceShape[0]*sliceShape[1],n_features)) for x in testLayers] )
testTruth = np.array( [x.reshape((sliceShape[0]*sliceShape[1],)).astype(int) for x in testTruth] )
asdfTest = zip(testLayers,GTest)
predTest = svm.predict(asdfTest)
LayerwiseDice=[]
for i in range(len(testLayers)):
diceScore = accuracy(predTest[i],testTruth[i])
layerDiceScores+=","+str(diceScore)
if math.isnan(diceScore):
if sum(predTest[i])==0 and sum(testTruth[i])==0:
LayerwiseDice.append(1.0)
continue
LayerwiseDice.append(diceScore)
LayerwiseDiceTotal.append(LayerwiseDice)
### Imputing the predicted pixels into full volume
if savePred==True:
finalPatientPred = np.zeros((240,240,150))
finalPatientTruth = np.zeros((240,240,150))
predInsert = np.dstack(tuple([x.reshape(180,180) for x in predTest]))
truthInsert = np.dstack(tuple([x.reshape(180,180) for x in testTruth]))
finalPatientPred[30:(240-30),30:(240-30),startSlice:endSlice] = predInsert
finalPatientTruth[30:(240-30),30:(240-30),startSlice:endSlice] = truthInsert
finalPatientPred = finalPatientPred.astype('int')
# print "saving at "+ path+"/"+filename+"whole"
np.save(path+"/"+folder+filename+"whole",finalPatientPred)
# print "predInsert shape"
# print predInsert.shape
# finalPatientPred = np.reshape(finalPatientPred,(240*240*150,)).astype('int')
# finalPatientTruth = np.reshape(finalPatientTruth,(240*240*150,)).astype('int')
#
# print "Counters"
# print Counter(list(np.hstack(testTruth)))
# print Counter(list(finalPatientTruth))
# print confusion_matrix(np.hstack(predTest),np.hstack(testTruth))
# print confusion_matrix(finalPatientPred,finalPatientTruth)
overallTestDice = accuracy(np.hstack(predTest),np.hstack(testTruth))
extDice = np.mean ( np.array(LayerwiseDice)[ range(10) + range(len(LayerwiseDice)-10, len(LayerwiseDice)) ] )
prec,recall,f1 = precision_score(np.hstack(testTruth),np.hstack(predTest)) , recall_score(np.hstack(testTruth),np.hstack(predTest)) , f1_score(np.hstack(testTruth),np.hstack(predTest))
print "Patient %d : Overall test DICE for %s is : %f and extDice is %f"%(counter,folder,overallTestDice,extDice)
print "Precision : %f Recall : %f F1 : %f " %(prec,recall,f1)
print "__________________________________________"
# testResultFile.write(folder+","+str(len(testLayers))+","+str(meanTestDice)+","+str(overallTestDice) ","+str(np.max(testDice)) +","+ str(np.min(testDice))+"\n" )
testResultFile.write(folder+","+str(len(testLayers)) + ","+ str(overallTestDice) + ","+str(prec)+","+str(recall)+","+str(extDice)+layerDiceScores+"\n" )
overallDicePerPatient.append(overallTestDice)
extDicePerPatient.append(extDice)
PREC.append(prec), RECALL.append(recall) , F1.append(f1)
PatientTruthLayers.append(testTruth)
PatientPredLayers.append(predTest)
counter+=1
if counter==num_test and num_test!=-1:
break
######################################################################################################
print "Done testing slices"
overallDice = sum(overallDicePerPatient)/len(PatientTruthLayers)
overallPrec = sum(PREC)/len(PatientTruthLayers)
overallRecall = sum(RECALL)/len(PatientTruthLayers)
overallExtDice = np.mean(extDicePer | trainModel_Neighbor | identifier_name |
BratsCRFNeighborWhole.py | Counter
from CRFUtils import *
from BratsCheckPredictions import *
import math
from math import *
train_path="/media/bmi/MyPassport/new_n4/Recon_2013_data/N4_zscore_training_t1_t1c_hist_match"
test_path="/media/bmi/MyPassport/new_n4/Recon_2013_data/N4_zscore_testing_t1_t1c_hist_match"
#train_path="/media/bmi/MyPassport/n4_entire/Recon_2013_data/training_longitudnal"
#test_path="/media/bmi/MyPassport/n4_entire/Recon_2013_data/testing_longitudnal"
#train_path="/home/rsk/Documents/PyStruct/data/train"
#test_path="/home/rsk/Documents/PyStruct/data/test"
#%%
#################################################################################################
#Training the model
def trainModel_Neighbor(num_iter=5,inference="qpbo",trainer="NSlack",num_train=2,num_test=1,C=0.1,edges="180x180_dist1_diag0",inputs=[1,1,1,1,1,1],features="post+img+pred",neighbor=-1,directed=False,savePred=False):
padding=(30,30,30,30)
if directed==True:
features +="+directed"
resultsDir = os.getcwd()+'/CRFResults'
nameLen = len(os.listdir(resultsDir))
edgeFeature = edges
filename=str(nameLen)+"_CRF_iter_"+str(num_iter)+"_"+inference+"_"+trainer+"_"+features+"_"+str(num_train)+"_"+str(num_test)+"_"+edgeFeature
print "Loading training slices"
start = time.clock()
train =extractSlices2(train_path,num_train,padding,neighbor=neighbor,inputs=inputs)
end= time.clock()
train_load_time = (end-start)/60.0
[trainLayers,trainTruth,sliceShape] = train
print "Training slices loaded in %f" % (train_load_time)
n_features= len(trainLayers[0][0,0])
print "Layer shape is : "
print trainLayers[0].shape
print "Training the model"
edges= np.load("/home/bmi/CRF/edges/"+edges+".npy")
G = [edges for x in trainLayers]
print trainLayers[0].shape
trainLayers = np.array( [x.reshape((sliceShape[0]*sliceShape[1],n_features)) for x in trainLayers] )
trainTruth = np.array( [x.reshape((sliceShape[0]*sliceShape[1],)).astype(int) for x in trainTruth] )
if inference=='ogm':
crf = GraphCRF(inference_method=('ogm',{'alg':'fm'}),directed=directed)
else:
|
if trainer=="Frank":
svm = FrankWolfeSSVM(model = crf,max_iter=num_iter,C=C,n_jobs=6,verbose=1)
elif trainer=="NSlack":
svm = NSlackSSVM(model = crf,max_iter=num_iter,C=C,n_jobs=-1,verbose=1)
else:
svm = OneSlackSSVM(model = crf,max_iter=num_iter,C=C,n_jobs=-1,verbose=1)
start = time.clock()
asdf = zip(trainLayers,G)
svm.fit(asdf,trainTruth)
end = time.clock()
train_time = (end-start)/60.0
print "The training took %f" % (train_time)
print "Model parameter size :"
print svm.w.shape
print "making predictions on train data"
predTrain = svm.predict(asdf)
trainDice=[]
for i in range(len(trainLayers)):
diceScore = accuracy(predTrain[i],trainTruth[i])
trainDice.append(diceScore)
meanTrainDice = sum(trainDice)/len(trainLayers)
del trainLayers,trainTruth
################################################################################################
overallDicePerPatient=[] # For overall test Dice
extDicePerPatient=[]
PatientTruthLayers=[]
PatientPredLayers=[]
PREC=[]
RECALL=[]
F1=[]
LayerwiseDiceTotal=[]
testResultFile = open(os.getcwd()+"/CRFResults/"+filename+".csv",'a')
testResultFile.write("folderName,numLayers, Overall Dice, precision , recall, extDice"+"\n")
counter=0
print "Loading the test slices"
for folder in os.listdir(test_path):
path = test_path + "/" + folder
layerDiceScores=''
data = extractTestSlices2(path,padding,neighbor=neighbor,inputs=inputs)
if data!=0:
[testLayers,testTruth,sliceShape,startSlice,endSlice] = data
# trueTestLayers=testLayers
GTest = [edges for x in testLayers]
testLayers = np.array( [x.reshape((sliceShape[0]*sliceShape[1],n_features)) for x in testLayers] )
testTruth = np.array( [x.reshape((sliceShape[0]*sliceShape[1],)).astype(int) for x in testTruth] )
asdfTest = zip(testLayers,GTest)
predTest = svm.predict(asdfTest)
LayerwiseDice=[]
for i in range(len(testLayers)):
diceScore = accuracy(predTest[i],testTruth[i])
layerDiceScores+=","+str(diceScore)
if math.isnan(diceScore):
if sum(predTest[i])==0 and sum(testTruth[i])==0:
LayerwiseDice.append(1.0)
continue
LayerwiseDice.append(diceScore)
LayerwiseDiceTotal.append(LayerwiseDice)
### Imputing the predicted pixels into full volume
if savePred==True:
finalPatientPred = np.zeros((240,240,150))
finalPatientTruth = np.zeros((240,240,150))
predInsert = np.dstack(tuple([x.reshape(180,180) for x in predTest]))
truthInsert = np.dstack(tuple([x.reshape(180,180) for x in testTruth]))
finalPatientPred[30:(240-30),30:(240-30),startSlice:endSlice] = predInsert
finalPatientTruth[30:(240-30),30:(240-30),startSlice:endSlice] = truthInsert
finalPatientPred = finalPatientPred.astype('int')
# print "saving at "+ path+"/"+filename+"whole"
np.save(path+"/"+folder+filename+"whole",finalPatientPred)
# print "predInsert shape"
# print predInsert.shape
# finalPatientPred = np.reshape(finalPatientPred,(240*240*150,)).astype('int')
# finalPatientTruth = np.reshape(finalPatientTruth,(240*240*150,)).astype('int')
#
# print "Counters"
# print Counter(list(np.hstack(testTruth)))
# print Counter(list(finalPatientTruth))
# print confusion_matrix(np.hstack(predTest),np.hstack(testTruth))
# print confusion_matrix(finalPatientPred,finalPatientTruth)
overallTestDice = accuracy(np.hstack(predTest),np.hstack(testTruth))
extDice = np.mean ( np.array(LayerwiseDice)[ range(10) + range(len(LayerwiseDice)-10, len(LayerwiseDice)) ] )
prec,recall,f1 = precision_score(np.hstack(testTruth),np.hstack(predTest)) , recall_score(np.hstack(testTruth),np.hstack(predTest)) , f1_score(np.hstack(testTruth),np.hstack(predTest))
print "Patient %d : Overall test DICE for %s is : %f and extDice is %f"%(counter,folder,overallTestDice,extDice)
print "Precision : %f Recall : %f F1 : %f " %(prec,recall,f1)
print "__________________________________________"
# testResultFile.write(folder+","+str(len(testLayers))+","+str(meanTestDice)+","+str(overallTestDice) ","+str(np.max(testDice)) +","+ str(np.min(testDice))+"\n" )
testResultFile.write(folder+","+str(len(testLayers)) + ","+ str(overallTestDice) + ","+str(prec)+","+str(recall)+","+str(extDice)+layerDiceScores+"\n" )
overallDicePerPatient.append(overallTestDice)
extDicePerPatient.append(extDice)
PREC.append(prec), RECALL.append(recall) , F1.append(f1)
PatientTruthLayers.append(testTruth)
PatientPredLayers.append(predTest)
counter+=1
if counter==num_test and num_test!=-1:
break
######################################################################################################
print "Done testing slices"
overallDice = sum(overallDicePerPatient)/len(PatientTruthLayers)
overallPrec = sum(PREC)/len(PatientTruthLayers)
overallRecall = sum(RECALL)/len(PatientTruthLayers)
overallExtDice = np.mean(extDicePerPatient | crf = GraphCRF(inference_method=inference,directed=directed) | conditional_block |
playlist.py | .get('placement_filter')
## audio settings ##
# true if content responds to audio input
self.sound_reactive = kwargs.get('sound_reactive', False)
# if sound_reactive, false if content can still be shown without audio input available
self.sound_required = kwargs.get('sound_required', True)
# relative volume adjustment for audio input (to give more/less responsiveness)
self.volume_adjust = kwargs.get('volume_adjust', 1.)
# true if sketch has audio out (that we actually want to hear)
self.has_audio = kwargs.get('has_audio', False)
# true if content can use kinect
self.kinect_enabled = kwargs.get('kinect_enabled', False)
# if kinect_enabled, false if content still works without connect
self.kinect_required = kwargs.get('kinect_required', True)
self.server_side_parameters = kwargs.get('server_side_parameters', [])
## sketch-dependent parameters ##
# video
# length of video in seconds -- set automatically
self.duration = self.get_video_duration()
# how to play the video:
# - 'shuffle': play a random excerpt for the specific runtime
# - 'full': play the video start to finish
self.play_mode = kwargs.get('play_mode', 'shuffle')
# screencast
# command to launch program to be cast
self.cmdline = kwargs.get('cmdline')
# a hook to further configure/interact with the program after it's launched
self.post_launch = kwargs.get('post_launch')
if set(kwargs.keys()) - set(self.__dict__):
assert False, 'unrecognized arg'
def get_video_duration(self):
if not self.sketch == 'video':
return
vid = self.params['path']
try:
duration = float(os.popen('mediainfo --Inform="Video;%%Duration%%" "%s"' % vid).readlines()[0].strip())/1000.
except RuntimeError:
print 'could not read duration of %s' % vid
duration = 0
return duration
def to_json_info(self):
info = dict((k, getattr(self, k)) for k in ('name', 'sound_reactive', 'has_audio', 'kinect_enabled'))
if self.play_mode == 'full':
info['duration'] = self.duration
return info
# placement filter that ensures crisp alignment with lsdome panel/pixel geometry
def pixel_exact(p):
# forcing zero-rotation is sufficient for lsdome, and achieves the same spirit for prometheus (which
# doesn't have a concept of 'pixel exact') while still allowing for some variation in wing overlap
return getattr(p, 'rot', 0) == 0 and p.is_1to1
# like pixel_exact, but stretch to fit full canvas (so not 'exact', but still 'aligned')
def align_but_stretch(p):
return getattr(p, 'rot', 0) == 0 and p.stretch
_all_content = None
def all_content():
global _all_content
if not _all_content:
_all_content = [
Content('black', '[util] black (note: keeps running and using cpu)', manual=True),
Content('gridtest', '[util] uvw grid test', geometries=['lsdome'], manual=True),
Content('fctest', '[util] fc topology test', params={'fcconfig': fadecandy_config()}),
Content('layouttest', '[util] cartesian test (mouse)', manual=True, placement_filter=pixel_exact),
Content('binary', '[util] binary decomp', manual=True),
Content('cloud'),
Content('dontknow'),
Content('harmonics', geometries=['lsdome']),
Content('moire'),
Content('rings'),
Content('tube'),
Content('twinkle'),
Content('fft', sound_reactive=True),
Content('pixelflock', sound_reactive=True, sound_required=False, kinect_enabled=True, kinect_required=False),
Content('kinectdepth', 'kinectdepth', kinect_enabled=True,
placement_filter=align_but_stretch),
Content('screencast', 'projectm', cmdline='projectM-pulseaudio', sound_reactive=True, volume_adjust=1.5,
server_side_parameters=projectm_parameters(),
post_launch=lambda manager: projectm_control(manager, 'next'), # get off the default pattern
),
Content('stream', 'hdmi-in', manual=True, stretch_aspect=True, params={
'camera': 'FHD Capture: FHD Capture',
}),
Content('kaleidoscope', geometries=['lsdome'], placement_filter=pixel_exact, params={'scale': 2.}),
Content('kaleidoscope', geometries=['prometheus'], params={'scale': 3.2}),
Content('imgkaleidoscope', 'hearts', geometries=['lsdome'], placement_filter=pixel_exact, params={
'image': "res/img/hearts.jpg",
'scale': 1.,
'source_scale': 1.3,
'speed': .25,
}),
Content('video', 'video:chrissy_poi_zoom', geometries=['lsdome'], params={
'path': os.path.join(VIDEO_DIR, 'hayley_chrissy_fire_spinning.mp4'),
}, placement_filter=lambda p: p.name == 'poi (01-10 21:44)'),
]
_all_content.extend(load_videos())
_all_content = [c for c in _all_content if not c.geometries or settings.geometry in c.geometries]
_all_content = [c for c in _all_content if not (c.kinect_enabled and c.kinect_required) or settings.kinect]
for c in _all_content:
if c.kinect_enabled and settings.kinect and not c.placement_filter:
# when kinect used, ensure display lines up with camera
c.placement_filter = pixel_exact
assert len(set(c.name for c in _all_content)) == len(_all_content), 'content names not unique'
_all_content = dict((c.name, c) for c in _all_content)
return _all_content
def load_videos():
vids = [f.strip() for f in os.popen('find "%s" -type f' % VIDEO_DIR).readlines()]
for vid in vids:
# TODO placement restrictions? joan of arc require mirror mode?
# do special things for certain videos -- should probably make this more maintainable
args = {}
if 'knife' in vid:
args['play_mode'] = 'full'
if any(k in vid for k in ('knife', 'flood')):
args['has_audio'] = True
yield Content('video', 'video:%s' % os.path.relpath(vid, VIDEO_DIR), stretch_aspect=True, params={
'path': vid,
}, **args)
def fadecandy_config():
if settings.geometry == 'lsdome':
fcconfig = 'lsdome_%spanel.json' % settings.num_panels
elif settings.geometry == 'prometheus':
fcconfig = 'prometheus_wing.json'
return os.path.join(settings.repo_root, 'src/config/fadecandy', fcconfig)
def projectm_control(mgr, command):
interaction = {
'next': 'key r',
'toggle-lock': 'key l',
}[command]
launch.gui_interaction(mgr.content.window_id, interaction)
def projectm_parameters():
|
def game_content(rom):
try:
args = launch.launch_emulator(rom)
except:
return None
name = os.path.splitext(os.path.relpath(os.path.abspath(rom), settings.roms_path))[0]
return Content('screencast', name, cmdline=args['cmd'], params=args.get('params', {}), stretch_aspect=True, has_audio=True)
_games_content = None
def load_games(filt):
def all_roms_path_files():
for dirpath, _, filenames in os.walk(settings.roms_path):
for f in filenames:
yield os.path.join(dirpath, f)
global _games_content
if not _games_content:
_games_content = filter(None, map(game_content, all_roms_path_files()))
_games_content = dict((c.name, c) for c in _games_content)
print len(_games_content), 'roms'
if filt == 'favs':
return filter_games_favorites(_games_content)
else:
return filter_games(_games_content, filt)
def filter_games(all_games, filt):
def name_to_search_key(name):
name = os.path.split(name)[1]
name = name.split('(')[0]
words = name.lower().split()
words = [re.sub('[^a-z0-9]', '', w) for w in words]
return filter(None, words)
def match_key(query, key):
return all(any(kw.startswith(qw) for | import animations
class ProjectMNextPatternAction(animations.Parameter):
def param_def(self):
return {
'name': 'next pattern',
'isAction': True,
}
def handle_input_event(self, type, val):
if type != 'press':
return
projectm_control(self.manager, 'next')
def _update_value(self, val):
pass
return [ProjectMNextPatternAction] | identifier_body |
playlist.py | .get('placement_filter')
## audio settings ##
# true if content responds to audio input
self.sound_reactive = kwargs.get('sound_reactive', False)
# if sound_reactive, false if content can still be shown without audio input available
self.sound_required = kwargs.get('sound_required', True)
# relative volume adjustment for audio input (to give more/less responsiveness)
self.volume_adjust = kwargs.get('volume_adjust', 1.)
# true if sketch has audio out (that we actually want to hear)
self.has_audio = kwargs.get('has_audio', False)
# true if content can use kinect
self.kinect_enabled = kwargs.get('kinect_enabled', False)
# if kinect_enabled, false if content still works without connect
self.kinect_required = kwargs.get('kinect_required', True)
self.server_side_parameters = kwargs.get('server_side_parameters', [])
## sketch-dependent parameters ##
# video
# length of video in seconds -- set automatically
self.duration = self.get_video_duration()
# how to play the video:
# - 'shuffle': play a random excerpt for the specific runtime
# - 'full': play the video start to finish
self.play_mode = kwargs.get('play_mode', 'shuffle')
# screencast
# command to launch program to be cast
self.cmdline = kwargs.get('cmdline')
# a hook to further configure/interact with the program after it's launched
self.post_launch = kwargs.get('post_launch')
if set(kwargs.keys()) - set(self.__dict__):
assert False, 'unrecognized arg'
def get_video_duration(self):
if not self.sketch == 'video':
return
vid = self.params['path']
try:
duration = float(os.popen('mediainfo --Inform="Video;%%Duration%%" "%s"' % vid).readlines()[0].strip())/1000.
except RuntimeError:
print 'could not read duration of %s' % vid
duration = 0
return duration
def to_json_info(self):
info = dict((k, getattr(self, k)) for k in ('name', 'sound_reactive', 'has_audio', 'kinect_enabled'))
if self.play_mode == 'full':
info['duration'] = self.duration
return info
# placement filter that ensures crisp alignment with lsdome panel/pixel geometry
def pixel_exact(p):
# forcing zero-rotation is sufficient for lsdome, and achieves the same spirit for prometheus (which
# doesn't have a concept of 'pixel exact') while still allowing for some variation in wing overlap
return getattr(p, 'rot', 0) == 0 and p.is_1to1
# like pixel_exact, but stretch to fit full canvas (so not 'exact', but still 'aligned')
def align_but_stretch(p):
return getattr(p, 'rot', 0) == 0 and p.stretch
_all_content = None
def all_content():
global _all_content
if not _all_content:
_all_content = [
Content('black', '[util] black (note: keeps running and using cpu)', manual=True),
Content('gridtest', '[util] uvw grid test', geometries=['lsdome'], manual=True),
Content('fctest', '[util] fc topology test', params={'fcconfig': fadecandy_config()}),
Content('layouttest', '[util] cartesian test (mouse)', manual=True, placement_filter=pixel_exact),
Content('binary', '[util] binary decomp', manual=True),
Content('cloud'),
Content('dontknow'),
Content('harmonics', geometries=['lsdome']),
Content('moire'),
Content('rings'),
Content('tube'),
Content('twinkle'),
Content('fft', sound_reactive=True),
Content('pixelflock', sound_reactive=True, sound_required=False, kinect_enabled=True, kinect_required=False),
Content('kinectdepth', 'kinectdepth', kinect_enabled=True,
placement_filter=align_but_stretch),
Content('screencast', 'projectm', cmdline='projectM-pulseaudio', sound_reactive=True, volume_adjust=1.5,
server_side_parameters=projectm_parameters(),
post_launch=lambda manager: projectm_control(manager, 'next'), # get off the default pattern
), | Content('kaleidoscope', geometries=['lsdome'], placement_filter=pixel_exact, params={'scale': 2.}),
Content('kaleidoscope', geometries=['prometheus'], params={'scale': 3.2}),
Content('imgkaleidoscope', 'hearts', geometries=['lsdome'], placement_filter=pixel_exact, params={
'image': "res/img/hearts.jpg",
'scale': 1.,
'source_scale': 1.3,
'speed': .25,
}),
Content('video', 'video:chrissy_poi_zoom', geometries=['lsdome'], params={
'path': os.path.join(VIDEO_DIR, 'hayley_chrissy_fire_spinning.mp4'),
}, placement_filter=lambda p: p.name == 'poi (01-10 21:44)'),
]
_all_content.extend(load_videos())
_all_content = [c for c in _all_content if not c.geometries or settings.geometry in c.geometries]
_all_content = [c for c in _all_content if not (c.kinect_enabled and c.kinect_required) or settings.kinect]
for c in _all_content:
if c.kinect_enabled and settings.kinect and not c.placement_filter:
# when kinect used, ensure display lines up with camera
c.placement_filter = pixel_exact
assert len(set(c.name for c in _all_content)) == len(_all_content), 'content names not unique'
_all_content = dict((c.name, c) for c in _all_content)
return _all_content
def load_videos():
vids = [f.strip() for f in os.popen('find "%s" -type f' % VIDEO_DIR).readlines()]
for vid in vids:
# TODO placement restrictions? joan of arc require mirror mode?
# do special things for certain videos -- should probably make this more maintainable
args = {}
if 'knife' in vid:
args['play_mode'] = 'full'
if any(k in vid for k in ('knife', 'flood')):
args['has_audio'] = True
yield Content('video', 'video:%s' % os.path.relpath(vid, VIDEO_DIR), stretch_aspect=True, params={
'path': vid,
}, **args)
def fadecandy_config():
if settings.geometry == 'lsdome':
fcconfig = 'lsdome_%spanel.json' % settings.num_panels
elif settings.geometry == 'prometheus':
fcconfig = 'prometheus_wing.json'
return os.path.join(settings.repo_root, 'src/config/fadecandy', fcconfig)
def projectm_control(mgr, command):
interaction = {
'next': 'key r',
'toggle-lock': 'key l',
}[command]
launch.gui_interaction(mgr.content.window_id, interaction)
def projectm_parameters():
import animations
class ProjectMNextPatternAction(animations.Parameter):
def param_def(self):
return {
'name': 'next pattern',
'isAction': True,
}
def handle_input_event(self, type, val):
if type != 'press':
return
projectm_control(self.manager, 'next')
def _update_value(self, val):
pass
return [ProjectMNextPatternAction]
def game_content(rom):
try:
args = launch.launch_emulator(rom)
except:
return None
name = os.path.splitext(os.path.relpath(os.path.abspath(rom), settings.roms_path))[0]
return Content('screencast', name, cmdline=args['cmd'], params=args.get('params', {}), stretch_aspect=True, has_audio=True)
_games_content = None
def load_games(filt):
def all_roms_path_files():
for dirpath, _, filenames in os.walk(settings.roms_path):
for f in filenames:
yield os.path.join(dirpath, f)
global _games_content
if not _games_content:
_games_content = filter(None, map(game_content, all_roms_path_files()))
_games_content = dict((c.name, c) for c in _games_content)
print len(_games_content), 'roms'
if filt == 'favs':
return filter_games_favorites(_games_content)
else:
return filter_games(_games_content, filt)
def filter_games(all_games, filt):
def name_to_search_key(name):
name = os.path.split(name)[1]
name = name.split('(')[0]
words = name.lower().split()
words = [re.sub('[^a-z0-9]', '', w) for w in words]
return filter(None, words)
def match_key(query, key):
return all(any(kw.startswith(qw) for kw | Content('stream', 'hdmi-in', manual=True, stretch_aspect=True, params={
'camera': 'FHD Capture: FHD Capture',
}),
| random_line_split |
playlist.py | kwargs.get('placement_filter')
## audio settings ##
# true if content responds to audio input
self.sound_reactive = kwargs.get('sound_reactive', False)
# if sound_reactive, false if content can still be shown without audio input available
self.sound_required = kwargs.get('sound_required', True)
# relative volume adjustment for audio input (to give more/less responsiveness)
self.volume_adjust = kwargs.get('volume_adjust', 1.)
# true if sketch has audio out (that we actually want to hear)
self.has_audio = kwargs.get('has_audio', False)
# true if content can use kinect
self.kinect_enabled = kwargs.get('kinect_enabled', False)
# if kinect_enabled, false if content still works without connect
self.kinect_required = kwargs.get('kinect_required', True)
self.server_side_parameters = kwargs.get('server_side_parameters', [])
## sketch-dependent parameters ##
# video
# length of video in seconds -- set automatically
self.duration = self.get_video_duration()
# how to play the video:
# - 'shuffle': play a random excerpt for the specific runtime
# - 'full': play the video start to finish
self.play_mode = kwargs.get('play_mode', 'shuffle')
# screencast
# command to launch program to be cast
self.cmdline = kwargs.get('cmdline')
# a hook to further configure/interact with the program after it's launched
self.post_launch = kwargs.get('post_launch')
if set(kwargs.keys()) - set(self.__dict__):
assert False, 'unrecognized arg'
def get_video_duration(self):
if not self.sketch == 'video':
return
vid = self.params['path']
try:
duration = float(os.popen('mediainfo --Inform="Video;%%Duration%%" "%s"' % vid).readlines()[0].strip())/1000.
except RuntimeError:
print 'could not read duration of %s' % vid
duration = 0
return duration
def to_json_info(self):
info = dict((k, getattr(self, k)) for k in ('name', 'sound_reactive', 'has_audio', 'kinect_enabled'))
if self.play_mode == 'full':
info['duration'] = self.duration
return info
# placement filter that ensures crisp alignment with lsdome panel/pixel geometry
def pixel_exact(p):
# forcing zero-rotation is sufficient for lsdome, and achieves the same spirit for prometheus (which
# doesn't have a concept of 'pixel exact') while still allowing for some variation in wing overlap
return getattr(p, 'rot', 0) == 0 and p.is_1to1
# like pixel_exact, but stretch to fit full canvas (so not 'exact', but still 'aligned')
def align_but_stretch(p):
return getattr(p, 'rot', 0) == 0 and p.stretch
_all_content = None
def all_content():
global _all_content
if not _all_content:
| ),
Content('stream', 'hdmi-in', manual=True, stretch_aspect=True, params={
'camera': 'FHD Capture: FHD Capture',
}),
Content('kaleidoscope', geometries=['lsdome'], placement_filter=pixel_exact, params={'scale': 2.}),
Content('kaleidoscope', geometries=['prometheus'], params={'scale': 3.2}),
Content('imgkaleidoscope', 'hearts', geometries=['lsdome'], placement_filter=pixel_exact, params={
'image': "res/img/hearts.jpg",
'scale': 1.,
'source_scale': 1.3,
'speed': .25,
}),
Content('video', 'video:chrissy_poi_zoom', geometries=['lsdome'], params={
'path': os.path.join(VIDEO_DIR, 'hayley_chrissy_fire_spinning.mp4'),
}, placement_filter=lambda p: p.name == 'poi (01-10 21:44)'),
]
_all_content.extend(load_videos())
_all_content = [c for c in _all_content if not c.geometries or settings.geometry in c.geometries]
_all_content = [c for c in _all_content if not (c.kinect_enabled and c.kinect_required) or settings.kinect]
for c in _all_content:
if c.kinect_enabled and settings.kinect and not c.placement_filter:
# when kinect used, ensure display lines up with camera
c.placement_filter = pixel_exact
assert len(set(c.name for c in _all_content)) == len(_all_content), 'content names not unique'
_all_content = dict((c.name, c) for c in _all_content)
return _all_content
def load_videos():
vids = [f.strip() for f in os.popen('find "%s" -type f' % VIDEO_DIR).readlines()]
for vid in vids:
# TODO placement restrictions? joan of arc require mirror mode?
# do special things for certain videos -- should probably make this more maintainable
args = {}
if 'knife' in vid:
args['play_mode'] = 'full'
if any(k in vid for k in ('knife', 'flood')):
args['has_audio'] = True
yield Content('video', 'video:%s' % os.path.relpath(vid, VIDEO_DIR), stretch_aspect=True, params={
'path': vid,
}, **args)
def fadecandy_config():
if settings.geometry == 'lsdome':
fcconfig = 'lsdome_%spanel.json' % settings.num_panels
elif settings.geometry == 'prometheus':
fcconfig = 'prometheus_wing.json'
return os.path.join(settings.repo_root, 'src/config/fadecandy', fcconfig)
def projectm_control(mgr, command):
interaction = {
'next': 'key r',
'toggle-lock': 'key l',
}[command]
launch.gui_interaction(mgr.content.window_id, interaction)
def projectm_parameters():
import animations
class ProjectMNextPatternAction(animations.Parameter):
def param_def(self):
return {
'name': 'next pattern',
'isAction': True,
}
def handle_input_event(self, type, val):
if type != 'press':
return
projectm_control(self.manager, 'next')
def _update_value(self, val):
pass
return [ProjectMNextPatternAction]
def game_content(rom):
try:
args = launch.launch_emulator(rom)
except:
return None
name = os.path.splitext(os.path.relpath(os.path.abspath(rom), settings.roms_path))[0]
return Content('screencast', name, cmdline=args['cmd'], params=args.get('params', {}), stretch_aspect=True, has_audio=True)
_games_content = None
def load_games(filt):
def all_roms_path_files():
for dirpath, _, filenames in os.walk(settings.roms_path):
for f in filenames:
yield os.path.join(dirpath, f)
global _games_content
if not _games_content:
_games_content = filter(None, map(game_content, all_roms_path_files()))
_games_content = dict((c.name, c) for c in _games_content)
print len(_games_content), 'roms'
if filt == 'favs':
return filter_games_favorites(_games_content)
else:
return filter_games(_games_content, filt)
def filter_games(all_games, filt):
def name_to_search_key(name):
name = os.path.split(name)[1]
name = name.split('(')[0]
words = name.lower().split()
words = [re.sub('[^a-z0-9]', '', w) for w in words]
return filter(None, words)
def match_key(query, key):
return all(any(kw.startswith(qw) for kw in | _all_content = [
Content('black', '[util] black (note: keeps running and using cpu)', manual=True),
Content('gridtest', '[util] uvw grid test', geometries=['lsdome'], manual=True),
Content('fctest', '[util] fc topology test', params={'fcconfig': fadecandy_config()}),
Content('layouttest', '[util] cartesian test (mouse)', manual=True, placement_filter=pixel_exact),
Content('binary', '[util] binary decomp', manual=True),
Content('cloud'),
Content('dontknow'),
Content('harmonics', geometries=['lsdome']),
Content('moire'),
Content('rings'),
Content('tube'),
Content('twinkle'),
Content('fft', sound_reactive=True),
Content('pixelflock', sound_reactive=True, sound_required=False, kinect_enabled=True, kinect_required=False),
Content('kinectdepth', 'kinectdepth', kinect_enabled=True,
placement_filter=align_but_stretch),
Content('screencast', 'projectm', cmdline='projectM-pulseaudio', sound_reactive=True, volume_adjust=1.5,
server_side_parameters=projectm_parameters(),
post_launch=lambda manager: projectm_control(manager, 'next'), # get off the default pattern | conditional_block |
playlist.py | sdome, and achieves the same spirit for prometheus (which
# doesn't have a concept of 'pixel exact') while still allowing for some variation in wing overlap
return getattr(p, 'rot', 0) == 0 and p.is_1to1
# like pixel_exact, but stretch to fit full canvas (so not 'exact', but still 'aligned')
def align_but_stretch(p):
return getattr(p, 'rot', 0) == 0 and p.stretch
_all_content = None
def all_content():
global _all_content
if not _all_content:
_all_content = [
Content('black', '[util] black (note: keeps running and using cpu)', manual=True),
Content('gridtest', '[util] uvw grid test', geometries=['lsdome'], manual=True),
Content('fctest', '[util] fc topology test', params={'fcconfig': fadecandy_config()}),
Content('layouttest', '[util] cartesian test (mouse)', manual=True, placement_filter=pixel_exact),
Content('binary', '[util] binary decomp', manual=True),
Content('cloud'),
Content('dontknow'),
Content('harmonics', geometries=['lsdome']),
Content('moire'),
Content('rings'),
Content('tube'),
Content('twinkle'),
Content('fft', sound_reactive=True),
Content('pixelflock', sound_reactive=True, sound_required=False, kinect_enabled=True, kinect_required=False),
Content('kinectdepth', 'kinectdepth', kinect_enabled=True,
placement_filter=align_but_stretch),
Content('screencast', 'projectm', cmdline='projectM-pulseaudio', sound_reactive=True, volume_adjust=1.5,
server_side_parameters=projectm_parameters(),
post_launch=lambda manager: projectm_control(manager, 'next'), # get off the default pattern
),
Content('stream', 'hdmi-in', manual=True, stretch_aspect=True, params={
'camera': 'FHD Capture: FHD Capture',
}),
Content('kaleidoscope', geometries=['lsdome'], placement_filter=pixel_exact, params={'scale': 2.}),
Content('kaleidoscope', geometries=['prometheus'], params={'scale': 3.2}),
Content('imgkaleidoscope', 'hearts', geometries=['lsdome'], placement_filter=pixel_exact, params={
'image': "res/img/hearts.jpg",
'scale': 1.,
'source_scale': 1.3,
'speed': .25,
}),
Content('video', 'video:chrissy_poi_zoom', geometries=['lsdome'], params={
'path': os.path.join(VIDEO_DIR, 'hayley_chrissy_fire_spinning.mp4'),
}, placement_filter=lambda p: p.name == 'poi (01-10 21:44)'),
]
_all_content.extend(load_videos())
_all_content = [c for c in _all_content if not c.geometries or settings.geometry in c.geometries]
_all_content = [c for c in _all_content if not (c.kinect_enabled and c.kinect_required) or settings.kinect]
for c in _all_content:
if c.kinect_enabled and settings.kinect and not c.placement_filter:
# when kinect used, ensure display lines up with camera
c.placement_filter = pixel_exact
assert len(set(c.name for c in _all_content)) == len(_all_content), 'content names not unique'
_all_content = dict((c.name, c) for c in _all_content)
return _all_content
def load_videos():
vids = [f.strip() for f in os.popen('find "%s" -type f' % VIDEO_DIR).readlines()]
for vid in vids:
# TODO placement restrictions? joan of arc require mirror mode?
# do special things for certain videos -- should probably make this more maintainable
args = {}
if 'knife' in vid:
args['play_mode'] = 'full'
if any(k in vid for k in ('knife', 'flood')):
args['has_audio'] = True
yield Content('video', 'video:%s' % os.path.relpath(vid, VIDEO_DIR), stretch_aspect=True, params={
'path': vid,
}, **args)
def fadecandy_config():
if settings.geometry == 'lsdome':
fcconfig = 'lsdome_%spanel.json' % settings.num_panels
elif settings.geometry == 'prometheus':
fcconfig = 'prometheus_wing.json'
return os.path.join(settings.repo_root, 'src/config/fadecandy', fcconfig)
def projectm_control(mgr, command):
interaction = {
'next': 'key r',
'toggle-lock': 'key l',
}[command]
launch.gui_interaction(mgr.content.window_id, interaction)
def projectm_parameters():
import animations
class ProjectMNextPatternAction(animations.Parameter):
def param_def(self):
return {
'name': 'next pattern',
'isAction': True,
}
def handle_input_event(self, type, val):
if type != 'press':
return
projectm_control(self.manager, 'next')
def _update_value(self, val):
pass
return [ProjectMNextPatternAction]
def game_content(rom):
try:
args = launch.launch_emulator(rom)
except:
return None
name = os.path.splitext(os.path.relpath(os.path.abspath(rom), settings.roms_path))[0]
return Content('screencast', name, cmdline=args['cmd'], params=args.get('params', {}), stretch_aspect=True, has_audio=True)
_games_content = None
def load_games(filt):
def all_roms_path_files():
for dirpath, _, filenames in os.walk(settings.roms_path):
for f in filenames:
yield os.path.join(dirpath, f)
global _games_content
if not _games_content:
_games_content = filter(None, map(game_content, all_roms_path_files()))
_games_content = dict((c.name, c) for c in _games_content)
print len(_games_content), 'roms'
if filt == 'favs':
return filter_games_favorites(_games_content)
else:
return filter_games(_games_content, filt)
def filter_games(all_games, filt):
def name_to_search_key(name):
name = os.path.split(name)[1]
name = name.split('(')[0]
words = name.lower().split()
words = [re.sub('[^a-z0-9]', '', w) for w in words]
return filter(None, words)
def match_key(query, key):
return all(any(kw.startswith(qw) for kw in key) for qw in query)
return dict((k, v) for k, v in all_games.iteritems() if match_key(name_to_search_key(filt), name_to_search_key(k)))
def filter_games_favorites(all_games):
with open(settings.rom_favorites) as f:
favs = set(os.path.splitext(g.strip())[0] for g in f.readlines())
return dict((k, v) for k, v in all_games.iteritems() if k in favs)
class Playlist(object):
def __init__(self, name, choices):
self.name = name
# a mapping of content to relative likelihood
self.choices = choices if type(choices) == type({}) else dict((c, 1.) for c in choices)
self.last_played = None
def _all_choices_except_last_played(self):
for choice in self.choices.keys():
if choice == self.last_played and len(self.choices) > 1:
continue
yield choice
def get_likelihood(self, choice):
return self.choices[choice]
# TODO reduce likelihood of previous N selections
def get_next(self):
total_likelihood = sum(self.get_likelihood(choice) for choice in self._all_choices_except_last_played())
rand = random.uniform(0, total_likelihood)
cumulative_likelihood = 0
choice = None
for ch in self._all_choices_except_last_played():
cumulative_likelihood += self.get_likelihood(ch)
if cumulative_likelihood > rand:
choice = ch
break
self.last_played = choice
return choice
def to_json(self):
return {
'name': self.name,
'items': sorted(c.name for c in self.choices.keys()),
}
def load_playlists():
base = Playlist('(almost) everything', (c for c in all_content().values() if not c.manual))
nosound = Playlist('no sound-reactive', (c for c in base.choices.keys() if not c.sound_reactive or not c.sound_required))
playlists = [base, nosound]
playlists.extend(load_playlist_files())
return dict((pl.name, pl) for pl in playlists)
def load_playlist_files():
playlist_files = os.listdir(settings.playlists_dir)
for filename in playlist_files:
name, ext = os.path.splitext(filename)
if ext != '.playlist':
continue
path = os.path.join(settings.playlists_dir, filename)
with open(path) as f:
entries = filter(None, (ln.strip() for ln in f.readlines()))
def | parse_entry | identifier_name | |
rcu.rs | let (valid, pr) = match pllclk {
48_000_000 => (true, 0b01), // pllclk / 1
72_000_000 => (true, 0b00), // pllclk / 1.5
96_000_000 => (true, 0b11), // pllclk / 2
_ => (false, 0),
};
usbclk_valid = valid;
// Configure USB prescaler
rcu.cfg0.modify(|_, w| unsafe { w.usbfspsc().bits(pr) });
} else {
usbclk_valid = false;
}
let clocks = Clocks {
sysclk: Hertz(target_sysclk),
apb1_psc,
apb2_psc,
usbclk_valid
};
Rcu {
clocks,
regs: self.regs
}
}
}
#[derive(Copy, Clone)]
pub struct Clocks {
sysclk: Hertz,
apb1_psc: u8,
apb2_psc: u8,
usbclk_valid: bool,
}
impl Clocks {
/// Returns the system (core) frequency
pub const fn sysclk(&self) -> Hertz {
self.sysclk
}
/// Returns the frequency of the AHB
pub const fn hclk(&self) -> Hertz {
self.sysclk
}
/// Returns the frequency of the APB1
pub const fn pclk1(&self) -> Hertz {
Hertz(self.sysclk.0 / self.apb1_psc as u32)
}
/// Returns the frequency of the APB2
pub const fn pclk2(&self) -> Hertz {
Hertz(self.sysclk.0 / self.apb2_psc as u32)
}
/// Returns the frequency of the SysTick timer
pub const fn systick(&self) -> Hertz {
Hertz(self.sysclk.0 / 4)
}
/// Returns the frequency of the TIMER0 base clock
pub fn timer0(&self) -> Hertz {
let pclk2 = self.pclk2();
if self.apb2_psc == 1 {
pclk2
} else {
Hertz(pclk2.0 * 2)
}
}
/// Returns the frequency of the TIMER1..6 base clock
pub fn timerx(&self) -> Hertz {
let pclk1 = self.pclk1();
if self.apb1_psc == 1 {
pclk1
} else {
Hertz(pclk1.0 * 2)
}
}
/// Returns whether the USBCLK clock frequency is valid for the USB peripheral
pub const fn usbclk_valid(&self) -> bool {
self.usbclk_valid
}
}
macro_rules! base_freq {
($($PER:ident => $func:ident,)+) => {
$(
impl BaseFrequency for crate::pac::$PER {
#[inline(always)]
fn base_frequency(rcu: &Rcu) -> Hertz {
rcu.clocks.$func()
}
}
)+
}
}
base_freq! {
ADC0 => pclk2,
ADC1 => pclk2,
I2C0 => pclk1,
I2C1 => pclk1,
SPI0 => pclk2,
SPI1 => pclk1,
SPI2 => pclk1,
TIMER0 => timer0,
TIMER1 => timerx,
TIMER2 => timerx,
TIMER3 => timerx,
TIMER4 => timerx,
TIMER5 => timerx,
TIMER6 => timerx,
UART3 => pclk1,
UART4 => pclk1,
USART0 => pclk2,
USART1 => pclk1,
USART2 => pclk1,
}
pub(crate) mod closed_traits {
use super::Rcu;
use crate::time::Hertz;
/// Enable/disable peripheral
pub trait Enable {
fn enable(rcu: &mut Rcu);
fn disable(rcu: &mut Rcu);
}
/// Reset peripheral
pub trait Reset {
fn reset(rcu: &mut Rcu);
}
pub trait BaseFrequency {
fn base_frequency(rcu: &Rcu) -> Hertz;
}
}
pub(crate) use closed_traits::*;
macro_rules! bus_enable {
($PER:ident => ($apben:ident, $peren:ident)) => {
impl Enable for crate::pac::$PER {
#[inline(always)]
fn enable(rcu: &mut Rcu) {
interrupt::free(|_| {
rcu.regs.$apben.modify(|_, w| w.$peren().set_bit());
});
}
#[inline(always)]
fn disable(rcu: &mut Rcu) {
interrupt::free(|_| {
rcu.regs.$apben.modify(|_, w| w.$peren().clear_bit());
});
}
}
}
}
macro_rules! bus {
($($PER:ident => ($apben:ident, $apbrst:ident, $peren:ident, $perrst:ident),)+) => {
$(
bus_enable!($PER => ($apben, $peren));
impl Reset for crate::pac::$PER {
#[inline(always)]
fn reset(rcu: &mut Rcu) {
interrupt::free(|_| {
rcu.regs.$apbrst.modify(|_, w| w.$perrst().set_bit());
rcu.regs.$apbrst.modify(|_, w| w.$perrst().clear_bit());
});
}
}
)+
}
}
bus! {
ADC0 => (apb2en, apb2rst, adc0en, adc0rst),
ADC1 => (apb2en, apb2rst, adc1en, adc1rst),
AFIO => (apb2en, apb2rst, afen, afrst),
BKP => (apb1en, apb1rst, bkpien, bkpirst),
CAN0 => (apb1en, apb1rst, can0en, can0rst),
CAN1 => (apb1en, apb1rst, can1en, can1rst),
DAC => (apb1en, apb1rst, dacen, dacrst),
GPIOA => (apb2en, apb2rst, paen, parst),
GPIOB => (apb2en, apb2rst, pben, pbrst),
GPIOC => (apb2en, apb2rst, pcen, pcrst),
GPIOD => (apb2en, apb2rst, pden, pdrst),
GPIOE => (apb2en, apb2rst, peen, perst),
I2C0 => (apb1en, apb1rst, i2c0en, i2c0rst),
I2C1 => (apb1en, apb1rst, i2c1en, i2c1rst),
PMU => (apb1en, apb1rst, pmuen, pmurst),
SPI0 => (apb2en, apb2rst, spi0en, spi0rst),
SPI1 => (apb1en, apb1rst, spi1en, spi1rst),
SPI2 => (apb1en, apb1rst, spi2en, spi2rst),
TIMER0 => (apb2en, apb2rst, timer0en, timer0rst),
TIMER1 => (apb1en, apb1rst, timer1en, timer1rst),
TIMER2 => (apb1en, apb1rst, timer2en, timer2rst),
TIMER3 => (apb1en, apb1rst, timer3en, timer3rst),
TIMER4 => (apb1en, apb1rst, timer4en, timer4rst),
TIMER5 => (apb1en, apb1rst, timer5en, timer5rst),
TIMER6 => (apb1en, apb1rst, timer6en, timer6rst),
UART3 => (apb1en, apb1rst, uart3en, uart3rst),
UART4 => (apb1en, apb1rst, uart4en, uart4rst),
USART0 => (apb2en, apb2rst, usart0en, usart0rst),
USART1 => (apb1en, apb1rst, usart1en, usart1rst),
USART2 => (apb1en, apb1rst, usart2en, usart2rst),
USBFS_GLOBAL => (ahben, ahbrst, usbfsen, usbfsrst),
WWDGT => (apb1en, apb1rst, wwdgten, wwdgtrst), | }
bus_enable!(CRC => (ahben, crcen));
bus_enable!(DMA0 => (ahben, dma0en)); | random_line_split | |
rcu.rs | clk => (0b01, false),
(None, sysclk) if IRC8M == sysclk => (0b00, false),
_ => (0b10, true),
};
let pllsel_bit;
let predv0_bits;
let pllmf_bits;
if use_pll {
let pllmf;
if let Some(hxtal_freq) = self.hxtal {
// Use external clock + divider
pllsel_bit = true;
let calculate_pll = |source: u32, target: u32| -> Option<(u8, u8)> {
const PLL_IN_MIN: u32 = 600_000;
let div_max = cmp::min(16, source / PLL_IN_MIN);
for d in 1..=div_max {
let pllsource = source / d;
let pllm = target / pllsource;
if pllm < 2 || pllm == 15 || pllm > 32{
continue;
}
let actual_freq = pllsource * pllm;
if actual_freq == target {
return Some((d as u8, pllm as u8));
}
}
None
};
let (d, m) = calculate_pll(hxtal_freq, target_sysclk).expect("invalid sysclk value");
predv0_bits = d - 1;
pllmf = m;
} else {
// IRC8M/2 is used as an input clock
pllsel_bit = false;
let pllsource = IRC8M / 2;
let m = target_sysclk / pllsource;
let m = cmp::max(2, cmp::min(m, 32));
assert_ne!(m, 15, "invalid sysclk value");
let actual_sysclk = pllsource * m;
assert_eq!(target_sysclk, actual_sysclk, "invalid sysclk value");
predv0_bits = 0;
pllmf = m as u8;
}
pllmf_bits = match pllmf {
2..=14 => pllmf - 2,
16..=32 => pllmf - 1,
_ => unreachable!("invalid pll multiplier"),
};
} else {
pllsel_bit = false;
predv0_bits = 0;
pllmf_bits = 0;
}
// Switch to the internal clock
let rcu = unsafe { &*crate::pac::RCU::ptr() };
rcu.ctl.modify(|_, w| w.irc8men().set_bit()); // Enable IRC8M oscillator
while rcu.ctl.read().irc8mstb().bit_is_clear() {} // Wait for oscillator to stabilize
rcu.cfg0.modify(|_, w| unsafe { w.scs().bits(0b00) }); // Switch to the internal oscillator
rcu.ctl.modify(|_, w| w.pllen().clear_bit()); // Disable PLL
// Set bus prescalers
rcu.cfg0.modify(|_, w| unsafe { w.ahbpsc().bits(0b0000) }); // CK_SYS
rcu.cfg0.modify(|_, w| unsafe { w.apb1psc().bits(0b100) }); // CK_AHB / 2
rcu.cfg0.modify(|_, w| unsafe { w.apb2psc().bits(0b000) }); // CK_AHB
let apb1_psc = 2;
let apb2_psc = 1;
if self.hxtal.is_some() {
// Enable external oscillator
rcu.ctl.modify(|_, w| w.hxtalen().set_bit());
// Wait for oscillator to stabilize
while rcu.ctl.read().hxtalstb().bit_is_clear() {}
// Select HXTAL as prescaler input source clock
rcu.cfg1.modify(|_, w| w.predv0sel().clear_bit());
// Configure the prescaler
rcu.cfg1.modify(|_, w| unsafe { w.predv0().bits(predv0_bits) });
}
if use_pll {
// Configure PLL input selector
rcu.cfg0.modify(|_, w| w.pllsel().bit(pllsel_bit));
// Configure PLL multiplier
rcu.cfg0.modify(|_, w| unsafe { w
.pllmf_4().bit(pllmf_bits & 0x10 != 0)
.pllmf_3_0().bits(pllmf_bits & 0xf)
});
// Enable PLL
rcu.ctl.modify(|_, w| w.pllen().set_bit());
// Wait for PLL to stabilize
while rcu.ctl.read().pllstb().bit_is_clear() {}
} else {
// Disable PLL
rcu.ctl.modify(|_, w| w.pllen().clear_bit());
}
// Switch to the configured clock source
rcu.cfg0.modify(|_, w| unsafe { w.scs().bits(scs_bits) });
let usbclk_valid;
if use_pll {
let pllclk = target_sysclk;
let (valid, pr) = match pllclk {
48_000_000 => (true, 0b01), // pllclk / 1
72_000_000 => (true, 0b00), // pllclk / 1.5
96_000_000 => (true, 0b11), // pllclk / 2
_ => (false, 0),
};
usbclk_valid = valid;
// Configure USB prescaler
rcu.cfg0.modify(|_, w| unsafe { w.usbfspsc().bits(pr) });
} else {
usbclk_valid = false;
}
let clocks = Clocks {
sysclk: Hertz(target_sysclk),
apb1_psc,
apb2_psc,
usbclk_valid
};
Rcu {
clocks,
regs: self.regs
}
}
}
#[derive(Copy, Clone)]
pub struct Clocks {
sysclk: Hertz,
apb1_psc: u8,
apb2_psc: u8,
usbclk_valid: bool,
}
impl Clocks {
/// Returns the system (core) frequency
pub const fn sysclk(&self) -> Hertz {
self.sysclk
}
/// Returns the frequency of the AHB
pub const fn hclk(&self) -> Hertz {
self.sysclk
}
/// Returns the frequency of the APB1
pub const fn pclk1(&self) -> Hertz {
Hertz(self.sysclk.0 / self.apb1_psc as u32)
}
/// Returns the frequency of the APB2
pub const fn pclk2(&self) -> Hertz {
Hertz(self.sysclk.0 / self.apb2_psc as u32)
}
/// Returns the frequency of the SysTick timer
pub const fn systick(&self) -> Hertz {
Hertz(self.sysclk.0 / 4)
}
/// Returns the frequency of the TIMER0 base clock
pub fn timer0(&self) -> Hertz |
/// Returns the frequency of the TIMER1..6 base clock
pub fn timerx(&self) -> Hertz {
let pclk1 = self.pclk1();
if self.apb1_psc == 1 {
pclk1
} else {
Hertz(pclk1.0 * 2)
}
}
/// Returns whether the USBCLK clock frequency is valid for the USB peripheral
pub const fn usbclk_valid(&self) -> bool {
self.usbclk_valid
}
}
macro_rules! base_freq {
($($PER:ident => $func:ident,)+) => {
$(
impl BaseFrequency for crate::pac::$PER {
#[inline(always)]
fn base_frequency(rcu: &Rcu) -> Hertz {
rcu.clocks.$func()
}
}
)+
}
}
base_freq! {
ADC0 => pclk2,
ADC1 => pclk2,
I2C0 => pclk1,
I2C1 => pclk1,
SPI0 => pclk2,
SPI1 => pclk1,
SPI2 => pclk1,
TIMER0 => timer0,
TIMER1 => timerx,
TIMER2 => timerx,
TIMER3 => timerx,
TIMER4 => timerx,
TIMER5 => timerx,
TIMER6 => timerx,
UART3 => pclk1,
UART4 => pclk1,
USART0 => pclk2,
USART1 => pclk1,
USART2 => pclk1,
}
pub(crate) mod closed_traits {
use super::Rcu;
use crate::time::Hertz;
/// Enable/disable peripheral | {
let pclk2 = self.pclk2();
if self.apb2_psc == 1 {
pclk2
} else {
Hertz(pclk2.0 * 2)
}
} | identifier_body |
rcu.rs | clk => (0b01, false),
(None, sysclk) if IRC8M == sysclk => (0b00, false),
_ => (0b10, true),
};
let pllsel_bit;
let predv0_bits;
let pllmf_bits;
if use_pll {
let pllmf;
if let Some(hxtal_freq) = self.hxtal {
// Use external clock + divider
pllsel_bit = true;
let calculate_pll = |source: u32, target: u32| -> Option<(u8, u8)> {
const PLL_IN_MIN: u32 = 600_000;
let div_max = cmp::min(16, source / PLL_IN_MIN);
for d in 1..=div_max {
let pllsource = source / d;
let pllm = target / pllsource;
if pllm < 2 || pllm == 15 || pllm > 32{
continue;
}
let actual_freq = pllsource * pllm;
if actual_freq == target {
return Some((d as u8, pllm as u8));
}
}
None
};
let (d, m) = calculate_pll(hxtal_freq, target_sysclk).expect("invalid sysclk value");
predv0_bits = d - 1;
pllmf = m;
} else {
// IRC8M/2 is used as an input clock
pllsel_bit = false;
let pllsource = IRC8M / 2;
let m = target_sysclk / pllsource;
let m = cmp::max(2, cmp::min(m, 32));
assert_ne!(m, 15, "invalid sysclk value");
let actual_sysclk = pllsource * m;
assert_eq!(target_sysclk, actual_sysclk, "invalid sysclk value");
predv0_bits = 0;
pllmf = m as u8;
}
pllmf_bits = match pllmf {
2..=14 => pllmf - 2,
16..=32 => pllmf - 1,
_ => unreachable!("invalid pll multiplier"),
};
} else {
pllsel_bit = false;
predv0_bits = 0;
pllmf_bits = 0;
}
// Switch to the internal clock
let rcu = unsafe { &*crate::pac::RCU::ptr() };
rcu.ctl.modify(|_, w| w.irc8men().set_bit()); // Enable IRC8M oscillator
while rcu.ctl.read().irc8mstb().bit_is_clear() {} // Wait for oscillator to stabilize
rcu.cfg0.modify(|_, w| unsafe { w.scs().bits(0b00) }); // Switch to the internal oscillator
rcu.ctl.modify(|_, w| w.pllen().clear_bit()); // Disable PLL
// Set bus prescalers
rcu.cfg0.modify(|_, w| unsafe { w.ahbpsc().bits(0b0000) }); // CK_SYS
rcu.cfg0.modify(|_, w| unsafe { w.apb1psc().bits(0b100) }); // CK_AHB / 2
rcu.cfg0.modify(|_, w| unsafe { w.apb2psc().bits(0b000) }); // CK_AHB
let apb1_psc = 2;
let apb2_psc = 1;
if self.hxtal.is_some() {
// Enable external oscillator
rcu.ctl.modify(|_, w| w.hxtalen().set_bit());
// Wait for oscillator to stabilize
while rcu.ctl.read().hxtalstb().bit_is_clear() {}
// Select HXTAL as prescaler input source clock
rcu.cfg1.modify(|_, w| w.predv0sel().clear_bit());
// Configure the prescaler
rcu.cfg1.modify(|_, w| unsafe { w.predv0().bits(predv0_bits) });
}
if use_pll {
// Configure PLL input selector
rcu.cfg0.modify(|_, w| w.pllsel().bit(pllsel_bit));
// Configure PLL multiplier
rcu.cfg0.modify(|_, w| unsafe { w
.pllmf_4().bit(pllmf_bits & 0x10 != 0)
.pllmf_3_0().bits(pllmf_bits & 0xf)
});
// Enable PLL
rcu.ctl.modify(|_, w| w.pllen().set_bit());
// Wait for PLL to stabilize
while rcu.ctl.read().pllstb().bit_is_clear() {}
} else {
// Disable PLL
rcu.ctl.modify(|_, w| w.pllen().clear_bit());
}
// Switch to the configured clock source
rcu.cfg0.modify(|_, w| unsafe { w.scs().bits(scs_bits) });
let usbclk_valid;
if use_pll {
let pllclk = target_sysclk;
let (valid, pr) = match pllclk {
48_000_000 => (true, 0b01), // pllclk / 1
72_000_000 => (true, 0b00), // pllclk / 1.5
96_000_000 => (true, 0b11), // pllclk / 2
_ => (false, 0),
};
usbclk_valid = valid;
// Configure USB prescaler
rcu.cfg0.modify(|_, w| unsafe { w.usbfspsc().bits(pr) });
} else {
usbclk_valid = false;
}
let clocks = Clocks {
sysclk: Hertz(target_sysclk),
apb1_psc,
apb2_psc,
usbclk_valid
};
Rcu {
clocks,
regs: self.regs
}
}
}
#[derive(Copy, Clone)]
pub struct Clocks {
sysclk: Hertz,
apb1_psc: u8,
apb2_psc: u8,
usbclk_valid: bool,
}
impl Clocks {
/// Returns the system (core) frequency
pub const fn sysclk(&self) -> Hertz {
self.sysclk
}
/// Returns the frequency of the AHB
pub const fn hclk(&self) -> Hertz {
self.sysclk
}
/// Returns the frequency of the APB1
pub const fn pclk1(&self) -> Hertz {
Hertz(self.sysclk.0 / self.apb1_psc as u32)
}
/// Returns the frequency of the APB2
pub const fn pclk2(&self) -> Hertz {
Hertz(self.sysclk.0 / self.apb2_psc as u32)
}
/// Returns the frequency of the SysTick timer
pub const fn | (&self) -> Hertz {
Hertz(self.sysclk.0 / 4)
}
/// Returns the frequency of the TIMER0 base clock
pub fn timer0(&self) -> Hertz {
let pclk2 = self.pclk2();
if self.apb2_psc == 1 {
pclk2
} else {
Hertz(pclk2.0 * 2)
}
}
/// Returns the frequency of the TIMER1..6 base clock
pub fn timerx(&self) -> Hertz {
let pclk1 = self.pclk1();
if self.apb1_psc == 1 {
pclk1
} else {
Hertz(pclk1.0 * 2)
}
}
/// Returns whether the USBCLK clock frequency is valid for the USB peripheral
pub const fn usbclk_valid(&self) -> bool {
self.usbclk_valid
}
}
macro_rules! base_freq {
($($PER:ident => $func:ident,)+) => {
$(
impl BaseFrequency for crate::pac::$PER {
#[inline(always)]
fn base_frequency(rcu: &Rcu) -> Hertz {
rcu.clocks.$func()
}
}
)+
}
}
base_freq! {
ADC0 => pclk2,
ADC1 => pclk2,
I2C0 => pclk1,
I2C1 => pclk1,
SPI0 => pclk2,
SPI1 => pclk1,
SPI2 => pclk1,
TIMER0 => timer0,
TIMER1 => timerx,
TIMER2 => timerx,
TIMER3 => timerx,
TIMER4 => timerx,
TIMER5 => timerx,
TIMER6 => timerx,
UART3 => pclk1,
UART4 => pclk1,
USART0 => pclk2,
USART1 => pclk1,
USART2 => pclk1,
}
pub(crate) mod closed_traits {
use super::Rcu;
use crate::time::Hertz;
/// Enable/disable peripheral
| systick | identifier_name |
rcu.rs | clk => (0b01, false),
(None, sysclk) if IRC8M == sysclk => (0b00, false),
_ => (0b10, true),
};
let pllsel_bit;
let predv0_bits;
let pllmf_bits;
if use_pll | }
}
None
};
let (d, m) = calculate_pll(hxtal_freq, target_sysclk).expect("invalid sysclk value");
predv0_bits = d - 1;
pllmf = m;
} else {
// IRC8M/2 is used as an input clock
pllsel_bit = false;
let pllsource = IRC8M / 2;
let m = target_sysclk / pllsource;
let m = cmp::max(2, cmp::min(m, 32));
assert_ne!(m, 15, "invalid sysclk value");
let actual_sysclk = pllsource * m;
assert_eq!(target_sysclk, actual_sysclk, "invalid sysclk value");
predv0_bits = 0;
pllmf = m as u8;
}
pllmf_bits = match pllmf {
2..=14 => pllmf - 2,
16..=32 => pllmf - 1,
_ => unreachable!("invalid pll multiplier"),
};
}
else {
pllsel_bit = false;
predv0_bits = 0;
pllmf_bits = 0;
}
// Switch to the internal clock
let rcu = unsafe { &*crate::pac::RCU::ptr() };
rcu.ctl.modify(|_, w| w.irc8men().set_bit()); // Enable IRC8M oscillator
while rcu.ctl.read().irc8mstb().bit_is_clear() {} // Wait for oscillator to stabilize
rcu.cfg0.modify(|_, w| unsafe { w.scs().bits(0b00) }); // Switch to the internal oscillator
rcu.ctl.modify(|_, w| w.pllen().clear_bit()); // Disable PLL
// Set bus prescalers
rcu.cfg0.modify(|_, w| unsafe { w.ahbpsc().bits(0b0000) }); // CK_SYS
rcu.cfg0.modify(|_, w| unsafe { w.apb1psc().bits(0b100) }); // CK_AHB / 2
rcu.cfg0.modify(|_, w| unsafe { w.apb2psc().bits(0b000) }); // CK_AHB
let apb1_psc = 2;
let apb2_psc = 1;
if self.hxtal.is_some() {
// Enable external oscillator
rcu.ctl.modify(|_, w| w.hxtalen().set_bit());
// Wait for oscillator to stabilize
while rcu.ctl.read().hxtalstb().bit_is_clear() {}
// Select HXTAL as prescaler input source clock
rcu.cfg1.modify(|_, w| w.predv0sel().clear_bit());
// Configure the prescaler
rcu.cfg1.modify(|_, w| unsafe { w.predv0().bits(predv0_bits) });
}
if use_pll {
// Configure PLL input selector
rcu.cfg0.modify(|_, w| w.pllsel().bit(pllsel_bit));
// Configure PLL multiplier
rcu.cfg0.modify(|_, w| unsafe { w
.pllmf_4().bit(pllmf_bits & 0x10 != 0)
.pllmf_3_0().bits(pllmf_bits & 0xf)
});
// Enable PLL
rcu.ctl.modify(|_, w| w.pllen().set_bit());
// Wait for PLL to stabilize
while rcu.ctl.read().pllstb().bit_is_clear() {}
} else {
// Disable PLL
rcu.ctl.modify(|_, w| w.pllen().clear_bit());
}
// Switch to the configured clock source
rcu.cfg0.modify(|_, w| unsafe { w.scs().bits(scs_bits) });
let usbclk_valid;
if use_pll {
let pllclk = target_sysclk;
let (valid, pr) = match pllclk {
48_000_000 => (true, 0b01), // pllclk / 1
72_000_000 => (true, 0b00), // pllclk / 1.5
96_000_000 => (true, 0b11), // pllclk / 2
_ => (false, 0),
};
usbclk_valid = valid;
// Configure USB prescaler
rcu.cfg0.modify(|_, w| unsafe { w.usbfspsc().bits(pr) });
} else {
usbclk_valid = false;
}
let clocks = Clocks {
sysclk: Hertz(target_sysclk),
apb1_psc,
apb2_psc,
usbclk_valid
};
Rcu {
clocks,
regs: self.regs
}
}
}
#[derive(Copy, Clone)]
pub struct Clocks {
sysclk: Hertz,
apb1_psc: u8,
apb2_psc: u8,
usbclk_valid: bool,
}
impl Clocks {
/// Returns the system (core) frequency
pub const fn sysclk(&self) -> Hertz {
self.sysclk
}
/// Returns the frequency of the AHB
pub const fn hclk(&self) -> Hertz {
self.sysclk
}
/// Returns the frequency of the APB1
pub const fn pclk1(&self) -> Hertz {
Hertz(self.sysclk.0 / self.apb1_psc as u32)
}
/// Returns the frequency of the APB2
pub const fn pclk2(&self) -> Hertz {
Hertz(self.sysclk.0 / self.apb2_psc as u32)
}
/// Returns the frequency of the SysTick timer
pub const fn systick(&self) -> Hertz {
Hertz(self.sysclk.0 / 4)
}
/// Returns the frequency of the TIMER0 base clock
pub fn timer0(&self) -> Hertz {
let pclk2 = self.pclk2();
if self.apb2_psc == 1 {
pclk2
} else {
Hertz(pclk2.0 * 2)
}
}
/// Returns the frequency of the TIMER1..6 base clock
pub fn timerx(&self) -> Hertz {
let pclk1 = self.pclk1();
if self.apb1_psc == 1 {
pclk1
} else {
Hertz(pclk1.0 * 2)
}
}
/// Returns whether the USBCLK clock frequency is valid for the USB peripheral
pub const fn usbclk_valid(&self) -> bool {
self.usbclk_valid
}
}
macro_rules! base_freq {
($($PER:ident => $func:ident,)+) => {
$(
impl BaseFrequency for crate::pac::$PER {
#[inline(always)]
fn base_frequency(rcu: &Rcu) -> Hertz {
rcu.clocks.$func()
}
}
)+
}
}
base_freq! {
ADC0 => pclk2,
ADC1 => pclk2,
I2C0 => pclk1,
I2C1 => pclk1,
SPI0 => pclk2,
SPI1 => pclk1,
SPI2 => pclk1,
TIMER0 => timer0,
TIMER1 => timerx,
TIMER2 => timerx,
TIMER3 => timerx,
TIMER4 => timerx,
TIMER5 => timerx,
TIMER6 => timerx,
UART3 => pclk1,
UART4 => pclk1,
USART0 => pclk2,
USART1 => pclk1,
USART2 => pclk1,
}
pub(crate) mod closed_traits {
use super::Rcu;
use crate::time::Hertz;
/// Enable/disable peripheral
| {
let pllmf;
if let Some(hxtal_freq) = self.hxtal {
// Use external clock + divider
pllsel_bit = true;
let calculate_pll = |source: u32, target: u32| -> Option<(u8, u8)> {
const PLL_IN_MIN: u32 = 600_000;
let div_max = cmp::min(16, source / PLL_IN_MIN);
for d in 1..=div_max {
let pllsource = source / d;
let pllm = target / pllsource;
if pllm < 2 || pllm == 15 || pllm > 32{
continue;
}
let actual_freq = pllsource * pllm;
if actual_freq == target {
return Some((d as u8, pllm as u8)); | conditional_block |
types.go | nil {
reg.participantsByGaiaID = make(map[string]*ParticipantData)
}
reg.participantsByGaiaID[id] = data
}
if id := data.ID.ChatID; id != "" {
if reg.participantsByChatID == nil {
reg.participantsByChatID = make(map[string]*ParticipantData)
}
reg.participantsByChatID[id] = data
}
reg.allParticipants = append(reg.allParticipants, data)
}
func (reg *ParticipantRegistry) AllParticipants() []*ParticipantData {
return reg.allParticipants
}
func (reg *ParticipantRegistry) ForID(pid *ParticipantID) *ParticipantData {
if pid.GaiaID != "" {
if v := reg.participantsByGaiaID[pid.GaiaID]; v != nil {
return v
}
}
if pid.ChatID != "" {
if v := reg.participantsByChatID[pid.ChatID]; v != nil {
return v
}
}
return nil
}
type Conversation struct {
Conversation *ConversationEntry `json:"conversation"`
EventsMessage json.RawMessage `json:"events"`
initialized bool
reg ParticipantRegistry
events []json.RawMessage
decodedEvents []*Event
}
func (ce *Conversation) initialize() error {
if ce.initialized {
return nil
}
if err := json.Unmarshal([]byte(ce.EventsMessage), &ce.events); err != nil {
return err
}
ce.decodedEvents = make([]*Event, len(ce.events))
for _, pd := range ce.Conversation.ConversationInfo.ParticipantData {
ce.reg.Register(pd)
}
ce.initialized = true
return nil
}
func (ce *Conversation) ParticipantRegistry() *ParticipantRegistry { return &ce.reg }
func (ce *Conversation) EventsSize() int {
return len(ce.events)
}
func (ce *Conversation) ResolveAll() error {
for i := 0; i < len(ce.events); i++ {
_, err := ce.Event(i)
if err != nil {
return err
}
}
return nil
}
func (ce *Conversation) Event(i int) (*Event, error) {
if i < 0 || i >= len(ce.events) {
return nil, errors.New("Index out of bounds")
}
if ce.decodedEvents[i] == nil {
var event Event
if err := json.Unmarshal(ce.events[i], &event); err != nil {
return nil, err
}
ce.decodedEvents[i] = &event
}
return ce.decodedEvents[i], nil
}
type ConversationEntry struct {
ConversationInfo *ConversationInfo `json:"conversation"`
}
type SingleID struct {
ID string `json:"id"`
}
type ConversationInfo struct {
ID *SingleID `json:"id"`
Type string `json:"type"`
Name string `json:"name"`
CurrentParticipant []*ParticipantID `json:"current_participant"`
ParticipantData []*ParticipantData `json:"participant_data"`
}
type ParticipantID struct {
GaiaID string `json:"gaia_id"`
ChatID string `json:"chat_id"`
}
func (pid *ParticipantID) String() string |
// Matches returns true if pid's Gaia or Chat ID are both populated and match
// the equivalent values in other.
func (pid *ParticipantID) Matches(other *ParticipantID) bool {
if pid.GaiaID != "" && pid.GaiaID == other.GaiaID {
return true
}
if pid.ChatID != "" && pid.ChatID == other.ChatID {
return true
}
return false
}
type ParticipantData struct {
ID ParticipantID `json:"id"`
FallbackName string `json:"fallback_name"`
ParticipantType string `json:"participant_type"`
DomainID string `json:"domain_id"`
}
func (pd *ParticipantData) DisplayName() string {
return pd.FallbackName
}
type MessageContentSegment struct {
Type string `json:"type"`
Text string `json:"text"`
Formatting struct {
Bold bool `json:"bold"`
Italics bool `json:"italics"`
Strikethrough bool `json:"strikethrough"`
Underline bool `json:"underline"`
} `json:"formatting"`
LinkData *struct {
LinkTarget string `json:"link_target"`
} `json:"link_data"`
}
type Thumbnail struct {
URL string `json:"url"`
ImageURL string `json:"image_url"`
WidthPx int64 `json:"width_px"`
HeightPx int64 `json:"height_px"`
}
type PlusPhoto struct {
Thumbnail *Thumbnail `json:"thumbnail"`
OwnerObfuscatedID string `json:"owner_obfuscated_id"`
AlbumID string `json:"album_id"`
PhotoID string `json:"photo_id"`
URL string `json:"url"`
OriginalContentURL string `json:"original_content_url"`
MediaType string `json:"media_type"`
}
type GeoCoordinatesV2 struct {
Latitude float64 `json:"latitude"`
Longitude float64 `json:"longitude"`
}
type PostalAddressV2 struct {
StreetAddress string `json:"street_address"`
Name string `json:"name"`
AddressCountry string `json:"address_country"`
AddressLocality string `json:"address_locality"`
AddressRegion string `json:"address_region"`
PostalCode string `json:"postal_code"`
}
type ImageObjectV2 struct {
URL string `json:"url"`
}
type PlaceV2 struct {
URL string `json:"url"`
Name string `json:"name"`
Address *struct {
PostalAddressV2 PostalAddressV2 `json:"postal_address_v2"`
} `json:"address"`
Geo *struct {
GeoCoordinatesV2 GeoCoordinatesV2 `json:"geo_coordinates_v2"`
} `json:"geo"`
ID string `json:"id"`
ImageObjectV2 *ImageObjectV2 `json:"image_object_v2"`
}
type RepresentativeImage struct {
Type []EmbedItemType `json:"type"`
ID string `json:"id"`
ImageObjectV2 *ImageObjectV2 `json:"image_object_v2"`
}
type ThingV2 struct {
URL string `json:"url"`
Name string `json:"name"`
RepresentativeImage *RepresentativeImage `json:"representative_image"`
}
type EmbedItem struct {
Type []EmbedItemType `json:"type"`
ID string `json:"id"`
PlusPhoto *PlusPhoto `json:"plus_photo"`
PlaceV2 *PlaceV2 `json:"place_v2"`
ThingV2 *ThingV2 `json:"thing_v2"`
ImageObjectV2 *ImageObjectV2 `json:"image_object_v2"`
}
func (ei *EmbedItem) Key() string {
if pp := ei.PlusPhoto; pp != nil {
return fmt.Sprintf("%s:%s", pp.AlbumID, pp.PhotoID)
}
if p := ei.ThingV2; p != nil {
// Use a hash of the Thing's URL.
return util.HashForKey(p.URL)
}
return ei.ID
}
type MessageContentAttachment struct {
EmbedItem *EmbedItem `json:"embed_item"`
ID string `json:"id"`
}
type MessageContent struct {
Segment []*MessageContentSegment `json:"segment"`
Attachment []*MessageContentAttachment `json:"attachment"`
}
type ChatMessage struct {
MessageContent *MessageContent `json:"message_content"`
}
type ConversationRename struct {
NewName string `json:"new_name"`
OldName string `json:"old_name"`
}
type MembershipChange struct {
Type string `json:"type"`
ParticipantID []*ParticipantID `json:"participant_id"`
LeaveReason string `json:"leave_reason"`
}
type Event struct {
ConversationID *SingleID `json:"conversation_id"`
SenderID *ParticipantID `json:"sender_id"`
Timestamp string `json:"timestamp"`
ConversationRename *ConversationRename `json:"conversation_rename"`
ChatMessage *ChatMessage `json:"chat_message"`
MembershipChange *MembershipChange `json:"membership_change"`
EventID string `json:"event_id"`
EventType EventType `json:"event_type"`
}
func (e *Event) Time() (time.Time, error) {
// Timestamp is in microseconds from epoch.
micros, err := strconv.ParseInt(e.Timestamp, 10, 64)
if err != nil {
return time.Time{}, err
}
return time.Unix(0, micros*1000), nil
}
func (e *Event) Description(reg *ParticipantRegistry) (string, error) {
var parts []string
// Time
switch t, err := e.Time(); err {
case nil:
parts = append(parts, t.In(time.Local).Format(time.RFC3339Nano))
default:
parts = append(parts, fmt.Sprintf("Timestmap Error (%s)", e.Timestamp))
}
if sid := e.SenderID; sid != nil {
var pd *ParticipantData
if reg != nil {
pd = reg.ForID(sid)
| {
return fmt.Sprintf("gaia:%s/chat:%s", pid.GaiaID, pid.ChatID)
} | identifier_body |
types.go | nil {
reg.participantsByGaiaID = make(map[string]*ParticipantData)
}
reg.participantsByGaiaID[id] = data
}
if id := data.ID.ChatID; id != "" {
if reg.participantsByChatID == nil {
reg.participantsByChatID = make(map[string]*ParticipantData)
}
reg.participantsByChatID[id] = data
}
reg.allParticipants = append(reg.allParticipants, data)
}
func (reg *ParticipantRegistry) AllParticipants() []*ParticipantData {
return reg.allParticipants
}
func (reg *ParticipantRegistry) ForID(pid *ParticipantID) *ParticipantData {
if pid.GaiaID != "" {
if v := reg.participantsByGaiaID[pid.GaiaID]; v != nil {
return v
}
}
if pid.ChatID != "" {
if v := reg.participantsByChatID[pid.ChatID]; v != nil {
return v
}
}
return nil
}
type Conversation struct {
Conversation *ConversationEntry `json:"conversation"`
EventsMessage json.RawMessage `json:"events"`
initialized bool
reg ParticipantRegistry
events []json.RawMessage
decodedEvents []*Event
}
func (ce *Conversation) initialize() error {
if ce.initialized {
return nil
}
if err := json.Unmarshal([]byte(ce.EventsMessage), &ce.events); err != nil {
return err
}
ce.decodedEvents = make([]*Event, len(ce.events))
for _, pd := range ce.Conversation.ConversationInfo.ParticipantData {
ce.reg.Register(pd)
}
ce.initialized = true
return nil
}
func (ce *Conversation) ParticipantRegistry() *ParticipantRegistry { return &ce.reg }
func (ce *Conversation) EventsSize() int {
return len(ce.events)
}
func (ce *Conversation) ResolveAll() error {
for i := 0; i < len(ce.events); i++ {
_, err := ce.Event(i)
if err != nil {
return err
}
}
return nil
}
func (ce *Conversation) Event(i int) (*Event, error) {
if i < 0 || i >= len(ce.events) {
return nil, errors.New("Index out of bounds")
}
if ce.decodedEvents[i] == nil {
var event Event
if err := json.Unmarshal(ce.events[i], &event); err != nil {
return nil, err
}
ce.decodedEvents[i] = &event
}
return ce.decodedEvents[i], nil
}
type ConversationEntry struct {
ConversationInfo *ConversationInfo `json:"conversation"`
}
type SingleID struct {
ID string `json:"id"`
}
type ConversationInfo struct {
ID *SingleID `json:"id"`
Type string `json:"type"`
Name string `json:"name"`
CurrentParticipant []*ParticipantID `json:"current_participant"`
ParticipantData []*ParticipantData `json:"participant_data"`
}
type ParticipantID struct {
GaiaID string `json:"gaia_id"`
ChatID string `json:"chat_id"`
}
func (pid *ParticipantID) String() string {
return fmt.Sprintf("gaia:%s/chat:%s", pid.GaiaID, pid.ChatID)
}
// Matches returns true if pid's Gaia or Chat ID are both populated and match
// the equivalent values in other.
func (pid *ParticipantID) Matches(other *ParticipantID) bool {
if pid.GaiaID != "" && pid.GaiaID == other.GaiaID {
return true
}
if pid.ChatID != "" && pid.ChatID == other.ChatID {
return true
}
return false
}
type ParticipantData struct {
ID ParticipantID `json:"id"`
FallbackName string `json:"fallback_name"`
ParticipantType string `json:"participant_type"`
DomainID string `json:"domain_id"`
}
func (pd *ParticipantData) DisplayName() string {
return pd.FallbackName
}
type MessageContentSegment struct {
Type string `json:"type"`
Text string `json:"text"`
Formatting struct {
Bold bool `json:"bold"`
Italics bool `json:"italics"`
Strikethrough bool `json:"strikethrough"`
Underline bool `json:"underline"`
} `json:"formatting"`
LinkData *struct {
LinkTarget string `json:"link_target"`
} `json:"link_data"`
}
type Thumbnail struct {
URL string `json:"url"`
ImageURL string `json:"image_url"`
WidthPx int64 `json:"width_px"`
HeightPx int64 `json:"height_px"`
}
type PlusPhoto struct {
Thumbnail *Thumbnail `json:"thumbnail"`
OwnerObfuscatedID string `json:"owner_obfuscated_id"`
AlbumID string `json:"album_id"`
PhotoID string `json:"photo_id"`
URL string `json:"url"`
OriginalContentURL string `json:"original_content_url"`
MediaType string `json:"media_type"`
}
type GeoCoordinatesV2 struct {
Latitude float64 `json:"latitude"`
Longitude float64 `json:"longitude"`
}
type PostalAddressV2 struct {
StreetAddress string `json:"street_address"`
Name string `json:"name"`
AddressCountry string `json:"address_country"`
AddressLocality string `json:"address_locality"`
AddressRegion string `json:"address_region"`
PostalCode string `json:"postal_code"`
}
type ImageObjectV2 struct {
URL string `json:"url"`
}
type PlaceV2 struct {
URL string `json:"url"`
Name string `json:"name"`
Address *struct {
PostalAddressV2 PostalAddressV2 `json:"postal_address_v2"`
} `json:"address"`
Geo *struct {
GeoCoordinatesV2 GeoCoordinatesV2 `json:"geo_coordinates_v2"`
} `json:"geo"`
ID string `json:"id"`
ImageObjectV2 *ImageObjectV2 `json:"image_object_v2"`
}
type RepresentativeImage struct {
Type []EmbedItemType `json:"type"`
ID string `json:"id"`
ImageObjectV2 *ImageObjectV2 `json:"image_object_v2"`
}
type ThingV2 struct {
URL string `json:"url"`
Name string `json:"name"`
RepresentativeImage *RepresentativeImage `json:"representative_image"`
}
type EmbedItem struct {
Type []EmbedItemType `json:"type"`
ID string `json:"id"`
PlusPhoto *PlusPhoto `json:"plus_photo"`
PlaceV2 *PlaceV2 `json:"place_v2"`
ThingV2 *ThingV2 `json:"thing_v2"`
ImageObjectV2 *ImageObjectV2 `json:"image_object_v2"`
}
func (ei *EmbedItem) | () string {
if pp := ei.PlusPhoto; pp != nil {
return fmt.Sprintf("%s:%s", pp.AlbumID, pp.PhotoID)
}
if p := ei.ThingV2; p != nil {
// Use a hash of the Thing's URL.
return util.HashForKey(p.URL)
}
return ei.ID
}
type MessageContentAttachment struct {
EmbedItem *EmbedItem `json:"embed_item"`
ID string `json:"id"`
}
type MessageContent struct {
Segment []*MessageContentSegment `json:"segment"`
Attachment []*MessageContentAttachment `json:"attachment"`
}
type ChatMessage struct {
MessageContent *MessageContent `json:"message_content"`
}
type ConversationRename struct {
NewName string `json:"new_name"`
OldName string `json:"old_name"`
}
type MembershipChange struct {
Type string `json:"type"`
ParticipantID []*ParticipantID `json:"participant_id"`
LeaveReason string `json:"leave_reason"`
}
type Event struct {
ConversationID *SingleID `json:"conversation_id"`
SenderID *ParticipantID `json:"sender_id"`
Timestamp string `json:"timestamp"`
ConversationRename *ConversationRename `json:"conversation_rename"`
ChatMessage *ChatMessage `json:"chat_message"`
MembershipChange *MembershipChange `json:"membership_change"`
EventID string `json:"event_id"`
EventType EventType `json:"event_type"`
}
func (e *Event) Time() (time.Time, error) {
// Timestamp is in microseconds from epoch.
micros, err := strconv.ParseInt(e.Timestamp, 10, 64)
if err != nil {
return time.Time{}, err
}
return time.Unix(0, micros*1000), nil
}
func (e *Event) Description(reg *ParticipantRegistry) (string, error) {
var parts []string
// Time
switch t, err := e.Time(); err {
case nil:
parts = append(parts, t.In(time.Local).Format(time.RFC3339Nano))
default:
parts = append(parts, fmt.Sprintf("Timestmap Error (%s)", e.Timestamp))
}
if sid := e.SenderID; sid != nil {
var pd *ParticipantData
if reg != nil {
pd = reg.ForID(sid)
| Key | identifier_name |
types.go | nil {
reg.participantsByGaiaID = make(map[string]*ParticipantData)
}
reg.participantsByGaiaID[id] = data
}
if id := data.ID.ChatID; id != "" {
if reg.participantsByChatID == nil {
reg.participantsByChatID = make(map[string]*ParticipantData)
}
reg.participantsByChatID[id] = data
}
reg.allParticipants = append(reg.allParticipants, data)
}
func (reg *ParticipantRegistry) AllParticipants() []*ParticipantData {
return reg.allParticipants
}
func (reg *ParticipantRegistry) ForID(pid *ParticipantID) *ParticipantData {
if pid.GaiaID != "" {
if v := reg.participantsByGaiaID[pid.GaiaID]; v != nil {
return v
}
}
if pid.ChatID != "" {
if v := reg.participantsByChatID[pid.ChatID]; v != nil {
return v
}
}
return nil
}
type Conversation struct {
Conversation *ConversationEntry `json:"conversation"`
EventsMessage json.RawMessage `json:"events"`
initialized bool
reg ParticipantRegistry
events []json.RawMessage
decodedEvents []*Event
}
func (ce *Conversation) initialize() error {
if ce.initialized {
return nil
}
if err := json.Unmarshal([]byte(ce.EventsMessage), &ce.events); err != nil {
return err
}
ce.decodedEvents = make([]*Event, len(ce.events))
for _, pd := range ce.Conversation.ConversationInfo.ParticipantData {
ce.reg.Register(pd)
}
ce.initialized = true
return nil
}
func (ce *Conversation) ParticipantRegistry() *ParticipantRegistry { return &ce.reg }
func (ce *Conversation) EventsSize() int {
return len(ce.events)
}
func (ce *Conversation) ResolveAll() error {
for i := 0; i < len(ce.events); i++ {
_, err := ce.Event(i)
if err != nil {
return err
}
}
return nil
}
func (ce *Conversation) Event(i int) (*Event, error) {
if i < 0 || i >= len(ce.events) {
return nil, errors.New("Index out of bounds")
}
if ce.decodedEvents[i] == nil |
return ce.decodedEvents[i], nil
}
type ConversationEntry struct {
ConversationInfo *ConversationInfo `json:"conversation"`
}
type SingleID struct {
ID string `json:"id"`
}
type ConversationInfo struct {
ID *SingleID `json:"id"`
Type string `json:"type"`
Name string `json:"name"`
CurrentParticipant []*ParticipantID `json:"current_participant"`
ParticipantData []*ParticipantData `json:"participant_data"`
}
type ParticipantID struct {
GaiaID string `json:"gaia_id"`
ChatID string `json:"chat_id"`
}
func (pid *ParticipantID) String() string {
return fmt.Sprintf("gaia:%s/chat:%s", pid.GaiaID, pid.ChatID)
}
// Matches returns true if pid's Gaia or Chat ID are both populated and match
// the equivalent values in other.
func (pid *ParticipantID) Matches(other *ParticipantID) bool {
if pid.GaiaID != "" && pid.GaiaID == other.GaiaID {
return true
}
if pid.ChatID != "" && pid.ChatID == other.ChatID {
return true
}
return false
}
type ParticipantData struct {
ID ParticipantID `json:"id"`
FallbackName string `json:"fallback_name"`
ParticipantType string `json:"participant_type"`
DomainID string `json:"domain_id"`
}
func (pd *ParticipantData) DisplayName() string {
return pd.FallbackName
}
type MessageContentSegment struct {
Type string `json:"type"`
Text string `json:"text"`
Formatting struct {
Bold bool `json:"bold"`
Italics bool `json:"italics"`
Strikethrough bool `json:"strikethrough"`
Underline bool `json:"underline"`
} `json:"formatting"`
LinkData *struct {
LinkTarget string `json:"link_target"`
} `json:"link_data"`
}
type Thumbnail struct {
URL string `json:"url"`
ImageURL string `json:"image_url"`
WidthPx int64 `json:"width_px"`
HeightPx int64 `json:"height_px"`
}
type PlusPhoto struct {
Thumbnail *Thumbnail `json:"thumbnail"`
OwnerObfuscatedID string `json:"owner_obfuscated_id"`
AlbumID string `json:"album_id"`
PhotoID string `json:"photo_id"`
URL string `json:"url"`
OriginalContentURL string `json:"original_content_url"`
MediaType string `json:"media_type"`
}
type GeoCoordinatesV2 struct {
Latitude float64 `json:"latitude"`
Longitude float64 `json:"longitude"`
}
type PostalAddressV2 struct {
StreetAddress string `json:"street_address"`
Name string `json:"name"`
AddressCountry string `json:"address_country"`
AddressLocality string `json:"address_locality"`
AddressRegion string `json:"address_region"`
PostalCode string `json:"postal_code"`
}
type ImageObjectV2 struct {
URL string `json:"url"`
}
type PlaceV2 struct {
URL string `json:"url"`
Name string `json:"name"`
Address *struct {
PostalAddressV2 PostalAddressV2 `json:"postal_address_v2"`
} `json:"address"`
Geo *struct {
GeoCoordinatesV2 GeoCoordinatesV2 `json:"geo_coordinates_v2"`
} `json:"geo"`
ID string `json:"id"`
ImageObjectV2 *ImageObjectV2 `json:"image_object_v2"`
}
type RepresentativeImage struct {
Type []EmbedItemType `json:"type"`
ID string `json:"id"`
ImageObjectV2 *ImageObjectV2 `json:"image_object_v2"`
}
type ThingV2 struct {
URL string `json:"url"`
Name string `json:"name"`
RepresentativeImage *RepresentativeImage `json:"representative_image"`
}
type EmbedItem struct {
Type []EmbedItemType `json:"type"`
ID string `json:"id"`
PlusPhoto *PlusPhoto `json:"plus_photo"`
PlaceV2 *PlaceV2 `json:"place_v2"`
ThingV2 *ThingV2 `json:"thing_v2"`
ImageObjectV2 *ImageObjectV2 `json:"image_object_v2"`
}
func (ei *EmbedItem) Key() string {
if pp := ei.PlusPhoto; pp != nil {
return fmt.Sprintf("%s:%s", pp.AlbumID, pp.PhotoID)
}
if p := ei.ThingV2; p != nil {
// Use a hash of the Thing's URL.
return util.HashForKey(p.URL)
}
return ei.ID
}
type MessageContentAttachment struct {
EmbedItem *EmbedItem `json:"embed_item"`
ID string `json:"id"`
}
type MessageContent struct {
Segment []*MessageContentSegment `json:"segment"`
Attachment []*MessageContentAttachment `json:"attachment"`
}
type ChatMessage struct {
MessageContent *MessageContent `json:"message_content"`
}
type ConversationRename struct {
NewName string `json:"new_name"`
OldName string `json:"old_name"`
}
type MembershipChange struct {
Type string `json:"type"`
ParticipantID []*ParticipantID `json:"participant_id"`
LeaveReason string `json:"leave_reason"`
}
type Event struct {
ConversationID *SingleID `json:"conversation_id"`
SenderID *ParticipantID `json:"sender_id"`
Timestamp string `json:"timestamp"`
ConversationRename *ConversationRename `json:"conversation_rename"`
ChatMessage *ChatMessage `json:"chat_message"`
MembershipChange *MembershipChange `json:"membership_change"`
EventID string `json:"event_id"`
EventType EventType `json:"event_type"`
}
func (e *Event) Time() (time.Time, error) {
// Timestamp is in microseconds from epoch.
micros, err := strconv.ParseInt(e.Timestamp, 10, 64)
if err != nil {
return time.Time{}, err
}
return time.Unix(0, micros*1000), nil
}
func (e *Event) Description(reg *ParticipantRegistry) (string, error) {
var parts []string
// Time
switch t, err := e.Time(); err {
case nil:
parts = append(parts, t.In(time.Local).Format(time.RFC3339Nano))
default:
parts = append(parts, fmt.Sprintf("Timestmap Error (%s)", e.Timestamp))
}
if sid := e.SenderID; sid != nil {
var pd *ParticipantData
if reg != nil {
pd = reg.ForID(sid)
| {
var event Event
if err := json.Unmarshal(ce.events[i], &event); err != nil {
return nil, err
}
ce.decodedEvents[i] = &event
} | conditional_block |
types.go | nil {
reg.participantsByGaiaID = make(map[string]*ParticipantData)
}
reg.participantsByGaiaID[id] = data
}
if id := data.ID.ChatID; id != "" {
if reg.participantsByChatID == nil {
reg.participantsByChatID = make(map[string]*ParticipantData)
}
reg.participantsByChatID[id] = data
}
reg.allParticipants = append(reg.allParticipants, data)
}
func (reg *ParticipantRegistry) AllParticipants() []*ParticipantData {
return reg.allParticipants
}
func (reg *ParticipantRegistry) ForID(pid *ParticipantID) *ParticipantData {
if pid.GaiaID != "" {
if v := reg.participantsByGaiaID[pid.GaiaID]; v != nil {
return v
}
}
if pid.ChatID != "" {
if v := reg.participantsByChatID[pid.ChatID]; v != nil {
return v
}
}
return nil
}
type Conversation struct {
Conversation *ConversationEntry `json:"conversation"`
EventsMessage json.RawMessage `json:"events"`
initialized bool
reg ParticipantRegistry
events []json.RawMessage
decodedEvents []*Event
}
func (ce *Conversation) initialize() error {
if ce.initialized {
return nil
}
if err := json.Unmarshal([]byte(ce.EventsMessage), &ce.events); err != nil {
return err
}
ce.decodedEvents = make([]*Event, len(ce.events))
for _, pd := range ce.Conversation.ConversationInfo.ParticipantData {
ce.reg.Register(pd)
}
ce.initialized = true
return nil
}
func (ce *Conversation) ParticipantRegistry() *ParticipantRegistry { return &ce.reg }
func (ce *Conversation) EventsSize() int {
return len(ce.events)
}
func (ce *Conversation) ResolveAll() error {
for i := 0; i < len(ce.events); i++ {
_, err := ce.Event(i)
if err != nil {
return err
}
}
return nil
}
func (ce *Conversation) Event(i int) (*Event, error) {
if i < 0 || i >= len(ce.events) {
return nil, errors.New("Index out of bounds")
}
if ce.decodedEvents[i] == nil {
var event Event
if err := json.Unmarshal(ce.events[i], &event); err != nil {
return nil, err
}
ce.decodedEvents[i] = &event
}
return ce.decodedEvents[i], nil
}
type ConversationEntry struct {
ConversationInfo *ConversationInfo `json:"conversation"`
}
type SingleID struct {
ID string `json:"id"`
}
type ConversationInfo struct {
ID *SingleID `json:"id"`
Type string `json:"type"`
Name string `json:"name"`
CurrentParticipant []*ParticipantID `json:"current_participant"`
ParticipantData []*ParticipantData `json:"participant_data"`
}
type ParticipantID struct {
GaiaID string `json:"gaia_id"`
ChatID string `json:"chat_id"`
}
func (pid *ParticipantID) String() string {
return fmt.Sprintf("gaia:%s/chat:%s", pid.GaiaID, pid.ChatID)
}
// Matches returns true if pid's Gaia or Chat ID are both populated and match
// the equivalent values in other.
func (pid *ParticipantID) Matches(other *ParticipantID) bool {
if pid.GaiaID != "" && pid.GaiaID == other.GaiaID {
return true
}
if pid.ChatID != "" && pid.ChatID == other.ChatID {
return true
}
return false
}
type ParticipantData struct {
ID ParticipantID `json:"id"`
FallbackName string `json:"fallback_name"`
ParticipantType string `json:"participant_type"`
DomainID string `json:"domain_id"`
}
func (pd *ParticipantData) DisplayName() string {
return pd.FallbackName
}
type MessageContentSegment struct {
Type string `json:"type"`
Text string `json:"text"`
Formatting struct {
Bold bool `json:"bold"`
Italics bool `json:"italics"`
Strikethrough bool `json:"strikethrough"`
Underline bool `json:"underline"`
} `json:"formatting"`
LinkData *struct {
LinkTarget string `json:"link_target"`
} `json:"link_data"`
}
type Thumbnail struct {
URL string `json:"url"`
ImageURL string `json:"image_url"`
WidthPx int64 `json:"width_px"`
HeightPx int64 `json:"height_px"`
}
type PlusPhoto struct {
Thumbnail *Thumbnail `json:"thumbnail"`
OwnerObfuscatedID string `json:"owner_obfuscated_id"`
AlbumID string `json:"album_id"`
PhotoID string `json:"photo_id"`
URL string `json:"url"`
OriginalContentURL string `json:"original_content_url"`
MediaType string `json:"media_type"`
}
type GeoCoordinatesV2 struct {
Latitude float64 `json:"latitude"`
Longitude float64 `json:"longitude"`
}
type PostalAddressV2 struct {
StreetAddress string `json:"street_address"`
Name string `json:"name"`
AddressCountry string `json:"address_country"`
AddressLocality string `json:"address_locality"`
AddressRegion string `json:"address_region"`
PostalCode string `json:"postal_code"`
}
type ImageObjectV2 struct {
URL string `json:"url"`
}
type PlaceV2 struct {
URL string `json:"url"`
Name string `json:"name"`
Address *struct {
PostalAddressV2 PostalAddressV2 `json:"postal_address_v2"`
} `json:"address"`
Geo *struct {
GeoCoordinatesV2 GeoCoordinatesV2 `json:"geo_coordinates_v2"`
} `json:"geo"`
ID string `json:"id"`
ImageObjectV2 *ImageObjectV2 `json:"image_object_v2"`
}
type RepresentativeImage struct {
Type []EmbedItemType `json:"type"`
ID string `json:"id"`
ImageObjectV2 *ImageObjectV2 `json:"image_object_v2"`
}
type ThingV2 struct {
URL string `json:"url"`
Name string `json:"name"`
RepresentativeImage *RepresentativeImage `json:"representative_image"`
}
type EmbedItem struct {
Type []EmbedItemType `json:"type"`
ID string `json:"id"`
PlusPhoto *PlusPhoto `json:"plus_photo"`
PlaceV2 *PlaceV2 `json:"place_v2"`
ThingV2 *ThingV2 `json:"thing_v2"`
ImageObjectV2 *ImageObjectV2 `json:"image_object_v2"`
}
func (ei *EmbedItem) Key() string {
if pp := ei.PlusPhoto; pp != nil {
return fmt.Sprintf("%s:%s", pp.AlbumID, pp.PhotoID)
}
if p := ei.ThingV2; p != nil {
// Use a hash of the Thing's URL.
return util.HashForKey(p.URL)
}
return ei.ID
}
type MessageContentAttachment struct {
EmbedItem *EmbedItem `json:"embed_item"` |
type MessageContent struct {
Segment []*MessageContentSegment `json:"segment"`
Attachment []*MessageContentAttachment `json:"attachment"`
}
type ChatMessage struct {
MessageContent *MessageContent `json:"message_content"`
}
type ConversationRename struct {
NewName string `json:"new_name"`
OldName string `json:"old_name"`
}
type MembershipChange struct {
Type string `json:"type"`
ParticipantID []*ParticipantID `json:"participant_id"`
LeaveReason string `json:"leave_reason"`
}
type Event struct {
ConversationID *SingleID `json:"conversation_id"`
SenderID *ParticipantID `json:"sender_id"`
Timestamp string `json:"timestamp"`
ConversationRename *ConversationRename `json:"conversation_rename"`
ChatMessage *ChatMessage `json:"chat_message"`
MembershipChange *MembershipChange `json:"membership_change"`
EventID string `json:"event_id"`
EventType EventType `json:"event_type"`
}
func (e *Event) Time() (time.Time, error) {
// Timestamp is in microseconds from epoch.
micros, err := strconv.ParseInt(e.Timestamp, 10, 64)
if err != nil {
return time.Time{}, err
}
return time.Unix(0, micros*1000), nil
}
func (e *Event) Description(reg *ParticipantRegistry) (string, error) {
var parts []string
// Time
switch t, err := e.Time(); err {
case nil:
parts = append(parts, t.In(time.Local).Format(time.RFC3339Nano))
default:
parts = append(parts, fmt.Sprintf("Timestmap Error (%s)", e.Timestamp))
}
if sid := e.SenderID; sid != nil {
var pd *ParticipantData
if reg != nil {
pd = reg.ForID(sid)
| ID string `json:"id"`
} | random_line_split |
lib.rs | /// assert_eq!( select1(0, 0x0000_0000_0000_0002), Some(1) );
/// assert_eq!( select1(0, 0x0000_0000_0000_0004), Some(2) );
/// assert_eq!( select1(2, 0x0000_0000_0000_0004), None );
/// assert_eq!( select1(2, 0x0000_1010_1010_0114), Some(8) );
/// assert_eq!( select1(3, 0x0000_1010_1010_0114), Some(20) );
/// assert_eq!( select1(4, 0x0000_1010_1010_0114), Some(28) );
/// ```
#[inline]
pub fn select1(r: usize, x: u64) -> Option<usize> {
let result = select1_raw(r, x);
if result == 72 {None} else {Some(result)}
}
/// Finds the index of the `r`th one bit in `x`, returning 72 when not found.
///
/// Branchless. Uses the broadword algorithm from Vigna.
/// Note that bits are numbered from least-significant to most.
#[inline]
#[allow(clippy::many_single_char_names)]
pub fn select1_raw(r: usize, x: u64) -> usize {
let r = r as u64;
let mut s = x - ((x & 0xAAAA_AAAA_AAAA_AAAA) >> 1);
s = (s & 0x3333_3333_3333_3333) + ((s >> 2) & 0x3333_3333_3333_3333);
s = ((s + (s >> 4)) & 0x0F0F_0F0F_0F0F_0F0F).wrapping_mul(L8);
let b = (i_le8(s, r.wrapping_mul(L8)) >> 7).wrapping_mul(L8)>> 53 & !7;
let l = r - ((s << 8).wrapping_shr(b as u32) & 0xFF);
s = (u_nz8((x.wrapping_shr(b as u32) & 0xFF)
.wrapping_mul(L8) & 0x8040_2010_0804_0201) >> 7)
.wrapping_mul(L8);
(b + ((i_le8(s, l.wrapping_mul(L8)) >> 7).wrapping_mul(L8) >> 56)) as usize
}
/// Parallel ≤, treating a `u64` as a vector of 8 `u8`s.
///
/// Branchless.
///
/// # Examples
///
/// ```
/// use broadword::u_le8;
///
/// assert_eq!( u_le8(0x03_03_04_17_92_A0_A0_A1,
/// 0x04_03_03_92_17_A0_A0_A0),
/// 0x80_80_00_80_00_80_80_00 );
/// ```
#[inline]
pub fn u_le8(x: u64, y: u64) -> u64 {
((((y | H8) - (x & !H8)) | (x ^ y)) ^ (x & !y)) & H8
}
/// Parallel ≤, treating a `u64` as a vector of 8 `i8`s.
///
/// Branchless.
///
/// # Examples
///
/// ```
/// use broadword::i_le8;
///
/// assert_eq!( i_le8(0x03_03_04_00_FF_A0_A0_A1,
/// 0x04_03_03_FF_00_A0_A0_A0),
/// 0x80_80_00_00_80_80_80_00 );
/// ```
#[inline]
pub fn i_le8(x: u64, y: u64) -> u64 {
(((y | H8) - (x & !H8)) ^ x ^ y) & H8
}
/// Parallel >0, treating a `u64` as a vector of 8 `u8`s.
///
/// Branchless.
///
/// # Examples
///
/// ```
/// use broadword::u_nz8;
///
/// assert_eq!( u_nz8(0x00_01_A9_40_20_17_00_06),
/// 0x00_80_80_80_80_80_00_80 );
#[inline]
pub fn u_nz8(x: u64) -> u64 {
(((x | H8) - L8) | x) & H8
}
#[cfg(test)]
#[allow(clippy::many_single_char_names)]
mod test {
use std::hash::{Hash, Hasher};
use std::collections::hash_map::DefaultHasher;
use quickcheck::TestResult;
use super::*;
#[test]
fn count_ones_0() {
assert_eq!(0, count_ones(0));
}
#[test]
fn count_ones_1() {
assert_eq!(1, count_ones(1));
}
#[test]
fn count_ones_0000_0000_0000_0010() {
assert_eq!(1, count_ones(0x0000_0000_0000_0010));
}
#[test]
fn count_ones_1000_0000_0000_0000() {
assert_eq!(1, count_ones(0x1000_0000_0000_0000));
}
#[test]
fn count_ones_ffff_ffff_ffff_ffff() {
assert_eq!(64, count_ones(0xFFFF_FFFF_FFFF_FFFF));
}
fn count_ones_prop_base(word: u64) -> bool {
count_ones(word) == word.count_ones() as usize
}
quickcheck! {
fn count_ones_prop(word: u64) -> bool {
count_ones_prop_base(word)
}
fn count_ones_prop_hash(word: u64) -> bool {
count_ones_prop_base(hash(&word))
}
}
#[test]
fn select1_0_0() {
assert_eq!(None, select1(0, 0));
}
#[test]
fn select1_0_1() {
assert_eq!(Some(0), select1(0, 1));
}
#[test]
fn select1_0_2() {
assert_eq!(Some(1), select1(0, 2));
}
#[test]
fn select1_0_3() {
assert_eq!(Some(0), select1(0, 3));
}
#[test]
fn select1_1_2() {
assert_eq!(None, select1(1, 2));
}
#[test]
fn select1_1_3() {
assert_eq!(Some(1), select1(1, 3));
}
#[test]
fn select1_3_13() {
assert_eq!(None, select1(3, 0b1101));
}
fn select1_slow(r: usize, x: u64) -> Option<usize> {
let mut count = 0;
for index in 0 .. 64 {
if (x >> index) & 1 == 1 {
count += 1;
}
if count == r + 1 {
return Some(index);
}
}
None
}
fn select1_prop_base(r: u8, x: u64) -> TestResult {
if r > 64 { return TestResult::discard(); }
TestResult::from_bool(
select1(r as usize, x) == select1_slow(r as usize, x))
}
quickcheck! {
fn select1_prop(r: u8, x: u64) -> TestResult {
select1_prop_base(r, x)
}
fn select1_prop_hash(r: u8, x: u64) -> TestResult {
select1_prop_base(r, hash(&x))
}
}
fn get_bits(x: u64, i: u8, n: u8) -> u64 {
let mask = if n == 64 {!0} else {(1 << n) - 1};
(x >> i) & mask | random_line_split | ||
lib.rs | : u64) -> TestResult {
if r > 64 { return TestResult::discard(); }
TestResult::from_bool(
select1(r as usize, x) == select1_slow(r as usize, x))
}
quickcheck! {
fn select1_prop(r: u8, x: u64) -> TestResult {
select1_prop_base(r, x)
}
fn select1_prop_hash(r: u8, x: u64) -> TestResult {
select1_prop_base(r, hash(&x))
}
}
fn get_bits(x: u64, i: u8, n: u8) -> u64 {
let mask = if n == 64 {!0} else {(1 << n) - 1};
(x >> i) & mask
}
quickcheck! {
fn u_nz8_prop(argument: (u64, u64, u64, u64)) -> bool {
let n = hash(&argument);
let r = u_nz8(n);
for i in 0..8 {
let ni = get_bits(n, 8 * i, 8);
let ri = get_bits(r, 8 * i, 8);
if (ni != 0) != (ri == 0x80) {
return false;
}
}
true
}
}
#[test]
fn u_nz8_works() {
assert_eq!(b(0, 0, 0, 0, 0, 0, 0, 0),
u_nz8(u(0, 0, 0, 0, 0, 0, 0, 0)));
assert_eq!(b( 1, 1, 0, 1, 0, 1, 1, 1),
u_nz8(u(45, 12, 0, 129, 0, 3, 80, 1)));
assert_eq!(b(1, 1, 1, 1, 1, 1, 1, 1),
u_nz8(u(1, 2, 3, 4, 5, 6, 7, 8)));
assert_eq!(b( 1, 1, 1, 1, 0, 1, 1, 1),
u_nz8(0xFF_FF_FF_FF_00_FF_FF_FF));
}
fn u_le8_prop_base(n: u64, m: u64) -> bool {
let r = u_le8(n, m);
for i in 0..8 {
let ni = get_bits(n, 8 * i, 8);
let mi = get_bits(m, 8 * i, 8);
let ri = get_bits(r, 8 * i, 8);
if (ni <= mi) != (ri == 0x80) {
return false;
}
}
true
}
quickcheck! {
fn u_le8_prop(n: u64, m: u64) -> bool {
u_le8_prop_base(n, m)
}
fn u_le8_prop_hashed(n: (u64, u64, u64, u64),
m: (u64, u64, u64, u64)) -> bool {
let n = hash(&n);
let m = hash(&m);
u_le8_prop_base(n, m)
}
}
#[test]
fn le8_works() {
assert_eq!(b( 1, 1, 1, 1, 0, 0, 0, 0),
i_le8(i(0, 0, 0, 0, 0, 0, 0, 0),
i( 3, 2, 1, 0, -1, -2, -3, -4)));
assert_eq!(b( 0, 0, 0, 1, 1, 1, 1, 1),
i_le8(i(3, 2, 1, 0, -1, -2, -3, -4),
i( 0, 0, 0, 0, 0, 0, 0, 0)));
assert_eq!(b( 0, 0, 1, 1, 1, 1, 1, 1),
i_le8(i(19, 18, 17, 16, 15, 0, -1, -2),
i(17, 17, 17, 17, 17, 17, 17, 17)));
assert_eq!(b( 1, 1, 0, 0, 0, 0, 0, 0),
i_le8(i(-9, -8, -7, 0, 1, 2, 3, 4),
i(-8, -8, -8, -8, -8, -8, -8, -8)));
assert_eq!(b( 0, 1, 0, 1, 1, 0, 1, 0),
i_le8(i(8, 3, 46, 0, 0, 0, -6, -1),
i( 7, 3, 24, 1, 0, -9, 5, -2)));
}
#[test]
fn u_le8_works() {
assert_eq!(b( 1, 1, 1, 1, 1, 1, 1, 1),
u_le8(u( 0, 0, 0, 0, 0, 0, 0, 0),
u( 7, 6, 5, 4, 3, 2, 1, 0)));
assert_eq!(b( 1, 0, 0, 0, 0, 0, 0, 0),
u_le8(u( 0, 1, 2, 3, 4, 5, 6, 7),
u( 0, 0, 0, 0, 0, 0, 0, 0)));
assert_eq!(b( 0, 0, 1, 1, 1, 1, 1, 1),
u_le8(u(19, 18, 17, 16, 15, 14, 13, 12),
u(17, 17, 17, 17, 17, 17, 17, 17)));
assert_eq!(b( 0, 1, 0, 1, 1, 0, 1, 0),
u_le8(u( 8, 3, 46, 0, 0, 9, 3, 2),
u( 7, 3, 24, 1, 0, 0, 5, 1)));
}
/// Helpers for creating u64s.
fn b(a: u64, b: u64, c: u64, d: u64,
e: u64, f: u64, g: u64, h: u64) -> u64 {
(a << 63) | (b << 55) | (c << 47) | (d << 39) |
(e << 31) | (f << 23) | (g << 15) | (h << 7)
}
fn u(a: u8, b: u8, c: u8, d: u8,
e: u8, f: u8, g: u8, h: u8) -> u64 {
((a | as u64) << 56)
| ((b as u64) << 48)
| ((c as u64) << 40)
| ((d as u64) << 32)
| ((e as u64) << 24)
| ((f as u64) << 16)
| ((g as u64) << 8)
| (h as u64)
}
fn i(a: | identifier_body | |
lib.rs | /// Uses the broadword algorithm from Vigna.
/// Note that bits are numbered from least-significant to most.
///
/// # Examples
///
/// ```
/// use broadword::select1;
///
/// assert_eq!( select1(0, 0x0000_0000_0000_0000), None );
/// assert_eq!( select1(0, 0x0000_0000_0000_0001), Some(0) );
/// assert_eq!( select1(0, 0x0000_0000_0000_0002), Some(1) );
/// assert_eq!( select1(0, 0x0000_0000_0000_0004), Some(2) );
/// assert_eq!( select1(2, 0x0000_0000_0000_0004), None );
/// assert_eq!( select1(2, 0x0000_1010_1010_0114), Some(8) );
/// assert_eq!( select1(3, 0x0000_1010_1010_0114), Some(20) );
/// assert_eq!( select1(4, 0x0000_1010_1010_0114), Some(28) );
/// ```
#[inline]
pub fn select1(r: usize, x: u64) -> Option<usize> {
let result = select1_raw(r, x);
if result == 72 {None} else {Some(result)}
}
/// Finds the index of the `r`th one bit in `x`, returning 72 when not found.
///
/// Branchless. Uses the broadword algorithm from Vigna.
/// Note that bits are numbered from least-significant to most.
#[inline]
#[allow(clippy::many_single_char_names)]
pub fn select1_raw(r: usize, x: u64) -> usize {
let r = r as u64;
let mut s = x - ((x & 0xAAAA_AAAA_AAAA_AAAA) >> 1);
s = (s & 0x3333_3333_3333_3333) + ((s >> 2) & 0x3333_3333_3333_3333);
s = ((s + (s >> 4)) & 0x0F0F_0F0F_0F0F_0F0F).wrapping_mul(L8);
let b = (i_le8(s, r.wrapping_mul(L8)) >> 7).wrapping_mul(L8)>> 53 & !7;
let l = r - ((s << 8).wrapping_shr(b as u32) & 0xFF);
s = (u_nz8((x.wrapping_shr(b as u32) & 0xFF)
.wrapping_mul(L8) & 0x8040_2010_0804_0201) >> 7)
.wrapping_mul(L8);
(b + ((i_le8(s, l.wrapping_mul(L8)) >> 7).wrapping_mul(L8) >> 56)) as usize
}
/// Parallel ≤, treating a `u64` as a vector of 8 `u8`s.
///
/// Branchless.
///
/// # Examples
///
/// ```
/// use broadword::u_le8;
///
/// assert_eq!( u_le8(0x03_03_04_17_92_A0_A0_A1,
/// 0x04_03_03_92_17_A0_A0_A0),
/// 0x80_80_00_80_00_80_80_00 );
/// ```
#[inline]
pub fn u_le8(x: u64, y: u64) -> u64 {
((((y | H8) - (x & !H8)) | (x ^ y)) ^ (x & !y)) & H8
}
/// Parallel ≤, treating a `u64` as a vector of 8 `i8`s.
///
/// Branchless.
///
/// # Examples
///
/// ```
/// use broadword::i_le8;
///
/// assert_eq!( i_le8(0x03_03_04_00_FF_A0_A0_A1,
/// 0x04_03_03_FF_00_A0_A0_A0),
/// 0x80_80_00_00_80_80_80_00 );
/// ```
#[inline]
pub fn i_le8(x: u64, y: u64) -> u64 {
(((y | H8) - (x & !H8)) ^ x ^ y) & H8
}
/// Parallel >0, treating a `u64` as a vector of 8 `u8`s.
///
/// Branchless.
///
/// # Examples
///
/// ```
/// use broadword::u_nz8;
///
/// assert_eq!( u_nz8(0x00_01_A9_40_20_17_00_06),
/// 0x00_80_80_80_80_80_00_80 );
#[inline]
pub fn u_nz8(x: u64) -> u64 {
(((x | H8) - L8) | x) & H8
}
#[cfg(test)]
#[allow(clippy::many_single_char_names)]
mod test {
use std::hash::{Hash, Hasher};
use std::collections::hash_map::DefaultHasher;
use quickcheck::TestResult;
use super::*;
#[test]
fn count_ones_0() {
assert_eq!(0, count_ones(0));
}
#[test]
fn count_ones_1() {
assert_eq!(1, count_ones(1));
}
#[test]
fn count_ones_0000_0000_0000_0010() {
assert_eq!(1, count_ones(0x0000_0000_0000_0010));
}
#[test]
fn count_ones_1000_0000_0000_0000() {
assert_eq!(1, count_ones(0x1000_0000_0000_0000));
}
#[test]
fn count_ones_fff | ssert_eq!(64, count_ones(0xFFFF_FFFF_FFFF_FFFF));
}
fn count_ones_prop_base(word: u64) -> bool {
count_ones(word) == word.count_ones() as usize
}
quickcheck! {
fn count_ones_prop(word: u64) -> bool {
count_ones_prop_base(word)
}
fn count_ones_prop_hash(word: u64) -> bool {
count_ones_prop_base(hash(&word))
}
}
#[test]
fn select1_0_0() {
assert_eq!(None, select1(0, 0));
}
#[test]
fn select1_0_1() {
assert_eq!(Some(0), select1(0, 1));
}
#[test]
fn select1_0_2() {
assert_eq!(Some(1), select1(0, 2));
}
#[test]
fn select1_0_3() {
assert_eq!(Some(0), select1(0, 3));
}
#[test]
fn select1_1_2() {
assert_eq!(None, select1(1, 2));
}
#[test]
fn select1_1_3() {
assert_eq!(Some(1), select1(1, 3));
}
#[test]
fn select1_3_13() {
assert_eq!(None, select1(3, 0b1101));
}
fn select1_slow(r: usize, x: u64) -> Option<usize> {
let mut count = 0;
for index in 0 .. 64 {
if (x >> index) & 1 == 1 {
count += 1;
}
if count == r + 1 {
return Some(index);
}
}
None
}
fn select1_prop_base(r: u8, x: u64) -> TestResult {
if r > 64 { return TestResult::discard(); }
TestResult::from_bool(
select1(r as usize, x) == select1_slow(r as usize, x))
}
quickcheck! {
fn select1_prop(r: u | f_ffff_ffff_ffff() {
a | identifier_name |
lib.rs | /// Uses the broadword algorithm from Vigna.
/// Note that bits are numbered from least-significant to most.
///
/// # Examples
///
/// ```
/// use broadword::select1;
///
/// assert_eq!( select1(0, 0x0000_0000_0000_0000), None );
/// assert_eq!( select1(0, 0x0000_0000_0000_0001), Some(0) );
/// assert_eq!( select1(0, 0x0000_0000_0000_0002), Some(1) );
/// assert_eq!( select1(0, 0x0000_0000_0000_0004), Some(2) );
/// assert_eq!( select1(2, 0x0000_0000_0000_0004), None );
/// assert_eq!( select1(2, 0x0000_1010_1010_0114), Some(8) );
/// assert_eq!( select1(3, 0x0000_1010_1010_0114), Some(20) );
/// assert_eq!( select1(4, 0x0000_1010_1010_0114), Some(28) );
/// ```
#[inline]
pub fn select1(r: usize, x: u64) -> Option<usize> {
let result = select1_raw(r, x);
if result == 72 {None} else {Some(resu | nds the index of the `r`th one bit in `x`, returning 72 when not found.
///
/// Branchless. Uses the broadword algorithm from Vigna.
/// Note that bits are numbered from least-significant to most.
#[inline]
#[allow(clippy::many_single_char_names)]
pub fn select1_raw(r: usize, x: u64) -> usize {
let r = r as u64;
let mut s = x - ((x & 0xAAAA_AAAA_AAAA_AAAA) >> 1);
s = (s & 0x3333_3333_3333_3333) + ((s >> 2) & 0x3333_3333_3333_3333);
s = ((s + (s >> 4)) & 0x0F0F_0F0F_0F0F_0F0F).wrapping_mul(L8);
let b = (i_le8(s, r.wrapping_mul(L8)) >> 7).wrapping_mul(L8)>> 53 & !7;
let l = r - ((s << 8).wrapping_shr(b as u32) & 0xFF);
s = (u_nz8((x.wrapping_shr(b as u32) & 0xFF)
.wrapping_mul(L8) & 0x8040_2010_0804_0201) >> 7)
.wrapping_mul(L8);
(b + ((i_le8(s, l.wrapping_mul(L8)) >> 7).wrapping_mul(L8) >> 56)) as usize
}
/// Parallel ≤, treating a `u64` as a vector of 8 `u8`s.
///
/// Branchless.
///
/// # Examples
///
/// ```
/// use broadword::u_le8;
///
/// assert_eq!( u_le8(0x03_03_04_17_92_A0_A0_A1,
/// 0x04_03_03_92_17_A0_A0_A0),
/// 0x80_80_00_80_00_80_80_00 );
/// ```
#[inline]
pub fn u_le8(x: u64, y: u64) -> u64 {
((((y | H8) - (x & !H8)) | (x ^ y)) ^ (x & !y)) & H8
}
/// Parallel ≤, treating a `u64` as a vector of 8 `i8`s.
///
/// Branchless.
///
/// # Examples
///
/// ```
/// use broadword::i_le8;
///
/// assert_eq!( i_le8(0x03_03_04_00_FF_A0_A0_A1,
/// 0x04_03_03_FF_00_A0_A0_A0),
/// 0x80_80_00_00_80_80_80_00 );
/// ```
#[inline]
pub fn i_le8(x: u64, y: u64) -> u64 {
(((y | H8) - (x & !H8)) ^ x ^ y) & H8
}
/// Parallel >0, treating a `u64` as a vector of 8 `u8`s.
///
/// Branchless.
///
/// # Examples
///
/// ```
/// use broadword::u_nz8;
///
/// assert_eq!( u_nz8(0x00_01_A9_40_20_17_00_06),
/// 0x00_80_80_80_80_80_00_80 );
#[inline]
pub fn u_nz8(x: u64) -> u64 {
(((x | H8) - L8) | x) & H8
}
#[cfg(test)]
#[allow(clippy::many_single_char_names)]
mod test {
use std::hash::{Hash, Hasher};
use std::collections::hash_map::DefaultHasher;
use quickcheck::TestResult;
use super::*;
#[test]
fn count_ones_0() {
assert_eq!(0, count_ones(0));
}
#[test]
fn count_ones_1() {
assert_eq!(1, count_ones(1));
}
#[test]
fn count_ones_0000_0000_0000_0010() {
assert_eq!(1, count_ones(0x0000_0000_0000_0010));
}
#[test]
fn count_ones_1000_0000_0000_0000() {
assert_eq!(1, count_ones(0x1000_0000_0000_0000));
}
#[test]
fn count_ones_ffff_ffff_ffff_ffff() {
assert_eq!(64, count_ones(0xFFFF_FFFF_FFFF_FFFF));
}
fn count_ones_prop_base(word: u64) -> bool {
count_ones(word) == word.count_ones() as usize
}
quickcheck! {
fn count_ones_prop(word: u64) -> bool {
count_ones_prop_base(word)
}
fn count_ones_prop_hash(word: u64) -> bool {
count_ones_prop_base(hash(&word))
}
}
#[test]
fn select1_0_0() {
assert_eq!(None, select1(0, 0));
}
#[test]
fn select1_0_1() {
assert_eq!(Some(0), select1(0, 1));
}
#[test]
fn select1_0_2() {
assert_eq!(Some(1), select1(0, 2));
}
#[test]
fn select1_0_3() {
assert_eq!(Some(0), select1(0, 3));
}
#[test]
fn select1_1_2() {
assert_eq!(None, select1(1, 2));
}
#[test]
fn select1_1_3() {
assert_eq!(Some(1), select1(1, 3));
}
#[test]
fn select1_3_13() {
assert_eq!(None, select1(3, 0b1101));
}
fn select1_slow(r: usize, x: u64) -> Option<usize> {
let mut count = 0;
for index in 0 .. 64 {
if (x >> index) & 1 == 1 {
count += 1;
}
if count == r + 1 {
return Some(index);
}
}
None
}
fn select1_prop_base(r: u8, x: u64) -> TestResult {
if r > 64 { return TestResult::discard(); }
TestResult::from_bool(
select1(r as usize, x) == select1_slow(r as usize, x))
}
quickcheck! {
fn select1_prop(r: u | lt)}
}
/// Fi | conditional_block |
uart.rs | _rxto: ReadWrite<u32, Event::Register>, // 0x144-0x148
_reserved7: [u32; 1], // 0x148-0x14C
pub event_rxstarted: ReadWrite<u32, Event::Register>, // 0x14C-0x150
pub event_txstarted: ReadWrite<u32, Event::Register>, // 0x150-0x154
_reserved8: [u32; 1], // 0x154-0x158
pub event_txstopped: ReadWrite<u32, Event::Register>, // 0x158-0x15c
_reserved9: [u32; 41], // 0x15c-0x200
pub shorts: ReadWrite<u32, Shorts::Register>, // 0x200-0x204
_reserved10: [u32; 64], // 0x204-0x304
pub intenset: ReadWrite<u32, Interrupt::Register>, // 0x304-0x308
pub intenclr: ReadWrite<u32, Interrupt::Register>, // 0x308-0x30C
_reserved11: [u32; 93], // 0x30C-0x480
pub errorsrc: ReadWrite<u32, ErrorSrc::Register>, // 0x480-0x484
_reserved12: [u32; 31], // 0x484-0x500
pub enable: ReadWrite<u32, Uart::Register>, // 0x500-0x504
_reserved13: [u32; 1], // 0x504-0x508
pub pselrts: ReadWrite<u32, Psel::Register>, // 0x508-0x50c
pub pseltxd: ReadWrite<u32, Psel::Register>, // 0x50c-0x510
pub pselcts: ReadWrite<u32, Psel::Register>, // 0x510-0x514
pub pselrxd: ReadWrite<u32, Psel::Register>, // 0x514-0x518
_reserved14: [u32; 3], // 0x518-0x524
pub baudrate: ReadWrite<u32, Baudrate::Register>, // 0x524-0x528
_reserved15: [u32; 3], // 0x528-0x534
pub rxd_ptr: ReadWrite<u32, Pointer::Register>, // 0x534-0x538
pub rxd_maxcnt: ReadWrite<u32, Counter::Register>, // 0x538-0x53c
pub rxd_amount: ReadOnly<u32, Counter::Register>, // 0x53c-0x540
_reserved16: [u32; 1], // 0x540-0x544
pub txd_ptr: ReadWrite<u32, Pointer::Register>, // 0x544-0x548
pub txd_maxcnt: ReadWrite<u32, Counter::Register>, // 0x548-0x54c
pub txd_amount: ReadOnly<u32, Counter::Register>, // 0x54c-0x550
_reserved17: [u32; 7], // 0x550-0x56C
pub config: ReadWrite<u32, Config::Register>, // 0x56C-0x570
}
#[cfg_attr(rustfmt, rustfmt_skip)]
register_bitfields! [u32,
/// Start task
Task [
ENABLE OFFSET(0) NUMBITS(1)
],
/// Read event
Event [
READY OFFSET(0) NUMBITS(1)
],
/// Shortcuts
Shorts [
// Shortcut between ENDRX and STARTRX
ENDRX_STARTRX OFFSET(5) NUMBITS(1),
// Shortcut between ENDRX and STOPRX
ENDRX_STOPRX OFFSET(6) NUMBITS(1)
],
/// UART Interrupts
Interrupt [
CTS OFFSET(0) NUMBITS(1),
NCTS OFFSET(1) NUMBITS(1),
ENDRX OFFSET(4) NUMBITS(1),
ENDTX OFFSET(8) NUMBITS(1),
ERROR OFFSET(9) NUMBITS(1),
RXTO OFFSET(17) NUMBITS(1),
RXSTARTED OFFSET(19) NUMBITS(1),
TXSTARTED OFFSET(20) NUMBITS(1),
TXSTOPPED OFFSET(22) NUMBITS(1)
],
/// UART Errors
ErrorSrc [
OVERRUN OFFSET(0) NUMBITS(1),
PARITY OFFSET(1) NUMBITS(1),
FRAMING OFFSET(2) NUMBITS(1),
BREAK OFFSET(3) NUMBITS(1)
],
/// Enable UART
Uart [
ENABLE OFFSET(0) NUMBITS(4) [
ON = 8,
OFF = 0
]
],
/// Pin select
Psel [
// Pin number
PIN OFFSET(0) NUMBITS(5),
// Connect/Disconnect
CONNECT OFFSET(31) NUMBITS(1)
],
/// Baudrate
Baudrate [
BAUDRAUTE OFFSET(0) NUMBITS(32)
],
/// DMA pointer
Pointer [
POINTER OFFSET(0) NUMBITS(32)
],
/// Counter value
Counter [
COUNTER OFFSET(0) NUMBITS(8)
],
/// Configuration of parity and flow control
Config [
HWFC OFFSET(0) NUMBITS(1),
PARITY OFFSET(1) NUMBITS(3)
]
];
/// UARTE
// It should never be instanced outside this module but because a static mutable reference to it
// is exported outside this module it must be `pub`
pub struct | {
regs: *const UarteRegisters,
client: Cell<Option<&'static kernel::hil::uart::Client>>,
buffer: kernel::common::take_cell::TakeCell<'static, [u8]>,
remaining_bytes: Cell<usize>,
offset: Cell<usize>,
}
#[derive(Copy, Clone)]
pub struct UARTParams {
pub baud_rate: u32,
}
/// UARTE0 handle
// This should only be accessed by the reset_handler on startup
pub static mut UARTE0: Uarte = Uarte::new();
impl Uarte {
/// Constructor
pub const fn new() -> Uarte {
Uarte {
regs: UARTE_BASE as *const UarteRegisters,
client: Cell::new(None),
buffer: kernel::common::take_cell::TakeCell::empty(),
remaining_bytes: Cell::new(0),
offset: Cell::new(0),
}
}
/// Configure which pins the UART should use for txd, rxd, cts and rts
pub fn configure(
&self,
txd: pinmux::Pinmux,
rxd: pinmux::Pinmux,
cts: pinmux::Pinmux,
rts: pinmux::Pinmux,
) {
let regs = unsafe { &*self.regs };
regs.pseltxd.write(Psel::PIN.val(txd.into()));
regs.pselrxd.write(Psel::PIN.val(rxd.into()));
regs.pselcts.write(Psel::PIN.val(cts.into()));
regs.pselrts.write(Psel::PIN.val(rts.into()));
}
fn set_baud_rate(&self, baud_rate: u32) {
let regs = unsafe { &*self.regs };
match baud_rate {
1200 => regs.baudrate.set(0x0004F000),
2400 => regs.baudrate.set(0x0009D000),
4800 => regs.baudrate.set(0x0013B000),
9600 => regs.baudrate.set(0x00275000),
14400 => regs.baudrate.set(0x003AF000),
19200 => regs.baudrate.set(0x004EA000),
28800 => | Uarte | identifier_name |
uart.rs | event_rxto: ReadWrite<u32, Event::Register>, // 0x144-0x148
_reserved7: [u32; 1], // 0x148-0x14C
pub event_rxstarted: ReadWrite<u32, Event::Register>, // 0x14C-0x150
pub event_txstarted: ReadWrite<u32, Event::Register>, // 0x150-0x154
_reserved8: [u32; 1], // 0x154-0x158
pub event_txstopped: ReadWrite<u32, Event::Register>, // 0x158-0x15c
_reserved9: [u32; 41], // 0x15c-0x200
pub shorts: ReadWrite<u32, Shorts::Register>, // 0x200-0x204
_reserved10: [u32; 64], // 0x204-0x304
pub intenset: ReadWrite<u32, Interrupt::Register>, // 0x304-0x308
pub intenclr: ReadWrite<u32, Interrupt::Register>, // 0x308-0x30C
_reserved11: [u32; 93], // 0x30C-0x480 | pub pselrts: ReadWrite<u32, Psel::Register>, // 0x508-0x50c
pub pseltxd: ReadWrite<u32, Psel::Register>, // 0x50c-0x510
pub pselcts: ReadWrite<u32, Psel::Register>, // 0x510-0x514
pub pselrxd: ReadWrite<u32, Psel::Register>, // 0x514-0x518
_reserved14: [u32; 3], // 0x518-0x524
pub baudrate: ReadWrite<u32, Baudrate::Register>, // 0x524-0x528
_reserved15: [u32; 3], // 0x528-0x534
pub rxd_ptr: ReadWrite<u32, Pointer::Register>, // 0x534-0x538
pub rxd_maxcnt: ReadWrite<u32, Counter::Register>, // 0x538-0x53c
pub rxd_amount: ReadOnly<u32, Counter::Register>, // 0x53c-0x540
_reserved16: [u32; 1], // 0x540-0x544
pub txd_ptr: ReadWrite<u32, Pointer::Register>, // 0x544-0x548
pub txd_maxcnt: ReadWrite<u32, Counter::Register>, // 0x548-0x54c
pub txd_amount: ReadOnly<u32, Counter::Register>, // 0x54c-0x550
_reserved17: [u32; 7], // 0x550-0x56C
pub config: ReadWrite<u32, Config::Register>, // 0x56C-0x570
}
#[cfg_attr(rustfmt, rustfmt_skip)]
register_bitfields! [u32,
/// Start task
Task [
ENABLE OFFSET(0) NUMBITS(1)
],
/// Read event
Event [
READY OFFSET(0) NUMBITS(1)
],
/// Shortcuts
Shorts [
// Shortcut between ENDRX and STARTRX
ENDRX_STARTRX OFFSET(5) NUMBITS(1),
// Shortcut between ENDRX and STOPRX
ENDRX_STOPRX OFFSET(6) NUMBITS(1)
],
/// UART Interrupts
Interrupt [
CTS OFFSET(0) NUMBITS(1),
NCTS OFFSET(1) NUMBITS(1),
ENDRX OFFSET(4) NUMBITS(1),
ENDTX OFFSET(8) NUMBITS(1),
ERROR OFFSET(9) NUMBITS(1),
RXTO OFFSET(17) NUMBITS(1),
RXSTARTED OFFSET(19) NUMBITS(1),
TXSTARTED OFFSET(20) NUMBITS(1),
TXSTOPPED OFFSET(22) NUMBITS(1)
],
/// UART Errors
ErrorSrc [
OVERRUN OFFSET(0) NUMBITS(1),
PARITY OFFSET(1) NUMBITS(1),
FRAMING OFFSET(2) NUMBITS(1),
BREAK OFFSET(3) NUMBITS(1)
],
/// Enable UART
Uart [
ENABLE OFFSET(0) NUMBITS(4) [
ON = 8,
OFF = 0
]
],
/// Pin select
Psel [
// Pin number
PIN OFFSET(0) NUMBITS(5),
// Connect/Disconnect
CONNECT OFFSET(31) NUMBITS(1)
],
/// Baudrate
Baudrate [
BAUDRAUTE OFFSET(0) NUMBITS(32)
],
/// DMA pointer
Pointer [
POINTER OFFSET(0) NUMBITS(32)
],
/// Counter value
Counter [
COUNTER OFFSET(0) NUMBITS(8)
],
/// Configuration of parity and flow control
Config [
HWFC OFFSET(0) NUMBITS(1),
PARITY OFFSET(1) NUMBITS(3)
]
];
/// UARTE
// It should never be instanced outside this module but because a static mutable reference to it
// is exported outside this module it must be `pub`
pub struct Uarte {
regs: *const UarteRegisters,
client: Cell<Option<&'static kernel::hil::uart::Client>>,
buffer: kernel::common::take_cell::TakeCell<'static, [u8]>,
remaining_bytes: Cell<usize>,
offset: Cell<usize>,
}
#[derive(Copy, Clone)]
pub struct UARTParams {
pub baud_rate: u32,
}
/// UARTE0 handle
// This should only be accessed by the reset_handler on startup
pub static mut UARTE0: Uarte = Uarte::new();
impl Uarte {
/// Constructor
pub const fn new() -> Uarte {
Uarte {
regs: UARTE_BASE as *const UarteRegisters,
client: Cell::new(None),
buffer: kernel::common::take_cell::TakeCell::empty(),
remaining_bytes: Cell::new(0),
offset: Cell::new(0),
}
}
/// Configure which pins the UART should use for txd, rxd, cts and rts
pub fn configure(
&self,
txd: pinmux::Pinmux,
rxd: pinmux::Pinmux,
cts: pinmux::Pinmux,
rts: pinmux::Pinmux,
) {
let regs = unsafe { &*self.regs };
regs.pseltxd.write(Psel::PIN.val(txd.into()));
regs.pselrxd.write(Psel::PIN.val(rxd.into()));
regs.pselcts.write(Psel::PIN.val(cts.into()));
regs.pselrts.write(Psel::PIN.val(rts.into()));
}
fn set_baud_rate(&self, baud_rate: u32) {
let regs = unsafe { &*self.regs };
match baud_rate {
1200 => regs.baudrate.set(0x0004F000),
2400 => regs.baudrate.set(0x0009D000),
4800 => regs.baudrate.set(0x0013B000),
9600 => regs.baudrate.set(0x00275000),
14400 => regs.baudrate.set(0x003AF000),
19200 => regs.baudrate.set(0x004EA000),
28800 => regs.b | pub errorsrc: ReadWrite<u32, ErrorSrc::Register>, // 0x480-0x484
_reserved12: [u32; 31], // 0x484-0x500
pub enable: ReadWrite<u32, Uart::Register>, // 0x500-0x504
_reserved13: [u32; 1], // 0x504-0x508 | random_line_split |
uart.rs | 38-0x53c
pub rxd_amount: ReadOnly<u32, Counter::Register>, // 0x53c-0x540
_reserved16: [u32; 1], // 0x540-0x544
pub txd_ptr: ReadWrite<u32, Pointer::Register>, // 0x544-0x548
pub txd_maxcnt: ReadWrite<u32, Counter::Register>, // 0x548-0x54c
pub txd_amount: ReadOnly<u32, Counter::Register>, // 0x54c-0x550
_reserved17: [u32; 7], // 0x550-0x56C
pub config: ReadWrite<u32, Config::Register>, // 0x56C-0x570
}
#[cfg_attr(rustfmt, rustfmt_skip)]
register_bitfields! [u32,
/// Start task
Task [
ENABLE OFFSET(0) NUMBITS(1)
],
/// Read event
Event [
READY OFFSET(0) NUMBITS(1)
],
/// Shortcuts
Shorts [
// Shortcut between ENDRX and STARTRX
ENDRX_STARTRX OFFSET(5) NUMBITS(1),
// Shortcut between ENDRX and STOPRX
ENDRX_STOPRX OFFSET(6) NUMBITS(1)
],
/// UART Interrupts
Interrupt [
CTS OFFSET(0) NUMBITS(1),
NCTS OFFSET(1) NUMBITS(1),
ENDRX OFFSET(4) NUMBITS(1),
ENDTX OFFSET(8) NUMBITS(1),
ERROR OFFSET(9) NUMBITS(1),
RXTO OFFSET(17) NUMBITS(1),
RXSTARTED OFFSET(19) NUMBITS(1),
TXSTARTED OFFSET(20) NUMBITS(1),
TXSTOPPED OFFSET(22) NUMBITS(1)
],
/// UART Errors
ErrorSrc [
OVERRUN OFFSET(0) NUMBITS(1),
PARITY OFFSET(1) NUMBITS(1),
FRAMING OFFSET(2) NUMBITS(1),
BREAK OFFSET(3) NUMBITS(1)
],
/// Enable UART
Uart [
ENABLE OFFSET(0) NUMBITS(4) [
ON = 8,
OFF = 0
]
],
/// Pin select
Psel [
// Pin number
PIN OFFSET(0) NUMBITS(5),
// Connect/Disconnect
CONNECT OFFSET(31) NUMBITS(1)
],
/// Baudrate
Baudrate [
BAUDRAUTE OFFSET(0) NUMBITS(32)
],
/// DMA pointer
Pointer [
POINTER OFFSET(0) NUMBITS(32)
],
/// Counter value
Counter [
COUNTER OFFSET(0) NUMBITS(8)
],
/// Configuration of parity and flow control
Config [
HWFC OFFSET(0) NUMBITS(1),
PARITY OFFSET(1) NUMBITS(3)
]
];
/// UARTE
// It should never be instanced outside this module but because a static mutable reference to it
// is exported outside this module it must be `pub`
pub struct Uarte {
regs: *const UarteRegisters,
client: Cell<Option<&'static kernel::hil::uart::Client>>,
buffer: kernel::common::take_cell::TakeCell<'static, [u8]>,
remaining_bytes: Cell<usize>,
offset: Cell<usize>,
}
#[derive(Copy, Clone)]
pub struct UARTParams {
pub baud_rate: u32,
}
/// UARTE0 handle
// This should only be accessed by the reset_handler on startup
pub static mut UARTE0: Uarte = Uarte::new();
impl Uarte {
/// Constructor
pub const fn new() -> Uarte {
Uarte {
regs: UARTE_BASE as *const UarteRegisters,
client: Cell::new(None),
buffer: kernel::common::take_cell::TakeCell::empty(),
remaining_bytes: Cell::new(0),
offset: Cell::new(0),
}
}
/// Configure which pins the UART should use for txd, rxd, cts and rts
pub fn configure(
&self,
txd: pinmux::Pinmux,
rxd: pinmux::Pinmux,
cts: pinmux::Pinmux,
rts: pinmux::Pinmux,
) {
let regs = unsafe { &*self.regs };
regs.pseltxd.write(Psel::PIN.val(txd.into()));
regs.pselrxd.write(Psel::PIN.val(rxd.into()));
regs.pselcts.write(Psel::PIN.val(cts.into()));
regs.pselrts.write(Psel::PIN.val(rts.into()));
}
fn set_baud_rate(&self, baud_rate: u32) {
let regs = unsafe { &*self.regs };
match baud_rate {
1200 => regs.baudrate.set(0x0004F000),
2400 => regs.baudrate.set(0x0009D000),
4800 => regs.baudrate.set(0x0013B000),
9600 => regs.baudrate.set(0x00275000),
14400 => regs.baudrate.set(0x003AF000),
19200 => regs.baudrate.set(0x004EA000),
28800 => regs.baudrate.set(0x0075C000),
38400 => regs.baudrate.set(0x009D0000),
57600 => regs.baudrate.set(0x00EB0000),
76800 => regs.baudrate.set(0x013A9000),
115200 => regs.baudrate.set(0x01D60000),
230400 => regs.baudrate.set(0x03B00000),
250000 => regs.baudrate.set(0x04000000),
460800 => regs.baudrate.set(0x07400000),
921600 => regs.baudrate.set(0x0F000000),
1000000 => regs.baudrate.set(0x10000000),
_ => regs.baudrate.set(0x01D60000), //setting default to 115200
}
}
// Enable UART peripheral, this need to disabled for low power applications
fn enable_uart(&self) {
let regs = unsafe { &*self.regs };
regs.enable.write(Uart::ENABLE::ON);
}
#[allow(dead_code)]
fn disable_uart(&self) {
let regs = unsafe { &*self.regs };
regs.enable.write(Uart::ENABLE::OFF);
}
#[allow(dead_code)]
fn enable_rx_interrupts(&self) {
let regs = unsafe { &*self.regs };
regs.intenset.write(Interrupt::ENDRX::SET);
}
fn enable_tx_interrupts(&self) {
let regs = unsafe { &*self.regs };
regs.intenset.write(Interrupt::ENDTX::SET);
}
#[allow(dead_code)]
fn disable_rx_interrupts(&self) {
let regs = unsafe { &*self.regs };
regs.intenclr.write(Interrupt::ENDRX::SET);
}
fn disable_tx_interrupts(&self) {
let regs = unsafe { &*self.regs };
regs.intenclr.write(Interrupt::ENDTX::SET);
}
/// UART interrupt handler that only listens to `tx_end` events
#[inline(never)]
pub fn handle_interrupt(&mut self) {
// disable interrupts
self.disable_tx_interrupts();
let regs = unsafe { &*self.regs };
if self.tx_ready() | {
regs.event_endtx.write(Event::READY::CLEAR);
let tx_bytes = regs.txd_amount.get() as usize;
let rem = self.remaining_bytes.get();
// More bytes transmitted than requested `return silently`
// Cause probably a hardware fault
// FIXME: Progate error to the capsule
if tx_bytes > rem {
debug!("error more bytes than requested\r\n");
return;
}
self.remaining_bytes.set(rem - tx_bytes);
self.offset.set(tx_bytes);
if self.remaining_bytes.get() == 0 {
// Signal client write done
self.client.get().map(|client| {
self.buffer.take().map(|buffer| { | conditional_block | |
plonk_util.rs | (x)` for a given `x`, where `n` is the injective function related to the Halo
/// endomorphism.
pub fn halo_n<C: HaloCurve>(s_bits: &[bool]) -> C::ScalarField {
// This is based on Algorithm 2 of the Halo paper, except that we start with (a, b) = (0, 0).
debug_assert_eq!(s_bits.len() % 2, 0, "Number of scalar bits must be even");
let zero = C::ScalarField::ZERO;
let mut a = zero;
let mut b = zero;
for s_bits_chunk in s_bits.chunks(2) {
let bit_lo = s_bits_chunk[0];
let bit_hi = s_bits_chunk[1];
let sign = if bit_lo {
C::ScalarField::ONE
} else {
C::ScalarField::NEG_ONE
};
let (c, d) = if bit_hi { (sign, zero) } else { (zero, sign) };
a = a.double() + c;
b = b.double() + d;
}
a * C::ZETA_SCALAR + b
}
/// Compute `[n(s)].P` for a given `s`, where `n` is the injective function related to the Halo
/// endomorphism.
pub fn halo_n_mul<C: HaloCurve>(s_bits: &[bool], p: AffinePoint<C>) -> AffinePoint<C> {
// This is based on Algorithm 1 of the Halo paper, except that we start with Acc = O.
debug_assert_eq!(s_bits.len() % 2, 0, "Number of scalar bits must be even");
let p_p = p.to_projective();
let p_n = -p_p;
let endo_p_p = p.endomorphism().to_projective();
let endo_p_n = -endo_p_p;
let mut acc = ProjectivePoint::<C>::ZERO;
for s_bits_chunk in s_bits.chunks(2) {
let bit_lo = s_bits_chunk[0];
let bit_hi = s_bits_chunk[1];
let s = if bit_hi {
if bit_lo {
endo_p_p
} else {
endo_p_n
}
} else if bit_lo {
p_p
} else {
p_n
};
acc = acc.double() + s;
}
acc.to_affine()
}
pub fn | <F: Field>(coeffs: &[F], x: F) -> F {
let mut ans = F::ZERO;
let mut x_pow = F::ONE;
for &c in coeffs {
ans = ans + (c * x_pow);
x_pow = x_pow * x;
}
ans
}
/// Compute `[x^0, x^1, ..., x^(n - 1)]`.
pub fn powers<F: Field>(x: F, n: usize) -> Vec<F> {
let mut powers = Vec::new();
let mut current = F::ONE;
for i in 0..n {
if i != 0 {
current = current * x;
}
powers.push(current);
}
powers
}
/// Compute `[x^0, x^1, ..., x^(n - 1)]`.
pub(crate) fn powers_recursive<C: HaloCurve>(
builder: &mut CircuitBuilder<C>,
x: Target<C::ScalarField>,
n: usize,
) -> Vec<Target<C::ScalarField>> {
let mut powers = Vec::new();
let mut current = builder.one_wire();
for i in 0..n {
if i != 0 {
current = builder.mul(current, x);
}
powers.push(current);
}
powers
}
/// Returns the evaluation of a list of polynomials at a point.
pub(crate) fn eval_polys<F: Field>(polys: &[Polynomial<F>], powers: &[F]) -> Vec<F> {
polys.iter().map(|p| p.eval_from_power(powers)).collect()
}
/// Zero-pad a list of `n` polynomial coefficients to a length of `8n`, which is the degree at
/// which we do most polynomial arithmetic.
pub(crate) fn pad_to_8n<F: Field>(coeffs: &[F]) -> Vec<F> {
let n = coeffs.len();
let mut result = coeffs.to_vec();
while result.len() < 8 * n {
result.push(F::ZERO);
}
result
}
pub(crate) fn values_to_polynomials<F: Field>(
values_vec: &[Vec<F>],
fft_precomputation: &FftPrecomputation<F>,
) -> Vec<Polynomial<F>> {
values_vec
.par_iter()
.map(|values| Polynomial::from_evaluations(values, fft_precomputation))
.collect()
}
pub(crate) fn polynomials_to_values_padded<F: Field>(
polys_vec: &[Polynomial<F>],
fft_precomputation: &FftPrecomputation<F>,
) -> Vec<Vec<F>> {
polys_vec
.par_iter()
.map(|poly| {
let padded_poly = poly.padded(poly.len() * 8);
padded_poly.eval_domain(fft_precomputation)
})
.collect()
}
/// Like `pedersen_commit`, but with no blinding factor.
pub fn pedersen_hash<C: Curve>(
xs: &[C::ScalarField],
pedersen_g_msm_precomputation: &MsmPrecomputation<C>,
) -> ProjectivePoint<C> {
msm_execute_parallel(pedersen_g_msm_precomputation, xs)
}
#[allow(dead_code)]
fn pedersen_commit<C: Curve>(
xs: &[C::ScalarField],
opening: C::ScalarField,
h: AffinePoint<C>,
pedersen_g_msm_precomputation: &MsmPrecomputation<C>,
) -> ProjectivePoint<C> {
// TODO: Couldn't get this working with *.
let h = h.to_projective();
let mul_precomputation = h.mul_precompute();
let blinding_term = h.mul_with_precomputation(opening, mul_precomputation);
msm_execute_parallel(pedersen_g_msm_precomputation, xs) + blinding_term
}
pub fn commit_polynomials<C: Curve>(
polynomials: &[Polynomial<C::ScalarField>],
msm_precomputation: &MsmPrecomputation<C>,
blinding_point: AffinePoint<C>,
blinding: bool,
) -> Vec<PolynomialCommitment<C>> {
PolynomialCommitment::coeffs_vec_to_commitments(
polynomials
.iter()
.map(|p| p.coeffs())
.collect::<Vec<_>>()
.as_slice(),
msm_precomputation,
blinding_point,
blinding,
)
}
// Generate Z, which is used in Plonk's permutation argument.
pub fn permutation_polynomial<F: Field>(
degree: usize,
subgroup: &[F],
witness: &Witness<F>,
sigma_values: &[Vec<F>],
beta: F,
gamma: F,
) -> Vec<F> {
let mut plonk_z_points = vec![F::ONE];
let k_is = (0..NUM_ROUTED_WIRES)
.map(get_subgroup_shift::<F>)
.collect::<Vec<_>>();
for i in 1..degree {
let x = subgroup[i - 1];
let mut numerator = F::ONE;
let mut denominator = F::ONE;
for j in 0..NUM_ROUTED_WIRES {
let wire_value = witness.get_indices(i - 1, j);
let k_i = k_is[j];
let s_id = k_i * x;
let s_sigma = sigma_values[j][8 * (i - 1)];
numerator = numerator * (wire_value + beta * s_id + gamma);
denominator = denominator * (wire_value + beta * s_sigma + gamma);
}
let last = *plonk_z_points.last().unwrap();
plonk_z_points.push(last * numerator / denominator);
}
plonk_z_points
}
pub fn sigma_polynomials<F: Field>(
sigma: Vec<usize>,
degree: usize,
subgroup_generator: F,
) -> Vec<Vec<F>> {
sigma
.chunks(degree)
.map(|chunk| {
chunk
.par_iter()
.map(|&x| {
get_subgroup_shift::<F>(x / degree) * subgroup_generator.exp_usize(x % degree)
})
.collect::<Vec<_>>()
})
.collect()
}
/// Given polynomials `[p_0,...,p_k]` of degree `degree` and `alpha \in F`, returns `\sum_{i=0}^k alpha^i p_i`.
pub(crate) fn scale_polynomials<F: Field>(
polynomials: Vec<Polynomial<F>>,
alpha: F,
degree: usize,
) -> Polynomial<F> {
let alpha_powers = powers(alpha, polynomials.len());
Polynomial::from(
(0..degree)
.map(|i| {
(0..polynomials.len())
.map(|j| polynomials[j][i] * alpha_powers[j])
.fold(F::ZERO, |acc, x| acc + x)
})
.collect::<Vec<_>>(),
)
}
#[allow(dead_code | eval_poly | identifier_name |
plonk_util.rs | ProjectivePoint<C> {
msm_execute_parallel(pedersen_g_msm_precomputation, xs)
}
#[allow(dead_code)]
fn pedersen_commit<C: Curve>(
xs: &[C::ScalarField],
opening: C::ScalarField,
h: AffinePoint<C>,
pedersen_g_msm_precomputation: &MsmPrecomputation<C>,
) -> ProjectivePoint<C> {
// TODO: Couldn't get this working with *.
let h = h.to_projective();
let mul_precomputation = h.mul_precompute();
let blinding_term = h.mul_with_precomputation(opening, mul_precomputation);
msm_execute_parallel(pedersen_g_msm_precomputation, xs) + blinding_term
}
pub fn commit_polynomials<C: Curve>(
polynomials: &[Polynomial<C::ScalarField>],
msm_precomputation: &MsmPrecomputation<C>,
blinding_point: AffinePoint<C>,
blinding: bool,
) -> Vec<PolynomialCommitment<C>> {
PolynomialCommitment::coeffs_vec_to_commitments(
polynomials
.iter()
.map(|p| p.coeffs())
.collect::<Vec<_>>()
.as_slice(),
msm_precomputation,
blinding_point,
blinding,
)
}
// Generate Z, which is used in Plonk's permutation argument.
pub fn permutation_polynomial<F: Field>(
degree: usize,
subgroup: &[F],
witness: &Witness<F>,
sigma_values: &[Vec<F>],
beta: F,
gamma: F,
) -> Vec<F> {
let mut plonk_z_points = vec![F::ONE];
let k_is = (0..NUM_ROUTED_WIRES)
.map(get_subgroup_shift::<F>)
.collect::<Vec<_>>();
for i in 1..degree {
let x = subgroup[i - 1];
let mut numerator = F::ONE;
let mut denominator = F::ONE;
for j in 0..NUM_ROUTED_WIRES {
let wire_value = witness.get_indices(i - 1, j);
let k_i = k_is[j];
let s_id = k_i * x;
let s_sigma = sigma_values[j][8 * (i - 1)];
numerator = numerator * (wire_value + beta * s_id + gamma);
denominator = denominator * (wire_value + beta * s_sigma + gamma);
}
let last = *plonk_z_points.last().unwrap();
plonk_z_points.push(last * numerator / denominator);
}
plonk_z_points
}
pub fn sigma_polynomials<F: Field>(
sigma: Vec<usize>,
degree: usize,
subgroup_generator: F,
) -> Vec<Vec<F>> {
sigma
.chunks(degree)
.map(|chunk| {
chunk
.par_iter()
.map(|&x| {
get_subgroup_shift::<F>(x / degree) * subgroup_generator.exp_usize(x % degree)
})
.collect::<Vec<_>>()
})
.collect()
}
/// Given polynomials `[p_0,...,p_k]` of degree `degree` and `alpha \in F`, returns `\sum_{i=0}^k alpha^i p_i`.
pub(crate) fn scale_polynomials<F: Field>(
polynomials: Vec<Polynomial<F>>,
alpha: F,
degree: usize,
) -> Polynomial<F> {
let alpha_powers = powers(alpha, polynomials.len());
Polynomial::from(
(0..degree)
.map(|i| {
(0..polynomials.len())
.map(|j| polynomials[j][i] * alpha_powers[j])
.fold(F::ZERO, |acc, x| acc + x)
})
.collect::<Vec<_>>(),
)
}
#[allow(dead_code)]
pub(crate) fn polynomial_degree_plus_1<F: Field>(
points: &[F],
fft_precomputation: &FftPrecomputation<F>,
) -> usize {
let coeffs = ifft_with_precomputation_power_of_2(points, fft_precomputation);
coeffs.iter().rev().skip_while(|c| c.is_zero()).count()
}
// TODO: Maybe a streaming version using an `Iterator` would be faster and wouldn't require as much memory for large circuits.
// TODO: Optimize this.
pub fn halo_s<F: Field>(us: &[F]) -> Vec<F> {
let n = 1 << us.len();
let mut res = vec![F::ONE; n];
let us_inv = F::batch_multiplicative_inverse(us);
for (j, (&u, &u_inv)) in us.iter().rev().zip(us_inv.iter().rev()).enumerate() {
for (i, x) in res.iter_mut().enumerate() {
if i & (1 << j) == 0 {
*x = *x * u_inv;
} else {
*x = *x * u;
}
}
}
res
}
/// Evaluate `g(X, {u_i})` as defined in the Halo paper.
pub fn halo_g<F: Field>(x: F, us: &[F]) -> F {
let mut product = F::ONE;
let mut x_power = x;
for &u_i in us.iter().rev() {
let u_i_inv = u_i.multiplicative_inverse_assuming_nonzero();
let term = u_i * x_power + u_i_inv;
product = product * term;
x_power = x_power.square();
}
product
}
#[cfg(test)]
mod test {
use super::*;
use crate::{CircuitBuilder, Curve, Field, PartialWitness, Tweedledee};
#[test]
fn test_halo_n() {
type C = Tweedledee;
type SF = <Tweedledee as Curve>::ScalarField;
let p = C::convert(SF::rand()) * C::GENERATOR_PROJECTIVE;
let r = SF::rand();
let res = C::convert(halo_n::<C>(&r.to_canonical_bool_vec()[..128])) * p;
let p = p.to_affine();
assert_eq!(
res.to_affine(),
halo_n_mul::<C>(&r.to_canonical_bool_vec()[..128], p)
)
}
#[test]
fn test_permutation_polynomial() {
let mut builder = CircuitBuilder::<Tweedledee>::new(128);
let one = builder.one_wire();
let t = builder.add_virtual_target();
let t_sq = builder.square(t);
let quad = builder.add_many(&[one, t, t_sq]);
let seven =
builder.constant_wire(<Tweedledee as Curve>::ScalarField::from_canonical_usize(7));
let res = builder.sub(quad, seven);
builder.assert_zero(res);
let mut partial_witness = PartialWitness::new();
partial_witness.set_target(t, <Tweedledee as Curve>::ScalarField::TWO);
let circuit = builder.build();
let witness = circuit.generate_witness(partial_witness);
let beta = <Tweedledee as Curve>::ScalarField::rand();
let gamma = <Tweedledee as Curve>::ScalarField::rand();
let plonk_z_points_n = permutation_polynomial(
circuit.degree(),
&circuit.subgroup_n,
&witness,
&circuit.s_sigma_values_8n,
beta,
gamma,
);
// Verify that the permutation polynomial is well-formed.
let k_is = (0..NUM_ROUTED_WIRES)
.map(get_subgroup_shift::<<Tweedledee as Curve>::ScalarField>)
.collect::<Vec<_>>();
let wire_values = &witness.transpose();
for (i, &x) in circuit.subgroup_n.iter().enumerate() {
let (z_x, z_gz) = (
plonk_z_points_n[i],
plonk_z_points_n[(i + 1) % circuit.degree()],
);
let mut f_prime = <Tweedledee as Curve>::ScalarField::ONE;
let mut g_prime = <Tweedledee as Curve>::ScalarField::ONE;
for j in 0..NUM_ROUTED_WIRES {
let wire_value = wire_values[j][i];
let k_i = k_is[j];
let s_id = k_i * x;
let s_sigma = circuit.s_sigma_values_8n[j][8 * i];
f_prime = f_prime * (wire_value + beta * s_id + gamma);
g_prime = g_prime * (wire_value + beta * s_sigma + gamma);
}
let vanishing_v_shift_term = f_prime * z_x - g_prime * z_gz;
assert_eq!(
vanishing_v_shift_term,
<Tweedledee as Curve>::ScalarField::ZERO
);
}
}
#[test]
fn test_s_vector_g_function() | {
type F = <Tweedledee as Curve>::ScalarField;
let us = (0..10).map(|_| F::rand()).collect::<Vec<_>>();
let x = F::rand();
assert_eq!(
F::inner_product(&halo_s(&us), &powers(x, 1 << 10)),
halo_g(x, &us)
);
} | identifier_body | |
plonk_util.rs | n(x)` for a given `x`, where `n` is the injective function related to the Halo
/// endomorphism.
pub fn halo_n<C: HaloCurve>(s_bits: &[bool]) -> C::ScalarField {
// This is based on Algorithm 2 of the Halo paper, except that we start with (a, b) = (0, 0).
debug_assert_eq!(s_bits.len() % 2, 0, "Number of scalar bits must be even");
let zero = C::ScalarField::ZERO;
let mut a = zero;
let mut b = zero;
for s_bits_chunk in s_bits.chunks(2) {
let bit_lo = s_bits_chunk[0];
let bit_hi = s_bits_chunk[1];
let sign = if bit_lo {
C::ScalarField::ONE
} else {
C::ScalarField::NEG_ONE
};
let (c, d) = if bit_hi { (sign, zero) } else { (zero, sign) };
a = a.double() + c;
b = b.double() + d;
}
a * C::ZETA_SCALAR + b
}
/// Compute `[n(s)].P` for a given `s`, where `n` is the injective function related to the Halo
/// endomorphism.
pub fn halo_n_mul<C: HaloCurve>(s_bits: &[bool], p: AffinePoint<C>) -> AffinePoint<C> {
// This is based on Algorithm 1 of the Halo paper, except that we start with Acc = O.
debug_assert_eq!(s_bits.len() % 2, 0, "Number of scalar bits must be even");
let p_p = p.to_projective();
let p_n = -p_p;
let endo_p_p = p.endomorphism().to_projective();
let endo_p_n = -endo_p_p;
let mut acc = ProjectivePoint::<C>::ZERO;
for s_bits_chunk in s_bits.chunks(2) {
let bit_lo = s_bits_chunk[0];
let bit_hi = s_bits_chunk[1];
| if bit_lo {
endo_p_p
} else {
endo_p_n
}
} else if bit_lo {
p_p
} else {
p_n
};
acc = acc.double() + s;
}
acc.to_affine()
}
pub fn eval_poly<F: Field>(coeffs: &[F], x: F) -> F {
let mut ans = F::ZERO;
let mut x_pow = F::ONE;
for &c in coeffs {
ans = ans + (c * x_pow);
x_pow = x_pow * x;
}
ans
}
/// Compute `[x^0, x^1, ..., x^(n - 1)]`.
pub fn powers<F: Field>(x: F, n: usize) -> Vec<F> {
let mut powers = Vec::new();
let mut current = F::ONE;
for i in 0..n {
if i != 0 {
current = current * x;
}
powers.push(current);
}
powers
}
/// Compute `[x^0, x^1, ..., x^(n - 1)]`.
pub(crate) fn powers_recursive<C: HaloCurve>(
builder: &mut CircuitBuilder<C>,
x: Target<C::ScalarField>,
n: usize,
) -> Vec<Target<C::ScalarField>> {
let mut powers = Vec::new();
let mut current = builder.one_wire();
for i in 0..n {
if i != 0 {
current = builder.mul(current, x);
}
powers.push(current);
}
powers
}
/// Returns the evaluation of a list of polynomials at a point.
pub(crate) fn eval_polys<F: Field>(polys: &[Polynomial<F>], powers: &[F]) -> Vec<F> {
polys.iter().map(|p| p.eval_from_power(powers)).collect()
}
/// Zero-pad a list of `n` polynomial coefficients to a length of `8n`, which is the degree at
/// which we do most polynomial arithmetic.
pub(crate) fn pad_to_8n<F: Field>(coeffs: &[F]) -> Vec<F> {
let n = coeffs.len();
let mut result = coeffs.to_vec();
while result.len() < 8 * n {
result.push(F::ZERO);
}
result
}
pub(crate) fn values_to_polynomials<F: Field>(
values_vec: &[Vec<F>],
fft_precomputation: &FftPrecomputation<F>,
) -> Vec<Polynomial<F>> {
values_vec
.par_iter()
.map(|values| Polynomial::from_evaluations(values, fft_precomputation))
.collect()
}
pub(crate) fn polynomials_to_values_padded<F: Field>(
polys_vec: &[Polynomial<F>],
fft_precomputation: &FftPrecomputation<F>,
) -> Vec<Vec<F>> {
polys_vec
.par_iter()
.map(|poly| {
let padded_poly = poly.padded(poly.len() * 8);
padded_poly.eval_domain(fft_precomputation)
})
.collect()
}
/// Like `pedersen_commit`, but with no blinding factor.
pub fn pedersen_hash<C: Curve>(
xs: &[C::ScalarField],
pedersen_g_msm_precomputation: &MsmPrecomputation<C>,
) -> ProjectivePoint<C> {
msm_execute_parallel(pedersen_g_msm_precomputation, xs)
}
#[allow(dead_code)]
fn pedersen_commit<C: Curve>(
xs: &[C::ScalarField],
opening: C::ScalarField,
h: AffinePoint<C>,
pedersen_g_msm_precomputation: &MsmPrecomputation<C>,
) -> ProjectivePoint<C> {
// TODO: Couldn't get this working with *.
let h = h.to_projective();
let mul_precomputation = h.mul_precompute();
let blinding_term = h.mul_with_precomputation(opening, mul_precomputation);
msm_execute_parallel(pedersen_g_msm_precomputation, xs) + blinding_term
}
pub fn commit_polynomials<C: Curve>(
polynomials: &[Polynomial<C::ScalarField>],
msm_precomputation: &MsmPrecomputation<C>,
blinding_point: AffinePoint<C>,
blinding: bool,
) -> Vec<PolynomialCommitment<C>> {
PolynomialCommitment::coeffs_vec_to_commitments(
polynomials
.iter()
.map(|p| p.coeffs())
.collect::<Vec<_>>()
.as_slice(),
msm_precomputation,
blinding_point,
blinding,
)
}
// Generate Z, which is used in Plonk's permutation argument.
pub fn permutation_polynomial<F: Field>(
degree: usize,
subgroup: &[F],
witness: &Witness<F>,
sigma_values: &[Vec<F>],
beta: F,
gamma: F,
) -> Vec<F> {
let mut plonk_z_points = vec![F::ONE];
let k_is = (0..NUM_ROUTED_WIRES)
.map(get_subgroup_shift::<F>)
.collect::<Vec<_>>();
for i in 1..degree {
let x = subgroup[i - 1];
let mut numerator = F::ONE;
let mut denominator = F::ONE;
for j in 0..NUM_ROUTED_WIRES {
let wire_value = witness.get_indices(i - 1, j);
let k_i = k_is[j];
let s_id = k_i * x;
let s_sigma = sigma_values[j][8 * (i - 1)];
numerator = numerator * (wire_value + beta * s_id + gamma);
denominator = denominator * (wire_value + beta * s_sigma + gamma);
}
let last = *plonk_z_points.last().unwrap();
plonk_z_points.push(last * numerator / denominator);
}
plonk_z_points
}
pub fn sigma_polynomials<F: Field>(
sigma: Vec<usize>,
degree: usize,
subgroup_generator: F,
) -> Vec<Vec<F>> {
sigma
.chunks(degree)
.map(|chunk| {
chunk
.par_iter()
.map(|&x| {
get_subgroup_shift::<F>(x / degree) * subgroup_generator.exp_usize(x % degree)
})
.collect::<Vec<_>>()
})
.collect()
}
/// Given polynomials `[p_0,...,p_k]` of degree `degree` and `alpha \in F`, returns `\sum_{i=0}^k alpha^i p_i`.
pub(crate) fn scale_polynomials<F: Field>(
polynomials: Vec<Polynomial<F>>,
alpha: F,
degree: usize,
) -> Polynomial<F> {
let alpha_powers = powers(alpha, polynomials.len());
Polynomial::from(
(0..degree)
.map(|i| {
(0..polynomials.len())
.map(|j| polynomials[j][i] * alpha_powers[j])
.fold(F::ZERO, |acc, x| acc + x)
})
.collect::<Vec<_>>(),
)
}
#[allow(dead_code | let s = if bit_hi { | random_line_split |
plonk_util.rs | (x)` for a given `x`, where `n` is the injective function related to the Halo
/// endomorphism.
pub fn halo_n<C: HaloCurve>(s_bits: &[bool]) -> C::ScalarField {
// This is based on Algorithm 2 of the Halo paper, except that we start with (a, b) = (0, 0).
debug_assert_eq!(s_bits.len() % 2, 0, "Number of scalar bits must be even");
let zero = C::ScalarField::ZERO;
let mut a = zero;
let mut b = zero;
for s_bits_chunk in s_bits.chunks(2) {
let bit_lo = s_bits_chunk[0];
let bit_hi = s_bits_chunk[1];
let sign = if bit_lo {
C::ScalarField::ONE
} else | ;
let (c, d) = if bit_hi { (sign, zero) } else { (zero, sign) };
a = a.double() + c;
b = b.double() + d;
}
a * C::ZETA_SCALAR + b
}
/// Compute `[n(s)].P` for a given `s`, where `n` is the injective function related to the Halo
/// endomorphism.
pub fn halo_n_mul<C: HaloCurve>(s_bits: &[bool], p: AffinePoint<C>) -> AffinePoint<C> {
// This is based on Algorithm 1 of the Halo paper, except that we start with Acc = O.
debug_assert_eq!(s_bits.len() % 2, 0, "Number of scalar bits must be even");
let p_p = p.to_projective();
let p_n = -p_p;
let endo_p_p = p.endomorphism().to_projective();
let endo_p_n = -endo_p_p;
let mut acc = ProjectivePoint::<C>::ZERO;
for s_bits_chunk in s_bits.chunks(2) {
let bit_lo = s_bits_chunk[0];
let bit_hi = s_bits_chunk[1];
let s = if bit_hi {
if bit_lo {
endo_p_p
} else {
endo_p_n
}
} else if bit_lo {
p_p
} else {
p_n
};
acc = acc.double() + s;
}
acc.to_affine()
}
pub fn eval_poly<F: Field>(coeffs: &[F], x: F) -> F {
let mut ans = F::ZERO;
let mut x_pow = F::ONE;
for &c in coeffs {
ans = ans + (c * x_pow);
x_pow = x_pow * x;
}
ans
}
/// Compute `[x^0, x^1, ..., x^(n - 1)]`.
pub fn powers<F: Field>(x: F, n: usize) -> Vec<F> {
let mut powers = Vec::new();
let mut current = F::ONE;
for i in 0..n {
if i != 0 {
current = current * x;
}
powers.push(current);
}
powers
}
/// Compute `[x^0, x^1, ..., x^(n - 1)]`.
pub(crate) fn powers_recursive<C: HaloCurve>(
builder: &mut CircuitBuilder<C>,
x: Target<C::ScalarField>,
n: usize,
) -> Vec<Target<C::ScalarField>> {
let mut powers = Vec::new();
let mut current = builder.one_wire();
for i in 0..n {
if i != 0 {
current = builder.mul(current, x);
}
powers.push(current);
}
powers
}
/// Returns the evaluation of a list of polynomials at a point.
pub(crate) fn eval_polys<F: Field>(polys: &[Polynomial<F>], powers: &[F]) -> Vec<F> {
polys.iter().map(|p| p.eval_from_power(powers)).collect()
}
/// Zero-pad a list of `n` polynomial coefficients to a length of `8n`, which is the degree at
/// which we do most polynomial arithmetic.
pub(crate) fn pad_to_8n<F: Field>(coeffs: &[F]) -> Vec<F> {
let n = coeffs.len();
let mut result = coeffs.to_vec();
while result.len() < 8 * n {
result.push(F::ZERO);
}
result
}
pub(crate) fn values_to_polynomials<F: Field>(
values_vec: &[Vec<F>],
fft_precomputation: &FftPrecomputation<F>,
) -> Vec<Polynomial<F>> {
values_vec
.par_iter()
.map(|values| Polynomial::from_evaluations(values, fft_precomputation))
.collect()
}
pub(crate) fn polynomials_to_values_padded<F: Field>(
polys_vec: &[Polynomial<F>],
fft_precomputation: &FftPrecomputation<F>,
) -> Vec<Vec<F>> {
polys_vec
.par_iter()
.map(|poly| {
let padded_poly = poly.padded(poly.len() * 8);
padded_poly.eval_domain(fft_precomputation)
})
.collect()
}
/// Like `pedersen_commit`, but with no blinding factor.
pub fn pedersen_hash<C: Curve>(
xs: &[C::ScalarField],
pedersen_g_msm_precomputation: &MsmPrecomputation<C>,
) -> ProjectivePoint<C> {
msm_execute_parallel(pedersen_g_msm_precomputation, xs)
}
#[allow(dead_code)]
fn pedersen_commit<C: Curve>(
xs: &[C::ScalarField],
opening: C::ScalarField,
h: AffinePoint<C>,
pedersen_g_msm_precomputation: &MsmPrecomputation<C>,
) -> ProjectivePoint<C> {
// TODO: Couldn't get this working with *.
let h = h.to_projective();
let mul_precomputation = h.mul_precompute();
let blinding_term = h.mul_with_precomputation(opening, mul_precomputation);
msm_execute_parallel(pedersen_g_msm_precomputation, xs) + blinding_term
}
pub fn commit_polynomials<C: Curve>(
polynomials: &[Polynomial<C::ScalarField>],
msm_precomputation: &MsmPrecomputation<C>,
blinding_point: AffinePoint<C>,
blinding: bool,
) -> Vec<PolynomialCommitment<C>> {
PolynomialCommitment::coeffs_vec_to_commitments(
polynomials
.iter()
.map(|p| p.coeffs())
.collect::<Vec<_>>()
.as_slice(),
msm_precomputation,
blinding_point,
blinding,
)
}
// Generate Z, which is used in Plonk's permutation argument.
pub fn permutation_polynomial<F: Field>(
degree: usize,
subgroup: &[F],
witness: &Witness<F>,
sigma_values: &[Vec<F>],
beta: F,
gamma: F,
) -> Vec<F> {
let mut plonk_z_points = vec![F::ONE];
let k_is = (0..NUM_ROUTED_WIRES)
.map(get_subgroup_shift::<F>)
.collect::<Vec<_>>();
for i in 1..degree {
let x = subgroup[i - 1];
let mut numerator = F::ONE;
let mut denominator = F::ONE;
for j in 0..NUM_ROUTED_WIRES {
let wire_value = witness.get_indices(i - 1, j);
let k_i = k_is[j];
let s_id = k_i * x;
let s_sigma = sigma_values[j][8 * (i - 1)];
numerator = numerator * (wire_value + beta * s_id + gamma);
denominator = denominator * (wire_value + beta * s_sigma + gamma);
}
let last = *plonk_z_points.last().unwrap();
plonk_z_points.push(last * numerator / denominator);
}
plonk_z_points
}
pub fn sigma_polynomials<F: Field>(
sigma: Vec<usize>,
degree: usize,
subgroup_generator: F,
) -> Vec<Vec<F>> {
sigma
.chunks(degree)
.map(|chunk| {
chunk
.par_iter()
.map(|&x| {
get_subgroup_shift::<F>(x / degree) * subgroup_generator.exp_usize(x % degree)
})
.collect::<Vec<_>>()
})
.collect()
}
/// Given polynomials `[p_0,...,p_k]` of degree `degree` and `alpha \in F`, returns `\sum_{i=0}^k alpha^i p_i`.
pub(crate) fn scale_polynomials<F: Field>(
polynomials: Vec<Polynomial<F>>,
alpha: F,
degree: usize,
) -> Polynomial<F> {
let alpha_powers = powers(alpha, polynomials.len());
Polynomial::from(
(0..degree)
.map(|i| {
(0..polynomials.len())
.map(|j| polynomials[j][i] * alpha_powers[j])
.fold(F::ZERO, |acc, x| acc + x)
})
.collect::<Vec<_>>(),
)
}
#[allow(dead | {
C::ScalarField::NEG_ONE
} | conditional_block |
Zhihu__Crawler_JsonVersion.py | File)
self.opener = request.build_opener(request.HTTPCookieProcessor(self.cj), RedirectHandler())
self.client_info = 'monsterzpc@gmail.com'
self.passwd = 'Zpc920515'
self.url = 'https://www.zhihu.com/login/email'
self.target_page = ''
self.position = 0
print('''
############################################################
# #
# Zhihu Auto_Login and Crawler by Pengcheng Zhou. #
# #
############################################################
''')
def get_xsrf(self) :
'''
Get a special dynamic string for login
'''
login_target_page = request.urlopen(self.url)
pattern = re.compile('<input type="hidden" name="_xsrf" value="(.*)"/>')
_xsrf = re.findall(pattern, login_target_page.read().decode('utf-8'))[0]
return _xsrf
def get_captcha_url(self):
url = 'https://www.zhihu.com' + '/captcha.gif?r=' + str(int(time.time())) + '&type=login'
f = request.urlopen(url)
with open('./cap.png', 'wb') as image:
image.write(f.read())
image.close()
def login(self):
'''
Execution of login
'''
if (self.client_info == '' or self.passwd == '') :
self.client_info = input('请输入账号:')
self.passwd = getpass('请输入密码:')
self.get_captcha_url()
captcha = input('请输入验证码：')
if (self.client_info.find("@") != -1) :
print('''正在使用邮箱登录...\n用户名:''' + self.client_info+ '\n' + '密码 : ' + len(self.passwd) * '*'+ '\n' )
else :
self.url = ''
print('正在使用手机登录...')
form = {'_xsrf' : self.get_xsrf(),
'password' : self.passwd,
'email' : self.client_info,
'captcha': captcha }
print(form)
try:
req = request.Request(self.url, parse.urlencode(form).encode('utf-8'))
f = self.opener.open(req)
self.cj.save()
print(json.loads(f.read().decode('utf-8'))["msg"] + "!")
print("=" * 100)
except:
print('Error!')
def get_capthca(self) :
'''
Interface for getting the captcha
'''
pass
def get_target_page(self):
'''
Get main target_page content after logged in
'''
try:
self.cj.load()
print('Cookie loaded....')
self.target_page = self.opener.open('https://www.zhihu.com/people/edit')
f = open('zhihu.html', 'wb')
f.write(target_page_content.read())
except:
self.login()
self.get_target_page()
def isLogged(self, user_client):
'''
test if Logged
'''
f = user_client.open('https://www.zhihu.com/settings/profile').geturl()
if (f != 'https://www.zhihu.com/settings/profile'):
return False
return True
def user_getter(sefl):
return User_Getter('https://www.zhihu.com/people/xiao-guai-shou-2/activ | s()
def profile_collector(self, text_path=None) :
'''
main entry for collecting user's profile including id, gender, education, career
'''
count = 0
self.cj.load()
user_list = []
# check the source of the data
if (text_path != None) :
with open(text_path, 'r') as source_list :
for line in source_list :
user_list.append(line.split('\n')[0])
source_list.close()
else :
user_list = []
initial_time = time.time()
while(len(user_list) > 0):
# this try except block is for resuming from the server' shutdown
try :
for item in user_list :
start_time = time.time()
user_id = item
print('=Writing information of [', user_id,']...')
url = 'https://www.zhihu.com/api/v4/members/' + user_id + '?include=locations%2Cemployments%2Cgender%2Ceducations%2Cbusiness%2Cvoteup_count%2Cthanked_Count%2Cfollower_count%2Cfollowing_count%2Ccover_url%2Cfollowing_topic_count%2Cfollowing_question_count%2Cfollowing_favlists_count%2Cfollowing_columns_count%2Canswer_count%2Carticles_count%2Cpins_count%2Cquestion_count%2Ccommercial_question_count%2Cfavorite_count%2Cfavorited_count%2Clogs_count%2Cmarked_answers_count%2Cmarked_answers_text%2Cmessage_thread_token%2Caccount_status%2Cis_active%2Cis_force_renamed%2Cis_bind_sina%2Csina_weibo_url%2Csina_weibo_name%2Cshow_sina_weibo%2Cis_blocking%2Cis_blocked%2Cis_following%2Cis_followed%2Cmutual_followees_count%2Cvote_to_count%2Cvote_from_count%2Cthank_to_count%2Cthank_from_count%2Cthanked_count%2Cdescription%2Chosted_live_count%2Cparticipated_live_count%2Callow_message%2Cindustry_category%2Corg_name%2Corg_homepage%2Cbadge%5B%3F(type%3Dbest_answerer)%5D.topics'
req = request.Request(url)
raw_data = self.opener.open(req).read()
json_data = json.loads(raw_data)
# get key and value
pic_url = json_data["avatar_url"].split('_')[0] + '_xll.jpg'
number_id = json_data["id"]
user_name = json_data["name"]
# education
if ("educations" in json_data) :
if (len(json_data["educations"]) != 0) :
if ("school" in json_data["educations"][0]) :
university = json_data["educations"][0]["school"]["name"]
else :
university = 'None'
if ("major" in json_data["educations"][0]) :
major = json_data["educations"][0]["major"]["name"]
else:
major = 'None'
else :
university = 'None'
major = 'None'
else :
university = 'None'
major = 'None'
# employments
if ("employments" in json_data) :
if (len(json_data["employments"]) != 0) :
if ("company" in json_data["employments"][0]) :
company = json_data["employments"][0]["company"]["name"]
else :
company = 'None'
if ("occupation" in json_data["employments"][0]) :
occupation = json_data["employments"][0]["job"]["name"]
else :
occupation = 'None'
else :
company = 'None'
occupation = 'None'
else :
company = 'None'
occupation = 'None'
# location
if ("locations" in json_data) :
if (len(json_data["locations"]) != 0) :
location = json_data["locations"][0]["name"]
else :
location = 'None'
else :
location = 'None'
# business
if ("business" in json_data ) :
industry = json_data["business"]["name"]
else :
industry = 'None'
intro = json_data["headline"]
autobiography = json_data["description"]
user_type = json_data["type"]
follower_count = json_data["follower_count"]
following_count = json_data["following_count"]
answers_count = json_data["answer_count"]
articles_count = json_data["articles_count"]
if (json_data["gender"] == 1) :
gender = 'male'
else :
gender = 'female'
data = {
'id' : number_id,
'user_id' : user_id,
'name' : user_name,
'gender' : gender,
'university' : university,
'major' : major,
'industry' : industry,
'company' : company,
'occupation' : occupation,
'location' : location,
'intro' : intro,
'autobiography' : autobiography,
'user_type' : str(user_type),
'follower_count' : str(follower_count),
'following_count' : str(following_count),
'answer-count' : str(answers_count),
'articles_count' : str(articles_count)
}
# process folder
if not (os.path.exists(os.path.join('./data/' ,user_name | ities').url | identifier_name |
Zhihu__Crawler_JsonVersion.py | File)
self.opener = request.build_opener(request.HTTPCookieProcessor(self.cj), RedirectHandler())
self.client_info = 'monsterzpc@gmail.com'
self.passwd = 'Zpc920515'
self.url = 'https://www.zhihu.com/login/email'
self.target_page = ''
self.position = 0
print('''
############################################################
# #
# Zhihu Auto_Login and Crawler by Pengcheng Zhou. #
# #
############################################################
''')
def get_xsrf(self) :
'''
Get a special dynamic string for login
'''
login_target_page = request.urlopen(self.url)
pattern = re.compile('<input type="hidden" name="_xsrf" value="(.*)"/>')
_xsrf = re.findall(pattern, login_target_page.read().decode('utf-8'))[0]
return _xsrf
def get_captcha_url(self):
url = 'https://www.zhihu.com' + '/captcha.gif?r=' + str(int(time.time())) + '&type=login'
f = request.urlopen(url)
with open('./cap.png', 'wb') as image:
image.write(f.read())
image.close()
def login(self):
'''
Execution of login
'''
if (self.client_info == '' or self.passwd == '') :
self.client_info = input('请输入账号:')
self.passwd = getpass('请输入密码:')
self.get_captcha_url()
captcha = input('请输入验证码：')
if (self.client_info.find("@") != -1) :
print('''正在使用邮箱登录...\n用户名:''' + self.client_info+ '\n' + '密码 : ' + len(self.passwd) * '*'+ '\n' )
else :
self.url = ''
print('正在使用手机登录...')
form = {'_xsrf' : self.get_xsrf(),
'password' : self.passwd,
'email' : self.client_info,
'captcha': captcha }
print(form)
try:
req = request.Request(self.url, parse.urlencode(form).encode('utf-8'))
f = self.opener.open(req)
self.cj.save()
print(json.loads(f.read().decode('utf-8'))["msg"] + "!")
print("=" * 100)
except:
print('Error!')
def get_capthca(self) :
'''
Interface for getting the captcha
'''
pass
def get_target_page(self):
'''
Get main target_page content after logged in
'''
try:
self.cj.load()
print('Cookie loaded....')
self.target_page = self.opener.open('https://www.zhihu.com/people/edit')
f = open('zhihu.html', 'wb')
f.write(target_page_content.read())
except:
self.login()
self.get_target_page()
def isLogged(self, user_client):
'''
test if Logged
'''
f = user_client.open('https://www.zhihu.com/settings/profile').geturl()
if (f != 'https://www.zhihu.com/settings/profile'):
return False
return True |
def user_getter(sefl):
return User_Getter('https://www.zhihu.com/people/xiao-guai-shou-2/activities').urls()
def profile_collector(self, text_path=None) :
'''
main entry for collecting user's profile including id, gender, education, career
'''
count = 0
self.cj.load()
user_list = []
# check the source of the data
if (text_path != None) :
with open(text_path, 'r') as source_list :
for line in source_list :
user_list.append(line.split('\n')[0])
source_list.close()
else :
user_list = []
initial_time = time.time()
while(len(user_list) > 0):
# this try except block is for resuming from the server' shutdown
try :
for item in user_list :
start_time = time.time()
user_id = item
print('=Writing information of [', user_id,']...')
url = 'https://www.zhihu.com/api/v4/members/' + user_id + '?include=locations%2Cemployments%2Cgender%2Ceducations%2Cbusiness%2Cvoteup_count%2Cthanked_Count%2Cfollower_count%2Cfollowing_count%2Ccover_url%2Cfollowing_topic_count%2Cfollowing_question_count%2Cfollowing_favlists_count%2Cfollowing_columns_count%2Canswer_count%2Carticles_count%2Cpins_count%2Cquestion_count%2Ccommercial_question_count%2Cfavorite_count%2Cfavorited_count%2Clogs_count%2Cmarked_answers_count%2Cmarked_answers_text%2Cmessage_thread_token%2Caccount_status%2Cis_active%2Cis_force_renamed%2Cis_bind_sina%2Csina_weibo_url%2Csina_weibo_name%2Cshow_sina_weibo%2Cis_blocking%2Cis_blocked%2Cis_following%2Cis_followed%2Cmutual_followees_count%2Cvote_to_count%2Cvote_from_count%2Cthank_to_count%2Cthank_from_count%2Cthanked_count%2Cdescription%2Chosted_live_count%2Cparticipated_live_count%2Callow_message%2Cindustry_category%2Corg_name%2Corg_homepage%2Cbadge%5B%3F(type%3Dbest_answerer)%5D.topics'
req = request.Request(url)
raw_data = self.opener.open(req).read()
json_data = json.loads(raw_data)
# get key and value
pic_url = json_data["avatar_url"].split('_')[0] + '_xll.jpg'
number_id = json_data["id"]
user_name = json_data["name"]
# education
if ("educations" in json_data) :
if (len(json_data["educations"]) != 0) :
if ("school" in json_data["educations"][0]) :
university = json_data["educations"][0]["school"]["name"]
else :
university = 'None'
if ("major" in json_data["educations"][0]) :
major = json_data["educations"][0]["major"]["name"]
else:
major = 'None'
else :
university = 'None'
major = 'None'
else :
university = 'None'
major = 'None'
# employments
if ("employments" in json_data) :
if (len(json_data["employments"]) != 0) :
if ("company" in json_data["employments"][0]) :
company = json_data["employments"][0]["company"]["name"]
else :
company = 'None'
if ("occupation" in json_data["employments"][0]) :
occupation = json_data["employments"][0]["job"]["name"]
else :
occupation = 'None'
else :
company = 'None'
occupation = 'None'
else :
company = 'None'
occupation = 'None'
# location
if ("locations" in json_data) :
if (len(json_data["locations"]) != 0) :
location = json_data["locations"][0]["name"]
else :
location = 'None'
else :
location = 'None'
# business
if ("business" in json_data ) :
industry = json_data["business"]["name"]
else :
industry = 'None'
intro = json_data["headline"]
autobiography = json_data["description"]
user_type = json_data["type"]
follower_count = json_data["follower_count"]
following_count = json_data["following_count"]
answers_count = json_data["answer_count"]
articles_count = json_data["articles_count"]
if (json_data["gender"] == 1) :
gender = 'male'
else :
gender = 'female'
data = {
'id' : number_id,
'user_id' : user_id,
'name' : user_name,
'gender' : gender,
'university' : university,
'major' : major,
'industry' : industry,
'company' : company,
'occupation' : occupation,
'location' : location,
'intro' : intro,
'autobiography' : autobiography,
'user_type' : str(user_type),
'follower_count' : str(follower_count),
'following_count' : str(following_count),
'answer-count' : str(answers_count),
'articles_count' : str(articles_count)
}
# process folder
if not (os.path.exists(os.path.join('./data/' ,user_name)) | conditional_block | |
Zhihu__Crawler_JsonVersion.py | File)
self.opener = request.build_opener(request.HTTPCookieProcessor(self.cj), RedirectHandler())
self.client_info = 'monsterzpc@gmail.com'
self.passwd = 'Zpc920515'
self.url = 'https://www.zhihu.com/login/email'
self.target_page = ''
self.position = 0
print('''
############################################################
# #
# Zhihu Auto_Login and Crawler by Pengcheng Zhou. #
# #
############################################################
''')
def get_xsrf(self) :
'''
Get a special dynamic string for login
'''
login_target_page = request.urlopen(self.url)
pattern = re.compile('<input type="hidden" name="_xsrf" value="(.*)"/>')
_xsrf = re.findall(pattern, login_target_page.read().decode('utf-8'))[0]
return _xsrf
def get_captcha_url(self):
url = 'https:// | f):
'''
Execution of login
'''
if (self.client_info == '' or self.passwd == '') :
self.client_info = input('请输入账号:')
self.passwd = getpass('请输入密码:')
self.get_captcha_url()
captcha = input('请输入验证码：')
if (self.client_info.find("@") != -1) :
print('''正在使用邮箱登录...\n用户名:''' + self.client_info+ '\n' + '密码 : ' + len(self.passwd) * '*'+ '\n' )
else :
self.url = ''
print('正在使用手机登录...')
form = {'_xsrf' : self.get_xsrf(),
'password' : self.passwd,
'email' : self.client_info,
'captcha': captcha }
print(form)
try:
req = request.Request(self.url, parse.urlencode(form).encode('utf-8'))
f = self.opener.open(req)
self.cj.save()
print(json.loads(f.read().decode('utf-8'))["msg"] + "!")
print("=" * 100)
except:
print('Error!')
def get_capthca(self) :
'''
Interface for getting the captcha
'''
pass
def get_target_page(self):
'''
Get main target_page content after logged in
'''
try:
self.cj.load()
print('Cookie loaded....')
self.target_page = self.opener.open('https://www.zhihu.com/people/edit')
f = open('zhihu.html', 'wb')
f.write(target_page_content.read())
except:
self.login()
self.get_target_page()
def isLogged(self, user_client):
'''
test if Logged
'''
f = user_client.open('https://www.zhihu.com/settings/profile').geturl()
if (f != 'https://www.zhihu.com/settings/profile'):
return False
return True
def user_getter(sefl):
return User_Getter('https://www.zhihu.com/people/xiao-guai-shou-2/activities').urls()
def profile_collector(self, text_path=None) :
'''
main entry for collecting user's profile including id, gender, education, career
'''
count = 0
self.cj.load()
user_list = []
# check the source of the data
if (text_path != None) :
with open(text_path, 'r') as source_list :
for line in source_list :
user_list.append(line.split('\n')[0])
source_list.close()
else :
user_list = []
initial_time = time.time()
while(len(user_list) > 0):
# this try except block is for resuming from the server' shutdown
try :
for item in user_list :
start_time = time.time()
user_id = item
print('=Writing information of [', user_id,']...')
url = 'https://www.zhihu.com/api/v4/members/' + user_id + '?include=locations%2Cemployments%2Cgender%2Ceducations%2Cbusiness%2Cvoteup_count%2Cthanked_Count%2Cfollower_count%2Cfollowing_count%2Ccover_url%2Cfollowing_topic_count%2Cfollowing_question_count%2Cfollowing_favlists_count%2Cfollowing_columns_count%2Canswer_count%2Carticles_count%2Cpins_count%2Cquestion_count%2Ccommercial_question_count%2Cfavorite_count%2Cfavorited_count%2Clogs_count%2Cmarked_answers_count%2Cmarked_answers_text%2Cmessage_thread_token%2Caccount_status%2Cis_active%2Cis_force_renamed%2Cis_bind_sina%2Csina_weibo_url%2Csina_weibo_name%2Cshow_sina_weibo%2Cis_blocking%2Cis_blocked%2Cis_following%2Cis_followed%2Cmutual_followees_count%2Cvote_to_count%2Cvote_from_count%2Cthank_to_count%2Cthank_from_count%2Cthanked_count%2Cdescription%2Chosted_live_count%2Cparticipated_live_count%2Callow_message%2Cindustry_category%2Corg_name%2Corg_homepage%2Cbadge%5B%3F(type%3Dbest_answerer)%5D.topics'
req = request.Request(url)
raw_data = self.opener.open(req).read()
json_data = json.loads(raw_data)
# get key and value
pic_url = json_data["avatar_url"].split('_')[0] + '_xll.jpg'
number_id = json_data["id"]
user_name = json_data["name"]
# education
if ("educations" in json_data) :
if (len(json_data["educations"]) != 0) :
if ("school" in json_data["educations"][0]) :
university = json_data["educations"][0]["school"]["name"]
else :
university = 'None'
if ("major" in json_data["educations"][0]) :
major = json_data["educations"][0]["major"]["name"]
else:
major = 'None'
else :
university = 'None'
major = 'None'
else :
university = 'None'
major = 'None'
# employments
if ("employments" in json_data) :
if (len(json_data["employments"]) != 0) :
if ("company" in json_data["employments"][0]) :
company = json_data["employments"][0]["company"]["name"]
else :
company = 'None'
if ("occupation" in json_data["employments"][0]) :
occupation = json_data["employments"][0]["job"]["name"]
else :
occupation = 'None'
else :
company = 'None'
occupation = 'None'
else :
company = 'None'
occupation = 'None'
# location
if ("locations" in json_data) :
if (len(json_data["locations"]) != 0) :
location = json_data["locations"][0]["name"]
else :
location = 'None'
else :
location = 'None'
# business
if ("business" in json_data ) :
industry = json_data["business"]["name"]
else :
industry = 'None'
intro = json_data["headline"]
autobiography = json_data["description"]
user_type = json_data["type"]
follower_count = json_data["follower_count"]
following_count = json_data["following_count"]
answers_count = json_data["answer_count"]
articles_count = json_data["articles_count"]
if (json_data["gender"] == 1) :
gender = 'male'
else :
gender = 'female'
data = {
'id' : number_id,
'user_id' : user_id,
'name' : user_name,
'gender' : gender,
'university' : university,
'major' : major,
'industry' : industry,
'company' : company,
'occupation' : occupation,
'location' : location,
'intro' : intro,
'autobiography' : autobiography,
'user_type' : str(user_type),
'follower_count' : str(follower_count),
'following_count' : str(following_count),
'answer-count' : str(answers_count),
'articles_count' : str(articles_count)
}
# process folder
if not (os.path.exists(os.path.join('./data/' ,user_name)) | www.zhihu.com' + '/captcha.gif?r=' + str(int(time.time())) + '&type=login'
f = request.urlopen(url)
with open('./cap.png', 'wb') as image:
image.write(f.read())
image.close()
def login(sel | identifier_body |
Zhihu__Crawler_JsonVersion.py | #
#
# Created on : 03/07/17
# Last Modified :
#
# Author : Pengcheng Zhou(Kevin)
#
####################################################
import re
from urllib import parse, request, error
from multiprocessing import Pool
import http.cookiejar as Cookie
import time
import json
from getpass import getpass
import ssl
# Cancel the certification of target site
ssl._create_default_https_context = ssl._create_unverified_context
import os
from User_Getter import User_Getter
import random
cookieFile = 'zhihu_cookie.txt'
class RedirectHandler(request.HTTPRedirectHandler):
def http_error_302(self, req, fp, code, msg, headers):
print ("Cookie过期，重新登录中....")
return
http_error_301 = http_error_302
class Zhihu(object):
def __init__(self) :
'''
Initialize
'''
self.pool = Pool(4)
self.cj = Cookie.MozillaCookieJar(cookieFile)
self.opener = request.build_opener(request.HTTPCookieProcessor(self.cj), RedirectHandler())
self.client_info = 'monsterzpc@gmail.com'
self.passwd = 'Zpc920515'
self.url = 'https://www.zhihu.com/login/email'
self.target_page = ''
self.position = 0
print('''
############################################################
# #
# Zhihu Auto_Login and Crawler by Pengcheng Zhou. #
# #
############################################################
''')
def get_xsrf(self) :
'''
Get a special dynamic string for login
'''
login_target_page = request.urlopen(self.url)
pattern = re.compile('<input type="hidden" name="_xsrf" value="(.*)"/>')
_xsrf = re.findall(pattern, login_target_page.read().decode('utf-8'))[0]
return _xsrf
def get_captcha_url(self):
url = 'https://www.zhihu.com' + '/captcha.gif?r=' + str(int(time.time())) + '&type=login'
f = request.urlopen(url)
with open('./cap.png', 'wb') as image:
image.write(f.read())
image.close()
def login(self):
'''
Execution of login
'''
if (self.client_info == '' or self.passwd == '') :
self.client_info = input('请输入账号:')
self.passwd = getpass('请输入密码:')
self.get_captcha_url()
captcha = input('请输入验证码：')
if (self.client_info.find("@") != -1) :
print('''正在使用邮箱登录...\n用户名:''' + self.client_info+ '\n' + '密码 : ' + len(self.passwd) * '*'+ '\n' )
else :
self.url = ''
print('正在使用手机登录...')
form = {'_xsrf' : self.get_xsrf(),
'password' : self.passwd,
'email' : self.client_info,
'captcha': captcha }
print(form)
try:
req = request.Request(self.url, parse.urlencode(form).encode('utf-8'))
f = self.opener.open(req)
self.cj.save()
print(json.loads(f.read().decode('utf-8'))["msg"] + "!")
print("=" * 100)
except:
print('Error!')
def get_capthca(self) :
'''
Interface for getting the captcha
'''
pass
def get_target_page(self):
'''
Get main target_page content after logged in
'''
try:
self.cj.load()
print('Cookie loaded....')
self.target_page = self.opener.open('https://www.zhihu.com/people/edit')
f = open('zhihu.html', 'wb')
f.write(target_page_content.read())
except:
self.login()
self.get_target_page()
def isLogged(self, user_client):
'''
test if Logged
'''
f = user_client.open('https://www.zhihu.com/settings/profile').geturl()
if (f != 'https://www.zhihu.com/settings/profile'):
return False
return True
def user_getter(sefl):
return User_Getter('https://www.zhihu.com/people/xiao-guai-shou-2/activities').urls()
def profile_collector(self, text_path=None) :
'''
main entry for collecting user's profile including id, gender, education, career
'''
count = 0
self.cj.load()
user_list = []
# check the source of the data
if (text_path != None) :
with open(text_path, 'r') as source_list :
for line in source_list :
user_list.append(line.split('\n')[0])
source_list.close()
else :
user_list = []
initial_time = time.time()
while(len(user_list) > 0):
# this try except block is for resuming from the server' shutdown
try :
for item in user_list :
start_time = time.time()
user_id = item
print('=Writing information of [', user_id,']...')
url = 'https://www.zhihu.com/api/v4/members/' + user_id + '?include=locations%2Cemployments%2Cgender%2Ceducations%2Cbusiness%2Cvoteup_count%2Cthanked_Count%2Cfollower_count%2Cfollowing_count%2Ccover_url%2Cfollowing_topic_count%2Cfollowing_question_count%2Cfollowing_favlists_count%2Cfollowing_columns_count%2Canswer_count%2Carticles_count%2Cpins_count%2Cquestion_count%2Ccommercial_question_count%2Cfavorite_count%2Cfavorited_count%2Clogs_count%2Cmarked_answers_count%2Cmarked_answers_text%2Cmessage_thread_token%2Caccount_status%2Cis_active%2Cis_force_renamed%2Cis_bind_sina%2Csina_weibo_url%2Csina_weibo_name%2Cshow_sina_weibo%2Cis_blocking%2Cis_blocked%2Cis_following%2Cis_followed%2Cmutual_followees_count%2Cvote_to_count%2Cvote_from_count%2Cthank_to_count%2Cthank_from_count%2Cthanked_count%2Cdescription%2Chosted_live_count%2Cparticipated_live_count%2Callow_message%2Cindustry_category%2Corg_name%2Corg_homepage%2Cbadge%5B%3F(type%3Dbest_answerer)%5D.topics'
req = request.Request(url)
raw_data = self.opener.open(req).read()
json_data = json.loads(raw_data)
# get key and value
pic_url = json_data["avatar_url"].split('_')[0] + '_xll.jpg'
number_id = json_data["id"]
user_name = json_data["name"]
# education
if ("educations" in json_data) :
if (len(json_data["educations"]) != 0) :
if ("school" in json_data["educations"][0]) :
university = json_data["educations"][0]["school"]["name"]
else :
university = 'None'
if ("major" in json_data["educations"][0]) :
major = json_data["educations"][0]["major"]["name"]
else:
major = 'None'
else :
university = 'None'
major = 'None'
else :
university = 'None'
major = 'None'
# employments
if ("employments" in json_data) :
if (len(json_data["employments"]) != 0) :
if ("company" in json_data["employments"][0]) :
company = json_data["employments"][0]["company"]["name"]
else :
company = 'None'
if ("occupation" in json_data["employments"][0]) :
occupation = json_data["employments"][0]["job"]["name"]
else :
occupation = 'None'
else :
company = 'None'
occupation = 'None'
else :
company = 'None'
occupation = 'None'
# location
if ("locations" in json_data) :
if (len(json_data["locations"]) != 0) :
location = json_data["locations"][0]["name"]
else :
location = 'None'
else :
location = 'None'
# business
if ("business" in json_data ) :
industry = json_data["business"]["name"]
else :
industry = 'None'
intro = json_data["headline"]
autobiography = json_data["description"]
user_type = json_data["type"]
follower_count = json_data["follower_count"]
following_count = json_data | #!/usr/bin/python
# --*-- encoding:utf-8 --*--
####################################################
# Zhihu Auto-Aogin | random_line_split | |
main.rs | Cell<Option<TypeEncoder>>> = Mutex::new(RefCell::new(None));
type TypeMotor = Motor;
static G_MOTOR: Mutex<RefCell<Option<TypeMotor>>> = Mutex::new(RefCell::new(None));
static G_TIM: Mutex<RefCell<Option<Timer<TIM2>>>> = Mutex::new(RefCell::new(None));
static mut CURRENT_A: f32 = 0.0;
static mut CURRENT_B: f32 = 0.0;
static mut CURRENT_C: f32 = 0.0;
static mut MOT_ANGLE: u16 = 0;
static mut MOT_ANGLE_OLD: u16 = 0;
static mut MOT_VELOCITY: f32 = 0.0;
static mut MOT_VELOCITY_OLD: f32 = 0.0;
static mut ERR_VELOCITY: f32 = 0.0;
static mut ERR_VELOCITY_INT: f32 = 0.0;
static mut REF_CURR_D: f32 = 0.0;
static mut REF_CURR_Q: f32 = 0.0;
// System
const TIM2_FREQ_KHZ: u32 = 10;
// Motor
const MOT_POLE_PAIRS: u16 = 12;
// Encoder
const ENC_RESOLUTION: u16 = 16384;
#[interrupt]
fn ADC() {
// current sensing
unsafe {
let max_sample:u32 = (1 << 12) - 1;
let device = pac::Peripherals::steal();
device.ADC1.sr.modify(|_, w| w.jeoc().clear_bit());
let jdr1_data = device.ADC1.jdr1.read().jdata().bits();
let jdr1_offset = 48u32;
let so1 = ( ( (u32::from(jdr1_data) + jdr1_offset) * VDDA_CALIB ) / max_sample) as u16;
let jdr2_data = device.ADC1.jdr2.read().jdata().bits();
let jdr2_offset = 118u32;
let so2 = ( ( (u32::from(jdr2_data) + jdr2_offset) * VDDA_CALIB ) / max_sample) as u16;
CURRENT_B = (so1 as f32 - 1650.0) / 200.0;
CURRENT_C = (so2 as f32 - 1650.0) / 200.0;
CURRENT_A = - CURRENT_B - CURRENT_C;
}
/*
// LED Debug
cortex_m::interrupt::free(|cs| {
if let Some(ref mut led) = G_LED.borrow(cs).borrow_mut().as_mut() {
led.toggle().unwrap();
}
});
*/
}
#[interrupt]
fn TIM2() {
cortex_m::interrupt::free(|cs| {
if let Some(ref mut tim) = G_TIM.borrow(cs).borrow_mut().as_mut() |
});
static mut SPI3: Option<TypeSpi3> = None;
static mut MOTOR: Option<TypeMotor> = None;
unsafe{
let mut spi3 = SPI3.get_or_insert_with(|| {
cortex_m::interrupt::free(|cs| {
G_SPI3.borrow(cs).replace(None).unwrap()
})
});
let device = pac::Peripherals::steal();
let gpioa = device.GPIOA.split();
let ncs = gpioa.pa3.into_push_pull_output();
let mut as5048: TypeEncoder = AS5048A::new(&mut spi3, ncs);
// AS5048A
let measured_angle = as5048.angle().unwrap();
let angle_offset = 650u16;
MOT_ANGLE = (measured_angle - angle_offset) % ENC_RESOLUTION;
let electric_angle = MOT_ANGLE % (ENC_RESOLUTION/MOT_POLE_PAIRS);
let motor = MOTOR.get_or_insert_with(|| {
cortex_m::interrupt::free(|cs| {
G_MOTOR.borrow(cs).replace(None).unwrap()
})
});
// Velocity control
const REF_VELOCITY: f32 = - 100.0;
const VELLOCITY_PGAIN: f32 = 0.1;
const VELOCITY_IGAIN: f32 = 0.00001;
let res_velocity =
if (ENC_RESOLUTION-1000) < MOT_ANGLE_OLD && MOT_ANGLE < 1000 {
( MOT_ANGLE as f32 - MOT_ANGLE_OLD as f32 + ENC_RESOLUTION as f32 ) * TIM2_FREQ_KHZ as f32
} else if MOT_ANGLE_OLD < 1000 && MOT_ANGLE > (ENC_RESOLUTION-1000) {
( MOT_ANGLE as f32 - MOT_ANGLE_OLD as f32 - ENC_RESOLUTION as f32 ) * TIM2_FREQ_KHZ as f32
} else {
( MOT_ANGLE as f32 - MOT_ANGLE_OLD as f32 ) * TIM2_FREQ_KHZ as f32
};
let alpha = 0.1;
MOT_VELOCITY = alpha * res_velocity + (1.0 - alpha) * MOT_VELOCITY_OLD;
ERR_VELOCITY = MOT_VELOCITY - REF_VELOCITY;
ERR_VELOCITY_INT += ERR_VELOCITY;
REF_CURR_D = 0.0;
REF_CURR_Q = VELLOCITY_PGAIN * ERR_VELOCITY + VELOCITY_IGAIN * ERR_VELOCITY_INT;
REF_CURR_Q = -1.0 * REF_CURR_Q;
MOT_ANGLE_OLD = MOT_ANGLE;
MOT_VELOCITY_OLD = MOT_VELOCITY;
// select control mode
//motor.drive_profile().unwrap();
//motor.drive_sixstep().unwrap();
//motor.drive_anglebased_sixstep(electric_angle).unwrap();
motor.drive_foc(electric_angle, CURRENT_A, CURRENT_B, CURRENT_C, REF_CURR_D, REF_CURR_Q).unwrap();
}
/*
// LED Debug
cortex_m::interrupt::free(|cs| {
if let Some(ref mut led) = G_LED.borrow(cs).borrow_mut().as_mut() {
led.toggle().unwrap();
}
});
*/
}
#[entry]
fn main() -> ! {
let dp = pac::Peripherals::take().unwrap();
let cp = cortex_m::peripheral::Peripherals::take().unwrap();
let rcc = dp.RCC.constrain();
let clocks = rcc
.cfgr
.use_hse(8.mhz())
.sysclk(168.mhz())
.hclk(168.mhz())
.pclk1(42.mhz())
.pclk2(84.mhz())
.require_pll48clk()
.freeze();
let mut delay = hal::delay::Delay::new(cp.SYST, clocks);
let gpioa = dp.GPIOA.split();
let gpiob = dp.GPIOB.split();
let gpioc = dp.GPIOC.split();
// SPI3
let sck = gpioc.pc10.into_alternate_af6();
let miso = gpioc.pc11.into_alternate_af6();
let mosi = gpioc.pc12.into_alternate_af6();
let mut spi = Spi::spi3(
dp.SPI3,
(sck, miso, mosi),
MODE_1,
KiloHertz(2000).into(),
clocks,
);
// DRV8301
let ncs = gpioc.pc13.into_push_pull_output();
let en_gate = gpiob.pb12.into_push_pull_output();
let mut drv8301 = Drv8301::new(&mut spi, ncs, en_gate);
drv8301.init().unwrap();
// Move the pin into our global storage
cortex_m::interrupt::free(|cs| *G_SPI3.borrow(cs).borrow_mut() = Some(spi));
// PWM
let channels = (gpioa.pa8.into_alternate_af1(), gpioa.pa9.into_alternate_af1(), gpioa.pa10.into_alternate_af1(), gpioa.pa11.into_alternate_af1());
let pwm = pwm::tim1(dp.TIM1, channels, clocks, 16u32.khz());
let (ch1, ch2, ch3, ch4) = pwm;
let mut ch4 = ch4;
{
// Set complementary oututs mode as AF1
gpiob.pb13.into_alternate_af1();
gpiob.pb14.into_alternate_af1();
gpiob.pb15.into_alternate_af1();
unsafe {
let tim1_regb = &(*(TIM1::ptr()));
// Enable complementary outputs
tim1_regb.ccer.modify(|_, w| w.cc1ne().set_bit());
tim1_regb.ccer.modify(|_, w| w.cc2ne().set_bit());
tim1_regb.ccer.modify(|_, w| w.cc3ne().set_bit());
// Set dead time
tim1_regb.bdtr.modify(|_, | {
let _ = tim.wait();
} | conditional_block |
main.rs | Cell<Option<TypeEncoder>>> = Mutex::new(RefCell::new(None));
type TypeMotor = Motor;
static G_MOTOR: Mutex<RefCell<Option<TypeMotor>>> = Mutex::new(RefCell::new(None));
static G_TIM: Mutex<RefCell<Option<Timer<TIM2>>>> = Mutex::new(RefCell::new(None));
static mut CURRENT_A: f32 = 0.0;
static mut CURRENT_B: f32 = 0.0;
static mut CURRENT_C: f32 = 0.0;
static mut MOT_ANGLE: u16 = 0;
static mut MOT_ANGLE_OLD: u16 = 0;
static mut MOT_VELOCITY: f32 = 0.0;
static mut MOT_VELOCITY_OLD: f32 = 0.0;
static mut ERR_VELOCITY: f32 = 0.0;
static mut ERR_VELOCITY_INT: f32 = 0.0;
static mut REF_CURR_D: f32 = 0.0;
static mut REF_CURR_Q: f32 = 0.0;
// System
const TIM2_FREQ_KHZ: u32 = 10;
// Motor
const MOT_POLE_PAIRS: u16 = 12;
// Encoder
const ENC_RESOLUTION: u16 = 16384;
#[interrupt]
fn ADC() |
/*
// LED Debug
cortex_m::interrupt::free(|cs| {
if let Some(ref mut led) = G_LED.borrow(cs).borrow_mut().as_mut() {
led.toggle().unwrap();
}
});
*/
}
#[interrupt]
fn TIM2() {
cortex_m::interrupt::free(|cs| {
if let Some(ref mut tim) = G_TIM.borrow(cs).borrow_mut().as_mut() {
let _ = tim.wait();
}
});
static mut SPI3: Option<TypeSpi3> = None;
static mut MOTOR: Option<TypeMotor> = None;
unsafe{
let mut spi3 = SPI3.get_or_insert_with(|| {
cortex_m::interrupt::free(|cs| {
G_SPI3.borrow(cs).replace(None).unwrap()
})
});
let device = pac::Peripherals::steal();
let gpioa = device.GPIOA.split();
let ncs = gpioa.pa3.into_push_pull_output();
let mut as5048: TypeEncoder = AS5048A::new(&mut spi3, ncs);
// AS5048A
let measured_angle = as5048.angle().unwrap();
let angle_offset = 650u16;
MOT_ANGLE = (measured_angle - angle_offset) % ENC_RESOLUTION;
let electric_angle = MOT_ANGLE % (ENC_RESOLUTION/MOT_POLE_PAIRS);
let motor = MOTOR.get_or_insert_with(|| {
cortex_m::interrupt::free(|cs| {
G_MOTOR.borrow(cs).replace(None).unwrap()
})
});
// Velocity control
const REF_VELOCITY: f32 = - 100.0;
const VELLOCITY_PGAIN: f32 = 0.1;
const VELOCITY_IGAIN: f32 = 0.00001;
let res_velocity =
if (ENC_RESOLUTION-1000) < MOT_ANGLE_OLD && MOT_ANGLE < 1000 {
( MOT_ANGLE as f32 - MOT_ANGLE_OLD as f32 + ENC_RESOLUTION as f32 ) * TIM2_FREQ_KHZ as f32
} else if MOT_ANGLE_OLD < 1000 && MOT_ANGLE > (ENC_RESOLUTION-1000) {
( MOT_ANGLE as f32 - MOT_ANGLE_OLD as f32 - ENC_RESOLUTION as f32 ) * TIM2_FREQ_KHZ as f32
} else {
( MOT_ANGLE as f32 - MOT_ANGLE_OLD as f32 ) * TIM2_FREQ_KHZ as f32
};
let alpha = 0.1;
MOT_VELOCITY = alpha * res_velocity + (1.0 - alpha) * MOT_VELOCITY_OLD;
ERR_VELOCITY = MOT_VELOCITY - REF_VELOCITY;
ERR_VELOCITY_INT += ERR_VELOCITY;
REF_CURR_D = 0.0;
REF_CURR_Q = VELLOCITY_PGAIN * ERR_VELOCITY + VELOCITY_IGAIN * ERR_VELOCITY_INT;
REF_CURR_Q = -1.0 * REF_CURR_Q;
MOT_ANGLE_OLD = MOT_ANGLE;
MOT_VELOCITY_OLD = MOT_VELOCITY;
// select control mode
//motor.drive_profile().unwrap();
//motor.drive_sixstep().unwrap();
//motor.drive_anglebased_sixstep(electric_angle).unwrap();
motor.drive_foc(electric_angle, CURRENT_A, CURRENT_B, CURRENT_C, REF_CURR_D, REF_CURR_Q).unwrap();
}
/*
// LED Debug
cortex_m::interrupt::free(|cs| {
if let Some(ref mut led) = G_LED.borrow(cs).borrow_mut().as_mut() {
led.toggle().unwrap();
}
});
*/
}
#[entry]
fn main() -> ! {
let dp = pac::Peripherals::take().unwrap();
let cp = cortex_m::peripheral::Peripherals::take().unwrap();
let rcc = dp.RCC.constrain();
let clocks = rcc
.cfgr
.use_hse(8.mhz())
.sysclk(168.mhz())
.hclk(168.mhz())
.pclk1(42.mhz())
.pclk2(84.mhz())
.require_pll48clk()
.freeze();
let mut delay = hal::delay::Delay::new(cp.SYST, clocks);
let gpioa = dp.GPIOA.split();
let gpiob = dp.GPIOB.split();
let gpioc = dp.GPIOC.split();
// SPI3
let sck = gpioc.pc10.into_alternate_af6();
let miso = gpioc.pc11.into_alternate_af6();
let mosi = gpioc.pc12.into_alternate_af6();
let mut spi = Spi::spi3(
dp.SPI3,
(sck, miso, mosi),
MODE_1,
KiloHertz(2000).into(),
clocks,
);
// DRV8301
let ncs = gpioc.pc13.into_push_pull_output();
let en_gate = gpiob.pb12.into_push_pull_output();
let mut drv8301 = Drv8301::new(&mut spi, ncs, en_gate);
drv8301.init().unwrap();
// Move the pin into our global storage
cortex_m::interrupt::free(|cs| *G_SPI3.borrow(cs).borrow_mut() = Some(spi));
// PWM
let channels = (gpioa.pa8.into_alternate_af1(), gpioa.pa9.into_alternate_af1(), gpioa.pa10.into_alternate_af1(), gpioa.pa11.into_alternate_af1());
let pwm = pwm::tim1(dp.TIM1, channels, clocks, 16u32.khz());
let (ch1, ch2, ch3, ch4) = pwm;
let mut ch4 = ch4;
{
// Set complementary oututs mode as AF1
gpiob.pb13.into_alternate_af1();
gpiob.pb14.into_alternate_af1();
gpiob.pb15.into_alternate_af1();
unsafe {
let tim1_regb = &(*(TIM1::ptr()));
// Enable complementary outputs
tim1_regb.ccer.modify(|_, w| w.cc1ne().set_bit());
tim1_regb.ccer.modify(|_, w| w.cc2ne().set_bit());
tim1_regb.ccer.modify(|_, w| w.cc3ne().set_bit());
// Set dead time
tim1_regb.bdtr.modify(|_, | {
// current sensing
unsafe {
let max_sample:u32 = (1 << 12) - 1;
let device = pac::Peripherals::steal();
device.ADC1.sr.modify(|_, w| w.jeoc().clear_bit());
let jdr1_data = device.ADC1.jdr1.read().jdata().bits();
let jdr1_offset = 48u32;
let so1 = ( ( (u32::from(jdr1_data) + jdr1_offset) * VDDA_CALIB ) / max_sample) as u16;
let jdr2_data = device.ADC1.jdr2.read().jdata().bits();
let jdr2_offset = 118u32;
let so2 = ( ( (u32::from(jdr2_data) + jdr2_offset) * VDDA_CALIB ) / max_sample) as u16;
CURRENT_B = (so1 as f32 - 1650.0) / 200.0;
CURRENT_C = (so2 as f32 - 1650.0) / 200.0;
CURRENT_A = - CURRENT_B - CURRENT_C;
} | identifier_body |
main.rs | Cell<Option<TypeEncoder>>> = Mutex::new(RefCell::new(None));
type TypeMotor = Motor;
static G_MOTOR: Mutex<RefCell<Option<TypeMotor>>> = Mutex::new(RefCell::new(None));
static G_TIM: Mutex<RefCell<Option<Timer<TIM2>>>> = Mutex::new(RefCell::new(None));
static mut CURRENT_A: f32 = 0.0;
static mut CURRENT_B: f32 = 0.0;
static mut CURRENT_C: f32 = 0.0;
static mut MOT_ANGLE: u16 = 0;
static mut MOT_ANGLE_OLD: u16 = 0;
static mut MOT_VELOCITY: f32 = 0.0;
static mut MOT_VELOCITY_OLD: f32 = 0.0;
static mut ERR_VELOCITY: f32 = 0.0;
static mut ERR_VELOCITY_INT: f32 = 0.0;
static mut REF_CURR_D: f32 = 0.0;
static mut REF_CURR_Q: f32 = 0.0;
// System
const TIM2_FREQ_KHZ: u32 = 10;
// Motor
const MOT_POLE_PAIRS: u16 = 12;
// Encoder
const ENC_RESOLUTION: u16 = 16384;
#[interrupt]
fn | () {
// current sensing
unsafe {
let max_sample:u32 = (1 << 12) - 1;
let device = pac::Peripherals::steal();
device.ADC1.sr.modify(|_, w| w.jeoc().clear_bit());
let jdr1_data = device.ADC1.jdr1.read().jdata().bits();
let jdr1_offset = 48u32;
let so1 = ( ( (u32::from(jdr1_data) + jdr1_offset) * VDDA_CALIB ) / max_sample) as u16;
let jdr2_data = device.ADC1.jdr2.read().jdata().bits();
let jdr2_offset = 118u32;
let so2 = ( ( (u32::from(jdr2_data) + jdr2_offset) * VDDA_CALIB ) / max_sample) as u16;
CURRENT_B = (so1 as f32 - 1650.0) / 200.0;
CURRENT_C = (so2 as f32 - 1650.0) / 200.0;
CURRENT_A = - CURRENT_B - CURRENT_C;
}
/*
// LED Debug
cortex_m::interrupt::free(|cs| {
if let Some(ref mut led) = G_LED.borrow(cs).borrow_mut().as_mut() {
led.toggle().unwrap();
}
});
*/
}
#[interrupt]
fn TIM2() {
cortex_m::interrupt::free(|cs| {
if let Some(ref mut tim) = G_TIM.borrow(cs).borrow_mut().as_mut() {
let _ = tim.wait();
}
});
static mut SPI3: Option<TypeSpi3> = None;
static mut MOTOR: Option<TypeMotor> = None;
unsafe{
let mut spi3 = SPI3.get_or_insert_with(|| {
cortex_m::interrupt::free(|cs| {
G_SPI3.borrow(cs).replace(None).unwrap()
})
});
let device = pac::Peripherals::steal();
let gpioa = device.GPIOA.split();
let ncs = gpioa.pa3.into_push_pull_output();
let mut as5048: TypeEncoder = AS5048A::new(&mut spi3, ncs);
// AS5048A
let measured_angle = as5048.angle().unwrap();
let angle_offset = 650u16;
MOT_ANGLE = (measured_angle - angle_offset) % ENC_RESOLUTION;
let electric_angle = MOT_ANGLE % (ENC_RESOLUTION/MOT_POLE_PAIRS);
let motor = MOTOR.get_or_insert_with(|| {
cortex_m::interrupt::free(|cs| {
G_MOTOR.borrow(cs).replace(None).unwrap()
})
});
// Velocity control
const REF_VELOCITY: f32 = - 100.0;
const VELLOCITY_PGAIN: f32 = 0.1;
const VELOCITY_IGAIN: f32 = 0.00001;
let res_velocity =
if (ENC_RESOLUTION-1000) < MOT_ANGLE_OLD && MOT_ANGLE < 1000 {
( MOT_ANGLE as f32 - MOT_ANGLE_OLD as f32 + ENC_RESOLUTION as f32 ) * TIM2_FREQ_KHZ as f32
} else if MOT_ANGLE_OLD < 1000 && MOT_ANGLE > (ENC_RESOLUTION-1000) {
( MOT_ANGLE as f32 - MOT_ANGLE_OLD as f32 - ENC_RESOLUTION as f32 ) * TIM2_FREQ_KHZ as f32
} else {
( MOT_ANGLE as f32 - MOT_ANGLE_OLD as f32 ) * TIM2_FREQ_KHZ as f32
};
let alpha = 0.1;
MOT_VELOCITY = alpha * res_velocity + (1.0 - alpha) * MOT_VELOCITY_OLD;
ERR_VELOCITY = MOT_VELOCITY - REF_VELOCITY;
ERR_VELOCITY_INT += ERR_VELOCITY;
REF_CURR_D = 0.0;
REF_CURR_Q = VELLOCITY_PGAIN * ERR_VELOCITY + VELOCITY_IGAIN * ERR_VELOCITY_INT;
REF_CURR_Q = -1.0 * REF_CURR_Q;
MOT_ANGLE_OLD = MOT_ANGLE;
MOT_VELOCITY_OLD = MOT_VELOCITY;
// select control mode
//motor.drive_profile().unwrap();
//motor.drive_sixstep().unwrap();
//motor.drive_anglebased_sixstep(electric_angle).unwrap();
motor.drive_foc(electric_angle, CURRENT_A, CURRENT_B, CURRENT_C, REF_CURR_D, REF_CURR_Q).unwrap();
}
/*
// LED Debug
cortex_m::interrupt::free(|cs| {
if let Some(ref mut led) = G_LED.borrow(cs).borrow_mut().as_mut() {
led.toggle().unwrap();
}
});
*/
}
#[entry]
fn main() -> ! {
let dp = pac::Peripherals::take().unwrap();
let cp = cortex_m::peripheral::Peripherals::take().unwrap();
let rcc = dp.RCC.constrain();
let clocks = rcc
.cfgr
.use_hse(8.mhz())
.sysclk(168.mhz())
.hclk(168.mhz())
.pclk1(42.mhz())
.pclk2(84.mhz())
.require_pll48clk()
.freeze();
let mut delay = hal::delay::Delay::new(cp.SYST, clocks);
let gpioa = dp.GPIOA.split();
let gpiob = dp.GPIOB.split();
let gpioc = dp.GPIOC.split();
// SPI3
let sck = gpioc.pc10.into_alternate_af6();
let miso = gpioc.pc11.into_alternate_af6();
let mosi = gpioc.pc12.into_alternate_af6();
let mut spi = Spi::spi3(
dp.SPI3,
(sck, miso, mosi),
MODE_1,
KiloHertz(2000).into(),
clocks,
);
// DRV8301
let ncs = gpioc.pc13.into_push_pull_output();
let en_gate = gpiob.pb12.into_push_pull_output();
let mut drv8301 = Drv8301::new(&mut spi, ncs, en_gate);
drv8301.init().unwrap();
// Move the pin into our global storage
cortex_m::interrupt::free(|cs| *G_SPI3.borrow(cs).borrow_mut() = Some(spi));
// PWM
let channels = (gpioa.pa8.into_alternate_af1(), gpioa.pa9.into_alternate_af1(), gpioa.pa10.into_alternate_af1(), gpioa.pa11.into_alternate_af1());
let pwm = pwm::tim1(dp.TIM1, channels, clocks, 16u32.khz());
let (ch1, ch2, ch3, ch4) = pwm;
let mut ch4 = ch4;
{
// Set complementary oututs mode as AF1
gpiob.pb13.into_alternate_af1();
gpiob.pb14.into_alternate_af1();
gpiob.pb15.into_alternate_af1();
unsafe {
let tim1_regb = &(*(TIM1::ptr()));
// Enable complementary outputs
tim1_regb.ccer.modify(|_, w| w.cc1ne().set_bit());
tim1_regb.ccer.modify(|_, w| w.cc2ne().set_bit());
tim1_regb.ccer.modify(|_, w| w.cc3ne().set_bit());
// Set dead time
tim1_regb.bdtr.modify(|_, w | ADC | identifier_name |
main.rs | static G_MOTOR: Mutex<RefCell<Option<TypeMotor>>> = Mutex::new(RefCell::new(None));
static G_TIM: Mutex<RefCell<Option<Timer<TIM2>>>> = Mutex::new(RefCell::new(None));
static mut CURRENT_A: f32 = 0.0;
static mut CURRENT_B: f32 = 0.0;
static mut CURRENT_C: f32 = 0.0;
static mut MOT_ANGLE: u16 = 0;
static mut MOT_ANGLE_OLD: u16 = 0;
static mut MOT_VELOCITY: f32 = 0.0;
static mut MOT_VELOCITY_OLD: f32 = 0.0;
static mut ERR_VELOCITY: f32 = 0.0;
static mut ERR_VELOCITY_INT: f32 = 0.0;
static mut REF_CURR_D: f32 = 0.0;
static mut REF_CURR_Q: f32 = 0.0;
// System
const TIM2_FREQ_KHZ: u32 = 10;
// Motor
const MOT_POLE_PAIRS: u16 = 12;
// Encoder
const ENC_RESOLUTION: u16 = 16384;
#[interrupt]
fn ADC() {
// current sensing
unsafe {
let max_sample:u32 = (1 << 12) - 1;
let device = pac::Peripherals::steal();
device.ADC1.sr.modify(|_, w| w.jeoc().clear_bit());
let jdr1_data = device.ADC1.jdr1.read().jdata().bits();
let jdr1_offset = 48u32;
let so1 = ( ( (u32::from(jdr1_data) + jdr1_offset) * VDDA_CALIB ) / max_sample) as u16;
let jdr2_data = device.ADC1.jdr2.read().jdata().bits();
let jdr2_offset = 118u32;
let so2 = ( ( (u32::from(jdr2_data) + jdr2_offset) * VDDA_CALIB ) / max_sample) as u16;
CURRENT_B = (so1 as f32 - 1650.0) / 200.0;
CURRENT_C = (so2 as f32 - 1650.0) / 200.0;
CURRENT_A = - CURRENT_B - CURRENT_C;
}
/*
// LED Debug
cortex_m::interrupt::free(|cs| {
if let Some(ref mut led) = G_LED.borrow(cs).borrow_mut().as_mut() {
led.toggle().unwrap();
}
});
*/
}
#[interrupt]
fn TIM2() {
cortex_m::interrupt::free(|cs| {
if let Some(ref mut tim) = G_TIM.borrow(cs).borrow_mut().as_mut() {
let _ = tim.wait();
}
});
static mut SPI3: Option<TypeSpi3> = None;
static mut MOTOR: Option<TypeMotor> = None;
unsafe{
let mut spi3 = SPI3.get_or_insert_with(|| {
cortex_m::interrupt::free(|cs| {
G_SPI3.borrow(cs).replace(None).unwrap()
})
});
let device = pac::Peripherals::steal();
let gpioa = device.GPIOA.split();
let ncs = gpioa.pa3.into_push_pull_output();
let mut as5048: TypeEncoder = AS5048A::new(&mut spi3, ncs);
// AS5048A
let measured_angle = as5048.angle().unwrap();
let angle_offset = 650u16;
MOT_ANGLE = (measured_angle - angle_offset) % ENC_RESOLUTION;
let electric_angle = MOT_ANGLE % (ENC_RESOLUTION/MOT_POLE_PAIRS);
let motor = MOTOR.get_or_insert_with(|| {
cortex_m::interrupt::free(|cs| {
G_MOTOR.borrow(cs).replace(None).unwrap()
})
});
// Velocity control
const REF_VELOCITY: f32 = - 100.0;
const VELLOCITY_PGAIN: f32 = 0.1;
const VELOCITY_IGAIN: f32 = 0.00001;
let res_velocity =
if (ENC_RESOLUTION-1000) < MOT_ANGLE_OLD && MOT_ANGLE < 1000 {
( MOT_ANGLE as f32 - MOT_ANGLE_OLD as f32 + ENC_RESOLUTION as f32 ) * TIM2_FREQ_KHZ as f32
} else if MOT_ANGLE_OLD < 1000 && MOT_ANGLE > (ENC_RESOLUTION-1000) {
( MOT_ANGLE as f32 - MOT_ANGLE_OLD as f32 - ENC_RESOLUTION as f32 ) * TIM2_FREQ_KHZ as f32
} else {
( MOT_ANGLE as f32 - MOT_ANGLE_OLD as f32 ) * TIM2_FREQ_KHZ as f32
};
let alpha = 0.1;
MOT_VELOCITY = alpha * res_velocity + (1.0 - alpha) * MOT_VELOCITY_OLD;
ERR_VELOCITY = MOT_VELOCITY - REF_VELOCITY;
ERR_VELOCITY_INT += ERR_VELOCITY;
REF_CURR_D = 0.0;
REF_CURR_Q = VELLOCITY_PGAIN * ERR_VELOCITY + VELOCITY_IGAIN * ERR_VELOCITY_INT;
REF_CURR_Q = -1.0 * REF_CURR_Q;
MOT_ANGLE_OLD = MOT_ANGLE;
MOT_VELOCITY_OLD = MOT_VELOCITY;
// select control mode
//motor.drive_profile().unwrap();
//motor.drive_sixstep().unwrap();
//motor.drive_anglebased_sixstep(electric_angle).unwrap();
motor.drive_foc(electric_angle, CURRENT_A, CURRENT_B, CURRENT_C, REF_CURR_D, REF_CURR_Q).unwrap();
}
/*
// LED Debug
cortex_m::interrupt::free(|cs| {
if let Some(ref mut led) = G_LED.borrow(cs).borrow_mut().as_mut() {
led.toggle().unwrap();
}
});
*/
}
#[entry]
fn main() -> ! {
let dp = pac::Peripherals::take().unwrap();
let cp = cortex_m::peripheral::Peripherals::take().unwrap();
let rcc = dp.RCC.constrain();
let clocks = rcc
.cfgr
.use_hse(8.mhz())
.sysclk(168.mhz())
.hclk(168.mhz())
.pclk1(42.mhz())
.pclk2(84.mhz())
.require_pll48clk()
.freeze();
let mut delay = hal::delay::Delay::new(cp.SYST, clocks);
let gpioa = dp.GPIOA.split();
let gpiob = dp.GPIOB.split();
let gpioc = dp.GPIOC.split();
// SPI3
let sck = gpioc.pc10.into_alternate_af6();
let miso = gpioc.pc11.into_alternate_af6();
let mosi = gpioc.pc12.into_alternate_af6();
let mut spi = Spi::spi3(
dp.SPI3,
(sck, miso, mosi),
MODE_1,
KiloHertz(2000).into(),
clocks,
);
// DRV8301
let ncs = gpioc.pc13.into_push_pull_output();
let en_gate = gpiob.pb12.into_push_pull_output();
let mut drv8301 = Drv8301::new(&mut spi, ncs, en_gate);
drv8301.init().unwrap();
// Move the pin into our global storage
cortex_m::interrupt::free(|cs| *G_SPI3.borrow(cs).borrow_mut() = Some(spi));
// PWM
let channels = (gpioa.pa8.into_alternate_af1(), gpioa.pa9.into_alternate_af1(), gpioa.pa10.into_alternate_af1(), gpioa.pa11.into_alternate_af1());
let pwm = pwm::tim1(dp.TIM1, channels, clocks, 16u32.khz());
let (ch1, ch2, ch3, ch4) = pwm;
let mut ch4 = ch4;
{
// Set complementary oututs mode as AF1
gpiob.pb13.into_alternate_af1();
gpiob.pb14.into_alternate_af1();
gpiob.pb15.into_alternate_af1();
unsafe {
let tim1_regb = &(*(TIM1::ptr()));
// Enable complementary outputs
tim1_regb.ccer.modify(|_, w| w.cc1ne().set_bit());
tim1_regb.ccer.modify(|_, w| w | type TypeEncoder<'a> = AS5048A<'a, TypeSpi3, gpioa::PA3<Output<PushPull>>>;
//static G_AS5048A: Mutex<RefCell<Option<TypeEncoder>>> = Mutex::new(RefCell::new(None));
type TypeMotor = Motor; | random_line_split | |
MouvementBrownien.py | = -math.floor(GRID_HEIGHT/2); # Coordonnees dans referentiel enonce
GRID_Y_MAX = math.floor(GRID_HEIGHT/2); # Coordonnees dans referentiel enonce
#
CANVAS_WIDTH = GRID_WIDTH*GRID_STEP; # Taille resultante du canvas (zone dessin)
CANVAS_HEIGHT = GRID_HEIGHT*GRID_STEP; # Taille resultante du canvas (zone dessin)
CANVAS_BG_COLOR = "white"; # Couleur de fond du canvas (zone dessin)
#
NB_PARTICLES = 500; # Nombre de particles a simuler
PARTICLE_SIZE = GRID_STEP*2/3; # Taille des cercles pour representer chq particule
PARTICLE_COLOR = "red"; # Couleur des particules
#
NB_SIMU_STEPS = 100; # Nombre de pas de temps dans la simulation
SIMU_INVSPEED = 100; # Nombre de millisecondes entre chaque pas de temps
## The only shared var
paused=False;
#### Fonction des particules
# Initialise les positions des particules
def initParticles(N):
particles = [];
for p in xrange(N):
initialPos = { 'x': 0, 'y': 0 };
particles.append(initialPos);
return particles;
# Deplace aleatoirement une unique particule, en respectant la "condition de bordure"
def moveSingleParticle(oldPos):
aleat = random.randint(0, 3);
if (aleat==0):
newPos = { 'x':oldPos['x']+1, 'y': oldPos['y']};
elif (aleat==1):
newPos = { 'x': oldPos['x']-1, 'y': oldPos['y']};
elif (aleat==2):
newPos = { 'x': oldPos['x'], 'y': oldPos['y']+1};
elif (aleat==3):
newPos = { 'x': oldPos['x'], 'y': oldPos['y']-1};
else:
print("Should not have reached here! "+str(aleat)+" is not an accepted output");
## "Lorsqu'une particule rencontre une paroi, elle ne bouge pas si le mouvement
## determine aleatoirement la fait traverser cette paroi."
if (newPos['x']<GRID_X_MIN+1):
newPos['x'] = GRID_X_MIN+1;
elif (newPos['x']>GRID_X_MAX-1):
newPos['x'] = GRID_X_MAX-1;
elif (newPos['y']<GRID_Y_MIN+1):
newPos['y'] = GRID_Y_MIN+1;
elif (newPos['y']>GRID_Y_MAX-1):
newPos['y'] = GRID_Y_MAX-1;
return newPos;
# Deplace toutes les particules d'un pas aleatoire
def moveParticles(particles):
newParticles = [];
for p in xrange(len(particles)):
newParticles.append(moveSingleParticle(particles[p]));
return(newParticles);
def applyGravity(particles):
newParticles = [];
for p in xrange(len(particles)):
part = particles[p];
if (part['y']<GRID_Y_MAX-1): # Only change value if it particle does not exit screen
part['y'] += 1; # Make particle go down
newParticles.append(part);
return(newParticles);
#### Problem/Model to GUI/View functions
# Convertit la liste des positions des particules en un tableau
# (proche de la "grille graphique")
def convertToMatrix(particles):
matrix = [[0 for x in range(GRID_WIDTH)] for y in range(GRID_WIDTH)];
for p in xrange(len(particles)):
currentParticle = particles[p];
tx = int(math.floor(currentParticle['x']-GRID_X_MIN));
ty = int(math.floor(currentParticle['y']-GRID_Y_MIN));
##print("----------- Particle position: ("+str(x)+","+str(y)+")->("+str(tx)+","+str(ty)+")"); ## Debug
##print("----------- Grid: ["+str(GRID_X_MIN)+"->"+str(GRID_X_MAX)+" ; "+str(GRID_Y_MIN)+"->"+str(GRID_Y_MAX)+"] / ("+str(GRID_WIDTH)+", "+str(GRID_HEIGHT)+")");
matrix[tx][ty] += 1;
##print(matrix); # for debugging
return matrix;
#### Fonctions graphiques
# Un/Pauses the simulation
def pause(pauseButton):
global paused; ## required to set global var
paused = not paused;
if (paused):
pauseButton.config(text="Unpause");
else:
pauseButton.config(text="Pause");
# Creation & Placement des elements graphiques
def initGUI(rootWindow):
##global canvas; ## for debugging purpose
canvas = tkinter.Canvas(rootWindow, width=CANVAS_WIDTH, height=CANVAS_HEIGHT);
canvas.config(background=CANVAS_BG_COLOR);
canvas.pack();
slider = tkinter.Scale(rootWindow, from_=0, to=10, orient=tkinter.HORIZONTAL);
slider.set(0);
#slider.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
slider.pack();
label = tkinter.Label(rootWindow, text='t=0');
labelfont = ('times', 20, 'bold');
label.config(bg='black', fg='yellow');
label.config(font=labelfont);
label.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
label.pack(); # expand=YES, fill=BOTH
startButton = tkinter.Button(rootWindow, text="Démarrer",
command= lambda: startSimulationLoop(canvas,label,slider));
startButton.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
startButton.pack();
pauseButton = tkinter.Button(rootWindow, text="Pause",
command=lambda: pause(pauseButton));
pauseButton.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
pauseButton.pack();
exitButton = tkinter.Button(rootWindow, text="Sortir",
command=rootWindow.destroy);
exitButton.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
exitButton.pack();
def drawGrid(canvas):
for x in xrange(0, CANVAS_WIDTH, GRID_STEP):
l1 = canvas.create_line(x, 0, x, CANVAS_HEIGHT, fill=GRID_COLOR);
canvas.itemconfig(l1, tags=("vl")); ## Useless
for y in xrange(0, CANVAS_HEIGHT, GRID_STEP):
l2 = canvas.create_line(0, y, CANVAS_WIDTH, y, fill=GRID_COLOR);
canvas.itemconfig(l2, tags=("hl")); ## Useless
ctr = canvas.create_oval(-GRID_X_MIN*GRID_STEP-PARTICLE_SIZE/2,
-GRID_Y_MIN*GRID_STEP-PARTICLE_SIZE/2,
-GRID_X_MIN*GRID_STEP+PARTICLE_SIZE/2,
-GRID_Y_MIN*GRID_STEP+PARTICLE_SIZE/2,
outline="grey", fill="grey");
# def drawParticlesFromPositions(canvas, particles):
# for p in xrange(len(particles)):
# currentParticle = particles[p];
# tx = currentParticle['x']-GRID_X_MIN;
# ty = currentParticle['y']-GRID_Y_MIN;
# txg = tx*GRID_STEP;
# tyg = ty*GRID_STEP;
# o = canvas.create_oval(txg-PARTICLE_SIZE, tyg-PARTICLE_SIZE,
# txg+PARTICLE_SIZE, tyg+PARTICLE_SIZE,
# outline=PARTICLE_COLOR, fill=PARTICLE_COLOR);
# canvas.itemconfig(o, tags=("part"+str(p))); ## Useless
# canvas.update_idletasks(); # THIS IS A DIRTY HACK!!!
def drawParticlesFromGrid(canvas, matrix):
for x in xrange(GRID_WIDTH):
for y in xrange(GRID_HEIGHT):
if (matrix[x][y]>0):
xg = x*GRID_STEP;
yg = y*GRID_STEP;
o = canvas.create_oval(xg-PARTICLE_SIZE, yg-PARTICLE_SIZE,
xg+PARTICLE_SIZE, yg+PARTICLE_SIZE,
outline=PARTICLE_COLOR, fill=PARTICLE_COLOR);
canvas.itemconfig(o, tags=("part("+str(x)+"/"+str(y)+")")); ## Useless
##print("----------- Particle position: "+str(xg)+"/"+str(yg)); ## Debug
t = canvas.create_text((xg, yg), text=str(matrix[x][y]), font=FONT);
canvas.itemconfig(t, tags=("partCount("+str(x)+"/"+str(y)+")")); ## Useless
canvas.update_idletasks(); # THIS IS A DIRTY HACK!!!
def drawTime(label, t):
l |
# Lance la simulation with loop
## Problem1: we do no give a chance to the GUI elements to update => we need to force them
## Problem2: since the event loop is broken, the "Sortir" button does not work.
# def startSimulationLoop(canvas, label):
# particles = initParticles(NB_PARTICLES);
# for step in xrange(N | abel.configure(text="t="+str(t));
label.update_idletasks(); # THIS IS A DIRTY HACK!!!
| identifier_body |
MouvementBrownien.py | = -math.floor(GRID_HEIGHT/2); # Coordonnees dans referentiel enonce
GRID_Y_MAX = math.floor(GRID_HEIGHT/2); # Coordonnees dans referentiel enonce
#
CANVAS_WIDTH = GRID_WIDTH*GRID_STEP; # Taille resultante du canvas (zone dessin)
CANVAS_HEIGHT = GRID_HEIGHT*GRID_STEP; # Taille resultante du canvas (zone dessin)
CANVAS_BG_COLOR = "white"; # Couleur de fond du canvas (zone dessin)
#
NB_PARTICLES = 500; # Nombre de particles a simuler
PARTICLE_SIZE = GRID_STEP*2/3; # Taille des cercles pour representer chq particule
PARTICLE_COLOR = "red"; # Couleur des particules
#
NB_SIMU_STEPS = 100; # Nombre de pas de temps dans la simulation
SIMU_INVSPEED = 100; # Nombre de millisecondes entre chaque pas de temps
## The only shared var
paused=False;
#### Fonction des particules
# Initialise les positions des particules
def initParticles(N):
particles = [];
for p in xrange(N):
initialPos = { 'x': 0, 'y': 0 };
particles.append(initialPos);
return particles;
# Deplace aleatoirement une unique particule, en respectant la "condition de bordure"
def moveSingleParticle(oldPos):
aleat = random.randint(0, 3);
if (aleat==0):
newPos = { 'x':oldPos['x']+1, 'y': oldPos['y']};
elif (aleat==1):
newPos = { 'x': oldPos['x']-1, 'y': oldPos['y']};
elif (aleat==2):
newPos = { 'x': oldPos['x'], 'y': oldPos['y']+1};
elif (aleat==3):
newPos = { 'x': oldPos['x'], 'y': oldPos['y']-1};
else:
print("Should not have reached here! "+str(aleat)+" is not an accepted output");
## "Lorsqu'une particule rencontre une paroi, elle ne bouge pas si le mouvement
## determine aleatoirement la fait traverser cette paroi."
if (newPos['x']<GRID_X_MIN+1):
newPos['x'] = GRID_X_MIN+1;
elif (newPos['x']>GRID_X_MAX-1):
newPos['x'] = GRID_X_MAX-1;
elif (newPos['y']<GRID_Y_MIN+1):
newPos['y'] = GRID_Y_MIN+1;
elif (newPos['y']>GRID_Y_MAX-1):
newPos['y'] = GRID_Y_MAX-1;
return newPos;
# Deplace toutes les particules d'un pas aleatoire
def moveParticles(particles):
newParticles = [];
for p in xrange(len(particles)):
newParticles.append(moveSingleParticle(particles[p]));
return(newParticles);
def applyGravity(particles):
newParticles = [];
for p in xrange(len(particles)):
part = particles[p];
if (part['y']<GRID_Y_MAX-1): # Only change value if it particle does not exit screen
part['y'] += 1; # Make particle go down
newParticles.append(part);
return(newParticles);
#### Problem/Model to GUI/View functions
# Convertit la liste des positions des particules en un tableau
# (proche de la "grille graphique")
def convertToMatrix(particles):
matrix = [[0 for x in range(GRID_WIDTH)] for y in range(GRID_WIDTH)];
for p in xrange(len(particles)):
currentParticle = particles[p];
tx = int(math.floor(currentParticle['x']-GRID_X_MIN));
ty = int(math.floor(currentParticle['y']-GRID_Y_MIN));
##print("----------- Particle position: ("+str(x)+","+str(y)+")->("+str(tx)+","+str(ty)+")"); ## Debug
##print("----------- Grid: ["+str(GRID_X_MIN)+"->"+str(GRID_X_MAX)+" ; "+str(GRID_Y_MIN)+"->"+str(GRID_Y_MAX)+"] / ("+str(GRID_WIDTH)+", "+str(GRID_HEIGHT)+")");
matrix[tx][ty] += 1;
##print(matrix); # for debugging
return matrix;
#### Fonctions graphiques
# Un/Pauses the simulation
def pause(pauseButton):
global paused; ## required to set global var
paused = not paused;
if (paused):
pauseButton.config(text="Unpause");
else:
pauseButton.config(text="Pause");
# Creation & Placement des elements graphiques
def initGUI(rootWindow):
##global canvas; ## for debugging purpose
canvas = tkinter.Canvas(rootWindow, width=CANVAS_WIDTH, height=CANVAS_HEIGHT);
canvas.config(background=CANVAS_BG_COLOR);
canvas.pack();
slider = tkinter.Scale(rootWindow, from_=0, to=10, orient=tkinter.HORIZONTAL);
slider.set(0);
#slider.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
slider.pack();
label = tkinter.Label(rootWindow, text='t=0');
labelfont = ('times', 20, 'bold');
label.config(bg='black', fg='yellow');
label.config(font=labelfont);
label.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
label.pack(); # expand=YES, fill=BOTH
startButton = tkinter.Button(rootWindow, text="Démarrer",
command= lambda: startSimulationLoop(canvas,label,slider));
startButton.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
startButton.pack();
pauseButton = tkinter.Button(rootWindow, text="Pause",
command=lambda: pause(pauseButton));
pauseButton.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
pauseButton.pack();
exitButton = tkinter.Button(rootWindow, text="Sortir",
command=rootWindow.destroy);
exitButton.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
exitButton.pack();
def drawGrid(canvas):
for x in xrange(0, CANVAS_WIDTH, GRID_STEP):
l1 = canvas.create_line(x, 0, x, CANVAS_HEIGHT, fill=GRID_COLOR);
canvas.itemconfig(l1, tags=("vl")); ## Useless
for y in xrange(0, CANVAS_HEIGHT, GRID_STEP):
l2 = canvas.create_line(0, y, CANVAS_WIDTH, y, fill=GRID_COLOR);
canvas.itemconfig(l2, tags=("hl")); ## Useless
ctr = canvas.create_oval(-GRID_X_MIN*GRID_STEP-PARTICLE_SIZE/2,
-GRID_Y_MIN*GRID_STEP-PARTICLE_SIZE/2,
-GRID_X_MIN*GRID_STEP+PARTICLE_SIZE/2,
-GRID_Y_MIN*GRID_STEP+PARTICLE_SIZE/2,
outline="grey", fill="grey");
# def drawParticlesFromPositions(canvas, particles):
# for p in xrange(len(particles)):
# currentParticle = particles[p];
# tx = currentParticle['x']-GRID_X_MIN; | # ty = currentParticle['y']-GRID_Y_MIN;
# txg = tx*GRID_STEP;
# tyg = ty*GRID_STEP;
# o = canvas.create_oval(txg-PARTICLE_SIZE, tyg-PARTICLE_SIZE,
# txg+PARTICLE_SIZE, tyg+PARTICLE_SIZE,
# outline=PARTICLE_COLOR, fill=PARTICLE_COLOR);
# canvas.itemconfig(o, tags=("part"+str(p))); ## Useless
# canvas.update_idletasks(); # THIS IS A DIRTY HACK!!!
def drawParticlesFromGrid(canvas, matrix):
for x in xrange(GRID_WIDTH):
for y in xrange(GRID_HEIGHT):
if (matrix[x][y]>0):
xg = x*GRID_STEP;
yg = y*GRID_STEP;
o = canvas.create_oval(xg-PARTICLE_SIZE, yg-PARTICLE_SIZE,
xg+PARTICLE_SIZE, yg+PARTICLE_SIZE,
outline=PARTICLE_COLOR, fill=PARTICLE_COLOR);
canvas.itemconfig(o, tags=("part("+str(x)+"/"+str(y)+")")); ## Useless
##print("----------- Particle position: "+str(xg)+"/"+str(yg)); ## Debug
t = canvas.create_text((xg, yg), text=str(matrix[x][y]), font=FONT);
canvas.itemconfig(t, tags=("partCount("+str(x)+"/"+str(y)+")")); ## Useless
canvas.update_idletasks(); # THIS IS A DIRTY HACK!!!
def drawTime(label, t):
label.configure(text="t="+str(t));
label.update_idletasks(); # THIS IS A DIRTY HACK!!!
# Lance la simulation with loop
## Problem1: we do no give a chance to the GUI elements to update => we need to force them
## Problem2: since the event loop is broken, the "Sortir" button does not work.
# def startSimulationLoop(canvas, label):
# particles = initParticles(NB_PARTICLES);
# for step in xrange(NB_SIM | random_line_split | |
MouvementBrownien.py | = -math.floor(GRID_HEIGHT/2); # Coordonnees dans referentiel enonce
GRID_Y_MAX = math.floor(GRID_HEIGHT/2); # Coordonnees dans referentiel enonce
#
CANVAS_WIDTH = GRID_WIDTH*GRID_STEP; # Taille resultante du canvas (zone dessin)
CANVAS_HEIGHT = GRID_HEIGHT*GRID_STEP; # Taille resultante du canvas (zone dessin)
CANVAS_BG_COLOR = "white"; # Couleur de fond du canvas (zone dessin)
#
NB_PARTICLES = 500; # Nombre de particles a simuler
PARTICLE_SIZE = GRID_STEP*2/3; # Taille des cercles pour representer chq particule
PARTICLE_COLOR = "red"; # Couleur des particules
#
NB_SIMU_STEPS = 100; # Nombre de pas de temps dans la simulation
SIMU_INVSPEED = 100; # Nombre de millisecondes entre chaque pas de temps
## The only shared var
paused=False;
#### Fonction des particules
# Initialise les positions des particules
def initParticles(N):
particles = [];
for p in xrange(N):
initialPos = { 'x': 0, 'y': 0 };
particles.append(initialPos);
return particles;
# Deplace aleatoirement une unique particule, en respectant la "condition de bordure"
def moveSingleParticle(oldPos):
aleat = random.randint(0, 3);
if (aleat==0):
newPos = { 'x':oldPos['x']+1, 'y': oldPos['y']};
elif (aleat==1):
newPos = { 'x': oldPos['x']-1, 'y': oldPos['y']};
elif (aleat==2):
newPos = { 'x': oldPos['x'], 'y': oldPos['y']+1};
elif (aleat==3):
newPos = { 'x': oldPos['x'], 'y': oldPos['y']-1};
else:
print("Should not have reached here! "+str(aleat)+" is not an accepted output");
## "Lorsqu'une particule rencontre une paroi, elle ne bouge pas si le mouvement
## determine aleatoirement la fait traverser cette paroi."
if (newPos['x']<GRID_X_MIN+1):
newPos['x'] = GRID_X_MIN+1;
elif (newPos['x']>GRID_X_MAX-1):
newPos['x'] = GRID_X_MAX-1;
elif (newPos['y']<GRID_Y_MIN+1):
newPos['y'] = GRID_Y_MIN+1;
elif (newPos['y']>GRID_Y_MAX-1):
newPos['y'] = GRID_Y_MAX-1;
return newPos;
# Deplace toutes les particules d'un pas aleatoire
def moveParticles(particles):
newParticles = [];
for p in xrange(len(particles)):
newParticles.append(moveSingleParticle(particles[p]));
return(newParticles);
def applyGravity(particles):
newParticles = [];
for p in xrange(len(particles)):
part = particles[p];
if (part['y']<GRID_Y_MAX-1): # Only change value if it particle does not exit screen
part['y'] += 1; # Make particle go down
newParticles.append(part);
return(newParticles);
#### Problem/Model to GUI/View functions
# Convertit la liste des positions des particules en un tableau
# (proche de la "grille graphique")
def convertToMatrix(particles):
matrix = [[0 for x in range(GRID_WIDTH)] for y in range(GRID_WIDTH)];
for p in xrange(len(particles)):
currentParticle = particles[p];
tx = int(math.floor(currentParticle['x']-GRID_X_MIN));
ty = int(math.floor(currentParticle['y']-GRID_Y_MIN));
##print("----------- Particle position: ("+str(x)+","+str(y)+")->("+str(tx)+","+str(ty)+")"); ## Debug
##print("----------- Grid: ["+str(GRID_X_MIN)+"->"+str(GRID_X_MAX)+" ; "+str(GRID_Y_MIN)+"->"+str(GRID_Y_MAX)+"] / ("+str(GRID_WIDTH)+", "+str(GRID_HEIGHT)+")");
matrix[tx][ty] += 1;
##print(matrix); # for debugging
return matrix;
#### Fonctions graphiques
# Un/Pauses the simulation
def pause(pauseButton):
global paused; ## required to set global var
paused = not paused;
if (paused):
pauseButton.config(text="Unpause");
else:
|
# Creation & Placement des elements graphiques
def initGUI(rootWindow):
##global canvas; ## for debugging purpose
canvas = tkinter.Canvas(rootWindow, width=CANVAS_WIDTH, height=CANVAS_HEIGHT);
canvas.config(background=CANVAS_BG_COLOR);
canvas.pack();
slider = tkinter.Scale(rootWindow, from_=0, to=10, orient=tkinter.HORIZONTAL);
slider.set(0);
#slider.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
slider.pack();
label = tkinter.Label(rootWindow, text='t=0');
labelfont = ('times', 20, 'bold');
label.config(bg='black', fg='yellow');
label.config(font=labelfont);
label.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
label.pack(); # expand=YES, fill=BOTH
startButton = tkinter.Button(rootWindow, text="Démarrer",
command= lambda: startSimulationLoop(canvas,label,slider));
startButton.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
startButton.pack();
pauseButton = tkinter.Button(rootWindow, text="Pause",
command=lambda: pause(pauseButton));
pauseButton.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
pauseButton.pack();
exitButton = tkinter.Button(rootWindow, text="Sortir",
command=rootWindow.destroy);
exitButton.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
exitButton.pack();
def drawGrid(canvas):
for x in xrange(0, CANVAS_WIDTH, GRID_STEP):
l1 = canvas.create_line(x, 0, x, CANVAS_HEIGHT, fill=GRID_COLOR);
canvas.itemconfig(l1, tags=("vl")); ## Useless
for y in xrange(0, CANVAS_HEIGHT, GRID_STEP):
l2 = canvas.create_line(0, y, CANVAS_WIDTH, y, fill=GRID_COLOR);
canvas.itemconfig(l2, tags=("hl")); ## Useless
ctr = canvas.create_oval(-GRID_X_MIN*GRID_STEP-PARTICLE_SIZE/2,
-GRID_Y_MIN*GRID_STEP-PARTICLE_SIZE/2,
-GRID_X_MIN*GRID_STEP+PARTICLE_SIZE/2,
-GRID_Y_MIN*GRID_STEP+PARTICLE_SIZE/2,
outline="grey", fill="grey");
# def drawParticlesFromPositions(canvas, particles):
# for p in xrange(len(particles)):
# currentParticle = particles[p];
# tx = currentParticle['x']-GRID_X_MIN;
# ty = currentParticle['y']-GRID_Y_MIN;
# txg = tx*GRID_STEP;
# tyg = ty*GRID_STEP;
# o = canvas.create_oval(txg-PARTICLE_SIZE, tyg-PARTICLE_SIZE,
# txg+PARTICLE_SIZE, tyg+PARTICLE_SIZE,
# outline=PARTICLE_COLOR, fill=PARTICLE_COLOR);
# canvas.itemconfig(o, tags=("part"+str(p))); ## Useless
# canvas.update_idletasks(); # THIS IS A DIRTY HACK!!!
def drawParticlesFromGrid(canvas, matrix):
for x in xrange(GRID_WIDTH):
for y in xrange(GRID_HEIGHT):
if (matrix[x][y]>0):
xg = x*GRID_STEP;
yg = y*GRID_STEP;
o = canvas.create_oval(xg-PARTICLE_SIZE, yg-PARTICLE_SIZE,
xg+PARTICLE_SIZE, yg+PARTICLE_SIZE,
outline=PARTICLE_COLOR, fill=PARTICLE_COLOR);
canvas.itemconfig(o, tags=("part("+str(x)+"/"+str(y)+")")); ## Useless
##print("----------- Particle position: "+str(xg)+"/"+str(yg)); ## Debug
t = canvas.create_text((xg, yg), text=str(matrix[x][y]), font=FONT);
canvas.itemconfig(t, tags=("partCount("+str(x)+"/"+str(y)+")")); ## Useless
canvas.update_idletasks(); # THIS IS A DIRTY HACK!!!
def drawTime(label, t):
label.configure(text="t="+str(t));
label.update_idletasks(); # THIS IS A DIRTY HACK!!!
# Lance la simulation with loop
## Problem1: we do no give a chance to the GUI elements to update => we need to force them
## Problem2: since the event loop is broken, the "Sortir" button does not work.
# def startSimulationLoop(canvas, label):
# particles = initParticles(NB_PARTICLES);
# for step in xrange(NB | pauseButton.config(text="Pause"); | conditional_block |
MouvementBrownien.py | = -math.floor(GRID_HEIGHT/2); # Coordonnees dans referentiel enonce
GRID_Y_MAX = math.floor(GRID_HEIGHT/2); # Coordonnees dans referentiel enonce
#
CANVAS_WIDTH = GRID_WIDTH*GRID_STEP; # Taille resultante du canvas (zone dessin)
CANVAS_HEIGHT = GRID_HEIGHT*GRID_STEP; # Taille resultante du canvas (zone dessin)
CANVAS_BG_COLOR = "white"; # Couleur de fond du canvas (zone dessin)
#
NB_PARTICLES = 500; # Nombre de particles a simuler
PARTICLE_SIZE = GRID_STEP*2/3; # Taille des cercles pour representer chq particule
PARTICLE_COLOR = "red"; # Couleur des particules
#
NB_SIMU_STEPS = 100; # Nombre de pas de temps dans la simulation
SIMU_INVSPEED = 100; # Nombre de millisecondes entre chaque pas de temps
## The only shared var
paused=False;
#### Fonction des particules
# Initialise les positions des particules
def initParticles(N):
particles = [];
for p in xrange(N):
initialPos = { 'x': 0, 'y': 0 };
particles.append(initialPos);
return particles;
# Deplace aleatoirement une unique particule, en respectant la "condition de bordure"
def moveSingleParticle(oldPos):
aleat = random.randint(0, 3);
if (aleat==0):
newPos = { 'x':oldPos['x']+1, 'y': oldPos['y']};
elif (aleat==1):
newPos = { 'x': oldPos['x']-1, 'y': oldPos['y']};
elif (aleat==2):
newPos = { 'x': oldPos['x'], 'y': oldPos['y']+1};
elif (aleat==3):
newPos = { 'x': oldPos['x'], 'y': oldPos['y']-1};
else:
print("Should not have reached here! "+str(aleat)+" is not an accepted output");
## "Lorsqu'une particule rencontre une paroi, elle ne bouge pas si le mouvement
## determine aleatoirement la fait traverser cette paroi."
if (newPos['x']<GRID_X_MIN+1):
newPos['x'] = GRID_X_MIN+1;
elif (newPos['x']>GRID_X_MAX-1):
newPos['x'] = GRID_X_MAX-1;
elif (newPos['y']<GRID_Y_MIN+1):
newPos['y'] = GRID_Y_MIN+1;
elif (newPos['y']>GRID_Y_MAX-1):
newPos['y'] = GRID_Y_MAX-1;
return newPos;
# Deplace toutes les particules d'un pas aleatoire
def moveParticles(particles):
newParticles = [];
for p in xrange(len(particles)):
newParticles.append(moveSingleParticle(particles[p]));
return(newParticles);
def applyGravity(particles):
newParticles = [];
for p in xrange(len(particles)):
part = particles[p];
if (part['y']<GRID_Y_MAX-1): # Only change value if it particle does not exit screen
part['y'] += 1; # Make particle go down
newParticles.append(part);
return(newParticles);
#### Problem/Model to GUI/View functions
# Convertit la liste des positions des particules en un tableau
# (proche de la "grille graphique")
def convertToMatrix(particles):
matrix = [[0 for x in range(GRID_WIDTH)] for y in range(GRID_WIDTH)];
for p in xrange(len(particles)):
currentParticle = particles[p];
tx = int(math.floor(currentParticle['x']-GRID_X_MIN));
ty = int(math.floor(currentParticle['y']-GRID_Y_MIN));
##print("----------- Particle position: ("+str(x)+","+str(y)+")->("+str(tx)+","+str(ty)+")"); ## Debug
##print("----------- Grid: ["+str(GRID_X_MIN)+"->"+str(GRID_X_MAX)+" ; "+str(GRID_Y_MIN)+"->"+str(GRID_Y_MAX)+"] / ("+str(GRID_WIDTH)+", "+str(GRID_HEIGHT)+")");
matrix[tx][ty] += 1;
##print(matrix); # for debugging
return matrix;
#### Fonctions graphiques
# Un/Pauses the simulation
def pause(pauseButton):
global paused; ## required to set global var
paused = not paused;
if (paused):
pauseButton.config(text="Unpause");
else:
pauseButton.config(text="Pause");
# Creation & Placement des elements graphiques
def initGUI(rootWindow):
##global canvas; ## for debugging purpose
canvas = tkinter.Canvas(rootWindow, width=CANVAS_WIDTH, height=CANVAS_HEIGHT);
canvas.config(background=CANVAS_BG_COLOR);
canvas.pack();
slider = tkinter.Scale(rootWindow, from_=0, to=10, orient=tkinter.HORIZONTAL);
slider.set(0);
#slider.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
slider.pack();
label = tkinter.Label(rootWindow, text='t=0');
labelfont = ('times', 20, 'bold');
label.config(bg='black', fg='yellow');
label.config(font=labelfont);
label.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
label.pack(); # expand=YES, fill=BOTH
startButton = tkinter.Button(rootWindow, text="Démarrer",
command= lambda: startSimulationLoop(canvas,label,slider));
startButton.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
startButton.pack();
pauseButton = tkinter.Button(rootWindow, text="Pause",
command=lambda: pause(pauseButton));
pauseButton.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
pauseButton.pack();
exitButton = tkinter.Button(rootWindow, text="Sortir",
command=rootWindow.destroy);
exitButton.config(height=GUI_ELT_HEIGHT, width=GUI_ELT_WIDTH);
exitButton.pack();
def d | canvas):
for x in xrange(0, CANVAS_WIDTH, GRID_STEP):
l1 = canvas.create_line(x, 0, x, CANVAS_HEIGHT, fill=GRID_COLOR);
canvas.itemconfig(l1, tags=("vl")); ## Useless
for y in xrange(0, CANVAS_HEIGHT, GRID_STEP):
l2 = canvas.create_line(0, y, CANVAS_WIDTH, y, fill=GRID_COLOR);
canvas.itemconfig(l2, tags=("hl")); ## Useless
ctr = canvas.create_oval(-GRID_X_MIN*GRID_STEP-PARTICLE_SIZE/2,
-GRID_Y_MIN*GRID_STEP-PARTICLE_SIZE/2,
-GRID_X_MIN*GRID_STEP+PARTICLE_SIZE/2,
-GRID_Y_MIN*GRID_STEP+PARTICLE_SIZE/2,
outline="grey", fill="grey");
# def drawParticlesFromPositions(canvas, particles):
# for p in xrange(len(particles)):
# currentParticle = particles[p];
# tx = currentParticle['x']-GRID_X_MIN;
# ty = currentParticle['y']-GRID_Y_MIN;
# txg = tx*GRID_STEP;
# tyg = ty*GRID_STEP;
# o = canvas.create_oval(txg-PARTICLE_SIZE, tyg-PARTICLE_SIZE,
# txg+PARTICLE_SIZE, tyg+PARTICLE_SIZE,
# outline=PARTICLE_COLOR, fill=PARTICLE_COLOR);
# canvas.itemconfig(o, tags=("part"+str(p))); ## Useless
# canvas.update_idletasks(); # THIS IS A DIRTY HACK!!!
def drawParticlesFromGrid(canvas, matrix):
for x in xrange(GRID_WIDTH):
for y in xrange(GRID_HEIGHT):
if (matrix[x][y]>0):
xg = x*GRID_STEP;
yg = y*GRID_STEP;
o = canvas.create_oval(xg-PARTICLE_SIZE, yg-PARTICLE_SIZE,
xg+PARTICLE_SIZE, yg+PARTICLE_SIZE,
outline=PARTICLE_COLOR, fill=PARTICLE_COLOR);
canvas.itemconfig(o, tags=("part("+str(x)+"/"+str(y)+")")); ## Useless
##print("----------- Particle position: "+str(xg)+"/"+str(yg)); ## Debug
t = canvas.create_text((xg, yg), text=str(matrix[x][y]), font=FONT);
canvas.itemconfig(t, tags=("partCount("+str(x)+"/"+str(y)+")")); ## Useless
canvas.update_idletasks(); # THIS IS A DIRTY HACK!!!
def drawTime(label, t):
label.configure(text="t="+str(t));
label.update_idletasks(); # THIS IS A DIRTY HACK!!!
# Lance la simulation with loop
## Problem1: we do no give a chance to the GUI elements to update => we need to force them
## Problem2: since the event loop is broken, the "Sortir" button does not work.
# def startSimulationLoop(canvas, label):
# particles = initParticles(NB_PARTICLES);
# for step in xrange(N | rawGrid( | identifier_name |
roster.go | (m *gtk.TreeStore, iter *gtk.TreeIter, index int) string {
val, _ := m.GetValue(iter, index)
v, _ := val.GetString()
return v
}
func (r *roster) getAccountAndJidFromEvent(bt *gdk.EventButton) (jid string, account *account, rowType string, ok bool) {
x := bt.X()
y := bt.Y()
path := new(gtk.TreePath)
found := r.view.GetPathAtPos(int(x), int(y), path, nil, nil, nil)
if !found {
return "", nil, "", false
}
iter, err := r.model.GetIter(path)
if err != nil {
return "", nil, "", false
}
jid = getFromModelIter(r.model, iter, indexJid)
accountID := getFromModelIter(r.model, iter, indexAccountID)
rowType = getFromModelIter(r.model, iter, indexRowType)
account, ok = r.getAccount(accountID)
return jid, account, rowType, ok
}
func (r *roster) createAccountPeerPopup(jid string, account *account, bt *gdk.EventButton) {
builder := builderForDefinition("ContactPopupMenu")
obj, _ := builder.GetObject("contactMenu")
mn := obj.(*gtk.Menu)
builder.ConnectSignals(map[string]interface{}{
"on_remove_contact": func() {
account.session.RemoveContact(jid)
r.ui.removePeer(account, jid)
r.redraw()
},
"on_allow_contact_to_see_status": func() {
account.session.ApprovePresenceSubscription(jid, "" /* generate id */)
},
"on_forbid_contact_to_see_status": func() {
account.session.DenyPresenceSubscription(jid, "" /* generate id */)
},
"on_ask_contact_to_see_status": func() {
account.session.RequestPresenceSubscription(jid)
},
"on_dump_info": func() {
r.debugPrintRosterFor(account.session.GetConfig().Account)
},
})
mn.ShowAll()
mn.PopupAtMouseCursor(nil, nil, int(bt.Button()), bt.Time())
}
func (r *roster) createAccountPopup(jid string, account *account, bt *gdk.EventButton) {
builder := builderForDefinition("AccountPopupMenu")
obj, _ := builder.GetObject("accountMenu")
mn := obj.(*gtk.Menu)
builder.ConnectSignals(map[string]interface{}{
"on_connect": func() {
account.connect()
},
"on_disconnect": func() {
account.disconnect()
},
"on_dump_info": func() {
r.debugPrintRosterFor(account.session.GetConfig().Account)
},
})
connx, _ := builder.GetObject("connectMenuItem")
connect := connx.(*gtk.MenuItem)
dconnx, _ := builder.GetObject("disconnectMenuItem")
disconnect := dconnx.(*gtk.MenuItem)
connect.SetSensitive(account.session.IsDisconnected())
disconnect.SetSensitive(account.session.IsConnected())
mn.ShowAll()
mn.PopupAtMouseCursor(nil, nil, int(bt.Button()), bt.Time())
}
func (r *roster) onButtonPress(view *gtk.TreeView, ev *gdk.Event) bool {
bt := &gdk.EventButton{ev}
if bt.Button() == 0x03 {
jid, account, rowType, ok := r.getAccountAndJidFromEvent(bt)
if ok {
switch rowType {
case "peer":
r.createAccountPeerPopup(jid, account, bt)
case "account":
r.createAccountPopup(jid, account, bt)
}
}
}
return false
}
func (r *roster) onActivateBuddy(v *gtk.TreeView, path *gtk.TreePath) {
selection, _ := v.GetSelection()
defer selection.UnselectPath(path)
iter, err := r.model.GetIter(path)
if err != nil {
return
}
jid := getFromModelIter(r.model, iter, indexJid)
accountID := getFromModelIter(r.model, iter, indexAccountID)
rowType := getFromModelIter(r.model, iter, indexRowType)
if rowType != "peer" {
r.isCollapsed[jid] = !r.isCollapsed[jid]
r.redraw()
return
}
account, ok := r.getAccount(accountID)
if !ok {
return
}
r.openConversationWindow(account, jid)
}
func (r *roster) openConversationWindow(account *account, to string) (*conversationWindow, error) {
c, ok := account.getConversationWith(to)
if !ok {
textBuffer := r.ui.getTags().createTextBuffer()
c = account.createConversationWindow(to, r.ui.displaySettings, textBuffer)
r.ui.connectShortcutsChildWindow(c.win)
r.ui.connectShortcutsConversationWindow(c)
c.parentWin = r.ui.window
}
c.Show()
return c, nil
}
func (r *roster) displayNameFor(account *account, from string) string {
p, ok := r.ui.getPeer(account, from)
if !ok {
return from
}
return p.NameForPresentation()
}
func (r *roster) presenceUpdated(account *account, from, show, showStatus string, gone bool) {
c, ok := account.getConversationWith(from)
if !ok {
return
}
doInUIThread(func() {
c.appendStatus(r.displayNameFor(account, from), time.Now(), show, showStatus, gone)
})
}
func (r *roster) messageReceived(account *account, from string, timestamp time.Time, encrypted bool, message []byte) {
doInUIThread(func() {
conv, err := r.openConversationWindow(account, from)
if err != nil {
return
}
conv.appendMessage(r.displayNameFor(account, from), timestamp, encrypted, ui.StripHTML(message), false)
})
}
func (r *roster) update(account *account, entries *rosters.List) {
r.ui.accountManager.Lock()
defer r.ui.accountManager.Unlock()
r.ui.accountManager.setContacts(account, entries)
}
func (r *roster) debugPrintRosterFor(nm string) {
r.ui.accountManager.RLock()
defer r.ui.accountManager.RUnlock()
for account, rs := range r.ui.accountManager.getAllContacts() {
if account.session.GetConfig().Is(nm) {
rs.Iter(func(_ int, item *rosters.Peer) {
fmt.Printf("-> %s\n", item.Dump())
})
}
}
fmt.Printf(" ************************************** \n")
fmt.Println()
}
func isNominallyVisible(p *rosters.Peer) bool {
return (p.Subscription != "none" && p.Subscription != "") || p.PendingSubscribeID != ""
}
func shouldDisplay(p *rosters.Peer, showOffline bool) bool {
return isNominallyVisible(p) && (showOffline || p.Online)
}
func isAway(p *rosters.Peer) bool {
switch p.Status {
case "dnd", "xa", "away":
return true
}
return false
}
func isOnline(p *rosters.Peer) bool {
return p.PendingSubscribeID == "" && p.Online
}
func decideStatusFor(p *rosters.Peer) string {
if p.PendingSubscribeID != "" {
return "unknown"
}
if !p.Online {
return "offline"
}
switch p.Status {
case "dnd":
return "busy"
case "xa":
return "extended-away"
case "away":
return "away"
}
return "available"
}
func decideColorFor(p *rosters.Peer) string {
if !p.Online {
return "#aaaaaa"
}
return "#000000"
}
func createGroupDisplayName(parentName string, counter *counter, isExpanded bool) string {
name := parentName
if !isExpanded {
name = fmt.Sprintf("[%s]", name)
}
return fmt.Sprintf("%s (%d/%d)", name, counter.online, counter.total)
}
func createTooltipFor(item *rosters.Peer) string {
pname := html.EscapeString(item.NameForPresentation())
jid := html.EscapeString(item.Jid)
if pname != jid {
return fmt.Sprintf("%s (%s)", pname, jid)
}
return jid
}
func (r *roster) addItem(item *rosters.Peer, parentIter *gtk.TreeIter, indent string) {
iter := r.model.Append(parentIter)
setAll(r.model, iter,
item.Jid,
fmt.Sprintf("%s %s", indent, item.NameForPresentation()),
item.BelongsTo,
decideColorFor(item),
"#ffffff",
nil,
createTooltipFor(item),
)
r.model.SetValue(iter, indexRowType, "peer")
r.model.SetValue(iter, indexStatusIcon, statusIcons[decideStatusFor(item)].getPixbuf())
}
func (r *roster) redrawMerged() {
showOffline := !r.ui.config.Display.ShowOnlyOnline
r.ui.accountManager.RLock()
defer r.ui.accountManager.RUnlock()
r.toCollapse = nil
grp := rosters.TopLevelGroup()
for account, contacts := range r.ui.accountManager.getAllContacts() {
contacts.AddTo(grp, account.session.GroupDelimiter)
}
accountCounter := &counter{}
r.displayGroup(grp, nil, accountCounter, showOffline, "")
r.view.ExpandAll()
for _, path := range r.toCollapse {
| getFromModelIter | identifier_name | |
roster.go | builder.GetObject("accountMenu")
mn := obj.(*gtk.Menu)
builder.ConnectSignals(map[string]interface{}{
"on_connect": func() {
account.connect()
},
"on_disconnect": func() {
account.disconnect()
},
"on_dump_info": func() {
r.debugPrintRosterFor(account.session.GetConfig().Account)
},
})
connx, _ := builder.GetObject("connectMenuItem")
connect := connx.(*gtk.MenuItem)
dconnx, _ := builder.GetObject("disconnectMenuItem")
disconnect := dconnx.(*gtk.MenuItem)
connect.SetSensitive(account.session.IsDisconnected())
disconnect.SetSensitive(account.session.IsConnected())
mn.ShowAll()
mn.PopupAtMouseCursor(nil, nil, int(bt.Button()), bt.Time())
}
func (r *roster) onButtonPress(view *gtk.TreeView, ev *gdk.Event) bool {
bt := &gdk.EventButton{ev}
if bt.Button() == 0x03 {
jid, account, rowType, ok := r.getAccountAndJidFromEvent(bt)
if ok {
switch rowType {
case "peer":
r.createAccountPeerPopup(jid, account, bt)
case "account":
r.createAccountPopup(jid, account, bt)
}
}
}
return false
}
func (r *roster) onActivateBuddy(v *gtk.TreeView, path *gtk.TreePath) {
selection, _ := v.GetSelection()
defer selection.UnselectPath(path)
iter, err := r.model.GetIter(path)
if err != nil {
return
}
jid := getFromModelIter(r.model, iter, indexJid)
accountID := getFromModelIter(r.model, iter, indexAccountID)
rowType := getFromModelIter(r.model, iter, indexRowType)
if rowType != "peer" {
r.isCollapsed[jid] = !r.isCollapsed[jid]
r.redraw()
return
}
account, ok := r.getAccount(accountID)
if !ok {
return
}
r.openConversationWindow(account, jid)
}
func (r *roster) openConversationWindow(account *account, to string) (*conversationWindow, error) {
c, ok := account.getConversationWith(to)
if !ok {
textBuffer := r.ui.getTags().createTextBuffer()
c = account.createConversationWindow(to, r.ui.displaySettings, textBuffer)
r.ui.connectShortcutsChildWindow(c.win)
r.ui.connectShortcutsConversationWindow(c)
c.parentWin = r.ui.window
}
c.Show()
return c, nil
}
func (r *roster) displayNameFor(account *account, from string) string {
p, ok := r.ui.getPeer(account, from)
if !ok {
return from
}
return p.NameForPresentation()
}
func (r *roster) presenceUpdated(account *account, from, show, showStatus string, gone bool) {
c, ok := account.getConversationWith(from)
if !ok {
return
}
doInUIThread(func() {
c.appendStatus(r.displayNameFor(account, from), time.Now(), show, showStatus, gone)
})
}
func (r *roster) messageReceived(account *account, from string, timestamp time.Time, encrypted bool, message []byte) {
doInUIThread(func() {
conv, err := r.openConversationWindow(account, from)
if err != nil {
return
}
conv.appendMessage(r.displayNameFor(account, from), timestamp, encrypted, ui.StripHTML(message), false)
})
}
func (r *roster) update(account *account, entries *rosters.List) {
r.ui.accountManager.Lock()
defer r.ui.accountManager.Unlock()
r.ui.accountManager.setContacts(account, entries)
}
func (r *roster) debugPrintRosterFor(nm string) {
r.ui.accountManager.RLock()
defer r.ui.accountManager.RUnlock()
for account, rs := range r.ui.accountManager.getAllContacts() {
if account.session.GetConfig().Is(nm) {
rs.Iter(func(_ int, item *rosters.Peer) {
fmt.Printf("-> %s\n", item.Dump())
})
}
}
fmt.Printf(" ************************************** \n")
fmt.Println()
}
func isNominallyVisible(p *rosters.Peer) bool {
return (p.Subscription != "none" && p.Subscription != "") || p.PendingSubscribeID != ""
}
func shouldDisplay(p *rosters.Peer, showOffline bool) bool {
return isNominallyVisible(p) && (showOffline || p.Online)
}
func isAway(p *rosters.Peer) bool {
switch p.Status {
case "dnd", "xa", "away":
return true
}
return false
}
func isOnline(p *rosters.Peer) bool {
return p.PendingSubscribeID == "" && p.Online
}
func decideStatusFor(p *rosters.Peer) string {
if p.PendingSubscribeID != "" {
return "unknown"
}
if !p.Online {
return "offline"
}
switch p.Status {
case "dnd":
return "busy"
case "xa":
return "extended-away"
case "away":
return "away"
}
return "available"
}
func decideColorFor(p *rosters.Peer) string {
if !p.Online {
return "#aaaaaa"
}
return "#000000"
}
func createGroupDisplayName(parentName string, counter *counter, isExpanded bool) string {
name := parentName
if !isExpanded {
name = fmt.Sprintf("[%s]", name)
}
return fmt.Sprintf("%s (%d/%d)", name, counter.online, counter.total)
}
func createTooltipFor(item *rosters.Peer) string {
pname := html.EscapeString(item.NameForPresentation())
jid := html.EscapeString(item.Jid)
if pname != jid {
return fmt.Sprintf("%s (%s)", pname, jid)
}
return jid
}
func (r *roster) addItem(item *rosters.Peer, parentIter *gtk.TreeIter, indent string) {
iter := r.model.Append(parentIter)
setAll(r.model, iter,
item.Jid,
fmt.Sprintf("%s %s", indent, item.NameForPresentation()),
item.BelongsTo,
decideColorFor(item),
"#ffffff",
nil,
createTooltipFor(item),
)
r.model.SetValue(iter, indexRowType, "peer")
r.model.SetValue(iter, indexStatusIcon, statusIcons[decideStatusFor(item)].getPixbuf())
}
func (r *roster) redrawMerged() {
showOffline := !r.ui.config.Display.ShowOnlyOnline
r.ui.accountManager.RLock()
defer r.ui.accountManager.RUnlock()
r.toCollapse = nil
grp := rosters.TopLevelGroup()
for account, contacts := range r.ui.accountManager.getAllContacts() {
contacts.AddTo(grp, account.session.GroupDelimiter)
}
accountCounter := &counter{}
r.displayGroup(grp, nil, accountCounter, showOffline, "")
r.view.ExpandAll()
for _, path := range r.toCollapse {
r.view.CollapseRow(path)
}
}
type counter struct {
total int
online int
}
func (c *counter) inc(total, online bool) {
if total {
c.total++
}
if online {
c.online++
}
}
func (r *roster) displayGroup(g *rosters.Group, parentIter *gtk.TreeIter, accountCounter *counter, showOffline bool, accountName string) {
pi := parentIter
groupCounter := &counter{}
groupID := accountName + "//" + g.FullGroupName()
if g.GroupName != "" {
pi = r.model.Append(parentIter)
r.model.SetValue(pi, indexParentJid, groupID)
r.model.SetValue(pi, indexRowType, "group")
r.model.SetValue(pi, indexWeight, 500)
r.model.SetValue(pi, indexBackgroundColor, "#e9e7f3")
}
for _, item := range g.Peers() {
vs := isNominallyVisible(item)
o := isOnline(item)
accountCounter.inc(vs, vs && o)
groupCounter.inc(vs, vs && o)
if shouldDisplay(item, showOffline) {
r.addItem(item, pi, "")
}
}
for _, gr := range g.Groups() {
r.displayGroup(gr, pi, accountCounter, showOffline, accountName)
}
if g.GroupName != "" {
parentPath, _ := r.model.GetPath(pi)
shouldCollapse, ok := r.isCollapsed[groupID]
isExpanded := true
if ok && shouldCollapse {
isExpanded = false
r.toCollapse = append(r.toCollapse, parentPath)
}
r.model.SetValue(pi, indexParentDisplayName, createGroupDisplayName(g.FullGroupName(), groupCounter, isExpanded))
}
}
func (r *roster) redrawSeparateAccount(account *account, contacts *rosters.List, showOffline bool) {
parentIter := r.model.Append(nil)
accountCounter := &counter{}
grp := contacts.Grouped(account.session.GroupDelimiter)
parentName := account.session.GetConfig().Account
r.displayGroup(grp, parentIter, accountCounter, showOffline, parentName)
r.model.SetValue(parentIter, indexParentJid, parentName)
r.model.SetValue(parentIter, indexAccountID, account.session.GetConfig().ID()) | r.model.SetValue(parentIter, indexRowType, "account") | random_line_split | |
roster.go | int) string {
val, _ := m.GetValue(iter, index)
v, _ := val.GetString()
return v
}
func (r *roster) getAccountAndJidFromEvent(bt *gdk.EventButton) (jid string, account *account, rowType string, ok bool) {
x := bt.X()
y := bt.Y()
path := new(gtk.TreePath)
found := r.view.GetPathAtPos(int(x), int(y), path, nil, nil, nil)
if !found {
return "", nil, "", false
}
iter, err := r.model.GetIter(path)
if err != nil {
return "", nil, "", false
}
jid = getFromModelIter(r.model, iter, indexJid)
accountID := getFromModelIter(r.model, iter, indexAccountID)
rowType = getFromModelIter(r.model, iter, indexRowType)
account, ok = r.getAccount(accountID)
return jid, account, rowType, ok
}
func (r *roster) createAccountPeerPopup(jid string, account *account, bt *gdk.EventButton) {
builder := builderForDefinition("ContactPopupMenu")
obj, _ := builder.GetObject("contactMenu")
mn := obj.(*gtk.Menu)
builder.ConnectSignals(map[string]interface{}{
"on_remove_contact": func() {
account.session.RemoveContact(jid)
r.ui.removePeer(account, jid)
r.redraw()
},
"on_allow_contact_to_see_status": func() {
account.session.ApprovePresenceSubscription(jid, "" /* generate id */)
},
"on_forbid_contact_to_see_status": func() {
account.session.DenyPresenceSubscription(jid, "" /* generate id */)
},
"on_ask_contact_to_see_status": func() {
account.session.RequestPresenceSubscription(jid)
},
"on_dump_info": func() {
r.debugPrintRosterFor(account.session.GetConfig().Account)
},
})
mn.ShowAll()
mn.PopupAtMouseCursor(nil, nil, int(bt.Button()), bt.Time())
}
func (r *roster) createAccountPopup(jid string, account *account, bt *gdk.EventButton) {
builder := builderForDefinition("AccountPopupMenu")
obj, _ := builder.GetObject("accountMenu")
mn := obj.(*gtk.Menu)
builder.ConnectSignals(map[string]interface{}{
"on_connect": func() {
account.connect()
},
"on_disconnect": func() {
account.disconnect()
},
"on_dump_info": func() {
r.debugPrintRosterFor(account.session.GetConfig().Account)
},
})
connx, _ := builder.GetObject("connectMenuItem")
connect := connx.(*gtk.MenuItem)
dconnx, _ := builder.GetObject("disconnectMenuItem")
disconnect := dconnx.(*gtk.MenuItem)
connect.SetSensitive(account.session.IsDisconnected())
disconnect.SetSensitive(account.session.IsConnected())
mn.ShowAll()
mn.PopupAtMouseCursor(nil, nil, int(bt.Button()), bt.Time())
}
func (r *roster) onButtonPress(view *gtk.TreeView, ev *gdk.Event) bool |
func (r *roster) onActivateBuddy(v *gtk.TreeView, path *gtk.TreePath) {
selection, _ := v.GetSelection()
defer selection.UnselectPath(path)
iter, err := r.model.GetIter(path)
if err != nil {
return
}
jid := getFromModelIter(r.model, iter, indexJid)
accountID := getFromModelIter(r.model, iter, indexAccountID)
rowType := getFromModelIter(r.model, iter, indexRowType)
if rowType != "peer" {
r.isCollapsed[jid] = !r.isCollapsed[jid]
r.redraw()
return
}
account, ok := r.getAccount(accountID)
if !ok {
return
}
r.openConversationWindow(account, jid)
}
func (r *roster) openConversationWindow(account *account, to string) (*conversationWindow, error) {
c, ok := account.getConversationWith(to)
if !ok {
textBuffer := r.ui.getTags().createTextBuffer()
c = account.createConversationWindow(to, r.ui.displaySettings, textBuffer)
r.ui.connectShortcutsChildWindow(c.win)
r.ui.connectShortcutsConversationWindow(c)
c.parentWin = r.ui.window
}
c.Show()
return c, nil
}
func (r *roster) displayNameFor(account *account, from string) string {
p, ok := r.ui.getPeer(account, from)
if !ok {
return from
}
return p.NameForPresentation()
}
func (r *roster) presenceUpdated(account *account, from, show, showStatus string, gone bool) {
c, ok := account.getConversationWith(from)
if !ok {
return
}
doInUIThread(func() {
c.appendStatus(r.displayNameFor(account, from), time.Now(), show, showStatus, gone)
})
}
func (r *roster) messageReceived(account *account, from string, timestamp time.Time, encrypted bool, message []byte) {
doInUIThread(func() {
conv, err := r.openConversationWindow(account, from)
if err != nil {
return
}
conv.appendMessage(r.displayNameFor(account, from), timestamp, encrypted, ui.StripHTML(message), false)
})
}
func (r *roster) update(account *account, entries *rosters.List) {
r.ui.accountManager.Lock()
defer r.ui.accountManager.Unlock()
r.ui.accountManager.setContacts(account, entries)
}
func (r *roster) debugPrintRosterFor(nm string) {
r.ui.accountManager.RLock()
defer r.ui.accountManager.RUnlock()
for account, rs := range r.ui.accountManager.getAllContacts() {
if account.session.GetConfig().Is(nm) {
rs.Iter(func(_ int, item *rosters.Peer) {
fmt.Printf("-> %s\n", item.Dump())
})
}
}
fmt.Printf(" ************************************** \n")
fmt.Println()
}
func isNominallyVisible(p *rosters.Peer) bool {
return (p.Subscription != "none" && p.Subscription != "") || p.PendingSubscribeID != ""
}
func shouldDisplay(p *rosters.Peer, showOffline bool) bool {
return isNominallyVisible(p) && (showOffline || p.Online)
}
func isAway(p *rosters.Peer) bool {
switch p.Status {
case "dnd", "xa", "away":
return true
}
return false
}
func isOnline(p *rosters.Peer) bool {
return p.PendingSubscribeID == "" && p.Online
}
func decideStatusFor(p *rosters.Peer) string {
if p.PendingSubscribeID != "" {
return "unknown"
}
if !p.Online {
return "offline"
}
switch p.Status {
case "dnd":
return "busy"
case "xa":
return "extended-away"
case "away":
return "away"
}
return "available"
}
func decideColorFor(p *rosters.Peer) string {
if !p.Online {
return "#aaaaaa"
}
return "#000000"
}
func createGroupDisplayName(parentName string, counter *counter, isExpanded bool) string {
name := parentName
if !isExpanded {
name = fmt.Sprintf("[%s]", name)
}
return fmt.Sprintf("%s (%d/%d)", name, counter.online, counter.total)
}
func createTooltipFor(item *rosters.Peer) string {
pname := html.EscapeString(item.NameForPresentation())
jid := html.EscapeString(item.Jid)
if pname != jid {
return fmt.Sprintf("%s (%s)", pname, jid)
}
return jid
}
func (r *roster) addItem(item *rosters.Peer, parentIter *gtk.TreeIter, indent string) {
iter := r.model.Append(parentIter)
setAll(r.model, iter,
item.Jid,
fmt.Sprintf("%s %s", indent, item.NameForPresentation()),
item.BelongsTo,
decideColorFor(item),
"#ffffff",
nil,
createTooltipFor(item),
)
r.model.SetValue(iter, indexRowType, "peer")
r.model.SetValue(iter, indexStatusIcon, statusIcons[decideStatusFor(item)].getPixbuf())
}
func (r *roster) redrawMerged() {
showOffline := !r.ui.config.Display.ShowOnlyOnline
r.ui.accountManager.RLock()
defer r.ui.accountManager.RUnlock()
r.toCollapse = nil
grp := rosters.TopLevelGroup()
for account, contacts := range r.ui.accountManager.getAllContacts() {
contacts.AddTo(grp, account.session.GroupDelimiter)
}
accountCounter := &counter{}
r.displayGroup(grp, nil, accountCounter, showOffline, "")
r.view.ExpandAll()
for _, path := range r.toCollapse {
r.view.CollapseRow(path)
}
}
type counter struct {
total | {
bt := &gdk.EventButton{ev}
if bt.Button() == 0x03 {
jid, account, rowType, ok := r.getAccountAndJidFromEvent(bt)
if ok {
switch rowType {
case "peer":
r.createAccountPeerPopup(jid, account, bt)
case "account":
r.createAccountPopup(jid, account, bt)
}
}
}
return false
} | identifier_body |
roster.go | int) string {
val, _ := m.GetValue(iter, index)
v, _ := val.GetString()
return v
}
func (r *roster) getAccountAndJidFromEvent(bt *gdk.EventButton) (jid string, account *account, rowType string, ok bool) {
x := bt.X()
y := bt.Y()
path := new(gtk.TreePath)
found := r.view.GetPathAtPos(int(x), int(y), path, nil, nil, nil)
if !found {
return "", nil, "", false
}
iter, err := r.model.GetIter(path)
if err != nil {
return "", nil, "", false
}
jid = getFromModelIter(r.model, iter, indexJid)
accountID := getFromModelIter(r.model, iter, indexAccountID)
rowType = getFromModelIter(r.model, iter, indexRowType)
account, ok = r.getAccount(accountID)
return jid, account, rowType, ok
}
func (r *roster) createAccountPeerPopup(jid string, account *account, bt *gdk.EventButton) {
builder := builderForDefinition("ContactPopupMenu")
obj, _ := builder.GetObject("contactMenu")
mn := obj.(*gtk.Menu)
builder.ConnectSignals(map[string]interface{}{
"on_remove_contact": func() {
account.session.RemoveContact(jid)
r.ui.removePeer(account, jid)
r.redraw()
},
"on_allow_contact_to_see_status": func() {
account.session.ApprovePresenceSubscription(jid, "" /* generate id */)
},
"on_forbid_contact_to_see_status": func() {
account.session.DenyPresenceSubscription(jid, "" /* generate id */)
},
"on_ask_contact_to_see_status": func() {
account.session.RequestPresenceSubscription(jid)
},
"on_dump_info": func() {
r.debugPrintRosterFor(account.session.GetConfig().Account)
},
})
mn.ShowAll()
mn.PopupAtMouseCursor(nil, nil, int(bt.Button()), bt.Time())
}
func (r *roster) createAccountPopup(jid string, account *account, bt *gdk.EventButton) {
builder := builderForDefinition("AccountPopupMenu")
obj, _ := builder.GetObject("accountMenu")
mn := obj.(*gtk.Menu)
builder.ConnectSignals(map[string]interface{}{
"on_connect": func() {
account.connect()
},
"on_disconnect": func() {
account.disconnect()
},
"on_dump_info": func() {
r.debugPrintRosterFor(account.session.GetConfig().Account)
},
})
connx, _ := builder.GetObject("connectMenuItem")
connect := connx.(*gtk.MenuItem)
dconnx, _ := builder.GetObject("disconnectMenuItem")
disconnect := dconnx.(*gtk.MenuItem)
connect.SetSensitive(account.session.IsDisconnected())
disconnect.SetSensitive(account.session.IsConnected())
mn.ShowAll()
mn.PopupAtMouseCursor(nil, nil, int(bt.Button()), bt.Time())
}
func (r *roster) onButtonPress(view *gtk.TreeView, ev *gdk.Event) bool {
bt := &gdk.EventButton{ev}
if bt.Button() == 0x03 {
jid, account, rowType, ok := r.getAccountAndJidFromEvent(bt)
if ok {
switch rowType {
case "peer":
r.createAccountPeerPopup(jid, account, bt)
case "account":
r.createAccountPopup(jid, account, bt)
}
}
}
return false
}
func (r *roster) onActivateBuddy(v *gtk.TreeView, path *gtk.TreePath) {
selection, _ := v.GetSelection()
defer selection.UnselectPath(path)
iter, err := r.model.GetIter(path)
if err != nil {
return
}
jid := getFromModelIter(r.model, iter, indexJid)
accountID := getFromModelIter(r.model, iter, indexAccountID)
rowType := getFromModelIter(r.model, iter, indexRowType)
if rowType != "peer" {
r.isCollapsed[jid] = !r.isCollapsed[jid]
r.redraw()
return
}
account, ok := r.getAccount(accountID)
if !ok {
return
}
r.openConversationWindow(account, jid)
}
func (r *roster) openConversationWindow(account *account, to string) (*conversationWindow, error) {
c, ok := account.getConversationWith(to)
if !ok {
textBuffer := r.ui.getTags().createTextBuffer()
c = account.createConversationWindow(to, r.ui.displaySettings, textBuffer)
r.ui.connectShortcutsChildWindow(c.win)
r.ui.connectShortcutsConversationWindow(c)
c.parentWin = r.ui.window
}
c.Show()
return c, nil
}
func (r *roster) displayNameFor(account *account, from string) string {
p, ok := r.ui.getPeer(account, from)
if !ok {
return from
}
return p.NameForPresentation()
}
func (r *roster) presenceUpdated(account *account, from, show, showStatus string, gone bool) {
c, ok := account.getConversationWith(from)
if !ok {
return
}
doInUIThread(func() {
c.appendStatus(r.displayNameFor(account, from), time.Now(), show, showStatus, gone)
})
}
func (r *roster) messageReceived(account *account, from string, timestamp time.Time, encrypted bool, message []byte) {
doInUIThread(func() {
conv, err := r.openConversationWindow(account, from)
if err != nil {
return
}
conv.appendMessage(r.displayNameFor(account, from), timestamp, encrypted, ui.StripHTML(message), false)
})
}
func (r *roster) update(account *account, entries *rosters.List) {
r.ui.accountManager.Lock()
defer r.ui.accountManager.Unlock()
r.ui.accountManager.setContacts(account, entries)
}
func (r *roster) debugPrintRosterFor(nm string) {
r.ui.accountManager.RLock()
defer r.ui.accountManager.RUnlock()
for account, rs := range r.ui.accountManager.getAllContacts() {
if account.session.GetConfig().Is(nm) {
rs.Iter(func(_ int, item *rosters.Peer) {
fmt.Printf("-> %s\n", item.Dump())
})
}
}
fmt.Printf(" ************************************** \n")
fmt.Println()
}
func isNominallyVisible(p *rosters.Peer) bool {
return (p.Subscription != "none" && p.Subscription != "") || p.PendingSubscribeID != ""
}
func shouldDisplay(p *rosters.Peer, showOffline bool) bool {
return isNominallyVisible(p) && (showOffline || p.Online)
}
func isAway(p *rosters.Peer) bool {
switch p.Status {
case "dnd", "xa", "away":
return true
}
return false
}
func isOnline(p *rosters.Peer) bool {
return p.PendingSubscribeID == "" && p.Online
}
func decideStatusFor(p *rosters.Peer) string {
if p.PendingSubscribeID != "" |
if !p.Online {
return "offline"
}
switch p.Status {
case "dnd":
return "busy"
case "xa":
return "extended-away"
case "away":
return "away"
}
return "available"
}
func decideColorFor(p *rosters.Peer) string {
if !p.Online {
return "#aaaaaa"
}
return "#000000"
}
func createGroupDisplayName(parentName string, counter *counter, isExpanded bool) string {
name := parentName
if !isExpanded {
name = fmt.Sprintf("[%s]", name)
}
return fmt.Sprintf("%s (%d/%d)", name, counter.online, counter.total)
}
func createTooltipFor(item *rosters.Peer) string {
pname := html.EscapeString(item.NameForPresentation())
jid := html.EscapeString(item.Jid)
if pname != jid {
return fmt.Sprintf("%s (%s)", pname, jid)
}
return jid
}
func (r *roster) addItem(item *rosters.Peer, parentIter *gtk.TreeIter, indent string) {
iter := r.model.Append(parentIter)
setAll(r.model, iter,
item.Jid,
fmt.Sprintf("%s %s", indent, item.NameForPresentation()),
item.BelongsTo,
decideColorFor(item),
"#ffffff",
nil,
createTooltipFor(item),
)
r.model.SetValue(iter, indexRowType, "peer")
r.model.SetValue(iter, indexStatusIcon, statusIcons[decideStatusFor(item)].getPixbuf())
}
func (r *roster) redrawMerged() {
showOffline := !r.ui.config.Display.ShowOnlyOnline
r.ui.accountManager.RLock()
defer r.ui.accountManager.RUnlock()
r.toCollapse = nil
grp := rosters.TopLevelGroup()
for account, contacts := range r.ui.accountManager.getAllContacts() {
contacts.AddTo(grp, account.session.GroupDelimiter)
}
accountCounter := &counter{}
r.displayGroup(grp, nil, accountCounter, showOffline, "")
r.view.ExpandAll()
for _, path := range r.toCollapse {
r.view.CollapseRow(path)
}
}
type counter struct {
total | {
return "unknown"
} | conditional_block |
models.py | . :)
def create_database(db_settings: Dict[str, Any], database_name: str) -> None:
with connect(**db_settings) as connection:
cursor = connection.cursor()
cursor.execute(f'CREATE DATABASE IF NOT EXISTS {database_name}')
def remove_database(db_settings: Dict[str, Any], database_name: str) -> None:
with connect(**db_settings) as connection:
cursor = connection.cursor()
cursor.execute(f'DROP DATABASE IF EXISTS {database_name}')
class Keywords(str, Enum):
ID = 'ID'
Properties = 'properties'
And = 'AND'
From = 'FROM'
InsertInto = 'INSERT INTO'
Set = 'SET'
Select = 'SELECT'
Update = 'UPDATE'
Values = 'VALUES'
Where = 'WHERE'
class EmptyQuery(Exception):
"""Raised when `.execute()` is called without prior select/filter."""
class SchemaNotFound(Exception):
"""Raised when the requested Schema is not found."""
class BaseModel:
db_settings: Dict[str, Any] = DB_SETTINGS
table_name: str
schema: Type[ISchema]
_table_created: Dict[str, bool] = {}
BLANK_QUERY: str = ''
def _create_table_if_not_exists(self) -> None:
"""Automatically create the provided schema table if it does not exist.
For example::
{
"title":"SportSchema",
"type":"object",
"properties":{
"Name":{
"title":"Name",
"type":"string"
},
"Slug":{
"title":"Slug",
"type":"string"
},
"Active":{
"title":"Active",
"type":"boolean" | "Active"
]
}
Would result in the following create table query::
CREATE TABLE IF NOT EXISTS sports (ID INTEGER PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(255), Slug VARCHAR(255), Active BOOLEAN)
"""
COLUMN_DEFINITIONS = 'definitions'
COLUMN_TYPE = 'type'
KEY_REF = '$ref'
TYPE_LOOKUP = {
'string': 'VARCHAR(255)',
'integer': 'INTEGER',
'boolean': 'BOOLEAN',
'number': 'INTEGER',
}
def ref_lookup(
property: Dict[str, Any], fields: Dict[str, Any]
) -> Dict[str, Any]:
ref = property[KEY_REF]
property_lookup_name = ref[ref.rfind('/') + 1 :]
return fields[COLUMN_DEFINITIONS][property_lookup_name]
field_queries = []
fields = json.loads(self.schema.schema_json())
del fields[Keywords.Properties.value][
Keywords.ID.value
] # Remove primary key field. It is handled with auto increment below.
for property_name, property in fields[Keywords.Properties.value].items():
if KEY_REF in property:
property = ref_lookup(property, fields)
field_queries.append(
f'{property_name} {TYPE_LOOKUP[property[COLUMN_TYPE]]}'
)
table_columns = ', '.join(field_queries)
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(
f'CREATE TABLE IF NOT EXISTS {self.table_name} (ID INTEGER PRIMARY KEY AUTO_INCREMENT, {table_columns})'
)
self._table_created[self.table_name] = True
def __init__(self) -> None:
if not self._table_created.get(self.table_name):
self._create_table_if_not_exists()
self._query: str = BaseModel.BLANK_QUERY
self._last_method_called: Optional[function] = None
def _clean_selected_fields(self, field_names: Tuple[str, ...]) -> Tuple[str, ...]:
"""Remove duplicates, e.g. 'ID' field requested twice.
Maintains order. Using a set doesn't maintain order.
"""
list_field_names = [Keywords.ID.value]
for field in field_names:
if field in list_field_names:
continue
list_field_names.append(field)
return tuple(list_field_names)
def _append_to_query(self, statement: str) -> None:
if self._query == BaseModel.BLANK_QUERY:
fields = json.loads(self.schema.schema_json())
field_names = ', '.join(fields[Keywords.Properties.value].keys())
self._query = f'{Keywords.Select.value} {field_names} {Keywords.From.value} {self.table_name}'
self._query += f' {statement}'
def _map_results_to_schema(
self, field_names: Iterable[str], results: List[Tuple[Any, ...]]
) -> List[ISchema]:
schema_objects: List[ISchema] = []
for result in results:
row_data_mapped_to_fields = dict(zip(field_names, result))
schema_objects.append(self.schema.construct(**row_data_mapped_to_fields))
return schema_objects
def _fields_from_schema(self, schema: ISchema) -> List[str]:
return cast(List[str], schema.dict().keys()) # KeysView[str]
def _values_from_schema(self, schema: ISchema) -> List[Any]:
return cast(List[Any], schema.dict().values()) # KeysView[Any]
def select_fields(self, *field_names) -> List[ISchema]:
field_names = self._clean_selected_fields(field_names)
fields_formatted = ', '.join(field_names)
query = f'{Keywords.Select.value} {fields_formatted} {Keywords.From.value} {self.table_name}'
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(query)
results = cursor.fetchall()
return self._map_results_to_schema(field_names, results)
def insert(self, schema: ISchema) -> ISchema:
fields = self._fields_from_schema(schema)
field_names = ', '.join(self._fields_from_schema(schema))
fields_placeholder = ('%s, ' * len(fields))[:-2] # Remove trailing , .
values = tuple(self._values_from_schema(schema))
query = f'{Keywords.InsertInto.value} {self.table_name} ({field_names}) {Keywords.Values.value} ({fields_placeholder})'
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(query, values)
connection.commit()
schema.set_id(cursor.lastrowid)
return schema
def update(self, schema: ISchema) -> ISchema:
REMOVE_ID_FIELD_WITH_INDEX = 1
field_names = list(self._fields_from_schema(schema))[
REMOVE_ID_FIELD_WITH_INDEX:
]
values = list(self._values_from_schema(schema))[REMOVE_ID_FIELD_WITH_INDEX:]
fields_placeholder = ', '.join(
[f'{field_name} = %s' for field_name in field_names]
)
query = f"{Keywords.Update.value} {self.table_name} {Keywords.Set.value} {fields_placeholder} {Keywords.Where.value} {Keywords.ID.value} = '{schema.get_id()}'"
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(query, values)
connection.commit()
return schema
def select(self, *field_names) -> 'BaseModel':
field_names = self._clean_selected_fields(field_names)
fields_formatted = ', '.join(field_names)
self._query = f'{Keywords.Select.value} {fields_formatted} {Keywords.From.value} {self.table_name}'
self._last_method_called = self.select
return self
def filter(self, field_name: str, operator: Operators, value: Any) -> 'BaseModel':
expression = (
Keywords.And.value
if self._last_method_called == self.filter
else Keywords.Where.value
)
query = f"{expression} {field_name} {operator.value} '{value}'"
self._append_to_query(query)
self._last_method_called = self.filter
return self
def execute(self) -> List[ISchema]:
if self._query == BaseModel.BLANK_QUERY:
raise EmptyQuery()
field_names = list(
map(
str.strip,
self._query[
self._query.find(Keywords.Select.value)
+ len(Keywords.Select.value) : self._query.find(Keywords.From.value)
]
.strip()
.split(','),
)
)
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(self._query)
results = cursor.fetchall()
self._query = BaseModel.BLANK_QUERY
self._last_method_called = None
return self._map_results_to_schema(field_names, results)
def find(self, id: int) -> ISchema:
self.filter(Keywords.ID.value, Operators.Equals, id)
result = self.execute()
if result:
return result[0]
raise SchemaNotFound(f'Not found, ID: {id}.')
def get_query(self) -> str:
return self._query
class SportModel(BaseModel):
schema = SportSchema
table_name = 'sports'
class EventModel(BaseModel):
schema = EventSchema
table_name = 'events'
def update(self, schema: ISchema) -> ISchema:
"""When all the events of a sport are inactive,
the sport becomes inactive
"""
schema = super().update(schema)
schema = cast(EventSchema, schema)
if not schema.Active and schema.Sport > 0:
self.select('ID', 'Sport', 'Active').filter(
'Sport', Operators.Equals, schema.Sport,
).filter('Active', Operators | }
},
"required":[
"Name",
"Slug", | random_line_split |
models.py | . :)
def create_database(db_settings: Dict[str, Any], database_name: str) -> None:
with connect(**db_settings) as connection:
cursor = connection.cursor()
cursor.execute(f'CREATE DATABASE IF NOT EXISTS {database_name}')
def remove_database(db_settings: Dict[str, Any], database_name: str) -> None:
with connect(**db_settings) as connection:
cursor = connection.cursor()
cursor.execute(f'DROP DATABASE IF EXISTS {database_name}')
class Keywords(str, Enum):
ID = 'ID'
Properties = 'properties'
And = 'AND'
From = 'FROM'
InsertInto = 'INSERT INTO'
Set = 'SET'
Select = 'SELECT'
Update = 'UPDATE'
Values = 'VALUES'
Where = 'WHERE'
class EmptyQuery(Exception):
"""Raised when `.execute()` is called without prior select/filter."""
class SchemaNotFound(Exception):
"""Raised when the requested Schema is not found."""
class BaseModel:
db_settings: Dict[str, Any] = DB_SETTINGS
table_name: str
schema: Type[ISchema]
_table_created: Dict[str, bool] = {}
BLANK_QUERY: str = ''
def _create_table_if_not_exists(self) -> None:
"""Automatically create the provided schema table if it does not exist.
For example::
{
"title":"SportSchema",
"type":"object",
"properties":{
"Name":{
"title":"Name",
"type":"string"
},
"Slug":{
"title":"Slug",
"type":"string"
},
"Active":{
"title":"Active",
"type":"boolean"
}
},
"required":[
"Name",
"Slug",
"Active"
]
}
Would result in the following create table query::
CREATE TABLE IF NOT EXISTS sports (ID INTEGER PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(255), Slug VARCHAR(255), Active BOOLEAN)
"""
COLUMN_DEFINITIONS = 'definitions'
COLUMN_TYPE = 'type'
KEY_REF = '$ref'
TYPE_LOOKUP = {
'string': 'VARCHAR(255)',
'integer': 'INTEGER',
'boolean': 'BOOLEAN',
'number': 'INTEGER',
}
def ref_lookup(
property: Dict[str, Any], fields: Dict[str, Any]
) -> Dict[str, Any]:
ref = property[KEY_REF]
property_lookup_name = ref[ref.rfind('/') + 1 :]
return fields[COLUMN_DEFINITIONS][property_lookup_name]
field_queries = []
fields = json.loads(self.schema.schema_json())
del fields[Keywords.Properties.value][
Keywords.ID.value
] # Remove primary key field. It is handled with auto increment below.
for property_name, property in fields[Keywords.Properties.value].items():
if KEY_REF in property:
property = ref_lookup(property, fields)
field_queries.append(
f'{property_name} {TYPE_LOOKUP[property[COLUMN_TYPE]]}'
)
table_columns = ', '.join(field_queries)
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(
f'CREATE TABLE IF NOT EXISTS {self.table_name} (ID INTEGER PRIMARY KEY AUTO_INCREMENT, {table_columns})'
)
self._table_created[self.table_name] = True
def __init__(self) -> None:
if not self._table_created.get(self.table_name):
self._create_table_if_not_exists()
self._query: str = BaseModel.BLANK_QUERY
self._last_method_called: Optional[function] = None
def _clean_selected_fields(self, field_names: Tuple[str, ...]) -> Tuple[str, ...]:
"""Remove duplicates, e.g. 'ID' field requested twice.
Maintains order. Using a set doesn't maintain order.
"""
list_field_names = [Keywords.ID.value]
for field in field_names:
if field in list_field_names:
continue
list_field_names.append(field)
return tuple(list_field_names)
def _append_to_query(self, statement: str) -> None:
if self._query == BaseModel.BLANK_QUERY:
fields = json.loads(self.schema.schema_json())
field_names = ', '.join(fields[Keywords.Properties.value].keys())
self._query = f'{Keywords.Select.value} {field_names} {Keywords.From.value} {self.table_name}'
self._query += f' {statement}'
def _map_results_to_schema(
self, field_names: Iterable[str], results: List[Tuple[Any, ...]]
) -> List[ISchema]:
|
def _fields_from_schema(self, schema: ISchema) -> List[str]:
return cast(List[str], schema.dict().keys()) # KeysView[str]
def _values_from_schema(self, schema: ISchema) -> List[Any]:
return cast(List[Any], schema.dict().values()) # KeysView[Any]
def select_fields(self, *field_names) -> List[ISchema]:
field_names = self._clean_selected_fields(field_names)
fields_formatted = ', '.join(field_names)
query = f'{Keywords.Select.value} {fields_formatted} {Keywords.From.value} {self.table_name}'
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(query)
results = cursor.fetchall()
return self._map_results_to_schema(field_names, results)
def insert(self, schema: ISchema) -> ISchema:
fields = self._fields_from_schema(schema)
field_names = ', '.join(self._fields_from_schema(schema))
fields_placeholder = ('%s, ' * len(fields))[:-2] # Remove trailing , .
values = tuple(self._values_from_schema(schema))
query = f'{Keywords.InsertInto.value} {self.table_name} ({field_names}) {Keywords.Values.value} ({fields_placeholder})'
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(query, values)
connection.commit()
schema.set_id(cursor.lastrowid)
return schema
def update(self, schema: ISchema) -> ISchema:
REMOVE_ID_FIELD_WITH_INDEX = 1
field_names = list(self._fields_from_schema(schema))[
REMOVE_ID_FIELD_WITH_INDEX:
]
values = list(self._values_from_schema(schema))[REMOVE_ID_FIELD_WITH_INDEX:]
fields_placeholder = ', '.join(
[f'{field_name} = %s' for field_name in field_names]
)
query = f"{Keywords.Update.value} {self.table_name} {Keywords.Set.value} {fields_placeholder} {Keywords.Where.value} {Keywords.ID.value} = '{schema.get_id()}'"
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(query, values)
connection.commit()
return schema
def select(self, *field_names) -> 'BaseModel':
field_names = self._clean_selected_fields(field_names)
fields_formatted = ', '.join(field_names)
self._query = f'{Keywords.Select.value} {fields_formatted} {Keywords.From.value} {self.table_name}'
self._last_method_called = self.select
return self
def filter(self, field_name: str, operator: Operators, value: Any) -> 'BaseModel':
expression = (
Keywords.And.value
if self._last_method_called == self.filter
else Keywords.Where.value
)
query = f"{expression} {field_name} {operator.value} '{value}'"
self._append_to_query(query)
self._last_method_called = self.filter
return self
def execute(self) -> List[ISchema]:
if self._query == BaseModel.BLANK_QUERY:
raise EmptyQuery()
field_names = list(
map(
str.strip,
self._query[
self._query.find(Keywords.Select.value)
+ len(Keywords.Select.value) : self._query.find(Keywords.From.value)
]
.strip()
.split(','),
)
)
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(self._query)
results = cursor.fetchall()
self._query = BaseModel.BLANK_QUERY
self._last_method_called = None
return self._map_results_to_schema(field_names, results)
def find(self, id: int) -> ISchema:
self.filter(Keywords.ID.value, Operators.Equals, id)
result = self.execute()
if result:
return result[0]
raise SchemaNotFound(f'Not found, ID: {id}.')
def get_query(self) -> str:
return self._query
class SportModel(BaseModel):
schema = SportSchema
table_name = 'sports'
class EventModel(BaseModel):
schema = EventSchema
table_name = 'events'
def update(self, schema: ISchema) -> ISchema:
"""When all the events of a sport are inactive,
the sport becomes inactive
"""
schema = super().update(schema)
schema = cast(EventSchema, schema)
if not schema.Active and schema.Sport > 0:
self.select('ID', 'Sport', 'Active').filter(
'Sport', Operators.Equals, schema.Sport,
).filter('Active', Operators | schema_objects: List[ISchema] = []
for result in results:
row_data_mapped_to_fields = dict(zip(field_names, result))
schema_objects.append(self.schema.construct(**row_data_mapped_to_fields))
return schema_objects | identifier_body |
models.py | :)
def create_database(db_settings: Dict[str, Any], database_name: str) -> None:
with connect(**db_settings) as connection:
cursor = connection.cursor()
cursor.execute(f'CREATE DATABASE IF NOT EXISTS {database_name}')
def remove_database(db_settings: Dict[str, Any], database_name: str) -> None:
with connect(**db_settings) as connection:
cursor = connection.cursor()
cursor.execute(f'DROP DATABASE IF EXISTS {database_name}')
class Keywords(str, Enum):
ID = 'ID'
Properties = 'properties'
And = 'AND'
From = 'FROM'
InsertInto = 'INSERT INTO'
Set = 'SET'
Select = 'SELECT'
Update = 'UPDATE'
Values = 'VALUES'
Where = 'WHERE'
class EmptyQuery(Exception):
"""Raised when `.execute()` is called without prior select/filter."""
class SchemaNotFound(Exception):
"""Raised when the requested Schema is not found."""
class BaseModel:
db_settings: Dict[str, Any] = DB_SETTINGS
table_name: str
schema: Type[ISchema]
_table_created: Dict[str, bool] = {}
BLANK_QUERY: str = ''
def _create_table_if_not_exists(self) -> None:
"""Automatically create the provided schema table if it does not exist.
For example::
{
"title":"SportSchema",
"type":"object",
"properties":{
"Name":{
"title":"Name",
"type":"string"
},
"Slug":{
"title":"Slug",
"type":"string"
},
"Active":{
"title":"Active",
"type":"boolean"
}
},
"required":[
"Name",
"Slug",
"Active"
]
}
Would result in the following create table query::
CREATE TABLE IF NOT EXISTS sports (ID INTEGER PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(255), Slug VARCHAR(255), Active BOOLEAN)
"""
COLUMN_DEFINITIONS = 'definitions'
COLUMN_TYPE = 'type'
KEY_REF = '$ref'
TYPE_LOOKUP = {
'string': 'VARCHAR(255)',
'integer': 'INTEGER',
'boolean': 'BOOLEAN',
'number': 'INTEGER',
}
def ref_lookup(
property: Dict[str, Any], fields: Dict[str, Any]
) -> Dict[str, Any]:
ref = property[KEY_REF]
property_lookup_name = ref[ref.rfind('/') + 1 :]
return fields[COLUMN_DEFINITIONS][property_lookup_name]
field_queries = []
fields = json.loads(self.schema.schema_json())
del fields[Keywords.Properties.value][
Keywords.ID.value
] # Remove primary key field. It is handled with auto increment below.
for property_name, property in fields[Keywords.Properties.value].items():
|
table_columns = ', '.join(field_queries)
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(
f'CREATE TABLE IF NOT EXISTS {self.table_name} (ID INTEGER PRIMARY KEY AUTO_INCREMENT, {table_columns})'
)
self._table_created[self.table_name] = True
def __init__(self) -> None:
if not self._table_created.get(self.table_name):
self._create_table_if_not_exists()
self._query: str = BaseModel.BLANK_QUERY
self._last_method_called: Optional[function] = None
def _clean_selected_fields(self, field_names: Tuple[str, ...]) -> Tuple[str, ...]:
"""Remove duplicates, e.g. 'ID' field requested twice.
Maintains order. Using a set doesn't maintain order.
"""
list_field_names = [Keywords.ID.value]
for field in field_names:
if field in list_field_names:
continue
list_field_names.append(field)
return tuple(list_field_names)
def _append_to_query(self, statement: str) -> None:
if self._query == BaseModel.BLANK_QUERY:
fields = json.loads(self.schema.schema_json())
field_names = ', '.join(fields[Keywords.Properties.value].keys())
self._query = f'{Keywords.Select.value} {field_names} {Keywords.From.value} {self.table_name}'
self._query += f' {statement}'
def _map_results_to_schema(
self, field_names: Iterable[str], results: List[Tuple[Any, ...]]
) -> List[ISchema]:
schema_objects: List[ISchema] = []
for result in results:
row_data_mapped_to_fields = dict(zip(field_names, result))
schema_objects.append(self.schema.construct(**row_data_mapped_to_fields))
return schema_objects
def _fields_from_schema(self, schema: ISchema) -> List[str]:
return cast(List[str], schema.dict().keys()) # KeysView[str]
def _values_from_schema(self, schema: ISchema) -> List[Any]:
return cast(List[Any], schema.dict().values()) # KeysView[Any]
def select_fields(self, *field_names) -> List[ISchema]:
field_names = self._clean_selected_fields(field_names)
fields_formatted = ', '.join(field_names)
query = f'{Keywords.Select.value} {fields_formatted} {Keywords.From.value} {self.table_name}'
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(query)
results = cursor.fetchall()
return self._map_results_to_schema(field_names, results)
def insert(self, schema: ISchema) -> ISchema:
fields = self._fields_from_schema(schema)
field_names = ', '.join(self._fields_from_schema(schema))
fields_placeholder = ('%s, ' * len(fields))[:-2] # Remove trailing , .
values = tuple(self._values_from_schema(schema))
query = f'{Keywords.InsertInto.value} {self.table_name} ({field_names}) {Keywords.Values.value} ({fields_placeholder})'
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(query, values)
connection.commit()
schema.set_id(cursor.lastrowid)
return schema
def update(self, schema: ISchema) -> ISchema:
REMOVE_ID_FIELD_WITH_INDEX = 1
field_names = list(self._fields_from_schema(schema))[
REMOVE_ID_FIELD_WITH_INDEX:
]
values = list(self._values_from_schema(schema))[REMOVE_ID_FIELD_WITH_INDEX:]
fields_placeholder = ', '.join(
[f'{field_name} = %s' for field_name in field_names]
)
query = f"{Keywords.Update.value} {self.table_name} {Keywords.Set.value} {fields_placeholder} {Keywords.Where.value} {Keywords.ID.value} = '{schema.get_id()}'"
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(query, values)
connection.commit()
return schema
def select(self, *field_names) -> 'BaseModel':
field_names = self._clean_selected_fields(field_names)
fields_formatted = ', '.join(field_names)
self._query = f'{Keywords.Select.value} {fields_formatted} {Keywords.From.value} {self.table_name}'
self._last_method_called = self.select
return self
def filter(self, field_name: str, operator: Operators, value: Any) -> 'BaseModel':
expression = (
Keywords.And.value
if self._last_method_called == self.filter
else Keywords.Where.value
)
query = f"{expression} {field_name} {operator.value} '{value}'"
self._append_to_query(query)
self._last_method_called = self.filter
return self
def execute(self) -> List[ISchema]:
if self._query == BaseModel.BLANK_QUERY:
raise EmptyQuery()
field_names = list(
map(
str.strip,
self._query[
self._query.find(Keywords.Select.value)
+ len(Keywords.Select.value) : self._query.find(Keywords.From.value)
]
.strip()
.split(','),
)
)
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(self._query)
results = cursor.fetchall()
self._query = BaseModel.BLANK_QUERY
self._last_method_called = None
return self._map_results_to_schema(field_names, results)
def find(self, id: int) -> ISchema:
self.filter(Keywords.ID.value, Operators.Equals, id)
result = self.execute()
if result:
return result[0]
raise SchemaNotFound(f'Not found, ID: {id}.')
def get_query(self) -> str:
return self._query
class SportModel(BaseModel):
schema = SportSchema
table_name = 'sports'
class EventModel(BaseModel):
schema = EventSchema
table_name = 'events'
def update(self, schema: ISchema) -> ISchema:
"""When all the events of a sport are inactive,
the sport becomes inactive
"""
schema = super().update(schema)
schema = cast(EventSchema, schema)
if not schema.Active and schema.Sport > 0:
self.select('ID', 'Sport', 'Active').filter(
'Sport', Operators.Equals, schema.Sport,
).filter('Active', Operators | if KEY_REF in property:
property = ref_lookup(property, fields)
field_queries.append(
f'{property_name} {TYPE_LOOKUP[property[COLUMN_TYPE]]}'
) | conditional_block |
models.py | . :)
def create_database(db_settings: Dict[str, Any], database_name: str) -> None:
with connect(**db_settings) as connection:
cursor = connection.cursor()
cursor.execute(f'CREATE DATABASE IF NOT EXISTS {database_name}')
def remove_database(db_settings: Dict[str, Any], database_name: str) -> None:
with connect(**db_settings) as connection:
cursor = connection.cursor()
cursor.execute(f'DROP DATABASE IF EXISTS {database_name}')
class Keywords(str, Enum):
ID = 'ID'
Properties = 'properties'
And = 'AND'
From = 'FROM'
InsertInto = 'INSERT INTO'
Set = 'SET'
Select = 'SELECT'
Update = 'UPDATE'
Values = 'VALUES'
Where = 'WHERE'
class EmptyQuery(Exception):
"""Raised when `.execute()` is called without prior select/filter."""
class SchemaNotFound(Exception):
"""Raised when the requested Schema is not found."""
class BaseModel:
db_settings: Dict[str, Any] = DB_SETTINGS
table_name: str
schema: Type[ISchema]
_table_created: Dict[str, bool] = {}
BLANK_QUERY: str = ''
def _create_table_if_not_exists(self) -> None:
"""Automatically create the provided schema table if it does not exist.
For example::
{
"title":"SportSchema",
"type":"object",
"properties":{
"Name":{
"title":"Name",
"type":"string"
},
"Slug":{
"title":"Slug",
"type":"string"
},
"Active":{
"title":"Active",
"type":"boolean"
}
},
"required":[
"Name",
"Slug",
"Active"
]
}
Would result in the following create table query::
CREATE TABLE IF NOT EXISTS sports (ID INTEGER PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(255), Slug VARCHAR(255), Active BOOLEAN)
"""
COLUMN_DEFINITIONS = 'definitions'
COLUMN_TYPE = 'type'
KEY_REF = '$ref'
TYPE_LOOKUP = {
'string': 'VARCHAR(255)',
'integer': 'INTEGER',
'boolean': 'BOOLEAN',
'number': 'INTEGER',
}
def ref_lookup(
property: Dict[str, Any], fields: Dict[str, Any]
) -> Dict[str, Any]:
ref = property[KEY_REF]
property_lookup_name = ref[ref.rfind('/') + 1 :]
return fields[COLUMN_DEFINITIONS][property_lookup_name]
field_queries = []
fields = json.loads(self.schema.schema_json())
del fields[Keywords.Properties.value][
Keywords.ID.value
] # Remove primary key field. It is handled with auto increment below.
for property_name, property in fields[Keywords.Properties.value].items():
if KEY_REF in property:
property = ref_lookup(property, fields)
field_queries.append(
f'{property_name} {TYPE_LOOKUP[property[COLUMN_TYPE]]}'
)
table_columns = ', '.join(field_queries)
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(
f'CREATE TABLE IF NOT EXISTS {self.table_name} (ID INTEGER PRIMARY KEY AUTO_INCREMENT, {table_columns})'
)
self._table_created[self.table_name] = True
def __init__(self) -> None:
if not self._table_created.get(self.table_name):
self._create_table_if_not_exists()
self._query: str = BaseModel.BLANK_QUERY
self._last_method_called: Optional[function] = None
def _clean_selected_fields(self, field_names: Tuple[str, ...]) -> Tuple[str, ...]:
"""Remove duplicates, e.g. 'ID' field requested twice.
Maintains order. Using a set doesn't maintain order.
"""
list_field_names = [Keywords.ID.value]
for field in field_names:
if field in list_field_names:
continue
list_field_names.append(field)
return tuple(list_field_names)
def _append_to_query(self, statement: str) -> None:
if self._query == BaseModel.BLANK_QUERY:
fields = json.loads(self.schema.schema_json())
field_names = ', '.join(fields[Keywords.Properties.value].keys())
self._query = f'{Keywords.Select.value} {field_names} {Keywords.From.value} {self.table_name}'
self._query += f' {statement}'
def _map_results_to_schema(
self, field_names: Iterable[str], results: List[Tuple[Any, ...]]
) -> List[ISchema]:
schema_objects: List[ISchema] = []
for result in results:
row_data_mapped_to_fields = dict(zip(field_names, result))
schema_objects.append(self.schema.construct(**row_data_mapped_to_fields))
return schema_objects
def _fields_from_schema(self, schema: ISchema) -> List[str]:
return cast(List[str], schema.dict().keys()) # KeysView[str]
def | (self, schema: ISchema) -> List[Any]:
return cast(List[Any], schema.dict().values()) # KeysView[Any]
def select_fields(self, *field_names) -> List[ISchema]:
field_names = self._clean_selected_fields(field_names)
fields_formatted = ', '.join(field_names)
query = f'{Keywords.Select.value} {fields_formatted} {Keywords.From.value} {self.table_name}'
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(query)
results = cursor.fetchall()
return self._map_results_to_schema(field_names, results)
def insert(self, schema: ISchema) -> ISchema:
fields = self._fields_from_schema(schema)
field_names = ', '.join(self._fields_from_schema(schema))
fields_placeholder = ('%s, ' * len(fields))[:-2] # Remove trailing , .
values = tuple(self._values_from_schema(schema))
query = f'{Keywords.InsertInto.value} {self.table_name} ({field_names}) {Keywords.Values.value} ({fields_placeholder})'
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(query, values)
connection.commit()
schema.set_id(cursor.lastrowid)
return schema
def update(self, schema: ISchema) -> ISchema:
REMOVE_ID_FIELD_WITH_INDEX = 1
field_names = list(self._fields_from_schema(schema))[
REMOVE_ID_FIELD_WITH_INDEX:
]
values = list(self._values_from_schema(schema))[REMOVE_ID_FIELD_WITH_INDEX:]
fields_placeholder = ', '.join(
[f'{field_name} = %s' for field_name in field_names]
)
query = f"{Keywords.Update.value} {self.table_name} {Keywords.Set.value} {fields_placeholder} {Keywords.Where.value} {Keywords.ID.value} = '{schema.get_id()}'"
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(query, values)
connection.commit()
return schema
def select(self, *field_names) -> 'BaseModel':
field_names = self._clean_selected_fields(field_names)
fields_formatted = ', '.join(field_names)
self._query = f'{Keywords.Select.value} {fields_formatted} {Keywords.From.value} {self.table_name}'
self._last_method_called = self.select
return self
def filter(self, field_name: str, operator: Operators, value: Any) -> 'BaseModel':
expression = (
Keywords.And.value
if self._last_method_called == self.filter
else Keywords.Where.value
)
query = f"{expression} {field_name} {operator.value} '{value}'"
self._append_to_query(query)
self._last_method_called = self.filter
return self
def execute(self) -> List[ISchema]:
if self._query == BaseModel.BLANK_QUERY:
raise EmptyQuery()
field_names = list(
map(
str.strip,
self._query[
self._query.find(Keywords.Select.value)
+ len(Keywords.Select.value) : self._query.find(Keywords.From.value)
]
.strip()
.split(','),
)
)
with connect(**BaseModel.db_settings) as connection:
cursor = connection.cursor()
cursor.execute(self._query)
results = cursor.fetchall()
self._query = BaseModel.BLANK_QUERY
self._last_method_called = None
return self._map_results_to_schema(field_names, results)
def find(self, id: int) -> ISchema:
self.filter(Keywords.ID.value, Operators.Equals, id)
result = self.execute()
if result:
return result[0]
raise SchemaNotFound(f'Not found, ID: {id}.')
def get_query(self) -> str:
return self._query
class SportModel(BaseModel):
schema = SportSchema
table_name = 'sports'
class EventModel(BaseModel):
schema = EventSchema
table_name = 'events'
def update(self, schema: ISchema) -> ISchema:
"""When all the events of a sport are inactive,
the sport becomes inactive
"""
schema = super().update(schema)
schema = cast(EventSchema, schema)
if not schema.Active and schema.Sport > 0:
self.select('ID', 'Sport', 'Active').filter(
'Sport', Operators.Equals, schema.Sport,
).filter('Active', Operators | _values_from_schema | identifier_name |
wgl.rs | wgl")
.encode_wide()
.chain(Some(0).into_iter())
.collect::<Vec<_>>();
class.cbSize = mem::size_of::<WNDCLASSEXW>() as UINT;
class.lpszClassName = class_name.as_ptr();
class.lpfnWndProc = Some(DefWindowProcW);
RegisterClassExW(&class);
let hwnd = CreateWindowExW(
0,
class_name.as_ptr(),
std::ptr::null(),
0,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
std::ptr::null_mut(),
std::ptr::null_mut(),
instance,
std::ptr::null_mut(),
);
let hdc = GetDC(hwnd);
let desc = PIXELFORMATDESCRIPTOR {
nSize: std::mem::size_of::<PIXELFORMATDESCRIPTOR>() as u16,
nVersion: 1,
dwFlags: PFD_SUPPORT_OPENGL,
iPixelType: PFD_TYPE_RGBA,
cColorBits: 8,
cRedBits: 0,
cRedShift: 0,
cGreenBits: 0,
cGreenShift: 0,
cBlueBits: 0,
cBlueShift: 0,
cAlphaBits: 8,
cAlphaShift: 0,
cAccumBits: 0,
cAccumRedBits: 0,
cAccumGreenBits: 0,
cAccumBlueBits: 0,
cAccumAlphaBits: 0,
cDepthBits: 0,
cStencilBits: 0,
cAuxBuffers: 0,
iLayerType: PFD_MAIN_PLANE,
bReserved: 0,
dwLayerMask: 0,
dwVisibleMask: 0,
dwDamageMask: 0,
};
let format_id = ChoosePixelFormat(hdc, &desc);
SetPixelFormat(hdc, format_id, &desc);
let hglrc = wglCreateContext(hdc);
println!("{:?}", (hwnd, hdc, format_id, hglrc));
wglMakeCurrent(hdc, hglrc);
let name = OsStr::new("opengl32.dll")
.encode_wide()
.chain(Some(0).into_iter())
.collect::<Vec<_>>();
let lib = LoadLibraryW(name.as_ptr());
let wgl = wgl_ext_sys::Wgl::load_with(|sym| {
let sym = CString::new(sym.as_bytes()).unwrap();
let addr = wgl_sys::GetProcAddress(sym.as_ptr()) as *const ();
if !addr.is_null() {
addr as *const _
} else {
GetProcAddress(lib, sym.as_ptr()) as *const _
}
});
Entry {
hwnd,
hdc: hdc as _,
wgl,
lib,
}
}
}
}
impl Drop for Entry {
fn drop(&mut self) {
unsafe {
DestroyWindow(self.hwnd);
}
}
}
lazy_static! {
// Entry function pointers
pub(crate) static ref WGL_ENTRY: Entry = Entry::new();
}
pub struct Instance {
pub(crate) ctxt: DeviceContext,
}
impl Instance {
pub fn create(_name: &str, version: u32) -> Result<Self, hal::UnsupportedBackend> {
unsafe {
let glrc = WGL_ENTRY.wgl.CreateContextAttribsARB(
WGL_ENTRY.hdc as *const _,
ptr::null(),
ptr::null(),
) as HGLRC;
wglMakeCurrent(WGL_ENTRY.hdc as *mut _, glrc);
Ok(Instance {
ctxt: DeviceContext {
ctxt: Context { glrc },
hdc: WGL_ENTRY.hdc,
},
})
}
}
#[cfg(windows)]
pub fn create_surface_from_hwnd(&self, hwnd: *mut c_void) -> Surface {
Surface {
hwnd: hwnd as *mut _,
swapchain: None,
renderbuffer: None,
}
}
#[cfg(feature = "winit")]
pub fn create_surface(&self, window: &winit::window::Window) -> Surface {
use winit::platform::windows::WindowExtWindows;
let hwnd = window.hwnd();
self.create_surface_from_hwnd(hwnd as *mut _)
}
}
impl hal::Instance for Instance {
type Backend = Backend;
fn enumerate_adapters(&self) -> Vec<Adapter<Backend>> {
let gl_container = GlContainer::from_fn_proc(|s| unsafe {
let sym = CString::new(s.as_bytes()).unwrap();
let addr = wgl_sys::GetProcAddress(sym.as_ptr()) as *const ();
if !addr.is_null() {
addr as *const _
} else {
GetProcAddress(WGL_ENTRY.lib, sym.as_ptr()) as *const _
}
});
let adapter = PhysicalDevice::new_adapter(self.ctxt, gl_container);
vec![adapter]
}
}
#[derive(Debug)]
pub struct Surface {
pub(crate) hwnd: HWND,
pub(crate) swapchain: Option<Swapchain>,
renderbuffer: Option<native::Renderbuffer>,
}
// TODO: high -msiglreith
unsafe impl Send for Surface {}
unsafe impl Sync for Surface {}
impl window::Surface<Backend> for Surface {
fn compatibility(
&self,
physical_device: &PhysicalDevice,
) -> (
window::SurfaceCapabilities,
Option<Vec<f::Format>>,
Vec<window::PresentMode>,
) {
let extent = unsafe {
let mut rect: RECT = mem::zeroed();
GetClientRect(self.hwnd, &mut rect);
window::Extent2D {
width: (rect.right - rect.left) as _,
height: (rect.bottom - rect.top) as _,
}
};
let caps = window::SurfaceCapabilities {
image_count: 2 ..= 2,
current_extent: Some(extent),
extents: extent ..= extent,
max_image_layers: 1,
usage: image::Usage::COLOR_ATTACHMENT | image::Usage::TRANSFER_SRC,
composite_alpha: window::CompositeAlpha::OPAQUE, //TODO
};
let present_modes = vec![
window::PresentMode::Fifo, //TODO
];
(
caps,
Some(vec![f::Format::Rgba8Srgb, f::Format::Bgra8Srgb]),
present_modes,
)
}
fn supports_queue_family(&self, _queue_family: &QueueFamily) -> bool {
true
}
}
impl window::PresentationSurface<Backend> for Surface {
type SwapchainImage = native::ImageView;
unsafe fn configure_swapchain(
&mut self,
device: &Device,
config: window::SwapchainConfig,
) -> Result<(), window::CreationError> {
let gl = &device.share.context;
let context = match self.swapchain.take() {
Some(old) => {
for fbo in old.fbos {
gl.delete_framebuffer(fbo);
}
old.context
}
None => PresentContext::new(self, &device.share.instance_context),
};
context.make_current();
if self.renderbuffer.is_none() {
self.renderbuffer = Some(gl.create_renderbuffer().unwrap());
}
let desc = conv::describe_format(config.format).unwrap();
gl.bind_renderbuffer(glow::RENDERBUFFER, self.renderbuffer);
gl.renderbuffer_storage(
glow::RENDERBUFFER,
desc.tex_internal,
config.extent.width as i32,
config.extent.height as i32,
);
let fbo = gl.create_framebuffer().unwrap();
gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(fbo));
gl.framebuffer_renderbuffer(
glow::READ_FRAMEBUFFER,
glow::COLOR_ATTACHMENT0,
glow::RENDERBUFFER,
self.renderbuffer, | extent: config.extent,
fbos: iter::once(fbo).collect(),
});
Ok(())
}
unsafe fn unconfigure_swapchain(&mut self, device: &Device) {
let gl = &device.share.context;
if let Some(old) = self.swapchain.take() {
for fbo in old.fbos {
gl.delete_framebuffer(fbo);
}
}
if let Some(rbo) = self.renderbuffer.take() {
gl.delete_renderbuffer(rbo);
}
}
unsafe fn acquire_image(
&mut self,
_timeout_ns: u64,
) -> Result<(Self::SwapchainImage, Option<window::Suboptimal>), window::AcquireError> {
let image = native::ImageView::Renderbuffer(self.renderbuffer.unwrap());
Ok((image, None))
}
}
#[derive(Debug)]
pub struct Swapchain {
pub(crate) fbos: ArrayVec<[native::RawFrameBuffer; 3]>,
pub(crate) context: PresentContext,
pub(crate) extent: window::Extent2D,
}
impl Swapchain {
pub(crate) fn make_current(&self) {
self.context.make_current();
}
pub(crate) fn swap_buffers(&self) {
self.context.swap_buffers();
}
}
impl window::Swapchain<Backend> for Swapchain {
unsafe fn acquire_image(
&mut self,
_timeout_ns: u64,
_semaphore: Option | );
self.swapchain = Some(Swapchain {
context, | random_line_split |
wgl.rs | wgl")
.encode_wide()
.chain(Some(0).into_iter())
.collect::<Vec<_>>();
class.cbSize = mem::size_of::<WNDCLASSEXW>() as UINT;
class.lpszClassName = class_name.as_ptr();
class.lpfnWndProc = Some(DefWindowProcW);
RegisterClassExW(&class);
let hwnd = CreateWindowExW(
0,
class_name.as_ptr(),
std::ptr::null(),
0,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
std::ptr::null_mut(),
std::ptr::null_mut(),
instance,
std::ptr::null_mut(),
);
let hdc = GetDC(hwnd);
let desc = PIXELFORMATDESCRIPTOR {
nSize: std::mem::size_of::<PIXELFORMATDESCRIPTOR>() as u16,
nVersion: 1,
dwFlags: PFD_SUPPORT_OPENGL,
iPixelType: PFD_TYPE_RGBA,
cColorBits: 8,
cRedBits: 0,
cRedShift: 0,
cGreenBits: 0,
cGreenShift: 0,
cBlueBits: 0,
cBlueShift: 0,
cAlphaBits: 8,
cAlphaShift: 0,
cAccumBits: 0,
cAccumRedBits: 0,
cAccumGreenBits: 0,
cAccumBlueBits: 0,
cAccumAlphaBits: 0,
cDepthBits: 0,
cStencilBits: 0,
cAuxBuffers: 0,
iLayerType: PFD_MAIN_PLANE,
bReserved: 0,
dwLayerMask: 0,
dwVisibleMask: 0,
dwDamageMask: 0,
};
let format_id = ChoosePixelFormat(hdc, &desc);
SetPixelFormat(hdc, format_id, &desc);
let hglrc = wglCreateContext(hdc);
println!("{:?}", (hwnd, hdc, format_id, hglrc));
wglMakeCurrent(hdc, hglrc);
let name = OsStr::new("opengl32.dll")
.encode_wide()
.chain(Some(0).into_iter())
.collect::<Vec<_>>();
let lib = LoadLibraryW(name.as_ptr());
let wgl = wgl_ext_sys::Wgl::load_with(|sym| {
let sym = CString::new(sym.as_bytes()).unwrap();
let addr = wgl_sys::GetProcAddress(sym.as_ptr()) as *const ();
if !addr.is_null() | else {
GetProcAddress(lib, sym.as_ptr()) as *const _
}
});
Entry {
hwnd,
hdc: hdc as _,
wgl,
lib,
}
}
}
}
impl Drop for Entry {
fn drop(&mut self) {
unsafe {
DestroyWindow(self.hwnd);
}
}
}
lazy_static! {
// Entry function pointers
pub(crate) static ref WGL_ENTRY: Entry = Entry::new();
}
pub struct Instance {
pub(crate) ctxt: DeviceContext,
}
impl Instance {
pub fn create(_name: &str, version: u32) -> Result<Self, hal::UnsupportedBackend> {
unsafe {
let glrc = WGL_ENTRY.wgl.CreateContextAttribsARB(
WGL_ENTRY.hdc as *const _,
ptr::null(),
ptr::null(),
) as HGLRC;
wglMakeCurrent(WGL_ENTRY.hdc as *mut _, glrc);
Ok(Instance {
ctxt: DeviceContext {
ctxt: Context { glrc },
hdc: WGL_ENTRY.hdc,
},
})
}
}
#[cfg(windows)]
pub fn create_surface_from_hwnd(&self, hwnd: *mut c_void) -> Surface {
Surface {
hwnd: hwnd as *mut _,
swapchain: None,
renderbuffer: None,
}
}
#[cfg(feature = "winit")]
pub fn create_surface(&self, window: &winit::window::Window) -> Surface {
use winit::platform::windows::WindowExtWindows;
let hwnd = window.hwnd();
self.create_surface_from_hwnd(hwnd as *mut _)
}
}
impl hal::Instance for Instance {
type Backend = Backend;
fn enumerate_adapters(&self) -> Vec<Adapter<Backend>> {
let gl_container = GlContainer::from_fn_proc(|s| unsafe {
let sym = CString::new(s.as_bytes()).unwrap();
let addr = wgl_sys::GetProcAddress(sym.as_ptr()) as *const ();
if !addr.is_null() {
addr as *const _
} else {
GetProcAddress(WGL_ENTRY.lib, sym.as_ptr()) as *const _
}
});
let adapter = PhysicalDevice::new_adapter(self.ctxt, gl_container);
vec![adapter]
}
}
#[derive(Debug)]
pub struct Surface {
pub(crate) hwnd: HWND,
pub(crate) swapchain: Option<Swapchain>,
renderbuffer: Option<native::Renderbuffer>,
}
// TODO: high -msiglreith
unsafe impl Send for Surface {}
unsafe impl Sync for Surface {}
impl window::Surface<Backend> for Surface {
fn compatibility(
&self,
physical_device: &PhysicalDevice,
) -> (
window::SurfaceCapabilities,
Option<Vec<f::Format>>,
Vec<window::PresentMode>,
) {
let extent = unsafe {
let mut rect: RECT = mem::zeroed();
GetClientRect(self.hwnd, &mut rect);
window::Extent2D {
width: (rect.right - rect.left) as _,
height: (rect.bottom - rect.top) as _,
}
};
let caps = window::SurfaceCapabilities {
image_count: 2 ..= 2,
current_extent: Some(extent),
extents: extent ..= extent,
max_image_layers: 1,
usage: image::Usage::COLOR_ATTACHMENT | image::Usage::TRANSFER_SRC,
composite_alpha: window::CompositeAlpha::OPAQUE, //TODO
};
let present_modes = vec![
window::PresentMode::Fifo, //TODO
];
(
caps,
Some(vec![f::Format::Rgba8Srgb, f::Format::Bgra8Srgb]),
present_modes,
)
}
fn supports_queue_family(&self, _queue_family: &QueueFamily) -> bool {
true
}
}
impl window::PresentationSurface<Backend> for Surface {
type SwapchainImage = native::ImageView;
unsafe fn configure_swapchain(
&mut self,
device: &Device,
config: window::SwapchainConfig,
) -> Result<(), window::CreationError> {
let gl = &device.share.context;
let context = match self.swapchain.take() {
Some(old) => {
for fbo in old.fbos {
gl.delete_framebuffer(fbo);
}
old.context
}
None => PresentContext::new(self, &device.share.instance_context),
};
context.make_current();
if self.renderbuffer.is_none() {
self.renderbuffer = Some(gl.create_renderbuffer().unwrap());
}
let desc = conv::describe_format(config.format).unwrap();
gl.bind_renderbuffer(glow::RENDERBUFFER, self.renderbuffer);
gl.renderbuffer_storage(
glow::RENDERBUFFER,
desc.tex_internal,
config.extent.width as i32,
config.extent.height as i32,
);
let fbo = gl.create_framebuffer().unwrap();
gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(fbo));
gl.framebuffer_renderbuffer(
glow::READ_FRAMEBUFFER,
glow::COLOR_ATTACHMENT0,
glow::RENDERBUFFER,
self.renderbuffer,
);
self.swapchain = Some(Swapchain {
context,
extent: config.extent,
fbos: iter::once(fbo).collect(),
});
Ok(())
}
unsafe fn unconfigure_swapchain(&mut self, device: &Device) {
let gl = &device.share.context;
if let Some(old) = self.swapchain.take() {
for fbo in old.fbos {
gl.delete_framebuffer(fbo);
}
}
if let Some(rbo) = self.renderbuffer.take() {
gl.delete_renderbuffer(rbo);
}
}
unsafe fn acquire_image(
&mut self,
_timeout_ns: u64,
) -> Result<(Self::SwapchainImage, Option<window::Suboptimal>), window::AcquireError> {
let image = native::ImageView::Renderbuffer(self.renderbuffer.unwrap());
Ok((image, None))
}
}
#[derive(Debug)]
pub struct Swapchain {
pub(crate) fbos: ArrayVec<[native::RawFrameBuffer; 3]>,
pub(crate) context: PresentContext,
pub(crate) extent: window::Extent2D,
}
impl Swapchain {
pub(crate) fn make_current(&self) {
self.context.make_current();
}
pub(crate) fn swap_buffers(&self) {
self.context.swap_buffers();
}
}
impl window::Swapchain<Backend> for Swapchain {
unsafe fn acquire_image(
&mut self,
_timeout_ns: u64,
_semaphore: | {
addr as *const _
} | conditional_block |
wgl.rs | gl")
.encode_wide()
.chain(Some(0).into_iter())
.collect::<Vec<_>>();
class.cbSize = mem::size_of::<WNDCLASSEXW>() as UINT;
class.lpszClassName = class_name.as_ptr();
class.lpfnWndProc = Some(DefWindowProcW);
RegisterClassExW(&class);
let hwnd = CreateWindowExW(
0,
class_name.as_ptr(),
std::ptr::null(),
0,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
std::ptr::null_mut(),
std::ptr::null_mut(),
instance,
std::ptr::null_mut(),
);
let hdc = GetDC(hwnd);
let desc = PIXELFORMATDESCRIPTOR {
nSize: std::mem::size_of::<PIXELFORMATDESCRIPTOR>() as u16,
nVersion: 1,
dwFlags: PFD_SUPPORT_OPENGL,
iPixelType: PFD_TYPE_RGBA,
cColorBits: 8,
cRedBits: 0,
cRedShift: 0,
cGreenBits: 0,
cGreenShift: 0,
cBlueBits: 0,
cBlueShift: 0,
cAlphaBits: 8,
cAlphaShift: 0,
cAccumBits: 0,
cAccumRedBits: 0,
cAccumGreenBits: 0,
cAccumBlueBits: 0,
cAccumAlphaBits: 0,
cDepthBits: 0,
cStencilBits: 0,
cAuxBuffers: 0,
iLayerType: PFD_MAIN_PLANE,
bReserved: 0,
dwLayerMask: 0,
dwVisibleMask: 0,
dwDamageMask: 0,
};
let format_id = ChoosePixelFormat(hdc, &desc);
SetPixelFormat(hdc, format_id, &desc);
let hglrc = wglCreateContext(hdc);
println!("{:?}", (hwnd, hdc, format_id, hglrc));
wglMakeCurrent(hdc, hglrc);
let name = OsStr::new("opengl32.dll")
.encode_wide()
.chain(Some(0).into_iter())
.collect::<Vec<_>>();
let lib = LoadLibraryW(name.as_ptr());
let wgl = wgl_ext_sys::Wgl::load_with(|sym| {
let sym = CString::new(sym.as_bytes()).unwrap();
let addr = wgl_sys::GetProcAddress(sym.as_ptr()) as *const ();
if !addr.is_null() {
addr as *const _
} else {
GetProcAddress(lib, sym.as_ptr()) as *const _
}
});
Entry {
hwnd,
hdc: hdc as _,
wgl,
lib,
}
}
}
}
impl Drop for Entry {
fn drop(&mut self) {
unsafe {
DestroyWindow(self.hwnd);
}
}
}
lazy_static! {
// Entry function pointers
pub(crate) static ref WGL_ENTRY: Entry = Entry::new();
}
pub struct Instance {
pub(crate) ctxt: DeviceContext,
}
impl Instance {
pub fn create(_name: &str, version: u32) -> Result<Self, hal::UnsupportedBackend> {
unsafe {
let glrc = WGL_ENTRY.wgl.CreateContextAttribsARB(
WGL_ENTRY.hdc as *const _,
ptr::null(),
ptr::null(),
) as HGLRC;
wglMakeCurrent(WGL_ENTRY.hdc as *mut _, glrc);
Ok(Instance {
ctxt: DeviceContext {
ctxt: Context { glrc },
hdc: WGL_ENTRY.hdc,
},
})
}
}
#[cfg(windows)]
pub fn create_surface_from_hwnd(&self, hwnd: *mut c_void) -> Surface {
Surface {
hwnd: hwnd as *mut _,
swapchain: None,
renderbuffer: None,
}
}
#[cfg(feature = "winit")]
pub fn create_surface(&self, window: &winit::window::Window) -> Surface {
use winit::platform::windows::WindowExtWindows;
let hwnd = window.hwnd();
self.create_surface_from_hwnd(hwnd as *mut _)
}
}
impl hal::Instance for Instance {
type Backend = Backend;
fn enumerate_adapters(&self) -> Vec<Adapter<Backend>> {
let gl_container = GlContainer::from_fn_proc(|s| unsafe {
let sym = CString::new(s.as_bytes()).unwrap();
let addr = wgl_sys::GetProcAddress(sym.as_ptr()) as *const ();
if !addr.is_null() {
addr as *const _
} else {
GetProcAddress(WGL_ENTRY.lib, sym.as_ptr()) as *const _
}
});
let adapter = PhysicalDevice::new_adapter(self.ctxt, gl_container);
vec![adapter]
}
}
#[derive(Debug)]
pub struct Surface {
pub(crate) hwnd: HWND,
pub(crate) swapchain: Option<Swapchain>,
renderbuffer: Option<native::Renderbuffer>,
}
// TODO: high -msiglreith
unsafe impl Send for Surface {}
unsafe impl Sync for Surface {}
impl window::Surface<Backend> for Surface {
fn compatibility(
&self,
physical_device: &PhysicalDevice,
) -> (
window::SurfaceCapabilities,
Option<Vec<f::Format>>,
Vec<window::PresentMode>,
) {
let extent = unsafe {
let mut rect: RECT = mem::zeroed();
GetClientRect(self.hwnd, &mut rect);
window::Extent2D {
width: (rect.right - rect.left) as _,
height: (rect.bottom - rect.top) as _,
}
};
let caps = window::SurfaceCapabilities {
image_count: 2 ..= 2,
current_extent: Some(extent),
extents: extent ..= extent,
max_image_layers: 1,
usage: image::Usage::COLOR_ATTACHMENT | image::Usage::TRANSFER_SRC,
composite_alpha: window::CompositeAlpha::OPAQUE, //TODO
};
let present_modes = vec![
window::PresentMode::Fifo, //TODO
];
(
caps,
Some(vec![f::Format::Rgba8Srgb, f::Format::Bgra8Srgb]),
present_modes,
)
}
fn supports_queue_family(&self, _queue_family: &QueueFamily) -> bool |
}
impl window::PresentationSurface<Backend> for Surface {
type SwapchainImage = native::ImageView;
unsafe fn configure_swapchain(
&mut self,
device: &Device,
config: window::SwapchainConfig,
) -> Result<(), window::CreationError> {
let gl = &device.share.context;
let context = match self.swapchain.take() {
Some(old) => {
for fbo in old.fbos {
gl.delete_framebuffer(fbo);
}
old.context
}
None => PresentContext::new(self, &device.share.instance_context),
};
context.make_current();
if self.renderbuffer.is_none() {
self.renderbuffer = Some(gl.create_renderbuffer().unwrap());
}
let desc = conv::describe_format(config.format).unwrap();
gl.bind_renderbuffer(glow::RENDERBUFFER, self.renderbuffer);
gl.renderbuffer_storage(
glow::RENDERBUFFER,
desc.tex_internal,
config.extent.width as i32,
config.extent.height as i32,
);
let fbo = gl.create_framebuffer().unwrap();
gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(fbo));
gl.framebuffer_renderbuffer(
glow::READ_FRAMEBUFFER,
glow::COLOR_ATTACHMENT0,
glow::RENDERBUFFER,
self.renderbuffer,
);
self.swapchain = Some(Swapchain {
context,
extent: config.extent,
fbos: iter::once(fbo).collect(),
});
Ok(())
}
unsafe fn unconfigure_swapchain(&mut self, device: &Device) {
let gl = &device.share.context;
if let Some(old) = self.swapchain.take() {
for fbo in old.fbos {
gl.delete_framebuffer(fbo);
}
}
if let Some(rbo) = self.renderbuffer.take() {
gl.delete_renderbuffer(rbo);
}
}
unsafe fn acquire_image(
&mut self,
_timeout_ns: u64,
) -> Result<(Self::SwapchainImage, Option<window::Suboptimal>), window::AcquireError> {
let image = native::ImageView::Renderbuffer(self.renderbuffer.unwrap());
Ok((image, None))
}
}
#[derive(Debug)]
pub struct Swapchain {
pub(crate) fbos: ArrayVec<[native::RawFrameBuffer; 3]>,
pub(crate) context: PresentContext,
pub(crate) extent: window::Extent2D,
}
impl Swapchain {
pub(crate) fn make_current(&self) {
self.context.make_current();
}
pub(crate) fn swap_buffers(&self) {
self.context.swap_buffers();
}
}
impl window::Swapchain<Backend> for Swapchain {
unsafe fn acquire_image(
&mut self,
_timeout_ns: u64,
_semaphore: | {
true
} | identifier_body |
wgl.rs | FD_TYPE_RGBA,
cColorBits: 8,
cRedBits: 0,
cRedShift: 0,
cGreenBits: 0,
cGreenShift: 0,
cBlueBits: 0,
cBlueShift: 0,
cAlphaBits: 8,
cAlphaShift: 0,
cAccumBits: 0,
cAccumRedBits: 0,
cAccumGreenBits: 0,
cAccumBlueBits: 0,
cAccumAlphaBits: 0,
cDepthBits: 0,
cStencilBits: 0,
cAuxBuffers: 0,
iLayerType: PFD_MAIN_PLANE,
bReserved: 0,
dwLayerMask: 0,
dwVisibleMask: 0,
dwDamageMask: 0,
};
let format_id = ChoosePixelFormat(hdc, &desc);
SetPixelFormat(hdc, format_id, &desc);
let hglrc = wglCreateContext(hdc);
println!("{:?}", (hwnd, hdc, format_id, hglrc));
wglMakeCurrent(hdc, hglrc);
let name = OsStr::new("opengl32.dll")
.encode_wide()
.chain(Some(0).into_iter())
.collect::<Vec<_>>();
let lib = LoadLibraryW(name.as_ptr());
let wgl = wgl_ext_sys::Wgl::load_with(|sym| {
let sym = CString::new(sym.as_bytes()).unwrap();
let addr = wgl_sys::GetProcAddress(sym.as_ptr()) as *const ();
if !addr.is_null() {
addr as *const _
} else {
GetProcAddress(lib, sym.as_ptr()) as *const _
}
});
Entry {
hwnd,
hdc: hdc as _,
wgl,
lib,
}
}
}
}
impl Drop for Entry {
fn drop(&mut self) {
unsafe {
DestroyWindow(self.hwnd);
}
}
}
lazy_static! {
// Entry function pointers
pub(crate) static ref WGL_ENTRY: Entry = Entry::new();
}
pub struct Instance {
pub(crate) ctxt: DeviceContext,
}
impl Instance {
pub fn create(_name: &str, version: u32) -> Result<Self, hal::UnsupportedBackend> {
unsafe {
let glrc = WGL_ENTRY.wgl.CreateContextAttribsARB(
WGL_ENTRY.hdc as *const _,
ptr::null(),
ptr::null(),
) as HGLRC;
wglMakeCurrent(WGL_ENTRY.hdc as *mut _, glrc);
Ok(Instance {
ctxt: DeviceContext {
ctxt: Context { glrc },
hdc: WGL_ENTRY.hdc,
},
})
}
}
#[cfg(windows)]
pub fn create_surface_from_hwnd(&self, hwnd: *mut c_void) -> Surface {
Surface {
hwnd: hwnd as *mut _,
swapchain: None,
renderbuffer: None,
}
}
#[cfg(feature = "winit")]
pub fn create_surface(&self, window: &winit::window::Window) -> Surface {
use winit::platform::windows::WindowExtWindows;
let hwnd = window.hwnd();
self.create_surface_from_hwnd(hwnd as *mut _)
}
}
impl hal::Instance for Instance {
type Backend = Backend;
fn enumerate_adapters(&self) -> Vec<Adapter<Backend>> {
let gl_container = GlContainer::from_fn_proc(|s| unsafe {
let sym = CString::new(s.as_bytes()).unwrap();
let addr = wgl_sys::GetProcAddress(sym.as_ptr()) as *const ();
if !addr.is_null() {
addr as *const _
} else {
GetProcAddress(WGL_ENTRY.lib, sym.as_ptr()) as *const _
}
});
let adapter = PhysicalDevice::new_adapter(self.ctxt, gl_container);
vec![adapter]
}
}
#[derive(Debug)]
pub struct Surface {
pub(crate) hwnd: HWND,
pub(crate) swapchain: Option<Swapchain>,
renderbuffer: Option<native::Renderbuffer>,
}
// TODO: high -msiglreith
unsafe impl Send for Surface {}
unsafe impl Sync for Surface {}
impl window::Surface<Backend> for Surface {
fn compatibility(
&self,
physical_device: &PhysicalDevice,
) -> (
window::SurfaceCapabilities,
Option<Vec<f::Format>>,
Vec<window::PresentMode>,
) {
let extent = unsafe {
let mut rect: RECT = mem::zeroed();
GetClientRect(self.hwnd, &mut rect);
window::Extent2D {
width: (rect.right - rect.left) as _,
height: (rect.bottom - rect.top) as _,
}
};
let caps = window::SurfaceCapabilities {
image_count: 2 ..= 2,
current_extent: Some(extent),
extents: extent ..= extent,
max_image_layers: 1,
usage: image::Usage::COLOR_ATTACHMENT | image::Usage::TRANSFER_SRC,
composite_alpha: window::CompositeAlpha::OPAQUE, //TODO
};
let present_modes = vec![
window::PresentMode::Fifo, //TODO
];
(
caps,
Some(vec![f::Format::Rgba8Srgb, f::Format::Bgra8Srgb]),
present_modes,
)
}
fn supports_queue_family(&self, _queue_family: &QueueFamily) -> bool {
true
}
}
impl window::PresentationSurface<Backend> for Surface {
type SwapchainImage = native::ImageView;
unsafe fn configure_swapchain(
&mut self,
device: &Device,
config: window::SwapchainConfig,
) -> Result<(), window::CreationError> {
let gl = &device.share.context;
let context = match self.swapchain.take() {
Some(old) => {
for fbo in old.fbos {
gl.delete_framebuffer(fbo);
}
old.context
}
None => PresentContext::new(self, &device.share.instance_context),
};
context.make_current();
if self.renderbuffer.is_none() {
self.renderbuffer = Some(gl.create_renderbuffer().unwrap());
}
let desc = conv::describe_format(config.format).unwrap();
gl.bind_renderbuffer(glow::RENDERBUFFER, self.renderbuffer);
gl.renderbuffer_storage(
glow::RENDERBUFFER,
desc.tex_internal,
config.extent.width as i32,
config.extent.height as i32,
);
let fbo = gl.create_framebuffer().unwrap();
gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(fbo));
gl.framebuffer_renderbuffer(
glow::READ_FRAMEBUFFER,
glow::COLOR_ATTACHMENT0,
glow::RENDERBUFFER,
self.renderbuffer,
);
self.swapchain = Some(Swapchain {
context,
extent: config.extent,
fbos: iter::once(fbo).collect(),
});
Ok(())
}
unsafe fn unconfigure_swapchain(&mut self, device: &Device) {
let gl = &device.share.context;
if let Some(old) = self.swapchain.take() {
for fbo in old.fbos {
gl.delete_framebuffer(fbo);
}
}
if let Some(rbo) = self.renderbuffer.take() {
gl.delete_renderbuffer(rbo);
}
}
unsafe fn acquire_image(
&mut self,
_timeout_ns: u64,
) -> Result<(Self::SwapchainImage, Option<window::Suboptimal>), window::AcquireError> {
let image = native::ImageView::Renderbuffer(self.renderbuffer.unwrap());
Ok((image, None))
}
}
#[derive(Debug)]
pub struct Swapchain {
pub(crate) fbos: ArrayVec<[native::RawFrameBuffer; 3]>,
pub(crate) context: PresentContext,
pub(crate) extent: window::Extent2D,
}
impl Swapchain {
pub(crate) fn make_current(&self) {
self.context.make_current();
}
pub(crate) fn swap_buffers(&self) {
self.context.swap_buffers();
}
}
impl window::Swapchain<Backend> for Swapchain {
unsafe fn acquire_image(
&mut self,
_timeout_ns: u64,
_semaphore: Option<&native::Semaphore>,
_fence: Option<&native::Fence>,
) -> Result<(window::SwapImageIndex, Option<window::Suboptimal>), window::AcquireError> {
Ok((0, None)) // TODO
}
}
/// Basic abstraction for wgl context handles.
#[derive(Debug, Copy, Clone)]
struct Context {
glrc: HGLRC,
}
impl Context {
unsafe fn make_current(&self, hdc: HDC) {
wglMakeCurrent(hdc, self.glrc);
}
}
/// Owned context for devices and instances.
#[derive(Debug, Copy, Clone)]
pub(crate) struct DeviceContext {
/// Owned wgl context.
ctxt: Context,
/// Device context owned by the corresponding instance.
///
/// This refers to either a pbuffer or dummy window. Therefore not used for actual presentation.
hdc: HDC,
}
// TODO
unsafe impl Send for DeviceContext {}
unsafe impl Sync for DeviceContext {}
impl DeviceContext {
pub(crate) fn | make_current | identifier_name | |
RunExperiment.py | parser = argparse.ArgumentParser(description='Run simple linear track experiment.')
parser.add_argument('-P', '--serial-port', default='/dev/ttyACM0',
help='TTY device for USB-serial interface (e.g., /dev/ttyUSB0 or COM10)')
parser.add_argument('-C','--param-file', default='defaults.yaml',
help='YAML file containing task parameters')
parser.add_argument('-R','--random-seed', default=None,
help='Random seed. If specified, this also overrides the YAML configuration file.')
parser.add_argument('--output-dir', default=None,
help='Directory to write output file (defaults to cwd)')
parser.add_argument('--no-check-space', default=None,
help='Exits if less than 10 GB of space is available.')
args = parser.parse_args()
print(args)
if args.param_file == 'defaults.yaml':
warnings.warn('Using default configuration file. That is almost certainly not what you want to do!')
# YAML parameters: task settings
with open(args.param_file, 'r') as f:
Config = yaml.safe_load(f)
# ------------------- Validate config file-------------------------------------------------------------
if 'AuditoryStimuli' in Config:
from treadmillio.soundstimulus import validate_sound_config
validate_sound_config(Config['AuditoryStimuli'])
# ------------------- Setup logging. ------------------------------------------------------------------
DoLogCommands = Config['Preferences'].get('LogCommands', True)
if DoLogCommands:
auto_log_directory = Config['Preferences'].get('AutoLogDirectory', True) if 'Preferences' in Config else True
log_directory = Config['Preferences'].get('LogDirectory', None) if 'Preferences' in Config else None
if log_directory is not None and args.output_dir is not None:
warnings.warn('The configuration file specifies {} for logging, '
'but command line has {}. Using command line!\n'.format(log_directory, args.output_dir))
log_directory = args.output_dir
elif args.output_dir is not None:
log_directory = args.output_dir
elif auto_log_directory:
now = datetime.datetime.now()
log_root = Config['Preferences'].get('LogDirectoryRoot', '') if 'Preferences' in Config else ''
log_directory = os.path.join(log_root, '{}{}'.format('ExperimentLog', now.strftime("%Y-%m-%d_%H%M")))
else:
raise(ValueError('You did not specify a directory for experiment logs, and AutoLogDirectory is False.'))
if not os.path.isabs(log_directory):
log_directory = os.path.join(os.getcwd(), log_directory)
orig_log_directory = log_directory
k=1
while os.path.exists(log_directory):
k = k + 1
log_directory = orig_log_directory + '_' + str(k)
if log_directory != orig_log_directory:
warnings.warn('Specified experiment logs directory {} exists, using {}'.format(orig_log_directory, log_directory))
print('Creating log directory: {}\n'.format(log_directory))
os.makedirs(log_directory)
# Check for available space!
if not args.no_check_space:
disk_total, disk_used, disk_free = shutil.disk_usage(log_directory)
if disk_free < 10*1024.0**3: # if less than 10 GB is available, exit
print("\n!!!! Only {} MB available, exiting. Use the '--no-check-space' "
"command line option to override. !!!!".format(disk_free/(1024.0**2)))
os.removedirs(log_directory)
exit(0)
else:
print('#'*80, '\n')
print('Warning!!! Not logging!!!!')
print('#'*80, '\n')
log_directory = None
EnableSound = Config['Preferences'].get('EnableSound', False)
# Check for random seed on command line or in preferences
if args.random_seed is not None:
np.random.seed(int(args.random_seed))
print(f'Setting random seed to {args.random_seed}.')
if 'RandomSeed' in Config['Preferences']:
Config['Preferences']['RandomSeed'] = int(args.random_seed)
print('Overwriting random seed in preferences file (true value will be logged).')
elif 'RandomSeed' in Config['Preferences']:
np.random.seed(Config['Preferences']['RandomSeed'])
print(f"Setting random seed to {Config['Preferences']['RandomSeed']}.")
with ExitStack() as stack:
# -------------- Initialize Serial IO - Won't actually do anything until we call connect()! --------------------------
from treadmillio.serialinterface import SerialInterface
gpio_config = Config.get('GPIO', None)
if not gpio_config:
warnings.warn("No GPIOs specified in config file. All IOs will be inputs.", RuntimeWarning)
maze_config = Config.get('Maze', None)
if 'Preferences' in Config:
zmq_streaming = Config['Preferences'].get('DataStreamingPort', None)
Interface = stack.enter_context(SerialInterface(SerialPort=args.serial_port, gpio_config=gpio_config,
maze_config=maze_config, zmq_streaming=zmq_streaming))
#----------------------- Sound stimuli --------------
if 'AuditoryStimuli' in Config and EnableSound:
from treadmillio.soundstimulus import SoundStimulusController
SoundController = stack.enter_context(SoundStimulusController(Config['AuditoryStimuli'], Interface.virtual_track_length,
Interface.maze_topology, log_directory))
else:
SoundController = None
if 'AuditoryStimuli' in Config:
warnings.warn("Config file specified AuditoryStimuli, but EnableSound is False.", RuntimeWarning)
# ------------------- Read in State Machine States. ------------------------------------------------------------------
if 'StateMachine' in Config:
from treadmillio.taskstatemachine import TaskStateMachine
# BUG: Should check to make sure states are all connected properly?
StateMachine = stack.enter_context(TaskStateMachine(Config['StateMachine'], Interface, SoundController))
else:
StateMachine = None
# ------------------- Read in VR Reward Zones. ------------------------------------------------------------------
if 'RewardZones' in Config:
from treadmillio.rewardzone import RewardZoneController
RewardZones = RewardZoneController(Config['RewardZones'], Interface, SoundController)
else:
RewardZones = None
if DoLogCommands:
# -------------------------- Set up all the different log files -------------------------------------
# Log git diffs for provenance
import git # gitpython
repo = git.Repo(search_parent_directories=True)
GitCommit = repo.head.object.hexsha
GitChangedFiles = [fn.a_path for fn in repo.index.diff(None)]
GitPatch = [fn.diff for fn in repo.index.diff(None, create_patch=True)]
with open(os.path.join(log_directory, 'ExperimentCodeDiffs.txt'), 'w') as git_file:
print(f' Git Commit: {GitCommit}',file=git_file)
if GitChangedFiles:
print(f' ChangedFiles: {GitChangedFiles}',file=git_file)
print(f'Patch:\n{GitPatch}',file=git_file)
# Log config file used
with open(os.path.join(log_directory, 'ParsedConfig.yaml'), 'w') as yaml_file:
yaml.dump(Config, yaml_file, indent=4)
# Create data log file and write header
log_file = stack.enter_context(open(os.path.join(log_directory, 'DataLog.csv'), 'w', newline=''))
print(f'Experiment Data File.\n Version {NamedVersion}',file=log_file)
log_writer = csv.writer(log_file) # logging is actually CSV format
if StateMachine and DoLogCommands:
# Create state machine log file and write header
state_machine_log = stack.enter_context(open(os.path.join(log_directory, 'StatemachineLog.csv'), 'w', newline=''))
print(f'State Machine Log File.\n Version {NamedVersion}',file=state_machine_log)
state_log_writer = csv.writer(state_machine_log)
if RewardZones and DoLogCommands:
# Create state machine log file and write header
reward_zone_log = stack.enter_context(open(os.path.join(log_directory, 'RewardzoneLog.csv'), 'w', newline='', buffering=1))
print(f'Reward Zone Log File.\n Version {NamedVersion}',file=reward_zone_log)
reward_zone_writer = csv.writer(reward_zone_log)
if Profiling:
execution_log = stack.enter_context(open(os.path.join(log_directory, 'execution.csv'), 'w', newline=''))
execution_writer = csv.writer(execution_log)
# ------------------- Webcam Video Recording. ------------------------------------------------------------------ | else:
for cameraname, camera in Config['Cameras'].items():
if camera['RecordVideo']:
print('Over-riding camera configuration to not record video or timestamps!!!')
camera['RecordVideo'] = False
for cameraname, camera in Config['Cameras'].items():
shared_termination_flag = RunCameraInterface(camera) # this starts a bunch of processes
# ------------------- Webcam Video Recording. ------------------------------------------------------------------
if 'GigE-Cameras' in Config:
from treadmillio.camera.gigecam import RunCameraInterface
if DoLogCommands:
for cameraname, camera in Config['GigE-Cameras'].items():
camera['LogDirectory'] = log_directory
else:
for cameraname, | if 'Cameras' in Config:
from treadmillio.uvccam.uvccam import RunCameraInterface
if DoLogCommands:
for cameraname, camera in Config['Cameras'].items():
camera['LogDirectory'] = log_directory | random_line_split |
RunExperiment.py | os.path.join(os.getcwd(), log_directory)
orig_log_directory = log_directory
k=1
while os.path.exists(log_directory):
k = k + 1
log_directory = orig_log_directory + '_' + str(k)
if log_directory != orig_log_directory:
warnings.warn('Specified experiment logs directory {} exists, using {}'.format(orig_log_directory, log_directory))
print('Creating log directory: {}\n'.format(log_directory))
os.makedirs(log_directory)
# Check for available space!
if not args.no_check_space:
disk_total, disk_used, disk_free = shutil.disk_usage(log_directory)
if disk_free < 10*1024.0**3: # if less than 10 GB is available, exit
print("\n!!!! Only {} MB available, exiting. Use the '--no-check-space' "
"command line option to override. !!!!".format(disk_free/(1024.0**2)))
os.removedirs(log_directory)
exit(0)
else:
print('#'*80, '\n')
print('Warning!!! Not logging!!!!')
print('#'*80, '\n')
log_directory = None
EnableSound = Config['Preferences'].get('EnableSound', False)
# Check for random seed on command line or in preferences
if args.random_seed is not None:
np.random.seed(int(args.random_seed))
print(f'Setting random seed to {args.random_seed}.')
if 'RandomSeed' in Config['Preferences']:
Config['Preferences']['RandomSeed'] = int(args.random_seed)
print('Overwriting random seed in preferences file (true value will be logged).')
elif 'RandomSeed' in Config['Preferences']:
np.random.seed(Config['Preferences']['RandomSeed'])
print(f"Setting random seed to {Config['Preferences']['RandomSeed']}.")
with ExitStack() as stack:
# -------------- Initialize Serial IO - Won't actually do anything until we call connect()! --------------------------
from treadmillio.serialinterface import SerialInterface
gpio_config = Config.get('GPIO', None)
if not gpio_config:
warnings.warn("No GPIOs specified in config file. All IOs will be inputs.", RuntimeWarning)
maze_config = Config.get('Maze', None)
if 'Preferences' in Config:
zmq_streaming = Config['Preferences'].get('DataStreamingPort', None)
Interface = stack.enter_context(SerialInterface(SerialPort=args.serial_port, gpio_config=gpio_config,
maze_config=maze_config, zmq_streaming=zmq_streaming))
#----------------------- Sound stimuli --------------
if 'AuditoryStimuli' in Config and EnableSound:
from treadmillio.soundstimulus import SoundStimulusController
SoundController = stack.enter_context(SoundStimulusController(Config['AuditoryStimuli'], Interface.virtual_track_length,
Interface.maze_topology, log_directory))
else:
SoundController = None
if 'AuditoryStimuli' in Config:
warnings.warn("Config file specified AuditoryStimuli, but EnableSound is False.", RuntimeWarning)
# ------------------- Read in State Machine States. ------------------------------------------------------------------
if 'StateMachine' in Config:
from treadmillio.taskstatemachine import TaskStateMachine
# BUG: Should check to make sure states are all connected properly?
StateMachine = stack.enter_context(TaskStateMachine(Config['StateMachine'], Interface, SoundController))
else:
StateMachine = None
# ------------------- Read in VR Reward Zones. ------------------------------------------------------------------
if 'RewardZones' in Config:
from treadmillio.rewardzone import RewardZoneController
RewardZones = RewardZoneController(Config['RewardZones'], Interface, SoundController)
else:
RewardZones = None
if DoLogCommands:
# -------------------------- Set up all the different log files -------------------------------------
# Log git diffs for provenance
import git # gitpython
repo = git.Repo(search_parent_directories=True)
GitCommit = repo.head.object.hexsha
GitChangedFiles = [fn.a_path for fn in repo.index.diff(None)]
GitPatch = [fn.diff for fn in repo.index.diff(None, create_patch=True)]
with open(os.path.join(log_directory, 'ExperimentCodeDiffs.txt'), 'w') as git_file:
print(f' Git Commit: {GitCommit}',file=git_file)
if GitChangedFiles:
print(f' ChangedFiles: {GitChangedFiles}',file=git_file)
print(f'Patch:\n{GitPatch}',file=git_file)
# Log config file used
with open(os.path.join(log_directory, 'ParsedConfig.yaml'), 'w') as yaml_file:
yaml.dump(Config, yaml_file, indent=4)
# Create data log file and write header
log_file = stack.enter_context(open(os.path.join(log_directory, 'DataLog.csv'), 'w', newline=''))
print(f'Experiment Data File.\n Version {NamedVersion}',file=log_file)
log_writer = csv.writer(log_file) # logging is actually CSV format
if StateMachine and DoLogCommands:
# Create state machine log file and write header
state_machine_log = stack.enter_context(open(os.path.join(log_directory, 'StatemachineLog.csv'), 'w', newline=''))
print(f'State Machine Log File.\n Version {NamedVersion}',file=state_machine_log)
state_log_writer = csv.writer(state_machine_log)
if RewardZones and DoLogCommands:
# Create state machine log file and write header
reward_zone_log = stack.enter_context(open(os.path.join(log_directory, 'RewardzoneLog.csv'), 'w', newline='', buffering=1))
print(f'Reward Zone Log File.\n Version {NamedVersion}',file=reward_zone_log)
reward_zone_writer = csv.writer(reward_zone_log)
if Profiling:
execution_log = stack.enter_context(open(os.path.join(log_directory, 'execution.csv'), 'w', newline=''))
execution_writer = csv.writer(execution_log)
# ------------------- Webcam Video Recording. ------------------------------------------------------------------
if 'Cameras' in Config:
from treadmillio.uvccam.uvccam import RunCameraInterface
if DoLogCommands:
for cameraname, camera in Config['Cameras'].items():
camera['LogDirectory'] = log_directory
else:
for cameraname, camera in Config['Cameras'].items():
if camera['RecordVideo']:
print('Over-riding camera configuration to not record video or timestamps!!!')
camera['RecordVideo'] = False
for cameraname, camera in Config['Cameras'].items():
shared_termination_flag = RunCameraInterface(camera) # this starts a bunch of processes
# ------------------- Webcam Video Recording. ------------------------------------------------------------------
if 'GigE-Cameras' in Config:
from treadmillio.camera.gigecam import RunCameraInterface
if DoLogCommands:
for cameraname, camera in Config['GigE-Cameras'].items():
camera['LogDirectory'] = log_directory
else:
for cameraname, camera in Config['GigE-Cameras'].items():
if camera['RecordVideo']:
print('Over-riding camera configuration to not record video or timestamps!!!')
camera['RecordVideo'] = False
for cameraname, camera in Config['GigE-Cameras'].items():
shared_termination_flag = RunCameraInterface(camera) # this starts a bunch of processes
# TODO: Figure out how to handle errors below. The shared termination flag should work, but it doesn't
# ----------------- Initialization
##### Actually connect to IO device. We wait until here so that data doesn't get lost/confused in serial buffer
Interface.connect()
FlagChar, StructSize, MasterTime, InitialEncoder, InitialUnwrappedEncoder, InitialGPIO, AuxGPIO = Interface.read_data() # This will initialize encoder
if SoundController:
SoundController.start_capture() # TODO: This doesn't currently do anything
if StateMachine:
StateMachine.start(MasterTime)
first_sample = True
while(True):
## every 2 ms happens:
FlagChar, StructSize, MasterTime, Encoder, UnwrappedEncoder, GPIO, AuxGPIO = Interface.read_data()
last_ts = time.monotonic() # to match with miniscope timestamps (which is written in msec, here is sec)
# since read_data() is blocking, this is a farther bound (i.e., ts AFTER) data
if DoLogCommands:
if not first_sample:
log_writer.writerow([MasterTime, GPIO, Encoder, UnwrappedEncoder, last_ts, Interface.pos, Interface.velocity]) # Log data from serial interface
else: # for ths first sample, to synchronize to a meaningful clock, we the CLOCK_REALTIME time, in the first row
sys_ts = time.time()
log_writer.writerow([0, InitialGPIO, InitialEncoder, UnwrappedEncoder, sys_ts, 0, 0])
log_writer.writerow([MasterTime, GPIO, Encoder, UnwrappedEncoder, last_ts, Interface.pos, Interface.velocity])
first_sample = False
# -------------------- Updates --------------------
Interface.update_pulses() # lower any outstanding GPIO pulses
if SoundController:
SoundController.update_beeps(MasterTime) # stop any outstanding beeps
if StateMachine:
| if DoLogCommands:
StateMachine.update_statemachine(state_log_writer.writerow) # update the state machine
else:
StateMachine.update_statemachine(None) # update the state machine | conditional_block | |
single_iceberg_model.py | Download timing start
start_download = time.time ()
print ("Downloading Web data to files")
#Downloading data and writing to files function
def download (url):
"""
Downloads web data and writes it to a file
Parameters
----------
url : String
Web address used as the data source.
Returns
-------
None.
"""
path, url = url
r = requests.get (url, stream = True)
content = r.text
#print (content)
with open (path + '.txt', 'w') as f:
f.write (content)
#List of url web data
urls = [('Lidar', 'https://www.geog.leeds.ac.uk/courses/computing/study/core-python-odl2/assessment2/white1.lidar'),
('Radar', 'https://www.geog.leeds.ac.uk/courses/computing/study/core-python-odl2/assessment2/white1.radar')]
#Call download function
for x in urls:
download (x)
"""
Stage 3: Reading csv data into lists
"""
print ("Reading csv data")
#Reading csv into lidar
#Lidar represents the height of the pixel within the environment
lidar = []
with open ('Lidar.txt', newline = '') as f1:
reader = csv.reader (f1, quoting=csv.QUOTE_NONNUMERIC)
for row in reader:
#print (row)
rowlist_L = []
for value in row:
#print (value)
rowlist_L.append (int (value))
lidar.append (rowlist_L)
#for row in lidar:
#print ("length of row:", len (row))
#List contains empty rows
#Remove empty rows
lidar_clean = [x for x in lidar if x != []]
#print ("lidar2 length =", len(lidar_clean))
# for row in lidar_clean:
# print ("length of row:", len (row))
#Data familiaristation
# print (lidar_clean)
# print (type(lidar_clean))
# print ("Lidar length = ", len(lidar_clean))
#Reading csv into radar
#Radar represents ice or water within the environment
radar = []
with open ('Radar.txt', newline = '') as f2:
reader2 = csv.reader (f2, quoting=csv.QUOTE_NONNUMERIC)
for row in reader2:
#print (row)
rowlist_R = []
for value in row:
#print (value)
rowlist_R.append (int (value))
radar.append (rowlist_R)
#for row in radar:
#print ("length of row:", len (row))
#list contains empty rows
#remove empty rows
radar_clean = [x for x in radar if x != []]
#for row in radar_clean:
#print ("length of row:", len (row))
#Data familiarisation
# print (radar_clean)
# print (type(radar_clean))
# print ("Radar length = ", len(radar_clean))
#Download and list creation timing
end_download = time.time ()
download_time = (end_download - start_download)
print ("Download to reading in time: " + str(download_time))
# """
# Displaying lidar and radar data
# """
# #Code based on https://www.kite.com/python/answers/how-to-show-two-figures-at-once-in-matplotlib-in-python
# #Define axes
# plt.ylim = (0, 300)
# plt.xlim = (0, 300)
# #Lidar plot
# lidar_plot = plt.figure (1)
# #Assign title
# plt.title ('Lidar data')
# plt.imshow (lidar_clean)
# #Radar plot
# radar_plot = plt.figure (2)
# #Assign title
# plt.title ('Radar data')
# plt.imshow (radar_clean)
# #Show plots
# plt.show ()
#Commented code above has been moved into the GUI so removed here
"""
Stage 4: Finding ice areas and pulling their heights
"""
#Calculation timing
start_calculation = time.time ()
#Data familiarisation
# print (radar_clean [145][150])
# print (radar_clean [145])
# print (lidar_clean [145][150])
# print (lidar_clean [145])
print ("Locating ice and pulling heights")
#Pulling heights from lidar data
def pull_heights ():
"""
Pulls height values from the lidar data from ice locations within the
radar data, appending the heights to an ice list
Returns
-------
None.
"""
global ice
ice = []
for i in range (len (radar_clean)):
for j in range (len (radar_clean)):
|
#print (ice)
#print (len (ice))
print ("Ice located and heights pulled")
"""
Stage 5: Calculating ice mass
"""
print ("Determining iceberg size")
#Pull heights
def calculations ():
pull_heights ()
ice_size = (len(ice))
#print ("ice size:", ice_size)
#Calculating ice volume above sea level
print ("Calculating ice mass")
#Convert ice values from cm to m
ice_m = ((sum (ice)) * 0.1)
#print (ice_m)
#Calculating ice volume above surface
global ice_volume_positive
ice_volume_positive = (ice_size * ice_m)
#print (ice_volume_positive)
#Calculating sub-surface ice volume
global ice_volume_subsurface
ice_volume_subsurface = ice_volume_positive * 10
#print (ice_volume_subsurface)
#Calculating total ice volume
global ice_volume
ice_volume = ice_volume_positive + ice_volume_subsurface
#print (ice_volume)
#Calculating ice mass
global ice_mass
ice_mass = 900 * ice_volume
#print (ice_mass)
print ("Ice mass calculated")
run = tkinter.Label\
(text= ("Running Program" + "\n"))
run.pack ()
results_btn ['state'] = 'normal'
# """
# Stage 6: Calculating towability
# """
# print ("Calculating towability")
# def towability ():
# """
# Determines the towability of the iceberg
# Returns
# -------
# None.
# """
# if ice_mass > 36000000:
# print ("Iceberg cannot be towed")
# else:
# print ("Iceberg can be towed")
# print ("Towability calculated")
#Commented towability code above moved into GUI so removed here
#Calculation timing
end_calculation = time.time ()
calculation_time = (end_calculation - start_calculation)
print ("Calculation time: ", calculation_time)
# """
# Stage 6: Writing data out to a file
# """
# with open ("Data_out.txt", 'w') as FO:
# FO.write ("Above surface volume: " + str(ice_volume_positive) + '\n')
# FO.write ("Subsurface volume: " + str(ice_volume_subsurface) + '\n')
# FO.write ("Total ice volume: " + str(ice_volume) + '\n')
# FO.write ("Total mass: " + str(ice_mass) + '\n')
# Section moved to after GUI is completed as to access global variables
# within calculations function
"""
Stage 6: Initialise and populate GUI
"""
#Label code based on https://www.python-course.eu/tkinter_text_widget.php
#Create GUI description
description = tkinter.Label\
(text="This GUI runs the Iceberg Towability Model and shows its inputs and results"\
+ '\n')
description.pack ()
#Create user defined run
# menu_bar = tkinter.Menu (root)
# root.config (menu = menu_bar)
# model_menu = tkinter.Menu (menu_bar)
# menu_bar.add_cascade (label= "Model", menu= model_menu)
# model_menu.add_command (label= "Run Model", command= calculations)
run_btn = tkinter.Button (root, text= 'Run Program', command = calculations)
run_btn.pack (side= 'top', fill= 'both')
#Show input data graphs
def show_graphs ():
"""
Generates two figures simultaneously displaying lidar and radar input
datasets.
Figures will appear in individual pop-up windows.
Returns
-------
None.
"""
plt.ylim = (0, 300)
plt.xlim = (0, 300)
#Set up lidar plot to figure 1
lidar_plot = plt.figure (1)
#Assign title
plt.title ('Lidar data')
#Assign data
plt.imshow (lidar_clean)
#Set up radar plot to figure 2
radar_plot = plt.figure (2)
#Assign title
plt.title ('Radar data')
#Assign data
plt.imshow (radar_clean)
#Show plots
plt.show ()
#Display the results
def show_results ():
| radar_clean [i][j] = lidar_clean [i][j]
#print (radar_clean [i][j])
if (radar_clean [i][j]) > 100:
#print (radar_clean [i][j])
ice.append (lidar_clean [i][j]) | conditional_block |
single_iceberg_model.py | Download timing start
start_download = time.time ()
print ("Downloading Web data to files")
#Downloading data and writing to files function
def download (url):
"""
Downloads web data and writes it to a file
Parameters
----------
url : String
Web address used as the data source.
Returns
-------
None.
"""
path, url = url
r = requests.get (url, stream = True)
content = r.text
#print (content)
with open (path + '.txt', 'w') as f:
f.write (content)
#List of url web data
urls = [('Lidar', 'https://www.geog.leeds.ac.uk/courses/computing/study/core-python-odl2/assessment2/white1.lidar'),
('Radar', 'https://www.geog.leeds.ac.uk/courses/computing/study/core-python-odl2/assessment2/white1.radar')]
#Call download function
for x in urls:
download (x)
"""
Stage 3: Reading csv data into lists
"""
print ("Reading csv data")
#Reading csv into lidar
#Lidar represents the height of the pixel within the environment
lidar = []
with open ('Lidar.txt', newline = '') as f1:
reader = csv.reader (f1, quoting=csv.QUOTE_NONNUMERIC)
for row in reader:
#print (row)
rowlist_L = []
for value in row:
#print (value)
rowlist_L.append (int (value))
lidar.append (rowlist_L)
#for row in lidar:
#print ("length of row:", len (row))
#List contains empty rows
#Remove empty rows
lidar_clean = [x for x in lidar if x != []]
#print ("lidar2 length =", len(lidar_clean))
# for row in lidar_clean:
# print ("length of row:", len (row))
#Data familiaristation
# print (lidar_clean)
# print (type(lidar_clean))
# print ("Lidar length = ", len(lidar_clean))
#Reading csv into radar
#Radar represents ice or water within the environment
radar = []
with open ('Radar.txt', newline = '') as f2:
reader2 = csv.reader (f2, quoting=csv.QUOTE_NONNUMERIC)
for row in reader2:
#print (row)
rowlist_R = []
for value in row:
#print (value)
rowlist_R.append (int (value))
radar.append (rowlist_R)
#for row in radar:
#print ("length of row:", len (row))
#list contains empty rows
#remove empty rows
radar_clean = [x for x in radar if x != []]
#for row in radar_clean:
#print ("length of row:", len (row))
#Data familiarisation
# print (radar_clean)
# print (type(radar_clean))
# print ("Radar length = ", len(radar_clean))
#Download and list creation timing
end_download = time.time ()
download_time = (end_download - start_download)
print ("Download to reading in time: " + str(download_time))
# """
# Displaying lidar and radar data
# """
# #Code based on https://www.kite.com/python/answers/how-to-show-two-figures-at-once-in-matplotlib-in-python
# #Define axes
# plt.ylim = (0, 300)
# plt.xlim = (0, 300)
# #Lidar plot
# lidar_plot = plt.figure (1)
# #Assign title
# plt.title ('Lidar data')
# plt.imshow (lidar_clean)
# #Radar plot
# radar_plot = plt.figure (2)
# #Assign title
# plt.title ('Radar data')
# plt.imshow (radar_clean)
# #Show plots
# plt.show ()
#Commented code above has been moved into the GUI so removed here
"""
Stage 4: Finding ice areas and pulling their heights
"""
#Calculation timing
start_calculation = time.time ()
#Data familiarisation
# print (radar_clean [145][150])
# print (radar_clean [145])
# print (lidar_clean [145][150])
# print (lidar_clean [145])
print ("Locating ice and pulling heights")
#Pulling heights from lidar data
def pull_heights ():
"""
Pulls height values from the lidar data from ice locations within the
radar data, appending the heights to an ice list
Returns
-------
None. | for i in range (len (radar_clean)):
for j in range (len (radar_clean)):
radar_clean [i][j] = lidar_clean [i][j]
#print (radar_clean [i][j])
if (radar_clean [i][j]) > 100:
#print (radar_clean [i][j])
ice.append (lidar_clean [i][j])
#print (ice)
#print (len (ice))
print ("Ice located and heights pulled")
"""
Stage 5: Calculating ice mass
"""
print ("Determining iceberg size")
#Pull heights
def calculations ():
pull_heights ()
ice_size = (len(ice))
#print ("ice size:", ice_size)
#Calculating ice volume above sea level
print ("Calculating ice mass")
#Convert ice values from cm to m
ice_m = ((sum (ice)) * 0.1)
#print (ice_m)
#Calculating ice volume above surface
global ice_volume_positive
ice_volume_positive = (ice_size * ice_m)
#print (ice_volume_positive)
#Calculating sub-surface ice volume
global ice_volume_subsurface
ice_volume_subsurface = ice_volume_positive * 10
#print (ice_volume_subsurface)
#Calculating total ice volume
global ice_volume
ice_volume = ice_volume_positive + ice_volume_subsurface
#print (ice_volume)
#Calculating ice mass
global ice_mass
ice_mass = 900 * ice_volume
#print (ice_mass)
print ("Ice mass calculated")
run = tkinter.Label\
(text= ("Running Program" + "\n"))
run.pack ()
results_btn ['state'] = 'normal'
# """
# Stage 6: Calculating towability
# """
# print ("Calculating towability")
# def towability ():
# """
# Determines the towability of the iceberg
# Returns
# -------
# None.
# """
# if ice_mass > 36000000:
# print ("Iceberg cannot be towed")
# else:
# print ("Iceberg can be towed")
# print ("Towability calculated")
#Commented towability code above moved into GUI so removed here
#Calculation timing
end_calculation = time.time ()
calculation_time = (end_calculation - start_calculation)
print ("Calculation time: ", calculation_time)
# """
# Stage 6: Writing data out to a file
# """
# with open ("Data_out.txt", 'w') as FO:
# FO.write ("Above surface volume: " + str(ice_volume_positive) + '\n')
# FO.write ("Subsurface volume: " + str(ice_volume_subsurface) + '\n')
# FO.write ("Total ice volume: " + str(ice_volume) + '\n')
# FO.write ("Total mass: " + str(ice_mass) + '\n')
# Section moved to after GUI is completed as to access global variables
# within calculations function
"""
Stage 6: Initialise and populate GUI
"""
#Label code based on https://www.python-course.eu/tkinter_text_widget.php
#Create GUI description
description = tkinter.Label\
(text="This GUI runs the Iceberg Towability Model and shows its inputs and results"\
+ '\n')
description.pack ()
#Create user defined run
# menu_bar = tkinter.Menu (root)
# root.config (menu = menu_bar)
# model_menu = tkinter.Menu (menu_bar)
# menu_bar.add_cascade (label= "Model", menu= model_menu)
# model_menu.add_command (label= "Run Model", command= calculations)
run_btn = tkinter.Button (root, text= 'Run Program', command = calculations)
run_btn.pack (side= 'top', fill= 'both')
#Show input data graphs
def show_graphs ():
"""
Generates two figures simultaneously displaying lidar and radar input
datasets.
Figures will appear in individual pop-up windows.
Returns
-------
None.
"""
plt.ylim = (0, 300)
plt.xlim = (0, 300)
#Set up lidar plot to figure 1
lidar_plot = plt.figure (1)
#Assign title
plt.title ('Lidar data')
#Assign data
plt.imshow (lidar_clean)
#Set up radar plot to figure 2
radar_plot = plt.figure (2)
#Assign title
plt.title ('Radar data')
#Assign data
plt.imshow (radar_clean)
#Show plots
plt.show ()
#Display the results
def show_results ():
|
"""
global ice
ice = [] | random_line_split |
single_iceberg_model.py | Download timing start
start_download = time.time ()
print ("Downloading Web data to files")
#Downloading data and writing to files function
def download (url):
|
#List of url web data
urls = [('Lidar', 'https://www.geog.leeds.ac.uk/courses/computing/study/core-python-odl2/assessment2/white1.lidar'),
('Radar', 'https://www.geog.leeds.ac.uk/courses/computing/study/core-python-odl2/assessment2/white1.radar')]
#Call download function
for x in urls:
download (x)
"""
Stage 3: Reading csv data into lists
"""
print ("Reading csv data")
#Reading csv into lidar
#Lidar represents the height of the pixel within the environment
lidar = []
with open ('Lidar.txt', newline = '') as f1:
reader = csv.reader (f1, quoting=csv.QUOTE_NONNUMERIC)
for row in reader:
#print (row)
rowlist_L = []
for value in row:
#print (value)
rowlist_L.append (int (value))
lidar.append (rowlist_L)
#for row in lidar:
#print ("length of row:", len (row))
#List contains empty rows
#Remove empty rows
lidar_clean = [x for x in lidar if x != []]
#print ("lidar2 length =", len(lidar_clean))
# for row in lidar_clean:
# print ("length of row:", len (row))
#Data familiaristation
# print (lidar_clean)
# print (type(lidar_clean))
# print ("Lidar length = ", len(lidar_clean))
#Reading csv into radar
#Radar represents ice or water within the environment
radar = []
with open ('Radar.txt', newline = '') as f2:
reader2 = csv.reader (f2, quoting=csv.QUOTE_NONNUMERIC)
for row in reader2:
#print (row)
rowlist_R = []
for value in row:
#print (value)
rowlist_R.append (int (value))
radar.append (rowlist_R)
#for row in radar:
#print ("length of row:", len (row))
#list contains empty rows
#remove empty rows
radar_clean = [x for x in radar if x != []]
#for row in radar_clean:
#print ("length of row:", len (row))
#Data familiarisation
# print (radar_clean)
# print (type(radar_clean))
# print ("Radar length = ", len(radar_clean))
#Download and list creation timing
end_download = time.time ()
download_time = (end_download - start_download)
print ("Download to reading in time: " + str(download_time))
# """
# Displaying lidar and radar data
# """
# #Code based on https://www.kite.com/python/answers/how-to-show-two-figures-at-once-in-matplotlib-in-python
# #Define axes
# plt.ylim = (0, 300)
# plt.xlim = (0, 300)
# #Lidar plot
# lidar_plot = plt.figure (1)
# #Assign title
# plt.title ('Lidar data')
# plt.imshow (lidar_clean)
# #Radar plot
# radar_plot = plt.figure (2)
# #Assign title
# plt.title ('Radar data')
# plt.imshow (radar_clean)
# #Show plots
# plt.show ()
#Commented code above has been moved into the GUI so removed here
"""
Stage 4: Finding ice areas and pulling their heights
"""
#Calculation timing
start_calculation = time.time ()
#Data familiarisation
# print (radar_clean [145][150])
# print (radar_clean [145])
# print (lidar_clean [145][150])
# print (lidar_clean [145])
print ("Locating ice and pulling heights")
#Pulling heights from lidar data
def pull_heights ():
"""
Pulls height values from the lidar data from ice locations within the
radar data, appending the heights to an ice list
Returns
-------
None.
"""
global ice
ice = []
for i in range (len (radar_clean)):
for j in range (len (radar_clean)):
radar_clean [i][j] = lidar_clean [i][j]
#print (radar_clean [i][j])
if (radar_clean [i][j]) > 100:
#print (radar_clean [i][j])
ice.append (lidar_clean [i][j])
#print (ice)
#print (len (ice))
print ("Ice located and heights pulled")
"""
Stage 5: Calculating ice mass
"""
print ("Determining iceberg size")
#Pull heights
def calculations ():
pull_heights ()
ice_size = (len(ice))
#print ("ice size:", ice_size)
#Calculating ice volume above sea level
print ("Calculating ice mass")
#Convert ice values from cm to m
ice_m = ((sum (ice)) * 0.1)
#print (ice_m)
#Calculating ice volume above surface
global ice_volume_positive
ice_volume_positive = (ice_size * ice_m)
#print (ice_volume_positive)
#Calculating sub-surface ice volume
global ice_volume_subsurface
ice_volume_subsurface = ice_volume_positive * 10
#print (ice_volume_subsurface)
#Calculating total ice volume
global ice_volume
ice_volume = ice_volume_positive + ice_volume_subsurface
#print (ice_volume)
#Calculating ice mass
global ice_mass
ice_mass = 900 * ice_volume
#print (ice_mass)
print ("Ice mass calculated")
run = tkinter.Label\
(text= ("Running Program" + "\n"))
run.pack ()
results_btn ['state'] = 'normal'
# """
# Stage 6: Calculating towability
# """
# print ("Calculating towability")
# def towability ():
# """
# Determines the towability of the iceberg
# Returns
# -------
# None.
# """
# if ice_mass > 36000000:
# print ("Iceberg cannot be towed")
# else:
# print ("Iceberg can be towed")
# print ("Towability calculated")
#Commented towability code above moved into GUI so removed here
#Calculation timing
end_calculation = time.time ()
calculation_time = (end_calculation - start_calculation)
print ("Calculation time: ", calculation_time)
# """
# Stage 6: Writing data out to a file
# """
# with open ("Data_out.txt", 'w') as FO:
# FO.write ("Above surface volume: " + str(ice_volume_positive) + '\n')
# FO.write ("Subsurface volume: " + str(ice_volume_subsurface) + '\n')
# FO.write ("Total ice volume: " + str(ice_volume) + '\n')
# FO.write ("Total mass: " + str(ice_mass) + '\n')
# Section moved to after GUI is completed as to access global variables
# within calculations function
"""
Stage 6: Initialise and populate GUI
"""
#Label code based on https://www.python-course.eu/tkinter_text_widget.php
#Create GUI description
description = tkinter.Label\
(text="This GUI runs the Iceberg Towability Model and shows its inputs and results"\
+ '\n')
description.pack ()
#Create user defined run
# menu_bar = tkinter.Menu (root)
# root.config (menu = menu_bar)
# model_menu = tkinter.Menu (menu_bar)
# menu_bar.add_cascade (label= "Model", menu= model_menu)
# model_menu.add_command (label= "Run Model", command= calculations)
run_btn = tkinter.Button (root, text= 'Run Program', command = calculations)
run_btn.pack (side= 'top', fill= 'both')
#Show input data graphs
def show_graphs ():
"""
Generates two figures simultaneously displaying lidar and radar input
datasets.
Figures will appear in individual pop-up windows.
Returns
-------
None.
"""
plt.ylim = (0, 300)
plt.xlim = (0, 300)
#Set up lidar plot to figure 1
lidar_plot = plt.figure (1)
#Assign title
plt.title ('Lidar data')
#Assign data
plt.imshow (lidar_clean)
#Set up radar plot to figure 2
radar_plot = plt.figure (2)
#Assign title
plt.title ('Radar data')
#Assign data
plt.imshow (radar_clean)
#Show plots
plt.show ()
#Display the results
def show_results ():
| """
Downloads web data and writes it to a file
Parameters
----------
url : String
Web address used as the data source.
Returns
-------
None.
"""
path, url = url
r = requests.get (url, stream = True)
content = r.text
#print (content)
with open (path + '.txt', 'w') as f:
f.write (content) | identifier_body |
single_iceberg_model.py | Download timing start
start_download = time.time ()
print ("Downloading Web data to files")
#Downloading data and writing to files function
def download (url):
"""
Downloads web data and writes it to a file
Parameters
----------
url : String
Web address used as the data source.
Returns
-------
None.
"""
path, url = url
r = requests.get (url, stream = True)
content = r.text
#print (content)
with open (path + '.txt', 'w') as f:
f.write (content)
#List of url web data
urls = [('Lidar', 'https://www.geog.leeds.ac.uk/courses/computing/study/core-python-odl2/assessment2/white1.lidar'),
('Radar', 'https://www.geog.leeds.ac.uk/courses/computing/study/core-python-odl2/assessment2/white1.radar')]
#Call download function
for x in urls:
download (x)
"""
Stage 3: Reading csv data into lists
"""
print ("Reading csv data")
#Reading csv into lidar
#Lidar represents the height of the pixel within the environment
lidar = []
with open ('Lidar.txt', newline = '') as f1:
reader = csv.reader (f1, quoting=csv.QUOTE_NONNUMERIC)
for row in reader:
#print (row)
rowlist_L = []
for value in row:
#print (value)
rowlist_L.append (int (value))
lidar.append (rowlist_L)
#for row in lidar:
#print ("length of row:", len (row))
#List contains empty rows
#Remove empty rows
lidar_clean = [x for x in lidar if x != []]
#print ("lidar2 length =", len(lidar_clean))
# for row in lidar_clean:
# print ("length of row:", len (row))
#Data familiaristation
# print (lidar_clean)
# print (type(lidar_clean))
# print ("Lidar length = ", len(lidar_clean))
#Reading csv into radar
#Radar represents ice or water within the environment
radar = []
with open ('Radar.txt', newline = '') as f2:
reader2 = csv.reader (f2, quoting=csv.QUOTE_NONNUMERIC)
for row in reader2:
#print (row)
rowlist_R = []
for value in row:
#print (value)
rowlist_R.append (int (value))
radar.append (rowlist_R)
#for row in radar:
#print ("length of row:", len (row))
#list contains empty rows
#remove empty rows
radar_clean = [x for x in radar if x != []]
#for row in radar_clean:
#print ("length of row:", len (row))
#Data familiarisation
# print (radar_clean)
# print (type(radar_clean))
# print ("Radar length = ", len(radar_clean))
#Download and list creation timing
end_download = time.time ()
download_time = (end_download - start_download)
print ("Download to reading in time: " + str(download_time))
# """
# Displaying lidar and radar data
# """
# #Code based on https://www.kite.com/python/answers/how-to-show-two-figures-at-once-in-matplotlib-in-python
# #Define axes
# plt.ylim = (0, 300)
# plt.xlim = (0, 300)
# #Lidar plot
# lidar_plot = plt.figure (1)
# #Assign title
# plt.title ('Lidar data')
# plt.imshow (lidar_clean)
# #Radar plot
# radar_plot = plt.figure (2)
# #Assign title
# plt.title ('Radar data')
# plt.imshow (radar_clean)
# #Show plots
# plt.show ()
#Commented code above has been moved into the GUI so removed here
"""
Stage 4: Finding ice areas and pulling their heights
"""
#Calculation timing
start_calculation = time.time ()
#Data familiarisation
# print (radar_clean [145][150])
# print (radar_clean [145])
# print (lidar_clean [145][150])
# print (lidar_clean [145])
print ("Locating ice and pulling heights")
#Pulling heights from lidar data
def pull_heights ():
"""
Pulls height values from the lidar data from ice locations within the
radar data, appending the heights to an ice list
Returns
-------
None.
"""
global ice
ice = []
for i in range (len (radar_clean)):
for j in range (len (radar_clean)):
radar_clean [i][j] = lidar_clean [i][j]
#print (radar_clean [i][j])
if (radar_clean [i][j]) > 100:
#print (radar_clean [i][j])
ice.append (lidar_clean [i][j])
#print (ice)
#print (len (ice))
print ("Ice located and heights pulled")
"""
Stage 5: Calculating ice mass
"""
print ("Determining iceberg size")
#Pull heights
def calculations ():
pull_heights ()
ice_size = (len(ice))
#print ("ice size:", ice_size)
#Calculating ice volume above sea level
print ("Calculating ice mass")
#Convert ice values from cm to m
ice_m = ((sum (ice)) * 0.1)
#print (ice_m)
#Calculating ice volume above surface
global ice_volume_positive
ice_volume_positive = (ice_size * ice_m)
#print (ice_volume_positive)
#Calculating sub-surface ice volume
global ice_volume_subsurface
ice_volume_subsurface = ice_volume_positive * 10
#print (ice_volume_subsurface)
#Calculating total ice volume
global ice_volume
ice_volume = ice_volume_positive + ice_volume_subsurface
#print (ice_volume)
#Calculating ice mass
global ice_mass
ice_mass = 900 * ice_volume
#print (ice_mass)
print ("Ice mass calculated")
run = tkinter.Label\
(text= ("Running Program" + "\n"))
run.pack ()
results_btn ['state'] = 'normal'
# """
# Stage 6: Calculating towability
# """
# print ("Calculating towability")
# def towability ():
# """
# Determines the towability of the iceberg
# Returns
# -------
# None.
# """
# if ice_mass > 36000000:
# print ("Iceberg cannot be towed")
# else:
# print ("Iceberg can be towed")
# print ("Towability calculated")
#Commented towability code above moved into GUI so removed here
#Calculation timing
end_calculation = time.time ()
calculation_time = (end_calculation - start_calculation)
print ("Calculation time: ", calculation_time)
# """
# Stage 6: Writing data out to a file
# """
# with open ("Data_out.txt", 'w') as FO:
# FO.write ("Above surface volume: " + str(ice_volume_positive) + '\n')
# FO.write ("Subsurface volume: " + str(ice_volume_subsurface) + '\n')
# FO.write ("Total ice volume: " + str(ice_volume) + '\n')
# FO.write ("Total mass: " + str(ice_mass) + '\n')
# Section moved to after GUI is completed as to access global variables
# within calculations function
"""
Stage 6: Initialise and populate GUI
"""
#Label code based on https://www.python-course.eu/tkinter_text_widget.php
#Create GUI description
description = tkinter.Label\
(text="This GUI runs the Iceberg Towability Model and shows its inputs and results"\
+ '\n')
description.pack ()
#Create user defined run
# menu_bar = tkinter.Menu (root)
# root.config (menu = menu_bar)
# model_menu = tkinter.Menu (menu_bar)
# menu_bar.add_cascade (label= "Model", menu= model_menu)
# model_menu.add_command (label= "Run Model", command= calculations)
run_btn = tkinter.Button (root, text= 'Run Program', command = calculations)
run_btn.pack (side= 'top', fill= 'both')
#Show input data graphs
def | ():
"""
Generates two figures simultaneously displaying lidar and radar input
datasets.
Figures will appear in individual pop-up windows.
Returns
-------
None.
"""
plt.ylim = (0, 300)
plt.xlim = (0, 300)
#Set up lidar plot to figure 1
lidar_plot = plt.figure (1)
#Assign title
plt.title ('Lidar data')
#Assign data
plt.imshow (lidar_clean)
#Set up radar plot to figure 2
radar_plot = plt.figure (2)
#Assign title
plt.title ('Radar data')
#Assign data
plt.imshow (radar_clean)
#Show plots
plt.show ()
#Display the results
def show_results ():
| show_graphs | identifier_name |
buffio_test.go | ()) // 4
br.UnreadByte() // 撤销吐出,即栈中弹出的a元素又放回来了
fmt.Println(br.Buffered()) // 5
tmp, _ = br.ReadByte()
fmt.Printf("%q\n", tmp) // 'a'
}
func TestReadRune1(t *testing.T) {
// ReadRune读取一个utf-8编码的unicode码值
chinese := "中国人"
s := strings.NewReader(chinese)
br := bufio.NewReader(s)
tmp, _, err := br.ReadRune()
if err != nil {
panic(err)
}
fmt.Printf("%q\n", tmp) // '中'
}
func TestUnReadRune1(t *testing.T) {
chinese := "中国人"
s := strings.NewReader(chinese)
br := bufio.NewReader(s)
tmp, _, err := br.ReadRune()
if err != nil {
panic(err)
}
fmt.Printf("%q\n", tmp) // '中'
br.UnreadRune()
tmp, _, err = br.ReadRune()
if err != nil {
panic(err)
}
fmt.Printf("%q\n", tmp) // '中'
}
func TestReadLine1(t *testing.T) {
// ReadLine 是一个低水平的行读取原语，大多数情况下，应该使用
// ReadBytes('\n') 或 ReadString('\n')，或者使用一个 Scanner。
//
// ReadLine 通过调用 ReadSlice 方法实现，返回的也是缓存的切片。用于
// 读取一行数据，不包括行尾标记（\n 或 \r\n）。
//
// 只要能读出数据，err 就为 nil。如果没有数据可读，则 isPrefix 返回
// false，err 返回 io.EOF。
//
// 如果找到行尾标记，则返回查找结果，isPrefix 返回 false。
// 如果未找到行尾标记，则：
// 1、缓存不满，则将缓存填满后再次查找。
// 2、缓存是满的，则返回整个缓存，isPrefix 返回 true。
//
// 整个数据尾部“有一个换行标记”和“没有换行标记”的读取结果是一样。
//
// 如果 ReadLine 读取到换行标记，则调用 UnreadByte 撤销的是换行标记，
// 而不是返回的数据。
// func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)
s := strings.NewReader("123\nzzz")
br := bufio.NewReader(s)
for line, isPrefix, err := []byte{0}, false, error(nil); len(line) > 0 && err == nil; {
line, isPrefix, err = br.ReadLine()
fmt.Printf("%q %t %v\n", line, isPrefix, err)
/*
"123" false <nil>
"zzz" false <nil>
"" false EOF
*/
}
}
func TestReadSlice1(t *testing.T) {
// ReadSlice 在 b 中查找 delim 并返回 delim 及其之前的所有数据。
// 该操作会读出数据，返回的切片是已读出的数据的引用，切片中的数据
// 在下一次读取操作之前是有效的。
//
// 如果找到 delim，则返回查找结果，err 返回 nil。
// 如果未找到 delim，则：
// 1、缓存不满，则将缓存填满后再次查找。
// 2、缓存是满的，则返回整个缓存，err 返回 ErrBufferFull。
//
// 如果未找到 delim 且遇到错误（通常是 io.EOF），则返回缓存中的所
// 有数据和遇到的错误。
//
// 因为返回的数据有可能被下一次的读写操作修改，所以大多数操作应该
// 使用 ReadBytes 或 ReadString，它们返回的是数据的拷贝。
// func (b *Reader) ReadSlice(delim byte) (line []byte, err error)
s := strings.NewReader("ABC DEF GHI")
br := bufio.NewReader(s)
w, err := br.ReadSlice(' ')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", w) // "ABC "
w, err = br.ReadSlice(' ')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", w) // "DEF "
w, err = br.ReadSlice(' ')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", w) // panic: EOF
}
func TestReadBytes1(t *testing.T) {
// ReadBytes 功能同 ReadSlice，只不过返回的是缓存的拷贝。
// func (b *Reader) ReadBytes(delim byte) (line []byte, err error)
s := strings.NewReader("ABC,EFG,HIJ")
br := bufio.NewReader(s)
line, err := br.ReadBytes(',')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", line) // "ABC,"
line, err = br.ReadBytes(',')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", line) // "EFG,"
line, err = br.ReadBytes(',')
if err != nil {
panic(err) // panic: EOF
}
fmt.Printf("%q\n", line)
}
func TestReadString1(t *testing.T) {
// ReadString 功能同 ReadBytes，只不过返回的是字符串。
// func (b *Reader) ReadString(delim byte) (line string, err error)
s := strings.NewReader("你好,我是卡牌")
br := bufio.NewReader(s)
line, err := br.ReadString(',')
if err != nil {
panic(err)
}
fmt.Printf("%s\n", line) // 你好,
line, err = br.ReadString(',')
if err != nil {
panic(err) // panic: EOF
}
fmt.Printf("%s\n", line)
}
// bufio.Reader的WriteTo()和 bufio.Writer的ReadFrom()
// WriteTo方法实现了io.WriterTo接口。
// func (b *Reader) WriteTo(w io.Writer) (n int64, err error)
func TestWriteTo1(t *testing.T) {
b := bytes.NewBuffer(make([]byte, 0))
s := strings.NewReader("ABCDEFG")
br := bufio.NewReader(s)
br.WriteTo(b)
fmt.Printf("%s\n", b.String()) // ABCDEFG
fmt.Printf("%q\n", b) // "ABCDEFG"
fmt.Println(string(65)) // A
}
// ReadFrom实现了io.ReaderFrom接口。
// func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)
// ReadFrom无需使用Flush
func TestReadFrom1(t *testing.T) {
s := strings.NewReader("hello world")
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
bw.ReadFrom(s)
fmt.Println(b)
}
//go test -run=buffio_test.go -bench="BenchmarkReadFrom1" -benchtime="3s" -cpuprofile cpu.out
// linux 是 -bench=.
func BenchmarkReadFrom1(b *testing.B) {
b.ReportAllocs()
b.ResetTimer()
for idx := 0; idx < b.N; idx++ {
s := strings.NewReader("hello world")
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
bw.ReadFrom(s)
}
b.StopTimer()
}
// Writer实现了为io.Writer接口对象提供缓冲。
// 如果在向一个Writer类型值写入时遇到了错误，
// 该对象将不再接受任何数据，返回该错误
// 数据都写入后，调用者有义务调用Flush方法,
// 保证所有的数据都交给了下层的io.Writer。
func TestNewWriter1(t *testing.T) {
// NewWriter创建一个具有默认大小缓冲、写入w的*Writer。 相当于 NewWriterSize(wr, 4096)
// func NewWriter(w io.Writer) *Writer
// Buffered()返回缓冲中已使用的字节数。
// func (b *Writer) Buffered() int
// Available()返回缓冲中还有多少字节未使用。
// func (b *Writer) Available() int
// Reset丢弃缓冲中的数据，清除任何错误，将b重设为将其输出写入w。
// func (b *Writer) Reset(w io.Writer)
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
fmt.Println(bw.Available(), bw.Buffered()) // 4096 0
bw.WriteString("card")
fmt.Println(bw.Available(), bw.Buffered()) // 4092 4
bw.Reset(b)
fmt.Println(bw.Available(), bw.Buffered()) // 4096 0
}
func TestWrite1(t *testing.T) {
// Write 将 p 中的数据写入 b 中，返回写入的字节数
// 如果写入的字节数小于 p 的长度，则返回一个错误信息
// func (b *Writer) Write(p []byte) (nn int, err error)
// Flush 将缓存中的数据提交到底层的 io.Writer 中
// func (b *Writer) Flush() error
p := [...]byte{'a', 'b', 'c'}
| b := bytes.N | identifier_name | |
buffio_test.go | s %v %v\n", b[:n], n, err) // 0 EOF
}
func TestBuffered1(t *testing.T) {
// 返回可以从缓存中读取的字节数
// func (b *Reader) Buffered() int { return b.w - b.r }
s := strings.NewReader("123456789")
br := bufio.NewReader(s)
b := make([]byte, 3)
br.Read(b)
fmt.Println(br.Buffered()) // 6
br.Read(b)
fmt.Println(br.Buffered()) // 3
}
func TestReadByte1(t *testing.T) {
// ReadByte读取并返回一个字节。如果没有可用的数据，会返回错误。
// func (b *Reader) ReadByte() (c byte, err error)
origin := "abcd"
s := strings.NewReader(origin)
br := bufio.NewReader(s)
// 第一次读取
tmp, err := br.ReadByte()
if err != nil {
panic(err)
}
fmt.Printf("%q\n", tmp) // 'a'
// Buffered returns the number of bytes that can be read from the current buffer.
fmt.Println(br.Buffered()) // 3
for i := 0; i < len(origin); i++ {
tmp, err = br.ReadByte()
if err != nil {
// panic: EOF 因为已经读取了1个字符 缓存中只剩下3个
// 所以在读取第4个字符报错EOF
panic(err)
}
}
}
func TestUnreadByte1(t *testing.T) {
// 撤消最后读出的字节
s := strings.NewReader("abcde")
br := bufio.NewReader(s)
tmp, _ := br.ReadByte()
fmt.Printf("%q\n", tmp) // 'a'
fmt.Println(br.Buffered()) // 4
br.UnreadByte() // 撤销吐出,即栈中弹出的a元素又放回来了
fmt.Println(br.Buffered()) // 5
tmp, _ = br.ReadByte()
fmt.Printf("%q\n", tmp) // 'a'
}
func TestReadRune1(t *testing.T) {
// ReadRune读取一个utf-8编码的unicode码值
chinese := "中国人"
s := strings.NewReader(chinese)
br := bufio.NewReader(s)
tmp, _, err := br.ReadRune()
if err != nil {
panic(err)
}
fmt.Printf("%q\n", tmp) // '中'
}
func TestUnReadRune1(t *testing.T) {
chinese := "中国人"
s := strings.NewReader(chinese)
br := bufio.NewReader(s)
tmp, _, err := br.ReadRune()
if err != nil {
panic(err)
}
fmt.Printf("%q\n", tmp) // '中'
br.UnreadRune()
tmp, _, err = br.ReadRune()
if err != nil {
panic(err)
}
fmt.Printf("%q\n", tmp) // '中'
}
func TestReadLine1(t *testing.T) {
// ReadLine 是一个低水平的行读取原语，大多数情况下，应该使用
// ReadBytes('\n') 或 ReadString('\n')，或者使用一个 Scanner。
//
// ReadLine 通过调用 ReadSlice 方法实现，返回的也是缓存的切片。用于
// 读取一行数据，不包括行尾标记（\n 或 \r\n）。
//
// 只要能读出数据，err 就为 nil。如果没有数据可读，则 isPrefix 返回
// false，err 返回 io.EOF。
//
// 如果找到行尾标记，则返回查找结果，isPrefix 返回 false。
// 如果未找到行尾标记，则： | // 1、缓存不满，则将缓存填满后再次查找。
// 2、缓存是满的，则返回整个缓存，isPrefix 返回 true。
//
// 整个数据尾部“有一个换行标记”和“没有换行标记”的读取结果是一样。
//
// 如果 ReadLine 读取到换行标记，则调用 UnreadByte 撤销的是换行标记，
// 而不是返回的数据。
// func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)
s := strings.NewReader("123\nzzz")
br := bufio.NewReader(s)
for line, isPrefix, err := []byte{0}, false, error(nil); len(line) > 0 && err == nil; {
line, isPrefix, err = br.ReadLine()
fmt.Printf("%q %t %v\n", line, isPrefix, err)
/*
"123" false <nil>
"zzz" false <nil>
"" false EOF
*/
}
}
func TestReadSlice1(t *testing.T) {
// ReadSlice 在 b 中查找 delim 并返回 delim 及其之前的所有数据。
// 该操作会读出数据，返回的切片是已读出的数据的引用，切片中的数据
// 在下一次读取操作之前是有效的。
//
// 如果找到 delim，则返回查找结果，err 返回 nil。
// 如果未找到 delim，则：
// 1、缓存不满，则将缓存填满后再次查找。
// 2、缓存是满的，则返回整个缓存，err 返回 ErrBufferFull。
//
// 如果未找到 delim 且遇到错误（通常是 io.EOF），则返回缓存中的所
// 有数据和遇到的错误。
//
// 因为返回的数据有可能被下一次的读写操作修改，所以大多数操作应该
// 使用 ReadBytes 或 ReadString，它们返回的是数据的拷贝。
// func (b *Reader) ReadSlice(delim byte) (line []byte, err error)
s := strings.NewReader("ABC DEF GHI")
br := bufio.NewReader(s)
w, err := br.ReadSlice(' ')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", w) // "ABC "
w, err = br.ReadSlice(' ')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", w) // "DEF "
w, err = br.ReadSlice(' ')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", w) // panic: EOF
}
func TestReadBytes1(t *testing.T) {
// ReadBytes 功能同 ReadSlice，只不过返回的是缓存的拷贝。
// func (b *Reader) ReadBytes(delim byte) (line []byte, err error)
s := strings.NewReader("ABC,EFG,HIJ")
br := bufio.NewReader(s)
line, err := br.ReadBytes(',')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", line) // "ABC,"
line, err = br.ReadBytes(',')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", line) // "EFG,"
line, err = br.ReadBytes(',')
if err != nil {
panic(err) // panic: EOF
}
fmt.Printf("%q\n", line)
}
func TestReadString1(t *testing.T) {
// ReadString 功能同 ReadBytes，只不过返回的是字符串。
// func (b *Reader) ReadString(delim byte) (line string, err error)
s := strings.NewReader("你好,我是卡牌")
br := bufio.NewReader(s)
line, err := br.ReadString(',')
if err != nil {
panic(err)
}
fmt.Printf("%s\n", line) // 你好,
line, err = br.ReadString(',')
if err != nil {
panic(err) // panic: EOF
}
fmt.Printf("%s\n", line)
}
// bufio.Reader的WriteTo()和 bufio.Writer的ReadFrom()
// WriteTo方法实现了io.WriterTo接口。
// func (b *Reader) WriteTo(w io.Writer) (n int64, err error)
func TestWriteTo1(t *testing.T) {
b := bytes.NewBuffer(make([]byte, 0))
s := strings.NewReader("ABCDEFG")
br := bufio.NewReader(s)
br.WriteTo(b)
fmt.Printf("%s\n", b.String()) // ABCDEFG
fmt.Printf("%q\n", b) // "ABCDEFG"
fmt.Println(string(65)) // A
}
// ReadFrom实现了io.ReaderFrom接口。
// func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)
// ReadFrom无需使用Flush
func TestReadFrom1(t *testing.T) {
s := strings.NewReader("hello world")
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
bw.ReadFrom(s)
fmt.Println(b)
}
//go test -run=buffio_test.go -bench="BenchmarkReadFrom1" -benchtime="3s" -cpuprofile cpu.out
// linux 是 -bench=.
func BenchmarkReadFrom1(b *testing.B) {
b.ReportAllocs()
b.ResetTimer()
for idx := 0; idx < b.N; idx++ {
s := strings.NewReader("hello world")
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
bw.ReadFrom(s)
}
b.StopTimer()
}
// Writer实现了为io.Writer接口对象提供缓冲。
// 如果在向一个Writer类型值写入时遇到了错误，
// 该对象 | random_line_split | |
buffio_test.go | ([]byte, 3)
br.Read(b)
fmt.Println(br.Buffered()) // 6
br.Read(b)
fmt.Println(br.Buffered()) // 3
}
func TestReadByte1(t *testing.T) {
// ReadByte读取并返回一个字节。如果没有可用的数据，会返回错误。
// func (b *Reader) ReadByte() (c byte, err error)
origin := "abcd"
s := strings.NewReader(origin)
br := bufio.NewReader(s)
// 第一次读取
tmp, err := br.ReadByte()
if err != nil {
panic(err)
}
fmt.Printf("%q\n", tmp) // 'a'
// Buffered returns the number of bytes that can be read from the current buffer.
fmt.Println(br.Buffered()) // 3
for i := 0; i < len(origin); i++ {
tmp, err = br.ReadByte()
if err != nil {
// panic: EOF 因为已经读取了1个字符 缓存中只剩下3个
// 所以在读取第4个字符报错EOF
panic(err)
}
}
}
func TestUnreadByte1(t *testing.T) {
// 撤消最后读出的字节
s := strings.NewReader("abcde")
br := bufio.NewReader(s)
tmp, _ := br.ReadByte()
fmt.Printf("%q\n", tmp) // 'a'
fmt.Println(br.Buffered()) // 4
br.UnreadByte() // 撤销吐出,即栈中弹出的a元素又放回来了
fmt.Println(br.Buffered()) // 5
tmp, _ = br.ReadByte()
fmt.Printf("%q\n", tmp) // 'a'
}
func TestReadRune1(t *testing.T) {
// ReadRune读取一个utf-8编码的unicode码值
chinese := "中国人"
s := strings.NewReader(chinese)
br := bufio.NewReader(s)
tmp, _, err := br.ReadRune()
if err != nil {
panic(err)
}
fmt.Printf("%q\n", tmp) // '中'
}
func TestUnReadRune1(t *testing.T) {
chinese := "中国人"
s := strings.NewReader(chinese)
br := bufio.NewReader(s)
tmp, _, err := br.ReadRune()
if err != nil {
panic(err)
}
fmt.Printf("%q\n", tmp) // '中'
br.UnreadRune()
tmp, _, err = br.ReadRune()
if err != nil {
panic(err)
}
fmt.Printf("%q\n", tmp) // '中'
}
func TestReadLine1(t *testing.T) {
// ReadLine 是一个低水平的行读取原语，大多数情况下，应该使用
// ReadBytes('\n') 或 ReadString('\n')，或者使用一个 Scanner。
//
// ReadLine 通过调用 ReadSlice 方法实现，返回的也是缓存的切片。用于
// 读取一行数据，不包括行尾标记（\n 或 \r\n）。
//
// 只要能读出数据，err 就为 nil。如果没有数据可读，则 isPrefix 返回
// false，err 返回 io.EOF。
//
// 如果找到行尾标记，则返回查找结果，isPrefix 返回 false。
// 如果未找到行尾标记，则：
// 1、缓存不满，则将缓存填满后再次查找。
// 2、缓存是满的，则返回整个缓存，isPrefix 返回 true。
//
// 整个数据尾部“有一个换行标记”和“没有换行标记”的读取结果是一样。
//
// 如果 ReadLine 读取到换行标记，则调用 UnreadByte 撤销的是换行标记，
// 而不是返回的数据。
// func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)
s := strings.NewReader("123\nzzz")
br := bufio.NewReader(s)
for line, isPrefix, err := []byte{0}, false, error(nil); len(line) > 0 && err == nil; {
line, isPrefix, err = br.ReadLine()
fmt.Printf("%q %t %v\n", line, isPrefix, err)
/*
"123" false <nil>
"zzz" false <nil>
"" false EOF
*/
}
}
func TestReadSlice1(t *testing.T) {
// ReadSlice 在 b 中查找 delim 并返回 delim 及其之前的所有数据。
// 该操作会读出数据，返回的切片是已读出的数据的引用，切片中的数据
// 在下一次读取操作之前是有效的。
//
// 如果找到 delim，则返回查找结果，err 返回 nil。
// 如果未找到 delim，则：
// 1、缓存不满，则将缓存填满后再次查找。
// 2、缓存是满的，则返回整个缓存，err 返回 ErrBufferFull。
//
// 如果未找到 delim 且遇到错误（通常是 io.EOF），则返回缓存中的所
// 有数据和遇到的错误。
//
// 因为返回的数据有可能被下一次的读写操作修改，所以大多数操作应该
// 使用 ReadBytes 或 ReadString，它们返回的是数据的拷贝。
// func (b *Reader) ReadSlice(delim byte) (line []byte, err error)
s := strings.NewReader("ABC DEF GHI")
br := bufio.NewReader(s)
w, err := br.ReadSlice(' ')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", w) // "ABC "
w, err = br.ReadSlice(' ')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", w) // "DEF "
w, err = br.ReadSlice(' ')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", w) // panic: EOF
}
func TestReadBytes1(t *testing.T) {
// ReadBytes 功能同 ReadSlice，只不过返回的是缓存的拷贝。
// func (b *Reader) ReadBytes(delim byte) (line []byte, err error)
s := strings.NewReader("ABC,EFG,HIJ")
br := bufio.NewReader(s)
line, err := br.ReadBytes(',')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", line) // "ABC,"
line, err = br.ReadBytes(',')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", line) // "EFG,"
line, err = br.ReadBytes(',')
if err != nil {
panic(err) // panic: EOF
}
fmt.Printf("%q\n", line)
}
func TestReadString1(t *testing.T) {
// ReadString 功能同 ReadBytes，只不过返回的是字符串。
// func (b *Reader) ReadString(delim byte) (line string, err error)
s := strings.NewReader("你好,我是卡牌")
br := bufio.NewReader(s)
line, err := br.ReadString(',')
if err != nil {
panic(err)
}
fmt.Printf("%s\n", line) // 你好,
line, err = br.ReadString(',')
if err != nil {
panic(err) // panic: EOF
}
fmt.Printf("%s\n", line)
}
// bufio.Reader的WriteTo()和 bufio.Writer的ReadFrom()
// WriteTo方法实现了io.WriterTo接口。
// func (b *Reader) WriteTo(w io.Writer) (n int64, err error)
func TestWriteTo1(t *testing.T) {
b := bytes.NewBuffer(make([]byte, 0))
s := strings.NewReader("ABCDEFG")
br := bufio.NewReader(s)
br.WriteTo(b)
fmt.Printf("%s\n", b.String()) // ABCDEFG
fmt.Printf("%q\n", b) // "ABCDEFG"
fmt.Println(string(65)) // A
}
// ReadFrom实现了io.ReaderFrom接口。
// func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)
// ReadFrom无需使用Flush
func TestReadFrom1(t *testing.T) {
s := strings.NewReader("hello world")
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
bw.ReadFrom(s)
fmt.Println(b)
}
//go test -run=buffio_test.go -bench="BenchmarkReadFrom1" -benchtime="3s" -cpuprofile cpu.out
// linux 是 -bench=.
func BenchmarkReadFrom1(b *testing.B) {
b.ReportAllocs()
b.ResetTimer()
for idx := 0; idx < b.N; idx++ {
s := strings.NewReader("hello world")
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
bw.ReadFrom(s)
}
b.StopTimer()
}
// Writer实现了为io.Writer接口对象提供缓冲。
// 如果在向一个Writer类型值写入时遇到了错误，
// 该对象将不再接受任何数据，返回该错误
// 数据都写入后，调用者有义务调用Flush方法,
// 保证所有的数据都交给了下层的io.Writer。
func TestNewWriter1(t *testing.T) {
// NewWriter创建一个具有默认大小缓冲、写入w的*Writer。 相当于 NewWriterSize(w | r, 4096)
// func | conditional_block | |
buffio_test.go | err := []byte{0}, false, error(nil); len(line) > 0 && err == nil; {
line, isPrefix, err = br.ReadLine()
fmt.Printf("%q %t %v\n", line, isPrefix, err)
/*
"123" false <nil>
"zzz" false <nil>
"" false EOF
*/
}
}
func TestReadSlice1(t *testing.T) {
// ReadSlice 在 b 中查找 delim 并返回 delim 及其之前的所有数据。
// 该操作会读出数据，返回的切片是已读出的数据的引用，切片中的数据
// 在下一次读取操作之前是有效的。
//
// 如果找到 delim，则返回查找结果，err 返回 nil。
// 如果未找到 delim，则：
// 1、缓存不满，则将缓存填满后再次查找。
// 2、缓存是满的，则返回整个缓存，err 返回 ErrBufferFull。
//
// 如果未找到 delim 且遇到错误（通常是 io.EOF），则返回缓存中的所
// 有数据和遇到的错误。
//
// 因为返回的数据有可能被下一次的读写操作修改，所以大多数操作应该
// 使用 ReadBytes 或 ReadString，它们返回的是数据的拷贝。
// func (b *Reader) ReadSlice(delim byte) (line []byte, err error)
s := strings.NewReader("ABC DEF GHI")
br := bufio.NewReader(s)
w, err := br.ReadSlice(' ')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", w) // "ABC "
w, err = br.ReadSlice(' ')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", w) // "DEF "
w, err = br.ReadSlice(' ')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", w) // panic: EOF
}
func TestReadBytes1(t *testing.T) {
// ReadBytes 功能同 ReadSlice，只不过返回的是缓存的拷贝。
// func (b *Reader) ReadBytes(delim byte) (line []byte, err error)
s := strings.NewReader("ABC,EFG,HIJ")
br := bufio.NewReader(s)
line, err := br.ReadBytes(',')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", line) // "ABC,"
line, err = br.ReadBytes(',')
if err != nil {
panic(err)
}
fmt.Printf("%q\n", line) // "EFG,"
line, err = br.ReadBytes(',')
if err != nil {
panic(err) // panic: EOF
}
fmt.Printf("%q\n", line)
}
func TestReadString1(t *testing.T) {
// ReadString 功能同 ReadBytes，只不过返回的是字符串。
// func (b *Reader) ReadString(delim byte) (line string, err error)
s := strings.NewReader("你好,我是卡牌")
br := bufio.NewReader(s)
line, err := br.ReadString(',')
if err != nil {
panic(err)
}
fmt.Printf("%s\n", line) // 你好,
line, err = br.ReadString(',')
if err != nil {
panic(err) // panic: EOF
}
fmt.Printf("%s\n", line)
}
// bufio.Reader的WriteTo()和 bufio.Writer的ReadFrom()
// WriteTo方法实现了io.WriterTo接口。
// func (b *Reader) WriteTo(w io.Writer) (n int64, err error)
func TestWriteTo1(t *testing.T) {
b := bytes.NewBuffer(make([]byte, 0))
s := strings.NewReader("ABCDEFG")
br := bufio.NewReader(s)
br.WriteTo(b)
fmt.Printf("%s\n", b.String()) // ABCDEFG
fmt.Printf("%q\n", b) // "ABCDEFG"
fmt.Println(string(65)) // A
}
// ReadFrom实现了io.ReaderFrom接口。
// func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)
// ReadFrom无需使用Flush
func TestReadFrom1(t *testing.T) {
s := strings.NewReader("hello world")
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
bw.ReadFrom(s)
fmt.Println(b)
}
//go test -run=buffio_test.go -bench="BenchmarkReadFrom1" -benchtime="3s" -cpuprofile cpu.out
// linux 是 -bench=.
func BenchmarkReadFrom1(b *testing.B) {
b.ReportAllocs()
b.ResetTimer()
for idx := 0; idx < b.N; idx++ {
s := strings.NewReader("hello world")
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
bw.ReadFrom(s)
}
b.StopTimer()
}
// Writer实现了为io.Writer接口对象提供缓冲。
// 如果在向一个Writer类型值写入时遇到了错误，
// 该对象将不再接受任何数据，返回该错误
// 数据都写入后，调用者有义务调用Flush方法,
// 保证所有的数据都交给了下层的io.Writer。
func TestNewWriter1(t *testing.T) {
// NewWriter创建一个具有默认大小缓冲、写入w的*Writer。 相当于 NewWriterSize(wr, 4096)
// func NewWriter(w io.Writer) *Writer
// Buffered()返回缓冲中已使用的字节数。
// func (b *Writer) Buffered() int
// Available()返回缓冲中还有多少字节未使用。
// func (b *Writer) Available() int
// Reset丢弃缓冲中的数据，清除任何错误，将b重设为将其输出写入w。
// func (b *Writer) Reset(w io.Writer)
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
fmt.Println(bw.Available(), bw.Buffered()) // 4096 0
bw.WriteString("card")
fmt.Println(bw.Available(), bw.Buffered()) // 4092 4
bw.Reset(b)
fmt.Println(bw.Available(), bw.Buffered()) // 4096 0
}
func TestWrite1(t *testing.T) {
// Write 将 p 中的数据写入 b 中，返回写入的字节数
// 如果写入的字节数小于 p 的长度，则返回一个错误信息
// func (b *Writer) Write(p []byte) (nn int, err error)
// Flush 将缓存中的数据提交到底层的 io.Writer 中
// func (b *Writer) Flush() error
p := [...]byte{'a', 'b', 'c'}
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
bw.Write(p[:])
bw.Flush()
fmt.Printf("%q\n", b) //"abc"
}
func TestWriteString1(t *testing.T) {
// WriteString 同 Write，只不过写入的是字符串
// func (b *Writer) WriteString(s string) (int, error)
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
bw.WriteString("hello world")
bw.Flush()
fmt.Printf("%s\n", b) //hello world
}
func TestWriteByte1(t *testing.T) {
// WriteByte写入单个字节。
// func (b *Writer) WriteByte(c byte) error
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
bw.WriteByte('c')
bw.Flush()
fmt.Println(b)
}
func TestWriteRune1(t *testing.T) {
// WriteRune写入一个unicode码值（的utf-8编码），返回写入的字节数和可能的错误。
// func (b *Writer) WriteRune(r rune) (size int, err error)
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
size, err := bw.WriteRune('周')
if err != nil {
panic(err)
}
fmt.Println(size) // 3
bw.Flush()
fmt.Println(b) // 周
}
func TestReadWriter1(t *testing.T) {
// ReadWriter类型保管了指向Reader和Writer类型的指针
// 实现了io.ReadWriter接口。
// NewReadWriter 生成bufio.ReadWriter对象
// func NewReadWriter(r *Reader, w *Writer) *ReadWriter
b := bytes.NewBuffer(make([]byte, 0))
bw := bufio.NewWriter(b)
s := strings.NewReader("hello world")
br := bufio.NewReade | r(s)
rw := bufio.NewReadWriter(br, bw)
word, err := rw.ReadString(' ')
if err != nil {
panic(err)
}
fmt.Printf("%s\n", word) // hello
_, err = rw.WriteString(",I'm coming")
if err != nil {
panic(err)
}
rw.Flush()
fmt.Println(b)
}
func TestNewScanner1(t *testing.T) {
// Scanner 提供了一个方便的接口来读取数据，例如遍历多行文本中的行。Scan 方法会通过
// 一个“匹配函数”读取数据中符合要求的部分，跳过不符合要求的部分。“匹配函数”由调 | identifier_body | |
particle.rs | ];
}
#[rustfmt::skip]
const PARTICLE_TEXTURE_PIXELS: [u8; 64] = [
0, 0, 1, 1, 1, 1, 0, 0,
0, 1, 1, 1, 1, 1, 1, 0,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
0, 1, 1, 1, 1, 1, 1, 0,
0, 0, 1, 1, 1, 1, 0, 0,
];
pub struct ParticlePipeline {
pipeline: wgpu::RenderPipeline,
bind_group_layouts: Vec<wgpu::BindGroupLayout>,
vertex_buffer: wgpu::Buffer,
sampler: wgpu::Sampler,
textures: Vec<wgpu::Texture>,
texture_views: Vec<wgpu::TextureView>,
bind_group: wgpu::BindGroup,
}
impl ParticlePipeline {
pub fn new(
device: &wgpu::Device,
queue: &wgpu::Queue,
compiler: &mut shaderc::Compiler,
sample_count: u32,
palette: &Palette,
) -> ParticlePipeline {
let (pipeline, bind_group_layouts) =
ParticlePipeline::create(device, compiler, &[], sample_count);
use wgpu::util::DeviceExt as _;
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: None,
contents: unsafe { any_slice_as_bytes(&VERTICES) },
usage: wgpu::BufferUsage::VERTEX,
});
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("particle sampler"),
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: wgpu::FilterMode::Nearest,
min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::FilterMode::Linear,
lod_min_clamp: -1000.0,
lod_max_clamp: 1000.0,
compare: None,
anisotropy_clamp: NonZeroU8::new(16),
border_color: None,
});
let textures: Vec<wgpu::Texture> = (0..256)
.map(|i| {
let mut pixels = PARTICLE_TEXTURE_PIXELS;
// set up palette translation
for pix in pixels.iter_mut() {
if *pix == 0 | else {
*pix *= i as u8;
}
}
let (diffuse_data, _) = palette.translate(&pixels);
create_texture(
device,
queue,
Some(&format!("particle texture {}", i)),
8,
8,
&TextureData::Diffuse(diffuse_data),
)
})
.collect();
let texture_views: Vec<wgpu::TextureView> = textures
.iter()
.map(|t| t.create_view(&Default::default()))
.collect();
let texture_view_refs = texture_views.iter().collect::<Vec<_>>();
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("particle bind group"),
layout: &bind_group_layouts[0],
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Sampler(&sampler),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureViewArray(&texture_view_refs[..]),
},
],
});
ParticlePipeline {
pipeline,
bind_group_layouts,
sampler,
textures,
texture_views,
bind_group,
vertex_buffer,
}
}
pub fn rebuild(
&mut self,
device: &wgpu::Device,
compiler: &mut shaderc::Compiler,
sample_count: u32,
) {
let layout_refs: Vec<_> = self.bind_group_layouts.iter().collect();
self.pipeline = ParticlePipeline::recreate(device, compiler, &layout_refs, sample_count);
}
pub fn pipeline(&self) -> &wgpu::RenderPipeline {
&self.pipeline
}
pub fn bind_group_layouts(&self) -> &[wgpu::BindGroupLayout] {
&self.bind_group_layouts
}
pub fn vertex_buffer(&self) -> &wgpu::Buffer {
&self.vertex_buffer
}
pub fn record_draw<'a, 'b, P>(
&'a self,
pass: &mut wgpu::RenderPass<'a>,
bump: &'a Bump,
camera: &Camera,
particles: P,
) where
P: Iterator<Item = &'b Particle>,
{
use PushConstantUpdate::*;
pass.set_pipeline(self.pipeline());
pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
pass.set_bind_group(0, &self.bind_group, &[]);
// face toward camera
let Angles { pitch, yaw, roll } = camera.angles();
let rotation = Angles {
pitch: -pitch,
yaw: -yaw,
roll: -roll,
}
.mat4_wgpu();
for particle in particles {
let q_origin = particle.origin();
let translation =
Matrix4::from_translation([-q_origin.y, q_origin.z, -q_origin.x].into());
Self::set_push_constants(
pass,
Update(bump.alloc(VertexPushConstants {
transform: camera.view_projection() * translation * rotation,
})),
Retain,
Update(bump.alloc(FragmentPushConstants {
color: particle.color() as u32,
})),
);
pass.draw(0..6, 0..1);
}
}
}
#[derive(Copy, Clone, Debug)]
pub struct VertexPushConstants {
pub transform: Matrix4<f32>,
}
#[derive(Copy, Clone, Debug)]
pub struct FragmentPushConstants {
pub color: u32,
}
const BIND_GROUP_LAYOUT_ENTRIES: &[wgpu::BindGroupLayoutEntry] = &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::Sampler {
filtering: true,
comparison: false,
},
count: None,
},
// per-index texture array
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::Texture {
view_dimension: wgpu::TextureViewDimension::D2,
sample_type: wgpu::TextureSampleType::Float { filterable: true },
multisampled: false,
},
count: NonZeroU32::new(256),
},
];
lazy_static! {
static ref VERTEX_ATTRIBUTES: [[wgpu::VertexAttribute; 2]; 2] = [
wgpu::vertex_attr_array![
// position
0 => Float32x3,
// texcoord
1 => Float32x2,
],
wgpu::vertex_attr_array![
// instance position
2 => Float32x3,
// color index
3 => Uint32,
]
];
}
impl Pipeline for ParticlePipeline {
type VertexPushConstants = VertexPushConstants;
type SharedPushConstants = ();
type FragmentPushConstants = FragmentPushConstants;
fn name() -> &'static str {
"particle"
}
fn vertex_shader() -> &'static str {
include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/shaders/particle.vert"
))
}
fn fragment_shader() -> &'static str {
include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/shaders/particle.frag"
))
}
// NOTE: if any of the binding indices are changed, they must also be changed in
// the corresponding shaders and the BindGroupLayout generation functions.
fn bind_group_layout_descriptors() -> Vec<wgpu::BindGroupLayoutDescriptor<'static>> {
vec![
// group 0
wgpu::BindGroupLayoutDescriptor {
label: Some("particle bind group layout"),
entries: BIND_GROUP_LAYOUT_ENTRIES,
},
]
}
fn primitive_state() -> wgpu::PrimitiveState {
WorldPipelineBase::primitive_state()
}
fn color_target_states() -> Vec<wgpu::ColorTargetState> {
WorldPipelineBase::color_target_states()
}
fn depth_stencil_state() -> Option<wgpu::DepthStencilState> {
let mut desc = WorldPipelineBase::depth_stencil_state().unwrap();
desc.depth_write_enabled = false;
Some(desc)
| {
*pix = 0xFF;
} | conditional_block |
particle.rs | ];
}
#[rustfmt::skip]
const PARTICLE_TEXTURE_PIXELS: [u8; 64] = [
0, 0, 1, 1, 1, 1, 0, 0,
0, 1, 1, 1, 1, 1, 1, 0,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
0, 1, 1, 1, 1, 1, 1, 0,
0, 0, 1, 1, 1, 1, 0, 0,
];
pub struct ParticlePipeline {
pipeline: wgpu::RenderPipeline,
bind_group_layouts: Vec<wgpu::BindGroupLayout>,
vertex_buffer: wgpu::Buffer,
sampler: wgpu::Sampler,
textures: Vec<wgpu::Texture>,
texture_views: Vec<wgpu::TextureView>,
bind_group: wgpu::BindGroup,
}
impl ParticlePipeline {
pub fn new(
device: &wgpu::Device,
queue: &wgpu::Queue,
compiler: &mut shaderc::Compiler,
sample_count: u32,
palette: &Palette,
) -> ParticlePipeline {
let (pipeline, bind_group_layouts) =
ParticlePipeline::create(device, compiler, &[], sample_count);
use wgpu::util::DeviceExt as _;
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: None,
contents: unsafe { any_slice_as_bytes(&VERTICES) },
usage: wgpu::BufferUsage::VERTEX,
});
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("particle sampler"),
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: wgpu::FilterMode::Nearest,
min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::FilterMode::Linear,
lod_min_clamp: -1000.0,
lod_max_clamp: 1000.0,
compare: None,
anisotropy_clamp: NonZeroU8::new(16),
border_color: None,
});
let textures: Vec<wgpu::Texture> = (0..256)
.map(|i| {
let mut pixels = PARTICLE_TEXTURE_PIXELS;
// set up palette translation
for pix in pixels.iter_mut() {
if *pix == 0 {
*pix = 0xFF;
} else {
*pix *= i as u8;
}
}
let (diffuse_data, _) = palette.translate(&pixels);
create_texture(
device,
queue,
Some(&format!("particle texture {}", i)),
8,
8,
&TextureData::Diffuse(diffuse_data),
)
})
.collect();
let texture_views: Vec<wgpu::TextureView> = textures
.iter()
.map(|t| t.create_view(&Default::default()))
.collect();
let texture_view_refs = texture_views.iter().collect::<Vec<_>>();
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("particle bind group"),
layout: &bind_group_layouts[0],
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Sampler(&sampler),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureViewArray(&texture_view_refs[..]),
},
],
});
ParticlePipeline {
pipeline,
bind_group_layouts,
sampler,
textures,
texture_views,
bind_group,
vertex_buffer,
}
}
pub fn rebuild(
&mut self,
device: &wgpu::Device,
compiler: &mut shaderc::Compiler,
sample_count: u32,
) {
let layout_refs: Vec<_> = self.bind_group_layouts.iter().collect();
self.pipeline = ParticlePipeline::recreate(device, compiler, &layout_refs, sample_count);
}
pub fn | (&self) -> &wgpu::RenderPipeline {
&self.pipeline
}
pub fn bind_group_layouts(&self) -> &[wgpu::BindGroupLayout] {
&self.bind_group_layouts
}
pub fn vertex_buffer(&self) -> &wgpu::Buffer {
&self.vertex_buffer
}
pub fn record_draw<'a, 'b, P>(
&'a self,
pass: &mut wgpu::RenderPass<'a>,
bump: &'a Bump,
camera: &Camera,
particles: P,
) where
P: Iterator<Item = &'b Particle>,
{
use PushConstantUpdate::*;
pass.set_pipeline(self.pipeline());
pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
pass.set_bind_group(0, &self.bind_group, &[]);
// face toward camera
let Angles { pitch, yaw, roll } = camera.angles();
let rotation = Angles {
pitch: -pitch,
yaw: -yaw,
roll: -roll,
}
.mat4_wgpu();
for particle in particles {
let q_origin = particle.origin();
let translation =
Matrix4::from_translation([-q_origin.y, q_origin.z, -q_origin.x].into());
Self::set_push_constants(
pass,
Update(bump.alloc(VertexPushConstants {
transform: camera.view_projection() * translation * rotation,
})),
Retain,
Update(bump.alloc(FragmentPushConstants {
color: particle.color() as u32,
})),
);
pass.draw(0..6, 0..1);
}
}
}
#[derive(Copy, Clone, Debug)]
pub struct VertexPushConstants {
pub transform: Matrix4<f32>,
}
#[derive(Copy, Clone, Debug)]
pub struct FragmentPushConstants {
pub color: u32,
}
const BIND_GROUP_LAYOUT_ENTRIES: &[wgpu::BindGroupLayoutEntry] = &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::Sampler {
filtering: true,
comparison: false,
},
count: None,
},
// per-index texture array
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::Texture {
view_dimension: wgpu::TextureViewDimension::D2,
sample_type: wgpu::TextureSampleType::Float { filterable: true },
multisampled: false,
},
count: NonZeroU32::new(256),
},
];
lazy_static! {
static ref VERTEX_ATTRIBUTES: [[wgpu::VertexAttribute; 2]; 2] = [
wgpu::vertex_attr_array![
// position
0 => Float32x3,
// texcoord
1 => Float32x2,
],
wgpu::vertex_attr_array![
// instance position
2 => Float32x3,
// color index
3 => Uint32,
]
];
}
impl Pipeline for ParticlePipeline {
type VertexPushConstants = VertexPushConstants;
type SharedPushConstants = ();
type FragmentPushConstants = FragmentPushConstants;
fn name() -> &'static str {
"particle"
}
fn vertex_shader() -> &'static str {
include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/shaders/particle.vert"
))
}
fn fragment_shader() -> &'static str {
include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/shaders/particle.frag"
))
}
// NOTE: if any of the binding indices are changed, they must also be changed in
// the corresponding shaders and the BindGroupLayout generation functions.
fn bind_group_layout_descriptors() -> Vec<wgpu::BindGroupLayoutDescriptor<'static>> {
vec![
// group 0
wgpu::BindGroupLayoutDescriptor {
label: Some("particle bind group layout"),
entries: BIND_GROUP_LAYOUT_ENTRIES,
},
]
}
fn primitive_state() -> wgpu::PrimitiveState {
WorldPipelineBase::primitive_state()
}
fn color_target_states() -> Vec<wgpu::ColorTargetState> {
WorldPipelineBase::color_target_states()
}
fn depth_stencil_state() -> Option<wgpu::DepthStencilState> {
let mut desc = WorldPipelineBase::depth_stencil_state().unwrap();
desc.depth_write_enabled = false;
Some(desc)
| pipeline | identifier_name |
particle.rs | ];
}
#[rustfmt::skip]
const PARTICLE_TEXTURE_PIXELS: [u8; 64] = [
0, 0, 1, 1, 1, 1, 0, 0,
0, 1, 1, 1, 1, 1, 1, 0,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
0, 1, 1, 1, 1, 1, 1, 0,
0, 0, 1, 1, 1, 1, 0, 0,
];
pub struct ParticlePipeline {
pipeline: wgpu::RenderPipeline,
bind_group_layouts: Vec<wgpu::BindGroupLayout>,
vertex_buffer: wgpu::Buffer,
sampler: wgpu::Sampler,
textures: Vec<wgpu::Texture>,
texture_views: Vec<wgpu::TextureView>,
bind_group: wgpu::BindGroup,
}
impl ParticlePipeline {
pub fn new(
device: &wgpu::Device,
queue: &wgpu::Queue,
compiler: &mut shaderc::Compiler,
sample_count: u32,
palette: &Palette,
) -> ParticlePipeline {
let (pipeline, bind_group_layouts) =
ParticlePipeline::create(device, compiler, &[], sample_count);
use wgpu::util::DeviceExt as _;
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: None,
contents: unsafe { any_slice_as_bytes(&VERTICES) },
usage: wgpu::BufferUsage::VERTEX,
});
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("particle sampler"),
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: wgpu::FilterMode::Nearest,
min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::FilterMode::Linear,
lod_min_clamp: -1000.0,
lod_max_clamp: 1000.0,
compare: None,
anisotropy_clamp: NonZeroU8::new(16),
border_color: None,
});
let textures: Vec<wgpu::Texture> = (0..256)
.map(|i| {
let mut pixels = PARTICLE_TEXTURE_PIXELS;
// set up palette translation
for pix in pixels.iter_mut() {
if *pix == 0 {
*pix = 0xFF;
} else {
*pix *= i as u8;
}
}
let (diffuse_data, _) = palette.translate(&pixels);
create_texture(
device,
queue,
Some(&format!("particle texture {}", i)),
8,
8,
&TextureData::Diffuse(diffuse_data),
)
})
.collect();
let texture_views: Vec<wgpu::TextureView> = textures
.iter()
.map(|t| t.create_view(&Default::default()))
.collect();
let texture_view_refs = texture_views.iter().collect::<Vec<_>>();
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("particle bind group"),
layout: &bind_group_layouts[0],
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Sampler(&sampler),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureViewArray(&texture_view_refs[..]),
},
],
});
ParticlePipeline {
pipeline,
bind_group_layouts,
sampler,
textures,
texture_views,
bind_group,
vertex_buffer,
}
}
pub fn rebuild(
&mut self,
device: &wgpu::Device,
compiler: &mut shaderc::Compiler,
sample_count: u32,
) {
let layout_refs: Vec<_> = self.bind_group_layouts.iter().collect();
self.pipeline = ParticlePipeline::recreate(device, compiler, &layout_refs, sample_count);
}
pub fn pipeline(&self) -> &wgpu::RenderPipeline {
&self.pipeline
}
pub fn bind_group_layouts(&self) -> &[wgpu::BindGroupLayout] {
&self.bind_group_layouts
}
pub fn vertex_buffer(&self) -> &wgpu::Buffer {
&self.vertex_buffer
}
pub fn record_draw<'a, 'b, P>(
&'a self,
pass: &mut wgpu::RenderPass<'a>,
bump: &'a Bump,
camera: &Camera,
particles: P,
) where
P: Iterator<Item = &'b Particle>,
{
use PushConstantUpdate::*;
pass.set_pipeline(self.pipeline());
pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
pass.set_bind_group(0, &self.bind_group, &[]);
// face toward camera
let Angles { pitch, yaw, roll } = camera.angles();
let rotation = Angles {
pitch: -pitch,
yaw: -yaw,
roll: -roll,
}
.mat4_wgpu();
for particle in particles {
let q_origin = particle.origin();
let translation =
Matrix4::from_translation([-q_origin.y, q_origin.z, -q_origin.x].into());
Self::set_push_constants(
pass,
Update(bump.alloc(VertexPushConstants {
transform: camera.view_projection() * translation * rotation,
})),
Retain,
Update(bump.alloc(FragmentPushConstants {
color: particle.color() as u32,
})),
);
pass.draw(0..6, 0..1);
}
}
}
#[derive(Copy, Clone, Debug)]
pub struct VertexPushConstants {
pub transform: Matrix4<f32>,
}
#[derive(Copy, Clone, Debug)]
pub struct FragmentPushConstants {
pub color: u32, | visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::Sampler {
filtering: true,
comparison: false,
},
count: None,
},
// per-index texture array
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::Texture {
view_dimension: wgpu::TextureViewDimension::D2,
sample_type: wgpu::TextureSampleType::Float { filterable: true },
multisampled: false,
},
count: NonZeroU32::new(256),
},
];
lazy_static! {
static ref VERTEX_ATTRIBUTES: [[wgpu::VertexAttribute; 2]; 2] = [
wgpu::vertex_attr_array![
// position
0 => Float32x3,
// texcoord
1 => Float32x2,
],
wgpu::vertex_attr_array![
// instance position
2 => Float32x3,
// color index
3 => Uint32,
]
];
}
impl Pipeline for ParticlePipeline {
type VertexPushConstants = VertexPushConstants;
type SharedPushConstants = ();
type FragmentPushConstants = FragmentPushConstants;
fn name() -> &'static str {
"particle"
}
fn vertex_shader() -> &'static str {
include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/shaders/particle.vert"
))
}
fn fragment_shader() -> &'static str {
include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/shaders/particle.frag"
))
}
// NOTE: if any of the binding indices are changed, they must also be changed in
// the corresponding shaders and the BindGroupLayout generation functions.
fn bind_group_layout_descriptors() -> Vec<wgpu::BindGroupLayoutDescriptor<'static>> {
vec![
// group 0
wgpu::BindGroupLayoutDescriptor {
label: Some("particle bind group layout"),
entries: BIND_GROUP_LAYOUT_ENTRIES,
},
]
}
fn primitive_state() -> wgpu::PrimitiveState {
WorldPipelineBase::primitive_state()
}
fn color_target_states() -> Vec<wgpu::ColorTargetState> {
WorldPipelineBase::color_target_states()
}
fn depth_stencil_state() -> Option<wgpu::DepthStencilState> {
let mut desc = WorldPipelineBase::depth_stencil_state().unwrap();
desc.depth_write_enabled = false;
Some(desc)
| }
const BIND_GROUP_LAYOUT_ENTRIES: &[wgpu::BindGroupLayoutEntry] = &[
wgpu::BindGroupLayoutEntry {
binding: 0, | random_line_split |
particle.rs | ];
}
#[rustfmt::skip]
const PARTICLE_TEXTURE_PIXELS: [u8; 64] = [
0, 0, 1, 1, 1, 1, 0, 0,
0, 1, 1, 1, 1, 1, 1, 0,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
0, 1, 1, 1, 1, 1, 1, 0,
0, 0, 1, 1, 1, 1, 0, 0,
];
pub struct ParticlePipeline {
pipeline: wgpu::RenderPipeline,
bind_group_layouts: Vec<wgpu::BindGroupLayout>,
vertex_buffer: wgpu::Buffer,
sampler: wgpu::Sampler,
textures: Vec<wgpu::Texture>,
texture_views: Vec<wgpu::TextureView>,
bind_group: wgpu::BindGroup,
}
impl ParticlePipeline {
pub fn new(
device: &wgpu::Device,
queue: &wgpu::Queue,
compiler: &mut shaderc::Compiler,
sample_count: u32,
palette: &Palette,
) -> ParticlePipeline {
let (pipeline, bind_group_layouts) =
ParticlePipeline::create(device, compiler, &[], sample_count);
use wgpu::util::DeviceExt as _;
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: None,
contents: unsafe { any_slice_as_bytes(&VERTICES) },
usage: wgpu::BufferUsage::VERTEX,
});
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("particle sampler"),
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: wgpu::FilterMode::Nearest,
min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::FilterMode::Linear,
lod_min_clamp: -1000.0,
lod_max_clamp: 1000.0,
compare: None,
anisotropy_clamp: NonZeroU8::new(16),
border_color: None,
});
let textures: Vec<wgpu::Texture> = (0..256)
.map(|i| {
let mut pixels = PARTICLE_TEXTURE_PIXELS;
// set up palette translation
for pix in pixels.iter_mut() {
if *pix == 0 {
*pix = 0xFF;
} else {
*pix *= i as u8;
}
}
let (diffuse_data, _) = palette.translate(&pixels);
create_texture(
device,
queue,
Some(&format!("particle texture {}", i)),
8,
8,
&TextureData::Diffuse(diffuse_data),
)
})
.collect();
let texture_views: Vec<wgpu::TextureView> = textures
.iter()
.map(|t| t.create_view(&Default::default()))
.collect();
let texture_view_refs = texture_views.iter().collect::<Vec<_>>();
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("particle bind group"),
layout: &bind_group_layouts[0],
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Sampler(&sampler),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureViewArray(&texture_view_refs[..]),
},
],
});
ParticlePipeline {
pipeline,
bind_group_layouts,
sampler,
textures,
texture_views,
bind_group,
vertex_buffer,
}
}
pub fn rebuild(
&mut self,
device: &wgpu::Device,
compiler: &mut shaderc::Compiler,
sample_count: u32,
) {
let layout_refs: Vec<_> = self.bind_group_layouts.iter().collect();
self.pipeline = ParticlePipeline::recreate(device, compiler, &layout_refs, sample_count);
}
pub fn pipeline(&self) -> &wgpu::RenderPipeline {
&self.pipeline
}
pub fn bind_group_layouts(&self) -> &[wgpu::BindGroupLayout] {
&self.bind_group_layouts
}
pub fn vertex_buffer(&self) -> &wgpu::Buffer {
&self.vertex_buffer
}
pub fn record_draw<'a, 'b, P>(
&'a self,
pass: &mut wgpu::RenderPass<'a>,
bump: &'a Bump,
camera: &Camera,
particles: P,
) where
P: Iterator<Item = &'b Particle>,
| Self::set_push_constants(
pass,
Update(bump.alloc(VertexPushConstants {
transform: camera.view_projection() * translation * rotation,
})),
Retain,
Update(bump.alloc(FragmentPushConstants {
color: particle.color() as u32,
})),
);
pass.draw(0..6, 0..1);
}
}
}
#[derive(Copy, Clone, Debug)]
pub struct VertexPushConstants {
pub transform: Matrix4<f32>,
}
#[derive(Copy, Clone, Debug)]
pub struct FragmentPushConstants {
pub color: u32,
}
const BIND_GROUP_LAYOUT_ENTRIES: &[wgpu::BindGroupLayoutEntry] = &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::Sampler {
filtering: true,
comparison: false,
},
count: None,
},
// per-index texture array
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::Texture {
view_dimension: wgpu::TextureViewDimension::D2,
sample_type: wgpu::TextureSampleType::Float { filterable: true },
multisampled: false,
},
count: NonZeroU32::new(256),
},
];
lazy_static! {
static ref VERTEX_ATTRIBUTES: [[wgpu::VertexAttribute; 2]; 2] = [
wgpu::vertex_attr_array![
// position
0 => Float32x3,
// texcoord
1 => Float32x2,
],
wgpu::vertex_attr_array![
// instance position
2 => Float32x3,
// color index
3 => Uint32,
]
];
}
impl Pipeline for ParticlePipeline {
type VertexPushConstants = VertexPushConstants;
type SharedPushConstants = ();
type FragmentPushConstants = FragmentPushConstants;
fn name() -> &'static str {
"particle"
}
fn vertex_shader() -> &'static str {
include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/shaders/particle.vert"
))
}
fn fragment_shader() -> &'static str {
include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/shaders/particle.frag"
))
}
// NOTE: if any of the binding indices are changed, they must also be changed in
// the corresponding shaders and the BindGroupLayout generation functions.
fn bind_group_layout_descriptors() -> Vec<wgpu::BindGroupLayoutDescriptor<'static>> {
vec![
// group 0
wgpu::BindGroupLayoutDescriptor {
label: Some("particle bind group layout"),
entries: BIND_GROUP_LAYOUT_ENTRIES,
},
]
}
fn primitive_state() -> wgpu::PrimitiveState {
WorldPipelineBase::primitive_state()
}
fn color_target_states() -> Vec<wgpu::ColorTargetState> {
WorldPipelineBase::color_target_states()
}
fn depth_stencil_state() -> Option<wgpu::DepthStencilState> {
let mut desc = WorldPipelineBase::depth_stencil_state().unwrap();
desc.depth_write_enabled = false;
Some(desc)
| {
use PushConstantUpdate::*;
pass.set_pipeline(self.pipeline());
pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
pass.set_bind_group(0, &self.bind_group, &[]);
// face toward camera
let Angles { pitch, yaw, roll } = camera.angles();
let rotation = Angles {
pitch: -pitch,
yaw: -yaw,
roll: -roll,
}
.mat4_wgpu();
for particle in particles {
let q_origin = particle.origin();
let translation =
Matrix4::from_translation([-q_origin.y, q_origin.z, -q_origin.x].into()); | identifier_body |
train_transformer.py | global_valid_step += 1
fout.write(' '.join(convert_ids_to_seq(output_seqs[0], vocab_bulider)) + '\n')
if (i+1) % opt.logstep == 0:
show_gen_seq(src, output_seqs, out_lens, tgt_gold, vocab_bulider, global_valid_step, mode='valid')
# summary
avg_loss = total_loss / i
avg_bleu = bleu_score / i
avg_distinct_1 = distinct_1_score / i
avg_distinct_2 = distinct_2_score / i
writer.log_loss(avg_loss, mode='valid')
mylogger.log(
i, epoch, model, value=avg_bleu, is_train=False,
info=f'loss: {avg_loss:.4f} | ppl: {math.exp(avg_loss):.4f} | BLEU: {avg_bleu:.5f} | d1: {avg_distinct_1:.3f} | d2: {avg_distinct_2:.3f}')
fout.close()
def run_model(model, train_loader, eval_loader, niter, criterion, optimizer, scheduler):
mylogger.log_info('Running Model')
for i in range(niter):
mylogger.log_info(f'EPOCH: {i}, lr: {optimizer.state_dict()["param_groups"][0]["lr"]}')
train(i, model, train_loader, criterion, optimizer, scheduler)
eval(i, model, eval_loader, criterion, beam_size=opt.beam)
def convert_ids_to_seq(id_seq, vocab_bulider):
return [vocab_bulider.id_to_word(idx) for idx in id_seq]
def show_gen_seq(batch_in_seqs, batch_out_seqs, batch_out_lens, groud_truth, vocab_bulider, step, mode='train'):
for in_id, out_id, out_len, gold_id in zip(batch_in_seqs, batch_out_seqs, batch_out_lens, groud_truth):
in_seq = convert_ids_to_seq(in_id, vocab_bulider)
out_seq = convert_ids_to_seq(out_id[:out_len] if out_len > 0 else out_id, vocab_bulider)
gold_seq = convert_ids_to_seq(gold_id, vocab_bulider)
writer.add_text(tag=mode + '_post', sentence=' '.join(in_seq[:get_index(in_seq, '<pad>')]), global_step=step)
writer.add_text(tag=mode + '_pred', sentence=' '.join(out_seq), global_step=step)
writer.add_text(tag=mode + '_reps', sentence=' '.join(gold_seq[:get_index(in_seq, '<pad>')]), global_step=step)
if __name__ == '__main__':
begin_time = time.strftime("%H%M%S", time.localtime())
model_name = 'transformer' + begin_time
opt = parse_args()
device = "cuda" if torch.cuda.is_available() else "cpu"
torch.cuda.set_device(opt.gpuid)
init_seed(opt.manualSeed)
ACCUMULATION = opt.batchsize // opt.realbatch
mylogger = LogManager(checkpoint_step=10,
save_dir='./save',
model_name=model_name,
log_file_name=model_name + '.log',
mode='max', device=device)
mylogger.save_args(opt)
writer = SummaryHelper(save_dir='./save', model_name=model_name)
train_data_dir = './data/opensubtitles'
# train_data_dir = './data/wmt15en-de'
vocab_file_list = ['dialogue_length3_6.post']
# vocab_file_list = ['all_de-en.bpe.post', 'all_de-en.bpe.response']
vocab_bulider = VocabBulider(
train_data_dir, src_files=vocab_file_list, ignore_unk_error=True,
vocab_file='vocab.txt', min_count=opt.mincount, update=opt.update)
print('most common 50:', vocab_bulider.most_common(50))
mylogger.log_info('vocab size: %d' % len(vocab_bulider))
# metircs
bleu_metirc = BLEUMetric(vocab_bulider.id2vocab, ignore_smoothing_error=True)
distinct_1 = DistinctNGram(ngram=1)
distinct_2 = DistinctNGram(ngram=2)
# train dataset and dataloader
if opt.cotk: # use dataset in paper 'cotk'
# opensub_file_name_list = ['all_de-en.bpe']
opensub_file_name_list = ['opensub_pair_dev', 'opensub_pair_test', 'opensub_pair_train']
unk_token = None
else: # use dataset in paper 'Non-Autoregressive Neural Dialogue Generation'
opensub_file_name_list = ['dialogue_length3_6']
unk_token = 'UNknown'
opensub_dataset = OpenSubDataset(
data_dir=train_data_dir, vocab_bulider=vocab_bulider,
file_name_list=opensub_file_name_list, unk_token='UNknown',
save_process=False, samples=opt.trainsamples, add_bos=True, add_eos=True)
print(opensub_dataset.sample())
opensub_dataloader = DataLoader(
opensub_dataset, batch_size=opt.realbatch,
collate_fn=PadCollate(dim=0, pad_id=vocab_bulider.padid, device=device),
shuffle=True, num_workers=opt.workers, drop_last=True)
# dev set
dev_data_dir = './data/imsdb'
imsdb_file_name_list = ['imsdb_lower']
# dev_data_dir = './data/wmt15en-de'
# imsdb_file_name_list = ['newstest']
imsdb_dataset = IMSDBDataset(
data_dir=dev_data_dir, vocab_bulider=vocab_bulider,
file_name_list=imsdb_file_name_list, save_process=False,
samples=opt.validsamples, add_bos=True, add_eos=True)
print(imsdb_dataset.sample())
imsdb_dataloader = DataLoader(
imsdb_dataset, batch_size=1,
collate_fn=PadCollate(dim=0, pad_id=vocab_bulider.padid, device=device),
shuffle=False, num_workers=opt.workers, drop_last=True)
# model definition
if opt.mine:
model = Transformer(
ntoken=len(vocab_bulider), d_model=opt.embedsize, nhead=opt.nhead,
num_encoder_layers=opt.encoderlayer, num_decoder_layers=opt.decoderlayer,
dim_feedforward=opt.feedforward, postnorm=True, dropout=opt.dropout, gumbels=opt.gumbels,
use_src_mask=False, use_tgt_mask=True, use_memory_mask=False,
activation='relu', use_vocab_attn=False, use_pos_attn=False,
relative_clip=0, highway=False, device=device, max_sent_length=32,
share_input_output_embedding=False, share_encoder_decoder_embedding=True,
share_vocab_embedding=True, fix_pos_encoding=opt.fix).to(device)
else:
model = TransformerTorch(
ntoken=len(vocab_bulider), d_model=opt.embedsize, nhead=opt.nhead,
num_encoder_layers=opt.encoderlayer, num_decoder_layers=opt.decoderlayer,
dim_feedforward=opt.feedforward, postnorm=True, dropout=opt.dropout, gumbels=opt.gumbels,
use_src_mask=False, use_tgt_mask=False, use_memory_mask=False,
activation='relu', use_vocab_attn=False, use_pos_attn=False,
relative_clip=0, highway=False, device=device, max_sent_length=32,
share_input_output_embedding=False, share_encoder_decoder_embedding=True,
share_vocab_embedding=True, fix_pos_encoding=opt.fix).to(device)
model.show_graph()
if opt.half:
model = model.half()
if opt.ft:
model = restore_best_state(model, opt.ckpt, save_dir='./save', device=model.device)
# optimizer and scheduler
if opt.warmup:
optimizer = RAdam(
filter(lambda p: p.requires_grad, model.parameters()),
lr=1., betas=(opt.beta1, opt.beta2), eps=opt.eps)
rate_ratio = 1. / math.sqrt(opt.embedsize)
# top_lr = 1 / sqrt(d_model * warmup_step) at step == warmup_step
scheduler = optim.lr_scheduler.LambdaLR(
optimizer,
lr_lambda=lambda step: rate_ratio * min(1. / math.sqrt(step+1), step*(opt.warmup_step**(-1.5))))
else:
optimizer = RAdam(
filter(lambda p: p.requires_grad, model.parameters()),
lr=opt.lr, betas=(opt.beta1, opt.beta2), eps=opt.eps,
weight_decay=opt.weight_decay)
scheduler = optim.lr_scheduler.StepLR(
optimizer, step_size=opt.schedulerstep, gamma=opt.gamma)
# loss function
# criterion = nn.CrossEntropyLoss(ignore_index=vocab_bulider.padid) # for Transformer
criterion = LabelSmoothedCrossEntropyLoss(eps=0.1, ignore_index=vocab_bulider.padid)
# run model
global_train_step, global_valid_step = 0, 0
run_model(
| model, opensub_dataloader, imsdb_dataloader,
opt.niter, criterion, optimizer, scheduler)
writer.close() | random_line_split | |
train_transformer.py | distinct_2_score += distinct_2(out_seqs, tgt_lens)
# summary writer
global_train_step += 1
writer.log_loss(loss.item()*ACCUMULATION, mode='train')
if (i+1) % ACCUMULATION == 0:
# clip_grad_norm_(model.parameters(), max_norm=5)
optimizer.step()
optimizer.zero_grad()
scheduler.step()
if (i+1) % opt.logstep == 0:
avg_loss = (total_loss / opt.logstep) * ACCUMULATION
avg_bleu = bleu_score / opt.logstep
avg_distinct_1 = distinct_1_score / opt.logstep
avg_distinct_2 = distinct_2_score / opt.logstep
mylogger.log(
i, epoch, model, value=avg_loss, is_train=True,
info=f'loss: {avg_loss:.4f} | ppl: {math.exp(avg_loss):.4f} | BLEU: {avg_bleu:.5f} | d1: {avg_distinct_1:.3f} | d2: {avg_distinct_2:.3f}')
total_loss = 0.
bleu_score = 0.
distinct_1_score, distinct_2_score = 0., 0.
show_gen_seq(src[:2], out_seqs[:2], tgt_lens[:2], tgt_gold[:2], vocab_bulider, global_train_step, mode='train')
def eval(epoch, model, dataloader, criterion, beam_size=2):
global global_valid_step
model.eval()
criterion.eval()
total_loss = 0.
bleu_score = 0.
distinct_1_score, distinct_2_score = 0., 0.
fout = open(os.path.join('./save/' + model_name + '/', model_name + '_' + str(epoch)), 'w', encoding='utf-8')
with torch.no_grad():
for i, (src, tgt, src_lens, tgt_lens) in tqdm(enumerate(dataloader, 0), desc='eval', total=len(imsdb_dataset)):
tgt_begin = torch.LongTensor([[vocab_bulider['<bos>']]]).to(device)
tgt_gold = tgt[:, 1:]
if beam_size > 1:
output_seqs, output_probs = model.beam_search(
src=src, tgt_begin=tgt_begin, src_length=src_lens,
eos_token_id=vocab_bulider['<eos>'], beam_size=beam_size, max_length=tgt_lens.item())
else:
output_seqs, output_probs = model.greedy(
src=src, tgt_begin=tgt_begin, src_length=src_lens,
eos_token_id=vocab_bulider['<eos>'], max_length=tgt_lens.item())
min_len = min(tgt_gold.shape[1], output_seqs.shape[1])
# loss
loss = criterion(output_probs[:, :min_len, :].permute(0, 2, 1), tgt_gold[:, :min_len])
total_loss += loss.item()
# calculate metrics
out_lens = [min_len]
bleu_score += bleu_metirc(tgt_gold, output_seqs, out_lens)
distinct_1_score += distinct_1(output_seqs, out_lens)
distinct_2_score += distinct_2(output_seqs, out_lens)
# show sequence
global_valid_step += 1
fout.write(' '.join(convert_ids_to_seq(output_seqs[0], vocab_bulider)) + '\n')
if (i+1) % opt.logstep == 0:
show_gen_seq(src, output_seqs, out_lens, tgt_gold, vocab_bulider, global_valid_step, mode='valid')
# summary
avg_loss = total_loss / i
avg_bleu = bleu_score / i
avg_distinct_1 = distinct_1_score / i
avg_distinct_2 = distinct_2_score / i
writer.log_loss(avg_loss, mode='valid')
mylogger.log(
i, epoch, model, value=avg_bleu, is_train=False,
info=f'loss: {avg_loss:.4f} | ppl: {math.exp(avg_loss):.4f} | BLEU: {avg_bleu:.5f} | d1: {avg_distinct_1:.3f} | d2: {avg_distinct_2:.3f}')
fout.close()
def run_model(model, train_loader, eval_loader, niter, criterion, optimizer, scheduler):
mylogger.log_info('Running Model')
for i in range(niter):
mylogger.log_info(f'EPOCH: {i}, lr: {optimizer.state_dict()["param_groups"][0]["lr"]}')
train(i, model, train_loader, criterion, optimizer, scheduler)
eval(i, model, eval_loader, criterion, beam_size=opt.beam)
def convert_ids_to_seq(id_seq, vocab_bulider):
return [vocab_bulider.id_to_word(idx) for idx in id_seq]
def show_gen_seq(batch_in_seqs, batch_out_seqs, batch_out_lens, groud_truth, vocab_bulider, step, mode='train'):
for in_id, out_id, out_len, gold_id in zip(batch_in_seqs, batch_out_seqs, batch_out_lens, groud_truth):
in_seq = convert_ids_to_seq(in_id, vocab_bulider)
out_seq = convert_ids_to_seq(out_id[:out_len] if out_len > 0 else out_id, vocab_bulider)
gold_seq = convert_ids_to_seq(gold_id, vocab_bulider)
writer.add_text(tag=mode + '_post', sentence=' '.join(in_seq[:get_index(in_seq, '<pad>')]), global_step=step)
writer.add_text(tag=mode + '_pred', sentence=' '.join(out_seq), global_step=step)
writer.add_text(tag=mode + '_reps', sentence=' '.join(gold_seq[:get_index(in_seq, '<pad>')]), global_step=step)
if __name__ == '__main__':
begin_time = time.strftime("%H%M%S", time.localtime())
model_name = 'transformer' + begin_time
opt = parse_args()
device = "cuda" if torch.cuda.is_available() else "cpu"
torch.cuda.set_device(opt.gpuid)
init_seed(opt.manualSeed)
ACCUMULATION = opt.batchsize // opt.realbatch
mylogger = LogManager(checkpoint_step=10,
save_dir='./save',
model_name=model_name,
log_file_name=model_name + '.log',
mode='max', device=device)
mylogger.save_args(opt)
writer = SummaryHelper(save_dir='./save', model_name=model_name)
train_data_dir = './data/opensubtitles'
# train_data_dir = './data/wmt15en-de'
vocab_file_list = ['dialogue_length3_6.post']
# vocab_file_list = ['all_de-en.bpe.post', 'all_de-en.bpe.response']
vocab_bulider = VocabBulider(
train_data_dir, src_files=vocab_file_list, ignore_unk_error=True,
vocab_file='vocab.txt', min_count=opt.mincount, update=opt.update)
print('most common 50:', vocab_bulider.most_common(50))
mylogger.log_info('vocab size: %d' % len(vocab_bulider))
# metircs
bleu_metirc = BLEUMetric(vocab_bulider.id2vocab, ignore_smoothing_error=True)
distinct_1 = DistinctNGram(ngram=1)
distinct_2 = DistinctNGram(ngram=2)
# train dataset and dataloader
if opt.cotk: # use dataset in paper 'cotk'
# opensub_file_name_list = ['all_de-en.bpe']
opensub_file_name_list = ['opensub_pair_dev', 'opensub_pair_test', 'opensub_pair_train']
unk_token = None
else: # use dataset in paper 'Non-Autoregressive Neural Dialogue Generation'
opensub_file_name_list = ['dialogue_length3_6']
unk_token = 'UNknown'
opensub_dataset = OpenSubDataset(
data_dir=train_data_dir, vocab_bulider | global global_train_step
model.train()
total_loss = 0.
bleu_score = 0.
distinct_1_score, distinct_2_score = 0., 0.
for i, (src, tgt, src_lens, tgt_lens) in tqdm(enumerate(dataloader, 0), desc='train', total=len(opensub_dataset)//opt.realbatch):
tgt_input = tgt[:, :-1]
tgt_gold = tgt[:, 1:]
tgt_lens = tgt_lens - 1
decoder_output_probs, _ = model(
src=src, tgt=tgt_input, src_lengths=src_lens, tgt_lengths=tgt_lens)
decoder_output_probs_T = decoder_output_probs.permute(0, 2, 1)
out_seqs = torch.argmax(decoder_output_probs, dim=2)
# loss
loss = criterion(decoder_output_probs_T, tgt_gold) / ACCUMULATION
loss.backward()
total_loss += loss.item()
# calculate metrics
bleu_score += bleu_metirc(tgt_gold, out_seqs, tgt_lens)
distinct_1_score += distinct_1(out_seqs, tgt_lens)
| identifier_body | |
train_transformer.py | =2)
# loss
loss = criterion(decoder_output_probs_T, tgt_gold) / ACCUMULATION
loss.backward()
total_loss += loss.item()
# calculate metrics
bleu_score += bleu_metirc(tgt_gold, out_seqs, tgt_lens)
distinct_1_score += distinct_1(out_seqs, tgt_lens)
distinct_2_score += distinct_2(out_seqs, tgt_lens)
# summary writer
global_train_step += 1
writer.log_loss(loss.item()*ACCUMULATION, mode='train')
if (i+1) % ACCUMULATION == 0:
# clip_grad_norm_(model.parameters(), max_norm=5)
optimizer.step()
optimizer.zero_grad()
scheduler.step()
if (i+1) % opt.logstep == 0:
avg_loss = (total_loss / opt.logstep) * ACCUMULATION
avg_bleu = bleu_score / opt.logstep
avg_distinct_1 = distinct_1_score / opt.logstep
avg_distinct_2 = distinct_2_score / opt.logstep
mylogger.log(
i, epoch, model, value=avg_loss, is_train=True,
info=f'loss: {avg_loss:.4f} | ppl: {math.exp(avg_loss):.4f} | BLEU: {avg_bleu:.5f} | d1: {avg_distinct_1:.3f} | d2: {avg_distinct_2:.3f}')
total_loss = 0.
bleu_score = 0.
distinct_1_score, distinct_2_score = 0., 0.
show_gen_seq(src[:2], out_seqs[:2], tgt_lens[:2], tgt_gold[:2], vocab_bulider, global_train_step, mode='train')
def eval(epoch, model, dataloader, criterion, beam_size=2):
global global_valid_step
model.eval()
criterion.eval()
total_loss = 0.
bleu_score = 0.
distinct_1_score, distinct_2_score = 0., 0.
fout = open(os.path.join('./save/' + model_name + '/', model_name + '_' + str(epoch)), 'w', encoding='utf-8')
with torch.no_grad():
for i, (src, tgt, src_lens, tgt_lens) in tqdm(enumerate(dataloader, 0), desc='eval', total=len(imsdb_dataset)):
tgt_begin = torch.LongTensor([[vocab_bulider['<bos>']]]).to(device)
tgt_gold = tgt[:, 1:]
if beam_size > 1:
output_seqs, output_probs = model.beam_search(
src=src, tgt_begin=tgt_begin, src_length=src_lens,
eos_token_id=vocab_bulider['<eos>'], beam_size=beam_size, max_length=tgt_lens.item())
else:
output_seqs, output_probs = model.greedy(
src=src, tgt_begin=tgt_begin, src_length=src_lens,
eos_token_id=vocab_bulider['<eos>'], max_length=tgt_lens.item())
min_len = min(tgt_gold.shape[1], output_seqs.shape[1])
# loss
loss = criterion(output_probs[:, :min_len, :].permute(0, 2, 1), tgt_gold[:, :min_len])
total_loss += loss.item()
# calculate metrics
out_lens = [min_len]
bleu_score += bleu_metirc(tgt_gold, output_seqs, out_lens)
distinct_1_score += distinct_1(output_seqs, out_lens)
distinct_2_score += distinct_2(output_seqs, out_lens)
# show sequence
global_valid_step += 1
fout.write(' '.join(convert_ids_to_seq(output_seqs[0], vocab_bulider)) + '\n')
if (i+1) % opt.logstep == 0:
show_gen_seq(src, output_seqs, out_lens, tgt_gold, vocab_bulider, global_valid_step, mode='valid')
# summary
avg_loss = total_loss / i
avg_bleu = bleu_score / i
avg_distinct_1 = distinct_1_score / i
avg_distinct_2 = distinct_2_score / i
writer.log_loss(avg_loss, mode='valid')
mylogger.log(
i, epoch, model, value=avg_bleu, is_train=False,
info=f'loss: {avg_loss:.4f} | ppl: {math.exp(avg_loss):.4f} | BLEU: {avg_bleu:.5f} | d1: {avg_distinct_1:.3f} | d2: {avg_distinct_2:.3f}')
fout.close()
def | (model, train_loader, eval_loader, niter, criterion, optimizer, scheduler):
mylogger.log_info('Running Model')
for i in range(niter):
mylogger.log_info(f'EPOCH: {i}, lr: {optimizer.state_dict()["param_groups"][0]["lr"]}')
train(i, model, train_loader, criterion, optimizer, scheduler)
eval(i, model, eval_loader, criterion, beam_size=opt.beam)
def convert_ids_to_seq(id_seq, vocab_bulider):
return [vocab_bulider.id_to_word(idx) for idx in id_seq]
def show_gen_seq(batch_in_seqs, batch_out_seqs, batch_out_lens, groud_truth, vocab_bulider, step, mode='train'):
for in_id, out_id, out_len, gold_id in zip(batch_in_seqs, batch_out_seqs, batch_out_lens, groud_truth):
in_seq = convert_ids_to_seq(in_id, vocab_bulider)
out_seq = convert_ids_to_seq(out_id[:out_len] if out_len > 0 else out_id, vocab_bulider)
gold_seq = convert_ids_to_seq(gold_id, vocab_bulider)
writer.add_text(tag=mode + '_post', sentence=' '.join(in_seq[:get_index(in_seq, '<pad>')]), global_step=step)
writer.add_text(tag=mode + '_pred', sentence=' '.join(out_seq), global_step=step)
writer.add_text(tag=mode + '_reps', sentence=' '.join(gold_seq[:get_index(in_seq, '<pad>')]), global_step=step)
if __name__ == '__main__':
begin_time = time.strftime("%H%M%S", time.localtime())
model_name = 'transformer' + begin_time
opt = parse_args()
device = "cuda" if torch.cuda.is_available() else "cpu"
torch.cuda.set_device(opt.gpuid)
init_seed(opt.manualSeed)
ACCUMULATION = opt.batchsize // opt.realbatch
mylogger = LogManager(checkpoint_step=10,
save_dir='./save',
model_name=model_name,
log_file_name=model_name + '.log',
mode='max', device=device)
mylogger.save_args(opt)
writer = SummaryHelper(save_dir='./save', model_name=model_name)
train_data_dir = './data/opensubtitles'
# train_data_dir = './data/wmt15en-de'
vocab_file_list = ['dialogue_length3_6.post']
# vocab_file_list = ['all_de-en.bpe.post', 'all_de-en.bpe.response']
vocab_bulider = VocabBulider(
train_data_dir, src_files=vocab_file_list, ignore_unk_error=True,
vocab_file='vocab.txt', min_count=opt.mincount, update=opt.update)
print('most common 50:', vocab_bulider.most_common(50))
mylogger.log_info('vocab size: %d' % len(vocab_bulider))
# metircs
bleu_metirc = BLEUMetric(vocab_bulider.id2vocab, ignore_smoothing_error=True)
distinct_1 = DistinctNGram(ngram=1)
distinct_2 = DistinctNGram(ngram=2)
# train dataset and dataloader
if opt.cotk: # use dataset in paper 'cotk'
# opensub_file_name_list = ['all_de-en.bpe']
opensub_file_name_list = ['opensub_pair_dev', 'opensub_pair_test', 'opensub_pair_train']
unk_token = None
else: # use dataset in paper 'Non-Autoregressive Neural Dialogue Generation'
opensub_file_name_list = ['dialogue_length3_6']
unk_token = 'UNknown'
opensub_dataset = OpenSubDataset(
data_dir=train_data_dir, vocab_bulider=vocab_bulider,
file_name_list=opensub_file_name_list, unk_token='UNknown',
save_process=False, samples=opt.trainsamples, add_bos=True, add_eos=True)
print(opensub_dataset.sample())
opensub_dataloader = DataLoader(
opensub_dataset, batch_size=opt.realbatch,
collate_fn=PadCollate(dim=0, pad_id=vocab_bulider.padid, device=device),
shuffle=True, num_workers=opt.workers, drop_last=True)
# dev set
dev_data_dir = './data/imsdb'
imsdb_file_name_list = ['imsdb_lower']
# dev_data_dir = './data/wmt15en-de'
# imsdb_file_name_list = ['newstest']
imsdb_dataset | run_model | identifier_name |
train_transformer.py | =2)
# loss
loss = criterion(decoder_output_probs_T, tgt_gold) / ACCUMULATION
loss.backward()
total_loss += loss.item()
# calculate metrics
bleu_score += bleu_metirc(tgt_gold, out_seqs, tgt_lens)
distinct_1_score += distinct_1(out_seqs, tgt_lens)
distinct_2_score += distinct_2(out_seqs, tgt_lens)
# summary writer
global_train_step += 1
writer.log_loss(loss.item()*ACCUMULATION, mode='train')
if (i+1) % ACCUMULATION == 0:
# clip_grad_norm_(model.parameters(), max_norm=5)
optimizer.step()
optimizer.zero_grad()
scheduler.step()
if (i+1) % opt.logstep == 0:
|
def eval(epoch, model, dataloader, criterion, beam_size=2):
global global_valid_step
model.eval()
criterion.eval()
total_loss = 0.
bleu_score = 0.
distinct_1_score, distinct_2_score = 0., 0.
fout = open(os.path.join('./save/' + model_name + '/', model_name + '_' + str(epoch)), 'w', encoding='utf-8')
with torch.no_grad():
for i, (src, tgt, src_lens, tgt_lens) in tqdm(enumerate(dataloader, 0), desc='eval', total=len(imsdb_dataset)):
tgt_begin = torch.LongTensor([[vocab_bulider['<bos>']]]).to(device)
tgt_gold = tgt[:, 1:]
if beam_size > 1:
output_seqs, output_probs = model.beam_search(
src=src, tgt_begin=tgt_begin, src_length=src_lens,
eos_token_id=vocab_bulider['<eos>'], beam_size=beam_size, max_length=tgt_lens.item())
else:
output_seqs, output_probs = model.greedy(
src=src, tgt_begin=tgt_begin, src_length=src_lens,
eos_token_id=vocab_bulider['<eos>'], max_length=tgt_lens.item())
min_len = min(tgt_gold.shape[1], output_seqs.shape[1])
# loss
loss = criterion(output_probs[:, :min_len, :].permute(0, 2, 1), tgt_gold[:, :min_len])
total_loss += loss.item()
# calculate metrics
out_lens = [min_len]
bleu_score += bleu_metirc(tgt_gold, output_seqs, out_lens)
distinct_1_score += distinct_1(output_seqs, out_lens)
distinct_2_score += distinct_2(output_seqs, out_lens)
# show sequence
global_valid_step += 1
fout.write(' '.join(convert_ids_to_seq(output_seqs[0], vocab_bulider)) + '\n')
if (i+1) % opt.logstep == 0:
show_gen_seq(src, output_seqs, out_lens, tgt_gold, vocab_bulider, global_valid_step, mode='valid')
# summary
avg_loss = total_loss / i
avg_bleu = bleu_score / i
avg_distinct_1 = distinct_1_score / i
avg_distinct_2 = distinct_2_score / i
writer.log_loss(avg_loss, mode='valid')
mylogger.log(
i, epoch, model, value=avg_bleu, is_train=False,
info=f'loss: {avg_loss:.4f} | ppl: {math.exp(avg_loss):.4f} | BLEU: {avg_bleu:.5f} | d1: {avg_distinct_1:.3f} | d2: {avg_distinct_2:.3f}')
fout.close()
def run_model(model, train_loader, eval_loader, niter, criterion, optimizer, scheduler):
mylogger.log_info('Running Model')
for i in range(niter):
mylogger.log_info(f'EPOCH: {i}, lr: {optimizer.state_dict()["param_groups"][0]["lr"]}')
train(i, model, train_loader, criterion, optimizer, scheduler)
eval(i, model, eval_loader, criterion, beam_size=opt.beam)
def convert_ids_to_seq(id_seq, vocab_bulider):
return [vocab_bulider.id_to_word(idx) for idx in id_seq]
def show_gen_seq(batch_in_seqs, batch_out_seqs, batch_out_lens, groud_truth, vocab_bulider, step, mode='train'):
for in_id, out_id, out_len, gold_id in zip(batch_in_seqs, batch_out_seqs, batch_out_lens, groud_truth):
in_seq = convert_ids_to_seq(in_id, vocab_bulider)
out_seq = convert_ids_to_seq(out_id[:out_len] if out_len > 0 else out_id, vocab_bulider)
gold_seq = convert_ids_to_seq(gold_id, vocab_bulider)
writer.add_text(tag=mode + '_post', sentence=' '.join(in_seq[:get_index(in_seq, '<pad>')]), global_step=step)
writer.add_text(tag=mode + '_pred', sentence=' '.join(out_seq), global_step=step)
writer.add_text(tag=mode + '_reps', sentence=' '.join(gold_seq[:get_index(in_seq, '<pad>')]), global_step=step)
if __name__ == '__main__':
begin_time = time.strftime("%H%M%S", time.localtime())
model_name = 'transformer' + begin_time
opt = parse_args()
device = "cuda" if torch.cuda.is_available() else "cpu"
torch.cuda.set_device(opt.gpuid)
init_seed(opt.manualSeed)
ACCUMULATION = opt.batchsize // opt.realbatch
mylogger = LogManager(checkpoint_step=10,
save_dir='./save',
model_name=model_name,
log_file_name=model_name + '.log',
mode='max', device=device)
mylogger.save_args(opt)
writer = SummaryHelper(save_dir='./save', model_name=model_name)
train_data_dir = './data/opensubtitles'
# train_data_dir = './data/wmt15en-de'
vocab_file_list = ['dialogue_length3_6.post']
# vocab_file_list = ['all_de-en.bpe.post', 'all_de-en.bpe.response']
vocab_bulider = VocabBulider(
train_data_dir, src_files=vocab_file_list, ignore_unk_error=True,
vocab_file='vocab.txt', min_count=opt.mincount, update=opt.update)
print('most common 50:', vocab_bulider.most_common(50))
mylogger.log_info('vocab size: %d' % len(vocab_bulider))
# metircs
bleu_metirc = BLEUMetric(vocab_bulider.id2vocab, ignore_smoothing_error=True)
distinct_1 = DistinctNGram(ngram=1)
distinct_2 = DistinctNGram(ngram=2)
# train dataset and dataloader
if opt.cotk: # use dataset in paper 'cotk'
# opensub_file_name_list = ['all_de-en.bpe']
opensub_file_name_list = ['opensub_pair_dev', 'opensub_pair_test', 'opensub_pair_train']
unk_token = None
else: # use dataset in paper 'Non-Autoregressive Neural Dialogue Generation'
opensub_file_name_list = ['dialogue_length3_6']
unk_token = 'UNknown'
opensub_dataset = OpenSubDataset(
data_dir=train_data_dir, vocab_bulider=vocab_bulider,
file_name_list=opensub_file_name_list, unk_token='UNknown',
save_process=False, samples=opt.trainsamples, add_bos=True, add_eos=True)
print(opensub_dataset.sample())
opensub_dataloader = DataLoader(
opensub_dataset, batch_size=opt.realbatch,
collate_fn=PadCollate(dim=0, pad_id=vocab_bulider.padid, device=device),
shuffle=True, num_workers=opt.workers, drop_last=True)
# dev set
dev_data_dir = './data/imsdb'
imsdb_file_name_list = ['imsdb_lower']
# dev_data_dir = './data/wmt15en-de'
# imsdb_file_name_list = ['newstest']
imsdb_dataset = | avg_loss = (total_loss / opt.logstep) * ACCUMULATION
avg_bleu = bleu_score / opt.logstep
avg_distinct_1 = distinct_1_score / opt.logstep
avg_distinct_2 = distinct_2_score / opt.logstep
mylogger.log(
i, epoch, model, value=avg_loss, is_train=True,
info=f'loss: {avg_loss:.4f} | ppl: {math.exp(avg_loss):.4f} | BLEU: {avg_bleu:.5f} | d1: {avg_distinct_1:.3f} | d2: {avg_distinct_2:.3f}')
total_loss = 0.
bleu_score = 0.
distinct_1_score, distinct_2_score = 0., 0.
show_gen_seq(src[:2], out_seqs[:2], tgt_lens[:2], tgt_gold[:2], vocab_bulider, global_train_step, mode='train') | conditional_block |
p21_sim.py | 693 #DUMMY
omega_MDM2 = 8.318 #DUMMY
omega_CD = 0.023 #DUMMY
omega_CDInk4 = 1 #DUMMY
omega_CE = 1 #DUMMY
omega_CA = 1 #DUMMY
omega_CACDC20 = 1 #DUMMY
omega_CB = 1 #DUMMY
omega_CBCDC20 = 1 #DUMMY
beta_E2FRb = 2 #DUMMY
beta_E2FRbMP = beta_E2FRb * 0.3 #DUMMY, but should be smaller than beta_E2FRb
beta_mdm2p14 = 1 #DUMMY
beta_cp21 = 1 #DUMMY
beta_E7p21 = 1 #DUMMY
beta_E7pRB = 1 #DUMMY
beta_E7pRBP = 1 #DUMMY
beta_E7pRBPP = 1 #DUMMY
delta_E7p21 = 1 #DUMMY
delta_E7pRB = 1 #DUMMY
epsilon_RbCD = 0.4 #DUMMY
epsilon_RbCE = 0.7 #DUMMY
epsilon_E2F = 20 #DUMMY
epsilon_CDC20 = 1 #DUMMY
sigma_Rb = 0.3 #DUMMY
sigma_RbMP = 0.1 #DUMMY
sigma_E2F = 0.7 #DUMMY
sigma_CDC20 = 1 #DUMMY
kappa_CECA = 1 #DUMMY
kappa_CBCA = 1 #DUMMY
#Knockdown terms. These should all be equal to 1 unless we're testing the
#effects of a knockdown.
theta_E2F = 1
theta_p53 = 1
theta_CE = 1
theta_MDM2 = 1
theta_CD = 1
theta_CA = 1
theta_Ink4 = 1
theta_CB = 1
theta_CDC20 = 1
k_p21 = 1
k_p53 = 1
k_RbMP = 1
k_RbPP = 1
k_RbCD = 1
k_RbCE = 1
k_E2FCA = 1
k_E2F = 1
k_CD = 1
k_CA = 1
k_CB = 1
k_CDC20CB = 1
k_CDC20 = 1
E2F_tot = 10 #DUMMY
CDC20_tot = 0.285
Rb_tot = 10 #DUMMY
#Potentially override parameters
for infile in infiles:
reader = open(infile)
for line in reader.readlines():
exec(line)
#Dummy initial conditions
y0 = [0.1,0.1,0.1,0.1,Rb_tot,0.0,0.0,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0,0]
#Abort early if the output directory already exists.
if dirname != "":
if os.path.exists(dirname):
sys.stderr.write("Output dir " + dirname + " already exists. Aborting.\n")
sys.exit(2)
#Functions to be called from the derivative functions.
def | (t):
return 0 #dummy
def E7(t):
return 0 #dummy
#Fractions for inhibition/inactive complex formation.
#Each has a sanity check in case chief input is near zero.
sanity_threshold = 0.00001
def f(e2f, rb, rbmp):
if e2f < sanity_threshold:
return 0
return e2f**2 / (e2f + beta_E2FRb * rb + beta_E2FRbMP * rbmp)
def g(mdm2, p14):
if mdm2 < sanity_threshold:
return 0
return mdm2**2 / (mdm2 + beta_mdm2p14 * p14)
def h(c, p21, cd, ce, ca, cb):
if c < sanity_threshold:
return 0
if ca+cb+cd+ce < sanity_threshold:
return 0
return c**2 / (c + beta_cp21 * p21 * c / (ca+cb+cd+ce))
def j(e7, e7prb, e7p21):
return e7 - e7prb - e7p21
#Variable key
#y[0] = p14
#y[1] = Ink4
#y[2] = p21
#y[3] = p53
#y[4] = Rb
#y[5] = pRb-P
#y[6] = pRb-PP
#y[7] = E2F
#y[8] = mdm2
#y[9] = pMDM2
#y[10] = CD (Cyclin D/CDK4-6 complex)
#y[11] = CE (Cyclin E/CDK2 complex)
#y[12] = CA (Cyclin A/CDK2 complex)
#y[13] = CB (Cyclin B/CDK1 complex)
#y[14] = CDC20
#y[15] = E7-pRB
#y[16] = E7-p21
names = []
names.append("p14")
names.append("Ink4")
names.append("p21")
names.append("p53")
names.append("pRb")
names.append("pRb-P")
names.append("pRb-PP")
names.append("E2F")
names.append("mdm2")
names.append("pMDM2")
names.append("CD")
names.append("CE")
names.append("CA")
names.append("CB")
names.append("CDC20")
names.append("E7-pRB")
names.append("E7-p21")
#The derivative function for the differential equation system.
def func(y,t):
return [
#We have p14 being produced by E2F after inhibition from Rb
#is accounted for, and degraded at a constant rate.
alpha_p14 * theta_E2F * f(y[7], y[4], y[5]) - omega_p14 * y[0],
#It's just like the p14 equation, but with Ink4 instead!
alpha_Ink4 * theta_E2F * f(y[7], y[4], y[5]) - omega_Ink4 * y[1],
#Form p21 at a rate proportional to p53 presence; degrade it
#"naturally" or with help from Cyclin E/CDK2. E7 sequesters p21.
alpha_p21 * theta_p53 * y[3] - omega_p21 * y[2] - omega_p21CE * theta_CE * y[11] * y[2]/(y[2]+k_p21) - beta_E7p21 * j(E7(t),y[15],y[16]) * y[2] + delta_E7p21 * y[16],
#P53 is generated naturally at a constant rate, and degrades
#both on its own and with help from MDM2.
alpha_p53 - omega_p53 * y[3] - (omega_p53MDM2 * theta_MDM2 * g(y[9], y[0]) + omega_p53E6 * E6(t)) * y[3]/(y[3]+k_p53),
#Rb gets monophosphorylated by Cyclin D/CDK4-6. Rb-monophosphate
#gets its phosphate cleaved at a constant rate. Rb of all sorts
#gets sequestered by E7.
-epsilon_RbCD * theta_CD * y[4]/(y[4]+k_RbCD) * y[10] + sigma_Rb * y[5]/(y[5]+k_RbMP) - beta_E7pRB * j(E7(t),y[15],y[16]) * y[4] + delta_E7pRB * y[15] * y[4]/Rb_tot,
#Rb-monophosphate can be formed by phosphorylation of Rb or cleavage
#of Rb-polyphosphate. It can be lost by Cyclin E/CDK2 or
#phosphatase activity. Rb of all sorts gets sequestered by E7.
epsilon_RbCD * theta_CD * y[4]/(y[4]+k_RbCD) * y[10] - sigma_Rb * y[5]/(y[5]+k_RbMP) - epsilon_RbCE * theta_CE * y[5]/(y[5]+k_RbCE) * y[11] + sigma_Rb | E6 | identifier_name |
p21_sim.py | 693 #DUMMY
omega_MDM2 = 8.318 #DUMMY
omega_CD = 0.023 #DUMMY
omega_CDInk4 = 1 #DUMMY
omega_CE = 1 #DUMMY
omega_CA = 1 #DUMMY
omega_CACDC20 = 1 #DUMMY
omega_CB = 1 #DUMMY
omega_CBCDC20 = 1 #DUMMY
beta_E2FRb = 2 #DUMMY
beta_E2FRbMP = beta_E2FRb * 0.3 #DUMMY, but should be smaller than beta_E2FRb
beta_mdm2p14 = 1 #DUMMY
beta_cp21 = 1 #DUMMY
beta_E7p21 = 1 #DUMMY
beta_E7pRB = 1 #DUMMY
beta_E7pRBP = 1 #DUMMY
beta_E7pRBPP = 1 #DUMMY
delta_E7p21 = 1 #DUMMY
delta_E7pRB = 1 #DUMMY
epsilon_RbCD = 0.4 #DUMMY
epsilon_RbCE = 0.7 #DUMMY
epsilon_E2F = 20 #DUMMY
epsilon_CDC20 = 1 #DUMMY
sigma_Rb = 0.3 #DUMMY
sigma_RbMP = 0.1 #DUMMY
sigma_E2F = 0.7 #DUMMY
sigma_CDC20 = 1 #DUMMY
kappa_CECA = 1 #DUMMY
kappa_CBCA = 1 #DUMMY
#Knockdown terms. These should all be equal to 1 unless we're testing the
#effects of a knockdown.
theta_E2F = 1
theta_p53 = 1
theta_CE = 1
theta_MDM2 = 1
theta_CD = 1
theta_CA = 1
theta_Ink4 = 1
theta_CB = 1
theta_CDC20 = 1
k_p21 = 1
k_p53 = 1
k_RbMP = 1
k_RbPP = 1
k_RbCD = 1
k_RbCE = 1
k_E2FCA = 1
k_E2F = 1
k_CD = 1
k_CA = 1
k_CB = 1
k_CDC20CB = 1
k_CDC20 = 1
E2F_tot = 10 #DUMMY
CDC20_tot = 0.285
Rb_tot = 10 #DUMMY
#Potentially override parameters
for infile in infiles:
reader = open(infile)
for line in reader.readlines():
exec(line)
#Dummy initial conditions
y0 = [0.1,0.1,0.1,0.1,Rb_tot,0.0,0.0,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0,0]
#Abort early if the output directory already exists.
if dirname != "":
if os.path.exists(dirname):
sys.stderr.write("Output dir " + dirname + " already exists. Aborting.\n")
sys.exit(2)
#Functions to be called from the derivative functions.
def E6(t):
return 0 #dummy
def E7(t):
return 0 #dummy
#Fractions for inhibition/inactive complex formation.
#Each has a sanity check in case chief input is near zero.
sanity_threshold = 0.00001
def f(e2f, rb, rbmp):
if e2f < sanity_threshold:
return 0
return e2f**2 / (e2f + beta_E2FRb * rb + beta_E2FRbMP * rbmp)
def g(mdm2, p14):
if mdm2 < sanity_threshold:
return 0
return mdm2**2 / (mdm2 + beta_mdm2p14 * p14)
def h(c, p21, cd, ce, ca, cb):
if c < sanity_threshold:
return 0
if ca+cb+cd+ce < sanity_threshold:
return 0
return c**2 / (c + beta_cp21 * p21 * c / (ca+cb+cd+ce)) |
def j(e7, e7prb, e7p21):
return e7 - e7prb - e7p21
#Variable key
#y[0] = p14
#y[1] = Ink4
#y[2] = p21
#y[3] = p53
#y[4] = Rb
#y[5] = pRb-P
#y[6] = pRb-PP
#y[7] = E2F
#y[8] = mdm2
#y[9] = pMDM2
#y[10] = CD (Cyclin D/CDK4-6 complex)
#y[11] = CE (Cyclin E/CDK2 complex)
#y[12] = CA (Cyclin A/CDK2 complex)
#y[13] = CB (Cyclin B/CDK1 complex)
#y[14] = CDC20
#y[15] = E7-pRB
#y[16] = E7-p21
names = []
names.append("p14")
names.append("Ink4")
names.append("p21")
names.append("p53")
names.append("pRb")
names.append("pRb-P")
names.append("pRb-PP")
names.append("E2F")
names.append("mdm2")
names.append("pMDM2")
names.append("CD")
names.append("CE")
names.append("CA")
names.append("CB")
names.append("CDC20")
names.append("E7-pRB")
names.append("E7-p21")
#The derivative function for the differential equation system.
def func(y,t):
return [
#We have p14 being produced by E2F after inhibition from Rb
#is accounted for, and degraded at a constant rate.
alpha_p14 * theta_E2F * f(y[7], y[4], y[5]) - omega_p14 * y[0],
#It's just like the p14 equation, but with Ink4 instead!
alpha_Ink4 * theta_E2F * f(y[7], y[4], y[5]) - omega_Ink4 * y[1],
#Form p21 at a rate proportional to p53 presence; degrade it
#"naturally" or with help from Cyclin E/CDK2. E7 sequesters p21.
alpha_p21 * theta_p53 * y[3] - omega_p21 * y[2] - omega_p21CE * theta_CE * y[11] * y[2]/(y[2]+k_p21) - beta_E7p21 * j(E7(t),y[15],y[16]) * y[2] + delta_E7p21 * y[16],
#P53 is generated naturally at a constant rate, and degrades
#both on its own and with help from MDM2.
alpha_p53 - omega_p53 * y[3] - (omega_p53MDM2 * theta_MDM2 * g(y[9], y[0]) + omega_p53E6 * E6(t)) * y[3]/(y[3]+k_p53),
#Rb gets monophosphorylated by Cyclin D/CDK4-6. Rb-monophosphate
#gets its phosphate cleaved at a constant rate. Rb of all sorts
#gets sequestered by E7.
-epsilon_RbCD * theta_CD * y[4]/(y[4]+k_RbCD) * y[10] + sigma_Rb * y[5]/(y[5]+k_RbMP) - beta_E7pRB * j(E7(t),y[15],y[16]) * y[4] + delta_E7pRB * y[15] * y[4]/Rb_tot,
#Rb-monophosphate can be formed by phosphorylation of Rb or cleavage
#of Rb-polyphosphate. It can be lost by Cyclin E/CDK2 or
#phosphatase activity. Rb of all sorts gets sequestered by E7.
epsilon_RbCD * theta_CD * y[4]/(y[4]+k_RbCD) * y[10] - sigma_Rb * y[5]/(y[5]+k_RbMP) - epsilon_RbCE * theta_CE * y[5]/(y[5]+k_RbCE) * y[11] + sigma_Rb | random_line_split | |
p21_sim.py | .693 #DUMMY
omega_MDM2 = 8.318 #DUMMY
omega_CD = 0.023 #DUMMY
omega_CDInk4 = 1 #DUMMY
omega_CE = 1 #DUMMY
omega_CA = 1 #DUMMY
omega_CACDC20 = 1 #DUMMY
omega_CB = 1 #DUMMY
omega_CBCDC20 = 1 #DUMMY
beta_E2FRb = 2 #DUMMY
beta_E2FRbMP = beta_E2FRb * 0.3 #DUMMY, but should be smaller than beta_E2FRb
beta_mdm2p14 = 1 #DUMMY
beta_cp21 = 1 #DUMMY
beta_E7p21 = 1 #DUMMY
beta_E7pRB = 1 #DUMMY
beta_E7pRBP = 1 #DUMMY
beta_E7pRBPP = 1 #DUMMY
delta_E7p21 = 1 #DUMMY
delta_E7pRB = 1 #DUMMY
epsilon_RbCD = 0.4 #DUMMY
epsilon_RbCE = 0.7 #DUMMY
epsilon_E2F = 20 #DUMMY
epsilon_CDC20 = 1 #DUMMY
sigma_Rb = 0.3 #DUMMY
sigma_RbMP = 0.1 #DUMMY
sigma_E2F = 0.7 #DUMMY
sigma_CDC20 = 1 #DUMMY
kappa_CECA = 1 #DUMMY
kappa_CBCA = 1 #DUMMY
#Knockdown terms. These should all be equal to 1 unless we're testing the
#effects of a knockdown.
theta_E2F = 1
theta_p53 = 1
theta_CE = 1
theta_MDM2 = 1
theta_CD = 1
theta_CA = 1
theta_Ink4 = 1
theta_CB = 1
theta_CDC20 = 1
k_p21 = 1
k_p53 = 1
k_RbMP = 1
k_RbPP = 1
k_RbCD = 1
k_RbCE = 1
k_E2FCA = 1
k_E2F = 1
k_CD = 1
k_CA = 1
k_CB = 1
k_CDC20CB = 1
k_CDC20 = 1
E2F_tot = 10 #DUMMY
CDC20_tot = 0.285
Rb_tot = 10 #DUMMY
#Potentially override parameters
for infile in infiles:
reader = open(infile)
for line in reader.readlines():
exec(line)
#Dummy initial conditions
y0 = [0.1,0.1,0.1,0.1,Rb_tot,0.0,0.0,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0,0]
#Abort early if the output directory already exists.
if dirname != "":
if os.path.exists(dirname):
sys.stderr.write("Output dir " + dirname + " already exists. Aborting.\n")
sys.exit(2)
#Functions to be called from the derivative functions.
def E6(t):
return 0 #dummy
def E7(t):
return 0 #dummy
#Fractions for inhibition/inactive complex formation.
#Each has a sanity check in case chief input is near zero.
sanity_threshold = 0.00001
def f(e2f, rb, rbmp):
if e2f < sanity_threshold:
|
return e2f**2 / (e2f + beta_E2FRb * rb + beta_E2FRbMP * rbmp)
def g(mdm2, p14):
if mdm2 < sanity_threshold:
return 0
return mdm2**2 / (mdm2 + beta_mdm2p14 * p14)
def h(c, p21, cd, ce, ca, cb):
if c < sanity_threshold:
return 0
if ca+cb+cd+ce < sanity_threshold:
return 0
return c**2 / (c + beta_cp21 * p21 * c / (ca+cb+cd+ce))
def j(e7, e7prb, e7p21):
return e7 - e7prb - e7p21
#Variable key
#y[0] = p14
#y[1] = Ink4
#y[2] = p21
#y[3] = p53
#y[4] = Rb
#y[5] = pRb-P
#y[6] = pRb-PP
#y[7] = E2F
#y[8] = mdm2
#y[9] = pMDM2
#y[10] = CD (Cyclin D/CDK4-6 complex)
#y[11] = CE (Cyclin E/CDK2 complex)
#y[12] = CA (Cyclin A/CDK2 complex)
#y[13] = CB (Cyclin B/CDK1 complex)
#y[14] = CDC20
#y[15] = E7-pRB
#y[16] = E7-p21
names = []
names.append("p14")
names.append("Ink4")
names.append("p21")
names.append("p53")
names.append("pRb")
names.append("pRb-P")
names.append("pRb-PP")
names.append("E2F")
names.append("mdm2")
names.append("pMDM2")
names.append("CD")
names.append("CE")
names.append("CA")
names.append("CB")
names.append("CDC20")
names.append("E7-pRB")
names.append("E7-p21")
#The derivative function for the differential equation system.
def func(y,t):
return [
#We have p14 being produced by E2F after inhibition from Rb
#is accounted for, and degraded at a constant rate.
alpha_p14 * theta_E2F * f(y[7], y[4], y[5]) - omega_p14 * y[0],
#It's just like the p14 equation, but with Ink4 instead!
alpha_Ink4 * theta_E2F * f(y[7], y[4], y[5]) - omega_Ink4 * y[1],
#Form p21 at a rate proportional to p53 presence; degrade it
#"naturally" or with help from Cyclin E/CDK2. E7 sequesters p21.
alpha_p21 * theta_p53 * y[3] - omega_p21 * y[2] - omega_p21CE * theta_CE * y[11] * y[2]/(y[2]+k_p21) - beta_E7p21 * j(E7(t),y[15],y[16]) * y[2] + delta_E7p21 * y[16],
#P53 is generated naturally at a constant rate, and degrades
#both on its own and with help from MDM2.
alpha_p53 - omega_p53 * y[3] - (omega_p53MDM2 * theta_MDM2 * g(y[9], y[0]) + omega_p53E6 * E6(t)) * y[3]/(y[3]+k_p53),
#Rb gets monophosphorylated by Cyclin D/CDK4-6. Rb-monophosphate
#gets its phosphate cleaved at a constant rate. Rb of all sorts
#gets sequestered by E7.
-epsilon_RbCD * theta_CD * y[4]/(y[4]+k_RbCD) * y[10] + sigma_Rb * y[5]/(y[5]+k_RbMP) - beta_E7pRB * j(E7(t),y[15],y[16]) * y[4] + delta_E7pRB * y[15] * y[4]/Rb_tot,
#Rb-monophosphate can be formed by phosphorylation of Rb or cleavage
#of Rb-polyphosphate. It can be lost by Cyclin E/CDK2 or
#phosphatase activity. Rb of all sorts gets sequestered by E7.
epsilon_RbCD * theta_CD * y[4]/(y[4]+k_RbCD) * y[10] - sigma_Rb * y[5]/(y[5]+k_RbMP) - epsilon_RbCE * theta_CE * y[5]/(y[5]+k_RbCE) * y[11] + sigma_Rb | return 0 | conditional_block |
p21_sim.py | 693 #DUMMY
omega_MDM2 = 8.318 #DUMMY
omega_CD = 0.023 #DUMMY
omega_CDInk4 = 1 #DUMMY
omega_CE = 1 #DUMMY
omega_CA = 1 #DUMMY
omega_CACDC20 = 1 #DUMMY
omega_CB = 1 #DUMMY
omega_CBCDC20 = 1 #DUMMY
beta_E2FRb = 2 #DUMMY
beta_E2FRbMP = beta_E2FRb * 0.3 #DUMMY, but should be smaller than beta_E2FRb
beta_mdm2p14 = 1 #DUMMY
beta_cp21 = 1 #DUMMY
beta_E7p21 = 1 #DUMMY
beta_E7pRB = 1 #DUMMY
beta_E7pRBP = 1 #DUMMY
beta_E7pRBPP = 1 #DUMMY
delta_E7p21 = 1 #DUMMY
delta_E7pRB = 1 #DUMMY
epsilon_RbCD = 0.4 #DUMMY
epsilon_RbCE = 0.7 #DUMMY
epsilon_E2F = 20 #DUMMY
epsilon_CDC20 = 1 #DUMMY
sigma_Rb = 0.3 #DUMMY
sigma_RbMP = 0.1 #DUMMY
sigma_E2F = 0.7 #DUMMY
sigma_CDC20 = 1 #DUMMY
kappa_CECA = 1 #DUMMY
kappa_CBCA = 1 #DUMMY
#Knockdown terms. These should all be equal to 1 unless we're testing the
#effects of a knockdown.
theta_E2F = 1
theta_p53 = 1
theta_CE = 1
theta_MDM2 = 1
theta_CD = 1
theta_CA = 1
theta_Ink4 = 1
theta_CB = 1
theta_CDC20 = 1
k_p21 = 1
k_p53 = 1
k_RbMP = 1
k_RbPP = 1
k_RbCD = 1
k_RbCE = 1
k_E2FCA = 1
k_E2F = 1
k_CD = 1
k_CA = 1
k_CB = 1
k_CDC20CB = 1
k_CDC20 = 1
E2F_tot = 10 #DUMMY
CDC20_tot = 0.285
Rb_tot = 10 #DUMMY
#Potentially override parameters
for infile in infiles:
reader = open(infile)
for line in reader.readlines():
exec(line)
#Dummy initial conditions
y0 = [0.1,0.1,0.1,0.1,Rb_tot,0.0,0.0,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0,0]
#Abort early if the output directory already exists.
if dirname != "":
if os.path.exists(dirname):
sys.stderr.write("Output dir " + dirname + " already exists. Aborting.\n")
sys.exit(2)
#Functions to be called from the derivative functions.
def E6(t):
return 0 #dummy
def E7(t):
return 0 #dummy
#Fractions for inhibition/inactive complex formation.
#Each has a sanity check in case chief input is near zero.
sanity_threshold = 0.00001
def f(e2f, rb, rbmp):
if e2f < sanity_threshold:
return 0
return e2f**2 / (e2f + beta_E2FRb * rb + beta_E2FRbMP * rbmp)
def g(mdm2, p14):
if mdm2 < sanity_threshold:
return 0
return mdm2**2 / (mdm2 + beta_mdm2p14 * p14)
def h(c, p21, cd, ce, ca, cb):
|
def j(e7, e7prb, e7p21):
return e7 - e7prb - e7p21
#Variable key
#y[0] = p14
#y[1] = Ink4
#y[2] = p21
#y[3] = p53
#y[4] = Rb
#y[5] = pRb-P
#y[6] = pRb-PP
#y[7] = E2F
#y[8] = mdm2
#y[9] = pMDM2
#y[10] = CD (Cyclin D/CDK4-6 complex)
#y[11] = CE (Cyclin E/CDK2 complex)
#y[12] = CA (Cyclin A/CDK2 complex)
#y[13] = CB (Cyclin B/CDK1 complex)
#y[14] = CDC20
#y[15] = E7-pRB
#y[16] = E7-p21
names = []
names.append("p14")
names.append("Ink4")
names.append("p21")
names.append("p53")
names.append("pRb")
names.append("pRb-P")
names.append("pRb-PP")
names.append("E2F")
names.append("mdm2")
names.append("pMDM2")
names.append("CD")
names.append("CE")
names.append("CA")
names.append("CB")
names.append("CDC20")
names.append("E7-pRB")
names.append("E7-p21")
#The derivative function for the differential equation system.
def func(y,t):
return [
#We have p14 being produced by E2F after inhibition from Rb
#is accounted for, and degraded at a constant rate.
alpha_p14 * theta_E2F * f(y[7], y[4], y[5]) - omega_p14 * y[0],
#It's just like the p14 equation, but with Ink4 instead!
alpha_Ink4 * theta_E2F * f(y[7], y[4], y[5]) - omega_Ink4 * y[1],
#Form p21 at a rate proportional to p53 presence; degrade it
#"naturally" or with help from Cyclin E/CDK2. E7 sequesters p21.
alpha_p21 * theta_p53 * y[3] - omega_p21 * y[2] - omega_p21CE * theta_CE * y[11] * y[2]/(y[2]+k_p21) - beta_E7p21 * j(E7(t),y[15],y[16]) * y[2] + delta_E7p21 * y[16],
#P53 is generated naturally at a constant rate, and degrades
#both on its own and with help from MDM2.
alpha_p53 - omega_p53 * y[3] - (omega_p53MDM2 * theta_MDM2 * g(y[9], y[0]) + omega_p53E6 * E6(t)) * y[3]/(y[3]+k_p53),
#Rb gets monophosphorylated by Cyclin D/CDK4-6. Rb-monophosphate
#gets its phosphate cleaved at a constant rate. Rb of all sorts
#gets sequestered by E7.
-epsilon_RbCD * theta_CD * y[4]/(y[4]+k_RbCD) * y[10] + sigma_Rb * y[5]/(y[5]+k_RbMP) - beta_E7pRB * j(E7(t),y[15],y[16]) * y[4] + delta_E7pRB * y[15] * y[4]/Rb_tot,
#Rb-monophosphate can be formed by phosphorylation of Rb or cleavage
#of Rb-polyphosphate. It can be lost by Cyclin E/CDK2 or
#phosphatase activity. Rb of all sorts gets sequestered by E7.
epsilon_RbCD * theta_CD * y[4]/(y[4]+k_RbCD) * y[10] - sigma_Rb * y[5]/(y[5]+k_RbMP) - epsilon_RbCE * theta_CE * y[5]/(y[5]+k_RbCE) * y[11] + sigma_Rb | if c < sanity_threshold:
return 0
if ca+cb+cd+ce < sanity_threshold:
return 0
return c**2 / (c + beta_cp21 * p21 * c / (ca+cb+cd+ce)) | identifier_body |
yaml.ts | instanceof type)) {
this._index = Number.MIN_SAFE_INTEGER;
}
}
return this as unknown as AncestryBuilder<X>;
}
/**
* Move up the path, asserting that the current node was a key of a mapping
* pair. The builder skips over the Pair to the parent YAMLMap.
*/
parentOfKey(): AncestryBuilder<YAMLMap> {
const node = this.get();
this.parent(Pair);
const pairNode = this.get();
if (pairNode instanceof Pair && pairNode.key === node) {
this.parent(YAMLMap);
} else {
this._index = Number.MIN_SAFE_INTEGER;
}
return this as unknown as AncestryBuilder<YAMLMap>;
}
/**
* Get node up to which the assertions have led.
*/
get(): N | null {
return (this._path[this._index] as N) || null;
}
/**
* Get the key of the Pair one level down the path.
*
* The key is returned only if it indeed is a string Scalar.
*/
// The `this` argument is for generics restriction of this method.
getStringKey(this: AncestryBuilder<YAMLMap>): string | null {
const node = this._path[this._index + 1];
if (
node instanceof Pair &&
node.key instanceof Scalar &&
typeof node.key.value === 'string'
) {
return node.key.value;
}
return null;
}
/**
* Get the value of the Pair one level down the path.
*/
// The `this` argument is for generics restriction of this method.
getValue(this: AncestryBuilder<YAMLMap>): Node | null {
const node = this._path[this._index + 1];
if (node instanceof Pair) {
return node.value;
}
return null;
}
/**
* Get the path to which the assertions have led.
*
* The path will be a subpath of the original path.
*/
getPath(): Node[] | null {
if (this._index < 0) return null;
const path = this._path.slice(0, this._index + 1);
return path;
}
/**
* Get the path to the key of the Pair one level down the path to which the
* assertions have led.
*
* The path will be a subpath of the original path.
*/
// The `this` argument is for generics restriction of this method.
getKeyPath(this: AncestryBuilder<YAMLMap>): Node[] | null {
if (this._index < 0) return null;
const path = this._path.slice(0, this._index + 1);
const node = this._path[this._index + 1];
if (node instanceof Pair) {
path.push(node);
path.push(node.key);
return path;
}
return null;
}
}
export function getPathAt(
document: TextDocument,
position: Position,
docs: Document[],
inclusive = false
): Node[] | null {
const offset = document.offsetAt(position);
const doc = _.find(docs, (d) => contains(d.contents, offset, inclusive));
if (doc && doc.contents) {
return getPathAtOffset([doc.contents], offset, inclusive);
}
return null;
}
export function contains(
node: Node | null,
offset: number,
inclusive: boolean
): boolean {
const range = getOrigRange(node);
return !!(
range &&
range[0] <= offset &&
(range[1] > offset || (inclusive && range[1] >= offset))
);
}
export function getPathAtOffset(
path: Node[],
offset: number,
inclusive: boolean
): Node[] | null {
if (path) {
const currentNode = path[path.length - 1];
if (currentNode instanceof YAMLMap) {
let pair = _.find(currentNode.items, (p) =>
contains(p.key, offset, inclusive)
);
if (pair) {
return getPathAtOffset(path.concat(pair, pair.key), offset, inclusive);
}
pair = _.find(currentNode.items, (p) =>
contains(p.value, offset, inclusive)
);
if (pair) {
return getPathAtOffset(
path.concat(pair, pair.value),
offset,
inclusive
);
}
pair = _.find(currentNode.items, (p) => {
const inBetweenNode = new Node();
const start = getOrigRange(p.key as Node)?.[1];
const end = getOrigRange(p.value as Node)?.[0];
if (start && end) {
inBetweenNode.range = [start, end - 1];
return contains(inBetweenNode, offset, inclusive);
} else return false;
});
if (pair) {
return path.concat(pair, new Node());
}
} else if (currentNode instanceof YAMLSeq) {
const item = _.find(currentNode.items, (n) =>
contains(n, offset, inclusive)
);
if (item) {
return getPathAtOffset(path.concat(item), offset, inclusive);
}
} else if (contains(currentNode, offset, inclusive)) {
return path;
}
return path.concat(new Node()); // empty node as indentation marker
}
return null;
}
export const tasksKey = /^(tasks|pre_tasks|post_tasks|block|rescue|always)$/;
/**
* Determines whether the path points at a parameter key of an Ansible task.
*/
export function isTaskParam(path: Node[]): boolean {
const taskListPath = new AncestryBuilder(path)
.parentOfKey()
.parent(YAMLSeq)
.getPath();
if (taskListPath) {
// basic shape of the task list has been found
if (isPlayParam(path) || isBlockParam(path) || isRoleParam(path))
return false;
if (taskListPath.length === 1) {
// case when the task list is at the top level of the document
return true;
}
const taskListKey = new AncestryBuilder(taskListPath)
.parent(YAMLMap)
.getStringKey();
if (taskListKey && tasksKey.test(taskListKey)) {
// case when a task list is defined explicitly by a keyword
return true;
}
}
return false;
}
/**
* Tries to find the list of collections declared at the Ansible play/block/task level.
*/
export function getDeclaredCollections(modulePath: Node[] | null): string[] {
const declaredCollections: string[] = [];
const taskParamsNode = new AncestryBuilder(modulePath).parent(YAMLMap).get();
declaredCollections.push(...getDeclaredCollectionsForMap(taskParamsNode));
let path: Node[] | null = new AncestryBuilder(modulePath)
.parent(YAMLMap)
.getPath();
while (true) {
// traverse the YAML up through the Ansible blocks
const builder = new AncestryBuilder(path).parent(YAMLSeq).parent(YAMLMap);
const key = builder.getStringKey();
if (key && /^block|rescue|always$/.test(key)) {
declaredCollections.push(...getDeclaredCollectionsForMap(builder.get()));
path = builder.getPath();
} else {
break;
}
}
// now we should be at the tasks/pre_tasks/post_tasks level
const playParamsNode = new AncestryBuilder(path)
.parent(YAMLSeq)
.parent(YAMLMap)
.get();
declaredCollections.push(...getDeclaredCollectionsForMap(playParamsNode));
return [...new Set(declaredCollections)]; // deduplicate
}
function getDeclaredCollectionsForMap(playNode: YAMLMap | null): string[] {
const declaredCollections: string[] = [];
const collectionsPair = _.find(
playNode?.items,
(pair) => pair.key instanceof Scalar && pair.key.value === 'collections'
);
if (collectionsPair) {
// we've found the collections declaration
const collectionsNode = collectionsPair.value;
if (collectionsNode instanceof YAMLSeq) {
for (const collectionNode of collectionsNode.items) {
if (collectionNode instanceof Scalar) {
declaredCollections.push(collectionNode.value);
}
}
}
}
return declaredCollections;
}
/**
* Heuristically determines whether the path points at an Ansible play. The
* `fileUri` helps guessing in case the YAML tree doesn't give any clues.
*
* Returns `undefined` if highly uncertain.
*/
export function isPlayParam(
path: Node[],
fileUri?: string
): boolean | undefined {
const isAtRoot =
new AncestryBuilder(path).parentOfKey().parent(YAMLSeq).getPath()
?.length === 1;
if (isAtRoot) {
const mapNode = new AncestryBuilder(path).parentOfKey().get() as YAMLMap;
const providedKeys = getYamlMapKeys(mapNode);
const containsPlayKeyword = providedKeys.some((p) =>
playExclusiveKeywords.has(p)
);
if (containsPlayKeyword) {
return true;
}
if (fileUri) {
const isInRole = /\/roles\/[^/]+\/tasks\//.test(fileUri);
if (isInRole) {
return false;
}
}
} else | {
return false;
} | conditional_block | |
yaml.ts | this._index--;
}
}
if (type) {
if (!(this.get() instanceof type)) {
this._index = Number.MIN_SAFE_INTEGER;
}
}
return this as unknown as AncestryBuilder<X>;
}
/**
* Move up the path, asserting that the current node was a key of a mapping
* pair. The builder skips over the Pair to the parent YAMLMap.
*/
parentOfKey(): AncestryBuilder<YAMLMap> {
const node = this.get();
this.parent(Pair);
const pairNode = this.get();
if (pairNode instanceof Pair && pairNode.key === node) {
this.parent(YAMLMap);
} else {
this._index = Number.MIN_SAFE_INTEGER;
}
return this as unknown as AncestryBuilder<YAMLMap>;
}
/**
* Get node up to which the assertions have led.
*/
get(): N | null {
return (this._path[this._index] as N) || null;
}
/**
* Get the key of the Pair one level down the path.
*
* The key is returned only if it indeed is a string Scalar.
*/
// The `this` argument is for generics restriction of this method.
getStringKey(this: AncestryBuilder<YAMLMap>): string | null {
const node = this._path[this._index + 1];
if (
node instanceof Pair &&
node.key instanceof Scalar &&
typeof node.key.value === 'string'
) {
return node.key.value;
}
return null;
}
/**
* Get the value of the Pair one level down the path.
*/
// The `this` argument is for generics restriction of this method.
getValue(this: AncestryBuilder<YAMLMap>): Node | null {
const node = this._path[this._index + 1];
if (node instanceof Pair) {
return node.value;
}
return null;
}
/**
* Get the path to which the assertions have led.
*
* The path will be a subpath of the original path.
*/
getPath(): Node[] | null |
/**
* Get the path to the key of the Pair one level down the path to which the
* assertions have led.
*
* The path will be a subpath of the original path.
*/
// The `this` argument is for generics restriction of this method.
getKeyPath(this: AncestryBuilder<YAMLMap>): Node[] | null {
if (this._index < 0) return null;
const path = this._path.slice(0, this._index + 1);
const node = this._path[this._index + 1];
if (node instanceof Pair) {
path.push(node);
path.push(node.key);
return path;
}
return null;
}
}
export function getPathAt(
document: TextDocument,
position: Position,
docs: Document[],
inclusive = false
): Node[] | null {
const offset = document.offsetAt(position);
const doc = _.find(docs, (d) => contains(d.contents, offset, inclusive));
if (doc && doc.contents) {
return getPathAtOffset([doc.contents], offset, inclusive);
}
return null;
}
export function contains(
node: Node | null,
offset: number,
inclusive: boolean
): boolean {
const range = getOrigRange(node);
return !!(
range &&
range[0] <= offset &&
(range[1] > offset || (inclusive && range[1] >= offset))
);
}
export function getPathAtOffset(
path: Node[],
offset: number,
inclusive: boolean
): Node[] | null {
if (path) {
const currentNode = path[path.length - 1];
if (currentNode instanceof YAMLMap) {
let pair = _.find(currentNode.items, (p) =>
contains(p.key, offset, inclusive)
);
if (pair) {
return getPathAtOffset(path.concat(pair, pair.key), offset, inclusive);
}
pair = _.find(currentNode.items, (p) =>
contains(p.value, offset, inclusive)
);
if (pair) {
return getPathAtOffset(
path.concat(pair, pair.value),
offset,
inclusive
);
}
pair = _.find(currentNode.items, (p) => {
const inBetweenNode = new Node();
const start = getOrigRange(p.key as Node)?.[1];
const end = getOrigRange(p.value as Node)?.[0];
if (start && end) {
inBetweenNode.range = [start, end - 1];
return contains(inBetweenNode, offset, inclusive);
} else return false;
});
if (pair) {
return path.concat(pair, new Node());
}
} else if (currentNode instanceof YAMLSeq) {
const item = _.find(currentNode.items, (n) =>
contains(n, offset, inclusive)
);
if (item) {
return getPathAtOffset(path.concat(item), offset, inclusive);
}
} else if (contains(currentNode, offset, inclusive)) {
return path;
}
return path.concat(new Node()); // empty node as indentation marker
}
return null;
}
export const tasksKey = /^(tasks|pre_tasks|post_tasks|block|rescue|always)$/;
/**
* Determines whether the path points at a parameter key of an Ansible task.
*/
export function isTaskParam(path: Node[]): boolean {
const taskListPath = new AncestryBuilder(path)
.parentOfKey()
.parent(YAMLSeq)
.getPath();
if (taskListPath) {
// basic shape of the task list has been found
if (isPlayParam(path) || isBlockParam(path) || isRoleParam(path))
return false;
if (taskListPath.length === 1) {
// case when the task list is at the top level of the document
return true;
}
const taskListKey = new AncestryBuilder(taskListPath)
.parent(YAMLMap)
.getStringKey();
if (taskListKey && tasksKey.test(taskListKey)) {
// case when a task list is defined explicitly by a keyword
return true;
}
}
return false;
}
/**
* Tries to find the list of collections declared at the Ansible play/block/task level.
*/
export function getDeclaredCollections(modulePath: Node[] | null): string[] {
const declaredCollections: string[] = [];
const taskParamsNode = new AncestryBuilder(modulePath).parent(YAMLMap).get();
declaredCollections.push(...getDeclaredCollectionsForMap(taskParamsNode));
let path: Node[] | null = new AncestryBuilder(modulePath)
.parent(YAMLMap)
.getPath();
while (true) {
// traverse the YAML up through the Ansible blocks
const builder = new AncestryBuilder(path).parent(YAMLSeq).parent(YAMLMap);
const key = builder.getStringKey();
if (key && /^block|rescue|always$/.test(key)) {
declaredCollections.push(...getDeclaredCollectionsForMap(builder.get()));
path = builder.getPath();
} else {
break;
}
}
// now we should be at the tasks/pre_tasks/post_tasks level
const playParamsNode = new AncestryBuilder(path)
.parent(YAMLSeq)
.parent(YAMLMap)
.get();
declaredCollections.push(...getDeclaredCollectionsForMap(playParamsNode));
return [...new Set(declaredCollections)]; // deduplicate
}
function getDeclaredCollectionsForMap(playNode: YAMLMap | null): string[] {
const declaredCollections: string[] = [];
const collectionsPair = _.find(
playNode?.items,
(pair) => pair.key instanceof Scalar && pair.key.value === 'collections'
);
if (collectionsPair) {
// we've found the collections declaration
const collectionsNode = collectionsPair.value;
if (collectionsNode instanceof YAMLSeq) {
for (const collectionNode of collectionsNode.items) {
if (collectionNode instanceof Scalar) {
declaredCollections.push(collectionNode.value);
}
}
}
}
return declaredCollections;
}
/**
* Heuristically determines whether the path points at an Ansible play. The
* `fileUri` helps guessing in case the YAML tree doesn't give any clues.
*
* Returns `undefined` if highly uncertain.
*/
export function isPlayParam(
path: Node[],
fileUri?: string
): boolean | undefined {
const isAtRoot =
new AncestryBuilder(path).parentOfKey().parent(YAMLSeq).getPath()
?.length === 1;
if (isAtRoot) {
const mapNode = new AncestryBuilder(path).parentOfKey().get() as YAMLMap;
const providedKeys = getYamlMapKeys(mapNode);
const containsPlayKeyword = providedKeys.some((p) =>
playExclusiveKeywords.has(p)
);
if (containsPlayKeyword) {
return true;
}
if (fileUri) {
const isInRole = /\/roles\/[^/]+\/tasks\//.test(fileUri);
if (is | {
if (this._index < 0) return null;
const path = this._path.slice(0, this._index + 1);
return path;
} | identifier_body |
yaml.ts | this._index--;
}
}
if (type) {
if (!(this.get() instanceof type)) {
this._index = Number.MIN_SAFE_INTEGER;
}
}
return this as unknown as AncestryBuilder<X>;
}
/**
* Move up the path, asserting that the current node was a key of a mapping
* pair. The builder skips over the Pair to the parent YAMLMap.
*/
parentOfKey(): AncestryBuilder<YAMLMap> {
const node = this.get();
this.parent(Pair);
const pairNode = this.get();
if (pairNode instanceof Pair && pairNode.key === node) {
this.parent(YAMLMap);
} else {
this._index = Number.MIN_SAFE_INTEGER;
}
return this as unknown as AncestryBuilder<YAMLMap>;
}
/**
* Get node up to which the assertions have led.
*/
get(): N | null {
return (this._path[this._index] as N) || null;
}
/**
* Get the key of the Pair one level down the path.
*
* The key is returned only if it indeed is a string Scalar.
*/
// The `this` argument is for generics restriction of this method.
getStringKey(this: AncestryBuilder<YAMLMap>): string | null {
const node = this._path[this._index + 1];
if (
node instanceof Pair &&
node.key instanceof Scalar &&
typeof node.key.value === 'string'
) {
return node.key.value;
}
return null;
}
/**
* Get the value of the Pair one level down the path.
*/
// The `this` argument is for generics restriction of this method.
getValue(this: AncestryBuilder<YAMLMap>): Node | null {
const node = this._path[this._index + 1];
if (node instanceof Pair) {
return node.value;
} |
/**
* Get the path to which the assertions have led.
*
* The path will be a subpath of the original path.
*/
getPath(): Node[] | null {
if (this._index < 0) return null;
const path = this._path.slice(0, this._index + 1);
return path;
}
/**
* Get the path to the key of the Pair one level down the path to which the
* assertions have led.
*
* The path will be a subpath of the original path.
*/
// The `this` argument is for generics restriction of this method.
getKeyPath(this: AncestryBuilder<YAMLMap>): Node[] | null {
if (this._index < 0) return null;
const path = this._path.slice(0, this._index + 1);
const node = this._path[this._index + 1];
if (node instanceof Pair) {
path.push(node);
path.push(node.key);
return path;
}
return null;
}
}
export function getPathAt(
document: TextDocument,
position: Position,
docs: Document[],
inclusive = false
): Node[] | null {
const offset = document.offsetAt(position);
const doc = _.find(docs, (d) => contains(d.contents, offset, inclusive));
if (doc && doc.contents) {
return getPathAtOffset([doc.contents], offset, inclusive);
}
return null;
}
export function contains(
node: Node | null,
offset: number,
inclusive: boolean
): boolean {
const range = getOrigRange(node);
return !!(
range &&
range[0] <= offset &&
(range[1] > offset || (inclusive && range[1] >= offset))
);
}
export function getPathAtOffset(
path: Node[],
offset: number,
inclusive: boolean
): Node[] | null {
if (path) {
const currentNode = path[path.length - 1];
if (currentNode instanceof YAMLMap) {
let pair = _.find(currentNode.items, (p) =>
contains(p.key, offset, inclusive)
);
if (pair) {
return getPathAtOffset(path.concat(pair, pair.key), offset, inclusive);
}
pair = _.find(currentNode.items, (p) =>
contains(p.value, offset, inclusive)
);
if (pair) {
return getPathAtOffset(
path.concat(pair, pair.value),
offset,
inclusive
);
}
pair = _.find(currentNode.items, (p) => {
const inBetweenNode = new Node();
const start = getOrigRange(p.key as Node)?.[1];
const end = getOrigRange(p.value as Node)?.[0];
if (start && end) {
inBetweenNode.range = [start, end - 1];
return contains(inBetweenNode, offset, inclusive);
} else return false;
});
if (pair) {
return path.concat(pair, new Node());
}
} else if (currentNode instanceof YAMLSeq) {
const item = _.find(currentNode.items, (n) =>
contains(n, offset, inclusive)
);
if (item) {
return getPathAtOffset(path.concat(item), offset, inclusive);
}
} else if (contains(currentNode, offset, inclusive)) {
return path;
}
return path.concat(new Node()); // empty node as indentation marker
}
return null;
}
export const tasksKey = /^(tasks|pre_tasks|post_tasks|block|rescue|always)$/;
/**
* Determines whether the path points at a parameter key of an Ansible task.
*/
export function isTaskParam(path: Node[]): boolean {
const taskListPath = new AncestryBuilder(path)
.parentOfKey()
.parent(YAMLSeq)
.getPath();
if (taskListPath) {
// basic shape of the task list has been found
if (isPlayParam(path) || isBlockParam(path) || isRoleParam(path))
return false;
if (taskListPath.length === 1) {
// case when the task list is at the top level of the document
return true;
}
const taskListKey = new AncestryBuilder(taskListPath)
.parent(YAMLMap)
.getStringKey();
if (taskListKey && tasksKey.test(taskListKey)) {
// case when a task list is defined explicitly by a keyword
return true;
}
}
return false;
}
/**
* Tries to find the list of collections declared at the Ansible play/block/task level.
*/
export function getDeclaredCollections(modulePath: Node[] | null): string[] {
const declaredCollections: string[] = [];
const taskParamsNode = new AncestryBuilder(modulePath).parent(YAMLMap).get();
declaredCollections.push(...getDeclaredCollectionsForMap(taskParamsNode));
let path: Node[] | null = new AncestryBuilder(modulePath)
.parent(YAMLMap)
.getPath();
while (true) {
// traverse the YAML up through the Ansible blocks
const builder = new AncestryBuilder(path).parent(YAMLSeq).parent(YAMLMap);
const key = builder.getStringKey();
if (key && /^block|rescue|always$/.test(key)) {
declaredCollections.push(...getDeclaredCollectionsForMap(builder.get()));
path = builder.getPath();
} else {
break;
}
}
// now we should be at the tasks/pre_tasks/post_tasks level
const playParamsNode = new AncestryBuilder(path)
.parent(YAMLSeq)
.parent(YAMLMap)
.get();
declaredCollections.push(...getDeclaredCollectionsForMap(playParamsNode));
return [...new Set(declaredCollections)]; // deduplicate
}
function getDeclaredCollectionsForMap(playNode: YAMLMap | null): string[] {
const declaredCollections: string[] = [];
const collectionsPair = _.find(
playNode?.items,
(pair) => pair.key instanceof Scalar && pair.key.value === 'collections'
);
if (collectionsPair) {
// we've found the collections declaration
const collectionsNode = collectionsPair.value;
if (collectionsNode instanceof YAMLSeq) {
for (const collectionNode of collectionsNode.items) {
if (collectionNode instanceof Scalar) {
declaredCollections.push(collectionNode.value);
}
}
}
}
return declaredCollections;
}
/**
* Heuristically determines whether the path points at an Ansible play. The
* `fileUri` helps guessing in case the YAML tree doesn't give any clues.
*
* Returns `undefined` if highly uncertain.
*/
export function isPlayParam(
path: Node[],
fileUri?: string
): boolean | undefined {
const isAtRoot =
new AncestryBuilder(path).parentOfKey().parent(YAMLSeq).getPath()
?.length === 1;
if (isAtRoot) {
const mapNode = new AncestryBuilder(path).parentOfKey().get() as YAMLMap;
const providedKeys = getYamlMapKeys(mapNode);
const containsPlayKeyword = providedKeys.some((p) =>
playExclusiveKeywords.has(p)
);
if (containsPlayKeyword) {
return true;
}
if (fileUri) {
const isInRole = /\/roles\/[^/]+\/tasks\//.test(fileUri);
if (isIn | return null;
} | random_line_split |
yaml.ts | this._index--;
}
}
if (type) {
if (!(this.get() instanceof type)) {
this._index = Number.MIN_SAFE_INTEGER;
}
}
return this as unknown as AncestryBuilder<X>;
}
/**
* Move up the path, asserting that the current node was a key of a mapping
* pair. The builder skips over the Pair to the parent YAMLMap.
*/
parentOfKey(): AncestryBuilder<YAMLMap> {
const node = this.get();
this.parent(Pair);
const pairNode = this.get();
if (pairNode instanceof Pair && pairNode.key === node) {
this.parent(YAMLMap);
} else {
this._index = Number.MIN_SAFE_INTEGER;
}
return this as unknown as AncestryBuilder<YAMLMap>;
}
/**
* Get node up to which the assertions have led.
*/
| (): N | null {
return (this._path[this._index] as N) || null;
}
/**
* Get the key of the Pair one level down the path.
*
* The key is returned only if it indeed is a string Scalar.
*/
// The `this` argument is for generics restriction of this method.
getStringKey(this: AncestryBuilder<YAMLMap>): string | null {
const node = this._path[this._index + 1];
if (
node instanceof Pair &&
node.key instanceof Scalar &&
typeof node.key.value === 'string'
) {
return node.key.value;
}
return null;
}
/**
* Get the value of the Pair one level down the path.
*/
// The `this` argument is for generics restriction of this method.
getValue(this: AncestryBuilder<YAMLMap>): Node | null {
const node = this._path[this._index + 1];
if (node instanceof Pair) {
return node.value;
}
return null;
}
/**
* Get the path to which the assertions have led.
*
* The path will be a subpath of the original path.
*/
getPath(): Node[] | null {
if (this._index < 0) return null;
const path = this._path.slice(0, this._index + 1);
return path;
}
/**
* Get the path to the key of the Pair one level down the path to which the
* assertions have led.
*
* The path will be a subpath of the original path.
*/
// The `this` argument is for generics restriction of this method.
getKeyPath(this: AncestryBuilder<YAMLMap>): Node[] | null {
if (this._index < 0) return null;
const path = this._path.slice(0, this._index + 1);
const node = this._path[this._index + 1];
if (node instanceof Pair) {
path.push(node);
path.push(node.key);
return path;
}
return null;
}
}
export function getPathAt(
document: TextDocument,
position: Position,
docs: Document[],
inclusive = false
): Node[] | null {
const offset = document.offsetAt(position);
const doc = _.find(docs, (d) => contains(d.contents, offset, inclusive));
if (doc && doc.contents) {
return getPathAtOffset([doc.contents], offset, inclusive);
}
return null;
}
export function contains(
node: Node | null,
offset: number,
inclusive: boolean
): boolean {
const range = getOrigRange(node);
return !!(
range &&
range[0] <= offset &&
(range[1] > offset || (inclusive && range[1] >= offset))
);
}
export function getPathAtOffset(
path: Node[],
offset: number,
inclusive: boolean
): Node[] | null {
if (path) {
const currentNode = path[path.length - 1];
if (currentNode instanceof YAMLMap) {
let pair = _.find(currentNode.items, (p) =>
contains(p.key, offset, inclusive)
);
if (pair) {
return getPathAtOffset(path.concat(pair, pair.key), offset, inclusive);
}
pair = _.find(currentNode.items, (p) =>
contains(p.value, offset, inclusive)
);
if (pair) {
return getPathAtOffset(
path.concat(pair, pair.value),
offset,
inclusive
);
}
pair = _.find(currentNode.items, (p) => {
const inBetweenNode = new Node();
const start = getOrigRange(p.key as Node)?.[1];
const end = getOrigRange(p.value as Node)?.[0];
if (start && end) {
inBetweenNode.range = [start, end - 1];
return contains(inBetweenNode, offset, inclusive);
} else return false;
});
if (pair) {
return path.concat(pair, new Node());
}
} else if (currentNode instanceof YAMLSeq) {
const item = _.find(currentNode.items, (n) =>
contains(n, offset, inclusive)
);
if (item) {
return getPathAtOffset(path.concat(item), offset, inclusive);
}
} else if (contains(currentNode, offset, inclusive)) {
return path;
}
return path.concat(new Node()); // empty node as indentation marker
}
return null;
}
export const tasksKey = /^(tasks|pre_tasks|post_tasks|block|rescue|always)$/;
/**
* Determines whether the path points at a parameter key of an Ansible task.
*/
export function isTaskParam(path: Node[]): boolean {
const taskListPath = new AncestryBuilder(path)
.parentOfKey()
.parent(YAMLSeq)
.getPath();
if (taskListPath) {
// basic shape of the task list has been found
if (isPlayParam(path) || isBlockParam(path) || isRoleParam(path))
return false;
if (taskListPath.length === 1) {
// case when the task list is at the top level of the document
return true;
}
const taskListKey = new AncestryBuilder(taskListPath)
.parent(YAMLMap)
.getStringKey();
if (taskListKey && tasksKey.test(taskListKey)) {
// case when a task list is defined explicitly by a keyword
return true;
}
}
return false;
}
/**
* Tries to find the list of collections declared at the Ansible play/block/task level.
*/
export function getDeclaredCollections(modulePath: Node[] | null): string[] {
const declaredCollections: string[] = [];
const taskParamsNode = new AncestryBuilder(modulePath).parent(YAMLMap).get();
declaredCollections.push(...getDeclaredCollectionsForMap(taskParamsNode));
let path: Node[] | null = new AncestryBuilder(modulePath)
.parent(YAMLMap)
.getPath();
while (true) {
// traverse the YAML up through the Ansible blocks
const builder = new AncestryBuilder(path).parent(YAMLSeq).parent(YAMLMap);
const key = builder.getStringKey();
if (key && /^block|rescue|always$/.test(key)) {
declaredCollections.push(...getDeclaredCollectionsForMap(builder.get()));
path = builder.getPath();
} else {
break;
}
}
// now we should be at the tasks/pre_tasks/post_tasks level
const playParamsNode = new AncestryBuilder(path)
.parent(YAMLSeq)
.parent(YAMLMap)
.get();
declaredCollections.push(...getDeclaredCollectionsForMap(playParamsNode));
return [...new Set(declaredCollections)]; // deduplicate
}
function getDeclaredCollectionsForMap(playNode: YAMLMap | null): string[] {
const declaredCollections: string[] = [];
const collectionsPair = _.find(
playNode?.items,
(pair) => pair.key instanceof Scalar && pair.key.value === 'collections'
);
if (collectionsPair) {
// we've found the collections declaration
const collectionsNode = collectionsPair.value;
if (collectionsNode instanceof YAMLSeq) {
for (const collectionNode of collectionsNode.items) {
if (collectionNode instanceof Scalar) {
declaredCollections.push(collectionNode.value);
}
}
}
}
return declaredCollections;
}
/**
* Heuristically determines whether the path points at an Ansible play. The
* `fileUri` helps guessing in case the YAML tree doesn't give any clues.
*
* Returns `undefined` if highly uncertain.
*/
export function isPlayParam(
path: Node[],
fileUri?: string
): boolean | undefined {
const isAtRoot =
new AncestryBuilder(path).parentOfKey().parent(YAMLSeq).getPath()
?.length === 1;
if (isAtRoot) {
const mapNode = new AncestryBuilder(path).parentOfKey().get() as YAMLMap;
const providedKeys = getYamlMapKeys(mapNode);
const containsPlayKeyword = providedKeys.some((p) =>
playExclusiveKeywords.has(p)
);
if (containsPlayKeyword) {
return true;
}
if (fileUri) {
const isInRole = /\/roles\/[^/]+\/tasks\//.test(fileUri);
if (isInRole | get | identifier_name |
main.rs | first.starts_with("== "));
assert!(first.ends_with(" =="));
let name = first
.trim_end_matches(" ==")
.trim_start_matches("== ")
.to_owned();
let message = lines
.next()
.ok_or_else(|| anyhow!("No second line"))?
.trim()
.to_owned();
assert!(!message.is_empty(), "Expected non-empty message");
let next = lines.next().ok_or_else(|| anyhow!("No third line"))?.trim();
assert!(next.is_empty(), "Expected third line to be empty");
let next = lines
.next()
.ok_or_else(|| anyhow!("No fourth line"))?
.trim();
assert!(
next == "Doors here lead:",
"Expected third line to be 'Doors here lead:'"
);
let mut directions = Vec::new();
let mut next = lines
.next()
.ok_or_else(|| anyhow!("No line after doors"))?
.trim();
while next.starts_with("- ") {
let dir = next.trim_start_matches("- ");
let dir = str_to_compass(dir)?;
directions.push(dir);
next = lines
.next()
.ok_or_else(|| anyhow!("No line after directions"))?
.trim();
}
assert!(
next.is_empty(),
"Expected line after directions to be empty"
);
next = lines
.next()
.ok_or_else(|| anyhow!("No line after directions + empty"))?
.trim();
let mut items = BTreeSet::new();
if next == "Items here:" {
next = lines
.next()
.ok_or_else(|| anyhow!("No line after items"))?
.trim();
while next.starts_with("- ") {
let item = next.trim_start_matches("- ");
items.insert(item.to_owned());
next = lines
.next() | .ok_or_else(|| anyhow!("No line after items"))?
.trim();
}
assert!(
next.is_empty(),
"Expected line after items to be empty, got '{}'",
next
);
next = lines
.next()
.ok_or_else(|| anyhow!("No line after items + empty"))?
.trim();
}
if next.contains("Alert!") {
return Err(Ejection(next.into()).into());
}
assert_eq!(
next, "Command?",
"Expected line after items to be 'Command?'"
);
assert!(lines.next().is_none());
Ok(Room {
name,
message,
items,
directions,
})
}
}
#[derive(Debug, Clone)]
pub struct Explorer {
comp: IntComp,
room: Key,
direction: Compass,
carrying: BTreeSet<String>,
map: Map,
}
impl Explorer {
fn new(mut comp: IntComp) -> AnyResult<Self> {
let mut output = OutputVec::new();
comp.run_to_input(&mut output)?;
let out = output.as_string()?;
let room = Room::from_str(&out)?;
let mut map: Map = Default::default();
let key = map.add_room(room);
let exp = Explorer {
comp,
room: key,
direction: Compass::North,
carrying: Default::default(),
map,
};
Ok(exp)
}
fn see_room(&self) -> &Room {
self.map.get(self.room)
}
fn process_input_str(&mut self, output: &mut OutputVec, input: &str) -> anyhow::Result<String> {
log::debug!("Process 1: '{}'", input);
self.comp
.process_ascii(input, output)?
.expect(Stopped::Input)?;
log::debug!("Process 2: '\\n'");
self.comp
.process_ascii("\n", output)?
.expect(Stopped::Input)?;
log::debug!("Processed: '\\n'");
Ok(output.as_string()?)
}
fn process_str(&mut self, input: &str) -> anyhow::Result<String> {
let mut out = OutputVec::new();
match self.process_input_str(&mut out, input) {
Ok(v) => Ok(v),
Err(e) => {
let output = out.as_string()?;
log::warn!("process_str failure on input {}, output: {}", input, output);
Err(e)
}
}
}
// fn north(&mut self) -> anyhow::Result<String> {
// self.process_str("north")
// }
// fn south(&mut self) -> anyhow::Result<String> {
// self.process_str("south")
// }
// fn east(&mut self) -> anyhow::Result<String> {
// self.process_str("east")
// }
// fn west(&mut self) -> anyhow::Result<String> {
// self.process_str("west")
// }
pub fn step(&mut self, direction: Compass) -> anyhow::Result<()> {
let input = match direction {
Compass::East => "east",
Compass::North => "north",
Compass::South => "south",
Compass::West => "west",
};
log::debug!("Taking step {}", input);
let output = self.process_str(input)?;
log::debug!("Took step:\n{}\n", output);
let room = Room::from_str(&output)?;
let new = self.map.add_room(room);
self.map.add_door(self.room, direction, new);
self.room = new;
self.direction = direction;
Ok(())
}
pub fn take(&mut self, item: &str) -> anyhow::Result<String> {
log::debug!("Taking {}", item);
let mut s = String::from("take ");
s.push_str(item);
let result = self.process_str(&s)?;
let new = self.carrying.insert(item.to_string());
let room = self.map.rooms.get_mut(self.room).unwrap();
room.items.remove(item);
assert!(new, "Expected to add {}", item);
log::debug!(" took {}", item);
Ok(result)
}
pub fn drop(&mut self, item: &str) -> anyhow::Result<String> {
let found = self.carrying.remove(item);
assert!(!found, "Expected to drop {}", item);
let mut s = String::from("drop ");
s.push_str(item);
self.process_str(&s)
}
pub fn inventory(&mut self) -> anyhow::Result<String> {
self.process_str("inv")
}
fn left_wall_step(&mut self) -> AnyResult<()> {
let mut dir = self.direction + Turn::Left;
for _ in 0..4 {
log::debug!("Checking {} -> {}", self.direction, dir);
if self.see_room().directions.contains(&dir) {
break;
}
dir = dir + Turn::Right;
}
assert!(self.see_room().directions.contains(&dir));
self.step(dir)?;
log::debug!("Stepped {}, {}", dir, self.see_room().name);
Ok(())
}
fn explore_and_take(&mut self, items: &BTreeSet<String>) -> AnyResult<()> {
let start = self.room;
let mut start_directions = self.see_room().directions.clone();
start_directions.reverse();
loop {
let overlap: BTreeSet<String> = items
.intersection(&self.see_room().items)
.map(|s| s.to_owned())
.collect();
for item in overlap {
let _output = self.take(&item)?;
// println!("Took {}, output: {}", item, output.trim());
}
if self.see_room().name == "Security Checkpoint" {
// println!("inv: {}", self.inventory()?);
log::info!("Turning around at security checkpoint");
self.step(self.direction + Turn::Reverse)?;
continue;
}
if self.room == start {
let dir = match start_directions.pop() {
None => return Ok(()),
Some(d) => d,
};
self.step(dir)?;
continue;
}
self.left_wall_step()?;
}
}
pub fn goto(&mut self, room: &str) -> AnyResult<()> {
loop {
if self.see_room().name == room {
return Ok(());
}
self.left_wall_step()?;
}
}
}
type Key = slotmap::DefaultKey;
#[derive(Default, Debug, Clone)]
pub struct Map {
rooms_by_name: HashMap<String, Key>,
rooms: SlotMap<Key, Room>,
doors: HashMap<Key, BTreeMap<Compass, Key>>,
unvisited: HashMap<Key, BTreeSet<Compass>>,
}
impl Map {
fn add_room(&mut self, room: Room) -> Key {
if let Some(&key) = self.rooms_by_name.get(&room.name) {
return key;
}
let name = room.name.clone();
let directions = room.directions.clone();
let key = self.rooms.insert(room);
self.rooms_by_name.insert(name, key);
let unvisited = self.unvisited.insert(key, Default::default());
assert!(unvisited.is_none());
let unvisited = self.unvisited.get_mut(&key).unwrap();
for dir in directions {
unvisited.insert(dir);
}
key
}
fn visit(&mut self, room: Key, direction: Compass) {
if let Occupied(mut o) = self.unvisited.entry(room) {
o.get | random_line_split | |
main.rs | _str(&mut self, output: &mut OutputVec, input: &str) -> anyhow::Result<String> {
log::debug!("Process 1: '{}'", input);
self.comp
.process_ascii(input, output)?
.expect(Stopped::Input)?;
log::debug!("Process 2: '\\n'");
self.comp
.process_ascii("\n", output)?
.expect(Stopped::Input)?;
log::debug!("Processed: '\\n'");
Ok(output.as_string()?)
}
fn process_str(&mut self, input: &str) -> anyhow::Result<String> {
let mut out = OutputVec::new();
match self.process_input_str(&mut out, input) {
Ok(v) => Ok(v),
Err(e) => {
let output = out.as_string()?;
log::warn!("process_str failure on input {}, output: {}", input, output);
Err(e)
}
}
}
// fn north(&mut self) -> anyhow::Result<String> {
// self.process_str("north")
// }
// fn south(&mut self) -> anyhow::Result<String> {
// self.process_str("south")
// }
// fn east(&mut self) -> anyhow::Result<String> {
// self.process_str("east")
// }
// fn west(&mut self) -> anyhow::Result<String> {
// self.process_str("west")
// }
pub fn step(&mut self, direction: Compass) -> anyhow::Result<()> {
let input = match direction {
Compass::East => "east",
Compass::North => "north",
Compass::South => "south",
Compass::West => "west",
};
log::debug!("Taking step {}", input);
let output = self.process_str(input)?;
log::debug!("Took step:\n{}\n", output);
let room = Room::from_str(&output)?;
let new = self.map.add_room(room);
self.map.add_door(self.room, direction, new);
self.room = new;
self.direction = direction;
Ok(())
}
pub fn take(&mut self, item: &str) -> anyhow::Result<String> {
log::debug!("Taking {}", item);
let mut s = String::from("take ");
s.push_str(item);
let result = self.process_str(&s)?;
let new = self.carrying.insert(item.to_string());
let room = self.map.rooms.get_mut(self.room).unwrap();
room.items.remove(item);
assert!(new, "Expected to add {}", item);
log::debug!(" took {}", item);
Ok(result)
}
pub fn drop(&mut self, item: &str) -> anyhow::Result<String> {
let found = self.carrying.remove(item);
assert!(!found, "Expected to drop {}", item);
let mut s = String::from("drop ");
s.push_str(item);
self.process_str(&s)
}
pub fn inventory(&mut self) -> anyhow::Result<String> {
self.process_str("inv")
}
fn left_wall_step(&mut self) -> AnyResult<()> {
let mut dir = self.direction + Turn::Left;
for _ in 0..4 {
log::debug!("Checking {} -> {}", self.direction, dir);
if self.see_room().directions.contains(&dir) {
break;
}
dir = dir + Turn::Right;
}
assert!(self.see_room().directions.contains(&dir));
self.step(dir)?;
log::debug!("Stepped {}, {}", dir, self.see_room().name);
Ok(())
}
fn explore_and_take(&mut self, items: &BTreeSet<String>) -> AnyResult<()> {
let start = self.room;
let mut start_directions = self.see_room().directions.clone();
start_directions.reverse();
loop {
let overlap: BTreeSet<String> = items
.intersection(&self.see_room().items)
.map(|s| s.to_owned())
.collect();
for item in overlap {
let _output = self.take(&item)?;
// println!("Took {}, output: {}", item, output.trim());
}
if self.see_room().name == "Security Checkpoint" {
// println!("inv: {}", self.inventory()?);
log::info!("Turning around at security checkpoint");
self.step(self.direction + Turn::Reverse)?;
continue;
}
if self.room == start {
let dir = match start_directions.pop() {
None => return Ok(()),
Some(d) => d,
};
self.step(dir)?;
continue;
}
self.left_wall_step()?;
}
}
pub fn goto(&mut self, room: &str) -> AnyResult<()> {
loop {
if self.see_room().name == room {
return Ok(());
}
self.left_wall_step()?;
}
}
}
type Key = slotmap::DefaultKey;
#[derive(Default, Debug, Clone)]
pub struct Map {
rooms_by_name: HashMap<String, Key>,
rooms: SlotMap<Key, Room>,
doors: HashMap<Key, BTreeMap<Compass, Key>>,
unvisited: HashMap<Key, BTreeSet<Compass>>,
}
impl Map {
fn add_room(&mut self, room: Room) -> Key {
if let Some(&key) = self.rooms_by_name.get(&room.name) {
return key;
}
let name = room.name.clone();
let directions = room.directions.clone();
let key = self.rooms.insert(room);
self.rooms_by_name.insert(name, key);
let unvisited = self.unvisited.insert(key, Default::default());
assert!(unvisited.is_none());
let unvisited = self.unvisited.get_mut(&key).unwrap();
for dir in directions {
unvisited.insert(dir);
}
key
}
fn visit(&mut self, room: Key, direction: Compass) {
if let Occupied(mut o) = self.unvisited.entry(room) {
o.get_mut().remove(&direction);
if o.get().is_empty() {
o.remove();
}
}
}
fn add_door(&mut self, first: Key, direction: Compass, second: Key) {
self.doors
.entry(first)
.or_default()
.insert(direction, second);
self.doors
.entry(second)
.or_default()
.insert(direction + Turn::Reverse, first);
self.visit(first, direction);
self.visit(second, direction + Turn::Reverse);
}
pub fn len(&self) -> usize {
self.rooms.len()
}
pub fn is_empty(&self) -> bool {
self.rooms.is_empty()
}
pub fn contains(&self, room: &Room) -> bool {
self.rooms_by_name.contains_key(&room.name)
}
fn get(&self, key: Key) -> &Room {
self.rooms.get(key).unwrap()
}
#[allow(dead_code)]
fn to_coords(&self, origin: Option<Key>) -> HashMap<Position, Key> {
let start = match (origin, self.rooms.iter().next()) {
(Some(k), _) => k,
(None, None) => return Default::default(),
(None, Some((k, _r))) => k,
};
let mut queue = vec![(Position(0, 0), start)];
let mut seen = HashSet::new();
let mut coords = HashMap::new();
while let Some((pos, r)) = queue.pop() {
match coords.entry(pos) {
Occupied(o) => {
assert!(seen.contains(&r));
assert!(*o.get() == r);
}
Vacant(v) => {
assert!(!seen.contains(&r));
seen.insert(r);
v.insert(r);
let neighbors = self.doors.get(&r).unwrap();
for (&d, &r) in neighbors {
queue.push((pos + d, r));
}
}
}
}
coords
}
}
/*
NV
||
SB KT=GW=PS
|| ||
CQ=HD
||
|| OB=ST
|| ||
SG HB=EG=WD=AR=SL
|| ||
HW=HC=CO
||
SC
AR: Arcade
CO: Corridor
CQ: Crew Quarters
EG: Engineering
GW: Gift Wrapping Center
HB: Hull Breach
HC: Hot Chocolate Fountain
HD: Holodeck
HW: Hallway
KT: Kitchen
NV: Navigation
OB: Observatory
SB: Sick Bay
SC: Security Checkpoint
SG: Storage
SL: Science Lab
ST: Stables
WD: Warp Drive Maintenance
*/
fn try_item_combos(initial_explorer: Explorer, items: Vec<String>) -> AnyResult<Explorer> | {
let total = 1 << items.len();
for n in 0..total {
let mut explorer = initial_explorer.clone();
let cur_items: BTreeSet<String> = items
.iter()
.enumerate()
.filter_map(|(i, item)| {
if (n & (1 << i)) == 0 {
None
} else {
Some(item.clone())
}
})
.collect();
log::info!("Items: {:?}", cur_items);
explorer.explore_and_take(&cur_items)?;
assert_eq!(explorer.carrying, cur_items); | identifier_body | |
main.rs | line to be empty");
let next = lines
.next()
.ok_or_else(|| anyhow!("No fourth line"))?
.trim();
assert!(
next == "Doors here lead:",
"Expected third line to be 'Doors here lead:'"
);
let mut directions = Vec::new();
let mut next = lines
.next()
.ok_or_else(|| anyhow!("No line after doors"))?
.trim();
while next.starts_with("- ") {
let dir = next.trim_start_matches("- ");
let dir = str_to_compass(dir)?;
directions.push(dir);
next = lines
.next()
.ok_or_else(|| anyhow!("No line after directions"))?
.trim();
}
assert!(
next.is_empty(),
"Expected line after directions to be empty"
);
next = lines
.next()
.ok_or_else(|| anyhow!("No line after directions + empty"))?
.trim();
let mut items = BTreeSet::new();
if next == "Items here:" {
next = lines
.next()
.ok_or_else(|| anyhow!("No line after items"))?
.trim();
while next.starts_with("- ") {
let item = next.trim_start_matches("- ");
items.insert(item.to_owned());
next = lines
.next()
.ok_or_else(|| anyhow!("No line after items"))?
.trim();
}
assert!(
next.is_empty(),
"Expected line after items to be empty, got '{}'",
next
);
next = lines
.next()
.ok_or_else(|| anyhow!("No line after items + empty"))?
.trim();
}
if next.contains("Alert!") {
return Err(Ejection(next.into()).into());
}
assert_eq!(
next, "Command?",
"Expected line after items to be 'Command?'"
);
assert!(lines.next().is_none());
Ok(Room {
name,
message,
items,
directions,
})
}
}
#[derive(Debug, Clone)]
pub struct Explorer {
comp: IntComp,
room: Key,
direction: Compass,
carrying: BTreeSet<String>,
map: Map,
}
impl Explorer {
fn new(mut comp: IntComp) -> AnyResult<Self> {
let mut output = OutputVec::new();
comp.run_to_input(&mut output)?;
let out = output.as_string()?;
let room = Room::from_str(&out)?;
let mut map: Map = Default::default();
let key = map.add_room(room);
let exp = Explorer {
comp,
room: key,
direction: Compass::North,
carrying: Default::default(),
map,
};
Ok(exp)
}
fn see_room(&self) -> &Room {
self.map.get(self.room)
}
fn process_input_str(&mut self, output: &mut OutputVec, input: &str) -> anyhow::Result<String> {
log::debug!("Process 1: '{}'", input);
self.comp
.process_ascii(input, output)?
.expect(Stopped::Input)?;
log::debug!("Process 2: '\\n'");
self.comp
.process_ascii("\n", output)?
.expect(Stopped::Input)?;
log::debug!("Processed: '\\n'");
Ok(output.as_string()?)
}
fn process_str(&mut self, input: &str) -> anyhow::Result<String> {
let mut out = OutputVec::new();
match self.process_input_str(&mut out, input) {
Ok(v) => Ok(v),
Err(e) => {
let output = out.as_string()?;
log::warn!("process_str failure on input {}, output: {}", input, output);
Err(e)
}
}
}
// fn north(&mut self) -> anyhow::Result<String> {
// self.process_str("north")
// }
// fn south(&mut self) -> anyhow::Result<String> {
// self.process_str("south")
// }
// fn east(&mut self) -> anyhow::Result<String> {
// self.process_str("east")
// }
// fn west(&mut self) -> anyhow::Result<String> {
// self.process_str("west")
// }
pub fn step(&mut self, direction: Compass) -> anyhow::Result<()> {
let input = match direction {
Compass::East => "east",
Compass::North => "north",
Compass::South => "south",
Compass::West => "west",
};
log::debug!("Taking step {}", input);
let output = self.process_str(input)?;
log::debug!("Took step:\n{}\n", output);
let room = Room::from_str(&output)?;
let new = self.map.add_room(room);
self.map.add_door(self.room, direction, new);
self.room = new;
self.direction = direction;
Ok(())
}
pub fn take(&mut self, item: &str) -> anyhow::Result<String> {
log::debug!("Taking {}", item);
let mut s = String::from("take ");
s.push_str(item);
let result = self.process_str(&s)?;
let new = self.carrying.insert(item.to_string());
let room = self.map.rooms.get_mut(self.room).unwrap();
room.items.remove(item);
assert!(new, "Expected to add {}", item);
log::debug!(" took {}", item);
Ok(result)
}
pub fn drop(&mut self, item: &str) -> anyhow::Result<String> {
let found = self.carrying.remove(item);
assert!(!found, "Expected to drop {}", item);
let mut s = String::from("drop ");
s.push_str(item);
self.process_str(&s)
}
pub fn inventory(&mut self) -> anyhow::Result<String> {
self.process_str("inv")
}
fn left_wall_step(&mut self) -> AnyResult<()> {
let mut dir = self.direction + Turn::Left;
for _ in 0..4 {
log::debug!("Checking {} -> {}", self.direction, dir);
if self.see_room().directions.contains(&dir) {
break;
}
dir = dir + Turn::Right;
}
assert!(self.see_room().directions.contains(&dir));
self.step(dir)?;
log::debug!("Stepped {}, {}", dir, self.see_room().name);
Ok(())
}
fn explore_and_take(&mut self, items: &BTreeSet<String>) -> AnyResult<()> {
let start = self.room;
let mut start_directions = self.see_room().directions.clone();
start_directions.reverse();
loop {
let overlap: BTreeSet<String> = items
.intersection(&self.see_room().items)
.map(|s| s.to_owned())
.collect();
for item in overlap {
let _output = self.take(&item)?;
// println!("Took {}, output: {}", item, output.trim());
}
if self.see_room().name == "Security Checkpoint" {
// println!("inv: {}", self.inventory()?);
log::info!("Turning around at security checkpoint");
self.step(self.direction + Turn::Reverse)?;
continue;
}
if self.room == start {
let dir = match start_directions.pop() {
None => return Ok(()),
Some(d) => d,
};
self.step(dir)?;
continue;
}
self.left_wall_step()?;
}
}
pub fn goto(&mut self, room: &str) -> AnyResult<()> {
loop {
if self.see_room().name == room {
return Ok(());
}
self.left_wall_step()?;
}
}
}
type Key = slotmap::DefaultKey;
#[derive(Default, Debug, Clone)]
pub struct Map {
rooms_by_name: HashMap<String, Key>,
rooms: SlotMap<Key, Room>,
doors: HashMap<Key, BTreeMap<Compass, Key>>,
unvisited: HashMap<Key, BTreeSet<Compass>>,
}
impl Map {
fn add_room(&mut self, room: Room) -> Key {
if let Some(&key) = self.rooms_by_name.get(&room.name) {
return key;
}
let name = room.name.clone();
let directions = room.directions.clone();
let key = self.rooms.insert(room);
self.rooms_by_name.insert(name, key);
let unvisited = self.unvisited.insert(key, Default::default());
assert!(unvisited.is_none());
let unvisited = self.unvisited.get_mut(&key).unwrap();
for dir in directions {
unvisited.insert(dir);
}
key
}
fn visit(&mut self, room: Key, direction: Compass) {
if let Occupied(mut o) = self.unvisited.entry(room) {
o.get_mut().remove(&direction);
if o.get().is_empty() {
o.remove();
}
}
}
fn add_door(&mut self, first: Key, direction: Compass, second: Key) {
self.doors
.entry(first)
.or_default()
.insert(direction, second);
self.doors
.entry(second)
.or_default()
.insert(direction + Turn::Reverse, first);
self.visit(first, direction);
self.visit(second, direction + Turn::Reverse);
}
pub fn | len | identifier_name | |
main.rs | .starts_with("== "));
assert!(first.ends_with(" =="));
let name = first
.trim_end_matches(" ==")
.trim_start_matches("== ")
.to_owned();
let message = lines
.next()
.ok_or_else(|| anyhow!("No second line"))?
.trim()
.to_owned();
assert!(!message.is_empty(), "Expected non-empty message");
let next = lines.next().ok_or_else(|| anyhow!("No third line"))?.trim();
assert!(next.is_empty(), "Expected third line to be empty");
let next = lines
.next()
.ok_or_else(|| anyhow!("No fourth line"))?
.trim();
assert!(
next == "Doors here lead:",
"Expected third line to be 'Doors here lead:'"
);
let mut directions = Vec::new();
let mut next = lines
.next()
.ok_or_else(|| anyhow!("No line after doors"))?
.trim();
while next.starts_with("- ") {
let dir = next.trim_start_matches("- ");
let dir = str_to_compass(dir)?;
directions.push(dir);
next = lines
.next()
.ok_or_else(|| anyhow!("No line after directions"))?
.trim();
}
assert!(
next.is_empty(),
"Expected line after directions to be empty"
);
next = lines
.next()
.ok_or_else(|| anyhow!("No line after directions + empty"))?
.trim();
let mut items = BTreeSet::new();
if next == "Items here:" {
next = lines
.next()
.ok_or_else(|| anyhow!("No line after items"))?
.trim();
while next.starts_with("- ") {
let item = next.trim_start_matches("- ");
items.insert(item.to_owned());
next = lines
.next()
.ok_or_else(|| anyhow!("No line after items"))?
.trim();
}
assert!(
next.is_empty(),
"Expected line after items to be empty, got '{}'",
next
);
next = lines
.next()
.ok_or_else(|| anyhow!("No line after items + empty"))?
.trim();
}
if next.contains("Alert!") {
return Err(Ejection(next.into()).into());
}
assert_eq!(
next, "Command?",
"Expected line after items to be 'Command?'"
);
assert!(lines.next().is_none());
Ok(Room {
name,
message,
items,
directions,
})
}
}
#[derive(Debug, Clone)]
pub struct Explorer {
comp: IntComp,
room: Key,
direction: Compass,
carrying: BTreeSet<String>,
map: Map,
}
impl Explorer {
fn new(mut comp: IntComp) -> AnyResult<Self> {
let mut output = OutputVec::new();
comp.run_to_input(&mut output)?;
let out = output.as_string()?;
let room = Room::from_str(&out)?;
let mut map: Map = Default::default();
let key = map.add_room(room);
let exp = Explorer {
comp,
room: key,
direction: Compass::North,
carrying: Default::default(),
map,
};
Ok(exp)
}
fn see_room(&self) -> &Room {
self.map.get(self.room)
}
fn process_input_str(&mut self, output: &mut OutputVec, input: &str) -> anyhow::Result<String> {
log::debug!("Process 1: '{}'", input);
self.comp
.process_ascii(input, output)?
.expect(Stopped::Input)?;
log::debug!("Process 2: '\\n'");
self.comp
.process_ascii("\n", output)?
.expect(Stopped::Input)?;
log::debug!("Processed: '\\n'");
Ok(output.as_string()?)
}
fn process_str(&mut self, input: &str) -> anyhow::Result<String> {
let mut out = OutputVec::new();
match self.process_input_str(&mut out, input) {
Ok(v) => Ok(v),
Err(e) => |
}
}
// fn north(&mut self) -> anyhow::Result<String> {
// self.process_str("north")
// }
// fn south(&mut self) -> anyhow::Result<String> {
// self.process_str("south")
// }
// fn east(&mut self) -> anyhow::Result<String> {
// self.process_str("east")
// }
// fn west(&mut self) -> anyhow::Result<String> {
// self.process_str("west")
// }
pub fn step(&mut self, direction: Compass) -> anyhow::Result<()> {
let input = match direction {
Compass::East => "east",
Compass::North => "north",
Compass::South => "south",
Compass::West => "west",
};
log::debug!("Taking step {}", input);
let output = self.process_str(input)?;
log::debug!("Took step:\n{}\n", output);
let room = Room::from_str(&output)?;
let new = self.map.add_room(room);
self.map.add_door(self.room, direction, new);
self.room = new;
self.direction = direction;
Ok(())
}
pub fn take(&mut self, item: &str) -> anyhow::Result<String> {
log::debug!("Taking {}", item);
let mut s = String::from("take ");
s.push_str(item);
let result = self.process_str(&s)?;
let new = self.carrying.insert(item.to_string());
let room = self.map.rooms.get_mut(self.room).unwrap();
room.items.remove(item);
assert!(new, "Expected to add {}", item);
log::debug!(" took {}", item);
Ok(result)
}
pub fn drop(&mut self, item: &str) -> anyhow::Result<String> {
let found = self.carrying.remove(item);
assert!(!found, "Expected to drop {}", item);
let mut s = String::from("drop ");
s.push_str(item);
self.process_str(&s)
}
pub fn inventory(&mut self) -> anyhow::Result<String> {
self.process_str("inv")
}
fn left_wall_step(&mut self) -> AnyResult<()> {
let mut dir = self.direction + Turn::Left;
for _ in 0..4 {
log::debug!("Checking {} -> {}", self.direction, dir);
if self.see_room().directions.contains(&dir) {
break;
}
dir = dir + Turn::Right;
}
assert!(self.see_room().directions.contains(&dir));
self.step(dir)?;
log::debug!("Stepped {}, {}", dir, self.see_room().name);
Ok(())
}
fn explore_and_take(&mut self, items: &BTreeSet<String>) -> AnyResult<()> {
let start = self.room;
let mut start_directions = self.see_room().directions.clone();
start_directions.reverse();
loop {
let overlap: BTreeSet<String> = items
.intersection(&self.see_room().items)
.map(|s| s.to_owned())
.collect();
for item in overlap {
let _output = self.take(&item)?;
// println!("Took {}, output: {}", item, output.trim());
}
if self.see_room().name == "Security Checkpoint" {
// println!("inv: {}", self.inventory()?);
log::info!("Turning around at security checkpoint");
self.step(self.direction + Turn::Reverse)?;
continue;
}
if self.room == start {
let dir = match start_directions.pop() {
None => return Ok(()),
Some(d) => d,
};
self.step(dir)?;
continue;
}
self.left_wall_step()?;
}
}
pub fn goto(&mut self, room: &str) -> AnyResult<()> {
loop {
if self.see_room().name == room {
return Ok(());
}
self.left_wall_step()?;
}
}
}
type Key = slotmap::DefaultKey;
#[derive(Default, Debug, Clone)]
pub struct Map {
rooms_by_name: HashMap<String, Key>,
rooms: SlotMap<Key, Room>,
doors: HashMap<Key, BTreeMap<Compass, Key>>,
unvisited: HashMap<Key, BTreeSet<Compass>>,
}
impl Map {
fn add_room(&mut self, room: Room) -> Key {
if let Some(&key) = self.rooms_by_name.get(&room.name) {
return key;
}
let name = room.name.clone();
let directions = room.directions.clone();
let key = self.rooms.insert(room);
self.rooms_by_name.insert(name, key);
let unvisited = self.unvisited.insert(key, Default::default());
assert!(unvisited.is_none());
let unvisited = self.unvisited.get_mut(&key).unwrap();
for dir in directions {
unvisited.insert(dir);
}
key
}
fn visit(&mut self, room: Key, direction: Compass) {
if let Occupied(mut o) = self.unvisited.entry(room) {
o | {
let output = out.as_string()?;
log::warn!("process_str failure on input {}, output: {}", input, output);
Err(e)
} | conditional_block |
client.go | err := syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_RCVBUF, bufferSize); err != nil {
return 0, nil, err
}
}
}
return s, lsa, nil
}
// Make syscall asking for all connections. Invoke 'cb' for each connection.
func queryAllConnections(bufferSize int, cb func(Conn), inetFamily uint8) error {
s, lsa, err := connectNetfilter(bufferSize, 0)
if err != nil {
return err
}
defer syscall.Close(s)
msg := ConntrackListReq{
Header: syscall.NlMsghdr{
Len: syscall.NLMSG_HDRLEN + sizeofGenmsg,
Type: (NFNL_SUBSYS_CTNETLINK << 8) | uint16(IpctnlMsgCtGet),
Flags: syscall.NLM_F_REQUEST | syscall.NLM_F_DUMP,
Pid: 0,
Seq: 0,
},
Body: unix.Nfgenmsg{
Nfgen_family: inetFamily,
Version: NFNETLINK_V0,
Res_id: 0,
},
}
wb := msg.toWireFormat()
// fmt.Printf("msg bytes: %q\n", wb)
if err := syscall.Sendto(s, wb, 0, lsa); err != nil {
return err
}
return readMsgs(s, cb)
}
// Stream all connections instead of query for all of them at once.
func StreamAllConnections(inetFamily uint8) chan Conn {
ch := make(chan Conn, 1)
go func() {
queryAllConnections(0, func(c Conn) {
ch <- c
}, inetFamily)
close(ch)
}()
return ch
}
// Lists all the connections that conntrack is tracking.
func Connections(inetFamily uint8) ([]Conn, error) {
return ConnectionsSize(0, inetFamily)
}
// Lists all the connections that conntrack is tracking, using specified netlink buffer size.
func ConnectionsSize(bufferSize int, inetFamily uint8) ([]Conn, error) {
var conns []Conn
queryAllConnections(bufferSize, func(c Conn) {
conns = append(conns, c)
}, inetFamily)
return conns, nil
}
// Established lists all established TCP connections.
func Established(inetFamily uint8) ([]ConnTCP, error) {
var conns []ConnTCP
local := localIPs()
err := queryAllConnections(0, func(c Conn) {
if c.MsgType != NfctMsgUpdate {
fmt.Printf("msg isn't an update: %d\n", c.MsgType)
return
}
if c.TCPState != "ESTABLISHED" {
// fmt.Printf("state isn't ESTABLISHED: %s\n", c.TCPState)
return
}
if tc := c.ConnTCP(local); tc != nil {
conns = append(conns, *tc)
}
}, inetFamily)
if err != nil {
return nil, err
}
return conns, nil
}
// Follow gives a channel with all changes.
func Follow(flags uint32) (<-chan Conn, func(), error) {
return FollowSize(0, flags)
}
// Follow gives a channel with all changes, , using specified netlink buffer size.
func FollowSize(bufferSize int, flags uint32) (<-chan Conn, func(), error) {
var closing bool
s, _, err := connectNetfilter(bufferSize, flags)
stop := func() {
closing = true
syscall.Close(s)
}
if err != nil {
return nil, stop, err
}
res := make(chan Conn, 1)
go func() {
defer syscall.Close(s)
if err := readMsgs(s, func(c Conn) {
// if conn.TCPState != 3 {
// // 3 is TCP established.
// continue
// }
res <- c
}); err != nil && !closing {
panic(err)
}
}()
return res, stop, nil
}
func readMsgs(s int, cb func(Conn)) error {
rb := make([]byte, 2*syscall.Getpagesize())
loop:
for {
nr, _, err := syscall.Recvfrom(s, rb, 0)
if err == syscall.ENOBUFS {
// ENOBUF means we miss some events here. No way around it. That's life.
cb(Conn{Err: syscall.ENOBUFS})
continue
} else if err != nil {
return err
}
msgs, err := syscall.ParseNetlinkMessage(rb[:nr])
if err != nil {
return err
}
for _, msg := range msgs {
if msg.Header.Type == unix.NLMSG_ERROR {
return errors.New("NLMSG_ERROR")
}
if msg.Header.Type == unix.NLMSG_DONE {
break loop
}
if nflnSubsysID(msg.Header.Type) != NFNL_SUBSYS_CTNETLINK {
return fmt.Errorf(
"unexpected subsys_id: %d\n",
nflnSubsysID(msg.Header.Type),
)
}
conn, err := parsePayload(msg.Data[sizeofGenmsg:])
if err != nil {
return err
}
// Taken from conntrack/parse.c:__parse_message_type
switch CntlMsgTypes(nflnMsgType(msg.Header.Type)) {
case IpctnlMsgCtNew:
conn.MsgType = NfctMsgUpdate
if msg.Header.Flags&(syscall.NLM_F_CREATE|syscall.NLM_F_EXCL) > 0 {
conn.MsgType = NfctMsgNew
}
case IpctnlMsgCtDelete:
conn.MsgType = NfctMsgDestroy
}
cb(*conn)
}
}
return nil
}
type Tuple struct {
Proto uint8
Src net.IP
SrcPort uint16
Dst net.IP
DstPort uint16
// Flow stats.
Bytes uint64
Packets uint64
// ICMP stuff.
IcmpId uint16
IcmpType uint8
IcmpCode uint8
}
func (t Tuple) String() string {
return fmt.Sprintf("src=%v dst=%v sport=%d dport=%d packets=%d size=%d",t.Src,t.Dst,t.SrcPort,t.DstPort,t.Packets,t.Bytes)
}
type Conn struct {
MsgType NfConntrackMsg
TCPState string
Status CtStatus
Orig Tuple
Reply Tuple
// ct.mark, used to set permission type of the flow.
CtMark uint32
// ct.id, used to identify connections.
CtId uint32
// For multitenancy.
Zone uint16
// Error, if any.
Err error
}
func (c Conn) String() string{
return fmt.Sprintf("%d %s %v %v mark=%d\n",c.Orig.Proto,c.TCPState,c.Orig,c.Reply,c.CtMark)
}
// ConnTCP decides which way this connection is going and makes a ConnTCP.
func (c Conn) ConnTCP(local map[string]struct{}) *ConnTCP {
// conntrack gives us all connections, even things passing through, but it
// doesn't tell us what the local IP is. So we use `local` as a guide
// what's local.
src := c.Orig.Src.String()
dst := c.Orig.Dst.String()
_, srcLocal := local[src]
_, dstLocal := local[dst]
// If both are local we must just order things predictably.
if srcLocal && dstLocal {
srcLocal = c.Orig.SrcPort < c.Orig.DstPort
}
if srcLocal {
return &ConnTCP{
Local: src,
LocalPort: strconv.Itoa(int(c.Orig.SrcPort)),
Remote: dst,
RemotePort: strconv.Itoa(int(c.Orig.DstPort)),
}
}
if dstLocal {
return &ConnTCP{
Local: dst,
LocalPort: strconv.Itoa(int(c.Orig.DstPort)),
Remote: src,
RemotePort: strconv.Itoa(int(c.Orig.SrcPort)),
}
}
// Neither is local. conntrack also reports NAT connections.
return nil
}
func parsePayload(b []byte) (*Conn, error) {
// Most of this comes from libnetfilter_conntrack/src/conntrack/parse_mnl.c
conn := &Conn{}
var attrSpace [16]Attr
attrs, err := parseAttrs(b, attrSpace[0:0])
if err != nil |
for _, attr := range attrs {
switch CtattrType(attr.Typ) {
case CtaTupleOrig:
parseTuple(attr.Msg, &conn.Orig)
case CtaTupleReply:
parseTuple(attr.Msg, &conn.Reply)
case CtaCountersOrig:
conn.Orig.Packets, conn.Orig.Bytes, _ = parseCounters(attr.Msg)
case CtaCountersReply:
conn.Reply.Packets, conn.Reply.Bytes, _ = parseCounters | {
return conn, err
} | conditional_block |
client.go | err := syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_RCVBUF, bufferSize); err != nil {
return 0, nil, err
}
}
}
return s, lsa, nil
}
// Make syscall asking for all connections. Invoke 'cb' for each connection.
func queryAllConnections(bufferSize int, cb func(Conn), inetFamily uint8) error {
s, lsa, err := connectNetfilter(bufferSize, 0)
if err != nil {
return err
}
defer syscall.Close(s)
msg := ConntrackListReq{
Header: syscall.NlMsghdr{
Len: syscall.NLMSG_HDRLEN + sizeofGenmsg,
Type: (NFNL_SUBSYS_CTNETLINK << 8) | uint16(IpctnlMsgCtGet),
Flags: syscall.NLM_F_REQUEST | syscall.NLM_F_DUMP,
Pid: 0,
Seq: 0,
},
Body: unix.Nfgenmsg{
Nfgen_family: inetFamily,
Version: NFNETLINK_V0,
Res_id: 0,
},
}
wb := msg.toWireFormat()
// fmt.Printf("msg bytes: %q\n", wb)
if err := syscall.Sendto(s, wb, 0, lsa); err != nil {
return err
}
return readMsgs(s, cb)
}
// Stream all connections instead of query for all of them at once.
func StreamAllConnections(inetFamily uint8) chan Conn {
ch := make(chan Conn, 1)
go func() {
queryAllConnections(0, func(c Conn) {
ch <- c
}, inetFamily)
close(ch)
}()
return ch
}
// Lists all the connections that conntrack is tracking.
func Connections(inetFamily uint8) ([]Conn, error) {
return ConnectionsSize(0, inetFamily)
}
// Lists all the connections that conntrack is tracking, using specified netlink buffer size.
func ConnectionsSize(bufferSize int, inetFamily uint8) ([]Conn, error) {
var conns []Conn
queryAllConnections(bufferSize, func(c Conn) {
conns = append(conns, c)
}, inetFamily)
return conns, nil
}
// Established lists all established TCP connections.
func Established(inetFamily uint8) ([]ConnTCP, error) {
var conns []ConnTCP
local := localIPs()
err := queryAllConnections(0, func(c Conn) {
if c.MsgType != NfctMsgUpdate {
fmt.Printf("msg isn't an update: %d\n", c.MsgType)
return
}
if c.TCPState != "ESTABLISHED" {
// fmt.Printf("state isn't ESTABLISHED: %s\n", c.TCPState)
return
}
if tc := c.ConnTCP(local); tc != nil {
conns = append(conns, *tc)
}
}, inetFamily)
if err != nil {
return nil, err
}
return conns, nil
}
// Follow gives a channel with all changes.
func Follow(flags uint32) (<-chan Conn, func(), error) {
return FollowSize(0, flags)
}
// Follow gives a channel with all changes, , using specified netlink buffer size.
func FollowSize(bufferSize int, flags uint32) (<-chan Conn, func(), error) {
var closing bool
s, _, err := connectNetfilter(bufferSize, flags)
stop := func() {
closing = true
syscall.Close(s)
}
if err != nil {
return nil, stop, err
}
res := make(chan Conn, 1)
go func() {
defer syscall.Close(s)
if err := readMsgs(s, func(c Conn) {
// if conn.TCPState != 3 {
// // 3 is TCP established.
// continue
// }
res <- c
}); err != nil && !closing {
panic(err)
}
}()
return res, stop, nil
}
func readMsgs(s int, cb func(Conn)) error {
rb := make([]byte, 2*syscall.Getpagesize())
loop:
for {
nr, _, err := syscall.Recvfrom(s, rb, 0)
if err == syscall.ENOBUFS {
// ENOBUF means we miss some events here. No way around it. That's life.
cb(Conn{Err: syscall.ENOBUFS})
continue
} else if err != nil {
return err
}
msgs, err := syscall.ParseNetlinkMessage(rb[:nr])
if err != nil {
return err
}
for _, msg := range msgs {
if msg.Header.Type == unix.NLMSG_ERROR {
return errors.New("NLMSG_ERROR")
}
if msg.Header.Type == unix.NLMSG_DONE {
break loop
}
if nflnSubsysID(msg.Header.Type) != NFNL_SUBSYS_CTNETLINK {
return fmt.Errorf(
"unexpected subsys_id: %d\n",
nflnSubsysID(msg.Header.Type),
)
}
conn, err := parsePayload(msg.Data[sizeofGenmsg:])
if err != nil {
return err
}
// Taken from conntrack/parse.c:__parse_message_type
switch CntlMsgTypes(nflnMsgType(msg.Header.Type)) {
case IpctnlMsgCtNew:
conn.MsgType = NfctMsgUpdate
if msg.Header.Flags&(syscall.NLM_F_CREATE|syscall.NLM_F_EXCL) > 0 {
conn.MsgType = NfctMsgNew
}
case IpctnlMsgCtDelete:
conn.MsgType = NfctMsgDestroy
}
cb(*conn)
}
}
return nil
}
type Tuple struct {
Proto uint8
Src net.IP
SrcPort uint16
Dst net.IP
DstPort uint16
// Flow stats.
Bytes uint64
Packets uint64
// ICMP stuff.
IcmpId uint16
IcmpType uint8
IcmpCode uint8
}
func (t Tuple) String() string {
return fmt.Sprintf("src=%v dst=%v sport=%d dport=%d packets=%d size=%d",t.Src,t.Dst,t.SrcPort,t.DstPort,t.Packets,t.Bytes)
}
type Conn struct {
MsgType NfConntrackMsg
TCPState string
Status CtStatus
Orig Tuple
Reply Tuple
// ct.mark, used to set permission type of the flow.
CtMark uint32
// ct.id, used to identify connections.
CtId uint32
// For multitenancy.
Zone uint16
// Error, if any.
Err error
}
func (c Conn) | () string{
return fmt.Sprintf("%d %s %v %v mark=%d\n",c.Orig.Proto,c.TCPState,c.Orig,c.Reply,c.CtMark)
}
// ConnTCP decides which way this connection is going and makes a ConnTCP.
func (c Conn) ConnTCP(local map[string]struct{}) *ConnTCP {
// conntrack gives us all connections, even things passing through, but it
// doesn't tell us what the local IP is. So we use `local` as a guide
// what's local.
src := c.Orig.Src.String()
dst := c.Orig.Dst.String()
_, srcLocal := local[src]
_, dstLocal := local[dst]
// If both are local we must just order things predictably.
if srcLocal && dstLocal {
srcLocal = c.Orig.SrcPort < c.Orig.DstPort
}
if srcLocal {
return &ConnTCP{
Local: src,
LocalPort: strconv.Itoa(int(c.Orig.SrcPort)),
Remote: dst,
RemotePort: strconv.Itoa(int(c.Orig.DstPort)),
}
}
if dstLocal {
return &ConnTCP{
Local: dst,
LocalPort: strconv.Itoa(int(c.Orig.DstPort)),
Remote: src,
RemotePort: strconv.Itoa(int(c.Orig.SrcPort)),
}
}
// Neither is local. conntrack also reports NAT connections.
return nil
}
func parsePayload(b []byte) (*Conn, error) {
// Most of this comes from libnetfilter_conntrack/src/conntrack/parse_mnl.c
conn := &Conn{}
var attrSpace [16]Attr
attrs, err := parseAttrs(b, attrSpace[0:0])
if err != nil {
return conn, err
}
for _, attr := range attrs {
switch CtattrType(attr.Typ) {
case CtaTupleOrig:
parseTuple(attr.Msg, &conn.Orig)
case CtaTupleReply:
parseTuple(attr.Msg, &conn.Reply)
case CtaCountersOrig:
conn.Orig.Packets, conn.Orig.Bytes, _ = parseCounters(attr.Msg)
case CtaCountersReply:
conn.Reply.Packets, conn.Reply.Bytes, _ = parseCounters(attr | String | identifier_name |
client.go | err := syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_RCVBUF, bufferSize); err != nil {
return 0, nil, err
}
}
}
return s, lsa, nil
}
// Make syscall asking for all connections. Invoke 'cb' for each connection.
func queryAllConnections(bufferSize int, cb func(Conn), inetFamily uint8) error {
s, lsa, err := connectNetfilter(bufferSize, 0)
if err != nil {
return err
}
defer syscall.Close(s)
msg := ConntrackListReq{
Header: syscall.NlMsghdr{
Len: syscall.NLMSG_HDRLEN + sizeofGenmsg,
Type: (NFNL_SUBSYS_CTNETLINK << 8) | uint16(IpctnlMsgCtGet),
Flags: syscall.NLM_F_REQUEST | syscall.NLM_F_DUMP,
Pid: 0,
Seq: 0,
},
Body: unix.Nfgenmsg{
Nfgen_family: inetFamily,
Version: NFNETLINK_V0,
Res_id: 0,
},
}
wb := msg.toWireFormat()
// fmt.Printf("msg bytes: %q\n", wb)
if err := syscall.Sendto(s, wb, 0, lsa); err != nil {
return err
}
return readMsgs(s, cb)
}
// Stream all connections instead of query for all of them at once.
func StreamAllConnections(inetFamily uint8) chan Conn {
ch := make(chan Conn, 1)
go func() {
queryAllConnections(0, func(c Conn) {
ch <- c
}, inetFamily)
close(ch)
}()
return ch
}
// Lists all the connections that conntrack is tracking.
func Connections(inetFamily uint8) ([]Conn, error) {
return ConnectionsSize(0, inetFamily)
}
// Lists all the connections that conntrack is tracking, using specified netlink buffer size.
func ConnectionsSize(bufferSize int, inetFamily uint8) ([]Conn, error) {
var conns []Conn
queryAllConnections(bufferSize, func(c Conn) {
conns = append(conns, c)
}, inetFamily)
return conns, nil
}
// Established lists all established TCP connections.
func Established(inetFamily uint8) ([]ConnTCP, error) {
var conns []ConnTCP
local := localIPs()
err := queryAllConnections(0, func(c Conn) {
if c.MsgType != NfctMsgUpdate {
fmt.Printf("msg isn't an update: %d\n", c.MsgType)
return
}
if c.TCPState != "ESTABLISHED" {
// fmt.Printf("state isn't ESTABLISHED: %s\n", c.TCPState)
return
}
if tc := c.ConnTCP(local); tc != nil {
conns = append(conns, *tc)
}
}, inetFamily)
if err != nil {
return nil, err
}
return conns, nil
}
// Follow gives a channel with all changes.
func Follow(flags uint32) (<-chan Conn, func(), error) {
return FollowSize(0, flags)
}
// Follow gives a channel with all changes, , using specified netlink buffer size.
func FollowSize(bufferSize int, flags uint32) (<-chan Conn, func(), error) {
var closing bool
s, _, err := connectNetfilter(bufferSize, flags)
stop := func() {
closing = true
syscall.Close(s)
}
if err != nil {
return nil, stop, err
}
res := make(chan Conn, 1)
go func() {
defer syscall.Close(s)
if err := readMsgs(s, func(c Conn) {
// if conn.TCPState != 3 {
// // 3 is TCP established.
// continue
// }
res <- c
}); err != nil && !closing {
panic(err)
}
}()
return res, stop, nil
}
func readMsgs(s int, cb func(Conn)) error {
rb := make([]byte, 2*syscall.Getpagesize())
loop:
for {
nr, _, err := syscall.Recvfrom(s, rb, 0)
if err == syscall.ENOBUFS {
// ENOBUF means we miss some events here. No way around it. That's life.
cb(Conn{Err: syscall.ENOBUFS})
continue
} else if err != nil {
return err
}
msgs, err := syscall.ParseNetlinkMessage(rb[:nr])
if err != nil {
return err
}
for _, msg := range msgs {
if msg.Header.Type == unix.NLMSG_ERROR {
return errors.New("NLMSG_ERROR")
}
if msg.Header.Type == unix.NLMSG_DONE {
break loop
}
if nflnSubsysID(msg.Header.Type) != NFNL_SUBSYS_CTNETLINK {
return fmt.Errorf(
"unexpected subsys_id: %d\n",
nflnSubsysID(msg.Header.Type),
)
}
conn, err := parsePayload(msg.Data[sizeofGenmsg:])
if err != nil {
return err
} | if msg.Header.Flags&(syscall.NLM_F_CREATE|syscall.NLM_F_EXCL) > 0 {
conn.MsgType = NfctMsgNew
}
case IpctnlMsgCtDelete:
conn.MsgType = NfctMsgDestroy
}
cb(*conn)
}
}
return nil
}
type Tuple struct {
Proto uint8
Src net.IP
SrcPort uint16
Dst net.IP
DstPort uint16
// Flow stats.
Bytes uint64
Packets uint64
// ICMP stuff.
IcmpId uint16
IcmpType uint8
IcmpCode uint8
}
func (t Tuple) String() string {
return fmt.Sprintf("src=%v dst=%v sport=%d dport=%d packets=%d size=%d",t.Src,t.Dst,t.SrcPort,t.DstPort,t.Packets,t.Bytes)
}
type Conn struct {
MsgType NfConntrackMsg
TCPState string
Status CtStatus
Orig Tuple
Reply Tuple
// ct.mark, used to set permission type of the flow.
CtMark uint32
// ct.id, used to identify connections.
CtId uint32
// For multitenancy.
Zone uint16
// Error, if any.
Err error
}
func (c Conn) String() string{
return fmt.Sprintf("%d %s %v %v mark=%d\n",c.Orig.Proto,c.TCPState,c.Orig,c.Reply,c.CtMark)
}
// ConnTCP decides which way this connection is going and makes a ConnTCP.
func (c Conn) ConnTCP(local map[string]struct{}) *ConnTCP {
// conntrack gives us all connections, even things passing through, but it
// doesn't tell us what the local IP is. So we use `local` as a guide
// what's local.
src := c.Orig.Src.String()
dst := c.Orig.Dst.String()
_, srcLocal := local[src]
_, dstLocal := local[dst]
// If both are local we must just order things predictably.
if srcLocal && dstLocal {
srcLocal = c.Orig.SrcPort < c.Orig.DstPort
}
if srcLocal {
return &ConnTCP{
Local: src,
LocalPort: strconv.Itoa(int(c.Orig.SrcPort)),
Remote: dst,
RemotePort: strconv.Itoa(int(c.Orig.DstPort)),
}
}
if dstLocal {
return &ConnTCP{
Local: dst,
LocalPort: strconv.Itoa(int(c.Orig.DstPort)),
Remote: src,
RemotePort: strconv.Itoa(int(c.Orig.SrcPort)),
}
}
// Neither is local. conntrack also reports NAT connections.
return nil
}
func parsePayload(b []byte) (*Conn, error) {
// Most of this comes from libnetfilter_conntrack/src/conntrack/parse_mnl.c
conn := &Conn{}
var attrSpace [16]Attr
attrs, err := parseAttrs(b, attrSpace[0:0])
if err != nil {
return conn, err
}
for _, attr := range attrs {
switch CtattrType(attr.Typ) {
case CtaTupleOrig:
parseTuple(attr.Msg, &conn.Orig)
case CtaTupleReply:
parseTuple(attr.Msg, &conn.Reply)
case CtaCountersOrig:
conn.Orig.Packets, conn.Orig.Bytes, _ = parseCounters(attr.Msg)
case CtaCountersReply:
conn.Reply.Packets, conn.Reply.Bytes, _ = parseCounters(attr.Msg |
// Taken from conntrack/parse.c:__parse_message_type
switch CntlMsgTypes(nflnMsgType(msg.Header.Type)) {
case IpctnlMsgCtNew:
conn.MsgType = NfctMsgUpdate | random_line_split |
client.go | err := syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_RCVBUF, bufferSize); err != nil {
return 0, nil, err
}
}
}
return s, lsa, nil
}
// Make syscall asking for all connections. Invoke 'cb' for each connection.
func queryAllConnections(bufferSize int, cb func(Conn), inetFamily uint8) error {
s, lsa, err := connectNetfilter(bufferSize, 0)
if err != nil {
return err
}
defer syscall.Close(s)
msg := ConntrackListReq{
Header: syscall.NlMsghdr{
Len: syscall.NLMSG_HDRLEN + sizeofGenmsg,
Type: (NFNL_SUBSYS_CTNETLINK << 8) | uint16(IpctnlMsgCtGet),
Flags: syscall.NLM_F_REQUEST | syscall.NLM_F_DUMP,
Pid: 0,
Seq: 0,
},
Body: unix.Nfgenmsg{
Nfgen_family: inetFamily,
Version: NFNETLINK_V0,
Res_id: 0,
},
}
wb := msg.toWireFormat()
// fmt.Printf("msg bytes: %q\n", wb)
if err := syscall.Sendto(s, wb, 0, lsa); err != nil {
return err
}
return readMsgs(s, cb)
}
// Stream all connections instead of query for all of them at once.
func StreamAllConnections(inetFamily uint8) chan Conn {
ch := make(chan Conn, 1)
go func() {
queryAllConnections(0, func(c Conn) {
ch <- c
}, inetFamily)
close(ch)
}()
return ch
}
// Lists all the connections that conntrack is tracking.
func Connections(inetFamily uint8) ([]Conn, error) {
return ConnectionsSize(0, inetFamily)
}
// Lists all the connections that conntrack is tracking, using specified netlink buffer size.
func ConnectionsSize(bufferSize int, inetFamily uint8) ([]Conn, error) {
var conns []Conn
queryAllConnections(bufferSize, func(c Conn) {
conns = append(conns, c)
}, inetFamily)
return conns, nil
}
// Established lists all established TCP connections.
func Established(inetFamily uint8) ([]ConnTCP, error) {
var conns []ConnTCP
local := localIPs()
err := queryAllConnections(0, func(c Conn) {
if c.MsgType != NfctMsgUpdate {
fmt.Printf("msg isn't an update: %d\n", c.MsgType)
return
}
if c.TCPState != "ESTABLISHED" {
// fmt.Printf("state isn't ESTABLISHED: %s\n", c.TCPState)
return
}
if tc := c.ConnTCP(local); tc != nil {
conns = append(conns, *tc)
}
}, inetFamily)
if err != nil {
return nil, err
}
return conns, nil
}
// Follow gives a channel with all changes.
func Follow(flags uint32) (<-chan Conn, func(), error) {
return FollowSize(0, flags)
}
// Follow gives a channel with all changes, , using specified netlink buffer size.
func FollowSize(bufferSize int, flags uint32) (<-chan Conn, func(), error) {
var closing bool
s, _, err := connectNetfilter(bufferSize, flags)
stop := func() {
closing = true
syscall.Close(s)
}
if err != nil {
return nil, stop, err
}
res := make(chan Conn, 1)
go func() {
defer syscall.Close(s)
if err := readMsgs(s, func(c Conn) {
// if conn.TCPState != 3 {
// // 3 is TCP established.
// continue
// }
res <- c
}); err != nil && !closing {
panic(err)
}
}()
return res, stop, nil
}
func readMsgs(s int, cb func(Conn)) error {
rb := make([]byte, 2*syscall.Getpagesize())
loop:
for {
nr, _, err := syscall.Recvfrom(s, rb, 0)
if err == syscall.ENOBUFS {
// ENOBUF means we miss some events here. No way around it. That's life.
cb(Conn{Err: syscall.ENOBUFS})
continue
} else if err != nil {
return err
}
msgs, err := syscall.ParseNetlinkMessage(rb[:nr])
if err != nil {
return err
}
for _, msg := range msgs {
if msg.Header.Type == unix.NLMSG_ERROR {
return errors.New("NLMSG_ERROR")
}
if msg.Header.Type == unix.NLMSG_DONE {
break loop
}
if nflnSubsysID(msg.Header.Type) != NFNL_SUBSYS_CTNETLINK {
return fmt.Errorf(
"unexpected subsys_id: %d\n",
nflnSubsysID(msg.Header.Type),
)
}
conn, err := parsePayload(msg.Data[sizeofGenmsg:])
if err != nil {
return err
}
// Taken from conntrack/parse.c:__parse_message_type
switch CntlMsgTypes(nflnMsgType(msg.Header.Type)) {
case IpctnlMsgCtNew:
conn.MsgType = NfctMsgUpdate
if msg.Header.Flags&(syscall.NLM_F_CREATE|syscall.NLM_F_EXCL) > 0 {
conn.MsgType = NfctMsgNew
}
case IpctnlMsgCtDelete:
conn.MsgType = NfctMsgDestroy
}
cb(*conn)
}
}
return nil
}
type Tuple struct {
Proto uint8
Src net.IP
SrcPort uint16
Dst net.IP
DstPort uint16
// Flow stats.
Bytes uint64
Packets uint64
// ICMP stuff.
IcmpId uint16
IcmpType uint8
IcmpCode uint8
}
func (t Tuple) String() string {
return fmt.Sprintf("src=%v dst=%v sport=%d dport=%d packets=%d size=%d",t.Src,t.Dst,t.SrcPort,t.DstPort,t.Packets,t.Bytes)
}
type Conn struct {
MsgType NfConntrackMsg
TCPState string
Status CtStatus
Orig Tuple
Reply Tuple
// ct.mark, used to set permission type of the flow.
CtMark uint32
// ct.id, used to identify connections.
CtId uint32
// For multitenancy.
Zone uint16
// Error, if any.
Err error
}
func (c Conn) String() string |
// ConnTCP decides which way this connection is going and makes a ConnTCP.
func (c Conn) ConnTCP(local map[string]struct{}) *ConnTCP {
// conntrack gives us all connections, even things passing through, but it
// doesn't tell us what the local IP is. So we use `local` as a guide
// what's local.
src := c.Orig.Src.String()
dst := c.Orig.Dst.String()
_, srcLocal := local[src]
_, dstLocal := local[dst]
// If both are local we must just order things predictably.
if srcLocal && dstLocal {
srcLocal = c.Orig.SrcPort < c.Orig.DstPort
}
if srcLocal {
return &ConnTCP{
Local: src,
LocalPort: strconv.Itoa(int(c.Orig.SrcPort)),
Remote: dst,
RemotePort: strconv.Itoa(int(c.Orig.DstPort)),
}
}
if dstLocal {
return &ConnTCP{
Local: dst,
LocalPort: strconv.Itoa(int(c.Orig.DstPort)),
Remote: src,
RemotePort: strconv.Itoa(int(c.Orig.SrcPort)),
}
}
// Neither is local. conntrack also reports NAT connections.
return nil
}
func parsePayload(b []byte) (*Conn, error) {
// Most of this comes from libnetfilter_conntrack/src/conntrack/parse_mnl.c
conn := &Conn{}
var attrSpace [16]Attr
attrs, err := parseAttrs(b, attrSpace[0:0])
if err != nil {
return conn, err
}
for _, attr := range attrs {
switch CtattrType(attr.Typ) {
case CtaTupleOrig:
parseTuple(attr.Msg, &conn.Orig)
case CtaTupleReply:
parseTuple(attr.Msg, &conn.Reply)
case CtaCountersOrig:
conn.Orig.Packets, conn.Orig.Bytes, _ = parseCounters(attr.Msg)
case CtaCountersReply:
conn.Reply.Packets, conn.Reply.Bytes, _ = parseCounters(attr | {
return fmt.Sprintf("%d %s %v %v mark=%d\n",c.Orig.Proto,c.TCPState,c.Orig,c.Reply,c.CtMark)
} | identifier_body |
mongos.go | -operator",
"app.kubernetes.io/part-of": "percona-server-mongodb",
}
if cr.Spec.Sharding.Mongos.Labels != nil {
for k, v := range cr.Spec.Sharding.Mongos.Labels {
ls[k] = v
}
}
c, err := mongosContainer(cr, customConf.Type.IsUsable(), cfgInstances)
if err != nil {
return appsv1.DeploymentSpec{}, fmt.Errorf("failed to create container %v", err)
}
initContainers := InitContainers(cr, operatorPod)
for i := range initContainers {
initContainers[i].Resources.Limits = c.Resources.Limits
initContainers[i].Resources.Requests = c.Resources.Requests
}
containers, ok := cr.Spec.Sharding.Mongos.MultiAZ.WithSidecars(c)
if !ok {
log.Info(fmt.Sprintf("Sidecar container name cannot be %s. It's skipped", c.Name))
}
annotations := cr.Spec.Sharding.Mongos.MultiAZ.Annotations
if annotations == nil {
annotations = make(map[string]string)
}
if customConf.Type.IsUsable() {
annotations["percona.com/configuration-hash"] = customConf.HashHex
}
zero := intstr.FromInt(0)
return appsv1.DeploymentSpec{
Replicas: &cr.Spec.Sharding.Mongos.Size,
Selector: &metav1.LabelSelector{
MatchLabels: ls,
},
Template: corev1.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: ls,
Annotations: annotations,
},
Spec: corev1.PodSpec{
SecurityContext: cr.Spec.Sharding.Mongos.PodSecurityContext,
Affinity: PodAffinity(cr, cr.Spec.Sharding.Mongos.MultiAZ.Affinity, ls),
NodeSelector: cr.Spec.Sharding.Mongos.MultiAZ.NodeSelector,
Tolerations: cr.Spec.Sharding.Mongos.MultiAZ.Tolerations,
PriorityClassName: cr.Spec.Sharding.Mongos.MultiAZ.PriorityClassName,
RestartPolicy: corev1.RestartPolicyAlways,
ImagePullSecrets: cr.Spec.ImagePullSecrets,
Containers: containers,
InitContainers: initContainers,
Volumes: volumes(cr, customConf.Type),
SchedulerName: cr.Spec.SchedulerName,
RuntimeClassName: cr.Spec.Sharding.Mongos.MultiAZ.RuntimeClassName,
},
},
Strategy: appsv1.DeploymentStrategy{
Type: appsv1.RollingUpdateDeploymentStrategyType,
RollingUpdate: &appsv1.RollingUpdateDeployment{
MaxSurge: &zero,
},
},
}, nil
}
func InitContainers(cr *api.PerconaServerMongoDB, operatorPod corev1.Pod) []corev1.Container {
image := cr.Spec.InitImage
if len(image) == 0 {
if cr.CompareVersion(version.Version) != 0 {
image = strings.Split(operatorPod.Spec.Containers[0].Image, ":")[0] + ":" + cr.Spec.CRVersion
} else {
image = operatorPod.Spec.Containers[0].Image
}
}
return []corev1.Container{EntrypointInitContainer(image, cr.Spec.ImagePullPolicy)}
}
func | (cr *api.PerconaServerMongoDB, useConfigFile bool, cfgInstances []string) (corev1.Container, error) {
fvar := false
resources, err := CreateResources(cr.Spec.Sharding.Mongos.ResourcesSpec)
if err != nil {
return corev1.Container{}, fmt.Errorf("resource creation: %v", err)
}
volumes := []corev1.VolumeMount{
{
Name: MongodDataVolClaimName,
MountPath: MongodContainerDataDir,
},
{
Name: InternalKey(cr),
MountPath: mongodSecretsDir,
ReadOnly: true,
},
{
Name: "ssl",
MountPath: sslDir,
ReadOnly: true,
},
{
Name: "ssl-internal",
MountPath: sslInternalDir,
ReadOnly: true,
},
}
if useConfigFile {
volumes = append(volumes, corev1.VolumeMount{
Name: "config",
MountPath: mongosConfigDir,
})
}
if cr.CompareVersion("1.8.0") >= 0 {
volumes = append(volumes, corev1.VolumeMount{
Name: "users-secret-file",
MountPath: "/etc/users-secret",
ReadOnly: true,
})
}
container := corev1.Container{
Name: "mongos",
Image: cr.Spec.Image,
ImagePullPolicy: cr.Spec.ImagePullPolicy,
Args: mongosContainerArgs(cr, resources, useConfigFile, cfgInstances),
Ports: []corev1.ContainerPort{
{
Name: mongosPortName,
HostPort: cr.Spec.Sharding.Mongos.HostPort,
ContainerPort: cr.Spec.Sharding.Mongos.Port,
},
},
Env: []corev1.EnvVar{
{
Name: "MONGODB_PORT",
Value: strconv.Itoa(int(cr.Spec.Sharding.Mongos.Port)),
},
},
EnvFrom: []corev1.EnvFromSource{
{
SecretRef: &corev1.SecretEnvSource{
LocalObjectReference: corev1.LocalObjectReference{
Name: cr.Spec.Secrets.Users,
},
Optional: &fvar,
},
},
{
SecretRef: &corev1.SecretEnvSource{
LocalObjectReference: corev1.LocalObjectReference{
Name: api.UserSecretName(cr),
},
Optional: &fvar,
},
},
},
WorkingDir: MongodContainerDataDir,
LivenessProbe: &cr.Spec.Sharding.Mongos.LivenessProbe.Probe,
ReadinessProbe: cr.Spec.Sharding.Mongos.ReadinessProbe,
SecurityContext: cr.Spec.Sharding.Mongos.ContainerSecurityContext,
Resources: resources,
VolumeMounts: volumes,
Command: []string{"/data/db/ps-entry.sh"},
}
return container, nil
}
func mongosContainerArgs(cr *api.PerconaServerMongoDB, resources corev1.ResourceRequirements, useConfigFile bool, cfgInstances []string) []string {
mdSpec := cr.Spec.Mongod
msSpec := cr.Spec.Sharding.Mongos
cfgRs := cr.Spec.Sharding.ConfigsvrReplSet
// sort config instances to prevent unnecessary updates
sort.Strings(cfgInstances)
configDB := fmt.Sprintf("%s/%s", cfgRs.Name, strings.Join(cfgInstances, ","))
args := []string{
"mongos",
"--bind_ip_all",
"--port=" + strconv.Itoa(int(msSpec.Port)),
"--sslAllowInvalidCertificates",
"--configdb",
configDB,
}
if cr.CompareVersion("1.7.0") >= 0 {
args = append(args,
"--relaxPermChecks",
)
}
if cr.Spec.UnsafeConf {
args = append(args,
"--clusterAuthMode=keyFile",
"--keyFile="+mongodSecretsDir+"/mongodb-key",
)
} else {
args = append(args,
"--sslMode=preferSSL",
"--clusterAuthMode=x509",
)
}
if mdSpec.Security != nil && mdSpec.Security.RedactClientLogData {
args = append(args, "--redactClientLogData")
}
if msSpec.SetParameter != nil {
if msSpec.SetParameter.CursorTimeoutMillis > 0 {
args = append(args,
"--setParameter",
"cursorTimeoutMillis="+strconv.Itoa(msSpec.SetParameter.CursorTimeoutMillis),
)
}
}
if msSpec.AuditLog != nil && msSpec.AuditLog.Destination == api.AuditLogDestinationFile {
if msSpec.AuditLog.Filter == "" {
msSpec.AuditLog.Filter = "{}"
}
args = append(args,
"--auditDestination=file",
"--auditFilter="+msSpec.AuditLog.Filter,
"--auditFormat="+string(msSpec.AuditLog.Format),
)
switch msSpec.AuditLog.Format {
case api.AuditLogFormatBSON:
args = append(args, "--auditPath="+MongodContainerDataDir+"/auditLog.bson")
default:
args = append(args, "--auditPath="+MongodContainerDataDir+"/auditLog.json")
}
}
if useConfigFile {
args = append(args, fmt.Sprintf("--config=%s/mongos.conf", mongosConfigDir))
}
return args
}
func volumes(cr *api.PerconaServerMongoDB, configSource VolumeSourceType) []corev1.Volume {
fvar, tvar := false, true
volumes := []corev1.Volume{
{
Name: InternalKey(cr),
VolumeSource: corev1.VolumeSource{
Secret: &corev1.SecretVolumeSource{
DefaultMode: &secretFileMode,
SecretName: | mongosContainer | identifier_name |
mongos.go | ",
"app.kubernetes.io/part-of": "percona-server-mongodb",
}
if cr.Spec.Sharding.Mongos.Labels != nil {
for k, v := range cr.Spec.Sharding.Mongos.Labels {
ls[k] = v
}
}
c, err := mongosContainer(cr, customConf.Type.IsUsable(), cfgInstances)
if err != nil {
return appsv1.DeploymentSpec{}, fmt.Errorf("failed to create container %v", err)
}
initContainers := InitContainers(cr, operatorPod)
for i := range initContainers {
initContainers[i].Resources.Limits = c.Resources.Limits
initContainers[i].Resources.Requests = c.Resources.Requests
}
containers, ok := cr.Spec.Sharding.Mongos.MultiAZ.WithSidecars(c)
if !ok {
log.Info(fmt.Sprintf("Sidecar container name cannot be %s. It's skipped", c.Name))
}
annotations := cr.Spec.Sharding.Mongos.MultiAZ.Annotations
if annotations == nil {
annotations = make(map[string]string)
}
if customConf.Type.IsUsable() {
annotations["percona.com/configuration-hash"] = customConf.HashHex
}
zero := intstr.FromInt(0)
return appsv1.DeploymentSpec{
Replicas: &cr.Spec.Sharding.Mongos.Size,
Selector: &metav1.LabelSelector{
MatchLabels: ls,
},
Template: corev1.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: ls,
Annotations: annotations,
},
Spec: corev1.PodSpec{
SecurityContext: cr.Spec.Sharding.Mongos.PodSecurityContext,
Affinity: PodAffinity(cr, cr.Spec.Sharding.Mongos.MultiAZ.Affinity, ls),
NodeSelector: cr.Spec.Sharding.Mongos.MultiAZ.NodeSelector,
Tolerations: cr.Spec.Sharding.Mongos.MultiAZ.Tolerations,
PriorityClassName: cr.Spec.Sharding.Mongos.MultiAZ.PriorityClassName,
RestartPolicy: corev1.RestartPolicyAlways,
ImagePullSecrets: cr.Spec.ImagePullSecrets,
Containers: containers,
InitContainers: initContainers,
Volumes: volumes(cr, customConf.Type),
SchedulerName: cr.Spec.SchedulerName,
RuntimeClassName: cr.Spec.Sharding.Mongos.MultiAZ.RuntimeClassName,
},
},
Strategy: appsv1.DeploymentStrategy{
Type: appsv1.RollingUpdateDeploymentStrategyType,
RollingUpdate: &appsv1.RollingUpdateDeployment{
MaxSurge: &zero,
},
},
}, nil
}
func InitContainers(cr *api.PerconaServerMongoDB, operatorPod corev1.Pod) []corev1.Container {
image := cr.Spec.InitImage
if len(image) == 0 {
if cr.CompareVersion(version.Version) != 0 {
image = strings.Split(operatorPod.Spec.Containers[0].Image, ":")[0] + ":" + cr.Spec.CRVersion
} else {
image = operatorPod.Spec.Containers[0].Image
}
}
return []corev1.Container{EntrypointInitContainer(image, cr.Spec.ImagePullPolicy)}
}
func mongosContainer(cr *api.PerconaServerMongoDB, useConfigFile bool, cfgInstances []string) (corev1.Container, error) {
fvar := false
resources, err := CreateResources(cr.Spec.Sharding.Mongos.ResourcesSpec)
if err != nil {
return corev1.Container{}, fmt.Errorf("resource creation: %v", err)
}
volumes := []corev1.VolumeMount{
{
Name: MongodDataVolClaimName,
MountPath: MongodContainerDataDir,
},
{
Name: InternalKey(cr),
MountPath: mongodSecretsDir,
ReadOnly: true,
},
{
Name: "ssl",
MountPath: sslDir,
ReadOnly: true,
},
{
Name: "ssl-internal",
MountPath: sslInternalDir,
ReadOnly: true,
},
}
if useConfigFile {
volumes = append(volumes, corev1.VolumeMount{
Name: "config",
MountPath: mongosConfigDir,
})
}
if cr.CompareVersion("1.8.0") >= 0 {
volumes = append(volumes, corev1.VolumeMount{
Name: "users-secret-file",
MountPath: "/etc/users-secret",
ReadOnly: true,
})
}
container := corev1.Container{
Name: "mongos",
Image: cr.Spec.Image,
ImagePullPolicy: cr.Spec.ImagePullPolicy,
Args: mongosContainerArgs(cr, resources, useConfigFile, cfgInstances),
Ports: []corev1.ContainerPort{
{
Name: mongosPortName,
HostPort: cr.Spec.Sharding.Mongos.HostPort,
ContainerPort: cr.Spec.Sharding.Mongos.Port,
},
},
Env: []corev1.EnvVar{
{
Name: "MONGODB_PORT",
Value: strconv.Itoa(int(cr.Spec.Sharding.Mongos.Port)),
},
},
EnvFrom: []corev1.EnvFromSource{
{
SecretRef: &corev1.SecretEnvSource{
LocalObjectReference: corev1.LocalObjectReference{
Name: cr.Spec.Secrets.Users,
},
Optional: &fvar,
},
},
{
SecretRef: &corev1.SecretEnvSource{
LocalObjectReference: corev1.LocalObjectReference{
Name: api.UserSecretName(cr),
},
Optional: &fvar,
},
},
},
WorkingDir: MongodContainerDataDir,
LivenessProbe: &cr.Spec.Sharding.Mongos.LivenessProbe.Probe,
ReadinessProbe: cr.Spec.Sharding.Mongos.ReadinessProbe,
SecurityContext: cr.Spec.Sharding.Mongos.ContainerSecurityContext,
Resources: resources,
VolumeMounts: volumes,
Command: []string{"/data/db/ps-entry.sh"},
}
return container, nil
}
func mongosContainerArgs(cr *api.PerconaServerMongoDB, resources corev1.ResourceRequirements, useConfigFile bool, cfgInstances []string) []string {
mdSpec := cr.Spec.Mongod
msSpec := cr.Spec.Sharding.Mongos
cfgRs := cr.Spec.Sharding.ConfigsvrReplSet
// sort config instances to prevent unnecessary updates
sort.Strings(cfgInstances)
configDB := fmt.Sprintf("%s/%s", cfgRs.Name, strings.Join(cfgInstances, ","))
args := []string{
"mongos",
"--bind_ip_all",
"--port=" + strconv.Itoa(int(msSpec.Port)),
"--sslAllowInvalidCertificates",
"--configdb",
configDB,
}
if cr.CompareVersion("1.7.0") >= 0 {
args = append(args,
"--relaxPermChecks",
)
}
if cr.Spec.UnsafeConf {
args = append(args,
"--clusterAuthMode=keyFile",
"--keyFile="+mongodSecretsDir+"/mongodb-key",
)
} else {
args = append(args,
"--sslMode=preferSSL",
"--clusterAuthMode=x509",
)
}
if mdSpec.Security != nil && mdSpec.Security.RedactClientLogData {
args = append(args, "--redactClientLogData")
}
if msSpec.SetParameter != nil {
if msSpec.SetParameter.CursorTimeoutMillis > 0 {
args = append(args,
"--setParameter",
"cursorTimeoutMillis="+strconv.Itoa(msSpec.SetParameter.CursorTimeoutMillis),
)
}
}
if msSpec.AuditLog != nil && msSpec.AuditLog.Destination == api.AuditLogDestinationFile {
if msSpec.AuditLog.Filter == "" {
msSpec.AuditLog.Filter = "{}"
}
args = append(args,
"--auditDestination=file",
"--auditFilter="+msSpec.AuditLog.Filter,
"--auditFormat="+string(msSpec.AuditLog.Format),
)
switch msSpec.AuditLog.Format {
case api.AuditLogFormatBSON:
args = append(args, "--auditPath="+MongodContainerDataDir+"/auditLog.bson")
default:
args = append(args, "--auditPath="+MongodContainerDataDir+"/auditLog.json")
}
}
if useConfigFile |
return args
}
func volumes(cr *api.PerconaServerMongoDB, configSource VolumeSourceType) []corev1.Volume {
fvar, tvar := false, true
volumes := []corev1.Volume{
{
Name: InternalKey(cr),
VolumeSource: corev1.VolumeSource{
Secret: &corev1.SecretVolumeSource{
DefaultMode: &secretFileMode,
SecretName: | {
args = append(args, fmt.Sprintf("--config=%s/mongos.conf", mongosConfigDir))
} | conditional_block |
mongos.go | ),
SchedulerName: cr.Spec.SchedulerName,
RuntimeClassName: cr.Spec.Sharding.Mongos.MultiAZ.RuntimeClassName,
},
},
Strategy: appsv1.DeploymentStrategy{
Type: appsv1.RollingUpdateDeploymentStrategyType,
RollingUpdate: &appsv1.RollingUpdateDeployment{
MaxSurge: &zero,
},
},
}, nil
}
func InitContainers(cr *api.PerconaServerMongoDB, operatorPod corev1.Pod) []corev1.Container {
image := cr.Spec.InitImage
if len(image) == 0 {
if cr.CompareVersion(version.Version) != 0 {
image = strings.Split(operatorPod.Spec.Containers[0].Image, ":")[0] + ":" + cr.Spec.CRVersion
} else {
image = operatorPod.Spec.Containers[0].Image
}
}
return []corev1.Container{EntrypointInitContainer(image, cr.Spec.ImagePullPolicy)}
}
func mongosContainer(cr *api.PerconaServerMongoDB, useConfigFile bool, cfgInstances []string) (corev1.Container, error) {
fvar := false
resources, err := CreateResources(cr.Spec.Sharding.Mongos.ResourcesSpec)
if err != nil {
return corev1.Container{}, fmt.Errorf("resource creation: %v", err)
}
volumes := []corev1.VolumeMount{
{
Name: MongodDataVolClaimName,
MountPath: MongodContainerDataDir,
},
{
Name: InternalKey(cr),
MountPath: mongodSecretsDir,
ReadOnly: true,
},
{
Name: "ssl",
MountPath: sslDir,
ReadOnly: true,
},
{
Name: "ssl-internal",
MountPath: sslInternalDir,
ReadOnly: true,
},
}
if useConfigFile {
volumes = append(volumes, corev1.VolumeMount{
Name: "config",
MountPath: mongosConfigDir,
})
}
if cr.CompareVersion("1.8.0") >= 0 {
volumes = append(volumes, corev1.VolumeMount{
Name: "users-secret-file",
MountPath: "/etc/users-secret",
ReadOnly: true,
})
}
container := corev1.Container{
Name: "mongos",
Image: cr.Spec.Image,
ImagePullPolicy: cr.Spec.ImagePullPolicy,
Args: mongosContainerArgs(cr, resources, useConfigFile, cfgInstances),
Ports: []corev1.ContainerPort{
{
Name: mongosPortName,
HostPort: cr.Spec.Sharding.Mongos.HostPort,
ContainerPort: cr.Spec.Sharding.Mongos.Port,
},
},
Env: []corev1.EnvVar{
{
Name: "MONGODB_PORT",
Value: strconv.Itoa(int(cr.Spec.Sharding.Mongos.Port)),
},
},
EnvFrom: []corev1.EnvFromSource{
{
SecretRef: &corev1.SecretEnvSource{
LocalObjectReference: corev1.LocalObjectReference{
Name: cr.Spec.Secrets.Users,
},
Optional: &fvar,
},
},
{
SecretRef: &corev1.SecretEnvSource{
LocalObjectReference: corev1.LocalObjectReference{
Name: api.UserSecretName(cr),
},
Optional: &fvar,
},
},
},
WorkingDir: MongodContainerDataDir,
LivenessProbe: &cr.Spec.Sharding.Mongos.LivenessProbe.Probe,
ReadinessProbe: cr.Spec.Sharding.Mongos.ReadinessProbe,
SecurityContext: cr.Spec.Sharding.Mongos.ContainerSecurityContext,
Resources: resources,
VolumeMounts: volumes,
Command: []string{"/data/db/ps-entry.sh"},
}
return container, nil
}
func mongosContainerArgs(cr *api.PerconaServerMongoDB, resources corev1.ResourceRequirements, useConfigFile bool, cfgInstances []string) []string {
mdSpec := cr.Spec.Mongod
msSpec := cr.Spec.Sharding.Mongos
cfgRs := cr.Spec.Sharding.ConfigsvrReplSet
// sort config instances to prevent unnecessary updates
sort.Strings(cfgInstances)
configDB := fmt.Sprintf("%s/%s", cfgRs.Name, strings.Join(cfgInstances, ","))
args := []string{
"mongos",
"--bind_ip_all",
"--port=" + strconv.Itoa(int(msSpec.Port)),
"--sslAllowInvalidCertificates",
"--configdb",
configDB,
}
if cr.CompareVersion("1.7.0") >= 0 {
args = append(args,
"--relaxPermChecks",
)
}
if cr.Spec.UnsafeConf {
args = append(args,
"--clusterAuthMode=keyFile",
"--keyFile="+mongodSecretsDir+"/mongodb-key",
)
} else {
args = append(args,
"--sslMode=preferSSL",
"--clusterAuthMode=x509",
)
}
if mdSpec.Security != nil && mdSpec.Security.RedactClientLogData {
args = append(args, "--redactClientLogData")
}
if msSpec.SetParameter != nil {
if msSpec.SetParameter.CursorTimeoutMillis > 0 {
args = append(args,
"--setParameter",
"cursorTimeoutMillis="+strconv.Itoa(msSpec.SetParameter.CursorTimeoutMillis),
)
}
}
if msSpec.AuditLog != nil && msSpec.AuditLog.Destination == api.AuditLogDestinationFile {
if msSpec.AuditLog.Filter == "" {
msSpec.AuditLog.Filter = "{}"
}
args = append(args,
"--auditDestination=file",
"--auditFilter="+msSpec.AuditLog.Filter,
"--auditFormat="+string(msSpec.AuditLog.Format),
)
switch msSpec.AuditLog.Format {
case api.AuditLogFormatBSON:
args = append(args, "--auditPath="+MongodContainerDataDir+"/auditLog.bson")
default:
args = append(args, "--auditPath="+MongodContainerDataDir+"/auditLog.json")
}
}
if useConfigFile {
args = append(args, fmt.Sprintf("--config=%s/mongos.conf", mongosConfigDir))
}
return args
}
func volumes(cr *api.PerconaServerMongoDB, configSource VolumeSourceType) []corev1.Volume {
fvar, tvar := false, true
volumes := []corev1.Volume{
{
Name: InternalKey(cr),
VolumeSource: corev1.VolumeSource{
Secret: &corev1.SecretVolumeSource{
DefaultMode: &secretFileMode,
SecretName: InternalKey(cr),
Optional: &fvar,
},
},
},
{
Name: "ssl",
VolumeSource: corev1.VolumeSource{
Secret: &corev1.SecretVolumeSource{
SecretName: cr.Spec.Secrets.SSL,
Optional: &cr.Spec.UnsafeConf,
DefaultMode: &secretFileMode,
},
},
},
{
Name: "ssl-internal",
VolumeSource: corev1.VolumeSource{
Secret: &corev1.SecretVolumeSource{
SecretName: cr.Spec.Secrets.SSLInternal,
Optional: &tvar,
DefaultMode: &secretFileMode,
},
},
},
{
Name: MongodDataVolClaimName,
VolumeSource: corev1.VolumeSource{
EmptyDir: &corev1.EmptyDirVolumeSource{},
},
},
}
if cr.CompareVersion("1.8.0") >= 0 {
volumes = append(volumes, corev1.Volume{
Name: "users-secret-file",
VolumeSource: corev1.VolumeSource{
Secret: &corev1.SecretVolumeSource{
SecretName: api.InternalUserSecretName(cr),
},
},
})
}
if configSource.IsUsable() {
volumes = append(volumes, corev1.Volume{
Name: "config",
VolumeSource: configSource.VolumeSource(MongosCustomConfigName(cr.Name)),
})
}
return volumes
}
func MongosService(cr *api.PerconaServerMongoDB) corev1.Service {
svc := corev1.Service{
TypeMeta: metav1.TypeMeta{
APIVersion: "v1",
Kind: "Service",
},
ObjectMeta: metav1.ObjectMeta{
Name: cr.Name + "-" + "mongos",
Namespace: cr.Namespace,
},
}
if cr.Spec.Sharding.Mongos != nil {
svc.Annotations = cr.Spec.Sharding.Mongos.Expose.ServiceAnnotations
}
return svc
}
func MongosServiceSpec(cr *api.PerconaServerMongoDB) corev1.ServiceSpec {
ls := map[string]string{ | "app.kubernetes.io/name": "percona-server-mongodb", | random_line_split | |
mongos.go | .IsUsable(), cfgInstances)
if err != nil {
return appsv1.DeploymentSpec{}, fmt.Errorf("failed to create container %v", err)
}
initContainers := InitContainers(cr, operatorPod)
for i := range initContainers {
initContainers[i].Resources.Limits = c.Resources.Limits
initContainers[i].Resources.Requests = c.Resources.Requests
}
containers, ok := cr.Spec.Sharding.Mongos.MultiAZ.WithSidecars(c)
if !ok {
log.Info(fmt.Sprintf("Sidecar container name cannot be %s. It's skipped", c.Name))
}
annotations := cr.Spec.Sharding.Mongos.MultiAZ.Annotations
if annotations == nil {
annotations = make(map[string]string)
}
if customConf.Type.IsUsable() {
annotations["percona.com/configuration-hash"] = customConf.HashHex
}
zero := intstr.FromInt(0)
return appsv1.DeploymentSpec{
Replicas: &cr.Spec.Sharding.Mongos.Size,
Selector: &metav1.LabelSelector{
MatchLabels: ls,
},
Template: corev1.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: ls,
Annotations: annotations,
},
Spec: corev1.PodSpec{
SecurityContext: cr.Spec.Sharding.Mongos.PodSecurityContext,
Affinity: PodAffinity(cr, cr.Spec.Sharding.Mongos.MultiAZ.Affinity, ls),
NodeSelector: cr.Spec.Sharding.Mongos.MultiAZ.NodeSelector,
Tolerations: cr.Spec.Sharding.Mongos.MultiAZ.Tolerations,
PriorityClassName: cr.Spec.Sharding.Mongos.MultiAZ.PriorityClassName,
RestartPolicy: corev1.RestartPolicyAlways,
ImagePullSecrets: cr.Spec.ImagePullSecrets,
Containers: containers,
InitContainers: initContainers,
Volumes: volumes(cr, customConf.Type),
SchedulerName: cr.Spec.SchedulerName,
RuntimeClassName: cr.Spec.Sharding.Mongos.MultiAZ.RuntimeClassName,
},
},
Strategy: appsv1.DeploymentStrategy{
Type: appsv1.RollingUpdateDeploymentStrategyType,
RollingUpdate: &appsv1.RollingUpdateDeployment{
MaxSurge: &zero,
},
},
}, nil
}
func InitContainers(cr *api.PerconaServerMongoDB, operatorPod corev1.Pod) []corev1.Container {
image := cr.Spec.InitImage
if len(image) == 0 {
if cr.CompareVersion(version.Version) != 0 {
image = strings.Split(operatorPod.Spec.Containers[0].Image, ":")[0] + ":" + cr.Spec.CRVersion
} else {
image = operatorPod.Spec.Containers[0].Image
}
}
return []corev1.Container{EntrypointInitContainer(image, cr.Spec.ImagePullPolicy)}
}
func mongosContainer(cr *api.PerconaServerMongoDB, useConfigFile bool, cfgInstances []string) (corev1.Container, error) {
fvar := false
resources, err := CreateResources(cr.Spec.Sharding.Mongos.ResourcesSpec)
if err != nil {
return corev1.Container{}, fmt.Errorf("resource creation: %v", err)
}
volumes := []corev1.VolumeMount{
{
Name: MongodDataVolClaimName,
MountPath: MongodContainerDataDir,
},
{
Name: InternalKey(cr),
MountPath: mongodSecretsDir,
ReadOnly: true,
},
{
Name: "ssl",
MountPath: sslDir,
ReadOnly: true,
},
{
Name: "ssl-internal",
MountPath: sslInternalDir,
ReadOnly: true,
},
}
if useConfigFile {
volumes = append(volumes, corev1.VolumeMount{
Name: "config",
MountPath: mongosConfigDir,
})
}
if cr.CompareVersion("1.8.0") >= 0 {
volumes = append(volumes, corev1.VolumeMount{
Name: "users-secret-file",
MountPath: "/etc/users-secret",
ReadOnly: true,
})
}
container := corev1.Container{
Name: "mongos",
Image: cr.Spec.Image,
ImagePullPolicy: cr.Spec.ImagePullPolicy,
Args: mongosContainerArgs(cr, resources, useConfigFile, cfgInstances),
Ports: []corev1.ContainerPort{
{
Name: mongosPortName,
HostPort: cr.Spec.Sharding.Mongos.HostPort,
ContainerPort: cr.Spec.Sharding.Mongos.Port,
},
},
Env: []corev1.EnvVar{
{
Name: "MONGODB_PORT",
Value: strconv.Itoa(int(cr.Spec.Sharding.Mongos.Port)),
},
},
EnvFrom: []corev1.EnvFromSource{
{
SecretRef: &corev1.SecretEnvSource{
LocalObjectReference: corev1.LocalObjectReference{
Name: cr.Spec.Secrets.Users,
},
Optional: &fvar,
},
},
{
SecretRef: &corev1.SecretEnvSource{
LocalObjectReference: corev1.LocalObjectReference{
Name: api.UserSecretName(cr),
},
Optional: &fvar,
},
},
},
WorkingDir: MongodContainerDataDir,
LivenessProbe: &cr.Spec.Sharding.Mongos.LivenessProbe.Probe,
ReadinessProbe: cr.Spec.Sharding.Mongos.ReadinessProbe,
SecurityContext: cr.Spec.Sharding.Mongos.ContainerSecurityContext,
Resources: resources,
VolumeMounts: volumes,
Command: []string{"/data/db/ps-entry.sh"},
}
return container, nil
}
func mongosContainerArgs(cr *api.PerconaServerMongoDB, resources corev1.ResourceRequirements, useConfigFile bool, cfgInstances []string) []string {
mdSpec := cr.Spec.Mongod
msSpec := cr.Spec.Sharding.Mongos
cfgRs := cr.Spec.Sharding.ConfigsvrReplSet
// sort config instances to prevent unnecessary updates
sort.Strings(cfgInstances)
configDB := fmt.Sprintf("%s/%s", cfgRs.Name, strings.Join(cfgInstances, ","))
args := []string{
"mongos",
"--bind_ip_all",
"--port=" + strconv.Itoa(int(msSpec.Port)),
"--sslAllowInvalidCertificates",
"--configdb",
configDB,
}
if cr.CompareVersion("1.7.0") >= 0 {
args = append(args,
"--relaxPermChecks",
)
}
if cr.Spec.UnsafeConf {
args = append(args,
"--clusterAuthMode=keyFile",
"--keyFile="+mongodSecretsDir+"/mongodb-key",
)
} else {
args = append(args,
"--sslMode=preferSSL",
"--clusterAuthMode=x509",
)
}
if mdSpec.Security != nil && mdSpec.Security.RedactClientLogData {
args = append(args, "--redactClientLogData")
}
if msSpec.SetParameter != nil {
if msSpec.SetParameter.CursorTimeoutMillis > 0 {
args = append(args,
"--setParameter",
"cursorTimeoutMillis="+strconv.Itoa(msSpec.SetParameter.CursorTimeoutMillis),
)
}
}
if msSpec.AuditLog != nil && msSpec.AuditLog.Destination == api.AuditLogDestinationFile {
if msSpec.AuditLog.Filter == "" {
msSpec.AuditLog.Filter = "{}"
}
args = append(args,
"--auditDestination=file",
"--auditFilter="+msSpec.AuditLog.Filter,
"--auditFormat="+string(msSpec.AuditLog.Format),
)
switch msSpec.AuditLog.Format {
case api.AuditLogFormatBSON:
args = append(args, "--auditPath="+MongodContainerDataDir+"/auditLog.bson")
default:
args = append(args, "--auditPath="+MongodContainerDataDir+"/auditLog.json")
}
}
if useConfigFile {
args = append(args, fmt.Sprintf("--config=%s/mongos.conf", mongosConfigDir))
}
return args
}
func volumes(cr *api.PerconaServerMongoDB, configSource VolumeSourceType) []corev1.Volume | {
fvar, tvar := false, true
volumes := []corev1.Volume{
{
Name: InternalKey(cr),
VolumeSource: corev1.VolumeSource{
Secret: &corev1.SecretVolumeSource{
DefaultMode: &secretFileMode,
SecretName: InternalKey(cr),
Optional: &fvar,
},
},
},
{
Name: "ssl",
VolumeSource: corev1.VolumeSource{
Secret: &corev1.SecretVolumeSource{
SecretName: cr.Spec.Secrets.SSL,
Optional: &cr.Spec.UnsafeConf, | identifier_body | |
gridview.rs | ust_planned].commands_to_finalize.push(cmd)
}
pub fn rollback(&mut self, new_snapshot: &Snapshot) {
let old_planned: Vec<_> = self.planned.drain(..).collect();
self.planned
.push_back(new_snapshot.new_with_same_droplets());
assert_eq!(self.planned.len(), 1);
for planned_snapshot in old_planned {
planned_snapshot.abort(self)
}
}
pub fn perturb(&self, rng: &mut impl Rng, snapshot: &Snapshot) -> Option<Snapshot> {
let now = snapshot;
let then = self.completed.last()?;
let id = {
let ids: Vec<_> = now.droplets.keys().collect();
match rng.choose(ids.as_slice()) {
Some(&&id) => id,
None => return None,
}
};
let mut now2 = now.new_with_same_droplets();
if let Some(old_droplet) = then.droplets.get(&id) {
let was_there = now2.droplets.insert(id, old_droplet.clone());
assert!(was_there.is_some());
}
Some(now2)
}
pub fn add_error_edges(&mut self, planned: &Snapshot, actual: &Snapshot) {
let previous = self.completed.last().unwrap();
let edges = previous.get_error_edges(planned, actual);
let n_edges = edges.len();
warn!(
"Added error {} edges, now there are {}: {:?}",
n_edges,
self.bad_edges.len() / 2,
edges,
);
for (loc1, loc2) in edges {
// for now, insert edges both ways
self.bad_edges.insert((loc1, loc2));
self.bad_edges.insert((loc2, loc1));
}
}
}
pub struct GridSubView<'a> {
backing_gridview: &'a mut GridView,
mapping: Map<Location, Location>,
ids: Set<DropletId>,
}
impl<'a> GridSubView<'a> {
pub fn tick(&mut self) {
self.backing_gridview.tick()
}
#[cfg(feature = "pi")]
pub fn with_pi<T>(&mut self, f: impl FnOnce(&mut RaspberryPi) -> T) -> Option<T> {
self.backing_gridview.pi.as_mut().map(f)
}
pub fn get_electrode(&self, loc: &Location) -> Option<&Electrode> {
let actual_loc = self.mapping.get(loc)?;
self.backing_gridview.grid.get_cell(&actual_loc)
}
// TODO: translate or somehow hide the untranslated location of this
pub fn get(&self, id: &DropletId) -> &Droplet {
assert!(self.ids.contains(&id));
&self.backing_gridview.snapshot().droplets[id]
}
fn get_mut(&mut self, id: &DropletId) -> &mut Droplet {
assert!(self.ids.contains(&id));
self.backing_gridview
.snapshot_mut()
.droplets
.get_mut(id)
.unwrap()
}
pub fn insert(&mut self, mut droplet: Droplet) {
let new_loc = self.mapping.get(&droplet.location);
trace!("Inserting {:#?} at {:?}", droplet, new_loc);
droplet.location = *new_loc.unwrap();
let was_not_there = self.ids.insert(droplet.id);
assert!(was_not_there);
let snapshot = self.backing_gridview.snapshot_mut();
let was_there = snapshot.droplets.insert(droplet.id, droplet);
assert!(was_there.is_none());
}
pub fn remove(&mut self, id: &DropletId) -> Droplet {
let was_there = self.ids.remove(id);
assert!(was_there);
let snapshot = self.backing_gridview.snapshot_mut();
let mut droplet = snapshot.droplets.remove(id).unwrap();
// FIXME this is pretty dumb
let (unmapped_loc, _) = self
.mapping
.iter()
.find(|(_, &v)| v == droplet.location)
.unwrap();
droplet.location = *unmapped_loc;
droplet
}
fn check_droplet(&self, id: &DropletId) {
// TODO will this have translated or real location??
let droplet = self.get(id);
let mapped_to: Set<_> = self.mapping.values().collect();
// TODO this is pretty slow
for i in 0..droplet.dimensions.y {
for j in 0..droplet.dimensions.x {
let loc = Location {
y: droplet.location.y + i,
x: droplet.location.x + j,
};
if !mapped_to.contains(&loc) {
panic!("{} was unmapped!, mapping: {:#?}", loc, self.mapping);
}
}
}
}
fn update(&mut self, id: &DropletId, func: impl FnOnce(&mut Droplet)) {
func(self.get_mut(id));
self.check_droplet(id);
}
pub fn move_west(&mut self, id: DropletId) {
trace!("Moving droplet {:?} west", id);
self.update(&id, |droplet| {
droplet.location = droplet.location.west();
})
}
pub fn move_east(&mut self, id: DropletId) {
trace!("Moving droplet {:?} east", id);
self.update(&id, |droplet| {
droplet.location = droplet.location.east();
})
}
pub fn move_north(&mut self, id: DropletId) {
trace!("Moving droplet {:?} north", id);
self.update(&id, |droplet| {
droplet.location = droplet.location.north();
})
}
pub fn move_south(&mut self, id: DropletId) {
trace!("Moving droplet {:?} south", id);
self.update(&id, |droplet| {
droplet.location = droplet.location.south();
})
}
}
#[cfg(test)]
pub mod tests {
use super::*;
use grid::parse::tests::parse_strings;
pub fn id2c(id: &DropletId) -> char {
assert!(id.id < 255);
(id.id as u8) as char
}
pub fn c2id(c: char) -> DropletId {
for u in 0x00u8..0xff {
let c2 = u as char;
if c == c2 {
return DropletId {
id: u as usize,
process_id: 0,
};
}
}
panic!("Can't make {} a u8", c);
}
pub fn parse_gridview(strs: &[&str]) -> GridView {
// same chars are guaranteed to have the same ids
let (grid, blobs) = parse_strings(&strs);
let mut snapshot = Snapshot::default();
for (ch, blob) in blobs.iter() {
let id = c2id(*ch);
snapshot.droplets.insert(id, blob.to_droplet(id));
}
let mut gv = GridView::new(grid);
gv.planned[0] = snapshot;
gv
}
pub fn parse_snapshot(strs: &[&str]) -> Snapshot {
let mut gv = parse_gridview(strs);
gv.planned.remove(0).unwrap()
}
fn check_all_matched(
snapshot_strs: &[&str],
blob_strs: &[&str],
) -> Option<Map<DropletId, SimpleBlob>> {
let snapshot = parse_snapshot(&snapshot_strs);
let (_, chip_blobs) = parse_strings(&blob_strs);
let blobs: Vec<SimpleBlob> = chip_blobs.values().cloned().collect();
let result: Map<DropletId, SimpleBlob> = snapshot.match_with_blobs(&blobs)?;
// create the expected map by mapping the ids in the snapshot
// to the associated blob which corresponds to the character
let mut expected: Map<DropletId, SimpleBlob> = Map::new();
for id in snapshot.droplets.keys() {
expected.insert(*id, chip_blobs[&id2c(id)].clone());
}
for id in expected.keys() {
// we can't compare blobs or droplets, so we get the droplet_info
assert_eq!(
result.get(id).map(|blob| blob.to_droplet(*id).info()),
expected.get(id).map(|blob| blob.to_droplet(*id).info())
)
}
Some(result)
}
#[test]
fn test_no_diff() {
let strs = vec![
"aa..........c",
".....bb......",
".............",
".............",
];
assert!(check_all_matched(&strs, &strs).is_some());
}
#[test]
fn test_location_diff() {
let exec_strs = vec![
"aa..........c",
".....bb......",
".............",
".............",
];
let chip_strs = vec![
"aa...........",
"............c",
".....bb......",
".............", | ]; | random_line_split | |
gridview.rs | let mut ids = vec![]; // store corresponding ids to indeces
let mut matches = vec![]; // store similarity between blobs/droplets
let n = blobs.len();
// store the id of each droplet in its corresponding
// index in 'ids', then store the similarity of each
// droplet to each blob in 'matches'
for (&id, droplet) in &self.droplets {
ids.push(id);
for blob in blobs {
let similarity = blob.get_similarity(&droplet);
// must be non-negative for the algorithm to work
assert!(similarity >= 0);
matches.push(similarity);
}
}
// convert the matches vector to a matrix
// input should be [1,2,3,4], where the output
// matrix is [[1,2],[3,4]]
let m: Matrix<i32> = Matrix::from_vec(n, n, matches);
// km is a vector of size n where the value at each index
// corresponds to the index of a blob
let (_c, km) = kuhn_munkres_min(&m);
for i in 0..n {
result.insert(ids[i], blobs[km[i]].clone());
}
Some(result)
}
// this will take commands_to_finalize from the old snapshot into the new
// one if an error is found produced
pub fn correct(&mut self, blobs: &[impl Blob]) -> Option<Snapshot> {
let blob_matching = self.match_with_blobs(blobs)?;
let mut was_error = false;
let new_droplets: Map<_, _> = blob_matching
.iter()
.map(|(&id, blob)| {
let d = self.droplets.get_mut(&id).unwrap();
let d_new = blob.to_droplet(id);
if d.location != d_new.location || d.dimensions != d_new.dimensions {
info!("Found error in droplet {:?}", id);
debug!("Droplet error\n Expected: {:#?}\n Found: {:#?}", d, d_new);
was_error = true;
}
// HACK FIXME this mutation is not great
if (d.volume - d_new.volume).abs() > 1.0 {
info!(
"volume of {} changed: {} -> {}",
id.id, d.volume, d_new.volume
)
}
d.volume = d_new.volume;
(id, d_new)
}).collect();
if was_error {
let mut new_snapshot = Snapshot {
droplets: new_droplets,
commands_to_finalize: Vec::new(),
};
::std::mem::swap(
&mut new_snapshot.commands_to_finalize,
&mut self.commands_to_finalize,
);
Some(new_snapshot)
} else {
None
}
}
pub fn diff_droplet(&self, id: &DropletId, other: &Snapshot) -> DropletDiff {
use self::DropletDiff::*;
let droplet = self
.droplets
.get(id)
.expect("id should be in self snapshot");
if let Some(other_droplet) = other.droplets.get(id) {
// NOTE we only care about location diffs for now
let loc = droplet.location;
let other_loc = other_droplet.location;
if loc != other_loc {
// for now, just assert that we are only moving one spot at a time
// FIXME HACK
// assert_eq!((&loc - &other_loc).norm(), 1);
Moved {
from: loc,
to: other_loc,
}
} else {
DidNotMove
}
} else {
Disappeared
}
}
pub fn get_error_edges(
&self,
planned_outcome: &Snapshot,
actual_outcome: &Snapshot,
) -> Vec<(Location, Location)> {
use self::DropletDiff::*;
self.droplets
.keys()
.filter_map(|id| {
let planned_diff = self.diff_droplet(id, planned_outcome);
let actual_diff = self.diff_droplet(id, actual_outcome);
match (planned_diff, actual_diff) {
(Moved { from, to }, DidNotMove) => {
if (&from - &to).norm() == 1 {
Some((from, to))
} else {
warn!("Droplet {} jumped from {} to {}!", id.id, from, to);
None
}
}
_ => None,
}
}).collect()
}
}
#[derive(Debug)]
pub enum ExecResponse {
Step(Snapshot),
NotReady,
Done,
}
impl GridView {
pub fn new(grid: Grid) -> GridView {
let mut planned = VecDeque::new();
planned.push_back(Snapshot::default());
#[cfg(feature = "pi")]
let pi = match ::std::env::var("PUDDLE_PI") {
Ok(s) => if s == "1" {
let mut pi = RaspberryPi::new().unwrap();
info!("Initialized the pi!");
Some(pi)
} else {
warn!("Couldn't read PUDDLE_PI={}", s);
None
},
Err(_) => {
info!("Did not start the pi!");
None
}
};
GridView {
grid: grid,
planned,
completed: Vec::new(),
done: false,
bad_edges: Set::new(),
#[cfg(feature = "pi")]
pi,
}
}
pub fn close(&mut self) {
info!("Marking gridview as DONE!");
self.done = true;
}
pub fn execute(&mut self) -> ExecResponse {
use self::ExecResponse::*;
// compare with len - 1 because we wouldn't want to "write out" a state
// that hasn't been fully planned
let resp = if let Some(planned_snapshot) = self.planned.pop_front() {
Step(planned_snapshot)
} else if self.done {
Done
} else {
NotReady
};
trace!(
"execute sending {:?}. Completed: {}, planned: {}.",
resp,
self.completed.len(),
self.planned.len(),
);
resp
}
pub fn commit_pending(&mut self, mut snapshot: Snapshot) {
#[cfg(not(feature = "pi"))]
snapshot.finalize();
#[cfg(feature = "pi")]
snapshot.finalize(self.pi.as_mut());
self.completed.push(snapshot);
}
pub fn snapshot(&self) -> &Snapshot {
self.planned.back().unwrap()
}
// TODO probably shouldn't provide this
pub fn snapshot_mut(&mut self) -> &mut Snapshot |
pub fn snapshot_ensure(&mut self) {
if self.planned.is_empty() {
let last = self.completed.last().unwrap();
self.planned.push_back(last.new_with_same_droplets())
}
}
pub fn exec_snapshot(&self) -> &Snapshot {
self.completed.last().unwrap()
}
fn tick(&mut self) {
let new_snapshot = {
let just_planned = self.planned.back().unwrap();
if let Some(col) = just_planned.get_collision() {
panic!("collision: {:#?}", col);
};
just_planned.new_with_same_droplets()
};
self.planned.push_back(new_snapshot);
trace!("TICK! len={}", self.planned.len());
}
fn update(&mut self, id: DropletId, func: impl FnOnce(&mut Droplet)) {
let now = self.planned.back_mut().unwrap();
let droplet = now
.droplets
.get_mut(&id)
.unwrap_or_else(|| panic!("Tried to remove a non-existent droplet: {:?}", id));
func(droplet);
}
pub fn plan_droplet_info(&self, pid_option: Option<ProcessId>) -> Vec<DropletInfo> {
// gets from the planner for now
self.planned.back().unwrap().droplet_info(pid_option)
}
pub fn take_paths(&mut self, paths: &Map<DropletId, Path>, final_tick: bool) {
let max_len = paths.values().map(|path| path.len()).max().unwrap_or(0);
// make sure that all droplets start where they are at this time step
for (id, path) in paths.iter() {
let snapshot = self.planned.back().unwrap();
let droplet = &snapshot.droplets[&id];
assert_eq!(droplet.location, path[0]);
}
for i in 1..max_len {
for (&id, path) in paths.iter() {
if i < path.len() {
self.update(id, |droplet| {
assert!(droplet.location.distance_to(&path[i]) <= 1);
droplet.location = path[i];
});
}
}
if i < max_len - 1 || final_tick {
self.tick();
}
}
}
pub fn subview(
&mut self,
ids: impl IntoIterator<Item = DropletId>,
mapping: Map<Location, Location>,
) -> GridSubView {
GridSubView {
backing_gridview: self,
mapping: mapping,
ids: ids.into | {
self.planned.back_mut().unwrap()
} | identifier_body |
gridview.rs | {
Disappeared,
DidNotMove,
Moved { from: Location, to: Location },
}
impl Snapshot {
pub fn new_with_same_droplets(&self) -> Snapshot {
let mut new_snapshot = Snapshot::default();
new_snapshot.droplets = self.droplets.clone();
// clear out the destination because we're doing to replan
for d in new_snapshot.droplets.values_mut() {
d.destination = None;
}
new_snapshot
}
#[cfg(not(feature = "pi"))]
fn finalize(&mut self) {
// we need to drain this so we can mutate the command without mutating
// self, as we need to pass self into cmd.finalize
// this feels pretty ugly....
let mut x: Vec<_> = self.commands_to_finalize.drain(..).collect();
for cmd in &mut x {
debug!("Finalizing command: {:#?}", cmd);
cmd.finalize(self)
}
self.commands_to_finalize = x;
}
#[cfg(feature = "pi")]
fn finalize(&mut self, pi: Option<&mut RaspberryPi>) {
// we need to drain this so we can mutate the command without mutating
// self, as we need to pass self into cmd.finalize
// this feels pretty ugly....
let mut x: Vec<_> = self.commands_to_finalize.drain(..).collect();
if let Some(pi) = pi {
for cmd in &mut x {
debug!("Finalizing command: {:#?}", cmd);
cmd.finalize(self, Some(pi))
}
} else {
for cmd in &mut x {
debug!("Finalizing command: {:#?}", cmd);
cmd.finalize(self, None)
}
}
self.commands_to_finalize = x;
}
pub fn abort(mut self, gridview: &mut GridView) {
for mut cmd in self.commands_to_finalize.drain(..) {
debug!("Sending command back for replanning: {:#?}", cmd);
if let Err((mut cmd, err)) = gridview.plan(cmd) {
cmd.abort(err);
}
}
}
pub fn droplet_info(&self, pid_option: Option<ProcessId>) -> Vec<DropletInfo> {
self.droplets
.values()
.filter(|&d| pid_option.map_or(true, |pid| d.id.process_id == pid))
.map(|d| d.info())
.collect()
}
/// Returns an invalid droplet, if any.
fn get_collision(&self) -> Option<(i32, Droplet, Droplet)> {
for (id1, droplet1) in &self.droplets {
for (id2, droplet2) in &self.droplets {
if id1 == id2 {
continue;
}
if droplet1.collision_group == droplet2.collision_group {
continue;
}
let distance = droplet1.collision_distance(droplet2);
if distance <= 0 {
return Some((distance, droplet1.clone(), droplet2.clone()));
}
}
}
None
}
pub fn to_blobs(&self) -> Vec<SimpleBlob> {
self.droplets.values().map(|d| d.to_blob()).collect()
}
/// Takes a map of droplet ids to droplets (as in that
/// of the planner/executor view) and a vector of blobs
/// (as in that of the chip view) and returns a matching
/// of droplet ids to closest matching blobs.
///
/// Can currently only handle where both views contain
/// the same number of 'droplets'
fn match_with_blobs<B: Blob>(&self, blobs: &[B]) -> Option<Map<DropletId, B>> {
// Ensure lengths are the same
if self.droplets.len() != blobs.len() {
error!("Expected and actual droplets are of different lengths");
return None;
}
let mut result = Map::new(); // to be returned
let mut ids = vec![]; // store corresponding ids to indeces
let mut matches = vec![]; // store similarity between blobs/droplets
let n = blobs.len();
// store the id of each droplet in its corresponding
// index in 'ids', then store the similarity of each
// droplet to each blob in 'matches'
for (&id, droplet) in &self.droplets {
ids.push(id);
for blob in blobs {
let similarity = blob.get_similarity(&droplet);
// must be non-negative for the algorithm to work
assert!(similarity >= 0);
matches.push(similarity);
}
}
// convert the matches vector to a matrix
// input should be [1,2,3,4], where the output
// matrix is [[1,2],[3,4]]
let m: Matrix<i32> = Matrix::from_vec(n, n, matches);
// km is a vector of size n where the value at each index
// corresponds to the index of a blob
let (_c, km) = kuhn_munkres_min(&m);
for i in 0..n {
result.insert(ids[i], blobs[km[i]].clone());
}
Some(result)
}
// this will take commands_to_finalize from the old snapshot into the new
// one if an error is found produced
pub fn correct(&mut self, blobs: &[impl Blob]) -> Option<Snapshot> {
let blob_matching = self.match_with_blobs(blobs)?;
let mut was_error = false;
let new_droplets: Map<_, _> = blob_matching
.iter()
.map(|(&id, blob)| {
let d = self.droplets.get_mut(&id).unwrap();
let d_new = blob.to_droplet(id);
if d.location != d_new.location || d.dimensions != d_new.dimensions {
info!("Found error in droplet {:?}", id);
debug!("Droplet error\n Expected: {:#?}\n Found: {:#?}", d, d_new);
was_error = true;
}
// HACK FIXME this mutation is not great
if (d.volume - d_new.volume).abs() > 1.0 {
info!(
"volume of {} changed: {} -> {}",
id.id, d.volume, d_new.volume
)
}
d.volume = d_new.volume;
(id, d_new)
}).collect();
if was_error {
let mut new_snapshot = Snapshot {
droplets: new_droplets,
commands_to_finalize: Vec::new(),
};
::std::mem::swap(
&mut new_snapshot.commands_to_finalize,
&mut self.commands_to_finalize,
);
Some(new_snapshot)
} else {
None
}
}
pub fn diff_droplet(&self, id: &DropletId, other: &Snapshot) -> DropletDiff {
use self::DropletDiff::*;
let droplet = self
.droplets
.get(id)
.expect("id should be in self snapshot");
if let Some(other_droplet) = other.droplets.get(id) {
// NOTE we only care about location diffs for now
let loc = droplet.location;
let other_loc = other_droplet.location;
if loc != other_loc {
// for now, just assert that we are only moving one spot at a time
// FIXME HACK
// assert_eq!((&loc - &other_loc).norm(), 1);
Moved {
from: loc,
to: other_loc,
}
} else {
DidNotMove
}
} else {
Disappeared
}
}
pub fn get_error_edges(
&self,
planned_outcome: &Snapshot,
actual_outcome: &Snapshot,
) -> Vec<(Location, Location)> {
use self::DropletDiff::*;
self.droplets
.keys()
.filter_map(|id| {
let planned_diff = self.diff_droplet(id, planned_outcome);
let actual_diff = self.diff_droplet(id, actual_outcome);
match (planned_diff, actual_diff) {
(Moved { from, to }, DidNotMove) => {
if (&from - &to).norm() == 1 {
Some((from, to))
} else {
warn!("Droplet {} jumped from {} to {}!", id.id, from, to);
None
}
}
_ => None,
}
}).collect()
}
}
#[derive(Debug)]
pub enum ExecResponse {
Step(Snapshot),
NotReady,
Done,
}
impl GridView {
pub fn new(grid: Grid) -> GridView {
let mut planned = VecDeque::new();
planned.push_back(Snapshot::default());
#[cfg(feature = "pi")]
let pi = match ::std::env::var("PUDDLE_PI") {
Ok(s) => if s == "1" {
let mut pi = RaspberryPi::new().unwrap();
info!("Initialized the pi!");
Some(pi)
} else {
warn!("Couldn't read PUDDLE_PI={}", s);
None
},
Err(_) => {
info!("Did not start the pi!");
None
}
};
| DropletDiff | identifier_name | |
wix.rs | data structure is needed because WIX requires each path to have its own `id` and `guid`.
#[derive(Serialize)]
struct | {
/// the GUID to use on the WIX XML.
guid: String,
/// the id to use on the WIX XML.
id: String,
/// the binary path.
path: String,
}
/// A Resource file to bundle with WIX.
/// This data structure is needed because WIX requires each path to have its own `id` and `guid`.
#[derive(Serialize, Clone)]
struct ResourceFile {
/// the GUID to use on the WIX XML.
guid: String,
/// the id to use on the WIX XML.
id: String,
/// the file path.
path: String,
}
/// A resource directory to bundle with WIX.
/// This data structure is needed because WIX requires each path to have its own `id` and `guid`.
#[derive(Serialize)]
struct ResourceDirectory {
/// the directory name of the described resource.
name: String,
/// the files of the described resource directory.
files: Vec<ResourceFile>,
/// the directories that are children of the described resource directory.
directories: Vec<ResourceDirectory>,
}
impl ResourceDirectory {
/// Adds a file to this directory descriptor.
fn add_file(&mut self, file: ResourceFile) {
self.files.push(file);
}
/// Generates the wix XML string to bundle this directory resources recursively
fn get_wix_data(self) -> crate::Result<(String, Vec<String>)> {
let mut files = String::from("");
let mut file_ids = Vec::new();
for file in self.files {
file_ids.push(file.id.clone());
files.push_str(
format!(
r#"<Component Id="{id}" Guid="{guid}" Win64="$(var.Win64)" KeyPath="yes"><File Id="PathFile_{id}" Source="{path}" /></Component>"#,
id = file.id,
guid = file.guid,
path = file.path
).as_str()
);
}
let mut directories = String::from("");
for directory in self.directories {
let (wix_string, ids) = directory.get_wix_data()?;
for id in ids {
file_ids.push(id)
}
directories.push_str(wix_string.as_str());
}
let wix_string = format!(
r#"<Directory Id="{name}" Name="{name}">{contents}</Directory>"#,
name = self.name,
contents = format!("{}{}", files, directories)
);
Ok((wix_string, file_ids))
}
}
/// Copies the icons to the binary path, under the `resources` folder,
/// and returns the path to that directory.
fn copy_icons(settings: &Settings) -> crate::Result<PathBuf> {
let base_dir = settings.project_out_directory();
let resource_dir = base_dir.join("resources");
let mut image_path = PathBuf::from(settings.project_out_directory());
// pop off till in tauri_src dir
image_path.pop();
image_path.pop();
// get icon dir and icon file.
let image_path = image_path.join("icons");
let opts = super::path_utils::Options::default();
copy(
image_path,
&resource_dir,
&Options {
copy_files: true,
overwrite: true,
..opts
},
)?;
Ok(resource_dir)
}
/// Function used to download Wix and VC_REDIST. Checks SHA256 to verify the download.
fn download_and_verify(url: &str, hash: &str) -> crate::Result<Vec<u8>> {
common::print_info(format!("Downloading {}", url).as_str())?;
let response = attohttpc::get(url).send()?;
let data: Vec<u8> = response.bytes()?;
common::print_info("validating hash")?;
let mut hasher = sha2::Sha256::new();
hasher.update(&data);
let url_hash = hasher.finalize().to_vec();
let expected_hash = hex::decode(hash)?;
if expected_hash == url_hash {
Ok(data)
} else {
Err(crate::Error::HashError)
}
}
/// The installer directory of the app.
fn app_installer_dir(settings: &Settings) -> crate::Result<PathBuf> {
let arch = match settings.binary_arch() {
"x86" => "x86",
"x86_64" => "x64",
target => {
return Err(crate::Error::ArchError(format!(
"Unsupported architecture: {}",
target
)))
}
};
let package_base_name = format!(
"{}_{}_{}",
settings.main_binary_name().replace(".exe", ""),
settings.version_string(),
arch
);
Ok(
settings
.project_out_directory()
.to_path_buf()
.join(format!("bundle/msi/{}.msi", package_base_name)),
)
}
/// Extracts the zips from Wix and VC_REDIST into a useable path.
fn extract_zip(data: &Vec<u8>, path: &Path) -> crate::Result<()> {
let cursor = Cursor::new(data);
let mut zipa = ZipArchive::new(cursor)?;
for i in 0..zipa.len() {
let mut file = zipa.by_index(i)?;
let dest_path = path.join(file.name());
let parent = dest_path.parent().expect("Failed to get parent");
if !parent.exists() {
create_dir_all(parent)?;
}
let mut buff: Vec<u8> = Vec::new();
file.read_to_end(&mut buff)?;
let mut fileout = File::create(dest_path).expect("Failed to open file");
fileout.write_all(&buff)?;
}
Ok(())
}
/// Generates the UUID for the Wix template.
fn generate_package_guid(settings: &Settings) -> Uuid {
generate_guid(settings.bundle_identifier().as_bytes())
}
/// Generates a GUID.
fn generate_guid(key: &[u8]) -> Uuid {
let namespace = Uuid::from_bytes(UUID_NAMESPACE);
Uuid::new_v5(&namespace, key)
}
// Specifically goes and gets Wix and verifies the download via Sha256
pub fn get_and_extract_wix(path: &Path) -> crate::Result<()> {
common::print_info("Verifying wix package")?;
let data = download_and_verify(WIX_URL, WIX_SHA256)?;
common::print_info("extracting WIX")?;
extract_zip(&data, path)
}
// For if bundler needs DLL files.
// fn run_heat_exe(
// wix_toolset_path: &Path,
// build_path: &Path,
// harvest_dir: &Path,
// platform: &str,
// ) -> Result<(), String> {
// let mut args = vec!["dir"];
// let harvest_str = harvest_dir.display().to_string();
// args.push(&harvest_str);
// args.push("-platform");
// args.push(platform);
// args.push("-cg");
// args.push("AppFiles");
// args.push("-dr");
// args.push("APPLICATIONFOLDER");
// args.push("-gg");
// args.push("-srd");
// args.push("-out");
// args.push("appdir.wxs");
// args.push("-var");
// args.push("var.SourceDir");
// let heat_exe = wix_toolset_path.join("heat.exe");
// let mut cmd = Command::new(&heat_exe)
// .args(&args)
// .stdout(Stdio::piped())
// .current_dir(build_path)
// .spawn()
// .expect("error running heat.exe");
// {
// let stdout = cmd.stdout.as_mut().unwrap();
// let reader = BufReader::new(stdout);
// for line in reader.lines() {
// info!(logger, "{}", line.unwrap());
// }
// }
// let status = cmd.wait().unwrap();
// if status.success() {
// Ok(())
// } else {
// Err("error running heat.exe".to_string())
// }
// }
/// Runs the Candle.exe executable for Wix. Candle parses the wxs file and generates the code for building the installer.
fn run_candle(
settings: &Settings,
wix_toolset_path: &Path,
build_path: &Path,
wxs_file_name: &str,
) -> crate::Result<()> {
let arch = match settings.binary_arch() {
"x86_64" => "x64",
"x86" => "x86",
target => {
return Err(crate::Error::ArchError(format!(
"unsupported target: {}",
target
)))
}
};
let main_binary = settings
.binaries()
.iter()
.find(|bin| bin.main())
.ok_or_else(|| anyhow::anyhow!("Failed to get main binary"))?;
let args = vec![
"-arch".to_string(),
arch.to_string(),
wxs_file_name.to_string(),
format!(
"-dSourceDir={}",
settings.binary_path(main_binary).display()
),
];
let candle_exe = wix_toolset_path.join("candle.exe");
common::print_info(format!("running candle for {}", wxs_file_name).as_str())?;
let mut cmd = Command::new(&candle_exe);
cmd | Binary | identifier_name |
wix.rs | data structure is needed because WIX requires each path to have its own `id` and `guid`.
#[derive(Serialize)]
struct Binary {
/// the GUID to use on the WIX XML.
guid: String,
/// the id to use on the WIX XML.
id: String,
/// the binary path.
path: String,
}
/// A Resource file to bundle with WIX.
/// This data structure is needed because WIX requires each path to have its own `id` and `guid`.
#[derive(Serialize, Clone)]
struct ResourceFile {
/// the GUID to use on the WIX XML.
guid: String,
/// the id to use on the WIX XML.
id: String,
/// the file path.
path: String,
}
/// A resource directory to bundle with WIX.
/// This data structure is needed because WIX requires each path to have its own `id` and `guid`.
#[derive(Serialize)]
struct ResourceDirectory {
/// the directory name of the described resource.
name: String,
/// the files of the described resource directory.
files: Vec<ResourceFile>,
/// the directories that are children of the described resource directory.
directories: Vec<ResourceDirectory>,
}
impl ResourceDirectory {
/// Adds a file to this directory descriptor.
fn add_file(&mut self, file: ResourceFile) {
self.files.push(file);
}
/// Generates the wix XML string to bundle this directory resources recursively
fn get_wix_data(self) -> crate::Result<(String, Vec<String>)> {
let mut files = String::from("");
let mut file_ids = Vec::new();
for file in self.files {
file_ids.push(file.id.clone());
files.push_str(
format!(
r#"<Component Id="{id}" Guid="{guid}" Win64="$(var.Win64)" KeyPath="yes"><File Id="PathFile_{id}" Source="{path}" /></Component>"#,
id = file.id,
guid = file.guid,
path = file.path
).as_str()
);
}
let mut directories = String::from("");
for directory in self.directories {
let (wix_string, ids) = directory.get_wix_data()?;
for id in ids {
file_ids.push(id)
}
directories.push_str(wix_string.as_str());
}
let wix_string = format!(
r#"<Directory Id="{name}" Name="{name}">{contents}</Directory>"#,
name = self.name,
contents = format!("{}{}", files, directories)
);
Ok((wix_string, file_ids))
}
}
/// Copies the icons to the binary path, under the `resources` folder,
/// and returns the path to that directory.
fn copy_icons(settings: &Settings) -> crate::Result<PathBuf> {
let base_dir = settings.project_out_directory();
let resource_dir = base_dir.join("resources");
let mut image_path = PathBuf::from(settings.project_out_directory());
// pop off till in tauri_src dir
image_path.pop();
image_path.pop();
// get icon dir and icon file.
let image_path = image_path.join("icons");
let opts = super::path_utils::Options::default();
copy(
image_path,
&resource_dir,
&Options {
copy_files: true,
overwrite: true,
..opts
},
)?;
Ok(resource_dir)
}
/// Function used to download Wix and VC_REDIST. Checks SHA256 to verify the download.
fn download_and_verify(url: &str, hash: &str) -> crate::Result<Vec<u8>> {
common::print_info(format!("Downloading {}", url).as_str())?;
let response = attohttpc::get(url).send()?;
let data: Vec<u8> = response.bytes()?;
common::print_info("validating hash")?;
let mut hasher = sha2::Sha256::new();
hasher.update(&data);
let url_hash = hasher.finalize().to_vec();
let expected_hash = hex::decode(hash)?;
if expected_hash == url_hash {
Ok(data)
} else {
Err(crate::Error::HashError)
}
}
/// The installer directory of the app.
fn app_installer_dir(settings: &Settings) -> crate::Result<PathBuf> {
let arch = match settings.binary_arch() {
"x86" => "x86",
"x86_64" => "x64",
target => {
return Err(crate::Error::ArchError(format!(
"Unsupported architecture: {}",
target
)))
}
};
let package_base_name = format!(
"{}_{}_{}",
settings.main_binary_name().replace(".exe", ""),
settings.version_string(),
arch
);
Ok(
settings
.project_out_directory()
.to_path_buf()
.join(format!("bundle/msi/{}.msi", package_base_name)),
)
}
/// Extracts the zips from Wix and VC_REDIST into a useable path.
fn extract_zip(data: &Vec<u8>, path: &Path) -> crate::Result<()> {
let cursor = Cursor::new(data);
let mut zipa = ZipArchive::new(cursor)?;
for i in 0..zipa.len() {
let mut file = zipa.by_index(i)?;
let dest_path = path.join(file.name());
let parent = dest_path.parent().expect("Failed to get parent");
if !parent.exists() {
create_dir_all(parent)?;
}
let mut buff: Vec<u8> = Vec::new();
file.read_to_end(&mut buff)?;
let mut fileout = File::create(dest_path).expect("Failed to open file");
fileout.write_all(&buff)?;
}
Ok(())
}
/// Generates the UUID for the Wix template.
fn generate_package_guid(settings: &Settings) -> Uuid {
generate_guid(settings.bundle_identifier().as_bytes())
}
/// Generates a GUID.
fn generate_guid(key: &[u8]) -> Uuid {
let namespace = Uuid::from_bytes(UUID_NAMESPACE);
Uuid::new_v5(&namespace, key)
}
// Specifically goes and gets Wix and verifies the download via Sha256
pub fn get_and_extract_wix(path: &Path) -> crate::Result<()> {
common::print_info("Verifying wix package")?;
let data = download_and_verify(WIX_URL, WIX_SHA256)?;
common::print_info("extracting WIX")?;
extract_zip(&data, path)
}
// For if bundler needs DLL files.
// fn run_heat_exe(
// wix_toolset_path: &Path,
// build_path: &Path,
// harvest_dir: &Path,
// platform: &str,
// ) -> Result<(), String> {
// let mut args = vec!["dir"];
// let harvest_str = harvest_dir.display().to_string();
// args.push(&harvest_str);
// args.push("-platform");
// args.push(platform);
// args.push("-cg");
// args.push("AppFiles");
// args.push("-dr");
// args.push("APPLICATIONFOLDER");
// args.push("-gg");
// args.push("-srd");
// args.push("-out");
// args.push("appdir.wxs");
// args.push("-var");
// args.push("var.SourceDir");
// let heat_exe = wix_toolset_path.join("heat.exe");
// let mut cmd = Command::new(&heat_exe)
// .args(&args)
// .stdout(Stdio::piped())
// .current_dir(build_path)
// .spawn()
// .expect("error running heat.exe");
// {
// let stdout = cmd.stdout.as_mut().unwrap();
// let reader = BufReader::new(stdout);
// for line in reader.lines() {
// info!(logger, "{}", line.unwrap());
// }
// }
// let status = cmd.wait().unwrap();
// if status.success() {
// Ok(())
// } else {
// Err("error running heat.exe".to_string())
// }
// }
/// Runs the Candle.exe executable for Wix. Candle parses the wxs file and generates the code for building the installer.
fn run_candle(
settings: &Settings,
wix_toolset_path: &Path,
build_path: &Path,
wxs_file_name: &str,
) -> crate::Result<()> | arch.to_string(),
wxs_file_name.to_string(),
format!(
"-dSourceDir={}",
settings.binary_path(main_binary).display()
),
];
let candle_exe = wix_toolset_path.join("candle.exe");
common::print_info(format!("running candle for {}", wxs_file_name).as_str())?;
let mut cmd = Command::new(&candle_exe);
cmd | {
let arch = match settings.binary_arch() {
"x86_64" => "x64",
"x86" => "x86",
target => {
return Err(crate::Error::ArchError(format!(
"unsupported target: {}",
target
)))
}
};
let main_binary = settings
.binaries()
.iter()
.find(|bin| bin.main())
.ok_or_else(|| anyhow::anyhow!("Failed to get main binary"))?;
let args = vec![
"-arch".to_string(), | identifier_body |
wix.rs | _else(|| anyhow::anyhow!("Failed to get main binary"))?;
let args = vec![
"-arch".to_string(),
arch.to_string(),
wxs_file_name.to_string(),
format!(
"-dSourceDir={}",
settings.binary_path(main_binary).display()
),
];
let candle_exe = wix_toolset_path.join("candle.exe");
common::print_info(format!("running candle for {}", wxs_file_name).as_str())?;
let mut cmd = Command::new(&candle_exe);
cmd
.args(&args)
.stdout(Stdio::piped())
.current_dir(build_path);
common::print_info("running candle.exe")?;
common::execute_with_output(&mut cmd).map_err(|_| crate::Error::CandleError)
}
/// Runs the Light.exe file. Light takes the generated code from Candle and produces an MSI Installer.
fn run_light(
wix_toolset_path: &Path,
build_path: &Path,
wixobjs: &[&str],
output_path: &Path,
) -> crate::Result<PathBuf> {
let light_exe = wix_toolset_path.join("light.exe");
let mut args: Vec<String> = vec![
"-ext".to_string(),
"WixUIExtension".to_string(),
"-o".to_string(),
output_path.display().to_string(),
];
for p in wixobjs {
args.push(p.to_string());
}
let mut cmd = Command::new(&light_exe);
cmd
.args(&args)
.stdout(Stdio::piped())
.current_dir(build_path);
common::print_info(format!("running light to produce {}", output_path.display()).as_str())?;
common::execute_with_output(&mut cmd)
.map(|_| output_path.to_path_buf())
.map_err(|_| crate::Error::LightError)
}
// fn get_icon_data() -> crate::Result<()> {
// Ok(())
// }
// Entry point for bundling and creating the MSI installer. For now the only supported platform is Windows x64.
pub fn build_wix_app_installer(
settings: &Settings,
wix_toolset_path: &Path,
) -> crate::Result<PathBuf> {
let arch = match settings.binary_arch() {
"x86_64" => "x64",
"x86" => "x86",
target => {
return Err(crate::Error::ArchError(format!(
"unsupported target: {}",
target
)))
}
};
// target only supports x64.
common::print_info(format!("Target: {}", arch).as_str())?;
let output_path = settings
.project_out_directory()
.join("bundle/msi")
.join(arch);
let mut data = BTreeMap::new();
if let Ok(tauri_config) = crate::bundle::tauri_config::get() {
data.insert(
"embedded_server",
to_json(tauri_config.tauri.embedded_server.active),
);
}
data.insert("product_name", to_json(settings.bundle_name()));
data.insert("version", to_json(settings.version_string()));
let manufacturer = settings.bundle_identifier().to_string();
data.insert("manufacturer", to_json(manufacturer.as_str()));
let upgrade_code = Uuid::new_v5(
&Uuid::NAMESPACE_DNS,
format!("{}.app.x64", &settings.main_binary_name()).as_bytes(),
)
.to_string();
data.insert("upgrade_code", to_json(&upgrade_code.as_str()));
let path_guid = generate_package_guid(settings).to_string();
data.insert("path_component_guid", to_json(&path_guid.as_str()));
let shortcut_guid = generate_package_guid(settings).to_string();
data.insert("shortcut_guid", to_json(&shortcut_guid.as_str()));
let app_exe_name = settings.main_binary_name().to_string();
data.insert("app_exe_name", to_json(&app_exe_name));
let binaries = generate_binaries_data(&settings)?;
let binaries_json = to_json(&binaries);
data.insert("binaries", binaries_json);
let resources = generate_resource_data(&settings)?;
let mut resources_wix_string = String::from("");
let mut files_ids = Vec::new();
for (_, dir) in resources {
let (wix_string, ids) = dir.get_wix_data()?;
resources_wix_string.push_str(wix_string.as_str());
for id in ids {
files_ids.push(id);
}
}
data.insert("resources", to_json(resources_wix_string));
data.insert("resource_file_ids", to_json(files_ids));
let main_binary = settings
.binaries()
.iter()
.find(|bin| bin.main())
.ok_or_else(|| anyhow::anyhow!("Failed to get main binary"))?;
let app_exe_source = settings.binary_path(main_binary).display().to_string();
data.insert("app_exe_source", to_json(&app_exe_source));
// copy icons from icons folder to resource folder near msi
let image_path = copy_icons(&settings)?;
let path = image_path.join("icon.ico").display().to_string();
data.insert("icon_path", to_json(path.as_str()));
let temp = HANDLEBARS.render("main.wxs", &data)?;
if output_path.exists() {
remove_dir_all(&output_path).or_else(|e| Err(e))?;
}
create_dir_all(&output_path).or_else(|e| Err(e))?;
let main_wxs_path = output_path.join("main.wxs");
write(&main_wxs_path, temp).or_else(|e| Err(e))?;
let input_basenames = vec!["main"];
for basename in &input_basenames {
let wxs = format!("{}.wxs", basename);
run_candle(settings, &wix_toolset_path, &output_path, &wxs)?;
}
let wixobjs = vec!["main.wixobj"];
let target = run_light(
&wix_toolset_path,
&output_path,
&wixobjs,
&app_installer_dir(settings)?,
)?;
Ok(target)
}
/// Generates the data required for the external binaries and extra binaries bundling.
fn generate_binaries_data(settings: &Settings) -> crate::Result<Vec<Binary>> {
let mut binaries = Vec::new();
let regex = Regex::new(r"[^\w\d\.]")?;
let cwd = std::env::current_dir()?;
for src in settings.external_binaries() {
let src = src?;
let filename = src
.file_name()
.expect("failed to extract external binary filename")
.to_os_string()
.into_string()
.expect("failed to convert external binary filename to string");
let guid = generate_guid(filename.as_bytes()).to_string();
binaries.push(Binary {
guid,
path: cwd
.join(src)
.into_os_string()
.into_string()
.expect("failed to read external binary path"),
id: regex.replace_all(&filename, "").to_string(),
});
}
for bin in settings.binaries() {
let filename = bin.name();
let guid = generate_guid(filename.as_bytes()).to_string();
if !bin.main() {
binaries.push(Binary {
guid,
path: settings
.binary_path(bin)
.into_os_string()
.into_string()
.expect("failed to read binary path"),
id: regex.replace_all(&filename, "").to_string(),
})
}
}
Ok(binaries)
}
/// Generates the data required for the resource bundling on wix
fn generate_resource_data(settings: &Settings) -> crate::Result<ResourceMap> {
let mut resources = ResourceMap::new();
let regex = Regex::new(r"[^\w\d\.]")?;
let cwd = std::env::current_dir()?;
for src in settings.resource_files() {
let src = src?;
let filename = src
.file_name()
.expect("failed to extract resource filename")
.to_os_string()
.into_string()
.expect("failed to convert resource filename to string");
let resource_path = cwd
.join(src.clone())
.into_os_string()
.into_string()
.expect("failed to read resource path");
let resource_entry = ResourceFile {
guid: generate_guid(filename.as_bytes()).to_string(),
path: resource_path,
id: regex.replace_all(&filename, "").to_string(),
};
// split the resource path directories
let mut directories = src
.components()
.filter(|component| {
let comp = component.as_os_str();
comp != "." && comp != ".."
})
.collect::<Vec<_>>();
directories.truncate(directories.len() - 1);
// transform the directory structure to a chained vec structure
for directory in directories {
let directory_name = directory
.as_os_str()
.to_os_string()
.into_string()
.expect("failed to read resource folder name");
// if the directory is already on the map
if resources.contains_key(&directory_name) {
let directory_entry = &mut resources
.get_mut(&directory_name)
.expect("Unable to handle resources");
if directory_entry.name == directory_name {
// the directory entry is the root of the chain
directory_entry.add_file(resource_entry.clone());
} else {
let index = directory_entry | random_line_split | ||
collision.go | Collisions(cg *quad.CollisionGroup, now stime.Time) ([]entity.Entity, []entity.Entity) {
// Reset the resolved slice
phase.solved = phase.solved[:0]
// Generate a collision index for the collision group
phase.collisionIndex = cg.CollisionIndex()
// A map to store entities that still remain in the world
remaining := make(map[entity.Id]entity.Entity, len(cg.Entities))
remainingSlice := func() []entity.Entity {
// Build a slice from the `remaining` map
s := make([]entity.Entity, 0, len(remaining))
for _, e := range remaining {
s = append(s, e)
}
return s
}
for _, c := range cg.Collisions {
if phase.hasSolved(c) {
continue
}
var entities []entity.Entity
// Resolve type of entity in collision.A
switch e := c.A.(type) {
case actorEntity:
// Resolve the type of entity in collision.B
entities = phase.resolveActorEntity(phase.actorIndex[e.ActorId()], c.B, c, now)
default:
switch e := c.B.(type) {
case actorEntity:
// Resolve the type of entity in collision.B
entities = phase.resolveActorEntity(phase.actorIndex[e.ActorId()], c.A, c, now)
}
}
// As collisions are solved they return entities
// that have been created or modified and we store
// them in a map by their Id. Multiple collisions
// may modify and entity, therefor we only will
// one version of the entity back to engine when
// we return.
for _, e := range entities {
remaining[e.Id()] = e
}
}
return remainingSlice(), nil
}
func (phase *narrowPhase) resolveActorEntity(a *actor, with entity.Entity, collision quad.Collision, now stime.Time) []entity.Entity {
switch e := with.(type) {
case actorEntity:
b := phase.actorIndex[e.ActorId()]
return phase.solveActorActor(&solverActorActor{}, a, b, collision)
case assailEntity:
return phase.solveActorAssail(a, e, collision, now)
case wallEntity:
a.revertMoveAction()
return []entity.Entity{a.Entity(), e}
}
return nil
} | }
var percentDamage float64
switch a.pathAction {
case nil:
if a.Cell() == assail.Cell() {
percentDamage = 1.0
}
default:
coordCollision := coord.NewCellCollision(*a.pathAction, assail.Cell())
percentDamage = coordCollision.OverlapAt(now)
}
damage := int(math.Floor(float64(assail.damage) * percentDamage))
a.hp -= damage
if a.hp <= 0 {
a.hp = 100
a.actorEntity.cell = origin
a.actorEntity.facing = coord.South
a.actorEntity.pathAction = nil
}
return []entity.Entity{a.Entity()}
}
func newActorActorCollision(a, b *actor) (*actor, *actor, coord.Collision) {
var collision coord.Collision
switch {
case a.pathAction == nil && b.pathAction != nil:
a, b = b, a
fallthrough
case a.pathAction != nil && b.pathAction == nil:
collision = coord.NewCellCollision(*a.pathAction, b.Cell())
// A or B may have had a previous collision resolved that
// caused this collision to not be possible anymore.
// It is more relevant to return nil here then a
// coord.Collision with type CT_NONE
if collision.Type() == coord.CT_NONE {
return a, b, nil
}
case a.pathAction != nil && b.pathAction != nil:
pathCollision := coord.NewPathCollision(*a.pathAction, *b.pathAction)
// coord.NewPathCollision can flip the,
// A and B paths to simplify the number
// of collision types. This normalizes
// actor A with pathCollision.A
if *a.pathAction != pathCollision.A {
a, b = b, a
}
collision = pathCollision
case a.pathAction == nil && b.pathAction == nil:
// This case handles actors being on the same square,
// but not moving at all.
// There isn't a coord.CollisionType for this case.
// Maybe there should be?
return a, b, nil
default:
panic(fmt.Sprintf("impossible collision between {%v} {%v}", a, b))
}
return a, b, collision
}
type node struct {
actor *actor
entity entity.Entity
}
// Move forward in the directed graph. This movement is based on
// which entity is occupying the destination of the other's path action.
func followGraph(a, b *actor, collision quad.Collision) node {
// normalize a, b to collision.[A, B]
if a.actorEntity.Id() != collision.A.Id() {
a, b = b, a
}
var actor *actor
var entity entity.Entity
switch {
case a.pathAction.Orig == b.pathAction.Dest:
entity = collision.A
actor = a
case b.pathAction.Orig == a.pathAction.Dest:
entity = collision.B
actor = b
default:
panic(fmt.Sprintf("unexpected graph state %v between %v & %v", collision, a, b))
}
return node{actor, entity}
}
// Used to figure out which actor is "A" if
// the collision was CT_A_INTO_B instead of CT_NONE
func currentNode(a, b *actor, collision quad.Collision) *actor {
switch {
case a.pathAction.Orig == b.pathAction.Dest:
return b
case b.pathAction.Orig == a.pathAction.Dest:
return a
default:
panic(fmt.Sprintf("unexpected graph state %v between %v & %v", collision, a, b))
}
}
// Compare entity Id's with the entities in
// a collision and return the one that isn't
// the actor.
func otherEntityIn(a *actor, collision quad.Collision) entity.Entity {
var e entity.Entity
// figure out is prioritized actor is A or B in the collision
switch {
case a.actorEntity.Id() != collision.A.Id():
e = collision.A
case a.actorEntity.Id() != collision.B.Id():
e = collision.B
default:
panic(fmt.Sprintf("unexpected graph state %v actor %v", collision, a))
}
return e
}
// Store what actor's have been visited during
// a recursive solve. Used to avoid infinite
// recursion through a cycle in the graph.
type solverActorActor struct {
visited []*actor
}
func (s solverActorActor) hasVisited(actor *actor) bool {
for _, a := range s.visited {
if actor == a {
return true
}
}
return false
}
func (phase *narrowPhase) solveActorActor(solver *solverActorActor, a, b *actor, collision quad.Collision) []entity.Entity {
// When this functions returns the
// collision will have been solved
defer func() {
phase.solved = append(phase.solved, collision)
}()
var entities []entity.Entity
attemptSolve:
a, b, coordCollision := newActorActorCollision(a, b)
if coordCollision == nil {
goto resolved
}
switch coordCollision.Type() {
case coord.CT_NONE:
// This may not be entirely accurate.
// We should walk through the collision index
// of our partner too see if they should resolve
// some of there collisions first. They may
// appear to be moving to us right now, but
// have a collision that when solved will
// render them motionless, thus we would become
// motionless as well.
e, err := phase.solveDependencies(solver, a, b, collision)
switch err {
case nil:
if len(e) > 0 {
entities = append(entities, e...)
}
// Try solving again
goto attemptSolve
case errCycleDetected:
// Detected a cycle, we can't move
currentNode(a, b, collision).revertMoveAction()
goto resolved
case errNoDependencies:
// All dependencies have been solved
// We can move
goto resolved
}
case coord.CT_CELL_DEST:
a.revertMoveAction()
goto resolved
case coord.CT_SWAP:
a.revertMoveAction()
b.revertMoveAction()
goto resolved
case coord.CT_A_INTO_B_FROM_SIDE:
// This may not be entirely accurate.
// We should walk through the collision index
// of our partner too see if they should resolve
// some of there collisions first. They may
// appear to be moving to us right |
func (phase *narrowPhase) solveActorAssail(a *actor, assail assailEntity, collision quad.Collision, now stime.Time) []entity.Entity {
// Don't damage yourself
if assail.spawnedBy == a.actorEntity.Id() {
return []entity.Entity{a.Entity()} | random_line_split |
collision.go |
return false
}
func (phase narrowPhaseLocker) ResolveCollisions(cg *quad.CollisionGroup, now stime.Time) ([]entity.Entity, []entity.Entity) {
defer phase.ActorIndexLocker.RUnlock()
return newNarrowPhase(phase.ActorIndexLocker.RLock()).ResolveCollisions(cg, now)
}
// Implementation of the quad.NarrowPhaseHandler interface.
func (phase narrowPhase) ResolveCollisions(cg *quad.CollisionGroup, now stime.Time) ([]entity.Entity, []entity.Entity) {
// Reset the resolved slice
phase.solved = phase.solved[:0]
// Generate a collision index for the collision group
phase.collisionIndex = cg.CollisionIndex()
// A map to store entities that still remain in the world
remaining := make(map[entity.Id]entity.Entity, len(cg.Entities))
remainingSlice := func() []entity.Entity {
// Build a slice from the `remaining` map
s := make([]entity.Entity, 0, len(remaining))
for _, e := range remaining {
s = append(s, e)
}
return s
}
for _, c := range cg.Collisions {
if phase.hasSolved(c) {
continue
}
var entities []entity.Entity
// Resolve type of entity in collision.A
switch e := c.A.(type) {
case actorEntity:
// Resolve the type of entity in collision.B
entities = phase.resolveActorEntity(phase.actorIndex[e.ActorId()], c.B, c, now)
default:
switch e := c.B.(type) {
case actorEntity:
// Resolve the type of entity in collision.B
entities = phase.resolveActorEntity(phase.actorIndex[e.ActorId()], c.A, c, now)
}
}
// As collisions are solved they return entities
// that have been created or modified and we store
// them in a map by their Id. Multiple collisions
// may modify and entity, therefor we only will
// one version of the entity back to engine when
// we return.
for _, e := range entities {
remaining[e.Id()] = e
}
}
return remainingSlice(), nil
}
func (phase *narrowPhase) resolveActorEntity(a *actor, with entity.Entity, collision quad.Collision, now stime.Time) []entity.Entity {
switch e := with.(type) {
case actorEntity:
b := phase.actorIndex[e.ActorId()]
return phase.solveActorActor(&solverActorActor{}, a, b, collision)
case assailEntity:
return phase.solveActorAssail(a, e, collision, now)
case wallEntity:
a.revertMoveAction()
return []entity.Entity{a.Entity(), e}
}
return nil
}
func (phase *narrowPhase) solveActorAssail(a *actor, assail assailEntity, collision quad.Collision, now stime.Time) []entity.Entity {
// Don't damage yourself
if assail.spawnedBy == a.actorEntity.Id() {
return []entity.Entity{a.Entity()}
}
var percentDamage float64
switch a.pathAction {
case nil:
if a.Cell() == assail.Cell() {
percentDamage = 1.0
}
default:
coordCollision := coord.NewCellCollision(*a.pathAction, assail.Cell())
percentDamage = coordCollision.OverlapAt(now)
}
damage := int(math.Floor(float64(assail.damage) * percentDamage))
a.hp -= damage
if a.hp <= 0 {
a.hp = 100
a.actorEntity.cell = origin
a.actorEntity.facing = coord.South
a.actorEntity.pathAction = nil
}
return []entity.Entity{a.Entity()}
}
func newActorActorCollision(a, b *actor) (*actor, *actor, coord.Collision) {
var collision coord.Collision
switch {
case a.pathAction == nil && b.pathAction != nil:
a, b = b, a
fallthrough
case a.pathAction != nil && b.pathAction == nil:
collision = coord.NewCellCollision(*a.pathAction, b.Cell())
// A or B may have had a previous collision resolved that
// caused this collision to not be possible anymore.
// It is more relevant to return nil here then a
// coord.Collision with type CT_NONE
if collision.Type() == coord.CT_NONE {
return a, b, nil
}
case a.pathAction != nil && b.pathAction != nil:
pathCollision := coord.NewPathCollision(*a.pathAction, *b.pathAction)
// coord.NewPathCollision can flip the,
// A and B paths to simplify the number
// of collision types. This normalizes
// actor A with pathCollision.A
if *a.pathAction != pathCollision.A {
a, b = b, a
}
collision = pathCollision
case a.pathAction == nil && b.pathAction == nil:
// This case handles actors being on the same square,
// but not moving at all.
// There isn't a coord.CollisionType for this case.
// Maybe there should be?
return a, b, nil
default:
panic(fmt.Sprintf("impossible collision between {%v} {%v}", a, b))
}
return a, b, collision
}
type node struct {
actor *actor
entity entity.Entity
}
// Move forward in the directed graph. This movement is based on
// which entity is occupying the destination of the other's path action.
func followGraph(a, b *actor, collision quad.Collision) node {
// normalize a, b to collision.[A, B]
if a.actorEntity.Id() != collision.A.Id() {
a, b = b, a
}
var actor *actor
var entity entity.Entity
switch {
case a.pathAction.Orig == b.pathAction.Dest:
entity = collision.A
actor = a
case b.pathAction.Orig == a.pathAction.Dest:
entity = collision.B
actor = b
default:
panic(fmt.Sprintf("unexpected graph state %v between %v & %v", collision, a, b))
}
return node{actor, entity}
}
// Used to figure out which actor is "A" if
// the collision was CT_A_INTO_B instead of CT_NONE
func currentNode(a, b *actor, collision quad.Collision) *actor {
switch {
case a.pathAction.Orig == b.pathAction.Dest:
return b
case b.pathAction.Orig == a.pathAction.Dest:
return a
default:
panic(fmt.Sprintf("unexpected graph state %v between %v & %v", collision, a, b))
}
}
// Compare entity Id's with the entities in
// a collision and return the one that isn't
// the actor.
func otherEntityIn(a *actor, collision quad.Collision) entity.Entity {
var e entity.Entity
// figure out is prioritized actor is A or B in the collision
switch {
case a.actorEntity.Id() != collision.A.Id():
e = collision.A
case a.actorEntity.Id() != collision.B.Id():
e = collision.B
default:
panic(fmt.Sprintf("unexpected graph state %v actor %v", collision, a))
}
return e
}
// Store what actor's have been visited during
// a recursive solve. Used to avoid infinite
// recursion through a cycle in the graph.
type solverActorActor struct {
visited []*actor
}
func (s solverActorActor) hasVisited(actor *actor) bool {
for _, a := range s.visited {
if actor == a {
return true
}
}
return false
}
func (phase *narrowPhase) solveActorActor(solver *solverActorActor, a, b *actor, collision quad.Collision) []entity.Entity {
// When this functions returns the
// collision will have been solved
defer func() {
phase.solved = append(phase.solved, collision)
}()
var entities []entity.Entity
attemptSolve:
a, b, coordCollision := newActorActorCollision(a, b)
if coordCollision == nil {
goto resolved
}
switch coordCollision.Type() {
case coord.CT_NONE:
// This may not be entirely accurate.
// We should walk through the collision index
// of our partner too see if they should resolve
// some of there collisions first. They may
// appear to be moving to us right now, but
// have a collision that when solved will
// render them motionless, thus we would become
// motionless as well.
e, err := phase.solveDependencies(solver, a, b, collision)
switch err {
case nil:
if len(e) > 0 {
entities = append(entities, e...)
}
// Try solving again
goto attemptSolve
case errCycleDetected:
// Detected a cycle, we can't move
currentNode(a, b, collision).revertMoveAction()
goto resolved
case errNoDependencies:
// All dependencies have been solved
// We can move
goto resolved
}
case coord.CT_CELL_DEST | {
if c.IsSameAs(solved) {
return true
}
} | conditional_block | |
collision.go | isions(cg *quad.CollisionGroup, now stime.Time) ([]entity.Entity, []entity.Entity) {
// Reset the resolved slice
phase.solved = phase.solved[:0]
// Generate a collision index for the collision group
phase.collisionIndex = cg.CollisionIndex()
// A map to store entities that still remain in the world
remaining := make(map[entity.Id]entity.Entity, len(cg.Entities))
remainingSlice := func() []entity.Entity {
// Build a slice from the `remaining` map
s := make([]entity.Entity, 0, len(remaining))
for _, e := range remaining {
s = append(s, e)
}
return s
}
for _, c := range cg.Collisions {
if phase.hasSolved(c) {
continue
}
var entities []entity.Entity
// Resolve type of entity in collision.A
switch e := c.A.(type) {
case actorEntity:
// Resolve the type of entity in collision.B
entities = phase.resolveActorEntity(phase.actorIndex[e.ActorId()], c.B, c, now)
default:
switch e := c.B.(type) {
case actorEntity:
// Resolve the type of entity in collision.B
entities = phase.resolveActorEntity(phase.actorIndex[e.ActorId()], c.A, c, now)
}
}
// As collisions are solved they return entities
// that have been created or modified and we store
// them in a map by their Id. Multiple collisions
// may modify and entity, therefor we only will
// one version of the entity back to engine when
// we return.
for _, e := range entities {
remaining[e.Id()] = e
}
}
return remainingSlice(), nil
}
func (phase *narrowPhase) resolveActorEntity(a *actor, with entity.Entity, collision quad.Collision, now stime.Time) []entity.Entity {
switch e := with.(type) {
case actorEntity:
b := phase.actorIndex[e.ActorId()]
return phase.solveActorActor(&solverActorActor{}, a, b, collision)
case assailEntity:
return phase.solveActorAssail(a, e, collision, now)
case wallEntity:
a.revertMoveAction()
return []entity.Entity{a.Entity(), e}
}
return nil
}
func (phase *narrowPhase) solveActorAssail(a *actor, assail assailEntity, collision quad.Collision, now stime.Time) []entity.Entity {
// Don't damage yourself
if assail.spawnedBy == a.actorEntity.Id() {
return []entity.Entity{a.Entity()}
}
var percentDamage float64
switch a.pathAction {
case nil:
if a.Cell() == assail.Cell() {
percentDamage = 1.0
}
default:
coordCollision := coord.NewCellCollision(*a.pathAction, assail.Cell())
percentDamage = coordCollision.OverlapAt(now)
}
damage := int(math.Floor(float64(assail.damage) * percentDamage))
a.hp -= damage
if a.hp <= 0 {
a.hp = 100
a.actorEntity.cell = origin
a.actorEntity.facing = coord.South
a.actorEntity.pathAction = nil
}
return []entity.Entity{a.Entity()}
}
func newActorActorCollision(a, b *actor) (*actor, *actor, coord.Collision) {
var collision coord.Collision
switch {
case a.pathAction == nil && b.pathAction != nil:
a, b = b, a
fallthrough
case a.pathAction != nil && b.pathAction == nil:
collision = coord.NewCellCollision(*a.pathAction, b.Cell())
// A or B may have had a previous collision resolved that
// caused this collision to not be possible anymore.
// It is more relevant to return nil here then a
// coord.Collision with type CT_NONE
if collision.Type() == coord.CT_NONE {
return a, b, nil
}
case a.pathAction != nil && b.pathAction != nil:
pathCollision := coord.NewPathCollision(*a.pathAction, *b.pathAction)
// coord.NewPathCollision can flip the,
// A and B paths to simplify the number
// of collision types. This normalizes
// actor A with pathCollision.A
if *a.pathAction != pathCollision.A {
a, b = b, a
}
collision = pathCollision
case a.pathAction == nil && b.pathAction == nil:
// This case handles actors being on the same square,
// but not moving at all.
// There isn't a coord.CollisionType for this case.
// Maybe there should be?
return a, b, nil
default:
panic(fmt.Sprintf("impossible collision between {%v} {%v}", a, b))
}
return a, b, collision
}
type node struct {
actor *actor
entity entity.Entity
}
// Move forward in the directed graph. This movement is based on
// which entity is occupying the destination of the other's path action.
func followGraph(a, b *actor, collision quad.Collision) node {
// normalize a, b to collision.[A, B]
if a.actorEntity.Id() != collision.A.Id() {
a, b = b, a
}
var actor *actor
var entity entity.Entity
switch {
case a.pathAction.Orig == b.pathAction.Dest:
entity = collision.A
actor = a
case b.pathAction.Orig == a.pathAction.Dest:
entity = collision.B
actor = b
default:
panic(fmt.Sprintf("unexpected graph state %v between %v & %v", collision, a, b))
}
return node{actor, entity}
}
// Used to figure out which actor is "A" if
// the collision was CT_A_INTO_B instead of CT_NONE
func currentNode(a, b *actor, collision quad.Collision) *actor |
// Compare entity Id's with the entities in
// a collision and return the one that isn't
// the actor.
func otherEntityIn(a *actor, collision quad.Collision) entity.Entity {
var e entity.Entity
// figure out is prioritized actor is A or B in the collision
switch {
case a.actorEntity.Id() != collision.A.Id():
e = collision.A
case a.actorEntity.Id() != collision.B.Id():
e = collision.B
default:
panic(fmt.Sprintf("unexpected graph state %v actor %v", collision, a))
}
return e
}
// Store what actor's have been visited during
// a recursive solve. Used to avoid infinite
// recursion through a cycle in the graph.
type solverActorActor struct {
visited []*actor
}
func (s solverActorActor) hasVisited(actor *actor) bool {
for _, a := range s.visited {
if actor == a {
return true
}
}
return false
}
func (phase *narrowPhase) solveActorActor(solver *solverActorActor, a, b *actor, collision quad.Collision) []entity.Entity {
// When this functions returns the
// collision will have been solved
defer func() {
phase.solved = append(phase.solved, collision)
}()
var entities []entity.Entity
attemptSolve:
a, b, coordCollision := newActorActorCollision(a, b)
if coordCollision == nil {
goto resolved
}
switch coordCollision.Type() {
case coord.CT_NONE:
// This may not be entirely accurate.
// We should walk through the collision index
// of our partner too see if they should resolve
// some of there collisions first. They may
// appear to be moving to us right now, but
// have a collision that when solved will
// render them motionless, thus we would become
// motionless as well.
e, err := phase.solveDependencies(solver, a, b, collision)
switch err {
case nil:
if len(e) > 0 {
entities = append(entities, e...)
}
// Try solving again
goto attemptSolve
case errCycleDetected:
// Detected a cycle, we can't move
currentNode(a, b, collision).revertMoveAction()
goto resolved
case errNoDependencies:
// All dependencies have been solved
// We can move
goto resolved
}
case coord.CT_CELL_DEST:
a.revertMoveAction()
goto resolved
case coord.CT_SWAP:
a.revertMoveAction()
b.revertMoveAction()
goto resolved
case coord.CT_A_INTO_B_FROM_SIDE:
// This may not be entirely accurate.
// We should walk through the collision index
// of our partner too see if they should resolve
// some of there collisions first. They may
// appear to be moving to us right | {
switch {
case a.pathAction.Orig == b.pathAction.Dest:
return b
case b.pathAction.Orig == a.pathAction.Dest:
return a
default:
panic(fmt.Sprintf("unexpected graph state %v between %v & %v", collision, a, b))
}
} | identifier_body |
collision.go | Collisions(cg *quad.CollisionGroup, now stime.Time) ([]entity.Entity, []entity.Entity) {
// Reset the resolved slice
phase.solved = phase.solved[:0]
// Generate a collision index for the collision group
phase.collisionIndex = cg.CollisionIndex()
// A map to store entities that still remain in the world
remaining := make(map[entity.Id]entity.Entity, len(cg.Entities))
remainingSlice := func() []entity.Entity {
// Build a slice from the `remaining` map
s := make([]entity.Entity, 0, len(remaining))
for _, e := range remaining {
s = append(s, e)
}
return s
}
for _, c := range cg.Collisions {
if phase.hasSolved(c) {
continue
}
var entities []entity.Entity
// Resolve type of entity in collision.A
switch e := c.A.(type) {
case actorEntity:
// Resolve the type of entity in collision.B
entities = phase.resolveActorEntity(phase.actorIndex[e.ActorId()], c.B, c, now)
default:
switch e := c.B.(type) {
case actorEntity:
// Resolve the type of entity in collision.B
entities = phase.resolveActorEntity(phase.actorIndex[e.ActorId()], c.A, c, now)
}
}
// As collisions are solved they return entities
// that have been created or modified and we store
// them in a map by their Id. Multiple collisions
// may modify and entity, therefor we only will
// one version of the entity back to engine when
// we return.
for _, e := range entities {
remaining[e.Id()] = e
}
}
return remainingSlice(), nil
}
func (phase *narrowPhase) resolveActorEntity(a *actor, with entity.Entity, collision quad.Collision, now stime.Time) []entity.Entity {
switch e := with.(type) {
case actorEntity:
b := phase.actorIndex[e.ActorId()]
return phase.solveActorActor(&solverActorActor{}, a, b, collision)
case assailEntity:
return phase.solveActorAssail(a, e, collision, now)
case wallEntity:
a.revertMoveAction()
return []entity.Entity{a.Entity(), e}
}
return nil
}
func (phase *narrowPhase) solveActorAssail(a *actor, assail assailEntity, collision quad.Collision, now stime.Time) []entity.Entity {
// Don't damage yourself
if assail.spawnedBy == a.actorEntity.Id() {
return []entity.Entity{a.Entity()}
}
var percentDamage float64
switch a.pathAction {
case nil:
if a.Cell() == assail.Cell() {
percentDamage = 1.0
}
default:
coordCollision := coord.NewCellCollision(*a.pathAction, assail.Cell())
percentDamage = coordCollision.OverlapAt(now)
}
damage := int(math.Floor(float64(assail.damage) * percentDamage))
a.hp -= damage
if a.hp <= 0 {
a.hp = 100
a.actorEntity.cell = origin
a.actorEntity.facing = coord.South
a.actorEntity.pathAction = nil
}
return []entity.Entity{a.Entity()}
}
func | (a, b *actor) (*actor, *actor, coord.Collision) {
var collision coord.Collision
switch {
case a.pathAction == nil && b.pathAction != nil:
a, b = b, a
fallthrough
case a.pathAction != nil && b.pathAction == nil:
collision = coord.NewCellCollision(*a.pathAction, b.Cell())
// A or B may have had a previous collision resolved that
// caused this collision to not be possible anymore.
// It is more relevant to return nil here then a
// coord.Collision with type CT_NONE
if collision.Type() == coord.CT_NONE {
return a, b, nil
}
case a.pathAction != nil && b.pathAction != nil:
pathCollision := coord.NewPathCollision(*a.pathAction, *b.pathAction)
// coord.NewPathCollision can flip the,
// A and B paths to simplify the number
// of collision types. This normalizes
// actor A with pathCollision.A
if *a.pathAction != pathCollision.A {
a, b = b, a
}
collision = pathCollision
case a.pathAction == nil && b.pathAction == nil:
// This case handles actors being on the same square,
// but not moving at all.
// There isn't a coord.CollisionType for this case.
// Maybe there should be?
return a, b, nil
default:
panic(fmt.Sprintf("impossible collision between {%v} {%v}", a, b))
}
return a, b, collision
}
type node struct {
actor *actor
entity entity.Entity
}
// Move forward in the directed graph. This movement is based on
// which entity is occupying the destination of the other's path action.
func followGraph(a, b *actor, collision quad.Collision) node {
// normalize a, b to collision.[A, B]
if a.actorEntity.Id() != collision.A.Id() {
a, b = b, a
}
var actor *actor
var entity entity.Entity
switch {
case a.pathAction.Orig == b.pathAction.Dest:
entity = collision.A
actor = a
case b.pathAction.Orig == a.pathAction.Dest:
entity = collision.B
actor = b
default:
panic(fmt.Sprintf("unexpected graph state %v between %v & %v", collision, a, b))
}
return node{actor, entity}
}
// Used to figure out which actor is "A" if
// the collision was CT_A_INTO_B instead of CT_NONE
func currentNode(a, b *actor, collision quad.Collision) *actor {
switch {
case a.pathAction.Orig == b.pathAction.Dest:
return b
case b.pathAction.Orig == a.pathAction.Dest:
return a
default:
panic(fmt.Sprintf("unexpected graph state %v between %v & %v", collision, a, b))
}
}
// Compare entity Id's with the entities in
// a collision and return the one that isn't
// the actor.
func otherEntityIn(a *actor, collision quad.Collision) entity.Entity {
var e entity.Entity
// figure out is prioritized actor is A or B in the collision
switch {
case a.actorEntity.Id() != collision.A.Id():
e = collision.A
case a.actorEntity.Id() != collision.B.Id():
e = collision.B
default:
panic(fmt.Sprintf("unexpected graph state %v actor %v", collision, a))
}
return e
}
// Store what actor's have been visited during
// a recursive solve. Used to avoid infinite
// recursion through a cycle in the graph.
type solverActorActor struct {
visited []*actor
}
func (s solverActorActor) hasVisited(actor *actor) bool {
for _, a := range s.visited {
if actor == a {
return true
}
}
return false
}
func (phase *narrowPhase) solveActorActor(solver *solverActorActor, a, b *actor, collision quad.Collision) []entity.Entity {
// When this functions returns the
// collision will have been solved
defer func() {
phase.solved = append(phase.solved, collision)
}()
var entities []entity.Entity
attemptSolve:
a, b, coordCollision := newActorActorCollision(a, b)
if coordCollision == nil {
goto resolved
}
switch coordCollision.Type() {
case coord.CT_NONE:
// This may not be entirely accurate.
// We should walk through the collision index
// of our partner too see if they should resolve
// some of there collisions first. They may
// appear to be moving to us right now, but
// have a collision that when solved will
// render them motionless, thus we would become
// motionless as well.
e, err := phase.solveDependencies(solver, a, b, collision)
switch err {
case nil:
if len(e) > 0 {
entities = append(entities, e...)
}
// Try solving again
goto attemptSolve
case errCycleDetected:
// Detected a cycle, we can't move
currentNode(a, b, collision).revertMoveAction()
goto resolved
case errNoDependencies:
// All dependencies have been solved
// We can move
goto resolved
}
case coord.CT_CELL_DEST:
a.revertMoveAction()
goto resolved
case coord.CT_SWAP:
a.revertMoveAction()
b.revertMoveAction()
goto resolved
case coord.CT_A_INTO_B_FROM_SIDE:
// This may not be entirely accurate.
// We should walk through the collision index
// of our partner too see if they should resolve
// some of there collisions first. They may
// appear to be moving to us right | newActorActorCollision | identifier_name |
main.go | var trowner, trname string
var hbrev, brbd uint
var osvs []string
var logger = log.New(os.Stderr, "", log.LstdFlags)
func ferr(msg string, args ...interface{}) {
fmt.Printf(msg+"\n", args...)
os.Exit(1)
}
var ghc *github.Client
func init() {
pflag.StringVar(&rname, "release", "", "release name (ex: v1.0.0)")
pflag.StringVar(&npath, "notes-path", "relnotes.md", "path to release notes")
pflag.StringVar(&commitsha, "commit", "", "commit SHA to release")
pflag.StringVar(&taprepo, "tap-repo", "dollarshaveclub/homebrew-public", "name of tap GitHub repository ([owner]/[repo])")
pflag.StringVar(&tapref, "tap-repo-ref", "master", "tap repository ref (branch/tag/SHA)")
pflag.StringVar(&fpath, "formula", "Formula/psst.rb", "path to formula within tap repo")
pflag.StringVar(&ftpath, "formula-template", "Formula/psst.rb.tmpl", "path to formula template within tap repo")
pflag.StringVar(&targetoslist, "macos-versions", "el_capitan,high_sierra,sierra", "Supported MacOS versions (comma-delimited)")
pflag.UintVar(&hbrev, "homebrew-rev", 0, "Homebrew revision (bump to force reinstall/rebuild)")
pflag.UintVar(&brbd, "bottle-rebuild", 1, "Bottle rebuild (bump to force bottle reinstall)")
pflag.BoolVar(&draft, "draft", false, "Draft release (unpublished)")
pflag.BoolVar(&prerelease, "prerelease", false, "Prerelease")
pflag.BoolVar(&dobuild, "build", true, "Build binaries first")
pflag.Parse()
trs := strings.Split(taprepo, "/")
if len(trs) != 2 {
ferr("malformed tap repo (expected [owner]/[repo]): %v", taprepo)
}
if rname == "" {
ferr("release name is required")
}
trowner = trs[0]
trname = trs[1]
osvs = strings.Split(targetoslist, ",")
if len(osvs) == 0 {
ferr("At least one MacOS version is required")
}
ghtoken = os.Getenv("GITHUB_TOKEN")
if ghtoken == "" {
ferr("GITHUB_TOKEN missing from environment")
}
if err := checkFiles(npath); err != nil {
ferr("file path error: %v", err)
}
checkLocalRepoVersion()
ghc = newGHClient()
}
func newGHClient() *github.Client {
tc := oauth2.NewClient(context.Background(), oauth2.StaticTokenSource(
&oauth2.Token{AccessToken: ghtoken},
))
return github.NewClient(tc)
}
func checkLocalRepoVersion() {
cmd := exec.Command("git", "rev-parse", "HEAD")
out, err := cmd.Output()
if err != nil {
ferr("error getting git command output: %v", err)
}
if strings.TrimRight(string(out), "\n") != commitsha {
ferr("current git revision does not match requested release version: %v (expected %v)", string(out), commitsha)
}
}
func checkFiles(paths ...string) error {
for _, p := range paths {
if _, err := os.Stat(p); err != nil {
return errors.Wrap(err, "file error")
}
}
return nil
}
func createGitTag() error {
msg := fmt.Sprintf("release %v", rname)
ot := "commit"
tag := github.Tag{
Tag: &rname,
Message: &msg,
Object: &github.GitObject{
Type: &ot,
SHA: &commitsha,
},
}
log.Printf("creating tag...\n")
_, _, err := ghc.Git.CreateTag(context.Background(), repoOwner, repoName, &tag)
if err != nil {
return errors.Wrap(err, "error creating tag")
}
refstr := fmt.Sprintf("refs/tags/%v", rname)
objt := "commit"
ref := github.Reference{
Ref: &refstr,
Object: &github.GitObject{
Type: &objt,
SHA: &commitsha,
},
}
log.Printf("creating tag ref...\n")
_, _, err = ghc.Git.CreateRef(context.Background(), repoOwner, repoName, &ref)
if err != nil {
return errors.Wrap(err, "error creating tag ref")
}
return nil
}
type bottleDefinition struct {
Hash string
TargetOS string
}
type formulaTemplateData struct {
Tag string
CommitSHA string
HomebrewRevision uint
BaseDownloadURL string
Bottled bool
BottleRebuild uint
BottleDefs []bottleDefinition
}
func (ftd *formulaTemplateData) populate(bdefs []bottleDefinition) {
ftd.Tag = rname
ftd.CommitSHA = commitsha
if hbrev > 0 {
ftd.HomebrewRevision = hbrev
}
ftd.BaseDownloadURL = fmt.Sprintf("https://github.com/%v/%v/releases/download/%v", repoOwner, repoName, rname)
ftd.BottleRebuild = brbd
ftd.Bottled = true
ftd.BottleDefs = bdefs
}
const header = "# GENERATED FROM TEMPLATE. DO NOT EDIT!\n"
// generateFormula fetches the template from github, executes the template with ftd and returns the raw data or error, if any
func generateFormula(ftd formulaTemplateData) ([]byte, error) {
logger.Printf("Generating Homebrew formula")
// get template
fc, _, _, err := ghc.Repositories.GetContents(context.Background(), trowner, trname, ftpath, &github.RepositoryContentGetOptions{Ref: tapref})
if err != nil {
return nil, errors.Wrap(err, "error getting formula template")
}
rt, err := fc.GetContent()
if err != nil {
return nil, errors.Wrap(err, "error getting formula template content")
}
// generate new formula
tmpl, err := template.New("formula").Parse(rt)
if err != nil {
return nil, errors.Wrap(err, "error parsing formula template")
}
buf := bytes.NewBuffer([]byte{})
if err = tmpl.Execute(buf, &ftd); err != nil {
return nil, errors.Wrap(err, "error executing template")
}
return append([]byte(header), buf.Bytes()...), nil
}
func pushFormula(fd []byte) error {
logger.Printf("Pushing Homebrew formula")
// Get the current file for the SHA
fc, _, _, err := ghc.Repositories.GetContents(context.Background(), trowner, trname, fpath, &github.RepositoryContentGetOptions{Ref: tapref})
if err != nil {
return errors.Wrap(err, "error getting formula contents")
}
sp := func(s string) *string {
return &s
}
_, _, err = ghc.Repositories.UpdateFile(context.Background(), trowner, trname, fpath, &github.RepositoryContentFileOptions{
Message: sp(fmt.Sprintf("updated for release %v", rname)),
Content: fd,
SHA: fc.SHA,
Branch: &tapref,
})
if err != nil {
return errors.Wrap(err, "error updating formula")
}
return nil
}
const (
linuxBinName = "psst-linux-amd64"
)
var buildopts = []string{"-ldflags", "-X github.com/dollarshaveclub/psst/cmd.CommitSHA=%v -X github.com/dollarshaveclub/psst/cmd.Version=%v -X github.com/dollarshaveclub/psst/cmd.CompiledDirectory=github -X github.com/dollarshaveclub/psst/cmd.CompiledStorage=vault -X github.com/dollarshaveclub/psst/cmd.Org=dollarshaveclub"}
func buildBins() error {
if err := os.MkdirAll("bins", os.ModeDir|0755); err != nil {
return errors.Wrap(err, "error creating bins directory")
}
cwd, err := os.Getwd()
if err != nil {
return errors.Wrap(err, "error getting working directory")
}
wd := filepath.Join(cwd, "..")
buildopts[1] = fmt.Sprintf(buildopts[1], commitsha, rname)
build := func(osn string) ([]byte, error) {
cmd := exec.Command("go", append([]string{"build"}, buildopts...)...)
cmd.Env = append(os.Environ(), []string{fmt.Sprintf("GOOS=%v", osn), "GOARCH=amd64"}...)
cmd.Dir = wd
return cmd.CombinedOutput()
}
logger.Printf("Building binaries...\n")
logger.Printf("...macOS amd64")
if out, err := build("darwin"); err != nil {
return errors.Wrapf(err, "error running build command: %s", out)
}
if err := os.Rename(filepath.Join(wd, "psst"), filepath.Join(cwd | var rname, npath, commitsha, ghtoken, taprepo, tapref, fpath, ftpath, targetoslist string
var draft, prerelease, dobuild bool | random_line_split | |
main.go | oauth2.StaticTokenSource(
&oauth2.Token{AccessToken: ghtoken},
))
return github.NewClient(tc)
}
func checkLocalRepoVersion() {
cmd := exec.Command("git", "rev-parse", "HEAD")
out, err := cmd.Output()
if err != nil {
ferr("error getting git command output: %v", err)
}
if strings.TrimRight(string(out), "\n") != commitsha {
ferr("current git revision does not match requested release version: %v (expected %v)", string(out), commitsha)
}
}
func checkFiles(paths ...string) error {
for _, p := range paths {
if _, err := os.Stat(p); err != nil {
return errors.Wrap(err, "file error")
}
}
return nil
}
func createGitTag() error {
msg := fmt.Sprintf("release %v", rname)
ot := "commit"
tag := github.Tag{
Tag: &rname,
Message: &msg,
Object: &github.GitObject{
Type: &ot,
SHA: &commitsha,
},
}
log.Printf("creating tag...\n")
_, _, err := ghc.Git.CreateTag(context.Background(), repoOwner, repoName, &tag)
if err != nil {
return errors.Wrap(err, "error creating tag")
}
refstr := fmt.Sprintf("refs/tags/%v", rname)
objt := "commit"
ref := github.Reference{
Ref: &refstr,
Object: &github.GitObject{
Type: &objt,
SHA: &commitsha,
},
}
log.Printf("creating tag ref...\n")
_, _, err = ghc.Git.CreateRef(context.Background(), repoOwner, repoName, &ref)
if err != nil {
return errors.Wrap(err, "error creating tag ref")
}
return nil
}
type bottleDefinition struct {
Hash string
TargetOS string
}
type formulaTemplateData struct {
Tag string
CommitSHA string
HomebrewRevision uint
BaseDownloadURL string
Bottled bool
BottleRebuild uint
BottleDefs []bottleDefinition
}
func (ftd *formulaTemplateData) populate(bdefs []bottleDefinition) {
ftd.Tag = rname
ftd.CommitSHA = commitsha
if hbrev > 0 {
ftd.HomebrewRevision = hbrev
}
ftd.BaseDownloadURL = fmt.Sprintf("https://github.com/%v/%v/releases/download/%v", repoOwner, repoName, rname)
ftd.BottleRebuild = brbd
ftd.Bottled = true
ftd.BottleDefs = bdefs
}
const header = "# GENERATED FROM TEMPLATE. DO NOT EDIT!\n"
// generateFormula fetches the template from github, executes the template with ftd and returns the raw data or error, if any
func generateFormula(ftd formulaTemplateData) ([]byte, error) {
logger.Printf("Generating Homebrew formula")
// get template
fc, _, _, err := ghc.Repositories.GetContents(context.Background(), trowner, trname, ftpath, &github.RepositoryContentGetOptions{Ref: tapref})
if err != nil {
return nil, errors.Wrap(err, "error getting formula template")
}
rt, err := fc.GetContent()
if err != nil {
return nil, errors.Wrap(err, "error getting formula template content")
}
// generate new formula
tmpl, err := template.New("formula").Parse(rt)
if err != nil {
return nil, errors.Wrap(err, "error parsing formula template")
}
buf := bytes.NewBuffer([]byte{})
if err = tmpl.Execute(buf, &ftd); err != nil {
return nil, errors.Wrap(err, "error executing template")
}
return append([]byte(header), buf.Bytes()...), nil
}
func pushFormula(fd []byte) error {
logger.Printf("Pushing Homebrew formula")
// Get the current file for the SHA
fc, _, _, err := ghc.Repositories.GetContents(context.Background(), trowner, trname, fpath, &github.RepositoryContentGetOptions{Ref: tapref})
if err != nil {
return errors.Wrap(err, "error getting formula contents")
}
sp := func(s string) *string {
return &s
}
_, _, err = ghc.Repositories.UpdateFile(context.Background(), trowner, trname, fpath, &github.RepositoryContentFileOptions{
Message: sp(fmt.Sprintf("updated for release %v", rname)),
Content: fd,
SHA: fc.SHA,
Branch: &tapref,
})
if err != nil {
return errors.Wrap(err, "error updating formula")
}
return nil
}
const (
linuxBinName = "psst-linux-amd64"
)
var buildopts = []string{"-ldflags", "-X github.com/dollarshaveclub/psst/cmd.CommitSHA=%v -X github.com/dollarshaveclub/psst/cmd.Version=%v -X github.com/dollarshaveclub/psst/cmd.CompiledDirectory=github -X github.com/dollarshaveclub/psst/cmd.CompiledStorage=vault -X github.com/dollarshaveclub/psst/cmd.Org=dollarshaveclub"}
func buildBins() error {
if err := os.MkdirAll("bins", os.ModeDir|0755); err != nil {
return errors.Wrap(err, "error creating bins directory")
}
cwd, err := os.Getwd()
if err != nil {
return errors.Wrap(err, "error getting working directory")
}
wd := filepath.Join(cwd, "..")
buildopts[1] = fmt.Sprintf(buildopts[1], commitsha, rname)
build := func(osn string) ([]byte, error) {
cmd := exec.Command("go", append([]string{"build"}, buildopts...)...)
cmd.Env = append(os.Environ(), []string{fmt.Sprintf("GOOS=%v", osn), "GOARCH=amd64"}...)
cmd.Dir = wd
return cmd.CombinedOutput()
}
logger.Printf("Building binaries...\n")
logger.Printf("...macOS amd64")
if out, err := build("darwin"); err != nil {
return errors.Wrapf(err, "error running build command: %s", out)
}
if err := os.Rename(filepath.Join(wd, "psst"), filepath.Join(cwd, "bins", "psst-darwin")); err != nil {
return errors.Wrap(err, "error renaming binary")
}
logger.Printf("...Linux amd64")
if out, err := build("linux"); err != nil {
return errors.Wrapf(err, "error running build command: %s", out)
}
lfn := filepath.Join(cwd, "bins", linuxBinName)
if err := os.Rename(filepath.Join(wd, "psst"), lfn); err != nil {
return errors.Wrap(err, "error renaming binary")
}
// compress linux binary
logger.Printf("...compressing Linux binary\n")
d, err := ioutil.ReadFile(lfn)
if err != nil {
return errors.Wrap(err, "error reading linux binary")
}
f, err := os.Create(lfn + ".gz")
if err != nil {
return errors.Wrap(err, "error creating compressed linux binary")
}
defer f.Close()
gw := gzip.NewWriter(f)
defer gw.Close()
if _, err := gw.Write(d); err != nil {
return errors.Wrap(err, "error writing compressed linux binary")
}
return nil
}
// "copy" (link) a file if it doesn't exist
func cpifneeded(src, dest string) error {
if _, err := os.Stat(dest); err != nil {
if os.IsNotExist(err) {
return os.Link(src, dest)
}
return errors.Wrap(err, "error getting destination")
}
return nil
}
var bottleNameTmpl = template.Must(template.New("bn").Parse("psst-{{ .Release }}{{ if .HomebrewRevision }}_{{ .HomebrewRevision }}{{ end }}.{{ .OS }}.bottle.{{ .BottleRebuild }}.tar.gz"))
// createBottle synthetically creates a bottle tarball returning the bottle definitions, local bottle filenames and error if any
func createBottle() ([]bottleDefinition, []string, error) | {
logger.Printf("Creating Homebrew bottle...\n")
cwd, err := os.Getwd()
if err != nil {
return nil, nil, errors.Wrap(err, "error getting working directory")
}
rver := regexp.MustCompile("([0-9.]+)").FindString(rname)
basepath := filepath.Join(".", "psst", rver)
binpath := filepath.Join(basepath, "bin")
if err := os.MkdirAll(binpath, os.ModeDir|0755); err != nil {
return nil, nil, errors.Wrap(err, "error creating bottle directory path")
}
// .brew
if err := os.MkdirAll(filepath.Join(basepath, ".brew"), os.ModeDir|0755); err != nil {
return nil, nil, errors.Wrap(err, "error creating .brew directory")
}
// copy README
if err := cpifneeded(filepath.Join(cwd, "..", "README.md"), filepath.Join(basepath, "README.md")); err != nil {
return nil, nil, errors.Wrap(err, "error copying README")
} | identifier_body |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.