text
stringlengths 8
6.05M
|
|---|
#!/usr/bin/python
# -*- coding: utf-8 -*-
import webbrowser
url = "http://www.psicobyte.com"
webbrowser.open(url, new=2)
|
# Function: ScoreLetter
# Dependency:
# Input: a letter 'i'
# Output: an integer(score of letter)
# Description:
def ScoreLetter(letter):
magic_book = {
'a': 2, 'b': 5, 'c': 4, 'd': 4, 'e': 1, 'f': 6, \
'g': 5, 'h': 5, 'i': 1, 'j': 7, 'k': 6, 'l': 3, \
'm': 5, 'n': 2, 'o': 3, 'p': 5, 'q': 7, 'r': 2, \
's': 1, 't': 2, 'u': 4, 'v': 6, 'w': 6, 'x': 7, \
'y': 5, 'z': 7
}
return(magic_book[letter])
# Test Codes
if __name__ == "__main__":
for letter in "abcdefghijklmnopqrstuvwxyz":
print(ScoreLetter(letter))
|
import cv2
from torch.utils.data import Dataset
import torchvision.transforms as transforms
import numpy.ma as ma
import numpy as np
from image_utils import (EnhancedCompose, Merge, RandomCropNumpy, Split, to_tensor,
BilinearResize, CenterCropNumpy, RandomRotate, AddGaussianNoise,
RandomFlipHorizontal, RandomColor, RandomAffineZoom)
from torchvision.transforms import Lambda, Normalize, ToTensor
NYUD_MEAN = [0.48056951, 0.41091299, 0.39225179]
NYUD_STD = [0.28918225, 0.29590312, 0.3093034]
out_size = (256, 208)
class NYUDepthV2(Dataset):
def __init__(self, imgs, test=False):
self.imgs = imgs
self.transform = self.get_transform(training=True, size=(256, 208))
self.trans = transforms.Compose([
transforms.ToPILImage(),
# transforms.CenterCrop((228, 304)),
transforms.ToTensor(),
transforms.Normalize(NYUD_MEAN, NYUD_STD)
])
self.trans_depth = transforms.Compose([
transforms.ToPILImage(),
transforms.ToTensor(),
# transforms.Normalize([0.5], [0.5])
])
self.trans_mask = transforms.Compose([
transforms.ToPILImage(),
transforms.ToTensor()
])
self.transform_test = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((228, 304)),
transforms.ToTensor(),
])
self.normalize = transforms.Compose([
transforms.Normalize(NYUD_MEAN, NYUD_STD)
])
self.test = test
if test:
self.images = np.load('test_set/images.npy')
self.depths = np.load('test_set/depths.npy')
def __getitem__(self, index):
if ~self.test:
index = index * 10
img_rgb = cv2.imread(self.imgs[index][0] + '/' + self.imgs[index][1])
img_rgb = cv2.resize(img_rgb, out_size, interpolation=cv2.INTER_AREA)
img_dep = cv2.imread(self.imgs[index][0] + '/' + self.imgs[index][2], cv2.IMREAD_GRAYSCALE)
img_dep = cv2.resize(img_dep, out_size, interpolation=cv2.INTER_AREA)
# depth = np.expand_dims(img_dep, axis=2)
# temp_mask = self.get_mask(depth)
# image, depth_mask = self.transform([img_rgb, depth, temp_mask])
# depth = depth_mask[0].unsqueeze(0)
# mask = depth_mask[1].unsqueeze(0)
image = self.trans(img_rgb)
depth = self.trans_depth(img_dep)
mask = self.trans_mask(self.get_mask(img_dep))
return image, depth, mask
else:
image = self.normalize(self.transform_test(self.images[index]))
depth = self.transform_test(self.depths[index])
return image, depth, 1
def __len__(self):
return int(len(self.imgs) / 10)
def get_mask(self, img_dep):
img_mask_1 = ma.masked_not_equal(img_dep, 0)
img_mask_2 = ma.masked_not_equal(img_dep, 255)
img_mask = ~img_mask_1.mask + ~img_mask_2.mask
img_mask = np.array(img_mask, dtype=np.uint8)
return 255 - img_mask * 255
def get_transform(self, training=True, size=(256, 192), normalize=True):
if training:
transforms = [
Merge(),
RandomFlipHorizontal(),
RandomRotate(angle_range=(-5, 5), mode='constant'),
RandomCropNumpy(size=size),
RandomAffineZoom(scale_range=(1.0, 1.5)),
Split([0, 3], [3, 5]), #
# Note: ToTensor maps from [0, 255] to [0, 1] while to_tensor does not
[RandomColor(multiplier_range=(0.8, 1.2)), None],
]
else:
transforms = [
[BilinearResize(0.5), None],
]
transforms.extend([
# Note: ToTensor maps from [0, 255] to [0, 1] while to_tensor does not
[ToTensor(), Lambda(to_tensor)],
[Normalize(mean=NYUD_MEAN, std=NYUD_STD), None] if normalize else None
])
return EnhancedCompose(transforms)
|
print("""
Short Tutorial on Sets
----------------------
Sets are mutable unorderd arrays of values. Sets are used for
comparisons, much like in boolean algebra. Importantly, sets
cannot contain duplicates! If duplicate values are passed into
a set creation, any duplicates are dropped.
""")
#Creating sets
print("""
Creating Sets
--------------
""")
print('Create set by a = set([1,2,3,4,5,6,7,8,9])')
print("Create set by a = set('abcdefg')")
print('Create set by a = {1,2,3,4,5,6,7,8,9}')
print('Create empty set by a = set(), cannot do a = {}')
#Changing elements in set
print("""
Changing Sets
-------------
""")
a = set('abcdefg')
print('Current state of set. a =', a)
print("Adding to set.\t\t\tCmd: a.add('h')\t\tResult:", a.add('h'))
print("Remove from set.\t\tCmd: a.remove('h')\tResult:", a.remove('h'), '- Returns error is element does not exist in set')
print("Remove from set if present.\tCmd: a.discard('h')\tResult:", a.discard('g'), '-tReturns no errors')
print("Remove and return last element.\tCmd: a.pop()\t\tReturns:", a.pop())
print("Remove all elements.\t\tCmd: a.clear()\t\tReturns:", a.clear())
#Set comparison
print("""
Set Comparison
--------------
""")
a = set('abracadabra')
b = set('alakazam')
print("Creating two new sets:\nCmd: a = set('abracadabra')\tResult: a = ", a, "\nCmd: b = set('alakazam')\tResult: b = ", b)
print('Letters in a but not in b.\tCmd: a-b\tResult:', a-b)
print('Letters in a or b.\t\tCmd: a|b\tResult:', a|b)
print('Letters in a and b.\t\tCmd: a&b\tResult:', a&b)
print('Letters in a xor b.\t\tCmd: a^b\tResult:', a^b)
print('Is a super set of b.\t\tCmd: a>b\tResult:', a^b)
print('Is a sub set of b.\t\tCmd: a<b\tResult:', a^b)
#Performing operations on a set
print("""
Various Operations
------------------
""")
a = set('abcdefg')
print('Note: Most operations require all elements of list be the same type.')
print('Convert other sequence types to a set by using set(var) command.')
print('Current state of set. a =', a)
print('Length of set.\t\tCmd: len(a)\t\tReturns:', len(a))
print('Max of set.\t\tCmd: max(a)\t\tReturns:', max(a))
print('Min of set.\t\tCmd: min(a)\t\tReturns:', min(a))
print("Test for element.\tCmd: 'a' in a\t\tReturns:", 'a' in a)
#Notes on list properties
print("""
Notes on set properties
-----------------------
- There was an older module called sets (as opposed to set) which functioned
similarly, but has since been depreciated. Do not use sets.
- All set elements are necessarily hashable.
- Checking for existence of elements within a set is much faster than checking
for existence in a tuple or list due to elements being hashed.
- There exists a frozenset sequence with many of the same properties, the only
difference being that frozensets are immutable.
""")
|
from data import Data_coldStart
import numpy as np
import logging
EPOCH = 30
LEARNRATE = 0.1
DECAY = 0.9
DIM = 10
FEATURE = 2
# logger = logging.getLogger()
# logger.setLevel(logging.NOTSET)
# formatter = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s")
#
# log_writer = logging.FileHandler('cold_net_3.7.log', 'a')
# log_writer.setLevel(logging.DEBUG)
# log_writer.setFormatter(formatter)
# log_print = logging.StreamHandler()
# log_print.setLevel(logging.INFO)
# log_print.setFormatter(formatter)
#
# logger.addHandler(log_writer)
# logger.addHandler(log_print)
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def vector_sigmoid(vector):
sig_vec = np.zeros_like(vector)
length = vector.shape[0]
for i in range(length):
sig_vec[i] = round(sigmoid(vector[i]), 3)
return sig_vec
class cold_model():
def __init__(self, act_num, country_num, director_num,
genre_num, users, dim=10, feature=4):
self.dim = dim
self.act_num = act_num
self.cty_num = country_num
self.drt_num = director_num
self.genre_num = genre_num
self.feature = feature
# printformat = 'dim=%d, act_num=%d, cty_num=%d, drt_num=%d, genre_num=%d'
# logger.debug('dim=%d, lr=%f' % (dim, LEARNRATE))
self.actor_w = np.random.uniform(-0.1, 0.1, (dim, act_num))
self.country_w = np.random.uniform(-0.1, 0.1, (dim, country_num))
self.director_w = np.random.uniform(-0.1, 0.1, (dim, director_num))
self.genre_w = np.random.uniform(-0.1, 0.1, (dim, genre_num))
self.actor_v = np.random.uniform(-0.1, 0.1, dim)
self.country_v = np.random.uniform(-0.1, 0.1, dim)
self.director_v = np.random.uniform(-0.1, 0.1, dim)
self.genre_v = np.random.uniform(-0.1, 0.1, dim)
self.P = {}
self.mk_user_mat(users)
self.init_gradient_param()
def mk_user_mat(self, users):
for user in users:
self.P[user] = np.random.uniform(0, 1, self.feature)
def prediction(self, actor, country, director, genre, user):
# vector shape = dim
self.actor_f = vector_sigmoid(np.dot(self.actor_w, actor))
self.country_f = vector_sigmoid(np.dot(self.country_w, country))
self.director_f = vector_sigmoid(np.dot(self.director_w, director))
self.genre_f = vector_sigmoid(np.dot(self.genre_w, genre))
# scalar shape = 1
actor_n = np.dot(self.actor_f, self.actor_v)
country_n = np.dot(self.country_f, self.country_v)
director_n = np.dot(self.director_f, self.director_v)
genre_n = np.dot(self.genre_f, self.genre_v)
self.vector_n = np.array([actor_n, country_n, director_n, genre_n])
return round(np.dot(self.P[user], self.vector_n), 2)
def init_gradient_param(self):
'''
:param users: 用户种类
:description: 用来暂存梯度下降更新的值
'''
self.ud_P = np.zeros(self.feature)
self.ud_actor_w = np.zeros_like(self.actor_w)
self.ud_country_w = np.zeros_like(self.actor_w)
self.ud_director_w = np.zeros_like(self.director_w)
self.ud_genre_w = np.zeros_like(self.genre_w)
self.ud_actor_v = np.zeros_like(self.actor_v)
self.ud_country_v = np.zeros_like(self.country_v)
self.ud_director_v = np.zeros_like(self.director_v)
self.ud_genre_v = np.zeros_like(self.genre_v)
def backward(self, user, eui, actor, country, director, genre, maxgrad=2):
for i in range(self.feature):
number = -eui * self.vector_n[i]
self.ud_P[i] = number if abs(number) < maxgrad else number/abs(number)*maxgrad
for t in range(self.dim):
actor_n = -eui * self.P[user][0] * self.actor_f[t]
country_n = -eui * self.P[user][1] * self.country_f[t]
director_n = -eui * self.P[user][2] * self.director_f[t]
genre_n = -eui * self.P[user][3] * self.genre_f[t]
self.ud_actor_v[t] = actor_n if abs(actor_n) < maxgrad else actor_n/abs(actor_n)*maxgrad
self.ud_country_v[t] = country_n if abs(country_n) < maxgrad else country_n/abs(country_n)*maxgrad
self.ud_director_v[t] = director_n if abs(director_n) < maxgrad else director_n/abs(director_n)*maxgrad
self.ud_genre_v[t] = genre_n if abs(genre_n) < maxgrad else genre_n/abs(genre_n)*maxgrad
mid_act = self.ud_actor_v[t] * self.actor_v[t] * (1 - self.actor_f[t])
mid_country = self.ud_country_v[t] * self.country_v[t] * (1 - self.country_f[t])
mid_director = self.ud_director_v[t] * self.director_v[t] * (1 - self.director_f[t])
mid_genre = self.ud_genre_v[t] * self.genre_v[t] * (1 - self.genre_f[t])
for k in range(self.act_num):
wn = mid_act * actor[k]
self.ud_actor_w[t][k] = wn if abs(wn) < maxgrad else wn/abs(wn)*maxgrad
for k in range(self.cty_num):
wn = mid_country * country[k]
self.ud_country_w[t][k] = wn if abs(wn) < maxgrad else wn/abs(wn)*maxgrad
for k in range(self.drt_num):
wn = mid_director * director[k]
self.ud_director_w[t][k] = wn if abs(wn) < maxgrad else wn/abs(wn)*maxgrad
for k in range(self.genre_num):
wn = mid_genre * genre[k]
self.ud_genre_w[t][k] = wn if abs(wn) < maxgrad else wn/abs(wn)*maxgrad
# print('ud_P', self.ud_P)
# print('\nud_actor_v', self.actor_v)
# print('\nud_country_v', self.ud_country_v)
# print('\nud_dirctor_v', self.ud_director_v)
# print('\nud_genre_v', self.ud_genre_v)
# print('\nud_actor_w', self.ud_actor_w)
# print('\nud_country_w', self.ud_country_w)
# print('\nud_director_w', self.ud_director_w)
# print('\nud_genre_w\n\n', self.ud_genre_w)
def update(self, user, lr=0.01):
for i in range(self.feature):
self.P[user][i] -= lr * self.ud_P[i]
for t in range(self.dim):
self.actor_v[t] -= lr * self.ud_actor_v[t]
self.country_v[t] -= lr * self.ud_country_v[t]
self.country_v[t] -= lr * self.ud_director_v[t]
self.genre_v[t] -= lr * self.ud_genre_v[t]
for t in range(self.dim):
for k in range(self.act_num):
self.actor_w[t][k] -= lr * self.ud_actor_w[t][k]
for k in range(self.cty_num):
self.country_w[t][k] -= lr * self.ud_country_w[t][k]
for k in range(self.drt_num):
self.director_w[t][k] -= lr * self.ud_director_w[t][k]
for k in range(self.genre_num):
self.genre_w[t][k] -= lr * self.ud_genre_w[t][k]
def train(self, train, actors, countries, directors, genres, lr, epoch=10 ** 6):
MAE = 0
RMSE = 0
for j, (user, item, rating) in enumerate(train):
eui = rating - self.prediction(actors[item], countries[item],
directors[item], genres[item], user)
# print(eui)
self.backward(user, eui, actors[item], countries[item],
directors[item], genres[item])
self.update(user, lr)
MAE += abs(eui)
RMSE += eui ** 2
return MAE/j, RMSE/j
def fit(self, EPOCH, data):
lr = LEARNRATE
for i in range(EPOCH):
MAE, RMSE = self.train(data.train.ratings, data.item_actors, data.item_country,
data.item_director, data.item_genres, LEARNRATE)
yield (i, MAE)
# logger.info('%d epoch the train MAE %f, RMSE %f' %
# (i, MAE / train_len, RMSE / train_len))
# MAE, RMSE = CM.test(data.test.ratings, data.item_actors, data.item_country,
# data.item_director, data.item_genres)
# logger.info('%d epoch the test MAE %f, RMSE %f\n' %
# (i, MAE / test_len, RMSE / test_len))
if i % 3 == 0:
lr *= DECAY
yield "finish"
def test(self, test, actors, countries, directors, genres):
MAE = 0
RMSE = 0
for j, (user, item, rating) in enumerate(test):
eui = rating - self.prediction(actors[item], countries[item],
directors[item], genres[item], user)
MAE += abs(eui)
RMSE += eui ** 2
return MAE, RMSE
def save_param(self):
path = 'model'
import os
if not os.path.exists(path):
os.makedirs(path)
self.writefile(path + 'actors_w', self.actor_w)
self.writefile(path + 'country_w', self.country_w)
self.writefile(path + 'director_w', self.director_w)
self.writefile(path + 'genre_w', self.genre_w)
self.writefile(path + 'actor_v', self.actor_v)
self.writefile(path + 'country_v', self.country_v)
self.writefile(path + 'director_v', self.director_v)
self.writefile(path + 'genre_v', self.genre_v)
self.writefile(path + 'P', self.P)
print('saving the model is successful!')
def writefile(self, filename, param):
with open(filename, 'w') as f:
f.writelines(str(param))
datapath = r'C:\Users\Darkn\python\recommender\hetrec2011-movielens-2k-v2'
dim = 10
data = Data_coldStart()
data.get_actor(datapath + r'\movie_actors.dat', weight=20)
data.get_country(datapath + r'\movie_countries.dat')
data.get_director(datapath + r'\movie_directors.dat')
data.get_genres(datapath + r'\movie_genres.dat', weight=30)
# data.get_data(DATAPATH + r'\user_ratedmovies.dat')
data.read_data()
actor_num, country_num, director_num, genre_num = data.size()
CM = cold_model(actor_num, country_num, director_num, genre_num, data.train.users, dim)
for epoch_info in CM.fit(30, data):
print(epoch_info)
|
from unittest import TestCase
from rest_framework.test import APIRequestFactory
from mimics.serializers import MimicSerializer
from windows.models import Window
class DeviceSerializerTestCase(TestCase):
def setUp(self):
self.factory = APIRequestFactory()
def test_get_links(self):
# TODO: `Mimic.window` field should not be required, in fact, `mimics` can creates as a library to select from
# it to use in `Windows`, so there should be a m2m field `windows.mimics` instead `mimic.window`
window = Window.objects.create(title="Security System", slug='security-system')
serializer = MimicSerializer(
data={'name': "Alarm Controller", 'slug': 'alarm-controller', 'window': window.pk},
context={'request': self.factory.get('/api/mimics/')}
)
valid = serializer.is_valid()
self.assertTrue(valid, serializer.errors)
mimic = serializer.save()
self.assertDictContainsSubset({
'links': {
'self': 'http://testserver/api/mimics/%s/' % mimic.pk,
'window': 'http://testserver/api/windows/%s/' % mimic.window.pk,
'vars': 'http://testserver/api/vars/?mimic=%s' % mimic.pk,
}
}, serializer.data)
|
#!/usr/bin/env python3
import argparse
import os
import os.path
from astroid.manager import AstroidManager
from astroid.utils import ASTWalker
from astroid.as_string import dump
from lib.check import check
import sys
class PrintAll:
def set_context(self, node, child_node):
pass
def visit_module(self, node):
print(node.as_string())
def print_module_code(module_path, tree):
print("In path %s" % module_path)
ASTWalker(PrintAll()).walk(tree)
def print_module_tree(module_path, tree):
print("In path %s" % module_path)
print(dump(tree))
def main():
#sys.argv = ["", "--check", "test_files/one_file/file.py"]
sys.argv = ["", "--check", "test_files/basic/caller.py"]
parser = argparse.ArgumentParser(description='Statically check types for consistency')
parser.add_argument('path', type=str, help='path to directory containing Python files,'
' or a path to a single Python file')
parser.add_argument("--print-code", action='store_true')
parser.add_argument("--print-tree", action='store_true')
parser.add_argument("--check", action="store_true")
args = parser.parse_args()
manager = AstroidManager()
dir, file = os.path.split(args.path)
if file[-len(".py"):] != ".py":
raise Exception("File must end with .py")
nodes = list(manager.project_from_files([dir]).get_children())
for child_node in nodes:
file_name = file[:-len(".py")]
node_name = child_node.name.split(".")[-1]
print(file_name, node_name)
if file_name == node_name:
node = child_node
break
else:
raise Exception("Unable to match filename with module")
if args.print_code:
print_module_code(args.path, node)
elif args.print_tree:
print_module_tree(args.path, node)
elif args.check:
check(args.path, node)
else:
raise Exception("One option must be selected")
if __name__ == "__main__":
main()
|
# Copyright 2023 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from pants.backend.terraform.lint.tfsec.rules import rules as tfsec_rules
def rules():
return tfsec_rules()
|
import os
import pdb
import matplotlib as M
import matplotlib.pyplot as plt
import evac.utils as utils
fig,axes = plt.subplots(nrows=4,ncols=3)
CASES = collections.OrderedDict()
CASES[datetime.datetime(2016,3,31,0,0,0)] = [
datetime.datetime(2016,3,31,19,0,0),
datetime.datetime(2016,3,31,20,0,0),
datetime.datetime(2016,3,31,21,0,0),
datetime.datetime(2016,3,31,22,0,0),
datetime.datetime(2016,3,31,23,0,0),
]
CASES[datetime.datetime(2017,5,1,0,0,0)] = [
datetime.datetime(2017,5,1,19,0,0),
datetime.datetime(2017,5,1,20,0,0),
datetime.datetime(2017,5,1,21,0,0),
datetime.datetime(2017,5,1,22,0,0),
datetime.datetime(2017,5,1,23,0,0),
]
CASES[datetime.datetime(2017,5,2,0,0,0)] = [
datetime.datetime(2017,5,2,23,0,0),
datetime.datetime(2017,5,3,0,0,0),
datetime.datetime(2017,5,3,1,0,0),
datetime.datetime(2017,5,3,2,0,0),
datetime.datetime(2017,5,3,3,0,0),
]
CASES[datetime.datetime(2017,5,4,0,0,0)] = [
datetime.datetime(2017,5,4,22,0,0),
datetime.datetime(2017,5,4,23,0,0),
datetime.datetime(2017,5,5,0,0,0),
datetime.datetime(2017,5,5,1,0,0),
datetime.datetime(2017,5,5,2,0,0),
]
KEYTIMES = {
datetime.datetime(2016,3,31,0,0,0) : datetime.datetime(2016,3,31,18,0,0),
datetime.datetime(2017,5,1,0,0,0) : datetime.datetime(2017,5,1,18,0,0),
datetime.datetime(2017,5,2,0,0,0) : datetime.datetime(2017,5,2,21,0,0),
datetime.datetime(2017,5,4,0,0,0) : datetime.datetime(2017,5,4,21,0,0),
for n, ax in axes.flat:
# nc is column number
# nr is row number
# https://rda.ucar.edu/datasets/ds608.0/
# Load reanalysis data depending on row
# Plot data depending on column
if nc == 0:
# CAPE and SHEAR
elif nc == 1:
# 500/925 hPa Z and sfc fronts
axes[0,n].contourf()
elif nc == 2:
# Reflectivity + tornado reports
|
import openpyxl as xl
from openpyxl.chart import Reference, BarChart
wb = xl.load_workbook("../files/excel/sample.xlsx")
sheet = wb["items"]
for row in range(2, sheet.max_row + 1):
priceCell = sheet.cell(row, 2)
descountCell = sheet.cell(row, 3)
totalCell = sheet.cell(row, 4)
totalCell.value = priceCell.value - ((descountCell.value * priceCell.value) / 100)
reference = Reference(sheet, min_row=2, max_row=5, min_col=1, max_col=4)
chart = BarChart()
chart.add_data(reference)
sheet.add_chart(chart, "A10")
wb.save("sample1.xlsx")
|
from utils import *
from .translators import *
from .scorers import *
from .keygenerators import *
from .solvers import *
|
#!/usr/bin/python
import copy
class Polynomial:
# coeffs is a list of the coefficients where index represents the degree
def __init__(self, coeffs):
self.coeffs = coeffs
def __deepcopy__(self, memo={}):
return Polynomial(copy.deepcopy(self.coeffs))
def __getitem__(self, degree):
return self.coeffs[degree - 1]
def __sub__(self, polynomial):
for i in range(len(polynomial.coeffs)):
self.coeffs[i] -= polynomial.coeffs[i]
# Removes the powers with a coefficient of 0 from the end
while self.coeffs[len(self.coeffs) - 1] == 0:
self.coeffs = self.coeffs[:len(self.coeffs) - 1]
return self
def __mul__(self, other):
for i in range(len(self.coeffs)):
self.coeffs[i] *= other
return self
def __str__(self):
ans = ""
if self.coeffs[len(self.coeffs) - 1] != 0 and len(self.coeffs) > 1:
if self.coeffs[len(self.coeffs) - 1] < 0:
ans += "-" + str(abs(self.coeffs[len(self.coeffs) - 1])) + "x^" + str(len(self.coeffs) - 1)
else:
ans += str(self.coeffs[len(self.coeffs) - 1]) + "x^" + str(len(self.coeffs) - 1)
for i in range(len(self.coeffs) - 2, 0, -1):
if self.coeffs[i] != 0:
if self.coeffs[i] > 0:
ans += " + "
else:
ans += " - "
ans += str(abs(self.coeffs[i])) + "x^" + str(i)
if self.coeffs[0] != 0:
if self.coeffs[0] > 0:
ans += " + "
else:
ans += " - "
ans += str(abs(self.coeffs[0]))
return ans
# Returns the degree of the polynomial
def degree(self):
return len(self.coeffs)
def longDivision(dividend, divisor):
if divisor.degree() == 0:
return # Error
q = [0] * (dividend.degree() - divisor.degree() + 1)
while dividend.degree() >= divisor.degree():
coeffs = [0] * (dividend.degree() - divisor.degree())
coeffs.extend(divisor.coeffs)
d = Polynomial(coeffs)
q[dividend.degree() - divisor.degree()] = dividend[dividend.degree()] // d[d.degree()]
d *= q[dividend.degree() - divisor.degree()]
dividend -= d
return Polynomial(q), dividend
# Set the dividend here
# x^3 - 12x^2 - 42
dividend = Polynomial([-42, 0, -12, 1])
# Set the divisor here
# x - 3
divisor = Polynomial([-3, 1])
t = longDivision(copy.deepcopy(dividend), divisor)
print("(" + str(dividend) + ") / (" + str(divisor) + ") = " + str(t[0]) + " Remainder = " + str(t[1]))
# List of tuples to iteratively test on
examples = [(Polynomial([-4, 0, -2, 1]), Polynomial([-3, 1])),
(Polynomial([-3, 2, -4, 1]), Polynomial([2, 1])),
(Polynomial([-7, 2, -13, 4]), Polynomial([-2, 3, 1])),
(Polynomial([5, 0, -2, 3]), Polynomial([-1, 0, 1]))]
for ex in examples:
t = longDivision(copy.deepcopy(ex[0]), ex[1])
print("(" + str(dividend) + ") / (" + str(divisor) + ") = " + str(t[0]) + " Remainder = " + str(t[1]))
|
import numpy as np
# 1ª questão, a.: Rede MLP para classificação
class MLPClassifier():
# Coloquei uma taxa de aprendizado (alpha) padrão de 0.1 e 100 épocas
def __init__(self, hidden_unit=None, epochs=100, alpha=0.1):
self.units = hidden_unit
self.epochs = epochs
self.alpha = alpha
def sigmoid(self, z):
return 1 / (1 + np.exp(-z))
def grad_sigmoid(self, z):
return self.sigmoid(z) * (1 - self.sigmoid(z))
def logistic_loss(self, y, y_pred):
return np.mean(-y * np.log(y_pred) - (1 - y)*np.log(1 - y_pred))
# Inicializando os pesos com valores entre 0 a 1
def initialize_weights(self, X, hidden_unit):
w_init = np.array([np.random.uniform(low=0, high=1, size=X.shape[1]) for i in range(hidden_unit)])
w_init[:, 0] = 1
weights = []
weights.append(w_init)
w_init = np.array([np.random.uniform(low=0, high=1, size=hidden_unit + 1) for i in range(X.shape[0])])
w_init[:, 0] = 0
weights.append(w_init)
return weights
# Calcula ui, zi, uk, yk
def mlp_forward(self, weights, X, activation_function, output=False):
num_hidden_layers = len(weights) - 1
layer_u = []
layer_z = []
for h in range(num_hidden_layers + 1):
if (h == 0):
u = weights[h] @ X
z = np.vstack((np.ones((1, u.shape[1])), activation_function(u)))
else:
u = weights[h] @ layer_z[h - 1]
z = activation_function(u)
layer_u.append(u)
layer_z.append(z)
if output:
y_pred = layer_z[1]
return y_pred #Retorna os valores preditos
else:
return (layer_u, layer_z)
# Calcula o error/ruído (ek) e os gradientes locais = delta_k e delta_i
def mlp_backward(self, weights, y, grad_activation_function, layer_u, layer_z):
num_hidden_layers = len(weights) - 1
layer_delta = [None]*(num_hidden_layers + 1)
for h in range(num_hidden_layers, -1, -1):
if h < num_hidden_layers:
delta = grad_activation_function(layer_u[h]) * \
(weights[h + 1][:, 1:].T @ layer_delta[h + 1])
else:
y_pred = y - layer_z[1]
delta = y_pred * grad_activation_function(layer_u[1])
layer_delta[h] = delta
return layer_delta
def fit(self, X, y):
activation = self.sigmoid
grad_activation = self.grad_sigmoid
loss_function = self.logistic_loss
loss_history = []
num_hidden_layers = 1
# y = y.copy()
# if len(y.shape) == 1:
# y = y[:, None]
# Inicializando os pesos
weights = self.initialize_weights(X, self.units)
for epoch in range(self.epochs):
random_permutation = np.array_split(np.random.permutation(y.shape[0]), y.shape[0])
for i in random_permutation:
Xi = X[i].T
yi = y[i].T
# Sentido direto
layer_u, layer_z = self.mlp_forward(weights, Xi, activation)
# Sentido inverso
layer_delta = self.mlp_backward(weights, yi, grad_activation, layer_u, layer_z)
# Atualiza os pesos
for h in range(num_hidden_layers + 1):
if h == 0:
layer_input = Xi.T
else:
layer_input = layer_z[h - 1].T
delta_weight = (self.alpha / Xi.shape[1]) * layer_delta[h] @ layer_input
weights[h] += delta_weight
model_output = self.mlp_forward(weights, X.T, activation, output=True)
loss_history.append(loss_function(y.T, model_output[0]))
self.weights = weights
self.loss = loss_history
def predict(self, X):
model_output = self.mlp_forward(self.weights, X.T, self.sigmoid, output=True)
return np.maximum(0, np.sign(model_output[0] - 0.55)) #Convertendo as probabilidades para 0's e 1's
def loss_history(self):
return self.loss
# 1. questão, b.: KNN para classificação
class KNeighborsClassifier():
def __init__(self, n_neighbors=None):
self.k = n_neighbors
def euclidean_distance(self, Xi, Xj):
return np.sqrt(np.sum((Xi - Xj)**2))
def batch_euclidean_distance(self, X1, X2):
return -2 * X1 @ X2.T + np.sum(X1**2, axis=1)[:, None] + np.sum(X2**2, axis=1)
# Fluxo geral e mais específico do algoritmo
def distance_matrix(self, X_, X):
dist_matrix = np.zeros((X_.shape[0], X.shape[0]))
for i in range(X_.shape[0]):
for j in range(X.shape[0]):
dist_matrix[i, j] = self.euclidean_distance(X_[i, :], X[j, :])
return dist_matrix
# Forma mais simplificada, utilizando as operações do próprio Numpy
def batch_distance_matrix(self, X_, X):
return self.batch_euclidean_distance(X_, X)
def fit(self, X, y):
self.classes = np.unique(y)
self.X = X
self.y = y.astype(int)
def predict(self, X_):
dist_matrix = self.batch_distance_matrix(X_, self.X)
#dist_matrix = self.distance_matrix(X_, self.X)
knn = np.argsort(dist_matrix)[:, 0:self.k]
y_pred = self.classes[np.argmax(np.apply_along_axis(np.bincount, 1, self.y[knn], minlength=self.classes.shape[0]), axis=1)]
return y_pred
|
from database_connection import connect
conn = connect()
cursor = conn.cursor()
# print("database created successfully")
# cursor.execute('''CREATE TABLE IF NOT EXISTS Admin
# (id INT AUTO_INCREMENT PRIMARY KEY,
# name VARCHAR(30) NOT NULL,
# email VARCHAR(20) NOT NULL,
# password VARCHAR(10) NOT NULL,
# created_at DATETIME DEFAULT CURRENT_TIMESTAMP);''')
#
# cursor.execute("INSERT INTO Admin VALUES (1,'sayan','sayan@gmail.com','sayan@1',datetime());")
#
# cursor.execute('''CREATE TABLE IF NOT EXISTS Employees
# (id INTEGER PRIMARY KEY AUTOINCREMENT,
# name VARCHAR(30) NOT NULL,
# email VARCHAR(20) NOT NULL UNIQUE,
# password VARCHAR(10) NOT NULL,
# role VARCHAR(10) DEFAULT "not assigned",
# created_at DATETIME DEFAULT CURRENT_TIMESTAMP);''')
#
#
# cursor.execute('''CREATE TABLE IF NOT EXISTS Supervisors
# (id INTEGER PRIMARY KEY AUTOINCREMENT,
# name VARCHAR(30) NOT NULL,
# email VARCHAR(20) NOT NULL,
# password VARCHAR(10) NOT NULL,
# assigned VARCHAR(20) DEFAULT "none",
# Team_Number INTEGER(10) NOT NULL,
# created_at DATETIME DEFAULT CURRENT_TIMESTAMP);''')
# cursor.execute('''CREATE TABLE IF NOT EXISTS Complaints
# (id INTEGER PRIMARY KEY AUTOINCREMENT,
# accident_name VARCHAR(30) NOT NULL,
# comments VARCHAR(50) NOT NULL,
# worker_id INTEGER(10) NOT NULL,
# status VARCHAR(10) DEFAULT "open",
# assigned_team INTEGER(10) DEFAULT "none",
# created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
# FOREIGN KEY (worker_id) REFERENCES Employees(id),
# FOREIGN KEY (assigned_team) REFERENCES Supervisors(Team_Number));''')
# cursor.execute('''CREATE TABLE IF NOT EXISTS Report
# (id INTEGER PRIMARY KEY AUTOINCREMENT,
# complaint_id INTEGER(10) NOT NULL,
# team_no INTEGER(10) NOT NULL,
# root_cause VARCHAR(50) NOT NULL,
# details VARCHAR(100) NOT NULL,
# status VARCHAR(10) DEFAULT "none",
# no_of_people_effected INTEGER(100) NOT NULL,
# death_rate INTEGER(100) DEFAULT "none",
# created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
# FOREIGN KEY (complaint_id) REFERENCES Complaints(id),
# FOREIGN KEY (team_no) REFERENCES Supervisors(Team_Number));''')
#
conn.commit()
conn.close()
|
import numpy as np
import pandas as pd
import sqlalchemy
from sqlalchemy.ext.automap import automap_base
from sqlalchemy.orm import Session
from sqlalchemy import create_engine, func
from flask import (
Flask,
render_template,
jsonify)
#################################################
# Reflect Database
#################################################
#connect to belly_button_biodiversity.sqlite
engine = create_engine("sqlite:///belly_button_biodiversity.sqlite", echo=False)
#use automap base
# Reflect Database into ORM classes
Base = automap_base()
Base.prepare(engine, reflect=True)
#set up session queries
session=Session(engine)
#Assign tables as objects
otu=Base.classes.otu
samples=Base.classes.samples
meta=Base.classes.samples_metadata
#################################################
# Flask Setup
#################################################
app = Flask(__name__)
#################################################
# Flask Routes
#################################################
@app.route("/")
def home():
"""Render Home Page."""
return render_template("index.html")
@app.route("/names")
def sample_names():
"""Return sample names"""
# sample names are column (from the 2nd column) names for the table samples
names = samples.__table__.columns.keys()[1:]
return jsonify(names)
@app.route("/otu")
def otu_description():
"""Return description of otu"""
# query for description in otu table
results=session.query(otu.lowest_taxonomic_unit_found).all()
descp=[i[0] for i in results]
return jsonify(descp)
@app.route("/metadata/<sample>")
def meta_data(sample):
#extract the id number of sample name eg. BB_940 into 940 for search
search=int(sample[3:])
print(sample)
result =session.query(meta).filter(meta.SAMPLEID==search).all()
#convert result into dictionary
dict_result=result[0].__dict__
# last part of dictionary is _sa_instance_state and needs to be removed
del dict_result['_sa_instance_state']
return jsonify(dict_result)
@app.route("/wfreq/<sample>")
def wfreq_data(sample):
#extract the id number of sample name eg. BB_940 into 940 for search
search=int(sample[3:])
print(sample)
result =session.query(meta.WFREQ).filter(meta.SAMPLEID==search).all()[0][0]
return jsonify(result)
@app.route('/samples/<sample>')
def sample_data(sample):
search=sample
# session.query(sample)
sel='samples.{}'.format(search)
print(sel)
result_1=session.query(samples.otu_id,sel).all()
data=pd.DataFrame(result_1,columns=['OTU_ID','Sample_Values']).sort_values('Sample_Values',ascending=False)
#convert the int into string so it can be jsonified
otu_id_str=list(data['OTU_ID'].astype('str'))
values_str=list(data['Sample_Values'].astype('str'))
return_dict={'otu_ids':otu_id_str,'sample_values':values_str}
print(return_dict)
return jsonify(return_dict)
if __name__ == '__main__':
app.run(debug=True)
|
from translate import Translator
print('HEEEELLOOOOOOOO')
translator = Translator(to_lang='fr')
translation = translator.translate('This is a boy: Ibrahim Olawale')
print(translation)
print(Translator)
with open('scared.txt', mode='r') as my_story:
story = my_story.read()
print(story)
translated_story = translator.translate(story)
print(translated_story)
with open('translated_story.txt', mode='w') as my_translated_story:
text = my_translated_story.write(translated_story)
print(text)
#text = my_story.write('The End.')
#translated_text = translator.translate(my_story)
# print(text)
# print(my_story.readlines())
# print(my_story)
|
import os
import shutil
import sys
#directory = 'C:\\dev\\projects\\halo\halo-cli\\tests\\gen4\\BIAN_APIs_Release9.0'
#dest = 'C:\\dev\\projects\\halo\halo-cli\\tests\\gen4\\BIAN9'
directory = sys.argv[1]
dest = sys.argv[2]
do_copy = False
#[print(x[0]) for x in os.walk(directory)]
cnt = 1
for x in os.walk(directory):
dir_files = x[2]
if len(dir_files) == 0:
continue
sd_name = None
f_name = None
json_name = None
for f in dir_files:
if f.endswith('json'):
f_name = f.replace('.json','')
obj_str = '"'+str(cnt)+'": { \
"f_name": "'+ f_name.strip() +'", \
"name": "'+ f_name.strip() +'", \
"service_domain": true, \
"swagger": true \
},'
print(obj_str)
#print(str(cnt)+' '+f_name)
cnt = cnt+1
if f.endswith('.json'):
json_name = x[0]+'\\'+f
if os.path.isfile(json_name) and do_copy:
shutil.copy(json_name, dest+'\\'+f_name+'.json')
|
"""
Implementation of Rescola-Wagner Model in Python3
"""
import numpy as np
import matplotlib.pyplot as plt
from utility import set_all_args
class pavlovian_conditioning(object):
def __init__(self, num_stimuli = 1, **kwargs):
self.num_stimuli = num_stimuli
self.learning_rate = 0.1 * np.ones(num_stimuli)
self.weights = np.zeros(num_stimuli)
set_all_args(self, kwargs)
self.w_his = [self.weights.copy()]
# stimuli must be a np array
def learn_step(self, stimuli, reward):
assert(len(stimuli) == self.num_stimuli)
reward_supposed = np.sum(self.weights * stimuli)
delta = reward - reward_supposed
self.weights += delta * self.learning_rate * stimuli
self.w_his.append(self.weights.copy())
def learn(self, experiments):
for exp in experiments:
self.learn_step(exp[:-1], exp[-1])
def plot(self, label = "$w$"):
w_his = np.transpose(self.w_his)
if self.num_stimuli == 1:
plt.plot(w_his[0], label = label)
else:
for i in range(self.num_stimuli):
plt.plot(w_his[i], label = "$w^{{({})}}$".format(i+1))
plt.xlabel("trial $n$")
plt.ylabel("animal's prediction parameter $w$")
|
import socket
import sys
# Create a UDS socket
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
# Connect the socket to the port where the server is listening
server_address = './uds_socket'
print >>sys.stdout, 'connecting to %s' % server_address
try:
sock.connect(server_address)
except socket.error, msg:
print >>sys.stderr, msg
sys.exit(1)
try:
# Send data
message = 'This is the message. It will be repeated.'
print >>sys.stderr, 'sending "%s"' % message
sock.sendall(message)
# Look for the response
amount_received = 0
amount_expected = len(message)
while amount_received < amount_expected:
data = sock.recv(16)
amount_received += len(data)
print >>sys.stderr, 'received "%s"' % data
finally:
print >>sys.stderr, 'closing socket'
sock.close()
"""
connecting to ./uds_socket
sending "This is the message. It will be repeated."
received "This is the mess"
received "age. It will be "
received "repeated."
closing socket
"""
|
import os, sys, inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0,parentdir)
import unittest
import cvxpy as cp
import numpy as np
import fisherVerifier
import fisherMarket
np.set_printoptions(formatter={'float': '{: 0.3f}'.format})
class MyTestCase(unittest.TestCase):
def testExample1(self):
"""
Example in the Eisenberg-Gale paper:
Consensus of Subjective Probabilities: The Pari-Mutuel Method on JSTOR
https://www.jstor.org/stable/2237130?casa_token=O576M6_fWzsAAAAA:QqMHo9vTXEQa1Q7X-dUkPDaNSneFLzhTmChI6XWKVFMgh6GE8iwI4x-vmezbE1fe4-KDKcsVPJBK1OmcSCgIVYmQ8Uv2SljiTxTp3Ur264Pwmn8Kzp0g&socuuid=8a7880bd-edae-4c49-b540-73ea19e69fba&socplat=twitter
"""
valuations = np.array([[10.85, 10.5], [0.5, 0.5]])
budgets = np.array([1, 1])
m1 = fisherMarket.FisherMarket(valuations, budgets)
X, p = m1.solveMarket("linear", printResults=False)
print(X)
print(p)
def testMarkets(self, num_buyers=15, num_goods=20, num_trials=10, tolerance=1e-1):
"""
Test num_trials many i.i.d. random markets with num_buyers many consumers and num_goods many goods.
For each market, compute its equilibria as a fisher (linear) market. Then, fixing the equilibria price vector,
compute for each consumer its utility maximizing bundle. The utility of the later computation should equal
the utility of the equilibria computation. We check equality up to given tolerance.
:param num_buyers: the number of consumers. Default is 20.
:param num_goods: the number of goods. Default is 20.
:param num_trials: the number of random, i.i.d. markets.
"""
for trial in range(num_trials):
try:
# Matrix of valuations: |buyers| x |goods|
valuations = np.random.rand(num_buyers, num_goods)*100
# Budgets of buyers: |buyers|
budgets = np.random.rand(num_buyers)*10
print(f"\n ********** Linear Utility Tests **********")
################ Linear #################
# Create Market
market = fisherMarket.FisherMarket(valuations, budgets)
X, p = market.solveMarket("linear", printResults=False)
print(f"\n ***** Trial {trial} *****")
consumer_eq_utility = np.sum(valuations*X, axis = 1)
for buyer in range(num_buyers):
budget = budgets[buyer]
valuation = valuations[buyer]
max_u = fisherVerifier.getIndirectUtil(valuation, p, budget, utility = "linear")
error = abs(max_u - consumer_eq_utility[buyer])
print(f"{buyer}'s consumer error is {error}")
self.assertLess(error, tolerance*max_u)
print(f"\n ********** Quasilinear Utility Tests **********")
################ Quasiinear #################
# Create Market
market = fisherMarket.FisherMarket(valuations, budgets)
X, p = market.solveMarket("quasilinear", printResults=False)
print(f"\n ***** Trial {trial} *****")
consumer_eq_utility = np.sum((valuations- p)*X, axis = 1)
print(consumer_eq_utility.shape)
for buyer in range(num_buyers):
budget = budgets[buyer]
valuation = valuations[buyer]
max_u = fisherVerifier.getIndirectUtil((valuation - p), p, budget, utility = "linear")
error = abs(max_u - consumer_eq_utility[buyer])
print(f"{buyer}'s consumer error is {error}")
self.assertLess(error, tolerance*max_u)
print(f"\n ********** Leontief Utility Tests **********")
################ Leontief #################
# Create Market
market = fisherMarket.FisherMarket(valuations, budgets)
X, p = market.solveMarket("leontief", printResults=False)
print(f"\n ***** Trial {trial} *****")
consumer_eq_utility = np.min(X/valuations, axis = 1)
for buyer in range(num_buyers):
budget = budgets[buyer]
valuation = valuations[buyer]
max_u = fisherVerifier.getIndirectUtil(valuation, p, budget, utility = "leontief")
error = abs(max_u - consumer_eq_utility[buyer])
print(f"{buyer}'s consumer error is {error}")
self.assertLess(error, tolerance)
print(f"\n ********** CES Utility Tests **********")
################ CES #################
rho = np.random.choice([0.3, 0.4, 0.5, 0.6, 0.7])
# Create Market
X, p = market.solveMarket("ces", printResults=False, rho = rho)
consumer_eq_utility = np.sum(valuations*np.power(X, rho), axis = 1)**(1/rho)
for buyer in range(num_buyers):
budget = budgets[buyer]
valuation = valuations[buyer]
max_x = fisherVerifier.getMarshallianDemand(valuation, p, budget, utility = "ces", rho = rho)
max_u = (valuation.T @ np.power(max_x, rho))**(1/rho)
error = abs(max_u - consumer_eq_utility[buyer])
print(f"{buyer}'s util1 {max_u} other util {consumer_eq_utility[buyer]}")
print(f"{buyer}'s consumer error is {error}")
self.assertLess(error, tolerance)
except cp.error.SolverError:
print("IGNORING")
if __name__ == '__main__':
unittest.main()
|
li = []
while 1:
try: li.append(float(input()))
except: break
print(max(li) - min(li))
|
import turtle
turtle.pendown()
counter = 0
while(not (counter == 6)):
turtle.forward(100)
turtle.right(60)
counter = counter + 1
|
import tensorflow as tf
import numpy as np
#import tensorflow.examples.tutorials.mnist.input_data as input_data
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST data", one_hot=True)
|
import falcon
import log
from sqlalchemy.orm.exc import NoResultFound
from controller.base import BaseResource
from util.hooks import authorization
from util.authorization import encrypt_token, hash_password, uuid
from model import User, Base
from util.error.errors import NotValidParameterError, UserNotExistsError, AppError, OperationError
from util.validators import validate_user_create, validate_money_transfer_create
LOG = log.get_logger()
class Collection(BaseResource):
"""
/resev/v1/users
"""
@falcon.before(validate_user_create)
def on_post(self, req, res):
session = req.context['session']
user_req = req.context['data']
if user_req:
user = User()
user.username = user_req['username']
user.email = user_req['email']
user.password = hash_password(user_req['password']).decode('utf-8')
user.details = user_req['details'] if 'info' in user_req else None
user.balance = user_req['balance'] if 'balance'in user_req else 100.0
uuid_id = uuid()
user.uuid_id = uuid_id
user.token = encrypt_token(uuid_id).decode('utf-8')
session.add(user)
user_db = session.query(User).filter_by(username=user_req['username']).one()
self.on_success(res, user_db.to_dict())
else:
raise NotValidParameterError(req.context['data'])
@falcon.before(authorization)
def on_get(self, req, res):
session = req.context['session']
user_dbs = session.query(User).all()
if user_dbs:
obj = [user.to_dict() for user in user_dbs]
self.on_success(res, obj)
else:
raise AppError()
@falcon.before(authorization)
def on_put(self, req, res):
pass
class Item(BaseResource):
"""
/resev/v1/users/{user_id}
"""
@falcon.before(authorization)
def on_get(self, req, res, user_id):
session = req.context['session']
try:
user_db = User.find_one(session, user_id)
self.on_success(res, user_db.to_dict())
except NoResultFound:
raise UserNotExistsError('user id: %s' % user_id)
class ItemTransfer(BaseResource):
"""
/resev/v1/users/{user_id}/transfer
"""
@falcon.before(authorization)
@falcon.before(validate_money_transfer_create)
def on_post(self, req, res, user_id):
session = req.context['session']
borrow_data = req.context['data']
if borrow_data:
try:
user_lender = User.find_one(session, user_id)
user_borrower = User.find_by_username(session, borrow_data['borrower'])
quantity = borrow_data['quantity']
except NoResultFound:
raise UserNotExistsError('user id: %s' % user_id)
try:
if user_lender.balance < 0:
raise OperationError()
lender_quantity = user_lender.balance - quantity
borrower_quantity = user_borrower.balance + quantity
user_lender.find_update(session, user_lender.user_id, {User.balance: lender_quantity})
user_borrower.find_update(session, user_borrower.user_id, {User.balance: borrower_quantity})
session.commit()
user_updated = User.find_one(session, user_id)
except Exception as e:
raise OperationError()
self.on_success(res, user_updated.to_dict())
else:
raise NotValidParameterError(req.context['data'])
|
from distutils.core import setup, Extension
module1 = Extension('_iter',
sources=['_iter.c'])
# extra_compile_args=['/Zi'],
# extra_link_args=['/DEBUG'])
setup(name='_iter',
version='0.1',
description='Contains iteration stuffs',
ext_modules=[module1])
|
"""Message View tests."""
# run these tests like:
#
# FLASK_ENV=production python -m unittest test_user_views.py
import os
import pdb
from unittest import TestCase
from models import Follows, db, connect_db, Message, User
os.environ['DATABASE_URL'] = "postgresql:///warbler-test"
from app import app, CURR_USER_KEY, users_followers
db.create_all()
app.config['WTF_CSRF_ENABLED'] = False
class UsereViewTestCase(TestCase):
"""Test views for messages."""
def setUp(self):
"""Create test client, add sample data."""
User.query.delete()
Message.query.delete()
self.client = app.test_client()
u = User.signup(username="testuser",
email="test@test.com",
password="testuser",
image_url=None)
db.session.add(u)
db.session.commit()
self.testuser = User.query.filter_by(username=u.username).one()
msg = Message(
text="text",
user_id=self.testuser.id
)
db.session.add(msg)
db.session.commit()
self.testmessage = Message.query.get(msg.id)
def tearDown(self):
"""Clear tables"""
User.query.delete()
Message.query.delete()
def test_logout(self):
"""Can user properly log out?"""
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.testuser.id
resp = c.get("/logout", follow_redirects=True)
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn("<h2 class=\"join-message\">Welcome back.</h2>", html)
def test_home_logged_in(self):
"""Can user see the proper home page when logged in?"""
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.testuser.id
resp = c.get("/")
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn(self.testuser.username, html)
def test_follow_views_logged_in(self):
"""Can user see followed / following views for any user?"""
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.testuser.id
User.signup("test", "test@test.net", "PASSWORD", "")
u = User.query.filter_by(username="test").one()
db.session.add(Follows(
user_being_followed_id=u.id,
user_following_id=self.testuser.id
))
db.session.commit()
resp = c.get(f"/users/{self.testuser.id}/following")
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn(u.username, html)
resp = c.get(f"/users/{u.id}/followers")
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn(self.testuser.username, html)
def test_follow_views_logged_out(self):
"""Can user see follower / following views for any user when logged out?"""
with self.client as c:
resp = c.get(f"/users/{self.testuser.id}/following")
self.assertEqual(resp.status_code, 302)
resp = c.get(f"/users/{self.testuser.id}/followers")
self.assertEqual(resp.status_code, 302)
def test_new_message_logged_in(self):
"""Can user create new message when logged in?"""
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.testuser.id
resp = c.post(f"/messages/new",
data={"text": "TEST_TEXT"},
follow_redirects=True)
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn("TEST_TEXT", html)
def test_new_message_logged_out(self):
"""Can user create new message when logged out?"""
with self.client as c:
resp = c.get(f"/messages/new", follow_redirects=True)
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn("Access unauthorized.", html)
self.assertEqual(len(Message.query.all()), 1)
def test_delete_message_logged_in(self):
"""Can a logged in user delete their own message?"""
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.testuser.id
msg = Message(text="TEST_TEXT", user_id=self.testuser.id)
db.session.add(msg)
db.session.commit()
msg = Message.query.filter_by(text="TEST_TEXT").one()
resp = c.post(f"/messages/{msg.id}/delete", follow_redirects=True)
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertNotIn(msg.text, html)
self.assertFalse(Message.query.filter_by(id=msg.id).one_or_none())
def test_delete_another_users_message_logged_in(self):
"""Can a logged in user delete another user's message?"""
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.testuser.id
User.signup("foo", "foo@foo.foo", "foontastic", "")
u = User.query.filter_by(username="foo").one()
msg = Message(text="TEST_TEXT", user_id=u.id)
db.session.add(msg)
db.session.commit()
msg = Message.query.filter_by(text="TEST_TEXT").one()
resp = c.post(f"/messages/{msg.id}/delete", follow_redirects=True)
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn("Access unauthorized", html)
def test_delete_message_logged_out(self):
"""Can a user delete a message?"""
with self.client as c:
msg = Message(text="TEST_TEXT", user_id=self.testuser.id)
db.session.add(msg)
db.session.commit()
msg = Message.query.filter_by(text="TEST_TEXT").one()
resp = c.post(f"/messages/{msg.id}/delete", follow_redirects=True)
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn("Access unauthorized", html)
|
"""Module containing test functions for Income Account/Statement zones."""
from re import finditer
import numpy as np
import pandas as pd
import re
def test_caps_income_account(value):
"""Search zone content for 'INCOME ACCOUNT' string."""
def caps_ratio(value):
"""Define ratio of capital characters."""
cap_count = 0
for char in value.replace(' ', ''):
if char.isupper():
cap_count += 1
caps_ratio = cap_count / len(value.replace(' ', ''))
return caps_ratio
test_string = r'.*[Iil][Nnm][CcOo0Ee]{2}.{1,4}[Aa][CcOoEe0]{3}[Uu].*'
print_test = r'[Iil][Nnm][CcOo0Ee]{2}.{1,4}[Aa][CcOoEe0]{3}[Uu].{1,3}'
if re.match(test_string, value):
value_out = 0
for match in finditer(print_test, value):
if caps_ratio(match.group()) > .2:
# print(match.span(), match.group())
value_out = 1
else:
value_out = 0
return value_out
def test_income_account(value):
"""Search zone content for 'Income Account' string."""
test_string_account = r'.*[Iil][nm][coe0]{2}.{1,4}[Aa][coe0]{3}[u].*'
print_test_account = r'[Iil][nm][coe0]{2}.{1,4}[Aa][coe0]{3}[u].{1,3}'
if re.match(test_string_account, value):
value_out = 0
test_string_year = r'.*[Yy][er][as].{1,10}[Eet][no]d*.*'
test_string_month = r'.*[Mm][o][n\.].{1,9}[\s][Eet][no]d*.*'
test_string_period = r'.*[Pp][eo]ri.{1,30}[Eet]*[no]*d*.*'
test_string_to = r'.*\d{3,4}.{1,3}to.*'
print_test_year = r'[Yy][er][as].{1,10}[Eet\&][no]d*'
print_test_month = r'[Mm][o][n\.].{1,9}[\s][Eet\&][no]d*'
print_test_period = r'[Pp][eo]ri.{1,30}[Eet\&]*[no]*d*'
print_test_to = r'\d{3,4}.{1,3}to'
if (re.match(test_string_year, value) or re.match(test_string_month, value) or
re.match(test_string_period, value) or re.match(test_string_to, value)):
match_beginning_year = []
match_beginning_month = []
match_beginning_period = []
match_beginning_to = []
for match in finditer(print_test_account, value):
# print(match.span(), match.group())
match_beginning = match.span()[0]
match_end = match.span()[-1]
for match in finditer(print_test_year, value):
# print(match.span(), match.group())
match_beginning_year.append(match.span()[0])
for match in finditer(print_test_month, value):
match_beginning_month.append(match.span()[0])
for match in finditer(print_test_period, value):
match_beginning_period.append(match.span()[0])
for match in finditer(print_test_to, value):
match_beginning_to.append(match.span()[0])
sub_match_list = match_beginning_year + match_beginning_month + match_beginning_period + match_beginning_to
distance_list = [True for match in sub_match_list if abs(match_end - match) < 45]
if any(distance_list):
value_out = 1
else:
value_out = 0
return value_out
def trailing_number_content(row):
"""Search current or next zone string for high-density of numbers (indicating table)."""
value_out = 0
current_zone = str(row['text'])
zone_next = str(row['zone_next'])
def digit_ratio(test_string):
"""Define ratio of capital characters."""
digit_count = 0
for char in test_string.replace(' ', ''):
if char.isdigit():
digit_count += 1
digit_ratio = digit_count / len(test_string.replace(' ', ''))
return digit_ratio
def count_dollars(test_string):
"""Define ratio of capital characters."""
dollar_count = 0
for char in test_string.replace(' ', ''):
if char == '$' or char == '£':
dollar_count += 1
return dollar_count
test_string = r'.*[Iil][Nnm][CcOo0Ee]{2}.{1,4}[Aa][CcOoEe0]{3}[Uu].*'
print_test = r'[Iil][Nnm][CcOo0Ee]{2}.{1,4}[Aa][CcOoEe0]{3}[Uu].{1,3}'
if re.match(test_string, current_zone):
for match in finditer(print_test, current_zone):
# print(match.span(), match.group())
# print(row.name)
match_beginning = match.span()[0]
len_to_end = len(current_zone) - match_beginning
if len_to_end < 350:
overflow = 350 - len_to_end
test_string = current_zone[match_beginning:] + zone_next[:overflow]
else:
test_string = current_zone[match_beginning:match_beginning + 350]
test_string_digit_ratio = digit_ratio(test_string)
test_string_dollar_count = count_dollars(test_string)
if test_string_digit_ratio > .15 and test_string_dollar_count > 3:
value_out = 1
return value_out
def test_trailing_colon(value):
"""ID trailing colons and semi-colons"""
test_string = r'.*[Iil][Nnm][CcOo0Ee]{2}.{1,4}[Aa][CcOoEe0]{3}[Uu].{1,3}\s*[\;\:].*'
if re.match(test_string, str(value)):
value_out = 1
else:
value_out = 0
return value_out
|
from Statstools.Timeseries import Timeseries
import numpy
import matplotlib.pyplot
from mpl_toolkits.axes_grid1 import make_axes_locatable
class Discretized():
def __init__(self, name, mesh, data, dimX, dimY, dimZ):
self.name = name
self.mesh = mesh
self.data = data
self.dimX = dimX
self.dimY = dimY
self.dimZ = dimZ
@classmethod
def generateMesh(cls, name, data, edges):
dimY = data.shape[0]
dimX = data.shape[1]
dimZ = data.shape[2]
print("Warning... Meshing of Timeseries objects may take long.")
mesh = [[Timeseries('('+str(i)+' '+str(j)+')', data[i,j,:], edges) for j in range(dimX)] for i in range(dimY)]
print("Mesh generated.")
return cls(name, mesh, data, dimX, dimY, dimZ)
def plotSlice(self, time, log=True, legend=True):
imData = self.data[:,:,time]
if log:
color = numpy.log10(imData)
else:
color = imData
ax = matplotlib.pyplot.gca()
im = matplotlib.pyplot.imshow(color, origin='lower')
if legend:
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad = 0.1)
matplotlib.pyplot.colorbar(im, cax = cax)
def likelihood(self, value):
""" The function likelihood(value) returns a two-dimensional numpy array object where each entry is the likelihood that the sample with value is from the probability mass function at the location. This is not normalized. """
likely = numpy.array([[self.mesh[i][j].likelihood(value) for j in range(self.dimX)] for i in range(self.dimY)])
return likely
if __name__ == "__main__":
import h5py
downstream = h5py.File("/home/sebo/Desktop/PlumeDataHDF/mouseDiscretization.hdf5", "r")
Data = downstream["Downstream/instSum"]
dimY = len(Data)
dimX = len(Data[0])
AvgDataY = numpy.sum(Data, axis=0)
AvgData = numpy.sum(AvgDataY, axis=0)/(dimY*dimX)
avgTS = Timeseries.flatProb("average", AvgData, 32)
test = Discretized.generateMesh('geht', Data, avgTS.edges)
l = test.likelihood(2500)
print(l.shape)
#test.plotSlice(500)
#matplotlib.pyplot.show()
'''
print(test.dim)
print('likelihoodTesting')
print(numpy.shape(test.mesh))
p = test.likelihood(test.dataset.data[10,20,50])
imData = p
color = p
ax = matplotlib.pyplot.gca()
im = matplotlib.pyplot.imshow(color, origin='lower')
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad = 0.1)
matplotlib.pyplot.colorbar(im, cax = cax)
matplotlib.pyplot.show()
'''
|
class Player_Token:
def __init__(self, owner, owner_symbol):
self.owner = owner
self.owner_symbol = owner_symbol
|
from threading import Thread
from time import sleep, ctime
loops = (4, 2)
def loop(nloop, nsec):
print("Start loop", nloop, "at:", ctime())
sleep(nsec)
print("Done loop", nloop, "at:", ctime())
if __name__ == '__main__':
print("Starting at:", ctime())
threads = [Thread(target=loop, args=(nloop, nsec)) for nloop, nsec in enumerate(loops)]
[thread.start() for thread in threads]
[thread.join() for thread in threads]
print("All Done at:", ctime())
|
MAIN_MENU = "Main menu"
ENTER_ENGLISH_WORD = "Please, enter your english word"
ENTER_RUSSIAN_WORD = "Please, enter russian translation"
ENTER_MORE_RUSSIAN_WORD = "You entered russian translation.\nEnter another translation or push buttons"
|
from django.template.response import TemplateResponse
from django.contrib.auth import login, authenticate
from django.contrib.auth.forms import UserCreationForm
from django.shortcuts import render, redirect
from myapp.models import *
from django.http import HttpResponseRedirect
from myapp.forms import *
from django.contrib.auth.decorators import login_required
from django.contrib.auth import authenticate, login, logout
from django.shortcuts import redirect
from django.core.mail import send_mail
def lek(request):
drugs_f = Drugs()
form = DrugsForm(request.POST or None, instance = drugs_f)
if form.is_valid():
drugs_f = form.save()
return redirect(main_drug)
ctx = {'form': form, 'DrugsForm': DrugsForm}
return TemplateResponse(request, 'drugs.html', ctx)
def doctor(request):
doctor_f = Doctor()
form = DocForm(request.POST or None, instance = doctor_f)
if form.is_valid():
doctor_f = form.save()
return redirect(main_doc)
ctx = {'form': form, 'DocForm': DocForm}
return TemplateResponse(request, 'doctor.html', ctx)
@login_required(login_url='http://127.0.0.1:8000/signup/')
def info(request):
baby_f = BabyInfo()
form = InfoForm(request.POST or None, instance = baby_f)
if form.is_valid():
baby_f = form.save(commit=False)
baby_f.user = request.user
baby_f.save()
return redirect(main_info)
ctx = {'form': form, 'InfoForm': InfoForm}
return TemplateResponse(request, 'info.html', ctx)
@login_required(login_url='http://127.0.0.1:8000/signup/')
def doc_cont(request):
contact_f = DoctorContatct()
form = ContactForm(request.POST or None, instance = contact_f)
if form.is_valid():
contact_f = form.save(commit = False)
contact_f.user = request.user
contact_f.save()
return redirect(main_contact)
ctx = {'form' : form, 'ContactForm' : ContactForm}
return TemplateResponse(request, 'contact.html',ctx)
def main_contact(request):
objectslist = DoctorContatct.objects.all()
number = len(objectslist) - 1
user = str(objectslist[number].user)
subject = 'Mail from: ' + user
message = str(objectslist[number].description)
sent_to = str(objectslist[number].doctor_choice) + '@example.com'
#send_mail(subject,message,(user + '@example.com'),[sent_to])
return render(request, 'mail_send.html')
def signup(request):
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=username, password=raw_password)
login(request, user)
return redirect(home)
else:
form = UserCreationForm()
return render(request, 'signup.html', {'form': form})
def home(request):
return TemplateResponse(request, 'mainp.html')
def main_info(request):
return render(request, 'formsave.html')
def main(request):
return render(request, 'base.html')
def main_drug(request):
objectslist = Drugs.objects.all()
number= len(objectslist) - 1
weight = float(objectslist[number].weight)
dose = (objectslist[number].other_drug)
warning ='Przed podaniem upewnij się czy lek jest odpowiedni dla dzieci w tym wieku'
drug_dose = int(dose)*int(weight)
return render(request, "calculate.html", {'drug_dose':drug_dose, 'warning':warning})
def main_doc(request):
objectslist = Doctor.objects.all()
number = len(objectslist) - 1
age = int(objectslist[number].age)
fever = float(objectslist[number].fever)
symptoms0 = objectslist[number].symptoms
symptoms1=[]
for i in range(2, len(symptoms0)):
if symptoms0[i] == "'":
break
else:
symptoms1.append(symptoms0[i])
symptoms = ''
for i in range(0,len(symptoms1)):
symptoms += symptoms1[i]
#age category
if age<6:
age_cat = 1
elif age <=12:
age_cat = 2
#36-37 no symptoms cat 1
if symptoms == 'none':
if fever<37 :
fev_cat = 1
#37-37,5 no symptoms cat 2
if fever >= 37 and fever <37.5:
fev_cat = 2
#37,5-38 no symptoms cat 3
if fever >= 37.5 and fever <38:
fev_cat = 3
#38-38,5 no symptoms cat 4
if fever >= 38 and fever <38.5:
fev_cat = 4
#38,5-39 no symptoms cat 5
if fever >= 38.5 and fever <39:
fev_cat = 5
#39-40 no symptoms cat6
if fever >=39:
fev_cat = 6
else:
if fever < 38:
fev_cat = 7
if fever >=38:
fev_cat = 8
base = Fever.objects.all()
for i in range(len(base)):
if fev_cat < 7:
if age_cat == base[i].kategoria_wiek and fev_cat == base[i].kategoria_goraczka:
recommend = base[i].zalecenia
break
else:
if age_cat == base[i].kategoria_wiek and fev_cat == base[i].kategoria_goraczka and symptoms == base[i].objawy:
recommend = base[i].zalecenia
break
return render(request, "doctor_recommendation.html", {'recommendation': recommend})
def profil(request):
babies = BabyInfo.objects.filter(user=request.user)
messages = DoctorContatct.objects.filter(user=request.user)
context = {"babies":babies,"messages":messages}
return render(request,"profile.html", context)
def auth_logout(request):
logout(request)
return redirect('home')
|
# -*- coding: utf-8 -*-
class Solution:
def countArrangement(self, N):
return [1, 2, 3, 8, 10, 36, 41, 132, 250, 700, 750, 4010, 4237, 10680, 24679][
N - 1
]
if __name__ == "__main__":
solution = Solution()
assert 2 == solution.countArrangement(2)
|
from ftplib import FTP
class Uploader:
def connect(self, hostname, username, password):
raise NotImplementedError()
def disconnect(self):
raise NotImplementedError()
def upload(self, data, uploaded_name, destination=None):
raise NotImplementedError()
class FtpUploader(Uploader):
def __init__(self):
self.connection = None
def connect(self, hostname, username, password):
self.connection = FTP(hostname, username, password)
def disconnect(self):
resp = None
try:
if self.connection is not None:
resp = self.connection.quit()
finally:
# if call to self.connection.quit() succeeds, calling close() below is not needed
if resp is not None and self.connection is not None:
self.connection.close()
def upload(self, data, uploaded_name, destination=None):
if self.connection is not None:
if destination is not None and self.connection.pwd() != destination:
self.connection.cwd(destination)
self.connection.storbinary('STOR ' + uploaded_name, data)
|
from xml.sax import make_parser
from xml.sax.handler import ContentHandler, feature_namespaces
from xml.dom.minidom import parse
import xml.dom.minidom
import xml.etree.cElementTree as cet
from html.parser import HTMLParser
class MovieHandler(ContentHandler):
def __init__(self):
super(MovieHandler, self).__init__()
self.CurrentTag = ""
self.CurrentTagValue = ''
# 元素开始调用
def startElement(self, name, attrs):
self.CurrentTag = name
if name == 'movie':
print("*****Movie*****")
title = attrs["title"]
print("Title:", title)
# 元素结束调用
def endElement(self, name):
if self.CurrentTag == "type":
print("Type:", self.CurrentTagValue)
elif self.CurrentTag == "format":
print("Format:", self.CurrentTagValue)
elif self.CurrentTag == "year":
print("Year:", self.CurrentTagValue)
elif self.CurrentTag == "rating":
print("Rating:", self.CurrentTagValue)
elif self.CurrentTag == "stars":
print("Stars:", self.CurrentTagValue)
elif self.CurrentTag == "description":
print("Description:", self.CurrentTagValue)
self.CurrentTag = ""
# 读取字符调用
def characters(self, content):
if content:
self.CurrentTagValue = content
class DOMAnalysisXML(object):
def analysis(self):
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
print("Root element : %s" % collection.getAttribute("shelf"))
# 在集合中获取所有电影
movies = collection.getElementsByTagName("movie")
# 打印每部电影的详细信息
for movie in movies:
print("*****Movie*****")
if movie.hasAttribute("title"):
print("Title: %s" % movie.getAttribute("title"))
type = movie.getElementsByTagName('type')[0]
print("Type: %s" % type.childNodes[0].data)
format = movie.getElementsByTagName('format')[0]
print("Format: %s" % format.childNodes[0].data)
rating = movie.getElementsByTagName('rating')[0]
print("Rating: %s" % rating.childNodes[0].data)
description = movie.getElementsByTagName('description')[0]
print("Description: %s" % description.childNodes[0].data)
if __name__ == '__main__':
# # 创建一个解析器
# parser = make_parser()
# # turn off namepsaces
# parser.setFeature(feature_namespaces, 0)
#
# # 重写 ContextHandler
# Handler = MovieHandler()
# parser.setContentHandler(Handler)
# parser.parse("movies.xml")
# DOMAnalysisXML().analysis()
tree = cet.parse("movies.xml")
root = tree.getroot()
for child in root:
print(child.tag)
|
import cv2
import numpy.ma as ma
import cv2.aruco as aruco
import numpy as np
import pickle
from numpy import linalg as LA
from numpy.linalg import inv
import math
import copy
import rospy
from sensor_msgs.msg import CameraInfo
from realsense2_camera.msg import Extrinsics
class projection:
def __init__(self, camId):
self.camId = camId
self.intrinsic = dict.fromkeys(['rgb'])
self.extrinsic = dict.fromkeys(['rgb'])
self.distCoeffs = None
self.extrinsic['rgb'] = dict.fromkeys(['rvec','tvec','projMatrix'])
def getIntrinsicFromROS(self, data):
if 'color' in data.header.frame_id:
self.intrinsic['rgb'] = np.array(data.K).reshape(3,3)
self.distCoeffs = np.zeros((1,5), dtype=np.float64)
def getIntrinsicParameters(self):
self.getIntrinsicFromROS(rospy.wait_for_message('/camera{}/color/camera_info'.format(self.camId), CameraInfo)) #wait_for_message read only once the topic
def calibrateWithBoard(self, imgs, sensor, draw=False):
# Constant parameters used in Aruco methods
ARUCO_PARAMETERS = aruco.DetectorParameters_create()
ARUCO_DICT = aruco.Dictionary_get(aruco.DICT_4X4_50)
# Create grid board object we're using in our stream
CHARUCO_BOARD = aruco.CharucoBoard_create(
squaresX=10,
squaresY=6,
squareLength=0.04, #in meters
markerLength=0.03, #in meters
dictionary=ARUCO_DICT)
# grayscale image
gray = cv2.cvtColor(imgs[sensor], cv2.COLOR_BGR2GRAY)
# Detect Aruco markers
corners, ids, rejectedImgPoints = aruco.detectMarkers(gray, ARUCO_DICT, parameters=ARUCO_PARAMETERS)
# Refine detected markers
# Eliminates markers not part of our board, adds missing markers to the board
corners, ids, rejectedImgPoints, recoveredIds = aruco.refineDetectedMarkers(image = gray,
board = CHARUCO_BOARD,
detectedCorners = corners,
detectedIds = ids,
rejectedCorners = rejectedImgPoints,
cameraMatrix = self.intrinsic[sensor],
distCoeffs = self.distCoeffs)
#print('Found {} corners in C{} sensor {}'.format(len(corners), self.camId, sensor))
imgs[sensor] = aruco.drawDetectedMarkers(imgs[sensor], corners, ids=ids, borderColor=(0, 0, 255))
# Only try to find CharucoBoard if we found markers
if ids is not None and len(ids) > 10:
# Get charuco corners and ids from detected aruco markers
response, charuco_corners, charuco_ids = aruco.interpolateCornersCharuco(markerCorners=corners,
markerIds=ids,
image=gray,
board=CHARUCO_BOARD)
# Require more than 20 squares
if response is not None and response > 20:
# Estimate the posture of the charuco board, which is a construction of 3D space based on the 2D video
pose, self.extrinsic[sensor]['rvec'], self.extrinsic[sensor]['tvec'] = aruco.estimatePoseCharucoBoard(charucoCorners=charuco_corners,
charucoIds=charuco_ids,
board=CHARUCO_BOARD,
cameraMatrix=self.intrinsic[sensor],
distCoeffs=self.distCoeffs)
if draw:
imgs[sensor] = aruco.drawAxis(imgs[sensor], self.intrinsic[sensor], self.distCoeffs, self.extrinsic[sensor]['rvec'], self.extrinsic[sensor]['tvec'], 2)
cv2.imwrite('./data/out/calib_C{}_{}.png'.format(self.camId,sensor), imgs[sensor])
else:
print('Calibration board is not fully visible for C{} sensor: {}'.format(self.camId, sensor))
assert 1==0
self.extrinsic[sensor]['rvec'] = cv2.Rodrigues(self.extrinsic[sensor]['rvec'])[0]
self.extrinsic[sensor]['projMatrix'] = np.matmul(self.intrinsic[sensor], np.concatenate((self.extrinsic[sensor]['rvec'],self.extrinsic[sensor]['tvec']), axis=1))
def cameraPose(self, _imgs):
rospy.loginfo('Calibrating camera {} ...'.format(self.camId))
imgs = copy.deepcopy(_imgs)
# Estimate extrinsic parameters (need a calibration board within the field of view of all cameras)
self.getIntrinsicParameters()
self.calibrateWithBoard(imgs, 'rgb', draw=True)
def getCentroid(c, mask):
# Get the largest contour
contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
contour_sizes = [(cv2.contourArea(contour), contour) for contour in contours]
largest_contour = max(contour_sizes, key=lambda x: x[0])[1]
# Get centroid of the largest contour
M = cv2.moments(largest_contour)
try:
centroid = np.array((M['m10']/M['m00'], M['m01']/M['m00']))
return centroid
except:
print('Centroid not found')
return None
def triangulate(c1, c2, point1, point2, undistort=True):
if (point1.dtype != 'float64'):
point1 = point1.astype(np.float64)
if (point2.dtype != 'float64'):
point2 = point2.astype(np.float64)
point3d = cv2.triangulatePoints(c1.extrinsic['rgb']['projMatrix'], c2.extrinsic['rgb']['projMatrix'], point1.reshape(2,1), point2.reshape(2,1)).transpose()
for point in point3d:
point /= point[-1]
return point3d.reshape(-1)
def get3D(c1, c2, mask1, mask2, glass, _img1=None, _img2=None, drawCentroid=False, drawDimensions=False):
img1 = copy.deepcopy(_img1)
img2 = copy.deepcopy(_img2)
centr1 = getCentroid(c1, mask1)
centr2 = getCentroid(c2, mask2)
if centr1 is not None and centr2 is not None:
glass.centroid = triangulate(c1, c2, centr1, centr2)[:-1].reshape(-1,3)
# Draw centroid
if drawCentroid:
# Draw 2D centroid of tracking mask
#cv2.circle(img1, tuple(centr1.astype(int)), 10, (0,128,0), -1)
#cv2.circle(img2, tuple(centr2.astype(int)), 10, (0,128,0), -1)
# Draw 3D centroid projected to image
point1, _ = cv2.projectPoints(glass.centroid, c1.extrinsic['rgb']['rvec'], c1.extrinsic['rgb']['tvec'], c1.intrinsic['rgb'], c1.distCoeffs)
point2, _ = cv2.projectPoints(glass.centroid, c2.extrinsic['rgb']['rvec'], c2.extrinsic['rgb']['tvec'], c2.intrinsic['rgb'], c2.distCoeffs)
point1 = point1.squeeze().astype(int)
point2 = point2.squeeze().astype(int)
cv2.circle(img1, tuple(point1), 6, (128,0,0), -1)
cv2.circle(img2, tuple(point2), 6, (128,0,0), -1)
# Draw height and width lines
if drawDimensions:
# Get top/bottom points
top = copy.deepcopy(glass.centroid)
bottom = copy.deepcopy(glass.centroid)
top[0,2] += glass.h/2
bottom[0,2] -= glass.h/2
topC1, _ = cv2.projectPoints(top, c1.extrinsic['rgb']['rvec'], c1.extrinsic['rgb']['tvec'], c1.intrinsic['rgb'], c1.distCoeffs)
bottomC1, _ = cv2.projectPoints(bottom, c1.extrinsic['rgb']['rvec'], c1.extrinsic['rgb']['tvec'], c1.intrinsic['rgb'], c1.distCoeffs)
topC2, _ = cv2.projectPoints(top, c2.extrinsic['rgb']['rvec'], c1.extrinsic['rgb']['tvec'], c2.intrinsic['rgb'], c2.distCoeffs)
bottomC2, _ = cv2.projectPoints(bottom, c2.extrinsic['rgb']['rvec'], c2.extrinsic['rgb']['tvec'], c2.intrinsic['rgb'], c2.distCoeffs)
topC1 = topC1.squeeze().astype(int)
bottomC1 = bottomC1.squeeze().astype(int)
topC2 = topC2.squeeze().astype(int)
bottomC2 = bottomC2.squeeze().astype(int)
# Get rigth/left points
right = copy.deepcopy(glass.centroid)
left = copy.deepcopy(glass.centroid)
right[0,0] += glass.w/2
left[0,0] -= glass.w/2
rightC1, _ = cv2.projectPoints(right, c1.extrinsic['rgb']['rvec'], c1.extrinsic['rgb']['tvec'], c1.intrinsic['rgb'], c1.distCoeffs)
leftC1, _ = cv2.projectPoints(left, c1.extrinsic['rgb']['rvec'], c1.extrinsic['rgb']['tvec'], c1.intrinsic['rgb'], c1.distCoeffs)
rightC2, _ = cv2.projectPoints(right, c2.extrinsic['rgb']['rvec'], c2.extrinsic['rgb']['tvec'], c2.intrinsic['rgb'], c2.distCoeffs)
leftC2, _ = cv2.projectPoints(left, c2.extrinsic['rgb']['rvec'], c2.extrinsic['rgb']['tvec'], c2.intrinsic['rgb'], c2.distCoeffs)
rightC1 = rightC1.squeeze().astype(int)
leftC1 = leftC1.squeeze().astype(int)
rightC2 = rightC2.squeeze().astype(int)
leftC2 = leftC2.squeeze().astype(int)
cv2.line(img1, tuple(topC1), tuple(bottomC1), (128,0,0), 2)
cv2.line(img1, tuple(rightC1), tuple(leftC1), (128,0,0), 2)
cv2.line(img2, tuple(topC2), tuple(bottomC2), (128,0,0), 2)
cv2.line(img2, tuple(rightC2), tuple(leftC2), (128,0,0), 2)
return glass, img1, img2
def getObjectDimensions(cam, _seg, _img, centroid, offset, atHeight, draw=False):
# Sample 3D circunferences in world coordinate system at z = centroid
step = 0.001 #1mm
minDiameter = 0.01 #1cm
maxDiameter = 0.15 #20cm
radiuses = np.linspace(maxDiameter/2, minDiameter/2, num=int((maxDiameter-minDiameter)/step))
angularStep = 18#degrees
angles = np.linspace(0., 359., num=int((359.)/angularStep))
h = centroid[2]*2.
for radius in radiuses:
seg2plot = copy.deepcopy(_seg).squeeze()
seg = copy.deepcopy(_seg).squeeze()
img = copy.deepcopy(_img)
p_3d = []
for angle_d in angles:
angle = math.radians(angle_d)
p_3d.append(np.array((centroid[0]+(radius*math.cos(angle)), centroid[1]+(radius*math.sin(angle)), atHeight)).reshape(1,3))
# Reproject to image
p_2d, _ = cv2.projectPoints(np.array(p_3d), cam.extrinsic['rgb']['rvec'], cam.extrinsic['rgb']['tvec'], cam.intrinsic['rgb'], cam.distCoeffs)
p_2d = p_2d.squeeze().astype(int)
# Displace to segmentation
p_2d[:,0] -= offset
if draw:
for p in p_2d:
cv2.circle(img, (int(p[0]), int(p[1])), 2, (0,0,255), -1)
if draw:
for p in p_2d:
cv2.circle(seg2plot, (int(p[0]), int(p[1])), 2, (0,0,255), -1)
areIn = seg[p_2d[:,1], p_2d[:,0]]
# Check if imaged points are in the segmentation
if np.count_nonzero(areIn) == areIn.shape[0]:
return radius*2, h
if draw:
cv2.imwrite('./data/out/measuring_C{}_rad{:.5f}.png'.format(cam.camId, radius), img)
|
# 15-112, Summer 1, Homework 1.4
######################################
# Full name: joyce moon
# Andrew ID: seojinm
# Section: B
######################################
######### IMPORTANT NOTE #############
# You are not allowed to use lists, or recursion.
# And you are not allowed to use any string methods or import the string module.
import math
# See here for details:
# https://www.cs.cmu.edu/~112/notes/quiz2-practice.html#cosineError
def cosineError(x, k):
result=0
for i in range (k+1):
result+=((-1)**i)*(x**(2*i))/math.factorial(2*i)
return abs(math.cos(x)-result)
# See here for details:
# https://www.cs.cmu.edu/~112/notes/hw2-practice.html#isRotation
def isRotation(x, y):
if x==0 and y==0: return True
elif x==0 or y==0: return False
lengthx = 1 if x==1 else math.ceil(math.log10(x))
lengthy = 1 if y==1 else math.ceil(math.log10(y))
newy=y
for i in range (lengthy):
lengthnewy=1 if newy==1 else math.ceil(math.log10(newy))
if lengthy!=lengthnewy:
newy=(newy%10)*10**(lengthy-1)+newy//10
else:
newy=(newy%10)*10**(lengthy-1)+newy//10
if x==newy:
return True
return False
# See here for details:
# https://www.cs.cmu.edu/~112/notes/hw2-practice.html#longestDigitRun
def longestDigitRun(n):
times=0
previousdigit=n%10
current=0
result=-1
if n==0:
return 0
m=1 if n==1 else math.ceil(math.log10(n))
for i in range(m):
if n%10==previousdigit:
current+=1
else: current=1
if current>times:
times=current
result=n%10
if current==times:
result=min(n%10,result)
previousdigit=n%10
n//=10
return result
# Return True if all characters in the string s are digits
# and there is at least one character. Return False otherwise.
def isDigit(s):
if len(s)==0:
return False
for c in s:
if not (ord("0")<=ord(c)<=ord("9")):
return False
return True
# Return True if all cased characters in the string s are lowercase
# and there is at least one cased character. Return False otherwise.
def isLower(s):
n=0
if len(s)==0:
return False
for c in s:
if (ord("a")<=ord(c)<=ord("z")):
n+=1
elif (ord("A")<=ord(c)<=ord("Z")):
return False
if n>0:
return True
return False
# Return True if all alphabetic characters in the string s are uppercase
# and there is at least one alphabetic character. Otherwise return False.
def isUpper(s):
n=0
if len(s)==0:
return False
for c in s:
if (ord("A")<=ord(c)<=ord("Z")):
n+=1
elif (ord("a")<=ord(c)<=ord("z")):
return False
if n>0:
return True
return False
# Return True if all characters in the string s are alphabetic
# and there is at least one character. Return False otherwise.
def isAlpha(s):
if len(s)==0:
return False
for c in s:
if not (ord("A")<=ord(c)<=ord("Z") or ord("a")<=ord(c)<=ord("z")):
return False
return True
# Return True if all characters in the string s are alphanumeric
# (i.e. alphabetical character or a digit)
# and there is at least one character. Return False otherwise.
def isAlNum(s):
if len(s)==0:
return False
for c in s:
if not (ord("A")<=ord(c)<=ord("Z") or ord("a")<=ord(c)<=ord("z") or ord("0")<=ord(c)<=ord("9")):
return False
return True
# Input s is assumed to be a string.
# Return a copy of s with all the lowercase letters converted to uppercase.
def toUpper(s):
news=""
for c in s:
if ord("a")<=ord(c)<=ord("z"):
news+=chr(ord(c)-ord("a")+ord("A"))
else: news+=c
return news
# Input s is assumed to be a string.
# Return a copy of s with all the uppercase letters converted to lowercase.
def toLower(s):
news=""
for c in s:
if ord("A")<=ord(c)<=ord("Z"):
news+=chr(ord(c)+ord("a")-ord("A"))
else: news+=c
return news
# Input is assumed to be a pair of strings s and t.
# Return True if string s starts with the string t. Return False otherwise.
# If index is given, the start of s is considered to be the given index.
def startsWith(s, t, index=0):
n=0
if len(s)<len(t):return False
for i in range (index,len(t)+index):
if not s[i] == t[n]:
return False
n+=1
return True
# Input is assumed to be a pair of strings s and t.
# Return True if string s ends with the string t. Return False otherwise.
def endsWith(s, t):
n=len(t)-1
if len(s)<len(t):return False
for i in range (1,len(t)+1):
if not s[len(s)-i] == t[n]:
return False
n-=1
return True
# Input is assumed to be a pair of strings s and t.
# Return the number of (non-overlapping) occurrences of string t in string s.
def count(s, t):
result=0
if len(t)==0: return len(s)+1
while len(s)>0:
if s[0:len(t)]==t:
result+=1
s=s[len(t):]
else: s=s[1:]
return result
# Input is assumed to be a pair of strings s and t.
# Return the lowest index in s where the substring t is found.
# If t is not found, return -1.
# If index is given, the start of s is considered to be the given index.
# Hint: use startsWith
def find(s, t, index=0):
s=s[index:]
if len(t)==0: return 0
for i in range (len(s)):
if startsWith(s,t):
return i+index
s=s[1:]
return -1
# The input is assumed to be a string s.
# Return the string s reversed.
# You are not allowed to use string slicing for this function.
# In particular, you can't do s[::-1]
def reverseString(s):
news=""
for i in range (1,len(s)+1):
news+=s[len(s)-i]
return news
# Removes leading and trailing spaces.
# For now we are only considering " " as a space.
# In particular don't worry about "\n" or "\t".
def strip(s):
if s=="":
return s
while startsWith(s," ") or endsWith(s," "):
if startsWith(s," "):
s=s[1:]
if endsWith(s," "):
s=s[:-1]
return s
# Return True if string t is a substring of string s, and False otherwise.
# There is actually a built-in operator called "in" that does this
# i.e., (t in s) returns the correct answer.
# But you are not allowed to use the in operator with strings.
def isSubstring(t, s):
while len(t)<=len(s):
if s[0:len(t)]==t:
return True
s=s[1:]
return False
# Replace in string s all occurrences of string t1 with string t2.
def replace(s, t1, t2):
news=""
if len(t1)==0:
for c in s:
news=news+t2+c
news+=t2
return news
elif not isSubstring(t1,s):
return s
while len(s)>0:
if s[:len(t1)]==t1:
news+=t2
s=s[len(t1):]
else:
news+=s[0]
s=s[1:]
return news
# Remove all occurrences of string t from string s.
# Hint: This should be very short.
def remove(s, t):
return replace(s,t,"")
# Remove all spaces from string s.
# Hint: This should be very short.
def removeSpaces(s):
return replace(s," ","")
######################################################################
# ignore_rest: The autograder will ignore all code below here
######################################################################
# Make sure every function is tested thoroughly before you submit to Autolab.
def almostEqual(d1, d2):
epsilon = 10**-8
return abs(d1 - d2) < epsilon
def testCosineError():
print("Testing cosineError()...", end="")
assert(almostEqual(cosineError(0, 0), abs(math.cos(0) - 1)))
assert(almostEqual(cosineError(1, 0), abs(math.cos(1) - 1)))
x = 1.2
guess = 1 - x**2/2 + x**4/(4*3*2)
error = abs(math.cos(x) - guess)
assert(almostEqual(cosineError(x, 2), error))
x = 0.75
guess = 1 - x**2/2 + x**4/(4*3*2) - x**6/(6*5*4*3*2)
error = abs(math.cos(x) - guess)
assert(almostEqual(cosineError(x, 3), error))
print("Passed!")
def testIsRotation():
print("Testing isRotation... ", end="")
assert(isRotation(0, 0))
assert(not isRotation(0, 1))
assert(isRotation(3012, 1230))
assert(isRotation(3412, 1234))
assert(isRotation(321, 3210))
assert(isRotation(3021, 3021))
print("Passed!")
def testLongestDigitRun():
print("Testing longestDigitRun... ", end="")
assert(longestDigitRun(0) == 0)
assert(longestDigitRun(10) == 0)
assert(longestDigitRun(110) == 1)
assert(longestDigitRun(110011) == 0)
assert(longestDigitRun(123444444) == 4)
assert(longestDigitRun(1233442211) == 1)
assert(longestDigitRun(1233441122) == 1)
assert(longestDigitRun(65432221115555) == 5)
assert(longestDigitRun(7866633388888) == 8)
assert(longestDigitRun(123434) == 1)
assert(longestDigitRun(122223333) == 2)
print("Passed!")
def testIsDigit():
print("Testing isDigit... ", end="")
assert(not isDigit(""))
assert(not isDigit(" "))
assert(not isDigit("ABCD"))
assert(not isDigit("abcd"))
assert(isDigit("1234"))
assert(not isDigit("!*&$"))
assert(not isDigit("AB12"))
assert(not isDigit("ab12"))
assert(not isDigit("!*12"))
assert(not isDigit("!*ab"))
assert(not isDigit("!*AB"))
print("Passed!")
def testIsLower():
print("Testing isLower... ", end="")
assert(not isLower(""))
assert(not isLower(" "))
assert(not isLower("ABCD"))
assert(isLower("abcd"))
assert(not isLower("1234"))
assert(not isLower("!*&$"))
assert(not isLower("AB12"))
assert(isLower("ab12"))
assert(not isLower("!*12"))
assert(isLower("!*ab"))
assert(not isLower("!*AA"))
print("Passed!")
def testIsUpper():
print("Testing isUpper... ", end="")
assert(not isUpper(""))
assert(not isUpper(" "))
assert(isUpper("ABCD"))
assert(not isUpper("abcd"))
assert(not isUpper("1234"))
assert(not isUpper("!*&$"))
assert(isUpper("AB12"))
assert(not isUpper("ab12"))
assert(not isUpper("!*12"))
assert(not isUpper("!*ab"))
assert(isUpper("!*AB"))
print("Passed!")
def testIsAlpha():
print("Testing isAlpha... ", end="")
assert(not isAlpha(""))
assert(not isAlpha(" "))
assert(isAlpha("ABCD"))
assert(isAlpha("abcd"))
assert(not isAlpha("1234"))
assert(not isAlpha("!*&$"))
assert(not isAlpha("AB12"))
assert(not isAlpha("ab12"))
assert(not isAlpha("!*12"))
assert(not isAlpha("!*ab"))
assert(not isAlpha("!*AB"))
print("Passed!")
def testIsAlNum():
print("Testing isAlNum... ", end="")
assert(not isAlNum(""))
assert(not isAlNum(" "))
assert(isAlNum("ABCD"))
assert(isAlNum("abcd"))
assert(isAlNum("1234"))
assert(not isAlNum("!*&$"))
assert(isAlNum("AB12"))
assert(isAlNum("ab12"))
assert(not isAlNum("!*12"))
assert(not isAlNum("!*ab"))
assert(not isAlNum("!*AB"))
print("Passed!")
def testToUpper():
print("Testing toUpper... ", end="")
assert(toUpper("") == "")
assert(toUpper(" ") == " ")
assert(toUpper("ABCD") == "ABCD")
assert(toUpper("abcd") == "ABCD")
assert(toUpper("1234") == "1234")
assert(toUpper("!*&$") == "!*&$")
assert(toUpper("AB12") == "AB12")
assert(toUpper("ab12") == "AB12")
assert(toUpper("!*12") == "!*12")
assert(toUpper("!*ab") == "!*AB")
assert(toUpper("!*AB") == "!*AB")
print("Passed!")
def testToLower():
print("Testing toLower... ", end="")
assert(toLower("") == "")
assert(toLower(" ") == " ")
assert(toLower("ABCD") == "abcd")
assert(toLower("abcd") == "abcd")
assert(toLower("1234") == "1234")
assert(toLower("!*&$") == "!*&$")
assert(toLower("AB12") == "ab12")
assert(toLower("ab12") == "ab12")
assert(toLower("!*12") == "!*12")
assert(toLower("!*ab") == "!*ab")
assert(toLower("!*AB") == "!*ab")
print("Passed!")
def testStartsWith():
print("Testing startsWith... ", end="")
assert(startsWith("", ""))
assert(startsWith("a", ""))
assert(startsWith("a", "a"))
assert(not startsWith("a", "b"))
assert(startsWith("aa", "a"))
assert(startsWith("ab", "a"))
assert(not startsWith("ba", "a"))
assert(startsWith("abba", "abba"))
assert(startsWith("abba", "abb"))
print("Passed!")
def testEndsWith():
print("Testing endsWith... ", end="")
assert(endsWith("", ""))
assert(endsWith("a", ""))
assert(endsWith("a", "a"))
assert(not endsWith("a", "b"))
assert(endsWith("aa", "a"))
assert(not endsWith("ab", "a"))
assert(endsWith("ba", "a"))
assert(endsWith("abba", "abba"))
assert(endsWith("abba", "bba"))
print("Passed!")
def testReverseString():
print("Testing reverse... ", end="")
assert(reverseString("") == "")
assert(reverseString("a") == "a")
assert(reverseString("aa") == "aa")
assert(reverseString("ab") == "ba")
assert(reverseString("aba") == "aba")
assert(reverseString("abcd") == "dcba")
print("Passed!")
def testCount():
print("Testing count... ", end="")
assert(count("", "") == 1)
assert(count("", "a") == 0)
assert(count("abc", "") == 4)
assert(count("a", "a") == 1)
assert(count("a", "b") == 0)
assert(count("aa", "a") == 2)
assert(count("abbba", "bb") == 1)
assert(count("abbbba", "bb") == 2)
assert(count("This is a history test", "is") == 3)
print("Passed!")
def testFind():
print("Testing find... ", end="")
assert(find("", "") == 0)
assert(find("", "a") == -1)
assert(find("abc", "") == 0)
assert(find("a", "a") == 0)
assert(find("a", "b") == -1)
assert(find("aa", "a") == 0)
assert(find("abbba", "bb") == 1)
assert(find("aabbba", "bb") == 2)
assert(find("This is a history test", "is") == 2)
assert(find("Dogs and cats!", "and") == 5)
assert(find("Dogs and cats!", "or") == -1)
print("Passed!")
def testStrip():
print("Testing strip... ", end="")
assert(strip("") == "")
assert(strip("a") == "a")
assert(strip(" a") == "a")
assert(strip(" a") == "a")
assert(strip("a ") == "a")
assert(strip("a ") == "a")
assert(strip(" a ") == "a")
assert(strip(" a aa a a ") == "a aa a a")
print("Passed!")
def testIsSubstring():
print("Testing isSubstring... ", end="")
assert(isSubstring("", ""))
assert(isSubstring("", "a"))
assert(isSubstring("a", "a"))
assert(not isSubstring("a", "b"))
assert(not isSubstring("aa", "a"))
assert(isSubstring("abc", "abcd"))
assert(isSubstring("abc", "xabcx"))
assert(isSubstring("abc", "xyzabc"))
assert(not isSubstring("abc", "axbxc"))
print("Passed!")
def testReplace():
print("Testing replace... ", end="")
assert(replace("", "", "") == "")
assert(replace("a", "", "b") == "bab")
assert(replace("aaa", "", "b") == "bababab")
assert(replace("a", "a", " ") == " ")
assert(replace("hello hi hello", "hello", "hi") == "hi hi hi")
assert(replace("hello hi hello", "hi", "hello") == "hello hello hello")
print("Passed!")
def testRemove():
print("Testing remove... ", end="")
assert(remove("", "") == "")
assert(remove("a", "") == "a")
assert(remove("a", "a") == "")
assert(remove("aa", "a") == "")
assert(remove("ab", "a") == "b")
assert(remove("ab", "b") == "a")
assert(remove("abba", "b") == "aa")
assert(remove("abba", "bb") == "aa")
assert(remove("abcdabcdabcd", "bc") == "adadad")
assert(remove("abc", "d") == "abc")
assert(remove("", "d") == "")
print("Passed!")
def testRemoveSpaces():
print("Testing removeSpaces... ", end="")
assert(removeSpaces("") == "")
assert(removeSpaces(" ") == "")
assert(removeSpaces(" ") == "")
assert(removeSpaces(" a") == "a")
assert(removeSpaces("a ") == "a")
assert(removeSpaces(" a") == "a")
assert(removeSpaces("a ") == "a")
assert(removeSpaces(" a ") == "a")
assert(removeSpaces(" a ") == "a")
assert(removeSpaces(" a b c ") == "abc")
print("Passed!")
def testAll():
testLongestDigitRun()
testIsRotation()
testCosineError()
testIsDigit()
testIsLower()
testIsUpper()
testIsAlpha()
testIsAlNum()
testToUpper()
testToLower()
testStartsWith()
testEndsWith()
testReverseString()
testCount()
testFind()
testStrip()
testIsSubstring()
testReplace()
testRemove()
testRemoveSpaces()
testAll()
|
#! /usr/bin/python
# Author: Ruoteng Li
# Date: 6th Aug 2016
import numpy as np
import png
import matplotlib.pyplot as plt
import matplotlib.colors as cl
import flowlib as fl
def flow_read(flow_file):
"""
Read kitti flow from .png file
:param flow_file:
:return:
"""
flow_object = png.Reader(filename=flow_file)
flow_direct = flow_object.asDirect()
flow_data = list(flow_direct[2])
(w, h) = flow_direct[3]['size']
flow = np.zeros((h, w, 3), dtype=np.float64)
for i in range(len(flow_data)):
flow[i, :, 0] = flow_data[i][0::3]
flow[i, :, 1] = flow_data[i][1::3]
flow[i, :, 2] = flow_data[i][2::3]
invalid_idx = (flow[:, :, 2] == 0)
flow[:, :, 0:2] = (flow[:, :, 0:2] - 2 ** 15) / 64.0
flow[invalid_idx, 0] = 0
flow[invalid_idx, 1] = 0
return flow
def flow_visualize(flow, save_filename=None, mode='Y'):
if mode == 'Y':
# Ccbcr color wheel
img = fl.flow_to_image(flow)
plt.imshow(img)
plt.show()
elif mode == 'RGB':
(h, w) = flow.shape[0:2]
du = flow[:, :, 0]
dv = flow[:, :, 1]
valid = flow[:, :, 2]
max_flow = max(np.max(du), np.max(dv))
img = np.zeros((h, w, 3), dtype=np.float64)
# angle layer
img[:, :, 0] = np.arctan2(dv, du) / (2 * np.pi)
# magnitude layer, normalized to 1
img[:, :, 1] = np.sqrt(du * du + dv * dv) * 8 / max_flow
# phase layer
img[:, :, 2] = 8 - img[:, :, 1]
# clip to [0,1]
small_idx = img[:, :, 0:3] < 0
large_idx = img[:, :, 0:3] > 1
img[small_idx] = 0
img[large_idx] = 1
# convert to rgb
img = cl.hsv_to_rgb(img)
# remove invalid point
img[:, :, 0] = img[:, :, 0] * valid
img[:, :, 1] = img[:, :, 1] * valid
img[:, :, 2] = img[:, :, 2] * valid
# show
plt.imshow(img)
if save_filename is not None:
plt.savefig(save_filename, bbox_inches='tight')
else:
plt.show()
return
|
# COMP90024 Assignment 2
# Team: 48
# City: Melbourne
# Members: Wenqi Sun(928630), Yunlu Wen(869338), Fei Zhou(972547)
# Pei-Yun Sun(667816), Yiming Zhang(889262)
import json
import argparse
from db import TweetStore
import requests
# json files
JSON_PATH = "json_files/"
FILE_DICT = {
"db_auth": "db_auth.json",
}
def get_args():
""" Obtaining args from terminal """
parser = argparse.ArgumentParser(description="Add senpy to all docs in the db")
parser.add_argument("-db", "--db_name", type = str, required = True,
help = "Name of Database for storing")
parser.add_argument("-na", "--num_process", type = int, required = True,
help = "Number of processes adding senpy to this db")
parser.add_argument("-id", "--id", type = int, required = True,
help = "Current process id / number, should start from 0")
args = parser.parse_args()
return args
def read_jsons():
""" Read required json data files """
with open(JSON_PATH + FILE_DICT["db_auth"], "r") as f:
db_auth = json.load(f)
return db_auth
def main():
# get arguments
args = get_args()
db_auth = read_jsons()
# db url
url = "http://" + db_auth["user"] + ":" + db_auth["pwd"] \
+ "@" + db_auth["ip"] + ":" + db_auth["port"] + "/"
# initialise DB
storage = TweetStore(args.db_name, url)
db = storage.get_db()
try:
for doc_id in db:
# more than one process working
if (args.num_process > 1):
if (int(doc_id) % args.num_process) != args.id:
# not the job of this process
continue
doc = db[doc_id]
if "senpy" not in doc.keys() or doc["senpy"] == None:
res = requests.get('http://senpy.gsi.upm.es/api/emotion-depechemood',
params={"input": doc["text"]})
doc["senpy"] = json.loads(res.text)
db[doc_id] = doc
print("UPDATE DOC ", doc["_id"])
except:
# done
pass
if __name__ == "__main__":
main()
|
import unittest
from game_object import compare_points, wall_width
class TestComparePoints(unittest.TestCase):
def setUp(self):
self.f_wall = [[200, 200]]
self.res = None
# walls
def test_walls_negative(self):
# max point x
s_wall = [304, 200]
self.res = compare_points(self.f_wall, s_wall, wall_width, 0, 5, True)
self.assertEqual(self.res, 0)
def test_walls_positive(self):
s_wall = [400, 200]
self.res = compare_points(self.f_wall, s_wall, wall_width, 0, 5, True)
self.assertEqual(self.res, 1)
# food
def test_food_negative(self):
food_points = [230, 220]
self.res = compare_points(self.f_wall, food_points, 10, 20, 20)
self.assertTrue(self.res == 0)
def test_food_positive(self):
food_points = [400, 200]
self.res = compare_points(self.f_wall, food_points, 10, 20, 20)
self.assertTrue(self.res == 1)
def tearDown(self):
print('Result in test :', self.res)
if __name__ == '__main__':
unittest.main()
|
#!/usr/bin/env python
# coding: utf-8
# ## Numpy 배열의 변경
# - append, insert, delete
# - concatenate, vstack, hstack
# - hsplit, vsplit
# In[19]:
import numpy as np
# In[2]:
a = np.arange(1, 10).reshape(3, 3)
b = np.arange(10, 19).reshape(3, 3)
# In[3]:
print(a)
# In[4]:
print(b)
# ## append()
# - 2개의 배열을 합친 후 1차원으로 차원 축소
# - append()는 원본을 건드리지 않는다
# In[8]:
result = np.append(a, b)
print(result)
# In[9]:
print(a)
# In[11]:
# axis를 기준으로 append
# m x n : m => axis = 1 , n => axis = 0
# In[12]:
print(a)
# In[13]:
print(b)
# In[16]:
result1 = np.append(a, b, axis = 0) #세로(종) 기준으로 합침
print(result1)
# In[17]:
result2 = np.append(a, b, axis = 1) #가로(횡) 기준으로 합침
print(result2)
# ## insert()
# - 차원을 축소함
# In[18]:
a = np.arange(1, 10).reshape(3, 3)
print(a)
# In[25]:
print(np.insert(a, 1, 99)) #a의 인덱스 1번 위치에 99를 삽입하라
# In[23]:
print(np.insert(a, 1, 99, axis = 0)) #열의 1번째 위치에 99를 집어 넣음, 원본을 건드리지 않음
# In[27]:
print(np.insert(a, 1, 99, axis = 1)) #행의 1번째 위치를 기준으로 99를 집어 넣음
# ## delete()
# In[28]:
a = np.arange(1, 10).reshape(3, 3)
print(a)
# In[30]:
print(np.delete(a, 1)) #1번째 인덱스를 삭제함
# In[31]:
print(a)
# In[33]:
print(np.delete(a, 1, axis = 0)) #각각의 열에서 1번째 열의 값을 삭제하게 됨
# In[34]:
print(np.delete(a, 1, axis = 1)) #각각의 행에서 1번째 행의 값을 삭제하게 됨
# ## 배열의 결합
# - concatenate(), vstack(), hstack()
#
# ## concatenate()
# In[43]:
import numpy as np
# In[44]:
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# In[46]:
print(np.concatenate([a, b]))
# In[48]:
matrix = np.array([[1,2, 3], [4, 5, 6]]) #2행 3열
print(matrix)
# In[51]:
print(matrix.shape) #형태를 알려 줌
# In[53]:
print(np.concatenate([matrix, matrix], axis = 0))
# In[54]:
print(np.concatenate([matrix, matrix], axis = 1))
# In[56]:
print(matrix)
# In[72]:
a = np.array([10, 11, 12])
print(a)
b = np.array([[33], [33]])
print(b)
# In[59]:
print(np.vstack([a, matrix]))
# In[73]:
print(np.hstack([matrix, b]))
# In[74]:
print(np.hstack([b, matrix]))
# ## 배열 분리
# - 공유 폴더 : https://bit.ly/319Nllo
# - kilah@softsociety.net
# - kilah@naver.com
# In[77]:
import numpy as np
# In[78]:
data = np.arange(1, 25).reshape(4, 6)
print(data)
# In[80]:
a, b = np.hsplit(data, 2)
print(a)
print()
print(b)
# In[82]:
a, b, c = np.hsplit(data, 3)
print(a)
print()
print(b)
print()
print(c)
# In[86]:
a, b, c, d = np.hsplit(data, [1, 3, 5]) # a => [:, :1], b => [:, 1:3], c => [:, 3:5], d => [:, 5:6]
print(data)
print()
print(a)
print()
print(b)
print()
print(c)
print()
print(d)
# In[89]:
# vsplit()의 사용
data = np.arange(1, 25).reshape(4, 6)
print(data)
# In[94]:
r1, r2, r3, r4 = np.vsplit(data, 4)
print(r1)
print()
print(r2)
print()
print(r3)
print()
print(r4)
# In[ ]:
|
# -*- coding:utf-8 -*-
from flask import Blueprint, render_template, session
from flask_login import current_user
from app.forum.models import Topic
from app.message.models import Message
from app.game.models import Game_News
from app.util.helper import get_online_user_nums, highest_online_number
index = Blueprint("index", __name__)
@index.route('/', methods=['GET'])
def main():
hot_news = Game_News.get_hot()
news_index = Game_News.get_index()
news = Game_News.get(1).items
for n in news:
p = n.pic.split('.')
p[-2] += 'm'
n.pic = '.'.join(p)
if current_user.is_authenticated:
session['my_topic_num'] = Topic.get_user_topic_num(username=current_user.username)
session['msg_num'] = Message.get_user_unread_num(current_user.id)
session['following_nums'] = current_user.following_num
session['online_nums'] = get_online_user_nums()
session["highest_online_num"] = highest_online_number()
return render_template("index.html", hot_news=hot_news, news_index=news_index, news=news)
|
api = input ("Please type your API key:")
mac = input ("Please share your macaddress:")
import requests
r = requests.get('https://api.macaddress.io/v1?apiKey='+str(api)+'&output=vendor&search='+str(mac)+'')
print (r.text)
|
# Generated by Django 3.2.5 on 2021-07-26 20:49
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('clinic_app', '0003_visit'),
]
operations = [
migrations.AddField(
model_name='patient',
name='phone',
field=models.IntegerField(blank=True, max_length=10, null=True),
),
migrations.AlterField(
model_name='patient',
name='birth_certificate_no',
field=models.IntegerField(blank=True, null=True),
),
migrations.AlterField(
model_name='patient',
name='id_number',
field=models.IntegerField(blank=True, null=True),
),
]
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import datetime
import SecureWitness.models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
]
operations = [
migrations.CreateModel(
name='Bulletin',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('name', models.CharField(max_length=100)),
('date', models.DateField(default=datetime.date.today)),
('location', models.CharField(default=b'', max_length=100)),
('description', models.TextField(default=b'')),
('public', models.BooleanField(default=False)),
('author', models.CharField(max_length=100)),
],
options={
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Document',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('file', models.FileField(upload_to=SecureWitness.models.place_document)),
('user', models.CharField(max_length=100)),
('bulletin', models.ForeignKey(to='SecureWitness.Bulletin', on_delete=django.db.models.deletion.DO_NOTHING)),
],
options={
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Folder',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('name', models.CharField(max_length=100)),
('user', models.CharField(max_length=100)),
],
options={
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Sharing',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('author', models.CharField(max_length=100)),
('reader', models.CharField(max_length=100)),
('bulletin', models.ForeignKey(to='SecureWitness.Bulletin', on_delete=django.db.models.deletion.DO_NOTHING)),
],
options={
},
bases=(models.Model,),
),
migrations.AddField(
model_name='bulletin',
name='folder',
field=models.ForeignKey(on_delete=django.db.models.deletion.DO_NOTHING, default=0, to='SecureWitness.Folder'),
preserve_default=True,
),
]
|
# -*- coding: utf-8 -*-
import inject, uuid
from model.config import Config
from model.users.users import Users
from model.systems.assistance.devices import Devices
from model.systems.assistance.templates import Templates
from model.systems.assistance.logs import Logs
class Firmware:
config = inject.attr(Config)
devices = inject.attr(Devices)
users = inject.attr(Users)
logs = inject.attr(Logs)
templates = inject.attr(Templates)
def __init__(self):
self.passwords = []
self._loadPasswordsFromConfig()
def _loadPasswordsFromConfig(self):
i = 1
self.passwords = []
while True:
p = 'firmware_password{}'.format(i)
i = i + 1
if p in self.config.configs:
self.passwords.append(self.config.configs[p])
else:
break
def firmwareDeviceAnnounce(self,conn,password,device):
if password not in self.passwords:
return None
self.devices.persistOrUpdate(conn,device)
return device['id']
def checkSid(self,conn,sid):
return self.devices.isEnabled(conn,sid)
'''
Sincroniza los logs enviados como parámetro que no existen en la base
retorna:
Lista de logs sincronizados
'''
def syncLogs(self,conn,logs):
if logs is None or len(logs) <= 0:
return []
return self.logs.persistLogs(conn,logs)
'''
Actualiza los datos del usuario y sus templates
'''
def syncUser(self,conn,user,templates):
if self.users.needSync(conn,user):
self.users.updateUser(conn,user)
if templates is not None:
for t in templates:
if self.templates.needSync(conn,t):
self.templates.update(conn,t)
|
'''
633. Sum of Square Numbers
Given a non-negative integer c, your task is to decide whether there're two
integers a and b such that pow(a, 2) + pow(b, 2) = c.
Example 1:
Input: 5
Output: True
Explanation: 1 * 1 + 2 * 2 = 5
Example 2:
Input: 3
Output: False
'''
class Solution(object):
def mySqrt(self, x):
"""
:type x: int
:rtype: int
"""
left = 0
right = x
while left <= right:
mid = (left + right)/2
if mid**2 > x:
right = mid-1
elif mid**2 < x:
left = mid+1
else:
return mid
return left-1
def isPerfectSquare(self, num):
"""
:type num: int
:rtype: bool
"""
left = 0
right = num
while left <= right:
mid = (left + right) / 2
if mid**2 == num:
return True
elif mid**2 < num:
left = mid + 1
else:
right = mid - 1
return False
def judgeSquareSum(self, c):
"""
:type c: int
:rtype: bool
"""
if self.isPerfectSquare(c):
return True
left = 1
right = self.mySqrt(c) + 1
while left <= right:
if pow(left, 2) + pow(right, 2) < c:
left = left + 1
elif pow(left, 2) + pow(right, 2) > c:
right = right - 1
else:
return True
return False
if __name__ == '__main__':
c = 2
c = 999999999
cs = Solution()
print cs.judgeSquareSum(c)
|
#!/usr/bin/python3
from vector import Vector
vector1 = Vector([1,2,3])
vector2 = Vector([1,2,3])
vector3 = Vector([3,4,5]);
print( vector1,vector2 ,)
print( vector1 == vector2 )
print( vector1 == vector3 )
print ( vector1.plus(vector2))
print (value, sep, end, file, flush)
|
import unittest
# function spelling mistake is from CodeWars
from katas.beta.binary_pyramid_101 import binary_piramid
class BinaryPyramidTestCase(unittest.TestCase):
def test_equals(self):
self.assertEqual(binary_piramid(1, 4), '1111010')
def test_equals_2(self):
self.assertEqual(binary_piramid(1, 6), '101001101')
def test_equals_3(self):
self.assertEqual(binary_piramid(6, 20), '1110010110100011')
def test_equals_4(self):
self.assertEqual(binary_piramid(21, 60), '1100000100010001010100')
|
import unicodecsv
enrollments = []
f = open('enrollments.csv', 'rb')
reader = unicodecsv.DictReader(f)
i = 0
for row in reader:
enrollments.append(row)
print enrollments[i]
i = i+1
f.close()
|
# import requests
# sessiion = requests.Session()
# params = {'username':'zhaolf','password':'password'}
# r = requests.post('http://pythonscraping.com/pages/cookies/welcome.php',params=params)
# print(r.text)
# print('cokkies is set to :')
# print(r.cookies.get_dict())
# print('Going to profile page..')
#
# s = sessiion.get('http://pythonscraping.com/pages/cookies/profile.php')
# print(s.text)
#
from requests.auth import AuthBase
from requests.auth import HTTPBasicAuth
import requests
auth = HTTPBasicAuth('sss','password')
r = requests.get('http://pythonscraping.com/pages/auth/login.php',auth=auth)
# print(r.text)
|
""" Interactive Smoke Plume
Hot smoke is emitted from a circular region at the bottom.
The simulation computes the resulting air flow in a closed box.
The grid resolution of the smoke density and velocity field can be changed during the simulation.
The actual resolution values are the squares of the slider values.
Performance curves are available in Φ-Board.
"""
from phi.flow import *
smoke_res = vis.control(8, (3, 20))
v_res = vis.control(8, (3, 20))
pressure_solver = vis.control('auto', ('auto', 'CG', 'CG-adaptive', 'CG-native', 'direct', 'GMres', 'lGMres', 'biCG', 'CGS', 'QMR', 'GCrotMK'))
BOUNDS = Box(x=100, y=100)
INFLOW = Sphere(x=50, y=10, radius=5)
velocity = StaggeredGrid((0, 0), 0, x=v_res ** 2, y=v_res ** 2, bounds=BOUNDS)
smoke = CenteredGrid(0, ZERO_GRADIENT, x=smoke_res ** 2, y=smoke_res ** 2, bounds=BOUNDS)
viewer = view(smoke, velocity, namespace=globals(), play=False)
for _ in viewer.range(warmup=1):
# Resize grids if needed
inflow = resample(INFLOW, CenteredGrid(0, smoke.extrapolation, x=smoke_res ** 2, y=smoke_res ** 2, bounds=BOUNDS), soft=True)
smoke = resample(smoke, inflow)
velocity = velocity.at(StaggeredGrid(0, velocity.extrapolation, x=v_res ** 2, y=v_res ** 2, bounds=BOUNDS))
# Physics step
smoke = advect.mac_cormack(smoke, velocity, 1) + inflow
buoyancy_force = (smoke * (0, 0.1)).at(velocity)
velocity = advect.semi_lagrangian(velocity, velocity, 1) + buoyancy_force
try:
with math.SolveTape() as solves:
velocity, pressure = fluid.make_incompressible(velocity, (), Solve(pressure_solver, 1e-5))
viewer.log_scalars(solve_time=solves[0].solve_time)
viewer.info(f"Presure solve {v_res**2}x{v_res**2} with {solves[0].method}: {solves[0].solve_time * 1000:.0f} ms ({solves[0].iterations} iterations)")
except ConvergenceException as err:
viewer.info(f"Presure solve {v_res**2}x{v_res**2} with {err.result.method}: {err}\nMax residual: {math.max(abs(err.result.residual.values))}")
velocity -= field.spatial_gradient(err.result.x, velocity.extrapolation, type=type(velocity))
|
import time
from snap7 import util
from snap7 import client
from LoadTags import loadTags
from LoadDBs import loadDBs
from restart import restart_program
import GravaDados
import logging
# initialize the log settings
logging.basicConfig(format='%(asctime)s - %(levelname)s:%(message)s', datefmt='%d/%m/%Y %H:%M:%S',filename = 'historian.log', level = logging.INFO)
# Configuracao do PLC
ipSiemens = '192.168.1.1'
clock = 1
def conection(ipSiemens):
if not plc.get_connected() :
try:
print "Conectando ao PLC Siemens..."
plc.connect(ipSiemens, 0, 2) # connect to PLC
msg1 = "Conectado ao PLC Siemens, IP:" + ipSiemens
print msg1
return True
except Exception as e:
print(e)
return False
else:
return True
#converte o byte lido no PLC para seu respectivo tipo
def read_tags():
"""
length: Proxima posicao pos a variavel desejada
start: location we are going to start the read
"""
try:
# Leitura das DBs pode ser ate em outra funcao
for db in dbs.values():
db.get_values(plc)
for tag in tags:
tag.set_value(dbs[str(tag.db)].data)
GravaDados.grava_tag(tags)
return True
except Exception as e:
print(e)
restart_program()
if __name__ == "__main__":
tags = loadTags()
dbs = loadDBs()
plc = client.Client()
mincount = 0
heartbit = 0
while True:
if conection(ipSiemens) :
try:
read_tags()
time.sleep(clock)
heartbit += 1
if heartbit > 60:
mincount += 1
print "checkpoint de funcionamento minuto " + str(mincount)
heartbit = 0
erro = 0
except:
restart_program()
else:
print "Erro em alguma lib"
restart_program()
|
def Sieve(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
z = []
x = Sieve(104730)
for i in range(2, 104730):
if x[i]:
z.append(i)
t = int(input())
for _ in range(t):
n = int(input())
print(z[n-1])
|
import json
import os
def getcount(filepath):
count = 0
#判断给定的路径是否是.py文件
if filepath.endswith('.py'):
#打开文件
f = open(filepath,'r',encoding='utf-8')
#先读取一行
content = f.readline()
#当读取的代码行不是空的时候进入while循环
while content != '':
#判断代码行不是换行符\n时进入,代码行数加1
if content != '\n' and '#' not in content :
count += 1
#接着读取下一行
content = f.readline()
f.close()
return count
# print(getcount('E:\\learning.py'))
def getDebugJson():
with open('D:\\chengxu\\SoftwareEngineering\\probabilityTheory2\\possiBC\\GetAlgorithmCapabilityRowDATA\\group3_data.json','r',encoding='utf8')as fp:
json_data = json.load(fp)
# 创建字典
info_dict = {}
for key in json_data:
caseList=list(json_data[key]['cases'])
addList=[]
for case in caseList:
tempDict={}
tempDict['case_id']=case['case_id']
tempDict['case_type'] = case['case_type']
tempDict['upload_times']=len(case['upload_records'])
# tempList=[]
# tempD={}
# for record in case['upload_records']:
# tempD['upload_time']=record['upload_time']
# tempD['score'] = record['score']
# tempList.append(tempD)
# tempDict['upload_records']=tempList
tempDict['deltaScore']=case['upload_records'][len(case['upload_records'])-1]['score']-case['upload_records'][0]['score']
tempDict['deltaTime']=case['upload_records'][len(case['upload_records'])-1]['upload_time']-case['upload_records'][0]['upload_time']
addList.append(tempDict)
info_dict[key]=addList
# dumps 将数据转换成字符串
info_json = json.dumps(info_dict,sort_keys=False, indent=4, separators=(',', ': '),ensure_ascii=False)
# 显示数据类型
print(type(info_json))
f = open('D:\\chengxu\\SoftwareEngineering\\probabilityTheory2\\possiBC\\RawData\\debug.json', 'w')
f.write(info_json)
def get_filelist(dir):
Filelist = []
for home, dirs, files in os.walk(dir):
for filename in files:
# 文件名列表，包含完整路径
Filelist.append(os.path.join(home, filename))
# # 文件名列表，只包含文件名
# Filelist.append( filename)
return Filelist
def getFirstConstructionJson():
with open('D:\\chengxu\\SoftwareEngineering\\probabilityTheory2\\possiBC\\GetAlgorithmCapabilityRowDATA\\group3_data.json','r',encoding='utf8')as fp:
json_data = json.load(fp)
# 创建字典
info_dict = {}
for key in json_data:
caseList = list(json_data[key]['cases'])
addList = []
for case in caseList:
tempDict={}
tempDict['case_id']=case['case_id']
tempDict['case_type'] = case['case_type']
firstUpload=case['upload_records'][0]
tempDict['firstTime']=firstUpload['upload_time']
tempDict['firstScore'] = firstUpload['score']
url=firstUpload['code_url']
fileName=''
i=len(url)-1
while(i>=0):
if(url[i]!='/'):
fileName+=url[i]
else:
break
i-=1
fileName=fileName[::-1]
dirname = fileName.replace('.zip', '')
dir='D:\\chengxu\\SoftwareEngineering\\probabilityTheory2\\simpleFirstCode\\'+key+'\\'+case['case_type']+'\\'+case['case_id']+'\\'+dirname
fileList=get_filelist(dir)
fileDir=''
for file in fileList:
if(file.endswith('main.py')):
fileDir=file+''
break
tempDict['firstLines']=getcount(fileDir)
addList.append(tempDict)
info_dict[key] = addList
# dumps 将数据转换成字符串
info_json = json.dumps(info_dict,sort_keys=False, indent=4, separators=(',', ': '),ensure_ascii=False)
# 显示数据类型
print(type(info_json))
f = open('D:\\chengxu\\SoftwareEngineering\\probabilityTheory2\\possiBC\\RawData\\firstConstruction.json', 'w')
f.write(info_json)
getDebugJson()
getFirstConstructionJson()
|
from pyparsing import Or, And, Forward, Literal, ZeroOrMore, Group
from asn1PERser.classes.parse_actions import parse_ModuleDefinition
from .assignment_def import TypeAssignment, ValueAssignment
from .common_def import DefinedValue
from .lexical_items import COMMA, LEFT_CURLY_BRACKET, RIGHT_CURLY_BRACKET, \
assignment, typereference, valuereference, empty, modulereference, \
number, identifier
FROM = Literal("FROM")
EXPLICIT_TAGS = Literal("EXPLICIT TAGS")
IMPLICIT_TAGS = Literal("IMPLICIT TAGS")
AUTOMATIC_TAGS = Literal("AUTOMATIC TAGS")
DEFINITIONS = Literal("DEFINITIONS").setResultsName("DEFINITIONS")
BEGIN = Literal("BEGIN").setResultsName("BEGIN")
END = Literal("END").setResultsName("END")
# 13.1
Assignment = Or([
TypeAssignment,
ValueAssignment,
# XMLValueAssignment,
# ValueSetTypeAssignment,
# ObjectClassAssignment, # Rec. ITU-T X.681 | ISO/IEC 8824-2, 9.1
# ObjectAssignment, # Rec. ITU-T X.681 | ISO/IEC 8824-2, 11.1
# ObjectSetAssignment, # Rec. ITU-T X.681 | ISO/IEC 8824-2, 12.1
# ParameterizedAssignment # Rec. ITU-T X.683 | ISO/IEC 8824-4, 8.1
])
# 13.1
# AssignmentList = Forward()
# AssignmentList << Or([
# Assignment,
# AssignmentList + Assignment
# ])
AssignmentList = ZeroOrMore(Assignment)
# 13.1
Reference = Or([
typereference,
valuereference,
# objectclassreference,
# objectreference,
# objectsetreference
])
# 13.1
Symbol = Or([
Reference,
# ParameterizedReference
])
# 13.1
SymbolList = Forward()
SymbolList << Or([
Symbol,
SymbolList + COMMA + Symbol
])
# 13.1
AssignedIdentifier = Or([
# ObjectIdentifierValue,
DefinedValue,
empty
])
# 13.1
GlobalModuleReference = modulereference + AssignedIdentifier
# 13.1
SymbolsFromModule = SymbolList + FROM + GlobalModuleReference
# 13.1
SymbolsFromModuleList = Or([
SymbolsFromModule,
# SymbolsFromModuleList + SymbolsFromModule
])
# 13.1
SymbolsImported = Or([
SymbolsFromModuleList,
empty
])
# 13.1
Imports = Or([
# "IMPORTS" + SymbolsImported + ";",
empty
])
# 13.1
SymbolsExported = Or([
SymbolList,
empty
])
# 13.1
Exports = Or([
# "EXPORTS" + SymbolsExported + ";",
# "EXPORTS ALL" + ";",
empty
])
# 13.1
ModuleBody = Or([
Exports + Imports + AssignmentList,
empty
])
# 13.1
ExtensionDefault = Or([
# "EXTENSIBILITY IMPLIED",
empty
])
# 13.1
TagDefault = Or([
# EXPLICIT_TAGS,
# IMPLICIT_TAGS,
AUTOMATIC_TAGS,
empty
])
# 13.1
EncodingReferenceDefault = Or([
# encodingreference + "INSTRUCTIONS",
empty
])
# 13.1
DefinitiveNumberForm = number
# 13.1
DefinitiveNameAndNumberForm = identifier + LEFT_CURLY_BRACKET + DefinitiveNumberForm + RIGHT_CURLY_BRACKET
# 13.1
DefinitiveObjIdComponent = Or([
# NameForm,
DefinitiveNumberForm,
DefinitiveNameAndNumberForm
])
# 13.1
# DefinitiveObjIdComponentList = Or([
# DefinitiveObjIdComponent,
# DefinitiveObjIdComponent + DefinitiveObjIdComponentList
# ])
# 13.1
# DefinitiveOIDandIRI = And([
# DefinitiveOID,
# IRIValue
# ])
# 13.1
# DefinitiveOID = "{" + DefinitiveObjIdComponentList + "}"
# 13.1
DefinitiveIdentification = Or([
# DefinitiveOID,
# DefinitiveOIDandIRI,
empty
])
# 13.1
ModuleIdentifier = And([
modulereference,
# DefinitiveIdentification
])
# 13.1
ModuleDefinition = And([
ModuleIdentifier.setResultsName("ModuleIdentifier"),
DEFINITIONS,
EncodingReferenceDefault.setResultsName("EncodingReferenceDefault"),
TagDefault.setResultsName("TagDefault"),
ExtensionDefault.setResultsName("ExtensionDefault"),
assignment,
BEGIN,
Group(ModuleBody).setResultsName("ModuleBody"),
# EncodingControlSection + \
END
]).setParseAction(parse_ModuleDefinition)
|
import numpy as np
import sys
from keras.models import Model
import keras.layers as layers
# keras implement
def _conv_block(inputs, filters, alpha, kernel=(3, 3), strides=(1, 1)):
channel_axis = -1
filters = int(filters * alpha)
x = layers.ZeroPadding2D(padding=((0, 1), (0, 1)), name='conv1_pad')(inputs)
x = layers.Conv2D(filters, kernel,
padding='valid',
use_bias=False,
strides=strides,
name='conv1')(x)
x = layers.ReLU(6., name='conv1_relu')(x)
return layers.BatchNormalization(axis=channel_axis, name='conv1_bn')(x)
def _depthwise_conv_block(inputs, pointwise_conv_filters, alpha,
depth_multiplier=1, strides=(1, 1), block_id=1):
channel_axis = -1
pointwise_conv_filters = int(pointwise_conv_filters * alpha)
if strides == (1, 1):
x = inputs
else:
x = layers.ZeroPadding2D(((0, 1), (0, 1)),
name='conv_pad_%d' % block_id)(inputs)
x = layers.DepthwiseConv2D((3, 3),
padding='same' if strides == (1, 1) else 'valid',
depth_multiplier=depth_multiplier,
strides=strides,
use_bias=False,
name='conv_dw_%d' % block_id)(x)
x = layers.ReLU(6., name='conv_dw_%d_relu' % block_id)(x)
x = layers.BatchNormalization(
axis=channel_axis, name='conv_dw_%d_bn' % block_id)(x)
x = layers.Conv2D(pointwise_conv_filters, (1, 1),
padding='same',
use_bias=False,
strides=(1, 1),
name='conv_pw_%d' % block_id)(x)
x = layers.ReLU(6., name='conv_pw_%d_relu' % block_id)(x)
return layers.BatchNormalization(axis=channel_axis,
name='conv_pw_%d_bn' % block_id)(x)
def MobileNet(input_shape=None,
alpha=1.0,
depth_multiplier=1,
classes=7):
# Determine proper input shape and default size.
rows = input_shape[0]
cols = input_shape[1]
default_size = rows
img_input = layers.Input(shape=input_shape)
x = _conv_block(img_input, 32, alpha, strides=(2, 2))
x = _depthwise_conv_block(x, 64, alpha, depth_multiplier, block_id=1)
x = layers.Dropout(0.1, name='dropout128')(x)
x = _depthwise_conv_block(x, 128, alpha, depth_multiplier,
strides=(2, 2), block_id=2)
x = _depthwise_conv_block(x, 128, alpha, depth_multiplier, block_id=3)
x = _depthwise_conv_block(x, 256, alpha, depth_multiplier,
strides=(2, 2), block_id=4)
x = _depthwise_conv_block(x, 256, alpha, depth_multiplier, block_id=5)
x = _depthwise_conv_block(x, 256, alpha, depth_multiplier, block_id=6)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(128, activation="relu")(x)
x = layers.Dropout(0.3)(x)
x = layers.Dense(64, activation="relu")(x)
x = layers.Dropout(0.3)(x)
x = layers.Dense(7, activation="softmax")(x)
inputs = img_input
# Create model.
model = Model(inputs, x, name='mobilenet_%0.2f_%s' % (alpha, rows))
return model
def create_model(input_shape,
alpha,
depth_multiplier,
classes=7):
model = MobileNet(input_shape=input_shape,
alpha=alpha,
depth_multiplier=depth_multiplier,
classes=classes)
print(model.summary())
return model
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from models.reg import Registry
from storage.schema.deserialize import SchemaDeserializer
from storage.impl.merge_serializer import MergeSerializer
if __name__ == '__main__':
deserializer = SchemaDeserializer('./schema')
serializer = MergeSerializer('./schema/implementation', './schema/merged')
resource_reg = Registry()
for type_name in deserializer.resources():
resource_reg.add_type(deserializer.decode_resource(type_name))
for type_name in resource_reg.types:
serializer._serialize_resource(resource_reg.get_type(type_name))
|
# -*- coding: utf-8 -*-
# Import libraries
import os
import sys
import string
import copy
import datetime
import time
import requests
import numpy as np
import pandas as pd
from random import randint
from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
class Scraper(object):
def __init__(self):
self.init()
def init(self):
self.updatePaths()
#---------- Methods for file input - output
def write_txt(self, text, filePath):
with open(filePath, 'w') as f:
f.write(text)
def read_dict(self, filePath):
return np.load(filePath).item()
def write_dict(self, dictionary, filePath):
np.save(filePath, dictionary)
def convertListToPandasDf(self, table, header=True):
if (header == False):
df = pd.DataFrame(table)
else:
df = pd.DataFrame(table, columns=header)
return df
def savePandasDfAsCsv(self, df, filePath, header=True):
if (header == False):
df.to_csv(filePath, index=False, header=False)
else:
df.to_csv(filePath, index=False)
#---------- Methods for keeping time
def startTimer(self):
self.startTime = time.time()
def elapsedTime(self):
currentTime = time.time()
return (currentTime - self.startTime)
def wait(self, seconds=2, random=False):
if (random):
time.sleep(randint(seconds-1, seconds))
else:
time.sleep(seconds)
#---------- Methods for dynamically creating file paths and folders
def updatePaths(self):
self.getDate()
def getDate(self):
# YYYY-MM-DD
now = datetime.datetime.now()
self.now = now
yearStr = str(now.year)
monthStr = str(now.month)
if (len(monthStr) < 2):
monthStr = '0' + monthStr
dayStr = str(now.day)
self.date = yearStr + '-' + monthStr + '-' + dayStr
def dirMissing(self, directory):
if (not os.path.exists(directory)):
return True
return False
def createFolder(self, directory):
print('Creating Folder: ' + directory)
os.makedirs(directory)
#---------- Methods for starting webdriver (aka browser) and opening / closing
def restartBrowser(self):
print('\tRestarting browser')
self.quitBrowser()
self.openBrowser()
def openBrowser(self, runHeadless=False, loadImages=False):
options = webdriver.ChromeOptions()
if (runHeadless):
options.add_argument('--headless')
user_agent = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.50 Safari/537.36'
options.add_argument(f'user-agent={user_agent}')
# Set the window size
options.add_argument('--window-size=800,600')
if (loadImages == False):
prefs = {'profile.managed_default_content_settings.images':2}
options.add_experimental_option('prefs', prefs)
# Set the location
options.binary_location = '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary'
chromedriverPath ='/Users/jhelvy/Documents/chromedriver'
self.browser = webdriver.Chrome(executable_path=chromedriverPath,
options=options)
def openNewBrowserTab(self):
self.browser.execute_script('''window.open("about:blank","_blank");''')
def switchToBrowserTab(self, tabIndex):
tabs = self.browser.window_handles
self.browser.switch_to.window(tabs[tabIndex])
def closeBrowserTab(self, tabIndex=None):
if (tabIndex == None):
self.browser.close()
else:
self.switchToBrowserTab(tabIndex)
self.browser.close()
def quitBrowser(self):
self.browser.quit()
#---------- Methods for browser navigation
def browserToUrl(self):
url = self.buildUrl()
self.browser.get(url)
pageLoaded = False
self.startTimer()
while (pageLoaded == False):
self.wait()
pageLoaded = self.hasPageLoaded()
if (self.elapsedTime() > 30):
self.restartBrowser()
def buildUrl(self):
return 'http://www.google.com'
def hasPageLoaded(self):
return True
#---------- Methods for getting data from the browser
def getHtmlFromBrowser(self):
return self.browser.page_source
def getHtmlFromUrl(self, url):
page = requests.get(url)
return page.text
def getSoup(self, html):
return BeautifulSoup(html, 'lxml')
def screenshot(self):
self.browser.save_screenshot('./screenshots/temp.png')
def getPageData(self):
return 42
|
import logging
from pylons import request, response, session, tmpl_context as c
from pylons.controllers.util import abort, redirect_to
from gwhiz.lib.base import BaseController, render
log = logging.getLogger(__name__)
class EmacsclientController(BaseController):
def index(self,id):
import os
id = id.replace('@','/')
#os.system('emacsclient -n %s'%id)
return id
# Return a rendered template
#return render('/emacsclient.mako')
# or, return a response
|
#!/usr/bin/env python
# encoding: utf-8
"""
Given an input string, reverse the string word by word.
For example,
Given s = "the sky is blue",
return "blue is sky the".
"""
def reverseWords(s):
return ' '.join(s.strip().split()[::-1])
|
class LinkedListNode:
def __init__(self,value=0,parent=None,leftnode=None,rightnode=None):
self.value=value
self.parent=parent
self.left=leftnode
self.right=rightnode
self.visited=False
def PreorderWalk(self, node):
if (node is not None):
print(node.value)
self.PreorderWalk(node.left)
self.PreorderWalk(node.right)
def InorderWalk(self,node):
if(node is not None):
self.InorderWalk(node.left)
print(node.value)
self.InorderWalk(node.right)
def PostorderWalk(self,node):
if(node is not None):
self.PostorderWalk(node.left)
self.PostorderWalk(node.right)
print(node.value)
def TreeSearch(self,node,val):
if(node is None or val==node.value):
return node
else:
if(val<node.value):
self.TreeSearch(node.left)
else:
self.TreeSearch(node.right)
def TreeMinimum(self,node):
tmp=node
while(tmp.left is not None):
tmp=tmp.left
return tmp
def TreeMaximum(self,node):
tmp=node
while(tmp.left is not None):
tmp=tmp.right
return tmp
def TreeSuccessor(self,node):
if(node.right is not None):
return self.TreeMinimum(node.right)
y=node.parent
while(y is not None and node==y.right):
node=y
y=y.parent
return y
def TreePredecessor(self,node):
pass
def Tree_Insert(self,value):
tmp=self
while(tmp is not None):
tmp_parent=tmp
if(value<tmp.value):
tmp=tmp.left
elif(value>tmp.value):
tmp=tmp.right
newnode=LinkedListNode(value)
tmp=tmp_parent
newnode.parent=tmp
if(tmp.left is None and value<tmp.value):
tmp.left=newnode
if (tmp.right is None and value > tmp.value):
tmp.right = newnode
def Depth_First_Traversal_List(self,visited,graph,node):
"""
DFS(G, u)
u.visited = true
for each v ∈ G.Adj[u]
if v.visited == false
DFS(G,v)
"""
if node not in visited:
print(node)
visited.add(node)
for neighbour in graph[node]:
self.Depth_First_Traversal_List(visited, graph, neighbour)
def Depth_First_Traversal_Tree(self,root):
if root is None:
return
else:
print(root.value, end=" ")
self.Depth_First_Traversal_Tree(root.left)
self.Depth_First_Traversal_Tree(root.right)
if __name__=="__main__":
# Assignment-1: implement the BFT using tree data structure
# Assignment-2: convert the bft search method to Breadth First Search where user passes a value and
#
# Using a Python dictionary to act as an adjacency list
#=========== using tree data structure
# [20]
# [10] [21]
# [9 [15] [30]
# [N N] [14] [18] [25 N]
# [N N] [N N] [24 28]
root = LinkedListNode(20)
root.Tree_Insert(21)
root.Tree_Insert(30)
root.Tree_Insert(10)
root.Tree_Insert(9)
root.Tree_Insert(15)
root.Tree_Insert(14)
root.Tree_Insert(18)
root.Tree_Insert(25)
root.Tree_Insert(24)
root.Tree_Insert(28)
#root.Breadth_First_Traversal_Tree(root)
print("===============================")
root.Depth_First_Traversal_Tree(root)
#implement the search method
|
import clify
from dps import cfg
from dps.env.advanced import yolo_rl
from dps.datasets import EmnistObjectDetectionDataset
distributions = dict(
area_weight=list([1.5, 2.0, 2.5, 3.0]),
nonzero_weight=list([150, 200, 250, 300]),
)
config = yolo_rl.good_sequential_config.copy(
render_step=100000,
eval_step=1000,
max_experiences=175000,
patience=10000000,
max_steps=1000000,
area_weight=None,
nonzero_weight=None,
)
config.curriculum[-1]['max_experiences'] = 100000000
# Create the datasets if necessary.
print("Forcing creation of first dataset.")
with config:
train = EmnistObjectDetectionDataset(n_examples=int(config.n_train), shuffle=True, example_range=(0.0, 0.9))
val = EmnistObjectDetectionDataset(n_examples=int(config.n_val), shuffle=True, example_range=(0.9, 1.))
print("Forcing creation of second dataset.")
with config.copy(config.curriculum[-1]):
train = EmnistObjectDetectionDataset(n_examples=int(cfg.n_train), shuffle=True, example_range=(0.0, 0.9))
val = EmnistObjectDetectionDataset(n_examples=int(cfg.n_val), shuffle=True, example_range=(0.9, 1.))
from dps.hyper import build_and_submit
clify.wrap_function(build_and_submit)(config=config, distributions=distributions)
|
class Trip:
def __init__(self, id, start_x, start_y, finish_x, finish_y, earliest, latest):
self.id = id
self.start_x = int(start_x)
self.start_y = int(start_y)
self.finish_x = int(finish_x)
self.finish_y = int(finish_y)
self.earliest = int(earliest)
self.latest = int(latest)
self.car = None
self.score = 0
def __str__(self):
return '[{}] from {},{} to {},{}'.format(self.id, self.start_x,
self.start_y, self.finish_x,
self.finish_y)
|
# -*- coding: utf-8 -*-
"""
This problem was asked by Uber.
Given an array of integers, return a new array such that each element at index i of the new array
is the product of all the numbers in the original array except the one at i.
For example, if our input was [1, 2, 3, 4, 5], the expected output would be [120, 60, 40, 30, 24].
If our input was [3, 2, 1], the expected output would be [2, 3, 6].
Follow-up: what if you can't use division?
"""
from functools import reduce
def dcp2(nums):
product = reduce(lambda x,y: x*y, nums)
products = []
for i in range(0,len(nums)):
products.append(product/nums[i])
return products
def dcp2_nodiv(nums):
products = []
for i in range(0,len(nums)):
products.append(reduce(lambda x,y: x*y,[x for k,x in enumerate(nums) if k != i]))
return products
|
__author__ = 'AlecGriffin'
from Verse import Verse
from Bible import Bible
from Chapter import Chapter
from Book import Book
def getParsedContent():
bookName = ""
bible = Bible()
book = Book("Genesis")
chapter = Chapter(1)
file = open("bible.txt")
bookname = ""
for line in file:
splitLine = line.split()
# Aquires Book Title Name of current line
if (splitLine[0].isdigit()):
bookName = splitLine[0] + " " + splitLine[1]
elif (splitLine[0] == "Song"):
bookName = splitLine[0] + " " + splitLine[1] + " " + splitLine[2]
else:
bookName = splitLine[0]
# Aquires Book Chapter number and verse number of current line
if (splitLine[0].isdigit()):
chapNumAndVerseNum = splitLine[2].split(sep=":")
elif (splitLine[0] == "Song"):
chapNumAndVerseNum = splitLine[3].split(sep=":")
else:
chapNumAndVerseNum = splitLine[1].split(sep=":")
# Uses chapNumandVerseNum to get the chapter number
# and the verse Number
currentChapNum = chapNumAndVerseNum[0]
currentVerseNum = chapNumAndVerseNum[1]
verseString = ""
# Aquires the Verse String from the current line.
if (splitLine[0].isdigit()):
for index in range(3, len(splitLine)):
verseString += splitLine[index] + " "
elif (splitLine[0] == "Song"):
for index in range(4, len(splitLine)):
verseString += splitLine[index] + " "
else:
for index in range(2, len(splitLine)):
verseString += splitLine[index] + " "
# Uses generated verse String to create a new bible verse
currentBibleVerse = Verse(currentVerseNum, verseString)
# When Book Title Changes, add the current book to the bible.
# Then, create new book.
if (book.bookTitle != bookName):
book.addChapter(chapter)
chapter = Chapter(currentChapNum)
bible.addBook(book.bookTitle, book)
book = Book(bookName) # Resets Book Object
book.bookTitle = bookName
# When Book Number Changes, add the current chapter to the current book
# Then, Create a new book.
elif(currentChapNum != chapter.chapterNum):
book.addChapter(chapter)
chapter = Chapter(currentChapNum)
# Adds each verse to the correct chapter
chapter.addVerse(currentBibleVerse)
# Adds Revelations [Edge Case]
book.addChapter(chapter)
bible.addBook(bookName, book)
return bible
|
import unittest
from katas.kyu_7.where_is_vasya import where_is_he
class WhereIsHeTestCase(unittest.TestCase):
def test_equals(self):
self.assertEqual(where_is_he(3, 1, 1), 2)
def test_equals_2(self):
self.assertEqual(where_is_he(5, 2, 3), 3)
def test_equals_3(self):
self.assertEqual(where_is_he(6, 5, 5), 1)
def test_equals_4(self):
self.assertEqual(where_is_he(5, 4, 0), 1)
def test_equals_5(self):
self.assertEqual(where_is_he(9, 4, 3), 4)
|
#The "zip" built-in function takes a few lists (two in this example),
# and creates tuples by picking up elements from each list.
# The first tuple contains elements from the first positions in the lists, and so on.
d1=["a","b","c","d","e"]
d2=["f","g","h","i","j"]
d3=zip(d1,d2)
for x in d3:
print(x[0] + "" + x[1])
|
from logging import Logger, getLogger
from flask import Flask
def get_logger(app: Flask, name: str) -> Logger:
"""Utitlity method to get a specific logger that is a child logger of the app.logger."""
logger_name = f"{app.import_name}.{name}"
return getLogger(logger_name)
|
import logging
from flask import Response, make_response, jsonify, request
from flask_login import login_required
from waitlist.base import db
from waitlist.permissions import perm_manager
from waitlist.storage.database import Account, Character
from waitlist.utility.eve_id_utils import get_character_by_id,\
get_character_by_name
from waitlist.blueprints.swagger_api.models import errors
from . import bp_v1
from waitlist.signal.signals import send_alt_link_removed, send_alt_link_added
from flask_login.utils import current_user
logger = logging.getLogger(__name__)
perm_manager.define_permission('change_character_links')
perm_change_links = perm_manager.get_permission('change_character_links')
perm_manager.define_permission('accounts_download_list')
perm_manager.define_permission('accounts_download_list')
@login_required
@perm_change_links.require()
@bp_v1.route('/<int:account_id>/links/<int:character_id>',
methods=['DELETE'])
def links_delete_v1(account_id: int, character_id: int) -> Response:
"""
file: links_delete_v1.yml
"""
acc: Account = db.session.query(Account).get(account_id)
if acc is None:
resp: Response = jsonify(errors.error_404(f'No Account with id {account_id} found.'))
resp.status_code = 404
return resp
character_to_remove: Character = None
for character in acc.characters:
if character.id == character_id:
character_to_remove = character
break
if character_to_remove is None:
resp: Response = jsonify(errors.error_404('No Character link found.'))
resp.status_code = 404
return resp
logger.debug("Trying to delete link from %s to %s", acc, character_to_remove)
acc.characters.remove(character_to_remove)
if acc.current_char == character_to_remove.id:
acc.current_char = None
db.session.commit()
# tell handlers about this
send_alt_link_removed(links_delete_v1, current_user.id, account_id, character_id)
return make_response('', 204)
@login_required
@perm_change_links.require()
@bp_v1.route('/<int:account_id>/links',
methods=['POST'])
def links_post_v1(account_id: int) -> Response:
"""
file: links_post_v1.yml
"""
data = request.json
character_name = data['character_name'] if 'character_name' in data else None
character_id = data['character_id'] if 'character_id' in data else None
if character_id is not None:
character_id = int(character_id)
if character_id is None and character_name is None:
resp: Response = jsonify(errors.error_400(f"character_name or character_id needs to be provided"))
resp.status_code = 400
return resp
account: Account = db.session.query(Account).get(account_id)
if account is None:
resp: Response = jsonify(errors.error_404(f"No Account with id={account_id} exists."))
resp.status_code = 404
return resp
character: Character = None
if character_id is None:
character = get_character_by_name(character_name)
else:
character = get_character_by_id(character_id)
if character is None:
resp: Response = jsonify(
errors.error_400(f"No character with "
f"{'id='+character_id if character_id is not None else 'name='+character_name}"))
resp.status_code = 400
return resp
if character in account.characters:
resp: Response = jsonify(
errors
.error_400(f"The Account already has a connection to the "
f" with {'id='+character_id if character_id is not None else 'name='+character_name}."))
resp.status_code = 400
return resp
character.owner_hash = ''
account.characters.append(character)
db.session.commit()
send_alt_link_added(links_post_v1, current_user.id, account.id, character.id)
resp: Response = jsonify({
'account_id': account.id,
'character_id': character.id,
'character_name': character.eve_name,
'message': (f'Link between Account {account.username}'
f' and Character {character.eve_name} was created.')
})
resp.status_code = 201
return resp
@login_required
@perm_manager.require('accounts_download_list')
@bp_v1.route('/download', methods=['GET'])
def download_get_v1() -> Response:
"""
file: download_get_v1.yml
"""
include_disabled = request.args.get('include_disabled', False, type=bool)
include_alts = request.args.get('include_alts', False, type=bool)
include_owner_hash = request.args.get('include_owner_hash', False,
type=bool)
as_download = request.args.get('as_download', False, type=bool)
if include_disabled:
accs = db.session.query(Account).all()
else:
accs = db.session.query(Account).filter(
Account.disabled == False).all()
accs_out = []
for acc in accs:
acc_out = {}
acc_out['username'] = acc.username
acc_out['disabled'] = acc.disabled
if include_alts:
acc_out['alts'] = []
for alt in acc.characters:
alt_out = {}
alt_out['name'] = alt.get_eve_name()
if include_owner_hash and alt.owner_hash is not None\
and alt.owner_hash != '':
alt_out['owner_hash'] = alt.owner_hash
alt_out['id'] = alt.id
acc_out['alts'].append(alt_out)
accs_out.append(acc_out)
resp: Response = jsonify(accs_out)
resp.status_code = 200
if as_download:
resp.headers['Content-Disposition'] =\
'attachment; filename="full_commander_list.json"'
return resp
|
class State(object):
# MARK: Constructor for a state object.
def __init__(self, state, parent, child):
# An integer.
self.state = state
# A state object.
self.parent = parent
# A set of state objects.
self.child = child
# An integer.
self.heuristic = None
# An integer to corresponding move.
# 0 => No previous move.
# 1 => 1 is subtracted from the first digit.
# 2 => 1 is added to the first digit.
# 3 => 1 is subtracted from the second digit.
# 4 => 1 is added to the second digit.
# 5 => 1 is subtracted from the third digit.
# 6 => 1 is added to the third digit.
self.previous_move = 0
# For getting the path to current state.
self.path = ""
# For getting the path cost to evaluate in A*.
self.path_cost = 0
self.evaluation_function = 0
# MARK: Calculating heuristic value and set heuristic value base on goal given.
def set_heuristic(self, goal):
current_first_digit = int(self.state_to_string(self.state)[:1])
current_second_digit = int(self.state_to_string(self.state)[1:2])
current_third_digit = int(self.state_to_string(self.state)[2:])
goal_first_digit = int(self.state_to_string(goal)[:1])
goal_second_digit = int(self.state_to_string(goal)[1:2])
goal_third_digit = int(self.state_to_string(goal)[2:])
calculated_heuristic = abs(current_first_digit - goal_first_digit) + abs(
current_second_digit - goal_second_digit) + abs(current_third_digit - goal_third_digit)
self.heuristic = calculated_heuristic
return
# MARK: Compare states' content. Return true if they have the same content.
def is_identical_state(self, target_node):
if self.state != target_node.state:
return False
if len(self.child) != len(target_node.child):
return False
for index in range(len(self.child)):
if self.child[index].state != target_node.child[index].state:
return False
return True
# MARK: Add the path to this state.
def add_path(self, previous_path):
if previous_path == "":
self.path = self.state_to_string(self.state)
else:
self.path = previous_path + "," + self.state_to_string(self.state)
return
# MARK: Return a string that is 3 digits long with padding if needed.
@staticmethod
def state_to_string(state):
if state < 10:
return "00" + str(state)
elif state < 100:
return "0" + str(state)
else:
return str(state)
|
# -*- coding: utf-8 -*-
"""
Created on Tue Jan 31 14:33:06 2017
@author: eardo
"""
import numpy as np
import os
import matplotlib.pyplot as plt
os.chdir('C:\Users\eardo\Desktop\pyoutput')
degree_sign= u'\N{DEGREE SIGN}'
freqT=np.genfromtxt("freqT.csv", delimiter=",")
T=freqT[:,0]
freq=freqT[:,1]
fig=plt.plot(T,freq, linewidth=0, marker="o")
plt.title('Frequency of droplet freezing', fontsize=16)
plt.xlabel('T ('+degree_sign+'C)')
plt.ylabel('Instances observed')
plt.xlim(-30,-5)
plt.show()
|
class A:
def __init__(self,no=0):
print("I am Const of A")
self.no = no
def display(self):
print(" I am display of A Class")
print(self.no)
class B(A):
def __init__(self,name="dummy"):
print("I am Const of B")
self.name = name
def show(self):
print(" I am show of B Class")
print(self.name)
#-----------------------------------
b1 = B()
b1.show()
b1.display() # Error because no variable is not init
|
name = "Sheila Brito"
age = 15
gpa = 4.0
print name
print age
print gpa
print 'My name is', name, 'I am', age, 'years old. My gpa is', gpa
print 'in ten years i will be', age+10
ageinhumanyears = 3
ageindogyears = ageinhumanyears * 7
print 'My dog is', ageindogyears, 'years old in dog years'
print 'but my dog is', ageinhumanyears, 'in human years'
#order of operations
#parenthesis, exponentes, multiplication, division, addition, substraction
mynumber = 5*4+10
print mynumber
print "hello", 2
import math
root= math. sqrt(81)
print root
|
from django.http import HttpResponseRedirect
from django.shortcuts import render
from .forms import *
import User.CustomAuth
from django.contrib.auth import login as authLogin
# Create your views here.
def login(request):
next = request.POST.get('next', request.GET.get('next', ''))
if not request.method == 'POST':
form = LoginForm()
return render(request, 'login/login.html', {'form': form, 'next': next})
form = LoginForm(request.POST)
if not form.is_valid():
return render(request, 'login/loginFailedOld.html') #ERROR! invalid form request!
mail = request.POST['mail']
auth = User.CustomAuth.CustomAuth()
try:
request.POST['update_user']
update = True
except:
update = False
user = auth.authenticate(username=mail, password=request.POST['password'], update_user=update)
if user is None:
return render(request, 'login/loginFailedOld.html')
if user.username == 'ucilnicaDown' or user.username == 'noStudentId' or user.username == 'incorrectCredentials':
return render(request, 'login/login_failed.html', {'error': str(user.username)})
authLogin(request, user, 'User.CustomAuth.CustomAuth')
if next:
return HttpResponseRedirect(next)
return HttpResponseRedirect('/')
|
import requests
def main():
response = requests.get("https://api.exchangeratesapi.io/latest")
if response.status_code != 200:
print("Status Code: ", response.status_code)
raise Exception("There was an error!")
data = response.json()
print("JSON data: ", data)
if __name__ == "__main__":
main()
|
import random
import traceback
import requests
import logging
log = logging.getLogger('log')
def get_proxies():
# 代理服务器，支持http和https
return ['192.168.62.10:12000'] #
def req(session, url, proxies=None, debug=0, method='get', timeout=3, retry_times=2, proxy=False,**kwargs):
request_method = {'get': session.get, 'post': session.post, 'head': session.head, 'options': session.options}
retry = retry_times
is_first = True
# proxy = ""
while retry > 0:
try:
if debug == 0:
#需要代理
if proxy:
proxies = proxies if proxies else get_proxies()
if proxies:
proxy = random.choice(proxies)
print('proxy:', proxy)
# return request_method[method](url, proxies={"http": proxy}, timeout=2, **kwargs)
if url[:6] == 'https:':
# print('https')
return request_method[method](url, proxies={"https": "https://" + proxy}, timeout=timeout,
**kwargs)
# elif url[:6] == 'http:/':
else:
# print('http')
return request_method[method](url, proxies={"http": "http://" + proxy}, timeout=timeout,
**kwargs)
else:
return request_method[method](url, timeout=timeout, **kwargs)
else:
return request_method[method](url, timeout=timeout, **kwargs)
else:
return request_method[method](url, timeout=timeout, **kwargs)
except Exception as er:
retry -= 1
msg = traceback.format_exc()
log.error("请求错误--{}".format(msg))
# if (debug == 0 and retry == 0 and "time out" in msg and "192.168" in msg):
# raise Exception("连接代理服务，最后:" + proxy + "超时" + "请求次数:" + str(retry_times + 1))
try:
if retry == 0 and debug == 1:
return request_method[method](url, timeout=timeout, **kwargs)
except:
raise Exception("http请求失败：URL地址:" + url + "请求次数:" + str(retry_times + 1))
|
#Speed Tape Gauge
#
#
# -- Currently Missing
#
# -- Mach text
# -- Fine location and positioning
# -- Connection with GlassServer
import pyglet
from pyglet.gl import *
from gauge import gauge_parent
import common
import variable
import math, time
import text
class Vspeed_c(object):
#Hold all data on VSpeed Class
def __init__(self, name, y_pos, value, visible):
self.name = name
self.y_pos = y_pos
self.value = value
self.visible = visible
def draw_indicator(self, loc):
if self.y_pos + loc > -165:
glPushMatrix()
glTranslatef(-35.0, self.y_pos + loc, 0.0)
glScalef(0.15,0.15,1.0)
if self.visible.value:
text.write("%s %3d" %(self.name, self.value.value))
else:
text.write("%s" %(self.name))
glPopMatrix()
def draw_selected(self, loc):
#Always draw located below airspeed tape
glPushMatrix()
glTranslatef(-35.0, loc, 0.0)
glScalef(0.15,0.15,1.0)
if self.visible.value:
text.write("%s %3d" %(self.name, self.value.value))
else:
text.write("%s ---" %(self.name))
glPopMatrix()
def draw_bug(self, airspeed, knot_unit):
if self.visible.value:
diff = (self.value.value- airspeed) * knot_unit
noshow = 168 #If out of this range then don't show
if abs(diff) <= noshow:
glPushMatrix()
glTranslatef(17.5, diff, 0.0) #Move to point of V speed bug
#Draw Line
glBegin(GL_LINES)
glVertex2f(-35.0,0.0)
glVertex2f(-7.5,0.0)
glEnd()
#Draw Text next to line 1,2,R,T
glScalef(0.12,0.12,1.0)
text.write(self.name[1]) #Only do 2nd character
glPopMatrix()
def draw(self,loc, airspeed, knot_unit):
self.draw_indicator(loc)
self.draw_bug(airspeed, knot_unit)
class gauge_c(gauge_parent):
def __init__(self, *args, **kwds):
super(gauge_c, self).__init__(*args, **kwds)
self.x = 90
self.y = 300
self.set_native_size(self.x, self.y)
self.earth = (0.69, 0.4, 0.0) #The ground color on attitude indicator
self.sky = (0.0, 0.6, 0.8)
self.pixel_per_degree = 7.5
self.load_batch()
#Init Constants
self.knot_unit = 3.5 #Number of units per knot
self.knot_text = ['%3d' %(i*10) for i in range(0,56,2)]
#Init Variables
self.IAS = variable.variables.load(0x100,'4F')
self.OnGround = variable.variables.load(0x127)
self.Mach = variable.variables.load(0x103,'4F')
self.V1 = variable.variables.load(0x1100)
self.V1_visible = variable.variables.load(0x1101)
self.VR = variable.variables.load(0x1102)
self.VR_visible = variable.variables.load(0x1103)
self.V2 = variable.variables.load(0x1104)
self.V2_visible = variable.variables.load(0x1105)
self.VT = variable.variables.load(0x1106)
self.VT_visible = variable.variables.load(0x1107)
self.VSpeed_Selected = variable.variables.load(0x1108)
self.Vinput = 0 #Vspeed that is selected. (0-4) 0=V1 1=VR 2=V2 3=VT
self.a = 0.0
# Init Vspeeds
y_space = 30
y_offset = 5
self.Vspeed_l = [Vspeed_c('V1', y_offset, self.V1, self.V1_visible),Vspeed_c('VR', y_space+y_offset, self.VR, self.VR_visible),
Vspeed_c('V2', 2*y_space+y_offset, self.V2, self.V2_visible), Vspeed_c('VT', 3*y_space+y_offset, self.VT, self.VT_visible)]
# Init speed tending line variables
self.IAS_speeds = [[40.0, time.time()]] * 60
self.IAS_trend = 0.0
self.Mach_visible = False
def comp(self):
self.time = time.time()
self.comp_IAS_accel()
self.comp_Mach_disp()
def comp_Mach_disp(self):
self.Mach_ind = self.Mach.value
if self.Mach_visible:
if self.Mach_ind < 0.4: self.Mach_visible = False
else:
if self.Mach_ind > 0.45: self.Mach_visible = True
def comp_IAS_accel(self):
self.IAS_speeds.append([self.airspeed,self.time])
self.IAS_speeds.pop(0)
avg = []
for i in range(0,60,6):
first = self.IAS_speeds[i]
last = self.IAS_speeds[i+5]
if (last[1]-first[1])!=0.0:
avg.append((last[0]-first[0]) / (last[1]-first[1]))
if len(avg) == 0:
new_trend = 0
else:
new_trend = sum(avg) / len(avg) * 10.0
self.IAS_trend += (new_trend - self.IAS_trend) * 0.10
#Limit trending to 50 knots.
if self.IAS_trend>50: self.IAS_trend = 50
elif self.IAS_trend<-50: self.IAS_trend = -50
def load_batch(self):
self.arrow_shape = self.center_arrow_b()
self.top_black_shape = self.black_blocks_b(True)
self.bottom_black_shape = self.black_blocks_b(False)
self.speedbug_shape = self.speedbug_b()
self.barberup_shape = self.barberpole_b(1)
self.barberdown_shape = self.barberpole_b(-1)
def black_blocks_b(self, top):
#Black blocks on top and bottom of speed tape. To hide numbers that spill over.
# -- Used insted of scissoring.
x1 = -45
x2 = 10
y1 = 150
y2 = 200
if top:
y1=-y1
y2=-y2
v1 = common.vertex.lines()
v1.add([x1,y1,-x1,y1,-x1,y2,x1,y2])
batch = pyglet.graphics.Batch()
b1 = batch.add(v1.num_points, GL_POLYGON, None, ('v2f', v1.points),('c3f',common.color.black*v1.num_points))
return batch
def speedbug_b(self):
v1 = common.vertex.lines()
v1.add([0,0,10,8,10,15,0,15,0,-15,10,-15,10,-8,0,0])
batch = pyglet.graphics.Batch()
b1 = batch.add(v1.num_points, GL_LINES, None, ('v2f', v1.points),('c3f',common.color.purple*v1.num_points))
return batch
def barberpole_b(self, dir):
step = 12 #Determine step between
x1 = 2
x2 = 14
vp = common.vertex.lines()
vl = common.vertex.lines()
loc = 0
i =0
num = 2
d = step* dir
#Draw polygon
vp.add([x1,0,x2,0])
loc+=d
vp.add([x2,loc,x1,loc, x1,0])
loc+=d
#Draw lines
vl.add([x1,0,x1,loc])
vl.reset()
vl.add([x2,0,x2,loc])
batch = pyglet.graphics.Batch()
b1 = batch.add(vp.num_points, GL_POLYGON, None, ('v2f', vp.points),('c3f', common.color.red*vp.num_points))
b2 = batch.add(vl.num_points, GL_LINES, None, ('v2f', vl.points),('c3f', common.color.red*vl.num_points))
return batch
def center_arrow_b(self):
#Center White Arrow
y = 0 #self.y_center
w = 18.0
h = 10.0
point = 0.0 #Point of arrow's X cord
v1 = common.vertex.lines()
v1.add([point,y])
v1.add([point+w, y-h])
v1.add([point+w, y+h])
v1.add([point,y])
v2 = common.vertex.lines()
v2.add([point+w,y])
v2.add([point+w + 12.0, y])
batch = pyglet.graphics.Batch()
b1 = batch.add(v1.num_points, GL_LINES, None, ('v2f', v1.points),('c3f',common.color.white*v1.num_points))
b2 = batch.add(v2.num_points, GL_LINES, None, ('v2f', v2.points),('c3f',common.color.white*v2.num_points))
return batch
def airspeed_diff(self, difference):
#Pink Line above or below arrow that shoes accel or decel rate. Forcast 5 seconds ahead??
if abs(difference) > 1: #If forcasted not difference is less than 2 knots then down't show
y1 = 0
y2 = y1 + difference * self.knot_unit
x1 = 18
x2 = x1 + 12.0
glLineWidth(2.0)
common.color.set(common.color.purple)
glBegin(GL_LINE_STRIP)
glVertex2f(x1, y2)
glVertex2f(x2, y2)
glVertex2f(x2, y1)
glEnd()
def speedbug_draw(self, x=0,y=0):
diff = 100 - self.indicated_IAS()
diff = diff*self.knot_unit
if abs(diff)<168:
glPushMatrix()
glTranslatef(0,diff,0)
self.speedbug_shape.draw()
glPopMatrix()
def speedbugind_draw(self, x=0,y=0):
common.color.set(common.color.purple)
glPushMatrix()
glTranslatef(x,y,0)
self.speedbug_shape.draw()
glTranslatef(30,0,0)
glScalef(0.15,0.15,1.0)
text.write("%3d" %(100))
glPopMatrix()
def Vspeeds(self, start_loc, start_tick_ten):
#Draw Vspeeds
#First calculate location of each of the Vspeeds (V1,VR,V2,VT)
loc = start_loc - (start_tick_ten *10 * self.knot_unit)
common.color.set(common.color.cyan)
for speed in self.Vspeed_l:
speed.draw(loc, self.airspeed, self.knot_unit)
def Vspeed_selected(self, loc):
common.color.set(common.color.cyan)
self.Vspeed_l[self.VSpeed_Selected.value].draw_selected(loc)
def tick_marks(self, x=0, y=0):
#Draw the tick mark
unit_apart = self.knot_unit
center = 0.0
y_center = 0
#air_spd is class of speed, will use IAS, Mach, and V Speeds, possibly Ground Speed
airspeed = self.indicated_IAS()
self.a+=0.1
#airspeed = self.a
common.color.set(common.color.white) #White
#glLineWidth(2.0)
start_tick_ten = (int(airspeed) / 10) - 4
tick_ten = start_tick_ten
start_loc = y_center - ((airspeed - (tick_ten * 10)) * unit_apart)
loc = start_loc
glBegin(GL_LINES)
vert_line_bottom = -150
for i in range(10):
#Tick itself
if tick_ten == 4:
vert_line_bottom = loc
if tick_ten >=4: #This causes nothing below 40 to be displyed
glVertex2f(center - 10.0, loc)
glVertex2f(center, loc)
if tick_ten <20: #If its under 200 knots add a 5 knot mork
mid_loc = loc + (unit_apart * 5) # This is equivelent of 5 knots higher
glVertex2f(center - 5.0, mid_loc)
glVertex2f(center, mid_loc)
tick_ten = tick_ten +1
loc = loc + (unit_apart * 10)
#Draw verticle Line of airspeed tape
glVertex2f(center, vert_line_bottom)
glVertex2f(center, 150.0)
glEnd()
return start_loc, start_tick_ten
def tick_numbers(self, start_loc, start_tick_ten):
loc = start_loc
tick_ten = start_tick_ten
unit_apart = self.knot_unit
# glLineWidth(2.0)
for i in range(10):
# Put in numbers
if (tick_ten >=4) & (tick_ten % 2 == 0): #Must be multiple of 20 and above 0 knots
#Print out number print
glPushMatrix()
#if tick_ten >=10:
# glTranslatef(8.0, loc - 6.0, 0.0)
# glScalef(0.13,0.13,1) #Scale text, also done in else statement below.
#c = (tick_ten / 10) + 48
#glutStrokeCharacter(GLUT_STROKE_ROMAN, c)
# text.write(self.knot_text[tick_ten/2])
#else:
# glTranslatef(18.0, loc - 6.0, 0.0) #Move over since no hundreds digit
# glScalef(0.13,0.13,1) #Don't forget to scale text
#c = (tick_ten % 10) + 48
#glutStrokeCharacter(GLUT_STROKE_ROMAN, c) #Tens digit
#glutStrokeCharacter(GLUT_STROKE_ROMAN, 48) # Ones Digit
glTranslatef(-40.0, loc, 0.0)
glScalef(0.13,0.13,1.0)
text.write(self.knot_text[tick_ten/2])
glPopMatrix()
elif (tick_ten == 3): #Put in V Speed Text
#self.V_Speeds(air_spd, loc - 12.0)
pass
tick_ten = tick_ten +1
loc = loc + (unit_apart * 10)
def speed_cues(self):
def lowspeedcue(y):
x1 = -17.5
x2 = 22.5
common.color.set(common.color.green)
glLineWidth(2.0)
glBegin(GL_LINES)
glVertex2f(x1,y)
glVertex2f(x2,y)
glEnd()
def barberpole(y, dir):
glPushMatrix()
noshow = 168
if dir==1:
if y < -noshow: #If outside of range draw bar entire length
num = 14
y = -noshow + (y % 24)
else:
num = int(((noshow - y) / 24) + 1)
glTranslatef(0,y,0)
for i in range(num):
self.barberup_shape.draw()
glTranslatef(0,24,0)
else:
if y > noshow: #If outside of range draw bar entire length
num = 14
y = noshow + (y % 24)
else:
num = int(((noshow + y) / 24) + 1)
glTranslatef(0,y,0)
for i in range(num):
self.barberdown_shape.draw()
glTranslatef(0,-24,0)
glPopMatrix()
#Lowspeed cue
y = self.calc_show(60)
if y: lowspeedcue(y)
#Barber Pole Lower
y = self.calc_show(120, False)
#barberpole(y,-1) ##Disable Lower Barber Pole for now.
#Barber Pole Upper
y = self.calc_show(220, False)
barberpole(y,1)
def airspeed_mach_text(self, value, x=0, y=0): # Text on top
common.color.set(common.color.white)
#Draw Text Part
glPushMatrix()
glTranslatef(x, y, 0.0)
glScalef(0.13,0.13,1.0)
text.write("M", 100)
text.write(("%3.3f" %value)[1:], 90)
glPopMatrix()
def calc_show(self, speed, return_none = True):
#Calculate on speed tape if item should be visible and where.
diff = (speed - self.airspeed) * self.knot_unit
noshow = 168
if (abs(diff) <= noshow) or (not return_none):
return diff
else:
return None
def indicated_IAS(self):
indicated = self.IAS.value
if indicated <40: indicated =40
elif indicated > 500: indicated = 500
return indicated
def draw(self):
#self.glLineWidth(2.0)
#Limit Airspeed
self.airspeed = self.indicated_IAS()
self.comp()
glLineWidth(2.0)
start_loc, start_tick_ten = self.tick_marks()
self.tick_numbers(start_loc, start_tick_ten)
self.speedbug_draw()
self.Vspeeds(start_loc, start_tick_ten)
self.speed_cues()
#Airspeed pink trending line, only draw if inflight.
if not self.OnGround.value: self.airspeed_diff(self.IAS_trend)
self.arrow_shape.draw()
self.top_black_shape.draw()
self.bottom_black_shape.draw()
self.speedbugind_draw(-40,-170)
self.Vspeed_selected(-200)
if self.Mach_visible: self.airspeed_mach_text(self.Mach.value, -38, 170)
|
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import getopt, datetime, os, subprocess, sys
#os.chdir('../')
def main(argv):
try:
opts, args = getopt.getopt(argv, "m:", ["message="])
except getopt.GetoptError:
sys.exit(2)
for opt, arg in opts:
if opt in ("-m", "--message"):
message = arg
major_v = 0
minor_v = 4
#read minor minor release number
f = open('minor_minor_number.txt', 'r')
ln = f.readlines()
f.close()
minor_minor_v = int(ln[0].strip()) + 1
#write incremented minor minor release number
f = open('minor_minor_number.txt', 'w')
f.write(str(minor_minor_v))
f.close()
builddate = datetime.datetime.now().strftime("%d-%b-%Y %H:%M")
#set git tag
gittag = str(major_v) + '.' + str(minor_v) + '.' + str(minor_minor_v)
f = open('00_preface.Rmd', 'r')
ln = f.readlines()
f.close()
for i in range(len(ln)):
if ln[i].strip().split(':')[0].strip() == "subtitle":
ln[i] = 'subtitle: "' + gittag +'"\n'
f = open('00_preface.Rmd', 'w')
f.writelines(ln)
f.close()
subprocess.call('git commit -a -m"' + message+'"', shell=True)
#tag the commit so that it can be easily retrieved
subprocess.call('git tag -a "' + gittag +'"' + ' -m "' + gittag +'"', shell=True)
if __name__ == "__main__":
main(sys.argv[1:])
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
initial = True
dependencies = [
('contenttypes', '0001_initial'),
('core', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Event',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('created_at', models.DateTimeField(db_index=True)),
('title', models.TextField()),
('is_update', models.BooleanField(default=False)),
('related_object_id', models.PositiveIntegerField(db_index=True, null=True, blank=True)),
('issue', models.ForeignKey(to='core.Issue')),
('related_content_type', models.ForeignKey(blank=True, to='contenttypes.ContentType', null=True)),
('repository', models.ForeignKey(to='core.Repository')),
],
options={
'ordering': ('created_at',),
},
bases=(models.Model,),
),
migrations.CreateModel(
name='EventPart',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('field', models.CharField(max_length=50, db_index=True)),
('old_value', models.TextField(null=True, blank=True)),
('new_value', models.TextField(null=True, blank=True)),
('event', models.ForeignKey(related_name='parts', to='events.Event')),
],
options={
'ordering': ('id',),
},
bases=(models.Model,),
),
]
|
#!/bin/python3
import math
import os
import random
import re
import sys
# Complete the countingValleys function below.
def countingValleys(n, s):
valles = 0
altitude_nova = 0
altitude_velha = 0
for c in s :
if(altitude_velha >= 0 and altitude_nova < 0):
valles += 1
altitude_velha = altitude_nova
if c == 'D':
altitude_nova -= 1
else:
altitude_nova += 1
return valles
if __name__ == '__main__':
n = 8
s = ["D", "D", "U", "U", "D", "D", "U", "D", "U", "U", "U", "D"]
result = countingValleys(n, s)
print(result)
|
'''
Created on 27. feb. 2017
@author: tsy
License: CC-BY
'''
from random import randint
import numpy as np
if __name__ == '__main__':
pass
def roll(dice):
res = 0
for n in range(dice):
res =+ randint(1,6)
return res
def charge(M=None,distance = None,swiftStride=False):
assert M is not None
assert distance is not None
res = list()
chargePassed = False
res.append(roll(1))
res.append(roll(1))
if swiftStride:
res.append(roll(1))
chargeRange= sum(res) - min(res)
else:
chargeRange=sum(res)
if chargeRange >= distance:
chargePassed = True
return chargePassed
def LdTest(Ld=None,reRoll=False,coldBlood=False):
assert Ld is not None
def __test__(Ld,reRoll,coldBlood):
passTest = False
res = list()
res.append(roll(1))
res.append(roll(1))
if coldBlood:
res.append(roll(1))
score = sum(res) - max(res)
else:
score = sum(res)
if score<=Ld:
passTest = True
return passTest
passTest = __test__(Ld,reRoll,coldBlood)
if passTest is False and reRoll is True:
passTest = __test__(Ld,reRoll,coldBlood)
return passTest
def cast(dice=None,castValue=None):
assert type(dice) is not None
assert castValue is not None
assert dice < 6
assert castValue <20
spellCast = True
res = list()
#cast dice
for n in range(dice):
res.append(roll(1))
#check for OP and roll another dice if OP
res.sort()
if dice>1:
if res[-1] is 6 and res[-2] is 6:
res.append(roll(1))
#summarize castScore
castScore = sum(res)
#check against castValue
if castScore<castValue:
spellCast = False
return spellCast
def printTables():
N = 250000 # number of seeds for each simulation
printCharge = True
printLd = True
printMagic = True
if printCharge:
'''charge range'''
#distances to check
chargeRes = list()
QSres = list()
for m in range(3,13):
#runs/seeds
res = list()
append = res.append
for n in range(N):
append(charge(M=0,distance = m,swiftStride=False))
chargeRes.append(np.mean(res)*100)
res = list()
append = res.append
for n in range(N):
append(charge(M=0,distance = m,swiftStride=True))
QSres.append(np.mean(res)*100)
if printLd:
'''Leadership tests'''
resNormal= list()
resColdBlood=list()
resReRoll = list()
resReRollCB = list()
for ld in range(2,11):
l1=list()
l2 = list()
l3 = list()
l4 = list()
for n in range(N):
l1.append(LdTest(Ld=ld,reRoll=False,coldBlood=False))
l2.append(LdTest(Ld=ld,reRoll=False,coldBlood=True))
l3.append(LdTest(Ld=ld,reRoll=True,coldBlood=False))
l4.append(LdTest(Ld=ld,reRoll=True,coldBlood=True))
resNormal.append(np.mean(l1)*100)
resColdBlood.append(np.mean(l2)*100)
resReRoll.append(np.mean(l3)*100)
resReRollCB.append(np.mean(l4)*100)
if printMagic:
'''casting tests'''
res1d6 = list()
res2d6 = list()
res3d6 = list()
res4d6 = list()
res5d6 = list()
for castValue in range(3,20):
l1=list()
l2 = list()
l3 = list()
l4 = list()
l5 = list()
for n in range(N):
l1.append(cast(dice=1,castValue=castValue))
l2.append(cast(dice=2,castValue=castValue))
l3.append(cast(dice=3,castValue=castValue))
l4.append(cast(dice=4,castValue=castValue))
l5.append(cast(dice=5,castValue=castValue))
res1d6.append(np.mean(l1)*100)
res2d6.append(np.mean(l2)*100)
res3d6.append(np.mean(l3)*100)
res4d6.append(np.mean(l4)*100)
res5d6.append(np.mean(l5)*100)
if printCharge:
print(' Charges:')
print('Charge: %s' % ', '.join('\t{:.1f}'.format(e) for e in chargeRes))
print('Swiftstride: %s' % ', '.join('\t{:.1f}'.format(e) for e in QSres) )
print('----------------------------------------------------------------------------' )
if printLd:
print(' Leadership Tests:')
print('2d6: %s' % ', '.join('\t{:.1f}'.format(e) for e in resNormal) )
print('2d6 + reroll: %s' % ', '.join('\t{:.1f}'.format(e) for e in resReRoll) )
print('d26 + Cold Blood: %s' % ', '.join('\t{:.1f}'.format(e) for e in resColdBlood))
print('d26 + Cold Blood + reroll: %s' % ', '.join('\t{:.1f}'.format(e) for e in resReRollCB) )
print('----------------------------------------------------------------------------' )
if printMagic:
print(' Chance to Pass and dispel:')
print('1d6:%s' % ', '.join('\t{:.1f}'.format(e) for e in res1d6))
print('2d6:%s' % ', '.join('\t{:.1f}'.format(e) for e in res2d6))
print('3d6:%s' % ', '.join('\t{:.1f}'.format(e) for e in res3d6))
print('4d6:%s' % ', '.join('\t{:.1f}'.format(e) for e in res4d6))
print('5d6:%s' % ', '.join('\t{:.1f}'.format(e) for e in res5d6))
printTables()
|
# import asyncio
# async def coro():
# i = 0
# while True:
# await asyncio.sleep(1)
# print(i)
# i += 1
# async def complete():
# print('complete')
# async def main():
# task = asyncio.create_task(coro())
# while True:
# await asyncio.sleep(5)
# print(task)
# task.cancel()
# await complete()
# if __name__ == "__main__":
# loop = asyncio.get_event_loop()
# loop.run_until_complete(main())
# import asyncio
# async def main():
# q = asyncio.Queue()
# await q.put((1,3))
# await q.put((2,3))
# if (1,3) in q:
# print('it is')
# else:
# print('its not')
# if __name__ == "__main__":
# loop = asyncio.get_event_loop()
# loop.run_until_complete(main())
# if __name__ == "__main__":
# import time
# start = time.time()
# count = 0
# for i in range(200000):
# if i % 123:
# count += 1
# end = time.time()
# print(count)
# print(end - start)
# import bitstring
# if __name__ == "__main__":
# a = bitstring.BitArray(10)
# a[0] = True
# a[3] = True
# a[7] = True
# print(f'{a.bin}')
# a = a.tobytes()
# print(f'{a}')
# a = bitstring.BitArray(bytes=a)
# print(f'{a.bin}')
# for idx, piece in enumerate(a):
# if piece:
# print(f'true in {idx}')
import asyncio
async def handle_echo(reader, writer):
data = await reader.read(100)
message = data.decode()
addr_repr = ':'.join(map(str, writer.get_extra_info('peername')))
print("Received %r from %s" % (message, addr_repr))
if message != 'Hello World!':
print('mismatch.')
writer.close()
return
print("Send: %r" % message)
writer.write(data)
await writer.drain()
print("Close the client socket")
writer.close()
loop = asyncio.get_event_loop()
coro = asyncio.start_server(handle_echo, '127.0.0.1', 8888, loop=loop)
server = loop.run_until_complete(coro)
# Serve requests until Ctrl+C is pressed
print('Serving on {}'.format(server.sockets[0].getsockname()))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
# Close the server
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()
|
from _typeshed import Incomplete
def node_link_data(
G,
attrs: Incomplete | None = None,
*,
source: str = "source",
target: str = "target",
name: str = "id",
key: str = "key",
link: str = "links",
): ...
def node_link_graph(
data,
directed: bool = False,
multigraph: bool = True,
attrs: Incomplete | None = None,
*,
source: str = "source",
target: str = "target",
name: str = "id",
key: str = "key",
link: str = "links",
): ...
|
from django.shortcuts import render,redirect
from .forms import git_userform
from django.http import HttpResponse
import requests
import json
from django.views.generic.base import TemplateView
def reposearch(request):
if request.method=='GET':
form=git_userform()
return render(request,'view.html',{'form':form})
if request.method=='POST':
form=git_userform(request.POST)
if form.is_valid():
git_username=form.cleaned_data.get('g_username')
user=requests.get("https://api.github.com/users/%s"%git_username)
user1=requests.get("https://api.github.com/users/%s/repos"%git_username)
repo=user1.json()
repo1=[]
for repos in repo:
if isinstance(repos,dict):
repo1.append((repos["name"],repos["language"]))
if user.status_code==200:
found=True
else:
found=False
request.session['git_username']=git_username
return render(request,'view.html',{'form':form,'git_username':git_username,'found':found,'repo':repo1})
else:
form=git_userform()
return render(request,'view.html',{'form':form})
def commithist(request,reponame):
git_user=request.session['git_username']
histreq=requests.get("https://api.github.com/repos/%s/%s/commits"%(git_user,reponame))
repohist=histreq.json()
history=[]
for keys in repohist:
history.append(keys["commit"]["committer"]["date"])
return render(request,'repo.html',{'dict':history,'git_username':git_user,'reponame':reponame})
# Create your views here.
|
from matplotlib.animation import FuncAnimation
import json
import math
from math import acos
from time import time
from ahrs.common.constants import M_PI, RAD2DEG
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import frccontrol as fct
import control as ct
from frccontrol import kalmd
altArr = None
dt = None
timeArr = None
def calculate_altitude(pressure):
# assume in layer 1
GRAVITATIONAL_ACCELERATION = -9.80665
AIR_GAS_CONSTANT = 287.053
NUMBER_OF_LAYERS = 7
MAXIMUM_ALTITUDE = 84852
MINIMUM_PRESSURE = 0.3734
LAYER0_BASE_TEMPERATURE = 288.15
LAYER0_BASE_PRESSURE = 101325
lapse_rate = [-0.0065, 0.0, 0.001, 0.0028, 0.0, -0.0028, -0.002, ]
base_altitude = [0, 11000, 20000, 32000, 47000, 51000, 71000, ]
next_base_temperature = LAYER0_BASE_TEMPERATURE
next_base_pressure = LAYER0_BASE_PRESSURE
layer_number = -1
while (layer_number < NUMBER_OF_LAYERS - 2):
layer_number = layer_number + 1
base_pressure = next_base_pressure
base_temperature = next_base_temperature
delta_z = base_altitude[layer_number + 1] - base_altitude[layer_number]
if (lapse_rate[layer_number] == 0.0):
exponent = GRAVITATIONAL_ACCELERATION * \
delta_z / AIR_GAS_CONSTANT / base_temperature
next_base_pressure = next_base_pressure * math.exp(exponent)
else:
base = (lapse_rate[layer_number] *
delta_z / base_temperature) + 1.0
exponent = GRAVITATIONAL_ACCELERATION / \
(AIR_GAS_CONSTANT * lapse_rate[layer_number])
next_base_pressure *= math.pow(base, exponent)
next_base_temperature += delta_z * lapse_rate[layer_number]
if (pressure >= next_base_pressure):
break
if (lapse_rate[layer_number] == 0.0):
coefficient = (AIR_GAS_CONSTANT /
GRAVITATIONAL_ACCELERATION) * base_temperature
altitude = base_altitude[layer_number] + \
coefficient * math.log(pressure / base_pressure)
else:
base = pressure / base_pressure
exponent = AIR_GAS_CONSTANT * \
lapse_rate[layer_number] / GRAVITATIONAL_ACCELERATION
coefficient = base_temperature / lapse_rate[layer_number]
altitude = base_altitude[layer_number] + \
coefficient * (pow(base, exponent) - 1)
return altitude
def make_goose():
# in this dataset, ay is up
global timeArr, altArr, dt, ayArr, temperature, csv
# csv = pd.read_csv("D:\\Documents\\Angry Goose TCC 5-15-21.txt")
csv = pd.read_csv("D:\\Documents\\Angry Goose StAlbans 11-20-21.txt")
# csv = pd.read_csv("D:\\Documents\\pendulum test 2.txt")
# csv = pd.read_csv("D:\\Downloads\\Flight-1-1-22-F31.csv")
# csv = pd.read_csv("D:\\Downloads\\Carby_Goose_Jan_2022.txt")
# csv = pd.read_csv("python/sensorfusion/flightdata/Goose_MDRA_11-14.csv")
timeArr = csv['time']
timeArr = timeArr / 1000
timeArr = timeArr
# Convert to mpss sans earth gravity
ayArr = -csv['ay']
# ayArr = ayArr - 1
# ayArr = ayArr * 9.81
# ayArr = csv['ay']**2+csv['ax']**2+csv['az']**2
# ayArr=np.sqrt(ayArr)
ayArr = ayArr - 1
ayArr = ayArr * 9.81
# Already in meters
altArr = csv['alt']
temperature = csv['temp'] / 100 # cenit-celcius to C
# dt = 50/1000 # ms
dt = np.mean(np.diff(timeArr))
def make_drone_goose():
# in this dataset, ay is up
global timeArr, altArr, dt, ayArr
csv = pd.read_csv("D:\\Documents\\drone test 2 12-11021.txt")
timeArr = csv['time']
timeArr = timeArr / 1000
# timeArr = timeArr - 670
# Convert to mpss sans earth gravity
# ayArr = csv['ay']
# ayArr = ayArr - 1
# ayArr = ayArr * 9.81
ayArr = csv['ay']**2+csv['ax']**2+csv['az']**2
ayArr = np.sqrt(ayArr)
ayArr = ayArr - 1
ayArr = ayArr * 9.81
# Already in meters
altArr = csv['altitude']
dt = 21/1000 # ms
def make_fcb(num=3):
global timeArr, altArr, dt, ayArr, csv
if num == 1:
# df = pd.read_csv("D:\\Downloads\\output-post.csv")
OUTPUT_POST_CSV_NAME = (
"D:\\Documents\\GitHub\\fcb-offloader-standalone\\output_data\\output-post.csv")
df = pd.read_csv(OUTPUT_POST_CSV_NAME)
elif num == 2:
df = pd.read_csv("D:\\Downloads\\fcb-06-20-2021-output-post(1).csv")
elif num == 3:
df = pd.read_csv("D:\\Downloads\\fcb-mdra-marmon-12-19-2021.csv")
elif num == 4:
df = pd.read_csv("D:\\Downloads\\magcal_raw.csv")
elif num == 5:
df = pd.read_csv("D:\\Downloads\\carbytooded.csv")
elif num == 6:
df = pd.read_csv("D:\\Downloads\\fcbv0-11-20-2021-carby.csv")
elif num == 7:
df = pd.read_csv("D:\\Downloads\\superguppy-fcb.csv")
elif num == 7:
df = pd.read_csv("python/sensorfusion/flightdata/fcb 11-14-21 trd.csv")
elif num == 8:
df = pd.read_csv(
"../pyqt_groundstation/output/LDRS-beanboozler-l265-output-post.csv")
csv = df
# print(csv)
timeArr = df["timestamp_s"] / 1 # 000
ayArr = np.abs(df["imu_accel_y_avg"]) - 9.81
# ayArr = df['imu_accel_x_avg']**2+df['imu_accel_y_avg']**2+df['imu_accel_z_avg']**2
# ayArr=np.sqrt(ayArr)
# ayArr = ayArr - 9.81
# altArr = (df["baro_temp_avg"] / -0.0065) * (1 - pow(25 / df["baro_pres_avg"][0], 287.0474909 * -0.0065 / 9.80665)) * 10
altArr = np.array([calculate_altitude(p * 101325)
for p in df["baro_pres_avg"]])
altArr = altArr - altArr[0]
csv["gps_alt"] = csv["gps_alt"] - csv["gps_alt"][0]
dt = .0155 # On average, during flight
# dt = .02 # In sim
return csv
def make_blackhole():
global timeArr, altArr, dt, ayArr, csv
# df = pd.read_csv("D:\\Downloads\\blackhole2.csv")
df = pd.read_csv("D:\\Downloads\\blackholebooster.csv")
timeArr = df["time"]
altArr = df["altitude"] * 0.3048
ayArr = np.zeros((len(timeArr), 1))
dt = np.mean(np.diff(timeArr))
csv = df
def make_line_cutter():
global timeArr, altArr, dt, ayArr
df = pd.read_csv("D:\\Documents\\GitHub\\dpf-line-cutter\\code\\launch archive\\2021-11-14 MDRA\\Cherry_flight_data.csv",
names=['state', 'time', 'pressure', 'altitude', 'avalt', 'delta-alt', 'av-delta-alt', 'temp', 'ax', 'ay', 'az', 'battsense', 'cutsense1', 'cutsense2', 'currentsense', 'photores'])
# df = pd.read_csv("D:\\Downloads\\fcb-06-20-2021-output-post(1).csv")
timeArr = df["time"] / 1000
ayArr = (df["ax"]**2+df['ay']**2+df['az']**2)**0.5 * 9.81 - 9.81
# altArr = (df["baro_temp_avg"] / -0.0065) * (1 - pow(df["baro_pres_avg"] / df["baro_pres_avg"][0], 287.0474909 * -0.0065 / 9.80665)) * 10
altArr = 44330.76 * (1.0 - (df['pressure'] / 101295)**(1.0 / 5.25588))
dt = np.mean(np.diff(timeArr))
# Our system state is [pos, vel]
# inputs are [accel]
# outputs are [pos]
# https://www.wolframalpha.com/input/?i=%28%7B%7B0%2C1%7D%2C%7B0%2C0%7D%7D+dot+%7B%7B2%7D%2C+%7B1%7D%7D+%29%2B+%28+%7B%7B0%7D%2C%7B1%7D%7D+dot+%7B3%7D%29
# x-dot = [vel ] = [0 1] * [pos] + [0] * [accel]
# [accel] [0 0] [vel] [1]
# y = [pos] = [1 0] * [pos] + [0] * [accel]
# [vel]
def make_cov_matrix(elems):
return np.diag(np.square(elems))
def do_kalman():
global uArray, buarray, xhatarr
global timeArr, altArr, dt, ayArr, xhatarr
global stateArray
global apogeeTime
apogeeTime = 0
sysc = ct.ss(np.array([[0, 1], [0, 0]]), np.array(
[[0], [1]]), np.array([1, 0]), np.array([0]))
sysd = sysc.sample(dt) # Discretize model
# sysd = ct.ss(np.array([[1, dt, dt* dt /2],[0,1, dt],[0,0,1]]), np.array([[0,0],[0,0],[0,0]]), np.array([[1,0,0],[0,0,1]]), np.array([[0, 0], [0, 0]]))
print(sysd)
# Q is our process noise covariance
# It's [pos variance, vel variance, accel variance]^t
# R is measurement noise (how sure we are about out measurement)
Q = make_cov_matrix([0.5, 3])
R = make_cov_matrix([80])
kalman_gain, P_steady = kalmd(sysd, Q, R)
# kalman_gain = np.array([[.01657], [.0934]])
print(kalman_gain)
# We assume we start at 0 position and velocity
xhatarr = []
x_hat = np.array([[0], [0]])
uArray = []
buarray = []
last_alt = 0
state = 0
stateArray = []
max_alt = 0
for (t, accel, altitude) in zip(timeArr, ayArr, altArr):
if state >= 2:
u = np.array([[0]])
else:
u = np.array([[accel]])
# uArray.append(u[0,0])
# bu = np.dot(sysd.B, u)
# buarray.append([bu[0,0], bu[1,0]])
# u = np.array([[0],[0]])
# y = np.array([[altitude], [accel]])
y = np.array([[altitude]])
# # predict
x_hat = sysd.A @ x_hat + sysd.B @ u
AO_MAX_BARO_SPEED = 200
AO_MAX_BARO_HEIGHT = 30000 * 100000
speed_distrust = x_hat[1, 0] - AO_MAX_BARO_SPEED
height_distrust = x_hat[0, 0] - AO_MAX_BARO_HEIGHT
if (speed_distrust <= 0):
speed_distrust = 0
elif (speed_distrust > height_distrust):
height_distrust = speed_distrust
if (height_distrust > 1):
height_distrust = 1
error = y - sysd.C @ x_hat - sysd.D @ u
if (height_distrust > 0):
# print(f"Speed {x_hat[1,0]} of {AO_MAX_BARO_SPEED}")
error = error * (100 - height_distrust)
# correct
x_hat += kalman_gain @ error
xhatarr.append([x_hat[0, 0], x_hat[1, 0]])
if x_hat[0, 0] > 50 and state == 0:
state = 1 # boost
elif state == 1 and max_alt - 3 > x_hat[0, 0] and x_hat[1, 0] < 0:
apogeeTime = t
state = 2 # apogee
last_alt = x_hat[0, 0]
stateArray.append(state)
max_alt = max(max_alt, x_hat[0, 0])
# Convert to NP array so we can slice
xhatarr = np.array(xhatarr)
buarray = np.array(buarray)
class NumpyEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, np.ndarray):
return obj.tolist()
return json.JSONEncoder.default(self, obj)
def do_gyro_integration(mag_data):
global csv, timeArr, orientation, dt
import ahrs.filters as filters
import ahrs.common.orientation as orient
if "wx_raw" in csv:
gyro_data = np.array(
[csv["wx_raw"] / 32.8, csv["wy_raw"] / 32.8, csv["wz_raw"] / 32.8]).T
gyro_data = gyro_data * M_PI / 180.0 # deg/s to rad/s
elif "imu1_gyro_x_real" in csv:
gyro_data = np.array([-csv["imu1_gyro_x_real"], -csv["imu1_gyro_z_real"],
csv["imu1_gyro_y_real"]]).T / 4 # /4 for sensitivity bug fix
else:
gyro_data = np.array([csv["wx"], csv["wy"], csv["wz"]]).T
gyro_data = gyro_data * M_PI / 180.0 # deg/s to rad/s
# Crappy gyro cal -- subtract out the average of the first 10
gyro_offset = [np.mean(gyro_data[:30, 0]), np.mean(
gyro_data[:30]), np.mean(gyro_data[:30, 2])]
gyro_data = gyro_data - gyro_offset
if "ax" in csv:
acc_data = np.array([-csv["ax"] * 9.81, -csv["az"]
* 9.81, csv["ay"] * 9.81]).T
else:
acc_data = np.array(
[-csv["imu1_accel_x_real"], csv["imu1_accel_z_real"], -csv["imu1_accel_y_real"]]).T
# gyro_data = gyro_data[900:,:]
if mag_data is not None:
initial_tilt = orient.ecompass(
acc_data[0], mag_data[0], frame='ENU', representation='quaternion')
else:
initial_tilt = orient.acc2q(acc_data[1, :])
plt.figure()
plt.plot(timeArr, gyro_data[:, 0], label="X")
plt.plot(timeArr, gyro_data[:, 1], label="Y")
plt.plot(timeArr, gyro_data[:, 2], label="Z")
plt.plot(timeArr, acc_data[:, 0], label="aX")
plt.plot(timeArr, acc_data[:, 1], label="aY")
plt.plot(timeArr, acc_data[:, 2], label="aZ")
plt.legend()
rotM = orient.q2R(initial_tilt)
newX = np.array([1, 0, 0]).T @ rotM
angleBetween = newX @ np.array([1, 0, 0]).T
print(f"Initial tilt: {initial_tilt} angle {acos(angleBetween) * RAD2DEG}")
# orientation = filters.Mahony(gyr=gyro_data, acc=acc_data, frequency=1.0/np.mean(np.diff(timeArr)))
# orientation = filters.Tilt(acc=acc_data)
# orientation = filters.AngularRate(gyr=gyro_data[1000:,:], q0=initial_tilt, frequency=1/dt)
orientation = filters.AngularRate(
gyr=gyro_data, q0=initial_tilt, frequency=1/dt)
import RocketEKF
from ahrs.utils.wmm import WMM
# MDRA
wmm = WMM(latitude=39.0785319, longitude=-75.87425944, height=0)
# X is north, Y is East, Z is down
# So by default, it's NED
# We want East-North-Up
m_ref = np.array([wmm.Y, wmm.X, -wmm.Z]) / 1000
print(f"Mag ref: {m_ref} microTesla")
# o2 = RocketEKF.EKF(gyr=gyro_data, mag=mag_data, frequency=1/np.mean(np.diff(timeArr)), q0=initial_tilt, m_ref=m_ref, frame='ENU')
# orientation = o2
# np.savetxt('orient.mat', json.dumps(orientation.Q.tolist())
bigarr = []
i = 0
for row in orientation.Q:
# bigarr.append([row[0], row[1], row[2], row[3], csv["high_g_accel_x_real"][i], csv["high_g_accel_y_real"][i], csv["high_g_accel_z_real"][i], timeArr[i]])
bigarr.append([row[0], row[1], row[2], row[3], timeArr[i]])
i = i + 1
bigarr = np.array(bigarr)
print(bigarr.shape)
json_dump = json.dumps(bigarr,
cls=NumpyEncoder)
# print(json_dump)
with open("orient.json", "w") as txt:
txt.write(json_dump)
np.savetxt("orient.csv", bigarr)
def plot_gyro_rates(name):
global csv, timeArr
plt.figure()
gyro_data = None
if "wx_raw" in csv:
gyro_data = np.array(
[csv["wx_raw"] / 32.8, csv["wy_raw"] / 32.8, csv["wz_raw"] / 32.8]).T
elif "wx" in csv:
gyro_data = np.array([csv["wx"], csv["wy"], csv["wz"]]).T
elif "imu1_gyro_x_real" in csv:
gyro_data = np.array(
[csv["imu1_gyro_x_real"], csv["imu1_gyro_y_real"], csv["imu1_gyro_z_real"]]).T
gyro_data = np.rad2deg(gyro_data)
gyro_data = gyro_data / 4 # Fix error in sensitivity
if gyro_data is not None:
plt.title(f"Angular rate over time for {name}")
plt.plot(timeArr, gyro_data[:, 0], label="wx (deg/s)")
plt.plot(timeArr, gyro_data[:, 1], label="wy (deg/s)")
plt.plot(timeArr, gyro_data[:, 2], label="wz (deg/s)")
plt.legend()
def plot_gyro():
global csv, timeArr, orientation
import ahrs.common.orientation as orient
euler = []
for row in orientation.Q:
# Roll is about x, pitch about y and yaw is about z
# The coordinate system appears to be NED (North-East-Down)??
# I know for sure Z axis is vertical
euler.append(orient.q2rpy(row))
euler = np.array(euler)
euler = euler * RAD2DEG
plt.figure()
plt.subplot(211)
# plt.plot(timeArr, euler[:,0], label="Roll, deg")
# plt.plot(timeArr, euler[:,1], label="Pitch, deg")
# plt.plot(timeArr, euler[:,2], label="Yaw, deg")
plt.plot(euler[:, 0], label="Roll, deg")
plt.plot(euler[:, 1], label="Pitch, deg")
plt.plot(euler[:, 2], label="Yaw, deg")
# plt.plot(csv["imu1_accel_y_real"], label="Y accel")
# plt.plot(csv["pos_z"], label="Altitude")
plt.legend()
plt.subplot(212)
# we can really just plot the orientation direction cosines
cosines = [orient.q2euler(row) for row in orientation.Q]
cosines = np.array(cosines)
plt.plot(timeArr, cosines[:, 0], label="East")
plt.plot(timeArr, cosines[:, 1], label="North")
plt.plot(timeArr, cosines[:, 2], label="Up")
# plt.plot(timeArr, csv['ax'], label="Ax, gees")
# plt.plot(timeArr, csv['ay'], label="Ay, gees")
# plt.plot(timeArr, csv['az'], label="Az, gees")
plt.legend()
def rotation_matrix(quat):
import math
w, x, y, z = quat
norm = math.sqrt(w ** 2 + x ** 2 + y ** 2 + z ** 2)
if norm == 1:
s = 2.0
elif norm > 0:
s = 2.0 / norm
else:
s = 0
xs = x * s
ys = y * s
zs = z * s
xx = x * xs
xy = x * ys
xz = x * zs
xw = w * xs
yy = y * ys
yz = y * zs
yw = w * ys
zz = z * zs
zw = w * zs
return np.array([[1 - (yy + zz), (xy - zw), (xz + yw)], [(xy + zw),
1 - (xx + zz), (yz - xw)], [(xz - yw), (yz + xw), 1 - (xx + yy)]])
def update(num, data, line):
# print(data[:2, :num])
# print(data[2, :num])
print("-------------")
line.set_data(data[:2, :num])
line.set_3d_properties(data[2, :num])
def pygame_orientation():
global orientation, line, xyzs
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.set_xlim3d(-1.2, 1.2)
ax.set_ylim3d(-1.2, 1.2)
ax.set_zlim3d(-1.2, 1.2)
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
xyzs = []
for row in orientation.Q[0:1500, :]:
xyz = rotation_matrix(row) @ np.array([[0], [-1], [0]])
xyzs.append((xyz[0, 0], xyz[1, 0], xyz[2, 0]))
xyzs = np.array(xyzs)
# data = np.array(list(gen(1000))).T
data = xyzs
line, = ax.plot(data[0, 0:1], data[1, 0:1], data[2, 0:1])
# ax.plot(xyzs[:, 0], xyzs[:, 1], xyzs[:, 2], label="[0 0 1]^T transformed by q")
ani = FuncAnimation(fig, update, 10000, fargs=(
data, line), interval=2, blit=False)
plt.show()
def plot_kalman():
global uArray, buarray, xhatarr, altArr, ayArr, timeArr, stateArray, apogeeTime, temperature, csv
print(np.max(xhatarr[:, 0]))
plt.subplot(311)
plt.title("Position (m)")
plt.plot(timeArr, altArr, label="Barometric Position")
plt.plot(timeArr, csv["gps_alt"], label="Barometric Position")
# plt.plot(timeArr, ayArr, label="Upwards acceleration",color='y')
plt.plot(timeArr, xhatarr[:, 0], label="Kalman Position")
plt.legend()
plt.axvline(x=apogeeTime, ls='--')
plt.subplot(312)
plt.title("Velocity (m/s)")
# plt.scatter(timeArr[1:], np.diff(altArr)/np.diff(timeArr), label="Velocity (dBaro/dt)")
# plt.plot(timeArr[1:], np.diff(xhatarr[:,0])/np.diff(timeArr), label="Numerical Diff Velocity")
plt.plot(timeArr, xhatarr[:, 1], label="Kalman Velocity")
# plt.plot(timeArr, ayArr, label="Upwards acceleration")
plt.legend()
plt.axvline(x=apogeeTime, ls='--')
plt.subplot(313)
plt.title("Accel (m/s/s)")
# plt.scatter(timeArr[1:], np.diff(altArr)/np.diff(timeArr), label="Velocity (dBaro/dt)")
plt.plot(timeArr, ayArr, label="Raw acceleration")
# plt.plot(timeArr, xhatarr[:,2], label="Kalman Accel")
plt.legend()
plt.axvline(x=apogeeTime, ls='--')
gyro_data = None
if "wx_raw" in csv:
gyro_data = np.array(
[csv["wx_raw"] / 32.8, csv["wy_raw"] / 32.8, csv["wz_raw"] / 32.8]).T
elif "wx" in csv:
gyro_data = np.array([csv["wx"], csv["wy"], csv["wz"]]).T
if gyro_data is not None:
plt.subplot(224)
# plt.title("Temperature (C) over time (s)")
# plt.plot(timeArr, temperature, label="Temperature (C)")
plt.title("Angular rate over time")
plt.plot(timeArr, gyro_data[:, 0], label="wx (deg/s)")
plt.plot(timeArr, gyro_data[:, 1], label="wy (deg/s)")
plt.plot(timeArr, gyro_data[:, 2], label="wz (deg/s)")
plt.xlim(apogeeTime-35, apogeeTime + 1)
plt.axvline(x=apogeeTime, ls='--')
plt.legend()
# plt.figure()
# plt.plot(timeArr, altArr, label="Barometric Position")
# plt.plot(timeArr, xhatarr[:,0], label="Kalman Position")
# plt.plot(timeArr, xhatarr[:,1], label="Kalman Velocity")
# plt.plot(timeArr, xhatarr[:,2], label="Kalman Accel")
# plt.plot(timeArr, ayArr, label="Raw acceleration")
# plt.plot(timeArr, stateArray, label="state")
# plt.legend()
def plot_altitude():
global uArray, buarray, xhatarr, altArr, ayArr, timeArr
plt.plot(timeArr, altArr)
def plot_accel():
global timeArr, csv
if "ax" in csv:
acc_data = np.array([csv["ax"] * 9.81, csv["ay"]
* 9.81, csv["az"] * 9.81]).T
else:
acc_data = np.array(
[csv["imu1_accel_x_real"], csv["imu1_accel_y_real"], csv["imu1_accel_z_real"]]).T
plt.figure()
plt.plot(timeArr, acc_data[:, 0], label="ax")
plt.plot(timeArr, acc_data[:, 1], label="ay")
plt.plot(timeArr, acc_data[:, 2], label="az")
plt.legend()
def plot_mag():
global csv, timeArr, altArr
if False:
plt.scatter(csv['imu1_mag_x'], csv['imu1_mag_y'])
plt.scatter(csv['imu1_mag_y'], csv['imu1_mag_z'])
plt.scatter(csv['imu1_mag_x'], csv['imu1_mag_z'])
plt.xlim(-3000, 3000)
plt.ylim(-3000, 3000)
# on FCBV0, we negate x and y per https://learn.sparkfun.com/tutorials/lsm9ds1-breakout-hookup-guide/all
mag_x = csv['imu1_mag_x'] * -1
mag_y = csv['imu1_mag_y'] * -1
mag_z = csv['imu1_mag_z']
min_x = min(mag_x)
max_x = max(mag_x)
min_y = min(mag_y)
max_y = max(mag_y)
min_z = min(mag_z)
max_z = max(mag_z)
print("X range: ", min_x, max_x)
print("Y range: ", min_y, max_y)
print("Z range: ", min_z, max_z)
mag_calibration = [(max_x + min_x) / 2,
(max_y + min_y) / 2, (max_z + min_z) / 2]
print("Final calibration in uTesla:", mag_calibration)
cal_mag_x = [x - mag_calibration[0] for x in mag_x]
cal_mag_y = [y - mag_calibration[1] for y in mag_y]
cal_mag_z = [z - mag_calibration[2] for z in mag_z]
if True:
plt.figure()
plt.scatter(cal_mag_x, cal_mag_y, color='r', label='XY')
plt.scatter(cal_mag_y, cal_mag_z, color='g', label='YZ')
plt.scatter(cal_mag_z, cal_mag_x, color='b', label='ZX')
plt.xlim(-3000, 3000)
plt.ylim(-3000, 3000)
plt.legend()
return np.array([cal_mag_x, cal_mag_y, cal_mag_z]).T
ax = plt.axes(projection='3d')
maxUt = 2.5
ax.set_xlim3d(-maxUt, maxUt)
ax.set_ylim3d(-maxUt, maxUt)
ax.set_zlim3d(-maxUt, maxUt)
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
# csv = csv.loc[1800:4000,:]
print(timeArr)
ax.plot(csv['imu1_mag_x_real'],
csv['imu1_mag_y_real'], csv['imu1_mag_z_real'])
ax.plot(csv['imu2_mag_x_real'],
csv['imu2_mag_y_real'], csv['imu2_mag_z_real'])
plt.figure()
plt.plot(timeArr, csv['imu2_gyro_x_real'])
plt.plot(timeArr, csv['imu2_gyro_y_real'])
plt.plot(timeArr, csv['imu2_gyro_z_real'])
# plt.plot(csv["baro_pres_avg"])
def output_mag_vec(mag):
global timeArr, csv
timeArr = timeArr-timeArr[0] - 100
# return np.array([cal_mag_x, cal_mag_y, cal_mag_z]).T
plt.figure()
plt.subplot(411)
plt.plot(timeArr, mag[:, 0], label="X, uT")
plt.plot(timeArr, mag[:, 1], label="Y, uT")
plt.plot(timeArr, mag[:, 2], label="Z, uT")
plt.xlim(25, 125)
plt.legend()
plt.subplot(412)
plt.plot(timeArr, csv["pos_z"], label="Alt, m")
plt.plot(timeArr, csv["vel_z"], label="Vel, m/s")
plt.xlim(25, 125)
plt.legend()
plt.subplot(413)
plt.plot(timeArr, csv["imu1_gyro_x_real"], label="Wx, rad/s")
plt.plot(timeArr, csv["imu1_gyro_y_real"], label="Wy, rad/s")
plt.plot(timeArr, csv["imu1_gyro_z_real"], label="Wz, rad/s")
plt.legend()
plt.xlim(25, 125)
plt.subplot(414)
plt.plot(timeArr, csv["imu1_accel_x_real"], label="Ax, m/s/s")
plt.plot(timeArr, csv["imu1_accel_y_real"], label="Ay, m/s/s")
plt.plot(timeArr, csv["imu1_accel_z_real"], label="Az, m/s/s")
plt.xlim(25, 125)
plt.legend()
np.savetxt("magvec.mat", mag)
plt.figure()
plt.title("dt, seconds")
plt.plot(timeArr[1:], np.diff(timeArr))
# plt.plot(1/np.diff(timeArr))
df = csv
# plt.subplot(212)
# plt.title("state")
# plt.scatter(timeArr, csv['state'])
plt.axvline(timeArr[np.where(df['state'] == 12)[0][0]], ls="--")
plt.axvline(timeArr[np.where(df['state'] == 7)[0][0]], ls="--")
plt.axvline(timeArr[np.where(df['state'] == 8)[0][0]], ls="--")
plt.axvline(timeArr[np.where(df['state'] == 10)[0][0]], ls="--")
plt.axvline(timeArr[np.where(df['state'] == 11)[0][0]], ls="--")
if __name__ == "__main__":
make_fcb(8)
# plot_accel()
# plot_gyro_rates("FCB (Corrected, /4)")
# make_goose()
# plot_accel()
# plot_gyro_rates("GOOSE")
# mag = plot_mag()
# make_goose()
# make_drone_goose()
# make_line_cutter()
# make_blackhole()
# output_mag_vec(mag)
do_kalman()
# do_gyro_integration(None)
plot_kalman()
# plot_gyro()
# plot_gyro_rates("FCB")
# pygame_orientation()
plt.show()
|
from substitutionkeygenerator import *
from .. import utils
import random
class PermutationKeyGenerator(SubstitutionKeyGenerator):
def __init__(self, sequence=utils.alphabet, rand_func=lambda x: x ** 5, **kwargs):
"""Similar to SubstitutionTranslator, but returns just lists"""
SubstitutionKeyGenerator.__init__(self, alphabet=sequence, rand_func=rand_func, **kwargs)
self.sequence = list(sequence)
def getRandomKey(self):
return super(PermutationKeyGenerator, self).getRandomKey(True)
def getAllKeys(self):
"""Returns all permutations in lexicographic order (according to indexing in the given sequence)"""
return super(PermutationKeyGenerator, self).getAllKeys(True)
def mutateKey(self, key):
"""Swaps random number of elements around"""
return super(PermutationKeyGenerator, self).mutateKey(key, True)
def lock(self, indx, value):
"""Lock an index of the key, so that the other functions return only keys with the set value on the given index"""
if (value not in self.alphabet):
raise ValueError("Arguments not in sequence")
self.locks[self.sequence[indx]] = value
def unlock(self, indx):
return self.locks.pop(self.sequence[indx])
|
from nameparser import HumanName
from nameparser.config import CONSTANTS
name = HumanName("Ralf Mühlenhöver, Geschäftsführer")
print(name.title)
print(name.first)
print(name.middle)
print(name.last)
|
# Generated by Django 2.1.3 on 2018-11-28 11:04
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('MyClass', '0002_adress_email_group_phone'),
]
operations = [
migrations.RenameField(
model_name='phone',
old_name='person',
new_name='person_addres',
),
]
|
from tornado.web import RequestHandler
import jsonpickle
from db.database import TraceDatabase
from trace import Trace
# POST USAGE:
# curl -v http://localhost:8888/ -X POST --data-binary '{"traceseq": 1, "customerseq": 100, "title": "post-test", "mainclass":"monitoring-manager", "subclass":"orchestrator-m" }' -H "Content-type: application/json"
class TraceHandler(RequestHandler):
def initialize(self, logger):
self.logger=logger
#sudo -u postgres psql -d e2e_trace_manager -c "select * from tb_e2e_trace_list"
#self.dbm = dbManager('e2e_trace_manager', 'e2e_trace_manager', 'nfv', 'ohhberry3333', '211.224.204.203', '5432')
traceDB = TraceDatabase()
self.dbengine = traceDB.get_engine()
def print_result(self, records):
for row in records:
print "trace_seq= %s customer_seq= %s trace_title= %s create_dttm= %s\n" % (row['trace_seq'], row['customer_seq'], row['trace_title'], row['create_dttm'])
def get(self):
trace = Trace(1, 100, 'test', 'monitoring-manager', 'orchestrator-m')
data_string= jsonpickle.encode(trace)
self.write(data_string)
traceSelectSql = "select * from tb_e2e_trace_list"
records = self.dbengine.execute(traceSelectSql)
self.print_result(records)
def post(self):
self.logger.info('POST= %s' % self.request.body)
traceReq = jsonpickle.decode(self.request.body)
trace = Trace(traceReq['traceseq'], traceReq['customerseq'], traceReq['title'], traceReq['mainclass'], traceReq['subclass'])
traceAddSql = "INSERT INTO tb_e2e_trace_list (trace_seq, customer_seq, trace_title, create_dttm) \
VALUES ( %d, %d, '%s', now())" % (trace.traceseq, trace.customerseq, trace.title)
self.logger.info("traceAddSql= %s" % traceAddSql)
self.dbengine.execute(traceAddSql)
|
from selenium import webdriver
from time import sleep
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.keys import Keys
browser = webdriver.Chrome()
browser.maximize_window()
browser.get('http://113.108.207.92:7070/TNB/login.action')
userName = browser.find_element_by_id('userName').send_keys('tnb')
password = browser.find_element_by_id('password').send_keys('1')
login = browser.find_element_by_id('login_go').click()
sleep(5)
moveto = browser.find_element_by_xpath('//*[@id="menu"]/li[4]/a')
ActionChains(browser).move_to_element(moveto).perform()
sleep(10)
pg_input = browser.find_element_by_xpath('//*[@id="menu"]/li[4]/ul/li[1]/a').click()
sleep(10)
browser.switch_to.frame('menu3001')
# 201705030100
browser.find_element_by_xpath('//*[@id="txtBarCode"]').clear()
browser.find_element_by_xpath('//*[@id="txtBarCode"]').send_keys('201705030100') # Ctrl + Alt + 向下键，复制内容到下一行
browser.find_element_by_xpath('//*[@id="txtBarCode"]').send_keys(Keys.ENTER) # Ctrl + Alt + 向下键，复制内容到下一行
browser.find_element_by_id('btnSave').click()
browser.find_element_by_id('popup_ok').click()
#logout = browser.find_element_by_link_text('注销').click()
|
# template for "Guess the number" mini-project
#run the program in codeskulptor
# input will come from buttons and an input field
# all output for the game will be printed in the console
import simplegui
import math
import random
# helper function to start and restart the game
def new_game():
print "New game. Range is [0,100) \nNumber of remaining guesses is 7"
new_game1(99)
def new_game1(range):
global secret_number
global num_guesses
global rng
rng= range
secret_number=random.randint(0,range)
if range==999:
num_guesses=10
elif range==99:
num_guesses=7
# define event handlers for control panel
def range100():
print "New game. Range is [0,100) \nNumber of remaining guesses is 7\n"
new_game1(99)
def range1000():
print "New game. Range is [0,1000) \nNumber of remaining guesses is 10\n"
new_game1(999)
def input_guess(guess):
global operand
i=0
global secret_number
global num_guesses
operand=int(guess)
print "Guess was "+guess
num_guesses=num_guesses-1
if num_guesses==0:
print "Number of remaining guesses is 0 \nYou ran out of guesses"
print "The number was ",secret_number,"\n"
i=i+1
if rng==99:
range100()
elif rng==999:
range1000()
elif num_guesses>=1:
print "Number of remaining guesses is "+str(num_guesses)
if i>=1 and (num_guesses==10 or num_guesses==7):
input_guess(guess)
else:
if secret_number<operand:
print "Lower!\n"
elif secret_number>operand:
print "Higher!\n"
else:
print "Correct!\n"
# create frame
f = simplegui.create_frame("Guess the Number",300,300)
# register event handlers for control elements and start frame
f.add_button("Range is [0,100)", range100, 100)
f.add_button("Range is [0,1000)", range1000,100)
f.add_input("Guess", input_guess, 100)
f.start()
# call new_game
new_game()
|
import time
import logging
import RPi.GPIO as GPIO
# #############################################################################
# Class: PIR
# Detects whether there has been movement around the clock, and turns the
# matrix off if there has not been any
# #############################################################################
class PIR:
def __init__(self, ledmatrix, pirpin, nomovementforseconds):
logging.info('init motion')
self.__Matrix = ledmatrix
self.__delay = nomovementforseconds
self.__pin = pirpin
GPIO.setup(self.__pin, GPIO.IN)
# -------------------------------------------------------------------------
# pir_set_matrix
# Sets up the matrix ID AFTER the PIT has been intialised
# -------------------------------------------------------------------------
def pir_set_matrix(self, ledmatrix):
self.__Matrix = ledmatrix
# -------------------------------------------------------------------------
# wait_for_no_movement
# Waits to see if there is movement within self.__delay seconds
# If there is none, fades the matrix to black and stops it from being
# updated.
# Once movement is seen, fades the screen back on.
# -------------------------------------------------------------------------
def wait_for_no_movement(self):
logging.info('Motion sensor')
if (self.__Matrix == 0):
logging.error("You must set up the matrix before using the PIR")
return
t = time.time()
screenstate = True
while True:
while (GPIO.input(self.__pin) == 0):
if ((time.time() - t) >= self.__delay and screenstate):
screenstate = False
self.__Matrix.set_draw_on_matrix(screenstate)
time.sleep(0.1)
if (not screenstate):
screenstate = True
self.__Matrix.set_draw_on_matrix(screenstate)
# Wait for 100 milliseconds
t = time.time()
time.sleep(0.1)
|
timer = 0
def on_button_pressed_a():
global timer
timer = randint(5, 15)
basic.show_icon(IconNames.CHESSBOARD)
while timer > 0:
timer += -1
basic.pause(1000)
basic.show_icon(IconNames.SKULL)
pass
input.on_button_pressed(Button.A, on_button_pressed_a)
|
import tensorflow as tf
import numpy as np
'''
f_org = open('filepath', 'r')
f_new = open('filepath', 'w')
while True:
line = f_org.readline()
if not line: break
line = line.replace('x', '1').replace('positive', '1').replace('b', '0.5').replace('o', '-1').replace('negative', '0')
f_new.write(line)
print(line)
f_org.close()
f_new.close()
'''
xy = np.loadtxt('filepath', delimiter=',', dtype=np.float32)
x_data = xy[:, 0:-1]
y_data = xy[:, [-1]]
X = tf.placeholder(tf.float32, shape=[None, 9])
Y = tf.placeholder(tf.float32, shape=[None, 1])
w1 = tf.Variable(tf.random_normal([9, 27]), name='weight1')
w2 = tf.Variable(tf.random_normal([27, 27]), name='weight2')
w3 = tf.Variable(tf.random_normal([27, 1]), name='weight3')
b1 = tf.Variable(tf.random_normal([1]), name='bias1')
b2 = tf.Variable(tf.random_normal([1]), name='bias2')
b3 = tf.Variable(tf.random_normal([1]), name='bias3')
a1 = tf.tanh(tf.matmul(X, w1) + b1)
a2 = tf.tanh(tf.matmul(a1, w2) + b2)
hypothesis = tf.sigmoid(tf.matmul(a2, w3) + b3)
cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1)
train = optimizer.minimize(cost)
predicted = tf.cast(hypothesis > 0.5, dtype=tf.float32)
accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32))
sess = tf.Session()
sess.run(tf.global_variables_initializer())
for step in range(3001):
cost_val, hy_val = sess.run([cost, train], feed_dict={X: x_data, Y: y_data})
if step % 100 == 0:
print(step, "Cost: ", cost_val)
h, c, a = sess.run([hypothesis, predicted, accuracy], feed_dict={X: x_data, Y: y_data})
print('\nHypothesis: ', h, "\nCorrect (Y): ", c, "\nAccuracy: ", a)
x_input = 0
while True:
print("player 1: 1, player 2: -1, empty: 0")
x_input = input('Input your game result: ').split(',')
x_list = list(map(float, x_input))
if len(x_list) != 9:
print('Wrong data type. pls write again')
continue
x_list = [x_list]
answer = sess.run(hypothesis, feed_dict={X: x_list})
result = 'Win' if int(answer + 0.5) else 'Lose'
print('prediction: ', answer, '\nResult: ', result)
|
from django.urls import path, include
from django.views.generic import ListView, DetailView
from telecomNews.models import Articles
from django.conf.urls.static import static
from django.conf import settings
urlpatterns = [
path('', ListView.as_view(queryset=Articles.objects.all().order_by("-date")[:20],
template_name="telecomNews/posts.html")),
path('<pk>', DetailView.as_view(model=Articles, template_name="telecomNews/post.html")),
]+ static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
|
from django.test import TestCase
from mainapp.models import Url
from mainapp.forms import ShorteningForm
# python manage.py test --pattern="tests_forms.py"
class FormTestCase(TestCase):
@classmethod
def setUpTestData(cls):
obj = Url.objects.create(target_url="https://www.evernote.com/")
obj.save()
Url.assign_shortcode(obj, "http://127.0.0.1")
class EventFormTestCase(FormTestCase):
def test_valid_form(self):
obj = Url.objects.get(pk=1)
data = {'target_url': "https://www.evernote.com/"}
form = ShorteningForm(data=data)
print(form.errors)
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data.get('target_url'), obj.target_url)
|
import boto3
region = 'us-west-2'
def account_alias():
iam_client = boto3.client('iam')
response = iam_client.list_account_aliases()["AccountAliases"][0]
return(response)
def main():
alias = account_alias()
print(alias)
if __name__ == '__main__':
main()
|
import unittest
from katas.beta.string_repeat import repeat_str
class StringRepeatTestCase(unittest.TestCase):
def test_equal_1(self):
self.assertEqual(repeat_str(4, 'a'), 'aaaa')
def test_equal_2(self):
self.assertEqual(repeat_str(3, 'hello '), 'hello hello hello ')
def test_equal_3(self):
self.assertEqual(repeat_str(2, 'abc'), 'abcabc')
|
"""
Application-specific configuration for Azzaip.
"""
from django.apps import AppConfig
class AzzaipConfig(AppConfig):
"""
Azzaip application metadata.
"""
name = 'azzaip'
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.