blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
281
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
57
| license_type
stringclasses 2
values | repo_name
stringlengths 6
116
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 313
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 18.2k
668M
⌀ | star_events_count
int64 0
102k
| fork_events_count
int64 0
38.2k
| gha_license_id
stringclasses 17
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 107
values | src_encoding
stringclasses 20
values | language
stringclasses 1
value | is_vendor
bool 2
classes | is_generated
bool 2
classes | length_bytes
int64 4
6.02M
| extension
stringclasses 78
values | content
stringlengths 2
6.02M
| authors
listlengths 1
1
| author
stringlengths 0
175
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1d539066706ca4f69d3130d49688deb922c477b3
|
98311c7b2b2257f14f0f4a0657363e893872798e
|
/project/src/python/practicum.py
|
e3f1dfcf9ef76f4b71a4dd1106d26832dc48802f
|
[
"MIT"
] |
permissive
|
aslupin/Yak-Ngaen-Project
|
fed9a264a863e1174c00ec8ad360f1c03422f393
|
c91b3cc83d2eda22b62fe877276bdd1a8a1b24fd
|
refs/heads/master
| 2022-01-28T02:44:39.385903
| 2019-05-09T13:36:04
| 2019-05-09T13:36:04
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 4,616
|
py
|
import usb
# RQ_SET_LED = 0
# RQ_SET_LED_VALUE = 1
# RQ_GET_SWITCH = 2
# RQ_GET_LIGHT = 3
RQ_GET_SOUND_PLAYER_I = 1
RQ_GET_SOUND_PLAYER_II = 2
####################################
def find_mcu_boards():
'''
Find all Practicum MCU boards attached to the machine, then return a list
of USB device handles for all the boards
>>> devices = find_mcu_boards()
>>> first_board = McuBoard(devices[0])
'''
boards = [dev for bus in usb.busses()
for dev in bus.devices
if (dev.idVendor,dev.idProduct) == (0x16c0,0x05dc)]
return boards
####################################
class McuBoard:
'''
Generic class for accessing Practicum MCU board via USB connection.
'''
################################
def __init__(self, dev):
self.device = dev
self.handle = dev.open()
################################
def usb_write(self, request, data=[], index=0, value=0):
'''
Send data output to the USB device (i.e., MCU board)
request: request number to appear as bRequest field on the USB device
index: 16-bit value to appear as wIndex field on the USB device
value: 16-bit value to appear as wValue field on the USB device
'''
reqType = usb.TYPE_VENDOR | usb.RECIP_DEVICE | usb.ENDPOINT_OUT
self.handle.controlMsg(
reqType, request, data, value=value, index=index)
################################
def usb_read(self, request, length=1, index=0, value=0):
'''
Request data input from the USB device (i.e., MCU board)
request: request number to appear as bRequest field on the USB device
length: number of bytes to read from the USB device
index: 16-bit value to appear as wIndex field on the USB device
value: 16-bit value to appear as wValue field on the USB device
If successful, the method returns a tuple of length specified
containing data returned from the MCU board.
'''
reqType = usb.TYPE_VENDOR | usb.RECIP_DEVICE | usb.ENDPOINT_IN
buf = self.handle.controlMsg(
reqType, request, length, value=value, index=index)
return buf
####################################
class PeriBoard:
################################
def __init__(self, mcu):
self.mcu = mcu
################################
# def get_sound_playeri(self):
# sound = self.mcu.usb_read(request=RQ_GET_SOUND_PLAYER_I, length=2)
# return sound[0]
# def get_sound_playerii(self):
# sound = self.mcu.usb_read(request=RQ_GET_SOUND_PLAYER_II, length=2)
# return sound[0]
def get_sound(self, player):
'''
Return the current reading of light sensor on peripheral board
'''
if(player == RQ_GET_SOUND_PLAYER_I):
sound = self.mcu.usb_read(request=RQ_GET_SOUND_PLAYER_I, length=2)
return sound[0]
# return sound[0]
elif(player == RQ_GET_SOUND_PLAYER_II):
sound = self.mcu.usb_read(request=RQ_GET_SOUND_PLAYER_II, length=2)
# return sound[0]
return sound[0]
# light[1] *= 256
# result = light[1] + light[0]
# return (sound[1] * 256 ) + sound[0]
# ################################
# def set_led(self, led_no, led_state):
# '''
# Set status of LED led_no on peripheral board to led_state
# (0 => off, 1 => on)
# '''
# self.mcu.usb_write(request=RQ_SET_LED, index=led_no, value=led_state)
# # return
# ################################
# def set_led_value(self, value):
# '''
# Display right 3 bits of value on peripheral board's LEDs
# '''
# self.mcu.usb_write(request=RQ_SET_LED_VALUE, value=value)
# # return
# ################################
# def get_switch(self):
# '''
# Return a boolean value indicating whether the switch on the peripheral
# board is currently pressed
# '''
# state = self.mcu.usb_read(request=RQ_GET_SWITCH, length=1)
# return state[0] == 1
# ################################
# def get_light(self):
# '''
# Return the current reading of light sensor on peripheral board
# '''
# light = self.mcu.usb_read(request=RQ_GET_LIGHT, length=2)
# # light[1] *= 256
# # result = light[1] + light[0]
# return ( light[1] * 256 ) + light[0]
|
[
"poon_arsene_lupin@hotmail.com"
] |
poon_arsene_lupin@hotmail.com
|
a6d6d50572836ba4614154dce36cf5e2c21f9c51
|
ca7aa979e7059467e158830b76673f5b77a0f5a3
|
/Python_codes/p02679/s613915096.py
|
fec86a56bc93ae2efcf62264eb570f7a448a4ed4
|
[] |
no_license
|
Aasthaengg/IBMdataset
|
7abb6cbcc4fb03ef5ca68ac64ba460c4a64f8901
|
f33f1c5c3b16d0ea8d1f5a7d479ad288bb3f48d8
|
refs/heads/main
| 2023-04-22T10:22:44.763102
| 2021-05-13T17:27:22
| 2021-05-13T17:27:22
| 367,112,348
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 667
|
py
|
import math, collections
N = int(input())
AB = [[int(_) for _ in input().split()] for _ in range(N)]
mod = 10**9 + 7
C = collections.Counter()
gcd = math.gcd
a0 = 0
for a, b in AB:
if a == b == 0:
a0 += 1
elif a == 0:
C[0, -1] += 1
else:
g = gcd(a, b)
a //= g
b //= g
if a < 0:
a *= -1
b *= -1
C[a, b] += 1
ans = 1
for a, b in C:
if C[b, -a]:
continue
elif C[-b, a]:
ans *= (pow(2, C[a, b], mod) + pow(2, C[-b, a], mod) - 1) % mod
ans %= mod
else:
ans *= pow(2, C[a, b], mod)
ans %= mod
ans += a0 - 1
ans %= mod
print(ans)
|
[
"66529651+Aastha2104@users.noreply.github.com"
] |
66529651+Aastha2104@users.noreply.github.com
|
0d5612bcf83e90343b35f237bfbb6536fe5a32fc
|
99dbc0388a1396d9d0f636ba6ad4e7ce6b646637
|
/app/frontend/views.py
|
4ae6ddaba7060c91bb981e1d735c5289f1895cb6
|
[] |
no_license
|
thefedoration/tracker-widgets
|
9469f27a023cc6c4f3cb1161f39452deb58ce282
|
47bd08030a8ced3b6ddf2c48cc41f8f0b705aa79
|
refs/heads/master
| 2021-06-22T04:44:47.565674
| 2017-05-15T13:32:27
| 2017-05-15T13:32:27
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 448
|
py
|
from django.shortcuts import render, redirect
# serves up frontend bundle
def index(request):
# if user is logged in, fire up the frontend app
if request.user.is_authenticated():
return render(request, 'frontend/index.html')
# otherwise not logged in, send them to login screen
path = request.path
if path[0] == '/':
path = path[1:]
return redirect('/accounts/login/?next=%s' % path)
|
[
"fedor@pymetrics.com"
] |
fedor@pymetrics.com
|
8bb434118d8a33e713f63403eaff1c739d22dc81
|
144c0ec2098c1a79f277729550262ab953a34aed
|
/logisticka.py
|
32ff6f38f03be4fd21104c731494fc99743dc6be
|
[] |
no_license
|
mkonjikovac/logistickaRegresija
|
ad7142d38824c70e992213ae8d4f6bb6ab2d74c7
|
37e58a40526a3679aeeaacbe49d5ad0e06d8881c
|
refs/heads/master
| 2022-03-07T03:30:00.813775
| 2019-11-08T13:57:02
| 2019-11-08T13:57:02
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 7,989
|
py
|
# logisticka
import pandas as pd
import numpy as np
import math
import matplotlib.pyplot as plt
import seaborn as sn
def standardization(x):
xs = np.copy(x)
for i in range(1, n):
xa = np.average(xs[:, i])
std = np.std(xs[:, i])
for j in range(m):
xs[j, i] = (xs[j, i] - xa) / std
return xs
def h(theta, x):
return 1 / (1 + math.exp(-theta.T.dot(x)))
# sarzni gradijentni spust, maksimizacija verodostojnosti
def gradient(x, y, theta):
gl = np.zeros((n, 1))
for i in range(m):
h_theta = h(theta, x[i].T)
for j in range(n):
gl[j] = gl[j] + (y[i] - h_theta) * x[i, j]
return gl
def gradient_loss(x, y):
alpha_l, alpha, alpha_h = 0.01, 0.02, 0.04
theta_l, J_l = gradient_descent_j(x, y, alpha_l, 1)
theta, J = gradient_descent_j(x, y, alpha, 1)
theta_h, J_h = gradient_descent_j(x, y, alpha_h, 1)
plt.plot(range(len(J_l)), J_l)
plt.plot(range(len(J)), J)
plt.plot(range(len(J_h)), J_h)
plt.legend(['alpha = 0.01', 'alpha = 0.02', 'alpha = 0.04'], loc='upper right')
plt.xlabel('iter')
plt.ylabel('J')
plt.show()
def gradient_descent_j(x, y, alpha=0.02, flag=0):
theta = np.zeros((n, 1))
bound = 2e-2
J = []
dl = gradient(x, y, theta)
while np.linalg.norm(dl) > bound:
theta = theta + alpha * dl
dl = gradient(x, y, theta)
if flag:
dJ = 0
for i in range(m):
ht = h(theta, xs[i].T)
dJ = dJ + y[i] * math.log(ht) + (1 - y[i]) * math.log(1 - ht)
J.append(-dJ)
return theta, J
def gradient_descent(x, y):
theta, J = gradient_descent_j(x, y)
return theta
# softmax
def delta(x, y, theta):
m = x.shape[0]
deltaJ = np.zeros((k, n))
for r in range(k - 1):
for i in range(m):
s = 0
for j in range(k):
s = s + math.exp(theta[j].dot(x[i].T))
deltaJ[r] = deltaJ[r] + ((y[i] == r) - math.exp(theta[r].dot(x[i].T)) / s) * x[i]
return deltaJ
def gauss(x, my, sigma):
sigma2 = math.pow(sigma, 2)
return 1 / math.sqrt(2 * math.pi * sigma2) * math.exp(-math.pow((x - my), 2) / 2 * sigma2)
def gnb(x, my1, sigma1, my0, sigma0):
invS1, invS0 = np.linalg.inv(sigma1), np.linalg.inv(sigma0)
return math.exp(0.5 * x.T.dot(invS1).dot(x) - my1.T.dot(invS1).dot(x) + 0.5 * my1.T.dot(invS1).dot(my1)
- 0.5 * x.T.dot(invS0).dot(x) + my0.T.dot(invS0).dot(x) - 0.5 * my0.T.dot(invS0).dot(my0))
def plot_conf(conf, reg, train):
if train == 1:
print(reg)
print('conf_train:')
else:
print('conf_test:')
print(conf)
df_cm = pd.DataFrame(conf, range(k), range(k))
hm = sn.heatmap(df_cm, annot=True, annot_kws={"size": 12})
bottom, top = hm.get_ylim()
hm.set_ylim(bottom + 0.5, top - 0.5)
plt.show()
df = pd.read_csv('multiclass_data.csv', header=None)
df.columns = ['x1', 'x2', 'x3', 'x4', 'x5', 'y']
df.insert(0, 'one', 1)
boundary_index = round(df.shape[0] * 0.8)
df = df.sample(frac=1)
y = df['y'].to_numpy()
x = df.iloc[:, 0:6].to_numpy()
m, n, k = x.shape[0], x.shape[1], len(np.unique(y)) # n ukljucuje kolonu sa 1
xs = standardization(x)
# logisticka regresija
y0, y1, y2 = np.copy(y), np.copy(y), np.copy(y)
y0[y0 >= 1], y0[y0 == 0], y0[y0 > 1] = 2, 1, 0
y1[y1 != 1] = 0
y2[y2 <= 1], y2[y2 == 2] = 0, 1
theta0, theta1, theta2 = gradient_descent(xs, y0), gradient_descent(xs, y1), gradient_descent(xs, y2)
conf_train, conf_test = np.zeros((k, k)), np.zeros((k, k))
y_guess = np.zeros((m, 1), int)
for i in range(m):
h0, h1, h2 = h(theta0, xs[i].T), h(theta1, xs[i].T), h(theta2, xs[i].T)
if h0 > h1 and h0 > h2:
y_guess[i] = 0
elif h1 > h0 and h1 > h2:
y_guess[i] = 1
else:
y_guess[i] = 2
if i < boundary_index:
conf_train[y[i], y_guess[i]] = conf_train[y[i], y_guess[i]] + 1
else:
conf_test[y[i], y_guess[i]] = conf_test[y[i], y_guess[i]] + 1
plot_conf(conf_train, 'LOGISTIČKA:', 1)
plot_conf(conf_test, 'LOGISTIČKA:', 0)
gradient_loss(xs, y1) # funkcija gubitka u zavisnosti od stope ucenja
# softmax
shuffle = np.arange(m)
row_num = [5, 10, 20]
row_size = row_num[1]
for row in row_num:
alpha, step, cnt = 0.02, 0, 1000
theta_row, J = np.zeros((k, n)), []
for i in range(cnt):
theta_row = theta_row + alpha * delta(xs[step:min(m, step + row)], y[step:min(m, step + row)], theta_row)
dJ = 0
for i in range(m):
y_guess = 0
for j in range(k):
y_guess = y_guess + math.exp(theta_row[j].dot(xs[i].T))
dJ = dJ + (theta_row[y[i]].dot(xs[i].T) - math.log(y_guess))
J.append(-dJ)
step = (step + row) % m
if step < row:
step = 0
np.random.shuffle(shuffle)
xs, y = xs[shuffle], y[shuffle]
if row == row_size:
theta = theta_row
plt.plot(range(len(J)), J)
plt.legend(['šarža = 5', 'šarža = 10', 'šarža = 20'], loc='upper right')
plt.xlabel('iter')
plt.ylabel('J')
plt.show()
conf_train, conf_test = np.zeros((k, k)), np.zeros((k, k))
for i in range(m):
phi, s = np.zeros((k, 1)), 0
for r in range(k):
phi[r] = math.exp(theta[r].dot(xs[i].T))
s = s + math.exp(theta[r].dot(xs[i].T))
phi = phi / s
phi_max_index = np.argmax(phi)
if i < boundary_index:
conf_train[y[i], phi_max_index] = conf_train[y[i], phi_max_index] + 1
else:
conf_test[y[i], phi_max_index] = conf_test[y[i], phi_max_index] + 1
plot_conf(conf_train, 'SOFTMAX:', 1)
plot_conf(conf_test, 'SOFTMAX:', 0)
# GDA - Gausovska diskriminantna analiza
xs = xs[:, 1:]
xs = np.c_[xs, y]
n = n - 1 # nema potrebe vise za kolonom sa 1
xs0, xs1, xs2 = xs[np.where(xs[:, n] == 0)], xs[np.where(xs[:, n] == 1)], xs[np.where(xs[:, n] == 2)]
xs0, xs1, xs2 = xs0[:, :-1], xs1[:, :-1], xs2[:, :-1]
x_sep = [xs0, xs1, xs2]
my, sigma = np.zeros((k, n)), np.zeros((k, n))
# racunanje my-matematicko ocekivanje, sigma-standardna devijansa
for i in range(k):
for j in range(n):
my[i, j] = np.mean(x_sep[i][:, j])
sigma[i, j] = np.std(x_sep[i][:, j])
conf_train, conf_test = np.zeros((k, k)), np.zeros((k, k))
for i in range(m):
gm, p = np.zeros((k, n)), np.zeros(k) # gauss matrix
total = 0
for l in range(k):
for j in range(n):
gm[l, j] = gauss(xs[i, j], my[l, j], sigma[l, j])
p[l] = np.prod(gm[l])
total = total + p[l]
p = p / total
if i < boundary_index:
conf_train[y[i], np.argmax(p)] = conf_train[y[i], np.argmax(p)] + 1
else:
conf_test[y[i], np.argmax(p)] = conf_test[y[i], np.argmax(p)] + 1
plot_conf(conf_train, 'GDA:', 1)
plot_conf(conf_test, 'GDA:', 0)
# GNB - Naivni Bayes
MY0 = np.ones((5, xs0.shape[0]))
MY1 = np.ones((5, xs1.shape[0]))
MY2 = np.ones((5, xs2.shape[0]))
for j in range(n):
MY0[j] = my[0, j]
MY1[j] = my[1, j]
MY2[j] = my[2, j]
print(xs0, my)
SIGMA0 = 1 / (xs0.shape[0] - 1) * (xs0.T - MY0).dot((xs0.T - MY0).T)
SIGMA1 = 1 / (xs1.shape[0] - 1) * (xs1.T - MY1).dot((xs1.T - MY1).T)
SIGMA2 = 1 / (xs2.shape[0] - 1) * (xs2.T - MY2).dot((xs2.T - MY2).T)
conf_train, conf_test = np.zeros((k, k)), np.zeros((k, k))
xs = xs[:, :-1] # izbacivanje kolone sa 1
for i in range(m):
p = np.zeros(k)
p[0] = 1 / (1 + gnb(xs[i].T, my[1].T, SIGMA1, my[0].T, SIGMA0) + gnb(xs[i].T, my[2].T, SIGMA2, my[0].T, SIGMA0))
p[1] = 1 / (1 + gnb(xs[i].T, my[0].T, SIGMA0, my[1].T, SIGMA1) + gnb(xs[i].T, my[2].T, SIGMA2, my[1].T, SIGMA1))
p[2] = 1 / (1 + gnb(xs[i].T, my[0].T, SIGMA0, my[2].T, SIGMA2) + gnb(xs[i].T, my[1].T, SIGMA1, my[2].T, SIGMA2))
if i < boundary_index:
conf_train[y[i], np.argmax(p)] = conf_train[y[i], np.argmax(p)] + 1
else:
conf_test[y[i], np.argmax(p)] = conf_test[y[i], np.argmax(p)] + 1
plot_conf(conf_train, 'GNB:', 1)
plot_conf(conf_test, 'GNB:', 0)
|
[
"mkonjikovac12@gmail.com"
] |
mkonjikovac12@gmail.com
|
c77f59e3b90ce19c50bd0a77c092b148f74acab0
|
9d30a8c8620640b5e18c6aa5aa4bca6c01a60182
|
/Code/utils/inference1.py
|
13954a3246b767b1a5ad098f07456a4cfcff6c9b
|
[
"MIT"
] |
permissive
|
zhouzhiyuan1/RADANet
|
00ed5e2380007b53f918788d9e44fcec26c9ce21
|
f0db67e5b16b5b566efd40402b7b2b2a5342d5ad
|
refs/heads/main
| 2023-08-31T18:50:05.560253
| 2021-11-02T11:37:59
| 2021-11-02T11:37:59
| 423,765,661
| 4
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 6,803
|
py
|
#!/usr/bin/env python3
# coding: utf-8
__author__ = 'cleardusk'
import numpy as np
from math import sqrt
import scipy.io as sio
import matplotlib.pyplot as plt
from .ddfa import reconstruct_vertex
def get_suffix(filename):
"""a.jpg -> jpg"""
pos = filename.rfind('.')
if pos == -1:
return ''
return filename[pos:]
def crop_img(img, roi_box):
h, w = img.shape[:2]
sx, sy, ex, ey = [int(round(_)) for _ in roi_box]
dh, dw = ey - sy, ex - sx
if len(img.shape) == 3:
res = np.zeros((dh, dw, 3), dtype=np.uint8)
else:
res = np.zeros((dh, dw), dtype=np.uint8)
if sx < 0:
sx, dsx = 0, -sx
else:
dsx = 0
if ex > w:
ex, dex = w, dw - (ex - w)
else:
dex = dw
if sy < 0:
sy, dsy = 0, -sy
else:
dsy = 0
if ey > h:
ey, dey = h, dh - (ey - h)
else:
dey = dh
res[dsy:dey, dsx:dex] = img[sy:ey, sx:ex]
return res
def calc_hypotenuse(pts):
bbox = [min(pts[0, :]), min(pts[1, :]), max(pts[0, :]), max(pts[1, :])]
center = [(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2]
radius = max(bbox[2] - bbox[0], bbox[3] - bbox[1]) / 2
bbox = [center[0] - radius, center[1] - radius, center[0] + radius, center[1] + radius]
llength = sqrt((bbox[2] - bbox[0]) ** 2 + (bbox[3] - bbox[1]) ** 2)
return llength / 3
def parse_roi_box_from_landmark(pts):
"""calc roi box from landmark"""
bbox = [min(pts[0, :]), min(pts[1, :]), max(pts[0, :]), max(pts[1, :])]
center = [(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2]
radius = max(bbox[2] - bbox[0], bbox[3] - bbox[1]) / 2
bbox = [center[0] - radius, center[1] - radius, center[0] + radius, center[1] + radius]
llength = sqrt((bbox[2] - bbox[0]) ** 2 + (bbox[3] - bbox[1]) ** 2)
center_x = (bbox[2] + bbox[0]) / 2
center_y = (bbox[3] + bbox[1]) / 2
roi_box = [0] * 4
roi_box[0] = center_x - llength / 2
roi_box[1] = center_y - llength / 2
roi_box[2] = roi_box[0] + llength
roi_box[3] = roi_box[1] + llength
return roi_box
def parse_roi_box_from_bbox(bbox):
left, top, right, bottom = bbox
old_size = (right - left + bottom - top) / 2
center_x = right - (right - left) / 2.0
center_y = bottom - (bottom - top) / 2.0 + old_size * 0.14
size = int(old_size * 1.58)
roi_box = [0] * 4
roi_box[0] = center_x - size / 2
roi_box[1] = center_y - size / 2
roi_box[2] = roi_box[0] + size
roi_box[3] = roi_box[1] + size
return roi_box
def dump_to_ply(vertex, tri, wfp):
header = """ply
format ascii 1.0
element vertex {}
property float x
property float y
property float z
element face {}
property list uchar int vertex_indices
end_header"""
n_vertex = vertex.shape[1]
n_face = tri.shape[1]
header = header.format(n_vertex, n_face)
with open(wfp, 'w') as f:
f.write(header + '\n')
for i in range(n_vertex):
x, y, z = vertex[:, i]
f.write('{:.4f} {:.4f} {:.4f}\n'.format(x, y, z))
for i in range(n_face):
idx1, idx2, idx3 = tri[:, i]
f.write('3 {} {} {}\n'.format(idx1 - 1, idx2 - 1, idx3 - 1))
print('Dump tp {}'.format(wfp))
def dump_vertex(vertex, wfp):
sio.savemat(wfp, {'vertex': vertex})
print('Dump to {}'.format(wfp))
def _predict_vertices(param, roi_bbox, dense, transform=True):
vertex = reconstruct_vertex(param, dense=dense)
sx, sy, ex, ey = roi_bbox
scale_x = (ex - sx) / 120
scale_y = (ey - sy) / 120
vertex[0, :] = vertex[0, :] * scale_x + sx
vertex[1, :] = vertex[1, :] * scale_y + sy
s = (scale_x + scale_y) / 2
vertex[2, :] *= s
return vertex
def predict_68pts(param, roi_box):
return _predict_vertices(param, roi_box, dense=False)
def predict_dense(param, roi_box):
return _predict_vertices(param, roi_box, dense=True)
def draw_landmarks(img, pts, style='fancy', wfp=None, show_flg=False, **kwargs):
"""Draw landmarks using matplotlib"""
height, width = img.shape[:2]
plt.figure(figsize=(12, height / width * 12))
plt.imshow(img[:, :, ::-1])
plt.subplots_adjust(left=0, right=1, top=1, bottom=0)
plt.axis('off')
if not type(pts) in [tuple, list]:
pts = [pts]
for i in range(len(pts)):
if style == 'simple':
plt.plot(pts[i][0, :], pts[i][1, :], 'o', markersize=4, color='g')
elif style == 'fancy':
alpha = 0.8
markersize = 10
lw = 1.5
color = kwargs.get('color', 'r')
markeredgecolor = kwargs.get('markeredgecolor', 'red')
nums = [0, 17, 22, 27, 31, 36, 42, 48, 60, 68]
# close eyes and mouths
plot_close = lambda i1, i2: plt.plot([pts[i][0, i1], pts[i][0, i2]], [pts[i][1, i1], pts[i][1, i2]],
color=color, lw=lw, alpha=alpha - 0.1)
plot_close(41, 36)
plot_close(47, 42)
plot_close(59, 48)
plot_close(67, 60)
for ind in range(len(nums) - 1):
l, r = nums[ind], nums[ind + 1]
plt.plot(pts[i][0, l:r], pts[i][1, l:r], color=color, lw=lw, alpha=alpha - 0.1)
plt.plot(pts[i][0, l:r], pts[i][1, l:r], marker='o', linestyle='None', markersize=markersize,
color=color,
markeredgecolor=markeredgecolor, alpha=alpha)
if wfp is not None:
plt.savefig(wfp, dpi=200)
print('Save visualization result to {}'.format(wfp))
if show_flg:
plt.show()
def get_colors(image, vertices):
[h, w, _] = image.shape
vertices[0, :] = np.minimum(np.maximum(vertices[0, :], 0), w - 1) # x
vertices[1, :] = np.minimum(np.maximum(vertices[1, :], 0), h - 1) # y
ind = np.round(vertices).astype(np.int32)
colors = image[ind[1, :], ind[0, :], :] # n x 3
return colors
def write_obj_with_colors(obj_name, vertices, triangles, colors):
triangles = triangles.copy() # meshlab start with 1
if obj_name.split('.')[-1] != 'obj':
obj_name = obj_name + '.obj'
# write obj
with open(obj_name, 'w') as f:
# write vertices & colors
for i in range(vertices.shape[1]):
s = 'v {:.4f} {:.4f} {:.4f} {} {} {}\n'.format(vertices[1, i], vertices[0, i], vertices[2, i], colors[i, 2],
colors[i, 1], colors[i, 0])
f.write(s)
# write f: ver ind/ uv ind
for i in range(triangles.shape[1]):
s = 'f {} {} {}\n'.format(triangles[0, i], triangles[1, i], triangles[2, i])
f.write(s)
def main():
pass
if __name__ == '__main__':
main()
|
[
"zy980203123@163.com"
] |
zy980203123@163.com
|
8f4ca0a46c8c2f2b477ecfa59a36f08c988916bb
|
c220ac95ee13465d549b721700fe482ed490a2ac
|
/itty/__init__.py
|
6363a9929b9908c6a4220c4143cefa060e4c3310
|
[
"BSD-3-Clause"
] |
permissive
|
ruthenium/itty
|
66587621e1f36fc66202bf3a24509438d04b48d1
|
5d4219909c88d21af8b5548d366888accace68f6
|
refs/heads/master
| 2021-01-18T08:46:24.315865
| 2011-08-17T03:10:47
| 2011-08-17T03:10:47
| 2,151,905
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,591
|
py
|
from .base import (HTTP_MAPPINGS,
Callback as _Callback,
Error as _Error,
Request,
Response,
static_file,
EnvironmentError,
Forbidden,
NotFound,
AppError,
Redirect,
App,
run_app)
APP_METHODS = { }
class Callback(_Callback):
def __get__(self, instance, owner):
if instance is None:
return self
return self._func
@classmethod
def decorator(cls, pattern):
def wrapper(func):
res = cls(pattern, func)
APP_METHODS[func.func_name] = res
return func
return wrapper
class GetCallback(Callback):
method = 'GET'
get = GetCallback.decorator
class PostCallback(Callback):
method = 'POST'
post = PostCallback.decorator
class PutCallback(Callback):
method = 'PUT'
put = PutCallback.decorator
class DeleteCallback(Callback):
method = 'DELETE'
delete = DeleteCallback.decorator
class Error(_Error):
def __get__(self, instance, owner):
if instance is None:
return self
return self._func
@classmethod
def decorator(cls, status):
def wrapper(func):
res = cls(func, status)
APP_METHODS[func.func_name] = res
return func
return wrapper
error = Error.decorator
def run_itty(host='localhost', port=8080, adapter='wsgiref'):
return run_app(type('IttyMainApplication',
(base.App, ),
APP_METHODS),
host, port, adapter)
|
[
"bubucektop@gmail.com"
] |
bubucektop@gmail.com
|
ed8716a26481360b16a530a1bada6c0c07139b62
|
b7dc309c2870431ea90710daf829fd364cf2d578
|
/牛客聪明编辑.py
|
aa96c3286b912ed9c91a11d94b2d70ef75d0fcfe
|
[] |
no_license
|
KaGen1999/Leetcode-by-Python
|
7d65e7890279a2910aae297929a33f52001ad287
|
ef10b1aa9b7060f949dcd392d62ddaba5fbcdbb8
|
refs/heads/master
| 2021-05-20T21:02:44.904731
| 2020-09-13T16:23:50
| 2020-09-13T16:23:50
| 252,415,887
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 523
|
py
|
n = int(input())
for i in range(n):
s = input()
b = ''
new_s = ''
count = 1
state = 0
for each in s:
if each != b:
if state == 1:
new_s = new_s + each
state = 2
elif state == 2:
new_s = new_s + each
state = 0
else:
new_s = new_s + each
else:
if state == 0:
state = 1
new_s = new_s + each
b = each
print(new_s)
|
[
"1032336124@qq.com"
] |
1032336124@qq.com
|
86c976754fbba24178415faffcb3f295036aef07
|
b4e9c9927f4839dcf2e03b26d51cc08f1ad5c362
|
/el7toel8/acme/actors/acmestoragemigrator/actor.py
|
9a312a6f0840ebb57cf8e6aa7e8d83031aa43db0
|
[] |
no_license
|
shaded-enmity/isv-repositories
|
cbde5baacf49029a4122541987ec30f634c9c85f
|
8f52c44cc6c0d663c5ceef2eea92aea759d20899
|
refs/heads/master
| 2022-06-21T00:11:25.417412
| 2020-05-06T15:05:18
| 2020-05-06T15:05:18
| 261,727,873
| 0
| 0
| null | 2020-05-06T15:05:19
| 2020-05-06T10:39:07
| null |
UTF-8
|
Python
| false
| false
| 1,380
|
py
|
from leapp.actors import Actor
from leapp.models import Report, AcmeStorageInfo
from leapp.tags import FirstBootPhaseTag, IPUWorkflowTag
from leapp import reporting
import os
class AcmeStorageMigrator(Actor):
"""
Migrate ACME Storage device from old location to the new one
"""
name = 'acme_storage_migrator'
consumes = (AcmeStorageInfo,)
produces = (Report,)
tags = (FirstBootPhaseTag, IPUWorkflowTag)
def process(self):
acme_storage_info = next(self.consume(AcmeStorageInfo),None)
# Rename the device
if acme_storage_info.has_device and acme_storage_info.has_kernel_module:
os.rename('/dev/acme0', '/dev/acme')
# Emit a report message informing the system administrator that the device
# path has been changed
reporting.create_report([
reporting.Title('ACME Storage device path migrated'),
reporting.Summary('ACME Storage device path has been changed to /dev/acme'),
reporting.Severity(reporting.Severity.INFO),
reporting.Tags([reporting.Tags.OS_FACTS]),
reporting.RelatedResource('device', '/dev/acme'),
reporting.ExternalLink(
url='https://acme.corp/storage-rhel',
title='ACME Storage on RHEL'
)
])
|
[
"noreply@github.com"
] |
noreply@github.com
|
9a0f0433298aaf2b0b0aa33f5a64b0273f639e93
|
24d8cf871b092b2d60fc85d5320e1bc761a7cbe2
|
/eXe/rev2669-2722/left-trunk-2722/twisted/internet/iocpreactor/udp.py
|
3bf7a5bba392de8252482bdf0e1ba0600cfe27fa
|
[
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
joliebig/featurehouse_fstmerge_examples
|
af1b963537839d13e834f829cf51f8ad5e6ffe76
|
1a99c1788f0eb9f1e5d8c2ced3892d00cd9449ad
|
refs/heads/master
| 2016-09-05T10:24:50.974902
| 2013-03-28T16:28:47
| 2013-03-28T16:28:47
| 9,080,611
| 3
| 2
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 6,644
|
py
|
import socket
from twisted.internet import interfaces, defer, error, protocol, address
from twisted.internet.abstract import isIPAddress
from twisted.persisted import styles
from twisted.python import log, failure, reflect
from ops import ReadFileOp, WriteFileOp, WSARecvFromOp, WSASendToOp
from util import StateEventMachineType
from zope.interface import implements
ERROR_PORT_UNREACHABLE = 1234
class Port(log.Logger, styles.Ephemeral, object):
__metaclass__ = StateEventMachineType
implements(interfaces.IUDPTransport)
events = ["startListening", "stopListening", "write", "readDone", "readErr", "writeDone", "writeErr", "connect"]
sockinfo = (socket.AF_INET, socket.SOCK_DGRAM, 0)
read_op_class = WSARecvFromOp
write_op_class = WSASendToOp
reading = False
_realPortNumber = None
disconnected = property(lambda self: self.state == "disconnected")
def __init__(self, bindAddress, proto, maxPacketSize=8192):
assert isinstance(proto, protocol.DatagramProtocol)
self.state = "disconnected"
from twisted.internet import reactor
self.bindAddress = bindAddress
self._connectedAddr = None
self.protocol = proto
self.maxPacketSize = maxPacketSize
self.logstr = reflect.qual(self.protocol.__class__) + " (UDP)"
self.read_op = self.read_op_class(self)
self.readbuf = reactor.AllocateReadBuffer(maxPacketSize)
self.reactor = reactor
def __repr__(self):
if self._realPortNumber is not None:
return "<%s on %s>" % (self.protocol.__class__, self._realPortNumber)
else:
return "<%s not connected>" % (self.protocol.__class__,)
def handle_listening_connect(self, host, port):
if not isIPAddress(host):
raise ValueError, "please pass only IP addresses, not domain names"
self.state = "connecting"
return defer.maybeDeferred(self._connectDone, host, port)
def handle_connecting_connect(self, host, port):
raise RuntimeError, "already connected, reconnecting is not currently supported (talk to itamar if you want this)"
handle_connected_connect = handle_connecting_connect
def _connectDone(self, host, port):
self._connectedAddr = (host, port)
self.state = "connected"
self.socket.connect((host, port))
return self._connectedAddr
def handle_disconnected_startListening(self):
self._bindSocket()
host, port = self.bindAddress
if isIPAddress(host):
return defer.maybeDeferred(self._connectSocket, host)
else:
d = self.reactor.resolve(host)
d.addCallback(self._connectSocket)
return d
def _bindSocket(self):
try:
skt = socket.socket(*self.sockinfo)
skt.bind(self.bindAddress)
except socket.error, le:
raise error.CannotListenError, (None, None, le)
self._realPortNumber = skt.getsockname()[1]
log.msg("%s starting on %s"%(self.protocol.__class__, self._realPortNumber))
self.socket = skt
def _connectSocket(self, host):
self.bindAddress = (host, self.bindAddress[1])
self.protocol.makeConnection(self)
self.startReading()
self.state = "listening"
def startReading(self):
self.reading = True
try:
self.read_op.initiateOp(self.socket.fileno(), self.readbuf)
except WindowsError, we:
log.msg("initiating read failed with args %s" % (we,))
def stopReading(self):
self.reading = False
def handle_listening_readDone(self, bytes, addr = None):
if addr:
self.protocol.datagramReceived(self.readbuf[:bytes], addr)
else:
self.protocol.datagramReceived(self.readbuf[:bytes])
if self.reading:
self.startReading()
handle_connecting_readDone = handle_listening_readDone
handle_connected_readDone = handle_listening_readDone
def handle_listening_readErr(self, ret, bytes):
log.msg("read failed with err %s" % (ret,))
if ret == 1234: # ERROR_PORT_UNREACHABLE
self.protocol.connectionRefused()
if self.reading:
self.startReading()
handle_connecting_readErr = handle_listening_readErr
handle_connected_readErr = handle_listening_readErr
def handle_disconnected_readErr(self, ret, bytes):
pass # no kicking the dead horse
def handle_disconnected_readDone(self, bytes, addr = None):
pass # no kicking the dead horse
def handle_listening_write(self, data, addr):
self.performWrite(data, addr)
def handle_connected_write(self, data, addr = None):
assert addr in (None, self._connectedAddr)
self.performWrite(data, addr)
def performWrite(self, data, addr = None):
self.writing = True
try:
write_op = self.write_op_class(self)
if not addr:
addr = self._connectedAddr
write_op.initiateOp(self.socket.fileno(), data, addr)
except WindowsError, we:
log.msg("initiating write failed with args %s" % (we,))
def handle_listening_writeDone(self, bytes):
log.msg("write success with bytes %s" % (bytes,))
handle_connecting_writeDone = handle_listening_writeDone
handle_connected_writeDone = handle_listening_writeDone
def handle_listening_writeErr(self, ret, bytes):
log.msg("write failed with err %s" % (ret,))
if ret == ERROR_PORT_UNREACHABLE:
self.protocol.connectionRefused()
handle_connecting_writeErr = handle_listening_writeErr
handle_connected_writeErr = handle_listening_writeErr
def handle_disconnected_writeErr(self, ret, bytes):
pass # no kicking the dead horse
def handle_disconnected_writeDone(self, bytes):
pass # no kicking the dead horse
def writeSequence(self, seq, addr):
self.write("".join(seq), addr)
def handle_listening_stopListening(self):
self.stopReading()
self.connectionLost()
handle_connecting_stopListening = handle_listening_stopListening
handle_connected_stopListening = handle_listening_stopListening
def connectionLost(self, reason=None):
log.msg('(Port %s Closed)' % self._realPortNumber)
self._realPortNumber = None
self.protocol.doStop()
self.socket.close()
del self.socket
self.state = "disconnected"
def logPrefix(self):
return self.logstr
def getHost(self):
return address.IPv4Address('UDP', *(self.socket.getsockname() + ('INET_UDP',)))
|
[
"joliebig@fim.uni-passau.de"
] |
joliebig@fim.uni-passau.de
|
4ec4d34dab5f7644e361280ca777fc5fb41fdb92
|
782efe22f3251a701796e68e82fbce27c2ce2d8f
|
/Discussion/migrations/0042_auto_20200515_1217.py
|
0b9097e87756d35dd0f7ac9dcbb9599753393a94
|
[] |
no_license
|
Escalation99/Workev
|
ffc10e64776bf90d206a4a7a8ef3655c22f0223b
|
c2312c54c152b823e991ef5955b5d2df7ff58222
|
refs/heads/main
| 2023-03-13T05:36:54.386719
| 2021-03-06T10:27:06
| 2021-03-06T10:27:06
| 310,613,595
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 586
|
py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.11.29 on 2020-05-15 05:17
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('Discussion', '0041_auto_20200513_1402'),
]
operations = [
migrations.AlterField(
model_name='post',
name='category',
field=models.CharField(choices=[('Announcement', 'Announcement'), ('Other', 'Other'), ('Meeting', 'Meeting'), ('Jobdesc', 'Jobdesc')], default='Jobdesc', max_length=50),
),
]
|
[
"raytommy1234@gmail.com"
] |
raytommy1234@gmail.com
|
a34d40955607245d7cd5152f6173d3ba1d85f7cd
|
0e867a76d0263d40f78a643d466ebfc10b0ac4f0
|
/activities/nmz/nmz_setup.py
|
bd9401b72f5fcf89e245c9ae516efefd4d687f25
|
[
"MIT"
] |
permissive
|
anordin95/replay_mouse
|
b49d29b0ce0c72ed347e178b982c96b93af678b9
|
569abe771cac3b639317b1ca97c98b0c486a4714
|
refs/heads/master
| 2022-07-04T18:28:57.299865
| 2020-05-16T14:33:41
| 2020-05-16T14:33:41
| 259,782,742
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,379
|
py
|
from pathlib import Path
from primitives.potion_tracker import setup_potions_tracker
from primitives.get_quick_pray_location import get_quick_pray_location
from primitives.record import record
PICKLE_FOLDER = Path('pickled_objects')
PRAYER_POTS_FILENAME = PICKLE_FOLDER / 'prayer_pots.pkl'
RANGE_POTS_FILENAME = PICKLE_FOLDER / 'ranging_pots.pkl'
ABSORPTION_POTS_FILENAME = PICKLE_FOLDER / 'absorption_pots.pkl'
QUICK_PRAY_LOC_FILE = PICKLE_FOLDER / 'quick_pray_loc.pkl'
ROCK_CAKE_ACTION_LIST_FILE = PICKLE_FOLDER / 'rock_cake_action_list.pkl'
import logging
log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
log_level = logging.INFO
logging.basicConfig(level=log_level, format=log_format)
# for use with prayer pots
# def setup():
# setup_potions_tracker(filename=RANGE_POTS_FILENAME, potion_type='range')
# setup_potions_tracker(filename=PRAYER_POTS_FILENAME, potion_type='prayer')
# for use with absorption pots
logger = logging.getLogger('__name__')
def setup():
logger.info("Record guzzling a rock cake. When done, press esc.")
record(use_potions=False, filename=ROCK_CAKE_ACTION_LIST_FILE)
get_quick_pray_location(filename=QUICK_PRAY_LOC_FILE)
setup_potions_tracker(filename=RANGE_POTS_FILENAME, potion_type='range')
setup_potions_tracker(filename=ABSORPTION_POTS_FILENAME, potion_type='absorption')
if __name__ == '__main__':
setup()
|
[
"anordin@butterflynetinc.com"
] |
anordin@butterflynetinc.com
|
ee4ec4d60d0e2809301b28150cd9934a01d330c6
|
bffa0938e70732e992a5d5dc5fb30559fd0ceb7b
|
/Zadanie9/main.py
|
7be093c8309014ad5a6351c1465cc96dc7c501d2
|
[] |
no_license
|
LenovoDobrynin/zadanie9.py
|
281d5d4850dfb374a273701f588a323f0c524b48
|
54d75ff2645d447b6f31a9327feaadb1fbf0f21e
|
refs/heads/master
| 2023-08-28T00:35:01.091714
| 2021-10-14T20:38:18
| 2021-10-14T20:38:18
| 417,274,906
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,098
|
py
|
a1 = float(input('Введите число а1: '))
a2 = float(input('Введите число a2: '))
a3 = float(input('Введите число a3: '))
b1 = float(input('Введите число b1: '))
b2 = float(input('Введите число b2: '))
b3 = float(input('Введите число b3: '))
c1 = float(input('Введите число c1: '))
c2 = float(input('Введите число c2: '))
c3 = float(input('Введите число c3: '))
d1 = float(input('Введите число d1: '))
d2 = float(input('Введите число d2: '))
d3 = float(input('Введите число d3: '))
delta = a1*b2*c3+b1*c2*a3+c1*a2*b3-c1*b2*a3-a1*c2*b3-b1*a2*c3
if delta == 0:
print('Главный определитель системы равен нулю')
else:
delta1 = d1*b2*c3+b1*c2*d3+c1*d2*b3-c1*b2*d3-d1*c2*b3-b1*d2*c3
delta2 = a1*d2*c3+d1*c2*a3+c1*a2*d3-c1*d2*a3-a1*c2*d3-d1*a2*c3
delta3 = a1*b2*d3+b1*d2*a3+d1*a2*b3-d1*b2*a3-a1*d2*b3-b1*a2*d3
x = delta1/delta
y = delta2/delta
z = delta3/delta
print(x,y,z)
|
[
"noreply@github.com"
] |
noreply@github.com
|
428efb464a06b53657e381f76bf9e07b3382ba40
|
6fddeb3fb4be07e4c1063a0c49d1f25606fa78c2
|
/WebProject1/primeiroPrograma.py
|
a6f6ef9bb480d32170e34644221afe8968666b18
|
[] |
no_license
|
RuanNunes/Logica-de-Programa-o-com-Python
|
d3f663881c2e51888608d9cf5f51c0956cdd10dd
|
18b2b41e485d3e58ce2d5cf923e389cd146d7f18
|
refs/heads/master
| 2020-03-17T16:27:40.661667
| 2018-06-03T20:06:29
| 2018-06-03T20:06:29
| 133,749,488
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 223
|
py
|
class primeiroPrograma(object):
print('Meu Primeiro Programa')
num1 = int(input('Digite Um Numero:'))
num2 = int(input('Digite o Segundo Numero:'))
print('A soma dos numeros é:', num1 + num2)
pass
|
[
"ruan.nunes@el.com.br"
] |
ruan.nunes@el.com.br
|
d008e616c943f18e5f7f5c090bc112e713db99cf
|
c4b7b5a9c56a9b6394a14704d2faf76754175473
|
/rooms/templatetags/is_booked.py
|
da615b5d82465d9cb146e16beb8eeaefaf53bbc4
|
[] |
no_license
|
seungjinhan/airbnb_clone_django
|
71a15e5242bad28fd96d5f47652a049a77f12f61
|
4c38780746409ea1ed9b4f5b02abca60326752c2
|
refs/heads/master
| 2022-12-02T15:14:39.341441
| 2020-08-23T13:50:42
| 2020-08-23T13:50:42
| 280,878,495
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 554
|
py
|
import datetime
from django import template
from reservations import models as reservation_model
register = template.Library()
@register.simple_tag
def is_booked(room, day):
if day.number == 0:
return False
try:
date = datetime.datetime(
year=day.year, month=day.month, day=day.number)
reservation_model.BookedDay.objects.get(
day=date, reservation__room=room)
print(date)
print(room)
return True
except reservation_model.BookedDay.DoesNotExist:
return False
|
[
"hanblues@gmail.com"
] |
hanblues@gmail.com
|
5dcf1531f3266b5a1c867bd6a62ba36a36b2bbc2
|
7b08ceb8c901a09e41d4a67804e2adf94142cb17
|
/description2process/__init__.py
|
2f99a8019b7c0dace78658a646cc5d28bfb7d318
|
[] |
no_license
|
simrit1/Description2Process
|
1e7cfcc4dc6bb762d69f27bbe1eedd4e0cef6a38
|
223372f3588f7ac67537eae3012667951b5543e0
|
refs/heads/master
| 2023-08-25T23:12:50.838804
| 2019-05-16T16:51:51
| 2019-05-16T16:51:51
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 6,370
|
py
|
import tensorflow as tf
# We need to enable eager execution for inference at the end of this notebook.
tfe = tf.contrib.eager
tfe.enable_eager_execution()
TFVERSION='1.13'
import os
os.environ['TFVERSION'] = TFVERSION
# Import library
from description2process import data_generation
from description2process import contraction_expansion
from description2process import coreference_resolution
from description2process import clause_extraction
from description2process import activity_recognition
from description2process import activity_extraction
from description2process import structured_description
from description2process import xml_model
from description2process import visualization
from description2process import evaluation
# Returns the visualisation of a process description
# INPUT: process description in string format
def description2model(description, png = False):
# step1 : contraction expansion
description = contraction_expansion.expand_contractions(description)
print("Step 1/8 DONE: contraction expansion")
# step2 : coreference resolution
description = coreference_resolution.resolve_coreferences(description)
print("Step 2/8 DONE: coreference resolution")
# step3 : clause extraction
subsentences = clause_extraction.get_clauses(description)
print("Step 3/8 DONE: extracted clauses ")
# step4: label clauses
labeled_clauses_df = activity_recognition.contains_activity_list(subsentences)
print("Step 4/8 DONE: labeled clauses ")
# step5: activity extraction
df_activities = activity_extraction.get_activity_df(labeled_clauses_df)
print("Step 5/8 DONE: extracted activities ")
# step6: get a structured_descriptions
str_descr = structured_description.get_structured_description(description, df_activities)
print("Step 6/8 DONE: semi-structured descriptions")
# step7: get XML format of models
xml = xml_model.structured2xml(str_descr)
print("Step 7/8 DONE: model in XML")
# step8: Visualize the model in xml
model = visualization.xml2model(xml, png)
print("Step 8/8 DONE: Visualize model")
return model
# Returns the xml format of the process description
# INPUT: process description in string format
def description2xml(description):
# step1 : contraction expansion
description = contraction_expansion.expand_contractions(description)
print("Step 1/7 DONE: contraction expansion")
# step2 : coreference resolution
description = coreference_resolution.resolve_coreferences(description)
print("Step 2/7 DONE: coreference resolution")
# step3 : clause extraction
subsentences = clause_extraction.get_clauses(description)
print("Step 3/7 DONE: extracted clauses ")
# step4: label clauses
labeled_clauses_df = activity_recognition.contains_activity_list(subsentences)
print("Step 4/7 DONE: labeled clauses ")
# step5: activity extraction
df_activities = activity_extraction.get_activity_df(labeled_clauses_df)
print("Step 5/7 DONE: extracted activities ")
# step6: get a structured_descriptions
str_descr = structured_description.get_structured_description(description, df_activities)
print("Step 6/7 DONE: semi-structured descriptions")
# step7: get XML format of models
xml = xml_model.structured2xml(str_descr)
print("Step 7/7 DONE: model in XML")
return xml
# returns the structured description of raw process descriptions
# Input: pandas dataframe of process descriptions
def description2structured_df(description_df):
# step1 : contraction expansion
description_df = contraction_expansion.expand_contractions_df(description_df)
print("Step 1/6 DONE: contraction expansion")
# step2 : coreference resolution
description_df = coreference_resolution.resolve_coreferences_df(description_df)
print("Step 2/6 DONE: coreference resolution")
# step3 : clause extraction
description_df = clause_extraction.get_clauses_df(description_df)
print("Step 3/6 DONE: extracted clauses ")
# step4: label clauses
labeled_clauses = activity_recognition.contains_activity_df(description_df)
print("Step 4/6 DONE: labeled clauses ")
# step5: activity extraction
df_activities = activity_extraction.get_activity_df(labeled_clauses)
print("Step 5/6 DONE: extracted activities ")
# step6: get a structured_descriptions
str_descr = structured_description.get_structured_description_df(description_df, df_activities)
print("Step 6/6 DONE: returned structured descriptions")
return str_descr
# return the descripition after contraction expansion and coreference resolution.
# This type of description can be seen as a cleaned version of the original one.
# Input: pandas dataframe of process descriptions
def description2referenceresolved_df(description_df):
# step1 : contraction expansion
description_df = contraction_expansion.expand_contractions_df(description_df)
# step2 : coreference resolution
description_df = coreference_resolution.resolve_coreferences_df(description_df)
return description_df
# Return the description with a list containing the description's extracted clauses
# Input: pandas dataframe of process description
def description2clauses_df(description_df):
# step1 : contraction expansion
description_df = contraction_expansion.expand_contractions_df(description_df)
# step2 : coreference resolution
description_df = coreference_resolution.resolve_coreferences_df(description_df)
# step3 : clause extraction
description_df = clause_extraction.get_clauses_df(description_df)
return description_df
# Return the description with a list containg the descriptions's extracted clauses
# + an extra dataframe with all its labeled clauses
# Input: pandas dataframe of process descriptions
def description2labeledclauses_df(description_df):
# step1 : contraction expansion
description_df = contraction_expansion.expand_contractions_df(description_df)
# step2 : coreference resolution
description_df = coreference_resolution.resolve_coreferences_df(description_df)
# step3 : clause extraction
description_df = clause_extraction.get_clauses_df(description_df)
# step4: label clauses
labeled_clauses = activity_recognition.contains_activity_df(description_df)
return labeled_clauses, description_df
|
[
"noreply@github.com"
] |
noreply@github.com
|
344ac01479164503dbab03b95cd598cba2744ea4
|
047ddbf7dc154786da48f4b5ab8968a7abcad24b
|
/genprimo.py
|
51c4484a5e8c896c48e9515a294848b3c6413007
|
[] |
no_license
|
algoritmos-2019-2/clase-1-JAAD300
|
ecea409136bcc63e4c778b43c5b339cbb4a718de
|
0ab81d11a6532956636e8999a2f9ae11d75b8977
|
refs/heads/master
| 2020-04-19T20:03:19.553368
| 2019-04-01T05:40:22
| 2019-04-01T05:40:22
| 168,404,653
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 350
|
py
|
#!/usr/bin/env python3
def checador(n):
for i in range(2, n):
if (n % i) == 0:
return print(n, "no es primo")
else:
return print(n, "es primo")
print("ingrese número")
checador(int(input()))
|
[
"jorge@Jorge-PC.localdomain"
] |
jorge@Jorge-PC.localdomain
|
e9811e3794478cb96fb7f9d5165286664ef1e3d4
|
67b8c98b89f45780b1a153b2a06ed9b76626df23
|
/pyparrot_modified/pyparrot/networking/bleConnection.py
|
95cec165f89ea2033ec44f380e408329ea22c022
|
[
"MIT"
] |
permissive
|
Hollyqui/PyStalk
|
fe37dccb583f083b284134d0787dc9ef5dfeee5e
|
98abdaeb6194e79b402304a619182cec63074f2d
|
refs/heads/master
| 2020-06-02T15:51:40.106253
| 2020-02-11T08:00:47
| 2020-02-11T08:00:47
| 191,217,500
| 3
| 2
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 27,229
|
py
|
from bluepy.btle import Peripheral, UUID, DefaultDelegate, BTLEException
from pyparrot_modified.pyparrot.utils.colorPrint import color_print
import struct
import time
from pyparrot_modified.pyparrot.commandsandsensors.DroneSensorParser import get_data_format_and_size
from datetime import datetime
class MinidroneDelegate(DefaultDelegate):
"""
Handle BLE notififications
"""
def __init__(self, handle_map, minidrone, ble_connection):
DefaultDelegate.__init__(self)
self.handle_map = handle_map
self.minidrone = minidrone
self.ble_connection = ble_connection
color_print("initializing notification delegate", "INFO")
def handleNotification(self, cHandle, data):
#print "handling notificiation from channel %d" % cHandle
#print "handle map is %s " % self.handle_map[cHandle]
#print "channel map is %s " % self.minidrone.characteristic_receive_uuids[self.handle_map[cHandle]]
#print "data is %s " % data
channel = self.ble_connection.characteristic_receive_uuids[self.handle_map[cHandle]]
(packet_type, packet_seq_num) = struct.unpack('<BB', data[0:2])
raw_data = data[2:]
if channel == 'ACK_DRONE_DATA':
# data received from drone (needs to be ack on 1e)
#color_print("calling update sensors ack true", "WARN")
self.minidrone.update_sensors(packet_type, None, packet_seq_num, raw_data, ack=True)
elif channel == 'NO_ACK_DRONE_DATA':
# data from drone (including battery and others), no ack
#color_print("drone data - no ack needed")
self.minidrone.update_sensors(packet_type, None, packet_seq_num, raw_data, ack=False)
elif channel == 'ACK_COMMAND_SENT':
# ack 0b channel, SEND_WITH_ACK
#color_print("Ack! command received!")
self.ble_connection._set_command_received('SEND_WITH_ACK', True)
elif channel == 'ACK_HIGH_PRIORITY':
# ack 0c channel, SEND_HIGH_PRIORITY
#color_print("Ack! high priority received")
self.ble_connection._set_command_received('SEND_HIGH_PRIORITY', True)
else:
color_print("unknown channel %s sending data " % channel, "ERROR")
color_print(cHandle)
class BLEConnection:
def __init__(self, address, minidrone):
"""
Initialize with its BLE address - if you don't know the address, call findMinidrone
and that will discover it for you.
:param address: unique address for this minidrone
:param minidrone: the Minidrone object for this minidrone (needed for callbacks for sensors)
"""
self.address = address
self.drone_connection = Peripheral()
self.minidrone = minidrone
# the following UUID segments come from the Minidrone and from the documenation at
# http://forum.developer.parrot.com/t/minidrone-characteristics-uuid/4686/3
# the 3rd and 4th bytes are used to identify the service
self.service_uuids = {
'fa00': 'ARCOMMAND_SENDING_SERVICE',
'fb00': 'ARCOMMAND_RECEIVING_SERVICE',
'fc00': 'PERFORMANCE_COUNTER_SERVICE',
'fd21': 'NORMAL_BLE_FTP_SERVICE',
'fd51': 'UPDATE_BLE_FTP',
'fe00': 'UPDATE_RFCOMM_SERVICE',
'1800': 'Device Info',
'1801': 'unknown',
}
# the following characteristic UUID segments come from the documentation at
# http://forum.developer.parrot.com/t/minidrone-characteristics-uuid/4686/3
# the 4th bytes are used to identify the characteristic
# the usage of the channels are also documented here
# http://forum.developer.parrot.com/t/ble-characteristics-of-minidrones/5912/2
self.characteristic_send_uuids = {
'0a': 'SEND_NO_ACK', # not-ack commandsandsensors (PCMD only)
'0b': 'SEND_WITH_ACK', # ack commandsandsensors (all piloting commandsandsensors)
'0c': 'SEND_HIGH_PRIORITY', # emergency commandsandsensors
'1e': 'ACK_COMMAND' # ack for data sent on 0e
}
# counters for each packet (required as part of the packet)
self.characteristic_send_counter = {
'SEND_NO_ACK': 0,
'SEND_WITH_ACK': 0,
'SEND_HIGH_PRIORITY': 0,
'ACK_COMMAND': 0,
'RECEIVE_WITH_ACK': 0
}
# the following characteristic UUID segments come from the documentation at
# http://forum.developer.parrot.com/t/minidrone-characteristics-uuid/4686/3
# the 4th bytes are used to identify the characteristic
# the types of commandsandsensors and data coming back are also documented here
# http://forum.developer.parrot.com/t/ble-characteristics-of-minidrones/5912/2
self.characteristic_receive_uuids = {
'0e': 'ACK_DRONE_DATA', # drone data that needs an ack (needs to be ack on 1e)
'0f': 'NO_ACK_DRONE_DATA', # data from drone (including battery and others), no ack
'1b': 'ACK_COMMAND_SENT', # ack 0b channel, SEND_WITH_ACK
'1c': 'ACK_HIGH_PRIORITY', # ack 0c channel, SEND_HIGH_PRIORITY
}
# these are the FTP incoming and outcoming channels
# the handling characteristic seems to be the one to send commandsandsensors to (per the SDK)
# information gained from reading ARUTILS_BLEFtp.m in the SDK
self.characteristic_ftp_uuids = {
'22': 'NORMAL_FTP_TRANSFERRING',
'23': 'NORMAL_FTP_GETTING',
'24': 'NORMAL_FTP_HANDLING',
'52': 'UPDATE_FTP_TRANSFERRING',
'53': 'UPDATE_FTP_GETTING',
'54': 'UPDATE_FTP_HANDLING',
}
# FTP commandsandsensors (obtained via ARUTILS_BLEFtp.m in the SDK)
self.ftp_commands = {
"list": "LIS",
"get": "GET"
}
# need to save for communication (but they are initialized in connect)
self.services = None
self.send_characteristics = dict()
self.receive_characteristics = dict()
self.handshake_characteristics = dict()
self.ftp_characteristics = dict()
self.data_types = {
'ACK': 1,
'DATA_NO_ACK': 2,
'LOW_LATENCY_DATA': 3,
'DATA_WITH_ACK': 4
}
# store whether a command was acked
self.command_received = {
'SEND_WITH_ACK': False,
'SEND_HIGH_PRIORITY': False,
'ACK_COMMAND': False
}
# instead of parsing the XML file every time, cache the results
self.command_tuple_cache = dict()
self.sensor_tuple_cache = dict()
# maximum number of times to try a packet before assuming it failed
self.max_packet_retries = 3
def connect(self, num_retries):
"""
Connects to the drone and re-tries in case of failure the specified number of times
:param: num_retries is the number of times to retry
:return: True if it succeeds and False otherwise
"""
# first try to connect to the wifi
try_num = 1
connected = False
while (try_num < num_retries and not connected):
try:
self._connect()
connected = True
except BTLEException:
color_print("retrying connections", "INFO")
try_num += 1
# fall through, return False as something failed
return connected
def _reconnect(self, num_retries):
"""
Reconnect to the drone (assumed the BLE crashed)
:param: num_retries is the number of times to retry
:return: True if it succeeds and False otherwise
"""
try_num = 1
success = False
while (try_num < num_retries and not success):
try:
color_print("trying to re-connect to the minidrone at address %s" % self.address, "WARN")
self.drone_connection.connect(self.address, "random")
color_print("connected! Asking for services and characteristics", "SUCCESS")
success = True
except BTLEException:
color_print("retrying connections", "WARN")
try_num += 1
if (success):
# do the magic handshake
self._perform_handshake()
return success
def _connect(self):
"""
Connect to the minidrone to prepare for flying - includes getting the services and characteristics
for communication
:return: throws an error if the drone connection failed. Returns void if nothing failed.
"""
color_print("trying to connect to the minidrone at address %s" % self.address, "INFO")
self.drone_connection.connect(self.address, "random")
color_print("connected! Asking for services and characteristics", "SUCCESS")
# re-try until all services have been found
allServicesFound = False
# used for notifications
handle_map = dict()
while not allServicesFound:
# get the services
self.services = self.drone_connection.getServices()
# loop through the services
for s in self.services:
hex_str = self._get_byte_str_from_uuid(s.uuid, 3, 4)
# store the characteristics for receive & send
if (self.service_uuids[hex_str] == 'ARCOMMAND_RECEIVING_SERVICE'):
# only store the ones used to receive data
for c in s.getCharacteristics():
hex_str = self._get_byte_str_from_uuid(c.uuid, 4, 4)
if hex_str in self.characteristic_receive_uuids:
self.receive_characteristics[self.characteristic_receive_uuids[hex_str]] = c
handle_map[c.getHandle()] = hex_str
elif (self.service_uuids[hex_str] == 'ARCOMMAND_SENDING_SERVICE'):
# only store the ones used to send data
for c in s.getCharacteristics():
hex_str = self._get_byte_str_from_uuid(c.uuid, 4, 4)
if hex_str in self.characteristic_send_uuids:
self.send_characteristics[self.characteristic_send_uuids[hex_str]] = c
elif (self.service_uuids[hex_str] == 'UPDATE_BLE_FTP'):
# store the FTP info
for c in s.getCharacteristics():
hex_str = self._get_byte_str_from_uuid(c.uuid, 4, 4)
if hex_str in self.characteristic_ftp_uuids:
self.ftp_characteristics[self.characteristic_ftp_uuids[hex_str]] = c
elif (self.service_uuids[hex_str] == 'NORMAL_BLE_FTP_SERVICE'):
# store the FTP info
for c in s.getCharacteristics():
hex_str = self._get_byte_str_from_uuid(c.uuid, 4, 4)
if hex_str in self.characteristic_ftp_uuids:
self.ftp_characteristics[self.characteristic_ftp_uuids[hex_str]] = c
# need to register for notifications and write 0100 to the right handles
# this is sort of magic (not in the docs!) but it shows up on the forum here
# http://forum.developer.parrot.com/t/minimal-ble-commands-to-send-for-take-off/1686/2
# Note this code snippet below more or less came from the python example posted to that forum (I adapted it to my interface)
for c in s.getCharacteristics():
if self._get_byte_str_from_uuid(c.uuid, 3, 4) in \
['fb0f', 'fb0e', 'fb1b', 'fb1c', 'fd22', 'fd23', 'fd24', 'fd52', 'fd53', 'fd54']:
self.handshake_characteristics[self._get_byte_str_from_uuid(c.uuid, 3, 4)] = c
# check to see if all 8 characteristics were found
allServicesFound = True
for r_id in self.characteristic_receive_uuids.values():
if r_id not in self.receive_characteristics:
color_print("setting to false in receive on %s" % r_id)
allServicesFound = False
for s_id in self.characteristic_send_uuids.values():
if s_id not in self.send_characteristics:
color_print("setting to false in send")
allServicesFound = False
for f_id in self.characteristic_ftp_uuids.values():
if f_id not in self.ftp_characteristics:
color_print("setting to false in ftp")
allServicesFound = False
# and ensure all handshake characteristics were found
if len(self.handshake_characteristics.keys()) != 10:
color_print("setting to false in len")
allServicesFound = False
# do the magic handshake
self._perform_handshake()
# initialize the delegate to handle notifications
self.drone_connection.setDelegate(MinidroneDelegate(handle_map, self.minidrone, self))
def _perform_handshake(self):
"""
Magic handshake
Need to register for notifications and write 0100 to the right handles
This is sort of magic (not in the docs!) but it shows up on the forum here
http://forum.developer.parrot.com/t/minimal-ble-commandsandsensors-to-send-for-take-off/1686/2
:return: nothing
"""
color_print("magic handshake to make the drone listen to our commandsandsensors")
# Note this code snippet below more or less came from the python example posted to that forum (I adapted it to my interface)
for c in self.handshake_characteristics.values():
# for some reason bluepy characteristic handle is two lower than what I need...
# Need to write 0x0100 to the characteristics value handle (which is 2 higher)
self.drone_connection.writeCharacteristic(c.handle + 2, struct.pack("<BB", 1, 0))
def disconnect(self):
"""
Disconnect the BLE connection. Always call this at the end of your programs to
cleanly disconnect.
:return: void
"""
self.drone_connection.disconnect()
def _get_byte_str_from_uuid(self, uuid, byte_start, byte_end):
"""
Extract the specified byte string from the UUID btle object. This is an ugly hack
but it was necessary because of the way the UUID object is represented and the documentation
on the byte strings from Parrot. You give it the starting byte (counting from 1 since
that is how their docs count) and the ending byte and it returns that as a string extracted
from the UUID. It is assumed it happens before the first - in the UUID.
:param uuid: btle UUID object
:param byte_start: starting byte (counting from 1)
:param byte_end: ending byte (counting from 1)
:return: string with the requested bytes (to be used as a key in the lookup tables for services)
"""
uuid_str = format("%s" % uuid)
idx_start = 2 * (byte_start - 1)
idx_end = 2 * (byte_end)
my_hex_str = uuid_str[idx_start:idx_end]
return my_hex_str
def send_turn_command(self, command_tuple, degrees):
"""
Build the packet for turning and send it
:param command_tuple: command tuple from the parser
:param degrees: how many degrees to turn
:return: True if the command was sent and False otherwise
"""
self.characteristic_send_counter['SEND_WITH_ACK'] = (self.characteristic_send_counter['SEND_WITH_ACK'] + 1) % 256
packet = struct.pack("<BBBBHh", self.data_types['DATA_WITH_ACK'],
self.characteristic_send_counter['SEND_WITH_ACK'],
command_tuple[0], command_tuple[1], command_tuple[2],
degrees)
return self.send_command_packet_ack(packet)
def send_auto_takeoff_command(self, command_tuple):
"""
Build the packet for auto takeoff and send it
:param command_tuple: command tuple from the parser
:return: True if the command was sent and False otherwise
"""
# print command_tuple
self.characteristic_send_counter['SEND_WITH_ACK'] = (
self.characteristic_send_counter[
'SEND_WITH_ACK'] + 1) % 256
packet = struct.pack("<BBBBHB", self.data_types['DATA_WITH_ACK'],
self.characteristic_send_counter['SEND_WITH_ACK'],
command_tuple[0], command_tuple[1], command_tuple[2],
1)
return self.send_command_packet_ack(packet)
def send_command_packet_ack(self, packet):
"""
Sends the actual packet on the ack channel. Internal function only.
:param packet: packet constructed according to the command rules (variable size, constructed elsewhere)
:return: True if the command was sent and False otherwise
"""
try_num = 0
self._set_command_received('SEND_WITH_ACK', False)
while (try_num < self.max_packet_retries and not self.command_received['SEND_WITH_ACK']):
color_print("sending command packet on try %d" % try_num, 2)
self._safe_ble_write(characteristic=self.send_characteristics['SEND_WITH_ACK'], packet=packet)
#self.send_characteristics['SEND_WITH_ACK'].write(packet)
try_num += 1
color_print("sleeping for a notification", 2)
#notify = self.drone.waitForNotifications(1.0)
self.smart_sleep(0.5)
#color_print("awake %s " % notify, 2)
return self.command_received['SEND_WITH_ACK']
def send_pcmd_command(self, command_tuple, roll, pitch, yaw, vertical_movement, duration):
"""
Send the PCMD command with the specified roll, pitch, and yaw
:param command_tuple: command tuple per the parser
:param roll:
:param pitch:
:param yaw:
:param vertical_movement:
:param duration:
"""
start_time = time.time()
while (time.time() - start_time < duration):
self.characteristic_send_counter['SEND_NO_ACK'] = (
self.characteristic_send_counter['SEND_NO_ACK'] + 1) % 256
packet = struct.pack("<BBBBHBbbbbI", self.data_types['DATA_NO_ACK'],
self.characteristic_send_counter['SEND_NO_ACK'],
command_tuple[0], command_tuple[1], command_tuple[2],
1, int(roll), int(pitch), int(yaw), int(vertical_movement), 0)
self._safe_ble_write(characteristic=self.send_characteristics['SEND_NO_ACK'], packet=packet)
# self.send_characteristics['SEND_NO_ACK'].write(packet)
notify = self.drone_connection.waitForNotifications(0.1)
def send_noparam_command_packet_ack(self, command_tuple):
"""
Send a command on the ack channel - where all commandsandsensors except PCMD go, per
http://forum.developer.parrot.com/t/ble-characteristics-of-minidrones/5912/2
the id of the last command sent (for use in ack) is the send counter (which is incremented before sending)
Ensures the packet was received or sends it again up to a maximum number of times.
:param command_tuple: 3 tuple of the command bytes. 0 padded for 4th byte
:return: True if the command was sent and False otherwise
"""
self.characteristic_send_counter['SEND_WITH_ACK'] = (self.characteristic_send_counter['SEND_WITH_ACK'] + 1) % 256
packet = struct.pack("<BBBBH", self.data_types['DATA_WITH_ACK'], self.characteristic_send_counter['SEND_WITH_ACK'],
command_tuple[0], command_tuple[1], command_tuple[2])
return self.send_command_packet_ack(packet)
def send_enum_command_packet_ack(self, command_tuple, enum_value, usb_id=None):
"""
Send a command on the ack channel with enum parameters as well (most likely a flip).
All commandsandsensors except PCMD go on the ack channel per
http://forum.developer.parrot.com/t/ble-characteristics-of-minidrones/5912/2
the id of the last command sent (for use in ack) is the send counter (which is incremented before sending)
:param command_tuple: 3 tuple of the command bytes. 0 padded for 4th byte
:param enum_value: the enum index
:return: nothing
"""
self.characteristic_send_counter['SEND_WITH_ACK'] = (self.characteristic_send_counter['SEND_WITH_ACK'] + 1) % 256
if (usb_id is None):
packet = struct.pack("<BBBBBBI", self.data_types['DATA_WITH_ACK'], self.characteristic_send_counter['SEND_WITH_ACK'],
command_tuple[0], command_tuple[1], command_tuple[2], 0,
enum_value)
else:
color_print((self.data_types['DATA_WITH_ACK'], self.characteristic_send_counter['SEND_WITH_ACK'],
command_tuple[0], command_tuple[1], command_tuple[2], 0, usb_id, enum_value), 1)
packet = struct.pack("<BBBBHBI", self.data_types['DATA_WITH_ACK'], self.characteristic_send_counter['SEND_WITH_ACK'],
command_tuple[0], command_tuple[1], command_tuple[2],
usb_id, enum_value)
return self.send_command_packet_ack(packet)
def send_param_command_packet(self, command_tuple, param_tuple=None, param_type_tuple=0, ack=True):
"""
Send a command packet with parameters. Ack channel is optional for future flexibility,
but currently commands are always send over the Ack channel so it defaults to True.
Contributed by awm102 on github. Edited by Amy McGovern to work for BLE commands also.
:param: command_tuple: the command tuple derived from command_parser.get_command_tuple()
:param: param_tuple (optional): the parameter values to be sent (can be found in the XML files)
:param: param_size_tuple (optional): a tuple of strings representing the data type of the parameters
e.g. u8, float etc. (can be found in the XML files)
:param: ack (optional): allows ack to be turned off if required
:return:
"""
# Create lists to store the number of bytes and pack chars needed for parameters
# Default them to zero so that if no params are provided the packet size is correct
param_size_list = [0] * len(param_tuple)
pack_char_list = [0] * len(param_tuple)
if param_tuple is not None:
# Fetch the parameter sizes. By looping over the param_tuple we only get the data
# for requested parameters so a mismatch in params and types does not matter
for i, param in enumerate(param_tuple):
pack_char_list[i], param_size_list[i] = get_data_format_and_size(param, param_type_tuple[i])
if ack:
ack_string = 'SEND_WITH_ACK'
data_ack_string = 'DATA_WITH_ACK'
else:
ack_string = 'SEND_NO_ACK'
data_ack_string = 'DATA_NO_ACK'
# Construct the base packet
self.characteristic_send_counter['SEND_WITH_ACK'] = (self.characteristic_send_counter['SEND_WITH_ACK'] + 1) % 256
# TODO: Amy changed this to match the BLE packet structure but needs to fully test it
packet = struct.pack("<BBBBH", self.data_types[data_ack_string],
self.characteristic_send_counter[ack_string],
command_tuple[0], command_tuple[1], command_tuple[2])
if param_tuple is not None:
# Add in the parameter values based on their sizes
for i, param in enumerate(param_tuple):
packet += struct.pack(pack_char_list[i], param)
# TODO: Fix this to not go with ack always
return self.send_command_packet_ack(packet)
def _set_command_received(self, channel, val):
"""
Set the command received on the specified channel to the specified value (used for acks)
:param channel: channel
:param val: True or False
:return:
"""
self.command_received[channel] = val
def _safe_ble_write(self, characteristic, packet):
"""
Write to the specified BLE characteristic but first ensure the connection is valid
:param characteristic:
:param packet:
:return:
"""
success = False
while (not success):
try:
characteristic.write(packet)
success = True
except BTLEException:
color_print("reconnecting to send packet", "WARN")
self._reconnect(3)
def ack_packet(self, buffer_id, packet_id):
"""
Ack the packet id specified by the argument on the ACK_COMMAND channel
:param packet_id: the packet id to ack
:return: nothing
"""
#color_print("ack last packet on the ACK_COMMAND channel", "INFO")
self.characteristic_send_counter['ACK_COMMAND'] = (self.characteristic_send_counter['ACK_COMMAND'] + 1) % 256
packet = struct.pack("<BBB", self.data_types['ACK'], self.characteristic_send_counter['ACK_COMMAND'],
packet_id)
#color_print("sending packet %d %d %d" % (self.data_types['ACK'], self.characteristic_send_counter['ACK_COMMAND'],
# packet_id), "INFO")
self._safe_ble_write(characteristic=self.send_characteristics['ACK_COMMAND'], packet=packet)
#self.send_characteristics['ACK_COMMAND'].write(packet)
def smart_sleep(self, timeout):
"""
Sleeps the requested number of seconds but wakes up for notifications
Note: NEVER use regular time.sleep! It is a blocking sleep and it will likely
cause the BLE to disconnect due to dropped notifications. Always use smart_sleep instead!
:param timeout: number of seconds to sleep
:return:
"""
start_time = datetime.now()
new_time = datetime.now()
diff = (new_time - start_time).seconds + ((new_time - start_time).microseconds / 1000000.0)
while (diff < timeout):
try:
notify = self.drone_connection.waitForNotifications(0.1)
except:
color_print("reconnecting to wait", "WARN")
self._reconnect(3)
new_time = datetime.now()
diff = (new_time - start_time).seconds + ((new_time - start_time).microseconds / 1000000.0)
|
[
"noreply@github.com"
] |
noreply@github.com
|
6a27868511bae2d8a9d10a768aa6fea1b3b93397
|
7e246c308597762dccb129883706fb5f827b1f05
|
/examples/cli_debug.py
|
7cf1bec440e4396e14220a1389a6e98210f17e55
|
[] |
no_license
|
NGnius/casl
|
b54bdd26003e582d77bb04b4e80e13c34074b4ad
|
db5bc4fbf6819ba89d0258e4c24a7fa85273d145
|
refs/heads/master
| 2023-03-01T08:52:31.681391
| 2021-02-05T03:12:43
| 2021-02-05T03:12:43
| 330,711,583
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 179
|
py
|
#!/usr/bin/python3
import sys
import json
data = input()
payload = json.loads(data)
response = json.dumps({"error": "debug error", "action": {"type": "Custom"}})
print(response)
|
[
"ngniusness@gmail.com"
] |
ngniusness@gmail.com
|
d1963e7cc009082ee066bf6e7b3db7e2a3f62383
|
6472cd640341f4bcc3867c3579a87ee8b763ae15
|
/conventionalAI/venv/lib/python3.6/site-packages/rivescript/rivescript.py
|
95fdae4013df4e458c3448a8cef0dfdd83a16f8e
|
[] |
no_license
|
iafjayoza/Machine_Learning
|
7e9664cb6da6e0521e3475c9f80acd3ff15d1fc8
|
aba8fd939194b839da03f4c1ebd9eac8331d0b90
|
refs/heads/master
| 2023-06-01T14:28:59.391643
| 2021-06-25T17:12:57
| 2021-06-25T17:12:57
| 380,303,445
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 103,656
|
py
|
#!/usr/bin/env python
# The MIT License (MIT)
#
# Copyright (c) 2016 Noah Petherbridge
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from __future__ import unicode_literals
from six import text_type
import sys
import os
import re
import string
import random
import pprint
import copy
import codecs
from . import __version__
from . import python
# Common regular expressions.
class RE(object):
equals = re.compile('\s*=\s*')
ws = re.compile('\s+')
objend = re.compile('^\s*<\s*object')
weight = re.compile('\{weight=(\d+)\}')
inherit = re.compile('\{inherits=(\d+)\}')
wilds = re.compile('[\s\*\#\_]+')
nasties = re.compile('[^A-Za-z0-9 ]')
crlf = re.compile('<crlf>')
literal_w = re.compile(r'\\w')
array = re.compile(r'\@(.+?)\b')
def_syntax = re.compile(r'^.+(?:\s+.+|)\s*=\s*.+?$')
name_syntax = re.compile(r'[^a-z0-9_\-\s]')
utf8_trig = re.compile(r'[A-Z\\.]')
trig_syntax = re.compile(r'[^a-z0-9(\|)\[\]*_#@{}<>=\s]')
cond_syntax = re.compile(r'^.+?\s*(?:==|eq|!=|ne|<>|<|<=|>|>=)\s*.+?=>.+?$')
utf8_meta = re.compile(r'[\\<>]')
utf8_punct = re.compile(r'[.?,!;:@#$%^&*()]')
cond_split = re.compile(r'\s*=>\s*')
cond_parse = re.compile(r'^(.+?)\s+(==|eq|!=|ne|<>|<|<=|>|>=)\s+(.+?)$')
topic_tag = re.compile(r'\{topic=(.+?)\}')
set_tag = re.compile(r'<set (.+?)=(.+?)>')
bot_tag = re.compile(r'<bot (.+?)>')
get_tag = re.compile(r'<get (.+?)>')
star_tags = re.compile(r'<star(\d+)>')
botstars = re.compile(r'<botstar(\d+)>')
input_tags = re.compile(r'<input([1-9])>')
reply_tags = re.compile(r'<reply([1-9])>')
random_tags = re.compile(r'\{random\}(.+?)\{/random\}')
redir_tag = re.compile(r'\{@(.+?)\}')
tag_search = re.compile(r'<([^<]+?)>')
placeholder = re.compile(r'\x00(\d+)\x00')
zero_star = re.compile(r'^\*$')
optionals = re.compile(r'\[(.+?)\]')
# Version of RiveScript we support.
rs_version = 2.0
# Exportable constants.
RS_ERR_MATCH = "[ERR: No reply matched]"
RS_ERR_REPLY = "[ERR: No reply found]"
RS_ERR_DEEP_RECURSION = "[ERR: Deep recursion detected]"
RS_ERR_OBJECT = "[ERR: Error when executing Python object]"
RS_ERR_OBJECT_HANDLER = "[ERR: No Object Handler]"
RS_ERR_OBJECT_MISSING = "[ERR: Object Not Found]"
class RiveScript(object):
"""A RiveScript interpreter for Python 2 and 3."""
# Concatenation mode characters.
_concat_modes = dict(
none="",
space=" ",
newline="\n",
)
############################################################################
# Initialization and Utility Methods #
############################################################################
def __init__(self, debug=False, strict=True, depth=50, log="", utf8=False):
"""Initialize a new RiveScript interpreter.
bool debug: Specify a debug mode.
bool strict: Strict mode (RS syntax errors are fatal)
str log: Specify a log file for debug output to go to (instead of STDOUT).
int depth: Specify the recursion depth limit.
bool utf8: Enable UTF-8 support."""
###
# User configurable fields.
###
# Debugging
self._debug = debug # Debug mode
self._log = log # Debug log file
# Unicode stuff
self._utf8 = utf8 # UTF-8 mode
self.unicode_punctuation = re.compile(r'[.,!?;:]')
# Misc.
self._strict = strict # Strict mode
self._depth = depth # Recursion depth limit
###
# Internal fields.
###
self._gvars = {} # 'global' variables
self._bvars = {} # 'bot' variables
self._subs = {} # 'sub' variables
self._person = {} # 'person' variables
self._arrays = {} # 'array' variables
self._users = {} # 'user' variables
self._freeze = {} # frozen 'user' variables
self._includes = {} # included topics
self._lineage = {} # inherited topics
self._handlers = {} # Object handlers
self._objlangs = {} # Languages of objects used
self._topics = {} # Main reply structure
self._thats = {} # %Previous reply structure
self._sorted = {} # Sorted buffers
self._syntax = {} # Syntax tracking (filenames & line no.'s)
self._regexc = { # Precomputed regexes for speed optimizations.
"trigger": {},
"subs": {},
"person": {},
}
# "Current request" variables.
self._current_user = None # The current user ID.
# Define the default Python language handler.
self._handlers["python"] = python.PyRiveObjects()
self._say("Interpreter initialized.")
@classmethod
def VERSION(self=None):
"""Return the version number of the RiveScript library.
This may be called as either a class method or a method of a RiveScript object."""
return __version__
def _say(self, message):
if self._debug:
print("[RS] {}".format(message))
if self._log:
# Log it to the file.
fh = open(self._log, 'a')
fh.write("[RS] " + message + "\n")
fh.close()
def _warn(self, message, fname='', lineno=0):
header = "[RS]"
if self._debug:
header = "[RS::Warning]"
if len(fname) and lineno > 0:
print(header, message, "at", fname, "line", lineno)
else:
print(header, message)
############################################################################
# Loading and Parsing Methods #
############################################################################
def load_directory(self, directory, ext=None):
"""Load RiveScript documents from a directory.
Provide `ext` as a list of extensions to search for. The default list
is `.rive`, `.rs`"""
self._say("Loading from directory: " + directory)
if ext is None:
# Use the default extensions - .rive is preferable.
ext = ['.rive', '.rs']
elif type(ext) == str:
# Backwards compatibility for ext being a string value.
ext = [ext]
if not os.path.isdir(directory):
self._warn("Error: " + directory + " is not a directory.")
return
for item in os.listdir(directory):
for extension in ext:
if item.lower().endswith(extension):
# Load this file.
self.load_file(os.path.join(directory, item))
break
def load_file(self, filename):
"""Load and parse a RiveScript document."""
self._say("Loading file: " + filename)
fh = codecs.open(filename, 'r', 'utf-8')
lines = fh.readlines()
fh.close()
self._say("Parsing " + str(len(lines)) + " lines of code from " + filename)
self._parse(filename, lines)
def stream(self, code):
"""Stream in RiveScript source code dynamically.
`code` can either be a string containing RiveScript code or an array
of lines of RiveScript code."""
self._say("Streaming code.")
if type(code) in [str, text_type]:
code = code.split("\n")
self._parse("stream()", code)
def _parse(self, fname, code):
"""Parse RiveScript code into memory."""
self._say("Parsing code")
# Track temporary variables.
topic = 'random' # Default topic=random
lineno = 0 # Line numbers for syntax tracking
comment = False # In a multi-line comment
inobj = False # In an object
objname = '' # The name of the object we're in
objlang = '' # The programming language of the object
objbuf = [] # Object contents buffer
ontrig = '' # The current trigger
repcnt = 0 # Reply counter
concnt = 0 # Condition counter
isThat = '' # Is a %Previous trigger
# Local (file scoped) parser options.
local_options = dict(
concat="none", # Concat mode for ^Continue command
)
# Read each line.
for lp, line in enumerate(code):
lineno += 1
self._say("Line: " + line + " (topic: " + topic + ") incomment: " + str(inobj))
if len(line.strip()) == 0: # Skip blank lines
continue
# In an object?
if inobj:
if re.match(RE.objend, line):
# End the object.
if len(objname):
# Call the object's handler.
if objlang in self._handlers:
self._objlangs[objname] = objlang
self._handlers[objlang].load(objname, objbuf)
else:
self._warn("Object creation failed: no handler for " + objlang, fname, lineno)
objname = ''
objlang = ''
objbuf = []
inobj = False
else:
objbuf.append(line)
continue
line = line.strip() # Trim excess space. We do it down here so we
# don't mess up python objects!
# Look for comments.
if line[:2] == '//': # A single-line comment.
continue
elif line[0] == '#':
self._warn("Using the # symbol for comments is deprecated", fname, lineno)
elif line[:2] == '/*': # Start of a multi-line comment.
if '*/' not in line: # Cancel if the end is here too.
comment = True
continue
elif '*/' in line:
comment = False
continue
if comment:
continue
# Separate the command from the data.
if len(line) < 2:
self._warn("Weird single-character line '" + line + "' found.", fname, lineno)
continue
cmd = line[0]
line = line[1:].strip()
# Ignore inline comments if there's a space before and after
# the // symbols.
if " // " in line:
line = line.split(" // ")[0].strip()
# Run a syntax check on this line.
syntax_error = self.check_syntax(cmd, line)
if syntax_error:
# There was a syntax error! Are we enforcing strict mode?
syntax_error = "Syntax error in " + fname + " line " + str(lineno) + ": " \
+ syntax_error + " (near: " + cmd + " " + line + ")"
if self._strict:
raise Exception(syntax_error)
else:
self._warn(syntax_error)
return # Don't try to continue
# Reset the %Previous state if this is a new +Trigger.
if cmd == '+':
isThat = ''
# Do a lookahead for ^Continue and %Previous commands.
for i in range(lp + 1, len(code)):
lookahead = code[i].strip()
if len(lookahead) < 2:
continue
lookCmd = lookahead[0]
lookahead = lookahead[1:].strip()
# Only continue if the lookahead line has any data.
if len(lookahead) != 0:
# The lookahead command has to be either a % or a ^.
if lookCmd != '^' and lookCmd != '%':
break
# If the current command is a +, see if the following is
# a %.
if cmd == '+':
if lookCmd == '%':
isThat = lookahead
break
else:
isThat = ''
# If the current command is a ! and the next command(s) are
# ^, we'll tack each extension on as a line break (which is
# useful information for arrays).
if cmd == '!':
if lookCmd == '^':
line += "<crlf>" + lookahead
continue
# If the current command is not a ^ and the line after is
# not a %, but the line after IS a ^, then tack it on to the
# end of the current line.
if cmd != '^' and lookCmd != '%':
if lookCmd == '^':
line += self._concat_modes.get(
local_options["concat"], ""
) + lookahead
else:
break
self._say("Command: " + cmd + "; line: " + line)
# Handle the types of RiveScript commands.
if cmd == '!':
# ! DEFINE
halves = re.split(RE.equals, line, 2)
left = re.split(RE.ws, halves[0].strip(), 2)
value, type, var = '', '', ''
if len(halves) == 2:
value = halves[1].strip()
if len(left) >= 1:
type = left[0].strip()
if len(left) >= 2:
var = ' '.join(left[1:]).strip()
# Remove 'fake' line breaks unless this is an array.
if type != 'array':
value = re.sub(RE.crlf, '', value)
# Handle version numbers.
if type == 'version':
# Verify we support it.
try:
if float(value) > rs_version:
self._warn("Unsupported RiveScript version. We only support " + rs_version, fname, lineno)
return
except:
self._warn("Error parsing RiveScript version number: not a number", fname, lineno)
continue
# All other types of defines require a variable and value name.
if len(var) == 0:
self._warn("Undefined variable name", fname, lineno)
continue
elif len(value) == 0:
self._warn("Undefined variable value", fname, lineno)
continue
# Handle the rest of the types.
if type == 'local':
# Local file-scoped parser options.
self._say("\tSet parser option " + var + " = " + value)
local_options[var] = value
elif type == 'global':
# 'Global' variables
self._say("\tSet global " + var + " = " + value)
if value == '<undef>':
try:
del(self._gvars[var])
except:
self._warn("Failed to delete missing global variable", fname, lineno)
else:
self._gvars[var] = value
# Handle flipping debug and depth vars.
if var == 'debug':
if value.lower() == 'true':
value = True
else:
value = False
self._debug = value
elif var == 'depth':
try:
self._depth = int(value)
except:
self._warn("Failed to set 'depth' because the value isn't a number!", fname, lineno)
elif var == 'strict':
if value.lower() == 'true':
self._strict = True
else:
self._strict = False
elif type == 'var':
# Bot variables
self._say("\tSet bot variable " + var + " = " + value)
if value == '<undef>':
try:
del(self._bvars[var])
except:
self._warn("Failed to delete missing bot variable", fname, lineno)
else:
self._bvars[var] = value
elif type == 'array':
# Arrays
self._say("\tArray " + var + " = " + value)
if value == '<undef>':
try:
del(self._arrays[var])
except:
self._warn("Failed to delete missing array", fname, lineno)
continue
# Did this have multiple parts?
parts = value.split("<crlf>")
# Process each line of array data.
fields = []
for val in parts:
if '|' in val:
fields.extend(val.split('|'))
else:
fields.extend(re.split(RE.ws, val))
# Convert any remaining '\s' escape codes into spaces.
for f in fields:
f = f.replace('\s', ' ')
self._arrays[var] = fields
elif type == 'sub':
# Substitutions
self._say("\tSubstitution " + var + " => " + value)
if value == '<undef>':
try:
del(self._subs[var])
except:
self._warn("Failed to delete missing substitution", fname, lineno)
else:
self._subs[var] = value
# Precompile the regexp.
self._precompile_substitution("subs", var)
elif type == 'person':
# Person Substitutions
self._say("\tPerson Substitution " + var + " => " + value)
if value == '<undef>':
try:
del(self._person[var])
except:
self._warn("Failed to delete missing person substitution", fname, lineno)
else:
self._person[var] = value
# Precompile the regexp.
self._precompile_substitution("person", var)
else:
self._warn("Unknown definition type '" + type + "'", fname, lineno)
elif cmd == '>':
# > LABEL
temp = re.split(RE.ws, line)
type = temp[0]
name = ''
fields = []
if len(temp) >= 2:
name = temp[1]
if len(temp) >= 3:
fields = temp[2:]
# Handle the label types.
if type == 'begin':
# The BEGIN block.
self._say("\tFound the BEGIN block.")
type = 'topic'
name = '__begin__'
if type == 'topic':
# Starting a new topic.
self._say("\tSet topic to " + name)
ontrig = ''
topic = name
# Does this topic include or inherit another one?
mode = '' # or 'inherits' or 'includes'
if len(fields) >= 2:
for field in fields:
if field == 'includes':
mode = 'includes'
elif field == 'inherits':
mode = 'inherits'
elif mode != '':
# This topic is either inherited or included.
if mode == 'includes':
if name not in self._includes:
self._includes[name] = {}
self._includes[name][field] = 1
else:
if name not in self._lineage:
self._lineage[name] = {}
self._lineage[name][field] = 1
elif type == 'object':
# If a field was provided, it should be the programming
# language.
lang = None
if len(fields) > 0:
lang = fields[0].lower()
# Only try to parse a language we support.
ontrig = ''
if lang is None:
self._warn("Trying to parse unknown programming language", fname, lineno)
lang = 'python' # Assume it's Python.
# See if we have a defined handler for this language.
if lang in self._handlers:
# We have a handler, so start loading the code.
objname = name
objlang = lang
objbuf = []
inobj = True
else:
# We don't have a handler, just ignore it.
objname = ''
objlang = ''
objbuf = []
inobj = True
else:
self._warn("Unknown label type '" + type + "'", fname, lineno)
elif cmd == '<':
# < LABEL
type = line
if type == 'begin' or type == 'topic':
self._say("\tEnd topic label.")
topic = 'random'
elif type == 'object':
self._say("\tEnd object label.")
inobj = False
elif cmd == '+':
# + TRIGGER
self._say("\tTrigger pattern: " + line)
if len(isThat):
self._initTT('thats', topic, isThat, line)
self._initTT('syntax', topic, line, 'thats')
self._syntax['thats'][topic][line]['trigger'] = (fname, lineno)
else:
self._initTT('topics', topic, line)
self._initTT('syntax', topic, line, 'topic')
self._syntax['topic'][topic][line]['trigger'] = (fname, lineno)
ontrig = line
repcnt = 0
concnt = 0
# Pre-compile the trigger's regexp if possible.
self._precompile_regexp(ontrig)
elif cmd == '-':
# - REPLY
if ontrig == '':
self._warn("Response found before trigger", fname, lineno)
continue
self._say("\tResponse: " + line)
if len(isThat):
self._thats[topic][isThat][ontrig]['reply'][repcnt] = line
self._syntax['thats'][topic][ontrig]['reply'][repcnt] = (fname, lineno)
else:
self._topics[topic][ontrig]['reply'][repcnt] = line
self._syntax['topic'][topic][ontrig]['reply'][repcnt] = (fname, lineno)
repcnt += 1
elif cmd == '%':
# % PREVIOUS
pass # This was handled above.
elif cmd == '^':
# ^ CONTINUE
pass # This was handled above.
elif cmd == '@':
# @ REDIRECT
self._say("\tRedirect response to " + line)
if len(isThat):
self._thats[topic][isThat][ontrig]['redirect'] = line
self._syntax['thats'][topic][ontrig]['redirect'] = (fname, lineno)
else:
self._topics[topic][ontrig]['redirect'] = line
self._syntax['topic'][topic][ontrig]['redirect'] = (fname, lineno)
elif cmd == '*':
# * CONDITION
self._say("\tAdding condition: " + line)
if len(isThat):
self._thats[topic][isThat][ontrig]['condition'][concnt] = line
self._syntax['thats'][topic][ontrig]['condition'][concnt] = (fname, lineno)
else:
self._topics[topic][ontrig]['condition'][concnt] = line
self._syntax['topic'][topic][ontrig]['condition'][concnt] = (fname, lineno)
concnt += 1
else:
self._warn("Unrecognized command \"" + cmd + "\"", fname, lineno)
continue
def check_syntax(self, cmd, line):
"""Syntax check a RiveScript command and line.
Returns a syntax error string on error; None otherwise."""
# Run syntax checks based on the type of command.
if cmd == '!':
# ! Definition
# - Must be formatted like this:
# ! type name = value
# OR
# ! type = value
match = re.match(RE.def_syntax, line)
if not match:
return "Invalid format for !Definition line: must be '! type name = value' OR '! type = value'"
elif cmd == '>':
# > Label
# - The "begin" label must have only one argument ("begin")
# - "topic" labels must be lowercased but can inherit other topics (a-z0-9_\s)
# - "object" labels must follow the same rules as "topic", but don't need to be lowercase
parts = re.split(" ", line, 2)
if parts[0] == "begin" and len(parts) > 1:
return "The 'begin' label takes no additional arguments, should be verbatim '> begin'"
elif parts[0] == "topic":
match = re.match(RE.name_syntax, line)
if match:
return "Topics should be lowercased and contain only numbers and letters"
elif parts[0] == "object":
match = re.match(RE.name_syntax, line)
if match:
return "Objects can only contain numbers and letters"
elif cmd == '+' or cmd == '%' or cmd == '@':
# + Trigger, % Previous, @ Redirect
# This one is strict. The triggers are to be run through the regexp engine,
# therefore it should be acceptable for the regexp engine.
# - Entirely lowercase
# - No symbols except: ( | ) [ ] * _ # @ { } < > =
# - All brackets should be matched
parens = 0 # Open parenthesis
square = 0 # Open square brackets
curly = 0 # Open curly brackets
angle = 0 # Open angled brackets
# Count brackets.
for char in line:
if char == '(':
parens += 1
elif char == ')':
parens -= 1
elif char == '[':
square += 1
elif char == ']':
square -= 1
elif char == '{':
curly += 1
elif char == '}':
curly -= 1
elif char == '<':
angle += 1
elif char == '>':
angle -= 1
# Any mismatches?
if parens != 0:
return "Unmatched parenthesis brackets"
elif square != 0:
return "Unmatched square brackets"
elif curly != 0:
return "Unmatched curly brackets"
elif angle != 0:
return "Unmatched angle brackets"
# In UTF-8 mode, most symbols are allowed.
if self._utf8:
match = re.match(RE.utf8_trig, line)
if match:
return "Triggers can't contain uppercase letters, backslashes or dots in UTF-8 mode."
else:
match = re.match(RE.trig_syntax, line)
if match:
return "Triggers may only contain lowercase letters, numbers, and these symbols: ( | ) [ ] * _ # @ { } < > ="
elif cmd == '-' or cmd == '^' or cmd == '/':
# - Trigger, ^ Continue, / Comment
# These commands take verbatim arguments, so their syntax is loose.
pass
elif cmd == '*':
# * Condition
# Syntax for a conditional is as follows:
# * value symbol value => response
match = re.match(RE.cond_syntax, line)
if not match:
return "Invalid format for !Condition: should be like '* value symbol value => response'"
return None
def deparse(self):
"""Return the in-memory RiveScript document as a Python data structure.
This would be useful for developing a user interface for editing
RiveScript replies without having to edit the RiveScript code
manually."""
# Data to return.
result = {
"begin": {
"global": {},
"var": {},
"sub": {},
"person": {},
"array": {},
"triggers": {},
"that": {},
},
"topic": {},
"that": {},
"inherit": {},
"include": {},
}
# Populate the config fields.
if self._debug:
result["begin"]["global"]["debug"] = self._debug
if self._depth != 50:
result["begin"]["global"]["depth"] = 50
# Definitions
result["begin"]["var"] = self._bvars.copy()
result["begin"]["sub"] = self._subs.copy()
result["begin"]["person"] = self._person.copy()
result["begin"]["array"] = self._arrays.copy()
result["begin"]["global"].update(self._gvars.copy())
# Topic Triggers.
for topic in self._topics:
dest = {} # Where to place the topic info
if topic == "__begin__":
# Begin block.
dest = result["begin"]["triggers"]
else:
# Normal topic.
if topic not in result["topic"]:
result["topic"][topic] = {}
dest = result["topic"][topic]
# Copy the triggers.
for trig, data in self._topics[topic].iteritems():
dest[trig] = self._copy_trigger(trig, data)
# %Previous's.
for topic in self._thats:
dest = {} # Where to place the topic info
if topic == "__begin__":
# Begin block.
dest = result["begin"]["that"]
else:
# Normal topic.
if topic not in result["that"]:
result["that"][topic] = {}
dest = result["that"][topic]
# The "that" structure is backwards: bot reply, then trigger, then info.
for previous, pdata in self._thats[topic].iteritems():
for trig, data in pdata.iteritems():
dest[trig] = self._copy_trigger(trig, data, previous)
# Inherits/Includes.
for topic, data in self._lineage.iteritems():
result["inherit"][topic] = []
for inherit in data:
result["inherit"][topic].append(inherit)
for topic, data in self._includes.iteritems():
result["include"][topic] = []
for include in data:
result["include"][topic].append(include)
return result
def write(self, fh, deparsed=None):
"""Write the currently parsed RiveScript data into a file.
Pass either a file name (string) or a file handle object.
This uses `deparse()` to dump a representation of the loaded data and
writes it to the destination file. If you provide your own data as the
`deparsed` argument, it will use that data instead of calling
`deparse()` itself. This way you can use `deparse()`, edit the data,
and use that to write the RiveScript document (for example, to be used
by a user interface for editing RiveScript without writing the code
directly)."""
# Passed a string instead of a file handle?
if type(fh) is str:
fh = codecs.open(fh, "w", "utf-8")
# Deparse the loaded data.
if deparsed is None:
deparsed = self.deparse()
# Start at the beginning.
fh.write("// Written by rivescript.deparse()\n")
fh.write("! version = 2.0\n\n")
# Variables of all sorts!
for kind in ["global", "var", "sub", "person", "array"]:
if len(deparsed["begin"][kind].keys()) == 0:
continue
for var in sorted(deparsed["begin"][kind].keys()):
# Array types need to be separated by either spaces or pipes.
data = deparsed["begin"][kind][var]
if type(data) not in [str, text_type]:
needs_pipes = False
for test in data:
if " " in test:
needs_pipes = True
break
# Word-wrap the result, target width is 78 chars minus the
# kind, var, and spaces and equals sign.
width = 78 - len(kind) - len(var) - 4
if needs_pipes:
data = self._write_wrapped("|".join(data), sep="|")
else:
data = " ".join(data)
fh.write("! {kind} {var} = {data}\n".format(
kind=kind,
var=var,
data=data,
))
fh.write("\n")
# Begin block.
if len(deparsed["begin"]["triggers"].keys()):
fh.write("> begin\n\n")
self._write_triggers(fh, deparsed["begin"]["triggers"], indent="\t")
fh.write("< begin\n\n")
# The topics. Random first!
topics = ["random"]
topics.extend(sorted(deparsed["topic"].keys()))
done_random = False
for topic in topics:
if topic not in deparsed["topic"]: continue
if topic == "random" and done_random: continue
if topic == "random": done_random = True
tagged = False # Used > topic tag
if topic != "random" or topic in deparsed["include"] or topic in deparsed["inherit"]:
tagged = True
fh.write("> topic " + topic)
if topic in deparsed["inherit"]:
fh.write(" inherits " + " ".join(deparsed["inherit"][topic]))
if topic in deparsed["include"]:
fh.write(" includes " + " ".join(deparsed["include"][topic]))
fh.write("\n\n")
indent = "\t" if tagged else ""
self._write_triggers(fh, deparsed["topic"][topic], indent=indent)
# Any %Previous's?
if topic in deparsed["that"]:
self._write_triggers(fh, deparsed["that"][topic], indent=indent)
if tagged:
fh.write("< topic\n\n")
return True
def _copy_trigger(self, trig, data, previous=None):
"""Make copies of all data below a trigger."""
# Copied data.
dest = {}
if previous:
dest["previous"] = previous
if "redirect" in data and data["redirect"]:
# @Redirect
dest["redirect"] = data["redirect"]
if "condition" in data and len(data["condition"].keys()):
# *Condition
dest["condition"] = []
for i in sorted(data["condition"].keys()):
dest["condition"].append(data["condition"][i])
if "reply" in data and len(data["reply"].keys()):
# -Reply
dest["reply"] = []
for i in sorted(data["reply"].keys()):
dest["reply"].append(data["reply"][i])
return dest
def _write_triggers(self, fh, triggers, indent=""):
"""Write triggers to a file handle."""
for trig in sorted(triggers.keys()):
fh.write(indent + "+ " + self._write_wrapped(trig, indent=indent) + "\n")
d = triggers[trig]
if "previous" in d:
fh.write(indent + "% " + self._write_wrapped(d["previous"], indent=indent) + "\n")
if "condition" in d:
for cond in d["condition"]:
fh.write(indent + "* " + self._write_wrapped(cond, indent=indent) + "\n")
if "redirect" in d:
fh.write(indent + "@ " + self._write_wrapped(d["redirect"], indent=indent) + "\n")
if "reply" in d:
for reply in d["reply"]:
fh.write(indent + "- " + self._write_wrapped(reply, indent=indent) + "\n")
fh.write("\n")
def _write_wrapped(self, line, sep=" ", indent="", width=78):
"""Word-wrap a line of RiveScript code for being written to a file."""
words = line.split(sep)
lines = []
line = ""
buf = []
while len(words):
buf.append(words.pop(0))
line = sep.join(buf)
if len(line) > width:
# Need to word wrap!
words.insert(0, buf.pop()) # Undo
lines.append(sep.join(buf))
buf = []
line = ""
# Straggler?
if line:
lines.append(line)
# Returned output
result = lines.pop(0)
if len(lines):
eol = ""
if sep == " ":
eol = "\s"
for item in lines:
result += eol + "\n" + indent + "^ " + item
return result
def _initTT(self, toplevel, topic, trigger, what=''):
"""Initialize a Topic Tree data structure."""
if toplevel == 'topics':
if topic not in self._topics:
self._topics[topic] = {}
if trigger not in self._topics[topic]:
self._topics[topic][trigger] = {}
self._topics[topic][trigger]['reply'] = {}
self._topics[topic][trigger]['condition'] = {}
self._topics[topic][trigger]['redirect'] = None
elif toplevel == 'thats':
if topic not in self._thats:
self._thats[topic] = {}
if trigger not in self._thats[topic]:
self._thats[topic][trigger] = {}
if what not in self._thats[topic][trigger]:
self._thats[topic][trigger][what] = {}
self._thats[topic][trigger][what]['reply'] = {}
self._thats[topic][trigger][what]['condition'] = {}
self._thats[topic][trigger][what]['redirect'] = {}
elif toplevel == 'syntax':
if what not in self._syntax:
self._syntax[what] = {}
if topic not in self._syntax[what]:
self._syntax[what][topic] = {}
if trigger not in self._syntax[what][topic]:
self._syntax[what][topic][trigger] = {}
self._syntax[what][topic][trigger]['reply'] = {}
self._syntax[what][topic][trigger]['condition'] = {}
self._syntax[what][topic][trigger]['redirect'] = {}
############################################################################
# Sorting Methods #
############################################################################
def sort_replies(self, thats=False):
"""Sort the loaded triggers."""
# This method can sort both triggers and that's.
triglvl = None
sortlvl = None
if thats:
triglvl = self._thats
sortlvl = 'thats'
else:
triglvl = self._topics
sortlvl = 'topics'
# (Re)Initialize the sort cache.
self._sorted[sortlvl] = {}
self._say("Sorting triggers...")
# Loop through all the topics.
for topic in triglvl:
self._say("Analyzing topic " + topic)
# Collect a list of all the triggers we're going to need to worry
# about. If this topic inherits another topic, we need to
# recursively add those to the list.
alltrig = self._topic_triggers(topic, triglvl)
# Keep in mind here that there is a difference between 'includes'
# and 'inherits' -- topics that inherit other topics are able to
# OVERRIDE triggers that appear in the inherited topic. This means
# that if the top topic has a trigger of simply '*', then *NO*
# triggers are capable of matching in ANY inherited topic, because
# even though * has the lowest sorting priority, it has an automatic
# priority over all inherited topics.
#
# The _topic_triggers method takes this into account. All topics
# that inherit other topics will have their triggers prefixed with
# a fictional {inherits} tag, which would start at {inherits=0} and
# increment if the topic tree has other inheriting topics. So we can
# use this tag to make sure topics that inherit things will have
# their triggers always be on top of the stack, from inherits=0 to
# inherits=n.
# Sort these triggers.
running = self._sort_trigger_set(alltrig)
# Save this topic's sorted list.
if sortlvl not in self._sorted:
self._sorted[sortlvl] = {}
self._sorted[sortlvl][topic] = running
# And do it all again for %Previous!
if not thats:
# This will sort the %Previous lines to best match the bot's last reply.
self.sort_replies(True)
# If any of those %Previous's had more than one +trigger for them,
# this will sort all those +triggers to pair back the best human
# interaction.
self._sort_that_triggers()
# Also sort both kinds of substitutions.
self._sort_list('subs', self._subs)
self._sort_list('person', self._person)
def _sort_that_triggers(self):
"""Make a sorted list of triggers that correspond to %Previous groups."""
self._say("Sorting reverse triggers for %Previous groups...")
if "that_trig" not in self._sorted:
self._sorted["that_trig"] = {}
for topic in self._thats:
if topic not in self._sorted["that_trig"]:
self._sorted["that_trig"][topic] = {}
for bottrig in self._thats[topic]:
if bottrig not in self._sorted["that_trig"][topic]:
self._sorted["that_trig"][topic][bottrig] = []
triggers = self._sort_trigger_set(self._thats[topic][bottrig].keys())
self._sorted["that_trig"][topic][bottrig] = triggers
def _sort_trigger_set(self, triggers):
"""Sort a group of triggers in optimal sorting order."""
# Create a priority map.
prior = {
0: [] # Default priority=0
}
for trig in triggers:
match, weight = re.search(RE.weight, trig), 0
if match:
weight = int(match.group(1))
if weight not in prior:
prior[weight] = []
prior[weight].append(trig)
# Keep a running list of sorted triggers for this topic.
running = []
# Sort them by priority.
for p in sorted(prior.keys(), reverse=True):
self._say("\tSorting triggers with priority " + str(p))
# So, some of these triggers may include {inherits} tags, if they
# came form a topic which inherits another topic. Lower inherits
# values mean higher priority on the stack.
inherits = -1 # -1 means no {inherits} tag
highest_inherits = -1 # highest inheritance number seen
# Loop through and categorize these triggers.
track = {
inherits: self._init_sort_track()
}
for trig in prior[p]:
self._say("\t\tLooking at trigger: " + trig)
# See if it has an inherits tag.
match = re.search(RE.inherit, trig)
if match:
inherits = int(match.group(1))
if inherits > highest_inherits:
highest_inherits = inherits
self._say("\t\t\tTrigger belongs to a topic which inherits other topics: level=" + str(inherits))
trig = re.sub(RE.inherit, "", trig)
else:
inherits = -1
# If this is the first time we've seen this inheritance level,
# initialize its track structure.
if inherits not in track:
track[inherits] = self._init_sort_track()
# Start inspecting the trigger's contents.
if '_' in trig:
# Alphabetic wildcard included.
cnt = self._word_count(trig)
self._say("\t\t\tHas a _ wildcard with " + str(cnt) + " words.")
if cnt > 1:
if cnt not in track[inherits]['alpha']:
track[inherits]['alpha'][cnt] = []
track[inherits]['alpha'][cnt].append(trig)
else:
track[inherits]['under'].append(trig)
elif '#' in trig:
# Numeric wildcard included.
cnt = self._word_count(trig)
self._say("\t\t\tHas a # wildcard with " + str(cnt) + " words.")
if cnt > 1:
if cnt not in track[inherits]['number']:
track[inherits]['number'][cnt] = []
track[inherits]['number'][cnt].append(trig)
else:
track[inherits]['pound'].append(trig)
elif '*' in trig:
# Wildcard included.
cnt = self._word_count(trig)
self._say("\t\t\tHas a * wildcard with " + str(cnt) + " words.")
if cnt > 1:
if cnt not in track[inherits]['wild']:
track[inherits]['wild'][cnt] = []
track[inherits]['wild'][cnt].append(trig)
else:
track[inherits]['star'].append(trig)
elif '[' in trig:
# Optionals included.
cnt = self._word_count(trig)
self._say("\t\t\tHas optionals and " + str(cnt) + " words.")
if cnt not in track[inherits]['option']:
track[inherits]['option'][cnt] = []
track[inherits]['option'][cnt].append(trig)
else:
# Totally atomic.
cnt = self._word_count(trig)
self._say("\t\t\tTotally atomic and " + str(cnt) + " words.")
if cnt not in track[inherits]['atomic']:
track[inherits]['atomic'][cnt] = []
track[inherits]['atomic'][cnt].append(trig)
# Move the no-{inherits} triggers to the bottom of the stack.
track[highest_inherits + 1] = track[-1]
del(track[-1])
# Add this group to the sort list.
for ip in sorted(track.keys()):
self._say("ip=" + str(ip))
for kind in ['atomic', 'option', 'alpha', 'number', 'wild']:
for wordcnt in sorted(track[ip][kind], reverse=True):
# Triggers with a matching word count should be sorted
# by length, descending.
running.extend(sorted(track[ip][kind][wordcnt], key=len, reverse=True))
running.extend(sorted(track[ip]['under'], key=len, reverse=True))
running.extend(sorted(track[ip]['pound'], key=len, reverse=True))
running.extend(sorted(track[ip]['star'], key=len, reverse=True))
return running
def _sort_list(self, name, items):
"""Sort a simple list by number of words and length."""
def by_length(word1, word2):
return len(word2) - len(word1)
# Initialize the list sort buffer.
if "lists" not in self._sorted:
self._sorted["lists"] = {}
self._sorted["lists"][name] = []
# Track by number of words.
track = {}
# Loop through each item.
for item in items:
# Count the words.
cword = self._word_count(item, all=True)
if cword not in track:
track[cword] = []
track[cword].append(item)
# Sort them.
output = []
for count in sorted(track.keys(), reverse=True):
sort = sorted(track[count], key=len, reverse=True)
output.extend(sort)
self._sorted["lists"][name] = output
def _init_sort_track(self):
"""Returns a new dict for keeping track of triggers for sorting."""
return {
'atomic': {}, # Sort by number of whole words
'option': {}, # Sort optionals by number of words
'alpha': {}, # Sort alpha wildcards by no. of words
'number': {}, # Sort number wildcards by no. of words
'wild': {}, # Sort wildcards by no. of words
'pound': [], # Triggers of just #
'under': [], # Triggers of just _
'star': [] # Triggers of just *
}
############################################################################
# Public Configuration Methods #
############################################################################
def set_handler(self, language, obj):
"""Define a custom language handler for RiveScript objects.
language: The lowercased name of the programming language,
e.g. python, javascript, perl
obj: An instance of a class object that provides the following interface:
class MyObjectHandler:
def __init__(self):
pass
def load(self, name, code):
# name = the name of the object from the RiveScript code
# code = the source code of the object
def call(self, rs, name, fields):
# rs = the current RiveScript interpreter object
# name = the name of the object being called
# fields = array of arguments passed to the object
return reply
Pass in a None value for the object to delete an existing handler (for example,
to prevent Python code from being able to be run by default).
Look in the `eg` folder of the rivescript-python distribution for an example
script that sets up a JavaScript language handler."""
# Allow them to delete a handler too.
if obj is None:
if language in self._handlers:
del self._handlers[language]
else:
self._handlers[language] = obj
def set_subroutine(self, name, code):
"""Define a Python object from your program.
This is equivalent to having an object defined in the RiveScript code, except
your Python code is defining it instead. `name` is the name of the object, and
`code` is a Python function (a `def`) that accepts rs,args as its parameters.
This method is only available if there is a Python handler set up (which there
is by default, unless you've called set_handler("python", None))."""
# Do we have a Python handler?
if 'python' in self._handlers:
self._handlers['python']._objects[name] = code
self._objlangs[name] = 'python'
else:
self._warn("Can't set_subroutine: no Python object handler!")
def set_global(self, name, value):
"""Set a global variable.
Equivalent to `! global` in RiveScript code. Set to None to delete."""
if value is None:
# Unset the variable.
if name in self._gvars:
del self._gvars[name]
self._gvars[name] = value
def set_variable(self, name, value):
"""Set a bot variable.
Equivalent to `! var` in RiveScript code. Set to None to delete."""
if value is None:
# Unset the variable.
if name in self._bvars:
del self._bvars[name]
self._bvars[name] = value
def set_substitution(self, what, rep):
"""Set a substitution.
Equivalent to `! sub` in RiveScript code. Set to None to delete."""
if rep is None:
# Unset the variable.
if what in self._subs:
del self._subs[what]
self._subs[what] = rep
def set_person(self, what, rep):
"""Set a person substitution.
Equivalent to `! person` in RiveScript code. Set to None to delete."""
if rep is None:
# Unset the variable.
if what in self._person:
del self._person[what]
self._person[what] = rep
def set_uservar(self, user, name, value):
"""Set a variable for a user."""
if user not in self._users:
self._users[user] = {"topic": "random"}
self._users[user][name] = value
def get_uservar(self, user, name):
"""Get a variable about a user.
If the user has no data at all, returns None. If the user doesn't have a value
set for the variable you want, returns the string 'undefined'."""
if user in self._users:
if name in self._users[user]:
return self._users[user][name]
else:
return "undefined"
else:
return None
def get_uservars(self, user=None):
"""Get all variables about a user (or all users).
If no username is passed, returns the entire user database structure. Otherwise,
only returns the variables for the given user, or None if none exist."""
if user is None:
# All the users!
return self._users
elif user in self._users:
# Just this one!
return self._users[user]
else:
# No info.
return None
def clear_uservars(self, user=None):
"""Delete all variables about a user (or all users).
If no username is passed, deletes all variables about all users. Otherwise, only
deletes all variables for the given user."""
if user is None:
# All the users!
self._users = {}
elif user in self._users:
# Just this one.
self._users[user] = {}
def freeze_uservars(self, user):
"""Freeze the variable state for a user.
This will clone and preserve a user's entire variable state, so that it can be
restored later with `thaw_uservars`."""
if user in self._users:
# Clone the user's data.
self._freeze[user] = copy.deepcopy(self._users[user])
else:
self._warn("Can't freeze vars for user " + user + ": not found!")
def thaw_uservars(self, user, action="thaw"):
"""Thaw a user's frozen variables.
The `action` can be one of the following options:
discard: Don't restore the user's variables, just delete the frozen copy.
keep: Keep the frozen copy after restoring the variables.
thaw: Restore the variables, then delete the frozen copy (default)."""
if user in self._freeze:
# What are we doing?
if action == "thaw":
# Thawing them out.
self.clear_uservars(user)
self._users[user] = copy.deepcopy(self._freeze[user])
del self._freeze[user]
elif action == "discard":
# Just discard the frozen copy.
del self._freeze[user]
elif action == "keep":
# Keep the frozen copy afterward.
self.clear_uservars(user)
self._users[user] = copy.deepcopy(self._freeze[user])
else:
self._warn("Unsupported thaw action")
else:
self._warn("Can't thaw vars for user " + user + ": not found!")
def last_match(self, user):
"""Get the last trigger matched for the user.
This will return the raw trigger text that the user's last message matched. If
there was no match, this will return None."""
return self.get_uservar(user, "__lastmatch__")
def trigger_info(self, trigger=None, dump=False):
"""Get information about a trigger.
Pass in a raw trigger to find out what file name and line number it appeared at.
This is useful for e.g. tracking down the location of the trigger last matched
by the user via last_match(). Returns a list of matching triggers, containing
their topics, filenames and line numbers. Returns None if there weren't
any matches found.
The keys in the trigger info is as follows:
* category: Either 'topic' (for normal) or 'thats' (for %Previous triggers)
* topic: The topic name
* trigger: The raw trigger text
* filename: The filename the trigger was found in.
* lineno: The line number the trigger was found on.
Pass in a true value for `dump`, and the entire syntax tracking
tree is returned."""
if dump:
return self._syntax
response = None
# Search the syntax tree for the trigger.
for category in self._syntax:
for topic in self._syntax[category]:
if trigger in self._syntax[category][topic]:
# We got a match!
if response is None:
response = list()
fname, lineno = self._syntax[category][topic][trigger]['trigger']
response.append(dict(
category=category,
topic=topic,
trigger=trigger,
filename=fname,
line=lineno,
))
return response
def current_user(self):
"""Retrieve the user ID of the current user talking to your bot.
This is mostly useful inside of a Python object macro to get the user ID of the
person who caused the object macro to be invoked (i.e. to set a variable for
that user from within the object).
This will return None if used outside of the context of getting a reply (i.e.
the value is unset at the end of the `reply()` method)."""
if self._current_user is None:
# They're doing it wrong.
self._warn("current_user() is meant to be used from within a Python object macro!")
return self._current_user
############################################################################
# Reply Fetching Methods #
############################################################################
def reply(self, user, msg, errors_as_replies=True):
"""Fetch a reply from the RiveScript brain."""
self._say("Get reply to [" + user + "] " + msg)
# Store the current user in case an object macro needs it.
self._current_user = user
# Format their message.
msg = self._format_message(msg)
reply = ''
# If the BEGIN block exists, consult it first.
if "__begin__" in self._topics:
begin = self._getreply(user, 'request', context='begin', ignore_object_errors=errors_as_replies)
# Okay to continue?
if '{ok}' in begin:
try:
reply = self._getreply(user, msg, ignore_object_errors=errors_as_replies)
except RiveScriptError as e:
if not errors_as_replies:
raise
reply = e.error_message
begin = begin.replace('{ok}', reply)
reply = begin
# Run more tag substitutions.
reply = self._process_tags(user, msg, reply, ignore_object_errors=errors_as_replies)
else:
# Just continue then.
try:
reply = self._getreply(user, msg, ignore_object_errors=errors_as_replies)
except RiveScriptError as e:
if not errors_as_replies:
raise
reply = e.error_message
# Save their reply history.
oldInput = self._users[user]['__history__']['input'][:8]
self._users[user]['__history__']['input'] = [msg]
self._users[user]['__history__']['input'].extend(oldInput)
oldReply = self._users[user]['__history__']['reply'][:8]
self._users[user]['__history__']['reply'] = [reply]
self._users[user]['__history__']['reply'].extend(oldReply)
# Unset the current user.
self._current_user = None
return reply
def _format_message(self, msg, botreply=False):
"""Format a user's message for safe processing."""
# Make sure the string is Unicode for Python 2.
if sys.version_info[0] < 3 and isinstance(msg, str):
msg = msg.decode('utf8')
# Lowercase it.
msg = msg.lower()
# Run substitutions on it.
msg = self._substitute(msg, "subs")
# In UTF-8 mode, only strip metacharacters and HTML brackets
# (to protect from obvious XSS attacks).
if self._utf8:
msg = re.sub(RE.utf8_meta, '', msg)
msg = re.sub(self.unicode_punctuation, '', msg)
# For the bot's reply, also strip common punctuation.
if botreply:
msg = re.sub(RE.utf8_punct, '', msg)
else:
# For everything else, strip all non-alphanumerics.
msg = self._strip_nasties(msg)
return msg
def _getreply(self, user, msg, context='normal', step=0, ignore_object_errors=True):
# Needed to sort replies?
if 'topics' not in self._sorted:
raise RepliesNotSortedError("You must call sort_replies() once you are done loading RiveScript documents")
# Initialize the user's profile?
if user not in self._users:
self._users[user] = {'topic': 'random'}
# Collect data on the user.
topic = self._users[user]['topic']
stars = []
thatstars = [] # For %Previous's.
reply = ''
# Avoid letting them fall into a missing topic.
if topic not in self._topics:
self._warn("User " + user + " was in an empty topic named '" + topic + "'")
topic = self._users[user]['topic'] = 'random'
# Avoid deep recursion.
if step > self._depth:
raise DeepRecursionError
# Are we in the BEGIN statement?
if context == 'begin':
topic = '__begin__'
# Initialize this user's history.
if '__history__' not in self._users[user]:
self._users[user]['__history__'] = {
'input': [
'undefined', 'undefined', 'undefined', 'undefined',
'undefined', 'undefined', 'undefined', 'undefined',
'undefined'
],
'reply': [
'undefined', 'undefined', 'undefined', 'undefined',
'undefined', 'undefined', 'undefined', 'undefined',
'undefined'
]
}
# More topic sanity checking.
if topic not in self._topics:
# This was handled before, which would mean topic=random and
# it doesn't exist. Serious issue!
raise NoDefaultRandomTopicError("no default topic 'random' was found")
# Create a pointer for the matched data when we find it.
matched = None
matchedTrigger = None
foundMatch = False
# See if there were any %Previous's in this topic, or any topic related
# to it. This should only be done the first time -- not during a
# recursive redirection. This is because in a redirection, "lastreply"
# is still gonna be the same as it was the first time, causing an
# infinite loop!
if step == 0:
allTopics = [topic]
if topic in self._includes or topic in self._lineage:
# Get all the topics!
allTopics = self._get_topic_tree(topic)
# Scan them all!
for top in allTopics:
self._say("Checking topic " + top + " for any %Previous's.")
if top in self._sorted["thats"]:
self._say("There is a %Previous in this topic!")
# Do we have history yet?
lastReply = self._users[user]["__history__"]["reply"][0]
# Format the bot's last reply the same way as the human's.
lastReply = self._format_message(lastReply, botreply=True)
self._say("lastReply: " + lastReply)
# See if it's a match.
for trig in self._sorted["thats"][top]:
botside = self._reply_regexp(user, trig)
self._say("Try to match lastReply (" + lastReply + ") to " + trig)
# Match??
match = re.match(botside, lastReply)
if match:
# Huzzah! See if OUR message is right too.
self._say("Bot side matched!")
thatstars = match.groups()
for subtrig in self._sorted["that_trig"][top][trig]:
humanside = self._reply_regexp(user, subtrig)
self._say("Now try to match " + msg + " to " + subtrig)
match = re.match(humanside, msg)
if match:
self._say("Found a match!")
matched = self._thats[top][trig][subtrig]
matchedTrigger = subtrig
foundMatch = True
# Get the stars!
stars = match.groups()
break
# Break if we found a match.
if foundMatch:
break
# Break if we found a match.
if foundMatch:
break
# Search their topic for a match to their trigger.
if not foundMatch:
for trig in self._sorted["topics"][topic]:
# Process the triggers.
regexp = self._reply_regexp(user, trig)
self._say("Try to match %r against %r (%r)" % (msg, trig, regexp))
# Python's regular expression engine is slow. Try a verbatim
# match if this is an atomic trigger.
isAtomic = self._is_atomic(trig)
isMatch = False
if isAtomic:
# Only look for exact matches, no sense running atomic triggers
# through the regexp engine.
if msg == trig:
isMatch = True
else:
# Non-atomic triggers always need the regexp.
match = re.match(regexp, msg)
if match:
# The regexp matched!
isMatch = True
# Collect the stars.
stars = match.groups()
if isMatch:
self._say("Found a match!")
# We found a match, but what if the trigger we've matched
# doesn't belong to our topic? Find it!
if trig not in self._topics[topic]:
# We have to find it.
matched = self._find_trigger_by_inheritance(topic, trig)
else:
# We do have it!
matched = self._topics[topic][trig]
foundMatch = True
matchedTrigger = trig
break
# Store what trigger they matched on. If their matched trigger is None,
# this will be too, which is great.
self._users[user]["__lastmatch__"] = matchedTrigger
if matched:
for nil in [1]:
# See if there are any hard redirects.
if matched["redirect"]:
self._say("Redirecting us to " + matched["redirect"])
redirect = self._process_tags(user, msg, matched["redirect"], stars, thatstars, step,
ignore_object_errors)
self._say("Pretend user said: " + redirect)
reply = self._getreply(user, redirect, step=(step + 1), ignore_object_errors=ignore_object_errors)
break
# Check the conditionals.
for con in sorted(matched["condition"]):
halves = re.split(RE.cond_split, matched["condition"][con])
if halves and len(halves) == 2:
condition = re.match(RE.cond_parse, halves[0])
if condition:
left = condition.group(1)
eq = condition.group(2)
right = condition.group(3)
potreply = halves[1]
self._say("Left: " + left + "; eq: " + eq + "; right: " + right + " => " + potreply)
# Process tags all around.
left = self._process_tags(user, msg, left, stars, thatstars, step, ignore_object_errors)
right = self._process_tags(user, msg, right, stars, thatstars, step, ignore_object_errors)
# Defaults?
if len(left) == 0:
left = 'undefined'
if len(right) == 0:
right = 'undefined'
self._say("Check if " + left + " " + eq + " " + right)
# Validate it.
passed = False
if eq == 'eq' or eq == '==':
if left == right:
passed = True
elif eq == 'ne' or eq == '!=' or eq == '<>':
if left != right:
passed = True
else:
# Gasp, dealing with numbers here...
try:
left, right = int(left), int(right)
if eq == '<':
if left < right:
passed = True
elif eq == '<=':
if left <= right:
passed = True
elif eq == '>':
if left > right:
passed = True
elif eq == '>=':
if left >= right:
passed = True
except:
self._warn("Failed to evaluate numeric condition!")
# How truthful?
if passed:
reply = potreply
break
# Have our reply yet?
if len(reply) > 0:
break
# Process weights in the replies.
bucket = []
for rep in sorted(matched["reply"]):
text = matched["reply"][rep]
weight = 1
match = re.match(RE.weight, text)
if match:
weight = int(match.group(1))
if weight <= 0:
self._warn("Can't have a weight <= 0!")
weight = 1
for i in range(0, weight):
bucket.append(text)
# Get a random reply.
reply = random.choice(bucket)
break
# Still no reply?
if not foundMatch:
raise NoMatchError
elif len(reply) == 0:
raise NoReplyError
self._say("Reply: " + reply)
# Process tags for the BEGIN block.
if context == "begin":
# BEGIN blocks can only set topics and uservars. The rest happen
# later!
reTopic = re.findall(RE.topic_tag, reply)
for match in reTopic:
self._say("Setting user's topic to " + match)
self._users[user]["topic"] = match
reply = reply.replace('{{topic={match}}}'.format(match=match), '')
reSet = re.findall(RE.set_tag, reply)
for match in reSet:
self._say("Set uservar " + str(match[0]) + "=" + str(match[1]))
self._users[user][match[0]] = match[1]
reply = reply.replace('<set {key}={value}>'.format(key=match[0], value=match[1]), '')
else:
# Process more tags if not in BEGIN.
reply = self._process_tags(user, msg, reply, stars, thatstars, step, ignore_object_errors)
return reply
def _substitute(self, msg, kind):
"""Run a kind of substitution on a message."""
# Safety checking.
if 'lists' not in self._sorted:
raise RepliesNotSortedError("You must call sort_replies() once you are done loading RiveScript documents")
if kind not in self._sorted["lists"]:
raise RepliesNotSortedError("You must call sort_replies() once you are done loading RiveScript documents")
# Get the substitution map.
subs = None
if kind == 'subs':
subs = self._subs
else:
subs = self._person
# Make placeholders each time we substitute something.
ph = []
i = 0
for pattern in self._sorted["lists"][kind]:
result = subs[pattern]
# Make a placeholder.
ph.append(result)
placeholder = "\x00%d\x00" % i
i += 1
cache = self._regexc[kind][pattern]
msg = re.sub(cache["sub1"], placeholder, msg)
msg = re.sub(cache["sub2"], placeholder + r'\1', msg)
msg = re.sub(cache["sub3"], r'\1' + placeholder + r'\2', msg)
msg = re.sub(cache["sub4"], r'\1' + placeholder, msg)
placeholders = re.findall(RE.placeholder, msg)
for match in placeholders:
i = int(match)
result = ph[i]
msg = msg.replace('\x00' + match + '\x00', result)
# Strip & return.
return msg.strip()
def _precompile_substitution(self, kind, pattern):
"""Pre-compile the regexp for a substitution pattern.
This will speed up the substitutions that happen at the beginning of
the reply fetching process. With the default brain, this took the
time for _substitute down from 0.08s to 0.02s"""
if pattern not in self._regexc[kind]:
qm = re.escape(pattern)
self._regexc[kind][pattern] = {
"qm": qm,
"sub1": re.compile(r'^' + qm + r'$'),
"sub2": re.compile(r'^' + qm + r'(\W+)'),
"sub3": re.compile(r'(\W+)' + qm + r'(\W+)'),
"sub4": re.compile(r'(\W+)' + qm + r'$'),
}
def _do_expand_array(self, array_name, depth=0):
""" Do recurrent array expansion, returning a set of keywords.
Exception is thrown when there are cyclical dependencies between
arrays or if the @array name references an undefined array."""
if depth > self._depth:
raise Exception("deep recursion detected")
if not array_name in self._arrays:
raise Exception("array '%s' not defined" % (array_name))
ret = list(self._arrays[array_name])
for array in self._arrays[array_name]:
if array.startswith('@'):
ret.remove(array)
expanded = self._do_expand_array(array[1:], depth+1)
ret.extend(expanded)
return set(ret)
def _expand_array(self, array_name):
""" Expand variables and return a set of keywords.
Warning is issued when exceptions occur."""
ret = self._arrays[array_name] if array_name in self._arrays else []
try:
ret = self._do_expand_array(array_name)
except Exception as e:
self._warn("Error expanding array '%s': %s" % (array_name, str(e)))
return ret
def _reply_regexp(self, user, regexp):
"""Prepares a trigger for the regular expression engine."""
if regexp in self._regexc["trigger"]:
# Already compiled this one!
return self._regexc["trigger"][regexp]
# If the trigger is simply '*' then the * there needs to become (.*?)
# to match the blank string too.
regexp = re.sub(RE.zero_star, r'<zerowidthstar>', regexp)
# Simple replacements.
regexp = regexp.replace('*', '(.+?)') # Convert * into (.+?)
regexp = regexp.replace('#', '(\d+?)') # Convert # into (\d+?)
regexp = regexp.replace('_', '(\w+?)') # Convert _ into (\w+?)
regexp = re.sub(r'\{weight=\d+\}', '', regexp) # Remove {weight} tags
regexp = regexp.replace('<zerowidthstar>', r'(.*?)')
# Optionals.
optionals = re.findall(RE.optionals, regexp)
for match in optionals:
parts = match.split("|")
new = []
for p in parts:
p = r'(?:\\s|\\b)+{}(?:\\s|\\b)+'.format(p)
new.append(p)
# If this optional had a star or anything in it, make it
# non-matching.
pipes = '|'.join(new)
pipes = re.sub(re.escape('(.+?)'), '(?:.+?)', pipes)
pipes = re.sub(re.escape('(\d+?)'), '(?:\d+?)', pipes)
pipes = re.sub(re.escape('([A-Za-z]+?)'), '(?:[A-Za-z]+?)', pipes)
regexp = re.sub(r'\s*\[' + re.escape(match) + '\]\s*',
'(?:' + pipes + r'|(?:\\s|\\b))', regexp)
# _ wildcards can't match numbers!
regexp = re.sub(RE.literal_w, r'[A-Za-z]', regexp)
# Filter in arrays.
arrays = re.findall(RE.array, regexp)
for array in arrays:
rep = ''
if array in self._arrays:
rep = r'(?:' + '|'.join(self._expand_array(array)) + ')'
regexp = re.sub(r'\@' + re.escape(array) + r'\b', rep, regexp)
# Filter in bot variables.
bvars = re.findall(RE.bot_tag, regexp)
for var in bvars:
rep = ''
if var in self._bvars:
rep = self._strip_nasties(self._bvars[var])
regexp = regexp.replace('<bot {var}>'.format(var=var), rep)
# Filter in user variables.
uvars = re.findall(RE.get_tag, regexp)
for var in uvars:
rep = ''
if var in self._users[user]:
rep = self._strip_nasties(self._users[user][var])
regexp = regexp.replace('<get {var}>'.format(var=var), rep)
# Filter in <input> and <reply> tags. This is a slow process, so only
# do it if we have to!
if '<input' in regexp or '<reply' in regexp:
for type in ['input', 'reply']:
tags = re.findall(r'<' + type + r'([0-9])>', regexp)
for index in tags:
rep = self._format_message(self._users[user]['__history__'][type][int(index) - 1])
regexp = regexp.replace('<{type}{index}>'.format(type=type, index=index), rep)
regexp = regexp.replace('<{type}>'.format(type=type),
self._format_message(self._users[user]['__history__'][type][0]))
# TODO: the Perl version doesn't do just <input>/<reply> in trigs!
return re.compile(r'^' + regexp + r'$')
def _precompile_regexp(self, trigger):
"""Precompile the regex for most triggers.
If the trigger is non-atomic, and doesn't include dynamic tags like
`<bot>`, `<get>`, `<input>/<reply>` or arrays, it can be precompiled
and save time when matching."""
if self._is_atomic(trigger):
return # Don't need a regexp for atomic triggers.
# Check for dynamic tags.
for tag in ["@", "<bot", "<get", "<input", "<reply"]:
if tag in trigger:
return # Can't precompile this trigger.
self._regexc["trigger"][trigger] = self._reply_regexp(None, trigger)
def _process_tags(self, user, msg, reply, st=[], bst=[], depth=0, ignore_object_errors=True):
"""Post process tags in a message."""
stars = ['']
stars.extend(st)
botstars = ['']
botstars.extend(bst)
if len(stars) == 1:
stars.append("undefined")
if len(botstars) == 1:
botstars.append("undefined")
# Tag shortcuts.
reply = reply.replace('<person>', '{person}<star>{/person}')
reply = reply.replace('<@>', '{@<star>}')
reply = reply.replace('<formal>', '{formal}<star>{/formal}')
reply = reply.replace('<sentence>', '{sentence}<star>{/sentence}')
reply = reply.replace('<uppercase>', '{uppercase}<star>{/uppercase}')
reply = reply.replace('<lowercase>', '{lowercase}<star>{/lowercase}')
# Weight and <star> tags.
reply = re.sub(RE.weight, '', reply) # Leftover {weight}s
if len(stars) > 0:
reply = reply.replace('<star>', stars[1])
reStars = re.findall(RE.star_tags, reply)
for match in reStars:
if int(match) < len(stars):
reply = reply.replace('<star{match}>'.format(match=match), stars[int(match)])
if len(botstars) > 0:
reply = reply.replace('<botstar>', botstars[1])
reStars = re.findall(RE.botstars, reply)
for match in reStars:
if int(match) < len(botstars):
reply = reply.replace('<botstar{match}>'.format(match=match), botstars[int(match)])
# <input> and <reply>
reply = reply.replace('<input>', self._users[user]['__history__']['input'][0])
reply = reply.replace('<reply>', self._users[user]['__history__']['reply'][0])
reInput = re.findall(RE.input_tags, reply)
for match in reInput:
reply = reply.replace('<input{match}>'.format(match=match),
self._users[user]['__history__']['input'][int(match) - 1])
reReply = re.findall(RE.reply_tags, reply)
for match in reReply:
reply = reply.replace('<reply{match}>'.format(match=match),
self._users[user]['__history__']['reply'][int(match) - 1])
# <id> and escape codes.
reply = reply.replace('<id>', user)
reply = reply.replace('\\s', ' ')
reply = reply.replace('\\n', "\n")
reply = reply.replace('\\#', '#')
# Random bits.
reRandom = re.findall(RE.random_tags, reply)
for match in reRandom:
output = ''
if '|' in match:
output = random.choice(match.split('|'))
else:
output = random.choice(match.split(' '))
reply = reply.replace('{{random}}{match}{{/random}}'.format(match=match), output)
# Person Substitutions and String Formatting.
for item in ['person', 'formal', 'sentence', 'uppercase', 'lowercase']:
matcher = re.findall(r'\{' + item + r'\}(.+?)\{/' + item + r'\}', reply)
for match in matcher:
output = None
if item == 'person':
# Person substitutions.
output = self._substitute(match, "person")
else:
output = self._string_format(match, item)
reply = reply.replace('{{{item}}}{match}{{/{item}}}'.format(item=item, match=match), output)
# Handle all variable-related tags with an iterative regex approach,
# to allow for nesting of tags in arbitrary ways (think <set a=<get b>>)
# Dummy out the <call> tags first, because we don't handle them right
# here.
reply = reply.replace("<call>", "{__call__}")
reply = reply.replace("</call>", "{/__call__}")
while True:
# This regex will match a <tag> which contains no other tag inside
# it, i.e. in the case of <set a=<get b>> it will match <get b> but
# not the <set> tag, on the first pass. The second pass will get the
# <set> tag, and so on.
match = re.search(RE.tag_search, reply)
if not match: break # No remaining tags!
match = match.group(1)
parts = match.split(" ", 1)
tag = parts[0].lower()
data = parts[1] if len(parts) > 1 else ""
insert = "" # Result of the tag evaluation
# Handle the tags.
if tag == "bot" or tag == "env":
# <bot> and <env> tags are similar.
target = self._bvars if tag == "bot" else self._gvars
if "=" in data:
# Setting a bot/env variable.
parts = data.split("=")
self._say("Set " + tag + " variable " + text_type(parts[0]) + "=" + text_type(parts[1]))
target[parts[0]] = parts[1]
else:
# Getting a bot/env variable.
insert = target.get(data, "undefined")
elif tag == "set":
# <set> user vars.
parts = data.split("=")
self._say("Set uservar " + text_type(parts[0]) + "=" + text_type(parts[1]))
self._users[user][parts[0]] = parts[1]
elif tag in ["add", "sub", "mult", "div"]:
# Math operator tags.
parts = data.split("=")
var = parts[0]
value = parts[1]
# Sanity check the value.
try:
value = int(value)
if var not in self._users[user]:
# Initialize it.
self._users[user][var] = 0
except:
insert = "[ERR: Math can't '{}' non-numeric value '{}']".format(tag, value)
# Attempt the operation.
try:
orig = int(self._users[user][var])
new = 0
if tag == "add":
new = orig + value
elif tag == "sub":
new = orig - value
elif tag == "mult":
new = orig * value
elif tag == "div":
new = orig / value
self._users[user][var] = new
except:
insert = "[ERR: Math couldn't '{}' to value '{}']".format(tag, self._users[user][var])
elif tag == "get":
insert = self._users[user].get(data, "undefined")
else:
# Unrecognized tag.
insert = "\x00{}\x01".format(match)
reply = reply.replace("<{}>".format(match), insert)
# Restore unrecognized tags.
reply = reply.replace("\x00", "<").replace("\x01", ">")
# Streaming code. DEPRECATED!
if '{!' in reply:
self._warn("Use of the {!...} tag is deprecated and not supported here.")
# Topic setter.
reTopic = re.findall(RE.topic_tag, reply)
for match in reTopic:
self._say("Setting user's topic to " + match)
self._users[user]["topic"] = match
reply = reply.replace('{{topic={match}}}'.format(match=match), '')
# Inline redirecter.
reRedir = re.findall(RE.redir_tag, reply)
for match in reRedir:
self._say("Redirect to " + match)
at = match.strip()
subreply = self._getreply(user, at, step=(depth + 1))
reply = reply.replace('{{@{match}}}'.format(match=match), subreply)
# Object caller.
reply = reply.replace("{__call__}", "<call>")
reply = reply.replace("{/__call__}", "</call>")
reCall = re.findall(r'<call>(.+?)</call>', reply)
for match in reCall:
parts = re.split(RE.ws, match)
output = ''
obj = parts[0]
args = []
if len(parts) > 1:
args = parts[1:]
# Do we know this object?
if obj in self._objlangs:
# We do, but do we have a handler for that language?
lang = self._objlangs[obj]
if lang in self._handlers:
# We do.
try:
output = self._handlers[lang].call(self, obj, user, args)
except python.PythonObjectError as e:
self._warn(str(e))
if not ignore_object_errors:
raise ObjectError(str(e))
output = RS_ERR_OBJECT
else:
if not ignore_object_errors:
raise ObjectError(RS_ERR_OBJECT_HANDLER)
output = RS_ERR_OBJECT_HANDLER
else:
if not ignore_object_errors:
raise ObjectError(RS_ERR_OBJECT_MISSING)
output = RS_ERR_OBJECT_MISSING
reply = reply.replace('<call>{match}</call>'.format(match=match), output)
return reply
def _string_format(self, msg, method):
"""Format a string (upper, lower, formal, sentence)."""
if method == "uppercase":
return msg.upper()
elif method == "lowercase":
return msg.lower()
elif method == "sentence":
return msg.capitalize()
elif method == "formal":
return string.capwords(msg)
############################################################################
# Topic inheritance Utility Methods #
############################################################################
def _topic_triggers(self, topic, triglvl, depth=0, inheritance=0, inherited=False):
"""Recursively scan a topic and return a list of all triggers."""
# Break if we're in too deep.
if depth > self._depth:
self._warn("Deep recursion while scanning topic inheritance")
# Important info about the depth vs inheritance params to this function:
# depth increments by 1 each time this function recursively calls itself.
# inheritance increments by 1 only when this topic inherits another
# topic.
#
# This way, '> topic alpha includes beta inherits gamma' will have this
# effect:
# alpha and beta's triggers are combined together into one matching
# pool, and then those triggers have higher matching priority than
# gamma's.
#
# The inherited option is True if this is a recursive call, from a topic
# that inherits other topics. This forces the {inherits} tag to be added
# to the triggers. This only applies when the top topic 'includes'
# another topic.
self._say("\tCollecting trigger list for topic " + topic + "(depth="
+ str(depth) + "; inheritance=" + str(inheritance) + "; "
+ "inherited=" + str(inherited) + ")")
# topic: the name of the topic
# triglvl: reference to self._topics or self._thats
# depth: starts at 0 and ++'s with each recursion
# Collect an array of triggers to return.
triggers = []
# Get those that exist in this topic directly.
inThisTopic = []
if topic in triglvl:
for trigger in triglvl[topic]:
inThisTopic.append(trigger)
# Does this topic include others?
if topic in self._includes:
# Check every included topic.
for includes in self._includes[topic]:
self._say("\t\tTopic " + topic + " includes " + includes)
triggers.extend(self._topic_triggers(includes, triglvl, (depth + 1), inheritance, True))
# Does this topic inherit others?
if topic in self._lineage:
# Check every inherited topic.
for inherits in self._lineage[topic]:
self._say("\t\tTopic " + topic + " inherits " + inherits)
triggers.extend(self._topic_triggers(inherits, triglvl, (depth + 1), (inheritance + 1), False))
# Collect the triggers for *this* topic. If this topic inherits any
# other topics, it means that this topic's triggers have higher
# priority than those in any inherited topics. Enforce this with an
# {inherits} tag.
if topic in self._lineage or inherited:
for trigger in inThisTopic:
self._say("\t\tPrefixing trigger with {inherits=" + str(inheritance) + "}" + trigger)
triggers.append("{inherits=" + str(inheritance) + "}" + trigger)
else:
triggers.extend(inThisTopic)
return triggers
def _find_trigger_by_inheritance(self, topic, trig, depth=0):
"""Locate the replies for a trigger in an inherited/included topic."""
# This sub was called because the user matched a trigger from the sorted
# array, but the trigger doesn't belong to their topic, and is instead
# in an inherited or included topic. This is to search for it.
# Prevent recursion.
if depth > self._depth:
self._warn("Deep recursion detected while following an inheritance trail!")
return None
# inheritance is more important than inclusion: triggers in one topic can
# override those in an inherited topic.
if topic in self._lineage:
for inherits in sorted(self._lineage[topic]):
# See if this inherited topic has our trigger.
if trig in self._topics[inherits]:
# Great!
return self._topics[inherits][trig]
else:
# Check what THAT topic inherits from.
match = self._find_trigger_by_inheritance(
inherits, trig, (depth + 1)
)
if match:
# Found it!
return match
# See if this topic has an "includes"
if topic in self._includes:
for includes in sorted(self._includes[topic]):
# See if this included topic has our trigger.
if trig in self._topics[includes]:
# Great!
return self._topics[includes][trig]
else:
# Check what THAT topic inherits from.
match = self._find_trigger_by_inheritance(
includes, trig, (depth + 1)
)
if match:
# Found it!
return match
# Don't know what else to do!
return None
def _get_topic_tree(self, topic, depth=0):
"""Given one topic, get the list of all included/inherited topics."""
# Break if we're in too deep.
if depth > self._depth:
self._warn("Deep recursion while scanning topic trees!")
return []
# Collect an array of all topics.
topics = [topic]
# Does this topic include others?
if topic in self._includes:
# Try each of these.
for includes in sorted(self._includes[topic]):
topics.extend(self._get_topic_tree(includes, depth + 1))
# Does this topic inherit others?
if topic in self._lineage:
# Try each of these.
for inherits in sorted(self._lineage[topic]):
topics.extend(self._get_topic_tree(inherits, depth + 1))
return topics
############################################################################
# Miscellaneous Private Methods #
############################################################################
def _is_atomic(self, trigger):
"""Determine if a trigger is atomic or not."""
# Atomic triggers don't contain any wildcards or parenthesis or anything
# of the sort. We don't need to test the full character set, just left
# brackets will do.
special = ['*', '#', '_', '(', '[', '<', '@']
for char in special:
if char in trigger:
return False
return True
def _word_count(self, trigger, all=False):
"""Count the words that aren't wildcards in a trigger."""
words = []
if all:
words = re.split(RE.ws, trigger)
else:
words = re.split(RE.wilds, trigger)
wc = 0 # Word count
for word in words:
if len(word) > 0:
wc += 1
return wc
def _strip_nasties(self, s):
"""Formats a string for ASCII regex matching."""
s = re.sub(RE.nasties, '', s)
return s
def _dump(self):
"""For debugging, dump the entire data structure."""
pp = pprint.PrettyPrinter(indent=4)
print("=== Variables ===")
print("-- Globals --")
pp.pprint(self._gvars)
print("-- Bot vars --")
pp.pprint(self._bvars)
print("-- Substitutions --")
pp.pprint(self._subs)
print("-- Person Substitutions --")
pp.pprint(self._person)
print("-- Arrays --")
pp.pprint(self._arrays)
print("=== Topic Structure ===")
pp.pprint(self._topics)
print("=== %Previous Structure ===")
pp.pprint(self._thats)
print("=== Includes ===")
pp.pprint(self._includes)
print("=== Inherits ===")
pp.pprint(self._lineage)
print("=== Sort Buffer ===")
pp.pprint(self._sorted)
print("=== Syntax Tree ===")
pp.pprint(self._syntax)
################################################################################
# Exception Classes #
################################################################################
class RiveScriptError(Exception):
"""RiveScript base exception class"""
def __init__(self, error_message=None):
super(RiveScriptError, self).__init__(error_message)
self.error_message = error_message
class NoMatchError(RiveScriptError):
"""No reply could be matched"""
def __init__(self):
super(NoMatchError, self).__init__(RS_ERR_MATCH)
class NoReplyError(RiveScriptError):
"""No reply could be found"""
def __init__(self):
super(NoReplyError, self).__init__(RS_ERR_REPLY)
class ObjectError(RiveScriptError):
"""An error occurred when executing a Python object"""
def __init__(self, error_message=RS_ERR_OBJECT):
super(ObjectError, self).__init__(error_message)
class DeepRecursionError(RiveScriptError):
"""Prevented an infinite loop / deep recursion, unable to retrieve a reply for this message"""
def __init__(self):
super(DeepRecursionError, self).__init__(RS_ERR_DEEP_RECURSION)
class NoDefaultRandomTopicError(Exception):
"""No default topic 'random' could be found, critical error"""
pass
class RepliesNotSortedError(Exception):
"""sort_replies() was not called after the RiveScript documents were loaded, critical error"""
pass
################################################################################
# Interactive Mode #
################################################################################
if __name__ == "__main__":
from interactive import interactive_mode
interactive_mode()
# vim:expandtab
|
[
"jaykumar.oza@jeppesen.com"
] |
jaykumar.oza@jeppesen.com
|
fecb95f2df1a15ec0d1133aa0f186e37532e7f1c
|
357ce8dbb7e2ebab438ae90a8f598ba625ee74a1
|
/perticks/api/models.py
|
b2bf85e2e850ce59d32e170e83561f33d1a78fcd
|
[] |
no_license
|
HealthHackAu2016/per-ticks
|
899870f0c3915bb8d0aed9fcfe609674934b1a76
|
03eeaf57ea7e8c1efc07a8ff48c59edc058f7b4d
|
refs/heads/master
| 2021-01-11T02:50:00.246122
| 2016-10-16T07:07:42
| 2016-10-16T07:07:42
| 70,917,456
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,645
|
py
|
from django.db import models
from django.contrib import admin
from django.core.validators import RegexValidator, EmailValidator
class BiteReport(models.Model):
# Validators
alphanumeric = RegexValidator(r'^[0-9]*$', 'Only numeric characters are allowed.')
validate_email = EmailValidator()
# Fields
id = models.AutoField(primary_key=True)
auth_id = models.CharField(max_length=20)
auth_code = models.CharField(max_length=20)
email = models.CharField(max_length=200, blank=True, validators=[validate_email])
phone = models.CharField(max_length=11, blank=True, validators=[alphanumeric])
allows_follow_up = models.BooleanField(default=False)
wants_reminder = models.BooleanField(default=False)
symptom_comments = models.TextField()
submission_date = models.DateField(auto_now_add=True)
bite_date = models.DateField()
lat = models.FloatField()
lon = models.FloatField()
bitten_before = models.BooleanField(default=False)
number_of_bites = models.IntegerField(default=1)
# travel
admin.site.register(BiteReport)
class HospitalData(models.Model):
numeric = RegexValidator(r'^[0-9]*$', 'Only numeric characters are allowed.')
hospital_name = models.CharField(max_length=128)
hospital_address = models.CharField(max_length=512)
hospital_telephone = models.CharField(max_length=11, blank=True, validators=[numeric])
admin.site.register(HospitalData)
class Reminders(models.Model):
report = models.ForeignKey(BiteReport)
reminder_date = models.DateField()
reminder_sent = models.BooleanField(default=False)
admin.site.register(Reminders)
|
[
"mail@trisreed.com"
] |
mail@trisreed.com
|
ac65b404dace4784df733dfdfafadcc28eb379aa
|
c135da511684bfb267a8bac5a84b3f032b2d7b26
|
/algorithms/delete-columns-to-make-sorted/DeleteColumnsToMakeSorted.py
|
b25bbcf217bb13ce0ca196ee9f751ee7ef66193b
|
[] |
no_license
|
hieudtrinh/coursera_python
|
0bc9841a8be7ea38b5fdf9bf1d2bcd6e40387e60
|
6bd01f898eca617ec3c6ad215f47f7f41265dd4f
|
refs/heads/main
| 2023-02-16T20:59:46.617531
| 2021-01-19T19:05:35
| 2021-01-19T19:05:35
| 319,189,486
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,249
|
py
|
import sys
from typing import List
class DeleteColumnsToMakeSorted:
def minDeletionSize(self, A: List[str]) -> int:
return sum(col != tuple(sorted(col)) for col in zip(*A))
def minDeletionSize1(self, A: List[str]) -> int:
res = 0
for pos in range(len(A[0])):
for word in range(len(A)-1):
if A[word][pos] > A[word+1][pos]:
res += 1
break
return res
def minDeletionSize2(self, A: List[str]) -> int:
strings = []
for i in range(0,len(A[0])):
temp = "".join([item[i] for item in A])
if "".join(sorted(temp)) == temp:
pass
else:
strings.append(1)
return len(strings)
def minDeletionSize3(self, A: List[str]) -> int:
l=[]
k=[]
for i in range(len(A[0])):
for j in range(len(A)):
l.append((A[j][i]))
if l != sorted(l):
k.append(i)
l=[]
return len(k)
def main(argv, arc):
A = ["cba", "daf", "ghi"]
solution = DeleteColumnsToMakeSorted()
solution.minDeletionSize(A)
if __name__ == '__main__':
main(sys.argv, len(sys.argv))
|
[
"user.namecd"
] |
user.namecd
|
cb87f2390f4328b284144e4fa1564341cb8bdcf7
|
c27c51f5c33e0431dbe7db6e18c21b249d476cfa
|
/OpenSource_Python_Code/nova-2013.2/nova/tests/api/ec2/test_faults.py
|
36cee0663bf4ff4b4c640f0b081a869d016d26a6
|
[
"Apache-2.0"
] |
permissive
|
bopopescu/Python_Stuff
|
9bef74e0db17bb5e3ba2d908ced01ee744820d80
|
9aa94a0fa5e4e802090c7b29ec88b840e304d9e5
|
refs/heads/master
| 2022-11-20T06:54:36.581623
| 2017-12-04T18:56:02
| 2017-12-04T18:56:02
| 282,171,169
| 0
| 0
| null | 2020-07-24T08:54:37
| 2020-07-24T08:54:36
| null |
UTF-8
|
Python
| false
| false
| 1,914
|
py
|
# vim: tabstop=4 shiftwidth=4 softtabstop=4
#
# 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.
import mox
import webob
from nova.api.ec2 import faults
from nova import test
from nova import wsgi
class TestFaults(test.NoDBTestCase):
"""Tests covering ec2 Fault class."""
def test_fault_exception(self):
# Ensure the status_int is set correctly on faults.
fault = faults.Fault(webob.exc.HTTPBadRequest(
explanation='test'))
self.assertTrue(isinstance(fault.wrapped_exc,
webob.exc.HTTPBadRequest))
def test_fault_exception_status_int(self):
# Ensure the status_int is set correctly on faults.
fault = faults.Fault(webob.exc.HTTPNotFound(explanation='test'))
self.assertEquals(fault.wrapped_exc.status_int, 404)
def test_fault_call(self):
# Ensure proper EC2 response on faults.
message = 'test message'
ex = webob.exc.HTTPNotFound(explanation=message)
fault = faults.Fault(ex)
req = wsgi.Request.blank('/test')
req.GET['AWSAccessKeyId'] = "test_user_id:test_project_id"
self.mox.StubOutWithMock(faults, 'ec2_error_response')
faults.ec2_error_response(mox.IgnoreArg(), 'HTTPNotFound',
message=message, status=ex.status_int)
self.mox.ReplayAll()
fault(req)
|
[
"thelma1944@gmail.com"
] |
thelma1944@gmail.com
|
c35a45aa07d805a1a36b6c9ba503f843f82fe68e
|
3554cedeca0e21a015534290a95d0a3930ff1cc1
|
/spider/spideOnDelegation.py
|
f6be5c0879481f57b3fb6d95aa692fb56bf285b8
|
[] |
no_license
|
baolintian/EZTrade
|
27d2329468f44bbedc610e0f8ab75be05ccfb247
|
72ee63fdcbfd37574a7734bd0991cff114481f79
|
refs/heads/main
| 2023-09-01T04:08:20.086976
| 2021-09-23T08:47:32
| 2021-09-23T08:47:32
| 390,328,602
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 15,650
|
py
|
import requests
import json
import time
import datetime
def get_token():
url = "http://i-2o0wkhxv.cloud.nelbds.org.cn:8180/api/app//dwf/v1/app/login?password=31c15919&userName=admin"
payload = {}
headers = {
'accept': '*/*',
'Authorization': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsImV4cCI6MTYyNTY3NTgyNH0.LkYBQnKfeDoEYJAMs4HOZae_Gq9nyu8kqOVP3T_qkkdmHb9pgRJbw4dlbxjEO69tFh7NQ3-vT-EHLTYo6b8Nyw'
}
response = requests.request("GET", url, headers=headers, data=payload)
return json.loads(response.text)["data"]
def get_delegation_info():
url = "http://i-2o0wkhxv.cloud.nelbds.org.cn:8180/api/app//dwf/v1/omf/entities/DelegateInfo/objects"
payload = json.dumps({
"condition": "and 1=1",
"pageSize": 10,
"startIndex": 0
})
token = get_token()
headers = {
'accept': '*/*',
'Authorization': token,
'Content-Type': 'application/json',
'Cookie': 'JSESSIONID=8BC976CB994C3656F9AE0E913A2521C9'
}
response = requests.request("POST", url, headers=headers, data=payload)
response = json.loads(response.text)
return response
def get_coin_info(class_name, condition):
url = "http://i-2o0wkhxv.cloud.nelbds.org.cn:8180/api/app//dwf/v1/omf/entities/"+class_name+"/objects"
payload = json.dumps({
"condition": condition,
"pageSize": 100,
"startIndex": 0
})
token = get_token()
headers = {
'accept': '*/*',
'Authorization': token,
'Content-Type': 'application/json',
'Cookie': 'JSESSIONID=8BC976CB994C3656F9AE0E913A2521C9'
}
response = requests.request("POST", url, headers=headers, data=payload)
response = json.loads(response.text)
return response
def delete_delegation_by_oid(class_name, oid):
url = "http://i-2o0wkhxv.cloud.nelbds.org.cn:8180/api/app//dwf/v1/omf/entities/"+class_name+"/objects-delete"
payload = json.dumps([
oid
])
token = get_token()
headers = {
'accept': '*/*',
'Authorization': token,
'Content-Type': 'application/json',
'Cookie': 'JSESSIONID=8BC976CB994C3656F9AE0E913A2521C9'
}
requests.request("POST", url, headers=headers, data=payload)
def create_transaction(class_name, message):
import requests
import json
url = "http://i-2o0wkhxv.cloud.nelbds.org.cn:8180/api/app//dwf/v1/omf/entities/"+class_name+"/objects-create"
payload = json.dumps([
message
])
token = get_token()
headers = {
'accept': '*/*',
'Authorization': token,
'Content-Type': 'application/json',
'Cookie': 'JSESSIONID=8BC976CB994C3656F9AE0E913A2521C9'
}
response = requests.request("POST", url, headers=headers, data=payload)
if response.status_code == 200:
return True
else:
return False
def get_instance_by_oid(class_name, oid):
import requests
import json
url = "http://i-2o0wkhxv.cloud.nelbds.org.cn:8180/api/app//dwf/v1/omf/entities/"+class_name+"/objects/oids"
payload = json.dumps([
oid
])
token = get_token()
headers = {
'accept': '*/*',
'Authorization': token,
'Content-Type': 'application/json'
}
response = requests.request("POST", url, headers=headers, data=payload)
return json.loads(response.text)
def edit_VirtualAccount_by_oid(class_name, obj):
url = "http://i-2o0wkhxv.cloud.nelbds.org.cn:8180/api/app//dwf/v1/omf/entities/"+class_name+"/objects-update?forceUpdate=false"
payload = json.dumps([
obj
])
token = get_token()
headers = {
'accept': '*/*',
'Authorization': token,
'Content-Type': 'application/json'
}
response = requests.request("POST", url, headers=headers, data=payload)
print(response.text)
def get_single_coin_info(class_name, condition):
url = "http://i-2o0wkhxv.cloud.nelbds.org.cn:8180/api/app//dwf/v1/omf/entities/"+class_name+"/objects"
payload = json.dumps({
"condition": condition,
"pageSize": 100
})
token = get_token()
headers = {
'accept': '*/*',
'Authorization': token,
'Content-Type': 'application/json'
}
response = requests.request("POST", url, headers=headers, data=payload)
return json.loads(response.text)
def edit_single_coin_hold(class_name, obj):
url = "http://i-2o0wkhxv.cloud.nelbds.org.cn:8180/api/app//dwf/v1/omf/entities/" + class_name + "/objects-update?forceUpdate=false"
payload = json.dumps([
obj
])
token = get_token()
headers = {
'accept': '*/*',
'Authorization': token,
'Content-Type': 'application/json'
}
response = requests.request("POST", url, headers=headers, data=payload)
while(True):
delegation_info = get_delegation_info()
# print(delegation_info)
# print(len(delegation_info["data"]))
delegation_info = delegation_info["data"]
# 获取各个币种的价格信息
coin_info = get_coin_info("CoinInfo", "and 1=1")
coin_info = coin_info["data"]
# print(coin_info)
coin_dict = {}
for i in range(len(coin_info)):
coin_name = coin_info[i]["coinName"]
coin_price = coin_info[i]["coinPrice"]
coin_dict[coin_name] = coin_price
# 对所有的委托进行处理
for i in range(len(delegation_info)):
print(delegation_info[i])
delegate_coin_name = delegation_info[i]["delegateCoinName"]
delegate_price = delegation_info[i]["delegatePrice"]
delegate_action = delegation_info[i]["delegateAction"]
delegate_number = delegation_info[i]["delegateAmount"]
delegate_oid = delegation_info[i]["oid"]
delegator_oid = delegation_info[i]["delegatorOID"]
# delegate_type = delegation_info[i]["delegateType"]
# 异常处理
if delegate_action != "BUY" and delegate_action != "SELL":
delete_delegation_by_oid("DelegateInfo", delegate_oid)
if delegate_coin_name in coin_dict.keys():
if delegate_action == "BUY" and delegate_price < coin_dict[delegate_coin_name]:
continue
if delegate_action == "SELL" and delegate_price > coin_dict[delegate_coin_name]:
continue
if delegate_action == "BUY":
transaction_message = {
"transactionCoinName": delegate_coin_name,
"transactionAmount": delegate_number,
"transactionPrice": delegate_price,
"transactionPersonOID": delegator_oid,
"transactionAction": delegate_action,
"transactionTime": str(int(time.mktime(datetime.datetime.now().timetuple()))*1000)
}
print("BUY")
print(transaction_message)
result = create_transaction("TransactionHistory", transaction_message)
if result:
# 增加或者修改持仓信息
user = get_instance_by_oid("VirtualAccount", delegator_oid)["data"][0]
user_oid = user["oid"]
user_tot = user["asset"]
user_coin_asset = user["coinAsset"]
user_cash = user["cash"]
user_frozenAsset = user["frozenAsset"]
user_usableAsset = user["usableAsset"]
user_frozenAsset = user_frozenAsset - delegate_number*delegate_price*(1+0.001)
user_coin_asset = user_coin_asset + delegate_number*coin_dict[delegate_coin_name]
user_cash = user_frozenAsset+user_usableAsset
user_tot = user_cash+user_coin_asset
# TODO: 更新收益率
obj = {
"oid": user_oid,
"asset": user_tot,
"coinAsset": user_coin_asset,
"cash": user_cash,
"frozenAsset": user_frozenAsset,
"usableAsset": user_usableAsset
# "delegatorOID": delegator_oid
}
edit_VirtualAccount_by_oid("VirtualAccount", obj)
# 增加或者修改持仓信息
hold_info = get_single_coin_info(r"SingleCoinInfo", "and obj.coinHolderOID = '"+str(user_oid)+r"'")
hold_info = hold_info["data"]
hold_coin_dict = {}
flag = False
for j in range(len(hold_info)):
if hold_info[j]["coinName"] == delegate_coin_name:
print("real update")
flag = True
coin_number = hold_info[j]["coinAmount"]
hold_price = hold_info[j]["coinHoldPrice"]
avg_price = hold_info[j]["coinAveragePrice"]
transaction_time = hold_info[j]["coinTime"]
usable_amount = hold_info[j]["coinUsableAmount"]
hold_price = (hold_price * coin_number + delegate_number * delegate_price) / (
coin_number + delegate_number)
avg_price = (hold_price*transaction_time+delegate_price)/(1+transaction_time)
transaction_time = transaction_time+1
coin_number = coin_number+delegate_number
usable_amount = usable_amount+delegate_number
obj = {
"oid": hold_info[j]["oid"],
"coinAmount": coin_number,
"coinHoldPrice": hold_price,
"coinAveragePrice": avg_price,
"coinTime": transaction_time,
"coinUsableAmount": usable_amount
}
edit_single_coin_hold("SingleCoinInfo", obj)
break
if flag == False:
obj = {
"coinAmount": delegate_number,
"coinHoldPrice": delegate_price,
"coinAveragePrice": delegate_price,
"coinTime": 1,
"coinName": delegate_coin_name,
"coinHolderOID": delegator_oid,
"coinUsableAmount": delegate_number
}
create_transaction("SingleCoinInfo", obj)
# 删除委托信息
delete_delegation_by_oid("DelegateInfo", delegate_oid)
if delegate_action == "SELL":
# 更改用户的资金
# 更改/删除用户持仓信息
# 创建交易记录
# 删除委托信息
transaction_message = {
# 包含SELL 和 AUTO SELL
"transactionAction": delegate_action,
"transactionCoinName": delegate_coin_name,
"transactionAmount": delegate_number,
"transactionPrice": delegate_price,
"transactionPersonOID": delegator_oid,
"transactionTime": str(int(time.mktime(datetime.datetime.now().timetuple())) * 1000)
}
print("SELL")
print(transaction_message)
result = create_transaction("TransactionHistory", transaction_message)
if result:
# 增加或者修改持仓信息
user = get_instance_by_oid("VirtualAccount", delegator_oid)["data"][0]
user_oid = user["oid"]
user_tot = user["asset"]
user_coin_asset = user["coinAsset"]
user_cash = user["cash"]
user_frozenAsset = user["frozenAsset"]
user_usableAsset = user["usableAsset"]
user_coin_asset = user_coin_asset - delegate_number * coin_dict[delegate_coin_name]
user_usableAsset = user_usableAsset+delegate_number * delegate_price*(1-0.001)
user_cash = user_frozenAsset + user_usableAsset
user_tot = user_cash + user_coin_asset
# TODO: 更新收益率
obj = {
"oid": user_oid,
"asset": user_tot,
"coinAsset": user_coin_asset,
"cash": user_cash,
"frozenAsset": user_frozenAsset,
"usableAsset": user_usableAsset
}
edit_VirtualAccount_by_oid("VirtualAccount", obj)
# 增加或者修改持仓信息
hold_info = get_single_coin_info(r"SingleCoinInfo",
"and obj.coinHolderOID = '" + str(user_oid) + r"'")
hold_info = hold_info["data"]
hold_coin_dict = {}
for j in range(len(hold_info)):
if hold_info[j]["coinName"] == delegate_coin_name:
print("real update")
# flag = True
coin_number = hold_info[j]["coinAmount"]
hold_price = hold_info[j]["coinHoldPrice"]
avg_price = hold_info[j]["coinAveragePrice"]
transaction_time = hold_info[j]["coinTime"]
usable_amount = hold_info[j]["coinUsableAmount"]
if(coin_number - delegate_number != 0):
hold_price = (hold_price * coin_number - delegate_number * delegate_price) / (
coin_number - delegate_number)
else:
hold_price = 0
avg_price = (hold_price * transaction_time + delegate_price) / (1 + transaction_time)
transaction_time = transaction_time+1
coin_number = coin_number - delegate_number
print("剩余币种")
print(coin_number)
if(coin_number <= 0.0001):
# 直接删除持仓记录
delete_delegation_by_oid("SingleCoinInfo", hold_info[j]["oid"])
else:
usable_amount = usable_amount
obj = {
"oid": hold_info[j]["oid"],
"coinAmount": coin_number,
"coinHoldPrice": hold_price,
"coinAveragePrice": avg_price,
"coinTime": transaction_time,
"coinUsableAmount": usable_amount
}
edit_single_coin_hold("SingleCoinInfo", obj)
break
# 删除委托信息
delete_delegation_by_oid("DelegateInfo", delegate_oid)
time.sleep(2)
|
[
"tianbaolin1@gmail.com"
] |
tianbaolin1@gmail.com
|
e5f7852757d20d9217562defb3d22da0c1893cb6
|
5e809acc62b080f1adad2c34e647241cdc5ad297
|
/myenv/bin/markdown_py
|
fa2c63491a1647ccda5e1725538898c521cfc6a8
|
[
"MIT"
] |
permissive
|
RootenberG/My-blog-project
|
f520af79a2f3eb416b3dadee46813a812ce9d53d
|
7ef4670cfa9d54d9345d52ca008aae5fed5605bc
|
refs/heads/master
| 2020-08-15T20:04:29.478049
| 2020-02-08T21:57:46
| 2020-02-08T21:57:46
| 215,400,930
| 0
| 0
|
MIT
| 2019-10-30T20:54:38
| 2019-10-15T21:34:30
|
Python
|
UTF-8
|
Python
| false
| false
| 255
|
#!/home/den/devspace/My-blog-project/myenv/bin/python3.7
# -*- coding: utf-8 -*-
import re
import sys
from markdown.__main__ import run
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(run())
|
[
"savichevdenis244@gmail.com"
] |
savichevdenis244@gmail.com
|
|
50317930bb9698c10a56bf2f5e1c9bf9b3f6f36b
|
38f619c6210d77d156c6a9ae2850b30b1d96fd79
|
/gen_winning_paths.py
|
3a4c2ee73521727270a7dd6a1f62200d8b43fc07
|
[] |
no_license
|
ofraam/GTTT
|
3c2d0fc55e17c794b9e4f7078640e86d73b780fc
|
83e4c4f0d4c667bc719239d79daa1ab9417e7d1e
|
refs/heads/master
| 2021-01-20T04:46:15.095923
| 2019-08-08T15:57:04
| 2019-08-08T15:57:04
| 89,724,782
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,938
|
py
|
if __name__ == "__main__":
dimension = 10
streak = 5
filename = "examples/board_"+str(dimension)+"_"+str(streak)+".txt"
row = 1
col = 1
winning_paths = []
#check horizontal
for row in range(1,dimension+1):
for col in range(1, dimension + 1):
i = (row-1)*dimension+col
if (i+(streak-1))<=(dimension*row): #horizontal paths
path = []
for s in range(0,streak):
path.append(i+s)
winning_paths.append(path)
if (i+(streak-1)*dimension)<=dimension*(dimension-1)+col: #vertical paths
path = []
for s in range(0,streak):
path.append(i+(s)*dimension)
winning_paths.append(path)
if (i+(streak-1)*(dimension+1))<=dimension*dimension: #diagonal right paths
if (i + (streak - 1) * (dimension + 1)) <= (row + (streak - 1)) * dimension: # diagonal right paths
path = []
for s in range(0,streak):
path.append(i+(s)*(dimension+1))
winning_paths.append(path)
if (i+(streak-1)*(dimension-1))<=dimension*dimension: #diagonal right paths
if (i + (streak - 1) * (dimension - 1)) > ((row-1) + (streak - 1)) * dimension: # diagonal right paths
path = []
for s in range(0,streak):
path.append(i+(s)*(dimension-1))
winning_paths.append(path)
with open(filename, "w") as text_file:
text_file.write(str(dimension*dimension))
text_file.write("\n")
for path in winning_paths:
for i in range(len(path)):
text_file.write(str(path[i]))
if i<len(path)-1:
text_file.write(" ")
text_file.write("\n")
print winning_paths
|
[
"oamir@seas.harvard.edu"
] |
oamir@seas.harvard.edu
|
af319737ac47b4c0bdc71afb813cb1635135868b
|
8e8f09667b7aae2e8e35e6c130e426aedbe3d565
|
/apps/destination/migrations/0005_auto_20170719_1338.py
|
251620743aee30278a95641ae10effdf2bac21ae
|
[] |
no_license
|
TripHub/_API
|
c33e8b08f43cc45b5d7ed788aaaaed714fdcf802
|
dad85e34e826d951a971088bc77c8e63b403f01f
|
refs/heads/master
| 2021-06-24T05:50:28.964085
| 2017-08-06T11:01:50
| 2017-08-06T11:01:50
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 883
|
py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.11 on 2017-07-19 13:38
from __future__ import unicode_literals
import django.contrib.postgres.fields.jsonb
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('destination', '0004_auto_20170705_1325'),
]
operations = [
migrations.RemoveField(
model_name='destination',
name='address',
),
migrations.RemoveField(
model_name='destination',
name='latitude',
),
migrations.RemoveField(
model_name='destination',
name='longitude',
),
migrations.AddField(
model_name='destination',
name='data',
field=django.contrib.postgres.fields.jsonb.JSONField(default={}),
preserve_default=False,
),
]
|
[
"Ben@hadfieldfamily.co.uk"
] |
Ben@hadfieldfamily.co.uk
|
d1716fb4ec493d1b89f08262b63cd4a0ccee5a05
|
af8cb7ec280573b58a16ae6e92a938828ffc052d
|
/Recurrent_network/Recurrent_network2.py
|
d0ec9b7584d15643b4ca53b345c7e20dda0a2df4
|
[] |
no_license
|
ninetailskim/Tensorflow_Tutorial
|
65e44ecce976fdd469fc8c34b0d1ed975e5b9989
|
cb7d8fcd12e57de80f5cded091e014b425e3467f
|
refs/heads/master
| 2021-07-02T22:46:55.503318
| 2017-09-23T08:31:03
| 2017-09-23T08:31:03
| 104,552,409
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,383
|
py
|
'''
static_rnn
input :A length T list of inputs, each a Tensor of shape [batch_size, input_size], or a nested tuple of such elements.
x = tf.unstack(x, timesteps, 1)
output : A list of outputs (one for each input), or a nested tuple of such elements.
output[-1]
'''
import tensorflow as tf
from tensorflow.contrib import rnn
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('/tmp/data', one_hot=True)
learning_rate = 0.001
training_steps = 10000
batch_size = 128
display_step = 200
num_input = 28
timesteps = 28
num_hidden = 128
num_classes = 10
X = tf.placeholder(tf.float32, [None, timesteps, num_input])
Y = tf.placeholder(tf.float32, [None, num_classes])
weights={
'out':tf.get_variable('weight_out', [num_hidden, num_classes], tf.float32)
}
biases = {
'out':tf.get_variable('biases_out', [num_classes], tf.float32)
}
def RNN(x, weight, biases):
x = tf.unstack(x, timesteps, 1)
lstm_cell = rnn.BasicLSTMCell(num_hidden, forget_bias=1.0)
#h0 = lstm_cell.zero_state(batch_size, tf.float32)
output, state = rnn.static_rnn(lstm_cell, x, dtype=tf.float32)
out = tf.nn.bias_add(tf.matmul(output[-1], weight['out']), biases['out'])
return out
logits = RNN(X, weights, biases)
prediction = tf.nn.softmax(logits)
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=Y))
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for step in range(1, training_steps + 1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
batch_x = batch_x.reshape((-1, timesteps, num_input))
_, loss, acc = sess.run([train_op, loss_op, accuracy],feed_dict={X:batch_x, Y:batch_y})
if step % display_step == 0:
print("Step:", step, "loss:", loss, "Accuracy:", acc)
print("Training finished!")
test_len = 128
test_data = mnist.test.images[:test_len].reshape((-1, timesteps, num_input))
test_label = mnist.test.labels[:test_len]
print("Test:", sess.run(accuracy, feed_dict={X:test_data, Y:test_label}))
|
[
"ninetailsyeon@163.com"
] |
ninetailsyeon@163.com
|
ff06d12c1f57c1abcc60e770b2ba9375591bfd04
|
7ba5e9e271f1199582500bc40334ce4dfff03698
|
/manage.py
|
e1e56792c1b390bb6ae5ff85c7019e487c5a3838
|
[] |
no_license
|
R1Ng0-1488/four-a-docker
|
9ffc0cd2004b06ea9b9871eb2aad778854083bf5
|
2b66ed5baa6df777391343f82c5512b90689b981
|
refs/heads/master
| 2023-04-13T05:04:34.600023
| 2021-04-27T09:23:25
| 2021-04-27T09:23:25
| 357,534,439
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 629
|
py
|
#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys
def main():
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'fourArest.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line(sys.argv)
if __name__ == '__main__':
main()
|
[
"57253219+R1Ng0-1488@users.noreply.github.com"
] |
57253219+R1Ng0-1488@users.noreply.github.com
|
886183df918841571dc3a1914dbf86b3af70ee3d
|
9ce345af50e58596564a942471c19b17fec5b1b7
|
/venv/Scripts/pip-script.py
|
8ff319223bd8fc27e410ac0fa90fd31b50f27fd7
|
[] |
no_license
|
ArsenTrynko/Python_lab10
|
2f6a4379a53c66f365a85f9db6c818128690d17f
|
8da5281ef60e40e43b31e7a38e1d3739d926b552
|
refs/heads/master
| 2020-05-31T00:47:41.813171
| 2019-06-03T16:26:38
| 2019-06-03T16:26:38
| 190,041,659
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 406
|
py
|
#!C:\Users\MI\PycharmProjects\Lab10\venv\Scripts\python.exe
# EASY-INSTALL-ENTRY-SCRIPT: 'pip==19.0.3','console_scripts','pip'
__requires__ = 'pip==19.0.3'
import re
import sys
from pkg_resources import load_entry_point
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(
load_entry_point('pip==19.0.3', 'console_scripts', 'pip')()
)
|
[
"jarkodara@gmail.com"
] |
jarkodara@gmail.com
|
bcaf5aa98c8edf969dc67d07dbc2b241654d3d1d
|
fb7f04ffbdcdf4f5aa7c0e6ccf83f7671ef10770
|
/server.py
|
cadfd74d1f7a4b805332831f5238f54f81f48b2d
|
[] |
no_license
|
Bthelisma/LandingPage
|
8ce348ece186c57e98d00cb5fdde8149587accae
|
87fdf0bed1ad0e7a978095c47d9ba3ea860b74b7
|
refs/heads/master
| 2020-03-22T18:59:26.266574
| 2018-07-10T23:14:03
| 2018-07-10T23:14:03
| 140,496,511
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 307
|
py
|
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def index():
return render_template("index.html")
@app.route('/ninjas')
def ninjas():
return render_template("ninjas.html")
@app.route('/dojos')
def dojos():
return render_template("dojos.html")
app.run(debug=True)
|
[
"contactjerseysure@gmail.com"
] |
contactjerseysure@gmail.com
|
9800c7757cdf7213dc56c1006e976f8cfdd3b3f5
|
19e84b3ea7944811b6fd113309b8a7c7b5ae33ba
|
/oec/db_data/views.py
|
cf69e179543b30faae5c5f12887affeaeba22e82
|
[] |
no_license
|
fxcebx/oec
|
cf9c4cfaa3b4d92d4cbd3539ff94b7f910209167
|
cbba5d7513f63cdb5dc761146db784f2a9879ea7
|
refs/heads/master
| 2020-12-06T20:41:17.105920
| 2015-10-10T03:01:56
| 2015-10-10T03:01:56
| 44,028,188
| 0
| 0
| null | 2015-10-25T22:06:13
| 2015-10-10T21:01:46
|
CSS
|
UTF-8
|
Python
| false
| false
| 5,007
|
py
|
from flask import Blueprint, request, jsonify, make_response, g
from oec import db
from oec.utils import make_query
from oec.db_attr.models import Yo as Attr_yo
from oec.db_data import hs92_models
from oec.db_data import hs96_models
from oec.db_data import hs02_models
from oec.db_data import hs07_models
from oec.db_data import sitc_models
from oec.decorators import crossdomain
mod = Blueprint('data', __name__, url_prefix='/<any("sitc","hs","hs92","hs96","hs02","hs07"):classification>')
@mod.url_value_preprocessor
def get_product_classification_models(endpoint, values):
g.locale="en"
classification = values.pop('classification')
g.prod_classification = classification
if classification == "hs" or classification == "hs92":
g.prod_models = hs92_models
elif classification == "hs96":
g.prod_models = hs96_models
elif classification == "hs02":
g.prod_models = hs02_models
elif classification == "hs07":
g.prod_models = hs07_models
elif classification == "sitc":
g.prod_models = sitc_models
g.output_depth = request.args.get("output_depth")
############################################################
# ----------------------------------------------------------
# 2 variable views
#
############################################################
@mod.route('/<trade_flow>/all/<origin_id>/all/all/')
@mod.route('/<trade_flow>/<year>/<origin_id>/all/all/')
@mod.route('/<trade_flow>/<year>/show/all/all/')
@crossdomain(origin='*')
def yo(**kwargs):
q = db.session.query(Attr_yo, getattr(g.prod_models, "Yo")) \
.filter(Attr_yo.origin_id == getattr(g.prod_models, "Yo").origin_id) \
.filter(Attr_yo.year == getattr(g.prod_models, "Yo").year)
return make_response(make_query(q, request.args, g.locale, getattr(g.prod_models, "Yo"), **kwargs))
@mod.route('/<trade_flow>/all/all/<dest_id>/all/')
@mod.route('/<trade_flow>/<year>/all/<dest_id>/all/')
@mod.route('/<trade_flow>/<year>/all/show/all/')
@crossdomain(origin='*')
def yd(**kwargs):
return make_response(make_query(getattr(g.prod_models, "Yd"), request.args, g.locale, **kwargs))
@mod.route('/<trade_flow>/all/all/all/<prod_id>/')
@mod.route('/<trade_flow>/<year>/all/all/<prod_id>/')
@mod.route('/<trade_flow>/<year>/all/all/show/')
@crossdomain(origin='*')
def yp(**kwargs):
return make_response(make_query(getattr(g.prod_models, "Yp"), \
request.args, g.locale, classification=g.prod_classification, \
output_depth=g.output_depth, **kwargs))
############################################################
# ----------------------------------------------------------
# 3 variable views
#
############################################################
@mod.route('/<trade_flow>/all/<origin_id>/show/all/')
@mod.route('/<trade_flow>/<year>/<origin_id>/show/all/')
@crossdomain(origin='*')
def yod(**kwargs):
return make_response(make_query(getattr(g.prod_models, "Yod"), request.args, g.locale, **kwargs))
@mod.route('/<trade_flow>/all/<origin_id>/all/show/')
@mod.route('/<trade_flow>/<year>/<origin_id>/all/show/')
@crossdomain(origin='*')
def yop(**kwargs):
return make_response(make_query(getattr(g.prod_models, "Yop"), \
request.args, g.locale, classification=g.prod_classification, \
output_depth=g.output_depth, **kwargs))
@mod.route('/<trade_flow>/all/show/all/<prod_id>/')
@mod.route('/<trade_flow>/<year>/show/all/<prod_id>/')
@crossdomain(origin='*')
def yop_dest(**kwargs):
return make_response(make_query(getattr(g.prod_models, "Yop"), \
request.args, g.locale, classification=g.prod_classification, **kwargs))
@mod.route('/<trade_flow>/all/all/<dest_id>/show/')
@mod.route('/<trade_flow>/<year>/all/<dest_id>/show/')
@crossdomain(origin='*')
def ydp(**kwargs):
return make_response(make_query(getattr(g.prod_models, "Ydp"), \
request.args, g.locale, classification=g.prod_classification, \
output_depth=g.output_depth, **kwargs))
############################################################
# ----------------------------------------------------------
# 4 variable views
#
############################################################
@mod.route('/<trade_flow>/all/<origin_id>/<dest_id>/all/')
@mod.route('/<trade_flow>/<year>/<origin_id>/<dest_id>/all/')
@mod.route('/<trade_flow>/all/<origin_id>/<dest_id>/show/')
@mod.route('/<trade_flow>/<year>/<origin_id>/<dest_id>/show/')
@crossdomain(origin='*')
def yodp(**kwargs):
return make_response(make_query(getattr(g.prod_models, "Yodp"), \
request.args, g.locale, classification=g.prod_classification, \
output_depth=g.output_depth, **kwargs))
@mod.route('/<trade_flow>/all/<origin_id>/show/<prod_id>/')
@mod.route('/<trade_flow>/<year>/<origin_id>/show/<prod_id>/')
@crossdomain(origin='*')
def yodp_dest(**kwargs):
return make_response(make_query(getattr(g.prod_models, "Yodp"), \
request.args, g.locale, classification=g.prod_classification, **kwargs))
|
[
"alexandersimoes@gmail.com"
] |
alexandersimoes@gmail.com
|
79dbeaf0b944d391662e5119f73dae9367fe504f
|
bd26284c804ded76f21d25b9c7a355304428e4d7
|
/2/2-4. Cartpole.py
|
e5c1e31c1bf0433c30db2eb054cf87b7c840057f
|
[
"Apache-2.0"
] |
permissive
|
Wonjuseo/Project101
|
0c93171bbd6ab86dfbc32f474e12e7b7229db4da
|
8c49601e34f56035acd198a09428fa71f6606ca7
|
refs/heads/master
| 2021-01-19T23:25:40.658736
| 2018-07-02T13:45:03
| 2018-07-02T13:45:03
| 88,979,764
| 8
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 633
|
py
|
# Cart Pole example
import gym
# Environment
env = gym.make('CartPole-v0')
env.reset()
# Parameters
random_episodes = 0
reward_sum = 0
while random_episodes < 10:
# Rendering
env.render()
# Get action
action = env.action_space.sample()
# Update state, reward, done
observation, reward, done, _ = env.step(action)
print(observation,reward,done)
# Add reward
reward_sum += reward
# if it fails, the results were shown
if done:
random_episodes += 1
print("Reward for this episode was:", reward_sum)
reward_sum = 0
env.reset()
|
[
"noreply@github.com"
] |
noreply@github.com
|
68e6812af340c1592f989fbc771b1033a152cf91
|
582660ae9d3c21010042bd6262e421a2a6e94e61
|
/python/introduction/python_if-else/python_if_else.py
|
a8c09703dd210c9a51a596580200c33614db93c6
|
[] |
no_license
|
tim-mccabe/hacker-rank
|
5e12bcd9baabb94c98bca8ef906063092279f4a2
|
61480d2f7b4d567ac48d526417afd7dbc5a2329e
|
refs/heads/master
| 2023-01-30T11:57:23.041756
| 2020-12-10T20:50:52
| 2020-12-10T20:50:52
| 320,064,591
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 392
|
py
|
#!/bin/python3
import math
import os
import random
import re
import sys
if __name__ == '__main__':
n = int(input().strip())
if int(n) % 2 == 1:
print('Weird')
if 2 <= int(n) <= 5 and int(n) % 2 == 0:
print('Not Weird')
if 6 <= int(n) <= 20 and int(n) % 2 == 0:
print('Weird')
if int(n) > 20 and int(n) % 2 == 0:
print('Not Weird')
|
[
"timmccabe44@gmail.com"
] |
timmccabe44@gmail.com
|
1af07f337196fda10e15701549e6243804b7e233
|
9467b65606bdeb2ff1417267728f95aac96e2bd9
|
/p24.py
|
ab13db0c38f7d99139ac1511ae52bfb7916bcb43
|
[] |
no_license
|
prince3453/python
|
a7d1e46f0669f50ac4ca74aa11a393a3f69c9471
|
ca31d46dd885b619e4d7cefbf83b813684afad93
|
refs/heads/master
| 2020-12-06T13:31:13.314451
| 2020-05-16T05:53:00
| 2020-05-16T05:53:00
| 232,474,854
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 901
|
py
|
class Bank:
def __init__(self, balance):
self.balance = balance
self.methods = [self.printBalance,self.deposite,self.withdraw]
def printBalance(self):
print("Current Balance:",self.balance)
def inputAmount(self):
return float(input("Enter Amount:"))
def deposite(self):
amount = self.inputAmount()
self.balance += amount
self.printBalance()
def withdraw(self):
amount = self.inputAmount()
if self.balance - amount <= 500:
print("The Account Does Not Has Sufficient Balance.")
else:
self.balance -= amount
self.printBalance()
var = Bank(10000)
while True:
choice = int(input("select \n1. for checking balance.\n2. for deposite.\n3. for withdrawal.\n4. for exit."))
if choice == 4: break
else:
var.methods[choice-1]()
|
[
"noreply@github.com"
] |
noreply@github.com
|
e62a576701748974d99d413ad69f0fa9b0b33e9b
|
21c77c2ff4d5fbb982943a22abd46a18a804621c
|
/flow_control/your_name.py
|
68fec85da56a05006fdeaef5eb410d09972eb812
|
[] |
no_license
|
foleymd/boring-stuff
|
56592f576da19238de5c742b78c34d86688b6319
|
d81f10f801a512c38a713344a2fe1d8b5b7e5a09
|
refs/heads/main
| 2023-01-05T19:21:31.248420
| 2020-10-22T20:24:10
| 2020-10-22T20:24:10
| 302,201,760
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 294
|
py
|
# break example
name = ''
while True:
print('Please type your name.')
name = input()
if name == 'your name':
break
print('Thank you!')
# continue example
spam = 0
while spam < 5:
spam = spam + 1
if spam == 3:
continue
print('spam is ' + str(spam))
|
[
"foleymd@gmail.com"
] |
foleymd@gmail.com
|
955bb168de6e1ab256033fbf68a95eb968b92146
|
180d93304e80e485be81dd06dbbc8a3be0c34365
|
/exporter/opentelemetry-exporter-opencensus/tests/test_otcollector_trace_exporter.py
|
222a94d60b3b85e025d4607da7ff392a7c43b338
|
[
"Apache-2.0"
] |
permissive
|
marcosflobo/opentelemetry-python
|
dbb26b04dbbc813696dbc3f8b3db4543af8cf68c
|
81d80aab5d4fd23d0d75b223d482d491ac86f006
|
refs/heads/main
| 2023-05-04T21:51:24.754989
| 2021-05-06T01:51:26
| 2021-05-06T01:51:26
| 365,263,246
| 1
| 0
|
Apache-2.0
| 2021-05-07T14:40:16
| 2021-05-07T14:40:15
| null |
UTF-8
|
Python
| false
| false
| 11,824
|
py
|
# Copyright The OpenTelemetry 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.
import unittest
from unittest import mock
import grpc
from google.protobuf.timestamp_pb2 import Timestamp
from opencensus.proto.trace.v1 import trace_pb2
import opentelemetry.exporter.opencensus.util as utils
from opentelemetry import trace as trace_api
from opentelemetry.exporter.opencensus.trace_exporter import (
OpenCensusSpanExporter,
translate_to_collector,
)
from opentelemetry.sdk import trace
from opentelemetry.sdk.resources import SERVICE_NAME, Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SpanExportResult
from opentelemetry.trace import TraceFlags
# pylint: disable=no-member
class TestCollectorSpanExporter(unittest.TestCase):
def test_constructor(self):
mock_get_node = mock.Mock()
patch = mock.patch(
"opentelemetry.exporter.opencensus.util.get_node",
side_effect=mock_get_node,
)
trace_api.set_tracer_provider(
TracerProvider(
resource=Resource.create({SERVICE_NAME: "testServiceName"})
)
)
host_name = "testHostName"
client = grpc.insecure_channel("")
endpoint = "testEndpoint"
with patch:
exporter = OpenCensusSpanExporter(
host_name=host_name,
endpoint=endpoint,
client=client,
)
self.assertIs(exporter.client, client)
self.assertEqual(exporter.endpoint, endpoint)
mock_get_node.assert_called_with("testServiceName", host_name)
def test_get_collector_span_kind(self):
result = utils.get_collector_span_kind(trace_api.SpanKind.SERVER)
self.assertIs(result, trace_pb2.Span.SpanKind.SERVER)
result = utils.get_collector_span_kind(trace_api.SpanKind.CLIENT)
self.assertIs(result, trace_pb2.Span.SpanKind.CLIENT)
result = utils.get_collector_span_kind(trace_api.SpanKind.CONSUMER)
self.assertIs(result, trace_pb2.Span.SpanKind.SPAN_KIND_UNSPECIFIED)
result = utils.get_collector_span_kind(trace_api.SpanKind.PRODUCER)
self.assertIs(result, trace_pb2.Span.SpanKind.SPAN_KIND_UNSPECIFIED)
result = utils.get_collector_span_kind(trace_api.SpanKind.INTERNAL)
self.assertIs(result, trace_pb2.Span.SpanKind.SPAN_KIND_UNSPECIFIED)
def test_proto_timestamp_from_time_ns(self):
result = utils.proto_timestamp_from_time_ns(12345)
self.assertIsInstance(result, Timestamp)
self.assertEqual(result.nanos, 12345)
# pylint: disable=too-many-locals
# pylint: disable=too-many-statements
def test_translate_to_collector(self):
trace_id = 0x6E0C63257DE34C926F9EFCD03927272E
span_id = 0x34BF92DEEFC58C92
parent_id = 0x1111111111111111
base_time = 683647322 * 10 ** 9 # in ns
start_times = (
base_time,
base_time + 150 * 10 ** 6,
base_time + 300 * 10 ** 6,
)
durations = (50 * 10 ** 6, 100 * 10 ** 6, 200 * 10 ** 6)
end_times = (
start_times[0] + durations[0],
start_times[1] + durations[1],
start_times[2] + durations[2],
)
span_context = trace_api.SpanContext(
trace_id,
span_id,
is_remote=False,
trace_flags=TraceFlags(TraceFlags.SAMPLED),
trace_state=trace_api.TraceState([("testkey", "testvalue")]),
)
parent_span_context = trace_api.SpanContext(
trace_id, parent_id, is_remote=False
)
other_context = trace_api.SpanContext(
trace_id, span_id, is_remote=False
)
event_attributes = {
"annotation_bool": True,
"annotation_string": "annotation_test",
"key_float": 0.3,
}
event_timestamp = base_time + 50 * 10 ** 6
event = trace.Event(
name="event0",
timestamp=event_timestamp,
attributes=event_attributes,
)
link_attributes = {"key_bool": True}
link_1 = trace_api.Link(
context=other_context, attributes=link_attributes
)
link_2 = trace_api.Link(
context=parent_span_context, attributes=link_attributes
)
span_1 = trace._Span(
name="test1",
context=span_context,
parent=parent_span_context,
events=(event,),
links=(link_1,),
kind=trace_api.SpanKind.CLIENT,
)
span_2 = trace._Span(
name="test2",
context=parent_span_context,
parent=None,
kind=trace_api.SpanKind.SERVER,
)
span_3 = trace._Span(
name="test3",
context=other_context,
links=(link_2,),
parent=span_2.get_span_context(),
)
otel_spans = [span_1, span_2, span_3]
otel_spans[0].start(start_time=start_times[0])
otel_spans[0].set_attribute("key_bool", False)
otel_spans[0].set_attribute("key_string", "hello_world")
otel_spans[0].set_attribute("key_float", 111.22)
otel_spans[0].set_attribute("key_int", 333)
otel_spans[0].set_status(trace_api.Status(trace_api.StatusCode.OK))
otel_spans[0].end(end_time=end_times[0])
otel_spans[1].start(start_time=start_times[1])
otel_spans[1].set_status(
trace_api.Status(
trace_api.StatusCode.ERROR,
{"test", "val"},
)
)
otel_spans[1].end(end_time=end_times[1])
otel_spans[2].start(start_time=start_times[2])
otel_spans[2].end(end_time=end_times[2])
output_spans = translate_to_collector(otel_spans)
self.assertEqual(len(output_spans), 3)
self.assertEqual(
output_spans[0].trace_id, b"n\x0cc%}\xe3L\x92o\x9e\xfc\xd09''."
)
self.assertEqual(
output_spans[0].span_id, b"4\xbf\x92\xde\xef\xc5\x8c\x92"
)
self.assertEqual(
output_spans[0].name, trace_pb2.TruncatableString(value="test1")
)
self.assertEqual(
output_spans[1].name, trace_pb2.TruncatableString(value="test2")
)
self.assertEqual(
output_spans[2].name, trace_pb2.TruncatableString(value="test3")
)
self.assertEqual(
output_spans[0].start_time.seconds,
int(start_times[0] / 1000000000),
)
self.assertEqual(
output_spans[0].end_time.seconds, int(end_times[0] / 1000000000)
)
self.assertEqual(output_spans[0].kind, trace_api.SpanKind.CLIENT.value)
self.assertEqual(output_spans[1].kind, trace_api.SpanKind.SERVER.value)
self.assertEqual(
output_spans[0].parent_span_id, b"\x11\x11\x11\x11\x11\x11\x11\x11"
)
self.assertEqual(
output_spans[2].parent_span_id, b"\x11\x11\x11\x11\x11\x11\x11\x11"
)
self.assertEqual(
output_spans[0].status.code,
trace_api.StatusCode.OK.value,
)
self.assertEqual(len(output_spans[0].tracestate.entries), 1)
self.assertEqual(output_spans[0].tracestate.entries[0].key, "testkey")
self.assertEqual(
output_spans[0].tracestate.entries[0].value, "testvalue"
)
self.assertEqual(
output_spans[0].attributes.attribute_map["key_bool"].bool_value,
False,
)
self.assertEqual(
output_spans[0]
.attributes.attribute_map["key_string"]
.string_value.value,
"hello_world",
)
self.assertEqual(
output_spans[0].attributes.attribute_map["key_float"].double_value,
111.22,
)
self.assertEqual(
output_spans[0].attributes.attribute_map["key_int"].int_value, 333
)
self.assertEqual(
output_spans[0].time_events.time_event[0].time.seconds, 683647322
)
self.assertEqual(
output_spans[0]
.time_events.time_event[0]
.annotation.description.value,
"event0",
)
self.assertEqual(
output_spans[0]
.time_events.time_event[0]
.annotation.attributes.attribute_map["annotation_bool"]
.bool_value,
True,
)
self.assertEqual(
output_spans[0]
.time_events.time_event[0]
.annotation.attributes.attribute_map["annotation_string"]
.string_value.value,
"annotation_test",
)
self.assertEqual(
output_spans[0]
.time_events.time_event[0]
.annotation.attributes.attribute_map["key_float"]
.double_value,
0.3,
)
self.assertEqual(
output_spans[0].links.link[0].trace_id,
b"n\x0cc%}\xe3L\x92o\x9e\xfc\xd09''.",
)
self.assertEqual(
output_spans[0].links.link[0].span_id,
b"4\xbf\x92\xde\xef\xc5\x8c\x92",
)
self.assertEqual(
output_spans[0].links.link[0].type,
trace_pb2.Span.Link.Type.TYPE_UNSPECIFIED,
)
self.assertEqual(
output_spans[1].status.code,
trace_api.StatusCode.ERROR.value,
)
self.assertEqual(
output_spans[2].links.link[0].type,
trace_pb2.Span.Link.Type.PARENT_LINKED_SPAN,
)
self.assertEqual(
output_spans[0]
.links.link[0]
.attributes.attribute_map["key_bool"]
.bool_value,
True,
)
def test_export(self):
mock_client = mock.MagicMock()
mock_export = mock.MagicMock()
mock_client.Export = mock_export
host_name = "testHostName"
collector_exporter = OpenCensusSpanExporter(
client=mock_client, host_name=host_name
)
trace_id = 0x6E0C63257DE34C926F9EFCD03927272E
span_id = 0x34BF92DEEFC58C92
span_context = trace_api.SpanContext(
trace_id,
span_id,
is_remote=False,
trace_flags=TraceFlags(TraceFlags.SAMPLED),
)
otel_spans = [
trace._Span(
name="test1",
context=span_context,
kind=trace_api.SpanKind.CLIENT,
)
]
result_status = collector_exporter.export(otel_spans)
self.assertEqual(SpanExportResult.SUCCESS, result_status)
# pylint: disable=unsubscriptable-object
export_arg = mock_export.call_args[0]
service_request = next(export_arg[0])
output_spans = getattr(service_request, "spans")
output_node = getattr(service_request, "node")
self.assertEqual(len(output_spans), 1)
self.assertIsNotNone(getattr(output_node, "library_info"))
self.assertIsNotNone(getattr(output_node, "service_info"))
output_identifier = getattr(output_node, "identifier")
self.assertEqual(
getattr(output_identifier, "host_name"), "testHostName"
)
|
[
"noreply@github.com"
] |
noreply@github.com
|
4e303dd29190aa0d67c81ae34f62c8efeeaa0d0a
|
b17af89152a7305efb915da7c856c744e7dbd4f0
|
/Dict_Project01_NumericIntegrasjon/F6_SendData.py
|
da51e5ba8dbeb3ed8133bee03f93e93dbcebc84e
|
[] |
no_license
|
EspenEig/Bachelor2021-vedlegg
|
6bb8e9efa84710500855f6129ce8f706b16bd690
|
2893f41e9e92f757360fe7d85dc03fd51d497f39
|
refs/heads/main
| 2023-05-01T12:34:45.403503
| 2021-05-12T16:31:59
| 2021-05-12T16:31:59
| 358,355,290
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 529
|
py
|
import json
def SendData(robot, measurements, online):
data = {}
for key in measurements:
if key == "zeroTime" or key == "ts":
continue
data[key] = (measurements[key][-1])
if online:
msg = json.dumps(data)
robot["connection"].send(msg)
if not robot["connection"].recv(3) == b"ack":
print("No data ack")
robot["out_file"].write("{},{},{},{}\n".format(
data["light"],
data["time"],
data["flow"],
data["volume"]))
|
[
"54357741+EspenEig@users.noreply.github.com"
] |
54357741+EspenEig@users.noreply.github.com
|
bf4f8be8ccdd998f8098cbf3f6605a7b524c9816
|
f92722620b74644ee0f2e1a7461d4330ea3374da
|
/blog/migrations/0001_initial.py
|
7ade040810ee75b4aa619f2bb513df02743ad060
|
[] |
no_license
|
designwithabhishek/mywebsite
|
c01e2784b733a681f215cac1c449a98554ca8cb0
|
4aa0593cb750330921de4367e2a389c4918845a1
|
refs/heads/master
| 2023-05-11T10:12:24.617089
| 2019-06-25T17:36:08
| 2019-06-25T17:36:08
| 200,085,766
| 0
| 0
| null | 2023-04-21T20:35:26
| 2019-08-01T16:37:09
|
HTML
|
UTF-8
|
Python
| false
| false
| 835
|
py
|
# Generated by Django 2.2.2 on 2019-06-23 04:53
import datetime
from django.db import migrations, models
from django.utils.timezone import utc
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Post',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('title', models.CharField(max_length=50)),
('author', models.CharField(max_length=50)),
('created', models.DateTimeField(verbose_name=datetime.datetime(2019, 6, 23, 4, 53, 36, 984687, tzinfo=utc))),
('content', models.TextField()),
('image', models.ImageField(upload_to='')),
],
),
]
|
[
"designwithabhishek1996.com"
] |
designwithabhishek1996.com
|
9ae24c0c1c39be6cfa372b401d1b1ebdd5bd2035
|
d15be7017a8d28ad351d2872fdf36b8638a60abd
|
/Solutions/week01/word_counter.py
|
a35bc79b42b58ad6bf3ccc3b99120b527f4f46df
|
[] |
no_license
|
shadydealer/Python-101
|
60ebdd098d38de45bede35905a378e8311e6891a
|
9ec2dccd61f54f4ff8f86fe6dd26cd7dd06f570d
|
refs/heads/master
| 2021-04-15T11:42:57.712723
| 2018-06-04T10:32:30
| 2018-06-04T10:32:30
| 126,197,141
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 761
|
py
|
word = input()
rows, cols = map(int, input().split())
def get_input():
"""get_input() -> 2D array"""
matrix = []
for i in range(rows):
matrix.append(input().split())
# for subset in matrix:
# print(subset)
return matrix
move_x =[-1,0,1]
move_y =[-1,0,1]
def is_valid_index(x,y):
"""is_valid_index(int, int) -> bool"""
if x >= 0 and y >= 0 and x < cols and y < rows:
return True
return False
def count_occurance(matrix, x,y, str_ind):
"""count_occurance(2D array, string) -> unsigned int"""
for y in range(matrix):
for x in range(matrix[i]): #matrix_char
for k in range(word): #word_char
if matrix[y][x] == word[k]:
y+=move_y[j]
x+=move_x[i]
else:
y-=move_y[j]*k
x-=move_x[i]*k
matrix = get_input()
|
[
"shady"
] |
shady
|
dfab9c98e6e8c2274dad941069669ae7f05d9833
|
15f438d029528a978383f24f85035c911e314b72
|
/scripts/tile.py
|
4265e245943caf8bebb807cdee81181b01d0187c
|
[
"MIT"
] |
permissive
|
rg314/autoballs
|
91d11315a61d4c088b099744301b3f1b68eecc93
|
21fab5c810f18c0d50c23051928d3bb86fbc6941
|
refs/heads/main
| 2023-05-30T11:48:52.901933
| 2021-06-23T14:48:27
| 2021-06-23T14:48:27
| 341,683,921
| 1
| 0
|
MIT
| 2021-03-18T23:28:23
| 2021-02-23T20:39:55
|
Python
|
UTF-8
|
Python
| false
| false
| 2,397
|
py
|
import os
import glob
import cv2
import matplotlib.pyplot as plt
import numpy as np
import math
size = 512
tile_size = (size, size)
offset = (size, size)
image_types = 'data'
origin_path = os.path.abspath(os.path.join(f'train_data/{image_types}/*', os.pardir))
images = glob.glob(origin_path+'/imgs/*.tif')
masks = [x.replace(f'imgs/img_', 'masks/img_') for x in images]
data = [(x, y) for (x, y) in list(zip(images, masks)) if os.path.exists(x) and os.path.exists(y)]
images, masks = zip(*data)
x = []
y = []
idx = 0
non_zero = 0
for img_n, mask_n in list(zip(images, masks)):
mask = cv2.imread(mask_n)
mask = (mask > 255//2) * 255
img = cv2.imread(img_n)
mask = np.asarray(mask).astype('uint8')
mask = mask[:,:,0]
img_shape = img.shape
# cv2.imwrite('test.tif', mask)
# print(mask)
if mask.shape[:2] == img.shape[:2]:
for i in range(int(math.ceil(img_shape[0]/(offset[1] * 1.0)))):
for j in range(int(math.ceil(img_shape[1]/(offset[0] * 1.0)))):
cropped_img = img[offset[1]*i:min(offset[1]*i+tile_size[1], img_shape[0]), offset[0]*j:min(offset[0]*j+tile_size[0], img_shape[1])]
cropped_mask = mask[offset[1]*i:min(offset[1]*i+tile_size[1], img_shape[0]), offset[0]*j:min(offset[0]*j+tile_size[0], img_shape[1])]
#
path = os.getcwd() + f'/train_data/data_tile_{size}/imgs'
if not os.path.exists(path):
os.makedirs(path)
imtgt = 'img_'+str(idx).zfill(5)+'.tif'
img_target = os.path.join(path, imtgt)
path = os.getcwd() + f'/train_data/data_tile_{size}/masks'
if not os.path.exists(path):
os.makedirs(path)
mskgt = imtgt
mask_target = os.path.join(path, mskgt)
# # print(cropped_img.shape, img_target)
# # print(cropped_mask.shape, mask_target)
cv2.imwrite(img_target, cropped_img)
cv2.imwrite(mask_target, ~cropped_mask)
if np.sum(cropped_mask) > 0:
non_zero += 1
idx += 1
print(f'Total {non_zero} out of {idx} which is {(non_zero*100/idx):.2f} %')
|
[
"ryan.greenhalgh@hotmail.co.uk"
] |
ryan.greenhalgh@hotmail.co.uk
|
019e5dd75cb9ff5d93826aea9822c1224063626a
|
3a7b0262d408c8faad77d0710d0bee91e27643b9
|
/Major_Requirements.py
|
a91f9661064cb93b0d8670f6a5c2951172039976
|
[] |
no_license
|
fmixson/testfulldegree
|
c1a13eb89001b017e7800304a3197d042a7e234b
|
de013a7f2171d66ab6a9fd4ed6a1604b53ef79d5
|
refs/heads/main
| 2023-06-27T23:08:22.016373
| 2021-08-08T20:07:37
| 2021-08-08T20:07:37
| 394,053,091
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 6,400
|
py
|
import pandas as pd
class MajorRequirements:
# major_requirements_dataframe = pd.read_csv("C:/Users/family/Desktop/Programming/English_PlanA_GE.csv")
# major_requirements_dataframe = pd.read_csv("C:/Users/family/Desktop/Programming/Copy of COMM_AA.csv")
# major_requirements_dict = {}
def __init__(self, revised_course_list, completed_ge_courses, major_requirements):
self.major_requirements = major_requirements
self.revised_course_list = revised_course_list
self.completed_ge_courses = completed_ge_courses
self.major_course_dict = {}
self.major_courses_list = []
self.major_courses_list2 = []
self.major_units_list = []
self.major_units_dict = {}
self.area_units_dict = {}
self.major_requirements_dict = {}
self.major_no_courses_requirement_dict = {}
# self.discipline_list = []
# self.discipline_set = set()
def _two_disciplines(self, course_key, total_area_units, total_units):
discipline = course_key.split()
discipline = discipline[0]
disc = False
# print('area units', total_area_units, 'total units', total_units - 3)
if total_area_units == (total_units - 3):
unique_disciplines = set(self.discipline_list)
# print(len(unique_disciplines))
# print('unique', unique_disciplines)
if len(unique_disciplines) < 2:
if discipline in unique_disciplines:
disc = True
else:
self.discipline_list.append(discipline)
else:
self.discipline_list.append(discipline)
# print('discipline list', self.discipline_list)
return disc
def _three_disciplines(self, course_key, total_area_units, total_units):
discipline = course_key.split()
discipline = discipline[0]
disc = False
# print('area units', total_area_units, 'total units', total_units - 6)
if total_area_units >= (total_units - 6):
unique_disciplines = set(self.discipline_list)
# print(len(unique_disciplines))
# print('unique', unique_disciplines)
if len(unique_disciplines) < 3:
if len(unique_disciplines) == 2:
self.discipline_list.append(discipline)
elif unique_disciplines == 1:
if discipline in unique_disciplines:
disc = True
else:
self.discipline_list.append(discipline)
else:
self.discipline_list.append(discipline)
return disc
def major_courses_completed(self, area_name, total_units, number_of_disciplines=1):
proficiency_list = ['Writing_Proficiency', 'Math_Proficiency', 'Health_Proficiency', 'Reading_Proficiency']
major_requirements_dataframe = pd.read_csv(self.major_requirements)
self.major_courses_list2 = []
total_area_units = 0
area_units_list = []
ge_course_list = []
self.major_requirements_dict[area_name] = total_units
print('total units', total_units)
if total_units == '':
pass
else:
if total_units < 3:
self.major_no_courses_requirement_dict[area_name] = 1
else:
self.major_no_courses_requirement_dict[area_name] = total_units / 3
disc = False
self.discipline_list = []
self.discipline_set = set()
# print('maj course no', self.major_no_courses_requirement_dict)
# print('maj req dict', self.major_requirements_dict)
for key in self.completed_ge_courses:
if key not in proficiency_list:
ge_course_list.append(self.completed_ge_courses[key])
for i in range(len(major_requirements_dataframe[area_name])):
ge_course = False
major_course = False
if total_area_units < total_units:
for course_key in self.revised_course_list:
if course_key == major_requirements_dataframe.loc[i, area_name]:
if course_key in ge_course_list:
ge_course = True
if course_key in self.major_courses_list:
major_course = True
if not major_course:
if number_of_disciplines > 1:
if number_of_disciplines == 2:
disc = MajorRequirements._two_disciplines(self, course_key=course_key,
total_area_units=total_area_units,
total_units=total_units)
elif number_of_disciplines == 3:
disc = MajorRequirements._three_disciplines(self, course_key=course_key,
total_area_units=total_area_units,
total_units=total_units)
if not disc:
self.area_units_dict[area_name] = self.revised_course_list[course_key]
self.major_courses_list.append(course_key)
self.major_courses_list2.append(course_key)
self.major_course_dict[area_name] = self.major_courses_list2
# print('dict under',self.major_course_dict)
area_units_list.append(self.revised_course_list[course_key])
if not ge_course:
self.major_units_list.append(self.revised_course_list[course_key])
total_area_units = sum(area_units_list)
self.area_units_dict[area_name] = total_area_units
# print('maj course dict', self.major_course_dict)
return self.major_requirements_dict, self.major_course_dict, self.major_no_courses_requirement_dict
|
[
"noreply@github.com"
] |
noreply@github.com
|
a3832a608ada34da7f6cc1b6ee7f96711396596b
|
00b2e5b0e600dccf0857e00b5710005062df92e3
|
/Fatima/fatima_raman.py
|
3abb8f47a90baebde4c4833d5c9befe4a28ee767
|
[] |
no_license
|
NMI-BMNT/auswertung
|
bf933046df3db729a3769fc50ce8c047d8a86177
|
b9017ac6745764fc4ddf63c9d982a21e30777885
|
refs/heads/master
| 2022-01-10T12:41:10.416401
| 2018-05-23T11:48:55
| 2018-05-23T11:48:55
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 7,036
|
py
|
import os
import numpy as np
import scipy.ndimage as ndimage
import scipy.ndimage.filters as filters
import scipy.optimize as opt
from scipy.optimize import curve_fit, basinhopping
import scipy.sparse as sparse
from scipy.special import *
from plotsettings import *
import matplotlib.pyplot as plt
from matplotlib.patches import Polygon
import seaborn as sns
from skimage.feature import peak_local_max
from skimage.morphology import watershed
from skimage.filters import threshold_otsu
import re
import scipy.signal as signal
import peakutils as pu
def lorentz(x, amplitude, x0, sigma):
g = (amplitude*2/(np.pi*sigma))/(1+4*np.square((x-x0)/sigma))
return g.ravel()
def gauss(x, amplitude, x0, sigma):
g = amplitude/sigma * np.sqrt(4*np.log(2)/np.pi)*np.exp(-4*np.log(2)*np.square((x-x0)/sigma))
return g.ravel()
# https://www.webpages.uidaho.edu/brauns/vibspect1.pdf
def asymvoigt(x, amplitude, x0, sigma, a , f):
sigma = 2 * sigma/(1 + np.exp(a*(x-x0)) )
g = f*lorentz(x,amplitude,x0,sigma)+(1-f)*gauss(x,amplitude,x0,sigma)
return g.ravel()
def fit_fun(x, amp, x0, sigma,a,f):
return asymvoigt(x, amp, x0, sigma,a,f)
path = '/home/sei/Raman/Fatima3/'
savedir = path + 'plots/'
peak_pos = [1085,1590]
search_width = 100 # cm^-1
try:
os.mkdir(savedir)
except:
pass
files = []
for file in os.listdir(path):
if re.search(r"\.(txt)$", file) is not None:
files.append(file)
print(files)
#file = files[0]
k_max = np.zeros((len(files),len(peak_pos)))
c_max = np.zeros((len(files),len(peak_pos)))
labels = np.array([])
for i,file in enumerate(files):
print(file)
k, counts = np.loadtxt(path + file, unpack=True)
counts = signal.savgol_filter(counts, 31, 1, mode='interp')
base = pu.baseline(counts, 11, max_it=10000, tol=0.00001)
counts -= base
#newfig(0.9)
plt.plot(k, counts, linewidth=1)
# plt.plot(k, bl, linewidth=1)
# plt.plot(wl[mask], filtered[mask], color="black", linewidth=0.6)
plt.ylabel(r'$I_{\nu}\, /\, counts$')
plt.xlabel(r'$wavenumber\, /\, cm^{-1}$')
# plt.xlim((minwl, maxwl))
# plt.plot(wl, counts)
plt.tight_layout()
#plt.show()
plt.savefig(savedir + file[:-4] + ".pdf", dpi=300)
plt.close()
for j,peak in enumerate(peak_pos):
mask = (k <= peak + search_width) & (k >= peak - search_width)
c1 = counts[mask]
k1 = k[mask]
max_ind = np.argmax(c1)
k_max[i,j] = k1[max_ind]
c_max[i,j] = c1[max_ind]
labels = np.append(labels,file[:-6])
print(c_max)
sort = np.argsort(labels)
labels = labels[sort]
k_max = k_max[sort,:]
c_max = c_max[sort,:]
print(labels)
label = np.unique(labels)
print(label)
for l in label:
mask = labels == l
plt.scatter(k_max[mask], c_max[mask])
plt.savefig(path + "scatter.pdf", dpi=300)
plt.close()
mean = np.zeros((len(label),len(peak_pos)))
err = np.zeros((len(label),len(peak_pos)))
for i,l in enumerate(label):
mask = labels == l
for j in range(len(peak_pos)):
mean[i,j] = np.mean(c_max[mask,j])
err[i,j] = np.std(c_max[mask,j])
print(mean)
print(mean[:,0].ravel())
print(np.arange(0,mean.shape[0],1))
for i in range(mean.shape[1]):
plt.bar(np.arange(0,mean.shape[0],1)*mean.shape[1]+(i+1),mean[:,i].ravel(),yerr=err[:,i].ravel())
plt.xticks((np.arange(0,mean.shape[0],1)*mean.shape[1]+(mean.shape[1]+1)/2), label)
plt.savefig(path + "bar.pdf", dpi=300)
plt.close()
print('-> Writing measured values to file')
with open(path + "raman.csv", 'w') as f:
f.write("label,")
for j in range(mean.shape[1]):
f.write("mean"+str(peak_pos[j])+",err"+str(peak_pos[j])+",")
f.write("\r\n")
for i in range(len(label)):
f.write( label[i] + ",")
for j in range(mean.shape[1]):
f.write( str(mean[i,j])+ "," + str(err[i,j])+"," )
f.write("\r\n")
mean = np.zeros((len(label),len(counts)))
err = np.zeros((len(label),len(counts)))
for i, l in enumerate(label):
buf = []
for j,file in enumerate(files):
if file[:-6] == l:
k, counts = np.loadtxt(path + file, unpack=True)
#counts = signal.savgol_filter(counts, 31, 1, mode='interp')
#base = pu.baseline(counts, 11, max_it=10000, tol=0.00001)
#counts -= base
buf.append(counts)
buf = np.array(buf)
print(buf.shape)
mean[i, :] = np.mean(buf,axis=0)
err[i, :] = np.std(buf,axis=0)
fig, ax = newfig(0.9)
colors = plt.rcParams["axes.prop_cycle"].by_key()["color"]
legend = ["A: 30 min","B: 30 min","C: 90 min","D: 90 min"]
print(label)
print(legend)
for i, l in enumerate(label):
poly = np.array((k,mean[i,:]+err[i,:]+1000*i))
poly = np.hstack((poly,np.fliplr(np.array((k, mean[i,:] - err[i,:]+1000*i)))))
poly = poly.T
ax.add_patch(Polygon(poly, closed=True,fill=True,alpha = 0.3,facecolor=colors[i]))
#plt.plot(wl, mean_spec, linewidth=0.8)
plt.plot(k,mean[i,:]+1000*i, linewidth=0.8)
plt.ylabel(r'$I_{\nu}\, /\, counts$')
plt.xlabel(r'$\Delta\widetilde{\nu}\, /\, cm^{-1}$')
plt.legend(legend)
plt.tight_layout()
plt.savefig(path + "overview.pdf", dpi=300)
plt.close()
# width = 100
# max_ind = np.argmax(counts)
# indices = np.arange(0, len(k), 1)
# mask = (indices <= max_ind + width) & (indices >= max_ind - width)
# # inds = np.arange(max_ind-width,max_ind+width,1)
# k1 = k[mask]
# counts1 = counts[mask]
# def err_fun(p):
# fit = fit_fun(k1, *p)
# diff = np.abs(counts1 - fit)
# return np.sum(diff)
#
# #def fit_fun(x, amp, x0, sigma,a,f,b,c):
# b = 0# ( np.mean(counts1[20:])-np.mean(counts1[:-20]) )/( np.mean(k1[20:])-np.mean(k1[:-20]) )
# c = 0#np.mean(k1[20:])
# start = [counts[max_ind]*3,k[max_ind],150,0.01,0.1]
# upper = [counts[max_ind]*10, k[max_ind]+width, 500, 1,1]
# lower = [ 0, k[max_ind]-width, 10, 0,0]
# bnds = []
# for i in range(len(upper)):
# bnds.append((lower[i], upper[i]))
#
# #minimizer_kwargs = {"method": "SLSQP","bounds": bnds,"tol":1e-10}
# #res = basinhopping(err_fun, start, minimizer_kwargs=minimizer_kwargs, niter=1000,disp=False)
# res = opt.minimize(err_fun, start, method='SLSQP', options={'disp': True, 'maxiter': 10000},tol=1e-10)
# #res = opt.minimize(err_fun, start, method='L-BFGS-B', options={'disp': True, 'maxiter': 5000})
# #res = opt.minimize(err_fun, start, method='Nelder-Mead', options={'disp': True, 'maxiter': 5000})
#
# popt = res.x
#
# print(popt)
# plt.plot(k1, counts1, linewidth=1)
# plt.plot(k1, fit_fun(k1,popt[0],popt[1],popt[2],popt[3],popt[4]), linewidth=1)
# #plt.plot(k1, popt[5]*k1+popt[6])
# plt.ylabel(r'$I_{\nu}\, /\, counts$')
# plt.xlabel(r'$wavenumber\, /\, cm^{-1}$')
# plt.savefig(savedir + file[:-4] + "fit.pdf", dpi=300)
# #plt.show()
# plt.close()
#
# fit = fit_fun(k1,popt[0],popt[1],popt[2],popt[3],popt[4])
# print(np.max(fit))
|
[
"Simon.Dickreuter@uni-tuebingen.de"
] |
Simon.Dickreuter@uni-tuebingen.de
|
4da9c1e6ca004b93d1f275e2bd86ea3be8e69b31
|
52bb1d25a8c146b81b876343f861025e034fa964
|
/roglick/dungeon/utils.py
|
fcf6a2a864c5ae7cc6c50f2c302b33b63529bf23
|
[
"MIT"
] |
permissive
|
Kromey/roglick
|
b3fc7a6bce7e60a150c9a9ed1cc825ef3988cf8a
|
b76202af71df0c30be0bd5f06a3428c990476e0e
|
refs/heads/master
| 2020-12-14T15:49:53.163385
| 2016-05-24T16:29:06
| 2016-05-24T16:29:06
| 21,549,421
| 6
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,519
|
py
|
from roglick.engine import random
from roglick.utils import clamp
def smoothstep(a, b, x):
"""Basic S-curve interpolation function.
Based on reference implementation available at
https://en.wikipedia.org/wiki/Smoothstep
"""
x = clamp((x - a)/(b - a), 0.0, 1.0)
return x*x*(3 - 2*x)
def smootherstep(a, b, x):
"""Improved S-curve interpolation function.
Based on reference implementation of the improved algorithm proposed by
Ken Perlin that is available at https://en.wikipedia.org/wiki/Smoothstep
"""
x = clamp((x - a)/(b - a), 0.0, 1.0)
return x*x*x*(x*(x*6 - 15) + 10);
def lerp(a, b, x):
"""Linear interpolation function."""
return a + x * (b - a)
class PerlinNoise2D(object):
def __init__(self, seed=None):
self.p = [x for x in range(256)]
if seed is None:
seed = random.get_int()
rand = random.Random(seed)
rand.shuffle(self.p)
def octave(self, x, y, octaves=5, persistence=0.5):
total = 0
frequency = 1
amplitude = 1
max_val = 0
for i in range(octaves):
total += self.noise(x*frequency, y*frequency) * amplitude
max_val += amplitude
amplitude *= persistence
frequency *= 2
return total / max_val
def noise(self, x, y):
xi = int(x)
yi = int(y)
xf = x - xi
yf = y - yi
u = self.fade(xf)
v = self.fade(yf)
aa = self.p_hash(self.p_hash( xi )+ yi )
ab = self.p_hash(self.p_hash( xi )+ yi+1)
ba = self.p_hash(self.p_hash(xi+1)+ yi )
bb = self.p_hash(self.p_hash(xi+1)+ yi+1)
x1 = lerp(self.grad(aa, xf , yf), self.grad(ba, xf-1, yf), u)
x2 = lerp(self.grad(ab, xf , yf-1), self.grad(bb, xf-1, yf-1), u)
return (lerp(x1, x2, v) + 1) / 2 # Constrain to [0,1] rather than [-1,1]
def fade(self, t):
return smootherstep(0.0, 1.0, t)
def p_hash(self, i):
i = i & 255
return self.p[i]
def grad(self, h, x, y):
"""This gradient function is based on Riven's optimization
Source: http://riven8192.blogspot.com/2010/08/calculate-perlinnoise-twice-as-fast.html
"""
h = h % 4
if h == 0:
return x + y
elif h == 1:
return -x + y
elif h == 2:
return x - y
elif h == 3:
return -x - y
else:
# Never happens
return 0
|
[
"travisvz@gmail.com"
] |
travisvz@gmail.com
|
ce9628165675f68be35472bfb365504846ce6053
|
9f078f64c86af7425d32c5e498b0af4458543a8b
|
/bin/owl
|
084c37efcdf13305ac24c9f84df33c20cb7572e6
|
[] |
no_license
|
lucassmagal/Owl
|
7252ba86f7b4a1deea1be10d1f1a715476585712
|
40272bdc03415d6073ea62da39399e5a2ace1344
|
refs/heads/master
| 2021-01-01T20:17:36.396245
| 2013-05-12T14:43:09
| 2013-05-12T14:43:09
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 101
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
from owl.cli import run
run(sys.argv[1:])
|
[
"magal.lucas@gmail.com"
] |
magal.lucas@gmail.com
|
|
ed3e3d70a1fd13a1e41fa4985818c02092340a95
|
413fb29b62fe9ba07362d614ba49e7200482216d
|
/fraud_detection/src/com/mr/data_analysis_python/sampleFraudData.py
|
4a77df03d96dbcfeca3f64da411e6f1ddb5ee5a5
|
[] |
no_license
|
cash2one/fraud_detection
|
ff2cc0a151b16cd3151c584839a227a384716ca7
|
6097e47800394f8659c5d14ab6a6538b2af8d444
|
refs/heads/master
| 2021-01-19T04:46:32.710395
| 2016-07-09T11:58:05
| 2016-07-09T11:58:05
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 911
|
py
|
__author__ = 'TakiyaHideto'
import sys
import random
class SampleFraudData:
def __init__(self, input, output):
self.input = input
self.output = output
self.sampleRatio = float(sys.argv[3])/float(sys.argv[4])
def __sample(self):
with open(self.output, "w") as fileOut:
with open(self.input, "r") as fileIn:
for line in fileIn:
if line.startswith("0"):
if random.random() < self.sampleRatio:
fileOut.write(line)
elif line.startswith("1"):
fileOut.write(line)
def runMe(self):
self.__sample()
if __name__ == "__main__":
if len(sys.argv) != 5:
print "<inputFile> <outputSampledFile> <fraudDataQuant> <normalDataQuant>"
exit(1)
job = SampleFraudData(sys.argv[1], sys.argv[2])
job.runMe()
|
[
"TakiyaHideto@iekoumatoMacBook-Pro.local"
] |
TakiyaHideto@iekoumatoMacBook-Pro.local
|
49ef89ed9847f6370bab12ee14d5b37c98c4382f
|
8cf211cabe8c5169b2c9c3c6b38f69ac6c93b93e
|
/flask_bootcamp/section_6/venv/lib/python3.6/os.py
|
ac0bdb84664fdfc380e6a61aeee8932f5167c92b
|
[] |
no_license
|
bopopescu/Python_Personal_Projects
|
020256cb6835438b1b776eacb1a39d4cb5bc2efc
|
025145130da5ac846b8aa14764783739ff68f64c
|
refs/heads/master
| 2022-11-21T04:47:17.253558
| 2018-10-25T22:12:07
| 2018-10-25T22:12:07
| 281,146,690
| 0
| 0
| null | 2020-07-20T14:57:05
| 2020-07-20T14:57:04
| null |
UTF-8
|
Python
| false
| false
| 44
|
py
|
/home/vinicius/anaconda3/lib/python3.6/os.py
|
[
"vinicius.yosiura@live.com"
] |
vinicius.yosiura@live.com
|
31c16a62d12f6538275dc374ce02c654b07ba690
|
582b93ca3747f7ec4ce8c00464c26698b0b8b229
|
/DevExa/settings.py
|
658b53ef61b015873d139dc62dd14ca2e8e29f93
|
[] |
no_license
|
BeToOxX/Final
|
7615e0e37c4ca8858687f0293b5058dc75d79a9c
|
f4371207836b4f7cd856c7237ada3cd60a597bce
|
refs/heads/master
| 2023-08-23T18:06:00.585583
| 2021-10-07T06:01:50
| 2021-10-07T06:01:50
| 414,474,675
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,325
|
py
|
"""
Django settings for DevExa project.
Generated by 'django-admin startproject' using Django 2.0.6.
For more information on this file, see
https://docs.djangoproject.com/en/2.0/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/2.0/ref/settings/
"""
import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '=g8j_n6d=)gf_b*vn4hlt%!v5#njdwz_x_u80roi@51qcfze52'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = ['*']
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'apps.web'
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
'whitenoise.middleware.WhiteNoiseMiddleware',
]
ROOT_URLCONF = 'DevExa.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': ['template'],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'DevExa.wsgi.application'
# Database
# https://docs.djangoproject.com/en/2.0/ref/settings/#databases
import dj_database_url
from decouple import config
DATABASES = {
'default': dj_database_url.config(
default=config('DATABASE_URL')
)
}
"""
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
"""
# Password validation
# https://docs.djangoproject.com/en/2.0/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/2.0/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.0/howto/static-files/
STATIC_URL = '/static/'
|
[
"rubengza.98@gmail.com"
] |
rubengza.98@gmail.com
|
341fc6379af0b753834833efa91503520488d7fa
|
a3aaf7bb73471c67d4adc40aee159e60e7fc964b
|
/face_pic.py
|
f2573255284ef455f037aef1a2398b61799bfee2
|
[] |
no_license
|
muskaankularia/Gaze-tracker
|
29360516efbe94a8ef19aeefa8805db7224b15df
|
dcae52f85d486ce0f8ec1566814be7136c97df38
|
refs/heads/master
| 2021-08-22T05:53:12.770849
| 2017-11-29T12:09:06
| 2017-11-29T12:09:06
| 112,461,356
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 5,519
|
py
|
import numpy as np
import cv2
import sys
import os
import shutil
import timm
if os.path.exists('./data'):
shutil.rmtree('./data')
dirname = 'data'
os.mkdir(dirname)
face_cascade = cv2.CascadeClassifier('/usr/local/Cellar/opencv/3.3.0_3/share/OpenCV/haarcascades/haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier('//usr/local/Cellar/opencv/3.3.0_3/share/OpenCV/haarcascades/haarcascade_eye.xml')
# mouth_cascade = cv2.CascadeClassifier('/usr/local/Cellar/opencv/3.3.0_3/share/OpenCV/haarcascades/haarcascade_mcs_mouth.xml')
mouth_cascade = cv2.CascadeClassifier('./haarcascade_mcs_mouth.xml')
# if len(sys.argv) < 2:
# sys.exit('Wrong Usage')
# image_name = sys.argv[1]
# img = cv2.imread(image_name)
camera = cv2.VideoCapture(0)
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('sample.avi',fourcc, 3, (1280,720))
counter = 0
kernel = np.ones((3,3),np.uint8)
while 1:
retval, img = camera.read()
# print img.shape
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# print 'y'
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
for (x,y,w,h) in faces:
# print 'face found'
cv2.rectangle(img, (x,y), (x+w, y+h), 0, 2)
roi_face = gray[y:y+h, x:x+w]
roi_face_color = img[y:y+h, x:x+w]
eyes = eye_cascade.detectMultiScale(roi_face, 1.3, 5)
for (ex, ey, ew, eh) in eyes:
counter += 1
cv2.rectangle(roi_face_color, (ex,ey), (ex+ew, ey+eh), (0,255,0), 2)
# print "eye " + str(ex) + " " + str(ey)
# roi_eye = roi_face[int(1.2*ey):int(0.8*(ey+eh)), int(1.2*ex):int(0.8*(ex+ew))]
roi_eye = roi_face[ey:ey+eh, ex:ex+ew]
center = 0
roi_eye = cv2.GaussianBlur(roi_eye,(3,3),0)
roi_eye = cv2.addWeighted(roi_eye,1.5,roi_eye,-0.5,0)
roi_eye_canny = cv2.Canny(roi_eye,100,200)
cv2.imwrite('./data/canny' + str(counter) + '.png', roi_eye_canny)
laplacian = cv2.Laplacian(roi_eye,cv2.CV_64F)
cv2.imwrite('./data/lapla' + str(counter) + '.png', laplacian)
# res = cv2.resize(roi_eye,(int(ew/2), int(eh/2)), interpolation = cv2.INTER_AREA)
roi_eyex = cv2.Sobel(roi_eye, cv2.CV_64F, 1, 0, ksize=3)
roi_eyey = cv2.Sobel(roi_eye, cv2.CV_64F, 0, 1, ksize=3)
roi_eyex = np.absolute(roi_eyex)
roi_eyey = np.absolute(roi_eyey)
roi_eyex = np.uint8(roi_eyex)
roi_eyey = np.uint8(roi_eyey)
# sobelx64f = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=5)
# abs_sobel64f = np.absolute(sobelx64f)
# sobel_8u = np.uint8(abs_sobel64f)
cv2.imwrite('./data/zsobely' + str(counter) + '.png', roi_eyey)
cv2.imwrite('./data/zsobelx' + str(counter) + '.png', roi_eyex)
ret, tmp = cv2.threshold(roi_eyex, 0, 255, cv2.THRESH_OTSU)
tmp = cv2.erode(tmp, kernel, iterations=1)
cv2.imwrite('./data/zsobelxt' + str(counter) + '.png', tmp)
mag = np.hypot(roi_eyex, roi_eyey) # magnitude
mag *= 255.0 / np.max(mag) # normalize (Q&D)
roi_eye_sobel = mag.astype(np.uint8)
# roi_eye_sobel = cv2.morphologyEx(roi_eye_sobel, cv2.MORPH_OPEN, kernel)
cv2.imwrite('./data/xy' + str(counter) + '.png', roi_eye_sobel)
# roi_eye_sobel = cv2.morphologyEx(roi_eye_sobel, cv2.MORPH_OPEN, kernel)
# roi_eye_sobel = cv2.erode(roi_eye_sobel, kernel, iterations = 1)
# roi_eye_sobel = cv2.morphologyEx(roi_eye_sobel, cv2.MORPH_CLOSE, kernel)
ret, roi_eye_sobel = cv2.threshold(roi_eye_sobel, 0, 255, cv2.THRESH_OTSU)
roi_eye_sobel = cv2.erode(roi_eye_sobel, kernel, iterations=1)
cv2.imwrite('./data/tempthresh' + str(counter) + '.png', roi_eye_sobel)
roi_eye_color = roi_face_color[ey:ey+eh, ex:ex+ew]
# center = timm.findEyeCenter(roi_eye_color, (0,0))
# cv2.circle(roi_eye_color, center, 5, (255, 255, 255), 2)
pupils = cv2.HoughCircles(roi_eye_sobel, cv2.HOUGH_GRADIENT, 1, 100, param1 = 100, param2 = 10, minRadius=int(ew/11), maxRadius=int(ew/3))
if pupils is not None:
# print 'not none'
pupils = np.round(pupils[0,:]).astype("int")
for (x,y,r) in pupils:
print str(x) + " " + str(y) + " " + str(r) + " --- " + str(counter) + " " + str(int(ew/11)) + "-" + str(int(ew/3))
# cv2.circle(roi_eye_color, (x, y), r, (255, 165, 0), 2)
cv2.circle(roi_eye_color, (x, y), 2, (255, 165, 0), 3)
# cv2.imshow('eye' + str(x), roi_eye_color)
# print roi_eye_sobel.shape
# print roi_eye_color.shape
comb = np.zeros(shape=(roi_eye_color.shape[0], roi_eye_color.shape[1]*2, roi_eye_color.shape[2]), dtype=np.uint8)
comb[:roi_eye_color.shape[0], :roi_eye_color.shape[1]] = roi_eye_color
comb[:roi_eye_sobel.shape[0], roi_eye_sobel.shape[1]:] = roi_eye_sobel[:, :, None]
# cat = np.concatenate([roi_eye_sobel, roi_eye_color])
cv2.imwrite('./data/eye' + str(counter) + '.png', comb)
# cv2.moveWindow('eye' + str(x), 1000, 100)
# cv2.resizeWindow('eye' + str(x), eh*2, ew*2)
# mouths = mouth_cascade.detectMultiScale(roi_face, 1.7, 11)
# for (mx, my, mw, mh) in mouths:
# cv2.rectangle(roi_face_color, (mx, my), (mx+mw, my+mh), (0, 0, 0), 2)
# roi_mouth = roi_face[my:my+mh, mx:mx+mw]
# roi_mouth_color = roi_face_color[my:my+mh, mx:mx+mw]
# roi_mouth = cv2.cornerHarris(roi_mouth, 2, 3, 0.04)
# roi_mouth = cv2.dilate(roi_mouth, None)
# roi_mouth_color[roi_mouth>0.01*roi_mouth.max()]=[0,0,255]
out.write(img)
cv2.imshow('test', img)
# cv2.imshow('bhawsar', gray)
# cv2.moveWindow('bhawsar', 800,100)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
camera.release()
out.release()
# cv2.waitKey(0)
cv2.destroyAllWindows()
|
[
"noreply@github.com"
] |
noreply@github.com
|
94885939895e110e0050528f9b92b238256a9c00
|
39efbd67fa02ef628bd86051781145b77b8244d9
|
/PLXs/086-01173-00 ok/CSVReader.py
|
2965cac991750f4034087c8861c66e11bd242ba1
|
[] |
no_license
|
hbenr/ProjectBender
|
9df2326df01ec04db93d2311e0107a5ac2706802
|
c0432ae0a9ceaf6442f92f59805bdfbdddc2fd14
|
refs/heads/master
| 2021-05-29T19:36:07.437213
| 2015-09-17T20:02:07
| 2015-09-17T20:02:07
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,343
|
py
|
#-------------------------------------------------------------------------------
# Name: module1
# Purpose:
#
# Author: MAT.TE
#
# Created: 20/08/2015
# Copyright: (c) MAT.TE 2015
# Licence: <your licence>
#-------------------------------------------------------------------------------
import csv
from UtilitiesHB import *
def cadFetch(BOARD_ORIGIN, CAD_FILENAME):
startSaving = False
with open(CAD_FILENAME + '.csv', 'rb') as cadFile:
reader = csv.reader(cadFile)
fiducials = []
devices = []
for row in reader:
if row[0] == 'Name':
startSaving = True
continue
if startSaving and (row[0] != '' and not 'H' in row[0]
and not 'TP' in row[0] and not 'F' in row[0] and not 'N' in row[0]
and not 'P' in row[0] and not 'K' in row[0] and not 'LED' in row[0]
and not 'MOV' in row[0]):
devices.append(['d', unitsConverter(int(row[2]), False, BOARD_ORIGIN, False),
unitsConverter(int(row[1]), False, BOARD_ORIGIN, True), row[0].lower(), 'n0000', row[3],
'partNo', 'f-1', row[0].lower(), 'SHAPE'])
elif startSaving and 'F' in row[0]:
fiducials.append(['f', unitsConverter(int(row[2]), False, BOARD_ORIGIN, False),
unitsConverter(int(row[1]), False, BOARD_ORIGIN, True)])
elif startSaving and (row[0] == ''):
break
return fiducials, devices
def bomFetch(devices, BOM_FILENAME):
startSaving = False
with open(BOM_FILENAME + '.csv', 'rb') as bomFile:
reader = csv.reader(bomFile)
for row in reader:
currentDevices = []
for elem in row[8].split(','):
currentDevices.extend(deviceEnumerator(elem))
if row[0] == 'Part No':
startSaving = True
continue
if startSaving and row[8] != '':
for elem in currentDevices:
for component in devices:
if elem.lower() == component[3]:
component[6] = row[4]
return sorted(devices, key= lambda x: int(x[2]))
def main():
raw_input("Wrong file! Use plxHelper ")
if __name__ == '__main__':
main()
|
[
"MAT.TE@CTLMAT0301D.Robertshaw.com"
] |
MAT.TE@CTLMAT0301D.Robertshaw.com
|
d3d6757ce1df376dff4c92caaad8942329c824b0
|
801e30ca6313e09ae19c2109604325556edf7e11
|
/validate_hcp_release.py
|
295ec2b714eeaf5286237d8780121fdcfc0be382
|
[] |
no_license
|
MHouse/validate_hcp_release
|
5335dbb531564e52e38b10bf538cced6bc2b1265
|
0c9f98fcd51b5c7e7c64f962c6393019b67790ec
|
refs/heads/master
| 2021-01-16T18:18:22.110563
| 2013-02-22T21:17:38
| 2013-02-22T21:17:38
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 8,747
|
py
|
#! /usr/bin/env python
__author__ = 'mhouse01'
import requests
import json
import os
import csv
from lxml import etree
from sys import exit
from operator import itemgetter, attrgetter
import argparse
import ConfigParser
from seriesDetails import seriesDetails, csvOrder, seriesLabels, scanIsPackage
# Declare the XNAT Namespace for use in XML parsing
xnatNS = "{http://nrg.wustl.edu/xnat}"
xmlFormat = {'format': 'xml'}
jsonFormat = {'format': 'json'}
# PARSE INPUT
parser = argparse.ArgumentParser(description="Alpha program to pull Subject session parameters from XNAT for verification")
parser.add_argument("-c", "--config", dest="configFile", default="validate_hcp_release.cfg", type=str, help="config file must be specified")
parser.add_argument("-P", "--project", dest="Project", default="HCP_Phase2", type=str, help="specify project")
parser.add_argument("-S", "--subject", dest="Subject", type=str, help="specify subject of interest")
parser.add_argument("-D", "--destination_dir", dest="destDir", default='/tmp', type=str, help="specify the directory for output")
parser.add_argument("-M", "--output_map", dest="outputMap", default='all', type=str, help="specify the output mapping: all, public, package")
parser.add_argument("-v", "--verbose", dest="verbose", default=False, action="store_true", help="show more verbose output")
parser.add_argument('--version', action='version', version='%(prog)s: v0.1')
args = parser.parse_args()
args.destDir = os.path.normpath( args.destDir )
# Read the config file
config = ConfigParser.ConfigParser()
try:
config.read( args.configFile )
username = config.get('Credentials', 'username')
password = config.get('Credentials', 'password')
restServerName = config.get('Server', 'server')
restSecurity = config.getboolean('Server', 'security')
except ConfigParser.Error as e:
print "Error reading configuration file:"
print " " + str( e )
exit(1)
if restSecurity:
print "Using only secure connections"
restRoot = "https://" + restServerName
else:
print "Security turned off for all connections"
restRoot = "http://" + restServerName + ":8080"
# If we find an OS certificate bundle, use it instead of the built-in bundle
if requests.utils.get_os_ca_bundle_path() and restSecurity:
os.environ['REQUESTS_CA_BUNDLE'] = requests.utils.get_os_ca_bundle_path()
print "Using CA Bundle: %s" % requests.utils.DEFAULT_CA_BUNDLE_PATH
# Establish a Session ID
try:
r = requests.get( restRoot + "/data/JSESSION", auth=(username, password) )
# If we don't get an OK; code: requests.codes.ok
r.raise_for_status()
# Check if the REST Request fails
except (requests.ConnectionError, requests.exceptions.RequestException) as e:
print "Failed to retrieve REST Session ID:"
print " " + str( e )
exit(1)
restSessionID = r.content
print "Rest Session ID: %s " % (restSessionID)
restSessionHeader = {"Cookie": "JSESSIONID=" + restSessionID}
mrSessions = {"xsiType": "xnat:mrSessionData"}
# Get the list of MR Sessions for each Experiment
# Create a URL pointing to the Experiments for this Subject
restExperimentsURL = restRoot + "/data/archive/projects/" + args.Project + "/subjects/" + args.Subject + "/experiments/"
# Get the list of MR Sessions for the Subject in JSON format
try:
# Create a dictionary of parameters for the rest call
restParams = mrSessions.copy()
restParams.update(jsonFormat)
# Make the rest call
r = requests.get( restExperimentsURL, params=restParams, headers=restSessionHeader)
# If we don't get an OK; code: requests.codes.ok
r.raise_for_status()
# Check if the REST Request fails
except (requests.ConnectionError, requests.exceptions.RequestException) as e:
print "Failed to retrieve MR Session list: %s" % e
exit(1)
# Parse the JSON from the GET
experimentJSON = json.loads( r.content )
# Strip off the trash that comes back with it and store it as a list of name/value pairs
experimentResultsJSON = experimentJSON.get('ResultSet').get('Result')
# List Comprehensions Rock! http://docs.python.org/tutorial/datastructures.html
# Create a stripped down version of the results with a new field for seriesList; Store it in the experimentResults object
experimentResults = [ {'label': experimentItem.get('label').encode('ascii', 'ignore'),
'date': experimentItem.get('date').encode('ascii', 'ignore'),
'subjectSessionNum': None,
'seriesList': None } for experimentItem in experimentResultsJSON ]
# Loop over the MR Experiment Results
for experiment in experimentResults:
print "Gathering results for " + experiment['label']
# Compose a rest URL for this Experiment
restSingleExperimentURL = restExperimentsURL + experiment['label']
# Make a rest request to get the complete XNAT Session XML
try:
r = requests.get( restSingleExperimentURL, params=xmlFormat, headers=restSessionHeader, timeout=10.0 )
# If we don't get an OK; code: requests.codes.ok
r.raise_for_status()
# Check if the REST Request fails
except requests.Timeout as e:
print "Timed out while attempting to retrieve XML:"
print " " + str( e )
if not args.restSecurity:
print "Note that insecure connections are only allowed locally"
exit(1)
# Check if the REST Request fails
except (requests.ConnectionError, requests.exceptions.RequestException) as e:
print "Failed to retrieve XML: %s" % e
exit(1)
# Parse the XML result into an Element Tree
root = etree.fromstring(r.text.encode(r.encoding))
# Extract the Study Date for the session
if experiment['date'] == "":
experiment['date'] = "2013-01-01"
print "Assuming study date of " + experiment['date']
# Start with an empty series list
seriesList = list()
# Iterate over 'scan' records that contain an 'ID' element
for element in root.iterfind(".//" + xnatNS + "scan[@ID]"):
# Create an empty seriesDetails record
currentSeries = seriesDetails()
#Record some basic experiment level info in each scan
currentSeries.subjectName = args.Subject
currentSeries.sessionLabel = experiment['label']
currentSeries.sessionDate = experiment['date']
currentSeries.fromScanXML( element )
# Add the current series to the end of the list
seriesList.append( currentSeries )
# Sort the series list by DateTime
seriesList.sort( key=attrgetter('DateTime') )
# Store the subjectSessionNum extracted from the first item (first acquired scan) in the sorted list
experiment['subjectSessionNum'] = iter(seriesList).next().subjectSessionNum
# Store the series list along with the experiment label
experiment['seriesList'] = seriesList
# Sort the Experiment Results list by the Subject Session Number
experimentResults.sort( key=itemgetter('subjectSessionNum') )
# Name the CSV file by the Subject name
csvFile = args.destDir + os.sep + args.Subject + "_" + args.outputMap + ".csv"
# Create an empty Series Notes object. This can be populated with field specific notes for each Experiment
seriesNotes = seriesDetails()
# Open the CSV file for write/binary
with open( csvFile, 'wb' ) as f:
# Create a CSV Writer for dictionary formatted objects. Give it the Dictionary order for output.
csvWriter = csv.DictWriter( f, csvOrder( args.outputMap ) )
# Write out the series labels as a Header
if args.outputMap != "package":
csvWriter.writerow( seriesLabels(args.outputMap) )
# Loop over all experiment results
for experiment in experimentResults:
# Populate the Series Notes for this Experiment with the Experiment Date and Label
seriesNotes.scan_ID = experiment['label']
seriesNotes.startTime = experiment['date']
# Write out the notes only on 'all' maps
if args.outputMap == "all":
csvWriter.writerow( seriesNotes.asDictionary(args.outputMap) )
# Loop over all scans in each experiment
for scan in experiment['seriesList']:
# Write each scan by converting it to a Dictionary and pulling the relevant Mapping subset
nextRow = scan.asDictionary(args.outputMap)
# But only if this row should be included
if args.outputMap == "all" or \
(args.outputMap == "release" and scan.targetForRelease == "1") or \
(args.outputMap == "release" and restServerName == "hcpx-demo.humanconnectome.org") or \
(args.outputMap == "package" and scanIsPackage(scan.dbDesc)):
csvWriter.writerow( nextRow )
print "Subject details written to: " + csvFile
|
[
"mdhouse@gmail.com"
] |
mdhouse@gmail.com
|
8de31727528745859574b0a71d4d7f4265c46740
|
2718b6f68a717b24cd6238a20d4116b3dea3201b
|
/BlogTemplate/mysite_env/mysite/apps/blog/views.py
|
39b584eea388bcf248d6a6d595bae4840b4bf60b
|
[] |
no_license
|
tminlun/BlogTemplate
|
e94654e01e170f27c97c197c898c102518ad13ab
|
d475587fdd9e111961bbfa56666255d38cfdc056
|
refs/heads/master
| 2022-12-11T00:51:53.019391
| 2018-12-05T14:54:04
| 2018-12-05T14:54:04
| 138,825,320
| 0
| 0
| null | 2022-12-08T02:25:29
| 2018-06-27T03:30:20
|
Python
|
UTF-8
|
Python
| false
| false
| 4,519
|
py
|
from django.shortcuts import render,get_object_or_404
from django.core.paginator import Paginator
from django.conf import settings
from django.contrib.contenttypes.models import ContentType
from django.db.models.aggregates import Count
from read_statistics.utils import read_statistics_once_read
from comment.models import Comment
from .models import Blog,BlogType
#获取博客列表共同的数据,设置参数blog_all_list全部博客,因为每个方法都有不同的获取方法
def get_blog_list_common_data(request, blog_all_list):
paginator = Paginator(blog_all_list, settings.EACH_PAGE_BLOG_NUMBER) # 每一页10篇博客
page_num = request.GET.get('page', 1) # 获取页码参数,get请求
page_of_blogs = paginator.get_page(page_num) # 获取当前页码
current_page_num = page_of_blogs.number # 获取当前页码
# current_page_num - 2 , 1 只是拿1和currentr_page_num - 2比，range范围还是
# current_page_num - 2, currentr_page_num
page_range = list(range(max(current_page_num - 2, 1), current_page_num)) + \
list(range(current_page_num, min(current_page_num + 2, paginator.num_pages) + 1))
# 添加省略
if page_range[0] - 1 >= 2:
page_range.insert(0, '...')
# 如果总页 - 最后一页 大于等于2
if paginator.num_pages - page_range[-1] >= 2:
page_range.append('...')
# 添加第一页和最后一页
if page_range[0] != 1:
page_range.insert(0, 1) # 将第一个页码变成1(insert在第一个插入)
if page_range[-1] != paginator.num_pages:
page_range.append(paginator.num_pages) # 添加总页码到最后显示页码(append在尾部添加)
blog_dates = Blog.objects.dates('created_time','month',order="DESC")
blog_dates_dict = {}
for blog_date in blog_dates:
date_count = Blog.objects.filter(created_time__year=blog_date.year,created_time__month=blog_date.month).count()
blog_dates_dict[blog_date] = date_count
context = {}
context['page_of_blogs'] = page_of_blogs # 当前页码
context['page_range'] = page_range # 返回所有页码给模板
context['blogs'] = page_of_blogs.object_list # 获取所有博客
# annotate自动返回BlogType的所有数据
context['blog_types']=BlogType.objects.annotate(type_count = Count('blog')).filter(type_count__gt=0)
# 获取到全部的年和月
context['blog_dates'] = blog_dates_dict # 这里是一个坑,记住把日期和数量给对象
return context #返回给模板 render(request,'？.html',context)
def blog_list(request):
blog_all_list = Blog.objects.all()#全部的博客列表
context = get_blog_list_common_data(request,blog_all_list) #传递给context
return render(request, 'blog/blog_list.html', context)
def blogs_with_type(request,blog_with_type_pk):
blog_type = get_object_or_404(BlogType,pk = blog_with_type_pk)#获取分类
blog_all_list = Blog.objects.filter(blog_type=blog_type)#获取所有筛选类型博客
context = get_blog_list_common_data(request, blog_all_list)
context['blog_type'] = blog_type # 分类名
return render(request, 'blog/blogs_with_type.html', context)
def blogs_with_date(request,year,month):
#获取到对应年和月的博客
blog_all_list = Blog.objects.filter(created_time__year=year, created_time__month=month)
context = get_blog_list_common_data(request, blog_all_list)
context['blog_with_date'] = "%s年%s月" %(year,month) #当前的年月
return render(request, 'blog/blogs_with_date.html', context)
#博客细节
def blog_detail(request,blog_pk):
context = {}
blog = get_object_or_404(Blog, pk = blog_pk)
#判断浏览器是否有cookie记录，有不加数，没有加数；get获取字典的key
read_cookie_key = read_statistics_once_read(request, blog)
blog_content_type = ContentType.objects.get_for_model(blog)
comments = Comment.objects.filter(content_type=blog_content_type,object_id=blog.pk)
context['blog'] = blog
#前一篇博客，大于：__gt=
context['previous_blog'] = Blog.objects.filter(created_time__gt=blog.created_time).last()
#后一篇博客，小于：__lt=
context['next_blog'] = Blog.objects.filter(created_time__lt=blog.created_time).first()
context['user'] = request.user
context['comments'] = comments
response=render(request, 'blog/blog_detail.html', context)
response.set_cookie(read_cookie_key, 'ture') #坑，值 记得填写
return response
|
[
"1272443075@qq.com"
] |
1272443075@qq.com
|
99aaac368b5a91c9ccdea2dd36758013b517c21f
|
03db4adc692a989a0dbc90d1175bdabaaa5341b3
|
/Lab-9-hhu14.py
|
2af4c479900e134d179c8572e04c55d197cc93ab
|
[] |
no_license
|
MeloHu/CS128
|
e70d18668238533cd0e8b42588e5d7b0e88c8766
|
e2595aea14f150efce25816b1215f35ef319b751
|
refs/heads/master
| 2021-05-05T10:06:35.993342
| 2017-09-19T04:24:44
| 2017-09-19T04:24:44
| 104,021,607
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,745
|
py
|
# coding: utf-8
# In[ ]:
## Honglie Hu,hhu14@earlham.edu,Saturday&8:00 at 66.5486,-18.0233,Lab9-M&M
# In[1]:
## Part A
def main():
filename = input("file_name:")
file = open(filename,"r")
text = file.read()
length = text.split()
count=len(length)
print("Count:",count)
TheNumber =[float(i) for i in length]
file.close()
## to get "mode"
mNumber = [TheNumber.count(i) for i in TheNumber]
position = max(mNumber)
positionArray = mNumber.index(position)
Mode = TheNumber[positionArray]
## --------------------------------------
print("Total:",sum(TheNumber))
print("Smallest:",min(TheNumber))
print("Largest:",max(TheNumber))
average=sum(TheNumber)/count
print("Mode:",Mode)
print("Average:",average)
main()
# In[2]:
## Part B
def main():
import math
filename = input("file_name:")
file = open(filename,"r")
text = file.read()
length = text.split()
count = len(length)
print("Count:",count)
TheNumber =[float(i) for i in length]
file.close()
## to get "mode"
mNumber = [TheNumber.count(i) for i in TheNumber]
position = max(mNumber)
positionArray = mNumber.index(position)
Mode = TheNumber[positionArray]
## ---------------------------------
print("Total:",sum(TheNumber))
print("Smallest:",min(TheNumber))
print("Largest:",max(TheNumber))
average=sum(TheNumber)/count
print("Mode:",Mode)
## to get "median"
TheNumber.sort()
medianNumber = len(TheNumber)
Median =(TheNumber[math.floor(medianNumber/2)])
print("Median:",Median)
## ----------------------------------
print("Average:",average)
main()
# In[ ]:
|
[
"noreply@github.com"
] |
noreply@github.com
|
ee56c5923d4e412ecef2b0e9a6abc6e9db42e260
|
1f60222696b27d1a0f93282c73f72f6870c0c7d6
|
/alpha_transform/AlphaTransformUtility.py
|
6c4cbca2cb07bcccddf7a558df7b93567d90c79c
|
[
"MIT"
] |
permissive
|
dedale-fet/alpha-transform
|
7ff3d5859ccf4924170894a9eb030fa8ac4da099
|
41b4fb0b28b908391f9ddf17cdcde8b956d3d064
|
refs/heads/master
| 2021-01-13T14:28:57.702914
| 2020-08-04T15:40:22
| 2020-08-04T15:40:22
| 72,874,669
| 14
| 7
| null | 2020-07-19T18:47:18
| 2016-11-04T18:26:33
|
Python
|
UTF-8
|
Python
| false
| false
| 11,097
|
py
|
r"""
This module contains several utility functions which can be used e.g.
for thresholding the alpha-shearlet coefficients or for using the
alpha-shearlet transform for denoising.
Finally, it also contains the functions :func:`my_ravel` and :func:`my_unravel`
which can be used to convert the alpha-shearlet coefficients into a
1-dimensional vector and back. This is in particular convenient for the
subsampled transform, where this conversion is not entirely trivial, since the
different "coefficient images" have varying dimensions.
"""
import os.path
import math
import numpy as np
import numexpr as ne
import scipy.ndimage
def find_free_file(file_template):
r"""
This function finds the first nonexistent ("free") file obtained by
"counting upwards" using the passed template/pattern.
**Required Parameter**
:param string file_template:
This should be a string whose ``format()`` method can be called
using only an integer argument, e.g. ``'/home/test_{0:0>2d}.txt'``,
which would result in ``find_free_file`` consecutively checking
the following files for existence:
`/home/test_00.txt,`
`/home/test_01.txt, ...`
**Return value**
:return:
``file_template.format(i)`` for the first value of ``i`` for which
the corresponding file does not yet exist.
"""
i = 0
while os.path.isfile(file_template.format(i)):
i += 1
return file_template.format(i)
def threshold(coeffs, thresh_value, mode):
r"""
Given a set of coefficients, this function performs a thresholding
procedure, i.e., either soft or hard thresholding.
**Required parameters**
:param coeffs:
The coefficients to be thresholded.
Either a three-dimensional :class:`numpy.ndarray` or a generator
producing two dimensional :class:`numpy.ndarray` objects.
:param float thresh_value:
The thresholding cutoff :math:`c` for the coefficients, see also
``mode`` for more details.
:param string mode:
Either ``'hard'`` or ``'soft'``. This parameter determines whether
the hard thresholding operator
.. math::
\Lambda_cx
=\begin{cases}
x, & \text{if }|x|\geq c,\\
0, & \text{if }|x|<c,
\end{cases}
or the soft thresholding operator
.. math::
\Lambda_cx
=\begin{cases}
x\cdot \frac{|x|-c}{|x|}, & \text{if }|x|\geq c,\\
0, & \text{if }|x|<c
\end{cases}
is applied to each entry of the coefficients.
**Return value**
:return:
A generator producing the thresholded coefficients. Each
thresholded "coefficient image", i.e., each thresholded
2-dimensional array, is produced in turn.
"""
if mode == 'hard':
for coeff in coeffs:
ev_string = 'coeff * (real(abs(coeff)) >= thresh_value)'
yield ne.evaluate(ev_string)
# yield coeff * (np.abs(coeff) >= thresh_value)
elif mode == 'soft':
for coeff in coeffs:
ev_string = ('(real(abs(coeff)) - thresh_value) * '
'(real(abs(coeff)) >= thresh_value)')
large_values = ne.evaluate(ev_string)
# large_values = np.maximum(np.abs(coeff) - thresh_value, 0)
ev_str_2 = 'coeff * large_values / (large_values + thresh_value)'
yield ne.evaluate(ev_str_2)
# yield coeff * large_values / (large_values + thresh_value)
else:
raise ValueError("'mode' must be 'hard' or 'soft'")
def scale_gen(trafo):
r"""
**Required parameter**
:param trafo:
An object of class :class:`AlphaTransform.AlphaShearletTransform`.
**Return value**
:return:
A generator producing integers. The i-th produced integer
is the *scale* (starting from -1 for the low-pass part) of the i-th
alpha-shearlet associated to ``trafo``.
Hence, if ``coeff = trafo.transform(im)``, then the following iteration
produces the associated scale to each "coefficient image"::
for scale, c in zip(scale_gen(trafo), coeff):
...
"""
indices_gen = iter(trafo.indices)
next(indices_gen)
yield -1
for index in indices_gen:
yield index[0]
def denoise(img, trafo, noise_lvl, multipliers=None):
r"""
Given a noisy image :math:`\tilde f`, this function performs a denoising
procedure based on shearlet thresholding. More precisely:
#. A scale dependent threshold parameter :math:`c=(c_j)_j` is calculated
according to :math:`c_j=m_j\cdot \lambda / \sqrt{N_1\cdot N_2}`, where
:math:`m_j` is a multiplier for the jth scale, :math:`\lambda` is the
noise level present in the image :math:`\tilde f` and
:math:`N_1\times N_2` are its dimensions.
#. The alpha-shearlet transform of :math:`\tilde f` is calculated
using ``trafo``.
#. Hard thesholding with threshold parameter (cutoff) :math:`c` is
performed on alpha-shearlet coefficients, i.e., for each scale ``j``,
each of the coefficients belonging to the jth scale is set to zero if
its absolute value is smaller than :math:`c_j` and otherwise it is
left unchanged.
#. The (pseudo)-inverse of the alpha-shearlet transform is applied to the
thresholded coefficients and this reconstruction is the return value
of the function.
**Required parameters**
:param numpy.ndarray img:
The “image” (2 dimensional array) that should be denoised.
:param trafo:
An object of class :class:`AlphaTransform.AlphaShearletTransform`.
This object is used to calculate the (inverse) alpha-shearlet
transform during the denoising procedure.
The dimension of the transform and of ``img`` need to coincide.
:param float noise_lvl:
The (presumed) noise level present in ``img``.
If ``img = img_clean + noise``, then ``noise_lvl`` should be
approximately equal to the :math:`\ell^2` norm of ``noise``.
In particular, if ``im`` is obtained by adding Gaussian noise with
standard deviation :math:`\sigma` (in each entry) to a noise free
image :math:`f`, then the noise level :math:`\lambda` is given by
:math:`\lambda= \sigma\cdot \sqrt{N_1\cdot N_2}`; see also
:func:`AdaptiveAlpha.optimize_denoising`.
**Keyword parameter**
:param list multipliers:
A list of multipliers (floats) for each scale. ``multipliers[j]``
determines the value of :math:`m_j` and thus of the cutoff
:math:`c_j = m_j \cdot \lambda / \sqrt{N_1 \cdot N_2}` for scale ``j``.
In particular, ``len(multipliers)`` needs
to be equal to the number of the scales of ``trafo``.
**Return value**
:return:
The denoised image, i.e., the result of the denoising procedure
described above.
"""
coeff_gen = trafo.transform_generator(img, do_norm=True)
if multipliers is None:
# multipliers = [1] + ([2.5] * (trafo.num_scales - 1)) + [5]
multipliers = [3] * trafo.num_scales + [4]
width = trafo.width
height = trafo.height
thresh_lvls = [multi * noise_lvl / math.sqrt(width * height)
for multi in multipliers]
thresh_coeff = (coeff * (np.abs(coeff) >= thresh_lvls[scale + 1])
for (coeff, scale) in zip(coeff_gen, scale_gen(trafo)))
recon = trafo.inverse_transform(thresh_coeff, real=True, do_norm=True)
return recon
def image_load(path):
r"""
Given a '.npy' or '.png' file, this function loads the file and returns
its content as a two-dimensional :class:`numpy.ndarray` of :class:`float`
values.
For '.png' images, the pixel values are normalized to be between 0 and 1
(instead of between 0 and 255) and color images are converted to
grey-scale.
**Required parameter**
:param string path:
Path to the image to be converted, either of a '.png' or '.npy' file.
**Return value**
:return:
The loaded image as a two-dimensional :class:`numpy.ndarray`.
"""
image_extension = path[path.rfind('.'):]
if image_extension == '.npy':
return np.array(np.load(path), dtype='float64')
elif image_extension == '.png':
return np.array(scipy.ndimage.imread(path, flatten=True) / 255.0,
dtype='float64')
else:
raise ValueError("This function can only load .png or .npy files.")
def _print_listlist(listlist):
for front, back, l in zip(['['] + ([' '] * (len(listlist) - 1)),
([''] * (len(listlist) - 1)) + [']'],
listlist):
print(front + str(l) + back)
def my_ravel(coeff):
r"""
The subsampled alpha-shearlet transform returns a list of differently
sized(!) two-dimensional arrays. Likewise, the fully sampled transform
yields a three dimensional numpy array containing the coefficients.
The present function can be used (in both cases) to convert this list into
a single *one-dimensional* numpy array.
.. note::
In order to invert this conversion to a one-dimensional array,
use the associated function :func:`my_unravel`. Precisely,
:func:`my_unravel` satisfies
``my_unravel(my_trafo, my_ravel(coeff)) == coeff``,
if coeff is obtained from calling ``my_trafo.transform(im)``
for some image ``im``.
The preceding equality holds at least up to (negligible)
differences (the left-hand side is a generator while the
right-hand side could also be a list).
**Required parameter**
:param list coeff:
A list (or a generator) containing/producing two-dimensional
numpy arrays.
**Return value**
:return:
A one-dimensional :class:`numpy.ndarray` from which **coeff** can
be reconstructed.
"""
return np.concatenate([c.ravel() for c in coeff])
def my_unravel(trafo, coeff):
r"""
This method is a companion method to :func:`my_ravel`.
See the documentation of that function for more details.
**Required parameters**
:param trafo:
An object of class :class:`AlphaTransform.AlphaShearletTransform`.
:param numpy.ndarray coeff:
A one-dimensional numpy array, obtained via
``my_ravel(coeff_unrav)``, where ``coeff_unrav`` is of the same
dimensions as the output of ``trafo.transform(im)``, where
``im`` is an image.
**Return value**
:return:
A generator producing the same values as ``coeff_unrav``, i.e.,
an "unravelled" version of ``coeff``.
"""
coeff_sizes = [spec.shape for spec in trafo.spectrograms]
split_points = np.cumsum([spec.size for spec in trafo.spectrograms])
return (c.reshape(size)
for size, c in zip(coeff_sizes, np.split(coeff, split_points)))
|
[
"felix.voigtlaender@gmail.com"
] |
felix.voigtlaender@gmail.com
|
c10ea4aaf707b2472d05f5082eeeb2cded2d7235
|
e69aa8050bced4e625928e3e18e14e892ba860dc
|
/Partial_Permutations.py
|
5886fbe97a1612b6882017146363daf371f01eae
|
[
"MIT"
] |
permissive
|
Esprit-Nobel/ROSALIND
|
e65cf85f1fbe0660cda547926d91be3f109edce9
|
ec964f6d9cc5d97339106c89df865fb105251928
|
refs/heads/master
| 2021-01-12T18:16:19.768656
| 2016-11-02T14:06:50
| 2016-11-02T14:06:50
| 71,357,591
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 392
|
py
|
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Tue Oct 18 18:18:43 2016
@author: yannick
"""
import sys
import math
with open(sys.argv[1], "r") as fichier_lu:
CONTENU = fichier_lu.readlines()
NUM = CONTENU[0].strip("\n\r\t ").split()
TOT = ( math.factorial( long(NUM[0]) ) / \
math.factorial( long(NUM[0])-long(NUM[1]) ) ) \
% 1000000
print TOT
|
[
"esprit.nobel@orange.fr"
] |
esprit.nobel@orange.fr
|
b391859b94fd32af4b40bd699c1b6acde8391faf
|
edb884e3f639261f36bbb8f444e2200bb879a9a2
|
/diagfi_compare_singlemonth.py
|
baa02ec94263fd6a9e083e4dbd41e800d3960a62
|
[] |
no_license
|
draelsaid/MGCM-python
|
7df36a783829fadb1d89ec9e54f92470d54c0493
|
9ee1491f009bed5f092c21a9235d61e9612f32f0
|
refs/heads/master
| 2020-06-21T22:41:09.556055
| 2017-05-31T12:22:45
| 2017-05-31T12:22:45
| 74,768,319
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 40,806
|
py
|
# Compares NetCDF data from the Mars GCM for Full Mars Year by combining monthly output of diagfi.nc files
# Adam El-Said 08/2016
import matplotlib as mpl
#mpl.use('Agg') # removes need for X-Server (graphics in linux). For qsub only.
import numpy as np
import pylab as py
import matplotlib.colors as colors
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import make_axes_locatable
from mars_time import MarsTime
from scipy.io import *
from matplotlib import cm,ticker
from plt_timeseries import *
from matplotlib.ticker import FormatStrFormatter
from MidPointNorm import *
# Prints EVERYTHING inside a variable without holding back (intended for diagnostic)
np.set_printoptions(threshold=np.inf)
# Abbreviate sol_ls conversion function
sol_Ls=MarsTime().sol_ls
# Moving average
def moving_average(a, n=3) :
ret = np.cumsum(a, dtype=float)
ret[n:] = ret[n:] - ret[:-n]
return ret[n - 1:] / n
# Initialise dictionaries - due to data size
Ls_m = {}
psa, psb = {}, {}
presa, presb = {}, {}
tempa, tempb = {}, {}
tsurfa, tsurfb = {}, {}
ua, ub = {}, {}
va, vb = {}, {}
dustqa, dustqb = {}, {}
dustNa, dustNb = {}, {}
rhoa, rhob = {}, {}
fluxsurflwa, fluxsurflwb = {}, {}
fluxsurfswa, fluxsurfswb = {}, {}
fluxtoplwa, fluxtoplwb = {}, {}
fluxtopswa, fluxtopswb = {}, {}
taua, taub = {}, {}
rdusta, rdustb = {}, {}
lw_htrta, lw_htrtb = {}, {}
sw_htrta, sw_htrtb = {}, {}
dqsseda, dqssedb = {}, {}
dqsdeva, dqsdevb = {}, {}
# Grab topography from surface.nc or mola32.nc file
ml = netcdf.netcdf_file('/padata/mars/users/aes442/mgcm_data/surface.nc','r')
mola = {}
mola[0] = ml.variables['latitude'][:]
mola[1] = ml.variables['longitude'][:]
mola[2] = ml.variables['zMOL'][:]
# Import data from Luca's TES dust files for comparison
a = netcdf.netcdf_file('/padata/mars/users/aes442/mgcm_data/dust_MY28.nc','r')
d_lat_s = a.variables['latitude'][:]
d_lon_s = a.variables['longitude'][:]
d_t = a.variables['Time'][:]
d_d = a.variables['dustop'][:]
d_lat = np.linspace(-90,90,d_lat_s.shape[0])
d_lon = np.linspace(-180,180,d_lon_s.shape[0])
# Number of months in comparison (always add 1 because of Python indexing)
Months = 2 # No. of months
amth = 1 # Actual month
# This loop assigns the data in both directories to variables here. This is done for each month. The result is a dictionary of dictionaries. One dictionary containing a dictionary for every month.
for i in xrange(1,Months):
mgcm = "MGCM_v5-1"
rundira = "a_ds8"
rundirb = "a_ref4"
month = ("m%s" % (amth)) # CHANGE
filename = "diagfi.nc"
a = netcdf.netcdf_file("/padata/alpha/users/aes442/RUNS/R-%s/%s/%s/%s" % (mgcm,rundira,month,filename),'r')
b = netcdf.netcdf_file("/padata/alpha/users/aes442/RUNS/R-%s/%s/%s/%s" % (mgcm,rundirb,month,filename),'r')
lat = a.variables['lat'][:]
lon = a.variables['lon'][:]
sigma = a.variables['sigma'][:]
t_m = a.variables['time'][:]
Ls_m[i] = a.variables['Ls'][:]
psa[i] = a.variables['ps'][:]
presa[i] = a.variables['pressure'][:]
tempa[i] = a.variables['temp'][:]
tsurfa[i] = a.variables['tsurf'][:]
ua[i] = a.variables['u'][:]
va[i] = a.variables['v'][:]
dustqa[i] = a.variables['dustq'][:]
dustNa[i] = a.variables['dustN'][:]
rhoa[i] = a.variables['rho'][:]
fluxsurflwa[i] = a.variables['fluxsurf_lw'][:]
fluxsurfswa[i] = a.variables['fluxsurf_sw'][:]
fluxtoplwa[i] = a.variables['fluxtop_lw'][:]
fluxtopswa[i] = a.variables['fluxtop_sw'][:]
taua[i] = a.variables['taudustvis'][:]
rdusta[i] = a.variables['reffdust'][:]
lw_htrta[i] = a.variables['lw_htrt'][:]
sw_htrta[i] = a.variables['sw_htrt'][:]
dqsseda[i] = a.variables['dqssed'][:]
dqsdeva[i] = a.variables['dqsdev'][:]
psb[i] = b.variables['ps'][:]
presb[i] = b.variables['pressure'][:]
tempb[i] = b.variables['temp'][:]
tsurfb[i] = b.variables['tsurf'][:]
ub[i] = b.variables['u'][:]
vb[i] = b.variables['v'][:]
dustqb[i] = b.variables['dustq'][:]
dustNb[i] = b.variables['dustN'][:]
rhob[i] = b.variables['rho'][:]
fluxsurflwb[i] = b.variables['fluxsurf_lw'][:]
fluxsurfswb[i] = b.variables['fluxsurf_sw'][:]
fluxtoplwb[i] = b.variables['fluxtop_lw'][:]
fluxtopswb[i] = b.variables['fluxtop_sw'][:]
taub[i] = b.variables['taudustvis'][:]
rdustb[i] = b.variables['reffdust'][:]
lw_htrtb[i] = b.variables['lw_htrt'][:]
sw_htrtb[i] = b.variables['sw_htrt'][:]
dqssedb[i] = b.variables['dqssed'][:]
dqsdevb[i] = b.variables['dqsdev'][:]
# Calculate approximate HEIGHT from sigma (km)
alt = np.zeros((sigma.shape[0]))
for i in xrange(len(sigma)):
alt[i] = -10.8*np.log(sigma[i])
print "Latitude: %i || Longitude: %i || Model levels: %i => Alt Min:%.3f | Alt Max:%.3f | Alt half: %.3f " % (lat.shape[0],lon.shape[0],sigma.shape[0],alt[0],alt[-1],alt[18])
alt_half=18 # 47.8km
# Get time dimension length
n = 0
for i in xrange(1,len(psa)+1,1): # len(psa) gives the number of months
n = n + len(dustqa[i]) # len(dustqa[i]) gives the number of time steps in each month.
print ("Total time steps: %i" % (n))
## Ls vector
Ls_s = (Months-1)*30 # Number of solar longitudes for time vector for comparison
Ls = np.zeros((n))
# Method 2 grabs Ls's from model (has bugs, but can be ironed out)
p=0
for i in xrange(1,len(Ls_m)+1,1):
gg = Ls_m[i]
for j in xrange(gg.shape[0]):
Ls[p] = gg[j]
p = p + 1
Ls = np.roll(Ls,5)
Ls[-1] = np.ceil(Ls[-2])
Ls[:6] = np.linspace(np.floor(Ls[5]),Ls[5],6)
print Ls[:8], Ls[-8:]
## Create all other variables, with altitude dimension removed
ps_a, ps_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
temp_a, temp_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
tsurf_a, tsurf_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
u_a, u_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
v_a, v_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
dustq_a, dustq_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
dustN_a, dustN_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
rho_a, rho_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
fslwa, fslwb = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
fsswa, fsswb = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
ftlwa, ftlwb = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
ftswa, ftswb = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
tau_a, tau_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
rdust_a, rdust_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
lw_htrt_a, lw_htrt_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
sw_htrt_a, sw_htrt_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
pres_a, pres_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
dqssed_a, dqssed_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
dqsdev_a, dqsdev_b = np.zeros((n,lat.shape[0],lon.shape[0])), np.zeros((n,lat.shape[0],lon.shape[0]))
# 3D Vars
ps_a, ps_b = psa[1][:,:,:], psb[1][:,:,:]
fslwa, fslwb = fluxsurflwa[1][:,:,:], fluxsurflwb[1][:,:,:]
fsswa, fsswb = fluxsurfswa[1][:,:,:], fluxsurfswb[1][:,:,:]
ftlwa, ftlwb = fluxtoplwa[1][:,:,:], fluxtoplwb[1][:,:,:]
ftswa, ftswb = fluxtopswa[1][:,:,:], fluxtopswb[1][:,:,:]
tau_a, tau_b = taua[1][:,:,:], taub[1][:,:,:]
tsurf_a, tsurf_b = tsurfa[1][:,:,:], tsurfb[1][:,:,:]
dqssed_a, dqssed_b = dqsseda[1][:,:,:], dqssedb[1][:,:,:]
dqsdev_a, dqsdev_b = dqsdeva[1][:,:,:], dqsdevb[1][:,:,:]
# 4D Vars
temp_a, temp_b = tempa[1][:,1,:,:], tempb[1][:,1,:,:]
u_a, u_b = ua[1][:,1,:,:], ub[1][:,1,:,:]
v_a, v_b = va[1][:,1,:,:], vb[1][:,1,:,:]
dustq_a, dustq_b = dustqa[1][:,1,:,:], dustqb[1][:,1,:,:]
dustN_a, dustN_b = dustNa[1][:,1,:,:], dustNb[1][:,1,:,:]
rho_a, rho_b = rhoa[1][:,1,:,:], rhob[1][:,1,:,:]
rdust_a, rdust_b = rdusta[1][:,1,:,:], rdustb[1][:,1,:,:]
lw_htrt_a, lw_htrt_b = lw_htrta[1][:,1,:,:], lw_htrtb[1][:,1,:,:]
sw_htrt_a, sw_htrt_b = sw_htrta[1][:,1,:,:], sw_htrtb[1][:,1,:,:]
pres_a, pres_b = presa[1][:,1,:,:], presb[1][:,1,:,:]
# Longitudal averaging
# Variables without longitude
temp_aa, temp_bb = np.zeros((n,sigma.shape[0],lat.shape[0])), np.zeros((n,sigma.shape[0],lat.shape[0]))
tsurf_aa, tsurf_bb = np.zeros((n,sigma.shape[0],lat.shape[0])), np.zeros((n,sigma.shape[0],lat.shape[0]))
u_aa, u_bb = np.zeros((n,sigma.shape[0],lat.shape[0])), np.zeros((n,sigma.shape[0],lat.shape[0]))
dustq_aa, dustq_bb = np.zeros((n,sigma.shape[0],lat.shape[0])), np.zeros((n,sigma.shape[0],lat.shape[0]))
dustN_aa, dustN_bb = np.zeros((n,sigma.shape[0],lat.shape[0])), np.zeros((n,sigma.shape[0],lat.shape[0]))
rho_aa, rho_bb = np.zeros((n,sigma.shape[0],lat.shape[0])), np.zeros((n,sigma.shape[0],lat.shape[0]))
rdust_aa, rdust_bb = np.zeros((n,sigma.shape[0],lat.shape[0])), np.zeros((n,sigma.shape[0],lat.shape[0]))
lw_htrt_aa, lw_htrt_bb = np.zeros((n,sigma.shape[0],lat.shape[0])), np.zeros((n,sigma.shape[0],lat.shape[0]))
sw_htrt_aa, sw_htrt_bb = np.zeros((n,sigma.shape[0],lat.shape[0])), np.zeros((n,sigma.shape[0],lat.shape[0]))
pres_aa, pres_bb = np.zeros((n,sigma.shape[0],lat.shape[0])), np.zeros((n,sigma.shape[0],lat.shape[0]))
# 4D Vars
temp_aa, temp_bb = np.sum(tempa[1],axis=3)/tempa[1].shape[3], np.sum(tempb[1],axis=3)/tempb[1].shape[3]
u_aa, u_bb = np.sum(ua[1],axis=3)/ua[1].shape[3], np.sum(ub[1],axis=3)/ub[1].shape[3]
dustq_aa, dustq_bb = np.sum(dustqa[1],axis=3)/dustqa[1].shape[3], np.sum(dustqb[1],axis=3)/dustqb[1].shape[3]
dustN_aa, dustN_bb = np.sum(dustNa[1],axis=3)/dustNa[1].shape[3], np.sum(dustNb[1],axis=3)/dustNb[1].shape[3]
rho_aa, rho_bb = np.sum(rhoa[1],axis=3)/rhoa[1].shape[3], np.sum(rhob[1],axis=3)/rhob[1].shape[3]
rdust_aa, rdust_bb = np.sum(rdusta[1],axis=3)/rdusta[1].shape[3], np.sum(rdustb[1],axis=3)/rdustb[1].shape[3]
lw_htrt_aa, lw_htrt_bb = np.sum(lw_htrta[1],axis=3)/lw_htrta[1].shape[3], np.sum(lw_htrtb[1],axis=3)/lw_htrtb[1].shape[3]
sw_htrt_aa, sw_htrt_bb = np.sum(sw_htrta[1],axis=3)/sw_htrta[1].shape[3], np.sum(sw_htrtb[1],axis=3)/sw_htrtb[1].shape[3]
pres_aa, pres_bb = np.sum(presa[1],axis=3)/presa[1].shape[3], np.sum(presb[1],axis=3)/presb[1].shape[3]
# Calculate differences
dustq_diff = dustq_a - dustq_b
dustN_diff = dustN_a - dustN_b
temp_diff = temp_a - temp_b
tsurf_diff = tsurf_a - tsurf_b
ps_diff = ps_a - ps_b
rho_diff = rho_a - rho_b
u_diff = u_a - u_b
v_diff = v_a - v_b
rdust_diff = rdust_a - rdust_b
lw_htrt_diff = lw_htrt_a - lw_htrt_b
sw_htrt_diff = sw_htrt_a - sw_htrt_b
pres_diff = pres_a - pres_b
dqssed_diff = dqssed_a - dqssed_b
dqsdev_diff = dqsdev_a - dqsdev_b
fslw_diff = fslwa - fslwb
fssw_diff = fsswa - fsswb
ftlw_diff = ftlwa - ftlwb
ftsw_diff = ftswa - ftswb
t_d = temp_aa - temp_bb
pres_d = pres_aa - pres_bb
ts_d = tsurf_aa - tsurf_bb
dq_d = dustq_aa - dustq_bb
dN_d = dustN_aa - dustN_bb
rho_d = rho_aa - rho_bb
u_d = u_aa - u_bb
rdust_d = rdust_aa - rdust_bb
lw_htrt_d = lw_htrt_aa - lw_htrt_bb
sw_htrt_d = sw_htrt_aa - sw_htrt_bb
# Zonal averaging (time,lat)
temp_avg = np.sum(temp_a,axis=2)/temp_a.shape[2] - np.sum(temp_b,axis=2)/temp_b.shape[2]
tsurf_avg = np.sum(tsurf_a,axis=2)/tsurf_a.shape[2] - np.sum(tsurf_b,axis=2)/tsurf_b.shape[2]
ps_avg = np.sum(ps_a,axis=2)/ps_a.shape[2] - np.sum(ps_b,axis=2)/ps_b.shape[2]
pres_avg = np.sum(pres_a,axis=2)/pres_a.shape[2] - np.sum(pres_b,axis=2)/pres_b.shape[2]
u_avg = np.sum(u_a,axis=2)/u_a.shape[2] - np.sum(u_b,axis=2)/u_b.shape[2]
rho_avg = np.sum(rho_a,axis=2)/rho_a.shape[2] - np.sum(rho_b,axis=2)/rho_b.shape[2]
fssw_avg = np.sum(fsswa,axis=2)/fsswa.shape[2] - np.sum(fsswb,axis=2)/fsswb.shape[2]
fslw_avg = np.sum(fslwa,axis=2)/fslwa.shape[2] - np.sum(fslwb,axis=2)/fslwb.shape[2]
ftsw_avg = np.sum(ftswa,axis=2)/ftswa.shape[2] - np.sum(ftswb,axis=2)/ftswb.shape[2]
ftlw_avg = np.sum(ftlwa,axis=2)/ftlwa.shape[2] - np.sum(ftlwb,axis=2)/ftlwb.shape[2]
tau_a_avg = np.sum(tau_a,axis=2)/tau_a.shape[2]
tau_b_avg = np.sum(tau_b,axis=2)/tau_b.shape[2]
rdust_avg = np.sum(rdust_a,axis=2)/rdust_a.shape[2] - np.sum(rdust_b,axis=2)/rdust_b.shape[2]
lw_htrt_avg = np.sum(lw_htrt_a,axis=2)/lw_htrt_a.shape[2] - np.sum(lw_htrt_b,axis=2)/lw_htrt_b.shape[2]
sw_htrt_avg = np.sum(sw_htrt_a,axis=2)/sw_htrt_a.shape[2] - np.sum(sw_htrt_b,axis=2)/sw_htrt_b.shape[2]
temp_avg_ = np.sum(temp_b,axis=2)/temp_b.shape[2]
pres_avg_ = np.sum(pres_b,axis=2)/pres_b.shape[2]
tsurf_avg_ = np.sum(tsurf_b,axis=2)/tsurf_b.shape[2]
ps_avg_ = np.sum(ps_b,axis=2)/ps_b.shape[2]
u_avg_ = np.sum(u_b,axis=2)/u_b.shape[2]
rho_avg_ = np.sum(rho_b,axis=2)/rho_b.shape[2]
fssw_avg_ = np.sum(fsswb,axis=2)/fsswb.shape[2]
fslw_avg_ = np.sum(fslwb,axis=2)/fslwb.shape[2]
ftsw_avg_ = np.sum(ftswb,axis=2)/ftswb.shape[2]
ftlw_avg_ = np.sum(ftlwb,axis=2)/ftlwb.shape[2]
# from 35N to 55N Lat
#tmp_ = np.sum(np.sum(temp_avg_[:,7:11],axis=0)/n,axis=0)/4
#tmps_ = np.sum(np.sum(tsurf_avg_[:,7:11],axis=0)/n,axis=0)/4
#ps_ = np.sum(np.sum(ps_avg_[:,7:11],axis=0)/n,axis=0)/4
#pres_ = np.sum(np.sum(pres_avg_[:,7:11],axis=0)/n,axis=0)/4
#rho_ = np.sum(np.sum(rho_avg_[:,7:11],axis=0)/n,axis=0)/4
#u_ = np.sum(np.sum(np.absolute(u_avg_[:,7:11]),axis=0)/n,axis=0)/4
#fslw_ = np.sum(np.sum(fslw_avg_[:,7:11],axis=0)/n,axis=0)/4
#fssw_ = np.sum(np.sum(fssw_avg_[:,7:11],axis=0)/n,axis=0)/4
#ftlw_ = np.sum(np.sum(ftlw_avg_[:,7:11],axis=0)/n,axis=0)/4
#ftsw_ = np.sum(np.sum(ftsw_avg_[:,7:11],axis=0)/n,axis=0)/4
#tmp_1 = np.sum(np.sum(temp_avg[:,7:11],axis=0)/n,axis=0)/4
#tmps_1 = np.sum(np.sum(tsurf_avg[:,7:11],axis=0)/n,axis=0)/4
#ps_1 = np.sum(np.sum(ps_avg[:,7:11],axis=0)/n,axis=0)/4
#pres_1 = np.sum(np.sum(pres_avg[:,7:11],axis=0)/n,axis=0)/4
#rho_1 = np.sum(np.sum(rho_avg[:,7:11],axis=0)/n,axis=0)/4
#u_1 = np.sum(np.sum(u_avg[:,7:11],axis=0)/n,axis=0)/4
#fslw_1 = np.sum(np.sum(fslw_avg[:,7:11],axis=0)/n,axis=0)/4
#fssw_1 = np.sum(np.sum(fssw_avg[:,7:11],axis=0)/n,axis=0)/4
#ftlw_1 = np.sum(np.sum(ftlw_avg[:,7:11],axis=0)/n,axis=0)/4
#ftsw_1 = np.sum(np.sum(ftsw_avg[:,7:11],axis=0)/n,axis=0)/4
#print "AVERAGES: tmp: %.2f || surf tmp: %.2f || press: %.2f || surf press: %.2f || dens: %.2f || zon wind: #%.2f || fluxes (inLW: %.2f, outLW: %.2f, inSW: %.2f, outSW: %.2f). " % (tmp_, tmps_, pres_, ps_, rho_, u_, #fslw_, ftlw_, fssw_, ftsw_)
#print tmp_1/tmp_, tmps_1/tmps_, pres_1/pres_, ps_1/ps_, rho_1/rho_, u_1/u_, fslw_1/fslw_, fssw_1/fssw_, ftlw_1/ftlw_, ftsw_1/ftsw_
# Time moving-point average of zonal average
nn=2 # Number of points to average over
t_avg = Ls[:-(nn-1)]
temp_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
pres_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
tsurf_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
ps_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
u_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
rho_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
fssw_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
fslw_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
ftsw_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
ftlw_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
rdust_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
lw_htrt_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
sw_htrt_avg_t = np.zeros((t_avg.shape[0],lat.shape[0]))
for i in xrange(0,lat.shape[0]):
temp_avg_t[:,i] = moving_average(temp_avg[:,i],n=nn)
pres_avg_t[:,i] = moving_average(pres_avg[:,i],n=nn)
tsurf_avg_t[:,i] = moving_average(tsurf_avg[:,i],n=nn)
ps_avg_t[:,i] = moving_average(ps_avg[:,i],n=nn)
u_avg_t[:,i] = moving_average(u_avg[:,i],n=nn)
rho_avg_t[:,i] = moving_average(rho_avg[:,i],n=nn)
fssw_avg_t[:,i] = moving_average(fssw_avg[:,i],n=nn)
fslw_avg_t[:,i] = moving_average(fslw_avg[:,i],n=nn)
ftsw_avg_t[:,i] = moving_average(ftsw_avg[:,i],n=nn)
ftlw_avg_t[:,i] = moving_average(ftlw_avg[:,i],n=nn)
rdust_avg_t[:,i] = moving_average(rdust_avg[:,i],n=nn)
lw_htrt_avg_t[:,i] = moving_average(lw_htrt_avg[:,i],n=nn)
sw_htrt_avg_t[:,i] = moving_average(sw_htrt_avg[:,i],n=nn)
############ TIME AVERAGE of differences ###################
nnn=nn
t_av = Ls[:-(nnn-1)]
td_avg = np.zeros((t_av.shape[0],sigma.shape[0],lat.shape[0]))
pres_avg = np.zeros((t_av.shape[0],sigma.shape[0],lat.shape[0]))
tds_avg = np.zeros((t_av.shape[0],sigma.shape[0],lat.shape[0]))
dqd_avg = np.zeros((t_av.shape[0],sigma.shape[0],lat.shape[0]))
dNd_avg = np.zeros((t_av.shape[0],sigma.shape[0],lat.shape[0]))
rhod_avg = np.zeros((t_av.shape[0],sigma.shape[0],lat.shape[0]))
ud_avg = np.zeros((t_av.shape[0],sigma.shape[0],lat.shape[0]))
rd_avg = np.zeros((t_av.shape[0],sigma.shape[0],lat.shape[0]))
lwhr_avg = np.zeros((t_av.shape[0],sigma.shape[0],lat.shape[0]))
swhr_avg = np.zeros((t_av.shape[0],sigma.shape[0],lat.shape[0]))
for j in xrange(0,lat.shape[0],1):
for i in xrange(0,sigma.shape[0],1):
td_avg[:,i,j] = moving_average(t_d[:,i,j],n=nnn)
pres_avg[:,i,j] = moving_average(pres_d[:,i,j],n=nnn)
tds_avg[:,i,j] = moving_average(ts_d[:,i,j],n=nnn)
dqd_avg[:,i,j] = moving_average(dq_d[:,i,j],n=nnn)
dNd_avg[:,i,j] = moving_average(dN_d[:,i,j],n=nnn)
rhod_avg[:,i,j] = moving_average(rho_d[:,i,j],n=nnn)
ud_avg[:,i,j] = moving_average(u_d[:,i,j],n=nnn)
rd_avg[:,i,j] = moving_average(rdust_d[:,i,j],n=nnn)
lwhr_avg[:,i,j] = moving_average(lw_htrt_d[:,i,j],n=nnn)
swhr_avg[:,i,j] = moving_average(sw_htrt_d[:,i,j],n=nnn)
# Save destination
fpath = "/home/physastro/aes442/results/Dustruns/m%i/" % (amth)
## Plot settings (MUST CHANGE FROM MONTH TO MONTH)
######################################################################################
# Which Ls do you want to focus on?
Ls_ee= 4.
Ls_e = 5.5
l_1 = np.where(Ls - Ls_ee > 0.001)[0][0]
l_2 = np.where(Ls - Ls_e > 0.001)[0][0]
Ls = Ls[l_1:l_2]
n = l_2 - l_1
## Dust storm insertion points (Ls - tstep_start - centre [lat,lon])
# m1 = 3.95 - 96 - [45, -135]
# m26 = 45.66 - 408 - [45, -90]
# m30 = 153.95 - 84 - [ 0, 0]
# m33 = 244.28 - 84 - [-2, -6]
# m34 = 273.52 - 60 - [-45, 90]
c = np.matrix('4. 45.') # Dust storm mid-points [Ls Lat]
#########################################################################################
######## TES dust files
# Zonal averaging
tau_d_z = d_d.sum(axis=2)/d_d.shape[2]
# Time averaging
nnnn=2
tau_d_avg=np.zeros((tau_d_z.shape[0]-(nnnn-1),tau_d_z.shape[1]))
for i in xrange(0,d_lat_s.shape[0]):
tau_d_avg[:,i] = moving_average(tau_d_z[:,i],nnnn)
# first and last sols
sol_a = int(np.round(669*(Ls_ee/360.)))
sol_s = int(np.round(669*(Ls_e/360.)))
tau_d_avg = tau_d_avg[sol_a:sol_s,:]
d_Ls_avg = np.linspace(Ls_ee,Ls_e,tau_d_avg.shape[0])
#########
## PLOTS
# Common settings (ticks)
t_t = np.linspace(Ls_ee,Ls_e,n)
t_tau = np.linspace(Ls_ee,Ls_e,n)
lat_t = np.linspace(90,-90,lat.shape[0])
lon_t = np.linspace(-180,180,lon.shape[0])
# Solar longitude
i_mj=0.2
i_mn=0.05
major_ticksx = np.arange(Ls_ee, Ls_e+i_mj, i_mj)
minor_ticksx = np.arange(Ls_ee, Ls_e, i_mn)
# Latitude
major_ticksy = np.arange(-90, 91, 30)
minor_ticksy = np.arange(-90, 91, 10)
## tau_ref, tau_ds, tau_tes PLOT
tau_ds = np.matrix.transpose(tau_a_avg)
tau_ds = tau_ds[:,l_1:l_2]
tau_ref = np.matrix.transpose(tau_b_avg)
tau_ref = tau_ref[:,l_1:l_2]
tau_TES = np.matrix.transpose(tau_d_avg)
f, axarr = plt.subplots(2, 1, sharex=True, sharey=True, figsize=(12,12), dpi=100)
x = t_tau
y = lat_t
xx = d_Ls_avg
yy = np.linspace(-90,90,d_lat_s.shape[0])
xlabel = 'Solar longitude / degrees'
ylabel = 'Latitude / degrees'
cb_label = 'Dust optical depth / SI'
# Common axis labels
f.text(0.5, 0.04, '%s' % (xlabel), fontsize=18, ha='center')
f.text(0.06, 0.5, '%s' % (ylabel), fontsize=18, va='center', rotation='vertical')
ax1 = axarr[0].pcolormesh(x, y, tau_ds, cmap='gist_rainbow_r', vmin=np.min((np.min(tau_ds),np.min(tau_ref),np.min(tau_TES))), vmax=np.max((np.max(tau_ds),np.max(tau_ref),np.max(tau_TES))))
axarr[0].axis('tight')
axarr[0].plot(c[0,0],c[0,1],'o',color='y',markersize=10)
axarr[0].set_xticks(major_ticksx)
axarr[0].set_xticks(minor_ticksx, minor=True)
axarr[0].set_yticks(major_ticksy)
axarr[0].set_yticks(minor_ticksy, minor=True)
axarr[0].set_title('(a) Dust storm run', fontsize=14)
axarr[0].tick_params(axis='both', labelsize=11, pad=10)
ax2 = axarr[1].pcolormesh(x, y, tau_ref, cmap='gist_rainbow_r', vmin=np.min((np.min(tau_ds),np.min(tau_ref),np.min(tau_TES))), vmax=np.max((np.max(tau_ds),np.max(tau_ref),np.max(tau_TES))))
axarr[1].set_title('(b) Reference run', fontsize=14)
# Colorbar creation and placement
f.subplots_adjust(right=0.8)
cbar_ax = f.add_axes([0.85, 0.1, 0.04, 0.8]) # [h_placement, v_placement, h_size, v_size]
cb = f.colorbar(ax1, cax=cbar_ax, format='%.1f', extend='both') # double-edged colorbar
cb.set_label('%s' % (cb_label), fontsize=16) # colorbar label
#f.subplots_adjust(right=0.8)
#cbar_ax = f.add_axes([0.85, 0.665, 0.04, 0.235]) # [h_placement, v_placement, h_size, v_size]
#cb = f.colorbar(ax1, cax=cbar_ax, format='%.1f', extend='both') # double-edged colorbar
#cb.set_label('%s' % (cb_label), fontsize=16) # colorbar label
#f.subplots_adjust(right=0.8)
#cbar_ax2 = f.add_axes([0.85, 0.38, 0.04, 0.235]) # [h_placement, v_placement, h_size, v_size]
#cb = f.colorbar(ax2, cax=cbar_ax2, format='%.1f', extend='both') # double-edged colorbar
#cb.set_label('%s' % (cb_label), fontsize=16) # colorbar label
#f.subplots_adjust(right=0.8)
#cbar_ax3 = f.add_axes([0.85, 0.095, 0.04, 0.235]) # [h_placement, v_placement, h_size, v_size]
#cb = f.colorbar(ax3, cax=cbar_ax3, format='%.1f', extend='both') # double-edged colorbar
#cb.set_label('%s' % (cb_label), fontsize=16) # colorbar label
plt.savefig("%sCDOD_latvsLs_dsrunvsrefrun.png" % (fpath), bbox_inches='tight')
## TEMP/WIND/TOPG map
# DATA
day = 1
hr = 96 # this is actually the tstep (t=96 is storm start)
lvl = 0
# variable[day][hour, elevation, lat, lon]
ut = ua[day][hr,lvl,:,:] - ub[day][hr,lvl,:,:]
vt = va[day][hr,lvl,:,:] - vb[day][hr,lvl,:,:]
#data = tempa[day][hr,lvl,:,:] - tempb[day][hr,lvl,:,:]
data = tsurfa[day][hr,:,:] - tsurfb[day][hr,:,:]
data2= presa[day][hr,:,:] - presb[day][hr,:,:]
# Longitude
major_ticksx = np.arange(np.floor(lon_t[0]), np.ceil(lon_t[-1]), 30)
minor_ticksx = np.arange(np.floor(lon_t[0]), np.ceil(lon_t[-1]), 10)
# Latitude
major_ticksy = np.arange(np.floor(lat_t[-1]), np.ceil(lat_t[0]), 30)
minor_ticksy = np.arange(np.floor(lat_t[-1]), np.ceil(lat_t[0]), 10)
## PLOT temperature/winds/topography
f, axarr = plt.subplots(1, 1, sharex=True, sharey=True, figsize=(10,10), dpi=100)
x = lon_t
y = lat_t
xlabel = 'Longitude / degrees'
ylabel = 'Latitude / degrees'
cblabel= 'Temperature difference / K'
plt.xlabel(xlabel, fontsize=14, labelpad=10)
plt.ylabel(ylabel, fontsize=14, labelpad=10)
# Main plot
ax = axarr.pcolormesh(x, y, data, cmap='RdBu_r', norm=MidPointNorm(midpoint=0.))
# Secondary plot
ax2 = axarr.quiver(x, y, ut, vt, scale=2**2, units='y', width=0.1)
aq = axarr.quiverkey(ax2, 0.815, 0.9, 1, r'$1 \frac{m}{s}$', labelpos='E', coordinates='figure')
# Topography
lvls = [-5,0,5,10,15]
ax3 = axarr.contour(mola[1], mola[0], mola[2], lvls, colors='k')
# Ticks
axarr.set_xticks(major_ticksx)
axarr.set_xticks(minor_ticksx, minor=True)
axarr.set_yticks(major_ticksy)
axarr.set_yticks(minor_ticksy, minor=True)
axarr.tick_params(axis='both', labelsize=12, pad=10)
axarr.axis('tight')
# Colour bar
f.subplots_adjust(right=0.8)
cbar_ax = f.add_axes([0.85, 0.1, 0.04, 0.8]) # [h_place, v_place, h_size, v_size]
cb = f.colorbar(ax, cax=cbar_ax, format='%.1f', extend='both') # double-edged colorbar
cb.set_label('%s' % (cblabel), fontsize=16) # colorbar label
plt.axis('tight')
plt.savefig("%stemp_uvwind_mola_latvslon.png" % (fpath), bbox_inches='tight')
plt.close('all')
## Temperature PLOT
temp_t = tsurf_avg_t.T
temp_t = temp_t[:,l_1:l_2]
fig = plt.figure(figsize=(10,10), dpi=100)
ax = fig.add_subplot(1,1,1)
plt.pcolormesh(t_t,lat_t,temp_t, norm=MidPointNorm(midpoint=0.), cmap='RdBu_r')
plt.xlabel('Solar longitude / degrees', fontsize=14, labelpad=10)
plt.ylabel('Latitude / degrees', fontsize=14, labelpad=10)
# Extra Markers
ax.plot(c[0,0],c[0,1],'o',color='y',markersize=10)
# Ticks
ax.set_xticks(major_ticksx)
ax.set_xticks(minor_ticksx, minor=True)
ax.set_yticks(major_ticksy)
ax.set_yticks(minor_ticksy, minor=True)
ax.tick_params(axis='both', labelsize=12, pad=10)
# Colour bar
cb = plt.colorbar(format='%.2f', extend='both')
cb.set_label('Temperature difference / K')
tick_locator = ticker.MaxNLocator(nbins=16)
cb.locator = tick_locator
plt.axis('tight')
plt.savefig("%sSurfTempDiff_LatvsTime_FY_uavg_tavg.png" % (fpath), bbox_inches='tight')
## Surface pressure and Atmospheric density at surface PLOT
ps_t = np.matrix.transpose(pres_avg_t)
ps_t = ps_t[:,l_1:l_2]
rho_t = np.matrix.transpose(rho_avg_t)
rho_t = rho_t[:,l_1:l_2]
f, axarr = plt.subplots(2, 1, sharex=True, sharey=True, figsize=(12,12), dpi=100)
x = t_t
y = lat_t
xlabel = 'Solar longitude / degrees'
ylabel = 'Latitude / degrees'
cb_label = 'Atmospheric pressure difference / Pa'
cb_label2 = 'Atmospheric density difference / kg / $m^3$'
# Common axis labels
f.text(0.5, 0.04, '%s' % (xlabel), fontsize=18, ha='center')
f.text(0.06, 0.5, '%s' % (ylabel), fontsize=18, va='center', rotation='vertical')
ax1 = axarr[0].pcolormesh(x, y, ps_t, norm=MidPointNorm(midpoint=0.), cmap='RdBu_r')
axarr[0].axis('tight')
axarr[0].plot(c[0,0],c[0,1],'o',color='y',markersize=10)
axarr[0].set_xticks(major_ticksx)
axarr[0].set_xticks(minor_ticksx, minor=True)
axarr[0].set_yticks(major_ticksy)
axarr[0].set_yticks(minor_ticksy, minor=True)
axarr[0].set_title('(a)', fontsize=18)
axarr[0].tick_params(axis='both', labelsize=14)
ax2 = axarr[1].pcolormesh(x, y, rho_t, norm=MidPointNorm(midpoint=0.), cmap='RdBu_r')
axarr[1].plot(c[0,0],c[0,1],'o',color='y',markersize=10)
axarr[1].set_title('(b)', fontsize=18)
# Colorbar creation and placement
f.subplots_adjust(right=0.8)
cbar_ax = f.add_axes([0.85, 0.54, 0.04, 0.36]) # [h_placement, v_placement, h_size, v_size]
cb = f.colorbar(ax1, cax=cbar_ax, format='%.1f', extend='both') # double-edged colorbar
cb.set_label('%s' % (cb_label), fontsize=14) # colorbar label
cbar_ax2 = f.add_axes([0.85, 0.1, 0.04, 0.36]) # [h_placement, v_placement, h_size, v_size]
cb2 = f.colorbar(ax2, cax=cbar_ax2, format='%.1e', extend='both') # double-edged colorbar
cb2.set_label('%s' % (cb_label2), fontsize=14) # colorbar label
plt.savefig("%sPresDensDiff_LatvsLs_zonavg_tavg.png" % (fpath), bbox_inches='tight')
# Zonal wind PLOT
u_t = np.matrix.transpose(u_avg_t)
u_t = u_t[:,l_1:l_2]
fig = plt.figure( figsize=(10,10), dpi=100)
ax = fig.add_subplot(1,1,1)
plt.pcolormesh(t_t,lat_t,u_t,norm=MidPointNorm(midpoint=0.), cmap='RdBu_r')
plt.xlabel('Solar longitude / degrees',fontsize=16)
plt.ylabel('Latitude / degrees',fontsize=16)
ax.plot(c[0,0],c[0,1],'o',color='y',markersize=10)
ax.set_xticks(major_ticksx)
ax.set_xticks(minor_ticksx, minor=True)
ax.set_yticks(major_ticksy)
ax.set_yticks(minor_ticksy, minor=True)
cb = plt.colorbar(format='%.1f', extend='both')
cb.set_label('Zonal wind velocity difference / m / s')
tick_locator = ticker.MaxNLocator(nbins=7)
cb.locator = tick_locator
cb.update_ticks()
plt.axis('tight')
plt.savefig("%sZonalWindDiff_LatvsTime_FY_uavg_tavg.png" % (fpath), bbox_inches='tight')
# ALL FLUXES on one plot
fslw_t = np.matrix.transpose(fslw_avg_t[l_1:l_2,:]) # Incoming (surf) long wave (IR) radiation
ftlw_t = np.matrix.transpose(ftlw_avg_t[l_1:l_2,:]) # Outgoing (top) long wave (IR) radiation
fssw_t = np.matrix.transpose(fssw_avg_t[l_1:l_2,:]) # Incoming (surf) short wave (VL) radiation
ftsw_t = np.matrix.transpose(ftsw_avg_t[l_1:l_2,:]) # Outgoing (top) short wave (VL) radiation
f, axarr = plt.subplots(2, 2, sharex=True, sharey=True, figsize=(12,12), dpi=100)
x = t_t
y = lat_t
xlabel = 'Solar longitude / degrees'
ylabel = 'Latitude / degrees'
cb_label = 'Radiative flux difference / W / $m^2$'
# Common axis labels
f.text(0.5, 0.04, '%s' % (xlabel), fontsize=18, ha='center')
f.text(0.06, 0.5, '%s' % (ylabel), fontsize=18, va='center', rotation='vertical')
ax1 = axarr[0,0].pcolormesh(x, y, fslw_t, norm=MidPointNorm(midpoint=0.), cmap='RdBu_r')
axarr[0,0].axis('tight')
axarr[0,0].plot(c[0,0],c[0,1],'o',color='y',markersize=10)
axarr[0,0].set_xticks(major_ticksx)
axarr[0,0].set_xticks(minor_ticksx, minor=True)
axarr[0,0].set_yticks(major_ticksy)
axarr[0,0].set_yticks(minor_ticksy, minor=True)
axarr[0,0].set_title('Incident flux at surface (LW) (a)', fontsize=10)
axarr[0,0].tick_params(axis='both', labelsize=10)
dv1 = make_axes_locatable(axarr[0,0])
cax1 = dv1.append_axes("right",size="5%",pad=0.05)
cb = f.colorbar(ax1,cax=cax1, format='%.1f', extend='both')
cb.set_label('%s' % (cb_label), fontsize=10)
ax2 = axarr[0,1].pcolormesh(x, y, ftlw_t, norm=MidPointNorm(midpoint=0.), cmap='RdBu_r')
axarr[0,1].plot(c[0,0],c[0,1],'o',color='y',markersize=10)
axarr[0,1].set_title('Outgoing flux at top (LW) (b)', fontsize=10)
axarr[0,1].tick_params(axis='both', labelsize=10)
dv2 = make_axes_locatable(axarr[0,1])
cax2 = dv2.append_axes("right",size="5%",pad=0.05)
cb2 = f.colorbar(ax2,cax=cax2, format='%.1f', extend='both')
cb2.set_label('%s' % (cb_label), fontsize=10)
ax3 = axarr[1,0].pcolormesh(x, y, fssw_t, norm=MidPointNorm(midpoint=0.), cmap='RdBu_r')
axarr[1,0].plot(c[0,0],c[0,1],'o',color='y',markersize=10)
axarr[1,0].set_title('Incident flux at surface (SW) (c)', fontsize=10)
axarr[1,0].tick_params(axis='both', labelsize=10)
dv3 = make_axes_locatable(axarr[1,0])
cax3 = dv3.append_axes("right",size="5%",pad=0.05)
cb3 = f.colorbar(ax3,cax=cax3, format='%.1f', extend='both')
cb3.set_label('%s' % (cb_label), fontsize=10)
ax4 = axarr[1,1].pcolormesh(x, y, ftsw_t, norm=MidPointNorm(midpoint=0.), cmap='RdBu_r')
axarr[1,1].plot(c[0,0],c[0,1],'o',color='y',markersize=10)
axarr[1,1].set_title('Outgoing flux at top (SW) (d)', fontsize=10)
axarr[1,1].tick_params(axis='both', labelsize=10)
dv4 = make_axes_locatable(axarr[1,1])
cax4 = dv4.append_axes("right",size="5%",pad=0.05)
cb4 = f.colorbar(ax4,cax=cax4, format='%.1f', extend='both')
cb4.set_label('%s' % (cb_label), fontsize=10)
# Colorbar creation and placement
#f.subplots_adjust(right=0.8)
#cbar_ax = f.add_axes([0.85, 0.1, 0.04, 0.8]) # [h_placement, v_placement, h_size, v_size]
#cb = f.colorbar(ax3, cax=cbar_ax, format='%.1f', extend='both') # double-edged colorbar
#cb.set_label('%s' % (cb_label), fontsize=14) # colorbar label
plt.savefig("%sfluxes_latvsLs_zonavg_tavg.png" % (fpath), bbox_inches='tight')
### Short-term Temperature and Heating rates at exact location vs Altitude (put in particle size or mmr)
# lat = 87.49999, 82.49999, 77.5, 72.5, 67.5, 62.5, 57.5, 52.5, 47.5, 42.5,
# 37.5, 32.5, 27.5, 22.5, 17.5, 12.5, 7.500001, 2.500001, -2.500001,
# -7.500003, -12.5, -17.5, -22.5, -27.5, -32.5, -37.5, -42.5, -47.5, -52.5,
# -57.5, -62.5, -67.5, -72.5, -77.5, -82.49999, -87.49999 ;
# lon = -180, -175, -170, -165, -160, -155, -150, -145, -140, -135, -130,
# -125, -120, -115, -110, -105, -100, -95, -90, -84.99999, -80, -75, -70,
# -65, -60, -55, -50, -45, -40, -35, -30, -25, -20, -15, -10, -5, 0, 5, 10,
# 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 84.99999, 90, 95,
# 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155, 160, 165,
# 170, 175 ;
## Dust storm insertion points (Ls - tstep_start - [lat,lon])
# m26 = 45.66 - 408 - [45, -90]
# m30 = 153.95 - 84 - [ 0, 0]
# m33 = 244.28 - 84 - [-2, -6]
# m34 = 273.52 - 60 - [-45, 90]
### Plot explaination
# Storm starts at tstep=96, which is midnight of sol 8 relative to (0,0). However the storm is at 135W (midpoint).
# So 360/24 = 15deg for each hour, meaning local time at 135W is 135/15=9hrs behind (0,0) local time, so at dust storm time insertion it is 15:00 locally.
# We want the plot to start 1 day before the storm, which will be at tstep=84, since each tstep accounts for 2 hours.
# From tstep=84 we push forward 10 hours for approximate midnight plot start
### In reality the plot starts at 01:00 the night before the storm, local time 135W.
f, axarr = plt.subplots(3, 1, sharex=True, sharey=True, figsize=(12,12), dpi=100)
tl1, tl2 =89, 125
al=15
latl, lonl=6, 9
d1 = tempa[1][tl1:tl2,:al,latl,lonl]
d2 = tempb[1][tl1:tl2,:al,latl,lonl]
d3 = (88800/24.)*(sw_htrta[1][tl1:tl2,:al,latl,lonl] + lw_htrta[1][tl1:tl2,:al,latl,lonl]) # NET heat rate (SW cooling, LW heating) changed from K/s to K/hr
d4 = rdusta[1][tl1:tl2,:al,latl,lonl]
d5 = dustqa[1][tl1:tl2,:al,latl,lonl]
data = np.matrix.transpose(d2)
data2 = np.matrix.transpose(d1)
data3 = np.matrix.transpose(d3)
data4 = np.matrix.transpose(d4)
data5 = np.matrix.transpose(d5)
y = alt[:al]
x = np.linspace(0,72,data.shape[1])
xlabel = 'Local time / hr'
ylabel = 'Altitude above surface / km'
cb_label = 'Temperature / K'
cb_label2 = 'Net heating rate / K / hr'
major_ticksx = np.arange(0,np.max(x)+1,6)
minor_ticksx = np.arange(0,np.max(x),2)
major_ticksy = np.arange(0,np.max(y)+1,10)
minor_ticksy = np.arange(0,np.max(y),2)
# Common axis labels
f.text(0.5, 0.04, '%s' % (xlabel), fontsize=16, ha='center')
f.text(0.06, 0.5, '%s' % (ylabel), fontsize=16, va='center', rotation='vertical')
ax1 = axarr[0].pcolormesh(x, y, data, cmap='jet')
axarr[0].axis('tight')
axarr[0].set_xticks(major_ticksx)
axarr[0].set_yticks(major_ticksy)
axarr[0].set_xticks(minor_ticksx, minor=True)
axarr[0].set_yticks(minor_ticksy, minor=True)
axarr[0].set_title('Reference run (a)', fontsize=10)
axarr[0].tick_params(axis='both', labelsize=14)
ax2 = axarr[1].pcolormesh(x, y, data2, cmap='jet')
axarr[1].set_title('Dust storm run (b)', fontsize=10)
axarr[1].tick_params(axis='both', labelsize=14)
axarr[1].add_patch(mpl.patches.Rectangle((14, 0), 24, 9, facecolor="none", linestyle='dashed'))
ax3 = axarr[2].pcolormesh(x, y, data3, cmap='RdBu_r', vmax=10, vmin=-10)
axarr[2].set_title('Dust storm run (c)', fontsize=10)
axarr[2].tick_params(axis='both', labelsize=14)
axarr[2].add_patch(mpl.patches.Rectangle((14, 0), 24, 9, facecolor="none", linestyle='dashed'))
lvl = np.array([10**-6,10**-5,1*10**-4,10**-3]) # Contour levels
ax = axarr[2].contour(x,y,data5,lvl,colors='k',linewidth=3,locator=ticker.LogLocator())
plt.clabel(ax, fontsize=9, inline=1,fmt='%2.0e')
f.subplots_adjust(right=0.8)
cbar_ax = f.add_axes([0.85, 0.38, 0.02, 0.52]) # [h_placement, v_placement, h_size, v_size]
cb = f.colorbar(ax1, cax=cbar_ax, format='%.0f', extend='both') # double-edged colorbar
cb.set_label('%s' % (cb_label), fontsize=16) # colorbar label
f.subplots_adjust(right=0.8)
cbar_ax2 = f.add_axes([0.85, 0.095, 0.02, 0.235]) # [h_placement, v_placement, h_size, v_size]
cb = f.colorbar(ax3, cax=cbar_ax2, format='%.0f', extend='both') # double-edged colorbar
cb.set_label('%s' % (cb_label2), fontsize=16) # colorbar label
#locs,labels = py.xticks()
#py.xticks(locs, map(lambda x: "%02d" % x, locs*1e9))
plt.savefig("%sheating.png" % (fpath), bbox_inches='tight')
plt.close('all')
### Time series plots
# settings
s_l = [-2.05, -6.12, 242.7] # landing site marking on plot (actually for 244.7, Ls is messed up)
ticky_latlon = [60,10,30,10] # tick settings [xmajor,xminor,ymajor,yminor] ticks
ticky_latalt = [60,10,20,10]
int_Ls = int(np.ceil(Ls.shape[0]/(12*Months)))
# Dust particle size contours
rd_ds1 = {}
rd_ds1[0] = alt[:alt_half]
rd_ds1[1] = lat_t
rd_ds1[2] = rd_avg[:,:alt_half,:]
# dust mmr average difference contours
dqd_ds = {}
dqd_ds[0] = alt[:alt_half]
dqd_ds[1] = lat_t
dqd_ds[2] = dqd_avg[:,:alt_half,:]
wind = {}
wind[0] = u_diff
wind[1] = v_diff
## Dust storm 1 Time series dustq (mmr) (time, lat, lon)
plt_timeseries(dustq_diff[l_1:,:,:], lon_t, lat_t, Ls_m[1][l_1:], 4,4, ticky_latlon, 'Longitude / degrees', 'Latitude / degrees', 'Ls: ', 'Dust MMR difference / kg / kg', 3, '%sDustqdiff_latlon_tseries_ds1.png' % (fpath), mola)
alt_t = alt # Height of 20.9km
latll = 26
dustq_diff_altlon = dustqa[1][l_1:,:,latll,:] - dustqb[1][l_1:,:,latll,:]
temp_diff_altlon = tempa[1][l_1:,:,latll,:] - tempb[1][l_1:,:,latll,:]
plt_timeseries(temp_diff_altlon, lon_t, alt_t, Ls, 4,4, ticky_latalt, 'Longitude / degrees', 'Altitude / km', 'Ls: ', 'Temperature difference / K', int_Ls, '%stemp_altlon_tseries_ds1.png' % (fpath))
a
plt_timeseries(dustq_diff_altlon, lon_t, alt_t, Ls_m[1][l_1:], 4, 4, ticky_latalt, 'Longitude / degrees', 'Altitude / km', 'Ls: ', 'Dust MMR difference / kg / kg', 3, '%sdustq_altlon_tseries_ds1.png' % (fpath))
plt.close('all')
## IMPACT CALCULATIONS
## Dust storm insertion points (Ls - tstep_start - [lat,lon])
### DS1 m1 = 3.95 - (96-120, 2 sol) - [45, -135] (ORIGINAL DS)
llat1, llat2 = 22.5, 67.5
llon1, llon2 = -155., -115.
lalt1, lalt2 = 0., 8.
ts1, ts2 = 120, 132
### DS2 m26 = 45.66 - 408 - [45, -90]
#llat1, llat2 = 22.5, 67.5
#llon1, llon2 = -110., -70.
#lalt1, lalt2 = 0., 8.
#ts1, ts2 = 420, 432
### DS3 m30 = 153.95 - 84 - [ 0, 0]
#llat1, llat2 = -22.5, 22.5
#llon1, llon2 = -20., 20.
#lalt1, lalt2 = 0., 8.
#ts1, ts2 = 96, 108
### DS4 m33 = 244.28 - 84 - [-2, -6] (EXOMARS)
#llat1, llat2 = -22.5, 22.5
#llon1, llon2 = -20., 20.
#lalt1, lalt2 = 0., 8.
#ts1, ts2 = 96, 108
### DS5 m34 = 273.52 - 60 - [-45, 90]
#llat1, llat2 = -67.5, -22.5
#llon1, llon2 = 70., 110.
#lalt1, lalt2 = 0., 8.
#ts1, ts2 = 72, 84
lat_1, lat_2 = np.where(lat - llat2 >= 0.001)[0][-1]+1, np.where(lat - llat1 >= 0.001)[0][-1]+1
lon_1, lon_2 = np.where(lon - llon1 >= 0.001)[0][0]-1, np.where(lon - llon2 >= 0.001)[0][0]-1
alt_1, alt_2 = 0., np.where(alt - lalt2 >= 0.001)[0][0]
# Loop to compute impact
re_err, avg_t = {}, {}
re, avg = {}, {}
day = 1
var_da = [dustqa[1], dustNa[1], tempa[1], tsurfa[1], presa[1], psa[1], ua[1], va[1], rhoa[1], fluxsurflwa[1], fluxsurfswa[1], fluxtoplwa[1], fluxtopswa[1]]
var_db = [dustqb[1], dustNb[1], tempb[1], tsurfb[1], presb[1], psb[1], ub[1], vb[1], rhob[1], fluxsurflwb[1], fluxsurfswb[1], fluxtoplwb[1], fluxtopswb[1]]
re[day] = np.zeros([len(var_da), (ts2-ts1)+1])
avg[day] = np.zeros([len(var_da), (ts2-ts1)+1])
re_err[day] = np.zeros(len(var_da))
avg_t[day] = np.zeros(len(var_da))
for n in xrange(0, len(var_da)):
data_a = var_da[n]
data_b = var_db[n]
if len(data_a.shape)==4:
m=0
for j in xrange(ts1, ts2+1):
aa = data_a[j,alt_1:alt_2,lat_1:lat_2,lon_1:lon_2].flatten() - data_b[j,alt_1:alt_2,lat_1:lat_2,lon_1:lon_2].flatten()
a_ref = data_b[j,alt_1:alt_2,lat_1:lat_2,lon_1:lon_2].flatten()
avg[day][n,m] = sum(a_ref)/a_ref.shape[0]
re[day][n,m] = np.linalg.norm(aa) / np.linalg.norm(a_ref)
m=m+1
else:
m=0
for j in xrange(ts1, ts2+1):
aa = data_a[j,lat_1:lat_2,lon_1:lon_2].flatten() - data_b[j,lat_1:lat_2,lon_1:lon_2].flatten()
a_ref = data_b[j,lat_1:lat_2,lon_1:lon_2].flatten()
avg[day][n,m] = sum(a_ref)/a_ref.shape[0]
re[day][n,m] = np.linalg.norm(aa) / np.linalg.norm(a_ref)
m=m+1
re[day][(np.isnan(re[day])==True)] = 0.
re_err[day][n] = sum(re[day][n,:]) / re[day][n,:].shape[0]
avg_t[day][n] = sum(avg[day][n,:]) / avg[day][n,:].shape[0]
np.savetxt("%srelative_errors_t.txt" % (fpath), re[1], fmt='%.2e')
np.savetxt("%srelative_errors.txt" % (fpath), re_err[1], fmt='%.2e')
np.savetxt("%saverages.txt" % (fpath), avg[1], fmt='%.2e')
np.savetxt("%saverages_t.txt" % (fpath), avg_t[1], fmt='%.2e')
|
[
"adam.el-said@open.ac.uk"
] |
adam.el-said@open.ac.uk
|
18c4b876571211b4d59ba56578c12df35106481c
|
5f08d36d8cf92bff8c778eb4fa04e0df4b5768b1
|
/Week10/CurveFitting.py
|
f1719852ab0bba0e27a75c1874c86a835d44f949
|
[] |
no_license
|
npilgram/PHYS202-S13
|
ae22e5ced93fdedfe757187c8a364a9c3cb359a9
|
8ed9162d820e61aae624f5e646b894e83ce5faca
|
refs/heads/master
| 2021-01-02T23:13:38.342579
| 2013-06-15T02:47:14
| 2013-06-15T02:47:14
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 924
|
py
|
import numpy as np
def LinearLeastSquaresFit(x,y):
"""Take in arrays representing (x,y) values for set of linearly varying data and perform
a linear least squares regression. Return the resulting slope and intercept parameters of
the best fit line with their uncertainties."""
x_ave = np.sum(x)/len(x)
y_ave = np.sum(y)/len(y)
xsqr_ave = np.sum((x*x))/len((x*x))
xy_ave = np.sum((x*y))/len((x*y))
m = (xy_ave - (x_ave*y_ave))/(xsqr_ave - (x_ave**2))
b = ((xsqr_ave*y_ave)-(x_ave*xy_ave))/(xsqr_ave - (x_ave**2))
uncer = np.zeros(len(x))
for i in range(len(x)):
uncer[i]=y[i]-((m*x[i])+b)
uncer_sqr_ave = np.sum((uncer*uncer))/len((uncer*uncer))
m_err = np.sqrt((1/(len(x)-2.))*(uncer_sqr_ave/(xsqr_ave -(x_ave**2))))
b_err = np.sqrt((1/(len(x)-2.))*((uncer_sqr_ave*xsqr_ave)/(xsqr_ave -(x_ave**2))))
return (m,b,m_err,b_err)
|
[
"npilgram@calpoly.edu"
] |
npilgram@calpoly.edu
|
26edd3c2bede88520759eec09c94b180a897f414
|
58579a68a94967abb1b8d74cab06f687f4a79a7b
|
/PythonStyle/code_sample_test.py
|
fee48cead8af0cc166df1e5fd80a4ff6024f53bc
|
[] |
no_license
|
imdsoho/python
|
3c65cb9b19c2b2299d5bca67ebcde7d7f2f8bec2
|
eed1ef3e835f2ab77e4e197a689a9595bd93243e
|
refs/heads/master
| 2020-04-16T06:38:49.089727
| 2020-02-05T09:11:44
| 2020-02-05T09:11:44
| 165,355,451
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,283
|
py
|
class cust_slice(object):
"""
slice(stop)
slice(start, stop[, step])
Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).
"""
def indices(self, len): # real signature unknown; restored from __doc__
"""
S.indices(len) -> (start, stop, stride)
Assuming a sequence of length len, calculate the start and stop
indices, and the stride length of the extended slice described by
S. Out of bounds indices are clipped in a manner consistent with the
handling of normal slices.
"""
pass
def __eq__(self, *args, **kwargs): # real signature unknown
""" Return self==value. """
pass
def __getattribute__(self, *args, **kwargs): # real signature unknown
""" Return getattr(self, name). """
pass
def __ge__(self, *args, **kwargs): # real signature unknown
""" Return self>=value. """
pass
def __gt__(self, *args, **kwargs): # real signature unknown
""" Return self>value. """
pass
def __init__(self, stop): # real signature unknown; restored from __doc__
print("__init__")
pass
def __le__(self, *args, **kwargs): # real signature unknown
""" Return self<=value. """
pass
def __lt__(self, *args, **kwargs): # real signature unknown
""" Return self<value. """
pass
@staticmethod # known case of __new__
def __new__(*args, **kwargs): # real signature unknown
""" Create and return a new object. See help(type) for accurate signature. """
print("__new__")
print(args)
print(kwargs)
pass
def __ne__(self, *args, **kwargs): # real signature unknown
""" Return self!=value. """
pass
def __reduce__(self, *args, **kwargs): # real signature unknown
""" Return state information for pickling. """
pass
def __repr__(self, *args, **kwargs): # real signature unknown
""" Return repr(self). """
pass
start = property(lambda self: 0)
""":type: int"""
step = property(lambda self: 0)
""":type: int"""
stop = property(lambda self: 0)
""":type: int"""
__hash__ = None
sl = cust_slice(1)
print(sl)
|
[
"imdsoho@gmail.com"
] |
imdsoho@gmail.com
|
1e65771ae50c232198a15764de8fa56266b68719
|
646c30e512e7ead3de33974e856f1a0ef242fec8
|
/Educational Codeforces Round 73/C. Perfect Team.py
|
b972a3b41cc05690f80a2878cd9c667420188aad
|
[] |
no_license
|
Hybrid-Skills/Codeforces
|
2194f6d78186b8f6af5389ae6eccdd45c724ee23
|
68f281ba3d14ee039aa89238f3545bf06b90bc74
|
refs/heads/master
| 2020-06-03T02:38:24.502731
| 2019-11-16T16:30:25
| 2019-11-16T16:30:25
| 191,399,681
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 292
|
py
|
for _ in range(int(input())):
c, m, x = map(int, input().split())
maxi = (c + m + x)//3
if c >= m:
if m <= maxi:
print(m)
elif m > maxi:
print(maxi)
else:
if c <= maxi:
print(c)
else:
print(maxi)
|
[
"ankurgoyal616@gmail.com"
] |
ankurgoyal616@gmail.com
|
791732e7600f99bd887cc9a3ffddbe99e5bf9c14
|
fe7feafddd2b03814046039411afbaafd1cdcd43
|
/b7/b7.py
|
7b38e13986d44c3e30b1ada5028f64862afafad0
|
[] |
no_license
|
vamsikrishna2421/Scripting-Languages
|
d87e668eb8d0d9002cd32bed301a7795d4477908
|
89fc94ff6d0e77a4e75bbee3a127ac0b3e16cb51
|
refs/heads/master
| 2020-06-25T20:14:41.082900
| 2017-12-26T21:09:37
| 2017-12-26T21:09:37
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,054
|
py
|
import pandas as pd
import matplotlib.pyplot as plt
fname=raw_input("Enter filename: ")
df=pd.read_csv(fname)
print "Headers of the Dataset are :-"
#print df.columns.values
print df.head(0)
print "**Dataset Description**"
print df.info()
print df.describe()
df=df.drop(["Pclass","PassengerId","Parch","Name"],axis=1)
print "\n\nAfter Dropping Unwanted Columns:-\n",df.head(0)
print "\nWith Empty Column Values:-\n",df
df['Cabin']=df["Cabin"].fillna("CC55")
print "\n\nWithout Empty Column Values:-\n",df
print "\n\nNumber of Entries: ",len(df)
print "\nNumber of Columns: ",len(df.columns)
print "\n\nAttributes and Their Datatypes:-\n"
df.info()
print "\nMinimum Age: ",df['Age'].min()
print "\nMaximum Age: ",df['Age'].max()
print "\nMean Age: ",round(df['Age'].mean(),2)
gp=df['Age'].plot.hist()
gp.set_ylabel("Number of People")
gp.set_xlabel("Age")
gp.set_title("Age vs No. of People")
plt.show()
dgp=df.Age.plot()
dgp.set_ylabel("Age")
dgp.set_xlabel("Number of People")
dgp.set_title("Age vs No. of People")
plt.show()
|
[
"noreply@github.com"
] |
noreply@github.com
|
bc48ed3a69d6249ded7e941d7d465964d67fa3dc
|
4d946b12fa07bb4375b687e74bbc785d35c5175b
|
/DIO-intro-python.py
|
1e8c1c1014ebc5344d98c14d8f69b35db3e45730
|
[] |
no_license
|
Thalitachargel/100daysofCode
|
c4994bdc48870fc6b702387fe9ec004148ac73b0
|
0333a3f0358d1309368a4f93fec6759e307d7dba
|
refs/heads/main
| 2023-07-05T02:14:00.105793
| 2021-08-18T22:28:21
| 2021-08-18T22:28:21
| 363,527,384
| 0
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 12,648
|
py
|
#!/usr/bin/env python
# coding: utf-8
# # Introdução a programação em Python 🐱💻
# ## Digital Inovation One
# ## Modulo 6
# 🐍 Organizando conjuntos e subconjuntos de elementos em Python
#
# In[3]:
# O que é conjunto:
conjunto = {1, 2, 3, 4}
print(type(conjunto))
# In[4]:
# Conjunto não permite duplicidade
conjunto_Duplo = {1, 2, 3, 4, 4, 2}
print(conjunto_Duplo)
# In[5]:
# adincionando elementos ao conjunto
conjunto.add(5)
conjunto
# In[7]:
# removento elemento
conjunto.discard(2)
conjunto
# ### Operações com conjuntos
# In[11]:
# União entre conjuntos
conj1 = {1, 2, 3, 4, 5}
conj2 = {5, 6, 7, 8}
print( f'conjunto 1 ={ conj1} e conjunto 1 = {conj2}')
conj_uniao = conj1.union(conj2)
conj_uniao
# In[12]:
# Intersecção entre conjuntos
conj_interseccao = conj1.intersection(conj2)
conj_interseccao
# In[16]:
# Diferença
conj_diferencaA = conj1.difference(conj2)
conj_diferencaB = conj2.difference(conj1)
print(f"conj1 ≠ conj2 = {conj_diferencaA} e conj2 ≠ conj1 = {conj_diferencaB}")
# In[20]:
# diferença simétrica (o não tem nos dos conjuntos, ou seja,
# todos os elementos que não são compartilhados entre os conjuntos)
conj_dif_simetrico = conj1.symmetric_difference(conj2)
conj_dif_simetrico
# ### Pertinencia
# In[33]:
# Is subset - Se um conjunto é um subconjunto de outro
conjA = {1, 2, 3}
conjB = {1, 2, 3, 4, 5}
conj_subset = conjA.issubset(conjB)
conj_subset2 = conjB.issubset(conjA)
conj_subset2
if conj_subset == True:
print("Conjunto A é subset do Conjunto B")
else:
print("Conjunto B é subset do Conjunto A")
if conj_subset2 == True:
print("Conjunto A é subset do Conjunto B")
else:
print("Conjunto B é subset do Conjunto A")
# In[36]:
# Super conjunto
conj_superset = conjA.issuperset(conjB)
conj_superset1 = conjB.issuperset(conjA)
if conj_superset == True:
print("Conjunto A é superconjunto do Conjunto B")
else:
print("Conjunto B é superconjunto do Conjunto A")
if conj_superset1 == True:
print("Conjunto A é superconjunto do Conjunto B")
else:
print("Conjunto B é superconjunto do Conjunto A")
# In[46]:
# convertendo uma lista em conjunto
lista = ['cachorro', 'gato', 'gato', 'elefante']
conj_animais = set(lista)
print(conj_animais, type(lista), type(conj_animais))
# In[51]:
# converter de volta a lista
#lista_animais = list(conj_animais)
#print(lista_animais, type(lista_animais))
# ## Módulo 7 - Construindo Métodos, Funções e Classes em Python
# In[56]:
# condicional IF, else
a = int(input("Primeiro Valor: "))
b = int(input("Segundo valor: "))
if a > b:
print(f'O primeiro valor, {a}, é maior que o segundo valor, {b}.')
else:
print(f'O segundo valor, {b}, é maior que o primeiro valor, {a}.')
# In[58]:
# E Elif
a = int(input("Primeiro Valor: "))
b = int(input("Segundo valor: "))
c = int(input("Terceiro Valor: "))
if a > b and a > c:
print(f'O maior numero é o primerio, {a}.')
elif b > a and b > c:
print(f'O maior numero é o segundo, {b}.')
else:
print(f'O maior numero é o terceiro, {c}.')
# In[62]:
# Exercício
# saber se o numero digitado é par
n = int(input("Digite um número:"))
if n == 0:
print("Digite um número diferente de zero!")
elif n % 2 == 0:
print(f'O número {n} é par.')
else:
print(f'O número {n} é impar')
# In[63]:
# função é tudo aquilo que retorna valor
# Método é Definição e não retorna valor
def soma(a, b):
return a + b # como tem retorno, vira uma função
print(soma(1, 2))
print(soma(3, 4))
# In[64]:
def subtracao(a, b):
return a - b
print(subtracao(10, 2))
# In[76]:
# Classe
def multiplicacao(a, b):
return a * b
def divisao(a, b):
return (a / b)
print(multiplicacao(10, 2))
print(divisao(50, 5))
# Transformando em classe
class Calculadora:
def __init__(self, num1, num2):
self.a = num1
self.b = num2
def soma(self):
return self.a + self.b
def subtracao(self):
return self.a - self.b
def multiplicacao(self):
return self.a * self.b
def divisao(self):
return self.a / self.b
calculadora = Calculadora(10, 2)
print(calculadora.a, calculadora.b)
print(calculadora.soma())
print(calculadora.subtracao())
print(calculadora.multiplicacao())
print(calculadora.divisao())
# In[79]:
# Calculadora 2
class Calculadora2:
def __init__(self):
pass
def soma(self, a, b):
return a + b
def subtracao(self, a, b):
return a - b
def multiplicacao(self, a, b):
return a * b
def divisao(self, a, b):
return a / b
calculadora2 = Calculadora2()
print(calculadora2.soma(10,2))
print(calculadora2.subtracao(5,3))
print(calculadora2.multiplicacao(100,2))
print(calculadora2.divisao(10,5))
# In[95]:
# criar uma televisão usando Class
class Televisao:
def __init__(self):
self.ligada = False
self.canal = 5
def power(self):
if self.ligada:
self.ligada = False
else:
self.ligada = True
def aumenta_canal(self):
if self.ligada:
self.canal += 1
else:
print("A tv está desligada")
def diminui_canal(self):
if self.ligada:
self.canal -= 1
else:
print("A tv está desligada")
televisao = Televisao()
print(f'A televisão está ligada: {televisao.ligada}')
televisao.power()
print(f'A televisão está ligada: {televisao.ligada}')
televisao.power()
print(f'A televisão está ligada: {televisao.ligada}')
print(f'Canal {televisao.canal}')
televisao.aumenta_canal()
televisao.power()
televisao.aumenta_canal()
televisao.aumenta_canal()
print(f'Canal {televisao.canal}')
televisao.diminui_canal()
print(f'Canal {televisao.canal}')
# ### Módulo 8 - Lidando com módulos, importação de classes, métodos e lambdas
# In[100]:
#modulo - são os arquivos py
#import ClasseTelevisao #O exercicio proposto só funciona no PY;.
# In[108]:
def contador_de_letras(lista_palavras):
contador = []
for x in lista_palavras:
quantidade = len(x)
contador.append(quantidade)
return contador
if __name__ == '__main__':
lista = ['cachorro', 'gato']
print(contador_de_letras(lista))
list1=['cachorro', 'gato', 'elefante']
total_de_letras_lista = contador_de_letras(list1)
print(f'Total letras da lista {list1} é {total_de_letras_lista}')
# In[107]:
list1=['cachorro', 'gato', 'elefante']
total_de_letras_lista = contador_de_letras(list1)
print(total_de_letras_lista)
# In[110]:
#Função anonima
# convertendo o contador em uma função anonima
lista_animais = ['cachorro', 'gato', 'elefante']
#contador_letras = lambda lista # paramentro : [Len (x) for x in lista] #devolução
#passe o for de x pela lista, e retorne o len de x em forma de lista
contador_letras = lambda lista : [len(x) for x in lista]
contador_letras(lista_animais)
# In[115]:
soma2 = lambda a, b: a + b
soma2(2, 3)
# In[127]:
#criando um dicionario de lambdas
calculadora3 ={ 'soma': lambda a, b: a + b,
'subtracao': lambda a, b : a - b,
'multiplicacao': lambda a, b: a * b,
'divisao': lambda a, b : a / b}
type(calculadora3)
# In[128]:
cal3 = calculadora3['soma']
# In[129]:
cal3(2,3)
# ### Modulo 9 - Gere, copie, mova e escreva
# ### Módulo 10 Aprenda a utilizar data e hora
#
# In[183]:
#Importanto a biblioteca
from datetime import date, time, datetime, timedelta
# In[135]:
data_atual = date.today()
data_atual
# In[137]:
#Formatando data atual
data_atual.strftime('%d/%m/%y')
# In[138]:
data_atual.strftime('%d/%m/%Y')
# In[139]:
data_atual.strftime('%d * %m * %y')
# In[140]:
data_atual.strftime('%d ~%m~%y')
# In[143]:
data_atual_str = data_atual.strftime('%A/%B/%Y')
data_atual_str
# In[145]:
type(data_atual) #datetime.date
type (data_atual_str) #string
# In[186]:
# time
def trabalhando_com_date():
data_atual = date.today()
data_atual_str = data_atual.strftime('%A %B %Y')
dia1 = data_atual.day
print(data_atual_str, dia1)
def trabalhando_com_time():
horario = time(hour=15, minute=18, second=30)
print(horario.strftime('%H:%M:%S'))
def trabalhando_com_datetime():
data_atual = datetime.now()
dia = data_atual.strftime('%d %m %y')
hora = data_atual.strftime('%H, %M %S')
completa = data_atual.strftime('%c')
print(data_atual, dia, hora, completa)
print(data_atual.weekday())
tupla = ('Segunda', 'Terça', 'Quarta',
'Quinta', 'Sexta', 'Sábado', 'Domingo')
print(tupla[data_atual.weekday()])
data_criada = datetime(2008, 5, 25, 20, 15, 30, 20)
print(data_criada)
print(data_criada.strftime('%c'))
data_str = '21/03/1985 12:20:22'
data_con = datetime.strptime(data_str, '%d/%m/%Y %H:%M:%S')
print(data_str)
#subtração de data e hora
nova_data = data_con - timedelta(days = 365, hours = 2)
print(nova_data.strftime('%d - %m - %Y'))
if __name__ == '__main__':
trabalhando_com_date()
trabalhando_com_time()
trabalhando_com_datetime()
# ### Módulo 11 Gerenciando e criando excessões
# In[187]:
# forçando um erro
divisao = 10 / 0
# In[189]:
try:
divisao = 10 / 0
except ZeroDivisionError:
print('Não é possivel dividir por zero')
# In[191]:
# forçar erro
lista = [1, 10]
numero = lista[3]
# In[198]:
try:
lista = [1, 2]
numero = lista[3]
except IndexError:
print("Erro ao acessar indice inesistente")
except:
print('Erro desconhecido')
# In[204]:
try:
x = alma
print(alma)
except BaseException as ex:
print(f'Erro desconhecido. Erro tipo: {ex}.')
# In[211]:
#else
arquivo = open('teste.txt', 'w')
try:
texto = arquivo.read()
print('fechar arquivo')
arquivo.close()
except ZeroDivisionError:
print("não é possivel dividr por zero")
except ArithmeticError:
print("Erro de op aritmetica")
except IndexError:
print("Erro ao acessar indice inesistente")
except BaseException as ex:
print(f'Erro desconhecido. Erro tipo: {ex}.')
else:
print('Executa quando não ocorre exceção')
# In[213]:
arquivo = open('teste.txt', 'w')
try:
texto = arquivo.read()
print('fechar arquivo')
except ZeroDivisionError:
print("não é possivel dividr por zero")
except ArithmeticError:
print("Erro de op aritmetica")
except IndexError:
print("Erro ao acessar indice inesistente")
except BaseException as ex:
print(f'Erro desconhecido. Erro tipo: {ex}.')
else:
print('Executa quando não ocorre exceção')
arquivo.close()
# In[223]:
#Exercicio
while True:
try:
nota = int(input("Digite uma nota entre 0 e 10: "))
print(nota)
if x > 10:
break
except ValueError:
print("Valor inválido. Deve-se digitar apenas Numeros.")
# In[222]:
#criando classe de excessão
class Error(Exception):
pass
class InputError(Error):
def __init__(self, message):
self.message = message
# In[ ]:
while True:
try:
nota = int(input("Digite uma nota entre 0 e 10: "))
print(nota)
if nota > 10:
raise InputError('O valor não pode ser maior que 10')
elif nota < 0:
raise InputError('O valor não pode ser negativo')
break
except ValueError:
print("Valor inválido. Deve-se digitar apenas Numeros.")
except InputError as ex:
print(ex)
# ### Modulo 12 e final: Instalando pacotes e request
# In[230]:
pip list
# In[235]:
#bibliotecas ou pacotes
get_ipython().system('pip install requests')
# In[236]:
pip freeze
# In[240]:
import requests
# In[250]:
#testando o requests
response = requests.get('https://viacep.com.br/ws/70165900/json/')
print(response.status_code) # sucesso = 200
print(response.text)
print(response.json()) #em formato de dicionário
print(type(response.text))
# In[252]:
dado_cep = response.json()
print(dado_cep['logradouro'])
print(dado_cep['complemento'])
# In[256]:
def pokemon(nome_pokemon):
response = requests.get(f'https://pokeapi.co/api/v2/pokemon/{nome_pokemon}')
dados_pokemon = response.json()
return dados_pokemon
pokemon('ditto')
# In[257]:
#request de sites comuns
def retorna_response(url):
response = requests.get(url)
return response.txt
# In[262]:
print(retorna_response('https://recruit.navercorp.com/global/recruitMain'))
# In[ ]:
|
[
"noreply@github.com"
] |
noreply@github.com
|
beff39c0b7dcb6bdf841867e852ac3a4d5057438
|
42dc79035b8488b59374a44ee87136d9fd56bdb3
|
/30-Day-Challange/Day-7/count_negative_sorted-2.py
|
1903e4b1dc070af2101c398bcd4be981714a4312
|
[
"Apache-2.0"
] |
permissive
|
EashanKaushik/LeetCode
|
f8e655b8a52fa01ef5def44b18b2352875bb7ab8
|
8ee2a61cefa42b332b6252fafff4a2772d25aa31
|
refs/heads/main
| 2023-06-06T17:15:54.218097
| 2021-07-06T11:46:35
| 2021-07-06T11:46:35
| 371,109,481
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 475
|
py
|
class Solution:
def countNegatives(self, grid):
m = len(grid)
n = len(grid[0])
current = 0
row = 0
col = n - 1
while row < m and col >= 0:
curr = grid[row][col]
if curr < 0:
current += m - row
col -= 1
else:
row += 1
return current
s = Solution()
print(s.countNegatives([[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]))
|
[
"EashanK16@gmail.com"
] |
EashanK16@gmail.com
|
d1c81821046b2be4b5a8b0c06ec25dac7c3a6841
|
cc33d6045e08be160dcae36dc9e9e24d190878d8
|
/visualization/visualizer2d.py
|
84f60383c873dd67276d11a3c1b07c0329de4ffb
|
[
"Apache-2.0"
] |
permissive
|
StanfordVL/visualization
|
66ca20a2d7d435b1fc950dfbed4e205488418e3a
|
06a179c550a608a548f3cad70f06dd0c8610fa66
|
refs/heads/master
| 2021-06-23T01:54:16.414594
| 2017-08-30T01:05:43
| 2017-08-30T01:05:43
| 105,830,187
| 0
| 0
| null | 2017-10-04T23:35:12
| 2017-10-04T23:35:12
| null |
UTF-8
|
Python
| false
| false
| 5,636
|
py
|
"""
Common 2D visualizations using pyplot
Author: Jeff Mahler
"""
import numpy as np
import IPython
import matplotlib.pyplot as plt
import matplotlib.tri as mtri
from autolab_core import Box, Contour
from perception import BinaryImage, ColorImage, DepthImage, GrayscaleImage, RgbdImage, GdImage, SegmentationImage
class Visualizer2D:
@staticmethod
def figure(size=(8,8), *args, **kwargs):
""" Creates a figure.
Parameters
----------
size : 2-tuple
size of the view window in inches
args : list
args of mayavi figure
kwargs : list
keyword args of mayavi figure
Returns
-------
pyplot figure
the current figure
"""
return plt.figure(figsize=size, *args, **kwargs)
@staticmethod
def show(*args, **kwargs):
""" Show the current figure """
plt.show(*args, **kwargs)
@staticmethod
def clf(*args, **kwargs):
""" Clear the current figure """
plt.clf(*args, **kwargs)
@staticmethod
def xlim(*args, **kwargs):
""" Set the x limits of the current figure """
plt.xlim(*args, **kwargs)
@staticmethod
def ylim(*args, **kwargs):
""" Set the y limits the current figure """
plt.ylim(*args, **kwargs)
@staticmethod
def savefig(*args, **kwargs):
""" Save the current figure """
plt.savefig(*args, **kwargs)
@staticmethod
def colorbar(*args, **kwargs):
""" Adds a colorbar to the current figure """
plt.colorbar(*args, **kwargs)
@staticmethod
def subplot(*args, **kwargs):
""" Creates a subplot in the current figure """
plt.subplot(*args, **kwargs)
@staticmethod
def title(*args, **kwargs):
""" Creates a title in the current figure """
plt.title(*args, **kwargs)
@staticmethod
def xlabel(*args, **kwargs):
""" Creates an x axis label in the current figure """
plt.xlabel(*args, **kwargs)
@staticmethod
def ylabel(*args, **kwargs):
""" Creates an y axis label in the current figure """
plt.ylabel(*args, **kwargs)
@staticmethod
def legend(*args, **kwargs):
""" Creates a legend for the current figure """
plt.legend(*args, **kwargs)
@staticmethod
def scatter(*args, **kwargs):
""" Scatters points """
plt.scatter(*args, **kwargs)
@staticmethod
def plot(*args, **kwargs):
""" Plots lines """
plt.plot(*args, **kwargs)
@staticmethod
def imshow(image, **kwargs):
""" Displays an image.
Parameters
----------
image : :obj:`perception.Image`
image to display
"""
if isinstance(image, BinaryImage) or isinstance(image, GrayscaleImage):
plt.imshow(image.data, cmap=plt.cm.gray, **kwargs)
elif isinstance(image, ColorImage) or isinstance(image, SegmentationImage):
plt.imshow(image.data, **kwargs)
elif isinstance(image, DepthImage):
plt.imshow(image.data, cmap=plt.cm.gray_r, **kwargs)
elif isinstance(image, RgbdImage):
# default to showing color only, for now...
plt.imshow(image.color.data, **kwargs)
elif isinstance(image, GdImage):
# default to showing gray only, for now...
plt.imshow(image.gray.data, cmap=plt.cm.gray, **kwargs)
plt.axis('off')
@staticmethod
def box(b, line_width=2, color='g', style='-'):
""" Draws a box on the current plot.
Parameters
----------
b : :obj:`autolab_core.Box`
box to draw
line_width : int
width of lines on side of box
color : :obj:`str`
color of box
style : :obj:`str`
style of lines to draw
"""
if not isinstance(b, Box):
raise ValueError('Input must be of type Box')
# get min pixels
min_i = b.min_pt[1]
min_j = b.min_pt[0]
max_i = b.max_pt[1]
max_j = b.max_pt[0]
top_left = np.array([min_i, min_j])
top_right = np.array([max_i, min_j])
bottom_left = np.array([min_i, max_j])
bottom_right = np.array([max_i, max_j])
# create lines
left = np.c_[top_left, bottom_left].T
right = np.c_[top_right, bottom_right].T
top = np.c_[top_left, top_right].T
bottom = np.c_[bottom_left, bottom_right].T
# plot lines
plt.plot(left[:,0], left[:,1], linewidth=line_width, color=color, linestyle=style)
plt.plot(right[:,0], right[:,1], linewidth=line_width, color=color, linestyle=style)
plt.plot(top[:,0], top[:,1], linewidth=line_width, color=color, linestyle=style)
plt.plot(bottom[:,0], bottom[:,1], linewidth=line_width, color=color, linestyle=style)
@staticmethod
def contour(c, subsample=1, size=10, color='g'):
""" Draws a contour on the current plot by scattering points.
Parameters
----------
c : :obj:`autolab_core.Contour`
contour to draw
subsample : int
subsample rate for boundary pixels
size : int
size of scattered points
color : :obj:`str`
color of box
"""
if not isinstance(c, Contour):
raise ValueError('Input must be of type Contour')
for i in range(c.num_pixels)[0::subsample]:
plt.scatter(c.boundary_pixels[i,1], c.boundary_pixels[i,0], s=size, c=color)
|
[
"jmahler@berkeley.edu"
] |
jmahler@berkeley.edu
|
07a5041034955e430ae5f1723511345940c3a5b6
|
1f4e6b4045df3a0313880da83e69f10d44c8bab4
|
/4 Data types 3listpy.py
|
15a8f1cd8c2ab2129144c106420c4f510286c828
|
[] |
no_license
|
AhmedAliGhanem/PythonForNetowrk-Cisco
|
daee76b17cc271b56516d559a8fb4184656a15b0
|
f71b2325db69cb5eb9c6a9fe0c6f04a217468875
|
refs/heads/master
| 2022-01-12T09:26:25.338980
| 2019-06-22T16:18:23
| 2019-06-22T16:18:23
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,129
|
py
|
#List
years = [2000, 2001, 2002]
print(years)
Repeatable = [2000, 2001, 2000]
print(Repeatable)
mix = [2000, "yasser", 2002]
print(mix)
x = ["A", "B", "C"]
y = ["D", "E"]
z = x + y
print(z)
z = x * 3
print(z)
z = "A" in y
print(z)
fastethernet_speed=['auto', '10', '100']
print(fastethernet_speed)
print(fastethernet_speed[0])
portList = []
portList.append(21)
portList.append(80)
portList.append(443)
portList.append(25)
print(portList)
portList.sort()
print(portList)
pos = portList.index(80)
print ("[+] There are "+str(pos)+" ports to scan before 80.")
portList.remove(443)
print(portList)
test = 'CCIE CCNP CCNA and CCNT'
print(test.split())
fastethernet_duplex = 'auto half full'
fastethernet_duplex_list = fastethernet_duplex.split()
print(fastethernet_duplex_list)
fastethernet_duplex_list[0] = 'Auto'
fastethernet_duplex_list[1] = 'Half'
fastethernet_duplex_list[2] = 'Full'
print(fastethernet_duplex_list)
print(fastethernet_duplex_list[0])
del fastethernet_duplex_list[0]
print(fastethernet_duplex_list)
print('Auto' in fastethernet_duplex_list)
|
[
"noreply@github.com"
] |
noreply@github.com
|
479f083fa79fc3fdc8c1cf6c85a8c0a00641158c
|
a62b70e3eed1bee2b2214f1f78be131d9485f370
|
/codes/app.py
|
3794515aeaaa27242abe484bc055afe523041a2a
|
[] |
no_license
|
nileshvarshney/restful_database
|
53a12a68f40d142021c30d155d9b67bc3fab99aa
|
2a16b74c2ab99804158d9eeb23fec0ada33292aa
|
refs/heads/master
| 2020-12-03T07:50:35.017918
| 2020-01-03T07:30:52
| 2020-01-03T07:30:52
| 231,248,830
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 519
|
py
|
from flask import Flask
from flask_restful import Api
from flask_jwt import JWT
from security import authenticate, identity
from resources.user import RegisterUser
from resources.item import ItemList, Items
app = Flask(__name__)
api = Api(app)
app.secret_key='sanjose'
jwt = JWT(app, authentication_handler=authenticate, identity_handler=identity) # /auth
api.add_resource(Items,'/item/<string:name>')
api.add_resource(ItemList,'/items')
api.add_resource(RegisterUser,'/registerUser')
app.run(port=5000,debug=True)
|
[
"nilvarshney@stubhub.com"
] |
nilvarshney@stubhub.com
|
b29d6c67789222e938357e11fa5b9b8b77863402
|
6bbe91ea2ebc098b7b7ea5179761f7852875b3f6
|
/pugbot.py
|
12aea378d489f64a42a51b0e33ce7a3006854f7e
|
[] |
no_license
|
dpyro/pugbot
|
531c1c83ceac8d8ae937247af2d1221752c35f13
|
1e8f1b30de11f98be9ee53c2128104758f997799
|
refs/heads/master
| 2021-01-20T13:49:58.008215
| 2010-08-27T19:33:28
| 2010-08-27T19:33:28
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 16,453
|
py
|
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
# vim: enc=utf-8
from __future__ import print_function
from sys import stderr
import logging
import re
from twisted.words.protocols import irc
from twisted.internet import reactor, protocol, task
from pugdata import *
from pugserver import public_ip
def connectSSL(irc_server, irc_port, app):
f = PugBotFactory(app)
reactor.connectSSL(irc_server, irc_port, f, ssl.ClientContextFactory())
def connectTCP(irc_server, irc_port, app):
f = PugBotFactory(app)
reactor.connectTCP(irc_server, irc_port, f)
# needed for @command decorator
_commands = {}
class PugBot(irc.IRCClient):
_re_stripper = re.compile("""[\x0f\x02\x1f\x16\x1d\x11] | # formatting
\x03(?:\d{1,2}(?:,\d{1,2})?)? | # mIRC colors
\x04[0-9a-fA-F]{0,6} # rgb colors
""", re.UNICODE | re.VERBOSE)
@staticmethod
def _strip_all(str):
return PugBot._re_stripper.sub('', str)
@staticmethod
def _has_color(str):
str_strip = PugBot._strip_all(str)
return str != str_strip
MSG_INFO = 0x1
MSG_CONFIRM = 0x2
MSG_ERROR = 0x3
def __init__(self, app):
self.app = app
self.nickname = app.irc_nick
self.password = app.irc_pass
self.color = app.irc_color
self.lineRate = .75
self.versionName = 'PugBot'
self.keep_alive = task.LoopingCall(self._ping)
self.nickmodes = {}
self.users = {} # (nick, PugUser)
self.logger = logging.getLogger("PugApp.PugBot")
def _colorize(self, str, type):
color_dict = {
self.MSG_ERROR : '\x02\x035,01',
self.MSG_INFO : '\x02\x030,01',
self.MSG_CONFIRM : '\x02\x033,01'
}
color_reset = '\x0f'
if self.color:
# only automatically color if no (custom) color formatting is already present
str = color_dict.get(type, '') + str + color_reset if not self._has_color(str) else str + color_reset
else:
str = self._strip_all(str)
return str
# overrides
def msg(self, user, message, type=None):
message_stripped = self._strip_all(message)
log_message = u"{0} (msg) ← {1}".format(user, message_stripped)
self.logger.info(log_message) if user != self.app.irc_server else self.logger.debug(log_message)
if type is not None:
message = self._colorize(message, type)
nick = PugBot._get_nick(user)
irc.IRCClient.msg(self, nick, message)
def notice(self, user, message, type=None):
message_stripped = self._strip_all(message)
self.logger.info(u"{0} (notice) ← {1}".format(user, message_stripped))
if type is not None:
message = self._colorize(message, type)
nick = PugBot._get_nick(user)
irc.IRCClient.notice(self, nick, message)
def describe(self, channel, action):
self.logger.info("{0} (action) ← {1}".format(channel, action))
irc.IRCClient.describe(self, channel, action)
def whois(self, nickname, server=None):
self.logger.debug(u"Requested WHOIS {0}".format(nickname))
irc.IRCClient.whois(self, nickname, server)
# callbacks
def signedOn(self):
self.logger.info(u"Signed onto IRC network {0}:{1}".format(self.app.irc_server, self.app.irc_port))
self._nickserv_login()
self.join(self.app.irc_channel)
self.keep_alive.start(100)
def joined(self, channel):
self.app.print_irc("* joined channel {0}".format(channel))
self.logger.info(u"Joined channel {0}".format(channel))
self._who(channel)
self.whois(self.app.irc_nick)
def left(self, channel):
self.app.print_irc("* left channel {0}".format(channel))
self.logger.info(u"Left channel {0}".format(channel))
self.nickmodes.clear()
self.users.clear()
def kickedFrom(self, channel, kicker, message):
self.logger.warning(u"Kicked from {0} by {1} ({2})".format(channel, kicker, message))
self.nickmodes.clear()
self.users.clear()
task.deferLater(reactor, 5.0, self.join, self.app.irc_channel)
def nickChanged(self, nick):
self.logger.warning(u"Nick changed to: {0}".format(nick))
def privmsg(self, user, channel, msg):
msg = self._strip_all(msg)
self.logger.info(u":{0} (msg) → {1}: {2}".format(user, channel, msg))
cmd = msg.split(' ', 1)[0].lower()
nick = PugBot._get_nick(user)
if cmd in _commands:
cmd_f, cmd_access = _commands[cmd]
if cmd_access is None:
cmd_f(self, user, channel, msg)
elif nick not in self.users:
self.whois(nick)
self.notice(user, "Refreshing access list, please try again shortly.", self.MSG_ERROR)
elif self.users[nick].irc_access >= cmd_access:
cmd_f(self, user, channel, msg)
else:
self.notice(user, "You don't have access to this command!", self.MSG_ERROR)
def noticed(self, user, channel, msg):
self.logger.info(u"{0} (notice) → {1}: {2}".format(user, channel, msg))
def action(self, user, channel, data):
self.logger.info(u"{0} (action) → {1}: {2}".format(user, channel, msg))
def _purge_user(self, user, reason):
self.logger.info(u"{0}: {1}".format(user, reason))
nick = PugBot._get_nick(user)
if nick in self.users:
p_user = self.users[nick]
if p_user in self.app.players:
self.app.remove(p_user)
self.logger.debug(u"Removed user {0} from game ({1})".format(nick, reason))
self._list_players(channel)
del self.users[nick]
def userLeft(self, user, channel):
reason = u"left {0}".format(channel)
if channel.lower() == self.app.irc_channel:
self._purge_user(user, reason)
def userQuit(self, user, quitMessage):
reason = u"quit ({0})".format(quitMessage)
self._purge_user(user, reason)
def userKicked(self, kickee, channel, kicker, message):
reason = u"kicked by {0} in {1} ({2})".format(kicker, channel, message)
if channel.lower() == self.app.irc_channel:
self._purge_user(kickee, reason)
def userRenamed(self, oldname, newname):
if oldname in self.users:
p_user = self.users[oldname]
p_user.irc_name = newname
self.db_session.add(p_user)
self.db_session.commit()
self.users[newname] = p_user
del self.users[oldname]
self.logger.info(u"User renamed: {0} → {1}".format(oldname, newname))
def modeChanged(self, user, channel, set, modes, args):
if channel.lower() == self.app.irc_channel:
self._who(channel)
mode_prefix = '+' if set else '-'
for mode, arg in zip(modes, args):
self.logger.debug(u"{0} → {1} mode change: {2}{3} {4}".format(
user, channel, mode_prefix, mode, arg))
def pong(self, user, secs):
self.logger.debug(u"{0} (pong) ← {1}".format(user, secs))
def irc_RPL_WHOREPLY(self, prefix, args):
me, chan, uname, host, server, nick, modes, name = args
log_msg = u"Recieved WHOREPLY: chan: {0}, uname: {1}, host: {2}, server: {3}, nick: {4}, modes: {5}, name: {6}".format(
chan, uname, host, server, nick, modes, name)
self.logger.debug(log_msg)
if chan.lower() == self.app.irc_channel:
access = PugBot._get_access(modes)
self.nickmodes[nick] = access
self.logger.debug(u"Set {0} to access level {1}".format(nick, access))
def irc_RPL_ENDOFWHO(self, prefix, args):
self.logger.debug(u"Recieved WHO list: {0}".format(args))
def irc_RPL_WHOISUSER(self, prefix, args):
self.logger.debug(u"WHOIS list: {0}".format(args))
def irc_RPL_WHOISACCOUNT(self, prefix, args):
me, nick, account, msg = args
self.logger.debug(u"WHOIS account: nick: {0}, account {1}".format(nick, account))
if nick in self.users:
self.users[nick].irc_account = account
else:
p_user = PugUser(nick, account)
self.users[nick] = p_user
def irc_RPL_ENDOFWHOIS(self, prefix, args):
self.logger.debug(u"Recieved WHOIS: {0}".format(args))
@staticmethod
def _get_nick(user):
return user.split('!', 1)[0]
@staticmethod
def _get_access(modes):
mode_dict = {
'@': PugUser.IRC_OP,
'+': PugUser.IRC_VOICED
}
for key, val in mode_dict.iteritems():
if key in modes:
return val
return PugUser.IRC_USER
def _who(self, channel):
msg = 'WHO {0}'.format(channel.lower())
self.logger.debug(u"Requested {0}".format(msg))
self.sendLine(msg)
def _ping(self):
self.ping(self.app.irc_server)
def _nickserv_login(self):
self.msg('NickServ@services.', 'IDENTIFY {0} {1}'.format(self.nickname, self.password))
def _authserv_login(self):
self.msg('AuthServ@services.', 'AUTH {0} {1}'.format(self.nickname, self.password))
def _list_players(self, channel):
players = self.app.players
if len(players) == 0:
self.msg(channel, "No players are currently signed up.", self.MSG_INFO)
else:
player_list = ', '.join((p.irc_nick for p in self.app.players))
suffix = 's' if len(self.app.players) != 1 else ''
self.msg(channel, "{0} player{1}: {2}".format(len(players), suffix, player_list), self.MSG_INFO)
def _teams(self, channel):
team1, team2 = self.app.teams()
team1 = ', '.join((p.irc_nick for p in team1))
team2 = ', '.join((p.irc_nick for p in team2))
self.msg(channel, "10,01BLU Team: {0}".format(team1))
self.msg(channel, "05,01RED Team: {0}".format(team2))
msg_red = "You have been assigned to RED team. Connect as soon as possible to {0}:{1}".format(
self.app.rcon_server, self.app.rcon_port)
msg_blu = "You have been assigned to BLU team. Connect as soon as possible to {0}:{1}".format(
self.app.rcon_server, self.app.rcon_port)
[self.msg(p.irc_nick, msg_red, MSG_INFO) for p in team1]
[self.msg(p.irc_nick, msg_blu, MSG_INFO) for p in team2]
class command(object):
def __init__(self, name, access=None):
self.name = name
self.access = access
def __call__(self, f):
global _commands
if not isinstance(self.name, str):
for name in self.name:
name = name.lower()
_commands[name] = (f, self.access)
else:
name = self.name.lower()
_commands[name] = (f, self.access)
def exec_cmd(*args):
try:
f(args)
except Exception as e:
print(Fore.RED + e, file=stderr)
self.logger.exception(e)
return exec_cmd
# commands
@command('!startgame', PugUser.IRC_OP)
def cmd_startgame(self, user, channel, msg):
self.app.startgame()
self.msg(channel, "Game started. Type !add to join the game.", self.MSG_INFO)
@command([ '!add', '!a' ], PugUser.IRC_USER)
def cmd_join(self, user, channel, msg):
nick = PugBot._get_nick(user)
p_user = self.users[nick]
if self.app.game is not None:
if p_user not in self.app.players:
self.app.add(p_user)
self.notice(user, "You successfully added to the game.", self.MSG_CONFIRM)
if len(self.app.players) >= 12:
self._teams(channel)
else:
self._list_players(channel)
else:
self.notice(user, "You have already signed up for the game!", self.MSG_ERROR)
else:
self.notice(user, "There is no active game to sign up for!", self.MSG_ERROR)
@command('!join')
def cmd_add(self, user, channel, msg):
self.notice(user, "Please use !add instead.", self.MSG_ERROR)
@command([ '!remove', '!r' ], PugUser.IRC_USER)
def cmd_remove(self, user, channel, msg):
nick = PugBot._get_nick(user)
p_user = self.users[nick]
if p_user in self.app.players:
self.app.remove(p_user)
self.notice(user, "You successfully removed from the game.", self.MSG_CONFIRM)
self._list_players(channel)
else:
self.notice(user, "You are not in the game!", self.MSG_ERROR)
@command(('!players', '!p'))
def cmd_list(self, user, channel, msg):
if self.app.game is None:
self.msg(channel, "There is no game running currently.", self.MSG_INFO)
else:
self._list_players(channel)
@command('!endgame', PugUser.IRC_OP)
def cmd_endgame(self, user, channel, msg):
if self.app.game is not None:
self.app.endgame()
self.msg(channel, "Game ended.", self.MSG_INFO)
else:
self.notice(user, "There is no game to be ended!", self.MSG_ERROR)
@command('!server')
def cmd_server(self, user, channel, msg):
info = self.app.serverinfo()
self.msg(channel, "connect {0}:{1};".format(self.app.rcon_server, info['port']), self.MSG_INFO)
#TODO: Why does it give key errors when using format()?
self.msg(channel, "%(map)s | %(numplayers)s / %(maxplayers)s | stv: %(specport)s" % (info), self.MSG_INFO)
@command('!mumble')
def cmd_mumble(self, user, channel, msg):
self.msg(channel, ("Mumble is the shiniest new voice server/client used by players to communicate with each other.\n"
"It's not laggy as hell like Ventrilo and has a sweet ingame overlay. Unfortunately, Europeans use it.\n"
"Mumble IP: {0} port: {1}").format(self.app.mumble_server, self.app.mumble_port), self.MSG_INFO)
@command('!version')
def cmd_version(self, user, channel, msg):
self.msg(channel, "PugBot: 3alpha", self.MSG_INFO)
@command('!bear')
def cmd_bear(self, user, channel, msg):
self.describe(channel, "goes 4rawr!", self.MSG_INFO)
@command('!magnets')
def cmd_magnets(self, user, channl, msg):
self.msg(channel, "What am I, a scientist?", self.MSG_INFO)
@command('!rtd')
def cmd_rtd(self, user, channel, msg):
nick = PugBot._get_nick(user)
self.msg(channel, "Don't be a noob, {0}.".format(nick), self.MSG_INFO)
@command('!whattimeisit')
def cmd_whattimeisit(self, user, channel, msg):
nick = PugBot._get_nick(user)
self.msg(channel, "Go back to #tf2.pug.na, {0}.".format(nick))
class PugBotFactory(protocol.ReconnectingClientFactory):
protocol = PugBot
def __init__(self, app):
self.app = app
self.logger = logging.getLogger("PugApp.PugBot")
def buildProtocol(self, addr):
self.resetDelay()
p = PugBot(self.app)
p.factory = self
return p
def clientConnectionLost(self, connector, reason):
msg = "connection lost, reconnecting: {0}".format(reason)
self.app.print_irc(msg)
self.logger.error(msg)
protocol.ReconnectingClientFactory.clientConnectionLost(self, connector, reason)
def clientConnectionFailed(self, connector, reason):
msg = "connection failed: {0}".format(reason)
self.app.print_irc(msg)
self.logger.error(msg)
protocol.ReconnectingClientFactory.clientConnectionLost(self, connector, reason)
|
[
"darkpyro@gmail.com"
] |
darkpyro@gmail.com
|
4ceac2bc4f9946d9f2573cc41ecd8880bc8d7375
|
d200aee203cb0d384213747d5fd3934c80c9728a
|
/Python/First Exercise.py
|
5632cb72b27aebec64b0d76abd7f701832a9d8de
|
[] |
no_license
|
Dmiller2599/BFOR206
|
1ab1b43e38423926080f15f2b7d50c44612906f3
|
a8cae7cc8fe60f63175e3abc6ed4b4f7a68ac247
|
refs/heads/main
| 2023-03-20T19:17:18.063724
| 2021-03-21T03:29:53
| 2021-03-21T03:29:53
| 335,765,737
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,525
|
py
|
# -*- coding: utf-8 -*-
"""
Spyder Editor
This is a block comment.
I can type whatever I desire here.
This script will demonstarte basic variables,
if statements, and for loops with Python.
"""
# this is a normal comment.
"""
The comment below defines a chunck that spyder can
use to separate parts of code into small blocks.
This makes it easy to run just a small part of your code.
The syntax is
#%%
If you want to name a chunk
#%% chunk name
"""
#%% define vars
# To run a single line press, f9
my_str = "this is a string"
print(my_str)
my_num = 123.456789
my_int = 123
print(my_num, my_int)
# to run entire chunk
# Ctrl + Enter (Cmd + Enter on Mac)
# to run the entire chunk and go to the next chunk
# Shift + Enter
#%% if statements
a = 0
b = 1
print("the value of a is:", a)
if a > b:
# Everything indented is part of the if statement
print("a is greater than b. Wow!")
elif a < b:
print("a is less than b. Weak!")
else:
print("a and b are the same, eh?")
print("Done with if statements.")
#%% for loops
for i in range(10):
print("the number i is", i)
#%% nested statements
for i in range(5, 10):
print("i is ", i)
# indents are important!
for j in range(3):
print("j is ", j)
print("done with nested loops")
#%% lab
"""
Fix this code below to complete the lab
"""
my_list = ['Hello', 'BFOR', 206, None, 'Bye!']
for item in my_list:
if item is None:
print("Found item with value of None!")
else:
print("The item is", item)
|
[
"david.miller2599@gmail.com"
] |
david.miller2599@gmail.com
|
5a5a5583911ddb9db5402f6b3d6030070b115f57
|
1e50f1643376039ca988d909e79f528e01fa1371
|
/leetcode/editor/cn/292.nim-游戏.py
|
174da887a6b080c9b99b41e140bf445662a9f611
|
[] |
no_license
|
mahatmaWM/leetcode
|
482a249e56e2121f4896e34c58d9fa44d6d0034b
|
4f41dad6a38d3cac1c32bc1f157e20aa14eab9be
|
refs/heads/master
| 2022-09-04T17:53:54.832210
| 2022-08-06T07:29:46
| 2022-08-06T07:29:46
| 224,415,259
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 981
|
py
|
#
# @lc app=leetcode.cn id=292 lang=python3
#
# [292] Nim 游戏
#
# https://leetcode-cn.com/problems/nim-game/description/
#
# algorithms
# Easy (69.45%)
# Likes: 326
# Dislikes: 0
# Total Accepted: 50K
# Total Submissions: 71.9K
# Testcase Example: '4'
#
# 你和你的朋友，两个人一起玩 Nim 游戏：桌子上有一堆石头，每次你们轮流拿掉 1 - 3 块石头。 拿掉最后一块石头的人就是获胜者。你作为先手。
#
# 你们是聪明人，每一步都是最优解。 编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。
#
# 示例:
#
# 输入: 4
# 输出: false
# 解释: 如果堆中有 4 块石头，那么你永远不会赢得比赛；
# 因为无论你拿走 1 块、2 块 还是 3 块石头，最后一块石头总是会被你的朋友拿走。
#
#
#
# @lc code=start
class Solution:
def canWinNim(self, n: int) -> bool:
return False if n % 4 == 0 else True
# @lc code=end
|
[
"chrismwang@tencent.com"
] |
chrismwang@tencent.com
|
113b1426d9036aee80c7202882206d1f33646a46
|
fa1e90dedb7f9b84cd210420215ff6a9bf7e6f2d
|
/airmozilla/suggest/forms.py
|
605254a63fff168bd1e667a2ed8a5f5f55e9866b
|
[] |
no_license
|
sara-mansouri/airmozilla
|
f7bdf6aeafa9a7a299fc69c506e186ba47be7ccb
|
8f93162be46044798df1e6d0ce80c8407fc41995
|
refs/heads/master
| 2021-01-16T18:28:35.569244
| 2014-03-28T02:59:31
| 2014-03-28T02:59:31
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 11,080
|
py
|
from django import forms
from django.conf import settings
from django.template.defaultfilters import filesizeformat
from django.utils.timesince import timesince
from django.utils.safestring import mark_safe
from django.db.models import Q
from slugify import slugify
import requests
from funfactory.urlresolvers import reverse
from airmozilla.base.forms import BaseModelForm
from airmozilla.main.models import (
SuggestedEvent,
Event,
Tag,
Channel,
SuggestedEventComment
)
from airmozilla.comments.models import SuggestedDiscussion
from airmozilla.uploads.models import Upload
from . import utils
class StartForm(BaseModelForm):
event_type = forms.ChoiceField(
label='',
choices=[
('upcoming', 'Upcoming'),
('pre-recorded', 'Pre-recorded'),
('popcorn', 'Popcorn')
],
widget=forms.widgets.RadioSelect()
)
class Meta:
model = SuggestedEvent
fields = ('title',)
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user')
super(StartForm, self).__init__(*args, **kwargs)
# self.fields['upcoming'].label = ''
# self.fields['upcoming'].widget = forms.widgets.RadioSelect(
# choices=[(True, 'Upcoming'), (False, 'Pre-recorded')]
# )
def clean_title(self):
value = self.cleaned_data['title']
if Event.objects.filter(title__iexact=value):
raise forms.ValidationError("Event title already used")
if SuggestedEvent.objects.filter(title__iexact=value, user=self.user):
raise forms.ValidationError(
"You already have a suggest event with this title"
)
return value
class TitleForm(BaseModelForm):
class Meta:
model = SuggestedEvent
fields = ('title', 'slug')
def clean_slug(self):
value = self.cleaned_data['slug']
if value:
if Event.objects.filter(slug__iexact=value):
raise forms.ValidationError('Already taken')
return value
def clean_title(self):
value = self.cleaned_data['title']
if Event.objects.filter(title__iexact=value):
raise forms.ValidationError("Event title already used")
return value
def clean(self):
cleaned_data = super(TitleForm, self).clean()
if 'slug' in cleaned_data and 'title' in cleaned_data:
if not cleaned_data['slug']:
cleaned_data['slug'] = slugify(cleaned_data['title']).lower()
if Event.objects.filter(slug=cleaned_data['slug']):
raise forms.ValidationError('Slug already taken')
return cleaned_data
class ChooseFileForm(BaseModelForm):
class Meta:
model = SuggestedEvent
fields = ('upload',)
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user')
super(ChooseFileForm, self).__init__(*args, **kwargs)
this_or_nothing = (
Q(suggested_event__isnull=True) |
Q(suggested_event=self.instance)
)
uploads = (
Upload.objects
.filter(user=self.user)
.filter(this_or_nothing)
.order_by('created')
)
self.fields['upload'].widget = forms.widgets.RadioSelect(
choices=[(x.pk, self.describe_upload(x)) for x in uploads]
)
@staticmethod
def describe_upload(upload):
html = (
'%s <br><span class="metadata">(%s) uploaded %s ago</span>' % (
upload.file_name,
filesizeformat(upload.size),
timesince(upload.created)
)
)
return mark_safe(html)
class PopcornForm(BaseModelForm):
class Meta:
model = SuggestedEvent
fields = ('popcorn_url',)
def __init__(self, *args, **kwargs):
super(PopcornForm, self).__init__(*args, **kwargs)
self.fields['popcorn_url'].label = 'Popcorn URL'
def clean_popcorn_url(self):
url = self.cleaned_data['popcorn_url']
if '://' not in url:
url = 'http://' + url
response = requests.get(url)
if response.status_code != 200:
raise forms.ValidationError('URL can not be found')
return url
class DescriptionForm(BaseModelForm):
class Meta:
model = SuggestedEvent
fields = ('description', 'short_description')
def __init__(self, *args, **kwargs):
super(DescriptionForm, self).__init__(*args, **kwargs)
self.fields['description'].help_text = (
"Write a description of your event that will entice viewers to "
"watch.<br>"
"An interesting description improves the chances of your "
"presentation being picked up by bloggers and other websites."
"<br>"
"Please phrase your description in the present tense. "
)
self.fields['short_description'].help_text = (
"This Short Description is used in public feeds and tweets. "
"<br>If your event is non-public be careful "
"<b>not to "
"disclose sensitive information here</b>."
"<br>If left blank the system will use the first few "
"words of the description above."
)
class DetailsForm(BaseModelForm):
tags = forms.CharField(required=False)
enable_discussion = forms.BooleanField(required=False)
class Meta:
model = SuggestedEvent
fields = (
'location',
'start_time',
'privacy',
'category',
'tags',
'channels',
'additional_links',
'remote_presenters',
)
def __init__(self, *args, **kwargs):
super(DetailsForm, self).__init__(*args, **kwargs)
self.fields['channels'].required = False
if not self.instance.upcoming:
del self.fields['location']
del self.fields['start_time']
del self.fields['remote_presenters']
else:
self.fields['location'].required = True
self.fields['start_time'].required = True
self.fields['location'].help_text = (
"Choose an Air Mozilla origination point. <br>"
"If the location of your event isn't on the list, "
"choose Live Remote. <br>"
"Note that live remote dates and times are UTC."
)
self.fields['remote_presenters'].help_text = (
"If there will be presenters who present remotely, please "
"enter email addresses, names and locations about these "
"presenters."
)
self.fields['remote_presenters'].widget.attrs['rows'] = 3
if 'instance' in kwargs:
event = kwargs['instance']
if event.pk:
tag_format = lambda objects: ','.join(map(unicode, objects))
tags_formatted = tag_format(event.tags.all())
self.initial['tags'] = tags_formatted
self.fields['tags'].help_text = (
"Enter some keywords to help viewers find the recording of your "
"event. <br>Press return between keywords"
)
self.fields['channels'].help_text = (
"Should your event appear in one or more particular "
"Air Mozilla Channels? <br>If in doubt, select Main."
)
self.fields['additional_links'].help_text = (
"If you have links to slides, the presenter's blog, or other "
"relevant links, list them here and they will appear on "
"the event page."
)
self.fields['additional_links'].widget.attrs['rows'] = 3
def clean_tags(self):
tags = self.cleaned_data['tags']
split_tags = [t.strip() for t in tags.split(',') if t.strip()]
final_tags = []
for tag_name in split_tags:
t, __ = Tag.objects.get_or_create(name=tag_name)
final_tags.append(t)
return final_tags
def clean_channels(self):
channels = self.cleaned_data['channels']
if not channels:
return Channel.objects.filter(slug=settings.DEFAULT_CHANNEL_SLUG)
return channels
class DiscussionForm(BaseModelForm):
emails = forms.CharField(required=False, label="Moderators")
class Meta:
model = SuggestedDiscussion
fields = ('enabled', 'moderate_all')
def __init__(self, *args, **kwargs):
super(DiscussionForm, self).__init__(*args, **kwargs)
event = self.instance.event
self.fields['moderate_all'].help_text = (
'That every comment has to be approved before being shown '
'publically. '
)
self.fields['emails'].widget.attrs.update({
'data-autocomplete-url': reverse('suggest:autocomplete_emails')
})
if event.privacy != Event.PRIVACY_COMPANY:
self.fields['moderate_all'].widget.attrs.update(
{'disabled': 'disabled'}
)
self.fields['moderate_all'].help_text += (
'<br>If the event is not MoCo private you have to have '
'full moderation on '
'all the time.'
)
def clean_emails(self):
value = self.cleaned_data['emails']
emails = list(set([
x.lower().strip() for x in value.split(',') if x.strip()
]))
for email in emails:
if not utils.is_valid_email(email):
raise forms.ValidationError(
'%s is not a valid email address' % (email,)
)
return emails
class PlaceholderForm(BaseModelForm):
class Meta:
model = SuggestedEvent
fields = ('placeholder_img',)
def __init__(self, *args, **kwargs):
super(PlaceholderForm, self).__init__(*args, **kwargs)
self.fields['placeholder_img'].help_text = (
"We need a placeholder image for your event. <br>"
"A recent head-shot of the speaker is preferred. <br>"
"Placeholder images should be 200 x 200 px or larger."
)
#class ParticipantsForm(BaseModelForm):
#
# participants = forms.CharField(required=False)
#
# class Meta:
# model = SuggestedEvent
# fields = ('participants',)
#
# def clean_participants(self):
# participants = self.cleaned_data['participants']
# split_participants = [p.strip() for p in participants.split(',')
# if p.strip()]
# final_participants = []
# for participant_name in split_participants:
# p = Participant.objects.get(name=participant_name)
# final_participants.append(p)
# return final_participants
#
class SuggestedEventCommentForm(BaseModelForm):
class Meta:
model = SuggestedEventComment
fields = ('comment',)
|
[
"mail@peterbe.com"
] |
mail@peterbe.com
|
c2a6d24f20bb1c2478b4feea8182623aca53bac4
|
2f98aa7e5bfc2fc5ef25e4d5cfa1d7802e3a7fae
|
/python/python_14413.py
|
5e67c83692878ae8becbb59fe8019e05781959d1
|
[] |
no_license
|
AK-1121/code_extraction
|
cc812b6832b112e3ffcc2bb7eb4237fd85c88c01
|
5297a4a3aab3bb37efa24a89636935da04a1f8b6
|
refs/heads/master
| 2020-05-23T08:04:11.789141
| 2015-10-22T19:19:40
| 2015-10-22T19:19:40
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 140
|
py
|
# changing type of a entry in dictionary throws error
d = {'today': datetime.today()}
d['today'] = d['today'].strftime(<your format>)
|
[
"ubuntu@ip-172-31-7-228.us-west-2.compute.internal"
] |
ubuntu@ip-172-31-7-228.us-west-2.compute.internal
|
d9b3198dc97ae3d100c2537f1a374cc313ba3383
|
0e22ce0913d3f0f7a7404a3add796533df10ffd2
|
/code_exam_student_grade.py
|
db18cc99d9d2ae1c6cf6534b6d0b6f0c95625ef4
|
[] |
no_license
|
Bhuvan1696/PythoN
|
714e98717d277c81d8a6d0a83873af0ff6f45df3
|
685eddd9cb7132867519f9dff71ed3a55502cca6
|
refs/heads/master
| 2020-12-09T18:05:57.724508
| 2020-02-22T17:51:06
| 2020-02-22T17:51:06
| 233,379,464
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,248
|
py
|
""" Student Mark Statement """
def grade(percentage, eng, sci, mat):
if ( eng >= 25 and sci >= 35 and mat >= 35):
if (percentage > 90):
print ("Grade A")
elif (percentage > 75 and percentage <= 90):
print ("Grafe B")
else:
print ("Average")
else:
print("Fail..!")
def total_marks(eng, theory, practical, mat):
if (eng <= 75 and theory <= 75 and practical <= 25 and mat <= 100):
tot_sci = theory + practical
total = eng + tot_sci + mat
percent = total/3
print ("Over all percentage :", percent)
grade(percent, eng, tot_sci, mat)
else:
print(" Out of Marks..")
def get_marks():
eng = input("Enter English out of 75 :")
eng = int(eng)
sci_thoery = input("Enter Science_Thoery out of 75 :")
sci_thoery = int(sci_thoery)
sci_practical = input("Enter Science_Pracical out of 25 :")
sci_practical = int(sci_practical)
mat = input("Enter Maths out of 100 :")
mat = int(mat)
return eng, sci_thoery, sci_practical, mat
def main():
english, thoery, practical, maths = get_marks()
total_marks(english, thoery, practical, maths)
#Main starts from here
main()
|
[
"noreply@github.com"
] |
noreply@github.com
|
eeb85c0763b4b58838c030ceccd1de9ec42a82e6
|
5cea11c9373d997430b523227ce81b61972ad1e3
|
/tests/test_client_events.py
|
bd3bc8ac4bf3a96cd62673408ee09427626646ff
|
[
"BSD-3-Clause"
] |
permissive
|
tinylambda/grpclib
|
fcc0d4f5723fe36359ceb9655764e9a37c87ebc1
|
948e32a29a4ad82ebbfdbb681f7a797f6233bff3
|
refs/heads/master
| 2023-07-15T16:19:59.776603
| 2021-08-25T19:56:10
| 2021-08-25T19:56:10
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,234
|
py
|
import pytest
from multidict import MultiDict
from google.rpc.error_details_pb2 import ResourceInfo
from grpclib.const import Status
from grpclib.events import listen, SendRequest, SendMessage, RecvMessage
from grpclib.events import RecvInitialMetadata, RecvTrailingMetadata
from grpclib.testing import ChannelFor
from grpclib._compat import nullcontext
from grpclib.exceptions import GRPCError
from dummy_pb2 import DummyRequest, DummyReply
from dummy_grpc import DummyServiceStub, DummyServiceBase
class DummyService(DummyServiceBase):
def __init__(self, fail=False):
self.fail = fail
async def UnaryUnary(self, stream):
await stream.recv_message()
await stream.send_initial_metadata(metadata={'initial': 'true'})
await stream.send_message(DummyReply(value='pong'))
if self.fail:
await stream.send_trailing_metadata(
status=Status.NOT_FOUND,
status_message="Everything is not OK",
status_details=[ResourceInfo()],
metadata={'trailing': 'true'},
)
else:
await stream.send_trailing_metadata(metadata={'trailing': 'true'})
async def UnaryStream(self, stream):
raise GRPCError(Status.UNIMPLEMENTED)
async def StreamUnary(self, stream):
raise GRPCError(Status.UNIMPLEMENTED)
async def StreamStream(self, stream):
raise GRPCError(Status.UNIMPLEMENTED)
async def _test(event_type, *, fail=False):
service = DummyService(fail)
events = []
async def callback(event_):
events.append(event_)
async with ChannelFor([service]) as channel:
listen(channel, event_type, callback)
stub = DummyServiceStub(channel)
ctx = pytest.raises(GRPCError) if fail else nullcontext()
with ctx:
reply = await stub.UnaryUnary(DummyRequest(value='ping'),
timeout=1,
metadata={'request': 'true'})
assert reply == DummyReply(value='pong')
event, = events
return event
@pytest.mark.asyncio
async def test_send_request():
event = await _test(SendRequest)
assert event.metadata == MultiDict({'request': 'true'})
assert event.method_name == '/dummy.DummyService/UnaryUnary'
assert event.deadline.time_remaining() > 0
assert event.content_type == 'application/grpc'
@pytest.mark.asyncio
async def test_send_message():
event = await _test(SendMessage)
assert event.message == DummyRequest(value='ping')
@pytest.mark.asyncio
async def test_recv_message():
event = await _test(RecvMessage)
assert event.message == DummyReply(value='pong')
@pytest.mark.asyncio
async def test_recv_initial_metadata():
event = await _test(RecvInitialMetadata)
assert event.metadata == MultiDict({'initial': 'true'})
@pytest.mark.asyncio
async def test_recv_trailing_metadata():
event = await _test(RecvTrailingMetadata, fail=True)
assert event.metadata == MultiDict({'trailing': 'true'})
assert event.status is Status.NOT_FOUND
assert event.status_message == "Everything is not OK"
assert isinstance(event.status_details[0], ResourceInfo)
|
[
"vladimir@magamedov.com"
] |
vladimir@magamedov.com
|
0239f50106a25909870229a9b49d17ca773a5c68
|
d125a7467b815ea3027567b0a6976c8ad730beb9
|
/src/itsmservice/itsmservice/conf/product.py
|
82ef0f132d7f11c4ceea13a01500a1df5a454f0f
|
[] |
no_license
|
sunyaxiong/itsmservice
|
06a1cb38b7314695613e2432f2e1d56c86aad815
|
e50fccae9ae536ac520337ec79b1d1c985e49aa4
|
refs/heads/master
| 2022-12-12T11:14:03.838601
| 2018-10-31T06:17:25
| 2018-10-31T06:17:25
| 137,029,391
| 0
| 0
| null | 2022-12-08T00:58:47
| 2018-06-12T06:50:01
|
JavaScript
|
UTF-8
|
Python
| false
| false
| 1,765
|
py
|
# cas conf
SUCC_REDIRECT_URL = "itsm.ecscloud.com"
CAS_SERVER_URL = "http://cas.ecscloud.com/cas/"
CMP_URL = "http://cmp.ecscloud.com"
# CAS_REDIRECT_URL = "http://www.baidu.com"
# databases conf
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'itsm',
'USER': 'root',
'PASSWORD': 'Itsm@vstecs.com',
'HOST': '127.0.0.1',
'PORT': '3306',
'OPTIONS': {
'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
'charset': 'utf8mb4',
},
},
'cas_db': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'cas',
'USER': 'root',
'PASSWORD': 'Db@vstecs.com',
"HOST": "172.31.31.255",
"PORT": "3306",
},
}
# use multi-database in django
DATABASE_ROUTERS = ['itsmservice.database_router.DatabaseAppsRouter']
DATABASE_APPS_MAPPING = {
# example:
# 'app_name':'database_name',
'cas_sync': 'cas_db',
}
# fit2cloud api conf
INTERNET_HOST = "cmp.ecscloud.com"
CLOUD_HOST = "172.16.13.155"
CMDB_HOST = "172.16.13.155"
access_key = "My00ZjRkMzVkZA=="
cloud_secret_key = "228e1f50-3b39-4213-a8d8-17e8bf2aeb1e"
CMDB_CONF = {
"access_key": access_key,
"version": "v1",
"signature_method": "HmacSHA256",
"signature_version": "v1"
}
CLOUD_CONF = {
"access_key": access_key,
"version": "v1",
"signature_method": "HmacSHA256",
"signature_version": "v1",
"user": "sunyaxiong@vstecs.com",
}
secret_key = cloud_secret_key
# cloud_secret_key = '228e1f50-3b39-4213-a8d8-17e8bf2aeb1e'
# mail
EMAIL_HOST = 'smtp.163.com'
EMAIL_PORT = 25
EMAIL_HOST_USER = 'sunyaxiongnn@163.com'
EMAIL_HOST_PASSWORD = 'Sun880519'
EMAIL_SUBJECT_PREFIX = u'[vstecs.com]'
EMAIL_USE_TLS = True
|
[
"sunyaxiong"
] |
sunyaxiong
|
9cff0f2a316ca7bb8e9daefe0127a1a8ef5609ea
|
90177443dddd57dc7a8ad2cfb0758b0abb2a10f2
|
/currency_converter.py
|
d786177fbbec6974fdfcfcaa260732194b7bc02b
|
[] |
no_license
|
Tengtiantian/data-analytics
|
18181d6d17d4077f503f505500f50b1fdb6efe44
|
ac63bde80a4355c2d0911f60fd8f55683ae026bf
|
refs/heads/main
| 2023-07-10T15:53:32.334067
| 2021-08-17T09:19:25
| 2021-08-17T09:19:25
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 406
|
py
|
"""
作者：梁斌
功能：汇率兑换
版本：1.0
日期：01/08/2017
"""
# 汇率
USD_VS_RMB = 6.77
# 人民币的输入
rmb_str_value = input('请输入人民币(CNY)金额：')
# 将字符串转换为数字
rmb_value = eval(rmb_str_value)
# 汇率计算
usd_value = rmb_value / USD_VS_RMB
# 输出结果
print('美元(USD)金额是：', usd_value)
|
[
"wangsiyuan_id@126.com"
] |
wangsiyuan_id@126.com
|
31dd5fd0705bfebccf299f10eb6ba594038b885d
|
f0d713996eb095bcdc701f3fab0a8110b8541cbb
|
/5ejvPTQeiioTTA9xZ_0.py
|
9b5d0b04aa8e5dca2af5037100305f74b9f4c108
|
[] |
no_license
|
daniel-reich/turbo-robot
|
feda6c0523bb83ab8954b6d06302bfec5b16ebdf
|
a7a25c63097674c0a81675eed7e6b763785f1c41
|
refs/heads/main
| 2023-03-26T01:55:14.210264
| 2021-03-23T16:08:01
| 2021-03-23T16:08:01
| 350,773,815
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 395
|
py
|
"""
Create a function that checks if the argument is an integer or a string.
Return `"int"` if it's an integer and `"str"` if it's a string.
### Examples
int_or_string(8) ➞ "int"
int_or_string("Hello") ➞ "str"
int_or_string(9843532) ➞ "int"
### Notes
Input will either be an integer or a string.
"""
def int_or_string(var):
return var.__class__.__name__
|
[
"daniel.reich@danielreichs-MacBook-Pro.local"
] |
daniel.reich@danielreichs-MacBook-Pro.local
|
282e63fed4ef69cb10987c6e83a4b406b3ef4bf6
|
f0316e656767cf505b32c83eef4df13bb9f6b60c
|
/Kattis/cups.py
|
4789de27f116b754ca591f250e6577a087e0b6a9
|
[] |
no_license
|
AkshdeepSharma/Classroom
|
70ec46b35fab5fc4a9d2eac430659d7dafba93da
|
4e55799466c101c736de6c7e07d716ff147deb83
|
refs/heads/master
| 2022-06-13T18:14:03.236503
| 2022-05-17T20:16:28
| 2022-05-17T20:16:28
| 94,828,359
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 257
|
py
|
N = int(input())
cups = []
for i in range(N):
a, b = input().split()
try:
cups.append([int(b), a])
except:
cups.append([int(a) // 2, b])
cups = sorted(cups, key=lambda x: x[0])
for k in range(len(cups)):
print(cups[k][1])
|
[
"akshdeep.s@live.com"
] |
akshdeep.s@live.com
|
e5ae86739f26139d2a56b19277ea7832e21d41bd
|
f74dd098c3e665d8f605af5ebe7e2874ac31dd2f
|
/aiogithubapi/namespaces/user.py
|
1d1bd8b8cab4928b70f10f1d9836568e6cc2db64
|
[
"MIT"
] |
permissive
|
ludeeus/aiogithubapi
|
ce87382698827939aaa127b378b9a11998f13c06
|
90f3fc98e5096300269763c9a5857481b2dec4d2
|
refs/heads/main
| 2023-08-20T19:30:05.309844
| 2023-08-14T20:24:21
| 2023-08-14T20:24:21
| 198,505,021
| 21
| 20
|
MIT
| 2023-09-11T06:12:10
| 2019-07-23T20:39:53
|
Python
|
UTF-8
|
Python
| false
| false
| 2,993
|
py
|
"""
Methods for the authenticated user namespace
https://docs.github.com/en/rest/reference/users#get-the-authenticated-user
"""
from __future__ import annotations
from typing import Any, Dict
from ..const import GitHubRequestKwarg
from ..models.organization import GitHubOrganizationMinimalModel
from ..models.repository import GitHubRepositoryModel
from ..models.response import GitHubResponseModel
from ..models.user import GitHubAuthenticatedUserModel
from .base import BaseNamespace
from .projects import GitHubUserProjectsNamespace
class GitHubUserNamespace(BaseNamespace):
"""Methods for the user namespace"""
def __post_init__(self) -> None:
self._projects = GitHubUserProjectsNamespace(self._client)
@property
def projects(self) -> GitHubUserProjectsNamespace:
"""Property to access the users projects namespace"""
return self._projects
async def get(
self,
**kwargs: Dict[GitHubRequestKwarg, Any],
) -> GitHubResponseModel[GitHubAuthenticatedUserModel]:
"""
Get the authenticated user
https://docs.github.com/en/rest/reference/users#get-a-user
"""
response = await self._client.async_call_api(
endpoint="/user",
**kwargs,
)
response.data = GitHubAuthenticatedUserModel(response.data)
return response
async def starred(
self,
**kwargs: Dict[GitHubRequestKwarg, Any],
) -> GitHubResponseModel[list[GitHubRepositoryModel]]:
"""
Get the authenticated user starred repositories
https://docs.github.com/en/rest/reference/users#get-a-user
"""
response = await self._client.async_call_api(
endpoint="/user/starred",
**kwargs,
)
response.data = [GitHubRepositoryModel(data) for data in response.data]
return response
async def repos(
self,
**kwargs: Dict[GitHubRequestKwarg, Any],
) -> GitHubResponseModel[list[GitHubRepositoryModel]]:
"""
Get the repositories for the authenticated user
https://docs.github.com/en/rest/reference/repos#list-repositories-for-a-user
"""
response = await self._client.async_call_api(
endpoint="/user/repos",
**kwargs,
)
response.data = [GitHubRepositoryModel(data) for data in response.data]
return response
async def orgs(
self,
**kwargs: Dict[GitHubRequestKwarg, Any],
) -> GitHubResponseModel[list[GitHubOrganizationMinimalModel]]:
"""
List public organization memberships for the specified user.
https://docs.github.com/en/rest/reference/orgs#list-organizations-for-the-authenticated-user
"""
response = await self._client.async_call_api(endpoint="/user/orgs", **kwargs)
response.data = [GitHubOrganizationMinimalModel(data) for data in response.data or []]
return response
|
[
"noreply@github.com"
] |
noreply@github.com
|
7b288b67b9fa3473f2fb3c72085b6de7ea893109
|
6cecdc007a3aafe0c0d0160053811a1197aca519
|
/apps/receiver/management/commands/generate_submissions.py
|
ae672ba20a318c1fc46d7ecce22a17363b20c062
|
[] |
no_license
|
commtrack/temp-aquatest
|
91d678c927cc4b2dce6f709afe7faf2768b58157
|
3b10d179552b1e9d6a0e4ad5e91a92a05dba19c7
|
refs/heads/master
| 2016-08-04T18:06:47.582196
| 2010-09-29T13:20:13
| 2010-09-29T13:20:13
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,172
|
py
|
""" This script generates all the necessary data to
synchronize with a remote CommCareHQ server on that server.
This is only really useful if you intend to manually
scp/rsync data to your local server, which requires a
login to the remote server. So this is not the standard
synchronization workflow (but is necessary for low-connectivity
settings)
"""
import bz2
import sys
import urllib2
import httplib
import cStringIO
from urlparse import urlparse
from optparse import make_option
from django.core.management.base import LabelCommand, CommandError
from django_rest_interface import util as rest_util
from receiver.models import Submission
class Command(LabelCommand):
option_list = LabelCommand.option_list + (
make_option('-a','--all', action='store_true', dest='all', \
default=False, help='Generate all files'),
make_option('-?','--debug', action='store_true', dest='debug', \
default=False, help='Generate some files'),
make_option('-d','--download', action='store_true', dest='download', \
default=False, help='Download files.'),
)
help = "Generate synchronization files on a CommCareHQ remote server."
args = "<remote_url username password>"
label = 'IP address of the remote server (including port), username, and password'
def handle(self, *args, **options):
if len(args) != 3:
raise CommandError('Please specify %s.' % self.label)
remote_url = args[0]
username = args[1]
password = args[2]
print "Generating synchronization data from %s" % remote_url
all = options.get('all', False)
debug = options.get('debug', False)
download = options.get('download', False)
generate_submissions(remote_url, username, password, not all, debug, download)
def __del__(self):
pass
def generate_submissions(remote_url, username, password, latest=True, debug=False, download=False, to='submissions.tar'):
""" Generate sync data from remote server
remote_url: url of remote server (ip:port)
username, password: credentials for logging in
"""
status = rest_util.login(remote_url, username, password)
if not status:
print "Sorry. Your credentials were not accepted."
sys.exit()
url = 'http://%s/api/submissions/' % remote_url
if latest:
MD5_buffer = rest_util.get_field_as_bz2(Submission, 'checksum', debug)
response = rest_util.request(url, username, password, MD5_buffer)
print "Generated latest remote submissions"
else:
response = urllib2.urlopen(url)
print "Generated all remote submissions archive"
if download:
fout = open(to, 'w+b')
fout.write(response.read())
fout.close()
print "Submissions downloaded to %s" % to
else:
# Check for status messages
# (i think tar payloads always begin 'BZ'...)
response = response.read(255)
if response[:2] != "BZ":
print response
return response
|
[
"allen.machary@gmail.com"
] |
allen.machary@gmail.com
|
25758d4020776fdb429b99cd383fb2251ca42ea7
|
cbbc0c95e367932e962f8d9e6175a5150d0c6570
|
/coursera/algorithmic_toolbox/Greedy Algorithms/Maximum Salary/maximum_salary.py
|
2ebcd8633f3620ee15e42cef0dfecc8f14bbe780
|
[] |
no_license
|
chobostar/education_and_training
|
1369ab98f28b93651bb861a40c1fa0603973519e
|
fcec324a1b92916401ba8de5c61f6d7b1ee69c68
|
refs/heads/master
| 2023-08-04T04:36:16.217908
| 2023-07-22T08:09:54
| 2023-07-22T08:09:54
| 216,988,123
| 0
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,107
|
py
|
# python3
from itertools import permutations
import random
def if_greater(x, y: str) -> bool:
return (x + y) > (y + x)
def sort(items):
less = []
equal = []
greater = []
if len(items) > 1:
pivot = random.choice(items)
for x in items:
if not if_greater(x, pivot) and x != pivot:
less.append(x)
elif x == pivot:
equal.append(x)
elif if_greater(x, pivot):
greater.append(x)
return sort(greater)+equal+sort(less)
else:
return items
def largest_number_naive(numbers):
numbers = list(map(str, numbers))
largest = 0
for permutation in permutations(numbers):
largest = max(largest, int("".join(permutation)))
return largest
def largest_number(numbers):
sorted_numbers = sort([str(number) for number in numbers])
result = ''.join(sorted_numbers)
return int(result)
if __name__ == '__main__':
n = int(input())
input_numbers = input().split()
assert len(input_numbers) == n
print(largest_number(input_numbers))
|
[
"yakutskkirill@mail.ru"
] |
yakutskkirill@mail.ru
|
22f4ffa79f304c929e6c0680c0a2228d0e15dd2b
|
dbf2d3f8eb11d04123894e398446b56ca791c9f6
|
/examples/02.py
|
c9847666ba51a1574e379280d847d651e7982b21
|
[] |
no_license
|
podhmo/nendo
|
ed8d9a62ab23f7409a8ce519f28deff7d3642942
|
841ec7a990019596c769a2f581a1190aeb8cbd56
|
refs/heads/master
| 2021-01-22T17:47:58.964323
| 2015-06-28T11:37:38
| 2015-06-28T11:37:38
| 37,828,656
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 550
|
py
|
# -*- coding:utf-8 -*-
import logging
logger = logging.getLogger(__name__)
"""
-- select explicitly
SELECT open_emp_id, product_cd
FROM account
ORDER BY open_emp_id, product_cd;
"""
from nendo import Query, make_record, render
from nendo.value import List
Account = make_record("account", "account_id product_cd open_date avail_balance open_emp_id")
query = (Query()
.from_(Account)
.order_by(List([Account.open_emp_id, Account.product_cd]).desc())
.select(Account.open_emp_id, Account.product_cd))
print(render(query))
|
[
"podhmo+altair@beproud.jp"
] |
podhmo+altair@beproud.jp
|
ee39967cfee84345c3f981e0d983d21bfa8dc82f
|
dbe86e522bf7c0fa58531e13bed3dd97051e1b79
|
/cognitoLogin.py
|
4ab85e5d4802764ca7ab75cbd00e13fa51ba772e
|
[] |
no_license
|
Asteriw/CMPT473-AWSApp
|
e214281bbae59f9319efe423f55745e0a10dddb1
|
9d30543439913259a5e88fdf5b8913d3cac5acb4
|
refs/heads/master
| 2023-04-25T05:39:35.352531
| 2021-04-09T05:57:31
| 2021-04-09T05:57:31
| 369,430,240
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,570
|
py
|
import boto3
import botocore.exceptions
import hmac
import hashlib
import base64
import json
USER_POOL_ID = 'us-east-1_b6HnaK2eM'
CLIENT_ID = '4tnka15q9dfg2si6rd9d44mncc'
CLIENT_SECRET = '1i3e81c7nqnjqkl9dcnd48ebmn629ieivs3umi37ib3lv9907n8r'
def get_secret_hash(username):
msg = username + CLIENT_ID
dig = hmac.new(str(CLIENT_SECRET).encode('utf-8'),
msg = str(msg).encode('utf-8'), digestmod=hashlib.sha256).digest()
d2 = base64.b64encode(dig).decode()
return d2
def initiate_auth(client, username, password):
secret_hash = get_secret_hash(username)
try:
resp = client.admin_initiate_auth(
UserPoolId=USER_POOL_ID,
ClientId=CLIENT_ID,
AuthFlow='ADMIN_NO_SRP_AUTH',
AuthParameters={
'USERNAME': username,
'SECRET_HASH': secret_hash,
'PASSWORD': password,
},
ClientMetadata={
'name': username,
'password': password,
})
except client.exceptions.NotAuthorizedException:
return None, "The username or password is incorrect"
except client.exceptions.UserNotConfirmedException:
return resp, None
except Exception as e:
return None, e.__str__()
return resp, None
def lambda_handler(event, context):
client = boto3.client('cognito-idp')
for field in ["username", "password"]:
if event.get(field) is None:
return {"error": True,
"success": False,
"message": f"{field} is required",
"data": None}
resp, msg = initiate_auth(client, event.get("username"), event.get("password"))
print(resp)
print(msg)
if msg != None:
return {'message': msg,
"error": True, "success": False, "data": None}
if resp.get("AuthenticationResult"):
return {'message': "success",
"error": False,
"success": True,
"data": {
"id_token": resp["AuthenticationResult"]["IdToken"],
"refresh_token": resp["AuthenticationResult"]["RefreshToken"],
"access_token": resp["AuthenticationResult"]["AccessToken"],
"expires_in": resp["AuthenticationResult"]["ExpiresIn"],
"token_type": resp["AuthenticationResult"]["TokenType"]
}}
else: #this code block is relevant only when MFA is enabled
return {"error": True,
"success": False,
"data": None, "message": None}
|
[
"zhiqi_qiao@sfu.ca"
] |
zhiqi_qiao@sfu.ca
|
adf625842636ccc75d545aa5f1e107a48d4ec5cb
|
f8d753a822047a68e417ba58d17f754789e2af93
|
/migrations/versions/ad4acce05428_.py
|
182a439446f9e08a2fd3cbe43752625d82ba13eb
|
[] |
no_license
|
daronjp/travel_blog
|
113eba826ccabcc18c51fc169e3b2ae359365b77
|
2a016ec840ebb468112a79c52605404d2ac1aa72
|
refs/heads/master
| 2023-05-10T19:39:34.713528
| 2022-09-13T03:47:57
| 2022-09-13T03:47:57
| 211,604,162
| 0
| 0
| null | 2023-05-01T22:49:07
| 2019-09-29T04:39:32
|
Python
|
UTF-8
|
Python
| false
| false
| 798
|
py
|
"""empty message
Revision ID: ad4acce05428
Revises: 07c5566941d1
Create Date: 2019-09-30 14:09:13.551393
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = 'ad4acce05428'
down_revision = '07c5566941d1'
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('users',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('user_name', sa.String(), nullable=True),
sa.Column('password_hash', sa.String(), nullable=True),
sa.PrimaryKeyConstraint('id')
)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_table('users')
# ### end Alembic commands ###
|
[
"daronjp@gmail.com"
] |
daronjp@gmail.com
|
d4a33c08e35fe6ddedc4fee59d98a62a0b60cb31
|
1493997bb11718d3c18c6632b6dd010535f742f5
|
/particles/particles_point_sprites.py
|
34a1996efb93c10ffe497379fab53cf8acfd7ca9
|
[] |
no_license
|
kovrov/scrap
|
cd0cf2c98a62d5af6e4206a2cab7bb8e4560b168
|
b0f38d95dd4acd89c832188265dece4d91383bbb
|
refs/heads/master
| 2021-01-20T12:21:34.742007
| 2010-01-12T19:53:23
| 2010-01-12T19:53:23
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,964
|
py
|
from pyglet.gl import gl_info
assert gl_info.have_extension("GL_ARB_point_sprite"), "ARB_point_sprite not available"
from pyglet.gl import *
import random
# see:
# http://www.opengl.org/registry/specs/ARB/point_sprite.txt
# http://www.opengl.org/registry/specs/ARB/point_parameters.txt
g_slowdown = 2.0
# Query for the max point size supported by the hardware
g_maxSize = c_float(0.0)
glGetFloatv(GL_POINT_SIZE_MAX_ARB, pointer(g_maxSize))
# Clamp size to 100.0f or the sprites could get a little too big on some of the
# newer graphic cards. My ATI card at home supports a max point size of 1024.0!
if (g_maxSize.value > 100.0): g_maxSize.value = 100.0
def draw_task(texture_id):
particles = [{
'life': 1.0,
'fade': random.uniform(0.1, 0.004),
#'r': 1.0, 'g': 1.0, 'b': 1.0,
'r': 0.32, 'g': 0.32, 'b': 0.32,
'x': 0.0, 'y': 0.0, 'z': 0.0,
'xi': float(random.randint(-250, 250)),
'yi': float(random.randint(-250, 250)),
'zi': float(random.randint(-250, 250)),
'xg': 0.0, 'yg': -0.8, 'zg': 0.0,
} for i in xrange(1000)]
glDisable(GL_DEPTH_TEST) # TODO: see if this integrates well with rest of render...
glEnable(GL_POINT_SPRITE_ARB) # affects global state
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE)
# This is how will our point sprite's size will be modified by
# distance from the viewer
glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, (c_float*3)(1.0, 0.0, 0.01))
glPointSize(g_maxSize)
# The alpha of a point is calculated to allow the fading of points instead
# of shrinking them past a defined threshold size. The threshold is defined
# by GL_POINT_FADE_THRESHOLD_SIZE_ARB and is not clamped to the minimum and
# maximum point sizes.
# glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0)
# glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 1.0)
# glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, g_maxSize)
# Specify point sprite texture coordinate replacement mode for each
# texture unit (see ARB_point_sprite specs)
glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE) # per-texture unit
while True:
yield
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
glBindTexture(GL_TEXTURE_2D, texture_id)
glBegin(GL_POINTS)
for p in particles:
# draw
glColor4f(p['r'], p['g'], p['b'], p['life'])
glVertex3f(p['x'], p['y'], p['z'])
# update
p['life'] -= p['fade']
p['x'] += p['xi'] / (g_slowdown * 1000)
p['y'] += p['yi'] / (g_slowdown * 1000)
p['z'] += p['zi'] / (g_slowdown * 1000)
p['xi'] += p['xg']
p['yi'] += p['yg']
p['zi'] += p['zg']
if p['life'] < 0.0:
p['life'] = 1.0
p['fade'] = random.uniform(0.1, 0.004)
p['x'] = 0.0; p['y'] = 0.0; p['z'] = 0.0
p['xi'] = random.uniform(-32.0, 32.0)
p['yi'] = random.uniform(-32.0, 32.0)
p['zi'] = random.uniform(-32.0, 32.0)
glEnd()
glEnable(GL_BLEND)
glDisable(GL_POINT_SPRITE_ARB)
|
[
"kovrov@gmail.com"
] |
kovrov@gmail.com
|
d4eb0b65a8e727748c9d78004d51c636bf799cf0
|
6aea393423a0f840c5d28e903726c1fc82dd0544
|
/System_class.py
|
4b9ee2d8eebe3fa193ecc2a20d2e3af9fc762a77
|
[] |
no_license
|
markrsteiner/markosim_reloaded
|
7ea4e9ed6d3403a2e560e055f89ab359c69519be
|
96ce8d534c9e59feb79ed1e80a52ef55e88a7749
|
refs/heads/master
| 2020-04-10T18:09:24.717592
| 2019-02-28T16:28:55
| 2019-02-28T16:28:55
| 161,195,604
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 10,260
|
py
|
import math
import numpy as np
import format__output
class System:
def __init__(self, user_input_file: dict, simulation_instance) -> None: # should take simulator instance or something
self.input_bus_voltage = float(user_input_file['Vcc [V]'])
self.input_ic_peak = float(user_input_file['Io [Apk]'])
self.input_mod_depth = float(user_input_file['Mod. Depth'])
self.input_output_freq = float(user_input_file['fo [Hz]'])
self.input_t_sink = float(user_input_file['Ts [\u00B0C]'])
self.input_modulation_type = simulation_instance.get__modulation_type()
self.input_freq_carrier = float(user_input_file['fc [kHz]'])
self.is_three_level = simulation_instance.get__three_level_flag()
if self.is_three_level:
self.input_bus_voltage /= 2
self.input_rg_on_inside = float(user_input_file['Inside rg on [\u03A9]'])
self.input_rg_off_inside = float(user_input_file['Inside rg off [\u03A9]'])
self.input_rg_on_outside = float(user_input_file['Outside rg on [\u03A9]'])
self.input_rg_off_outside = float(user_input_file['Outside rg off [\u03A9]'])
else:
self.input_rg_on = float(user_input_file['rg on [\u03A9]'])
self.input_rg_off = float(user_input_file['rg off [\u03A9]'])
self.rg_output_flag = True
self.input_power_factor = float(user_input_file['PF [cos(\u03D5)]'])
self.step_size = simulation_instance.get__step_size()
self.time_division = 1 / self.input_output_freq / 360.0 * self.step_size
self.switches_per_degree = self.input_freq_carrier * self.time_division
self.power_factor_phase_shift = math.acos(float(user_input_file['PF [cos(\u03D5)]']))
self.output_current = []
self.system_output_view = {}
self.cycle_angle__degree = None
self.system_output_voltage = np.arange(0)
self.duty_cycle__p = []
self.duty_cycle__n = []
self.calculate__system_output()
def calculate__system_output(self):
self.cycle_angle__degree = np.array([val * math.pi / 180 * self.step_size for val in range(int(360 / self.step_size))]) #todo there is probably a smarter way to do this with numpy arange
if self.input_modulation_type == "Sinusoidal":
self.calculate__sinusoidal_output()
if self.input_modulation_type == "SVPWM": # add later maybe
self.calculate__svpwm_output()
if self.input_modulation_type == 'Two Phase I':
self.calculate__two_phase1_output()
if self.is_three_level:
self.duty_cycle__p = np.clip(self.system_output_voltage / self.input_bus_voltage, 0, 1)
self.duty_cycle__n = np.clip(-self.system_output_voltage / self.input_bus_voltage, 0, 1)
else:
self.duty_cycle__p = np.clip(np.divide(self.system_output_voltage, self.input_bus_voltage), 0, 1)
self.duty_cycle__n = 1 - self.duty_cycle__p
def create__output_view(self, inside_module, outside_module=None, diode_module=None):
is_three_level = outside_module is not None and diode_module is not None
if is_three_level:
self.system_output_view = format__output.build__output_view_dict(self, inside_module, outside_module, diode_module)
self.system_output_view.update({'Modulation': self.input_modulation_type})
if not self.rg_output_flag:
self.system_output_view.update({
'Outside rg on [\u03A9]': "STOCK",
'Outside rg off [\u03A9]': "STOCK",
'Inside rg on [\u03A9]': "STOCK",
'Inside rg off [\u03A9]': "STOCK"
})
else:
self.system_output_view = format__output.build__output_view_dict(self, inside_module)
self.system_output_view.update({'Modulation': self.input_modulation_type})
if self.rg_output_flag:
self.system_output_view.update({'rg on [\u03A9]': self.input_rg_on, 'rg off [\u03A9]': self.input_rg_off})
else:
self.system_output_view.update({'rg on [\u03A9]': "STOCK", 'rg off [\u03A9]': "STOCK"})
def calculate__sinusoidal_output(self):
if self.is_three_level:
self.system_output_voltage = self.input_bus_voltage * self.input_mod_depth * np.sin(self.cycle_angle__degree)
else:
self.system_output_voltage = self.input_bus_voltage * (1 + self.input_mod_depth * np.sin(self.cycle_angle__degree)) / 2
self.output_current = self.input_ic_peak * np.sin(self.cycle_angle__degree - self.power_factor_phase_shift)
def calculate__svpwm_output(self):
sector = np.floor(self.cycle_angle__degree * 3 / math.pi)
duty_cycle = np.array([self.svpwm_helper(_sector, _degree) for _sector, _degree in zip(sector, self.cycle_angle__degree)])
self.system_output_voltage = self.input_bus_voltage * duty_cycle
self.output_current = self.input_ic_peak * np.cos(self.cycle_angle__degree - self.power_factor_phase_shift)
def svpwm_helper(self, sector, degree):
modified_input_mod_depth = self.input_mod_depth * math.sqrt(3) / 2
duty_cycle_results = {
0: modified_input_mod_depth * math.cos(degree - math.pi / 6) + (1.0 - modified_input_mod_depth * math.cos(degree - math.pi / 6)) / 2.0,
1: modified_input_mod_depth * math.sin(2 * math.pi / 3 - degree) + (1.0 - modified_input_mod_depth * math.cos(degree - math.pi / 2)) / 2.0,
2: (1.0 - modified_input_mod_depth * math.cos(degree - 5 * math.pi / 6)) / 2.0,
3: (1.0 - modified_input_mod_depth * math.cos(degree - 7 * math.pi / 6)) / 2.0,
4: modified_input_mod_depth * math.sin(degree - 4 * math.pi / 3) + (1.0 - modified_input_mod_depth * math.cos(degree - 3 * math.pi / 2)) / 2.0,
5: modified_input_mod_depth * math.cos(degree - 11 * math.pi / 6) + (1.0 - modified_input_mod_depth * math.cos(degree - 11 * math.pi / 6)) / 2.0
}
return duty_cycle_results[sector]
def calculate__two_phase1_output(self):
sector = np.floor(self.cycle_angle__degree * 3 / math.pi)
duty_cycle = np.array([self.two_phase1_helper(_sector, _degree) for _sector, _degree in zip(sector, self.cycle_angle__degree)])
self.system_output_voltage = self.input_bus_voltage * duty_cycle
self.output_current = self.input_ic_peak * np.cos(self.cycle_angle__degree - self.power_factor_phase_shift)
def two_phase1_helper(self, sector, degree):
modified_input_mod_depth = self.input_mod_depth * math.sqrt(3) / 2
duty_cycle_results = {
0: modified_input_mod_depth * math.sin(degree + math.pi / 6),
1: 1.0,
2: -modified_input_mod_depth * math.sin(degree - 7 * math.pi / 6),
3: 1.0 + modified_input_mod_depth * math.sin(degree + math.pi / 6),
4: 0.0,
5: 1.0 - modified_input_mod_depth * math.sin(degree - 7 * math.pi / 6)
}
return duty_cycle_results[sector]
def calculate__two_phase2_output(self):
sector = np.floor(self.cycle_angle__degree * 1.5 * math.pi)
duty_cycle = np.array([self.two_phase2_helper(_sector, _degree) for _sector, _degree in zip(sector, self.cycle_angle__degree)])
self.system_output_voltage = self.input_bus_voltage * duty_cycle
self.output_current = self.input_ic_peak * np.cos(self.cycle_angle__degree - self.power_factor_phase_shift - math.pi / 6)
def two_phase2_helper(self, sector, degree):
modified_input_mod_depth = self.input_mod_depth * math.sqrt(3) / 2
duty_cycle_results = {
0: modified_input_mod_depth * math.sin(degree),
1: modified_input_mod_depth * math.sin(degree - math.pi / 3),
2: 0
}
return duty_cycle_results[sector]
# Getters and setters
#
# def set__step_size(self, step_size):
# self.step_size = step_size
# self.time_division = 1 / self.input_output_freq / 360.0 * self.step_size
# self.switches_per_degree = self.input_freq_carrier * self.time_division
#
# def set__three_level(self, is_three_level):
# self.is_three_level = is_three_level
# self.input_bus_voltage /= 2
#
# def set__modulation(self, input__modulation_type):
# self.input_modulation_type = input__modulation_type
def set__input_current(self, input_current):
self.input_ic_peak = input_current
def set__rg_flag(self, flag):
self.rg_output_flag = flag
def get__input_current(self):
return self.input_ic_peak
def get__input_bus_voltage(self):
return self.input_bus_voltage
def get__switches_per_degree(self):
return self.switches_per_degree
def get__input_output_freq(self):
return self.input_output_freq
def get__input_mod_depth(self):
return self.input_mod_depth
def get__input_freq_carrier(self):
return self.input_freq_carrier
def get__input_power_factor(self):
return self.input_power_factor
def get__duty_cycle__p(self):
return self.duty_cycle__p
def get__duty_cycle__n(self):
return self.duty_cycle__n
def get__step_size(self):
return self.step_size
def get__time_division(self):
return self.time_division
def get__input_t_sink(self):
return self.input_t_sink
def get__system_output_current(self):
return self.output_current
def get__system_output_voltage(self):
return self.system_output_voltage
def get__system_output_view(self):
return self.system_output_view
def get__input_rg_on(self):
return self.input_rg_on
def get__input_rg_off(self):
return self.input_rg_off
def get__input_rg_on_inside(self):
return self.input_rg_on_inside
def get__input_rg_off_inside(self):
return self.input_rg_off_inside
def get__input_rg_on_outside(self):
return self.input_rg_on_outside
def get__input_rg_off_outside(self):
return self.input_rg_off_outside
def get__three_level(self):
return self.is_three_level
|
[
"calarmy1"
] |
calarmy1
|
4f7ae60a8596d2b441a4ff0da86b405f6c80aba6
|
ad5d38fce4785037c108186f17eb1c64380355ef
|
/sddsd/google-cloud-sdk.staging/lib/googlecloudsdk/calliope/arg_parsers.py
|
106bfe82ce32e1f5504ba759ff9f2da633c36cc4
|
[
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] |
permissive
|
saranraju90/multik8s
|
75864b605a139ddb7947ed4de4ae8466bdd49acb
|
428576dedef7bb9cd6516e2c1ab2714581e1137c
|
refs/heads/master
| 2023-03-03T21:56:14.383571
| 2021-02-20T14:56:42
| 2021-02-20T14:56:42
| 339,665,231
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 53,962
|
py
|
# -*- coding: utf-8 -*- #
# Copyright 2013 Google LLC. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""A module that provides parsing utilities for argparse.
For details of how argparse argument pasers work, see:
http://docs.python.org/dev/library/argparse.html#type
Example usage:
import argparse
import arg_parsers
parser = argparse.ArgumentParser()
parser.add_argument(
'--metadata',
type=arg_parsers.ArgDict())
parser.add_argument(
'--delay',
default='5s',
type=arg_parsers.Duration(lower_bound='1s', upper_bound='10s')
parser.add_argument(
'--disk-size',
default='10GB',
type=arg_parsers.BinarySize(lower_bound='1GB', upper_bound='10TB')
res = parser.parse_args(
'--names --metadata x=y,a=b,c=d --delay 1s --disk-size 10gb'.split())
assert res.metadata == {'a': 'b', 'c': 'd', 'x': 'y'}
assert res.delay == 1
assert res.disk_size == 10737418240
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
import argparse
import collections
import copy
import re
from dateutil import tz
from googlecloudsdk.calliope import parser_errors
from googlecloudsdk.core import log
from googlecloudsdk.core import yaml
from googlecloudsdk.core.console import console_attr
from googlecloudsdk.core.console import console_io
from googlecloudsdk.core.util import files
from googlecloudsdk.core.util import times
import six
from six.moves import zip # pylint: disable=redefined-builtin
__all__ = ['Duration', 'BinarySize']
class Error(Exception):
"""Exceptions that are defined by this module."""
class ArgumentTypeError(Error, argparse.ArgumentTypeError):
"""Exceptions for parsers that are used as argparse types."""
class ArgumentParsingError(Error, argparse.ArgumentError):
"""Raised when there is a problem with user input.
argparse.ArgumentError takes both the action and a message as constructor
parameters.
"""
def _GenerateErrorMessage(error, user_input=None, error_idx=None):
"""Constructs an error message for an exception.
Args:
error: str, The error message that should be displayed. This
message should not end with any punctuation--the full error
message is constructed by appending more information to error.
user_input: str, The user input that caused the error.
error_idx: int, The index at which the error occurred. If None,
the index will not be printed in the error message.
Returns:
str: The message to use for the exception.
"""
if user_input is None:
return error
elif not user_input: # Is input empty?
return error + '; received empty string'
elif error_idx is None:
return error + '; received: ' + user_input
return ('{error_message} at index {error_idx}: {user_input}'
.format(error_message=error, user_input=user_input,
error_idx=error_idx))
_VALUE_PATTERN = r"""
^ # Beginning of input marker.
(?P<amount>\d+) # Amount.
((?P<suffix>[-/a-zA-Z]+))? # Optional scale and type abbr.
$ # End of input marker.
"""
_RANGE_PATTERN = r'^(?P<start>[0-9]+)(-(?P<end>[0-9]+))?$'
_SECOND = 1
_MINUTE = 60 * _SECOND
_HOUR = 60 * _MINUTE
_DAY = 24 * _HOUR
# The units are adopted from sleep(1):
# http://linux.die.net/man/1/sleep
_DURATION_SCALES = {
's': _SECOND,
'm': _MINUTE,
'h': _HOUR,
'd': _DAY,
}
_BINARY_SIZE_SCALES = {
'': 1,
'K': 1 << 10,
'M': 1 << 20,
'G': 1 << 30,
'T': 1 << 40,
'P': 1 << 50,
'Ki': 1 << 10,
'Mi': 1 << 20,
'Gi': 1 << 30,
'Ti': 1 << 40,
'Pi': 1 << 50,
}
def GetMultiCompleter(individual_completer):
"""Create a completer to handle completion for comma separated lists.
Args:
individual_completer: A function that completes an individual element.
Returns:
A function that completes the last element of the list.
"""
def MultiCompleter(prefix, parsed_args, **kwargs):
start = ''
lst = prefix.rsplit(',', 1)
if len(lst) > 1:
start = lst[0] + ','
prefix = lst[1]
matches = individual_completer(prefix, parsed_args, **kwargs)
return [start + match for match in matches]
return MultiCompleter
def _DeleteTypeAbbr(suffix, type_abbr='B'):
"""Returns suffix with trailing type abbreviation deleted."""
if not suffix:
return suffix
s = suffix.upper()
i = len(s)
for c in reversed(type_abbr.upper()):
if not i:
break
if s[i - 1] == c:
i -= 1
return suffix[:i]
def GetBinarySizePerUnit(suffix, type_abbr='B'):
"""Returns the binary size per unit for binary suffix string.
Args:
suffix: str, A case insensitive unit suffix string with optional type
abbreviation.
type_abbr: str, The optional case insensitive type abbreviation following
the suffix.
Raises:
ValueError for unknown units.
Returns:
The binary size per unit for a unit+type_abbr suffix.
"""
unit = _DeleteTypeAbbr(suffix.upper(), type_abbr)
return _BINARY_SIZE_SCALES.get(unit)
def _ValueParser(scales, default_unit, lower_bound=None, upper_bound=None,
strict_case=True, type_abbr='B',
suggested_binary_size_scales=None):
"""A helper that returns a function that can parse values with units.
Casing for all units matters.
Args:
scales: {str: int}, A dictionary mapping units to their magnitudes in
relation to the lowest magnitude unit in the dict.
default_unit: str, The default unit to use if the user's input is
missing unit.
lower_bound: str, An inclusive lower bound.
upper_bound: str, An inclusive upper bound.
strict_case: bool, whether to be strict on case-checking
type_abbr: str, the type suffix abbreviation, e.g., B for bytes, b/s for
bits/sec.
suggested_binary_size_scales: list, A list of strings with units that will
be recommended to user.
Returns:
A function that can parse values.
"""
def UnitsByMagnitude(suggested_binary_size_scales=None):
"""Returns a list of the units in scales sorted by magnitude."""
scale_items = sorted(six.iteritems(scales),
key=lambda value: (value[1], value[0]))
if suggested_binary_size_scales is None:
return [key + type_abbr for key, _ in scale_items]
return [key + type_abbr for key, _ in scale_items
if key + type_abbr in suggested_binary_size_scales]
def Parse(value):
"""Parses value that can contain a unit and type avvreviation."""
match = re.match(_VALUE_PATTERN, value, re.VERBOSE)
if not match:
raise ArgumentTypeError(_GenerateErrorMessage(
'given value must be of the form INTEGER[UNIT] where units '
'can be one of {0}'
.format(', '.join(UnitsByMagnitude(suggested_binary_size_scales))),
user_input=value))
amount = int(match.group('amount'))
suffix = match.group('suffix') or ''
unit = _DeleteTypeAbbr(suffix, type_abbr)
if strict_case:
unit_case = unit
default_unit_case = _DeleteTypeAbbr(default_unit, type_abbr)
scales_case = scales
else:
unit_case = unit.upper()
default_unit_case = _DeleteTypeAbbr(default_unit.upper(), type_abbr)
scales_case = dict([(k.upper(), v) for k, v in scales.items()])
if not unit and unit == suffix:
return amount * scales_case[default_unit_case]
elif unit_case in scales_case:
return amount * scales_case[unit_case]
else:
raise ArgumentTypeError(_GenerateErrorMessage(
'unit must be one of {0}'.format(', '.join(UnitsByMagnitude())),
user_input=unit))
if lower_bound is None:
parsed_lower_bound = None
else:
parsed_lower_bound = Parse(lower_bound)
if upper_bound is None:
parsed_upper_bound = None
else:
parsed_upper_bound = Parse(upper_bound)
def ParseWithBoundsChecking(value):
"""Same as Parse except bound checking is performed."""
if value is None:
return None
else:
parsed_value = Parse(value)
if parsed_lower_bound is not None and parsed_value < parsed_lower_bound:
raise ArgumentTypeError(_GenerateErrorMessage(
'value must be greater than or equal to {0}'.format(lower_bound),
user_input=value))
elif parsed_upper_bound is not None and parsed_value > parsed_upper_bound:
raise ArgumentTypeError(_GenerateErrorMessage(
'value must be less than or equal to {0}'.format(upper_bound),
user_input=value))
else:
return parsed_value
return ParseWithBoundsChecking
def RegexpValidator(pattern, description):
"""Returns a function that validates a string against a regular expression.
For example:
>>> alphanumeric_type = RegexpValidator(
... r'[a-zA-Z0-9]+',
... 'must contain one or more alphanumeric characters')
>>> parser.add_argument('--foo', type=alphanumeric_type)
>>> parser.parse_args(['--foo', '?'])
>>> # SystemExit raised and the error "error: argument foo: Bad value [?]:
>>> # must contain one or more alphanumeric characters" is displayed
Args:
pattern: str, the pattern to compile into a regular expression to check
description: an error message to show if the argument doesn't match
Returns:
function: str -> str, usable as an argparse type
"""
def Parse(value):
if not re.match(pattern + '$', value):
raise ArgumentTypeError('Bad value [{0}]: {1}'.format(value, description))
return value
return Parse
def CustomFunctionValidator(fn, description, parser=None):
"""Returns a function that validates the input by running it through fn.
For example:
>>> def isEven(val):
... return val % 2 == 0
>>> even_number_parser = arg_parsers.CustomFunctionValidator(
isEven, 'This is not even!', parser=arg_parsers.BoundedInt(0))
>>> parser.add_argument('--foo', type=even_number_parser)
>>> parser.parse_args(['--foo', '3'])
>>> # SystemExit raised and the error "error: argument foo: Bad value [3]:
>>> # This is not even!" is displayed
Args:
fn: str -> boolean
description: an error message to show if boolean function returns False
parser: an arg_parser that is applied to to value before validation. The
value is also returned by this parser.
Returns:
function: str -> str, usable as an argparse type
"""
def Parse(value):
"""Validates and returns a custom object from an argument string value."""
try:
parsed_value = parser(value) if parser else value
except ArgumentTypeError:
pass
else:
if fn(parsed_value):
return parsed_value
encoded_value = console_attr.SafeText(value)
formatted_err = 'Bad value [{0}]: {1}'.format(encoded_value, description)
raise ArgumentTypeError(formatted_err)
return Parse
def Duration(default_unit='s',
lower_bound='0',
upper_bound=None,
parsed_unit='s'):
"""Returns a function that can parse time durations.
See times.ParseDuration() for details. If the unit is omitted, seconds is
assumed. The parsed unit is assumed to be seconds, but can be specified as
ms or us.
For example:
parser = Duration()
assert parser('10s') == 10
parser = Duration(parsed_unit='ms')
assert parser('10s') == 10000
parser = Duration(parsed_unit='us')
assert parser('10s') == 10000000
Args:
default_unit: str, The default duration unit.
lower_bound: str, An inclusive lower bound for values.
upper_bound: str, An inclusive upper bound for values.
parsed_unit: str, The unit that the result should be returned as. Can be
's', 'ms', or 'us'.
Raises:
ArgumentTypeError: If either the lower_bound or upper_bound
cannot be parsed. The returned function will also raise this
error if it cannot parse its input. This exception is also
raised if the returned function receives an out-of-bounds
input.
Returns:
A function that accepts a single time duration as input to be
parsed.
"""
def Parse(value):
"""Parses a duration from value and returns integer of the parsed_unit."""
if parsed_unit == 'ms':
multiplier = 1000
elif parsed_unit == 'us':
multiplier = 1000000
elif parsed_unit == 's':
multiplier = 1
else:
raise ArgumentTypeError(
_GenerateErrorMessage('parsed_unit must be one of s, ms, us.'))
try:
duration = times.ParseDuration(value, default_suffix=default_unit)
return int(duration.total_seconds * multiplier)
except times.Error as e:
message = six.text_type(e).rstrip('.')
raise ArgumentTypeError(_GenerateErrorMessage(
'Failed to parse duration: {0}'.format(message, user_input=value)))
parsed_lower_bound = Parse(lower_bound)
if upper_bound is None:
parsed_upper_bound = None
else:
parsed_upper_bound = Parse(upper_bound)
def ParseWithBoundsChecking(value):
"""Same as Parse except bound checking is performed."""
if value is None:
return None
parsed_value = Parse(value)
if parsed_lower_bound is not None and parsed_value < parsed_lower_bound:
raise ArgumentTypeError(_GenerateErrorMessage(
'value must be greater than or equal to {0}'.format(lower_bound),
user_input=value))
if parsed_upper_bound is not None and parsed_value > parsed_upper_bound:
raise ArgumentTypeError(_GenerateErrorMessage(
'value must be less than or equal to {0}'.format(upper_bound),
user_input=value))
return parsed_value
return ParseWithBoundsChecking
def BinarySize(lower_bound=None, upper_bound=None,
suggested_binary_size_scales=None, default_unit='G',
type_abbr='B'):
"""Returns a function that can parse binary sizes.
Binary sizes are defined as base-2 values representing number of
bytes.
Input to the parsing function must be a string of the form:
INTEGER[UNIT]
The integer must be non-negative. Valid units are "B", "KB", "MB",
"GB", "TB", "KiB", "MiB", "GiB", "TiB", "PiB". If the unit is
omitted then default_unit is assumed.
The result is parsed in bytes. For example:
parser = BinarySize()
assert parser('10GB') == 1073741824
Args:
lower_bound: str, An inclusive lower bound for values.
upper_bound: str, An inclusive upper bound for values.
suggested_binary_size_scales: list, A list of strings with units that will
be recommended to user.
default_unit: str, unit used when user did not specify unit.
type_abbr: str, the type suffix abbreviation, e.g., B for bytes, b/s for
bits/sec.
Raises:
ArgumentTypeError: If either the lower_bound or upper_bound
cannot be parsed. The returned function will also raise this
error if it cannot parse its input. This exception is also
raised if the returned function receives an out-of-bounds
input.
Returns:
A function that accepts a single binary size as input to be
parsed.
"""
return _ValueParser(
_BINARY_SIZE_SCALES, default_unit=default_unit, lower_bound=lower_bound,
upper_bound=upper_bound, strict_case=False, type_abbr=type_abbr,
suggested_binary_size_scales=suggested_binary_size_scales)
_KV_PAIR_DELIMITER = '='
class Range(object):
"""Range of integer values."""
def __init__(self, start, end):
self.start = start
self.end = end
@staticmethod
def Parse(string_value):
"""Creates Range object out of given string value."""
match = re.match(_RANGE_PATTERN, string_value)
if not match:
raise ArgumentTypeError('Expected a non-negative integer value or a '
'range of such values instead of "{0}"'
.format(string_value))
start = int(match.group('start'))
end = match.group('end')
if end is None:
end = start
else:
end = int(end)
if end < start:
raise ArgumentTypeError('Expected range start {0} smaller or equal to '
'range end {1} in "{2}"'.format(
start, end, string_value))
return Range(start, end)
def Combine(self, other):
"""Combines two overlapping or adjacent ranges, raises otherwise."""
if self.end + 1 < other.start or self.start > other.end + 1:
raise Error('Cannot combine non-overlapping or non-adjacent ranges '
'{0} and {1}'.format(self, other))
return Range(min(self.start, other.start), max(self.end, other.end))
def __eq__(self, other):
if isinstance(other, Range):
return self.start == other.start and self.end == other.end
return False
def __lt__(self, other):
if self.start == other.start:
return self.end < other.end
return self.start < other.start
def __str__(self):
if self.start == self.end:
return six.text_type(self.start)
return '{0}-{1}'.format(self.start, self.end)
class HostPort(object):
"""A class for holding host and port information."""
IPV4_OR_HOST_PATTERN = r'^(?P<address>[\w\d\.-]+)?(:|:(?P<port>[\d]+))?$'
# includes hostnames
IPV6_PATTERN = r'^(\[(?P<address>[\w\d:]+)\])(:|:(?P<port>[\d]+))?$'
def __init__(self, host, port):
self.host = host
self.port = port
@staticmethod
def Parse(s, ipv6_enabled=False):
"""Parse the given string into a HostPort object.
This can be used as an argparse type.
Args:
s: str, The string to parse. If ipv6_enabled and host is an IPv6 address,
it should be placed in square brackets: e.g.
[2001:db8:0:0:0:ff00:42:8329]
or
[2001:db8:0:0:0:ff00:42:8329]:8080
ipv6_enabled: boolean, If True then accept IPv6 addresses.
Raises:
ArgumentTypeError: If the string is not valid.
Returns:
HostPort, The parsed object.
"""
if not s:
return HostPort(None, None)
match = re.match(HostPort.IPV4_OR_HOST_PATTERN, s, re.UNICODE)
if ipv6_enabled and not match:
match = re.match(HostPort.IPV6_PATTERN, s, re.UNICODE)
if not match:
raise ArgumentTypeError(_GenerateErrorMessage(
'Failed to parse host and port. Expected format \n\n'
' IPv4_ADDRESS_OR_HOSTNAME:PORT\n\n'
'or\n\n'
' [IPv6_ADDRESS]:PORT\n\n'
'(where :PORT is optional).',
user_input=s))
elif not match:
raise ArgumentTypeError(_GenerateErrorMessage(
'Failed to parse host and port. Expected format \n\n'
' IPv4_ADDRESS_OR_HOSTNAME:PORT\n\n'
'(where :PORT is optional).',
user_input=s))
return HostPort(match.group('address'), match.group('port'))
class Day(object):
"""A class for parsing a datetime object for a specific day."""
@staticmethod
def Parse(s):
if not s:
return None
try:
return times.ParseDateTime(s, '%Y-%m-%d').date()
except times.Error as e:
raise ArgumentTypeError(
_GenerateErrorMessage(
'Failed to parse date: {0}'.format(six.text_type(e)),
user_input=s))
class Datetime(object):
"""A class for parsing a datetime object."""
@staticmethod
def Parse(s):
"""Parses a string value into a Datetime object in local timezone."""
if not s:
return None
try:
return times.ParseDateTime(s)
except times.Error as e:
raise ArgumentTypeError(
_GenerateErrorMessage(
'Failed to parse date/time: {0}'.format(six.text_type(e)),
user_input=s))
@staticmethod
def ParseUtcTime(s):
"""Parses a string representing a time in UTC into a Datetime object."""
if not s:
return None
try:
return times.ParseDateTime(s, tzinfo=tz.tzutc())
except times.Error as e:
raise ArgumentTypeError(
_GenerateErrorMessage(
'Failed to parse UTC time: {0}'.format(six.text_type(e)),
user_input=s))
class DayOfWeek(object):
"""A class for parsing a day of the week."""
DAYS = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
@staticmethod
def Parse(s):
"""Validates and normalizes a string as a day of the week."""
if not s:
return None
fixed = s.upper()[:3]
if fixed not in DayOfWeek.DAYS:
raise ArgumentTypeError(
_GenerateErrorMessage(
'Failed to parse day of week. Value should be one of {0}'.format(
', '.join(DayOfWeek.DAYS)),
user_input=s))
return fixed
def _BoundedType(type_builder, type_description,
lower_bound=None, upper_bound=None, unlimited=False):
"""Returns a function that can parse given type within some bound.
Args:
type_builder: A callable for building the requested type from the value
string.
type_description: str, Description of the requested type (for verbose
messages).
lower_bound: of type compatible with type_builder,
The value must be >= lower_bound.
upper_bound: of type compatible with type_builder,
The value must be <= upper_bound.
unlimited: bool, If True then a value of 'unlimited' means no limit.
Returns:
A function that can parse given type within some bound.
"""
def Parse(value):
"""Parses value as a type constructed by type_builder.
Args:
value: str, Value to be converted to the requested type.
Raises:
ArgumentTypeError: If the provided value is out of bounds or unparsable.
Returns:
Value converted to the requested type.
"""
if unlimited and value == 'unlimited':
return None
try:
v = type_builder(value)
except ValueError:
raise ArgumentTypeError(
_GenerateErrorMessage('Value must be {0}'.format(type_description),
user_input=value))
if lower_bound is not None and v < lower_bound:
raise ArgumentTypeError(
_GenerateErrorMessage(
'Value must be greater than or equal to {0}'.format(lower_bound),
user_input=value))
if upper_bound is not None and upper_bound < v:
raise ArgumentTypeError(
_GenerateErrorMessage(
'Value must be less than or equal to {0}'.format(upper_bound),
user_input=value))
return v
return Parse
def BoundedInt(*args, **kwargs):
return _BoundedType(int, 'an integer', *args, **kwargs)
def BoundedFloat(*args, **kwargs):
return _BoundedType(float, 'a floating point number', *args, **kwargs)
def _TokenizeQuotedList(arg_value, delim=','):
"""Tokenize an argument into a list.
Args:
arg_value: str, The raw argument.
delim: str, The delimiter on which to split the argument string.
Returns:
[str], The tokenized list.
"""
if arg_value:
if not arg_value.endswith(delim):
arg_value += delim
return arg_value.split(delim)[:-1]
return []
class ArgType(object):
"""Base class for arg types."""
class ArgBoolean(ArgType):
"""Interpret an argument value as a bool."""
def __init__(
self, truthy_strings=None, falsey_strings=None, case_sensitive=False):
self._case_sensitive = case_sensitive
if truthy_strings:
self._truthy_strings = truthy_strings
else:
self._truthy_strings = ['true', 'yes']
if falsey_strings:
self._falsey_strings = falsey_strings
else:
self._falsey_strings = ['false', 'no']
def __call__(self, arg_value):
if not self._case_sensitive:
normalized_arg_value = arg_value.lower()
else:
normalized_arg_value = arg_value
if normalized_arg_value in self._truthy_strings:
return True
if normalized_arg_value in self._falsey_strings:
return False
raise ArgumentTypeError(
'Invalid flag value [{0}], expected one of [{1}]'.format(
arg_value,
', '.join(self._truthy_strings + self._falsey_strings)
)
)
class ArgList(ArgType):
"""Interpret an argument value as a list.
Intended to be used as the type= for a flag argument. Splits the string on
commas or another delimiter and returns a list.
By default, splits on commas:
'a,b,c' -> ['a', 'b', 'c']
There is an available syntax for using an alternate delimiter:
'^:^a,b:c' -> ['a,b', 'c']
'^::^a:b::c' -> ['a:b', 'c']
'^,^^a^,b,c' -> ['^a^', ',b', 'c']
"""
DEFAULT_DELIM_CHAR = ','
ALT_DELIM_CHAR = '^'
def __init__(self,
element_type=None,
min_length=0,
max_length=None,
choices=None,
custom_delim_char=None,
visible_choices=None):
"""Initialize an ArgList.
Args:
element_type: (str)->str, A function to apply to each of the list items.
min_length: int, The minimum size of the list.
max_length: int, The maximum size of the list.
choices: [element_type], a list of valid possibilities for elements. If
None, then no constraints are imposed.
custom_delim_char: char, A customized delimiter character.
visible_choices: [element_type], a list of valid possibilities for
elements to be shown to the user. If None, defaults to choices.
Returns:
(str)->[str], A function to parse the list of values in the argument.
Raises:
ArgumentTypeError: If the list is malformed.
"""
self.element_type = element_type
self.choices = choices
self.visible_choices = (
visible_choices if visible_choices is not None else choices)
if self.visible_choices:
def ChoiceType(raw_value):
if element_type:
typed_value = element_type(raw_value)
else:
typed_value = raw_value
if typed_value not in choices:
raise ArgumentTypeError('{value} must be one of [{choices}]'.format(
value=typed_value,
choices=', '.join(
[six.text_type(choice) for choice in self.visible_choices])))
return typed_value
self.element_type = ChoiceType
self.min_length = min_length
self.max_length = max_length
self.custom_delim_char = custom_delim_char
def __call__(self, arg_value): # pylint:disable=missing-docstring
if isinstance(arg_value, list):
arg_list = arg_value
elif not isinstance(arg_value, six.string_types):
raise ArgumentTypeError('Invalid type [{}] for flag value [{}]'.format(
type(arg_value).__name__, arg_value))
else:
delim = self.custom_delim_char or self.DEFAULT_DELIM_CHAR
if (arg_value.startswith(self.ALT_DELIM_CHAR) and
self.ALT_DELIM_CHAR in arg_value[1:]):
delim, arg_value = arg_value[1:].split(self.ALT_DELIM_CHAR, 1)
if not delim:
raise ArgumentTypeError(
'Invalid delimeter. Please see `gcloud topic flags-file` or '
'`gcloud topic escaping` for information on providing list or '
'dictionary flag values with special characters.')
arg_list = _TokenizeQuotedList(arg_value, delim=delim)
# TODO(b/35944028): These exceptions won't present well to the user.
if len(arg_list) < self.min_length:
raise ArgumentTypeError('not enough args')
if self.max_length is not None and len(arg_list) > self.max_length:
raise ArgumentTypeError('too many args')
if self.element_type:
arg_list = [self.element_type(arg) for arg in arg_list]
return arg_list
_MAX_METAVAR_LENGTH = 30 # arbitrary, but this is pretty long
def GetUsageMsg(self, is_custom_metavar, metavar):
"""Get a specially-formatted metavar for the ArgList to use in help.
An example is worth 1,000 words:
>>> ArgList().GetUsageMetavar('FOO')
'[FOO,...]'
>>> ArgList(min_length=1).GetUsageMetavar('FOO')
'FOO,[FOO,...]'
>>> ArgList(max_length=2).GetUsageMetavar('FOO')
'FOO,[FOO]'
>>> ArgList(max_length=3).GetUsageMetavar('FOO') # One, two, many...
'FOO,[FOO,...]'
>>> ArgList(min_length=2, max_length=2).GetUsageMetavar('FOO')
'FOO,FOO'
>>> ArgList().GetUsageMetavar('REALLY_VERY_QUITE_LONG_METAVAR')
'REALLY_VERY_QUITE_LONG_METAVAR,[...]'
Args:
is_custom_metavar: unused in GetUsageMsg
metavar: string, the base metavar to turn into an ArgList metavar
Returns:
string, the ArgList usage metavar
"""
del is_custom_metavar # Unused in GetUsageMsg
delim_char = self.custom_delim_char or self.DEFAULT_DELIM_CHAR
required = delim_char.join([metavar] * self.min_length)
if self.max_length:
num_optional = self.max_length - self.min_length
else:
num_optional = None
# Use the "1, 2, many" approach to counting
if num_optional == 0:
optional = ''
elif num_optional == 1:
optional = '[{}]'.format(metavar)
elif num_optional == 2:
optional = '[{0}{1}[{0}]]'.format(metavar, delim_char)
else:
optional = '[{}{}...]'.format(metavar, delim_char)
msg = delim_char.join([x for x in [required, optional] if x])
if len(msg) < self._MAX_METAVAR_LENGTH:
return msg
# With long metavars, only put it in once.
if self.min_length == 0:
return '[{}{}...]'.format(metavar, delim_char)
if self.min_length == 1:
return '{}{}[...]'.format(metavar, delim_char)
else:
return '{0}{1}...{1}[...]'.format(metavar, delim_char)
class ArgDict(ArgList):
"""Interpret an argument value as a dict.
Intended to be used as the type= for a flag argument. Splits the string on
commas to get a list, and then splits the items on equals to get a set of
key-value pairs to get a dict.
"""
def __init__(self, key_type=None, value_type=None, spec=None, min_length=0,
max_length=None, allow_key_only=False, required_keys=None,
operators=None):
"""Initialize an ArgDict.
Args:
key_type: (str)->str, A function to apply to each of the dict keys.
value_type: (str)->str, A function to apply to each of the dict values.
spec: {str: (str)->str}, A mapping of expected keys to functions.
The functions are applied to the values. If None, an arbitrary
set of keys will be accepted. If not None, it is an error for the
user to supply a key that is not in the spec. If the function specified
is None, then accept a key only without '=value'.
min_length: int, The minimum number of keys in the dict.
max_length: int, The maximum number of keys in the dict.
allow_key_only: bool, Allow empty values.
required_keys: [str], Required keys in the dict.
operators: operator_char -> value_type, Define multiple single character
operators, each with its own value_type converter. Use value_type==None
for no conversion. The default value is {'=': value_type}
Returns:
(str)->{str:str}, A function to parse the dict in the argument.
Raises:
ArgumentTypeError: If the list is malformed.
ValueError: If both value_type and spec are provided.
"""
super(ArgDict, self).__init__(min_length=min_length, max_length=max_length)
if spec and value_type:
raise ValueError('cannot have both spec and sub_type')
self.key_type = key_type
self.spec = spec
self.allow_key_only = allow_key_only
self.required_keys = required_keys or []
if not operators:
operators = {'=': value_type}
for op in operators.keys():
if len(op) != 1:
raise ArgumentTypeError(
'Operator [{}] must be one character.'.format(op))
ops = ''.join(six.iterkeys(operators))
key_op_value_pattern = '([^{ops}]+)([{ops}]?)(.*)'.format(
ops=re.escape(ops))
self.key_op_value = re.compile(key_op_value_pattern, re.DOTALL)
self.operators = operators
def _ApplySpec(self, key, value):
if key in self.spec:
if self.spec[key] is None:
if value:
raise ArgumentTypeError('Key [{0}] does not take a value'.format(key))
return None
return self.spec[key](value)
else:
raise ArgumentTypeError(
_GenerateErrorMessage(
'valid keys are [{0}]'.format(
', '.join(sorted(self.spec.keys()))),
user_input=key))
def _ValidateKeyValue(self, key, value, op='='):
"""Converts and validates <key,value> and returns (key,value)."""
if (not op or value is None) and not self.allow_key_only:
raise ArgumentTypeError(
'Bad syntax for dict arg: [{0}]. Please see '
'`gcloud topic flags-file` or `gcloud topic escaping` for '
'information on providing list or dictionary flag values with '
'special characters.'.format(key))
if self.key_type:
try:
key = self.key_type(key)
except ValueError:
raise ArgumentTypeError('Invalid key [{0}]'.format(key))
convert_value = self.operators.get(op, None)
if convert_value:
try:
value = convert_value(value)
except ValueError:
raise ArgumentTypeError('Invalid value [{0}]'.format(value))
if self.spec:
value = self._ApplySpec(key, value)
return key, value
def __call__(self, arg_value): # pylint:disable=missing-docstring
if isinstance(arg_value, dict):
raw_dict = arg_value
arg_dict = collections.OrderedDict()
for key, value in six.iteritems(raw_dict):
key, value = self._ValidateKeyValue(key, value)
arg_dict[key] = value
elif not isinstance(arg_value, six.string_types):
raise ArgumentTypeError('Invalid type [{}] for flag value [{}]'.format(
type(arg_value).__name__, arg_value))
else:
arg_list = super(ArgDict, self).__call__(arg_value)
arg_dict = collections.OrderedDict()
for arg in arg_list:
match = self.key_op_value.match(arg)
# TODO(b/35944028): These exceptions won't present well to the user.
if not match:
raise ArgumentTypeError('Invalid flag value [{0}]'.format(arg))
key, op, value = match.group(1), match.group(2), match.group(3)
key, value = self._ValidateKeyValue(key, value, op=op)
arg_dict[key] = value
for required_key in self.required_keys:
if required_key not in arg_dict:
raise ArgumentTypeError(
'Key [{0}] required in dict arg but not provided'.format(
required_key))
return arg_dict
def GetUsageMsg(self, is_custom_metavar, metavar):
# If we're not using a spec to limit the key values or if metavar
# has been overridden, then use the normal ArgList formatting
if not self.spec or is_custom_metavar:
return super(ArgDict, self).GetUsageMsg(is_custom_metavar, metavar)
msg_list = []
spec_list = sorted(six.iteritems(self.spec))
# First put the spec keys with no value followed by those that expect a
# value
for spec_key, spec_function in spec_list:
if spec_function is None:
if not self.allow_key_only:
raise ArgumentTypeError(
'Key [{0}] specified in spec without a function but '
'allow_key_only is set to False'.format(spec_key))
msg_list.append(spec_key)
for spec_key, spec_function in spec_list:
if spec_function is not None:
msg_list.append('{0}={1}'.format(spec_key, spec_key.upper()))
msg = '[' + '],['.join(msg_list) + ']'
return msg
class UpdateAction(argparse.Action):
r"""Create a single dict value from delimited or repeated flags.
This class is intended to be a more flexible version of
argparse._AppendAction.
For example, with the following flag definition:
parser.add_argument(
'--inputs',
type=arg_parsers.ArgDict(),
action='append')
a caller can specify on the command line flags such as:
--inputs k1=v1,k2=v2
and the result will be a list of one dict:
[{ 'k1': 'v1', 'k2': 'v2' }]
Specifying two separate command line flags such as:
--inputs k1=v1 \
--inputs k2=v2
will produce a list of dicts:
[{ 'k1': 'v1'}, { 'k2': 'v2' }]
The UpdateAction class allows for both of the above user inputs to result
in the same: a single dictionary:
{ 'k1': 'v1', 'k2': 'v2' }
This gives end-users a lot more flexibility in constructing their command
lines, especially when scripting calls.
Note that this class will raise an exception if a key value is specified
more than once. To allow for a key value to be specified multiple times,
use UpdateActionWithAppend.
"""
def OnDuplicateKeyRaiseError(self, key, existing_value=None, new_value=None):
if existing_value is None:
user_input = None
else:
user_input = ', '.join([existing_value, new_value])
raise argparse.ArgumentError(self, _GenerateErrorMessage(
'"{0}" cannot be specified multiple times'.format(key),
user_input=user_input))
def __init__(self,
option_strings,
dest,
nargs=None,
const=None,
default=None,
type=None, # pylint:disable=redefined-builtin
choices=None,
required=False,
help=None, # pylint:disable=redefined-builtin
metavar=None,
onduplicatekey_handler=OnDuplicateKeyRaiseError):
if nargs == 0:
raise ValueError('nargs for append actions must be > 0; if arg '
'strings are not supplying the value to append, '
'the append const action may be more appropriate')
if const is not None and nargs != argparse.OPTIONAL:
raise ValueError('nargs must be %r to supply const' % argparse.OPTIONAL)
self.choices = choices
if isinstance(choices, dict):
choices = sorted(choices.keys())
super(UpdateAction, self).__init__(
option_strings=option_strings,
dest=dest,
nargs=nargs,
const=const,
default=default,
type=type,
choices=choices,
required=required,
help=help,
metavar=metavar)
self.onduplicatekey_handler = onduplicatekey_handler
def _EnsureValue(self, namespace, name, value):
if getattr(namespace, name, None) is None:
setattr(namespace, name, value)
return getattr(namespace, name)
# pylint: disable=protected-access
def __call__(self, parser, namespace, values, option_string=None):
if isinstance(values, dict):
# Get the existing arg value (if any)
items = copy.copy(self._EnsureValue(
namespace, self.dest, collections.OrderedDict()))
# Merge the new key/value pair(s) in
for k, v in six.iteritems(values):
if k in items:
v = self.onduplicatekey_handler(self, k, items[k], v)
items[k] = v
else:
# Get the existing arg value (if any)
items = copy.copy(self._EnsureValue(namespace, self.dest, []))
# Merge the new key/value pair(s) in
for k in values:
if k in items:
self.onduplicatekey_handler(self, k)
else:
items.append(k)
# Saved the merged dictionary
setattr(namespace, self.dest, items)
class UpdateActionWithAppend(UpdateAction):
"""Create a single dict value from delimited or repeated flags.
This class provides a variant of UpdateAction, which allows for users to
append, rather than reject, duplicate key values. For example, the user
can specify:
--inputs k1=v1a --inputs k1=v1b --inputs k2=v2
and the result will be:
{ 'k1': ['v1a', 'v1b'], 'k2': 'v2' }
"""
def OnDuplicateKeyAppend(self, key, existing_value=None, new_value=None):
if existing_value is None:
return key
elif isinstance(existing_value, list):
return existing_value + [new_value]
else:
return [existing_value, new_value]
def __init__(self,
option_strings,
dest,
nargs=None,
const=None,
default=None,
type=None, # pylint:disable=redefined-builtin
choices=None,
required=False,
help=None, # pylint:disable=redefined-builtin
metavar=None,
onduplicatekey_handler=OnDuplicateKeyAppend):
super(UpdateActionWithAppend, self).__init__(
option_strings=option_strings,
dest=dest,
nargs=nargs,
const=const,
default=default,
type=type,
choices=choices,
required=required,
help=help,
metavar=metavar,
onduplicatekey_handler=onduplicatekey_handler)
class RemainderAction(argparse._StoreAction): # pylint: disable=protected-access
"""An action with a couple of helpers to better handle --.
argparse on its own does not properly handle -- implementation args.
argparse.REMAINDER greedily steals valid flags before a --, and nargs='*' will
bind to [] and not parse args after --. This Action represents arguments to
be passed through to a subcommand after --.
Primarily, this Action provides two utility parsers to help a modified
ArgumentParser parse -- properly.
There is one additional property kwarg:
example: A usage statement used to construct nice additional help.
"""
def __init__(self, *args, **kwargs):
if kwargs['nargs'] is not argparse.REMAINDER:
raise ValueError(
'The RemainderAction should only be used when '
'nargs=argparse.REMAINDER.')
# Create detailed help.
self.explanation = (
"The '--' argument must be specified between gcloud specific args on "
'the left and {metavar} on the right.'
).format(metavar=kwargs['metavar'])
if 'help' in kwargs:
kwargs['help'] += '\n+\n' + self.explanation
if 'example' in kwargs:
kwargs['help'] += ' Example:\n\n' + kwargs['example']
del kwargs['example']
super(RemainderAction, self).__init__(*args, **kwargs)
def _SplitOnDash(self, args):
split_index = args.index('--')
# Remove -- before passing through
return args[:split_index], args[split_index + 1:]
def ParseKnownArgs(self, args, namespace):
"""Binds all args after -- to the namespace."""
# Not [], so that we can distinguish between empty remainder args and
# absent remainder args.
remainder_args = None
if '--' in args:
args, remainder_args = self._SplitOnDash(args)
self(None, namespace, remainder_args)
return namespace, args
def ParseRemainingArgs(self, remaining_args, namespace, original_args):
"""Parses the unrecognized args from the end of the remaining_args.
This method identifies all unrecognized arguments after the last argument
recognized by a parser (but before --). It then either logs a warning and
binds them to the namespace or raises an error, depending on strictness.
Args:
remaining_args: A list of arguments that the parsers did not recognize.
namespace: The Namespace to bind to.
original_args: The full list of arguments given to the top parser,
Raises:
ArgumentError: If there were remaining arguments after the last recognized
argument and this action is strict.
Returns:
A tuple of the updated namespace and unrecognized arguments (before the
last recognized argument).
"""
# Only parse consecutive unknown args from the end of the original args.
# Strip out everything after '--'
if '--' in original_args:
original_args, _ = self._SplitOnDash(original_args)
# Find common suffix between remaining_args and original_args
split_index = 0
for i, (arg1, arg2) in enumerate(
zip(reversed(remaining_args), reversed(original_args))):
if arg1 != arg2:
split_index = len(remaining_args) - i
break
pass_through_args = remaining_args[split_index:]
remaining_args = remaining_args[:split_index]
if pass_through_args:
msg = ('unrecognized args: {args}\n' + self.explanation).format(
args=' '.join(pass_through_args))
raise parser_errors.UnrecognizedArgumentsError(msg)
self(None, namespace, pass_through_args)
return namespace, remaining_args
class StoreOnceAction(argparse.Action):
r"""Create a single dict value from delimited flags.
For example, with the following flag definition:
parser.add_argument(
'--inputs',
type=arg_parsers.ArgDict(),
action=StoreOnceAction)
a caller can specify on the command line flags such as:
--inputs k1=v1,k2=v2
and the result will be a list of one dict:
[{ 'k1': 'v1', 'k2': 'v2' }]
Specifying two separate command line flags such as:
--inputs k1=v1 \
--inputs k2=v2
will raise an exception.
Note that this class will raise an exception if a key value is specified
more than once. To allow for a key value to be specified multiple times,
use UpdateActionWithAppend.
"""
def OnSecondArgumentRaiseError(self):
raise argparse.ArgumentError(self, _GenerateErrorMessage(
'"{0}" argument cannot be specified multiple times'.format(self.dest)))
def __init__(self, *args, **kwargs):
self.dest_is_populated = False
super(StoreOnceAction, self).__init__(*args, **kwargs)
# pylint: disable=protected-access
def __call__(self, parser, namespace, values, option_string=None):
# Make sure no existing arg value exist
if self.dest_is_populated:
self.OnSecondArgumentRaiseError()
self.dest_is_populated = True
setattr(namespace, self.dest, values)
class _HandleNoArgAction(argparse.Action):
"""This class should not be used directly, use HandleNoArgAction instead."""
def __init__(self, none_arg, deprecation_message, **kwargs):
super(_HandleNoArgAction, self).__init__(**kwargs)
self.none_arg = none_arg
self.deprecation_message = deprecation_message
def __call__(self, parser, namespace, value, option_string=None):
if value is None:
log.warning(self.deprecation_message)
if self.none_arg:
setattr(namespace, self.none_arg, True)
setattr(namespace, self.dest, value)
def HandleNoArgAction(none_arg, deprecation_message):
"""Creates an argparse.Action that warns when called with no arguments.
This function creates an argparse action which can be used to gracefully
deprecate a flag using nargs=?. When a flag is created with this action, it
simply log.warning()s the given deprecation_message and then sets the value of
the none_arg to True.
This means if you use the none_arg no_foo and attach this action to foo,
`--foo` (no argument), it will have the same effect as `--no-foo`.
Args:
none_arg: a boolean argument to write to. For --no-foo use "no_foo"
deprecation_message: msg to tell user to stop using with no arguments.
Returns:
An argparse action.
"""
def HandleNoArgActionInit(**kwargs):
return _HandleNoArgAction(none_arg, deprecation_message, **kwargs)
return HandleNoArgActionInit
class FileContents(object):
"""Creates an argparse type that reads the contents of a file or stdin.
This is similar to argparse.FileType, but unlike FileType it does not leave
a dangling file handle open. The argument stored in the argparse Namespace
is the file's contents.
Attributes:
binary: bool, If True, the contents of the file will be returned as bytes.
Returns:
A function that accepts a filename, or "-" representing that stdin should be
used as input.
"""
def __init__(self, binary=False):
self.binary = binary
def __call__(self, name):
"""Return the contents of the file with the specified name.
If name is "-", stdin is read until EOF. Otherwise, the named file is read.
Args:
name: str, The file name, or '-' to indicate stdin.
Returns:
The contents of the file.
Raises:
ArgumentTypeError: If the file cannot be read or is too large.
"""
try:
return console_io.ReadFromFileOrStdin(name, binary=self.binary)
except files.Error as e:
raise ArgumentTypeError(e)
class YAMLFileContents(object):
"""Creates an argparse type that reads the contents of a YAML or JSON file.
This is similar to argparse.FileType, but unlike FileType it does not leave
a dangling file handle open. The argument stored in the argparse Namespace
is the file's contents parsed as a YAML object.
Attributes:
validator: function, Function that will validate the provided input
file contents.
Returns:
A function that accepts a filename that should be parsed as a YAML
or JSON file.
"""
def __init__(self, validator=None):
if validator and not callable(validator):
raise ArgumentTypeError('Validator must be callable')
self.validator = validator
def _AssertJsonLike(self, yaml_data):
if not (yaml.dict_like(yaml_data) or yaml.list_like(yaml_data)):
raise ArgumentTypeError('Invalid YAML/JSON Data [{}]'.format(yaml_data))
def _LoadSingleYamlDocument(self, name):
"""Returns the yaml data for a file or from stdin for a single document.
YAML allows multiple documents in a single file by using `---` as a
separator between documents. See https://yaml.org/spec/1.1/#id857577.
However, some YAML-generating tools generate a single document followed by
this separator before ending the file.
This method supports the case of a single document in a file that contains
superfluous document separators, but still throws if multiple documents are
actually found.
Args:
name: str, The file path to the file or "-" to read from stdin.
Returns:
The contents of the file parsed as a YAML data object.
"""
if name == '-':
stdin = console_io.ReadStdin() # Save to potentially reuse below
yaml_data = yaml.load_all(stdin)
else:
yaml_data = yaml.load_all_path(name)
yaml_data = [d for d in yaml_data if d is not None] # Remove empty docs
# Return the single document if only 1 is found.
if len(yaml_data) == 1:
return yaml_data[0]
# Multiple (or 0) documents found. Try to parse again with single-document
# loader so its error is propagated rather than creating our own.
if name == '-':
return yaml.load(stdin)
else:
return yaml.load_path(name)
def __call__(self, name):
"""Load YAML data from file path (name) or stdin.
If name is "-", stdin is read until EOF. Otherwise, the named file is read.
If self.validator is set, call it on the yaml data once it is loaded.
Args:
name: str, The file path to the file.
Returns:
The contents of the file parsed as a YAML data object.
Raises:
ArgumentTypeError: If the file cannot be read or is not a JSON/YAML like
object.
ValueError: If file content fails validation.
"""
try:
yaml_data = self._LoadSingleYamlDocument(name)
self._AssertJsonLike(yaml_data)
if self.validator:
if not self.validator(yaml_data):
raise ValueError('Invalid YAML/JSON content [{}]'.format(yaml_data))
return yaml_data
except (yaml.YAMLParseError, yaml.FileLoadError) as e:
raise ArgumentTypeError(e)
class StoreTrueFalseAction(argparse._StoreTrueAction): # pylint: disable=protected-access
"""Argparse action that acts as a combination of store_true and store_false.
Calliope already gives any bool-type arguments the standard and `--no-`
variants. In most cases we only want to document the option that does
something---if we have `default=False`, we don't want to show `--no-foo`,
since it won't do anything.
But in some cases we *do* want to show both variants: one example is when
`--foo` means "enable," `--no-foo` means "disable," and neither means "do
nothing." The obvious way to represent this is `default=None`; however, (1)
the default value of `default` is already None, so most boolean actions would
have this setting by default (not what we want), and (2) we still want an
option to have this True/False/None behavior *without* the flag documentation.
To get around this, we have an opt-in version of the same thing that documents
both the flag and its inverse.
"""
def __init__(self, *args, **kwargs):
super(StoreTrueFalseAction, self).__init__(*args, default=None, **kwargs)
def StoreFilePathAndContentsAction(binary=False):
"""Returns Action that stores both file content and file path.
Args:
binary: boolean, whether or not this is a binary file.
Returns:
An argparse action.
"""
class Action(argparse.Action):
"""Stores both file content and file path.
Stores file contents under original flag DEST and stores file path under
DEST_path.
"""
def __init__(self, *args, **kwargs):
super(Action, self).__init__(*args, **kwargs)
def __call__(self, parser, namespace, value, option_string=None):
"""Stores the contents of the file and the file name in namespace."""
try:
content = console_io.ReadFromFileOrStdin(value, binary=binary)
except files.Error as e:
raise ArgumentTypeError(e)
setattr(namespace, self.dest, content)
new_dest = '{}_path'.format(self.dest)
setattr(namespace, new_dest, value)
return Action
|
[
"saranraju90@gmail.com"
] |
saranraju90@gmail.com
|
504975487133379c5ad90d41e592ecc7584e58ac
|
f69af7fb96d29edc5d7bd7424acfa9078ba5047d
|
/models/networks.py
|
95fbfab2f1a59fdeb3945ea0396ea30a6b8e80dc
|
[
"MIT",
"BSD-3-Clause",
"BSD-2-Clause"
] |
permissive
|
TrendingTechnology/PeeledHuman
|
ece77dcf3eef81990be720fd4a8e72db2cb5f6d9
|
ab7bff2c03b22774ecea4bc4ec3ae214da654dd5
|
refs/heads/master
| 2023-05-08T09:53:23.413879
| 2021-05-21T12:22:20
| 2021-05-21T12:22:20
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 23,561
|
py
|
import torch
import torch.nn as nn
from torch.nn import init
import functools
import copy
from torch.optim import lr_scheduler
###############################################################################
# Helper Functions
###############################################################################
class Identity(nn.Module):
def forward(self, x):
return x
def get_norm_layer(norm_type='instance'):
"""Return a normalization layer
Parameters:
norm_type (str) -- the name of the normalization layer: batch | instance | none
For BatchNorm, we use learnable affine parameters and track running statistics (mean/stddev).
For InstanceNorm, we do not use learnable affine parameters. We do not track running statistics.
"""
if norm_type == 'batch':
norm_layer = functools.partial(nn.BatchNorm2d, affine=True, track_running_stats=True)
elif norm_type == 'instance':
norm_layer = functools.partial(nn.InstanceNorm2d, affine=False, track_running_stats=False)
elif norm_type == 'none':
norm_layer = lambda x: Identity()
else:
raise NotImplementedError('normalization layer [%s] is not found' % norm_type)
return norm_layer
def get_scheduler(optimizer, opt):
"""Return a learning rate scheduler
Parameters:
optimizer -- the optimizer of the network
opt (option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions．
opt.lr_policy is the name of learning rate policy: linear | step | plateau | cosine
For 'linear', we keep the same learning rate for the first <opt.niter> epochs
and linearly decay the rate to zero over the next <opt.niter_decay> epochs.
For other schedulers (step, plateau, and cosine), we use the default PyTorch schedulers.
See https://pytorch.org/docs/stable/optim.html for more details.
"""
if opt.lr_policy == 'linear':
def lambda_rule(epoch):
lr_l = 1.0 - max(0, epoch + opt.epoch_count - opt.niter) / float(opt.niter_decay + 1)
return lr_l
scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_rule)
elif opt.lr_policy == 'step':
scheduler = lr_scheduler.StepLR(optimizer, step_size=opt.lr_decay_iters, gamma=0.1)
elif opt.lr_policy == 'plateau':
scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.2, threshold=0.01, patience=5)
elif opt.lr_policy == 'cosine':
scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=opt.niter, eta_min=0)
else:
return NotImplementedError('learning rate policy [%s] is not implemented', opt.lr_policy)
return scheduler
def init_weights(net, init_type='normal', init_gain=0.02):
"""Initialize network weights.
Parameters:
net (network) -- network to be initialized
init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal
init_gain (float) -- scaling factor for normal, xavier and orthogonal.
We use 'normal' in the original pix2pix and CycleGAN paper. But xavier and kaiming might
work better for some applications. Feel free to try yourself.
"""
def init_func(m): # define the initialization function
classname = m.__class__.__name__
if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1):
if init_type == 'normal':
init.normal_(m.weight.data, 0.0, init_gain)
elif init_type == 'xavier':
init.xavier_normal_(m.weight.data, gain=init_gain)
elif init_type == 'kaiming':
init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')
elif init_type == 'orthogonal':
init.orthogonal_(m.weight.data, gain=init_gain)
else:
raise NotImplementedError('initialization method [%s] is not implemented' % init_type)
if hasattr(m, 'bias') and m.bias is not None:
init.constant_(m.bias.data, 0.0)
elif classname.find('BatchNorm2d') != -1: # BatchNorm Layer's weight is not a matrix; only normal distribution applies.
init.normal_(m.weight.data, 1.0, init_gain)
init.constant_(m.bias.data, 0.0)
print('initialize network with %s' % init_type)
net.apply(init_func) # apply the initialization function <init_func>
def init_net(net, init_type='normal', init_gain=0.02, gpu_ids=[]):
"""Initialize a network: 1. register CPU/GPU device (with multi-GPU support); 2. initialize the network weights
Parameters:
net (network) -- the network to be initialized
init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal
gain (float) -- scaling factor for normal, xavier and orthogonal.
gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2
Return an initialized network.
"""
if len(gpu_ids) > 0:
assert(torch.cuda.is_available())
net.to(gpu_ids[0])
net = torch.nn.DataParallel(net, gpu_ids) # multi-GPUs
net = convert_model(net)
net.cuda()
init_weights(net, init_type, init_gain=init_gain)
return net
def define_G(input_nc, output_nc, ngf, netG, norm='batch', use_dropout=False, init_type='normal', init_gain=0.02, gpu_ids=[]):
"""Create a generator
Parameters:
input_nc (int) -- the number of channels in input images
output_nc (int) -- the number of channels in output images
ngf (int) -- the number of filters in the last conv layer
netG (str) -- the architecture's name: resnet_9blocks | resnet_6blocks | resnet_18blocks
norm (str) -- the name of normalization layers used in the network: batch | instance | none
use_dropout (bool) -- if use dropout layers.
init_type (str) -- the name of our initialization method.
init_gain (float) -- scaling factor for normal, xavier and orthogonal.
gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2
Returns a generator
The generator has been initialized by <init_net>. It uses RELU for non-linearity.
"""
net = None
norm_layer = get_norm_layer(norm_type=norm)
if netG == 'resnet_9blocks':
net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, n_blocks=9)
elif netG == 'resnet_6blocks':
net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, n_blocks=6)
elif netG == 'resnet_18blocks':
net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, n_blocks=18)
else:
raise NotImplementedError('Generator model name [%s] is not recognized' % netG)
return init_net(net, init_type, init_gain, gpu_ids)
def define_D(input_nc, ndf, netD, n_layers_D=3, norm='batch', init_type='normal', init_gain=0.02, gpu_ids=[]):
"""Create a discriminator
Parameters:
input_nc (int) -- the number of channels in input images
ndf (int) -- the number of filters in the first conv layer
netD (str) -- the architecture's name: basic | n_layers | pixel
n_layers_D (int) -- the number of conv layers in the discriminator; effective when netD=='n_layers'
norm (str) -- the type of normalization layers used in the network.
init_type (str) -- the name of the initialization method.
init_gain (float) -- scaling factor for normal, xavier and orthogonal.
gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2
Returns a discriminator
Our current implementation provides three types of discriminators:
[basic]: 'PatchGAN' classifier described in the original pix2pix paper.
It can classify whether 70x70 overlapping patches are real or fake.
Such a patch-level discriminator architecture has fewer parameters
than a full-image discriminator and can work on arbitrarily-sized images
in a fully convolutional fashion.
[n_layers]: With this mode, you cna specify the number of conv layers in the discriminator
with the parameter <n_layers_D> (default=3 as used in [basic] (PatchGAN).)
[pixel]: 1x1 PixelGAN discriminator can classify whether a pixel is real or not.
It encourages greater color diversity but has no effect on spatial statistics.
The discriminator has been initialized by <init_net>. It uses Leakly RELU for non-linearity.
"""
net = None
norm_layer = get_norm_layer(norm_type=norm)
if netD == 'basic': # default PatchGAN classifier
net = NLayerDiscriminator(input_nc, ndf, n_layers=3, norm_layer=norm_layer)
elif netD == 'n_layers': # more options
net = NLayerDiscriminator(input_nc, ndf, n_layers_D, norm_layer=norm_layer)
elif netD == 'pixel': # classify if each pixel is real or fake
net = PixelDiscriminator(input_nc, ndf, norm_layer=norm_layer)
else:
raise NotImplementedError('Discriminator model name [%s] is not recognized' % netD)
return init_net(net, init_type, init_gain, gpu_ids)
##############################################################################
# Classes
##############################################################################
class GANLoss(nn.Module):
"""Define different GAN objectives.
The GANLoss class abstracts away the need to create the target label tensor
that has the same size as the input.
"""
def __init__(self, gan_mode, target_real_label=1.0, target_fake_label=0.0):
""" Initialize the GANLoss class.
Parameters:
gan_mode (str) - - the type of GAN objective. It currently supports vanilla, lsgan, and wgangp.
target_real_label (bool) - - label for a real image
target_fake_label (bool) - - label of a fake image
Note: Do not use sigmoid as the last layer of Discriminator.
LSGAN needs no sigmoid. vanilla GANs will handle it with BCEWithLogitsLoss.
"""
super(GANLoss, self).__init__()
self.register_buffer('real_label', torch.tensor(target_real_label))
self.register_buffer('fake_label', torch.tensor(target_fake_label))
self.gan_mode = gan_mode
if gan_mode == 'lsgan':
self.loss = nn.MSELoss()
elif gan_mode == 'vanilla':
self.loss = nn.BCEWithLogitsLoss()
elif gan_mode in ['wgangp']:
self.loss = None
else:
raise NotImplementedError('gan mode %s not implemented' % gan_mode)
def get_target_tensor(self, prediction, target_is_real):
"""Create label tensors with the same size as the input.
Parameters:
prediction (tensor) - - tpyically the prediction from a discriminator
target_is_real (bool) - - if the ground truth label is for real images or fake images
Returns:
A label tensor filled with ground truth label, and with the size of the input
"""
if target_is_real:
target_tensor = self.real_label
else:
target_tensor = self.fake_label
return target_tensor.expand_as(prediction)
def __call__(self, prediction, target_is_real):
"""Calculate loss given Discriminator's output and grount truth labels.
Parameters:
prediction (tensor) - - tpyically the prediction output from a discriminator
target_is_real (bool) - - if the ground truth label is for real images or fake images
Returns:
the calculated loss.
"""
if self.gan_mode in ['lsgan', 'vanilla']:
target_tensor = self.get_target_tensor(prediction, target_is_real)
loss = self.loss(prediction, target_tensor)
elif self.gan_mode == 'wgangp':
if target_is_real:
loss = -prediction.mean()
else:
loss = prediction.mean()
return loss
def cal_gradient_penalty(netD, real_data, fake_data, device, type='mixed', constant=1.0, lambda_gp=10.0):
"""Calculate the gradient penalty loss, used in WGAN-GP paper https://arxiv.org/abs/1704.00028
Arguments:
netD (network) -- discriminator network
real_data (tensor array) -- real images
fake_data (tensor array) -- generated images from the generator
device (str) -- GPU / CPU: from torch.device('cuda:{}'.format(self.gpu_ids[0])) if self.gpu_ids else torch.device('cpu')
type (str) -- if we mix real and fake data or not [real | fake | mixed].
constant (float) -- the constant used in formula ( | |gradient||_2 - constant)^2
lambda_gp (float) -- weight for this loss
Returns the gradient penalty loss
"""
if lambda_gp > 0.0:
if type == 'real': # either use real images, fake images, or a linear interpolation of two.
interpolatesv = real_data
elif type == 'fake':
interpolatesv = fake_data
elif type == 'mixed':
alpha = torch.rand(real_data.shape[0], 1, device=device)
alpha = alpha.expand(real_data.shape[0], real_data.nelement() // real_data.shape[0]).contiguous().view(*real_data.shape)
interpolatesv = alpha * real_data + ((1 - alpha) * fake_data)
else:
raise NotImplementedError('{} not implemented'.format(type))
interpolatesv.requires_grad_(True)
disc_interpolates = netD(interpolatesv)
gradients = torch.autograd.grad(outputs=disc_interpolates, inputs=interpolatesv,
grad_outputs=torch.ones(disc_interpolates.size()).to(device),
create_graph=True, retain_graph=True, only_inputs=True)
gradients = gradients[0].view(real_data.size(0), -1) # flat the data
gradient_penalty = (((gradients + 1e-16).norm(2, dim=1) - constant) ** 2).mean() * lambda_gp # added eps
return gradient_penalty, gradients
else:
return 0.0, None
class ResnetGenerator(nn.Module):
"""Resnet-based generator that consists of Resnet blocks between a few downsampling/upsampling operations.
We adapt Torch code and idea from Justin Johnson's neural style transfer project(https://github.com/jcjohnson/fast-neural-style)
"""
def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, padding_type='reflect'):
"""Construct a Resnet-based generator
Parameters:
input_nc (int) -- the number of channels in input images
output_nc (int) -- the number of channels in output images
ngf (int) -- the number of filters in the last conv layer
norm_layer -- normalization layer
use_dropout (bool) -- if use dropout layers
n_blocks (int) -- the number of ResNet blocks
padding_type (str) -- the name of padding layer in conv layers: reflect | replicate | zero
"""
assert(n_blocks >= 0)
super(ResnetGenerator, self).__init__()
if type(norm_layer) == functools.partial:
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
model = [nn.ReflectionPad2d(3),
nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias),
norm_layer(ngf),
nn.ReLU(True)]
n_downsampling = 2
for i in range(n_downsampling): # add downsampling layers
mult = 2 ** i
model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias),
norm_layer(ngf * mult * 2),
nn.ReLU(True)]
mult = 2 ** n_downsampling
for i in range(n_blocks): # add ResNet blocks
model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)]
model_depth = []
model_rgb = []
for i in range(n_downsampling): # add upsampling layers
mult = 2 ** (n_downsampling - i)
model_depth += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),
kernel_size=3, stride=2,
padding=1, output_padding=1,
bias=use_bias),
norm_layer(int(ngf * mult / 2)),
nn.ReLU(True)]
model_rgb += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),
kernel_size=3, stride=2,
padding=1, output_padding=1,
bias=use_bias),
norm_layer(int(ngf * mult / 2)),
nn.ReLU(True)]
model_depth += [nn.ReflectionPad2d(3)]
model_depth += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]
model_depth += [nn.Sigmoid()]
model_rgb += [nn.ReflectionPad2d(3)]
model_rgb += [nn.Conv2d(ngf, 3*(output_nc-1), kernel_size=7, padding=0)]
# model_rgb += [nn.Conv2d(ngf, 3*output_nc, kernel_size=7, padding=0)]
model_rgb += [nn.Tanh()]
self.model = nn.Sequential(*model)
self.model_depth = nn.Sequential(*model_depth)
self.model_rgb = nn.Sequential(*model_rgb)
def forward(self, input):
"""Standard forward"""
downsample = self.model(input)
return self.model_rgb(downsample), self.model_depth(downsample)
class ResnetBlock(nn.Module):
"""Define a Resnet block"""
def __init__(self, dim, padding_type, norm_layer, use_dropout, use_bias):
"""Initialize the Resnet block
A resnet block is a conv block with skip connections
We construct a conv block with build_conv_block function,
and implement skip connections in <forward> function.
Original Resnet paper: https://arxiv.org/pdf/1512.03385.pdf
"""
super(ResnetBlock, self).__init__()
self.conv_block = self.build_conv_block(dim, padding_type, norm_layer, use_dropout, use_bias)
def build_conv_block(self, dim, padding_type, norm_layer, use_dropout, use_bias):
"""Construct a convolutional block.
Parameters:
dim (int) -- the number of channels in the conv layer.
padding_type (str) -- the name of padding layer: reflect | replicate | zero
norm_layer -- normalization layer
use_dropout (bool) -- if use dropout layers.
use_bias (bool) -- if the conv layer uses bias or not
Returns a conv block (with a conv layer, a normalization layer, and a non-linearity layer (ReLU))
"""
conv_block = []
p = 0
if padding_type == 'reflect':
conv_block += [nn.ReflectionPad2d(1)]
elif padding_type == 'replicate':
conv_block += [nn.ReplicationPad2d(1)]
elif padding_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' % padding_type)
conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias), norm_layer(dim), nn.ReLU(True)]
if use_dropout:
conv_block += [nn.Dropout(0.5)]
p = 0
if padding_type == 'reflect':
conv_block += [nn.ReflectionPad2d(1)]
elif padding_type == 'replicate':
conv_block += [nn.ReplicationPad2d(1)]
elif padding_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' % padding_type)
conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias), norm_layer(dim)]
return nn.Sequential(*conv_block)
def forward(self, x):
"""Forward function (with skip connections)"""
out = x + self.conv_block(x) # add skip connections
return out
class NLayerDiscriminator(nn.Module):
"""Defines a PatchGAN discriminator"""
def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d):
"""Construct a PatchGAN discriminator
Parameters:
input_nc (int) -- the number of channels in input images
ndf (int) -- the number of filters in the last conv layer
n_layers (int) -- the number of conv layers in the discriminator
norm_layer -- normalization layer
"""
super(NLayerDiscriminator, self).__init__()
if type(norm_layer) == functools.partial: # no need to use bias as BatchNorm2d has affine parameters
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
kw = 4
padw = 1
sequence = [nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw), nn.LeakyReLU(0.2, True)]
nf_mult = 1
nf_mult_prev = 1
for n in range(1, n_layers): # gradually increase the number of filters
nf_mult_prev = nf_mult
nf_mult = min(2 ** n, 8)
sequence += [
nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=2, padding=padw, bias=use_bias),
norm_layer(ndf * nf_mult),
nn.LeakyReLU(0.2, True)
]
nf_mult_prev = nf_mult
nf_mult = min(2 ** n_layers, 8)
sequence += [
nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=1, padding=padw, bias=use_bias),
norm_layer(ndf * nf_mult),
nn.LeakyReLU(0.2, True)
]
sequence += [nn.Conv2d(ndf * nf_mult, 1, kernel_size=kw, stride=1, padding=padw)] # output 1 channel prediction map
self.model = nn.Sequential(*sequence)
def forward(self, input):
"""Standard forward."""
return self.model(input)
class PixelDiscriminator(nn.Module):
"""Defines a 1x1 PatchGAN discriminator (pixelGAN)"""
def __init__(self, input_nc, ndf=64, norm_layer=nn.BatchNorm2d):
"""Construct a 1x1 PatchGAN discriminator
Parameters:
input_nc (int) -- the number of channels in input images
ndf (int) -- the number of filters in the last conv layer
norm_layer -- normalization layer
"""
super(PixelDiscriminator, self).__init__()
if type(norm_layer) == functools.partial: # no need to use bias as BatchNorm2d has affine parameters
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
self.net = [
nn.Conv2d(input_nc, ndf, kernel_size=1, stride=1, padding=0),
nn.LeakyReLU(0.2, True),
nn.Conv2d(ndf, ndf * 2, kernel_size=1, stride=1, padding=0, bias=use_bias),
norm_layer(ndf * 2),
nn.LeakyReLU(0.2, True),
nn.Conv2d(ndf * 2, 1, kernel_size=1, stride=1, padding=0, bias=use_bias)]
self.net = nn.Sequential(*self.net)
def forward(self, input):
"""Standard forward."""
return self.net(input)
|
[
"rohanchacko007@gmail.com"
] |
rohanchacko007@gmail.com
|
56b0c048589ed3ef8f13303160de9e5ae6e672df
|
9701287f1cc7734d31c898708581b15a41916e36
|
/backend/app/crud/inventory.py
|
5dc66359f2914fdfc5f4b7ef88503d0e6e4b1ba9
|
[] |
no_license
|
cedric0306/fastERP
|
a40c6d3bd3f07f65d2d8c1a440d8930f20bf4aee
|
d87824e945b01bc1969c9e2fdea3f243f6240a2f
|
refs/heads/main
| 2023-07-27T07:44:58.711211
| 2021-08-27T15:14:08
| 2021-08-27T15:14:08
| 564,331,443
| 1
| 0
| null | 2022-11-10T13:44:17
| 2022-11-10T13:44:16
| null |
UTF-8
|
Python
| false
| false
| 1,833
|
py
|
from sqlalchemy.orm import Session
from fastapi import Depends
from ..models import Inventory as InventoryModel, User
from ..schemas.inventory import InventoryCreate, InventoryDelete, InventoryUpdate
from ..dependencies import get_current_user
# CASH
def get_inventory(db: Session, inventory_id: int):
return db.query(InventoryModel).filter(InventoryModel.id == inventory_id).first()
def get_inventoryes(db: Session, skip: int = 0, limit: int = 100):
return db.query(InventoryModel).offset(skip).limit(limit).all()
def create_inventory(db: Session, inventory: InventoryCreate, current_user: User):
db_inventory = InventoryModel(date=inventory.date,
description=inventory.description,
created_on=inventory.created_on,
user_id=current_user.id,
status=inventory.status)
db.add(db_inventory)
db.commit()
return db_inventory
def update_inventory(db: Session, inventory: InventoryUpdate, current_user: User):
inventory_data = db.query(InventoryModel).filter(
InventoryModel.id == inventory.id).first()
inventory_data.date = inventory.date
inventory_data.description = inventory.description
inventory_data.user_id = current_user.id,
inventory_data.status = inventory.status
db.commit()
db.refresh(inventory_data)
return inventory_data
def delete_inventory(db: Session, inventory: InventoryDelete):
inventory_data = db.query(InventoryModel).filter(
InventoryModel.id == inventory.id).first()
if inventory_data is None:
return None
else:
db.delete(inventory_data)
db.commit()
return inventory_data
|
[
"wasuaje@shorecg.com"
] |
wasuaje@shorecg.com
|
7dbe960a1c9a8e1e356ad75deab3f1df4abc7aac
|
4a0c3f5f697ab694067f5fc59486707440593856
|
/python/20_Slots.py
|
b95795f1ef5714b1713849c16c00279e4745897a
|
[] |
no_license
|
shweb360/Python
|
4cfe5e1e12d0bad02217ccd1bded7815a1c192e9
|
dd589674ed22ebd835efb21954ed0a96430002f8
|
refs/heads/master
| 2021-06-24T17:04:22.378895
| 2019-12-01T06:06:51
| 2019-12-01T06:06:51
| 102,442,763
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 744
|
py
|
#1.1创建一个类：
class Student(object):
pass
#1.2给实例绑定一个属性：
s=Student()
s.name="Wushuang"
print(s.name);
#1.3给实例绑定一个方法
def set_age(self,age):
self.age=age
from types import MethodType
#给实例绑定一个方法
s.set_age=MethodType(set_age,s)
#调用实例方法
s.set_age(25)
print(s.age)
#2.0使用__slots_
#但是，如果我们想要限制实例的属性怎么办？
#比如，只允许对Student实例添加name和age属性。
#为了达到限制的目的，Python允许在定义class的时候，
#定义一个特殊的__slots__变量，来限制该class实例能添加的属性：
class Student2(object):
__slots__=('name','age')
s2=Student2()
s2.name="Michael"
s2.age=24
print(s2)
|
[
"785132826@qq.com"
] |
785132826@qq.com
|
d556f5c5b3363e7fc2bbc713413256455f6f53d3
|
7b6e3c5e6b963c749da9f946275661ae0e67dbd2
|
/src/model/test/yolo_v2_test.py
|
f12f453a1da9ecff535acc2209d498da9c687322
|
[] |
no_license
|
WeiZongqi/yolo-tensorflow
|
c8237295b41beb61943207d8511c80a0f33507f2
|
53eaa2ad779918ced2ded2834e09abf2e0ed7202
|
refs/heads/master
| 2021-01-25T14:26:58.371334
| 2017-12-28T08:18:59
| 2017-12-28T08:18:59
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 11,688
|
py
|
# -*- coding: utf8 -*-
# author: ronniecao
from __future__ import print_function
import sys
import os
import time
import numpy
import matplotlib.pyplot as plt
import tensorflow as tf
from src.data.image import ImageProcessor
from src.model.yolo_v2 import TinyYolo
class TinyYoloTestor:
def test_calculate_loss(self):
self.batch_size = 1
self.cell_size = 2
self.n_boxes = 2
self.max_objects = 3
self.n_classes = 5
coord_pred = numpy.zeros((1, 2, 2, 2, 4))
coord_pred[0,0,0,0,:] = [0.4, 0.4, 0.1, 0.1]
coord_pred[0,0,0,1,:] = [0.1, 0.1, 0.1, 0.1]
coord_pred[0,0,1,0,:] = [0.75, 0.25, 0.1, 0.1]
coord_pred[0,0,1,1,:] = [0.7, 0.2, 0.1, 0.1]
coord_pred[0,1,0,0,:] = [0.3, 0.8, 0.1, 0.1]
coord_pred[0,1,0,1,:] = [0.25, 0.75, 0.1, 0.1]
coord_pred[0,1,1,0,:] = [0.75, 0.75, 0.1, 0.1]
coord_pred[0,1,1,1,:] = [0.7, 0.8, 0.1, 0.1]
conf_pred = numpy.zeros((1, 2, 2, 2, 1))
conf_pred[0,0,0,0,0] = 1.0
conf_pred[0,0,0,1,0] = 1.0
conf_pred[0,0,1,0,0] = 1.0
conf_pred[0,0,1,1,0] = 0.2
conf_pred[0,1,0,0,0] = 0.1
conf_pred[0,1,0,1,0] = 0.9
conf_pred[0,1,1,0,0] = 1.0
class_pred = numpy.zeros((1, 2, 2, 2, 5))
class_pred[0,0,0,0,0] = 0.9
class_pred[0,0,0,0,1] = 0.1
class_pred[0,0,0,1,1] = 1.0
class_pred[0,0,1,0,4] = 0.8
class_pred[0,0,1,0,3] = 0.1
class_pred[0,0,1,0,2] = 0.1
class_pred[0,1,0,1,2] = 1.0
class_pred[0,1,1,0,3] = 0.8
class_pred[0,1,1,0,0] = 0.05
class_pred[0,1,1,0,1] = 0.05
class_pred[0,1,1,0,2] = 0.05
class_pred[0,1,1,0,4] = 0.05
coord_true = numpy.zeros((1, 2, 2, 3, 4))
coord_true[0,0,0,0,:] = [0.1, 0.1, 0.1, 0.1]
coord_true[0,0,0,1,:] = [0.4, 0.4, 0.1, 0.1]
coord_true[0,0,1,0,:] = [0.75, 0.25, 0.1, 0.1]
coord_true[0,1,0,0,:] = [0.25, 0.75, 0.1, 0.1]
coord_true[0,1,1,0,:] = [0.75, 0.75, 0.1, 0.1]
class_true = numpy.zeros((1, 2, 2, 3, 5))
class_true[0,0,0,0,1] = 1.0
class_true[0,0,0,1,0] = 1.0
class_true[0,0,1,0,4] = 1.0
class_true[0,1,0,0,2] = 1.0
class_true[0,1,1,0,3] = 1.0
object_mask = numpy.zeros((1, 2, 2, 3))
object_mask[0,0,0,0] = 1
object_mask[0,0,0,1] = 1
object_mask[0,0,1,0] = 1
object_mask[0,1,0,0] = 1
object_mask[0,1,1,0] = 1
coord_true_tf = tf.placeholder(
dtype=tf.float32, shape=[1, 2, 2, 3, 4], name='coord_true_tf')
coord_pred_tf = tf.placeholder(
dtype=tf.float32, shape=[1, 2, 2, 2, 4], name='coord_pred_tf')
conf_pred_tf = tf.placeholder(
dtype=tf.float32, shape=[1, 2, 2, 2, 1], name='conf_pred_tf')
class_true_tf = tf.placeholder(
dtype=tf.float32, shape=[1, 2, 2, 3, 5], name='class_true_tf')
class_pred_tf = tf.placeholder(
dtype=tf.float32, shape=[1, 2, 2, 2, 5], name='class_pred_tf')
object_mask_tf = tf.placeholder(
dtype=tf.float32, shape=[1, 2, 2, 3], name='object_mask_tf')
coord_pred_iter = tf.tile(
tf.reshape(coord_pred_tf, shape=[
self.batch_size, self.cell_size, self.cell_size, self.n_boxes, 1, 4]),
[1, 1, 1, 1, self.max_objects, 1])
coord_true_iter = tf.reshape(coord_true_tf, shape=[
self.batch_size, self.cell_size, self.cell_size, 1, self.max_objects, 4])
coord_true_iter = tf.tile(coord_true_iter, [1, 1, 1, self.n_boxes, 1, 1])
iou_tensor = self.calculate_iou_tf(coord_pred_iter, coord_true_iter)
iou_tensor_max = tf.reduce_max(iou_tensor, 3, keep_dims=True)
iou_tensor_mask = tf.cast(
(iou_tensor >= iou_tensor_max), dtype=tf.float32) * tf.reshape(
object_mask_tf, shape=(
self.batch_size, self.cell_size, self.cell_size, 1, self.max_objects, 1))
iou_tensor_pred_mask = tf.reduce_sum(iou_tensor_mask, axis=4)
coord_label = tf.reduce_max(iou_tensor_mask * coord_true_iter, axis=4)
coord_loss = tf.nn.l2_loss((coord_pred_tf - coord_label) * iou_tensor_pred_mask) / (
tf.reduce_sum(object_mask_tf, axis=[0,1,2,3]))
iou_value = tf.reduce_sum(
tf.reduce_max(iou_tensor, axis=4) * iou_tensor_pred_mask, axis=[0,1,2,3]) / (
tf.reduce_sum(object_mask_tf, axis=[0,1,2,3]))
conf_label = tf.reduce_max(iou_tensor_mask * tf.ones(shape=(
self.batch_size, self.cell_size, self.cell_size,
self.n_boxes, self.max_objects, 1)), axis=4)
object_loss = tf.nn.l2_loss(
(conf_pred_tf - conf_label) * iou_tensor_pred_mask) / (
tf.reduce_sum(object_mask_tf, axis=[0,1,2,3]))
object_value = tf.reduce_sum(
conf_pred_tf * iou_tensor_pred_mask, axis=[0,1,2,3]) / (
tf.reduce_sum(object_mask_tf, axis=[0,1,2,3]))
inv_iou_tensor_pred_mask = tf.ones(shape=(
self.batch_size, self.cell_size, self.cell_size,
self.n_boxes, 1)) - iou_tensor_pred_mask
noobject_loss = tf.nn.l2_loss(
(conf_pred_tf - conf_label) * inv_iou_tensor_pred_mask) / (
tf.reduce_sum(object_mask_tf, axis=[0,1,2,3]))
noobject_value = tf.reduce_sum(
conf_pred_tf * inv_iou_tensor_pred_mask, axis=[0,1,2,3]) / (
tf.reduce_sum(inv_iou_tensor_pred_mask, axis=[0,1,2,3]))
class_true_iter = tf.reshape(class_true_tf, shape=[
self.batch_size, self.cell_size, self.cell_size, 1, self.max_objects, self.n_classes])
class_true_iter = tf.tile(class_true_iter, [1, 1, 1, self.n_boxes, 1, 1])
class_label = tf.reduce_max(iou_tensor_mask * class_true_iter, axis=4)
class_loss = tf.nn.l2_loss(
(class_pred_tf - class_label) * iou_tensor_pred_mask) / (
tf.reduce_sum(object_mask_tf, axis=[0,1,2,3]))
class_value = tf.reduce_sum(
class_pred_tf * class_label * iou_tensor_pred_mask, axis=[0,1,2,3,4]) / (
tf.reduce_sum(object_mask_tf, axis=[0,1,2,3]))
sess = tf.Session()
[output] = sess.run(
fetches=[class_value],
feed_dict={coord_true_tf: coord_true, coord_pred_tf: coord_pred,
conf_pred_tf: conf_pred,
class_true_tf: class_true, class_pred_tf: class_pred,
object_mask_tf: object_mask})
print(output)
def calculate_iou_tf(self, box_pred, box_true):
box1 = tf.stack([
box_pred[:,:,:,:,:,0] - box_pred[:,:,:,:,:,2] / 2.0,
box_pred[:,:,:,:,:,1] - box_pred[:,:,:,:,:,3] / 2.0,
box_pred[:,:,:,:,:,0] + box_pred[:,:,:,:,:,2] / 2.0,
box_pred[:,:,:,:,:,1] + box_pred[:,:,:,:,:,3] / 2.0])
box1 = tf.transpose(box1, perm=[1, 2, 3, 4, 5, 0])
box2 = tf.stack([
box_true[:,:,:,:,:,0] - box_true[:,:,:,:,:,2] / 2.0,
box_true[:,:,:,:,:,1] - box_true[:,:,:,:,:,3] / 2.0,
box_true[:,:,:,:,:,0] + box_true[:,:,:,:,:,2] / 2.0,
box_true[:,:,:,:,:,1] + box_true[:,:,:,:,:,3] / 2.0])
box2 = tf.transpose(box2, perm=[1, 2, 3, 4, 5, 0])
left_top = tf.maximum(box1[:,:,:,:,:,0:2], box2[:,:,:,:,:,0:2])
right_bottom = tf.minimum(box1[:,:,:,:,:,2:4], box2[:,:,:,:,:,2:4])
intersection = right_bottom - left_top
inter_area = intersection[:,:,:,:,:,0] * intersection[:,:,:,:,:,1]
mask = tf.cast(intersection[:,:,:,:,:,0] > 0, tf.float32) * \
tf.cast(intersection[:,:,:,:,:,1] > 0, tf.float32)
inter_area = inter_area * mask
box1_area = (box1[:,:,:,:,:,2]-box1[:,:,:,:,:,0]) * (box1[:,:,:,:,:,3]-box1[:,:,:,:,:,1])
box2_area = (box2[:,:,:,:,:,2]-box2[:,:,:,:,:,0]) * (box2[:,:,:,:,:,3]-box2[:,:,:,:,:,1])
iou = inter_area / (box1_area + box2_area - inter_area + 1e-6)
return tf.reshape(iou, shape=[
self.batch_size, self.cell_size, self.cell_size, self.n_boxes, self.max_objects, 1])
def test_get_box_pred(self):
label = [[0, 0, 0, 0, 0]] * 5
label[0] = [0.5, 0.15, 0.8, 0.2, 1]
label[1] = [0.5, 0.7, 0.1, 0.2, 1]
label[2] = [0.5, 0.9, 0.6, 0.1, 1]
pred = numpy.zeros(shape=(3,3,6,5))
pred[0,1,4,:] = [-1.6, -1.73, 0.09, -0.09, 1.0]
# pred[1,0,4,:] = [0.0, 0.0, 0.0, 0.0, 1.0]
image_processor = ImageProcessor(
'Z:', image_size=96, max_objects_per_image=5, cell_size=3, n_classes=1)
class_label, class_mask, box_label, object_num = \
image_processor.process_label(label)
tiny_yolo = TinyYolo(
n_channel=3, n_classes=1, image_size=96, max_objects_per_image=5,
box_per_cell=6, object_scala=10, nobject_scala=5,
coord_scala=10, class_scala=1, batch_size=1)
box_pred = tf.placeholder(
dtype=tf.float32, shape=[3, 3, 6, 4], name='box_pred')
box_truth = tf.placeholder(
dtype=tf.float32, shape=[3, 3, 1, 4], name='box_truth')
iou_matrix = tiny_yolo.get_box_pred(box_pred)
sess = tf.Session()
[output] = sess.run(
fetches=[iou_matrix],
feed_dict={box_pred: pred[:,:,:,0:4]})
sess.close()
print(output, output.shape)
# 画图
image = numpy.zeros(shape=(256, 256, 3), dtype='uint8') + 255
cv2.line(image, (0, int(256/3.0)), (256, int(256/3.0)), (100, 149, 237), 1)
cv2.line(image, (0, int(256*2.0/3.0)), (256, int(256*2.0/3.0)), (100, 149, 237), 1)
cv2.line(image, (int(256/3.0), 0), (int(256/3.0), 256), (100, 149, 237), 1)
cv2.line(image, (int(256*2.0/3.0), 0), (int(256*2.0/3.0), 256), (100, 149, 237), 1)
for center_x, center_y, w, h, prob in label:
if prob != 1.0:
continue
# 画中心点
cv2.circle(image, (int(center_x*256), int(center_y*256)), 2, (255, 99, 71), 0)
# 画真实框
xmin = int((center_x - w / 2.0) * 256)
xmax = int((center_x + w / 2.0) * 256)
ymin = int((center_y - h / 2.0) * 256)
ymax = int((center_y + h / 2.0) * 256)
cv2.rectangle(image, (xmin, ymin), (xmax, ymax), (255, 99, 71), 0)
for x in range(3):
for y in range(3):
for n in range(2):
[center_x, center_y, w, h, prob] = pred[x, y, n, :]
# 画中心点
cv2.circle(image, (int(center_x*256), int(center_y*256)), 2, (238, 130, 238), 0)
# 画预测框
xmin = int((center_x - w / 2.0) * 256)
xmax = int((center_x + w / 2.0) * 256)
ymin = int((center_y - h / 2.0) * 256)
ymax = int((center_y + h / 2.0) * 256)
cv2.rectangle(image, (xmin, ymin), (xmax, ymax), (238, 130, 238), 0)
plt.imshow(image)
plt.show()
|
[
"caocao7066@outlook.com"
] |
caocao7066@outlook.com
|
33e88efe4e627f6559fbe2ae3e666d6cd80bb96a
|
25db8b32ecda47a22a8a1ae4551e2378e4d576cf
|
/rest/serializers.py
|
48d3eeebe7c5ac11184608c3cbe7c1f91bd0730c
|
[] |
no_license
|
viperfx/ng-forum
|
4754ca69d699ad466e836b28bda68d9d84e0cd34
|
5a55692122b91876104c209a73bab05f7318c3ff
|
refs/heads/master
| 2021-01-01T19:42:18.879573
| 2013-11-08T15:27:32
| 2013-11-08T15:27:32
| 13,254,263
| 4
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 902
|
py
|
from django.contrib.auth.models import User, Group
from rest_framework import serializers
from rest.models import Forum, Thread, Post
class UserSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = User
fields = ('url', 'username', 'email', 'groups')
class GroupSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = Group
fields = ('url', 'name')
class ForumSerializer(serializers.ModelSerializer):
class Meta:
model = Forum
depth=1
fields = ('id','title', 'threads',)
class ThreadSerializer(serializers.ModelSerializer):
class Meta:
model = Thread
depth=2
fields = ('id','title', 'forum', 'body', 'creator','created', 'posts')
class PostSerializer(serializers.ModelSerializer):
class Meta:
model = Post
fields = ('thread', 'body', 'creator')
|
[
"tharshan09@gmail.com"
] |
tharshan09@gmail.com
|
282cc009f6f0e3ea9db0caeb7c910203e582bc4d
|
13df9ce30c3b6999f38ccf46ea9a85f3fa9f44a9
|
/reports/forms.py
|
75e02c96731b1abb0eb6f31b575fa2e133c1e6a8
|
[] |
no_license
|
PavelM87/tf_idf_app
|
37b5598f7f46af308f24733a145b8308610a0797
|
6b36e516b2daefd89b52765f1244857d16a4efcd
|
refs/heads/master
| 2023-07-26T16:03:33.165133
| 2021-09-13T16:04:20
| 2021-09-13T16:04:20
| 405,765,698
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 146
|
py
|
from django import forms
from .models import File
class FileForm(forms.ModelForm):
class Meta:
model = File
fields = 'file',
|
[
"mospv87@gmail.com"
] |
mospv87@gmail.com
|
88c38efa8ff0a8056b6fc309011e034888426fa0
|
26acc7e23024098661a42da37e2cb4ed56c21b44
|
/dgp/genera/load/loader.py
|
daf5ca8acee012f9dd328fd48ef0fb2baf85a38a
|
[
"MIT"
] |
permissive
|
dataspot/dgp
|
80536c0e296570c109511de3dae6e0297bb8b0fd
|
e86d604c8af5534985f9b788ba809facbc325152
|
refs/heads/master
| 2023-03-16T05:15:38.362702
| 2023-03-09T07:07:28
| 2023-03-09T07:07:28
| 169,378,970
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,879
|
py
|
import os
import json
import requests
from hashlib import md5
from dataflows import Flow, load, dump_to_path
from dataflows.base.schema_validator import ignore
from ...core import BaseDataGenusProcessor, Required, Validator, ConfigurableDGP
from .analyzers import FileFormatDGP, StructureDGP
from ...config.consts import CONFIG_URL, CONFIG_PUBLISH_ALLOWED, RESOURCE_NAME
from ...config.log import logger
class LoaderDGP(BaseDataGenusProcessor):
PRE_CHECKS = Validator(
Required(CONFIG_URL, 'Source data URL or path')
)
def init(self):
self.steps = self.init_classes([
FileFormatDGP,
StructureDGP,
])
def hash_key(self, *args):
data = json.dumps(args, sort_keys=True, ensure_ascii=False)
return md5(data.encode('utf8')).hexdigest()
def flow(self):
if len(self.errors) == 0:
config = self.config._unflatten()
source = config['source']
ref_hash = self.hash_key(source, config['structure'], config.get('publish'))
cache_path = os.path.join('.cache', ref_hash)
datapackage_path = os.path.join(cache_path, 'datapackage.json')
structure_params = self.context._structure_params()
http_session = self.context.http_session()
loader = load(source.pop('path'), validate=False,
name=RESOURCE_NAME,
**source, **structure_params,
http_session=http_session,
http_timeout=120,
infer_strategy=load.INFER_PYTHON_TYPES,
cast_strategy=load.CAST_DO_NOTHING,
limit_rows=(
None
if self.config.get(CONFIG_PUBLISH_ALLOWED)
else 5000
))
if self.config.get(CONFIG_PUBLISH_ALLOWED):
return Flow(
loader,
)
else:
if not os.path.exists(datapackage_path):
logger.info('Caching source data into %s', cache_path)
Flow(
loader,
dump_to_path(cache_path, validator_options=dict(on_error=ignore)),
# printer(),
).process()
logger.info('Using cached source data from %s', cache_path)
return Flow(
load(datapackage_path, resources=RESOURCE_NAME),
)
class PostLoaderDGP(ConfigurableDGP):
def init(self):
super().init('loading', per_taxonomy=False)
self._flows = None
class PreLoaderDGP(ConfigurableDGP):
def init(self):
super().init('preloading', per_taxonomy=False)
self._flows = None
|
[
"adam.kariv@gmail.com"
] |
adam.kariv@gmail.com
|
26435cad8b4f6e3701b33caaa53babbe68372fcd
|
122db49900adae3d25bf6a17db54699086593f94
|
/klimplot_fetch.py
|
7bbb62ddb847248ee839f7ceb18b007e5ac29816
|
[] |
no_license
|
geoenvo/klimplot
|
77a63296ad85b5e1e2a2fa391ab3904d289860ea
|
0c70b350c5dca155211f2e4089b7765f34ef7101
|
refs/heads/master
| 2021-01-10T11:19:06.675854
| 2016-02-16T03:41:42
| 2016-02-16T03:41:42
| 51,801,455
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,725
|
py
|
# Klimplot
# Fetch Script
# (c) 2015 Mohammad Fadli
# Geo Enviro Omega, PT
# KlimPlot digunakan untuk memvisualisasikan dan mempublikasikan data Iklim menjadi bentuk Map Services.
# Script ini digunakan untuk me
#HOWTO
# Jalankan di background: python klimplot.py &
# Taruh di cron, atau jalankan sebagai services berkala
# Struktur folder hasil akan menyesuaikan
import os.path
import wget
import subprocess
#define variable
#Sumber Data (Server PIKAM via http)
spath="http://202.90.199.147/ec_prob/results_mat/"
#sfolder="2015.01.01/"
#sfile="control.2015.02_ver_2015.01.01.csv"
#surl=spath+sfolder+sfile
#cpath=os.getcwd()+"/"
#nama folder direktori
datadir="data/"
#path di mana folder data yg difetch akan di simpan
datapath="/home/klimplot/"+datadir
#datapath=cpath+datadir
#filepath=datapath+sfile
#Check Folder data
if not os.path.exists(datapath):
os.makedirs(datapath)
else:
print "\n Directory already exist."
"""
#Check File
if not os.path.exists(filepath):
#Get File
wget.download(surl,datapath)
else:
print "\n File already exist. Download Aborted."
"""
subprocess.call("wget -r -np -nc --cut-dirs=2 -A '*.csv' --ignore-case -nH -P "+datapath+" "+spath, shell=True)
"""
-r recursive download folder
-np no parents directory, tidak mendownload isi dari parent directory
-nH would download all files to the directory d in the current directory
-P you will save to specific directory
-nc, --no-clobber: skip downloads that would download to existing files.
--cut-dirs tidak melihat struktur direktori yang ada di sub folder sebelumnya.
-A '*.csv' hanya download csv file
"""
print "\n Alhamdulillah."
|
[
"mf4dl1@gmail.com"
] |
mf4dl1@gmail.com
|
205d88ba56174f27a86af32366448306598b91ae
|
5839955687eefea132172ef47f76963ff219e6ef
|
/DeviceManagement/migrations/0001_initial.py
|
086039bc932336985973f00381bd8ab71fb43522
|
[] |
no_license
|
echo6120/DeviceManagement
|
2724bc3d849a898f2d17e290194dfca39c737a88
|
7b67f8d567620b102914e38f7f41bf23f2adbfda
|
refs/heads/master
| 2020-12-22T20:30:04.790143
| 2020-01-29T07:17:22
| 2020-01-29T07:17:22
| 236,923,453
| 2
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 559
|
py
|
# Generated by Django 2.0 on 2020-01-26 09:14
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='ArticleColumn',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('System', models.CharField(max_length=200)),
('created', models.DateField(auto_now_add=True)),
],
),
]
|
[
"jingyu@rd.netease.com"
] |
jingyu@rd.netease.com
|
6dadb8446146a85cfb8ae39894b3b97d9a46708d
|
24108066b4b5b6ecd02c7fb499d970eab1877380
|
/codeforces/queueatschool.py
|
b500a8dde8579bfc2827cd50ca3f5685bf164946
|
[] |
no_license
|
vishu1994/Datastructures-And-Algorithms
|
93fc7e1d1f5fac775b6c50cb8cafd1a4f3060544
|
35bfc28edd8ebf1c1724be41402b1befd478aed4
|
refs/heads/master
| 2020-03-30T19:26:36.413735
| 2019-07-27T10:31:47
| 2019-07-27T10:31:47
| 151,542,840
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 338
|
py
|
nt=list(map(int,input().split()))
n=nt[0]
t=nt[1]
myqueue=list(input())
for i in range(t):
j=0
while j<len(myqueue)-1:
if myqueue[j]=="B" and myqueue[j+1]=="G":
myqueue[j],myqueue[j+1]="G","B"
j=j+2
else:
j=j+1
for i in myqueue:
print(i,end="")
|
[
"vishalpandey801@gmail.com"
] |
vishalpandey801@gmail.com
|
9e656061375e6a5225c6de0e83fae8c1cdc6db7f
|
b3e0d941ac23992e3a80edb1df5bd53e856ce5d5
|
/docs/source/conf.py
|
46b7f0f9c95cd64808e625b4e341ff0415384b63
|
[
"MIT"
] |
permissive
|
tjryankeogh/phytophotoutils
|
6f5c33b4dda06c66f07bd45d5c27336c6304e9b0
|
48c1747bca837f1d4c73ff48d7c232840eca8352
|
refs/heads/master
| 2023-04-18T00:00:50.236233
| 2021-04-12T13:51:58
| 2021-04-12T13:51:58
| 364,512,652
| 0
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,271
|
py
|
# Configuration file for the Sphinx documentation builder.
#
# This file only contains a selection of the most common options. For a full
# list see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# -- Path setup --------------------------------------------------------------
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
import os
import sys
#import sphinx_rtd_theme
#sys.path.insert(0, os.path.abspath('../../phyto_photo_utils/'))
sys.path.insert(0, os.path.realpath('../..'))
# -- Project information -----------------------------------------------------
project = 'PhytoPhotoUtils'
copyright = '2019, Thomas Ryan-Keogh, Charlotte Robinson'
author = 'Thomas Ryan-Keogh, Charlotte Robinson'
# The short X.Y version
version = '1.0'
# The full version, including alpha/beta/rc tags
release = '01-10-2019'
# -- General configuration ---------------------------------------------------
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = ['sphinx.ext.coverage', 'sphinx.ext.napoleon', 'sphinx.ext.autodoc']
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The master toctree document.
master_doc = 'index'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path .
exclude_patterns = []
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = 'sphinx_rtd_theme'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
# html_theme_options = {}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Custom sidebar templates, must be a dictionary that maps document names
# to template names.
#
# The default sidebars (for documents that don't match any pattern) are
# defined by theme itself. Builtin themes are using these templates by
# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
# 'searchbox.html']``.
#
# html_sidebars = {}
|
[
"tjryankeogh@googlemail.com"
] |
tjryankeogh@googlemail.com
|
107fd2eb3a81f9b2607eb4a1121d912182da8ca1
|
a120911eb088a02694e87baeaa996ded22704aab
|
/bookstore/migrations/0003_auto_20170315_2142.py
|
8d1bd6efe973c4c4978227435b76ae79eb6bad6f
|
[] |
no_license
|
muhilvarnan/django-bookstore
|
684acb534ca68b7651bedefae1b15622e2454208
|
812913626350a27846b6c1546a202ec538d40c5f
|
refs/heads/master
| 2021-01-22T18:51:03.877940
| 2017-03-15T22:10:35
| 2017-03-15T22:10:35
| 85,125,673
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 936
|
py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.6 on 2017-03-15 21:42
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('bookstore', '0002_remove_books_isbn_number'),
]
operations = [
migrations.RemoveField(
model_name='books',
name='publication_year',
),
migrations.RemoveField(
model_name='orders',
name='purchase_items',
),
migrations.AddField(
model_name='orders',
name='book',
field=models.ManyToManyField(to='bookstore.Books'),
),
migrations.AlterField(
model_name='orders',
name='customer',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='bookstore.Customers'),
),
]
|
[
"muhilvarnan.v@gmail.com"
] |
muhilvarnan.v@gmail.com
|
16e33a5a72cc6d87ecf6a25897cdc01209c3cf9c
|
cd3e72bad360d7426b6504e2e74321f47bc23eeb
|
/levelupreports/views/users/gamesbyuser.py
|
6d2e6130d8838c693d6079219540a0198f4e0765
|
[] |
no_license
|
SLLittrell/Levelup-server
|
e2eb662bf16ee9f2f53603820b03f17cb5bde1a2
|
2b582469f5888c7dcc2a1d506b4d1c7c140b3bb8
|
refs/heads/main
| 2023-05-14T18:07:41.513042
| 2021-05-27T15:50:10
| 2021-05-27T15:50:10
| 364,028,553
| 0
| 0
| null | 2021-05-27T15:50:11
| 2021-05-03T18:46:24
|
Python
|
UTF-8
|
Python
| false
| false
| 3,316
|
py
|
"""Module for generating games by user report"""
import sqlite3
from django.shortcuts import render
from levelupapi.models import Game
from levelupreports.views import Connection
def usergame_list(request):
"""Function to build an HTML report of games by user"""
if request.method == 'GET':
# Connect to project database
with sqlite3.connect(Connection.db_path) as conn:
conn.row_factory = sqlite3.Row
db_cursor = conn.cursor()
# Query for all games, with related user info.
db_cursor.execute("""
SELECT
g.id,
g.title,
g.maker,
g.game_category_id,
g.number_of_players,
g.skill_level,
u.id user_id,
u.first_name || ' ' || u.last_name AS full_name
FROM
levelupapi_game g
JOIN
levelupapi_gamer gr ON g.gamer_id = gr.id
JOIN
auth_user u ON gr.user_id = u.id
""")
dataset = db_cursor.fetchall()
# Take the flat data from the database, and build the
# following data structure for each gamer.
#
# {
# 1: {
# "id": 1,
# "full_name": "Admina Straytor",
# "games": [
# {
# "id": 1,
# "title": "Foo",
# "maker": "Bar Games",
# "skill_level": 3,
# "number_of_players": 4,
# "gametype_id": 2
# }
# ]
# }
# }
games_by_user = {}
for row in dataset:
# Crete a Game instance and set its properties
game = Game()
game.title = row["title"]
game.maker = row["maker"]
game.skill_level = row["skill_level"]
game.number_of_players = row["number_of_players"]
game.game_category_id = row["game_category_id"]
# Store the user's id
uid = row["user_id"]
# If the user's id is already a key in the dictionary...
if uid in games_by_user:
# Add the current game to the `games` list for it
games_by_user[uid]['games'].append(game)
else:
# Otherwise, create the key and dictionary value
games_by_user[uid] = {}
games_by_user[uid]["id"] = uid
games_by_user[uid]["full_name"] = row["full_name"]
games_by_user[uid]["games"] = [game]
# Get only the values from the dictionary and create a list from them
list_of_users_with_games = games_by_user.values()
# Specify the Django template and provide data context
template = 'users/list_with_games.html'
context = {
'usergame_list': list_of_users_with_games
}
return render(request, template, context)
|
[
"stacey.littrell@gmail.com"
] |
stacey.littrell@gmail.com
|
56441abdcb0c3e4c4bc9e6e51c066f53b4474751
|
d09fd96bbc931fbb8522e5c991973f064a4ded50
|
/baxter/devel/lib/python2.7/dist-packages/baxter_core_msgs/msg/_AssemblyStates.py
|
e02cc99b32b08bd3ff9a2b09c7d226c451abe8d2
|
[] |
no_license
|
rymonyu/EE4-Robotics
|
b3827ba0dff5bdfdd1e47fe07a40e955c5226f38
|
6cf9272abd7fe8a074dc74a032f6e0b35edb8548
|
refs/heads/master
| 2020-08-22T15:09:39.706809
| 2019-12-15T23:35:45
| 2019-12-15T23:35:45
| 216,420,098
| 6
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 116
|
py
|
/home/rob/baxter/devel/.private/baxter_core_msgs/lib/python2.7/dist-packages/baxter_core_msgs/msg/_AssemblyStates.py
|
[
"rymonyu@gmail.com"
] |
rymonyu@gmail.com
|
fabcbe720fa7f9586321ad3d1884bd8c89a35a95
|
fa701904e59a94510a5c4fa3e1e64a8fe4135fd6
|
/mysite/mysite/settings.py
|
887b16718fbb0754f36a99c8116988166e0bd302
|
[] |
no_license
|
pr0mila/django_practice
|
6c4c29987d94d7d838fe6f5378862f266203d97f
|
64ab8181f053d158ed1c5d47d459e8771cc4681a
|
refs/heads/master
| 2020-08-18T09:27:01.351518
| 2019-10-18T21:04:18
| 2019-10-18T21:04:18
| 215,774,432
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,112
|
py
|
"""
Django settings for mysite project.
Generated by 'django-admin startproject' using Django 3.1.
For more information on this file, see
https://docs.djangoproject.com/en/dev/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/dev/ref/settings/
"""
import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/dev/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '&x^9hen^vm3#thtq8(ijj3ld=yj^=l%)hy4tp7e4kt!v8=9-^7'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'polls.apps.PollsConfig',
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'mysite.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'mysite.wsgi.application'
# Database
# https://docs.djangoproject.com/en/dev/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
# Password validation
# https://docs.djangoproject.com/en/dev/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/dev/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/dev/howto/static-files/
STATIC_URL = '/static/'
|
[
"me@promila.info"
] |
me@promila.info
|
648100aedd647315dd5b9631cec11785d7b6a4b0
|
ad3da434e91d28d5062089070b2c3b6915a775ae
|
/Django-Scraping/news/migrations/0002_weather.py
|
a74bcd94da2f22d109807b57d7689578344a6043
|
[
"Apache-2.0"
] |
permissive
|
mitus1212/Django-Scraping
|
f241a97481feef69aee9b159fe833a3bff6154da
|
00d503b004cc7c4a23de154bbca55351b7f3546d
|
refs/heads/master
| 2023-01-01T23:11:49.375542
| 2020-06-10T17:57:56
| 2020-06-10T17:57:56
| 180,415,060
| 0
| 0
| null | 2022-11-22T03:39:21
| 2019-04-09T17:13:27
|
JavaScript
|
UTF-8
|
Python
| false
| false
| 552
|
py
|
# Generated by Django 2.1.7 on 2019-04-11 14:29
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('news', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Weather',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('weather', models.TextField()),
('degree', models.CharField(max_length=200)),
],
),
]
|
[
"mitus11112@gmail.com"
] |
mitus11112@gmail.com
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.