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 220
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 257
values | content
stringlengths 2
10.3M
| authors
listlengths 1
1
| author_id
stringlengths 0
212
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
89e8ab9227a0a50a720b819e974157d583e35762
|
b5012bfee90c3974176c76bd55c89652be441d9c
|
/hackers.py
|
59014634ed3ccebbec4acbb81d8f7ea453eaad14
|
[] |
no_license
|
Tuoppi1/School-work
|
5affeb751d46df6a584236f62f6e6fb24eb22f9a
|
d5ce3be273c644013ae0341a7776792f86e1ffed
|
refs/heads/master
| 2020-08-12T23:53:30.492774
| 2019-12-15T02:18:07
| 2019-12-15T02:18:07
| 214,868,954
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,097
|
py
|
import re
import time
import requests
import matplotlib.pyplot as plt
# This program uses a russian proxy IP address
# Because i got banned from www.iplocate.io
# Current proxy worked for me at least
# Use your default IP address by removing proxies parameter from requests.get(url,proxies).json() (line 30)
file = open("logins.txt")
hackList = []
ipAddressList = []
countryDict = {}
proxies = {"https":"195.239.86.102:45871"}
hackTimeDict = {"00":0,"01":0,"02":0,"03":0,"04":0,"05":0,"06":0,"07":0,"08":0,\
"09":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,\
"18":0,"19":0,"20":0,"21":0,"22":0,"23":0}
countryList = []
for line in file:
if "Tue Oct 2" in line:
ipAddress = re.search("\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}",line).group()
hackTime = re.search("\d+:\d+",line).group()
if ipAddress not in ipAddressList:
ipAddressList.append(ipAddress)
time.sleep(1)
hacker = requests.get("https://www.iplocate.io/api/lookup/{}".format(ipAddress)).json()
hackList.append(hacker)
try:
#print(hacker["country"])
if hacker["country"] in countryDict:
countryDict[hacker["country"]] += 1
else:
countryDict[hacker["country"]] = 1
hackTimeDict[hackTime[:-3]] += 1
except:
pass
#if len(hackList) > 15: # <-- uncomment this and break for testing purposes
#break
countryList = sorted(countryDict.items(),key=lambda x: x[1],reverse=True)
n = []
label = []
for i in countryList:
if len(n) == 10:
break
n.append(i[1])
label.append(i[0])
sortedHackTimeList = sorted(hackTimeDict.items(),key=lambda x: x[0])
n1 = []
label1 = []
for i in sortedHackTimeList:
n1.append(i[1])
label1.append(i[0])
plt.figure(figsize=(5,5))
plt.figure(1)
plt.pie(n,labels = label)
plt.savefig("hackpie.png")
plt.figure(2)
plt.figure(figsize=(10,6))
plt.bar(label1,n1)
plt.savefig("hackbar.png")
plt.show
|
[
"noreply@github.com"
] |
Tuoppi1.noreply@github.com
|
0a9807695a6b48465c8bcda0fe72456b4e3a34b2
|
284d0cfb0d62bcbd1b5ec42cdafef0ff0c776231
|
/Imaging_Jellies/src/camera_test/camera_noise_test.py
|
0d7d13e7237949eebc310b9cdc222eec31e9cf3b
|
[] |
no_license
|
nicolewxu/BE107_ProjectGroup3_Jellyfish
|
d7e082f2279fa44e024d69be48cb9f2c046db0df
|
631b59fdd02d18acbbdd9d90161fbed829def94f
|
refs/heads/master
| 2020-12-24T13:20:59.944454
| 2015-05-26T06:50:47
| 2015-05-26T06:50:47
| 35,862,589
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 6,912
|
py
|
import cv2
import os
import numpy as np
import cPickle
def main():
#move_pics()
#make_avg_background()
#find_contours_with_background()
find_contours_with_adaptive_thresholding()
find_contours_with_otsu_thresholding()
#find_contours_vanilla()
def move_pics():
pics = dict()
for folder in ['fly_with_food_stills', 'larvae_stills']:
pics[folder] = []
img_folder = 'videos_for_tracking/' + folder
for root, dirs, filenames in os.walk(img_folder):
for f in filenames:
filename = os.path.join('videos_for_tracking', folder, f)
larva_img = cv2.imread(filename, 0)
pics[folder].append(larva_img)
output_filename = os.path.join('output', folder, f)
cv2.imwrite(output_filename, larva_img)
cPickle.dump(pics, open('output/all_imgs.pickle', 'wb'))
return pics
def make_avg_background():
pics = cPickle.load(open('output/all_imgs.pickle', 'r'))
for scene in pics.keys():
# initialize accumulator destination
cumulative_img = np.float64(pics[scene][0])
cumulative_img /= 255.0
cv2.imshow('init cumulative', cumulative_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
for n in range(100):
for i in range(len(pics[scene])):
#pics[scene][i] = 255 - pics[scene][i]
#cv2.imshow('img', pics[scene][i])
#cv2.waitKey(0)
#pics[scene][i] = cv2.cvtColor(pics[scene][i], cv2.COLOR_BGR2GRAY)
cv2.accumulateWeighted(np.float64(pics[scene][i])/255.0, cumulative_img, .01)
cv2.imshow('accumulating?', cumulative_img)
cv2.waitKey(0)
output_filename = os.path.join('output', scene, 'background.jpg')
cv2.imwrite(output_filename, cumulative_img*255.0)
def find_centroids(centroid_filename, contours, img):
with open(centroid_filename, 'w') as centroid_file:
centroid_file.write("X\tY\n")
centroids = []
for fly in contours:
max_coordinates = np.amax(fly, axis=0)
min_coordinates = np.amin(fly, axis=0)
centroid = (max_coordinates + min_coordinates)/2
centroid_file.write(str(centroid[0,0]) + "\t" + str(centroid[0,1]) + "\n")
cv2.circle(img, (centroid[0,0], centroid[0,1]), 2, (0, 255, 0), -1)
centroids.append(centroid)
return centroids, img
def find_contours_with_background():
pics = cPickle.load(open('output/all_imgs.pickle', 'r'))
for scene in pics.keys():
background_filename = os.path.join('output', scene, 'background.jpg')
background_img = cv2.imread(background_filename, 0)
x = 0
for larva_grey in pics[scene]:
x += 1
no_background_img = cv2.absdiff(larva_grey, background_img)
#cv2.imshow('background-corrected', no_background_img)
#cv2.waitKey(0)
blurred = cv2.GaussianBlur(no_background_img, (5,5), 0)
ret, thresh = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)
#cv2.imshow('thresholded?', thresh)
#cv2.waitKey(0)
cv2.imwrite(os.path.join('output', scene, 'thresholded', 'thresholded_img_' + str(x) + '.jpg'), thresh)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
centroid_filename = os.path.join('output', scene, 'contours', 'background_subtraction', 'centroids_' + str(x) + '.txt')
centroids, larva_grey = find_centroids(centroid_filename, contours, larva_grey)
cv2.drawContours(larva_grey, contours, -1, (0,255,0), 1)
cv2.imshow('contours', larva_grey)
cv2.waitKey(0)
cv2.imwrite(os.path.join('output', scene, 'contours', 'background_subtraction', 'contour_of_img_' + str(x) + ".jpg"), larva_grey)
def find_contours_with_adaptive_thresholding():
pics = cPickle.load(open('output/all_imgs.pickle', 'r'))
for scene in pics.keys():
background_filename = os.path.join('output', scene, 'background.jpg')
background_img = cv2.imread(background_filename, 0)
x = 0
for larva_grey in pics[scene]:
x += 1
blurred = cv2.GaussianBlur(larva_grey, (5,5), 0)
thresh = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 3, 2)
#ret, thresh = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)
cv2.imshow('thresholded?', thresh)
#cv2.waitKey(0)
cv2.imwrite(os.path.join('output', scene, 'thresholded', 'thresholded_img_' + str(x) + '.jpg'), thresh)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
centroid_filename = os.path.join('output', scene, 'contours', 'adaptive_threshold', 'centroids_' + str(x) + '.txt')
centroids, larva_grey = find_centroids(centroid_filename, contours, larva_grey)
cv2.drawContours(larva_grey, contours, -1, (0,255,0), 1)
cv2.imshow('contours', larva_grey)
#cv2.waitKey(0)
cv2.imwrite(os.path.join('output', scene, 'contours', 'adaptive_threshold', 'contour_of_img_' + str(x) + ".jpg"), larva_grey)
def find_contours_with_otsu_thresholding():
pics = cPickle.load(open('output/all_imgs.pickle', 'r'))
for scene in pics.keys():
background_filename = os.path.join('output', scene, 'background.jpg')
background_img = cv2.imread(background_filename, 0)
x = 0
for larva_grey in pics[scene]:
x += 1
#thresh = cv2.adaptiveThreshold(larva_grey, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 3, 2)
blurred = cv2.GaussianBlur(larva_grey, (5,5), 0)
ret, thresh = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)
cv2.imshow('thresholded?', thresh)
#cv2.waitKey(0)
cv2.imwrite(os.path.join('output', scene, 'thresholded', 'thresholded_img_' + str(x) + '.jpg'), thresh)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
centroid_filename = os.path.join('output', scene, 'contours', 'otsu_threshold', 'centroids_' + str(x) + '.txt')
centroids, larva_grey = find_centroids(centroid_filename, contours, larva_grey)
cv2.drawContours(larva_grey, contours, -1, (0,255,0), 1)
cv2.imshow('contours', larva_grey)
#cv2.waitKey(0)
cv2.imwrite(os.path.join('output', scene, 'contours', 'otsu_threshold', 'contour_of_img_' + str(x) + ".jpg"), larva_grey)
def find_contours_vanilla():
pics = cPickle.load(open('output/all_imgs.pickle', 'r'))
for scene in pics.keys():
x = 0
for larva_grey in pics[scene]:
x += 1
larva_grey = 255-larva_grey
ret, thresh = cv2.threshold(larva_grey, 127, 255, cv2.THRESH_BINARY)
cv2.imshow('original', larva_grey)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
cv2.imshow('original 2', larva_grey)
centroid_filename = os.path.join('output', scene, 'contours', 'vanilla', 'centroids_' + str(x) + '.txt')
centroids, larva_grey = find_centroids(centroid_filename, contours, larva_grey)
cv2.drawContours(larva_grey, contours, -1, (0,255,0), 1)
cv2.imshow('contours', larva_grey)
cv2.waitKey(0)
cv2.imwrite(os.path.join('output', scene, 'contours', 'vanilla', 'contour_of_img_' + str(x) + ".jpg"), larva_grey)
main()
|
[
"nicolewxu@dhcp-7-245.caltech.edu"
] |
nicolewxu@dhcp-7-245.caltech.edu
|
db2053ff6088956d37ca5a3a875a95d76e48daa4
|
e08f10a7469868f44a3cc5278033d4fd19b36598
|
/collection-old.py
|
f9b812733fa7253152c1f837adeda1807b1fea90
|
[
"MIT"
] |
permissive
|
neal-rogers/baseball-card-inventory
|
4498cadd444755afcf8b3d7c1ee2825264de40ce
|
9940ba746072892961b7ade586e63f7deb26d2e6
|
refs/heads/master
| 2020-12-25T23:18:48.513129
| 2017-02-19T00:45:32
| 2017-02-19T00:45:32
| 34,287,900
| 1
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,874
|
py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""This is a simple baseball card inventory system."""
import graphx, csv, json, os
def check_file(self):
"""Args:
None.
Returns:
something() = stuff.
Examples:
>>>
"""
if os.path.isfile('data\cards.json'):
print 'Loading database.'
jsoncards = open('data\cards.json', 'a')
else:
print 'No file found, importing from CSV...'
csvcards = open('data\cards.csv', 'r')
fields = (
"UID",
"PLAYER",
"POSITION",
"BRAND",
"CID",
"YEAR",
"CONDITION",
"SOLD",
"VALUE"
)
csv_rdr = csv.DictReader(csvcards, fields)
jsoncards = open('data\cards.json', 'a')
with jsoncards:
for row in csv_rdr:
json.dump(row, jsoncards)
jsoncards.write('\n')
csvcards.close()
print 'Import complete.'
#csvfile = open('cards.csv', 'r')
#jsonfile = open('cards.json', 'w')
ask_1 = raw_input('What would you like to do?, Update, Search, or Report?: ').title()
if ask_1 == 'Update':
reply_1 = 'Add'
elif ask_1 == 'Search' or 'Report':
reply_1 = 'Search By'
ask_2 = raw_input('{A}? '.format(A=reply_1)).title()
if ask_2 == 'Yes' or 'Add':
raw_input('Enter player name, position, team: ')
elif ask_2 == 'Search' or 'Report':
reply_2 = 'Search By'
uid += len()
# new_card = {'uid': , 'player': , 'position': , 'cid': , 'year': , 'condition':}
sreply = 'Add'
elif fask == 'Search' or 'Report':
sreply = 'Search By'
nask = raw_input('{A}? '.format(A=freply)).title()
"""
"""
if ask_3 == 'Report':
pass
# def c_sold ():
def main():
print graphx.BANNER
if __name__ == '__main__':
main()
|
[
"neal.rogers@spsmail.cuny.edu"
] |
neal.rogers@spsmail.cuny.edu
|
97fe4b22a0d5bd7822f3f5e943e4fad93fc6b66d
|
9de9e636cf845c681fdbf1c6c058cc69d5d05da5
|
/IO/Writer.py
|
5ed136de1753e4ebcc60d562cf59aef0e316b217
|
[] |
no_license
|
dxcv/Portfolio-Management-1
|
4278eebb5c91a3a02ea76398b681ef9dc5beeb1f
|
9f188aeab3177d0a13bae32e3a318a4f18642a3c
|
refs/heads/master
| 2020-12-05T21:48:37.690004
| 2019-01-03T01:34:41
| 2019-01-03T01:34:41
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,408
|
py
|
# -*- coding: utf-8 -*-
"""
Created on Thu Nov 15 12:51:44 2018
Write to excel function
@author: ACM05
"""
import pandas as pd
import IO.IO_Tools_Func as IO_TF
class Writer():
def __init__( self,
f_name ):
""" Writer object for
defined format
"""
self.f_name = f_name
self.writer = pd.ExcelWriter( f_name,
engine='xlsxwriter',
options={'nan_inf_to_errors': True})
self.book = self.writer.book
""" Loading all format settings
"""
self.header_format = self.book.add_format(IO_TF.get_format())
self.ticker_format = self.book.add_format(IO_TF.get_ticker_format())
self.thousand_format = self.book.add_format(IO_TF.get_num_k_format())
self.bold_format = self.book.add_format(IO_TF.get_format_bold())
self.pct_format = self.book.add_format(IO_TF.get_num_pct_format())
self.BPS_format = self.book.add_format(IO_TF.get_num_BPS_format())
def add_sheet( self,
s_name ):
""" Add sheets into this workbook
Please pre define all worksheet names
"""
workbook = self.writer.book
worksheet = workbook.add_worksheet( s_name )
self.writer.sheets[s_name] = worksheet
def write_ticker( self,
s_name,
i_row,
i_col,
i_string ):
""" Write tickers with defined formatting
"""
worksheet = self.writer.sheets[s_name]
worksheet.write( i_row, i_col,
i_string, self.ticker_format )
def write_raw( self,
s_name,
i_row,
i_col,
i_string ):
""" Write string into given file with sheet name
raw data without design
"""
worksheet = self.writer.sheets[s_name]
worksheet.write( i_row, i_col,
i_string, self.bold_format )
def write_df( self,
i_row,
i_col,
df,
s_name ):
""" Write to excel given
file name and sheet name
"""
""" Step one load formatting
"""
worksheet = self.writer.sheets[s_name]
""" Step two write df into this work sheet
"""
df = df.reset_index()
df = IO_TF.Add_Sum_Row_df(df, "ALL")
df.to_excel( self.writer,
s_name,
startrow = i_row,
startcol = i_col,
index = False )
for col, value in enumerate(df.columns.values):
worksheet.write( i_row, col+i_col,
value, self.header_format )
for col, value in enumerate(df.iloc[-1]):
if value == value:
worksheet.write( i_row+df.shape[0], col+i_col,
value, self.bold_format )
else:
worksheet.write( i_row+df.shape[0], col+i_col,
"", self.bold_format )
def close( self ):
self.writer.save()
|
[
"noreply@github.com"
] |
dxcv.noreply@github.com
|
bf96a09a63a04c6313e4811b636283950b097e22
|
ef0aed73e99562d86250e13eb9d0bcf2cf6b2229
|
/main.py
|
1d89ca3a79e87bdc03d5f61afbed1c0ec61977d5
|
[] |
no_license
|
HuesodeDurazno/MagicPoemModel
|
38869dfed4ea82515eddf9207693b68facfcbd5d
|
30b3058c342c8051cf1084cf4c208b0b0c5f3576
|
refs/heads/main
| 2023-09-01T10:43:34.852352
| 2021-10-26T22:42:38
| 2021-10-26T22:42:38
| 421,604,862
| 1
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 172
|
py
|
import os
import numpy as np
import re
import spacy
import urllib.request
def poem_generator(file, word, n_sents=4):
nlp = spacy.load("es")
init_str = nlp(word)
|
[
"ivanwhite230@gmail.com"
] |
ivanwhite230@gmail.com
|
16e6aad20191bccd6294c9578cb217ce79720b51
|
a6beb7c6901d49493fe8c2bd7e001464af799a19
|
/jd_goods/jd_goods/spiders/get_goods
|
67742aab9a5aecacc3c624e207892303cc41b2c3
|
[] |
no_license
|
RokieProgramer/Scrapy_demo
|
72b5b4f1ffa3abcf5cf7f5f138f1b1d4eda81fb3
|
3f5ebb70f975aa86494339f5ad43a9a3ff11bc35
|
refs/heads/master
| 2020-05-30T09:40:26.703200
| 2019-05-31T23:49:33
| 2019-05-31T23:49:33
| 189,652,087
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 5,572
|
# -*- coding: utf-8 -*-
import scrapy
from jd_goods.items import JdGoodsItem
from urllib.parse import urlencode
import re
import json
class GetGoodsSpider(scrapy.Spider):
name = 'get_goods'
# allowed_domains = ['jd.com']
# https://search.jd.com/Search?keyword=huwwei_p30pro
def start_requests(self):
# keyword = input("请输入想要查询的物品：")
# max_page = int(input('请输入想要爬取的最大页面数：'))
keyword = 'iphone X'
max_page = 1
url = 'https://search.jd.com/Search?'
for page in range(1, max_page+1):
url += urlencode({'keyword':keyword, 'enc': 'utf-8', 'page': page})
yield scrapy.Request(url)
def parse(self, response):
node_list = response.xpath('//div[@id="J_goodsList"]//div[@class="p-name p-name-type-2"]')
# print('***'*20)
# print(len(node_list))
# print('***' * 20)
for index, node in enumerate(node_list):
# 产品详情页面
goods_url = 'https:' + node.xpath('./a/@href').extract_first()
goods_url = response.urljoin(goods_url)
yield scrapy.Request(url=goods_url,callback=self.parse_goods_page)
#
def parse_goods_page(self, response):
'''
解析产品详情页面,解析颜色，获取当前一个颜色的所有机型的页面
:param response:
:return:
'''
item = JdGoodsItem()
describition = response.xpath(
'//div[@class="sku-name"]/text()').extract()
describition = ''.join(describition)
item['describition'] = describition.strip()
item = JdGoodsItem()
describition = response.xpath(
'//div[@class="sku-name"]/text()').extract()
describition = ''.join(describition)
item['describition'] = describition.strip()
node_list = response.xpath('//div[@id="choose-attr-1"]/div/div')
for node in node_list:
item['color'] = node.xpath('./a/i/text()').extract_first().strip()
# 颜色对应的页面链接
data_sku = node.xpath('./@data-sku').extract_first()
next_url = 'https://item.jd.com/{data_sku}.html'.format(data_sku=data_sku)
next_url = response.urljoin(next_url)
yield scrapy.Request(url=next_url,
meta={'item': item},
callback=self.parse_goods_page_1)
def parse_goods_page_1(self, response):
'''
当前颜色对应的内存+rom版本对应机型页面
:param response:
:return:
'''
item = response.meta['item']
node_list = response.xpath('//div[@id="choose-attr-2"]/div/div')
for node in node_list:
item['memories'] = node.xpath('./a/text()').extract_first().strip()
# 内存+ROM对应的页面链接
data_sku = node.xpath('./@data-sku').extract_first()
next_url = 'https://item.jd.com/{data_sku}.html'.format(
data_sku=data_sku)
next_url = response.urljoin(next_url)
yield scrapy.Request(next_url,
meta={'item': item},
callback=self.parse_goods_page_2)
def parse_goods_page_2(self, response):
'''
机型颜色，内存，ROM固定，获取套餐版本页面链接
:param response:
:return:
'''
item = response.meta['item']
node_list = response.xpath('//div[@id="choose-attr-3"]/div/div')
for node in node_list:
item['version'] = node.xpath('./a/text()').extract_first().strip()
# 套餐版本对应的页面链接
data_sku = node.xpath('./@data-sku').extract_first()
item['id'] = data_sku
next_url = 'https://item.jd.com/{data_sku}.html'.format(
data_sku=data_sku)
next_url = response.urljoin(next_url)
yield scrapy.Request(next_url,
meta={'item': item},
callback=self.parse_goods_page_3)
def parse_goods_page_3(self, response):
'''
颜色，内存+ROM，套餐版本都以确定，获取产品图片链接
:param response:
:return:
'''
item = response.meta['item']
# 产品价格
price= response.xpath('//span[@class="p-price"]/span/text()').extract()
# 包含所有当前颜色对应的产品图片
img_node_list = response.xpath('//ul[@class="lh"]/li')
img_list = []
for node in img_node_list:
img_source = node.xpath('./img/@src').extract_first()
img_url = re.sub('\d{1}\/\w{1}\d{2,3}\w{1}\d{2,3}\w{1}', '0/', img_source)
img_url = 'http:' + img_url
img_list.append(img_url)
item['img_url'] = img_list
url = "https://p.3.cn/prices/mgets?callback=&skuIds=J_" + item['id']
url = response.urljoin(url)
yield scrapy.Request(url, meta={'item': item}, callback=self.parse_price)
def parse_price(self, response):
'''
获取价格
:param response:
:return:
'''
item = response.meta['item']
price_str = response.body
price_str = price_str.decode('utf-8')
pattern = re.compile('"p":"(.*)"}')
result = re.findall(pattern, price_str)
print('价格是：', result[0])
item['price'] = '￥' + result[0]
yield item
|
[
"noreply@github.com"
] |
RokieProgramer.noreply@github.com
|
|
a596bb3c9d9652d2ae7143f07e2a8838190af2e0
|
08b9e2128236a37df530d6afa5d127b7d2a28b95
|
/test/test.py
|
85bff6c475551aa6698d5c9525f433377c736b53
|
[] |
no_license
|
glebLit/Chat
|
c1889679ae3989efdc313a4fede5cadba94a91c0
|
271866dd1841235ba5e856cd14cb32627a6e91ac
|
refs/heads/master
| 2021-08-23T22:06:12.105637
| 2017-12-06T19:42:59
| 2017-12-06T19:42:59
| 109,710,943
| 1
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,149
|
py
|
#!/usr/bin/env python
import unittest
import urllib2
import time
from flask import Flask
from flask_socketio import SocketIO, emit
from socketIO_client import SocketIO, LoggingNamespace
from socketio import packet
import socket
app = Flask(__name__)
class FlaskTests(unittest.TestCase):
global result
result = urllib2.urlopen("http://localhost:5000/")
def setUp(self):
self.app = app.test_client()
self.app.testing = True
def test_home_status_code200(self):
self.assertEqual(result.code,200)
def test_html (self):
result = urllib2.urlopen("http://localhost:5000/")
self.assertEqual(result.read()[1:46], '!DOCTYPE html>\n<html lang="en">\n <head>\n ')
def test_send_msg(self):
socketIO = SocketIO('localhost', 5000)
socketIO.emit('my event', {'message': 'test', "user_name": 'test'})
pkt = packet.Packet()
self.assertEqual(pkt.packet_type, packet.EVENT)
self.assertTrue(socketIO.connected)
def test_connected(self):
socketIO = SocketIO('localhost', 5000)
self.assertTrue(socketIO.connected)
def test_disconnectsd(self):
socketIO = SocketIO('localhost', 5000)
socketIO.disconnect()
self.assertFalse(socketIO.connected)
def test_wait(self):
socketIO = SocketIO('localhost', 5000)
socketIO.emit('wait_with_disconnect')
timeout_in_seconds = 5
start_time = time.time()
socketIO.wait(timeout_in_seconds)
self.assertTrue(time.time() - start_time-1 < timeout_in_seconds)
def test_recieve_msg(self):
global msg
def on_aaa_response(*args):
global msg
msg = args[0]
def on_connect():
print('connect')
socketIO = SocketIO('localhost', 5000)
socketIO.on('connect', on_connect)
socketIO.on('my response', on_aaa_response)
socketIO.emit('my event', {'message': 'test', "user_name": 'test'})
socketIO.wait(seconds=1)
self.assertEqual(msg, {u'message': u'test', u'user_name': u'test'})
def test_delete_client(self):
global msg
def on_aaa_response(*args):
global msg
msg = args[0]
def on_connect():
print('connect')
socketIO = SocketIO('localhost', 5000)
socketIO.on('connect', on_connect)
socketIO.on('my response', on_aaa_response)
socketIO.emit('my event', {'data': u'Anonimus Disconnected'})
socketIO.wait(seconds=1)
self.assertEqual(msg, {u'message': u'Anonimus left chat room', u'user_name': u'server'})
def test_new_client(self):
global msg
def on_aaa_response(*args):
global msg
msg = args[0]
def on_connect():
print('connect')
socketIO = SocketIO('localhost', 5000)
socketIO.on('connect', on_connect)
socketIO.on('my response', on_aaa_response)
socketIO.emit('my event', {u'data': u'User Connected'})
socketIO.wait(seconds=1)
self.assertEqual(msg, {u'message': u'One more user!', u'user_name': u'server'})
def setDown(self):
pass
if __name__== '__main__':
unittest.main()
|
[
"gleb19960@yandex.ru"
] |
gleb19960@yandex.ru
|
d0fd9ae97dd8894464641a2387bc5db31a6ea3a3
|
04bd3387ed96a9856c14f76e3022171305203a72
|
/GetPopuler.py
|
348fc46c31c5691ec2af8fdeaedfdaec2f02e79d
|
[] |
no_license
|
Yashwant94308/ATG-Selenium
|
bb3fff41b642951db3b5ab605d524ddcee4794f1
|
39424bee93e49f752105dd35311c2569e1a2de43
|
refs/heads/master
| 2023-05-26T04:36:58.998935
| 2021-05-29T08:34:26
| 2021-05-29T08:34:26
| 371,921,460
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 249
|
py
|
import requests, json
response = requests.get(
'https://www.flickr.com/services/rest/?method=flickr.photos.getPopular&api_key=22a1377a56b4c384b61b723a80a73492'
'&user_id=193065083%40N04&format=json&nojsoncallback=1')
print(response.json())
|
[
"yashwant94308@gmail.com"
] |
yashwant94308@gmail.com
|
6c5fcdc365a2d9524863e685c0e18db9824f2d75
|
4856abe62782bbd1c1f56758ad949aea785b65af
|
/game_functions.py
|
3c52d29a2ad1738466abe44261960c24e91cad60
|
[] |
no_license
|
theVidVid/Alien_Invasion
|
fc8196d67b3658403297ca3b39133b4c5c73f511
|
6b47032e540be96d16af0f1f9b60a9f6f3f60543
|
refs/heads/master
| 2020-04-18T20:29:55.248742
| 2019-03-13T21:11:00
| 2019-03-13T21:11:00
| 167,739,600
| 4
| 1
| null | 2019-03-06T19:49:48
| 2019-01-26T21:14:10
|
Python
|
UTF-8
|
Python
| false
| false
| 11,928
|
py
|
import sys
from time import sleep
import pygame
from bullet import Bullet
from alien import Alien
# The sys module is used to exit the game when the quits.
# The pygame module contains the functionality needed to make a game.
def check_events(ai_settings, screen, stats, sb, play_button, ship, aliens,
bullets):
"""Respond to keypresses and mouse events."""
for event in pygame.event.get():
if event.type == pygame.QUIT:
save_high_score(stats, sb)
pygame.quit()
sys.exit()
# KEYDOWN signifies the pressing of a key
elif event.type == pygame.KEYDOWN:
check_keydown_events(event, ai_settings, screen, stats, sb,
ship, bullets)
# KEYUP signifies the release of a pressed key
elif event.type == pygame.KEYUP:
check_keyup_events(event, ship)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
check_play_button(ai_settings, screen, stats, sb, play_button,
ship, aliens, bullets, mouse_x, mouse_y)
def check_play_button(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets, mouse_x, mouse_y):
"""Start a new game when the player clicks Play button."""
button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
if button_clicked and not stats.game_active:
# Load the game's song
ai_settings.game_song = pygame.mixer.music.load("GameSong/Grind.ogg")
ai_settings.game_song = pygame.mixer.music.play(-1)
# Reset the game settings.
ai_settings.initialize_dynamic_settings()
# Hide the mouse cursor.
pygame.mouse.set_visible(False)
# Reset the game statistics.
stats.reset_stats()
stats.game_active = True
# Reset the scoreboard images.
sb.prep_score()
sb.prep_high_score()
sb.prep_level()
sb.prep_ships()
# Empty the list of aliens and bullets.
aliens.empty()
bullets.empty()
# Create a new fleet and center the ship.
create_fleet(ai_settings, screen, ship, aliens)
ship.center_ship()
def check_keydown_events(event, ai_settings, screen, stats, sb, ship, bullets):
"""Respond to keypresses."""
if event.key == pygame.K_RIGHT:
# Move the ship to the right.
ship.moving_right = True
elif event.key == pygame.K_LEFT:
# Move the ship to the left.
ship.moving_left = True
elif event.key == pygame.K_SPACE:
# Fires a bullet.
fire_bullet(ai_settings, screen, ship, bullets)
elif event.key == pygame.K_p:
# Entering the letter 'p' pauses the game.
pause_game(event, ai_settings, screen, stats, sb, ship, bullets)
elif event.key == pygame.K_u:
# Entering the letter 'u' unpauses the game.
unpause_game(event, ai_settings, screen, stats, sb, ship, bullets)
elif event.key == pygame.K_q:
# Entering the letter 'q' quits the game.
save_high_score(stats, sb)
pygame.quit()
sys.exit()
def fire_bullet(ai_settings, screen, ship, bullets):
"""Fire a bullet if limit hasn't been reached yet."""
# Create a new bullet and add it to bullets group.
if len(bullets) < ai_settings.bullets_allowed:
new_bullet = Bullet(ai_settings, screen, ship)
bullets.add(new_bullet)
ai_settings.bullet_sound.play()
def pause_game(event, ai_settings, screen, stats, sb, ship, bullets):
"""Puts the game in a pause state."""
if stats.game_active == True:
# Load pause sound clip.
ai_settings.pause_in.play()
# Pause the game's song
ai_settings.game_song = pygame.mixer.music.load("GameSong/Grind.ogg")
ai_settings.game_song = pygame.mixer.music.pause()
# Set game state to False.
stats.game_active = False
def unpause_game(event, ai_settings, screen, stats, sb, ship, bullets):
"""Returns the game back to previous state."""
if stats.game_active == False:
# Set game state to True
stats.game_active = True
# Load the unpause sound clip.
ai_settings.pause_out.play()
# Play the game's song
ai_settings.game_song = pygame.mixer.music.load("GameSong/Grind.ogg")
ai_settings.game_song = pygame.mixer.music.play(-1)
def check_keyup_events(event, ship):
"""Respond to key releases."""
if event.key == pygame.K_RIGHT:
# The ship stops moving to the right.
ship.moving_right = False
elif event.key == pygame.K_LEFT:
# The ship stops moving to the left.
ship.moving_left = False
def update_bullets(ai_settings, screen, stats, sb, ship, aliens, bullets):
"""Update position of bullets and get rid of old bullets"""
# Update bullet positions.
bullets.update()
# Get rid of bullets that have disappeared.
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
check_bullet_alien_collisions(ai_settings, screen, stats, sb, ship,
aliens, bullets)
def check_bullet_alien_collisions(ai_settings, screen, stats, sb, ship,
aliens, bullets):
"""Respond to bullet-alien collisions."""
# Remove any bullets and aliens that have collided.
collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)
if collisions:
for aliens in collisions.values():
stats.score += ai_settings.alien_points * len(aliens)
sb.prep_score()
ai_settings.destroyed_alien.play()
check_high_score(stats, sb)
if len(aliens) == 0:
# Load level cleared sound clip
ai_settings.new_level.play()
# If the entire fleet is destroyed, start a new level.
bullets.empty()
ai_settings.increase_speed()
# Increase level.
stats.level += 1
sb.prep_level()
create_fleet(ai_settings, screen, ship, aliens)
def update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button):
"""Update images on the screen and flip to the new screen."""
# Redraw the screen during each pass through the loop.
screen.fill(ai_settings.bg_color)
# Redraw all bullets behind ship and aliens.
for bullet in bullets.sprites():
bullet.draw_bullet()
ship.blitme()
aliens.draw(screen)
# Draw the score information.
sb.show_score()
# Draw the play button if the game is inactive.
if not stats.game_active:
play_button.draw_button()
# Make the most recently drawn screen visible.
pygame.display.flip()
def get_number_aliens_x(ai_settings, alien_width):
"""Determing the number of aliens that fit in a row."""
available_space_x = ai_settings.screen_width - 2 * alien_width
number_aliens_x = int(available_space_x / (2 * alien_width))
return number_aliens_x
def get_number_rows(ai_settings, ship_height, alien_height):
"""Determine the number of rows of aliens that fit on the screen."""
available_space_y = (ai_settings.screen_height -
(3 * alien_height) - ship_height)
number_rows = int(available_space_y / (2 * alien_height))
return number_rows
def create_alien(ai_settings, screen, aliens, alien_number, row_number):
"""Create an alien and place it in the row."""
alien = Alien(ai_settings, screen)
# Spacing between each alien is equal to one alien width.
alien_width = alien.rect.width
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
aliens.add(alien)
def create_fleet(ai_settings, screen, ship, aliens):
"""Create a full fleet of aliens."""
# Create an alien and find the number of aliens in a row.
alien = Alien(ai_settings, screen)
number_aliens_x = get_number_aliens_x(ai_settings, alien.rect.width)
number_rows = get_number_rows(ai_settings, ship.rect.height,
alien.rect.height)
# Create the fleet of aliens.
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
create_alien(ai_settings, screen, aliens, alien_number,
row_number)
def check_fleet_edges(ai_settings, aliens):
"""Respond appropriately if any aliens have reached an edge."""
for alien in aliens.sprites():
if alien.check_edges():
change_fleet_direction(ai_settings, aliens)
break
def change_fleet_direction(ai_settings, aliens):
"""Drop the entire fleet and change the fleet's direction."""
for alien in aliens.sprites():
alien.rect.y += ai_settings.fleet_drop_speed
ai_settings.fleet_direction *= -1
def ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets):
"""Respond to ship being hit by alien."""
if stats.ships_left > 0:
# Reduce the number of ships left
stats.ships_left -= 1
# Load ship collision sound
ai_settings.ship_collision.play()
# Stop game music
ai_settings.game_song = pygame.mixer.music.load("GameSong/Grind.ogg")
ai_settings.game_song = pygame.mixer.music.stop()
# Update scoreboard
sb.prep_ships()
# Empty the list of aliens and bullets.
aliens.empty()
bullets.empty()
# Plays level refresh sound clip.
ai_settings.level_refresh.play()
# Plays the game song again from the beginning.
ai_settings.game_song = pygame.mixer.music.play(-1)
# Create a new fleet and center the ship.
create_fleet(ai_settings, screen, ship, aliens)
ship.center_ship()
# Pause.
sleep(1.5)
else:
ai_settings.game_song = pygame.mixer.music.stop()
ai_settings.game_over.play()
stats.game_active = False
pygame.mouse.set_visible(True)
def check_aliens_bottom(ai_settings, screen, stats, sb, ship, aliens,
bullets):
"""Check if any aliens have reached the bottom of the screen."""
screen_rect = screen.get_rect()
for alien in aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
#Treat this the same as if the ship got hit.
ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets)
break
def update_aliens(ai_settings, screen, stats, sb, ship, aliens, bullets):
"""
Check if the fleet is at an edge,
and then update the positions of all aliens in the fleet.
"""
check_fleet_edges(ai_settings, aliens)
aliens.update()
# Look for alien-ship collisions
if pygame.sprite.spritecollideany(ship, aliens):
ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets)
# Look for aliens hitting the bottom of the screen
check_aliens_bottom(ai_settings, screen, stats, sb, ship, aliens, bullets)
def check_high_score(stats, sb):
"""Check to see if there's a new high score."""
if stats.score > stats.high_score:
stats.high_score = stats.score
sb.prep_high_score()
def save_high_score(stats, sb):
"""Saves the highest score to a .txt file."""
save_file = "GameSaveData/high_score.txt"
high_score = round(stats.high_score, -1)
saved_high_score = str(high_score)
with open(save_file, 'w') as f_obj:
f_obj.write(saved_high_score)
|
[
"ianjvidaurre@gmail.com"
] |
ianjvidaurre@gmail.com
|
174769dec8a2daec7c96b080ca6fe9f8c1de0b45
|
22af8fd63f53ead6cf92fd1628025d95859f0942
|
/emplay/wsgi.py
|
bc70109ee95562f413bf5ce87b1880b3b69f8b6e
|
[] |
no_license
|
alok162/EMPLAY-PRO
|
dd2e076ce381182719f599c23f5bc402c4629d93
|
345fae1c41067c674de542450b011967b9f2328c
|
refs/heads/master
| 2020-03-19T17:04:47.598527
| 2018-06-13T05:11:02
| 2018-06-13T05:11:02
| 136,743,323
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 389
|
py
|
"""
WSGI config for emplay 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/1.9/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "emplay.settings")
application = get_wsgi_application()
|
[
"alok@Aloks-MacBook-Pro.local"
] |
alok@Aloks-MacBook-Pro.local
|
ca06edde0b5cfd9aac6613d1fe1529f2a76675e1
|
ad23346ae1a2c47446c7ef3363ac28192a7598ad
|
/rover_ws/build/catkin_tools_prebuild/catkin_generated/pkg.installspace.context.pc.py
|
a9c0976f9c91a358d3ddc0f7899fed4f0abe8126
|
[] |
no_license
|
michaeldibono/mini-rover-backup
|
5c24e307e9a546bbdf7371b2a684f6cc006af4ab
|
1d9fb172c75289eb69fc22d2bc28030d1a138e5e
|
refs/heads/master
| 2021-01-18T18:36:43.353374
| 2017-08-16T18:15:20
| 2017-08-16T18:15:20
| 100,519,468
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 390
|
py
|
# generated from catkin/cmake/template/pkg.context.pc.in
CATKIN_PACKAGE_PREFIX = ""
PROJECT_PKG_CONFIG_INCLUDE_DIRS = "".split(';') if "" != "" else []
PROJECT_CATKIN_DEPENDS = "".replace(';', ' ')
PKG_CONFIG_LIBRARIES_WITH_PREFIX = "".split(';') if "" != "" else []
PROJECT_NAME = "catkin_tools_prebuild"
PROJECT_SPACE_DIR = "/home/robotics/git/rover_ws/install"
PROJECT_VERSION = "0.0.0"
|
[
"yetan@fiu.edu"
] |
yetan@fiu.edu
|
c088978c79af6296316fa521727b2ebf9bb34d07
|
291c7ed825161973a2d8742f2f180f04ce6e2689
|
/website/__init__.py
|
a55432fa42f2f76214b396a4257247662bb44e9c
|
[] |
no_license
|
opoweiluo/E-commerce-for-small-business
|
ec1f870d7cadaffdcfe449e5b51e09a05c3a8f5b
|
2ab617e1814259aac689579025c6af4775e4181b
|
refs/heads/main
| 2022-12-27T00:33:14.023612
| 2020-10-13T01:42:51
| 2020-10-13T01:42:51
| 302,741,684
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 629
|
py
|
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_bootstrap import Bootstrap
from flask_login import LoginManager
from flask_bcrypt import Bcrypt
import pymysql
pymysql.install_as_MySQLdb()
app = Flask(__name__)
app.secret_key = 'david'
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:root@localhost/data'
app.config['SQLALCHEMY_TRACK_MODIFICATION'] = False
bcrypt = Bcrypt(app)
bootstrap = Bootstrap(app)
db = SQLAlchemy(app)
login_manager = LoginManager(app)
login_manager.init_app(app)
login_manager.login_view = "login"
login_manager.session_protection = "strong"
from website import routes
|
[
"noreply@github.com"
] |
opoweiluo.noreply@github.com
|
b6f35c1a1ea83e61d21732c084d936b0869d821b
|
401f694fd838a88b7782ab3fb80fe687a0268082
|
/InterpreterDebugger/demo_script.py
|
9a30fc19b36c28932359006b406607b0405fef40
|
[
"MIT",
"Python-2.0"
] |
permissive
|
rockobonaparte/cloaca
|
8871f46ebcd1d018be2a61b5775daa65444ee0eb
|
f2b28cb77faaeca736bb0cf286361dd96f362789
|
refs/heads/master
| 2022-10-22T08:46:36.872543
| 2022-10-08T19:21:06
| 2022-10-08T19:21:06
| 175,341,337
| 4
| 4
| null | 2020-05-15T11:57:02
| 2019-03-13T03:42:17
|
C#
|
UTF-8
|
Python
| false
| false
| 65
|
py
|
import heapq
heapq.heapify([0, 9, 1, 8, 7, 3])
print("Done!")
|
[
"adam.preble@gmail.com"
] |
adam.preble@gmail.com
|
5ddbda28127ab2fb18249701f06df9c1649219a4
|
8fe781f8ac5b1c1d5214ac5a87c5ad855f791a6d
|
/src/clean_data.py
|
90720e0134fea7776aa816fbd08598bb52e51b1b
|
[] |
no_license
|
ternaus/kaggle_ultrasound
|
fabf45b89f5ab0888bb22e9b5205d90b14ce8f06
|
2d688d0cea8e2b1651980e972b1d6400b797c70b
|
refs/heads/master
| 2021-01-11T15:48:19.835115
| 2016-08-20T01:47:37
| 2016-08-20T01:47:37
| 64,818,757
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,349
|
py
|
from __future__ import division
"""
This script makes train data less noisy in a way:
Finds similar images assigns to these clusters of images max mask
"""
import networkx as nx
import os
import pandas as pd
from tqdm import tqdm
from PIL import Image
import glob
import pandas as pd
import cv2
import os
import numpy as np
from pylab import *
from tqdm import tqdm
from scipy.cluster.hierarchy import dendrogram, linkage
from scipy.spatial.distance import pdist, squareform
image_rows = 420
image_cols = 580
data_path = '../data'
train_data_path = os.path.join(data_path, 'train')
images = os.listdir(train_data_path)
total = len(images) / 2
imgs = np.ndarray((total, 1, image_rows, image_cols), dtype=np.uint8)
imgs_mask = np.ndarray((total, 1, image_rows, image_cols), dtype=np.uint8)
i = 0
print('-'*30)
print('Creating training images...')
print('-'*30)
for image_name in tqdm(images):
if 'mask' in image_name:
continue
image_mask_name = image_name.split('.')[0] + '_mask.tif'
img = cv2.imread(os.path.join(train_data_path, image_name), cv2.IMREAD_GRAYSCALE)
img_mask = cv2.imread(os.path.join(train_data_path, image_mask_name), cv2.IMREAD_GRAYSCALE)
img = np.array([img])
img_mask = np.array([img_mask])
imgs[i] = img
imgs_mask[i] = img_mask
i += 1
print('Loading done.')
train_ids = [x for x in images if 'mask' not in x]
train = pd.DataFrame()
train['subject'] = map(lambda x: int(x.split('_')[0]), train_ids)
train['filename'] = train_ids
train['image_num'] = map(lambda x: int(x.split('.')[0].split('_')[1]), train_ids)
imgs_flat = np.reshape(imgs, (5635, 420*580))
for subject in train['subject'].unique():
a = imgs_flat[(train['subject'] == subject).astype(int).values == 1]
b = squareform(pdist(a))
graph = []
for i in range(1, 2000):
for j in range(i + 1, 120):
if (b < 5000)[(i, j)]:
graph += [(i, j)]
G = nx.Graph()
G.add_edges_from(graph)
connected_components = list(map(list, nx.connected_component_subgraphs(G)))
clusters = pd.DataFrame(zip(range(len(connected_components), connected_components)),
columns=['cluster_name', 'components'])
temp = pd.DataFrame()
temp['image_num'] = train.loc[(train['subject'] == subject), 'image_num']
temp['subject'] = subject
|
[
"iglovikov@gmail.com"
] |
iglovikov@gmail.com
|
204a504cca4f179ed50d214b89f4d43b0f58d0eb
|
9a8878b48bafaac3877a2354e070b85dd7ec00f0
|
/EDPC/B_frog2.py
|
77d8b927688d8ba2a9cdf4b512d7e3a9e2ea5864
|
[] |
no_license
|
ikikohei/atcoder
|
5505506a20f15cb32821d43b592e3fc9ee44dafe
|
9fe585e8554cd19a9d04aa4d9c2e7531e6586fcb
|
refs/heads/master
| 2023-05-31T22:01:01.734021
| 2021-06-26T14:13:02
| 2021-06-26T14:13:02
| 311,360,312
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 679
|
py
|
def DPmethodForFrog2(N,h,K):
max_val = 10000000000
dp = [max_val]*(10**5 + 1)
dp[0] = 0
for i in range(N-1):
# if i+1 <= K:
# for j in range(i+1):
# if dp[i+1] > dp[j]+abs(h[i+1] - h[j]):
# dp[i+1] = dp[j] + abs(h[i+1]-h[j])
# else:
t = min(i+1,K)
for l in range(i+1-t,i+1):
if dp[i+1] > dp[l] + abs(h[i+1] - h[l]):
dp[i+1] = dp[l] + abs(h[i+1]-h[l])
return dp
def main():
N, K = map(int,input().split())
hight = list(map(int,input().split()))
dp = DPmethodForFrog2(N,hight,K)
print(dp[N-1])
if __name__=='__main__':
main()
|
[
"i.k0712r@gmail.com"
] |
i.k0712r@gmail.com
|
633f383970cec190025bf934ec1d356e6c1d9a65
|
3823bfba09bbb1bc0f525a241283df3cb6b97615
|
/scrapyprj/replay/ZipUtility.py
|
742983d59edfb0b637490abcd6254bdb2f2d1a06
|
[] |
no_license
|
alexmason528/torforum_crawler
|
ed3a585dd7b454ad71b021f3014f40a48b38c1e9
|
70964905d79818501c9fc32d3e6417dcc6eaa828
|
refs/heads/master
| 2020-03-19T01:04:25.914342
| 2018-05-29T18:24:36
| 2018-05-29T18:24:36
| 135,520,458
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 7,584
|
py
|
import os
import sys
import stat
from os.path import abspath
import fnmatch
import collections
import errno
try:
import zlib
del zlib
_ZLIB_SUPPORTED = True
except ImportError:
_ZLIB_SUPPORTED = False
try:
import bz2
del bz2
_BZ2_SUPPORTED = True
except ImportError:
_BZ2_SUPPORTED = False
try:
from pwd import getpwnam
except ImportError:
getpwnam = None
try:
from grp import getgrnam
except ImportError:
getgrnam = None
def _make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_run=0,
owner=None, group=None, logger=None):
"""Create a (possibly compressed) tar file from all the files under
'base_dir'.
'compress' must be "gzip" (the default), "bzip2", or None.
'owner' and 'group' can be used to define an owner and a group for the
archive that is being built. If not provided, the current owner and group
will be used.
The output tar file will be named 'base_name' + ".tar", possibly plus
the appropriate compression extension (".gz", or ".bz2").
Returns the output filename.
"""
if compress is None:
tar_compression = ''
elif _ZLIB_SUPPORTED and compress == 'gzip':
tar_compression = 'gz'
elif _BZ2_SUPPORTED and compress == 'bzip2':
tar_compression = 'bz2'
else:
raise ValueError("bad value for 'compress', or compression format not "
"supported : {0}".format(compress))
compress_ext = '.' + tar_compression if compress else ''
archive_name = base_name + '.tar' + compress_ext
archive_dir = os.path.dirname(archive_name)
if archive_dir and not os.path.exists(archive_dir):
if logger is not None:
logger.info("creating %s", archive_dir)
if not dry_run:
os.makedirs(archive_dir)
# creating the tarball
import tarfile # late import so Python build itself doesn't break
if logger is not None:
logger.info('Creating tar archive')
uid = _get_uid(owner)
gid = _get_gid(group)
def _set_uid_gid(tarinfo):
if gid is not None:
tarinfo.gid = gid
tarinfo.gname = group
if uid is not None:
tarinfo.uid = uid
tarinfo.uname = owner
return tarinfo
if not dry_run:
tar = tarfile.open(archive_name, 'w|%s' % tar_compression)
try:
tar.add(base_dir, filter=_set_uid_gid)
finally:
tar.close()
return archive_name
def _call_external_zip(base_dir, zip_filename, verbose=False, dry_run=False):
# XXX see if we want to keep an external call here
if verbose:
zipoptions = "-r"
else:
zipoptions = "-rq"
from distutils.errors import DistutilsExecError
from distutils.spawn import spawn
try:
spawn(["zip", zipoptions, zip_filename, base_dir], dry_run=dry_run)
except DistutilsExecError:
# XXX really should distinguish between "couldn't find
# external 'zip' command" and "zip failed".
raise ExecError, \
("unable to create zip file '%s': "
"could neither import the 'zipfile' module nor "
"find a standalone zip utility") % zip_filename
def _make_zipfile(base_name, base_dir, verbose=0, dry_run=0, logger=None):
"""Create a zip file from all the files under 'base_dir'.
The output zip file will be named 'base_name' + ".zip". Uses either the
"zipfile" Python module (if available) or the InfoZIP "zip" utility
(if installed and found on the default search path). If neither tool is
available, raises ExecError. Returns the name of the output zip
file.
"""
zip_filename = base_name + ".zip"
archive_dir = os.path.dirname(base_name)
if archive_dir and not os.path.exists(archive_dir):
if logger is not None:
logger.info("creating %s", archive_dir)
if not dry_run:
os.makedirs(archive_dir)
# If zipfile module is not available, try spawning an external 'zip'
# command.
try:
import zlib
import zipfile
except ImportError:
zipfile = None
if zipfile is None:
_call_external_zip(base_dir, zip_filename, verbose, dry_run)
else:
if logger is not None:
logger.info("creating '%s' and adding '%s' to it",
zip_filename, base_dir)
if not dry_run:
with zipfile.ZipFile(zip_filename, "w",
compression=zipfile.ZIP_DEFLATED,
allowZip64=True) as zf:
path = os.path.normpath(base_dir)
if path != os.curdir:
zf.write(path, path)
if logger is not None:
logger.info("adding '%s'", path)
for dirpath, dirnames, filenames in os.walk(base_dir):
for name in sorted(dirnames):
path = os.path.normpath(os.path.join(dirpath, name))
zf.write(path, path)
if logger is not None:
logger.info("adding '%s'", path)
for name in filenames:
path = os.path.normpath(os.path.join(dirpath, name))
if os.path.isfile(path):
zf.write(path, path)
if logger is not None:
logger.info("adding '%s'", path)
return zip_filename
_ARCHIVE_FORMATS = {
'tar': (_make_tarball, [('compress', None)], "uncompressed tar file"),
'zip': (_make_zipfile, [], "ZIP file")
}
def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
dry_run=0, owner=None, group=None, logger=None):
"""Create an archive file (eg. zip or tar).
'base_name' is the name of the file to create, minus any format-specific
extension; 'format' is the archive format: one of "zip", "tar", "gztar",
or "bztar". Or any other registered format.
'root_dir' is a directory that will be the root directory of the
archive; ie. we typically chdir into 'root_dir' before creating the
archive. 'base_dir' is the directory where we start archiving from;
ie. 'base_dir' will be the common prefix of all files and
directories in the archive. 'root_dir' and 'base_dir' both default
to the current directory. Returns the name of the archive file.
'owner' and 'group' are used when creating a tar archive. By default,
uses the current owner and group.
"""
save_cwd = os.getcwd()
if root_dir is not None:
if logger is not None:
logger.debug("changing into '%s'", root_dir)
base_name = os.path.abspath(base_name)
if not dry_run:
os.chdir(root_dir)
if base_dir is None:
base_dir = os.curdir
kwargs = {'dry_run': dry_run, 'logger': logger}
try:
format_info = _ARCHIVE_FORMATS[format]
except KeyError:
raise ValueError, "unknown archive format '%s'" % format
func = format_info[0]
for arg, val in format_info[1]:
kwargs[arg] = val
if format != 'zip':
kwargs['owner'] = owner
kwargs['group'] = group
try:
filename = func(base_name, base_dir, **kwargs)
finally:
if root_dir is not None:
if logger is not None:
logger.debug("changing back to '%s'", save_cwd)
os.chdir(save_cwd)
return filename
|
[
"steven@gilligan.io"
] |
steven@gilligan.io
|
d47dec240304cb46afa238c6d1e46db1d150dbf4
|
8d9e9f5e3246ea3c682b81c6a8c9578dd4e0666b
|
/max_soft_function.py
|
272135a948561debcd22f51eb1c589849c64aa25
|
[] |
no_license
|
defunSM/python-machine-learning
|
f9df9e32b8c28b58410203a2300f31935f6477b5
|
21eb73491e0526b6b654df00a70fe66869837b23
|
refs/heads/master
| 2021-01-12T08:58:07.509854
| 2017-06-01T11:22:15
| 2017-06-01T11:22:15
| 76,738,388
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 320
|
py
|
#!/usr/bin/env python
import sys, os
import numpy as np
def maxsoftfunc(x):
return np.exp(x) / np.sum(np.exp(x))
def main():
array = [0.1, 1.1, 2.1]
ans = maxsoftfunc(array)
print(ans)
total = 0
for i in ans:
total += i
print(total)
if __name__=="__main__":
main()
|
[
"sxh8083@g.rit.edu"
] |
sxh8083@g.rit.edu
|
bcf521a2c46390f05edb564682e5fe27c896efd1
|
7a1085aa658114bacc3889c1c7d92d1d6e411159
|
/thread_cls.py
|
06dbbfe502d83a277367c7634480f01650c20699
|
[] |
no_license
|
huahuijay/class3
|
cc66956ba13006e832a722aff560225df9c5b3f2
|
0551f4a64f5748d396d44f0915e5f9fea110f966
|
refs/heads/master
| 2021-01-11T02:00:20.122088
| 2016-10-13T15:03:01
| 2016-10-13T15:03:01
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 622
|
py
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
import Queue
import threading
import time
ip_queue = Queue.Queue()
class Ping(object):
def __call__(self):
while 1:
if not ip_queue.qsize():
break
ip = ip_queue.get()
time.sleep(1)
print ip
if __name__ == '__main__':
for i in range(254):
ip = '192.168.1.%s' % (i + 1)
ip_queue.put(ip)
threads = []
for i in range(50):
t = threading.Thread(target=Ping())
threads.append(t)
for t in threads:
t.start()
for t in threads:
t.join()
|
[
"peng.luo@idiaoyan.com"
] |
peng.luo@idiaoyan.com
|
3a5877287dae4f76c16aa6d37576640de2e97602
|
127cdebd60c1c439f559c1f711d071c0d920d131
|
/leilei/cainiao.py
|
d88ffe7d7fa247568fd80458973cfb4e750a4fe7
|
[] |
no_license
|
fei2yi/mytoos
|
b13660af90b2a4029bbb9fd292961d8007e856c8
|
9901e33a0a19f1ac0bf19f7b7c7b2eb0e58b96b0
|
refs/heads/master
| 2020-04-08T18:27:59.262780
| 2019-05-16T03:45:02
| 2019-05-16T03:45:02
| 159,609,149
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,127
|
py
|
import xlrd
from win32com import client as wc
from docx import Document
kinship,amend = {},{}
name,num,mynum,col_index,margin,mf_list,ROW = [],[],[],[],[],[],[]
# def doSaveAas():
# word = wc.Dispatch('Word.Application')
# doc = word.Documents.Open(u'aaaa.doc') # 目标路径下的文件
# doc.SaveAs(u'E:\\bin\\tuokoulv\\aaaa.docx', 12, False, "", True, "", False, False, False, False) # 转化后路径下的文件
# doc.Close()
# word.Quit()
path = 'aaaa.docx'
document = Document(path) #读入文件
tables = document.tables #获取文件中的表格集
table1 = tables[2]
for row in range(1,len(table1.rows)):
kinship[table1.cell(row,0).text] = table1.cell(row,2).text
print('kinship',kinship)
table = tables[-2 ]#获取文件中的第一个表格
for row in range(0,len(table.rows)):#从表格第二行开始循环读取表格数据
if row == 0:
for col in range(0, len(table.columns)):
name.append(table.cell(row,col).text)
for col in range(3, len(table.columns)):
if table.cell(row,col).text != '':
num.append(table.cell(row,col).text)
mynum.append(table.cell(row,col).text)
elif table.cell(row,col).text == '':
num.append(num[-1])
pre = ''
lis_ind = []
print('num',num)
for i, vvv in enumerate(num):
if kinship[vvv] != '胚胎':
continue
elif vvv != pre:
lis_ind = []
lis_ind.append(i + 3)
col_index.append(lis_ind)
else:
lis_ind.append(i + 3)
pre = vvv
temp = []
# print('col_index1',col_index)
for clid, cl in enumerate(col_index):
if clid == len(col_index) - 1:
temp.append(cl)
else:
temp.append(cl[:-1])
margin.append(cl[-2])
amend [cl[-2]] = mynum[clid]
col_index = temp
print('col_index',col_index)
#cell(i,0)表示第(i+1)行第1列数据，以此类推
elif row == 1:
for col in range(0, len(table.columns)):
if col < 3:
ROW.append('')
else:
ROW.append(table.cell(row,col).text)
print('ROW', ROW)
MF_ = []
for i, vvv in enumerate(ROW):
if vvv:
MF_.append(vvv[0])
elif not vvv and MF_:
mf_list.append(MF_)
MF_ = []
if i == len(ROW) - 1:
mf_list.append(MF_)
print('mf_list',mf_list)
else:
rews_h = []
xf = []
for h, vh in enumerate(ROW):
# print('vh',vh)
# print('rows',rows)
xf = table.cell(row,h)
print(type(xf))
print(xf.background)
# bgx = xfx.background.pattern_colour_index
# if bgx == 10:
# rews_h.append(1)
# elif vh == '?':
# rews_h.append(2)
# else:
# rews_h.append(0)
# base_.append(rews_h)
# doSaveAas()
|
[
"415923506@qq.com"
] |
415923506@qq.com
|
ac8bb2b49f625d413a32f8fef679bc03ce802ab6
|
ade22d64b99e7306eaeaf06684cc9c4f2d539881
|
/oscquintette/tests/v1/test_plugin.py
|
36de987851507a942e89237853e783acf38e25f1
|
[
"Apache-2.0"
] |
permissive
|
dtroyer/osc-quintette
|
59204e4ad2e25be237fb3ec13cbb5087518197d6
|
e37585936b1db9e87ab52e11e714afaf167a0039
|
refs/heads/master
| 2020-04-04T22:57:54.745055
| 2015-01-15T06:42:16
| 2015-01-15T06:42:16
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,266
|
py
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
import sys
from oscquintette.tests import base
from oscquintette.tests import fakes
from oscquintette.v1 import plugin
# Load the plugin init module for the plugin list and show commands
import oscquintette.plugin
plugin_name = 'oscquintette'
plugin_client = 'oscquintette.plugin'
class FakePluginV1Client(object):
def __init__(self, **kwargs):
#self.servers = mock.Mock()
#self.servers.resource_class = fakes.FakeResource(None, {})
self.auth_token = kwargs['token']
self.management_url = kwargs['endpoint']
class TestPluginV1(base.TestCommand):
def setUp(self):
super(TestPluginV1, self).setUp()
self.app.client_manager.oscquintette = FakePluginV1Client(
endpoint=fakes.AUTH_URL,
token=fakes.AUTH_TOKEN,
)
# Get a shortcut to the Service Catalog Mock
#self.catalog_mock = self.app.client_manager.identity.service_catalog
#self.catalog_mock.reset_mock()
class TestPluginList(TestPluginV1):
def setUp(self):
super(TestPluginList, self).setUp()
self.app.ext_modules = [
sys.modules[plugin_client],
]
# Get the command object to test
self.cmd = plugin.ListPlugin(self.app, None)
def test_plugin_list(self):
arglist = []
verifylist = []
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
collist = ('Name', 'Versions', 'Module')
self.assertEqual(columns, collist)
datalist = ((
plugin_name,
oscquintette.plugin.API_VERSIONS.keys(),
plugin_client,
), )
self.assertEqual(tuple(data), datalist)
class TestPluginShow(TestPluginV1):
def setUp(self):
super(TestPluginShow, self).setUp()
self.app.ext_modules = [
sys.modules[plugin_client],
]
# Get the command object to test
self.cmd = plugin.ShowPlugin(self.app, None)
def test_plugin_show(self):
arglist = [
plugin_name,
]
verifylist = [
('name', plugin_name),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
# DisplayCommandBase.take_action() returns two tuples
columns, data = self.cmd.take_action(parsed_args)
collist = ('1', 'module', 'name')
self.assertEqual(columns, collist)
datalist = (
oscquintette.plugin.API_VERSIONS['1'],
plugin_client,
plugin_name,
)
self.assertEqual(data, datalist)
|
[
"dtroyer@gmail.com"
] |
dtroyer@gmail.com
|
13cd0c8c3642448ab20d30e377b9836c2e2b3b0f
|
7a4ed01a40e8d79126b26f5e8fca43c8e61e78fd
|
/Python Built-in Modules/Python Itertools Module/1.Infinite Iterators/1.3.repeat()/1.Example_Of_repeat.py
|
b1c087d52f7e27726d3536cbc8a9c1f00b84432f
|
[] |
no_license
|
satyam-seth-learnings/python_learning
|
5a7f75bb613dcd7fedc31a1567a434039b9417f8
|
7e76c03e94f5c314dcf1bfae6f26b4a8a6e658da
|
refs/heads/main
| 2023-08-25T14:08:11.423875
| 2021-10-09T13:00:49
| 2021-10-09T13:00:49
| 333,840,032
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 102
|
py
|
from itertools import repeat
print ("Printing the numbers repeatedly : ")
print (list(repeat(25, 4)))
|
[
"satyam1998.1998@gmail.com"
] |
satyam1998.1998@gmail.com
|
dd84a0764d1cd38b85cddd32caf67859a5427497
|
4ac77337083c7fdb28a901831003cfd0e0ef7bf1
|
/any_urlfield/models/fields.py
|
2d6a67b84cb2f887d661bd1a22600a432304957f
|
[
"Apache-2.0"
] |
permissive
|
borgstrom/django-any-urlfield
|
deb6a10b87c26f53bb3ca5085d486238ab6c2a6c
|
3f97bfd628a5770268b715ee8f796aaab89cf841
|
refs/heads/master
| 2020-12-11T02:13:14.725873
| 2013-12-12T21:55:12
| 2013-12-12T21:55:12
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 4,655
|
py
|
"""
Custom model fields to link to CMS content.
"""
from django.core.exceptions import ValidationError
from django.core.validators import URLValidator
from django.db import models
from any_urlfield.models.values import AnyUrlValue
from any_urlfield.registry import UrlTypeRegistry
class AnyUrlField(models.CharField):
"""
A CharField that can either refer to a CMS page ID, or external URL.
.. figure:: /images/anyurlfield1.*
:width: 363px
:height: 74px
:alt: AnyUrlField, with external URL input.
.. figure:: /images/anyurlfield2.*
:width: 290px
:height: 76px
:alt: AnyUrlField, with internal page input.
By default, the ``AnyUrlField`` only supports linking to external pages.
To add support for your own models (e.g. an ``Article`` model),
include the following code in :file:`models.py`:
.. code-block:: python
from any_urlfield.models import AnyUrlField
AnyUrlField.register_model(Article)
Now, the ``AnyUrlField`` offers users a dropdown field to directly select an article.
By default, it uses a :class:`django.forms.ModelChoiceField` field with a :class:`django.forms.Select` widget
to render the field. This can be customized using the ``form_field`` and ``widget`` parameters:
.. code-block:: python
from any_urlfield.models import AnyUrlField
from any_urlfield.forms import SimpleRawIdWidget
AnyUrlField.register_model(Article, widget=SimpleRawIdWidget(Article))
Now, the ``Article`` model will be displayed as raw input field with a browse button.
"""
__metaclass__ = models.SubfieldBase
_static_registry = UrlTypeRegistry() # Also accessed by AnyUrlValue as internal field.
def __init__(self, *args, **kwargs):
if not kwargs.has_key('max_length'):
kwargs['max_length'] = 300
super(AnyUrlField, self).__init__(*args, **kwargs)
@classmethod
def register_model(cls, ModelClass, form_field=None, widget=None, title=None, prefix=None):
"""
Register a model to use in the URL field.
This function needs to be called once for every model
that should be selectable in the URL field.
:param ModelClass: The model to register.
:param form_field: The form field class used to render the field.
:param widget: The widget class, can be used instead of the form field.
:param title: The title of the model, by default it uses the models ``verbose_name``.
:param prefix: A custom prefix for the model in the serialized database format. By default it uses "appname.modelname".
"""
cls._static_registry.register(ModelClass, form_field, widget, title, prefix)
def formfield(self, **kwargs):
# Associate formfield.
# Import locally to avoid circular references.
from any_urlfield.forms.fields import AnyUrlField as AnyUrlFormField
kwargs['form_class'] = AnyUrlFormField
kwargs['url_type_registry'] = self._static_registry
if kwargs.has_key('widget'):
del kwargs['widget']
return super(AnyUrlField, self).formfield(**kwargs)
def to_python(self, value):
if isinstance(value, AnyUrlValue):
return value
# Convert the string value
if value is None:
return None
return AnyUrlValue.from_db_value(value, self._static_registry)
def get_prep_value(self, value):
if isinstance(value, basestring):
# Happens with south migration
return value
elif value is None:
return None if self.null else ''
else:
# Convert back to string
return value.to_db_value()
def value_to_string(self, obj):
# For dumpdata
value = self._get_val_from_obj(obj)
return self.get_prep_value(value)
def validate(self, value, model_instance):
# Final validation of the field, before storing in the DB.
super(AnyUrlField, self).validate(value, model_instance)
if value:
if value.type_prefix == 'http':
validate_url = URLValidator()
validate_url(value.type_value)
elif value.type_value:
if not value.exists():
raise ValidationError(self.error_messages['invalid_choice'] % value.type_value)
# Tell South how to create custom fields
try:
from south.modelsinspector import add_introspection_rules
add_introspection_rules([], [
"^" + __name__.replace(".", "\.") + "\.AnyUrlField",
])
except ImportError:
pass
|
[
"vdboor@edoburu.nl"
] |
vdboor@edoburu.nl
|
7b1ce87dae5357070654d64c13e0421c247e54da
|
51f886e82c1b670d2202e9e2dee9ae7e776f55ad
|
/HITB-XCTF 2018/WEB/Python's revenge/run.py
|
ff9357baaba52f64c3568293733c5bb94d5dd212
|
[] |
no_license
|
kankanhua/CTFS
|
e2249699c0c8096b3362fd7b79add6fa897fffa9
|
2ea1cedbd124e9136e28ad77d5173524a90ee0b3
|
refs/heads/master
| 2020-04-03T01:19:05.281002
| 2018-07-09T13:20:57
| 2018-07-09T13:20:57
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 80
|
py
|
#!flask/bin/python
from app import *
if __name__ == "__main__":
app.run()
|
[
"523279238@qq.com"
] |
523279238@qq.com
|
b5ffffc779bb9a663018d7d61a89415f02b6c32a
|
3f9163cc45befbc20b19a19bf1fd875b483c2965
|
/python/paddle/distributed/passes/auto_parallel_gradient_merge.py
|
bc40dad8ac0d9a69f37ef6d6704bd644b87522cc
|
[
"Apache-2.0"
] |
permissive
|
forschumi/Paddle
|
27926b1ddb76be08dc3f768df787fc9a4078f8e4
|
58d2949d6d2a1689e17527fb501d69c3501adf9f
|
refs/heads/develop
| 2022-07-04T03:07:52.446858
| 2022-06-05T11:44:04
| 2022-06-05T11:44:04
| 83,878,029
| 0
| 0
| null | 2017-03-04T08:11:50
| 2017-03-04T08:11:49
| null |
UTF-8
|
Python
| false
| false
| 14,250
|
py
|
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
from collections import OrderedDict
from typing import List, Tuple, Dict, Any
import paddle
from paddle.framework import core
from paddle.fluid.framework import program_guard, device_guard
from paddle.fluid import unique_name, layers
from paddle.fluid.clip import append_gradient_clip_ops
from .pass_base import PassBase, PassType, register_pass
from paddle.distributed.auto_parallel.utils import set_var_dist_attr
from paddle.distributed.auto_parallel.utils import naive_set_dist_op_attr_for_program_by_mesh_and_mapping
from paddle.distributed.auto_parallel.process_group import get_world_process_group
world_process_group = get_world_process_group()
def _is_the_backward_op(op):
OP_ROLE_KEY = core.op_proto_and_checker_maker.kOpRoleAttrName()
OpRole = core.op_proto_and_checker_maker.OpRole
return OP_ROLE_KEY in op.attr_names and \
int(op.all_attrs()[OP_ROLE_KEY]) & int(OpRole.Backward)
def _is_the_optimizer_op(op):
OP_ROLE_KEY = core.op_proto_and_checker_maker.kOpRoleAttrName()
OpRole = core.op_proto_and_checker_maker.OpRole
return OP_ROLE_KEY in op.attr_names and \
int(op.all_attrs()[OP_ROLE_KEY]) & int(OpRole.Optimize)
def _remove_and_get_optimizer_op(main_program, dist_context):
# 1 create tmp block
# 2 mv optimizer op from global program to tmp block
# 3 del the op from dist_context
from paddle.distributed.fleet.meta_optimizers.common import OpRole
main_block = main_program.global_block()
temp_block = main_program._create_block()
removed_op_idx = []
optimize_ops_desc = []
for idx, op in enumerate(main_block.ops):
if _is_the_optimizer_op(op):
# append optimizer op to tmp block
new_op_desc = temp_block.desc.append_op()
new_op_desc.copy_from(op.desc)
optimize_ops_desc.append(new_op_desc)
removed_op_idx.append(idx)
# del op from dist_context
if dist_context:
dist_context.del_dist_op_for_program(op)
for idx in removed_op_idx[::-1]:
main_block._remove_op(idx)
return optimize_ops_desc
def _remove_op_role_var(param, grad):
op_maker = core.op_proto_and_checker_maker
op = grad.op
if op.has_attr(op_maker.kOpRoleVarAttrName()):
op._remove_attr(op_maker.kOpRoleVarAttrName())
def _get_gm_cond_var(main_program, k_steps, dist_context):
main_block = main_program.global_block()
# Add const var
k_step_var = layers.create_global_var(name="gradient_merge_k",
shape=[1],
value=int(k_steps),
dtype='int32',
persistable=True,
force_cpu=True)
set_var_dist_attr(dist_context, k_step_var, [-1], world_process_group.ranks)
zero_var = layers.create_global_var(name="gradient_merge_zero",
shape=[1],
value=int(0),
dtype='int32',
persistable=True,
force_cpu=True)
set_var_dist_attr(dist_context, zero_var, [-1], world_process_group.ranks)
# Add step var & cond var
step_var = layers.create_global_var(name="gradient_merge_step",
shape=[1],
value=int(0),
dtype='int32',
persistable=True,
force_cpu=True)
set_var_dist_attr(dist_context, step_var, [-1], world_process_group.ranks)
cond_var = main_block.create_var(name="gradient_merge_cond",
shape=[1],
dtype='bool')
set_var_dist_attr(dist_context, cond_var, [-1], world_process_group.ranks)
with device_guard("cpu"):
# step_var = (step_var + 1) % k_step
layers.increment(x=step_var, value=1.0, in_place=True)
elementwise_mod_op = main_block.append_op(type='elementwise_mod',
inputs={
'X': step_var,
'Y': k_step_var
},
outputs={'Out': step_var},
attrs={
'axis': -1,
'use_mkldnn': False
})
naive_set_dist_op_attr_for_program_by_mesh_and_mapping(
elementwise_mod_op, world_process_group.ranks, [-1], dist_context)
# cond_var = (step_var == 0)
equal_op = main_block.append_op(type='equal',
inputs={
'X': step_var,
'Y': zero_var
},
outputs={'Out': cond_var})
naive_set_dist_op_attr_for_program_by_mesh_and_mapping(
equal_op, world_process_group.ranks, [-1], dist_context)
return cond_var
def _append_gradient_merge_backward_op(
main_program, startup_program, params_grads: List[Tuple[Any, Any]],
cond_var_name: str,
dist_context) -> Tuple[List[Tuple[Any, Any]], Dict[str, Any]]:
main_block = main_program.global_block()
startup_block = startup_program.global_block()
# step1: remove grad.op's op_role_var
for param, grad in params_grads:
assert (
param.type != core.VarDesc.VarType.SELECTED_ROWS
), "SELECTED_ROWS is not supported in GradientMergeOptimizer for now"
_remove_op_role_var(param, grad)
param_to_gradient_merge = {}
new_params_to_grads = []
# step2: create gradient_merge var and init with 0
for param, grad in params_grads:
param_name = param.name
param_var = main_block.var(param_name)
assert (param_var is not None)
ref_dist_attr = dist_context.get_tensor_dist_attr_for_program(param_var)
assert ref_dist_attr is not None
gradient_merge_var = main_block.create_var(name=param_name +
"@GRAD@GradientMerge",
shape=param_var.shape,
dtype=param_var.dtype,
persistable=True)
param_to_gradient_merge[param_name] = gradient_merge_var
ref_process_mesh = ref_dist_attr.process_mesh
ref_dims_mapping = ref_dist_attr.dims_mapping
set_var_dist_attr(dist_context, gradient_merge_var, ref_dims_mapping,
ref_process_mesh)
startup_gradient_merge_var = startup_block.create_var(
name=param_name + "@GRAD@GradientMerge",
shape=param_var.shape,
dtype=param_var.dtype,
persistable=True)
startup_block.append_op(type="fill_constant",
outputs={"Out": startup_gradient_merge_var},
attrs={
"shape": param_var.shape,
"dtype": param_var.dtype,
"value": float(0),
})
# grad_merge += grad
new_grad_op = main_block.append_op(type="elementwise_add",
inputs={
'X': grad,
'Y': gradient_merge_var
},
outputs={'Out': gradient_merge_var},
attrs={
'axis': -1,
'use_mkldnn': False
})
new_params_to_grads.append([param, gradient_merge_var])
naive_set_dist_op_attr_for_program_by_mesh_and_mapping(
new_grad_op, ref_process_mesh, ref_dims_mapping, dist_context)
return new_params_to_grads, param_to_gradient_merge
def _create_cond_block_and_update_optimizer(
main_program, cond_var, new_params_to_grads: List[Tuple[Any, Any]],
param_to_gradient_merge: Dict[str, Any], optimize_ops_desc: List[Any],
k_steps, avg):
def true_apply_gradient():
cur_block_idx = main_program.current_block_idx
cur_block = main_program.current_block()
# cur_block's forward_block & backward_block is itself
cur_block._set_forward_block_idx(cur_block_idx)
op_maker = core.op_proto_and_checker_maker
if avg:
for param, new_grad in new_params_to_grads:
# grad /= k_steps
cur_block.append_op(type='scale',
inputs={'X': new_grad},
outputs={'Out': new_grad},
attrs={
'scale': 1.0 / k_steps,
'bias': 0.0,
'bias_after_scale': False
})
new_grad.op._set_attr(op_maker.kOpRoleAttrName(),
op_maker.OpRole.Optimize)
# append optimizer ops
for op_desc in optimize_ops_desc:
new_op_desc = cur_block.desc.append_op()
new_op_desc.copy_from(op_desc)
#update input/output
for input_name in new_op_desc.input_arg_names():
if input_name in new_params_to_grads:
new_op_desc._rename_input(input_name,
new_params_to_grads[input_name])
for output_name in new_op_desc.output_arg_names():
if output_name in new_params_to_grads:
new_op_desc._rename_output(output_name,
new_params_to_grads[output_name])
# remove op_role_var
if new_op_desc.has_attr(op_maker.kOpRoleVarAttrName()):
new_op_desc.remove_attr(op_maker.kOpRoleVarAttrName())
# op's update Grad
if core.grad_var_suffix() in new_op_desc.input_arg_names():
grad_value = new_op_desc.input("Grad")[0]
# TODO FIXME(xym) support fp16
grad_merge_value = grad_value + '@GradientMerge'
new_op_desc.set_input("Grad", [grad_merge_value])
main_program.global_block()._sync_with_cpp()
cur_block._sync_with_cpp()
# clear gradient_merge_vars
for param, new_grad in new_params_to_grads:
layers.fill_constant(shape=new_grad.shape,
dtype=new_grad.dtype,
value=0.0,
out=new_grad)
new_grad.op._set_attr(op_maker.kOpRoleAttrName(),
op_maker.OpRole.Optimize)
layers.cond(cond_var, true_fn=true_apply_gradient, false_fn=None)
def parse_program(main_program, startup_program, params_grads, k_steps, avg,
dist_context):
# 1 create gradient_merge_cond
cond_var = _get_gm_cond_var(main_program, k_steps, dist_context)
# 2 remove optimizer_op from main_program
optimize_ops_desc = _remove_and_get_optimizer_op(main_program, dist_context)
# back to block 0
main_program._rollback()
# 3 append gradient merge backward op to main_program
new_params_to_grads, param_to_gradient_merge = _append_gradient_merge_backward_op(
main_program, startup_program, params_grads, cond_var.name,
dist_context)
# 4 create ConditionalBlock and append gradient merge optimizer ops
_create_cond_block_and_update_optimizer(main_program, cond_var,
new_params_to_grads,
param_to_gradient_merge,
optimize_ops_desc, k_steps, avg)
@register_pass("auto_parallel_gradient_merge_pass")
class GradientMergePass(PassBase):
def __init__(self):
super(GradientMergePass, self).__init__()
self.set_attr("k_steps", -1)
self.set_attr("avg", True)
self.set_attr("inner_optimizer", None)
def _check_self(self):
if self.get_attr("k_steps") < 1:
return False
return True
def _check_conflict(self, other_pass):
return True
def _type(self):
return PassType.COMM_OPT
def _apply_single_impl(self, main_program, startup_program, context):
k_steps = self.get_attr("k_steps", -1)
avg = self.get_attr("avg", False)
dist_context = self.get_attr("dist_context")
params_grads = self.get_attr("params_grads")
with paddle.static.program_guard(main_program, startup_program):
parse_program(main_program, startup_program, params_grads, k_steps,
avg, dist_context)
main_program._sync_with_cpp()
|
[
"noreply@github.com"
] |
forschumi.noreply@github.com
|
6a71b1c6d6048d65ec434b7db6b8ca6701671ae5
|
8d1237874cceee240d605edc0caa4ac5255d040e
|
/HW4/example-ptt(version dict).py
|
b51264fe5da721ebace4a993db6d7de471b097f7
|
[] |
no_license
|
fatwinnie/Sam_Test
|
545f9c7f4782d7e279a2aafd3278e58b8272ee23
|
3ba99bd3d21baeb74b94c703edcad1d480b99661
|
refs/heads/master
| 2022-12-27T16:06:47.323058
| 2020-10-16T09:51:44
| 2020-10-16T09:51:44
| 287,498,760
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,342
|
py
|
import requests
from bs4 import BeautifulSoup
import numpy as np
import pandas as pd
url = "https://www.ptt.cc/bbs/joke/index.html"
response = requests.get(url)
html_doc = response.text # text 屬性就是 html檔案
soup = BeautifulSoup(response.text, "html.parser")
post_author = [] #建立一個空的 list 放作者 id
recommend = [] # 放推文數
post_title = [] #放標題
post_date = [] #放貼文日期
posts = soup.find_all("div", class_ = "r-ent")
for post in posts:
try:
post_author.append(post.find("div", class_ = "author").string)
except:
post_author.append(np.nan)
try:
post_title.append(post.find("a").string)
except:
post_titles.append(np.nan)
try:
post_date.append(post.find("div", class_ = "date").string)
except:
post_dates.append(np.nan)
find_recommend = soup.find_all("div", class_ = "nrec")
for rec in find_recommend:
try:
#recommend.append(post.find("span").string)
recommend.append(int(rec.find("span").string))
except:
recommend.append(np.nan)
joke_dict = {"author": post_author,
"recommends": recommend,
"title": post_title,
"date": post_date
}
joke_df = pd.DataFrame(ptt_nba_dict)
#joke_df
joke_df.to_csv('beatifulsoup.csv',encoding='utf_8_sig')
|
[
"noreply@github.com"
] |
fatwinnie.noreply@github.com
|
40a3d067d1e3b7a8dc8e422b14866b6111bd77a8
|
3e9ac661325657664f3f7fa26ff2edf5310a8341
|
/python/demo100/15.py
|
82e514ce0d7a6957012d7aafb52d784906df006e
|
[] |
no_license
|
JollenWang/study
|
47d1c22a6e15cb82d0ecfc6f43e32e3c61fbad36
|
660a47fd60dd1415f71da362232d710b322b932f
|
refs/heads/master
| 2020-06-15T23:53:37.625988
| 2017-04-21T11:18:20
| 2017-04-21T11:18:20
| 75,257,807
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 490
|
py
|
#!/usr/bin/python
#-*- coding:utf-8 -*-
#author : Jollen Wang
#date : 2016/05/10
#version: 1.0
'''
题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
'''
def main():
score = int(raw_input("$>Enter the score:"))
print "grade=",
if score >= 90:
print "A"
elif score >= 60:
print "B"
else:
print "C"
if __name__ == "__main__":
main()
|
[
"jollen_wang@163.com"
] |
jollen_wang@163.com
|
458365ada1fd265704f15bcdea4a1b43e2126cfb
|
57c0b710086538c41a119d1866a71705c43ea2d9
|
/Face and Feature Detection/detectfacescircle.py
|
7ca145d58a9f47d937dfedf8341858d2ad7b91d5
|
[] |
no_license
|
AlokRanjanBhoi/pencv-For-Python
|
3bf171790f5c0bb50553eba6b0cd3a0252bdcd67
|
087150f6c1c486e3b136e8d71e140241d83c67cf
|
refs/heads/master
| 2020-04-08T02:00:31.737585
| 2018-12-27T16:41:10
| 2018-12-27T16:41:10
| 158,918,641
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 512
|
py
|
import numpy as np
import cv2
img = cv2.imread("faces.jpg",1)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
path = "haarcascade_eye.xml"
eye_cascade = cv2.CascadeClassifier(path)
eyes = eye_cascade.detectMultiScale(gray, scaleFactor=1.02,minNeighbors=20,minSize=(10,10))
print(len(eyes))
for (x,y,w,h) in eyes:
xc = (x+x+w)/2
yc = (y+y+h)/2
radius =w/2
cv2.circle(img,(int(xc),int(yc)), int(radius), (255,0,0),2)
cv2.imshow("Eyes",img)
cv2.waitKey(0)
cv2.destroyAllWindows()
|
[
"noreply@github.com"
] |
AlokRanjanBhoi.noreply@github.com
|
2129c72f2a51f1fe14350be0ad03e9f24634a8fb
|
ccb7633dae1393b546a189e0fd513665fae3e49f
|
/lambda/lambda_function.py
|
56e022fca38257a6b11f88d467cc74fffe8ec3e3
|
[] |
no_license
|
rahulsinha036/Weather-API-Alexa-Skill
|
65003976b119aaa0f154a9df52fcd0fa816f39eb
|
d07bf560f62a3c351e5d78111a310ff2b68ce46b
|
refs/heads/master
| 2022-12-25T05:34:51.151714
| 2020-09-27T10:35:09
| 2020-09-27T10:35:09
| 299,008,011
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 6,801
|
py
|
# -*- coding: utf-8 -*-
# This sample demonstrates handling intents from an Alexa skill using the Alexa Skills Kit SDK for Python.
# Please visit https://alexa.design/cookbook for additional examples on implementing slots, dialog management,
# session persistence, api calls, and more.
# This sample is built using the handler classes approach in skill builder.
import logging
import ask_sdk_core.utils as ask_utils
import requests
from ask_sdk_core.skill_builder import SkillBuilder
from ask_sdk_core.dispatch_components import AbstractRequestHandler
from ask_sdk_core.dispatch_components import AbstractExceptionHandler
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_model import Response
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
class LaunchRequestHandler(AbstractRequestHandler):
"""Handler for Skill Launch."""
def can_handle(self, handler_input):
# type: (HandlerInput) -> bool
return ask_utils.is_request_type("LaunchRequest")(handler_input)
def handle(self, handler_input):
# type: (HandlerInput) -> Response
speak_output = "Welcome to RS weather."
return (
handler_input.response_builder
.speak(speak_output)
.ask(speak_output)
.response
)
class GetWeatherIntentHandler(AbstractRequestHandler):
"""Handler for Get Weather Intent."""
def can_handle(self, handler_input):
# type: (HandlerInput) -> bool
return ask_utils.is_intent_name("GetWeatherIntent")(handler_input)
def handle(self, handler_input):
# type: (HandlerInput) -> Response
slots = handler_input.request_envelope.request.intent.slots
city = slots['city'].value
speak_output = ''
api_address = "http://api.openweathermap.org/data/2.5/weather?appid=d2926362ecd564ba1863bb2df0772161&units=metric&q="
url = api_address + city
json_data = requests.get(url).json()
formatted_json = json_data['weather'][0]['main']
temp = json_data['main']['temp']
name = json_data['name']
sys = json_data['sys']['country']
description = json_data['weather'][0]['description']
speak_output = "The weather is {}, {} and temp is {} of {} in {}.".format(formatted_json, description, temp, name, sys)
repromptOutput = " You want to know weather again of other city?"
return (
handler_input.response_builder
.speak(speak_output)
.ask(repromptOutput)
.response
)
class HelpIntentHandler(AbstractRequestHandler):
"""Handler for Help Intent."""
def can_handle(self, handler_input):
# type: (HandlerInput) -> bool
return ask_utils.is_intent_name("AMAZON.HelpIntent")(handler_input)
def handle(self, handler_input):
# type: (HandlerInput) -> Response
speak_output = "Hello,How we can help you? You can say that tell me new york tipsy weather."
return (
handler_input.response_builder
.speak(speak_output)
.ask(speak_output)
.response
)
class CancelOrStopIntentHandler(AbstractRequestHandler):
"""Single handler for Cancel and Stop Intent."""
def can_handle(self, handler_input):
# type: (HandlerInput) -> bool
return (ask_utils.is_intent_name("AMAZON.CancelIntent")(handler_input) or
ask_utils.is_intent_name("AMAZON.StopIntent")(handler_input))
def handle(self, handler_input):
# type: (HandlerInput) -> Response
speak_output = "Goodbye! see you soon."
return (
handler_input.response_builder
.speak(speak_output)
.response
)
class SessionEndedRequestHandler(AbstractRequestHandler):
"""Handler for Session End."""
def can_handle(self, handler_input):
# type: (HandlerInput) -> bool
return ask_utils.is_request_type("SessionEndedRequest")(handler_input)
def handle(self, handler_input):
# type: (HandlerInput) -> Response
# Any cleanup logic goes here.
return handler_input.response_builder.response
class IntentReflectorHandler(AbstractRequestHandler):
"""The intent reflector is used for interaction model testing and debugging.
It will simply repeat the intent the user said. You can create custom handlers
for your intents by defining them above, then also adding them to the request
handler chain below.
"""
def can_handle(self, handler_input):
# type: (HandlerInput) -> bool
return ask_utils.is_request_type("IntentRequest")(handler_input)
def handle(self, handler_input):
# type: (HandlerInput) -> Response
intent_name = ask_utils.get_intent_name(handler_input)
speak_output = "You just triggered " + intent_name + "."
return (
handler_input.response_builder
.speak(speak_output)
# .ask("add a reprompt if you want to keep the session open for the user to respond")
.response
)
class CatchAllExceptionHandler(AbstractExceptionHandler):
"""Generic error handling to capture any syntax or routing errors. If you receive an error
stating the request handler chain is not found, you have not implemented a handler for
the intent being invoked or included it in the skill builder below.
"""
def can_handle(self, handler_input, exception):
# type: (HandlerInput, Exception) -> bool
return True
def handle(self, handler_input, exception):
# type: (HandlerInput, Exception) -> Response
logger.error(exception, exc_info=True)
speak_output = "Sorry, I had trouble doing what you asked. Please try again."
return (
handler_input.response_builder
.speak(speak_output)
.ask(speak_output)
.response
)
# The SkillBuilder object acts as the entry point for your skill, routing all request and response
# payloads to the handlers above. Make sure any new handlers or interceptors you've
# defined are included below. The order matters - they're processed top to bottom.
sb = SkillBuilder()
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(GetWeatherIntentHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(CancelOrStopIntentHandler())
sb.add_request_handler(SessionEndedRequestHandler())
sb.add_request_handler(IntentReflectorHandler()) # make sure IntentReflectorHandler is last so it doesn't override your custom intent handlers
sb.add_exception_handler(CatchAllExceptionHandler())
lambda_handler = sb.lambda_handler()
|
[
"noreply@github.com"
] |
rahulsinha036.noreply@github.com
|
f502a1ab4fbd3fb3c402deb9bcb0a91171c04ca9
|
3ea75e35408de10bba250f52120b5424bd50fdd9
|
/py/plotSigzFunc.py
|
21812552da7cc7dfcdf7898e0e091f012d051cf2
|
[] |
no_license
|
jobovy/segue-maps
|
9848fe59ee24a11a751df4f8855c40f2480aef23
|
ed20b1058a98618700a20da5aa9b5ebd2ea7719b
|
refs/heads/main
| 2022-11-30T15:27:08.079999
| 2016-12-20T04:28:26
| 2016-12-20T04:28:26
| 40,663,061
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 4,199
|
py
|
import os, os.path
import math
import numpy
import cPickle as pickle
from matplotlib import pyplot
from optparse import OptionParser
from scipy import optimize, special
from galpy.util import bovy_coords, bovy_plot
def plotSigzFunc(parser):
(options,args)= parser.parse_args()
if len(args) == 0:
parser.print_help()
return
if os.path.exists(args[0]):#Load savefile
savefile= open(args[0],'rb')
params1= pickle.load(savefile)
samples1= pickle.load(savefile)
savefile.close()
else:
print "Need to give filename ..."
if os.path.exists(args[1]):#Load savefile
savefile= open(args[1],'rb')
params1= pickle.load(savefile)
samples2= pickle.load(savefile)
savefile.close()
else:
print "Need to give filename ..."
#First one
zs= numpy.linspace(0.3,1.2,1001)
xrange= [0.,1.3]
yrange= [0.,60.]
#Now plot the mean and std-dev from the posterior
zmean= numpy.zeros(len(zs))
nsigs= 3
zsigs= numpy.zeros((len(zs),2*nsigs))
fs= numpy.zeros((len(zs),len(samples1)))
ds= zs-0.5
for ii in range(len(samples1)):
thisparams= samples1[ii]
fs[:,ii]= math.exp(thisparams[1])+thisparams[2]*ds+thisparams[3]*ds**2.
#Record mean and std-devs
zmean[:]= numpy.mean(fs,axis=1)
bovy_plot.bovy_print()
xlabel=r'$|z|\ [\mathrm{kpc}]$'
ylabel=r'$\sigma_z\ [\mathrm{km\ s}^{-1}]$'
bovy_plot.bovy_plot(zs,zmean,'k-',xrange=xrange,yrange=yrange,
xlabel=xlabel,
ylabel=ylabel)
for ii in range(nsigs):
for jj in range(len(zs)):
thisf= sorted(fs[jj,:])
thiscut= 0.5*special.erfc((ii+1.)/math.sqrt(2.))
zsigs[jj,2*ii]= thisf[int(math.floor(thiscut*len(samples1)))]
thiscut= 1.-thiscut
zsigs[jj,2*ii+1]= thisf[int(math.floor(thiscut*len(samples1)))]
colord, cc= (1.-0.75)/nsigs, 1
nsigma= nsigs
pyplot.fill_between(zs,zsigs[:,0],zsigs[:,1],color='0.75')
while nsigma > 1:
pyplot.fill_between(zs,zsigs[:,cc+1],zsigs[:,cc-1],
color='%f' % (.75+colord*cc))
pyplot.fill_between(zs,zsigs[:,cc],zsigs[:,cc+2],
color='%f' % (.75+colord*cc))
cc+= 1.
nsigma-= 1
bovy_plot.bovy_plot(zs,zmean,'k-',overplot=True)
#Second one
zmean= numpy.zeros(len(zs))
zsigs= numpy.zeros((len(zs),2*nsigs))
fs= numpy.zeros((len(zs),len(samples2)))
for ii in range(len(samples2)):
thisparams= samples2[ii]
fs[:,ii]= math.exp(thisparams[1])+thisparams[2]*ds+thisparams[3]*ds**2.
#Record mean and std-devs
zmean[:]= numpy.mean(fs,axis=1)
for ii in range(nsigs):
for jj in range(len(zs)):
thisf= sorted(fs[jj,:])
thiscut= 0.5*special.erfc((ii+1.)/math.sqrt(2.))
zsigs[jj,2*ii]= thisf[int(math.ceil(thiscut*len(samples2)))]
thiscut= 1.-thiscut
zsigs[jj,2*ii+1]= thisf[int(math.ceil(thiscut*len(samples2)))]
colord, cc= (1.-0.75)/nsigs, 1
nsigma= nsigs
pyplot.fill_between(zs,zsigs[:,0],zsigs[:,1],color='0.75')
while nsigma > 1:
pyplot.fill_between(zs,zsigs[:,cc+1],zsigs[:,cc-1],
color='%f' % (.75+colord*cc))
pyplot.fill_between(zs,zsigs[:,cc],zsigs[:,cc+2],
color='%f' % (.75+colord*cc))
cc+= 1.
nsigma-= 1
bovy_plot.bovy_plot(zs,zmean,'k-',overplot=True)
bovy_plot.bovy_text(r'$-0.4 < [\mathrm{Fe/H}] < 0.5\,, \ \ -0.25 < [\alpha/\mathrm{Fe}] < 0.2$',bottom_right=True)
bovy_plot.bovy_text(r'$-1.5 < [\mathrm{Fe/H}] < -0.5\,, \ \ 0.25 < [\alpha/\mathrm{Fe}] < 0.5$',top_left=True)
bovy_plot.bovy_end_print(options.plotfile)
return None
def get_options():
usage = "usage: %prog [options] <savefilename>\n\nsavefilename= name of the file that the fit/samples will be saved to"
parser = OptionParser(usage=usage)
parser.add_option("-o",dest='plotfile',
help="Name of file for plot")
return parser
if __name__ == '__main__':
plotSigzFunc(get_options())
|
[
"jo.bovy@gmail.com"
] |
jo.bovy@gmail.com
|
28bf8e32b2fc71691571cc473c7d4d6c7cefcf3a
|
fe98f7502a5724be0ec7ec3ae73ff4703d299d6e
|
/Neural Tree/data.py
|
1b85e274b45f66319d308125e39f23e90bf4375f
|
[] |
no_license
|
SoumitraAgarwal/BTP
|
92ab095aacf3dd374148f40b9e777bb49c4253f1
|
07df960ad7e8680680a9d3494c8a860b394867d1
|
refs/heads/master
| 2020-03-16T12:39:13.548988
| 2018-05-09T06:09:11
| 2018-05-09T06:09:11
| 132,671,601
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,513
|
py
|
import random
import math
import pandas as pd
import numpy as np
from sklearn import preprocessing
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import axes3d, Axes3D
plt.switch_backend('agg')
random.seed(311)
def generate(radius, centre):
alpha = 2 * math.pi * random.random()
r = radius*random.random()
x = r*math.cos(alpha) + centre[0]
y = r*math.sin(alpha) + centre[1]
return [x,y]
k = 10
n = 600
ranger = 500
C = []
X = []
Y = []
for j in range(k):
T = [random.uniform(0, ranger), random.uniform(0, ranger)]
temp = []
C.append([[j*ranger + random.uniform(0, ranger), ranger*random.uniform(0, k)], 400*random.uniform(0, 1)])
for i in range(n):
temp.append(generate(C[j][1], C[j][0]))
temp = np.asarray(temp)
Y.append(np.matmul(temp,T))
X.append(temp)
X = np.asarray(X)
Y = np.asarray(Y)
fig = plt.figure()
ax1 = fig.add_subplot(111)
colors = cm.rainbow(np.linspace(0, 1, len(Y)))
for i in range(k):
x1, y1 = X[i].T
ax1.scatter( x1,y1, s = 3, marker="o", label='target', color=colors[i])
plt.savefig('Data.png')
X1 = []
X2 = []
for i in range(k):
x1,x2 = X[i].T
X1.append(x1)
X2.append(x2)
X1 = np.asarray(X1)
X2 = np.asarray(X2)
Y = Y.ravel()
X1 = X1.ravel()
X2 = X2.ravel()
X1 = preprocessing.scale(X1)
X2 = preprocessing.scale(X2)
Y = preprocessing.scale(Y)
data = pd.DataFrame(data = {
'X1':X1,
'X2':X2,
'Y' :Y
})
data = data.sample(frac=1).reset_index(drop=True)
data.to_csv('data.csv', index = False)
|
[
"agarwalsoumitra1504@gmail.com"
] |
agarwalsoumitra1504@gmail.com
|
ef3d990361a736c2c8243ef71653066e995e9f04
|
a1c7b21d96d6326790831b2b3115fcd2563655a4
|
/pylidc/__init__.py
|
95c187456f43a5b9aafdc6d2673def316432c058
|
[
"MIT"
] |
permissive
|
jovsa/pylidc
|
3837b17fbe02bc60817081a349681612f24b2f81
|
bd378a60a4b0e6dfb569afb25c3dfcbbcd169550
|
refs/heads/master
| 2021-06-13T02:45:41.359793
| 2017-03-10T23:14:57
| 2017-03-10T23:14:57
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,068
|
py
|
"""
--------------------------------------------------------
Author: Matt Hancock, not.matt.hancock@gmail.com
--------------------------------------------------------
This python module implements an (ORM) object relational mapping
to an sqlite database containing the annotation information from
the XML files provided by the LIDC dataset. The purpose of this
module is to make for easier data querying and to include
functional aspects of the data models in addition to pure
attribute information, e.g., computing nodule centroids from
contour attribtues.
The ORM is implemented using sqlalchemy. There are three data models:
Scan, Annotation, and Contour
The relationships are "one to many" for each model going left
to right, i.e., scans have many annotations and annotations
have many contours.
For more information, see the model classes themselves.
"""
from __future__ import print_function as _pf
__version__ = '0.1.2'
# Hidden stuff.
import os as _os
import pkg_resources as _pr
from sqlalchemy import create_engine as _create_engine
from sqlalchemy.orm import sessionmaker as _sessionmaker
_dbpath = _pr.resource_filename('pylidc', 'pylidc.sqlite')
_engine = _create_engine('sqlite:///'+_dbpath)
_session = _sessionmaker(bind=_engine)()
# Public stuff.
from .Scan import Scan
from .Scan import dicompath
from .Annotation import Annotation
from .Contour import Contour
def query(*args):
"""
Wraps the sqlalchemy session object. Some example usage:
>>> import pylidc as pl
>>> qu = pl.query(pl.Scan).filter(pl.Scan.slice_thickness <= 1.)
>>> print qu.count()
>>> # => 97
>>> scan = qu.first()
>>> print len(scan.annotations)
>>> # => 11
>>> qu = pl.query(pl.Annotation).filter((pl.Annotation.malignancy > 3), (pl.Annotation.spiculation < 3))
>>> print qu.count()
>>> # => 1083
>>> annotation = qu.first()
>>> print annotation.estimate_volume()
>>> # => 5230.33874999
"""
return _session.query(*args)
|
[
"mhancock743@gmail.com"
] |
mhancock743@gmail.com
|
64a5d750a89fb054c3e4071ed1214595cb22f90c
|
5acc62ab7c37bc2aa5b2e7eedc8c0960b37bda7b
|
/setup.py
|
ef25940cc4b5a049843c0c1d65b07ed48d136ecb
|
[
"MIT"
] |
permissive
|
DanWertheimer/pyJDBCConnector
|
6476a3039ec0ba7a957e28744a869a0cfe859c41
|
41d7121fefb51692f1cec9bfc464de448bfc159f
|
refs/heads/master
| 2022-08-29T00:30:42.744437
| 2020-05-20T10:19:34
| 2020-05-20T10:19:34
| 264,123,305
| 2
| 0
|
MIT
| 2020-05-19T14:14:32
| 2020-05-15T07:12:19
|
Python
|
UTF-8
|
Python
| false
| false
| 1,675
|
py
|
import setuptools
from pyjdbcconnector import __version__
# read the contents of your README file
from os import path
this_directory = path.abspath(path.dirname(__file__))
with open(path.join(this_directory, 'README.md'), encoding='utf-8') as f:
long_description = f.read()
setuptools.setup(
name='pyjdbcconnector',
version=__version__,
description='A high level JDBC API',
long_description=long_description,
long_description_content_type='text/markdown',
url='https://github.com/DanWertheimer/pyJDBCConnector',
download_url='https://github.com/DanWertheimer/pyJDBCConnector/archive/v0.2.1.tar.gz',
author='Daniel Wertheimer',
author_email='danwertheimer@gmail.com',
packages=setuptools.find_packages(),
license='MIT',
classifiers=[
'Development Status :: 3 - Alpha',
# Indicate who your project is intended for
'Intended Audience :: Developers',
# Pick your license as you wish (should match "license" above)
'License :: OSI Approved :: MIT License',
# Specify the Python versions you support here. In particular, ensure
# that you indicate whether you support Python 2, Python 3 or both.
'Programming Language :: Python :: 3.6',
],
zip_safe=False,
python_requires='>=3.6',
install_requires=[
'JPype1 == 0.6.3',
'JayDeBeApi >= 1.1.1',
'PyHive == 0.6.2'
],
project_urls={
'Documentation': 'https://pyjdbcconnector.readthedocs.io/en/latest/',
'Source': 'https://github.com/DanWertheimer/pyJDBCConnector',
'Say Thanks!': 'https://saythanks.io/to/danwertheimer%40gmail.com'
},
)
|
[
"Daniel.Wertheimer@absa.africa"
] |
Daniel.Wertheimer@absa.africa
|
debd832aa46efe641d1cd44a23481c762f2593d0
|
eb874c1b263a1db2f7beb04b08d51a5b0f6ad8e8
|
/dcl_main.py
|
d8d844d6508f216dc70b4286a3389fafcbe761c9
|
[] |
no_license
|
freekang/DCL-1
|
2c89d5b07767864819709118f06f1e34465c5c5d
|
63f30e282716a22a922c29e4f3b5e5f81696dbb0
|
refs/heads/main
| 2023-04-03T14:29:45.764790
| 2021-04-11T02:53:20
| 2021-04-11T02:53:20
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 10,652
|
py
|
import os
import sys
import torch
import yaml
# from torchvision import datasets
from models.mlp_head import MLPHead
from models.bert_base_network import BertNet
from trainer import BertBYOLTrainer
from dataclasses import dataclass, field
from typing import Optional
import logging
# os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID' # 按照PCI_BUS_ID顺序从0开始排列GPU设备
# os.environ['CUDA_VISIBLE_DEVICES'] = '0' #设置当前使用的GPU设备仅为0号设备
from transformers import (
CONFIG_MAPPING,
MODEL_WITH_LM_HEAD_MAPPING,
AutoConfig,
AutoModelWithLMHead,
AutoTokenizer,
DataCollatorForLanguageModeling,
BYOLDataCollatorForLanguageModeling,
HfArgumentParser,
LineByLineTextDataset,
PreTrainedTokenizer,
TrainingArguments,
set_seed,
RobertaModel,
RobertaTokenizer,
RobertaForMaskedLM,
BertForMaskedLM,
BertTokenizer,
AutoConfig,
AutoModelForSequenceClassification,
glue_processors
)
from utils.util import GlueContrastDataset
from transformers import GlueDataset
logger = logging.getLogger(__name__)
MODEL_CONFIG_CLASSES = list(MODEL_WITH_LM_HEAD_MAPPING.keys())
MODEL_TYPES = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)
@dataclass
class DataTrainingArguments:
"""
Arguments pertaining to what data we are going to input our model for training and eval.
Using `HfArgumentParser` we can turn this class
into argparse arguments to be able to specify them on
the command line.
"""
task_name: str = field(metadata={"help": "The name of the task to train on: " + ", ".join(glue_processors.keys())})
data_dir: str = field(
metadata={"help": "The input data dir. Should contain the .tsv files (or other data files) for the task."}
)
max_seq_length: int = field(
default=128,
metadata={
"help": "The maximum total input sequence length after tokenization. Sequences longer "
"than this will be truncated, sequences shorter will be padded."
},
)
mlm: bool = field(
default=False, metadata={"help": "Train with masked-language modeling loss instead of language modeling."}
)
mlm_probability: float = field(
default=0.15, metadata={"help": "Ratio of tokens to mask for masked language modeling loss"}
)
plm_probability: float = field(
default=1 / 6,
metadata={
"help": "Ratio of length of a span of masked tokens to surrounding context length for permutation language modeling."
},
)
max_span_length: int = field(
default=5, metadata={"help": "Maximum length of a span of masked tokens for permutation language modeling."}
)
block_size: int = field(
default=-1,
metadata={
"help": "Optional input sequence length after tokenization."
"The training dataset will be truncated in block of this size for training."
"Default to the model max input length for single sentence inputs (take into account special tokens)."
},
)
overwrite_cache: bool = field(
default=False, metadata={"help": "Overwrite the cached training and evaluation sets"}
)
def __post_init__(self):
self.task_name = self.task_name.lower()
@dataclass
class ModelArguments:
"""
Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
"""
model_name_or_path: str = field(
metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}
)
model_type: Optional[str] = field(
default=None,
metadata={"help": "If training from scratch, pass a model type from the list: " + ", ".join(MODEL_TYPES)},
)
config_name: Optional[str] = field(
default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
)
tokenizer_name: Optional[str] = field(
default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
)
cache_dir: Optional[str] = field(
default=None, metadata={"help": "Where do you want to store the pretrained models downloaded from s3"}
)
norm_type: Optional[str] = field(
default=None, metadata={"help": "norm type in contrast_model"}
)
def prepare_bert(model_path):
if model_path == 'bert-base-uncased':
model_class = BertForMaskedLM
tokenizer_class = BertTokenizer
pretrained_weights = 'bert-base-uncased'
else:
model_class = RobertaForMaskedLM
tokenizer_class = RobertaTokenizer
pretrained_weights = 'roberta-base'
# 载入预训练的tokenizer和model
tokenizer = tokenizer_class.from_pretrained(pretrained_weights)
model = model_class.from_pretrained(pretrained_weights)
# model1 = RobertaModel.from_pretrained(pretrained_weights)
# id = tokenizer.encode("Here is some text to encode", add_special_tokens=True)
# input_ids = torch.tensor([tokenizer.encode("Here is some text to encode", add_special_tokens=True)])
# with torch.no_grad():
# last_hidden_states = model(input_ids)[0] # Models outputs are now tuples
return tokenizer,model
def main():
# See all possible arguments in src/transformers/training_args.py
# or by passing the --help flag to this script.
# We now keep distinct sets of args, for a cleaner separation of concerns.
byol_config = yaml.load(open("./config/config.yaml", "r"), Loader=yaml.FullLoader)
parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments))
if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
# If we pass only one argument to the script and it's the path to a json file,
# let's parse it to get our arguments.
model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
else:
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
if (
os.path.exists(training_args.output_dir)
and os.listdir(training_args.output_dir)
and training_args.do_train
and not training_args.overwrite_output_dir
):
raise ValueError(
f"Output directory ({training_args.output_dir}) already exists and is not empty. Use --overwrite_output_dir to overcome."
)
# Setup logging
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN,
)
logger.warning(
"Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s",
training_args.local_rank,
training_args.device,
training_args.n_gpu,
bool(training_args.local_rank != -1),
training_args.fp16,
)
logger.info("Training/evaluation parameters %s", training_args)
# Set seed
set_seed(training_args.seed)
# 导入roberta相关模型
tokenizer, bertformlm = prepare_bert(model_args.model_name_or_path)
bertformlm.resize_token_embeddings(len(tokenizer))
if data_args.block_size <= 0:
data_args.block_size = tokenizer.max_len
else:
data_args.block_size = min(data_args.block_size, tokenizer.max_len)
# Get datasets
train_dataset = (
GlueContrastDataset(data_args, tokenizer=tokenizer,
cache_dir=model_args.cache_dir) if training_args.do_train else None
)
data_collator = BYOLDataCollatorForLanguageModeling(
tokenizer=tokenizer, mlm=data_args.mlm, mlm_probability=data_args.mlm_probability
)
dataset_num = len(train_dataset)
training_args.save_steps = dataset_num // training_args.per_device_train_batch_size//2
training_args.logging_steps = training_args.save_steps
print('train_dataset.len:', len(train_dataset))
print('save_steps:', training_args.save_steps)
print('eval_steps:', training_args.eval_steps)
print('logging_steps:', training_args.logging_steps)
# online encoder
online_network = BertNet(bert=bertformlm,norm_type=model_args.norm_type, model_name=model_args.model_name_or_path,**byol_config['network'])
# predictor network
predictor = MLPHead(norm_type=model_args.norm_type,in_channels=online_network.projetion.net[-1].out_features,
**byol_config['network']['projection_head'],layer=2)
# target encoder
target_network = BertNet(bert=bertformlm,norm_type=model_args.norm_type, model_name=model_args.model_name_or_path, **byol_config['network'])
# load pre-trained model if defined
if model_args.model_name_or_path:
try:
# load pre-trained parameters
# online2 = BertNet(bert=bertformlm,norm_type='power',model_name=model_args.model_name_or_path, **byol_config['network'])
# load_params = torch.load(os.path.join(os.path.join('/home/chenxiang/pretrained_model/PyTorch-BYOL/new_result/bert_power_pretrain_glue/MNLI/checkpoint-epoch1', 'pytorch_model.bin')),
# map_location=torch.device(torch.device(training_args.device)))
#
# online2.load_state_dict(load_params['online_network_state_dict'])
# online_network.roberta.load_state_dict(online2.roberta.state_dict())
# del load_params,online2
logger.info("Training online_network parameters from %s", model_args.model_name_or_path)
except FileNotFoundError:
logger.info("Pre-trained weights not found. Training from scratch.")
trainer = BertBYOLTrainer(
args = training_args,
online_network=online_network,
target_network=target_network,
# optimizer=optimizer,
predictor=predictor,
data_collator=data_collator,
train_dataset=train_dataset,
**byol_config['trainer'])
# Training
if training_args.do_train:
model_path = model_args.model_name_or_path
trainer.train(model_path=model_path)
trainer.save_model()
# For convenience, we also re-save the tokenizer to the same directory,
# so that you can share your model easily on huggingface.co/models =)
if trainer.is_world_master():
tokenizer.save_pretrained(training_args.output_dir)
if __name__ == '__main__':
main()
|
[
"852975133@qq.com"
] |
852975133@qq.com
|
8c4a5643db05aa582d6890691f9259ba39448975
|
455ce0c304e4a9f080862cb8459066ac741f3d38
|
/day06/funcAsVar.py
|
abdfe02a2e1454e4e58302d9b697a4725542a345
|
[] |
no_license
|
venkatram64/python3_work
|
23a835b0f8f690ca167e74bbbe94f46e3bd8c99f
|
754f42f6fa2be4446264a8e2532abd55213af4df
|
refs/heads/master
| 2021-06-15T22:41:31.031925
| 2021-02-16T04:56:50
| 2021-02-16T04:56:50
| 153,217,220
| 1
| 3
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 125
|
py
|
def square(num):
return num * num
s = square # function is assigned to a variable, and later can be excuted
print(s(5))
|
[
"venkat.veerareddy@hotmail.com"
] |
venkat.veerareddy@hotmail.com
|
e9c684dd4c93afc3e080a8243908e154b3b2ebeb
|
ff4fc5ffab9143e5440ae78415b1128429530a5f
|
/knowledge_files/函数列表.py
|
ee836d26dae015ce05eb4a8b6fc3c47366260076
|
[] |
no_license
|
LyuuuuXinwei/knowledge
|
4ee2a4cdc5007430ca6ef09a1368604b89deead0
|
218f1c903bc8113b70fd4997e5f5349a86263153
|
refs/heads/master
| 2021-01-20T01:50:04.702084
| 2018-02-08T16:18:48
| 2018-02-08T16:18:48
| 101,301,112
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,136
|
py
|
match_ # 正则检查需要被变复数的单词
apply_ # 以正则方式替换
import re
def match_sxz(noun):
return re.search('[sxz]$', noun)
def apply_sxz(noun):
return re.sub('$', 'es', noun)
'''rules函数列表'''
rules = ((match_sxz, apply_sxz),
(match_h, apply_h),
(match_y, apply_y),
(match_default, apply_default)
)
def plural(noun):
for matches_rule, apply_rule in rules:
if matches_rule(noun):
return apply_rule(noun)
'''体会下高级语言额简洁'''
'''闭合，动态函数~'''
def build_match_and_apply_functions(pattern, search, replace):
def matches_rule(word):
return re.search(pattern, word)
def apply_rule(word): ②
return re.sub(search, replace, word)
return(matches_rule, apply_rule)
'''构造一个四组参数的tuple，传入参数的构造整齐简洁'''
patterns=(('[sxz]$', '$', 'es'),('[^aeioudgkprt]h$', '$', 'es'),('(qu|[^aeiou])y$', 'y$', 'ies'),('$', '$', 's'))
'''for传递成组参数，结果简洁'''
rules = [build_match_and_apply_functions(pattern, search, replace) for (pattern, search, replace) in patterns]
|
[
"416626614@qq.com"
] |
416626614@qq.com
|
d476c12d19016fedb10bf55bbe245feb207b93ac
|
971e0efcc68b8f7cfb1040c38008426f7bcf9d2e
|
/tests/model_control/detailed/transf_Quantization/model_control_one_enabled_Quantization_Lag1Trend_NoCycle_NoAR.py
|
ff7ef11eee723d83fe871324617d9665f298f2bc
|
[
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
antoinecarme/pyaf
|
a105d172c2e7544f8d580d75f28b751351dd83b6
|
b12db77cb3fa9292e774b2b33db8ce732647c35e
|
refs/heads/master
| 2023-09-01T09:30:59.967219
| 2023-07-28T20:15:53
| 2023-07-28T20:15:53
| 70,790,978
| 457
| 77
|
BSD-3-Clause
| 2023-03-08T21:45:40
| 2016-10-13T09:30:30
|
Python
|
UTF-8
|
Python
| false
| false
| 154
|
py
|
import tests.model_control.test_ozone_custom_models_enabled as testmod
testmod.build_model( ['Quantization'] , ['Lag1Trend'] , ['NoCycle'] , ['NoAR'] );
|
[
"antoine.carme@laposte.net"
] |
antoine.carme@laposte.net
|
6e1df05610ec9c28d74938442be383a7185cc1d9
|
d1820a2b617f0ebb1c60f5f258bd8a844bd660d3
|
/schedule/models/route.py
|
b6edf5c88fd2f300488236fc29d6f820544d1c52
|
[] |
no_license
|
sfrieson/subway
|
0db4a8b9ef60bcb9c62803c0c9a28e6dbb8e6fc1
|
7f4252d12b7d5a935188dba359579849da008397
|
refs/heads/master
| 2020-03-26T04:36:27.977293
| 2018-09-09T11:35:17
| 2018-09-09T11:35:17
| 144,512,476
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 709
|
py
|
from lib import db
def get(route_id):
return db.get_one("SELECT * FROM routes where route_id = '%s';" % route_id)
def get_paths(route_id):
return db.get_many("""
SELECT
shape_id, points.point_id, shape_pt_sequence, point_lon, point_lat
FROM
shapes
JOIN points on shapes.point_id = points.point_id
WHERE
shape_id IN (
SELECT DISTINCT
shapes.shape_id
FROM
shapes
JOIN trips ON trips.shape_id = shapes.shape_id
WHERE route_id = '%s'
)
ORDER BY
shape_id, shape_pt_sequence
""" % route_id)
|
[
"sfrieson@gmail.com"
] |
sfrieson@gmail.com
|
015abfc9ea79a4582643af75018f4ff2b5c66e16
|
97b87984b70021730df04bac0b5cf1d076bf4592
|
/quartile.py
|
cbbe94b69dd22d55559ef291addce60772d64294
|
[] |
no_license
|
ayush-ruel/Statistics
|
0bcede4691e861ec45e4b4d2f3d9274e071b6b78
|
1f2ba99d685c8a0a224d41b9cb46dc6b255f5a8f
|
refs/heads/master
| 2020-04-23T18:02:54.940588
| 2019-02-26T21:59:03
| 2019-02-26T21:59:03
| 171,353,355
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 282
|
py
|
from statistics import median
n=int(input())
arr=[int(x) for x in input().split()]
arr.sort()
t=int(len(arr)/2)
if len(arr)%2==0:
L=arr[:t]
U=arr[t:]
else:
L=arr[:t]
U=arr[t+1:]
print(int(median(L)))
print(int(median(arr)))
print(int(median(U)))
|
[
"noreply@github.com"
] |
ayush-ruel.noreply@github.com
|
aa187842f546ec38434033435a6d0116e9184da1
|
d8127d11c7294796a4d85a8ed0dba43cb6fce715
|
/basic_knowledge/10_2_3.py
|
fd0e314d26afb2b1df2080fef79e4910693c7a57
|
[] |
no_license
|
TophTab/Learning_python_firsttime
|
77e6a33069fa6718c878bcf6b7925fa3f703d16e
|
4e30d6d2c120a911c8e6cc1f0918128bf7fb372b
|
refs/heads/main
| 2023-01-06T22:23:39.482131
| 2020-11-07T13:34:55
| 2020-11-07T13:34:55
| 310,820,651
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 217
|
py
|
with open('programming.txt','a') as file_object:
file_object.write("I also love finding\n")
file_object.write('I love creating\n')
with open('programming.txt','r') as file_object:
print(file_object.read())
|
[
"TophTab@github.com"
] |
TophTab@github.com
|
95a196583e24ca85981351ed0bf9c3a4ece3c9bb
|
f6644453d0a228cec214d09551468105134c5da3
|
/mobilenetv2.py
|
84c1b802d29d0097fc7043eceb38466e66aa5a92
|
[] |
no_license
|
ibadami/MobileNet_v2
|
97a49692edce291631b8d123ae2031c8179ff395
|
b10065448bf65e007032e0e04a170045c4a0b8b2
|
refs/heads/master
| 2020-04-17T22:02:34.702865
| 2019-01-22T10:53:33
| 2019-01-22T10:53:33
| 166,977,607
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 4,710
|
py
|
"""MobileNet v2 model for TFLearn.
# Reference
[MobileNetV2: Inverted Residuals and Linear Bottlenecks]
(https://arxiv.org/abs/1801.04381)
_author__ = "Ishrat Badami, badami@nevisq.com"
"""
from tflearn.layers.conv import conv_2d, grouped_conv_2d, global_avg_pool
from tflearn.layers.core import dropout, reshape, input_data
from tflearn.layers.merge_ops import merge
from tflearn.layers.normalization import batch_normalization
def _conv_block(input_net, filters, kernel, strides):
"""Convolution Block
This function defines a 2D convolution operation with BN and relu6.
Parameters
----------
input_net: Tensor, input tensor of convolution layer.
filters: Integer, the dimensionality of the output space.
kernel: An integer or tuple/list of 2 integers, specifying the
width and height of the 2D convolution window.
strides: An integer or tuple/list of 2 integers,
specifying the strides of the convolution along the width and height.
Can be a single integer to specify the same value for
all spatial dimensions.
# Returns
Output tensor.
"""
net = conv_2d(input_net, filters, kernel, strides, activation='relu6', weights_init='xavier')
net = batch_normalization(net)
return net
def _bottleneck(input_net, filters, kernel, t, s, r=False):
"""Bottleneck
This function defines a basic bottleneck structure.
Parameters
----------
input_net: Tensor, input tensor of conv layer.
filters: Integer, the dimensionality of the output space.
kernel: An integer or tuple/list of 2 integers, specifying the
width and height of the 2D convolution window.
t: Integer, expansion factor.
t is always applied to the input size.
s: An integer or tuple/list of 2 integers,specifying the strides
of the convolution along the width and height.Can be a single
integer to specify the same value for all spatial dimensions.
r: Boolean, Whether to use the residuals.
# Returns
Output tensor.
"""
t_channel = input_net.shape[3] * t # channel expansion
net = _conv_block(input_net, t_channel, (1, 1), (1, 1))
net = grouped_conv_2d(net, channel_multiplier=1, filter_size=kernel, strides=(s, s), padding='same',
activation='relu6', weights_init='xavier')
net = batch_normalization(net)
net = conv_2d(net, filters, (1, 1), strides=(1, 1), padding='same')
net = batch_normalization(net)
if r:
net = merge([net, input_net], 'elemwise_sum')
return net
def _inverted_residual_block(input_net, filters, kernel, t, strides, n):
"""Inverted Residual Block
This function defines a sequence of 1 or more identical layers.
Parameters
----------
input_net: Tensor, input tensor of conv layer.
filters: Integer, the dimensionality of the output space.
kernel: An integer or tuple/list of 2 integers, specifying the
width and height of the 2D convolution window.
t: Integer, expansion factor.
t is always applied to the input size.
s: An integer or tuple/list of 2 integers,specifying the strides
of the convolution along the width and height.Can be a single
integer to specify the same value for all spatial dimensions.
n: Integer, layer repeat times.
# Returns
Output tensor.
"""
net = _bottleneck(input_net, filters, kernel, t, strides)
for i in range(1, n):
net = _bottleneck(net, filters, kernel, t, 1, True)
return net
def mobile_net_v2(input_shape, n_classes, img_prep=None, img_aug=None):
"""MobileNetv2
This function defines a MobileNetv2 architectures.
Parameters
----------
input_shape: An integer or tuple/list of 3 integers, shape
of input tensor.
n_classes: Number of classes.
img_prep: Function handle for image pre-processing
img_aug: Function handle for image augmentation
# Returns
MobileNetv2 model.
"""
inputs = input_data(shape=input_shape, data_preprocessing=img_prep, data_augmentation=img_aug)
x = reshape(inputs, [-1, input_shape[0], input_shape[1], 1])
x = _conv_block(x, 32, (3, 3), strides=(2, 2))
x = _inverted_residual_block(x, 16, (3, 3), t=1, strides=1, n=1)
x = _inverted_residual_block(x, 24, (3, 3), t=6, strides=2, n=2)
x = _inverted_residual_block(x, 32, (3, 3), t=6, strides=2, n=3)
x = _inverted_residual_block(x, 64, (3, 3), t=6, strides=2, n=4)
x = _inverted_residual_block(x, 96, (3, 3), t=6, strides=1, n=3)
x = _inverted_residual_block(x, 160, (3, 3), t=6, strides=2, n=3)
x = _inverted_residual_block(x, 320, (3, 3), t=6, strides=1, n=1)
x = _conv_block(x, 1280, (1, 1), strides=(1, 1))
x = global_avg_pool(x)
x = reshape(x, [-1, 1, 1, 1280])
x = dropout(x, 0.3, name='Dropout')
x = conv_2d(x, n_classes, (1, 1), padding='same', activation='softmax', weights_init='xavier')
output = reshape(x, [-1, n_classes])
return output
|
[
"noreply@github.com"
] |
ibadami.noreply@github.com
|
45b764bb9a978270fd4f4004643081df442084c4
|
8531e93ea9a499804da4606499dfb258efc4ed3c
|
/speechToText.py
|
5d0edc8dad0fe274ac651a8c210f34be183b1a8c
|
[] |
no_license
|
marblefactory/Speech-to-Text
|
a09ce4fe9276af89200ee1dcc1a85f6ef68a07b5
|
8888561bbbe27a41594ab27da64f6281d9dc0fc0
|
refs/heads/master
| 2021-07-20T23:57:10.949806
| 2017-10-30T12:47:22
| 2017-10-30T12:47:22
| 108,848,476
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 839
|
py
|
import speech_recognition as sr
r = sr.Recognizer()
m = sr.Microphone()
try:
print("Geting ambinent noise")
with m as source: r.adjust_for_ambient_noise(source)
print("Energy threshold established")
while True:
print("Say something:")
with m as source: audio = r.listen(source)
print("Will no convert to text...")
try:
text = r.recognize_google(audio)
if str is bytes:
print(u"You said {}".format(text).encode("utf-8"))
else:
print("You said {}".format(text))
except sr.UnknownValueError:
print("Oops! Didn't catch that")
except sr.RequestError as e:
print("Uh oh! Couldn't request results from Google Speech Recognition service; {0}".format(e))
except KeyboardInterrupt:
pass
|
[
"c.leathart@hotmail.co.uk"
] |
c.leathart@hotmail.co.uk
|
9207c0d477fcdff3fdfc7421a7da2c788d2c36af
|
38b5f3ad3ff93342c817b74e7b315f06dd077119
|
/exec27.py
|
14ae0f84658618befe9a7b0257f2663c1df63854
|
[] |
no_license
|
xXxDevBR/Python-Exercicios
|
abff6e2fcc48b27db11d68ba375916413ca90edc
|
aaa2c1608f258023adb1d56370a9d8c596ef458e
|
refs/heads/master
| 2020-04-16T10:50:38.294074
| 2019-01-13T15:17:28
| 2019-01-13T15:17:28
| 165,518,809
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 165
|
py
|
nome = str(input('Digite seu nome: ')).strip().split()
print('Seu primeiro nome é {}'.format(nome[0]))
print('Seu último nome é {}'.format(nome[len(nome)-1]))
|
[
"xXxDevBR@clashoverdrive245@protonmail.com"
] |
xXxDevBR@clashoverdrive245@protonmail.com
|
8bf5be3241894ee6b7a5f6ec3ba7cdc9946a56f7
|
57e1c170b3721e2c4f9529415b0c015d0de91ff1
|
/utils.py
|
675248601b525ba2ea93060751236375ab0ed512
|
[] |
no_license
|
sobadrush/DockerDev-ReadCsv2Excel
|
3b849222f7cd0a64fed423df1ff179cdfc5f9794
|
4e1d1c088f6da9a34473987f8c671965b3829d7e
|
refs/heads/main
| 2023-09-05T10:00:37.796979
| 2021-11-22T07:50:41
| 2021-11-22T07:50:41
| 417,730,672
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 886
|
py
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def plus(a, b):
return a + b
def handleMemo(_list):
if len(_list) == 1 or _list[0] == '':
return
# for idx, val in enumerate(tempLine):
# if idx >= 4:
# tempLine[idx] = val.replace(" ", "，")
# return tempLine
# ref. https://www.geeksforgeeks.org/python-replace-elements-greater-than-k/
tempList = [elem.replace(" ", "，") if idx >= 4 else elem for idx, elem in enumerate(_list)]
# 1. Google: python clear list
# 2. Concate list: ref. https://stackoverflow.com/questions/1720421/how-do-i-concatenate-two-lists-in-python
_list[:] = tempList[0:5] + [''.join(tempList[5:])]
if __name__ == '__main__':
print(f'My Answer is: {plus(3, 4)}')
# myList = ["A1", "B2", "C3", "D4", "E 5", "F 6"]
# handleMemo(myList)
# print(f'handleMemo is: {myList}')
|
[
"sobadrush@icloud.com"
] |
sobadrush@icloud.com
|
a25ee7b2a7ac37922e741c367dfb32c3a7c44e00
|
dbe4e7b18e611907201f2d46a1d3df5834cae14f
|
/splunk_add_on_ucc_framework/start_alert_build.py
|
d05cfedf7930e2f14bad9b2898621ee42d26788d
|
[
"Apache-2.0"
] |
permissive
|
JasonConger/addonfactory-ucc-generator
|
d6198e0d0e8b1113034403d3e2df67c9e00f4652
|
17548eee55ee270d8954e9b3df3ebc9da2d90300
|
refs/heads/main
| 2023-04-04T20:44:55.629207
| 2021-04-12T07:12:52
| 2021-04-14T18:57:49
| 358,644,617
| 1
| 0
| null | 2021-04-16T15:35:03
| 2021-04-16T15:35:02
| null |
UTF-8
|
Python
| false
| false
| 2,621
|
py
|
# SPDX-FileCopyrightText: 2020 2020
#
# SPDX-License-Identifier: Apache-2.0
from __future__ import absolute_import
from . import normalize
import logging
import os
from .modular_alert_builder.build_core import generate_alerts
import traceback
class LoggerAdapter(logging.LoggerAdapter):
def __init__(self, prefix, logger):
super(LoggerAdapter, self).__init__(logger, {})
self.prefix = prefix
def process(self, msg, kwargs):
return '[%s] %s' % (self.prefix, msg), kwargs
def validate(alert, logger):
try:
fields = []
if alert.get("entity"):
for entity in alert.get("entity"):
if entity.get("field") in fields:
raise Exception("Field names should be unique")
else:
fields.append(entity.get("field"))
if entity.get("type") in ["radio", "singleSelect"]:
if not entity.get("options"):
raise Exception(
"{} type must have options parameter".format(entity.get("type")))
elif entity.get("options"):
raise Exception(
"{} type must not contain options parameter".format(entity.get("type")))
if entity.get("type") in ["singleSelectSplunkSearch"]:
if not all([entity.get("search"), entity.get("valueField"), entity.get("labelField")]):
raise Exception("{} type must have search, valueLabel and valueField parameters".format(
entity.get("type")))
elif any([entity.get("search"), entity.get("valueField"), entity.get("labelField")]):
raise Exception("{} type must not contain search, valueField or labelField parameter".format(
entity.get("type")))
except:
logger.error(traceback.format_exc())
raise
def alert_build(schema_content, product_id, short_name, output_dir,sourcedir):
# Initializing logger
logging.basicConfig()
logger = logging.getLogger('Alert Logger')
logger = LoggerAdapter('ta="{}" Creating Alerts'.format(short_name),
logger)
# Validation
for alert in schema_content['alerts']:
validate(alert, logger)
# Get the alert schema with required structure
envs = normalize.normalize(schema_content, product_id, short_name)
pack_folder = os.path.join(sourcedir, 'arf_dir_templates', 'modular_alert_package')
# Generate Alerts
generate_alerts(pack_folder, output_dir, logger, envs)
|
[
"rfaircloth@splunk.com"
] |
rfaircloth@splunk.com
|
21ac7b8bd278492a0c7324f8fe0d272953855df9
|
67dbbe74262b95ddce44287967d7dd7af393a60b
|
/web_deploy/__init__.py
|
bfa0f3ffe8e23bb2df5f913dedc9ed52dfdb19f2
|
[
"Apache-2.0"
] |
permissive
|
ygavenchuk/web-deploy
|
444b93e70ffa8ba848992f7cfd2a68cae0f5fb01
|
2a1cc0931a931a68114c535af3b508fc01f00684
|
refs/heads/master
| 2021-01-01T19:21:17.094038
| 2015-07-06T12:59:11
| 2015-07-06T12:59:11
| 38,040,524
| 0
| 2
| null | 2015-07-01T10:07:38
| 2015-06-25T09:31:04
|
Python
|
UTF-8
|
Python
| false
| false
| 830
|
py
|
# -*- coding: utf-8 -*-
#
# Copyright 2015 Yuriy Gavenchuk aka murminathor
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from .base import *
from .daemon import *
from .db import *
from .project import *
from .system import *
from .vcs import *
__author__ = 'y.gavenchuk'
__version__ = '0.0.3'
VERSION = __version__.split('.')
|
[
"y.gavenchuk@bvblogic.com"
] |
y.gavenchuk@bvblogic.com
|
5be51dbb88aa58f10058062d78de161544e789e6
|
cc2fcc1a0c5ea9789f98ec97614d7b25b03ba101
|
/st2common/tests/unit/test_configs_registrar.py
|
e23dfe74262ed4c55b95ba299c1a0f50fbeb08c9
|
[
"Apache-2.0"
] |
permissive
|
Junsheng-Wu/st2
|
6451808da7de84798641882ca202c3d1688f8ba8
|
c3cdf657f7008095f3c68b4132b9fe76d2f52d81
|
refs/heads/master
| 2022-04-30T21:32:44.039258
| 2020-03-03T07:03:57
| 2020-03-03T07:03:57
| 244,301,363
| 0
| 0
|
Apache-2.0
| 2022-03-29T22:04:26
| 2020-03-02T06:53:58
|
Python
|
UTF-8
|
Python
| false
| false
| 4,577
|
py
|
# Licensed to the StackStorm, Inc ('StackStorm') under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import mock
from st2common.content import utils as content_utils
from st2common.bootstrap.configsregistrar import ConfigsRegistrar
from st2common.persistence.pack import Pack
from st2common.persistence.pack import Config
from st2tests.api import SUPER_SECRET_PARAMETER
from st2tests.base import CleanDbTestCase
from st2tests import fixturesloader
__all__ = [
'ConfigsRegistrarTestCase'
]
PACK_1_PATH = os.path.join(fixturesloader.get_fixtures_packs_base_path(), 'dummy_pack_1')
PACK_6_PATH = os.path.join(fixturesloader.get_fixtures_packs_base_path(), 'dummy_pack_6')
class ConfigsRegistrarTestCase(CleanDbTestCase):
def test_register_configs_for_all_packs(self):
# Verify DB is empty
pack_dbs = Pack.get_all()
config_dbs = Config.get_all()
self.assertEqual(len(pack_dbs), 0)
self.assertEqual(len(config_dbs), 0)
registrar = ConfigsRegistrar(use_pack_cache=False)
registrar._pack_loader.get_packs = mock.Mock()
registrar._pack_loader.get_packs.return_value = {'dummy_pack_1': PACK_1_PATH}
packs_base_paths = content_utils.get_packs_base_paths()
registrar.register_from_packs(base_dirs=packs_base_paths)
# Verify pack and schema have been registered
pack_dbs = Pack.get_all()
config_dbs = Config.get_all()
self.assertEqual(len(pack_dbs), 1)
self.assertEqual(len(config_dbs), 1)
config_db = config_dbs[0]
self.assertEqual(config_db.values['api_key'], '{{st2kv.user.api_key}}')
self.assertEqual(config_db.values['api_secret'], SUPER_SECRET_PARAMETER)
self.assertEqual(config_db.values['region'], 'us-west-1')
def test_register_all_configs_invalid_config_no_config_schema(self):
# verify_ configs is on, but ConfigSchema for the pack doesn't exist so
# validation should proceed normally
# Verify DB is empty
pack_dbs = Pack.get_all()
config_dbs = Config.get_all()
self.assertEqual(len(pack_dbs), 0)
self.assertEqual(len(config_dbs), 0)
registrar = ConfigsRegistrar(use_pack_cache=False, validate_configs=False)
registrar._pack_loader.get_packs = mock.Mock()
registrar._pack_loader.get_packs.return_value = {'dummy_pack_6': PACK_6_PATH}
packs_base_paths = content_utils.get_packs_base_paths()
registrar.register_from_packs(base_dirs=packs_base_paths)
# Verify pack and schema have been registered
pack_dbs = Pack.get_all()
config_dbs = Config.get_all()
self.assertEqual(len(pack_dbs), 1)
self.assertEqual(len(config_dbs), 1)
def test_register_all_configs_with_config_schema_validation_validation_failure(self):
# Verify DB is empty
pack_dbs = Pack.get_all()
config_dbs = Config.get_all()
self.assertEqual(len(pack_dbs), 0)
self.assertEqual(len(config_dbs), 0)
registrar = ConfigsRegistrar(use_pack_cache=False, fail_on_failure=True,
validate_configs=True)
registrar._pack_loader.get_packs = mock.Mock()
registrar._pack_loader.get_packs.return_value = {'dummy_pack_6': PACK_6_PATH}
# Register ConfigSchema for pack
registrar._register_pack_db = mock.Mock()
registrar._register_pack(pack_name='dummy_pack_5', pack_dir=PACK_6_PATH)
packs_base_paths = content_utils.get_packs_base_paths()
expected_msg = ('Failed validating attribute "regions" in config for pack "dummy_pack_6" '
'(.*?): 1000 is not of type u\'array\'')
self.assertRaisesRegexp(ValueError, expected_msg,
registrar.register_from_packs,
base_dirs=packs_base_paths)
|
[
"wei.ying@easystack.cn"
] |
wei.ying@easystack.cn
|
3df1a403fdfd729c21e8a16868b681af9bfc772f
|
7f8ac39fa2d83a6a12cbb7ac26996dc465f57bcb
|
/Analysis/susyAnalysis.py
|
3f1324ab35c40586a4a7a5d10f4c283c9fbe1a80
|
[] |
no_license
|
ingridavh/SUSY
|
7450ce7c2bec21e78158c2448eb7d016fddbb875
|
8a9b3a6eae1720b5674a06d01ffda91b87234554
|
refs/heads/master
| 2021-01-20T09:36:55.930940
| 2017-06-01T17:42:43
| 2017-06-01T17:42:43
| 90,267,226
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 7,706
|
py
|
import AnalysisHelpers as AH
import ROOT
import Analysis
import math
#======================================================================
class susyAnalysis(Analysis.Analysis):
"""Semileptonic susyAnalysis loosely based on the ATLAS analyses of top pair events where
one W boson decays to leptons and one decays to hadrons.
"""
def __init__(self, store):
super(susyAnalysis, self).__init__(store)
def initialize(self):
self.hist_WtMass = self.addStandardHistogram("WtMass")
self.hist_leptn = self.addStandardHistogram("lep_n")
self.hist_leptpt = self.addStandardHistogram("lep_pt")
self.hist_lepteta = self.addStandardHistogram("lep_eta")
self.hist_leptE = self.addStandardHistogram("lep_E")
self.hist_leptphi = self.addStandardHistogram("lep_phi")
self.hist_leptch = self.addStandardHistogram("lep_charge")
self.hist_leptID = self.addStandardHistogram("lep_type")
self.hist_leptptc = self.addStandardHistogram("lep_ptconerel30")
self.hist_leptetc = self.addStandardHistogram("lep_etconerel20")
self.hist_lepz0 = self.addStandardHistogram("lep_z0")
self.hist_lepd0 = self.addStandardHistogram("lep_d0")
self.hist_njets = self.addStandardHistogram("n_jets")
self.hist_jetspt = self.addStandardHistogram("jet_pt")
self.hist_jetm = self.addStandardHistogram("jet_m")
self.hist_jetJVF = self.addStandardHistogram("jet_jvf")
self.hist_jeteta = self.addStandardHistogram("jet_eta")
self.hist_jetmv1 = self.addStandardHistogram("jet_MV1")
self.hist_jet1pt = self.addStandardHistogram("jet1_pt")
self.hist_jet2pt = self.addStandardHistogram("jet2_pt")
self.hist_jet3pt = self.addStandardHistogram("jet3_pt")
self.hist_etmiss = self.addStandardHistogram("etmiss")
self.hist_vxp_z = self.addStandardHistogram("vxp_z")
self.hist_pvxp_n = self.addStandardHistogram("pvxp_n")
#Self-added
self.hist_mt = self.addStandardHistogram("mt")
self.hist_meff = self.addStandardHistogram("meff")
self.hist_meratio = self.addStandardHistogram("meratio")
def analyze(self):
# retrieving objects
eventinfo = self.Store.getEventInfo()
weight = eventinfo.scalefactor()*eventinfo.eventWeight() if not self.getIsData() else 1
self.countEvent("all", weight)
# apply standard event based selection
if not AH.StandardEventCuts(eventinfo): return False
self.countEvent("EventCuts", weight)
# neutrinos are expected, so cut on missing transverse momentum
#-----------------------------------Change cut according to signal
etmiss = self.Store.getEtMiss()
#self.countEvent("MET", weight)
# one good lepton from one of the W boson decays is expected, so require exactly one good lepton
goodLeptons = AH.selectAndSortContainer(self.Store.getLeptons(), AH.isGoodLepton, lambda p: p.pt())
if not (len(goodLeptons) == 1): return False
self.countEvent("1 Lepton", weight)
leadlepton = goodLeptons[0]
# two jets from one of the W boson decays as well as two b-jets from the top pair decays are expected
#-------------------------------------------------------
#HER kan du bestemme antall jets
goodJets = AH.selectAndSortContainer(self.Store.getJets(), AH.isGoodJet, lambda p: p.pt())
#Require at least 3 jets
if not (len(goodJets) >= 3) : return False
self.countEvent("Jets", weight)
#PT requirement on leading lepton
if not (leadlepton.pt() > 25) : return False
#lepton veto
if len(goodLeptons) > 1 :
if not (goodLeptons[-1].pt() > 10): return False
#----------------------------------------------------
#PT requirement on leading jets
if not goodJets[0].pt() > 80: return False
if not goodJets[1].pt() > 80: return False
if not goodJets[2].pt() > 30: return False
#Jet veto
if len(goodJets) > 4:
if goodJets[4].pt() > 40: return False
#Cut on missing energy
#change to 400GeV because of plot
if not (etmiss.et() > 500.0): return False
# apply the b-tagging requirement using the MV1 algorithm at 80% efficiency
#-------------------------Not looking for b-jets
btags = sum([1 for jet in goodJets if jet.mv1() > 0.7892])
#if not (btags >= 2): return False
#self.countEvent("btags", weight)
# apply a cut on the transverse mass of the W boson decaying to leptons
#-----------------Change transverse mass mass according to sample
#if not (AH.WTransverseMass(leadlepton, etmiss) > 30.0): return False
#trasverse mass
mt = math.sqrt( 2*leadlepton.pt() * etmiss.et() * (1-math.cos(leadlepton.phi()) ) )
#inclusive effective mass and exclusive effective mass
meffincl = etmiss.et()
meffexcl = etmiss.et()
for i in range(len(goodLeptons)) :
meffincl += goodLeptons[i].pt()
meffexcl += goodLeptons[i].pt()
for j in range(len(goodJets)) : meffincl += goodJets[j].pt()
for k in range(3) : meffexcl += goodJets[k].pt()
#Ratio
emratio = 0
if not meffexcl == 0 :
emratio = etmiss.et()/float(meffexcl)
# cut on transverse mass
if not (mt > 150) : return False
#cut on ratio
if not (emratio > 0.3) : return False
#cut on effective inclusive mass
if not (meffincl > 1400) : return False
# Histograms detailing event information
self.hist_vxp_z.Fill(eventinfo.primaryVertexPosition(), weight)
self.hist_pvxp_n.Fill(eventinfo.numberOfVertices(), weight)
# histograms for the W boson properties
self.hist_WtMass.Fill(AH.WTransverseMass(leadlepton, etmiss), weight)
# histograms for missing et
self.hist_etmiss.Fill(etmiss.et(),weight)
# histograms detailing lepton information
self.hist_leptn.Fill(len(goodLeptons), weight)
self.hist_leptpt.Fill(leadlepton.pt(), weight)
self.hist_lepteta.Fill(leadlepton.eta(), weight)
self.hist_leptE.Fill(leadlepton.e(), weight)
self.hist_leptphi.Fill(leadlepton.phi(), weight)
self.hist_leptch.Fill(leadlepton.charge(), weight)
self.hist_leptID.Fill(leadlepton.pdgId(), weight)
self.hist_lepz0.Fill(leadlepton.z0(), weight)
self.hist_lepd0.Fill(leadlepton.d0(), weight)
self.hist_leptptc.Fill(leadlepton.isoptconerel30(), weight)
self.hist_leptetc.Fill(leadlepton.isoetconerel20(), weight)
# histograms detailing jet information
self.hist_njets.Fill(len(goodJets), weight)
[self.hist_jetm.Fill(jet.m(), weight) for jet in goodJets]
[self.hist_jetspt.Fill(jet.pt(), weight) for jet in goodJets]
[self.hist_jetJVF.Fill(jet.jvf(), weight) for jet in goodJets]
[self.hist_jeteta.Fill(jet.eta(), weight) for jet in goodJets]
[self.hist_jetmv1.Fill(jet.mv1(), weight) for jet in goodJets]
self.hist_jet1pt.Fill(goodJets[0].pt(), weight)
self.hist_jet2pt.Fill(goodJets[1].pt(), weight)
self.hist_jet3pt.Fill(goodJets[2].pt(), weight)
#Histograms detailing self-added
self.hist_mt.Fill(mt, weight)
self.hist_meff.Fill(meffincl, weight)
self.hist_meratio.Fill(emratio, weight)
return True
def finalize(self):
pass
|
[
"ingridavh@hotmail.com"
] |
ingridavh@hotmail.com
|
2da6036ab876d2232b76b7ef2f9869daa5258513
|
1d3c4449b6884578dbd9b8d0cdcf183c844c2801
|
/1106.py
|
13f7dcb81326f394a13899b3001195962f6aa552
|
[] |
no_license
|
thanos73k/CoTe
|
fa5e84048c6405daa712445391b14e9160fb7507
|
e96754b970ed33269c50fef00973aa066d9739a6
|
refs/heads/main
| 2023-07-13T10:42:51.845553
| 2021-08-23T14:31:08
| 2021-08-23T14:31:08
| 383,343,960
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 305
|
py
|
goal, city= map(int, input().split())
info=[]
INF=987654321
dp=[0] + [INF]* 2000
for _ in range(city):
tmp =list( map(int,input().split()))
info.append(tmp)
for cost, people in info:
for i in range(people, goal + people):
dp[i]= min(dp[i],dp[i-people]+cost)
print(min(dp[goal:]))
|
[
"59728699+thanos73k@users.noreply.github.com"
] |
59728699+thanos73k@users.noreply.github.com
|
196964f8812712d14c761353096cc995312f630d
|
52b5773617a1b972a905de4d692540d26ff74926
|
/.history/containsDuplicate_20200907093833.py
|
a13711fe822495f778880bcdac9e84cd2d398e7d
|
[] |
no_license
|
MaryanneNjeri/pythonModules
|
56f54bf098ae58ea069bf33f11ae94fa8eedcabc
|
f4e56b1e4dda2349267af634a46f6b9df6686020
|
refs/heads/master
| 2022-12-16T02:59:19.896129
| 2020-09-11T12:05:22
| 2020-09-11T12:05:22
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 133
|
py
|
def duplicate(nums,k,t):
number = None
for i in range(len(nums)):
for j in range(i+1,len(nums)):
if nu
|
[
"mary.jereh@gmail.com"
] |
mary.jereh@gmail.com
|
8f580dc6cac81d892c88c452ae7a6db718851418
|
ded0a8f68a945d40aaeabdd298a08117cbe79e3c
|
/Projets/fonction.py
|
ea482df223a7f40553a74440ee21358e51c510cf
|
[] |
no_license
|
Stephanie-Njike/Python
|
cd3931af29851f3bc89ccf468123dcb8c01b496b
|
f22f3a5ddb19bd27404a532781802ef7d33af8bc
|
refs/heads/main
| 2023-07-05T15:39:41.744830
| 2021-08-09T15:28:25
| 2021-08-09T15:28:25
| 394,320,479
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 4,242
|
py
|
"""
def list_in_param(*params):
return params[0]+params[1]+params[2]
value = list_in_param(1, 2, 3, 4, 5, 8)
print(value)
value2 = list_in_param('1', '2', '3', '4')
print(value2)
def list_in_param2(a, *params):
return params[0]+params[1]+params[2]+a
value = list_in_param2(1, 2, 3, 4, 5, 8)
print(value)
def dico_in_param(**params):
return params
print(dico_in_param(nom="Stephanie", prenom="olive"))
def maliste(listeParam):
listeParam.append('moi')
return listeParam
liste = [1, 2, 3]
print(maliste(liste))
"""
"""
def triangle(n):
nombre_espace_gauche = n
nombre_etoiles_milieu = 1
nombre_espace_droit = n
for i in range(n):
for j in range (nombre_espace_gauche):
print(' ', end = '')
for k in range (nombre_etoiles_milieu):
print('*', end = '')
for l in range (nombre_espace_droit):
print(' ', end = '')
# print(' => ',i)
print('')
nombre_espace_gauche = nombre_espace_gauche - 1
nombre_etoiles_milieu = nombre_etoiles_milieu + 2
nombre_espace_droit = nombre_espace_droit - 1
return " "
print(triangle(n = int(input("saisir la hauteur du triangle : "))))
"""
"""
def triangleNewMethod(n):
espace = n
nombreEtoile = 1
for i in range(n):
print(' '*espace, '*'*nombreEtoile, ' '*espace)
espace = espace - 1
nombreEtoile = nombreEtoile + 2
triangleNewMethod(n = int(input("saisir la hauteur du triangle : ")))
"""
"""
def maximum(nb1,nb2,nb3):
max1 = nb1
if nb1 > nb2 and nb1 > nb3:
max1 = nb1
if nb3 > nb1 and nb3 > nb2:
max1 = nb3
else:
max1 = nb2
return max1
print(maximum(nb1 = int(input("saisir le premier nombre : ")),
nb2 = int(input("saisir le deuxieme nombre : ")),
nb3 = int(input("saisir le troisieme nombre : "))))
"""
"""
def triangleAvecChiffres(n):
espace = n
nombreEtoile = 2
valeurAAfficher = 1
for i in range(n):
if valeurAAfficher < n:
print(' '*espace, str(valeurAAfficher)*nombreEtoile, ' '*espace)
espace = espace - 1
nombreEtoile = nombreEtoile + 2
valeurAAfficher = valeurAAfficher + 1
triangleAvecChiffres(n = int(input("saisir la hauteur du triangle : ")))
"""
"""
def triangleNewMethod(n):
espace = n
nombreEtoile = 2
for i in range(1, n):
print(' '*espace, str(i)*nombreEtoile, ' '*espace)
espace = espace - 1
nombreEtoile = nombreEtoile + 2
triangleNewMethod(n = int(input("saisir la hauteur du triangle : ")))
"""
"""
def chiffre_porte_bonheur (nb):
nouveau = nb
while nouveau >= 10:
resultat = str(nouveau)
somme = 0
for i in range(len(resultat)):
chiffre = int(resultat[i])
print(chiffre,"**2 = ",chiffre**2)
somme = somme + chiffre**2
nouveau = somme
if nouveau == 1:
print("le chiffre ", nb, " est un chiffre porte bonheur")
else:
print ("le chiffre ", nb, " n'est pas un chiffre porte bonheur")
print(chiffre_porte_bonheur (nb = int(input("saisir le nombre : "))))
"""
"""
def compte_mot(phrase):
liste_mot = phrase.split(':')
print(liste_mot)
nombre_mot = len(liste_mot)
return nombre_mot
print(compte_mot('Bonjour:toi:et:moi:aussi'))
"""
"""
def NbCMin(passe):
liste = [i.islower() for i in passe]
print(liste)
return sum(liste)
"""
"""
def NbCMin(passe):
som = 0
for i in passe:
if i.islower():
som = som + 1
return som
print(NbCMin('paREDsse'))
"""
"""
def longMaj(passe):
longMajMax = 0
longTmp = 0
for i in passe:
if i.isupper():
longTmp = longTmp + 1
else:
longTmp = 0
if longTmp > longMajMax:
longMajMax = longTmp
return longMajMax
print(longMaj('ERRRiiuooiiAAfgghrrhhhDDDDR'))
"""
def premier_nb(borninf,bornsup):
for nbr1 in range(borninf,bornsup):
nbrpre = 1
for div1 in range(2,nbr1):
if nbr1 % div1 == 0:
nbrpre = 0
if nbrpre == 1:
print("Le nombre - ",nbr1, " - est premier" )
return nbr1
premier_nb(1,100)
|
[
"pair_one@smart-coders.guru"
] |
pair_one@smart-coders.guru
|
dcb6d1f9b8f18e4873a300301df53135071597f8
|
853f628139c5accdb14a2bcbcb2ea11df5e2ea82
|
/3-5.py
|
3e90e66f83d69f658ce7c67025617164fef60c0b
|
[
"MIT"
] |
permissive
|
MasazI/python-r-stan-bayesian-model
|
cdcc49348a55bbd615925da8de5f260a6235620b
|
05a224958a3f5cbea207001465ac12b6862d9d9f
|
refs/heads/master
| 2022-02-28T13:21:32.779730
| 2019-11-03T13:36:04
| 2019-11-03T13:36:04
| 218,285,214
| 5
| 2
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,098
|
py
|
###############
#
# Transform R to Python Copyright (c) 2016 Masahiro Imai Released under the MIT license
#
###############
import os
import numpy as np
import pystan
import pandas
import pickle
import seaborn as sns
import matplotlib.pyplot as plt
import arviz as az
file_beer_sales_2 = pandas.read_csv('3-2-1-beer-sales-2.csv')
print(file_beer_sales_2.head())
# sns.pairplot(file_beer_sales_2)
# plt.show()
print(len(file_beer_sales_2))
sample_num = len(file_beer_sales_2)
temperature_pred = range(11,31)
stan_data = {
'N': sample_num,
'sales': file_beer_sales_2['sales'],
'temperature': file_beer_sales_2['temperature'],
'N_pred': len(temperature_pred),
'temperature_pred': temperature_pred
}
if os.path.exists('3-3-1-simple-lm-pred.pkl'):
sm = pickle.load(open('3-3-1-simple-lm-pred.pkl', 'rb'))
else:
# a model using prior for mu and sigma.
sm = pystan.StanModel(file='3-3-1-simple-lm-pred.stan')
mcmc_result = sm.sampling(
data=stan_data,
seed=1,
chains=4,
iter=2000,
warmup=1000,
thin=1
)
print(mcmc_result)
# mcmc_result.plot()
# plt.show()
mcmc_sample = mcmc_result.extract(permuted=True)
print(mcmc_sample['sales_pred'].shape)
az.plot_forest([mcmc_sample['beta'], mcmc_sample['Intercept']])
plt.show()
# visualization of regression line
df = pandas.DataFrame(mcmc_sample['sales_pred'])
col = np.arange(11,31)
df.columns = col
qua = [0.025, 0.25, 0.50, 0.75, 0.975]
d_est = pandas.DataFrame()
for i in np.arange(len(df.columns)):
for qu in qua:
d_est[qu] = df.quantile(qu)
print(d_est)
x = d_est.index
y1 = d_est[0.025].values
y2 = d_est[0.25].values
y3 = d_est[0.5].values
y4 = d_est[0.75].values
y5 = d_est[0.975].values
plt.fill_between(x,y1,y5,facecolor='blue',alpha=0.1)
plt.fill_between(x,y2,y4,facecolor='blue',alpha=0.5)
plt.plot(x,y3,'k-')
plt.scatter(file_beer_sales_2["temperature"],file_beer_sales_2["sales"],c='b')
plt.show()
# saving compiled model
if not os.path.exists('3-3-1-simple-lm-pred.pkl'):
with open('3-3-1-simple-lm-pred.pkl', 'wb') as f:
pickle.dump(sm, f)
|
[
"masaz.dream@gmail.com"
] |
masaz.dream@gmail.com
|
286901b3a6a7ec15eaad0c29b53851f0e00a3e81
|
599db5e2e3c4d6c296de25a8ef8e95a862df032b
|
/OpenAI Gym/(clear)breakout-ramdeterministic-v4/model6/14000epi/modelPlay.py
|
7e5537269ecb2dd11378115b992616635625fad7
|
[] |
no_license
|
wantyouring/ML-practice-code
|
bb7577e99f22587c7ca016c1c4d067175e5ce9d9
|
a3efbb4d252bacc831c5d7a01daf6476e7a755e4
|
refs/heads/master
| 2020-05-14T17:45:17.735081
| 2019-06-30T14:43:25
| 2019-06-30T14:43:25
| 181,898,074
| 0
| 1
| null | 2019-06-15T05:52:44
| 2019-04-17T13:31:24
|
Python
|
UTF-8
|
Python
| false
| false
| 3,233
|
py
|
# 학습모델 play. random action과 학습model 비교.
import gym
import pylab
import numpy as np
import gym.wrappers as wrappers
from doubleDQN2 import DoubleDQNAgent
EPISODES = 1 # 처음은 random으로 수행, 나중에는 학습model로 수행
global_step = 0
def change_action(action):
if action == 0:
return 0
elif action == 1:
return 2
elif action == 2:
return 3
elif action == 3:
return 3
if __name__ == "__main__":
env = gym.make('Breakout-ramDeterministic-v4')
env = wrappers.Monitor(env,"./results",force = True)
state_size = 128
action_size = 3
agent = DoubleDQNAgent(state_size, action_size)
agent.load_model()
agent.epsilon = -1 # Q value에 의해서만 움직이게끔.
agent.render = True
scores, episodes = [], []
random_success_cnt = 0
model_success_cnt = 0
# 랜덤액션 진행시
for e in range(EPISODES):
done = False
score = 0
life = 5
env.reset()
for i in range(5):
env.step(1) # 시작 action.
while not done:
action = env.action_space.sample()
_, reward, done, info = env.step(change_action(action))
score += reward
if done:
if score > 0:
random_success_cnt += 1
print("episode:", e, " score:", score)
scores.append(score)
episodes.append(e)
break
if life != info['ale.lives']:
life = info['ale.lives']
for i in range(5):
state, _, _, _ = env.step(1)
state = np.reshape(state, [1, 128])
# 학습모델 play
for e in range(EPISODES,EPISODES*2):
done = False
life = 5
score = 0
state = env.reset()
for i in range(5):
state, _, _, _ = env.step(1) # 시작 action.
state = np.reshape(state,[1,128])
while not done:
global_step += 1
if agent.render:
env.render()
# 현재 s에서 a취해 s`, r, done 정보 얻기.
action = agent.get_action(state)
next_state, reward, done, info = env.step(change_action(action))
score += reward
state = next_state
state = np.reshape(state, [1, 128])
if done:
if score > 0 :
model_success_cnt += 1
print("episode:", e, " score:", score)
scores.append(score)
episodes.append(e)
if e % 5 == 0:
pylab.plot(episodes, scores)
pylab.savefig("./play_score.png")
break
if life != info['ale.lives']:
life = info['ale.lives']
for i in range(5):
state, _, _, _ = env.step(1)
state = np.reshape(state, [1, 128])
env.close()
print("random : {}/{} success. rate : {}".format(random_success_cnt,EPISODES,random_success_cnt/EPISODES))
print("model : {}/{} success. rate : {}".format(model_success_cnt,EPISODES,model_success_cnt/EPISODES))
|
[
"pwc99@naver.com"
] |
pwc99@naver.com
|
4a18ef0719c0058c463c0200d66e76acbe62ccfd
|
e49b654d3db99773390c5b9686df9c99fbf92b2a
|
/linked_lists/is_palindrome.py
|
703a4960dc6cfbe7e741efde1dd056a7ede1b2cc
|
[] |
no_license
|
hao89/diary_of_programming_puzzles
|
467e8264d0ad38768ba5ac3cfb45301293d79943
|
0e05d3716f28075f99bbd7b433d16a383209e57c
|
refs/heads/master
| 2021-01-16T00:49:38.956102
| 2015-08-25T13:44:53
| 2015-08-25T13:44:53
| 41,692,587
| 1
| 0
| null | 2015-08-31T18:20:38
| 2015-08-31T18:20:36
|
Python
|
UTF-8
|
Python
| false
| false
| 831
|
py
|
"""
Implement a function to check if a linked list is a palindrome
"""
import random
from linked_list import LinkedListNode
def is_palindrome1(linked_list):
# reverse and compare
pass
def build_palindrome_list():
root = LinkedListNode(5)
previous_node = root
for i in range(0, 2):
new_node = LinkedListNode(random.randint(0, 9))
previous_node.next = new_node
previous_node = new_node
stack = []
current_node = root
while current_node.next != None: # all but the last one
stack.append(current_node.data)
current_node = current_node.next
while len(stack) != 0:
data = stack.pop()
new_node = LinkedListNode(data)
previous_node.next = new_node
previous_node = new_node
return root
def build_random_list():
pass
|
[
"me@davidadamojr.com"
] |
me@davidadamojr.com
|
8f7329745bd74286e1d3df0ea9914dfa18347a3b
|
0e0e755dcee24259fff3223a8f3579e6f1717e52
|
/Final Project/final project.py
|
2d98f59c616276085d2f0eb8e5a7fe6aaa72f1ff
|
[] |
no_license
|
anwittin/Python
|
0e25eb4cf7822d338e9fd64da1d7daa058d249c0
|
1a9eeba502dc74b0279fab8466f6d088a6fc425f
|
refs/heads/master
| 2016-08-12T04:27:13.080084
| 2016-01-01T22:40:11
| 2016-01-01T23:16:36
| 43,617,445
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,384
|
py
|
from sys import exit
import time
def kitchen():
print "This is the kitchen, there is food to cook and a small door at the back too."
print "You're hungry. what do you do?"
print "cook | enter door"
choice = raw_input("> ").lower()
if choice == 'cook':
print "Nice, hopefully you know what you're doing!\n"
print "Smells good, I hope you enjoy it"
print "Here come the zombies!"
dead("You shouldn't have started cooking...")
else:
print "Smart choice zombies like the smell of food."
print "This door leads to a safe room."
safe_room()
def front_room():
print "You're in the living room, there is a body here."
time.sleep(.75)
print "The body looks worse for wear. It may be a zombie."
time.sleep(.75)
print "The body starts moving and is blocking the next room."
time.sleep(.75)
print "What are you going to do? Punch | Stab | Run"
zombie_moved = False
while True:
choice = raw_input("> ").lower()
if choice == "punch":
dead("The zombie is fast and grabs you and eats your face.")
elif choice == "stab":
print "The zombie takes the stabbing and keeps coming at you."
print "What do you do now? Punch | Stab | Run"
elif choice == "run":
print "That was close!"
safe_room()
else:
print "I got no idea what that means."
def bedroom_room():
print "You are in a bedroom."
time.sleep(.75)
print "There is a bed, some clean clothes here and a closet."
time.sleep(.75)
print "What do you want to do? Sleep | Change | Closet | Cry "
choice = raw_input("> ").lower()
if "cry" in choice:
dead("Bummer, your tears brought the zombies.")
elif "closet" in choice:
safe_room()
elif "change" in choice:
tomorrow("A clean set of clothes helps win the smell battle.")
elif "Sleep" in choice:
dead("You gotta find a safer place to sleep!")
else:
print "Type Sleep | Change | Closet | Cry "
def safe_room():
print "You found the safe room, with food, water and weapons."
time.sleep(.75)
print "Good job it looks like you may survive until tomorrow"
time.sleep(.75)
print "What do you want to do? Sleep | Eat | Equip weapons | Go Outside"
while True:
choice = raw_input("> ").lower()
if choice == "sleep":
tomorrow("Sleep until things get better")
elif choice == "eat":
print "Nom Nom Nom"
tomorrow("Full belly to fight again tomorrow")
elif choice == "equip weapons":
print "You're a fighter!"
tomorrow("Mount up")
elif choice == "go outside":
print "That was a bad idea :-/"
dead("The zombies eat your brains.")
else:
print "I got no idea what that means."
def dead(why):
print why,"Good job! You're a zombie now."
print "Play again? Y / N"
choice = raw_input("> ").lower()
if choice == 'y':
start()
else:
print "Thanks for playing"
exit()
def tomorrow(why):
print why, "\nWinner Winner not a zombie dinner!"
print "Play again? Y / N"
choice = raw_input("> ").lower()
if choice == 'y':
start()
else:
print "Thanks for playing"
exit()
def start():
print "You have just escaped from the zombies that are outside."
print "There is a door to the north, east and west."
print "Which one do you take?"
choice = raw_input("> ")
if choice == "west":
front_room()
elif choice == "east":
bedroom_room()
elif choice == "north":
kitchen()
else:
dead("You stumble around the room until you starve.")
start()
|
[
"anwittin@gmail.com"
] |
anwittin@gmail.com
|
9620bd4a537d18089f1bbe6c5d247c907e171b40
|
486ea742752f63c65015fb982798a7fef43c8bae
|
/bot/account_manager/browser_automation_utils/webdrivermanager.py
|
848cc683628670552bb1be960c9d49720e99406d
|
[] |
no_license
|
rrosajp/BingRewardsBot
|
6f17ec00a624cc8406bef5f4c0fbf32ec340521f
|
56d4012dfda61ee7303a6942f87635bdb4e4c820
|
refs/heads/master
| 2021-06-01T10:16:33.546077
| 2016-08-14T08:29:50
| 2016-08-14T08:29:50
| 286,825,267
| 1
| 0
| null | 2020-08-11T18:59:02
| 2020-08-11T18:59:01
| null |
UTF-8
|
Python
| false
| false
| 2,327
|
py
|
import os
import browsertypes
_ABS_PATH_TO_THIS_DIR = os.path.realpath(os.path.dirname(__file__))
def _make_path_absolute(path):
'''
@param path
A relative or absolute path to a webdriver executable __file__
@return
- If path is absolute or None, then return as is.
- Otherwise, if path is relative, then make it absolute by prepending
_ABS_PATH_TO_THIS_DIR to it.
'''
abs_path = path
if not path or os.path.isabs(path):
return path
return os.path.join(_ABS_PATH_TO_THIS_DIR, path)
def get_selenium_webdriver(browser_type, mobile = False):
'''
@param browser_type
Specifies the type of the target browser (e.g., Chrome, Firefox, etc.).
@param mobile
By default, mobile = False, so the webdriver will be returned as is,
with no extra config.
But, if mobile = True, then the webdriver will be configured to spoof
a mobile browser's user-agent.
@return
- The Selenium webdriver object for the target browser type
- None if no such object can be constructed (b/c of missing driver executable,
missing config for specified browser type, etc.)
'''
all_webdriver_config = browsertypes.WEBDRIVER_CONFIG
# If there is no webdriver config for the specified browser type, return None.
driver_config = all_webdriver_config.get(browser_type.value, None)
if not driver_config:
return None
# If the specified browser type is Firefox, then the executable path is not required
# since Selenium offers in-built support for the Firefox webdriver.
if browser_type.value == browsertypes.BrowserType.Firefox.value:
return driver_config[browsertypes.SELENIUM_WEBDRIVER]("", mobile).get_driver()
# For all other browser types, get the path to the webdriver executable that can run
# on the current platform, and create a Selenium webdriver object that uses this path.
# If there is no path for the current platform, then return None.
executable_path = _make_path_absolute(driver_config.get(browsertypes.CURRENT_PLATFORM, None))
return driver_config[browsertypes.SELENIUM_WEBDRIVER](executable_path, mobile).get_driver() if executable_path else None
|
[
"sairambkrishnan@gmail.com"
] |
sairambkrishnan@gmail.com
|
00ccd496ce7dea6f368a321332faf326dce7f540
|
a38eb3c692ea213b9db90148edb2052468ff7bc3
|
/datasets/__init__.py
|
da8a68bfb78cbd159bf9a7a64efa3cf0917df160
|
[] |
no_license
|
VictorTao1998/ActiveStereoRui
|
cc5cc5d282d2935dab5c7ecb34e691a88682ec4e
|
cd5325932b52ff4090e6e40403a8710a99723a6d
|
refs/heads/main
| 2023-08-24T03:59:05.904458
| 2021-10-28T17:42:31
| 2021-10-28T17:42:31
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 45
|
py
|
"""
Author: Isabella Liu 8/8/21
Feature:
"""
|
[
"jit124@ucsd.edu"
] |
jit124@ucsd.edu
|
69709d69ea014f6f4dfe7ed425332532be7c41f0
|
617c294d421f8abbd7f85e627bf662430b7a28bc
|
/easy_web_py/core/mainHandler.py
|
d08aba816b8ec4082b3093df6830c42b896bf31a
|
[] |
no_license
|
Gustavovaler/easy_web_py
|
a6a9df7b3f30e9c9226921fd6205b8918c6fb7af
|
695e8713c06dbbabcab5bb584f53dbf0820dc95f
|
refs/heads/master
| 2022-09-21T03:08:21.632406
| 2020-06-04T06:39:53
| 2020-06-04T06:39:53
| 256,370,531
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 371
|
py
|
from http.server import BaseHTTPRequestHandler
from ..resources.routes import routes_list
class MainHandler(BaseHTTPRequestHandler):
print(routes_list)
def parse_path(self):
for route in routes_list:
if self.path in route["path"]:
self.controller_request = route["controller"]
return self.controller_request
|
[
"gustavodevaler@gmail.com"
] |
gustavodevaler@gmail.com
|
4ce5322003186f1ce33d14ae98702957ae346789
|
0cbe53436e0e753c41b039a3050f77a8b7f2e0e1
|
/data_pro/Queries_pkl.py
|
e2f6e2feee71993a08e39c38d504c278388b8a1d
|
[] |
no_license
|
s1530129650/Code_Recommendation
|
9848d95ec3edc7c61a48178b9e9e06348b2e2e66
|
1d77e1a35a1ab92a717e0435e521cf4ff520cec6
|
refs/heads/master
| 2020-05-14T23:51:11.111958
| 2019-05-28T12:08:56
| 2019-05-28T12:08:56
| 182,002,981
| 1
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 6,380
|
py
|
#!/usr/bin/env python
#!-*-coding:utf-8 -*-
"""
@version: python3.7
@author: v-enshi
@license: Apache Licence
@contact: 123@qq.com
@site:
@software: PyCharm
@file: Queries_pkl.py
@time: 2019/4/25 9:46
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import json
import random
import numpy as np
import time
torch.manual_seed(1)
use_gpu = False
use_gpu = True
if use_gpu:
device = torch.device("cuda")
max_vocab_size = 50000
CONTEXT_WINDOW = 100
else:
device = torch.device("cpu")
max_vocab_size = 100
CONTEXT_WINDOW = 100
time_start = time.time()
##1. data loading {"type":xxx, "children":XXX} or {"type":xxx, "value":XXX}
def data_loading(filepath):
data = []
with open(filepath, 'r') as load_f:
data1 = load_f.readlines()
for i in range(len(data1)):
content = json.loads(data1[i])
data.append(content)
return data
if use_gpu:
training_path = r"../data/python/python100k_train.json"
else:
str = r"D:\v-enshi\Language model\suggestion\Code Completion with Neural Attention and Pointer Networks"
training_path = str + r"\data\python\f10_.json"
training_data = data_loading(training_path)
now = time.time()
print("data loading",now-time_start)
## 2. build vocabulary
def build_vocab(data):
type_to_ix = {"EOF": 0,"UNK":1}
word_to_ix = {}
for i in range(len(data)):
for item in data[i]:
if item["type"] not in type_to_ix:
type_to_ix[item["type"]] = len(type_to_ix)
if "value" in item.keys():
if item["value"] in word_to_ix:
word_to_ix[item["value"]] = word_to_ix[item["value"]] + 1
else:
word_to_ix[item["value"]] = 1
# 1k 10k 50k vocabulary
L = sorted(word_to_ix.items(), key=lambda item: item[1], reverse=True)
print("L len",len(L),L[max_vocab_size][1])
value_to_ix = {"EOF": 0,"UNK":1}
for i in range(max_vocab_size):
value_to_ix[L[i][0]] = len(value_to_ix)
return type_to_ix, value_to_ix
type_vocab,value_vocab = build_vocab(training_data)
now = time.time()
print("build vocabulary",now-time_start)
# 3. make the queries
def Queries(data):
data_rd = []
random = np.random.RandomState(0)
for i in range(len(data)):
length = len(data[i])
if length <= CONTEXT_WINDOW + 2:
continue
rd = random.randint(CONTEXT_WINDOW + 1, length - 1)
while "value" not in data[i][rd].keys(): # 1.look for leaf node
rd = rd + 1
if rd >= length:
break
if rd >= length:
continue
query = []
# find same node in the context
for j in range(rd - 1, rd - CONTEXT_WINDOW - 1,
-1): # whether the remove node in the context.if the node in context,we remeber the position in context
if data[i][rd]["type"] == data[i][j]["type"] and "value" in data[i][j].keys() and data[i][rd]["value"] == \
data[i][j]["value"]:
#print("j$$$$$$$$$$$",rd - 1, rd - CONTEXT_WINDOW - 1,j,rd - j - 1)
query = [data[i][:rd], [data[i][rd]], rd, rd - j - 1]
break
if j == rd - CONTEXT_WINDOW: # there is no same node in context
continue
# add parents node
for j in range(rd - 1, rd - CONTEXT_WINDOW - 1, -1):
if "children" in data[i][j].keys() and rd in data[i][j]["children"]:
query.append(rd - j - 1)
break
if j == rd - CONTEXT_WINDOW:
query.append(CONTEXT_WINDOW - 1)
break
# query = [context,predict_node,position, same_node_position,parent_node_position]
data_rd.append(query)
return data_rd
training_queries = Queries(training_data)
training_queries.sort( key=lambda x: x[2],reverse=True) # sort
#print(training_queries)
now = time.time()
print("make the queries",now-time_start)
#4 text -> index
def prepare_sequence(seq, val_to_ix, type_to_ix): # trans code to idex
idxs_ty = []
idxs_vl = []
UNK = 1
for node in seq:
value_str = node.get('value', 'UNK')
idxs_vl.append(val_to_ix.get(value_str, UNK))
idxs_ty.append(type_to_ix[node.get('type', 'UNK')])
#print("np.array([idxs_ty, idxs_vl])",np.array([idxs_ty, idxs_vl]))
return torch.tensor([idxs_vl, idxs_ty],dtype = torch.long)
input_value = []
input_type = []
parent = []
target = []
for i in range(len(training_queries)):
sequence = training_queries[i][0]
[input_val, input_ty] = prepare_sequence(sequence, value_vocab, type_vocab)
par = torch.tensor(training_queries[i][4],dtype = torch.long)
targ = torch.tensor(training_queries[i][3],dtype = torch.long)
input_value.append(input_val)
input_type.append(input_ty)
parent.append(par)
target.append(targ)
now = time.time()
print("text -> index",now-time_start)
#5 padding and save
import torch.nn.utils.rnn as rnn_utils
from torch.utils.data import DataLoader
import torch.utils.data as data
class MyData(data.Dataset):
def __init__(self,data_seq, input_value, input_type, target, parent):
self.input_value = input_value
self.input_type = input_type
self.target = target
self.parent = parent
self.length = len(self.target)
self.data_length = [len(sq) for sq in data_seq]
def __len__(self):
return self.length
def __getitem__(self, idx):
return self.input_type[idx],self.input_value[idx], self.data_length[idx], self.target[idx], self.parent[idx]
x = rnn_utils.pad_sequence(input_value, batch_first=True)
y = rnn_utils.pad_sequence(input_type, batch_first=True)
dataAll = MyData(input_value,x,y,target,parent)
#print(dataAll.data_length)
now = time.time()
print("5. padding ",now-time_start)
# save
import pickle
with open('../data/python/training_50k.pickle', 'wb') as f:
pickle.dump(dataAll, f, protocol=pickle.HIGHEST_PROTOCOL)
np.savez('../data/python/vocabulary_50k.npz',value_vocab = value_vocab,type_vocab = type_vocab)
|
[
"noreply@github.com"
] |
s1530129650.noreply@github.com
|
15a49c1e93ac6f6575ef74ea8af48334dbb97f8f
|
f6f9ca202b70e93a324de89b8316f389bf838508
|
/src/gui/archat.py
|
9c95974953d8bd0a0d132a0a6ee09cafd8c5017e
|
[
"MIT"
] |
permissive
|
180D-FW-2020/Team8
|
4e6d46870041d5015f2d5094acd44f15270017fa
|
ba439a2e65d759d0abd8d4fa827601b16228d841
|
refs/heads/master
| 2023-03-13T20:00:05.024413
| 2021-03-11T17:43:04
| 2021-03-11T17:43:04
| 297,810,211
| 2
| 1
|
MIT
| 2021-03-11T17:41:58
| 2020-09-23T00:46:07
|
Python
|
UTF-8
|
Python
| false
| false
| 7,302
|
py
|
## AR Chat #######################################################################################################
## a class for creating a message board in OpenCV
ROOT = "data/gui/"
import cv2 as cv
'''
An ARChat object outputs an array with a custom UI created by the Butcher Bros (spec. Michael)
Public Functions:
- post: posts a message to the ARChat
- stage: stages a message to the user's staging area
- getPath: returns the path to the ARChat image
'''
class ARChat():
'''
Initialize a new ARChat.
The ARChat always initializes with at least one board topic, "general"
Inputs:
- topic: the topic associated with each ARChat
- roomIndex: number signifying which chatroom in the list of chatrooms is currently selected
- chatrooms: a list of type str, which contains a string of currently active boards
'''
def __init__(self, topic, roomIndex, chatrooms = []):
self.topic = topic
self.messages = []
self.rooms = chatrooms
self.roomIndex = roomIndex
self.wordlimit = 42
self.fontSize = 1.5
self.boardpath = topic
self.stagedMessage = ""
self.write_messages()
self.write_rooms()
'''
Posts a message to be updated to the currently active board
Inputs:
- user (str): the name of the user who sent the message
- message (str): the message sent by the user
- color (tuple): the RGB tuple associated with the user
- time (dict): dictionary with hour, minute, second
'''
def post(self, user, message, color, timestamp, overflow=False):
h = ""
m = ""
s = ""
if(len(user) + len(message) <= self.wordlimit):
if(overflow == False):
h = str(timestamp["hour"])
m = str(timestamp["minute"])
s = str(timestamp["second"])
if(len(str(timestamp["hour"])) == 1):
h = '0' + str(timestamp["hour"])
if(len(str(timestamp["minute"])) == 1):
m = '0' + str(timestamp["minute"])
if(len(str(timestamp["second"])) == 1):
s = '0' + str(timestamp["second"])
self.messages.insert(0, (user, message, color, "<" + h + ":" + m + ":" + s + ">"))
else:
self.messages.insert(0, ("", message, color, ""))
self.write_messages()
self.write_rooms()
self.write_staged_message()
else:
if(overflow == False):
h = str(timestamp["hour"])
m = str(timestamp["minute"])
s = str(timestamp["second"])
if(len(str(timestamp["hour"])) == 1):
h = '0' + str(timestamp["hour"])
if(len(str(timestamp["minute"])) == 1):
m = '0' + str(timestamp["minute"])
if(len(str(timestamp["second"])) == 1):
s = '0' + str(timestamp["second"])
msg = self.process_msg(message, self.wordlimit)
self.messages.insert(0, (user, msg[0], color, "<" + h + ":" + m + ":" + s + ">"))
self.post(user, msg[1], color, "", True)
else:
msg = self.process_msg(message, self.wordlimit)
self.messages.insert(0, ("", msg[0], color, ""))
self.post(user, msg[1], color, "", True)
'''
Stages a message to the user's staging area
Inputs:
- message (str): the string to place in the user's message box
'''
def stage(self, message, index=0):
if(len(message) <= (self.wordlimit + 20)):
self.stagedMessage = message
if(index == 0):
self.write_staged_message()
else:
self.write_staged_message(index)
else:
msg = self.process_msg(message, self.wordlimit + 20)
self.stagedMessage = msg[0]
self.write_staged_message()
index += 1
self.stage(msg[1], index)
'''
Returns a path to the saved ARChat .jpg
'''
def getPath(self):
return ROOT + self.boardpath
def addRoom(self, topic):
self.rooms.append(topic)
self.write_messages()
self.write_rooms()
# message overflow processing
def process_msg(self, message, lim):
for i in range(lim-1, 0, -1):
if(message[i] == ' '):
return (message[:i], message[i+1:])
# post messages to chatboard
def write_messages(self):
im = cv.imread(ROOT + 'chat.png', 1)
index = 0
for message in self.messages:
if len(message[3]) != 0:
cv.putText(im, message[3] + " " + message[0] + ": " + message[1], (int(im.shape[1]/4), im.shape[0]-200-80*index), cv.FONT_HERSHEY_SIMPLEX, self.fontSize, message[2], 2, cv.LINE_AA)
else:
cv.putText(im, message[0] + message[1], (int(im.shape[1]/4), im.shape[0]-200-80*index), cv.FONT_HERSHEY_SIMPLEX, self.fontSize, message[2], 2, cv.LINE_AA)
index += 1
cv.imwrite(str(self.getPath()) + '.jpg', im)
# post message rooms to chatboard
def write_rooms(self):
im = cv.imread(str(self.getPath()) + '.jpg', 1)
index = 0
for room in self.rooms:
cv.putText(im, room, (50, im.shape[0]-1000+100*index), cv.FONT_HERSHEY_SIMPLEX, self.fontSize, (255,255,255), 2, cv.LINE_AA)
if(index == self.roomIndex):
cv.putText(im, room, (50, im.shape[0]-1000+100*index), cv.FONT_HERSHEY_SIMPLEX, self.fontSize, (255,0,255), 20, cv.LINE_AA)
cv.putText(im, room, (50, im.shape[0]-1000+100*index), cv.FONT_HERSHEY_SIMPLEX, self.fontSize, (255,255,255), 2, cv.LINE_AA)
index += 1
cv.imwrite(str(self.getPath()) + '.jpg', im)
# post queued message to chatboard
def write_staged_message(self, index=0):
im = cv.imread(str(self.getPath()) + '.jpg', 1)
cv.putText(im, self.stagedMessage, (int(im.shape[1]/4), im.shape[0]-90+50*index), cv.FONT_HERSHEY_SIMPLEX, self.fontSize, [255,255,255], 2, cv.LINE_AA)
cv.imwrite(str(self.getPath()) + '.jpg', im)
if __name__ == '__main__':
masterRooms = ["chat1", "chat2", "chat3"]
chat1 = ARChat("chat1", 0, masterRooms)
chat2 = ARChat("chat2", 1, masterRooms)
chat3 = ARChat("chat3", 2, masterRooms)
chat1.post("Nico", "some bullshit hey this is a bullshit space", [255,124,255], {"hour": 12, "minute": 31, "second": 22})
chat1.post("Nate", "this is a tester message really long please overflow due to character count", [0,0,255], {"hour": 12, "minute": 32, "second": 11})
chat1.post("Tommy", "this is a tester message again", [255,0,0], {"hour": 12, "minute": 33, "second": 1})
chat1.stage("I don't think this overflow works as intended yet so why don't I keep testing this stuff and see when it breaks")
chat2.post("Michael", "testing testing 123", [0,255,0], {"hour": 1, "minute": 5, "second": 2})
chat3.post("Walter", "Let's cook", [125,125,255], {"hour": 1, "minute": 5, "second": 2})
chat3.post("Jesse", "Hell yeah", [255,125,125], {"hour": 1, "minute": 5, "second": 56})
|
[
"noreply@github.com"
] |
180D-FW-2020.noreply@github.com
|
07f54965bf19a638d7de2870978fd0fccb3c3b59
|
635670997e25d7fd578701995fe0422dd5671528
|
/src/models_VAE/best_models/vae/encoder.py
|
48db109dad68d468093e78e6d9e4cbd35e10fc19
|
[] |
no_license
|
QuangNamVu/thesis
|
5126c0281d93e7a5c2c3a5784363d7f6c6baadfd
|
01a404de2dfb70f13f3e61a9a8f3b73c88d93502
|
refs/heads/master
| 2022-12-24T10:08:33.472729
| 2019-12-21T16:27:07
| 2019-12-21T16:27:07
| 174,741,015
| 0
| 3
| null | 2022-12-14T06:56:36
| 2019-03-09T20:09:03
|
Jupyter Notebook
|
UTF-8
|
Python
| false
| false
| 1,892
|
py
|
import tensorflow as tf
from tensorpack import *
from tf_utils.ar_layers import *
from tf_utils.common import *
def encoder(self, x):
is_training = get_current_tower_context().is_training
# [M, T, D] => [M, T, f0]
fc_l1 = gaussian_dense(name='encode_l1', inputs=x, out_C=self.hps.f[0])
activate_l1 = tf.nn.elu(fc_l1)
out_l1 = tf.layers.dropout(inputs=activate_l1, rate=self.hps.dropout_rate, training=is_training)
# [M, T, f0] => [M, T, f1]
fc_l2 = gaussian_dense(name='encode_l2', inputs=out_l1, out_C=self.hps.f[0])
activate_l2 = tf.nn.tanh(fc_l2)
out_l2 = tf.layers.dropout(inputs=activate_l2, rate=self.hps.dropout_rate, training=is_training)
cell = tf.nn.rnn_cell.LSTMCell(num_units=self.hps.lstm_units, state_is_tuple=True)
# z: [M, T, o]
# h: [M, o]
# c: [M, o]
# [M, T, f1] => [M, T, o]
outputs, state = tf.nn.dynamic_rnn(cell, out_l2, sequence_length=[self.hps.T] * self.hps.M, dtype=tf.float32,
parallel_iterations=64)
# [M, T, o] => [M, T * o] => [M, n_z]
next_seq = tf.reshape(outputs, shape=[-1, self.hps.T * self.hps.lstm_units])
state_c = state.c
if self.hps.is_VDE:
# z_lst = tf.contrib.layers.fully_connected(inputs=next_seq, out_C=2 * self.hps.n_z)
z_lst = gaussian_dense(name='encode_fc1', inputs=next_seq, out_C=2 * self.hps.n_z)
else:
rs_l3 = tf.reshape(out_l2, [-1, self.hps.T * self.hps.f[1]])
z_lst = gaussian_dense(name='encode_fc2', inputs=rs_l3, out_C=2 * self.hps.n_z)
z_mu, z_std1 = split(z_lst, split_dim=1, split_sizes=[self.hps.n_z, self.hps.n_z])
z_std = 1e-10 + tf.nn.softplus(z_std1)
if self.hps.is_VAE:
noise = tf.random_normal(shape=tf.shape(z_mu), mean=0.0, stddev=1.0)
z = z_mu + noise * z_std
else:
z = z_mu
return z_mu, z_std, z, state_c
|
[
"you@example.com"
] |
you@example.com
|
6e7000c867060f75c285361bd18e96b9365fac25
|
90ee22848a633676fe0da4a0a061e6d278d318fb
|
/Arrays/leet.py
|
7ce365448183389917db26fee33a9050a4ba9fdd
|
[] |
no_license
|
VinothRajasekar/practice
|
459d33dbe9a0b4f55485baee1389beba3d1abc04
|
c395f2fc9028c33e2d52c2c0c86f0c1077d29c8e
|
refs/heads/master
| 2020-04-18T19:54:11.577376
| 2019-11-07T03:04:12
| 2019-11-07T03:04:12
| 167,724,045
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 144
|
py
|
def hello():
print("hello world")
val = set()
val.add("1")
val.add("2")
val.remove("2")
print(val)
c = hello()
print(c)
|
[
"vinu.barro@gmail.com"
] |
vinu.barro@gmail.com
|
dc2ea8bc1a8d47ea00f0731625419d553fe1c45e
|
1081b4b2a575b4b786db71289f6e06497da4ae27
|
/PSO/Microgrid optimization/In objective approach/Multiprocessing/MicrogridPSO_module_PSO.py
|
3a081a2119588e545b5c45c775954a51d5982771
|
[] |
no_license
|
cycle13/Miniconda
|
6e468f6d87b8424f662cf3aefdf250c1ec81f97b
|
0d589134a9d65dccad05bb968406c98df26f29ab
|
refs/heads/master
| 2022-01-06T21:51:16.291238
| 2019-07-09T02:11:04
| 2019-07-09T02:11:04
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 13,507
|
py
|
import numpy as np
import copy
from MicrogridPSO_module_flowchart import loop_flowchart
# * Initialize particles & to input parameters
def initialize_PSO_parameters(PSO):
# * input initialize parametes
n_iterations = int(PSO.Multiprocessing_parameters["n_iterations"])
n_particles = int(PSO.Multiprocessing_parameters["n_particles"])
w = float(PSO.Multiprocessing_parameters["w"])
c1 = float(PSO.Multiprocessing_parameters["c1"])
c2 = float(PSO.Multiprocessing_parameters["c2"])
return n_iterations, n_particles, w, c1, c2
# * 粒子の数を引数にして初期の粒子を作成する。「3次元」
def initialize__PSO_particles(n_particles):
"""
ランダムな整数のバクトルを作成
"""
velocity_vector = ([np.array([0, 0, 0, 0]) for _ in range(n_particles)])
previous_velocity_vector = ([np.array([0, 0, 0, 0])
for _ in range(n_particles)])
iteration = 0
personal_best_fitness_value = np.array(
[float('inf') for _ in range(n_particles)])
global_best_fitness_value = float('inf')
range_vector = [10000, 20, 100, 30]
particle_position_vector = \
np.array([np.array([np.random.rand() * range_vector[0], np.random.rand() * range_vector[1],
np.random.rand() * range_vector[2], np.random.rand() * range_vector[3]])
for _ in range(n_particles)])
personal_best_position = particle_position_vector
global_best_position = personal_best_position
particle = {"particle_position_vector": particle_position_vector,
"personal_best_position": personal_best_position,
"personal_best_fitness_value": personal_best_fitness_value,
"global_best_fitness_value": global_best_fitness_value,
"global_best_position": global_best_position,
"velocity_vector": velocity_vector,
"previous_velocity_vector": previous_velocity_vector,
"iteration": iteration,
"range_vector": range_vector
}
return particle
# * 制約条件関数
def constrained(position):
x = position[0]
y = position[1]
z = position[2]
v = position[3]
if 20000 > x > 0 and 40 > y > 0 and 200 > z > 0 and 60 > v > 0:
judge = True
else:
judge = False
return judge
# Find optimized cost configurations.
def iterations_PSO(PSO):
# initialized particle
n_iterations, n_particles, w, c1, c2 = initialize_PSO_parameters(PSO)
PSO.particle = initialize__PSO_particles(n_particles)
print(
PSO.fitness_variable_parameters,
"\niterations:",
n_iterations,
"n_particles:",
n_particles,
"w:",
w,
"c1:",
c1,
"c2:",
c2,
"particle:",
PSO.particle)
# * PSO calc
PSO.all_particle_data = np.zeros(shape=(n_iterations, n_particles, 4))
PSO.all_particle_data_with_cost = np.zeros(shape=(n_iterations, n_particles, 6))
PSO.particle_data = np.zeros(shape=(n_particles, 4))
PSO.particle_data_with_cost = np.zeros(shape=(n_particles, 6))
particle_position_vector = PSO.particle["particle_position_vector"]
PSO.personal_best_position = PSO.particle["personal_best_position"]
PSO.personal_best_fitness_value = PSO.particle["personal_best_fitness_value"]
PSO.global_best_fitness_value = PSO.particle["global_best_fitness_value"]
PSO.global_best_position = PSO.particle["global_best_position"]
previous_velocity_vector = PSO.particle["previous_velocity_vector"]
iteration = PSO.particle["iteration"]
original_particle_position_vector = np.array([0, 0, 0, 0])
original_previous_velocity_vector = np.array([0, 0, 0, 0])
PSO.global_best_list = []
PSO.iteration_list = []
PSO.best_cost_list = []
for iteration in range(n_iterations):
print('-------iteration', '=', str(iteration), '-----------')
print(str(particle_position_vector))
for i in range(n_particles):
# * 粒子を設備容量に格納する。
PSO.update_fitness_variable_parameters(
{'pv_cap_max': particle_position_vector[i][0],
'wind_cap_max': particle_position_vector[i][1],
'battery_cap_max': particle_position_vector[i][2],
'diesel_max': particle_position_vector[i][3]})
# * total_checkのリセット
total_check = True
# * フローチャートをループで回して計算結果を取得
df, total_check, variables, total_cost, PSO.SCL, PSO.SEL, success_loops, failed_loops = loop_flowchart(
PSO)
# * whileループの回数をリセット
loop_number = 1
# * フローチャートもしくは、制約条件にエラーがある場合、粒子の位置をランダムにリセット
while total_check is False or constrained(
particle_position_vector[i]) is False:
print(' *particle_position_vector is error.loop=',
loop_number, particle_position_vector[i])
'''
particle_position_vector[i] = [np.random.rand()*PSO.particle["range_vector"][0], np.random.rand()*PSO.particle["range_vector"][1],\
np.random.rand()*PSO.particle["range_vector"][2], np.random.rand()*PSO.particle["range_vector"][3]]
'''
if iteration == 0:
particle_position_vector[i] = [
np.random.rand() * PSO.particle["range_vector"][0],
np.random.rand() * PSO.particle["range_vector"][1],
np.random.rand() * PSO.particle["range_vector"][2],
np.random.rand() * PSO.particle["range_vector"][3]]
loop_number += 1
else:
if loop_number == 1:
original_particle_position_vector = particle_position_vector[i]
original_previous_velocity_vector = previous_velocity_vector[i]
print(
' *original_particle_position_vector',
original_particle_position_vector)
print(
' *original_previous_velocity_vector',
original_previous_velocity_vector)
new_velocity = (
w * original_previous_velocity_vector) + (
c1 * np.random.rand()) * (
PSO.personal_best_position[i] - original_particle_position_vector) + (
c2 * np.random.rand()) * (
PSO.global_best_position - original_particle_position_vector)
particle_position_vector[i] = new_velocity + \
original_particle_position_vector
# ループが３回以上続く場合、ポジションをリセット
if loop_number >= 3:
particle_position_vector[i] = [
np.random.rand() * PSO.particle["range_vector"][0],
np.random.rand() * PSO.particle["range_vector"][1],
np.random.rand() * PSO.particle["range_vector"][2],
np.random.rand() * PSO.particle["range_vector"][3]]
print(
' *loop=',
loop_number,
'new_velocity:',
new_velocity,
'original_particle_position_vector',
original_particle_position_vector)
loop_number += 1
print(
' *particle_position_vector is updated by error.',
particle_position_vector[i])
# * 粒子を設備容量に格納する。
PSO.update_fitness_variable_parameters(
{'pv_cap_max': particle_position_vector[i][0],
'wind_cap_max': particle_position_vector[i][1],
'battery_cap_max': particle_position_vector[i][2],
'diesel_max': particle_position_vector[i][3]})
# * Total_checkのリセット
total_check = True
# * フローチャートをループで回して計算結果を取得
df, total_check, variables, total_cost, PSO.SCL, PSO.SEL, success_loops, failed_loops \
= loop_flowchart(PSO)
# * フローチャートがエラーなく動く場合、PSOに進む。
# * かつ、制約条件をクリアしている時
if total_check and constrained(particle_position_vector[i]):
fitness_cadidate = total_cost
print(
'-----particle_position[',
str(i),
'] ',
fitness_cadidate,
'[yen]. ',
particle_position_vector[i])
if (PSO.personal_best_fitness_value[i] > fitness_cadidate):
print(
' *personal best is updated.particle[',
i,
']:',
particle_position_vector[i])
# ! リストが参照渡しのため、値渡しにして勝手に変更されないようにしている。
# http://amacbee.hatenablog.com/entry/2016/12/07/004510
# https://rcmdnk.com/blog/2015/07/08/computer-python/
PSO.personal_best_fitness_value[i] = copy.deepcopy(
fitness_cadidate)
PSO.personal_best_position[i] = copy.deepcopy(
particle_position_vector[i])
if (PSO.global_best_fitness_value > fitness_cadidate):
print(
' *global best is updated.',
particle_position_vector[i])
print('variables: ', variables)
# ! リストが参照渡しのため、値渡しにして勝手に変更されないようにしている。
PSO.global_best_fitness_value = copy.deepcopy(
fitness_cadidate)
PSO.global_best_position = copy.deepcopy(
particle_position_vector[i])
PSO.best = {
'iterations': iteration,
'particle_number': i,
'global_best_position': PSO.global_best_position,
'global_best_fitness_value': PSO.global_best_fitness_value,
'table': df,
"variables": variables,
"SCL": PSO.SCL,
"SEL": PSO.SEL}
# * 粒子の位置情報を格納
PSO.particle_data[i] = particle_position_vector[i]
PSO.particle_data_with_cost[i] = np.append(np.append(particle_position_vector[i], total_cost), PSO.global_best_fitness_value)
if iteration != 0:
previous_velocity_vector[i] = new_velocity
new_velocity = (
w * previous_velocity_vector[i]) + (
c1 * np.random.rand()) * (
PSO.personal_best_position[i] - particle_position_vector[i]) + (
c2 * np.random.rand()) * (
PSO.global_best_position - particle_position_vector[i])
new_position = new_velocity + particle_position_vector[i]
particle_position_vector[i] = new_position
print(
' *previous_velocity_vector[',
i,
']',
previous_velocity_vector[i])
print(' *new_velocity', new_velocity)
previous_velocity_vector[i] = new_velocity
print(' *particle_position_vector[',
str(i),
'] is updated. particle_position:',
str(particle_position_vector[i]))
# * 各イテレーションの値をリストに保存
PSO.global_best_list.append(PSO.global_best_position)
PSO.iteration_list.append(iteration)
PSO.best_cost_list.append(PSO.global_best_fitness_value)
PSO.all_particle_data[iteration] = PSO.particle_data
PSO.all_particle_data_with_cost[iteration] = PSO.particle_data_with_cost
iteration = iteration + 1
# * 全粒子情報をnpyファイルとして出力
np.save("Result/" + str(PSO.Multiprocessing_parameters["state_name"]) + "all_particle_data.npy", PSO.all_particle_data)
np.save("Result/" + str(PSO.Multiprocessing_parameters["state_name"]) + "all_particle_data_with_cost.npy", PSO.all_particle_data_with_cost)
print(
"The best position is ",
PSO.best["global_best_position"],
" and global_best_fitness_value is",
PSO.best["global_best_fitness_value"],
"Each particles best is:",
PSO.personal_best_position,
" in iteration number ",
iteration,
"and ",
n_particles,
"particles.")
return PSO
|
[
"insideman02468@gmail.com"
] |
insideman02468@gmail.com
|
1350a94623bca2d8ec71d8f2452ae5975888cf01
|
ff3b1f10d179ffae5b63a4a86c46c0d50858c122
|
/env/bin/django-admin.py
|
f8b5cecf0a7d827708532a25d8ff2790739def6f
|
[] |
no_license
|
Petrovich80/urok2
|
de9e50a5d670e0ed836d799b0f24129efcd69cfb
|
0f55ed9c3fc9067372d843f8e451e409ec601c78
|
refs/heads/master
| 2023-05-10T01:41:32.383023
| 2021-06-08T08:40:47
| 2021-06-08T08:40:47
| 375,018,778
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 148
|
py
|
#!/home/petrov0803/app2/env/bin/python3.8
from django.core import management
if __name__ == "__main__":
management.execute_from_command_line()
|
[
"petrov0803@gmail.com"
] |
petrov0803@gmail.com
|
7ae19c87ae0a743f37e10842eb6d7fe795206b0d
|
4afa76df7f5f42fa97fd90f8da01374654d0d891
|
/train.py
|
4365b894e7248fe4525d2627f482f451ef9b658d
|
[] |
no_license
|
hantek/zmlp
|
923b8ce11c93dca620fe4bae0be5a5d341a3f64f
|
0fce920850f84631f6996e50df2a6089a958a172
|
refs/heads/master
| 2021-01-22T02:34:12.575698
| 2014-12-06T03:58:25
| 2014-12-06T03:58:25
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 11,025
|
py
|
import numpy
import numpy.random
import theano
import theano.tensor as T
SharedCPU = theano.tensor.sharedvar.TensorSharedVariable
try:
SharedGPU = theano.sandbox.cuda.var.CudaNdarraySharedVariable
except:
SharedGPU=SharedCPU
class GraddescentMinibatch(object):
def __init__(self, varin, data, cost, params,
truth=None, truth_data=None, supervised=False,
batchsize=100, learningrate=0.1, momentum=0.9,
rng=None, verbose=True):
"""
Using stochastic gradient descent with momentum on data in a minibatch
update manner.
"""
# TODO: check dependencies between varin, cost, and param.
assert isinstance(varin, T.TensorVariable)
if (not isinstance(data, SharedCPU)) and \
(not isinstance(data, SharedGPU)):
raise TypeError("\'data\' needs to be a theano shared variable.")
assert isinstance(cost, T.TensorVariable)
assert isinstance(params, list)
self.varin = varin
self.data = data
self.cost = cost
self.params = params
if supervised:
if (not isinstance(truth_data, SharedCPU)) and \
(not isinstance(truth_data, SharedGPU)):
raise TypeError("\'truth_data\' needs to be a theano " + \
"shared variable.")
assert isinstance(truth, T.TensorVariable)
self.truth_data = truth_data
self.truth = truth
self.verbose = verbose
self.batchsize = batchsize
self.numbatches = self.data.get_value().shape[0] / batchsize
self.momentum = momentum
self.supervised = supervised
if rng is None:
rng = numpy.random.RandomState(1)
assert isinstance(rng, numpy.random.RandomState), \
"rng has to be a random number generater."
self.rng = rng
self.epochcount = 0
self.index = T.lscalar('batch_index_in_sgd')
self.incs = dict([(
p,
theano.shared(value=numpy.zeros(p.get_value().shape,
dtype=theano.config.floatX),
name='inc_' + p.name,
broadcastable=p.broadcastable)
) for p in self.params])
self.grad = T.grad(self.cost, self.params)
self.set_learningrate(learningrate)
def set_learningrate(self, learningrate):
"""
TODO: set_learningrate() is not known to be working after
initialization. Not checked. A unit test should be written on it.
"""
self.learningrate = learningrate
self.inc_updates = [] # updates the parameter increasements (i.e.
# value in the self.incs dictionary.). Due to
# momentum, the increasement itself is
# changing between epochs. Its increasing by:
# from (key) inc_params
# to (value) momentum * inc_params - lr * grad
self.updates = [] # updates the parameters of model during each epoch.
# from (key) params
# to (value) params + inc_params
for _param, _grad in zip(self.params, self.grad):
self.inc_updates.append(
(self.incs[_param],
self.momentum * self.incs[_param] - self.learningrate * _grad
)
)
self.updates.append((_param, _param + self.incs[_param]))
if not self.supervised:
self._updateincs = theano.function(
inputs = [self.index],
outputs = self.cost,
updates = self.inc_updates,
givens = {
self.varin : self.data[self.index * self.batchsize: \
(self.index+1)*self.batchsize]
}
)
else:
self._updateincs = theano.function(
inputs = [self.index],
outputs = self.cost,
updates = self.inc_updates,
givens = {
self.varin : self.data[self.index * self.batchsize: \
(self.index+1)*self.batchsize],
self.truth : self.truth_data[self.index * self.batchsize: \
(self.index+1)*self.batchsize]
}
)
self.n = T.scalar('n')
self.noop = 0.0 * self.n
self._trainmodel = theano.function([self.n], self.noop,
updates = self.updates)
def step(self):
# def inplaceclip(x):
# x[:,:] *= x>0.0
# return x
# def inplacemask(x, mask):
# x[:,:] *= mask
# return x
stepcount = 0.0
cost = 0.
for batch_index in self.rng.permutation(self.numbatches - 1):
stepcount += 1.0
# This is Roland's way of computing cost, still mean over all
# batches. It saves space and don't harm computing time...
# But a little bit unfamilliar to understand at first glance.
cost = (1.0 - 1.0/stepcount) * cost + \
(1.0/stepcount) * self._updateincs(batch_index)
self._trainmodel(0)
self.epochcount += 1
if self.verbose:
print 'epoch: %d, lr: %f, cost: %f' % (
self.epochcount, self.learningrate, cost
)
return cost
class FeedbackAlignment(object):
def __init__(self, model, data, truth_data,
batchsize=100, learningrate=0.1, rng=None, verbose=True):
"""
It works for both linear and nonlinear layers.
Cost is defined intrinsicaly as the MSE between target y vector and
real y vector at the top layer.
Parameters:
------------
model : StackedLayer
data : theano.compile.SharedVariable
truth_data : theano.compile.SharedVariable
"""
if (not isinstance(data, SharedCPU)) and \
(not isinstance(data, SharedGPU)):
raise TypeError("\'data\' needs to be a theano shared variable.")
if (not isinstance(truth_data, SharedCPU)) and \
(not isinstance(truth_data, SharedGPU)):
raise TypeError("\'truth_data\' needs to be a theano shared variable.")
self.varin = model.models_stack[0].varin
self.truth = T.lmatrix('trurh_fba')
self.data = data
self.truth_data = truth_data
self.model = model
self.output = model.models_stack[-1].output()
self.verbose = verbose
self.batchsize = batchsize
self.numbatches = self.data.get_value().shape[0] / batchsize
if rng is None:
rng = numpy.random.RandomState(1)
assert isinstance(rng, numpy.random.RandomState), \
"rng has to be a random number generater."
self.rng = rng
self.error = (self.truth - self.output) * \
self.model.models_stack[-1].activ_prime()
# set fixed random matrix
self.fixed_B = [None, ]
for imod in self.model.models_stack[1:]:
i_layer_B = []
for ipar in imod.params:
rnd = numpy.asarray(
self.rng.uniform(
low = -4 * numpy.sqrt(6. / (imod.n_in + imod.n_out)),
high = 4 * numpy.sqrt(6. / (imod.n_in + imod.n_out)),
size = ipar.get_value().shape
),
dtype=ipar.dtype
)
i_layer_B.append(
theano.shared(value = rnd, name=ipar.name + '_fixed',
borrow=True)
)
self.fixed_B.append(i_layer_B)
self.epochcount = 0
self.index = T.lscalar('batch_index_in_fba')
self._get_cost = theano.function(
inputs = [self.index],
outputs = T.sum(self.error ** 2),
givens = {
self.varin : self.data[self.index * self.batchsize: \
(self.index+1)*self.batchsize],
self.truth : self.truth_data[self.index * self.batchsize: \
(self.index+1)*self.batchsize]
}
)
self.set_learningrate(learningrate)
def set_learningrate(self, learningrate):
self.learningrate = learningrate
layer_error = self.error
self.layer_learning_funcs = []
for i in range(len(self.model.models_stack) - 1, -1, -1):
iupdates = []
iupdates.append((
self.model.models_stack[i].w,
self.model.models_stack[i].w + self.learningrate * \
T.dot(self.model.models_stack[i].varin.T, layer_error)
)) # w
iupdates.append((
self.model.models_stack[i].b,
self.model.models_stack[i].b + self.learningrate * \
T.mean(layer_error, axis=0)
)) # b
if i > 0: # exclude the first layer.
layer_error = T.dot(layer_error, self.fixed_B[i][0].T) * \
self.model.models_stack[i-1].activ_prime()
self.layer_learning_funcs.append(
theano.function(
inputs = [self.index],
outputs = self.model.models_stack[i].output(),
updates = iupdates,
givens = {
self.varin : self.data[
self.index * self.batchsize: \
(self.index+1)*self.batchsize
],
self.truth : self.truth_data[
self.index * self.batchsize: \
(self.index+1)*self.batchsize
]
}
)
)
def step(self):
stepcount = 0.
cost = 0.
for batch_index in self.rng.permutation(self.numbatches - 1):
stepcount += 1.
cost = (1.0 - 1.0/stepcount) * cost + \
(1.0/stepcount) * self._get_cost(batch_index)
for layer_learn in self.layer_learning_funcs:
layer_learn(batch_index)
self.epochcount += 1
if self.verbose:
print 'epoch: %d, lr: %f, cost: %f' % (
self.epochcount, self.learningrate, cost
)
return cost
|
[
"lin.zhouhan@gmail.com"
] |
lin.zhouhan@gmail.com
|
17bb28c909cb81a12d6e09aa97eceda48b4c70d7
|
2ac2dc7550d4e08d56dff220c65d78799e221dc9
|
/users/forms.py
|
a28532794be55c34c3d0c00b0f403baddb94d9a9
|
[] |
no_license
|
Vladimir-1909/blog_news
|
b152883962ac3521c3294bd1e590f4144dc18966
|
d5a45e70bb44c7004824b83e1e3771c25760c975
|
refs/heads/main
| 2023-03-07T15:47:43.969174
| 2021-02-22T08:37:44
| 2021-02-22T08:37:44
| 341,130,810
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 4,474
|
py
|
from django import forms
from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm
from .models import Profile, SendMail
class UserRegisterForm(UserCreationForm):
email = forms.EmailField(
label='Введите Почту',
required=True,
widget=forms.TextInput(attrs={
'class': 'form-control',
'placeholder': 'Введите Почту',
'autocomplete': 'off'
})
)
username = forms.CharField(
label='Введите Логин',
required=True,
help_text='Нельзя вводить символы: @, /, _',
widget=forms.TextInput(attrs={
'class': 'form-control',
'placeholder': 'Введите Логин',
'autocomplete': 'off'
})
)
password1 = forms.CharField(
label='Введите Пароль',
required=True,
help_text='Пароль не долже быть маленьким и простым',
widget=forms.PasswordInput(attrs={
'class': 'form-control',
'placeholder': 'Введите Пароль',
'autocomplete': 'off'
})
)
password2 = forms.CharField(
label='Подтвердите пароль',
required=True,
widget=forms.PasswordInput(attrs={
'class': 'form-control',
'placeholder': 'Подтвердите пароль',
'autocomplete': 'off'
})
)
class Meta:
model = User
fields = ['email', 'username', 'password1', 'password2']
class UserUpdateForm(forms.ModelForm):
username = forms.CharField(
label='Имя пользователя',
required=False,
help_text='Обязательное поле. Не более 150 символов. Только буквы, цифры и символы: @/./+/-/_.',
widget=forms.TextInput(attrs={
'class': 'form-control help-text',
'placeholder': 'Введите Логин'
})
)
email = forms.EmailField(
label='Email',
required=False,
widget=forms.TextInput(attrs={
'class': 'form-control',
'placeholder': 'Введите Почту'
})
)
class Meta:
model = User
fields = ['username', 'email']
class ProfileImageForm(forms.ModelForm):
img = forms.ImageField(
label='Изображение профиля',
required=True
)
class Meta:
model = Profile
fields = ['img']
class UpdateGenderSelection(forms.ModelForm):
selections = (
(' ', '-'),
('m', 'Мужской пол.'),
('w', 'Женский пол.')
)
gender = forms.ChoiceField(
choices=selections,
label='Выберите пол',
widget=forms.Select(attrs={'class': 'form-control'})
)
class Meta:
model = Profile
fields = ['gender']
class MailAgreement(forms.ModelForm):
agreement = forms.BooleanField(
label='Соглашение про отправку уведомлений на почту',
label_suffix='',
required=False,
widget=forms.CheckboxInput()
)
class Meta:
model = Profile
fields = ['agreement']
class SendMailUserForm(forms.ModelForm):
subject = forms.CharField(
label='Тема письма',
required=True,
widget=forms.TextInput(attrs={
'class': 'form-control',
'placeholder': 'Форма отправки сообщений',
})
)
from_email = forms.EmailField(
label='Ваша почта',
required=True,
help_text='Обязательное поле',
widget=forms.TextInput(attrs={
'class': 'form-control',
'autocomplete': 'off'
})
)
plain_message = forms.CharField(
label='Введите текст сообщения',
required=True,
widget=forms.Textarea(attrs={
'class': 'form-control',
'placeholder': 'Все поля проходят проверки. Если что-то не заполнено, то отображается ошибка',
'autocomplete': 'off'
})
)
class Meta:
model = SendMail
fields = ['subject', 'from_email', 'plain_message']
|
[
"vtgk12ak@gmail.com"
] |
vtgk12ak@gmail.com
|
534e606f6d54fae55bbd0424ff0939fd209fb081
|
d75cb7e463247cb88196e90fe3e9c8ed4595775b
|
/SchoolJudgeSummary/delete_db.py
|
2681952472a2f7e0519ae19eeb3537421caf0d27
|
[] |
no_license
|
xscrat/SchoolJudgeSrc
|
7bcd993c5096df52de40117be8b52de893437e28
|
bca646254417232f15fe991ce75f92288590ecc5
|
refs/heads/master
| 2023-03-09T05:27:53.020785
| 2021-03-03T02:54:05
| 2021-03-03T02:54:05
| 343,808,403
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 235
|
py
|
# -- coding:utf-8 --
import requests
import globals
r = requests.post('http://%s:%s/delete_db/' % (globals.server_ip, globals.server_port))
if r.status_code == 200:
print('删库成功')
else:
print('删库失败')
|
[
"xjfscrat@gmail.com"
] |
xjfscrat@gmail.com
|
7fd01682debf28b599f6a3f86aa54b2e11ffb67d
|
7f392d3d784a95e0ba99118070bdfcf508d225c2
|
/projectManager/sproject_manager/views.py
|
2f5ea3c271647f97cfbee1aef53180bcdf4ff0c1
|
[
"MIT"
] |
permissive
|
ufajardo/task-tracker
|
0656b86edbe98b5e5b3c8dfab43b14f785e43c97
|
5817c6d1b563a9a6d2c1112bcd0b73531a316a8c
|
refs/heads/master
| 2021-08-07T07:26:26.395368
| 2019-05-30T20:44:31
| 2019-05-30T20:44:31
| 186,176,679
| 0
| 0
| null | 2020-06-05T21:03:17
| 2019-05-11T20:04:53
|
Python
|
UTF-8
|
Python
| false
| false
| 3,036
|
py
|
from django.shortcuts import render, get_object_or_404, redirect
from django.utils import timezone
from rest_framework import generics, viewsets
from .serializers import ProjectSerializer, TaskSerializer
from .models import Project, Task
from .forms import TaskForm, ProjForm
# Create your views here.
def index(request):
project_list = Project.objects.all()
task_list = Task.objects.all()
context = {
'project_list': project_list,
'task_list': task_list,
}
return render(request, 'sproject_manager/index.html', context)
def create_task(request):
task = TaskForm(request.POST or None)
if task.is_valid():
task.save()
return redirect('project_manager:index')
context = {
'taskform': task
}
return render(request, 'sproject_manager/task-create.html', context)
def create_proj(request):
proj = ProjForm(request.POST or None)
if proj.is_valid():
proj.save()
return redirect('project_manager:index')
context = {
'proj': proj
}
return render(request, 'sproject_manager/proj-create.html', context)
def update_task(request, id):
task = get_object_or_404(Task, id=id)
taskform = TaskForm(request.POST or None, instance=task)
if request.POST:
if taskform.is_valid():
data = request.POST.copy()
status = data.get('status')
if status == "ACTIVE":
obj = taskform.save(commit=False)
obj.start_date = timezone.now()
obj.save()
return redirect('project_manager:index')
elif status == "CLOSED":
obj = taskform.save(commit=False)
obj.end_date = timezone.now()
obj.save()
return redirect('project_manager:index')
elif status == "PENDING":
taskform.save()
return redirect('project_manager:index')
context = {
'task': task,
'taskform': taskform
}
return render(request, 'sproject_manager/task-details.html', context)
def proj_details(request, id):
proj = get_object_or_404(Project, id=id)
task_list = Task.objects.filter(project=id)
context = {
'proj': proj,
'task_list': task_list,
}
return render(request, 'sproject_manager/proj-details.html', context)
class ProjectList(viewsets.ModelViewSet):
serializer_class = TaskSerializer
def get_queryset(self):
"""
This view should return a list of all the purchases for
the user as determined by the username portion of the URL.
"""
id = self.kwargs['id']
return Task.objects.filter(project=id)
def delete_task(request, id):
task = get_object_or_404(Task, id=id)
if request.POST:
Task.objects.filter(id=id).delete()
return redirect('project_manager:index')
context = {
'task': task,
}
return render(request, 'sproject_manager/task-delete.html', context)
|
[
"ulysses.fajardo214@gmail.com"
] |
ulysses.fajardo214@gmail.com
|
c7e654ae56b455cb14bc56c0dedaa2ea56c31dd7
|
f268c12874985a5028150d64cffdcb2470b32dd4
|
/build.py
|
b8f53a09af44c659a9e1befc5a913ad4322ec625
|
[] |
no_license
|
sagarambalam/fsdse-python-assignment-31
|
49b39bb6fc01caece448dda89fba17a45770d535
|
d75be72c5e06592c7c791b203bd2c02753886493
|
refs/heads/master
| 2021-01-21T23:04:24.852859
| 2017-06-23T05:13:43
| 2017-06-23T05:13:43
| 95,184,731
| 0
| 0
| null | 2017-06-23T05:02:25
| 2017-06-23T05:02:25
| null |
UTF-8
|
Python
| false
| false
| 262
|
py
|
def solution(dic1):
list_a = sorted(dic1.values())
list_1 = list_a[0]
list_2 = list_a[1]
final_list=[]
for i in range(len(list_a)):
for j in range(len(list_a)):
final_list.append(list_1[i]+list_2[j])
return final_list
|
[
"sagar.ambalam@gmail.com"
] |
sagar.ambalam@gmail.com
|
b45cc10b7dd6a7c3e4acc055c6c47c9efec8d6f7
|
02e3fca30edaa8d8cc87c21895cb0cf1df112a35
|
/prepare_training_dataset.py
|
d7b4a8c00870b3ae1a809173e5a7253e35f57a78
|
[] |
no_license
|
huster123/DataScience_Project
|
dc151c159d906f5a169c5bdfd7c9da304598aeac
|
6289d49052be64efccaf618553b67b9613207db2
|
refs/heads/master
| 2020-05-01T13:35:36.916908
| 2018-08-13T16:41:37
| 2018-08-13T16:41:37
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,751
|
py
|
# coding: utf-8
"""
Created on Thu Jun 7 13:07:59 2018
@author: fahad
@purpose : The purpose of this code is to prepare the training dataset and calculate the RUL.
The program will read the required C-MAPSS dataset file and will return the dataset with calculate RUL as
a dataframe. Also, will save the dataframe to a CSV file
"""
# import packages
import numpy as np
import pandas as pd
# define file column heading
col_header = np.array(['UNIT_ID','CYCLE_ID','CONDITION_1','CONDITION_2','CONDITION_3','SENSOR_01','SENSOR_02','SENSOR_03','SENSOR_04',
'SENSOR_05','SENSOR_06','SENSOR_07','SENSOR_08','SENSOR_09','SENSOR_10','SENSOR_11','SENSOR_12','SENSOR_13',
'SENSOR_14','SENSOR_15','SENSOR_16','SENSOR_17','SENSOR_18','SENSOR_19','SENSOR_20','SENSOR_21'])
# funtion to calculate single RUL
def calcRUL(x,y):
rul = y-x
if rul >= 119:
rul = 119
return rul
# function to calculate Rul for a file
def populateRUL(data1):
data1['RUL']=-1
result = pd.DataFrame()
df_ids = data1['UNIT_ID'].unique()
for ids in df_ids:
df_data1 = data1[data1['UNIT_ID'] == ids].copy()
maxc = df_data1['CYCLE_ID'].max()
df_data1['RUL'] = df_data1[df_data1['UNIT_ID'] == ids]['CYCLE_ID'].apply(lambda x: calcRUL(x,maxc))
result = result.append(df_data1)
return result
# populate traing file with RUl column and save results to csv file and create all traing dataframe
def load_Training_data(number):
df = pd.read_csv('CMAPSSData/train_FD00'+str(number)+'.txt', delim_whitespace=True, header=None, names=col_header)
df = populateRUL(df)
df.to_csv('inputData/Train_FD00'+str(number)+'.csv',mode='w', index=False)
return df
|
[
"noreply@github.com"
] |
huster123.noreply@github.com
|
9a985c189a5328bcc149258b1faf5e97c967615f
|
ab66cdd15bb1ad964e21ce236e3e524b1eebb58a
|
/build/toolchain/win/setup_toolchain.py
|
66e840bb9bee4e29ff2d61f9afdf05d8d839e3f3
|
[
"BSD-3-Clause"
] |
permissive
|
tainyiPeter/build-gn
|
729659f3af90318d8ca80caa0a2f72d9bbfc595e
|
59376ea32237f28525173e25fe1ce4a5c19ad659
|
refs/heads/master
| 2020-04-19T09:52:23.499802
| 2018-12-18T10:43:26
| 2018-12-18T10:56:07
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 8,687
|
py
|
# Copyright (c) 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
#
# Copies the given "win tool" (which the toolchain uses to wrap compiler
# invocations) and the environment blocks for the 32-bit and 64-bit builds on
# Windows to the build directory.
#
# The arguments are the visual studio install location and the location of the
# win tool. The script assumes that the root build directory is the current dir
# and the files will be written to the current directory.
import errno
import json
import os
import re
import subprocess
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir))
import gn_helpers
SCRIPT_DIR = os.path.dirname(__file__)
def _ExtractImportantEnvironment(output_of_set):
"""Extracts environment variables required for the toolchain to run from
a textual dump output by the cmd.exe 'set' command."""
envvars_to_save = (
'goma_.*', # TODO(scottmg): This is ugly, but needed for goma.
'include',
'lib',
'libpath',
'path',
'pathext',
'systemroot',
'temp',
'tmp',
)
env = {}
# This occasionally happens and leads to misleading SYSTEMROOT error messages
# if not caught here.
if output_of_set.count('=') == 0:
raise Exception('Invalid output_of_set. Value is:\n%s' % output_of_set)
for line in output_of_set.splitlines():
for envvar in envvars_to_save:
if re.match(envvar + '=', line.lower()):
var, setting = line.split('=', 1)
if envvar == 'path':
# Our own rules and actions in Chromium rely on python being in the
# path. Add the path to this python here so that if it's not in the
# path when ninja is run later, python will still be found.
setting = os.path.dirname(sys.executable) + os.pathsep + setting
env[var.upper()] = setting.lower()
break
if sys.platform in ('win32', 'cygwin'):
for required in ('SYSTEMROOT', 'TEMP', 'TMP'):
if required not in env:
raise Exception('Environment variable "%s" '
'required to be set to valid path' % required)
return env
def _DetectVisualStudioPath():
"""Return path to the GYP_MSVS_VERSION of Visual Studio.
"""
# Use the code in build/vs_toolchain.py to avoid duplicating code.
chromium_dir = os.path.abspath(os.path.join(SCRIPT_DIR, '..', '..', '..'))
sys.path.append(os.path.join(chromium_dir, 'build'))
import vs_toolchain
return vs_toolchain.DetectVisualStudioPath()
def _LoadEnvFromBat(args):
"""Given a bat command, runs it and returns env vars set by it."""
args = args[:]
args.extend(('&&', 'set'))
popen = subprocess.Popen(
args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
variables, _ = popen.communicate()
if popen.returncode != 0:
raise Exception('"%s" failed with error %d' % (args, popen.returncode))
return variables
def _LoadToolchainEnv(cpu, sdk_dir):
"""Returns a dictionary with environment variables that must be set while
running binaries from the toolchain (e.g. INCLUDE and PATH for cl.exe)."""
# Check if we are running in the SDK command line environment and use
# the setup script from the SDK if so. |cpu| should be either
# 'x86' or 'x64'.
assert cpu in ('x86', 'x64')
# PATCH(build-gn): Do not assume depot_tools by default.
if bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', 0))) and sdk_dir:
# Load environment from json file.
env = os.path.normpath(os.path.join(sdk_dir, 'bin/SetEnv.%s.json' % cpu))
env = json.load(open(env))['env']
for k in env:
entries = [os.path.join(*([os.path.join(sdk_dir, 'bin')] + e))
for e in env[k]]
# clang-cl wants INCLUDE to be ;-separated even on non-Windows,
# lld-link wants LIB to be ;-separated even on non-Windows. Path gets :.
# The separator for INCLUDE here must match the one used in main() below.
sep = os.pathsep if k == 'PATH' else ';'
env[k] = sep.join(entries)
# PATH is a bit of a special case, it's in addition to the current PATH.
env['PATH'] = env['PATH'] + os.pathsep + os.environ['PATH']
# Augment with the current env to pick up TEMP and friends.
for k in os.environ:
if k not in env:
env[k] = os.environ[k]
varlines = []
for k in sorted(env.keys()):
varlines.append('%s=%s' % (str(k), str(env[k])))
variables = '\n'.join(varlines)
# Check that the json file contained the same environment as the .cmd file.
if sys.platform in ('win32', 'cygwin'):
script = os.path.normpath(os.path.join(sdk_dir, 'Bin/SetEnv.cmd'))
assert _ExtractImportantEnvironment(variables) == \
_ExtractImportantEnvironment(_LoadEnvFromBat([script, '/' + cpu]))
else:
if 'GYP_MSVS_OVERRIDE_PATH' not in os.environ:
os.environ['GYP_MSVS_OVERRIDE_PATH'] = _DetectVisualStudioPath()
# We only support x64-hosted tools.
script_path = os.path.normpath(os.path.join(
os.environ['GYP_MSVS_OVERRIDE_PATH'],
'VC/vcvarsall.bat'))
if not os.path.exists(script_path):
# vcvarsall.bat for VS 2017 fails if run after running vcvarsall.bat from
# VS 2013 or VS 2015. Fix this by clearing the vsinstalldir environment
# variable.
if 'VSINSTALLDIR' in os.environ:
del os.environ['VSINSTALLDIR']
other_path = os.path.normpath(os.path.join(
os.environ['GYP_MSVS_OVERRIDE_PATH'],
'VC/Auxiliary/Build/vcvarsall.bat'))
if not os.path.exists(other_path):
raise Exception('%s is missing - make sure VC++ tools are installed.' %
script_path)
script_path = other_path
# Chromium requires the 10.0.15063.468 SDK - previous versions don't have
# all of the required declarations and 10.0.16299.0 has some
# incompatibilities (crbug.com/773476).
args = [script_path, 'amd64_x86' if cpu == 'x86' else 'amd64',
'10.0.15063.0']
variables = _LoadEnvFromBat(args)
return _ExtractImportantEnvironment(variables)
def _FormatAsEnvironmentBlock(envvar_dict):
"""Format as an 'environment block' directly suitable for CreateProcess.
Briefly this is a list of key=value\0, terminated by an additional \0. See
CreateProcess documentation for more details."""
block = ''
nul = '\0'
for key, value in envvar_dict.iteritems():
block += key + '=' + value + nul
block += nul
return block
def main():
if len(sys.argv) != 6:
print('Usage setup_toolchain.py '
'<visual studio path> <win sdk path> '
'<runtime dirs> <target_cpu> <goma_disabled>')
sys.exit(2)
win_sdk_path = sys.argv[2]
runtime_dirs = sys.argv[3]
target_cpu = sys.argv[4]
goma_disabled = sys.argv[5]
cpus = ('x86', 'x64')
assert target_cpu in cpus
vc_bin_dir = ''
include = ''
# TODO(scottmg|goma): Do we need an equivalent of
# ninja_use_custom_environment_files?
for cpu in cpus:
# Extract environment variables for subprocesses.
env = _LoadToolchainEnv(cpu, win_sdk_path)
env['PATH'] = runtime_dirs + os.pathsep + env['PATH']
env['GOMA_DISABLED'] = goma_disabled
if cpu == target_cpu:
for path in env['PATH'].split(os.pathsep):
if os.path.exists(os.path.join(path, 'cl.exe')):
vc_bin_dir = os.path.realpath(path)
break
# The separator for INCLUDE here must match the one used in
# _LoadToolchainEnv() above.
include = [p.replace('"', r'\"') for p in env['INCLUDE'].split(';') if p]
include_I = ' '.join(['"/I' + i + '"' for i in include])
include_imsvc = ' '.join(['"-imsvc' + i + '"' for i in include])
env_block = _FormatAsEnvironmentBlock(env)
with open('environment.' + cpu, 'wb') as f:
f.write(env_block)
# Create a store app version of the environment.
if 'LIB' in env:
env['LIB'] = env['LIB'] .replace(r'\VC\LIB', r'\VC\LIB\STORE')
if 'LIBPATH' in env:
env['LIBPATH'] = env['LIBPATH'].replace(r'\VC\LIB', r'\VC\LIB\STORE')
env_block = _FormatAsEnvironmentBlock(env)
with open('environment.winrt_' + cpu, 'wb') as f:
f.write(env_block)
assert vc_bin_dir
print 'vc_bin_dir = ' + gn_helpers.ToGNString(vc_bin_dir)
assert include_I
print 'include_flags_I = ' + gn_helpers.ToGNString(include_I)
assert include_imsvc
print 'include_flags_imsvc = ' + gn_helpers.ToGNString(include_imsvc)
if __name__ == '__main__':
main()
|
[
"zcbenz@gmail.com"
] |
zcbenz@gmail.com
|
5fdba8f4725b9411b49d8f846a12dd1a5db0e84d
|
37c5ba847d3e466a916d58f8707c0e04704f9144
|
/ariac_behaviors/ariac_flexbe_behaviors/src/ariac_flexbe_behaviors/get_order_sm.py
|
12309fd2f1b750050ce3f829501d711014c49cdb
|
[] |
no_license
|
JustPtrck/roboticsP4
|
32bcf2076c11b51fecc19b8ea4dc21defe209f89
|
5904b11d6981fe2a19aed34cc235ef8f49fbcbc1
|
refs/heads/master
| 2022-09-01T06:37:09.519532
| 2020-05-19T10:50:04
| 2020-05-19T10:50:04
| 261,726,933
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 7,454
|
py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
###########################################################
# WARNING: Generated code! #
# ************************** #
# Manual changes may get lost if file is generated again. #
# Only code inside the [MANUAL] tags will be kept. #
###########################################################
from flexbe_core import Behavior, Autonomy, OperatableStateMachine, ConcurrencyContainer, PriorityContainer, Logger
from ariac_flexbe_states.start_assignment_state import StartAssignment
from ariac_logistics_flexbe_states.get_part_from_products_state import GetPartFromProductsState
from ariac_flexbe_behaviors.transportparttoagv_sm import TransportPartToAgvSM
from ariac_support_flexbe_states.add_numeric_state import AddNumericState
from ariac_support_flexbe_states.equal_state import EqualState
from ariac_flexbe_behaviors.notify_shipment_ready_sm import notify_shipment_readySM
from ariac_flexbe_states.messageLogger import MessageLogger
from ariac_logistics_flexbe_states.get_products_from_shipment_state import GetProductsFromShipmentState
from ariac_logistics_flexbe_states.get_order_state import GetOrderState
from ariac_support_flexbe_states.replace_state import ReplaceState
# Additional imports can be added inside the following tags
# [MANUAL_IMPORT]
# [/MANUAL_IMPORT]
'''
Created on Sun Apr 19 2020
@author: Gerard Harkema
'''
class get_orderSM(Behavior):
'''
Tests the starting and stopping of the assignment
'''
def __init__(self):
super(get_orderSM, self).__init__()
self.name = 'get_order'
# parameters of this behavior
# references to used behaviors
self.add_behavior(TransportPartToAgvSM, 'TransportPartToAgv')
self.add_behavior(notify_shipment_readySM, 'notify_shipment_ready')
# Additional initialization code can be added inside the following tags
# [MANUAL_INIT]
# [/MANUAL_INIT]
# Behavior comments:
def create(self):
# x:667 y:540, x:729 y:205
_state_machine = OperatableStateMachine(outcomes=['finished', 'fail'])
_state_machine.userdata.shipments = []
_state_machine.userdata.part_type = ''
_state_machine.userdata.material_locations = []
_state_machine.userdata.number_of_shipments = 0
_state_machine.userdata.order_id = ''
_state_machine.userdata.products = []
_state_machine.userdata.number_of_products = 0
_state_machine.userdata.agv_id = ''
_state_machine.userdata.shipment_type = ''
_state_machine.userdata.pose = []
_state_machine.userdata.product_index = 0
_state_machine.userdata.shipment_index = 1
_state_machine.userdata.add_one = 1
_state_machine.userdata.part_pose = []
_state_machine.userdata.zero = 0
# Additional creation code can be added inside the following tags
# [MANUAL_CREATE]
# [/MANUAL_CREATE]
with _state_machine:
# x:30 y:40
OperatableStateMachine.add('Start',
StartAssignment(),
transitions={'continue': 'GetOrder'},
autonomy={'continue': Autonomy.Off})
# x:905 y:34
OperatableStateMachine.add('GetProductPose',
GetPartFromProductsState(),
transitions={'continue': 'message_3', 'invalid_index': 'fail'},
autonomy={'continue': Autonomy.Off, 'invalid_index': Autonomy.Off},
remapping={'products': 'products', 'index': 'product_index', 'type': 'part_type', 'pose': 'part_pose'})
# x:1091 y:123
OperatableStateMachine.add('TransportPartToAgv',
self.use_behavior(TransportPartToAgvSM, 'TransportPartToAgv'),
transitions={'finished': 'IncrementProductIndex', 'failed': 'fail'},
autonomy={'finished': Autonomy.Inherit, 'failed': Autonomy.Inherit},
remapping={'agv_id': 'agv_id', 'part_type': 'part_type', 'part_pose': 'part_pose'})
# x:1095 y:229
OperatableStateMachine.add('IncrementProductIndex',
AddNumericState(),
transitions={'done': 'ShipmentReady?'},
autonomy={'done': Autonomy.Off},
remapping={'value_a': 'product_index', 'value_b': 'add_one', 'result': 'product_index'})
# x:1092 y:486
OperatableStateMachine.add('IncrementShipmentIndex',
AddNumericState(),
transitions={'done': 'notify_shipment_ready'},
autonomy={'done': Autonomy.Off},
remapping={'value_a': 'shipment_index', 'value_b': 'add_one', 'result': 'shipment_index'})
# x:1094 y:329
OperatableStateMachine.add('ShipmentReady?',
EqualState(),
transitions={'true': 'ResetProductIndex', 'false': 'GetProductPose'},
autonomy={'true': Autonomy.Off, 'false': Autonomy.Off},
remapping={'value_a': 'product_index', 'value_b': 'number_of_products'})
# x:474 y:461
OperatableStateMachine.add('OrderReady?',
EqualState(),
transitions={'true': 'ResetShiptIndex', 'false': 'GetProductsShipment'},
autonomy={'true': Autonomy.Off, 'false': Autonomy.Off},
remapping={'value_a': 'shipment_index', 'value_b': 'number_of_shipments'})
# x:857 y:483
OperatableStateMachine.add('notify_shipment_ready',
self.use_behavior(notify_shipment_readySM, 'notify_shipment_ready'),
transitions={'finished': 'OrderReady?', 'failed': 'fail'},
autonomy={'finished': Autonomy.Inherit, 'failed': Autonomy.Inherit})
# x:402 y:33
OperatableStateMachine.add('message',
MessageLogger(),
transitions={'continue': 'GetProductsShipment'},
autonomy={'continue': Autonomy.Off},
remapping={'message': 'order_id'})
# x:766 y:40
OperatableStateMachine.add('message_2',
MessageLogger(),
transitions={'continue': 'GetProductPose'},
autonomy={'continue': Autonomy.Off},
remapping={'message': 'shipment_type'})
# x:1090 y:36
OperatableStateMachine.add('message_3',
MessageLogger(),
transitions={'continue': 'TransportPartToAgv'},
autonomy={'continue': Autonomy.Off},
remapping={'message': 'part_type'})
# x:560 y:34
OperatableStateMachine.add('GetProductsShipment',
GetProductsFromShipmentState(),
transitions={'continue': 'message_2', 'invalid_index': 'fail'},
autonomy={'continue': Autonomy.Off, 'invalid_index': Autonomy.Off},
remapping={'shipments': 'shipments', 'index': 'shipment_index', 'shipment_type': 'shipment_type', 'agv_id': 'agv_id', 'products': 'products', 'number_of_products': 'number_of_products'})
# x:203 y:32
OperatableStateMachine.add('GetOrder',
GetOrderState(),
transitions={'continue': 'message'},
autonomy={'continue': Autonomy.Off},
remapping={'order_id': 'order_id', 'shipments': 'shipments', 'number_of_shipments': 'number_of_shipments'})
# x:1090 y:407
OperatableStateMachine.add('ResetProductIndex',
ReplaceState(),
transitions={'done': 'IncrementShipmentIndex'},
autonomy={'done': Autonomy.Off},
remapping={'value': 'zero', 'result': 'product_index'})
# x:338 y:318
OperatableStateMachine.add('ResetShiptIndex',
ReplaceState(),
transitions={'done': 'GetOrder'},
autonomy={'done': Autonomy.Off},
remapping={'value': 'zero', 'result': 'shipment_index'})
return _state_machine
# Private functions can be added inside the following tags
# [MANUAL_FUNC]
# [/MANUAL_FUNC]
|
[
"patrickverwimp@gmail.com"
] |
patrickverwimp@gmail.com
|
a96bac8257857719d4e612c36e2dc88f720a5690
|
ad212b92beac17c4d061848c1dcd443d02a168c8
|
/monthly_challenge/202008/19_goat_latin.py
|
e866084a3ba4569f5efdb64fd6aa23d3416e864d
|
[] |
no_license
|
21eleven/leetcode-solutions
|
5ec97e4391c8ebaa77f4404a1155f3ef464953b3
|
35c91e6f5f5ed348186b8641e6fc49c825322d32
|
refs/heads/master
| 2023-03-03T10:22:41.726612
| 2021-02-13T21:02:13
| 2021-02-13T21:02:13
| 260,374,085
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,420
|
py
|
"""
A sentence S is given, composed of words separated by spaces. Each word consists of lowercase and uppercase letters only.
We would like to convert the sentence to "Goat Latin" (a made-up language similar to Pig Latin.)
The rules of Goat Latin are as follows:
If a word begins with a vowel (a, e, i, o, or u), append "ma" to the end of the word.
For example, the word 'apple' becomes 'applema'.
If a word begins with a consonant (i.e. not a vowel), remove the first letter and append it to the end, then add "ma".
For example, the word "goat" becomes "oatgma".
Add one letter 'a' to the end of each word per its word index in the sentence, starting with 1.
For example, the first word gets "a" added to the end, the second word gets "aa" added to the end and so on.
Return the final sentence representing the conversion from S to Goat Latin.
Example 1:
Input: "I speak Goat Latin"
Output: "Imaa peaksmaaa oatGmaaaa atinLmaaaaa"
"""
class Solution:
def toGoatLatin(self, S: str) -> str:
words = S.split()
vowels = set(["a", "e", "i", "o", "u"])
goat = []
idx = 2
a = 'a'
for w in words:
if w[0].lower() in vowels:
goat.append(f"{w}m{a*idx}")
else:
goat.append(f"{w[1:]}{w[0]}m{a*idx}")
idx += 1
return ' '.join(goat)
|
[
"noahlidell@gmail.com"
] |
noahlidell@gmail.com
|
2caa36497292851a2824c6d22461f476df9e29db
|
8d113f0a487dab55c733ff63da5bba9e20f69b69
|
/config/settings.py
|
bca76446204a4d8a3e3373d62517eb9c85a8dc70
|
[
"MIT"
] |
permissive
|
AktanKasymaliev/django-video-hosting
|
c33d341a7709a21869c44a15eb6a3b6e9a783f54
|
b201ed3421025da22b43405452bde617ea26a90f
|
refs/heads/main
| 2023-07-18T08:10:00.289537
| 2021-09-02T20:15:41
| 2021-09-02T20:15:41
| 387,730,116
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 4,039
|
py
|
"""
Django settings for config project.
Generated by 'django-admin startproject' using Django 3.2.5.
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/
"""
import os
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 = os.environ.get("DJANGO_KEY")
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = eval(os.environ.get("DJANGO_DEBUG"))
ALLOWED_HOSTS = ['localhost', '127.0.0.1']
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'django.contrib.sites',
"videoApp",
"channels",
"django_cleanup",
]
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 = 'config.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates')],
'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 = 'config.wsgi.application'
ASGI_APPLICATION = 'config.asgi.application'
CHANNEL_LAYERS = {
'default': {
'BACKEND': 'channels_redis.core.RedisChannelLayer',
'CONFIG': {
'hosts': [('127.0.0.1', 6379)],
}
}
}
# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': os.environ.get("DATABASE_NAME"),
'USER': os.environ.get("DATABASE_USER"),
'PASSWORD': os.environ.get("DATABASE_PASSW"),
'HOST': os.environ.get("DATABASE_HOST"),
'PORT': os.environ.get("DATABASE_PORT"),
}
}
# 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/'
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
STATIC_DIR = os.path.join(BASE_DIR, 'static')
STATICFILES_DIRS = [STATIC_DIR]
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
# Default primary key field type
# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
|
[
"aktan.kasymaliev@icloud.com"
] |
aktan.kasymaliev@icloud.com
|
b5915b18fbbba281d99d4d188ad3de150336d99e
|
dbaad22aa8aa6f0ebdeacfbe9588b281e4e2a106
|
/0423 Pandas/1-複習-pandas/Pandas1_csv_-plot1.py
|
58fb6438f52cd86d1347b1d57e7b87de2c826879
|
[
"MIT"
] |
permissive
|
ccrain78990s/Python-Exercise
|
b4ecec6a653afd90de855a64fbf587032705fa8f
|
a9d09d5f3484efc2b9d9a53b71307257a51be160
|
refs/heads/main
| 2023-07-18T08:31:39.557299
| 2021-09-06T15:26:19
| 2021-09-06T15:26:19
| 357,761,471
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,289
|
py
|
#!/usr/bin/env python
# -*- coding=utf-8 -*-
__author__ = "Chen"
# 0423 練習
"""
資料出處:
公開發行公司股票發行概況統計表_New
https://data.gov.tw/dataset/103533
主要欄位說明:
年月、上市家數、上市資本額_十億元、上市成長率、上市面值_十億元、上市市值_十億元、
上櫃家數、上櫃資本額_十億元、上櫃成長率、上櫃面值_十億元、上櫃市值_十億元、
未上市上櫃家數、未上市上櫃資本額_十億元、公告日期
"""
import pandas as pd
df = pd.read_csv('每月_公開發行公司股票發行概況統計表.csv')
print(df.head())
print(type(df))
# 查看自資料訊息
print("=====資料訊息=====")
print(df.info())
# 資料大小
print("=====資料大小=====")
print(df.shape)
print("=====欄位名稱=====")
print(df.columns)
print("=====索引指數=====")
print(df.index)
print("=====統計描述=====")
print(df.describe())
print("**小練習***************************************************************")
print("========1.把 [年月,上市家數,上市資本額_十億元] 印出來========")
print(df[['年月','上市家數','上市資本額_十億元']])
#df2=df[['年月','上市家數','上市資本額_十億元']]
print("========2.找出 2019 年的資料========")
print(df[(df['年月']<=201999) & (df['年月']>=201900) ])
print("========3.找出 上市成長率 最高的年月========")
#print(df.上市成長率.max())
#print(df.上市成長率.idxmax())
max1=df.上市成長率.idxmax()
print(df[max1:max1+1])
print("========4.找出 2019 年的[上市成長率] 最高的月份========")
df2=df[(df['年月']<=201999) & (df['年月']>=201900) ]
max2=df2.上市成長率.idxmax()
print(df[max2:max2+1])
print("========5.找出 2018 年的資料========")
print(df[(df['年月']<=201899) & (df['年月']>=201800) ])
"""
未做完 可以參考老師解答
print("========6.比較 2017 和 2018 年的[上市資本額_十億元] 情況 (差異)========")
df3=df[(df['年月']<=201799) & (df['年月']>=201700) ]
df4=df[(df['年月']<=201899) & (df['年月']>=201800) ]
df5=df3[['年月','上市資本額_十億元']]
df6=df4[['年月','上市資本額_十億元']]
#df7=pd.concat([df5, df6], ignore_index=True)
df7=pd.merge(df5, df6,how='')
print(df7)
"""
|
[
"47476106+ccrain78990s@users.noreply.github.com"
] |
47476106+ccrain78990s@users.noreply.github.com
|
7023c1ee2710feaa888de4d2ad13b09a40472335
|
7209bab118b61d6ae36cca7f725226518bb9c0ec
|
/Drivingschool/urls.py
|
53f7eee7661676e0ac01be06f1349a4aae4bdb20
|
[] |
no_license
|
saaid960/driving1
|
a965e117d7b41a038bcf8f73c1b1e3f9dc04e1f2
|
63c1327ba64cb5e0ad1fafb02de86b641e599c07
|
refs/heads/master
| 2023-04-12T04:20:43.062582
| 2021-04-25T06:03:09
| 2021-04-25T06:03:09
| 344,208,582
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,420
|
py
|
"""Drivingschool 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
from django.contrib.staticfiles.urls import staticfiles_urlpatterns
from home import views
from home.views import home, registerpage, loginpage, logoutuser, video, index, addTodo, deleteTodo
urlpatterns = [
path('admin/', admin.site.urls),
path("Apply/", views.registerpage, name="Apply"),
path('', views.home, name="home"),
path('todo/', views.index, name="index"),
path('add/', addTodo),
path('deletetodo/<int:i_id>/', deleteTodo),
path('register/', registerpage, name="register"),
path('login/', views.loginpage, name="login"),
path('logout/', views.logoutuser, name="logout"),
path('video/', views.video, name="video"),
]
urlpatterns += staticfiles_urlpatterns()
|
[
"saaid7600@gmail.com"
] |
saaid7600@gmail.com
|
f09d1140e195dbf860ff3a408fbcd67171d8c3f0
|
834d7ea5179414f17d37f3bb58164b8f6ac11b24
|
/bin/MadGraph5_aMCatNLO/cards/production/2017/13TeV/bbDM_2HDMa/Multigrid_producer.py
|
465a227c5e5e12cba4fea295a8cb75925b14a0c1
|
[] |
no_license
|
diracyoon/genproductions
|
aa9ee41ac1dde9e14ed039496c3259328ece7073
|
a7740f4d28c7bfff4e71827dc807d57d974e29b7
|
refs/heads/master
| 2021-01-11T11:22:44.685243
| 2018-11-23T14:05:36
| 2018-11-23T14:05:36
| 72,719,084
| 1
| 0
| null | 2016-11-03T07:21:29
| 2016-11-03T07:21:29
| null |
UTF-8
|
Python
| false
| false
| 3,326
|
py
|
import sys
import os
verbose = False
old_cardsPath = 'Template'
prefix = 'bbDM_2HDMa_MH3_AA_MH4_XX_Mchi_YY'
os.system('mkdir '+ old_cardsPath+'/'+prefix)
os.system('cp '+old_cardsPath+'/'+'run_card.dat'+' '+ old_cardsPath+'/'+prefix+'/bbDM_2HDMa_MH3_AA_MH4_XX_Mchi_YY_run_card.dat' )
os.system('cp '+old_cardsPath+'/'+'proc_card.dat'+' '+ old_cardsPath+'/'+prefix+'/bbDM_2HDMa_MH3_AA_MH4_XX_Mchi_YY_proc_card.dat' )
os.system('cp '+old_cardsPath+'/'+'extramodels.dat'+' '+ old_cardsPath+'/'+prefix+'/bbDM_2HDMa_MH3_AA_MH4_XX_Mchi_YY_extramodels.dat' )
os.system('cp '+old_cardsPath+'/'+'customizecards.dat'+' '+ old_cardsPath+'/'+prefix+'/bbDM_2HDMa_MH3_AA_MH4_XX_Mchi_YY_customizecards.dat' )
os.system('cp '+old_cardsPath+'/'+'cuts.f'+' '+ old_cardsPath+'/'+prefix+'/bbDM_2HDMa_MH3_AA_MH4_XX_Mchi_YY_cuts.f' )
d_cardspath = os.path.join(old_cardsPath, prefix)
if verbose: print (d_cardspath)
d_run_card = os.path.join(d_cardspath,prefix+'_run_card.dat')
d_proc_card = os.path.join(d_cardspath,prefix+'_proc_card.dat')
d_extramodels = os.path.join(d_cardspath,prefix+'_extramodels.dat')
d_customizecards = os.path.join(d_cardspath,prefix+'_customizecards.dat')
d_cutcards = os.path.join(d_cardspath,prefix+'_cuts.f')
if verbose: print (d_run_card, d_proc_card, d_extramodels, d_customizecards)
def change_cards(d_cardname, cardname,MH3, MH4, Mchi):
f = open(d_cardname, 'r')
fout = open (cardname, 'w')
for line in f:
line = line.replace('AA', str(MH3))
line = line.replace('XX', str(MH4))
line = line.replace('YY', str(Mchi))
fout.write(line)
fout.close()
print ("Cardname",cardname)
def submitgrid(MH3, MH4, Mchi):
cardspath = d_cardspath.replace("AA",str(MH3)).replace("XX",str(MH4)).replace("YY",str(Mchi))
print ("cardpath",cardspath)
os.system('mkdir '+cardspath)
run_card = d_run_card.replace("AA",str(MH3)).replace("XX",str(MH4)).replace("YY",str(Mchi))
proc_card = d_proc_card.replace("AA",str(MH3)).replace("XX",str(MH4)).replace("YY",str(Mchi))
extramodels = d_extramodels.replace("AA",str(MH3)).replace("XX",str(MH4)).replace("YY",str(Mchi))
customizecards = d_customizecards.replace("AA",str(MH3)).replace("XX",str(MH4)).replace("YY",str(Mchi))
cutcards = d_cutcards.replace("AA",str(MH3)).replace("XX",str(MH4)).replace("YY",str(Mchi))
change_cards(d_run_card, run_card, MH3, MH4, Mchi)
change_cards(d_proc_card, proc_card,MH3 , MH4, Mchi)
change_cards(d_extramodels, extramodels, MH3, MH4, Mchi)
change_cards(d_customizecards, customizecards, MH3, MH4, Mchi)
change_cards(d_cutcards, cutcards, MH3,MH4, Mchi)
outdir = prefix.replace("AA",str(MH3)).replace("XX",str(MH4)).replace("YY",str(Mchi))
print ("output dir",outdir)
os.system('nohup ./submit_cmsconnect_gridpack_generation.sh '+ outdir +' '+ cardspath +' 4 "4 Gb" > mysubmit_'+outdir+'.debug 2>&1 &')
Mchi = [10]
MH3 = [600, 700, 800, 900, 1000, 1100, 1200]
for k in MH3:
for i in Mchi:
for j in range(100, 1200, 100):
if k > 1000 and j > 1000:
break
if j < k:
mh3 = k
mh4 = j
mchi = i
print("MH3=", mh3, "MH4= ", mh4)
submitgrid(mh3, mh4, mchi)
|
[
"tiwariPC@users.noreply.github.com"
] |
tiwariPC@users.noreply.github.com
|
209064d49d8c00a51c9b5b172250822afd75a2ac
|
c88ea9215c3f87c5a06e8f98ea57931144d4c022
|
/tests/strategy/filtering/test_thunk.py
|
9e1bdabd3eadf83a7e9079a3ccbb0d41ec00701e
|
[] |
no_license
|
dylandoamaral/certum
|
980e01dac2febfb1c9da7cb7be5301a5a6a91f3d
|
d8595cb4c3a101f9a78cddc1aa2c51cccac9095a
|
refs/heads/main
| 2023-03-13T23:00:25.733011
| 2021-03-14T10:06:14
| 2021-03-14T10:06:14
| 332,206,245
| 1
| 0
| null | 2021-03-14T10:06:15
| 2021-01-23T12:34:39
|
Python
|
UTF-8
|
Python
| false
| false
| 927
|
py
|
import pytest
from certum.error import Error
from certum.strategy.filtering.thunk import ThunkFiltering
@pytest.mark.parametrize(
"errors, result",
[
([Error(["x"], "my message")], 1),
([Error(["x", "b"], "my message")], 1),
([Error(["x"], "my message"), Error(["x", "b"], "my message")], 1),
(
[
Error(["x"], "my message"),
Error(["x", "b"], "my message"),
Error(["x", "b", "e"], "my message"),
],
1,
),
(
[
Error(["x"], "my message"),
Error(["x", "b"], "my message"),
Error(["y"], "my message"),
],
2,
),
],
)
def test_thunk(errors, result):
"""A thunk filtering strategy should keep the elements with the minimum depth."""
assert len(ThunkFiltering().filter(errors)) == result
|
[
"noreply@github.com"
] |
dylandoamaral.noreply@github.com
|
473edc044398c5b3eca2579faca5a7c518d2a277
|
10e5b1b2e42a2ff6ec998ed900071e8b5da2e74e
|
/array/0509_fibonacci_number/0509_fibonacci_number.py
|
5d815145881d946e9ff8a001d2a66e9ff2dcd44e
|
[] |
no_license
|
zdyxry/LeetCode
|
1f71092d687316de1901156b74fbc03588f0b0a5
|
b149d1e8a83b0dfc724bd9dc129a1cad407dd91f
|
refs/heads/master
| 2023-01-29T11:59:14.162531
| 2023-01-26T03:20:23
| 2023-01-26T03:20:23
| 178,754,208
| 6
| 4
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 806
|
py
|
# -*- coding: utf-8 -*-
class Solution(object):
def fib(self, N):
if N <= 1:
return N
return self.fib(N - 1) + self.fib(N - 2)
def fib2(self, N):
array = [i for i in xrange(N)]
for i in xrange(2, N+1):
array[i] = array[i-1] + array[i-2]
return array[-1]
def fib3(self, N):
if N <=1:
return N
left = 0
right =1
for i in range(2,N+1):
left, right = right, left + right
return right
def fib4(self, N):
array =[i for i in range(N+1)]
return self.fibola(array, N)
def fibola(self, array, N):
if N <= 1:
return N
array[N] = self.fibola(array, N-1) + array[N-2]
return array[N]
print(Solution().fib4(6))
|
[
"zdyxry@gmail.com"
] |
zdyxry@gmail.com
|
aa2d46b8434f07ea0404ccb72de436955c2f5a6f
|
d260346cf55f36c0a97b2b68fa65cabbf6f16564
|
/witheppy/runner.py
|
e8cf1cb86ca49af4d13cd292146c2921fc0ec00c
|
[
"MIT"
] |
permissive
|
pyenergyplus/witheppy
|
d27ba26f761d270b8787166c2c71193fcddb374b
|
cf1870827d43a0068cb63b93634a3deaa862241c
|
refs/heads/master
| 2023-07-07T05:04:28.885150
| 2023-06-29T20:39:26
| 2023-06-29T20:39:26
| 153,138,024
| 10
| 2
|
MIT
| 2023-06-29T20:39:27
| 2018-10-15T15:32:30
|
Python
|
UTF-8
|
Python
| false
| false
| 1,468
|
py
|
# Copyright (c) 2019 Santosh Philip
# =======================================================================
# Distributed under the MIT License.
# (See accompanying file LICENSE or copy at
# http://opensource.org/licenses/MIT)
# =======================================================================
"""helpers that enhance idf.run"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import os
def eplaunch_run(idf):
"""Run the E+ simulation exactly as EPLaunch would run a single file
with it's default setting
EPLaunch does the following by default:
- expands the Template objects
- puts the out output files in the same folder as the idf
- Uses idf filename as the output prefix
- Uses Capitals for the output suffix
Parameters
----------
idf : modelbuilder.IDF
the idf file. The idf file needs a weather file when opened
Returns
-------
NoneType
"""
fname = idf.idfname
weather = None # add weather args after bugfix for issue #236
if not weather:
wfile = idf.epw
else:
wfile = weather
folder = os.path.dirname(fname)
noext = os.path.splitext(os.path.basename(fname))[0]
idf.run(
weather=wfile,
expandobjects=True,
output_directory=folder,
output_prefix=noext,
output_suffix="C",
)
|
[
"santosh_philip@yahoo.com"
] |
santosh_philip@yahoo.com
|
c3bb7b99c92804951ac54fb144661450664dff9e
|
5312c056c32595007ca3f35c63088cfb76f2d408
|
/convolutions/sequences.py
|
a859c50dc06ce90146df6163bbc3a1035b974eae
|
[] |
no_license
|
namisama269/COMP3121-3821
|
9a46b3b59fd0b4a8017a0085fabf3e2f5acca801
|
3fd5b94a7a591ea8ce5209ac2af90119f6dc69e8
|
refs/heads/main
| 2023-08-23T04:25:40.814329
| 2021-11-03T04:14:36
| 2021-11-03T04:14:36
| 408,246,072
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 709
|
py
|
"""
Operations on 2 sequences A and B
A = [a0,a1,...,an], B = [b0,b1,...,bm]
"""
def add(A, B):
pass
def pmul(A, B):
pass
def dot(A, B):
if len(A) != len(B):
raise ValueError("A and B must have same length")
return [A[i]*B[i] for i in range(len(A))]
def concat(A, B):
pass
def convolution(A, B):
"""
Brute force linear convolution of 2 sequences
"""
n = len(A)
m = len(B)
conv = [0] * (n+m-1)
for i in range(n):
for k in range(m):
conv[i+k] += A[i]*B[k]
return conv
def padzero(A, newLen):
while len(A) < newLen:
A.append(0)
if __name__ == "__main__":
A = [1,1]
B = [1,2,1]
print(convolution(A,B))
|
[
"namwarlockclash@gmail.com"
] |
namwarlockclash@gmail.com
|
4a29bb1b1e74602ea2d8737fb776aeaa75db8ac5
|
0ccee825e9315b5490496be46706ddfe38b36dad
|
/paddleball.py
|
68363f367699f85e31782e7e94bfb0a034580ad9
|
[] |
no_license
|
Drewleks/python-for-kids
|
dd86bee3f110c779fbfa64aab982e2fec18fd02f
|
2896df13f511456ca1682b077ca82086082e7c27
|
refs/heads/master
| 2020-04-07T15:58:46.274090
| 2019-06-19T20:28:54
| 2019-06-19T20:28:54
| 158,509,999
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,421
|
py
|
from tkinter import *
import random
import time
class Ball:
def __init__(self, canvas, paddle, color):
self.canvas = canvas
self.paddle = paddle
self.id = canvas.create_oval(10, 10, 25, 25, fill=color)
self.canvas.move(self.id, 245, 100)
starts = [-3, -2, -1, 1, 2, 3]
random.shuffle(starts)
self.x = starts[0]
self.y = -3
self.canvas_height = self.canvas.winfo_height()
self.canvas_width = self.canvas.winfo_width()
self.hit_bottom = False
def hit_paddle(self, pos):
paddle_pos = self.canvas.coords(self.paddle.id)
if pos[2] >= paddle_pos[0] and pos[0] <= paddle_pos[2]:
if pos[3] >= paddle_pos[1] and pos[3] <= paddle_pos[3]:
return True
return False
def draw(self):
self.canvas.move(self.id, self.x, self.y)
pos = self.canvas.coords(self.id)
if pos[1] <= 0:
self.y = 3
if pos[3] >= self.canvas_height:
self.hit_bottom = True
if self.hit_paddle(pos) == True:
self.y = -3
if pos[0] <= 0:
self.x = 3
if pos[2] >= self.canvas_width:
self.x = -3
class Paddle:
def __init__(self, canvas, color):
self.canvas = canvas
self.id = canvas.create_rectangle(0, 0, 100, 10, fill=color)
self.canvas.move(self.id, 200, 300)
self.x = 0
self.canvas_width = self.canvas.winfo_width()
self.canvas.bind_all('<KeyPress-Left>', self.turn_left)
self.canvas.bind_all('<KeyPress-Right>', self.turn_right)
def turn_left(self, evt):
self.x = -3
def turn_right(self, evt):
self.x = 3
def draw(self):
self.canvas.move(self.id, self.x, 0)
pos = self.canvas.coords(self.id)
if pos[0] <= 0:
self.x = 0
elif pos[2] >= self.canvas_width:
self.x = 0
tk = Tk()
tk.title("Игра")
tk.resizable(0, 0)
tk.wm_attributes("-topmost", 1)
canvas = Canvas(tk, width=500, height=400, bd=0, highlightthickness=0)
canvas.pack()
tk.update()
paddle = Paddle(canvas, 'Blue')
ball = Ball(canvas, paddle, 'red')
while 1:
if ball.hit_bottom == False:
ball.draw()
paddle.draw()
tk.update_idletasks()
tk.update()
time.sleep(0.01)
|
[
"noreply@github.com"
] |
Drewleks.noreply@github.com
|
13be7231187d37ac75c66c3d2fed7e893c559c16
|
e93ba589366452ccb47ccbaf1ec4c613ba8bbc73
|
/clase4_map.py
|
539de9b06741a829ff7b01afd7cef891a524be75
|
[] |
no_license
|
ericksc/pythonbasico
|
d340209683084ca7059767fea39c33987f8fcac2
|
13110acef5b2af02bc11954e38dc3443a0c43419
|
refs/heads/master
| 2023-06-19T05:44:13.349958
| 2021-07-16T16:17:26
| 2021-07-16T16:17:26
| 369,639,836
| 0
| 2
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 57
|
py
|
a = [1,2,3, 'hola', 4, 5, True]
b = list(map( type, a))
|
[
"ecsa@gft.com"
] |
ecsa@gft.com
|
1d4c1a6a7d097727c67229681c7abf1bfe13d42a
|
05e99875ebdb5b95fe478bc9a0dedfc6adae5442
|
/render.py
|
db6d102a7db6785bf36f50afef50cde267b9eb80
|
[] |
no_license
|
dstathis/renderdocs
|
96d7fea587f7760aa3526eb3c58100e8ea8cc2ba
|
cac27f25f66f1c72ab918b4e00670a211154bf79
|
refs/heads/master
| 2022-12-18T20:00:25.220294
| 2020-09-28T21:13:01
| 2020-09-28T21:13:01
| 296,403,587
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,644
|
py
|
#!/usr/bin/env python3
from __future__ import print_function
import pickle
import os.path
import subprocess
from pathlib import Path
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
# If modifying these scopes, delete the file token.pickle.
SCOPES = ['https://www.googleapis.com/auth/documents.readonly',
'https://www.googleapis.com/auth/drive.readonly']
# The ID of a sample document.
DOCUMENT_ID = '1jwFlPG_q5lr80NYI19L_3mErAv4Yk2-g6uzK113Qiks'
docdir = Path('docs')
def get_doc(service, doc_id):
# Retrieve the documents contents from the Docs service.
document = service.documents().get(documentId=doc_id).execute()
fname = f'{document["title"]}.md'.replace(' ', '_')
contents = document['body']['content']
text = []
for elt in contents:
if 'paragraph' in elt:
text_elements = elt['paragraph']['elements']
for text_element in text_elements:
chars = text_element.get('textRun')
if chars:
text.append(chars['content'])
with (docdir / fname).open('w') as f:
f.write('\n'.join(text))
return fname
def main():
creds = None
# The file token.pickle stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
if os.path.exists('token.pickle'):
with open('token.pickle', 'rb') as token:
creds = pickle.load(token)
# If there are no (valid) credentials available, let the user log in.
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
'credentials.json', SCOPES)
creds = flow.run_local_server(port=0)
# Save the credentials for the next run
with open('token.pickle', 'wb') as token:
pickle.dump(creds, token)
docs_service = build('docs', 'v1', credentials=creds)
drive_service = build('drive', 'v2', credentials=creds)
docdir.mkdir(exist_ok=True)
with Path('id.txt').open() as f:
folder_id = f.read().strip()
items = drive_service.children().list(folderId=folder_id).execute()['items']
with open('home.md', 'w') as f:
for doc in items:
fname = get_doc(docs_service, doc['id'])
f.write(f'[{fname}](docs/{fname}) \n')
subprocess.run(['grip', '-b', 'home.md'])
if __name__ == '__main__':
main()
|
[
"dylan@theone.ninja"
] |
dylan@theone.ninja
|
0a6f99febf158ce23215714249263dc107358160
|
2724412db1fc69b67b74a7d1c4ca4731962908d3
|
/tests/test_streams.py
|
fd7c66a0bdc95eac88148387db0573a5c90b4496
|
[
"BSD-3-Clause"
] |
permissive
|
Tijani-Dia/websockets
|
a981267685e681df822307bce4ec7eb781e9927d
|
ed9a7b446c7147f6f88dbeb1d86546ad754e435e
|
refs/heads/main
| 2023-08-23T13:10:16.030126
| 2021-10-08T20:18:24
| 2021-10-28T20:17:30
| 425,114,573
| 1
| 0
|
BSD-3-Clause
| 2021-11-05T23:56:39
| 2021-11-05T23:56:39
| null |
UTF-8
|
Python
| false
| false
| 6,055
|
py
|
from websockets.streams import StreamReader
from .utils import GeneratorTestCase
class StreamReaderTests(GeneratorTestCase):
def setUp(self):
self.reader = StreamReader()
def test_read_line(self):
self.reader.feed_data(b"spam\neggs\n")
gen = self.reader.read_line(32)
line = self.assertGeneratorReturns(gen)
self.assertEqual(line, b"spam\n")
gen = self.reader.read_line(32)
line = self.assertGeneratorReturns(gen)
self.assertEqual(line, b"eggs\n")
def test_read_line_need_more_data(self):
self.reader.feed_data(b"spa")
gen = self.reader.read_line(32)
self.assertGeneratorRunning(gen)
self.reader.feed_data(b"m\neg")
line = self.assertGeneratorReturns(gen)
self.assertEqual(line, b"spam\n")
gen = self.reader.read_line(32)
self.assertGeneratorRunning(gen)
self.reader.feed_data(b"gs\n")
line = self.assertGeneratorReturns(gen)
self.assertEqual(line, b"eggs\n")
def test_read_line_not_enough_data(self):
self.reader.feed_data(b"spa")
self.reader.feed_eof()
gen = self.reader.read_line(32)
with self.assertRaises(EOFError) as raised:
next(gen)
self.assertEqual(
str(raised.exception),
"stream ends after 3 bytes, before end of line",
)
def test_read_line_too_long(self):
self.reader.feed_data(b"spam\neggs\n")
gen = self.reader.read_line(2)
with self.assertRaises(RuntimeError) as raised:
next(gen)
self.assertEqual(
str(raised.exception),
"read 5 bytes, expected no more than 2 bytes",
)
def test_read_line_too_long_need_more_data(self):
self.reader.feed_data(b"spa")
gen = self.reader.read_line(2)
with self.assertRaises(RuntimeError) as raised:
next(gen)
self.assertEqual(
str(raised.exception),
"read 3 bytes, expected no more than 2 bytes",
)
def test_read_exact(self):
self.reader.feed_data(b"spameggs")
gen = self.reader.read_exact(4)
data = self.assertGeneratorReturns(gen)
self.assertEqual(data, b"spam")
gen = self.reader.read_exact(4)
data = self.assertGeneratorReturns(gen)
self.assertEqual(data, b"eggs")
def test_read_exact_need_more_data(self):
self.reader.feed_data(b"spa")
gen = self.reader.read_exact(4)
self.assertGeneratorRunning(gen)
self.reader.feed_data(b"meg")
data = self.assertGeneratorReturns(gen)
self.assertEqual(data, b"spam")
gen = self.reader.read_exact(4)
self.assertGeneratorRunning(gen)
self.reader.feed_data(b"gs")
data = self.assertGeneratorReturns(gen)
self.assertEqual(data, b"eggs")
def test_read_exact_not_enough_data(self):
self.reader.feed_data(b"spa")
self.reader.feed_eof()
gen = self.reader.read_exact(4)
with self.assertRaises(EOFError) as raised:
next(gen)
self.assertEqual(
str(raised.exception),
"stream ends after 3 bytes, expected 4 bytes",
)
def test_read_to_eof(self):
gen = self.reader.read_to_eof(32)
self.reader.feed_data(b"spam")
self.assertGeneratorRunning(gen)
self.reader.feed_eof()
data = self.assertGeneratorReturns(gen)
self.assertEqual(data, b"spam")
def test_read_to_eof_at_eof(self):
self.reader.feed_eof()
gen = self.reader.read_to_eof(32)
data = self.assertGeneratorReturns(gen)
self.assertEqual(data, b"")
def test_read_to_eof_too_long(self):
gen = self.reader.read_to_eof(2)
self.reader.feed_data(b"spam")
with self.assertRaises(RuntimeError) as raised:
next(gen)
self.assertEqual(
str(raised.exception),
"read 4 bytes, expected no more than 2 bytes",
)
def test_at_eof_after_feed_data(self):
gen = self.reader.at_eof()
self.assertGeneratorRunning(gen)
self.reader.feed_data(b"spam")
eof = self.assertGeneratorReturns(gen)
self.assertFalse(eof)
def test_at_eof_after_feed_eof(self):
gen = self.reader.at_eof()
self.assertGeneratorRunning(gen)
self.reader.feed_eof()
eof = self.assertGeneratorReturns(gen)
self.assertTrue(eof)
def test_feed_data_after_feed_data(self):
self.reader.feed_data(b"spam")
self.reader.feed_data(b"eggs")
gen = self.reader.read_exact(8)
data = self.assertGeneratorReturns(gen)
self.assertEqual(data, b"spameggs")
gen = self.reader.at_eof()
self.assertGeneratorRunning(gen)
def test_feed_eof_after_feed_data(self):
self.reader.feed_data(b"spam")
self.reader.feed_eof()
gen = self.reader.read_exact(4)
data = self.assertGeneratorReturns(gen)
self.assertEqual(data, b"spam")
gen = self.reader.at_eof()
eof = self.assertGeneratorReturns(gen)
self.assertTrue(eof)
def test_feed_data_after_feed_eof(self):
self.reader.feed_eof()
with self.assertRaises(EOFError) as raised:
self.reader.feed_data(b"spam")
self.assertEqual(
str(raised.exception),
"stream ended",
)
def test_feed_eof_after_feed_eof(self):
self.reader.feed_eof()
with self.assertRaises(EOFError) as raised:
self.reader.feed_eof()
self.assertEqual(
str(raised.exception),
"stream ended",
)
def test_discard(self):
gen = self.reader.read_to_eof(32)
self.reader.feed_data(b"spam")
self.reader.discard()
self.assertGeneratorRunning(gen)
self.reader.feed_eof()
data = self.assertGeneratorReturns(gen)
self.assertEqual(data, b"")
|
[
"aymeric.augustin@m4x.org"
] |
aymeric.augustin@m4x.org
|
0c41eb9b825513fc3f392c454d24189c96027204
|
c3796ebebb42e55878556a53abad1a2e18fa4020
|
/test/functional/p2p_unrequested_blocks.py
|
f90431fdef055f22d5946052e24c023ed7e313de
|
[
"MIT"
] |
permissive
|
lycion/genex-project
|
a9e54d22138ca81339f76bba166aa9f366fa9dd8
|
fc103e93ee274dc57179d01c32b0235b29e364ca
|
refs/heads/master
| 2020-03-29T02:18:33.445995
| 2018-08-07T23:56:27
| 2018-08-07T23:56:27
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 13,842
|
py
|
#!/usr/bin/env python3
# Copyright (c) 2015-2017 The Genex Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Test processing of unrequested blocks.
Setup: two nodes, node0+node1, not connected to each other. Node1 will have
nMinimumChainWork set to 0x10, so it won't process low-work unrequested blocks.
We have one P2PInterface connection to node0 called test_node, and one to node1
called min_work_node.
The test:
1. Generate one block on each node, to leave IBD.
2. Mine a new block on each tip, and deliver to each node from node's peer.
The tip should advance for node0, but node1 should skip processing due to
nMinimumChainWork.
Node1 is unused in tests 3-7:
3. Mine a block that forks from the genesis block, and deliver to test_node.
Node0 should not process this block (just accept the header), because it
is unrequested and doesn't have more or equal work to the tip.
4a,b. Send another two blocks that build on the forking block.
Node0 should process the second block but be stuck on the shorter chain,
because it's missing an intermediate block.
4c.Send 288 more blocks on the longer chain (the number of blocks ahead
we currently store).
Node0 should process all but the last block (too far ahead in height).
5. Send a duplicate of the block in #3 to Node0.
Node0 should not process the block because it is unrequested, and stay on
the shorter chain.
6. Send Node0 an inv for the height 3 block produced in #4 above.
Node0 should figure out that Node0 has the missing height 2 block and send a
getdata.
7. Send Node0 the missing block again.
Node0 should process and the tip should advance.
8. Create a fork which is invalid at a height longer than the current chain
(ie to which the node will try to reorg) but which has headers built on top
of the invalid block. Check that we get disconnected if we send more headers
on the chain the node now knows to be invalid.
9. Test Node1 is able to sync when connected to node0 (which should have sufficient
work on its chain).
"""
from test_framework.mininode import *
from test_framework.test_framework import GenexTestFramework
from test_framework.util import *
import time
from test_framework.blocktools import create_block, create_coinbase, create_transaction
class AcceptBlockTest(GenexTestFramework):
def set_test_params(self):
self.setup_clean_chain = True
self.num_nodes = 2
self.extra_args = [[], ["-minimumchainwork=0x10"]]
def setup_network(self):
# Node0 will be used to test behavior of processing unrequested blocks
# from peers which are not whitelisted, while Node1 will be used for
# the whitelisted case.
# Node2 will be used for non-whitelisted peers to test the interaction
# with nMinimumChainWork.
self.setup_nodes()
def run_test(self):
# Setup the p2p connections
# test_node connects to node0 (not whitelisted)
test_node = self.nodes[0].add_p2p_connection(P2PInterface())
# min_work_node connects to node1 (whitelisted)
min_work_node = self.nodes[1].add_p2p_connection(P2PInterface())
test_node.wait_for_verack()
min_work_node.wait_for_verack()
# 1. Have nodes mine a block (leave IBD)
[ n.generate(1) for n in self.nodes ]
tips = [ int("0x" + n.getbestblockhash(), 0) for n in self.nodes ]
# 2. Send one block that builds on each tip.
# This should be accepted by node0
blocks_h2 = [] # the height 2 blocks on each node's chain
block_time = int(time.time()) + 1
for i in range(2):
blocks_h2.append(create_block(tips[i], create_coinbase(2), block_time))
blocks_h2[i].solve()
block_time += 1
test_node.send_message(msg_block(blocks_h2[0]))
min_work_node.send_message(msg_block(blocks_h2[1]))
for x in [test_node, min_work_node]:
x.sync_with_ping()
assert_equal(self.nodes[0].getblockcount(), 2)
assert_equal(self.nodes[1].getblockcount(), 1)
self.log.info("First height 2 block accepted by node0; correctly rejected by node1")
# 3. Send another block that builds on genesis.
block_h1f = create_block(int("0x" + self.nodes[0].getblockhash(0), 0), create_coinbase(1), block_time)
block_time += 1
block_h1f.solve()
test_node.send_message(msg_block(block_h1f))
test_node.sync_with_ping()
tip_entry_found = False
for x in self.nodes[0].getchaintips():
if x['hash'] == block_h1f.hash:
assert_equal(x['status'], "headers-only")
tip_entry_found = True
assert(tip_entry_found)
assert_raises_rpc_error(-1, "Block not found on disk", self.nodes[0].getblock, block_h1f.hash)
# 4. Send another two block that build on the fork.
block_h2f = create_block(block_h1f.sha256, create_coinbase(2), block_time)
block_time += 1
block_h2f.solve()
test_node.send_message(msg_block(block_h2f))
test_node.sync_with_ping()
# Since the earlier block was not processed by node, the new block
# can't be fully validated.
tip_entry_found = False
for x in self.nodes[0].getchaintips():
if x['hash'] == block_h2f.hash:
assert_equal(x['status'], "headers-only")
tip_entry_found = True
assert(tip_entry_found)
# But this block should be accepted by node since it has equal work.
self.nodes[0].getblock(block_h2f.hash)
self.log.info("Second height 2 block accepted, but not reorg'ed to")
# 4b. Now send another block that builds on the forking chain.
block_h3 = create_block(block_h2f.sha256, create_coinbase(3), block_h2f.nTime+1)
block_h3.solve()
test_node.send_message(msg_block(block_h3))
test_node.sync_with_ping()
# Since the earlier block was not processed by node, the new block
# can't be fully validated.
tip_entry_found = False
for x in self.nodes[0].getchaintips():
if x['hash'] == block_h3.hash:
assert_equal(x['status'], "headers-only")
tip_entry_found = True
assert(tip_entry_found)
self.nodes[0].getblock(block_h3.hash)
# But this block should be accepted by node since it has more work.
self.nodes[0].getblock(block_h3.hash)
self.log.info("Unrequested more-work block accepted")
# 4c. Now mine 288 more blocks and deliver; all should be processed but
# the last (height-too-high) on node (as long as it is not missing any headers)
tip = block_h3
all_blocks = []
for i in range(288):
next_block = create_block(tip.sha256, create_coinbase(i + 4), tip.nTime+1)
next_block.solve()
all_blocks.append(next_block)
tip = next_block
# Now send the block at height 5 and check that it wasn't accepted (missing header)
test_node.send_message(msg_block(all_blocks[1]))
test_node.sync_with_ping()
assert_raises_rpc_error(-5, "Block not found", self.nodes[0].getblock, all_blocks[1].hash)
assert_raises_rpc_error(-5, "Block not found", self.nodes[0].getblockheader, all_blocks[1].hash)
# The block at height 5 should be accepted if we provide the missing header, though
headers_message = msg_headers()
headers_message.headers.append(CBlockHeader(all_blocks[0]))
test_node.send_message(headers_message)
test_node.send_message(msg_block(all_blocks[1]))
test_node.sync_with_ping()
self.nodes[0].getblock(all_blocks[1].hash)
# Now send the blocks in all_blocks
for i in range(288):
test_node.send_message(msg_block(all_blocks[i]))
test_node.sync_with_ping()
# Blocks 1-287 should be accepted, block 288 should be ignored because it's too far ahead
for x in all_blocks[:-1]:
self.nodes[0].getblock(x.hash)
assert_raises_rpc_error(-1, "Block not found on disk", self.nodes[0].getblock, all_blocks[-1].hash)
# 5. Test handling of unrequested block on the node that didn't process
# Should still not be processed (even though it has a child that has more
# work).
# The node should have requested the blocks at some point, so
# disconnect/reconnect first
self.nodes[0].disconnect_p2ps()
self.nodes[1].disconnect_p2ps()
test_node = self.nodes[0].add_p2p_connection(P2PInterface())
test_node.wait_for_verack()
test_node.send_message(msg_block(block_h1f))
test_node.sync_with_ping()
assert_equal(self.nodes[0].getblockcount(), 2)
self.log.info("Unrequested block that would complete more-work chain was ignored")
# 6. Try to get node to request the missing block.
# Poke the node with an inv for block at height 3 and see if that
# triggers a getdata on block 2 (it should if block 2 is missing).
with mininode_lock:
# Clear state so we can check the getdata request
test_node.last_message.pop("getdata", None)
test_node.send_message(msg_inv([CInv(2, block_h3.sha256)]))
test_node.sync_with_ping()
with mininode_lock:
getdata = test_node.last_message["getdata"]
# Check that the getdata includes the right block
assert_equal(getdata.inv[0].hash, block_h1f.sha256)
self.log.info("Inv at tip triggered getdata for unprocessed block")
# 7. Send the missing block for the third time (now it is requested)
test_node.send_message(msg_block(block_h1f))
test_node.sync_with_ping()
assert_equal(self.nodes[0].getblockcount(), 290)
self.nodes[0].getblock(all_blocks[286].hash)
assert_equal(self.nodes[0].getbestblockhash(), all_blocks[286].hash)
assert_raises_rpc_error(-1, "Block not found on disk", self.nodes[0].getblock, all_blocks[287].hash)
self.log.info("Successfully reorged to longer chain from non-whitelisted peer")
# 8. Create a chain which is invalid at a height longer than the
# current chain, but which has more blocks on top of that
block_289f = create_block(all_blocks[284].sha256, create_coinbase(289), all_blocks[284].nTime+1)
block_289f.solve()
block_290f = create_block(block_289f.sha256, create_coinbase(290), block_289f.nTime+1)
block_290f.solve()
block_291 = create_block(block_290f.sha256, create_coinbase(291), block_290f.nTime+1)
# block_291 spends a coinbase below maturity!
block_291.vtx.append(create_transaction(block_290f.vtx[0], 0, b"42", 1))
block_291.hashMerkleRoot = block_291.calc_merkle_root()
block_291.solve()
block_292 = create_block(block_291.sha256, create_coinbase(292), block_291.nTime+1)
block_292.solve()
# Now send all the headers on the chain and enough blocks to trigger reorg
headers_message = msg_headers()
headers_message.headers.append(CBlockHeader(block_289f))
headers_message.headers.append(CBlockHeader(block_290f))
headers_message.headers.append(CBlockHeader(block_291))
headers_message.headers.append(CBlockHeader(block_292))
test_node.send_message(headers_message)
test_node.sync_with_ping()
tip_entry_found = False
for x in self.nodes[0].getchaintips():
if x['hash'] == block_292.hash:
assert_equal(x['status'], "headers-only")
tip_entry_found = True
assert(tip_entry_found)
assert_raises_rpc_error(-1, "Block not found on disk", self.nodes[0].getblock, block_292.hash)
test_node.send_message(msg_block(block_289f))
test_node.send_message(msg_block(block_290f))
test_node.sync_with_ping()
self.nodes[0].getblock(block_289f.hash)
self.nodes[0].getblock(block_290f.hash)
test_node.send_message(msg_block(block_291))
# At this point we've sent an obviously-bogus block, wait for full processing
# without assuming whether we will be disconnected or not
try:
# Only wait a short while so the test doesn't take forever if we do get
# disconnected
test_node.sync_with_ping(timeout=1)
except AssertionError:
test_node.wait_for_disconnect()
self.nodes[0].disconnect_p2ps()
test_node = self.nodes[0].add_p2p_connection(P2PInterface())
test_node.wait_for_verack()
# We should have failed reorg and switched back to 290 (but have block 291)
assert_equal(self.nodes[0].getblockcount(), 290)
assert_equal(self.nodes[0].getbestblockhash(), all_blocks[286].hash)
assert_equal(self.nodes[0].getblock(block_291.hash)["confirmations"], -1)
# Now send a new header on the invalid chain, indicating we're forked off, and expect to get disconnected
block_293 = create_block(block_292.sha256, create_coinbase(293), block_292.nTime+1)
block_293.solve()
headers_message = msg_headers()
headers_message.headers.append(CBlockHeader(block_293))
test_node.send_message(headers_message)
test_node.wait_for_disconnect()
# 9. Connect node1 to node0 and ensure it is able to sync
connect_nodes(self.nodes[0], 1)
sync_blocks([self.nodes[0], self.nodes[1]])
self.log.info("Successfully synced nodes 1 and 0")
if __name__ == '__main__':
AcceptBlockTest().main()
|
[
"40029035+genexcore@users.noreply.github.com"
] |
40029035+genexcore@users.noreply.github.com
|
4b14a84a25716004baaf55a0e43796fab1a29293
|
a137466dbaa5d704cd5a15ab9dfd17907b24be04
|
/algo2/mrdqn/agent.py
|
21a44e7aca50bb7bc677d14406d87263a932f502
|
[
"Apache-2.0"
] |
permissive
|
xlnwel/g2rl
|
92c15b8b9d0cd75b6d2dc8df20e6717e1a621ff6
|
e1261fdd2ce70724a99ddd174616cf013917b241
|
refs/heads/master
| 2023-08-30T10:29:44.169523
| 2021-11-08T07:50:43
| 2021-11-08T07:50:43
| 422,582,891
| 1
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 6,158
|
py
|
import tensorflow as tf
from utility.tf_utils import softmax, log_softmax, explained_variance
from utility.rl_utils import *
from utility.rl_loss import retrace
from core.decorator import override
from algo.mrdqn.base import RDQNBase, get_data_format, collect
class Agent(RDQNBase):
""" MRDQN methods """
@tf.function
def _learn(self, obs, action, reward, discount, mu, mask,
IS_ratio=1, state=None, prev_action=None, prev_reward=None):
obs, action, mu, mask, target, state, add_inp, terms = \
self._compute_target_and_process_data(
obs, action, reward, discount, mu, mask,
state, prev_action, prev_reward)
with tf.GradientTape() as tape:
x, _ = self._compute_embed(obs, mask, state, add_inp)
qs = self.q(x)
q = tf.reduce_sum(qs * action, -1)
error = target - q
value_loss = tf.reduce_mean(.5 * error**2, axis=-1)
value_loss = tf.reduce_mean(IS_ratio * value_loss)
terms['value_loss'] = value_loss
tf.debugging.assert_shapes([
[q, (None, self._sample_size)],
[target, (None, self._sample_size)],
[error, (None, self._sample_size)],
[IS_ratio, (None,)],
[value_loss, ()]
])
terms['value_norm'] = self._value_opt(tape, value_loss)
if 'actor' in self.model:
with tf.GradientTape() as tape:
pi, logpi = self.actor.train_step(x)
pi_a = tf.reduce_sum(pi * action, -1)
reinforce = tf.minimum(1. / mu, self._loo_c) * error * pi_a
v = tf.reduce_sum(qs * pi, axis=-1)
regularization = -tf.reduce_sum(pi * logpi, axis=-1)
loo_loss = -(self._v_pi_coef * v + self._reinforce_coef * reinforce)
tf.debugging.assert_shapes([
[pi, (None, self._sample_size, self._action_dim)],
[qs, (None, self._sample_size, self._action_dim)],
[v, (None, self._sample_size)],
[reinforce, (None, self._sample_size)],
[regularization, (None, self._sample_size)],
])
loo_loss = tf.reduce_mean(loo_loss, axis=-1)
regularization = tf.reduce_mean(regularization, axis=-1)
actor_loss = loo_loss - self._tau * regularization
actor_loss = tf.reduce_mean(IS_ratio * actor_loss)
terms.update(dict(
reinforce=reinforce,
v=v,
loo_loss=loo_loss,
regularization=regularization,
actor_loss=actor_loss,
ratio=tf.reduce_mean(pi_a / mu),
pi_min=tf.reduce_min(pi),
pi_std=tf.math.reduce_std(pi)
))
terms['actor_norm'] = self._actor_opt(tape, actor_loss)
if self._is_per:
priority = self._compute_priority(tf.abs(error))
terms['priority'] = priority
terms.update(dict(
q=q,
q_std=tf.math.reduce_std(q),
error=error,
error_std=tf.math.reduce_std(error),
mu_min=tf.reduce_min(mu),
mu=mu,
mu_inv=tf.reduce_mean(1/mu),
mu_std=tf.math.reduce_std(mu),
target=target,
explained_variance_q=explained_variance(target, q)
))
return terms
@override(RDQNBase)
def _compute_target(self, obs, action, reward, discount,
mu, mask, state, add_inp):
terms = {}
x, _ = self._compute_embed(obs, mask, state, add_inp, online=False)
if self._burn_in_size:
bis = self._burn_in_size
ss = self._sample_size
_, reward = tf.split(reward, [bis, ss], 1)
_, discount = tf.split(discount, [bis, ss], 1)
_, next_mu_a = tf.split(mu, [bis+1, ss], 1)
_, next_x = tf.split(x, [bis+1, ss], 1)
_, next_action = tf.split(action, [bis+1, ss], 1)
else:
_, next_mu_a = tf.split(mu, [1, self._sample_size], 1)
_, next_x = tf.split(x, [1, self._sample_size], 1)
_, next_action = tf.split(action, [1, self._sample_size], 1)
next_qs = self.target_q(next_x)
regularization = None
if 'actor' in self.model:
next_pi, next_logpi = self.target_actor.train_step(next_x)
if self._probabilistic_regularization == 'entropy':
regularization = tf.reduce_sum(
self._tau * next_pi * next_logpi, axis=-1)
else:
if self._probabilistic_regularization is None:
if self._double: # don't suggest to use double Q here, but implement it anyway
online_x, _ = self._compute_embed(obs, mask, state, add_inp)
next_online_x = tf.split(online_x, [bis+1, ss-1], 1)
next_online_qs = self.q(next_online_x)
next_pi = self.q.compute_greedy_action(next_online_qs, one_hot=True)
else:
next_pi = self.target_q.compute_greedy_action(next_qs, one_hot=True)
elif self._probabilistic_regularization == 'prob':
next_pi = softmax(next_qs, self._tau)
elif self._probabilistic_regularization == 'entropy':
next_pi = softmax(next_qs, self._tau)
next_logpi = log_softmax(next_qs, self._tau)
regularization = tf.reduce_sum(next_pi * next_logpi, axis=-1)
terms['next_entropy'] = - regularization / self._tau
else:
raise ValueError(self._probabilistic_regularization)
discount = discount * self._gamma
target = retrace(
reward, next_qs, next_action,
next_pi, next_mu_a, discount,
lambda_=self._lambda,
axis=1, tbo=self._tbo,
regularization=regularization)
return target, terms
|
[
"122134545@qq.com"
] |
122134545@qq.com
|
457db9cf31f17eff66a91f40c6afac4e33165f21
|
c2e2d1a80850017b95931752801024eb3f03b66a
|
/revision/repeated_word.py
|
2be1c4bb117045c352ee5c281760dcd177c55f98
|
[] |
no_license
|
shreyasvinaya/School_assignments
|
61e7c909f1f0764d0978455d137a962e05e34c5e
|
2c2dbd328fc896b70555176802c1c2166c974353
|
refs/heads/master
| 2020-07-08T18:58:15.001500
| 2019-11-19T05:01:12
| 2019-11-19T05:01:12
| 203,750,066
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 326
|
py
|
#most repeated word
a=input('enter a sentence')
b=a.split()
print(b)
d={}
for i in range(len(b)):
pass
if b[i] not in d:
d[b[i]]=1
else:
for j in d:
pass
if b[i]==j :
pass
d[b[i]]+=1
highest=0
item=''
for q in d:
if d[q]>highest :
pass
highest=d[q]
item=q
print(item,highest)
|
[
"noreply@github.com"
] |
shreyasvinaya.noreply@github.com
|
b77ad5adbfe3bdc3c5a57d4185371cc854289ac2
|
a07124716edd86159dff277010132ba9c5cd0f75
|
/Text-Based Browser/task/tests.py
|
3ca883bce21f71b1767281f280b941e8d1d999d1
|
[
"MIT"
] |
permissive
|
drtierney/hyperskill-TextBasedBrowser-Python
|
27a15fa0bd44a927a9552d4815a0b4ab69375710
|
a4f2ac60643559e580b75a02078a679e5f1f0a2c
|
refs/heads/main
| 2023-08-28T04:24:51.693648
| 2021-10-25T17:34:58
| 2021-10-25T17:34:58
| 415,304,838
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 5,637
|
py
|
from hstest.stage_test import StageTest
from hstest.test_case import TestCase
from hstest.check_result import CheckResult
import os
import shutil
import sys
if sys.platform.startswith("win"):
import _locale
# pylint: disable=protected-access
_locale._getdefaultlocale = (lambda *args: ['en_US', 'utf8'])
CheckResult.correct = lambda: CheckResult(True, '')
CheckResult.wrong = lambda feedback: CheckResult(False, feedback)
class TextBasedBrowserTest(StageTest):
def generate(self):
return [
TestCase(
stdin='bloomberg.com\nbloomberg\nexit',
attach=('Bloomberg', 'New York Times', 'bloomberg'),
args=['tb_tabs']
),
TestCase(
stdin='nytimes.com\nnytimes\nexit',
attach=('New York Times', 'Bloomberg', 'nytimes'),
args=['tb_tabs']
),
TestCase(
stdin='nytimescom\nexit',
args=['tb_tabs']
),
TestCase(
stdin='blooomberg.com\nexit',
args=['tb_tabs']
),
TestCase(
stdin='blooomberg.com\nnytimes.com\nexit',
attach=(None, 'New York Times', 'Bloomberg', 'nytimes'),
args=['tb_tabs']
),
TestCase(
stdin='nytimescom\nbloomberg.com\nexit',
attach=(None, 'Bloomberg', 'New York Times', 'bloomberg'),
args=['tb_tabs']
),
TestCase(
stdin='bloomberg.com\nnytimes.com\nback\nexit',
attach={
'This New Liquid Is Magnetic, and Mesmerizing': (1, 'New York Times'),
'The Space Race: From Apollo 11 to Elon Musk': (2, 'Bloomberg')
},
args=['tb_tabs']
),
TestCase(
stdin='nytimes.com\nbloomberg.com\nback\nexit',
attach={
'This New Liquid Is Magnetic, and Mesmerizing': (2, 'New York Times'),
'The Space Race: From Apollo 11 to Elon Musk': (1, 'Bloomberg')
},
args=['tb_tabs']
),
]
def _check_files(self, path_for_tabs: str, right_word: str) -> int:
"""
Helper which checks that browser saves visited url in files and
provides access to them.
:param path_for_tabs: directory which must contain saved tabs
:param right_word: Word-marker which must be in right tab
:return: True, if right_words is present in saved tab
"""
for path, dirs, files in os.walk(path_for_tabs):
for file in files:
with open(os.path.join(path_for_tabs, file), 'r') as tab:
try:
content = tab.read()
except UnicodeDecodeError:
return -1
if right_word in content:
return 1
break
return 0
def check(self, reply, attach):
# Incorrect URL
if attach is None:
if 'error' in reply.lower():
return CheckResult.correct()
else:
return CheckResult.wrong('There was no "error" word, but should be.')
# Correct URL
if isinstance(attach, tuple):
if len(attach) == 4:
_, *attach = attach
if 'error' not in reply.lower():
return CheckResult.wrong('There was no "error" word, but should be.')
right_word, wrong_word, correct_file_name = attach
path_for_tabs = 'tb_tabs'
if not os.path.isdir(path_for_tabs):
return CheckResult.wrong(
"Can't find a directory \"" + path_for_tabs + "\" "
"in which you should save your web pages.")
check_files_result = self._check_files(path_for_tabs, right_word)
if not check_files_result:
return CheckResult.wrong(
"Seems like you did\'n save the web page "
"\"" + right_word + "\" into the "
"directory \"" + path_for_tabs + "\". "
"This file with page should be named \"" + correct_file_name + "\"")
elif check_files_result == -1:
return CheckResult.wrong('An error occurred while reading your saved tab. '
'Perhaps you used the wrong encoding?')
try:
shutil.rmtree(path_for_tabs)
except PermissionError:
return CheckResult.wrong("Impossible to remove the directory for tabs. Perhaps you haven't closed some file?")
if wrong_word in reply:
return CheckResult.wrong('It seems like you printed wrong variable')
if right_word in reply:
return CheckResult.correct()
return CheckResult.wrong('You printed neither bloomberg_com nor nytimes_com')
if isinstance(attach, dict):
for key, value in attach.items():
count, site = value
real_count = reply.count(key)
if reply.count(key) != count:
return CheckResult.wrong(
f'The site "{site}" should be displayed {count} time(s).\n'
f'Actually displayed: {real_count} time(s).'
)
return CheckResult.correct()
TextBasedBrowserTest().run_tests()
|
[
"d.r.tierney@hotmail.co.uk"
] |
d.r.tierney@hotmail.co.uk
|
9aba1899299285447301d3bd0bbab2728dbffe70
|
2f5e366b7dc799e77ea7a4200e7a491f78a538b9
|
/src/Writer.py
|
84833457bb852ecf7460d82bd22e39d03afacd74
|
[] |
no_license
|
dspray95/swarm-ai-python
|
111e0555b8ec2bd823980691b4e39f5db453da26
|
156b072689badb2542b4cc8032b3733a7d33bc53
|
refs/heads/master
| 2020-03-11T19:02:26.953261
| 2018-04-21T14:27:54
| 2018-04-21T14:27:54
| 130,195,277
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 598
|
py
|
class Writer:
def __init__(self, path):
self.path = path + "\\data"
def write_file(self, aggression, distribution, dead, productivity, time):
csv = open(self.path + "swarmdata.csv", "w")
title_row = "aggression,distribution,dead,productivity,time\n"
csv.write(title_row)
for index, aggression in enumerate(aggression):
row = aggression[index] + "," + distribution[index] + "," + dead[index] + "," + productivity[index] + "," + time[index]
row = row.replace("\n", '')
row = row + "\n"
csv.write(row)
|
[
"dspray95@gmail.com"
] |
dspray95@gmail.com
|
440882081229f4907b7d73f358e1e957fd47ae98
|
9660ada2f477f0d89f60cfd2e979824c7c97ea31
|
/src/experiments/no_trading_data.py
|
6903b582da442d6a8ab9f56f8ff7138f8a02fa9c
|
[] |
no_license
|
JonasLaksen/deeptsa
|
941464fa499ac8022f7980e59265d48d83d078b9
|
1e8f9faf6272e9720bafcb7a0269ad7301fd3cdd
|
refs/heads/master
| 2022-12-20T21:46:39.246314
| 2020-07-19T21:28:36
| 2020-07-19T21:28:36
| 170,122,906
| 0
| 0
| null | 2022-11-21T22:47:57
| 2019-02-11T12:11:49
|
Python
|
UTF-8
|
Python
| false
| false
| 3,705
|
py
|
import json
import os
import pathlib
import random
import sys
from datetime import datetime
from functools import reduce
import numpy as np
import tensorflow as tf
from src.lstm_one_output import LSTMOneOutput
from src.models.stacked_lstm import StackedLSTM
from src.utils import load_data, get_features, plot_one, get_feature_list_lags
seed = int(sys.argv[1]) if sys.argv[1] else 0
type_search = sys.argv[2] if sys.argv[2] else 'hyper'
layer_sizes = list(map(int, sys.argv[3].split(","))) if sys.argv[3] else [999]
model_type = sys.argv[4] if sys.argv[4] else 'stacked'
os.environ['PYTHONHASHSEED'] = str(seed)
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
def calculate_n_features_and_batch_size(X_train):
return X_train.shape[2], X_train.shape[0]
def experiment_no_trading_data(epochs, y_type='next_price', feature_list=[], experiment_name="no_trading_data"):
experiment_timestamp = datetime.now()
description = 'Analyse all stocks without trading data and evaluate'
X, y, y_dir, X_stocks, scaler_y = load_data(feature_list, y_type)
X, y, y_dir, X_stocks = X, y, y_dir, X_stocks
training_size = int(.9 * len(X[0]))
X_train, y_train = X[:, :training_size], y[:, :training_size]
X_val, y_val = X[:, training_size:], y[:, training_size:]
n_features, batch_size = calculate_n_features_and_batch_size(X_train)
stock_list = [np.arange(len(X)).reshape((len(X), 1, 1))]
lstm = LSTMOneOutput(**{
'X_stocks': X_stocks,
'X_train': X_train,
'y_train': y_train,
'X_val': X_val,
'y_val': y_val,
'feature_list': feature_list,
'dropout': .1,
'optimizer': tf.keras.optimizers.Adam(.001),
'loss': 'MSE',
'model_generator': StackedLSTM,
'layer_sizes': layer_sizes,
'seed': seed,
'n_features': n_features,
'batch_size': batch_size,
'stock_list': stock_list
})
losses = lstm.train(
gen_epochs=epochs,
spech_epochs=0,
copy_weights_from_gen_to_spec=False,
load_spec=False,
load_gen=False,
train_general=True,
train_specialized=False)
evaluation = lstm.generate_general_model_results(
scaler_y=scaler_y, y_type=y_type
)
filename_midfix = f
'{os.path.basename(__file__)}/{experiment_timestamp}'
directory = f
'results/{filename_midfix}/aksje-{i}-{X_stocks[i]}'
if not os.path.exists(directory):
os.makedirs(directory)
evaluation = lstm.generate_general_model_results(
scaler_y=scaler_y, y_type=y_type, title="No trading data", filename=f
'{ directory }/plot'
)
with open(
f'results/{os.path.basename(__file__)}/{experiment_timestamp}/{experiment_name}/loss_history.txt',
'a+') as f:
f.write(str(losses['general_loss']))
f.write(str(losses['general_val_loss']))
with open(
f'results/{os.path.basename(__file__)}/{experiment_timestamp}/{experiment_name}/evaluation.json',
'a+') as f:
f.write(json.dumps(evaluation, indent=4));
with open(f'results/{os.path.basename(__file__)}/{experiment_timestamp}/{experiment_name}/meta.txt',
'a+') as f:
f.write(lstm.meta(description, epochs))
plot_one('Loss history', [losses['general_loss'], losses['general_val_loss']], ['Training loss', 'Validation loss'], ['Epoch', 'Loss'])
feature_list = get_features(trading=False)
experiment_no_trading_data(5000, y_type="next_price", feature_list=feature_list)
|
[
"pthoang94@gmail.com"
] |
pthoang94@gmail.com
|
03df94b728472d4265b8096044658913498868d3
|
e669f692892b23cdc5829bf82e3b81ab016ec973
|
/active_learning/query_strategies/core_set.py
|
3a52ff7357f36990feff47e505bf04ec60b9916d
|
[] |
no_license
|
JackYANG19/A-Benchmark-and-Empirical-Analysis-for-Replay-Strategies-in-Continual-Learning
|
848610f94eb38de0148ef6d05af0ec4144feecce
|
a6be52884576d56135fd05181df747ea2323f79f
|
refs/heads/main
| 2023-05-29T00:37:49.633513
| 2021-06-11T07:44:02
| 2021-06-11T07:44:02
| 375,931,888
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,406
|
py
|
import numpy as np
from .strategy import Strategy
from sklearn.neighbors import NearestNeighbors
import pickle
from datetime import datetime
class CoreSet(Strategy):
def __init__(self, X, Y, idxs_lb, net, handler, args, tor=1e-4):
super(CoreSet, self).__init__(X, Y, idxs_lb, net, handler, args)
self.tor = tor
def query(self, n):
lb_flag = self.idxs_lb.copy()
embedding = self.get_embedding(self.X, self.Y)
embedding = embedding.numpy()
print('calculate distance matrix')
t_start = datetime.now()
dist_mat = np.matmul(embedding, embedding.transpose())
sq = np.array(dist_mat.diagonal()).reshape(len(self.X), 1)
dist_mat *= -2
dist_mat += sq
dist_mat += sq.transpose()
dist_mat = np.sqrt(dist_mat)
print(datetime.now() - t_start)
print('calculate greedy solution')
t_start = datetime.now()
mat = dist_mat[~lb_flag, :][:, lb_flag]
for i in range(n):
if i % 10 == 0:
print('greedy solution {}/{}'.format(i, n))
mat_min = mat.min(axis=1)
q_idx_ = mat_min.argmax()
q_idx = np.arange(self.n_pool)[~lb_flag][q_idx_]
lb_flag[q_idx] = True
mat = np.delete(mat, q_idx_, 0)
mat = np.append(mat, dist_mat[~lb_flag, q_idx][:, None], axis=1)
print(datetime.now() - t_start)
opt = mat.min(axis=1).max()
bound_u = opt
bound_l = opt / 2.0
delta = opt
xx, yy = np.where(dist_mat <= opt)
dd = dist_mat[xx, yy]
lb_flag_ = self.idxs_lb.copy()
subset = np.where(lb_flag_ == True)[0].tolist()
SEED = 5
pickle.dump((xx.tolist(), yy.tolist(), dd.tolist(), subset, float(opt), n, self.n_pool),
open('mip{}.pkl'.format(SEED), 'wb'), 2)
import ipdb
ipdb.set_trace()
# solving MIP
# download Gurobi software from http://www.gurobi.com/
# sh {GUROBI_HOME}/linux64/bin/gurobi.sh < core_set_sovle_solve.py
sols = pickle.load(open('sols{}.pkl'.format(SEED), 'rb'))
if sols is None:
q_idxs = lb_flag
else:
lb_flag_[sols] = True
q_idxs = lb_flag_
print('sum q_idxs = {}'.format(q_idxs.sum()))
return np.arange(self.n_pool)[(self.idxs_lb ^ q_idxs)]
|
[
"noreply@github.com"
] |
JackYANG19.noreply@github.com
|
4918810498af75369329a2204c7cccbe0e40efb1
|
40dd8330e5f78c4348bbddc2c5acfd59d793dd51
|
/tools/model_converters/twins2mmseg.py
|
647d41784aa07468be4b3f2e183064ad55266ad1
|
[
"Apache-2.0"
] |
permissive
|
open-mmlab/mmsegmentation
|
0d12092312e2c465ede1fd7dd9847b6f2b37049c
|
30a3f94f3e2916e27fa38c67cc3b8c69c1893fe8
|
refs/heads/main
| 2023-09-04T10:54:52.299711
| 2023-07-24T07:28:21
| 2023-07-24T07:28:21
| 272,133,018
| 6,534
| 2,375
|
Apache-2.0
| 2023-09-14T01:22:32
| 2020-06-14T04:32:33
|
Python
|
UTF-8
|
Python
| false
| false
| 2,764
|
py
|
# Copyright (c) OpenMMLab. All rights reserved.
import argparse
import os.path as osp
from collections import OrderedDict
import mmengine
import torch
from mmengine.runner import CheckpointLoader
def convert_twins(args, ckpt):
new_ckpt = OrderedDict()
for k, v in list(ckpt.items()):
new_v = v
if k.startswith('head'):
continue
elif k.startswith('patch_embeds'):
if 'proj.' in k:
new_k = k.replace('proj.', 'projection.')
else:
new_k = k
elif k.startswith('blocks'):
# Union
if 'attn.q.' in k:
new_k = k.replace('q.', 'attn.in_proj_')
new_v = torch.cat([v, ckpt[k.replace('attn.q.', 'attn.kv.')]],
dim=0)
elif 'mlp.fc1' in k:
new_k = k.replace('mlp.fc1', 'ffn.layers.0.0')
elif 'mlp.fc2' in k:
new_k = k.replace('mlp.fc2', 'ffn.layers.1')
# Only pcpvt
elif args.model == 'pcpvt':
if 'attn.proj.' in k:
new_k = k.replace('proj.', 'attn.out_proj.')
else:
new_k = k
# Only svt
else:
if 'attn.proj.' in k:
k_lst = k.split('.')
if int(k_lst[2]) % 2 == 1:
new_k = k.replace('proj.', 'attn.out_proj.')
else:
new_k = k
else:
new_k = k
new_k = new_k.replace('blocks.', 'layers.')
elif k.startswith('pos_block'):
new_k = k.replace('pos_block', 'position_encodings')
if 'proj.0.' in new_k:
new_k = new_k.replace('proj.0.', 'proj.')
else:
new_k = k
if 'attn.kv.' not in k:
new_ckpt[new_k] = new_v
return new_ckpt
def main():
parser = argparse.ArgumentParser(
description='Convert keys in timm pretrained vit models to '
'MMSegmentation style.')
parser.add_argument('src', help='src model path or url')
# The dst path must be a full path of the new checkpoint.
parser.add_argument('dst', help='save path')
parser.add_argument('model', help='model: pcpvt or svt')
args = parser.parse_args()
checkpoint = CheckpointLoader.load_checkpoint(args.src, map_location='cpu')
if 'state_dict' in checkpoint:
# timm checkpoint
state_dict = checkpoint['state_dict']
else:
state_dict = checkpoint
weight = convert_twins(args, state_dict)
mmengine.mkdir_or_exist(osp.dirname(args.dst))
torch.save(weight, args.dst)
if __name__ == '__main__':
main()
|
[
"noreply@github.com"
] |
open-mmlab.noreply@github.com
|
6332935611c8fc4d545043236f06b43121fcb9a3
|
555319a2f344a789e6971a877824111b13004c6d
|
/transfer_points.py
|
65a0b2040789bb1378783a424f0548a72d95a945
|
[] |
no_license
|
Kairobo/Learn_Python
|
66e792054e70b72039a610cb8159693352b3092e
|
903f5d1d8614f4b3a81dc005362efb0ee50e8778
|
refs/heads/master
| 2021-01-25T09:45:00.162914
| 2018-09-12T04:53:07
| 2018-09-12T04:53:07
| 123,317,004
| 2
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,917
|
py
|
from copy import deepcopy
import numpy as np
def vector_norm(vec):
return np.sqrt(np.power(vec[0],2)+np.power(vec[1],2))
def vector_divide(vec,divider=1):
assert(len(vec)==2)
vec_new = deepcopy(vec)
vec_new[0] = vec_new[0]/divider
vec_new[1] = vec_new[1]/divider
return vec_new
def vector_add(add_list):
vec_new = [0,0]
if len(add_list) == 0:
return vec_new
for i in range(len(add_list)):
vec_new[0] = vec_new[0] + add_list[i][0]
vec_new[1] = vec_new[1] + add_list[i][1]
return vec_new
def vector_subtract_2(sub_list):
vec_new = [0,0]
assert len(sub_list) == 2
vec_new[0] = sub_list[0][0] - sub_list[1][0]
vec_new[1] = sub_list[0][1] - sub_list[1][1]
return vec_new
#Effect: given four geo_points locations and their pixel locations
#and a list of polygon positions, transfer the four polygon_locations as geo_points
#Require:
#the sequence of the geo_locations is corresponding to the pix_locations
# 1 2
#
# 4 3
def polygon_pix2geo(polygon_indexes,pix_locations,geo_locations):
polygon_new = deepcopy(polygon_indexes)
num_points = len(polygon_indexes)
gO_0 = geo_locations[3]
#4->1
tmp_sub_list = [geo_locations[3],geo_locations[0]]
gx_0 = vector_subtract_2(tmp_sub_list)
gx_0_norm = vector_norm(gx_0)
# 4->3
tmp_sub_list = [geo_locations[3],geo_locations[2]]
gy_0 = vector_subtract_2(tmp_sub_list)
gy_0_norm = vector_norm(gy_0)
for i in range(num_points):
tmp_add_list = []
tmp_add_list.append(O_0)
tmp_add_list.append()
return polygon_new
pix_locations =[[10,10],[10,240],[240,240],[240,10]]
geo_locations = [[99,3],[100,3],[100,4],[99,4]]#la,long
polygon_indexes = [[0,0],[100,50],[30,70]]
polygon_new = polygon_pix2geo(polygon_indexes=polygon_indexes,pix_locations=pix_locations,geo_locations=geo_locations)
print(polygon_new)
|
[
"kajia@umich.edu"
] |
kajia@umich.edu
|
2e7a4bd79b06aac3719043d6611fdd4744d9fe10
|
51065aaa884c855fb00d65abbebd6d33f99b289c
|
/Nenotal PDA monitoring/Software/HR_Unit_Tests.py
|
5617303e8bb7e476765ed366ba2bcf0ad1bbe6df
|
[] |
no_license
|
johnsonhit/Neonatal-cardiac-monitoring
|
e5d78ae8772f0366a764760a804c33293ee015bc
|
efd2b896e8ef7272d61b5f2b98e49ed6ad6e4e1a
|
refs/heads/master
| 2020-07-25T16:43:31.984399
| 2019-03-26T02:03:23
| 2019-03-26T02:03:23
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 7,552
|
py
|
# -*- coding: utf-8 -*-
"""
Created on Wed Sep 23 18:04:46 2015
@author: Moseph
"""
import unittest
class runTests(unittest.TestCase): #all of the below unit tests test the accuracy and correctness of functions used in HR_Monitor.py
# Status: All tests Run OK in ~0.03 seconds
def test_findTHRZone(self):
"""
checks that accurate target heart zone is calculated based off of input data
"""
from HR_Monitor import findTHRZone
input1=22
output1, output2, output3, output4=findTHRZone(input1)
self.assertAlmostEqual(output3,191.6, msg='ironically the max is not actually a max')
self.assertEqual(output1,134, msg='70% of what???, definitely not the max!')
self.assertEqual(output2,163, msg='85% of what???, certainly not the max!')
def test_findsafeRHR(self):
"""
checks that accurate safe resting heart rate (RHR) is calculated based off of all combinations of input data
"""
from HR_Monitor import findsafeRHR
input1='Male'
input2='Female'
input3='High Level Athlete'
input4='Relatively Fit'
input5='Couch Potato'
output1=findsafeRHR(input1,input3)
output2=findsafeRHR(input1,input4)
output3=findsafeRHR(input1,input5)
output4=findsafeRHR(input2,input3)
output5=findsafeRHR(input2,input4)
output6=findsafeRHR(input2,input5)
self.assertEqual(output1,48, msg='Lie detector is telling me this is a lie')
self.assertEqual(output2,60, msg='Something smells fishy...tuna maybe?')
self.assertEqual(output3,72, msg='You lie about as well as you pass unit tests')
self.assertEqual(output4,52, msg='Lie detector is telling me this is a lie')
self.assertEqual(output5,64, msg='Something smells fishy...is it salmon?')
self.assertEqual(output6,76, msg='You lie about as well as you pass unit tests')
def test_importandseparate(self):
"""
checks for if the input vectors are the same length
"""
from HR_Monitor import importandseparate
from random import randrange
input1 = randrange(1,21,1)
t, v=importandseparate(input1)
self.assertEqual(len(t),len(v), msg='different lengths! abort abort abort!')
def test_makenparray(self):
"""
checks to make sure input vectors are output as numpy arrays
"""
from HR_Monitor import makenparray
from numpy import ndarray
a=[1,3,-5,2,7,5,9,-1,3,-4]
a_new=makenparray(a)
self.assertIsInstance(a_new,ndarray, msg='not an np array!!!')
def test_removeDCoffset(self):
"""
checks that the input and output vectors are the same length
"""
from HR_Monitor import removeDCoffset
from numpy import array, int8
input1=array([1,2,3,4,5,10,9,8,7,6], dtype=int8)
output1=removeDCoffset(input1)
self.assertEqual(len(input1),len(output1), msg='output length is not quite right')
def test_normalizeData(self):
"""
checks that an input array is properly normalized by ensuring all resulting
values are between -1 and 1, that either -1 or 1 is a value, and the correct
value is chosen to normalize data against
"""
from HR_Monitor import normalizeData
from numpy import array, float32, absolute
input1=array([-5.6,-9.4,-3.5,-1.4,4.3,4.8,0.9,-2.8,-3.9,6.9], dtype=float32)
output1=normalizeData(input1)
self.assertLessEqual(max(output1), 1, msg='values are abnormal...get it? :)')
self.assertGreaterEqual(min(output1), -1, msg='values are abnormal...get it? :)')
self.assertEqual(max(abs(output1)),1, msg='values are abnormal...get it? :)')
self.assertEqual(abs(output1[1]), 1, msg='normalized against wrong value')
self.assertEqual(len(input1),len(output1), msg='output length is not quite right')
def test_elapsedtime(self):
"""
checks that (1) elapsed time is result of final index value in a vector
minus the initial index value (2) elapsed time is a single value (3) elapsed
time is positive
"""
from HR_Monitor import elapsedtime
from numpy import array, float32
b=[1,2,3,4,5,6,7,8,9,10]
a=array(b, dtype=float32)
a_new=elapsedtime(a)
self.assertEqual(a_new.size,1, msg='WRONG, this should be a single value, not a vector')
self.assertEqual(a_new,9, msg='Nope, this elapsed time is not correct')
self.assertGreater(a_new,0, msg='Eh eh, time elapsed should be greater than 0')
def test_crosscorrviafor(self):
"""
checks that cross correlation of kernel with measured signal via for loop
is working properly by ensuring the resulting numpy array of correlation
coefficients is the appropriate length (which equals number of loops) and
each index value is correct, using known values
"""
from HR_Monitor import crosscorrviafor
from numpy import array, float32
a=array([3,1,2,0,2], dtype=float32) #known measured signal array
b=array([1,1], dtype=float32) #kernel array
c=len(b)
x=crosscorrviafor(a,c,b)
self.assertEqual(len(x), len(a)-1, msg='Coefficient vector wrong length dude')
self.assertEqual(x[0], 4, msg='Cross correlation went south bro')
self.assertEqual(x[1], 3, msg='Cross correlation went south bro')
self.assertEqual(x[2], 2, msg='Cross correlation went south bro')
self.assertEqual(x[3], 2, msg='Cross correlation went south bro')
def test_sectominconvert(self):
"""
checks that conversion from seconds to minutes of a given time numpy array
is done correctly using known values
"""
from HR_Monitor import sectomin
from numpy import array, float32
a=array([120], dtype=float32)
b=sectomin(a)
self.assertEqual(b, 2, msg='Ummm, this is not in minutes man!')
def test_simpledivision(self):
"""
checks for correct division of two numpy arrays using known values
"""
from HR_Monitor import calcheartrate
from numpy import array, float32
a=array([50], dtype=float32)
b=array([20], dtype=float32)
output1, output2 = calcheartrate(a,b)
self.assertEqual(output1, 2.5, msg='Go back to 3rd grade and learn to divide...in Python')
def test_lessthan(self):
"""
checks that the less than condition is properly assessed
"""
from HR_Monitor import detectbradycardia
input1=50
input2=85
output1=detectbradycardia(input1, input2)
output2=detectbradycardia(input2, input1)
self.assertEqual(output1, 0, msg='this would be true...if it were opposite day')
self.assertEqual(output2, 1, msg='opposite day only exists in cartoons')
def test_greaterthan(self):
"""
checks that the greater than condition is properly assessed
"""
from HR_Monitor import detecttachycardia
input1=27
input2=43
output1=detecttachycardia(input1, input2)
output2=detecttachycardia(input2, input1)
self.assertEqual(output1, 1, msg='this would not be false...if it were opposite day')
self.assertEqual(output2, 0, msg='opposite day or not, this is wrong')
if __name__ == '__main__':
unittest.main()
|
[
"noreply@github.com"
] |
johnsonhit.noreply@github.com
|
e00966eccc36c07429403e8283952fe96a7dc0c6
|
f398d8a101679f02c86d056a7027664559d59f3d
|
/mediaserverV1/common/app.py
|
5dbbb1bdc00586acd75186a2e07f615d8a9a8e95
|
[] |
no_license
|
sasanyi/mediaserver-client
|
5c5ffcef438eb54947a7fe73a66f2fef4c52b9f1
|
bd2eaadd2aa0412dd80d3fedfee9438331b48923
|
refs/heads/main
| 2023-05-09T19:21:03.170112
| 2021-04-20T11:59:58
| 2021-04-20T11:59:58
| 359,217,955
| 0
| 1
| null | 2021-06-02T06:58:31
| 2021-04-18T18:05:05
|
JavaScript
|
UTF-8
|
Python
| false
| false
| 646
|
py
|
from sqlalchemy.orm import sessionmaker
from .models import Base
class App:
__db = None
@staticmethod
def setDb(db):
App.__db = db
@staticmethod
def getDb():
if App.__db is not None:
return App.__db
else:
raise RuntimeError("Server not configured")
class Database:
engine = None
_db = None
def __init__(self, engine):
self.engine = engine
Base.metadata.create_all(bind=engine)
Session = sessionmaker(bind=engine)
self._db = Session()
@property
def db(self):
return self._db
|
[
"savanya.sandor.jozsef@gmail.com"
] |
savanya.sandor.jozsef@gmail.com
|
c436a852bf1b29fdd43c22fec676f7de2348174a
|
da7a165522daea7c346693c5f32850017c482967
|
/abc51-100/abc066/c.py
|
09ed9795009df321637516a4eee2dcfb604ef0b8
|
[] |
no_license
|
SShayashi/ABC
|
19f8750919208c5ff8935638dbaab941c255f914
|
3cbfee0c5251c1bb0df6306166d8d4b33bf7bb2c
|
refs/heads/master
| 2021-05-04T21:06:10.720367
| 2020-07-11T13:59:16
| 2020-07-11T13:59:29
| 119,886,572
| 2
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 317
|
py
|
def main():
n = int(input())
a = list(map(int, input().split()))
even = a[1::2]
odd = a[::2]
ans = []
if n % 2 == 0:
even.reverse()
ans = even + odd
else:
odd.reverse()
ans = odd + even
to_str = map(str, ans)
return " ".join(to_str)
print(main())
|
[
"sshayashi0208@gmail.com"
] |
sshayashi0208@gmail.com
|
668a48a3ce0d405c8471c0a654011de3bee895c6
|
96facbfa0cd5a2ca63819d67f46af3c3456631c1
|
/sound4bats/plot_metrics.py
|
9e4acaa3c4f6e31ed3e7ecbc9ab6650ece023e7c
|
[
"MIT"
] |
permissive
|
cloudedbats/cloudedbats_sound
|
114a79f88ea0dd789304b88ecf451acc4196bb3e
|
e9c263ed86665f2f2a0b8bed300bca0a5c5b61f6
|
refs/heads/master
| 2021-07-14T03:36:12.777907
| 2020-07-21T07:27:54
| 2020-07-21T07:27:54
| 158,961,160
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 329
|
py
|
#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: http://cloudedbats.org
# Copyright (c) 2019 Arnold Andreasson
# License: MIT License (see LICENSE.txt or http://opensource.org/licenses/mit).
import numpy
import pathlib
import dsp4bats
class PlotMetrics():
""" """
def __init__(self, debug=False):
""" """
|
[
"parallels@parallels-Parallels-Virtual-Platform"
] |
parallels@parallels-Parallels-Virtual-Platform
|
9c966306cb14e900ddb0fe333aef456dc990cd86
|
20854911d21af4061fb8508998f9e6221805fa11
|
/compasssudoku/util.py
|
0350f8e270cc274ec463fce0a507bdc1235c9e05
|
[
"MIT"
] |
permissive
|
corrodedHash/compass-sudoku-z3
|
4df43bb79e5b8143b6efae8a7b09e353d6cbc428
|
62105ce76e1965da48944d98eb7eaac16ac313b0
|
refs/heads/master
| 2020-09-11T08:15:29.459647
| 2020-02-27T14:12:12
| 2020-02-27T14:12:12
| 222,002,117
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,663
|
py
|
"""Contains utility"""
import enum
from typing import Tuple, List, Optional
Coord2D = Tuple[int, int]
class CardinalDirection(enum.Enum):
"""Cardinal directions"""
north = enum.auto()
east = enum.auto()
south = enum.auto()
west = enum.auto()
DIRECTION_MAP = {
CardinalDirection.north: (0, -1),
CardinalDirection.east: (1, 0),
CardinalDirection.south: (0, 1),
CardinalDirection.west: (-1, 0),
}
ORTHOGONAL_DIRECTION_MAP = {
CardinalDirection.north: (1, 0),
CardinalDirection.east: (0, 1),
CardinalDirection.south: (-1, 0),
CardinalDirection.west: (0, -1),
}
def in_bounds(cell: Coord2D, bounds: Coord2D) -> bool:
"""Check that coordinate is in [0, bounds)"""
return cell[0] >= 0 and cell[0] < bounds[0] and cell[1] >= 0 and cell[1] < bounds[1]
def add_coords(summand1: Coord2D, summand2: Coord2D, bounds: Optional[Coord2D] = None) -> Coord2D:
"""Add two tuples"""
result = (summand1[0] + summand2[0], summand1[1] + summand2[1])
if bounds is not None:
result = (result[0] % bounds[0], result[1] % bounds[1])
return result
def get_direction_cells(
origin: Coord2D, dimensions: Coord2D, direction: CardinalDirection
) -> List[Coord2D]:
"""List all cells in the given direction"""
result = []
current = add_coords(origin, DIRECTION_MAP[direction])
while in_bounds(current, dimensions):
result.append(current)
current = add_coords(current, ORTHOGONAL_DIRECTION_MAP[direction], dimensions)
if current[0] == origin[0] or current[1] == origin[1]:
current = add_coords(current, DIRECTION_MAP[direction])
return result
|
[
"lukas.woelfer@rwth-aachen.de"
] |
lukas.woelfer@rwth-aachen.de
|
16f56f1f208c469a2d92b843ac849f98a7111d08
|
7087a5dd1772c9456f098bc024a894dcaeef5432
|
/backup/build/new-calkube/kubernetes-6.0.0_snapshot-py2.7.egg/kubernetes/client/models/v1_delete_options.py
|
575bcf443ee81e1402ef6bba7a8c440f8590df0a
|
[] |
no_license
|
santhoshchami/kubecctl-python
|
5be7a5a17cc6f08ec717b3eb1c11719ef7653aba
|
cd45af465e25b0799d65c573e841e2acb983ee68
|
refs/heads/master
| 2021-06-23T11:00:43.615062
| 2019-07-10T16:57:06
| 2019-07-10T16:57:06
| 145,669,246
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 10,530
|
py
|
# coding: utf-8
"""
Kubernetes
No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
OpenAPI spec version: v1.10.0
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
from pprint import pformat
from six import iteritems
import re
class V1DeleteOptions(object):
"""
NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
"""
"""
Attributes:
swagger_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
swagger_types = {
'api_version': 'str',
'grace_period_seconds': 'int',
'kind': 'str',
'orphan_dependents': 'bool',
'preconditions': 'V1Preconditions',
'propagation_policy': 'str'
}
attribute_map = {
'api_version': 'apiVersion',
'grace_period_seconds': 'gracePeriodSeconds',
'kind': 'kind',
'orphan_dependents': 'orphanDependents',
'preconditions': 'preconditions',
'propagation_policy': 'propagationPolicy'
}
def __init__(self, api_version=None, grace_period_seconds=None, kind=None, orphan_dependents=None, preconditions=None, propagation_policy=None):
"""
V1DeleteOptions - a model defined in Swagger
"""
self._api_version = None
self._grace_period_seconds = None
self._kind = None
self._orphan_dependents = None
self._preconditions = None
self._propagation_policy = None
self.discriminator = None
if api_version is not None:
self.api_version = api_version
if grace_period_seconds is not None:
self.grace_period_seconds = grace_period_seconds
if kind is not None:
self.kind = kind
if orphan_dependents is not None:
self.orphan_dependents = orphan_dependents
if preconditions is not None:
self.preconditions = preconditions
if propagation_policy is not None:
self.propagation_policy = propagation_policy
@property
def api_version(self):
"""
Gets the api_version of this V1DeleteOptions.
APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources
:return: The api_version of this V1DeleteOptions.
:rtype: str
"""
return self._api_version
@api_version.setter
def api_version(self, api_version):
"""
Sets the api_version of this V1DeleteOptions.
APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources
:param api_version: The api_version of this V1DeleteOptions.
:type: str
"""
self._api_version = api_version
@property
def grace_period_seconds(self):
"""
Gets the grace_period_seconds of this V1DeleteOptions.
The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
:return: The grace_period_seconds of this V1DeleteOptions.
:rtype: int
"""
return self._grace_period_seconds
@grace_period_seconds.setter
def grace_period_seconds(self, grace_period_seconds):
"""
Sets the grace_period_seconds of this V1DeleteOptions.
The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
:param grace_period_seconds: The grace_period_seconds of this V1DeleteOptions.
:type: int
"""
self._grace_period_seconds = grace_period_seconds
@property
def kind(self):
"""
Gets the kind of this V1DeleteOptions.
Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
:return: The kind of this V1DeleteOptions.
:rtype: str
"""
return self._kind
@kind.setter
def kind(self, kind):
"""
Sets the kind of this V1DeleteOptions.
Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
:param kind: The kind of this V1DeleteOptions.
:type: str
"""
self._kind = kind
@property
def orphan_dependents(self):
"""
Gets the orphan_dependents of this V1DeleteOptions.
Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
:return: The orphan_dependents of this V1DeleteOptions.
:rtype: bool
"""
return self._orphan_dependents
@orphan_dependents.setter
def orphan_dependents(self, orphan_dependents):
"""
Sets the orphan_dependents of this V1DeleteOptions.
Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
:param orphan_dependents: The orphan_dependents of this V1DeleteOptions.
:type: bool
"""
self._orphan_dependents = orphan_dependents
@property
def preconditions(self):
"""
Gets the preconditions of this V1DeleteOptions.
Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned.
:return: The preconditions of this V1DeleteOptions.
:rtype: V1Preconditions
"""
return self._preconditions
@preconditions.setter
def preconditions(self, preconditions):
"""
Sets the preconditions of this V1DeleteOptions.
Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned.
:param preconditions: The preconditions of this V1DeleteOptions.
:type: V1Preconditions
"""
self._preconditions = preconditions
@property
def propagation_policy(self):
"""
Gets the propagation_policy of this V1DeleteOptions.
Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
:return: The propagation_policy of this V1DeleteOptions.
:rtype: str
"""
return self._propagation_policy
@propagation_policy.setter
def propagation_policy(self, propagation_policy):
"""
Sets the propagation_policy of this V1DeleteOptions.
Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
:param propagation_policy: The propagation_policy of this V1DeleteOptions.
:type: str
"""
self._propagation_policy = propagation_policy
def to_dict(self):
"""
Returns the model properties as a dict
"""
result = {}
for attr, _ in iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
return result
def to_str(self):
"""
Returns the string representation of the model
"""
return pformat(self.to_dict())
def __repr__(self):
"""
For `print` and `pprint`
"""
return self.to_str()
def __eq__(self, other):
"""
Returns true if both objects are equal
"""
if not isinstance(other, V1DeleteOptions):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""
Returns true if both objects are not equal
"""
return not self == other
|
[
"root@kube-node02.local"
] |
root@kube-node02.local
|
5a1800a557704e33d4f51badeae781b4ae00bcca
|
c3a01f8bcece48f94a347b92694f90227708f507
|
/pyvisa/testsuite/test_constants.py
|
8c5add8034b3b0c9c0686b60af1742adea537ea8
|
[
"MIT"
] |
permissive
|
panlun/pyvisa
|
e16a6cdaae47bc69d932538f14c62015d17be7ab
|
124c46bd2ad89e49031339d6181255c2808fecbc
|
refs/heads/master
| 2022-11-21T13:07:29.280849
| 2020-06-24T22:23:27
| 2020-06-24T22:23:27
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 649
|
py
|
# -*- coding: utf-8 -*-
"""Test objects from constants.
This file is part of PyVISA.
:copyright: 2019-2020 by PyVISA Authors, see AUTHORS for more details.
:license: MIT, see LICENSE for more details.
"""
from pyvisa.constants import DataWidth
from . import BaseTestCase
class TestDataWidth(BaseTestCase):
def test_conversion_from_literal(self):
for v, e in zip(
(8, 16, 32, 64),
(DataWidth.bit_8, DataWidth.bit_16, DataWidth.bit_32, DataWidth.bit_64),
):
self.assertEqual(DataWidth.from_literal(v), e)
with self.assertRaises(ValueError):
DataWidth.from_literal(0)
|
[
"marul@laposte.net"
] |
marul@laposte.net
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.