text string | size int64 | token_count int64 |
|---|---|---|
# coding: utf-8
# funcions for quick testing
import numpy as np
# helper functions
def normalization(arr, normalize_mode, norm_range = [0,1]):
"""
Helper function: Normalizes the image based on the specified mode and range
Args:
arr: numpy array
normalize_mode: either "whiten", "normalize_clip", or "normalize" representing the type of normalization to use
norm_range: (Optional) Specifies the range for the numpy array values
Returns:
A normalized array based on the specifications
"""
# reiniating the batch_size dimension
if normalize_mode == "whiten":
return whiten(arr)
elif normalize_mode == "normalize_clip":
return normalize_clip(arr, norm_range = norm_range)
elif normalize_mode == "normalize":
return minmax_normalize(arr, norm_range = norm_range)
else:
return NotImplementedError("Please use the supported modes.")
def normalize_clip(arr, norm_range = [0,1]):
"""
Args:
arr: numpy array
norm_range: list of 2 integers specifying normalizing range
based on https://stats.stackexchange.com/questions/178626/how-to-normalize-data-between-1-and-1
Returns:
Whitened and normalized array with outliers clipped in the specified range
"""
# whitens -> clips -> scales to [0,1]
# whiten
norm_img = np.clip(whiten(arr), -5, 5)
norm_img = minmax_normalize(arr, norm_range)
return norm_img
def whiten(arr):
"""
Mean-Var Normalization (Z-score norm)
* mean of 0 and standard deviation of 1
Args:
arr: numpy array
Returns:
A numpy array with a mean of 0 and a standard deviation of 1
"""
shape = arr.shape
arr = arr.flatten()
norm_img = (arr-np.mean(arr)) / np.std(arr)
return norm_img.reshape(shape)
def minmax_normalize(arr, norm_range = [0,1]):
"""
Args:
arr: numpy array
norm_range: list of 2 integers specifying normalizing range
based on https://stats.stackexchange.com/questions/178626/how-to-normalize-data-between-1-and-1
Returns:
Normalized array with outliers clipped in the specified range
"""
norm_img = ((norm_range[1]-norm_range[0]) * (arr - np.amin(arr)) / (np.amax(arr) - np.amin(arr))) + norm_range[0]
return norm_img
def clip_upper_lower_percentile(image, mask=None, percentile_lower=0.2, percentile_upper=99.8):
"""
Clipping values for positive class areas.
Args:
image:
mask:
percentile_lower:
percentile_upper:
Return:
Image with clipped pixel intensities
"""
# Copyright 2017 Division of Medical Image Computing, German Cancer Research Center (DKFZ)
#
# 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.
# ===================================================================================================
# Changes: Added the ability to have the function clip at only the necessary percentiles with no mask and removed the
# automatic generation of a mask
# finding the percentile values
cut_off_lower = np.percentile(image[mask != 0].ravel(), percentile_lower)
cut_off_upper = np.percentile(image[mask != 0].ravel(), percentile_upper)
# clipping based on percentiles
res = np.copy(image)
if mask is not None:
res[(res < cut_off_lower) & (mask !=0)] = cut_off_lower
res[(res > cut_off_upper) & (mask !=0)] = cut_off_upper
elif mask is None:
res[(res < cut_off_lower)] = cut_off_lower
res[(res > cut_off_upper)] = cut_off_upper
return res
| 4,138 | 1,246 |
import datetime
t = (3, 30, 2019, 9, 25)
x = datetime.datetime(t[2], t[3], t[4], t[0], t[1])
print(x.strftime("%m/%d/%Y %H:%M"))
| 130 | 74 |
# Autoencoder based on: https://towardsdatascience.com/predictive-maintenance-of-turbofan-engine-64911e39c367
import argparse
import pandas as pd
import numpy as np
import itertools
import logging
import random
import os
from scipy.spatial.distance import pdist, squareform
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.preprocessing import MinMaxScaler, StandardScaler
import tensorflow as tf
from tensorflow.keras.models import *
from tensorflow.keras.layers import *
from tensorflow.keras.optimizers import *
from tensorflow.keras.utils import *
from tensorflow.keras.callbacks import *
def get_logger(name):
logger = logging.getLogger(name)
log_format = '%(asctime)s %(levelname)s %(name)s: %(message)s'
logging.basicConfig(format=log_format, level=logging.INFO)
return logger
def parse_args():
parser = argparse.ArgumentParser()
# model_dir is always passed in from SageMaker. By default this is a S3 path under the default bucket.
parser.add_argument('--model_dir', type=str)
parser.add_argument('--sm-model-dir', type=str, default=os.environ.get('SM_MODEL_DIR'))
parser.add_argument('--training_dir', type=str, default=os.environ['SM_CHANNEL_TRAIN'])
parser.add_argument('--num_datasets', type=int, default=1)
parser.add_argument('--batch_size', type=int, default=512)
parser.add_argument('--epochs', type=int, default=25)
parser.add_argument('--sequence_length', type=int, default=50) # AE
parser.add_argument('--validation_split', type=float, default=0.2) # AE
parser.add_argument('--patience', type=int, default=6) # AE
return parser.parse_args()
def read_train_data(training_dir, num_datasets):
train_dfs = [pd.read_csv(os.path.join(training_dir, 'train-{}.csv'.format(i))) for i in range(num_datasets)]
return train_dfs
def read_test_data(training_dir, num_datasets):
test_dfs = [pd.read_csv(os.path.join(training_dir, 'test-{}.csv'.format(i))) for i in range(num_datasets)]
return test_dfs
def gen_sequence(id_df, seq_length, seq_cols):
data_matrix = id_df[seq_cols].values
num_elements = data_matrix.shape[0]
# Iterate over two lists in parallel.
# For example id1 have 192 rows and sequence_length is equal to 50
# so zip iterate over two following list of numbers (0,142),(50,192)
# 0 50 (start stop) -> from row 0 to row 50
# 1 51 (start stop) -> from row 1 to row 51
# 2 52 (start stop) -> from row 2 to row 52
# ...
# 141 191 (start stop) -> from row 141 to 191
for start, stop in zip(range(0, num_elements-seq_length), range(seq_length, num_elements)):
yield data_matrix[start:stop, :]
def gen_labels(id_df, seq_length, label):
data_matrix = id_df[label].values
num_elements = data_matrix.shape[0]
# I have to remove the first seq_length labels
# because for one id the first sequence of seq_length size have as target
# the last label (the previus ones are discarded).
# All the next id's sequences will have associated step by step one label as target.
return data_matrix[seq_length:num_elements, :]
def rec_plot(s, eps=0.10, steps=10):
d = pdist(s[:,None])
d = np.floor(d/eps)
d[d>steps] = steps
Z = squareform(d)
return Z
def get_dataset(train_df, test_df, sequence_length):
# NOTE: Skipping processing besides labels which are included in this page
# see: https://github.com/awslabs/predictive-maintenance-using-machine-learning/blob/master/source/notebooks/sagemaker_predictive_maintenance/preprocess.py
### ADD NEW LABEL TRAIN ###
w1 = 45
w0 = 15
train_df['label1'] = np.where(train_df['RUL'] <= w1, 1, 0 )
train_df['label2'] = train_df['label1']
train_df.loc[train_df['RUL'] <= w0, 'label2'] = 2
### ADD NEW LABEL TEST ###
test_df['label1'] = np.where(test_df['RUL'] <= w1, 1, 0 )
test_df['label2'] = test_df['label1']
test_df.loc[test_df['RUL'] <= w0, 'label2'] = 2
### DROP NA DATA ###
train_df = train_df.dropna(axis=1)
test_df = test_df.dropna(axis=1)
### SEQUENCE COL: COLUMNS TO CONSIDER ###
sequence_cols = []
for col in train_df.columns:
if col[0] == 's':
sequence_cols.append(col)
#sequence_cols.append('cycle_norm')
logging.info('Sequence Cols: {}'.format(sequence_cols))
### GENERATE X TRAIN TEST ###
x_train, x_test = [], []
for engine_id in train_df.id.unique():
for sequence in gen_sequence(train_df[train_df.id==engine_id], sequence_length, sequence_cols):
x_train.append(sequence)
for sequence in gen_sequence(test_df[test_df.id==engine_id], sequence_length, sequence_cols):
x_test.append(sequence)
x_train = np.asarray(x_train)
x_test = np.asarray(x_test)
logging.info("X_Train shape: {}".format(x_train.shape))
logging.info("X_Test shape: {}".format(x_test.shape))
### GENERATE Y TRAIN TEST ###
y_train, y_test = [], []
for engine_id in train_df.id.unique():
for label in gen_labels(train_df[train_df.id==engine_id], sequence_length, ['label2'] ):
y_train.append(label)
for label in gen_labels(test_df[test_df.id==engine_id], sequence_length, ['label2']):
y_test.append(label)
y_train = np.asarray(y_train).reshape(-1,1)
y_test = np.asarray(y_test).reshape(-1,1)
### ENCODE LABEL ###
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
logging.info("y_train shape: {}".format(y_train.shape))
logging.info("y_test shape: {}".format(y_test.shape))
### TRANSFORM X TRAIN TEST IN IMAGES ###
x_train_img = np.apply_along_axis(rec_plot, 1, x_train).astype('float16')
logging.info("x_train_image shape: {}".format(x_train_img.shape))
x_test_img = np.apply_along_axis(rec_plot, 1, x_test).astype('float16')
logging.info("x_test_image shape: {}".format(x_test_img.shape))
return x_train_img, y_train, x_test_img, y_test
def fit_model(x_train_img, y_train, batch_size=512, epochs=25, validation_split=0.2, patience=6):
input_shape = x_train_img.shape[1:]
logging.info("Input shape: {}".format(input_shape))
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=input_shape))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(3, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
logging.info(model.summary())
### FIT ###
tf.random.set_seed(33)
np.random.seed(33)
random.seed(33)
session_conf = tf.compat.v1.ConfigProto(
intra_op_parallelism_threads=1,
inter_op_parallelism_threads=1
)
sess = tf.compat.v1.Session(
graph=tf.compat.v1.get_default_graph(),
config=session_conf
)
tf.compat.v1.keras.backend.set_session(sess)
es = EarlyStopping(monitor='val_accuracy', mode='auto', restore_best_weights=True, verbose=1, patience=patience)
model.fit(x_train_img, y_train, batch_size=batch_size, epochs=epochs, callbacks=[es],
validation_split=validation_split, verbose=2)
### EVAL ###
logging.info('Evaluate: {}'.format(model.evaluate(x_test_img, y_test, verbose=2)))
logging.info(classification_report(np.where(y_test != 0)[1], model.predict_classes(x_test_img)))
return model
if __name__ == '__main__':
logging = get_logger(__name__)
logging.info('numpy version:{} Tensorflow version::{}'.format(np.__version__, tf.__version__))
args = parse_args()
# Read the first dataset
train_df = read_train_data(args.training_dir, args.num_datasets)[0]
test_df = read_test_data(args.training_dir, args.num_datasets)[0]
# Get the training dataset as an image
x_train_img, y_train, x_test_img, y_test = get_dataset(train_df, test_df, args.sequence_length)
model = fit_model(x_train_img, y_train,
batch_size=args.batch_size,
epochs=args.epochs,
validation_split=args.validation_split,
patience=args.patience)
logging.info('saving model to: {}...'.format(args.model_dir))
model.save(os.path.join(args.sm_model_dir, '000000001')) | 8,654 | 3,143 |
#! /usr/bin/env python
# vim: set fileencoding=utf-8
import sys
import json
def main():
args = sys.argv[1:]
fn = args[0]
with open(fn) as fp:
d = json.load(fp)
# Using sorted() to get same results in Python 2 and 3.
for k, v in sorted(d.items()):
assert isinstance(v, list)
assert 0 < len(v) < 4
# print(k, v)
print('%-40s %s' % (k, ' '.join('%d' % n for n in v)))
main()
| 437 | 174 |
# -*- coding: utf-8 -*-
import os
import datetime
import time
import MySQLdb as mdb
LIB_INDEXES = 'D:\\TEMP\\librusec'
MYSQL_HOST = '127.0.0.1'
MYSQL_BASE = 'books100'
MYSQL_LOGIN = 'root'
MYSQL_PASSW = 'qwerty'
SQL_CHECK_BASE = "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '%s'"
SQL_CREATE_BASE = "CREATE DATABASE `%s` DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;"
SQL_USE_BASE = 'USE `%s`;'
class BookDatabase(object):
"""
Database class for store books
"""
SQL_NEW_BOOK = u"INSERT INTO books VALUES ({0}, '{1}', {2}, '{3}', '{4}', '{5}')"
SQL_CHECK_AUTHOR = u"select id from authors where last_name='{0}' and first_name = '{1}' and middle_name='{2}'"
SQL_NEW_AUTHOR = u"INSERT INTO authors (last_name, first_name, middle_name) VALUES ('{0}', '{1}', '{2}')"
SQL_NEW_LINK = u"INSERT INTO link_ab VALUES ({0}, {1})"
def __init__(self):
self._conn = mdb.connect(MYSQL_HOST, MYSQL_LOGIN, MYSQL_PASSW, MYSQL_BASE, charset='utf8')
self._cur = self._conn.cursor()
def get_last_row_id(self):
return self._cur.lastrowid
def exec_sql(self, sql):
return self._cur.execute(sql)
def get_row_count(self):
return self._cur.rowcount
def get_value(self, index):
data = self._cur.fetchone()
return data[index]
def store_author(self, last_name, first_name, middle_name):
"""
Store new author with check existing record
:param last_name: last name author
:param first_name: first name author
:param middle_name: middle name author
:return: Id new record
"""
sql = self.SQL_CHECK_AUTHOR.format(last_name, first_name, middle_name)
self.exec_sql(sql)
if self.get_row_count() == 0:
sql = self.SQL_NEW_AUTHOR.format(last_name, first_name, middle_name)
self.exec_sql(sql)
id_author = self.get_last_row_id()
else:
id_author = self.get_value(0)
return id_author
def store_book(self, id_book, name, book_size, book_type, lang, genre):
"""
Store new book
:param id_book: Id book
:param name: Name of book
:param book_size: Size book in bytes
:param book_type: Type book
:param lang: Language book
:param genre: Genres
:return: Id new record
"""
book_name = name.replace("'", '`')
sql = self.SQL_NEW_BOOK.format(id_book, book_name, book_size, book_type, lang, genre)
self.exec_sql(sql)
return id_book
def store_author_in_book(self, id_book, id_author):
"""
Store links for book+author
:param id_book: Id book
:param id_author: Id author
:return: nothing
"""
sql = self.SQL_NEW_LINK.format(id_book, id_author)
self.exec_sql(sql)
def create_schema(filename):
"""
Create database schema from sql-file
:param filename: Input schema sql-file for MySql
:return:
"""
start = time.time()
f = open(filename, 'r')
sql = " ".join(f.readlines())
print "Start executing: " + filename + " at " + str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M")) + "\n" + sql
conn = mdb.connect(MYSQL_HOST, MYSQL_LOGIN, MYSQL_PASSW)
cur = conn.cursor()
sql_check = SQL_CHECK_BASE % MYSQL_BASE
cur.execute(sql_check)
if cur.rowcount == 0:
cur.execute(SQL_CREATE_BASE % MYSQL_BASE)
cur.execute(SQL_USE_BASE % MYSQL_BASE)
cur.execute(sql)
else:
print "Database exist. Stop!"
end = time.time()
print "Time elapsed to run the query:"
print str((end - start)*1000) + ' ms'
def process_file(inp_file, book_db):
with open(inp_file) as f:
row_counter = 0
for line in f:
row_counter += 1
line = line.decode('utf-8').strip()
book_item = line.split(chr(4))
bid = book_item[7]
bname = book_item[2]
bsize = book_item[6]
btype = book_item[9]
blang = book_item[11]
bgenre = book_item[1]
try:
id_book = book_db.store_book(int(bid), bname, int(bsize), btype, blang, bgenre)
except IndexError:
print 'Index error in %s file (%d line)' % (inp_file, row_counter)
except Exception as e:
print 'Error message: %s (%s)' % (e.args, e.message)
author_line = line.split(chr(4))[0]
author_line = author_line.replace("'", '`')
authors = author_line.split(':')
for author in authors:
item = author.split(',')
if len(item) > 1:
try:
id_author = book_db.store_author(item[0], item[1], item[2])
except Exception as e:
print 'Error message author: %s (%s). Error in %s file (%d line)' % (e.args, e.message, inp_file, row_counter)
try:
book_db.store_author_in_book(id_book, id_author)
except Exception as e:
print 'Error message link: %s (%s). Error in %s file (%d line)' % (e.args, e.message, inp_file, row_counter)
def process_index_files(path_to_index):
"""
Processing all files in path LIB_INDEXES
:param path_to_index: path to LIB_ARCHIVE
:return:
"""
book_db = BookDatabase()
index = 0
indexes = filter(lambda x: x.endswith('.inp'), os.listdir(path_to_index))
cnt_files = len(indexes)
os.chdir(path_to_index)
for index_file in indexes:
index += 1
print 'Process file %s. File %d from %d' % (index_file, index, cnt_files)
start_time = time.time()
process_file(index_file, book_db)
elapsed = (time.time() - start_time)
print "Ok. Processing in {:10.4f} s.".format(elapsed)
def main():
create_schema('schema.sql')
process_index_files(LIB_INDEXES)
if __name__ == "__main__":
main()
| 6,070 | 2,041 |
# -*- coding: utf-8 -*-
import Shift as shi
import Enum as enu
def evalShift(individual):
"""
This method is grobal method.
This method is evaluation.
If you need new evaluation method, you must define it as follows.
RETURN:
evaluation values
"""
shift = shi.Shift(individual) # Get indiviaual of shift
shift.employees = enu.EMPLOYEES # Get employees list
# 想定人数とアサイン人数の差
people_count_sub_sum = sum(shift.abs_people_between_need_and_actual()) / enu.EVA_1
# 応募していない時間帯へのアサイン数
not_applicated_count = shift.not_applicated_assign() / enu.EVA_2
# アサイン数が応募数の半分以下の従業員数
few_work_user = len(shift.few_work_user()) / enu.EVA_3
# 管理者が1人もいないコマ数
no_manager_box = len(shift.no_manager_box()) / enu.EVA_4
# a,bの全部にアサインされている
three_box_per_day = len(shift.three_box_per_day()) / enu.EVA_5
# 出勤日数(出勤日数は人によって異なるためget_work_day_num()の中で計算済み)
work_day = shift.get_work_day_num()
return (
not_applicated_count,
people_count_sub_sum,
few_work_user,
no_manager_box,
three_box_per_day,
work_day[0],
work_day[1],
work_day[2],
work_day[3],
work_day[4],
work_day[5],
work_day[6],
work_day[7],
work_day[8],
work_day[9],
work_day[10]
)
| 1,328 | 620 |
from .version import __version__
__version__
| 46 | 14 |
from sqlalchemy import Column, Integer, String
from app.database import Base
class Word(Base):
id = Column(Integer, primary_key=True, index=True, autoincrement=True)
origin = Column(String, index=True, unique=True, nullable=False)
pronunciation = Column(String)
translation = Column(String)
created_at = Column(String)
updated_at = Column(String)
| 375 | 112 |
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
import bdlb
import torch
import json
# path_img = './data/test_result/t5/'
# path_img = './results_18_ce_noshuffle/2_'
#
# image = Image.open(path_img + '100.png')
# plt.imshow(image)
# plt.show()
#
# overlay = Image.open(path_img + 'overlay.png')
# plt.imshow(overlay)
# plt.show()
#
# pred = Image.open(path_img + 'pred.png')
# plt.imshow(pred)
# plt.show()
#
# target = Image.open(path_img + 'target.png')
# plt.imshow(target)
# plt.show()
#
# scores = Image.open(path_img + 'scores.png')
# scores = np.array(scores) / 255
# plt.imshow(scores)
# plt.show()
#
# dis_sum = np.load(path_img + 'dis_sum.npy')
# plt.imshow(dis_sum)
# plt.show()
with open('logit_dict.json','r',encoding='utf8')as fp:
json_data = json.load(fp)
for i in range(13):
print(len(json_data[i]))
plt.figure()
plt.hist(json_data[i])
plt.show()
| 912 | 385 |
import telebot
bot = telebot.TeleBot("879497357:AAHxUAZR2ZMy7q1dsC12NoFOmvBnKo9a3FA")
@bot.message_handler(content_types=['text'])
def echo_all(message):
bot.send_message(message.chat.id, message.text)
bot.polling( none_stop = True ) | 238 | 112 |
# -*- coding: utf-8 -*-
from model.address import Address
import random
import string
import os.path
import json
import getopt
import sys
import jsonpickle
try:
opts, args = getopt.getopt(sys.argv[1:], 'n:f:', ['number of address', 'file'])
except getopt.GetoptError as err:
getopt.usage()
sys.exit(2)
n = 5
f = 'data/address.json'
for o, a in opts:
if o == '-n':
n = int(a)
elif o == '-f':
f = a
def random_string(prefix, maxlen):
symbols = string.ascii_letters + string.digits + string.punctuation + " "*10
return prefix + "".join([random.choice(symbols) for i in range(random.randrange(maxlen))])
testdata = [Address(firstname="",
middlename="",
lastname="",
nickname="",
photo="",
title="",
company="",
address_home="",
home="",
mobile="",
work="",
fax="",
email="",
email2="",
email3="",
homepage="",
bday="",
bmonth="-",
byear="",
aday="",
amonth="-",
ayear="",
address2="",
phone2="",
notes="")] + \
[Address(firstname=random_string("firstname", 10),
middlename=random_string('middlename', 10),
lastname=random_string('lastname', 10),
nickname=random_string('nickname', 10),
photo="C:\\fakepath\\title.gif",
title=random_string('title', 10),
company=random_string('company', 10),
address_home=random_string('address_home', 10),
home=random_string('8', 10),
mobile=random_string('8', 10),
work=random_string('8', 10),
fax=random_string('8', 10),
email=random_string('8', 10),
email2=random_string('8', 10),
email3=random_string('8', 10),
homepage=random_string('8', 10),
bday=str(random.randrange(1, 32)),
bmonth="September",
byear=random_string('8', 10),
aday=str(random.randrange(1, 32)),
amonth="May",
ayear=random_string('8', 10),
address2=random_string('8', 10),
phone2=random_string('8', 10),
notes=random_string('8', 10))
for i in range(n)]
file = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', f)
with open(file, 'w') as out:
jsonpickle.set_encoder_options('json', indent=2)
out.write(jsonpickle.encode(testdata)) | 2,980 | 901 |
"""``phyphy`` package for automating and parsing HyPhy (>=2.3.7) standard analyses.
Written by Stephanie J. Spielman.
Test modules
----------------
* phyphy_test
"""
from phyphy import *
| 192 | 68 |
import scripts.screen_interface as si
import scripts.game_interface as gi
import ctypes
import os
import keyboard
import uuid
GI = gi.GameInterface()
# find center of screen
user32 = ctypes.windll.user32
screenSize = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)
centerPoint = tuple(i/2 for i in screenSize)
print('Screen Size X:%d y:%d' % screenSize)
print('Targeting Center X:%d y:%d' % centerPoint)
GI = gi.GameInterface()
SI = si.ScreenInterface()
GI.center_x = centerPoint[0]
GI.center_y = centerPoint[1]
GI.range_classifications = 10
while True:
angle = GI.get_mouse_class()
print(angle) | 613 | 216 |
import json
import queue
from control.WorkerQueue import WorkerQueue as WQ
from data.StorageIO import StorageIO
'''
The WorkerControl coordinates workers and assigns jobs.
Worker register themself at startup. The controller queues workers as well as jobs in two seperate queues.
As soon as a worker and a job are available, they are taken from the queues and the job_id is send to the worker
via MQTT. After the worker finishes its job, it will be put back into the queue
'''
class WorkerControl:
config_queue = queue.Queue(-1) # infinite size
COMMAND_START = "start"
COMMAND_STOP = "stop"
commandIO = None
storageIO: StorageIO = None
worker_list = {} # "worker_id" : "job_id"
worker_job_mapping = {}
worker_queue = WQ()
def get_worker_info(self):
return self.worker_list
# Function called by external Thread !!!
def busy_changed_callback(self, worker_id, busy_message):
try:
if len(busy_message) == 0:
print("Worker LOST: " + worker_id)
self.worker_queue.remove_worker(worker_id)
self.worker_list.pop(worker_id, None)
if not worker_id in self.worker_job_mapping:
print("Unknown worker reported busy change! This should not happen")
else:
self.update_status(worker_id, "lost")
else:
message = json.loads(busy_message)
is_busy = message["busy"] # either False or the job_id
self.worker_list[worker_id] = is_busy
if is_busy == False:
if "job_id" in message:
self.update_status(worker_id, message["status"])
if worker_id in self.worker_job_mapping:
del self.worker_job_mapping[worker_id]
self.worker_queue.add_to_queue(worker_id)
else:
job_id = message["job_id"]
self.worker_queue.remove_worker(worker_id)
self.worker_job_mapping[worker_id] = job_id
self.update_status(worker_id, message["status"])
print("Worker is busy: " + worker_id)
except Exception as e:
print("An error occurred in MQTT callback: " + str(e))
def update_status(self, worker_id: str, status: str):
if not worker_id in self.worker_job_mapping:
print("ERROR. Tried to set status for unset worker!")
else:
self.storageIO.update_job_status(self.worker_job_mapping[worker_id], status)
def __init__(self, commandIO, storageIO: StorageIO):
self.commandIO = commandIO
self.storageIO = storageIO
self.commandIO.on_busy_changed(self.busy_changed_callback)
def modify_job_state(self, job_list, command: str):
for job in job_list:
config = {"job_id": job}
if command == self.COMMAND_START:
self.create_new_job(config)
else:
pass
# Function called by external Thread !!!
def create_new_job(self, job_config: dict):
try:
print("-> Job ready (ID=" + job_config["job_id"] + ")")
self.config_queue.put(job_config, timeout=1)
except:
return False
return True
def run(self):
while (True):
jsonConfig = self.config_queue.get()
job_id = jsonConfig["job_id"]
print("<- Job selected (ID=" + job_id + ")")
ready_worker = self.worker_queue.get_next_worker()
print("Starting new job (id: " + job_id + ")")
self.commandIO.start_new_job(ready_worker, json.dumps(jsonConfig))
if ready_worker in self.worker_job_mapping:
print("Removing orphaned job from worker job mapping")
del self.worker_job_mapping[ready_worker]
self.worker_job_mapping[ready_worker] = job_id
self.update_status(ready_worker, "assigned")
| 4,052 | 1,146 |
import discord
import sys
import random
import aiohttp
import logging
token = sys.argv[1]
group = sys.argv[2]
tokenno = sys.argv[3]
msgtxt = sys.argv[4]
useproxies = sys.argv[5]
logging.basicConfig(filename='RTB.log', filemode='w', format='Token {}'.format(str(tokenno))+' - %(levelname)s - %(message)s',level=logging.CRITICAL)
if useproxies == 'True':
proxy_list = open("proxies.txt").read().splitlines()
proxy = random.choice(proxy_list)
con = aiohttp.ProxyConnector(proxy="http://"+proxy)
client = discord.Client(connector=con)
else:
client = discord.Client()
@client.event
async def on_ready():
groupdm = client.get_channel(int(group))
while not client.is_closed():
try:
await groupdm.send(msgtxt)
except Exception:
pass
try:
client.run(token, bot=False)
except Exception as c:
logging.critical('Token {} Unable to login: {}'.format(str(tokenno),str(c)))
print (c)
| 986 | 350 |
# Generated by Django 3.1.7 on 2021-05-07 03:50
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('school', '0017_emplois_emp'),
]
operations = [
migrations.CreateModel(
name='ListEmplois',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('Classe', models.CharField(max_length=100)),
('pdf', models.FileField(upload_to='')),
],
),
]
| 570 | 183 |
from model.gpt import gpt
import tensorflow as tf
import numpy as np
def gpt_encoder(model_config, features, labels,
mode, target, reuse=tf.AUTO_REUSE):
input_ids = features["input_ids"]
past = features.get('past', None)
model = gpt.GPT(model_config)
if model_config.get("scope", None):
scope = model_config['scope']
else:
scope = 'model'
model_config['scope'] = scope
model.build_model(hparams=model_config,
X=input_ids,
past=past,
scope=scope,
reuse=reuse)
return model
| 522 | 220 |
import os
def gcat(filenames):
for filename in filenames:
with open(filename) as f:
for line in f:
yield line
def ggrep(pattern, filenames):
for filename in filenames:
with open(filename) as f:
for line in f:
if pattern in line:
yield line
# Codigo de pruebas para gcat
print("Fichero linea a linea")
print("-----------------------------")
for line in gcat([os.path.join(os.path.dirname(os.path.realpath(__file__)), 'quijote.txt')]):
print(line)
print("-----------------------------")
print()
print()
# Codigo de pruebas para ggrep
print("Lineas del fichero que contienen la palabra 'los'")
print("-----------------------------")
for l in list(ggrep("los", [os.path.join(os.path.dirname(os.path.realpath(__file__)), 'quijote.txt')])):
print(l)
print("-----------------------------")
| 900 | 279 |
import binaryninja
from .breach_arch import BreachArch
BreachArch.register()
from .breach_programview import BreachProgramView
BreachProgramView.register()
from .breach_calling_convention import BreachCallingConvention
from .breach_platform import BreachPlatform | 265 | 77 |
from django.core.exceptions import ObjectDoesNotExist
from django.db import IntegrityError
from rest_framework.decorators import api_view
from rest_framework import status
from swot_item_vote.models import Vote
from swot_item.models import SwotItem
from .serializers import serialize, get_item_confidence
from swot.models import Swot
from core.decorators import authenticate
from core.serializers import deserialize
@api_view(['GET'])
@authenticate
@deserialize
@serialize
def vote_list(request, swot_id):
try:
Swot.objects.get(id=swot_id)
except ObjectDoesNotExist:
return (
None,
status.HTTP_404_NOT_FOUND,
['Swot {} does not exist'.format(swot_id)]
)
votes = Vote.objects.filter(swot_id=swot_id)
return (
[vote for vote in votes],
status.HTTP_200_OK,
None,
)
@api_view(['POST'])
@authenticate
@deserialize
@serialize
def vote(request, swot_item_id):
swot_item_id = int(swot_item_id)
vote_type = request.body['voteType']
user_id = request.user.id
swot_item = None
try:
swot_item = SwotItem.objects.get(id=swot_item_id)
except ObjectDoesNotExist:
return (
None,
status.HTTP_404_NOT_FOUND,
['Swot Item does {} not exist'.format(swot_item_id)]
)
try:
existing_vote = Vote.objects.get(
swot_item_id=swot_item_id,
created_by_id=user_id
)
existing_vote_type = existing_vote.voteType
existing_vote.delete()
if existing_vote_type == vote_type:
return (
None,
status.HTTP_200_OK,
None
)
except ObjectDoesNotExist:
pass
vote = None
try:
vote = Vote(
created_by_id=user_id,
swot_item_id=swot_item_id,
swot_id=swot_item.swot_id,
voteType=vote_type
)
except IntegrityError, ie:
return (
None,
status.HTTP_400_BAD_REQUEST,
[ie]
)
try:
vote.save()
except:
return (
None,
status.HTTP_400_BAD_REQUEST,
['Error saving vote']
)
SwotItem.objects\
.filter(pk=swot_item_id)\
.update(score=get_item_confidence(swot_item_id))
return (
vote,
status.HTTP_201_CREATED,
None,
)
| 2,460 | 805 |
#!/usr/bin/env python3
#################################################################################
################# Helper Module #################################################
################# Provides abstraction to car sensors and PHY layer #############
#################################################################################
from __future__ import absolute_import
from __future__ import print_function
import os
import sys
sys.path.append('../src/packets/header/')
# Import proto modules
import CARRequestToMT_pb2
import MTGPSResponse_pb2
import MTSpeedResponse_pb2
import MsgFromNodeToUDM_pb2
import MessageForwardFromUDM_pb2
import BigData_pb2
import DistributeProcesses_pb2
# Import other libraries
import optparse
import subprocess
import random
import time
import zmq
import thread
import json
import xml.etree.ElementTree as ET
import netifaces as ni
import math
import sys
import linecache
import datetime
import threading
import base64
from threading import Lock, Thread
import time
from xmlr import xmliter
# Uncomment when required debugging
# debugger proc
"""def traceit(frame, event, arg):
if event == "line":
lineno = frame.f_lineno
filename = frame.f_globals["__file__"]
if (filename.endswith(".pyc") or
filename.endswith(".pyo")):
filename = filename[:-1]
name = frame.f_globals["__name__"]
line = linecache.getline(filename, lineno)
print(name, lineno, line.rstrip())
return traceit"""
# Global Vaiables
ParserIP = ""
ParserPort = ""
UDMPort = ""
Keys = []
SumoFloatingDataPath = ""
VehInfoHashMap = {}
APInfoHashMap = {}
StartPort = 12000
Incrementor = 0
AllAddrTable = {}
CommRange = 0.0
LogInfoEnable = ""
LogInfoFile = ""
LogInfoStdOutput = ""
LogDebugEnable = ""
LogDebugFile = ""
LogDebugStdOutput = ""
LogStatsEnable = ""
LogStatsFILE = ""
LogStatsStdOutput = ""
LogErrorEnable = ""
LogErrorFILE = ""
LogErrorStdOutput = ""
LogFilePath = ""
ExperimentNumber = ""
RunInForeGround = ""
RunInForeGroundList = ""
LogFile = ""
UDMPublisher = "NULL"
UDMExitPublisher = "NULL"
SystemsIP = []
SystemsIPSubscript = 0
DistributedSystemsPublisher = ""
NOTFinished = True
lock = Lock()
# Converts string into list which has literals separated by commas and returns it
def ConvertStringToList(string):
li = list(string.split(" "))
return li
# Starts a car process in different terminal, takes vid(Vehicle ID) and starting port number helps car to spawn in-car processes
# incrementor determines the number of ports could be reserved for each car
def start_carProc(vid):
global StartPort, Incrementor, RunInForeGround, RunInForeGroundList, SystemsIPSubscript, SystemsIP, DistributedSystemsPublisher
Message = DistributeProcesses_pb2.PROCESS_DISTRIBUTION()
# Create message
if RunInForeGround == "TRUE" or vid in RunInForeGroundList:
Message.RUN_IN_FOREGROUND = True
else:
Message.RUN_IN_FOREGROUND = False
Message.ID = vid
Message.START_PORT_NO = str(StartPort + Incrementor)
Message.MODULE_TYPE = "CAR"
if SystemsIPSubscript % len(SystemsIP) == 0:
SystemsIPSubscript += 1
# Send message
DistributedSystemsPublisher.send_multipart([SystemsIP[SystemsIPSubscript % len(SystemsIP)], Message.SerializeToString()])
SystemsIPSubscript = SystemsIPSubscript % len(SystemsIP) + 1
Incrementor += 5
LogsDebug("A Car process " + vid + " is started")
LogsInfo("A Car process " + vid + " is started")
# Sends message to Command Receiver running on remote machine with ID=-1 indicating one experiment run is completed
def SendKillSigToTerminals():
Message = DistributeProcesses_pb2.PROCESS_DISTRIBUTION()
Message.ID = "-1"
for each in SystemsIP:
DistributedSystemsPublisher.send_multipart([each, Message.SerializeToString()])
# Server waits for the client(car process) requests - for position and speed
def MobilityServer():
global ParserIP, ParserPort, VehInfoHashMap, NOTFinished
context = zmq.Context()
socket = context.socket(zmq.REP)
LogsDebug("Sumo Data Parser Server binds at the address "+ParserIP+":" + ParserPort)
socket.bind("tcp://"+ParserIP+":"+ParserPort)
Request = CARRequestToMT_pb2.CARREQUESTTOMT()
GPSResponse = MTGPSResponse_pb2.MTGPSRESPONSE()
SpeedResponse = MTSpeedResponse_pb2.MTSPEEDRESPONSE()
while NOTFinished:
# Wait for next request from client
vehInfoReq = socket.recv()
Request.ParseFromString(vehInfoReq)
# parse the request
VehID = Request.VID
ReqType = Request.REQ
# Check what is the request type (for position or speed) accordingly build the json reply
if ReqType == "POS":
LogsDebug("A request for Position is arrived for Vehicle ID " + VehID)
if VehID in VehInfoHashMap:
LogsDebug("Vehicle ID " + VehID + " exists and a response with updated Position data will be sent")
GPSResponse.INFO_EXISTS = 1
GPSResponse.X = float(json.loads(VehInfoHashMap[VehID])["X"])
GPSResponse.Y = float(json.loads(VehInfoHashMap[VehID])["Y"])
GPSResponse.DIR = float(json.loads(VehInfoHashMap[VehID])["DIR"])
GPSResponse.LANE = json.loads(VehInfoHashMap[VehID])["LANE"]
else:
LogsDebug("Vehicle ID " + VehID + " do not exist in the network and response is sent")
GPSResponse.INFO_EXISTS = 0
DataToSend = GPSResponse.SerializeToString()
elif ReqType == "SPE":
LogsDebug("A request for Speed is arrived for Vehicle ID " + VehID)
if VehID in VehInfoHashMap:
LogsDebug("Vehicle ID " + VehID + " exists and a response with updated Speed data will be sent")
SpeedResponse.INFO_EXISTS = 1
SpeedResponse.SPEED = float(json.loads(VehInfoHashMap[VehID])["SPE"])
else:
LogsDebug("Vehicle ID " + VehID + " do not exist in the network")
SpeedResponse.INFO_EXISTS = 0
DataToSend = SpeedResponse.SerializeToString()
socket.send(DataToSend)
# Updates the speed and position information in the hashmap
def update_hashmap(vid, x, y, speed, angle, lane):
global VehInfoHashMap
jsonVehData = {
"X" : x,
"Y" : y,
"SPE" : speed,
"DIR" : angle,
"LANE" : lane
}
VehInfoHashMap[vid] = json.dumps(jsonVehData)
Message = MsgFromNodeToUDM_pb2.MSGFROMNODETOUDM()
# udm module: server awaits the message forward requests from its clients (car or ap)
def udm_server():
global ParserIP, UDMPort, Message
context = zmq.Context()
socket = context.socket(zmq.PULL)
LogsDebug("UDM Server binds at the address "+ParserIP+":" + UDMPort)
LogsInfo("UDM Server binds at the address "+ParserIP+":" + UDMPort)
socket.bind("tcp://"+ParserIP+":"+UDMPort)
while True:
# Wait for next request from client
msgForwardReq = socket.recv()
Message.ParseFromString(msgForwardReq)
# mtype - message type (INIT or UNICAST or BROADCAST)
# Only cars send INIT message - once, when the process get started
try:
mtype = Message.MTYPE
except ValueError:
mtype = ""
LogsError("This occur very very rarely and yet to investigate on why this error!! ...")
if mtype == "INIT":
LogsInfo("INIT message recieved from " + Message.SRC_ID)
LogsDebug("INIT message recieved from " + Message.SRC_ID)
store_ip_port(msgForwardReq)
elif mtype == "UNI" or mtype == "BROAD" or mtype == "MUL":
forward_msg(msgForwardReq)
# Called when udm recieves INIT messages
# Stores IP and Port details of the Cars
def store_ip_port(msgForwardReq):
global AllAddrTable, Message
Message.ParseFromString(msgForwardReq)
_id = Message.SRC_ID
newip = Message.IP
newport = Message.PORT
_type = Message.SRC_TYPE
LogsDebug("From the INIT Message Vehicle " + _id + " IP PORT and TYPE are extracted " + newip + " " + newport + " " + _type
+ " and are stored")
new_data = {
'IP' : newip,
'PORT' : newport,
'TYPE' : _type
}
AllAddrTable[_id] = json.dumps(new_data)
# Based on the MTYPE(message type) calls different message forwarding modules
def forward_msg(msgForwardReq):
global VehInfoHashMap, APInfoHashMap, Message
Message.ParseFromString(msgForwardReq)
mtype = Message.MTYPE
src_id = Message.SRC_ID
# Checks if the source id is either present in updated vehicle hash map or AP hash map
# If it exists only then forward the messages (else the vehicles not in the network anymore)
if VehInfoHashMap and APInfoHashMap:
if src_id in VehInfoHashMap or src_id in APInfoHashMap:
if mtype == "UNI":
send_unicast_msg(msgForwardReq)
elif mtype == "BROAD":
send_broadcast_msg(msgForwardReq)
elif mtype == "MUL":
send_multicast_msg(msgForwardReq)
# Forwards unicast messages
def send_unicast_msg(msgForwardReq):
global APInfoHashMap, VehInfoHashMap, AllAddrTable, Message
Message.ParseFromString(msgForwardReq)
src_id = Message.SRC_ID
dest_id = Message.DEST_ID
LogsDebug("UNICAST message is recieved from " + src_id + " to forawrd it to " + dest_id)
LogsInfo("UNICAST message is recieved from " + src_id + " to forawrd it to " + dest_id)
if src_id in VehInfoHashMap:
src_details = json.loads(VehInfoHashMap[src_id])
elif src_id in APInfoHashMap:
src_details = json.loads(APInfoHashMap[src_id])
src_X = src_details['X']
src_Y = src_details['Y']
SrcExistsInAddrTable = True
try:
srcType_json = json.loads(AllAddrTable[src_id])
except KeyError:
SrcExistsInAddrTable = False
# Checks if destination node is still in the network
if (dest_id in VehInfoHashMap or dest_id in APInfoHashMap) and SrcExistsInAddrTable:
# Checks if destination address is known to the UDM
if dest_id in AllAddrTable:
# If the source type is BS donot check for communication range
if srcType_json['TYPE'] == "BS":
PublishMsg(msgForwardReq, dest_id)
LogsDebug("Received UNICAST message is forwarded to " + dest_id)
else:
Dest_json = json.loads(AllAddrTable[dest_id])
# If dest type is car or RSU check if source and destination are in the communication range
# else for BS skips the check and forward the message
if Dest_json['TYPE'] == "CAR":
car_json = json.loads(VehInfoHashMap[dest_id])
LogsDebug("range check between " + src_id + " -----------> " + dest_id)
LogsDebug(src_id+"("+src_X+","+src_Y+") "+dest_id+"("+ car_json["X"]+ ","+ car_json["Y"]+ ")")
if within_range(src_X, src_Y, car_json["X"], car_json["Y"]):
PublishMsg(msgForwardReq, dest_id)
LogsDebug("Received UNICAST message is forwarded to " + dest_id)
elif Dest_json['TYPE'] == "RSU":
RSU_json = json.loads(APInfoHashMap[dest_id])
LogsDebug("range check between " + src_id + " -----------> " + dest_id)
LogsDebug(src_id+"("+src_X+","+src_Y+") "+dest_id+"("+ RSU_json["X"]+ ","+ RSU_json["Y"]+ ")")
if within_range(src_X, src_Y, RSU_json["X"], RSU_json["Y"]):
PublishMsg(msgForwardReq, dest_id)
LogsDebug("Received UNICAST message is forwarded to " + dest_id)
elif Dest_json['TYPE'] == "BS":
PublishMsg(msgForwardReq, dest_id)
LogsDebug("Received UNICAST message is forwarded to " + dest_id)
else:
LogsError("Unicast message to VID " + dest_id + "failed, since vehicle doesn't exist or Address is still Unknown")
def PublishMsg(msgForwardReq, dest_id):
global UDMPublisher, Message
Message.ParseFromString(msgForwardReq)
src_id = Message.SRC_ID
dest_json = json.loads(AllAddrTable[dest_id])
src_json = json.loads(AllAddrTable[src_id])
DataToForward = MessageForwardFromUDM_pb2.MESSAGEFROMUDM()
DataToForward.SRC_ID = src_id
# Copy contents of the incoming message to new message that is forwarded to destination node
DataToForward.DATA.DATALINE1 = Message.DATA.DATALINE1
DataToForward.DATA.DATALINE2 = Message.DATA.DATALINE2
DataToForward.DATA.ID = Message.DATA.ID
DataToForward.DATA.X = Message.DATA.X
DataToForward.DATA.DIR = Message.DATA.DIR
DataToForward.DATA.SPEED = Message.DATA.SPEED
DataToForward.DATA.DATATYPE = Message.DATA.DATATYPE
DataToForward.DATA.TIMESTAMP = Message.DATA.TIMESTAMP
DataToForward.DATA.Y = Message.DATA.Y
DataToForward.DATA.CH = Message.DATA.CH
DataToForward.DATA.CMLIST = Message.DATA.CMLIST
DataToForward.DATA.CLUSTERID = Message.DATA.CLUSTERID
DataToForward.DATA.CLUSTER_SEQ_NUM = Message.DATA.CLUSTER_SEQ_NUM;
DataToForward.DATA.FILENAME = Message.DATA.FILENAME
DataToForward.DATA.DATA = Message.DATA.DATA
DataToForward.DATA.CHUNKNUM = Message.DATA.CHUNKNUM
DataToForward.DATA.LASTPKT = Message.DATA.LASTPKT
DataToForward.DATA.START_TIME = Message.DATA.START_TIME
DataToForward.DATA.TASKSEQNUM = Message.DATA.TASKSEQNUM
DataToForward.DATA.TASKMAXTIME = Message.DATA.TASKMAXTIME
DataToForward.DATA.FINISHTIME = Message.DATA.FINISHTIME
DataToForward.DATA.RESULT = Message.DATA.RESULT
# Adding additional fields
DataToForward.SRC_TYPE = src_json['TYPE']
DataToForward.DEST_TYPE = dest_json['TYPE']
DataToForward.EXIT = False
DataToSend = DataToForward.SerializeToString()
if "DCA" in Message.SUB_DEST_ID:
DestID = dest_id + "DCAID"
elif "TASK" in Message.SUB_DEST_ID:
DestID = dest_id + "TASKDID"
elif "DC" in Message.SUB_DEST_ID:
DestID = dest_id + "DCID"
else:
DestID = dest_id + "ID"
UDMPublisher.send_multipart([str(DestID), DataToSend])
# Forwards broadcast messages
def send_broadcast_msg(msgForwardReq):
global APInfoHashMap, VehInfoHashMap, AllAddrTable, Message
Message.ParseFromString(msgForwardReq)
src_id = Message.SRC_ID
LogsDebug("Broadcast message is recieved from " + src_id)
LogsInfo("Broadcast message is recieved from "+ src_id)
if src_id in VehInfoHashMap:
src_details = json.loads(VehInfoHashMap[src_id])
elif src_id in APInfoHashMap:
src_details = json.loads(APInfoHashMap[src_id])
src_X = src_details['X']
src_Y = src_details['Y']
SrcExistsInAddrTable = True
try:
srcType_json = json.loads(AllAddrTable[src_id])
except KeyError:
SrcExistsInAddrTable = False
# Check all the cars in the address table if they are within the communication range
CopyOfAllAddrTable = dict(AllAddrTable)
for _id in CopyOfAllAddrTable:
# Check if _id is exists in the network and
# and the _id should not be the source id (to avoid broadcast back to the source)
if (_id in VehInfoHashMap or _id in APInfoHashMap) and _id != src_id and SrcExistsInAddrTable:
# If the source type is BS donot check for communication range
if srcType_json['TYPE'] == "BS":
PublishMsg(msgForwardReq, _id)
LogsDebug("Received BROADCAST message is forwarded to" + _id)
# If dest type is car or RSU check if source and destination are in the communication range
# else if it is a BS skips the check and forward the message
else:
broad_json = json.loads(CopyOfAllAddrTable[_id])
if broad_json['TYPE'] == 'CAR':
car_json = json.loads(VehInfoHashMap[_id])
LogsDebug("range check between "+src_id+" -----------> "+_id)
if within_range(src_X, src_Y, car_json["X"], car_json["Y"]):
PublishMsg(msgForwardReq, _id)
LogsDebug("Received BROADCAST message is forwarded to" + _id)
elif broad_json['TYPE'] == "RSU":
RSU_json = json.loads(APInfoHashMap[_id])
LogsDebug("range check between "+src_id+" -----------> "+_id)
if within_range(src_X, src_Y, RSU_json["X"], RSU_json["Y"]):
PublishMsg(msgForwardReq, _id)
LogsDebug("Received BROADCAST message is forwarded to" + _id)
elif broad_json['TYPE'] == "BS":
PublishMsg(msgForwardReq, _id)
LogsDebug("Received BROADCAST message is forwarded to" + _id)
# Detects if both are in the communication range(Do not consider obstacles)
def within_range(x1, y1, x2, y2):
global CommRange
distance = math.sqrt( (float(x1) - float(x2)) * (float(x1) - float(x2)) + (float(y1) - float(y2)) * (float(y1) - float(y2)) )
LogsDebug("Comparison " + str(distance) +" < " + CommRange + " ??")
if float(distance) < float(CommRange):
return True
else:
return False
VehiclesExitList = []
import random
# When vehicle exists network this method sends exit message to the vehicle
def DeleteFromNetwork(each):
# Sleeps for random time (because at last timestep all cars exits at once) to avoid race to acquire lock
time.sleep(float(random.randint(1,100))/100.0)
DataToForward = MessageForwardFromUDM_pb2.MESSAGEFROMUDM()
# Indicates vehicles to exit
DataToForward.EXIT = True
DataToSend = DataToForward.SerializeToString()
print(each)
lock.acquire()
# Send all modules of cars an exit message
UDMExitPublisher.send_multipart([str(each) + "DCAEXITID", DataToSend])
UDMExitPublisher.send_multipart([str(each) + "TASKDEXITID", DataToSend])
UDMExitPublisher.send_multipart([str(each) + "EXITID", DataToSend])
UDMExitPublisher.send_multipart([str(each) + "EXITGPSID", DataToSend])
UDMExitPublisher.send_multipart([str(each) + "EXITSPEEDID", DataToSend])
lock.release()
# Allows cars to terminate before Helper removes car from the existing list
time.sleep(12.0)
del VehInfoHashMap[each]
# Deletes the car data when the car no longer exists in the network
def cleanup_VehInfoHashMap(VIDList):
global VehInfoHashMap, Keys, VehiclesExitList, UDMExitPublisher
Keys = VehInfoHashMap.keys()
for each in Keys:
if each not in VIDList and each not in VehiclesExitList:
VehiclesExitList.append(each)
# Creates a thread for each exited car to send a exit message to vehicle
thread.start_new_thread(DeleteFromNetwork,(each,))
# Subscriber always misses the first message. FirstMsg is used to send first message twice
FirstMsg = True
i = 0
_list = []
_dict = {}
# First proc called in the main()
def run():
start = 0.0
end = 0.0
FirstTime = 1
WaitPeriod = 0.0
WaitDue = 0.0
# Creates a UDM server thread
thread.start_new_thread(udm_server, ())
# Creates server that responds to speed and position requests from the vehicles
thread.start_new_thread(MobilityServer, ())
global SumoFloatingDataPath, VehInfoHashMap, APInfoHashMap, NOTFinished
car_proc_list = []
# Read AP info from XML file and spawns AP process in appropriate machine
update_APInfoHashMap()
# iterates through the floating car data timestamps(interval of 0.1 seconds)
#for iteration in root.iter('timestep'):
for d in xmliter(SumoFloatingDataPath, 'timestep'):
if float(d['@time']) % 20.0 == 0:
print("Current timestep = " , d['@time'])
# VIDList at every timestamp iteration is set to empty. Global parameter stores existing vehicles details
VIDList = []
# If at certain timestep there is no vehicle exist, it raises exception
try:
type(d['vehicle'])
except:
time.sleep(0.1)
continue
if type(d['vehicle']) == type(_dict):
vid = d['vehicle']['@id']
if vid not in VIDList:
# If its a new vehicle add it to the list
VIDList.append(vid)
if vid not in car_proc_list:
# If its a new vehicle spwan car processes
car_proc_list.append(vid)
start_carProc(vid)
update_hashmap(vid, d['vehicle']['@x'], d['vehicle']['@y'], d['vehicle']['@speed'], d['vehicle']['@angle'],d['vehicle']['@lane'])
elif type(d['vehicle']) == type(_list):
for each in d['vehicle']:
vid = each['@id']
if vid not in VIDList:
# If its a new vehicle add it to the list
VIDList.append(vid)
if vid not in car_proc_list:
# If its a new vehicle spwan car processes
car_proc_list.append(vid)
start_carProc(vid)
update_hashmap(vid, each['@x'], each['@y'], each['@speed'], each['@angle'],each['@lane'])
# After each time stamp remove vehicles from the hashmap which doesnt exist anymore in the network
cleanup_VehInfoHashMap(VIDList)
#LogsDebug("Currently the following vehicles exist in the network")
#for key, value in VehInfoHashMap.iteritems():
#LogsDebug("Vehicle ID " + key)
# Print timestep once in 20 seconds
if float(d['@time']) % 20.0 == 0:
print(0.1 - ((end - WaitPeriod) - start))
end = time.time() # Record End time
if FirstTime == 1:
end = 0.0
FirstTime = 0
WaitPeriod = 0.1 - ((end - WaitPeriod) - start) - WaitDue # Calculate waitperiod
start = time.time() # Calculate Start time
try:
# If time.sleep is passed a negative argument it raises exception
time.sleep(WaitPeriod + 0.03)
WaitDue = 0.0
except:
print("exception raised",WaitPeriod)
# If at certail step Waitperiod becomes negative - it takes the negative time due to next step
# If Waitperiod becomes negative at every timestep that starting inducing delay endless
WaitDue = -1 * WaitPeriod
WaitPeriod = 0.0
time.sleep(WaitPeriod)
print("Finished timesteps")
VIDList = []
# Send termination message to all existing vehicles
cleanup_VehInfoHashMap(VIDList)
print("Sent Termination message to all active cars")
time.sleep(18.0)
Keys = APInfoHashMap.keys()
DataToSend = ""
# Send termination message to all existin APs
for each in Keys:
print(each)
DataToForward = MessageForwardFromUDM_pb2.MESSAGEFROMUDM()
DataToForward.EXIT = True
DataToSend = DataToForward.SerializeToString()
lock.acquire()
UDMPublisher.send_multipart([str(each) + "ID", DataToSend])
UDMPublisher.send_multipart([str(each) + "DCID", DataToSend])
lock.release()
# Indicating in-car sensors that timesteps finished
NOTFinished = False
time.sleep(5.0)
print("Sent Termination message to all active APs")
LogsInfo("FINISHED")
LogsDebug("FINISHED")
# sleep allows all the vehicles and APs to write thier stats
time.sleep(60)
# Send termination messages to remote machine terminal indicating completed one experiment run
SendKillSigToTerminals()
sys.stdout.flush()
# Parse config file to extract details of base stations and rsu's and store them in 'APInfoHashMap'
# 'APInfoHashMap' stores id versus (ip, port and type(rsu or bs))
def update_APInfoHashMap():
global APInfoHashMap, RunInForeGround, RunInForeGroundList, DistributedSystemsPublisher, FirstMsg
LogsDebug("Parsing config file ../config/ap/config.xml")
tree = ET.parse('../config/ap/config.xml')
root = tree.getroot()
Message = DistributeProcesses_pb2.PROCESS_DISTRIBUTION()
for iteration in root.iter('config'):
for APDetails in iteration.iter('BS'):
BS_data = {
'X' : APDetails.get('x'),
'Y' : APDetails.get('y')
}
APInfoHashMap[APDetails.get('id')] = json.dumps(BS_data)
BS_IP_data = {
'IP' : APDetails.get('ip'),
'PORT' : APDetails.get('port'),
'TYPE' : "BS"
}
AllAddrTable[APDetails.get('id')] = json.dumps(BS_IP_data)
LogsDebug("BASESTATION module " + APDetails.get('id') + " is started in a separate terminal")
LogsInfo("BASESTATION module " + APDetails.get('id') + " is started in a separate terminal")
if RunInForeGround == "TRUE" or APDetails.get('id') in RunInForeGroundList:
Message.RUN_IN_FOREGROUND = True
else:
Message.RUN_IN_FOREGROUND = False
Message.ID = APDetails.get('id')
Message.MODULE_TYPE = "BS"
if FirstMsg:
DistributedSystemsPublisher.send_multipart([SystemsIP[0], Message.SerializeToString()])
FirstMsg = False
time.sleep(2)
DistributedSystemsPublisher.send_multipart([SystemsIP[0], Message.SerializeToString()])
for APDetails in iteration.iter('RSU'):
RSU_data = {
'X' : APDetails.get('x'),
'Y' : APDetails.get('y')
}
APInfoHashMap[APDetails.get('id')] = json.dumps(RSU_data)
RSU_IP_data = {
'IP' : APDetails.get('ip'),
'PORT' : APDetails.get('port'),
'TYPE' : "RSU"
}
AllAddrTable[APDetails.get('id')] = json.dumps(RSU_IP_data)
LogsDebug("ROADSIDE module " + APDetails.get('id') + " is started")
LogsInfo("ROADSIDE module " + APDetails.get('id') + " is started")
if RunInForeGround == "TRUE" or APDetails.get('id') in RunInForeGroundList:
Message.RUN_IN_FOREGROUND = True
else:
Message.RUN_IN_FOREGROUND = False
Message.ID = APDetails.get('id')
Message.MODULE_TYPE = "RSU"
if FirstMsg:
DistributedSystemsPublisher.send_multipart([SystemsIP[0], Message.SerializeToString()])
FirstMsg = False
time.sleep(2)
DistributedSystemsPublisher.send_multipart([SystemsIP[0], Message.SerializeToString()])
LogsDebug("Parsed details from ../config/ap/config.xml and stored. Details::")
for key, value in AllAddrTable.iteritems():
LogsDebug(str(key) + " " + str(json.loads(value)))
def updateLoggingUtilConfigParams():
global LogInfoEnable, LogInfoFile, LogInfoStdOutput, LogDebugEnable, LogDebugFile, LogDebugStdOutput, LogStatsEnable, LogStatsFILE, LogStatsStdOutput, LogErrorEnable, LogErrorFILE, LogErrorStdOutput, LogFilePath, ExperimentNumber, LogFile
tree = ET.parse('../config/logging_utility/config.xml')
root = tree.getroot()
for iteration in root.iter('config'):
for LogDetails in iteration.iter('Tool'):
name = LogDetails.get("name")
if name == "LogInfo":
LogInfoEnable = LogDetails.get('LogInfoEnable')
LogInfoFile = LogDetails.get('LogInfoFile')
LogInfoStdOutput = LogDetails.get('LogInfoStdOutput')
elif name == "LogDebug":
LogDebugEnable = LogDetails.get('LogDebugEnable')
LogDebugFile = LogDetails.get('LogDebugFile')
LogDebugStdOutput = LogDetails.get('LogDebugStdOutput')
elif name == "LogStats":
LogStatsEnable = LogDetails.get('LogStatsEnable')
LogStatsFILE = LogDetails.get('LogStatsFILE')
LogStatsStdOutput = LogDetails.get('LogStatsStdOutput')
elif name == "LogError":
LogErrorEnable = LogDetails.get('LogErrorEnable')
LogErrorFILE = LogDetails.get('LogErrorFILE')
LogErrorStdOutput = LogDetails.get('LogErrorStdOutput')
elif name == "path":
LogFilePath = LogDetails.get('LogFilePath')
elif name == "ExperimentNum":
ExperimentNumber = LogDetails.get('ExperimentNumber')
print(LogInfoEnable, LogInfoFile, LogInfoStdOutput, LogDebugEnable, LogDebugFile, LogDebugStdOutput, LogStatsEnable, LogStatsFILE, LogStatsStdOutput, LogErrorEnable, LogErrorFILE, LogErrorStdOutput, LogFilePath, ExperimentNumber)
filename = "../results/logs/" + "["+ExperimentNumber+"][MOBILITYANDUDM].txt"
LogFile = open(filename, "a")
# Creates a socket used by UDM to publish messages
def InitiatePubSocket():
global UDMPublisher
context = zmq.Context()
UDMPublisher = context.socket(zmq.PUB)
UDMPublisher.bind("tcp://"+str(ParserIP)+":"+str(int(UDMPort) + 1))
# Creates a socket used by UDM to send exit or termination messages
def InitiateExitPubSocket():
global UDMExitPublisher
context = zmq.Context()
UDMExitPublisher = context.socket(zmq.PUB)
UDMExitPublisher.bind("tcp://"+str(ParserIP)+":"+str(int(UDMPort) + 3))
# Parse config file to read parser and udm related details
def ReadConfigfile():
global ParserIP, ParserPort, UDMPort, SumoFloatingDataPath, CommRange, RunInForeGround, RunInForeGroundList, SystemsIP
print("Parsing config file ../config/common/config.xml")
tree = ET.parse('../config/common/config.xml')
root = tree.getroot()
for neighbor in root.iter('ParserIP'):
ParserIP = neighbor.get('ParserIP')
for neighbor in root.iter('ParserPort'):
ParserPort = neighbor.get('ParserPort')
for neighbor in root.iter('UDMPort'):
UDMPort = neighbor.get('UDMPort')
for neighbor in root.iter('SumoFloatingDataPath'):
SumoFloatingDataPath = neighbor.get('SumoFloatingDataPath')
for neighbor in root.iter('CommRange'):
CommRange = neighbor.get('CommRange')
for neighbor in root.iter('RunInForeGround'):
RunInForeGround = neighbor.get('RunInForeGround')
for neighbor in root.iter('RunInForeGroundList'):
RunInForeGroundList = neighbor.get('RunInForeGroundList')
for neighbor in root.iter('IPList'):
SystemsIP = ConvertStringToList(neighbor.get('IPList'))
print("Extracted values ParserIP = " + ParserIP + " ParserPort = " + ParserPort + " UDMPort = " + UDMPort
+ " SumoFloatingDataPath = " + SumoFloatingDataPath + " CommRange = " + CommRange + "RunInForeGround = " +
RunInForeGround + "RunInForeGroundList = " + RunInForeGroundList)
InitiatePubSocket()
InitiateExitPubSocket()
PrepareSystemResources()
updateLoggingUtilConfigParams()
def GetCurrentTime():
currentDT = datetime.datetime.now()
CurrentTime = str(currentDT.hour) + ":" + str(currentDT.minute) + ":" + str(currentDT.second) + "." + str(currentDT.microsecond / 1000)
return CurrentTime
def GetLogString(message):
LogString = "[" + GetCurrentTime() + "]["+ExperimentNumber+"][MOBILITYANDUDM][" + message + "]\n"
return LogString
def LogsFilewrite(message):
global LogFile
LogFile.write(GetLogString(message))
def LogsInfo(message):
global LogInfoEnable, LogInfoFile, LogInfoStdOutput
if LogInfoEnable == "TRUE":
if LogInfoFile == "TRUE":
LogsFilewrite(message)
if LogInfoStdOutput == "TRUE":
print(GetLogString(message))
def LogsDebug(message):
global LogDebugEnable, LogDebugFile, LogDebugStdOutput
if LogDebugEnable == "TRUE":
if LogDebugFile == "TRUE":
LogsFilewrite(message)
if LogDebugStdOutput == "TRUE":
print(GetLogString(message))
def LogsStats(message):
global LogStatsEnable, LogStatsFILE, LogStatsStdOutput
if LogStatsEnable == "TRUE":
if LogStatsFILE == "TRUE":
LogsFilewrite(message)
if LogStatsStdOutput == "TRUE":
print(GetLogString(message))
def LogsError(message):
global LogErrorEnable, LogErrorFILE, LogErrorStdOutput
if LogErrorEnable == "TRUE":
if LogErrorFILE == "TRUE":
LogsFilewrite(message)
if LogErrorStdOutput == "TRUE":
print(GetLogString(message))
def PrepareSystemResources():
global DistributedSystemsPublisher
context = zmq.Context()
DistributedSystemsPublisher = context.socket(zmq.PUB)
DistributedSystemsPublisher.bind("tcp://"+str(ParserIP)+":"+str(int(UDMPort) + 2))
# this is the main entry point of this script
if __name__ == "__main__":
print("here1")
global LogString, SystemsIP
#Uncomment when debugging is required
#sys.settrace(traceit)
ReadConfigfile()
print(SystemsIP)
run()
| 30,553 | 10,904 |
def partition(a, start, end):
pivot = a[start]
left = start + 1
right = end
met = False
# Iterate until i reaches j in the middle
while not met:
while left <= right and a[left] <= pivot:
left = left + 1
while right >= left and a[right] >= pivot:
right = right - 1
if left >= right:
met = True
else:
a[left], a[right] = a[right], a[left]
# Swap pivot with the position of j
a[start], a[right] = a[right], a[start]
return right
def quick_sort(li, l, r):
if l < r:
split = partition(li, l, r)
quick_sort(li, l, split - 1)
quick_sort(li, split + 1, r)
if __name__ == '__main__':
li = [65, 72, 23, 36, 99, 20, 1, 44]
# [8, 2, 5, 13, 4, 19, 12, 6, 3, 11, 10, 7, 9]
print("Unsorted list: ", li)
quick_sort(li, 0, len(li) - 1)
print("Sorted list: ", li)
| 879 | 410 |
"""
Copyright (c) 2021 Aiven Ltd
See LICENSE for details
Algorithms to help with redistributing parts across servers for tables using the
Replicated family of table engines.
This does not support shards, but this is the right place to add support for them.
"""
from astacus.common.ipc import SnapshotFile
from astacus.coordinator.plugins.clickhouse.escaping import escape_for_file_name
from pathlib import Path
from typing import Dict, Iterable, List, Optional, Set, Tuple
import dataclasses
import re
import uuid
@dataclasses.dataclass
class PartFile:
snapshot_file: SnapshotFile
servers: Set[int]
@dataclasses.dataclass
class Part:
files: Dict[Path, PartFile]
total_size: int
@dataclasses.dataclass(frozen=True)
class PartKey:
table_uuid: uuid.UUID
part_name: str
def group_files_into_parts(snapshot_files: List[List[SnapshotFile]],
table_uuids: Set[uuid.UUID]) -> Tuple[List[Part], List[List[SnapshotFile]]]:
"""
Regroup all files that form a MergeTree table parts together in a `Part`.
Only parts from the provided list of `table_uuids` are regrouped.
Returns the list of `Part` and a separate list of list of `SnapshotFile` that
were not selected to make a `Part`.
The input and output list of lists will have the same length: the number
of server in the cluster (the first list is for the first server, etc.)
"""
other_files: List[List[SnapshotFile]] = [[] for _ in snapshot_files]
keyed_parts: Dict[PartKey, Part] = {}
for server_index, server_files in enumerate(snapshot_files):
for snapshot_file in server_files:
if not add_file_to_parts(snapshot_file, server_index, table_uuids, keyed_parts):
other_files[server_index].append(snapshot_file)
return list(keyed_parts.values()), other_files
def add_file_to_parts(
snapshot_file: SnapshotFile, server_index: int, table_uuids: Set[uuid.UUID], parts: Dict[PartKey, Part]
) -> bool:
"""
If the `snapshot_file` is a file from a part of one of the tables listed in
`table_uuids`, add it to the corresponding Part in `parts`.
A file is from a part if its path starts with
"store/3_first_char_of_table_uuid/table_uuid/detached/part_name".
If a file already exists in a part, the `server_index` is added to the `server` set
of the `PartFile` for that file.
Raises a `ValueError` if a different file with the same name already exists in a
part: a `PartFile` must be the identical on all servers where it is present.
Returns `True` if and only if the file was added to a `Part`.
"""
path_parts = snapshot_file.relative_path.parts
has_enough_depth = len(path_parts) >= 6
if not has_enough_depth:
return False
has_store_and_detached = path_parts[0] == "store" and path_parts[3] == "detached"
has_uuid_prefix = path_parts[1] == path_parts[2][:3]
has_valid_uuid = re.match(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", path_parts[2])
if not (has_store_and_detached and has_uuid_prefix and has_valid_uuid):
return False
table_uuid = uuid.UUID(path_parts[2])
if table_uuid not in table_uuids:
return False
part_key = PartKey(table_uuid=table_uuid, part_name=path_parts[4])
part = parts.setdefault(part_key, Part(files={}, total_size=0))
part_file = part.files.get(snapshot_file.relative_path)
if part_file is None:
part.files[snapshot_file.relative_path] = PartFile(snapshot_file=snapshot_file, servers={server_index})
part.total_size += snapshot_file.file_size
elif part_file.snapshot_file.equals_excluding_mtime(snapshot_file):
part_file.servers.add(server_index)
else:
raise ValueError(
f"Inconsistent part file {snapshot_file.relative_path} of part {part_key} "
f"between servers {part_file.servers} and server {server_index}:\n"
f" {part_file.snapshot_file}\n"
f" {snapshot_file}"
)
return True
def check_parts_replication(parts: Iterable[Part]):
"""
Checks that within a single part, all files are present on the same set of servers.
"""
for part in parts:
part_servers: Optional[Set[int]] = None
for file_path, file in part.files.items():
if part_servers is None:
part_servers = file.servers
elif part_servers != file.servers:
raise ValueError(
f"Inconsistent part, not all files are identically replicated: "
f"some files are on servers {part_servers} while {file_path} is on servers {file.servers}"
)
def distribute_parts_to_servers(parts: List[Part], server_files: List[List[SnapshotFile]]):
"""
Distributes each part to only one of the multiple servers where the part was
during the backup.
Parts are distributed to each server such as the total download size for each
server is roughly equal (using a greedy algorithm).
"""
total_file_sizes = [0 for _ in server_files]
for part in sorted(parts, key=lambda p: p.total_size, reverse=True):
server_index = None
for file in part.files.values():
if server_index is None:
server_index = min(file.servers, key=total_file_sizes.__getitem__)
total_file_sizes[server_index] += file.snapshot_file.file_size
server_files[server_index].append(file.snapshot_file)
def get_frozen_parts_pattern(freeze_name: str) -> str:
"""
Returns the glob pattern inside ClickHouse data dir where frozen table parts are stored.
"""
escaped_freeze_name = escape_for_file_name(freeze_name)
return f"shadow/{escaped_freeze_name}/store/**/*"
| 5,787 | 1,819 |
# -*- coding: utf-8 -*-
# This file is part of the Rocket Web Server
# Copyright (c) 2012 Timothy Farrell
#
# See the included LICENSE.txt file for licensing details.
# Import System Modules
import sys
import unittest
# Import Custom Modules
import rocket
# Define Constants
PY3K = sys.version_info[0] > 2
# Define Tests
class RocketInitTest(unittest.TestCase):
def testMembers(self):
members = ["VERSION", "SERVER_NAME", "SERVER_SOFTWARE", "HTTP_SERVER_SOFTWARE", "BUF_SIZE", "IS_JYTHON", "IGNORE_ERRORS_ON_CLOSE", "DEFAULT_LISTEN_QUEUE_SIZE", "DEFAULT_MIN_THREADS", "DEFAULT_MAX_THREADS", "DEFAULTS", "PY3K", "u", "b", "Rocket", "CherryPyWSGIServer"]
for m in members:
self.assertTrue(hasattr(rocket, m),
msg="rocket module does not have %s" % m)
def testUnicode(self):
if PY3K:
self.skipTest("Not a valid test in Python 3")
self.assertEqual(rocket.u('abc'), eval("u'abc'"))
self.assertEqual(type(rocket.u('abc')), type(eval("u'abc'")))
def testBytes(self):
if PY3K:
self.skipTest("Not a valid test in Python 3")
self.assertEqual(rocket.b('abc'), 'abc')
self.assertEqual(type(rocket.b('abc')), type('abc'))
if __name__ == '__main__':
unittest.main()
| 1,301 | 464 |
from setuptools import setup
setup(
name='Unet',
version='',
packages=['models'],
url='',
license='',
author='hemanth sharma',
author_email='',
description=''
)
| 206 | 69 |
import pygame
from side_scroller.constants import BLACK
from side_scroller.settings import GameSettings, Fonts
from side_scroller.player import Player, Hitbox
from side_scroller.constants import GAME_NAME
class Game():
def __init__(self):
self.player = Player(0, Player.y_bottom_barrier)
self.screen = pygame.display.set_mode((GameSettings.width, GameSettings.height))
self.game_fps = GameSettings.minFps
self.fps_clock = pygame.time.Clock()
self.fps_over_min = 1
self.per_loop_adjustment = 1
self.neutral_count = 0
self.obstacles = list()
self.initialize_game()
def initialize_game(self):
pygame.init()
pygame.display.set_caption(GAME_NAME)
self.initialize_background()
def initialize_background(self):
self.screen.blit(GameSettings.background.image, GameSettings.background.rect)
def refresh_player_location_background(self):
self.screen.blit(GameSettings.background.image, self.player.rect, self.player.rect)
def update_score_hud(self):
score_text = Fonts.hud_font.render(
f"Score: {int(self.player.score.score)}", True, BLACK
)
self.screen.blit(
GameSettings.background.image,
score_text.get_rect(),
score_text.get_rect())
self.screen.blit(score_text, score_text.get_rect())
def update_high_score(self):
self.player.adjust_high_scores()
def prepare_new_game(self):
self.player.prepare_new_game()
self.obstacles = list()
self.initialize_background()
self.neutral_count = 0
def set_current_fps_over_min_fps(self):
self.fps_over_min = self.game_fps / GameSettings.minFps
def set_per_loop_adjustment(self):
self.per_loop_adjustment = GameSettings.minFps / self.game_fps
def is_hover_limit_reached(self):
return self.neutral_count > GameSettings.hoverLimit * self.fps_over_min
def increase_count_to_obstacle_tick(self):
self.player.score.countToObstacleTick += self.per_loop_adjustment
def increase_count_to_level_tick(self):
self.player.score.countToLevelTick += self.per_loop_adjustment
def tick_game_fps_clock(self):
self.fps_clock.tick(self.game_fps)
def get_obstacles_in_player_path_y(self) -> list:
"""
Returns a list of obstacles that could be hit if the player moved along y axis.
"""
player_path_y = Hitbox(
pygame.Rect(
0,
0,
self.player.width,
10000
),
"neutral"
)
return pygame.sprite.spritecollide(player_path_y, self.obstacles, False)
| 2,757 | 883 |
def get_min_drops(N, k):
if N == 0 or N == 1 or k == 1:
return N
possibilities = list()
for i in range(1, N + 1):
possibilities.append(
max(get_min_drops(i-1, k-1),
get_min_drops(N-i, k))
)
return min(possibilities) + 1
# Tests
assert get_min_drops(20, 2) == 6
assert get_min_drops(15, 3) == 5
| 366 | 155 |
#coding=utf-8
import sys, os
import socket
import hashlib
import virus_total_apis
from PyQt4 import QtCore
sys.path.append("..")
from publicfunc.fileanalyze import PEFileAnalize, getFileInfo
class UploadFile(QtCore.QThread):
finishSignal = QtCore.pyqtSignal(int, tuple)
'''
@文件名
@用户公钥
'''
def __init__(self, filename, apikey, parent=None):
super(UploadFile, self).__init__(parent)
self.filename = str(filename)#.encode('cp936')
self.apikey = apikey
print self.filename
'''
检查网络，后期转移至common功能
'''
def checkInternet(self):
try:
host = socket.gethostbyname("www.virustotal.com")
s = socket.create_connection((host, 80), 2)
print "internet ok"
return True
except:
print "internet err"
return False
'''
virustotal api函数
解析json文件内容
@apikey:用户公钥
返回响应代码及检测结果
'''
def virustotalApi(self, apikey):
key = apikey
result = []
result1 = [] # 检测到的引擎
result2 = [] # 未检测到的引擎
vt = virus_total_apis.PublicApi(key)
md5 = hashlib.md5(open(self.filename, 'rb').read()).hexdigest()
response = vt.get_file_report(md5)
# print response # 所有结果
print response["response_code"] # 网络响应码
if 204 == response["response_code"]: # 超出上传频率
print "204"
return ("http_code", "", response["response_code"], "")
response_code_ = response["results"]["response_code"]
# print response_code_ # 返回信息响应代码
if 1 == response_code_:
# 解析json回传内容
# 先显示报毒的引擎
for n in response["results"]["scans"]:
if response["results"]["scans"][n]["detected"]:
result1.append("{} ^ {}".format(n, response["results"]["scans"][n]["result"]))
else:
result2.append("{} ^ {}".format(n, response["results"]["scans"][n]["result"]))
result = sorted(result1, key=str.lower) + sorted(result2, key=str.lower)
elif -2 == response_code_:
pass
else:
response = vt.scan_file(self.filename) # 32M limit
if response["results"]["verbose_msg"]:
result.append(response["results"]["verbose_msg"])
else:
result.append(response["results"]["permalink"])
if 1 == response_code_:
return ("scan_result", result, response["response_code"], response_code_)
else:
return ("permalink", result, response["response_code"], response_code_)
# return ("scan_result", result, "http", response["response_code"], "code", response_code_)
# if response_code_ is 1 else ("permalink", result, "http", response["response_code"], "code", response_code_)
# print ("scan_result", result) if response_code_ is 1 else ("permalink", result)
def run(self):
print "run"
useless, baseinfo = getFileInfo(self.filename)
infos = ("baseinfo", baseinfo)
self.finishSignal.emit(2, infos)
ret = self.checkInternet()
if not ret:
self.finishSignal.emit(3, tuple(['网络连接失败...']))
return
msg = self.virustotalApi(self.apikey)
self.finishSignal.emit(1, msg)
class AddFileToQqueu(QtCore.QThread):
def __init__(self, filename, parent=None):
super(AddFileToQqueu, self).__init__(parent)
self.filename = filename
def run(self):
pass | 3,525 | 1,182 |
import smtplib
server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls()
server.login("tt0815550@gmail.com", "AureliaK1609")
msg = "YOUR MESSAGE!"
server.sendmail("e.kaczmarek01@gmail.com", "tt0815550@gmail.com", msg)
server.quit()
| 240 | 117 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import string
class Caesar(object):
def __init__(self):
self.ALPHABET = string.ascii_letters
def character_type(self, character):
""" Returns the alphabet box """
if character.isupper():
return string.ascii_uppercase
return string.ascii_lowercase
def encrypt(self, text: str, key: int) -> str:
""" Returns the encrypted text """
ENCRYPT_TEXT = ""
for letter in text:
if letter in self.ALPHABET:
alphabet = self.character_type(letter)
index = alphabet.index(letter) + key
ENCRYPT_TEXT += alphabet[index % len(alphabet)]
if letter not in self.ALPHABET:
ENCRYPT_TEXT += letter
return ENCRYPT_TEXT
def decrypt(self, cipher: str, key: int) -> str:
""" Returns the decrypted text """
DECRYPT_TEXT = ""
for letter in cipher:
if letter in self.ALPHABET:
alphabet = self.character_type(letter)
index = alphabet.index(letter) - key
DECRYPT_TEXT += alphabet[index % len(alphabet)]
if letter not in self.ALPHABET:
DECRYPT_TEXT += letter
return DECRYPT_TEXT
| 1,450 | 398 |
# Informe um nº e mostre sua tabuada
print('-' * 36)
n = int(input('Digite um nº e veja sua tabuada: '))
print('=' * 36)
for i in range(1, 11):
print(n, 'x', i, '=', n * i)
print('=' * 36)
| 193 | 95 |
"""
Split: dividir string
Join: juntar uma lista (str)
Enumerate: enumerar elementos da lista (iteráveis)
"""
string ='O Brasil é o pais do futebol, o Brasil é penta.'
lista_1 = string.split(' ')
lista_2 = string.split(',')
print(lista_1)
print(lista_2)
palavra = ''
contagem = 0
for valor in lista_1:
print(f'A palavra {valor} apareceu {lista_1.count(valor)}x na frase')
qtd_vezes = lista_1.count(valor)
if qtd_vezes > contagem:
contagem = qtd_vezes | 473 | 183 |
import pytest
from commitizen import cmd
@pytest.fixture(scope="function")
def tmp_git_project(tmpdir):
with tmpdir.as_cwd():
cmd.run("git init")
yield tmpdir
@pytest.fixture(scope="function")
def tmp_commitizen_project(tmp_git_project):
with tmp_git_project.as_cwd():
tmp_commitizen_cfg_file = tmp_git_project.join("pyproject.toml")
tmp_commitizen_cfg_file.write("[tool.commitizen]\n" 'version="0.1.0"\n')
yield tmp_git_project
| 484 | 172 |
list = [3, 4]
"{3}".format(*[1, 2, *list])
"{4}".format(*[1, 2, *list])
"{1}".format(*[1, 2, *list])
"{3}".format(*[*list, 1, 2])
"{4}".format(*[*list, 1, 2])
"{1}".format(*[*list, 1, 2]) | 188 | 115 |
import sys
import re
from typing import Any, Optional, IO, Sequence
from argparse import ArgumentParser as CoreArgumentParser, Namespace, _SubParsersAction
from .markdown import MarkdownFormatter, MarkdownHelpAction
from .bashcompletion import BashCompletionAction, hook as bashcompletion_hook
ArgumentSubParser = _SubParsersAction
class ArgumentParser(CoreArgumentParser):
def __init__(self, markdown_help: bool = False, bash_completion: bool = False, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
self.markdown_help = markdown_help
self.bash_completion = bash_completion
if self.markdown_help:
self.add_argument('--md-help', action=MarkdownHelpAction)
if self.bash_completion:
self.add_argument('--bash-completion', action=BashCompletionAction)
self._optionals.title = 'optional arguments'
def error_no_help(self, message: str) -> None:
sys.stderr.write('{}: error: {}\n'.format(self.prog, message))
sys.exit(2)
def print_help(self, file: Optional[IO[str]] = None) -> None:
'''Hook to make help more command line friendly, if there is markdown markers in the text.
'''
if not self.markdown_help:
super().print_help(file)
return
if self.formatter_class is not MarkdownFormatter:
original_description = self.description
original_actions = self._actions
# code block "markers" are not really nice to have in cli help
if self.description is not None:
self.description = '\n'.join([line for line in self.description.split('\n') if '```' not in line])
self.description = self.description.replace('\n\n', '\n')
for action in self._actions:
if action.help is not None:
# remove any markdown link markers
action.help = re.sub(r'\[([^\]]*)\]\([^\)]*\)', r'\1', action.help)
super().print_help(file)
if self.formatter_class is not MarkdownFormatter:
self.description = original_description
self._actions = original_actions
def parse_args(self, args: Optional[Sequence[str]] = None, namespace: Optional[Namespace] = None) -> Namespace: # type: ignore
'''Hook to add `--bash-complete` to all parsers, if enabled for parser.
'''
if self.bash_completion:
bashcompletion_hook(self)
return super().parse_args(args, namespace)
| 2,547 | 700 |
from flask import Flask, render_template, request, redirect,Blueprint, json, url_for, session
from modules import dataBase,usuario
import psycopg2, os, subprocess, bcrypt
#
#def getData():
# DATABASE_URL = os.environ['DATABASE_URL']
# con = psycopg2.connect(DATABASE_URL, sslmode='require')
# return con
### connect to the dataBase
DATABASE_URL = os.environ['DATABASE_URL']
connectionData = dataBase.dataAccess()
####
###Usuario
usersDataOnline = usuario.acessManager()
#userData = usuario.acessoUser()
###
| 524 | 181 |
import plistlib
from pathlib import Path
from datetime import datetime, timezone, timedelta
class Validate:
"""
Validate an unpacked .ipa file in various ways
The following rules are enforced. All are treated as errors, except as noted:
req-001: The root must contain a sub-directory called 'Payload'
req-002: Payload must contain a single .app sub-directory
req-003: The .app root must contain an Info.plist file
req-004: The application-identifier prefix from the provisioning profile Entitlements section must match one of
the values in the ApplicationIdentifierPrefix array
req-005: WARNING: Should warn if the provisioning profile has expired
req-006: The app id from the Entitlements section must match the app id from Info.plist, taking wildcards into account.
req-007: Executable files should be in the correct format for iOS devices (armv7, armv7s, arm64, etc)
"""
def __init__(self, dest_path) -> None:
"""
__init__
:param dest_path: The path to the unpacked .ipa file (location of the Payload folder)
"""
super().__init__()
self._root_path = Path(dest_path)
self._payload_path = None
self._app_dir = None
self._plist_file = None
self._bundle_id = None
self._executable_file = None
@property
def app_dir(self):
return self._app_dir
@property
def executable_name(self):
return self._executable_file
@property
def executable_path(self):
return self._app_dir / self._executable_file
def validate_structure(self):
"""
Validates the basic structure of an .ipa file
:return:
"""
# req-001
self._payload_path = self._root_path / 'Payload'
if not self._payload_path.is_dir():
raise Exception("Root Payload path not found")
# req-002
app_dirs = sorted(self._payload_path.glob('*.app'))
if len(app_dirs) == 0:
raise Exception("No .app directories found within Payload")
if len(app_dirs) > 1:
raise Exception("Multiple .app directories found within Payload")
for dir1 in app_dirs:
if not dir1.is_dir():
raise Exception("{0} is not a directory".format(dir1))
# req-003
self._app_dir = dir1
print('Found app: {0}'.format(dir1))
self._plist_file = self._app_dir / 'Info.plist'
if not self._plist_file.is_file():
raise Exception("Info.plist file was not found in the app bundle")
def extract_plist(self):
"""
Extracts information from the Info.plist file
:return: Dictionary representation of Info.plist contents
"""
with self._plist_file.open('rb') as plist_fp:
p_dict = plistlib.load(plist_fp)
self._bundle_id = p_dict.get('CFBundleIdentifier')
self._executable_file = p_dict.get('CFBundleExecutable')
return p_dict
def extract_provisioning_plist(self, embedded_prov_plist_path):
"""
Extracts information from the Info.plist file
:param embedded_prov_plist_path: Full path to the plist file which is embedded in the provisioning profile
:return: Dictionary representation of embedded.mobileprovision contents
"""
with embedded_prov_plist_path.open('rb') as plist_fp:
p_dict = plistlib.load(plist_fp)
return p_dict
def validate_provisioning_plist(self, plist_dict):
"""
Validate the embedded provisioning plist which was extracted in a previous step.
:param plist_dict: Dictionary representation of the embedded.mobileprovision file
:return: None
"""
app_id_prefix_array = plist_dict['ApplicationIdentifierPrefix']
entitlements_dict = plist_dict['Entitlements']
app_identifier_raw = entitlements_dict.get('application-identifier')
ix = app_identifier_raw.find('.')
if ix >= 0:
app_identifier_prefix = app_identifier_raw[:ix]
app_id = app_identifier_raw[ix+1:]
else:
app_identifier_prefix = app_identifier_raw
app_id = ''
get_task_allow = entitlements_dict.get('get-task-allow')
keychain_groups = entitlements_dict.get('keychain-access-groups')
# req-004
if app_identifier_prefix not in app_id_prefix_array:
raise Exception('The entitlements application-identifier {0} does not match any of the given app id prefixes'.format(app_identifier_prefix))
# req-005
exp_date = plist_dict['ExpirationDate']
now = datetime.now()
if exp_date < now:
print('The embedded provisioning profile has expired on {0}'.format(exp_date))
# req-006
self._validate_app_id(self._bundle_id, app_id)
def _validate_app_id(self, app_id_from_info_plist, app_id_from_provisioning_file):
"""
Validate the app ids from the Info.plist and provisioning profile to see if they match, taking wildcards into account.
Examples:
com.acme.app1, com.acme.app1 => match
com.acme.app1, com.acme.app2 => fail
com.acme.app1, com.acme.* => match
com.acme.app1, * => match
:param app_id_from_info_plist: Full appid from the Info.plist file, ex: com.acme.app1
:param app_id_from_provisioning_file: App id (possibly wildcard) from the provisioning profile
:return: None
"""
has_wildcard = False
ix = app_id_from_provisioning_file.find('*')
if ix >= 0:
has_wildcard = True
match_app_id = app_id_from_provisioning_file[:ix]
else:
match_app_id = app_id_from_provisioning_file
if has_wildcard:
wc_len = len(match_app_id)
match = (app_id_from_info_plist[:ix] == match_app_id)
else:
match = (app_id_from_info_plist == match_app_id)
if not match:
raise Exception('Bundle ID does not match app ID from provisioning profile: {0}'.format(app_id_from_provisioning_file))
| 6,192 | 1,844 |
import pandas
import rtree
import networkx
import numpy as np
import cv2
from skimage.measure import regionprops
from merlin.core import analysistask
from merlin.util import imagefilters
class SumSignal(analysistask.ParallelAnalysisTask):
"""
An analysis task that calculates the signal intensity within the boundaries
of a cell for all rounds not used in the codebook, useful for measuring
RNA species that were stained individually.
"""
def __init__(self, dataSet, parameters=None, analysisName=None):
super().__init__(dataSet, parameters, analysisName)
if 'apply_highpass' not in self.parameters:
self.parameters['apply_highpass'] = False
if 'highpass_sigma' not in self.parameters:
self.parameters['highpass_sigma'] = 5
if 'z_index' not in self.parameters:
self.parameters['z_index'] = 0
if self.parameters['z_index'] >= len(self.dataSet.get_z_positions()):
raise analysistask.InvalidParameterException(
'Invalid z_index specified for %s. (%i > %i)'
% (self.analysisName, self.parameters['z_index'],
len(self.dataSet.get_z_positions())))
self.highpass = str(self.parameters['apply_highpass']).upper() == 'TRUE'
self.alignTask = self.dataSet.load_analysis_task(
self.parameters['global_align_task'])
def fragment_count(self):
return len(self.dataSet.get_fovs())
def get_estimated_memory(self):
return 2048
def get_estimated_time(self):
return 1
def get_dependencies(self):
return [self.parameters['warp_task'],
self.parameters['segment_task'],
self.parameters['global_align_task']]
def _extract_signal(self, cells, inputImage, zIndex) -> pandas.DataFrame:
cellCoords = []
for cell in cells:
regions = cell.get_boundaries()[zIndex]
if len(regions) == 0:
cellCoords.append([])
else:
pixels = []
for region in regions:
coords = region.exterior.coords.xy
xyZip = list(zip(coords[0].tolist(), coords[1].tolist()))
pixels.append(np.array(
self.alignTask.global_coordinates_to_fov(
cell.get_fov(), xyZip)))
cellCoords.append(pixels)
cellIDs = [str(cells[x].get_feature_id()) for x in range(len(cells))]
mask = np.zeros(inputImage.shape, np.uint8)
for i, cell in enumerate(cellCoords):
cv2.drawContours(mask, cell, -1, i+1, -1)
propsDict = {x.label: x for x in regionprops(mask, inputImage)}
propsOut = pandas.DataFrame(
data=[(propsDict[k].intensity_image.sum(),
propsDict[k].filled_area)
if k in propsDict else (0, 0)
for k in range(1, len(cellCoords) + 1)],
index=cellIDs,
columns=['Intensity', 'Pixels'])
return propsOut
def _get_sum_signal(self, fov, channels, zIndex):
fTask = self.dataSet.load_analysis_task(self.parameters['warp_task'])
sTask = self.dataSet.load_analysis_task(self.parameters['segment_task'])
cells = sTask.get_feature_database().read_features(fov)
signals = []
for ch in channels:
img = fTask.get_aligned_image(fov, ch, zIndex)
if self.highpass:
highPassSigma = self.parameters['highpass_sigma']
highPassFilterSize = int(2 * np.ceil(3 * highPassSigma) + 1)
img = imagefilters.high_pass_filter(img,
highPassFilterSize,
highPassSigma)
signals.append(self._extract_signal(cells, img,
zIndex).iloc[:, [0]])
# adding num of pixels
signals.append(self._extract_signal(cells, img, zIndex).iloc[:, [1]])
compiledSignal = pandas.concat(signals, 1)
compiledSignal.columns = channels+['Pixels']
return compiledSignal
def get_sum_signals(self, fov: int = None) -> pandas.DataFrame:
"""Retrieve the sum signals calculated from this analysis task.
Args:
fov: the fov to get the sum signals for. If not specified, the
sum signals for all fovs are returned.
Returns:
A pandas data frame containing the sum signal information.
"""
if fov is None:
return pandas.concat(
[self.get_sum_signals(fov) for fov in self.dataSet.get_fovs()]
)
return self.dataSet.load_dataframe_from_csv(
'sequential_signal', self.get_analysis_name(),
fov, 'signals', index_col=0)
def _run_analysis(self, fragmentIndex):
zIndex = int(self.parameters['z_index'])
channels, geneNames = self.dataSet.get_data_organization()\
.get_sequential_rounds()
fovSignal = self._get_sum_signal(fragmentIndex, channels, zIndex)
normSignal = fovSignal.iloc[:, :-1].div(fovSignal.loc[:, 'Pixels'], 0)
normSignal.columns = geneNames
self.dataSet.save_dataframe_to_csv(
normSignal, 'sequential_signal', self.get_analysis_name(),
fragmentIndex, 'signals')
class ExportSumSignals(analysistask.AnalysisTask):
def __init__(self, dataSet, parameters=None, analysisName=None):
super().__init__(dataSet, parameters, analysisName)
def get_estimated_memory(self):
return 2048
def get_estimated_time(self):
return 5
def get_dependencies(self):
return [self.parameters['sequential_task']]
def _run_analysis(self):
sTask = self.dataSet.load_analysis_task(
self.parameters['sequential_task'])
signals = sTask.get_sum_signals()
self.dataSet.save_dataframe_to_csv(
signals, 'sequential_sum_signals',
self.get_analysis_name())
| 6,183 | 1,803 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from nornir.core.task import Task
from netests import log
from netests.tools.file import open_file
from netests.protocols.facts import Facts
from netests.select_vars import select_host_vars
from netests.comparators.log_compare import log_compare, log_no_yaml_data
from netests.constants import NOT_SET, FACTS_WORKS_KEY, FACTS_DATA_HOST_KEY
from netests.exceptions.netests_exceptions import (
NetestsOverideTruthVarsKeyUnsupported
)
def _compare_transit_facts(task, options={}):
task.host[FACTS_WORKS_KEY] = _compare_facts(
host_keys=task.host.keys(),
hostname=task.host.name,
groups=task.host.groups,
facts_host_data=task.host.get(FACTS_DATA_HOST_KEY, None),
test=False,
options=options,
task=task
)
return task.host[FACTS_WORKS_KEY]
def _compare_facts(
host_keys,
hostname: str,
groups: list,
facts_host_data: Facts,
test=False,
options={},
task=Task
) -> bool:
if (
'own_vars' in options.keys() and
options.get('own_vars') is not None and
'enable' in options.get('own_vars').keys() and
options.get('own_vars').get('enable') is True
):
raise NetestsOverideTruthVarsKeyUnsupported()
else:
if test:
facts_yaml_data = open_file(
path="tests/features/src/facts_tests.yml"
).get(hostname)
else:
facts_yaml_data = select_host_vars(
hostname=hostname,
groups=groups,
protocol="facts"
)
log.debug(
"FACTS_DATA_HOST_KEY in host_keys="
f"{FACTS_DATA_HOST_KEY in host_keys}\n"
"facts_yaml_data is not None="
f"{facts_yaml_data is not None}"
)
if (
FACTS_DATA_HOST_KEY in host_keys and
facts_yaml_data is not None
):
verity_facts = Facts(
hostname=hostname,
domain=facts_yaml_data.get('domain', NOT_SET),
version=facts_yaml_data.get('version', NOT_SET),
build=facts_yaml_data.get('build', NOT_SET),
serial=facts_yaml_data.get('serial', NOT_SET),
base_mac=facts_yaml_data.get('serial', NOT_SET),
memory=facts_yaml_data.get('memory', NOT_SET),
vendor=facts_yaml_data.get('vendor', NOT_SET),
model=facts_yaml_data.get('model', NOT_SET),
interfaces_lst=facts_yaml_data.get('interfaces', list()),
options=facts_host_data.options
)
log_compare(verity_facts, facts_host_data, hostname, groups)
return verity_facts == facts_host_data
else:
log_no_yaml_data(
"facts",
FACTS_DATA_HOST_KEY,
"FACTS_DATA_HOST_KEY",
hostname,
groups
)
return True
| 3,012 | 950 |
#おまじない
from tkinter import Tk, Button, X, Frame, GROOVE, W, E, Label, Entry, END
import numpy as np
import os
from matplotlib import pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
# プロットする関数
def graph(data):
# 大きさ(6,3)のグラフを生成する
fig = plt.Figure(figsize=(6,3))
ax1 = fig.add_subplot(111)
# もらったデータをプロットする。
ax1.plot(data)
# グラフの描画
canvas = FigureCanvasTkAgg(fig, frame_3)
canvas.draw()
canvas.get_tk_widget().grid(row=1, column=0)
return fig
# 入力フォームの保存
def plot():
# 入力フォームを読み込む
a = box1.get()
b = box2.get()
c = box3.get()
# 表形式に変換
result = []
result.append(int(a))
result.append(int(b))
result.append(int(c))
# 描画関数にデータを渡す
graph(result)
#おまじない ↓ここから本文
if __name__ == '__main__':
# tkinter定義
root = Tk()
# ボタン1
frame_1 = Frame(root, bd=4, relief=GROOVE) #ボタン1の定義
frame_1.grid(row=0, column=0) #ボタン1の位置
btn1 = Button(frame_1, text='描画', command=plot, font=("",20)) #ボタン1が押されたときの処理
btn1.pack(fill=X) #ボタン1設置
# グラフ
frame_3 = Frame(root, bd=4, relief=GROOVE) #ボタン1の定義
frame_3.grid(row=1, column=0)
canvas = FigureCanvasTkAgg(graph([]), frame_3)
# 入力フォーム
box1 = Entry(width=3) #入力フォームの定義
box1.place(x=20, y=5) #入力フォームの位置
box2 = Entry(width=3) #入力フォームの定義
box2.place(x=50, y=5) #入力フォームの位置
box3 = Entry(width=3) #入力フォームの定義
box3.place(x=80, y=5) #入力フォームの位置
# tkinter作動
root.mainloop() | 1,579 | 833 |
# coding=utf-8
"""
"""
from . import mutation
from . import crossover
from . import base
class BinaryGA(base.GeneticAlgorithm):
"""A binary encoded genetic algorithm."""
def num_bits(self):
"""Return the number of bits used by the encoding scheme.
Returns:
int: The number of bits used by the encoding scheme.
"""
raise NotImplementedError
def mutate(self, chromosome):
"""Use toggle (bit inversion) mutation on a chromosome."""
return mutation.toggle(chromosome, self.num_bits(), self.mutation_prob)
class ValueGA(base.GeneticAlgorithm):
"""A list encoded genetic algorithm."""
def get_value(self):
"""Retrieve a valid allele value at random."""
raise NotImplementedError
def mutate(self, chromosome):
return mutation.point(chromosome, self.get_value, self.mutation_prob)
class ListGA(ValueGA):
"""A list encoded genetic algorithm."""
def mutate(self, chromosome):
return mutation.heterogeneous_length(chromosome, self.get_value,
self.mutation_prob)
class PermutationGA(base.GeneticAlgorithm):
"""A permutation encoded genetic algorithm."""
def mutate(self, chromosome):
return mutation.swap(chromosome, self.mutation_prob)
| 1,326 | 393 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import logging
import os
# TODO: Remove entirely if you don't register GStreamer elements below
import pygst
pygst.require('0.10')
import gst
import gobject
from mopidy import config, ext
__version__ = '0.1.0'
# TODO: If you need to log, use loggers named after the current Python module
logger = logging.getLogger(__name__)
class Extension(ext.Extension):
dist_name = 'Mopidy-Monobox'
ext_name = 'monobox'
version = __version__
def get_default_config(self):
conf_file = os.path.join(os.path.dirname(__file__), 'ext.conf')
return config.read(conf_file)
def get_config_schema(self):
schema = super(Extension, self).get_config_schema()
schema['serial_port'] = config.String()
schema['serial_bps'] = config.Integer()
schema['shuffle'] = config.Boolean()
schema['only_playlists'] = config.List(optional=True)
schema['cue_feature'] = config.Boolean()
schema['pulses_trigger'] = config.Integer()
return schema
def setup(self, registry):
from .frontend import MonoboxFrontend
registry.add('frontend', MonoboxFrontend)
| 1,230 | 384 |
"""Farmer class tests.
:author: Someone
:email: someone@pnnl.gov
License: BSD 2-Clause, see LICENSE and DISCLAIMER files
"""
import unittest
from im3agents import FarmerOne
class TestFarmers(unittest.TestCase):
def test_farmerone(self):
error_min_age = FarmerOne(age=-1)
error_max_age = FarmerOne(age=151)
valid = FarmerOne(age=32)
# expect value errors for exceeding min and max
with self.assertRaises(ValueError):
error_min_age.age
with self.assertRaises(ValueError):
error_max_age.age
# expect valid age
self.assertEqual(valid.age, 32)
if __name__ == '__main__':
unittest.main()
| 698 | 249 |
from tool.runners.python import SubmissionPy
WHITE = 0
BLACK = 1
DIRECTIONS = {
"e": (-1, 0), # (x, y) with axes right/bottom
"se": (-0.5, 1),
"sw": (0.5, 1),
"w": (1, 0),
"nw": (0.5, -1),
"ne": (-0.5, -1),
}
class ThChSubmission(SubmissionPy):
def run(self, s):
flipped_tiles = {}
for line in s.split("\n"):
i = 0
x, y = (0, 0) # ref
while i < len(line):
if line[i] == "s" or line[i] == "n":
direction = line[i : i + 2]
i += 2
else:
direction = line[i]
i += 1
dx, dy = DIRECTIONS[direction]
x += dx
y += dy
flipped_tiles[(x, y)] = (flipped_tiles.get((x, y), WHITE) + 1) % 2
return sum(tile == BLACK for tile in flipped_tiles.values())
def test_th_ch():
"""
Run `python -m pytest ./day-24/part-1/th-ch.py` to test the submission.
"""
assert (
ThChSubmission().run(
"""
seeswwswswwnenewsewsw
neeenesenwnwwswnenewnwwsewnenwseswesw
seswneswswsenwwnwse
nwnwneseeswswnenewneswwnewseswneseene
swweswneswnenwsewnwneneseenw
eesenwseswswnenwswnwnwsewwnwsene
sewnenenenesenwsewnenwwwse
wenwwweseeeweswwwnwwe
wsweesenenewnwwnwsenewsenwwsesesenwne
neeswseenwwswnwswswnw
nenwswwsewswnenenewsenwsenwnesesenew
enewnwewneswsewnwswenweswnenwsenwsw
sweneswneswneneenwnewenewwneswswnese
swwesenesewenwneswnwwneseswwne
enesenwswwswneneswsenwnewswseenwsese
wnwnesenesenenwwnenwsewesewsesesew
nenewswnwewswnenesenwnesewesw
eneswnwswnwsenenwnwnwwseeswneewsenese
neswnwewnwnwseenwseesewsenwsweewe
wseweeenwnesenwwwswnew
""".strip()
)
== 10
)
| 1,744 | 733 |
n = int(input())
l1 = list()
l2 = list()
for _ in range(n):
t, v = input().split()
l1.append(int(t))
l2.append(float(v))
result = 0
for i in range(len(l1) - 1):
result += ((l2[i] + l2[i + 1]) / 2) * (l1[i + 1] - l1[i])
print(result / 1000)
| 259 | 133 |
__version__ = '3.1.0rc1'
__license__ = "Apache Software License"
| 66 | 28 |
n = int(input())
a, l, p = map(int, input().split())
if a >= n and l >= n and p >= n:
print("S")
else:
print("N") | 126 | 56 |
"""----------------------------------------------------------------------------
This is the core of the parsing stage:
*re_find comments will search for everything between the $$ and EOL
*re_findDataLabels will search for everything between the start of a tag
(##) and the start of the next tag ignoring the contents of next tag,
while grouping into tag name and tag contents
----------------------------------------------------------------------------"""
re_findComments = r'\$\$[\s\S]*?(?=\n)'
re_findBlocks = r'(##TITLE\=[\W\w]*?##END=)'
re_findDataLabels = r'##([\w\W]*?)=([\w\W]*?(?=\n##[\w\W]))'
FILE = True
DIR = False
| 643 | 183 |
# This is a lightweight ML agent trained by self-play.
# After sharing this notebook,
# we will add Hungry Geese environment in our HandyRL library.
# https://github.com/DeNA/HandyRL
# We hope you enjoy reinforcement learning!
import pickle
import bz2
import base64
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# Neural Network for Hungry Geese
class TorusConv2d(nn.Module):
def __init__(self, input_dim, output_dim, kernel_size, bn):
super().__init__()
self.edge_size = (kernel_size[0] // 2, kernel_size[1] // 2)
self.conv = nn.Conv2d(input_dim, output_dim, kernel_size=kernel_size)
self.bn = nn.BatchNorm2d(output_dim) if bn else None
def forward(self, x):
h = torch.cat([x[:,:,:,-self.edge_size[1]:], x, x[:,:,:,:self.edge_size[1]]], dim=3)
h = torch.cat([h[:,:,-self.edge_size[0]:], h, h[:,:,:self.edge_size[0]]], dim=2)
h = self.conv(h)
h = self.bn(h) if self.bn is not None else h
return h
class GeeseNet(nn.Module):
def __init__(self):
super().__init__()
layers, filters = 12, 32
self.conv0 = TorusConv2d(17, filters, (3, 3), True)
self.blocks = nn.ModuleList([TorusConv2d(filters, filters, (3, 3), True) for _ in range(layers)])
self.head_p = nn.Linear(filters, 4, bias=False)
self.head_v = nn.Linear(filters * 2, 1, bias=False)
def forward(self, x):
h = F.relu_(self.conv0(x))
for block in self.blocks:
h = F.relu_(h + block(h))
h_head = (h * x[:,:1]).view(h.size(0), h.size(1), -1).sum(-1)
h_avg = h.view(h.size(0), h.size(1), -1).mean(-1)
p = self.head_p(h_head)
v = torch.tanh(self.head_v(torch.cat([h_head, h_avg], 1)))
return {'policy': p, 'value': v}
# Input for Neural Network
def make_input(obses):
b = np.zeros((17, 7 * 11), dtype=np.float32)
obs = obses[-1]
for p, pos_list in enumerate(obs['geese']):
# head position
for pos in pos_list[:1]:
b[0 + (p - obs['index']) % 4, pos] = 1
# tip position
for pos in pos_list[-1:]:
b[4 + (p - obs['index']) % 4, pos] = 1
# whole position
for pos in pos_list:
b[8 + (p - obs['index']) % 4, pos] = 1
# previous head position
if len(obses) > 1:
obs_prev = obses[-2]
for p, pos_list in enumerate(obs_prev['geese']):
for pos in pos_list[:1]:
b[12 + (p - obs['index']) % 4, pos] = 1
# food
for pos in obs['food']:
b[16, pos] = 1
return b.reshape(-1, 7, 11)
# Load PyTorch Model
PARAM = b'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'
state_dict = pickle.loads(bz2.decompress(base64.b64decode(PARAM)))
model = GeeseNet()
model.load_state_dict(state_dict)
model.eval()
#model = GeeseNet()
#model.load_state_dict(torch.load('./latest.pth'))
#model.eval()
# Main Function of Agent
obses = []
def agent(obs, _):
obses.append(obs)
x = make_input(obses)
with torch.no_grad():
xt = torch.from_numpy(x).unsqueeze(0)
o = model(xt)
p = o['policy'].squeeze(0).detach().numpy()
actions = ['NORTH', 'SOUTH', 'WEST', 'EAST']
return actions[np.argmax(p)]
| 607,382 | 498,379 |
# -*- coding: utf-8 -*-
#
# Copyright: (c) 2019, F5 Networks Inc.
# GNU General Public License v3.0 (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type
import os
import json
import pytest
import sys
if sys.version_info < (2, 7):
pytestmark = pytest.mark.skip("F5 Ansible modules require Python >= 2.7")
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.f5networks.f5_modules.plugins.modules.bigip_message_routing_transport_config import (
ApiParameters, ModuleParameters, ModuleManager, GenericModuleManager, ArgumentSpec
)
from ansible_collections.f5networks.f5_modules.tests.unit.compat import unittest
from ansible_collections.f5networks.f5_modules.tests.unit.compat.mock import Mock, patch
from ansible_collections.f5networks.f5_modules.tests.unit.modules.utils import set_module_args
fixture_path = os.path.join(os.path.dirname(__file__), 'fixtures')
fixture_data = {}
def load_fixture(name):
path = os.path.join(fixture_path, name)
if path in fixture_data:
return fixture_data[path]
with open(path) as f:
data = f.read()
try:
data = json.loads(data)
except Exception:
pass
fixture_data[path] = data
return data
class TestParameters(unittest.TestCase):
def test_module_parameters(self):
args = dict(
name='foo',
partition='foobar',
description='my description',
profiles=['genericmsg', 'foo_udp'],
src_addr_translation=dict(
type='snat',
pool='some_pool1'
),
src_port=1023,
rules=['rule1', 'rule2'],
)
p = ModuleParameters(params=args)
assert p.name == 'foo'
assert p.partition == 'foobar'
assert p.description == 'my description'
assert p.profiles == ['/foobar/genericmsg', '/foobar/foo_udp']
assert p.snat_type == 'snat'
assert p.snat_pool == '/foobar/some_pool1'
assert p.src_port == 1023
assert p.rules == ['/foobar/rule1', '/foobar/rule2']
def test_api_parameters(self):
args = load_fixture('load_generic_transport_config.json')
p = ApiParameters(params=args)
assert p.name == 'gen1'
assert p.partition == 'Common'
assert p.profiles == ['/Common/diametersession', '/Common/tcp']
assert p.snat_type == 'snat'
assert p.src_port == 0
assert p.snat_pool == '/Common/test_snat'
assert p.rules == ['/Common/test']
class TestManager(unittest.TestCase):
def setUp(self):
self.spec = ArgumentSpec()
self.p2 = patch('ansible_collections.f5networks.f5_modules.plugins.modules.bigip_message_routing_transport_config.tmos_version')
self.p3 = patch('ansible_collections.f5networks.f5_modules.plugins.modules.bigip_message_routing_transport_config.send_teem')
self.m2 = self.p2.start()
self.m2.return_value = '14.1.0'
self.m3 = self.p3.start()
self.m3.return_value = True
def tearDown(self):
self.p2.stop()
self.p3.stop()
def test_create_generic_transport(self, *args):
set_module_args(dict(
name='foo',
partition='foobar',
description='my description',
profiles=['genericmsg', 'foo_udp'],
src_addr_translation=dict(
type='snat',
pool='some_pool1'
),
src_port=1023,
rules=['rule1', 'rule2'],
provider=dict(
server='localhost',
password='password',
user='admin'
)
))
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode
)
# Override methods in the specific type of manager
gm = GenericModuleManager(module=module)
gm.exists = Mock(return_value=False)
gm.create_on_device = Mock(return_value=True)
mm = ModuleManager(module=module)
mm.version_less_than_14 = Mock(return_value=False)
mm.get_manager = Mock(return_value=gm)
results = mm.exec_module()
assert results['changed'] is True
assert results['description'] == 'my description'
assert results['src_addr_translation'] == dict(type='snat', pool='/foobar/some_pool1')
assert results['src_port'] == 1023
assert results['rules'] == ['/foobar/rule1', '/foobar/rule2']
assert results['profiles'] == ['/foobar/genericmsg', '/foobar/foo_udp']
def test_update_generic_transport(self, *args):
set_module_args(dict(
name='gen1',
src_port=1024,
rules=['/Common/barfoo'],
provider=dict(
server='localhost',
password='password',
user='admin'
)
))
current = ApiParameters(params=load_fixture('load_generic_transport_config.json'))
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
)
# Override methods in the specific type of manager
gm = GenericModuleManager(module=module)
gm.exists = Mock(return_value=True)
gm.update_on_device = Mock(return_value=True)
gm.read_current_from_device = Mock(return_value=current)
mm = ModuleManager(module=module)
mm.version_less_than_14 = Mock(return_value=False)
mm.get_manager = Mock(return_value=gm)
results = mm.exec_module()
assert results['changed'] is True
assert results['src_port'] == 1024
assert results['rules'] == ['/Common/barfoo']
| 5,879 | 1,822 |
############################################################################
#
# Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
# Contact: http://www.qt-project.org/legal
#
# This file is part of Qt Creator.
#
# Commercial License Usage
# Licensees holding valid commercial Qt licenses may use this file in
# accordance with the commercial license agreement provided with the
# Software or, alternatively, in accordance with the terms contained in
# a written agreement between you and Digia. For licensing terms and
# conditions see http://www.qt.io/licensing. For further information
# use the contact form at http://www.qt.io/contact-us.
#
# GNU Lesser General Public License Usage
# Alternatively, this file may be used under the terms of the GNU Lesser
# General Public License version 2.1 or version 3 as published by the Free
# Software Foundation and appearing in the file LICENSE.LGPLv21 and
# LICENSE.LGPLv3 included in the packaging of this file. Please review the
# following information to ensure the GNU Lesser General Public License
# requirements will be met: https://www.gnu.org/licenses/lgpl.html and
# http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
#
# In addition, as a special exception, Digia gives you certain additional
# rights. These rights are described in the Digia Qt LGPL Exception
# version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
#
#############################################################################
# This is a place to add your own dumpers for testing purposes.
# Any contents here will be picked up by GDB and LLDB based
# debugging in Qt Creator automatically. This code is not used
# when debugging with CDB on Windows.
# NOTE: This file will get overwritten when updating Qt Creator.
#
# To add dumpers that don't get overwritten, copy this file here
# to a safe location outside the Qt Creator installation and
# make this location known to Qt Creator using the Debugger /
# GDB / Dumper customization / Additional file setting.
# Example to display a simple type
# template<typename U, typename V> struct MapNode
# {
# U key;
# V data;
# }
#
# def qdump__MapNode(d, value):
# d.putValue("This is the value column contents")
# d.putNumChild(2)
# if d.isExpanded():
# with Children(d):
# # Compact simple case.
# d.putSubItem("key", value["key"])
# # Same effect, with more customization possibilities.
# with SubItem(d, "data")
# d.putItem("data", value["data"])
# Check http://qt-project.org/doc/qtcreator-3.2/creator-debugging-helpers.html
# for more details or look at qttypes.py, stdtypes.py, boosttypes.py
# for more complex examples.
from dumper import *
from stdtypes import *
######################## Your code below #######################
# copy this file over the corresponding file in qt designer installation
def qdump__IBK__Path(d, value):
qdump__std__string(d, value["m_path"])
def qdump__IBK__Unit(d, value):
qdump__std__string(d, value["m_name"])
| 3,062 | 873 |
from ..open_oas.builder.builder import OasBuilder
from unittest import TestCase
from ..tests.schemas.schemas import PaginationSchema
from ..open_oas.decorators import Deferred, path_parameter
class TestPathParameter(TestCase):
def run_tests(self, builder: OasBuilder):
data = builder.get_data()
parameters = (
data.get("paths", {}).get("/gists", {})
# .get("get", {})
.get("parameters", [])
)
self.assertNotEqual(parameters, [])
for param in parameters:
self.assertEqual(
param.get("schema", {}).get("$ref", {}),
"#/components/schemas/Pagination",
)
def test_data(self):
data = {
"paths": {
"/gists": {
"parameters": [
{
"schema": PaginationSchema,
"in": "query",
"name": "offsetParam",
"required": False,
},
{
"schema": PaginationSchema,
"in": "query",
"name": "limitParam",
"required": False,
},
],
"get": {
"summary": "Gets a list of users.",
"responses": {"200": {"description": "OK"}},
},
}
},
}
builder = OasBuilder(data)
# pprint(builder.get_data())
self.run_tests(builder)
def test_data_dict_schema(self):
data = {
"paths": {
"/gists": {
"parameters": [
{
"schema": {"type": "object"},
"in": "query",
"name": "offsetParam",
"required": False,
},
{
"schema": {"type": "object"},
"in": "query",
"name": "limitParam",
"required": False,
},
],
"get": {
"summary": "Gets a list of users.",
"responses": {"200": {"description": "OK"}},
},
}
},
}
builder = OasBuilder(data)
# pprint(builder.get_data())
# self.run_tests(builder)
parameters = (
builder.get_data()
.get("paths", {})
.get("/gists", {})
# .get("get", {})
.get("parameters", [])
)
self.assertEqual(
parameters,
data.get("paths", {}).get("/gists", {})
# .get("get", {})
.get("parameters", []),
)
def test_decorator(self):
path_parameter(
["/gists"],
"query",
name="offsetParam",
schema=PaginationSchema,
description="",
)
path_parameter(
["/gists"],
"query",
name="limitParam",
schema=PaginationSchema,
description="",
)
builder = OasBuilder()
# pprint(builder.get_data())
self.run_tests(builder)
def tearDown(self) -> None:
Deferred._deferred = []
return super().tearDown()
| 3,618 | 893 |
from load import *
from _2048 import _2048
from numpy import *
from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer, SigmoidLayer
def convolution(x, flat = False):
# return x
def dist(x, y):
if x==y:
return x
else:
return 0
ans = []
for ind in xrange(x.shape[1]):
ele = x[:, ind].reshape(int(x.shape[0] ** .5), -1)
addition = []
for i in xrange(4):
for j in xrange(4):
if i+1 < 4:
addition.append( dist(ele[i, j], ele[i+1, j]))
if j+1 < 4:
addition.append( dist(ele[i, j], ele[i, j+1]))
ans.append ( list(ele.flatten())+(addition) )
# ans.append(addition)
if flat:
return array(ans).flatten()
else:
return array(ans)
def con1(x, flat = False, ori = False):
return convolute(x, [array([[1, -0.5]]), array([[-0.5, 1]]), array([[1], [-0.5]]), array([[-0.5], [1]])], flat, ori)
def convolute(x, con_mats, flat = False, ori = True):
ans = []
n, m = x.shape
a = int(n ** 0.5)
for ind in xrange(m):
ele = x[:, ind].reshape(a, -1)
addition = []
for con_mat in con_mats:
cn, cm = con_mat.shape
for i in xrange(a - cn + 1):
for j in xrange( a - cm + 1):
acc = 0
for i_ in xrange(cn):
for j_ in xrange(cm):
acc += ele[i + i_, j + j_] * con_mat[i_, j_];
addition.append( acc )
if ori:
ans.append( list(ele.flatten()) + (addition) )
else:
ans.append(addition)
if flat:
return array(ans).flatten()
else:
return array(ans)
def softmax_dec(board, u, d, l, r, f):
p = f(con1(board.reshape(-1,1), flat = True))
# print p
if all(board == u[0]):
p[0] = 0
if all(board == d[0]):
p[1] = 0
if all(board == l[0]):
p[2] = 0
if all(board == r[0]):
p[3] = 0
# p /= p.sum()
# return random.choice(arange(4), p = p)
return p.argmax()
if __name__ == '__main__':
tr_x = load('rec_board.npy')
tr_y = load('rec_move.npy')
tr_x = con1(tr_x.T)
print tr_x.shape
print tr_y.shape
data = ClassificationDataSet(tr_x.shape[1], 1, nb_classes = 4)
for ind, ele in enumerate(tr_x):
data.addSample(ele, tr_y[ind])
data._convertToOneOfMany()
print data.outdim
fnn = buildNetwork(data.indim, 10, 10, data.outdim, hiddenclass=SigmoidLayer, outclass=SoftmaxLayer )
trainer = BackpropTrainer( fnn, dataset=data)#, momentum=0.1, verbose=True, weightdecay=0.01)
for i in xrange(3):
print trainer.train()
#trainer.trainUntilConvergence()
game = _2048(length = 4)
game.mul_test(100, lambda a, b, c, d, e: softmax_dec(a, b, c, d, e, f = fnn.activate), addition_arg = True)
| 3,214 | 1,185 |
#!/usr/bin/env python3.8
from passwords import Credentials
from login import accounts
import random
#create credentials func
def create(fname,lname,user,passwords,email):
newCredentials = Credentials(fname,lname,user,passwords,email)
return newCredentials
#delete
'''
function to delete credentials & accounts
'''
def delete(credentials):
credentials.delete()
def deleteAccount(accounts):
accounts.deleteAccount()
'''
save credentials & accounts
'''
def saveCredentials(Credentials):
Credentials.saveCredentials()
def saveAccounts(accounts):
accounts.saveAccounts()
'''
search credentials
'''
def auth_user(email):
return Credentials.auth_by_email
'''
check if contact exist
'''
def account_exists(email):
return Credentials.accounts_display(email)
'''
display
'''
def display_all_users():
return accounts.display_all_users
def main():
print('Your name?')
username = input()
code = input(f'Press Enter {username}')
while True:
print("Use these short codes :")
print("cc - create a new contact")
print("dc - display contacts")
print("fc -find a contact")
print("ex -exit the contact list")
print("del-to delete ")
short_code = input()
if short_code == 'cc':
print('First name:')
fname = input()
print('last name:')
lname = input()
print('username')
username = input()
print('email:')
email = input()
print('password:')
passwords = input(round(random.random()))
saveCredentials(create(fname,lname,username,passwords,email))
print(f'Your data has been taken d{fname}')
elif short_code == 'dc':
if display_all_users():
print('users:')
for account in display_all_users():
print(f'{account.username} {account.email}')
elif short_code == 'fc':
print('enter email address to search')
search = input()
if accounts_exists(email):
auth_by_email = find_contact(search)
print(f'{search.first}')
else:
print('NO credentials found!')
elif short_code == 'del':
print('input Y confirm')
confirm = input()
if delete():
credentials.delete()
print('credential deleted')
else:
print('credentials not found')
elif short_code == 'ex':
print('happy coding!')
break
else:
print('Not an existing shortcut')
if __name__ == '__main__':
main()
| 2,757 | 733 |
from django.test import TestCase
from django.test.client import RequestFactory
from django.template import Template, Context
from django.template.loader import render_to_string
from .models import Author, Book
expected_headers = '''
<tr>
<th>Name</th><th>The title</th><th>Comment</th><th>Stars</th><th>AuthorID</th>
</tr>
'''.strip()
class HeadersTest(TestCase):
def setUp(self):
self.maxDiff = None
self.context = {'object_list': Book.objects.all}
author = Author.objects.create(name='MyAuthor', rating=2)
for i in range(11):
Book.objects.create(author=author, title='B'+str(i), rating=10)
def testHeaders1(self):
result = render_to_string('django_find/headers.html', self.context)
self.assertEqual(result.strip(), expected_headers, result)
| 815 | 252 |
#!/usr/bin/env python
import sys
import copy
import rospy
import tf_conversions
import tf.transformations as transform
import tf
from math import pi
import math
import thread
import os
import random
import geometry_msgs.msg
from geometry_msgs.msg import Pose, PoseArray
from trajectory_msgs.msg import JointTrajectory, JointTrajectoryPoint
import moveit_msgs.msg
import shape_msgs.msg
import visualization_msgs.msg
import diabolo_gazebo.msg
from diabolo_play.srv import SetInitialStickPositionsRequest, SetInitialStickPositions
from diabolo_play.srv import CreateSticksTrajectoryRequest, CreateSticksTrajectory
from diabolo_play.srv import CreateRobotTrajectory, CreateRobotTrajectoryRequest
from moveit_msgs.srv import GetPlanningScene, GetPlanningSceneRequest
import pandas as pd
import numpy as np
from gazebo_msgs.srv import (
DeleteModel,
DeleteModelRequest,
SpawnModel,
SpawnModelRequest,
)
from diabolo_play.msg import DiaboloMotionSplineSeeds
from diabolo_play.srv import GetDiaboloState, GetDiaboloStateRequest
from std_msgs.msg import String
from std_srvs.srv import Empty, EmptyRequest
import rospkg
from diabolo_gazebo.msg import DiaboloState
from scipy import interpolate
import matplotlib.pyplot as plt
from diabolo_play.motion_knot_points import KnotPointsServer
import yaml
import pickle
class PlayerClass:
def __init__(self):
rospy.init_node("diabolo_player", anonymous=True)
self._rospack = rospkg.RosPack()
self.diabolo_urdf_pack = self._rospack.get_path("diabolo_gazebo")
self.diabolo_urdf_file_path = os.path.join(
self.diabolo_urdf_pack, "urdf", "diabolo.urdf"
)
self._package_directory = self._rospack.get_path("diabolo_play")
self.tf_listener = tf.TransformListener()
self.tf_broadcaster = tf.TransformBroadcaster()
self.marker_count = 0
self.marker_pub = rospy.Publisher(
"visualization_markers", visualization_msgs.msg.Marker, queue_size=100
)
self.marker_array_pub = rospy.Publisher(
"visualization_marker_array",
visualization_msgs.msg.MarkerArray,
queue_size=100,
latch=True,
)
self.pub_stick_poses = rospy.Publisher(
"/diabolo_stick_poses",
geometry_msgs.msg.PoseArray,
queue_size=50,
latch=True,
)
self.pub_diabolo_position = rospy.Publisher(
"/experiment_diabolo_position", geometry_msgs.msg.Pose, queue_size=50
)
self.diabolo_state_pub = rospy.Publisher(
"/experiment_diabolo_state", DiaboloState, queue_size=1
)
self.a_bot_command_pub = rospy.Publisher(
"/a_bot/scaled_pos_joint_traj_controller/command",
JointTrajectory,
queue_size=1,
)
self.b_bot_command_pub = rospy.Publisher(
"/b_bot/scaled_pos_joint_traj_controller/command",
JointTrajectory,
queue_size=1,
)
self.set_robots_initial_position_service = rospy.ServiceProxy(
"/initialize_robots_from_stick_positions", SetInitialStickPositions
)
self.command_robot_trajectory_service = rospy.ServiceProxy(
"/command_robot_traj_from_stick_traj", CreateRobotTrajectory
)
self.a_bot_display_traj_pub = rospy.Publisher(
"/display_a_bot_bioik_trajectory",
moveit_msgs.msg.DisplayTrajectory,
queue_size=1,
)
self.b_bot_display_traj_pub = rospy.Publisher(
"/display_b_bot_bioik_trajectory",
moveit_msgs.msg.DisplayTrajectory,
queue_size=1,
)
self.pause_gazebo_service = rospy.ServiceProxy("/gazebo/pause_physics", Empty)
self.unpause_gazebo_service = rospy.ServiceProxy(
"/gazebo/unpause_physics", Empty
)
self.get_diabolo_state_service = rospy.ServiceProxy(
"/get_observed_diabolo_state", GetDiaboloState
)
self.generate_trajectory_service = rospy.ServiceProxy(
"/generate_stick_trajectory", CreateSticksTrajectory
)
self.get_planning_scene_service = rospy.ServiceProxy(
"/get_planning_scene", GetPlanningScene
)
self.latest_diabolo_state = None
self.create_markers()
self.sim_recorder = None # This will be filled with a DiaboloSimRecorder type if running automated trials
self.current_rot_velocity = 0.0 # TODO: Calculate rotational velocity from experiment data and store here
self.left_traj_plan_marker = None
self.right_traj_plan_marker = None
# self.timer = rospy.Timer(rospy.Duration(0.01), self.get_observed_diabolo_state , oneshot=False)
# If this is true, the intermediate frames are displayed. Useful if the calibration seems off, or the rotations are not correct.
self.pub_rate = 50.0
rospy.set_param("/stick_pose_publish_rate", self.pub_rate)
# This parameter is set by the gazebo launch file if robots are being spawned in gazebo
# If the parameter is true, the program will wait for the service to initialize robot positions
self.constrain_to_plane = True # If true, ignore motion x coordinates
self.DEFAULT_X_COORD = (
0.55 # Set robots to this coordinate if motion constrained to plane
)
self.filename = ""
# This is a dictionary of the functions gotten by spline interpolation from the data
self.motion_functions = {}
# This is the name of the current motion being executed.
# The function(s) to be used can be extracted using this by appending
# "_sl" (for left stick)
# "_sr" (for right stick)
# and using it as the key for the self.motion_functions dictionary
self.current_motion = ""
self.frame_rate = 120.0
self.last_stick_positions = {}
self.read_transformed_motion_data(
folder=("experiments/output/2020-09-14_motion_extraction/")
)
self.initialize_motion_functions()
self.get_stick_tips_from_tf()
self.create_knot_server()
self.stop_motion_flag = True
self.tilt_offset = 0.0
self.changed_tilt_offset_flag = False
print("Started experiment playback class")
def get_stick_tips_from_tf(self):
# Get initial stick positions from tf.
# If not available, assume robots are at 'diabolo_ready' position
a_t = geometry_msgs.msg.Point()
b_t = geometry_msgs.msg.Point()
try:
self.tf_listener.waitForTransform(
"/world", "/a_bot_diabolo_stick_tip", rospy.Time(), rospy.Duration(1.0)
)
print("Got stick tip positions from tf")
(a_trans, a_rot) = self.tf_listener.lookupTransform(
"/world", "/a_bot_diabolo_stick_tip", rospy.Time(0)
)
(b_trans, b_rot) = self.tf_listener.lookupTransform(
"/world", "/b_bot_diabolo_stick_tip", rospy.Time(0)
)
a_t.x = a_trans[0]
a_t.y = a_trans[1]
a_t.z = a_trans[2]
b_t.x = b_trans[0]
b_t.y = b_trans[1]
b_t.z = b_trans[2]
except:
print("Transforms not available")
print("Initializing with initial position for this robot")
pose_left = self.motion_functions[self.current_motion + "_sl"][
"initial_pose"
]
pose_right = self.motion_functions[self.current_motion + "_sr"][
"initial_pose"
]
a_t = pose_right.position
b_t = pose_left.position
self.last_stick_positions = {"pos_left": b_t, "pos_right": a_t}
def create_knot_server(self):
"""
Create a knot server with the number of points given by the number knots in the current motion
"""
interactive_knot_points = len(
self.motion_functions[self.current_motion + "_sl"]["time_seed"]
)
if (
self.motion_functions[self.current_motion + "_sl"]["motion_type"]
== "periodic"
):
interactive_knot_points -= 1
pos_left = self.last_stick_positions["pos_left"]
pos_right = self.last_stick_positions["pos_right"]
left_seed_positions = []
right_seed_positions = []
left_seed_positions.append(pos_left)
right_seed_positions.append(pos_right)
left_dict = self.motion_functions[self.current_motion + "_sl"]
right_dict = self.motion_functions[self.current_motion + "_sr"]
for i in range(interactive_knot_points):
# Fill the seed position arrays with the initial seeds if available
left_seed = geometry_msgs.msg.Point(
left_dict["x_knot_seed"][i],
left_dict["y_knot_seed"][i],
left_dict["z_knot_seed"][i],
)
right_seed = geometry_msgs.msg.Point(
right_dict["x_knot_seed"][i],
right_dict["y_knot_seed"][i],
right_dict["z_knot_seed"][i],
)
left_seed_positions.append(left_seed)
right_seed_positions.append(right_seed)
self.knot_point_server = KnotPointsServer(
interactive_knot_points, [left_seed_positions, right_seed_positions]
)
def get_observed_diabolo_state(self, timer):
# Store the real pose/simulated pose of the diabolo to use for prediction
try:
req = GetDiaboloStateRequest()
req.header.stamp = rospy.Time.now()
resp = self.get_diabolo_state_service(req)
if resp.success:
self.latest_diabolo_state = resp.state
# else:
# self.latest_diabolo_pose = None
# self.latest_diabolo_trans_vel = None
except:
self.latest_diabolo_state = None
def _make_marker_from_mesh(
self,
mesh_filename="package://diabolo_play/meshes/diabolo_shell.stl",
namespace="diabolo",
scale=(1, 1, 1),
color=(1, 1, 1),
alpha=1.0,
):
"""
Based on the 'makeMesh()' function from 'moveit_commander/planning_scene_interface.py'
pose is a PoseStamped object.
"""
marker = visualization_msgs.msg.Marker()
marker.header.frame_id = "world"
marker.header.stamp = rospy.Time.now()
marker.ns = namespace
marker.id = self.marker_count
self.marker_count = self.marker_count + 1
marker.type = visualization_msgs.msg.Marker.MESH_RESOURCE
marker.action = visualization_msgs.msg.Marker.ADD
marker.pose.orientation.w = 1.0
marker.scale.x = scale[0]
marker.scale.y = scale[1]
marker.scale.z = scale[2]
marker.color.a = alpha
marker.color.r = color[0]
marker.color.g = color[1]
marker.color.b = color[2]
marker.mesh_resource = mesh_filename
return marker
def create_markers(self):
# Create marker objects from the meshes
self.diabolo_shell_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_shell.stl",
color=(1, 0, 0),
scale=[0.001, 0.001, 0.001],
namespace="",
)
self.diabolo_fixator_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_fixators.stl",
color=(0.1, 0.1, 0.1),
scale=[0.001, 0.001, 0.001],
namespace="",
)
self.diabolo_axis_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_axis.stl",
color=(0.7, 0.7, 0.7),
scale=[0.001, 0.001, 0.001],
namespace="",
)
self.stick_left_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_stick.stl",
color=(153 / 255.0, 75 / 255.0, 0.1),
scale=[0.001, 0.001, 0.001],
namespace="",
)
self.stick_right_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_stick.stl",
color=(153 / 255.0, 75 / 255.0, 0.1),
scale=[0.001, 0.001, 0.001],
namespace="",
)
self.holder_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_mount.stl",
color=(1, 1, 200 / 255.0),
scale=[0.001, 0.001, 0.001],
namespace="",
)
# Add the string
self.line_segments_marker = self._make_marker_from_mesh(
"", color=(204 / 255.0, 100 / 255.0, 0), namespace=""
)
self.line_segments_marker.type = visualization_msgs.msg.Marker.LINE_STRIP
self.line_segments_marker.points.append(
geometry_msgs.msg.Point(1, 1, 1)
) # The left stick tip
self.line_segments_marker.points.append(
geometry_msgs.msg.Point(0, 0, 0)
) # The diabolo center
self.line_segments_marker.points.append(
geometry_msgs.msg.Point(-1, -1, 1)
) # The right stick tip
self.line_segments_marker.scale.x = 0.005 # line width
self.sphere_marker_1 = self._make_marker_from_mesh(
"", color=(0.0, 0.0, 1.0), scale=[0.08, 0.08, 0.08], namespace=""
)
self.sphere_marker_1.type = visualization_msgs.msg.Marker.SPHERE
self.sphere_marker_2 = self._make_marker_from_mesh(
"", color=(0.0, 0.0, 1.0), scale=[0.08, 0.08, 0.08], namespace=""
)
self.sphere_marker_2.type = visualization_msgs.msg.Marker.SPHERE
def update_and_publish_markers(self, poses):
"""
poses needs to be a dict containing "diabolo", "stick_left", "stick_right" poses as geometry_msgs.msg.Pose
"""
self.sphere_marker_1.pose = poses["stick_left"]
self.sphere_marker_2.pose = poses["stick_right"]
# Flip orientations for correct display of the sticks
marker_array = [self.sphere_marker_1, self.sphere_marker_2]
self.marker_array_pub.publish(marker_array)
def read_transformed_motion_data(
self, folder="experiments/output/2020-09-14_motion_extraction/"
):
# This is a different function because the header is formatted differently in the transformed CSV file
linear_accel_file = "linear_accel_stick_motion.csv"
circular_accel_right_file = "circular_accel_right_stick_motion.csv"
circular_accel_left_file = "circular_accel_left_stick_motion.csv"
self.motion_data_dict = {}
# Get linear acceleration stick positions
motion_df = pd.read_csv(
os.path.join(self._package_directory, folder, linear_accel_file),
header=[0, 1, 2],
)
self.motion_data_dict["lin_accel_sl"] = motion_df["stick_left"]
self.motion_data_dict["lin_accel_sr"] = motion_df["stick_right"]
# Get circular acceleration stick positions
motion_df = pd.read_csv(
os.path.join(self._package_directory, folder, circular_accel_right_file),
header=[0, 1, 2],
)
self.motion_data_dict["circ_accel_sr"] = motion_df["stick_right"]
self.motion_data_dict["circ_accel_sl"] = motion_df["stick_left"]
def force_add_motion_function_(self):
"""
This is a helper function to add and overwrite motion functions in the database.
"""
self.current_motion = "lin_accel"
self.motion_functions["circ_accel_sr"]["time_seed"] = (
0.35,
0.65,
0.95,
1.25,
1.55,
1.85,
)
self.motion_functions["circ_accel_sr"]["motion_type"] = "periodic"
self.motion_functions["circ_accel_sl"]["time_seed"] = (
0.35,
0.65,
0.95,
1.25,
1.55,
1.85,
)
self.motion_functions["circ_accel_sl"]["motion_type"] = "periodic"
### For horizontal impulse
left_pose = Pose()
right_pose = Pose()
left_pose.position.x = self.DEFAULT_X_COORD
right_pose.position.x = self.DEFAULT_X_COORD
left_pose.position.y = 0.05
right_pose.position.y = -0.05
left_pose.position.z = 1.25
right_pose.position.z = 1.25
self.motion_functions["horizontal_impulse_short_left_sl"] = {
"x_knot_seed": (0.0, 0.0),
"y_knot_seed": (-0.23, -0.1),
"z_knot_seed": (0.0, 0.0),
"time_seed": (0.6, 1.0, 1.7),
"initial_pose": copy.deepcopy(left_pose),
"motion_type": "periodic",
}
self.motion_functions["horizontal_impulse_short_left_sr"] = {
"x_knot_seed": (0.0, 0.0),
"y_knot_seed": (-0.23, -0.1),
"z_knot_seed": (0.0, 0.0),
"time_seed": (0.8, 1.0, 1.7),
"initial_pose": copy.deepcopy(right_pose),
"motion_type": "periodic",
}
### For lin_accel
self.motion_functions["lin_accel_sr"]["time_seed"] = (0.25, 0.5, 0.9, 1.2)
self.motion_functions["lin_accel_sr"]["motion_type"] = "periodic"
self.motion_functions["lin_accel_sl"]["time_seed"] = (0.25, 0.5, 0.9, 1.2)
self.motion_functions["lin_accel_sl"]["motion_type"] = "periodic"
self.motion_functions["lin_accel_sr"]["x_knot_seed"] = (0.0, 0.0, 0.0)
self.motion_functions["lin_accel_sr"]["y_knot_seed"] = (0.05, 0.0, 0.05)
self.motion_functions["lin_accel_sr"]["z_knot_seed"] = (0.2, 0.4, 0.2)
self.motion_functions["lin_accel_sl"]["x_knot_seed"] = (0.0, 0.0, 0.0)
self.motion_functions["lin_accel_sl"]["y_knot_seed"] = (-0.05, 0.0, -0.05)
self.motion_functions["lin_accel_sl"]["z_knot_seed"] = (-0.15, -0.3, -0.15)
self.motion_functions["lin_accel_sl"][
"initial_pose"
].position.x = self.DEFAULT_X_COORD
self.motion_functions["lin_accel_sl"]["initial_pose"].position.y = 0.1
self.motion_functions["lin_accel_sl"]["initial_pose"].position.z = 1.47
self.motion_functions["lin_accel_sr"][
"initial_pose"
].position.x = self.DEFAULT_X_COORD
self.motion_functions["lin_accel_sr"]["initial_pose"].position.y = -0.1
self.motion_functions["lin_accel_sr"]["initial_pose"].position.z = 1.07
### For vertical throw
left_pose = Pose()
right_pose = Pose()
left_pose.position.x = self.DEFAULT_X_COORD
right_pose.position.x = self.DEFAULT_X_COORD
left_pose.position.y = 0.05
right_pose.position.y = -0.05
left_pose.position.z = 1.25
right_pose.position.z = 1.25
### throw_1.bag and throw_1b.bag settings
# self.motion_functions["vertical_throw_sl"] = {"x_knot_seed":(0.0, 0.0, 0.0), \
# "y_knot_seed":(0.2, 0.65, 0.728), \
# "time_seed": (0.4, 0.8, 0.96), \
# self.motion_functions["vertical_throw_sr"] = {"x_knot_seed":(0.0, 0.0, 0.0), \
# "y_knot_seed":(-0.2, -0.65, -0.728), \
# "time_seed": (0.4, 0.8, 0.96), \
### throw_2.bag settings
# self.motion_functions["vertical_throw_sl"] = {"x_knot_seed":(0.0, 0.0, 0.0), \
# "y_knot_seed":(0.2, 0.65, 0.729), \
# "z_knot_seed":(0.0, 0.0, 0.0), \
# "time_seed": (0.4, 0.8, 0.94), \
# self.motion_functions["vertical_throw_sr"] = {"x_knot_seed":(0.0, 0.0, 0.0), \
# "y_knot_seed":(-0.2, -0.65, -0.729), \
# "z_knot_seed":(0.0, 0.0, 0.0), \
# "time_seed": (0.4, 0.8, 0.94), \
self.motion_functions["vertical_throw_sl"] = {
"x_knot_seed": (0.0, 0.0, 0.0),
"y_knot_seed": (0.2, 0.65, 0.731),
"z_knot_seed": (0.0, 0.0, 0.0),
"time_seed": (0.4, 0.8, 0.92),
"flight_time": 0.5,
"initial_pose": copy.deepcopy(left_pose),
"motion_type": "oneshot",
}
self.motion_functions["vertical_throw_sr"] = {
"x_knot_seed": (0.0, 0.0, 0.0),
"y_knot_seed": (-0.2, -0.65, -0.731),
"z_knot_seed": (0.0, 0.0, 0.0),
"time_seed": (0.4, 0.8, 0.92),
"flight_time": 0.5,
"initial_pose": copy.deepcopy(right_pose),
"motion_type": "oneshot",
}
def add_motion_function(self, name, num_knot_points=5):
# TODO: Create a new motion and add it to self.motion_list and self.motion_functions under that key
# TODO: Use self.motion_functions.keys instead of maintaining self.motion_list
left_pose = Pose()
right_pose = Pose()
left_pose.position.x = self.DEFAULT_X_COORD
right_pose.position.x = self.DEFAULT_X_COORD
left_pose.position.y = 0.05
right_pose.position.y = -0.05
left_pose.position.z = 1.25
right_pose.position.z = 1.25
self.motion_functions[name + "_sl"] = {
"x_knot_seed": [0.0] * num_knot_points,
"y_knot_seed": range(0.1, (num_knot_points + 1) * 0.1, 0.1),
"z_knot_seed": range(0.05, (num_knot_points + 1) * 0.05, 0.05),
"time_seed": range(0.5, (num_knot_points + 1) * 0.5, 0.5),
"initial_pose": copy.deepcopy(left_pose),
"motion_type": "periodic",
}
self.motion_functions[name + "_sr"] = {
"x_knot_seed": [0.0] * num_knot_points,
"y_knot_seed": range(0.1, (num_knot_points + 1) * 0.1, 0.1),
"z_knot_seed": range(0.05, (num_knot_points + 1) * 0.05, 0.05),
"time_seed": range(0.5, (num_knot_points + 1) * 0.5, 0.5),
"initial_pose": copy.deepcopy(right_pose),
"motion_type": "periodic",
}
def initialize_motion_functions(
self, use_saved_values=True, filename="default.pkl"
):
# First add the period motions, for which there is motion capture data
self.motion_functions = {}
path = os.path.join(self._package_directory, "config", filename)
if os.path.exists(path) and use_saved_values:
print("Using stored motion function values")
with open(path, "r") as f:
self.motion_functions = pickle.load(f)
else:
print("Using hardcoded values")
self.motion_list = []
# Make the last position in the data the same as the first postion, to make the motion cyclic
for key in self.motion_data_dict:
pos_data = np.array(self.motion_data_dict[key]["Position"])
delta_x = pos_data[-1] - pos_data[0]
total_steps = pos_data.shape[0]
for i in range(total_steps):
pos_data[i] = pos_data[i] - delta_x * (
float(i) / float(total_steps - 1)
)
# Using two "cycles" of the data for interpolation to ensure I get the correct slope at the end points
# That is why pos_data is made by appending two of the data arrays
pos_data = np.append(pos_data, pos_data).reshape(
pos_data.shape[0] * 2, -1
)
time_steps = np.arange(pos_data.shape[0]) / self.frame_rate
# Create spline functions by interpolating between the data positions, ignoring the nan values
good_indices = np.where(np.isfinite(pos_data))[0].reshape(-1, 3)[
:, 0
] # Indices where array is finite
# Store the functions returning spline functions, time period of this motion and the initial position of the motion
self.motion_functions[key] = {
"X": interpolate.InterpolatedUnivariateSpline(
time_steps[good_indices], pos_data[good_indices, 0]
),
"Y": interpolate.InterpolatedUnivariateSpline(
time_steps[good_indices], pos_data[good_indices, 1]
),
"Z": interpolate.InterpolatedUnivariateSpline(
time_steps[good_indices], pos_data[good_indices, 2]
),
"period": pos_data.shape[0] / (2.0 * self.frame_rate),
}
self.motion_functions[key]["initial_pose"] = self.stick_pose_at_time(
function=self.motion_functions[key], time=0
)
self.motion_list.append(key)
# There are 6 knot points for circular accel and linear accel, but the last point is the same as the initial position
# Therefore, the number of interactive markers should be len(time_seed)-1 for circular motions
self.motion_functions["circ_accel_sr"]["time_seed"] = (
0.3,
0.6,
0.9,
1.2,
1.5,
1.8,
)
self.motion_functions["circ_accel_sr"]["motion_type"] = "periodic"
self.motion_functions["circ_accel_sl"]["time_seed"] = (
0.3,
0.6,
0.9,
1.2,
1.5,
1.8,
)
self.motion_functions["circ_accel_sl"]["motion_type"] = "periodic"
self.motion_functions["circ_accel_sr"]["x_knot_seed"] = (
0.0,
0.0,
0.0,
0.0,
0.0,
)
self.motion_functions["circ_accel_sr"]["y_knot_seed"] = (
-0.042,
-0.24,
-0.41,
-0.371,
-0.163,
)
self.motion_functions["circ_accel_sr"]["z_knot_seed"] = (
0.20,
0.30,
0.2,
0.0,
-0.076,
)
self.motion_functions["circ_accel_sl"]["x_knot_seed"] = (
0.0,
0.0,
0.0,
0.0,
0.0,
)
self.motion_functions["circ_accel_sl"]["y_knot_seed"] = (
-0.061,
0.0592,
0.2619,
0.3100,
0.1410,
)
self.motion_functions["circ_accel_sl"]["z_knot_seed"] = (
0.1801,
0.3820,
0.344,
0.15914,
0.03543,
)
self.motion_functions["lin_accel_sr"]["time_seed"] = (0.3, 0.6, 0.9, 1.2)
self.motion_functions["lin_accel_sr"]["motion_type"] = "periodic"
self.motion_functions["lin_accel_sl"]["time_seed"] = (0.3, 0.6, 0.9, 1.2)
self.motion_functions["lin_accel_sl"]["motion_type"] = "periodic"
self.motion_functions["lin_accel_sr"]["x_knot_seed"] = (0.0, 0.0, 0.0)
self.motion_functions["lin_accel_sr"]["y_knot_seed"] = (-0.05, 0.0, -0.05)
self.motion_functions["lin_accel_sr"]["z_knot_seed"] = (0.1, 0.2, 0.1)
self.motion_functions["lin_accel_sl"]["x_knot_seed"] = (0.0, 0.0, 0.0)
self.motion_functions["lin_accel_sl"]["y_knot_seed"] = (0.05, 0.0, 0.05)
self.motion_functions["lin_accel_sl"]["z_knot_seed"] = (-0.1, -0.2, -0.1)
self.motion_functions["lin_accel_sl"][
"initial_pose"
].position.x = self.DEFAULT_X_COORD
self.motion_functions["lin_accel_sl"]["initial_pose"].position.y = 0.1
self.motion_functions["lin_accel_sl"]["initial_pose"].position.z = 1.42
self.motion_functions["lin_accel_sr"][
"initial_pose"
].position.x = self.DEFAULT_X_COORD
self.motion_functions["lin_accel_sr"]["initial_pose"].position.y = -0.1
self.motion_functions["lin_accel_sr"]["initial_pose"].position.z = 1.12
left_pose = Pose()
right_pose = Pose()
left_pose.position.x = self.DEFAULT_X_COORD
left_pose.position.y = 0.21
left_pose.position.z = 1.27
right_pose.position.x = self.DEFAULT_X_COORD
right_pose.position.y = -0.28
right_pose.position.z = 1.27
# Now store the initial position for throwing motions
# self.motion_functions["circ_accel_sr"]["initial_pose"] = circ_accel_initial_pose_right
left_pose = Pose()
right_pose = Pose()
left_pose.position.x = self.DEFAULT_X_COORD
right_pose.position.x = self.DEFAULT_X_COORD
left_pose.position.y = 0.05
right_pose.position.y = -0.05
left_pose.position.z = 1.25
right_pose.position.z = 1.25
self.motion_functions["vertical_throw_sl"] = {
"x_knot_seed": (0.0, 0.0, 0.0),
"y_knot_seed": (0.1, 0.74, 0.748),
"z_knot_seed": (0.0, 0.0, 0.0),
"time_seed": (0.2, 0.55, 0.6),
"flight_time": 0.5,
"initial_pose": copy.deepcopy(left_pose),
"motion_type": "oneshot",
}
self.motion_functions["vertical_throw_sr"] = {
"x_knot_seed": (0.0, 0.0, 0.0),
"y_knot_seed": (-0.1, -0.74, -0.748),
"z_knot_seed": (0.0, 0.0, 0.0),
"time_seed": (0.2, 0.55, 0.6),
"flight_time": 0.5,
"initial_pose": copy.deepcopy(right_pose),
"motion_type": "oneshot",
}
left_pose.position.y = 0.15
right_pose.position.y = -0.15
left_pose.position.z = 1.20
right_pose.position.z = 1.30
self.motion_functions["right_throw_sl"] = {
"x_knot_seed": (0.0, 0.0, 0.0, 0.0, 0.0, 0.0),
"y_knot_seed": (-0.1, 0.33, 0.46),
"z_knot_seed": (0.2, 0.42, 0.439),
"time_seed": (0.1, 0.2, 0.3, 0.4, 0.5, 0.6),
"flight_time": 0.5,
"initial_pose": copy.deepcopy(left_pose),
"motion_type": "oneshot",
}
self.motion_functions["right_throw_sr"] = {
"x_knot_seed": (0.0, 0.0, 0.0, 0.0, 0.0, 0.0),
"y_knot_seed": (0.1, -0.33, -0.46),
"z_knot_seed": (-0.2, -0.42, -0.439),
"time_seed": (0.1, 0.2, 0.3, 0.4, 0.5, 0.6),
"flight_time": 0.5,
"initial_pose": copy.deepcopy(right_pose),
"motion_type": "oneshot",
}
self.motion_functions["left_throw_sl"] = {
"x_knot_seed": (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0),
"y_knot_seed": (-0.1, 0.2, 0.304652, 0.4, 0.5, 0.6, 0.7, 0.8),
"z_knot_seed": (0.1, -0.22814, -0.38441, -0.4, -0.5, -0.6, -0.7, -0.8),
"time_seed": (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8),
"flight_time": 0.5,
"initial_pose": copy.deepcopy(left_pose),
"motion_type": "oneshot",
}
self.motion_functions["left_throw_sr"] = {
"x_knot_seed": (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0),
"y_knot_seed": (0.1, -0.22814, -0.38441, -0.4, -0.5, -0.6, -0.7, -0.8),
"z_knot_seed": (0.1, 0.2, 0.304652, 0.4, 0.5, 0.6, 0.7, 0.8),
"time_seed": (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8),
"flight_time": 0.5,
"initial_pose": copy.deepcopy(right_pose),
"motion_type": "oneshot",
}
self.motion_list.append("vertical_throw")
self.motion_list.append("right_throw")
self.motion_list.append("left_throw")
self.motion_list = [
m.replace("_sr", "").replace("_sl", "") for m in self.motion_list
]
self.motion_list = list(set(self.motion_list))
#
print("Available motions are: " + str(self.motion_list))
self.motion_list = []
for key in self.motion_data_dict:
self.motion_list.append(key)
self.motion_list.append("vertical_throw")
self.motion_list.append("right_throw")
self.motion_list.append("left_throw")
self.motion_list = [
m.replace("_sr", "").replace("_sl", "") for m in self.motion_list
]
self.motion_list = list(set(self.motion_list))
left_pose = Pose()
right_pose = Pose()
left_pose.position.x = self.DEFAULT_X_COORD
right_pose.position.x = self.DEFAULT_X_COORD
left_pose.position.y = 0.05
right_pose.position.y = -0.05
left_pose.position.z = 1.25
right_pose.position.z = 1.25
self.motion_functions["horizontal_impulse_sl"] = {
"x_knot_seed": (0.0, 0.0, 0.0, 0.0),
"y_knot_seed": (0.23, 0.12, -0.12, 0.23),
"z_knot_seed": (0.0, 0.0, 0.0, 0.0),
"time_seed": (0.9, 1.4, 2.0, 2.8, 3.5),
"initial_pose": copy.deepcopy(left_pose),
"motion_type": "periodic",
}
self.motion_functions["horizontal_impulse_sr"] = {
"x_knot_seed": (0.0, 0.0, 0.0, 0.0),
"y_knot_seed": (0.23, 0.12, -0.12, 0.23),
"z_knot_seed": (0.0, 0.0, 0.0, 0.0),
"time_seed": (0.9, 1.4, 2.0, 2.8, 3.5),
"initial_pose": copy.deepcopy(right_pose),
"motion_type": "periodic",
}
self.motion_functions["vertical_throw_sr"]["y_knot_seed"] = (
-0.1,
-0.725,
-0.735,
)
self.motion_functions["vertical_throw_sl"]["y_knot_seed"] = (0.1, 0.725, 0.735)
left_pose.position.z = 1.35
right_pose.position.z = 1.35
self.motion_functions["left_throw_sl"]["initial_pose"] = left_pose
self.motion_functions["left_throw_sr"]["initial_pose"] = right_pose
self.current_motion = "circ_accel"
def get_traj_for_transition_to_motion(self, desired_motion):
"""
Return stick poses between the current position and start point of the desired motion
Parameters:
desired_motion: A string naming the motion desired. This must one of the accepted names contained in the self.motion_list list
If current motion is the same as desired motion, returns without doing anything
"""
# if(self.current_motion == desired_motion):
# print("Already executing this. Returning")0.9, 1.2, 1.6
# Get start position of desired motion for each arm
sr_target_pose = self.motion_functions[desired_motion + "_sl"]["initial_pose"]
sl_target_pose = self.motion_functions[desired_motion + "_sr"]["initial_pose"]
# Get direction of travel for both sticks as as vector
sr_target_pose_vec = np.array(
(
sr_target_pose.position.x,
sr_target_pose.position.y,
sr_target_pose.position.z,
)
)
sl_target_pose_vec = np.array(
(
sl_target_pose.position.x,
sl_target_pose.position.y,
sl_target_pose.position.z,
)
)
sr_current_pose_vec = np.array(
(
self.last_stick_positions["pos_right"].x,
self.last_stick_positions["pos_right"].y,
self.last_stick_positions["pos_right"].z,
)
)
sl_current_pose_vec = np.array(
(
self.last_stick_positions["pos_left"].x,
self.last_stick_positions["pos_left"].y,
self.last_stick_positions["pos_left"].z,
)
)
# Get directions of travel for both arms
left_dir = sl_target_pose_vec - sl_current_pose_vec
right_dir = sr_target_pose_vec - sr_current_pose_vec
if np.linalg.norm(left_dir) < 0.01 or np.linalg.norm(right_dir) < 0.01:
self.initialize_robot_positions()
return False, False
time_to_target = 0.8 # Set a constant time to get to the target
steps = int(time_to_target * self.pub_rate) # the number of steps to target
left_step_length = np.linalg.norm(left_dir) / steps
right_step_length = np.linalg.norm(right_dir) / steps
print(
"Step lengths are : \n Left: "
+ str(left_step_length)
+ "\n Right: "
+ str(right_step_length)
)
# Get normal of direction vectors
if left_step_length != 0.0:
left_dir = left_dir / np.linalg.norm(left_dir)
if right_step_length != 0.0:
right_dir = right_dir / np.linalg.norm(right_dir)
left_stick_pose_array = PoseArray()
right_stick_pose_array = PoseArray()
for i in range(0, steps + 1):
pose_l = Pose()
pose_r = Pose()
# Get next waypoint by adding normal direction vector * step length to current position
sr_current_pose_vec = sr_current_pose_vec + right_dir * right_step_length
sl_current_pose_vec = sl_current_pose_vec + left_dir * left_step_length
pose_r.position.x = sr_current_pose_vec[0]
pose_r.position.y = sr_current_pose_vec[1]
pose_r.position.z = sr_current_pose_vec[2]
pose_l.position.x = sl_current_pose_vec[0]
pose_l.position.y = sl_current_pose_vec[1]
pose_l.position.z = sl_current_pose_vec[2]
left_stick_pose_array.poses.append(copy.deepcopy(pose_l))
right_stick_pose_array.poses.append(copy.deepcopy(pose_r))
# The last pose published should be the target pose
self.current_motion = desired_motion
return left_stick_pose_array, right_stick_pose_array
# self.start_publish()
def stick_pose_at_time(self, function, time, rate=1.0):
"""
Parameters:
function: The motion function(s) to use. Expects a dictionary containing a function object for each X, Y and Z coordinates at time t
as well as the time period of the function
rate: Rate of rotation. Greater than one for faster motion
time: The time at which to calculate the coordinates
"""
t = (rate * time) % function["period"] # Time
pose = Pose()
if self.constrain_to_plane:
pose.position.x = self.DEFAULT_X_COORD
else:
pose.position.x = function["X"](t) + 0.3
pose.position.y = function["Y"](t) + 0.2
pose.position.z = function["Z"](t) - 0.1
return pose
def initialize_robot_positions(self):
print("Waiting for robot arm initialization service")
try:
rospy.wait_for_service(
"/initialize_robots_from_stick_positions", timeout=1.0
)
pose_left = self.motion_functions[self.current_motion + "_sl"][
"initial_pose"
]
pose_right = self.motion_functions[self.current_motion + "_sr"][
"initial_pose"
]
req = SetInitialStickPositionsRequest()
req.left_stick_position = pose_left.position
req.right_stick_position = pose_right.position
self.set_robots_initial_position_service(req)
self.last_stick_positions = {
"pos_left": pose_left.position,
"pos_right": pose_right.position,
}
except rospy.ROSException:
print(
"Service not found. Did you start the stick position to joint converter node?"
)
self.create_knot_server()
def start_publish(self, loop=False, speed_factor=1.0):
print("Starting publish")
# self.check_amplitude()
thread.start_new_thread(self._run_publish, (loop, speed_factor))
def stop_publish(self):
self.exit_publish_flag = True
def _run_publish(self, loop=False, speed_factor=1.0):
"This function is meant to be called in a separate thread by play_experiment"
print("Starting publish 2")
self.exit_publish_flag = False
self.pause_publish_flag = False
r = rospy.Rate(self.pub_rate)
initial_time = rospy.get_time()
motion = self.current_motion
while True:
time = rospy.get_time() - initial_time
# Adding an empty pose as the robot controller requires a pose array msg
pose_array = PoseArray()
pose_l = self.stick_pose_at_time(
function=self.motion_functions[motion + "_sl"],
time=time,
rate=speed_factor,
)
pose_r = self.stick_pose_at_time(
function=self.motion_functions[motion + "_sr"],
time=time,
rate=speed_factor,
)
pose_array.poses.append(pose_l)
pose_array.poses.append(pose_r)
self.pub_stick_poses.publish(pose_array)
self.last_stick_positions = {
"pos_left": pose_l.position,
"pos_right": pose_r.position,
}
self.update_and_publish_markers(
{"stick_left": pose_l, "stick_right": pose_r}
)
if self.pause_publish_flag:
rospy.loginfo("Publishing stick poses is paused!")
while self.pause_publish_flag:
rospy.sleep(0.2)
rospy.loginfo("Publishing stick poses is resumed!")
if self.exit_publish_flag or rospy.is_shutdown():
print("Done with thread while loop")
break
r.sleep()
rospy.loginfo("Stopping...")
return
# Takes diabolo sim parameters as argument.
# parameters[0] = /pv_pre_cap_scaling_factor
# parameters[1] = /pv_cap_scaling_factor
# parameters[2] = /pv_post_cap_scaling_factor
# parameters[3] = /constrained_velocity_scaling_factor
def initialize_sim_diabolo(self, parameters=(1.0, 1.0, 1.0, 1.0)):
# Set the pull velocity parameters
rospy.set_param("/pv_pre_cap_scaling_factor", parameters[0])
rospy.set_param("/pv_cap_scaling_factor", parameters[1])
rospy.set_param("/pv_post_cap_scaling_factor", parameters[2])
rospy.set_param("/constrained_velocity_scaling_factor", parameters[3])
# Delete existing diabolo if present
delete_model = rospy.ServiceProxy("/gazebo/delete_model", DeleteModel)
rospy.wait_for_service("/gazebo/delete_model")
req = DeleteModelRequest()
req.model_name = "diabolo"
try:
if not delete_model(req):
print("There was no diabolo spawned")
except:
raise
# Set initial postions as parameters on the parameter server
pose_left = self.motion_functions[self.current_motion + "_sl"]["initial_pose"]
pose_right = self.motion_functions[self.current_motion + "_sr"]["initial_pose"]
left_pos = pose_left.position
right_pos = pose_right.position
rospy.set_param(
"/right_stick_initial_position",
[
float(self.last_stick_positions["pos_right"].x),
float(self.last_stick_positions["pos_right"].y),
float(self.last_stick_positions["pos_right"].z),
],
)
rospy.set_param(
"/left_stick_initial_position",
[
float(self.last_stick_positions["pos_left"].x),
float(self.last_stick_positions["pos_left"].y),
float(self.last_stick_positions["pos_left"].z),
],
)
# The initial rotational velocity of the diabolo
rospy.set_param("/diabolo_initial_rot_velocity", 25.0)
print("Done setting params")
self._spawn_diabolo_in_gazebo()
return True
def _spawn_diabolo_in_gazebo(self):
# Create service proxy
spawn_model = rospy.ServiceProxy("/gazebo/spawn_urdf_model", SpawnModel)
rospy.wait_for_service("/gazebo/spawn_urdf_model")
# Load URDF
with open(self.diabolo_urdf_file_path, "r") as f:
poses = dict()
model_xml = f.read()
# Spawn model
req = SpawnModelRequest()
req.model_name = "diabolo"
# req.initial_pose = diabolo_pose
pose = Pose()
pose.position.x = 0.7
pose.position.y = 0.0
pose.position.z = 0.7
req.initial_pose.position = pose.position
req.model_xml = model_xml
req.robot_namespace = "/"
req.reference_frame = "world"
if spawn_model(req).success:
print("Spawning diabolo in gazebo")
rospy.sleep(0.2)
def execute_periodic_trajectory_(
self,
a_bot_trajectory,
b_bot_trajectory,
speed_factor=0.5,
confirm_execution=True,
start_time=None,
):
req = GetPlanningSceneRequest()
req.components.components = req.components.ROBOT_STATE
planning_scene = self.get_planning_scene_service(req)
try:
display_a_bot_traj = moveit_msgs.msg.DisplayTrajectory()
display_b_bot_traj = moveit_msgs.msg.DisplayTrajectory()
a_bot_robot_traj = moveit_msgs.msg.RobotTrajectory()
b_bot_robot_traj = moveit_msgs.msg.RobotTrajectory()
a_bot_robot_traj.joint_trajectory = a_bot_trajectory
b_bot_robot_traj.joint_trajectory = b_bot_trajectory
display_a_bot_traj.trajectory.append(a_bot_robot_traj)
display_b_bot_traj.trajectory.append(b_bot_robot_traj)
display_a_bot_traj.trajectory_start = planning_scene.scene.robot_state
display_b_bot_traj.trajectory_start = planning_scene.scene.robot_state
self.a_bot_display_traj_pub.publish(display_a_bot_traj)
self.b_bot_display_traj_pub.publish(display_b_bot_traj)
time_to_start = start_time
if not time_to_start:
time_to_start = rospy.Time.now()
if confirm_execution:
print("Execute this trajectory? y/n")
e = raw_input()
if e == "y":
time_to_start = rospy.Time.now() + rospy.Duration(0.1)
a_bot_trajectory.header.stamp = time_to_start
b_bot_trajectory.header.stamp = time_to_start
self.a_bot_command_pub.publish(a_bot_trajectory)
self.b_bot_command_pub.publish(b_bot_trajectory)
else:
# print("Auto execution selected. Executing")
a_bot_trajectory.header.stamp = time_to_start
b_bot_trajectory.header.stamp = time_to_start
# if(time_to_start.to_sec() > rospy.Time.now().to_sec()):
# print("Time in header = " + str(time_to_start.to_sec()))
# print("Published time = " + str(rospy.Time.now().to_sec()))
# else:
# rospy.logerr("Time in header = " + str(time_to_start.to_sec()))
# rospy.logerr("Published time = " + str(rospy.Time.now().to_sec()))
self.a_bot_command_pub.publish(a_bot_trajectory)
self.b_bot_command_pub.publish(b_bot_trajectory)
return time_to_start + a_bot_trajectory.points[-1].time_from_start
except:
raise
def execute_throw_trajectory_(
self,
a_bot_trajectory,
b_bot_trajectory,
time_of_flight=0.5,
speed_factor=1.0,
reverse=False,
confirm_execution=True,
start_time=None,
):
a_bot_whole_trajectory = copy.deepcopy(a_bot_trajectory)
b_bot_whole_trajectory = copy.deepcopy(b_bot_trajectory)
last_time = rospy.Duration(0)
old_last_time = rospy.Duration(0)
new_a_bot_trajectory = copy.deepcopy(a_bot_whole_trajectory)
for i in range(len(a_bot_whole_trajectory.points)):
if not i == 0:
step_length = (
a_bot_whole_trajectory.points[i].time_from_start
- a_bot_whole_trajectory.points[i - 1].time_from_start
)
else:
step_length = a_bot_whole_trajectory.points[i].time_from_start
new_step_length = step_length / speed_factor
new_a_bot_trajectory.points[i].time_from_start = new_step_length + last_time
last_time = new_step_length + last_time
last_time = rospy.Duration(0)
old_last_time = rospy.Duration(0)
new_b_bot_trajectory = copy.deepcopy(b_bot_whole_trajectory)
for i in range(len(b_bot_whole_trajectory.points)):
if not i == 0:
step_length = (
b_bot_whole_trajectory.points[i].time_from_start
- b_bot_whole_trajectory.points[i - 1].time_from_start
)
else:
step_length = b_bot_whole_trajectory.points[i].time_from_start
new_step_length = step_length / speed_factor
new_b_bot_trajectory.points[i].time_from_start = new_step_length + last_time
last_time = new_step_length + last_time
time_to_start = start_time
req = GetPlanningSceneRequest()
req.components.components = req.components.ROBOT_STATE
planning_scene = self.get_planning_scene_service(req)
a_bot_display_traj = moveit_msgs.msg.DisplayTrajectory()
b_bot_display_traj = moveit_msgs.msg.DisplayTrajectory()
a_bot_robot_traj = moveit_msgs.msg.RobotTrajectory()
a_bot_robot_traj.joint_trajectory = copy.deepcopy(new_a_bot_trajectory)
b_bot_robot_traj = moveit_msgs.msg.RobotTrajectory()
b_bot_robot_traj.joint_trajectory = copy.deepcopy(new_b_bot_trajectory)
a_bot_display_traj.trajectory.append(a_bot_robot_traj)
b_bot_display_traj.trajectory.append(b_bot_robot_traj)
a_bot_display_traj.trajectory_start = planning_scene.scene.robot_state
b_bot_display_traj.trajectory_start = planning_scene.scene.robot_state
self.a_bot_display_traj_pub.publish(a_bot_display_traj)
self.b_bot_display_traj_pub.publish(b_bot_display_traj)
if confirm_execution:
print("Execute this trajectory? y/n")
e = raw_input()
if e == "y":
now = rospy.Time.now() + rospy.Duration(1.0)
new_a_bot_trajectory.header.stamp = now
new_b_bot_trajectory.header.stamp = now
self.a_bot_command_pub.publish(new_a_bot_trajectory)
self.b_bot_command_pub.publish(new_b_bot_trajectory)
else:
print("Auto execution selected. Executing")
new_a_bot_trajectory.header.stamp = time_to_start
new_b_bot_trajectory.header.stamp = time_to_start
self.a_bot_command_pub.publish(new_a_bot_trajectory)
self.b_bot_command_pub.publish(new_b_bot_trajectory)
return time_to_start + new_a_bot_trajectory.points[-1].time_from_start
# if(reverse):
# self.last_stick_positions["pos_left"] = left_stick_traj.poses[0].position
# self.last_stick_positions["pos_right"] = right_stick_traj.poses[0].position
# Increase the time from start for all the
# rospy.sleep(time_of_flight)
# TEMP: Reverse motion nack to starting point of the trajectory
# req = CreateRobotTrajectoryRequest()
# number_of_poses = len(left_stick_traj.poses)
# resp = self.command_robot_trajectory_service(req)
# if(resp.success):
# print("Reverse trajectory executed!")
def make_prediction_request_msg_(
self, planned_left_poses=None, planned_right_poses=None
):
# Goal positions and velocities are arrays of the appropriate type
req = CreateSticksTrajectoryRequest()
################### Set current Sim Config
req.current_sim_config.pv_pre_cap_scale = 0.13
req.current_sim_config.pv_post_cap_scale = 0.13
req.current_sim_config.pv_cap_scale = 0.07
req.current_sim_config.velocity_diffusion_factor = 0.9999
if (
self.motion_functions[self.current_motion + "_sl"]["motion_type"]
== "oneshot"
):
req.motion_flag = CreateSticksTrajectoryRequest.THROW
elif (
self.motion_functions[self.current_motion + "_sl"]["motion_type"]
== "periodic"
):
req.motion_flag = CreateSticksTrajectoryRequest.LOOP
# Diabolo constant parameters
req.current_sim_config.mass = 0.2
req.current_sim_config.axle_radius = 0.0065
req.current_sim_config.string_length = 1.58
if planned_left_poses and planned_right_poses:
req.planned_left_stick_poses = copy.deepcopy(planned_left_poses)
req.planned_right_stick_poses = copy.deepcopy(planned_right_poses)
return req
def run_oneshot_motion(
self,
interactive=True,
confirm_execution=True,
preparatory_motion="horizontal_impulse",
):
planned_left_poses = None
planned_right_poses = None
# The trajectory begins one second from now
trajectory_start_time = rospy.Time.now() + rospy.Duration(1.0)
prediction_time = 0
diab_state_req = GetDiaboloStateRequest()
diab_state_req.header.stamp = rospy.Time.now()
diabolo_state_resp = copy.deepcopy(
self.get_diabolo_state_service(diab_state_req)
)
self.latest_diabolo_state = copy.deepcopy(diabolo_state_resp.state)
# Get diabolo orientation here, to handle pitch and yaw
dp = self.latest_diabolo_state.pose.orientation
self.get_stick_tips_from_tf()
left_stick_start_pos = self.last_stick_positions["pos_left"]
right_stick_start_pos = self.last_stick_positions["pos_right"]
# Execute a pre-defined motion (e.g. to give a horizontal impulse for sideways throws)
if self.current_motion == "left_throw" or self.current_motion == "right_throw":
motion = copy.deepcopy(self.current_motion)
self.current_motion = do_preparatory_motion
prediction_start_time = rospy.Time.now()
(
a_bot_trajectory,
b_bot_trajectory,
left_stick_poses,
right_stick_poses,
) = self.call_prediction_service(
interactive=False,
planned_left_poses=planned_left_poses,
planned_right_poses=planned_right_poses,
left_stick_start_pos=left_stick_start_pos,
right_stick_start_pos=right_stick_start_pos,
plan=False,
)
trajectory_end_time = self.execute_periodic_trajectory_(
a_bot_trajectory,
b_bot_trajectory,
1.0,
True,
start_time=trajectory_start_time,
)
safe_prediction_time = rospy.Duration(0.5)
sleep_time = (trajectory_end_time - rospy.Time.now()) - safe_prediction_time
rospy.sleep(sleep_time)
diab_state_req = GetDiaboloStateRequest()
diab_state_req.header.stamp = rospy.Time.now()
diabolo_state_resp = copy.deepcopy(
self.get_diabolo_state_service(diab_state_req)
)
self.latest_diabolo_state = copy.deepcopy(diabolo_state_resp.state)
trajectory_start_time = trajectory_end_time
self.current_motion = motion
(
a_bot_trajectory,
b_bot_trajectory,
left_stick_poses,
right_stick_poses,
) = self.call_prediction_service(
interactive=True,
planned_left_poses=planned_left_poses,
planned_right_poses=planned_right_poses,
left_stick_start_pos=left_stick_start_pos,
right_stick_start_pos=right_stick_start_pos,
plan=False,
)
if a_bot_trajectory:
trajectory_end_time = self.execute_throw_trajectory_(
a_bot_trajectory,
b_bot_trajectory,
1.0,
1.0,
True,
False,
start_time=trajectory_start_time,
)
# Create reverse trajectory
# TODO: Add the initial point to the reversed trajectory. The calculated trajectory does not have the first point.
# There is probably also not much point keeping the last point of the old trajectory (That is the current position)
reverse_a_bot_trajectory = JointTrajectory()
reverse_b_bot_trajectory = JointTrajectory()
# print(len(a_bot_trajectory.points))
reverse_a_bot_trajectory.joint_names = a_bot_trajectory.joint_names
reverse_b_bot_trajectory.joint_names = b_bot_trajectory.joint_names
for i in range(len(a_bot_trajectory.points)):
# print("Now adding " + str(a_bot_trajectory.points[i].time_from_start.to_sec()) + " time from start reverse traj")
reverse_a_bot_trajectory.points.append(
copy.deepcopy(
a_bot_trajectory.points[len(a_bot_trajectory.points) - 1 - i]
)
)
reverse_a_bot_trajectory.points[
i
].time_from_start = a_bot_trajectory.points[i].time_from_start
for i in range(len(b_bot_trajectory.points)):
reverse_b_bot_trajectory.points.append(
copy.deepcopy(
b_bot_trajectory.points[len(b_bot_trajectory.points) - 1 - i]
)
)
reverse_b_bot_trajectory.points[
i
].time_from_start = b_bot_trajectory.points[i].time_from_start
# rospy.logwarn("Forward trajectory")
# print(a_bot_trajectory)
# rospy.logwarn("Reverse trajectory")
# print(reverse_a_bot_trajectory)
print("Reverse trajectory? y/n?")
e = raw_input()
if e == "y":
trajectory_start_time = rospy.Time.now() + rospy.Duration(0.01)
trajectory_end_time = self.execute_throw_trajectory_(
reverse_a_bot_trajectory,
reverse_b_bot_trajectory,
1.0,
0.8,
False,
False,
start_time=trajectory_start_time,
)
else:
rospy.logerr("Could not find a trajectory")
def start_periodic_motion(
self,
interactive=True,
confirm_execution=True,
preparatory_motion="horizontal_impulse",
):
self.stop_motion_flag = False
thread.start_new_thread(
self.run_periodic_motion,
(interactive, confirm_execution, preparatory_motion),
)
def stop_periodic_motion(self):
self.stop_motion_flag = True
def run_periodic_motion(
self,
interactive=False,
confirm_execution=True,
preparatory_motion="horizontal_impulse",
):
#### IMPORTANT: This assumes that the points in the trajectory are evenly spaced
#### That must be assured by the node providing the stick trajectory/robot trajectory generating service
planned_left_poses = None
planned_right_poses = None
# The trajectory begins one second from now
trajectory_start_time = rospy.Time.now() + rospy.Duration(1.0)
prediction_time = 0
diab_state_req = GetDiaboloStateRequest()
diab_state_req.header.stamp = rospy.Time.now()
diabolo_state_resp = copy.deepcopy(
self.get_diabolo_state_service(diab_state_req)
)
self.latest_diabolo_state = copy.deepcopy(diabolo_state_resp.state)
# Get diabolo orientation here, to handle pitch and yaw
dp = self.latest_diabolo_state.pose.orientation
self.get_stick_tips_from_tf()
left_stick_start_pos = self.last_stick_positions["pos_left"]
right_stick_start_pos = self.last_stick_positions["pos_right"]
# First, execute the pre-defined horizontal motion
motion = copy.deepcopy(self.current_motion)
if preparatory_motion:
self.current_motion = preparatory_motion
(
a_bot_trajectory,
b_bot_trajectory,
left_stick_poses,
right_stick_poses,
) = self.call_prediction_service(
interactive=False,
planned_left_poses=None,
planned_right_poses=None,
left_stick_start_pos=left_stick_start_pos,
right_stick_start_pos=right_stick_start_pos,
plan=False,
)
trajectory_end_time = self.execute_periodic_trajectory_(
a_bot_trajectory,
b_bot_trajectory,
1.0,
confirm_execution,
start_time=trajectory_start_time,
)
# In this part of the code, "prediction" means motion generation
safe_prediction_time = rospy.Duration(0.5)
prediction_start_time = (
trajectory_end_time - trajectory_start_time
) - safe_prediction_time
print("Prediction start time = " + str(prediction_start_time.to_sec()))
# Break out if there is not enough time to plan
if prediction_start_time.to_sec() < 0.0:
print(
"Prediction time is too long. Is = "
+ str(safe_prediction_time.to_sec())
)
prediction_start_time = trajectory_end_time
planned_left_poses = None
planned_right_poses = None
last_traj_end_time = rospy.Time.now() + rospy.Duration(1.0)
else:
# rospy.logwarn("prediction_start_time is " + str(prediction_start_time.to_sec()))
# rospy.logwarn("Trajectory length is " + str((trajectory_end_time - trajectory_start_time).to_sec()))
# Find the point from which to get planned poses
planned_left_poses = geometry_msgs.msg.PoseArray()
planned_right_poses = geometry_msgs.msg.PoseArray()
# This is the id of the last pose to execute in the sent trajectory
last_pose_to_execute = 0
for j in range(len(a_bot_trajectory.points) - 1):
# print("Time from start for j = " + str(j) + " is" + str(a_bot_trajectory.points[j].time_from_start.to_sec()))
if (
a_bot_trajectory.points[j].time_from_start
<= prediction_start_time
and a_bot_trajectory.points[j + 1].time_from_start
> prediction_start_time
):
# pass the left and right poses from the ith position onwards as planned trajectories to the prediction node
planned_left_poses.poses = left_stick_poses.poses[j:]
planned_right_poses.poses = right_stick_poses.poses[j:]
last_pose_to_execute = j
break
# Store end position of start trajectory as start position of old trajectory
print(
"last_pose to execute is "
+ str(last_pose_to_execute)
+ " at time "
+ str(
a_bot_trajectory.points[
last_pose_to_execute
].time_from_start.to_sec()
)
)
left_stick_start_pos = planned_left_poses.poses[0].position
right_stick_start_pos = planned_right_poses.poses[0].position
planned_left_poses.poses = planned_left_poses.poses[1:]
planned_right_poses.poses = planned_right_poses.poses[1:]
# Sleep until the next trajectory is at left_stick_start_pos
now = rospy.Time.now()
sleep_time1 = (
trajectory_start_time - now
) # Until current trajectory is over
sleep_time2 = (
trajectory_end_time - trajectory_start_time
) - safe_prediction_time
# Until next trajectory is at left_stick_start_pos
sleep_time = sleep_time1 + sleep_time2
rospy.sleep(sleep_time)
# Change the current motion back to what it was before applying the impulse
self.current_motion = motion
trajectory_start_time = trajectory_end_time
else:
trajectory_start_time = rospy.Time.now() + rospy.Duration(1.0)
prediction_time = 0
diab_state_req = GetDiaboloStateRequest()
diab_state_req.header.stamp = rospy.Time.now()
diabolo_state_resp = copy.deepcopy(
self.get_diabolo_state_service(diab_state_req)
)
self.latest_diabolo_state = copy.deepcopy(diabolo_state_resp.state)
while True:
prediction_start_time = rospy.Time.now()
(
a_bot_trajectory,
b_bot_trajectory,
left_stick_poses,
right_stick_poses,
) = self.call_prediction_service(
interactive=True,
planned_left_poses=planned_left_poses,
planned_right_poses=planned_right_poses,
left_stick_start_pos=left_stick_start_pos,
right_stick_start_pos=right_stick_start_pos,
plan=False,
)
# If user-set flag is true, stop moving the arms
if self.stop_motion_flag or rospy.is_shutdown():
break
# Ensure that the prediction service found something
if a_bot_trajectory:
reverse = False
if (
self.motion_functions[self.current_motion + "_sl"]["motion_type"]
== "periodic"
):
# Queue up the trajectory in the driver, so it will be executed next
trajectory_end_time = self.execute_periodic_trajectory_(
a_bot_trajectory,
b_bot_trajectory,
1.0,
confirm_execution,
start_time=trajectory_start_time,
)
# Time that this prediction/motion generation took
prediction_time = rospy.Time.now() - prediction_start_time
# Add safety buffer
safe_prediction_time = prediction_time + prediction_time * 0.3
# This should be the time from start for the first pose for the list of "planned poses"
# when planning the next trajectory
prediction_start_time = (
trajectory_end_time - trajectory_start_time
) - safe_prediction_time
# Don't plan another trajectory if there is not enough time to plan it
if prediction_start_time.to_sec() < 0.0:
# print("Prediction time is too long. Is = " + str(safe_prediction_time.to_sec()))
prediction_start_time = trajectory_end_time
planned_left_poses = None
planned_right_poses = None
last_traj_end_time = rospy.Time.now() + rospy.Duration(1.0)
break
else: # Prepare next loop
# rospy.logwarn("prediction_start_time is " + str(prediction_start_time.to_sec()))
# rospy.logwarn("Trajectory length is " + str((trajectory_end_time - trajectory_start_time).to_sec()))
# Find the point from which to get planned poses
planned_left_poses = geometry_msgs.msg.PoseArray()
planned_right_poses = geometry_msgs.msg.PoseArray()
# Find the last point in the stick trajectory to be executed before beginning the prediction
# for the diabolo state at the end of the current trajectory
# Trim planned poses to contain only remainder of next trajectory. This will be used during the
# next iteration.
last_pose_to_execute = 0
for j in range(len(a_bot_trajectory.points) - 1):
if (
a_bot_trajectory.points[j].time_from_start
<= prediction_start_time
and a_bot_trajectory.points[j + 1].time_from_start
> prediction_start_time
):
# pass the left and right poses from the ith positon onwards as planned trajectories to the prediction node
# print("len(a_bot_trajectory.points)", len(a_bot_trajectory.points))
# print("len(left_stick_poses.poses)", len(left_stick_poses.poses))
planned_left_poses.poses = left_stick_poses.poses[j:]
planned_right_poses.poses = right_stick_poses.poses[j:]
last_pose_to_execute = j
break
# Store end position of start trajectory as start position of old trajectory
left_stick_start_pos = planned_left_poses.poses[0].position
right_stick_start_pos = planned_right_poses.poses[0].position
planned_left_poses.poses = planned_left_poses.poses[1:]
planned_right_poses.poses = planned_right_poses.poses[1:]
# Sleep until the next trajectory is at left_stick_start_pos
now = rospy.Time.now()
sleep_time1 = (
trajectory_start_time - now
) # Until current trajectory is over
sleep_time2 = (
trajectory_end_time - trajectory_start_time
) - safe_prediction_time
# Until next trajectory is at left_stick_start_pos
sleep_time = sleep_time1 + sleep_time2
rospy.sleep(sleep_time)
# self.pause_gazebo_service()
diab_state_req = GetDiaboloStateRequest()
diab_state_req.header.stamp = (
trajectory_start_time
+ a_bot_trajectory.points[last_pose_to_execute].time_from_start
)
self.latest_diabolo_state = copy.deepcopy(
self.get_diabolo_state_service(diab_state_req).state
)
trajectory_start_time = trajectory_end_time
# self.unpause_gazebo_service()
return
def get_diabolo_waypoint_goals(
self,
goal_velocity=geometry_msgs.msg.Point(),
goal_position=geometry_msgs.msg.Point(),
):
# This is the initial position. Do not add to request waypoints
goal_states = []
goal_state = DiaboloState()
diabolo_goal_pos = geometry_msgs.msg.Point()
diabolo_goal_vel = geometry_msgs.msg.Point()
# if self.latest_diabolo_pose:
# diabolo_goal_pos = copy.deepcopy(self.latest_diabolo_pose.position)
# else:
if (
self.motion_functions[self.current_motion + "_sl"]["motion_type"]
== "periodic"
):
diabolo_goal_pos = geometry_msgs.msg.Point()
diabolo_goal_pos.x = self.DEFAULT_X_COORD
diabolo_goal_pos.y = -0.0382
diabolo_goal_pos.z = 0.51991
## First waypoint
diabolo_goal_pos.x = self.DEFAULT_X_COORD
diabolo_goal_pos.y = diabolo_goal_pos.y + 0.3
diabolo_goal_pos.z = diabolo_goal_pos.z + 0.2
diabolo_goal_vel.x = 0.0
diabolo_goal_vel.y = -0.5
diabolo_goal_vel.z = 1.0
goal_state.trans_velocity = copy.deepcopy(diabolo_goal_vel)
goal_state.pose.position = copy.deepcopy(diabolo_goal_pos)
goal_state.pose.orientation.w = 1.0
goal_states.append(copy.deepcopy(goal_state))
## Second waypoint
diabolo_goal_pos.x = self.DEFAULT_X_COORD
diabolo_goal_pos.y = diabolo_goal_pos.y - 0.1
diabolo_goal_pos.z = diabolo_goal_pos.z + 0.2
diabolo_goal_vel.x = 0.0
diabolo_goal_vel.y = -1.0
diabolo_goal_vel.z = 0.1
goal_state.trans_velocity = copy.deepcopy(diabolo_goal_vel)
goal_state.pose.position = copy.deepcopy(diabolo_goal_pos)
goal_state.pose.orientation.w = 1.0
goal_states.append(copy.deepcopy(goal_state))
## Third waypoint
diabolo_goal_pos.x = self.DEFAULT_X_COORD
diabolo_goal_pos.y = diabolo_goal_pos.y - 0.5
diabolo_goal_pos.z = diabolo_goal_pos.z + 0.0
diabolo_goal_vel.x = 0.0
diabolo_goal_vel.y = -0.5
diabolo_goal_vel.z = -0.5
goal_state.trans_velocity = copy.deepcopy(diabolo_goal_vel)
goal_state.pose.position = copy.deepcopy(diabolo_goal_pos)
goal_state.pose.orientation.w = 1.0
goal_states.append(copy.deepcopy(goal_state))
## Fourth waypoint
diabolo_goal_pos.x = self.DEFAULT_X_COORD
diabolo_goal_pos.y = diabolo_goal_pos.y - 0.1
diabolo_goal_pos.z = diabolo_goal_pos.z - 0.2
diabolo_goal_vel.x = 0.0
diabolo_goal_vel.y = 1.0
diabolo_goal_vel.z = -0.5
goal_state.trans_velocity = copy.deepcopy(diabolo_goal_vel)
goal_state.pose.position = copy.deepcopy(diabolo_goal_pos)
goal_state.pose.orientation.w = 1.0
goal_states.append(copy.deepcopy(goal_state))
# End of if current motion is circular acceleration
else:
diabolo_goal_pos = geometry_msgs.msg.Point(
x=self.DEFAULT_X_COORD, y=0.0, z=1.25
)
diabolo_goal_vel = geometry_msgs.msg.Point(x=0.0, y=0.0, z=1.4) # 0.1 m
# diabolo_goal_vel = geometry_msgs.msg.Point(x=0.0, y=0.0, z=2.0) # 0.2 m
# diabolo_goal_vel = geometry_msgs.msg.Point(x=0.0, y=0.0, z=2.8) # 0.4 m
# diabolo_goal_vel = geometry_msgs.msg.Point(x=0.0, y=0.0, z=3.4) # 0.6 m
# diabolo_goal_vel = geometry_msgs.msg.Point(x=0.0, y=0.0, z=3.97) # 0.8 m
# diabolo_goal_vel = geometry_msgs.msg.Point(x=0.0, y=0.0, z=4.4) # 1.0 m
goal_state.trans_velocity = copy.deepcopy(diabolo_goal_vel)
goal_state.pose.position = copy.deepcopy(diabolo_goal_pos)
goal_states.append(goal_state)
return goal_states
def save_current_knot_points(self, filename="default.pkl"):
path = os.path.join(self._package_directory, "config", filename)
print("Saving to " + path)
with open(path, "w") as f:
pickle.dump(self.motion_functions, f)
def call_prediction_service(
self,
planned_left_poses=None,
planned_right_poses=None,
interactive=False,
left_stick_start_pos=None,
right_stick_start_pos=None,
plan=True,
):
"""
Call the service that returns a robot trajectory for a given set of diabolo goal states.
The service starts planning a new motion starting from a point in the future.
planned_left_poses, planned_right_poses are the stick trajectories that will be executed
until that point in the future.
The current diabolo state is added inside this method, and the diabolo state in the future
estimated using the planned_poses.
left_stick_start_pos, right_stick_start_pos are the stick positions *before* that prediction,
or the start position to plan from if the planned_poses are empty.
"""
## Set diabolo goal states
# rospy.logwarn("Entered prediction service function")
## TODO: Change this to allow multiple waypoint goals
req = self.make_prediction_request_msg_(planned_left_poses, planned_right_poses)
req.goal_states = self.get_diabolo_waypoint_goals()
## Set current sim config
# Diabolo velocity and pose
diabolo_pose = Pose()
diabolo_vel = geometry_msgs.msg.Point()
if self.latest_diabolo_state:
# print("Using actual diabolo starting position")
diabolo_pose = self.latest_diabolo_state.pose
diabolo_vel = self.latest_diabolo_state.trans_velocity
else:
rospy.logwarn("Using default diabolo coordinates for prediction service")
diabolo_pose.position.x = self.DEFAULT_X_COORD
diabolo_pose.position.y = 0.053
diabolo_pose.position.z = 0.554
req.current_sim_config.trans_velocity = geometry_msgs.msg.Point()
sl_pose = Pose()
sr_pose = Pose()
# self.get_stick_tips_from_tf()
## TODO: Get the actual current stick poses. This is temporary
sl_pose.position = left_stick_start_pos
sr_pose.position = right_stick_start_pos
req.current_sim_config.initial_poses.poses.append(diabolo_pose)
req.current_sim_config.trans_velocity = diabolo_vel
req.current_sim_config.initial_poses.poses.append(sl_pose)
req.current_sim_config.initial_poses.poses.append(sr_pose)
# IMPORTANT: Must give stick update rate and sim time step
req.stick_update_time_step = 1.0 / self.pub_rate
req.current_sim_config.time_step = 0.002
req.optimize = plan
req.constrain_to_YZ = True
# Set spline knot point seeds
# Set seeds for left stick
time_seed = self.motion_functions[self.current_motion + "_sl"]["time_seed"]
# Plot the stick trajectories/splines
# These are the seeds for the chosen motion
if not interactive:
"""
If not interactive, use the motion seeds precalculated for the current motion
"""
left_motion = self.motion_functions[self.current_motion + "_sl"]
right_motion = self.motion_functions[self.current_motion + "_sr"]
# The number of knot points should correspond to the number of time seeds
for i in range(len(time_seed)):
left_knot_point = geometry_msgs.msg.Point()
right_knot_point = geometry_msgs.msg.Point()
if (
i == len(time_seed) - 1
and self.motion_functions[self.current_motion + "_sl"][
"motion_type"
]
== "periodic"
):
# If this is a periodic motion, the last knot point must be at the initial robot position
left_knot_point = geometry_msgs.msg.Point()
right_knot_point = geometry_msgs.msg.Point()
else:
left_knot_point.x = copy.deepcopy(left_motion["x_knot_seed"][i])
left_knot_point.y = copy.deepcopy(left_motion["y_knot_seed"][i])
left_knot_point.z = copy.deepcopy(left_motion["z_knot_seed"][i])
right_knot_point.x = copy.deepcopy(right_motion["x_knot_seed"][i])
right_knot_point.y = copy.deepcopy(right_motion["y_knot_seed"][i])
right_knot_point.z = copy.deepcopy(right_motion["z_knot_seed"][i])
if self.changed_tilt_offset_flag:
# This means the tilt offset has changed since the last trajectory.
# Must add tilt over the course of this new trajectory
print(
"Setting left x knot seed at "
+ str(self.tilt_offset * ((float(i + 1)) / len(time_seed)))
)
left_knot_point.x -= self.tilt_offset * (
float((i + 1.0)) / len(time_seed)
)
right_knot_point.x += self.tilt_offset * (
float((i + 1.0)) / len(time_seed)
)
req.knot_seeds.left_seed.append(copy.deepcopy(left_knot_point))
req.knot_seeds.right_seed.append(copy.deepcopy(right_knot_point))
req.knot_seeds.time_seed.append(copy.deepcopy(time_seed[i]))
else:
"""
If interactive, set the motion seeds to the points gotten from the interactive markers
"""
marker_positions = copy.deepcopy(
self.knot_point_server.get_marker_positions(relative=True)
)
# Replace current knot seeds with newly set knot seeds
self.motion_functions[self.current_motion + "_sl"]["x_knot_seed"] = []
self.motion_functions[self.current_motion + "_sl"]["y_knot_seed"] = []
self.motion_functions[self.current_motion + "_sl"]["z_knot_seed"] = []
self.motion_functions[self.current_motion + "_sr"]["x_knot_seed"] = []
self.motion_functions[self.current_motion + "_sr"]["z_knot_seed"] = []
self.motion_functions[self.current_motion + "_sr"]["y_knot_seed"] = []
left_positions = marker_positions[0]
right_positions = marker_positions[1]
# print(left_positions)
for i in range(len(time_seed)):
left_knot_point = geometry_msgs.msg.Point()
right_knot_point = geometry_msgs.msg.Point()
if (
i == len(time_seed) - 1
and self.motion_functions[self.current_motion + "_sl"][
"motion_type"
]
== "periodic"
):
# If this is a periodic motion, the last knot point must be at the initial robot position
left_knot_point = geometry_msgs.msg.Point()
right_knot_point = geometry_msgs.msg.Point()
else:
left_knot_point = copy.deepcopy(left_positions[i])
right_knot_point = copy.deepcopy(right_positions[i])
self.motion_functions[self.current_motion + "_sl"][
"x_knot_seed"
].append(left_knot_point.x)
self.motion_functions[self.current_motion + "_sl"][
"y_knot_seed"
].append(left_knot_point.y)
self.motion_functions[self.current_motion + "_sl"][
"z_knot_seed"
].append(left_knot_point.z)
self.motion_functions[self.current_motion + "_sr"][
"x_knot_seed"
].append(right_knot_point.x)
self.motion_functions[self.current_motion + "_sr"][
"y_knot_seed"
].append(right_knot_point.y)
self.motion_functions[self.current_motion + "_sr"][
"z_knot_seed"
].append(right_knot_point.z)
if self.changed_tilt_offset_flag:
# This means the tilt offset has changed since the last trajectory.
# Must add tilt over the course of this new trajectory
print(
"Setting left x knot seed at "
+ str(self.tilt_offset * ((float(i + 1)) / len(time_seed)))
)
left_knot_point.x -= self.tilt_offset * (
float((i + 1.0)) / len(time_seed)
)
right_knot_point.x += self.tilt_offset * (
float((i + 1.0)) / len(time_seed)
)
req.knot_seeds.left_seed.append(copy.deepcopy(left_knot_point))
req.knot_seeds.right_seed.append(copy.deepcopy(right_knot_point))
req.knot_seeds.time_seed.append(copy.deepcopy(time_seed[i]))
self.changed_tilt_offset_flag = False
# rospy.logwarn("Calling prediction service")
resp = self.generate_trajectory_service(req)
# rospy.logwarn("Prediction service returned")
if resp.success:
# print("Got trajectories!")
self.marker_count = 0
marker_array = []
self.left_traj_plan_marker = self._make_marker_from_mesh(
mesh_filename="",
namespace="left_stick_plan",
scale=(0.01, 1, 1),
color=(1, 0, 0),
)
self.left_traj_plan_marker.type = visualization_msgs.msg.Marker.LINE_STRIP
for i in resp.left_stick_poses.poses:
self.left_traj_plan_marker.points.append(i.position)
self.right_traj_plan_marker = self._make_marker_from_mesh(
mesh_filename="",
namespace="right_stick_plan",
scale=(0.01, 1, 1),
color=(0, 0, 1),
)
self.right_traj_plan_marker.type = visualization_msgs.msg.Marker.LINE_STRIP
for i in resp.right_stick_poses.poses:
self.right_traj_plan_marker.points.append(i.position)
marker_array.append(copy.deepcopy(self.left_traj_plan_marker))
marker_array.append(copy.deepcopy(self.right_traj_plan_marker))
self.sphere_marker_1.pose = sr_pose
self.sphere_marker_1.pose.orientation.w = 1.0
self.sphere_marker_1.ns = "right_stick_plan"
self.sphere_marker_1.color.r = 0
self.sphere_marker_1.color.g = 0
self.sphere_marker_1.color.b = 1
self.sphere_marker_2.pose = sl_pose
self.sphere_marker_2.ns = "left_stick_plan"
self.sphere_marker_2.pose.orientation.w = 1.0
self.sphere_marker_2.color.r = 1
self.sphere_marker_2.color.g = 0
self.sphere_marker_2.color.b = 0
marker_array.append(copy.deepcopy(self.sphere_marker_1))
marker_array.append(copy.deepcopy(self.sphere_marker_2))
# Display diabolo start state with a white marker
initial_pos_shell_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_shell.stl",
color=(1.0, 1.0, 1.0),
scale=[0.001, 0.001, 0.001],
namespace="initial_pos",
)
initial_pos_shell_marker.pose = diabolo_pose
initial_pos_fixator_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_fixators.stl",
color=(1.0, 1.0, 1.0),
scale=[0.001, 0.001, 0.001],
namespace="initial_pos",
)
initial_pos_fixator_marker.pose = diabolo_pose
initial_pos_axis_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_axis.stl",
color=(1.0, 1.0, 1.0),
scale=[0.001, 0.001, 0.001],
namespace="initial_pos",
)
initial_pos_axis_marker.pose = diabolo_pose
marker_array.append(copy.deepcopy(initial_pos_shell_marker))
marker_array.append(copy.deepcopy(initial_pos_fixator_marker))
marker_array.append(copy.deepcopy(initial_pos_axis_marker))
initial_diabolo_vel_marker = self._make_marker_from_mesh(
"",
color=(1.0, 1.0, 1.0),
scale=[0.03, 0.02, 0.02],
namespace="initial_pos",
)
initial_vel_base = geometry_msgs.msg.Point()
initial_vel_tip = geometry_msgs.msg.Point()
initial_diabolo_vel_marker.type = visualization_msgs.msg.Marker.ARROW
initial_vel_base = diabolo_pose.position
initial_vel_tip.x = initial_vel_base.x + (diabolo_vel.x) / 2.0
initial_vel_tip.y = initial_vel_base.y + (diabolo_vel.y) / 2.0
initial_vel_tip.z = initial_vel_base.z + (diabolo_vel.z) / 2.0
initial_diabolo_vel_marker.points.append(initial_vel_base)
initial_diabolo_vel_marker.points.append(initial_vel_tip)
marker_array.append(copy.deepcopy(initial_diabolo_vel_marker))
marker_count = self.marker_count
diabolo_shell_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_shell.stl",
color=(0.0, 1.0, 0.0),
scale=[0.001, 0.001, 0.001],
namespace="",
)
diabolo_fixator_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_fixators.stl",
color=(0.1, 0.1, 0.1),
scale=[0.001, 0.001, 0.001],
namespace="",
)
diabolo_axis_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_axis.stl",
color=(0.7, 0.7, 0.7),
scale=[0.001, 0.001, 0.001],
namespace="",
)
goal_diabolo_shell_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_shell.stl",
color=(100.0 / 255.0, 255.0 / 255.0, 50.0 / 255.0),
scale=[0.001, 0.001, 0.001],
namespace="",
)
goal_diabolo_fixator_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_fixators.stl",
color=(0.1, 0.1, 0.1),
scale=[0.001, 0.001, 0.001],
namespace="",
)
goal_diabolo_axis_marker = self._make_marker_from_mesh(
"package://diabolo_scene_description/meshes/diabolo_axis.stl",
color=(0.7, 0.7, 0.7),
scale=[0.001, 0.001, 0.001],
namespace="",
)
goal_diabolo_vel_marker = self._make_marker_from_mesh(
"",
color=(100.0 / 255.0, 255.0 / 255.0, 50.0 / 255.0),
scale=[0.02, 0.02, 0.02],
namespace="",
)
diabolo_to_goal_marker = self._make_marker_from_mesh(
"",
color=(1.0, 1.0, 1.0),
scale=[0.01, 0.02, 0.02],
namespace="",
alpha=0.5,
)
self.marker_count = marker_count + 1
for i in range(len(req.goal_states)):
ns = "waypoint_" + str(i)
# diabolo_shell_marker.pose = resp.diabolo_states[i].pose
# diabolo_fixator_marker.pose = resp.diabolo_states[i].pose
# diabolo_axis_marker.pose = resp.diabolo_states[i].pose
self.sphere_marker_g = self._make_marker_from_mesh(
"",
color=(240.0 / 255.0, 230.0 / 255.0, 50.0 / 255.0),
scale=[0.05, 0.05, 0.05],
namespace="closest_point_to_goal",
)
self.sphere_marker_g.type = visualization_msgs.msg.Marker.SPHERE
self.sphere_marker_g.pose = resp.diabolo_states[i].pose
self.sphere_marker_g.id = self.marker_count
self.marker_count += 1
marker_array.append(copy.deepcopy(self.sphere_marker_g))
goal_diabolo_shell_marker.pose = req.goal_states[i].pose
goal_diabolo_shell_marker.id = self.marker_count
goal_diabolo_shell_marker.ns = "goal_states"
self.marker_count += 1
goal_diabolo_fixator_marker.pose = req.goal_states[i].pose
goal_diabolo_fixator_marker.id = self.marker_count
goal_diabolo_fixator_marker.ns = "goal_states"
self.marker_count += 1
goal_diabolo_axis_marker.pose = req.goal_states[i].pose
goal_diabolo_axis_marker.id = self.marker_count
goal_diabolo_axis_marker.ns = "goal_states"
self.marker_count += 1
marker_array.append(copy.deepcopy(goal_diabolo_shell_marker))
marker_array.append(copy.deepcopy(goal_diabolo_fixator_marker))
marker_array.append(copy.deepcopy(goal_diabolo_axis_marker))
## The goal state velocity
# goal_vel_base = geometry_msgs.msg.Point()
# goal_vel_tip = geometry_msgs.msg.Point()
# goal_diabolo_vel_marker.type = visualization_msgs.msg.Marker.ARROW
# goal_vel_base = req.goal_states[i].pose.position
# goal_vel_tip.x = goal_vel_base.x + (req.goal_states[i].trans_velocity.x)/2.0
# goal_vel_tip.y = goal_vel_base.y + (req.goal_states[i].trans_velocity.y)/2.0
# goal_vel_tip.z = goal_vel_base.z + (req.goal_states[i].trans_velocity.z)/2.0
# goal_diabolo_vel_marker.points.append(goal_vel_base)
# goal_diabolo_vel_marker.points.append(goal_vel_tip)
## The distance between the goal state and the closest point
# FIXME: This doesn't seem to point to the closest point.
diabolo_to_goal_base = geometry_msgs.msg.Point()
diabolo_to_goal_tip = geometry_msgs.msg.Point()
diabolo_to_goal_marker.type = visualization_msgs.msg.Marker.ARROW
diabolo_to_goal_base = req.goal_states[i].pose.position
diabolo_to_goal_tip = resp.diabolo_states[i].pose.position
diabolo_to_goal_marker.points.append(diabolo_to_goal_base)
diabolo_to_goal_marker.points.append(diabolo_to_goal_tip)
diabolo_to_goal_marker.id = self.marker_count
diabolo_to_goal_marker.ns = "from_goal_to_closest_point"
self.marker_count += 1
marker_array.append(copy.deepcopy(diabolo_to_goal_marker))
# predicted_diabolo_vel_marker = self._make_marker_from_mesh("", color=(0.,1.,0.), scale=[0.02, 0.02, 0.02], namespace=ns)
# predicted_vel_base = geometry_msgs.msg.Point()
# predicted_vel_tip = geometry_msgs.msg.Point()
# predicted_diabolo_vel_marker.type = visualization_msgs.msg.Marker.ARROW
# predicted_vel_base = resp.diabolo_states[i].pose.position
# predicted_vel_tip.x = predicted_vel_base.x + (resp.diabolo_states[i].trans_velocity.x)/2.0
# predicted_vel_tip.y = predicted_vel_base.y + (resp.diabolo_states[i].trans_velocity.y)/2.0
# predicted_vel_tip.z = predicted_vel_base.z + (resp.diabolo_states[i].trans_velocity.z)/2.0
# predicted_diabolo_vel_marker.points.append(predicted_vel_base)
# predicted_diabolo_vel_marker.points.append(predicted_vel_tip)
# marker_array.append(copy.deepcopy(predicted_diabolo_vel_marker))
self.marker_array_pub.publish(marker_array)
# time_of_flight = 2.0*(resp.diabolo_trans_vel.z)/9.81
# rospy.logwarn("Returning trajectories")
return (
resp.a_bot_trajectory,
resp.b_bot_trajectory,
resp.left_stick_poses,
resp.right_stick_poses,
)
else:
# print("Trajectory not found. Aborting")
return None, None, None, None
if __name__ == "__main__":
try:
c = PlayerClass()
i = 1
# print(c.motion_functions)
c.force_add_motion_function_()
prep_motions = ["None", "horizontal_impulse", "horizontal_impulse_short_left"]
# prep_motion = prep_motions[2]
prep_motion = ""
while not rospy.is_shutdown():
rospy.loginfo("Enter 1 to load motion data")
rospy.loginfo(
"Enter 2 to initialize the motion functions with hardcoded values."
)
rospy.loginfo("Enter 3 to initialize the robot positions.")
rospy.loginfo("Enter d to spawn diabolo in simulation")
rospy.loginfo("Enter sx to start playback at custom rate.")
rospy.loginfo("Enter m to change the motion being executed")
rospy.loginfo("Enter n to change the preparatory motion")
rospy.loginfo("Enter ox to start oneshot motion")
rospy.loginfo("Enter px to start continuous periodic motion")
rospy.loginfo("Enter t to stop motion.")
rospy.loginfo("Enter f to tilt the diabolo forward.")
rospy.loginfo("Enter b to tilt the diabolo backward.")
rospy.loginfo("Enter k to save the current knot points")
rospy.loginfo("Enter x to exit.")
i = raw_input()
if i == "1":
c.read_transformed_motion_data(
folder=("experiments/output/2020-09-14_motion_extraction/")
)
elif i == "2":
c.initialize_motion_functions(use_saved_values=False)
elif i == "3":
c.initialize_robot_positions()
elif i == "d" or i == "D":
print("Default parameters are (0.13, 0.13, 0.07, .9999). Change? y/n")
a = raw_input()
if a == "y":
print("Enter the parameters, seperated by spaces")
p = raw_input().split()
if len(p) >= 4:
print(
"New parameters are: "
+ p[0]
+ " "
+ p[1]
+ " "
+ p[2]
+ " "
+ p[3]
)
c.initialize_sim_diabolo(
parameters=(
float(p[0]),
float(p[1]),
float(p[2]),
float(p[3]),
)
)
else:
print("Not enough parameters")
else:
c.initialize_sim_diabolo(
parameters=(0.13, 0.13, 0.07, 0.9999)
) # Set the diabolo plugin parameters and spawn the diabolo
# One-shot / continuous motion execution call
elif i == "ox" or i == "OX":
print(
"This will execute the motion without asking for confirmation. \n Meant for execution in simulation \n Are you sure? y/n?"
)
e = raw_input()
if e == "y":
# TODO: pass preparatory_motion?
c.run_oneshot_motion(interactive=True, confirm_execution=False)
else:
print("Aborting")
elif i == "px" or i == "PX":
print(
"This will execute the motion without asking for confirmation. \n Meant for execution in simulation \n Are you sure? y/n?"
)
e = raw_input()
if e == "y":
c.start_periodic_motion(
interactive=True,
confirm_execution=False,
preparatory_motion=prep_motion,
)
else:
print("Aborting")
elif i == "T" or i == "t":
c.stop_periodic_motion()
elif i == "f":
# To tilt the diabolo forward, the right hand goes forward
c.tilt_offset = 0.03
c.changed_tilt_offset_flag = True
elif i == "b":
c.tilt_offset = -0.03
c.changed_tilt_offset_flag = True
## Changing motion / prep. motion
elif i == "m" or i == "M":
print("The current motion is " + c.current_motion)
print("Change? y/n")
i = raw_input()
if i == "y":
print("List of available functions is as follows: ")
print(
"Enter the appropriate index number to choose the motion to change to"
)
for i in range(len(c.motion_list)):
print(str(i) + ": " + str(c.motion_list[i]))
i = raw_input()
try:
c.current_motion = c.motion_list[int(i)]
except:
print("Incorrect index. Aborting")
raise
elif i == "n" or i == "N":
print("The current preparatory motion is " + prep_motion)
print("Change? y/n")
i = raw_input()
if i == "y":
print("List of available motions: ")
print(
"Enter the appropriate index number to choose the motion to change to"
)
for i in range(len(prep_motions)):
print(str(i) + ": " + str(prep_motions[i]))
i = raw_input()
try:
prep_motion = prep_motions[int(i)]
if prep_motion == "None":
prep_motion = ""
except:
print("Incorrect index. Aborting")
raise
elif i == "r":
c.tilt_offset = 0.0
elif i == "k" or i == "K":
c.save_current_knot_points()
elif i == "x":
# c.stop_publish()
break
elif i == "":
continue
except rospy.ROSInterruptException:
pass
| 103,875 | 33,444 |
from workflow import web
class APIException(Exception):
def __init__(self, status, message, url):
self.status = status
self.message = message
self.url = url
super(APIException, self).__init__(
"{status} > {message}".format(
status=self.status,
message=self.message
)
)
class Genius:
BASE_URL = "https://api.genius.com"
def __init__(self, access_token):
assert access_token
self.access_token = "Bearer {access_token}".format(access_token=access_token)
def __call__(self, service, **params):
url = "{base_url}/{service}".format(base_url=self.BASE_URL, service=service)
params["text_format"] = "plain"
response = web.get(
url=url,
params=params,
headers={"Authorization": self.access_token}
).json()
meta = response["meta"]
if meta["status"] != 200:
raise APIException(meta["status"], meta["message"], url)
return response["response"]
def search(self, text, page=1, per_page=20):
assert text
assert page > 0
assert 21 > per_page > 1
result = self("search", q=text, page=page, per_page=per_page)
return map(
lambda hit: hit["result"],
result.get("hits", [])
)
| 1,378 | 407 |
from setuptools import setup, find_packages
setup(
name='CosmOrc',
version='0.1',
include_package_data=True,
packages=find_packages(),
python_requires='>=3.6',
install_requires=[
'Click==7.0',
'numpy==1.16.2',
'pandas==0.24.2',
'pyaml==19.4.1',
'PySnooper==0.2.8',
'python-dateutil==2.8.0',
'pytz==2019.3',
'PyYAML==5.1.2',
'six==1.12.0',
'typing==3.7.4.1',
],
entry_points='''
[console_scripts]
CosmOrc = main:cli
''',
)
| 555 | 232 |
from ralph.admin.filters import DateListFilter
class BuyoutDateFilter(DateListFilter):
def queryset(self, request, queryset):
queryset = super().queryset(request, queryset)
if queryset is not None:
queryset = queryset.filter(model__category__show_buyout_date=True)
return queryset
| 323 | 93 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
###########################################################
# WARNING: Generated code! #
# ************************** #
# Manual changes may get lost if file is generated again. #
# Only code inside the [MANUAL] tags will be kept. #
###########################################################
from flexbe_core import Behavior, Autonomy, OperatableStateMachine, ConcurrencyContainer, PriorityContainer, Logger
from sweetie_bot_flexbe_states.wait_for_message_state import WaitForMessageState
from sweetie_bot_flexbe_states.compound_action_state import CompoundAction
# Additional imports can be added inside the following tags
# [MANUAL_IMPORT]
# [/MANUAL_IMPORT]
'''
Created on Wed Nov 21 2018
@author: mutronics
'''
class RBC18Part2SM(Behavior):
'''
RBC Presentation Part2
'''
def __init__(self):
super(RBC18Part2SM, self).__init__()
self.name = 'RBC18Part2'
# parameters of this behavior
# references to used behaviors
# Additional initialization code can be added inside the following tags
# [MANUAL_INIT]
# [/MANUAL_INIT]
# Behavior comments:
def create(self):
joy_topic = '/hmi/joystick'
# x:20 y:231, x:260 y:311
_state_machine = OperatableStateMachine(outcomes=['finished', 'failed'])
# Additional creation code can be added inside the following tags
# [MANUAL_CREATE]
# [/MANUAL_CREATE]
with _state_machine:
# x:57 y:34
OperatableStateMachine.add('WaitKey1',
WaitForMessageState(topic=joy_topic, condition=lambda x: x.buttons[12], buffered=False, clear=False),
transitions={'received': 'SpasiboMut', 'unavailable': 'failed'},
autonomy={'received': Autonomy.Off, 'unavailable': Autonomy.Off},
remapping={'message': 'message'})
# x:179 y:106
OperatableStateMachine.add('SpasiboMut',
CompoundAction(t1=[0,0.0], type1='voice/play_wav', cmd1='spasibo_mut_tvoyo_uporstvo_vsegda_radovalo_menya', t2=[0,0.0], type2=None, cmd2='', t3=[0,0.0], type3=None, cmd3='', t4=[0,0.0], type4=None, cmd4=''),
transitions={'success': 'WaitKey2', 'failure': 'failed'},
autonomy={'success': Autonomy.Off, 'failure': Autonomy.Off})
# x:442 y:360
OperatableStateMachine.add('WaitKey3',
WaitForMessageState(topic=joy_topic, condition=lambda x: x.buttons[12], buffered=False, clear=False),
transitions={'received': 'SpasiboZuviel', 'unavailable': 'failed'},
autonomy={'received': Autonomy.Off, 'unavailable': Autonomy.Off},
remapping={'message': 'message'})
# x:123 y:441
OperatableStateMachine.add('SpasiboZuviel',
CompoundAction(t1=[0,0.0], type1='voice/play_wav', cmd1='prekrasno_chuvstvuete_kakaya_skrita_vo_mne_mosch', t2=[0,0.0], type2=None, cmd2='', t3=[0,0.0], type3=None, cmd3='', t4=[0,0.0], type4=None, cmd4=''),
transitions={'success': 'finished', 'failure': 'failed'},
autonomy={'success': Autonomy.Off, 'failure': Autonomy.Off})
# x:428 y:236
OperatableStateMachine.add('SpasiboStefanShiron',
CompoundAction(t1=[0,0.0], type1='voice/play_wav', cmd1='spasibo_ya_uslishala_vse_chto_hotela', t2=[0,0.0], type2=None, cmd2='', t3=[0,0.0], type3=None, cmd3='', t4=[0,0.0], type4=None, cmd4=''),
transitions={'success': 'WaitKey3', 'failure': 'failed'},
autonomy={'success': Autonomy.Off, 'failure': Autonomy.Off})
# x:370 y:44
OperatableStateMachine.add('WaitKey2',
WaitForMessageState(topic=joy_topic, condition=lambda x: x.buttons[12], buffered=False, clear=False),
transitions={'received': 'SpasiboStefanShiron', 'unavailable': 'failed'},
autonomy={'received': Autonomy.Off, 'unavailable': Autonomy.Off},
remapping={'message': 'message'})
return _state_machine
# Private functions can be added inside the following tags
# [MANUAL_FUNC]
# [/MANUAL_FUNC]
| 3,976 | 1,660 |
# AUTOGENERATED! DO NOT EDIT! File to edit: nbs/01_eda.ipynb (unless otherwise specified).
__all__ = ['palet', 'seed_everything', 'print_competition_data', 'get_train_pivot', 'get_train_df', 'count_pct',
'get_classification_df', 'rle2mask', 'make_mask', 'mask2rle', 'plot_mask_image', 'plot_defected_image',
'get_random_idx', 'show_defects']
# Cell
from fastai.vision.all import *
import numpy as np
import pandas as pd
import cv2
from matplotlib import pyplot as plt
# Cell
palet = [
(249, 192, 12), # ClassId 1
(0, 185, 241), # ClassId 2
(114, 0, 218), # ClassId 3
(249,50,12) # ClassId 4
]
# Cell
def seed_everything(seed=69):
"""
Seeds `random`, `os.environ["PYTHONHASHSEED"]`,
`numpy`, `torch.cuda` and `torch.backends`.
"""
warnings.filterwarnings("ignore")
random.seed(seed)
os.environ["PYTHONHASHSEED"] = str(seed)
np.random.seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
# Cell
def print_competition_data(p: Path):
for elem in p.ls():
print(elem)
# Cell
def get_train_pivot(df):
"""
Summarize the training csv with ClassId as columns and values EncodedPixels
"""
def rles2classids(s: pd.Series):
classids = []
for classid in s.index:
if classid != "n":
value = s[classid]
if not (value is np.nan):
classids.append(str(classid))
return " ".join(classids)
train_pivot = df.pivot(
index="ImageId", columns="ClassId", values="EncodedPixels")
train_pivot["n"] = train_pivot.notnull().sum(1)
train_pivot["ClassIds"] = train_pivot.apply(rles2classids, axis=1)
return train_pivot
def get_train_df(path, only_faulty=False, pivot=False, hard_negatives=False):
"""
Get training DataFrame with all the images in data/train_images.
Returns only the faulty images if `only_faulty`.
"""
img_path = path/"train_images"
csv_file_name = path/"train.csv"
train = pd.read_csv(csv_file_name)
img_names = [img.name for img in get_image_files(img_path)]
df_all = pd.DataFrame({'ImageId': img_names})
train_all = pd.merge(df_all, train, on="ImageId", how="outer", indicator=True)
# Renaming and fillna
train_all.rename(columns={'_merge': 'status'}, inplace=True)
rename_dict = {"both": "faulty", "left_only": "no_faulty", "right_only": "missing"}
train_all["status"] = train_all["status"].cat.rename_categories(rename_dict)
train_all = train_all[train_all["status"]!="missing"]
train_all.ClassId.fillna(0, inplace=True)
train_all.ClassId = train_all.ClassId.astype('int64')
train_all.EncodedPixels.fillna(-1, inplace=True)
train_all["ImageId_ClassId"] = train_all["ImageId"] + "_" + train_all["ClassId"].astype('str')
if hard_negatives:
hard_neg_patterns = pd.read_csv(
path/"hard_negatives_patterns.txt", header=None, names=["ImageId"])
cond = train_all["status"]=="faulty"
cond_hn = train_all["ImageId"].isin(hard_neg_patterns["ImageId"].tolist())
train_all = train_all.loc[cond | cond_hn]
if only_faulty:
train_all = train_all[train_all["status"]=="faulty"]
if pivot:
return get_train_pivot(train_all)
return train_all
# Cell
def count_pct(df, column="ClassId"):
"""Returns a `pandas.DataFrame` with count and frequencies stats for `column`."""
class_count = df[column].value_counts().sort_index()
class_count.index.set_names(column, inplace=True)
class_count = class_count.to_frame()
class_count.rename(columns={column: "num"}, inplace=True)
return class_count.assign(freq=lambda df: df["num"] / df["num"].sum())
# Cell
def get_classification_df(df: pd.DataFrame):
"""
Get the DataFrame for the multiclass classification model
"""
def assign_multi_ClassId(x):
"""Returns a string with multi ClassId sep with a blank space (' ')"""
def fill_cols(c):
return c.fillna(5).astype('int64').astype(str)
cols = [fill_cols(x[i]) for i in range(5)]
cols = [col.replace('5', '') for col in cols]
ClassId_multi = cols[0] + " " + cols[1] + " " + \
cols[2] + " " + cols[3] + " " + cols[4]
ClassId_multi = ClassId_multi.str.strip()
ClassId_multi = ClassId_multi.str.replace(' ', ' ')
return ClassId_multi.str.strip()
train_multi = df.pivot(
index="ImageId", columns="ClassId", values="ClassId")
train_multi = train_multi.assign(
ClassId_multi=lambda x: assign_multi_ClassId(x))
return train_multi.reset_index()[["ImageId", "ClassId_multi"]]
# Cell
def rle2mask(rle, value=1, shape=(256,1600)):
"""
mask_rle: run-length as string formated (start length)
shape: (width,height) of array to return
Returns numpy array, 1 - mask, 0 - background
Source: https://www.kaggle.com/paulorzp/rle-functions-run-lenght-encode-decode
"""
s = rle.split()
starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]
starts -= 1
ends = starts + lengths
img = np.zeros(shape[0]*shape[1], dtype=np.uint8)
for lo, hi in zip(starts, ends):
img[lo:hi] = value
return img.reshape((shape[1], shape[0])).T
# Cell
def make_mask(item, df, flatten=False):
'''
Given an item as:
- row index [int] or
- ImageId [str] or
- file [Path] or
- query [pd.Series],
returns the image_item and mask with two types of shapes:
- (256, 1600) if `flatten`,
- (256, 1600, 4) if not `flatten`,
'''
if isinstance(item, str): cond = df.loc[item]
elif isinstance(item, int): cond = df.iloc[item]
elif isinstance(item, Path): cond = df.loc[item.name]
elif isinstance(item, pd.Series): cond = df.loc[item["ImageId"]]
else:
print(item, type(item))
raise KeyError("invalid item")
fname = cond.name
# without 0 ClassId, only 1,2,3,4 ClassId
labels = cond[1:-2]
h, w = (256, 1600)
masks = np.zeros((h, w, 4), dtype=np.float32) # 4:class 1～4 (ch:0～3)
for itemx, label in enumerate(labels.values):
if label is not np.nan:
masks[:, :, itemx] = rle2mask(rle=label, value=1, shape=(h,w))
if flatten:
classes = np.array([1, 2, 3, 4])
masks = (masks * classes).sum(-1)
return fname, masks
# Cell
def mask2rle(mask):
"""
Efficient implementation of mask2rle, from @paulorzp
img: numpy array, 1 - mask, 0 - background
Returns run length as string formated
Source: https://www.kaggle.com/xhlulu/efficient-mask2rle
"""
pixels = mask.T.flatten()
pixels = np.pad(pixels, ((1, 1), ))
runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
runs[1::2] -= runs[::2]
return ' '.join(str(x) for x in runs)
# Cell
def plot_mask_image(name: str, img: np.array, mask: np.array):
"""Plot a np.array image and mask with contours."""
fig, ax = plt.subplots(figsize=(15, 5))
mask = mask.astype(np.uint8)
for ch in range(4):
contours, _ = cv2.findContours(mask[:, :, ch], cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
for i in range(len(contours)):
cv2.polylines(img, contours[i], True, palet[ch], 2)
ax.set_title(name, fontsize=13)
ax.imshow(img)
plt.xticks([])
plt.yticks([])
plt.show()
# Cell
def plot_defected_image(img_path: Path, df: pd.DataFrame, class_id=None):
"""Plot a `img_path` Path image from the training folder with contours."""
img_name = img_path.name
img = cv2.imread(str(img_path))
_, mask = make_mask(img_path, df)
class_ids = np.arange(1, 5)
cond = np.argmax(mask, axis=0).argmax(axis=0) > 0
classid = class_ids[cond]
if class_id is None:
title = f"Original: Image {img_name} with defect type: {list(classid)}"
plot_mask_image(title, img, mask)
else:
title = f"Original: Image {img_name} with defect type {class_id}"
idx = class_id-1
filter_mask = np.zeros((256, 1600, 4), dtype=np.float32)
filter_mask[:, :, idx] = mask[:, :, idx]
plot_mask_image(title, img, filter_mask)
# Cell
def get_random_idx(n: int) -> np.ndarray:
"""
Return a random sequence of size `n`.
"""
rng = np.random.default_rng()
return rng.permutation(n)
# Cell
def show_defects(path, df, class_id=None, n=20, only_defects=True, multi_defects=False):
"""
Plot multiple images.
Attributes:
`path`: [Path]
`df`: [pd.DataFrame] only train_pivot
`class_id`: [str or int] select a type of defect otherwise plot all kinds;
`n`: select the number of images to plot;
`only_defects` [bool, default True]: if False it shows even the no faulty images;
`multi_defects` [bool, default False]: if True it shows imgs with multi defects.
"""
cond_no_defects = df[0] == -1
cond_multi_defects = df["n"] > 1
df = df.loc[cond_no_defects] if not only_defects else df.loc[~cond_no_defects]
df = df.loc[cond_multi_defects] if multi_defects else df.loc[~cond_multi_defects]
if class_id is not None:
cond_classId = df[class_id].notna()
df = df.loc[cond_classId]
imgid_from_df = df.index.tolist()
pfiles_list = L([path / "train_images" / imgid for imgid in imgid_from_df])
perm_paths = pfiles_list[get_random_idx(len(pfiles_list))]
for img_path in perm_paths[:n]:
plot_defected_image(img_path, df) | 9,512 | 3,517 |
import pickle
import zlib
from django.core.cache import cache
from fila_da_creche.queries.dt_atualizacao import get_dt_atualizacao
from rest_framework.response import Response
from rest_framework.views import APIView
from vaga_remanescente.queries.distrito import get_distritos
from vaga_remanescente.queries.dre import get_dre
from vaga_remanescente.queries.sub_prefeitura import get_sub_prefeituras
from vaga_remanescente.queries.vaga_por_escolas import get_vaga_por_escolas
class GetVagaByEscola(APIView):
def get(self, request, cd_serie):
resposta = {}
filtro = request.GET.get('filtro', '')
busca = request.GET.get('busca', '')
if cd_serie not in [1, 4, 27, 28]:
return Response('Série invalida')
# Queries no Banco no DW
resposta['escolas'] = get_vaga_por_escolas(filtro, busca, cd_serie)
resposta['dt_atualizacao'] = get_dt_atualizacao()
return Response(resposta)
class GetVagasFilter(APIView):
def get(self, request):
cache_time = 3600
cached_item = cache.get('filtros_vaga')
if not cached_item:
response = {'dres': get_dre(),
'distritos': get_distritos(),
'sub-prefeituras': get_sub_prefeituras()}
cache.set('filtros_vaga', zlib.compress(pickle.dumps(response)), cache_time)
return Response(response)
print('Com cache')
return Response(pickle.loads(zlib.decompress(cached_item)))
| 1,548 | 558 |
import glob
from flask import Markup
SERVER_OPTIONS = [{'text': 'Local Host', 'value': '127.0.0.1'},
{'text': 'Test weved23962', 'value': '10.201.144.167'},
{'text': 'Stage weves31263', 'value': '10.50.8.130'},
{'text': 'Prod wevep31172', 'value': '10.48.164.198'}
]
def server_options(ip_address: str) -> Markup:
return Markup(SERVER_OPTIONS)
def sql_options(base_dir: str) -> [Markup, str]:
"""Create an option list based on files in the directory.
:param base_dir: where the sql files are located
:return: list of options
"""
pattern = f'{base_dir}/*.sql'
files = glob.glob(pattern, recursive=True)
options = ''
first = True
first_file = ''
for file in files:
file = file.replace('\\', '/')
description = file.replace('.sql', '').replace('_', ' ')
last_count = description.rfind('/') + 1
description = description[last_count:]
# print(description)
if first:
options += f'<option value="{file}" selected="selected">{description}</option>\n'
first_file = file
first = False
else:
options += f'<option value="{file}">{description}</option>\n'
return Markup(options), first_file
def vue_sql_select(base_dir: str) -> [Markup, str]:
"""Create an option list based on files in the directory.
:param base_dir: where the sql files are located
:return: list of options
"""
pattern = f'{base_dir}/*.sql'
files = glob.glob(pattern, recursive=True)
options = []
first = True
first_file = ''
for file in files:
file = file.replace('\\', '/')
description = file.replace('.sql', '').replace('_', ' ')
last_count = description.rfind('/') + 1
description = description[last_count:]
# print(description)
if first:
first_file = file
first = False
# options += f"{{text: '{description}', value: '{file}'}},"
options.append({'text': f'{description}', 'value': f'{file}'})
return Markup(options), first_file
if __name__ == '__main__':
print(vue_sql_select('../sql/pa_related/care_guidance'))
print(sql_options('../sql/pa_related/care_guidance'))
| 2,310 | 739 |
import streamlit as st
from xkcd import xkcd_plot
from shared import translate, LANGUAGE_DICT
# Set page properties for the app
st.set_page_config(
page_title="Streamlit & XKCD",
layout="wide",
initial_sidebar_state="expanded",
)
# Initialize the session states - f_list has functions and colors
if 'f_list' not in st.session_state:
st.session_state['f_list'] = [
("5*exp(-x**2)", "g"),
("sin(5*x)/x", "b"),
]
if 'SLANG' not in st.session_state:
st.session_state['SLANG'] = list(LANGUAGE_DICT.keys())[0]
# The side bar
language_title = st.sidebar.empty() # Hack so the title gets updated before selection is made
st.session_state['SLANG'] = st.sidebar.selectbox("",
list(LANGUAGE_DICT.keys())
)
language_title.subheader(translate("language_title"))
# Delete
SLANG_DICT = LANGUAGE_DICT[st.session_state['SLANG']]
st.sidebar.subheader(translate("parameters_title"))
with st.sidebar.expander(translate("functions_expander")):
f = st.text_input(translate("equation"), "sin(5*x)/x")
c = st.color_picker(translate("function_color"), "#0000FF")
col1, col2 = st.columns(2)
if col1.button(translate("add_function")):
st.session_state['f_list'].append( (f, c) )
if col2.button(translate("clean_functions")):
st.session_state['f_list'] = []
st.write(translate("functions_link"))
with st.sidebar.expander(translate("graph_expander")):
title = st.text_input(translate("title_text"), translate("title_value"))
xlabel = st.text_input(translate("xlabel_text"), "x")
ylabel = st.text_input(translate("ylabel_text"), "y")
xmin = st.number_input(translate("xmin_text"), value=-5)
xmax = st.number_input(translate("xmax_text"), value=+5)
st.sidebar.markdown(translate("links_md"))
# The main view
try:
fig = xkcd_plot(st.session_state['f_list'], title, xlabel, ylabel, xmin, xmax, Nx=1001)
st.pyplot(fig)
except Exception as e:
st.session_state['f_list'] = []
st.error(translate("error_warning"))
st.warning(translate("error_advice"))
st.exception(e) | 2,237 | 745 |
"""
* Copyright (c) 2008, Flagon Slayer Brewery
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the Flagon Slayer Brewery nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY Flagon Slayer Brewery ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL Flagon Slayer Brewery BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""
import pygtk
pygtk.require("2.0")
import gtk, gtk.glade
from recipe import*
from obj_manager import*
from util import*
from wndRecipeIngredients import*
class ProcedureWindow(object):
"""
#########################################################################
# Sub-Class: ProcedureWindow #
# Opens the GUI window to create and store a new #
# Procedures into the new Recipe Object. Creates the button #
# handlers and has the functions to support them. #
#-----------------------------------------------------------------------#
"""
def __init__(self):
self.gladefile = 'gui/recipe.glade'
def run(self, TempNewRecipe, Edit=None):
self.wTree = gtk.glade.XML(self.gladefile, 'wndAddProcedures')
#store the new recipe object passed to here
self.procedures = TempNewRecipe
#store editing
self.Editing = Edit
#dictionary of Handlers for events in procedure GUI window
#including the method function to support that handle
# dic = {"Button Handler Name": sef.CorresondingFunctionTitle}
dic = {
"btnAddProcedures_clicked_cb" : self.AddProcedures,
"btnDelete_clicked_cb" : self.DeleteProcedures,
"wndAddProcedures_destory_cb" : self.exit,
"btnFinish_clicked_cb" : self.exit,
"btnClearForm_clicked_cb" : self.clearFields,
}
self.wTree.signal_autoconnect(dic)
#send dictionary of hanles to GUI
#set window GUI for Recipe and open
self.wind = self.wTree.get_widget('wndAddProcedures')
self.setTrees()
self.PopulateTrees()
self.wind.run()
def setTrees(self, callback=None):
"""
creates a tree list to hold all New Recipe Procedures
"""
self.tre_Procedure = self.wTree.get_widget('tre_Procedure')
self.tre_Procedures_List = setupList(self.tre_Procedure, ['Name', 'Time', 'Description'], (str,str,str))
def PopulateTrees(self, callback=None):
"""
Populate the procedures if any stored
"""
for i in self.procedures.Procedures:
self.tre_Procedures_List.append([i.name, "%s %s" % (i.timing_delta, i.time_unit), i.description])
def AddProcedures(self, callback):
"""
Function that supports the Add Procedure button.
Function stores each single procedure created into
a procedure object that is stored in a list of procedeures
stored in the new Recipe object
"""
#create variable to hold text input fro GUI text boxes
ProcedureName = self.wTree.get_widget('Name_text')
Time = self.wTree.get_widget('Time_txt')
Description = self.wTree.get_widget('Description_txt')
Unit = self.wTree.get_widget('TimeUnit').get_active_text()
#call the Add_procedure function in recipe.py
#creates an object for each single procedure
#then stores them in a procedures list
self.procedures.Add_procedure(ProcedureName.get_text(), Time.get_text(), Description.get_text(), Unit)
self.tre_Procedures_List.insert(0,[ProcedureName.get_text(), "%s %s" % (Time.get_text(),Unit), Description.get_text()])
#test purposes to see if inputs are correct and stored
print 'reach look at fields procedure'
print ProcedureName.get_text(), Description.get_text(), Time.get_text(), Unit
self.clearFields(self)
def DeleteProcedures(self, callback):
"""
Function that supports the delete procedure button.
Deletes the selected procedure in the Recipe procedure tree.
"""
#try:
Model, selected = self.tre_Procedure.get_selection().get_selected()
selection = Model[selected]
#retreive object to delete from the ingredient list
name = selection[0]
description = selection[2]
self.procedures.Delete_Procedure(name, description)
self.tre_Procedures_List.remove(selected)
print 'Reach Delete Procedures'
print "%s" % (selected)
#except:
#print ' no selection try again'
def clearFields(self, callback):
"""
Function that supports the Clear All Procedures Form button.
Clears all text fields in the Procedures Form
"""
print 'Reach Clear All Fields for Procedure'
self.wTree.get_widget('Name_text').set_text('')
self.wTree.get_widget('Description_txt').set_text('')
self.wTree.get_widget('Time_txt').set_text('')
self.wTree.get_widget('TimeUnit').set_active(-1)
def exit(self, callback):
"""
Function to handle quit
"""
self.wind.destroy()
print 'exit procedure'
| 5,798 | 2,025 |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.4 on 2018-12-16 02:43
from __future__ import unicode_literals
from django.db import migrations, models
import oidc_provider.fields
class Migration(migrations.Migration):
dependencies = [
('oidc_provider', '0027_swappable_client_model'),
]
operations = [
migrations.RenameField(
model_name='client',
old_name='response_types',
new_name='old_response_types',
),
migrations.AddField(
model_name='client',
name='response_types',
field=oidc_provider.fields.JsonMultiSelectModelField(choices=[('code', 'code (Authorization Code Flow)'), ('id_token', 'id_token (Implicit Flow)'), ('id_token token', 'id_token token (Implicit Flow)'), ('code token', 'code token (Hybrid Flow)'), ('code id_token', 'code id_token (Hybrid Flow)'), ('code id_token token', 'code id_token token (Hybrid Flow)')], default=set, verbose_name='Response Types'),
),
]
| 1,018 | 322 |
"""
This module masks faces using kpts already detected
"""
import numpy as np
import argparse
import cv2
#from RCN.preprocessing.tools import BGR2Gray
from PIL import Image
import h5py
def get_parsed_keypoints(path):
with open(path) as f:
x = f.read()
y=x.split('\n')
z=[[int(i) for i in k.split()] for k in y if k is not '']
return np.array(z)
def read_kpts(kpts_dir, imgs_ids):
kpts_list = []
for img_id in imgs_ids:
img_path = '%s/%s_crop.txt' % (kpts_dir, img_id)
kpts = get_parsed_keypoints(img_path)
kpts_list.append(kpts)
return np.array(kpts_list)
def mask_out_face(imgs, pred_kpts):
mask_imgs = []
for img, kpts in zip(imgs, pred_kpts):
# mask_img = cv2.fillPoly(img, kpts)
kpts = kpts.astype(np.int32)
# reordering #1 to #17 kpts to form a polygon
kpts_mask = np.concatenate((kpts[:17][::-1], kpts[17:27]), axis=0)
img_mask = img.copy()
#cv2.fillConvexPoly(img_mask, kpts_mask, 0)
cv2.fillPoly(img_mask, kpts_mask.reshape(1,27,2), 0)
mask_imgs.append(img_mask)
return mask_imgs
def plot_cross(img, kpt, color, lnt=1):
kpt = map(int, kpt)
x, y = kpt
cv2.line(img=img, pt1=(x-lnt, y-lnt), pt2=(x+lnt, y+lnt), color=color)
cv2.line(img=img, pt1=(x-lnt, y+lnt), pt2=(x+lnt, y-lnt), color=color)
return img
def draw_kpts(img, kpts, color):
for kpt in kpts:
x_i = int(kpt[0])
y_i = int(kpt[1])
img = plot_cross(img, kpt=(x_i, y_i), color=color)
return img
def convert_np_to_PIL(np_img):
img_rev = np_img[:, :, ::-1].copy()
rescaled = (255.0 / img_rev.max() * (img_rev - img_rev.min())).astype(np.uint8)
im = Image.fromarray(rescaled)
return im
def tile_images(img, img_mask, img_depthNet, row_size, col_size):
rows = 1
cols = 3
gap_sz = 5
gap_cols = (cols - 1) * gap_sz
gap_rows = (rows - 1) * gap_sz
index = 0
new_im = Image.new('RGB', (cols*col_size + gap_cols,
rows*row_size + gap_rows), "white")
for i in xrange(0, rows * row_size + gap_rows, row_size + gap_sz):
for jj in xrange(0, cols * col_size + gap_cols, col_size + gap_sz):
if jj == 0:
new_im.paste(img, (jj, i))
elif jj == col_size + gap_sz:
new_im.paste(img_mask, (jj, i))
else:
new_im.paste(img_depthNet, (jj, i))
return new_im
if __name__ == "__main__":
#parser = argparse.ArgumentParser(description='Getting keypoint prediction\
# using a trained model.')
#parser.add_argument('--img_path', type=str, help='the complete path to the\
# pickle file that contains pre-processed images',
# required=True)
#kpts_path = '/home/honari/libs/test_RCN/RCN/plotting/keypoints'
kpts_path = "./keypoints"
#args = parser.parse_args()
#img_path = args.img_path
imgs_path = 'celebA.h5'
#fp = open(img_path, 'r')
fp = h5py.File(imgs_path, 'a')
#dset = pickle.load(fp)
imgs = fp['src_GT']
#imgs_depthNet = fp['src_depthNet']
imgs_ids = fp['src_id'][:].astype("U6")
print('getting kpts')
#pred_kpts = get_kpts(imgs, path)
pred_kpts = read_kpts(kpts_path, imgs_ids)
print('getting masks')
masked_face = mask_out_face(imgs, pred_kpts)
"""
data_dict = OrderedDict()
data_dict['img_orig'] = imgs
data_dict['img_mask'] = masked_face
pickle.dump('mask_faces.pickle', data_dict)
"""
src_GT_mask_face = np.array(masked_face).astype(np.uint8)
#img_path_out = img_path.split('.pickle')[0] + '_with_mask.pickle'
#with open(img_path_out, 'wb') as fp:
# pickle.dump(dset, fp)
fp.create_dataset('src_GT_mask_face', data=src_GT_mask_face)
src_depthNet = fp['src_depthNet']
fp.create_dataset('src_depthNet_and_mask',
data=np.concatenate((src_depthNet, src_GT_mask_face), axis=-1))
'''
print('plotting samples')
n_sample = 50
for img, img_mask, img_depthNet, img_id in \
zip(imgs, masked_face, imgs_depthNet, np.arange(n_sample)):
row_size, col_size, _ = img.shape
img_PIL = convert_np_to_PIL(img)
img_mask_PIL = convert_np_to_PIL(img_mask)
img_depthNet_PIL = convert_np_to_PIL(img_depthNet)
img_new = tile_images(img_PIL, img_mask_PIL, img_depthNet_PIL,
row_size, col_size)
img_new.save('./sample_mask_imgs/img_%s.png' % (img_id))
'''
fp.close()
print('done!')
| 4,693 | 1,862 |
import cv2 as cv
import numpy as np
img = cv.imread('test.png')
# 将图片大小改为1920*1080h,s,v = cv.split(hsvimg)
img = cv.resize(img, dsize=(1920, 1080), fx=1, fy=1, interpolation=cv.INTER_NEAREST)
# hsv图像
hsvimg = cv.cvtColor(img, cv.COLOR_BGR2HSV)
lower_y = np.array([20, 43, 46])
upper_y = np.array([34, 255, 220])
mask = cv.inRange(hsvimg, lower_y, upper_y)
# 霍夫直线检测
lines = cv.HoughLinesP(mask, 1, np.pi / 180, 127, minLineLength=500, maxLineGap=1)
for line in lines:
x1, y1, x2, y2 = line[0]
cv.line(img, (x1, y1), (x2, y2), (0, 255, 0), 1)
cv.imshow('img', img)
cv.waitKey(0)
| 589 | 332 |
# -*- coding: utf-8 -*-
# Generated by Django 1.11 on 2017-04-26 00:00
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
('parking', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='SpotReservation',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('spot_reservation_date', models.DateField()),
('spot_reservation_start_time', models.TimeField()),
('spot_reservation_end_time', models.TimeField()),
('spot_location', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='reservation_spot', to='parking.SpotLocation')),
],
),
]
| 926 | 286 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@Time : 2021/2/26 12:07 下午
@Author : hcai
@Email : hua.cai@unidt.com
"""
import textembedding.get_embedding
import textembedding.load_model
name = "textbedding"
# 加载wv model
def load_word2vect(filepath):
model = textembedding.load_model.load_word2vect(filepath)
return model
# 获取字向量
def get_word_embedding(model,word,min=1,max=3):
word_vector = textembedding.get_embedding.get_word_embedding(model, word, min, max)
return word_vector
# 获取句子向量
def get_sentence_embedding(model, sentence, add_pos_weight=['n','nr','ng','ns','nt','nz'],stop_words_path=None):
sentence_vector = textembedding.get_embedding.get_sentence_embedding(model, sentence, add_pos_weight, stop_words_path)
return sentence_vector
# 获取句子相似度
def get_vector_similarity(query_vec,vec_list,metric_type='cos'):
vector_similarity = textembedding.get_embedding.get_similarity(query_vec,vec_list,metric_type)
return vector_similarity | 988 | 398 |
# Import matplotlib.pyplot
import matplotlib.pyplot as plt
# Set start and end dates
start = date(2016, 1, 1)
end = date(2016, 12, 31)
# Set the ticker and data_source
ticker = 'FB'
data_source = 'google'
# Import the data using DataReader
stock_prices = DataReader(ticker, data_source, start, end)
# Plot Close
stock_prices['Close'].plot(title=ticker)
# Show the plot
plt.show()
| 385 | 145 |
# !/usr/bin/env python
# coding=utf8
import json
import traceback
from tornado.web import RequestHandler
from pfrock.cli import logger
from pfrock.core.constants import PFROCK_CONFIG_SERVER, PFROCK_CONFIG_ROUTER, PFROCK_CONFIG_PORT, ROUTER_METHOD, \
ROUTER_PATH, ROUTER_OPTIONS, ROUTER_HANDLER
from pfrock.core.lib import auto_str
@auto_str
class PfrockConfigRouter(object):
SUPPORTED_METHODS = RequestHandler.SUPPORTED_METHODS
def __init__(self, path, methods, handler, options={}):
self.path = path
self.handler = handler
self.options = options
self.methods = []
if methods == "any":
self.methods = []
else:
for method in methods:
method = method.upper()
if method in self.SUPPORTED_METHODS:
self.methods.append(method)
@auto_str
class PfrockConfigServer(object):
def __init__(self, routes, port):
self.routes = routes
self.port = port
class PfrockConfigParser(object):
@classmethod
def _parse_router(cls, router):
path = router[ROUTER_PATH] if ROUTER_PATH in router else None
methods = router[ROUTER_METHOD] if ROUTER_METHOD in router else []
handler = router[ROUTER_HANDLER] if ROUTER_HANDLER in router else None
options = router[ROUTER_OPTIONS] if ROUTER_OPTIONS in router else None
if path and handler:
return PfrockConfigRouter(path, methods, handler, options)
return None
@classmethod
def _parse_routers(cls, routers):
router_list = []
for router in routers:
router = cls._parse_router(router)
if router:
router_list.append(router)
return router_list
@classmethod
def _parse_servers(cls, server):
port = server[PFROCK_CONFIG_PORT] if PFROCK_CONFIG_PORT in server else None
routers = cls._parse_routers(server[PFROCK_CONFIG_ROUTER]) if PFROCK_CONFIG_ROUTER in server else None
if port and routers:
return PfrockConfigServer(routers, port)
@classmethod
def do(cls, config_file_path):
with open(config_file_path, 'r') as fin:
try:
config_data = json.load(fin)
except:
logger.error("%s not well formed \n%s" % (config_file_path, traceback.format_exc()))
return None
config_servers = config_data[PFROCK_CONFIG_SERVER] if PFROCK_CONFIG_SERVER in config_data else None
if config_servers:
for config_server in config_servers:
config_server = cls._parse_servers(config_server)
# todo: dev version just support one server
return config_server
return None
| 2,808 | 841 |
from typing import List, Union
import torch
from torch import nn
from torch.nn import functional as F
from src.modules.max_mahalanobis import MaxMahalanobis, GaussianResult
from src.modules.normalize import Normalize
from src.resnet.bottleneck_block_v2s3 import create_bottleneck_stage_v2s3
from src.resnet.shared import GaussianMode, ResNet_Gaussian
class ResNetV2_3Stage_Gaussian(ResNet_Gaussian):
"""
Implements Max-Mahalanobis center loss for classification on 32x32 RGB images (e.g. CIFAR-10).
Reference papers:
- Identity Mappings in Deep Residual Networks (https://arxiv.org/abs/1603.05027)
- Rethinking Softmax Cross-Entropy Loss For Adversarial Robustness (https://arxiv.org/pdf/1905.10626.pdf)
Reference implementations:
- Official code (https://github.com/P2333/Max-Mahalanobis-Training/blob/master/train.py)
"""
normalize: Normalize
conv1: nn.Conv2d
stage2: nn.Sequential
stage3: nn.Sequential
stage4: nn.Sequential
bn_post: nn.BatchNorm2d
avgpool: nn.AdaptiveAvgPool2d
fc: nn.Linear
max_mahalanobis: MaxMahalanobis
out_channels: int
def __init__(self, stage_sizes: List[int], radius: float, n_classes: int):
super().__init__()
if len(stage_sizes) != 3:
raise ValueError("Stage_sizes must have length 3!")
if radius <= 0:
raise ValueError("Radius must be positive!")
if n_classes <= 1:
raise ValueError("N_classes must be greater than 1!")
self.init_layers(stage_sizes, radius, n_classes)
self.reset_parameters()
self.out_channels = n_classes
def init_layers(self, stage_sizes: List[int], radius: float, n_classes: int) -> None:
self.normalize = Normalize(3)
self.conv1 = nn.Conv2d(3, 16, 3, padding=1, bias=False)
self.stage2 = create_bottleneck_stage_v2s3(stage_sizes[0], 16, 16, 64, 1)
self.stage3 = create_bottleneck_stage_v2s3(stage_sizes[1], 64, 32, 128, 2)
self.stage4 = create_bottleneck_stage_v2s3(stage_sizes[2], 128, 64, 256, 2)
self.bn_post = nn.BatchNorm2d(256)
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(256, 256)
self.max_mahalanobis = MaxMahalanobis(radius, 256, n_classes)
def reset_parameters(self) -> None:
for module in self.modules():
if isinstance(module, (nn.Conv2d, nn.Linear)):
nn.init.kaiming_normal_(module.weight, nonlinearity="relu")
def forward(self, x: torch.Tensor, mode: GaussianMode) -> Union[torch.Tensor, GaussianResult]:
if x.shape[1:] != (3, 32, 32):
raise ValueError("Input tensor must have shape [N, C=3, H=32, W=32]!")
x = self.normalize(x)
x = self.conv1(x)
x = self.stage2(x)
x = self.stage3(x)
x = self.stage4(x)
x = self.bn_post(x)
x = F.relu(x, inplace=True)
x = self.avgpool(x)
x = torch.flatten(x, 1)
x = self.fc(x)
x = self.max_mahalanobis(x, mode)
return x
class ResNet29V2_Gaussian(ResNetV2_3Stage_Gaussian):
def __init__(self, radius: float, n_classes: int):
super().__init__([3, 3, 3], radius, n_classes)
class ResNet47V2_Gaussian(ResNetV2_3Stage_Gaussian):
def __init__(self, radius: float, n_classes: int):
super().__init__([5, 5, 5], radius, n_classes)
class ResNet65V2_Gaussian(ResNetV2_3Stage_Gaussian):
def __init__(self, radius: float, n_classes: int):
super().__init__([7, 7, 7], radius, n_classes)
class ResNet83V2_Gaussian(ResNetV2_3Stage_Gaussian):
def __init__(self, radius: float, n_classes: int):
super().__init__([9, 9, 9], radius, n_classes)
| 3,722 | 1,451 |
systemMenu = {"ไก่ทอด": 35, "เป็ดทอด": 45, "ปลาทอด": 55, "ผักทอด": 20}
menuList = []
def showBill():
print("---- My Food----")
totalPrice = 0
for number in range(len(menuList)):
print(menuList[number][0],menuList[number][1])
totalPrice += int(menuList[number][1])
print("Totalprice :", totalPrice)
while True:
menuName = input("Please Enter Menu :")
if(menuName.lower() == "exit"):
break
else:
menuList.append([menuName, systemMenu[menuName]])
showBill() | 504 | 197 |
# -*- coding: utf-8 -*-
import requests
import os
# 6000 is a large number to make sure we get all the components of a collection. Please do note that RISE also has a pagination feature,
# which can be implemented by clients if they wish.
per_page = 6000
# getting the list of collections that the user has access to:
collections_response = requests.get(f'https://rise.mpiwg-berlin.mpg.de/api/collections?per_page={per_page}')
collections = collections_response.json()
# each accessible collections has a name, a uuid, and a number of resources.
# print(collections)
idx = 1
for collection in collections:
print(f'collection at index: {idx}')
idx += 1
print(collection)
# picking a collection by its index
# collection_index = 1
# collection = collections[collection_index]
results = list(filter(lambda collection: collection['name'] == 'MPIWG - 哈佛燕京圖書館藏珍稀方志', collections))
collection = results[0]
print(collection['uuid'])
collection_uuid = collection['uuid']
# we grab all resources for this collection
resources_response = requests.get(f'https://rise.mpiwg-berlin.mpg.de/api/collections/{collection_uuid}/resources?per_page={per_page}')
corpus_path = './corpus'
if not os.path.exists(corpus_path):
os.makedirs(corpus_path)
for resource in resources_response.json():
uuid = resource['uuid']
resource_name = resource['name']
print(resource_name)
if not os.path.exists(corpus_path + "/" + resource_name):
os.makedirs(corpus_path + "/" + resource_name)
sections = requests.get("https://rise.mpiwg-berlin.mpg.de/api/resources/"+ resource['uuid'] +"/sections")
for section in sections.json():
print(section)
print(section['uuid'])
section_name = section['name']
section_path = corpus_path + "/" + resource_name + "/" + section_name
file = open(section_path +".txt", "w")
content_units = requests.get("https://rise.mpiwg-berlin.mpg.de/api/sections/"+ section['uuid'] +"/content_units?per_page=6000")
for content_unit in content_units.json():
print(content_unit)
file.write(content_unit['content'])
file.close() | 2,229 | 694 |
# ___ ___ ___ _ _
# |_ _| _ \___| __(_)_ _ __| |___ _ _
# | || _/___| _|| | ' \/ _` / -_) '_|
# |___|_| |_| |_|_||_\__,_\___|_|
# Made by Robertas64
#Importing the module
import os
from time import *
banner = """
___ ___ ___ _ _
|_ _| _ \___| __(_)_ _ __| |___ _ _
| || _/___| _|| | ' \/ _` / -_) '_|
|___|_| |_| |_|_||_\__,_\___|_|
Find GrowtopiaServer Real IP
Author : Robertas64
Make sure you're connected
To GrowtopiaServer hosts
"""
#Main
print(banner)
os.system("ping growtopia1.com") | 612 | 261 |
import pandas as pd
import matplotlib.pyplot as plt
def retrieve_data():
train_data = 'data/Nov_btc.csv'
test_data = 'data/btc_test_data.csv'
df = pd.read_csv(test_data)
df = df.drop(columns=['date', 'weighted','volume'])
# Columns are set at close, high, low and open.
df = df.dropna()
data = df.values
return data
| 348 | 126 |
import argparse
import os
import torch
import torch.nn as nn
import torch.optim as optim
import argparse
from torch.utils.data import DataLoader
from torchvision import transforms
from dataset.main import Flickr8kDataset
from dataset.caps_collate import CapsCollate
from dataset.download import DownloadDataset
from model.main import ImageCaptioningModel,ViTImageCaptioningModel
from train import train, split_subsets
from transformers import ViTFeatureExtractor
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
use_ViT_Enc = True
def main(args):
if use_ViT_Enc:
print("It is using ViT encoder!!!!")
transform = None
feature_extractor = ViTFeatureExtractor.from_pretrained('google/vit-base-patch16-224-in21k')
else:
feature_extractor = None
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Resize((args['image_size'], args['image_size'])),
# The normalize parameters depends on the model we're gonna use
# If we apply transfer learning from a model that used ImageNet, then
# we should use the ImageNet values to normalize the dataset.
# Otherwise we could just normalize the values between -1 and 1 using the
# standard mean and standard deviation
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
dataset = Flickr8kDataset(dataset_folder='data', transform=transform,
reduce=True, vocab_max_size=args['vocabulary_size'],feature_extractor=feature_extractor)
# Create the model
if use_ViT_Enc:
model = ViTImageCaptioningModel(
embed_size=args['embedding_dimension'],
vocab = dataset.vocab,
caption_max_length=args['captions_max_length'],
).to(device)
else:
model = ImageCaptioningModel(
image_features_dim=args['image_features_dimension'],
embed_size=args['embedding_dimension'],
vocab = dataset.vocab,
caption_max_length=args['captions_max_length'],
).to(device)
# Perform the split of the dataset
train_split, test_split = split_subsets(dataset,all_captions=True)
train_loader = DataLoader(train_split, shuffle=True, batch_size=args['batch_size'], collate_fn=CapsCollate(
pad_idx=dataset.vocab.word_to_index['<PAD>'], batch_first=True))
test_loader = DataLoader(test_split, shuffle=True, batch_size=args['batch_size'], collate_fn=CapsCollate(
pad_idx=dataset.vocab.word_to_index['<PAD>'], batch_first=True))
optimizer = optim.Adam(model.parameters(), lr=args['learning_rate'], betas=(0.9, 0.98), eps=1e-9)
criterion = nn.CrossEntropyLoss(ignore_index=dataset.vocab.word_to_index['<PAD>'])
train(
num_epochs=args['epochs'],
model=model,
train_loader=train_loader,
test_loader=test_loader,
optimizer=optimizer,
criterion=criterion,
device=device,
log_interval=args['log_interval']
)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Image captioning model setup')
parser.add_argument('-bsz','--batch-size',type=int, required=False, choices=[4,8,16,32,64], default=64, help='Number of images to process on each batch')
parser.add_argument('-vocab','--vocabulary-size',type=int, required=False, default=5000, help='Number of words that our model will use to generate the captions of the images')
parser.add_argument('-image-feature','--image-features-dimension',type=int, choices=[256,512,1024], required=False, default=512, help='Number of features that the model will take for each image')
parser.add_argument('-attn-dim','--attention-dimension',type=int, choices=[256,512,1024], required=False, default=256, help='Dimension of the attention tensor')
parser.add_argument('-embed-dim','--embedding-dimension',type=int, choices=[256,512,1024], required=False, default=256, help='Dimension of the word embedding tensor')
parser.add_argument('-epochs','--epochs',type=int, required=False, default=100, help='Number of epochs that our model will run')
parser.add_argument('-captions-length','--captions-max-length',type=int, required=False, default=28, help='Max size of the predicted captions')
parser.add_argument('-lr','--learning-rate',type=float, required=False, choices=[1e-1,1e-2,1e-3,1e-4],default=1e-3, help='Max size of the predicted captions')
parser.add_argument('-img-size','--image-size',type=int, required=False, choices=[224,256,320], default=224, help='Size of the input image that our model will process')
parser.add_argument('-log','--log-interval',type=int, required=False, default=5, help='During training, every X epochs, we log the results')
args = parser.parse_args()
variables = vars(args)
if not os.path.exists('data'):
print('Downloading Flickr8k dataset...')
filepath = os.path.join(os.getcwd(),'data')
DownloadDataset.download(filepath)
main(variables)
| 4,715 | 1,708 |
import unittest
from unittest import TestCase
from Implementations.FastIntegersFromGit import FastIntegersFromGit
from Implementations.helpers.Helper import ListToPolynomial, toNumbers
from Implementations.FasterSubsetSum.RandomizedBase import NearLinearBase
from benchmarks.test_distributions import Distributions as dist
class RandomizedBaseTester(TestCase):
@classmethod
def setUp(cls):
cls.fasterSubset = NearLinearBase(False, 1)
def test_faster_sumset_base_returns_correct_sumset(self):
vals = [1, 15, 3, 8, 120, 290, 530, 420, 152, 320, 150, 190]
T = 11
sums = self.fasterSubset.fasterSubsetSum(vals, T, 0.2)
self.assertListEqual(sums, [0, 1, 3, 4, 8, 9, 11])
def test_color_coding_base_returns_correct_sumset(self):
vals = [1, 15, 3, 8, 120, 290, 530, 420, 152, 320, 150, 190]
T = 11
characteristic = ListToPolynomial(vals)
sums = self.fasterSubset.color_coding(characteristic, T, len(vals), 0.2)
self.assertListEqual(toNumbers(sums), [0, 1, 3, 4, 8, 9, 11])
@unittest.skip("Not currently working.")
def test_faster_sumset_returns_correct_sumset_multiples(self):
vals = [1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
T = 11
sums = self.fasterSubset.fasterSubsetSum(vals, T, 0.2)
self.assertListEqual(sums, [0, 1, 3, 4])
@unittest.skip("Not currently working. I.e some of the speed ups we done means this does not work properly")
def test_faster_simple(self):
vals = [8, 10]
T = 18
a = list(set(vals))
delta = 0.0001
fast = self.fasterSubset.fasterSubsetSum(a, T, delta)
self.assertListEqual(fast, [0, 8, 10, 18])
@unittest.skip("comment in for benchmark.")
def test_me(self):
delta = 0.0001
i = 500
a, T = dist.evenDistribution(i)
fast = self.fasterSubset.fasterSubsetSum(a, T, delta)
# expertSolution = FastIntegersFromGit().run(a, T)
# self.assertListEqual(fast, expertSolution)
| 2,050 | 837 |
# Тип данных МНОЖЕСТВО (set)------------------------
#------------------------------------------
# Инициализация
temp_set = {1,2,3}
print(type(temp_set), temp_set)
temp_list = [1,2,1,2,2,3,4,12,32]
temp_set = set(temp_list)
print(type(temp_set), temp_set)
# Обращения к элементам множества
print(100 in temp_set)
for element in temp_set:
print(element)
# Функции с множествами
#----------
# Операции с множествами
# Методы
my_set_1 = set([1, 2, 3, 4, 5])
my_set_2 = set([5, 6, 7, 8, 9])
my_set_3 = my_set_1.union(my_set_2)
print(my_set_3)
my_set_4 = my_set_1.difference(my_set_2)
print(my_set_4) | 633 | 294 |
from fabric.api import cd, run, settings, sudo
configurations = {
'daily': {
'branch': 'master',
'ssl': False,
},
'dev': {
'branch': 'master',
'ssl': False,
},
'prod': {
'branch': 'prod',
'ssl': False,
},
'staging': {
'branch': 'prod',
'ssl': False,
},
}
def deploy(config):
configuration = configurations[config]
branch = configuration['branch']
use_ssl = configuration['ssl']
PYTHON_DIR = '/var/www/python'
repo_dir = '{0}/guidcoin-{1}'.format(PYTHON_DIR, config)
web_dir = '{0}/web'.format(repo_dir)
config_dir = '{0}/config/ubuntu-14.04'.format(repo_dir)
uwsgi_dir = '{0}/uwsgi'.format(config_dir)
nginx_dir = '{0}/nginx'.format(config_dir)
virtualenv_python = '{0}/venv/bin/python'.format(repo_dir)
_update_source(repo_dir, branch)
_compile_source(config, repo_dir, web_dir, virtualenv_python)
_reload_code(config, uwsgi_dir)
_reload_web(config, nginx_dir, use_ssl)
_run_tests(config, web_dir, virtualenv_python)
def _update_source(repo_dir, branch):
with cd(repo_dir):
sudo('chgrp -R webadmin .')
sudo('chmod -R ug+w .')
run('git fetch origin')
# Attempt to checkout the target branch. This might fail if we've
# never deployed from this branch before in this deployment. In that case,
# just create the branch then try again.
with settings(warn_only=True):
result = sudo('git checkout {0}'.format(branch))
if result.failed:
sudo('git branch {0}'.format(branch))
sudo('git checkout {0}'.format(branch))
sudo('git reset --hard origin/{0}'.format(branch))
def _compile_source(config, repo_dir, web_dir, virtualenv_python):
with cd(repo_dir):
sudo('venv/bin/pip install --requirement=requirements.txt')
with cd(web_dir):
sudo('find . -iname "*.pyc" -exec rm {} \;')
sudo('{0} -m compileall .'.format(virtualenv_python))
sudo('{0} manage_{1}.py collectstatic --noinput'.format(virtualenv_python, config))
def _reload_code(config, uwsgi_dir):
with cd(uwsgi_dir):
sudo('cp guidcoin-{0}.ini /etc/uwsgi/apps-enabled'.format(config))
sudo('chmod 755 /etc/uwsgi/apps-enabled/guidcoin-{0}.ini'.format(config))
sudo('/etc/init.d/uwsgi start guidcoin-{0}'.format(config))
sudo('/etc/init.d/uwsgi reload guidcoin-{0}'.format(config))
def _reload_web(config, nginx_dir, ssl):
with cd(nginx_dir):
sudo('cp {0}-guidcoin-com /etc/nginx/sites-enabled/'.format(config))
if ssl:
sudo('cp ssl/{0}.guidcoin.com.* /etc/nginx/ssl'.format(config))
sudo('chown root /etc/nginx/ssl/{0}.guidcoin.com.*'.format(config))
sudo('chgrp root /etc/nginx/ssl/{0}.guidcoin.com.*'.format(config))
sudo('chmod 644 /etc/nginx/ssl/{0}.guidcoin.com.*'.format(config))
sudo('/etc/init.d/nginx reload')
def _run_tests(config, web_dir, virtualenv_python):
with cd(web_dir):
run('{0} manage_{1}.py test'.format(virtualenv_python, config))
def deploy_global_config(config):
global_dir = '/var/www/python/guidcoin-{0}/config/ubuntu-14.04/global'.format(config)
SHARED_MEM = '/etc/sysctl.d/30-postgresql-shm.conf'
NGINX_CONF = '/etc/nginx/nginx.conf'
POSTGRES_HBA = '/etc/postgresql/9.3/main/pg_hba.conf'
POSTGRES_CONF = '/etc/postgresql/9.3/main/postgresql.conf'
with cd(global_dir):
sudo('cp 30-postgresql-shm.conf {0}'.format(SHARED_MEM))
_update_permissions(SHARED_MEM, 'root', 'root', '644')
sudo('cp nginx.conf {0}'.format(NGINX_CONF))
_update_permissions(NGINX_CONF, 'root', 'root', '644')
sudo('cp pg_hba.conf {0}'.format(POSTGRES_HBA))
_update_permissions(POSTGRES_HBA, 'postgres', 'postgres', '640')
sudo('cp postgresql.conf {0}'.format(POSTGRES_CONF))
_update_permissions(POSTGRES_HBA, 'postgres', 'postgres', '644')
sudo('/etc/init.d/nginx restart')
sudo('/etc/init.d/postgresql restart')
def _update_permissions(path, owner, group, mode):
sudo('chown {0}:{1} {2}'.format(owner, group, path))
sudo('chmod {0} {1}'.format(mode, path))
def shutdown(config):
configuration = configurations[config]
branch = configuration['branch']
PYTHON_DIR = '/var/www/python'
repo_dir = '{0}/guidcoin-{1}'.format(PYTHON_DIR, config)
nginx_dir = '{0}/config/ubuntu-14.04/nginx/shutdown'.format(repo_dir)
_update_source(repo_dir, branch)
_reload_web(config, nginx_dir)
| 4,744 | 1,761 |
"""
파이썬으로 Tree Sort를 구현한 코드입니다.
정확히 말하자면 Binary Search Tree를 구현하였습니다.
Binary Search Tree는
각 노드에 값이 있다.
Root 노드가 존재한다.
노드의 왼쪽 서브트리에는 그 노드의 값보다 작은 값들을 지닌 노드들로 이루어져있다.
노드의 오른쪽 서브트리에는 그 노드의 값과 같거나 큰 값들을 지닌 노드들로 이루어져있다.
좌우 하위 트리는 각각이 다시 Binary Search Tree 이어야 합니다.
"""
from __future__ import print_function
class node(): #Binary Search Tree를 구현한 class
def __init__(self, val): #시작할때 처음 값을 node에 넣어줍니다.
self.val = val
self.left = None
self.right = None
def insert(self,val): #insert 해주는 코드로서
if self.val:
if val < self.val: #root의 값보다 작을 경우 왼쪽 서브트리로
if self.left is None:
self.left = node(val)
else:
self.left.insert(val)
elif val > self.val: #root의 값보다 클 경우 오른쪽 서브트리로 넣어줍니다.
if self.right is None:
self.right = node(val)
else:
self.right.insert(val)
else:
self.val = val
"""
Binary Search Tree를 오름차순으로 출력하기위해선
inorder 순으로 배열에 저장하여 출력을 해야하기 위해 inorder 함수를 추가하였습니다.
"""
def inorder(root, res):
if root:
inorder(root.left,res)
res.append(root.val)
inorder(root.right,res)
def treesort(arr):
# Binary Search Tree를 만드는 코드입니다.
if len(arr) == 0:
return arr
root = node(arr[0])
for i in range(1,len(arr)):
root.insert(arr[i])
# 오름차순 출력을 위해 inorder 함수를 사용하였습니다.
res = []
inorder(root,res)
return res
if __name__ == '__main__':
try:
raw_input # Python 2
except NameError:
raw_input = input # Python 3
for i in range(3):
user_input = raw_input('Enter numbers separated by a comma:\n').strip()
unsorted = [int(item) for item in user_input.split(',')]
print(treesort(unsorted))
| 1,863 | 1,002 |
# coding: utf-8
from __future__ import unicode_literals, absolute_import
_NOTSET = type(
b"NotSet",
(object,),
{"__repr__": lambda self: "<ValueNotSet>"}
)()
def get_by_path(keys, source_dict):
if "." in keys:
key, tail_keys = keys.split(".", 1)
if key not in source_dict:
return _NOTSET
return get_by_path(tail_keys, source_dict[key])
else:
return source_dict.get(keys, _NOTSET) | 446 | 157 |
from typing import List
import json
import e2e.Libs.Ristretto.Ristretto as Ristretto
from e2e.Libs.BLS import PrivateKey
from e2e.Classes.Transactions.Transactions import Claim, Send, Transactions
from e2e.Classes.Consensus.Verification import SignedVerification
from e2e.Classes.Consensus.VerificationPacket import VerificationPacket
from e2e.Classes.Consensus.SpamFilter import SpamFilter
from e2e.Classes.Merit.Merit import Block, Merit
from e2e.Vectors.Generation.PrototypeChain import PrototypeBlock, PrototypeChain
edPrivKey: Ristretto.SigningKey = Ristretto.SigningKey(b'\0' * 32)
edPubKey: bytes = edPrivKey.get_verifying_key()
transactions: Transactions = Transactions()
sendFilter: SpamFilter = SpamFilter(3)
proto: PrototypeChain = PrototypeChain(40, keepUnlocked=True)
proto.add(1)
merit: Merit = Merit.fromJSON(proto.toJSON())
#Create a Claim.
claim: Claim = Claim([(merit.mints[-1], 0)], edPubKey)
claim.sign(PrivateKey(0))
transactions.add(claim)
merit.add(
PrototypeBlock(
merit.blockchain.blocks[-1].header.time + 1200,
packets=[VerificationPacket(claim.hash, list(range(2)))]
).finish(0, merit)
)
sends: List[Send] = [
#Transaction which will win.
Send([(claim.hash, 0)], [(bytes(32), claim.amount)]),
#Transaction which will be beaten.
Send([(claim.hash, 0)], [(edPubKey, claim.amount // 2), (edPubKey, claim.amount // 2)])
]
#Children. One which will have a Verification, one which won't.
sends += [
Send([(sends[1].hash, 0)], [(edPubKey, claim.amount // 2)]),
Send([(sends[1].hash, 1)], [(edPubKey, claim.amount // 2)])
]
#Send which spend the remaining descendant of the beaten Transaction.
sends.append(Send([(sends[2].hash, 0)], [(bytes(32), claim.amount // 2)]))
for s in range(len(sends)):
sends[s].sign(edPrivKey)
sends[s].beat(sendFilter)
if s < 3:
transactions.add(sends[s])
verif: SignedVerification = SignedVerification(sends[2].hash, 1)
verif.sign(1, PrivateKey(1))
merit.add(
PrototypeBlock(
merit.blockchain.blocks[-1].header.time + 1200,
packets=[
VerificationPacket(sends[0].hash, [0]),
VerificationPacket(sends[1].hash, [1])
]
).finish(0, merit)
)
merit.add(
PrototypeBlock(
merit.blockchain.blocks[-1].header.time + 1200,
packets=[VerificationPacket(sends[2].hash, [0])]
).finish(0, merit)
)
for _ in range(4):
merit.add(
PrototypeBlock(merit.blockchain.blocks[-1].header.time + 1200).finish(0, merit)
)
blockWBeatenVerif: Block = PrototypeBlock(
merit.blockchain.blocks[-1].header.time + 1200,
packets=[VerificationPacket(sends[2].hash, [1])]
).finish(0, merit)
merit.add(
PrototypeBlock(merit.blockchain.blocks[-1].header.time + 1200).finish(0, merit)
)
with open("e2e/Vectors/Consensus/Beaten.json", "w") as vectors:
vectors.write(json.dumps({
"blockchain": merit.toJSON(),
"transactions": transactions.toJSON(),
"sends": [send.toJSON() for send in sends],
"verification": verif.toSignedJSON(),
"blockWithBeatenVerification": blockWBeatenVerif.toJSON()
}))
| 3,030 | 1,176 |
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# This is an EXUDYN example
#
# Details: Simulate Chain with 3D rigid bodies and SphericalJoint;
# Also test MarkerNodePosition
#
# Author: Johannes Gerstmayr
# Date: 2020-04-09
#
# Copyright:This file is part of Exudyn. Exudyn is free software. You can redistribute it and/or modify it under the terms of the Exudyn license. See 'LICENSE.txt' for more details.
#
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
import sys
sys.path.append('../TestModels') #for modelUnitTest as this example may be used also as a unit test
import exudyn as exu
from exudyn.itemInterface import *
from exudyn.utilities import *
from exudyn.graphicsDataUtilities import *
from modelUnitTests import ExudynTestStructure, exudynTestGlobals
SC = exu.SystemContainer()
mbs = SC.AddSystem()
nBodies = 4
color = [0.1,0.1,0.8,1]
s = 0.1 #width of cube
sx = 3*s #lengt of cube/body
cPosZ = 0.1 #offset of constraint in z-direction
zz = sx * (nBodies+1)*2 #max size of background
background0 = GraphicsDataRectangle(-zz,-zz,zz,sx,color)
oGround=mbs.AddObject(ObjectGround(referencePosition= [0,0,0],
visualization=VObjectGround(graphicsData= [background0])))
mPosLast = mbs.AddMarker(MarkerBodyPosition(bodyNumber = oGround,
localPosition=[-sx,0,cPosZ*0]))
#create a chain of bodies:
for i in range(nBodies):
f = 0 #factor for initial velocities
omega0 = [0,50.*f,20*f] #arbitrary initial angular velocity
ep0 = eulerParameters0 #no rotation
ep_t0 = AngularVelocity2EulerParameters_t(omega0, ep0)
p0 = [-sx+i*2*sx,0.,0] #reference position
v0 = [0.2*f,0.,0.] #initial translational velocity
nRB = mbs.AddNode(NodeRigidBodyEP(referenceCoordinates=p0+ep0,
initialVelocities=v0+list(ep_t0)))
#nRB = mbs.AddNode(NodeRigidBodyEP(referenceCoordinates=[0,0,0,1,0,0,0], initialVelocities=[0,0,0,0,0,0,0]))
oGraphics = GraphicsDataOrthoCubeLines(-sx,-s,-s, sx,s,s, [0.8,0.1,0.1,1])
oRB = mbs.AddObject(ObjectRigidBody(physicsMass=2,
physicsInertia=[6,1,6,0,0,0],
nodeNumber=nRB,
visualization=VObjectRigidBody(graphicsData=[oGraphics])))
mMassRB = mbs.AddMarker(MarkerBodyMass(bodyNumber = oRB))
mbs.AddLoad(Gravity(markerNumber = mMassRB, loadVector=[0.,-9.81,0.])) #gravity in negative z-direction
if i==0:
#mPos = mbs.AddMarker(MarkerBodyPosition(bodyNumber = oRB, localPosition = [-sx*0,0.,cPosZ*0]))
mPos = mbs.AddMarker(MarkerNodePosition(nodeNumber=nRB))
else:
mPos = mbs.AddMarker(MarkerBodyPosition(bodyNumber = oRB, localPosition = [-sx,0.,cPosZ]))
#alternative with spring-damper:
#mbs.AddObject(ObjectConnectorCartesianSpringDamper(markerNumbers = [mPosLast, mPos],
# stiffness=[k,k,k], damping=[d,d,d])) #gravity in negative z-direction
axes = [1,1,1]
if (i==0):
axes = [0,1,1]
mbs.AddObject(SphericalJoint(markerNumbers = [mPosLast, mPos], constrainedAxes=axes))
#marker for next chain body
mPosLast = mbs.AddMarker(MarkerBodyPosition(bodyNumber = oRB, localPosition = [sx,0.,cPosZ]))
mbs.Assemble()
#exu.Print(mbs)
simulationSettings = exu.SimulationSettings() #takes currently set values or default values
fact = 1000
simulationSettings.timeIntegration.numberOfSteps = 1*fact
simulationSettings.timeIntegration.endTime = 0.001*fact
simulationSettings.solutionSettings.solutionWritePeriod = simulationSettings.timeIntegration.endTime/fact*10
simulationSettings.timeIntegration.verboseMode = 1
simulationSettings.timeIntegration.newton.useModifiedNewton = True
simulationSettings.timeIntegration.generalizedAlpha.useIndex2Constraints = False
simulationSettings.timeIntegration.generalizedAlpha.useNewmark = False
simulationSettings.timeIntegration.generalizedAlpha.spectralRadius = 0.6 #0.6 works well
simulationSettings.solutionSettings.solutionInformation = "rigid body tests"
SC.visualizationSettings.nodes.defaultSize = 0.05
#simulationSettings.displayComputationTime = True
#simulationSettings.displayStatistics = True
if exudynTestGlobals.useGraphics:
exu.StartRenderer()
mbs.WaitForUserToContinue()
SC.TimeIntegrationSolve(mbs, 'GeneralizedAlpha', simulationSettings)
#+++++++++++++++++++++++++++++++++++++++++++++
sol = mbs.systemData.GetODE2Coordinates();
solref = mbs.systemData.GetODE2Coordinates(configuration=exu.ConfigurationType.Reference);
#exu.Print('sol=',sol)
u = 0
for i in range(14): #take coordinates of first two bodies
u += abs(sol[i]+solref[i])
exu.Print('solution of sphericalJointTest=',u)
exudynTestGlobals.testError = u - (4.409004179180698) #2020-04-04: 4.409004179180698
if exudynTestGlobals.useGraphics:
#SC.WaitForRenderEngineStopFlag()
exu.StopRenderer() #safely close rendering window!
| 5,105 | 1,838 |
import logging
import sys
import time
from typing import List, Optional
import uvicorn
from fastapi import FastAPI
from fastapi.exceptions import RequestValidationError
from fastapi.responses import PlainTextResponse
from sklearn.pipeline import Pipeline
from src.entities import (
read_app_params,
HeartDiseaseModelRequest,
HeartDiseaseModelResponse,
)
from src.models import make_predict, load_model
logger = logging.getLogger(__name__)
handler = logging.StreamHandler(sys.stdout)
logger.setLevel(logging.INFO)
logger.addHandler(handler)
DEFAULT_CONFIG_PATH = "configs/app_config.yaml"
model: Optional[Pipeline] = None
app = FastAPI()
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request, exc):
return PlainTextResponse(str(exc), status_code=400)
@app.get("/")
def main():
return "it is entry point of our predictor"
@app.on_event("startup")
def load_app_model():
time.sleep(30)
app_params = read_app_params("configs/app_config.yaml")
logger.info("Start loading model")
global model
model = load_model(app_params.model_path)
logger.info("Model loaded")
@app.get("/predict/", response_model=List[HeartDiseaseModelResponse])
def predict(request: HeartDiseaseModelRequest):
return make_predict(request.data, request.features, model)
@app.get("/predict_new/", response_model=List[HeartDiseaseModelResponse])
def predict(request: HeartDiseaseModelRequest):
# For checking new code version (new docker image)
return make_predict(request.data, request.features, model)
@app.get("/healthz")
def health() -> bool:
return not (model is None)
def setup_app():
app_params = read_app_params(DEFAULT_CONFIG_PATH)
logger.info(f"Running app on {app_params.host} with port {app_params.port}")
uvicorn.run(app, host=app_params.host, port=app_params.port)
if __name__ == "__main__":
setup_app()
| 1,915 | 604 |
import hashlib
import hmac
import json
import datetime
from abc import ABCMeta, abstractmethod
from twisted.internet import protocol
from mod_config.models import Rule, Actions
from mod_honeypot.models import PiPotReport, Deployment
from pipot.encryption import Encryption
from pipot.notifications import NotificationLoader
from pipot.services import ServiceLoader
class ICollector:
"""
Interface that represents a uniform collector.
"""
__metaclass__ = ABCMeta
def __init__(self):
pass
@abstractmethod
def process_data(self, data):
"""
Server-side processing of received data.
:param data: A JSONified version of the data.
:type data: str
:return: None
:rtype: None
"""
pass
@abstractmethod
def queue_data(self, service_name, data):
"""
Client-side processing of data to send
:param service_name: The name of the service.
:type service_name: str
:param data: A JSON collection of data
:type data: dict
:return: None
:rtype: None
"""
pass
class ServerCollector(ICollector):
def __init__(self, db):
super(ServerCollector, self).__init__()
self.db = db
def queue_data(self, service_name, data):
pass
def process_data(self, data):
print("Received a message: %s" % data)
# Attempt to deserialize the data
try:
data = json.loads(data)
except ValueError:
print('Message not valid JSON; discarding')
return
# Check if JSON contains the two required fields
if 'data' not in data or 'instance' not in data:
print('Invalid JSON (information missing; discarding)')
return
""":type : mod_honeypot.models.Deployment"""
honeypot = Deployment.query.filter(
Deployment.instance_key == data['instance']).first()
if honeypot is not None:
# Attempt to decrypt content
decrypted = Encryption.decrypt(honeypot.encryption_key,
data['data'])
try:
decrypted_data = json.loads(decrypted)
except ValueError:
print('Decrypted data is not JSON; discarding')
return
if 'hmac' not in decrypted_data or \
'content' not in decrypted_data:
print('Decrypted data misses info; discarding')
return
# Verify message authenticity
mac = hmac.new(
str(honeypot.mac_key),
str(json.dumps(decrypted_data['content'], sort_keys=True)),
hashlib.sha256
).hexdigest()
try:
authentic = hmac.compare_digest(
mac, decrypted_data['hmac'].encode('utf8'))
except AttributeError:
# Older python version? Fallback which is less safe
authentic = mac == decrypted_data['hmac']
if authentic:
print('Data authenticated; processing')
# Determine service
for entry in decrypted_data['content']:
# Entry exists out of timestamp, service & data elements
timestamp = datetime.datetime.utcnow()
try:
timestamp = datetime.datetime.strptime(
entry['timestamp'], '%Y-%m-%d %H:%M:%S')
except ValueError:
pass
if entry['service'] == 'PiPot':
# Store
row = PiPotReport(honeypot.id, entry['data'],
timestamp)
self.db.add(row)
self.db.commit()
print('Stored PiPot entry in the database')
else:
# Get active services through the deployment profile
for p_service in honeypot.profile.services:
if p_service.service.name != entry['service']:
continue
print('Valid service for profile: %s' %
entry['service'])
# Valid service
service = ServiceLoader.get_class_instance(
entry['service'], self,
p_service.get_service_config()
)
# Convert JSON back to object
service_data = service.create_storage_row(
honeypot.id, entry['data'], timestamp)
notification_level = \
service.get_notification_level(service_data)
# Get rules that apply here
rules = Rule.query.filter(
Rule.service_id ==
p_service.service_id
).order_by(Rule.level.asc())
rule_parsed = False
for rule in rules:
if not rule.matches(notification_level):
continue
# Process message according to rule
notifier = \
NotificationLoader.get_class_instance(
rule.notification.name,
rule.get_notification_config()
)
notifier.process(
service_data.get_message_for_level(
notification_level
)
)
if rule.action == Actions.drop:
rule_parsed = True
break
if not rule_parsed:
# Store in DB
self.db.add(service_data)
self.db.commit()
print('Processed message; stored in DB')
else:
print('Processed message; dropping due to '
'rules')
if len(honeypot.profile.services) == 0:
print('There are no services configured for '
'this honeypot; discarding')
else:
print('Message not authentic; discarding')
# print('Expected: %s, got %s' % (mac, decrypted_data[
# 'hmac']))
# print('Payload: %s' % json.dumps(decrypted_data['content']))
else:
print('Unknown honeypot instance (%s); discarding' %
data['instance'])
class SSLCollector(protocol.Protocol):
def __init__(self, factory):
self.factory = factory
def connectionMade(self):
pass
def connectionLost(self, reason=protocol.connectionDone):
pass
def dataReceived(self, data):
if 'collector' in self.factory.__dict__:
self.factory.collector.process_data(data)
else:
print('No collector present!')
class SSLFactory(protocol.Factory):
def __init__(self, collector):
self.collector = collector
def buildProtocol(self, addr):
return SSLCollector(self)
class UDPCollector(protocol.DatagramProtocol):
def __init__(self, collector):
self.collector = collector
def datagramReceived(self, data, addr):
self.collector.process_data(data)
| 8,040 | 1,847 |
from sys import modules
from functools import wraps
from jsonschema import validate
from pyhttptest.constants import (
HTTP_METHOD_NAMES,
JSON_FILE_EXTENSION,
)
from pyhttptest.exceptions import (
FileExtensionError,
HTTPMethodNotSupportedError
)
from pyhttptest.http_schemas import ( # noqa
get_schema,
post_schema,
put_schema,
delete_schema
)
def check_file_extension(func):
"""A decorator responsible for checking whether
the file extension is supported.
An inner :func:`_decorator` slices the last five
characters of the passed ``file_path`` parameter and
checking whether they are equal to JSON file extension(.json).
If there is equality, decorated function business logic is
performed otherwise, the exception for not supported file extension
is raised.
Usage:
.. code-block:: python
@check_file_extension
def load_content_from_json_file(file_path):
...
:raises FileExtensionError: If the file extension is not '.json'.
"""
@wraps(func)
def _decorator(file_path):
file_extension = file_path[-5:]
if file_extension != JSON_FILE_EXTENSION:
raise FileExtensionError(file_extension)
return func(file_path)
return _decorator
def validate_extract_json_properties_func_args(func):
"""A validation decorator, ensuring that arguments
passed to the decorated function are with proper types.
An inner :func:`_decorator` does checking of arguments
types. If the types of the arguments are different than allowing
ones, the exception is raised, otherwise decorated function
is processed.
Usage:
.. code-block:: python
@validate_extract_json_properties_func_args
def extract_properties_values_from_json(data, keys):
...
:raises TypeError: If the data is not a `dict`.
:raises TypeError: If the keys is not a type of (`tuple`, `list`, `set`).
"""
@wraps(func)
def _decorator(data, keys):
if not isinstance(data, dict):
raise TypeError(
(
"Passed 'data' param argument, must be of "
"data type 'dict'. Not a type of {type}.".format(
type=type(data)
)
)
)
if not isinstance(keys, (tuple, list, set)):
raise TypeError(
(
"Passed 'keys' param argument, must be one of: "
"(tuple, list, set) data types. Not a type of {type}.".format(
type=type(keys)
)
)
)
return func(data, keys)
return _decorator
def validate_data_against_json_schema(func):
"""A validation decorator, ensuring that data is
covering JSON Schema requirements.
An inner :func:`_decorator` does checking of data
type, HTTP Method support along with appropriate JSON Schema,
that can validate passed data. If one of the checks doesn't match,
the exception is raised, otherwise, data validation is run against
JSON Schema and decorated function is processed.
Usage:
.. code-block:: python
@validate_data_against_json_schema
def extract_json_data(data):
...
:raises TypeError: If the data is not a `dict`.
:raises HTTPMethodNotSupportedError: If an HTTP Method is not supported.
:raises TypeError: If lack of appropriate JSON Schema to validate data.
"""
@wraps(func)
def _decorator(data):
if not isinstance(data, dict):
raise TypeError(
(
"Passed 'data' param argument, must be of "
"data type 'dict'. Not a type of {type}.".format(
type=type(data)
)
)
)
if 'verb' not in data or data['verb'].lower() not in HTTP_METHOD_NAMES:
raise HTTPMethodNotSupportedError(data.get('verb', 'None'))
http_schema_name = '_'.join([data['verb'].lower(), 'schema'])
# The key is used to extract module loaded in sys.modules
http_schema_module_key = '.'.join(
['pyhttptest.http_schemas', http_schema_name]
)
# Extract the module instance
http_schema_module = modules[http_schema_module_key]
if not hasattr(http_schema_module, http_schema_name):
raise ValueError(
(
'There is no appropriate JSON Schema to '
'validate data against it.'
)
)
http_schema_instance = getattr(http_schema_module, http_schema_name)
validate(instance=data, schema=http_schema_instance)
return func(data)
return _decorator
| 4,852 | 1,312 |
from datetime import datetime
import arrow
import pytest
from django.conf import settings
from resources.models import Day, Period, Reservation, Resource, ResourceType, Unit
TEST_PERFORMANCE = bool(getattr(settings, "TEST_PERFORMANCE", False))
@pytest.mark.skipif(not TEST_PERFORMANCE, reason="TEST_PERFORMANCE not enabled")
@pytest.mark.django_db
def test_api_resource_scalability(api_client):
u1 = Unit.objects.create(name='Unit 1', id='unit_1', time_zone='Europe/Helsinki')
rt = ResourceType.objects.create(name='Type 1', id='type_1', main_type='space')
p1 = Period.objects.create(start='2015-06-01', end='2015-09-01', unit=u1, name='')
Day.objects.create(period=p1, weekday=0, opens='08:00', closes='22:00')
Day.objects.create(period=p1, weekday=1, opens='08:00', closes='16:00')
# make reservations for the whole day
begin_res = arrow.get('2015-06-01T08:00:00Z').datetime
end_res = arrow.get('2015-06-01T16:00:00Z').datetime
perf_res_list = open('perf_res_list.csv', 'w')
perf_res_avail = open('perf_res_avail.csv', 'w')
perf_reservation = open('perf_reservation.csv', 'w')
perf_res_list.write('Resource listing\n')
perf_res_list.write('resources, time (s)\n')
perf_res_avail.write('Availability listing\n')
perf_res_avail.write('resources, time (s)\n')
perf_reservation.write('Single resource availability\n')
perf_reservation.write('Total reservations, time (s)\n')
for n in [1, 10, 100, 1000]:
Resource.objects.all().delete()
for i in range(n):
resource = Resource.objects.create(name=('Resource ' + str(i)), id=('r' + str(i)), unit=u1, type=rt)
Reservation.objects.create(resource=resource, begin=begin_res, end=end_res)
# Time the resource listing (resource query and serialization ~ O(n))
start = datetime.now()
response = api_client.get('/v1/resource/')
end = datetime.now()
perf_res_list.write(str(n) + ', ' + str(end - start) + '\n')
# Time the availability listing (resource and reservation queries, serialization and filtering ~ O(n)+O(n))
start = datetime.now()
response = api_client.get('/v1/resource/?start=2015-06-01T08:00:00Z&end=2015-06-01T16:00:00Z&duration=5000')
end = datetime.now()
perf_res_avail.write(str(n) + ', ' + str(end - start) + '\n')
# Time single resource availability (resource and reservation queries and serialization ~ O(1))
start = datetime.now()
response = api_client.get('/v1/resource/r0?start=2015-06-01T08:00:00Z&end=2015-06-01T16:00:00Z&duration=5000')
end = datetime.now()
perf_reservation.write(str(n) + ', ' + str(end - start) + '\n')
@pytest.mark.skipif(not TEST_PERFORMANCE, reason="TEST_PERFORMANCE not enabled")
@pytest.mark.django_db
def test_avail_resource_scalability(client):
u1 = Unit.objects.create(name='Unit 1', id='unit_1', time_zone='Europe/Helsinki')
rt = ResourceType.objects.create(name='Type 1', id='type_1', main_type='space')
p1 = Period.objects.create(start='2015-06-01', end='2015-09-01', unit=u1, name='')
Day.objects.create(period=p1, weekday=0, opens='08:00', closes='22:00')
Day.objects.create(period=p1, weekday=1, opens='08:00', closes='16:00')
# make reservations for the whole day
begin_res = arrow.get('2015-06-01T08:00:00Z').datetime
end_res = arrow.get('2015-06-01T16:00:00Z').datetime
perf_res_list = open('perf_res_list.csv', 'w')
perf_res_avail = open('perf_res_avail.csv', 'w')
perf_reservation = open('perf_reservation.csv', 'w')
perf_res_list.write('Resource listing\n')
perf_res_list.write('resources, time (s)\n')
perf_res_avail.write('Availability listing\n')
perf_res_avail.write('resources, time (s)\n')
perf_reservation.write('Single resource availability\n')
perf_reservation.write('Total reservations, time (s)\n')
for n in [1, 10, 100, 1000]:
Resource.objects.all().delete()
for i in range(n):
resource = Resource.objects.create(name=('Resource ' + str(i)), id=('r' + str(i)), unit=u1, type=rt)
Reservation.objects.create(resource=resource, begin=begin_res, end=end_res)
# Time the general availability for n resources and reservations
start = datetime.now()
response = client.get('/test/availability?start_date=2015-06-01&end_date=2015-06-30')
end = datetime.now()
perf_res_list.write(str(n) + ', ' + str(end - start) + '\n')
| 4,523 | 1,708 |
# Generated by Django 3.2.8 on 2021-10-12 22:34
from django.db import migrations, models
def fill_in_datetime_fields(apps, schema_editor):
# Old values in output field of delta table where string instead of json
Job = apps.get_model("core", "Job")
Job.objects.update(
started_at=models.F("created_at"), finished_at=models.F("updated_at")
)
class Migration(migrations.Migration):
dependencies = [
("core", "0044_alter_user_username"),
]
operations = [
migrations.AddField(
model_name="job",
name="finished_at",
field=models.DateTimeField(blank=True, null=True, editable=False),
),
migrations.AddField(
model_name="job",
name="started_at",
field=models.DateTimeField(blank=True, null=True, editable=False),
),
migrations.RunPython(fill_in_datetime_fields, migrations.RunPython.noop),
]
| 951 | 301 |
default_app_config = "wagtail_tag_manager.config.WagtailTagManagerConfig"
| 74 | 26 |
# Copyright 2015 ETH Zurich
#
# 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.
"""
:mod:`cache_test` --- lib.zk.cache unit tests
======================================================
"""
# Stdlib
from unittest.mock import call, patch
# External packages
import nose
import nose.tools as ntools
from kazoo.exceptions import (
ConnectionLoss,
NoNodeError,
NodeExistsError,
SessionExpiredError,
)
# SCION
from lib.zk.errors import ZkNoConnection, ZkNoNodeError
from lib.zk.cache import ZkSharedCache
from test.testcommon import assert_these_calls, create_mock
class TestZkSharedCacheStore(object):
"""
Unit tests for lib.zk.cache.ZkSharedCache.store
"""
def _setup(self):
inst = ZkSharedCache("zk", "path", "handler")
inst._path = "/path"
inst._zk = create_mock(["is_connected"])
inst._kazoo = create_mock(["create", "set"])
inst._incoming_entries = create_mock(["append"])
return inst
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test_not_connected(self, init):
inst = self._setup()
inst._zk.is_connected.return_value = False
# Call
ntools.assert_raises(ZkNoConnection, inst.store, 'n', 'v')
# Tests
inst._zk.is_connected.assert_called_once_with()
@patch("lib.zk.cache.time.time", autospec=True)
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test_set(self, init, time_):
inst = self._setup()
# Call
inst.store('n', 'v')
# Tests
inst._kazoo.set.assert_called_once_with("/path/n", "v")
ntools.assert_false(inst._kazoo.create.called)
inst._incoming_entries.append.assert_called_once_with(
("n", time_.return_value))
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def _check_set_conn_loss(self, excp, init):
inst = self._setup()
inst._kazoo.set.side_effect = excp
# Call
ntools.assert_raises(ZkNoConnection, inst.store, 'n', 'v')
def test_set_conn_loss(self):
for excp in ConnectionLoss, SessionExpiredError:
yield self._check_set_conn_loss, excp
@patch("lib.zk.cache.time.time", autospec=True)
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test_create(self, init, time_):
inst = self._setup()
inst._kazoo.set.side_effect = NoNodeError
# Call
inst.store('n', 'v')
# Tests
inst._kazoo.create.assert_called_once_with("/path/n", "v",
makepath=True)
inst._incoming_entries.append.assert_called_once_with(
("n", time_.return_value))
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test_suddenly_exists(self, init):
inst = self._setup()
inst._kazoo.set.side_effect = NoNodeError
inst._kazoo.create.side_effect = NodeExistsError
# Call
inst.store('n', 'v')
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def _check_create_conn_loss(self, excp, init):
inst = self._setup()
inst._kazoo.set.side_effect = NoNodeError
inst._kazoo.create.side_effect = excp
# Call
ntools.assert_raises(ZkNoConnection, inst.store, 'n', 'v')
def test_create_conn_loss(self):
for excp in ConnectionLoss, SessionExpiredError:
yield self._check_create_conn_loss, excp
class TestZkSharedCacheProcess(object):
"""
Unit tests for lib.zk.cache.ZkSharedCache.process
"""
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test_not_connected(self, init):
inst = ZkSharedCache("zk", "path", "handler")
inst._zk = create_mock(["is_connected"])
inst._zk.is_connected.return_value = False
# Call
ntools.assert_raises(ZkNoConnection, inst.process)
# Tests
inst._zk.is_connected.assert_called_once_with()
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test_full(self, init):
inst = ZkSharedCache("zk", "path", "handler")
inst._zk = create_mock(["conn_epoch", "is_connected"])
inst._incoming_entries = create_mock(["__bool__", "popleft"])
inst._incoming_entries.__bool__.side_effect = True, True, False
inst._incoming_entries.popleft.side_effect = ("inc0", 1), ("inc1", 0)
inst._entries = {"inc0": 0, "old0": 0}
inst._list_entries = create_mock()
inst._list_entries.return_value = "inc0", "inc1", "new0"
inst._handle_entries = create_mock()
inst._path = "/path"
# Call
inst.process()
# Tests
ntools.eq_(inst._entries, {"inc0": 0, "inc1": 0})
inst._handle_entries.assert_called_once_with({"new0"})
class TestZkSharedCacheGet(object):
"""
Unit tests for lib.zk.cache.ZkSharedCache._get
"""
@patch("lib.zk.cache.time.time", autospec=True)
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test_success(self, init, time_):
inst = ZkSharedCache("zk", "path", "handler")
inst._path = "/path"
inst._kazoo = create_mock(["get"])
inst._kazoo.get.return_value = ("data", "meta")
inst._entries = create_mock(["setdefault"])
# Call
ntools.eq_(inst._get("name"), "data")
# Tests
inst._kazoo.get.assert_called_once_with("/path/name")
inst._entries.setdefault.assert_called_once_with(
"name", time_.return_value)
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test_no_entry(self, init):
inst = ZkSharedCache("zk", "path", "handler")
inst._path = "/path"
inst._kazoo = create_mock(["get"])
inst._kazoo.get.side_effect = NoNodeError
inst._entries = create_mock(["pop"])
# Call
ntools.assert_raises(ZkNoNodeError, inst._get, "name")
# Tests
inst._kazoo.get.assert_called_once_with("/path/name")
inst._entries.pop.assert_called_once_with("name", None)
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def _check_exception(self, excp, expected, init):
inst = ZkSharedCache("zk", "path", "handler")
inst._path = "/path"
inst._kazoo = create_mock(["get"])
inst._kazoo.get.side_effect = excp
# Call
ntools.assert_raises(expected, inst._get, "name")
def test_exceptions(self):
for excp, expected in (
(ConnectionLoss, ZkNoConnection),
(SessionExpiredError, ZkNoConnection),
):
yield self._check_exception, excp, expected
class TestZkSharedCacheListEntries(object):
"""
Unit tests for lib.zk.cache.ZkSharedCache._list_entries
"""
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test_sucesss(self, init):
inst = ZkSharedCache("zk", "path", "handler")
inst._path = "/path"
inst._kazoo = create_mock(["get_children"])
inst._kazoo.get_children.return_value = [
"node0", "node1", "node2", "node3"]
# Call
ntools.eq_(inst._list_entries(),
{"node0", "node1", "node2", "node3"})
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test_no_cache(self, init):
inst = ZkSharedCache("zk", "path", "handler")
inst._path = "/path"
inst._kazoo = create_mock(["get_children"])
inst._kazoo.get_children.side_effect = NoNodeError
# Call
ntools.eq_(inst._list_entries(), set())
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def _check_children_exception(self, excp, expected, init):
inst = ZkSharedCache("zk", "path", "handler")
inst._path = "/path"
inst._kazoo = create_mock(["get_children"])
inst._kazoo.get_children.side_effect = excp
# Call
ntools.assert_raises(expected, inst._list_entries)
def test_children_exceptions(self):
for excp, expected in (
(ConnectionLoss, ZkNoConnection),
(SessionExpiredError, ZkNoConnection),
):
yield self._check_children_exception, excp, expected
class TestZkSharedCacheHandleEntries(object):
"""
Unit test for lib.zk.cache.ZkSharedCache._handle_entries
"""
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test(self, init):
inst = ZkSharedCache("zk", "path", "handler")
entry_names = ["entry0", "entry1", "entry2", "entry3"]
inst._get = create_mock()
inst._get.side_effect = [
"data0", ZkNoNodeError, "data2", ZkNoConnection
]
inst._path = "/path"
inst._handler = create_mock()
# Call
ntools.eq_(inst._handle_entries(entry_names), 2)
# Tests
assert_these_calls(inst._get, ([call(i) for i in entry_names]))
inst._handler.assert_called_once_with(["data0", "data2"])
class TestZkSharedCacheExpire(object):
"""
Unit test for lib.zk.cache.ZkSharedCache.expire
"""
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test_not_connected(self, init):
inst = ZkSharedCache("zk", "path", "handler")
inst._zk = create_mock(["is_connected"])
inst._zk.is_connected.return_value = False
# Call
ntools.assert_raises(ZkNoConnection, inst.expire, 42)
# Tests
inst._zk.is_connected.assert_called_once_with()
def _setup(self, time_, entries):
inst = ZkSharedCache("zk", "path", "handler")
inst._zk = create_mock(["is_connected"])
time_.return_value = 1000
inst._entries = entries
inst._kazoo = create_mock(["delete"])
inst._path = "/path"
return inst
@patch("lib.zk.cache.time.time", autospec=True)
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def test_success(self, init, time_):
entries = {}
for last_seen in 1000, 999, 996, 995, 994, 990, 1001:
entries["entry%d" % last_seen] = last_seen
inst = self._setup(time_, entries)
# Call
inst.expire(5)
# Tests
assert_these_calls(inst._kazoo.delete, [
call("/path/entry994"), call("/path/entry990")
], any_order=True)
@patch("lib.zk.cache.time.time", autospec=True)
@patch("lib.zk.cache.ZkSharedCache.__init__", autospec=True,
return_value=None)
def _check_exception(self, excp, expected, init, time_):
inst = self._setup(time_, {"entry1": 0})
inst._kazoo.delete.side_effect = excp
# Call
ntools.assert_raises(expected, inst.expire, 5)
def test_exceptions(self):
for excp, expected in (
(NoNodeError, ZkNoNodeError),
(ConnectionLoss, ZkNoConnection),
(SessionExpiredError, ZkNoConnection),
):
yield self._check_exception, excp, expected
if __name__ == "__main__":
nose.run(defaultTest=__name__)
| 12,081 | 3,927 |
# -*- coding: utf-8 -*-
#
# Copyright © 2021 Shuoyang Ding <shuoyangd@gmail.com>
# Created on 2021-02-11
#
# Distributed under terms of the MIT license.
import argparse
import logging
import math
import sys
logging.basicConfig(
format='%(asctime)s %(levelname)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO)
logging.getLogger().setLevel(logging.INFO)
opt_parser = argparse.ArgumentParser(description="")
opt_parser.add_argument("--tag-file", "-tf", required=True, help="file that holds system predictions, one label per line")
opt_parser.add_argument("--ref-file", "-rf", required=True, help="file that holds reference ok/bad labels, one label per line")
def f1(prec, recl):
return 2 * (prec * recl) / (prec + recl)
def main(options):
tf = open(options.tag_file, 'r')
rf = open(options.ref_file, 'r')
ok_correct = 0
ok_label_total = 0
ok_pred_total = 0
bad_correct = 0
bad_label_total = 0
bad_pred_total = 0
for idx, (tl, rl) in enumerate(zip(tf, rf)):
tag = tl.strip()
rl = rl.strip()
if tag == "OK":
ok_pred_total += 1
if rl == "OK":
ok_correct += 1
ok_label_total += 1
else:
bad_label_total += 1
elif tag == "BAD":
bad_pred_total += 1
if rl == "BAD":
bad_correct += 1
bad_label_total += 1
else:
ok_label_total += 1
else:
logging.error("line {0}: tag should either have value OK/BAD, but has value {1}".format(idx, tag))
if not (tf.read() == rf.read() == ''):
logging.error("Your tag and reference file are of different length. You should fix that first.")
ok_prec = ok_correct / ok_pred_total
ok_recl = ok_correct / ok_label_total
ok_f1 = f1(ok_prec, ok_recl)
sys.stdout.write("p/r/f for ok label: {0:.4f}/{1:.4f}/{2:.4f}\n".format(ok_prec, ok_recl, ok_f1))
bad_prec = bad_correct / bad_pred_total
bad_recl = bad_correct / bad_label_total
bad_f1 = f1(bad_prec, bad_recl)
sys.stdout.write("p/r/f for bad label: {0:.4f}/{1:.4f}/{2:.4f}\n".format(bad_prec, bad_recl, bad_f1))
sys.stdout.write("macro-f1: {0:.4f}\n".format(ok_f1 * bad_f1))
if __name__ == "__main__":
ret = opt_parser.parse_known_args()
options = ret[0]
if ret[1]:
logging.warning(
"unknown arguments: {0}".format(
opt_parser.parse_known_args()[1]))
main(options)
| 2,347 | 941 |
import collections
from typing import List
def maxDepth(s: str) -> int:
stack = []
max_depth = 0
for character in s:
if character == '(':
stack.append(character)
elif character == ')':
stack.pop()
max_depth = max(max_depth, len(stack))
return max_depth
def removeOuterParentheses(s: str) -> str:
stack = []
result = ''
for i, character in enumerate(s):
if character == '(':
stack.append(i)
else:
if len(stack) == 1:
result += s[stack[0] + 1:i]
stack.pop()
return result
def removeDuplicates(s: str) -> str:
stack = []
for character in s:
if not stack:
stack.append(character)
elif character == stack[-1]:
stack.pop()
else:
stack.append(character)
return ''.join(stack)
def calPoints(ops: List[str]) -> int:
stack = []
total_points = 0
for operation in ops:
if operation == 'C':
total_points -= stack.pop()
else:
if operation == '+':
stack.append(stack[-1] + stack[-2])
elif operation == 'D':
stack.append(stack[-1] * 2)
else:
stack.append(int(operation))
total_points += stack[-1]
return total_points
def makeGood(s: str) -> str:
stack = []
for character in s:
if not stack:
stack.append(character)
elif stack[-1] == character.lower() and stack[-1] != character:
stack.pop()
else:
stack.append(character)
return ''.join(stack)
def backspaceCompare(s: str, t: str) -> bool:
s_list = []
t_list = []
for character in s:
if character == '#':
if s_list:
s_list.pop()
else:
s_list.append(character)
for character in t:
if character == '#':
if t_list:
t_list.pop()
else:
t_list.append(character)
return s_list == t_list
def isValid(s: str) -> bool:
curly = 0
square = 0
bracket = 0
for character in s:
if character == ')':
bracket -= 1
elif character == '(':
bracket += 1
elif character == ']':
square -= 1
elif character == '[':
square += 1
elif character == '}':
curly -= 1
else:
curly += 1
if curly | square | bracket == -1:
return False
return curly == square == bracket == 0
def minAddToMakeValid(s: str) -> int:
min_add = 0
stack = 0
for character in s:
if character == ')':
if not stack:
min_add += 1
else:
stack -= 1
else:
stack += 1
return min_add + stack
def reverseParentheses(s: str) -> str:
s = list(s)
stack = []
result_list = []
for index, character in enumerate(s):
if character == ')':
while stack[-1] != '(':
result_list.append(stack.pop())
stack.pop()
stack.extend(result_list)
result_list = []
else:
stack.append(character)
return ''.join(stack)
def validateStackSequences(pushed: List[int], popped: List[int]) -> bool:
stack = []
pushed = collections.deque(pushed)
popped = collections.deque(popped)
while pushed:
if not stack or stack[-1] != popped[0]:
stack.append(pushed.popleft())
else:
popped.popleft()
stack.pop()
while popped and stack[-1] == popped[0]:
stack.pop()
popped.popleft()
return len(pushed) == len(popped) == 0
def minRemoveToMakeValid(s: str) -> str:
stack = []
remove_set = set()
for index, character in enumerate(s):
if character == ')':
if not stack:
remove_set.add(index)
else:
stack.pop()
elif character == '(':
stack.append(index)
remove_set.update(stack)
result = ''
for index, character in enumerate(s):
if index not in remove_set:
result += character
return result
def is_valid_abc(s: str) -> bool:
stack = []
for character in s:
stack.append(character)
while len(stack) >= 3 and stack[-3] + stack[-2] + stack[-1] == 'abc':
stack.pop()
stack.pop()
stack.pop()
return not stack
def remove_duplicate_value(s: str, k: int) -> str:
stack = []
for character in s:
stack.append(character)
if len(stack) >= k:
if set(stack[-k:]) == set(character):
for _ in range(k):
stack.pop()
return ''.join(stack)
def decodeString(s: str) -> str:
stack = []
for character in s:
stack.append(character)
if stack[-1] == ']':
stack.pop()
decode = ''
while stack[-1] != '[':
decode = stack.pop() + decode
stack.pop()
number = ''
while stack and stack[-1].isnumeric():
number += stack.pop()
decode = int(number[::-1]) * decode
stack.extend(list(decode))
return ''.join(stack)
def isanumber(a):
try:
float(repr(a))
bool_a = True
except:
bool_a = False
return bool_a
def evalRPN(tokens: List[str]) -> int:
stack = []
for i, token in enumerate(tokens):
if token.lstrip('-').isnumeric():
stack.append(int(token))
else:
first_pop = stack.pop()
second_pop = stack.pop()
if token == '/':
stack.append(int(second_pop / first_pop))
elif token == '+':
stack.append(second_pop + first_pop)
elif token == '*':
stack.append(second_pop * first_pop)
elif token == '-':
stack.append(second_pop - first_pop)
return stack[-1]
def finalPrices(prices: List[int]) -> List[int]:
result = [price for price in prices]
stack = []
for i, price in enumerate(prices):
if not stack:
stack.append(i)
else:
while stack and prices[stack[-1]] >= price:
index = stack.pop()
result[index] = prices[index] - price
stack.append(i)
return result
def nextGreaterElement(nums1: List[int], nums2: List[int]) -> List[int]:
result_map = {}
stack = []
for i, number in enumerate(nums2):
while stack and nums2[stack[-1]] < number:
index = stack.pop()
result_map[nums2[index]] = number
stack.append(i)
for i, num in enumerate(nums1):
if num in result_map:
nums1[i] = result_map[num]
else:
nums1[i] = -1
return nums1
def dailyTemperatures(temperatures: List[int]) -> List[int]:
result = [0 for _ in range(len(temperatures))]
stack = []
for index, temperature in enumerate(temperatures):
while stack and temperatures[stack[-1]] < temperature:
stack_index = stack.pop()
result[stack_index] = index - stack_index
stack.append(index)
return result
def nextGreaterElements(nums: List[int]) -> List[int]:
stack = []
result = [-1 for _ in range(len(nums))]
for i, num in enumerate(nums):
while stack and nums[stack[-1]] < num:
index = stack.pop()
result[index] = num
stack.append(i)
for i, num in enumerate(nums):
while stack and nums[stack[-1]] < num:
index = stack.pop()
result[index] = num
if not stack:
return result
return result
def exclusiveTime(n: int, logs: List[str]) -> List[int]:
res = [0] * n
stack = []
for log in logs:
ID, op, time = log.split(':')
ID = int(ID)
time = int(time)
if op == 'start':
if stack:
res[stack[-1][0]] += time - stack[-1][1]
stack.append([ID, time])
else:
prev = stack.pop()
res[ID] += time - prev[1] + 1
if stack:
stack[-1][1] = time + 1
return res
def validSubarrays(nums: List[int]) -> int:
result = 0
pointer_a = 0
while pointer_a < len(nums):
pointer_b = pointer_a
temp_result = []
while pointer_b < len(nums):
if nums[pointer_b] < nums[pointer_a]:
break
temp_result.append(nums[pointer_b])
result += 1
pointer_b += 1
pointer_a += 1
return result
input = [1, 4, 2, 5, 3]
print(validSubarrays(input))
| 8,865 | 2,692 |
#!/usr/bin/env python3
#
# Stolen almost verbatim from:
# https://gitlab.cern.ch/lhcb-rta/pidcalib2/-/blob/master/src/pidcalib2/pklhisto2root.py
###############################################################################
# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration #
# #
# This software is distributed under the terms of the GNU General Public #
# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". #
# #
# In applying this licence, CERN does not waive the privileges and immunities #
# granted to it by virtue of its status as an Intergovernmental Organization #
# or submit itself to any jurisdiction. #
###############################################################################
"""Convert pickled PIDCalib2 histograms to TH*D & save them in a ROOT file.
Only 1D, 2D, and 3D histograms are supported by ROOT. Attempting to convert
higher-dimensional histograms will result in an exception.
"""
import itertools
import math
import pathlib
import pickle
import sys
import boost_histogram as bh
import ROOT
def convert_to_root_histo(name: str, bh_histo: bh.Histogram):
"""Convert boost_histogram histogram to a ROOT histogram.
Only 1D, 2D, and 3D histograms are supported by ROOT. Attempting to convert
higher-dimensional histograms will result in an exception.
Furthermore, the boost histogram must have a storage type that stores
variance, e.g., Weight.
Args:
name: Name of the new ROOT histogram.
bh_histo: The histogram to convert.
Returns:
The converted ROOT histogram. Type depends on dimensionality.
"""
histo = None
if len(bh_histo.axes) == 1:
histo = ROOT.TH1D(name, name, 3, 0, 1)
histo.SetBins(bh_histo.axes[0].size, bh_histo.axes[0].edges)
histo.GetXaxis().SetTitle(bh_histo.axes[0].metadata["name"])
elif len(bh_histo.axes) == 2:
histo = ROOT.TH2D(name, name, 3, 0, 1, 3, 0, 1)
histo.SetBins(
bh_histo.axes[0].size,
bh_histo.axes[0].edges,
bh_histo.axes[1].size,
bh_histo.axes[1].edges,
)
histo.GetXaxis().SetTitle(bh_histo.axes[0].metadata["name"])
histo.GetYaxis().SetTitle(bh_histo.axes[1].metadata["name"])
elif len(bh_histo.axes) == 3:
histo = ROOT.TH3D(name, name, 3, 0, 1, 3, 0, 1, 3, 0, 1)
histo.SetBins(
bh_histo.axes[0].size,
bh_histo.axes[0].edges,
bh_histo.axes[1].size,
bh_histo.axes[1].edges,
bh_histo.axes[2].size,
bh_histo.axes[2].edges,
)
histo.GetXaxis().SetTitle(bh_histo.axes[0].metadata["name"])
histo.GetYaxis().SetTitle(bh_histo.axes[1].metadata["name"])
histo.GetZaxis().SetTitle(bh_histo.axes[2].metadata["name"])
else:
raise Exception(f"{len(bh_histo.axes)}D histograms not supported by ROOT")
indices_ranges = [list(range(n)) for n in bh_histo.axes.size]
for indices_tuple in itertools.product(*indices_ranges):
root_indices = [index + 1 for index in indices_tuple]
histo.SetBinContent(
histo.GetBin(*root_indices), bh_histo[indices_tuple].value # type: ignore
)
histo.SetBinError(
histo.GetBin(*root_indices), math.sqrt(bh_histo[indices_tuple].variance) # type: ignore # noqa
)
return histo
def convert_pklfile_to_rootfile(path: str, output_path: str):
pkl_path = pathlib.Path(path)
root_path = pathlib.Path(output_path)
eff_histos = {}
with open(pkl_path, "rb") as f:
eff_histos["eff"] = pickle.load(f)
eff_histos["passing"] = pickle.load(f)
eff_histos["total"] = pickle.load(f)
for item in eff_histos.values():
assert isinstance(item, bh.Histogram)
root_file = ROOT.TFile(str(root_path), "RECREATE")
eff_histo = convert_to_root_histo("eff", eff_histos["eff"])
eff_histo.Write()
passing_histo = convert_to_root_histo("passing", eff_histos["passing"])
passing_histo.Write()
total_histo = convert_to_root_histo("total", eff_histos["total"])
total_histo.Write()
root_file.Close()
def main():
file_in = sys.argv[1]
try:
file_out = sys.argv[2]
except IndexError:
file_out = pathlib.Path(sys.argv[1]).with_suffix('.root')
convert_pklfile_to_rootfile(file_in, file_out)
if __name__ == "__main__":
main()
| 4,684 | 1,664 |
d1 = {"koe":4,"slang":0,"konijn":4,"zebra":4}
d1["koe"]
d2 = {"vis":0,"beer":4,"kip":2}
d1.update(d2)
print (d1) | 112 | 67 |
from app.database import crud
from fastapi import HTTPException, status
def check_for_team_existence(db, team_id):
if crud.get_team(db, team_id=team_id) is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Team {} not found".format(team_id))
def check_for_player_existence(db, player_id):
if crud.get_player(db, player_id=player_id) is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Player {} not found".format(player_id))
def check_for_match_existence(db, match_id):
if crud.get_match(db, match_id=match_id) is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Match {} not found".format(match_id))
def check_for_tournament_existence(db, tournament_id):
if crud.get_tournament(db, tournament_id=tournament_id) is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Match {} not found".format(tournament_id))
| 958 | 338 |
"""
This module represents the Consumer.
Computer Systems Architecture Course
Assignment 1
March 2020
"""
from threading import Thread
from time import sleep
class Consumer(Thread):
"""
Class that represents a consumer.
"""
def __init__(self, carts, marketplace, retry_wait_time, **kwargs):
"""
Constructor.
:type carts: List
:param carts: a list of add and remove operations
:type marketplace: Marketplace
:param marketplace: a reference to the marketplace
:type retry_wait_time: Time
:param retry_wait_time: the number of seconds that a producer must wait
until the Marketplace becomes available
:type kwargs:
:param kwargs: other arguments that are passed to the Thread's __init__()
"""
Thread.__init__(self, **kwargs)
self.carts = carts
self.marketplace = marketplace
self.retry_wait_time = retry_wait_time
self.name = kwargs["name"]
self.cart_id = -1
def run(self):
for current_cart in self.carts:
self.cart_id = self.marketplace.new_cart(self.name)
for current_order in current_cart:
product_type = current_order["type"]
product = current_order["product"]
quantity = current_order["quantity"]
if product_type == "add":
while quantity > 0:
while True:
ret = self.marketplace.add_to_cart(self.cart_id, product)
if ret:
break
sleep(self.retry_wait_time)
quantity -= 1
else:
while quantity > 0:
self.marketplace.remove_from_cart(self.cart_id, product)
quantity -= 1
self.marketplace.place_order(self.cart_id)
| 1,964 | 515 |
import torch.nn as nn
import torch
import numpy as np
from torch.autograd import Variable
class RNNModel(nn.Module):
def __init__(self, input_dim, hidden_dim, layer_dim, output_dim):
super(RNNModel, self).__init__()
self.hidden_dim = hidden_dim
self.layer_dim = layer_dim
self.rnn = nn.RNN(input_dim, hidden_dim, layer_dim, batch_first=True, nonlinearity='relu')
self.fc = nn.Linear(hidden_dim, output_dim)
def forward(self, x):
h0 = Variable(torch.zeros(self.layer_dim, x.size(0), self.hidden_dim))
out, hn = self.rnn(x, h0)
out = self.fc(out[:, -1, :])
return out
def shuffle_torch(x, y):
p = np.random.permutation(x.shape[0])
return x[p], y[p]
def batch_generator_torch(x, y, batch_size, shuffle=True):
if shuffle:
x, y = shuffle_torch(x, y)
n_samples = x.shape[0]
for i in range(0, n_samples, batch_size):
yield x[i:i + batch_size], y[i:i + batch_size]
| 978 | 375 |
"""
transaction_set.py
Defines the Enrollment 834 005010X220A1 transaction set model.
"""
from typing import List, Optional
from linuxforhealth.x12.models import X12SegmentGroup
from .loops import Footer, Header, Loop1000A, Loop1000B, Loop1000C, Loop2000
from pydantic import root_validator, Field
from linuxforhealth.x12.validators import validate_segment_count
class BenefitEnrollmentAndMaintenance(X12SegmentGroup):
"""
The ASC X12 834 (Benefit Enrollment and Maintenance) transaction model.
"""
header: Header
loop_1000a: Loop1000A
loop_1000b: Loop1000B
loop_1000c: Optional[List[Loop1000C]] = Field(max_items=2)
loop_2000: List[Loop2000]
footer: Footer
# _validate_segment_count = root_validator(allow_reuse=True)(validate_segment_count)
| 791 | 312 |