def __init__(self): # основной запуск иконки
Taskbar.__init__(self)
icon = win32gui.LoadIcon(0, win32con.IDI_APPLICATION)
self.setIcon(icon)
self.show()
Read.init()
win32gui.PumpMessages()
def upload():
# Panggil UploadForm dari form.py
form = UploadForm()
docList = renderDocList()
global fileList , wordList , mVec
# Jika ada file tersubmit, ambil nama file (secured oleh werkzeug) , cek ekstensinya jika .txt, simpan file ke folder test
if form.validate_on_submit():
for files in form.file.data :
filename = secure_filename(files.filename)
file_ext = os.path.splitext(filename)[1]
if file_ext != '.txt':
flash(f'Format of file(s) uploaded is not allowed (.txt only), file submission canceled!' , 'danger')
return redirect(url_for('upload'))
files.save('../test/' + filename)
flash(f'File(s) added!' , 'success')
# Karena ada input file baru, database kamus di-update
# Menampung semua nama file ke dalam suatu variabel list fileList
fileList = []
for root, dirs, files in os.walk('../test', topdown=False):
for name in files :
dir = os.path.join(root,name).split('\\') # Mengambil hanya nama filenya, tidak bersama direktori yang displit oleh \
fileList.append(dir[1])
contentList = []
for name in fileList :
# Menampung tiap konten dalam tiap file, melakukan cleaning, konversi ke token, menghapus stopword, dan lemmatize
content = Read.readfile('../test/'+name)
content = Read.cleaning(content)
content = Read.token(content)
content = Preprocessing.stopwords(content)
content = Preprocessing.stemming(content)
# Menggabungkan semua konten menjadi satu list
contentList.append(content)
# Membuat variabel penampung kata-kata yang ada di dokumen
wordList = []
for content in contentList :
for word in content :
if word not in wordList :
wordList.append(word)
# Membuat variabel penampung jumlah kemunculan tiap kata pada tiap data
mVec = [[0 for x in range(len(wordList))] for y in range(len(fileList))]
j = 0
for content in contentList :
for word in content :
for i in range(len(wordList)) :
if word == wordList[i] :
mVec[j][i] = mVec[j][i] + 1
j = j + 1
return redirect(url_for('upload'))
return render_template('upload.html', form=form, docs = docList)
def __init__(self):
reader = readers()
print(reader)
if not reader:
print("Reader NOT CONNECTED")
print("Connect reader please, and try again")
Read.exit_app()
else:
print("Приложите карту ")
app_init()
def write_head(self):
with open(self.__outvcf, 'w') as fi:
##header
fi.write("{}".format(Read.Readvcf(self.__invcf).header))
#samples行
samples = Read.Readvcf(self.__invcf).samples.split('|')
newsamples = []
for group_name in self.__grp_dict:
for i in self.__grp_dict[group_name]['index']:
newsamples.append(samples[i])
fi.write(
"#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\t{}\n".
format("\t".join(newsamples)))
def main(self):
if not self.__invcf:
print('Use --help for command line help')
return
try:
os.makedirs(args.work_dir)
except:
pass
#print ('%s exists' %(args.work_dir))
self.get_group()
self.write_head()
low_dp, high_dp = self.__depth.split(',')
vcfinfo = Read.Readvcf(self.__invcf).extract
#pool = mp.Pool(1) #启动多线程池
for each in vcfinfo:
self.run_filter(each, self.__grp_dict, low_dp, high_dp)
#pool.apply_async(self.run_filter, args=(each, self.__grp_dict, low_dp, high_dp))#函数写入到多线程池
"""
print('Waiting for all subprocesses done...')
pool.close()
pool.join()
print('All subprocesses done.')
pool.terminate()
"""
print("低/高深度标记次数: {}".format(self.__total_dp_num))
print("Homogeneous标记次数: {}".format(self.__total_homogeneous_num))
def algrun():
global t, list
time_start = time.time()
map = Map.Map()
x, y = Read.Read()
map.path[0] = x
map.path[1] = y
# state == 0: SA, state == 1: LS
state = 0
if state == 0:
# SA(map, T, Coolrate)
alg = SA.SA(map, 100, 0.001)
alg.run()
elif state == 1:
# LS(map, state), state = 0: LS1, state = 1: LS2, state = 2: 2-OPT
alg = LS.LS(map, 2)
alg.run()
list.append(alg.path.distance())
time_end = time.time()
t += (time_end - time_start)
print('totally cost', time_end - time_start, 's')
def GetFile (self, FileName, Owner, user_conf, user_integ, logger, IsHoneyPot, Read) :
logger.Put_Get_Audit(Owner, FileName, "Get", IsHoneyPot)
path = ""
if IsHoneyPot == 0 :
self.dir = "Files/"
else :
self.dir = "Fake/Files/"
# Check for path traversal attack
if '\\' in FileName or '/' in FileName:
return "Invalid file name\n"
if self.FileNameCheck(FileName) == -1:
return "File Not Found !!!\n"
file = open(self.dir + FileName, "r")
file_acl = file.readline()
file_acl = file.readline()
file.close()
if self.OwnerCheck(Owner, FileName) == -1 and self._CheckDiscretionaryAccess(file_acl, Owner) == -1:
return "Permission Denied !!!\n"
if self._CheckDiscretionaryAccess(file_acl, Owner) == -1:
return "Permission Denied!(By discretionary access control rules)\n"
file_content = Read.ReadFromFile(Owner, FileName, user_conf, user_integ, logger, IsHoneyPot)
os.remove(self.dir + FileName)
return FileName + " Removed from Server Successfully !!!\n" + file_content
def checkStorage(unitMap, status, sandbox):
for unitNum in range(0, len(unitMap)):
currentStatusData = Read.read('127.0.0.1', 0, registerSize, unitNum)
print("[%d] %s" % (unitNum, currentStatusData))
if (status[unitNum] is False):
print("[X]read failed, ignore this unit.")
continue
# compare current status , it don't match old status, write to storage, and sent to sandbox.
if (currentStatusData == status[unitNum]):
continue
if (sandboxON):
sandboxAccept = sandbox.checkSandBox(unitNum, currentStatusData[0])
if (sandboxAccept):
if (sentToDevice(unitMap[unitNum], currentStatusData,
unitNum)):
status[unitNum] = currentStatusData
else:
print("[X]sent to device failed.")
else:
print("[!]dangerous action to device[%s]: %s" %
(unitMap[unitNum], currentStatusData))
print("[!]Recovery to last status.")
if (sentToDevice(unitMap[unitNum], status[unitNum], unitNum)):
print("[-]Recover success.")
else:
print("[X]Recover failed.")
else:
print(currentStatusData, " <-> ", status[unitNum])
if (sentToDevice(unitMap[unitNum], currentStatusData, unitNum)):
status[unitNum] = currentStatusData
else:
print("[X]sent to device failed.")
def main():
reference = Reference(argv[1])
reference.get_regions_index()
print("Reference %s processed" % argv[1])
with gzip.open(argv[2], 'rt') as sam_file:
alignment = AlignmentInformation(reference)
print("Processing alignment information in SAM file...")
for line in sam_file.readlines(
)[2:]: # Information of reads alignment starts in 2nd line
read = Read(line)
if read.flag != 4 and read.quality == 255:
'''
Reads with flag value 4 (i.e. not aligned) and quality value different than 255 (optimal)
are not processed
'''
read.parse_cigar()
read.get_aligned_sequence()
for exon_range in reference.exons_index_list:
in_exons = read.is_aligned_to(exon_range)
if in_exons is True: # Only exon information is accounted
alignment.update_count_dictionary(read)
break
alignment.create_proportion_dictionary()
print("Progressive analysis in progress...")
progressive_analysis = ProgressiveAnalysis(
alignment) # Proportion_threshold value customizable, default=5
print("%i genes/s detected" %
len(list(progressive_analysis.result_alleles_dictionary.keys())))
print("Combined analysis in progress...")
combined_analysis = CombinedAnalysis(progressive_analysis, alignment)
write_output_file(progressive_analysis, combined_analysis, argv[2],
argv[3])
print("Analysis done, results written into output file: %s" % argv[3])
sam_file.close()
sam_file.close()
def __main__():
check_files_and_folders()
socket = Socket.ServerSocket()
connection = socket.Socket()
sr = Server(connection, Cryptography.session_crypto(None), Registery.Registery(), Login.serverLogin(),
Download.Download(), Upload.Upload(), List.List(), Read.Read(), Write.Write(),
SessionKeyExchange.ServerSession(None),
DACCommands.DACCommands(), Auditor.Auditor())
sr.Handler()
def launch(market):
results = []
if (market in ['Resources', 'Miner']):
results.extend(
Read.readingFrom(Settings.settings['Markets']['location']['otype'],
Settings.settings['Read']['mode']['texte'],
method='single_textline',
colors=['gray']))
results.extend(
Read.readingFrom(
Settings.settings['Markets']['location']['title'],
Settings.settings['Read']['mode']['texte'],
method='single_textline',
))
results.extend(
Read.readingFrom(
Settings.settings['Markets']['location']['un'],
Settings.settings['Read']['mode']['kamas'],
method='only_digits',
))
results.extend(
Read.readingFrom(
Settings.settings['Markets']['location']['dix'],
Settings.settings['Read']['mode']['kamas'],
method='only_digits',
))
results.extend(
Read.readingFrom(
Settings.settings['Markets']['location']['cent'],
Settings.settings['Read']['mode']['kamas'],
method='only_digits',
))
results = Check.checkResources(results)
results = Parse.parseResources(results)
marketsToDb[market](results)
return results
elif (market == 'RollBack'):
marketsToDb['RollBack']()
elif (market == 'commitDB'):
marketsToDb['commitDB']()
def info(self):
msg = QtWidgets.QMessageBox()
msg.setMaximumSize(QtCore.QSize(281, 16777215))
msg.setGeometry(QtCore.QRect(510, 330, 581, 281))
msg.setInformativeText("Hold the tag near the RFID reader")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
ret = rd.rfid()
print(ret)
if ret == 1:
self.choice()
def plotMeanVelocityComponent(RA, Retau, velocity_component):
fig = plt.figure(1, figsize=(10, 30))
gs = fig.add_gridspec(6, 14)
fig.suptitle(
'Mean velocity flow for $R_{\\tau}$ and different RA values for velocity compoment '
+ velocity_component)
fig.subplots_adjust(hspace=1)
for ii in range(len(RA)):
ra = RA[ii]
ncols = RA[ii] - 1
### Collect coordinates and mean velocity data
usecase = str(ra) + '_' + str(Retau)
zcoord, DIM_Z = Read.importCoordinates('z', usecase)
ycoord, DIM_Y = Read.importCoordinates('y', usecase)
U = Read.importMeanVelocity(DIM_Y, DIM_Z, usecase,
velocity_component)
### Create subplots
if (ncols == 0):
ax = fig.add_subplot(gs[ii, 0])
else:
ax = fig.add_subplot(gs[ii, 0:ncols])
### Add contour graphs to subplots
ax.contourf(U,
extent=(np.amin(zcoord), np.amax(zcoord),
np.amin(ycoord), np.amax(ycoord)),
cmap=plt.cm.Oranges)
ax.set_title('RA = ' + str(ra))
if (ii == m.ceil(len(RA) / 2)):
ax.set_ylabel('z: spanwise (a. u.)')
if (ii == len(RA) - 1):
ax.set_xlabel('y: wall normal (a. u. )')
plt.plot()
def __init__(self, invcf, grp_dict, grp_name="", samples_lst=[]):
self.invcf = invcf
self.all_samples_lst = Read.Readvcf(self.invcf).samples.split('|')
self.grp_dict = grp_dict
if grp_name:
self.grp_name = grp_name
else:
self.grp_name = 'All'
if len(samples_lst) > 1:
self.samples_lst = samples_lst
else:
self.samples_lst = self.all_samples_lst
self.handle_grp()
def initial(unitMap, status):
for unitNum in range(0, len(unitMap)):
statusData = Read.read('127.0.0.1', 0, registerSize, unitNum)
if (statusData == False):
sys.exit("initial failed.")
status.append(statusData)
sandbox = None
if (sandboxON):
print("[-]The sandbox is ON!")
sandbox = Sandbox.SandBox()
return sandbox
else:
print("[!]The sandbox is current OFF!")
return None
def delegate(conn, user_in):
user_in = user_in.lower()
if user_in == "create":
print("\n")
return Create.Create(conn)
elif user_in == "read":
print("\n")
return Read.Read(conn)
elif user_in == "update":
print("\n")
return Update.Update(conn)
elif user_in == "delete":
print("\n")
return Delete.Delete(conn)
else:
raise Exception("Invalid User input: " + user_in)
def svm(w,data_pts,eta,lam,tau,d,weight,shuff=0,N=1,n=0):#,result,index): #,tau):
l = len(w)
fn = np.zeros(tau) # array of calculated loss functions for each local iteration (tau)
for t in range(0, int(tau)):
x, y = Read.Read(d, data_pts, weight, offset=0) # weight modifies yread Read(numPoints, data, weight, offset=0)
wT = w.transpose()
dfn = np.zeros(l)
for j in range(0 , d):
if (1-y[j]*np.dot(wT, x[j]))<0:
max = 0
else:
max = 1-y[j]*np.dot(wT, x[j])
for i in range(0,l):
dfn[i] += (lam*w[i]-(y[j]*x[j,i])*max)/d
fn[t] += ((lam/2)*np.dot(w, wT)**2 + (max**2)/2)/d
w = w - eta*dfn
return w,fn
def auth():
authenticated = False
while not authenticated:
print("Waiting for admin card to authenticate ...")
card = Read.main()
print "Card read : " + card
headers = {"Content-Type": "application/json"}
payload = {"card_id": card}
r = requests.post(URLAuth, data=json.dumps(payload), headers=headers)
tokenRetour = json.loads(r.content)
if "user" in tokenRetour and "role" in tokenRetour["user"] and (
tokenRetour["user"]["role"] == "ROLE_SUPER_ADMIN"
or tokenRetour["user"]["role"] == "ROLE_ADMIN"):
print "AUTHENTICATED ! \n ROLE : " + tokenRetour["user"][
"role"] + " \n Firstname : " + tokenRetour["user"]["firstname"]
return tokenRetour["value"]
elif "user" not in tokenRetour:
print "La carte n'est pas lie a un compte"
else:
print "La carte n'a pas un role super admin ou admin "
def svm(w,
data_pts,
eta,
lam,
tau,
d,
weight,
shuff=0,
N=1,
n=0): #,result,index): #,tau):
l = len(w)
fn = np.zeros(
tau
) # array of calculated loss functions for each local iteration (tau)
for t in range(0, int(tau)):
if t > 0: # execute shuffling after the first iteration
if shuff == 1:
np.random.shuffle(data_pts)
elif shuff == 2:
data_pts = Shuffle.rRobin(data_pts, N=N)
elif shuff == 3:
data_pts = Shuffle.segShift(data_pts, N=N)
x, y = Read.Read(d, data_pts, weight,
offset=n) # weight modifies yread
wT = w.transpose()
dfn = np.zeros(l)
for j in range(0, d):
if (1 - y[j] * np.dot(wT, x[j])) < 0:
max = 0
else:
max = 1 - y[j] * np.dot(wT, x[j])
for i in range(0, l):
dfn[i] += (lam * w[i] - (y[j] * x[j, i]) * max) / d
fn[t] += ((lam / 2) * np.dot(w, wT)**2 + (max**2) / 2) / d
w = w - eta * dfn
return w, fn
def main( fq_file, n ): pos = 0 with open( fq_file ) as f: for row in f: l = row.strip() if pos % 4 == 0: R = Read( l, trim_by=n ) elif pos % 4 == 1: R.bases = l elif pos % 4 == 2: R.name_ = l elif pos % 4 == 3: R.quals = l R.remove_polyA() try: print R except TypeError: pass pos += 1
def reset(self):
self.read_uid = ''
self.button.setEnabled(False)
self.button2.setEnabled(False)
self.button3.setEnabled(False)
self.button4.setEnabled(False)
time.sleep(2)
self.read_uid = Read.run()
conn = sqlite3.connect("cul.db")
cur = conn.cursor()
cur.execute("select * from emp_list where uid = ?", (self.read_uid, ))
rows = cur.fetchall()
conn.close()
if not rows:
self.button.setEnabled(True)
self.button4.setEnabled(True)
self.label.setText("등록 되지않은 카드입니다.")
else:
self.button4.setEnabled(True)
self.button2.setEnabled(True)
self.button3.setEnabled(True)
self.label.setText("반갑습니다")
'008_z005p037', '009_z004p485', '010_z003p984', '011_z003p528',
'012_z003p017', '013_z002p478', '014_z002p237', '015_z002p012',
'016_z001p737', '017_z001p487', '018_z001p259', '019_z001p004',
'020_z000p865', '021_z000p736', '022_z000p615', '023_z000p503',
'024_z000p366', '025_z000p271', '026_z000p183', '027_z000p101',
'028_z000p000'
]
tag = TAGS[Snap]
#SIMREF =
sim = '/cosma5/data/Eagle/ScienceRuns/Planck1/L0025N0376/PE/REFERENCE/data/'
#sim = '/cosma5/data/Eagle/ScienceRuns/Planck1/L0100N1504/PE/REFERENCE/data/'
sim_name = 'L0025N0376_ref'
#sim_name = 'L0100N1504_ref'
L, a, h = R.Read_MainProp(sim, tag)
L *= (a / h)
################################ READ ####################################
pos_St, Mass_St, num_St, num_St_SH = R.Read_Particles(sim, tag)
NumOfSubhalos = R.Read_Haloes(sim, tag)
SubHalo_gr, SubHalo_sgr, SubHalo_pos = R.Read_Subhaloes(sim, tag)
ParticleID, Particle_Binding_Energy = R.Read_Particles_ID(sim, tag)
################################ MAIN ##################################
Index_Range = F.Get_PartIndexRange(num_St, num_St_SH, NumOfSubhalos)
CenterOfPotential = F.Get_SubHaloCenter(SubHalo_gr, SubHalo_sgr, NumOfSubhalos,
SubHalo_pos)
Sel_Group = []
class Seedbed(object):
"""Class Seedbed the hole seedbed at this time
:parameter crusty: if this seedbed has a crusty top
:parameter dry_crust: if this seed bed has a dry crust
:parameter collisions: a count of collisions # TODO make this work - then use a list of collision objects
:parameter run_day: the day after sowing that the seedbed is on now
:parameter seed_tray: a set of instances of class seed in a list
:parameter clod_bed: a set of instances of class clod in a list
:parameter all_rain: the total accumulated rainfall so far in the test
:parameter setup: an instance of the setup class that contains all the info on the sowing from the setup files
:returns A seedbed object
"""
crusty = False # is the seed bead currently crusty
dry_crust = False # is the crust currently dry
collisions = 0 # the number of times a clods or seed collide
run_day = 0 # the day of the seed bed run
seed_tray = list() # a seed tray containing all the seed objects
clod_bed = list() # a try of the clods containing all the clod objects
all_rain = 0 # Total rain fall
setup = Read.setupSeedbed(
) # Read the setup 5 setup files and make an object of all the data
def __init__(self): # todo define clod limets
"""Initialise an instance of seedbed
:parameter clod_no: the number of each clod - 1 indexed
:parameter clod_set: the min size of the clod for a grouped lot of clods
:parameter clod: the clod in this set
:parameter clod_lims: an array representing the [L,h,l] for a clod
:parameter clod_serf_prob: the result of a function call to find where the clod is stuck [False,False,False] for [prob_serf, stuck_serf, stuck_soil]
:parameter Clod: the class that makes a clod object
:parameter sd: a seed in this sowing
:parameter Seed: the class that makes a Seed object
"""
self.setup.sort_clods()
clod_no = 0 # a unique clod number for each clod
for clod_set in range(0, len(self.setup.clod_nos)):
for clod in range(
0,
Clods.clod_numbers(self.setup.clod_nos[clod_set],
self.setup.plot_xyz)):
clod_no += 1 # update for each clod
Write.run_summ("clod " + str(clod_no))
clod_lims = Clods.clod_size(self.setup.clod_lims, clod_set)
radi = (sum(clod_lims) / 3.0) / 2.0
clod_serf_prob = Fun.clod_restriction(
self.setup.p_serf[clod_set],
self.setup.p_stuck_serf[clod_set],
self.setup.p_stuck_soil[clod_set])
self.clod_bed.append(
Clods.Clod(
clod_no,
Fun.position_calc(
self.seed_tray, self.clod_bed,
self.setup.plot_xyz[2] - self.setup.sow_depth,
self.setup.plot_xyz, True, radi, clod_serf_prob),
self.setup.plot_xyz[2], clod_lims))
#print self.clod_bed[clod]
for sd in range(0, self.setup.no_seeds):
self.seed_tray.append(
Seeds.Seed(
sd + 1, self.setup.day_death, self.setup.therm_times,
self.setup.base_germ, self.setup.base_elong,
self.setup.base_wet,
Fun.position_calc(
self.seed_tray, self.clod_bed,
self.setup.plot_xyz[2] - self.setup.sow_depth,
self.setup.plot_xyz, False)))
Write.run_summ("seed " + str(sd + 1) + " initialised")
print self.seed_tray[sd]
def next_day(self, day):
"""Calls other functions to make the next day proceed
:param day: The day of the year to look up the rainfall
:returns : objects
"""
self.run_day += 1
self.crusty_prob(day)
Write.Seed_info(self.seed_tray, self.setup.no_seeds,
self.setup.sow_depth) # germination info write out
for sd in range(0, self.setup.no_seeds):
self.seed_tray[sd].next_day(day, self.setup, self.clod_bed,
self.crusty)
print self.seed_tray[sd]
def crusty_prob(self, day):
"""returns the probability of the seedling getting through the outer layer of soil
:param day: The day of the year to look up the rainfall
:keyword CRc: The rainfall needed cumulatively to produce a crust (default 12mm)
:keyword DRc1: The recent rainfall needed to produce a crust (default 5mm)
:keyword DRc2: The recent rainfall needed to make the crust soft and most (default 3.5mm)
:returns prob: -1 for no crust or the probabilty of going thrugh the crust (1 for wet crust)
"""
crust = False # default no crust
self.all_rain += self.setup.enviro_data_rain[
day] # increment total rain fall
if self.all_rain > self.setup.crc: # all rain more than amount of total rain to make a crust
crust = True
if self.setup.enviro_data_rain[
day] > self.setup.drc1: # Day rain more than day rain to make a crust
crust = True
if crust:
if self.setup.enviro_data_rain[day] > self.setup.drc2:
prob = 1 # crust is wet end seedling can emerge prob = 1
else:
prob = self.setup.p_dry_crust # crust is dry emergence depends on seed power
else:
prob = -1
self.crusty = prob
if (raw_xml == ""):
print("XML file empty")
sys.exit()
bed_dict = LoadBed.LoadBedFile(bed_file_path)
xml = bs4.BeautifulSoup(raw_xml, "html.parser")
discordant_reads = xml.findAll("discordant_read_pair")
softclip_reads = xml.findAll("softclip_read_pair")
deletion_reads = xml.findAll("deletion_read_pair")
read_list = []
for x in softclip_reads:
a = Read.Read()
a.SetRead(x)
read_list.append(a)
for x in deletion_reads:
a = Read.Read()
a.SetRead(x)
read_list.append(a)
breakpoint_list = []
breakpoint_dict = collections.defaultdict(int)
read_list.sort(key=lambda x: x.left_coordinate)
for x in read_list:
entry = x.read.reference_name.string + ":" + str(x.left_coordinate)
################################ Vars ################################################## Snap = int(sys.argv[1]) h = 0.6777 Mcut = 0.0 Rad = 0.05 # 30 pkpc NBin = 50 # dx = 100 ppc TAGS = ['000_z020p000','001_z015p132','002_z009p993','003_z008p988','004_z008p075','005_z007p050','006_z005p971','007_z005p487','008_z005p037','009_z004p485','010_z003p984','011_z003p528','012_z003p017','013_z002p478','014_z002p237','015_z002p012','016_z001p737','017_z001p487','018_z001p259','019_z001p004','020_z000p865','021_z000p736','022_z000p615','023_z000p503','024_z000p366','025_z000p271','026_z000p183','027_z000p101','028_z000p000'] tag = TAGS[Snap] #sim='/cosma5/data/Eagle/ScienceRuns/Planck1/L0025N0752/PE/RECALIBRATED/data/' sim = '/cosma5/data/Eagle/ScienceRuns/Planck1/L0100N1504/PE/REFERENCE/data/' sim_name = 'L0100N1504_ref' L,a,h = R.Read_MainProp(sim, tag) L *= (a/h) ################################ READ #################################### pos_St,Mass_St,num_St,num_St_SH = R.Read_Particles(sim, tag) NumOfSubhalos = R.Read_Haloes(sim, tag) ################################ MAIN ################################## Index_Range = F.Get_PartIndexRange(num_St,num_St_SH,NumOfSubhalos) Sel_Group = []
import Email
import GUI
import Randomizer
import Read
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.output(17, False)
cards = [35915910110]
Id = Read.Read()
if (Id in cards):
message = Randomizer.random(4)
Email.Email(message)
GUI.Gui(message)
else:
print "Access Denied"
GPIO.cleanup()
quit()
<insert_size>414</insert_size>
<read_sequence>TAGGGGTGGGGGCGAGCTTTCACCATCGTGATGGACACTGAAGGAGCTCCCCACCCCCTGATCAGCCAGGAGGATGCAGTTACTATATTTAGAGTAGAAAATCACTCAGAGACATTGTCATTCAGCCTAGGTCATAAGGCTATTATGCAT</read_sequence>
<quality></quality>
<alignments>
<start_coordinate_1>chr2:29448016-29448090</start_coordinate_1>
<orientation_1>forward</orientation_1>
<match_coordinates_1>1-75</match_coordinates_1>
<bitscore_1>145</bitscore_1>
<length_1>75</length_1>
<flag_1>26</flag_1>
<start_coordinate_2>chr2:42493955-42493883</start_coordinate_2>
<orientation_2>reverse</orientation_2>
<match_coordinates_2>3-75</match_coordinates_2>
<bitscore_2>135</bitscore_2>
<length_2>73</length_2>
<flag_2>5</flag_2>
</alignments>
</read>
</softclip_read_pair>"""
bp = Read.Read()
xml = bs4.BeautifulSoup(raw_xml, "html.parser")
bp.SetRead(xml)
b = Break()
b.AddRead(bp)
b._FindConsensus()
assert(b.GetLeftSequence() == "-----TAGGAGGACCGACTAGTCCCCCACCCCTCGAGGAAGTCACAGGTAGTGCTACCACTTTCGAGCGGGGGTGGGGAT-------------------------------------------------------------------------------------")
assert(b.GetRightSequence() == "-----AGTTACTATATTTAGAGTAGAAAATCACTCAGAGACATTGTCATTCAGCCTAGGTCATAAGGCTATTATGCAT---------------------------------------------------------------------------------------")
run = True
ardData = serial.Serial('COM4', 9600)
while (run):
hookcd = 20
lanterncd = 22
flaycd = 9
ultcd = 140
hookmod = 2
lanternmod = 2.5
flaymod = 0
ultmod = 20
ab1, ab2, ab3, ult, cdr, lvl1, lvl2, lvl3, lvlult, run, Health, Mana = Read.parse(
)
hookexpect = 0
if lvl1 > 0:
hookexpect = (hookcd - (hookmod *
(lvl1 - 1))) * (1 - int(cdr[1:len(cdr)]) / 100)
if var == 0:
if (len(ab1) > 1):
if (int(ab1[1:len(ab1)]) > hookexpect - 3 + var):
if count > 1:
var = 5
print('miss')
ardData.write(b'1')
ardData.write(b'0')
print "######################################################" print "Starting the code!! Good Luck!!" print "Package Load" ################################################ Pannel ################################################ print "Pannel load" ############################################### VARS ################################################### print "Vars load" Arr_Pos = [] Arr_Vel = [] Arr_Gnum = [] ############################################### Init ################################################### print "Init" ############################################### Read ################################################### print "Read" L, a, h = R.Read_MainProp_V01() M_Group, Cen_Group, R_Group = R.Read_Halo_Prop_Sergio_V01() Pos_DM, Vel_DM, num_DM, mass_DM = R.Read_Part_Prop_Sergio_V04() R_Group = array(R_Group) / a Cen_Group = array(Cen_Group) / a Pos_DM = array(Pos_DM) / a ############################################### Part Sel ################################################### print "Part Sel" ID = where(M_Group > D.Mcut)[0] + 1 GroupID_DM, Particle_ID_DM = F.Get_PartGroupID(num_DM, ID) Index = argsort(GroupID_DM) Particle_ID_DM = Particle_ID_DM[Index] GroupID_DM = GroupID_DM[Index]
from Read import *
from metric import *
from cab import cab
taxis = [cab() for i in range(firstline([2]))]
availableTaxis=[i for i in taxis]
nfl = Read('a_example.in')
jobs = nfl.getJobs()
jobs_by_length = sorted(jobs, key = lambda x : distance([x[0], x[1]], [x[2], x[3]]))
jobs_by_start = sorted(jobs, key = lambda x : x[4])
counter=0
while(i<=10):
for (job in jobs_by_start):
if(len(availableTaxis)!=0):
availableTaxis[0].assign(job)
updateAvailableCabs(availableTaxis)
counter+=1
def updateAvailableCabs(availableTaxis):
availableTaxis=[if(i.isAvailable()) i for i in taxis]
import re
import Read
print Read.read_email_from_gmail().email_body
link_pattern = re.compile('<a[^>]+href=\'(.*?)\'[^>]*>(.*)?</a>')
search = link_pattern.search(Read.email_body)
if search is not None:
print("Link found! -> " + search.group(0))
else:
print("No links were found.")
def start(filename):
Binarise.getBinary(filename)
number_of_segments=RLSA.getSegments(filename.strip('.tif'))
Read.getText(filename.strip('.tif'), number_of_segments)
#
# No one except the Owners have the right to access or modify the code.
#
#########################################################################################################
# Owner : SRM Team Humaniod, Kattankulathur
# Author : Akarsh Shrivastava
# Maintainer: No one tries to maintain this.
#
# Yes I was so jobless that I did all this
import Read
from Dynamixel import Dynamixel
from time import sleep, time
# TODO- think of offsets
# constraints for m2,m5,m8 : -98 to 100
# constraints for m11 : 98 to -100
if __name__ == '__main__':
dxl = Dynamixel()
raw_input("press Enter to continue ")
#Read.do_motion(dxl, "motions/stand_up.mot", 1)
#Read.do_motion(dxl, "motions/left_turn.mot")
#Read.do_motion(dxl, "motions/init_walk.mot", 1)
#Read.do_motion(dxl, "motions/walk.mot")
#Read.do_motion(dxl, "motions/sit_down.mot", 1)
Read.do_motion(dxl, "motions/spot_march.mot")