hexsha
stringlengths 40
40
| size
int64 6
782k
| ext
stringclasses 7
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
237
| max_stars_repo_name
stringlengths 6
72
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
list | max_stars_count
int64 1
53k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
184
| max_issues_repo_name
stringlengths 6
72
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
list | max_issues_count
int64 1
27.1k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
184
| max_forks_repo_name
stringlengths 6
72
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
list | max_forks_count
int64 1
12.2k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 6
782k
| avg_line_length
float64 2.75
664k
| max_line_length
int64 5
782k
| alphanum_fraction
float64 0
1
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
6aee86de95ce7256a515f3d51114045440c5747d
| 4,443 |
py
|
Python
|
egs/dns_challenge/baseline/train.py
|
groadabike/asteroid
|
276d98346ab791d904fbfe79b9b8e374392dd128
|
[
"MIT"
] | 1 |
2020-12-18T02:42:23.000Z
|
2020-12-18T02:42:23.000Z
|
egs/dns_challenge/baseline/train.py
|
groadabike/asteroid
|
276d98346ab791d904fbfe79b9b8e374392dd128
|
[
"MIT"
] | null | null | null |
egs/dns_challenge/baseline/train.py
|
groadabike/asteroid
|
276d98346ab791d904fbfe79b9b8e374392dd128
|
[
"MIT"
] | null | null | null |
import argparse
import json
import os
from functools import partial
import pytorch_lightning as pl
import torch
from pytorch_lightning.callbacks import ModelCheckpoint, EarlyStopping
from torch.optim.lr_scheduler import ReduceLROnPlateau
from torch.utils.data import DataLoader, random_split
from asteroid.data import DNSDataset
from asteroid.utils import str2bool_arg
from model import make_model_and_optimizer, SimpleSystem, distance
torch.manual_seed(17) # Reproducibility on the dataset spliting
parser = argparse.ArgumentParser()
parser.add_argument("--exp_dir", default="exp/tmp", help="Full path to save best validation model")
parser.add_argument("--is_complex", default=True, type=str2bool_arg)
def main(conf):
total_set = DNSDataset(conf["data"]["json_dir"])
train_len = int(len(total_set) * (1 - conf["data"]["val_prop"]))
val_len = len(total_set) - train_len
train_set, val_set = random_split(total_set, [train_len, val_len])
train_loader = DataLoader(
train_set,
shuffle=True,
batch_size=conf["training"]["batch_size"],
num_workers=conf["training"]["num_workers"],
drop_last=True,
)
val_loader = DataLoader(
val_set,
shuffle=False,
batch_size=conf["training"]["batch_size"],
num_workers=conf["training"]["num_workers"],
drop_last=True,
)
# Define model and optimizer in a local function (defined in the recipe).
# Two advantages to this : re-instantiating the model and optimizer
# for retraining and evaluating is straight-forward.
model, optimizer = make_model_and_optimizer(conf)
# Define scheduler
scheduler = None
if conf["training"]["half_lr"]:
scheduler = ReduceLROnPlateau(optimizer=optimizer, factor=0.5, patience=5)
# Just after instantiating, save the args. Easy loading in the future.
exp_dir = conf["main_args"]["exp_dir"]
os.makedirs(exp_dir, exist_ok=True)
conf_path = os.path.join(exp_dir, "conf.yml")
with open(conf_path, "w") as outfile:
yaml.safe_dump(conf, outfile)
# Define Loss function.
loss_func = partial(distance, is_complex=conf["main_args"]["is_complex"])
system = SimpleSystem(
model=model,
loss_func=loss_func,
optimizer=optimizer,
train_loader=train_loader,
val_loader=val_loader,
scheduler=scheduler,
config=conf,
)
# Define callbacks
checkpoint_dir = os.path.join(exp_dir, "checkpoints/")
checkpoint = ModelCheckpoint(
checkpoint_dir, monitor="val_loss", mode="min", save_top_k=5, verbose=True
)
early_stopping = False
if conf["training"]["early_stop"]:
early_stopping = EarlyStopping(monitor="val_loss", patience=30, verbose=True)
# Don't ask GPU if they are not available.
gpus = -1 if torch.cuda.is_available() else None
trainer = pl.Trainer(
max_epochs=conf["training"]["epochs"],
checkpoint_callback=checkpoint,
early_stop_callback=early_stopping,
default_root_dir=exp_dir,
gpus=gpus,
distributed_backend="dp",
train_percent_check=1.0, # Useful for fast experiment
gradient_clip_val=5.0,
)
trainer.fit(system)
best_k = {k: v.item() for k, v in checkpoint.best_k_models.items()}
with open(os.path.join(exp_dir, "best_k_models.json"), "w") as f:
json.dump(best_k, f, indent=0)
if __name__ == "__main__":
import yaml
from pprint import pprint
from asteroid.utils import prepare_parser_from_dict, parse_args_as_dict
# We start with opening the config file conf.yml as a dictionary from
# which we can create parsers. Each top level key in the dictionary defined
# by the YAML file creates a group in the parser.
with open("local/conf.yml") as f:
def_conf = yaml.safe_load(f)
parser = prepare_parser_from_dict(def_conf, parser=parser)
# Arguments are then parsed into a hierarchical dictionary (instead of
# flat, as returned by argparse) to facilitate calls to the different
# asteroid methods (see in main).
# plain_args is the direct output of parser.parse_args() and contains all
# the attributes in an non-hierarchical structure. It can be useful to also
# have it so we included it here but it is not used.
arg_dic, plain_args = parse_args_as_dict(parser, return_plain_args=True)
pprint(arg_dic)
main(arg_dic)
| 37.336134 | 99 | 0.701778 |
e4026bb7bc894b5c06b24233de07077fb8bd08bf
| 22,762 |
py
|
Python
|
modules/genetic_algorithm.py
|
J0nasW/Bachelorarbeit
|
37052be075713f2016d42782397ff875e3e982f8
|
[
"MIT"
] | null | null | null |
modules/genetic_algorithm.py
|
J0nasW/Bachelorarbeit
|
37052be075713f2016d42782397ff875e3e982f8
|
[
"MIT"
] | null | null | null |
modules/genetic_algorithm.py
|
J0nasW/Bachelorarbeit
|
37052be075713f2016d42782397ff875e3e982f8
|
[
"MIT"
] | null | null | null |
"""
RL MODULE WITH GENETIC ALGORITHMS
CALL BY: <genetic_algorithm.py>
RETURN: Parameter Matrices for the inverted Pendulum Problem
Stores Data of best Parameters in '<date>_ga_<reward>.hkl'
INFO: Still under development
"""
# Some dependencies
import os
import numpy as np # Maths and stuff
import gym.spaces # Simulating the Environments
import hickle as hkl # Performance Dumping in HDF5 Format <.hkl>
import time # For Runtime Evaluations
import datetime # For Datestamp on stored files
import matplotlib.pyplot as plt
from .lif import I_syn_calc, I_gap_calc, U_neuron_calc
from .parameters import *
def initialize_limits():
# Some important Parameters for the genetic Algorithms--------------------------------------
# Initial Limits of the Parameters
w_low = 0
w_high = 3
w_limit = np.array([w_low, w_high])
sig_low = 0.05
sig_high = 0.5
sig_limit = np.array([sig_low, sig_high])
C_m_low = 0.01
C_m_high = 1
C_m_limit = np.array([C_m_low, C_m_high])
G_leak_low = 0.1
G_leak_high = 2.5
G_leak_limit = np.array([G_leak_low, G_leak_high])
U_leak_low = -70
U_leak_high = -50
U_leak_limit = np.array([U_leak_low, U_leak_high])
return w_limit, sig_limit, C_m_limit, G_leak_limit, U_leak_limit
# Initialization----------------------------------------------------------------------------
def initialize(Default_U_leak):
global totalreward, done, info
# Initializing Neurons and Sensors------------------------------------------------------
for i in range(0,4):
x[i] = Default_U_leak
for i in range(0,4):
u[i] = Default_U_leak
#OpenAI Gym Parameters-----------------------------------------------------------------
totalreward = 0
done = 0
info = 0
#-------------------------------------------------------------------------------------------
# Clear Function---------------------------------------------------------------------------
def clear():
# Reset Generation-Episode-Counter
gen_episodes = 0
gen_reward_arr = []
gen_selection_reward_arr = []
# Reset Parameter Tensors
dict_syn = {}
id_syn = 0
dict_neuro = {}
id_neuro = 0
# Reset Parameter Arrays
w_A_sel = w_B_sel = w_B_gap_sel = w_sel = sig_A_sel = sig_B_sel = sig_sel = C_m_sel = G_leak_sel = U_leak_sel = np.array([])
return gen_episodes, gen_reward_arr, gen_selection_reward_arr, dict_syn, id_syn, dict_neuro, id_neuro, w_A_sel, w_B_sel, w_B_gap_sel, w_sel, sig_A_sel, sig_B_sel, sig_sel, C_m_sel, G_leak_sel, U_leak_sel
#-------------------------------------------------------------------------------------------
# Random Function---------------------------------------------------------------------------
def random_parameters(w_limit, sig_limit, C_m_limit, G_leak_limit, U_leak_limit):
# Initialize random parameters for our Neurons and Synapses according to the current Network
# For Synapses
w_A_rnd = np.squeeze(np.random.uniform(low = w_limit[0], high = w_limit[1], size = (1,nbr_of_inter_synapses)))
w_B_rnd = np.squeeze(np.random.uniform(low = w_limit[0], high = w_limit[1], size = (1,nbr_of_sensor_synapses)))
w_B_gap_rnd = np.squeeze(np.random.uniform(low = w_limit[0], high = w_limit[1], size = (1,nbr_of_gap_junctions)))
sig_A_rnd = np.squeeze(np.random.uniform(low = sig_limit[0], high = sig_limit[1], size = (1,nbr_of_inter_synapses)))
sig_B_rnd = np.squeeze(np.random.uniform(low = sig_limit[0], high = sig_limit[1], size = (1,nbr_of_sensor_synapses)))
# For Neurons
C_m_rnd = np.squeeze(np.random.uniform(low = C_m_limit[0], high = C_m_limit[1], size = (1,nbr_of_inter_neurons)))
G_leak_rnd = np.squeeze(np.random.uniform(low = G_leak_limit[0], high = G_leak_limit[1], size = (1,nbr_of_inter_neurons)))
U_leak_rnd = np.squeeze(np.random.uniform(low = U_leak_limit[0], high = U_leak_limit[1], size = (1,nbr_of_inter_neurons)))
return w_A_rnd, w_B_rnd, w_B_gap_rnd, sig_A_rnd, sig_B_rnd, C_m_rnd, G_leak_rnd, U_leak_rnd
def random_parameters_symm(w_limit, sig_limit, C_m_limit, G_leak_limit, U_leak_limit):
# Initialize symmetrical random parameters for our Neurons and Synapses according to the current Network
# For Synapses
w_A_rnd = np.squeeze(np.random.uniform(low = w_limit[0], high = w_limit[1], size = (1,nbr_of_inter_synapses_symm)))
w_A_rnd = np.append(w_A_rnd, np.flip(w_A_rnd))
w_B_rnd = np.squeeze(np.random.uniform(low = w_limit[0], high = w_limit[1], size = (1,nbr_of_sensor_synapses_symm)))
w_B_rnd = np.append(w_B_rnd, np.flip(w_B_rnd))
w_B_gap_rnd = np.squeeze(np.random.uniform(low = w_limit[0], high = w_limit[1], size = (1,nbr_of_gap_junctions_symm)))
w_B_gap_rnd = np.append(w_B_gap_rnd, np.flip(w_B_gap_rnd))
sig_A_rnd = np.squeeze(np.random.uniform(low = sig_limit[0], high = sig_limit[1], size = (1,nbr_of_inter_synapses_symm)))
sig_A_rnd = np.append(sig_A_rnd, np.flip(sig_A_rnd))
sig_B_rnd = np.squeeze(np.random.uniform(low = sig_limit[0], high = sig_limit[1], size = (1,nbr_of_sensor_synapses_symm)))
sig_B_rnd = np.append(sig_B_rnd, np.flip(sig_B_rnd))
# For Neurons
C_m_rnd = np.squeeze(np.random.uniform(low = C_m_limit[0], high = C_m_limit[1], size = (1,nbr_of_inter_neurons_symm)))
C_m_rnd = np.append(C_m_rnd, np.flip(C_m_rnd))
G_leak_rnd = np.squeeze(np.random.uniform(low = G_leak_limit[0], high = G_leak_limit[1], size = (1,nbr_of_inter_neurons_symm)))
G_leak_rnd = np.append(G_leak_rnd, np.flip(G_leak_rnd))
U_leak_rnd = np.squeeze(np.random.uniform(low = U_leak_limit[0], high = U_leak_limit[1], size = (1,nbr_of_inter_neurons_symm)))
U_leak_rnd = np.append(U_leak_rnd, np.flip(U_leak_rnd))
return w_A_rnd, w_B_rnd, w_B_gap_rnd, sig_A_rnd, sig_B_rnd, C_m_rnd, G_leak_rnd, U_leak_rnd
#-------------------------------------------------------------------------------------------
# Plot Function-----------------------------------------------------------------------------
def plot(w_limit_arr_low, w_limit_arr_high, sig_limit_arr_low, sig_limit_arr_high, C_m_limit_arr_low, C_m_limit_arr_high, G_leak_limit_arr_low, G_leak_limit_arr_high, U_leak_limit_arr_low, U_leak_limit_arr_high, reward_arr_plot, best_reward_arr_plot):
plt.rc('text', usetex=True)
plt.rc('font', family='serif', size=20)
plt.figure(1)
#plt.suptitle('TW Circuit Simulator - Genetic Algorithm - SYNAPSE', fontsize=16)
plt.subplot(121)
plt.title('$\omega_{limit}$', fontsize=22)
plt.plot(w_limit_arr_low, '-b', label='$\omega_{low}$', linewidth=1)
plt.plot(w_limit_arr_high, '-g', label='$\omega_{high}$', linewidth=1)
plt.xlabel('Generation')
plt.ylabel('$S$')
plt.legend(loc='upper left')
plt.subplot(122)
plt.title('$\sigma_{limit}$', fontsize=22)
plt.plot(sig_limit_arr_low, '-b', label='$\sigma_{low}$', linewidth=1)
plt.plot(sig_limit_arr_high, '-g', label='$\sigma_{high}$', linewidth=1)
plt.xlabel('Generation')
plt.legend(loc='upper left')
plt.figure(2)
#plt.suptitle('TW Circuit Simulator - Genetic Algorithm - NEURON', fontsize=16)
plt.subplot(131)
plt.title('$C_{m\_limit}$', fontsize=22)
plt.plot(C_m_limit_arr_low, '-b', label='$C_{m\_low}$', linewidth=1)
plt.plot(C_m_limit_arr_high, '-g', label='$C_{m\_high}$', linewidth=1)
plt.xlabel('Generation')
plt.ylabel('$mF$')
plt.legend(loc='upper left')
plt.subplot(132)
plt.title('$G_{leak\_limit}$', fontsize=22)
plt.plot(G_leak_limit_arr_low, '-b', label='$G_{leak\_low}$', linewidth=1)
plt.plot(G_leak_limit_arr_high, '-g', label='$G_{leak\_high}$', linewidth=1)
plt.xlabel('Generation')
plt.ylabel('$S$')
plt.legend(loc='upper left')
plt.subplot(133)
plt.title('$U_{leak\_limit}$', fontsize=22)
plt.plot(U_leak_limit_arr_low, '-b', label='$U_{leak\_low}$', linewidth=1)
plt.plot(U_leak_limit_arr_high, '-g', label='$U_{leak\_high}$', linewidth=1)
plt.xlabel('Generation')
plt.ylabel('$mV$')
plt.legend(loc='upper left')
'''
plt.figure(3)
plt.suptitle('TW Circuit Simulator - GENETICAL ALGORITHM - REWARD', fontsize=16)
plt.subplot(121)
plt.title('Best Reward of Selection', fontsize=10)
plt.plot(best_reward_arr_plot, '-r', label='Reward', linewidth=1)
plt.xlabel('Selection')
plt.ylabel('Reward')
plt.legend(loc='upper left')
plt.subplot(122)
plt.title('Best Reward of every EPISODE', fontsize=10)
plt.plot(reward_arr_plot, '-b', label='Reward', linewidth=1)
plt.xlabel('Episode')
plt.ylabel('Reward')
plt.legend(loc='upper left')
'''
plt.show()
#-------------------------------------------------------------------------------------------
# Compute Function--------------------------------------------------------------------------
def compute(x, u, w_A_rnd, w_B_rnd, w_B_gap_rnd, sig_A_rnd, sig_B_rnd, C_m_rnd, G_leak_rnd, U_leak_rnd):
# Some helpint Counter-Variables
k = 0
l = 0
m = 0
# Compute all Synapse Currents in this network------------------------------------------
for i in range(0,4):
for j in range (0,4):
# Synapse Currents between Interneurons
if A[i, j] == 1:
# Excitatory Synapse
I_s_inter[i, j] = I_syn_calc(x[i], x[j], E_in, w_A_rnd[k], sig_A_rnd[k], mu)
k += 1
elif A[i, j] == 2:
# Inhibitory Synapse
I_s_inter[i, j] = I_syn_calc(x[i], x[j], E_ex, w_A_rnd[k], sig_A_rnd[k], mu)
k += 1
else:
# No Connection here.
I_s_inter[i, j] = 0
# Synapse Currents between Sensory and Interneurons
if B[i, j] == 1:
# Inhibitory Synapse (can't be Excitatory)
I_s_sensor[i, j] = I_syn_calc(u[i], u[j], E_in, w_B_rnd[l], sig_B_rnd[l], mu)
l += 1
elif B[i, j] == 2:
I_s_sensor[i, j] = I_syn_calc(u[i], u[j], E_ex, w_B_rnd[l], sig_B_rnd[l], mu)
l += 1
elif B[i, j] == 3:
# Gap Junction
I_g_sensor[i, j] = I_gap_calc(u[i], x[j], w_B_gap_rnd[m])
m += 1
else:
# No Connection here.
I_s_sensor[i, j] = 0
I_g_sensor[i, j] = 0
#---------------------------------------------------------------------------------------
# Compute inter Neurons Voltages----------------------------------------------------
for i in range(0,4):
I_syn_inter = I_s_inter.sum(axis = 0) # Creates a 1x5 Array with the Sum of all Columns
I_gap_inter = I_g_inter.sum(axis = 0)
I_syn_stimuli = I_s_sensor.sum(axis = 0)
I_gap_stimuli = I_g_sensor.sum(axis = 0)
x[i], fire[i] = U_neuron_calc(x[i], I_syn_inter[i], I_gap_inter[i], I_syn_stimuli[i], I_gap_stimuli[i], C_m_rnd[i], G_leak_rnd[i], U_leak_rnd[i], v, delta_t)
#---------------------------------------------------------------------------------------
I_syn = np.add(I_syn_inter, I_syn_stimuli)
I_gap = np.add(I_gap_inter, I_gap_stimuli)
return x, u, fire, I_syn, I_gap
#-------------------------------------------------------------------------------------------
# OpenAI Gym--------------------------------------------------------------------------------
def run_episode(env, w_A_rnd, w_B_rnd, w_B_gap_rnd, sig_A_rnd, sig_B_rnd, C_m_rnd, G_leak_rnd, U_leak_rnd):
global x, u, fire, I_syn, I_gap, action
observation = env.reset()
totalreward = 0
for t in np.arange(t0,T,delta_t): # RUNNING THE EPISODE - Trynig to get 200 Steps in this Episode
# Compute the next Interneuron Voltages along with a possible "fire" Event - Now new with random parameter matrices
x, u, fire, I_syn, I_gap = compute(x, u, w_A_rnd, w_B_rnd, w_B_gap_rnd, sig_A_rnd, sig_B_rnd, C_m_rnd, G_leak_rnd, U_leak_rnd)
# Decide for an action and making a Step
if fire[0] == 1: # Sensory Neuron AVA is firing - resulting in a REVERSE Action (0 - LEFT)
action = 0
observation, reward, done, info = env.step(action)
elif fire[3] == 1: # Sensory Neuron AVB is firing - resulting in a FORWARD Action (1 - RIGHT)
action = 1
observation, reward, done, info = env.step(action)
else:
# If computing twice in a Simulation, this step is obsolete (No uncertainty)
observation, reward, done, info = env.step(action) # Have to use the action from the past time step - OpenAI Gym does not provide a "Do nothing"-Action
totalreward += reward # Counting the total reward.
observe(observation) # Trace the observation from our simulation back into the sensory neurons
if done:
# If reached a total Reward of 200
break
return totalreward
def observe(observation):
global u
# Interpreter: Calculating some of the observation values into valid data
cart_pos = observation[0] # [-2.4 2.4]
cart_vel = observation[1] # [-inf, inf]
angle = (observation[2] * 360) / (2 * np.pi) # in degrees [-12deg, 12deg] (for Simulations)
angle_velocity = observation[3] # [-inf, inf]
# Adapt, learn, overcome---------------------------------------------------------------------------
# Setting the Angle of the Pole to Sensory Neurons PLM (Phi+) and AVM (Phi-)
if angle > 0:
u[1] = Default_U_leak + ((v-Default_U_leak)/max_angle) * np.absolute(angle) # PLM
u[2] = Default_U_leak
elif angle == 0:
u[1] = u[2] = Default_U_leak
else:
u[2] = Default_U_leak + ((v-Default_U_leak)/max_angle) * np.absolute(angle) # AVM
u[1] = Default_U_leak
if SecondObservation == "cart":
# Setting the Cart Position to Sensory Neurons ALM (pos. movement) and PVD (neg. movement)
if cart_pos > 0:
u[3] = Default_U_leak + ((v-Default_U_leak)/max_cart_pos) * np.absolute(cart_pos) # ALM
u[0] = Default_U_leak
elif cart_pos == 0:
u[0] = u[3] = Default_U_leak
else:
u[0] = Default_U_leak + ((v-Default_U_leak)/max_cart_pos) * np.absolute(cart_pos) # PVD
u[3] = Default_U_leak
elif SecondObservation == "angle":
# Setting the Anglespeed of the Pole to Sensory Neurons ALM (Phi.+) and PVD (Phi.-)
if angle_velocity >= 0:
u[0] = Default_U_leak + ((v-Default_U_leak)/max_angle_velocity) * np.absolute(angle_velocity) # ALM
u[3] = Default_U_leak
elif cart_pos == 0:
u[0] = u[3] = Default_U_leak
else:
u[3] = Default_U_leak + ((v-Default_U_leak)/max_angle_velocity) * np.absolute(angle_velocity) # PVD
u[0] = Default_U_leak
return angle
#------------------------------------------------------------------------------------
#-------------------------------------------------------------------------------------------
# Main Function-----------------------------------------------------------------------------
#-------------------------------------------------------------------------------------------
def main(sim_time,plot_choice):
global x, u, env, action
start_time = time.time() # for Runtime reasons
# Initialize the Environment and some vital Parameters
action = 0
episodes = 0
gen_episodes = 0
best_reward = 0
env = gym.make('CartPole-v0')
# Initialize Genetic Arrays
current_parameters_syn = np.array([])
current_parameters_neuro = np.array([])
# Initialize Parameter Tensors (as Python Dictionaries)
dict_syn = {}
id_syn = 0
dict_neuro = {}
id_neuro = 0
#gen_parameter_mat_syn = np.empty((0,5), int)
#gen_parameter_mat_neuro = np.empty((0,3), int)
gen_reward_arr = np.array([])
gen_selection_reward_arr = np.array([])
gen_selection_parameter_mat_syn = np.empty((0,5), int)
gen_selection_parameter_mat_neuro = np.empty((0,3), int)
w_A_sel = w_B_sel = w_B_gap_sel = w_sel = sig_A_sel = sig_B_sel = sig_sel = C_m_sel = G_leak_sel = U_leak_sel = np.array([])
w_limit, sig_limit, C_m_limit, G_leak_limit, U_leak_limit = initialize_limits()
# Some plotting Arrays
w_limit_arr_low = w_limit_arr_high = sig_limit_arr_low = sig_limit_arr_high = C_m_limit_arr_low = C_m_limit_arr_high = G_leak_limit_arr_low = G_leak_limit_arr_high = U_leak_limit_arr_low = U_leak_limit_arr_high = reward_arr_plot = best_reward_arr_plot = np.array([])
while True:
initialize(Default_U_leak) # Initializing all Sensory- and Interneurons with the desired leakage voltage [-70mV]
episodes += 1 # Episode Counter
gen_episodes +=1
if IsSymmetrical == True:
w_A_rnd, w_B_rnd, w_B_gap_rnd, sig_A_rnd, sig_B_rnd, C_m_rnd, G_leak_rnd, U_leak_rnd = random_parameters_symm(w_limit, sig_limit, C_m_limit, G_leak_limit, U_leak_limit) # Make some new random parameter Matrices
elif IsSymmetrical == False:
w_A_rnd, w_B_rnd, w_B_gap_rnd, sig_A_rnd, sig_B_rnd, C_m_rnd, G_leak_rnd, U_leak_rnd = random_parameters(w_limit, sig_limit, C_m_limit, G_leak_limit, U_leak_limit) # Make some new random parameter Matrices
reward = run_episode(env, w_A_rnd, w_B_rnd, w_B_gap_rnd, sig_A_rnd, sig_B_rnd, C_m_rnd, G_leak_rnd, U_leak_rnd)
# Genetic stuff --------------------------
# Generates a Matrix of Parameters in the current Generation (100x8)
current_parameters_syn = np.array([w_A_rnd, w_B_rnd, np.append(w_B_gap_rnd,[0,0,0,0,0,0]), sig_A_rnd, sig_B_rnd])
current_parameters_neuro = np.array([C_m_rnd, G_leak_rnd, U_leak_rnd])
# Generate Tesors for Matrices through time
dict_syn.update({id_syn:current_parameters_syn}) # 5x8x100
dict_neuro.update({id_neuro:current_parameters_neuro}) # 3x4x100
id_syn += 1
id_neuro += 1
# Generates a Vector of Rewards in the current Generation (1x100)
gen_reward_arr = np.append(gen_reward_arr, reward)
if gen_episodes >= 100:
# Selection of the current Generation (10 out of 100 Episodes with the best Rewards)
gen_selection_reward_arr = np.argpartition(gen_reward_arr, -10)[-10:]
for i in range(10):
# Get indices of the best 10 Episodes
j = gen_selection_reward_arr[i]
w_A_sel = np.append(w_A_sel, dict_syn.get(j)[0,:])
w_B_sel = np.append(w_B_sel, dict_syn.get(j)[1,:])
w_B_gap_sel = np.append(w_B_gap_sel, dict_syn.get(j)[2,(0,1)])
sig_A_sel = np.append(sig_A_sel, dict_syn.get(j)[3,:])
sig_B_sel = np.append(sig_B_sel, dict_syn.get(j)[4,:])
C_m_sel = np.append(C_m_sel, dict_neuro.get(j)[0,:])
G_leak_sel = np.append(G_leak_sel, dict_neuro.get(j)[1,:])
U_leak_sel = np.append(U_leak_sel, dict_neuro.get(j)[2,:])
# Get the Parameter-Vektors of the Selection (each 1x10)
w_sel = np.append(w_A_sel, w_B_sel)
w_sel = np.append(w_sel, w_B_gap_sel)
sig_sel = np.append(sig_A_sel, sig_B_sel)
# Get maximum/minimum values for new Limits
w_limit = np.array([np.amin(w_sel), np.amax(w_sel)])
sig_limit = np.array([np.amin(sig_sel), np.amax(sig_sel)])
C_m_limit = np.array([np.amin(C_m_sel), np.amax(C_m_sel)])
G_leak_limit = np.array([np.amin(G_leak_sel), np.amax(G_leak_sel)])
U_leak_limit = np.array([np.amin(U_leak_sel), np.amax(U_leak_sel)])
if plot_choice == 1:
# For plotting purposes
w_limit_arr_low = np.append(w_limit_arr_low, w_limit[0])
w_limit_arr_high = np.append(w_limit_arr_high, w_limit[1])
sig_limit_arr_low = np.append(sig_limit_arr_low, sig_limit[0])
sig_limit_arr_high = np.append(sig_limit_arr_high, sig_limit[1])
C_m_limit_arr_low = np.append(C_m_limit_arr_low, C_m_limit[0])
C_m_limit_arr_high = np.append(C_m_limit_arr_high, C_m_limit[1])
G_leak_limit_arr_low = np.append(G_leak_limit_arr_low, G_leak_limit[0])
G_leak_limit_arr_high = np.append(G_leak_limit_arr_high, G_leak_limit[1])
U_leak_limit_arr_low = np.append(U_leak_limit_arr_low, U_leak_limit[0])
U_leak_limit_arr_high = np.append(U_leak_limit_arr_high, U_leak_limit[1])
best_reward_arr_plot = np.append(best_reward_arr_plot, gen_reward_arr[np.argpartition(gen_reward_arr, -1)[-1:]])
#Reset and Clear
gen_episodes, gen_reward_arr, gen_selection_reward_arr, dict_syn, id_syn, dict_neuro, id_neuro, w_A_sel, w_B_sel, w_B_gap_sel, w_sel, sig_A_sel, sig_B_sel, sig_sel, C_m_sel, G_leak_sel, U_leak_sel = clear()
if reward > best_reward:
# Set current reward as new best_reward
best_reward = reward
# Save Results of the Run with the best reward
Result = [w_A_rnd, w_B_rnd, w_B_gap_rnd, sig_A_rnd, sig_B_rnd, C_m_rnd, G_leak_rnd, U_leak_rnd]
reward_arr_plot = np.append(reward_arr_plot, best_reward)
if (time.time() - start_time) >= sim_time:
# End Simulation-Run, if given Simulation time is elapsed.
break
# Prepare some Information to dump..
date = datetime.datetime.now().strftime("%Y%m%d_%H-%M-%S")
best_reward_s = str(int(best_reward))
episodes = str(int(episodes))
elapsed_time = str((time.time() - start_time))
hkl.dump(Result, (current_dir + "/parameter_dumps/" + date + "_ga_" + best_reward_s + ".hkl"), mode='w')
# Information Text File
file = open((current_dir + "/information/" + date + "_parameter_run_ga_" + best_reward_s + ".txt"), "w")
file.write(("---GENETIC ALGORITHM---\nParameter run from " + date + " with Reward " + best_reward_s + " and " + episodes + " Episodes.\nSimulation Runtime was " + elapsed_time + "."))
file.close()
# Console Prints
print ('The best Reward was:',best_reward)
if plot_choice == 1:
plot(w_limit_arr_low, w_limit_arr_high, sig_limit_arr_low, sig_limit_arr_high, C_m_limit_arr_low, C_m_limit_arr_high, G_leak_limit_arr_low, G_leak_limit_arr_high, U_leak_limit_arr_low, U_leak_limit_arr_high, reward_arr_plot, best_reward_arr_plot)
print("--- %s seconds ---" % (time.time() - start_time))
return date, best_reward_s
#-------------------------------------------------------------------------------------------
if __name__=="__main__":
main()
| 44.37037 | 270 | 0.602232 |
7c25ca7f16e27629f6dc956408a6fd7c032d694e
| 1,436 |
py
|
Python
|
___Python/Thomas/pycurs_180625/p09_isbn/isbn.py
|
uvenil/PythonKurs201806
|
85afa9c9515f5dd8bec0c546f077d8cc39568fe8
|
[
"Apache-2.0"
] | null | null | null |
___Python/Thomas/pycurs_180625/p09_isbn/isbn.py
|
uvenil/PythonKurs201806
|
85afa9c9515f5dd8bec0c546f077d8cc39568fe8
|
[
"Apache-2.0"
] | null | null | null |
___Python/Thomas/pycurs_180625/p09_isbn/isbn.py
|
uvenil/PythonKurs201806
|
85afa9c9515f5dd8bec0c546f077d8cc39568fe8
|
[
"Apache-2.0"
] | null | null | null |
# Aufgabe:
# http://exercism.io/exercises/python/isbn-verifier/readme
# Prüfe, ob isbn eine gültige ISBN-Nummer ist
import re
def verify(isbn):
print(isbn)
list_isbn = []
for chr_isbn in isbn:
try:
i_isbn = int(chr_isbn)
if i_isbn in range(10):
list_isbn.append(i_isbn)
except ValueError:
pass
if len(list_isbn) == 10:
i_cl = 10
i_check_isbn = 0
while i_cl > 0:
i_check_isbn += list_isbn[i_cl-1]*i_cl
i_cl -= 1
if i_check_isbn % 11 == 0:
return True
else:
return False
return False
#if verify('3-598-21507-8'):
# print('Richtig')
#else:
# print('Falsch')
# def verify(isbn):
# if len(isbn < 10):
# return False
# check_digit = isbn[-1]
# if not(check_digit in range(0, 9) or check_digit == 'X'):
# return False
# if check_digit =='X':
# check_digit = 10
# else:
# check_digit = int(check_digit)
# pre = isbn[:-1] #entferne letzte Stelle
# pre = re.sub('[^0-9]', '', pre)
# print(pre)
# if len(pre) !=9:
# return False
#
# sum = 0
# for i in range(9):
# sum += int(pre[i]* (10-i)
# sum += check_digit
#
# return sum % 11 == 0
print(verify('3-598-P1581-X'))
| 23.933333 | 64 | 0.489554 |
7cc52dec871a3e5127d95306c8ff9d3d9aa9df44
| 4,443 |
py
|
Python
|
beispielanwendungen/hallowelt/hallowelt10_eingabedialoge.py
|
pbouda/pyqt-und-pyside-buch
|
a4ec10663ccc8aeda075c9a06b9707ded52382c8
|
[
"CC-BY-4.0"
] | 5 |
2017-03-11T13:27:27.000Z
|
2022-01-09T10:52:05.000Z
|
beispielanwendungen/hallowelt/hallowelt10_eingabedialoge.py
|
pbouda/pyqt-und-pyside-buch
|
a4ec10663ccc8aeda075c9a06b9707ded52382c8
|
[
"CC-BY-4.0"
] | 2 |
2021-02-14T10:59:59.000Z
|
2021-10-30T21:46:32.000Z
|
beispielanwendungen/hallowelt/hallowelt10_eingabedialoge.py
|
pbouda/pyqt-und-pyside-buch
|
a4ec10663ccc8aeda075c9a06b9707ded52382c8
|
[
"CC-BY-4.0"
] | 1 |
2019-08-07T03:08:18.000Z
|
2019-08-07T03:08:18.000Z
|
# -*- coding: utf-8 -*-
import sys
from PyQt4 import QtCore, QtGui
def main(argv):
app = QtGui.QApplication(argv)
mainwindow = MainWindow()
mainwindow.show()
sys.exit(app.exec_())
class MainWindow(QtGui.QMainWindow):
meinSignal = QtCore.pyqtSignal()
def __init__(self, *args):
QtGui.QMainWindow.__init__(self, *args)
self.createMenu()
self.createComponents()
self.createLayout()
self.createConnects()
self.setWindowTitle(self.tr(u"Hallo Welt"))
def createMenu(self):
self.actionDateiOeffnen = QtGui.QAction(self.tr(u"Datei öffnen..."), self)
self.actionDateiSpeichern = QtGui.QAction(self.tr(u"Speichern"), self)
self.actionBeenden = QtGui.QAction(self.tr(u"Beenden"), self)
self.actionBeenden.setMenuRole(QtGui.QAction.QuitRole)
menuDatei = self.menuBar().addMenu(self.tr(u"Datei"))
menuDatei.addAction(self.actionDateiOeffnen)
menuDatei.addAction(self.actionDateiSpeichern)
actiongroupAnsichten = QtGui.QActionGroup(self)
#self.actionLinksAusrichten = QtGui.QAction(self.tr(u"Links Ausrichten"), self)
self.actionLinksAusrichten = QtGui.QAction(self.tr(u"Links Ausrichten"), actiongroupAnsichten)
self.actionLinksAusrichten.setCheckable(True)
self.actionLinksAusrichten.setChecked(True)
#self.actionRechtsAusrichten = QtGui.QAction(self.tr(u"Rechts Ausrichten"), self)
self.actionRechtsAusrichten = QtGui.QAction(self.tr(u"Rechts Ausrichten"), actiongroupAnsichten)
self.actionRechtsAusrichten.setCheckable(True)
actiongroupAnsichten.setExclusive(False)
menuAnsicht = menuDatei.addMenu(self.tr(u"Ansicht"))
menuAnsicht.addAction(self.actionLinksAusrichten)
menuAnsicht.addAction(self.actionRechtsAusrichten)
menuDatei.addSeparator()
menuDatei.addAction(self.actionBeenden)
self.actionUeber = QtGui.QAction(self.tr(u"Über Hallo Welt..."), self)
menuUeber = self.menuBar().addMenu(self.tr(u"Hilfe"))
menuUeber.addAction(self.actionUeber)
def createComponents(self):
self.labelHalloWelt = QtGui.QLabel(self.tr(u"Hallo Welt!"));
self.buttonTextAktualisieren = QtGui.QPushButton(self.tr(u"Aktualisieren"));
self.editText = QtGui.QLineEdit()
def createConnects(self):
self.buttonTextAktualisieren.clicked.connect(self.textAktualisieren)
self.editText.textChanged.connect(self.labelHalloWelt.setText)
self.actionUeber.triggered.connect(self.zeigeUeberDialog)
@QtCore.pyqtSlot()
def zeigeUeberDialog(self):
ergebnis, ok = QtGui.QInputDialog.getInt(
self,
self.tr(u"Einfache Addition"),
self.tr(u"Wieviel ist 5 plus 7?"),
0, 0, 100, 1)
if ok:
print ergebnis
#ergebnis, ok = QtGui.QInputDialog.getDouble(
# self,
# self.tr(u"Schwierige Addition"),
# self.tr(u"Wieviel ist 5,6 plus 7,9?"),
# 0, 0, 100, 2)
#if ok:
# print ergebnis
#werte = [ self.tr(u"Ist doch egal"),
# self.tr(u"Dreizehnkommafünf"),
# self.tr(u"Zwei"),
# self.tr(u"Der Mount Everest") ]
#ergebnis, ok = QtGui.QInputDialog.getItem(
# self,
# self.tr(u"Schwierige Addition"),
# self.tr(u"Wieviel ist 5,6 plus 7,9?"),
# werte, 0, False)
#if ok:
# ergebnis = unicode(ergebnis)
# print ergebnis
#eingabe, ok = QtGui.QInputDialog.getText(
# self,
# self.tr(u"Schwierige Frage"),
# self.tr(u"Was ist der höchste Berg der Welt?"),
# QtGui.QLineEdit.Normal, "")
#if ok:
# print eingabe
@QtCore.pyqtSlot()
def textAktualisieren(self):
self.labelHalloWelt.setText(self.editText.text())
def createLayout(self):
layoutZentral = QtGui.QVBoxLayout()
layoutZentral.addWidget(self.labelHalloWelt)
layoutZentral.addWidget(self.editText)
layoutZentral.addWidget(self.buttonTextAktualisieren)
widgetZentral = QtGui.QWidget()
widgetZentral.setLayout(layoutZentral)
self.setCentralWidget(widgetZentral)
if __name__ == "__main__":
main(sys.argv)
| 35.830645 | 104 | 0.63133 |
860e46f2493c52e755d847fb2538b0e9b741ea24
| 47 |
py
|
Python
|
Python/Courses/Crash-Course-on-Python.Google/week-1-Hello-Python/02-hello-world-10-time-in-python.py
|
shihab4t/Books-Code
|
b637b6b2ad42e11faf87d29047311160fe3b2490
|
[
"Unlicense"
] | null | null | null |
Python/Courses/Crash-Course-on-Python.Google/week-1-Hello-Python/02-hello-world-10-time-in-python.py
|
shihab4t/Books-Code
|
b637b6b2ad42e11faf87d29047311160fe3b2490
|
[
"Unlicense"
] | null | null | null |
Python/Courses/Crash-Course-on-Python.Google/week-1-Hello-Python/02-hello-world-10-time-in-python.py
|
shihab4t/Books-Code
|
b637b6b2ad42e11faf87d29047311160fe3b2490
|
[
"Unlicense"
] | null | null | null |
for i in range(10):
print("Hello, World!")
| 15.666667 | 26 | 0.595745 |
86a1fe0ab17b13d9e0646e9ebd782a0e464d4c35
| 1,667 |
py
|
Python
|
Co-Simulation/Sumo/sumo-1.7.0/tools/sumolib/output/convert/gpx.py
|
uruzahe/carla
|
940c2ab23cce1eda1ef66de35f66b42d40865fb1
|
[
"MIT"
] | 4 |
2020-11-13T02:35:56.000Z
|
2021-03-29T20:15:54.000Z
|
sumolib/output/convert/gpx.py
|
KhalidHALBA-GR-NIST/UCEFSUMOV2V
|
4eb7ac761303a171718a10e4131184746bded9fd
|
[
"MIT"
] | 9 |
2020-12-09T02:12:39.000Z
|
2021-02-18T00:15:28.000Z
|
sumolib/output/convert/gpx.py
|
KhalidHALBA-GR-NIST/UCEFSUMOV2V
|
4eb7ac761303a171718a10e4131184746bded9fd
|
[
"MIT"
] | 1 |
2020-11-20T19:31:26.000Z
|
2020-11-20T19:31:26.000Z
|
# Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
# Copyright (C) 2014-2020 German Aerospace Center (DLR) and others.
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License 2.0 which is available at
# https://www.eclipse.org/legal/epl-2.0/
# This Source Code may also be made available under the following Secondary
# Licenses when the conditions for such availability set forth in the Eclipse
# Public License 2.0 are satisfied: GNU General Public License, version 2
# or later which is available at
# https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# @file gpx.py
# @author Jakob Erdmann
# @author Laura Bieker
# @date 2014-02-13
"""
This module includes functions for converting SUMO's fcd-output into
GPX format (http://en.wikipedia.org/wiki/GPS_eXchange_Format)
"""
from __future__ import absolute_import
from collections import defaultdict
def fcd2gpx(inpFCD, outSTRM, ignored):
tracks = defaultdict(list)
for timestep in inpFCD:
for v in timestep.vehicle:
tracks[v.id].append((timestep.time, v.x, v.y))
outSTRM.write('<?xml version="1.0" encoding="UTF-8"?>\n')
outSTRM.write('<gpx version="1.0">\n')
for vehicle in sorted(tracks):
outSTRM.write(" <trk><name>%s</name><trkseg>\n" % vehicle)
for timestamp, lon, lat in tracks[vehicle]:
outSTRM.write(' <trkpt lon="%s" lat="%s"><time>%s</time></trkpt>\n' % (
lon, lat, timestamp))
outSTRM.write(" </trkseg></trk>\n")
outSTRM.write('</gpx>\n')
| 40.658537 | 86 | 0.691662 |
86dbbbf8ed80d3ccc499560ebb2eae3a4eeeeffb
| 1,938 |
py
|
Python
|
python/coursera_python/FUND_OF_COMP_RICE/FUND_OF_COMPUTING_RICE/guess_the_no.py
|
SayanGhoshBDA/code-backup
|
8b6135facc0e598e9686b2e8eb2d69dd68198b80
|
[
"MIT"
] | 16 |
2018-11-26T08:39:42.000Z
|
2019-05-08T10:09:52.000Z
|
python/coursera_python/FUND_OF_COMP_RICE/FUND_OF_COMPUTING_RICE/guess_the_no.py
|
SayanGhoshBDA/code-backup
|
8b6135facc0e598e9686b2e8eb2d69dd68198b80
|
[
"MIT"
] | 8 |
2020-05-04T06:29:26.000Z
|
2022-02-12T05:33:16.000Z
|
python/coursera_python/FUND_OF_COMP_RICE/FUND_OF_COMPUTING_RICE/guess_the_no.py
|
SayanGhoshBDA/code-backup
|
8b6135facc0e598e9686b2e8eb2d69dd68198b80
|
[
"MIT"
] | 5 |
2020-02-11T16:02:21.000Z
|
2021-02-05T07:48:30.000Z
|
# template for "Guess the number" mini-project
# input will come from buttons and an input field
# all output for the game will be printed in the console
import random
import simplegui
import math
global secret_number
chances = 8
num_range = 100
# helper function to start and restart the game
def new_game():
# initialize global variables used in your code here
global secret_number
global num_range
secret_number = random.randint(0,num_range)
global chances
chances = 8
# remove this when you add your code
#pass
# define event handlers for control panel
def range100():
# button that changes the range to [0,100) and starts a new game
global num_range
num_range = 100
# remove this when you add your code
new_game()
def range1000():
# button that changes the range to [0,1000) and starts a new game
global num_range
num_range = 1000
new_game()
def input_guess(guess):
# main game logic goes here
print ""
int_guess = int(guess)
print "Guess was ",int_guess
global secret_number
if int_guess < secret_number:
print "Higher"
elif int_guess > secret_number:
print "Lower"
else:
print "Correct"
print "You Won!"
new_game()
global chances
chances = chances - 1
print "No. of chances remaining : ",chances
if chances == 0:
print "No. of chances left : ",chances
new_game()
# remove this when you add your code
#pass
# create frame
frame = simplegui.create_frame('Guess The no.', 200, 200)
# register event handlers for control elements and start frame
frame.add_button("Range is [0,100) ",range100,200)
frame.add_button("Range is [0,1000) ",range1000,200)
inp = frame.add_input('Enter a guess ', input_guess, 50)
#print inp
# call new_game
new_game()
# always remember to check your completed program against the grading rubric
| 25.84 | 76 | 0.682663 |
86fc5a86ad83611cfd57d5f724076c493072889b
| 951 |
py
|
Python
|
python/svadagenerator.py
|
wittrup/crap
|
a77474588fd54a5a998e24df7b1e6e2ab473ded1
|
[
"MIT"
] | 1 |
2017-12-12T13:58:08.000Z
|
2017-12-12T13:58:08.000Z
|
python/svadagenerator.py
|
wittrup/crap
|
a77474588fd54a5a998e24df7b1e6e2ab473ded1
|
[
"MIT"
] | null | null | null |
python/svadagenerator.py
|
wittrup/crap
|
a77474588fd54a5a998e24df7b1e6e2ab473ded1
|
[
"MIT"
] | 1 |
2019-11-03T10:16:35.000Z
|
2019-11-03T10:16:35.000Z
|
import sys
import csv
from random import choice
from urllib.parse import quote_plus as quote
from difflib import SequenceMatcher
svada = {}
with open('svadagenerator.csv', 'r', encoding='utf-8') as csvfile:
svadareader = csv.reader(csvfile, delimiter=';', quotechar="'")
key = None
for row in svadareader:
if '' in row:
key = row[0] if row[0] is not '' else None
if key is not None:
svada[key] = []
elif key is not None:
svada[key].append(row)
def similar(a, b):
subst = a.lower() in b.lower() or b.lower() in a.lower()
ratio = SequenceMatcher(None, a, b).ratio()
return ratio * (subst + 0.5), a, b
if len(sys.argv) > 1:
arg = sys.argv[1]
key = max(similar(key, arg) for key in svada.keys())[1]
else:
key = choice(list(svada.keys()))
print('"*', ' '.join(choice(svada[key])), '*" - http://www.svadagenerator.no/?type=%s' % quote(key), sep='')
| 30.677419 | 108 | 0.597266 |
07990a87e32f6b7b6dce1e52f48ce1df5ef580d2
| 672 |
py
|
Python
|
7-assets/past-student-repos/LambdaSchool-master/m6/63c1/single_number/single_number.py
|
eengineergz/Lambda
|
1fe511f7ef550aed998b75c18a432abf6ab41c5f
|
[
"MIT"
] | null | null | null |
7-assets/past-student-repos/LambdaSchool-master/m6/63c1/single_number/single_number.py
|
eengineergz/Lambda
|
1fe511f7ef550aed998b75c18a432abf6ab41c5f
|
[
"MIT"
] | null | null | null |
7-assets/past-student-repos/LambdaSchool-master/m6/63c1/single_number/single_number.py
|
eengineergz/Lambda
|
1fe511f7ef550aed998b75c18a432abf6ab41c5f
|
[
"MIT"
] | null | null | null |
'''
Input: a List of integers where every int except one shows up twice
Returns: an integer
'''
def single_number(arr):
# return the single number; all others appear twice
# FIRST: sort array
arr.sort()
# SECOND: loop through each item in array
for x in range(0, len(arr), 2):
# THIRD: if item found again, pass
if arr[x] == arr[x+1]:
x+=1
pass
# FOURTH: else return item
else:
return arr[x]
if __name__ == '__main__':
# Use the main function to test your implementation
arr = [1, 1, 4, 4, 5, 5, 3, 3, 9, 0, 0]
print(f"The odd-number-out is {single_number(arr)}")
| 25.846154 | 67 | 0.581845 |
07d506cb1a420efaef0db626cffc75ec8f1ab2b9
| 4,608 |
py
|
Python
|
__main__1.0.py
|
superbe/PizDB
|
478e9efb4754364a3ceb48a059ec53f8e54f3cbf
|
[
"MIT"
] | null | null | null |
__main__1.0.py
|
superbe/PizDB
|
478e9efb4754364a3ceb48a059ec53f8e54f3cbf
|
[
"MIT"
] | null | null | null |
__main__1.0.py
|
superbe/PizDB
|
478e9efb4754364a3ceb48a059ec53f8e54f3cbf
|
[
"MIT"
] | null | null | null |
import collections
class Arg:
"""
Данные запроса.
"""
def __init__(self, command_line):
"""
Конструктор.
:param command_line: строка запроса.
"""
if command_line is None:
raise ValueError(f'no argument specified: \'{command_line}\'')
self.__command_line = command_line.split(' ', maxsplit=2)
@property
def command(self):
"""
Команда.
:return: команда запроса.
"""
if not self.__command_line[0] or self.__command_line[0] == '':
raise ValueError(f'no command specified: \'{self.__command_line[0].upper()}\'')
return self.__command_line[0].upper()
@property
def name(self):
"""
Наименование данного.
:return: наименование данного запроса.
"""
if len(self.__command_line) < 2:
raise ValueError(f'no argument name specified: \'{self.command}\'')
return self.__command_line[1]
@property
def value(self):
"""
Значение данного
:return: значение данного запроса.
"""
if len(self.__command_line) < 3:
raise ValueError(f'no argument value specified: \'{self.command}\'')
return int(self.__command_line[2])
class PizDB:
"""
Основной класс базы данных.
"""
__version = 'Pizza db. Version 1.0. Small database.'
def __init__(self):
"""
Конструктор класса базы данных.
"""
self.__performed = True
self.__commands = ['SET', 'GET', 'UNSET', 'COUNTS', 'END', 'BEGIN', 'ROLLBACK', 'COMMIT']
self.__storage = {}
def __end(self):
"""
Завершить работу программы.
"""
self.__performed = False
def __set(self, data):
"""
Сохранить объект хранения.
:param data: параметры запроса.
"""
self.__storage[data.name] = data.value
def __get(self, data):
"""
Получить объект хранения.
:param data: параметры запроса.
:return: объект хранения.
"""
return self.__storage[data.name] if data.name in self.__storage else 'NULL'
def __unset(self, data):
"""
Удалить объект хранения.
:param data: параметры запроса.
"""
del self.__storage[data.name]
def __counts(self, data):
"""
Получить количество хранимых данных соответствующих параметрам запроса.
:param data: параметры запроса.
:return: количество хранимых данных соответствующих параметрам запроса.
"""
values = collections.Counter(self.__storage.values())
return values[int(data.name)] if int(data.name) in values.elements() else 0
def __execute(self, data):
"""
Выполнить запрос.
:param data: параметры запроса.
:return: результат выполнения запроса.
"""
if data.command not in self.__commands:
raise NameError(f'entered command does not exist: \'{data.command}\'')
if data.command == 'SET':
self.__set(data)
elif data.command == 'GET':
return self.__get(data)
elif data.command == 'UNSET':
self.__unset(data)
elif data.command == 'COUNTS':
return self.__counts(data)
elif data.command == 'END':
self.__end()
elif data.command == 'BEGIN':
return self.__begin()
elif data.command == 'ROLLBACK':
return self.__rollback()
elif data.command == 'COMMIT':
return self.__commit()
def execute(self, data):
"""
Выполнить запрос.
:param data: параметры запроса.
:return: результат выполнения запроса.
"""
return self.__execute(Arg(data))
@property
def performed(self):
"""
Флаг завершения работы программы.
:return: True - программа продолжает работат, False - завершить работу программы.
"""
return self.__performed
@property
def version(self):
"""
Версия программы.
:return: версия программы.
"""
return self.__version
def run():
"""
Точка входа.
"""
db = PizDB()
print(db.version)
while True:
try:
result = db.execute(input())
if not db.performed:
break
if result is not None:
print(result)
except NameError as error:
print(error)
except ValueError as error:
print(error)
run()
| 26.947368 | 97 | 0.557075 |
ed0177ffc21fe16d95bff7ea7cf54e6bf20f47ad
| 1,522 |
py
|
Python
|
official/recommend/deepfm/postprocess.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 77 |
2021-10-15T08:32:37.000Z
|
2022-03-30T13:09:11.000Z
|
official/recommend/deepfm/postprocess.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 3 |
2021-10-30T14:44:57.000Z
|
2022-02-14T06:57:57.000Z
|
official/recommend/deepfm/postprocess.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 24 |
2021-10-15T08:32:45.000Z
|
2022-03-24T18:45:20.000Z
|
# Copyright 2021 Huawei Technologies Co., Ltd
#
# 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.
# ============================================================================
"""postprocess."""
import os
import numpy as np
from mindspore import Tensor
from src.deepfm import AUCMetric
from src.model_utils.config import config
def get_acc():
''' get accuracy '''
auc_metric = AUCMetric()
files = os.listdir(config.label_path)
batch_size = config.batch_size
for f in files:
rst_file = os.path.join(config.result_path, f.split('.')[0] + '_0.bin')
label_file = os.path.join(config.label_path, f)
logit = Tensor(np.fromfile(rst_file, np.float32).reshape(batch_size, 1))
label = Tensor(np.fromfile(label_file, np.float32).reshape(batch_size, 1))
res = []
res.append(logit)
res.append(logit)
res.append(label)
auc_metric.update(*res)
auc = auc_metric.eval()
print("auc : {}".format(auc))
if __name__ == '__main__':
get_acc()
| 32.382979 | 82 | 0.659001 |
ed4276b1ef3c5461950a2263a96a5660f929c053
| 1,014 |
py
|
Python
|
tests/performance_test/read_write_test_v2.py
|
DockerComposeFiles/ARM
|
b0faddb525ad134ff8c589c370d8e61ab030c216
|
[
"MIT"
] | null | null | null |
tests/performance_test/read_write_test_v2.py
|
DockerComposeFiles/ARM
|
b0faddb525ad134ff8c589c370d8e61ab030c216
|
[
"MIT"
] | null | null | null |
tests/performance_test/read_write_test_v2.py
|
DockerComposeFiles/ARM
|
b0faddb525ad134ff8c589c370d8e61ab030c216
|
[
"MIT"
] | null | null | null |
#!/usr/bin/env python
# Auslesen einer Datei
import sys
import time
print("access-Test start")
# Messen der Lesezeiten
readStart = time.time()
# Testdatei
readFile = "passwords.txt"
# Datei wird in f geoeffnet und gelesen
with open(readFile) as f:
content = f.readlines()
f.close()
# Berechnung der Lesezeiten
readTime = (time.time() - readStart)
print("readTime:")
print(readTime)
# erzwingen der Ausgabe
sys.stdout.flush()
# Messen der Schreibzeiten
writeStart = time.time()
# Schreiben des Inhalts in eine Datei
o = open('passwords_output', 'w')
for line in content:
o.write(line)
o.close()
# Berechnung der Schreibzeiten
writeTime = (time.time() - writeStart)
print("writeTime bevor flush:")
print(writeTime)
# erzwingen der Ausgabe
sys.stdout.flush()
# Erneute Berechnung der Schreibzeit
print("writeTime after flush:")
writeTime = (time.time() - writeStart)
print(writeTime)
print("access-Test end")
# container bleibt für Debug-Zwecke fuer weitere drei minuten in Betrieb
time.sleep(180)
| 19.882353 | 72 | 0.740631 |
b9241776878badd5fc1c4918edff91d696223db1
| 188 |
py
|
Python
|
env/bin/django-admin.py
|
javiervar/SurveyManager
|
bbe2ed356654c32586c587f58c609c8ce014e96b
|
[
"MIT"
] | null | null | null |
env/bin/django-admin.py
|
javiervar/SurveyManager
|
bbe2ed356654c32586c587f58c609c8ce014e96b
|
[
"MIT"
] | null | null | null |
env/bin/django-admin.py
|
javiervar/SurveyManager
|
bbe2ed356654c32586c587f58c609c8ce014e96b
|
[
"MIT"
] | null | null | null |
#!/Users/retina/Documents/escuela/ProgramacionWeb/SurveyManager/env/bin/python3.7
from django.core import management
if __name__ == "__main__":
management.execute_from_command_line()
| 31.333333 | 81 | 0.808511 |
e059ea34b9f46f228d30b009aadc777ef53c3562
| 3,291 |
py
|
Python
|
Website/backend/main.py
|
nachgeradelt/nachgeradelt
|
d45ed6b3c9088d58cdd315e26b932b5da8b5f130
|
[
"MIT"
] | 3 |
2018-06-16T12:49:20.000Z
|
2021-01-26T16:15:11.000Z
|
Website/backend/main.py
|
nachgeradelt/nachgeradelt
|
d45ed6b3c9088d58cdd315e26b932b5da8b5f130
|
[
"MIT"
] | 2 |
2019-11-01T09:36:31.000Z
|
2020-11-20T13:27:42.000Z
|
Website/backend/main.py
|
nachgeradelt/nachgeradelt
|
d45ed6b3c9088d58cdd315e26b932b5da8b5f130
|
[
"MIT"
] | 1 |
2019-04-23T06:46:45.000Z
|
2019-04-23T06:46:45.000Z
|
# -*- coding: utf-8 -*-
from flask import Flask
from databasemanager.DatabaseManager import DatabaseManager
from api.queries.readqueries import SELECTS
from flask import request
from flasgger import Swagger
import yaml
app = Flask(__name__)
configfile = "config.yml"
datamanger = DatabaseManager(configfile=configfile)
@app.route("/v1/city")
def getAllCities():
"""Return all waypoints
---
responses:
200:
description: Return a List of all waypoints form the database)
"""
return datamanger.readTableAsJson(query=SELECTS['allWaypoints'])
@app.route("/v1/tour")
def getAllTours():
"""Return all tours
/v1/tour?start=1 Return all tours with start waypoint 1
/v1/tour?start=1&end=10 Return all tours with start waypoint 1 and includes the waypoint 10
---
parameters:
- name: start
in: query
type: integer
required: false
default: 4
- name: target
in: query
type: integer
required: false
default: 4
responses:
200:
description: /v1/tour Return a List of all tours form the database)
"""
if request.args.get("start") is not None:
if len(request.args) > 1:
start = {'start':request.args.get("start"),"end":request.args.get("target")}
return datamanger.readTableAsJson(query=SELECTS['tourStartEnd'],data=start)
start = {'start':request.args.get("start")}
return datamanger.readTableAsJson(query=SELECTS['tourStart'],data=start)
return datamanger.readTableAsJson(query=SELECTS['allTours'])
@app.route("/v1/city/<id>")
def getCity(id):
"""Return all targets
---
parameters:
- name: id
in: path
type: integer
required: true
default: 4
responses:
200:
description: Return a specific waypoint
"""
return datamanger.readTableAsJson(query=SELECTS['waypoint'],data={'id':id})
@app.route("/v1/tour/<id>")
def getTour(id):
"""Return all targets
---
parameters:
- name: id
in: path
type: integer
required: true
default: 4
responses:
200:
description: Return a specific tour
"""
return datamanger.readTableAsJson(query=SELECTS['tour'],data={'id':id})
@app.route("/v1/targets")
def getAllTargets():
"""Return all targets
---
responses:
200:
description: Return a List of all targets form the database)
"""
return datamanger.readTableAsJson(query=SELECTS['allTargets'])
@app.route("/v1/start")
def getAllStarts():
"""Return all starts
---
responses:
200:
description: Return a List of all starts form the database)
"""
return datamanger.readTableAsJson(query=SELECTS['allStarts'])
@app.route("/v1/qoutes")
def getAllQoutes():
"""Return all qoutes
---
responses:
200:
description: Return a List of all qoutes form the database)
"""
return datamanger.readTableAsJson(query=SELECTS['allQoutes'])
swag = Swagger(app)
if __name__ == "__main__":
with open(configfile, 'r') as ymlfile:
cfg = yaml.load(ymlfile)
config = cfg['backend']
app.run(debug=config['debug'],host=config['host'],port=config['port'])
| 25.913386 | 99 | 0.631419 |
0ef5511a7fec2cea6cfa4109a30be7bf35cb9f2e
| 740 |
py
|
Python
|
src/bo4e/enum/messgroesse.py
|
bo4e/BO4E-python
|
28b12f853c8a496d14b133759b7aa2d6661f79a0
|
[
"MIT"
] | 1 |
2022-03-02T12:49:44.000Z
|
2022-03-02T12:49:44.000Z
|
src/bo4e/enum/messgroesse.py
|
bo4e/BO4E-python
|
28b12f853c8a496d14b133759b7aa2d6661f79a0
|
[
"MIT"
] | 21 |
2022-02-04T07:38:46.000Z
|
2022-03-28T14:01:53.000Z
|
src/bo4e/enum/messgroesse.py
|
bo4e/BO4E-python
|
28b12f853c8a496d14b133759b7aa2d6661f79a0
|
[
"MIT"
] | null | null | null |
# pylint: disable=missing-module-docstring
from bo4e.enum.strenum import StrEnum
class Messgroesse(StrEnum):
"""
Gibt die physikalische Größe an, die gemessen wurde.
"""
STROM = "STROM" #: Strom
SPANNUNG = "SPANNUNG" #: Spannung
WIRKLEISTUNG = "WIRKLEISTUNG" #: Wirkleistung
BLINDLEISTUNG = "BLINDLEISTUNG" #: Blindleistung
DRUCK = "DRUCK" #: Druck
LASTGANG = "LASTGANG" #: Lastgang
LASTPROFIL = "LASTPROFIL" #: Lastprofil
TEMPERATUR = "TEMPERATUR" #: Temperatur
ZZAHL = "ZZAHL" #: Zustandszahl
BRENNWERT = "BRENNWERT" #: Brennwert
GRADTZAGSZAHLEN = "GRADTZAGSZAHLEN" #: Gradtagszahlen
VOLUMENSTROM = "VOLUMENSTROM" #: Volumenstrom
PREISE = "PREISE" #: Preise
| 32.173913 | 58 | 0.666216 |
1635d38cc762a4cff9ae66e25368f4c2a6f855aa
| 4,019 |
py
|
Python
|
research/nlp/senta/src/data/data_set_reader/basic_dataset_reader.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 77 |
2021-10-15T08:32:37.000Z
|
2022-03-30T13:09:11.000Z
|
research/nlp/senta/src/data/data_set_reader/basic_dataset_reader.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 3 |
2021-10-30T14:44:57.000Z
|
2022-02-14T06:57:57.000Z
|
research/nlp/senta/src/data/data_set_reader/basic_dataset_reader.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 24 |
2021-10-15T08:32:45.000Z
|
2022-03-24T18:45:20.000Z
|
# Copyright 2021 Huawei Technologies Co., Ltd
#
# 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.
# ============================================================================
"""
:py:class:`BasicDataSetReader`
"""
import csv
import os
import logging
from collections import namedtuple
import numpy as np
from src.common.register import RegisterSet
@RegisterSet.data_set_reader.register
class BasicDataSetReader():
"""BasicDataSetReader:
"""
def __init__(self, name, fields, config):
self.name = name
self.fields = fields
self.config = config
self.current_example = 0
self.current_epoch = 0
self.num_examples = 0
def data_generator(self):
"""
:return:
"""
assert os.path.isdir(self.config.data_path), "%s must be a directory that stores data files" \
% self.config.data_path
data_files = os.listdir(self.config.data_path)
def wrapper():
"""
:return:
"""
for epoch_index in range(self.config.epoch):
self.current_example = 0
self.current_epoch = epoch_index
for input_file in data_files:
examples = self.read_files(os.path.join(
self.config.data_path, input_file))
if self.config.shuffle:
np.random.shuffle(examples)
for batch_data in self.prepare_batch_data(
examples, self.config.batch_size):
yield batch_data
return wrapper
def read_files(self, file_path, quotechar=None):
"""
:param file_path
:return:
"""
with open(file_path, "r") as f:
try:
examples = []
reader = csv.reader(f, delimiter="\t", quotechar=quotechar)
len_fields = len(self.fields)
field_names = []
for filed in self.fields:
field_names.append(filed.name)
self.Example = namedtuple('Example', field_names)
for line in reader:
if len(line) == len_fields:
example = self.Example(*line)
examples.append(example)
return examples
except IOError:
logging.error("error in read tsv")
def prepare_batch_data(self, examples, batch_size):
"""
prepare_batch_data
"""
batch_records = []
for example in examples:
self.current_example += 1
if len(batch_records) < batch_size:
batch_records.append(example)
else:
yield self.serialize_batch_records(batch_records)
batch_records = [example]
if batch_records:
yield self.serialize_batch_records(batch_records)
def serialize_batch_records(self, batch_records):
"""
:param batch_records:
:return:
"""
return_list = []
example = batch_records[0]
for index in range(len(example._fields)):
text_batch = []
for record in batch_records:
text_batch.append(record[index])
id_list = self.fields[index].field_reader.convert_texts_to_ids(
text_batch)
return_list.extend(id_list)
return return_list
| 31.896825 | 102 | 0.56009 |
bcb7b22d6e146ea466b5a67a79eb8d784b86f301
| 7,819 |
py
|
Python
|
train_gs_gsovspgso.py
|
gdasoulas/PGSO
|
0fa02c626c9c9cf7e046f11ccbfd3bd6dc329a8d
|
[
"MIT"
] | 1 |
2022-03-08T15:23:26.000Z
|
2022-03-08T15:23:26.000Z
|
train_gs_gsovspgso.py
|
gdasoulas/PGSO
|
0fa02c626c9c9cf7e046f11ccbfd3bd6dc329a8d
|
[
"MIT"
] | null | null | null |
train_gs_gsovspgso.py
|
gdasoulas/PGSO
|
0fa02c626c9c9cf7e046f11ccbfd3bd6dc329a8d
|
[
"MIT"
] | null | null | null |
from __future__ import division
from __future__ import print_function
from datetime import datetime
from pathlib import Path
from plot_utils import plot_accs_per_initialization, plot_scalar_params_per_initialization
import time
import argparse
import numpy as np
import os.path as osp
import torch
import torch.nn.functional as F
import torch.optim as optim
import models.mp as mp_models
from torch_geometric.datasets import TUDataset
from torch_geometric.transforms import NormalizeFeatures, OneHotDegree
from torch_geometric.data import DataLoader
from plot_utils import plot_accs_per_use
# Training settings
parser = argparse.ArgumentParser()
parser.add_argument('--datadir', type=str, default='./data/',
help='Directory of datasets; default is ./data/')
parser.add_argument('--dataset', type=str, default='MUTAG',
help='Dataset name; default is Mutag')
parser.add_argument('--model', type=str, default='GIN',
help='Model to be trained; default is GIN')
parser.add_argument('--device', type=int, default=-1,
help='Set CUDA device number; if set to -1, disables cuda.')
parser.add_argument('--fastmode', action='store_true', default=False,
help='Validate during training pass.')
parser.add_argument('--seed', type=int, default=42, help='Random seed.')
parser.add_argument('--epochs', type=int, default=200,
help='Number of epochs to train.')
parser.add_argument('--batch_size', type=int, default=32,
help='Size of batch.')
parser.add_argument('--lr', type=float, default=0.01,
help='Initial learning rate.')
parser.add_argument('--lr_patience', type=float, default=50,
help='Number of epochs waiting for the next lr decay.')
parser.add_argument('--weight_decay', type=float, default=5e-4,
help='Weight decay (L2 loss on parameters).')
parser.add_argument('--hidden', type=int, default=16,
help='Number of hidden units.')
parser.add_argument('--num_layers', type=int, default=2,
help='Number of aggregation layers.')
parser.add_argument('--dropout', type=float, default=0.5,
help='Dropout rate (1 - keep probability).')
parser.add_argument('--outdir', type=str, default='./exps/',
help='Directory of experiments output; default is ./exps/')
args = parser.parse_args()
expfolder = osp.join(args.outdir, args.dataset+'_gsovspgso')
expfolder = osp.join(expfolder,datetime.now().strftime("%Y%m%d_%H%M%S"))
Path(expfolder).mkdir(parents=True, exist_ok=True)
device = torch.device('cuda:'+str(args.device)) if torch.cuda.is_available() else torch.device('cpu')
torch.manual_seed(args.seed)
np.random.seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
# np.random.seed(args.seed)
# torch.manual_seed(args.seed)
# if args.device > 0:
# torch.cuda.manual_seed(args.seed)
# pre_transform = NormalizeFeatures()
pre_transform = None
if args.dataset.startswith('IMDB'):
pre_transform = OneHotDegree(max_degree=150)
dataset = TUDataset(args.datadir, name=args.dataset, pre_transform=pre_transform).shuffle()
test_dataset = dataset[:len(dataset) // 10]
train_dataset = dataset[len(dataset) // 10:]
test_loader = DataLoader(test_dataset, batch_size=args.batch_size)
train_loader = DataLoader(train_dataset, batch_size=args.batch_size)
print(dataset.data)
# Model and optimizer
# for genlap_init in ['GCN', 'all_zeros', 'SymLaplacian', 'RWLaplacian', 'Adjacency']:
for genlap_use in [True,False]:
if 'GIN' in args.model:
model = getattr(mp_models, 'GIN_graph_classification')(input_dim=dataset.num_features,
hidden_dim=args.hidden,
output_dim=dataset.num_classes,
num_layers=args.num_layers,
dropout=args.dropout, genlap_use=genlap_use, genlap_init = 'GCN').to(device)
elif 'GCN' in args.model:
model = getattr(conv_models, args.model)(input_dim=dataset.num_features,
hidden_dim=args.hidden,
output_dim=dataset.num_classes,
num_layers=args.num_layers,
dropout=args.dropout, adj=adj).to(device)
else:
print('No such model!')
exit()
# optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=0.95)
exp_param_list = ['gnn_layers.'+ str(i)+ '.p' for i in range(1,args.num_layers+1)]
exp_param_list += ['gnn_layers.'+ str(i)+ '.q' for i in range(1,args.num_layers+1)]
exp_param_list += ['gnn_layers.'+ str(i)+ '.r' for i in range(1,args.num_layers+1)]
exp_params = list(filter(lambda kv: kv[0] in exp_param_list, model.named_parameters()))
base_params = list(filter(lambda kv: kv[0] not in exp_param_list, model.named_parameters()))
exp_params = [param[1] for param in exp_params]
base_params = [param[1] for param in base_params]
optimizer = optim.Adam([
{'params': base_params, 'lr':args.lr},
{'params': exp_params, 'lr': 0.005}
], lr=args.lr, weight_decay=args.weight_decay)
# optimizer = optim.Adam(model.parameters(),
# lr=args.lr, weight_decay=args.weight_decay)
criterion = torch.nn.CrossEntropyLoss()
lr_scheduler = None
if args.lr_patience > 0:
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.lr_patience, gamma=0.1)
# lr_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=opt.lr_patience, verbose=True)
def train(epoch):
model.train()
loss_all = 0
for data in train_loader:
data = data.to(device)
# adj = to_dense_adj(to_undirected(data.edge_index)).squeeze()
optimizer.zero_grad()
output = model(data.x, data.edge_index, data.batch)
loss = criterion(output, data.y)
loss.backward()
loss_all += loss.item() * data.num_graphs
optimizer.step()
return loss_all / len(train_dataset)
def test(loader):
model.eval()
correct = 0
for data in loader:
data = data.to(device)
# adj = to_dense_adj(to_undirected(data.edge_index)).squeeze()
output = model(data.x, data.edge_index, data.batch)
pred = output.max(dim=1)[1]
correct += pred.eq(data.y).sum().item()
return correct / len(loader.dataset)
# Train model
t_total = time.time()
states = []
for epoch in range(1,args.epochs+1):
train_loss = train(epoch)
train_acc = test(train_loader)
test_acc = test(test_loader)
whole_state = {
'epoch': epoch,
'model_state_dict': {key:val.clone() for key,val in model.state_dict().items()},
'optimizer_state_dict': optimizer.state_dict(),
'loss_train': train_loss,
'acc_train': train_acc,
'acc_val': test_acc,
}
states.append(whole_state)
print('Epoch: {:03d}, Train Loss: {:.7f}, '
'Train Acc: {:.7f}, Test Acc: {:.7f}'.format(epoch, train_loss,
train_acc, test_acc))
if args.lr_patience > 0:
lr_scheduler.step()
torch.save(states, osp.join(expfolder,f'model_states_gso_use={genlap_use}.pth'))
# plot_scalar_params_per_initialization(expfolder)
# plot_accs_per_initialization(expfolder)
plot_accs_per_use(expfolder)
| 42.264865 | 119 | 0.628981 |
e683c37d822a90779beaf1eee98c262316bd6a19
| 3,136 |
py
|
Python
|
project/views/event_suggestion.py
|
DanielGrams/gsevp
|
e94034f7b64de76f38754b56455e83092378261f
|
[
"MIT"
] | 1 |
2021-06-01T14:49:18.000Z
|
2021-06-01T14:49:18.000Z
|
project/views/event_suggestion.py
|
DanielGrams/gsevp
|
e94034f7b64de76f38754b56455e83092378261f
|
[
"MIT"
] | 286 |
2020-12-04T14:13:00.000Z
|
2022-03-09T19:05:16.000Z
|
project/views/event_suggestion.py
|
DanielGrams/gsevpt
|
a92f71694388e227e65ed1b24446246ee688d00e
|
[
"MIT"
] | null | null | null |
from flask import flash, redirect, render_template, url_for
from flask_babelex import gettext
from flask_security import auth_required
from sqlalchemy.exc import SQLAlchemyError
from project import app, db
from project.access import access_or_401
from project.forms.event_suggestion import RejectEventSuggestionForm
from project.models import EventReviewStatus, EventSuggestion
from project.views.utils import flash_errors, handleSqlError, send_mail
@app.route("/event_suggestion/<int:event_suggestion_id>/review")
@auth_required()
def event_suggestion_review(event_suggestion_id):
event_suggestion = EventSuggestion.query.get_or_404(event_suggestion_id)
access_or_401(event_suggestion.admin_unit, "event:verify")
form = RejectEventSuggestionForm(obj=event_suggestion)
return render_template(
"event_suggestion/review.html",
admin_unit=event_suggestion.admin_unit,
event_suggestion=event_suggestion,
form=form,
)
@app.route(
"/event_suggestion/<int:event_suggestion_id>/reject", methods=("GET", "POST")
)
@auth_required()
def event_suggestion_reject(event_suggestion_id):
event_suggestion = EventSuggestion.query.get_or_404(event_suggestion_id)
access_or_401(event_suggestion.admin_unit, "event:verify")
if event_suggestion.verified:
return redirect(
url_for("event_suggestion_review", event_suggestion_id=event_suggestion.id)
)
form = RejectEventSuggestionForm(obj=event_suggestion)
if form.validate_on_submit():
form.populate_obj(event_suggestion)
event_suggestion.review_status = EventReviewStatus.rejected
if event_suggestion.rejection_resaon == 0:
event_suggestion.rejection_resaon = None
try:
db.session.commit()
send_event_suggestion_review_status_mail(event_suggestion)
flash(gettext("Event suggestion successfully rejected"), "success")
return redirect(
url_for(
"manage_admin_unit_event_reviews", id=event_suggestion.admin_unit_id
)
)
except SQLAlchemyError as e:
db.session.rollback()
flash(handleSqlError(e), "danger")
else:
flash_errors(form)
return render_template(
"event_suggestion/reject.html",
form=form,
admin_unit=event_suggestion.admin_unit,
event_suggestion=event_suggestion,
)
@app.route("/event_suggestion/<int:event_suggestion_id>/review_status")
def event_suggestion_review_status(event_suggestion_id):
event_suggestion = EventSuggestion.query.get_or_404(event_suggestion_id)
return render_template(
"event_suggestion/review_status.html", event_suggestion=event_suggestion
)
def send_event_suggestion_review_status_mail(event_suggestion):
if event_suggestion.contact_email and event_suggestion.contact_email_notice:
send_mail(
event_suggestion.contact_email,
gettext("Event review status updated"),
"review_status_notice",
event_suggestion=event_suggestion,
)
| 34.461538 | 88 | 0.732462 |
5d6c7585740faf0ae43c8e9d5a4f810f20b5e4b5
| 2,064 |
py
|
Python
|
official/cv/simclr/src/simclr_model.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 77 |
2021-10-15T08:32:37.000Z
|
2022-03-30T13:09:11.000Z
|
official/cv/simclr/src/simclr_model.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 3 |
2021-10-30T14:44:57.000Z
|
2022-02-14T06:57:57.000Z
|
official/cv/simclr/src/simclr_model.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 24 |
2021-10-15T08:32:45.000Z
|
2022-03-24T18:45:20.000Z
|
# Copyright 2021 Huawei Technologies Co., Ltd
#
# 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.
# ============================================================================
"""SimCLR Model class."""
from mindspore import nn
from .resnet import _fc
class Identity(nn.Cell):
def construct(self, x):
return x
class SimCLR(nn.Cell):
"""
SimCLR Model.
"""
def __init__(self, encoder, project_dim, n_features):
super(SimCLR, self).__init__()
self.encoder = encoder
self.n_features = n_features
self.encoder.end_point = Identity()
self.dense1 = _fc(self.n_features, self.n_features)
self.relu = nn.ReLU()
self.end_point = _fc(self.n_features, project_dim)
# Projector MLP.
def projector(self, x):
out = self.dense1(x)
out = self.relu(out)
out = self.end_point(out)
return out
def construct(self, x_i, x_j):
h_i = self.encoder(x_i)
z_i = self.projector(h_i)
h_j = self.encoder(x_j)
z_j = self.projector(h_j)
return h_i, h_j, z_i, z_j
def inference(self, x):
h = self.encoder(x)
return h
class SimCLR_Classifier(nn.Cell):
"""
SimCLR with Classifier.
"""
def __init__(self, encoder, classifier):
super(SimCLR_Classifier, self).__init__()
self.encoder = encoder
self.classifier = classifier
self.softmax = nn.Softmax()
def construct(self, x):
y = self.encoder(x)
z = self.classifier(y)
return self.softmax(z)
| 29.913043 | 78 | 0.622578 |
ab5ba477558ea6c717c8aa143e504fe04078bfa4
| 937 |
py
|
Python
|
IVTa/2014/SHCHUKIN_F_O/task_2_30.py
|
YukkaSarasti/pythonintask
|
eadf4245abb65f4400a3bae30a4256b4658e009c
|
[
"Apache-2.0"
] | 1 |
2021-04-02T17:43:48.000Z
|
2021-04-02T17:43:48.000Z
|
IVTa/2014/SHCHUKIN_F_O/task_2_30.py
|
YukkaSarasti/pythonintask
|
eadf4245abb65f4400a3bae30a4256b4658e009c
|
[
"Apache-2.0"
] | null | null | null |
IVTa/2014/SHCHUKIN_F_O/task_2_30.py
|
YukkaSarasti/pythonintask
|
eadf4245abb65f4400a3bae30a4256b4658e009c
|
[
"Apache-2.0"
] | 1 |
2020-12-18T18:04:49.000Z
|
2020-12-18T18:04:49.000Z
|
# Задача 1. Вариант 30.
'''
Напишите программу, которая будет выводить на экран
наиболее понравившееся вам высказывание, автором которого
является Али ибн Абу Талиб. Не забудьте о том, что автор
должен быть упомянут на отдельной строке.
'''
# SHCHUKIN F. O.
# 24.02.2016
from sys import stdout as c
from time import sleep
quote = dict(
text='Самое большое богатство - разум.\nСамое большое наследство \
- воспитанность.\nСамая большая нищета - невежество.\n\
(Нет лучшего богатства, чем мудрость;\nнет страшнее нищеты, \
чем невежество;\nнет лучшего наследия, чем воспитанность\nи \
лучшей защиты, чем совесть.)',
author='Али ибн Абу Талиб'
)
sleep(1.0)
def printer(text):
for char in text:
c.write(char)
c.flush()
pause = 0.8 if char in ('-', '.', ',', ';') else 0.03
sleep(pause)
printer(quote['text'])
c.write('\n'*2 + '\t'*4)
printer(quote['author'])
c.write('\n'*2)
input('ok')
| 24.657895 | 70 | 0.677695 |
ab60ee58045fd3a398bcd41af48b9ce549d6429f
| 5,871 |
py
|
Python
|
prototype/examples/accessing_api/api.py
|
LernmodulController/LernmodulController-LernmodulControllerDocumentation
|
4d0cb3dcac01676f6a97df8f558095a27a4296af
|
[
"MIT"
] | null | null | null |
prototype/examples/accessing_api/api.py
|
LernmodulController/LernmodulController-LernmodulControllerDocumentation
|
4d0cb3dcac01676f6a97df8f558095a27a4296af
|
[
"MIT"
] | null | null | null |
prototype/examples/accessing_api/api.py
|
LernmodulController/LernmodulController-LernmodulControllerDocumentation
|
4d0cb3dcac01676f6a97df8f558095a27a4296af
|
[
"MIT"
] | 1 |
2021-09-26T12:09:52.000Z
|
2021-09-26T12:09:52.000Z
|
from flask import Flask, make_response, request
from distutils.util import strtobool
import requests
import os
import logging
from template_engine import TemplateEngine
from ws_proxy import WebsocketProxy, add_token
app = Flask(__name__)
class KubernetesAPI:
def __init__(self, base_uri, service_account_token=None,
cacert=None, insecure_ssl=False):
if service_account_token is None:
logging.warning("No service account token.")
if cacert is None:
logging.warning("No cacert.")
self.base_uri = base_uri
self.service_account_token = service_account_token
if insecure_ssl:
self.verify = False
elif cacert is None:
self.verify = True
else:
self.verify = cacert
def get(self, address):
headers = {"Authorization": f"Bearer {self.service_account_token}"}
response = requests.get(self.base_uri + address, headers=headers, verify=self.verify)
return response.text
def get_vmis(self, namespace=None):
if namespace is None:
namespace = "default"
address = f"/apis/kubevirt.io/v1alpha3/namespaces/{namespace}/virtualmachineinstances/"
return self.get(address)
def post(self, address, data):
headers = {"Authorization": f"Bearer {self.service_account_token}",
"Content-Type": "application/yaml"}
response = requests.post(self.base_uri + address, data=data, headers=headers, verify=self.verify)
return response.text
def create_vmi(self, data, namespace=None):
if namespace is None:
namespace = "default"
address = f"/apis/kubevirt.io/v1alpha3/namespaces/{namespace}/virtualmachineinstances/"
return self.post(address, data)
def delete(self, address):
headers = {"Authorization": f"Bearer {self.service_account_token}"}
response = requests.delete(self.base_uri + address, headers=headers, verify=self.verify)
return response.text
def delete_vmi(self, vmi_name, namespace=None):
if namespace is None:
namespace = "default"
address = f"/apis/kubevirt.io/v1alpha3/namespaces/{namespace}/virtualmachineinstances/{vmi_name}"
return self.delete(address)
def create_kubernetes_api_default(local_dev_mode: False):
kubernetes_service_host = os.environ["KUBERNETES_SERVICE_HOST"]
kubernetes_service_port = os.environ["KUBERNETES_SERVICE_PORT"]
cacert = None
service_account_token = None
if not local_dev_mode:
with open('/var/run/secrets/kubernetes.io/serviceaccount/token', 'r') as reader:
service_account_token = reader.read()
cacert = '/var/run/secrets/kubernetes.io/serviceaccount/ca.crt'
base_uri = f"https://{kubernetes_service_host}:{kubernetes_service_port}"
else:
base_uri = f"http://{kubernetes_service_host}:{kubernetes_service_port}"
k8s_api = KubernetesAPI(base_uri, service_account_token, cacert)
return k8s_api
KUBERNETES_API = None
@app.route("/")
def hello_world():
return "<p>Hello, World!</p>"
@app.route("/vmis")
def get_vmis():
r = KUBERNETES_API.get_vmis()
ret = make_response(r)
ret.mimetype = 'application/json'
return ret
@app.route("/create_vmi")
def create_vmi():
vm_image = request.args.get('vm_image', type=str)
vmi_name = request.args.get('vmi_name', type=str)
namespace = "default"
template_data = {"cores": 3, "memory": "3G",
"vm_image": vm_image, "vmi_name": vmi_name,
"namespace": namespace}
template_engine = TemplateEngine(template_data)
data = template_engine.replace('vmi_template.yaml')
r = KUBERNETES_API.create_vmi(data, namespace)
ret = make_response(r)
ret.mimetype = 'application/json'
return ret
@app.route("/delete_vmi")
def delete_vmi():
vmi_name = request.args.get('vmi_name', type=str)
namespace = "default"
r = KUBERNETES_API.delete_vmi(vmi_name, namespace)
ret = make_response(r)
ret.mimetype = 'application/json'
return ret
@app.route("/add_credentials")
def add_credentials():
user = request.args.get('user', type=str)
token = request.args.get('token', type=str)
vmi_name = request.args.get('vmi_name', type=str)
valid = add_token(token, user, vmi_name)
if valid:
return "Added credentials."
else:
return "Adding credentials not possible.", 400
conf = {
"websocket_remote_url": "ws://localhost:8001",
"websocket_api_path": "/apis/subresources.kubevirt.io/v1alpha3/namespaces/default/virtualmachineinstances/{vmi_name}/vnc",
"ws_proxy_host": "0.0.0.0",
"ws_proxy_port": 5001,
"flask_host": "0.0.0.0",
"flask_port": 5000,
"local_dev_mode": False,
}
def run(conf):
wp = WebsocketProxy(conf["websocket_remote_url"], conf["websocket_api_path"], conf["local_dev_mode"])
wp.run_in_thread(conf["ws_proxy_host"], conf["ws_proxy_port"])
app.run(host=conf["flask_host"], port=conf["flask_port"], debug=False)
wp.stop_thread()
logging.info("Shutdown complete")
def main():
global KUBERNETES_API
# local dev mode disables reading the kubernetes service
# account files and assumes you are running kubectl proxy
local_dev_mode_str = os.environ.get("LOCAL_DEV_MODE", "False")
conf["local_dev_mode"] = bool(strtobool(local_dev_mode_str))
if not conf["local_dev_mode"]:
kubernetes_service_host = os.environ["KUBERNETES_SERVICE_HOST"]
kubernetes_service_port = os.environ["KUBERNETES_SERVICE_PORT"]
conf["websocket_remote_url"] = "wss://" + kubernetes_service_host + ":" + str(kubernetes_service_port)
KUBERNETES_API = create_kubernetes_api_default(conf["local_dev_mode"])
run(conf)
if __name__ == '__main__':
main()
| 34.739645 | 126 | 0.682678 |
db623f101c398bdb2a613e36b708f9339a75d511
| 1,320 |
py
|
Python
|
recherche_youtube.py
|
K-A-R-I-M/SonKa
|
3ff5b95afa2f3c968cdaf670f27e6abc813907e4
|
[
"MIT"
] | 1 |
2020-07-30T15:46:06.000Z
|
2020-07-30T15:46:06.000Z
|
recherche_youtube.py
|
K-A-R-I-M/SonKa
|
3ff5b95afa2f3c968cdaf670f27e6abc813907e4
|
[
"MIT"
] | null | null | null |
recherche_youtube.py
|
K-A-R-I-M/SonKa
|
3ff5b95afa2f3c968cdaf670f27e6abc813907e4
|
[
"MIT"
] | null | null | null |
import asyncio
from pyppeteer import launch
from time import sleep
class RechercheLienYoutube():
def __init__(self):
self.nb_recherche = 0
async def recherche_lien(self, url):
browser = await launch()
page = await browser.newPage()
await page.goto(url)
tag = 'h3 > a'
element = await page.querySelector(tag)
title = await page.evaluate('(element) => element.textContent', element)
sleep(1)
await page.click(tag)
url_page = page.url
await browser.close()
return title, url_page
def _formatClair(self, txt):
#rendre compatible le texte avec le lien youtube de recherche
xtx = ""
cSpe = " "
for c in range(len(txt)):
if cSpe == txt[c]:
xtx += "+"
else:
xtx += txt[c]
return xtx
def recherche(self, txt):
txt = self._formatClair(txt)
url = "https://www.youtube.com/results?search_query="+txt
print('Ouverture de', url)
titre, url_trouv = asyncio.get_event_loop().run_until_complete(self.recherche_lien(url))
return titre, url_trouv
def getNbRecheche(self):
return self.nb_recherche
def addNbRecheche(self):
self.nb_recherche += 1
| 21.639344 | 96 | 0.584848 |
dbbf21828e509dabf6d5e3e79482681d70c069fa
| 3,872 |
py
|
Python
|
Imagenes/Stefan/2D/CasoB/Allpost.py
|
efogliatto/Tesis
|
058fa0c2e23cd538621d17d41bb216a4db4d211a
|
[
"CC0-1.0"
] | null | null | null |
Imagenes/Stefan/2D/CasoB/Allpost.py
|
efogliatto/Tesis
|
058fa0c2e23cd538621d17d41bb216a4db4d211a
|
[
"CC0-1.0"
] | null | null | null |
Imagenes/Stefan/2D/CasoB/Allpost.py
|
efogliatto/Tesis
|
058fa0c2e23cd538621d17d41bb216a4db4d211a
|
[
"CC0-1.0"
] | null | null | null |
import vdWColumn as vdw
import vdWColumn.postLBRun as post
import numpy as np
import matplotlib.pyplot as plt
import argparse
import os
from paraview.simple import *
import stefanFlow as stf
import matplotlib.ticker as mticker
import locale
# Extraccion de arreglos en linea desde el centro (xmax/2) hasta xmax
def get_array_from_case( lbmcase, time, array_name = 'rho', xmax = 600.0 ):
# Carga del caso con arrays para rho y p
lbmcase.PointArrays = [array_name]
# Filtro Plot over line
POL = PlotOverLine(Input=lbmcase, Source='High Resolution Line Source')
POL.Tolerance = 2.0e-16
POL.Source.Point1 = [1.0, 0.0, 0.0]
POL.Source.Point2 = [1.0, xmax, 0.0]
POL.Source.Resolution = (int)(xmax)
# Alocacion de arreglos
Array = np.array( range(POL.Source.Resolution+1), dtype=np.float64() )
# Extraccion del ultimo paso de tiempo
POL.UpdatePipeline( time )
POLf = servermanager.Fetch(POL)
for id in range( POL.Source.Resolution+1 ):
Array[id] = POLf.GetPointData().GetArray(array_name).GetValue(id)
return Array
if __name__ == "__main__":
# Argumentos de consola
parser = argparse.ArgumentParser(description='Post procesamiento del frente de evaporación')
parser.add_argument('-n', help='Rango de casos', type = int, default = 0)
parser.add_argument('-png', help='Imagen en formato png', action='store_true')
args = parser.parse_args()
# Propiedades de la solucion analitica
Tw = [0.0682597, 0.0727599, 0.0772602]
dxi = [15, 7, 6]
aa = 1
bb = 4
cv = 4
Tc = 8.0 * aa / (27. * bb)
Tr = 0.8
q3 = 1.7142857
alpha1 = -2
alpha2 = 2
# Perfiles de densidad
colorList = ['r', 'b', 'g', 'y']
mklist = ['o', 's', '^', '*']
with plt.style.context( ('thesis_classic') ):
for i, mk in zip( range( args.n + 1 ), mklist ):
# Solucion LB
lbmcase = EnSightReader( CaseFileName='Caso{}/lbm.case'.format(i) )
times = lbmcase.TimestepValues
xint = []
for t in times:
if t != 0.0:
lbRho = get_array_from_case( lbmcase, t, array_name = 'rho', xmax = 600.0 )
xcross, ll, rl = post.interphase( lbRho )
xint.append(xcross)
else:
xint.append( dxi[i] )
plt.plot( [t/1e6 for t in times], [(x-dxi[i])/600 for x in xint], linestyle='-', color='k' )
# Solucion analitica
hl, hg = vdw.latentHeat(Tr*Tc, aa, bb)
St = cv * (Tw[i] - Tr*Tc) / (hg - hl)
beta = stf.betaConstant(St, 0.)
alpha = (1./q3 - 0.5)*( 4. + 3.*alpha1 + 2.*alpha2) / 6.
tplot = times[0::2]
locale.setlocale(locale.LC_ALL, "es_AR.UTF-8")
plt.plot( [t/1e6 for t in tplot], [ 2 * beta * (alpha**0.5) * (t**0.5015) / 600 for t in tplot],
linestyle = 'None',
mec = colorList[i],
marker = mk,
mfc = 'None',
label = r'$St = {:.1n}$'.format(St))
# Ejes y leyenda
plt.ylabel(r'$x_i \, / \, L$')
plt.xlabel(r'$t \, \cdot 10^{-6}$')
plt.legend( loc='best', numpoints = 1 )
# Guardado
if args.png == True:
plt.savefig( 'Stefan_m2_2.png', format='png', bbox_inches = 'tight', dpi=600 )
else:
plt.savefig( 'Stefan_m2_2.pdf', format='pdf', bbox_inches = 'tight', dpi=600 )
plt.gcf().clear()
| 18.178404 | 109 | 0.512913 |
f42776ecc0e1b167e8f721f7a692e9f5c4a06e70
| 3,045 |
py
|
Python
|
src/bo4e/com/angebotsvariante.py
|
bo4e/BO4E-python
|
28b12f853c8a496d14b133759b7aa2d6661f79a0
|
[
"MIT"
] | 1 |
2022-03-02T12:49:44.000Z
|
2022-03-02T12:49:44.000Z
|
src/bo4e/com/angebotsvariante.py
|
bo4e/BO4E-python
|
28b12f853c8a496d14b133759b7aa2d6661f79a0
|
[
"MIT"
] | 21 |
2022-02-04T07:38:46.000Z
|
2022-03-28T14:01:53.000Z
|
src/bo4e/com/angebotsvariante.py
|
bo4e/BO4E-python
|
28b12f853c8a496d14b133759b7aa2d6661f79a0
|
[
"MIT"
] | null | null | null |
"""
Contains Angebotsvariante and corresponding marshmallow schema for de-/serialization
"""
from datetime import datetime
from typing import List, Optional
import attr
from marshmallow import fields
from marshmallow_enum import EnumField # type:ignore[import]
from bo4e.com.angebotsteil import Angebotsteil, AngebotsteilSchema
from bo4e.com.betrag import Betrag, BetragSchema
from bo4e.com.com import COM, COMSchema
from bo4e.com.menge import Menge, MengeSchema
from bo4e.enum.angebotsstatus import Angebotsstatus
from bo4e.validators import check_list_length_at_least_one
# pylint: disable=too-few-public-methods
@attr.s(auto_attribs=True, kw_only=True)
class Angebotsvariante(COM):
"""
Führt die verschiedenen Ausprägungen der Angebotsberechnung auf
.. HINT::
`Angebotsvariante JSON Schema <https://json-schema.app/view/%23?url=https://raw.githubusercontent.com/Hochfrequenz/BO4E-python/main/json_schemas/com/AngebotsvarianteSchema.json>`_
"""
# required attributes
#: Gibt den Status eines Angebotes an.
angebotsstatus: Angebotsstatus = attr.ib(validator=attr.validators.instance_of(Angebotsstatus))
#: Datum der Erstellung der Angebotsvariante
erstellungsdatum: datetime = attr.ib(validator=attr.validators.instance_of(datetime))
#: Bis zu diesem Zeitpunkt gilt die Angebotsvariante
bindefrist: datetime = attr.ib(validator=attr.validators.instance_of(datetime))
teile: List[Angebotsteil] = attr.ib(
validator=[
attr.validators.deep_iterable(
member_validator=attr.validators.instance_of(Angebotsteil),
iterable_validator=attr.validators.instance_of(list),
),
check_list_length_at_least_one,
]
)
"""
Angebotsteile werden im einfachsten Fall für eine Marktlokation oder Lieferstellenadresse erzeugt.
Hier werden die Mengen und Gesamtkosten aller Angebotspositionen zusammengefasst.
Eine Variante besteht mindestens aus einem Angebotsteil.
"""
# optional attributes
#: Aufsummierte Wirkarbeitsmenge aller Angebotsteile
gesamtmenge: Optional[Menge] = attr.ib(
default=None, validator=attr.validators.optional(attr.validators.instance_of(Menge))
)
# todo: write a validator for this: https://github.com/Hochfrequenz/BO4E-python/issues/320
#: Aufsummierte Kosten aller Angebotsteile
gesamtkosten: Optional[Betrag] = attr.ib(
default=None, validator=attr.validators.optional(attr.validators.instance_of(Betrag))
)
class AngebotsvarianteSchema(COMSchema):
"""
Schema for de-/serialization of Angebotsvariante
"""
class_name = Angebotsvariante
# required attributes
angebotsstatus = EnumField(Angebotsstatus)
erstellungsdatum = fields.DateTime()
bindefrist = fields.DateTime()
teile = fields.List(fields.Nested(AngebotsteilSchema))
# optional attributes
gesamtmenge = fields.Nested(MengeSchema, allow_none=True)
gesamtkosten = fields.Nested(BetragSchema, allow_none=True)
| 37.134146 | 187 | 0.750411 |
f4913c115887be8ce1bc91f82d8a413f1caed0b5
| 2,572 |
py
|
Python
|
sensoro/writeRFID/Read.py
|
bhemsen/bigBrother
|
260f927fdcf6b6d43ec79a7a7ea4ba61a44c5e6d
|
[
"MIT"
] | null | null | null |
sensoro/writeRFID/Read.py
|
bhemsen/bigBrother
|
260f927fdcf6b6d43ec79a7a7ea4ba61a44c5e6d
|
[
"MIT"
] | null | null | null |
sensoro/writeRFID/Read.py
|
bhemsen/bigBrother
|
260f927fdcf6b6d43ec79a7a7ea4ba61a44c5e6d
|
[
"MIT"
] | null | null | null |
#!/usr/bin/env python
# -*- coding: utf8 -*-
#
# Copyright 2014,2018 Mario Gomez <[email protected]>
#
# This file is part of MFRC522-Python
# MFRC522-Python is a simple Python implementation for
# the MFRC522 NFC Card Reader for the Raspberry Pi.
#
# MFRC522-Python is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# MFRC522-Python is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with MFRC522-Python. If not, see <http://www.gnu.org/licenses/>.
#
import RPi.GPIO as GPIO
import MFRC522
import signal
continue_reading = True
# Capture SIGINT for cleanup when the script is aborted
def end_read(signal,frame):
global continue_reading
print("Ctrl+C captured, ending read.")
continue_reading = False
GPIO.cleanup()
# Hook the SIGINT
signal.signal(signal.SIGINT, end_read)
# Create an object of the class MFRC522
MIFAREReader = MFRC522.MFRC522()
# Welcome message
print("Welcome to the MFRC522 data read example")
print("Press Ctrl-C to stop.")
# This loop keeps checking for chips. If one is near it will get the UID and authenticate
while continue_reading:
# Scan for cards
(status,TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL)
# If a card is found
if status == MIFAREReader.MI_OK:
print("Card detected")
# Get the UID of the card
(status,uid) = MIFAREReader.MFRC522_Anticoll()
# If we have the UID, continue
if status == MIFAREReader.MI_OK:
# Print UID
print("Card read UID: {},{},{},{}".format(uid[0], uid[1], uid[2], uid[3]))
# This is the default key for authentication
key = [0xFF,0xFF,0xFF,0xFF,0xFF,0xFF]
# Select the scanned tag
MIFAREReader.MFRC522_SelectTag(uid)
# Authenticate
status = MIFAREReader.MFRC522_Auth(MIFAREReader.PICC_AUTHENT1A, 8, key, uid)
# Check if authenticated
if status == MIFAREReader.MI_OK:
MIFAREReader.MFRC522_Read(8)
MIFAREReader.MFRC522_StopCrypto1()
else:
print("Authentication error")
| 31.365854 | 89 | 0.68818 |
be9d4b08e61f0853636ef700600d83c6e1cf9181
| 178 |
py
|
Python
|
Online-Judges/CodingBat/Python/Logic-02/Logic_2-05-round_sum.py
|
shihab4t/Competitive-Programming
|
e8eec7d4f7d86bfa1c00b7fbbedfd6a1518f19be
|
[
"Unlicense"
] | 3 |
2021-06-15T01:19:23.000Z
|
2022-03-16T18:23:53.000Z
|
Online-Judges/CodingBat/Python/Logic-02/Logic_2-05-round_sum.py
|
shihab4t/Competitive-Programming
|
e8eec7d4f7d86bfa1c00b7fbbedfd6a1518f19be
|
[
"Unlicense"
] | null | null | null |
Online-Judges/CodingBat/Python/Logic-02/Logic_2-05-round_sum.py
|
shihab4t/Competitive-Programming
|
e8eec7d4f7d86bfa1c00b7fbbedfd6a1518f19be
|
[
"Unlicense"
] | null | null | null |
def round_sum(a, b, c):
return round10(a) + round10(b) + round10(c)
def round10(num):
if num % 10 < 5:
return num - (num % 10)
return num + (10 - num % 10)
| 19.777778 | 47 | 0.539326 |
4ac6462a60f24eaf094b3a0e33a01dfd1b65e3ea
| 263 |
py
|
Python
|
sentinel/node/__init__.py
|
allagog0x01/sentwg
|
52285ecf2b03c30a78901a29a7af96c8ab5764c8
|
[
"Apache-2.0"
] | 342 |
2017-08-21T20:12:56.000Z
|
2022-03-19T17:58:25.000Z
|
sentinel/node/__init__.py
|
allagog0x01/sentwg
|
52285ecf2b03c30a78901a29a7af96c8ab5764c8
|
[
"Apache-2.0"
] | 57 |
2017-11-13T11:16:47.000Z
|
2022-03-01T13:54:31.000Z
|
vpn-node-cosmos/sentinel/node/__init__.py
|
smtcrms/sentinel
|
ff65bc9200f6c940aa184c0ec0872fdcfef25363
|
[
"MIT"
] | 72 |
2017-11-23T05:13:24.000Z
|
2022-02-25T14:18:33.000Z
|
# coding=utf-8
from .controllers import add_tx
from .controllers import get_free_coins
from .controllers import list_node
from .controllers import update_node
from .controllers import update_session
from .controllers import update_sessions
from .node import node
| 29.222222 | 40 | 0.847909 |
601188a95c23a883ac514e94019a7beb22c23969
| 4,530 |
py
|
Python
|
feedcrawler/notifiers.py
|
rix1337/RSScrawler
|
5a1c067148310c03321329d3fa409a4e4144fce7
|
[
"MIT"
] | 63 |
2016-03-21T21:35:07.000Z
|
2021-03-20T22:50:34.000Z
|
feedcrawler/notifiers.py
|
rix1337/RSScrawler
|
5a1c067148310c03321329d3fa409a4e4144fce7
|
[
"MIT"
] | 200 |
2016-03-15T21:45:26.000Z
|
2021-04-03T10:47:45.000Z
|
feedcrawler/notifiers.py
|
rix1337/RSScrawler
|
5a1c067148310c03321329d3fa409a4e4144fce7
|
[
"MIT"
] | 25 |
2016-03-15T20:44:33.000Z
|
2020-10-25T09:43:48.000Z
|
# -*- coding: utf-8 -*-
# FeedCrawler
# Projekt von https://github.com/rix1337
# Enthält Code von:
# https://github.com/Gutz-Pilz/pyLoad-stuff/blob/master/SJ.py
from urllib.error import HTTPError
from urllib.parse import urlencode
from urllib.request import urlopen, Request
import simplejson as json
from feedcrawler import internal
from feedcrawler.config import CrawlerConfig
def api_request_cutter(message, n):
for i in range(0, len(message), n):
yield message[i:i + n]
def notify(items):
notifications = CrawlerConfig('Notifications', )
homeassistant_settings = notifications.get("homeassistant").split(',')
pushbullet_token = notifications.get("pushbullet")
telegram_settings = notifications.get("telegram").split(',')
pushover_settings = notifications.get("pushover").split(',')
if len(items) > 0:
cut_items = list(api_request_cutter(items, 5))
if len(notifications.get("homeassistant")) > 0:
for cut_item in cut_items:
homassistant_url = homeassistant_settings[0]
homeassistant_password = homeassistant_settings[1]
home_assistant(cut_item, homassistant_url,
homeassistant_password)
if len(notifications.get("pushbullet")) > 0:
pushbullet(items, pushbullet_token)
if len(notifications.get("telegram")) > 0:
for cut_item in cut_items:
telegram_token = telegram_settings[0]
telegram_chatid = telegram_settings[1]
telegram(cut_item, telegram_token, telegram_chatid)
if len(notifications.get('pushover')) > 0:
for cut_item in cut_items:
pushover_user = pushover_settings[0]
pushover_token = pushover_settings[1]
pushover(cut_item, pushover_user, pushover_token)
def home_assistant(items, homassistant_url, homeassistant_password):
data = urlencode({
'title': 'FeedCrawler:',
'body': "\n\n".join(items)
}).encode("utf-8")
try:
req = Request(homassistant_url, data)
req.add_header('X-HA-Access', homeassistant_password)
req.add_header('Content-Type', 'application/json')
response = urlopen(req)
except HTTPError:
internal.logger.debug('FEHLER - Konnte Home Assistant API nicht erreichen')
return False
res = json.load(response)
if res['sender_name']:
internal.logger.debug('Home Assistant Erfolgreich versendet')
else:
internal.logger.debug('FEHLER - Konnte nicht an Home Assistant Senden')
def telegram(items, token, chatid):
data = urlencode({
'chat_id': chatid,
'text': "\n\n".join(items)
}).encode("utf-8")
try:
req = Request("https://api.telegram.org/bot" + token + "/sendMessage", data)
response = urlopen(req)
except HTTPError:
internal.logger.debug('FEHLER - Konnte Telegram API nicht erreichen')
return False
res = json.load(response)
if res['ok']:
internal.logger.debug('Telegram Erfolgreich versendet')
else:
internal.logger.debug('FEHLER - Konnte nicht an Telegram Senden')
def pushbullet(items, token):
data = urlencode({
'type': 'note',
'title': 'FeedCrawler:',
'body': "\n\n".join(items)
}).encode("utf-8")
try:
req = Request('https://api.pushbullet.com/v2/pushes', data)
req.add_header('Access-Token', token)
response = urlopen(req)
except HTTPError:
internal.logger.debug('FEHLER - Konnte Pushbullet API nicht erreichen')
return False
res = json.load(response)
if res['sender_name']:
internal.logger.debug('Pushbullet Erfolgreich versendet')
else:
internal.logger.debug('FEHLER - Konnte nicht an Pushbullet Senden')
def pushover(items, pushover_user, pushover_token):
data = urlencode({
'user': pushover_user,
'token': pushover_token,
'title': 'FeedCrawler',
'message': "\n\n".join(items)
}).encode("utf-8")
try:
req = Request('https://api.pushover.net/1/messages.json', data)
response = urlopen(req)
except HTTPError:
internal.logger.debug('FEHLER - Konnte Pushover API nicht erreichen')
return False
res = json.load(response)
if res['status'] == 1:
internal.logger.debug('Pushover Erfolgreich versendet')
else:
internal.logger.debug('FEHLER - Konnte nicht an Pushover Senden')
| 35.116279 | 84 | 0.642605 |
6015bd691735c3f845e6db95e98993bddc3be3a9
| 9,319 |
py
|
Python
|
frappe-bench/apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py
|
Semicheche/foa_frappe_docker
|
a186b65d5e807dd4caf049e8aeb3620a799c1225
|
[
"MIT"
] | null | null | null |
frappe-bench/apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py
|
Semicheche/foa_frappe_docker
|
a186b65d5e807dd4caf049e8aeb3620a799c1225
|
[
"MIT"
] | null | null | null |
frappe-bench/apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py
|
Semicheche/foa_frappe_docker
|
a186b65d5e807dd4caf049e8aeb3620a799c1225
|
[
"MIT"
] | null | null | null |
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
from __future__ import unicode_literals
import frappe
from frappe.utils import add_days, getdate, cint, cstr
from frappe import throw, _
from erpnext.utilities.transaction_base import TransactionBase, delete_events
from erpnext.stock.utils import get_valid_serial_nos
from erpnext.hr.doctype.employee.employee import get_holiday_list_for_employee
class MaintenanceSchedule(TransactionBase):
def generate_schedule(self):
self.set('schedules', [])
frappe.db.sql("""delete from `tabMaintenance Schedule Detail`
where parent=%s""", (self.name))
count = 1
for d in self.get('items'):
self.validate_maintenance_detail()
s_list = []
s_list = self.create_schedule_list(d.start_date, d.end_date, d.no_of_visits, d.sales_person)
for i in range(d.no_of_visits):
child = self.append('schedules')
child.item_code = d.item_code
child.item_name = d.item_name
child.scheduled_date = s_list[i].strftime('%Y-%m-%d')
if d.serial_no:
child.serial_no = d.serial_no
child.idx = count
count = count + 1
child.sales_person = d.sales_person
self.save()
def on_submit(self):
if not self.get('schedules'):
throw(_("Please click on 'Generate Schedule' to get schedule"))
self.check_serial_no_added()
self.validate_schedule()
email_map = {}
for d in self.get('items'):
if d.serial_no:
serial_nos = get_valid_serial_nos(d.serial_no)
self.validate_serial_no(serial_nos, d.start_date)
self.update_amc_date(serial_nos, d.end_date)
no_email_sp = []
if d.sales_person not in email_map:
sp = frappe.get_doc("Sales Person", d.sales_person)
try:
email_map[d.sales_person] = sp.get_email_id()
except frappe.ValidationError:
no_email_sp.append(d.sales_person)
if no_email_sp:
frappe.msgprint(
frappe._("Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}").format(
self.owner, "<br>" + "<br>".join(no_email_sp)
))
scheduled_date = frappe.db.sql("""select scheduled_date from
`tabMaintenance Schedule Detail` where sales_person=%s and item_code=%s and
parent=%s""", (d.sales_person, d.item_code, self.name), as_dict=1)
for key in scheduled_date:
description =frappe._("Reference: {0}, Item Code: {1} and Customer: {2}").format(self.name, d.item_code, self.customer)
frappe.get_doc({
"doctype": "Event",
"owner": email_map.get(d.sales_person, self.owner),
"subject": description,
"description": description,
"starts_on": cstr(key["scheduled_date"]) + " 10:00:00",
"event_type": "Private",
"ref_type": self.doctype,
"ref_name": self.name
}).insert(ignore_permissions=1)
frappe.db.set(self, 'status', 'Submitted')
def create_schedule_list(self, start_date, end_date, no_of_visit, sales_person):
schedule_list = []
start_date_copy = start_date
date_diff = (getdate(end_date) - getdate(start_date)).days
add_by = date_diff / no_of_visit
for visit in range(cint(no_of_visit)):
if (getdate(start_date_copy) < getdate(end_date)):
start_date_copy = add_days(start_date_copy, add_by)
if len(schedule_list) < no_of_visit:
schedule_date = self.validate_schedule_date_for_holiday_list(getdate(start_date_copy),
sales_person)
if schedule_date > getdate(end_date):
schedule_date = getdate(end_date)
schedule_list.append(schedule_date)
return schedule_list
def validate_schedule_date_for_holiday_list(self, schedule_date, sales_person):
validated = False
employee = frappe.db.get_value("Sales Person", sales_person, "employee")
if employee:
holiday_list = get_holiday_list_for_employee(employee)
else:
holiday_list = frappe.db.get_value("Company", self.company, "default_holiday_list")
holidays = frappe.db.sql_list('''select holiday_date from `tabHoliday` where parent=%s''', holiday_list)
if not validated and holidays:
# max iterations = len(holidays)
for i in range(len(holidays)):
if schedule_date in holidays:
schedule_date = add_days(schedule_date, -1)
else:
validated = True
break
return schedule_date
def validate_dates_with_periodicity(self):
for d in self.get("items"):
if d.start_date and d.end_date and d.periodicity and d.periodicity!="Random":
date_diff = (getdate(d.end_date) - getdate(d.start_date)).days + 1
days_in_period = {
"Weekly": 7,
"Monthly": 30,
"Quarterly": 90,
"Half Yearly": 180,
"Yearly": 365
}
if date_diff < days_in_period[d.periodicity]:
throw(_("Row {0}: To set {1} periodicity, difference between from and to date \
must be greater than or equal to {2}")
.format(d.idx, d.periodicity, days_in_period[d.periodicity]))
def validate_maintenance_detail(self):
if not self.get('items'):
throw(_("Please enter Maintaince Details first"))
for d in self.get('items'):
if not d.item_code:
throw(_("Please select item code"))
elif not d.start_date or not d.end_date:
throw(_("Please select Start Date and End Date for Item {0}".format(d.item_code)))
elif not d.no_of_visits:
throw(_("Please mention no of visits required"))
elif not d.sales_person:
throw(_("Please select Incharge Person's name"))
if getdate(d.start_date) >= getdate(d.end_date):
throw(_("Start date should be less than end date for Item {0}").format(d.item_code))
def validate_sales_order(self):
for d in self.get('items'):
if d.sales_order:
chk = frappe.db.sql("""select ms.name from `tabMaintenance Schedule` ms,
`tabMaintenance Schedule Item` msi where msi.parent=ms.name and
msi.sales_order=%s and ms.docstatus=1""", d.sales_order)
if chk:
throw(_("Maintenance Schedule {0} exists against {1}").format(chk[0][0], d.sales_order))
def validate(self):
self.validate_maintenance_detail()
self.validate_dates_with_periodicity()
self.validate_sales_order()
def on_update(self):
frappe.db.set(self, 'status', 'Draft')
def update_amc_date(self, serial_nos, amc_expiry_date=None):
for serial_no in serial_nos:
serial_no_doc = frappe.get_doc("Serial No", serial_no)
serial_no_doc.amc_expiry_date = amc_expiry_date
serial_no_doc.save()
def validate_serial_no(self, serial_nos, amc_start_date):
for serial_no in serial_nos:
sr_details = frappe.db.get_value("Serial No", serial_no,
["warranty_expiry_date", "amc_expiry_date", "warehouse", "delivery_date"], as_dict=1)
if not sr_details:
frappe.throw(_("Serial No {0} not found").format(serial_no))
if sr_details.warranty_expiry_date \
and getdate(sr_details.warranty_expiry_date) >= getdate(amc_start_date):
throw(_("Serial No {0} is under warranty upto {1}")
.format(serial_no, sr_details.warranty_expiry_date))
if sr_details.amc_expiry_date and getdate(sr_details.amc_expiry_date) >= getdate(amc_start_date):
throw(_("Serial No {0} is under maintenance contract upto {1}")
.format(serial_no, sr_details.amc_start_date))
if not sr_details.warehouse and sr_details.delivery_date and \
getdate(sr_details.delivery_date) >= getdate(amc_start_date):
throw(_("Maintenance start date can not be before delivery date for Serial No {0}")
.format(serial_no))
def validate_schedule(self):
item_lst1 =[]
item_lst2 =[]
for d in self.get('items'):
if d.item_code not in item_lst1:
item_lst1.append(d.item_code)
for m in self.get('schedules'):
if m.item_code not in item_lst2:
item_lst2.append(m.item_code)
if len(item_lst1) != len(item_lst2):
throw(_("Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule'"))
else:
for x in item_lst1:
if x not in item_lst2:
throw(_("Please click on 'Generate Schedule'"))
def check_serial_no_added(self):
serial_present =[]
for d in self.get('items'):
if d.serial_no:
serial_present.append(d.item_code)
for m in self.get('schedules'):
if serial_present:
if m.item_code in serial_present and not m.serial_no:
throw(_("Please click on 'Generate Schedule' to fetch Serial No added for Item {0}").format(m.item_code))
def on_cancel(self):
for d in self.get('items'):
if d.serial_no:
serial_nos = get_valid_serial_nos(d.serial_no)
self.update_amc_date(serial_nos)
frappe.db.set(self, 'status', 'Cancelled')
delete_events(self.doctype, self.name)
def on_trash(self):
delete_events(self.doctype, self.name)
@frappe.whitelist()
def make_maintenance_visit(source_name, target_doc=None):
from frappe.model.mapper import get_mapped_doc
def update_status(source, target, parent):
target.maintenance_type = "Scheduled"
doclist = get_mapped_doc("Maintenance Schedule", source_name, {
"Maintenance Schedule": {
"doctype": "Maintenance Visit",
"field_map": {
"name": "maintenance_schedule"
},
"validation": {
"docstatus": ["=", 1]
},
"postprocess": update_status
},
"Maintenance Schedule Item": {
"doctype": "Maintenance Visit Purpose",
"field_map": {
"parent": "prevdoc_docname",
"parenttype": "prevdoc_doctype",
"sales_person": "service_person"
}
}
}, target_doc)
return doclist
| 34.261029 | 129 | 0.713274 |
60cf70a2362fb6aa634a51a567c4ee2e5dae4d27
| 319 |
py
|
Python
|
BITs/2014/Shmireychik_S_V/task_1_17.py
|
YukkaSarasti/pythonintask
|
eadf4245abb65f4400a3bae30a4256b4658e009c
|
[
"Apache-2.0"
] | null | null | null |
BITs/2014/Shmireychik_S_V/task_1_17.py
|
YukkaSarasti/pythonintask
|
eadf4245abb65f4400a3bae30a4256b4658e009c
|
[
"Apache-2.0"
] | null | null | null |
BITs/2014/Shmireychik_S_V/task_1_17.py
|
YukkaSarasti/pythonintask
|
eadf4245abb65f4400a3bae30a4256b4658e009c
|
[
"Apache-2.0"
] | null | null | null |
#Задача 1. Вариант 17.
#Программа,которая сообщает род деятельности и псевдоним под которым скрывается Алексей Максимович Пешков
#Шмирейчик С.В.
#29.02.2016
print("Алексей Максимович Пешков - литературный псевдоним Максима Горького. Род деятельности - писатель, прозаик, драматург")
input("Нажмите Enter для выхода")
| 35.444444 | 125 | 0.802508 |
71b79b2a7b488b78fb6c737fcb1a0a834b299c83
| 505 |
py
|
Python
|
config.py
|
florenthemmi/ips-by-country
|
2f63ec2108ceaae97221de52654753c545733d84
|
[
"MIT"
] | 1 |
2021-05-24T06:16:49.000Z
|
2021-05-24T06:16:49.000Z
|
config.py
|
florenthemmi/ips-by-country
|
2f63ec2108ceaae97221de52654753c545733d84
|
[
"MIT"
] | null | null | null |
config.py
|
florenthemmi/ips-by-country
|
2f63ec2108ceaae97221de52654753c545733d84
|
[
"MIT"
] | null | null | null |
import json
import os
CIDR_MAX_SUBNETS = {}
CONFIG_DIRECTORY = 'config'
COUNTRIES = json.load(open(os.path.join(CONFIG_DIRECTORY, 'countries.json'), 'r'))
cidr_max_subnets_dict = json.load(open(os.path.join(CONFIG_DIRECTORY, 'cidr_max_subnets.json'), 'r'))
config_dict = json.load(open(os.path.join(CONFIG_DIRECTORY, 'config.json'), 'r'))
for key, value in cidr_max_subnets_dict.items():
CIDR_MAX_SUBNETS[int(key)] = value
for key, value in config_dict.items():
globals()[key.upper()] = value
| 31.5625 | 101 | 0.736634 |
c76eb2ddbd4be5728ea8021915e8a1310b41fbe2
| 516 |
py
|
Python
|
Tutorials/10 Days of Statistics/Day 4/binomial_distribution1.py
|
xuedong/hacker-rank
|
ce8a60f80c2c6935b427f9409d7e826ee0d26a89
|
[
"MIT"
] | 1 |
2021-02-22T17:37:45.000Z
|
2021-02-22T17:37:45.000Z
|
Tutorials/10 Days of Statistics/Day 4/binomial_distribution1.py
|
xuedong/hacker-rank
|
ce8a60f80c2c6935b427f9409d7e826ee0d26a89
|
[
"MIT"
] | null | null | null |
Tutorials/10 Days of Statistics/Day 4/binomial_distribution1.py
|
xuedong/hacker-rank
|
ce8a60f80c2c6935b427f9409d7e826ee0d26a89
|
[
"MIT"
] | null | null | null |
#!/bin/python3
import sys
from math import factorial as fac
def binomial(x, y):
try:
return fac(x) // fac(y) // fac(x - y)
except ValueError:
return 0
def bin_dist(n, k, p, q):
return binomial(n, k) * p**k * q**(n-k)
def f(p, q):
p1 = bin_dist(6, 0, p, q)
p2 = bin_dist(6, 1, p, q)
p3 = bin_dist(6, 2, p, q)
return 1 - p1 - p2 - p3
arr = [float(arr_i) for arr_i in input().strip().split(' ')]
a = arr[0]
b = arr[1]
p = a/(a+b)
q = b/(a+b)
print(round(f(p, q), 3))
| 17.2 | 60 | 0.527132 |
1bed5d10f72be8fb3f46eef6a4c2351c1ea55817
| 313 |
py
|
Python
|
nz_django/day4/orm_queryset_demo/front/migrations/0002_auto_20200221_1505.py
|
gaohj/nzflask_bbs
|
36a94c380b78241ed5d1e07edab9618c3e8d477b
|
[
"Apache-2.0"
] | null | null | null |
nz_django/day4/orm_queryset_demo/front/migrations/0002_auto_20200221_1505.py
|
gaohj/nzflask_bbs
|
36a94c380b78241ed5d1e07edab9618c3e8d477b
|
[
"Apache-2.0"
] | 27 |
2020-02-12T07:55:58.000Z
|
2022-03-12T00:19:09.000Z
|
nz_django/day4/orm_queryset_demo/front/migrations/0002_auto_20200221_1505.py
|
gaohj/nzflask_bbs
|
36a94c380b78241ed5d1e07edab9618c3e8d477b
|
[
"Apache-2.0"
] | 2 |
2020-02-18T01:54:55.000Z
|
2020-02-21T11:36:28.000Z
|
# Generated by Django 2.0 on 2020-02-21 07:05
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('front', '0001_initial'),
]
operations = [
migrations.AlterModelOptions(
name='bookorder',
options={},
),
]
| 17.388889 | 45 | 0.57508 |
1bf0292d960590d34df1417ac53193651eecc50e
| 680 |
py
|
Python
|
setup.py
|
li657835991/FCN
|
26bafeaf631a095d9d2befcc3b798a87c8d0fa7c
|
[
"MIT"
] | 235 |
2017-03-01T14:34:29.000Z
|
2021-06-03T16:16:16.000Z
|
setup.py
|
li657835991/FCN
|
26bafeaf631a095d9d2befcc3b798a87c8d0fa7c
|
[
"MIT"
] | 39 |
2017-03-25T01:20:25.000Z
|
2020-10-30T11:51:47.000Z
|
setup.py
|
li657835991/FCN
|
26bafeaf631a095d9d2befcc3b798a87c8d0fa7c
|
[
"MIT"
] | 105 |
2017-04-13T21:31:46.000Z
|
2021-11-01T17:25:48.000Z
|
"""Setup script."""
import setuptools
setuptools.setup(
author="Jihong Ju",
author_email="[email protected]",
extras_require={
"test": [
'keras>=2.0.0',
"pandas==0.19.2",
"tensorflow",
"codecov",
"mock",
"pytest",
"pytest-cov",
"pytest-pep8",
"pytest-runner",
"pydot",
"graphviz"
],
},
install_requires=[],
name="keras-fcn",
description=("A reimplemtenation of fully convolutional networks"),
packages=['keras_fcn'],
url="https://github.com/JihongJu/keras-fcn",
version="0.0.1",
)
| 22.666667 | 71 | 0.501471 |
90da493123158501e4e90d998beec4d7bda667a8
| 447 |
py
|
Python
|
scripts/scandb.py
|
evildrummer/1337-observer
|
621eb16711d9f70a59fb5524fc990dcab1004b14
|
[
"MIT"
] | 1 |
2022-01-28T22:29:44.000Z
|
2022-01-28T22:29:44.000Z
|
scripts/scandb.py
|
evildrummer/1337-observer
|
621eb16711d9f70a59fb5524fc990dcab1004b14
|
[
"MIT"
] | null | null | null |
scripts/scandb.py
|
evildrummer/1337-observer
|
621eb16711d9f70a59fb5524fc990dcab1004b14
|
[
"MIT"
] | 1 |
2022-01-28T21:10:41.000Z
|
2022-01-28T21:10:41.000Z
|
from censys.search import CensysHosts
import time
h = CensysHosts()
ip_result = []
for count in range(10, 1000):
for page in h.search('services.http.response.html_title:"Outlook" and location.country=`Germany`', pages=count):
for result in page:
print(result["ip"])
ip_result.append(result["ip"])
time.sleep(3)
with open("owa_deutschland.txt", "a") as my_file:
my_file.write("\n".join(ip_result))
| 29.8 | 116 | 0.662192 |
2914bf2da52c18098f616ef3328aeb37a40b2ba9
| 5,125 |
py
|
Python
|
applications/experimental/pipelines/pipelines/nodes/ranker/ernie_ranker.py
|
mukaiu/PaddleNLP
|
0315365dbafa6e3b1c7147121ba85e05884125a5
|
[
"Apache-2.0"
] | null | null | null |
applications/experimental/pipelines/pipelines/nodes/ranker/ernie_ranker.py
|
mukaiu/PaddleNLP
|
0315365dbafa6e3b1c7147121ba85e05884125a5
|
[
"Apache-2.0"
] | null | null | null |
applications/experimental/pipelines/pipelines/nodes/ranker/ernie_ranker.py
|
mukaiu/PaddleNLP
|
0315365dbafa6e3b1c7147121ba85e05884125a5
|
[
"Apache-2.0"
] | null | null | null |
# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import List, Optional, Union
import logging
from pathlib import Path
import paddle
from paddlenlp.transformers import ErnieCrossEncoder, ErnieTokenizer
from pipelines.schema import Document
from pipelines.nodes.ranker import BaseRanker
from pipelines.utils.common_utils import initialize_device_settings
logger = logging.getLogger(__name__)
class ErnieRanker(BaseRanker):
"""
Re-Ranking can be used on top of a retriever to boost the performance for document search. This is particularly useful if the retriever has a high recall but is bad in sorting the documents by relevance.
Usage example:
...
retriever = ElasticsearchRetriever(document_store=document_store)
ranker = SentenceTransformersRanker(model_name_or_path="rocketqa-zh-dureader-cross-encoder")
p = Pipeline()
p.add_node(component=retriever, name="ESRetriever", inputs=["Query"])
p.add_node(component=ranker, name="Ranker", inputs=["ESRetriever"])
"""
def __init__(
self,
model_name_or_path: Union[str, Path],
top_k: int = 10,
use_gpu: bool = True,
):
"""
:param model_name_or_path: Directory of a saved model or the name of a public model e.g.
'rocketqa-zh-dureader-cross-encoder'.
:param top_k: The maximum number of documents to return
:param use_gpu: Whether to use all available GPUs or the CPU. Falls back on CPU if no GPU is available.
"""
# save init parameters to enable export of component config as YAML
self.set_config(
model_name_or_path=model_name_or_path,
top_k=top_k,
)
self.top_k = top_k
self.devices, _ = initialize_device_settings(use_cuda=use_gpu,
multi_gpu=True)
self.transformer_model = ErnieCrossEncoder(model_name_or_path)
self.tokenizer = ErnieTokenizer.from_pretrained(model_name_or_path)
self.transformer_model.eval()
if len(self.devices) > 1:
self.model = paddle.DataParallel(self.transformer_model)
def predict_batch(self,
query_doc_list: List[dict],
top_k: int = None,
batch_size: int = None):
"""
Use loaded Ranker model to, for a list of queries, rank each query's supplied list of Document.
Returns list of dictionary of query and list of document sorted by (desc.) similarity with query
:param query_doc_list: List of dictionaries containing queries with their retrieved documents
:param top_k: The maximum number of answers to return for each query
:param batch_size: Number of samples the model receives in one batch for inference
:return: List of dictionaries containing query and ranked list of Document
"""
raise NotImplementedError
def predict(self,
query: str,
documents: List[Document],
top_k: Optional[int] = None) -> List[Document]:
"""
Use loaded ranker model to re-rank the supplied list of Document.
Returns list of Document sorted by (desc.) similarity with the query.
:param query: Query string
:param documents: List of Document to be re-ranked
:param top_k: The maximum number of documents to return
:return: List of Document
"""
if top_k is None:
top_k = self.top_k
features = self.tokenizer([query for doc in documents],
[doc.content for doc in documents],
max_seq_len=256,
pad_to_max_seq_len=True,
truncation_strategy="longest_first")
tensors = {k: paddle.to_tensor(v) for (k, v) in features.items()}
with paddle.no_grad():
similarity_scores = self.transformer_model.matching(
**tensors).numpy()
for doc, rank_score in zip(documents, similarity_scores):
doc.rank_score = rank_score
doc.score = rank_score
sorted_scores_and_documents = sorted(
zip(similarity_scores, documents),
key=lambda similarity_document_tuple: similarity_document_tuple[0],
reverse=True,
)
# rank documents according to scores
sorted_documents = [doc for _, doc in sorted_scores_and_documents]
return sorted_documents[:top_k]
| 39.122137 | 207 | 0.656195 |
31af215b5e77b5e61d0d1edaaf4a70b6e7f5599d
| 4,016 |
py
|
Python
|
WiSe-2122/Bot-Automation/impftermin-buchen.py
|
jonasrdt/Wirtschaftsinformatik2
|
30d5d896808b98664c55cb6fbb3b30a7f1904d9f
|
[
"MIT"
] | 1 |
2022-03-23T09:40:39.000Z
|
2022-03-23T09:40:39.000Z
|
WiSe-2122/Bot-Automation/impftermin-buchen.py
|
jonasrdt/Wirtschaftsinformatik2
|
30d5d896808b98664c55cb6fbb3b30a7f1904d9f
|
[
"MIT"
] | null | null | null |
WiSe-2122/Bot-Automation/impftermin-buchen.py
|
jonasrdt/Wirtschaftsinformatik2
|
30d5d896808b98664c55cb6fbb3b30a7f1904d9f
|
[
"MIT"
] | null | null | null |
# 1. Herunterladen von Google Chrome https://www.google.com/intl/de/chrome/
# 2. Google Chrome Version herausfinden
# 3. Passende Chromedriver herunterladen https://chromedriver.chromium.org/downloads
# 4. Selenium installieren
# Windows: py -m pip install selenium
# MacOS: python3 -m pip install selenium
# 5. Ausführen
from selenium import webdriver
from selenium.webdriver.support.ui import Select
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as expect
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains
import time
import os
# aktuelles Verzeichnis der Datei
aktVerzeichnis = os.path.dirname(__file__)
# Zusammensetzen des Verzeichnispfads zum chromedriver
chromedriver = os.path.join(aktVerzeichnis, 'chromedriver')
# Set URL to interact with
url = 'https://ticket.impfen-sh.de/sh/start/termine'
# Find webdriver for Chrome
browser = webdriver.Chrome(
executable_path= chromedriver)
# Aufrufen der Website mithilfe von Selenium
browser.get(url)
user = input("Bitte geben Sie den Vornamen ein: ")
user.strip()
date = input("Bitte geben Sie das Geburtsdatum ein: ")
date.strip()
# Namen einfügen
try:
user_input = WebDriverWait(browser, 120, 1).until(
expect.element_to_be_clickable(
(By.XPATH, "/html/body/div[1]/div[2]/div/main/div/div/div/div[3]/div[1]/div[2]/div[2]/div/div[1]/div/input")
)
)
finally:
user_input.send_keys(user)
# Geburtstag einfügen
try:
date_input = WebDriverWait(browser, 120, 1).until(
expect.element_to_be_clickable(
(By.XPATH, "/html/body/div[1]/div[2]/div/main/div/div/div/div[3]/div[1]/div[3]/div[2]/div/div[1]/div/input")
)
)
finally:
date_input.send_keys(date)
art_der_impfung = input("Welche Impfung wollen Sie haben: \n 1. Impfung, Impfstoff Moderna, zugelassen ab 12 Jahren, STIKO empfiehlt ab 30 Jahren. \n 2. Impfung, Impfstoff Moderna, zugelassen ab 12 Jahren, STIKO empfiehlt ab 30 Jahren. \n Impfung, Auffrischimpfung, für Personen von 18 Jahren oder älter, Impfstoff Moderna, STIKO empfiehlt ab 30 Jahren.: ")
if art_der_impfung == "1":
# Klicken des ersten Buttons
try:
erste_impfe = WebDriverWait(browser, 120, 1).until(
expect.element_to_be_clickable(
(By.XPATH, "/html/body/div[1]/div[2]/div/main/div/div/div/div[3]/div[1]/div[4]/div[2]/div/div[1]/div")
)
)
finally:
browser.implicitly_wait(10)
erste_impfe.click()
elif art_der_impfung == "2":
# Klicken des zweiten Buttons
try:
zweite_impfe = WebDriverWait(browser, 120, 1).until(
expect.element_to_be_clickable(
(By.XPATH, "/html/body/div[1]/div[2]/div/main/div/div/div/div[3]/div[1]/div[5]/div[2]/div/div[1]/div")
)
)
finally:
browser.implicitly_wait(10)
zweite_impfe.click()
elif art_der_impfung == "3":
# Klicken des zweiten Buttons
try:
dritte_impfe = WebDriverWait(browser, 120, 1).until(
expect.element_to_be_clickable(
(By.XPATH, "/html/body/div[1]/div[2]/div/main/div/div/div/div[3]/div[1]/div[6]/div[2]/div/div[1]/div")
)
)
finally:
browser.implicitly_wait(10)
dritte_impfe.click()
email = input("Bitte geben Sie Ihre E-Mail Adresse ein: ")
# E-Mail einfügen
try:
mail_input = WebDriverWait(browser, 120, 1).until(
expect.element_to_be_clickable(
(By.XPATH, "/html/body/div[1]/div[2]/div/main/div/div/div/div[3]/div[2]/div[2]/div[1]/div/input")
)
)
finally:
mail_input.send_keys(email)
# Klicken des Bestätigen Buttons
try:
confirm = WebDriverWait(browser, 120, 1).until(
expect.element_to_be_clickable(
(By.XPATH, "/html/body/div[1]/div[2]/div/main/div/div/div/div[3]/div[4]/button")
)
)
finally:
browser.implicitly_wait(10)
confirm.click()
| 34.62069 | 357 | 0.678785 |
b40e9142bdbd32e9889261269aa913108d359ba9
| 313 |
py
|
Python
|
python/loginputloop.py
|
wittrup/crap
|
a77474588fd54a5a998e24df7b1e6e2ab473ded1
|
[
"MIT"
] | 1 |
2017-12-12T13:58:08.000Z
|
2017-12-12T13:58:08.000Z
|
python/loginputloop.py
|
wittrup/crap
|
a77474588fd54a5a998e24df7b1e6e2ab473ded1
|
[
"MIT"
] | null | null | null |
python/loginputloop.py
|
wittrup/crap
|
a77474588fd54a5a998e24df7b1e6e2ab473ded1
|
[
"MIT"
] | 1 |
2019-11-03T10:16:35.000Z
|
2019-11-03T10:16:35.000Z
|
import os
from time import strftime as now
FORMAT = '%Y-%m-%d %H:%M:%S'
if __name__ == '__main__':
print(now(FORMAT), os.path.dirname(__file__))
s = input()
while s:
with open('log.txt', 'a+') as f:
f.write(now(FORMAT) + ' ' + s + '\n')
f.close()
s = input()
| 22.357143 | 49 | 0.507987 |
48a48e8a12f3f2b3b3eb1282abd336cefc8bcf19
| 535 |
py
|
Python
|
exercises/de/solution_03_06.py
|
Jette16/spacy-course
|
32df0c8f6192de6c9daba89740a28c0537e4d6a0
|
[
"MIT"
] | 2,085 |
2019-04-17T13:10:40.000Z
|
2022-03-30T21:51:46.000Z
|
exercises/de/solution_03_06.py
|
Jette16/spacy-course
|
32df0c8f6192de6c9daba89740a28c0537e4d6a0
|
[
"MIT"
] | 79 |
2019-04-18T14:42:55.000Z
|
2022-03-07T08:15:43.000Z
|
exercises/de/solution_03_06.py
|
Jette16/spacy-course
|
32df0c8f6192de6c9daba89740a28c0537e4d6a0
|
[
"MIT"
] | 361 |
2019-04-17T13:34:32.000Z
|
2022-03-28T04:42:45.000Z
|
import spacy
# Definiere die benutzerdefinierte Komponente
def length_component(doc):
# Berechne die Länge des Dokuments
doc_length = len(doc)
print(f"Dieses Dokument ist {doc_length} Tokens lang.")
# Gib das Doc zurück
return doc
# Lade das kleine deutsche Modell
nlp = spacy.load("de_core_news_sm")
# Füge die Komponente am Anfang der Pipeline hinzu und drucke die Namen der Komponenten
nlp.add_pipe(length_component, first=True)
print(nlp.pipe_names)
# Verarbeite einen Text
doc = nlp("Dies ist ein Satz.")
| 25.47619 | 87 | 0.753271 |
48bed1c304d82cbfa460f38aa164c4906a93f466
| 503 |
py
|
Python
|
influx-demo/db_producer.py
|
gregjhansell97/sandbox
|
d565da5db2c10af404ce62aa747d5e682bc02a86
|
[
"MIT"
] | null | null | null |
influx-demo/db_producer.py
|
gregjhansell97/sandbox
|
d565da5db2c10af404ce62aa747d5e682bc02a86
|
[
"MIT"
] | null | null | null |
influx-demo/db_producer.py
|
gregjhansell97/sandbox
|
d565da5db2c10af404ce62aa747d5e682bc02a86
|
[
"MIT"
] | null | null | null |
from influxdb import InfluxDBClient
'''
json_body = [
{
"measurement": "cpu_load_short",
"tags": {
"host": "server01",
"region": "us-west"
},
"time": "2009-11-10T23:00:00Z",
"fields": {
"value": 0.64
}
}
]
'''
client = InfluxDBClient(host="localhost", port=9694)
client.create_database("example")
#client.write_points(json_body)
#result = client.query("select value from cpu_load_short;")
#print(result)
| 17.344828 | 59 | 0.558648 |
7d5d0e0a72107f3ac4bc71903551ee3e318a769c
| 2,784 |
py
|
Python
|
Utils/tests/old_content_branch_test.py
|
diCagri/content
|
c532c50b213e6dddb8ae6a378d6d09198e08fc9f
|
[
"MIT"
] | 799 |
2016-08-02T06:43:14.000Z
|
2022-03-31T11:10:11.000Z
|
Utils/tests/old_content_branch_test.py
|
diCagri/content
|
c532c50b213e6dddb8ae6a378d6d09198e08fc9f
|
[
"MIT"
] | 9,317 |
2016-08-07T19:00:51.000Z
|
2022-03-31T21:56:04.000Z
|
Utils/tests/old_content_branch_test.py
|
diCagri/content
|
c532c50b213e6dddb8ae6a378d6d09198e08fc9f
|
[
"MIT"
] | 1,297 |
2016-08-04T13:59:00.000Z
|
2022-03-31T23:43:06.000Z
|
from Utils.old_content_branch import should_keep_json_file, should_keep_yml_file, edit_playbooks_directory, ryaml
import json
import shutil
TEST_VERSION = "5.1.9"
JSON_SHOULD_STAY = 'Packs/CommonReports/Reports/report-MTTRbyIncidentType2Quar.json'
YML_SHOULD_STAY = 'Packs/ThinkstCanary/Integrations/ThinkstCanary/ThinkstCanary.yml'
JSON_SHOULD_DELETE = 'Utils/tests/test_data_old_content/json_should_delete.json'
YML_SHOULD_DELETE = 'Packs/CommonPlaybooks/Playbooks/playbook-Calculate_Severity_By_Highest_DBotScore.yml'
TEST_TPB = 'Utils/tests/test_data_old_content/temp_test_playbook.yml'
def test_handle_json__should_stay():
"""
Given
- A path to a json file that should stay - lower fromVersion.
When
- Running should_keep_json_file on it.
Then
- function returns True (file should be updated).
"""
with open(JSON_SHOULD_STAY, 'r') as json_file:
json_content = json.loads(json_file.read())
assert should_keep_json_file(json_content, TEST_VERSION) is True
def test_handle_json__should_delete():
"""
Given
- A path to a json file that shouldn't stay - lower toVersion.
When
- Running should_keep_json_file on it.
Then
- function returns False (file should be deleted).
"""
with open(JSON_SHOULD_DELETE, 'r') as json_file:
json_content = json.loads(json_file.read())
assert should_keep_json_file(json_content, TEST_VERSION) is False
def test_handle_yml__should_stay():
"""
Given
- A path to a yml file that should stay - no fromversion.
When
- Running should_keep_yml_file on it.
Then
- function returns True (file should be updated)
"""
with open(YML_SHOULD_STAY, 'r') as yml_file:
yml_content = ryaml.load(yml_file)
assert should_keep_yml_file(yml_content, TEST_VERSION) is True
def test_handle_yml__should_delete():
"""
Given
- A path to a yml file that shouldn't stay - higher fromversion.
When
- Running should_keep_yml_file on it.
Then
- function returns False (file should be deleted)
"""
with open(YML_SHOULD_DELETE, 'r') as yml_file:
yml_content = ryaml.load(yml_file)
assert should_keep_yml_file(yml_content, TEST_VERSION) is True
def test_edit_playbooks_directory(tmp_path):
"""
Given
- A path to a tpb that should stay and its toversion field should change to 4.1.9.
When
- Running edit_playbooks_directory on it.
Then
- Tpb should be updated with a new toversion field.
"""
tmp_tpb = shutil.copyfile(TEST_TPB, f"{tmp_path}/tpb.yml")
edit_playbooks_directory(TEST_VERSION, tmp_path)
with open(tmp_tpb, 'r') as yml_file:
yml_content = ryaml.load(yml_file)
assert yml_content['toversion'] == '5.1.9'
| 28.701031 | 113 | 0.72306 |
7db6c61b4b486fd81c364e8df7c77eb7f0889b15
| 731 |
py
|
Python
|
Python/Tipos e comandos/RaizQuadrada.py
|
gianvstheworld/POO
|
f6b9d3d351d703d974a6ca031ee636aea7119367
|
[
"MIT"
] | null | null | null |
Python/Tipos e comandos/RaizQuadrada.py
|
gianvstheworld/POO
|
f6b9d3d351d703d974a6ca031ee636aea7119367
|
[
"MIT"
] | null | null | null |
Python/Tipos e comandos/RaizQuadrada.py
|
gianvstheworld/POO
|
f6b9d3d351d703d974a6ca031ee636aea7119367
|
[
"MIT"
] | null | null | null |
'''
-- Nome: Gianluca Capezzuto Sardinha
-- NUSP: 11876933
-- Exercício 1
'''
def main():
x = leu()
erro = 1
if(x > 10):
x0 = x/5
else:
x0 = x/2
xi = x0
yi = xi - 1
while(erro > 0.00000001):
xi = (yi+(x/yi))/2
erro = abs(xi - yi)
yi = xi
print("A raiz de {0} é {1}".format(x, xi))
def leu():
while(True):
try:
k = int(input('Digite um inteiro: '))
if(k < 0):
print('O número deve ser positivo!')
continue
break
except ValueError:
print('O valor digitado deve ser um número inteiro!')
return k
if __name__ == '__main__':
main()
| 14.333333 | 65 | 0.451436 |
81bd9e42d638dfc395c0e0fc5f1bdd497f537acf
| 1,213 |
py
|
Python
|
functions/utils.py
|
RodrigoLima82/workshop_health
|
b69324aaf3940f4a4b738d6575137849543e7aa0
|
[
"MIT"
] | 1 |
2021-02-28T20:50:11.000Z
|
2021-02-28T20:50:11.000Z
|
functions/utils.py
|
innovation4health/workshop_i4h
|
cf072071c3e788297180e86cd5c3f297d8a76bce
|
[
"MIT"
] | null | null | null |
functions/utils.py
|
innovation4health/workshop_i4h
|
cf072071c3e788297180e86cd5c3f297d8a76bce
|
[
"MIT"
] | null | null | null |
# Import de bibliotecas
import pandas as pd
import numpy as np
import glob
import random
from scipy.io import loadmat
import matplotlib.pyplot as plt
# Deep Learning
import tensorflow as tf
import keras
import keras.backend as K
from keras.models import load_model
from keras.utils.np_utils import to_categorical
# Imports
import biosppy
from biosppy.signals import ecg
## Função para preparar um dataframe com as feaures de Estratificacao de Riscos
def processamento(x, maxlen):
x = np.nan_to_num(x)
x = x[0, 0:maxlen]
x = x - np.mean(x)
x = x / np.std(x)
tmp = np.zeros((1, maxlen))
tmp[0, :len(x)] = x.T
x = tmp
x = np.expand_dims(x, axis = 2)
del tmp
return x
# Funcao para realizar as previsoes
def previsoes(model, x):
prob = model.predict(x)
ann = np.argmax(prob)
return prob, ann
# Função para estratificar o risco
def classifica_risco(registro):
# Condição 1
if registro[0] >= 0.8 and registro[1] == 1.0 :
return 'Alto'
# Condição 2
elif (registro[0] >= 0.6 or registro[0] < 0.8) and registro[1] == 1.0 :
return 'Médio'
# Condição 3
else:
return 'Baixo'
| 23.326923 | 79 | 0.642209 |
c48f27cd61d30e6a8a31d2dbdd703f56cfc05ce5
| 3,430 |
py
|
Python
|
test/test_npu/test_network_ops/test_masked_scatter.py
|
Ascend/pytorch
|
39849cf72dafe8d2fb68bd1679d8fd54ad60fcfc
|
[
"BSD-3-Clause"
] | 1 |
2021-12-02T03:07:35.000Z
|
2021-12-02T03:07:35.000Z
|
test/test_npu/test_network_ops/test_masked_scatter.py
|
Ascend/pytorch
|
39849cf72dafe8d2fb68bd1679d8fd54ad60fcfc
|
[
"BSD-3-Clause"
] | 1 |
2021-11-12T07:23:03.000Z
|
2021-11-12T08:28:13.000Z
|
test/test_npu/test_network_ops/test_masked_scatter.py
|
Ascend/pytorch
|
39849cf72dafe8d2fb68bd1679d8fd54ad60fcfc
|
[
"BSD-3-Clause"
] | null | null | null |
# Copyright (c) 2020 Huawei Technologies Co., Ltd
# Copyright (c) 2019, Facebook CORPORATION.
# All rights reserved.
#
# Licensed under the BSD 3-Clause License (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://opensource.org/licenses/BSD-3-Clause
#
# 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 torch
import numpy as np
import sys
import copy
import torch.nn as nn
from common_utils import TestCase, run_tests
from common_device_type import dtypes, instantiate_device_type_tests
from util_test import create_common_tensor
class TestMaskedScatter(TestCase):
def cpu_op_exec(self, input, maskbool, source):
cpu_output = torch.masked_scatter(input, maskbool, source)
return cpu_output.numpy()
def npu_op_exec(self, input, maskbool, source):
input = input.to("npu")
maskbool = maskbool.to("npu")
source = source.to("npu")
npu_output = torch.masked_scatter(input, maskbool, source)
npu_output = npu_output.to("cpu")
return npu_output.numpy()
def cpu_inp_op_exec(self, input, maskbool, source):
cpu_output = input.masked_scatter_(maskbool, source)
return cpu_output.numpy()
def npu_inp_op_exec(self, input, maskbool, source):
maskbool = maskbool.to("npu")
npu_output = input.masked_scatter_(maskbool, source)
npu_output = npu_output.to("cpu")
return npu_output.numpy()
def test_masked_scatter_float(self, device):
dtype_list = [np.float32]
format_list = [0, 3]
shape_list = [[4, 5],[3, 4, 5], [2, 3, 4, 5]]
shape_format = [
[i, j, k] for i in dtype_list for j in format_list for k in shape_list
]
mask = torch.randn(4, 1)
maskbool = mask.ge(0.5)
for item in shape_format:
print(item)
cpu_input, npu_input = create_common_tensor(item, 0, 100)
cpu_source, npu_source = create_common_tensor(item, 0, 100)
cpu_output2 = self.cpu_inp_op_exec(cpu_input, maskbool, cpu_source)
npu_output2 = self.npu_inp_op_exec(npu_input, maskbool, npu_source)
self.assertRtolEqual(cpu_output2, npu_output2)
def test_masked_scatter_int(self, device):
dtype_list = [np.int32, np.int64]
format_list = [0]
shape_list = [[4, 5],[3, 4, 5], [2, 3, 4, 5]]
shape_format = [
[i, j, k] for i in dtype_list for j in format_list for k in shape_list
]
mask = torch.randn(4, 1)
maskbool = mask.ge(0.5)
for item in shape_format:
print(item)
cpu_input, npu_input = create_common_tensor(item, 0, 100)
cpu_source, npu_source = create_common_tensor(item, 0, 100)
cpu_output2 = self.cpu_inp_op_exec(cpu_input, maskbool, cpu_source)
npu_output2 = self.npu_inp_op_exec(npu_input, maskbool, npu_source)
self.assertRtolEqual(cpu_output2, npu_output2)
instantiate_device_type_tests(TestMaskedScatter, globals(), except_for='cpu')
if __name__ == "__main__":
run_tests()
| 39.425287 | 82 | 0.672012 |
482aaec439195afc4bb1c655a4e9c37aab676bce
| 395 |
py
|
Python
|
lintcode/162-[DUP]-Find-Peak-Element/FindPeakELement_001.py
|
cc13ny/all-in
|
bc0b01e44e121ea68724da16f25f7e24386c53de
|
[
"MIT"
] | 1 |
2015-12-16T04:01:03.000Z
|
2015-12-16T04:01:03.000Z
|
lintcode/162-[DUP]-Find-Peak-Element/FindPeakELement_001.py
|
cc13ny/all-in
|
bc0b01e44e121ea68724da16f25f7e24386c53de
|
[
"MIT"
] | 1 |
2016-02-09T06:00:07.000Z
|
2016-02-09T07:20:13.000Z
|
lintcode/162-[DUP]-Find-Peak-Element/FindPeakELement_001.py
|
cc13ny/all-in
|
bc0b01e44e121ea68724da16f25f7e24386c53de
|
[
"MIT"
] | 2 |
2019-06-27T09:07:26.000Z
|
2019-07-01T04:40:13.000Z
|
class Solution:
# @param A: An integers list.
# @return: return any of peek positions.
def findPeak(self, A):
# write your code here
l, r = 1, len(A) - 2
while l <= r:
m = (l + r) / 2
if A[m - 1] >= A[m]:
r = m - 1
elif A[m] <= A[m + 1]:
l = m + 1
else:
return m
| 26.333333 | 44 | 0.374684 |
483edb028de3e0ec6374bebcbd01f67d56706c76
| 7,298 |
py
|
Python
|
TreeOutputLib/OneTimestepOneFile/OneTimestepOneFile.py
|
mcwimm/pyMANGA
|
6c7b53087e53b116bb02f91c33974f3dfd9a46de
|
[
"MIT"
] | 1 |
2021-03-16T08:35:50.000Z
|
2021-03-16T08:35:50.000Z
|
TreeOutputLib/OneTimestepOneFile/OneTimestepOneFile.py
|
mcwimm/pyMANGA
|
6c7b53087e53b116bb02f91c33974f3dfd9a46de
|
[
"MIT"
] | 67 |
2019-11-14T11:29:52.000Z
|
2022-03-09T14:37:11.000Z
|
TreeOutputLib/OneTimestepOneFile/OneTimestepOneFile.py
|
mcwimm/pyMANGA
|
6c7b53087e53b116bb02f91c33974f3dfd9a46de
|
[
"MIT"
] | 6 |
2019-11-12T11:11:41.000Z
|
2021-08-12T13:57:22.000Z
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@date: 2018-Today
@author: [email protected]
"""
from TreeOutputLib.TreeOutput import TreeOutput
import os
## Output class. This class creates one file per timestep at a defined
# location. A line containing time, position, desired geometric measures and
# desired parameters is written at every nth timestep.
class OneTimestepOneFile(TreeOutput):
## Constructor of dummy objects in order to drop output
# @param args xml element parsed from project to this constructor.
def __init__(self, args):
## Directory, where output is saved. Please make sure it exists and is
# empty.
self.output_dir = self.checkRequiredKey("output_dir", args)
## N-timesteps between two outputs
self.output_each_nth_timestep = int(
self.checkRequiredKey("output_each_nth_timestep", args))
## Check if overwrite of previous output is allowed
allow_previous_output = args.find("allow_previous_output")
if allow_previous_output is not None:
allow_previous_output = eval(allow_previous_output.text)
else:
allow_previous_output = False
## Geometric measures included in output
self.geometry_outputs = []
## Parameters included in output
self.parameter_outputs = []
## Parameters included in output
self.growth_outputs = []
## Network information included in output
self.network_outputs = []
## Counter for output generation
self._output_counter = 0
for key in args.iterchildren("geometry_output"):
self.geometry_outputs.append(key.text.strip())
for key in args.iterchildren("parameter_output"):
self.parameter_outputs.append(key.text.strip())
for key in args.iterchildren("growth_output"):
self.growth_outputs.append(key.text.strip())
for key in args.iterchildren("network_output"):
self.network_outputs.append(key.text.strip())
try:
dir_files = len(os.listdir(self.output_dir))
except FileNotFoundError:
print("No such directory: '" + self.output_dir +
"' as defined in the project file." +
" Creating directory...")
os.mkdir(self.output_dir)
dir_files = 0
if (dir_files > 0 and allow_previous_output == False):
raise ValueError("Output directory '" + self.output_dir +
"' is not empty.")
print(
"Output to '" + os.path.join(os.getcwd(), self.output_dir) +
"' of tree positions, the " + "parameters ",
self.parameter_outputs, " and geometric" + " measures ",
self.geometry_outputs, " at every " +
str(self.output_each_nth_timestep) + " timesteps initialized.")
## Writes output to predefined folder
# For each timestep a file is created throughout the simulation.
# This function is only able to work, if the output directory exists and
# is empty at the begin of the model run
def writeOutput(self, tree_groups, time):
self._output_counter = (self._output_counter %
self.output_each_nth_timestep)
if self._output_counter == 0:
delimiter = "\t"
filename = ("Population_t_%012.1f" % (time) + ".csv")
file = open(os.path.join(self.output_dir, filename), "w")
string = ""
string += 'tree' + delimiter + 'time' + delimiter + 'x' + \
delimiter + 'y'
string = self.addSelectedHeadings(string, delimiter)
string += "\n"
file.write(string)
for group_name, tree_group in tree_groups.items():
for tree in tree_group.getTrees():
growth_information = tree.getGrowthConceptInformation()
string = ""
string += (group_name + "_" + "%09.0d" % (tree.getId()) +
delimiter + str(time) + delimiter +
str(tree.x) + delimiter + str(tree.y))
string = self.addSelectedOutputs(tree, string, delimiter,
growth_information)
string += "\n"
file.write(string)
for growth_output in self.growth_outputs:
del (growth_information[growth_output])
file.close()
self._output_counter += 1
## This function checks if a key exists and if its text content is empty.
# Raises key-errors, if the key is not properly defined.
# @param key Name of the key to be checked
# @param args args parsed from project. Xml-element
def checkRequiredKey(self, key, args):
tmp = args.find(key)
if tmp is None:
raise KeyError("Required key '" + key + "' in project file at " +
"position MangaProject__tree_output is missing.")
elif tmp.text.strip() == "":
raise KeyError("Key '" + key + "' in project file at position " +
"MangaProject__tree_output needs to be specified.")
return tmp.text
## This function returns the output directory
def getOutputDir(self):
return self.output_dir
def addSelectedHeadings(self, string, delimiter):
for geometry_output in self.geometry_outputs:
string += delimiter + geometry_output
for parameter_output in self.parameter_outputs:
string += delimiter + parameter_output
for growth_output in self.growth_outputs:
string += delimiter + growth_output
for network_output in self.network_outputs:
string += delimiter + network_output
return string
def addSelectedOutputs(self, tree, string, delimiter, growth_information):
if len(self.geometry_outputs) > 0:
geometry = tree.getGeometry()
for geometry_output in self.geometry_outputs:
string += delimiter + str(geometry[geometry_output])
if len(self.parameter_outputs) > 0:
parameter = tree.getParameter()
for parameter_output in self.parameter_outputs:
string += delimiter + str(parameter[parameter_output])
if len(self.growth_outputs) > 0:
for growth_output_key in self.growth_outputs:
try:
string += delimiter + str(
growth_information[growth_output_key])
except KeyError:
growth_information[growth_output_key] = "NaN"
string += delimiter + str(
growth_information[growth_output_key])
print("Key " + growth_output_key +
" might be not available in growth " + "concept!" +
" Please read growth concept documentation.")
if len(self.network_outputs) > 0:
network = tree.getNetwork()
for network_output in self.network_outputs:
string += delimiter + str(network[network_output])
return string
| 46.484076 | 78 | 0.59345 |
48439a7d141690050f60cf03708c36507138af33
| 187 |
py
|
Python
|
exercises/ja/exc_01_03_01.py
|
tuanducdesign/spacy-course
|
f8d092c5fa2997fccb3f367d174dce8667932b3d
|
[
"MIT"
] | 2 |
2020-07-07T01:46:37.000Z
|
2021-04-20T03:19:43.000Z
|
exercises/ja/exc_01_03_01.py
|
tuanducdesign/spacy-course
|
f8d092c5fa2997fccb3f367d174dce8667932b3d
|
[
"MIT"
] | null | null | null |
exercises/ja/exc_01_03_01.py
|
tuanducdesign/spacy-course
|
f8d092c5fa2997fccb3f367d174dce8667932b3d
|
[
"MIT"
] | null | null | null |
# spaCyをインポートして、日本語のnlpオブジェクトを作成
import ____
nlp = ____
# テキストを処理
doc = ____("私はツリーカンガルーとイッカクが好きです。")
# 最初のトークンを選択
first_token = doc[____]
# 最初のトークンのテキストをプリント
print(first_token.____)
| 13.357143 | 35 | 0.775401 |
6f820b9982903ee83c2d6ec98f30ce9e18207a92
| 60 |
py
|
Python
|
samt/__init__.py
|
Killerhaschen/marvin-telegram-bot
|
c65e890a00450ed6ed4312d93e259db0c080ef6d
|
[
"MIT"
] | 1 |
2020-01-16T08:40:00.000Z
|
2020-01-16T08:40:00.000Z
|
samt/__init__.py
|
Killerhaschen/marvin-telegram-bot
|
c65e890a00450ed6ed4312d93e259db0c080ef6d
|
[
"MIT"
] | null | null | null |
samt/__init__.py
|
Killerhaschen/marvin-telegram-bot
|
c65e890a00450ed6ed4312d93e259db0c080ef6d
|
[
"MIT"
] | 1 |
2019-10-16T08:11:51.000Z
|
2019-10-16T08:11:51.000Z
|
from .samt import Bot, Answer, logger
from .helper import *
| 20 | 37 | 0.75 |
6fa64af864be6c4be8aa4eb590bef8b2954fd1e4
| 9,049 |
py
|
Python
|
Utils/py/PathPlanner/simulate_both.py
|
tarsoly/NaoTH
|
dcd2b67ef6bf9953c81d3e1b26e543b5922b7d52
|
[
"ECL-2.0",
"Apache-2.0"
] | null | null | null |
Utils/py/PathPlanner/simulate_both.py
|
tarsoly/NaoTH
|
dcd2b67ef6bf9953c81d3e1b26e543b5922b7d52
|
[
"ECL-2.0",
"Apache-2.0"
] | null | null | null |
Utils/py/PathPlanner/simulate_both.py
|
tarsoly/NaoTH
|
dcd2b67ef6bf9953c81d3e1b26e543b5922b7d52
|
[
"ECL-2.0",
"Apache-2.0"
] | null | null | null |
from __future__ import division
import LPG
import BISEC as B
from random import uniform as rand
import math
import sys
import numpy as np
from matplotlib import pyplot as plt
from matplotlib.patches import Circle
import matplotlib as mpl
import Queue as Q
import copy
import select
from sys import argv
import os.path
import sim
import naiv as N
import time
the_file, max_exp, filename, draw = sim.open_file(argv)
keys = {"p": False, "d": False, "e": False, "n": False, "r": False, "t": False, "escape": False, "f": False}
def key_pressed(event):
keys[str(event.key)] = True
def key_released(event):
keys[str(event.key)] = False
plt.connect("key_press_event", key_pressed)
#plt.connect("key_release_event", key_released)
# LPG parameters
base = 1.1789
minimal_cell = 100
angular_part = 16
parameter_s = 1
LPG_obstacles = []
obstacles = []
target = [0, 0]
robot_pos = (0, 0)
orig_robot_pos = copy.copy(robot_pos)
rot = np.arctan2(target[1], target[0]) # LPG
rot_a = LPG.get_a(target, rot) # LPG
orig_waypoints = LPG.compute_waypoints(target, LPG_obstacles, rot, rot_a)
orig_obstacles = copy.copy(obstacles)
orig_target = copy.copy(target)
waypoints = []
steps = []
actual_path_LPG = [(0, 0)]
actual_path_B = [(0, 0)]
actual_path_naiv = [(0, 0)]
all_robot = []
all_target = []
all_obstacle = []
all_path_LPG = []
all_path_B = []
all_path_naiv = []
times_LPG = []
times_B = []
times_naiv = []
pause = False
exp_count = 0
algorithm = 1
go_back_e = False
do_skip_e = False
do_skip_a = False
do_restart = False
show_sub = False
deadlock = False
loop_bool = True
save_current = False
current_all_path_B = []
current_all_path_LPG = []
current_all_path_naiv = []
current_target = []
current_obstacles = []
sim_obst = True
if len(argv) > 1:
if argv[1] is not 'f':
sim_obst = True
else:
sim_obst = False
# plot
while loop_bool:
if draw:
#mpl.rcParams['lines.linewidth'] = 0.5
plt.clf()
plt.axis("equal")
ax = plt.gca()
else:
ax = None
# check for key presses
if keys["p"] == True:
if pause:
print("Unpaused.")
elif not pause:
print("Paused.")
pause = not pause
keys["p"] = False
if keys["d"] == True:
print("Experiment " + str(exp_count) + ".")
print(orig_target, orig_obstacles)
keys["d"] = False
if len(argv) <= 3:
if keys["e"] == True:
print("Skipping current experiment.")
do_skip_e = True
#algorithm = 1
keys["e"] = False
if keys["n"] == True:
print("Switching algorithm.")
do_skip_a = True
keys["n"] = False
if keys["r"] == True:
print("Restarting experiment.")
do_restart = True
keys["r"] = False
if keys["f"] == True:
save_current = True
print("Saving current.")
keys["f"] = False
if keys["t"] == True:
show_sub = not show_sub
keys["t"] = False
if keys["escape"] == True:
sys.exit()
# switch algorithm
if np.absolute(robot_pos[0] - orig_target[0]) < 1 and np.absolute(robot_pos[1] - orig_target[1]) < 1 and algorithm < 3 or (algorithm < 3 and deadlock):
algorithm += 1
obstacles = copy.copy(orig_obstacles)
LPG_obstacles = copy.copy(orig_obstacles)
target = copy.copy(orig_target)
robot_pos = (0, 0)
deadlock = False
# skip current algorithm
if do_skip_a:
algorithm += 1
if algorithm == 4:
algorithm = 1
LPG_obstacles = copy.copy(orig_obstacles)
obstacles = copy.copy(orig_obstacles)
target = copy.copy(orig_target)
robot_pos = copy.copy(orig_robot_pos)
actual_path_LPG = [(0, 0)]
actual_path_B = [(0, 0)]
actual_path_naiv = [(0, 0)]
# restart current experiment
if do_restart:
target = copy.copy(orig_target)
robot_pos = copy.copy(orig_robot_pos)
obstacles = copy.copy(orig_obstacles)
LPG_obstacles = copy.copy(orig_obstacles)
actual_path_B = [(0, 0)]
actual_path_LPG = [(0, 0)]
actual_path_naiv = [(0, 0)]
do_restart = False
# save experiment and start next
if np.absolute(robot_pos[0] - orig_target[0]) < 1 and np.absolute(robot_pos[1] - orig_target[1]) < 1 and algorithm == 3 or do_skip_e or (deadlock and algorithm == 3):
deadlock = False
if not do_skip_e:
exp_count += 1
algorithm = 1
if exp_count > 1 and len(argv) > 3:
all_robot.append(copy.copy(orig_robot_pos))
all_target.append(copy.copy(orig_target))
all_obstacle.append(copy.copy(orig_obstacles))
all_path_LPG.append(copy.copy(actual_path_LPG))
all_path_B.append(copy.copy(actual_path_B))
all_path_naiv.append(copy.copy(actual_path_naiv))
everything = (all_robot, all_target, all_obstacle, all_path_LPG, all_path_B, all_path_naiv, times_LPG, times_B, times_naiv)
np.save(filename, everything)
if save_current:
current_all_path_LPG.append(copy.copy(actual_path_LPG))
current_all_path_B.append(copy.copy(actual_path_B))
current_all_path_naiv.append(copy.copy(actual_path_naiv))
current_target.append(orig_target)
current_obstacles.append(orig_obstacles)
current_everything = (current_target, current_all_path_LPG, current_all_path_B, current_all_path_naiv, current_obstacles)
np.save("current", current_everything)
save_current = False
print("Current saved.")
if len(argv) == 5:
loop_bool = eval('exp_count <= max_exp')
if not loop_bool:
sys.exit()
print("Experiment " + str(exp_count) + ".")
robot_pos, orig_robot_pos, target, orig_target, obstacles, orig_obstacles, LPG_obstacles, waypoints, orig_waypoints, actual_path_B, actual_path_LPG, actual_path_naiv = sim.new_experiment(sim_obst)
# stupid experiment???
do_skip_e = B.stupid_experiment(robot_pos, target, obstacles)
#if not do_skip_e:
# print(orig_target, orig_obstacles)
# plot field
if draw:
sim.draw_field(ax)
# draw obstacles
if draw:
B.draw_obstacles(ax, obstacles)
#LPG.draw_obstacles(ax, robot_pos, LPG_obstacles)
# LPG
if algorithm == 1:
start = time.time()
waypoints = LPG.compute_waypoints(target, LPG_obstacles, rot, rot_a)
if waypoints is not None:
gait = LPG.compute_gait(waypoints, target, rot)
times_LPG.append(time.time() - start)
#if draw:
#LPG.draw_waypoints(ax, waypoints, robot_pos, rot)
#if draw:
#LPG.draw_LPG(ax, robot_pos, rot)
# BISEC
if algorithm == 2:
start = time.time()
(gait, waypoints_B) = B.get_gait(robot_pos, target, obstacles, 0, ax, show_sub)
times_B.append(time.time() - start)
#if draw:
#ax.plot([robot_pos[0], target[0]],[robot_pos[1], target[1]], c='black') # straight trajectory line from robot_pos to target
# Naiv
if algorithm == 3:
start = time.time()
gait = N.compute_gait(robot_pos, target, obstacles)
times_naiv.append(time.time() - start)
# simulate the gait
if not pause and not do_skip_a:
gait, target, robot_pos, rot, rot_a, actual_path_B, actual_path_LPG, actual_path_naiv, obstacles, LPG_obstacles = sim.simulate(gait, target, robot_pos, rot, rot_a, actual_path_B, actual_path_LPG, actual_path_naiv, obstacles, orig_obstacles, LPG_obstacles, algorithm, sim_obst)
deadlock = (len(actual_path_naiv) > 200 and algorithm == 3) or (len(actual_path_LPG) > 200 and algorithm == 1) or (len(actual_path_B) > 200 and algorithm == 2)
if deadlock:
if algorithm == 1:
actual_path_LPG = []
print(" ------------ DEADLOCK LPG ------------")
elif algorithm == 2:
print(" ------------ DEADLOCK BISEC ------------")
actual_path_B = []
elif algorithm == 3:
print(" ------------ DEADLOCK NAIV ------------")
actual_path_naiv = []
# draw actual path
if draw:
sim.draw_path(actual_path_LPG, actual_path_B, actual_path_naiv, ax, algorithm)
# draw target and robot
if draw:
sim.draw_tar_rob(orig_target, robot_pos, ax)
do_skip_a = False
if draw:
ax.set_xlim([-5500, 5500])
ax.set_ylim([-3500, 3500])
plt.pause(0.000000000001)
| 32.433692 | 284 | 0.591557 |
5849a5285404f54763988871948637f2c0fa1643
| 8,990 |
py
|
Python
|
DDPG/DDPG_agent.py
|
pickxiguapi/rl-algorithm
|
a57991acd178077fd7f51bcd4ae2ee58492475c2
|
[
"MIT"
] | 2 |
2021-01-06T09:45:23.000Z
|
2021-04-21T09:39:14.000Z
|
DDPG/DDPG_agent.py
|
pickxiguapi/rl-algorithm
|
a57991acd178077fd7f51bcd4ae2ee58492475c2
|
[
"MIT"
] | null | null | null |
DDPG/DDPG_agent.py
|
pickxiguapi/rl-algorithm
|
a57991acd178077fd7f51bcd4ae2ee58492475c2
|
[
"MIT"
] | null | null | null |
# -*- encoding: utf-8 -*-
"""
@File : DDPG_agent.py
@Time : 2020/12/12
@Author : Yuan Yifu
"""
from gym import Env
from utils import OrnsteinUhlenbeckActionNoise, hard_update, soft_update
from DDPG_net import Actor, Critic
import torch
import numpy as np
import torch.nn.functional as F
import random
from collections import defaultdict
from tqdm import tqdm
class Transition(object):
def __init__(self, s=None, a=None, reward=None, done=None, s_=None):
self.data = [s, a, reward, done, s_]
def __str__(self):
return "s:{0:<3} a:{1:<3} r:{2:<4} done:{3:<5} s_:{4:<3}". \
format(str(self.data[0]), str(self.data[1]), str(self.data[2]), str(self.data[3]), str(self.data[4]))
@property
def s(self): return self.data[0]
@property
def a(self): return self.data[1]
@property
def reward(self): return self.data[2]
@property
def done(self): return self.data[3]
@property
def s_(self): return self.data[4]
class Agent(object):
"""
Agent 基类
"""
def __init__(self, env: Env = None,
capacity=1000):
# 保存一些Agent可以观测到的环境信息以及已经学到的经验
self.env = env # 建立对环境对象的引用
self.obs_space = env.observation_space if env is not None else None
self.action_space = env.action_space if env is not None else None
self.state = None # 个体的当前状态
# experience replay
self.max_capacity = capacity
self.pointer = 0
self.memory = defaultdict(Transition)
def store_transition(self, trans):
index = self.pointer % self.max_capacity # replace the old memory with new memory
index = int(index)
self.memory[index] = trans
self.pointer += 1
def step(self, a):
s = self.state
s_, r, done, info = self.env.step(a)
trans = Transition(s, a, r, done, s_)
self.store_transition(trans)
self.state = s_
return s_, r, done, info
def sample(self, batch_size=64):
"""
随机取样batch_size个样本，保证经验池满了之后再开始取样
:param batch_size:
:return:
"""
sample_trans = []
for _ in range(batch_size):
index = random.randint(0, self.max_capacity - 1)
sample_trans.append(self.memory[index])
return sample_trans
@property
def total_trans(self):
return len(self.memory)
# mu: Actor mu': Target Actor
# Q: Critic Q': Target Critic
class DDPGAgent(Agent):
def __init__(self, env: Env,
capacity=10000,
batch_size=128,
action_limit=1,
learning_rate=0.001,
gamma=0.99,):
super(DDPGAgent, self).__init__(env, capacity)
self.state_dim = env.observation_space.shape[0] # 状态特征数
self.action_dim = env.action_space.shape[0] # 动作特征数
self.action_lim = action_limit # 动作值限制
self.batch_size = batch_size # batch num
self.learning_rate = learning_rate # 学习率
self.gamma = gamma
self.tau = 0.001 # soft update
self.noise = OrnsteinUhlenbeckActionNoise(self.action_lim)
self.actor = Actor(self.state_dim, self.action_dim, self.action_lim)
self.target_actor = Actor(self.state_dim, self.action_dim, self.action_lim)
self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), self.learning_rate)
self.critic = Critic(self.state_dim, self.action_dim)
self.target_critic = Critic(self.state_dim, self.action_dim)
self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), self.learning_rate)
hard_update(self.target_actor, self.actor)
hard_update(self.target_critic, self.critic)
def save_models(self, episode_count):
torch.save(self.target_actor.state_dict(), './Models/' + str(episode_count) + '_actor.pt')
torch.save(self.target_critic.state_dict(), './Models/' + str(episode_count) + '_critic.pt')
print("Models saved successfully")
def load_models(self, episode):
self.actor.load_state_dict(torch.load('./Models/' + str(episode) + '_actor.pt'))
self.critic.load_state_dict(torch.load('./Models/' + str(episode) + '_critic.pt'))
hard_update(self.target_actor, self.actor)
hard_update(self.target_critic, self.critic)
print("Models loaded successfully")
def _learn_from_memory(self):
"""
learn from memory
:return:
"""
# 获取batch size个transition
trans_pieces = self.sample(self.batch_size)
s = np.vstack([x.s for x in trans_pieces])
a = np.array([x.a for x in trans_pieces])
r = np.array([x.reward for x in trans_pieces])
s_ = np.vstack([x.s_ for x in trans_pieces])
# Set yi = r + gamma * Q'(s_, mu'(s_))
a_ = self.target_actor.forward(s_).detach()
Q_ = torch.squeeze(self.target_critic.forward(s_, a_).detach())
r = torch.from_numpy(r)
y_target = r + self.gamma * Q_
y_target = y_target.type(torch.FloatTensor)
# y_pred = Q(s, a)
a = torch.from_numpy(a)
y_pred = torch.squeeze(self.critic.forward(s, a))
# Update critic by minimizing the loss: L = smooth_l1_loss(y_pred, y_target)
loss_critic = F.smooth_l1_loss(y_pred, y_target)
self.critic_optimizer.zero_grad()
loss_critic.backward()
self.critic_optimizer.step()
# Update the actor policy using the sampled policy gradient
# grad J = sum(grad Q(s, mu(s)))
"""
$$
\left.\left.\nabla_{\theta^{\mu}} J \approx \frac{1}{N} \sum_{i} \nabla_{a} Q\left(s, a \mid \theta^{Q}\right)\right|_{s=s_{i}, a=\mu\left(s_{i}\right)} \nabla_{\theta^{\mu}} \mu\left(s \mid \theta^{\mu}\right)\right|_{s_{i}}
$$
"""
pred_a = self.actor.forward(s) # mu(s)
# 梯度上升
loss_actor = -1 * torch.sum(self.critic.forward(s, pred_a))
self.actor_optimizer.zero_grad()
loss_actor.backward()
self.actor_optimizer.step()
# Update the target networks
soft_update(self.target_actor, self.actor, self.tau)
soft_update(self.target_critic, self.critic, self.tau)
return loss_critic.item(), loss_actor.item()
def running(self, episode_num=800, display=False, explore=True):
step_list = []
episode_reward_list = []
for i_episode in range(episode_num):
self.state = np.float64(self.env.reset())
done = False
# init episode loss (loss: loss_total / step_num)
loss_critic, loss_actor = 0, 0
# init step_num
step_num = 0
# init episode reward
episode_reward = 0
# episode index
episode_index = i_episode + 1
while not done:
# get state
s = self.state
# Select action
if explore:
# a = mu(s) + N
a = self.get_exploration_action(s)
else:
# a = mu(s)
a = self.get_action(s)
# Execute action a and observe reward r and observe new state s_
# Store transition(s, a, r, s_) in experience replay
s_, r, done, info = self.step(a)
# update reward
episode_reward += r
if display:
self.env.render()
# calculate loss
if self.total_trans >= self.max_capacity:
loss_c, loss_a = self._learn_from_memory()
loss_critic += loss_c
loss_actor += loss_a
# step num ++
step_num += 1
if step_num >= 4000:
done = True
# an episode end, calculate some info
loss_critic /= step_num
loss_actor /= step_num
step_list.append(step_num)
episode_reward_list.append(episode_reward)
print("episode:{:3}, step num:{}, reward:{}, loss critic:{:4.3f}, loss_actor:{:4.3f}".
format(episode_index, step_num, episode_reward, loss_critic, loss_actor))
if explore and episode_index % 100 == 0:
self.save_models(episode_index)
return step_list, episode_reward_list
def get_exploration_action(self, state):
"""
exploration 探索
:param state: state numpy float64
:return:
"""
action = self.actor.forward(state).detach()
new_action = action.data.numpy() + (self.noise.sample() * self.action_lim)
new_action = new_action.clip(min=-1 * self.action_lim,
max=self.action_lim)
return new_action
def get_action(self, state):
return self.actor.forward(state).detach().data.numpy()
| 33.670412 | 241 | 0.582759 |
585fa642e937fcf9127030822a7313deb8dc4a9a
| 4,394 |
py
|
Python
|
src/test/tests/queries/queryMultiWindow.py
|
visit-dav/vis
|
c08bc6e538ecd7d30ddc6399ec3022b9e062127e
|
[
"BSD-3-Clause"
] | 226 |
2018-12-29T01:13:49.000Z
|
2022-03-30T19:16:31.000Z
|
src/test/tests/queries/queryMultiWindow.py
|
visit-dav/vis
|
c08bc6e538ecd7d30ddc6399ec3022b9e062127e
|
[
"BSD-3-Clause"
] | 5,100 |
2019-01-14T18:19:25.000Z
|
2022-03-31T23:08:36.000Z
|
src/test/tests/queries/queryMultiWindow.py
|
visit-dav/vis
|
c08bc6e538ecd7d30ddc6399ec3022b9e062127e
|
[
"BSD-3-Clause"
] | 84 |
2019-01-24T17:41:50.000Z
|
2022-03-10T10:01:46.000Z
|
# ----------------------------------------------------------------------------
# CLASSES: nightly
#
# Test Case: queryMultiWindow.py #
# Tests: queries - Database
#
# Defect ID: none
#
# Programmer: Kathleen Bonnell
# Date: May 19, 2004
#
# Modifications:
# Kathleen Bonnell, Mon Dec 20 15:54:04 PST 2004
# Changed 'Variable by Zone' to 'PickByZone' and 'Variable by Node' to
# 'PickByNode'.
#
# Kathleen Bonnell, Thu Apr 3 10:00:48 PDT 2008
# Added tests from bug 8425.
#
# Mark C. Miller, Wed Jan 20 07:37:11 PST 2010
# Added ability to swtich between Silo's HDF5 and PDB data.
#
# Kathleen Biagas, Thu Jul 14 10:44:55 PDT 2011
# Clean up unused / unnecessary query arguments.
#
# ----------------------------------------------------------------------------
def QueryMultiWindow():
OpenDatabase(silo_data_path("wave*.silo database"))
AddPlot("Pseudocolor", "pressure")
SetTimeSliderState(31)
DrawPlots()
v = GetView3D()
v.viewNormal = (0, -1, 0)
v.viewUp = (0, 0, 1)
SetView3D(v)
CloneWindow()
SetTimeSliderState(64)
DrawPlots()
ChangeActivePlotsVar("v")
s = "Window 1 queries:\n"
SetActiveWindow(1)
Query("MinMax")
s = s + GetQueryOutputString()
Query("3D surface area")
s = s + GetQueryOutputString() + "\n"
Query("Volume")
s = s + GetQueryOutputString() + "\n"
PickByZone(7072)
s = s + GetPickOutput() + "\n"
PickByNode(11168)
s = s + GetPickOutput() + "\n"
Query("Variable Sum")
s = s + GetQueryOutputString() + "\n"
Query("Weighted Variable Sum")
s = s + GetQueryOutputString() + "\n"
Query("NumNodes", use_actual_data=0)
s = s + GetQueryOutputString() + "\n"
Query("NumZones", use_actual_data=0)
s = s + GetQueryOutputString() + "\n"
s = s + "\nWindow 2 queries:\n"
SetActiveWindow(2)
Query("MinMax")
s = s + GetQueryOutputString()
Query("3D surface area")
s = s + GetQueryOutputString() + "\n"
Query("Volume")
s = s + GetQueryOutputString() + "\n"
PickByZone(7072)
s = s + GetPickOutput() + "\n"
PickByNode(11168)
s = s + GetPickOutput() + "\n"
Query("Variable Sum")
s = s + GetQueryOutputString() + "\n"
Query("Weighted Variable Sum")
s = s + GetQueryOutputString() + "\n"
Query("NumNodes", use_actual_data=0)
s = s + GetQueryOutputString() + "\n"
Query("NumZones", use_actual_data=0)
s = s + GetQueryOutputString() + "\n"
#Delete window 2
DeleteWindow()
#Delete plots in window 1
DeleteAllPlots()
#bug 8425 (multiple windows, same db, same timestate)
OpenDatabase(silo_data_path("rect3d.silo"))
DefineScalarExpression("X", "coord(quadmesh3d)[0]")
DefineScalarExpression("unnamed1", "X-1")
DefineScalarExpression("unnamed2", "X-2")
DefineScalarExpression("unnamed3", "X-3")
SetWindowLayout(4)
AddPlot("Pseudocolor", "unnamed1")
DrawPlots()
Query("Weighted Variable Sum")
s = s + "\n" + GetQueryOutputString() + "\n"
SetActiveWindow(2)
AddPlot("Pseudocolor", "unnamed2")
DrawPlots()
Query("Weighted Variable Sum")
s = s + GetQueryOutputString() + "\n"
SetActiveWindow(3)
AddPlot("Pseudocolor", "unnamed3")
DrawPlots()
Query("Weighted Variable Sum")
s = s + GetQueryOutputString() + "\n"
SetActiveWindow(2)
Query("Weighted Variable Sum")
s = s + GetQueryOutputString() + "\n"
SetActiveWindow(4)
DeleteWindow()
SetActiveWindow(3)
DeleteWindow()
SetActiveWindow(2)
DeleteWindow()
DeleteAllPlots()
#bug 8425 (multiple plots, same window, same db, same root var)
OpenDatabase(silo_data_path("multi_rect2d.silo"))
DefineScalarExpression("p2", "p*p")
DefineScalarExpression("p3", "p*p*p")
AddPlot("Pseudocolor", "p")
AddPlot("Pseudocolor", "p2")
AddPlot("Pseudocolor", "p3")
DrawPlots()
SetActivePlots(0)
Query("Weighted Variable Sum")
s = s + "\n" + GetQueryOutputString() + "\n"
SetActivePlots(1)
Query("Weighted Variable Sum")
s = s + GetQueryOutputString() + "\n"
SetActivePlots(2)
Query("Weighted Variable Sum")
s = s + GetQueryOutputString() + "\n"
TestText("QueryMultiWindow", s)
DeleteAllPlots()
# Call the main function
TurnOnAllAnnotations()
QueryMultiWindow()
Exit()
| 28.348387 | 79 | 0.604233 |
5499ef2d22bffe32560bb21773e6a84a5a234d4b
| 1,404 |
py
|
Python
|
analyzer/convertcerts.py
|
ringvorlesung2019mgm/twitter-bingo
|
f0a1f40024e335977b395049618dafda123e7a8f
|
[
"Apache-2.0"
] | 2 |
2019-01-15T12:22:43.000Z
|
2021-09-08T15:58:49.000Z
|
analyzer/convertcerts.py
|
ringvorlesung2019mgm/twitter-bingo
|
f0a1f40024e335977b395049618dafda123e7a8f
|
[
"Apache-2.0"
] | 47 |
2018-11-08T14:06:13.000Z
|
2019-01-05T17:40:26.000Z
|
analyzer/convertcerts.py
|
ringvorlesung2019mgm/twitter-bingo
|
f0a1f40024e335977b395049618dafda123e7a8f
|
[
"Apache-2.0"
] | null | null | null |
from OpenSSL import crypto
import os.path
"""
Converts a x509 certificate to a PEM-encoded string
"""
def dump_cert(cert):
out = ""
out += "Subject: "+ ", ".join(x[0].decode()+":"+x[1].decode() for x in cert.get_subject().get_components())+"\n"
out += "Issuer: "+ ", ".join(x[0].decode()+":"+x[1].decode() for x in cert.get_issuer().get_components())+"\n"
out += crypto.dump_certificate(crypto.FILETYPE_PEM,cert).decode()
return out
"""
Given a file-path leading to a pkcs12 certificate-store this function converts the file to the PEM format and stores it with the same name but .pem suffix
"""
def pkcs12_to_pem(file,password,skip_existing=False):
filename, _ = os.path.splitext(file)
newfile = filename + ".pem"
if os.path.exists(newfile) and skip_existing:
return
with open(file,"rb") as f:
pkcs = crypto.load_pkcs12(f.read(),password)
cert = ""
pkey = ""
cas = []
if pkcs.get_certificate():
cert = dump_cert(pkcs.get_certificate())
if pkcs.get_privatekey():
pkey = crypto.dump_privatekey(crypto.FILETYPE_PEM,pkcs.get_privatekey(),'aes256',password.encode()).decode()
for ca in pkcs.get_ca_certificates():
cas.append(dump_cert(ca))
filecontent = cert+"\n"+pkey+"\n".join(cas)
with open(newfile,"w") as t:
t.write(filecontent)
| 39 | 154 | 0.62963 |
549c0e1a3ee8ef15b233d93b99c55deaaab5f2a1
| 14,657 |
py
|
Python
|
tpl/wbs_export.py
|
nussbrot/code-exchange
|
3427798c4391e5f9c17cd19399ac56997c091ee2
|
[
"MIT"
] | null | null | null |
tpl/wbs_export.py
|
nussbrot/code-exchange
|
3427798c4391e5f9c17cd19399ac56997c091ee2
|
[
"MIT"
] | null | null | null |
tpl/wbs_export.py
|
nussbrot/code-exchange
|
3427798c4391e5f9c17cd19399ac56997c091ee2
|
[
"MIT"
] | null | null | null |
"""
This module can export a Wishbone slave to VHDL from an SXL 'block' description
@author rhallmen
@date 20.06.2017
"""
import sys
import math
import re
from string import Template
from getpass import getuser
import datetime
import argparse
from os.path import basename, splitext
from antlr4 import *
sys.path.append('../python')
from sxlLexer import sxlLexer
from sxlParser import sxlParser
from sxlVisitor import sxlVisitor
from BlockSizeVisitor import BlockSizeVisitor
from RegisterAddressVisitor import RegisterAddressVisitor
from SignalVisitor import SignalVisitor, Position, Signal
class WbTemplate(Template):
"""
Subclass of Template class, because our templates use %identifier% as
placeholder. Also note the % at the end, this requires special handling
with an dictionary, since % is not an allowed character for python ids.
E.g. %id% -> the identifier to match is id%.
"""
delimiter = '%'
idpattern = r'[_a-z][_a-z0-9]*?%'
@classmethod
def from_file(cls, path):
"""Get an instance of this class with the template string
read from file @path
"""
with open(path, 'r') as file:
tpl = file.read()
return cls(tpl)
def _setup_parser():
parser = argparse.ArgumentParser(description="Export a wishbone slave")
parser.add_argument('-p', '--project', default='Solectrix Uber Project')
parser.add_argument('-t', '--template', default='wb_reg_no_rst.tpl.vhd')
parser.add_argument('sxl_file', help="sxl input")
parser.add_argument('sxl_block', help="which sxl block from sxl_file to export")
parser.add_argument('vhdl_file', help="vhdl output")
return parser
def _setup_dictionary(project, vhdl_file, tpl_file):
"""
All placeholders found in the template file need to have a
key value pair in a dictionary. For all SXL independent placeholders
this dict is build right here.
"""
date = datetime.date.today()
library = """
LIBRARY fun_lib;
USE fun_lib.wishbone_pkg.ALL;
"""
id_dic = {
'TPL_YEAR%':date.year,
'TPL_DATE%':date.strftime('%d.%m.%Y'),
'TPL_SCRIPT%':basename(__file__),
'TPL_TPLFILE%':basename(tpl_file),
'TPL_USER%':getuser(),
'TPL_LIBRARY%':library,
'TPL_PROCEDURES%':'',
'TPL_PROJECT%':project,
'TPL_VHDLFILE%':basename(vhdl_file),
'TPL_MODULE%':basename(splitext(vhdl_file)[0]),
}
return id_dic
def _setup_sxl_parse_tree(path):
"""Returning an ANTLR parse tree of the SXL file at path"""
inp = FileStream(path)
lexer = sxlLexer(inp)
stream = CommonTokenStream(lexer)
parser = sxlParser(stream)
tree = parser.blocks()
return tree
FIRST_CAP_RE = re.compile('(.)([A-Z][a-z]+)')
ALL_CAP_RE = re.compile('([a-z0-9])([A-Z])')
def convert(name):
"""Convert CamelCase to camel_case"""
name = FIRST_CAP_RE.sub(r'\1_\2', name)
return ALL_CAP_RE.sub(r'\1_\2', name).lower()
def double_quote(string):
"""Place double quotes around the given string"""
return '"' + string + '"'
def single_quote(string):
"""Place single quotes around the given string"""
return "'" + string + "'"
ADDR_PRE = "c_addr_"
def _addr_name(name):
return ADDR_PRE + convert(name)
def _rename_addr_dict(dic):
old_keys = list(dic.keys())
for key in old_keys:
name = _addr_name(key)
dic[name] = dic.pop(key)
INDENT = " "
def _join_with_indent(lis, indent_level):
string = "\n" + indent_level*INDENT
return string.join(lis)
def _format_reg_addr(dic):
# sort dict for addresses
sort = sorted(dic.items(), key=lambda x: x[1])
string = "CONSTANT {:21} : INTEGER := 16#{:04x}#;"
result = []
for name, addr in sort:
result.append(string.format(name, addr))
return result
def _format_addr_validation(items):
string = "'1' WHEN {},"
result = []
for key in items:
result.append(string.format(_addr_name(key)))
return result
def _format_notifier_constant(has_notify):
string = "CONSTANT {:21} : BOOLEAN := {};"
return [string.format("c_has_read_notifies", str(has_notify).upper())]
OUT_PRE = "o_"
IN_PRE = "i_"
PORT_DIC = {True:IN_PRE, False:OUT_PRE}
def _port_name(sig: Signal):
return PORT_DIC[sig.isInput] + convert(sig.name)
VECTOR = "STD_LOGIC_VECTOR"
BIT = "STD_LOGIC"
PORT_STRING = "{:25} : {:3} {};"
def _format_port_signal(signals):
"""
This deviates from the other format functions, because the dict
we get is filled with shallow Signal objects.
"""
result = []
for key, sig in signals.items():
if sig.isInput:
_dir = "IN"
else:
_dir = "OUT"
if sig.position.isRange:
_type = VECTOR + sig.position.decl()
else:
_type = BIT
_name = _port_name(sig)
result.append(PORT_STRING.format(_name, _dir, _type))
return result
READ_POST = "_trd"
WRITE_POST = "_twr"
def iter_notify_port(notifies):
"""
Generator. Expects a dict containing the name of the
notifier as keys and the mode ('rw'|'wo'|'ro') as value.
"""
for key, mode in notifies.items():
if mode in ['ro', 'rw']:
_name = OUT_PRE + convert(key) + READ_POST
yield (_name, "read")
if mode in ['wo', 'rw']:
_name = OUT_PRE + convert(key) + WRITE_POST
yield (_name, "read")
def _format_port_notify(notifies):
"""
This function expects a dict containing the name of the
notifier as keys and the mode ('rw'|'wo'|'ro') as value.
Notifies are always outputs.
"""
result = []
for _name, _ in iter_notify_port(notifies):
result.append(PORT_STRING.format(_name, "OUT", BIT))
return result
def _check_reset(reset, pos):
assert 2**len(pos) > reset
def _reset_bit_twiddling(reset, pos, old_reset):
_check_reset(reset, pos)
# we made sure reset fits into pos. No further checks are needed.
return old_reset | (reset << pos.right)
WO_PRE = "s_wo_"
T_PRE = "s_trg_"
RW_PRE = "s_rw_"
C_PRE = "s_const_"
REG_PRE = "s_reg_"
SIGNAL_DIC = {'wo':WO_PRE, 't':T_PRE, 'rw':RW_PRE, 'c':C_PRE}
def _sig_name(sig: Signal):
return SIGNAL_DIC[sig.mode] + convert(sig.name)
def _reg_name(reg):
return REG_PRE + convert(reg)
def _format_register_decl(regs):
"""
This function expects an dict of a list. With the keys being
the register names and the list containing corresponding
signal objects.
"""
result = []
_type = VECTOR + Position(True, 31, 0).decl()
string = 'SIGNAL {:30} : {} := x"{:08x}";'
for key, sigs in regs.items():
_reset = 0
_name = _reg_name(key)
for sig in sigs:
_reset = _reset_bit_twiddling(sig.reset, sig.position, _reset)
result.append(string.format(_name, _type, _reset))
return result
def _format_register_default(sigs, notifies):
"""
Grab trigger signals from sigs and notifies from notifies.
Default values are set on port names
"""
result = []
string = '{:30} <= {};'
# handle trigger signals
for sig in iter_signals_with_mode(sigs.values(), ['t']):
_name = _port_name(sig)
_value = "(OTHERS => '0')"
if len(sig.position) == 1:
_value = "'0'"
result.append(string.format(_name, _value))
# handle notifies
_value = "'0'"
for _name, _ in iter_notify_port(notifies):
result.append(string.format(_name, _value))
return result
def _mask_from_pos(pos: Position):
return (2**len(pos)-1) << pos.right
def _format_mask(mask):
return 'x"{:08x}"'.format(mask)
def _format_register_write(regs, validate, notifies):
"""
All writes must be gathered and written to a result list.
However this is unfortunately complicated.
- notifies: a dict with reg name as key and the notify type as value.
- validate: a list with validated register names. Only those may be added.
- regs: a dict with reg names as keys and corresponding signals as items.
"""
result = []
str_case = "WHEN {} =>"
fun_dic = {"rw":"set_reg", "wo":"set_reg", "t":"set_trg"}
str_reg = INDENT + "{}(s_int_data, s_int_we, {}, {});"
str_write_vec = INDENT + "set_write_port(s_int_data, s_int_we, {left}, {right}, {name});"
str_write_bit = INDENT + "set_write_port(s_int_data, s_int_we, {left}, {name});"
str_not = INDENT + "set_notify({}, {});"
not_dic = {"read":"s_int_trd", "write":"s_int_twr"}
# looping over validated registers
for reg_name in validate:
# First add the address. If we don't need it we will remove it later.
result.append(str_case.format(_addr_name(reg_name)))
# Each name in validate is also in regs, but not necessarily in notifies
sigs = regs[reg_name]
mask = 0
has_items = False
for sig in sigs:
if sig.mode in ['rw']:
has_items = True
# for rw registers a single statement is added, after building the mask
mask |= _mask_from_pos(sig.position)
if sig.mode in ['wo', 't']:
has_items = True
string_dic = {
"left":sig.position.left,
"right":sig.position.right,
"name":_port_name(sig)}
# write only signals have their own statement and map directly to ports
if len(sig.position) == 1:
string = str_write_bit
else:
string = str_write_vec
result.append(string.format(**string_dic))
# add rw if a mask is set
if mask > 0:
result.append(str_reg.format(fun_dic['rw'], _format_mask(mask), _reg_name(reg_name)))
# check if register has notifier
if reg_name in notifies:
has_items = True
for name, mode in iter_notify_port({reg_name:notifies[reg_name]}):
result.append(str_not.format(not_dic[mode], name))
# if we don't have items added, we remove the address
if not has_items:
result.pop()
return result
def iter_signals_with_mode(sigs, mode_list):
"""
return an iterator over sigs where sig.mode is in mode_list
"""
return filter(lambda sig: sig.mode in mode_list, sigs)
def _format_read_only(regs):
"""
Needed are read-only signals and their corresponding register names
"""
string = "{:39} <= {};"
result = []
for reg_name, sigs in regs.items():
# just iterate over read-only signals
for sig in iter_signals_with_mode(sigs, ['ro']):
reg_slice = _reg_name(reg_name) + str(sig.position)
result.append(string.format(reg_slice, _port_name(sig)))
return result
def _format_register_out(validate, regs):
"""
- validate: a list with all validated register names
- regs: a dictionary with register name as key and a list of signals as values
"""
string = "{reg:25} AND {mask} WHEN {addr},"
result = []
for reg in validate:
string_dic = {"reg":_reg_name(reg), "addr":_addr_name(reg)}
mask = 0
for sig in iter_signals_with_mode(regs[reg], ['ro', 'c', 'rw']):
mask |= _mask_from_pos(sig.position)
# add only if there are signals to read back
if mask > 0:
string_dic["mask"] = _format_mask(mask)
result.append(string.format(**string_dic))
return result
def _format_output_mapping(regs):
"""
All registers that can be read back, but are output ports need to be mapped
here. Currently these are signals with mode 'c' and 'rw'.
This will be obsolete once we decide to allow VHDL 2008, where ports with
mode out can be read back.
- regs: a dict with register name as key and a list of signals as value
"""
string = "{port:25} <= {reg}{slice};"
result = []
for reg, sigs in regs.items():
string_dic = {"reg":_reg_name(reg)}
for sig in iter_signals_with_mode(sigs, ['rw', 'c']):
string_dic["port"] = _port_name(sig)
string_dic["slice"] = str(sig.position)
result.append(string.format(**string_dic))
return result
def main(project, sxl_file, sxl_block, vhdl_file, tpl_file):
"""The main routine of this module"""
# setup dictionary
id_dic = _setup_dictionary(project, vhdl_file, tpl_file)
tree = _setup_sxl_parse_tree(sxl_file)
# get the block size
v = BlockSizeVisitor()
v.visit(tree)
tmp = v.dict[sxl_block]
block_size = math.ceil(math.log(tmp, 2))
id_dic['TPL_WBSIZE%'] = block_size
# get the register addresses
v = RegisterAddressVisitor()
v.visit(tree)
addr_dic = v.addr
_rename_addr_dict(addr_dic)
const = _format_reg_addr(addr_dic)
const.extend(_format_notifier_constant(v.has_read_notify))
id_dic['TPL_CONSTANTS%'] = _join_with_indent(const, 1)
# re-use the above visitor to also handle address validation
valids = v.validate
validate = _format_addr_validation(valids)
id_dic['TPL_ADDR_VALIDATION%'] = _join_with_indent(validate, 2)
# look at port declaration
v = SignalVisitor()
v.visit(tree)
ports = _format_port_signal(v.sigs)
ports.extend(_format_port_notify(v.notifies))
id_dic['TPL_PORTS%'] = _join_with_indent(ports, 2)
# look at register and signal declaration
signals = _format_register_decl(v.regs)
id_dic['TPL_REGISTERS%'] = _join_with_indent(signals, 1)
# look at default values
defaults = _format_register_default(v.sigs, v.notifies)
id_dic['TPL_REG_DEFAULT%'] = _join_with_indent(defaults, 3)
# look at wishbone write
writes = _format_register_write(v.regs, valids, v.notifies)
id_dic['TPL_REG_WR%'] = _join_with_indent(writes, 4)
# look at wishbone read-only
reads = _format_read_only(v.regs)
id_dic['TPL_REG_RD%'] = _join_with_indent(reads, 3)
# look at wishbone read back
readout = _format_register_out(valids, v.regs)
id_dic['TPL_REG_DATA_OUT%'] = _join_with_indent(readout, 2)
# look at output port mapping
mapping = _format_output_mapping(v.regs)
id_dic['TPL_PORT_REG_OUT%'] = _join_with_indent(mapping, 1)
# do the template substitution
tpl = WbTemplate.from_file(tpl_file)
with open(vhdl_file, 'w') as file:
file.write(tpl.substitute(id_dic))
if __name__ == '__main__':
PARSER = _setup_parser()
ARGS = PARSER.parse_args()
main(
ARGS.project, ARGS.sxl_file, ARGS.sxl_block,
ARGS.vhdl_file, ARGS.template)
| 32.284141 | 97 | 0.641536 |
3fc9fea0355688e95f8f4a2ede2fbdbde10c263d
| 207 |
py
|
Python
|
extract.py
|
LosWochos76/haushalt_wetter_extractor
|
1132c38ed3fd132262b7263368db7a7eebe6086d
|
[
"MIT"
] | null | null | null |
extract.py
|
LosWochos76/haushalt_wetter_extractor
|
1132c38ed3fd132262b7263368db7a7eebe6086d
|
[
"MIT"
] | null | null | null |
extract.py
|
LosWochos76/haushalt_wetter_extractor
|
1132c38ed3fd132262b7263368db7a7eebe6086d
|
[
"MIT"
] | null | null | null |
from budget import Budget
budget = Budget('Haushaltsplan_2021.pdf', 2021)
budget.extract_text_from_pdf()
budget.read_pages_from_text_files()
budget.write_data_to_excel()
budget.write_product_list_to_excel()
| 29.571429 | 47 | 0.850242 |
3fd944be9f21071550244a4c3c268e476893db52
| 998 |
py
|
Python
|
Curso_Python/Secao3-Python-Intermediario-Programacao-Procedural/88-89-90_desafio_valide_um_cnpj/validando_cnpj/__init__.py
|
pedrohd21/Cursos-Feitos
|
b223aad83867bfa45ad161d133e33c2c200d42bd
|
[
"MIT"
] | null | null | null |
Curso_Python/Secao3-Python-Intermediario-Programacao-Procedural/88-89-90_desafio_valide_um_cnpj/validando_cnpj/__init__.py
|
pedrohd21/Cursos-Feitos
|
b223aad83867bfa45ad161d133e33c2c200d42bd
|
[
"MIT"
] | null | null | null |
Curso_Python/Secao3-Python-Intermediario-Programacao-Procedural/88-89-90_desafio_valide_um_cnpj/validando_cnpj/__init__.py
|
pedrohd21/Cursos-Feitos
|
b223aad83867bfa45ad161d133e33c2c200d42bd
|
[
"MIT"
] | null | null | null |
import re
import random
def remover_caracteres(cnpj):
return re.sub(r'[^0-9]', '', cnpj)
def total(lista):
lista1 = '6543298765432'
total1 = 0
total2 = 0
for c in range(11):
total1 += int(lista[c]) * int(lista1[1:][c])
formula(total1)
for c in range(12):
total2 += int(lista[c]) * int(lista1[c])
total2 += formula(total1)
formula(total2)
return f'{formula(total1)}{formula(total2)}'
def formula(x):
digito = 11 - (x % 11)
if digito > 9:
return 0
else:
return 1
def validando(x, y):
if x == y:
return 'Valido'
else:
return 'Invalido'
def gera():
primeiro_digito = random.randint(0, 9)
segundo_digito = random.randint(0, 9)
segundo_bloco = random.randint(100, 999)
terceiro_bloco = random.randint(100, 999)
quarto_bloco = '0001'
cnpj = f'{primeiro_digito}{segundo_digito}{segundo_bloco}{terceiro_bloco}{quarto_bloco}'
cnpj += total(cnpj)
return cnpj
| 21.234043 | 92 | 0.60521 |
b76d625f9283b0541db5c61df706d5169aea9228
| 1,668 |
py
|
Python
|
scripts/docker/download_models.py
|
dimmollo/BIG-bench
|
f0dffeb4f16ef5489686a81e2d63362d251cda3e
|
[
"Apache-2.0"
] | 460 |
2021-01-26T21:23:37.000Z
|
2022-03-31T15:55:10.000Z
|
scripts/docker/download_models.py
|
dimmollo/BIG-bench
|
f0dffeb4f16ef5489686a81e2d63362d251cda3e
|
[
"Apache-2.0"
] | 475 |
2021-01-27T01:29:01.000Z
|
2022-03-30T20:23:56.000Z
|
scripts/docker/download_models.py
|
dimmollo/BIG-bench
|
f0dffeb4f16ef5489686a81e2d63362d251cda3e
|
[
"Apache-2.0"
] | 305 |
2021-01-26T23:28:11.000Z
|
2022-03-31T14:51:26.000Z
|
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# 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 transformers
MODELS = {
"gpt2": [
"gpt2",
"gpt2-medium",
"gpt2-large",
"gpt2-xl",
],
"openai-gpt": [
"openai-gpt",
],
}
MODEL_NAMES = sum(MODELS.values(), [])
MODEL_TYPES = dict([(y, k) for k, v in MODELS.items() for y in v])
MODEL_CLASSES = {
"gpt2": {
"lm": transformers.TFGPT2LMHeadModel,
"tokenizer": transformers.GPT2Tokenizer,
},
"openai-gpt": {
"lm": transformers.TFOpenAIGPTLMHeadModel,
"tokenizer": transformers.OpenAIGPTTokenizer,
},
}
# ----------------------------------------------------------------------------
if __name__ == "__main__":
for model_name in ["openai-gpt", "gpt2"]: # , "gpt2-medium", "gpt2-large"]:
model_type = MODEL_TYPES[model_name]
model_class = MODEL_CLASSES[model_type]["lm"]
tokenizer_class = MODEL_CLASSES[model_type]["tokenizer"]
tokenizer = tokenizer_class.from_pretrained(model_name)
model = model_class.from_pretrained(
model_name, pad_token_id=tokenizer.eos_token_id
)
| 30.888889 | 80 | 0.628897 |
b7ce93f0188e14affaf70b9887f9bce3ebda89c6
| 1,362 |
py
|
Python
|
source/pkgsrc/devel/py-hash/patches/patch-setup.py
|
Scottx86-64/dotfiles-1
|
51004b1e2b032664cce6b553d2052757c286087d
|
[
"Unlicense"
] | 1 |
2021-11-20T22:46:39.000Z
|
2021-11-20T22:46:39.000Z
|
source/pkgsrc/devel/py-hash/patches/patch-setup.py
|
Scottx86-64/dotfiles-1
|
51004b1e2b032664cce6b553d2052757c286087d
|
[
"Unlicense"
] | null | null | null |
source/pkgsrc/devel/py-hash/patches/patch-setup.py
|
Scottx86-64/dotfiles-1
|
51004b1e2b032664cce6b553d2052757c286087d
|
[
"Unlicense"
] | null | null | null |
$NetBSD: patch-setup.py,v 1.3 2018/06/30 19:01:52 fhajny Exp $
print is a function in Python 3.
--- setup.py.orig 2014-07-29 06:26:59.000000000 +0000
+++ setup.py
@@ -3,6 +3,7 @@
import sys
import os
import math
+import platform
from ez_setup import use_setuptools
use_setuptools()
@@ -56,14 +57,16 @@ elif os.name == "posix" and sys.platform
'/opt/local/include',
'/usr/local/include'
]
- libraries += ["boost_python-mt"]
- extra_compile_args += ["-msse4.2"]
+ libraries += ["boost_python" + os.environ.get('PYVER') + "-mt"]
+ if platform.machine() in ("i386", "amd64"):
+ extra_compile_args += ["-msse4.2"]
elif os.name == "posix":
- libraries += ["boost_python", "rt"]
- extra_compile_args += ["-msse4.2"]
+ libraries += ["boost_python" + os.environ.get('PYVER'), "rt"]
+ if platform.machine() in ("i386", "amd64"):
+ extra_compile_args += ["-msse4.2"]
if os.getenv('TRAVIS') == 'true':
- print "force to link boost::python base on Python version v%d.%d" % (sys.version_info.major, sys.version_info.minor)
+ print("force to link boost::python base on Python version v%d.%d" % (sys.version_info.major, sys.version_info.minor))
os.remove('/usr/lib/libboost_python.so')
os.symlink('/usr/lib/libboost_python-py%d%d.so' % (sys.version_info.major, sys.version_info.minor),
| 36.810811 | 122 | 0.638767 |
4d5ba76b2b632ee48b8b2b1a76937e16f5495c09
| 26,449 |
py
|
Python
|
toolsederhana2-master/sederhana.py
|
Zusyaku/Termux-And-Lali-Linux-V2
|
b1a1b0841d22d4bf2cc7932b72716d55f070871e
|
[
"Apache-2.0"
] | 2 |
2021-11-17T03:35:03.000Z
|
2021-12-08T06:00:31.000Z
|
toolsederhana2-master/sederhana.py
|
Zusyaku/Termux-And-Lali-Linux-V2
|
b1a1b0841d22d4bf2cc7932b72716d55f070871e
|
[
"Apache-2.0"
] | null | null | null |
toolsederhana2-master/sederhana.py
|
Zusyaku/Termux-And-Lali-Linux-V2
|
b1a1b0841d22d4bf2cc7932b72716d55f070871e
|
[
"Apache-2.0"
] | 2 |
2021-11-05T18:07:48.000Z
|
2022-02-24T21:25:07.000Z
|
#!/usr/bin/python
########-NGAPAI GAN MAU RECODE YA?-################################
#######-YAUDAH SILAHKAN TAPI INGAT KATA PEPATAH "BANGSAD KAO"-####
import time, sys, threading, os, urllib, httplib, json
from os import system
def menu():
print "\033[1;91m"
print """+============================================+
| Created by KANG NEWBIE { t.me/kang_nuubi } |
| note: Jika terjadi error hubungi author |
+============================================+"""
print "\033[1;93mMenu Pilihan: "
print "1. Bio data"
print "2. Tahun Kabisat"
print "3. Nembak Cewek"
print "4. Ternak LELE"
print "5. Menghitung Saldo"
print "6. Perkiraan Cuaca"
print "7. Mencari Bilanga Prima"
print "8. Membuat List Pegawai"
print "9. Kuis Sosial Media"
print "10. Install bot Caping"
print "11. Install bot NewsCat"
print "12. Install bot Kubik"
print "13. Install OSIF"
print "14. Install Spam Sms"
print "15. Install Hammer"
print "16. Install Lite ddos"
print "17. Install Tools Lazymux"
print "18. Install Metasploit"
print "19. Install APKDOWNLOADER"
print "20. Install Spam Email"
print "21. Install Gps Tracking"
print "22. Install Tools Cek Gempa Terkini"
print "23. Install Bot Chastree"
print "24. Install Tools Weeman/Phising"
print "25. Install Hunner Framework"
print "26. Install Sqlmap"
print "27. Install IpGeoLocation"
print "28. Install Admin Panel Finder"
print "29. Install Hakku Framework"
print "30. Install Red Hawk"
print "31. Install Mpsyt"
print "32. Install webdav"
print "33. Install SYTD"
print "34. Install Xerxes"
print "35. Install Torshammer"
print "36. Install Mail-Generator"
print "37. Install LiteOTP"
print "38. Install XAttacker"
print "39. Install Facebook Video Downloader"
print "40. Install Tools Th3inspector"
print "41. Install IP-Tracer"
print "42. Install KaliNethunter"
print "43. Install Termux Alpine"
print "44. Install Smsid"
print "45. Install Instagram Downloader"
print "46. Install Spam Call"
print "47. "
print "99. Update "
print "100. About"
print "0. KELUAR"
def biodata () :
print
print "\033[1;94mSELAMAT DATANG DI PROGRAM BIODATA"
print "\033[1;92m========================================================"
print "\033[1;91m*KETIKAN DENGAN HURUF KAPITAL SAJA!"
print "*tolong isi dengan baik dan benar semua data-data anda!"
print "*jika anda mengalami kesulitan bertanyalah."
print
nama_lengkap = raw_input("\033[93mNama Lengkap: ")
umur = raw_input("Umur: ")
jenis_kelamin = raw_input("Jenis Kelamin: ")
tempat_tanggal_lahir = raw_input("Tempat/tanggal lahir: ")
alamat = raw_input("Alamat: ")
agama = raw_input("Agama: ")
tinggi_badan = raw_input("Tinggi badan: ")
riwayat_penyakit = raw_input("Riwayat penyakit: ")
hobi = raw_input("Hobi: ")
sekolah = raw_input("Sekolah: ")
teks = "\nNama Lengkap: {}\nUmur: {}\nJenis Kelamin: {}\nTempat/tanggal lahir: {}\nAlamat: {}\nAgama: {}\nTinggi badan: {}\nRiwayat penyakit: {}\nHobi: {}\nSekolah: {}\n-----------------".format(nama_lengkap, umur, jenis_kelamin, tempat_tanggal_lahir, alamat, agama, tinggi_badan, riwayat_penyakit, hobi, sekolah)
file_bio = open("biodata.txt", "a")
file_bio.write(teks)
file_bio.close()
print "\033[91mNOTE: semua data anda telah dimasukan ke file 'biodata.txt'.\n terima kasih :)"
print
def tahunkabisat () :
tahun = input("\033[1;92mInput tahun: ")
if (tahun % 4) == 0:
if (tahun % 100) == 0:
if (tahun % 400) == 0:
print "-Tahun Tersebut Tahun Kabisat"
print
else:
print "-Tahun Tersebut Bukan Tahun Kabisat"
print
else:
print "-Tahun Tersebut Tahun Kabisat"
print
else:
print "-Tahun Tersebut Bukan Tahun Kabisat"
print
def nembakcewek ():
def utama():
print "\033[1;92mMaukah ente menjadi istriku ?"
print "1 = Mau"
print "2 = Tidak Mau"
dipilih = raw_input("Pilih Nomor ( 1 / 2 ) : ")
if dipilih == "1":
print '"Aku berjanji akan cinta sampai mati sama kamu :* "'
elif dipilih == "2":
print '"Yahh jomblo lagi deh"'
else :
print "Pilihannya Cuma 1 Sama 2 Doang tong -_- "
ulangi()
def ulangi():
dicobalagi = raw_input("Coba lagi ? [Y/T] : ")
if dicobalagi.lower() == "y":
utama()
elif dicobalagi.lower() == "t":
sys.exit("Dadah :)")
else :
print "Pilihannya Cuma Y dan T Doang tong -_- "
ulangi()
utama()
def lele():
print
nama = raw_input("Siapa nama mu? ")
jumlah_lele = int(input("Hai " + nama + " Berapa jumlah ikan lele yang kamu punya di kolam? "))
print "Ikan lele mu di kolam :", jumlah_lele, "ekor"
kasih_makan = int(input("Berapa kali Anda memberi pakan setiap harinya? "))
# Kondisi
if kasih_makan == 2:
print "Jadwal pakan Anda :", kasih_makan, "kali perhari."
print "Anda mengatur jadwal pakan yang tepat."
print
elif kasih_makan < 2:
print "Jadwal pakan Anda :", kasih_makan, "kali perhari."
print "Anda mengatur jadwal pakan yang kurang tepat."
print
elif kasih_makan > 2:
print "Jadwal pakan Anda :", kasih_makan, "kali perhari."
print "Anda memberikan pakan terlalu berlebihan."
print
elif kasih_makan == 0:
print "Jadwal pakan Anda :", kasih_makan, "kali perhari."
print "Maaf ikan lele Anda mati."
print
def saldo ():
print ("")
print ("\033[1;92m------ PROGRAM PYTHON UNTUK MENGHITUNG SALDO ------")
print ("")
print ("by : KANG NEWBIE")
print ("")
tabungan = int(input("Masukkan jumlah tabungan :"))
lama = int(input("Masukkan jumlah lama menabung (bulan) :"))
if tabungan < 1000000 :
sukuBunga = 0.03
saldoAkhir = (tabungan * sukuBunga) * lama + tabungan
print("")
print("Karena tabungan anda dibawah 1.000.000,\nbunga yang anda dapatkan 3%")
print("Saldo anda selama " + str (lama) + " bulan, adalah " +str (saldoAkhir))
print("")
elif tabungan > 1000000 :
sukuBunga = 0.04
saldoAkhir = (tabungan * sukuBunga) * lama + tabungan
print("")
print("Karena tabungan anda diatas 1.000.000,\nbunga yang anda dapatkan 4%")
print("Saldo anda selama " + str (lama) + " bulan, adalah " +str (saldoAkhir))
print("")
def cuaca():
print
kota= raw_input("\033[1;92mMasukkan Nama Kota : ")
conn = httplib.HTTPSConnection("api.openweathermap.org")
conn.request("GET", "/data/2.5/forecast?q="+kota.lower()+",id&mode=json&appid=503186110e24edea8f99643135fd77cc")
res = conn.getresponse()
data = json.loads(res.read())
for a in range (len(data['list'])):
print "==============================================="
print "Tanggal",data['list'][a]['dt_txt']
for b in range(len(data['list'][a]['weather'])):
print "Nama kota ", kota
print "Cuaca",data['list'][a]['weather'][b]['main']
print "Suhu ",int(data['list'][a]['main']['temp'])-273
print "Kecepatan angin ",data['list'][a]['wind']['speed']
print "==============================================="
def prima():
def is_prime(num):
if num < 2:
return False
for prime in range(2, num):
if num % prime == 0:
return False
return True
def find_primes(max_num):
primes = []
for prime in range(0, max_num):
if is_prime(prime):
primes.append(prime)
total_primes = str(len(primes))
largest_prime = str(primes[-1])
smallest_prime = str(primes[0])
print('\n[+] total bilangan prima 1 s/d %s : %s' % (max_num, total_primes))
print('[+] bilangan prima terbesar : %s' % (largest_prime))
print('[+] bilangan prima terkecil : %s\n' % (smallest_prime))
x = 0
while x < len(primes):
for value in primes:
x = x + 1
print(str(x)+' Yaitu : '+str(value))
if __name__ == '__main__':
print("")
max = int(raw_input('[*] masukan nilai max : '))
find_primes(max)
def pegawai():
stop = False
pegawai = [ ]
def tambah():
stop = False
i = 0
#Mengisi Array
while(not stop):
pegawai_baru = raw_input("Inputkan nama pegawai yang ke-{}: ".format(i+1))
pegawai.append(pegawai_baru)
# methode append menambahkan list/item dari belakang
# Increment 1
i += 1
tanya = raw_input("Mau isi lagi ? (y/t): ")
if(tanya == "t"):
kembali()
def lihat():
# Cetak Semua Pegawai
print "\n"
print "=" * 100
print "Kamu memiliki {} pegawai" .format(len(pegawai))
for hb in pegawai:
print "- {}" .format(hb)
print "\n"
pilih = raw_input("mau kembali ke menu ? (y/t): ")
if(pilih == "y"):
kembali()
else:
lihat()
#fungsi len digunakan untuk mengambil panjang list
def kembali():
print "*" * 100
print "1. Tambah Data Pegawai \n"
print "2. Lihat Data Pegawai \n"
print "3. Hapus Data Pegawai \n"
print "4. Exit \n"
pilih = input("Masukkan Pilihan (1/2/3/4) = ")
if(pilih == 1):
tambah()
elif(pilih == 2) :
lihat()
elif(pilih == 3):
hapus()
elif(pilih == 4):
stop = True
else:
stop = True
def hapus():
a = 0
print "Kamu memiliki {} pegawai" .format(len(pegawai))
for hb in pegawai:
print "- {}" .format(hb)
print "\n"
a = input("hapus data pegawai yang ke - ")
del pegawai[a-1]
print "Data Pegawai telah dihapus "
kembali()
kembali()
def kuis_sosmed():
from random import randint
count = 0
Soal = ["Social Media buatan Mark zuck...? ",
"Social Media yang eksis dengan awake sleep? ",
"Microblogging yang gambar burung apa hayo? ",
"Social Media yang populer dengan photo?",
"Social Media yang logonya hampir sama dengan Path ",
"Social Media buat pekerja itu namanya: ",
"Planet Python di Indonesia itu hanya: "]
Jawab = ["facebook",
"path",
"twitter",
"instagram",
"pinterest",
"linkedin",
"planpin"]
link = ["http://www.facebook.com",
"http://Path.com",
"http://twitter.com",
"http://Instagram.com",
"http://Pinterest.com",
"http://linkedin.com",
"http://planet.python.or.id/"]
i = randint(0, 7)
answer = raw_input("Pertanyaan 1 : " + Soal[i])
if answer.lower() == Jawab[i]:
print "Yeee Benar"
count = count + 1
else:
print "Yaah Salah \nJawaban Benar : " + Jawab[i]
print "Pengen Coba? Kunjungi : " + link[i]
i = randint(0, 7)
answer = raw_input("\nPertanyaan 2 : " + Soal[i])
if answer.lower() == Jawab[i]:
print "Yee Benar"
count = count + 1
else:
print "Yaah Salah \nJawaban Benar : " + Jawab[i]
print "Pengen Coba? Kunjungi : " + link[i]
i = randint(0, 7)
answer = raw_input("\nPertanyaan 3 : " + Soal[i])
if answer.lower() == Jawab[i]:
print "Yee Benar"
count = count + 1
else:
print "Yahh Salah \nJawaban Benar : " + Jawab[i]
print "Pengen Coba? Kunjungi : " + link[i]
i = randint(0, 7)
answer = raw_input("\nPertanyaan 4 : " + Soal[i])
if answer.lower() == Jawab[i]:
print "Yee Benar"
count = count + 1
else:
print "Yahh Salah \nJawaban Benar : " + Jawab[i]
print "Pengen Coba? Kunjungi : " + link[i]
i = randint(0, 7)
answer = raw_input("\nPertanyaan 5 : " + Soal[i])
if answer.lower() == Jawab[i]:
print "Yee Benar"
count = count + 1
else:
print "Yahh Salah \nJawaban Benar : " + Jawab[i]
print "Pengen Coba? Kunjungi : " + link[i]
i = randint(0, 7)
answer = raw_input("\nPertanyaan 6 : " + Soal[i])
if answer.lower() == Jawab[i]:
print "Yee Benar"
count = count + 1
else:
print "Yahh Salah \nJawaban Benar : " + Jawab[i]
print "Pengen Coba? Kunjungi : " + link[i]
i = randint(0, 7)
answer = raw_input("\nPertanyaan 7 : " + Soal[i])
if answer.lower() == Jawab[i]:
print "Yee Benar"
count = count + 1
else:
print "Yahh Salah \nJawaban Benar : " + Jawab[i]
print "Pengen Coba? Kunjungi : " + link[i]
print "\n %d jawaban benar" % (count)
print "\nNilai : %d persen\n" % (count / float(7) * 100)
def caping():
system('pkg update && pkg upgrade')
system('pkg install php')
system('pkg install git')
system('git clone https://github.com/anggaid14/caping')
system('mv caping $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def newscat():
system('apt upgrade && apt update')
system('apt install curl')
system('apt install git')
system('apt install bash')
system('apt install grep')
system('git clone https://github.com/lapakdigital/newscatbot')
system('mv newscatbot $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def kubik():
system('pkg update && pkg upgrade')
system('pkg install php')
system('pkg install nano')
system('pkg install git')
system('git clone https://github.com/radenvodka/kubik-bot')
system('mv kubik-bot $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def osif():
system('pkg update && pkg upgrade')
system('pip2 install requests mechanize')
system('pkg install git')
system('git clone https://github.com/CiKu370/OSIF')
system('mv OSIF $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def spamsms():
system('pkg update && pkg upgrade')
system('pkg install git')
system('pkg install php')
system('git clone https://github.com/KANG-NEWBIE/SpamSms')
system('mv SpamSms $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def hammer():
system('pkg update && pkg upgrade')
system('pkg install python')
system('pkg install git')
system('git clone https://github.com/cyweb/hammer')
system('mv hammer $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def liteddos():
os.system('pkg update && pkg upgrade')
os.system('pkg install git')
os.system('git clone https://github.com/4L13199/LITEDDOS')
os.system('mv LITEDDOS $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def lazymux():
system('pkg update && pkg upgrade')
system('pkg install git')
system('git clone https://github.com/Gameye98/Lazymux')
system('mv Lazymux $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def metasploit():
system('pkg update && pkg upgrade')
system('pkg install git')
system('git clone https://github.com/Hax4us/Metasploit_termux')
system('mv Metasploit_termux $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def apkdown():
system('pkg update && pkg upgrade')
system('pkg install git')
system('git clone https://github.com/karjok/APKDOWN')
system('mv APKDOWN $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print
def spammail():
system('pkg update && pkg upgrade')
system('pkg install php')
system('pkg install git')
system('git clone https://github.com/revan-ar/mail-spammer')
system('mv mail-spammer $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print
def gps():
system('pkg update && pkg upgrade')
system('pkg install php')
system('pkg install git')
system('git clone https://github.com/indosecid/gps_tracking')
system('mv gps_tracking $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def gempa():
system('pkg update && pkg upgrade')
system('pkg install git')
system('pkg install php')
system('pkg install python')
system('git clone https://github.com/suhada99/GempaTerikini')
system('mv GempaTerikini $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def chastree():
system('pkg update && pkg upgrade')
system('pkg install git')
system('pkg install php')
system('git clone https://github.com/radenvodka/cashtree')
system('mv cashtree $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def weeman():
system('pkg update && pkg upgrade')
system('pkg install git')
system('git clone https://github.com/evait-security/weeman')
system('mv weeman $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def hunner():
system('pkg update && pkg upgrade')
system('pkg install git')
system('pkg install python')
system('git clone https://github.com/b3-v3r/Hunner')
system('mv Hunner $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def sqlmap():
system('pkg update && pkg upgrade')
system('pkg install git')
system('pkg install python')
system('git clone https://github.com/sqlmapproject/sqlmap')
system('mv sqlmap $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def ipgeo():
system('pkg update && pkg upgrade')
system('pkg install git')
system('pkg install python')
system('pip install -r requirements.txt')
system('git clone https://github.com/maldevel/IPGeoLocation')
system('mv IPGeoLocation $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def admin_finder():
system('pkg update && pkg upgrade')
system('pkg install git')
system('git clone https://github.com/Techzindia/admin_penal')
system('mv admin_penal $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def hakku():
system('pkg install python')
system('git clone https://github.com/4shadoww/hakkuframework')
system('mv hakkuframework $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def red_hawk():
system('pkg install php')
system('git clone https://github.com/Tuhinshubhra/RED_HAWK')
system('mv RED_HAWK $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def mpsyt():
system('pip install mps_youtube')
system('pip install youtube_dl')
system('apt install mpv')
system('mpsyt')
def webdav():
system('pip2 install urllib3 chardet certifi idna requests')
system('apt install openssl curl')
system('pkg install libcurl')
system('pkg install wget')
system('mkdir webdav')
system('cd webdav')
system('wget pastebin.com/raw/HnVyQPtR')
system('mv HnVyQPtR webdav.py')
system('mv webdav.py webdav')
system('mv webdav $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def sytd():
system('pkg install python')
system('git clone https://github.com/karjok/SYTD')
system('mv SYTD $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def xerxes():
system('apt install clang')
system('git clone https://github.com/zanyarjamal/xerxes')
system('mv xerxes $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def torhammer():
system('pkg install tor')
system('git clone https://github.com/dotfighter/torshammer')
system('mv torshammer $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def mail_gen():
system('pkg install php')
system('git clone https://github.com/revan-ar/mail-gen')
system('mv mail-gen $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def liteotp():
system('pkg install php')
system('git clone https://github.com/Cvar1984/LiteOTP')
system('mv LiteOTP $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def xattack():
system('apt install perl')
system('git clone https://github.com/Moham3dRiahi/XAttacker/')
system('cpan install Log::Log4perl')
system('cpan install HTTP :: Request')
system('cpan install LWP :: Useragent')
system('mv XAttacker $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def fbvideo_down():
system('pkg install php')
system('git clone https://github.com/Tuhinshubhra/fbvid')
system('mv fbvid $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def the_inspect():
system('apt install perl make openssl git')
system('git clone https://github.com/Moham3dRiahi/Th3inspector')
system('mv Th3inspector $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def ip_tracer():
system('git clone https://github.com/Rajkumrdusad/IP-Tracer.git')
system('cd IP-Tracer')
system('mv IP-Tracer $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def nethunter():
system('git clone https://github.com/Hax4us/Nethunter-In-Termux')
system('cd Nethunter-In-Termux')
system('chmod +x kalinethunter')
system('./kalinethunter')
system('cd ..')
system('mv Nethunter-In-Termux $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def alpine():
system('apt -y upgrade && apt -y install curl proot')
system('curl -LO https://raw.githubusercontent.com/Hax4us/TermuxAlpine/master/TermuxAlpine.sh')
system('bash TermuxAlpine.sh')
system('startalpine')
def smsid():
system('git clone https://github.com/amsitlab/smsid-java')
system('mv smsid-java $HOME')
print
print "selanjutnya buka new seassion lalu agan ketik:\n$ cd smsid-java\n$ chmod +x install\n$ ./install"
print "cara menjalankannya \nsmsid send 085xxxxx (Untuk mengirim single pesan)\nsmsid boom 085xxxx (Untuk mengirim pesan sebanyak 2x atau lebih)"
print
def downig():
system('pkg install curl')
system('pkg install grep')
system('pkg install jq')
system('git clone https://github.com/Hax28dh8Sec/igdwnlod')
system('mv igdwnlod $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def spamtlp():
system('apt install wget')
system('apt install jq')
system('git clone https://github.com/Hax28dh8Sec/Tlpnspammer')
system('mv Tlpnspammer $HOME')
print "\033[92mSudah di install gan silahkan lihat di cd $HOME"
print "cara menggunakannya cari aja digoogle gan hehe"
print
def update():
system('cd && rm -rf toolsederhana2')
system('cd && git clone https://github.com/KANG-NEWBIE/toolsederhana2')
system('clear')
print "Restarting Program..."
time.sleep(2.5)
system('cd ../toolsederhana2 && python2 sederhana.py')
def tes():
print
print("\nUdah ya gan segitu dulu soalnya ane udah bingung apa lagi yang mau ditambahin hehe.\nlagian kalo kebanyakan pun nanti jadi bingung juga mau install yang mana eakan? hehehe, \nkalo agan mau ngembagin lagi ya silahkan saja gan aku ikhlas kok:')\nSampai Jumpa di project berikutnya gan:*"*10)
print
def tentang():
system('clear')
print """\033[1;91m+---------------------------+
| author : KANG NEWBIE |
| contact : t.me/kang_nuubi |
+---------------------------+"""
print "segala yang terjadi saat menggunakan tools ini ditanggu oleh pengguna\nJika terjadi error/bug harap hubungi saya"
print "terima kasih kepada : Allah SWT, member CRABS_ID, dan kepada diri saya sendiri hehe"
print
def keluar():
print "\033[1;93mTERIMA KASIH TELAH MENGGUNAKAN TOOLS KAMI:)"
print
sys.exit()
#Program Utama
system('clear')
print
time.sleep(0.5)
print "\033[1;92m------------------------------------------"
print "SELAMAT DATANG DI PROGRAM SEDERHANA KAMI"
print "------------------------------------------"
pilihan = 'y'
while (pilihan != 't'):
menu()
pilih = input("Masukkan pilihan : ")
if pilih == 1:
biodata()
elif pilih == 2:
tahunkabisat()
elif pilih == 3:
nembakcewek()
elif pilih == 4:
lele()
elif pilih == 5:
saldo()
elif pilih == 6:
cuaca()
elif pilih == 7:
prima()
elif pilih == 8:
pegawai()
elif pilih == 9:
kuis_sosmed()
elif pilih == 10:
caping()
elif pilih == 11:
newscat()
elif pilih == 12:
kubik()
elif pilih == 13:
osif()
elif pilih == 14:
spamsms()
elif pilih == 15:
hammer()
elif pilih == 16:
liteddos()
elif pilih == 17:
lazymux()
elif pilih == 18:
metasploit()
elif pilih == 19:
apkdown()
elif pilih == 20:
spammail()
elif pilih == 21:
gps()
elif pilih == 22:
gempa()
elif pilih == 23:
chastree()
elif pilih == 24:
weeman()
elif pilih == 25:
hunner()
elif pilih == 26:
sqlmap()
elif pilih == 27:
ipgeo()
elif pilih == 28:
admin_finder()
elif pilih == 29:
hakku()
elif pilih == 30:
red_hawk()
elif pilih == 31:
mpsyt()
elif pilih == 32:
webdav()
elif pilih == 33:
sytd()
elif pilih == 34:
xerxes()
elif pilih == 35:
torhammer()
elif pilih == 36:
mail_gen()
elif pilih == 37:
liteotp()
elif pilih == 38:
xattack()
elif pilih == 39:
fbvideo_down()
elif pilih == 40:
the_inspect()
elif pilih == 41:
ip_tracer()
elif pilih == 42:
nethunter()
elif pilih == 43:
alpine()
elif pilih == 44:
smsid()
elif pilih == 45:
downig()
elif pilih == 46:
spamtlp()
elif pilih == 47:
tes()
elif pilih == 99:
update()
elif pilih == 100:
tentang()
elif pilih == 0:
keluar()
else :
print ("\033[91mTINGGAL PILIH AJA SUSAH AMAT -_-")
print
pilihan = raw_input("Kembali Ke Menu Pilihan? (y/t) ")
system('clear')
continue
| 29.818489 | 315 | 0.661084 |
12ee5bfabbf4640b29ca5d150fe2b97e94eb7d05
| 416 |
py
|
Python
|
Django-Curso/tasks/migrations/0002_auto_20210121_1728.py
|
pedrohd21/Cursos-Feitos
|
b223aad83867bfa45ad161d133e33c2c200d42bd
|
[
"MIT"
] | null | null | null |
Django-Curso/tasks/migrations/0002_auto_20210121_1728.py
|
pedrohd21/Cursos-Feitos
|
b223aad83867bfa45ad161d133e33c2c200d42bd
|
[
"MIT"
] | null | null | null |
Django-Curso/tasks/migrations/0002_auto_20210121_1728.py
|
pedrohd21/Cursos-Feitos
|
b223aad83867bfa45ad161d133e33c2c200d42bd
|
[
"MIT"
] | null | null | null |
# Generated by Django 3.1.5 on 2021-01-21 20:28
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('tasks', '0001_initial'),
]
operations = [
migrations.AlterField(
model_name='task',
name='done',
field=models.CharField(choices=[('doing', 'Doing'), ('done', 'Done')], max_length=5),
),
]
| 21.894737 | 97 | 0.572115 |
67b1d7f0385778a6093c1bcd9f7fc379f82f659d
| 218 |
py
|
Python
|
bot/__init__.py
|
thecoderkitty/fluffington-bot
|
f518e7b66487aaf9e6c507ced43e15760d604be2
|
[
"MIT"
] | null | null | null |
bot/__init__.py
|
thecoderkitty/fluffington-bot
|
f518e7b66487aaf9e6c507ced43e15760d604be2
|
[
"MIT"
] | null | null | null |
bot/__init__.py
|
thecoderkitty/fluffington-bot
|
f518e7b66487aaf9e6c507ced43e15760d604be2
|
[
"MIT"
] | null | null | null |
import asyncio
import os
from bot import log
log.setup()
# On Windows, the selector event loop is required for aiodns.
if os.name == "nt":
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
| 19.818182 | 75 | 0.770642 |
67d43eab7be6b520667d5d42cc6ca9caa2310d4c
| 4,901 |
py
|
Python
|
doc/precursers/2019_09-Sneakernet/Sneakernet/lib/gg.py
|
Kyrus1999/BACnet
|
5be8e1377252166041bcd0b066cce5b92b077d06
|
[
"MIT"
] | 8 |
2020-03-17T21:12:18.000Z
|
2021-12-12T15:55:54.000Z
|
doc/precursers/2019_09-Sneakernet/Sneakernet/lib/gg.py
|
Kyrus1999/BACnet
|
5be8e1377252166041bcd0b066cce5b92b077d06
|
[
"MIT"
] | 2 |
2021-07-19T06:18:43.000Z
|
2022-02-10T12:17:58.000Z
|
doc/precursers/2019_09-Sneakernet/Sneakernet/lib/gg.py
|
Kyrus1999/BACnet
|
5be8e1377252166041bcd0b066cce5b92b077d06
|
[
"MIT"
] | 25 |
2020-03-20T09:32:45.000Z
|
2021-07-18T18:12:59.000Z
|
# sn/lib/gg.py
# GabbyGrove binary encoding
import cbor2
import hashlib
import lib.crypto as crypto
GG_TAG_CIPHERLINK = 1050
GG_CIPHERLINK_FEED_V1 = b'\x01' # ed25519
GG_CIPHERLINK_EVENT_V1 = b'\x02' # sha256
GG_CIPHERLINK_CONTENT_v1 = b'\x03' # sha256
GG_CIPHERLINK_FEED_SSB_V1 = b'\x04'
GG_CIPHERLINK_EVENT_SSB_V1 = b'\x05'
GG_CIPHERLINK_CONTENT_SSB_V1 = b'\x06'
GG_SIGNINGALGO_SHA256_ED25519 = 1
GG_CONTENT_ENCODING_OPAQUE = 0
GG_CONTENT_ENCODING_JSON = 1
GG_CONTENT_ENCODING_CBOR = 2
def mk_cipherlink(t,val):
if not val:
return None
return cbor2.CBORTag(GG_TAG_CIPHERLINK, t+val)
class EVENT:
def __init__(self, prev=None, feed=None, seq=0, time=0,
content = None, content_enc = GG_CONTENT_ENCODING_OPAQUE,
signing_algo = GG_SIGNINGALGO_SHA256_ED25519):
self.prev = prev
self.feed = feed
self.seq = seq
self.time = time
self.content = content
self.content_len = 0 if not content else len(content)
self.content_hash = None
self.content_enc = content_enc
self.signing_algo = signing_algo
#
self.signed_bytes = None
self.event_bytes = None
self.signature = None
self.cipherlink = None
def from_cbor(self, c):
# input must be CBOR of a signed event
e = cbor2.loads(c)
if type(e) != list and len(e) != 2:
return False # raise()
self.signed_bytes = c
self.event_bytes = e[0]
self.signature = e[1]
self.cipherlink = None
e = cbor2.loads(self.event_bytes)
# we should do more sanity checks ...
self.prev = None if not e[0] else e[0].value[1:]
self.feed = None if not e[1] else e[1].value[1:]
self.seq = e[2]
self.time = e[3]
self.content = None
self.content_len = e[4][1]
self.content_enc = e[4][0]
self.content_hash = e[4][2].value[1:]
self.signing_algo = e[5]
return True
def event_to_cbor(self):
if self.content and not self.content_hash:
self.content_hash = hashlib.sha256(self.content).digest()
self.event_bytes = cbor2.dumps([
mk_cipherlink(GG_CIPHERLINK_EVENT_V1, self.prev),
mk_cipherlink(GG_CIPHERLINK_FEED_V1, self.feed),
self.seq,
self.time,
[self.content_enc, len(self.content) if self.content else 0,
mk_cipherlink(GG_CIPHERLINK_EVENT_V1, self.content_hash)],
GG_SIGNINGALGO_SHA256_ED25519
])
return self.event_bytes
def signed_event_to_cbor(self):
# this assumes that self.event_bytes was already generated and
# that self.signature received its respective value
self.signed_bytes = cbor2.dumps([ self.event_bytes, self.signature ])
return self.signed_bytes
def get_sha256(self):
if not self.signed_bytes:
self.signed_event_to_cbor()
return hashlib.sha256(self.signed_bytes).digest()
def get_cipherlink(self):
if not self.cipherlink:
self.cipherlink = mk_cipherlink(GG_CIPHERLINK_EVENT_V1,
self.get_sha256())
return self.cipherlink
def pretty_print(self):
s = 'event {\n'
for i in ['prev', 'feed', 'seq', 'time']:
s += f' {i}: {getattr(self, i)}\n'
if self.content:
s += f' content: {len(self.content)} bytes ({self.content})' + '\n'
else:
s += ' content: None\n'
s += f' hash: {self.get_sha256()}' + '\n'
return s + '}'
class TRANSFER:
def __init__(self, event = None):
self.event = event # class EVENT
def to_cbor(self):
if self.event.content:
c = [ self.event.content, self.event.content_len,
self.event.content_enc ]
else:
c = None
return cbor2.dumps([ self.event.signed_event_to_cbor(), c ])
def from_cbor(self, c):
t = cbor2.loads(c)
if type(t) != list or len(t) != 2 or type(t[0]) != bytes:
return False # raise()
e = EVENT()
if not e.from_cbor(t[0]) or (type(t[1]) != list and t[1] != None):
return False # raise()
if not crypto.ED25519.validate(e.feed, e.event_bytes, e.signature):
# print("** WARNING: Failed to validate event.")
# return False
pass
self.event = e
if t[1] == None:
self.event.content = None
else:
self.event.content = t[1][0]
self.event.content_len = t[1][1]
self.event.content_enc = t[1][2]
self.event.content_hash = hashlib.sha256(t[1][0]).digest()
# TODO: validate content hash and length
return True
# eof
| 33.340136 | 80 | 0.583554 |
3f30570d7975a6c145605e13b9c8b1de2bf8effc
| 409 |
py
|
Python
|
tests/utils/tensorflow/test_tf_environment.py
|
fintzd/rasa
|
6359be5509c7d87cd29c2ab5149bc45e843fea85
|
[
"Apache-2.0"
] | 9,701 |
2019-04-16T15:46:27.000Z
|
2022-03-31T11:52:18.000Z
|
tests/utils/tensorflow/test_tf_environment.py
|
alfredfrancis/rasa
|
d8d226408f20cc2563c3aefbccef3e364a447666
|
[
"Apache-2.0"
] | 6,420 |
2019-04-16T15:58:22.000Z
|
2022-03-31T17:54:35.000Z
|
tests/utils/tensorflow/test_tf_environment.py
|
alfredfrancis/rasa
|
d8d226408f20cc2563c3aefbccef3e364a447666
|
[
"Apache-2.0"
] | 3,063 |
2019-04-16T15:23:52.000Z
|
2022-03-31T00:01:12.000Z
|
import pytest
from typing import Text, Dict
from rasa.utils.tensorflow.environment import _parse_gpu_config
@pytest.mark.parametrize(
"gpu_config_string, parsed_gpu_config",
[("0: 1024", {0: 1024}), ("0:1024, 1:2048", {0: 1024, 1: 2048})],
)
def test_gpu_config_parser(gpu_config_string: Text, parsed_gpu_config: Dict[int, int]):
assert _parse_gpu_config(gpu_config_string) == parsed_gpu_config
| 34.083333 | 87 | 0.753056 |
58e92b9c56182240321483bada385fd0a129683c
| 477 |
py
|
Python
|
INBa/2015/ORSHONOVA_E_G/task_2_17.py
|
YukkaSarasti/pythonintask
|
eadf4245abb65f4400a3bae30a4256b4658e009c
|
[
"Apache-2.0"
] | null | null | null |
INBa/2015/ORSHONOVA_E_G/task_2_17.py
|
YukkaSarasti/pythonintask
|
eadf4245abb65f4400a3bae30a4256b4658e009c
|
[
"Apache-2.0"
] | null | null | null |
INBa/2015/ORSHONOVA_E_G/task_2_17.py
|
YukkaSarasti/pythonintask
|
eadf4245abb65f4400a3bae30a4256b4658e009c
|
[
"Apache-2.0"
] | null | null | null |
#Задача 2. Вариант 17.
#Напишите программу, которая будет выводить на экран наиболее понравившееся вам высказывание, автором которого является Ас-Cамарканди. Не забудьте о том, что автор должен быть упомянут на отдельной строке.
#Orshonova. E. G.
#23.05.2016
print ("Если болезнь не определена, невозможно и лечить ее. Если дать противоядия сверх меры, То подействует оно вредней, чем яд.")
print ("\t\t\t\tАс-Самарканди Мухаммед ибн Али")
input ("\nНажмите enter для выхода")
| 59.625 | 205 | 0.779874 |
7a0b0b6446e3627896fda21d031f5cc1f5ac01c3
| 1,547 |
py
|
Python
|
Hackerrank_problems/kangaroo/kangaroo_solution3.py
|
gbrls/CompetitiveCode
|
b6f1b817a655635c3c843d40bd05793406fea9c6
|
[
"MIT"
] | 205 |
2021-09-30T15:41:05.000Z
|
2022-03-27T18:34:56.000Z
|
Hackerrank_problems/kangaroo/kangaroo_solution3.py
|
gbrls/CompetitiveCode
|
b6f1b817a655635c3c843d40bd05793406fea9c6
|
[
"MIT"
] | 566 |
2021-09-30T15:27:27.000Z
|
2021-10-16T21:21:02.000Z
|
Hackerrank_problems/kangaroo/kangaroo_solution3.py
|
gbrls/CompetitiveCode
|
b6f1b817a655635c3c843d40bd05793406fea9c6
|
[
"MIT"
] | 399 |
2021-09-29T05:40:46.000Z
|
2022-03-27T18:34:58.000Z
|
""" There are two cases:
case 1: When both kangaroo meets at the same location then we have to say "YES".
case 2: If they are not going to meet in the given distance then "NO".
"""
import math
import os
import random
import re
import sys
""" "kangaroo" function takes 4 parameters i.e.
1st kangaroo's start location x1 and moves at a rate of v1 meters per jump.
2nd kangaroo's start location x2 and moves at a rate of v2 meters per jump.
"""
def kangaroo(x1, v1, x2, v2):
count = 1 # it is counting the number of jumps.
while x1 != x2 and count < 10000: # this while loop runs util both kangaroo meets.
count += 1 # incrementing the count variable when both are not meeting.
x1 = x1 + v1 # adding 1st kangaroo intial distance and jummps per meter.
x2 = x2 + v2 # adding 2st kangaroo intial distance and jummps per meter.
if x1 == x2: # checking whether both kangaroo meeeting or not. If true then return "YES".
return "YES"
elif count == 10000: # if not meeting in the given distance then returns "NO"
return "NO"
if __name__ == '__main__':
fptr = open(os.environ['OUTPUT_PATH'], 'w')
x1V1X2V2 = input().split()
x1 = int(x1V1X2V2[0])
v1 = int(x1V1X2V2[1])
x2 = int(x1V1X2V2[2])
v2 = int(x1V1X2V2[3])
result = kangaroo(x1, v1, x2, v2)
fptr.write(result + '\n')
fptr.close()
| 32.914894 | 119 | 0.588882 |
3628a86c6ac0638371cae72ebd0cf6a2b98e7c89
| 1,812 |
py
|
Python
|
practices/practice_3/lab_3_sim.py
|
br4ch1st0chr0n3/robotic_systems_labs
|
23b8b81dc845e00cf02460258b9cec817019957b
|
[
"MIT"
] | null | null | null |
practices/practice_3/lab_3_sim.py
|
br4ch1st0chr0n3/robotic_systems_labs
|
23b8b81dc845e00cf02460258b9cec817019957b
|
[
"MIT"
] | null | null | null |
practices/practice_3/lab_3_sim.py
|
br4ch1st0chr0n3/robotic_systems_labs
|
23b8b81dc845e00cf02460258b9cec817019957b
|
[
"MIT"
] | null | null | null |
from time import perf_counter, sleep
from multiprocessing import Process, Manager
from numpy import array, zeros, sin, pi
# Set the control loop timings
frequency = 500
sampling_time = 1/frequency
sim_ratio = 5
pendulum = Manager().Namespace()
# SET INITIAL STATE
pendulum.state = zeros(2)
pendulum.state = array([pi/2,0])
pendulum.control = 0
def simulator(system):
try:
last_execution = 0
initial_time = perf_counter()
while True:
# ///////////////////////////////////////////
time = perf_counter() - initial_time # get actual time in secs
dt = time - last_execution
if dt >= sampling_time/sim_ratio:
last_execution = time
control = system.control
# DO SIMULATION
# IMPLEMENT YOUR SIMULATOR HERE
system.state = system.state #
except KeyboardInterrupt:
print('\nSimulator is terminated')
simulator_proc = Process(target=simulator, args=(pendulum,))
simulator_proc.start()
try:
last_execution = 0
control = 0
# find the global time before intering control loop
initial_time = perf_counter()
while True:
time = perf_counter() - initial_time # get actual time in secs
theta, dtheta = pendulum.state
# ///////////////////////////////////////////
# Update the control only on specific timings
# ///////////////////////////////////////////
if (time - last_execution) >= sampling_time:
last_execution = time
control = 0
pendulum.control = 0
print(f'State: {pendulum.state}', end=' \r', flush=True)
except KeyboardInterrupt:
sleep(0.5)
simulator_proc.join()
print('Disabled by interrupt')
| 27.044776 | 74 | 0.571192 |
3d1ad56533ff84a58d6310ec42a935960bde755a
| 7,056 |
py
|
Python
|
Dockerfiles/gedlab-khmer-filter-abund/pymodules/python2.7/lib/python/misopy/test_miso.py
|
poojavade/Genomics_Docker
|
829b5094bba18bbe03ae97daf925fee40a8476e8
|
[
"Apache-2.0"
] | 1 |
2019-07-29T02:53:51.000Z
|
2019-07-29T02:53:51.000Z
|
Dockerfiles/gedlab-khmer-filter-abund/pymodules/python2.7/lib/python/misopy/test_miso.py
|
poojavade/Genomics_Docker
|
829b5094bba18bbe03ae97daf925fee40a8476e8
|
[
"Apache-2.0"
] | 1 |
2021-09-11T14:30:32.000Z
|
2021-09-11T14:30:32.000Z
|
Dockerfiles/gedlab-khmer-filter-abund/pymodules/python2.7/lib/python/misopy/test_miso.py
|
poojavade/Genomics_Docker
|
829b5094bba18bbe03ae97daf925fee40a8476e8
|
[
"Apache-2.0"
] | 2 |
2016-12-19T02:27:46.000Z
|
2019-07-29T02:53:54.000Z
|
#!/usr/bin/env python
import os
import sys
import unittest
import pysam
import sam_utils
class TestMISO(unittest.TestCase):
"""
Test MISO functionality.
"""
def setUp(self):
# Find out the current directory
self.miso_path = \
os.path.dirname(os.path.abspath(os.path.expanduser(__file__)))
self.tests_data_dir = \
os.path.join(self.miso_path, "test-data")
self.events_analysis_cmd = "miso"
self.tests_output_dir = \
os.path.join(self.miso_path, "test-output")
self.test_sam_filename = \
os.path.join(self.tests_data_dir,
"sam-data",
"c2c12.Atp2b1.sam")
self.gff_events_dir = \
os.path.join(self.miso_path, "gff-events")
self.sam_to_bam_script = "sam_to_bam"
self.index_gff_script = "index_gff"
def test_a_sam_to_bam(self):
"""
Test conversion of SAM to BAM.
The 'a' ensures this runs first.
"""
print "Testing conversion of SAM to BAM..."
output_dir = \
os.path.join(self.tests_output_dir, "sam-output")
sam_to_bam_cmd = \
"%s --convert %s %s" %(self.sam_to_bam_script,
self.test_sam_filename,
output_dir)
print "Executing: %s" %(sam_to_bam_cmd)
os.system(sam_to_bam_cmd)
# Make sure conversion worked; sorted, indexed BAM file is outputted
assert(os.path.exists(os.path.join(output_dir,
"c2c12.Atp2b1.sorted.bam")))
def test_a2_strandedness(self):
"""
Test that strandedness is read correctly.
"""
# Read 1 is forward, on plus strand
# Has flag 129, i.e. '0b10000001'
f_read = pysam.AlignedRead()
f_read.qname = "f_read"
f_read.flag = 129
f_read.rname = 9
f_read.pos = 4991443
# Read 2 is reverse, on minus strand
# Has flag 81, i.e. '0b1010001'
r_read = pysam.AlignedRead()
r_read.qname = "r_read"
r_read.flag = 81
r_read.rname = 9
r_read.pos = 4991578
# Test that we can read the BAM strand flag correctly
assert(sam_utils.flag_to_strand(f_read.flag) == "+"), \
"Error in determining plus strand of read."
assert(sam_utils.flag_to_strand(r_read.flag) == "-"), \
"Error in determining minus strand of read."
##
## Test stranded-ness rules
##
# fr-unstranded,
# fr-firststrand,
plus_target_strand = "+"
minus_target_strand = "-"
# fr-unstranded: both strand reads should match
# either target strand
print "Testing fr-unstranded..."
for curr_read in [f_read, r_read]:
for target in [plus_target_strand, minus_target_strand]:
print "Checking read ", curr_read.qname, " against ", target
assert(sam_utils.read_matches_strand(curr_read,
target,
"fr-unstranded") == True), \
"Error checking strand of fr-unstranded."
# fr-firststrand: forward read must match target strand,
# i.e. +read matches +target, and -read matches -target
# test +read
print "Testing fr-firststrand..."
assert(sam_utils.read_matches_strand(f_read,
plus_target_strand,
"fr-firststrand") == True), \
"+read must match +target under fr-firstrand."
assert(sam_utils.read_matches_strand(f_read,
minus_target_strand,
"fr-firststrand") == False), \
"+read must match +target under fr-firststrand."
# test -read
assert(sam_utils.read_matches_strand(r_read,
plus_target_strand,
"fr-firststrand") == False), \
"-read must match -target under fr-firststrand."
assert(sam_utils.read_matches_strand(r_read,
minus_target_strand,
"fr-firststrand") == True), \
"-read must match -target under fr-firststrand."
# Test fr-firststrand read pair
pe = (300, 10)
assert(sam_utils.read_matches_strand((f_read, r_read),
plus_target_strand,
"fr-firststrand",
paired_end=pe) == True), \
"(+, -) must match +target under fr-firststrand."
# If target strand is -, second read must match minus strand
assert(sam_utils.read_matches_strand((f_read, r_read),
minus_target_strand,
"fr-firststrand",
paired_end=pe) == True), \
"(+, -) must match -target under fr-firststrand."
def test_z_gene_psi(self):
"""
Test gene-level Psi inferences using SAM/BAM reads.
The 'z' ensures this runs last.
"""
print "Testing gene-level Psi..."
sam_dir = os.path.join(self.tests_output_dir, "sam-output")
bam_filename = os.path.join(sam_dir, "c2c12.Atp2b1.sorted.bam")
read_len = 36
insert_mean = 250
insert_sd = 30
# First index the GFF of interest
gff_filename = os.path.join(self.gff_events_dir,
"mm9",
"genes",
"Atp2b1.mm9.gff")
gff_index_dir = os.path.join(self.gff_events_dir,
"mm9",
"genes",
"Atp2b1",
"indexed")
print "Testing GFF indexing of: %s" %(gff_filename)
index_cmd = "%s --index %s %s" %(self.index_gff_script,
gff_filename,
gff_index_dir)
print "Executing: %s" %(index_cmd)
os.system(index_cmd)
output_dir = os.path.join(self.tests_output_dir,
"gene-psi-output")
miso_cmd = "%s --run %s %s --output-dir %s --read-len %d " \
%(self.events_analysis_cmd,
gff_index_dir,
bam_filename,
output_dir,
read_len)
print "Executing: %s" %(miso_cmd)
os.system(miso_cmd)
def main():
unittest.main()
if __name__ == '__main__':
main()
| 39.2 | 81 | 0.49263 |
b132049a2539fda627b5895723e804824d3b0a67
| 1,012 |
py
|
Python
|
DesignPatterns/CreationalPattern/ObjetPool/object_p.py
|
BALAVIGNESHDOSTRIX/pyexpert
|
300498f66a3a4f6b3060d51b3d6643d8e63cf746
|
[
"CC0-1.0"
] | null | null | null |
DesignPatterns/CreationalPattern/ObjetPool/object_p.py
|
BALAVIGNESHDOSTRIX/pyexpert
|
300498f66a3a4f6b3060d51b3d6643d8e63cf746
|
[
"CC0-1.0"
] | null | null | null |
DesignPatterns/CreationalPattern/ObjetPool/object_p.py
|
BALAVIGNESHDOSTRIX/pyexpert
|
300498f66a3a4f6b3060d51b3d6643d8e63cf746
|
[
"CC0-1.0"
] | null | null | null |
####################################
# Author: "BALAVIGNESH" #
# Maintainer: "BALAVIGNESH" #
# License: "CC0 1.0 Universal" #
# Date: "10/05/2021" #
####################################
class Calculator:
def add(*args):
return sum(args)
def multiply(*args):
result = 1
for x in args:
result *= x
return result
class CalCulatorPool:
_instance_pool = []
def __call__(cls, size):
for x in range(size):
cls._instance_pool.append(CalCulatorPool())
@staticmethod
def factory():
return CalCulatorPool()
@classmethod
def _aquire(cls):
if not cls._instance_pool:
return cls.factory()
return cls._instance_pool.pop()
@classmethod
def _release(cls, instance):
cls._instance_pool.append(instance)
@classmethod
def checker(cls):
print(len(cls._instance_pool))
pool = CalCulatorPool()
pool(10)
pool.checker()
| 20.653061 | 55 | 0.534585 |
b1616e59b6759e1cb7a159f43db5fed76778c868
| 853 |
py
|
Python
|
leetcode/173-Binary-Search-Tree-Iterator/BinSearchTreeIterator_001.py
|
cc13ny/all-in
|
bc0b01e44e121ea68724da16f25f7e24386c53de
|
[
"MIT"
] | 1 |
2015-12-16T04:01:03.000Z
|
2015-12-16T04:01:03.000Z
|
leetcode/173-Binary-Search-Tree-Iterator/BinSearchTreeIterator_001.py
|
cc13ny/all-in
|
bc0b01e44e121ea68724da16f25f7e24386c53de
|
[
"MIT"
] | 1 |
2016-02-09T06:00:07.000Z
|
2016-02-09T07:20:13.000Z
|
leetcode/173-Binary-Search-Tree-Iterator/BinSearchTreeIterator_001.py
|
cc13ny/all-in
|
bc0b01e44e121ea68724da16f25f7e24386c53de
|
[
"MIT"
] | 2 |
2019-06-27T09:07:26.000Z
|
2019-07-01T04:40:13.000Z
|
# Definition for a binary tree node
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class BSTIterator:
# @param root, a binary search tree's root node
def __init__(self, root):
self.curt = root
self.stack = []
# @return a boolean, whether we have a next smallest number
def hasNext(self):
return self.curt or len(self.stack) != 0
# @return an integer, the next smallest number
def next(self):
curt = self.curt
stack = self.stack
while curt:
stack.append(curt)
curt = curt.left
curt = stack.pop()
self.curt = curt.right
return curt.val
# Your BSTIterator will be called like this:
# i, v = BSTIterator(root), []
# while i.hasNext(): v.append(i.next())
| 26.65625 | 63 | 0.583822 |
772bdaf9d8dedfa661c1404c477bcf0ea20558d1
| 2,318 |
py
|
Python
|
Prototype/main prototype/VisualizeWidget.py
|
fowado/BauphysikSE1
|
eb8805196c8fbf99a879c40c5e0725d740c5a0de
|
[
"CC-BY-4.0"
] | 4 |
2019-12-03T16:13:09.000Z
|
2019-12-11T23:22:58.000Z
|
Prototype/main prototype/VisualizeWidget.py
|
fowado/BauphysikSE1
|
eb8805196c8fbf99a879c40c5e0725d740c5a0de
|
[
"CC-BY-4.0"
] | 65 |
2019-12-08T17:43:59.000Z
|
2020-08-14T15:26:21.000Z
|
Prototype/main prototype/VisualizeWidget.py
|
fowado/BauphysikSE1
|
eb8805196c8fbf99a879c40c5e0725d740c5a0de
|
[
"CC-BY-4.0"
] | null | null | null |
# This Python file uses the following encoding: utf-8
from PyQt5 import QtCore
from PyQt5 import QtWidgets
import pyqtgraph as pg
from pyqtgraph import exporters
class VisualizeWidget(QtWidgets.QWidget):
def __init__(self):
QtWidgets.QWidget.__init__(self)
layout = QtWidgets.QVBoxLayout()
self.placeholderLabel = QtWidgets.QLabel()
self.placeholderLabel.setText("this is a placeholder")
self.graphWidget = pg.PlotWidget()
"""PlotWidget used for graphical representation"""
self.graphWidget.setBackground('w')
pen=pg.mkPen(color=(255,0,0))
self.width = []
self.temperature = []
self.graphWidget.setLabel('left', QtCore.QCoreApplication.translate("VisualizeWidget:","Temperatur in °C"))
self.graphWidget.setLabel('bottom', QtCore.QCoreApplication.translate("VisualizeWidget:","Distanz in m"))
self.graphWidget.setTitle(QtCore.QCoreApplication.translate("VisualizeWidget:","Temperaturverlauf"),color='k')
self.data_line = self.graphWidget.plot(self.width,self.temperature,pen=pen)
#layout.addWidget(self.placeholderLabel)
layout.addWidget(self.graphWidget)
self.setMaximumHeight(600)
#self.setMaximumWidth(400)
self.setLayout(layout)
def updateGraph(self, data):
"""updates Graph with given data object"""
self.width=[0]
self.temperature=[]
l = len(data.layers)
for i in range(l):
self.width.append(data.layers[i].width+self.width[i])
self.temperature.append(data.layers[i].t_left)
if i == l-1:
self.temperature.append(data.layers[i].t_right)
self.data_line.setData(self.width,self.temperature)
def switchMode(self,mode):
"""shows/hides widget according to given mode"""
if mode == 0:
self.graphWidget.hide()
else:
self.graphWidget.show()
def getImage(self):
"""get image of graph, used for export"""
try:
exporter = exporters.ImageExporter(self.graphWidget.plotItem)
exporter.parameters()['width'] = 600
img = exporter.export(None,True,False)
return img
except:
img = None
return img
| 33.594203 | 118 | 0.636756 |
b2a824978b46fce09e6c66963f72b579d40bfa6b
| 625 |
py
|
Python
|
matbench/metadata.py
|
sparks-baird/matbench
|
4424609454286e32fff2bcc724379b2a316c5a76
|
[
"MIT"
] | 15 |
2021-11-01T09:02:19.000Z
|
2022-03-19T10:59:41.000Z
|
matbench/metadata.py
|
sparks-baird/matbench
|
4424609454286e32fff2bcc724379b2a316c5a76
|
[
"MIT"
] | 62 |
2021-09-20T14:09:59.000Z
|
2022-03-30T19:03:22.000Z
|
matbench/metadata.py
|
ardunn/matbench
|
7d11a2d63766339ec00e610e2255be29b81544d3
|
[
"MIT"
] | 4 |
2021-03-22T10:37:42.000Z
|
2021-07-20T14:11:28.000Z
|
"""
Metadata for matbench.
"""
from matminer.datasets.utils import _load_dataset_dict
from monty.serialization import loadfn
from matbench.constants import (
MBV01_DATASET_METADATA_PATH,
MBV01_VALIDATION_DATA_PATH,
)
from matbench.util import RecursiveDotDict
MATMINER_DATASET_METADATA = _load_dataset_dict()
mbv01_metadata = loadfn(MBV01_DATASET_METADATA_PATH)
for d in mbv01_metadata.keys():
mbv01_metadata[d].update(MATMINER_DATASET_METADATA[d])
mbv01_metadata = RecursiveDotDict(mbv01_metadata)
mbv01_validation = loadfn(MBV01_VALIDATION_DATA_PATH)
mbv01_validation = RecursiveDotDict(mbv01_validation)
| 26.041667 | 58 | 0.8336 |
0c2b2c8613c9c3c2a3344d953046edbbdd17ac25
| 5,933 |
py
|
Python
|
Packs/PaloAltoNetworks_IoT3rdParty/Scripts/SendPANWIoTDevicesToCiscoISE/SendPANWIoTDevicesToCiscoISE.py
|
diCagri/content
|
c532c50b213e6dddb8ae6a378d6d09198e08fc9f
|
[
"MIT"
] | 799 |
2016-08-02T06:43:14.000Z
|
2022-03-31T11:10:11.000Z
|
Packs/PaloAltoNetworks_IoT3rdParty/Scripts/SendPANWIoTDevicesToCiscoISE/SendPANWIoTDevicesToCiscoISE.py
|
diCagri/content
|
c532c50b213e6dddb8ae6a378d6d09198e08fc9f
|
[
"MIT"
] | 9,317 |
2016-08-07T19:00:51.000Z
|
2022-03-31T21:56:04.000Z
|
Packs/PaloAltoNetworks_IoT3rdParty/Scripts/SendPANWIoTDevicesToCiscoISE/SendPANWIoTDevicesToCiscoISE.py
|
diCagri/content
|
c532c50b213e6dddb8ae6a378d6d09198e08fc9f
|
[
"MIT"
] | 1,297 |
2016-08-04T13:59:00.000Z
|
2022-03-31T23:43:06.000Z
|
import demistomock as demisto # noqa: F401
from CommonServerPython import * # noqa: F401
PANW_IOT_INSTANCE = demisto.args().get('panw_iot_3rd_party_instance')
CISCO_ISE_ACTIVE_INSTANCE = demisto.args().get("active_ise_instance")
GET_EP_ID_CMD = 'cisco-ise-get-endpoint-id-by-name'
def send_status_to_panw_iot_cloud(status, msg):
"""
Reports status details back to PANW IoT Cloud.
param status: Status (error, disabled, success) to be send to PANW IoT cloud.
param msg: Debug message to be send to PANW IoT cloud.
"""
resp = demisto.executeCommand("panw-iot-3rd-party-report-status-to-panw", {
"status": status,
"message": msg,
"integration_name": "ise",
"playbook_name": "PANW IoT 3rd Party Cisco ISE Integration - Bulk Export to Cisco ISE",
"asset_type": 'device',
"timestamp": int(round(time.time() * 1000)),
"using": PANW_IOT_INSTANCE
})
if isError(resp[0]):
err_msg = f'Error, failed to send status to PANW IoT Cloud - {resp[0].get("Contents")}'
raise Exception(err_msg)
def extract_ise_api_error(err_msg):
"""
Extract any connection error or error code if possible,
Otherwise just return the original error
"""
err_msg = err_msg.split('-')[0]
if err_msg.startswith("Error in API call to Cisco"):
start = err_msg.find('[') + 1
end = err_msg.find(']')
return err_msg[start:end]
elif err_msg.startswith("Connection Error. Verify"):
return "Connection Error"
else:
return err_msg
def update_existing_endpoint(mac, attr_map, ep_id, active_instance):
"""
Update an existing endpoint with the given custom attributes.
Param mac: mac address of the endpoint that needs to be updated.
Param attr_map: a map containing various ise custom attributes.
Param ep_id: ID for endpoint that needs to be updated.
Param active_instance: The primary/active ISE instance.
"""
attribute_names = ""
attribute_values = ""
for key in attr_map:
attribute_names += key + ","
attribute_values += str(attr_map[key]) + ","
attribute_names = attribute_names[:-1]
attribute_values = attribute_values[:-1]
resp = demisto.executeCommand("cisco-ise-update-endpoint-custom-attribute", {
"id": ep_id,
"macAddress": mac,
"attributeName": attribute_names,
"attributeValue": attribute_values,
"using": active_instance
})
if isError(resp[0]):
err_msg = f'Error, failed to update custom attributes for endpoint {id} - {resp[0].get("Contents")}'
raise Exception(err_msg)
def create_new_ep(mac, attr_map, active_instance):
"""
Create a new endpoint with the given params
Param mac: mac address of the endpoint that needs to be created.
Param attr_map: a map containing various ise custom attributes.
Param active_instance: The primary/active ISE instance.
"""
resp = demisto.executeCommand("cisco-ise-create-endpoint", {
"mac_address": mac,
"attributes_map": attr_map,
"using": active_instance
})
if isError(resp[0]):
err_msg = f'Failed to create new Endpoint {mac} - {resp[0].get("Contents")}'
raise Exception(err_msg)
def create_or_update_ep(mac, attr_map):
"""
Check if an enpoint exists in ISE, if not create one with the custom attributes
otherwise update it. If at any point the connection goes down or we get a 401 -
unautherized access we will attempt to get the new active instance.
Params mac: Mac adress of the endpoint.
attr_map: Custom attributes for the endpoint.
"""
global CISCO_ISE_ACTIVE_INSTANCE
global GET_EP_ID_CMD
cmd_mac_syntax_map = {
"cisco-ise-get-endpoint-id-by-name": "mac_address",
"cisco-ise-get-endpoint-id": "macAddress"
}
# Check if this mac address (endpoint) is present in ISE by attempting to get its ID
resp = demisto.executeCommand(GET_EP_ID_CMD, {
cmd_mac_syntax_map[GET_EP_ID_CMD]: mac,
"using": CISCO_ISE_ACTIVE_INSTANCE
})
if isError(resp[0]):
err_msg = extract_ise_api_error(resp[0].get("Contents"))
# 404 Not Found or empty results, we need to create a new EP
if err_msg == "404" or err_msg == "list index out of range":
create_new_ep(mac, attr_map, CISCO_ISE_ACTIVE_INSTANCE)
# 405 - Method not allowed means we need to switch to an old filter based API
elif err_msg == '405':
GET_EP_ID_CMD = "cisco-ise-get-endpoint-id"
else:
raise Exception(resp[0].get("Contents"))
else:
ep_id = resp[0]['EntryContext']['Endpoint(val.ID === obj.ID)']['ID']
update_existing_endpoint(mac, attr_map, ep_id, CISCO_ISE_ACTIVE_INSTANCE)
def send_panw_iot_devices_to_send_to_cisco_ise(device_list):
"""
For given device lists consisting of custom attributes, create or update
endpoints in Cisco ISE.
Param device_list: a list of devices and their custom attributes.
"""
count = 0
for device in device_list:
mac = device['mac']
attr_map = device['zb_attributes']
create_or_update_ep(mac, attr_map)
count += 1
return f'Successfully exported {count} devices to Cisco ISE'
def main():
device_list = demisto.args().get('device_maps')
status_msg = None
try:
status_msg = send_panw_iot_devices_to_send_to_cisco_ise(device_list)
except Exception as ex:
send_status_to_panw_iot_cloud("error", str(ex))
return_error(str(ex))
send_status_to_panw_iot_cloud("success", status_msg)
return_results(
CommandResults(
readable_output=status_msg,
outputs_prefix="PaloAltoIoTIntegrationBase.Status",
outputs=status_msg
)
)
if __name__ in ('__main__', '__builtin__', 'builtins'):
main()
| 35.106509 | 108 | 0.668127 |
ac8047b5bfb02c7bed68608fef966c365cce9679
| 3,796 |
py
|
Python
|
addition_module/DMUE/preprocess/crop_align.py
|
weihaoxie/FaceX-Zoo
|
db0b087e4f4d28152e172d6c8d3767a8870733b4
|
[
"Apache-2.0"
] | 1,329 |
2021-01-13T07:06:30.000Z
|
2022-03-31T07:23:39.000Z
|
addition_module/DMUE/preprocess/crop_align.py
|
weihaoxie/FaceX-Zoo
|
db0b087e4f4d28152e172d6c8d3767a8870733b4
|
[
"Apache-2.0"
] | 115 |
2021-01-13T10:42:57.000Z
|
2022-03-28T03:57:52.000Z
|
addition_module/DMUE/preprocess/crop_align.py
|
weihaoxie/FaceX-Zoo
|
db0b087e4f4d28152e172d6c8d3767a8870733b4
|
[
"Apache-2.0"
] | 351 |
2021-01-13T07:21:00.000Z
|
2022-03-29T14:11:39.000Z
|
import os
import cv2
import numpy as np
from tqdm import tqdm
from skimage import transform as trans
from mtcnn import MTCNN
from face_alignmenet.get_landmark import *
img_root = '/path/to/your/AffectNet_root'
save_root = '/path/to/your/align_larger_256'
missed_img_txt = '/path/to/your/missed_img.txt'
lb_txt = '/path/to/your/AffectNet_label_file.txt'
lb2_txt = '/path/to/your/lb2.txt'
mtcnn = MTCNN(keep_all=True)
lmd_t = np.load('template.npy')
model_ft = load_model()
unsupported_format = ['tif','TIF', 'bmp', 'BMP']
lines = open(lb_txt, 'r').readlines()
for i in tqdm(range(len(lines))):
line_ = lines[i]
img_path = line_.split(' ')[0].split('_')[1]
label = line_.split(' ')[1]
img_folder, img_name = img_path.split('/')[0], img_path.split('/')[1]
old_img_path = os.path.join(img_root, img_folder, img_name)
new_img_path = os.path.join(save_root, img_folder, img_name)
if not os.path.exists(os.path.dirname(new_img_path)):
os.makedirs(os.path.dirname(new_img_path))
if img_name.split('.')[1] in unsupported_format:
img_name = img_name.split('.')[0]+'.jpg'
for _format in unsupported_format:
line_ = line_.replace(_format, '.jpg')
if not os.path.exists(old_img_path):
with open(missed_img_txt, 'a+') as f:
f.write(line_+'\n')
continue
# align face
img = Image.open(old_img_path)
img_ = np.array(img)
boxes, probs = mtcnn.detect(img, landmarks=False)
if boxes is not None:
if boxes[0][0] < 0:
boxes[0][0] = 0
if boxes[0][1] < 0:
boxes[0][1] = 0
if boxes[0][2] > img_.shape[1]:
boxes[0][2] = img_.shape[1] - 1
if boxes[0][3] > img_.shape[0]:
boxes[0][3] = img_.shape[0] - 1
else:
with open(missed_img_txt, 'a+') as f:
f.write(line_)
continue
img_c = img_[int(boxes[0][1]):int(boxes[0][3]), int(boxes[0][0]):int(boxes[0][2]), :]
img_c = img_c[:, :, :3]
img_re = cv2.resize(img_c, (256, 256), interpolation=cv2.INTER_CUBIC)
img_re = img_re[:,:,:3]
lmd1 = get_lmd(model_ft, img_re)
lmd1[:, 0] = lmd1[:, 0] * img_c.shape[1] / 256 + boxes[0][0]
lmd1[:, 1] = lmd1[:, 1] * img_c.shape[0] / 256 + boxes[0][1]
tform = trans.SimilarityTransform()
res = tform.estimate(lmd1, lmd_t)
dst = trans.warp(img_, tform.inverse, output_shape=(800, 800), cval=0.0)
dst = uint8(dst * 255)
dst_ = Image.fromarray(dst)
boxes, probs = mtcnn.detect(dst_, landmarks=False)
if boxes is not None:
if boxes[0][0] < 0:
boxes[0][0] = 0
if boxes[0][1] < 0:
boxes[0][1] = 0
if boxes[0][2] > dst.shape[1]:
boxes[0][2] = dst.shape[1] - 1
if boxes[0][3] > dst.shape[0]:
boxes[0][3] = dst.shape[0] - 1
h, w = int(boxes[0][3])-int(boxes[0][1]), int(boxes[0][2])-int(boxes[0][0])
h_, w_ = h*256/224, w*256/224
pdh, pdw = int((h_-h)/2), int((w_-w)/2)
xmin, xmax, ymin, ymax = int(boxes[0][1])-pdh, int(boxes[0][3])+pdh, int(boxes[0][0])-pdw, int(boxes[0][2])+pdw
if xmin < 0:
xmin = 0
if ymin < 0:
ymin = 0
if ymax > dst.shape[1]:
ymax = dst.shape[1] - 1
if xmax > dst.shape[0]:
xmax = dst.shape[0] - 1
dst_large = dst[xmin:xmax, ymin:ymax, :]
if dst_large.shape[2] > 3:
dst_large = dst_large[:,:,:3]
else:
with open(missed_img_txt, 'a+') as f:
f.write(line_)
continue
dst_large = cv2.resize(dst_large, (256, 256), interpolation=cv2.INTER_CUBIC)[:, :, :3]
cv2.imwrite(new_img_path, dst_large[:,:,::-1])
with open(lb2_txt, 'a+') as f:
f.write(line_)
| 31.371901 | 119 | 0.567439 |
0248a795a319d86c9c606ab8d42a9eaeb7f9ee3f
| 634 |
py
|
Python
|
hausse/plugins/layout/discover_partials.py
|
andrenasturas/hausse
|
58e7cb71d5105cf1d6ec7d294e85668855bf8336
|
[
"MIT"
] | null | null | null |
hausse/plugins/layout/discover_partials.py
|
andrenasturas/hausse
|
58e7cb71d5105cf1d6ec7d294e85668855bf8336
|
[
"MIT"
] | 1 |
2021-08-30T21:41:46.000Z
|
2021-08-30T21:41:46.000Z
|
hausse/plugins/layout/discover_partials.py
|
andrenasturas/hausse
|
58e7cb71d5105cf1d6ec7d294e85668855bf8336
|
[
"MIT"
] | 1 |
2021-08-31T19:27:32.000Z
|
2021-08-31T19:27:32.000Z
|
import glob
import os
from pathlib import Path, PurePath
from typing import List
from hausse.lib import PathPlugin, Project
class DiscoverPartials(PathPlugin):
"""
Register layouts partials before layout engine plugin execution.
"""
def __init__(self, path: str = "partials", pattern: str = "*.hbs"):
super().__init__(path)
self.pattern = pattern
def __call__(self, project: Project):
project.settings["partials"] = dict()
for f in self.path.rglob(self.pattern):
with open(f, "r") as p:
project.settings["partials"][PurePath(f).stem] = p.read()
| 23.481481 | 73 | 0.643533 |
0c8a86c7470ae2cb4b0c64de9522035291d90985
| 234 |
py
|
Python
|
Language Proficiency/Python/Sets/Set .discard(), .remove() & .pop()/set_remove.py
|
xuedong/hacker-rank
|
ce8a60f80c2c6935b427f9409d7e826ee0d26a89
|
[
"MIT"
] | 1 |
2021-02-22T17:37:45.000Z
|
2021-02-22T17:37:45.000Z
|
Language Proficiency/Python/Sets/Set .discard(), .remove() & .pop()/set_remove.py
|
xuedong/hacker-rank
|
ce8a60f80c2c6935b427f9409d7e826ee0d26a89
|
[
"MIT"
] | null | null | null |
Language Proficiency/Python/Sets/Set .discard(), .remove() & .pop()/set_remove.py
|
xuedong/hacker-rank
|
ce8a60f80c2c6935b427f9409d7e826ee0d26a89
|
[
"MIT"
] | null | null | null |
#!/usr/bin/env python3
if __name__ == '__main__':
n = int(input())
s = set(map(int, input().split()))
N = int(input())
for _ in range(N):
eval("s.{0}({1})".format(*input().split()+['']))
print(sum(s))
| 16.714286 | 56 | 0.495726 |
0b5b0cc86c95ed34d72265cdaa420fb678375341
| 1,591 |
py
|
Python
|
simulation.py
|
Klark007/Selbstfahrendes-Auto-im-Modell
|
d7fe81392de2b29b7dbc7c9d929fa0031b89900b
|
[
"MIT"
] | null | null | null |
simulation.py
|
Klark007/Selbstfahrendes-Auto-im-Modell
|
d7fe81392de2b29b7dbc7c9d929fa0031b89900b
|
[
"MIT"
] | null | null | null |
simulation.py
|
Klark007/Selbstfahrendes-Auto-im-Modell
|
d7fe81392de2b29b7dbc7c9d929fa0031b89900b
|
[
"MIT"
] | null | null | null |
"""
Simulates a bad driving vehicle
"""
import Image_Recognition.Find_Car as find_car
import Image_Recognition.Find_Box as find_box
import Image_Recognition.Find_Rotation as find_rot
import Simplification.Image_Greyscaling as img_greyscale
import U_Generate_Image as generate_image
import numpy
import time
import random
def simulate(name):
# pos, rectangles (image coordinates), cell size
generate_image.run(None, run_on(name))
pass
def run_on(name):
start_time = time.time()
debugging = 1
# debugging = 0.5 will just be used when it is run as main
if __name__ != "__main__" and debugging == 0.5:
debugging = 0
img = img_greyscale.prepare_image(name, 100, 1)
print("Time after image preparation:", time.time() - start_time)
car_scanner = find_car.ImageScanner(img, 87, 30)
car_box = car_scanner.run()
print("Car:", car_box)
# size_range has to be tested out on different images
box_scanner = find_box.ImageScanner(img, 25, 25, 50, debugging)
rectangles, cell_size = box_scanner.run()
# creates a cutout version of the car bounding box
car_part = img[car_box[0][1]:car_box[0][1] + car_box[1][1], car_box[0][0]:car_box[0][0] + car_box[1][0]]
# get rotation of the car using the white point on the robot
rot = find_rot.RotationScanner(car_part, 250, 5).rotation
print("White circle:" + str(rot))
print("Time after image recognition:", time.time() - start_time)
return (car_box, rot, rectangles, cell_size)
if __name__ == "__main__":
simulate("Images/Artificial/2.png")
| 26.966102 | 108 | 0.705845 |
6549b5f8b82cef7e4fe5c25ba22fb3c2be72630b
| 210 |
py
|
Python
|
sso-db/ssodb/common/models/__init__.py
|
faical-yannick-congo/sso-backend
|
e962006b0fecd68e4da94e54b4dc63547a5a2c21
|
[
"MIT"
] | null | null | null |
sso-db/ssodb/common/models/__init__.py
|
faical-yannick-congo/sso-backend
|
e962006b0fecd68e4da94e54b4dc63547a5a2c21
|
[
"MIT"
] | null | null | null |
sso-db/ssodb/common/models/__init__.py
|
faical-yannick-congo/sso-backend
|
e962006b0fecd68e4da94e54b4dc63547a5a2c21
|
[
"MIT"
] | null | null | null |
"""SMS SSO Mongoengine Database Models.
"""
from .country_model import Country
from .city_model import City
from .service_model import Service
from .user_model import User
from .activity_model import Activity
| 23.333333 | 39 | 0.814286 |
0bf18861b086baa1885c836f1171decb42edbcb4
| 2,500 |
py
|
Python
|
scripts/qt1/pyqt_sw09_LCD_Slider_Button_Vererbung.py
|
ProfJust/Ruhr-TurtleBot-Competition-RTC-
|
5c2425bee331b4d5033757a9425676932d111775
|
[
"Unlicense",
"MIT"
] | null | null | null |
scripts/qt1/pyqt_sw09_LCD_Slider_Button_Vererbung.py
|
ProfJust/Ruhr-TurtleBot-Competition-RTC-
|
5c2425bee331b4d5033757a9425676932d111775
|
[
"Unlicense",
"MIT"
] | null | null | null |
scripts/qt1/pyqt_sw09_LCD_Slider_Button_Vererbung.py
|
ProfJust/Ruhr-TurtleBot-Competition-RTC-
|
5c2425bee331b4d5033757a9425676932d111775
|
[
"Unlicense",
"MIT"
] | null | null | null |
#!/usr/bin/python3
import sys
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import (QWidget, QLCDNumber, QSlider,
QPushButton, QVBoxLayout,
QHBoxLayout, QApplication, QLabel)
class myButton(QPushButton):
# Konstruktor
# benötigt Zugriff auf str '<' oder '>', Label und Slider
def __init__(self, str, lbl, slider):
super(myButton, self).__init__()
self.setText(str)
self.label = lbl
self.sld = slider
# > "this" bzw. self muss in Python immer explixit angegeben
# > werden, anders als z.B. bei C++.
# Das ist einer der Python-Grundsätze:
# "Explicit is better than implicit",
# zusaetzliche Fkt von myButton zu QPushButton
def SlotKlick(self):
sender = self.sender()
wert = self.sld.value()
if sender.text() == '<':
self.label.setText('less')
wert = wert-1
else:
self.label.setText('more')
wert = wert+1
self.sld.setValue(wert)
class Example(QWidget):
def __init__(self): # Konstrukor
# Konstruktor der Elternklasse aufrufen
super(Example, self).__init__()
self.initUI()
def initUI(self):
# Instanziierung der Widgets
lcd = QLCDNumber(self)
self.sld = QSlider(Qt.Horizontal, self)
self.lblStatus = QLabel('Statuszeile')
self.pbLess = myButton('<', self.lblStatus, self.sld)
self.pbMore = myButton('>', self.lblStatus, self.sld)
# BOX-Layout mit Widgets füllen
vbox = QVBoxLayout()
# 1.Reihe
vbox.addWidget(lcd)
# 2.Reihe
vbox.addWidget(self.sld)
# 3.Reihe
hbox = QHBoxLayout()
hbox.addWidget(self.pbLess)
hbox.addWidget(self.pbMore)
vbox.addLayout(hbox)
# 4.Reihe
vbox.addWidget(self.lblStatus)
# Alle Boxen ins Window setzen
self.setLayout(vbox)
# Signal und Slot verbinden
self.sld.valueChanged.connect(lcd.display)
self.sld.valueChanged.connect(lcd.display)
self.pbLess.clicked.connect(self.pbLess.SlotKlick)
self.pbMore.clicked.connect(self.pbMore.SlotKlick)
# Fenster Konfigurieren
self.setGeometry(300, 300, 250, 150)
self.setWindowTitle('Signal and slot')
self.show()
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
| 30.120482 | 68 | 0.596 |
500e7782331758cc040bde2af424c471c941b0c9
| 145 |
py
|
Python
|
pages/themes/beginners/sequenceDataTypes/Tasks_and_HW/tmp.py
|
ProgressBG-Python-Course/ProgressBG-Python
|
6429833696c2c50d9f902f62cc3a65ca62659c69
|
[
"MIT"
] | null | null | null |
pages/themes/beginners/sequenceDataTypes/Tasks_and_HW/tmp.py
|
ProgressBG-Python-Course/ProgressBG-Python
|
6429833696c2c50d9f902f62cc3a65ca62659c69
|
[
"MIT"
] | null | null | null |
pages/themes/beginners/sequenceDataTypes/Tasks_and_HW/tmp.py
|
ProgressBG-Python-Course/ProgressBG-Python
|
6429833696c2c50d9f902f62cc3a65ca62659c69
|
[
"MIT"
] | null | null | null |
sum = 0
first_num = 1000
last_num = 1200
num = first_num
while num <= last_num:
if num%2 == 0:
sum += num
num += 1
print(sum)
| 11.153846 | 22 | 0.565517 |
68090ea695d85274aea136d2363541ea902a9b2c
| 960 |
py
|
Python
|
app/api/v1/ticket.py
|
zucc-acm-devteam/zuccacm-sso
|
9c7d2f0b9cc069962f32b555152732a98bf2e94a
|
[
"Apache-2.0"
] | null | null | null |
app/api/v1/ticket.py
|
zucc-acm-devteam/zuccacm-sso
|
9c7d2f0b9cc069962f32b555152732a98bf2e94a
|
[
"Apache-2.0"
] | null | null | null |
app/api/v1/ticket.py
|
zucc-acm-devteam/zuccacm-sso
|
9c7d2f0b9cc069962f32b555152732a98bf2e94a
|
[
"Apache-2.0"
] | null | null | null |
from flask_login import current_user, login_required
from app.libs.red_print import RedPrint
from app.libs.error_code import Success, NotFound, Forbidden
from app.validators.ticket import CheckTicketForm
from app.models.user import User
from app.libs.helper import get_ticket, renew_ticket
api = RedPrint('ticket')
@api.route('', methods=['GET'])
@login_required
def get_ticket_api():
ticket = get_ticket(current_user)
if ticket is None:
ticket = renew_ticket(current_user)
return Success(data={
'username': current_user.username,
'ticket': ticket
})
@api.route('/check', methods=['POST'])
def check_ticket_api():
form = CheckTicketForm().validate_for_api().data_
user = User.get_by_id(form['username'])
if not user:
return NotFound(msg='用户不存在')
ticket = get_ticket(user)
if ticket is None or ticket != form['ticket']:
return Forbidden(msg='校验失败')
return Success(msg='校验成功')
| 29.090909 | 60 | 0.708333 |
96ce9fc536517ec8d08ce59e4a8421af856d9a59
| 4,765 |
py
|
Python
|
Co-Simulation/Sumo/sumo-1.7.0/tools/contributed/sumopy/coremodules/network/osmnx_import.py
|
uruzahe/carla
|
940c2ab23cce1eda1ef66de35f66b42d40865fb1
|
[
"MIT"
] | 4 |
2020-11-13T02:35:56.000Z
|
2021-03-29T20:15:54.000Z
|
Co-Simulation/Sumo/sumo-1.7.0/tools/contributed/sumopy/coremodules/network/osmnx_import.py
|
uruzahe/carla
|
940c2ab23cce1eda1ef66de35f66b42d40865fb1
|
[
"MIT"
] | 9 |
2020-12-09T02:12:39.000Z
|
2021-02-18T00:15:28.000Z
|
Co-Simulation/Sumo/sumo-1.7.0/tools/contributed/sumopy/coremodules/network/osmnx_import.py
|
uruzahe/carla
|
940c2ab23cce1eda1ef66de35f66b42d40865fb1
|
[
"MIT"
] | 1 |
2020-11-20T19:31:26.000Z
|
2020-11-20T19:31:26.000Z
|
# Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
# Copyright (C) 2016-2020 German Aerospace Center (DLR) and others.
# SUMOPy module
# Copyright (C) 2012-2017 University of Bologna - DICAM
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License 2.0 which is available at
# https://www.eclipse.org/legal/epl-2.0/
# This Source Code may also be made available under the following Secondary
# Licenses when the conditions for such availability set forth in the Eclipse
# Public License 2.0 are satisfied: GNU General Public License, version 2
# or later which is available at
# https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# @file osmnx_import.py
# @author Joerg Schweizer
# @date
import os
import json
import metworkx as nx
import agilepy.lib_base.classman as cm
import agilepy.lib_base.arrayman as am
import agilepy.lib_base.xmlman as xm
from netconvert import *
from coremodules.misc.shapeformat import guess_utm_from_coord
def import_nx(graphx, net, projparams=''):
"""
Import networkx graphx into net
"""
for id_node_sumo, nbrsdict in graphx.adjacency():
print ' id_node_sumo', id_node_sumo
for nbr, eattr in nbrsdict.items():
print ' nbr, eattr', nbr, eattr
if projparams == "":
projparams_target = guess_utm_from_coord()
class OxImporter(Process):
def __init__(self, scenario,
ident='oximporter',
name='OSMnx importer',
info='Import of network imported with the help of osmnx.',
logger=None, **kwargs):
print 'OxImporter.__init__'
self._init_common(ident,
parent=scenario,
name=name,
logger=logger,
info=info,
)
attrsman = self.set_attrsman(cm.Attrsman(self))
# self.id_mode = attrsman.add(am.AttrConf('id_mode', modechoices['bicycle'],
# groupnames = ['options'],
# choices = modechoices,
# name = 'Mode',
# info = 'Transport mode to be matched.',
# ))
self.osmdatafilepaths = attrsman.add(
cm.AttrConf('osmdatafilepaths', kwargs.get('osmdatafilepaths', ''),
groupnames=['options'],
perm='rw',
name='OSM data file(s)',
wildcards='Jason file (*.json)|*.json',
metatype='filepaths',
info="""One or several jason filepaths holding OSM related information.""",
))
self.nxnetworkpaths = attrsman.add(
cm.AttrConf('nxnetworkpaths', kwargs.get('nxnetworkpaths', ''),
groupnames=['options'],
perm='rw',
name='Networkx file(s)',
wildcards='NetworkX file (*.obj)|*.obj',
metatype='filepaths',
info="""One or several network X filepaths containing topological information of simplified network.""",
))
# def import_xnet(net, nodeshapefilepath, edgeshapefilepath, polyshapefilepath):
#import_nodeshapes(net, nodeshapefilepath)
def get_scenario(self):
return self.parent
def do(self):
print self.ident+'.do'
net = self.get_scenario().net
projparams_target = net.get_projparams()
if projparams_target in ("", "!"):
projparams_target = ""
for filepath in self.nxnetworkpaths:
graphx = cm.load_obj(filepath)
import_nx(graphx, net, projparams=projparams_target)
projparams_target = net.get_projparams()
# OxNodesImporter(self.nodeshapefilepath, self,
# projparams_target = projparams_target,
# is_guess_targetproj = is_guess_targetproj,
# logger = self.get_logger(),
# ).do()
# ShapefileImporter( self.nodeshapefilepath,
# self.parent.net.nodes.coords,
# map_attrconfig2shapeattr = {},
# projparams_target = projparams_target,
# is_guess_targetproj = is_guess_targetproj,
# logger = self.get_logger(),
# ).do()
return True
| 38.12 | 128 | 0.556348 |
4fd30062df6f81fe3f86f498957c201ebe2b7e16
| 37 |
py
|
Python
|
main.py
|
yunyuyuan/wuziqi-back
|
448632e4eee81f411564e2e9199fb603029e8008
|
[
"MIT"
] | null | null | null |
main.py
|
yunyuyuan/wuziqi-back
|
448632e4eee81f411564e2e9199fb603029e8008
|
[
"MIT"
] | null | null | null |
main.py
|
yunyuyuan/wuziqi-back
|
448632e4eee81f411564e2e9199fb603029e8008
|
[
"MIT"
] | null | null | null |
from src import start
app = start()
| 9.25 | 21 | 0.702703 |
8c68502f7d1f6630be38cda4c3bbd5df310c61a9
| 1,961 |
py
|
Python
|
apps/mail/views.py
|
LvanArkel/sbzwebsite
|
a26efbb050585312c53010f14f86c23616a8071f
|
[
"BSD-3-Clause"
] | 1 |
2017-01-08T13:21:43.000Z
|
2017-01-08T13:21:43.000Z
|
apps/mail/views.py
|
LvanArkel/sbzwebsite
|
a26efbb050585312c53010f14f86c23616a8071f
|
[
"BSD-3-Clause"
] | 17 |
2018-12-03T14:22:14.000Z
|
2021-07-14T15:15:12.000Z
|
apps/mail/views.py
|
LvanArkel/sbzwebsite
|
a26efbb050585312c53010f14f86c23616a8071f
|
[
"BSD-3-Clause"
] | 2 |
2018-12-03T14:58:49.000Z
|
2019-12-01T13:24:42.000Z
|
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect, get_object_or_404
from django.views.decorators.http import require_http_methods
from apps.mail import snt
from apps.mail.forms import GroupForm
from apps.mail.models import Group
@login_required
def index(request):
groups = Group.objects
people = groups.filter(type="P").all()
functions = groups.filter(type="F").all()
organizations = groups.filter(type="O").all()
for group_list in (people, functions, organizations):
for group in group_list:
group.form = GroupForm(instance=group)
create_form = GroupForm()
return render(request, 'mail/index.html', {
'create_form': create_form,
'people': people,
'functions': functions,
'organizations': organizations,
})
@login_required
def sync(request):
if request.method == 'POST':
commit = True
else:
commit = False
log = snt.sync(commit=commit)
return render(request, 'mail/sync.html', {
'log': log,
'commit': commit,
})
def warn_sync(request):
messages.warning(request, 'Please remember to synchronize the aliases with Hornet.')
@login_required
@require_http_methods(["POST"])
def group_create(request):
form = GroupForm(request.POST)
if form.is_valid():
form.save()
warn_sync(request)
return redirect('mail:index')
@login_required
@require_http_methods(["POST"])
def group_edit(request, pk):
group = get_object_or_404(Group, pk=pk)
form = GroupForm(request.POST, instance=group)
if form.is_valid():
form.save()
warn_sync(request)
return redirect('mail:index')
@login_required
@require_http_methods(["POST"])
def group_delete(request, pk):
group = get_object_or_404(Group, pk=pk)
group.delete()
warn_sync(request)
return redirect('mail:index')
| 22.802326 | 88 | 0.684345 |
ad53984bafc8c52b5f31f270f18ef6afb516d1ba
| 2,854 |
py
|
Python
|
travelplanner/Route.py
|
UCL/mphy0021-2019-travel-planner-sukrire
|
5f8b3479b858c46a01b68ee866560dd28d5be47a
|
[
"MIT"
] | null | null | null |
travelplanner/Route.py
|
UCL/mphy0021-2019-travel-planner-sukrire
|
5f8b3479b858c46a01b68ee866560dd28d5be47a
|
[
"MIT"
] | null | null | null |
travelplanner/Route.py
|
UCL/mphy0021-2019-travel-planner-sukrire
|
5f8b3479b858c46a01b68ee866560dd28d5be47a
|
[
"MIT"
] | null | null | null |
import numpy as np
import matplotlib.pyplot as plt
from travelplanner.read_passengers import Read_route
class Route:
def __init__(self, route, speed=10):
self.speed = speed
self.route = Read_route(route)
self.xcoord = []
self.ycoord = []
self.bstop = []
for points in range(len(self.route)):
self.xcoord.append(self.route[points][0])
self.ycoord.append(self.route[points][1])
self.bstop.append(self.route[points][2])
route_cc = self.route_cc()
for i in route_cc[1]:
assert int(i) % 2 == 0, 'Diagonal route'
def timetable(self):
self.stoptime = []
self.timetablevec = []
self.stopno = []
time = 0
stopcount = 0
for tick in range(len(self.bstop)):
if self.bstop[tick] != '':
self.stoptime.append(time)
self.stopno.append(stopcount)
else:
self.stoptime.append('')
self.stopno.append('')
time += self.speed
stopcount += 1
for points in range(len(self.bstop)):
self.timetablevec.append((self.bstop[points],
self.stoptime[points],
self.stopno[points]))
return self.timetablevec
def plot_map(self):
self.stopmarks = [step[2] for step in self.timetable() if step[0]]
max_x = max([n for n in self.xcoord]) + 5 # adds padding
max_y = max([n for n in self.ycoord]) + 5
grid = np.zeros((max_y, max_x))
for stop in self.bstop:
grid[self.ycoord, self.xcoord] = 1
for stop in self.stopmarks:
grid[self.ycoord[self.timetable()[stop][2]],
self.xcoord[self.timetable()[stop][2]]] += 1
fig, ax = plt.subplots(1, 1)
ax.pcolor(grid)
ax.invert_yaxis()
ax.set_aspect('equal', 'datalim')
return ax
def route_cc(self):
'''
Converts a set of route into a Freeman chain code
3 2 1
\ | /
4 - C - 0
/ | \
5 6 7
'''
start = self.xcoord[0], self.ycoord[0]
cc = []
freeman_cc2coord = {0: (1, 0),
1: (1, -1),
2: (0, -1),
3: (-1, -1),
4: (-1, 0),
5: (-1, 1),
6: (0, 1),
7: (1, 1)}
freeman_coord2cc = {val: key for key, val in freeman_cc2coord.items()}
for b, a in zip(self.route[1:], self.route):
x_step = b[0] - a[0]
y_step = b[1] - a[1]
cc.append(str(freeman_coord2cc[(x_step, y_step)]))
return start, ''.join(cc)
| 33.97619 | 78 | 0.475123 |
0e18f8cacecf92502af41e78b61d3b90a32d0a83
| 1,630 |
py
|
Python
|
my-cs/intern/visuality/graphs/pygraph_sample.py
|
zaqwes8811/cs-courses
|
aa9cf5ad109c9cfcacaadc11bf2defb2188ddce2
|
[
"Apache-2.0"
] | null | null | null |
my-cs/intern/visuality/graphs/pygraph_sample.py
|
zaqwes8811/cs-courses
|
aa9cf5ad109c9cfcacaadc11bf2defb2188ddce2
|
[
"Apache-2.0"
] | 15 |
2015-03-07T12:46:41.000Z
|
2015-04-11T09:08:36.000Z
|
intern/visuality/graphs/pygraph_sample.py
|
zaqwes8811/micro-apps
|
7f63fdf613eff5d441a3c2c7b52d2a3d02d9736a
|
[
"MIT"
] | null | null | null |
#!/usr/bin/env python
# Copyright (c) 2007-2008 Pedro Matiello <[email protected]>
# License: MIT (see COPYING file)
# Import pygraph
from pygraph.classes.graph import graph
from pygraph.classes.digraph import digraph
from pygraph.algorithms.searching import breadth_first_search
from pygraph.readwrite.dot import write
# Graph creation
gr = graph()
# Add nodes and edges
gr.add_nodes(["Portugal","Spain","France","Germany","Belgium","Netherlands","Italy"])
gr.add_nodes(["Switzerland","Austria","Denmark","Poland","Czech Republic","Slovakia","Hungary"])
gr.add_nodes(["England","Ireland","Scotland","Wales"])
gr.add_edge(("Portugal", "Spain"))
gr.add_edge(("Spain","France"))
gr.add_edge(("France","Belgium"))
gr.add_edge(("France","Germany"))
gr.add_edge(("France","Italy"))
gr.add_edge(("Belgium","Netherlands"))
gr.add_edge(("Germany","Belgium"))
gr.add_edge(("Germany","Netherlands"))
gr.add_edge(("England","Wales"))
gr.add_edge(("England","Scotland"))
gr.add_edge(("Scotland","Wales"))
gr.add_edge(("Switzerland","Austria"))
gr.add_edge(("Switzerland","Germany"))
gr.add_edge(("Switzerland","France"))
gr.add_edge(("Switzerland","Italy"))
gr.add_edge(("Austria","Germany"))
gr.add_edge(("Austria","Italy"))
gr.add_edge(("Austria","Czech Republic"))
gr.add_edge(("Austria","Slovakia"))
gr.add_edge(("Austria","Hungary"))
gr.add_edge(("Denmark","Germany"))
gr.add_edge(("Poland","Czech Republic"))
gr.add_edge(("Poland","Slovakia"))
gr.add_edge(("Poland","Germany"))
gr.add_edge(("Czech Republic","Slovakia"))
gr.add_edge(("Czech Republic","Germany"))
gr.add_edge(("Slovakia","Hungary"))
# Draw as PNG
dot = write(gr)
| 33.265306 | 96 | 0.715337 |
adbdfa1cb0a518e39f2d57202650471a8d22cd4c
| 1,183 |
py
|
Python
|
event_detector/gttm/word_cloud/wordcloud.py
|
MahdiFarnaghi/gtm
|
adbec372786262607291f901a444a0ebe9e98b48
|
[
"Apache-2.0"
] | null | null | null |
event_detector/gttm/word_cloud/wordcloud.py
|
MahdiFarnaghi/gtm
|
adbec372786262607291f901a444a0ebe9e98b48
|
[
"Apache-2.0"
] | null | null | null |
event_detector/gttm/word_cloud/wordcloud.py
|
MahdiFarnaghi/gtm
|
adbec372786262607291f901a444a0ebe9e98b48
|
[
"Apache-2.0"
] | null | null | null |
from pathlib import Path
import pandas as pd
import os
from wordcloud import WordCloud
def generate_wordcloud(series: pd.Series, stop_words=None, save_wc=False, max_words=20,
filepath_wc=""):
wc = WordCloud(background_color="white", max_words=max_words,
stopwords=stop_words, contour_width=3, contour_color='steelblue', width=4000, height=2000)
text = series.str.cat(sep=' ')
# generate word cloud
wordcloud = wc.generate(text)
if save_wc and filepath_wc != "":
if not Path(filepath_wc).parent.exists():
os.makedirs(Path(filepath_wc).parent.absolute())
wc.to_file(filepath_wc)
return wordcloud
def generate_wordcloud_of_topic(topic, save_wc=False, filepath_wc=""):
wc = WordCloud(background_color="white", max_words=50,
stopwords=None, contour_width=3, contour_color='steelblue', width=4000, height=2000)
wordcloud = wc.generate_from_frequencies(topic)
if save_wc and filepath_wc != "":
if not Path(filepath_wc).parent.exists():
os.makedirs(Path(filepath_wc).parent.absolute())
wc.to_file(filepath_wc)
return wordcloud
| 35.848485 | 109 | 0.682164 |
adbdfae8853d93cd0e713932e6776bff1b06ce9b
| 339 |
py
|
Python
|
project/services/location.py
|
DanielGrams/gsevp
|
e94034f7b64de76f38754b56455e83092378261f
|
[
"MIT"
] | 1 |
2021-06-01T14:49:18.000Z
|
2021-06-01T14:49:18.000Z
|
project/services/location.py
|
DanielGrams/gsevp
|
e94034f7b64de76f38754b56455e83092378261f
|
[
"MIT"
] | 286 |
2020-12-04T14:13:00.000Z
|
2022-03-09T19:05:16.000Z
|
project/services/location.py
|
DanielGrams/gsevpt
|
a92f71694388e227e65ed1b24446246ee688d00e
|
[
"MIT"
] | null | null | null |
def assign_location_values(target, origin):
if origin:
target.street = origin.street
target.postalCode = origin.postalCode
target.city = origin.city
target.state = origin.state
target.country = origin.country
target.latitude = origin.latitude
target.longitude = origin.longitude
| 33.9 | 45 | 0.669617 |
70b4e427d5e013b3e9efcf401242df098f538261
| 6,079 |
py
|
Python
|
research/cv/midas/infer/sdk/eval/util.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 77 |
2021-10-15T08:32:37.000Z
|
2022-03-30T13:09:11.000Z
|
research/cv/midas/infer/sdk/eval/util.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 3 |
2021-10-30T14:44:57.000Z
|
2022-02-14T06:57:57.000Z
|
research/cv/midas/infer/sdk/eval/util.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 24 |
2021-10-15T08:32:45.000Z
|
2022-03-24T18:45:20.000Z
|
# Copyright 2021 Huawei Technologies Co., Ltd
#
# 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.
# ============================================================================
"""util."""
import sys
import numpy as np
import cv2
from PIL import Image
TAG_FLOAT = 202021.25
TAG_CHAR = 'PIEH'
def read_image(path):
"""Read image and output RGB image (0-1).
Args:
path (str): path to file
Returns:
array: RGB image (0-1)
"""
img = cv2.imread(path)
if img.ndim == 2:
img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) / 255.0
return img
def write_depth(path, depth, bits=1):
"""Write depth map to pfm and png file.
Args:
path (str): filepath without extension
depth (array): depth
:param path:
:param depth:
:param bits:
"""
write_pfm(path + ".pfm", depth.astype(np.float32))
depth_min = depth.min()
depth_max = depth.max()
max_val = (2 ** (8 * bits)) - 1
if depth_max - depth_min > np.finfo("float").eps:
out = max_val * (depth - depth_min) / (depth_max - depth_min)
else:
out = np.zeros(depth.shape, dtype=depth.type)
if bits == 1:
cv2.imwrite(path + ".png", out.astype("uint8"))
elif bits == 2:
cv2.imwrite(path + ".png", out.astype("uint16"))
return out
def write_pfm(path, image, scale=1):
"""Write pfm file.
Args:
path (str): path file
image (array): data
scale (int, optional): Scale. Defaults to 1.
"""
with open(path, "wb") as file:
color = None
if image.dtype.name != "float32":
raise Exception("Image dtype must be float32.")
image = np.flipud(image)
if len(image.shape) == 3 and image.shape[2] == 3: # color image
color = True
elif (
len(image.shape) == 2 or len(image.shape) == 3 and image.shape[2] == 1
): # greyscale
color = False
else:
raise Exception("Image must have H x W x 3, H x W x 1 or H x W dimensions.")
file.write("PF\n" if color else "Pf\n".encode())
file.write("%d %d\n".encode() % (image.shape[1], image.shape[0]))
endian = image.dtype.byteorder
if endian == "<" or endian == "=" and sys.byteorder == "little":
scale = -scale
file.write("%f\n".encode() % scale)
image.tofile(file)
def depth_read_kitti(filename):
"""
:type filename: object
"""
depth_png = np.array(Image.open(filename), dtype=int)
depth = depth_png.astype(np.float) / 256.
depth[depth_png == 0] = -1.
return depth
def depth_read_sintel(filename):
""" Read depth data from file, return as numpy array. """
f = open(filename, 'rb')
_ = np.fromfile(f, dtype=np.float32, count=1)[0]
width = np.fromfile(f, dtype=np.int32, count=1)[0]
height = np.fromfile(f, dtype=np.int32, count=1)[0]
depth = np.fromfile(f, dtype=np.float32, count=-1).reshape((height, width))
return depth
class BadPixelMetric:
""" BadPixelMetric. """
def __init__(self, threshold=1.25, depth_cap=10, model='NYU'):
self.__threshold = threshold
self.__depth_cap = depth_cap
self.__model = model
def compute_scale_and_shift(self, prediction, target, mask):
""" compute_scale_and_shift. """
a_00 = np.sum(mask * prediction * prediction, (1, 2))
a_01 = np.sum(mask * prediction, (1, 2))
a_11 = np.sum(mask, (1, 2))
b_0 = np.sum(mask * prediction * target, (1, 2))
b_1 = np.sum(mask * target, (1, 2))
x_0 = np.zeros_like(b_0)
x_1 = np.zeros_like(b_1)
det = a_00 * a_11 - a_01 * a_01
valid = det > 0
x_0[valid] = (a_11[valid] * b_0[valid] - a_01[valid] * b_1[valid]) / det[valid]
x_1[valid] = (-a_01[valid] * b_0[valid] + a_00[valid] * b_1[valid]) / det[valid]
return x_0, x_1
def __call__(self, prediction, target, mask):
# transform predicted disparity to aligned depth
target_disparity = np.zeros_like(target)
target_disparity[mask == 1] = 1.0 / target[mask == 1]
scale, shift = self.compute_scale_and_shift(prediction, target_disparity, mask)
prediction_aligned = scale.reshape((-1, 1, 1)) * prediction + shift.reshape((-1, 1, 1))
disparity_cap = 1.0 / self.__depth_cap
prediction_aligned[prediction_aligned < disparity_cap] = disparity_cap
prediciton_depth = 1.0 / prediction_aligned
# bad pixel
err = np.zeros_like(prediciton_depth, dtype=np.float)
if self.__model == 'NYU' or self.__model == 'TUM' or self.__model == 'KITTI':
err[mask == 1] = np.maximum(
prediciton_depth[mask == 1] / target[mask == 1],
target[mask == 1] / prediciton_depth[mask == 1],
)
err[mask == 1] = (err[mask == 1] > self.__threshold)
p = np.sum(err, (1, 2)) / np.sum(mask, (1, 2))
if self.__model == 'Sintel' or self.__model == 'ETH3D':
err[mask == 1] = np.abs((prediciton_depth[mask == 1] - target[mask == 1]) / target[mask == 1])
err_sum = np.sum(err, (1, 2))
mask_sum = np.sum(mask, (1, 2))
print('err_sum is ', err_sum)
print('mask_sum is ', mask_sum)
if mask_sum == 0:
p = np.zeros(1)
else:
p = err_sum / mask_sum
return np.mean(p)
return 100 * np.mean(p)
| 30.70202 | 106 | 0.576082 |
1dff43116c71f64c4eb3ee0f3a5aecd11539dd4e
| 10,138 |
py
|
Python
|
source/pkgsrc/lang/python37/patches/patch-Lib_test_test__posix.py
|
Scottx86-64/dotfiles-1
|
51004b1e2b032664cce6b553d2052757c286087d
|
[
"Unlicense"
] | 1 |
2021-11-20T22:46:39.000Z
|
2021-11-20T22:46:39.000Z
|
source/pkgsrc/lang/python37/patches/patch-Lib_test_test__posix.py
|
Scottx86-64/dotfiles-1
|
51004b1e2b032664cce6b553d2052757c286087d
|
[
"Unlicense"
] | null | null | null |
source/pkgsrc/lang/python37/patches/patch-Lib_test_test__posix.py
|
Scottx86-64/dotfiles-1
|
51004b1e2b032664cce6b553d2052757c286087d
|
[
"Unlicense"
] | null | null | null |
$NetBSD: patch-Lib_test_test__posix.py,v 1.1 2020/11/17 19:33:26 sjmulder Exp $
Support for macOS 11 and Apple Silicon (ARM). Mostly backported from:
https://github.com/python/cpython/pull/22855
--- Lib/test/test_posix.py.orig 2020-08-15 05:20:16.000000000 +0000
+++ Lib/test/test_posix.py
@@ -1502,9 +1502,239 @@ class PosixGroupsTester(unittest.TestCas
posix.setgroups(groups)
self.assertListEqual(groups, posix.getgroups())
[email protected](sys.platform == "darwin", "test weak linking on macOS")
+class TestPosixWeaklinking(unittest.TestCase):
+ # These test cases verify that weak linking support on macOS works
+ # as expected. These cases only test new behaviour introduced by weak linking,
+ # regular behaviour is tested by the normal test cases.
+ #
+ # See the section on Weak Linking in Mac/README.txt for more information.
+ def setUp(self):
+ import sysconfig
+ import platform
+
+ config_vars = sysconfig.get_config_vars()
+ self.available = { nm for nm in config_vars if nm.startswith("HAVE_") and config_vars[nm] }
+ self.mac_ver = tuple(int(part) for part in platform.mac_ver()[0].split("."))
+
+ def _verify_available(self, name):
+ if name not in self.available:
+ raise unittest.SkipTest(f"{name} not weak-linked")
+
+ def test_pwritev(self):
+ self._verify_available("HAVE_PWRITEV")
+ if self.mac_ver >= (10, 16):
+ self.assertTrue(hasattr(os, "pwritev"), "os.pwritev is not available")
+ self.assertTrue(hasattr(os, "preadv"), "os.readv is not available")
+
+ else:
+ self.assertFalse(hasattr(os, "pwritev"), "os.pwritev is available")
+ self.assertFalse(hasattr(os, "preadv"), "os.readv is available")
+
+ def test_stat(self):
+ self._verify_available("HAVE_FSTATAT")
+ if self.mac_ver >= (10, 10):
+ self.assertIn("HAVE_FSTATAT", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_FSTATAT", posix._have_functions)
+
+ with self.assertRaisesRegex(NotImplementedError, "dir_fd unavailable"):
+ os.stat("file", dir_fd=0)
+
+ def test_access(self):
+ self._verify_available("HAVE_FACCESSAT")
+ if self.mac_ver >= (10, 10):
+ self.assertIn("HAVE_FACCESSAT", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_FACCESSAT", posix._have_functions)
+
+ with self.assertRaisesRegex(NotImplementedError, "dir_fd unavailable"):
+ os.access("file", os.R_OK, dir_fd=0)
+
+ with self.assertRaisesRegex(NotImplementedError, "follow_symlinks unavailable"):
+ os.access("file", os.R_OK, follow_symlinks=False)
+
+ with self.assertRaisesRegex(NotImplementedError, "effective_ids unavailable"):
+ os.access("file", os.R_OK, effective_ids=True)
+
+ def test_chmod(self):
+ self._verify_available("HAVE_FCHMODAT")
+ if self.mac_ver >= (10, 10):
+ self.assertIn("HAVE_FCHMODAT", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_FCHMODAT", posix._have_functions)
+ self.assertIn("HAVE_LCHMOD", posix._have_functions)
+
+ with self.assertRaisesRegex(NotImplementedError, "dir_fd unavailable"):
+ os.chmod("file", 0o644, dir_fd=0)
+
+ def test_chown(self):
+ self._verify_available("HAVE_FCHOWNAT")
+ if self.mac_ver >= (10, 10):
+ self.assertIn("HAVE_FCHOWNAT", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_FCHOWNAT", posix._have_functions)
+ self.assertIn("HAVE_LCHOWN", posix._have_functions)
+
+ with self.assertRaisesRegex(NotImplementedError, "dir_fd unavailable"):
+ os.chown("file", 0, 0, dir_fd=0)
+
+ def test_link(self):
+ self._verify_available("HAVE_LINKAT")
+ if self.mac_ver >= (10, 10):
+ self.assertIn("HAVE_LINKAT", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_LINKAT", posix._have_functions)
+
+ with self.assertRaisesRegex(NotImplementedError, "src_dir_fd unavailable"):
+ os.link("source", "target", src_dir_fd=0)
+
+ with self.assertRaisesRegex(NotImplementedError, "dst_dir_fd unavailable"):
+ os.link("source", "target", dst_dir_fd=0)
+
+ with self.assertRaisesRegex(NotImplementedError, "src_dir_fd unavailable"):
+ os.link("source", "target", src_dir_fd=0, dst_dir_fd=0)
+
+ # issue 41355: !HAVE_LINKAT code path ignores the follow_symlinks flag
+ with os_helper.temp_dir() as base_path:
+ link_path = os.path.join(base_path, "link")
+ target_path = os.path.join(base_path, "target")
+ source_path = os.path.join(base_path, "source")
+
+ with open(source_path, "w") as fp:
+ fp.write("data")
+
+ os.symlink("target", link_path)
+
+ # Calling os.link should fail in the link(2) call, and
+ # should not reject *follow_symlinks* (to match the
+ # behaviour you'd get when building on a platform without
+ # linkat)
+ with self.assertRaises(FileExistsError):
+ os.link(source_path, link_path, follow_symlinks=True)
+
+ with self.assertRaises(FileExistsError):
+ os.link(source_path, link_path, follow_symlinks=False)
+
+
+ def test_listdir_scandir(self):
+ self._verify_available("HAVE_FDOPENDIR")
+ if self.mac_ver >= (10, 10):
+ self.assertIn("HAVE_FDOPENDIR", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_FDOPENDIR", posix._have_functions)
+
+ with self.assertRaisesRegex(TypeError, "listdir: path should be string, bytes, os.PathLike or None, not int"):
+ os.listdir(0)
+
+ with self.assertRaisesRegex(TypeError, "scandir: path should be string, bytes, os.PathLike or None, not int"):
+ os.scandir(0)
+
+ def test_mkdir(self):
+ self._verify_available("HAVE_MKDIRAT")
+ if self.mac_ver >= (10, 10):
+ self.assertIn("HAVE_MKDIRAT", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_MKDIRAT", posix._have_functions)
+
+ with self.assertRaisesRegex(NotImplementedError, "dir_fd unavailable"):
+ os.mkdir("dir", dir_fd=0)
+
+ def test_rename_replace(self):
+ self._verify_available("HAVE_RENAMEAT")
+ if self.mac_ver >= (10, 10):
+ self.assertIn("HAVE_RENAMEAT", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_RENAMEAT", posix._have_functions)
+
+ with self.assertRaisesRegex(NotImplementedError, "src_dir_fd and dst_dir_fd unavailable"):
+ os.rename("a", "b", src_dir_fd=0)
+
+ with self.assertRaisesRegex(NotImplementedError, "src_dir_fd and dst_dir_fd unavailable"):
+ os.rename("a", "b", dst_dir_fd=0)
+
+ with self.assertRaisesRegex(NotImplementedError, "src_dir_fd and dst_dir_fd unavailable"):
+ os.replace("a", "b", src_dir_fd=0)
+
+ with self.assertRaisesRegex(NotImplementedError, "src_dir_fd and dst_dir_fd unavailable"):
+ os.replace("a", "b", dst_dir_fd=0)
+
+ def test_unlink_rmdir(self):
+ self._verify_available("HAVE_UNLINKAT")
+ if self.mac_ver >= (10, 10):
+ self.assertIn("HAVE_UNLINKAT", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_UNLINKAT", posix._have_functions)
+
+ with self.assertRaisesRegex(NotImplementedError, "dir_fd unavailable"):
+ os.unlink("path", dir_fd=0)
+
+ with self.assertRaisesRegex(NotImplementedError, "dir_fd unavailable"):
+ os.rmdir("path", dir_fd=0)
+
+ def test_open(self):
+ self._verify_available("HAVE_OPENAT")
+ if self.mac_ver >= (10, 10):
+ self.assertIn("HAVE_OPENAT", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_OPENAT", posix._have_functions)
+
+ with self.assertRaisesRegex(NotImplementedError, "dir_fd unavailable"):
+ os.open("path", os.O_RDONLY, dir_fd=0)
+
+ def test_readlink(self):
+ self._verify_available("HAVE_READLINKAT")
+ if self.mac_ver >= (10, 10):
+ self.assertIn("HAVE_READLINKAT", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_READLINKAT", posix._have_functions)
+
+ with self.assertRaisesRegex(NotImplementedError, "dir_fd unavailable"):
+ os.readlink("path", dir_fd=0)
+
+ def test_symlink(self):
+ self._verify_available("HAVE_SYMLINKAT")
+ if self.mac_ver >= (10, 10):
+ self.assertIn("HAVE_SYMLINKAT", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_SYMLINKAT", posix._have_functions)
+
+ with self.assertRaisesRegex(NotImplementedError, "dir_fd unavailable"):
+ os.symlink("a", "b", dir_fd=0)
+
+ def test_utime(self):
+ self._verify_available("HAVE_FUTIMENS")
+ self._verify_available("HAVE_UTIMENSAT")
+ if self.mac_ver >= (10, 13):
+ self.assertIn("HAVE_FUTIMENS", posix._have_functions)
+ self.assertIn("HAVE_UTIMENSAT", posix._have_functions)
+
+ else:
+ self.assertNotIn("HAVE_FUTIMENS", posix._have_functions)
+ self.assertNotIn("HAVE_UTIMENSAT", posix._have_functions)
+
+ with self.assertRaisesRegex(NotImplementedError, "dir_fd unavailable"):
+ os.utime("path", dir_fd=0)
+
def test_main():
try:
- support.run_unittest(PosixTester, PosixGroupsTester)
+ support.run_unittest(
+ PosixTester,
+ PosixGroupsTester,
+ TestPosixWeaklinking
+ )
finally:
support.reap_children()
| 40.714859 | 123 | 0.620043 |
384a3eaed8eee9fb82703b0ca9675bf087bbd48c
| 4,308 |
py
|
Python
|
Session09_AWSSagemakerAndLargeScaleModelTraining/CIFAR100Classifier.py
|
garima-mahato/TSAI_EMLO1.0
|
f1478572a20988296831e70d6cf1dac9b36e7573
|
[
"Apache-2.0"
] | null | null | null |
Session09_AWSSagemakerAndLargeScaleModelTraining/CIFAR100Classifier.py
|
garima-mahato/TSAI_EMLO1.0
|
f1478572a20988296831e70d6cf1dac9b36e7573
|
[
"Apache-2.0"
] | null | null | null |
Session09_AWSSagemakerAndLargeScaleModelTraining/CIFAR100Classifier.py
|
garima-mahato/TSAI_EMLO1.0
|
f1478572a20988296831e70d6cf1dac9b36e7573
|
[
"Apache-2.0"
] | null | null | null |
import os
import math
import random
import numpy
import torch
import torch.nn as nn
from torch.nn import functional as F
from torch.utils.data import DataLoader
from torch.utils.data.sampler import SubsetRandomSampler
from torchvision import transforms as T, datasets, models
import pytorch_lightning as pl
def accuracy(outputs, labels):
_, preds = torch.max(outputs, dim=1)
return torch.tensor(torch.sum(preds == labels).item() / len(preds))
class CIFAR100Classifier(pl.LightningModule):
def __init__(self, data_dir, batch_size=128, num_workers=4, num_classes=100, pretrained=True):
super().__init__()
# Set up class attributes
self.batch_size = batch_size
self.data_dir = data_dir
self.num_workers = num_workers
self.num_classes = num_classes
## Model
# Use pretrained Resnet34 models
self.network = models.resnet34(pretrained=pretrained)
# Replace last layer
self.network.fc = nn.Linear(self.network.fc.in_features, self.num_classes)
def forward(self, x):
return self.network(x)
def prepare_data(self):
means, stds = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]
transforms = {'train': T.Compose([T.ToTensor(), T.Normalize(means, stds, inplace=True)]), 'valid': T.Compose([T.ToTensor(), T.Normalize(means, stds, inplace=True)]), 'test': T.Compose([T.ToTensor(), T.Normalize(means, stds, inplace=True)])}
dataset = {}
dataset['train'] = datasets.CIFAR100(root=f'{self.data_dir}/cifar100_dataset/train', train=True, download=True, transform=transforms['train'])
dataset['valid'] = datasets.CIFAR100(root=f'{self.data_dir}/cifar100_dataset/valid', train=False, download=True, transform=transforms['valid'])
#datasets.ImageFolder(self.datadir+f'/{key.upper()}', transform=transforms[key])
dataloader = {}
for key in ['train','valid']:
if key == 'train':
dataloader[key] = DataLoader(dataset[key], self.batch_size, shuffle=True)
else:
dataloader[key] = DataLoader(dataset[key], self.batch_size)
self.train_loader, self.val_loader = dataloader['train'], dataloader['valid']
#return dataloader['train'], dataloader['valid'], dataloader['test']
def train_dataloader(self):
'''
Returns:
(torch.utils.data.DataLoader): Training set data loader
'''
return self.train_loader
def val_dataloader(self):
'''
Returns:
(torch.utils.data.DataLoader): Validation set data loader
'''
return self.val_loader
def configure_optimizers(self):
return torch.optim.Adam(self.parameters())
def training_step(self, batch, batch_idx):
# Get inputs and output from batch
x, labels = batch
# Compute prediction through the network
prediction = self.forward(x)
loss = F.cross_entropy(prediction, labels)
## Log training loss
#logs = {'train_loss': loss.item()}
output = {
'loss': loss,
'train_loss': loss.item()
}
return output
def validation_step(self, batch, batch_idx):
x, labels = batch
prediction = self.forward(x) # Generate predictions
loss = F.cross_entropy(prediction, labels) # Calculate loss
acc = accuracy(prediction, labels) # Calculate accuracy
return {'val_loss': loss.detach(), 'val_acc': acc}
def validation_epoch_end(self, outputs):
batch_losses = [x['val_loss'] for x in outputs]
epoch_loss = torch.stack(batch_losses).mean() # Combine losses
batch_accs = [x['val_acc'] for x in outputs]
epoch_acc = torch.stack(batch_accs).mean() # Combine accuracies
return {'val_loss': epoch_loss.item(), 'val_acc': epoch_acc.item()}
def epoch_end(self, epoch, result):
print("Epoch [{}],{} train_loss: {:.4f}, val_loss: {:.4f}, val_acc: {:.4f}".format(
epoch, "last_lr: {:.5f},".format(result['lrs'][-1]) if 'lrs' in result else '',
result['train_loss'], result['val_loss'], result['val_acc']))
| 39.522936 | 248 | 0.620241 |
2da6286c59a2654a43f2341b8cbab89645c02985
| 1,874 |
py
|
Python
|
Co-Simulation/Sumo/sumo-1.7.0/docs/tutorial/quickstart/runner.py
|
uruzahe/carla
|
940c2ab23cce1eda1ef66de35f66b42d40865fb1
|
[
"MIT"
] | null | null | null |
Co-Simulation/Sumo/sumo-1.7.0/docs/tutorial/quickstart/runner.py
|
uruzahe/carla
|
940c2ab23cce1eda1ef66de35f66b42d40865fb1
|
[
"MIT"
] | null | null | null |
Co-Simulation/Sumo/sumo-1.7.0/docs/tutorial/quickstart/runner.py
|
uruzahe/carla
|
940c2ab23cce1eda1ef66de35f66b42d40865fb1
|
[
"MIT"
] | null | null | null |
#!/usr/bin/env python
# Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
# Copyright (C) 2008-2020 German Aerospace Center (DLR) and others.
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License 2.0 which is available at
# https://www.eclipse.org/legal/epl-2.0/
# This Source Code may also be made available under the following Secondary
# Licenses when the conditions for such availability set forth in the Eclipse
# Public License 2.0 are satisfied: GNU General Public License, version 2
# or later which is available at
# https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# @file runner.py
# @author Daniel Krajzewicz
# @author Michael Behrisch
# @date 2011-09-25
from __future__ import absolute_import
from __future__ import print_function
import os
import subprocess
import sys
import shutil
sys.path.append(
os.path.join(os.path.dirname(__file__), '..', '..', '..', '..', "tools"))
sys.path.append(os.path.join(os.environ.get("SUMO_HOME", os.path.join(
os.path.dirname(__file__), "..", "..", "..")), "tools"))
from sumolib import checkBinary # noqa
netconvertBinary = checkBinary('netconvert')
sumoBinary = checkBinary('sumo')
# build/check network
retcode = subprocess.call(
[netconvertBinary, "-c", "data/quickstart.netccfg"], stdout=sys.stdout, stderr=sys.stderr)
try:
shutil.copy("data/quickstart.net.xml", "net.net.xml")
except IOError:
print("Missing 'quickstart.net.xml'")
print(">> Netbuilding closed with status %s" % retcode)
sys.stdout.flush()
# run simulation
retcode = subprocess.call(
[sumoBinary, "-c", "data/quickstart.sumocfg", "--no-step-log"], stdout=sys.stdout, stderr=sys.stderr)
print(">> Simulation closed with status %s" % retcode)
sys.stdout.flush()
| 37.48 | 105 | 0.731057 |
2dbae5edb8a4b121491015707f99aafed1ef500a
| 198 |
py
|
Python
|
nz_django/day7/middle_ware_demo/front/models.py
|
gaohj/nzflask_bbs
|
36a94c380b78241ed5d1e07edab9618c3e8d477b
|
[
"Apache-2.0"
] | null | null | null |
nz_django/day7/middle_ware_demo/front/models.py
|
gaohj/nzflask_bbs
|
36a94c380b78241ed5d1e07edab9618c3e8d477b
|
[
"Apache-2.0"
] | 27 |
2020-02-12T07:55:58.000Z
|
2022-03-12T00:19:09.000Z
|
nz_django/day7/middle_ware_demo/front/models.py
|
gaohj/nzflask_bbs
|
36a94c380b78241ed5d1e07edab9618c3e8d477b
|
[
"Apache-2.0"
] | 2 |
2020-02-18T01:54:55.000Z
|
2020-02-21T11:36:28.000Z
|
from django.db import models
class User(models.Model):
telephone = models.CharField(max_length=11)
password = models.CharField(max_length=50)
username = models.CharField(max_length=50)
| 28.285714 | 47 | 0.757576 |
35707622aa43bdf303238809cc191637a145ceca
| 4,056 |
py
|
Python
|
chord_rec/models/seq2seq/Seq2Seq.py
|
TianxueHu/ChordSymbolRec
|
d64a5be4f4914e6f682cb6d4079d7ba8a6fc2eac
|
[
"Unlicense",
"MIT"
] | null | null | null |
chord_rec/models/seq2seq/Seq2Seq.py
|
TianxueHu/ChordSymbolRec
|
d64a5be4f4914e6f682cb6d4079d7ba8a6fc2eac
|
[
"Unlicense",
"MIT"
] | null | null | null |
chord_rec/models/seq2seq/Seq2Seq.py
|
TianxueHu/ChordSymbolRec
|
d64a5be4f4914e6f682cb6d4079d7ba8a6fc2eac
|
[
"Unlicense",
"MIT"
] | null | null | null |
import random
import torch
import torch.nn as nn
import torch.optim as optim
class BaseSeq2Seq(nn.Module):
""" The Sequence to Sequence model. """
def __init__(self, encoder, decoder, device):
super().__init__()
self.device = device
self.encoder = encoder.to(device)
self.decoder = decoder.to(device)
assert self.encoder.encoder_hidden_size == self.decoder.decoder_hidden_size, \
"Hidden dimensions of encoder and decoder must be equal!"
assert self.encoder.n_layers == self.decoder.n_layers, \
"Encoder and decoder must have equal number of layers!"
def forward(self, source, target, out_seq_len = None, teacher_forcing = True, start_idx = None):
""" The forward pass of the Seq2Seq model.
Args:
source (tensor): sequences in source language of shape (batch_size, seq_len, input_size)
out_seq_len (int): the maximum length of the output sequence. If None, the length is determined by the input sequences.
"""
batch_size = source.shape[0]
if out_seq_len is None:
seq_len = source.shape[1]
if start_idx is None:
start_idx = 0
outputs = torch.full((batch_size, seq_len, self.decoder.output_size), start_idx, dtype = torch.float).to(self.device) # problem???
# outputs = torch.zeros(batch_size, seq_len, self.decoder.output_size).to(self.device)
encoder_outputs, hidden = self.encoder(source)
# first input to the decoder is the <sos> token
input = target[:,0].unsqueeze(1)
# input = source[:,0]
for t in range(1, seq_len):
output, hidden = self.decoder(input, hidden)
outputs[:,t,:] = output
# input = output.max(1)[1].unsqueeze(1)
if teacher_forcing:
input = target[:,t].unsqueeze(1)
else:
input = output.max(1)[1].unsqueeze(1)
# print(outputs)
return outputs
class AttnSeq2Seq(nn.Module):
""" The Sequence to Sequence model. """
def __init__(self, encoder, decoder, device):
super().__init__()
self.device = device
self.encoder = encoder.to(device)
self.decoder = decoder.to(device)
assert self.encoder.encoder_hidden_size == self.decoder.decoder_hidden_size, \
"Hidden dimensions of encoder and decoder must be equal!"
assert self.encoder.n_layers == self.decoder.n_layers, \
"Encoder and decoder must have equal number of layers!"
def forward(self, source, target, out_seq_len = None, teacher_forcing = True, start_idx = None):
""" The forward pass of the Seq2Seq model.
Args:
source (tensor): sequences in source language of shape (batch_size, seq_len, input_size)
out_seq_len (int): the maximum length of the output sequence. If None, the length is determined by the input sequences.
"""
batch_size = source.shape[0]
if out_seq_len is None:
seq_len = source.shape[1]
if start_idx is None:
start_idx = 0
outputs = torch.full((batch_size, seq_len, self.decoder.output_size), start_idx, dtype = torch.float).to(self.device) # problem???
# outputs = torch.zeros(batch_size, seq_len, self.decoder.output_size).to(self.device)
encoder_outputs, hidden = self.encoder(source)
# first input to the decoder is the <sos> token
input = target[:,0].unsqueeze(1)
# input = source[:,0]
for t in range(1, seq_len):
output, hidden, attn= self.decoder(input, hidden, encoder_outputs)
outputs[:,t,:] = output
# input = output.max(1)[1].unsqueeze(1)
if teacher_forcing:
input = target[:,t].unsqueeze(1)
else:
input = output.max(1)[1].unsqueeze(1)
# print(outputs)
return outputs
| 36.872727 | 138 | 0.605523 |
105412c0423945d83d12f7bfed4193828ea34730
| 1,677 |
py
|
Python
|
IVTa/2014/EGOROV_V_I/task_10_8.py
|
YukkaSarasti/pythonintask
|
eadf4245abb65f4400a3bae30a4256b4658e009c
|
[
"Apache-2.0"
] | null | null | null |
IVTa/2014/EGOROV_V_I/task_10_8.py
|
YukkaSarasti/pythonintask
|
eadf4245abb65f4400a3bae30a4256b4658e009c
|
[
"Apache-2.0"
] | null | null | null |
IVTa/2014/EGOROV_V_I/task_10_8.py
|
YukkaSarasti/pythonintask
|
eadf4245abb65f4400a3bae30a4256b4658e009c
|
[
"Apache-2.0"
] | null | null | null |
# Задача 10. Вариант 8
'''
Напишите программу "Генератор персонажей" для игры.
Пользователю должно быть предоставлено 30 пунктов,
которые можно распределить между четырьмя характеристиками:
Сила, Здоровье, Мудрость и Ловкость.
Надо сделать так, чтобы пользователь мог не только брать
эти пункты из общего "пула", но и возвращать их туда
из характеристик, которым он решил присвоить другие значения.
'''
# Egorov V. I.
# 07.04.2016
from operator import add, sub
ch = {'power' : 5,
'health' : 5,
'knowledge' : 5,
'agility' : 5}
point = 10
def info(ch):
print( '\nСила:\t\t', ch['power'],
'\nЗдоровье:\t', ch['health'],
'\nМудрость:\t', ch['knowledge'],
'\nЛовкость:\t', ch['agility'],
'\nОсталось очков: ', point)
info(ch)
while True:
aa = input('> ').lower().split()
if len(aa) != 2:
print('Неправильная команда')
continue
shoose1, shoose2 = None, 0
if aa[0] == 'сила':
shoose1 = 'power'
elif aa[0] == 'здоровье':
shoose1 = 'health'
elif aa[0] == 'мудрость':
shoose1 = 'knowledge'
elif aa[0] == 'ловкость':
shoose1 = 'agility'
else:
print('Неизвестная команда:', aa[0])
continue
try:
shoose2 = int(aa[1])
except:
print('Неизвестное число:', aa[1])
continue
while True:
abil = ch[shoose1]
value = shoose2
if abil < 2 and value < 1:
print('Достигнуто минимальное значение характеристики')
elif (abil + value) < 1:
print('Недопустимое значение характеристики')
elif (point - value) < 0:
print('Не хватает очков')
else:
dif = abil + value
point += abil - dif
ch[shoose1] = dif
break
info(ch)
input('Нажмите ENTER...')
| 20.45122 | 61 | 0.628503 |
106cc8e093db25fa4d34d1670d65780759b88903
| 1,579 |
py
|
Python
|
roboraptorz/client/mqttApp/testRoboDriver.py
|
icebear8/roboRinth
|
c0789a9faf978f31b0ed020d26fee2b04fb298ee
|
[
"MIT"
] | null | null | null |
roboraptorz/client/mqttApp/testRoboDriver.py
|
icebear8/roboRinth
|
c0789a9faf978f31b0ed020d26fee2b04fb298ee
|
[
"MIT"
] | null | null | null |
roboraptorz/client/mqttApp/testRoboDriver.py
|
icebear8/roboRinth
|
c0789a9faf978f31b0ed020d26fee2b04fb298ee
|
[
"MIT"
] | 1 |
2019-10-22T07:47:51.000Z
|
2019-10-22T07:47:51.000Z
|
#!/usr/bin/env python
import logging
import time
from RoboDriver import RoboDriver
from MqttClient import MqttClient
logger = logging.getLogger(__name__)
client = None
def _initializeLogging(loglevel):
numeric_level = getattr(logging, loglevel.upper(), None)
if not isinstance(numeric_level, int):
numeric_level = getattr(logging, DEBUG, None)
logging.basicConfig(format='%(asctime)s %(levelname)s:%(name)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S', level=numeric_level)
logging.Formatter.converter = time.gmtime
def onStatusMock(status):
logger.debug("Status notification: "+str(status))
def onColorsMock(dirDict):
logger.debug("Direction notification: "+str(dirDict))
def main():
# print(myRoboDriver.getMqttHandlerList())
print("Hallo")
host = "192.168.0.200"
port = 1883
loglevel = "DEBUG"
clientId = None
_initializeLogging(loglevel)
logger.debug("Main started")
# Setup mqtt client
client = MqttClient(host, port, clientId)
client.startAsync()
time.sleep(2)
# setup RoboDriver
myRoboDriver = RoboDriver("roboraptorz")
myRoboDriver.onStatus = onStatusMock
myRoboDriver.onColors = onColorsMock
client.subscribeTopics("roboraptorz/notification/#")
client.addMessageHandler(myRoboDriver.getMqttHandlerList())
myRoboDriver.setMqttClient(client)
# myRoboDriver.driveDirection()
# print("DriveDirection sent")
input("\n\nPress Enter to abort...\n\n")
# Terminate
client.stop()
logger.debug("Terminate")
if __name__ == '__main__':
main()
| 23.924242 | 129 | 0.708043 |
eaec04c28b335317f1142550ab9e84932d803567
| 4,513 |
py
|
Python
|
hihope_neptune-oh_hid/00_src/v0.1/third_party/LVM2/daemons/lvmdbusd/request.py
|
dawmlight/vendor_oh_fun
|
bc9fb50920f06cd4c27399f60076f5793043c77d
|
[
"Apache-2.0"
] | 1 |
2022-02-15T08:51:55.000Z
|
2022-02-15T08:51:55.000Z
|
hihope_neptune-oh_hid/00_src/v0.3/third_party/LVM2/daemons/lvmdbusd/request.py
|
dawmlight/vendor_oh_fun
|
bc9fb50920f06cd4c27399f60076f5793043c77d
|
[
"Apache-2.0"
] | null | null | null |
hihope_neptune-oh_hid/00_src/v0.3/third_party/LVM2/daemons/lvmdbusd/request.py
|
dawmlight/vendor_oh_fun
|
bc9fb50920f06cd4c27399f60076f5793043c77d
|
[
"Apache-2.0"
] | null | null | null |
# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions
# of the GNU General Public License v.2.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import threading
# noinspection PyUnresolvedReferences
from gi.repository import GLib
from .job import Job
from . import cfg
import traceback
from .utils import log_error, mt_async_call
class RequestEntry(object):
def __init__(self, tmo, method, arguments, cb, cb_error,
return_tuple=True, job_state=None):
self.method = method
self.arguments = arguments
self.cb = cb
self.cb_error = cb_error
self.timer_id = -1
self.lock = threading.RLock()
self.done = False
self._result = None
self._job = None
self._rc = 0
self._rc_error = None
self._return_tuple = return_tuple
self._job_state = job_state
if tmo < 0:
# Client is willing to block forever
pass
elif tmo == 0:
self._return_job()
else:
# Note: using 990 instead of 1000 for second to ms conversion to
# account for overhead. Goal is to return just before the
# timeout amount has expired. Better to be a little early than
# late.
self.timer_id = GLib.timeout_add(
tmo * 990, RequestEntry._request_timeout, self)
@staticmethod
def _request_timeout(r):
"""
Method which gets called when the timer runs out!
:param r: RequestEntry which timed out
:return: Result of timer_expired
"""
return r.timer_expired()
def _return_job(self):
# Return job is only called when we create a request object or when
# we pop a timer. In both cases we are running in the correct context
# and do not need to schedule the call back in main context.
self._job = Job(self, self._job_state)
cfg.om.register_object(self._job, True)
if self._return_tuple:
self.cb(('/', self._job.dbus_object_path()))
else:
self.cb(self._job.dbus_object_path())
def run_cmd(self):
try:
result = self.method(*self.arguments)
self.register_result(result)
except Exception as e:
# Use the request entry to return the result as the client may
# have gotten a job by the time we hit an error
# Lets get the stacktrace and set that to the error message
st = traceback.format_exc()
cfg.blackbox.dump()
log_error("Exception returned to client: \n%s" % st)
self.register_error(-1, str(e), e)
def is_done(self):
with self.lock:
rc = self.done
return rc
def get_errors(self):
with self.lock:
return (self._rc, self._rc_error)
def result(self):
with self.lock:
if self.done:
return self._result
return '/'
def _reg_ending(self, result, error_rc=0, error_msg=None,
error_exception=None):
with self.lock:
self.done = True
if self.timer_id != -1:
# Try to prevent the timer from firing
GLib.source_remove(self.timer_id)
self._result = result
self._rc = error_rc
self._rc_error = error_msg
if not self._job:
# We finished and there is no job, so return result or error
# now!
# Note: If we don't have a valid cb or cbe, this indicates a
# request that doesn't need a response as we already returned
# one before the request was processed.
if error_rc == 0:
if self.cb:
if self._return_tuple:
mt_async_call(self.cb, (result, '/'))
else:
mt_async_call(self.cb, result)
else:
if self.cb_error:
if not error_exception:
if not error_msg:
error_exception = Exception(
"An error occurred, but no reason was "
"given, see service logs!")
else:
error_exception = Exception(error_msg)
mt_async_call(self.cb_error, error_exception)
else:
# We have a job and it's complete, indicate that it's done.
self._job.Complete = True
self._job = None
def register_error(self, error_rc, error_message, error_exception):
self._reg_ending('/', error_rc, error_message, error_exception)
def register_result(self, result):
self._reg_ending(result)
def timer_expired(self):
with self.lock:
# Set the timer back to -1 as we will get a warning if we try
# to remove a timer that doesn't exist
self.timer_id = -1
if not self.done:
# Create dbus job object and return path to caller
self._return_job()
else:
# The job is done, we have nothing to do
pass
return False
| 28.745223 | 72 | 0.696433 |
dcbbd16af6f8f1b4fa8e7b8638207106a8560e05
| 1,240 |
py
|
Python
|
essensplan/customFunctions.py
|
jkopka/Essensplan
|
a7abb2f1c4892f89aa19b002dd334cdd619fb43a
|
[
"MIT"
] | null | null | null |
essensplan/customFunctions.py
|
jkopka/Essensplan
|
a7abb2f1c4892f89aa19b002dd334cdd619fb43a
|
[
"MIT"
] | null | null | null |
essensplan/customFunctions.py
|
jkopka/Essensplan
|
a7abb2f1c4892f89aa19b002dd334cdd619fb43a
|
[
"MIT"
] | null | null | null |
from datetime import date
from datetime import time
from datetime import datetime
from datetime import timedelta
def getMonday(choosenDate):
"""
getMonday() gibt das Datum des letzten Montag des gegebenen Datum zurück
"""
choosenDate
today = choosenDate.weekday()
dateMonday = choosenDate-timedelta(days=today)
return dateMonday
def addTodoListToWunderlist(todo_string:str):
# Fügt eine Todo der Liste "wochenplan" hinzu
import requests
import json
access_token = 'bafaf35af71f62ee44b6f9a1d8f9079f236e982d9d310ee89d75ff04d2cd'
client_id = '41e835d6b9c4a9c911d7'
list_id = '396960287'
headers={'X-Access-Token': access_token, 'X-Client-ID': client_id, 'Content-Type' : 'application/json'}
todo = {
"list_id": 396960287,
"title": todo_string,
"assignee_id": 123,
"completed": False,
"starred": False
}
data_json = json.dumps(todo)
# print(data_json)
# print("Querying Wunderlist...")
f = requests.post('https://a.wunderlist.com/api/v1/tasks', headers=headers, data=data_json)
# print("Done! Code: "+str(f.status_code))
j = json.loads(f.text)
# print(j)
#print(todo_string)
return f.status_code
| 29.52381 | 107 | 0.683065 |
f4aa23f109b39276b081b725e458a066217def7d
| 793 |
py
|
Python
|
backend/apps/ineedstudent/urls.py
|
n-hackert/match4healthcare
|
761248c27b49e568c545c643a72eac9a040649d7
|
[
"MIT"
] | null | null | null |
backend/apps/ineedstudent/urls.py
|
n-hackert/match4healthcare
|
761248c27b49e568c545c643a72eac9a040649d7
|
[
"MIT"
] | null | null | null |
backend/apps/ineedstudent/urls.py
|
n-hackert/match4healthcare
|
761248c27b49e568c545c643a72eac9a040649d7
|
[
"MIT"
] | null | null | null |
from django.urls import path
from . import views
from apps.iamstudent.views import student_list_view
urlpatterns = [
path('students/<countrycode>/<plz>/<int:distance>', student_list_view, name='list_by_plz'),
#path('students_testing/<countrycode>/<plz>/<int:distance>', views.student_list_view, name='student_list_view'),
path('hospitals/<countrycode>/<plz>', views.hospital_list, name='hospital_list'),
path('hospital_map', views.hospital_overview, name='hopsital_map'),
path('zustimmung', views.zustimmung, name='zustimmung'),
path('hospital_view/<str:uuid>/', views.hospital_view, name='hospital_view'),
path('hospital_dashboard', views.hospital_dashboard, name='hospital_dashboard'),
path('change_posting', views.change_posting, name='change_posting'),
]
| 49.5625 | 116 | 0.747793 |
8705afbdf336be2dc9e12ddf4f1eeb36b0785133
| 2,357 |
py
|
Python
|
research/cv/ESRGAN/src/vgg19/define.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 77 |
2021-10-15T08:32:37.000Z
|
2022-03-30T13:09:11.000Z
|
research/cv/ESRGAN/src/vgg19/define.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 3 |
2021-10-30T14:44:57.000Z
|
2022-02-14T06:57:57.000Z
|
research/cv/ESRGAN/src/vgg19/define.py
|
leelige/mindspore
|
5199e05ba3888963473f2b07da3f7bca5b9ef6dc
|
[
"Apache-2.0"
] | 24 |
2021-10-15T08:32:45.000Z
|
2022-03-24T18:45:20.000Z
|
# Copyright 2021 Huawei Technologies Co., Ltd
#
# 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.
# ============================================================================
"""Structure of VGG19"""
from mindspore import nn
from mindspore import load_checkpoint, load_param_into_net
class VGG(nn.Cell):
"""Structure of VGG19"""
def __init__(self, features):
super(VGG, self).__init__()
self.features = features
def construct(self, x):
x = self.features(x)
return x
def make_layers(mycfg, batch_norm=False):
"""make network"""
layers = []
in_channels = 3
for v in mycfg:
if v == 'M':
layers += [nn.MaxPool2d(kernel_size=2, stride=2, pad_mode='valid')]
else:
conv2d = nn.Conv2d(in_channels=in_channels, out_channels=v, kernel_size=3,
pad_mode='pad', padding=1, has_bias=True)
if batch_norm:
layers += [conv2d, nn.BatchNorm2d(num_features=v, momentum=0.9), nn.ReLU()]
else:
layers += [conv2d, nn.ReLU()]
in_channels = v
layers = layers[0:35]
return nn.SequentialCell([*layers])
cfgs = {
'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
}
def vgg19(vgg_ckpt):
"""VGG 19-layer model (configuration "19")
model pre-trained on ImageNet
"""
model = VGG(make_layers(cfgs['E']))
pretrained_state_dictms = load_checkpoint(vgg_ckpt)
load_param_into_net(model, pretrained_state_dictms)
return model
| 34.15942 | 113 | 0.593975 |
21e118bdf6784ff3e780c861140736ce6b1d6eeb
| 603 |
py
|
Python
|
Raspberry Pi Pico/Ri_Pico_Display_Test.py
|
ckuehnel/MicroPython
|
c57d0df744fe5301e755bd139b6cc56d69c442fd
|
[
"MIT"
] | 1 |
2021-03-22T18:38:43.000Z
|
2021-03-22T18:38:43.000Z
|
Raspberry Pi Pico/Ri_Pico_Display_Test.py
|
ckuehnel/MicroPython
|
c57d0df744fe5301e755bd139b6cc56d69c442fd
|
[
"MIT"
] | null | null | null |
Raspberry Pi Pico/Ri_Pico_Display_Test.py
|
ckuehnel/MicroPython
|
c57d0df744fe5301e755bd139b6cc56d69c442fd
|
[
"MIT"
] | 1 |
2021-02-06T10:07:36.000Z
|
2021-02-06T10:07:36.000Z
|
import time
import picodisplay as display
width = display.get_width()
height = display.get_height()
display_buffer = bytearray(width * height * 2) # 2-bytes per pixel (RGB565)
display.init(display_buffer)
display.set_backlight(1)
display.set_pen(0, 0, 0) # black
display.clear()
display.set_pen(100, 100, 100) # white
#display.circle(100,100,10)
#display.pixel(10,10)
#display.pixel_span(20,20,200) // wagerechte Linie
#display.rectangle(10,10,width-10,height-10)
display.text('01234567890123456789\n',10,10, 0, 2)
display.text('01234567890123456789\n',10,24, 0, 2)
display.update()
| 24.12 | 76 | 0.73466 |
21fd39e97a26098c032f5b956601539944fee179
| 7,626 |
py
|
Python
|
bildungslogin-plugin/tests/unittests/test_backend_udm_rest_api.py
|
univention/bildungslogin
|
29bebe858a5445dd5566aad594b33b9dd716eca4
|
[
"MIT"
] | null | null | null |
bildungslogin-plugin/tests/unittests/test_backend_udm_rest_api.py
|
univention/bildungslogin
|
29bebe858a5445dd5566aad594b33b9dd716eca4
|
[
"MIT"
] | null | null | null |
bildungslogin-plugin/tests/unittests/test_backend_udm_rest_api.py
|
univention/bildungslogin
|
29bebe858a5445dd5566aad594b33b9dd716eca4
|
[
"MIT"
] | null | null | null |
# -*- coding: utf-8 -*-
import copy
from unittest.mock import patch, Mock
import faker
import nest_asyncio
import pytest
from bildungslogin_plugin.backend import ConfigurationError, DbConnectionError
from bildungslogin_plugin.backend_udm_rest_api import UdmRestApiBackend
from bildungslogin_plugin.models import Class, SchoolContext, Workgroup
from bildungslogin_plugin.routes.v1.users import get_backend, set_backend
fake = faker.Faker()
# pytest event loop is already running: https://github.com/encode/starlette/issues/440
nest_asyncio.apply() # patches asyncio to allow nested use of asyncio.run and loop.run_until_complete
@pytest.fixture(scope="session")
def init_kwargs():
return lambda: {"username": fake.user_name(), "password": fake.first_name(), "url": fake.url()}
@patch("bildungslogin_plugin.backend_udm_rest_api.UDM")
def test_init_kwargs_ok(udm_mock, init_kwargs):
UdmRestApiBackend(**init_kwargs())
@patch("bildungslogin_plugin.backend_udm_rest_api.UDM")
def test_init_kwargs_missing(udm_mock, init_kwargs):
complete_kwargs = init_kwargs()
for k in complete_kwargs.keys():
kwargs = copy.deepcopy(complete_kwargs)
del kwargs[k]
with pytest.raises(ConfigurationError):
UdmRestApiBackend(**kwargs)
@pytest.mark.asyncio
@patch("bildungslogin_plugin.backend_udm_rest_api.UDM")
async def test_user_not_found(udm_mock, client):
backend = UdmRestApiBackend(
username=fake.user_name(),
password=fake.password(),
url="http://127.0.0.1/univention/udm",
)
try:
ori_backend = get_backend()
except RuntimeError:
ori_backend = None
try:
set_backend(backend)
resp = client.get(f"/v1/user/{fake.uuid4()}")
assert resp.status_code == 404
finally:
set_backend(ori_backend)
@pytest.mark.asyncio
async def test_connection_test_udm_connect():
backend = UdmRestApiBackend(
username=fake.user_name(),
password=fake.password(),
url="http://127.0.0.1/univention/udm",
)
with pytest.raises(DbConnectionError):
await backend.connection_test()
def test_intermittent_udm_rest_api_not_reachable(client):
backend = UdmRestApiBackend(
username=fake.user_name(),
password=fake.password(),
url="http://127.0.0.1/univention/udm",
)
try:
ori_backend = get_backend()
except RuntimeError:
ori_backend = None
try:
set_backend(backend)
resp = client.get(f"/v1/user/{fake.uuid4()}")
assert resp.status_code == 500
finally:
set_backend(ori_backend)
def roles_id(roles) -> str:
return "+".join(roles)
@pytest.mark.parametrize(
"roles",
(
["staff"],
["student"],
["teacher"],
["school_admin"],
["teacher", "staff"],
["student", "staff"],
),
ids=roles_id,
)
@pytest.mark.asyncio
async def test_get_school_context(fake_udm_user, roles):
school_ou = "test_school"
user = fake_udm_user(roles, [school_ou])
backend = UdmRestApiBackend(
username=fake.user_name(),
password=fake.password(),
url="http://127.0.0.1/univention/udm",
)
with patch.object(backend, "_get_object_by_name") as gobn_mock, \
patch.object(backend, "get_licenses_and_set_assignment_status") as glasas_mock, \
patch.object(backend, "get_classes") as gc_mock, \
patch.object(backend, "get_workgroups") as gw_mock:
# Prepare mocks
gobn_mock.return_value = Mock(**{"uuid": "1",
"props.name": school_ou,
"props.displayName": "Test School"})
glasas_mock.side_effect = [{Mock(**{"props.code": "1", "props.special_type": "Lehrkraft"})},
{Mock(**{"props.code": "2"})},
{Mock(**{"props.code": "3"})}]
gc_mock.return_value = [Mock(**{"uuid": "2", "props.name": f"{school_ou}-class"})]
gw_mock.return_value = [Mock(**{"uuid": "3", "props.name": f"{school_ou}-workgroup"})]
result = await backend.get_school_context(user)
# create expectation
expected_school_licenses = ["1"] if "teacher" in roles else []
expected_context = SchoolContext(
school_authority=None, # the value is not present in LDAP schema yet
school_code=school_ou,
school_identifier="4fc82b26aecb47d2868c4efbe3581732a3e7cbcc6c2efb32062c08170a05eeb8",
school_name="Test School",
roles=sorted(roles),
classes=[Class(
id="6b51d431df5d7f141cbececcf79edf3dd861c3b4069f0b11661a3eefacbba918",
name="class",
licenses=["2"],
)],
workgroups=[Workgroup(
id="3fdba35f04dc8c462986c992bcf875546257113072a909c162f7e470e581e278",
name="workgroup",
licenses=["3"],
)],
licenses=expected_school_licenses)
# check
expected_result = {expected_context.school_identifier: expected_context}
assert expected_result == result
@pytest.mark.asyncio
async def test_get_school_context_uses_get_roles_oc_fallback(fake_udm_user):
school_ou = "test_ou"
user = fake_udm_user(["teacher"], school_ou)
user.props.ucsschoolRole = [] # clean roles
backend = UdmRestApiBackend(
username=fake.user_name(),
password=fake.password(),
url="http://127.0.0.1/univention/udm",
)
result = backend.get_roles(user, school_ou)
expected = ["teacher"] # expect teacher role from the options
assert result == expected
def data_id(data) -> str:
roles, school, expected = data
return f"{'+'.join(roles)}/{school}->{'+'.join(expected)}"
@pytest.mark.parametrize(
"data",
(
(["teacher:school:School1", "student:school:School2"], "School1", {"teacher"}),
(["staff:school:School1", "staff:school:School2"], "School1", {"staff"}),
(["staff:school:School1", "staff:school:School2"], "School3", set()),
(["teacher:school:School1", "student:school:School1"], "School1", {"student", "teacher"}),
),
ids=data_id,
)
def test_get_roles_for_school(data):
roles, school, expected = data
assert expected == UdmRestApiBackend._get_roles_for_school(roles, school)
def test_get_roles_for_school_invalid_role():
with pytest.raises(ValueError):
UdmRestApiBackend._get_roles_for_school([":school:bar"], "bar")
def roles2_id(data) -> str:
options, expected = data
roles = "+".join(k for k, v in options.items() if v)
return f"{roles}->{'+'.join(expected)}"
@pytest.mark.parametrize(
"data",
(
({"ucsschoolAdministrator": False, "ucsschoolStaff": True, "foo": True}, {"staff"}),
({"ucsschoolAdministrator": True, "ucsschoolStaff": False, "foo": True}, {"school_admin"}),
({"ucsschoolStaff": True, "ucsschoolTeacher": True, "foo": True}, {"staff", "teacher"}),
({"ucsschoolStudent": True, "ucsschoolStaff": False, "foo": True}, {"student"}),
({"ucsschoolStaff": True, "ucsschoolTeacher": False, "foo": True}, {"staff"}),
({"ucsschoolTeacher": True, "ucsschoolStaff": False, "foo": True}, {"teacher"}),
({"foo": True}, {"RuntimeError"}),
),
ids=roles2_id,
)
def test_get_roles_oc_fallback(data):
options, expected = data
if expected == {"RuntimeError"}:
with pytest.raises(RuntimeError):
UdmRestApiBackend._get_roles_oc_fallback(options)
else:
assert expected == UdmRestApiBackend._get_roles_oc_fallback(options)
| 34.981651 | 102 | 0.648702 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.