seq_id stringlengths 4 11 | text stringlengths 113 2.92M | repo_name stringlengths 4 125 ⌀ | sub_path stringlengths 3 214 | file_name stringlengths 3 160 | file_ext stringclasses 18
values | file_size_in_byte int64 113 2.92M | program_lang stringclasses 1
value | lang stringclasses 93
values | doc_type stringclasses 1
value | stars int64 0 179k ⌀ | dataset stringclasses 3
values | pt stringclasses 78
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
73577960018 | #Cachary Tolentino
#12/1/22
#This program will output the highest calories of the elf carrying the most calories
#Main array containing all inputs
calorieListArray = []
#Reading in inputs and assigning each to a slot in an array
with open(r'C:\Users\rance\OneDrive\Documents\My Files\Git\AOC2022\Day1\inputDay1.txt') as f:
for line in f:
calorieListArray.append(line)
#Loops through all the listed calories
currentCalories = 0
highestCalories = 0
for cal in calorieListArray:
if cal == '\n':
currentCalories = 0
continue
else :
if cal == '\n':
continue
currentCalories = currentCalories + int(cal)
if currentCalories > highestCalories:
highestCalories = currentCalories
#Prints the highest calories
print(highestCalories)
| CacharyT/AdventOfCode2022 | Day1.p1/Day1.py | Day1.py | py | 854 | python | en | code | 0 | github-code | 13 |
9409380724 | amnt = float(input("Enter the amount of money : "))
while amnt < 0:
amnt = float(input("Please enter valid amount : "))
dot = str(amnt).find(".")
dlr = int(str(amnt)[:dot])
cnts = int(str(amnt)[dot+1:])
while cnts >= 100:
cnts = cnts - 100
dlr += 1
qtr = int(cnts/25)
cnts = cnts - (qtr*25)
dms = int(cnts/10)
cnts = cnts - (dms*10)
nckl = int(cnts/5)
cnts = cnts - (nckl*5)
pns = cnts
print("Dollars : {}\nQuarters : {}\nDimes : {}\nNickels : {}\nPennies : {}".format(str(dlr), str(qtr), str(dms), str(nckl), str(pns)))
| sunay-sharma/sem4practicals | FP/YSL_python/prac_2.1.py | prac_2.1.py | py | 544 | python | en | code | 0 | github-code | 13 |
72187828817 | from ahps_web import app
from ahps_web.bll.sun_data import get_astral_data
from datetime import datetime, timedelta
def house_codes():
codes = []
for hcx in range(0, 16):
codes.append(chr(ord('A') + hcx))
return codes
def device_codes():
codes = []
for dcx in range(1, 17):
codes.append(str(dcx))
return codes
@app.context_processor
def program_summary_formatter():
'''
Formats a module program into a human readable summary.
:return:
'''
def program_summary(program):
return build_program_summary(program)
return dict(program_summary = program_summary)
def build_program_summary(program):
# Calculate effective start and stop times
sun_data = get_astral_data(datetime.now())
sunset = sun_data["sunset"]
sunrise = sun_data["sunrise"]
effective_start_time = "No Time"
offset = timedelta(minutes=int(program["start_offset"]))
if program["start_trigger_method"] == "sunset":
effective_start_time = (sunset + offset).strftime("%I:%M%p")
elif program["start_trigger_method"] == "sunrise":
effective_start_time = (sunrise + offset).strftime("%I:%M%p")
elif program["start_trigger_method"] == "clock-time":
st = program["start_time"]
start_time = datetime.strptime(program["start_time"], "%I:%M %p")
effective_start_time = (start_time + offset).strftime("%I:%M%p")
else:
effective_start_time = "No Time"
effective_stop_time = "No Time"
offset = timedelta(minutes=int(program["stop_offset"]))
if program["stop_trigger_method"] == "sunset":
effective_stop_time = (sunset + offset).strftime("%I:%M%p")
elif program["stop_trigger_method"] == "sunrise":
effective_stop_time = (sunrise + offset).strftime("%I:%M%p")
elif program["stop_trigger_method"] == "clock-time":
st = program["stop_time"]
stop_time = datetime.strptime(program["stop_time"], "%I:%M %p")
effective_stop_time = (stop_time + offset).strftime("%I:%M%p")
else:
effective_stop_time = "No Time"
start = "Start: Method={0} Offset={1} EffectiveTime={2} Action={3}".format(program["start_trigger_method"],
program["start_offset"],
effective_start_time, program["start_action"])
stop = "Stop: Method={0} Offset={1} EffectiveTime={2} Action={3}".format(program["stop_trigger_method"],
program["stop_offset"],
effective_stop_time, program["stop_action"])
return start + "<br/>" + stop
| dhocker/ahps_web | ahps_web/views/view_helpers.py | view_helpers.py | py | 2,519 | python | en | code | 0 | github-code | 13 |
4181061755 | # Javier Franco
# Texas is Awesome!
import cv2
import numpy as np
#from cv2 import cv
#method = cv.CV_TM_SQDIFF_NORMED
#methods = ['cv2.TM_CCOEFF', 'cv2.TM_CCOEFF_NORMED', 'cv2.TM_CCORR',
# 'cv2.TM_CCORR_NORMED', 'cv2.TM_SQDIFF', 'cv2.TM_SQDIFF_NORMED']
# Read the images from the file
small_image = cv2.imread('fishtemplate.png')
large_image = cv2.imread('fish2.jpg')
#large_image = cv2.resize(large_image, (725, 375))
orig_image=large_image.copy()
#result = cv2.matchTemplate(small_image, large_image, cv2.TM_SQDIFF_NORMED)
result = cv2.matchTemplate(small_image, large_image, cv2.TM_CCOEFF_NORMED)
# We want the minimum squared difference
mn,_,mnLoc,mxLoc = cv2.minMaxLoc(result)
# Draw the rectangle:
# Extract the coordinates of our best match
#MPx,MPy = mnLoc
MPx,MPy = mxLoc
# Step 2: Get the size of the template. This is the same size as the match.
trows,tcols = small_image.shape[:2]
# Step 3: Draw the rectangle on large_image
cv2.rectangle(large_image, (MPx,MPy),(MPx+tcols,MPy+trows),(0,0,255),2)
# Display the original image with the rectangle around the match.
cv2.imshow('output',large_image)
#The image is only displayed if we call this
cv2.waitKey(0)
#
##%%
#
tail = large_image[MPy:MPy+trows, MPx:MPx+tcols] # Crop from x, y, w, h -> 100, 200, 300, 400
##tail= cv2.bilateralFilter(tail, 11, 17, 17)
tail = cv2.GaussianBlur(tail,(5,5),0)
## dilations to remove any small regions of noise
#tail = cv2.threshold(tail, 45, 255, cv2.THRESH_BINARY)[1]
#tail = cv2.erode(tail, None, iterations=2)
#tail = cv2.dilate(tail, None, iterations=2)
#
cv2.imshow("Edged Tail", tail)
cv2.waitKey(0)
tail = cv2.Canny(tail, 30, 200)
#
cv2.imshow("Edged Tail", tail)
cv2.waitKey(0)
#%% Find farthest right edge
trows,tcols = small_image.shape[:2]
#Assumed that the center of image is inside the tail
xPt=round(tcols*0.60) #Find point to start on Xaxis
yPt=round(trows/2) #Find mid point on Yaxis
currVec=tail[:xPt,yPt] #Get top half of tail
topedgeIdx=np.max(currVec.nonzero())
currVec=tail[xPt:,yPt] #Get top half of tail
bottomedgeIdx=np.min(currVec.nonzero())+xPt
maxEdgePt=[0,0]
for currRow in range(topedgeIdx,bottomedgeIdx):
rowVec=tail[currRow,xPt:]
curredgeIdx=list(rowVec.nonzero())
curredgeIdx=list(curredgeIdx[0])
if curredgeIdx[0] >maxEdgePt[1]:
maxEdgePt[0]=currRow
maxEdgePt[1]=curredgeIdx[0] #assign to first nonzero value
maxEdgePt[1]=maxEdgePt[1]+xPt
tail=cv2.circle(large_image,(maxEdgePt[1]+MPx,maxEdgePt[0]+MPy), 5, (0, 0,255), -1)
tailPt=maxEdgePt[1]+MPx
cv2.imshow("Tail", tail)
cv2.waitKey(0)
#%% Find numbers
#Find edges on entire image to search for numbers
gray = cv2.cvtColor(orig_image,cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray,(5,5),0)
edges = cv2.Canny(blur,50,150,apertureSize = 3)
#Show edges of image
#cv2.imshow("Numbers",edges)
#cv2.waitKey(0)
len_range=range(14,18)
CenterOffset=0.35
# Loop to find where the tail edge is at
for curr_len in len_range:
currNumImage = cv2.imread(str(curr_len)+'.png')
result = cv2.matchTemplate(currNumImage, orig_image, cv2.TM_SQDIFF_NORMED)
if len(result) != 0:
mn,_,mnLoc,_ = cv2.minMaxLoc(result)
MPx,MPy = mnLoc
trows,tcols = currNumImage.shape[:2]
cv2.rectangle(large_image, (MPx,MPy),(MPx+tcols,MPy+trows),(0,0,255),2)
maxCenter=MPx+tcols*CenterOffset
if maxCenter > tailPt:
print('The hi range has been found.')
break
lowrange=curr_len-1
currNumImage = cv2.imread(str(lowrange)+'.png')
result = cv2.matchTemplate(currNumImage, orig_image, cv2.TM_SQDIFF_NORMED)
mn,_,mnLoc,_ = cv2.minMaxLoc(result)
MPx,MPy = mnLoc
trows,tcols = currNumImage.shape[:2]
cv2.rectangle(large_image, (MPx,MPy),(MPx+tcols,MPy+trows),(0,0,255),2)
minCenter=MPx+tcols*CenterOffset
#cv2.imwrite('houghlines3.jpg',large_image)
cv2.imshow("Numbers",large_image)
cv2.waitKey(0)
## Make some location calcs
numSpan=maxCenter-minCenter
ptLoc=maxCenter-tailPt
ptFrac=1-ptLoc/numSpan
finalLength=16+ptFrac
print(finalLength)
| codybushnell/datachallenge-april7 | Javier_Franco/ImageSearch_Loop4Numbers.py | ImageSearch_Loop4Numbers.py | py | 4,098 | python | en | code | 0 | github-code | 13 |
17059461054 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import json
from alipay.aop.api.constant.ParamConstants import *
from alipay.aop.api.domain.SearchProductOrientedRuleOpenApi import SearchProductOrientedRuleOpenApi
from alipay.aop.api.domain.SearchProductPeriod import SearchProductPeriod
from alipay.aop.api.domain.SearchProductRegion import SearchProductRegion
class SearchBoxExclusiveMarketingInfoRequest(object):
def __init__(self):
self._action = None
self._action_type = None
self._action_url = None
self._applier_id = None
self._brand_id = None
self._item_id = None
self._material_link = None
self._material_type = None
self._oriented_rules = None
self._serv_code = None
self._target_period = None
self._target_region = None
self._title = None
@property
def action(self):
return self._action
@action.setter
def action(self, value):
self._action = value
@property
def action_type(self):
return self._action_type
@action_type.setter
def action_type(self, value):
self._action_type = value
@property
def action_url(self):
return self._action_url
@action_url.setter
def action_url(self, value):
self._action_url = value
@property
def applier_id(self):
return self._applier_id
@applier_id.setter
def applier_id(self, value):
self._applier_id = value
@property
def brand_id(self):
return self._brand_id
@brand_id.setter
def brand_id(self, value):
self._brand_id = value
@property
def item_id(self):
return self._item_id
@item_id.setter
def item_id(self, value):
self._item_id = value
@property
def material_link(self):
return self._material_link
@material_link.setter
def material_link(self, value):
self._material_link = value
@property
def material_type(self):
return self._material_type
@material_type.setter
def material_type(self, value):
self._material_type = value
@property
def oriented_rules(self):
return self._oriented_rules
@oriented_rules.setter
def oriented_rules(self, value):
if isinstance(value, SearchProductOrientedRuleOpenApi):
self._oriented_rules = value
else:
self._oriented_rules = SearchProductOrientedRuleOpenApi.from_alipay_dict(value)
@property
def serv_code(self):
return self._serv_code
@serv_code.setter
def serv_code(self, value):
self._serv_code = value
@property
def target_period(self):
return self._target_period
@target_period.setter
def target_period(self, value):
if isinstance(value, SearchProductPeriod):
self._target_period = value
else:
self._target_period = SearchProductPeriod.from_alipay_dict(value)
@property
def target_region(self):
return self._target_region
@target_region.setter
def target_region(self, value):
if isinstance(value, list):
self._target_region = list()
for i in value:
if isinstance(i, SearchProductRegion):
self._target_region.append(i)
else:
self._target_region.append(SearchProductRegion.from_alipay_dict(i))
@property
def title(self):
return self._title
@title.setter
def title(self, value):
self._title = value
def to_alipay_dict(self):
params = dict()
if self.action:
if hasattr(self.action, 'to_alipay_dict'):
params['action'] = self.action.to_alipay_dict()
else:
params['action'] = self.action
if self.action_type:
if hasattr(self.action_type, 'to_alipay_dict'):
params['action_type'] = self.action_type.to_alipay_dict()
else:
params['action_type'] = self.action_type
if self.action_url:
if hasattr(self.action_url, 'to_alipay_dict'):
params['action_url'] = self.action_url.to_alipay_dict()
else:
params['action_url'] = self.action_url
if self.applier_id:
if hasattr(self.applier_id, 'to_alipay_dict'):
params['applier_id'] = self.applier_id.to_alipay_dict()
else:
params['applier_id'] = self.applier_id
if self.brand_id:
if hasattr(self.brand_id, 'to_alipay_dict'):
params['brand_id'] = self.brand_id.to_alipay_dict()
else:
params['brand_id'] = self.brand_id
if self.item_id:
if hasattr(self.item_id, 'to_alipay_dict'):
params['item_id'] = self.item_id.to_alipay_dict()
else:
params['item_id'] = self.item_id
if self.material_link:
if hasattr(self.material_link, 'to_alipay_dict'):
params['material_link'] = self.material_link.to_alipay_dict()
else:
params['material_link'] = self.material_link
if self.material_type:
if hasattr(self.material_type, 'to_alipay_dict'):
params['material_type'] = self.material_type.to_alipay_dict()
else:
params['material_type'] = self.material_type
if self.oriented_rules:
if hasattr(self.oriented_rules, 'to_alipay_dict'):
params['oriented_rules'] = self.oriented_rules.to_alipay_dict()
else:
params['oriented_rules'] = self.oriented_rules
if self.serv_code:
if hasattr(self.serv_code, 'to_alipay_dict'):
params['serv_code'] = self.serv_code.to_alipay_dict()
else:
params['serv_code'] = self.serv_code
if self.target_period:
if hasattr(self.target_period, 'to_alipay_dict'):
params['target_period'] = self.target_period.to_alipay_dict()
else:
params['target_period'] = self.target_period
if self.target_region:
if isinstance(self.target_region, list):
for i in range(0, len(self.target_region)):
element = self.target_region[i]
if hasattr(element, 'to_alipay_dict'):
self.target_region[i] = element.to_alipay_dict()
if hasattr(self.target_region, 'to_alipay_dict'):
params['target_region'] = self.target_region.to_alipay_dict()
else:
params['target_region'] = self.target_region
if self.title:
if hasattr(self.title, 'to_alipay_dict'):
params['title'] = self.title.to_alipay_dict()
else:
params['title'] = self.title
return params
@staticmethod
def from_alipay_dict(d):
if not d:
return None
o = SearchBoxExclusiveMarketingInfoRequest()
if 'action' in d:
o.action = d['action']
if 'action_type' in d:
o.action_type = d['action_type']
if 'action_url' in d:
o.action_url = d['action_url']
if 'applier_id' in d:
o.applier_id = d['applier_id']
if 'brand_id' in d:
o.brand_id = d['brand_id']
if 'item_id' in d:
o.item_id = d['item_id']
if 'material_link' in d:
o.material_link = d['material_link']
if 'material_type' in d:
o.material_type = d['material_type']
if 'oriented_rules' in d:
o.oriented_rules = d['oriented_rules']
if 'serv_code' in d:
o.serv_code = d['serv_code']
if 'target_period' in d:
o.target_period = d['target_period']
if 'target_region' in d:
o.target_region = d['target_region']
if 'title' in d:
o.title = d['title']
return o
| alipay/alipay-sdk-python-all | alipay/aop/api/domain/SearchBoxExclusiveMarketingInfoRequest.py | SearchBoxExclusiveMarketingInfoRequest.py | py | 8,101 | python | en | code | 241 | github-code | 13 |
37982264913 | #!/usr/bin/env python
r"""
Numerical experiment of Chapter 14 (maximum likelihood estimation).
See Figure 14.8 and surrounding discussion.
The considered model and data are from Temereanca et al (2008):
X_0 ~ N(0, sigma^2)
X_t = rho X_{t-1} + \sigma U_t, U_t ~ N(0, 1)
Y_t ~ Bin(50, logit_inv(X_t))
where logit_inv(x) = 1/(b 1 + exp(-x))
The parameter is theta = (rho, sigma^2), with 0 <= rho <= 1, and sigma^2 >= 0.
We plot the contour of the log-likelihood function, and compare the following
algorithms:
* EM
* Nelder-Mead (simplex)
* gradient ascent (not plotted)
Note: MLE is (rho, sigma2) = (0.9981, 0.1089)
"""
import itertools
import matplotlib
from matplotlib import pyplot as plt
import numpy as np
import pickle
from scipy.special import expit
from scipy import optimize
import particles
from particles import datasets as dts
from particles import distributions as dists
from particles import state_space_models as ssms
# data
data = dts.Neuro().data
T = len(data)
# state space model
class NeuroXp(ssms.StateSpaceModel):
default_params = {'M': 50, 'rho': .99, 'sig2': .0121}
# values from Heng et al
def PX0(self):
return dists.Normal()
def PX(self, t, xp):
return dists.Normal(loc=self.rho * xp, scale=np.sqrt(self.sig2))
def PY(self, t, xp, x):
return dists.Binomial(n=self.M, p=expit(x))
def upper_bound_log_pt(self, t):
return - 0.5 * np.log(2. * np.pi * self.sig2)
class MinusLogLikEvaluator:
def __init__(self, N=1000):
self.N = N
self.args = []
self.lls = []
def __call__(self, x):
rho, sig2 = x[0], x[1]
if rho > 1. or rho < 0. or sig2 <=0:
return np.inf
fk = ssms.Bootstrap(ssm=NeuroXp(rho=rho, sig2=sig2), data=data)
pf = particles.SMC(fk=fk, N=self.N, qmc=True)
pf.run()
self.args.append(x)
self.lls.append(pf.logLt)
return - pf.logLt
def smoothing_trajectories(rho, sig2, N=100):
fk = ssms.Bootstrap(ssm=NeuroXp(rho=rho, sig2=sig2), data=data)
pf = particles.SMC(fk=fk, N=N, qmc=False, store_history=True)
pf.run()
(paths, ar) = pf.hist.backward_sampling(N, return_ar=True,
linear_cost=True)
print('Acceptance rate (FFBS-reject): %.3f' % ar)
return (paths, pf.logLt)
# saving intermediate results
#############################
save_intermediate = False
results_file = 'neuro_results.pkl'
all_results = {}
def save_results(new_results):
all_results.update(new_results)
with open(results_file, 'wb') as f:
pickle.dump(all_results, f)
# Evaluate log-likelihood on a grid
###################################
ng = 50
rhos = np.linspace(0., 1., ng)
sig2s = np.linspace(1e-2, 25., ng) # for sigma=0., returns Nan
ijs = list(itertools.product(range(ng), range(ng)))
fks = {ij: ssms.Bootstrap(ssm=NeuroXp(rho=rhos[ij[0]], sig2=sig2s[ij[1]]),
data=data)
for ij in ijs}
outf = lambda pf: pf.logLt
nruns = 5
print('computing log-likelihood on a grid')
results = particles.multiSMC(fk=fks, N=100, qmc=True, nruns=nruns, nprocs=0,
out_func=outf)
save_results({'results': results})
# EM
####
def EM_step(rho, sig2, N=100):
paths, loglik = smoothing_trajectories(rho, sig2, N=N)
num = np.mean(sum(x * xp for x, xp in zip(paths[1:], paths[:-1])))
den = np.mean(sum(x**2 for x in paths[:-1]))
new_rho = num / den
ssq = sum((x - new_rho * xp)**2
for x, xp in zip(paths[1:], paths[:-1]))
ssq += paths[0]**2
new_sig2 = np.mean(ssq) / T
return new_rho, new_sig2, loglik
def EM(rho0, sig20, N=100, maxiter=100, xatol=1e-2):
rhos, sig2s, lls = [rho0], [sig20], []
while len(rhos) < maxiter + 1:
new_rho, new_sig2, ll = EM_step(rhos[-1], sig2s[-1], N=N)
print(f'rho: {new_rho:.3f}, sigma^2: {new_sig2:.3f}')
rhos.append(new_rho)
sig2s.append(new_sig2)
lls.append(ll)
err = np.abs(rhos[-1] - rhos[-2]) + np.abs(sig2s[-1] - sig2s[-2])
if err < xatol:
break
return {'rhos':rhos, 'sig2s': sig2s, 'lls': lls}
print('EM algorithm')
rho0, sig20 = .1, .5
em_results = EM(rho0, sig20, N=100, xatol=1e-3)
save_results(em_results)
# gradient-free optimisation
############################
print('gradient-free optim (Nelder-Mead)')
ll_eval = MinusLogLikEvaluator(N=5000)
res_opt = optimize.minimize(ll_eval, [rho0, sig20], method='Nelder-Mead',
options={'maxiter': 100, 'xatol': 1e-2})
save_results({'ll_eval': ll_eval})
# gradient ascent
#################
def grad(rho, sig2, N=100):
paths, _ = smoothing_trajectories(rho, sig2, N=N)
residuals = [(x - rho * xp) for x, xp in zip(paths[1:], paths[:-1])]
sr2 = np.mean(sum(r**2 for r in residuals))
grad_sig2 = 0.5 * (sr2 / sig2**2 - (T + 1) / sig2)
srx = np.mean(sum(r * x for r, x in zip(residuals[1:], paths[:-1])))
grad_rho = srx / sig2
print(f'grads: {grad_rho:.3f}, {grad_sig2:3f}')
return grad_rho, grad_sig2
def grad_ascent_step(rho, sig2, N=100, lambdat=1e-4):
grad_rho, grad_sig2 = grad(rho, sig2, N=N)
new_rho = rho + lambdat * grad_rho
new_sig2 = sig2 + lambdat * grad_sig2
return new_rho, new_sig2
print('gradient ascent')
rhos_ga, sig2s_ga = [rho0], [sig20]
for _ in range(100):
new_rho, new_sig2 = grad_ascent_step(rhos_ga[-1], sig2s_ga[-1], lambdat=1e-6)
rhos_ga.append(new_rho)
sig2s_ga.append(new_sig2)
print(f'rho={rhos_ga[-1]:.3f}, sig2={sig2s_ga[-1]:.3f}')
save_results({'rhos_ga': rhos_ga, 'sig2s_ga': sig2s_ga})
# PLOTS
#######
plt.style.use('ggplot')
savefigs = True # False if you don't want to save plots as pdfs
# contour plots
rho_mg, sig2_mg = np.meshgrid(rhos, sig2s)
ll_arr = np.zeros((ng, ng, nruns))
for r in results:
i, j = r['fk']
k = r['run']
ll_arr[i, j, k] = r['output']
ll_var = np.var(ll_arr, axis=2)
ll_max = ll_arr.max(axis=2)
ll_mean = (np.log(np.mean(np.exp(ll_arr - ll_max[:, :, np.newaxis]), axis=2))
+ ll_max)
# mean is actually log-mean-exp
# variance contours
fig, ax = plt.subplots()
levels = (0.1, 1., 10., 100.)
CS = ax.contourf(rho_mg, sig2_mg, ll_var.T, levels=levels, cmap=plt.cm.bone)
ax.clabel(CS, inline=1, fontsize=10)
ax.set_xlabel(r'$\rho$')
ax.set_ylabel(r'$\sigma^2$')
cbar = fig.colorbar(CS)
cbar.ax.set_ylabel('variance log-lik')
if savefigs:
plt.savefig('neuro_contour_var.pdf')
# log-lik contours
fig, ax = plt.subplots()
matplotlib.rcParams['contour.negative_linestyle'] = 'solid'
imax, jmax = np.unravel_index(np.argmax(ll_mean), (ng, ng))
mle_ll = ll_mean[imax, jmax]
ax.plot(rhos[imax], sig2s[jmax], markersize=3, marker="o", color='black')
levels = mle_ll + np.linspace(- 2 * 10**4, -0., 121)
CS = ax.contour(rho_mg, sig2_mg, ll_mean.T, levels=levels, colors='lightgray')
ax.set_xlabel(r'$\rho$')
ax.set_ylabel(r'$\sigma^2$')
ax.set_xlim(left=0., right=1.)
ax.set_ylim(bottom=0., top=sig2s[-1])
# add EM points
ax.plot(em_results['rhos'], em_results['sig2s'], 'o-k', zorder=20, label='EM')
# add simplex points
rhos_simplex = [x[0] for x in ll_eval.args]
sig2s_simplex = [x[1] for x in ll_eval.args]
ax.scatter(rhos_simplex, sig2s_simplex, marker='x', c='gray', zorder=10,
label='simplex')
ax.legend(loc='upper left')
if savefigs:
plt.savefig('neuro_contour_ll_with_EM_and_simplex.pdf')
| nchopin/particles | book/mle/mle_neuro.py | mle_neuro.py | py | 7,440 | python | en | code | 337 | github-code | 13 |
14386276155 | #
# @lc app=leetcode.cn id=206 lang=python3
#
# [206] 反转链表
#
# @lc code=start
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
if not head:
return None
prev = None
cur = head
while cur.next:
next_next = cur.next.next
cur.next.next = head
head = cur.next
cur.next = next_next
return head
# @lc code=end
| largomst/leetcode-problem-solution | 206.反转链表.2.py | 206.反转链表.2.py | py | 586 | python | en | code | 0 | github-code | 13 |
1678756507 | import argparse
import os
from tqdm import tqdm
import os.path as osp
import time
import cv2
import torch
import xml.etree.ElementTree as ET
import pickle
import numpy as np
import sys
import shutil
def voc_ap(rec, prec, use_07_metric=False):
"""
Compute VOC AP given precision and recall.
If use_07_metric is true, uses the
VOC 07 11 point method (default:False).
"""
if use_07_metric:
# 11 point metric
ap = 0.0
for t in np.arange(0.0, 1.1, 0.1):
if np.sum(rec >= t) == 0:
p = 0
else:
p = np.max(prec[rec >= t])
ap = ap + p / 11.0
else:
# correct AP calculation
# first append sentinel values at the end
mrec = np.concatenate(([0.0], rec, [1.0]))
mpre = np.concatenate(([0.0], prec, [0.0]))
# compute the precision envelope
for i in range(mpre.size - 1, 0, -1):
mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])
# to calculate area under PR curve, look for points
# where X axis (recall) changes value
i = np.where(mrec[1:] != mrec[:-1])[0]
# and sum (\Delta recall) * prec
ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
return ap
def parse_rec(filename):
"""Parse a PASCAL VOC xml file"""
tree = ET.parse(filename)
objects = []
for obj in tree.findall("object"):
obj_struct = {}
obj_struct["name"] = obj.find("name").text
# obj_struct["pose"] = obj.find("pose").text
# obj_struct["truncated"] = int(obj.find("truncated").text)
obj_struct["difficult"] = int(obj.find("difficult").text)
bbox = obj.find("bndbox")
obj_struct["bbox"] = [
int(float(bbox.find("xmin").text)),
int(float(bbox.find("ymin").text)),
int(float(bbox.find("xmax").text)),
int(float(bbox.find("ymax").text)),
]
objects.append(obj_struct)
return objects
def voc_eval(
detpath,
annopath,
imagesetfile,
classname,
cachedir,
ovthresh=0.5,
use_07_metric=False,
limit = None
):
# first load gt
if not os.path.isdir(cachedir):
os.mkdir(cachedir)
cachefile = os.path.join(cachedir, "annots.pkl")
# read list of images
with open(imagesetfile, "r") as f:
lines = f.readlines()
imagenames = [x.strip() for x in lines]
# print(imagenames)
if not os.path.isfile(cachefile):
# load annots
recs = {}
for i, imagename in enumerate(imagenames):
recs[imagename] = parse_rec(annopath.format(imagename))
if i % 100 == 0:
print(f"Reading annotation for {i + 1}/{len(imagenames)}")
if limit != None and i == limit:
break
# save
print(f"Saving cached annotations to {cachefile}")
with open(cachefile, "wb") as f:
pickle.dump(recs, f)
else:
# load
with open(cachefile, "rb") as f:
recs = pickle.load(f)
# extract gt objects for this class
class_recs = {}
npos = 0
classname = 'Human'
for imagename in imagenames:
R = [obj for obj in recs[imagename] if obj["name"] == classname]
bbox = np.array([x["bbox"] for x in R])
difficult = np.array([0 for x in R]).astype(bool)
# difficult = np.array([x["difficult"] for x in R]).astype(bool)
det = [False] * len(R)
npos = npos + sum(~difficult)
class_recs[imagename] = {"bbox": bbox, "difficult": difficult, "det": det}
# read dets
detfile = detpath.format(classname)
with open(detfile, "r") as f:
lines = f.readlines()
if len(lines) == 0:
return 0, 0, 0
splitlines = [x.strip().split(" ") for x in lines]
image_ids = [x[0] for x in splitlines]
confidence = np.array([float(x[1]) for x in splitlines])
BB = np.array([[float(z) for z in x[2:]] for x in splitlines])
# print(BB)
# exit()
# sort by confidence
sorted_ind = np.argsort(-confidence)
BB = BB[sorted_ind, :]
image_ids = [image_ids[x] for x in sorted_ind]
# go down dets and mark TPs and FPs
nd = len(image_ids)
tp = np.zeros(nd)
fp = np.zeros(nd)
sum_GT = 0
# create list false positive images
fp_list_images = []
# caculate grounding true box
# print(image_ids)
# exit()
for frame,info in class_recs.items():
sum_GT +=info["bbox"].shape[0]
# Traversal each box prediction
for d in range(nd):
R = class_recs[image_ids[d]]
# print(R)
# exit()
bb = BB[d, :].astype(float)
# print(bb)
# exit()
ovmax = -np.inf
BBGT = R["bbox"].astype(float)
if BBGT.size > 0:
# compute overlaps
# intersection
ixmin = np.maximum(BBGT[:, 0], bb[0])
# print(BBGT[:, 0],bb[0])
# exit()
iymin = np.maximum(BBGT[:, 1], bb[1])
ixmax = np.minimum(BBGT[:, 2], bb[2])
iymax = np.minimum(BBGT[:, 3], bb[3])
iw = np.maximum(ixmax - ixmin + 1.0, 0.0)
ih = np.maximum(iymax - iymin + 1.0, 0.0)
inters = iw * ih
uni = (
(bb[2] - bb[0] + 1.0) * (bb[3] - bb[1] + 1.0)
+ (BBGT[:, 2] - BBGT[:, 0] + 1.0) * (BBGT[:, 3] - BBGT[:, 1] + 1.0) - inters
)
overlaps = inters / uni
ovmax = np.max(overlaps)
jmax = np.argmax(overlaps)
if ovmax > ovthresh:
if not R["difficult"][jmax]:
if not R["det"][jmax]:
tp[d] = 1.0
R["det"][jmax] = 1
else:
fp[d] = 1.0
else:
fp[d] = 1.0
fp_list_images.append(image_ids[d])
fp_list_images = set(fp_list_images)
# caculate fp,tp,fn,recall,percision
fp = np.cumsum(fp)
tp = np.cumsum(tp)
rec = tp / float(npos)
# avoid divide by zero in case the first detection matches a difficult
# ground truth
prec = tp / np.maximum(tp + fp, np.finfo(np.float64).eps)
# Caculate number fn,tp,fp
FN = int(np.max(npos) - np.max(tp))
TP = int(np.max(tp))
FP = int(np.max(fp))
ap = voc_ap(rec, prec, use_07_metric)
return rec, prec, ap, tp, fp,TP,FP,FN,sum_GT,fp_list_images
def move_fp_images(list_fp_images,base_name,image_draw_fodel):
"Moving images containg false positive cases"
new_folder = f"/media/anlab/800gb/trungnh/Fp_softhard_images/fp_images_{base_name}"
os.mkdir(new_folder)
for img in list_fp_images:
img = img+".jpg"
old_name = os.path.join(image_draw_fodel,img)
new_name = os.path.join(new_folder,img)
shutil.copy(old_name,new_name)
camera_list = ["ch02","ch03","ch04","ch06","ch07","ch08"]
# camera_list = ["ch04"]
ckpt_file = "/media/anlabadmin/data_ubuntu/yolox/Weight/Weight10epochs/latest_ckpt.pth_yolo_x_9.tar"
basename = os.path.basename(ckpt_file).split('.tar')[0]
for camera in camera_list:
print(f"====================={camera}==========================")
detpath = '/media/anlabadmin/data_ubuntu/yolox/Result_detection/model_x_10epochs_1800frames/'+camera+'/ResultGen_'+basename+'.txt'
annopath = '/media/anlabadmin/data_ubuntu/yolox/many_people_fullano1minute/'+camera+'/Annotations/{:s}.xml'
imagesetfile = '/media/anlabadmin/data_ubuntu/yolox/Result_detection/model_x_10epochs_1800frames/'+camera+'/listFilename_'+basename+'.txt'
classname = 'Human'
cachedir = '/media/anlabadmin/data_ubuntu/yolox/Result_detection/model_x_10epochs_1800frames/'+camera+'/tmp'
# ovthresh = 0.1
result_file = '/media/anlabadmin/data_ubuntu/yolox/Result_detection/model_x_10epochs_1800frames/'+f'{camera}/result_map_{basename}.txt'
average = 0
with open(detpath,'r') as f:
num_box_predict = len(f.readlines())
with open(result_file,"a") as f:
for ovthresh in [0.5]:
# Run evaluation
rec, prec, ap, tp, fp,TP,FP,FN,sum_GT,fp_list_images = voc_eval(
detpath,
annopath,
imagesetfile,
classname,
cachedir,
ovthresh
)
out_statemant = f"AP for ovthresh:{ovthresh} = {ap*100:.4f}"
# average = average+ap*100
f.write(out_statemant+"\n")
print(out_statemant)
print(f"TP : {TP},FP : {FP}, FN : {FN}")
# num boxes
print(f"Number of PREDICT boxes : {num_box_predict}")
print(f"Number of GT boxes : {sum_GT}")
print(f"TP : {TP},FP : {FP}, FN : {FN},Number of PREDICT boxes : {num_box_predict},Number of GT boxes : {sum_GT}")
print(f"TP_rate : {TP/num_box_predict},FP_rate : {FP/num_box_predict}, FN_rate : {FN/sum_GT}")
# write tp,fp,fn
f.write(f"TP : {TP},FP : {FP}, FN : {FN},Number of PREDICT boxes : {num_box_predict},Number of GT boxes : {sum_GT}\n")
f.write(f"TP_rate : {TP/num_box_predict},FP_rate : {FP/num_box_predict}, FN_rate : {FN/sum_GT}")
# f.write(f"Average AP: {average/9}")
print(f"=====================Done {camera}==========================")
# move fp images
# move_fp_images(fp_list_images,base_name=basename,image_draw_fodel=image_draw_folder)
| ttrung2h/ByteTrack | Eval/calMAP.py | calMAP.py | py | 9,558 | python | en | code | 0 | github-code | 13 |
14381331936 | import market
def main():
# example: book trade
id = market.book_trade('symbol', market.CURRENT_PRICE, 100)
# example-end
# example: cancel trade
market.cancel_trade('id')
# example-end
if __name__ == "__main__":
main() | byc1234/znai | znai-docs/znai/snippets/python-examples.py | python-examples.py | py | 251 | python | en | code | null | github-code | 13 |
70427128977 | import unittest
from solutions.day_19 import Solution
class Day19TestCase(unittest.TestCase):
def setUp(self):
self.solution = Solution()
def test_seen(self):
puzzle_input = ''' |
| +--+
A | C
F---|----E|--+
| | | D
+B-+ +--+
'''
assert self.solution.solve(puzzle_input) == 'ABCDEF'
def test_steps(self):
puzzle_input = ''' |
| +--+
A | C
F---|----E|--+
| | | D
+B-+ +--+
'''
assert self.solution.solve_again(puzzle_input) == 38
if __name__ == '__main__':
unittest.main()
| madr/julkalendern | 2017-python/tests/day_19_tests.py | day_19_tests.py | py | 768 | python | en | code | 3 | github-code | 13 |
22740065780 | import sqlite3
from anki import __version__, Card, Deck, Grade, User, AnkiDB
from pytest import fixture
EXPECTED_TABLES = {"users", "decks", "cards"}
@fixture
def front():
return "Hello"
@fixture
def back():
return "World"
@fixture
def card(front, back):
return Card(
front=front,
back=back
)
@fixture
def deck(card):
cards = [
card,
Card(front="", back=""),
Card(front="", back=""),
Card(front="", back=""),
]
return Deck(name="My Study Deck", cards=cards)
@fixture
def user():
return User(name="John")
@fixture
def ankidb() -> AnkiDB:
ankidb = AnkiDB(dbname="test_db.sqlite")
ankidb.setup_new_db()
yield ankidb
def test_version():
assert __version__ == '0.1.0'
def test_create_card(front, card):
assert isinstance(card, Card)
assert card.front is front
def test_review_card(card):
assert card.times_reviewed == 0
assert card.review_score == 0
card.review(grade=Grade.FAIL)
assert card.times_reviewed == 1
assert card.review_score == -2
card.review(grade=Grade.EASY)
card.review(grade=Grade.EASY)
card.review(grade=Grade.MEDIUM)
card.review(grade=Grade.EASY)
assert card.review_score == 1
card.review(grade=Grade.HARD)
assert card.review_score == 0
def test_create_deck(deck):
assert isinstance(deck, Deck)
def test_create_user(user):
assert user.id == 0
assert user.name == 'John'
assert User(name="Jane").id == 1
assert User(name="John").id == 2
def test_connect_to_db(ankidb):
"""Test that we can connect to the database"""
ankidb.connect().cursor()
def test_tables_are_there(ankidb):
"""Test that tables are created"""
con = ankidb.connect()
expected_tables = EXPECTED_TABLES
res = con.cursor().execute("SELECT name FROM sqlite_master WHERE type='table'")
tables = [i[0] for i in res]
assert set(tables) == expected_tables
def test_create_user_in_db(ankidb):
user = ankidb.create_user(name="John")
assert isinstance(user, User)
con = ankidb.connect()
con.row_factory = sqlite3.Row
res = con.cursor().execute(f"SELECT * FROM users WHERE id={user.id}").fetchone()
assert res['name'] == 'John'
def test_create_user_autoincrements_id(ankidb):
user1 = ankidb.create_user(name="John1")
user2 = ankidb.create_user(name="John2")
assert user1.id == user2.id - 1
def test_create_deck_and_assign_to_user(ankidb):
user = ankidb.create_user(name="John")
deck = ankidb.create_deck(name="My Study Deck", user_id=user.id)
assert isinstance(deck, Deck)
con = ankidb.connect()
con.row_factory = sqlite3.Row
res = con.cursor().execute(f"SELECT * FROM decks WHERE id={deck.id}").fetchone()
assert res['name'] == 'My Study Deck'
def test_create_card(ankidb):
user = ankidb.create_user(name="John")
deck = ankidb.create_deck(name="My Study Deck", user_id=user.id)
card = ankidb.create_card(front="Hello", back="World", deck_id=deck.id)
assert isinstance(card, Card)
con = ankidb.connect()
con.row_factory = sqlite3.Row
res = con.cursor().execute(f"SELECT * FROM cards WHERE id={card.id}").fetchone()
assert res['front'] == 'Hello'
assert res['back'] == 'World'
assert res['review_score'] == 0
def test_initiate_app():
"""Initiates the app and prompts the user"""
...
| Brunods1001/anki | tests/test_anki.py | test_anki.py | py | 3,399 | python | en | code | 0 | github-code | 13 |
32556749919 | from bs4 import BeautifulSoup
import requests
import pandas as pd
# 3 steps to get the data ETL(1.Extract 2.Trasform 3.Load)
# ___________ 1. Extract _____________
def extract(page):
headers = {'User-agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.114 Safari/537.36'}
url = f'https://www.linkedin.com//business/learning/blog?page0={page}#postlist0FocusPoint'
r = requests.get(url, headers)
soup = BeautifulSoup(r.content, 'html.parser')
return soup
# ___________ 2. Transform ____________
def transform(soup):
divs = soup.find_all('li', class_= 'post-list__item grid-post')
for item in divs:
title = item.find('a', class_= 'grid-post__link t-20 t-black').text.strip().replace('\n','')
# Here we are using try and except bcoz in few blog have none characters.
try:
category = item.find('a', class_='t-14 t-bold').text.strip().replace('\n','')
except:
category = ''
try:
author = item.find('p', class_= 'grid-post__author t-14 t-bold t-black').text.strip().replace('\n','')
except:
author = ''
pub_date = item.find('p', class_= 'grid-post__date t-14 t-black--light').text.strip().replace('\n','')
try:
desc = item.find('p', class_ = 'grid-post__description t-14').text.strip().replace('\n','')
except:
desc = ''
blog_data = {
"Title": title,
"Description": desc,
"Category": category,
"Author": author,
"Publish_Date": pub_date
}
linkedin_blog.append(blog_data)
# ____________purpose to check execution ___________
# print(f"{category} | {title} | {author} | {pub_date} | {description} ")
return
# Loop through fuction
linkedin_blog = []
for i in range(1,98):
print(f'Extracting the page {i}')
c = extract(i)
transform(c)
# ____________ 3. Load _____________
df = pd.DataFrame(linkedin_blog)
df.to_csv('Linkedin_blog_data.csv',index=False)
| Aspersh-Upadhyay/Scrape-Linkedin-Blog | Scrape-Linkedin-Blog.py | Scrape-Linkedin-Blog.py | py | 2,163 | python | en | code | 0 | github-code | 13 |
19992367964 | import os, sys
from pygame import *
def menu():
print ("+-----------------------MENU----------------------+")
print ("| 1 | 2 | 3 | 4 | 5 |")
print ("+-------------------------------------------------+")
print ("| Pause | Unpause | Play | Stop | Load |")
print ("+-------------------------------------------------+")
x = input("Enter Choice: ")
return x.strip()
def list_songs(songs):
for i, song in enumerate(songs):
print(i+1, ". ", song)
return int(input("Enter the song index which you want to play..."))
def action(songs,x):
if x == '1':
mixer.music.pause()
if x == '2':
mixer.music.unpause()
if x == '3':
mixer.music.play(-1)
if x == '4':
mixer.music.stop()
if x == '5':
mixer.music.load(songs[list_songs(songs)-1])
mixer.music.play(-1)
def play_music(songs,choice):
mixer.init()
mixer.music.load(songs[choice])
mixer.music.play(-1)
while mixer.music.get_busy():
x = menu()
action(songs,x)
print('Playing')
def check_baseDir():
songs=[]
if len(sys.argv)>1:
baseDir = sys.argv[1]
else:
baseDir = None
if baseDir:
for items in os.listdir(os.chdir(baseDir)):
if items.endswith('.mp3'):
songs.append(items)
else:
for items in os.listdir(os.getcwd()):
if items.endswith('.mp3'):
songs.append(items)
songs.sort()
return songs
def main():
songs=check_baseDir()
#Get the list of songs from the current directory
print('Welcome to the Terminal Music Player...\n')
print('Below are the list of songs in directory')
#If there are any songs in the directory
if len(songs)>=1:
try:
choice=list_songs(songs)
assert choice>=1
except AssertionError:
print('Please select at least one song')
else:
play_music(songs,choice-1)
else:
print('Sorry! There are no mp3s detected in your directory')
print('Try stating another directory when you call this application')
if __name__ == '__main__':
main() | linonepow/terminal-mp3player | src.py | src.py | py | 2,235 | python | en | code | 0 | github-code | 13 |
21507445909 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
from dip.boardgames.saboteur.Card import Card
from dip.boardgames.saboteur.CardDetector import CardDetector
from dip.boardgames.saboteur.PathPlanner import run_astar
from dip.boardgames.saboteur.Grid import Grid
from dip.boardgames.saboteur.Camera import Camera
from dip.boardgames.saboteur.ImageProcessor import ImageProcessor
from dip.boardgames.saboteur.GUI import GUI
import numpy as np
import cv2
import time
import random
class Game:
def __init__(self, loop_rate=5 ) -> None:
# self.n_players = n_players
# self.n_rounds = n_rounds
self.camera = Camera()
self.imageProcessor = ImageProcessor()
self.gui = GUI()
self.detector = CardDetector()
self.grid = Grid(dim={'rows': 5, 'cols': 9}, cell={
'cell_width': 40, 'cell_height': 65})
self.best_move = None
self.best_idx = None
self.frame_cv2 = None
self.suggested_cells = []
self.start_pos_pix = None
self.loop_rate = loop_rate
def validate_move(self, map_binary:np.ndarray, player_card_img:np.ndarray, coord:tuple) -> bool:
'''
Validate the supposed move. This checks if the player's card connects to the start card. If not, False is returned.
'''
# insert player_card_img into the grid at the given coordinates
r, c = coord
map_binaryC = map_binary.copy()
start_x = c * self.grid.cell_width
start_y = r * self.grid.cell_height
map_binaryC[start_y:start_y+self.grid.cell_height, start_x:start_x+self.grid.cell_width] = player_card_img
# cv2.imshow("Before map with playercard", map_binaryC)
map_binaryC = self.imageProcessor.dilate(map_binaryC, 3)
map_binaryC = self.imageProcessor.erode(map_binaryC, 3)
goal_pos_pix = self.grid.getGoal(image=map_binaryC, coord = coord)
path_found = run_astar(None, map_binaryC, self.start_pos_pix, goal_pos_pix )
if not path_found:
print("Card does not connect to start card")
if path_found is not None:
return path_found
else:
return False
def suggest_move(self, map_binary: np.ndarray, playable_cells: list[tuple], player_cards: list[Card]) -> tuple[list[Card], list[tuple]]:
"""
Suggest a move for the player.
Input:
map_binary: the map image
playable_cells: list of cells (center coordinates) where a player can play a suggested card
player_cards: list of cards that the player has
Output:
a list of cards that the player can play, empty list if no move can be made
"""
imageC = cv2.cvtColor(map_binary, cv2.COLOR_GRAY2BGR)
suggested_cards : list[tuple[Card, int, bool]]= []
# loc = []
is_card_suitable = False
offset = 3 # remove some pixels from the edges of the player card
# Loop through the board cards
self.suggested_cells = []
temp = []
for empty_cell_idx, empty_cell in enumerate(playable_cells):
x = empty_cell[1] * self.grid.cell_width
y = empty_cell[0] * self.grid.cell_height
imageC[y:y+self.grid.cell_height, x:x+self.grid.cell_width] = (0, 0, 255)
# loop through the player cards and find all suitable cards
for idx, player_card in enumerate(player_cards):
# quick image processing for the player card
player_card_img = player_card.get_image()
player_card_img = player_card_img[offset:-offset, offset:-offset]
player_card_img = cv2.resize(player_card_img, (self.grid.cell_width, self.grid.cell_height))
player_card_img = self.imageProcessor.fixBrightness(player_card_img)
player_card_img, _ = self.imageProcessor.processMap(player_card_img)
# find the neighbors of the empty cell
empty_cell_neighbors, empty_cell_neighbor_coords = self.grid.get_neighbors(empty_cell[0], empty_cell[1])
# extract empty cell neighbor images
cell_neighbor_images = {}
for side, neighbor in empty_cell_neighbors.items():
coord = empty_cell_neighbor_coords[side]
# filter out out of bounds cells.
if coord[0] < 0 or coord[1] < 0 or coord[0] >= self.grid.rows or coord[1] >= self.grid.cols:
continue
if neighbor is not None:
cell_neighbor_images[side] = self.grid.extract_cell(
map_binary, self.grid.cell_centers[coord[0]][coord[1]])
x = coord[1] * self.grid.cell_width
y = coord[0] * self.grid.cell_height
imageC[y:y+self.grid.cell_height , x:x+self.grid.cell_width] = (0, 255, 0)
is_card_suitable, is_rotate = self.detector.is_cardFit(cell_neighbor_images, player_card_img)
if not is_card_suitable:
# cv2.imshow("notsuitable", player_card_img)
# print("notsuitable @", empty_cell_idx)
# cv2.waitKey(0)
continue
else:
# Validate the card using Astar
isValid = self.validate_move(map_binary=map_binary, player_card_img=player_card_img, coord=empty_cell)
if isValid:
# append the player card to the suggested cards
card_info : tuple[Card, int, bool] = (player_card, empty_cell_idx, is_rotate)
suggested_cards.append(card_info)
# temp.append([idx, empty_cell_idx])
# append the coordinates of the empty cell to the suggested cells
if empty_cell not in self.suggested_cells:
self.suggested_cells.append(empty_cell)
return suggested_cards , self.suggested_cells
def findBestMove(self, suggested_cells: list[tuple], goal_coord: tuple) -> tuple:
"""
Get the best move for the player by computing the Manhattan distance between the suggested cards and goal card
Input:
suggested_cards: list of cards that the player can play
Output:
a card that the player can play
"""
dists = self.grid.computeDistances(goal_coord)
# print(f"dists {len(dists)}")
shortest_dist = np.inf
best_move = None
# best_idx = None
for idx, cell in enumerate(suggested_cells):
# print(cell)
dist = dists[cell[0]][cell[1]]
if dist < shortest_dist:
shortest_dist = dist
best_move = cell
# best_idx = idx
# print(f"Best move: {best_move}, dist: {shortest_dist}")
# print(f"Best idx: {best_idx}")
self.best_move = best_move
def get_playable_cells(self, grid_arr: list[list[Card]], grid_img: np.ndarray) -> list[tuple]:
"""
Get the playable cells for the player.
Input:
grid_arr: list of lists of cards
grid_img: numpy array of the grid image
Output:
a list of cells (center coordinates) where a player can play a suggested card
"""
playable_cells = []
# loop through the cells
for row in range(self.grid.rows):
for col in range(self.grid.cols):
# check if the cell is empty
if grid_arr[row][col] is not None:
# skip 'goal' cards from grid array
if grid_arr[row][col].type == 'goal':
continue
# print(f"row: {row}, col: {col}")
neighbors = self.grid.get_neighbors(row, col)
# Get the neighbors
neighbors, neighbors_idx = self.grid.get_neighbors(
row, col)
for side, neighbor in neighbors.items():
is_empty = False
coord = neighbors_idx[side]
# filter out out-of-bounds cells. Because, the grid is created with padded cells
if coord[0] < 0 or coord[1] < 0 or coord[0] >= self.grid.rows or coord[1] >= self.grid.cols:
continue
if neighbor is not None:
neighbor_card_img = self.grid.extract_cell(
grid_img, self.grid.cell_centers[coord[0]][coord[1]])
is_empty = np.mean(neighbor_card_img) == 0
# cv2.imshow(side, neighbor_card_img)
# if cv2.waitKey(100) == 27:
# break
else:
is_empty = True
# print(f"row: {row}, col: {col}, side: {side}, coord: {coord}, is_empty: {is_empty}")
if is_empty and (coord not in playable_cells):
playable_cells.append(coord)
# sort it
playable_cells.sort(key=lambda cell: (cell[0], cell[1]))
return playable_cells
def visualize_moves(self, image, playable_cells: list[tuple], suggested_cards : list[tuple[Card, int, bool]], mode="board"):
"""
Visualize the moves that can be made using a number of colors and labels.
Input:
playable_cells: list of cells (center coordinates) where a player can play a suggested card
suggested_cards: list of cards that the player can play from player deck
Output:
None
"""
# highlight the playable cells
cell_width = self.grid.cell_width
cell_height = self.grid.cell_height
imageC = image.copy()
if mode == "board":
# Add playable cells to the resized output
for c_idx, cell in enumerate(playable_cells):
x = cell[1] * cell_width
y = cell[0] * cell_height
# imageC[y:y+cell_height, x:x+cell_width] = (0, 255, 0) # Mark the cell with green color (RGB)
cv2.rectangle(imageC, (x, y), (x + int(cell_width), y + int(cell_height)), (0, 255, 0), 2) # Green bounding box with thickness 2
# cv2.line(imageC, (x, y), (x + cell_width -30, y + cell_height-30), (0, 255, 0), 2)
# cv2.line(imageC, (x + cell_width-30, y),(x, y + cell_height-30), (0, 255, 0), 2)
# Write index at the center of the cell
text = str(c_idx)
text_size, _ = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 1, 2)
text_x = x + (cell_width - text_size[0]) // 2
text_y = y + (cell_height + text_size[1]) // 2
# if c_idx == 12:
# print("look here.................................\n\n\n")
if self.best_move == (cell[0], cell[1]):
# cv2.putText(imageC, "BM", (text_x, text_y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2, cv2.LINE_AA)
cv2.rectangle(imageC, (x, y), (x + int(cell_width), y + int(cell_height)), (255, 0, 0), 2)
self.best_idx = c_idx
# else:
cv2.putText(imageC, text, (text_x, text_y), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2, cv2.LINE_AA)
cv2.imshow('game_MOVES', imageC)
self.grid
if mode == "player":
# # show the card label
temp_dict = {}
temp_rotate_dict = {}
for card_info in suggested_cards:
card = card_info[0]
cell_no = card_info[1]
is_rotate = card_info[2]
center_x = card.get_cx()
center_y = card.get_cy()
card_img = card.get_image()
if (center_x, center_y) in temp_dict:
# Append the cell_no to the existing list
temp_dict[(center_x, center_y)].append(cell_no)
selected_choice = random.sample(list(temp_dict[(center_x, center_y)]), min(len(temp_dict[(center_x, center_y)]), 3))
temp_dict[(center_x, center_y)] = selected_choice
temp_rotate_dict[(center_x, center_y)] = is_rotate
else:
# Create a new list with the cell_no
temp_dict[(center_x, center_y)] = [cell_no]
temp_rotate_dict[(center_x, center_y)] = is_rotate
# Draw bounding boxes and write numbers inside the boxes for dictionary centers
for center, numbers in temp_dict.items():
x = center[0]
y = center[1]
c_start_x = x - card_img.shape[1] // 2
c_start_y = y - card_img.shape[0] // 2
cv2.rectangle(imageC, (c_start_x, c_start_y), (c_start_x +card_img.shape[1], c_start_y + card_img.shape[0]), (0, 255, 0), thickness=2)
if temp_rotate_dict[(x, y)]:
cv2.putText(imageC, " R", (c_start_x-5, c_start_y+15), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2, cv2.LINE_AA)
if self.best_idx is not None :
if self.best_idx in numbers:
cv2.rectangle(imageC, (c_start_x, c_start_y), (c_start_x +card_img.shape[1], c_start_y + card_img.shape[0]), (255, 0, 0), thickness=2)
# cv2.putText(imageC, "Best Move", (c_start_x, c_start_y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2, cv2.LINE_AA)
# Write the numbers in the current cell with the desired spacing
for number in numbers:
cv2.putText(imageC, str(number), (x-10, y-20), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
y += 30 # Increase the y-coordinate for the next number within the cell
imageC = cv2.resize(imageC, (imageC.shape[1] * 2, imageC.shape[0] * 2))
cv2.imshow('player_MOVES', imageC)
def check_gameStatus(self, grid_arr:list[list[Card]], grid_img, map ) -> bool:
# TODO: Checks the current status of the game. if the game is over, return a string. Currently not working
"""If there is a connected path to the goal return True, else return False"""
# astar = run_astar(self.frame_cv2, map, start_pos, goal_pos)
for row in range(self.grid.rows):
for col in range(self.grid.cols):
# check if the cell is not empty
if grid_arr[row][col] is not None:
# Find card with gold
if grid_arr[row][col].type == 'goal':
card = grid_arr[row][col]
card_img = card.get_image()
isGold = self.imageProcessor.findGoldCard(card_img)
print("Gold: ", isGold)
return False
def start(self, cam_device_id=0):
"""
Starts the game
Input:
cam_device_id: The id of the camera. To be used by cv2.VideoCapture.
"""
global lock
global map_binary, board_area, start_pos
gui = GUI()
# Camera
cap = cv2.VideoCapture(cam_device_id)
if not cap.isOpened():
raise Exception("Camera not opened")
else:
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
cap.set(cv2.CAP_PROP_FPS, 30)
cap.set(cv2.CAP_PROP_AUTO_EXPOSURE, 0) # turn off auto exposure
cap.set(cv2.CAP_PROP_AUTO_WB, 0) # turn off white balance
cap.set(cv2.CAP_PROP_EXPOSURE, 0.5) # set exposure
cap.set(cv2.CAP_PROP_AUTOFOCUS, 0) # turn off auto focus
print("Camera is running")
_, image = cap.read()
# Assuming this is the image
# Get game regions
print("Getting board area...")
player_rect = (80, 380, 300, 280)
board_rect = (440, 50, 750, 650) # x, y, w, h
# extract region from image
board_area = image[board_rect[1]:board_rect[1] +
board_rect[3], board_rect[0]:board_rect[0]+board_rect[2]]
player_area = image[player_rect[1]:player_rect[1] +
player_rect[3], player_rect[0]:player_rect[0]+player_rect[2]]
cv2.imshow('player',player_area)
cv2.imshow('board', board_area)
cv2.waitKey(0)
# Scale to resize the frames
resize_scale = 1
board_area = cv2.resize(
board_area, (board_area.shape[1]//resize_scale, board_area.shape[0]//resize_scale))
player_area = cv2.resize(
player_area, (player_area.shape[1]//resize_scale, player_area.shape[0]//resize_scale))
grid_img = np.zeros((self.grid.cell_width*self.grid.rows,
self.grid.cell_height*self.grid.cols, 3), dtype=np.uint8)
start_time = time.time()
start_time_FPS = time.time()
frame_count = 0
isGameStart = False
showDebug = True
gui_text = {"FPS": 0, "Player Cards": 0,
"Board Cards": 0, "Playable Cells": 0}
playable_cells = []
print("Entering game loop")
lock = False
start_pos = None
goal_pos = None
self.start_pos_pix = None
goal_pos_pix = None
map_binary = None
while True:
gui.set_game_area(self.detector.detected_board_img)
gui.set_player_area(player_area)
gui.draw(gui_text=gui_text)
# get the frame
ret, frame = cap.read()
board_area = frame[board_rect[1]:board_rect[1] +
board_rect[3], board_rect[0]:board_rect[0]+board_rect[2]]
player_area = frame[player_rect[1]:player_rect[1] +
player_rect[3], player_rect[0]:player_rect[0]+player_rect[2]]
# resize the frames
board_area = cv2.resize(
board_area, (board_area.shape[1]//resize_scale, board_area.shape[0]//resize_scale))
player_area = cv2.resize(
player_area, (player_area.shape[1]//resize_scale, player_area.shape[0]//resize_scale))
# detect the cards
board_cards = self.detector.get_boardCards(board_area, resize_scale)
player_cards = self.detector.get_playerCards(player_area, resize_scale)
# generate grid array
grid_arr = self.grid.getArray(board_area, board_cards)
# update frame
self.frame_cv2 = board_area
if not isGameStart:
print("Starting game")
start_card = self.detector.get_startCard()
start_pos = self.grid.getCardCoord(start_card)
print(f"start_card: {start_pos}")
# get goal cards positions
goal_card = self.detector.get_goalCards()[0]
goal_pos = self.grid.getCardCoord(goal_card)
print(f"Selected goal_card: {goal_pos}")
isGameStart = True
# Now We will be ready to suggest moves
if isGameStart:
if time.time() - start_time > self.loop_rate:
start_time = time.time()
grid_img = self.grid.drawCards(grid_arr)
cv2.imshow('Grid', grid_img)
# suggest moves to reach the goal card
playable_cells = self.get_playable_cells(
grid_arr=grid_arr, grid_img=grid_img)
# get map for path planning
map_binary, map_rgb = self.imageProcessor.processMap(
grid_img, thresh_val=50)
cv2.imshow('Map', map_rgb)
# Get the start coordinates in pixel location. Will be used for path planning
if not lock:
self.start_pos_pix = self.grid.getGoal(image=map_binary, coord=start_pos)
lock = True
# get the moves
selected_cards, suggested_cells = self.suggest_move(
map_binary, playable_cells, player_cards)
# find the best move
self.findBestMove(suggested_cells, goal_pos)
# visualize the moves
self.visualize_moves(grid_img, playable_cells, selected_cards, mode='board')
self.visualize_moves(player_area, playable_cells, selected_cards, mode='player')
# Path planner verification. This is for every card generally placed on the board while game is in session
coords = self.grid.getGridCoords()
for cell in coords:
if cell == start_pos:
continue
goal_pos_pix = self.grid.getGoal(image=map_binary, coord = cell)
run_astar(grid_img, map_binary, self.start_pos_pix, goal_pos_pix)
# self.check_gameStatus(grid_arr=grid_arr, grid_img=grid_img, map=map_binary)
# Show FPS
frame_count += 1
end_time_FPS = time.time()
total_time = end_time_FPS - start_time_FPS
fps = frame_count / total_time
# Update GUI
gui_text["FPS"] = fps
gui_text["Player Cards"] = len(player_cards)
gui_text["Board Cards"] = len(board_cards)
gui_text["Playable Cells"] = len(playable_cells)
if showDebug:
self.detector.visualize(mode='board', selected_goal=goal_pos)
self.detector.visualize(mode='player')
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cv2.destroyAllWindows()
cap.release() | new2me321/saboteur-card-game | dip/boardgames/saboteur/Game.py | Game.py | py | 22,216 | python | en | code | 1 | github-code | 13 |
42746790135 | import numpy as np
from poptransformer import ops
from poptransformer.layers import BaseLayer
from poptransformer.layers import Linear
from poptransformer.utils.param_handler.tensor_parallel_strategy import shard
class BaseRWKVAttention(BaseLayer):
def __init__(self, context, name, hidden_size, attention_hidden_size, layer_id):
super().__init__(context, name)
self.hidden_size = hidden_size
self.attention_hidden_size = attention_hidden_size
self.layer_id = layer_id
self.collect_bind_layer_weights()
def collect_bind_layer_weights(self):
self.key_linear = Linear(
self.context, 'key', self.hidden_size, self.attention_hidden_size, use_bias=False)
self.receptance_linear = Linear(
self.context, 'receptance', self.hidden_size, self.attention_hidden_size, use_bias=False)
self.value_linear = Linear(
self.context, 'value', self.hidden_size, self.attention_hidden_size, use_bias=False)
self.output_linear = Linear(
self.context, 'output', self.attention_hidden_size, self.hidden_size, use_bias=False)
time_decay_key = '.'.join([self.context, 'time_decay'])
time_decay_np = self.get_param_from_state_dict(time_decay_key, [self.hidden_size])
self.time_decay = self.add_initialized_input_tensor(time_decay_np, time_decay_key)
time_first_key = '.'.join([self.context, 'time_first'])
time_first_np = self.get_param_from_state_dict(time_first_key, [self.hidden_size])
self.time_first = self.add_initialized_input_tensor(time_first_np, time_first_key)
time_mix_key_name = '.'.join([self.context, 'time_mix_key'])
time_mix_key_np = self.get_param_from_state_dict(time_mix_key_name, [1, 1, self.hidden_size])
self.time_mix_key = self.add_initialized_input_tensor(time_mix_key_np, time_mix_key_name)
time_mix_value_name = '.'.join([self.context, 'time_mix_value'])
time_mix_value_np = self.get_param_from_state_dict(time_mix_value_name, [1, 1, self.hidden_size])
self.time_mix_value = self.add_initialized_input_tensor(time_mix_value_np, time_mix_value_name)
time_mix_receptance_name = '.'.join([self.context, 'time_mix_receptance'])
time_mix_receptance_np = self.get_param_from_state_dict(time_mix_receptance_name, [1, 1, self.hidden_size])
self.time_mix_receptance = self.add_initialized_input_tensor(time_mix_receptance_np, time_mix_receptance_name)
def gate(self, graph, a, w, b):
y1 = ops.mul(graph, a, w)
y2 = ops.sub(graph, ops.constant(graph, np.array(1).astype(self.np_float_type)), w)
y2 = ops.mul(graph, y2, b)
y = ops.add(graph, y1, y2)
return y
def __call__(self, graph, hidden, layer_state):
with graph.nameScope('extract_key_value'):
num_state, den_state, max_state = layer_state[2:]
key = self.gate(graph, hidden, self.time_mix_key, layer_state[1])
value = self.gate(graph, hidden, self.time_mix_value, layer_state[1])
receptance = self.gate(graph, hidden, self.time_mix_receptance, layer_state[1])
layer_state[1] = hidden
key = self.key_linear(graph, key)
value = self.value_linear(graph, value)
receptance = self.receptance_linear(graph, receptance)
receptance = ops.sigmoid(graph, receptance)
if self.precision == 'fp16':
time_decay = ops.cast(graph, self.time_decay, 'FLOAT')
key = ops.cast(graph, key, 'FLOAT')
value = ops.cast(graph, value, 'FLOAT')
time_first = ops.cast(graph, self.time_first, 'FLOAT')
with graph.nameScope('rwkv_linear_attention'):
temp1 = ops.add(graph, key, time_first)
max_for_output = ops.maximum(graph, max_state, temp1)
e1 = ops.exp(graph, ops.sub(graph, max_state, max_for_output))
e2 = ops.exp(graph, ops.sub(graph, temp1, max_for_output))
numerator = ops.add(graph, ops.mul(graph, e1, num_state), ops.mul(graph, e2, value))
denominator = ops.add(graph, ops.mul(graph, e1, den_state), e2)
output = ops.div(graph, numerator, denominator)
time_decay = ops.exp(graph, time_decay)
temp2 = ops.sub(graph, max_state, time_decay)
max_for_state = ops.maximum(graph, temp2, key)
e1 = ops.exp(graph, ops.sub(graph, temp2, max_for_state))
e2 = ops.exp(graph, ops.sub(graph, key, max_for_state))
layer_state[2] = ops.add(graph, ops.mul(graph, e1, num_state), ops.mul(graph, e2, value))
layer_state[3] = ops.add(graph, ops.mul(graph, e1, den_state), e2)
layer_state[4] = max_for_state
if self.precision == 'fp16':
output = ops.cast(graph, output, self.popart_float_type)
output = ops.mul(graph, receptance, output)
output = self.output_linear(graph, output)
return output, layer_state
class TPRWKVAttention(BaseRWKVAttention):
def collect_bind_layer_weights(self):
key_tp_setting = {
'strategy_name': 'start',
}
output_tp_setting = {
'strategy_name': 'end',
}
self.key_linear = Linear(
self.context, 'key', self.hidden_size, self.attention_hidden_size, use_bias=False, **key_tp_setting)
self.receptance_linear = Linear(
self.context, 'receptance', self.hidden_size, self.attention_hidden_size, use_bias=False, **key_tp_setting)
self.value_linear = Linear(
self.context, 'value', self.hidden_size, self.attention_hidden_size, use_bias=False, **key_tp_setting)
self.output_linear = Linear(
self.context, 'output', self.attention_hidden_size, self.hidden_size, use_bias=False, **output_tp_setting)
vs_setting = {'vs_type': 'consecutive', 'group_size': 1}
time_decay_key = '.'.join([self.context, 'time_decay'])
time_decay_np = self.get_param_from_state_dict(time_decay_key, [self.hidden_size])
time_decay_np = shard(time_decay_np, self.num_replicas, -1)
self.time_decay = self.add_initialized_input_tensor(time_decay_np, time_decay_key, **vs_setting)
time_first_key = '.'.join([self.context, 'time_first'])
time_first_np = self.get_param_from_state_dict(time_first_key, [self.hidden_size])
time_first_np = shard(time_first_np, self.num_replicas, -1)
self.time_first = self.add_initialized_input_tensor(time_first_np, time_first_key, **vs_setting)
time_mix_key_name = '.'.join([self.context, 'time_mix_key'])
time_mix_key_np = self.get_param_from_state_dict(time_mix_key_name, [1, 1, self.hidden_size])
self.time_mix_key = self.add_initialized_input_tensor(time_mix_key_np, time_mix_key_name)
time_mix_value_name = '.'.join([self.context, 'time_mix_value'])
time_mix_value_np = self.get_param_from_state_dict(time_mix_value_name, [1, 1, self.hidden_size])
self.time_mix_value = self.add_initialized_input_tensor(time_mix_value_np, time_mix_value_name)
time_mix_receptance_name = '.'.join([self.context, 'time_mix_receptance'])
time_mix_receptance_np = self.get_param_from_state_dict(time_mix_receptance_name, [1, 1, self.hidden_size])
self.time_mix_receptance = self.add_initialized_input_tensor(time_mix_receptance_np, time_mix_receptance_name)
class RWKVAttention(TPRWKVAttention, BaseRWKVAttention):
layer_class_map = {
'tp': TPRWKVAttention,
'shard': BaseRWKVAttention}
def __init__(self, context, name, hidden_size, attention_hidden_size, layer_id):
model_type = self.model_type
self.layer_class = self.layer_class_map.get(model_type, None)
if not self.layer_class:
raise ValueError(f"Invalid model_type {model_type}, options: {self.layer_class_map.keys()}")
self.logger.debug(f'initializing model type: {self.layer_class.__name__}')
super().__init__(context, name, hidden_size, attention_hidden_size, layer_id)
def __call__(self, graph, hidden, layer_state):
return self.layer_class.__call__(self, graph, hidden, layer_state)
def collect_bind_layer_weights(self):
return self.layer_class.collect_bind_layer_weights(self)
| graphcore/PopTransformer | poptransformer/models/rwkv/attention.py | attention.py | py | 8,361 | python | en | code | 6 | github-code | 13 |
21477799309 | def main():
bass = 'Y'
print ('Choose number :')
print ('1) read ')
print ('2) write ')
choice = int(input(' : '))
while bass == 'Y' or bass == 'y' :
if choice == 1:
num_one()
elif choice == 2:
num_two()
else:
print('Only 1 or 2 ')
bass = input('Do this again?:(press Y or N)')
if bass == 'Y' or bass == 'y' :
print ('Choose number :')
print ('1) read ')
print ('2) write ')
choice = int(input('; '))
def num_one():
infile = open('15sep63/ine2friends.txt','r')
file_contents = infile.read()
infile.close()
print(file_contents)
def num_two():
infile = open('15sep63/ine2friends.txt','a')
name = input('Enter your name :')
infile.write(name + '\n')
infile.close()
main() | patsakon93/project1 | 15sep63/test1.py | test1.py | py | 855 | python | en | code | 0 | github-code | 13 |
9070101877 | import re
def read_file_content(file_path):
try:
with open(file_path, "r") as file:
return "".join(file.readlines()).split("\n")
except FileNotFoundError:
print("File or file path does not exist!")
def count_characters(list_name):
count = []
[count.append(len("".join(line))) for line in list_name]
return count
file_lines = read_file_content("text.txt")
file_words = [re.findall(r"[a-zA-Z]+", file_line) for file_line in file_lines]
count_letters = count_characters(file_words)
file_punctoation_marks = [re.findall(r"[!?.,'\"-]", file_line) for file_line in file_lines]
count_punctoations = count_characters(file_punctoation_marks)
result_lines = []
for index in range(len(file_lines)):
result_lines.append(f"Line: {index + 1} {file_lines[index]} ({count_letters[index]})({count_punctoations[index]})")
with open("output.txt", "w") as output_file:
output_file.writelines("\n".join(result_lines))
| vbukovska/SoftUni | Python_advanced/Ex6_file_handling/line_numbers.py | line_numbers.py | py | 964 | python | en | code | 0 | github-code | 13 |
6868952689 | from pymongo import MongoClient
client = MongoClient('localhost', 27017)
db = client.dbsparta
# insert / find / update / delete
# insert 예시 -----------------------------------------------------
doc = {'name':'jane','age':21}
db.users.insert_one(doc)
# find 예시 -------------------------------------------------------
same_ages = list(db.users.find({'age':21},{'_id':False})) # {'_id':False} : _id 값은 제외하고 출력
for person in same_ages:
print(person['name'], person['age'])
all = list(db.users.find({},{'_id':False})) # 모든 document를 find 해!
print(all)
user = db.users.find_one({'name':'bobby'},{'_id':False}) # find_one : 하나만 가져올 때
print('user: ', user)
# update 예시 -----------------------------------------------------
db.users.update_one({'name':'bobby'},{'$set':{'age':19}}) # 조건에 일치하는 가장 상단의 1명의 age만 변경
db.users.update_many({'name':'bobby'},{'$set':{'age':33}}) # bobby라는 이름을 가진 모든 age를 변경 (잘 쓰지는 안음)
# delete 예시 -----------------------------------------------------
db.users.delete_one({'name':'bobby'})
db.users.delete_many({'name':'jane'}) | conagreen/TIL-hanghae99 | Chapter0/sparta/pythonprac/dbprac.py | dbprac.py | py | 1,202 | python | ko | code | 0 | github-code | 13 |
16918311179 | from django.db import models
from django.urls import reverse
from django.utils.timezone import now
from shop.custom_field import *
from shop.define import *
class Contact(models.Model):
name = models.CharField(max_length=100)
email = models.EmailField()
phone = models.CharField(max_length=20)
message = models.TextField()
contacted = CustomBooleanFieldContact()
message_admin = models.TextField(blank=True)
created = models.DateTimeField(default=now)
class Meta:
verbose_name_plural = TABLE_CONTACT_SHOW
def __str__(self):
return self.name
| newfeed123/django | shop/models/contact.py | contact.py | py | 680 | python | en | code | 0 | github-code | 13 |
10191229125 | n, m, k, x = map(int, input().split())
dis = [[10001] * (n + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
dis[i][i] = 0
for i in range(m):
a, b = map(int, input().split())
dis[a][b] = 1
for p in range(1, n + 1):
for j in range(1, n + 1):
dis[x][j] = min(dis[x][j], dis[x][p] + dis[p][j])
check = False
for i in range(1, n + 1):
if dis[x][i] == k:
print(i)
check = True
if check == False:
print(-1)
# BFS(큐) 사용으로 메모리 초과 해결한 코드
import sys
input = sys.stdin.readline
from collections import deque
n, m, k, x = map(int, input().split())
graph = [[] for _ in range(n + 1)]
for _ in range(m):
a, b = map(int, input().split())
graph[a].append(b)
distance = [-1] * (n + 1)
distance[x] = 0
q = deque([x])
while q:
now = q.popleft()
for next_node in graph[now]:
if distance[next_node] == -1:
distance[next_node] = distance[now] + 1
q.append(next_node)
check = False
for i in range(1, n + 1):
if distance[i] == k:
print(i)
check = True
if check == False:
print(-1)
| Jinnie-J/Algorithm-study | algorithm study/dynamic_programming/A15_특정거리의도시찾기.py | A15_특정거리의도시찾기.py | py | 1,122 | python | en | code | 0 | github-code | 13 |
39283202520 | # Created by Qingzhi Ma at 27/01/2020
# All right reserved
# Department of Computer Science
# the University of Warwick
# Q.Ma.2@warwick.ac.uk
#
#
# hive -e "select ss_store_sk, count(*) from store_sales_40g where ss_sold_date_sk between 2451119 and 2451483 group by ss_store_sk;" > ~/group57counts.csv
#
#
from dbestclient.executor.executor import SqlExecutor
def run():
# config = {
# 'warehousedir': '/home/u1796377/Programs/dbestwarehouse',
# 'verbose': 'True',
# 'b_show_latency': 'True',
# 'backend_server': 'None',
# 'csv_split_char': '|',
# "epsabs": 10.0,
# "epsrel": 0.1,
# "mesh_grid_num": 20,
# "limit": 30,
# # "b_reg_mean":'True',
# "num_epoch": 400,
# "reg_type": "mdn",
# "density_type": "mdn",
# "num_gaussians": 4,
# }
sqlExecutor = SqlExecutor()
sqlExecutor.config.set_one_parameter("csv_split_char", "|")
sqlExecutor.set_table_headers("ss_sold_date_sk,ss_sold_time_sk,ss_item_sk,ss_customer_sk,ss_cdemo_sk,ss_hdemo_sk," +
"ss_addr_sk,ss_store_sk,ss_promo_sk,ss_ticket_number,ss_quantity,ss_wholesale_cost," +
"ss_list_price,ss_sales_price,ss_ext_discount_amt,ss_ext_sales_price," +
"ss_ext_wholesale_cost,ss_ext_list_price,ss_ext_tax,ss_coupon_amt,ss_net_paid," +
"ss_net_paid_inc_tax,ss_net_profit,none")
build_models(sqlExecutor)
query(sqlExecutor)
def build_models(sqlExecutor):
# 10k
sqlExecutor.execute(
"create table ss40g_1(ss_sales_price real, ss_sold_date_sk real, ss_coupon_amt categorical) from '/data/tpcds/40G/ss_600k.csv' GROUP BY ss_store_sk method uniform size 60000 scale data num_of_points2.csv", n_mdn_layer_node=8, encoding="binary", b_grid_search=False, device='gpu', b_use_gg=False, n_per_gg=260) # ,ss_quantity
# "create table ss40g_600k(ss_sales_price real, ss_sold_date_sk real) from '/data/tpcds/40G/ss_600k.csv' GROUP BY ss_store_sk method uniform size 600000")
# "create table ss_600k(ss_quantity real, ss_sales_price real) from '/data/tpcds/40G/ss_600k.csv' GROUP BY ss_store_sk method uniform size 600000")
# ss_coupon_amt categorical, ss_sold_time_sk categorical
def query(sqlExecutor):
sqlExecutor.execute(
"select avg(ss_sales_price) from ss40g_1 where ss_sold_date_sk between 2451119 and 2451483 and ss_coupon_amt='' group by ss_store_sk", n_jobs=1, n_division=20, b_use_gg=False, device='gpu')
# sqlExecutor.execute(
# "select sum(ss_sales_price) from ss40g_600k_tes_gg_cpu_grid_search where ss_sold_date_sk between 2451119 and 2451483 group by ss_store_sk", n_jobs=1)
# sqlExecutor.execute(
# "select avg(ss_sales_price) from ss40g_600k_tes_gg_cpu_grid_search where ss_sold_date_sk between 2451119 and 2451483 group by ss_store_sk", n_jobs=1)
# ("select count(ss_quantity) from ss_600k where ss_sales_price between 1 and 20 group by ss_store_sk")
if __name__ == "__main__":
run()
| qingzma/DBEstClient | experiments/tpcds/groupby/groupby57.py | groupby57.py | py | 3,112 | python | en | code | 14 | github-code | 13 |
6955083801 |
from liveapi.extensions import db, cache
from .users import UserService
from .transactions import managedtrans
from liveapi.models import Chatterbox
class TrackService:
@staticmethod
@managedtrans()
@cache.memoize()
def set_tracking(identity, display_name, channel_id=None):
user = UserService.find_by_google_id(identity)
if not user:
raise Exception("Identity user not found")
if channel_id:
chatterbox = user.tracked_fools.first(Chatterbox.channel_id == channel_id)
else:
chatterbox = user.tracked_fools.first(Chatterbox.display_name == display_name)
if not chatterbox:
chatterbox = Chatterbox(display_name=display_name, channel_id=channel_id, tracker_id=user.id)
db.session.add(chatterbox)
return chatterbox # for caching
@staticmethod
def update_tracking_from_message(identity, message):
'''
Args:
identity ():
message (model_chat_messages):
Returns:
'''
pass
| jobrienski/youtube_live | src/liveapi/services/track.py | track.py | py | 1,071 | python | en | code | 0 | github-code | 13 |
25106628250 | import requests
from requests import request
from bs4 import BeautifulSoup
import urllib.parse
import re
import threading
urls_to_city_pages = [
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_dolno%C5%9Bl%C4%85skim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_kujawsko-pomorskim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_lubelskim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_lubuskim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_%C5%82%C3%B3dzkim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_ma%C5%82opolskim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_mazowieckim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_opolskim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_podkarpackim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_podlaskim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_pomorskim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_%C5%9Bl%C4%85skim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_%C5%9Bwi%C4%99tokrzyskim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_warmi%C5%84sko-mazurskim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_wielkopolskim",
"https://pl.wikipedia.org/wiki/Kategoria:Miasta_w_wojew%C3%B3dztwie_zachodniopomorskim",
]
# print(len(urls_to_city_pages))
class City:
def __init__(self, url, province, city_name, **kwargs):
self.url = f"https://pl.wikipedia.org/{url}"
self.province = province
self.city_name = city_name
self.latitude, self.longitude = self.convert_coordinates(kwargs['latitude'], kwargs['longitude'])
def __str__(self):
return f"{self.city_name} {self.province} {self.latitude} {self.longitude}"
def print_data_to_csv(self):
return f"{self.city_name};{self.province};{self.latitude};{self.longitude}"
def dms_to_dd(self, degrees, minutes, seconds, direction):
# Calculate decimal degrees
dd = degrees + (minutes / 60) + (seconds / 3600)
# Check direction (N/S for latitude, E/W for longitude)
if direction in ['S', 'W']:
dd = -dd
return dd
def convert_coordinates(self, dms_lat, dms_lon):
# Split the DMS strings into degrees, minutes, seconds, and direction
lat_parts = dms_lat.split('°')
lat_deg = float(lat_parts[0])
lat_parts = lat_parts[1].split('′')
lat_min = float(lat_parts[0])
lat_parts = lat_parts[1].split('″')
lat_sec = float(lat_parts[0].replace(',', '.')) if len(lat_parts) > 1 else 0.0
lat_dir = dms_lat[-1]
lon_parts = dms_lon.split('°')
lon_deg = float(lon_parts[0])
lon_parts = lon_parts[1].split('′')
lon_min = float(lon_parts[0])
lon_parts = lon_parts[1].split('″')
lon_sec = float(lon_parts[0].replace(',', '.')) if len(lon_parts) > 1 else 0.0
lon_dir = dms_lon[-1]
# Convert to decimal degrees
latitude = self.dms_to_dd(lat_deg, lat_min, lat_sec, lat_dir)
longitude = self.dms_to_dd(lon_deg, lon_min, lon_sec, lon_dir)
return latitude, longitude
def find_data(url):
response = requests.get(url=url)
bs = BeautifulSoup(response.text, 'html.parser')
div_with_url = bs.find_all('div', class_='mw-category-group')
city_list = []
a_tags_list = []
province = ''
for div_index, div in enumerate(start=1, iterable=div_with_url):
a_tags = div.find_all('a')
for index, a in enumerate(start=1, iterable=a_tags):
if index == 1 and div_index == 1:
pattern = r'/wiki/.*'
decoded_text = re.sub(pattern, "", urllib.parse.unquote(a.get('href')).encode('utf-8').decode('utf-8'))
province = decoded_text
continue
#
city_url = a.get('href')
city_name = a.text
# print(city_url, city_name)
city_response = requests.get(url=f'https://pl.wikipedia.org/{city_url}')
city_soup = BeautifulSoup(city_response.text, 'html.parser')
city_province = ''
a_tag_province = city_soup.find('a', title='Podział administracyjny Polski', string='Województwo')
if a_tag_province:
tr_element = a_tag_province.find_parent('tr')
td_element = tr_element.find('td')
a_name = td_element.find('a')
city_province = a_name.text
latitude = city_soup.find('span', class_='latitude').text
longitude = city_soup.find('span', class_='longitude').text
city = City(url=city_url, province=city_province, city_name=city_name, latitude=latitude, longitude=longitude)
city_list.append(city)
for city in city_list:
print(city.print_data_to_csv())
threads = []
for page_url in urls_to_city_pages:
thread = threading.Thread(target=find_data, args=(page_url, ))
threads.append(thread)
thread.start()
# find_data(urls_to_city_pages[0])
| Tnovyloo/Poland-Cities-CSV | main.py | main.py | py | 5,354 | python | en | code | 0 | github-code | 13 |
74251522258 | import json
import csv
import requests
import sys
# keyword is a string
# results_str is a str
# results is a dictionary[keyword] -> sorted primary keys by table
def parse_and_add_to_results(keyword, results_str, results):
table_dict = {}
if keyword in results:
table_dict = results[keyword]
# list_of_results is a list of occurances in all tables.
list_of_results = json.loads(results_str)
for result_dict in list_of_results:
table = result_dict["TABLE"]
primary_key = result_dict["PRIMARY"]
primary_value = result_dict["PRIMARY_VALUE"]
primary_key_list = []
if primary_key in table_dict:
primary_key_list = table_dict[primary_key]
primary_key_list.append(primary_value)
table_dict[primary_key] = primary_key_list
results[keyword] = table_dict
def sort_and_remove_duplicates_in_list(primary_key_list):
sorted_by_frequency = sorted(primary_key_list,key=primary_key_list.count,reverse=True)
seen = set()
seen_add = seen.add
removed_duplicates = [x for x in sorted_by_frequency if not (x in seen or seen_add(x))]
print(removed_duplicates)
return removed_duplicates
# sorts the primary keys in the different tables and also removes duplicates.
def sort_and_remove_duplicates_in_results(results):
for key in results:
table_dict = results[key]
for primary_key in table_dict:
primary_key_list = table_dict[primary_key]
primary_key_list = sort_and_remove_duplicates_in_list(primary_key_list)
table_dict[primary_key] = primary_key_list
def search_for_keyword(keyword, results):
firebaseURL = "https://inf551-experimental.firebaseio.com/index/" + str(keyword) + ".json"
response = requests.get(firebaseURL)
if response.text == "null":
return
parse_and_add_to_results(keyword, response.text, results)
sort_and_remove_duplicates_in_results(results)
#print(results)
def search_databases(args):
results = {}
for arg in args[1:]:
search_for_keyword(arg, results)
if __name__ == "__main__":
search_databases(sys.argv)
| jordvnkm/inf551_project | hw1/homework1/search.py | search.py | py | 2,159 | python | en | code | 0 | github-code | 13 |
20437202594 | import numpy as np
fname='test_input.txt'
# fname='input.txt'
this_count = 0
max_count = 0
this_elf = 1
max_elf = 0
excl_1 = 127
excl_2 = 127
with open(fname) as fp:
for line in fp:
stripped = str.strip(line)
if stripped == '':
if this_count>max_count:
max_count=this_count
max_elf=this_elf
this_elf+=1
this_elf+=1
this_count=0
else:
this_count+=int(stripped)
print(max_elf, max_count) | stephanemagnan/advent-of-code-2022 | Day 01/day01.py | day01.py | py | 536 | python | en | code | 0 | github-code | 13 |
8655680281 | # from twilio.rest import Client
# # Your Account Sid and Auth Token from twilio.com/console
# # DANGER! This is insecure. See http://twil.io/secure
# account_sid = 'AC6f88642acc6eaec6eac5214bff36d18c'
# auth_token = 'cf7f64050ab8ed1c67a414fe216196e2'
# client = Client(account_sid, auth_token)
# # message = client.messages('MM800f449d0399ed014aae2bcc0cc2f2ec').fetch()\
# message = client.messages \
# .create(
# body="Join Earth's mightiest heroes. Like Kevin Bacon.",
# messaging_service_sid='MGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
# to='+2349026128622'
# )
# print(message.body)
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
from Projects.DiamondRubyQuiz.Tools import Templates
import sys
class QuizHome(QWidget):
def __init__(self):
QWidget.__init__(self)
self.window_title = "DiamondRubyQuiz"
self.window_icon = QIcon("Icons/icon.png")
self.window_layout = QVBoxLayout()
# self.window_layout.setSpacing(0)
self.window_layout.setContentsMargins(0, 0, 0, 0)
# self.window_layout.setAlignment(Qt.AlignCenter)
self.main_group = Quiz()
self.window_layout.addWidget(self.main_group)
# self.image = 'Icons/039-physics.png'
# self.image = 'Icons/bg2.jpg'
self.setAutoFillBackground(True)
self.autoFillBackground()
self.setStyleSheet(
"""
QWidget {
background-position: center;
background-repeat: no-repeat;
}
"""
)
self.setLayout(self.window_layout)
self.setWindowTitle(self.window_title)
self.setWindowIcon(self.window_icon)
# self.setMinimumSize(600, 500)
self.showMaximized()
class Quiz(QGroupBox):
def __init__(self):
QGroupBox.__init__(self)
# self.image_size = (self.width() // 2, self.height() // 2)
# self.image_size = (500, 400)
# self.bg_img = QImage('Icons/039-physics.png')
# self.bg_img = self.bg_img.scaled(QSize(self.image_size[0], self.image_size[1]))
# self.bg_palette = QPalette()
# self.bg_palette.setBrush(QPalette.Window, QBrush(self.bg_img))
# self.setPalette(self.bg_palette)
self.main_layout = QVBoxLayout()
self.main_layout.setSpacing(0)
# self.main_layout.setContentsMargins(0, 0, 0, 0)
# self.main_layout.setAlignment(Qt.AlignCenter)
self.setLayout(self.main_layout)
self.setStyleSheet(
"""
QGroupBox {
border: 0px;
padding: 0px;
}
"""
)
# self.window_layout.addWidget(self.main_group)
self.navigation_layout = QHBoxLayout()
self.navigation_layout.setContentsMargins(0, 0, 0, 0)
self.back_button = QPushButton()
self.back_button.clicked.connect(self.back_button_slot)
self.back_button_icon = QIcon("Icons/back_button.png")
self.back_button.setToolTip("Go back to previous page")
self.back_button.setIcon(self.back_button_icon)
self.back_button.setMaximumSize(35, 35)
self.back_button.setStyleSheet(
"""
QPushButton {
background-color: white;
border: 2px solid rgb(60, 150, 200);
border-radius: 5px;
}
QPushButton:hover {
border: 1px solid rgb(60, 150, 200);
}
"""
)
self.forward_button = QPushButton()
self.forward_button.clicked.connect(self.forward_button_slot)
self.forward_button_icon = QIcon("Icons/forward_button.png")
self.forward_button.setToolTip("Go back to next page")
self.forward_button.setIcon(self.forward_button_icon)
self.forward_button.setMaximumSize(35, 35)
self.forward_button.setStyleSheet(
"""
QPushButton {
background-color: white;
border: 2px solid rgb(60, 150, 200);
border-radius: 5px;
}
QPushButton:hover {
border: 1px solid rgb(60, 150, 200);
}
"""
)
self.intitialization()
def intitialization(self):
self.background()
self.centralWIDGET()
def background(self):
self.background_layout = QVBoxLayout()
self.background_layout.setAlignment(Qt.AlignCenter)
# self.background_layout.setContentsMargins(0, 0, 0, 0)
self.background_layout.addLayout(self.navigation_layout)
self.navigation_layout.addWidget(self.back_button)
self.navigation_layout.addWidget(self.forward_button)
self.background_group = QGroupBox()
self.background_group.setLayout(self.background_layout)
self.background_group.setStyleSheet(
"""
QGroupBox {
border: 0px
padding: 0px;
}
"""
)
self.background_stacked_widget = QStackedWidget()
self.background_layout.addWidget(
self.background_stacked_widget, stretch=0, alignment=Qt.AlignCenter
)
# self.window_layout.addWidget(self.background_group, stretch=0, alignment=Qt.AlignCenter)
self.main_layout.addWidget(
self.background_group, stretch=0, alignment=Qt.AlignCenter
)
def back_button_slot(self):
self.background_stacked_widget.setCurrentIndex(
self.background_stacked_widget.currentIndex() - 1
)
def forward_button_slot(self):
self.background_stacked_widget.setCurrentIndex(
self.background_stacked_widget.currentIndex() + 1
)
def centralWIDGET(self):
self.central_layout = QVBoxLayout()
self.central_layout.setContentsMargins(0, 0, 0, 0)
self.central_layout.setAlignment(Qt.AlignBottom)
self.central_eff = QGraphicsDropShadowEffect()
self.central_eff.setBlurRadius(11)
self.central_eff.setOffset(1.2)
# self.central_eff.setYOffset(-0.2)
self.header_layout = QVBoxLayout()
self.header_layout.setContentsMargins(0, 0, 0, 0)
self.header_layout.setAlignment(Qt.AlignCenter)
day = "Monday"
day = f"{day}'s"
mst = "DiamondRubyQuiz"
self.quiz_day_label = QLabel(day)
self.quiz_day_label.setMaximumHeight(60)
self.quiz_day_label.setStyleSheet(
"""
QLabel {
color: white;
font-weight: bold;
font-size: 19px;
font:Verdana;
}
"""
)
self.header_layout.addWidget(self.quiz_day_label)
self.quiz_mst_label = QLabel(mst)
self.quiz_mst_label.setMaximumHeight(65)
self.quiz_mst_label.setStyleSheet(
"""
QLabel {
color: white;
font-weight: bold;
font-size: 30px;
font:Verdana;
}
"""
)
self.header_layout.addWidget(self.quiz_mst_label)
self.header_group = QGroupBox()
# self.header_group.setMaximumSize(300, 500)
self.header_group.setLayout(self.header_layout)
self.header_group.setStyleSheet(
"""
QGroupBox {
border-radius: 40px;
background-color: rgb(60, 150, 200);
padding-left: 20px;
padding-right: 20px;
}
"""
)
self.central_layout.addWidget(self.header_group)
self.mid_width = 600
self.central_group = QGroupBox()
self.central_group.setGraphicsEffect(self.central_eff)
self.central_group.setFixedSize(self.mid_width, 500)
self.central_group.setLayout(self.central_layout)
self.central_group.setStyleSheet(
"""
QGroupBox {
border-radius: 50px;
background-color: rgb(60, 150, 200);
padding-left: 0px;
padding-right: 0px;
}
"""
)
self.central_mid_layout = QVBoxLayout()
self.central_mid_layout.setContentsMargins(0, 0, 0, 0)
self.central_mid_layout.setAlignment(Qt.AlignCenter)
self.quiz_title_layout = QVBoxLayout()
self.quiz_title_layout.setSpacing(4)
self.quiz_title_layout.setAlignment(Qt.AlignCenter)
self.intro_label = QLabel("Today's Quiz on")
self.intro_label.setMaximumHeight(50)
self.intro_label.setStyleSheet(
"""
QLabel {
color: black;
font-size: 13px;
font: Verdana;
}
"""
)
self.quiz_title_layout.addWidget(self.intro_label)
self.topic = "General Knowledge"
self.quiz_topic = QLabel(self.topic)
self.quiz_topic.setMaximumHeight(60)
self.quiz_topic.setStyleSheet(
"""
QLabel {
font-weight: bold;
font-size: 18px;
color: rgb(60, 150, 200);
}
"""
)
self.quiz_title_layout.addWidget(self.quiz_topic)
self.warning = QLabel("Quiz Ends in ")
self.warning.setMaximumHeight(50)
self.warning.setStyleSheet(
"""
QLabel {
color: black;
font-size: 13px;
font: Verdana;
}
"""
)
self.quiz_title_layout.addWidget(self.warning)
self.central_mid_layout.addLayout(self.quiz_title_layout)
self.clock_layout = QGridLayout()
self.clock_layout.setVerticalSpacing(3)
self.clock_layout.setHorizontalSpacing(8)
self.clock_layout.setAlignment(Qt.AlignCenter)
clock_size = (40, 40)
clock_eff1 = QGraphicsDropShadowEffect()
clock_eff1.setBlurRadius(10)
clock_eff1.setOffset(3)
clock_eff2 = QGraphicsDropShadowEffect()
clock_eff2.setBlurRadius(10)
clock_eff2.setOffset(3)
clock_eff3 = QGraphicsDropShadowEffect()
clock_eff3.setBlurRadius(10)
clock_eff3.setOffset(3)
self.hr = 4
self.min = 30
self.sd = 46
self.hour_label = QLabel(str(self.hr))
self.hour_label.setGraphicsEffect(clock_eff1)
self.hour_label.setFixedSize(clock_size[0], clock_size[1])
self.hour_label.setStyleSheet(
"""
QLabel {
font-weight: bold;
font-size: 20px;
font: Verdana;
color: black;
background-color: rgb(210, 210, 210);
border-radius: 4px;
padding: 5px;
text-align: center;
}
"""
)
self.clock_layout.addWidget(self.hour_label, 0, 0)
self.minute_label = QLabel(str(self.min))
self.minute_label.setGraphicsEffect(clock_eff2)
self.minute_label.setFixedSize(clock_size[0], clock_size[1])
self.minute_label.setStyleSheet(
"""
QLabel {
font-weight: bold;
font-size: 20px;
font: Verdana;
color: black;
background-color: rgb(210, 210, 210);
border-radius: 4px;
padding: 5px;
text-align: center;
}
"""
)
self.clock_layout.addWidget(self.minute_label, 0, 1)
self.second_label = QLabel(str(self.sd))
self.second_label.setGraphicsEffect(clock_eff3)
self.second_label.setFixedSize(clock_size[0], clock_size[1])
self.second_label.setStyleSheet(
"""
QLabel {
font-weight: bold;
font-size: 20px;
font: Verdana;
color: black;
background-color: rgb(210, 210, 210);
border-radius: 4px;
padding: 5px;
text-align: center;
}
"""
)
self.clock_layout.addWidget(self.second_label, 0, 2)
self.hr_l = QLabel("Hours")
self.hr_l.setFixedSize(clock_size[0], clock_size[1] // 3)
self.hr_l.setStyleSheet(
"""
QLabel {
font-weight: bold;
font-size: 10px;
font: Verdana;
color: black;
background-color: rgb(210, 210, 210);
border-radius: 4px;
padding: 1px;
text-align: center;
}
"""
)
self.clock_layout.addWidget(self.hr_l, 1, 0)
self.mn_l = QLabel("Minutes")
self.mn_l.setFixedSize(clock_size[0], clock_size[1] // 3)
self.mn_l.setStyleSheet(
"""
QLabel {
font-weight: bold;
font-size: 10px;
font: Verdana;
color: black;
background-color: rgb(210, 210, 210);
border-radius: 4px;
padding: 1px;
text-align: center;
}
"""
)
self.clock_layout.addWidget(self.mn_l, 1, 1)
self.sd_l = QLabel("Seconds")
self.sd_l.setFixedSize(clock_size[0], clock_size[1] // 3)
self.sd_l.setStyleSheet(
"""
QLabel {
font-weight: bold;
font-size: 10px;
font: Verdana;
color: black;
background-color: rgb(210, 210, 210);
border-radius: 4px;
padding: 1px;
text-align: center;
}
"""
)
self.clock_layout.addWidget(self.sd_l, 1, 2)
self.central_mid_layout.addLayout(self.clock_layout)
self.button_layout = QHBoxLayout()
self.button_layout.setSpacing(5)
self.button_layout.setAlignment(Qt.AlignCenter)
self.start_quiz_button = Templates.AnimatedButton()
self.start_quiz_button.setText("Play Quiz Now")
self.start_quiz_button.clicked.connect(self.start_quiz_slot)
self.button_layout.addWidget(self.start_quiz_button)
self.register_button = Templates.AnimatedButton()
self.register_button.setText("Sign Up")
self.register_button.clicked.connect(self.register_button_slot)
self.button_layout.addWidget(self.register_button)
self.central_mid_layout.addLayout(self.button_layout)
self.set_quiz_layout = QHBoxLayout()
self.set_quiz_layout.setSpacing(0)
self.set_quiz_layout.setAlignment(Qt.AlignCenter)
self.set_quiz_button = Templates.AnimatedButton("Set Quiz")
self.set_quiz_button.clicked.connect(self.set_quiz_slot)
self.set_quiz_layout.addWidget(self.set_quiz_button)
self.central_mid_layout.addLayout(self.set_quiz_layout)
self.central_mid_group = QGroupBox()
self.central_mid_group.setFixedSize(self.mid_width, 300)
self.central_mid_group.setLayout(self.central_mid_layout)
self.central_mid_group.setStyleSheet(
"""
QGroupBox {
border-radius: 40px;
border: 0px;
background-color: white;
padding: 20px;
}
"""
)
self.central_layout.addWidget(
self.central_mid_group, stretch=0, alignment=Qt.AlignCenter
)
self.aid_layout = QVBoxLayout()
self.aid_layout.addWidget(
self.central_group, stretch=0, alignment=Qt.AlignCenter
)
self.aid_group = QGroupBox()
self.aid_group.setLayout(self.aid_layout)
self.aid_group.setStyleSheet(
"""
QGroupBox {
border: 0px;
}
"""
)
self.background_stacked_widget.addWidget(self.aid_group)
self.background_stacked_widget.setCurrentIndex(0)
from Projects.DiamondRubyQuiz.Quiz import StartQuiz, QuizRegistration, SetQuiz
self.background_stacked_widget.addWidget(StartQuiz.StartQuiz())
self.background_stacked_widget.addWidget(QuizRegistration.QuizRegister())
self.background_stacked_widget.addWidget(SetQuiz.SetQuiz())
def start_quiz_slot(self):
try:
self.background_stacked_widget.setCurrentIndex(1)
except Exception as e:
raise e
def register_button_slot(self):
try:
self.background_stacked_widget.setCurrentIndex(2)
except Exception as e:
raise e
def set_quiz_slot(self):
try:
self.background_stacked_widget.setCurrentIndex(3)
except Exception as e:
raise e
if __name__ == "__main__":
app = QApplication(sys.argv)
window = QuizHome()
window.show()
sys.exit(app.exec_())
| struckchure/Finished-Projects | DiamondRubyQuiz/Test.py | Test.py | py | 15,456 | python | en | code | 1 | github-code | 13 |
28541693689 | import time
# sudo pip3 install adafruit-blinka
# sudo pip3 install adafruit-circuitpython-pca9685
# sudo pip3 install adafruit-circuitpython-servokit
from adafruit_pca9685 import PCA9685
from board import SCL, SDA
import busio
from adafruit_motor import servo
i2c_bus = busio.I2C(SCL, SDA)
pwm = PCA9685(i2c_bus) # 使用默认地址初始化PWM设备
pwm.frequency = 50 # 将频率设置为50 Hz
servo_12 = servo.Servo(pwm.channels[12]) # 指定第12通道的舵机（从0开始）
servo_15 = servo.Servo(pwm.channels[15]) # 指定第15通道的舵机
print('Moving servo on channel 0, press Ctrl-C to quit...')
servo_12.angle = 90
servo_15.angle = 90
while True:
# 伺服电机转动最小角度和最大角度
servo_12.angle = 0
servo_15.angle = 0
time.sleep(1)
servo_12.angle = 0
servo_15.angle = 180
time.sleep(1)
| cocpy/raspberrypi4 | 第7章/2/control_servo_motors.py | control_servo_motors.py | py | 967 | python | en | code | 0 | github-code | 13 |
20478620439 | from .element import Element
from collections import OrderedDict
class Elements(OrderedDict):
def __init__(self, elements=None):
OrderedDict.__init__(self)
if elements:
if type(elements) == Elements:
for key, val in elements.items:
self[key] = Element(val)
def add_atom(self, name):
if name not in self:
self[name] = Element(name)
self[name].num += 1
def set_element(self, name, num):
if name not in self:
self[name] = Element(name, num)
def name_list(self):
lis = []
for elem in self:
lis.append(elem)
return lis
def num_list(self):
lis = []
for elem in self.values():
lis.append(str(int(elem.num)))
return lis
def merge(self, other):
for elem in other:
if elem not in self:
self[elem] = Element(other[elem])
else:
self[elem].num += other[elem].num
tmp_dic = OrderedDict(sorted(self.items()))
self.clear()
for key, val in tmp_dic.items():
self[key] = val
# a = Elements()
# a.add_atom('Au')
# a.add_atom('Au')
# a.add_atom('U')
# a.add_atom('Ag')
# a.add_atom('Au')
#
# b = Elements()
# b.add_atom('Au')
# b.add_atom('Cu')
#
# a.merge(b)
# for elem in a:
# print(elem)
# print(a[elem].num)
| etalpha/vaspm | lib/elements.py | elements.py | py | 1,416 | python | en | code | 0 | github-code | 13 |
9715220364 | from sqlalchemy import Column, Integer, DateTime, Text, ForeignKey
from sqlalchemy.orm import relationship
from GaleriaViewer.model.base import Base
from GaleriaViewer.model import content_tag
class Tag(Base):
"""Model for all tags stored in database"""
__tablename__ = 'tag'
id = Column(Integer, primary_key=True)
name = Column(Text)
time_of_add = Column(DateTime)
time_of_last_modification = Column(DateTime)
thumbnail_id = Column(Integer, ForeignKey('content.id'))
thumbnail = relationship('Content')
contents = relationship('Content',
secondary='content_tag',
back_populates='tags'
)
| gr8prnm8/GaleriaViewer | GaleriaViewer/model/tag.py | tag.py | py | 714 | python | en | code | 0 | github-code | 13 |
42135008812 | def Parity (x):
'''
Проверка на четность
'''
par = x % 2 == 0
if par == True:
return ("Четное")
else:
return ("Нечетное")
def biggestNumberAndMultiplicity (nOne, nTwo):
'''
Определение большего числа
И кратны ли числа
'''
if nOne > nTwo:
if nOne % nTwo == 0:
return("Число {0} кратно {1}".format(nOne, nTwo)) # Нашел такое форматирование
else:
return("Число {0} не кратно {1}".format(nOne, nTwo))
else:
if nTwo % nOne == 0:
return("Число {0} кратно {1}".format(nTwo, nOne))
else:
return("Число {0} не кратно {1}".format(nTwo, nOne))
def smallestNumber (num1, num2, num3):
'''
Определение наименьшего числа
'''
if num1 < num2 and num1 < num3:
return("Наименьшее число: {0}".format(num1))
elif num2 < num3:
return("Наименьшее число: {0}".format(num2))
else:
return("Наименьшее число: {0}".format(num3))
def existTrian (side1, side2, side3):
'''
Проверка существования треугольника
'''
if side1 + side2 > side3 and side1 + side3 > side2 and side2 + side3 > side1:
return("Треугольник существует")
else:
return("Треугольник не существует")
def squareLength (rad):
'''
Определение площади и
Длины круга
'''
import math
square = "%.3f" % (float(math.pi * rad ** 2)) # Нашел ограничение количества
length = "%.3f" % (float(2 * math.pi * rad)) # Знаков после запятой
return("Площадь круга: {0} \nДлина окружности: {1}".format(square, length))
def quadraticEquation (a, b, c):
'''
Нахождение корней
Квадратного уравнения
'''
import math
D = float(b ** 2 - 4 * a * c)
if D < 0:
return("Уравнение не имеет корней")
elif D == 0:
root = "%.3f" % (float(- b / (2 * a)))
return("""В уравнении один корень
Корень: {0}""".format(root))
else:
rootOne = "%.3f" % (float((-b + math.sqrt(D)) / (2 * a)))
rootTwo = "%.3f" % (float((-b - math.sqrt(D)) / (2 * a)))
return("""В уравнении два корня
Первый корень: {0}
Второй корень: {1}""".format(rootOne, rootTwo)) | LevapTon/Studing | Информатика с основами программирования/Семестр 1/ЛабРаб 1 – Диалоги и ветвления/BackEnd.py | BackEnd.py | py | 2,631 | python | ru | code | 0 | github-code | 13 |
21951228658 | #!/usr/bin/python
# SPLASH EROSION
########## HERE IS THE INITIAL SECTION OF PROGRAM HEADER CLASS ##########
# PROGRAM TITLE
# Sediment Transport & Erosion Prediction
# PROGRAM DESCRIPTION
# STEP was initiated by Jenderal Soedirman University, a research university of technology located in Indonesia in 2017.
# STEP is an open-source project use for computing and predict the amount of sediment transport.
# This program has been tested and should work on almost all Python 3.6 compilers.
# Feel free to use the source code on your system.
# LOAD HEADER & MODULES
### LOADING HEADER ###
# Header is used for giving information about title and the version of the program
'''
import pyfiglet
pyfiglet.print_figlet("STEP",font="lean",justify="center")
pyfiglet.print_figlet("Sediment Transport & Erosion Prediction",font="digital",justify="center")
version = " Version x.x.x ";
print("{1:^75}".format(" ",version))
print(" ")
'''
### LOADING MODULES ###
# After the packages has been satisfied by running setup.py, then import the modules and the alias by running the script below:
import glob, os, shutil, itertools, re, sys, time, threading, pandas as pd, numpy as np
from itertools import zip_longest, groupby, islice
from functools import reduce
from operator import mul
np.set_printoptions(suppress=True, threshold=np.inf, linewidth=np.inf) # Handling output mode and turn scientific mode off, summarization and line-wrapping
# Disabled modules: pickle, chain, csv, ctypes, collections, pprint, from io import StringIO
# FLUSH OUTPUT FOLDER
# Loading Animation
done = False
def animate():
for c in itertools.cycle(['|', '/', '-', '\\']):
if done:
break
sys.stdout.write("\rIdentifying splash erosion data " + c)
sys.stdout.flush()
time.sleep(0.1)
sys.stdout.write('\n')
t = threading.Thread(target=animate)
t.start()
time.sleep(10)
done = True
# Flush and clean up the contents of output folder to make sure there is no files inside
output_directory = '../output'
for dirpath, dirnames, filenames in os.walk(output_directory):
# Remove regular files and ignore directories
for filename in filenames:
os.unlink(os.path.join(dirpath, filename))
# IMPORT LOCAL AND GLOBAL LISTS
### IMPORT LOCAL LISTS ###
# Import lists of folder path from local file
floc_local = glob.glob('../input/parameter/local*.*') # Load local file contents
cols_local = [0,1] # Read row and column index of local file
# Read certain columns with Pandas Module
df_local = pd.DataFrame()
for f_local in floc_local:
df_local = df_local.append(pd.read_csv
(f_local, delimiter='\s+', header=None, usecols=cols_local, na_values=['']),
ignore_index=True)
arr_local = df_local.values
### IMPORT GLOBAL LISTS ###
# Import lists of folder path from global file
floc_global = glob.glob('../input/parameter/global*.*') # Load global file contents
cols_global = [0,1] # Read row and column index of global file
# Read certain columns with Pandas Module
df_global = pd.DataFrame()
for f_global in floc_global:
df_global = df_global.append(pd.read_csv
(f_global, delimiter='\s+', header=None, usecols=cols_global, na_values=[''], skiprows=1),
ignore_index=True)
arr_global = df_global.values
########## HERE IS THE LAST SECTION OF PROGRAM HEADER CLASS ##########
########## HERE IS THE INITIAL SECTION OF SPLASH EROSION CLASS ##########
# SPLASH EROSION EQUATION
# Splash Erosion = Alpha x Squared of Rainfall Intensity
# Alpha will be calibrated by multiplied with the fraction of cover vegetation
# Before run this script below, User should provide the rainfall intensity for every single grid in input directory named "forcing"
########## HERE IS THE INITIAL SECTION OF GRID CELL CLASS ##########
# Grid Lat-Long
### COLUMNS SELECTION FOR CONTENT ###
# Load array data list from local file with initial name 'soil' located in /input/gridlatlon
floc_gll = arr_local[0,1] # Save Grid Lat-Lon folder path into a variable
flist_gll = glob.glob(floc_gll) # Load Grid Lat-Lon content from the folder path
cols_gll = [1,2,3] # Index 1,2,3 are Grid, Latitude, Longitude
# Reading certain rows and columns with Pandas Module
df_gll = pd.DataFrame()
for f_gll in flist_gll:
df_gll = df_gll.append(pd.read_csv
(f_gll, delimiter='\s+', header=None, usecols=cols_gll, na_values=['']),
ignore_index=True)
arr_gll = df_gll.values
# Writing selected rows and columns into a file
gll_stripped = "../output/erosion/tempfiles/gll/gll.txt"
with open(gll_stripped, 'w') as f_gll:
f_gll.write(np.array2string(arr_gll, separator=' '))
# Read the content of filename list of gll.txt
with open(gll_stripped) as gll_strp:
gll_strpin = gll_strp.read()
# remove brackets from gll string list
rmb_gll_strpin_1 = gll_strpin.replace('[[',' ')
rmb_gll_strpin_2 = rmb_gll_strpin_1.replace('[','')
rmb_gll_strpin_3 = rmb_gll_strpin_2.replace(']','')
rmb_gll_strpin_4 = rmb_gll_strpin_3.replace(']]','')
rmd_gll = re.compile("(?<=\d)(\.)(?!\d)")
rmb_gll_strpin_5 = rmd_gll.sub("",rmb_gll_strpin_4)
rmbd_gll_strpin = gll_stripped # Overwrite gll.txt
with open(rmbd_gll_strpin, 'w') as wr_rmbd:
wr_rmbd.write(rmb_gll_strpin_5)
### COLUMNS SELECTION FOR FILE NAME ###
# Open file path to be read
fl_fngll = open(floc_gll, 'r')
# Writing temporary file named fl_fngll.txt contains stripped columns
tmp_fngll = '../output/erosion/tempfiles/gll/fl_fngll.txt'
# Iterate over the lines and write it into a file
fn_gll = open(tmp_fngll,'w')
for line_gll in fl_fngll:
# Split the line into a list of column values
columns_gll = line_gll.split(' ')
# Clean any whitespace off the items
columns_gll = [col.strip() for col in columns_gll]
# Ensure the column has at least one value before printing
if columns_gll:
clat = str(columns_gll[2])
clon = str(columns_gll[3])
filename_splasherosion = clat+"_"+clon
# Write the list into a file
fn_gll.write("%s\n" %filename_splasherosion)
fn_gll.close()
### GLL WRITE INTO MULTIPLE FILES & NAME IT BASED ON FL_FNGLL.TXT ###
# Definition function for grouping
def grouper(n, iterable, fillvalue=None):
args = [iter(iterable)] * n
return zip_longest(fillvalue=fillvalue, * args)
# How many lines will be read and write into a file?
n = 1
# Read the content of filename list of splasherosion
with open(tmp_fngll) as lfn_gll:
lfrn_gll = lfn_gll.read().splitlines()
# Stripped GLL path location and initial definition of splasherosion filename
stripped_gll_floc = gll_stripped
dfn_of_se = '../output/erosion/splasherosion/splasherosion_{0}'
# Write lists of filename into file
with open(stripped_gll_floc) as f:
for i, g in enumerate(grouper(n, f, fillvalue=''), 1):
with open(dfn_of_se.format(i * n), 'w') as fout:
fout.writelines(g)
# Rename splasherosion_[number] to be se_[lat]_[lon]
root_splasherosion = '../output/erosion/splasherosion'
root_splasherosion_slush = '../output/erosion/splasherosion/'
ordered_files_root_splasherosion = sorted(os.listdir(root_splasherosion), key=lambda x: (int(re.sub('\D','',x)),x))
replace_by = 'se_{0}'
path_splash_old = list()
for item_splasherosion in ordered_files_root_splasherosion:
fullpath_splasherosion_old = os.path.join(root_splasherosion_slush, item_splasherosion)
path_splash_old.append(fullpath_splasherosion_old)
path_splash_new = list()
for lsfn_gll in lfrn_gll:
se = replace_by.format(lsfn_gll)
fullpath_splasherosion_new = os.path.join(root_splasherosion_slush, se)
path_splash_new.append(fullpath_splasherosion_new)
for spath_old, spath_new in zip(path_splash_old, path_splash_new):
shutil.move(spath_old, spath_new)
########## HERE IS THE LAST SECTION OF GRID CELL CLASS ##########
########## HERE IS THE INITIAL SECTION OF RAINFALL INTENSITY CLASS ##########
# Rainfall Intensity
### Copy entire forcing files into output temporary files for erosion (/output/erosion/tempfiles/ri) ###
srcp_ri = arr_local[1,1]
destp_ri = '../output/erosion/tempfiles/ri'
srcf_ri = os.listdir(srcp_ri)
for fl_ri in srcf_ri:
f_ri = os.path.join(srcp_ri, fl_ri)
if (os.path.isfile(f_ri)):
shutil.copy(f_ri, destp_ri)
### Columns selection ###
# Create list of filename to be read
os.chdir(destp_ri) # Change directory to /output/erosion/tempfiles/ri
with open("ri_flist.txt","w") as ri_flst: # Create a empty file ri_list.txt
for ri_flist in glob.glob("data_*_*"): # Take name lists of forcing data
ri_flst.write(str(ri_flist) + '\n') # Write it down into ri_list.txt
tmp_fnri = 'ri_flist.txt' # Save filename lists of rainfall intensity into a variable
with open(tmp_fnri) as lfn_ri: # Create list of filename to be read
lfr_ri = lfn_ri.read().splitlines() # Make a list with newlines as separator
main_from_ri = "../../../../main"
os.chdir(main_from_ri) # Change directory to /main/
# Stripping columns per file
os.chdir(destp_ri) # Change directory to /output/erosion/tempfiles/ri
for row in lfr_ri:
# Read and write with same filename
fl_fnri = open(row, 'r') # Open file name to be read
# Write temporary file named data_lat_lon.txt contains stripped columns
tmp_fnri = "%s" %row
fn_ri = open(tmp_fnri,'w')
forcing_from_ri = "../../../../input/forcing/"
rain = forcing_from_ri+str(row)
# Iterate over the lines and write it into a file
for line_ri in open(rain, 'r'):
# Split the line into a list of column values
columns_ri = line_ri.split(' ')
# Clean any white space off the items
columns_ri = [col.strip() for col in columns_ri]
# Ensure the column has at least one value before printing
if columns_ri:
mmph2mps = float((1/10**3)/(60*60))
ri = (float(columns_ri[0])*mmph2mps)**2
ri_sqr = str("%.30f" %ri)
fn_ri.write("%s\n" %ri_sqr)
fn_ri.close()
os.chdir(main_from_ri) # Change directory to /main/
########## HERE IS THE LAST SECTION OF RAINFALL INTENSITY CLASS ##########
########## HERE IS THE INITIAL SECTION OF CV ALPHA PARAMETER CALIBRATION CLASS ##########
# Cover Vegetation Coefficient
# Load array data list from global or local file with name file veg_param
# Active one of these parameters to choose local or global file as your vegetation parameter path
# Active path from global file
#fglob_vp = arr_globalfile[138,1] # Save vegetation parameter path into a variable
#fglist_vp = glob.glob(flist_vp) # Load path from globalfile_vp
# Active path from local file
floc_vp = arr_local[2,1] # Save vegetation parameter path into a variable
flist_vp = glob.glob(floc_vp) # Load path from localfile_vp
cols_vp = [0,1] # Index 0 is Grid and Classes and Index 1 is Class Nominal and Class Fraction
# Read certain columns with Pandas Module
df_vp = pd.DataFrame()
for f_vp in flist_vp:
df_vp = df_vp.append(pd.read_csv
(f_vp, delimiter='\s+', header=None, usecols=cols_vp, na_values=['']),
ignore_index=True)
arr_vp = df_vp.values
# Writing list into a file
cv_output = "../output/erosion/tempfiles/cv/cv.txt"
with open(cv_output, 'w') as f_vp:
f_vp.write(np.array2string(arr_vp, separator=' '))
# Save vegetation parameter array into a variable
with open(cv_output) as var_cv:
variable_cv = var_cv.read()
strvariable_cv = str(variable_cv)
# Save vegetation parameter array and also remove the bracket then write it into a file
with open(cv_output,"w") as rmbd_cv:
rmb_vp1 = strvariable_cv.replace('[[ ','')
rmb_vp2 = rmb_vp1.replace(' [ ','')
rmb_vp3 = rmb_vp2.replace(']','')
rmb_vp4 = rmb_vp3.replace(']]','')
rmd_an = re.compile("(?<=\d)(\.)(?!\d)")
rmb_vp5 = rmd_an.sub("",rmb_vp4)
rmbd_cv.write(rmb_vp5)
# Split the list into strings and lines
with open(cv_output) as str2lst_cv:
strtolist_cv = str(str2lst_cv.read()) # Convert the list into string
cv_perline = strtolist_cv.rstrip().splitlines() # Split the list per row line
cv_pernumber = strtolist_cv.split() # Split the list into per string
# Get data content of second column in cv.txt
nclass = cv_pernumber[1::2]
str_nclass = str(nclass)
rep_nclass = str_nclass.replace("'1', '1'","'1', '0.99999'")
rep_nclass = rep_nclass.replace("['","")
rep_nclass = rep_nclass.replace("']","")
rep_nclass = rep_nclass.replace("', '"," ")
spt_nclass = rep_nclass.split()
# Get the quantity of classes per grid
qclasses = list() # Generate empty list called qclasses
for qclass in spt_nclass: # Its mean every single data in nclass variable
# Selection the data, everything starts with "0" will be removed
prefix_zero = 0
if qclass.startswith(str(prefix_zero)):
pass
else:
qclasses.append(qclass)
# If the grid has only 1 class and the value of cv fraction is 1, execute script below
str_qclasses = str(qclasses)
prefix_one = str_qclasses.replace("'1.', '1.'","'1.'") # qClasses 1 with cv value = 1 (other format)
#prefix_one = str_qclasses.replace("'1', '1'","'1'") # qClasses 1 with cv value = 1
rid_the_dot = re.sub("[\.]","",prefix_one)
qclasses_new = re.findall(r'\d+', rid_the_dot)
# Save the iterated lines into a variable
cquantity = list()
for quantity in qclasses_new:
class_quantity = int(quantity)+1
cquantity.append(class_quantity)
# Grab the grid as filename
cvname = list()
with open(floc_gll) as fn_sepdgridclass:
fn_cvout = fn_sepdgridclass.read()
fn_cvout = fn_cvout.split('\n')
for each_fncvout in fn_cvout:
ff = each_fncvout.split(' ')
cvname.append(ff[1])
# Write the selected lines into files
with open(cv_output,"r") as mycvfile:
for name, N in zip(cvname, cquantity):
head = list(islice(mycvfile, N))
cv_from_main = "../output/erosion/tempfiles/cv/"
with open(cv_from_main+name,"w") as s:
s.writelines(head)
# Save file's contents into variable
vcv = list()
for varlst_cv in os.listdir(cv_from_main):
if varlst_cv.startswith("cv"):
pass
else:
rvarlst_cv = open(cv_from_main+varlst_cv,"r")
rcvarlst_cv = str(rvarlst_cv.read())
rrowvarlst_cv = rcvarlst_cv.split()
vcv.append(rrowvarlst_cv[2::])
# Alpha Parameter
# Change directory into input alpha folder
alpha_from_root = "../input/alpha/"
#os.chdir(alpha_from_root)
'''
# Get and create file of alpha
with open("data_alpha.txt","w") as wf_alpha:
for cveg in range(1,14):
wf_alpha.writelines("%i \n" %cveg)
root_from_alpha = "../../main/"
os.chdir(root_from_alpha)
# Show pop up dialog to user for filling alpha value
print("\nPlease fill the Alpha values in Alpha directory!")
question_alpha = input("\nIf You have already completed it, Press Y to continue or press N to exit! ")
if question_alpha.lower().startswith("y"):
print("\nPlease wait a moment...")
elif question_alpha.lower().startswith("n"):
exit()
'''
### Copy alpha file into output temporary files for erosion (/output/erosion/tempfiles/a) ###
srcp_alpha = alpha_from_root
destp_alpha = '../output/erosion/tempfiles/a/'
srcf_alpha = os.listdir(srcp_alpha)
for fl_alpha in srcf_alpha:
f_alpha = os.path.join(srcp_alpha, fl_alpha)
if (os.path.isfile(f_alpha)):
shutil.copy(f_alpha, destp_alpha)
# Save file's contents into variable
va = list()
for varlst_a in os.listdir(destp_alpha):
rvarlst_a = open(destp_alpha+varlst_a,"r")
rcvarlst_a = str(rvarlst_a.read())
rrowvarlst_a = rcvarlst_a.split()
va.append(rrowvarlst_a)
# Calibration Parameter
# Split alpha list every 2 elements
# Split cover vegetation every 2 elements
# Dictionary with same key will be combined or merged
# Multiply in every single key and sum up to get calibration parameter
for a in va:
try:
complist_alpha = [a[x:x+2] for x in range(0, len(a), 2)]
dict_alpha = dict(complist_alpha)
except:
continue
cp = list()
for cv in vcv:
try:
complist_cover_vegetation = [cv[x:x+2] for x in range(0, len(cv),2)]
dict_cover_vegetation = dict(complist_cover_vegetation)
dict_combine = {k: [dict_cover_vegetation[k],dict_alpha[k]] for k in dict_cover_vegetation}
for key in dict_combine.keys():
dict_combine[key] = [float(dict_combine[key][0]),float(dict_combine[key][1])]
muldict_combine = {key: reduce(mul, value) for key, value in dict_combine.items()}
summuldict_combine = sum(muldict_combine.values())
cp.append("%.5f" %summuldict_combine)
except:
print("\nERROR-UIA\n\nIt seems You forgot something.\n")
print("Make sure You fill all the Alpha values.\n")
print("If in a class the value is not avaliable just type 0.")
exit()
########## HERE IS THE LAST SECTION OF CV ALPHA PARAMETER CALIBRATION CLASS ##########
########## HERE IS THE INITIAL SECTION OF MULTIPLICATION OF ALPHA AND RAINFALL INTENSITY SQUARE CLASS ##########
# Reload Rainfall Intensity
# Load file's contents of rainfall intensity into variable
rainfall_intensity = list()
for varlst_ri in os.listdir(destp_ri):
if varlst_ri.startswith("data"):
rvarlst_ri = open(destp_ri+"/"+varlst_ri,"r")
rcvarlst_ri = str(rvarlst_ri.read())
rrowvarlst_ri = rcvarlst_ri.split()
rainfall_intensity.append(rrowvarlst_ri)
# Matrix Multiplication
# Multiplication of Squared Rainfall Intensity with Calibration Parameter
mm_from_main = "../output/erosion/tempfiles/mm/"
for name4splasherosion, irain, pc in zip(os.listdir(destp_ri), rainfall_intensity, cp):
array_pc = np.array(pc, dtype=float)
array_rain = np.array(irain, dtype=float)
result = array_pc * array_rain
if name4splasherosion.startswith("data_"):
with open(mm_from_main+name4splasherosion,"w") as results:
results.write(np.array2string(result,separator='\n', formatter={'float_kind':lambda result: "%.30f" % result}))
# Loading animation
print(" ")
done = False
def animate():
for c in itertools.cycle(['|', '/', '-', '\\']):
if done:
break
sys.stdout.write("\rCalculating splash erosion " + c)
sys.stdout.flush()
time.sleep(0.1)
sys.stdout.write('\n\nDone! Identifying sheet erosion data...\n')
t = threading.Thread(target=animate)
t.start()
time.sleep(10)
done = True
########## HERE IS THE LAST SECTION OF MULTIPLICATION OF ALPHA AND RAINFALL INTENSITY SQUARE CLASS ##########
########## HERE IS THE INITIAL SECTION OF SPLASH EROSION REPORT CLASS ##########
# SPLASH EROSION REPORT
### REPORT THE CALCULATION ###
# Print path of splash erosion filename list into a file named content_se.txt
report_ordered_files_root_splasherosion = sorted(os.listdir(root_splasherosion), key=lambda x: (int(re.sub('\D','',x)),x))
floc_content_se = "../output/erosion/tempfiles/ri/content_se.txt" # Save file path into a variable
each_content_se = open(floc_content_se, "w") # Open write mode with metode below:
for item_se in report_ordered_files_root_splasherosion: # Make a list of splash erosion filename
content_se = root_splasherosion+"/"+str(item_se) # Save full path of splash erosion files into a variable called content_se
s_content_se = str(content_se) # Convert into string class
each_content_se.write("%s\n" %s_content_se) # Write the list into content_se.txt
#print(item_se) # Print list of filename
#print(s_content_se) # Print full path of filename list
each_content_se.close() # Close function
loc_content_se = open(floc_content_se,"r") # Open read mode with floc_content-se as location of filename list
data_content_se = loc_content_se.read().splitlines() # Read per line and save it into variable (list)
#print(data_content_se)
# Print path of splash erosion filename list into a file named content_splsherosion.txt
report_ordered_files_root_splsherosion = sorted(os.listdir(mm_from_main), key=lambda x: (int(re.sub('\D','',x)),x))
root_splsherosion = mm_from_main # Root for splas herosion data file
floc_content_splsherosion = "../output/erosion/tempfiles/mm/content_splsherosion.txt" # Save file path into a variable
each_content_splsherosion = open(floc_content_splsherosion, "w") # Open write mode with metode below:
for item_splsherosion in report_ordered_files_root_splsherosion: # Make a list of splash erosion filename
if re.match("data_",item_splsherosion): # If the content of folder mm has initial name "data_" so they would be printed and save them into a variable
content_splsherosion = root_splsherosion+"/"+str(item_splsherosion) # Save full path of splash erosion files into a variable called content_splsherosion.txt
s_content_splsherosion = str(content_splsherosion) # Convert into string class
each_content_splsherosion.write("%s\n" %s_content_splsherosion) # Write the list into content_splsherosion.txt
#print(item_ri) # Print list of filename
#print(content_ri) # Print full path of filename list
each_content_splsherosion.close() # Close function
loc_content_splsherosion = open(floc_content_splsherosion,"r") # Open read mode with floc_content_splsherosion as location of filename list
data_content_splsherosion = loc_content_splsherosion.read().splitlines() # Read per line and save it into variable (list)
#print(data_content_ri)
# Read each file's content of splasherosion
sd_gll = []
for grid_ll in data_content_se:
read_grid_ll = open(grid_ll,"r")
plread_grid_ll = read_grid_ll.read()
rplgll = plread_grid_ll.rstrip().split('\n')
sd_gll.append(rplgll)
#print(rplgll)
# print(sd_gll)
# Read each file's content of rainfall intensity
sd_splsherosion = []
for rain_splsherosion in data_content_splsherosion:
read_rain_splsherosion = open(rain_splsherosion,"r")
plread_rain_splsherosion = read_rain_splsherosion.read()
rplrainisplsherosion = plread_rain_splsherosion.rstrip().split('\n')
sd_splsherosion.append(rplrainisplsherosion)
#print(rplraini)
#print(sd_ri)
# Merge to the Report
report = []
for i in itertools.zip_longest(sd_gll,sd_splsherosion):
str_se_done = str(i)
report.append("%s\n" %str_se_done)
locse_report = "../output/erosion/tempfiles/se/report.txt"
with open(locse_report,"w") as report_se:
report_se.writelines(report)
# Read splasherosion filenames
fnfl_gll = []
for se_nameit in os.listdir(root_splasherosion):
fnfl_gll.append(se_nameit)
#print(fnfl_gll)
# Write combined data into each splasherosion files
def grouper(n, iterable, fillvalue=None): # Definition function for grouping
args = [iter(iterable)] * n
return zip_longest(fillvalue=fillvalue, * args)
n = 1 # How many lines will be read and write into a file?
dst_of_se = '../output/erosion/splasherosion/splsherosion_{0}' # Report file location and definition splasherosion filename
with open(locse_report) as f: # Write lists of filename into file
for i, g in enumerate(grouper(n, f, fillvalue=''), 1):
with open(dst_of_se.format(i * n), 'w') as fout:
# Remove brackets from gll string list
str_g = str(g)
rone1 = str_g.replace('("(','')
rtwo2 = rone1.replace("[' ",'')
rthree3 = rtwo2.replace("'], ['",'\t\t')
rfour4 = rthree3.replace("', '",'\n\t\t\t\t\t\t\t\t\t\t')
rfive5 = rfour4.replace("'","")
rsix6 = rfive5.replace("]","")
rseven7 = rsix6.replace(")","")
reight8 = rseven7.replace('n",',"")
rnine9 = reight8.replace('\\','')
rten10 = rnine9.replace('[','')
fout.writelines(rten10)
# Rename splasherosion_[number] to be se_[lat]_[lon]
new_ordered_files_root_splasherosion = sorted(os.listdir(root_splasherosion), key=lambda x: (int(re.sub('\D','',x)),x))
path_splsherosion = list()
for item_splasherosion in new_ordered_files_root_splasherosion:
if item_splasherosion.startswith("splsherosion_"):
fullpath_splasherosion1 = os.path.join(root_splasherosion_slush, item_splasherosion)
path_splsherosion.append("%s" %fullpath_splasherosion1)
path_se = list()
for lsfn_gll in lfrn_gll:
se = replace_by.format(lsfn_gll)
fullpath_splasherosion2 = os.path.join(root_splasherosion_slush, se)
path_se.append(fullpath_splasherosion2)
for splashpath_old, splashpath_new in zip(path_splsherosion, path_se):
shutil.move(splashpath_old, splashpath_new)
########## HERE IS THE LAST SECTION OF SPLASH EROSION REPORT CLASS ##########
########## HERE IS THE LAST SECTION OF SPLASH EROSION CLASS ##########
########## HERE IS THE INITIAL SECTION OF REPORT REVISION CLASS ##########
# REPORT REVISION
# Grab and rename the file name
mm_from_main = "../output/erosion/tempfiles/mm/"
se_from_main = "../output/erosion/splasherosion/"
filename_se = list()
for rev_se in os.listdir(mm_from_main):
if rev_se.startswith("data"):
new_rev_se = rev_se.replace("data","se")
filename_se.append(new_rev_se)
splasherosion_new = list()
for cont_se in os.listdir(mm_from_main):
if cont_se.startswith("data"):
with open(mm_from_main+cont_se,"r") as cse:
cse_read = str(cse.read())
cse_rep = cse_read.replace("[","")
cse_rep = cse_rep.replace("]","")
cse_spl = cse_rep.split()
splasherosion_new.append(cse_spl)
for fn_se, se_new in zip(filename_se, splasherosion_new):
with open(se_from_main+fn_se,"w") as fse:
for senew in se_new:
float_senew = float(senew)
fse.writelines("%.30f\n" %float_senew)
########## HERE IS THE LAST SECTION OF REPORT REVISION CLASS ########## | GitContainer/STEPMaster | main/splasherosion.py | splasherosion.py | py | 26,083 | python | en | code | 1 | github-code | 13 |
18365897211 | import socket
from threading import Thread
class Server(Thread):
def __init__(self, conn):
super().__init__()
self._conn = conn
def run(self):
conn.send(str.encode("Welcome, type your info\n"))
while True:
data = conn.recv(2048)
if not data:
break
reply = "Server output: " + data.decode("utf-8")
conn.sendall(str.encode(reply))
conn.close()
host = ""
port = 5555
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.bind((host, port))
except socket.error as e:
print(str(e))
sock.listen(5)
print("Waiting for connection")
while True:
conn, addr = sock.accept()
print("connected to:" + addr[0] + ":" + str(addr[1]))
t_server = Server(conn)
t_server.start() | jeffnb/python-intermediate | foster-city/visa-python/fib_class.py | fib_class.py | py | 818 | python | en | code | 0 | github-code | 13 |
2074506517 | """
Author Jianzhe Lin
May.2, 2020
"""
from mpl_toolkits import mplot3d
import argparse
import multiprocessing
from pathlib import Path
import numpy as np
import cv2
import matplotlib.pyplot as plt
import open3d as o3d
import torch
import time
from re_id import load_pv_data, match_timestamp, judge_loc, judge_list, get_key, draw_loc
from re_id import load_extrinsics, load_rig2world_transforms, get_points_in_cam_space, match
from re_id import extract_tar_file, load_lut, DEPTH_SCALING_FACTOR, project_on_depth, extract_timestamp, cam2world
if __name__ == '__main__':
model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
parser = argparse.ArgumentParser(description='Save pcloud.')
parser.add_argument("--recording_path",
type=str,
default='C:/Users/peterlin/2022-04-15-142023',
help="Path to recording folder")
args = parser.parse_args()
sensor_name = "Depth Long Throw"
save_in_cam_space, discard_no_rgb, depth_path_suffix, disable_project_pinhole=False, False, '', False
#######read Paths#########
print("Creating files")
folder = Path(args.recording_path)
calib = r'{}_lut.bin'.format(sensor_name)
extrinsics = r'{}_extrinsics.txt'.format(sensor_name)
rig2world = r'{}_rig2world.txt'.format(sensor_name)
calib_path = folder / calib
rig2campath = folder / extrinsics
rig2world_path = folder / rig2world if not save_in_cam_space else ''
pv_info_path = sorted(folder.glob(r'*pv.txt'))
has_pv = len(list(pv_info_path)) > 0
if has_pv:
(pv_timestamps, focal_lengths, pv2world_transforms, ox,
oy, _, _) = load_pv_data(list(pv_info_path)[0])
principal_point = np.array([ox, oy])
# lookup table to extract xyz from depth
lut = load_lut(calib_path)
# from camera to rig space transformation (fixed)
rig2cam = load_extrinsics(rig2campath)
# from rig to world transformations (one per frame)
rig2world_transforms = load_rig2world_transforms(
rig2world_path) if rig2world_path != '' and Path(rig2world_path).exists() else None
depth_path = Path(folder / sensor_name)
depth_path.mkdir(exist_ok=True)
pinhole_folder = None
if has_pv:
# Create folders for pinhole projection
pinhole_folder = folder / 'pinhole_projection'
pinhole_folder.mkdir(exist_ok=True)
pinhole_folder_rgb = pinhole_folder / 'rgb'
pinhole_folder_rgb.mkdir(exist_ok=True)
pinhole_folder_depth = pinhole_folder / 'depth'
pinhole_folder_depth.mkdir(exist_ok=True)
# Extract tar only when calling the script directly
if __name__ == '__main__':
extract_tar_file(str(folder / '{}.tar'.format(sensor_name)), str(depth_path))
# Depth path suffix used for now only if we load masked AHAT
depth_paths = sorted(depth_path.glob('*[0-9]{}.pgm'.format(depth_path_suffix)))
assert len(list(depth_paths)) > 0
manager = multiprocessing.Manager()
shared_dict = manager.dict()
###########get the pv location on world coordinate#########
# load depth img
threeD_list = []
indx = 0
location_dict = {}
wh_dict = {}
patch_dict = {}
xyz_dict = []
num = [1] * 80
# flag_cnt = 0
volume = []
max_w, min_w, max_h, min_h, max_d, min_d = 0, 0, 0, 0, 0, 0
for path in depth_paths:
indx += 1
suffix = '_cam' if save_in_cam_space else ''
output_path = str(path)[:-4] + f'{suffix}.ply'
print(".", end="", flush=True)
# extract the timestamp for this frame
timestamp = extract_timestamp(path.name.replace(depth_path_suffix, ''))
img = cv2.imread(str(path), -1)
height, width = img.shape
assert len(lut) == width * height
# Get xyz points in camera space
points = get_points_in_cam_space(img, lut)
if rig2world_transforms and (timestamp in rig2world_transforms):
# if we have the transform from rig to world for this frame,
# then put the point clouds in world space
rig2world = rig2world_transforms[timestamp]
# print('Transform found for timestamp %s' % timestamp)
xyz, cam2world_transform = cam2world(points, rig2cam, rig2world)
# if flag_cnt == 0:
# cnt = 0
xyz_temp = []
width = [item[0] for item in xyz]
height = [item[1] for item in xyz]
depth = [item[2] for item in xyz]
temp_max_w, temp_min_w, temp_max_h, temp_min_h, temp_max_d, temp_min_d = max(width), min(width), max(height), min(height), max(depth), min(depth)
# for num_xyz in range(0, len(xyz)):
# arr = xyz[num_xyz]
# input_arr = np.sum(arr)
# if input_arr in xyz_dict:
# continue
# xyz_dict.append(input_arr)
# cnt += 1
id_list = []
name_list = []
if location_dict:
for k, v in location_dict.items():
id_list.append(get_key(xyz, v))
name_list.append(k)
rgb = None
if has_pv:
# if we have pv, get vertex colors
# get the pv frame which is closest in time
target_id = match_timestamp(timestamp, pv_timestamps)
pv_ts = pv_timestamps[target_id]
rgb_path = str(folder / 'PV' / f'{pv_ts}.png')
assert Path(rgb_path).exists()
pv_img = cv2.imread(rgb_path)
h, w, c = pv_img.shape
src3 = np.zeros((h, w, c), np.uint8)#use to record
src3.fill(255)
fig = plt.figure()
ax = plt.axes(projection='3d')
# print(cnt)
#first Step Detection###########
if temp_max_d - max_d > 0 or temp_max_h - max_h > 0 or temp_max_w - max_w > 0 or min_d - temp_min_d > 0 or min_h - temp_min_h > 0 or min_w - temp_min_w > 0:
flag_cnt = 0
else:
flag_cnt = 1
max_d, max_h, max_w = max(temp_max_d, max_d), max(temp_max_h, max_h), max(temp_max_w, max_w)
min_d, min_h, min_w = min(temp_min_d, min_d), min(temp_min_h, min_h), min(temp_min_w, min_w)
points, pv2world_transform, focal_length = xyz, pv2world_transforms[target_id], focal_lengths[target_id]
#Second step: Project from depth to pv via world space, and in return get the 3D location on world space
homog_points = np.hstack((points, np.ones(len(points)).reshape((-1, 1))))
world2pv_transform = np.linalg.inv(pv2world_transform)
points_pv = (world2pv_transform @ homog_points.T).T[:, :3]
intrinsic_matrix = np.array([[focal_length[0], 0, principal_point[0]], [
0, focal_length[1], principal_point[1]], [0, 0, 1]])
rvec = np.zeros(3)
tvec = np.zeros(3)
xy, _ = cv2.projectPoints(points_pv, rvec, tvec, intrinsic_matrix, None)
xy = np.squeeze(xy)
xy[:, 0] = w - xy[:, 0]
########get xy for each 3D points on world space#####
xy_0 = np.around(xy).astype(int)
rgb = np.zeros_like(points)
###due to the coordinate mismatch between depth and rgb, need to remove outside ids###
width_check = np.logical_and(0 <= xy_0[:, 0], xy_0[:, 0] < w)
height_check = np.logical_and(0 <= xy_0[:, 1], xy_0[:, 1] < h)
valid_ids = np.where(np.logical_and(width_check, height_check))[0]
z = points_pv[valid_ids, 2]
xy = xy_0[valid_ids, :]
res_patch_num = 0
id_list_adjusted = []
for i in range(len(id_list)):
num_id = 0
if len(id_list[i][np.in1d(id_list[i], valid_ids)]) == 0:
id_temp = 1
else:
id_temp = id_list[i][np.in1d(id_list[i], valid_ids)][0]
if id_temp is not None:
id_list_adjusted.append(id_temp)
loc = xy_0[id_temp]
name = name_list[i]
res_patch_num += match(pv_img, name, loc, patch_dict[name], wh_dict[name])
else:
flag_cnt = 0
break
# for j in range(len(id_list[i])):
# if id_list[i][j] in valid_ids:
# id_list_adjusted.append(id_list[i][j])
# loc = xy_0[id_list_adjusted[i]]
# name = name_list[i]
# # res_patch_num += match(pv_img, name, loc, patch_dict[name], wh_dict[name])
# num_id += 1
# break
# if num_id == 0:
# flag_cnt = 0
# break
# print(flag_cnt)
# print(id_list)
# print(res_patch_num == len(id_list))
# if flag_cnt and id_list and res_patch_num == len(id_list):
flag_seen = 0
# print(res_patch_num == len(id_list))
if flag_cnt and id_list and res_patch_num == len(id_list):
# if flag_cnt and id_list:
print('re_id')
for i in range(len(id_list)):
loc = xy_0[id_list_adjusted[i]]
name = name_list[i]
threeD_loc = xyz[id_list_adjusted[i]]
src = pv_img
for k, v in location_dict.items():
text = "{}!".format(str(name))
cv2.putText(src, text, (loc[0]-20, loc[1]-20), cv2.FONT_HERSHEY_COMPLEX, 0.7, (199,21,133), 2)
else:
print('detect')
results = model(pv_img.copy())
for result in results.xywhn[0]:
name = results.names[int(result[5])]
loc = [int(result[0]*w), int(result[1]*h)]
if loc is not None:
threeD_loc = judge_loc(loc, xy, valid_ids, points)
src = pv_img
if threeD_loc[0] != 0 and threeD_loc[1] != 0 and threeD_loc[2] != 0:
if name not in location_dict:
location_dict[name] = threeD_loc
wh_dict[name] = [int(result[2]*w), int(result[3]*h)]
patch_dict[name] = src[int((result[1]-result[3]/2)*h):int((result[1]+result[3]/2)*h), int((result[0]-result[2]/2)*w):int((result[0]+result[2]/2)*w)]
else:
text_all = []
for k, v in location_dict.items():
threeD_list_bool = judge_list(v, threeD_loc)
if threeD_list_bool:
text = "{}!".format(str(name))
if text not in text_all:
cv2.putText(src, text, (loc[0]-20, loc[1]-20), cv2.FONT_HERSHEY_COMPLEX, 1, (199,21,133), 2)
text_all.append(text)
if result==None:
pt_lefttop = [int(loc[0]-wh_dict[name][0]/2), int(loc[1]-wh_dict[name][1]/2)]
pt_rightbottom = [int(loc[0]+wh_dict[name][0]/2), int(loc[1]+wh_dict[name][1]/2)]
else:
pt_lefttop = [int((result[0]-result[2]/2)*w), int((result[1]-result[3]/2)*h)]
pt_rightbottom = [int((result[0]+result[2]/2)*w), int((result[1]+result[3]/2)*h)]
point_color = (0, 255, 0)
cv2.rectangle(src, tuple(pt_lefttop), tuple(pt_rightbottom), point_color, 2, 4)
flag_seen += 1
break
if not threeD_list_bool:
num[int(result[5])] += 1
name = name + '_' + str(num[int(result[5])])
location_dict[name] = threeD_loc
wh_dict[name] = [int(result[2]*w), int(result[3]*h)]
patch_dict[name] = src[int((result[0]-result[2]/2)*w):int((result[0]+result[2]/2)*w), int((result[1]-result[3]/2)*h):int((result[1]+result[3]/2)*h)]
ax.set_xlim((-4, 1))
ax.set_ylim((-4, 1))
ax.set_zlim((-4, 1))
flag = 0
for name, loc in location_dict.items():
flag += 1
ax.scatter(round(loc[0],3), round(loc[1],3), round(loc[2],3), marker='^')
ax.text(round(loc[0],3), round(loc[1],3), round(loc[2],3), name, fontsize=9)
text = str(name) + " : [" + str(round(loc[0],3)) + ',' + str(round(loc[1],3)) + ',' + str(round(loc[2],3)) + ']'
x = 20 + 300*(flag//10)
y = 20 + 40*(flag % 10)
cv2.putText(src3, text, (x, y), cv2.FONT_HERSHEY_COMPLEX, 0.8, (100, 200, 200), 1)
file_name = 'C:/Users/peterlin/ptg-alphatesting/rgb_3D.jpg'
plt.savefig(file_name,dpi = 96)
src_temp = cv2.imread(file_name)
src4 = cv2.resize(src_temp, (760, 428))
results.files = [str(indx) + '.jpg']
# cv2.imwrite('C:/Users/peterlin/ptg-alphatesting/rgb_results_2022_05_03/' + results.files[0], results.imgs[0])
results.save('C:/Users/peterlin/ptg-alphatesting/rgb_results_2022_04_20/')
src2 = cv2.imread('C:/Users/peterlin/ptg-alphatesting/rgb_results_2022_04_20/' + str(indx) + '.jpg')
# cv2.imshow('img22',src2)
# cv2.waitKey(0)
# cv2.destroyAllWindows()
img = np.hstack([src, src2])
img2 = np.hstack([src3, src4])
img_out = np.vstack([img, img2])
print(indx)
cv2.imwrite('C:/Users/peterlin/ptg-alphatesting/rgb_results_combined_2022_04_20/' + str(indx) + '.jpg', img_out)
| VIDA-NYU/ptgctl | examples/re_identification.py | re_identification.py | py | 15,306 | python | en | code | 0 | github-code | 13 |
4210525330 | from typing import List
class Solution:
def minFallingPathSum(self, matrix: List[List[int]]) -> int:
for i in reversed(range(0, len(matrix) - 1)):
for j in range(0, len(matrix[0])):
min_value = min(matrix[i + 1][j], matrix[i + 1][max(j - 1, 0)], matrix[i + 1][min(j + 1, len(matrix[0]) - 1)])
matrix[i][j] += min_value
return min(matrix[0])
print(Solution().minFallingPathSum([[2, 1, 3], [6, 5, 4], [7, 8, 9]]))
print(Solution().minFallingPathSum([[-19, 57], [-40, -5]]))
print(Solution().minFallingPathSum([[100, -42, -46, -41], [31, 97, 10, -10], [-58, -51, 82, 89], [51, 81, 69, -51]]))
| mhasan09/leetCode_M | min_falling_path_sum.py | min_falling_path_sum.py | py | 658 | python | en | code | 0 | github-code | 13 |
31935472902 | #!/usr/bin/python
### IMPORT
import os
import os.path
import sys
### GLOBAL VARIABLES
# Location of the path that will contain the scripts for this phase
# i.e. /home/user/project/scripts/variants_individual/
scriptsDir = sys.argv[1]
# Location of folder containing the BAM files to be genotyped and unified
# i.e. /home/user/project/data/reads_recalibrate/
bamListPath = sys.argv[2]
# Path to store log and intermediate files
# i.e. /home/user/project/logs/variants_individual/
logPath = sys.argv[3]
# Storage location of the genotyped files
# i.e. /home/user/project/data/variants_individual/
dataSavePath = sys.argv[4]
# Path to the reference genome in format. In the same directory its dictionary
# and index (fai) need to be stored
# i.e. /home/user/project/study-specs/referenceGenome/Homo_sapiens_assembly38.fasta
refPath = sys.argv[5]
# Number of batches
batchAmount = sys.argv[6]
# Identifier of the samples in the bamDir folder
bamListTemp = open(bamListPath, "r").read()
bamFilesPath = bamListTemp.split("\n")
sampleInfo = []
for i in bamFilesPath:
if i == "":
pass
else:
info = []
fileName = i.split('/')
info.append('/'.join(fileName))
sampleName = fileName[-1].split('.')
info.append('.'.join(sampleName[:-1]))
sampleInfo.append(info)
# Location to save generated slurm script
# i.e. /home/user/project/scripts/variants_individual/shScripts/
shScriptDirName = scriptsDir + "/shScripts/"
# Location to save generated scripts list
# i.e. /home/user/project/scripts/variants_individual/jobLists
joblistsDirName = scriptsDir + "/jobLists/"
# Location to save generated slurm script
# i.e. /home/user/project/scripts/variants_individual/slurm/
slurmDirName = scriptsDir + "/slurm/"
# Location of the GVCF file map
# i.e. /home/user/project/logs/variants_individual/gvcfMap.tsv
gvcfMapPath = logPath + "gvcfMap.tsv"
#Path to sh job list
# i.e. /home/user/project/scripts/variants_individual/jobLists/jobList.txt
jobFilePath = joblistsDirName + "jobList.txt"
##MAKE DIRECTORIES
# i.e. /home/user/project/scripts/variants_individual/shScripts/
if (not os.path.isdir(shScriptDirName)):
os.mkdir(shScriptDirName)
# i.e. /home/user/project/scripts/variants_individual/jobLists/
if (not os.path.isdir(joblistsDirName)):
os.mkdir(joblistsDirName)
# i.e. /home/user/project/scripts/variants_individual/slurm/
if (not os.path.isdir(slurmDirName)):
os.mkdir(slurmDirName)
### FUNCTION DEFINITIONS
shScriptPathList = []
def createScripts(info):
# Create the shell script file
bamFilePath = info[0]
bamID = info[1]
shScriptPath = shScriptDirName + bamID + ".sh"
shScriptPathList.append(shScriptPath)
individualGVCFFilePath = dataSavePath + bamID + ".gvcf.gz"
haploCallLogPath = logPath + bamID + "_haploCall.log"
sha256sumLogPath = logPath + "sha256sum.log"
md5sumLogPath = logPath + "md5sum.log"
shellFile = open(shScriptPath, "w")
# Write to the file
shellFile.write("#!/bin/bash\n\n")
shellFile.write("start=`date +%s`\n")
shellFile.write("start_moment=$(date)\n")
shellFile.write("echo Operation gatk HaplotypeCaller starts $(date) " + bamID + "\n")
shellFile.write('gatk --java-options "-Xmx4g" HaplotypeCaller -ERC GVCF -R ' + refPath + " -I " + bamFilePath + " -O " + individualGVCFFilePath + " -G StandardAnnotation -G StandardHCAnnotation &> " + haploCallLogPath + "\n")
shellFile.write("echo Operation sha256sum starts $(date) " + bamID + "\n")
shellFile.write("sha256sum " + individualGVCFFilePath + " >> " + sha256sumLogPath + "\n")
shellFile.write("echo Operation md5sum starts $(date) " + bamID + "\n")
shellFile.write("md5sum " + individualGVCFFilePath + " >> " + md5sumLogPath + "\n")
shellFile.write("end=`date +%s`\n")
shellFile.write("end_moment=$(date)\n")
shellFile.write("echo Job for " + bamID + " started on $start_moment and ended at $end_moment - Total time: $((end-start)) \n")
shellFile.close()
os.chmod(shScriptPath, 0o744)
def makeJobListFiles(batchAmount):
sliceLen = len(shScriptPathList) // int(batchAmount)
residue = len(shScriptPathList) % int(batchAmount)
for i in range(1, int(batchAmount) + 1 + residue ** 0):
batch = shScriptPathList[((i - 1) * sliceLen):(i * sliceLen)]
jobFilePath = joblistsDirName + "/JobList_" + str(i) + ".txt"
jobListFile = open(jobFilePath, "w")
for e in batch:
jobListFile.write(e + "\n")
jobListFile.close()
# Generate a slurm file for the scripts mentioned in the JobListFile
def makeslurmJobFiles(batchAmount):
residue = len(shScriptPathList) % int(batchAmount)
for i in range(1, int(batchAmount) + 1 + residue ** 0):
jobFilePath = joblistsDirName + "/JobList_" + str(i) + ".txt"
slurmFile = open(slurmDirName + "/variants_individual_" + str(i) + ".slurm", "w")
slurmFile.write("#!/bin/bash\n\n")
slurmFile.write("#SBATCH --partition=parallel\n")
slurmFile.write("#SBATCH --time=80:00:00\n")
slurmFile.write("#SBATCH --nodes=1\n")
slurmFile.write("#SBATCH --ntasks-per-node=20\n")
slurmFile.write("#SBATCH --job-name=variants_individual_" + str(i) + "\n")
slurmFile.write("#SBATCH --output=" + logPath + "/variants_individual_slurm_" + str(i) + ".log\n")
slurmFile.write("#SBATCH --mail-type=END,FAIL\n")
slurmFile.write("#SBATCH --mail-user=user@email.com\n\n")
slurmFile.write("module load gatk-4.2.5.0\n")
slurmFile.write("export OMP_NUM_THREADS=6\n")
slurmFile.write("export LANG=C\n")
slurmFile.write("conda activate bioinfo\n\n")
slurmFile.write("echo Start time: $(date)\n")
slurmFile.write("parallel=\"parallel --delay .2 -j 6 --joblog " + logPath + "/variants_individual_parallel_" + str(i) + ".log --resume\"\n")
slurmFile.write("$parallel < " + jobFilePath + "\n")
slurmFile.write("echo End time: $(date)\n")
slurmFile.close()
### IMPLEMENTATION
bamListTemp = open(bamListPath, "r").read()
bamFilesPath = bamListTemp.split("\n")
#Create shell scripts
for i in sampleInfo:
createScripts(i)
# Create job list
makeJobListFiles(batchAmount)
# Create slurm file
makeslurmJobFiles(batchAmount)
| jcvalverdehernandez/cr_dislipidemia_2022 | post__variant_call_workflow_slurm/variants_individual/variants_individual.py | variants_individual.py | py | 6,310 | python | en | code | 0 | github-code | 13 |
16773944453 | # (1, 골2) bfs_Codetree_색깔폭탄
import heapq
# n * n
# === input ===
N, M = map(int, input().split())
board = [list(map(int, input().split())) for _ in range(N)]
EMPTY, BLACK, RED = -2, -1, 0
# === algorithm ===
# 1. max(폭탄 묶음) 제거됨
# 2개 이상의 폭탄
# 모두 같은 색깔이거나, 빨간색을 포함
# 빨간색만으로 이루어지면 안 됨!
# 2. min(red)
# 3. max(r) *기준점: not RED, max(r), min(c)
# 4. min(c)
def remove_bomb() -> int:
global board
def find_bomb():
# (폭탄 개수, 빨간 색 개수, -r, c)
bomb_pq = []
visited = [[False]*N for _ in range(N)]
def bfs(start):
# 2개
queue = [start]
visited[start[0]][start[1]] = True
color = board[start[0]][start[1]]
bomb_list = [start]
while queue:
curr_r, curr_c = queue.pop(0)
for dr, dc in [[-1, 0], [0, -1], [1, 0], [0, 1]]:
nr, nc = curr_r + dr, curr_c + dc
if 0 <= nr < N and 0 <= nc < N and not visited[nr][nc]:
if board[nr][nc] == RED or board[nr][nc] == color:
queue.append([nr, nc])
visited[nr][nc] = True
bomb_list.append((nr, nc))
# TODO: RED 표시 복구, pq에 넣어주기
num_red = 0
for tr, tc in bomb_list:
if board[tr][tc] == RED:
visited[tr][tc] = False
num_red += 1
if len(bomb_list) >= 2:
bomb_pq.append((-len(bomb_list), num_red, -start[0], start[1], bomb_list))
# red -> 깍두기, red부터 시작 불가능
for r in range(N - 1, -1, -1):
for c in range(N):
if not visited[r][c] and board[r][c] > 0:
bfs([r, c])
heapq.heapify(bomb_pq)
if bomb_pq:
return bomb_pq[0][4]
else:
return []
removed = find_bomb()
for br, bc in removed:
board[br][bc] = EMPTY
print_debug("remove")
return len(removed) ** 2
# 2. 중력 작용
def gravity():
global board
for c in range(N):
floor = N - 1
for r in range(N - 1, -1, -1):
# BLACK은 안 움직임
if board[r][c] == BLACK:
floor = r - 1
# 폭탄은 떨어진다
elif board[r][c] != EMPTY:
if floor == r:
floor -= 1
else:
board[floor][c] = board[r][c]
board[r][c] = EMPTY
floor -= 1
print_debug("gravity")
# 3. 반시계 회전
def rotate():
global board
new_board = [[-2]*N for _ in range(N)]
for r in range(N):
for c in range(N):
new_board[(N - 1) - c][r] = board[r][c]
board = new_board
print_debug("rotate")
# 4. 중력 작용
# 5. 점수: 제거된 돌
def print_debug(title=""):
if debug:
print("=======================")
print(title)
for r in range(N):
print(*board[r])
print("=======================")
# === output ===
debug = False
# ans: 최종 점수
ans = 0
while True:
score = remove_bomb()
if score == 0:
break
ans += score
gravity()
rotate()
gravity()
print(ans)
| 1092soobin2/Algorithm-Study | bfs,dfs/(1, 골2) bfs_Codetree_색깔폭탄.py | (1, 골2) bfs_Codetree_색깔폭탄.py | py | 3,619 | python | en | code | 1 | github-code | 13 |
7644105778 | from django.urls import path
from . import views
urlpatterns = [
path('',views.vehicle_list,name='vehicle_list'),
path('vehicle_detail/<int:vehicle_id>/',views.vehicle_detail,name='vehicle_detail'),
path('vehicle_create/', views.vehicle_create, name='vehicle_create'),
path('vehicle_update/<int:vehicle_id>/', views.vehicle_update, name='vehicle_update'),
path('vehicle_delete/<int:vehicle_id>/', views.vehicle_delete, name='vehicle_delete'),
] | SwetharajKP/Vehicle_Management | VMS/vehicles/urls.py | urls.py | py | 465 | python | en | code | 0 | github-code | 13 |
19609761193 | from turtle import *
def blank_face():
color('wheat')
begin_fill()
circle(radius=50)
end_fill()
penup()
def next():
penup()
forward(150)
pendown()
def eyes(shape):
x, y = pos()
left(90)
forward(55)
left(90)
forward(30)
pendown()
color('black')
if shape == 'extreme':
write('>', font=15)
penup()
right(180)
forward(50)
pendown()
write('<', font=15)
elif shape == 'bored':
write('=', font=15)
penup()
right(180)
forward(50)
pendown()
write('=', font=15)
elif shape == 'rich':
write('$', font=15)
penup()
right(180)
forward(50)
pendown()
write('$', font=15)
elif shape == 'confused':
write('@', font=15)
penup()
right(180)
forward(50)
pendown()
write('@', font=15)
else: # normal
write('.', font=15)
penup()
right(180)
forward(50)
pendown()
write('.', font=15)
penup()
setx(x)
sety(y)
setheading(0)
def mouth(shape):
x, y = pos()
left(90)
forward(25)
left(90)
forward(5)
pendown()
color('black')
if shape == 'average':
write('_', font=15)
elif shape == 'sad':
write('∩', font=20)
else: # happy
write('U', font=15)
penup()
setx(x)
sety(y)
setheading(0)
penup()
setx(-300)
pendown()
while True:
input = textinput('Game', 'Do you want to draw your face(yes or no)? ').lower()
if input == 'no':
break
eyes_user = textinput('Eye', 'What do your eyes look like(normal, extreme, bored, rich, or confused)? ').lower()
mouth_user = textinput('Mouth', 'What does your mouth look like(happy, sad, or average)? ').lower()
blank_face()
eyes(eyes_user)
mouth(mouth_user)
next()
done() | zhahchun/information_processing_retrieval | w04/Stu04/emoji.py | emoji.py | py | 1,970 | python | en | code | 0 | github-code | 13 |
73468263697 |
import sys
class User:
name = ""
def __init__(self, name):
self.name = name
def sayHello(self):
print("Hello my name is " + self.name)
def sayBye(self):
print("Goodbye!!!!")
james = User("MANGA")
david = User("David")
eric = User("Eric")
james.sayHello()
david.sayHello()
eric.sayHello()
print("Type exit to close program")
leave = input()
if leave == "exit":
sys.exit()
else:
print("Program cannot close")
| BarringtonT/test | PythonTestFiles/user.py | user.py | py | 466 | python | en | code | 0 | github-code | 13 |
17800569314 | # encoding: utf-8
"""Unit test suite for histolab.util module."""
import operator
import numpy as np
import pytest
from tests.base import (
COMPLEX_MASK,
IMAGE1_GRAY,
IMAGE1_RGB,
IMAGE1_RGBA,
IMAGE2_GRAY,
IMAGE2_RGB,
IMAGE2_RGBA,
IMAGE3_GRAY_BLACK,
IMAGE3_RGB_BLACK,
IMAGE3_RGBA_BLACK,
IMAGE4_GRAY_WHITE,
IMAGE4_RGB_WHITE,
IMAGE4_RGBA_WHITE,
)
from histolab.types import CP, Region
from histolab.util import (
apply_mask_image,
lazyproperty,
np_to_pil,
random_choice_true_mask2d,
rectangle_to_mask,
region_coordinates,
regions_to_binary_mask,
scale_coordinates,
threshold_to_mask,
)
from ..fixtures import MASKNPY, NPY
from ..util import load_expectation, load_python_expression
@pytest.mark.parametrize(
"ref_coords, ref_size, target_size, expected_value",
(
(CP(0, 2, 4, 5), (10, 10), (5, 5), (0, 1, 2, 2)),
(CP(90, 112, 124, 125), (100, 100), (95, 95), (85, 106, 117, 118)),
),
)
def test_scale_coordinates(ref_coords, ref_size, target_size, expected_value):
x_ul, y_ul, x_br, y_br = expected_value
scaled_coords = scale_coordinates(ref_coords, ref_size, target_size)
assert scaled_coords == CP(x_ul, y_ul, x_br, y_br)
@pytest.mark.parametrize(
"img_array, expected_mode, expected_size, expected_type, expected_array",
(
(NPY.NP_TO_PIL_L, "L", (2, 2), np.uint8, "python-expr/np-to-pil-l"),
(NPY.NP_TO_PIL_LA, "LA", (2, 2), np.uint8, "python-expr/np-to-pil-la"),
(NPY.NP_TO_PIL_RGBA, "RGBA", (4, 4), np.uint8, "python-expr/np-to-pil-rgba"),
),
)
def test_util_np_to_pil(
img_array, expected_mode, expected_size, expected_type, expected_array
):
pil_img = np_to_pil(img_array)
assert pil_img.mode == expected_mode
assert pil_img.size == expected_size
assert np.array(pil_img).dtype == expected_type
np.testing.assert_array_almost_equal(
np.array(pil_img), load_python_expression(expected_array)
)
@pytest.mark.parametrize(
"img, threshold, relate, expected_array",
(
(IMAGE1_GRAY, 160, operator.gt, "python-expr/threshold-to-mask-160"),
(IMAGE2_GRAY, 140, operator.lt, "python-expr/threshold-to-mask-140"),
(IMAGE3_GRAY_BLACK, 0, operator.gt, "python-expr/5-x-5-zeros"),
(IMAGE3_GRAY_BLACK, 0, operator.lt, "python-expr/5-x-5-zeros"),
(IMAGE3_GRAY_BLACK, 1, operator.lt, "python-expr/5-x-5-ones"),
(IMAGE4_GRAY_WHITE, 0, operator.gt, "python-expr/5-x-5-ones"),
(IMAGE4_GRAY_WHITE, 1, operator.lt, "python-expr/5-x-5-zeros"),
(IMAGE1_RGB, 200, operator.lt, "python-expr/threshold-to-mask-200"),
(IMAGE2_RGB, 39, operator.gt, "python-expr/threshold-to-mask-39"),
(IMAGE3_RGB_BLACK, 0, operator.gt, "python-expr/5-x-5-x-3-zeros"),
(IMAGE3_RGB_BLACK, 0, operator.lt, "python-expr/5-x-5-x-3-zeros"),
(IMAGE3_RGB_BLACK, 1, operator.lt, "python-expr/5-x-5-x-3-ones"),
(IMAGE4_RGB_WHITE, 0, operator.gt, "python-expr/5-x-5-x-3-ones"),
(IMAGE4_RGB_WHITE, 1, operator.lt, "python-expr/5-x-5-x-3-zeros"),
(IMAGE1_RGBA, 178, operator.gt, "python-expr/threshold-to-mask-178"),
(IMAGE2_RGBA, 37, operator.lt, "python-expr/threshold-to-mask-37"),
(IMAGE3_RGBA_BLACK, 2, operator.gt, "python-expr/5-x-5-x-4-zeros"),
(IMAGE3_RGBA_BLACK, 0, operator.lt, "python-expr/5-x-5-x-4-zeros"),
(IMAGE3_RGBA_BLACK, 1, operator.lt, "python-expr/5-x-5-x-4-ones"),
(IMAGE4_RGBA_WHITE, 0, operator.gt, "python-expr/5-x-5-x-4-ones"),
(IMAGE4_RGBA_WHITE, 1, operator.lt, "python-expr/5-x-5-x-4-zeros"),
),
)
def test_util_threshold_to_mask(img, threshold, relate, expected_array):
mask = threshold_to_mask(np_to_pil(img), threshold, relate)
np.testing.assert_array_equal(mask, load_python_expression(expected_array))
@pytest.mark.parametrize(
"img, mask, expected_array",
(
(
NPY.APPLY_MASK_IMAGE_F1,
MASKNPY.APPLY_MASK_IMAGE_F1,
"python-expr/apply-mask-image-exp1",
),
(
NPY.APPLY_MASK_IMAGE_F2,
MASKNPY.APPLY_MASK_IMAGE_F2,
"python-expr/apply-mask-image-exp2",
),
(
NPY.APPLY_MASK_IMAGE_F3,
MASKNPY.APPLY_MASK_IMAGE_F3,
"python-expr/apply-mask-image-exp3",
),
(
NPY.APPLY_MASK_IMAGE_F4,
MASKNPY.APPLY_MASK_IMAGE_F4,
"python-expr/apply-mask-image-exp4",
),
),
)
def test_apply_mask_image(img, mask, expected_array):
masked_image = apply_mask_image(img, mask)
np.testing.assert_array_almost_equal(
np.array(masked_image), load_python_expression(expected_array)
)
@pytest.mark.parametrize(
"dims, vertices, expected_array",
(
((5, 5), CP(0, 3, 2, 5), "mask-arrays/polygon-to-mask-array-0325"),
((5, 6), CP(1, 0, 2, 0), "mask-arrays/polygon-to-mask-array-1020"),
((5, 5), CP(2, 1, 4, 3), "mask-arrays/polygon-to-mask-array-2143"),
),
)
def test_util_rectangle_to_mask(dims, vertices, expected_array):
rectangle_mask = rectangle_to_mask(dims, vertices)
assert rectangle_mask.shape == dims
np.testing.assert_array_almost_equal(
rectangle_mask, load_expectation(expected_array, type_="npy")
)
def test_region_coordinates():
region = Region(index=0, area=14, bbox=(0, 1, 1, 2), center=(0.5, 0.5), coords=None)
region_coords_ = region_coordinates(region)
assert region_coords_ == CP(x_ul=1, y_ul=0, x_br=2, y_br=1)
@pytest.mark.parametrize("seed", [(i,) for i in range(10)])
def test_random_choice_true_mask2d(seed):
np.random.seed(seed)
x, y = random_choice_true_mask2d(COMPLEX_MASK)
assert COMPLEX_MASK[x, y]
def test_regions_to_binary_mask():
regions = [
Region(
index=None,
area=None,
bbox=None,
center=None,
coords=np.array([[1, 3], [2, 3], [3, 2], [3, 3]]),
),
Region(
index=None,
area=None,
bbox=None,
center=None,
coords=np.array([[3, 7], [4, 7], [4, 8]]),
),
]
binary_mask_regions = regions_to_binary_mask(regions, dims=(10, 10))
assert type(binary_mask_regions) == np.ndarray
assert binary_mask_regions.dtype == bool
np.testing.assert_array_almost_equal(
binary_mask_regions,
load_expectation("mask-arrays/regions-to-binary-mask", type_="npy"),
)
class DescribeLazyPropertyDecorator:
"""Tests @lazyproperty decorator class."""
def it_is_a_property_object_on_class_access(self, Obj):
assert isinstance(Obj.fget, property)
def and_it_adopts_the_docstring_of_the_decorated_method(self, Obj):
assert Obj.fget.__doc__ == "Docstring of Obj.fget method definition."
def it_only_calculates_value_on_first_call(self, obj):
assert obj.fget == 1
assert obj.fget == 1
def it_raises_on_attempt_to_assign(self, obj):
assert obj.fget == 1
with pytest.raises(AttributeError):
obj.fget = 42
assert obj.fget == 1
assert obj.fget == 1
# fixture components ---------------------------------------------
@pytest.fixture
def Obj(self):
class Obj:
@lazyproperty
def fget(self):
"""Docstring of Obj.fget method definition."""
if not hasattr(self, "_n"):
self._n = 0
self._n += 1
return self._n
return Obj
@pytest.fixture
def obj(self, Obj):
return Obj()
| nsmdgr/histolab | tests/unit/test_util.py | test_util.py | py | 7,699 | python | en | code | 0 | github-code | 13 |
34357336582 | # This program is responsible for searching an e-mails and phone numbers in clipboard
import re, pyperclip
# This block of code contain a model to find phone numbers
phone_model = re.compile(r'''(
(\+(\d{2})|(\d){4})? # Phone code
((\s)|\-)? # separator - white sign or dash
(\d{3}) # 3 first numbers
((\s)|\-)? # separator - white sign or dash
(\d{3}) # Numbers from 4th to 6th
((\s)|\-)? # separator - white sign or dash
(\d{3}) # Numbers from 7th to 9th
)''', re.VERBOSE)
# Code containing a model to find e-mail address
email_model = re.compile(r'''(
[a-zA-Z0-9._%+-]+
@
[a-zA-Z0-9.-]+
\.
[a-zA-Z]{2,4}
)''', re.VERBOSE)
# Code block looking for matches in clipboard
text = str(pyperclip.paste())
matches = []
for groups in phone_model.findall(text):
matches.append(groups[0])
for groups in email_model.findall((text)):
matches.append(groups[0])
# Showing results from the clipboard
if len(matches) > 0:
pyperclip.copy('\n'.join(matches))
print("Copied to the clipboard")
print('\n'.join(matches))
else:
print('I don`t find any e-mail adress and phone number.')
| lenncb/E-mail-adresses-and-phone-numbers-searcher | email_and_phonenum_searcher.py | email_and_phonenum_searcher.py | py | 1,284 | python | en | code | 0 | github-code | 13 |
36322653083 | from typing import Any, List
def loopy_madness_with_while_loops(string1: str, string2: str) -> str:
"""
The exact same function as loopy_madness from Lab 5, but we ask that you
change any for loops that you used to while loops. Refer back to Lab 5 for
the specifications of this function.
"""
inter = ''
if len(string1) <= len(string2):
str3 = string1[::-1][1:]
str4 = string1[1:]
while len(string1) < len(string2) and len(string1) > 1:
string1 += str3 + str4
string1 = string1 * len(string2)
i=0
while i<len(string2):
inter += string1[i] + string2[i]
i+=1
elif len(string1) > len(string2):
str3 = string2[::-1][1:]
str4 = string2[1:]
while len(string2) < len(string1) and len(string2) > 1:
string2 += str3 + str4
string2 = string2 * len(string1)
i=0
while i<len(string1):
inter += string1[i] + string2[i]
i+=1
return inter
def longest_chain(lst: List[int]) -> int:
i=0
length = 0
while i<len(lst):
if lst[i] == 1:
length +=1
elif lst[i] == 0:
return length
i+=1
return length
def count_types(lst: List[Any]) -> List[int]:
i = 0
lst1 = []
lst2 = []
while i < len(lst):
if (type(lst[i])) not in lst2:
lst2.append(type(lst[i]))
lst1.append(1)
else:
lst1[lst2.index(type(lst[i]))] += 1
i += 1
return lst1
def second_largest(lst: List[int]) -> int:
i = 1
while len(lst) - 1 >= i:
j = len(lst) - 1
while j >= i:
if lst[j] < lst[j - 1]:
lst[j], lst[j - 1] = lst[j - 1], lst[j]
j -= 1
i += 1
return lst[-2]
| initialencounter/code | Python/SCS/lab6.py | lab6.py | py | 1,824 | python | en | code | 0 | github-code | 13 |
74076921936 | import os
import cv2
from piepline import BasicDataset
from pietoolbelt.datasets.common import get_root_by_env
class LIP(BasicDataset):
def __init__(self):
root = get_root_by_env('LIP_DATASET')
items = []
for set_dir in ['train', 'val']:
cur_images_dir = os.path.join(root, set_dir + '_images')
cur_annos_dir = os.path.join(root, set_dir + '_segmentations')
for img_file in os.listdir(cur_images_dir):
mask_file = os.path.splitext(img_file)[0] + '.png'
items.append({'data': os.path.join(cur_images_dir, img_file), 'target': os.path.join(cur_annos_dir, mask_file)})
super().__init__(items)
def _interpret_item(self, item) -> any:
img = cv2.imread(item['data'])
mask = cv2.imread(item['target'], cv2.IMREAD_UNCHANGED)
mask[mask > 0] = 1
return {'data': cv2.cvtColor(img, cv2.COLOR_BGR2RGB), 'target': mask}
| HumanParsingSDK/datasets | human_datasets/lip.py | lip.py | py | 952 | python | en | code | 2 | github-code | 13 |
15320287284 | import os
import tensorflow as tf
# Désactiver les avertissements de niveau inférieur de TensorFlow
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' # 3 = FATAL
tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
from keras.models import load_model
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
# Fonction pour charger et prétraiter les images
def preprocess_images(images, image_size=48):
''' Convertir les images en un format utilisable pour le CNN '''
num_pixels = image_size * image_size
images = images / 255.0 # Normalisation
images = images.reshape(-1, image_size, image_size, 1) # Redimensionnement
return images
# Fonction pour lire et prétraiter les données
def load_and_preprocess_data(file_path, is_train=True):
data = pd.read_csv(file_path)
# Séparer les pixels par des espaces et les convertir en entiers
pixels = data['pixels'].apply(lambda x: [int(pixel) for pixel in x.split()])
# Convertir en un tableau NumPy
images = np.vstack(pixels.values)
# Vérifier que chaque image contient 2304 pixels
if images.shape[1] != 2304:
raise ValueError(f"Chaque image doit contenir 2304 pixels, mais trouvé {images.shape[1]} pixels.")
# Redimensionner les images pour qu'elles correspondent à la forme attendue par le modèle
images = preprocess_images(images)
if is_train:
# Obtenir les étiquettes si c'est un ensemble d'entraînement
y = pd.get_dummies(data['emotion']).values
return images, y
else:
# Sinon, retourner seulement les images
return images
# Chemin vers le modèle sauvegardé
model_path = 'emotion_model.h5'
# Chemin vers le fichier de données (ajuster selon vos besoins)
data_file_path = 'filegive/test_with_emotions.csv' # Utilisez le même fichier que pour l'entraînement
# Charger et prétraiter les données
X, y = load_and_preprocess_data(data_file_path)
# Division en ensembles d'entraînement et de validation
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
# Charger le modèle
model = load_model(model_path)
# Évaluer le modèle sur l'ensemble de validation
loss, accuracy = model.evaluate(X_val, y_val)
final_num = round(accuracy * 100)
print(f"Accuracy on test set: {final_num}%")
| max260129/emotions-detector | scripts/predict.py | predict.py | py | 2,364 | python | fr | code | 0 | github-code | 13 |
28396406872 | import os
import shutil
import time
from collections import OrderedDict
import numpy as np
import torch
from torch.autograd import Variable
from torch.backends import cudnn
from torch.utils.data import DataLoader
from detect import netdef, data
from detect.data.dataset import DataBowl3Detector
from detect.data.split_combine import SplitCombine
from utils import gpu, env, file
from utils.log import get_logger
log = get_logger(__name__)
def get_file_list(args):
luna_data_dir = file.get_luna_data_path()
train_files = []
test_files = []
train_dir_count = 0
test_dir_count = 0
subset_arr = os.listdir(luna_data_dir)
list.sort(subset_arr)
for subset in subset_arr:
if not subset.startswith('subset'):
continue
arr_to_append = None
if train_dir_count < args.nd_train:
arr_to_append = train_files
train_dir_count += 1
elif test_dir_count < args.nd_test:
arr_to_append = test_files
test_dir_count += 1
if arr_to_append is None:
break
subset_dir = os.path.join(luna_data_dir, subset)
for f in os.listdir(subset_dir):
if not f.endswith('.mhd'): # TODO 没有抄黑名单
continue
file_name = os.path.join(subset, f[:-4])
arr_to_append.append(file_name)
log.info('Files for train: %s. Files for test: %s' % (len(train_files), len(test_files)))
return train_files, test_files
def get_train_loader(args, net_config):
train_files, test_files = get_file_list(args)
data_dir = env.get('preprocess_result_path')
dataset = DataBowl3Detector(
data_dir,
train_files,
net_config,
phase='train')
train_loader = DataLoader(
dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
return train_loader
def get_val_loader(args, net_config):
train_files, test_files = get_file_list(args)
data_dir = env.get('preprocess_result_path')
dataset = DataBowl3Detector(
data_dir,
test_files,
net_config,
phase='val')
val_loader = DataLoader(
dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
return val_loader
def get_learning_rate(args, epoch):
lr = args.learning_rate
if epoch <= args.epochs * 1 / 3:
lr = lr
elif epoch <= args.epochs * 2 / 3:
lr = 0.1 * lr
elif epoch <= args.epochs * 0.8:
lr = 0.05 * lr
else:
lr = 0.01 * lr
return lr
def try_resume(net, args, para: bool = False):
save_dir = file.get_net_save_dir(args)
if args.resume == 0:
args.start_epoch = 0
shutil.rmtree(save_dir, True) # 不继续 将之前的记录删掉
return
start_epoch = args.start_epoch
if start_epoch == -1:
file_list = os.listdir(save_dir)
vali_file_list = [f for f in file_list if f.endswith('.ckpt')]
vali_file_list.sort()
if len(vali_file_list) > 0:
last_file_name = vali_file_list[len(vali_file_list) - 1]
start_epoch = int(last_file_name[:-5])
file_name = file.get_net_save_file_path_name(args, start_epoch)
args.start_epoch = start_epoch
if os.path.exists(file_name):
log.info('Resuming model from: %s' % file_name)
checkpoint = torch.load(file_name)
if para:
new_state_dict = OrderedDict()
for k, v in checkpoint['state_dict'].items():
name = 'module.%s' % k # add `module.`
new_state_dict[name] = v
net.load_state_dict(new_state_dict)
else:
net.load_state_dict(checkpoint['state_dict'])
else:
log.info('No saved file. ID: %s. Epoch: %s' % (args.id, start_epoch))
def common_init(args):
gpu.set_gpu(args.gpu)
torch.manual_seed(0)
model = netdef.get_model(args.model)
config, net, loss, get_pbb = model.get_model()
try_resume(net, args)
net = torch.nn.DataParallel(net).cuda() # 使用多个GPU进行训练
loss = loss.cuda()
cudnn.benchmark = False
log.info("we have %s GPUs" % torch.cuda.device_count())
return config, net, loss, get_pbb
def run_train():
args = env.get_args()
config, net, loss, get_pbb = common_init(args)
train_loader = get_train_loader(args, config)
optimizer = torch.optim.SGD(
net.parameters(),
args.learning_rate,
momentum=0.9,
weight_decay=args.weight_decay)
for epoch in range(max(args.start_epoch + 1, 1), args.epochs + 1): # 跑完所有的epoch
train(train_loader, net, loss, epoch, optimizer, args)
def run_validate():
args = env.get_args()
config, net, loss, get_pbb = common_init(args)
args.nd_train = 0
args.nd_test = 10
val_loader = get_val_loader(args, config)
validate(val_loader, net, loss)
def train(data_loader, net, loss, epoch, optimizer, args): # 跑一个epoch
save_freq = args.save_freq
save_dir = file.get_net_save_dir(args)
start_time = time.time()
net.train()
lr = get_learning_rate(args, epoch)
for param_group in optimizer.param_groups:
param_group['lr'] = lr
metrics = []
for i, (data, target, coord) in enumerate(data_loader):
data = Variable(data.cuda(), requires_grad=True)
target = Variable(target.cuda())
coord = Variable(coord.cuda(), requires_grad=True)
output = net(data, coord)
loss_output = loss(output, target)
optimizer.zero_grad()
loss_output[0].backward()
optimizer.step()
metrics.append(normal_lost_list(loss_output))
if epoch % save_freq == 0:
state_dict = net.module.state_dict()
for key in state_dict.keys():
state_dict[key] = state_dict[key].cpu()
torch.save({
'epoch': epoch,
'save_dir': save_dir,
'state_dict': state_dict,
'args': args},
file.get_net_save_file_path_name(args, epoch))
log.info('Saved. Epoch [%d]' % epoch)
end_time = time.time()
metrics = np.asarray(metrics, np.float32)
log.info('Epoch %03d (lr %.5f)' % (epoch, lr))
log.info('Train: tpr %3.2f, tnr %3.2f, total pos %d, total neg %d, time %3.2f' % (
100.0 * np.sum(metrics[:, 6]) / np.sum(metrics[:, 7]),
100.0 * np.sum(metrics[:, 8]) / np.sum(metrics[:, 9]),
np.sum(metrics[:, 7]),
np.sum(metrics[:, 9]),
end_time - start_time))
log.info('loss %2.4f, classify loss %2.4f, regress loss %2.4f, %2.4f, %2.4f, %2.4f' % (
np.mean(metrics[:, 0]),
np.mean(metrics[:, 1]),
np.mean(metrics[:, 2]),
np.mean(metrics[:, 3]),
np.mean(metrics[:, 4]),
np.mean(metrics[:, 5])))
def validate(data_loader, net, loss):
start_time = time.time()
net.eval()
metrics = []
with torch.no_grad():
for i, (data, target, coord) in enumerate(data_loader):
data = Variable(data.cuda())
target = Variable(target.cuda())
coord = Variable(coord.cuda())
output = net(data, coord)
loss_output = loss(output, target, train=False)
metrics.append(normal_lost_list(loss_output))
end_time = time.time()
metrics = np.asarray(metrics, np.float32)
log.info('Validation: tpr %3.2f, tnr %3.2f, total pos %d, total neg %d, time %3.2f' % (
100.0 * np.sum(metrics[:, 6]) / np.sum(metrics[:, 7]),
100.0 * np.sum(metrics[:, 8]) / np.sum(metrics[:, 9]),
np.sum(metrics[:, 7]),
np.sum(metrics[:, 9]),
end_time - start_time))
log.info('loss %2.4f, classify loss %2.4f, regress loss %2.4f, %2.4f, %2.4f, %2.4f' % (
np.mean(metrics[:, 0]),
np.mean(metrics[:, 1]),
np.mean(metrics[:, 2]),
np.mean(metrics[:, 3]),
np.mean(metrics[:, 4]),
np.mean(metrics[:, 5])))
def get_test_loader(args, net_config):
train_files, test_files = get_file_list(args)
log.info(test_files)
data_dir = env.get('preprocess_result_path')
split_combine = SplitCombine(net_config['side_len'], net_config['max_stride'], net_config['stride'],
net_config['margin'], net_config['pad_value'])
dataset = DataBowl3Detector(
data_dir,
test_files,
net_config,
phase='test',
split_combine=split_combine)
test_loader = DataLoader(
dataset,
batch_size=1,
shuffle=False,
num_workers=args.workers,
collate_fn=data.collate,
pin_memory=False)
return test_loader
def run_test():
args = env.get_args()
args.resume = 1
args.nd_train = 9
args.nd_test = 1
config, net, loss, get_pbb = common_init(args)
data_loader = get_test_loader(args, config)
for ep in range(args.start_epoch, args.epochs + 1):
args.start_epoch = ep
try_resume(net, args, para=True)
save_dir = file.get_net_bbox_save_path(args, ep)
test(data_loader, net, get_pbb, args, config, save_dir)
log.info('Test Done. Epoch: %d' % ep)
def test(data_loader, net, get_pbb, args, net_config, save_dir):
net.eval()
namelist = []
split_combine = data_loader.dataset.split_combine
with torch.no_grad():
for i_name, (data, target, coord, nzhw, nzhw2) in enumerate(data_loader):
nzhw = nzhw[0]
name = data_loader.dataset.get_uid(i_name)
namelist.append(name)
data = data[0][0]
coord = coord[0][0]
output_feature = False
if 'output_feature' in net_config and net_config['output_feature']:
output_feature = True
n_per_run = args.gpu_test
split_list = list(range(0, len(data) + 1, n_per_run)) # python23 range
if split_list[-1] != len(data):
split_list.append(len(data))
output_list = []
feature_list = []
for i in range(len(split_list) - 1):
st = split_list[i]
ed = split_list[i + 1]
input = Variable(data[st:ed]).cuda()
input_coord = Variable(coord[st:ed]).cuda()
if output_feature:
output, feature = net(input, input_coord)
feature_list.append(feature.data.cpu().numpy())
else:
output = net(input, input_coord)
output_list.append(output.data.cpu().numpy())
output = np.concatenate(output_list, 0)
output = split_combine.combine(output, nzhw=nzhw)
if output_feature:
feature = np.concatenate(feature_list, 0).transpose([0, 2, 3, 4, 1])[:, :, :, :, :, np.newaxis]
feature = split_combine.combine(feature, net_config['side_len'])[..., 0]
thresh = args.testthresh # -8 #-3
# log.info(output)
log.info('output : %s' % str(output.shape))
log.info('thresh : %s' % thresh)
pbb, mask = get_pbb(output, thresh, is_mask=True)
log.info('pbb : %s' % str(pbb.shape))
log.info('max pbb ' + str(max(pbb[:, 0])))
log.info('min pbb ' + str(min(pbb[:, 0])))
if output_feature:
feature_selected = feature[mask[0], mask[1], mask[2]]
np.save(os.path.join(save_dir, '%s_feature.npy' % name), feature_selected)
np.save(os.path.join(save_dir, '%s_pbb.npy' % name), pbb)
if target is not None:
target = [np.asarray(t, np.float32) for t in target]
lbb = target[0] # batch_size=1
np.save(os.path.join(save_dir, '%s_lbb.npy' % name), lbb)
np.save(os.path.join(save_dir, 'namelist.npy'), namelist)
def normal_lost_list(tensor_list):
normal = []
for i in tensor_list:
normal.append(i.item() if isinstance(i, torch.Tensor) else i)
return normal
| simsara/LNDCML | detect/__init__.py | __init__.py | py | 12,171 | python | en | code | 1 | github-code | 13 |
33400710622 | import sys
import math
from .json_request import json_request
from urllib.parse import urlencode
from datetime import datetime
TOUR_URL_ENDPOINT = 'http://openapi.tour.go.kr/openapi/service/TourismResourceStatsService/getPchrgTrrsrtVisitorList'
ED_URL_ENDPOINT = 'http://openapi.tour.go.kr/openapi/service/EdrcntTourismStatsService/getEdrcntTourismStatsList'
def pd_gen_url(endpoint, service_key, **params):
url = '%s?%s&serviceKey=%s' % (endpoint, urlencode(params), service_key)
return url
def pd_fetch_foreign_visitor(
country_code=0,
year=0,
month=0,
service_key=''):
url = pd_gen_url(
ED_URL_ENDPOINT,
service_key,
YM='{0:04d}{1:02d}'.format(year, month),
NAT_CD=country_code,
ED_CD = 'E',
numOfRows=10,
_type='json',
pageNo=1
)
json_result = json_request(url=url)
resHeader = json_result.get('response').get('header')
if resHeader.get('resultMsg') != "OK" :
print("%s Error[%s] for request %s" % (datetime.now(), resHeader.get('resultMsg'), url))
return None
resBody = json_result.get('response').get('body')
items = None if resBody is None else resBody.get('items')
yield items.get('item') if isinstance(items, dict) else None
def pd_fetch_tourspot_visitor(
district1='',
district2='',
tourspot='',
year=0,
month=0,
service_key=''):
# v1.1 use pageno, hasnext
endpoint = 'http://openapi.tour.go.kr/openapi/service/TourismResourceStatsService/getPchrgTrrsrtVisitorList'
pageno = 1
hasnext = True
while hasnext:
url = pd_gen_url(
endpoint,
service_key,
YM='{0:04d}{1:02d}'.format(year, month),
SIDO=district1,
GUNGU=district2,
RES_NM=tourspot,
numOfRows=100,
_type='json',
pageNo=pageno)
json_result = json_request(url=url)
if json_result is None:
break
json_response = json_result.get('response')
json_header = json_response.get('header')
result_message = json_header.get('resultMsg')
if 'OK' != result_message:
print('%s : Error[%s] for Request(%s)' % (datetime.now(), result_message, url), file=sys.stderr)
break
json_body = json_response.get('body')
numofrows = json_body.get('numOfRows')
totalcount = json_body.get('totalCount')
if totalcount == 0:
break
last_pageno = math.ceil(totalcount / numofrows)
if pageno == last_pageno:
hasnext = False
else:
pageno += 1
json_items = json_body.get('items')
yield json_items.get('item') if isinstance(json_items, dict) else None
# # v 1.0
# url = pd_gen_url(
# TOUR_URL_ENDPOINT,
# service_key,
# YM='{0:04d}{1:02d}'.format(year, month),
# SIDO=district1,
# GUNSU=district2,
# RES_NM=tourspot,
# _type='json',
# numOfRows=50, pageNo=1)
#
# json_result = json_request(url=url)
#
# resHeader = json_result.get('response').get('header')
# if resHeader.get('resultMsg') != "OK" :
# print("%s Error[%s] for request %s" % (datetime.now(), resHeader.get('resultMsg'), url))
# return None
# resBody = json_result.get('response').get('body')
# items = None if resBody is None else resBody.get('items')
# try:
# item = None if items is None else items.get('item')
# yield item
# except AttributeError:
# pass | twooopark/Analysis_PublicData | collect/api/api.py | api.py | py | 3,648 | python | en | code | 0 | github-code | 13 |
8562450264 | #!/usr/bin/env python3
# Creates an answer key for all data owners specified
# to be consumed by the scoring and evaluation tools for tuning
import csv
from pathlib import Path
systems = ["site_a", "site_b", "site_c", "site_d", "site_e", "site_f"]
# output is clk_pos | h_id
header = ["HOUSEHOLD_POSITION", "HOUSEHOLD_ID"]
household_dict = {}
full_answer_key_path = Path("../temp-data/full_answer_key.csv")
for s in systems:
hid_line_map = []
pos_pid_map = []
output_lines = []
hid_dict = {}
key_path = Path("../temp-data") / "{}_key.csv".format(s)
pos_pid_path = Path("../temp-data") / "{}_household_pos_pid.csv".format(s)
hid_out_path = Path("../temp-data") / "{}_hid_mapping.csv".format(s)
with open(key_path) as key_csv:
key_reader = csv.reader(key_csv)
# Skips header
next(key_reader)
hid_line_map = list(key_reader)
for line in hid_line_map:
hid_dict[line[0]] = line[2]
if line[2] in household_dict:
household_dict[line[2]].append(s)
else:
household_dict[line[2]] = [s]
with open(pos_pid_path) as pos_pid_csv:
pos_pid_reader = csv.reader(pos_pid_csv)
# Skips header
next(pos_pid_reader)
pos_pid_map = list(pos_pid_reader)
for line in pos_pid_map:
hid = hid_dict[line[1]]
output_lines.append({"HOUSEHOLD_POSITION": line[0], "HOUSEHOLD_ID": hid})
with open(hid_out_path, "w", newline="", encoding="utf-8") as hid_out:
writer = csv.DictWriter(hid_out, fieldnames=header)
writer.writeheader()
for row in output_lines:
writer.writerow(row)
with open(full_answer_key_path, "w", newline="", encoding="utf-8") as full_key:
writer = csv.DictWriter(full_key, fieldnames=systems)
writer.writeheader()
for key in household_dict:
new_row = {}
for system in household_dict[key]:
new_row[system] = key
writer.writerow(new_row)
| mitre/data-owner-tools | testing-and-tuning/answer_key_map.py | answer_key_map.py | py | 2,012 | python | en | code | 5 | github-code | 13 |
39751095932 | from typing import Dict, Union
# Third Party Imports
from sqlalchemy import Column, ForeignKey, Integer, String
from sqlalchemy.orm import relationship
# RAMSTK Local Imports
from .. import RAMSTK_BASE
from .baserecord import RAMSTKBaseRecord
class RAMSTKSubCategoryRecord(RAMSTK_BASE, RAMSTKBaseRecord): # type: ignore
"""Class to represent ramstk_subcategory in the RAMSTK Common database."""
__defaults__ = {"description": "Subcategory Description"}
__tablename__ = "ramstk_subcategory"
__table_args__ = {"extend_existing": True}
category_id = Column(
"fld_category_id",
Integer,
ForeignKey("ramstk_category.fld_category_id"),
nullable=False,
)
subcategory_id = Column(
"fld_subcategory_id",
Integer,
primary_key=True,
autoincrement=True,
nullable=False,
)
description = Column(
"fld_description", String(512), default=__defaults__["description"]
)
# Define the relationships to other tables in the RAMSTK Program database.
category = relationship( # type: ignore
"RAMSTKCategoryRecord", back_populates="subcategory"
)
mode = relationship( # type: ignore
"RAMSTKFailureModeRecord",
back_populates="subcategory",
cascade="delete",
)
def get_attributes(self) -> Dict[str, Union[int, str]]:
"""Retrieve current values of RAMSTKSubCategory data model attributes.
:return: {category_id, subcategory_id, description} pairs.
:rtype: dict
"""
return {
"category_id": self.category_id,
"subcategory_id": self.subcategory_id,
"description": self.description,
}
| ReliaQualAssociates/ramstk | src/ramstk/models/dbrecords/commondb_subcategory_record.py | commondb_subcategory_record.py | py | 1,726 | python | en | code | 34 | github-code | 13 |
21453046038 | # Title : 미로 탐색
# Date : 2022/11/19
# https://www.acmicpc.net/problem/2178
import sys
from collections import deque
def bfs(x,y):
# 상, 하, 좌, 우
dx = [-1,1,0,0]
dy = [0,0,-1,1]
de = deque()
de.append((x,y))
check[x][y] = 1
while de :
tx, ty = de.popleft()
if tx == n-1 and ty == m-1 :
return check[tx][ty]
for i in range(4):
nx = tx + dx[i]
ny = ty + dy[i]
if nx < 0 or ny < 0 or nx >= n or ny >= m:
continue
if arr[nx][ny] == 0:
continue
if arr[nx][ny] == 1 and check[nx][ny] == 0:
check[nx][ny] = check[tx][ty] + 1
de.append((nx,ny))
n, m = map(int, sys.stdin.readline().split())
arr = [list(map(int, sys.stdin.readline().strip())) for _ in range(n)]
check = [[0 for _ in range(m)] for _ in range(n)]
print(bfs(0,0)) | kkyu-min/Baekjoon | BFS_DFS/2178.py | 2178.py | py | 958 | python | en | code | 0 | github-code | 13 |
17592793814 | #largest and smallest
x=0
largest=-1
smallest=None
while True:
x=input("enter the number: ")
if x=="done":
break
a=int(x)
if smallest is None:
smallest=a
elif a<smallest:
smallest=a
if a>largest:
largest=a
print(largest)
print(smallest)
| Mukesh-kanna/python-content-repo | largestsmallestnumber.py | largestsmallestnumber.py | py | 294 | python | en | code | 0 | github-code | 13 |
8052784227 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from ComssService.service.sync import SyncService
from ComssService.ServiceController import ServiceController
import re
# Regexp dla formatu Access Loga Apache'a
# Zgodny z Common Log Format (http://en.wikipedia.org/wiki/Common_Log_Format)
regex = '([(\d\.)]+) - - \[(.*?)\] "([A-Z]*?) (.*?) (.*?)" (\d+) (\d+|-) "(.*?)" "(.*?)"'
# Usługa ekstrakcji kodu odpowiedzi HTTP z pojedynczej linijki loga
class HttpExtractorService(SyncService):
print("##### Http Extrator Service #####")
def run(self):
while True:
data = self.read('1')
# Wyciąganie 5. grupy regexpa - kodu HTTP
statusCode = re.match(regex, data).groups()[5]
# Wysyłanie statusu HTTP na wyjście 2
self.send('2', statusCode)
if __name__ == '__main__':
# Uruchomienie usługi:
desc_file_name = 'http_extractor_service.xml'
s = ServiceController(HttpExtractorService, desc_file_name)
s.start() | pawellewandowski/TIRT | ComssService/project/http_extractor/http_extractor_service.py | http_extractor_service.py | py | 1,024 | python | en | code | 0 | github-code | 13 |
26188296075 | # Builder - common functions
import functools
import json
from pathlib import Path
import subprocess
from urllib.parse import urlparse
CONFIG_FILE = Path(__file__).parent.parent / "appliance_config.json"
SECRETS_DIR = Path(__file__).parent.parent / 'secrets'
SECRETS_FILE = SECRETS_DIR / 'secrets.json'
SECRETS_NAMES = {
'aws_access_key_id': ('AWS Access Key ID', '[A-Z0-9]{20}'),
'aws_secret_access_key': ('AWS Secret Access Key', '\S{40}'),
'region': ('AWS Region', 'us-(east|west)-[1-9]'),
'git_user': ('Git User Name', '\S{5}'),
'git_pwd': ('Git Password', '\S{5}'),
'repo_host': ('Repository Host', '^\S+\.(com|org|net)'),
'repo_url': ('Repository URL (skip https://)', '^\S+'),
}
echo = functools.partial(print, end='', flush=True)
def do_menu(term, title, menu):
def draw_menu(term, title, menu):
prep_screen(term, title)
for key, item in menu.items():
print(f" {key}) {item[0]}")
print(" x) Exit\n")
echo(f"{term.bright_blue}Option?{term.white} ")
with term.fullscreen():
draw_menu(term, title, menu)
while True:
with term.cbreak(): key = term.inkey()
if key == 'x' or key == 'X':
return False
if key.upper() in menu.keys():
menu[key.upper()][1](term)
return True # Forces re-build of menu options
draw_menu(term, title, menu)
def load_config():
with open(CONFIG_FILE, 'r') as _:
return json.load(_)
def load_secrets():
try:
if SECRETS_FILE.exists():
with open(SECRETS_FILE, 'r') as _:
return json.load(_)
except:
pass
return {k:"" for k in SECRETS_NAMES.keys()}
def prep_screen(term, title=None):
echo(term.home + term.clear)
print(term.center(f"{term.green}PiAppliance -- Configure and Build{term.white}"))
if title:
print(f"\n{term.bright_yellow}{title}{term.white}\n")
def press_any_key(term, msg):
print(msg)
echo(f"\n{term.bright_blue}Press any key to return to the menu: {term.white}")
with term.cbreak(): term.inkey()
return
def runcmd(cmd, params=None):
c = cmd.split(' ')
if params:
c.append(params)
return subprocess.run(c, capture_output=True)
def save_config(config):
with open(CONFIG_FILE, 'w') as _:
json.dump(config, _, indent=2, sort_keys=True)
def save_secrets(secrets):
if not SECRETS_DIR.exists():
SECRETS_DIR.mkdir()
with open(SECRETS_FILE, 'w') as _:
json.dump(secrets, _, indent=2, sort_keys=True)
def try_command(cmd, error, params=None):
proc = runcmd(cmd, params)
if proc.returncode:
raise Exception(f"{error}: {proc.stderr}")
__all__ = [
"do_menu",
"echo",
"load_config",
"load_secrets",
"prep_screen",
"press_any_key",
"runcmd",
"save_config",
"save_secrets",
"SECRETS_NAMES",
"try_command",
]
| tdesposito/Pi-Appliance | builder/__init__.py | __init__.py | py | 2,968 | python | en | code | 0 | github-code | 13 |
1227186107 | '''
Created on 29 Nov 2013
@author: Oskar
'''
class Unlock(object):
'''
Unlocks doors
'''
def __init__(self, console):
'''
Constructor
'''
self.console = console
self.synonms = ["unlock"]
@property
def args(self):
return [str(exit_.i_go(self.current_room)) for exit_ in self.current_room.exits]
def action(self, door):
for item in self.console.current_player.inventory:
if item in door.keys:
door.open_me()
print(door.is_open)
break
else:
print("You don't have the key to %s" %door.i_go(self.console.current_room))
def check(self, string):
for word in self.synonms:
if word in string:
return self
break
else:
return False | OskarBun/Game | src/oskar/console_actions/unlock.py | unlock.py | py | 904 | python | en | code | 0 | github-code | 13 |
15919398706 | # -*- coding: utf-8 -*-
# ---
# title: "Fairness"
# site: distill::distill_website
# jupyter:
# jupytext:
# formats: ipynb,Rmd,py:percent
# text_representation:
# extension: .py
# format_name: percent
# format_version: '1.3'
# jupytext_version: 1.11.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# %% tags=[] language="R"
# library(reticulate)
# use_condaenv('ethique_env')
# %%
# %%capture
# %run ./german.ipynb
# %% [markdown]
# # Fairness
# %% [markdown]
# # Les femmes sont discriminées
#
# ## Définition de la *fairness*
#
# ([source](https://en.wikipedia.org/wiki/Fairness_(machine_learning)))
#
# On appel biais algorithmique une erreur systématique et reproductible d'un système informatique qui entraîne les sorties de ce système à favoriser un groupe d'individus plutôt qu'un autre. Cette notion est déjà abordé par Joseph Weizenbaum en 1967 qui décrivait les programmes informatique de l'époque mimiquant le raisonnement humain pour résoudre des problèmes. Il dit dans *Computer Power and Human Reason* que les règles que suivent les programmes internalisent la vision du monde de leur créateur ce qui inclue leur biais et leur attentes. Cela ne concerne également les algorithmes qui apprennent d'eux-même car toutes données fournies à l'algorithme reflètent la manière dont l'homme prends des décisions.
#
# Le principe de *fairness* en apprentissage statistique corresponds aux différentes manières de corriger ou du moins de mitiger ce problème de biais algorithmique. Il est difficile voir impossible de donner une définition universelle de la *fairness* mais de manière générale on considère qu'un résultat est équitable s'il est indépendant d'un certain jeu de variables appelées *variables sensibles*. Pour une personnes les variables sensibles correspondent classiquement aux attributs comme le sexe, l'ethnicité, l'orientation sexuelle, ou tout autre caractéristiques sur lesquelles il est interdit de discriminé.
#
# Bien que le problème de biais algorithmique soit décrit depuis plus les années 70 les recherches en matière de *fairness* sont très récentes avec les publications les plus importantes datant seulement de 2018. (citer des papier ?)
#
# ## Définition mathématique
#
# Bien que la définition de *fairness* paraisse intuitive, il est nécessaire de faire des hypothèse pour mettre en place une définition théorique. Il existe donc différentes définition de la *fairness* selon les hypothèses retenues. Néanmoins de manière générale l'objectif de ces définition est que la déviation (ou le biais statistique) d'une ou plusieurs *métriques de parité* doivent être minimisé pour tout les individus ou tout les groupes d'individus.
#
# Il existe un très grand nombre de ces métriques de parités ([liste](https://developers.google.com/machine-learning/glossary/fairness)). Il existe certain outils permettant d'orienté le choix vers une métrique plutôt qu'une autre en fonction du rôle qu'aura le modèle statistique. Par exemple [*Aquiteas*](https://github.com/dssg/aequitas), une trousse à outils de *fairness* développée par le centre *data science and public policy* de l'université de Chicago, propose l'arbre de décision suivant :
#
# 
#
#
# Nous allons nous attarder sur trois métriques en utilisant les notations suivantes :
# - $Y$ : la caractéristique binaire de sortie
# - $X$ : le vecteur de caractéristique d'entrées sans la caractéristique sensible
# - $S$ : la caractéristique sensible
# - $\hat{Y}$ : la prédiction de la caractéristique de sortie
#
#
# **Définition 1 : *equalized odds***
#
# On dit que $\hat{Y}$ satisfait l'égalité des chance par rapport à $S$ et $Y$ si :
# $$
# P(\hat{Y}=1 \mid S=0, Y=y)=P(\hat{Y}=1 \mid S=1, Y=y) ; \quad y=0,1
# $$
# Autrement dit, $\hat{Y}$ est indépendant de $S$ conditionnellement à $Y$.
#
# **Définition 2 : *demographic parity***
#
# On dit que $\hat{Y}$ satisfait la parité démographique par rapport à $S$ si :
# $$
# P(\hat{Y}=1 \mid S=0)=P(\hat{Y}=1 \mid S=1)
# $$
# Autrement dit, $\hat{Y}$ est indépendant de S.
#
# **Définition 3 : *counterfactual fairness***
#
# On dit que $\hat{Y}$ satisfait l'équité contrefactuelle par rapport à $S$ et $X$ si :
# $$
# P(\hat{Y}=1 \mid S=0, X=x)=P(\hat{Y}=1 \mid S=1, X=x)
# $$
# Autrement dit, $\hat{Y}$ est indépendant de $S$ conditionnellement à $X$.
#
# L'égalité des chance et la parité démographique sont des métriques de parité de groupe (*group fairness*), on cherche à avoir le même traitement pour des groupes de personnes définie par leur variables sensibles $S$. Alors que l'équité contrefactuelle est une métrique de parité individuelle (*individual fairness*), on cherche à fournir un traitement similaire à des personnes similaires peut importe leur variables sensibles.
# Il est tout à fait possible d'avoir une interaction entre deux métriques des deux groupes on a alors un *subgroup fairness*.
#
# ## Application de la *fairness*
#
# Les problèmes de biais algorithmiques peuvent survenir des données ou du modèle c'est pour cela que l'on peut catégorisé les méthodes d'implémentation des solutions de *fairness* en trois parties :
# - pre-processing : ces méthodes qui ne dépendent pas du modèle tendent à mitiger les problèmes de *fairness* avant que les données soit utilisé dans un modèle statistique. Il s'agit souvent de transformer une ou plusieurs caractéristiques ou de changer la représentation des groupes.
# - in-processing : ces méthodes incorporent dans le processus d'entraînement les métriques que l'on cherche à minimiser.
# - post-processing : ces méthodes n'ont pas besoin d'un accès au modèle d'entraînement mais au lieu de traiter le problème de *fairness* sur la base de données d'entraînement on se base sur les prédictions.
#
#
# Dans la suite nous allons illustrer les différents biais qu'il peut exister dans notre modèle de prédiction de défaut en prenant comme variable sensible le sexe de l'individu. Nous verrons ensuite l'implémentation de méthodes *pre-processing*, *post-processing* et *in-processing*.
# %% [markdown]
# ## Mise en situation et implémentations
#
# ### Utilisation de la matrice de confusion
#
# La majorité des mesures de partialité sont basées sur la matrice de confusion. Elle comporte quatre classes :
# - Vrai positif (VP) : la vraie classe est 1 et la classe prédite est 1
# - Faux positif (FP) : la vraie classe est 0 et la classe prédite est 1
# - Vrai négatif (VN) : la vraie classe est 0 et la classe prédite est 0
# - Faux négatif (FN) : la vraie classe est 1 et la classe prédite est 0
#
# Les métriques de partialité sont calculé à partir de ces 4 valeurs pour des groupes de personnes partagants des caractéristiques communes (sex, ethnicité)
# %% code_folding=true
title = 'Matrice de confusion de la régression logistique'
disp = plot_confusion_matrix(logreg,
X_test,
y_test,
cmap=plt.cm.Blues)
ax = disp.ax_.set_title(title)
plt.show()
# %% [markdown]
# Dans cette représentation on a :
# - Vrai positif : bas à droite
# - Faux positif : haut à droite
# - Vrai négatif : haut à gauche
# - Faut négatif : bas à droite
# %% [markdown]
# ## Métriques de parité
# %% [markdown]
# Pour illustrer la *fairness* on va utilisé notre modèle de régression logistique implémenté dans l'article *intro*. Pour calculer les différentes métriques nous utilisons la boîte à outils développé par IBM : *AI Fairness 360*. Cette boite à outils implémente les calculs des biais mais aussi les méthodes de mitigations de ceux-ci.
# %%
# %%capture
from aif360.datasets import BinaryLabelDataset
from aif360.metrics import ClassificationMetric
# %% [markdown]
# La manière dont *AIF360* fonctionne pour le calcul de métrique de parité est la suivante :
# - On créer un dataframe (results) qui contient le $Y$, $\hat{Y}$ et la variable sensible en binaire
# %%
y_test = pd.Series(y_test, index=X_test.index, name='default')
y_pred = pd.Series(model.predict(X_test), index=X_test.index, name='default')
sex_bin = X_test.sex.map({'male': 0, 'female': 1})
results_test = pd.concat([y_test, sex_bin], axis=1)
results_pred = pd.concat([y_pred, sex_bin], axis=1)
results_test.head(3)
# %% [markdown]
# - On utilise l'objet BinaryLabelDataset en précisant le label et la variable sensible. Un pour les prédictions et un pour les tests. On fait également bien attention à préciser que le label 1 n'est pas positif pour la personne, il correspond à une prédiction de défaut.
# %%
bld_test = BinaryLabelDataset(df=results_test,
label_names=['default'],
protected_attribute_names=['sex'],
favorable_label=0,
unfavorable_label=1)
bld_pred = BinaryLabelDataset(df=results_pred,
label_names=['default'],
protected_attribute_names=['sex'],
favorable_label=0,
unfavorable_label=1)
# %% [markdown]
# - On utilise ensuite l'objet *ClassificationMetric* qui prend en entrée deux *BinaryLabelDataset* et une classification des groupes privilégiés. Il permets ensuite de calculer un très grands nombre de métrique ([liste](https://aif360.readthedocs.io/en/latest/modules/sklearn.html#module-aif360.sklearn.metrics))
# %%
fairness_metrics = ClassificationMetric(bld_test, bld_pred,
unprivileged_groups=[{'sex': 1}],
privileged_groups=[{'sex': 0}])
# %% [markdown]
# Average of difference in FPR and TPR for unprivileged and privileged
# groups:
#
# $$\tfrac{1}{2}\left[(FPR_{D = \text{unprivileged}} - FPR_{D = \text{privileged}})
# + (TPR_{D = \text{unprivileged}} - TPR_{D = \text{privileged}}))\right]$$
#
# A value of 0 indicates equality of odds.
# %%
fairness_metrics.average_odds_difference()
# %% [markdown]
# $$Pr(\hat{Y} = 1 | D = \text{unprivileged})
# - Pr(\hat{Y} = 1 | D = \text{privileged})$$
# %%
fairness_metrics.statistical_parity_difference()
# %% [markdown]
# $$TPR_{D = \text{unprivileged}} - TPR_{D = \text{privileged}}$$
# %%
fairness_metrics.true_positive_rate_difference()
# %% [markdown]
# $$\frac{Pr(\hat{Y} = 1 | D = \text{unprivileged})}
# {Pr(\hat{Y} = 1 | D = \text{privileged})}$$
# %%
fairness_metrics.disparate_impact()
# %%
fairness_metrics.accuracy()
# %% [markdown]
# # Comment mitiger les risques de discrimination
#
# ## Présentation des trois grandes familles
#
# ### Pre-Processing
# %% [markdown]
# ### In-Processing
# %% [markdown]
# ### Post-Processing
# %% [markdown]
# ## Implémentation des méthodes
#
# ### Pre-processing : *Reweight*
# %%
# %%capture
from aif360.algorithms.preprocessing import Reweighing
# %%
rw = Reweighing(unprivileged_groups=[{'sex': 1}],
privileged_groups=[{'sex': 0}])
# %%
if 'sex' in cat_variables: cat_variables.remove('sex')
preprocess = ColumnTransformer(
transformers=[
('cat', OneHotEncoder(drop='first'), cat_variables),
('ord', StandardScaler(), ord_variables)
])
X_train_proc = preprocess.fit_transform(X_train.drop(columns='sex'))
X_train_proc = pd.concat([pd.DataFrame(X_train_proc, index=X_train.index),
X_train.sex.map({'male':0, 'female':1})], axis=1)
# %% tags=["remove_output"]
# %%capture
bld_train = BinaryLabelDataset(df=pd.concat([X_train_proc, y_train], axis=1),
label_names=['default'],
protected_attribute_names=['sex'],
favorable_label=0, unfavorable_label=1)
bld_train = rw.fit_transform(bld_train)
w_train = bld_train.instance_weights.ravel()
model.fit(X_train, y_train, logreg__sample_weight = w_train)
# %%
y_test_pred = pd.Series(model.predict(X_test), index=X_test.index, name='defaut')
y_test = pd.Series(y_test, index=X_test.index, name='defaut')
sex_test = X_test.sex.map({'male': 0, 'female':1})
# %%
bld_test_pred = BinaryLabelDataset(df=pd.concat([y_test_pred, sex_test], axis=1),
label_names=['defaut'],
protected_attribute_names=['sex'],
favorable_label=0, unfavorable_label=1)
bld_test = BinaryLabelDataset(df=pd.concat([y_test, sex_test], axis=1),
label_names=['defaut'],
protected_attribute_names=['sex'],
favorable_label=0, unfavorable_label=1)
# %%
fairness_metrics = ClassificationMetric(bld_test, bld_test_pred,
unprivileged_groups=[{'sex': 1}], privileged_groups=[{'sex': 0}])
# %%
fairness_metrics.average_odds_difference()
# %%
fairness_metrics.statistical_parity_difference()
# %%
fairness_metrics.true_positive_rate_difference()
# %%
fairness_metrics.disparate_impact()
# %%
fairness_metrics.accuracy()
# %% [markdown]
# ### In-processing : ?
# %% [markdown]
# ### Post-processing : *Calibrated Equal Odds*
# %%
from aif360.algorithms.postprocessing import CalibratedEqOddsPostprocessing
# %%
cpp = CalibratedEqOddsPostprocessing(unprivileged_groups=[{'sex': 1}],
privileged_groups=[{'sex': 0}],
cost_constraint='fpr')
cpp = cpp.fit(bld_test, bld_test_pred)
bld_test_pred = cpp.predict(bld_test_pred)
fairness_metrics = ClassificationMetric(bld_test, bld_test_pred,
unprivileged_groups=[{'sex': 1}], privileged_groups=[{'sex': 0}])
# %%
fairness_metrics.average_odds_difference()
# %%
fairness_metrics.statistical_parity_difference()
# %%
fairness_metrics.true_positive_rate_difference()
# %%
fairness_metrics.disparate_impact()
# %%
fairness_metrics.accuracy()
# %% [markdown]
# # Critique de la partie 2 et recommendations
#
# ## Compromis
# - Est-ce que les hommes sont lésés par ces méthodes ?
# - Est-ce que ces méthodes sont beaucoup plus longues ?
#
# ## Ouverture
| gpltr/Ethique | fairness.py | fairness.py | py | 14,595 | python | fr | code | 0 | github-code | 13 |
34911062134 | from toxcore_enums_and_consts import *
from PySide import QtGui, QtCore
import profile
from file_transfers import TOX_FILE_TRANSFER_STATE
from util import curr_directory, convert_time
from messages import FILE_TRANSFER_MESSAGE_STATUS
from widgets import DataLabel
class MessageEdit(QtGui.QTextEdit):
def __init__(self, text, width, parent=None):
super(MessageEdit, self).__init__(parent)
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setWordWrapMode(QtGui.QTextOption.WrapAtWordBoundaryOrAnywhere)
self.document().setTextWidth(width)
self.setPlainText(text)
font = QtGui.QFont()
font.setFamily("Times New Roman")
font.setPixelSize(14)
font.setBold(False)
self.setFont(font)
self.setFixedHeight(self.document().size().height())
self.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse | QtCore.Qt.LinksAccessibleByMouse)
class MessageItem(QtGui.QWidget):
"""
Message in messages list
"""
def __init__(self, text, time, user='', message_type=TOX_MESSAGE_TYPE['NORMAL'], parent=None):
QtGui.QWidget.__init__(self, parent)
self.name = DataLabel(self)
self.name.setGeometry(QtCore.QRect(0, 2, 95, 20))
self.name.setTextFormat(QtCore.Qt.PlainText)
font = QtGui.QFont()
font.setFamily("Times New Roman")
font.setPointSize(11)
font.setBold(True)
self.name.setFont(font)
self.name.setObjectName("name")
self.name.setText(user)
self.time = QtGui.QLabel(self)
self.time.setGeometry(QtCore.QRect(parent.width() - 50, 0, 50, 25))
font = QtGui.QFont()
font.setFamily("Times New Roman")
font.setPointSize(10)
font.setBold(False)
self.time.setFont(font)
self.time.setObjectName("time")
self.time.setText(time)
self.message = MessageEdit(text, parent.width() - 150, self)
self.message.setGeometry(QtCore.QRect(100, 0, parent.width() - 150, self.message.height()))
self.setFixedHeight(self.message.height())
if message_type == TOX_MESSAGE_TYPE['ACTION']:
self.name.setStyleSheet("QLabel { color: #4169E1; }")
self.message.setStyleSheet("QTextEdit { color: #4169E1; }")
else:
if text[0] == '>':
self.message.setStyleSheet("QTextEdit { color: green; }")
if text[-1] == '<':
self.message.setStyleSheet("QTextEdit { color: red; }")
class ContactItem(QtGui.QWidget):
"""
Contact in friends list
"""
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setBaseSize(QtCore.QSize(250, 70))
self.avatar_label = QtGui.QLabel(self)
self.avatar_label.setGeometry(QtCore.QRect(3, 3, 64, 64))
self.avatar_label.setScaledContents(True)
self.name = DataLabel(self)
self.name.setGeometry(QtCore.QRect(70, 10, 160, 25))
font = QtGui.QFont()
font.setFamily("Times New Roman")
font.setPointSize(12)
font.setBold(True)
self.name.setFont(font)
self.name.setObjectName("name")
self.status_message = DataLabel(self)
self.status_message.setGeometry(QtCore.QRect(70, 30, 180, 20))
font.setPointSize(10)
font.setBold(False)
self.status_message.setFont(font)
self.status_message.setObjectName("status_message")
self.connection_status = StatusCircle(self)
self.connection_status.setGeometry(QtCore.QRect(220, 5, 32, 32))
self.connection_status.setObjectName("connection_status")
class StatusCircle(QtGui.QWidget):
"""
Connection status
"""
def __init__(self, parent):
QtGui.QWidget.__init__(self, parent)
self.setGeometry(0, 0, 32, 32)
self.data = None
self.messages = False
def paintEvent(self, event):
paint = QtGui.QPainter()
paint.begin(self)
paint.setRenderHint(QtGui.QPainter.Antialiasing)
k = 16
rad_x = rad_y = 5
if self.data is None:
color = QtCore.Qt.transparent
else:
if self.data == TOX_USER_STATUS['NONE']:
color = QtGui.QColor(50, 205, 50)
elif self.data == TOX_USER_STATUS['AWAY']:
color = QtGui.QColor(255, 200, 50)
else: # self.data == TOX_USER_STATUS['BUSY']:
color = QtGui.QColor(255, 50, 0)
paint.setPen(color)
center = QtCore.QPoint(k, k)
paint.setBrush(color)
paint.drawEllipse(center, rad_x, rad_y)
if self.messages:
if color == QtCore.Qt.transparent:
color = QtCore.Qt.darkRed
paint.setBrush(QtCore.Qt.transparent)
paint.setPen(color)
paint.drawEllipse(center, rad_x + 3, rad_y + 3)
paint.end()
class FileTransferItem(QtGui.QListWidget):
def __init__(self, file_name, size, time, user, friend_number, file_number, state, parent=None):
QtGui.QListWidget.__init__(self, parent)
self.resize(QtCore.QSize(620, 50))
if state != FILE_TRANSFER_MESSAGE_STATUS['CANCELLED']:
self.setStyleSheet('QWidget { background-color: green; }')
else:
self.setStyleSheet('QWidget { background-color: #B40404; }')
self.name = DataLabel(self)
self.name.setGeometry(QtCore.QRect(1, 15, 95, 20))
self.name.setTextFormat(QtCore.Qt.PlainText)
font = QtGui.QFont()
font.setFamily("Times New Roman")
font.setPointSize(11)
font.setBold(True)
self.name.setFont(font)
self.name.setText(user)
self.name.setStyleSheet('QLabel { color: black; }')
self.time = QtGui.QLabel(self)
self.time.setGeometry(QtCore.QRect(570, 2, 50, 46))
font.setPointSize(10)
font.setBold(False)
self.time.setFont(font)
self.time.setText(convert_time(time))
self.time.setStyleSheet('QLabel { color: black; }')
self.cancel = QtGui.QPushButton(self)
self.cancel.setGeometry(QtCore.QRect(500, 2, 46, 46))
pixmap = QtGui.QPixmap(curr_directory() + '/images/decline.png')
icon = QtGui.QIcon(pixmap)
self.cancel.setIcon(icon)
self.cancel.setIconSize(QtCore.QSize(30, 30))
self.cancel.setVisible(state > 1)
self.cancel.clicked.connect(lambda: self.cancel_transfer(friend_number, file_number))
self.cancel.setStyleSheet('QPushButton:hover { border: 1px solid #3A3939; }')
self.accept = QtGui.QPushButton(self)
self.accept.setGeometry(QtCore.QRect(450, 2, 46, 46))
pixmap = QtGui.QPixmap(curr_directory() + '/images/accept.png')
icon = QtGui.QIcon(pixmap)
self.accept.setIcon(icon)
self.accept.setIconSize(QtCore.QSize(30, 30))
self.accept.clicked.connect(lambda: self.accept_transfer(friend_number, file_number, size))
self.accept.setVisible(state == FILE_TRANSFER_MESSAGE_STATUS['INCOMING_NOT_STARTED'])
self.accept.setStyleSheet('QPushButton:hover { border: 1px solid #3A3939; }')
self.pb = QtGui.QProgressBar(self)
self.pb.setGeometry(QtCore.QRect(100, 15, 100, 20))
self.pb.setValue(0)
self.pb.setStyleSheet('QProgressBar { background-color: #302F2F; }')
if state < 2:
self.pb.setVisible(False)
self.file_name = DataLabel(self)
self.file_name.setGeometry(QtCore.QRect(210, 2, 230, 46))
font.setPointSize(12)
self.file_name.setFont(font)
file_size = size / 1024
if not file_size:
file_size = '{}B'.format(size)
elif file_size >= 1024:
file_size = '{}MB'.format(file_size / 1024)
else:
file_size = '{}KB'.format(file_size)
file_data = u'{} {}'.format(file_size, file_name)
self.file_name.setText(file_data)
self.file_name.setStyleSheet('QLabel { color: black; }')
self.saved_name = file_name
def cancel_transfer(self, friend_number, file_number):
pr = profile.Profile.get_instance()
pr.cancel_transfer(friend_number, file_number)
self.setStyleSheet('QListWidget { background-color: #B40404; }')
self.cancel.setVisible(False)
self.accept.setVisible(False)
self.pb.setVisible(False)
def accept_transfer(self, friend_number, file_number, size):
directory = QtGui.QFileDialog.getExistingDirectory()
if directory:
pr = profile.Profile.get_instance()
pr.accept_transfer(self, directory + '/' + self.saved_name, friend_number, file_number, size)
self.accept.setVisible(False)
@QtCore.Slot(int, float)
def update(self, state, progress):
self.pb.setValue(int(progress * 100))
if state == TOX_FILE_TRANSFER_STATE['CANCELED']:
self.setStyleSheet('QListWidget { background-color: #B40404; }')
self.cancel.setVisible(False)
self.accept.setVisible(False)
self.pb.setVisible(False)
elif state == TOX_FILE_TRANSFER_STATE['FINISHED']:
self.pb.setVisible(False)
self.cancel.setVisible(False)
class InlineImageItem(QtGui.QWidget):
def __init__(self, data, parent=None):
QtGui.QWidget.__init__(self, parent)
self.resize(QtCore.QSize(620, 500))
self._image_label = QtGui.QLabel(self)
self._image_label.raise_()
self._image_label.setAutoFillBackground(True)
self._image_label.setScaledContents(False)
self.pixmap = QtGui.QPixmap()
self.pixmap.loadFromData(QtCore.QByteArray(data), "PNG")
if self.pixmap.width() <= 600:
self._image_label.setPixmap(self.pixmap)
self.resize(QtCore.QSize(600, self.pixmap.height()))
else:
pixmap = self.pixmap.scaled(600, 600, QtCore.Qt.KeepAspectRatio)
self._image_label.setPixmap(pixmap)
self.resize(QtCore.QSize(600, pixmap.height()))
| SergeyDjam/toxygen | src/list_items.py | list_items.py | py | 10,197 | python | en | code | null | github-code | 13 |
9341538822 | # coding=utf-8
# Copyright 2020 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""All functions related to loss computation and optimization.
"""
from pickle import FALSE
import torch
import torch.optim as optim
import numpy as np
from STaSy.models import utils as mutils
from STaSy.sde_lib import VESDE, VPSDE
import logging
def get_optimizer(config, params):
if config.optim.optimizer == 'Adam':
optimizer = optim.Adam(params, lr=config.optim.lr, betas=(config.optim.beta1, 0.999), eps=config.optim.eps,
weight_decay=config.optim.weight_decay)
else:
raise NotImplementedError(
f'Optimizer {config.optim.optimizer} not supported yet!')
return optimizer
def optimization_manager(config):
def optimize_fn(optimizer, params, step, lr=config.optim.lr,
warmup=config.optim.warmup,
grad_clip=config.optim.grad_clip):
if warmup > 0:
for g in optimizer.param_groups:
g['lr'] = lr * np.minimum((step+1) / warmup, 1.0)
if grad_clip >= 0:
torch.nn.utils.clip_grad_norm_(params, max_norm=grad_clip)
optimizer.step()
return optimize_fn
def get_sde_loss_fn(sde, train, reduce_mean=True, continuous=True, likelihood_weighting=True, eps=1e-5):
reduce_op = torch.mean if reduce_mean else lambda *args, **kwargs: 0.5 * torch.sum(*args, **kwargs)
def loss_fn(model, batch):
score_fn = mutils.get_score_fn(sde, model, train=train, continuous=continuous)
t = torch.rand(batch.shape[0], device=batch.device) * (sde.T - eps) + eps
z = torch.randn_like(batch)
mean, std = sde.marginal_prob(batch, t)
perturbed_data = mean + std[:, None] * z
score = score_fn(perturbed_data, t)
if not likelihood_weighting:
losses = torch.square(score * std[:, None] + z)
losses = reduce_op(losses.reshape(losses.shape[0], -1), dim=-1)
else:
g2 = sde.sde(torch.zeros_like(batch), t)[1] ** 2
losses = torch.square(score + z / std[:, None])
losses = reduce_op(losses.reshape(losses.shape[0], -1), dim=-1) * g2
# loss = torch.mean(losses)
return losses
return loss_fn
def get_smld_loss_fn(vesde, train, reduce_mean=False):
assert isinstance(vesde, VESDE), "SMLD training only works for VESDEs."
smld_sigma_array = torch.flip(vesde.discrete_sigmas, dims=(0,))
reduce_op = torch.mean if reduce_mean else lambda *args, **kwargs: 0.5 * torch.sum(*args, **kwargs)
def loss_fn(model, batch):
model_fn = mutils.get_model_fn(model, train=train)
labels = torch.randint(0, vesde.N, (batch.shape[0],), device=batch.device)
sigmas = smld_sigma_array.to(batch.device)[labels]
noise = torch.randn_like(batch) * sigmas[:, None]
perturbed_data = noise + batch
score = model_fn(perturbed_data, labels)
target = -noise / (sigmas ** 2)[:, None]
losses = torch.square(score - target)
losses = reduce_op(losses.reshape(losses.shape[0], -1), dim=-1) * sigmas ** 2
loss = torch.mean(losses)
return loss
return loss_fn
def get_ddpm_loss_fn(vpsde, train, reduce_mean=True):
assert isinstance(vpsde, VPSDE), "DDPM training only works for VPSDEs."
reduce_op = torch.mean if reduce_mean else lambda *args, **kwargs: 0.5 * torch.sum(*args, **kwargs)
def loss_fn(model, batch):
model_fn = mutils.get_model_fn(model, train=train)
labels = torch.randint(0, vpsde.N, (batch.shape[0],), device=batch.device)
sqrt_alphas_cumprod = vpsde.sqrt_alphas_cumprod.to(batch.device)
sqrt_1m_alphas_cumprod = vpsde.sqrt_1m_alphas_cumprod.to(batch.device)
noise = torch.randn_like(batch)
perturbed_data = sqrt_alphas_cumprod[labels, None] * batch + \
sqrt_1m_alphas_cumprod[labels, None] * noise
score = model_fn(perturbed_data, labels)
losses = torch.square(score - noise)
losses = reduce_op(losses.reshape(losses.shape[0], -1), dim=-1)
loss = torch.mean(losses)
return loss
return loss_fn
def get_step_fn(sde, train, optimize_fn=None, reduce_mean=False, continuous=True, likelihood_weighting=False, workdir=False, spl=True, writer=None, alpha0=None, beta0=None):
if continuous:
loss_fn = get_sde_loss_fn(sde, train, reduce_mean=reduce_mean,
continuous=True, likelihood_weighting=likelihood_weighting)
else:
assert not likelihood_weighting, "Likelihood weighting is not supported for original SMLD/DDPM training."
if isinstance(sde, VESDE):
loss_fn = get_smld_loss_fn(sde, train, reduce_mean=reduce_mean)
elif isinstance(sde, VPSDE):
loss_fn = get_ddpm_loss_fn(sde, train, reduce_mean=reduce_mean)
else:
raise ValueError(f"Discrete training for {sde.__class__.__name__} is not recommended.")
def step_fn(state, batch):
model = state['model']
if train:
optimizer = state['optimizer']
optimizer.zero_grad()
losses = loss_fn(model, batch)
if spl:
nll = losses
q_alpha = torch.tensor(alpha0 + torch.log( torch.tensor(1+ 0.0001718*state['step']* (1-alpha0), dtype=torch.float32) )).clamp_(max=1).to(nll.device)
q_beta = torch.tensor(beta0 + torch.log( torch.tensor(1+ 0.0001718*state['step']* (1-beta0), dtype=torch.float32) )).clamp_(max=1).to(nll.device)
logging.info(f"q_alpha: {q_alpha}, q_beta: {q_beta}")
writer.add_scalars("quatiles", {"q_alpha":q_alpha.item(), "q_beta": q_beta.item()}, state['step'])
alpha = torch.quantile(nll, q_alpha)
beta = torch.quantile(nll, q_beta)
assert alpha <= beta
v = compute_v(nll, alpha, beta)
loss = torch.mean(v*losses)
logging.info(f"alpha: {alpha}, beta: {beta}")
logging.info(f"1 samples: {torch.sum(v == 1)} / {len(v)}")
logging.info(f"weighted samples: { torch.sum((v != 1) * (v != 0) )} / {len(v)}")
logging.info(f"0 samples: {torch.sum(v == 0)} / {len(v)}")
writer.add_scalars("thresholds", {"alpha":alpha.item(), "beta": beta.item()}, state['step'])
else:
loss = torch.mean(losses)
loss.backward()
optimize_fn(optimizer, model.parameters(), step=state['step'])
state['step'] += 1
state['ema'].update(model.parameters())
else:
with torch.no_grad():
ema = state['ema']
ema.store(model.parameters())
ema.copy_to(model.parameters())
losses, score = loss_fn(model, batch)
ema.restore(model.parameters())
loss = torch.mean(losses)
return loss
return step_fn
def min_max_scaling(factor, scale=(0, 1)):
std = (factor - factor.min()) / (factor.max() - factor.min())
new_min = torch.tensor(scale[0])
new_max = torch.tensor(scale[1])
return std * (new_max - new_min) + new_min
def compute_v(ll, alpha, beta):
v = -torch.ones(ll.shape).to(ll.device)
v[torch.gt(ll, beta)] = torch.tensor(0., device=v.device)
v[torch.le(ll, alpha)] = torch.tensor(1., device=v.device)
if ll[torch.eq(v, -1)].shape[0] !=0 and ll[torch.eq(v, -1)].shape[0] !=1 :
v[torch.eq(v, -1)] = min_max_scaling(ll[torch.eq(v, -1)], scale=(1, 0)).to(v.device)
else:
v[torch.eq(v, -1)] = torch.tensor(0.5, device=v.device)
return v | SamsungSAILMontreal/ForestDiffusion | STaSy/losses.py | losses.py | py | 7,927 | python | en | code | 41 | github-code | 13 |
22853438512 |
import datetime
import json
import os
import joblib
import matplotlib.pyplot as plt
import mxnet as mx
import numpy as np
import pandas as pd
from gluonts.dataset import common
from gluonts.dataset.common import ListDataset
from gluonts.dataset.field_names import FieldName
from mxnet import gluon
from tqdm.notebook import tqdm
from preprocessing import make_event_study, save_gluon, train_test_split
np.random.seed(1000)
SOURCE_PATH = "/mnt/spacious/shared/vadim_all_sensors.csv"
def get_dataframe(source_path):
df = pd.read_csv(source_path)
df["ds"] = pd.to_datetime(df["ds"])
df["target"] = df.groupby("DeviceId").Occupancy.fillna(method="ffill", limit=5)
df["sensor"], _ = pd.factorize(df["DeviceId"])
return df
def make_segments(df, diffed=True, drift_thresh=3600000000000.0*4, min_target_length=288//4):
segments = []
item_id = 0
for s in df.sensor.unique():
target_sequence = (df.loc[df.sensor == s, "target"]).to_numpy()
target_sequence -= np.min(target_sequence)
target_sequence /= np.max(target_sequence)
ds_sequence = (df.loc[df.sensor == s, "ds"]).to_numpy()[1:]
start_idx = 0
end_idx = 0
diff_seq = np.diff(ds_sequence).astype(int)
m = np.median(diff_seq)
while True:
if not len(ds_sequence[start_idx:]):
break
try:
diff_seq = np.diff(ds_sequence[start_idx:]).astype(int)
delta_seq = np.cumsum(diff_seq - m)
end_idx = np.argmax(np.abs(delta_seq) > drift_thresh) + start_idx
except ValueError:
break
t_seq = target_sequence[start_idx:end_idx].astype(np.float32)
d_seq = np.diff(target_sequence[start_idx:end_idx].astype(np.float32), prepend=0)
seg = dict(
start=ds_sequence[start_idx],
end=ds_sequence[end_idx],
target=d_seq if diffed else t_seq,
feat_static_cat=np.array([s], dtype=int),
item_id = item_id,
real_time = ds_sequence[:end_idx],
)
if diffed:
seg["feat_dynamic_real"]= t_seq[np.newaxis, :]
segments.append(seg)
start_idx = end_idx + 1
if start_idx >= target_sequence.shape[0]:
break
if np.all(np.isnan(target_sequence[end_idx:])):
break
item_id += 1
segments = [s for s in segments if len(s["target"]) > min_target_length]
return segments, item_id
def make_datasets():
dates = [
(pd.Timestamp(year=2012, month=1, day=1, freq="5min"), pd.Timestamp(year=2050, month=1, day=1, freq="5min")), # train-test.
(pd.Timestamp(year=2010, month=1, day=1, freq="5min"), pd.Timestamp(year=2010, month=6, day=1, freq="5min")), # cv's
(pd.Timestamp(year=2010, month=6, day=1, freq="5min"), pd.Timestamp(year=2010, month=12, day=1, freq="5min")),
(pd.Timestamp(year=2011, month=1, day=1, freq="5min"), pd.Timestamp(year=2011, month=6, day=1, freq="5min")),
(pd.Timestamp(year=2011, month=6, day=1, freq="5min"), pd.Timestamp(year=2011, month=12, day=1, freq="5min")),
]
print("Loading dataframe")
df = get_dataframe(SOURCE_PATH)
for diffed in [True, False]:
print("Making segments")
subname = "diffed" if diffed else "nondiffed"
dataset_name = "chic_d" if diffed else "chic"
segments, base_item_id = make_segments(df, diffed=diffed)
os.makedirs(f"data/cv/{dataset_name}/", exist_ok=True)
for i, (start_date, end_date) in enumerate(dates):
print(start_date, end_date)
item_id = base_item_id
train_segments, test_segments = train_test_split(segments, start_date, end_date, item_id)
print(len(train_segments), len(test_segments))
if i > 0:
save_path = f"data/cv/{dataset_name}/{dataset_name}_{i}.gluonts"
else:
save_path = f"data/{dataset_name}.gluonts"
save_gluon(save_path, train_segments, test_segments, "5T")
os.makedirs(f"data/examples/{dataset_name}/", exist_ok=True)
print("making event studies")
make_event_study(df, diffed,
pd.date_range(start='2013-3-13', end='2013-3-14', freq = 's'),
15,
f"data/examples/{dataset_name}/{dataset_name}_example_2013_3_13.pkl",
f"data/examples/{dataset_name}/{dataset_name}_reference_2013_3_13.pkl",
"5T"
)
make_event_study(df, diffed,
pd.date_range(start='2013-3-15', end='2013-3-16', freq = 's'),
15,
f"data/examples/{dataset_name}/{dataset_name}_example_2013_3_15.pkl",
f"data/examples/{dataset_name}/{dataset_name}_reference_2013_3_15.pkl",
"5T"
)
make_event_study(df, diffed,
pd.date_range(start='2013-10-10', end='2013-10-11', freq = 's'),
15,
f"data/examples/{dataset_name}/{dataset_name}_example_2013_10_10.pkl",
f"data/examples/{dataset_name}/{dataset_name}_reference_2013_10_10.pkl",
"5T"
)
if __name__ == "__main__":
make_datasets()
| pedrogerum/probabilistic-traffic-forecating | make_chicago_data.py | make_chicago_data.py | py | 5,314 | python | en | code | 0 | github-code | 13 |
25548143223 | """Hold configuration variables for the emulated hue bridge."""
import datetime
import logging
import os
import uuid
from getmac import get_mac_address
from .utils import get_local_ip, load_json, save_json
_LOGGER = logging.getLogger(__name__)
CONFIG_FILE = "emulated_hue.json"
class Config:
"""Hold configuration variables for the emulated hue bridge."""
def __init__(self, hue, data_path, hass_url, hass_token):
"""Initialize the instance."""
self.hue = hue
self.hass_url = hass_url
self.hass_token = hass_token
self.data_path = data_path
self._config = load_json(self.get_path(CONFIG_FILE))
self._link_mode_enabled = False
self._link_mode_discovery_key = None
# Get the IP address that will be passed to during discovery
self.host_ip_addr = get_local_ip()
_LOGGER.error(
"Listen IP address not specified, auto-detected address is %s, (DEBUG)",
self.host_ip_addr,
)
# Get the ports that the Hue bridge will listen on
# ports are currently hardcoded as Hue apps expect these ports
self.http_port = 81
self.https_port = 444
# Get whether or not UPNP binds to multicast address (239.255.255.250)
# or to the unicast address (host_ip_addr)
self.upnp_bind_multicast = True
mac_addr = str(get_mac_address(ip=self.host_ip_addr))
if not mac_addr or len(mac_addr) < 16:
# fall back to dummy mac
mac_addr = "b6:82:d3:45:ac:29"
self.mac_addr = mac_addr
self.mac_str = mac_addr.replace(":", "")
self.bridge_id = (self.mac_str[:6] + "FFFE" + self.mac_str[6:]).upper()
self.bridge_uid = f"2f402f80-da50-11e1-9b23-{self.mac_str}"
@property
def link_mode_enabled(self):
"""Return state of link mode."""
return self._link_mode_enabled
@property
def link_mode_discovery_key(self):
"""Return the temporary token which enables linking."""
return self._link_mode_discovery_key
def get_path(self, filename):
"""Get path to file at data location."""
return os.path.join(self.data_path, filename)
async def entity_id_to_light_id(self, entity_id):
"""Get a unique light_id number for the hass entity id."""
numbers = await self.get_storage_value("light_ids")
for number, ent_id in numbers.items():
if entity_id == ent_id:
return number
number = "1"
if numbers:
number = str(max(int(k) for k in numbers) + 1)
await self.set_storage_value("light_ids", number, entity_id)
return number
async def light_id_to_entity_id(self, number):
"""Convert unique light_id number to entity id."""
return await self.get_storage_value("light_ids", number)
async def entity_by_light_id(self, light_id):
"""Return the hass entity by supplying a light id."""
entity_id = await self.light_id_to_entity_id(light_id)
if not entity_id:
raise Exception("Invalid light_id provided!")
entity = await self.hue.hass.get_state(entity_id)
if not entity:
raise Exception(f"Entity {entity_id} not found!")
return entity
async def get_storage_value(self, key, subkey=None):
"""Get a value from persistent storage."""
main_val = self._config.get(key, None)
if main_val is None:
return {}
if subkey:
return main_val.get(subkey, None)
return main_val
async def set_storage_value(self, key, subkey, value):
"""Set a value in persistent storage."""
needs_save = False
if subkey is None and self._config.get(key) != value:
# main key changed
self._config[key] = value
needs_save = True
elif subkey and key not in self._config:
# new sublevel created
self._config[key] = {subkey: value}
needs_save = True
elif subkey and self._config[key].get(key) != value:
# sub key changed
self._config[key][subkey] = value
needs_save = True
# save config to file if changed
if needs_save:
save_json(self.get_path(CONFIG_FILE), self._config)
async def delete_storage_value(self, key, subkey=None):
"""Delete a value in persistent storage."""
if subkey:
self._config[key].pop(subkey, None)
else:
self._config.pop(key)
save_json(self.get_path(CONFIG_FILE), self._config)
async def get_users(self):
"""Get all registered users as dict."""
return await self.get_storage_value("users")
async def get_user(self, username):
"""Get details for given username."""
return await self.get_storage_value("users", username)
async def create_user(self, devicetype):
"""Create a new user for the api access."""
if not self._link_mode_enabled:
raise Exception("Link mode not enabled!")
all_users = await self.get_users()
# devicetype is used as deviceid: <application_name>#<devicename>
# return existing user if already registered
for item in all_users.values():
if item["name"] == devicetype:
return item
# create username and clientkey with uuid module
username = str(uuid.uuid4()).replace("-", "")[:20]
clientkey = str(uuid.uuid4()).replace("-", "")
user_obj = {
"name": devicetype,
"clientkey": clientkey,
"create date": datetime.datetime.now().strftime("%Y-%M-%DT%H:%M:%S"),
"username": username,
}
await self.set_storage_value("users", username, user_obj)
return user_obj
async def delete_user(self, username):
"""Delete a user."""
await self.delete_storage_value("users", username)
async def enable_link_mode(self):
"""Enable link mode for the duration of 30 seconds."""
if self._link_mode_enabled:
return # already enabled
self._link_mode_enabled = True
def auto_disable():
self.hue.event_loop.create_task(self.disable_link_mode())
self.hue.event_loop.call_later(60, auto_disable)
_LOGGER.info("Link mode is enabled for the next 60 seconds.")
async def disable_link_mode(self):
"""Disable link mode on the virtual bridge."""
self._link_mode_enabled = False
_LOGGER.info("Link mode is disabled.")
async def enable_link_mode_discovery(self):
"""Enable link mode discovery for the duration of 120 seconds."""
if self._link_mode_discovery_key:
return # already active
self._link_mode_discovery_key = str(uuid.uuid4())
# create persistent notification in hass
# user can click the link in the notification to enable linking
url = f"http://{self.host_ip_addr}/link?token={self._link_mode_discovery_key}"
msg = "Click the link below to enable pairing mode on the virtual bridge:\n\n"
msg += f"**[Enable link mode]({url})**"
msg_details = {
"notification_id": "hue_bridge_link_requested",
"title": "Emulated HUE Bridge",
"message": msg,
}
await self.hue.hass.call_service(
"persistent_notification", "create", msg_details
)
_LOGGER.info(
"Link request detected - Use the Homeassistant frontend to confirm this link request."
)
# make sure that the notification and link request are dismissed after 90 seconds
def auto_disable():
self._link_mode_discovery_key = None
self.hue.event_loop.create_task(
self.hue.hass.call_service(
"persistent_notification",
"dismiss",
{"notification_id": "hue_bridge_link_requested"},
)
)
self.hue.event_loop.call_later(120, auto_disable)
| mustikkax/hass_emulated_hue | emulated_hue/config.py | config.py | py | 8,137 | python | en | code | 1 | github-code | 13 |
22178883441 | import math
import random
import numpy as np
from scipy.stats import t
import matplotlib.pyplot as plt
def random_variable(s, a):
r = sum([random.uniform(0,1) for _ in range(12)])
result = (r - 6) * s + a
return result
def correlation_field(xdata, ydata):
correlation_field = np.correlate(xdata, ydata, mode='full')
plt.scatter(xdata, ydata, alpha=0.5)
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Кореляційне поле")
plt.grid(True)
plt.show()
def selective_average(s, data):
average = np.mean(data)
print("Sample mean of variable", s, average)
return average
def sample_variable(s, data, average, n):
variance = np.sum((data - average)**2) / n
print("Sample variance of variable", s, variance)
return variance
def coefficient_correlation(xdata, ydata, xaverage, yaverage, n, sx, sy):
correlation = np.sum((xdata - xaverage) * (ydata - yaverage)) / (n * sx * sy)
print("Sample correlation coefficient", correlation)
return correlation
def check_theorem(r, n, a):
T = (r * math.sqrt(n - 2)) / math.sqrt(1 - r ** 2)
tkp = t.ppf(1 - a / 2, n - 2)
if np.abs(T) < tkp:
print("Нема підстав відкидати нульову гіпотезу")
return
print("Нульову гіпотезу відкидаєм")
| Vlad1kent1/MathStatistic | lab2/func.py | func.py | py | 1,343 | python | en | code | 0 | github-code | 13 |
32900177034 | # NO TOUCHING ============================================
from random import choice
food = choice(['apple','grape', 'bacon', 'steak', 'worm', 'dirt'])
# NO TOUCHING =============================================
if food == "apple" or "grape":
print("fruit")
elif food == "bacon" or "steak":
print("meat")
else:
print("yuck") | lepaclab/Python_Bootcamp | Food_classification.py | Food_classification.py | py | 349 | python | en | code | 0 | github-code | 13 |
70392556819 | from flask import Flask, render_template
import json
app = Flask(__name__)
# Just for pytest purposes
testing = 'Network Automation Training'
# Dummy Database data call
vendors = [
{'cisco': 'routers',
'juniper': 'switches',
'palo alto': 'firewall',
'aris': ' spine switch'},
{'country': 'USA',
'state': 'California',
'city': 'San Francisco',
'author': 'Alp'}
]
vendors_to_json = json.dumps(vendors, indent=4)
@app.route("/")
def home():
return render_template('home.html', vendor=vendors_to_json)
@app.route("/nornir")
def nornir():
return render_template('nornir.html')
if __name__ == '__main__':
app.run(debug=True)
| fonzynice/flaskdemo | myapp.py | myapp.py | py | 680 | python | en | code | 0 | github-code | 13 |
16129401623 | #!/usr/bin/python3
"""
Purpose:
"""
from openpyxl import Workbook
from openpyxl.chart import BarChart, Reference
from openpyxl.worksheet import worksheet
def main(filename):
wb = Workbook()
sheet = wb.active
# Add data to spreadsheet
data_rows = [
("Book", "Kindle", "Paperback"),
(1, 9.99, 15.99),
(2, 9.99, 25.99),
(3, 9.99, 25.99),
(4, 4.99, 29.99),
(5, 14.99, 39.99),
]
for row in data_rows:
sheet.append(row)
# Create the bar chart
bar_chart = BarChart()
data = Reference(worksheet=sheet, min_row=1, max_row=10, min_col=2, max_col=3)
bar_chart.add_data(data, titles_from_data=True)
sheet.add_chart(bar_chart, "E2")
wb.save(filename)
if __name__ == "__main__":
main("bar_chart.xlsx")
| udhayprakash/PythonMaterial | python3/11_File_Operations/02_structured_files/05_xls_files/openpyxl_module/i_charts.py | i_charts.py | py | 806 | python | en | code | 7 | github-code | 13 |
38317742695 | import random
print(
"The game is simple. I will choose a number from 1 to 100.Your job is to guess the number.Don't worry I will help you :)")
number = random.randrange(1, 100)
you_win = False
total_attempts = 0
while not you_win:
current_guess = int(input("Please choose a number from 1 to 100: "))
total_attempts += 1
if current_guess == number:
you_win = True
print(f"Yes! This is the number. You will win the game!Congratulations!You needed {total_attempts} attempts.")
elif number > current_guess:
print("No. The number is bigger")
elif number < current_guess:
print("No. The number is smaller")
| Tsveti1103/Guess-the-number-game | game.py | game.py | py | 659 | python | en | code | 1 | github-code | 13 |
3286012679 | import matplotlib.pyplot as plt
import numpy as np
from sklearn.cluster import KMeans
from djikstras import Dijkstra
robot_starting_location=np.array([(0,10),(0,20)])
parcel_list=np.array([(40,30),(10,40),(20,35),(20,50),(40,40)])
class Warehourse_Router:
'''
Takes initial robot and parcel locations as input and performs allocation as well as routing for each
robot.
'''
def __init__(self, robot_starting_location, parcel_list, ox=None, oy=None):
self.robot_starting_location=robot_starting_location.copy()
self.robot_list=robot_starting_location.copy()
self.parcel_list=parcel_list.copy()
self.mapped_parcels=dict()
self.n_robots=len(self.robot_list)
self.n_parcels=len(self.parcel_list)
self.dist_travelled=[0]*self.n_robots
self.task_complete=False
self.robot_plot=[self.robot_list.copy()]
self.parcel_plot=[self.parcel_list.copy()]
self.path_planner = Dijkstra(ox, oy, 1, 1)
self.rx=[[] for _ in range(self.n_robots)]
self.ry=[[] for _ in range(self.n_robots)]
self.obstacles=[ox,oy]
self.total_distance=0
self.execute()
def find_nearest_parcel(self,robot_number):
#for a specific robot find the nearest available parcel
nearest_parcel=0
min_dist= np.inf
for p in range(self.n_parcels):
l1_norm=np.linalg.norm(self.robot_list[robot_number]-self.parcel_list[p], ord=1)
if l1_norm<min_dist:
nearest_parcel=p
min_dist=l1_norm
return nearest_parcel,min_dist
def parcel_mapper(self):
kmeans = KMeans(n_clusters=self.n_robots, random_state=0).fit(self.parcel_list)
cluster_index = np.array(kmeans.labels_) #will be of the form [0,0,1,1,0,1] for 2 clusters
for i in range(self.n_parcels):
if cluster_index[i] in self.mapped_parcels:
self.mapped_parcels[cluster_index[i]].append(self.parcel_list[i])
else:
self.mapped_parcels[cluster_index[i]]=[self.parcel_list[i]]
for key in self.mapped_parcels:
self.mapped_parcels[key] = sorted(self.mapped_parcels[key], key = lambda k: np.linalg.norm(k-self.robot_list[key], ord=1))
fig=plt.figure()
ax1=fig.add_subplot(1,1,1)
ax1.grid(True)
ax1.set_xlim((-10,60))
ax1.set_ylim((-10,60))
ax1.plot(*zip(*self.mapped_parcels[0]),'.g',markersize=15)
ax1.plot(*zip(*self.mapped_parcels[1]),'.b',markersize=15)
ax1.plot(self.obstacles[0], self.obstacles[1], ".k")
def move_robot(self):
'''
It will allocate a parcel to each robot and move the robot to new location. If there are no more
parcels left, it will return all the robots to their starting locations.
'''
for r in range(self.n_robots):
if len(self.mapped_parcels[r]):
target=self.mapped_parcels[r].pop(0)
self.dist_travelled[r]+=np.linalg.norm(self.robot_list[r]-target, ord=1)
self.robot_list[r]=target
#that robot returns to home
elif (self.robot_list[r]!=self.robot_starting_location[r]).all():
target=self.robot_starting_location[r]
self.dist_travelled[r]+=np.linalg.norm(self.robot_list[r]-target, ord=1)
self.robot_list[r]=target
#that robot is already at home
else:
continue
self.robot_plot.append(self.robot_list.copy())
self.parcel_plot.append(self.parcel_list.copy())
if (self.robot_list==self.robot_starting_location).all():
self.task_complete=True
def plot_positions(self):
iterations=len(self.robot_plot)
fig=plt.figure(figsize=(3*iterations,3))
for i in range(iterations):
ax1=fig.add_subplot(1,iterations,i+1)
ax1.grid(True)
ax1.set_xlim((-10,60))
ax1.set_ylim((-10,60))
ax1.scatter(*zip(*self.robot_plot[i]),marker='^')
ax1.plot(self.obstacles[0], self.obstacles[1], ".k")
# if i<iterations-1:
# ax1.plot(self.rx[0][i],self.ry[0][i])
# ax1.plot(self.rx[1][i],self.ry[1][i])
# ax1.plot(self.rx[2][i],self.ry[2][i])
ax1.plot(*zip(*self.parcel_plot[i]), ".r",markersize=5)
plt.show()
pass
def execute(self):
self.parcel_mapper()
print(self.mapped_parcels)
while not self.task_complete:
self.move_robot()
self.plot_positions()
self.total_distance=sum(self.dist_travelled)
print("total distance travelled: ", sum(self.dist_travelled))
ox, oy = [], []
#square boundary
for i in range(-10, 60):
ox.append(i)
oy.append(-10.0)
for i in range(-10, 60):
ox.append(60.0)
oy.append(i)
for i in range(-10, 61):
ox.append(i)
oy.append(60.0)
for i in range(-10, 61):
ox.append(-10.0)
oy.append(i)
#intermediate obstacles
for i in range(0, 50):
ox.append(15.0)
oy.append(i)
for i in range(0, 50):
ox.append(35.0)
oy.append(50.0 - i)
router=Warehourse_Router(robot_starting_location, parcel_list,ox,oy) | rutvikbaxi/VRP_codes | warehouse_MRTA/Greedy_strategy/clustering_based.py | clustering_based.py | py | 5,315 | python | en | code | 0 | github-code | 13 |
18274342976 | #!/usr/bin/env python
import os
import subprocess
def install(alsi):
from al_services.alsvc_mcafee.mcafee_lib import McAfeeScanner
mcafee_tgz = 'vscl-l64-604-e.tar.gz'
remote_path = 'mcafee/' + mcafee_tgz
install_dir = os.path.join(alsi.alroot, 'support/mcafee')
if not os.path.exists(install_dir):
os.makedirs(install_dir)
local_path = os.path.join('/tmp', mcafee_tgz)
alsi.fetch_package(remote_path, local_path)
alsi.runcmd(' '.join(['tar -xvzf', local_path, '-C', install_dir]))
avupdate_dir = os.path.join(alsi.alroot, "var", "avdat")
mcafee_update_dir = os.path.join(avupdate_dir, "mcafee")
if not os.path.exists(mcafee_update_dir):
os.makedirs(mcafee_update_dir)
remote_av_file = 'avvdat-latest.zip'
remote_av_path = 'av_updates/mcafee/' + remote_av_file
local_av_path = os.path.join('/tmp', remote_av_file)
alsi.fetch_package(remote_av_path, local_av_path)
subprocess.call(['unzip', '-o', local_av_path, '-d', mcafee_update_dir])
scanner = McAfeeScanner(os.path.join(install_dir, 'uvscan'), mcafee_update_dir)
scanner.decompress_avdefinitions()
if __name__ == '__main__':
from assemblyline.al.install import SiteInstaller
install(SiteInstaller())
| deeptechlabs/cyberweapons | assemblyline/alsvc_mcafee/installer.py | installer.py | py | 1,258 | python | en | code | 78 | github-code | 13 |
9936505146 | #!/usr/bin/env python
# coding: utf-8
# # Exploratory Analysis for COVID19 [3 pts]
#
# Inspired by the paper of [Brinati et al. (2020)](https://zenodo.org/record/3886927#.X7Jy_ZMzbm1), I produce an exploratory analysis attempting to detect COVID-19 (SWAB) based on features such as gender, age, blood exams, etc.
# In[1]:
# Import basic libraries
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib
# get_ipython().run_line_magic('matplotlib', 'inline')
matplotlib.style.use('seaborn-bright')
# In[2]:
# Import libraries and data needed.
data = pd.read_excel('covid_study_v2.xlsx')
# In[3]:
# Take a short overview of the data.
data.tail(4)
# In[4]:
# Sum the number of empty entries in each columns.
data_isna_sum = data.isna().sum()
data.isna().sum()
# In[5]:
# Find the average empty entries in each columns.
data_isna_mean = data.isna().mean()
data.isna().mean()
# In[6]:
# Find the count of features that have missing values.
print( "The count of features that have a mean greater than 0 is :", len(data.isna().mean()[data.isna().mean() > 0]))
# In[7]:
# Import the data of Table 2 Features and missing values in the dataset published in the paper.
data_paper = pd.DataFrame([['CRP',6,2.1],
['AST',2,0.7],
['ALT',13,4.6],
['GGT',143,51.2],
['LDH',85,30.4],
['WBC',2,0.7],
['Platelets',2,0.7],
['Neutrophils',70,25],
['Lymphocytes',70,25],
['Monocytes',70,25],
['Eosinophils',70,25],
['Basophils',71,25.4]],
columns=['Feature', 'N◦ of missing', '% of missing on the total'])
data_paper
# In[8]:
# Check if the dataframes are equal.
data.equals(data_paper)
# In[9]:
# Find the count of features included.
print( "The count of features included is :", len(data_paper))
# ---
#
# I notice that in the paper one parameter is not included. This is the **ALP** parameter
#
# ---
# I binarise the "GENDER" column (only 0s and 1s should be included).
#
# In[10]:
# Change in place the value gender from string to integer by settin 0 for male and 1 for female.
data.GENDER.replace(['M','F'],[0,1],inplace=True)
# In[11]:
# Check a glimpse at the new dataset
data.head(3)
# In[12]:
len(data)
# I detect and replace any non-empty yet invalid values in all the columns (e.g., a non-integer in a column of integers).
# In[13]:
# Each column of the dataframe should be homogenous in itself, meaning it should include the same type of data
# First I check what type of data each columns has.
def check_columns_type(data):
prototype="%-8s %-30s %s"
print(prototype % ("Value type", "Column", "Example Value"))
print("-"*55)
print("-"*55)
for c in data.columns:
print(prototype % (data[c].dtype, c, data[c].iloc[1]) )
check_columns_type(data)
# In[14]:
# I notice that the column Lymphocytes is of object type even though it should be float64.
# We tranform it to numeric.
data['Lymphocytes'] = pd.to_numeric(data['Lymphocytes'],errors='coerce')
# In[15]:
# I re-check so as to ensure that the data are in the correct format
# Each column of the dataframe should be homogenous in itself, meaning it should include the same type of data
# First I check what type of data each columns has.
def check_columns_type(data):
prototype="%-8s %-30s %s"
print(prototype % ("Value type", "Column", "Example Value"))
print("-"*55)
print("-"*55)
for c in data.columns:
print(prototype % (data[c].dtype, c, data[c].iloc[1]) )
check_columns_type(data)
# * I plot a correlation heatmap
# In[16]:
data.corr()
# In[17]:
plt.figure(figsize=(16, 12)) # set the size of figure
# mask the one triangle of the map
# adjust mask to exclude the correlation of a value with its self
mask = np.triu(np.ones_like(data.corr(), dtype=np.bool))[1:, :-1]
corr = round(data.corr(),2).iloc[1:,:-1].copy() # calculate correlation and exclude autocorrelaton
heatmap = sns.heatmap(corr, annot=True, cmap='coolwarm',
mask = mask, linewidths = 4, square = True) # store the heatmap as object in order to assign attributes
heatmap.set_title('Correlation Heatmap', fontdict={'fontsize':14}, pad=20) # add title
# I fill in the empty cells per column, by using such a value that will not affect the variance of that column.
# In[18]:
# First I calculate the mean and variance per columns
print('The mean per column is:\n', data.mean())
# In[19]:
var_before_fill = data.var() # store the variance before filling the nan values
print('The variance per column is:\n', data.var())
# ---
#
# In order to ensure that the variance remains the same I worked as following:
#
# I calculate the second degree polynomial that gives a $x_{n+1}$ value, which once added to a x array of lenght n its variance remains the same: Given that Var and $\overline{x}$ is the variance and mean of the x array and $Var'$ and $\overline{x'}$ is the variance and mean of the x array once $x_{n+1}$ is appended we want that:
#
# $$Var' = \frac{1}{n} \sum_{i=1}^{n+1} (x_i - \overline{x'})^2 = \frac{1}{n} \sum_{i=1}^{n+1} (x_i - \overline{x'})^2 = Var \,\,\,\,\,(1)$$
#
# and
#
# $$\overline{x} = \frac{1}{n}\sum_{i=1}^{n} x_i \Rightarrow \sum_{i=1}^{n} x_i = n \overline{x} \,\,\,\,\,(2)$$
#
# ---
#
# ---
# Finally, once solving equation 1 and substituting $\overline{x'}$ with $\overline{x}$ we end up with this equation:
#
# $$\big[\frac{1}{n} \sum_{i=1}^{n} \frac{1}{(n+1)^2} + \frac{n}{(n+1)^2}\big] x_{n+1}^2 + \frac{1}{n}\sum_{i=1}^{n}[\frac{2n\overline{x}}{(n+1)^2} - \frac{2 x_i}{n+1} -\frac{2n}{(n+1)^2}\overline{x}] x_{n+1} + \big[\frac{1}{n} \sum_{i=1}^{n} [x_i^2 + (\frac{n}{n+1} \overline{x})^2 - 2 x_i \frac{n}{n+1} \overline{x}]\\ + \frac{n}{(n+1)^2}\overline{x}^2) - Var\big] = 0 $$
#
# The calculation of the above equation is explained [here](supplement.pdf).
#
#
# ---
# ---
# This is in the form $\alpha x_{n+1}^2+ \beta x_{n+1} + c = 0$ where $a = a_1 + a_2 $, $b = b_1 + b_2 + b_3 $ and $c = c_1 + c_2 +c_3 + c_4$.
#
# * $ a_1 = \color{black}{[\frac{1}{n} \sum_{i=1}^{n} \frac{1}{(n+1)^2}] }$
# * $a_2= \color{black}{\frac{n}{(n+1)^2}}$
# * $b_1 = \color{black}{\frac{2n\overline{x}}{(n+1)^2} - \frac{2 x_i}{n+1}}$
# * $b_2 = \frac{1}{n}[\sum_{i=1}^{n} b_1] x_{n+1} = \color{black}{\frac{1}{n}\sum_{i=1}^{n}[\frac{2n\overline{x}}{(n+1)^2} - \frac{2 x_i}{n+1}] }$
# * $b_3 = \color{black}{-\frac{2n}{(n+1)^2}\overline{x}}$
# * $c_1 = \color{black}{x_i^2 + (\frac{n}{n+1} \overline{x})^2 - 2 x_i \frac{n}{n+1} \overline{x}}$
# * $c_2 = \frac{1}{n}\sum_{i=1}^{n} c_1 = \color{black}{\frac{1}{n}\sum_{i=1}^{n}[x_i^2 + (\frac{n}{n+1} \overline{x})^2 - 2 x_i \frac{n}{n+1} \overline{x} ]}$
# * $c_3 = \color{black}{\frac{n}{(n+1)^2}\overline{x}^2}$
# * $c_4 = \color{black}{-Var}$
#
#
#
# ---
# In[20]:
# I declare the functions that will calculate the elements
# which constitute the a, b and c factors of the 2nd degree polynomial
def f_a1(n):
return 1 / ((n + 1)**2)
def f_a2(n):
return n / ((n + 1)**2)
############################
def f_b1(n, x_bar, x_i):
return (2 * n * x_bar) / ((n + 1)**2) - (2 * x_i) / (n + 1)
def f_b2(x, x_bar):
total = 0
for x_i in x:
total += f_b1(len(x), x_bar, x_i)
return total / float(len(x))
def f_b3(n, x_bar):
return - ((2 * x_bar * n) / ((n + 1)**2))
############################
def f_c1(n, x_bar, x_i):
return x_i**2 + ((n * x_bar) / (n + 1))**2 - ((2 * n * x_bar * x_i) / (n + 1))
def f_c2(x, x_bar):
total = 0
for x_i in x:
total += f_c1(len(x), x_bar, x_i)
return total / float(len(x))
def f_c3(n, x_bar):
return (n * (x_bar**2)) / ((n + 1)**2)
def f_c4(x):
return - np.var(x, ddof=1)
############################
# I prepare the input factors a, b and c to be inserted to the np.roots() function
# which calculates the two roots of a 2nd degree polynomial
def calc_coeff(x):
n = float(len(x))
x_bar = np.mean(x)
a = f_a1(n) + f_a2(n)
b = f_b2(x, x_bar) + f_b3(n, x_bar)
c = f_c2(x, x_bar) + f_c3(n, x_bar) + f_c4(x)
return (a, b, c)
# In[21]:
# I declare the function to use the a,b,c inputs, calculate the value to be added and check the new variance
#epsilon = 1e-20 # I want to have the same variance to the 20th decimal point
def generate_variance_invariant_value(x): # x is the array, ie. the data of each column
root = np.roots(calc_coeff(x))[0] # calculate the roots and store the possitive value
#print('root is:', root) # debugging
x_new = np.append(x, root) # append the root to the array
#print('I created', len(x_new)) # debugging
nvar = np.var(x_new, ddof=1) # calcute the variance of the new dataset
#print('The new variance is:', nvar) # debugging
#if math.fabs(nvar != np.var(x, ddof=1)) > epsilon: # check if the new variance is the same as the original
#raise Exception("Variances differ! %f vs %f" % (nvar, np.var(x, ddof=1)))
return root
# In[22]:
# Sum the number of empty entries in each columns.
data_isna_sum = data.isna().sum()
data.isna().sum()
# In[23]:
# For each columns I create a dataset with values that will fill the nan fields
# In[24]:
# WBC
WBC = data['WBC'].to_numpy() # store the values to a numpy array
WBC_nan_free = data['WBC'].dropna().to_numpy() # create an array without the nan values
nan_count_WBC = len(WBC) - len(WBC_nan_free) # count the number of nan values
WBC_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_WBC): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(WBC_nan_free) # create a new value
WBC_nan_free = np.append(WBC_nan_free,new_value) # append it to the new array to iterate again
WBC_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[25]:
data_isna_sum = data.isna().sum()
data.isna().sum()
# In[26]:
# The values should have the index of the nan field of the dataframe
index_nan_WBC = data.loc[pd.isna(data['WBC']), :].index # find the nan index
WBC_values_to_fill_nan_series = pd.Series(WBC_values_to_fill_nan, index=index_nan_WBC) # assign the index to the new data
# In[27]:
# Platelets
Platelets = data['Platelets'].to_numpy() # store the values to a numpy array
Platelets_nan_free = data['Platelets'].dropna().to_numpy() # create an array without the nan values
nan_count_Platelets = len(Platelets) - len(Platelets_nan_free) # count the number of nan values
Platelets_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_Platelets): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(Platelets_nan_free) # create a new value
Platelets_nan_free = np.append(Platelets_nan_free,new_value) # append it to the new array to iterate again
Platelets_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[28]:
# The values should have the index of the nan field of the dataframe
index_nan_Platelets = data.loc[pd.isna(data['Platelets']), :].index # find the nan index
Platelets_values_to_fill_nan_series = pd.Series(Platelets_values_to_fill_nan, index=index_nan_Platelets) # assign the index to the new data
# In[29]:
# Neutrophils
Neutrophils = data['Neutrophils'].to_numpy() # store the values to a numpy array
Neutrophils_nan_free = data['Neutrophils'].dropna().to_numpy() # create an array without the nan values
nan_count_Neutrophils = len(Neutrophils) - len(Neutrophils_nan_free) # count the number of nan values
Neutrophils_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_Neutrophils): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(Neutrophils_nan_free) # create a new value
Neutrophils_nan_free = np.append(Neutrophils_nan_free,new_value) # append it to the new array to iterate again
Neutrophils_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[30]:
# The values should have the index of the nan field of the dataframe
index_nan_Neutrophils = data.loc[pd.isna(data['Neutrophils']), :].index # find the nan index
Neutrophils_values_to_fill_nan_series = pd.Series(Neutrophils_values_to_fill_nan, index=index_nan_Neutrophils) # assign the index to the new data
# In[31]:
# Lymphocytes
Lymphocytes = data['Lymphocytes'].to_numpy() # store the values to a numpy array
Lymphocytes_nan_free = data['Lymphocytes'].dropna().to_numpy() # create an array without the nan values
nan_count_Lymphocytes = len(Lymphocytes) - len(Lymphocytes_nan_free) # count the number of nan values
Lymphocytes_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_Lymphocytes): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(Lymphocytes_nan_free) # create a new value
Lymphocytes_nan_free = np.append(Lymphocytes_nan_free,new_value) # append it to the new array to iterate again
Lymphocytes_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[32]:
# The values should have the index of the nan field of the dataframe
index_nan_Lymphocytes = data.loc[pd.isna(data['Lymphocytes']), :].index # find the nan index
Lymphocytes_values_to_fill_nan_series = pd.Series(Lymphocytes_values_to_fill_nan, index=index_nan_Lymphocytes) # assign the index to the new data
# In[33]:
# Monocytes
Monocytes = data['Monocytes'].to_numpy() # store the values to a numpy array
Monocytes_nan_free = data['Monocytes'].dropna().to_numpy() # create an array without the nan values
nan_count_Monocytes = len(Monocytes) - len(Monocytes_nan_free) # count the number of nan values
Monocytes_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_Monocytes): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(Monocytes_nan_free) # create a new value
Monocytes_nan_free = np.append(Monocytes_nan_free,new_value) # append it to the new array to iterate again
Monocytes_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[34]:
# The values should have the index of the nan field of the dataframe
index_nan_Monocytes = data.loc[pd.isna(data['Monocytes']), :].index # find the nan index
Monocytes_values_to_fill_nan_series = pd.Series(Monocytes_values_to_fill_nan, index=index_nan_Monocytes) # assign the index to the new data
# In[35]:
# Eosinophils
Eosinophils = data['Eosinophils'].to_numpy() # store the values to a numpy array
Eosinophils_nan_free = data['Eosinophils'].dropna().to_numpy() # create an array without the nan values
nan_count_Eosinophils = len(Eosinophils) - len(Eosinophils_nan_free) # count the number of nan values
Eosinophils_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_Eosinophils): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(Eosinophils_nan_free) # create a new value
Eosinophils_nan_free = np.append(Eosinophils_nan_free,new_value) # append it to the new array to iterate again
Eosinophils_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[36]:
# The values should have the index of the nan field of the dataframe
index_nan_Eosinophils = data.loc[pd.isna(data['Eosinophils']), :].index # find the nan index
Eosinophils_values_to_fill_nan_series = pd.Series(Eosinophils_values_to_fill_nan, index=index_nan_Eosinophils) # assign the index to the new data
# In[37]:
# Basophils
Basophils = data['Basophils'].to_numpy() # store the values to a numpy array
Basophils_nan_free = data['Basophils'].dropna().to_numpy() # create an array without the nan values
nan_count_Basophils = len(Basophils) - len(Basophils_nan_free) # count the number of nan values
Basophils_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_Basophils): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(Basophils_nan_free) # create a new value
Basophils_nan_free = np.append(Basophils_nan_free,new_value) # append it to the new array to iterate again
Basophils_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[38]:
# The values should have the index of the nan field of the dataframe
index_nan_Basophils = data.loc[pd.isna(data['Basophils']), :].index # find the nan index
Basophils_values_to_fill_nan_series = pd.Series(Basophils_values_to_fill_nan, index=index_nan_Basophils) # assign the index to the new data
# In[39]:
# CRP
CRP = data['CRP'].to_numpy() # store the values to a numpy array
CRP_nan_free = data['CRP'].dropna().to_numpy() # create an array without the nan values
nan_count_CRP = len(CRP) - len(CRP_nan_free) # count the number of nan values
CRP_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_CRP): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(CRP_nan_free) # create a new value
CRP_nan_free = np.append(CRP_nan_free,new_value) # append it to the new array to iterate again
CRP_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[40]:
# The values should have the index of the nan field of the dataframe
index_nan_CRP = data.loc[pd.isna(data['CRP']), :].index # find the nan index
CRP_values_to_fill_nan_series = pd.Series(CRP_values_to_fill_nan, index=index_nan_CRP) # assign the index to the new data
# In[41]:
# AST
AST = data['AST'].to_numpy() # store the values to a numpy array
AST_nan_free = data['AST'].dropna().to_numpy() # create an array without the nan values
nan_count_AST = len(AST) - len(AST_nan_free) # count the number of nan values
AST_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_AST): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(AST_nan_free) # create a new value
AST_nan_free = np.append(AST_nan_free,new_value) # append it to the new array to iterate again
AST_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[42]:
# The values should have the index of the nan field of the dataframe
index_nan_AST = data.loc[pd.isna(data['AST']), :].index # find the nan index
AST_values_to_fill_nan_series = pd.Series(AST_values_to_fill_nan, index=index_nan_AST) # assign the index to the new data
# In[43]:
# ALT
ALT = data['ALT'].to_numpy() # store the values to a numpy array
ALT_nan_free = data['ALT'].dropna().to_numpy() # create an array without the nan values
nan_count_ALT = len(ALT) - len(ALT_nan_free) # count the number of nan values
ALT_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_ALT): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(ALT_nan_free) # create a new value
ALT_nan_free = np.append(ALT_nan_free,new_value) # append it to the new array to iterate again
ALT_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[44]:
# The values should have the index of the nan field of the dataframe
index_nan_ALT = data.loc[pd.isna(data['ALT']), :].index # find the nan index
ALT_values_to_fill_nan_series = pd.Series(ALT_values_to_fill_nan, index=index_nan_ALT) # assign the index to the new data
# In[45]:
# ALP
ALP = data['ALP'].to_numpy() # store the values to a numpy array
ALP_nan_free = data['ALP'].dropna().to_numpy() # create an array without the nan values
nan_count_ALP = len(ALP) - len(ALP_nan_free) # count the number of nan values
ALP_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_ALP): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(ALP_nan_free) # create a new value
ALP_nan_free = np.append(ALP_nan_free,new_value) # append it to the new array to iterate again
ALP_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[46]:
# The values should have the index of the nan field of the dataframe
index_nan_ALP = data.loc[pd.isna(data['ALP']), :].index # find the nan index
ALP_values_to_fill_nan_series = pd.Series(ALP_values_to_fill_nan, index=index_nan_ALP) # assign the index to the new data
# In[47]:
# GGT
GGT = data['GGT'].to_numpy() # store the values to a numpy array
GGT_nan_free = data['GGT'].dropna().to_numpy() # create an array without the nan values
nan_count_GGT = len(GGT) - len(GGT_nan_free) # count the number of nan values
GGT_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_GGT): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(GGT_nan_free) # create a new value
GGT_nan_free = np.append(GGT_nan_free,new_value) # append it to the new array to iterate again
GGT_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[48]:
# The values should have the index of the nan field of the dataframe
index_nan_GGT = data.loc[pd.isna(data['GGT']), :].index # find the nan index
GGT_values_to_fill_nan_series = pd.Series(GGT_values_to_fill_nan, index=index_nan_GGT) # assign the index to the new data
# In[49]:
# LDH
LDH = data['LDH'].to_numpy() # store the values to a numpy array
LDH_nan_free = data['LDH'].dropna().to_numpy() # create an array without the nan values
nan_count_LDH = len(LDH) - len(LDH_nan_free) # count the number of nan values
LDH_values_to_fill_nan = [] # create the list to store the new values
for i in range(nan_count_LDH): # iterate so many times as the count of nan values
new_value = generate_variance_invariant_value(LDH_nan_free) # create a new value
LDH_nan_free = np.append(LDH_nan_free,new_value) # append it to the new array to iterate again
LDH_values_to_fill_nan.append(new_value) # return the values to be used for filling the nan val at the df cols
# In[50]:
# The values should have the index of the nan field of the dataframe
index_nan_LDH = data.loc[pd.isna(data['LDH']), :].index # find the nan index
LDH_values_to_fill_nan_series = pd.Series(LDH_values_to_fill_nan, index=index_nan_LDH) # assign the index to the new data
# In[51]:
# Store the data in a dictionary to use it as input for the fillnan function
data_fill_nan_values = {'WBC': WBC_values_to_fill_nan_series,
'Platelets': Platelets_values_to_fill_nan_series,
'Neutrophils': Neutrophils_values_to_fill_nan_series,
'Lymphocytes': Lymphocytes_values_to_fill_nan_series,
'Monocytes': Monocytes_values_to_fill_nan_series,
'Eosinophils': Eosinophils_values_to_fill_nan_series,
'Basophils': Basophils_values_to_fill_nan_series,
'CRP': CRP_values_to_fill_nan_series,
'AST': AST_values_to_fill_nan_series,
'ALT': ALT_values_to_fill_nan_series,
'ALP': ALP_values_to_fill_nan_series,
'GGT': GGT_values_to_fill_nan_series,
'LDH': LDH_values_to_fill_nan_series}
# In[52]:
# Finally I perform the fill of the calculated values to the respective fields
data.fillna(value = data_fill_nan_values, inplace=True)
# In[53]:
# Control the result.
# Check againg the sum the number of empty entries in each columns.
data.isna().sum()
# In[54]:
# Also check the variance
var_after_fill = data.var()
# In[55]:
data.var()
# In[56]:
# Check if the variance remains the same
dec = 8
round(var_after_fill, dec) == round(var_before_fill, dec)
# ---
#
# Indeed the variance remains the same to the $8^{th}$ decimal point.
#
# ---
# I show a pairplot of "AGE", "WBC", "CRP", "AST" and "Lymphocytes", by visualising SWAB as hue.
# In[57]:
part = data[['AGE','WBC','CRP','AST','Lymphocytes','SWAB']].copy()
# In[58]:
sns.pairplot(part, hue="SWAB", markers=["o", "o"], plot_kws={'alpha':0.6})
| aandrovitsanea/Exploratory-Data-Analysis-for-COVID-19-patients | exploratory_analysis_covid-19.py | exploratory_analysis_covid-19.py | py | 25,179 | python | en | code | 0 | github-code | 13 |
27736135526 | import turtle
wn=turtle.Screen()
turtle.bgcolor('white')
turtle.color('red')
turtle.shape('turtle')
t5=turtle.Turtle()
move=1
###############################
t5.speed("fastest")
for i in range(10):
for i in range(4):
t5.pu()
t5.goto(500,200)
t5.pd()
t5.color('orange')
t5.pensize(3)
t5.circle(50,steps=4)
t5.right(100)
t5.speed("fastest")
for i in range(6):
for i in range(4):
t5.pu()
t5.goto(0,0)
t5.pd()
t5.color('red')
t5.pensize(3)
t5.circle(100,steps=6)
t5.right(100)
turtle.done() | Swapnil-Singh-99/PythonScriptsHub | TurtleAnimations/CirclePattern.py | CirclePattern.py | py | 648 | python | en | code | 19 | github-code | 13 |
21126391353 | import sys
from random import randint
from PyQt5.QtWidgets import QWidget, QPushButton, QApplication
from PyQt5.QtGui import QColor, QPainter, QFont
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(600, 300, 500, 500)
self.setWindowTitle('Git и случайные окружности')
font = QFont()
font.setPointSize(16)
self.flag = False
self.btn = QPushButton(self)
self.btn.resize(200, 100)
self.btn.move(150, 200)
self.btn.setText('Начать рисование')
self.btn.setFont(font)
self.btn.clicked.connect(self.btn_pushed)
def btn_pushed(self):
self.btn.deleteLater()
self.flag = True
self.update()
def paintEvent(self, event):
if self.flag:
for i in range(1000):
self.paint()
def paint(self):
qp = QPainter()
qp.begin(self)
color = QColor(randint(0, 255), randint(0, 255), randint(0, 255))
qp.setBrush(color)
qp.setPen(color)
r = randint(50, 350)
qp.drawEllipse(randint(50, 450) - (r // 4), randint(50, 450) - (r // 4), r // 2, r // 2)
qp.end()
def except_hook(cls, exception, traceback):
sys.__excepthook__(cls, exception, traceback)
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
ex.show()
sys.excepthook = except_hook
sys.exit(app.exec())
| rybolovlevalexey/Chelyabinsk-Rybolovlev | main.py | main.py | py | 1,530 | python | en | code | 0 | github-code | 13 |
16394985132 | """
Remediate Evident Signature:
AWS:CLT-004 CloudTrail logs not integrated with CloudWatch
Description:
CloudTrail logs are not automatically sent to CloudWatch Logs. CloudWatch integration facilitates real-time
and historic activity logging based on user, API, resource, and IP address. It will also establish alarms and
notifications for anomalous or sensitive account activity.
Required Permissions:
- iam:CreateRole
- iam:GetRole
- iam:PutRolePolicy
- logs:CreateLogGroup
- logs:DescribeLogGroups
- logs:PutRetentionPolicy
- cloudtrail:UpdateTrail
Sample IAM Policy:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "IAMPermissions",
"Action": [
"iam:CreateRole",
"iam:GetRole",
"iam:PutRolePolicy"
],
"Effect": "Allow",
"Resource": "*"
},
{
"Sid": "CloudWatchLogsPermissions",
"Action": [
"logs:CreateLogGroup",
"logs:DescribeLogGroups",
"logs:PutRetentionPolicy"
],
"Effect": "Allow",
"Resource": "*"
},
{
"Sid": "CloudTrailPermissions",
"Action": [
"cloudtrail:UpdateTrail"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
"""
import json
import boto3
from botocore.exceptions import ClientError
from time import sleep
# Options:
#
# AWS IAM Role/ Policy and CloudWatch Logs Group Name
#
role_name = 'CloudTrail_CloudWatchLogs_Role'
policy_name = 'CWLogsAllowDeliveryPolicy'
log_group_name = 'CloudTrail/DefaultLogGroup'
def remediate(session, alert, lambda_context):
"""
Main Function invoked by index.py
"""
trail_name = alert['resource_id']
region = alert['region']
iam = session.client('iam', region_name=region)
logs = session.client('logs', region_name=region)
clt = session.client('cloudtrail', region_name=region)
# Create IAM Role and Policy
role_arn = new_iam_role(iam)
# Create CloudWatch Logs group
log_group_arn = new_log_group(logs) if (role_arn != 'fail') else 'fail'
# Update Trail
trail_status = update_trail(clt, trail_name, log_group_arn, role_arn) if (log_group_arn != 'fail') else 'fail'
# Result
if trail_status != 'fail':
print('Integrated Trail {} with CloudWatch Logs group {}.'.format(trail_name, log_group_name))
else:
print('Failed to integrated Trail {} with CloudWatch Logs.'.format(trail_name))
return
def new_iam_role(iam):
"""
Create new IAM Role and Inline Policy
"""
try:
role = iam.create_role(
Path = '/',
RoleName = role_name,
AssumeRolePolicyDocument = json.dumps(Templates.RolePolicy)
)
role_arn = role['Role']['Arn']
print('New IAM Role created: {}'.format(role_arn))
except ClientError as e:
if e.response['Error']['Code'] == 'EntityAlreadyExists':
role = iam.get_role(
RoleName = role_name
)
role_arn = role['Role']['Arn']
print('Using existing IAM Role: {}'.format(role_arn))
else:
print(e.response['Error']['Message'])
return 'fail'
try:
policy = iam.put_role_policy(
RoleName = role_name,
PolicyName = policy_name,
PolicyDocument = json.dumps(Templates.LogsPolicy)
)
except ClientError as e:
print(e.response['Error']['Message'])
return 'fail'
sleep(10) # Wait for IAM resource to be available. >> Gotta be a better way.. { wait? get? }.
return role_arn
def new_log_group(logs):
"""
Create CloudWatch Logs group
"""
try:
group = logs.create_log_group(
logGroupName = log_group_name
)
print('New CloudWatch Logs group created: {}'.format(log_group_name))
except ClientError as e:
if e.response['Error']['Code'] == 'ResourceAlreadyExistsException':
print('Using existing CloudWatch Log group: {}'.format(log_group_name))
else:
print(e.response['Error']['Message'])
return 'fail'
try:
retention = logs.put_retention_policy(
logGroupName = log_group_name,
retentionInDays = 30
)
except ClientError as e:
print(e.response['Error']['Message'])
try:
log_group = logs.describe_log_groups(logGroupNamePrefix = log_group_name)['logGroups']
except ClientError as e:
print(e.response['Error']['Message'])
return 'fail'
else:
log_group_arn = log_group[0]['arn']
return log_group_arn
def update_trail(clt, trail_name, log_group_arn, role_arn):
"""
Update Trail to integrate with CloudWatch Logs
"""
try:
result = clt.update_trail(
Name = trail_name,
CloudWatchLogsLogGroupArn = log_group_arn,
CloudWatchLogsRoleArn = role_arn,
)
except ClientError as e:
print(e.response['Error']['Message'])
return 'fail'
return
class Templates:
RolePolicy = {
'Version': '2012-10-17',
'Statement': [
{
'Sid': '',
'Effect': 'Allow',
'Principal': {
'Service': 'cloudtrail.amazonaws.com'
},
'Action': 'sts:AssumeRole'
}
]
}
LogsPolicy = {
'Version': '2012-10-17',
'Statement': [
{
'Action': [
'logs:CreateLogStream',
'logs:PutLogEvents'
],
'Effect': 'Allow',
'Resource': '*'
}
]
}
| cloudcraeft/remediate | remediate/runbook/AWS-CLT-004.py | AWS-CLT-004.py | py | 5,565 | python | en | code | 1 | github-code | 13 |
15867314837 | import requests
import json
def matchingWord(strs):
link= "https://api.datamuse.com/words"
param={}
param["rel_rhy"]=strs
param['max']=3
page=requests.get(link, param)
print(type(page))
jsonbanalam=page.json()
return [name['word'] for name in jsonbanalam]
inp=input("input word")
matchingWord(inp) | aniksen0/pythonScriptsAndProject | returnSameTypewordAPI .py | returnSameTypewordAPI .py | py | 314 | python | en | code | 0 | github-code | 13 |
72943446738 | budget = float(input())
number_of_statist = int(input())
one_dress_price = float(input())
decore = budget * 0.1
dress_price = number_of_statist * one_dress_price
if number_of_statist > 150:
dress_price *= 0.9
needed_money = decore + dress_price
differance = abs(needed_money - budget)
if needed_money > budget:
print('Not enough money!')
print(f'Wingard needs {differance:.2f} leva more.')
else:
print('Action!')
print(f'Wingard starts filming with {differance:.2f} leva left.') | Andon-ov/Python-Basics | conditional_statements_exercise/godzilla_vs_kong.py | godzilla_vs_kong.py | py | 498 | python | en | code | 0 | github-code | 13 |
34377177829 | #!/bin/python
import argparse
parser = argparse.ArgumentParser(description='Read a file in reverse')
parser.add_argument('filename', help='the file to read')
parser.add_argument('--limit', '-l', type=int, help='the number of lines to read')
parser.add_argument('--version', '-v', action='version', version='%(prog)s 1.0', help='Displays the version of the script')
args = parser.parse_args()
print(args.filename)
with open(args.filename) as f:
lines = f.readlines()
lines.reverse()
if args.limit:
lines = lines[:args.limit]
for line in lines:
print(line.strip()[::-1])
| karthikghantasala/Py-learn | scripting_parsing_cmd_line_params_1.py | scripting_parsing_cmd_line_params_1.py | py | 586 | python | en | code | 1 | github-code | 13 |
14724067420 | from django.http import HttpResponse
from django.shortcuts import render_to_response
import datetime
from django.utils import timezone
import wikipedia
import googleapiclient
import json
import wget
import random
import urllib.request
from urllib.parse import urlparse
def return_image_url(q):
url = "https://www.google.co.in/search?site=imghp&tbm=isch&source=hp&biw=1366&bih=643&q=laws+of+motion&oq=%s&gs_l=img.3..0l10.1703.8384.0.8578.19.14.3.1.1.1.232.1981.0j8j3.11.0....0...1ac.1.58.img..5.14.1779.KMzyD-aRlfQ" % q
return url
def home(request):
return render_to_response('index.html',{'date': timezone.now()})
class Search:
url = "http://ajax.googleapis.com/ajax/services/search/web?v=1.0"
def __init__(self,query):
"""
Performs google search
"""
self.query = query
query = urllib.parse.urlencode({'q':self.query})
self.response = urllib.request.urlopen(self.url + '&q=%s' % self.query)
self.result = self.response.read().decode("utf8")
self.data = json.loads(self.result)
self.response_data = self.data['responseData']
def __str__(self):
print ("Query: %s" % self.query)
def search_wikipedia(self):
try:
items = wikipedia.search(self.query)
flag = True if self.query in items else random.choice(items)
if flag:
self.page = wikipedia.page(self.query)
self.summary = wikipedia.summary(self.query)
except:
print("Something wrong...")
def search(request):
query = request.GET.get('q',' ')
search = Search(query)
search.search_wikipedia()
| aaditkapoor/helpmerevise | Revise/views.py | views.py | py | 1,506 | python | en | code | 0 | github-code | 13 |
74638018256 | """
hosu 변수를 단지로 읽어주시면 감사하겠습니다...
"""
from collections import deque
dx = [0,0,1,-1]
dy = [1,-1,0,0]
n = int(input())
q = deque()
board=[]
hosu = 0 # 단지 개수
for _ in range(n):
board.append(list(map(int, input())))
countList= [] # 각 단지마다 몇 채의 집이 있는지 개수 세기
for i in range(n):
for j in range(n):
if board[i][j] == 0: # 보드 안에 0으로 되어있는 부분 및 BFS 통해 개수가 세어진 호수를 제거하기 위한 목적
continue
q.append((i,j))
board[i][j] = 0
count = 1 # 현재 단지의 집 1채 추가
hosu += 1 # 단지 카운트 증가
while q: #BFS
x, y = q.popleft()
for d in range(4):
nx = x + dx[d]
ny = y + dy[d]
if nx <0 or nx>= n or ny <0 or ny>=n:
continue
if board[nx][ny] == 1: #만약 다음 집을 세지 않았다면
board[nx][ny] = 0 # 세기 편하기 위해 다음 집을 0으로 만들어주기 (방문확인 목적)
q.append((nx,ny)) # 다음 집을 queue에 삽입
count += 1 # 현재 단지의 집 1 채를 더 추가
countList.append(count)
countList.sort() # 정렬
print(hosu)
for i in countList:
print(i) | Coding-Test-Study-Group/Coding-Test-Study | byeongjoo/백준 2667 단지번호붙이기.py | 백준 2667 단지번호붙이기.py | py | 1,377 | python | ko | code | 4 | github-code | 13 |
73721998096 | ## This file contains the FuzzyClustering class definition
import math
import numpy as np
class FuzzyClustering:
### Class variables
ra = 1
rb = 1.25
alpha = 4 / ra / ra
beta = 4 / rb / rb
# original values elower = 0.15 and eupper = 0.5
elower = 0.01
eupper = 0.5
### Making sure all class variables are of class np.array
## Function to return the index of data points which has the largest potential
def _getIndexWithMaxPotential(self):
return(np.where(self.potentials == self.potentials.max())[0].min())
## Function to simply set k-th data point's potential to 0
def _setKthPotential(self, k):
self.potentials[k] = 0
## Function to calcualte the Euclidean distance between two data points
def _calclualteDistance(x1, x2):
# making sure x1 and x2 are of class np.array
x1 = np.array(x1)
x2 = np.array(x2)
return(((x1 - x2) ** 2).sum())
## Function to normalize data
def _normalizeData(self):
min_max = (np.amin(self.data, axis = 0), np.amax(self.data, axis = 0))
# set normalizing_factors
self.normalizing_factors = (2 / (min_max[1] - min_max[0]), -(min_max[1] + min_max[0]) / (min_max[1] - min_max[0]))
# apply normalizing factors to original data
for j in range(len(self.data[0])):
self.data[:,j] = self.normalizing_factors[0][j] * self.data[:,j] + self.normalizing_factors[1][j]
## Function to calculate initial potential for data point i
def _calculateInitialPotential(self, i):
p = 0
for j in range(len(self.data)):
p += math.exp(-FuzzyClustering.alpha * FuzzyClustering._calclualteDistance(self.data[i], self.data[j]))
return(p)
## function to set initial potential for all data points
def _setInitialPotentials(self):
## initialize potentials
self.potentials = np.zeros(len(self.data))
for i in range(len(self.potentials)):
self.potentials[i] = self._calculateInitialPotential(i)
## Function to update potentials for all data points
def _updatePotential(self):
# get index (k) of data point with max potential
k = self._getIndexWithMaxPotential()
# get data point and corresponding potential for k-th data point
pk = self.potentials[k]
xk = self.data[k]
# update potentials
for i in range(len(self.potentials)):
self.potentials[i] = self.potentials[i] - pk * math.exp(-FuzzyClustering.beta * FuzzyClustering._calclualteDistance(self.data[i], xk))
## Function to return the shortest distance between data[k] to all previous selected cluster centers
def _getDMin(self, k):
dist = []
for center in self.cluster_centers:
dist.append(FuzzyClustering._calclualteDistance(self.data[k], center))
return(np.min(dist))
## Initialize an object
def __init__(self, data):
"""This function initialize a FuzzyClustering object and set necessary parameters
data: 2-dimensional array
"""
self.data = np.array(data)
self.cluster_centers = []
### helper variable
self.grey_center_index = -1
# normalize data points
self._normalizeData()
# initialize potentials for all data points
self._setInitialPotentials()
# find the first cluster center and append it to cluster_centers
idx = self._getIndexWithMaxPotential()
self.cluster_centers.append(self.data[idx])
# save p1star
self.p1star = self.potentials[idx]
## extract clustering centers
def extractClusteringCenters(self):
## Stop until all criteria met
while True:
## update potentials accordingly
if (self.grey_center_index >= 0):
self._setKthPotential(self.grey_center_index)
self.grey_center_index = -1
else:
self._updatePotential()
## Find pkstar
k = self._getIndexWithMaxPotential()
pkstar = self.potentials[k]
## update potentials and determine whether to continue
if (pkstar > FuzzyClustering.eupper * self.p1star):
# append the new cluster center into the list
self.cluster_centers.append(self.data[k])
elif (pkstar < FuzzyClustering.elower * self.p1star):
break
else:
d_min = self._getDMin(k)
if (d_min / FuzzyClustering.ra + pkstar / self.p1star >= 1):
# append the new cluster center
self.cluster_centers.append(self.data[k])
else:
self.grey_center_index = k
## Get denormalized cluster centers
def getDenormalizedClusterCenters(self):
denormalized = np.array(self.cluster_centers.copy())
# apply normalizing factors to get data into original scales
for j in range(len(denormalized[0])):
denormalized[:,j] = (denormalized[:,j] - self.normalizing_factors[1][j]) / self.normalizing_factors[0][j]
return(denormalized)
| Donkeybobo/fuzzyclustering | scripts/FuzzyClustering.py | FuzzyClustering.py | py | 5,580 | python | en | code | 0 | github-code | 13 |
20694296655 | from django.shortcuts import HttpResponse
from rest_framework.views import APIView
from rest_framework.generics import GenericAPIView, ListAPIView
from rest_framework.response import Response
from student.models.student import Student, Branch
from student.serializers.user import UserSerializer
from student.serializers.student import StudentSerializer, BranchSerializer
from rest_framework.response import responses
from rest_framework_simplejwt.authentication import JWTAuthentication
from rest_framework.permissions import IsAuthenticated
import jwt
# API for get loging details
def getLoginUser(request):
header = request.headers['Authorization']
token = header.split(' ')
decodedata = jwt.decode(token[1], 'SECRET_KEY', algotithums= ['HS256'])
print(decodedata)
return decodedata['user_id']
# User CRUD
class StudentViews(GenericAPIView):
authentication_classes = [JWTAuthentication]
permission_classes = [IsAuthenticated]
serializer_class = StudentSerializer
queryset = Student.objects.all()
def get(self, request):
try:
id = request.data.get('roll_no', None)
if (id in (None, "")):
student = Student.objects.all()
serializer = StudentSerializer(student, many=True)
return Response(serializer.data)
elif Student.objects.filter(roll_No=id).exists():
student_serializer = StudentSerializer(Student.objects.get(roll_No = id))
return Response({'mesage':'student with roll number exists', 'data': student_serializer.data})
else:
return Response({'mesage':'student with roll number dosenot exists'})
except Exception as e:
return Response(str(e))
def post(self, request):
try:
if (request.data['roll_No'] not in (None, "") and request.data['branch_name'] not in (None, "")):
if not (Student.objects.filter(roll_No = request.data.get('roll_No')).exists()):
# student_serializer = UserSerializer(data= request.data)
print(request.data.get('roll_No'))
print(request.data['branch_name'])
branch = Branch.objects.get(student_branch= request.data['branch_name'])
print(branch)
# branch_serializer = BranchSerializer(data = branch)
# if branch_serializer.is_valid():
# print((branch_serializer))
student = Student(roll_No = request.data['roll_No'],
f_Name = request.data['f_Name'].capitalize(),
m_name = request.data['m_name'].capitalize(),
l_Name = request.data['l_Name'].capitalize(),
branch_Id = branch)
student.save()
return Response({"data": [StudentSerializer(student).data]})
# return Response({ "message":"Some data is missing....."})
return Response({"error": {}, "message":"Roll Number already exists"})
# return Response ({'error':'Branch id dose not exists'})
else:
return Response({'error': 'Invalid roll number of branch id'})
except Exception as e:
return Response({"error": str(e), "message":"Some data is missing....."})
def put(self, request):
try:
data = getLoginUser(request)
print(data)
return Response('data updated')
# if Student.objects.filter(id = request.get('id')).exists():
# student_serilizer = StudentSerializer(Student.objects.filter(id =request.get('id')))
# return Response({"student": student_serilizer.data})
except Exception as e:
return str(e) | sanjay-sba3/Student_management_pro | student/views/student.py | student.py | py | 4,017 | python | en | code | 0 | github-code | 13 |
12305133448 | import audiofile
import numpy as np
from pathlib import Path
from typing import Union
import matplotlib.pyplot as plt
from subprocess import Popen, PIPE
from scipy.signal import savgol_filter
from common import get_video_duration
def db_to_AR(dB: float) -> float:
"""Convert decibels to amplitude ratio"""
return np.sqrt(10 ** (dB / 10))
def AR_to_dB(AR: float) -> float:
"""Convert amplitude ratio to decibels"""
return np.log10(AR ** 2) * 10
def stereo_to_mono(signal: np.ndarray) -> np.ndarray:
if len(signal.shape) < 2:
return signal
if signal.shape[0] == 1:
return signal[0, :]
elif signal.shape[0] == 2:
return np.mean(signal / 2, axis=0)
else:
raise ValueError(
f"Signal has shape: {signal.shape}. Expected (0-2, N)")
def open_audio(fp: Path, mono=True, **kwargs) -> tuple[np.ndarray, int]:
signal, sr = audiofile.read(fp, **kwargs)
if mono:
return stereo_to_mono(signal), sr
else:
return signal, sr
def filter(signal: np.ndarray, window_length=121, polyorder=2) -> np.ndarray:
return savgol_filter(np.abs(signal), window_length, polyorder=polyorder)
def rle(inarray: np.ndarray) -> tuple[np.ndarray]:
""" run length encoding. Partial credit to R rle function.
Multi datatype arrays catered for including non Numpy
returns: tuple (runlengths, startpositions, values) """
ia = np.asarray(inarray) # force numpy
n = len(ia)
if n == 0:
return (None, None, None)
else:
y = ia[1:] != ia[:-1] # pairwise unequal (string safe)
i = np.append(np.where(y), n - 1) # must include last element posi
z = np.diff(np.append(-1, i)) # run lengths
p = np.cumsum(np.append(0, z))[:-1] # positions
return(z, p, ia[i])
def partition(arr: np.ndarray, size=2, step=1, min_delta=0):
"""Partition 1D array `arr` into tuples of size `size`, with difference of size `step` between the last element of the `i`th and first element of the `i+1`th tuples"""
n = arr.shape[0]
if step > 0:
num_parts = ((n - size) // step) + 1
else:
num_parts = n // size
ret: list[np.ndarray] = []
for i in range(num_parts):
start = i*step if (step > 0) else i*size
stop = start + size
if stop > arr.shape[0]:
break
if min_delta > 0 and (arr[stop-1] - arr[start]) < min_delta:
continue
ret.append(arr[start:stop])
if ret:
return np.vstack(ret)
else:
raise ValueError(f"No partitions found.")
def pad_intervals(intervals: np.ndarray, pad: int, total: int) -> np.ndarray:
padded = intervals.copy()
padded[1:, 0] -= pad
padded[:-1, 1] += pad
if padded[0, 0] > pad:
padded[0, 0] -= pad
if padded[-1, 1] + pad < total:
padded[-1, 1] += pad
return padded
def clean_intervals(
intervals: np.ndarray,
min_dur: float = 0.5,
min_gap: float = 0.2,
) -> list[tuple[float, float]]:
"""Clean up intervals by
1. ensuring intervals are greater than a minimum duration
2. ensuring intervals are separated by a minimum duration
3. concatenating overlapping intervals (https://stackoverflow.com/a/58976449/10120386)
Args:
intervals (np.ndarray): start and end times in first and second columns
min_dur (float, optional): minimum interval duration. Defaults to 0.1.
min_gap (float, optional): minimum separation between adjacent intervals. Defaults to 0.2.
Returns:
list[tuple[float, float]]: list of processed `(start, end)` times
"""
# remove intervals with less than the minimum duration
durs = np.diff(intervals).flatten()
arr = intervals[durs > min_dur]
# remove overlapping intervals and ensure gaps > min_gap
valid = np.zeros(arr.shape[0]+1, dtype=bool)
valid[[0, -1]] = 1
valid[1:-1] = arr[1:, 0] - np.maximum.accumulate(arr[:-1, 1]) >= min_gap
merged = np.vstack(
(
arr[valid[:-1], 0],
arr[valid[1:], 1]
)
).T
print(
"Results of `clean_intervals`\n"
f"\tInitial no.: {len(intervals)}\n"
f"\tCleaned no. (%): {merged.shape[0]} "
f"({100*merged.shape[0] / len(intervals):.1f}%)\n"
)
return merged
def invert_intervals(intervals: np.ndarray, total: float) -> np.ndarray:
"""Invert intervals of non-silence, returning intervals of silence
Args:
intervals (np.ndarray): intervals of non-silence
total (float): total duration in units of `intervals`
Raises:
AssertionError: odd number of intervals
Returns:
np.ndarray: intervals of silence
"""
flat = intervals.flatten()
if flat[0] == 0:
flat = flat[1:]
else:
flat = np.insert(flat, 0, 0)
if flat[-1] == total:
flat = flat[:-1]
else:
flat = np.append(flat, total)
try:
assert flat.shape[0] % 2 == 0
except AssertionError:
raise AssertionError(f"odd number of intervals: {flat.shape[0]}")
return partition(flat, size=2, step=0)
# ---------------------------------------------------------------------------- #
# Silence detection #
# ---------------------------------------------------------------------------- #
def plot_intervals(
signal: np.ndarray,
sampling_rate: float,
intervals: np.ndarray,
downsample=10
) -> None:
plt.rcParams['font.size'] = 11
fig, ax = plt.subplots(figsize=(9, 5), dpi=120, constrained_layout=True)
y = signal[::downsample]
t = np.arange(start=0, step=downsample,
stop=signal.shape[0]) / sampling_rate
ax.set_ylabel("Amplitude")
ax.set_xlabel("Time (s)")
ax.plot(t, y, lw=1, alpha=0.5, color='b', label='Signal')
ylim = ax.get_ylim()
kw = dict(alpha=0.35, color='r', linewidth=0, label='Silence')
for i in range(intervals.shape[0]):
x1, x2 = intervals[i, :]
ax.fill_betweenx(ylim, x1, x2, **kw)
handles, labels = ax.get_legend_handles_labels()
ax.legend(
handles=handles[:2],
labels=labels[:2],
loc='lower right',
bbox_to_anchor=[0.98, 0.02],
fancybox=False,
)
ax.locator_params(axis="both", nbins=5)
plt.show()
def get_intervals(
signal: np.ndarray,
sampling_rate: float,
window_length=21,
polyorder=3,
max_sil_vol=-33,
min_seg_dur=0.1,
min_sil_dur=0.5,
min_gap_dur=0.1,
adj_seg_pad=0.1,
plot=True
) -> np.ndarray:
min_seg_dur *= sampling_rate
min_sil_dur *= sampling_rate
filt = filter(signal, window_length=window_length, polyorder=polyorder)
lens, inds, vals = rle(filt <= db_to_AR(max_sil_vol))
sil_dur_mask = np.logical_and(vals == 1, lens >= min_sil_dur)
seg_dur_mask = np.logical_and(vals == 0, lens <= min_seg_dur)
mask = np.logical_or(sil_dur_mask, seg_dur_mask)
ret: list[tuple] = [(inds[i], inds[i] + lens[i])
for i in np.where(mask)[0]]
out = np.array(ret)
out[1:, 0] += 1
# add padding between adjacent intervals
if adj_seg_pad > 0:
out = pad_intervals(out, round(
adj_seg_pad*sampling_rate), signal.shape[0])
# clean up intervals
out = clean_intervals(
out / sampling_rate,
min_seg_dur / sampling_rate,
min_gap_dur
)
tot_sil_dur = (out[:, 1] - out[:, 0]).sum()
tot_sil_dur = f"{tot_sil_dur:.2f} s ({tot_sil_dur*100/(signal.shape[0] / sampling_rate):.2f}%)"
avg_sil_amp = np.mean([np.mean(np.abs(signal[r[0]:r[1]]))
for r in ret[:100]])
avg_sil_amp = f"{AR_to_dB(avg_sil_amp):.1f} dB ({avg_sil_amp*100/np.mean(np.abs(signal)):.2f}%)"
print(
f"""Result of `get_intervals`
Total detected silence duration: {tot_sil_dur:>8}
Average silence amplitude (n=100): {avg_sil_amp:>8}
"""
)
if plot:
plot_intervals(signal, sampling_rate, out)
# invert silent intervals to get intervals of non-silence for ffmpeg to concatenate
return invert_intervals(out, signal.shape[0]/sampling_rate)
# ---------------------------------------------------------------------------- #
# Splicing #
# ---------------------------------------------------------------------------- #
VIDEO_SPLICE = "[0:v]trim=start={t0}:end={t1},setpts=PTS-STARTPTS[{ind}v];"
AUDIO_SPLICE = "[0:a]atrim=start={t0}:end={t1},asetpts=PTS-STARTPTS[{ind}a];"
def create_splice_pair_str(row: np.ndarray, ind: int) -> str:
"""Return the command for including one interval (from `row[1]` to `row[2]` of the video) in the `concat` filter of `ffmpeg`"""
t0, t1 = row
return f"[0:v]trim=start={t0}:end={t1},setpts=PTS-STARTPTS[{ind}v];" +\
f"[0:a]atrim=start={t0}:end={t1},asetpts=PTS-STARTPTS[{ind}a];"
def splice_video(filepath: Path, intervals: np.ndarray) -> None:
filepath = filepath.parent / filepath.stem
output_name = f"{filepath}_silenceremove.mp4"
num = intervals.shape[0]
inds = np.arange(0, num, dtype=int)
# join all intervals into a single filter
# pairs = [create_splice_pair_str(intervals[i], i)
# for i in range(intervals.shape[0])]
pairs = np.apply_along_axis(
create_splice_pair_str,
axis=1,
arr=np.c_[intervals, inds].astype('<U300'),
)
concat = ''.join(
[f"[{i}v][{i}a]" for i in inds]
) + f"concat=n={num}:v=1:a=1[outv][outa]"
# write filter to file
filterpath = f"{filepath}__filter.txt"
with open(filterpath, "w", newline="", encoding="utf-8", errors="ignore") as io:
io.writelines(pairs)
io.write(concat)
io.flush()
# assemble final command
cmd = f"ffmpeg -hide_banner -i \"{filepath}.mp4\" -filter_complex_script {filterpath}" +\
" -map [outv] -map [outa] " +\
output_name
Popen(['powershell', cmd])
return
# ---------------------------------------------------------------------------- #
# Crossfade #
# ---------------------------------------------------------------------------- #
def get_fadetypes(fadetypes: Union[str, list[str]], num: int) -> list[str]:
if isinstance(fadetypes, str):
return [fadetypes] * num
if len(fadetypes) < num:
fadetypes.extend(
[fadetypes[-1]] * (num - len(fadetypes))
)
return fadetypes
def random_vfade(n: int, ignore=None) -> list[str]:
"""Choose `n` random video transitions.
Args:
n (int): number of transitions to choose
ignore (list[str], optional): names of transitions to not use. Defaults to None.
Returns:
list[str]: names of transitions
"""
FADETYPES = [
'fade', 'fadeblack', 'fadewhite', 'distance', 'wipeleft', 'wiperight', 'wipeup', 'wipedown', 'slideleft', 'slideright', 'slideup', 'slidedown', 'smoothleft', 'smoothright', 'smoothup', 'smoothdown', 'circleclose', 'circleopen', 'horzclose', 'horzopen', 'vertclose', 'vertopen', 'hlslice', 'hrslice', 'vuslice', 'vdslice', 'pixelize', 'hblur', 'zoomin'
]
if ignore:
FADETYPES = [f for f in FADETYPES if f not in ignore]
vfadetypes = [choice(FADETYPES) for _ in range(n)]
print("Using the following vfadetypes:", vfadetypes, sep='\n')
return vfadetypes
def build_crossfade_filter(
files: list[str],
xdur: float = 1.0,
vfadetypes: Union[str, list[str]] = "fade",
afadetypes: Union[str, list[str]] = "exp") -> str:
"""
curve types for audio cross fade
examples: http://underpop.online.fr/f/ffmpeg/help/afade.htm.gz
common types: tri (linear, default), exp, [q/h/e]sin, cub, squ, cbr, log
"""
vfade = "[{i}:v]xfade=transition={fade}:duration={d}:offset={off}[xv{i}]"
afade = "[{i}:a]acrossfade=d={d}:c1={fade}:c2={fade}[xa{i}]"
prev_offset = 0.
vfades = []
afades = []
# number of fades
num = (len(files) - 1)
vfadetypes = get_fadetypes(vfadetypes, num)
afadetypes = get_fadetypes(afadetypes, num)
for i, f in enumerate(files[:-1]):
dur = get_video_duration(f)
off = dur + prev_offset - xdur
prev_offset = off
if i == 0:
v_in, a_in = "[0:v]", "[0:a]"
else:
v_in, a_in = f"[xv{i}]", f"[xa{i}]"
vfades.append(
v_in +\
vfade.format(
d=xdur, off=off, i=i+1, fade=vfadetypes[i]
)
)
afades.append(
a_in +\
afade.format(d=xdur, i=i+1, fade=afadetypes[i])
)
params = f"{'; '.join(vfades)}; {'; '.join(afades)}"
lastMap = f"-map \"[xv{i+1}]\" -map \"[xa{i+1}]\""
return f"-filter_complex \"{params}\" {lastMap}"
"""
Example of xfading select trimmed streams, and concatting the xfade output to a different trim
```
ffmpeg -i ".\saikou_menhera.mp4" -filter_complex "
[0:v]trim=start=0:end=10,setpts=PTS-STARTPTS[1v];
[0:a]atrim=start=0:end=10,asetpts=PTS-STARTPTS[1a];
[0:v]trim=start=960:end=970,setpts=PTS-STARTPTS[2v];
[0:a]atrim=start=960:end=970,asetpts=PTS-STARTPTS[2a];
[0:v]trim=start=2820:end=2830,setpts=PTS-STARTPTS[3v];
[0:a]atrim=start=2820:end=2830,asetpts=PTS-STARTPTS[3a];
[1v][2v]xfade=transition=fade:duration=1:offset=9[xv1];
[1a][2a]acrossfade=d=1:c1=exp:c2=exp[xa1];
[xv1][xa1][3v][3a]concat=n=2:v=1:a=1[outv][outa]" `
-map "[outv]" -map "[outa]" -movflags +faststart -c:v libx264 -c:a aac -shortest "./test_trim_concat_xfade.mp4"
```
"""
def crossfade(
files: list[str],
xdur: float = 1.0,
vfadetypes: Union[str, list[str]] = "fade",
afadetypes: Union[str, list[str]] = 'exp',) -> str:
"""Apply `xafde` to a list of video files
Args:
files (list[str]): list of video files
xdur (float, optional): crossfade duration. Defaults to 1.0.
fadetype (str, optional): video fade type. Defaults to "fade".
afade_types (tuple[str, str], optional): audio fade type. Defaults to ('exp', 'exp').
Returns:
str: ffmpeg command
For more `fadetype` arguments, see:
https://trac.ffmpeg.org/wiki/Xfade
For more `afade_types`, see:
https://trac.ffmpeg.org/wiki/AfadeCurves
"""
ins = build_input_string(files)
filter_ = build_filter(
files,
xdur=xdur,
vfadetypes=vfadetypes,
afadetypes=afadetypes
)
outpath = files[0].stem
if "_" in outpath:
outpath = '_'.join(outpath.split("_")[:-1])
outpath = files[0].parent / f"{outpath}_crossfade{files[0].suffix}"
if check_overwrite(outpath):
cmd = f"{ins} {filter_} \"{outpath}\""
Popen(['powershell.exe', cmd])
return cmd
# ---------------------------------------------------------------------------- #
# Usage #
# ---------------------------------------------------------------------------- #
VIDEO_PATH = Path("../../../../Videos/subtitles/full_raw/")
def main(filename: str, dir: Path = VIDEO_PATH, plot=True, splice=True) -> None:
fp = VIDEO_PATH / filename
signal, sr = open_audio(fp)
intervals = get_intervals(
signal, sr,
window_length=51,
polyorder=3,
min_seg_dur=1.,
min_sil_dur=0.25,
max_sil_vol=-45,
plot=plot
)
print("First 10 intervals:\n", intervals[:10, :])
if splice:
splice_video(fp.parent / fp.stem, np.round(intervals, decimals=3))
if __name__ == '__main__':
main("ichinoseuruha_king.m4a", plot=False, splice=True)
| haganenoneko/ClippingTools | MainClippingTools/remove_silence.py | remove_silence.py | py | 14,893 | python | en | code | 0 | github-code | 13 |
7469976703 | from art import logo, vs
from game_data import streamers
from random import randint
from os import system
lost = False
streamers_temp = streamers.copy()
score = 0
def clear():
_ = system('clear')
def get_streamer():
global streamers_temp
streamer = list(streamers_temp.items())[randint(0, len(streamers_temp) - 1)]
streamers_temp.pop(streamer[0])
return streamer
streamer1 = get_streamer()
print(logo)
while not lost and streamers_temp:
next_streamer = get_streamer()
follower_count1 = "{:,}".format(streamer1[1])
print(f'Compare A: {streamer1[0]}, {follower_count1}')
print(vs)
print(f'Compare B: {next_streamer[0]}')
choice = input("Who has more subs? Type 'A' or 'B': ").upper()
follower_count2 = "{:,}".format(next_streamer[1])
if choice == 'A':
if streamer1[1] > next_streamer[1]:
score += 1
clear()
print(logo)
print(f'You are right! {streamer1[0]} has {follower_count1} subs and '
f'{next_streamer[0]} has {follower_count2} subs')
print(f' Current score: {score}')
else:
print(f'Sorry that is wrong, {streamer1[0]} has {follower_count1} subs and '
f'{next_streamer[0]} has {follower_count2} subs')
print(f'final score: {score}')
lost = True
else:
if streamer1[1] < next_streamer[1]:
streamer1 = next_streamer
score += 1
clear()
print(logo)
print(f'You are right! {streamer1[0]} has {follower_count1} subs and '
f'{next_streamer[0]} has {follower_count2} subs')
print(f' Current score: {score}')
else:
print(f'Sorry that is wrong, {streamer1[0]} has {follower_count1} subs and '
f'{next_streamer[0]} has {follower_count2} subs')
print(f'final score: {score}')
lost = True
if not streamers_temp:
print('YOU COMPLETED THE GAME !!!')
| Ashoolak/higherOrLowerTwitch | main.py | main.py | py | 2,014 | python | en | code | 0 | github-code | 13 |
20420653519 | #!/usr/bin/python3
import config
import csv
import datetime
import decimal
import json
import os
import re
import sys
import time
import itertools
from common import Common
from detectors.ficus import FICUS
from detectors.ketek import KETEK
from detectors.ic import IC
from detectors.keithley_i0 import KEITHLEY_I0
from detectors.keithley_itrans import KEITHLEY_ITRANS
from SEDSS.SEDSupplements import CLIMessage
from SEDSS.SEDSupport import readFile, dataTransfer, timeModule
from SEDSS.SEDTmuxSession import tmuxSession
# from SEDSS.SEDFileManager import path
# from SEDSS.SEDTransfer import SEDTransfer
import threading
from xdiWriter import XDIWriter
import threading
import log
import shutil
import signal
import subprocess
import math
try:
import PyQt5
import epics
import numpy as np
except ImportError as e:
print("Please make sure the following packages are installed:")
print("PyQt5, epics, numpy")
class HESEB:
def __init__(self,cfg, testingMode = "No"):
#
#epics.PV("SCAN:STOP").put(0)
log.setup_custom_logger("./SED_Scantool.log")
log.info("Start scanning tool")
self.loadPVS("HESEB")
self.PVs["SCAN:Stop"].put(0) # disable stop function
self.PVs["SCAN:pause"].put(0) # flush scan pause pv
self.PVs["Calibration:Energy"].put(1) # disable I0 vs time plotting
self.PVs["I0:TRIGGER"].put(1) # disable I0 vs time plotting
self.PVs["It:TRIGGER"].put(1) # disable It vs time plotting
# self.PVs["Voltage:Validation"].put(0) # enable voltage source
epics.PV("VOLTAGE:VALIDATION").put(0) # enable voltage source
self.KeithelyI0PV = readFile("pvlist/KEITHLEY_I0.json").readJSON()
self.voltageSourcePARAM = []
# get the values of voltage source parameters before reset
self.voltageSourcePARAM.append(epics.PV(self.KeithelyI0PV["PV"]["voltageSourceEnable"]["pvname"]).get())
self.voltageSourcePARAM.append(epics.PV(self.KeithelyI0PV["PV"]["voltageSourceRange"]["pvname"]).get())
self.voltageSourcePARAM.append(epics.PV(self.KeithelyI0PV["PV"]["voltageSourceCurrentLimit"]["pvname"]).get())
self.voltageSourcePARAM.append(epics.PV(self.KeithelyI0PV["PV"]["voltageSourceVoltageRBV"]["pvname"]).get())
self.paths = Common.loadjson("configrations/paths.json")
self.cfg = cfg
self.scanLimites = readFile("configrations/limites.json").readJSON()
#log.info("Experiment configurations: ({})".format(json.dumps(self.cfg, indent=2, sort_keys=True)))
log.info("Experiment scan limites: ({})".format(json.dumps(self.scanLimites, indent=2, sort_keys=True)))
CLIMessage(" Confegrations to be implemented: {}".format(self.cfg), "M")
self.detChosen = None
self.userinfo = Common.loadjson("configrations/userinfo.json")
self.initPaths()
self.initPGM()
self.initDetectors()
# Set ^C interrupt to abort the scan
signal.signal(signal.SIGINT, self.signal_handler)
if testingMode == "No":
log.info("Testing mode: No")
self.runPauseMonitor()
else:
log.info("Testing mode: Yes")
self.tmuxSessionToKill = ['voltageSourceValidation', 'I0_startAcquire']
tmuxSession(self.tmuxSessionToKill).kill()
subprocess.Popen("./voltageSourceValidation.sh")
self.startScan()
def runPauseMonitor(self):
log.info("start pause trigger monitor")
PauseMonitorThread = threading.Thread(target=self.pauseTrigger, args=(), daemon=True)
PauseMonitorThread.start()
def loadPVS(self,name):
log.info("load PVs")
JsonPVlist = Common.loadjson("pvlist/{}.json".format(name))
self.PVs = {}
self.motors = {}
DisconnectedPvs = []
for entry,pvname in JsonPVlist["PV"].items():
pvname=pvname["pvname"]
PVobj = epics.PV(pvname)
if PVobj.get() is None:
#print("{} : is not connected\n".format(pvname))
CLIMessage("{} : is not connected".format(pvname), "E")
DisconnectedPvs.append("{}\n".format(pvname))
else:
#print("{} : is connected\n".format(pvname))
CLIMessage("{} : is connected".format(pvname), "I")
self.PVs[entry] = PVobj
for entry,mtrname in JsonPVlist["Motors"].items():
pvname=mtrname["pvname"]
MTRobj = epics.Motor(pvname)
if MTRobj is None:
#print("{} : is not connected\n".format(pvname))
CLIMessage("{} : is not connected".format(pvname), "E")
DisconnectedPvs.append("{}\n".format(pvname))
else:
#print("{} : is connected\n".format(pvname))
CLIMessage("{} : is connected".format(pvname), "I")
self.motors[entry] = MTRobj
if len(DisconnectedPvs):
log.error("Disconnected PVs: {}".format(DisconnectedPvs))
Common.show_message(PyQt5.QtWidgets.QMessageBox.Critical,"The following PVs are disconnected:\n {}".format(" ".join(DisconnectedPvs)),"scan tool" ,PyQt5.QtWidgets.QMessageBox.Ok)
sys.exit()
def initPaths(self):
log.info("Paths initialization")
self.creationTime = str(time.strftime("%Y%m%dT%H%M%S"))
self.BasePath = "{}/{}-{}".format(self.paths["local_data_path"],self.cfg["DataFileName"],self.creationTime)
self.cfgfilepath = "{}/{}_config_{}.cfg".format(self.BasePath,self.cfg["DataFileName"],self.creationTime)
self.localDataPath = "{}".format(self.BasePath)
#self.PVs["SCAN:Path"].put(self.localDataPath)
if not os.path.exists(self.BasePath):
log.info("Create base directory: {}".format(self.BasePath))
os.makedirs(self.BasePath)
with open(self.cfgfilepath,'w') as cfgfile:
json.dump(self.cfg,cfgfile)
cfgfile.close()
self.dataFileName = "{}-{}.dat".format(self.cfg["DataFileName"], str(datetime.datetime.now()))
self.dataFileFullPath = "{}/{}".format(self.localDataPath, self.dataFileName)
self.expStartTimeDF = str(time.strftime("%Y-%m-%dT%H:%M:%S")) # to be added to xdi file as a content
"""
Writing the data path into file to be available to the plotting tool.
"""
with open("./tmp/SEDPath.txt",'w') as SEDPath:
SEDPath.write(self.localDataPath)
SEDPath.close()
if not os.path.exists(self.localDataPath):
os.makedirs(self.localDataPath)
def drange(self,start,stop,step,prec=10):
log.info("Calculating energy points")
decimal.getcontext().prec = prec
points = []
r= decimal.Decimal(start)
step = decimal.Decimal(step)
while r <=stop:
points.append(float(r))
r += step
return points
def generateScanPoints(self):
log.info("Calculating samples, scans and Intervals")
Samples = range(1,self.cfg["Nsamples"]+1)
Scans = range(1,self.cfg["Nscans"]+1)
Intervals = range(1,self.cfg["NIntervals"]+1)
return itertools.product(Samples,Scans,Intervals)
def initPGM(self):
log.info("PGM initialization")
self.PVs["SCAN:pause"].put(0, wait=True) # set pause flag to Fales
self.motors["PGM:Grating"].put("stop_go",0) # Stop
time.sleep(0.1)
self.motors["PGM:Grating"].put("stop_go",3) # Go
time.sleep(0.1)
self.motors["PGM:M2"].put("stop_go",0) # Stop
time.sleep(0.1)
self.motors["PGM:M2"].put("stop_go",3) # Go
time.sleep(0.1)
self.PVs["PGM:Energy:Reached"].put(1, wait = True)
self.energy0 = self.cfg["Intervals"][0]["Startpoint"]
log.info("Move PGM to initial energy ({})".format(self.energy0))
self.MovePGM(self.energy0)
def MoveSmpX(self,SP):
log.info("Move sample X to: {}".format(SP))
self.motors["SMP:X"].put("stop_go",3) # Go
self.motors["SMP:X"].move(SP)
time.sleep(1)
while not self.motors["SMP:X"].done_moving:
CLIMessage("sample X moving ...", "IG")
time.sleep(1)
def MoveSmpY(self,SP):
log.info("Move sample Y to: {}".format(SP))
self.motors["SMP:Y"].put("stop_go",3) # Go
self.motors["SMP:Y"].move(SP)
time.sleep(1)
while not self.motors["SMP:Y"].done_moving:
CLIMessage("sample Y moving ...", "IG")
time.sleep(1)
def clearPlot(self):
log.info("Clear plots PVs and parameters")
self.Energy = []
self.I0 = []
self.It = []
self.It2 = []
self.AbsTr = []
self.AbsTr2 = []
self.If = []
self.AbsFlu = []
self.PVs["PLOT:Energy"].put(self.Energy)
self.PVs["PLOT:I0"].put(self.I0)
self.PVs["PLOT:It"].put(self.It)
self.PVs["PLOT:It2"].put(self.It2)
self.PVs["PLOT:AbsTr"].put(self.AbsTr)
self.PVs["PLOT:AbsTr2"].put(self.AbsTr2)
self.PVs["PLOT:If"].put(self.If)
self.PVs["PLOT:AbsFlu"].put(self.AbsFlu)
def setPlotData(self):
log.info("Setting plots data")
self.PVs["PLOT:Energy"].put(self.Energy)
self.PVs["PLOT:I0"].put(self.I0)
self.PVs["PLOT:It"].put(self.It)
self.PVs["PLOT:It2"].put(self.It2)
self.PVs["PLOT:AbsTr"].put(self.AbsTr[1:])
self.PVs["PLOT:AbsTr2"].put(self.AbsTr2)
self.PVs["PLOT:If"].put(self.If)
self.PVs["PLOT:AbsFlu"].put(self.AbsFlu)
def checkPause(self):
diffTime = 0
pauseFlag = 0
startTime = time.time()
while self.PVs["SCAN:pause"].get():
pauseFlag = 1
diffTime = time.time() - startTime
CLIMessage("Scan is paused | pausing time(sec): {}".format(diffTime), "IO")
time.sleep(0.1)
if pauseFlag == 1:
log.warning("Scan was paused | pausing time(sec): %f ", diffTime)
def pauseTrigger(self):
currentOk = True
photonShutterOk = True
radiationShutterOk = True
KeithelyI0OK = True
ringLowerCurrent = self.scanLimites["SRLowerCurrent"]
ringUpperCurrent = self.scanLimites["SRUpperCurrent"]
KeithelyI0LowerLimit = self.scanLimites["KEITHELY_I0LowerRBV"]
#reading detectors PVs
KeithelyI0ReadOut = epics.PV(self.KeithelyI0PV["PV"]["picoAmmeterI0AcqReadOut"]["pvname"])
"""
setup writing flages to avoid continues writing logs in the log file
"""
currentLogFlag = 0
photonShutterLogFlag = 0
radiationShutterLogFlag = 0
KeithelyI0LogFlag = 0
while True:
photonShutterStatus = self.PVs["photonShutter:Status"].get()
radiationShutterStatus = self.PVs["radiationShutter:Status"].get()
#StopperStatus = self.PVs["STOPPER:Status"].get()
currentCurrent = self.PVs["RING:Current"].get()
KeithelyI0ReadOut = epics.PV(self.KeithelyI0PV["PV"]["picoAmmeterI0AcqReadOut"]["pvname"]).get()
################### Check current parameters ###############
if ringLowerCurrent <= currentCurrent <= ringUpperCurrent:
currentOk = True
if currentLogFlag == 1:
log.warning("SR current is returned to allowed limites, now it is: {} mA."
.format(currentCurrent))
currentLogFlag = 0
else:
currentOk = False
if currentLogFlag == 0:
log.warning("Scan is paused | SR current is: {} mA.".format(currentCurrent))
currentLogFlag = 1
################### Check photonShutter parameters ###############
#print (self.PVs["photonShutter:Status"].get())
if photonShutterStatus == 1: # shutter is open 1, undefined 0, 2 closed, 3 interlocked
photonShutterOk = True
if photonShutterLogFlag == 1:
log.warning("Photon Shutter status is returned to allowed limites, now it is: open")
photonShutterLogFlag = 0
else:
photonShutterOk = False
if photonShutterLogFlag == 0:
log.warning("Scan is paused | Photon shutter status is: closed")
photonShutterLogFlag = 1
################### Check radiationShutter parameters ###############
if radiationShutterStatus == 1: # shutter is open 1, undefined 0, 2 closed, 3 interlocked
radiationShutterOk = True
if radiationShutterLogFlag == 1:
log.warning("Radiation shutter status is returned to allowed limites, now it is: open")
radiationShutterLogFlag =0
else:
radiationShutterOk = False
if radiationShutterLogFlag == 0:
log.warning("Scan is paused | Radiation shutter status is: closed")
radiationShutterLogFlag = 1
#################### Check ROIs if current, shutters and stopper are okay ###############
if currentOk and photonShutterOk and radiationShutterOk == True:
#################### Check Keithely_I0 ####################
if KeithelyI0ReadOut >= KeithelyI0LowerLimit:
KeithelyI0OK = True
if KeithelyI0LogFlag == 1:
log.warning("Keithely_I0 value is returned to allowed limites, it is now {}"
.format(KeithelyI0ReadOut))
KeithelyI0LogFlag = 0
else:
KeithelyI0OK = False
if KeithelyI0LogFlag == 0:
log.warning("Scan is paused | Keithely_I0 readout({}) is below the allowed limit ({})"
.format(KeithelyI0ReadOut,KeithelyI0LowerLimit))
KeithelyI0LogFlag = 1
# if any of below is false, pause the scan
if False in (currentOk, photonShutterOk, radiationShutterOk, KeithelyI0OK):
self.PVs["SCAN:pause"].put(1) # 1 pause, 0 release
else:
self.PVs["SCAN:pause"].put(0)
time.sleep(self.scanLimites["checkLimitesEvery"]) # time in seconds
def stopScanning(self):
self.PVs["SCAN:Stop"].put(1) # to make the interlock of voltage source
self.PVs["PGM:Energy:Reached"].put(1, wait=True)
log.warning("Stop button has been pressed, runinig scan is terminated !!")
os.rename("SED_Scantool.log", "SEDScanTool_{}.log".format(self.creationTime))
shutil.move("SEDScanTool_{}.log".format(self.creationTime), "{}/SEDScanTool_{}.log".format(self.localDataPath, self.creationTime))
self.dataTransfer()
sys.exit()
def initDetectors(self):
#self.available_detectors = ["IC1","IC2","IC3","KETEK","FICUS"]
log.info("Detectors initialization")
self.available_detectors = ["IC","KETEK","FICUS"]
self.Ingtime = [0.005, 0.0075, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1, 2.5, 5, 7.5, 10]
self.detectors = []
detlist = self.cfg["detectors"]
log.info("Chosen detectors are {}".format(detlist))
self.detChosen = detlist
for det in detlist:
if det in ("IC1", "IC2", "IC3"):
cfg={}
self.detectors.append(IC("IC", self.paths))
elif det == "KETEK":
self.detectors.append(KETEK("KETEK",self.paths))
elif det == "FICUS":
self.detectors.append(FICUS("FICUS",self.paths,self.userinfo))
elif det == "KEITHLEY_I0":
self.detectors.append(KEITHLEY_I0("KEITHLEY_I0",self.paths,self.userinfo,self.voltageSourcePARAM))
elif det == "KEITHLEY_Itrans":
self.detectors.append(KEITHLEY_ITRANS("KEITHLEY_ITRANS",self.paths,self.userinfo))
elif not det in self.available_detectors:
raise Exception("Unknown detector")
log.error("Unknown detector is Chosen")
def plotting(self):
#################### Plotting ####################
if "KEITHLEY_Itrans" in self.cfg["detectors"]:
plotting = self.paths["HESEB_ScanTool_I0_It"]
log.info("HESEB_ScanTool_I0_It started")
else:
plotting = self.paths["HESEB_ScanTool_I0"]
log.info("HESEB_ScanTool_I0 started")
self.plot = plotting
subprocess.Popen(self.plot)
def signal_handler(self, sig, frame):
"""Calls abort_scan when ^C is typed"""
if sig == signal.SIGINT:
self.PVs["SCAN:Stop"].put(1) # to make the interlock of voltage source
self.PVs["PGM:Energy:Reached"].put(1, wait=True)
log.warning("Ctrl + C (^C) has been pressed, runinig scan is terminated !!")
os.rename("SED_Scantool.log", "SEDScanTool_{}.log".format(self.creationTime))
shutil.move("SEDScanTool_{}.log".format(self.creationTime), "{}/SEDScanTool_{}.log".format(self.localDataPath, self.creationTime))
self.dataTransfer()
sys.exit()
| SESAME-Synchrotron/HESEBScanTool | heseb.py | heseb.py | py | 14,968 | python | en | code | 0 | github-code | 13 |
28242146135 |
# coding: utf-8
# In[1]:
import pandas as pd
# In[3]:
x = (1, 'a', 2, 'b')
type(x)
# In[4]:
x = [1, 'a', 2, 'b']
type(x)
# In[6]:
x.append(3.3)
print(x)
# In[7]:
for item in x:
print(item)
# In[8]:
i = 0
while(i != len(x)):
print(x[i])
i = i + 1
# In[9]:
1 in [1, 2, 3]
# In[10]:
x = 'This is a string'
print(x[0])
print(x[0:1])
print(x[0:2])
# In[11]:
x[-1]
# In[12]:
x[-4:-2]
# In[13]:
x[:3]
# In[15]:
x[3:]
# In[18]:
x = 'Dr. Christopher Brooks'
print(x[3:15])
# In[19]:
firstname = 'Christopher Arthur Hansen Brooks'.split(' ')[0]
lastname = 'Christopher Arthur Hansen Brooks'.split(' ')[-1]
print(firstname)
print(lastname)
# In[20]:
x= {'Christopher Brooks':'brooksch@umich.edu', 'Bill Gates' : 'billg@microsoft.com'}
x['Christopher Brooks']
# In[21]:
x['Kevyn Collins-Thompson'] = None
x['Kevyn Collins-Thompson']
# In[22]:
for name in x:
print(x[name])
# In[23]:
for name, email in x.items():
print(name)
print(email)
# x = ('Christopher', 'Brooks', 'brooksch@umich.edu')
# fname, lname, email = x
# In[28]:
fname
# In[29]:
lname
# In[30]:
email
# In[31]:
x = ('Christopher', 'Brooks', 'brooksch@umich.edu', 'Ann Arbor')
# In[32]:
print('Chris' + str(2))
# In[34]:
sales_record = {'price' : 3.24,
'num_items' : 4,
'person' : 'Chris'}
sales_statement = '{} bought {} item(s) at a price of {} each for a total of {}'
print(sales_statement.format(sales_record['person'],
sales_record['num_items'],
sales_record['price'],
sales_record['num_items'] * sales_record['price']))
# In[40]:
import csv
get_ipython().magic('precision 2')
with open('mpg.csv') as csvfile:
mpg = list(csv.DictReader(csvfile))
mpg[:3]
# In[41]:
mpg[:3]
# In[42]:
len(mpg)
# In[43]:
mpg[0].keys()
# In[45]:
sum(float(d['cty']) for d in mpg) / len(mpg)
# In[46]:
sum(float(d['hwy']) for d in mpg)/ len(mpg)
# In[48]:
cylinders = set(d['cyl'] for d in mpg)
cylinders
# In[49]:
CtyMpgByCyl = []
for c in cylinders:
summpg = 0
cyltypecount = 0
for d in mpg:
if d['cyl'] == c:
summpg += float(d['cty'])
cyltypecount += 1
CtyMpgByCyl.append((c, summpg / cyltypecount))
CtyMpgByCyl.sort(key=lambda x: x[0])
CtyMpgByCyl
# In[50]:
vehicleclass = set(d['class'] for d in mpg)
vehicleclass
# In[52]:
HwyMpgByClass = []
for t in vehicleclass: # iterate over all the vehicle classes
summpg = 0
vclasscount = 0
for d in mpg:
if d['class'] == t:
summpg += float(d['hwy'])
vclasscount += 1 # increment the count
HwyMpgByClass.append((t, summpg / vclasscount))
HwyMpgByClass.sort(key=lambda x: x[1])
HwyMpgByClass
# In[ ]:
| kammitama5/Data_Science_001 | JupyterScratchNotes_001.py | JupyterScratchNotes_001.py | py | 2,891 | python | en | code | 0 | github-code | 13 |
4991580174 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# This file is part of ArchSetup.
#
# ArchSetup is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# ArchSetup is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with ArchSetup. If not, see <http://www.gnu.org/licenses/>.
import textwrap
import curses
from Interface.Widgets.Widget import Widget
class ProgressWidget(Widget):
def __init__(self, y, x, percent, length):
self.percent = percent
self.length = length
super().__init__(y, x, 1, length)
def draw(self, window):
(posy, posx) = self.position()
if self.ishighlighted():
window.addstr(posy, posx, '[' + '#' * int(((self.length - 6) / 100 * self.percent)) + ' ' * int(self.length - 6 - int(((self.length - 6)) / 100 * self.percent)) + ']' + str(self.percent) + '%', curses.A_STANDOUT)
else:
window.addstr(posy, posx, '[' + '#' * int(((self.length - 6) / 100 * self.percent)) + ' ' * int(self.length - 6 - int(((self.length - 6)) / 100 * self.percent)) + ']' + str(self.percent) + '%')
def setvalue(self, value):
if value > 100:
self.percent = 100
else:
self.percent = value
def focus(self, focus):
return False
| antoniovazquezblanco/ArchSetup | Interface/Widgets/ProgressWidget.py | ProgressWidget.py | py | 1,696 | python | en | code | 2 | github-code | 13 |
74675203856 | import math
import numpy as np
def transform_coor(unit_vectors, xyz):
'''
Transform the coordinates in new system back to its coordinates in old system
Parameters
----------
unit_vectors : list of array
unit_vectors of the new system in old system
xyz : array
coordinates in new system
Returns
-------
xyz_old : array
coordinates in old system
'''
R = np.array(unit_vectors).T
b = np.matmul(R, xyz[:, np.newaxis])
return b[:, 0]
def grow_particle(pos1, pos2, bond, angle):
'''
Generate a random coordinates based on the coordinates of two parents, bond and angle
https://scicomp.stackexchange.com/questions/27965/rotate-a-vector-by-a-randomly-oriented-angle
@tparker
Parameters
----------
pos1 : np.ndarray
coordinates of far parent
pos2 : np.ndarray
coordinates of near parent
bond : float
bond between near parent and new particle
angle : float
angle between far parent, near parent and new particle
Returns
-------
xyz_new : array
coordinates of new particle
'''
delta = pos2 - pos1
v = delta / np.sqrt(np.dot(delta, delta))
a = np.array([1, 0, 0])
if np.dot(a, v) > 0.99:
a = np.array([0, 1, 0])
xb = np.cross(a, v)
xb = xb / np.sqrt(np.dot(xb, xb))
yb = np.cross(v, xb)
phi = np.random.random() * 2 * np.pi
w = np.sin(angle) * np.cos(phi) * xb + np.sin(angle) * np.sin(phi) * yb + np.cos(angle) * v
return pos2 + w * bond
def periodic_distance(pos1, pos2, box, distance_max=None):
'''
Calculate the distance between two points under periodic boundary condition
Parameters
----------
pos1 : np.ndarray
pos2 : np.ndarray
box : np.ndarray of shape (3,)
Lengths of rectangular periodic box. Triclinic box is not supported yet.
distance_max : float, optional
The maximum distance to be considered. Will return None if distance larger than it
Returns
-------
distance : float or None
May return None if distance is apparently larger than `distance_max`
'''
delta = pos2 - pos1
abs_delta = np.abs(delta)
if distance_max is not None and any((abs_delta > distance_max) & (abs_delta < box - distance_max)):
return None
### elements of delta will be transformed to (-0.5, 0.5]
delta -= np.ceil(delta / box - 0.5) * box
### elements of delta will be transformed to [-0.5, 0.5)
# delta -= np.floor(delta / box + 0.5) * box
return math.sqrt(np.dot(delta, delta))
def periodic_angle(pos1, pos2, pos3, box):
'''
Calculate the angle between three points under periodic boundary condition
Parameters
----------
pos1 : np.ndarray
pos2 : np.ndarray
pos3 : np.ndarray
box : np.ndarray of shape (3,)
Lengths of rectangular periodic box. Triclinic box is not supported yet.
Returns
-------
angle : float
'''
vec1 = pos1 - pos2
vec2 = pos3 - pos2
### elements of delta will be transformed to (-0.5, 0.5]
vec1 -= np.ceil(vec1 / box - 0.5) * box
vec2 -= np.ceil(vec2 / box - 0.5) * box
cos = vec1.dot(vec2) / np.sqrt(vec1.dot(vec1) * vec2.dot(vec2))
return float(np.arccos(np.clip(cos, -1, 1)))
def periodic_dihedral(pos1, pos2, pos3, pos4, box):
'''
Calculate the dihedral between four points under periodic boundary condition
Parameters
----------
pos1 : np.ndarray
pos2 : np.ndarray
pos3 : np.ndarray
pos4 : np.ndarray
box : np.ndarray of shape (3,)
Lengths of rectangular periodic box. Triclinic box is not supported yet.
Returns
-------
angle : float
'''
vec1 = pos2 - pos1
vec2 = pos3 - pos2
vec3 = pos4 - pos3
### elements of delta will be transformed to (-0.5, 0.5]
vec1 -= np.ceil(vec1 / box - 0.5) * box
vec2 -= np.ceil(vec2 / box - 0.5) * box
vec3 -= np.ceil(vec3 / box - 0.5) * box
n1 = np.cross(vec1, vec2)
n2 = np.cross(vec2, vec3)
cos = n1.dot(n2) / np.sqrt(n1.dot(n1) * n2.dot(n2))
value = float(np.arccos(np.clip(cos, -1, 1)))
sign = 1 if vec1.dot(n2) >= 0 else -1
return sign * value
def find_clusters(elements, func):
'''
Group elements into clusters
Parameters
----------
elements : Iterable
func : func
This function has two arguments. Both should be element from `elements`.
Return True if two elements should be grouped into the same cluster.
Returns
-------
clusters : list of list of int
The clusters formed by elements. Each cluster is represented by a list of the index of elements.
'''
n_element = len(elements)
flag = [0] * n_element
n_cluster = 0
clusters = []
for i in range(n_element):
if flag[i]:
continue
path = {i}
expand = set()
n_cluster += 1
flag[i] = n_cluster
for j in range(i + 1, n_element):
if flag[j]:
continue
if func(elements[i], elements[j]):
path.add(j)
expand.add(j)
flag[j] = n_cluster
while expand:
m = expand.pop()
for n in range(i + 1, n_element):
if flag[n]:
continue
if func(elements[m], elements[n]):
path.add(n)
expand.add(n)
flag[n] = n_cluster
clusters.append(list(path))
return clusters
def find_clusters_consecutive(elements, func):
'''
Group elements into clusters. If element i and j are in the same group, all elements between i and j will also be put in the same group.
Parameters
----------
elements : Iterable
func : func
This function has two arguments. Both should be element from `elements`.
Return True if two elements should be grouped into the same cluster.
Returns
-------
clusters : list of list of int
The clusters formed by elements. Each cluster is represented by a list of the index of elements.
'''
n_element = len(elements)
flag = [0] * n_element
n_cluster = 0
clusters = []
for i in range(n_element):
if not flag[i]:
n_cluster += 1
flag[i] = n_cluster
clusters.append({i})
for j in reversed(range(i + 1, n_element)):
if flag[j]:
break
if func(elements[i], elements[j]):
for n in range(i + 1, j + 1):
flag[n] = flag[i]
clusters[-1].add(n)
break
clusters = [list(c) for c in clusters]
return clusters
| z-gong/mstk | mstk/topology/geometry.py | geometry.py | py | 6,778 | python | en | code | 7 | github-code | 13 |
38657742741 | #!/usr/bin/python3
"""
FileStorage Module: Defines attributes and methods for handling the
serialization and deserialization of class instances using JSON.
"""
import json
class FileStorage:
"""
Serializes instances to a JSON file and deserializes JSON file to instances
Private class attribute:
__file_path: string - path to the JSON file (ex: file.json)
__objects: dictionary - Store all objects by <classname>.id
Example: to store a BaseModel object with id=12121212,the key will be
BaseModel.12121212
"""
__file_path = "file.json"
__objects = {}
def all(self):
"""Returns a dictionary of class objects"""
return self.__objects
def new(self, obj):
"""
Sets in __objects the obj with key <obj class name>.id
Args:
obj: dict - The object to set
"""
obj_id = "{}.{}".format(type(obj).__name__, obj.id)
self.__objects.update({obj_id: obj})
def save(self):
"""Serializes __objects to the JSON file (path: __file_path)"""
obj_dict = {
key: value.to_dict() for key, value in self.__objects.items()
}
with open(self.__file_path, 'w') as file:
json.dump(obj_dict, file)
def reload(self):
"""
Deserializes the JSON file to __objects only if the JSON file
(__file_path) exists
"""
classes = {
"Amenity": __import__("models.amenity").amenity.Amenity,
"City": __import__("models.city").city.City,
"Place": __import__("models.place").place.Place,
"Review": __import__("models.review").review.Review,
"State": __import__("models.state").state.State,
"User": __import__("models.user").user.User,
"BaseModel": __import__("models.base_model").base_model.BaseModel
}
existing_obj = {}
try:
with open(self.__file_path, 'r') as file:
existing_obj = json.load(file)
except FileNotFoundError:
pass
for key in existing_obj:
obj = existing_obj[key]
class_name = obj["__class__"]
if class_name in classes:
instance = classes[class_name](**obj)
self.__objects.update({key: instance})
| leoemaxie/AirBnB_clone | models/engine/file_storage.py | file_storage.py | py | 2,345 | python | en | code | 0 | github-code | 13 |
39616286494 | #!/usr/bin/env python3
import http.server
import socketserver
import urllib.parse
import base64
import os
import argparse
PORT = 8000
HOST = ""
RESERVED_DIR = "downloads"
class RequestHandler(http.server.SimpleHTTPRequestHandler):
def do_GET(self):
file_path = self.path
parsed_url = urllib.parse.urlparse(self.path)
query = urllib.parse.parse_qs(parsed_url.query)
if query:
if "b" in query:
decoded = base64.b64decode(query["b"][0].replace(" ", "+"))
if 's' in query:
path = os.path.join(RESERVED_DIR, query['s'][0])
with open(path, "wb") as f:
f.write(decoded)
else:
try:
decoded.decode("utf-8")
except UnicodeDecodeError:
pass
print("Decoded:")
print(decoded)
print()
self.send_error(404)
else:
if file_path == "/":
self.send_error(404)
super().do_GET()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-p", "--port", type=int, default=PORT)
parser.add_argument("-b", "--bind", default=HOST)
args = parser.parse_args()
os.makedirs(RESERVED_DIR, exist_ok=True)
socketserver.TCPServer.allow_reuse_address = True
with socketserver.TCPServer((args.bind, args.port),
RequestHandler) as httpd:
print("CTF Web Sesrver serving at port", args.port)
httpd.serve_forever()
if __name__ == '__main__':
main()
| dani84bs/ctf-web-server | ctf_web_server.py | ctf_web_server.py | py | 1,674 | python | en | code | 0 | github-code | 13 |
16706802054 | '''
PointGroup test.py
Written by Li Jiang
'''
import torch
import time
import numpy as np
import random
import os
from util.config import cfg
cfg.task = 'test'
from util.log import logger
import util.utils as utils
import util.eval as eval
from util_iou import *
import glob, plyfile, numpy as np, multiprocessing as mp, torch, json, argparse
import scannet_util,os,csv
# Map relevant classes to {0,1,...,19}, and ignored classes to -100
remapper = np.ones(150) * (-100)
for i, x in enumerate([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 24, 28, 33, 34, 36, 39]):
remapper[x] = i
mode='train'
conf_thres=0.9
dic={}
dic['wall']=0
dic['floor']=1
dic['cabinet']=2
dic['bed']=3
dic['chair']=4
dic['sofa']=5
dic['table']=6
dic['door']=7
dic['window']=8
dic['bookshelf']=9
dic['picture']=10
dic['counter']=11
dic['desk']=12
dic['curtain']=13
dic['refridgerator']=14
dic['shower curtain']=15
dic['toilet']=16
dic['sink']=17
dic['bathtub']=18
dic['otherfurniture']=19
def init():
global result_dir
result_dir = os.path.join(cfg.exp_path, 'result', 'epoch{}_nmst{}_scoret{}_npointt{}'.format(cfg.test_epoch, cfg.TEST_NMS_THRESH, cfg.TEST_SCORE_THRESH, cfg.TEST_NPOINT_THRESH), cfg.split)
backup_dir = os.path.join(result_dir, 'backup_files')
os.makedirs(backup_dir, exist_ok=True)
os.makedirs(os.path.join(result_dir, 'predicted_masks'), exist_ok=True)
os.system('cp test.py {}'.format(backup_dir))
os.system('cp {} {}'.format(cfg.model_dir, backup_dir))
os.system('cp {} {}'.format(cfg.dataset_dir, backup_dir))
os.system('cp {} {}'.format(cfg.config, backup_dir))
global semantic_label_idx
semantic_label_idx = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 24, 28, 33, 34, 36, 39]
logger.info(cfg)
random.seed(cfg.test_seed)
np.random.seed(cfg.test_seed)
torch.manual_seed(cfg.test_seed)
torch.cuda.manual_seed_all(cfg.test_seed)
def test(model, model_fn, data_name, epoch):
logger.info('>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>')
from data.scannetv2_inst import Dataset
dataset = Dataset(test=True)
dataset.testLoader()
dataloader = dataset.test_data_loader
intersection_meter = AverageMeter()
union_meter = AverageMeter()
target_meter = AverageMeter()
try:
os.mkdir(cfg.data_root+'/train'+str(conf_thres))
except:
pass
with torch.no_grad():
model = model.eval()
start = time.time()
matches = {}
for i, batch in enumerate(dataloader):
N = batch['feats'].shape[0]
test_scene_name = dataset.test_file_names[int(batch['id'][0])].split('/')[-1][:12]
start1 = time.time()
preds = model_fn(batch, model, epoch)
unary=np.amax(preds['unary'].cpu().numpy(),1)
end1 = time.time() - start1
Q=torch.argmax(preds['Q'],1).cpu().numpy()
crf=preds['semantic_crf'].cpu().numpy()
confs=preds['conf'].cpu().numpy()
group_all=preds['group_full']
group_to_point=preds['group2point_full']
sem_labels = np.zeros((unary.shape[0],)) #remapper[np.array(f2.elements[0]['label'])]
sem_labels[:]=-100
groups=[]
for i in range(20):
groups.append([])
cnt_group=0
cnt=len(group_all)
for i in range(cnt):
conf=confs[i]
c=Q[i]
if conf<conf_thres:#
continue
cnt_group+=1
groups[c].append(group_all[i])
idxs=group_to_point[group_all[i]]
sem_labels[idxs]=c
data=torch.load(cfg.data_root+'/train_weakly/'+test_scene_name+'_vh_clean_2.ply_inst_nostuff.pth')
coords=data[0]
colors=data[1]
prev_sem=data[2]
prev_groups=data[3]
full_seg=data[4]
prev_group_cnt=0
for g in range(len(prev_groups)):
g2=prev_groups[g]
prev_group_cnt+=len(g2)
for i in g2:
if (i not in groups[g]) and (i in group_to_point.keys()):
groups[g].append(i)
idxs=group_to_point[i]
sem_labels[idxs]=g
sem_labels[np.where(prev_sem!=-100)]=prev_sem[np.where(prev_sem!=-100)]
torch.save((coords, colors, sem_labels, groups, full_seg), cfg.data_root+'/train'+str(conf_thres)+'/'+test_scene_name+'_inst_nostuff.pth')
def non_max_suppression(ious, scores, threshold):
ixs = scores.argsort()[::-1]
pick = []
while len(ixs) > 0:
i = ixs[0]
pick.append(i)
iou = ious[i, ixs[1:]]
remove_ixs = np.where(iou > threshold)[0] + 1
ixs = np.delete(ixs, remove_ixs)
ixs = np.delete(ixs, 0)
return np.array(pick, dtype=np.int32)
if __name__ == '__main__':
init()
cfg.dataset='train_weakly'
##### get model version and data version
exp_name = cfg.config.split('/')[-1][:-5]
model_name = exp_name.split('_')[0]
data_name = exp_name.split('_')[-1]
##### model
logger.info('=> creating model ...')
logger.info('Classes: {}'.format(cfg.classes))
if model_name == 'pointgroup':
from model.pointgroup.pointgroup import PointGroup as Network
from model.pointgroup.pointgroup import model_fn_decorator
else:
print("Error: no model version " + model_name)
exit(0)
model = Network(cfg)
use_cuda = torch.cuda.is_available()
logger.info('cuda available: {}'.format(use_cuda))
assert use_cuda
model = model.cuda()
# logger.info(model)
logger.info('#classifier parameters (model): {}'.format(sum([x.nelement() for x in model.parameters()])))
##### model_fn (criterion)
model_fn = model_fn_decorator(test=True)
##### load model
print (model)
#utils.checkpoint_restore(model, cfg.exp_path, cfg.config.split('/')[-1][:-5], use_cuda, cfg.test_epoch, dist=False, f=cfg.pretrain) # resume from the latest epoch, or specify the epoch to restore
##### evaluate
test(model, model_fn, data_name, cfg.test_epoch)
| liuzhengzhe/One-Thing-One-Click | cvpr2021_version/merge/test_train.py | test_train.py | py | 6,363 | python | en | code | 48 | github-code | 13 |
20941817006 | # find uncoman element in a list of list
s = ' native method '
print(s.center(len(s)+20,'*'))
list1 = []
list2 = []
result = []
n = int(input())
print('for list1 enter element :\n')
for i in range(n):
a =list(map(int,input().split()))
list1.append(a)
print('for list2 enter element :\n')
for i in range(n):
b =list(map(int,input().split()))
list2.append(b)
for i in list1 :
if i not in list2:
result.append(i)
for i in list2 :
if i not in list1:
result.append(i)
print(result)
s = ' using set() + map() and ^ '
print(s.center(len(s)+20,'*'))
result_set = set(map(tuple,list1)) ^ set(map(tuple,list2))
result = list(map(list,result_set))
print(result_set)
print(result) | Rohit-saxena125/Python-code | List/Uncomman_element.py | Uncomman_element.py | py | 737 | python | en | code | 0 | github-code | 13 |
5276106856 | #!/usr/bin/env python3
#
# Dispersion of solutions, per cell, per method, shown in prior
#
from __future__ import division, print_function
import os
import sys
import myokit
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
from matplotlib.gridspec import GridSpecFromSubplotSpec as SubGridSpec
# Load project modules
sys.path.append(os.path.abspath(os.path.join('..', '..', 'python')))
import plots
import results
#
# Check input arguments
#
base = os.path.splitext(os.path.basename(__file__))[0]
args = sys.argv[1:]
if len(args) not in [1, 2]:
print('Syntax: ' + base + ' <cell|all> <zoom_method>')
sys.exit(1)
if args[0] == 'all':
cell_list = list(range(1, 10))
else:
cell_list = [int(args[0])]
zoom = False
methods = [2, 3, 4]
if len(args) == 2:
methods = [int(args[1])]
zoom = True
# Set font
font = {'family': 'arial', 'size': 10}
matplotlib.rc('font', **font)
# Matplotlib figure sizes are in inches
def mm(*size):
return tuple(x / 25.4 * 1.5 for x in size)
# Create figure
fig = plt.figure(figsize=mm(170, 47), dpi=200)
fig.subplots_adjust(0.057, 0.18, 0.99, 0.87)
grid = GridSpec(1, 4, wspace=0.33)
# P1/P2
ax0 = fig.add_subplot(grid[0, 0])
ax0.set_xlabel('p1 (log)')
ax0.set_ylabel('p2')
plots.prior12(ax0, True, labels=False)
# P3/P4
ax1 = fig.add_subplot(grid[0, 1])
ax1.set_xlabel('p3 (log)')
ax1.set_ylabel('p4')
plots.prior34(ax1, True, labels=False)
# P5/P6
ax2 = fig.add_subplot(grid[0, 2])
ax2.set_xlabel('p5 (log)')
ax2.set_ylabel('p6')
plots.prior12(ax2, True, labels=False)
# P7/P8
ax3 = fig.add_subplot(grid[0, 3])
ax3.set_xlabel('p7 (log)')
ax3.set_ylabel('p8')
plots.prior34(ax3, True, labels=False)
colors = [
'tab:blue',
'tab:orange',
'tab:green',
'tab:red',
]
markers = [
'o',
's',
'x',
'+',
]
#
# Run
#
for cell in cell_list:
for method in methods:
imethod = method - 1
ps = results.load_parameters(cell, method, repeats=True)
kw = {
'color': colors[imethod],
'marker': markers[imethod],
'label': 'Method ' + str(method),
'fillstyle': 'none',
'linestyle': '',
}
ax0.plot(ps[:, 0], ps[:, 1], **kw)
ax1.plot(ps[:, 2], ps[:, 3], **kw)
ax2.plot(ps[:, 4], ps[:, 5], **kw)
ax3.plot(ps[:, 6], ps[:, 7], **kw)
if zoom:
kw['color'] = 'black'
kw['fillstyle'] = 'full'
kw['marker'] = 's'
ax0.plot(ps[0, 0], ps[0, 1], **kw)
ax1.plot(ps[0, 2], ps[0, 3], **kw)
ax2.plot(ps[0, 4], ps[0, 5], **kw)
ax3.plot(ps[0, 6], ps[0, 7], **kw)
ax0.legend(loc=(0, 1.05), ncol=4)
font = {'weight': 'bold', 'fontsize': 14}
ax0.text(0.88, 0.88, 'A', font, transform=ax0.transAxes)
ax1.text(0.88, 0.88, 'B', font, transform=ax1.transAxes)
ax2.text(0.88, 0.88, 'C', font, transform=ax2.transAxes)
ax3.text(0.88, 0.88, 'D', font, transform=ax3.transAxes)
if zoom:
p = ps[0]
r = np.sqrt(np.sum((ps - p)**2, axis=1))
pnear = ps[r < 10*np.median(r[1:10])]
lo = np.min(pnear, axis=0)
hi = np.max(pnear, axis=0)
ra = hi - lo
lo -= ra * 0.05
hi += ra * 0.05
ax0.set_xlim(lo[0], hi[0])
ax0.set_ylim(lo[1], hi[1])
ax1.set_xlim(lo[2], hi[2])
ax1.set_ylim(lo[3], hi[3])
ax2.set_xlim(lo[4], hi[4])
ax2.set_ylim(lo[5], hi[5])
ax3.set_xlim(lo[6], hi[6])
ax3.set_ylim(lo[7], hi[7])
name = base + '-cell-' + str(cell)
if zoom:
name += '-zoom-' + str(methods[0])
plt.savefig(name + '.png')
plt.savefig(name + '.pdf')
plt.close()
#plt.show()
| CardiacModelling/FourWaysOfFitting | figures-unused/u5-reliability/fx-dispersion-in-prior.py | fx-dispersion-in-prior.py | py | 3,774 | python | en | code | 4 | github-code | 13 |
31193067870 | import pymfx4
from pymfx4.mfx4device import mfx4Cut
from pymfx4.mffullindex import FullIndex
from pymfx4.mfconnection import mfx_endpoints, mfx_close_endpoints
import time
# connect to a MFX_4 EDI (Node=0). This function
# will return a tuple of devices.
cutDevice = 0
for device in mfx_endpoints("192.168.3.117:4003", [0]):
if isinstance(device, mfx4Cut):
cutDevice = device
# print device info
print(cutDevice.SoftwareVersion.Value)
print(cutDevice.SoftwareDate.Value)
print(cutDevice.SoftwareTime.Value)
uploadSize = FullIndex(0, 0x200B, 0x0B) # Upload-Size-In-Bytes
def MyNotificationFunction(FI, Value):
print(f"{FI} => {Value}")
cutDevice.SetNotification(uploadSize, 500, MyNotificationFunction)
for i in range(10):
cutDevice.Set(uploadSize, f"{i*2}")
time.sleep(1)
cutDevice.RemoveNotification(uploadSize)
mfx_close_endpoints() | AAngold/pymfx4 | example/pymfx4_example.py | pymfx4_example.py | py | 868 | python | en | code | 0 | github-code | 13 |
4193169346 | import numpy as np
import math
import matplotlib.pyplot as plt
import matplotlib.lines as mlines
from heapq import heappush, heappop
import rospy
from geometry_msgs.msg import Point, Twist, PoseStamped
from math import pow, atan2, sqrt
import time
# move robot function
def move_robot(pub_vel, dvx, dvy, dw):
"""
Inputs:
pub_vel: the ROS publisher which publishes the information to topic 'cmd_vel_mux/input/navi'
dvx: velocity along x-direction
dvy: velocity along y-direction
dw: angular velocity
"""
r = rospy.Rate(100)
vel_value = Twist()
velocity = np.sqrt(dvx * dvx + dvy * dvy) / 100.0
endTime = rospy.Time.now() + rospy.Duration(1)
while rospy.Time.now() < endTime:
vel_value.linear.x = velocity
vel_value.angular.z = dw
pub_vel.publish(vel_value)
r.sleep()
# class for AStar
class AStar(object):
# init function
def __init__(self, start, goal, wheelRPM, clearance):
"""
Inputs:
start: this is the start coordinate of the robot. It is a tuple of form (x, y, theta).
goal: this is the goal coordinate of the robot. It is a tuple of form (x, y).
wheelRPM: this is the values of RPM of the wheels. It is of form (leftRPM, rightRPM).
clearance: this is the clearance that the robot needs to have with the obstacles.
"""
# start variable - tuple of of form (x, y, theta)
self.start = start
# goal variable - tuple of form (x, y)
self.goal = goal
# the map size along x and y dimensions in cms (map dimension are from -500 to 500 for both x and y direction)
# map size is 1000 cm x 1000 cm
self.xLength = 500
self.yLength = 500
# wheelRPM variable - tuple of form (leftRPM, rightRPM)
self.wheelRPM = wheelRPM
# clearance variable - distance of the robot from the obstacle
self.clearance = min(clearance + 10, 25)
# radius variable - the radius of the robot (taken from turtlebot datasheet)
self.radius = 20.0
# wheelDistance - the distance between wheels (taken from turtlebot datasheet)
self.wheelDistance = 34.0
# wheelRadius - the radius of the wheels (taken from turtlebot datasheet)
self.wheelRadius = 3.8
# distance - hashmap that stores net distance of the node from the start and the goal
self.distance = {}
# path - hashmap used for backtracking from the goal node to the start node
self.path = {}
# costToCome - hashmap to store the distance of the nodes from the start node
self.costToCome = {}
# costToGo - hashmap to store the distance of the nodes from the goal node
self.costToGo = {}
# hashMap - custom variable to hold visited nodes
self.hashMap = {}
# goalThreshold - threshold from goal node
self.goalThreshold = 15
# frequency - the value of frequency for curved path
self.frequency = 100
# move is valid or not
def IsValid(self, currX, currY):
"""
Inputs:
currX - the current x-position of the robot.
currY - the current y-posiiton of the robot.
Outputs:
True / False depending on whether the nodes lies within the map or not.
"""
nodeInMap = (currX >= (-self.xLength + self.radius + self.clearance) and currX <= (self.xLength - self.radius - self.clearance) and currY >= (-self.yLength + self.radius + self.clearance) and currY <= (self.yLength - self.radius - self.clearance))
return nodeInMap
# checks for an obstacle in the given map
def IsObstacle(self, row, col):
"""
Inputs:
row - the current x-position of the robot.
col - the current y-posiiton of the robot.
Outputs:
True / False depending on whether the nodes lies within obstacle or not.
"""
# constants
sum_of_c_and_r = self.clearance + self.radius
sqrt_of_c_and_r = 1.4142 * sum_of_c_and_r
# check circles(obstacles) in the given map
dist1 = ((row - 200.0) * (row - 200.0) + (col - 300.0) * (col - 300.0)) - ((100 + sum_of_c_and_r) * (100 + sum_of_c_and_r))
dist2 = ((row - 200.0) * (row - 200.0) + (col + 300.0) * (col + 300.0)) - ((100 + sum_of_c_and_r) * (100 + sum_of_c_and_r))
dist3 = ((row + 200.0) * (row + 200.0) + (col + 300.0) * (col + 300.0)) - ((100 + sum_of_c_and_r) * (100 + sum_of_c_and_r))
dist4 = ((row) * (row) + (col) * (col)) - ((100 + sum_of_c_and_r) * (100 + sum_of_c_and_r))
# check first square(obstacle) in the given map
(x1, y1) = (325 - sqrt_of_c_and_r, -75 - sqrt_of_c_and_r)
(x2, y2) = (325 - sqrt_of_c_and_r, 75 + sqrt_of_c_and_r)
(x3, y3) = (475 + sqrt_of_c_and_r, 75 + sqrt_of_c_and_r)
(x4, y4) = (475 + sqrt_of_c_and_r, -75 - sqrt_of_c_and_r)
first = ((col - y1) * (x2 - x1)) - ((y2 - y1) * (row - x1))
second = ((col - y2) * (x3 - x2)) - ((y3 - y2) * (row - x2))
third = ((col - y3) * (x4 - x3)) - ((y4 - y3) * (row - x3))
fourth = ((col - y4) * (x1 - x4)) - ((y1 - y4) * (row - x4))
dist5 = 1
dist6 = 1
if(first <= 0 and second <= 0 and third <= 0 and fourth <= 0):
dist5 = 0
dist6 = 0
# check second square(obstacle) in the given map
(x1, y1) = (-325 + sqrt_of_c_and_r, -75 - sqrt_of_c_and_r)
(x2, y2) = (-325 + sqrt_of_c_and_r, 75 + sqrt_of_c_and_r)
(x3, y3) = (-475 - sqrt_of_c_and_r, 75 + sqrt_of_c_and_r)
(x4, y4) = (-475 - sqrt_of_c_and_r, -75 - sqrt_of_c_and_r)
first = ((col - y1) * (x2 - x1)) - ((y2 - y1) * (row - x1))
second = ((col - y2) * (x3 - x2)) - ((y3 - y2) * (row - x2))
third = ((col - y3) * (x4 - x3)) - ((y4 - y3) * (row - x3))
fourth = ((col - y4) * (x1 - x4)) - ((y1 - y4) * (row - x4))
dist7 = 1
dist8 = 1
if(first >= 0 and second >= 0 and third >= 0 and fourth >= 0):
dist7 = 0
dist8 = 0
# check third square(obstacle) in the given map
(x1, y1) = (-125 + sqrt_of_c_and_r, 375 + sqrt_of_c_and_r)
(x2, y2) = (-125 + sqrt_of_c_and_r, 225 - sqrt_of_c_and_r)
(x3, y3) = (-275 - sqrt_of_c_and_r, 225 - sqrt_of_c_and_r)
(x4, y4) = (-275 - sqrt_of_c_and_r, 375 + sqrt_of_c_and_r)
first = ((col - y1) * (x2 - x1)) - ((y2 - y1) * (row - x1))
second = ((col - y2) * (x3 - x2)) - ((y3 - y2) * (row - x2))
third = ((col - y3) * (x4 - x3)) - ((y4 - y3) * (row - x3))
fourth = ((col - y4) * (x1 - x4)) - ((y1 - y4) * (row - x4))
dist9 = 1
dist10 = 1
if(first <= 0 and second <= 0 and third <= 0 and fourth <= 0):
dist9 = 0
dist10 = 0
# return true if obstacle, otherwise false
if(dist1 <= 0 or dist2 <= 0 or dist3 <= 0 or dist4 <= 0 or dist5 == 0 or dist6 == 0 or dist7 == 0 or dist8 == 0 or dist9 == 0 or dist10 == 0):
return True
return False
# animate path and show the nodes on map
def animate(self, exploredStates, backtrackStates):
"""
Inputs:
exploredStates: list of explored states when going from start to goal node.
backtrackStates: list of states to go from start to goal node.
"""
startX = []
startY = []
endX = []
endY = []
explored_startX = []
explored_startY = []
explored_endX = []
explored_endY = []
fig, ax = plt.subplots()
plt.xlabel("x-coordinate(in m)")
plt.ylabel("y-coordinate(in m)")
plt.grid()
ax.set_aspect('equal')
plt.xlim(-self.xLength / 100.0, self.xLength / 100.0)
plt.ylim(-self.yLength / 100.0, self.yLength / 100.0)
count = 0
# obstacle space
obstacleX = []
obstacleY = []
size = []
for index1 in range(-self.xLength, self.xLength):
for index2 in range(-self.yLength, self.yLength):
if(self.IsObstacle(index1, index2)):
obstacleX.append(index1 / 100.0)
obstacleY.append(index2 / 100.0)
size.append(15)
obstacleX = np.array(obstacleX)
obstacleY = np.array(obstacleY)
plt.scatter(obstacleX, obstacleY, color='b', s=size)
# explore node space
for index in range(1, len(exploredStates)):
parentNode = self.path[exploredStates[index]][0]
explored_startX.append(parentNode[0] / 100.0)
explored_startY.append(parentNode[1] / 100.0)
explored_endX.append((exploredStates[index][0] - parentNode[0]) / 100.0)
explored_endY.append((exploredStates[index][1] - parentNode[1]) / 100.0)
#if(count % 2000 == 0):
# plt.quiver(np.array((explored_startX)), np.array((explored_startY)), np.array((explored_endX)), np.array((explored_endY)), units = 'xy', scale = 1, color = 'g', label = 'Explored region')
# plt.savefig("output/phase3/sample" + str(count) + ".png", dpi=1700)
count = count + 1
# backtrack space
if(len(backtrackStates) > 0):
for index in range(1, len(backtrackStates)):
startX.append(backtrackStates[index-1][0] / 100.0)
startY.append(backtrackStates[index-1][1] / 100.0)
endX.append((backtrackStates[index][0] - backtrackStates[index-1][0]) / 100.0)
endY.append((backtrackStates[index][1] - backtrackStates[index-1][1]) / 100.0)
#if(count % 5 == 0):
# plt.quiver(np.array((startX)), np.array((startY)), np.array((endX)), np.array((endY)), units = 'xy', scale = 1, color = 'r', label = 'Backtrack path')
# plt.savefig("output/phase3/sample" + str(count) + ".png", dpi=1700)
count = count + 1
plt.quiver(np.array((explored_startX)), np.array((explored_startY)), np.array((explored_endX)), np.array((explored_endY)), units = 'xy', scale = 1, color = 'g', label = 'Explored region')
if(len(backtrackStates) > 0):
plt.quiver(np.array((startX)), np.array((startY)), np.array((endX)), np.array((endY)), units = 'xy', scale = 1, color = 'r', label = 'Backtrack path')
#plt.savefig("output.png", dpi=1700)
plt.legend()
plt.show()
plt.close()
# return updated position by taking into account non-holonomic constraint of robot
def GetNewPositionOfRobot(self, currentNode, leftRPM, rightRPM):
"""
Inputs:
currentNode: the current node, tupe of type (x, y, theta)
leftRPM: the value of RPM of left wheel
rightRPM: the value of RPM of right wheel
Outputs:
x: Updated x-coordinate
y: Updated y-coordinate
theta: Updated angle value
cost: Net cost to move from (currentNode, (x, y))
dvx: linear velocity along x-direction to move from (currentNode, (x, y))
dvy: linear velocity along y-direction to move from (currentNode, (x, y))
w: angle threshold during each time step dt
flag: determines whether it is possible to move from (currentNode, (x, y))
"""
# calculate angular valocity of left wheel and right wheel and initialise vairables
leftAngularVelocity = leftRPM * 2 * np.pi / 60.0
rightAngularVelocity = rightRPM * 2 * np.pi / 60.0
x = currentNode[0]
y = currentNode[1]
theta = currentNode[2]
dx = 0
dy = 0
dtheta = 0
cost = 0
flag = True
w = (self.wheelRadius / self.wheelDistance) * (rightAngularVelocity - leftAngularVelocity)
# get updated node after moving 100 steps
for index in range(0, self.frequency):
dvx = self.wheelRadius * 0.5 * (leftAngularVelocity + rightAngularVelocity) * math.cos(theta)
dvy = self.wheelRadius * 0.5 * (leftAngularVelocity + rightAngularVelocity) * math.sin(theta)
dx = dvx / self.frequency
dy = dvy / self.frequency
dtheta = w / self.frequency
x = x + dx
y = y + dy
theta = theta + dtheta
cost = cost + np.sqrt(dx ** 2 + dy ** 2)
if(self.IsValid(x, y) == False or self.IsObstacle(x, y)):
flag = False
break
# pruning
if(flag != False and self.hashMap.get(int(int(x * 100) + int(y * 10))) != None):
flag = False
# return updated location
return (x, y, theta, cost, dvx, dvy, w, flag)
# action move
def ActionMoveRobot(self, currentNode, leftRPM, rightRPM):
"""
currentNode: the current node, tupe of type (x, y, theta)
leftRPM: the value of RPM of left wheel
rightRPM: the value of RPM of right wheel
Outputs:
flag: True/ False, if possible to move to the updated node
newX: Updated x-coordinate
newY: Updated y-coordinate
newTheta: Updated angle value
dvx: linear velocity along x-direction to move from (currentNode, (newX, newY))
dvy: linear velocity along y-direction to move from (currentNode, (newX, newY))
dw: angle threshold during each time step dt
cost: Net cost to move from (currentNode, (x, y))
"""
# update position
(newX, newY, newTheta, cost, dvx, dvy, dw, flag) = self.GetNewPositionOfRobot(currentNode, leftRPM, rightRPM)
self.hashMap[int(int(newX * 100) + int(newY * 10))] = 1
# check obstacle
if(flag == True and self.IsValid(newX, newY) and self.IsObstacle(newX, newY) == False):
return (True, newX, newY, newTheta, dvx, dvy, dw, cost)
return (False, newX, newY, newTheta, dvx, dvy, dw, cost)
# update action
def UpdateAction(self, currentNode, weight, newX, newY, newTheta, action, cost):
"""
Inputs:
currentNode: the current node, tupe of type (x, y, theta)
weight: cost to move from (currentNode,(newX, newY))
newX: Updated x-coordinate
newY: Updated y-coordinate
newTheta: Updated angle value
action: containing dvx and dvy values for further storing
cost: the additional cost to move from (currentNode, (newX, newY))
Outputs:
True / False depedning on whether an optimal node found
"""
newCostToCome = self.costToCome[currentNode] + weight
newCostToGo = self.euc_heuristic(newX, newY)
newDistance = newCostToCome + newCostToGo + cost
if(self.distance.get((newX, newY, newTheta)) == None):
self.distance[(newX, newY, newTheta)] = float('inf')
if(self.distance[(newX, newY, newTheta)] > newDistance):
self.distance[(newX, newY, newTheta)] = newDistance
self.costToCome[(newX, newY, newTheta)] = newCostToCome
self.costToGo[(newX, newY, newTheta)] = newCostToGo
self.path[(newX, newY, newTheta)] = (currentNode, action)
return True
return False
# eucledian heuristic (becomes weighted a-star when weight made greater than 1.0)
def euc_heuristic(self, currX, currY, weight = 3.0):
"""
Inputs:
currX - the current x-position of the robot.
currY - the current y-posiiton of the robot.
weight - the weight used for A-star algorithm
Output:
Returns the eucledian distance between goal node and the current node(currX, currY)
"""
return weight * (np.sqrt(((self.goal[0] - currX) ** 2) + ((self.goal[1] - currY) ** 2)))
# a-star algo
def search(self):
"""
Outputs:
exploredStates: the states explored when moving from start node to goal node.
backtrackStates: the path from start node to goal node.
actions: list containing the (dvx, dvy) values for each possible node between start and goal node.
distance: the total distance between start node and goal node.
"""
# mark source node and create a queue
exploredStates = []
queue = []
self.costToCome[self.start] = 0
self.costToGo[self.start] = self.euc_heuristic(self.start[0], self.start[1])
self.distance[self.start] = self.costToCome[self.start] + self.costToGo[self.start]
heappush(queue, (self.distance[self.start], self.costToCome[self.start], self.start))
backtrackNode = None
flag = 0
steps = 0
# run A-star
while(len(queue) > 0):
# get current node
_, _, currentNode = heappop(queue)
self.hashMap[int(int(currentNode[0] * 100) + int(currentNode[1] * 10))] = 1
exploredStates.append(currentNode)
steps = steps + 1
# if goal node then break, using the distance formula
if(np.square(np.abs(currentNode[0] - self.goal[0])) + np.square(np.abs(currentNode[1] - self.goal[1])) < self.goalThreshold):
backtrackNode = currentNode
flag = 1
break
# break if steps greater than 1000000 (exit when no path exists)
if(steps > 1000000):
break
# traverse the edges
# action 1
(moveOnePossible, newX, newY, newTheta, dvx, dvy, dw, cost) = self.ActionMoveRobot(currentNode, 0, self.wheelRPM[0])
if(moveOnePossible):
updateHeap = self.UpdateAction(currentNode, self.wheelRPM[0], newX, newY, newTheta, (dvx, dvy, dw), cost)
if(updateHeap):
heappush(queue, (self.distance[(newX, newY, newTheta)], self.costToCome[(newX, newY, newTheta)], (newX, newY, newTheta)))
# action 2
(moveTwoPossible, newX, newY, newTheta, dvx, dvy, dw, cost) = self.ActionMoveRobot(currentNode, self.wheelRPM[0], 0)
if(moveTwoPossible):
updateHeap = self.UpdateAction(currentNode, self.wheelRPM[0], newX, newY, newTheta, (dvx, dvy, dw), cost)
if(updateHeap):
heappush(queue, (self.distance[(newX, newY, newTheta)], self.costToCome[(newX, newY, newTheta)], (newX, newY, newTheta)))
# action 3
(moveThreePossible, newX, newY, newTheta, dvx, dvy, dw, cost) = self.ActionMoveRobot(currentNode, self.wheelRPM[0], self.wheelRPM[0])
if(moveThreePossible):
updateHeap = self.UpdateAction(currentNode, (self.wheelRPM[0] * 1.4142), newX, newY, newTheta, (dvx, dvy, dw), cost)
if(updateHeap):
heappush(queue, (self.distance[(newX, newY, newTheta)], self.costToCome[(newX, newY, newTheta)], (newX, newY, newTheta)))
# action 4
(moveFourPossible, newX, newY, newTheta, dvx, dvy, dw, cost) = self.ActionMoveRobot(currentNode, 0, self.wheelRPM[1])
if(moveFourPossible):
updateHeap = self.UpdateAction(currentNode, self.wheelRPM[1], newX, newY, newTheta, (dvx, dvy, dw), cost)
if(updateHeap):
heappush(queue, (self.distance[(newX, newY, newTheta)], self.costToCome[(newX, newY, newTheta)], (newX, newY, newTheta)))
# action 5
(moveFivePossible, newX, newY, newTheta, dvx, dvy, dw, cost) = self.ActionMoveRobot(currentNode, self.wheelRPM[1], 0)
if(moveFivePossible):
updateHeap = self.UpdateAction(currentNode, self.wheelRPM[1], newX, newY, newTheta, (dvx, dvy, dw), cost)
if(updateHeap):
heappush(queue, (self.distance[(newX, newY, newTheta)], self.costToCome[(newX, newY, newTheta)], (newX, newY, newTheta)))
# action 6
(moveSixPossible, newX, newY, newTheta, dvx, dvy, dw, cost) = self.ActionMoveRobot(currentNode, self.wheelRPM[1], self.wheelRPM[1])
if(moveSixPossible):
updateHeap = self.UpdateAction(currentNode, (self.wheelRPM[1] * 1.4142), newX, newY, newTheta, (dvx, dvy, dw), cost)
if(updateHeap):
heappush(queue, (self.distance[(newX, newY, newTheta)], self.costToCome[(newX, newY, newTheta)], (newX, newY, newTheta)))
# action 7
(moveSevenPossible, newX, newY, newTheta, dvx, dvy, dw, cost) = self.ActionMoveRobot(currentNode, self.wheelRPM[0], self.wheelRPM[1])
if(moveSevenPossible):
updateHeap = self.UpdateAction(currentNode, max((self.wheelRPM[0] * 1.4142), (self.wheelRPM[1] * 1.4142)), newX, newY, newTheta, (dvx, dvy, dw), cost)
if(updateHeap):
heappush(queue, (self.distance[(newX, newY, newTheta)], self.costToCome[(newX, newY, newTheta)], (newX, newY, newTheta)))
# action 8
(moveEightPossible, newX, newY, newTheta, dvx, dvy, dw, cost) = self.ActionMoveRobot(currentNode, self.wheelRPM[1], self.wheelRPM[0])
if(moveEightPossible):
updateHeap = self.UpdateAction(currentNode, max((self.wheelRPM[0] * 1.4142), (self.wheelRPM[1] * 1.4142)), newX, newY, newTheta, (dvx, dvy, dw), cost)
if(updateHeap):
heappush(queue, (self.distance[(newX, newY, newTheta)], self.costToCome[(newX, newY, newTheta)], (newX, newY, newTheta)))
# return if no optimal path
if(flag == 0):
return (exploredStates, [], float('inf'))
# backtrack path
backtrackStates = []
actions = []
node = backtrackNode
action = None
while(node != self.start):
backtrackStates.append(node)
if(action != None):
actions.append(action)
node, action = self.path[node]
backtrackStates.append(self.start)
actions.append(action)
backtrackStates = list(reversed(backtrackStates))
actions = list(reversed(actions))
return (exploredStates, backtrackStates, actions, self.distance[backtrackNode])
# make ros publisher
rospy.init_node('turtlebot_astar')
pub_vel = rospy.Publisher('/mobile_base/commands/velocity', Twist, queue_size=10)
time.sleep(2)
# map size is 1000 cm x 1000 cm
print()
print()
startX = float(input("Enter the x-coordinate for start node(in m) : "))
startY = float(input("Enter the y-coordinate for start node(in m) : "))
startOrientation = float(input("Enter the orientation for start node : "))
goalX = float(input("Enter the x-coordinate for goal node(in m) : "))
goalY = float(input("Enter the y-coordinate for goal node(in m) : "))
firstRPM = float(input("Enter the first value of RPM : "))
secondRPM = float(input("Enter the second value of RPM : "))
clearance = float(input("Enter the clearance of the rigid robot(in m) : "))
# take start and goal node as input
start = (startX * 100.0, startY * 100.0, startOrientation)
goal = (goalX * 100.0, goalY * 100.0)
wheelRPM = (firstRPM, secondRPM) # (100, 50)
astar = AStar(start, goal, wheelRPM, clearance * 100)
if(astar.IsValid(start[0], start[1])):
if(astar.IsValid(goal[0], goal[1])):
if(astar.IsObstacle(start[0],start[1]) == False):
if(astar.IsObstacle(goal[0], goal[1]) == False):
states = astar.search()
explored_states = states[0]
backtrack_states = states[1]
actions = states[2]
# move robot in ROS from start to goal node
for index in range(0, len(actions)):
dvx, dvy, dw = actions[index]
move_robot(pub_vel, dvx, dvy, dw)
# print optimal path found or not
if(len(backtrack_states) == 0):
print("\nNo optimal path found.")
else:
print("\nOptimal path found.")
else:
print("The entered goal node is an obstacle ")
print("Please check README.md file for running turtlebot_astar.py file.")
else:
print("The entered start node is an obstacle ")
print("Please check README.md file for running turtlebot_astar.py file.")
else:
print("The entered goal node outside the map ")
print("Please check README.md file for running turtlebot_astar.py file.")
else:
print("The entered start node is outside the map ")
print("Please check README.md file for running turtlebot_astar.py file.")
| arp95/turtlebot_astar | scripts/turtlebot_astar.py | turtlebot_astar.py | py | 25,317 | python | en | code | 1 | github-code | 13 |
35553784025 | import numpy as np
import torch
import torch.nn as N
import torch.nn.functional as F
def _get_block(name):
'''Maps string names to block classes.
'''
if name == 'vgg': return _Vgg
raise Exception(f"Unknown block type '{name}'")
class _Vgg(N.Module):
'''A simple block of 3x3 convolutions.
'''
def __init__(self, in_channel, *channels):
super().__init__()
layers = []
c0 = in_channel
for c1 in channels:
conv = N.Conv2d(c0, c1, kernel_size=3, padding=1)
relu = N.ReLU(inplace=True)
layers += [conv, relu]
c0 = c1
self.layers = N.Sequential(*layers)
# Initialize weights
for m in layers:
if not isinstance(m, N.BatchNorm2d):
if hasattr(m, 'weight'): N.init.kaiming_uniform(m.weight)
if hasattr(m, 'bias'): m.bias.data.fill_(0)
def forward(self, x):
for layer in self.layers:
x = layer(x)
return x
class _DownBlock(N.Module):
'''A downward block for U-Net.
'''
def __init__(self, in_channel, *channels, block_type='vgg'):
super().__init__()
block = _get_block(block_type)
self.conv = block(in_channel, *channels)
self.resample = N.MaxPool2d(2)
def forward(self, x):
skip = self.conv(x)
out = self.resample(skip)
return out, skip
class _UpBlock(N.Module):
'''An upward block for U-Net.
'''
def __init__(self, in_channel, *channels, block_type='vgg'):
super().__init__()
block = _get_block(block_type)
self.conv = block(in_channel, *channels)
self.resample = N.ConvTranspose2d(channels[-1], channels[-1]//2, kernel_size=2, stride=2)
def forward(self, x, skip):
conv = self.conv(x)
up = self.resample(conv, output_size=skip.shape)
out = torch.cat((up, skip), 1)
return out
class UNet(N.Module):
'''A fully convolutional network based on U-Net.
"U-Net: Convolutional Networks for Biomedical Image Segmentation".
Olaf Ronneberger, Philipp Fischer, and Thomas Brox.
Medical Image Computing and Computer-Assisted Intervention (MICCAI),
Springer, LNCS, Vol.9351: 234--241, 2015,
https://arxiv.org/abs/1505.04597
This architecture differs slightly from the original in that it includes
an extra convolution on the input which steps up the channel count to the
size of the first "down block".
'''
def __init__(self, n_channels, n_classes, depth=4, size=1024, block_type='vgg'):
'''Construct a U-Net.
Args:
n_channels:
The number of channels in the input.
n_classes:
The number of classes in the output.
depth:
The depth of the U, e.g. the number of down/up steps.
The default of 4 is used in the original paper.
size:
The number of channels at the very bottom.
The default of 1024 is used in the original paper.
block_type:
The type of convolution block. The default of 'vgg' is used in
the original paper. The following are supported:
- 'vgg': blocks of simple 3x3 convolutions with ReLU activation.
'''
super().__init__()
block = _get_block(block_type)
# Input
c = size >> depth
c0 = c
self.input = block(n_channels, c0)
# Down
self.down = []
for i in range(depth):
down = _DownBlock(c0, c, c, block_type=block_type)
self.add_module(f'down{i}', down)
self.down.append(down)
c0 = c
c *= 2
# Up
self.up = []
for i in range(depth):
up = _UpBlock(c0, c, c, block_type=block_type)
self.add_module(f'up{i}', up)
self.up.append(up)
c0 = c
c //= 2
# Output
self.top = block(c0, c, c)
self.output = N.Conv2d(c, n_classes, kernel_size=1)
def forward(self, x):
# Input
x = self.input(x)
# Down
skip = []
for down in self.down:
x, s = down(x)
skip.append(s)
# Up
skip = list(reversed(skip))
for s, up in zip(skip, self.up):
x = up(x, s)
# Output
x = self.top(x)
x = self.output(x)
return x
| WeiwenXu21/mahoney | mahoney/unet.py | unet.py | py | 4,503 | python | en | code | 0 | github-code | 13 |
4882377036 | """
Example of how to send MANUAL_CONTROL messages to the autopilot using
pymavlink.
This message is able to fully replace the joystick inputs.
"""
import time
import math
# Import mavutil
from pymavlink import mavutil
# Create the connection
master = mavutil.mavlink_connection('udpin:192.168.2.6:14550')
# Wait a heartbeat before sending commands
master.wait_heartbeat()
# arm ArduSub autopilot and wait until confirmed
master.arducopter_arm()
master.motors_armed_wait()
# Send a positive x value, negative y, negative z,
# positive rotation and no button.
# https://mavlink.io/en/messages/common.html#MANUAL_CONTROL
# Warning: Because of some legacy workaround, z will work between [0-1000]
# where 0 is full reverse, 500 is no output and 1000 is full throttle.
# x,y and r will be between [-1000 and 1000].
TIME = time.time()
print(TIME)
while (time.time() < TIME + 2):
master.mav.manual_control_send(
master.target_system,
150, #x
0, #y
500, #z
0, #r
0) # buttons
time.sleep(3.75)
print("Timepo de Vals ")
TIME1 = time.time()
while (time.time() < TIME1 + 2):
master.mav.manual_control_send(
master.target_system,
350, #x
0, #y
500, #z
0, #r
0) # buttons
#print("Segundo velo ")
#time.sleep(0.75)
# To active button 0 (first button), 3 (fourth button) and 7 (eighth button)
# It's possible to check and configure this buttons in the Joystick menu of QGC
#buttons = 1 + 1 << 3 + 1 << 7
#master.mav.manual_control_send(
# master.target_system,
# 0,
# 0,
# 500, # 500 means neutral throttle
# 0,
#buttons) | Legohead259/Koda-AUV | examples/Manual_Control.py | Manual_Control.py | py | 1,649 | python | en | code | 1 | github-code | 13 |
39200910038 | from __future__ import print_function
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
import mimetypes
import os.path
import re
import shutil
import tempfile
import logging
import tuf.client.updater
import tuf.conf
import tuf.log
import six
from tuf.interposition.configuration import Configuration
logger = logging.getLogger('tuf.interposition.updater')
class Updater(object):
"""
<Purpose>
Provide a class that can download target files securely. It performs all
the actions of 'tuf/client/updater.py', but adds methods to handle HTTP
requests and multiple updater objects.
<Updater Methods>
refresh():
This method refreshes top-level metadata. It calls the refresh() method of
'tuf.client.updater'. refresh() method of 'tuf.client.updater' downloads,
verifies, and loads metadata of the top-level roles in a specific order
(i.e., timestamp -> snapshot -> root -> targets). The expiration time for
downloaded metadata is also verified.
cleanup():
It will clean up all the temporary directories that are made following a
download request. It also logs a message when a temporary file/directory
is deleted.
download_target(target_filepath):
It downloads the 'target_filepath' repository file. It also downloads any
required metadata to securely satisfy the 'target_filepath' request.
get_target_filepath(source_url):
'source_url' is the URL of the file to be updated. This method will find
the updated target for this file.
open(url, data):
Open the 'url' URL, which can either be a string or a request object.
The file is opened in the binary read mode as a temporary file.
retrieve(url, filename, reporthook, data):
retrieve() method first gets the target file path by calling
get_target_filepath(url), which is in 'tuf.interposition.updater.Updater'
and then calls download_target() for the above file path.
switch_context():
There is an updater object for each network location that is interposed.
Context switching is required because there are multiple
'tuf.client.updater' objects and each one depends on tuf.conf settings
that are shared.
"""
def __init__(self, configuration):
"""
<Purpose>
Constructor for an updater object that may be used to satisfy TUF update
requests, and can be used independent of other updater objects. A
temporary directory is created when this updater object is instantiated,
which is needed by 'tuf.interposition.updater.Updater', and the top-level
roles are refreshed. The 'tuf.client.updater' module performs the
low-level calls.
<Arguments>
configuration:
A dictionary holding information like the following:
- Which network location get intercepted?
- Given a network location, which TUF mirrors should we forward requests
to?
- Given a network location, which paths should be intercepted?
- Given a TUF mirror, how do we verify its SSL certificate?
This dictionary holds repository mirror information, conformant to
'tuf.formats.MIRRORDICT_SCHEMA'. Information such as the directory
containing the metadata and target files, the server's URL prefix, and
the target directories the client should be confined to.
repository_mirrors = {'mirror1': {'url_prefix': 'http://localhost:8001',
'metadata_path': 'metadata',
'targets_path': 'targets',
'confined_target_dirs': ['']}}
<Exceptions>
tuf.FormatError:
If the arguments of 'tuf.client.updater.Updater' are improperly
formatted.
tuf.RepositoryError:
If there is an error with the updater's repository files, such
as a missing 'root.json' file.
tuf.NoWorkingMirrorError:
If while refreshing, the metadata for any of the top-level roles cannot
be updated.
tuf.ExpiredMetadataError:
While refreshing, if any metadata has expired.
<Side Effects>
The metadata files (e.g., 'root.json', 'targets.json') for the top-level
roles are read from disk and stored in dictionaries.
<Returns>
None.
"""
self.configuration = configuration
# A temporary directory used for this updater over runtime.
self.tempdir = tempfile.mkdtemp()
logger.debug('Created temporary directory at ' + repr(self.tempdir))
# Switching context before instantiating updater because updater depends
# on some module (tuf.conf) variables.
self.switch_context()
# Instantiating a 'tuf.client.updater' object causes all the configurations
# for the top-level roles to be read from disk, including the key and role
# information for the delegated targets of 'targets'. The actual metadata
# for delegated roles is not loaded in __init__. The metadata for these
# delegated roles, including nested delegated roles, are loaded, updated,
# and saved to the 'self.metadata' store by the target methods, like
# all_targets() and targets_of_role().
self.updater = tuf.client.updater.Updater(self.configuration.hostname,
self.configuration.repository_mirrors)
# Update the client's top-level metadata. The download_target() method
# does not automatically refresh top-level prior to retrieving target files
# and their associated Targets metadata, so update the top-level metadata
# here.
logger.info('Refreshing top-level metadata for interposed ' + repr(configuration))
self.updater.refresh()
def refresh(self):
"""
<Purpose>
This method refreshes the top-level metadata. It calls the refresh()
method of 'tuf.client.updater'. refresh() method of
'tuf.client.updater.py' downloads, verifies, and loads metadata for the
top-level roles in a specific order (i.e., timestamp -> snapshot -> root
-> targets) The expiration time for downloaded metadata is also verified.
This refresh() method should be called by the client before any target
requests. Therefore to automate the process, it is called here.
<Arguments>
None
<Exceptions>
tuf.NoWorkingMirrorError:
If the metadata for any of the top-level roles cannot be updated.
tuf.ExpiredMetadataError:
If any metadata has expired.
<Side Effects>
Updates the metadata files of the top-level roles with the latest
information.
<Returns>
None
"""
self.updater.refresh()
def cleanup(self):
"""
<Purpose>
Remove the updater object's temporary directory (and any sub-directories)
created when the updater object is instantiated to store downloaded
targets and metadata.
<Arguments>
None
<Exceptions>
None
<Side Effects>
Removal of the temporary 'self.tempdir' directory.
<Returns>
None
"""
shutil.rmtree(self.tempdir)
logger.debug('Deleted temporary directory at ' + repr(self.tempdir))
def download_target(self, target_filepath):
"""
<Purpose>
Download the 'target_filepath' target file. Everything here is performed
in a temporary directory. It identifies the target information for
'target_filepath' by calling the target() method of 'tuf.client.updater'.
This method also downloads the metadata of the updated targets. By doing
this, the client retrieves the target information for the targets they
want to update. When client retrieves all the information, the
updated_targets() method of 'tuf.client.updater' is called to determine
the list of targets which have been changed from those saved locally on
disk. tuf.client.upater.download_target() downloads all the targets in
the list in the destination directory, which is our temporary directory.
This will only store the file in the temporary directory if the
downloaded file matches the description of the file in the trusted
metadata.
<Arguments>
target_filepath:
The target's relative path on the remote repository.
<Exceptions>
tuf.FormatError:
If 'target_filepath', 'updated_target' in
'tuf.client.updater.download_target', is improperly formatted.
tuf.UnknownTargetError:
If 'target_filepath' was not found.
tuf.NoWorkingMirrorError:
If a 'target_filepath' could not be downloaded from any of the mirrors.
<Side Effects>
A target file is saved to the local system.
<Returns>
It returns a (destination directory, filename) tuple where the target is
been stored and filename of the target file been stored in the directory.
"""
tuf.formats.RELPATH_SCHEMA.check_match(target_filepath)
# Download file into a temporary directory shared over runtime
destination_directory = self.tempdir
# A new path is generated by joining the destination directory path that is
# our temporary directory path and target file path.
# Note: join() discards 'destination_directory' if 'target_filepath'
# contains a leading path separator (i.e., is treated as an absolute path).
filename = \
os.path.join(destination_directory, target_filepath.lstrip(os.sep))
# Switch TUF context. Switching context before instantiating updater
# because updater depends on some module (tuf.conf) variables.
self.switch_context()
# Locate the fileinfo of 'target_filepath'. updater.target() searches
# targets metadata in order of trust, according to the currently trusted
# snapshot. To prevent consecutive target file requests from referring to
# different snapshots, top-level metadata is not automatically refreshed.
# It returns the target information for a specific file identified by its
# file path. This target method also downloads the metadata of updated
# targets.
targets = [self.updater.target(target_filepath)]
# TODO: targets are always updated if destination directory is new, right?
# After the client has retrieved the target information for those targets
# they are interested in updating, updated_targets() method is called to
# determine which targets have changed from those saved locally on disk.
# All the targets that have changed are returned in a list. From this list,
# a request to download is made by calling 'download_target()'.
updated_targets = \
self.updater.updated_targets(targets, destination_directory)
# The download_target() method in tuf.client.updater performs the actual
# download of the specified target. The file is saved to the
# 'destination_directory' argument.
for updated_target in updated_targets:
self.updater.download_target(updated_target, destination_directory)
return destination_directory, filename
# TODO: decide prudent course of action in case of failure.
def get_target_filepath(self, source_url):
"""
<Purpose>
Given source->target map, this method will figure out what TUF should
download when a URL is given.
<Arguments>
source_url:
The URL of the target we want to retrieve.
<Exceptions>
tuf.URLMatchesNoPatternError:
This exception is raised when no target_path url pattern is wrong and
does match regular expression.
<Side Effects>
None
<Returns>
If the target filepath is matched, return the filepath, otherwise raise
an exception.
"""
parsed_source_url = six.moves.urllib.parse.urlparse(source_url)
target_filepath = None
try:
# Does this source URL match any regular expression which tells us
# how to map the source URL to a target URL understood by TUF?
for target_path in self.configuration.target_paths:
#TODO: What these two lines are doing?
# target_path: { "regex_with_groups", "target_with_group_captures" }
# e.g. { ".*(/some/directory)/$", "{0}/index.html" }
source_path_pattern, target_path_pattern = list(target_path.items())[0]
source_path_match = \
re.match(source_path_pattern, parsed_source_url.path)
# TODO: A failure in string formatting is *critical*.
if source_path_match is not None:
target_filepath = \
target_path_pattern.format(*source_path_match.groups())
# If there is more than one regular expression which
# matches source_url, we resolve ambiguity by order of
# appearance.
break
# If source_url does not match any regular expression...
if target_filepath is None:
# ...then we raise a predictable exception.
raise tuf.URLMatchesNoPatternError(source_url)
except:
logger.exception('Possibly invalid target_paths for ' + \
repr(self.configuration.network_location) + \
'! No TUF interposition for ' + repr(source_url))
raise
else:
return target_filepath
# TODO: distinguish between urllib and urllib2 contracts.
def open(self, url, data=None):
"""
<Purpose>
Open the URL url which can either be a string or a request object.
The file is opened in the binary read mode as a temporary file. This is
called when TUF wants to open an already existing updater's 'url'.
<Arguments>
url:
The one which is to be opened.
data:
Must be a bytes object specifying additional data to be sent to the
server or None, if no such data needed.
<Exceptions>
tuf.FormatError:
TODO: validate arguments.
tuf.NoWorkingMirrorError:
If a 'target_filepath' could not be downloaded from any of the mirrors.
tuf.URLMatchesNoPatternError:
This exception is raised when no target_path url pattern is wrong and
does match regular expression.
<Side Effects>
None
<Returns>
'response' which is a file object with info() and geturl() methods added.
"""
# TODO: validate arguments.
filename, headers = self.retrieve(url, data=data)
# TUF should always open files in binary mode and remain transparent to the
# software updater. Opening files in text mode slightly alters the
# end-of-line characters and prevents binary files from properly loading on
# Windows.
# http://docs.python.org/2/tutorial/inputoutput.html#reading-and-writing-files
# TODO: like tempfile, ensure file is deleted when closed? open() in the
# line below is a predefined function in python.
temporary_file = open(filename, 'rb')
#TODO: addinfourl is not in urllib package anymore. We need to check if
# other option for this is working or not.
# Extend temporary_file with info(), getcode(), geturl()
# http://docs.python.org/2/library/urllib.html#urllib.urlopen
# addinfourl() works as a context manager.
response = six.moves.urllib.response.addinfourl(temporary_file, headers,
url, code=200)
return response
# TODO: distinguish between urllib and urllib2 contracts
def retrieve(self, url, filename=None, reporthook=None, data=None):
"""
<Purpose>
Get the target file path by calling self.get_target_filepath(url) and
then self.download_target() method for the above file path.
<Arguments>
url:
The URL of the target file to retrieve.
filename:
If given, then the given filename is used. If the filename is none,
then temporary file is used.
<Exceptions>
tuf.FormatError:
If 'target_filepath', 'updated_target' in
tuf.client.updater.download_target and arguments of updated_targets are
improperly formatted.
tuf.UnknownTargetError:
If 'target_filepath' was not found.
tuf.NoWorkingMirrorError:
If a 'target_filepath' could not be downloaded from any of the mirrors.
tuf.URLMatchesNoPatternError:
This exception is raised when no target_path url pattern is wrong and
does match regular expression.
<Side Effects>
A target file is saved to the local system when the
download_target(target_filepath) is called.
<Returns>
It returns the filename and the headers of the file just retrieved.
"""
logger.info('Interposing for '+ repr(url))
# What is the actual target to download given the URL? Sometimes we would
# like to transform the given URL to the intended target; e.g. "/simple/"
# => "/simple/index.html".
target_filepath = self.get_target_filepath(url)
# TODO: Set valid headers fetched from the actual download.
# NOTE: Important to guess the mime type from the target_filepath, not the
# unmodified URL.
content_type, content_encoding = mimetypes.guess_type(target_filepath)
headers = {
# NOTE: pip refers to this same header in at least these two duplicate
# ways.
"content-type": content_type,
"Content-Type": content_type,
}
# Download the target filepath determined by the original URL.
temporary_directory, temporary_filename = \
self.download_target(target_filepath)
if filename is None:
# If no filename is given, use the temporary file.
filename = temporary_filename
else:
# Otherwise, copy TUF-downloaded file in its own directory
# to the location user specified.
shutil.copy2(temporary_filename, filename)
return filename, headers
# TODO: thread-safety, perhaps with a context manager.
def switch_context(self):
"""
<Purpose>
There is an updater object for each network location that is interposed.
Context switching is required because there are multiple
'tuf.client.updater' objects and each one depends on tuf.conf settings
that are shared.
For this, two settings are required:
1. Setting local repository directory in 'tuf.conf'.
2. Setting the local SSL certificate PEM file.
<Arguments>
None
<Exceptions>
None
<Side Effects>
The given configuration's 'repository_directory' and ssl_certificates
settings are set to 'tuf.conf.repository_directory' and
'tuf.conf.ssl_certificates', respectively.
<Returns>
None
"""
# Set the local repository directory containing the metadata files.
tuf.conf.repository_directory = self.configuration.repository_directory
# Set the local SSL certificates PEM file.
tuf.conf.ssl_certificates = self.configuration.ssl_certificates
class UpdaterController(object):
"""
<Purpose>
A controller of Updater() objects. Given a configuration, it can build and
store an Updater, which can be used later with the help of get() method.
<UpdaterController's Methods>
__init__():
It creates and initializes an empty private map of updaters and an empty
private set of repository mirror network locations (hostname:port). This
is used to store the updaters added by TUF and later on TUF can get these
updater to reutilize.
__check_configuration_on_add(configuration):
It checks if the given configuration is valid or not.
add(configuration):
This method adds the updater by adding an object of
'tuf.interposition.updater.Updater' in the __updater map and by adding
repository mirror's network location in the empty set initialized when
the object of 'tuf.interposition.updater.UpdaterController' is created.
get(url):
Get the updater if it already exists. It takes the url and parses it.
Then it utilizes hostname and port of that url to check if it already
exists or not. If the updater exists, then it calls the
get_target_filepath() method which returns a target file path to be
downloaded.
refresh(configuration):
Refreshes the top-level metadata of the given 'configuration'. It
updates the latest copies of the metadata of the top-level roles.
remove(configuration):
Remove an Updater matching the given 'configuration' as well as its
associated mirrors.
"""
def __init__(self):
"""
<Purpose>
Initalize a private map of updaters and a private set of repository
mirror network locations (hostname:port) once the object of
'tuf.interposition.updater.UpdaterController' is created. This empty map
and set is later used to add, get, and remove updaters and their mirrors.
<Arguments>
None
<Exceptions>
None
<Side Effects>
An empty map called '__updaters' and an empty set called
'__repository_mirror_network_locations' is created.
<Returns>
None
"""
# A private map of Updaters (network_location: str -> updater: Updater)
self.__updaters = {}
# A private set of repository mirror network locations
self.__repository_mirror_network_locations = set()
def __check_configuration_on_add(self, configuration):
"""
<Purpose>
If the given Configuration is invalid, an exception is raised.
Otherwise, repository mirror network locations are returned.
<Arguments>
'configuration' contains hostname, port number, repository mirrors which
are to be checked if they are valid or not.
<Exceptions>
tuf.InvalidConfigurationError:
If the configuration is invalid. For example - wrong hostname, invalid
port number, wrong mirror format.
tuf.FormatError:
If the network_location is not unique or configuration.network_location
is same as repository_mirror_network_locations.
<Side Effects>
It logs the error message.
<Returns>
'repository_mirror_network_locations'
In order to prove that everything worked well, a part of configuration
is returned which is the list of repository mirrors.
"""
# Updater has a "global" view of configurations, so it performs
# additional checks after Configuration's own local checks. This will
# check if everything in tuf.interposition.configuration.ConfigurationParser
# worked or not.
# According to __read_configuration() method in
# tuf.interposition.__init__,
# configuration is an instance of
# tuf.interposition.configuration.Configuration because in this method -
# configuration = configuration_parser.parse()
# configuration_parser is an instance of
# tuf.interposition.configuration.ConfigurationParser
# The configuration_parser.parse() returns
# tuf.interposition.configuration.Configuration as an object which makes
# configuration an instance of tuf.interposition.configuration.Configuration
if not isinstance(configuration, Configuration):
raise tuf.InvalidConfigurationError('Invalid configuration')
# Restrict each (incoming, outgoing) network location pair to be unique across
# configurations; this prevents interposition cycles, amongst other
# things.
# GOOD: A -> { A:X, A:Y, B, ... }, C -> { D }, ...
# BAD: A -> { B }, B -> { C }, C -> { A }, ...
if configuration.network_location in self.__updaters:
message = 'Updater with ' + repr(configuration.network_location) + \
' already exists as an updater.'
raise tuf.FormatError()
if configuration.network_location in self.__repository_mirror_network_locations:
message = 'Updater with ' + repr(configuration.network_location) + \
' already exists as a mirror.'
raise tuf.FormatError(message)
# Check for redundancy in server repository mirrors.
repository_mirror_network_locations = \
configuration.get_repository_mirror_hostnames()
for mirror_network_location in repository_mirror_network_locations:
try:
# Restrict each network location in every (incoming, outgoing) pair to be
# unique across configurations; this prevents interposition cycles,
# amongst other things.
if mirror_network_location in self.__updaters:
message = 'Mirror with ' + repr(mirror_network_location) + \
' already exists as an updater.'
raise tuf.FormatError(message)
if mirror_network_location in self.__repository_mirror_network_locations:
message = 'Mirror with ' + repr(mirror_network_location) + \
' already exists as a mirror.'
raise tuf.FormatError(message)
except (tuf.FormatError) as e:
error_message = 'Invalid repository mirror ' + \
repr(mirror_network_location)
logger.exception(error_message)
raise
return repository_mirror_network_locations
def add(self, configuration):
"""
<Purpose>
Add an Updater based on the given 'configuration'. TUF keeps track of the
updaters so that it can be fetched for later use.
<Arguments>
'configuration' is an object and on the basis of this configuration, an
updater will be added.
<Exceptions>
tuf.InvalidConfigurationError:
If the configuration is invalid. For example - wrong hostname, invalid
port number, wrong mirror format.
tuf.FormatError:
This exception is raised if the network location which tuf is trying to
add is not unique.
<Side Effects>
The object of 'tuf.interposition.updater.Updater' is added in the list of
updaters. Also, the mirrors of this updater are added to
'repository_mirror_network_locations'.
<Returns>
None
"""
repository_mirror_network_locations = \
self.__check_configuration_on_add(configuration)
# If all is well, build and store an Updater, and remember network
# locations.
logger.info('Adding updater for interposed ' + repr(configuration))
# Adding an object of the tuf.interposition.updater.Updater with the given
# configuration.
self.__updaters[configuration.network_location] = Updater(configuration)
# Adding the new the repository mirror network locations to the list.
self.__repository_mirror_network_locations.update(repository_mirror_network_locations)
def refresh(self, configuration):
"""
<Purpose>
To refresh the top-level metadata of the given 'configuration'.
It updates the latest copies of the metadata for the top-level roles.
<Arguments>
'configuration' is the object containing the configurations of the updater
to be refreshed.
<Exceptions>
tuf.InvalidConfigurationError:
If there is anything wrong with the Format of the configuration, this
exception is raised.
tuf.NotFoundError:
If the updater to be refreshed is not found in the list of updaters or
mirrors, then tuf.NotFoundError exception is raised.
tuf.NoWorkingMirrorError:
If the metadata for any of the top-level roles cannot be updated.
tuf.ExpiredMetadataError:
If any metadata has expired.
<Side Effects>
It refreshes the updater and indicate this in the log file.
<Returns>
None
"""
# Check if the configuration is valid else raise an exception.
if not isinstance(configuration, Configuration):
raise tuf.InvalidConfigurationError('Invalid configuration')
# Get the repository mirrors of the given configuration.
repository_mirror_network_locations = \
configuration.get_repository_mirror_hostnames()
# Check if the configuration.network_location is available in the updater
# or mirror list.
if configuration.network_location not in self.__updaters:
message = 'Update with ' + repr(configuration.network_location) + \
' not found.'
raise tuf.NotFoundError(message)
if not repository_mirror_network_locations.issubset(self.__repository_mirror_network_locations):
message = 'Mirror with ' + repr(repository_mirror_network_locations) + \
' not found.'
raise tuf.NotFoundError(message)
# Get the updater and refresh its top-level metadata. In the majority of
# integrations, a software updater integrating TUF with interposition will
# usually only require an initial refresh() (i.e., when configure() is
# called). A series of target file requests may then occur, which are all
# referenced by the latest top-level metadata updated by configure().
# Although interposition was designed to remain transparent, for software
# updaters that require an explicit refresh of top-level metadata, this
# method is provided.
logger.info('Refreshing top-level metadata for ' + repr(configuration))
# If everything is good then fetch the updater from __updaters with the
# given configurations.
updater = self.__updaters.get(configuration.network_location)
# Refresh the fetched updater.
updater.refresh()
def get(self, url):
"""
<Purpose>
This method is to get the updater if it already exists. It takes the url
and parse it. Then it utilizes hostname and port of that url to check if
it already exists or not. If the updater exists, then it calls the
get_target_filepath() method which returns a target file path to be
downloaded.
<Arguments>
url:
URL which TUF is trying to get an updater. Assumption that url is a
string.
<Exceptions>
None
<Side Effects>
This method logs the messages in a log file if updater is not found or
not for the given url.
<Returns>
The get() method returns the updater with the given configuration. If
updater does not exists, it returns None.
"""
updater = None
try:
# Parse the given url to access individual parts of it.
parsed_url = six.moves.urllib.parse.urlparse(url)
hostname = parsed_url.hostname
port = parsed_url.port or 80
netloc = parsed_url.netloc
# Combine the hostname and port number and assign it to network_location.
# The combination of hostname and port is used to identify an updater.
network_location = \
"{hostname}:{port}".format(hostname=hostname, port=port)
# There can be a case when parsed_url.netloc does not have a port (e.g.
# 80). To avoid errors because of this case, tuf.interposition again set
# the parameters.
network_locations = set((netloc, network_location))
updater = self.__updaters.get(network_location)
if updater is None:
logger.warning('No updater for ' + repr(hostname))
else:
# Ensure that the updater is meant for this (hostname, port).
if updater.configuration.network_location in network_locations:
logger.info('Found updater for interposed network location: '+ \
repr(network_location))
# Raises an exception in case we do not recognize how to
# transform this URL for TUF. In that case, there will be no
# updater for this URL.
target_filepath = updater.get_target_filepath(url)
else:
# Same hostname, but different (not user-specified) port.
logger.warning('We have an updater for ' + \
repr(updater.configuration.network_location) + \
'but not for ' + repr(network_locations))
updater = None
except:
logger.exception('No updater or interposition for ' + repr(url))
updater = None
finally:
if updater is None:
logger.warning('No updater or interposition for ' + repr(url))
return updater
def remove(self, configuration):
"""
<Purpose>
Remove an Updater matching the given 'configuration', as well as its
associated mirrors.
<Arguments>
'configuration' is the configuration object of the updater to be removed.
<Exceptions>
tuf.InvalidConfigurationError:
If there is anything wrong with the configuration for example invalid
hostname, invalid port number etc, tuf.InvalidConfigurationError is
raised.
tuf.NotFoundError:
If the updater with the given configuration does not exists,
tuf.NotFoundError exception is raised.
<Side Effects>
Removes the stored updater and the mirrors associated with that updater.
Then tuf logs this information in a log file.
<Returns>
None
"""
# Check if the given configuration is valid or not.
if not isinstance(configuration, Configuration):
raise tuf.InvalidConfigurationError('Invalid configuration')
# If the configuration is valid, get the repository mirrors associated with
# it.
repository_mirror_network_locations = \
configuration.get_repository_mirror_hostnames()
# Check if network location of the given configuration exists or not.
if configuration.network_location not in self.__updaters:
raise tuf.NotFoundError('Network location not found')
# Check if the associated mirrors exists or not.
if not repository_mirror_network_locations.issubset(self.__repository_mirror_network_locations):
raise tuf.NotFoundError('Repository mirror does not exists')
# Get the updater.
updater = self.__updaters.get(configuration.network_location)
# If everything works well, remove the stored Updater as well as its
# associated repository mirror network locations.
updater.cleanup()
# Delete the updater from the list of updaters.
del self.__updaters[configuration.network_location]
# Remove the associated mirrors from the repository mirror set.
self.__repository_mirror_network_locations.difference_update(repository_mirror_network_locations)
# Log the message that the given updater is removed.
logger.info('Updater removed for interposed ' + repr(configuration))
| vladimir-v-diaz/demo | tuf/tuf/interposition/updater.py | updater.py | py | 35,913 | python | en | code | 1 | github-code | 13 |
17088588374 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import json
from alipay.aop.api.response.AlipayResponse import AlipayResponse
from alipay.aop.api.domain.CatalogNodeData import CatalogNodeData
class AlipayOpenSearchBrandcatalogBatchqueryResponse(AlipayResponse):
def __init__(self):
super(AlipayOpenSearchBrandcatalogBatchqueryResponse, self).__init__()
self._data = None
@property
def data(self):
return self._data
@data.setter
def data(self, value):
if isinstance(value, list):
self._data = list()
for i in value:
if isinstance(i, CatalogNodeData):
self._data.append(i)
else:
self._data.append(CatalogNodeData.from_alipay_dict(i))
def parse_response_content(self, response_content):
response = super(AlipayOpenSearchBrandcatalogBatchqueryResponse, self).parse_response_content(response_content)
if 'data' in response:
self.data = response['data']
| alipay/alipay-sdk-python-all | alipay/aop/api/response/AlipayOpenSearchBrandcatalogBatchqueryResponse.py | AlipayOpenSearchBrandcatalogBatchqueryResponse.py | py | 1,033 | python | en | code | 241 | github-code | 13 |
39709990041 | from manimlib.imports import *
class Equations(Scene):
def construct(self):
#Making equations
first_eq = TextMobject("$$d = \\sqrt{ {(x_{2} - x_{1})}^2 + {(y_{2} - y_{1})}^2}$$")
second_eq = ["$d$", "=", "$\\sqrt{ {(\\Delta x)}^2 + {(\\Delta y)}^2}$",]
second_mob = TextMobject(*second_eq)
for i,item in enumerate(second_mob):
if(i != 0):
item.next_to(second_mob[i-1],RIGHT)
eq2 = VGroup(*second_mob)
des1 = TextMobject("The distance between two points can be written as")
des2 = TextMobject("Or it can rewritten to be in the form")
#Coloring equations
second_mob.set_color_by_gradient("#33ccff","#ff00ff")
#Positioning equations
des1.shift(2*UP)
des2.shift(2*UP)
#Animating equations
self.play(Write(des1))
first_eq.shift(DOWN)
self.play(Write(first_eq))
self.play(ReplacementTransform(des1, des2), Transform(first_eq, eq2))
self.wait(1)
for i, item in enumerate(eq2):
if (i<2):
eq2[i].set_color(color=PURPLE)
else:
eq2[i].set_color(color="#00FFFF")
self.add(eq2)
self.wait(1)
| advayk/Manim-CalcII-Project | trial_equations copy.py | trial_equations copy.py | py | 1,253 | python | en | code | 0 | github-code | 13 |
31713822284 | class Solution:
def build_mapping(self, order):
return {char: i for i, char in enumerate(order)}
def compare(self, prev, current):
length = len(current)
for i, char in enumerate(prev):
if i >= length:
return 1
a = self.mapping[char]
b = self.mapping[current[i]]
if a > b:
return 1
elif a < b:
return -1
return 0
def isAlienSorted(self, words, order):
self.mapping = self.build_mapping(order)
for i in range(0, len(words) - 1):
prev, current = words[i], words[i+1]
if self.compare(prev, current) > 0:
return False
return True
if __name__ == "__main__":
s = Solution()
r = s.isAlienSorted(words=["hello","leetcode"], order="hlabcdefgijkmnopqrstuvwxyz")
assert r is True
r = s.isAlienSorted(words=["word","world","row"], order="worldabcefghijkmnpqstuvxyz")
assert r is False
r = s.isAlienSorted(words=["apple","app"], order="abcdefghijklmnopqrstuvwxyz")
assert r is False
| gsy/leetcode | verifying_an_alian_dictionary.py | verifying_an_alian_dictionary.py | py | 1,120 | python | en | code | 1 | github-code | 13 |
3646677119 | # -*- coding: utf-8 -*-
"""
Created on Mon Aug 31 07:54:42 2020
@author: Peng
"""
#%%
# Libraries and modules
import pandas as pd
import random
import numpy as np
# from model_templates_tmr import original_blstm
from keras.utils import to_categorical
# import sys
# sys.path.insert(1,'scripts/python/tmr/')
#%%
#Inputs
cluster_dataframe_path='data/cluster_dataframes/'
model_save_path='data/models/'
magn=20
max_len=100
sample_frac=0.2
is_dna_data=False
mask_length = None
embed_size = 256
batch_size=100
epochs=50
#%%
def aa_one_hot(seqs,max_len=None):
# =============================================================================
# one-hot encodes amino acid sequences. Sequences shorter than the longest sequence are
# paded with 0's for all amino acid features. Functionality in the future will include a nucleotide
# option.
# -seqs-- a list where each element is an amino acid string
# =============================================================================
import numpy as np
from tensorflow.image import resize
#dictionary matching AA and feature index for one-hot encoded matrix
aa_dict= {"A": 0,
"C": 1,
"D": 2,
"E": 3,
"F": 4,
"G": 5,
"H": 6,
"I": 7,
"K": 8,
"L": 9,
"M": 10,
"N": 11,
"P": 12,
"Q": 13,
"R": 14,
"S": 15,
"T": 16,
"V": 17,
"W": 18,
"Y": 19,
"X": 20,
"B": 21,
"Z": 22,
"J": 23,
"U": 24,
"O": 25}
#find maximum length sequence
if max_len == None:
n=[len(seq) for seq in seqs]
max_len = max(n)
#pre-define matrix based on length and number of sequences; pad 0s on end
#of sequences shorter than maximum length sequence
one_hot_matrix=np.zeros(shape=(len(seqs),max_len,26),dtype='float')
#indexing one_hot samples and timeseries (i.e., aa position)
#feature index is retrieved with dictionary
i=0
for seq in seqs:
j=0
tmp_vector=np.zeros(shape=(1,len(seq),26,1))
for aa in seq:
a=aa_dict[aa]
tmp_vector[0,j,a,0]=1
# one_hot_matrix[i,j,a]=1
j+=1
# if j == max_len: break
one_hot_matrix[i,:,:]=resize(tmp_vector,size=(max_len,26))[0,:,:,0].numpy()
i+=1
return one_hot_matrix
#%%
#load data from directory
def load_seq_dataframe(dir_path):
import os
import pandas as pd
seq_df=pd.DataFrame()
for filename in os.listdir(dir_path):
new_csv=dir_path+filename
seq_df=seq_df.append(pd.read_csv(new_csv))
return seq_df
#%%
#model architecture
def original_blstm(num_classes, num_letters, sequence_length, embed_size=50):
from keras.models import Sequential
from keras.layers import LSTM, Masking, Dense, Bidirectional, Dropout, MaxPooling1D, Conv1D, Activation
# from keras.layers.normalization import BatchNormalization
from keras.optimizers import Adam#, Nadam
model = Sequential()
model.add(Conv1D(input_shape=(sequence_length, num_letters), filters=320, kernel_size=26, padding="valid", activation="relu"))
model.add(MaxPooling1D(pool_size=13, strides=13))
model.add(Dropout(0.1))
model.add(Conv1D(filters=100, kernel_size=26, padding="valid", activation="relu"))
model.add(MaxPooling1D(pool_size=5))
model.add(Masking(mask_value=0))
model.add(Dropout(0.2))
model.add(Bidirectional(LSTM(320, activation="tanh", return_sequences=True)))
model.add(Dropout(0.5))
#model.add(LSTM(num_classes, activation="softmax", name="AV"))
model.add(LSTM(embed_size, activation="tanh"))
model.add(Dense(num_classes, activation=None, name="AV"))
model.add(Activation("softmax"))
model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=0.001), metrics=['accuracy'])
return model
#%%
#generate datasets for fitting
seq_df=load_seq_dataframe(cluster_dataframe_path)
uniq_anno=seq_df.annotation.unique()
num_classes=len(uniq_anno)
annotation_ydata_df=pd.DataFrame({'ydata': range(num_classes),'annotation': uniq_anno})
seq_df=pd.merge(seq_df,annotation_ydata_df,on='annotation')
seq_cluster=seq_df.loc[seq_df['Cluster'] > -1]
seq_cluster_noise=seq_df.loc[seq_df['Cluster'] == -1]
seq_cluster_a=seq_cluster
#%%
#generate training data for annotation/cluster datasets
##annotations
# train_a=seq_df.groupby(['annotation']).sample(frac=sample_frac)
# seq_df=seq_df.drop(train_a.index)
# train_a_one_hot=aa_one_hot(train_a['sequence'],max_len=max_len)
train_a=seq_cluster_a.groupby(['annotation']).sample(frac=sample_frac)
seq_cluster_a=seq_cluster_a.drop(train_a.index)
train_a_one_hot=aa_one_hot(train_a['sequence'],max_len=max_len)
##clusters
train_c=seq_cluster.groupby(['annotation','Cluster']).sample(frac=sample_frac)
seq_cluster=seq_cluster.drop(train_c.index)
train_c_one_hot=aa_one_hot(train_c['sequence'],max_len=max_len)
#%%
#generate validation data for annotation/cluster datasets
##annotation
# validation_a=seq_df.groupby(['annotation']).sample(frac=sample_frac)
# seq_df=seq_df.drop(validation_a.index)
# validation_a_one_hot=aa_one_hot(validation_a['sequence'],max_len=max_len)
validation_a=seq_cluster_a.groupby(['annotation']).sample(frac=sample_frac)
seq_cluster_a=seq_cluster_a.drop(validation_a.index)
validation_a_one_hot=aa_one_hot(validation_a['sequence'],max_len=max_len)
##clusters
validation_c=seq_cluster.groupby(['annotation','Cluster']).sample(frac=sample_frac)
seq_cluster=seq_cluster.drop(validation_c.index)
validation_c_one_hot=aa_one_hot(validation_c['sequence'],max_len=max_len)
#generate test data for annotation/cluster datasets
##annotation
# test_a=seq_df
# test_a_one_hot=aa_one_hot(test_a['sequence'],max_len=max_len)
test_a=seq_cluster_a
test_a_one_hot=aa_one_hot(test_a['sequence'],max_len=max_len)
#clusters
test_c=seq_cluster
test_c_one_hot=aa_one_hot(test_c['sequence'],max_len=max_len)
test_noise_one_hot=aa_one_hot(seq_cluster_noise['sequence'],max_len=max_len)
#%%
##generate y data for annotation/cluster datasets
##annotation
ytrain_a=to_categorical(np.array(train_a.ydata,dtype='uint8'),num_classes)
yvalidation_a=to_categorical(np.array(validation_a.ydata,dtype='uint8'),num_classes)
ytest_a=to_categorical(np.array(test_a.ydata,dtype='uint8'),num_classes)
#clusters
ytrain_c=to_categorical(np.array(train_c.ydata,dtype='uint8'),num_classes)
yvalidation_c=to_categorical(np.array(validation_c.ydata,dtype='uint8'),num_classes)
ytest_c=to_categorical(np.array(test_c.ydata,dtype='uint8'),num_classes)
ytest_noise=to_categorical(np.array(seq_cluster_noise.ydata,dtype='uint8'),num_classes)
num_letters = 4 if is_dna_data else 26
# sequence_length = train_one_hot.shape[1]
model_a= original_blstm(num_classes, num_letters, max_len, embed_size=embed_size)
model_c= original_blstm(num_classes, num_letters, max_len, embed_size=embed_size)
# n_train_a=train_a_one_hot.shape[0]
# n_train_c=train_c_one_hot.shape[0]
n_validation_a=validation_a_one_hot.shape[0]
n_validation_c=validation_c_one_hot.shape[0]
model_a.fit(x=train_a_one_hot,y=ytrain_a,batch_size=batch_size,
validation_data=(validation_a_one_hot,yvalidation_a),validation_batch_size=magn*batch_size,
epochs=epochs)
model_c.fit(x=train_c_one_hot,y=ytrain_c,batch_size=batch_size,
validation_data=(validation_c_one_hot,yvalidation_c),validation_batch_size=magn*batch_size,
epochs=epochs)
model_a.save(model_save_path + 'swiss100_annotation_only.h5')
model_c.save(model_save_path + 'swiss100_clusters.h5')
model_a.evaluate(test_a_one_hot,ytest_a)
model_c.evaluate(test_c_one_hot,ytest_c)
model_a.evaluate(test_noise_one_hot,ytest_noise)
model_c.evaluate(test_noise_one_hot,ytest_noise)
# for i in range(epochs):
# #generate indices for building training batch datasets
# sample_train_a_index=random.sample(range(n_train_a),batch_size)
# sample_train_c_index=random.sample(range(n_train_c),batch_size)
# #generate indices for building validation batch datasets
# sample_validation_a_index=random.sample(range(n_validation_a),batch_size)
# sample_validation_c_index=random.sample(range(n_validation_c),batch_size)
# #batch datasets
# ##training
# tmp_train_a_x=train_a_one_hot[sample_train_a_index,:,:]
# tmp_train_a_y=ytrain_a[sample_train_a_index,:]
# tmp_train_c_x=train_c_one_hot[sample_train_c_index,:,:]
# tmp_train_c_y=ytrain_c[sample_train_c_index,:]
# ##validation
# tmp_validation_a_x=validation_a_one_hot[sample_validation_a_index,:,:]
# tmp_validation_a_y=yvalidation_a[sample_validation_a_index,:]
# tmp_validation_c_x=validation_c_one_hot[sample_validation_c_index,:,:]
# tmp_validation_c_y=yvalidation_c[sample_validation_c_index,:]
# #fit models with batch datasets
# model_a.train_on_batch(tmp_train_a_x,tmp_train_a_y,validation_data=(tmp_validation_a_x,tmp_validation_a_y))
# model_c.train_on_batch(tmp_train_c_x,tmp_train_c_y,validation_data=(tmp_validation_c_x,tmp_validation_c_y))
# model.evaluate(test_one_hot,ytest)
# model.evaluate(test_noise_one_hot,ytest_noise)
##fit model
# model.fit(x=train_one_hot,y=ytrain,batch_size=100,epochs=500,validation_data=(validation_one_hot,yvalidation))
# =============================================================================
# model.evaluate(test_one_hot,ytest)
#
#
#
# #cluster sampling
# train=seq_cluster.groupby(['annotation','Cluster']).sample(5)
# seq_cluster=seq_cluster.drop(train.index)
# validation=seq_cluster.groupby(['annotation','Cluster']).sample(5)
# seq_cluster=seq_cluster.drop(validation.index)
# test=seq_cluster
#
#
#
#
#
# num_letters = 4 if is_dna_data else 26
# sequence_length = train_one_hot.shape[1]
# model = original_blstm(num_classes, num_letters, max_len, embed_size=embed_size)
#
# ##fit model
# ytrain=to_categorical(np.array(train.ydata,dtype='uint8'),num_classes)
# yvalidation=to_categorical(np.array(validation.ydata,dtype='uint8'),num_classes)
# ytest=to_categorical(np.array(test.ydata,dtype='uint8'),num_classes)
# ytest_noise=to_categorical(np.array(seq_cluster_noise.ydata,dtype='uint8'),num_classes)
# =============================================================================
# # model.fit(x=train_one_hot,y=ytrain,batch_size=100,epochs=500,validation_data=(validation_one_hot,yvalidation))
# model.evaluate(test_one_hot,ytest)
# model.evaluate(test_noise_one_hot,ytest_noise)
# model.save(model_save_path + 'swiss100_annotation_clusters.h5')
| taylorroyalty/sequence_cnn | gene_function/scripts/python/tmr/tmr_model_functions.py | tmr_model_functions.py | py | 10,751 | python | en | code | 0 | github-code | 13 |
43737307405 | import numpy as np
def get_reward(env, cluster, action, is_scheduled, time, debug=False):
# Weights for each factor
w1 = 1
w2 = 1
w3 = 1
w4 = 1
util = {}
for node in cluster.nodes:
cpu_ratio, mem_ratio = node.get_node_rsrc_ratio()
util[node.node_name] = {
"cpu": cpu_ratio,
"mem": mem_ratio
}
# rur = mean of cpu and mem utilization of all node
rur_cpu = round(np.mean([util[node]["cpu"] for node in util]), 2)
rur_mem = round(np.mean([util[node]["mem"] for node in util]), 2)
rur = round((rur_cpu + rur_mem) / 2, 2)
if debug:
print(f"(Stragegy_Default) Avg CPU util: {rur_cpu}")
print(f"(Stragegy_Default) Avg Mem util: {rur_mem}")
print(f"(Stragegy_Default) Avg Util: {rur}")
# rbd1 = summation of standard deviation of each resource in all nodes
std_cpu = round(np.std([util[node]["cpu"] for node in util]), 2)
std_mem = round(np.std([util[node]["mem"] for node in util]), 2)
rbd1 = round(std_cpu + std_mem, 2)
if debug:
print(f"(Stragegy_Default) Std CPU util: {std_cpu}")
print(f"(Stragegy_Default) Std Mem util: {std_mem}")
print(f"(Stragegy_Default) Imbalance: {rbd1}")
# rbd2 = Resource balance in each node between cpu and mem (1: best, 0: worst)
# The worst case should be 1 (e.g. All cpu: 1 and All mem: 0)
rbd2 = 0
for node in util:
rbd2 += abs(util[node]["cpu"] - util[node]["mem"])
rbd2 = round(rbd2 / len(util), 2)
rbd2 = 1 - rbd2
# prg = The number of scheduled pods over time (1: best, 0: worst) - Competitive reward only
# app = Average pending pods over time (1: best, 0: worst) - Competitive reward only
# pwd = Penalty for the wrong decision (-5 for wrong decision, 0 for correct decision)
if is_scheduled:
pwd = 0
else:
pwd = -5
reward = w1 * rur + w2 * rbd1 + w3 * rbd2 + w4 * pwd
return reward | seonwookim92/KubeEnv | kube_rl_scheduler/strategies/reward/static.py | static.py | py | 1,976 | python | en | code | 0 | github-code | 13 |
42425897341 | import numpy as np
name = 'GENERIC'
def load(train_input_file, train_output_file, test_input_file, test_output_file):
global inputsize
global inputdim
global outputsize
train_input = np.load(train_input_file)
train_output = np.load(train_output_file)
test_input = np.load(test_input_file)
test_output = np.load(test_output_file)
if(np.size(np.shape(train_input)) == 1):
inputsize = 1
inputdim = (1,)
else:
inputsize = np.prod(np.shape(train_input)[1:])
inputdim = np.shape(train_input)[1:]
if(np.size(np.shape(train_output)) == 1):
outputsize = 1
else:
outputsize = np.prod(np.shape(train_output)[1:])
return(train_input, train_output, test_input, test_output)
| kslaughter/opal | libOPAL/datasets/GENERIC.py | GENERIC.py | py | 773 | python | en | code | 4 | github-code | 13 |
70170844819 | #########################################################
# ~ ~ ~ Diversify ~ ~ ~ #
# A Spotify WebAPI that ranks the diversity of #
# your music library and makes recommendations #
# for new music if you'd like. #
# Author: Fuego #
#########################################################
import time
import Artist
import spotipy
from spotipy.oauth2 import SpotifyOAuth
from pyvis.network import Network
keys = open("keys.txt", "r")
client = keys.readline()
client_secret = keys.readline()
scope = 'user-library-read'
net = Network()
visited_uris = set()
visited_related_uris = set()
users_artists = {}
sp = spotipy.Spotify(auth_manager=SpotifyOAuth(
client_id=client[:-1],
client_secret=client_secret,
redirect_uri='http://localhost:8888/callback',
scope=scope))
#
def artist_related_to_list(artist_related, level):
artist_list = []
empty_artist = [Artist.Artist('', '', [''], graph_level=-1)]
for relation in artist_related['artists'][0:7]:
relation_name = relation['name']
relation_uri = relation['uri']
relation_artist_object = Artist.Artist(relation_name, relation_uri, empty_artist, graph_level=level)
artist_list.append(relation_artist_object)
if relation_uri not in visited_uris or relation_uri not in visited_related_uris:
visited_related_uris.add(relation_uri)
return artist_list
# Could be reincorporated back to track_accumulator
def saved_tracks_to_artists(total_tracks):
fifty_limit = (total_tracks // 50) * 50
# start track accumulator loop
track_accumulator(50, 0, fifty_limit)
# gets all tracks
def track_accumulator(limit, offset, offset_cap):
print("\n\nFetching all user tracks - this may take a while depending on the size of your library")
offset_var = offset
limit_var = limit
while True:
current_tracks = sp.current_user_saved_tracks(limit=limit_var, offset=offset_var)
for item in current_tracks['items']:
track = item['track']
artist_uri = track['artists'][0]['uri']
if artist_uri not in visited_uris:
add_artist(track, artist_uri)
else:
pass
value = check_offset(offset_var, offset_cap)
if value:
offset_var += limit_var
else:
break
def check_offset(current_offset, cap):
# print status update every 100 tracks
if current_offset % 100 == 0:
print("We are ", "{:.2%}".format(current_offset / cap), " of the way through your tracks")
time.sleep(0.55)
# print wait message every 200 tracks
if current_offset % 200 == 100:
time.sleep(0.09)
print("We are still sorting through your tracks...\nThanks for waiting!\n\n")
# print complete message at cap
if current_offset == cap:
print("\n\n100%! Track sorting complete!\nThanks for waiting!\n\n")
return False
# sleep and return True to continue incrementing offset to reach cap
else:
time.sleep(0.06)
return True
def add_artist(track_info, uri):
visited_uris.add(uri)
artist_name = track_info['artists'][0]['name']
artist_related = artist_related_to_list(sp.artist_related_artists(uri), 1)
users_artists[uri] = Artist.Artist(artist_name, uri, artist_related)
# VISUALIZER METHODS
# create node list
def create_network(artist_dict):
for uri, artist in artist_dict:
net.add_node(uri, artist.name)
for node in net.nodes:
this_artist = artist_dict[node.options["id"]]
for this_neighbor in this_artist.neighbors:
net.add_edge(this_artist.uri, this_neighbor)
# MAIN
# list of tracks from spotipy
saved_tracks = sp.current_user_saved_tracks()
# dict. k,v == artist_uri, Artist()
saved_tracks_to_artists(saved_tracks['total'])
for artist_key in users_artists:
artist_instance = users_artists[artist_key]
for related_artist in artist_instance.related:
if related_artist.uri in users_artists:
# print(f"{related_artist.name} related to {artist.name} from saved tracks", f"{artist.graph_level}:{related_artist.graph_level}")
artist_instance.start_relationship(related_artist)
else:
# print(f"{related_artist.name} related to {artist.name}", f"{artist.graph_level}:{related_artist.graph_level}")
artist_instance.add_related_neighbor(related_artist)
for artist_key in users_artists:
artist_instance = users_artists[artist_key]
name = artist_instance.name
print("Related to:", name)
for rel_artist in artist_instance.neighbors:
print(f"{users_artists[rel_artist].name}, level {users_artists[rel_artist].graph_level}")
print("\n\n")
| fueg0/diversify | main.py | main.py | py | 5,019 | python | en | code | 0 | github-code | 13 |
17114167584 |
import argparse
import itertools
import json
import logging
import sys
from os import environ, makedirs, path
from dotenv import load_dotenv
from agr_literature_service.lit_processing.utils.generic_utils import split_identifier
from agr_literature_service.lit_processing.utils.tmp_files_utils import init_tmp_dir
load_dotenv()
init_tmp_dir()
base_path = environ.get('XML_PATH')
# pipenv run python generate_dqm_json_test_set.py -i inputs/sample_dqm_load.json -d dqm_load_sample/
# pipenv run python generate_dqm_json_test_set.py -i inputs/sample_dqm_update.json -d dqm_update_sample/
# Take large dqm json data and generate a smaller subset to test with
# This takes about 90 seconds to run
logging.basicConfig(level=logging.INFO,
stream=sys.stdout,
format= '%(asctime)s - %(levelname)s - {%(module)s %(funcName)s:%(lineno)d} - %(message)s', # noqa E251
datefmt='%Y-%m-%d %H:%M:%S')
logger = logging.getLogger(__name__)
def load_sample_json(input_file, base_dir=base_path):
sample_file = base_dir + input_file
print("LOADING file {}".format(sample_file))
sample_json = dict()
try:
with open(sample_file, 'r') as f:
sample_json = json.load(f)
f.close()
except IOError:
logger.info("No sample.json file at %s", sample_file)
if not sample_json:
return
if 'data' not in sample_json:
logger.info("No 'data' in sample.json file at %s", sample_file)
return
return sample_json
def generate_dqm_json_test_set_from_sample_json(input_file, output_directory): # noqa C901
"""
generate <output_directory>/ files based on manually chosen entries in <input_file>
"""
sample_json = load_sample_json(input_file)
if not sample_json:
return
sample_path = base_path + output_directory
if not path.exists(sample_path):
makedirs(sample_path)
pmids_wanted = set()
mod_ids_wanted = dict()
ids_wanted = set()
ids_wanted_replace = dict()
for entry in sample_json['data']:
if 'pmid' in entry:
prefix, identifier, separator = split_identifier(entry['pmid'])
pmids_wanted.add(identifier)
ids_wanted.add(entry['pmid'])
if 'update_replace' in entry:
if entry['pmid'] not in ids_wanted_replace:
ids_wanted_replace[entry['pmid']] = dict()
for field in entry['update_replace']:
ids_wanted_replace[entry['pmid']][field] = entry['update_replace'][field]
if 'modId' in entry:
for mod_id in entry['modId']:
prefix, identifier, separator = split_identifier(mod_id)
if prefix not in mod_ids_wanted:
mod_ids_wanted[prefix] = set()
mod_ids_wanted[prefix].add(identifier)
ids_wanted.add(mod_id)
if 'update_replace' in entry:
if mod_id not in ids_wanted_replace:
ids_wanted_replace[mod_id] = dict()
for field in entry['update_replace']:
ids_wanted_replace[mod_id][field] = entry['update_replace'][field]
for mod in mod_ids_wanted:
logger.info("generating sample set for %s", mod)
input_filename = base_path + 'dqm_data/REFERENCE_' + mod + '.json'
logger.info("reading file %s", input_filename)
dqm_data = dict()
try:
with open(input_filename, 'r') as f:
dqm_data = json.load(f)
f.close()
except IOError:
logger.info("No %s file at %s", mod, input_filename)
if 'data' not in dqm_data:
logger.info("No 'data' in %s file at %s", mod, input_filename)
continue
dqm_wanted = []
for entry in dqm_data['data']:
if 'primaryId' in entry and entry['primaryId'] in ids_wanted:
xref_id = entry['primaryId']
if xref_id in ids_wanted_replace:
for field in ids_wanted_replace[xref_id]:
entry[field] = ids_wanted_replace[xref_id][field]
dqm_wanted.append(entry)
logger.info("Found primaryId %s in %s", entry['primaryId'], mod)
dqm_data['data'] = dqm_wanted
output_json_file = sample_path + 'REFERENCE_' + mod + '.json'
with open(output_json_file, "w") as json_file:
json_data = json.dumps(dqm_data, indent=4, sort_keys=True)
json_file.write(json_data)
json_file.close()
def generate_dqm_json_test_set_from_start_mid_end():
"""
generate dqm_sample/ files based on sampling from beginning, middle, and end of dqm files.
"""
sample_path = base_path + 'dqm_sample/'
if not path.exists(sample_path):
makedirs(sample_path)
sample_amount = 10
mods = ['SGD', 'RGD', 'FB', 'WB', 'MGI', 'ZFIN']
# mods = ['MGI']
for mod in mods:
logger.info("generating sample set for %s", mod)
input_filename = base_path + 'dqm_data/REFERENCE_' + mod + '.json'
logger.info("reading file %s", input_filename)
f = open(input_filename)
dqm_data = json.load(f)
# generate half-as-big set
# sample_amount = int(len(dqm_data['data']) / 2)
# dqm_data['data'] = dqm_data['data'][:sample_amount] # half one
# dqm_data['data'] = dqm_data['data'][-sample_amount:] # half two
reference_amount = len(dqm_data['data'])
if reference_amount > 3 * sample_amount:
sample1 = dqm_data['data'][:sample_amount]
start = int(reference_amount / 2) - 1
sample2 = dqm_data['data'][start:start + sample_amount]
sample3 = dqm_data['data'][-sample_amount:]
dqm_data['data'] = list(itertools.chain(sample1, sample2, sample3))
output_json_file = sample_path + 'REFERENCE_' + mod + '.json'
with open(output_json_file, "w") as json_file:
json_data = json.dumps(dqm_data, indent=4, sort_keys=True)
json_file.write(json_data)
json_file.close()
if __name__ == "__main__":
"""
call main start function
"""
parser = argparse.ArgumentParser()
parser.add_argument('-i', '--input', action='store', help='input json file to use')
parser.add_argument('-d', '--directory', action='store', help='output directory to generate into')
args = vars(parser.parse_args())
logger.info("starting generate_dqm_json_test_set.py")
# generate_dqm_json_test_set_from_start_mid_end()
if args['input'] and args['directory']:
generate_dqm_json_test_set_from_sample_json(args['input'], args['directory'])
else:
logger.info("Must pass a -i input file and a -d output directory")
logger.info("ending generate_dqm_json_test_set.py")
| alliance-genome/agr_literature_service | agr_literature_service/lit_processing/tests/generate_dqm_json_test_set.py | generate_dqm_json_test_set.py | py | 6,909 | python | en | code | 1 | github-code | 13 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.