blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
281
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
57
| license_type
stringclasses 2
values | repo_name
stringlengths 6
116
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 313
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 18.2k
668M
⌀ | star_events_count
int64 0
102k
| fork_events_count
int64 0
38.2k
| gha_license_id
stringclasses 17
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 107
values | src_encoding
stringclasses 20
values | language
stringclasses 1
value | is_vendor
bool 2
classes | is_generated
bool 2
classes | length_bytes
int64 4
6.02M
| extension
stringclasses 78
values | content
stringlengths 2
6.02M
| authors
listlengths 1
1
| author
stringlengths 0
175
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f0ee9e58c7029957af4366c984e9861db7dfc8e2
|
6ffed3351dd608ce311a7c04d813e4cbcc283d6f
|
/djongo_project/files/api/serializers.py
|
e0c2ca3d77901c61c0d12799e99a053ec5653fad
|
[] |
no_license
|
navill/ai_2-1
|
bc2311dd5e8839c6bd4112965b7348252408785a
|
7dd782b93286b7a407c433aa55a3b8f3f626fe89
|
refs/heads/master
| 2023-01-06T19:09:26.051130
| 2020-10-07T02:08:15
| 2020-10-07T02:08:15
| 290,131,119
| 0
| 0
| null | 2020-10-08T14:45:37
| 2020-08-25T06:20:46
|
Python
|
UTF-8
|
Python
| false
| false
| 1,396
|
py
|
from typing import *
from rest_framework import serializers
from rest_framework.reverse import reverse
from accounts.models import CommonUser
from utilities.file_utils import EncryptHandler
from files.models import CommonFile
class FileManageSerializer(serializers.ModelSerializer):
user = serializers.PrimaryKeyRelatedField(queryset=CommonUser.objects.all(), required=False)
patient_name = serializers.CharField(required=True)
file = serializers.FileField(use_url=False)
created_at = serializers.DateTimeField(read_only=True)
class Meta:
model = CommonFile
fields = ['user', 'patient_name', 'file', 'created_at']
read_only_fields = ['user']
def to_representation(self, instance: CommonFile) -> Dict:
ret = super().to_representation(instance)
encrypted_path = self._create_encrypted_path(str(instance.id))
encrypted_pull_url = reverse('files:download', args=[encrypted_path], request=self.context['request'])
ret['url'] = encrypted_pull_url
return ret
def create(self, validated_data: dict) -> CommonFile:
try:
file_obj = CommonFile.objects.create(**validated_data)
except Exception:
raise
return file_obj
def _create_encrypted_path(self, instance_id: str) -> str:
handler = EncryptHandler(instance_id)
return handler.encrypt()
|
[
"blue_jihoon@naver.com"
] |
blue_jihoon@naver.com
|
368d3a8e796916e2e6cadcf0e634c978a7ef2699
|
ae7ba9c83692cfcb39e95483d84610715930fe9e
|
/martinkersner/train-CRF-RNN/crfasrnn.py
|
472a86f853e687aa057de49dcc8aa8957733f63d
|
[] |
no_license
|
xenron/sandbox-github-clone
|
364721769ea0784fb82827b07196eaa32190126b
|
5eccdd8631f8bad78eb88bb89144972dbabc109c
|
refs/heads/master
| 2022-05-01T21:18:43.101664
| 2016-09-12T12:38:32
| 2016-09-12T12:38:32
| 65,951,766
| 5
| 7
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,462
|
py
|
#!/usr/bin/env python
# Martin Kersner, m.kersner@gmail.com
# 2016/03/03
from __future__ import print_function
caffe_root = '../caffe-crfrnn/'
import sys
sys.path.insert(0, caffe_root + 'python')
import os
import cPickle
import logging
import numpy as np
import pandas as pd
from PIL import Image as PILImage
import cStringIO as StringIO
import caffe
import matplotlib.pyplot as plt
from utils import palette_demo
# TODO concatenate input and output image
def main():
iteration, image_paths = process_arguments(sys.argv)
if iteration:
prototxt = 'TVG_CRFRNN_COCO_VOC_TEST_3_CLASSES.prototxt'
model = 'models/train_iter_{}.caffemodel'.format(iteration)
else:
prototxt = 'TVG_CRFRNN_COCO_VOC.prototxt'
model = 'TVG_CRFRNN_COCO_VOC.caffemodel'
if not exist_model(model, prototxt):
help()
# default images (part of http://www.cs.berkeley.edu/~bharath2/codes/SBD/download.html)
if not image_paths:
image_paths.append('images/2007_005844.png') # chair
image_paths.append('images/2008_007811.png') # bottle
image_paths.append('images/2007_002094.png') # bird
palette = palette_demo()
net = caffe.Segmenter(prototxt, model, True)
for path in image_paths:
image, cur_h, cur_w = preprocess_image(path)
if image == None:
print(path + ' does not exist! Skipping.' , file=sys.stderr)
continue
print('Processing ' + path + '...', end='')
segmentation = net.predict([image])
segm_post = postprocess_label(segmentation, cur_h, cur_w, palette)
plt.imshow(segm_post)
plt.savefig(create_label_name(path))
print('finished.')
def preprocess_image(image_path):
if not os.path.exists(image_path):
return None, 0, 0
input_image = 255 * caffe.io.load_image(image_path)
image = PILImage.fromarray(np.uint8(input_image))
image = np.array(image)
mean_vec = np.array([103.939, 116.779, 123.68], dtype=np.float32)
reshaped_mean_vec = mean_vec.reshape(1, 1, 3);
im = image[:,:,::-1]
im = im - reshaped_mean_vec
# Pad as necessary
cur_h, cur_w, cur_c = im.shape
pad_h = 500 - cur_h
pad_w = 500 - cur_w
im = np.pad(im, pad_width=((0, pad_h), (0, pad_w), (0, 0)), mode = 'constant', constant_values = 0)
return im, cur_h, cur_w
def postprocess_label(segmentation, cur_h, cur_w, palette):
segmentation2 = segmentation[0:cur_h, 0:cur_w]
output_im = PILImage.fromarray(segmentation2)
output_im.putpalette(palette)
return output_im
def create_label_name(orig_path):
return 'label_' + os.path.splitext(os.path.basename(orig_path))[0] + '.png'
def exist_model(model, prototxt):
if not os.path.exists(model):
print('Model ' + model + ' does not exist! Exiting.', file=sys.stderr)
return False
elif not os.path.exists(prototxt):
print('Prototxt' + prototxt + ' does not exist! Exiting.', file=sys.stderr)
return False
return True
def process_arguments(argv):
num_args = len(argv)
iteration = None
image_paths = []
if num_args == 2:
iteration = argv[1]
elif num_args > 2:
iteration = argv[1]
for name in argv[2:]:
image_paths.append(name)
return iteration, image_paths
def help():
print('Usage: python crfasrnn.py [ITERATION_NUM [IMAGE, IMAGE, ...]\n'
'ITERATION_NUM denotes iteration number of model which shall be run.\n'
'IMAGE one or more images can be passed as arguments.'
, file=sys.stderr)
exit()
if __name__ == '__main__':
main()
|
[
"xenron@outlook.com"
] |
xenron@outlook.com
|
98648afb1168eb37ec156f7995980e16668f754b
|
276be25104b8dd68aa45fb6bb5d0ff289dcad539
|
/testing/Belinda/app2.py
|
9602db1abe2ffd2f7da83ed45f26ed450721f7d9
|
[] |
no_license
|
CC196/Project-2
|
77ea2411607e84f9b75d55f1bfd0cd2b2240d553
|
fd3ca26703468443fec889e0e6e2d64dfd8214eb
|
refs/heads/main
| 2023-01-07T00:31:52.129842
| 2020-11-11T04:05:20
| 2020-11-11T04:05:20
| 302,524,477
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 4,321
|
py
|
import numpy as np
import sqlalchemy
from sqlalchemy.ext.automap import automap_base
from sqlalchemy.orm import Session
from sqlalchemy import create_engine, func
from flask import Flask, jsonify
# from flask_cors import CORS
#################################################
# Database Setup
#################################################
engine = create_engine("sqlite:///D:/Course_work/Project2/Project-2/Resources/Spotify.sqlite")
# reflect an existing database into a new model
Base = automap_base()
# reflect the tables
Base.prepare(engine, reflect=True)
# Save reference to the table
Top_fifty = Base.classes.top50_detail
All_year_top = Base.classes.top50_2019
world = Base.classes.SpotifyTopSongsByCountry
#################################################
# Flask Setup
#################################################
app = Flask(__name__)
# cors = CORS(app)
#################################################
# Flask Routes
#################################################
@app.route("/")
def welcome():
"""List all available api routes."""
return (
f"Available Routes:<br/>"
f"/api/v1.0/top_50_2020_May<br/>"
f"/api/v1.0/top_50_2019<br>"
f"/api/v1.0/top50_country_2020_May"
)
@app.route("/api/v1.0/top_50_2020_May")
def May():
session = Session(engine)
results = session.query(Top_fifty.Title, Top_fifty.popularity,Top_fifty.acousticness,Top_fifty.danceability,Top_fifty.energy, Top_fifty.instrumentalness,Top_fifty.loudness,Top_fifty.speechiness,Top_fifty.valence, Top_fifty.tempo).all()
session.close()
all_song = []
count = 1
for Title,popularity,acousticness,danceability,energy,instrumentalness, loudness, speechiness, valence, tempo in results:
if Title:
song_detail = {}
song_detail["Title"] = Title
song_detail["popularity"] = popularity
song_detail["acousticness"] = acousticness
song_detail["danceability"] = danceability
song_detail["energy"] = energy
song_detail["instrumentalness"] = instrumentalness
song_detail["loudness"] = loudness
song_detail["speechiness"] = speechiness
song_detail["valence"] = valence
song_detail["tempo"] = tempo
song_detail["rank_in_May"] = count
count+=1
all_song.append(song_detail)
return jsonify(all_song)
@app.route("/api/v1.0/top_50_2019")
def all_year():
session = Session(engine)
result = session.query(All_year_top.Title, All_year_top.Popularity,All_year_top.Acousticness,All_year_top.Danceability,All_year_top.Energy, All_year_top.Liveness,All_year_top.Loudness,All_year_top.Speechiness,All_year_top.Valence, All_year_top.BPM, All_year_top.Rank).all()
session.close()
all_song = []
for Title,popularity,acousticness,danceability,energy,liveness, loudness, speechiness, valence, BPM, rank in result:
if Title:
song_detail = {}
song_detail["Title"] = Title
song_detail["popularity"] = popularity
song_detail["acousticness"] = acousticness
song_detail["danceability"] = danceability
song_detail["energy"] = energy
song_detail["liveness"] = liveness
song_detail["loudness"] = loudness
song_detail["speechiness"] = speechiness
song_detail["valence"] = valence
song_detail["BPM"] = BPM
song_detail["Rank"] = rank
all_song.append(song_detail)
return jsonify(all_song)
@app.route("/api/v1.0/top50_country_2020_May")
def world_May():
session = Session(engine)
world_top = session.query(world.Country, world.Rank, world.Title, world.Artists, world.Album).all()
session.close()
all_world = []
country_rank = {}
for country, rank, title, artists, album in world_top:
if country not in country_rank:
country_rank[country] = []
song_detail = {}
song_detail["Rank"] = rank
song_detail["Title"] = title
song_detail["Artists"] = artists
song_detail["Album"] = album
country_rank[country].append(song_detail)
all_world.append(country_rank)
return jsonify(all_world)
if __name__ == '__main__':
app.run(debug=True)
|
[
"qinqin.zha@gmail.com"
] |
qinqin.zha@gmail.com
|
4e99a7acd3bcf8e67dc4a408c2fc47b15569d91a
|
72f59717e1e878005e31281c0fd09a4cf0c2f69b
|
/github_2fa.py
|
d85ef49c971ea1ac160bd894b11286db624b60cc
|
[] |
no_license
|
daguy666/api
|
7627daf8f195d97119277c9e3fb219f1e93aeda7
|
c2097813564b63d4034d2f64d0ae3aeea9a220b8
|
refs/heads/master
| 2020-04-21T11:55:46.153919
| 2014-11-06T19:34:04
| 2014-11-06T19:34:04
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 893
|
py
|
#!/usr/bin/env python
#
#github_2fa.py
#This will detect users who are in a specified
#org that have 2fa disabled
############################################
import json
import urllib2
import getpass
import sys
pw = getpass.getpass("Please enter a token: ")
org = raw_input("Org to search: ")
org_url = "https://api.github.com/orgs/%s/members?&filter=2fa_disabled&access_token=%s" % (org, pw)
try:
request = urllib2.Request(org_url)
result = urllib2.urlopen(request)
except urllib2.HTTPError, e:
if e.code == 400:
print "Bad Request"
elif e.code == 401:
print "Invalid Password"
elif e.code == 404:
print "Invalid org"
else:
print "Call to API failed.", e
sys.exit(1)
twofa_json = json.load(result)
print "Users in the %s Org that do not have two factor auth enabled: " % org
for entry in twofa_json:
print entry['login']
|
[
"jpistonejr@gmail.com"
] |
jpistonejr@gmail.com
|
039ddde1464386c3829683361c65b4dcf614072b
|
fe5eb98a1fa9a1bd194e7d859fddc9fc62ed842e
|
/modified_2/run_both_multi.py
|
a58183743d8e5d737bc79c5f36c4bae074557f77
|
[] |
no_license
|
TaehoLi/Capstone
|
862d27a819c455fcfa8da598a976d3bf1e9c9570
|
9329d7910c24d32b04598f373899819694f856e4
|
refs/heads/master
| 2020-04-18T08:11:52.207623
| 2019-12-26T12:04:32
| 2019-12-26T12:04:32
| 167,387,971
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 15,279
|
py
|
# -*- coding: utf-8 -*-
import argparse
import logging
import time
import cv2
import numpy as np
import matplotlib.pyplot as plt
#matplotlib auto
from tf_pose.estimator import TfPoseEstimator
from tf_pose.networks import get_graph_path, model_wh
from datetime import datetime
logger1 = logging.getLogger('TfPoseEstimator-WebCam')
logger1.setLevel(logging.DEBUG)
ch1 = logging.StreamHandler()
ch1.setLevel(logging.DEBUG)
formatter1 = logging.Formatter('[%(asctime)s] [%(name)s] [%(levelname)s] %(message)s')
ch1.setFormatter(formatter1)
logger1.addHandler(ch1)
logger2 = logging.getLogger('TfPoseEstimator-Video')
logger2.setLevel(logging.DEBUG)
ch2 = logging.StreamHandler()
ch2.setLevel(logging.DEBUG)
formatter2 = logging.Formatter('[%(asctime)s] [%(name)s] [%(levelname)s] %(message)s')
ch2.setFormatter(formatter2)
logger2.addHandler(ch2)
fps_time = 0
# codec
fourcc = cv2.VideoWriter_fourcc(*'XVID')
# VideoWriter object
# video resolution should be 640x480(must be same)
#out1 = cv2.VideoWriter('./data/output3.avi', fourcc, 20.0, (640,480))
#out2 = cv2.VideoWriter('./data/output4.avi', fourcc, 20.0, (640,480))
### 1:Webcam / 2:Video
if __name__ == '__main__':
# 1
parser1 = argparse.ArgumentParser(description='tf-pose-estimation realtime webcam')
parser1.add_argument('--camera', type=int, default=0)
parser1.add_argument('--resize', type=str, default='432x368',
help='if provided, resize images before they are processed. default=0x0, Recommends : 432x368 or 656x368 or 1312x736 ')
parser1.add_argument('--resize-out-ratio', type=float, default=4.0,
help='if provided, resize heatmaps before they are post-processed. default=1.0')
parser1.add_argument('--model', type=str, default='mobilenet_thin', help='cmu / mobilenet_thin / mobilenet_v2_large / mobilenet_v2_small')
parser1.add_argument('--show-process', type=bool, default=False,
help='for debug purpose, if enabled, speed for inference is dropped.')
parser1.add_argument('--video', type=str, default=None)
# 2
parser2 = argparse.ArgumentParser(description='tf-pose-estimation Video')
parser2.add_argument('--camera', type=int, default=None)
parser2.add_argument('--video', type=str, default='')
parser2.add_argument('--resize', type=str, default='432x368',
help='if provided, resize images before they are processed. default=0x0, Recommends : 432x368 or 656x368 or 1312x736 ')
parser2.add_argument('--resize-out-ratio', type=float, default=4.0,
help='if provided, resize heatmaps before they are post-processed. default=1.0')
parser2.add_argument('--model', type=str, default='mobilenet_thin', help='cmu / mobilenet_thin / mobilenet_v2_large / mobilenet_v2_small')
parser2.add_argument('--show-process', type=bool, default=False,
help='for debug purpose, if enabled, speed for inference is dropped.')
parser2.add_argument('--showBG', type=bool, default=True, help='False to show skeleton only.')
args1 = parser1.parse_args()
args2 = parser2.parse_args()
logger1.debug('initialization %s : %s' % (args1.model, get_graph_path(args1.model)))
logger2.debug('initialization %s : %s' % (args2.model, get_graph_path(args2.model)))
w1, h1 = model_wh(args1.resize)
w2, h2 = model_wh(args2.resize)
if w1 > 0 and h1 > 0:
e1 = TfPoseEstimator(get_graph_path(args1.model), target_size=(w1, h1))
else:
e1 = TfPoseEstimator(get_graph_path(args1.model), target_size=(432, 368))
if w2 > 0 and h2 > 0:
e2 = TfPoseEstimator(get_graph_path(args2.model), target_size=(w2, h2))
else:
e2 = TfPoseEstimator(get_graph_path(args2.model), target_size=(432, 368))
cap1 = cv2.VideoCapture(args1.camera)
cap2 = cv2.VideoCapture(args2.video)
if cap2.isOpened() is False:
print("Error opening video stream or file")
# data plotting
lstX = []
lstY1 = []
lstY2 = []
threshold = 0.55 # have to change
plt.ion()
fig1 = plt.figure(num='real-time plotting1')
sf1 = fig1.add_subplot(111)
plt.title('Upper Body')
plt.xticks([0, 1500000, 3000000, 4500000, 6000000])
plt.yticks([0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0])
plt.axhline(y=threshold, color='r', linestyle='--', linewidth=2)
line1, = sf1.plot([0, 6000000], [0,1], 'b-')
fig2 = plt.figure(num='real-time plotting2')
sf2 = fig2.add_subplot(111)
plt.title('Lower Body')
plt.xticks([0, 1500000, 3000000, 4500000, 6000000])
plt.yticks([0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0])
plt.axhline(y=threshold, color='r', linestyle='--', linewidth=2)
line2, = sf2.plot([0, 6000000], [0,1], 'b-')
while cap2.isOpened(): # loop
try:
ret_val1, image1 = cap1.read()
ret_val2, image2 = cap2.read()
logger1.debug('image process+')
humans1 = e1.inference(image1, resize_to_default=(w1 > 0 and h1 > 0), upsample_size=args1.resize_out_ratio)
logger2.debug('image process+')
humans2 = e2.inference(image2, resize_to_default=(w2 > 0 and h2 > 0), upsample_size=args2.resize_out_ratio)
### 2:Video) if(--showBG=False) print skeleton
if not args2.showBG:
image2 = np.zeros(image2.shape)
###
logger1.debug('postprocess+')
a = TfPoseEstimator.get_centers(image1, humans1, imgcopy=False) #all points
image1 = TfPoseEstimator.draw_humans(image1, humans1, imgcopy=False)
logger2.debug('postprocess+')
b = TfPoseEstimator.get_centers(image2, humans2, imgcopy=False) #상체 points
c = TfPoseEstimator.get_centers(image2, humans2, imgcopy=False) #하체 points
image2 = TfPoseEstimator.draw_humans(image2, humans2, imgcopy=False)
"""
1) 실시간으로 동영상의 점을 불러온다 (점의 좌표를 알아야함)
2) 실시간으로 웹캠의 점을 불러온다 (점의 좌표를 알아야함)
3) 점 간의 norm(거리)을 구한다 (scalar)
4) 예를 들어 점이 18개로 고정되어 있다면 각 pair점 간의 norm을 전부 구하고
5) sum 하여 그 값을 0과 1사이로 normalization 한다 ->result
6) result를 y축 time을 x축으로 실시간 데이터 plotting
7) result가 어떤 threshold를 넘어설때 마다 warning을 cv2.putText로 출력해준다.
"""
if 0 in b:
del b[0]
if 14 in b:
del b[14]
if 15 in b:
del b[15]
if 16 in b:
del b[16]
if 17 in b:
del b[17] # 눈, 코, 귀 points 제외
if 0 in c:
del c[0]
if 14 in c:
del c[14]
if 15 in c:
del c[15]
if 16 in c:
del c[16]
if 17 in c:
del c[17] # 눈, 코, 귀 points 제외
if 8 in b:
del b[8]
if 9 in b:
del b[9]
if 10 in b:
del b[10]
if 11 in b:
del b[11]
if 12 in b:
del b[12]
if 13 in b:
del b[13] #하체 points 제외
if 1 in c:
del c[1]
if 2 in c:
del c[2]
if 3 in c:
del c[3]
if 4 in c:
del c[4]
if 5 in c:
del c[5]
if 6 in c:
del c[6]
if 7 in c:
del c[7] #상체 points 제외
L2_norm1 = [] #상체
L2_norm2 = [] #하체
L2_nonzero1 = []
L2_nonzero2 = []
for i in range(18):
try:
L2_norm1.append(np.linalg.norm(np.array(a[i])-np.array(b[i]), ord=2))
except:
L2_norm1.append(0.0)
pass
if L2_norm1[i] is not 0.0:
L2_nonzero1.append(L2_norm1[i])
else:
pass
for i in range(18):
try:
L2_norm2.append(np.linalg.norm(np.array(a[i])-np.array(c[i]), ord=2))
except:
L2_norm2.append(0.0)
pass
if L2_norm2[i] is not 0.0:
L2_nonzero2.append(L2_norm2[i])
else:
pass
normalize1 = []
normalize2 = []
if len(L2_nonzero1) is 0:
normalize1.append(0.0)
elif len(L2_nonzero1) is 1:
normalize1.append(0.0)
elif len(L2_nonzero1) is 2:
normalize1.append(0.0)
else:
for i in range(len(L2_nonzero1)):
normalize1.append((L2_nonzero1[i]-min(L2_nonzero1))/(max(L2_nonzero1)-min(L2_nonzero1)))
result1 = np.sum(normalize1)/len(normalize1)
if len(L2_nonzero2) == 0:
normalize2.append(0.0)
elif len(L2_nonzero2) == 1:
normalize2.append(0.0)
elif len(L2_nonzero2) is 2:
normalize2.append(0.0)
else:
for i in range(len(L2_nonzero2)):
normalize2.append((L2_nonzero2[i]-min(L2_nonzero2))/(max(L2_nonzero2)-min(L2_nonzero2)))
result2 = np.sum(normalize2)/len(normalize2)
c = datetime.now()
d = c.strftime('%S%f')
d = np.float32(d) / 10.0
lstX.append(d)
lstY1.append(result1)
lstY2.append(result2)
print("Data point:", result1, result2)
if d > 5900000: # 1분마다 플롯 초기화
fig1.clf()
fig1 = plt.figure(num='real-time plotting1')
sf1 = fig1.add_subplot(111)
plt.title('Upper Body')
plt.xticks([0, 1500000, 3000000, 4500000, 6000000])
plt.yticks([0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0])
plt.axhline(y=threshold, color='r', linestyle='--', linewidth=2)
lstX=[]
lstY1=[]
line1, = sf1.plot([0, 6000000], [0,1], 'b-')
line1.set_data(lstX, lstY1)
fig2.clf()
fig2 = plt.figure(num='real-time plotting2')
sf2 = fig2.add_subplot(111)
plt.title('Lower Body')
plt.xticks([0, 1500000, 3000000, 4500000, 6000000])
plt.yticks([0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0])
plt.axhline(y=threshold, color='r', linestyle='--', linewidth=2)
lstY2=[]
line2, = sf2.plot([0, 6000000], [0,1], 'b-')
line2.set_data(lstX, lstY2)
else:
line1.set_data(lstX, lstY1)
line2.set_data(lstX, lstY2)
plt.show()
plt.pause(0.0001)
# 임계치 조정
if result1 > threshold and result2 > threshold:
#logger1.debug('show+')
#logger2.debug('show+')
cv2.putText(image1, "FPS: %f" % (1.0 / (time.time() - fps_time)),
(10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.putText(image2, "FPS: %f" % (1.0 / (time.time() - fps_time)),
(10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.putText(image1, "Wrong Pose", (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 2.35, (0,0,255), 5)
cv2.imshow('tf-pose-estimation Webcam', image1)
cv2.imshow('tf-pose-estimation Video', image2)
## 이미지를 파일에 저장, VideoWriter 객체에 연속적으로 저장하면 동영상이 됨.
#out1.write(image1)
#out2.write(image2)
fps_time = time.time()
elif result1 > threshold:
cv2.putText(image1, "FPS: %f" % (1.0 / (time.time() - fps_time)),
(10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.putText(image2, "FPS: %f" % (1.0 / (time.time() - fps_time)),
(10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.putText(image1, "Mind Upper", (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 2.35, (0,0,255), 5)
cv2.imshow('tf-pose-estimation Webcam', image1)
cv2.imshow('tf-pose-estimation Video', image2)
## 이미지를 파일에 저장, VideoWriter 객체에 연속적으로 저장하면 동영상이 됨.
#out1.write(image1)
#out2.write(image2)
fps_time = time.time()
elif result2 > threshold:
cv2.putText(image1, "FPS: %f" % (1.0 / (time.time() - fps_time)),
(10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.putText(image2, "FPS: %f" % (1.0 / (time.time() - fps_time)),
(10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.putText(image1, "Mind Lower", (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 2.35, (0,0,255), 5)
cv2.imshow('tf-pose-estimation Webcam', image1)
cv2.imshow('tf-pose-estimation Video', image2)
## 이미지를 파일에 저장, VideoWriter 객체에 연속적으로 저장하면 동영상이 됨.
#out1.write(image1)
#out2.write(image2)
fps_time = time.time()
else:
#logger1.debug('show+')
#logger2.debug('show+')
cv2.putText(image1, "FPS: %f" % (1.0 / (time.time() - fps_time)),
(10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.putText(image2, "FPS: %f" % (1.0 / (time.time() - fps_time)),
(10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.imshow('tf-pose-estimation Webcam', image1)
cv2.imshow('tf-pose-estimation Video', image2)
## 이미지를 파일에 저장, VideoWriter 객체에 연속적으로 저장하면 동영상이 됨.
#out1.write(image1)
#out2.write(image2)
fps_time = time.time()
if cv2.waitKey(1) == 27: #ESC
break #종료
except:
print("video is over")
break
while True:
if cv2.waitKey(1) & 0xFF == ord('q'): # press Q to destroy all windows
cv2.destroyAllWindows()
break
#cv2.destroyAllWindows()
logger1.debug('finished+')
logger2.debug('finished+')
|
[
"noreply@github.com"
] |
noreply@github.com
|
ad4994ace4456aa5f10d59b2268f5651f648d5f9
|
7af39ee40bd4df79ddf094fd3ecf59bedaed869f
|
/app.py
|
36affbfd05a1657139bb3b9f094c438c9e7234f9
|
[] |
no_license
|
LeoKavanagh/sleepui
|
0b35def13c2f794c29a9c9ad1efeee45aed956ff
|
cf8c862c84283126538a32d8fbf25635fa32aa33
|
refs/heads/master
| 2020-04-04T17:32:45.594262
| 2018-11-05T22:07:37
| 2018-11-05T22:07:37
| 156,125,022
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,701
|
py
|
from flask import Flask, request, render_template, url_for, redirect
import datetime as dt
app = Flask(__name__)
# Database lol
today = dt.date.today().strftime('%Y-%m-%d')
latest_pred = []
def deep_sleep_pct(steps, mean_rate, sd_rate, dsp_lag):
# fitbit - Sleep as Android adjustment
dsp_lag /= 3
b0 = -0.0343
b1 = 0.00
b2 = 0.0039
b3 = -0.0006 # coef for (max - min)
b4 = 0.2012
return b0 + b2 * mean_rate + b3 * sd_rate + b4 * dsp_lag
def log_prediction(pred):
latest_pred.append(pred)
@app.route('/')
@app.route('/index')
def index():
return render_template('index.html', latest_pred=latest_pred)
@app.route('/predict', methods=['GET', 'POST'])
def predict():
if request.method == 'POST':
data = request.form.to_dict()
pred = deep_sleep_pct(float(data['steps']),
float(data['mean_rate']),
float(data['sd_rate']),
float(data['dsp_lag']))
data['pred'] = pred
# Log to the 'database' so that we can show something in the if statement
# in the index.html template
log_prediction(pred)
return render_template('show_prediction.html',
today=today,
steps=float(data['steps']),
mean_rate=float(data['mean_rate']),
sd_rate=float(data['sd_rate']),
dsp_lag=float(data['dsp_lag']),
pred=float(data['pred']))
return render_template('input_data.html')
if __name__ == '__main__':
app.run(debug=True)
|
[
"leok90@gmail.com"
] |
leok90@gmail.com
|
fac531e71a08fa0485440c9f6fbb7d75d2bf50fd
|
2befe3929950fd5d6257ed6b1f1fd5751995f22f
|
/solutions/merge_sort.py
|
15489c9446b82baca70e9ed35dda41108dc2a0c8
|
[] |
no_license
|
redpanda-ai/ctci
|
a493abda7d95639ab785199ac77dfdcf529a1dd6
|
a621b25b55c749a678577fad4658b0b9171f889f
|
refs/heads/master
| 2021-07-09T18:26:17.193734
| 2020-09-26T04:02:20
| 2020-09-26T04:02:20
| 200,296,580
| 2
| 1
| null | 2023-09-14T00:36:51
| 2019-08-02T20:52:51
|
Python
|
UTF-8
|
Python
| false
| false
| 909
|
py
|
def merge_sort(arr):
if len(arr) > 1:
mid = len(arr) // 2
l_arr = arr[:mid]
r_arr = arr[mid:]
merge_sort(l_arr)
merge_sort(r_arr)
i = j = k = 0
while i < len(l_arr) and j < len(r_arr):
if l_arr[i] < r_arr[j]:
arr[k] = l_arr[i]
i += 1
else:
arr[k] = r_arr[j]
j += 1
k += 1
while i < len(l_arr):
arr[k] = l_arr[i]
i += 1
k += 1
while j < len(r_arr):
arr[k] = r_arr[j]
j += 1
k += 1
if __name__ == "__main__":
tests = [
[2, 1, 3, 5, 4, 7],
[2],
[],
[1, 1, 2, 1, 1, 1],
[7, 6, 5, 4, 3, 2, 1]
]
for test in tests:
print(f"\nInput: {test}")
merge_sort(test)
print(f"Output: {test}")
|
[
"joeandrewkey@gmail.com"
] |
joeandrewkey@gmail.com
|
d2d223dd5e9968b7af2c5e4232ccc82f887bf845
|
d3709ef033ddf881449c515936b448370a2625ee
|
/leetcode/058.Length of Last Word/common.py
|
58b6c30db0277230261076d8bd602b61eac1e818
|
[] |
no_license
|
xjhuang1993/PythonExercise
|
e7d7b12497986798184fa78a4e44764961237a56
|
444db0876295ee2dca2bd2c6103eb5fca4d643be
|
refs/heads/master
| 2020-03-19T01:03:26.988279
| 2018-06-06T01:53:35
| 2018-06-06T01:53:35
| 135,518,973
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 224
|
py
|
"""
Accepted
"""
def func(s):
if not s:
return 0
result_list = s.strip().split(" ")
result = len(result_list[-1])
return result
if __name__ == "__main__":
s = "Hello World"
print(func(s))
|
[
"398478432@qq.com"
] |
398478432@qq.com
|
71ca8542c4f7c61d9328341ec14b583e4d30c82d
|
e4920c4fe4290bde524e0c141189f80fddfe44b7
|
/info/migrations/0023_remove_message_recaptcha.py
|
85b4c72c01e9b2dc98df1f027f92d51e1b879720
|
[] |
no_license
|
ShahadatShuvo/Django_portfolio
|
42af2b0aa686bff08730cdb105f95d6b63adb620
|
795ed7cbb6444245af08582ea63f57a0f32679a0
|
refs/heads/master
| 2023-05-30T01:43:50.409584
| 2021-06-14T08:29:18
| 2021-06-14T08:29:18
| 376,372,632
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 330
|
py
|
# Generated by Django 2.2.16 on 2020-12-22 17:04
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('info', '0022_auto_20201222_1655'),
]
operations = [
migrations.RemoveField(
model_name='message',
name='recaptcha',
),
]
|
[
"shahadat@baiust.edu.bd"
] |
shahadat@baiust.edu.bd
|
97a9d2f3330873200fc4325d845a1d95fc6e784d
|
6a1fad01f41de94587c03c3904eaf087610a7422
|
/train.py
|
7499035720d29fae46c0d72b467b0cdca3c9fc9f
|
[] |
no_license
|
acids-ircam/ddsp_pytorch
|
1972c98f3d709d97df3606ef7f55cd724ac40c76
|
aaaf17d939ffbf7e6e4c848994204d07d62721a1
|
refs/heads/master
| 2021-12-12T00:48:31.743973
| 2021-09-07T07:46:51
| 2021-09-07T07:46:51
| 213,240,778
| 381
| 49
| null | 2021-11-26T21:18:46
| 2019-10-06T20:42:51
|
C
|
UTF-8
|
Python
| false
| false
| 3,338
|
py
|
import torch
from torch.utils.tensorboard import SummaryWriter
import yaml
from ddsp.model import DDSP
from effortless_config import Config
from os import path
from preprocess import Dataset
from tqdm import tqdm
from ddsp.core import multiscale_fft, safe_log, mean_std_loudness
import soundfile as sf
from einops import rearrange
from ddsp.utils import get_scheduler
import numpy as np
class args(Config):
CONFIG = "config.yaml"
NAME = "debug"
ROOT = "runs"
STEPS = 500000
BATCH = 16
START_LR = 1e-3
STOP_LR = 1e-4
DECAY_OVER = 400000
args.parse_args()
with open(args.CONFIG, "r") as config:
config = yaml.safe_load(config)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = DDSP(**config["model"]).to(device)
dataset = Dataset(config["preprocess"]["out_dir"])
dataloader = torch.utils.data.DataLoader(
dataset,
args.BATCH,
True,
drop_last=True,
)
mean_loudness, std_loudness = mean_std_loudness(dataloader)
config["data"]["mean_loudness"] = mean_loudness
config["data"]["std_loudness"] = std_loudness
writer = SummaryWriter(path.join(args.ROOT, args.NAME), flush_secs=20)
with open(path.join(args.ROOT, args.NAME, "config.yaml"), "w") as out_config:
yaml.safe_dump(config, out_config)
opt = torch.optim.Adam(model.parameters(), lr=args.START_LR)
schedule = get_scheduler(
len(dataloader),
args.START_LR,
args.STOP_LR,
args.DECAY_OVER,
)
# scheduler = torch.optim.lr_scheduler.LambdaLR(opt, schedule)
best_loss = float("inf")
mean_loss = 0
n_element = 0
step = 0
epochs = int(np.ceil(args.STEPS / len(dataloader)))
for e in tqdm(range(epochs)):
for s, p, l in dataloader:
s = s.to(device)
p = p.unsqueeze(-1).to(device)
l = l.unsqueeze(-1).to(device)
l = (l - mean_loudness) / std_loudness
y = model(p, l).squeeze(-1)
ori_stft = multiscale_fft(
s,
config["train"]["scales"],
config["train"]["overlap"],
)
rec_stft = multiscale_fft(
y,
config["train"]["scales"],
config["train"]["overlap"],
)
loss = 0
for s_x, s_y in zip(ori_stft, rec_stft):
lin_loss = (s_x - s_y).abs().mean()
log_loss = (safe_log(s_x) - safe_log(s_y)).abs().mean()
loss = loss + lin_loss + log_loss
opt.zero_grad()
loss.backward()
opt.step()
writer.add_scalar("loss", loss.item(), step)
step += 1
n_element += 1
mean_loss += (loss.item() - mean_loss) / n_element
if not e % 10:
writer.add_scalar("lr", schedule(e), e)
writer.add_scalar("reverb_decay", model.reverb.decay.item(), e)
writer.add_scalar("reverb_wet", model.reverb.wet.item(), e)
# scheduler.step()
if mean_loss < best_loss:
best_loss = mean_loss
torch.save(
model.state_dict(),
path.join(args.ROOT, args.NAME, "state.pth"),
)
mean_loss = 0
n_element = 0
audio = torch.cat([s, y], -1).reshape(-1).detach().cpu().numpy()
sf.write(
path.join(args.ROOT, args.NAME, f"eval_{e:06d}.wav"),
audio,
config["preprocess"]["sampling_rate"],
)
|
[
"caillon@ircam.fr"
] |
caillon@ircam.fr
|
59f182eac7ff61fa54275583dd65186678b519c5
|
ef34e68712fb4aa9a1320c4e1e370a24de34fcb4
|
/nlu/utils/environment/authentication.py
|
31b46bde24d6ece7e8670f0fe028b52bcba4a11a
|
[
"Apache-2.0"
] |
permissive
|
milyiyo/nlu
|
dd656e77eedf2c831482edfd4ec59490b25d3954
|
d209ed11c6a84639c268f08435552248391c5573
|
refs/heads/master
| 2023-08-16T00:03:10.326392
| 2021-10-16T03:05:49
| 2021-10-16T03:05:49
| 414,223,627
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,823
|
py
|
from nlu.utils.environment.env_utils import *
def install_and_import_healthcare(JSL_SECRET):
""" Install Spark-NLP-Healthcare PyPI Package in current enviroment if it cannot be imported and liscense provided"""
import importlib
try:
importlib.import_module('sparknlp_jsl')
except ImportError:
import pip
print("Spark NLP Healthcare could not be imported. Installing latest spark-nlp-jsl PyPI package via pip...")
hc_version = JSL_SECRET.split('-')[0]
import pyspark
pip_major_version = int(pip.__version__.split('.')[0])
if pip_major_version in [10, 18, 19, 20]:
# for these versions pip module does not support installing, we install via OS command.
os.system(
f'pip install spark-nlp-jsl=={hc_version} --extra-index-url https://pypi.johnsnowlabs.com/{JSL_SECRET}')
else:
pip.main(['install', f'spark-nlp-jsl=={hc_version}', '--extra-index-url',
f'https://pypi.johnsnowlabs.com/{JSL_SECRET}'])
finally:
import site
from importlib import reload
reload(site)
globals()['sparknlp_jsl'] = importlib.import_module('sparknlp_jsl')
def authenticate_enviroment(SPARK_NLP_LICENSE, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY):
"""Set Secret environ variables for Spark Context"""
os.environ['SPARK_NLP_LICENSE'] = SPARK_NLP_LICENSE
os.environ['AWS_ACCESS_KEY_ID'] = AWS_ACCESS_KEY_ID
os.environ['AWS_SECRET_ACCESS_KEY'] = AWS_SECRET_ACCESS_KEY
def get_authenticated_spark(SPARK_NLP_LICENSE, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, JSL_SECRET, gpu=False, ):
"""
Authenticates enviroment if not already done so and returns Spark Context with Healthcare Jar loaded
0. If no Spark-NLP-Healthcare, install it via PyPi
1. If not auth, run authenticate_enviroment()
"""
import sparknlp
authenticate_enviroment(SPARK_NLP_LICENSE, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)
install_and_import_healthcare(JSL_SECRET)
import sparknlp_jsl
if is_env_pyspark_2_3(): return sparknlp_jsl.start(JSL_SECRET, spark23=True, gpu=gpu)
if is_env_pyspark_2_4(): return sparknlp_jsl.start(JSL_SECRET, spark24=True, gpu=gpu)
if is_env_pyspark_3_0() or is_env_pyspark_3_1():
return sparknlp_jsl.start(JSL_SECRET, gpu=gpu, public=sparknlp.version())
print(f"Current Spark version {get_pyspark_version()} not supported!")
raise ValueError
def is_authorized_enviroment():
"""Check if auth secrets are set in enviroment"""
SPARK_NLP_LICENSE = os.getenv('SPARK_NLP_LICENSE')
AWS_ACCESS_KEY_ID = os.getenv('AWS_ACCESS_KEY_ID')
AWS_SECRET_ACCESS_KEY = os.getenv('AWS_SECRET_ACCESS_KEY')
return None not in [SPARK_NLP_LICENSE, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY]
|
[
"christian.kasim.loan@gmail.com"
] |
christian.kasim.loan@gmail.com
|
b483194ef410722c853543abfba98d1e36b2fa5b
|
1c2ae618653041b4dc739ad550f1749f2f5eeb81
|
/James-Script/Discovery/smtp-enum.py
|
cd88f4eb98a9ea6388fd0b7210f6882883b2a028
|
[] |
no_license
|
ubriggsl/OSEC-PWK
|
b50a5b1c8902fafb217d6766a960de90008d0af4
|
64c2dc943fde87457b835c98c6d409689d20bf3c
|
refs/heads/master
| 2021-01-20T00:08:29.484029
| 2017-05-15T02:33:14
| 2017-05-15T02:33:14
| 89,084,644
| 2
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 459
|
py
|
#!/usr/bin/python
import argparse
import socket
import sys
a = argparse.ArgumentParser()
a.add_argument('user')
a.add_argument('target')
a.add_argument('-p',dest='port',default='25')
args = a.parse_args()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
connect = s.connect((args.target,int(args.port)))
banner = s.recv(1024)
print banner
s.send('VRFY '+ args.user + '\r\n')
result = s.recv(1024)
print result
except:
pass
s.close()
|
[
"james@briggsconsulting.com"
] |
james@briggsconsulting.com
|
9e7202b2d72c068da23e38e2765dd64abbe128ce
|
52953b88fd65e64d13c0b8ebeae5d468305c01ea
|
/schema.py
|
cc90f9184c3d88b61fbb852d2641f19a86a0a955
|
[] |
no_license
|
antdood/EmojiCounter
|
ed77a77d032bda93e4f4cffc1145a5f74d90d7d3
|
e3aace43cf7da57eb57f9603ab9c8d2c28762310
|
refs/heads/main
| 2023-03-28T16:26:11.846775
| 2021-04-10T23:59:08
| 2021-04-10T23:59:08
| 350,259,821
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 151
|
py
|
CREATE TABLE emoji_usages
(
channel BIGINT UNSIGNED,
user BIGINT UNSIGNED,
emoji VARCHAR(255),
type ENUM('original', 'custom'),
time TIMESTAMP
);
|
[
"antawck@gmail.com"
] |
antawck@gmail.com
|
1c81bdca5dc92eada6417d4615dab19cc148a555
|
1f61e06271f8e9582669686457c40336235d1eee
|
/Module 1/Chapter 9/edge_detector.py
|
a7221300b04f62e04e673c71daddfa906d6eaed5
|
[
"MIT"
] |
permissive
|
PacktPublishing/Python-Real-World-Machine-Learning
|
f1747fdd73937544a243059ac7476bfbfac6d113
|
669e793cf80c35b6d2028f74bff2cd87b9458791
|
refs/heads/master
| 2023-04-13T11:48:13.459731
| 2023-01-30T09:21:10
| 2023-01-30T09:21:10
| 70,907,139
| 108
| 111
|
MIT
| 2023-04-04T14:38:41
| 2016-10-14T12:13:47
|
Jupyter Notebook
|
UTF-8
|
Python
| false
| false
| 598
|
py
|
import sys
import cv2
import numpy as np
# Load the input image -- 'chair.jpg'
# Convert it to grayscale
input_file = sys.argv[1]
img = cv2.imread(input_file, cv2.IMREAD_GRAYSCALE)
h, w = img.shape
sobel_horizontal = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=5)
sobel_vertical = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=5)
laplacian = cv2.Laplacian(img, cv2.CV_64F)
canny = cv2.Canny(img, 50, 240)
cv2.imshow('Original', img)
cv2.imshow('Sobel horizontal', sobel_horizontal)
cv2.imshow('Sobel vertical', sobel_vertical)
cv2.imshow('Laplacian', laplacian)
cv2.imshow('Canny', canny)
cv2.waitKey()
|
[
"eganl@packtpub.com"
] |
eganl@packtpub.com
|
12770caef27bc3fef998f1a1f8d9898aefccdd3f
|
aee126bb9fae134662e0ca2eab4c8d7483ab3ec6
|
/server/flaskApp/templates/app.py
|
ba8c62f877a5dff068fa88fd4b7552ad2099ed36
|
[] |
no_license
|
collier-watkins/DeafDoorbell
|
3479cc5da661b10c53981a30775ec28cfcb1524e
|
c8d8601a159a1469ccec3c9884012dc5d0b872f7
|
refs/heads/master
| 2020-05-04T01:09:32.807947
| 2019-05-27T01:41:53
| 2019-05-27T01:41:53
| 178,899,075
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,767
|
py
|
from flask import Flask, render_template, url_for, flash, request
from forms import MessageForm
from wtforms.widgets import html_params, HTMLString
from flask_socketio import SocketIO
#import subprocess
app = Flask(__name__)
app.config['SECRET_KEY'] = '3985723043u208uj23022039rue'
socketio = SocketIO(app)
client1IP = "192.168.0.16"
#Home Page
@app.route("/", methods=['GET', 'POST']) #Related to website locations
def homePage(): #Returns data for the main home page, should be HTML data
form = MessageForm()
JoysRoom = False
UpstairsBathroom = False
if request.method == "POST":
locations = request.form.getlist('location')
if u'Upstairs Bathroom' in locations : UpstairsBathroom = True
if u'Joys Room' in locations : JoysRoom = True
if form.validate_on_submit():
#THIS IS WHAT HAPPENS WHEN THE SUBMIT BUTTON IS PRESSED
message = request.form.get("LCDMessage")
app.logger.warning('Submit happened!')
app.logger.warning(message)
app.logger.warning("Joy\'s Room: " + str(JoysRoom))
app.logger.warning("Upstairs Bathroom: " + str(UpstairsBathroom))
######Send message to LCD and do GPIO stuff here #########
#subprocess.run()
#####################
return render_template('home.html', title='Blog Posts', form=form)
def messageReceived(methods=['GET', 'POST']):
print('message was received!!!')
@socketio.on('submitHit')
def handle_submit_event(json, methods=['GET', 'POST']):
print('received my event: ' + str(json))
socketio.emit('my response', json, callback=messageReceived)
#About Page
@app.route("/about")
def aboutPage():
return "<h1>About Page</h1>"
if __name__ == '__main__':
#Run Flask Application
socketio.run(app, debug=True, host='0.0.0.0', port=80)
|
[
"collier.watkins.chc@gmail.com"
] |
collier.watkins.chc@gmail.com
|
e8720a42e2d433fa822311add8bf6a44faced378
|
bda32ee120fd07499fad1e5e973249ac15861200
|
/ValidSudoku.py
|
5996590c78e0207e3f98330665a34507963f42cf
|
[] |
no_license
|
congyingTech/leetcode
|
5f76d11a283115e46fdf4f295cf0279f53e692a1
|
35ff5db1ee6abcb3cf1144a9bf5420758e31e6ec
|
refs/heads/master
| 2021-01-21T04:41:20.195451
| 2016-06-16T07:03:09
| 2016-06-16T07:03:09
| 54,643,108
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,772
|
py
|
#-*- coding:utf-8 -*-
'''
Created on Mar 30, 2016
@author: congyingw
'''
#Sudoku的要求有三条：每行的数只出现一次，每列的数只出现一次，每个九宫格数只出现一次。
#所以我们要验证这三个条件逐个遍历一遍。
class Solution:
def isValidSudoku(self, board):
for i in range(0, 9):
#第i行（固定的行）j列 or 第j行i列（固定的列）
if not self.isValidList([board[i][j] for j in range(0,9)]) or not self.isValidList([board[j][i] for j in range(0, 9)]):
return False
#检查第三条：九宫格里面是否出现重复，
for i in range(0, 3):
for j in range(0, 3):
if not self.isValidList([board[m][n] for m in range (3 * i, 3 * i + 3)for n in range(3 * j, 3*j + 3)]):
return False
return True
#判断是否是有效的list，去掉. 之后，set可以过滤相同的元素，过滤之后，看len是否相等
def isValidList(self, xs):
xs = list(filter(lambda x: x != '.', xs))
return len(set(xs)) == len(xs)
if __name__ == "__main__":
board = [[5, '.', '.', '.', '.', '.', '.', '.', '.'],
[5, 2, '.', '.', '.', '.', '.', '.', '.'],
['.', '.', 3, '.', '.', '.', '.', '.', '.'],
['.', '.', '.', 4, '.', '.', '.', '.', '.'],
['.', '.', '.', '.', 5, '.', '.', '.', '.'],
['.', '.', '.', '.', '.', 6, '.', '.', '.'],
['.', '.', '.', '.', '.', '.', 7, '.', '.'],
['.', '.', '.', '.', '.', '.', '.', 8, '.'],
['.', '.', '.', '.', '.', '.', '.', '.', 9]]
print(Solution().isValidSudoku(board))
|
[
"congyingTech@163.com"
] |
congyingTech@163.com
|
413948050ddee82de99cfae896398e6cdd3de69b
|
b252c3b7a78b37f8da3d5edca023e2bc38b368d4
|
/python_spider/learn_urllib.py
|
f35177e5ca0fc7636e025d24da4b8e810ec17bae
|
[] |
no_license
|
xianke5200/Python_spider_test
|
868447e48ae136314ba08a7c06440ba27951b201
|
7674ff2b4bcdc35248718d02245e968a5ca61add
|
refs/heads/master
| 2021-12-16T04:18:45.263926
| 2021-12-13T06:01:03
| 2021-12-13T06:01:03
| 234,503,928
| 2
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 822
|
py
|
import urllib
from urllib import request,parse
import ssl
#response = urllib.request.urlopen('http://192.168.1.153/bugfree/index.php/site/login')
#print(response.read().decode('utf-8'))
#context = ssl._create_unverified_context()
url = 'http://192.168.1.153/bugfree/index.php/site/login'
headers = {
'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko',
}
dict = {
#'return_url':'http://192.168.1.153/bugfree/index.php/bug/list/12',
'LoginForm[username]':'chenlue',
'LoginForm[password]':'chenlue',
'LoginForm[language]':'zh_cn',
'LoginForm[rememberMe]':'0'
}
data = bytes(parse.urlencode(dict),'utf-8')
req = request.Request(url,data=data,headers=headers,method='POST')
response = request.urlopen(req,data=data,timeout=1000)
print(response.read().decode('utf-8'))
|
[
"1833907216@qq.com"
] |
1833907216@qq.com
|
d8827844e462a3b2f1b7a4bfea42cf1fa45b6f4e
|
a080b5cb90d0e274b5a7aec3adb9bfdf4d5b8cd5
|
/jpgtopng.py
|
c01fa5b2f05dab9aa03590a67748832f4389f50d
|
[] |
no_license
|
nickcodes-py/JPGtoPNG-Converter
|
df2025855c87558c054de4dee7c73885d973b77a
|
c521cdba80008a2e0d3e0572b1bb7360020642b2
|
refs/heads/master
| 2020-12-04T20:55:37.693165
| 2020-01-05T10:18:14
| 2020-01-05T10:18:14
| 231,899,715
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 502
|
py
|
import sys
import os
from PIL import Image, ImageFilter
#Grab Current and New Folder
image_folder = sys.argv[1]
output_folder = sys.argv[2]
#Check if New exist, or create
if not os.path.exists(output_folder):
os.makedirs(output_folder)
#Loop through folder, convert images to PNG
for filename in os.listdir(image_folder):
img = Image.open(f'{image_folder}{filename}')
clean_name = os.path.splitext(filename)[0]
img.save(f'{output_folder}{clean_name}', 'png') #Save to new folder
|
[
"nikunj.dutt@outlook.com"
] |
nikunj.dutt@outlook.com
|
f76b563996fa4bd26228b5de39272a5ff2b2f5bf
|
7407b5a2bfad54bc9767c70c47d205164ffa337f
|
/models/db1.py
|
28d949a5077a8f9c4c8eccedeebe92588ac8d9c0
|
[
"MIT",
"LicenseRef-scancode-public-domain"
] |
permissive
|
abdulhalim-cu/motor-control-system
|
9397bb191fa22fceb66e88ccdb4ea80de774eb33
|
70d276d63163269c378620a85d46db8374b1a836
|
refs/heads/master
| 2021-01-01T18:31:42.750124
| 2017-08-01T01:51:27
| 2017-08-01T01:51:27
| 98,357,630
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,416
|
py
|
# -*- coding: utf-8 -*-
db.define_table('Device',
Field('device_id', 'string'),
Field('device_name', 'string'),
Field('model', 'string'),
Field('location', 'string')
)
db.Device.device_id.requires = [IS_NOT_EMPTY(),IS_NOT_IN_DB(db, 'Device.device_id')]
db.Device.device_name.requires = IS_NOT_EMPTY()
db.define_table('User_Device',
Field('user_ref_id', 'reference auth_user'),
Field('device_ref_id', 'reference Device'))
db.define_table('Direction',
Field('direction_type', label='Direction'),
format="%(direction_type)s")
db.define_table('Control_Instruction',
Field('device_ref_id', 'reference Device'),
Field('onoff_flag', 'boolean', notnull=True, label='Motor ON/OFF', comment='* Check for ON & Uncheck for OFF'),
Field('volt_flag', 'string', label='Voltage'),
Field('curr_flag', 'string', label='Current'),
Field('rot_flag', 'string', label='Rotation', comment='* Insert only integer value [revolution per minute]'),
Field('dir_flag', 'reference Direction', label='Direction', requires = IS_IN_DB(db, db.Direction.id,'%(direction_type)s')),
Field('freq_flag', 'string', label='Frequency'),
Field('off_flag', 'boolean', notnull=True, label='Off')
)
db.define_table('Changes',
Field('device_ref_id', 'reference Device'),
Field('change_flag', 'string')
)
db.define_table('Status',
Field('device_ref_id', 'reference Device'),
Field('created', 'datetime'),
Field('last_ping','datetime', requires=IS_NOT_EMPTY()),
Field('server_time','datetime', requires=IS_NOT_EMPTY()))
db.define_table('Device_States',
Field('device_ref_id', 'reference Device'),
Field('on_or_off', 'boolean', notnull=True, label='ON/OFF'),
Field('voltage', 'string'),
Field('current', 'string'),
Field('rotation', 'string'),
Field('direction', 'reference Direction', requires = IS_IN_DB(db, db.Direction.id,'%(direction_type)s')),
Field('frequency', 'string'),
Field('off', 'boolean', notnull=True, label='OFF'))
|
[
"abdulhalim.cu10@gmail.com"
] |
abdulhalim.cu10@gmail.com
|
c5273fe33676e21cd6b6a67e55bd93d84921ca2d
|
b8d4d9169b6df138cb45d64b618812c29e03012c
|
/Promos_for_our_e_commerce.py
|
fd57e264af0826cb3a8af2d38fc72f6a95ad63ed
|
[] |
no_license
|
mzfuadi97/Pythonq
|
5633057d351317d5156527fcf2cac288edec34cc
|
e64a180c9249650324d301a1d06407c8e01f3ea9
|
refs/heads/master
| 2023-08-03T07:19:12.543031
| 2021-09-21T04:34:21
| 2021-09-21T04:35:58
| 408,678,011
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 407,128
|
py
|
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"name": "Promos for our e-commerce.ipynb",
"provenance": []
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "code",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "YD0d355VUQeb",
"outputId": "b8034987-6295-4748-cf90-453ef771eca0"
},
"source": [
"#import library \n",
"import pandas as pd\n",
"\n",
"# Baca data 'ecommerce_banner_promo.csv'\n",
"data = pd.read_csv('https://storage.googleapis.com/dqlab-dataset/pythonTutorial/ecommerce_banner_promo.csv')\n",
"\n",
"#1. Data eksplorasi dengan head(), info(), describe(), shape\n",
"print(\"\\n[1] Data eksplorasi dengan head(), info(), describe(), shape\")\n",
"print(\"Lima data teratas:\")\n",
"print(data.head())\n",
"print(\"Informasi dataset:\")\n",
"print(data.info())\n",
"print(\"Statistik deskriptif dataset:\")\n",
"print(data.describe())\n",
"print(\"Ukuran dataset:\")\n",
"print(data.shape)"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"text": [
"\n",
"[1] Data eksplorasi dengan head(), info(), describe(), shape\n",
"Lima data teratas:\n",
" Daily Time Spent on Site Age ... Timestamp Clicked on Ad\n",
"0 68.95 35 ... 3/27/2016 0:53 0\n",
"1 80.23 31 ... 4/4/2016 1:39 0\n",
"2 69.47 26 ... 3/13/2016 20:35 0\n",
"3 74.15 29 ... 1/10/2016 2:31 0\n",
"4 68.37 35 ... 6/3/2016 3:36 0\n",
"\n",
"[5 rows x 10 columns]\n",
"Informasi dataset:\n",
"<class 'pandas.core.frame.DataFrame'>\n",
"RangeIndex: 1000 entries, 0 to 999\n",
"Data columns (total 10 columns):\n",
" # Column Non-Null Count Dtype \n",
"--- ------ -------------- ----- \n",
" 0 Daily Time Spent on Site 1000 non-null float64\n",
" 1 Age 1000 non-null int64 \n",
" 2 Area Income 1000 non-null float64\n",
" 3 Daily Internet Usage 1000 non-null float64\n",
" 4 Ad Topic Line 1000 non-null object \n",
" 5 City 1000 non-null object \n",
" 6 Male 1000 non-null int64 \n",
" 7 Country 1000 non-null object \n",
" 8 Timestamp 1000 non-null object \n",
" 9 Clicked on Ad 1000 non-null int64 \n",
"dtypes: float64(3), int64(3), object(4)\n",
"memory usage: 78.2+ KB\n",
"None\n",
"Statistik deskriptif dataset:\n",
" Daily Time Spent on Site Age ... Male Clicked on Ad\n",
"count 1000.000000 1000.000000 ... 1000.000000 1000.00000\n",
"mean 65.000200 36.009000 ... 0.481000 0.50000\n",
"std 15.853615 8.785562 ... 0.499889 0.50025\n",
"min 32.600000 19.000000 ... 0.000000 0.00000\n",
"25% 51.360000 29.000000 ... 0.000000 0.00000\n",
"50% 68.215000 35.000000 ... 0.000000 0.50000\n",
"75% 78.547500 42.000000 ... 1.000000 1.00000\n",
"max 91.430000 61.000000 ... 1.000000 1.00000\n",
"\n",
"[8 rows x 6 columns]\n",
"Ukuran dataset:\n",
"(1000, 10)\n"
],
"name": "stdout"
}
]
},
{
"cell_type": "code",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "dHnrKWBfUSR9",
"outputId": "009e3d75-9fbd-468e-bbf0-15712b1d3507"
},
"source": [
"#2. Data eksplorasi dengan dengan mengecek korelasi dari setiap feature menggunakan fungsi corr()\n",
"print(\"\\n[2] Data eksplorasi dengan dengan mengecek korelasi dari setiap feature menggunakan fungsi corr()\")\n",
"print(data.corr())\n",
"\n",
"#3. Data eksplorasi dengan mengecek distribusi label menggunakan fungsi groupby() dan size()\n",
"print(\"\\n[3] Data eksplorasi dengan mengecek distribusi label menggunakan fungsi groupby() dan size()\")\n",
"print(data.groupby('Clicked on Ad').size())"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"text": [
"\n",
"[2] Data eksplorasi dengan dengan mengecek korelasi dari setiap feature menggunakan fungsi corr()\n",
" Daily Time Spent on Site ... Clicked on Ad\n",
"Daily Time Spent on Site 1.000000 ... -0.748117\n",
"Age -0.331513 ... 0.492531\n",
"Area Income 0.310954 ... -0.476255\n",
"Daily Internet Usage 0.518658 ... -0.786539\n",
"Male -0.018951 ... -0.038027\n",
"Clicked on Ad -0.748117 ... 1.000000\n",
"\n",
"[6 rows x 6 columns]\n",
"\n",
"[3] Data eksplorasi dengan mengecek distribusi label menggunakan fungsi groupby() dan size()\n",
"Clicked on Ad\n",
"0 500\n",
"1 500\n",
"dtype: int64\n"
],
"name": "stdout"
}
]
},
{
"cell_type": "code",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 1000
},
"id": "tPJ9GKymUXHV",
"outputId": "ae0a44b1-a774-4889-f8ce-ee96b2053377"
},
"source": [
"#import library\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"# Seting: matplotlib and seaborn\n",
"sns.set_style('whitegrid')\n",
"plt.style.use('fivethirtyeight')\n",
"#4. Data eksplorasi dengan visualisasi\n",
"#4a. Visualisasi Jumlah user dibagi ke dalam rentang usia (Age) menggunakan histogram (hist()) plot\n",
"plt.figure(figsize=(10, 5))\n",
"plt.hist(data['Age'], bins = data.Age.nunique())\n",
"plt.xlabel('Age')\n",
"plt.tight_layout()\n",
"plt.show()\n",
"#4b. Gunakan pairplot() dari seaborn (sns) modul untuk menggambarkan hubungan setiap feature.\n",
"plt.figure()\n",
"sns.pairplot(data)\n",
"plt.show()"
],
"execution_count": null,
"outputs": [
{
"output_type": "display_data",
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 720x360 with 1 Axes>"
]
},
"metadata": {
"tags": []
}
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 432x288 with 0 Axes>"
]
},
"metadata": {
"tags": []
}
},
{
"output_type": "display_data",
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 1080x1080 with 42 Axes>"
]
},
"metadata": {
"tags": []
}
}
]
},
{
"cell_type": "code",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "q25Xy3DVUZ41",
"outputId": "93c3289f-9251-4959-966a-3fd6481d311b"
},
"source": [
"#5. Cek missing value\n",
"print(\"\\n[5] Cek missing value\")\n",
"print(data.isnull().sum().sum())"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"text": [
"\n",
"[5] Cek missing value\n",
"0\n"
],
"name": "stdout"
}
]
},
{
"cell_type": "code",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "r_kGRlZdUeq5",
"outputId": "1f5ecc58-11f1-408b-9ee6-4dac466ae186"
},
"source": [
"#import library\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.linear_model import LogisticRegression\n",
"\n",
"#6.Lakukan pemodelan dengan Logistic Regression, gunakan perbandingan 80:20 untuk training vs testing\n",
"print(\"\\n[6] Lakukan pemodelan dengan Logistic Regression, gunakan perbandingan 80:20 untuk training vs testing\")\n",
"\n",
"#6a.Drop Non-Numerical (object type) feature from X, as Logistic Regression can only take numbers, and also drop Target/label, assign Target Variable to y.\n",
"X = data.drop(['Ad Topic Line','City','Country','Timestamp','Clicked on Ad'], axis = 1)\n",
"y = data['Clicked on Ad']\n",
"\n",
"#6b. splitting the data\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = 42)\n",
"\n",
"#6c. Modelling\n",
"# Call the classifier\n",
"logreg = LogisticRegression()\n",
"\n",
"# Fit the classifier to the training data\n",
"logreg = logreg.fit(X_train,y_train)\n",
"\n",
"# Prediksi model\n",
"y_pred = logreg.predict(X_test)\n",
"\n",
"#6d. Evaluasi Model Performance\n",
"print(\"Evaluasi Model Performance:\")\n",
"print(\"Training Accuracy :\", logreg.score(X_train, y_train))\n",
"print(\"Testing Accuracy :\", logreg.score(X_test, y_test))"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"text": [
"\n",
"[6] Lakukan pemodelan dengan Logistic Regression, gunakan perbandingan 80:20 untuk training vs testing\n",
"Evaluasi Model Performance:\n",
"Training Accuracy : 0.9\n",
"Testing Accuracy : 0.9\n"
],
"name": "stdout"
}
]
},
{
"cell_type": "code",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "e_nJBVsUUons",
"outputId": "5a78dd97-f503-4221-f7ff-0388d88591fb"
},
"source": [
"# Import library\n",
"from sklearn.metrics import confusion_matrix, classification_report\n",
"\n",
"#7. Print Confusion matrix dan classification report\n",
"print(\"\\n[7] Print Confusion matrix dan classification report\")\n",
"\n",
"#apply confusion_matrix function to y_test and y_pred\n",
"print(\"Confusion matrix:\")\n",
"cm = confusion_matrix(y_test, y_pred)\n",
"print(cm)\n",
"\n",
"#apply classification_report function to y_test and y_pred\n",
"print(\"Classification report:\")\n",
"cr = classification_report(y_test, y_pred)\n",
"print(cr)"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"text": [
"\n",
"[7] Print Confusion matrix dan classification report\n",
"Confusion matrix:\n",
"[[85 4]\n",
" [16 95]]\n",
"Classification report:\n",
" precision recall f1-score support\n",
"\n",
" 0 0.84 0.96 0.89 89\n",
" 1 0.96 0.86 0.90 111\n",
"\n",
" accuracy 0.90 200\n",
" macro avg 0.90 0.91 0.90 200\n",
"weighted avg 0.91 0.90 0.90 200\n",
"\n"
],
"name": "stdout"
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "8dl68ec6U6FB"
},
"source": [
"Model sudah sangat baik dalam memprediksi user yang akan mengklik website atau tidak, dapat dilihat dari nilai accuracy = 0.90; Dataset memiliki jumlah label yang seimbang (balance class), sehingga evaluasi performansi dapat menggunakan metrik Accuracy"
]
},
{
"cell_type": "code",
"metadata": {
"id": "VMV1h1fYUsKQ"
},
"source": [
""
],
"execution_count": null,
"outputs": []
}
]
}
|
[
"mzfuadi@gmail.com"
] |
mzfuadi@gmail.com
|
7f3bf8c6c37f51045aadb727540f9a198debe4ce
|
a08670c23f1a8fed994fb781df93ce87a1ffc422
|
/web/base/__init__.py
|
658f51a797e95a51bb9111273933bf7998f7c2a2
|
[] |
no_license
|
roenfun/selenium-demo
|
962d53a459756716dea5bc81bdbc82105f619f61
|
7d5e46d8472cc22617d00df17f0fd272df19dff3
|
refs/heads/master
| 2023-03-21T13:27:49.707425
| 2021-03-15T03:23:37
| 2021-03-15T03:23:37
| 266,483,740
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 79
|
py
|
# @File : __init__.py.py
# @Author : Chad
# @Time : 2020-05-23
# coding:utf-8
|
[
"Chad.long@vipshop.com"
] |
Chad.long@vipshop.com
|
8c1baaf7bc0b2f574388dc5f64e36e1918a8a0b1
|
15b3d2c324748b2a9a96813fd7e0919cc4e249ae
|
/dashboard/dashboard/urls.py
|
3645e421490b14c597b18f35ad34efbc033bda4d
|
[] |
no_license
|
pzjc/dashboard-django
|
c1fb6fd7e8fa56ec10d714c0ea1607544f31f5fa
|
bb0dc34fb76cc768c9ef0d5f651a4112ddea73ec
|
refs/heads/master
| 2021-07-01T12:09:53.631999
| 2017-09-22T20:29:34
| 2017-09-22T20:29:34
| 104,480,897
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 766
|
py
|
"""dashboard URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.11/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.conf.urls import url, include
2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.contrib import admin
urlpatterns = [
url(r'^admin/', admin.site.urls),
]
|
[
"jz762@cornell.edu"
] |
jz762@cornell.edu
|
94bb8b2a0fb2fd8136b0743980291df09b163012
|
850001831b1fcdd4d27e328b356fc34909ca2917
|
/tests/test_map.py
|
77237924f7d6561097ffea685bfbe60e67c465bc
|
[
"BSD-3-Clause"
] |
permissive
|
yidiq7/pathos
|
b337353ccfe447866c46a4a784a7908c2f3fe31e
|
7e4fef911dc0283e245189df4683eea65bfd90f0
|
refs/heads/master
| 2022-08-24T08:43:34.009115
| 2020-05-27T12:18:21
| 2020-05-27T12:18:21
| 267,310,390
| 0
| 0
|
NOASSERTION
| 2020-05-27T12:14:50
| 2020-05-27T12:14:47
| null |
UTF-8
|
Python
| false
| false
| 2,170
|
py
|
#!/usr/bin/env python
#
# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
# Copyright (c) 1997-2016 California Institute of Technology.
# Copyright (c) 2016-2020 The Uncertainty Quantification Foundation.
# License: 3-clause BSD. The full license text is available at:
# - https://github.com/uqfoundation/pathos/blob/master/LICENSE
import time
verbose = False
delay = 0.01
items = 100
def busy_add(x,y, delay=0.01):
import time
for n in range(x):
x += n
for n in range(y):
y -= n
time.sleep(delay)
return x + y
def timed_pool(pool, items=100, delay=0.1, verbose=False):
_x = range(-items//2,items//2,2)
_y = range(len(_x))
_d = [delay]*len(_x)
if verbose: print(pool)
start = time.time()
res = pool.map(busy_add, _x, _y, _d)
_t = time.time() - start
if verbose: print("time to queue: %s" % _t)
start = time.time()
_sol_ = list(res)
t_ = time.time() - start
if verbose: print("time to results: %s\n" % t_)
return _sol_
class BuiltinPool(object):
def map(self, *args):
return list(map(*args))
std = timed_pool(BuiltinPool(), items, delay=0, verbose=False)
def test_serial():
from pathos.pools import SerialPool as PS
pool = PS()
res = timed_pool(pool, items, delay, verbose)
assert res == std
def test_pp():
from pathos.pools import ParallelPool as PPP
pool = PPP(servers=('localhost:5653','localhost:2414'))
res = timed_pool(pool, items, delay, verbose)
assert res == std
def test_processing():
from pathos.pools import ProcessPool as MPP
pool = MPP()
res = timed_pool(pool, items, delay, verbose)
assert res == std
def test_threading():
from pathos.pools import ThreadPool as MTP
pool = MTP()
res = timed_pool(pool, items, delay, verbose)
assert res == std
if __name__ == '__main__':
if verbose:
print("CONFIG: delay = %s" % delay)
print("CONFIG: items = %s" % items)
print("")
from pathos.helpers import freeze_support, shutdown
freeze_support()
test_serial()
test_pp()
test_processing()
test_threading()
shutdown()
|
[
"mmckerns@8bfda07e-5b16-0410-ab1d-fd04ec2748df"
] |
mmckerns@8bfda07e-5b16-0410-ab1d-fd04ec2748df
|
37ed82c45df03e22c5d1a9edd666017218ee89f1
|
c9500ad778b8521aaa85cb7fe3239989efaa4799
|
/plugins/zscaler/icon_zscaler/util/helpers.py
|
3a839a924b1fefd1411e0082e08af7540ce22557
|
[
"MIT"
] |
permissive
|
rapid7/insightconnect-plugins
|
5a6465e720f114d71b1a82fe14e42e94db104a0b
|
718d15ca36c57231bb89df0aebc53d0210db400c
|
refs/heads/master
| 2023-09-01T09:21:27.143980
| 2023-08-31T10:25:36
| 2023-08-31T10:25:36
| 190,435,635
| 61
| 60
|
MIT
| 2023-09-14T08:47:37
| 2019-06-05T17:05:12
|
Python
|
UTF-8
|
Python
| false
| false
| 4,440
|
py
|
from insightconnect_plugin_runtime.exceptions import PluginException
from re import sub, match, split
from typing import Union, Any, Dict
from icon_zscaler.util.constants import Assistance, Cause
CAMEL_CASE_REGEX = r"\b[a-z0-9]+([A-Z][a-z]+[0-9]*)*\b"
PASCAL_CASE_REGEX = r"\b[A-Z][a-z]+[0-9]*([A-Z][a-z]+[0-9]*)*\b"
CAMEL_CASE_ACRONYM_REGEX = r"\b[a-z0-9]+([A-Z]+[0-9]*)*\b"
def clean_dict(dictionary: Dict[str, Any]) -> Dict[str, Any]:
cleaned_dict = dictionary.copy()
for key, value in dictionary.items():
if isinstance(value, dict):
cleaned_dict[key] = clean_dict(value)
if cleaned_dict[key] == {}:
del cleaned_dict[key]
elif value in [None, "", 0, [], {}]:
del cleaned_dict[key]
return cleaned_dict
def remove_password_from_result(dictionary: dict) -> dict:
return {key: value for key, value in dictionary.copy().items() if key != "password"}
def prepare_department(department_api_result: list, given_department_name: str) -> dict:
for department in department_api_result:
if department.get("name") == given_department_name:
return department
raise PluginException(
cause=Cause.DEPARTMENT_NOT_FOUND,
assistance=Assistance.VERIFY_INPUT,
)
def prepare_groups(groups_api_result: list, given_groups_names: list) -> list:
result_list = []
available_names = [item.get("name") for item in groups_api_result]
for name in given_groups_names:
if name not in available_names:
raise PluginException(
cause=Cause.GROUP_NOT_FOUND,
assistance=Assistance.VERIFY_INPUT,
)
for group in groups_api_result:
for name in given_groups_names:
if name == group.get("name"):
result_list.append(group)
return result_list
def to_camel_case(provided_string: str) -> str:
if match(CAMEL_CASE_REGEX, provided_string):
return provided_string
if match(PASCAL_CASE_REGEX, provided_string):
return provided_string[0].lower() + provided_string[1:]
if match(CAMEL_CASE_ACRONYM_REGEX, provided_string):
words = split(r"(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z0-9])(?=[a-z])", provided_string)
result = "".join([w.title() for w in words])
return result[0].lower() + result[1:]
init, *temp = provided_string.split("_")
result = "".join([init.lower(), *map(str.title, temp)])
return result
def convert_dict_keys_to_camel_case(to_modify: Union[dict, list]) -> Union[dict, list]:
if isinstance(to_modify, list):
return [convert_dict_keys_to_camel_case(element) for element in to_modify]
elif isinstance(to_modify, dict):
output_dict = {}
for key, value in to_modify.items():
output_dict[to_camel_case(key)] = convert_dict_keys_to_camel_case(value)
return output_dict
else:
return to_modify
def filter_dict_keys(dict_to_modify: dict, keys_to_keep: list) -> dict:
if not isinstance(dict_to_modify, dict):
return dict_to_modify
return {key: dict_to_modify.get(key) for key in keys_to_keep if key in dict_to_modify}
def find_custom_url_category_by_name(url_category_name: str, url_categories_list: list) -> dict:
if not url_categories_list or not url_category_name:
raise PluginException(
cause=Cause.CATEGORY_NOT_FOUND,
assistance=Assistance.VERIFY_INPUT,
)
url_category = list(
filter(lambda category: category.get("configuredName") == url_category_name, url_categories_list)
)
if url_category and url_category[0].get("id"):
return url_category[0]
else:
raise PluginException(
cause=Cause.CATEGORY_NOT_FOUND,
assistance=Assistance.VERIFY_INPUT,
)
def find_url_category_by_id(url_category_id: str, url_categories_list: str) -> dict:
if not url_categories_list or not url_category_id:
raise PluginException(
cause=Cause.CATEGORY_NOT_FOUND,
assistance=Assistance.VERIFY_INPUT,
)
url_category = list(filter(lambda category: category.get("id") == url_category_id, url_categories_list))
if url_category and url_category[0].get("id"):
return url_category[0]
else:
raise PluginException(
cause=Cause.CATEGORY_NOT_FOUND,
assistance=Assistance.VERIFY_INPUT,
)
|
[
"noreply@github.com"
] |
noreply@github.com
|
224730f81d5c198b3bf51777919019a771f07a63
|
71c47b4c8f35279c1f875c499ecae3c2eaf65432
|
/Module_1/homework/100NSqrt.py
|
5976441d21bd1b5d6e2749fc5d97916fb9033217
|
[] |
no_license
|
isemiguk/Python_Coursera
|
e53ead7ed966a0b11a9c43667caa00f9c4504328
|
ce7d5904a91dfadd57d9a2bb4fb413d4c23c7a3c
|
refs/heads/master
| 2022-11-06T13:56:50.926356
| 2020-07-01T19:12:22
| 2020-07-01T19:12:22
| 266,181,204
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 36
|
py
|
a = input()
print(int(a * 100)**2)
|
[
"igorsemiguk@gmail.com"
] |
igorsemiguk@gmail.com
|
fa459c1d43ee6d8f2cdbb69fcdada36ad5305039
|
ee239ee6ead1f612fde7bec99be27c02afd11dd4
|
/sentimentanalyzer.py
|
8993e1ccb851c52fd63098f05ac298bcc7c21c68
|
[] |
no_license
|
vaitheeswarang/SentimentAnalyzer
|
fc5a597b6cf37e4b8726f4a559f46ce8fd4751e8
|
426b0e06a33a52b333a1631b66151bdde42eb715
|
refs/heads/master
| 2020-03-27T21:46:03.343604
| 2018-12-07T08:38:00
| 2018-12-07T08:38:00
| 147,174,131
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,898
|
py
|
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
print("*"*50)
#textt="the touch is not bad. the product is not a bad. i love this mobile fisrt. the product is awesome. it is easy to use. cost is too high to buy. camera is not good. comparing with other the quality is very bad. bad mobile. not good to say."
print("*"*50)
textt=input("Enter the review here: ")
text=[x.lower() for x in textt]
print("*"*50)
positive=['good','happy','love','awesome']
negative=['sad','bad','not','no','wont']
"""
for line in text:
sentence = line.split('.')
for word in sentence:
li=list(word.split(' '))
#print(li)
"""
#remove punctuations
punc='''.,!#@'''
no_punc=""
for char in text:
if char not in punc:
no_punc+=char
#print(no_punc)
#remove stopwords
#stop_words=set(stopwords.words('english'))
word_tokens=word_tokenize(no_punc)
stop_words={'on','a','the','is','was','i','it','to','with','other','this'}
filtered_sentence=[]
for w in word_tokens:
if w not in stop_words:
filtered_sentence.append(w)
#filtered_sentence=list(no_punc.split(' '))
#print(filtered_sentence)
''' Calculating without Negation words '''
pos_count, neg_count, neutral_count=0,0,0
for i in range(len(filtered_sentence)):
for j in range(len(positive)):
if (filtered_sentence[i]==positive[j]):
pos_count +=1
#print("Positive Word:", filtered_sentence[i])
for k in range(len(negative)):
if (filtered_sentence[i]==negative[k]):
neg_count+=-1
#print("Negative Word:", filtered_sentence[i])
break
#else:
# neutral_count+=neutral_count
total_score = pos_count+neg_count
print("Positive Count: ", +pos_count)
print("Negative Count: ", +neg_count)
print("Total Setiment Score without calculating Negated word: ", +total_score)
print("*"*75)
#print(stop_words)
if total_score>0:
print("The content is Positive")
elif total_score<0:
print("The content is Negative")
else:
print("The content is Neutral")
print("*"*75)
''' Calculating with Negation words '''
score,nscore=0,0
negation_words=['not','never','ever','didnt','no','wont']
pos_count,neg_count,negated_word,nnegated_word=0,0,0,0
for i in range(len(filtered_sentence)):
for k in range(len(negation_words)):
for j in range(len(positive)):
if(filtered_sentence[i]==negation_words[k]) and (filtered_sentence[i+1]==positive[j]):
#print(negation_words[k])
score=1*-1
negated_word+=1
print(filtered_sentence[i]+'_'+filtered_sentence[i+1])
for m in range(len(negation_words)):
for l in range(len(negative)):
if(filtered_sentence[i]==negation_words[m]) and (filtered_sentence[i+1]==negative[l]):
#print(negation_words[m])
nscore=1
nnegated_word+=1
print(filtered_sentence[i]+'_'+filtered_sentence[i+1])
print(filtered_sentence)
print("Total number of Negated words: ", negated_word)
print("The Total Score of Positive word with Negated_word is: ", score*negated_word)
print('\n')
print("Total number of Negative word with Negated words: ", nnegated_word)
print("The Total Score of Negative word with Negated_word is: ", nscore*nnegated_word)
print('\n')
print("The Total Sentiment Score with Negation words only: ", (score*negated_word)+(nscore*nnegated_word))
print("*"*75)
neg_total_score=(score*negated_word)+(nscore*nnegated_word)
if neg_total_score>0:
print("The content is Positive")
elif neg_total_score<0:
print("The content is Negative")
else:
print("The content is Neutral")
print("*"*75)
|
[
"noreply@github.com"
] |
noreply@github.com
|
ae28eeb606bc9e3c7a1b0a8586dd6305705295bb
|
add83856f85c4134a524671121212e32e9a0ade2
|
/aula4.py
|
6fb7f45e441fefbeecbb28f0bed9ee88a5a5bf73
|
[] |
no_license
|
priscilasvn10/Estudando_Python
|
671e3842c7b4e4de29e86cd7abe23f307d4a2ab8
|
ffef655a9c3282ac158435b3263928cd6cb531bd
|
refs/heads/master
| 2022-11-06T20:57:46.375239
| 2020-06-11T11:54:16
| 2020-06-11T11:54:16
| 271,512,537
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 221
|
py
|
a = int(input('Digite o primeito valor: '))
b = int(input('Digite o primeito valor: '))
soma = a + b
media = soma/2
print('O valor da soma é: {soma}'.format(soma=soma))
print('\n A média é {}'.format(media))
|
[
"noreply@github.com"
] |
noreply@github.com
|
0bea2a6533e2180f7d91076749f8da9dd71d235f
|
774df3c9bbb64889ae97b13363baf49709ad3f6c
|
/menwith/network.py
|
62d8a64f388a8a7199a6d71ab04d2a051c1d36ff
|
[] |
no_license
|
gmr/menwith
|
39095b8730d7ae87cd3d679bb65f3c6f1e775635
|
e03f51ccfa8db4db036f2f6e0fa640c579f1e150
|
refs/heads/master
| 2020-04-26T22:21:24.168247
| 2011-11-28T04:03:21
| 2011-11-28T04:03:21
| 173,705
| 1
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 8,961
|
py
|
"""
Main PCAP interface for listening on the NIC for data
"""
import logging
import pcap
from socket import ntohs, IPPROTO_TCP, IPPROTO_UDP
import struct
from . import memcache
# Ethernet constants
_ETHERTYPE_IPV4 = '\x08\x00'
# IPv4 Constants
_IPV4_BASE_HEADER_SIZE = 20 # Default IPv4 header size
_IPV4_OPTIONS_OFFSET = 20 # Bit 160
# TCP Constants
_TCP_BASE_HEADER_SIZE = 24
# Port we want to use by default
_MEMCACHED_PORT = 11211
# How many bytes to read
_SNAPSHOT_LENGTH = 65535
# Doesn't do anything in Linux
_TIMEOUT = 100
class TCPCapture(object):
def __init__(self, queue, device, port=_MEMCACHED_PORT):
"""Create a new TCPCapture object for the given device and port.
:param Queue queue: The cross-thread queue to create
:param str device: The device name (eth0, en1, etc)
:param int port: The port to listen on
:raises: ValueError
"""
self._logger = logging.getLogger('menwith.network.TCPCapture')
self._logger.debug('Setup with queue: %r', queue)
self._queue = queue
self._running = False
# Create the PCAP object
self._pcap = self._setup_libpcap(device, port)
def _char_conversion(self, value):
"""Convert the bytes to a character returning the converted string.
:param str value: The string to convert
:returns: str
"""
return ''.join(['%c' % byte for byte in value])
def _ethernet_decode(self, packet_in):
"""Extract the ethernet header, returning the ethernet header and
the remaining parts of the packet.
:param str packet_in: The full packet
:returns: tuple
"""
return (self._format_bytes(packet_in[0:6], ':'),
self._format_bytes(packet_in[6:12], ':'),
packet_in[12:14],
packet_in[14:])
def _format_bytes(self, value, delimiter=''):
"""Format a byte string returning the formatted value with the
specified delimiter.
:param str value: The byte string
:param str delimiter: The optional delimiter
:returns: str
"""
return delimiter.join(['%0.2x' % ord(byte) for byte in value])
def _ipv4_decode(self, packet_in):
"""Extract the IP header and populate a dictionary of values, returning
a the dictionary and the remaining data to extract.
:param str packet_in: The IP packet data
:returns: tuple
"""
out = {'version': struct.unpack('b', packet_in[0])[0] >> 4,
'ihl': (struct.unpack('b', packet_in[0])[0] & 0x0F) * 4,
'total_length': ntohs(struct.unpack('H', packet_in[2:4])[0]),
'identification': ntohs(struct.unpack('H', packet_in[4:6])[0]),
'flags': (ord(packet_in[6]) & 0xe0) >> 5,
'fragment_offset': (ntohs(struct.unpack('H',
packet_in[6:8])[0]) &
0x1f),
'ttl': ord(packet_in[8]),
'protocol': ord(packet_in[9]),
'checksum': ntohs(struct.unpack('H', packet_in[10:12])[0]),
'source': pcap.ntoa(struct.unpack('i', packet_in[12:16])[0]),
'destination': pcap.ntoa(struct.unpack('i',
packet_in[16:20])[0])}
# If our header size is more than 5 bytes, we have options
if out['ihl'] > _IPV4_BASE_HEADER_SIZE:
out['options'] = packet_in[_IPV4_BASE_HEADER_SIZE:out['ihl']]
else:
out['options'] = None
# Return the decoded packet
return out, packet_in[out['ihl']:]
def _process_packet(self, packet_length, packet_in, timestamp):
"""Called by libpcap's dispatch call, we receive raw data that needs
to be decoded then appended to the tcp buffer. When a full IP packet
is received, construct the TCP header dictionary.
:param int packet_length: The length of the packet received
:param str packet_in: The packet to be processed
:param float timestamp: The timestamp the packet was received
"""
# Extract the parts of the packet
dest, source, ethertype, payload = self._ethernet_decode(packet_in)
self._logger.debug(('Destination MAC Address: %s '
'Source MAC Address: %s'), dest, source)
# If we have an IPv4 ethertype, process it
if ethertype == _ETHERTYPE_IPV4:
# Process the IPv4 Header
ipv4_header, ipv4_payload = self._ipv4_decode(payload)
# Log the IPv4 Header values
self._logger.debug('IPv4 Header: %r', ipv4_header)
# Determine how to decode
if ipv4_header['protocol'] == IPPROTO_TCP:
# Decode the TCP Header
tcp_header, tcp_payload = self._tcp_decode(ipv4_payload)
# Log the TCP Header values
self._logger.debug('TCP Header: %r', tcp_header)
# Add the TCP data to the Queue for decoding
if tcp_payload:
self._queue.put(tcp_payload)
def _setup_libpcap(self, device, port):
"""Setup the pcap object and return the handle for it.
:returns: pcap.pcapObject
"""
# Validate the device
if not self._validate_device(device):
raise ValueError('Can not validate the device: %s' % device)
# Create the pcap object
pcap_object = pcap.pcapObject()
# Open the device in promiscuous mode
try:
pcap_object.open_live(device, _SNAPSHOT_LENGTH, True, _TIMEOUT)
self._logger.info('Opened %s', device)
except Exception as error:
raise OSError('Permission error opening device %s' % error)
# Set our filter up
filter = 'dst port %i' % port
# Create our pcap filter looking for ip packets for the memcached server
pcap_object.setfilter(filter, 1, 0)
self._logger.info('Filter set to: %s', filter)
# Set our operation to non-blocking
pcap_object.setnonblock(1)
# Return the handle to the pcap object
return pcap_object
def _tcp_decode(self, packet_in):
"""Extract the TCP header and populate a dictionary of values, returning
a the dictionary and the remaining data to extract.
:param str packet_in: The TCP packet data
:returns: tuple
"""
self._logger.debug('TCP Packet: %r', packet_in)
out = {'source_port': ntohs(struct.unpack('H', packet_in[0:2])[0]),
'dest_port': ntohs(struct.unpack('H', packet_in[2:4])[0]),
'data_offset': struct.unpack('B', packet_in[12])[0] >> 4}
return out, self._char_conversion(packet_in[(_TCP_BASE_HEADER_SIZE +
out['data_offset']):])
def _validate_device(self, device_name):
"""Validate the given device name as being available to the application.
While this is more hoops than just pcap.lookupdev, we can get a full
list of ip addresses we're listening for from this method.
:param str device_name: The device name to validate
:returns: Bool
"""
# Get all the devices available
devices = pcap.findalldevs()
# Iterate through the devices looking for the one we care about
for device in devices:
# Is this the droid, err device we are looking for?
if device[0] == device_name:
self._logger.debug('Validated device %s', device_name)
# Output ip addresses if there are any
if device[2]:
ip_addresses = list()
for address_info in device[2]:
ip_addresses.append(address_info[0])
self._logger.info('IP addresses to listen on: %r',
ip_addresses)
# Device validates
return True
# It was not found
return False
def process(self):
"""Start processing packets, dispatching received packets to the
TCPCapture._process_raw_data method.
Will loop as long as self._running is True
"""
# We want to process
self._running = True
# Iterate as long as we're processing
while self._running:
# Dispatch the reading of packets, as many as we can get
self._pcap.dispatch(1, self._process_packet)
def stop(self):
"""Causes the blocking listen call to stop."""
# Toggle the bool looped on in the listen method
self._running = False
# Log that the processing has been told to stop
self._logger.info('Indicated that processing of packets should stop')
|
[
"gmr@myyearbook.com"
] |
gmr@myyearbook.com
|
3e8640eb434a281e1b988d45b8387af02a0249b2
|
a3bdf69d3c5b8e422aae70eb21f3ae5f776e2ff9
|
/utils/excel_utils.py
|
5db791dbd899c620a96d16e483a8feaaa2a2cb18
|
[] |
no_license
|
cyssxt/data-sym-scrapy
|
6ce9d8d60869f89dc5f892984c113fdfeb52aefb
|
5fd92a42ec8a59fead315e2c63fc4d750de24c68
|
refs/heads/master
| 2021-08-23T18:41:02.036963
| 2017-12-06T02:47:39
| 2017-12-06T02:47:39
| 111,883,444
| 0
| 0
| null | 2017-11-24T06:22:27
| 2017-11-24T06:22:27
| null |
UTF-8
|
Python
| false
| false
| 2,437
|
py
|
import xlrd
from xlutils3.copy import copy
class ExcelParse(object):
"""
path:excel路径
sheet:excel中的sheet下表
head_index:excel标题头所在的行数
callback：遍历每一行的回掉
offset：内容体遍历的起始位置
limit：遍历的总记录数
descName：最终生成的excel
"""
def __init__(self, path, sheet=0, head_index=0, callback=None, offset=0, limit=None, desc_name="aaa.xls"):
data = xlrd.open_workbook(path)
self.table = data.sheet_by_index(sheet)
self.nrows = self.table.nrows
self.callback = callback
self.headIndex = head_index
self.ncols = self.table.ncols
self.headers = []
self.bodys = []
self.limit = limit
self.descTable = copy(data)
self.desc_name = desc_name
self.offset = offset
self.parse_header()
def parse(self):
for i in range(self.nrows):
row = self.table.row_values(i)
# data = self.callback and self.callback(self.table, row)
self.callback and self.callback(self.table, row)
def prase_body(self):
start = self.offset or (self.headIndex + 1)
end = (self.limit + start) if None is not self.limit else self.nrows
for bodyIndex in range(start, end):
self.callback and self.callback(self, self.table.row_values(bodyIndex), bodyIndex)
def parse_header(self):
head = self.table.row_values(self.headIndex)
for i in range(self.ncols):
self.headers.append(head[i])
"""
获取单元格的值
"""
def get_cell_value(self, row_index, header):
row = self.table.row_values(row_index)
index = self.headers.index(header)
return row[index]
"""
设置excel的单元格的值
"""
def set_cell_value(self, row_index, header, value, sheet=0):
index = self.headers.index(header)
table = self.descTable.get_sheet(sheet)
table.write(row_index, index, value)
"""
保存
"""
def save(self):
self.descTable.save(self.desc_name)
# http://browser.ihtsdotools.org/api/v1/snomed/en-edition/v20170731/descriptions?query=Headaches&limit=50&searchMode=partialMatching&lang=english&statusFilter=activeOnly&skipTo=0&returnLimit=100&normalize=true
# table, nRows = read_excel("../sym_about.xlsx")
# print nRows
|
[
"cyssxt@163.com"
] |
cyssxt@163.com
|
0292b72004bd85deca84805fc86f18693d557717
|
6fa7f99d3d3d9b177ef01ebf9a9da4982813b7d4
|
/JFLADuABfkeoz8mqN_5.py
|
418dc4c327c7b6b0b704d40cb3c93aa5c599e590
|
[] |
no_license
|
daniel-reich/ubiquitous-fiesta
|
26e80f0082f8589e51d359ce7953117a3da7d38c
|
9af2700dbe59284f5697e612491499841a6c126f
|
refs/heads/master
| 2023-04-05T06:40:37.328213
| 2021-04-06T20:17:44
| 2021-04-06T20:17:44
| 355,318,759
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 386
|
py
|
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def compare_age(self, other):
modifier = ''
if self.age < other.age:
modifier = 'older than'
elif self.age == other.age:
modifier = 'the same age as'
else:
modifier = 'younger than'
return '{n} is {m} me.'.format(n = other.name, m = modifier)
|
[
"daniel.reich@danielreichs-MacBook-Pro.local"
] |
daniel.reich@danielreichs-MacBook-Pro.local
|
74b1acca6c71d5a2a04373300690f2d2ca2e9bbd
|
1bd47bb8cffa81a8e7d578d3826a420e9750e161
|
/main.py
|
86049ea3a70e311a4e73e8ccc283d6a0a5982466
|
[] |
no_license
|
Damir10165/TableAndTree
|
24d8a5ef0afa4938ee05d833351d74d624ebe7aa
|
94fb3933066570c0ded7db5670ca1cc8abf22428
|
refs/heads/main
| 2023-08-17T10:58:39.704553
| 2021-07-16T12:43:26
| 2021-07-16T12:43:26
| 386,104,128
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,339
|
py
|
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PyQt5.QtWidgets import (QApplication, QWidget, QToolBar, QPushButton,
QMainWindow, QAction, QTextEdit, QGridLayout,
QTableView)
from PyQt5 import QtSql
import random
import sys
import os
DATABASE_NAME = 'example.db'
def Connect_DataBase():
if os.path.exists(DATABASE_NAME):
return Open_DataBase()
else:
return Create_DataBase()
def Open_DataBase():
con = QtSql.QSqlDatabase.addDatabase('QSQLITE')
con.setDatabaseName(DATABASE_NAME)
if con.open():
print("Open data base is success")
return con
else:
print("Error open data base")
return None
def Create_DataBase():
con = Open_DataBase()
if con is not None:
if Create_DataBase_Table(con):
print("Create data base is success")
return con
else:
print("Error create table")
return None
else:
print("Error open data base for create table")
return None
def Create_DataBase_Table(con):
if con.exec("CREATE TABLE Numbers (a float, b float, c float)"):
print("Create table is success")
return True
else:
print("Error create table")
return None
class Table(QTableView):
def __init__(self):
super().__init__()
self.con = Connect_DataBase()
self.model = QtSql.QSqlTableModel(self, self.con)
self.model.setTable('Numbers')
self.model.setEditStrategy(QtSql.QSqlTableModel.OnFieldChange)
self.model.select()
self.setModel(self.model)
def add_row(self):
rec = QtSql.QSqlRecord()
rec.append(QtSql.QSqlField('a'))
rec.append(QtSql.QSqlField('b'))
rec.append(QtSql.QSqlField('c'))
rec.setValue('a', float('{:.2}'.format(random.uniform(0,1))))
rec.setValue('b', float('{:.2}'.format(random.uniform(0,1))))
rec.setValue('c', float('{:.2}'.format(random.uniform(0,1))))
self.model.insertRecord(-1, rec)
class Window(QMainWindow):
#главное окно
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
#Таблица
self.table1 = Table()
#кнопки добавления строк и столбцов
Action_1 = QAction('Добавить строку', self)
Action_1.triggered.connect(self.table1.add_row)
self.toolbar = self.addToolBar('Добавить строку')
self.toolbar.addAction(Action_1)
#таблица и дерево
window = QWidget()
Tree = QTextEdit()
grid = QGridLayout()
grid.setSpacing(5)
grid.addWidget(self.table1, 1, 0)
grid.addWidget(Tree, 1, 1)
window.setLayout(grid)
self.setCentralWidget(window)
self.setCentralWidget(window)
self.setGeometry(500, 500, 500, 500)
self.setWindowTitle("Главное окно")
self.show()
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Window()
sys.exit(app.exec_())
|
[
"noreply@github.com"
] |
noreply@github.com
|
7bfbdeac3b9d9dcaf8e91951da6cda2e2c7d6ce8
|
7daf78ed6ddc52c46b7d83db865cb6bd57a451ac
|
/spi_test.py
|
bac96a76c0db60104f1b5eb8cbb731cffd3ffb3f
|
[] |
no_license
|
bitbytebitco/radpc_ai
|
684b038fb14d117afec189e4871160fb021d2186
|
cacf80efa37acd6bf563ec27697b3fd594ed4720
|
refs/heads/master
| 2023-06-29T01:50:43.178256
| 2021-08-05T02:59:21
| 2021-08-05T02:59:21
| 365,015,332
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,423
|
py
|
import os
import spidev
import time
import RPi.GPIO as GPIO
# GPIO init
GPIO.setmode(GPIO.BCM)
GPIO.setup(23,GPIO.IN, pull_up_down=GPIO.PUD_UP)
# SPI init
spi_bus =0
spi_device = 0
spi = spidev.SpiDev()
spi.open(spi_bus, spi_device)
#spi.max_speed_hz = 4000
#spi.max_speed_hz = 151000
spi.max_speed_hz = 145000 # NOTE: CLOCK STUFF IS WEIRD!
spi.no_cs = False
ACK = 0xEE
BINARY = False
# TODO: replace print statements with logging
def send_receive(channel=None):
try:
print('')
print('send_receive')
print('SENDING: ACK(`{}`)'.format(hex(ACK)))
print(hex(ACK))
ack_resp = spi.xfer([ACK]) # send 0xEE to MSP to start sequence
command = spi.readbytes(1)[0] # byte a byte which will be the COMMAND FOR THE RPI
if hex(command) == "0x22":
print('Command: RESET')
spi.writebytes([0x22]) # SEND CONFIRMATION (echo command)
elif hex(command) == "0x25":
print('Command: PACKET')
if True:
fake = []
for i in range(127):
fake.append(0x00)
spi.writebytes([0x25]) # SEND CONFIRMATION (echo command)
packet = spi.xfer(fake) # read PACKET
else:
spi.writebytes([0x25])
packet = spi.readbytes(128)
#print('packet data')
#print(packet)
#print([hex(i) for i in packet])
#print("".join([chr(i) for i in packet]))
bytes_str = bytes(bytearray([i for i in packet]))
#print(str(bytes_str))
packet_count = len(os.listdir(os.path.join(os.getcwd(), "packets"))) # count files for filename usage
with open('packets/{}.txt'.format(int(packet_count)+1), 'w') as binary_file:
if not(BINARY):
binary_file.write(str(bytes_str)) # saving as a str
else:
binary_file.write(bytes_str) # saving as binary needs `wb` in open()
print('packet {} saved'.format(packet_count))
else:
print("ELSE!")
print(hex(command))
except Exception as e:
print(e)
# SETUP Interrupt
GPIO.add_event_detect(23, GPIO.RISING, callback=send_receive, bouncetime=500)
# Main Loop
while True:
pass
print('####')
print('####')
|
[
"bitbytebitco@gmail.com"
] |
bitbytebitco@gmail.com
|
e3cb34e969e398b08d9c43935908f7b26d4014f0
|
000a4b227d970cdc6c8db192f4437698cb782721
|
/python/helpers/typeshed/stubs/stripe/stripe/api_resources/charge.pyi
|
2e3467e67bc5e6b90113fd9988cf281a375bde2c
|
[
"Apache-2.0",
"MIT"
] |
permissive
|
trinhanhngoc/intellij-community
|
2eb2f66a2a3a9456e7a0c5e7be1eaba03c38815d
|
1d4a962cfda308a73e0a7ef75186aaa4b15d1e17
|
refs/heads/master
| 2022-11-03T21:50:47.859675
| 2022-10-19T16:39:57
| 2022-10-19T23:25:35
| 205,765,945
| 1
| 0
|
Apache-2.0
| 2019-09-02T02:55:15
| 2019-09-02T02:55:15
| null |
UTF-8
|
Python
| false
| false
| 851
|
pyi
|
from typing import Any
from stripe import api_requestor as api_requestor
from stripe.api_resources.abstract import (
CreateableAPIResource as CreateableAPIResource,
ListableAPIResource as ListableAPIResource,
UpdateableAPIResource as UpdateableAPIResource,
custom_method as custom_method,
)
class Charge(CreateableAPIResource, ListableAPIResource, UpdateableAPIResource):
OBJECT_NAME: str
def capture(self, idempotency_key: Any | None = ..., **params): ...
def refund(self, idempotency_key: Any | None = ..., **params): ...
def update_dispute(self, idempotency_key: Any | None = ..., **params): ...
def close_dispute(self, idempotency_key: Any | None = ..., **params): ...
def mark_as_fraudulent(self, idempotency_key: Any | None = ...): ...
def mark_as_safe(self, idempotency_key: Any | None = ...): ...
|
[
"intellij-monorepo-bot-no-reply@jetbrains.com"
] |
intellij-monorepo-bot-no-reply@jetbrains.com
|
e93d618ef2a5f5ad993261c09a6a1b7b73293570
|
0fa1d839550f4bfb1d9d0860915770071422f2cd
|
/parrot.py
|
51dd4bbc1ed740272deb7e105a164b4e9cb6f887
|
[] |
no_license
|
crystalDf/Python-Crash-Course-2nd-Edition-Chapter-07-Input
|
b996d5b5bfbf20be039ac2e2314e51d6a51545a1
|
a8838fe405e4ce70e827a6ace98f3502b3a57f45
|
refs/heads/master
| 2023-06-10T08:12:07.675473
| 2021-06-20T14:45:01
| 2021-06-20T14:45:01
| 378,668,714
| 1
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 460
|
py
|
message = input("Tell me something, and I will repeat it back to you: ")
print(message)
prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "
message = ""
while message != 'quit':
message = input(prompt)
if message != 'quit':
print(message)
active = True
while active:
message = input(prompt)
if message == 'quit':
active = False
else:
print(message)
|
[
"chendong333@gmail.com"
] |
chendong333@gmail.com
|
b1d967e610d4020d110343b3a61c6a12bb491305
|
709522eb6c9730f2095df3d0f89b02b658e93e18
|
/run.py
|
6d7679064d87dd38d491dcc181560356ff89813e
|
[] |
no_license
|
haracewiat/MultiplayerGame
|
1bb549c4bae6655ece3f5c2386d33a2a042ac7d7
|
4896626da59c280a7a8ae22026cd33dd0818095f
|
refs/heads/master
| 2023-07-20T02:12:27.227911
| 2020-03-11T17:41:54
| 2020-03-11T17:41:54
| 246,146,985
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 99
|
py
|
from game import Game
if __name__ == "__main__":
print("run")
g = game.Game()
g.run()
|
[
"b.haracewiat@gmail.com"
] |
b.haracewiat@gmail.com
|
ec4b7992e11399e05868bd6cd613c86cd686efa1
|
bf02d48baebee89a95b2c637b6d017ca300039ef
|
/tictactoe/settings.py
|
f9e2d7ba7de9bf3f09d6d21562d2bce0679fe770
|
[] |
no_license
|
maheshwars/Tic-Tac-Toe
|
c4014b9d0c833e4d0648066f319b42a60e6d589e
|
b2ea1c5f0b84f8fbd5e360e323d4030e8fc82589
|
refs/heads/master
| 2022-12-09T12:41:50.696273
| 2020-09-09T21:30:27
| 2020-09-09T21:30:27
| 294,225,777
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,509
|
py
|
"""
Django settings for tictactoe project.
Generated by 'django-admin startproject' using Django 3.1.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.1/ref/settings/
"""
from pathlib import Path
import os
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve(strict=True).parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '%bx5#d_6-%-3#v(5p4t=n*svppv280hmaz^g3fdiuk95s--01p'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'gameplay',
'player',
'crispy_forms',
]
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 = 'tictactoe.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 = 'tictactoe.wsgi.application'
# Database
# https://docs.djangoproject.com/en/3.1/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
# Password validation
# https://docs.djangoproject.com/en/3.1/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.1/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.1/howto/static-files/
STATIC_URL = '/static/'
STATICFILES_DIRS = [
os.path.join(BASE_DIR, "static")
]
LOGIN_REDIRECT_URL = "player_home"
LOGOUT_REDIRECT_URL = "tictactoe_welcome"
LOGIN_URL = "player_login"
CRISPY_TEMPLATE_PACK ='bootstrap3'
|
[
"noreply@github.com"
] |
noreply@github.com
|
ecff5efbd76a2dde9d681d2784b800b6663f9127
|
b7c3511bf4293c12510f0eab72f6d2bffd05be19
|
/web_chat/chat/tests.py
|
4b658e6522c77c5c9eb85d331569b99c4f7bd68e
|
[] |
no_license
|
vramos1/backend-arquitectura
|
ab7e8831f899a038902c83c3bef89b202c432abb
|
159bad5b1e454328df6981d8935c909a8204e36d
|
refs/heads/master
| 2023-01-29T21:14:50.188507
| 2020-11-23T21:04:13
| 2020-11-23T21:04:13
| 310,602,901
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,265
|
py
|
from django.test import TestCase
from web_chat.chat.models import Room, Chat, Apply
from django.contrib.auth.models import User
# Create your tests here.
class ChatTest(TestCase):
def setUp(self):
self.user = User.objects.create(
is_superuser=False, password="test", username="test"
)
self.room = Room.objects.create(
name="test room", private=True, creator=self.user
)
self.room.users.add(self.user)
self.room.save()
self.message = Chat.objects.create(
username=self.user.username,
room=self.room,
message="this is a test message",
)
self.apply = Apply.objects.create(user=self.user, room=self.room)
def test_get_creator(self):
creator_username = self.room.get_creator()
self.assertEqual(creator_username, self.user.username)
def test_get_all_messages(self):
chats = self.room.get_all_messages()
self.assertEqual(chats[0].message, self.message.message)
def test_get_user_and_room(self):
username_string = self.apply.get_user_and_room()
correct_string = f"{self.user.username} => {self.room.name}"
self.assertEqual(username_string, correct_string)
|
[
"vramos1@uc.cl"
] |
vramos1@uc.cl
|
4ca6bb07c21ed85808635058d7bf3d36c71eb43e
|
b8f4b32171bba9e60a101f5a605e084c9aa974fd
|
/BaseTools/Source/Python/AutoGen/UniClassObject.py
|
b2895f7e5c63d238180b93830b7630499ffa202c
|
[
"BSD-3-Clause",
"BSD-2-Clause-Patent"
] |
permissive
|
jinjhuli/slimbootloader
|
3137ab83073865b247f69b09a628f8b39b4c05ee
|
cfba21067cf4dce659b508833d8c886967081375
|
refs/heads/master
| 2023-07-11T12:59:51.336343
| 2020-09-11T00:16:48
| 2020-09-11T00:24:52
| 149,729,121
| 1
| 0
|
BSD-2-Clause
| 2018-09-21T07:49:42
| 2018-09-21T07:49:42
| null |
UTF-8
|
Python
| false
| false
| 29,575
|
py
|
## @file
# This file is used to collect all defined strings in multiple uni files
#
#
# Copyright (c) 2014 Hewlett-Packard Development Company, L.P.<BR>
#
# Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
# SPDX-License-Identifier: BSD-2-Clause-Patent
##
# Import Modules
#
from __future__ import print_function
import Common.LongFilePathOs as os, codecs, re
import distutils.util
import Common.EdkLogger as EdkLogger
from io import BytesIO
from Common.BuildToolError import *
from Common.StringUtils import GetLineNo
from Common.Misc import PathClass
from Common.LongFilePathSupport import LongFilePath
from Common.GlobalData import *
##
# Static definitions
#
UNICODE_WIDE_CHAR = u'\\wide'
UNICODE_NARROW_CHAR = u'\\narrow'
UNICODE_NON_BREAKING_CHAR = u'\\nbr'
UNICODE_UNICODE_CR = '\r'
UNICODE_UNICODE_LF = '\n'
NARROW_CHAR = u'\uFFF0'
WIDE_CHAR = u'\uFFF1'
NON_BREAKING_CHAR = u'\uFFF2'
CR = u'\u000D'
LF = u'\u000A'
NULL = u'\u0000'
TAB = u'\t'
BACK_SLASH_PLACEHOLDER = u'\u0006'
gIncludePattern = re.compile("^#include +[\"<]+([^\"< >]+)[>\"]+$", re.MULTILINE | re.UNICODE)
## Convert a unicode string to a Hex list
#
# Convert a unicode string to a Hex list
# UniToHexList('ABC') is ['0x41', '0x00', '0x42', '0x00', '0x43', '0x00']
#
# @param Uni: The python unicode string
#
# @retval List: The formatted hex list
#
def UniToHexList(Uni):
List = []
for Item in Uni:
Temp = '%04X' % ord(Item)
List.append('0x' + Temp[2:4])
List.append('0x' + Temp[0:2])
return List
LangConvTable = {'eng':'en', 'fra':'fr', \
'aar':'aa', 'abk':'ab', 'ave':'ae', 'afr':'af', 'aka':'ak', 'amh':'am', \
'arg':'an', 'ara':'ar', 'asm':'as', 'ava':'av', 'aym':'ay', 'aze':'az', \
'bak':'ba', 'bel':'be', 'bul':'bg', 'bih':'bh', 'bis':'bi', 'bam':'bm', \
'ben':'bn', 'bod':'bo', 'bre':'br', 'bos':'bs', 'cat':'ca', 'che':'ce', \
'cha':'ch', 'cos':'co', 'cre':'cr', 'ces':'cs', 'chu':'cu', 'chv':'cv', \
'cym':'cy', 'dan':'da', 'deu':'de', 'div':'dv', 'dzo':'dz', 'ewe':'ee', \
'ell':'el', 'epo':'eo', 'spa':'es', 'est':'et', 'eus':'eu', 'fas':'fa', \
'ful':'ff', 'fin':'fi', 'fij':'fj', 'fao':'fo', 'fry':'fy', 'gle':'ga', \
'gla':'gd', 'glg':'gl', 'grn':'gn', 'guj':'gu', 'glv':'gv', 'hau':'ha', \
'heb':'he', 'hin':'hi', 'hmo':'ho', 'hrv':'hr', 'hat':'ht', 'hun':'hu', \
'hye':'hy', 'her':'hz', 'ina':'ia', 'ind':'id', 'ile':'ie', 'ibo':'ig', \
'iii':'ii', 'ipk':'ik', 'ido':'io', 'isl':'is', 'ita':'it', 'iku':'iu', \
'jpn':'ja', 'jav':'jv', 'kat':'ka', 'kon':'kg', 'kik':'ki', 'kua':'kj', \
'kaz':'kk', 'kal':'kl', 'khm':'km', 'kan':'kn', 'kor':'ko', 'kau':'kr', \
'kas':'ks', 'kur':'ku', 'kom':'kv', 'cor':'kw', 'kir':'ky', 'lat':'la', \
'ltz':'lb', 'lug':'lg', 'lim':'li', 'lin':'ln', 'lao':'lo', 'lit':'lt', \
'lub':'lu', 'lav':'lv', 'mlg':'mg', 'mah':'mh', 'mri':'mi', 'mkd':'mk', \
'mal':'ml', 'mon':'mn', 'mar':'mr', 'msa':'ms', 'mlt':'mt', 'mya':'my', \
'nau':'na', 'nob':'nb', 'nde':'nd', 'nep':'ne', 'ndo':'ng', 'nld':'nl', \
'nno':'nn', 'nor':'no', 'nbl':'nr', 'nav':'nv', 'nya':'ny', 'oci':'oc', \
'oji':'oj', 'orm':'om', 'ori':'or', 'oss':'os', 'pan':'pa', 'pli':'pi', \
'pol':'pl', 'pus':'ps', 'por':'pt', 'que':'qu', 'roh':'rm', 'run':'rn', \
'ron':'ro', 'rus':'ru', 'kin':'rw', 'san':'sa', 'srd':'sc', 'snd':'sd', \
'sme':'se', 'sag':'sg', 'sin':'si', 'slk':'sk', 'slv':'sl', 'smo':'sm', \
'sna':'sn', 'som':'so', 'sqi':'sq', 'srp':'sr', 'ssw':'ss', 'sot':'st', \
'sun':'su', 'swe':'sv', 'swa':'sw', 'tam':'ta', 'tel':'te', 'tgk':'tg', \
'tha':'th', 'tir':'ti', 'tuk':'tk', 'tgl':'tl', 'tsn':'tn', 'ton':'to', \
'tur':'tr', 'tso':'ts', 'tat':'tt', 'twi':'tw', 'tah':'ty', 'uig':'ug', \
'ukr':'uk', 'urd':'ur', 'uzb':'uz', 'ven':'ve', 'vie':'vi', 'vol':'vo', \
'wln':'wa', 'wol':'wo', 'xho':'xh', 'yid':'yi', 'yor':'yo', 'zha':'za', \
'zho':'zh', 'zul':'zu'}
## GetLanguageCode
#
# Check the language code read from .UNI file and convert ISO 639-2 codes to RFC 4646 codes if appropriate
# ISO 639-2 language codes supported in compatibility mode
# RFC 4646 language codes supported in native mode
#
# @param LangName: Language codes read from .UNI file
#
# @retval LangName: Valid language code in RFC 4646 format or None
#
def GetLanguageCode(LangName, IsCompatibleMode, File):
length = len(LangName)
if IsCompatibleMode:
if length == 3 and LangName.isalpha():
TempLangName = LangConvTable.get(LangName.lower())
if TempLangName is not None:
return TempLangName
return LangName
else:
EdkLogger.error("Unicode File Parser", FORMAT_INVALID, "Invalid ISO 639-2 language code : %s" % LangName, File)
if (LangName[0] == 'X' or LangName[0] == 'x') and LangName[1] == '-':
return LangName
if length == 2:
if LangName.isalpha():
return LangName
elif length == 3:
if LangName.isalpha() and LangConvTable.get(LangName.lower()) is None:
return LangName
elif length == 5:
if LangName[0:2].isalpha() and LangName[2] == '-':
return LangName
elif length >= 6:
if LangName[0:2].isalpha() and LangName[2] == '-':
return LangName
if LangName[0:3].isalpha() and LangConvTable.get(LangName.lower()) is None and LangName[3] == '-':
return LangName
EdkLogger.error("Unicode File Parser", FORMAT_INVALID, "Invalid RFC 4646 language code : %s" % LangName, File)
## Ucs2Codec
#
# This is only a partial codec implementation. It only supports
# encoding, and is primarily used to check that all the characters are
# valid for UCS-2.
#
class Ucs2Codec(codecs.Codec):
def __init__(self):
self.__utf16 = codecs.lookup('utf-16')
def encode(self, input, errors='strict'):
for Char in input:
CodePoint = ord(Char)
if CodePoint >= 0xd800 and CodePoint <= 0xdfff:
raise ValueError("Code Point is in range reserved for " +
"UTF-16 surrogate pairs")
elif CodePoint > 0xffff:
raise ValueError("Code Point too large to encode in UCS-2")
return self.__utf16.encode(input)
TheUcs2Codec = Ucs2Codec()
def Ucs2Search(name):
if name == 'ucs-2':
return codecs.CodecInfo(
name=name,
encode=TheUcs2Codec.encode,
decode=TheUcs2Codec.decode)
else:
return None
codecs.register(Ucs2Search)
## StringDefClassObject
#
# A structure for language definition
#
class StringDefClassObject(object):
def __init__(self, Name = None, Value = None, Referenced = False, Token = None, UseOtherLangDef = ''):
self.StringName = ''
self.StringNameByteList = []
self.StringValue = ''
self.StringValueByteList = ''
self.Token = 0
self.Referenced = Referenced
self.UseOtherLangDef = UseOtherLangDef
self.Length = 0
if Name is not None:
self.StringName = Name
self.StringNameByteList = UniToHexList(Name)
if Value is not None:
self.StringValue = Value + u'\x00' # Add a NULL at string tail
self.StringValueByteList = UniToHexList(self.StringValue)
self.Length = len(self.StringValueByteList)
if Token is not None:
self.Token = Token
def __str__(self):
return repr(self.StringName) + ' ' + \
repr(self.Token) + ' ' + \
repr(self.Referenced) + ' ' + \
repr(self.StringValue) + ' ' + \
repr(self.UseOtherLangDef)
def UpdateValue(self, Value = None):
if Value is not None:
self.StringValue = Value + u'\x00' # Add a NULL at string tail
self.StringValueByteList = UniToHexList(self.StringValue)
self.Length = len(self.StringValueByteList)
def StripComments(Line):
Comment = u'//'
CommentPos = Line.find(Comment)
while CommentPos >= 0:
# if there are non matched quotes before the comment header
# then we are in the middle of a string
# but we need to ignore the escaped quotes and backslashes.
if ((Line.count(u'"', 0, CommentPos) - Line.count(u'\\"', 0, CommentPos)) & 1) == 1:
CommentPos = Line.find (Comment, CommentPos + 1)
else:
return Line[:CommentPos].strip()
return Line.strip()
## UniFileClassObject
#
# A structure for .uni file definition
#
class UniFileClassObject(object):
def __init__(self, FileList = [], IsCompatibleMode = False, IncludePathList = []):
self.FileList = FileList
self.Token = 2
self.LanguageDef = [] #[ [u'LanguageIdentifier', u'PrintableName'], ... ]
self.OrderedStringList = {} #{ u'LanguageIdentifier' : [StringDefClassObject] }
self.OrderedStringDict = {} #{ u'LanguageIdentifier' : {StringName:(IndexInList)} }
self.OrderedStringListByToken = {} #{ u'LanguageIdentifier' : {Token: StringDefClassObject} }
self.IsCompatibleMode = IsCompatibleMode
self.IncludePathList = IncludePathList
if len(self.FileList) > 0:
self.LoadUniFiles(FileList)
#
# Get Language definition
#
def GetLangDef(self, File, Line):
Lang = distutils.util.split_quoted((Line.split(u"//")[0]))
if len(Lang) != 3:
try:
FileIn = UniFileClassObject.OpenUniFile(LongFilePath(File.Path))
except UnicodeError as X:
EdkLogger.error("build", FILE_READ_FAILURE, "File read failure: %s" % str(X), ExtraData=File);
except:
EdkLogger.error("build", FILE_OPEN_FAILURE, ExtraData=File);
LineNo = GetLineNo(FileIn, Line, False)
EdkLogger.error("Unicode File Parser", PARSER_ERROR, "Wrong language definition",
ExtraData="""%s\n\t*Correct format is like '#langdef en-US "English"'""" % Line, File=File, Line=LineNo)
else:
LangName = GetLanguageCode(Lang[1], self.IsCompatibleMode, self.File)
LangPrintName = Lang[2]
IsLangInDef = False
for Item in self.LanguageDef:
if Item[0] == LangName:
IsLangInDef = True
break;
if not IsLangInDef:
self.LanguageDef.append([LangName, LangPrintName])
#
# Add language string
#
self.AddStringToList(u'$LANGUAGE_NAME', LangName, LangName, 0, True, Index=0)
self.AddStringToList(u'$PRINTABLE_LANGUAGE_NAME', LangName, LangPrintName, 1, True, Index=1)
if not IsLangInDef:
#
# The found STRING tokens will be added into new language string list
# so that the unique STRING identifier is reserved for all languages in the package list.
#
FirstLangName = self.LanguageDef[0][0]
if LangName != FirstLangName:
for Index in range (2, len (self.OrderedStringList[FirstLangName])):
Item = self.OrderedStringList[FirstLangName][Index]
if Item.UseOtherLangDef != '':
OtherLang = Item.UseOtherLangDef
else:
OtherLang = FirstLangName
self.OrderedStringList[LangName].append (StringDefClassObject(Item.StringName, '', Item.Referenced, Item.Token, OtherLang))
self.OrderedStringDict[LangName][Item.StringName] = len(self.OrderedStringList[LangName]) - 1
return True
@staticmethod
def OpenUniFile(FileName):
#
# Read file
#
try:
UniFile = open(FileName, mode='rb')
FileIn = UniFile.read()
UniFile.close()
except:
EdkLogger.Error("build", FILE_OPEN_FAILURE, ExtraData=File)
#
# Detect Byte Order Mark at beginning of file. Default to UTF-8
#
Encoding = 'utf-8'
if (FileIn.startswith(codecs.BOM_UTF16_BE) or
FileIn.startswith(codecs.BOM_UTF16_LE)):
Encoding = 'utf-16'
UniFileClassObject.VerifyUcs2Data(FileIn, FileName, Encoding)
UniFile = BytesIO(FileIn)
Info = codecs.lookup(Encoding)
(Reader, Writer) = (Info.streamreader, Info.streamwriter)
return codecs.StreamReaderWriter(UniFile, Reader, Writer)
@staticmethod
def VerifyUcs2Data(FileIn, FileName, Encoding):
Ucs2Info = codecs.lookup('ucs-2')
#
# Convert to unicode
#
try:
FileDecoded = codecs.decode(FileIn, Encoding)
Ucs2Info.encode(FileDecoded)
except:
UniFile = BytesIO(FileIn)
Info = codecs.lookup(Encoding)
(Reader, Writer) = (Info.streamreader, Info.streamwriter)
File = codecs.StreamReaderWriter(UniFile, Reader, Writer)
LineNumber = 0
ErrMsg = lambda Encoding, LineNumber: \
'%s contains invalid %s characters on line %d.' % \
(FileName, Encoding, LineNumber)
while True:
LineNumber = LineNumber + 1
try:
Line = File.readline()
if Line == '':
EdkLogger.error('Unicode File Parser', PARSER_ERROR,
ErrMsg(Encoding, LineNumber))
Ucs2Info.encode(Line)
except:
EdkLogger.error('Unicode File Parser', PARSER_ERROR,
ErrMsg('UCS-2', LineNumber))
#
# Get String name and value
#
def GetStringObject(self, Item):
Language = ''
Value = ''
Name = Item.split()[1]
# Check the string name
if Name != '':
MatchString = gIdentifierPattern.match(Name)
if MatchString is None:
EdkLogger.error('Unicode File Parser', FORMAT_INVALID, 'The string token name %s defined in UNI file %s contains the invalid character.' % (Name, self.File))
LanguageList = Item.split(u'#language ')
for IndexI in range(len(LanguageList)):
if IndexI == 0:
continue
else:
Language = LanguageList[IndexI].split()[0]
Value = LanguageList[IndexI][LanguageList[IndexI].find(u'\"') + len(u'\"') : LanguageList[IndexI].rfind(u'\"')] #.replace(u'\r\n', u'')
Language = GetLanguageCode(Language, self.IsCompatibleMode, self.File)
self.AddStringToList(Name, Language, Value)
#
# Get include file list and load them
#
def GetIncludeFile(self, Item, Dir):
FileName = Item[Item.find(u'#include ') + len(u'#include ') :Item.find(u' ', len(u'#include '))][1:-1]
self.LoadUniFile(FileName)
#
# Pre-process before parse .uni file
#
def PreProcess(self, File):
try:
FileIn = UniFileClassObject.OpenUniFile(LongFilePath(File.Path))
except UnicodeError as X:
EdkLogger.error("build", FILE_READ_FAILURE, "File read failure: %s" % str(X), ExtraData=File.Path);
except OSError:
EdkLogger.error("Unicode File Parser", FILE_NOT_FOUND, ExtraData=File.Path)
except:
EdkLogger.error("build", FILE_OPEN_FAILURE, ExtraData=File.Path);
Lines = []
#
# Use unique identifier
#
for Line in FileIn:
Line = Line.strip()
Line = Line.replace(u'\\\\', BACK_SLASH_PLACEHOLDER)
Line = StripComments(Line)
#
# Ignore empty line
#
if len(Line) == 0:
continue
Line = Line.replace(u'/langdef', u'#langdef')
Line = Line.replace(u'/string', u'#string')
Line = Line.replace(u'/language', u'#language')
Line = Line.replace(u'/include', u'#include')
Line = Line.replace(UNICODE_WIDE_CHAR, WIDE_CHAR)
Line = Line.replace(UNICODE_NARROW_CHAR, NARROW_CHAR)
Line = Line.replace(UNICODE_NON_BREAKING_CHAR, NON_BREAKING_CHAR)
Line = Line.replace(u'\\r\\n', CR + LF)
Line = Line.replace(u'\\n', CR + LF)
Line = Line.replace(u'\\r', CR)
Line = Line.replace(u'\\t', u' ')
Line = Line.replace(u'\t', u' ')
Line = Line.replace(u'\\"', u'"')
Line = Line.replace(u"\\'", u"'")
Line = Line.replace(BACK_SLASH_PLACEHOLDER, u'\\')
StartPos = Line.find(u'\\x')
while (StartPos != -1):
EndPos = Line.find(u'\\', StartPos + 1, StartPos + 7)
if EndPos != -1 and EndPos - StartPos == 6 :
if g4HexChar.match(Line[StartPos + 2 : EndPos], re.UNICODE):
EndStr = Line[EndPos: ]
UniStr = Line[StartPos + 2: EndPos]
if EndStr.startswith(u'\\x') and len(EndStr) >= 7:
if EndStr[6] == u'\\' and g4HexChar.match(EndStr[2 : 6], re.UNICODE):
Line = Line[0 : StartPos] + UniStr + EndStr
else:
Line = Line[0 : StartPos] + UniStr + EndStr[1:]
StartPos = Line.find(u'\\x', StartPos + 1)
IncList = gIncludePattern.findall(Line)
if len(IncList) == 1:
for Dir in [File.Dir] + self.IncludePathList:
IncFile = PathClass(str(IncList[0]), Dir)
if os.path.isfile(IncFile.Path):
Lines.extend(self.PreProcess(IncFile))
break
else:
EdkLogger.error("Unicode File Parser", FILE_NOT_FOUND, Message="Cannot find include file", ExtraData=str(IncList[0]))
continue
Lines.append(Line)
return Lines
#
# Load a .uni file
#
def LoadUniFile(self, File = None):
if File is None:
EdkLogger.error("Unicode File Parser", PARSER_ERROR, 'No unicode file is given')
self.File = File
#
# Process special char in file
#
Lines = self.PreProcess(File)
#
# Get Unicode Information
#
for IndexI in range(len(Lines)):
Line = Lines[IndexI]
if (IndexI + 1) < len(Lines):
SecondLine = Lines[IndexI + 1]
if (IndexI + 2) < len(Lines):
ThirdLine = Lines[IndexI + 2]
#
# Get Language def information
#
if Line.find(u'#langdef ') >= 0:
self.GetLangDef(File, Line)
continue
Name = ''
Language = ''
Value = ''
#
# Get string def information format 1 as below
#
# #string MY_STRING_1
# #language eng
# My first English string line 1
# My first English string line 2
# #string MY_STRING_1
# #language spa
# Mi segunda secuencia 1
# Mi segunda secuencia 2
#
if Line.find(u'#string ') >= 0 and Line.find(u'#language ') < 0 and \
SecondLine.find(u'#string ') < 0 and SecondLine.find(u'#language ') >= 0 and \
ThirdLine.find(u'#string ') < 0 and ThirdLine.find(u'#language ') < 0:
Name = Line[Line.find(u'#string ') + len(u'#string ') : ].strip(' ')
Language = SecondLine[SecondLine.find(u'#language ') + len(u'#language ') : ].strip(' ')
for IndexJ in range(IndexI + 2, len(Lines)):
if Lines[IndexJ].find(u'#string ') < 0 and Lines[IndexJ].find(u'#language ') < 0:
Value = Value + Lines[IndexJ]
else:
IndexI = IndexJ
break
# Value = Value.replace(u'\r\n', u'')
Language = GetLanguageCode(Language, self.IsCompatibleMode, self.File)
# Check the string name
if not self.IsCompatibleMode and Name != '':
MatchString = gIdentifierPattern.match(Name)
if MatchString is None:
EdkLogger.error('Unicode File Parser', FORMAT_INVALID, 'The string token name %s defined in UNI file %s contains the invalid character.' % (Name, self.File))
self.AddStringToList(Name, Language, Value)
continue
#
# Get string def information format 2 as below
#
# #string MY_STRING_1 #language eng "My first English string line 1"
# "My first English string line 2"
# #language spa "Mi segunda secuencia 1"
# "Mi segunda secuencia 2"
# #string MY_STRING_2 #language eng "My first English string line 1"
# "My first English string line 2"
# #string MY_STRING_2 #language spa "Mi segunda secuencia 1"
# "Mi segunda secuencia 2"
#
if Line.find(u'#string ') >= 0 and Line.find(u'#language ') >= 0:
StringItem = Line
for IndexJ in range(IndexI + 1, len(Lines)):
if Lines[IndexJ].find(u'#string ') >= 0 and Lines[IndexJ].find(u'#language ') >= 0:
IndexI = IndexJ
break
elif Lines[IndexJ].find(u'#string ') < 0 and Lines[IndexJ].find(u'#language ') >= 0:
StringItem = StringItem + Lines[IndexJ]
elif Lines[IndexJ].count(u'\"') >= 2:
StringItem = StringItem[ : StringItem.rfind(u'\"')] + Lines[IndexJ][Lines[IndexJ].find(u'\"') + len(u'\"') : ]
self.GetStringObject(StringItem)
continue
#
# Load multiple .uni files
#
def LoadUniFiles(self, FileList):
if len(FileList) > 0:
for File in FileList:
self.LoadUniFile(File)
#
# Add a string to list
#
def AddStringToList(self, Name, Language, Value, Token = None, Referenced = False, UseOtherLangDef = '', Index = -1):
for LangNameItem in self.LanguageDef:
if Language == LangNameItem[0]:
break
else:
EdkLogger.error('Unicode File Parser', FORMAT_NOT_SUPPORTED, "The language '%s' for %s is not defined in Unicode file %s." \
% (Language, Name, self.File))
if Language not in self.OrderedStringList:
self.OrderedStringList[Language] = []
self.OrderedStringDict[Language] = {}
IsAdded = True
if Name in self.OrderedStringDict[Language]:
IsAdded = False
if Value is not None:
ItemIndexInList = self.OrderedStringDict[Language][Name]
Item = self.OrderedStringList[Language][ItemIndexInList]
Item.UpdateValue(Value)
Item.UseOtherLangDef = ''
if IsAdded:
Token = len(self.OrderedStringList[Language])
if Index == -1:
self.OrderedStringList[Language].append(StringDefClassObject(Name, Value, Referenced, Token, UseOtherLangDef))
self.OrderedStringDict[Language][Name] = Token
for LangName in self.LanguageDef:
#
# New STRING token will be added into all language string lists.
# so that the unique STRING identifier is reserved for all languages in the package list.
#
if LangName[0] != Language:
if UseOtherLangDef != '':
OtherLangDef = UseOtherLangDef
else:
OtherLangDef = Language
self.OrderedStringList[LangName[0]].append(StringDefClassObject(Name, '', Referenced, Token, OtherLangDef))
self.OrderedStringDict[LangName[0]][Name] = len(self.OrderedStringList[LangName[0]]) - 1
else:
self.OrderedStringList[Language].insert(Index, StringDefClassObject(Name, Value, Referenced, Token, UseOtherLangDef))
self.OrderedStringDict[Language][Name] = Index
#
# Set the string as referenced
#
def SetStringReferenced(self, Name):
#
# String stoken are added in the same order in all language string lists.
# So, only update the status of string stoken in first language string list.
#
Lang = self.LanguageDef[0][0]
if Name in self.OrderedStringDict[Lang]:
ItemIndexInList = self.OrderedStringDict[Lang][Name]
Item = self.OrderedStringList[Lang][ItemIndexInList]
Item.Referenced = True
#
# Search the string in language definition by Name
#
def FindStringValue(self, Name, Lang):
if Name in self.OrderedStringDict[Lang]:
ItemIndexInList = self.OrderedStringDict[Lang][Name]
return self.OrderedStringList[Lang][ItemIndexInList]
return None
#
# Search the string in language definition by Token
#
def FindByToken(self, Token, Lang):
for Item in self.OrderedStringList[Lang]:
if Item.Token == Token:
return Item
return None
#
# Re-order strings and re-generate tokens
#
def ReToken(self):
#
# Retoken all language strings according to the status of string stoken in the first language string.
#
FirstLangName = self.LanguageDef[0][0]
# Convert the OrderedStringList to be OrderedStringListByToken in order to faciliate future search by token
for LangNameItem in self.LanguageDef:
self.OrderedStringListByToken[LangNameItem[0]] = {}
#
# Use small token for all referred string stoken.
#
RefToken = 0
for Index in range (0, len (self.OrderedStringList[FirstLangName])):
FirstLangItem = self.OrderedStringList[FirstLangName][Index]
if FirstLangItem.Referenced == True:
for LangNameItem in self.LanguageDef:
LangName = LangNameItem[0]
OtherLangItem = self.OrderedStringList[LangName][Index]
OtherLangItem.Referenced = True
OtherLangItem.Token = RefToken
self.OrderedStringListByToken[LangName][OtherLangItem.Token] = OtherLangItem
RefToken = RefToken + 1
#
# Use big token for all unreferred string stoken.
#
UnRefToken = 0
for Index in range (0, len (self.OrderedStringList[FirstLangName])):
FirstLangItem = self.OrderedStringList[FirstLangName][Index]
if FirstLangItem.Referenced == False:
for LangNameItem in self.LanguageDef:
LangName = LangNameItem[0]
OtherLangItem = self.OrderedStringList[LangName][Index]
OtherLangItem.Token = RefToken + UnRefToken
self.OrderedStringListByToken[LangName][OtherLangItem.Token] = OtherLangItem
UnRefToken = UnRefToken + 1
#
# Show the instance itself
#
def ShowMe(self):
print(self.LanguageDef)
#print self.OrderedStringList
for Item in self.OrderedStringList:
print(Item)
for Member in self.OrderedStringList[Item]:
print(str(Member))
# This acts like the main() function for the script, unless it is 'import'ed into another
# script.
if __name__ == '__main__':
EdkLogger.Initialize()
EdkLogger.SetLevel(EdkLogger.DEBUG_0)
a = UniFileClassObject([PathClass("C:\\Edk\\Strings.uni"), PathClass("C:\\Edk\\Strings2.uni")])
a.ReToken()
a.ShowMe()
|
[
"maurice.ma@intel.com"
] |
maurice.ma@intel.com
|
ce95dbf6fcaaaf9619bb3af852fd822f2f11193d
|
aa74d22568d80866488a321026c369a12346484f
|
/microblog/app/venv/bin/flask
|
ffb649ae118d9a9f02968aa474a905ff4e264b54
|
[] |
no_license
|
nptravis/python-studies
|
0ca5e3d804beb2b9b7e3484606753324c9151bab
|
d649ac614bf9efdce1cc50e015f9252d1eba371c
|
refs/heads/master
| 2021-09-03T13:18:27.621292
| 2018-01-09T09:43:39
| 2018-01-09T09:43:39
| 114,952,074
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 268
|
#!/Users/Nic/Documents/projects/cs50/python/microblog/app/venv/bin/python3
# -*- coding: utf-8 -*-
import re
import sys
from flask.cli import main
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(main())
|
[
"nptravis@yahoo.com"
] |
nptravis@yahoo.com
|
|
9148b220bb576626f27c0f2cfb3cb25ebbcd7139
|
ad13583673551857615498b9605d9dcab63bb2c3
|
/output/models/ms_data/datatypes/facets/byte/byte_max_inclusive001_xsd/__init__.py
|
0444a6966ba5abae09b921e38485930982799bb6
|
[
"MIT"
] |
permissive
|
tefra/xsdata-w3c-tests
|
397180205a735b06170aa188f1f39451d2089815
|
081d0908382a0e0b29c8ee9caca6f1c0e36dd6db
|
refs/heads/main
| 2023-08-03T04:25:37.841917
| 2023-07-29T17:10:13
| 2023-07-30T12:11:13
| 239,622,251
| 2
| 0
|
MIT
| 2023-07-25T14:19:04
| 2020-02-10T21:59:47
|
Python
|
UTF-8
|
Python
| false
| false
| 173
|
py
|
from output.models.ms_data.datatypes.facets.byte.byte_max_inclusive001_xsd.byte_max_inclusive001 import (
FooType,
Test,
)
__all__ = [
"FooType",
"Test",
]
|
[
"tsoulloftas@gmail.com"
] |
tsoulloftas@gmail.com
|
61c9e42c66d7a8db5e32e7b93993184e39839ae7
|
69310bc4a04d4f9cbbb27a4c322c5d7d8fb3d0c3
|
/Tests/test_PopulationSample.py
|
bd4a0e308ae4df676de830ec8d97e519ca0cd2d5
|
[] |
no_license
|
jaylakhani14/statcalc
|
15ea52e787cb75cd767d6e3564fcefd7d06d7536
|
e28a233c06ff236b157494d2df31dea15c8dc328
|
refs/heads/master
| 2023-03-31T19:39:41.400843
| 2021-03-23T01:16:08
| 2021-03-23T01:16:08
| 344,951,449
| 1
| 3
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 676
|
py
|
import unittest
import numpy as np
import scipy
from PopulationSampling.simpleRandom import Sample
from PopulationSampling.confidence import Confidence
class MyTestCase(unittest.TestCase):
def test_simple_random_sample(self):
mylist = ["apple", "banana", "cherry"]
Sample.sample(mylist, 2)
def test_confidence_interval(self):
sample = [1, 2, 3, 4, 5, 6, 7, 8, 9]
c = 0.95
df = len(sample) - 1
sample_mean = np.mean(sample)
sample_standard_error = scipy.stats.sem(sample)
Confidence.mean_confidence_interval(c, df, sample_mean, sample_standard_error)
if __name__ == '__main__':
unittest.main()
|
[
"fjt7@njit.edu"
] |
fjt7@njit.edu
|
8c891499686c46192eb6e8fdbff3d1ff45edece6
|
d40b1042ab0c3506a35c65889f0df73405fb66b0
|
/namespaces.py
|
639b3bac194dbcc687399605a172bbb5c8b7d97f
|
[] |
no_license
|
juanique/ucursos-rdf
|
18a7e92789eb5f035e798d12128458bd6133af57
|
93c6c78876b99ecb253e0e98144e11ec39d9903e
|
refs/heads/master
| 2020-05-31T06:24:25.110260
| 2012-05-03T03:01:52
| 2012-05-03T03:01:52
| 4,177,485
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 588
|
py
|
from rdflib import Namespace
NFO = Namespace('http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#')
NIE = Namespace('http://www.semanticdesktop.org/ontologies/2007/01/19/nie#')
RDFS = Namespace('http://www.w3.org/2000/01/rdf-schema#')
RDF = Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#')
CLIP = Namespace('http://www.rdfclip.com/resource/')
CLIPS = Namespace('http://www.rdfclip.com/schema#')
XMLS = Namespace('http://www.w3.org/2001/XMLSchema#')
UCHILE = Namespace('http://www.rdfclip.com/resources/uchile#')
UCHILES = Namespace('http://www.rdfclip.com/schema/uchile#')
|
[
"juanique@ubuntu.(none)"
] |
juanique@ubuntu.(none)
|
ca93607b79207cc78004efd8c339bc2ab7e9d567
|
6b2a8dd202fdce77c971c412717e305e1caaac51
|
/solutions_5670465267826688_0/Python/yagao0o/dijkstra.py
|
96ca68f0bdc39cf5943ae362656074c360209c95
|
[] |
no_license
|
alexandraback/datacollection
|
0bc67a9ace00abbc843f4912562f3a064992e0e9
|
076a7bc7693f3abf07bfdbdac838cb4ef65ccfcf
|
refs/heads/master
| 2021-01-24T18:27:24.417992
| 2017-05-23T09:23:38
| 2017-05-23T09:23:38
| 84,313,442
| 2
| 4
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,207
|
py
|
# author: yagoa0o
# date : 2015/04/11
class Solution():
multi_square = {'1': {'1': '1', 'i': 'i', 'j': 'j', 'k': 'k'},
'i': {'1': 'i', 'i': '-1', 'j': 'k', 'k': '-j'},
'j': {'1': 'j', 'i': '-k', 'j': '-1', 'k': 'i'},
'k': {'1': 'k', 'i': 'j', 'j': '-i', 'k': '-1'}}
def get_result(self, input_file_name, output_file_name):
infile = open(input_file_name)
outfile = open(output_file_name, "w+")
total = int(infile.readline())
# main procedure
for i in range(total):
input_parms = infile.readline().split()
l = int(input_parms[0])
x = int(input_parms[1])
characters = infile.readline()
result = 'Yes'
if x % 4 != 0 and l > 1:
#count characters
cal_result = '1'
cal_string = characters[:l] * (x % 4 + 8) if x > 12 else characters[:l] * x
got_i = False
got_j = False
for char in cal_string:
cal_result = self.multiply(cal_result, char)
if (not got_i) and cal_result == 'i':
got_i = True
if (not got_j) and got_i and cal_result == 'k':
got_j = True
if cal_result == '-1' and got_i and got_j:
result = 'YES'
else:
result = 'NO'
else:
result = 'NO'
outfile.write('Case #' + str(i + 1) + ': ' + result + '\n')
infile.close()
outfile.close()
return False
def multiply(self, a, b):
is_negative = False
is_negative = is_negative != (a[0] == '-')
is_negative = is_negative != (b[0] == '-')
result = self.multi_square[a[-1]][b[-1]]
is_negative = is_negative != (result[0] == '-')
if not is_negative:
return result[-1]
else:
return '-' + result[-1]
solu = Solution()
file_name = 'C-small-attempt2'
solu.get_result(file_name + '.in', file_name + '.out')
|
[
"eewestman@gmail.com"
] |
eewestman@gmail.com
|
a6db5964253e81c368fcf13b0b31ecd3de6e3376
|
4eeb7257a706967a049ea0e020bdd8d05f987c21
|
/working/kub-nginx.py
|
f5b3cb82ed777fedc2d42f605087d169d7903549
|
[] |
no_license
|
monolive/airflow-dags
|
6e1451261f370ec9707a3226ad2ea4498d628faa
|
e1191d2193ca428f331c7ac0d09c89056893f891
|
refs/heads/master
| 2020-04-10T13:32:33.789760
| 2019-02-25T08:59:57
| 2019-02-25T08:59:57
| 161,053,387
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,569
|
py
|
#from airflow.contrib.operators import KubernetesOperator
from datetime import datetime, timedelta
from airflow import DAG
from airflow.operators.dummy_operator import DummyOperator
from airflow.contrib.operators.kubernetes_pod_operator import KubernetesPodOperator
from airflow.contrib.kubernetes.secret import Secret
seven_days_ago = datetime.combine(datetime.today() - timedelta(7), datetime.min.time())
default_args = {
'owner': 'airflow',
'depends_on_past': False,
'start_date': seven_days_ago,
'email': ['airflow@example.com'],
'email_on_failure': False,
'email_on_retry': False,
'retries': 1,
'retry_delay': timedelta(minutes=5),
# 'queue': 'bash_queue',
'pool': 'kube',
# 'priority_weight': 10,
# 'end_date': datetime(2016, 1, 1),
}
dag = DAG( 'nginx', default_args=default_args, schedule_interval=timedelta(days=1), dagrun_timeout=timedelta(minutes=5),)
start = DummyOperator(task_id='run_this_first', dag=dag)
boom = KubernetesPodOperator(namespace='airflow',
image="nginx:latest",
image_pull_policy="Always",
# cmds=["bash","-cx"],
# arguments=["echo","10"],
name="nginx",
task_id="startNginx",
is_delete_operator_pod=True,
hostnetwork=False,
dag=dag,
in_cluster=False,
)
boom.set_upstream(start)
|
[
"Olivier.Renault@vanquisbank.co.uk"
] |
Olivier.Renault@vanquisbank.co.uk
|
5a42411bbb622d7b2f01c712aad314bdfc8d9c6f
|
953b15ef3ff7d2a1b12d86dbf13f15af7eb8aa4a
|
/a3c_training_thread.py
|
a050c771ade48fcefdb98c1de9d1693718ecc548
|
[
"Apache-2.0"
] |
permissive
|
MightyChaos/async_transfer_rl
|
2fe213dda375f3df165dbe277aa656319997eb34
|
000601773d2e226848a49eb71cfc9d89cc6df9bb
|
refs/heads/master
| 2021-01-20T04:47:55.741247
| 2017-04-29T03:16:10
| 2017-04-29T03:16:10
| 89,735,265
| 0
| 0
| null | 2017-04-28T18:46:26
| 2017-04-28T18:46:26
| null |
UTF-8
|
Python
| false
| false
| 6,143
|
py
|
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
import random
import time
import sys
from game_state import GameState
from game_state import ACTION_SIZE
from game_ac_network import GameACFFNetwork, GameACLSTMNetwork
from constants import GAMMA
from constants import LOCAL_T_MAX
from constants import ENTROPY_BETA
from constants import USE_LSTM
LOG_INTERVAL = 100
PERFORMANCE_LOG_INTERVAL = 1000
class A3CTrainingThread(object):
def __init__(self,
thread_index,
global_network,
initial_learning_rate,
learning_rate_input,
grad_applier,
max_global_time_step,
device):
self.thread_index = thread_index
self.learning_rate_input = learning_rate_input
self.max_global_time_step = max_global_time_step
if USE_LSTM:
self.local_network = GameACLSTMNetwork(ACTION_SIZE, thread_index, device)
else:
self.local_network = GameACFFNetwork(ACTION_SIZE, thread_index, device)
self.local_network.prepare_loss(ENTROPY_BETA)
with tf.device(device):
var_refs = [v._ref() for v in self.local_network.get_vars()]
self.gradients = tf.gradients(
self.local_network.total_loss, var_refs,
gate_gradients=False,
aggregation_method=None,
colocate_gradients_with_ops=False)
self.apply_gradients = grad_applier.apply_gradients(
global_network.get_vars(),
self.gradients )
self.sync = self.local_network.sync_from(global_network)
self.game_state = GameState(113 * thread_index)
self.local_t = 0
self.initial_learning_rate = initial_learning_rate
self.episode_reward = 0
# variable controling log output
self.prev_local_t = 0
def _anneal_learning_rate(self, global_time_step):
learning_rate = self.initial_learning_rate * (self.max_global_time_step - global_time_step) / self.max_global_time_step
if learning_rate < 0.0:
learning_rate = 0.0
return learning_rate
def choose_action(self, pi_values):
return np.random.choice(range(len(pi_values)), p=pi_values)
def _record_score(self, sess, summary_writer, summary_op, score_input, score, global_t):
summary_str = sess.run(summary_op, feed_dict={
score_input: score
})
summary_writer.add_summary(summary_str, global_t)
summary_writer.flush()
def set_start_time(self, start_time):
self.start_time = start_time
def process(self, sess, global_t, summary_writer, summary_op, score_input):
states = []
actions = []
rewards = []
values = []
terminal_end = False
# copy weights from shared to local
sess.run( self.sync )
start_local_t = self.local_t
if USE_LSTM:
start_lstm_state = self.local_network.lstm_state_out
# t_max times loop
for i in range(LOCAL_T_MAX):
pi_, value_ = self.local_network.run_policy_and_value(sess, self.game_state.s_t)
action = self.choose_action(pi_)
states.append(self.game_state.s_t)
actions.append(action)
values.append(value_)
if (self.thread_index == 0) and (self.local_t % LOG_INTERVAL == 0):
print("local_iter={0} pi={1} V={2}".format(i, pi_, value_))
#print(" V={}".format(value_))
# process game
self.game_state.process(action)
# receive game result
reward = self.game_state.reward
terminal = self.game_state.terminal
self.episode_reward += reward
# clip reward
rewards.append( np.clip(reward, -1, 1) )
self.local_t += 1
# s_t1 -> s_t
self.game_state.update()
if terminal:
terminal_end = True
print("score={}".format(self.episode_reward))
self._record_score(sess, summary_writer, summary_op, score_input,
self.episode_reward, global_t)
self.episode_reward = 0
self.game_state.reset()
if USE_LSTM:
self.local_network.reset_state()
break
R = 0.0
if not terminal_end:
R = self.local_network.run_value(sess, self.game_state.s_t)
actions.reverse()
states.reverse()
rewards.reverse()
values.reverse()
batch_si = []
batch_a = []
batch_td = []
batch_R = []
# compute and accmulate gradients
for(ai, ri, si, Vi) in zip(actions, rewards, states, values):
R = ri + GAMMA * R
td = R - Vi
a = np.zeros([ACTION_SIZE])
a[ai] = 1
batch_si.append(si)
batch_a.append(a)
batch_td.append(td)
batch_R.append(R)
cur_learning_rate = self._anneal_learning_rate(global_t)
if USE_LSTM:
batch_si.reverse()
batch_a.reverse()
batch_td.reverse()
batch_R.reverse()
sess.run( self.apply_gradients,
feed_dict = {
self.local_network.s: batch_si,
self.local_network.a: batch_a,
self.local_network.td: batch_td,
self.local_network.r: batch_R,
self.local_network.initial_lstm_state: start_lstm_state,
self.local_network.step_size : [len(batch_a)],
self.learning_rate_input: cur_learning_rate } )
else:
sess.run( self.apply_gradients,
feed_dict = {
self.local_network.s: batch_si,
self.local_network.a: batch_a,
self.local_network.td: batch_td,
self.local_network.r: batch_R,
self.learning_rate_input: cur_learning_rate} )
if (self.thread_index == 0) and (self.local_t - self.prev_local_t >= PERFORMANCE_LOG_INTERVAL):
self.prev_local_t += PERFORMANCE_LOG_INTERVAL
elapsed_time = time.time() - self.start_time
steps_per_sec = global_t / elapsed_time
print("### Performance : {} STEPS in {:.0f} sec. {:.0f} STEPS/sec. {:.2f}M STEPS/hour".format(
global_t, elapsed_time, steps_per_sec, steps_per_sec * 3600 / 1000000.))
# return advanced local step size
diff_local_t = self.local_t - start_local_t
return diff_local_t
|
[
"yangluonaluna@gmail.com"
] |
yangluonaluna@gmail.com
|
b9d57dfeaf96a51267c065beaf179dce02cef79a
|
d5905c424264e9376fb80871749865140fbd3fb1
|
/MPCNN-sentence-similarity-tensorflow/embedding.py
|
cdf6713bff57f004be2f5dcc433e2611a2f190a8
|
[] |
no_license
|
eric-seekas/sentence_similarity
|
456e29ecb53e63a6f0ab804acfc6e919e1a1458c
|
647e90b1c43ab838fe857f87d3a2d5364112ff9b
|
refs/heads/master
| 2021-02-08T18:20:45.443720
| 2018-05-22T10:50:17
| 2018-05-22T10:50:17
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,310
|
py
|
"""
A toolkit you may find useful for mapping sentences to embeddings.
Download and unzip the standard GloVe embeddings to use this.
Skip-thoughts use unigram/bigram information from the Children Book dataset.
"""
from __future__ import print_function
import numpy as np
class Embedder(object):
""" Generic embedding interface.
Required:
* w: dict mapping tokens to indices
* g: matrix with one row per token index
* N: embedding dimensionality
"""
def map_tokens(self, tokens, ndim=2):
""" for the given list of tokens, return a list of GloVe embeddings,
or a single plain bag-of-words average embedding if ndim=1.
Unseen words (that's actually *very* rare) are mapped to 0-vectors. """
gtokens = [self.g[self.w[t]] for t in tokens if t in self.w]
if not gtokens:
return np.zeros((1, self.N)) if ndim == 2 else np.zeros(self.N)
gtokens = np.array(gtokens)
if ndim == 2:
return gtokens
else:
return gtokens.mean(axis=0)
def map_set(self, ss, ndim=2):
""" apply map_tokens on a whole set of sentences """
return [self.map_tokens(s, ndim=ndim) for s in ss]
def map_jset(self, sj):
""" for a set of sentence emb indices, get per-token embeddings """
return self.g[sj]
def pad_set(self, ss, spad, N=None):
""" Given a set of sentences transformed to per-word embeddings
(using glove.map_set()), convert them to a 3D matrix with fixed
sentence sizes - padded or trimmed to spad embeddings per sentence.
Output is a tensor of shape (len(ss), spad, N).
To determine spad, use something like
np.sort([np.shape(s) for s in s0], axis=0)[-1000]
so that typically everything fits, but you don't go to absurd lengths
to accomodate outliers.
"""
ss2 = []
if N is None:
N = self.N
for s in ss:
if spad > s.shape[0]:
if s.ndim == 2:
s = np.vstack((s, np.zeros((spad - s.shape[0], N))))
else: # pad non-embeddings (e.g. toklabels) too
s = np.hstack((s, np.zeros(spad - s.shape[0])))
elif spad < s.shape[0]:
s = s[:spad]
ss2.append(s)
return np.array(ss2)
class GloVe(Embedder):
""" A GloVe dictionary and the associated N-dimensional vector space """
def __init__(self, N=50, glovepath='/media/jlan/E/Projects/nlp/数据集/glove.6B/glove.6B.%dd.txt'):
""" Load GloVe dictionary from the standard distributed text file.
Glovepath should contain %d, which is substituted for the embedding
dimension N. """
self.N = N
self.w = dict()
self.g = []
self.glovepath = glovepath % (N,)
# [0] must be a zero vector
self.g.append(np.zeros(self.N))
with open(self.glovepath, 'r') as f:
for line in f:
l = line.split()
word = l[0]
self.w[word] = len(self.g)
self.g.append(np.array(l[1:]).astype(float))
self.w['UKNOW'] = len(self.g)
self.g.append(np.zeros(self.N))
self.g = np.array(self.g, dtype='float32')
|
[
"cbj_love@126.com"
] |
cbj_love@126.com
|
fbc8f567fc64ca0f8626efc764da3297fb9e5918
|
b5a9d42f7ea5e26cd82b3be2b26c324d5da79ba1
|
/tensorflow/contrib/tensor_forest/hybrid/python/models/stochastic_soft_decisions_to_data_then_nn.py
|
e916a8734c524c83772576e38418e6667fa6b0c9
|
[
"Apache-2.0"
] |
permissive
|
uve/tensorflow
|
e48cb29f39ed24ee27e81afd1687960682e1fbef
|
e08079463bf43e5963acc41da1f57e95603f8080
|
refs/heads/master
| 2020-11-29T11:30:40.391232
| 2020-01-11T13:43:10
| 2020-01-11T13:43:10
| 230,088,347
| 0
| 0
|
Apache-2.0
| 2019-12-25T10:49:15
| 2019-12-25T10:49:14
| null |
UTF-8
|
Python
| false
| false
| 1,954
|
py
|
# Copyright 2016 The TensorFlow 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.
# ==============================================================================
"""A hybrid model that samples paths when training."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from tensorflow.contrib.tensor_forest.hybrid.python.layers import decisions_to_data
from tensorflow.contrib.tensor_forest.hybrid.python.layers import fully_connected
from tensorflow.contrib.tensor_forest.hybrid.python.models import hard_decisions_to_data_then_nn
from tensorflow.python.training import adagrad
class StochasticSoftDecisionsToDataThenNN(
hard_decisions_to_data_then_nn.HardDecisionsToDataThenNN):
"""A hybrid model that samples paths when training."""
def __init__(self,
params,
device_assigner=None,
optimizer_class=adagrad.AdagradOptimizer,
**kwargs):
super(StochasticSoftDecisionsToDataThenNN, self).__init__(
params,
device_assigner=device_assigner,
optimizer_class=optimizer_class,
**kwargs)
self.layers = [decisions_to_data.StochasticSoftDecisionsToDataLayer(
params, 0, device_assigner),
fully_connected.FullyConnectedLayer(
params, 1, device_assigner=device_assigner)]
|
[
"v-grniki@microsoft.com"
] |
v-grniki@microsoft.com
|
29ddf0ad878bb01613933dec9c0ea4d5d69f4d37
|
e88de870db4ed98a39a1e7661f4662ba9d465b84
|
/fixture/session.py
|
2ab29c2141001defd40b5ad6e7da6669a31fc3a5
|
[] |
no_license
|
TatianaMoskvina/PainPoints
|
f11c371115e21da284e3375581ff4a485b38e495
|
291782aab76bc7b7b1cbdd493a0837b25c65a92c
|
refs/heads/master
| 2020-04-13T04:02:43.248112
| 2019-01-24T05:59:02
| 2019-01-24T05:59:02
| 162,949,377
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,490
|
py
|
class SessionHelper:
def __init__(self, app):
self.app = app
def log_out(self):
# log out
wd = self.app.wd
wd.find_element_by_id("myProfile").click()
wd.find_element_by_link_text("Log Out").click()
def ensure_logout(self):
wd = self.app.wd
if self.is_logged_in():
self.log_out()
def is_logged_in(self):
wd = self.app.wd
return len(wd.find_elemens_by_link_text("myProfile")) > 0
def ensure_log_in(self, username):
wd = self.app.wd
if self.is_logged_in():
if self.is_logged_in_as(username):
return
else:
self.log_out()
def as_logged_in_as(self):
wd = self.app.wd
username_login = wd.find_element_by_css_selector("div.name").text
mass_of_username = username_login.split(' ')
for i in mass_of_username:
if i == 'CompanyOwner)':
return i
return i == "CompanyOwner)"
def log_in(self, username, password):
wd = self.app.wd
self.app.open_home_page()
wd.find_element_by_id("Email").clear()
wd.find_element_by_id("Email").send_keys("%s" % username)
wd.find_element_by_id("Password").clear()
wd.find_element_by_id("Password").send_keys("%s" % password)
wd.find_element_by_xpath( "(.//*[normalize-space(text()) and normalize-space(.)='Password'])[1]/following::input[2]").click()
|
[
"moskvina.tania.vit@gmail.com"
] |
moskvina.tania.vit@gmail.com
|
25a420ee9e5512309aafd20ed676820b038209ea
|
b86608b6de44642ed29cd88bba4acbbdd31a0b04
|
/tools/agile-machine-learning-api/codes/trainer/launch_demo.py
|
8bd90b27237627cf0a348cdc757db624b062bda7
|
[
"Apache-2.0"
] |
permissive
|
MCRen88/professional-services
|
a514a926dd23e3c4ac6dadb656faed22c3d91d5d
|
d7bc3b194159ffdb149c9507890bb1fbae7a8d88
|
refs/heads/master
| 2020-12-15T16:38:17.860940
| 2020-01-06T19:29:47
| 2020-01-06T19:29:47
| 235,181,173
| 1
| 0
|
Apache-2.0
| 2020-01-20T19:26:15
| 2020-01-20T19:26:14
| null |
UTF-8
|
Python
| false
| false
| 21,978
|
py
|
# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""End to End script draft."""
import argparse
import ast
import os
import time
import numpy as np
import six
import tensorflow as tf
from tensorflow.contrib.training.python.training import hparam
from input_pipeline_dask import InputReader, BasicStats, DatasetInput
from models import CannedModel, CustomModel
from utils.metric_utils import mean_acc, mar, my_auc, rmse
from utils.optimizer_utils import Optimizer
class Config(object):
"""
Creates a run config object for training an estimator.
Object to be initialized using default parameters or
can be parsed by the user.
"""
def __init__(
self,
model_dir=None,
tf_random_seed=None,
save_summary_steps=100,
save_checkpoints_steps=None,
save_checkpoints_secs=120,
session_config=None,
keep_checkpoint_max=5,
keep_checkpoint_every_n_hours=10000,
log_step_count_steps=100,
train_distribute=None):
"""Initializes the config object.
Arguments:
model_dir : string, directory where the checkpoints are stored
tf_random_seed : integer, seed to set for random initialization
save_summary_steps : integer, number of global steps to save summaries
save_checkpoints_steps ; integer, number of global steps to save checkpoints
save_checkpoints_secs : integer, number of seconds to save checkpoints
session_config : object, a config proto used to set session parameters
keep_checkpoint_max : integer, maximum number of checkpoints to be stored
keep_checkpoint_every_n_hours : integer, frequency of saving checkpoints
log_step_count_steps : integer, frequency of steps to log information
train_distribute : tf.distribute.Strategy object, distribution strategy for training
"""
self.model_dir = model_dir
self.tf_random_seed = tf_random_seed
self.save_summary_steps = save_summary_steps
self.save_checkpoints_steps = save_checkpoints_steps
self.save_checkpoints_secs = save_checkpoints_secs
self.session_config = session_config
self.keep_checkpoint_max = keep_checkpoint_max
self.keep_checkpoint_every_n_hours = keep_checkpoint_every_n_hours
self.log_step_count_steps = log_step_count_steps
self.train_distribute = train_distribute
def set_config(self):
"""
Sets the Run config object with the parameters parsed by the user
"""
self.RunConfig = tf.estimator.RunConfig(
model_dir=self.model_dir,
tf_random_seed=self.tf_random_seed,
save_summary_steps=self.save_summary_steps,
session_config=self.session_config,
save_checkpoints_steps=self.save_checkpoints_steps,
save_checkpoints_secs=self.save_checkpoints_secs,
keep_checkpoint_max=self.keep_checkpoint_max,
keep_checkpoint_every_n_hours=self.keep_checkpoint_every_n_hours,
log_step_count_steps=self.log_step_count_steps,
train_distribute=self.train_distribute)
def get_config(self):
"""
Get Config object with parameters parsed by the user
Returns: tf.estimator.RunConfig object for estimator training
"""
return self.RunConfig
def get_is_chief(self):
"""
Get _is_chief boolean from RunConfig object
Returns: tf.estimator.RunConfig object for estimator training
"""
return self.RunConfig._is_chief
def prep_input(
csv_path,
task_type,
target_var,
na_values,
column_names,
to_drop,
gcs_path,
data_type,
name):
"""
Preprocessing function for train and eval datasets.
Arguments:
csv_path : str, path of the csv file
task_type : string, ML task at hand, following options are expected
[classification, regression, clustering]
target_var : string, Name of the dependent/target variable
na_values : string, String by which the na values are represented in the data
column_names : string, Names of the columns passed in a text file
to_drop : list, Any redundant columns which can be dropped
gcs_path : boolean, Whether the csv is stored on google cloud storage
data_type : dict, dictionary containing the data type of all columns in format
{'a': 'float', 'b': 'object', 'c': 'int' }
name : str, name of the data being based [train, eval]
Returns:
df : dask.DataFrame object, dataframe containing cleaned data of the passed csv file
cols : list, list containing column names of the data
defaults : list, list containing defaults of the columns
mapped : dict, dictionary containing vocabulary of the categorical columns
mean : pandas.Series, pandas series containing mean values of continous columns
std_dev : pandas.Series, pandas series containing standard deviation values of continous columns
"""
inp = InputReader(
csv_path=csv_path,
task_type=task_type,
target_var=target_var,
na_values=na_values,
column_names=column_names,
to_drop=to_drop,
gcs_path=gcs_path,
data_type=data_type)
df, cols = inp.parse_csv_wrap()
stats = BasicStats()
df, mean, std_dev, defaults = stats.clean_data(
df=df,
target_var=inp.target_var,
task_type=task_type,
name=name)
mapped = stats.find_vocab(df=df)
mapped.pop(inp.target_var)
return df, cols, defaults, mapped, mean, std_dev
def create_deep_cols(feat_cols, name):
"""Creates embedding and indicator columns for canned DNNclassifier.
Arguments:
feat_cols : list, A list of feature column objects.
name : string, name of the task in hand
Returns:
A list of feature column objects.
"""
deep_cols = None
if name not in ['linearclassifier', 'linearregressor',
'polynomialclassifier', 'polynomialregressor']:
deep_cols = list()
for i in feat_cols:
if i.dtype == 'string':
i = tf.feature_column.indicator_column(i)
deep_cols.append(i)
return deep_cols
def none_or_str(value):
"""
Creates a nonetype argument from command line.
Arguments:
value : The keyword argument from command line
Returns:
None if the string none is found
"""
if value == 'None':
return None
return value
def convert_to_list(value):
"""
Creates a list argument from command line.
Arguments:
value : The keyword argument from command line
Returns:
None if the string none is found
list if the string is space seperated values is found
"""
if value == 'None':
return None
return value.split(' ')
def convert_to_dict(value):
"""
Creates a dict argument from command line.
Arguments:
value : The keyword argument from command line
Returns:
None if the string none is found
dict if the string is space seperated values is found
"""
if value == 'None':
return None
return ast.literal_eval(value)
def run_experiment(hparams):
"""
Arguments:
hparams : tf.contrib.training.HParams object, contains all the arguments
as a set of key value pairs
Sets up the experiment to be launched on cloud machine learning engine
"""
a = time.time()
_, csv_cols, csv_defaults, mapped, mean, std_dev = prep_input(
csv_path=hparams.train_csv_path,
task_type=hparams.task_type,
target_var=hparams.target_var,
na_values=hparams.na_values,
column_names=hparams.column_names,
to_drop=hparams.to_drop,
gcs_path=hparams.gcs_path,
data_type=hparams.data_type,
name='train')
_, _, _, _, _, _ = prep_input(
csv_path=hparams.eval_csv_path,
task_type=hparams.task_type,
target_var=hparams.target_var,
na_values=hparams.na_values,
column_names=hparams.column_names,
to_drop=hparams.to_drop,
gcs_path=hparams.gcs_path,
data_type=hparams.data_type,
name='eval')
data = DatasetInput(
num_epochs=hparams.num_epochs,
batch_size=hparams.batch_size,
buffer_size=hparams.buffer_size,
csv_defaults=csv_defaults,
csv_cols=csv_cols,
target_var=hparams.target_var,
task_type=hparams.task_type,
condition=hparams.condition)
feature_cols = data.create_feature_columns_wrap(
dictionary=mapped,
mean=mean,
std_dev=std_dev)
b = time.time()
tf.logging.info('Parse time is : %s', b - a)
if hparams.name == 'kmeanscluster':
def train_input():
return data.kmeans_input_fn('train')
def eval_input():
return data.kmeans_input_fn('eval')
else:
def train_input():
return data.input_fn('train')
def eval_input():
return data.input_fn('eval')
def json_serving_input_fn():
"""
Build the serving inputs.
Returns: Serving input function for JSON data
"""
inputs = {}
for feat in feature_cols:
inputs[feat.name] = tf.placeholder(
shape=[None], dtype=feat.dtype, name=feat.name)
return tf.estimator.export.ServingInputReceiver(inputs, inputs)
def parse_csv(rows_string_tensor):
"""
Takes the string input tensor and returns a dict of rank-2 tensors.
Arguments:
rows_string_tensor : tf.Tensor object, Tensor of the prediction datapoint
Returns:
features : tensor objects of features for inference
"""
columns = tf.decode_csv(
rows_string_tensor, record_defaults=csv_defaults)
features = dict(zip(csv_cols, columns))
for key, _ in six.iteritems(features):
features[key] = tf.expand_dims(features[key], -1)
return features
def csv_serving_input_fn():
"""
Build the serving inputs.
Returns: Serving input function for CSV data
"""
csv_row = tf.placeholder(
shape=[None],
dtype=tf.string)
features = parse_csv(rows_string_tensor=csv_row)
return tf.estimator.export.ServingInputReceiver(
features,
{'csv_row': csv_row})
serving_functions = {
'JSON': json_serving_input_fn,
'CSV': csv_serving_input_fn
}
config_obj = Config(
model_dir=hparams.job_dir,
tf_random_seed=hparams.seed,
save_summary_steps=hparams.save_summary_steps,
session_config=None,
save_checkpoints_secs=hparams.save_checkpoints_secs,
save_checkpoints_steps=hparams.save_checkpoints_steps,
keep_checkpoint_max=hparams.keep_checkpoint_max,
keep_checkpoint_every_n_hours=hparams.keep_checkpoint_every_n_hours,
log_step_count_steps=hparams.log_step_count_steps,
train_distribute=hparams.distribute_strategy)
config_obj.set_config()
config = config_obj.get_config()
opt = Optimizer()
def linear_optimizer():
return opt.set_opt_wrap(
hparams.lin_opt,
hparams.learning_rate,
hparams.lr_rate_decay)
def deep_optimizer():
return opt.set_opt_wrap(
hparams.deep_opt,
hparams.learning_rate,
hparams.lr_rate_decay)
def poly_optimizer():
return opt.set_opt_wrap(
hparams.poly_opt,
hparams.learning_rate,
hparams.lr_rate_decay)
deep_cols = create_deep_cols(feature_cols, hparams.name)
hidden_units = [hparams.hidden_units]
feature_names = list(csv_cols)
feature_names.remove(hparams.target_var)
if hparams.name not in ['polynomialclassifier', 'polynomialregressor']:
model = CannedModel(
model_name=hparams.name,
feature_columns=feature_cols,
deep_columns=deep_cols,
hidden_units=hidden_units,
n_classes=hparams.n_classes,
linear_optimizer=linear_optimizer,
dnn_optimizer=deep_optimizer,
activation_fn=hparams.activation_fn,
dropout=hparams.dropout,
batch_norm=hparams.batch_norm,
config=config)
else:
model = CustomModel(
model_name=hparams.name,
batch_size=hparams.batch_size,
optimizer=poly_optimizer,
model_dir=hparams.job_dir,
config=config,
feature_names=feature_names,
learning_rate=hparams.learning_rate)
def mean_acc_metric(labels, predictions):
"""
Defining mean per class accuracy metric
Arguments:
labels : labels of the data
predictions : prediction of the model
Returns: function defining mean per class accuracy metric
"""
return mean_acc(labels, predictions, hparams.n_classes)
estimator = model.build_model()
if data.task_type == 'classification' and hparams.n_classes == 2:
estimator = tf.contrib.estimator.add_metrics(estimator, my_auc)
elif hparams.n_classes > 2:
estimator = tf.contrib.estimator.add_metrics(
estimator, mean_acc_metric)
else:
estimator = tf.contrib.estimator.add_metrics(estimator, rmse)
estimator = tf.contrib.estimator.add_metrics(estimator, mar)
if hparams.early_stopping:
old_loss = np.inf
for _ in range(hparams.eval_times):
estimator.train(input_fn=train_input,
steps=hparams.train_steps // hparams.eval_times)
output = estimator.evaluate(
input_fn=eval_input, steps=hparams.eval_steps)
loss = output['loss']
if loss >= old_loss:
tf.logging.info(
'EARLY STOPPING....... LOSS SATURATED AT : %s', loss)
break
else:
old_loss = loss
else:
train_spec = tf.estimator.TrainSpec(
train_input,
hparams.train_steps)
eval_spec = tf.estimator.EvalSpec(
eval_input,
hparams.eval_steps,
throttle_secs=hparams.eval_freq)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
if config_obj.get_is_chief():
estimator.export_savedmodel(
hparams.export_dir,
serving_functions[hparams.export_format],
assets_extra={
'lime_explainer': '/tmp/lime_explainer'},
strip_default_attrs=False)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
'--train_csv_path',
type=convert_to_list,
help='CSV file path[s] either on local or GCS',
required=True)
parser.add_argument(
'--eval_csv_path',
help='CSV file path for model eval',
required=True)
parser.add_argument(
'--task_type',
help='Machine learning task at hand',
required=True)
parser.add_argument(
'--target_var',
help='Name of the target variable',
required=True)
parser.add_argument(
'--data_type',
help='schema of the input data',
type=convert_to_dict,
default=None)
parser.add_argument(
'--column_names',
type=none_or_str,
help='text file containing column names',
default=None)
parser.add_argument(
'--num_clusters',
type=int,
help='number of clusters',
default=3)
parser.add_argument(
'--to_drop',
type=convert_to_list,
help='list of columns that can be dropped',
default=None)
parser.add_argument(
'--na_values',
type=none_or_str,
help='string by which na values are represented',
default=None)
parser.add_argument(
'--condition',
type=none_or_str,
help='logic to turn the target variable into levels',
default=None)
parser.add_argument(
'--gcs_path',
help='Whether the csv is on GCS',
default=True)
parser.add_argument(
'--num_epochs',
help='number of epochs for dataset to repeat',
type=int,
default=50)
parser.add_argument(
'--batch_size',
help='batch size to train and eval the model',
type=int,
default=64)
parser.add_argument(
'--buffer_size',
help='buffer size for prefetch',
type=int,
default=64)
parser.add_argument(
'--n_classes',
help='number of levels in target var',
default=2,
type=int)
parser.add_argument(
'--train_steps',
help='number of steps to train the model',
type=int,
default=50000)
parser.add_argument(
'--eval_steps',
help='number of eval batches to run',
type=int,
default=100)
parser.add_argument(
'--job-dir',
help='directory to store model checkpoints',
type=str,
default='/temp')
parser.add_argument(
'--seed',
help='seed to set for random initialization',
default=None)
parser.add_argument(
'--save_summary_steps',
help='number of global steps to save summaries',
type=int,
default=100)
parser.add_argument(
'--save_checkpoints_steps',
help='number of global steps to save checkpoints',
type=int,
default=500)
parser.add_argument(
'--save_checkpoints_secs',
help='number of seconds after which to save checkpoints',
type=int,
default=None)
parser.add_argument(
'--keep_checkpoint_max',
help='max number of checkpoints to save',
type=int,
default=5)
parser.add_argument(
'--keep_checkpoint_every_n_hours',
help='save checkpoint frequency',
type=int,
default=10000)
parser.add_argument(
'--log_step_count_steps',
help='how frequently to log information',
type=int,
default=100)
parser.add_argument(
'--distribute_strategy',
help='distribution strategy to use for training',
type=none_or_str,
default=None)
# model params
parser.add_argument(
'--name',
help='name of the model you want to use',
required=True,
choices=['linearclassifier', 'linearregressor',
'dnnclassifier', 'dnnregresssor', 'combinedclassifier',
'combinedregressor', 'kmeanscluster'])
parser.add_argument(
'--hidden_units',
help='number of hidden units in each layer of dnn',
type=int,
default=64
)
parser.add_argument(
'--num_layers',
help='number of hidden layers',
type=int,
default=2)
parser.add_argument(
'--lin_opt',
help='optimizer to use for linear models',
type=str,
default='ftrl')
parser.add_argument(
'--deep_opt',
help='optimizer to use for NN models',
type=str,
default='adam')
parser.add_argument(
'--lr_rate_decay',
help='whether to use learninf=g rate decay',
type=bool,
default=False)
parser.add_argument(
'--activation_fn',
help='activation fn to use for hidden units',
default=tf.nn.relu)
parser.add_argument(
'--dropout',
help='dropout rate for hidden layers',
default=None)
parser.add_argument(
'--batch_norm',
help='whether to use batch norm for hidden layers',
default=False)
parser.add_argument(
'--learning_rate',
help='learning rate for model training',
type=float,
default=0.001)
parser.add_argument(
'--eval_freq',
help='frequency in seconds to trigger evaluation run',
type=int,
default=30)
parser.add_argument(
'--eval_times',
help='early stopping criteria',
type=int,
default=10)
parser.add_argument(
'--early_stopping',
help='how to define when model training should end',
type=bool,
default=False)
parser.add_argument(
'--export_dir',
help='Directory for storing the frozen graph',
type=str,
required=True)
parser.add_argument(
'--export_format',
help='Format for the serving inputs',
type=str,
default='JSON')
parser.add_argument(
'--logging_level',
help='Format for the serving inputs',
type=str,
default='INFO',
choices=['INFO', 'DEBUG', 'ERROR', 'FATAL', 'WARN'])
args = parser.parse_args()
hparams = hparam.HParams(**args.__dict__)
tf.logging.set_verbosity(hparams.logging_level)
run_experiment(hparams)
os.system('rm -r /tmp/*.csv')
|
[
"jferriero@google.com"
] |
jferriero@google.com
|
52ff178dec4c0fecc3a4ec0097dbff7f0a46b8ed
|
0062da4c92b6a621343347a36ee32128838c09ec
|
/hw6/hw66.py
|
d53ded6c0933a977859a413ec67f23285fc1ca50
|
[] |
no_license
|
Skotmak/Homeworks
|
d3bb39e1d6d960ec3ad1c5c74a0eb5508f1f1e15
|
071e3c3a9d1341b28dd3a4828788f422fd943367
|
refs/heads/master
| 2022-05-13T07:50:45.869093
| 2022-05-03T17:19:53
| 2022-05-03T17:19:53
| 226,465,012
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 599
|
py
|
class First:
color = "red"
form = "circle"
style = "cool"
def changecolor(self,newcolor):
self.color = newcolor
def changeform(self,newform):
self.form = newform
def changestyle(self,newstyle):
self.style = newstyle
class Second:
color = "red"
def changecolor(self, newcolor):
self.color = newcolor
obj1 = First()
obj2 = Second()
print (obj1.color, obj1.form, obj1.style)
print (obj2.color)
a=input("enter color: ")
obj1.changecolor(a)
if obj1.color == "green" :
obj2.changecolor("blue")
print (obj1.color)
print (obj2.color)
|
[
"belok9999@yandex.ru"
] |
belok9999@yandex.ru
|
9b3c43e2159eccae5ed0ba80f67a626831e04c62
|
722d8f2aa69095dbdbe32ecdeebb4bcf20e2ea3c
|
/tests/test_issue10_17.py
|
e54ddd56630de1e5e811d12e7ec3f3da0d804333
|
[] |
permissive
|
clach04/pyqrcodeNG
|
1bad85bea9c2a5ca9bcda8849e35af51f8e394f3
|
8033a915eca1946537002b8b271ea2cddb4e004b
|
refs/heads/master
| 2022-04-23T00:18:36.478138
| 2020-01-21T22:28:44
| 2020-01-21T22:28:44
| 259,402,644
| 0
| 0
|
BSD-3-Clause
| 2020-04-27T17:24:36
| 2020-04-27T17:24:35
| null |
UTF-8
|
Python
| false
| false
| 424
|
py
|
# -*- coding: utf-8 -*-
"""\
Tests against <https://github.com/mnooner256/pyqrcode/issues/17> and
<https://github.com/heuer/pyqrcode/issues/10>
Unicode issues.
"""
from __future__ import unicode_literals
import pyqrcodeng as pyqrcode
def test_issue_10_17():
qr = pyqrcode.create('John’s Pizza')
assert qr
assert 'binary' == qr.mode
if __name__ == '__main__':
import pytest
pytest.main([__file__])
|
[
"heuer@semagia.com"
] |
heuer@semagia.com
|
46a326cd6ade0459a980a6bbdfafd899baf525e5
|
0208cbf2f0ea3c5405f2f8e3e74367df3916b999
|
/venv/bin/easy_install-3.6
|
cb43565f07cca22102c5e0b7d32db2c448086c7c
|
[
"MIT"
] |
permissive
|
BHushanRathod/ecolibrium-assessment
|
aaa111ea7ba5e495f7deff5f2e59c2a7816dfd2e
|
b7a4f1ebb69094bcb0c2d39fc94df3cd93c73fb0
|
refs/heads/master
| 2022-05-02T14:45:36.088566
| 2021-07-12T10:20:51
| 2021-07-12T10:20:51
| 172,217,130
| 0
| 0
|
MIT
| 2022-04-22T21:01:35
| 2019-02-23T13:23:35
|
Python
|
UTF-8
|
Python
| false
| false
| 468
|
6
|
#!/Users/bhushan/Truso1.0/Experiment/ecolibrium_assessment/venv/bin/python
# EASY-INSTALL-ENTRY-SCRIPT: 'setuptools==39.1.0','console_scripts','easy_install-3.6'
__requires__ = 'setuptools==39.1.0'
import re
import sys
from pkg_resources import load_entry_point
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(
load_entry_point('setuptools==39.1.0', 'console_scripts', 'easy_install-3.6')()
)
|
[
"abhushanprathod@gmail.com"
] |
abhushanprathod@gmail.com
|
97c39494d2c4397abe0b8e90109bb32a2af8219e
|
6730a45a5dcf89b7e9868f0a88e47541a5f30dc6
|
/tests/task_stat/test.py
|
c7a34f168b428d9a9ce28b1724701f1d8398d95e
|
[
"BSD-2-Clause-Views",
"BSD-2-Clause"
] |
permissive
|
dontkme/rmats-turbo
|
def1ca43c88b9c22827ef9652420d71d12f0f11f
|
8a2ad659717a1ccd6dbecd593dc1370ba7c30621
|
refs/heads/master
| 2023-08-24T11:19:14.177599
| 2021-08-03T12:50:52
| 2021-08-03T12:50:52
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 35,997
|
py
|
import collections
import os.path
import shutil
import subprocess
import sys
import unittest
import tests.base_test
import tests.output_parser as output_parser
import tests.test_config
import tests.util
class Test(tests.base_test.BaseTest):
def setUp(self):
super().setUp()
self._test_base_dir = tests.test_config.TEST_BASE_DIR
self._test_dir = os.path.join(self._test_base_dir, 'task_stat')
self._generated_input_dir = os.path.join(self._test_dir,
'generated_input')
self._out_dir_all = os.path.join(self._test_dir, 'out_all')
self._tmp_dir_all = os.path.join(self._test_dir, 'tmp_all')
self._out_dir_select = os.path.join(self._test_dir, 'out_select')
self._tmp_dir_select = os.path.join(self._test_dir, 'tmp_select')
self._out_dir_just_se = os.path.join(self._test_dir, 'out_just_se')
self._tmp_dir_just_se = os.path.join(self._test_dir, 'tmp_just_se')
tests.util.recreate_dirs([
self._generated_input_dir, self._out_dir_all, self._tmp_dir_all,
self._out_dir_select, self._tmp_dir_select, self._out_dir_just_se,
self._tmp_dir_just_se,
self._command_output_dir()
])
self._read_type = 'paired'
self._read_length = 50
self._chromosome_length = 4000
self._sample_1_bams_path = os.path.join(self._generated_input_dir,
'b1.txt')
self._sample_2_bams_path = os.path.join(self._generated_input_dir,
'b2.txt')
sample_1_bam_replicate_template = os.path.join(
self._generated_input_dir, 'sample_1_rep_{}.bam')
sample_2_bam_replicate_template = os.path.join(
self._generated_input_dir, 'sample_2_rep_{}.bam')
self._sample_1_bams = self._create_sample_1_bams(
self._sample_1_bams_path, sample_1_bam_replicate_template)
self._sample_2_bams = self._create_sample_2_bams(
self._sample_2_bams_path, sample_2_bam_replicate_template)
self._gtf_path = os.path.join(self._generated_input_dir, 'test.gtf')
self._gtf = self._create_gtf_from_transcripts(
self._gtf_path, self._exons_by_transcript())
self._sub_steps = [
'statoff',
'selected_stat',
'just_se',
'deferred_stat',
]
self._sub_step = None
def test(self):
for sub_step in self._sub_steps:
self._sub_step = sub_step
self._setup_sub_step()
self._run_test()
def _command_output_dir(self):
return os.path.join(self._test_dir, 'command_output')
def _rmats_arguments(self):
if self._sub_step == 'statoff':
return [
'--gtf', self._gtf_path, '-t', self._read_type, '--readLength',
str(self._read_length), '--od', self._out_dir_all, '--tmp',
self._tmp_dir_all, '--b1', self._sample_1_bams_path, '--b2',
self._sample_2_bams_path, '--task', 'both', '--statoff'
]
if self._sub_step == 'selected_stat':
return [
'--od', self._out_dir_select, '--tmp', self._tmp_dir_select,
'--task', 'stat'
]
if self._sub_step == 'just_se':
return [
'--od', self._out_dir_just_se, '--tmp', self._tmp_dir_just_se,
'--task', 'stat'
]
if self._sub_step == 'deferred_stat':
return [
'--od', self._out_dir_all, '--tmp', self._tmp_dir_all,
'--task', 'stat'
]
return None
def _setup_sub_step(self):
if self._sub_step == 'selected_stat':
self._setup_selected_stat()
if self._sub_step == 'just_se':
self._setup_just_se()
def _setup_selected_stat(self):
self._prepare_stat_inputs(self._out_dir_select, self._out_dir_all, [1],
[0, 3])
def _setup_just_se(self):
orig_from_gtf = os.path.join(self._out_dir_all, 'fromGTF.SE.txt')
new_from_gtf = os.path.join(self._out_dir_just_se, 'fromGTF.SE.txt')
shutil.copy(orig_from_gtf, new_from_gtf)
orig_raw = os.path.join(self._out_dir_all, 'JC.raw.input.SE.txt')
new_raw = os.path.join(self._out_dir_just_se, 'JC.raw.input.SE.txt')
shutil.copy(orig_raw, new_raw)
def _create_sample_1_bams(self, sample_1_bams_path,
sample_1_replicate_template):
rep_1_bam_path = sample_1_replicate_template.format(1)
rep_1_bam = self._create_bam_from_paired_read_coords(
rep_1_bam_path, self._chromosome_length, self._read_length,
self._paired_read_coords_1_1())
rep_2_bam_path = sample_1_replicate_template.format(2)
rep_2_bam = self._create_bam_from_paired_read_coords(
rep_2_bam_path, self._chromosome_length, self._read_length,
self._paired_read_coords_1_2())
sample_1_bams = [rep_1_bam, rep_2_bam]
self._write_bams(sample_1_bams, sample_1_bams_path)
return sample_1_bams
def _create_sample_2_bams(self, sample_2_bams_path,
sample_2_replicate_template):
rep_1_bam_path = sample_2_replicate_template.format(1)
rep_1_bam = self._create_bam_from_paired_read_coords(
rep_1_bam_path, self._chromosome_length, self._read_length,
self._paired_read_coords_2_1())
rep_2_bam_path = sample_2_replicate_template.format(2)
rep_2_bam = self._create_bam_from_paired_read_coords(
rep_2_bam_path, self._chromosome_length, self._read_length,
self._paired_read_coords_2_2())
sample_2_bams = [rep_1_bam, rep_2_bam]
self._write_bams(sample_2_bams, sample_2_bams_path)
return sample_2_bams
def _exons_by_transcript(self):
return [
[(1, 100), (201, 300), (401, 500)], # SE 1
[(601, 700), (801, 900), (1001, 1100)], # SE 2
[(1201, 1300), (1401, 1500), (1801, 1900)], # MXE
[(1201, 1300), (1601, 1700), (1801, 1900)], # MXE
[(2001, 2100), (2301, 2400)], # A5SS
[(2001, 2200), (2301, 2400)], # A5SS
[(2501, 2600), (2701, 2900)], # A3SS
[(2501, 2600), (2801, 2900)], # A3SS
[(3001, 3100), (3201, 3300)], # RI
[(3001, 3300)], # RI
]
def _include_read_SE_1(self):
return ([[81, 100], [201, 300]], [[201, 300]])
def _skip_read_SE_1(self):
return ([[81, 100], [401, 500]], [[401, 500]])
def _include_read_SE_2(self):
return ([[681, 700], [801, 900]], [[801, 900]])
def _skip_read_SE_2(self):
return ([[681, 700], [1001, 1100]], [[1001, 1100]])
def _se_reads_from_counts(self, i1, s1, i2, s2):
return i1 * [self._include_read_SE_1()] + s1 * [
self._skip_read_SE_1()
] + i2 * [self._include_read_SE_2()] + s2 * [self._skip_read_SE_2()]
def _mxe_read_1(self):
return ([[1281, 1300], [1401, 1500]], [[1401, 1500]])
def _mxe_read_2(self):
return ([[1281, 1300], [1601, 1700]], [[1601, 1700]])
def _a5ss_read_1(self):
return ([[2081, 2100], [2301, 2400]], [[2301, 2400]])
def _a5ss_read_2(self):
return ([[2181, 2200], [2301, 2400]], [[2301, 2400]])
def _a3ss_read_1(self):
return ([[2581, 2600], [2701, 2900]], [[2701, 2900]])
def _a3ss_read_2(self):
return ([[2581, 2600], [2801, 2900]], [[2801, 2900]])
def _ri_read_1(self):
return ([[3081, 3100], [3201, 3300]], [[3201, 3300]])
def _ri_read_2(self):
return ([[3081, 3300]], [[3001, 3220]])
def _other_reads(self):
return [
self._mxe_read_1(),
self._mxe_read_2(),
self._a5ss_read_1(),
self._a5ss_read_2(),
self._a3ss_read_1(),
self._a3ss_read_2(),
self._ri_read_1(),
self._ri_read_2()
]
def _paired_read_coords_1_1(self):
return self._se_reads_from_counts(10, 10, 10, 0) + self._other_reads()
def _paired_read_coords_1_2(self):
return self._se_reads_from_counts(15, 5, 10, 0) + self._other_reads()
def _paired_read_coords_2_1(self):
return self._se_reads_from_counts(10, 0, 10, 10) + self._other_reads()
def _paired_read_coords_2_2(self):
return self._se_reads_from_counts(10, 0, 15, 5) + self._other_reads()
def _prepare_stat_inputs(self, new_out_dir, old_out_dir, group_1_indices,
group_2_indices):
command = [
sys.executable, tests.test_config.PREPARE_STAT_INPUTS,
'--new-output-dir', new_out_dir, '--old-output-dir', old_out_dir,
'--group-1-indices', ','.join([str(x) for x in group_1_indices]),
'--group-2-indices', ','.join([str(x) for x in group_2_indices])
]
subprocess.run(command,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
check=True)
def _check_results(self):
if self._sub_step == 'statoff':
self._check_results_statoff()
elif self._sub_step == 'selected_stat':
self._check_results_selected_stat()
elif self._sub_step == 'just_se':
self._check_results_just_se()
elif self._sub_step == 'deferred_stat':
self._check_results_deferred_stat()
else:
self.fail('unexpected sub_step: {}'.format(self._sub_step))
def _read_floats(self, floats_str):
float_strs = floats_str.split(',')
floats = list()
for float_str in float_strs:
try:
floats.append(float(float_str))
except ValueError as e:
self.fail('could not parse {} as float from {}: {}'.format(
float_str, floats_str, e))
return floats
def _check_results_statoff(self):
self._check_no_error_results()
se_mats_jc_path = os.path.join(self._out_dir_all, 'SE.MATS.JC.txt')
se_mats_jc_header, se_mats_jc_rows, error = output_parser.parse_mats_jc(
se_mats_jc_path)
self.assertFalse(error)
self._check_se_mats_jc_header(se_mats_jc_header)
self.assertEqual(len(se_mats_jc_rows), 2)
for row in se_mats_jc_rows:
self.assertIn(row['exonStart_0base'], ['200', '800'])
if row['exonStart_0base'] == '200':
self.assertEqual(row['IJC_SAMPLE_1'], '10,15')
self.assertEqual(row['SJC_SAMPLE_1'], '10,5')
self.assertEqual(row['IJC_SAMPLE_2'], '10,10')
self.assertEqual(row['SJC_SAMPLE_2'], '0,0')
self.assertEqual(row['PValue'], 'NA')
self.assertEqual(row['FDR'], 'NA')
self.assertEqual(self._read_floats(row['IncLevel1']),
[0.333, 0.6])
self.assertEqual(self._read_floats(row['IncLevel2']),
[1.0, 1.0])
self.assertEqual(float(row['IncLevelDifference']), -0.533)
elif row['exonStart_0base'] == '800':
self.assertEqual(row['IJC_SAMPLE_1'], '10,10')
self.assertEqual(row['SJC_SAMPLE_1'], '0,0')
self.assertEqual(row['IJC_SAMPLE_2'], '10,15')
self.assertEqual(row['SJC_SAMPLE_2'], '10,5')
self.assertEqual(row['PValue'], 'NA')
self.assertEqual(row['FDR'], 'NA')
self.assertEqual(self._read_floats(row['IncLevel1']),
[1.0, 1.0])
self.assertEqual(self._read_floats(row['IncLevel2']),
[0.333, 0.6])
self.assertEqual(float(row['IncLevelDifference']), 0.533)
se_mats_jcec_path = os.path.join(self._out_dir_all, 'SE.MATS.JCEC.txt')
se_mats_jcec_header, se_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(se_mats_jcec_path))
self.assertFalse(error)
self._check_se_mats_jcec_header(se_mats_jcec_header)
self.assertEqual(len(se_mats_jcec_rows), 2)
for row in se_mats_jcec_rows:
self.assertIn(row['exonStart_0base'], ['200', '800'])
if row['exonStart_0base'] == '200':
self.assertEqual(row['IJC_SAMPLE_1'], '20,30')
self.assertEqual(row['SJC_SAMPLE_1'], '10,5')
self.assertEqual(row['IJC_SAMPLE_2'], '20,20')
self.assertEqual(row['SJC_SAMPLE_2'], '0,0')
self.assertEqual(row['PValue'], 'NA')
self.assertEqual(row['FDR'], 'NA')
self.assertEqual(self._read_floats(row['IncLevel1']),
[0.397, 0.664])
self.assertEqual(self._read_floats(row['IncLevel2']),
[1.0, 1.0])
self.assertEqual(float(row['IncLevelDifference']), -0.47)
mxe_mats_jc_path = os.path.join(self._out_dir_all, 'MXE.MATS.JC.txt')
mxe_mats_jc_header, mxe_mats_jc_rows, error = (
output_parser.parse_mats_jc(mxe_mats_jc_path))
self.assertFalse(error)
self._check_mxe_mats_jc_header(mxe_mats_jc_header)
self.assertEqual(len(mxe_mats_jc_rows), 1)
self.assertEqual(mxe_mats_jc_rows[0]['FDR'], 'NA')
mxe_mats_jcec_path = os.path.join(self._out_dir_all,
'MXE.MATS.JCEC.txt')
mxe_mats_jcec_header, mxe_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(mxe_mats_jcec_path))
self.assertFalse(error)
self._check_mxe_mats_jcec_header(mxe_mats_jcec_header)
self.assertEqual(len(mxe_mats_jcec_rows), 1)
self.assertEqual(mxe_mats_jcec_rows[0]['FDR'], 'NA')
a5ss_mats_jc_path = os.path.join(self._out_dir_all, 'A5SS.MATS.JC.txt')
a5ss_mats_jc_header, a5ss_mats_jc_rows, error = (
output_parser.parse_mats_jc(a5ss_mats_jc_path))
self.assertFalse(error)
self._check_a35ss_mats_jc_header(a5ss_mats_jc_header)
self.assertEqual(len(a5ss_mats_jc_rows), 1)
self.assertEqual(a5ss_mats_jc_rows[0]['FDR'], 'NA')
a5ss_mats_jcec_path = os.path.join(self._out_dir_all,
'A5SS.MATS.JCEC.txt')
a5ss_mats_jcec_header, a5ss_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(a5ss_mats_jcec_path))
self.assertFalse(error)
self._check_a35ss_mats_jcec_header(a5ss_mats_jcec_header)
self.assertEqual(len(a5ss_mats_jcec_rows), 1)
self.assertEqual(a5ss_mats_jcec_rows[0]['FDR'], 'NA')
a3ss_mats_jc_path = os.path.join(self._out_dir_all, 'A3SS.MATS.JC.txt')
a3ss_mats_jc_header, a3ss_mats_jc_rows, error = (
output_parser.parse_mats_jc(a3ss_mats_jc_path))
self.assertFalse(error)
self._check_a35ss_mats_jc_header(a3ss_mats_jc_header)
self.assertEqual(len(a3ss_mats_jc_rows), 1)
self.assertEqual(a3ss_mats_jc_rows[0]['FDR'], 'NA')
a3ss_mats_jcec_path = os.path.join(self._out_dir_all,
'A3SS.MATS.JCEC.txt')
a3ss_mats_jcec_header, a3ss_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(a3ss_mats_jcec_path))
self.assertFalse(error)
self._check_a35ss_mats_jcec_header(a3ss_mats_jcec_header)
self.assertEqual(len(a3ss_mats_jcec_rows), 1)
self.assertEqual(a3ss_mats_jcec_rows[0]['FDR'], 'NA')
ri_mats_jc_path = os.path.join(self._out_dir_all, 'RI.MATS.JC.txt')
ri_mats_jc_header, ri_mats_jc_rows, error = output_parser.parse_mats_jc(
ri_mats_jc_path)
self.assertFalse(error)
self._check_ri_mats_jc_header(ri_mats_jc_header)
self.assertEqual(len(ri_mats_jc_rows), 1)
self.assertEqual(ri_mats_jc_rows[0]['FDR'], 'NA')
ri_mats_jcec_path = os.path.join(self._out_dir_all, 'RI.MATS.JCEC.txt')
ri_mats_jcec_header, ri_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(ri_mats_jcec_path))
self.assertFalse(error)
self._check_ri_mats_jcec_header(ri_mats_jcec_header)
self.assertEqual(len(ri_mats_jcec_rows), 1)
self.assertEqual(ri_mats_jcec_rows[0]['FDR'], 'NA')
def _check_results_selected_stat(self):
self._check_no_error_results()
se_mats_jc_path = os.path.join(self._out_dir_select, 'SE.MATS.JC.txt')
se_mats_jc_header, se_mats_jc_rows, error = output_parser.parse_mats_jc(
se_mats_jc_path)
self.assertFalse(error)
self._check_se_mats_jc_header(se_mats_jc_header)
self.assertEqual(len(se_mats_jc_rows), 2)
for row in se_mats_jc_rows:
self.assertIn(row['exonStart_0base'], ['200', '800'])
if row['exonStart_0base'] == '200':
self.assertEqual(row['IJC_SAMPLE_1'], '15')
self.assertEqual(row['SJC_SAMPLE_1'], '5')
self.assertEqual(row['IJC_SAMPLE_2'], '10,10')
self.assertEqual(row['SJC_SAMPLE_2'], '10,0')
tests.util.assert_within_bounds(self, float(row['PValue']), 0,
1)
tests.util.assert_within_bounds(self, float(row['FDR']), 0, 1)
self.assertEqual(self._read_floats(row['IncLevel1']), [0.6])
self.assertEqual(self._read_floats(row['IncLevel2']),
[0.333, 1.0])
self.assertEqual(float(row['IncLevelDifference']), -0.067)
elif row['exonStart_0base'] == '800':
self.assertEqual(row['IJC_SAMPLE_1'], '10')
self.assertEqual(row['SJC_SAMPLE_1'], '0')
self.assertEqual(row['IJC_SAMPLE_2'], '10,15')
self.assertEqual(row['SJC_SAMPLE_2'], '0,5')
tests.util.assert_within_bounds(self, float(row['PValue']), 0,
1)
tests.util.assert_within_bounds(self, float(row['FDR']), 0, 1)
self.assertEqual(self._read_floats(row['IncLevel1']), [1.0])
self.assertEqual(self._read_floats(row['IncLevel2']),
[1.0, 0.6])
self.assertEqual(float(row['IncLevelDifference']), 0.2)
se_mats_jcec_path = os.path.join(self._out_dir_select,
'SE.MATS.JCEC.txt')
se_mats_jcec_header, se_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(se_mats_jcec_path))
self.assertFalse(error)
self._check_se_mats_jcec_header(se_mats_jcec_header)
self.assertEqual(len(se_mats_jcec_rows), 2)
for row in se_mats_jcec_rows:
self.assertIn(row['exonStart_0base'], ['200', '800'])
if row['exonStart_0base'] == '200':
self.assertEqual(row['IJC_SAMPLE_1'], '30')
self.assertEqual(row['SJC_SAMPLE_1'], '5')
self.assertEqual(row['IJC_SAMPLE_2'], '20,20')
self.assertEqual(row['SJC_SAMPLE_2'], '10,0')
tests.util.assert_within_bounds(self, float(row['PValue']), 0,
1)
tests.util.assert_within_bounds(self, float(row['FDR']), 0, 1)
self.assertEqual(self._read_floats(row['IncLevel1']), [0.664])
self.assertEqual(self._read_floats(row['IncLevel2']),
[0.397, 1.0])
self.assertEqual(float(row['IncLevelDifference']), -0.034)
mxe_mats_jc_path = os.path.join(self._out_dir_select,
'MXE.MATS.JC.txt')
mxe_mats_jc_header, mxe_mats_jc_rows, error = (
output_parser.parse_mats_jc(mxe_mats_jc_path))
self.assertFalse(error)
self._check_mxe_mats_jc_header(mxe_mats_jc_header)
self.assertEqual(len(mxe_mats_jc_rows), 1)
tests.util.assert_within_bounds(self,
float(mxe_mats_jc_rows[0]['FDR']), 0,
1)
mxe_mats_jcec_path = os.path.join(self._out_dir_select,
'MXE.MATS.JCEC.txt')
mxe_mats_jcec_header, mxe_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(mxe_mats_jcec_path))
self.assertFalse(error)
self._check_mxe_mats_jcec_header(mxe_mats_jcec_header)
self.assertEqual(len(mxe_mats_jcec_rows), 1)
tests.util.assert_within_bounds(self,
float(mxe_mats_jcec_rows[0]['FDR']), 0,
1)
a5ss_mats_jc_path = os.path.join(self._out_dir_select,
'A5SS.MATS.JC.txt')
a5ss_mats_jc_header, a5ss_mats_jc_rows, error = (
output_parser.parse_mats_jc(a5ss_mats_jc_path))
self.assertFalse(error)
self._check_a35ss_mats_jc_header(a5ss_mats_jc_header)
self.assertEqual(len(a5ss_mats_jc_rows), 1)
tests.util.assert_within_bounds(self,
float(a5ss_mats_jc_rows[0]['FDR']), 0,
1)
a5ss_mats_jcec_path = os.path.join(self._out_dir_select,
'A5SS.MATS.JCEC.txt')
a5ss_mats_jcec_header, a5ss_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(a5ss_mats_jcec_path))
self.assertFalse(error)
self._check_a35ss_mats_jcec_header(a5ss_mats_jcec_header)
self.assertEqual(len(a5ss_mats_jcec_rows), 1)
tests.util.assert_within_bounds(self,
float(a5ss_mats_jcec_rows[0]['FDR']),
0, 1)
a3ss_mats_jc_path = os.path.join(self._out_dir_select,
'A3SS.MATS.JC.txt')
a3ss_mats_jc_header, a3ss_mats_jc_rows, error = (
output_parser.parse_mats_jc(a3ss_mats_jc_path))
self.assertFalse(error)
self._check_a35ss_mats_jc_header(a3ss_mats_jc_header)
self.assertEqual(len(a3ss_mats_jc_rows), 1)
tests.util.assert_within_bounds(self,
float(a3ss_mats_jc_rows[0]['FDR']), 0,
1)
a3ss_mats_jcec_path = os.path.join(self._out_dir_select,
'A3SS.MATS.JCEC.txt')
a3ss_mats_jcec_header, a3ss_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(a3ss_mats_jcec_path))
self.assertFalse(error)
self._check_a35ss_mats_jcec_header(a3ss_mats_jcec_header)
self.assertEqual(len(a3ss_mats_jcec_rows), 1)
tests.util.assert_within_bounds(self,
float(a3ss_mats_jcec_rows[0]['FDR']),
0, 1)
ri_mats_jc_path = os.path.join(self._out_dir_select, 'RI.MATS.JC.txt')
ri_mats_jc_header, ri_mats_jc_rows, error = output_parser.parse_mats_jc(
ri_mats_jc_path)
self.assertFalse(error)
self._check_ri_mats_jc_header(ri_mats_jc_header)
self.assertEqual(len(ri_mats_jc_rows), 1)
tests.util.assert_within_bounds(self, float(ri_mats_jc_rows[0]['FDR']),
0, 1)
ri_mats_jcec_path = os.path.join(self._out_dir_select,
'RI.MATS.JCEC.txt')
ri_mats_jcec_header, ri_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(ri_mats_jcec_path))
self.assertFalse(error)
self._check_ri_mats_jcec_header(ri_mats_jcec_header)
self.assertEqual(len(ri_mats_jcec_rows), 1)
tests.util.assert_within_bounds(self,
float(ri_mats_jcec_rows[0]['FDR']), 0,
1)
def _check_results_just_se(self):
self.assertEqual(self._rmats_return_code, 0)
command_stderr_file_name = self._get_stderr_file_name()
with open(command_stderr_file_name, 'rt') as err_f_h:
err_lines = err_f_h.readlines()
self.assertEqual(len(err_lines), 9)
unable_to_produce_lines = collections.defaultdict(int)
for err_line in err_lines:
self.assertIn('Unable to produce final output files for', err_line)
if ' SE ' in err_line:
unable_to_produce_lines['SE'] += 1
if ' MXE ' in err_line:
unable_to_produce_lines['MXE'] += 1
if ' A5SS ' in err_line:
unable_to_produce_lines['A5SS'] += 1
if ' A3SS ' in err_line:
unable_to_produce_lines['A3SS'] += 1
if ' RI ' in err_line:
unable_to_produce_lines['RI'] += 1
self.assertEqual(unable_to_produce_lines, {
'SE': 1,
'MXE': 2,
'A5SS': 2,
'A3SS': 2,
'RI': 2
})
se_mats_jc_path = os.path.join(self._out_dir_just_se, 'SE.MATS.JC.txt')
se_mats_jc_header, se_mats_jc_rows, error = output_parser.parse_mats_jc(
se_mats_jc_path)
self.assertFalse(error)
self._check_se_mats_jc_header(se_mats_jc_header)
self.assertEqual(len(se_mats_jc_rows), 2)
for row in se_mats_jc_rows:
self.assertIn(row['exonStart_0base'], ['200', '800'])
if row['exonStart_0base'] == '200':
self.assertEqual(row['IJC_SAMPLE_1'], '10,15')
self.assertEqual(row['SJC_SAMPLE_1'], '10,5')
self.assertEqual(row['IJC_SAMPLE_2'], '10,10')
self.assertEqual(row['SJC_SAMPLE_2'], '0,0')
tests.util.assert_within_bounds(self, float(row['PValue']), 0,
1)
tests.util.assert_within_bounds(self, float(row['FDR']), 0, 1)
self.assertEqual(self._read_floats(row['IncLevel1']),
[0.333, 0.6])
self.assertEqual(self._read_floats(row['IncLevel2']),
[1.0, 1.0])
self.assertEqual(float(row['IncLevelDifference']), -0.533)
se_mats_jcec_path = os.path.join(self._out_dir_just_se,
'SE.MATS.JCEC.txt')
self.assertFalse(os.path.exists(se_mats_jcec_path))
mxe_mats_jc_path = os.path.join(self._out_dir_just_se,
'MXE.MATS.JC.txt')
self.assertFalse(os.path.exists(mxe_mats_jc_path))
mxe_mats_jcec_path = os.path.join(self._out_dir_just_se,
'MXE.MATS.JCEC.txt')
self.assertFalse(os.path.exists(mxe_mats_jcec_path))
a5ss_mats_jc_path = os.path.join(self._out_dir_just_se,
'A5SS.MATS.JC.txt')
self.assertFalse(os.path.exists(a5ss_mats_jc_path))
a5ss_mats_jcec_path = os.path.join(self._out_dir_just_se,
'A5SS.MATS.JCEC.txt')
self.assertFalse(os.path.exists(a5ss_mats_jcec_path))
a3ss_mats_jc_path = os.path.join(self._out_dir_just_se,
'A3SS.MATS.JC.txt')
self.assertFalse(os.path.exists(a3ss_mats_jc_path))
a3ss_mats_jcec_path = os.path.join(self._out_dir_just_se,
'A3SS.MATS.JCEC.txt')
self.assertFalse(os.path.exists(a3ss_mats_jcec_path))
ri_mats_jc_path = os.path.join(self._out_dir_just_se, 'RI.MATS.JC.txt')
self.assertFalse(os.path.exists(ri_mats_jc_path))
ri_mats_jcec_path = os.path.join(self._out_dir_just_se,
'RI.MATS.JCEC.txt')
self.assertFalse(os.path.exists(ri_mats_jcec_path))
def _check_results_deferred_stat(self):
self._check_no_error_results()
se_mats_jc_path = os.path.join(self._out_dir_all, 'SE.MATS.JC.txt')
se_mats_jc_header, se_mats_jc_rows, error = output_parser.parse_mats_jc(
se_mats_jc_path)
self.assertFalse(error)
self._check_se_mats_jc_header(se_mats_jc_header)
self.assertEqual(len(se_mats_jc_rows), 2)
for row in se_mats_jc_rows:
self.assertIn(row['exonStart_0base'], ['200', '800'])
if row['exonStart_0base'] == '200':
self.assertEqual(row['IJC_SAMPLE_1'], '10,15')
self.assertEqual(row['SJC_SAMPLE_1'], '10,5')
self.assertEqual(row['IJC_SAMPLE_2'], '10,10')
self.assertEqual(row['SJC_SAMPLE_2'], '0,0')
tests.util.assert_within_bounds(self, float(row['PValue']), 0,
1)
tests.util.assert_within_bounds(self, float(row['FDR']), 0, 1)
self.assertEqual(self._read_floats(row['IncLevel1']),
[0.333, 0.6])
self.assertEqual(self._read_floats(row['IncLevel2']),
[1.0, 1.0])
self.assertEqual(float(row['IncLevelDifference']), -0.533)
elif row['exonStart_0base'] == '800':
self.assertEqual(row['IJC_SAMPLE_1'], '10,10')
self.assertEqual(row['SJC_SAMPLE_1'], '0,0')
self.assertEqual(row['IJC_SAMPLE_2'], '10,15')
self.assertEqual(row['SJC_SAMPLE_2'], '10,5')
tests.util.assert_within_bounds(self, float(row['PValue']), 0,
1)
tests.util.assert_within_bounds(self, float(row['FDR']), 0, 1)
self.assertEqual(self._read_floats(row['IncLevel1']),
[1.0, 1.0])
self.assertEqual(self._read_floats(row['IncLevel2']),
[0.333, 0.6])
self.assertEqual(float(row['IncLevelDifference']), 0.533)
se_mats_jcec_path = os.path.join(self._out_dir_all, 'SE.MATS.JCEC.txt')
se_mats_jcec_header, se_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(se_mats_jcec_path))
self.assertFalse(error)
self._check_se_mats_jcec_header(se_mats_jcec_header)
self.assertEqual(len(se_mats_jcec_rows), 2)
for row in se_mats_jcec_rows:
self.assertIn(row['exonStart_0base'], ['200', '800'])
if row['exonStart_0base'] == '200':
self.assertEqual(row['IJC_SAMPLE_1'], '20,30')
self.assertEqual(row['SJC_SAMPLE_1'], '10,5')
self.assertEqual(row['IJC_SAMPLE_2'], '20,20')
self.assertEqual(row['SJC_SAMPLE_2'], '0,0')
tests.util.assert_within_bounds(self, float(row['PValue']), 0,
1)
tests.util.assert_within_bounds(self, float(row['FDR']), 0, 1)
self.assertEqual(self._read_floats(row['IncLevel1']),
[0.397, 0.664])
self.assertEqual(self._read_floats(row['IncLevel2']),
[1.0, 1.0])
self.assertEqual(float(row['IncLevelDifference']), -0.47)
mxe_mats_jc_path = os.path.join(self._out_dir_all, 'MXE.MATS.JC.txt')
mxe_mats_jc_header, mxe_mats_jc_rows, error = (
output_parser.parse_mats_jc(mxe_mats_jc_path))
self.assertFalse(error)
self._check_mxe_mats_jc_header(mxe_mats_jc_header)
self.assertEqual(len(mxe_mats_jc_rows), 1)
tests.util.assert_within_bounds(self,
float(mxe_mats_jc_rows[0]['FDR']), 0,
1)
mxe_mats_jcec_path = os.path.join(self._out_dir_all,
'MXE.MATS.JCEC.txt')
mxe_mats_jcec_header, mxe_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(mxe_mats_jcec_path))
self.assertFalse(error)
self._check_mxe_mats_jcec_header(mxe_mats_jcec_header)
self.assertEqual(len(mxe_mats_jcec_rows), 1)
tests.util.assert_within_bounds(self,
float(mxe_mats_jcec_rows[0]['FDR']), 0,
1)
a5ss_mats_jc_path = os.path.join(self._out_dir_all, 'A5SS.MATS.JC.txt')
a5ss_mats_jc_header, a5ss_mats_jc_rows, error = (
output_parser.parse_mats_jc(a5ss_mats_jc_path))
self.assertFalse(error)
self._check_a35ss_mats_jc_header(a5ss_mats_jc_header)
self.assertEqual(len(a5ss_mats_jc_rows), 1)
tests.util.assert_within_bounds(self,
float(a5ss_mats_jc_rows[0]['FDR']), 0,
1)
a5ss_mats_jcec_path = os.path.join(self._out_dir_all,
'A5SS.MATS.JCEC.txt')
a5ss_mats_jcec_header, a5ss_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(a5ss_mats_jcec_path))
self.assertFalse(error)
self._check_a35ss_mats_jcec_header(a5ss_mats_jcec_header)
self.assertEqual(len(a5ss_mats_jcec_rows), 1)
tests.util.assert_within_bounds(self,
float(a5ss_mats_jcec_rows[0]['FDR']),
0, 1)
a3ss_mats_jc_path = os.path.join(self._out_dir_all, 'A3SS.MATS.JC.txt')
a3ss_mats_jc_header, a3ss_mats_jc_rows, error = (
output_parser.parse_mats_jc(a3ss_mats_jc_path))
self.assertFalse(error)
self._check_a35ss_mats_jc_header(a3ss_mats_jc_header)
self.assertEqual(len(a3ss_mats_jc_rows), 1)
tests.util.assert_within_bounds(self,
float(a3ss_mats_jc_rows[0]['FDR']), 0,
1)
a3ss_mats_jcec_path = os.path.join(self._out_dir_all,
'A3SS.MATS.JCEC.txt')
a3ss_mats_jcec_header, a3ss_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(a3ss_mats_jcec_path))
self.assertFalse(error)
self._check_a35ss_mats_jcec_header(a3ss_mats_jcec_header)
self.assertEqual(len(a3ss_mats_jcec_rows), 1)
tests.util.assert_within_bounds(self,
float(a3ss_mats_jcec_rows[0]['FDR']),
0, 1)
ri_mats_jc_path = os.path.join(self._out_dir_all, 'RI.MATS.JC.txt')
ri_mats_jc_header, ri_mats_jc_rows, error = output_parser.parse_mats_jc(
ri_mats_jc_path)
self.assertFalse(error)
self._check_ri_mats_jc_header(ri_mats_jc_header)
self.assertEqual(len(ri_mats_jc_rows), 1)
tests.util.assert_within_bounds(self, float(ri_mats_jc_rows[0]['FDR']),
0, 1)
ri_mats_jcec_path = os.path.join(self._out_dir_all, 'RI.MATS.JCEC.txt')
ri_mats_jcec_header, ri_mats_jcec_rows, error = (
output_parser.parse_mats_jcec(ri_mats_jcec_path))
self.assertFalse(error)
self._check_ri_mats_jcec_header(ri_mats_jcec_header)
self.assertEqual(len(ri_mats_jcec_rows), 1)
tests.util.assert_within_bounds(self,
float(ri_mats_jcec_rows[0]['FDR']), 0,
1)
if __name__ == '__main__':
unittest.main(verbosity=2)
|
[
"noreply@github.com"
] |
noreply@github.com
|
90db28e0b00420ae8ba6a75d46a68285b150f3e2
|
bd7cbd805417429af1a6636eff86857b28162525
|
/encapsulation.py
|
c4a5fe1d25ea847720f29c90dc5c902265b1d92c
|
[] |
no_license
|
Qannaf/Python
|
d92cb9bad34de2a6814520f6487d548e93bfb52c
|
b8d23cdda6f5901bd176a4274f1b8d389267dc85
|
refs/heads/main
| 2023-04-28T09:03:30.854096
| 2021-05-22T08:35:51
| 2021-05-22T08:35:51
| 356,817,981
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 801
|
py
|
#coding:utf-8
#voila mon 12émé code en python
class Humain:
""""Classe qui définit un humain"""
def __init__(self,nom ,age): #constrecture
self.nom = nom
self._age = age
def _getage(self):
#print("Récupération interdite")
if self._age<= 1:
return "{} {}".format(self._age,"an")
return "{} {}".format(self._age,"ans")
def _setage(self,nouvel_age):
if nouvel_age<0:
self._age=0
else:
self._age = nouvel_age
#propreité <getter>,<setter>,<deleter>,<helper>
age = property(_getage,_setage)
#prgm principale
h1 = Humain("Qannaf",27)
print(h1.nom,"\t",h1.age)
h1.nom = "ALSAHMI"
h1.age = 1
print(h1.nom,"\t",h1.age)
print("{} {}".format(h1.nom,h1.age))
|
[
"qannafalsahmi@gmail.com"
] |
qannafalsahmi@gmail.com
|
5d7dcefc5473baa7b1829179e02b456b2dc7a467
|
1526f23c4a847768a5fc1c2ba596275d5d7ec0d5
|
/assgn2/pr7.py
|
16044b8670c8a1a1d63e463e2a9b0422df3600da
|
[] |
no_license
|
gitank007/python-assignmnet
|
d07e7d222242f13dbfe7bd5d1f7a75ddb8be9aa7
|
7b7588927a17c46dfea2b141c7ccf91b4b5f3949
|
refs/heads/master
| 2023-02-28T17:02:45.217169
| 2021-02-11T08:03:57
| 2021-02-11T08:03:57
| 333,665,413
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 561
|
py
|
''' nature of roots
step 1: if d=b^2 -4ac =0 ==>real and equal roots
step 2 if d>0 then they are rel roots
step 3 if d<0 then it is imaginary rots
'''
x,y,z=[int(x) for x in input("enter the space seprating values of cofficients of ax^2+bx+c values will be considered in repective manner: ").split()]
print("a={} ,b={}, c={} ".format(z,y,z))
d=(y**2)-4*x*z
print("the Value of discriminant for given equation is :",d)
if d==0:
print("The roots are real and equal ")
elif d>0:
print("The roots are real ")
else:
print("The rots are imaginary ")
|
[
"noreply@github.com"
] |
noreply@github.com
|
290d3ea467c81eb4adcf2a72c26529c2a9e07eb4
|
1a2ca64839723ede3134a0781128b0dc0b5f6ab8
|
/ExtractFeatures/Data/jsinix/Problem10.py
|
8f8dd302f291fb441406f1d44ec06aae2c72032e
|
[] |
no_license
|
vivekaxl/LexisNexis
|
bc8ee0b92ae95a200c41bd077082212243ee248c
|
5fa3a818c3d41bd9c3eb25122e1d376c8910269c
|
refs/heads/master
| 2021-01-13T01:44:41.814348
| 2015-07-08T15:42:35
| 2015-07-08T15:42:35
| 29,705,371
| 9
| 3
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 459
|
py
|
# Question: Summation of primes
# Problem 10
# The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
# Find the sum of all the primes below two million.
# Answer: 142913828922
#!/usr/bin/python
def is_prime(num):
for j in range(2,num):
if (num % j) == 0:
return False
return True
list1 = []
for i in range(3,2000000,2):
if is_prime(i) == True:
list1.append(i)
sum1 = 0
for j in list1:
sum1 = sum1+j
print sum1
|
[
"vivekaxl@gmail.com"
] |
vivekaxl@gmail.com
|
1153e48fb209a9481fc4f3d804857ae10cbf9c27
|
21264264d3323c2d801042ffe3aeecb97c393251
|
/regimens/tests/test_forms.py
|
e3402a9f38a01eb7015a07c85eb153af54a1a05f
|
[
"MIT"
] |
permissive
|
michael-xander/communique-webapp
|
a5dd45b3c1019d40ca02fea587ade35dbf16c0d0
|
85b450d7f6d0313c5e5ef53a262a850b7e93c3d6
|
refs/heads/master
| 2021-05-01T15:34:06.013729
| 2016-11-19T19:15:31
| 2016-11-19T19:15:31
| 63,105,520
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,502
|
py
|
from django.test import TestCase
import datetime
from regimens.forms import RegimenForm
from regimens.models import Drug
from patients.models import Patient
class RegimenFormTestCase(TestCase):
"""
Test cases for the regimen create form.
"""
def setUp(self):
Patient.objects.create(other_names='Jon', last_name='Snow', sex=Patient.MALE, identifier='A001')
Drug.objects.create(name='a Drug', description='A drug description')
def test_date_validation(self):
"""
Tests that the form invalidates submissions where the start date is greater then the end date
"""
form = RegimenForm()
self.assertFalse(form.is_bound)
self.assertFalse(form.is_valid())
current_date = datetime.date.today()
one_day = datetime.timedelta(days=1)
tomorrow = current_date + one_day
data = {}
data['patient'] = 1
data['notes'] = 'Sample notes'
data['drugs'] = (1,)
data['date_started'] = current_date
data['date_ended'] = tomorrow
self.assertTrue(data['date_started'] < data['date_ended'])
form = RegimenForm(data)
self.assertTrue(form.is_bound)
self.assertTrue(form.is_valid())
data['date_started'] = tomorrow
data['date_ended'] = current_date
self.assertFalse(data['date_started'] < data['date_ended'])
form = RegimenForm(data)
self.assertTrue(data)
self.assertFalse(form.is_valid())
|
[
"michaelkyeyune01@gmail.com"
] |
michaelkyeyune01@gmail.com
|
274befd704407b98b615b5efb59b5c392ba2d396
|
82b946da326148a3c1c1f687f96c0da165bb2c15
|
/sdk/python/pulumi_azure_native/sql/outbound_firewall_rule.py
|
5a8309fc8ccaf95892a167a53395faad58b8bd6a
|
[
"Apache-2.0",
"BSD-3-Clause"
] |
permissive
|
morrell/pulumi-azure-native
|
3916e978382366607f3df0a669f24cb16293ff5e
|
cd3ba4b9cb08c5e1df7674c1c71695b80e443f08
|
refs/heads/master
| 2023-06-20T19:37:05.414924
| 2021-07-19T20:57:53
| 2021-07-19T20:57:53
| 387,815,163
| 0
| 0
|
Apache-2.0
| 2021-07-20T14:18:29
| 2021-07-20T14:18:28
| null |
UTF-8
|
Python
| false
| false
| 7,974
|
py
|
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = ['OutboundFirewallRuleArgs', 'OutboundFirewallRule']
@pulumi.input_type
class OutboundFirewallRuleArgs:
def __init__(__self__, *,
resource_group_name: pulumi.Input[str],
server_name: pulumi.Input[str],
outbound_rule_fqdn: Optional[pulumi.Input[str]] = None):
"""
The set of arguments for constructing a OutboundFirewallRule resource.
:param pulumi.Input[str] resource_group_name: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal.
:param pulumi.Input[str] server_name: The name of the server.
"""
pulumi.set(__self__, "resource_group_name", resource_group_name)
pulumi.set(__self__, "server_name", server_name)
if outbound_rule_fqdn is not None:
pulumi.set(__self__, "outbound_rule_fqdn", outbound_rule_fqdn)
@property
@pulumi.getter(name="resourceGroupName")
def resource_group_name(self) -> pulumi.Input[str]:
"""
The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal.
"""
return pulumi.get(self, "resource_group_name")
@resource_group_name.setter
def resource_group_name(self, value: pulumi.Input[str]):
pulumi.set(self, "resource_group_name", value)
@property
@pulumi.getter(name="serverName")
def server_name(self) -> pulumi.Input[str]:
"""
The name of the server.
"""
return pulumi.get(self, "server_name")
@server_name.setter
def server_name(self, value: pulumi.Input[str]):
pulumi.set(self, "server_name", value)
@property
@pulumi.getter(name="outboundRuleFqdn")
def outbound_rule_fqdn(self) -> Optional[pulumi.Input[str]]:
return pulumi.get(self, "outbound_rule_fqdn")
@outbound_rule_fqdn.setter
def outbound_rule_fqdn(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "outbound_rule_fqdn", value)
class OutboundFirewallRule(pulumi.CustomResource):
@overload
def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
outbound_rule_fqdn: Optional[pulumi.Input[str]] = None,
resource_group_name: Optional[pulumi.Input[str]] = None,
server_name: Optional[pulumi.Input[str]] = None,
__props__=None):
"""
An Azure SQL DB Server Outbound Firewall Rule.
API Version: 2021-02-01-preview.
:param str resource_name: The name of the resource.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[str] resource_group_name: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal.
:param pulumi.Input[str] server_name: The name of the server.
"""
...
@overload
def __init__(__self__,
resource_name: str,
args: OutboundFirewallRuleArgs,
opts: Optional[pulumi.ResourceOptions] = None):
"""
An Azure SQL DB Server Outbound Firewall Rule.
API Version: 2021-02-01-preview.
:param str resource_name: The name of the resource.
:param OutboundFirewallRuleArgs args: The arguments to use to populate this resource's properties.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
...
def __init__(__self__, resource_name: str, *args, **kwargs):
resource_args, opts = _utilities.get_resource_args_opts(OutboundFirewallRuleArgs, pulumi.ResourceOptions, *args, **kwargs)
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
outbound_rule_fqdn: Optional[pulumi.Input[str]] = None,
resource_group_name: Optional[pulumi.Input[str]] = None,
server_name: Optional[pulumi.Input[str]] = None,
__props__=None):
if opts is None:
opts = pulumi.ResourceOptions()
if not isinstance(opts, pulumi.ResourceOptions):
raise TypeError('Expected resource options to be a ResourceOptions instance')
if opts.version is None:
opts.version = _utilities.get_version()
if opts.id is None:
if __props__ is not None:
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = OutboundFirewallRuleArgs.__new__(OutboundFirewallRuleArgs)
__props__.__dict__["outbound_rule_fqdn"] = outbound_rule_fqdn
if resource_group_name is None and not opts.urn:
raise TypeError("Missing required property 'resource_group_name'")
__props__.__dict__["resource_group_name"] = resource_group_name
if server_name is None and not opts.urn:
raise TypeError("Missing required property 'server_name'")
__props__.__dict__["server_name"] = server_name
__props__.__dict__["name"] = None
__props__.__dict__["provisioning_state"] = None
__props__.__dict__["type"] = None
alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="azure-nextgen:sql:OutboundFirewallRule"), pulumi.Alias(type_="azure-native:sql/v20210201preview:OutboundFirewallRule"), pulumi.Alias(type_="azure-nextgen:sql/v20210201preview:OutboundFirewallRule")])
opts = pulumi.ResourceOptions.merge(opts, alias_opts)
super(OutboundFirewallRule, __self__).__init__(
'azure-native:sql:OutboundFirewallRule',
resource_name,
__props__,
opts)
@staticmethod
def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None) -> 'OutboundFirewallRule':
"""
Get an existing OutboundFirewallRule resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = OutboundFirewallRuleArgs.__new__(OutboundFirewallRuleArgs)
__props__.__dict__["name"] = None
__props__.__dict__["provisioning_state"] = None
__props__.__dict__["type"] = None
return OutboundFirewallRule(resource_name, opts=opts, __props__=__props__)
@property
@pulumi.getter
def name(self) -> pulumi.Output[str]:
"""
Resource name.
"""
return pulumi.get(self, "name")
@property
@pulumi.getter(name="provisioningState")
def provisioning_state(self) -> pulumi.Output[str]:
"""
The state of the outbound rule.
"""
return pulumi.get(self, "provisioning_state")
@property
@pulumi.getter
def type(self) -> pulumi.Output[str]:
"""
Resource type.
"""
return pulumi.get(self, "type")
|
[
"noreply@github.com"
] |
noreply@github.com
|
da8b517d85a513db952f23fb60cba730404ee688
|
3c8cc407d7547f8702bfe06deb5f1c9087778ce3
|
/hiword/dataloader.py
|
4d6c1c1a4918a7d6da18e55b56ca7658f88ceae8
|
[
"Apache-2.0"
] |
permissive
|
jadbin/hiword
|
accaebbdee899e8e3ed11e024d6c488bca36c445
|
7789412747a2b6b59ee974f2a2efd57e355e3282
|
refs/heads/master
| 2023-04-06T21:57:17.260338
| 2023-03-15T16:21:49
| 2023-03-15T16:21:49
| 166,003,998
| 6
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,158
|
py
|
import os
from collections import defaultdict
from os import listdir
from os.path import join, dirname, isdir
class DictLoader:
def __init__(self):
self.dict = self._load_dict()
def word_freq(self, word):
return self.dict[word]
@staticmethod
def _load_dict():
res = defaultdict(lambda: 0)
d = join(dirname(__file__), 'data', 'dicts')
for name in os.listdir(d):
if name.endswith('.txt'):
dict_file = join(d, name)
with open(dict_file) as f:
for line in f:
s = line.split()
res[s[0]] = max(res[s[0]], int(s[1]))
return res
class IDFLoader:
def __init__(self):
self.idf = self._load_idf()
self.median_idf = sorted(self.idf.values())[len(self.idf) // 2]
def word_idf(self, word):
return self.idf.get(word, self.median_idf)
@staticmethod
def _load_idf():
idf_file = join(dirname(__file__), 'data', 'idf.txt')
res = {}
with open(idf_file) as f:
while True:
line = f.readline()
if not line:
break
s = line.split()
res[s[0]] = float(s[1])
return res
class StopwordsLoader:
def __init__(self):
self.stopwords = self._load_stopwords()
def is_stopword(self, word):
return word in self.stopwords
def remove(self, word):
self.stopwords.remove(word)
@staticmethod
def _load_stopwords():
file = join(dirname(__file__), 'data', 'stopwords')
res = set()
files = []
if isdir(file):
for fname in listdir(file):
if fname.endswith('.txt'):
files.append(join(file, fname))
else:
files.append(file)
for fname in files:
with open(fname) as f:
while True:
line = f.readline()
if not line:
break
s = line.strip()
res.add(s)
return res
|
[
"jadbin.com@hotmail.com"
] |
jadbin.com@hotmail.com
|
50c51970784b45eb11a6e6b9407324632f40fbe4
|
5fc1bb8df5af751e855ccdb224a37a7afb473d6e
|
/setup.py
|
0af5652144881f9fac8ad445e1c7b171c6d9d2ed
|
[
"BSD-3-Clause"
] |
permissive
|
areagle-stripe/SimpleML
|
c316ddaba7cac8dc709c4d9030e0de1897dc007a
|
10a2167a73570bc923c202930fa75ba56d46c504
|
refs/heads/master
| 2020-03-14T14:31:29.949925
| 2018-04-09T02:37:06
| 2018-04-09T02:37:06
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 647
|
py
|
from setuptools import setup, find_packages
setup(
name='simpleml',
version='0.1',
description='Simplified Machine Learning',
author='Elisha Yadgaran',
author_email='ElishaY@alum.mit.edu',
license='BSD-3',
url='https://github.com/eyadgaran/SimpleML',
download_url='https://github.com/eyadgaran/SimpleML/archive/0.1.tar.gz',
packages=find_packages(),
keywords = ['machine-learning'],
install_requires=[
'sqlalchemy',
'sqlalchemy_mixins',
'psycopg2',
'scikit-learn',
'numpy'
],
zip_safe=False,
test_suite='nose.collector',
tests_require=['nose']
)
|
[
"ElishaY@alum.mit.edu"
] |
ElishaY@alum.mit.edu
|
f2d017f5816dc45eeaf51e3c46e9eea79e6f4cc8
|
56fd010ffa40a8496a61ca4974ab136c55add8f6
|
/Bruit_TrafficRoutier/Zone_bruit.py
|
3635ac3c5a55fd3a7bc5b31513c5c08989a2ec68
|
[] |
no_license
|
BarAmina/Python_ArcPy
|
1f185894888acf1d8cab20d17b3cbd65b09a82e9
|
ffe5db519ddf60838096b27acb283c3fb44f1ac6
|
refs/heads/master
| 2020-08-04T22:25:03.955430
| 2019-10-11T21:34:23
| 2019-10-11T21:34:23
| 212,297,771
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,602
|
py
|
# -*- coding: utf-8 -*-
#-------------------------------------------------------------------------------
# Nom du script : Zone_bruit.py
# Objet : Génération de zones d'exposition au bruit du traffic routier
#-------------------------------------------------------------------------------
# Import arcpy module
import arcpy
# Configuration de l'environnement de géotraitement
arcpy.env.overwriteOutput = True
# Paramétrage des données en entrée
iris = arcpy.GetParameterAsText(0)
rue = arcpy.GetParameterAsText(1)
# Paramétrage des données intermédiaires
rueBuffer = ur"{0}_buffer".format(rue)
irisClip = ur"{0}_clip".format(iris)
arcpy.AddMessage(u"Calcul du nombre d'habitants exposés au bruit...")
# Ajout d'un champ "Surface_complète" à la classe d'entités des IRIS
arcpy.AddField_management(iris, u"Surface_complète", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
# Renseignement du champ avec la surface de l'IRIS
arcpy.CalculateField_management(iris, u"Surface_complète", "[Shape_Area]", "VB", "")
arcpy.AddMessage(u"=> Calcul de la surface totale des IRIS OK")
# Ajout d'un champ "Distance" à la classe d'entités des rues
arcpy.AddField_management(rue, "Distance", "SHORT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
# Renseignement du champ avec une portée du bruit, exprimée en mètres, variable suivant l'importance de la rue
arcpy.CalculateField_management(rue, "Distance", "Calc_Imp( !IMPORTANCE! )", "PYTHON", "def Calc_Imp(imp):\\n if imp == '1':\\n return 100\\n elif imp == '2':\\n return 50\\n elif imp == '3':\\n return 20\\n else:\\n return 0")
arcpy.AddMessage(u"=> Calcul de la portée du bruit de chaque rue OK")
# Création de zones tampons autour des rues avec les distances calculées
arcpy.Buffer_analysis(rue, rueBuffer, "Distance", "FULL", "ROUND", "ALL", "", "PLANAR")
arcpy.AddMessage(u"=> Création des zones d'exposition au bruit OK")
# Découpage des IRIS suivant les zones d'exposition au bruit
arcpy.Clip_analysis(iris, rueBuffer, irisClip, "")
arcpy.AddMessage(u"=> Découpage des IRIS suivant les zones d'exposition au bruit OK")
# Ajout d'un champ Pop_bruit à la classe d'analyse
arcpy.AddField_management(irisClip, "Pop_bruit", "SHORT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
# Renseignement du champ avec la population des IRIS découpées
arcpy.CalculateField_management(irisClip, "Pop_bruit", "[P07_POP] / [Surface_complète] * [Shape_Area]", "VB", "")
arcpy.AddMessage(u"Calcul du nombre d'habitants exposés au bruit OK")
|
[
"noreply@github.com"
] |
noreply@github.com
|
f519f8ae0d7bee8960df8f6c8053f6c930b0db76
|
a98eab432108d65c8546c44cded7808463b844a4
|
/common/libs/UploadService.py
|
1855eb6afd457e0dd62cbeb931b35ad635c2e266
|
[] |
no_license
|
RocketWill/Qamar
|
287ec3d5ad2ec7b3435c93def2d85bbe7d94d928
|
63e41d333559baf52a9010850bc4c2713ac0b93d
|
refs/heads/master
| 2020-04-21T23:55:59.459620
| 2019-03-19T12:00:02
| 2019-03-19T12:00:02
| 169,962,064
| 1
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,359
|
py
|
# -*- coding: utf-8 -*-
from werkzeug.utils import secure_filename
from application import app, db
import os, stat, uuid
from common.libs.Helper import getCurrentDate
from common.models.Image import Image
class UploadService():
@staticmethod
def uploadByFile(file):
config_upload = app.config['UPLOAD']
resp = {'code': 200, 'msg': "操作成功", "data": {}}
filename = secure_filename(file.filename)
ext = filename.rsplit(".", 1)[1]
if ext not in config_upload['ext']:
resp['code'] = -1
resp['msg'] = "不允許的擴展類型文件"
return resp
root_path = app.root_path + config_upload['prefix_path']
file_dir = getCurrentDate("%Y%m%d")
save_dir = root_path + file_dir
if not os.path.exists(save_dir):
os.mkdir(save_dir)
os.chmod(save_dir, stat.S_IRWXU | stat.S_IRGRP | stat.S_IRWXO)
filename = str(uuid.uuid4()).replace("-", "") + "." + ext
file.save("{0}/{1}".format(save_dir, filename))
model_image = Image()
model_image.file_key = file_dir + "/" + filename
model_image.created_time = getCurrentDate()
db.session.add(model_image)
db.session.commit()
resp['data'] = {
"file_key": model_image.file_key
}
return resp
|
[
"willcy1006@163.com"
] |
willcy1006@163.com
|
b6d557a679a01d00df7d8e053588222bcee90375
|
4b100e0519f3362554bac7434baac61a1d08ddd2
|
/third_party/ros_aarch64/lib/python2.7/dist-packages/dynamic_reconfigure/cfg/TestConfig.py
|
8cb1e13bddbb1e0b79add5109e2837449bfbccae
|
[
"Apache-2.0"
] |
permissive
|
YapingLiao/apollo1.0
|
17002fefaf01e0ee9f79713fd436c8c3386208b6
|
6e725e8dd5013b769efa18f43e5ae675f4847fbd
|
refs/heads/master
| 2020-06-18T13:04:52.019242
| 2018-01-29T01:50:43
| 2018-01-29T01:50:43
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 12,004
|
py
|
## *********************************************************
##
## File autogenerated for the dynamic_reconfigure_test package
## by the dynamic_reconfigure package.
## Please do not edit.
##
## ********************************************************/
from dynamic_reconfigure.encoding import extract_params
inf = float('inf')
config_description = {'upper': 'DEFAULT', 'lower': 'groups', 'srcline': 246, 'name': 'Default', 'parent': 0, 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'cstate': 'true', 'parentname': 'Default', 'class': 'DEFAULT', 'field': 'default', 'state': True, 'parentclass': '', 'groups': [{'upper': 'GROUP_ONE', 'lower': 'group_one', 'srcline': 123, 'name': 'Group_One', 'parent': 0, 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'cstate': 'true', 'parentname': 'Default', 'class': 'DEFAULT::GROUP_ONE', 'field': 'DEFAULT::group_one', 'state': True, 'parentclass': 'DEFAULT', 'groups': [{'upper': 'GROUP2', 'lower': 'group2', 'srcline': 123, 'name': 'GROUP2', 'parent': 1, 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'cstate': 'false', 'parentname': 'Group_One', 'class': 'DEFAULT::GROUP_ONE::GROUP2', 'field': 'DEFAULT::GROUP_ONE::group2', 'state': False, 'parentclass': 'DEFAULT::GROUP_ONE', 'groups': [{'upper': 'GROUP3', 'lower': 'group3', 'srcline': 123, 'name': 'Group3', 'parent': 2, 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'cstate': 'true', 'parentname': 'GROUP2', 'class': 'DEFAULT::GROUP_ONE::GROUP2::GROUP3', 'field': 'DEFAULT::GROUP_ONE::GROUP2::group3', 'state': True, 'parentclass': 'DEFAULT::GROUP_ONE::GROUP2', 'groups': [], 'parameters': [{'srcline': 70, 'description': 'Were very far down now', 'max': 3, 'cconsttype': 'const int', 'ctype': 'int', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'name': 'deep_var_int', 'edit_method': "{'enum_description': 'An enum to set the size.', 'enum': [{'srcline': 45, 'description': 'A small constant', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'cconsttype': 'const int', 'value': 0, 'ctype': 'int', 'type': 'int', 'name': 'Small'}, {'srcline': 46, 'description': 'A medium value', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'cconsttype': 'const int', 'value': 1, 'ctype': 'int', 'type': 'int', 'name': 'Medium'}, {'srcline': 47, 'description': 'A large value', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'cconsttype': 'const int', 'value': 2, 'ctype': 'int', 'type': 'int', 'name': 'Large'}, {'srcline': 48, 'description': 'An extra large value', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'cconsttype': 'const int', 'value': 3, 'ctype': 'int', 'type': 'int', 'name': 'ExtraLarge'}]}", 'default': 0, 'level': 0, 'min': 0, 'type': 'int'}, {'srcline': 71, 'description': 'Were even farther down now!!', 'max': True, 'cconsttype': 'const bool', 'ctype': 'bool', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'name': 'deep_var_bool', 'edit_method': '', 'default': True, 'level': 0, 'min': False, 'type': 'bool'}, {'srcline': 72, 'description': 'Were super far down now!!', 'max': inf, 'cconsttype': 'const double', 'ctype': 'double', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'name': 'deep_var_double', 'edit_method': '', 'default': -1.0, 'level': 0, 'min': -inf, 'type': 'double'}], 'type': '', 'id': 3}], 'parameters': [{'srcline': 65, 'description': 'A third level group parameter', 'max': inf, 'cconsttype': 'const double', 'ctype': 'double', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'name': 'group2_double', 'edit_method': '', 'default': 3.333, 'level': 0, 'min': -inf, 'type': 'double'}, {'srcline': 66, 'description': 'A third level group parameter', 'max': '', 'cconsttype': 'const char * const', 'ctype': 'std::string', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'name': 'group2_string', 'edit_method': '', 'default': 'test string', 'level': 0, 'min': '', 'type': 'str'}, {'srcline': 67, 'description': 'Something', 'max': '', 'cconsttype': 'const char * const', 'ctype': 'std::string', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'name': 'some_other', 'edit_method': '', 'default': 'AAAAAAGGHH', 'level': 0, 'min': '', 'type': 'str'}, {'srcline': 68, 'description': 'A boolean', 'max': True, 'cconsttype': 'const bool', 'ctype': 'bool', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'name': 'variable', 'edit_method': '', 'default': True, 'level': 0, 'min': False, 'type': 'bool'}], 'type': 'collapse', 'id': 2}], 'parameters': [{'srcline': 63, 'description': 'A second level group parameter', 'max': 2147483647, 'cconsttype': 'const int', 'ctype': 'int', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'name': 'group1_int', 'edit_method': '', 'default': 2, 'level': 1, 'min': -2147483648, 'type': 'int'}], 'type': '', 'id': 1}, {'upper': 'UPPER_GROUP_2', 'lower': 'upper_group_2', 'srcline': 123, 'name': 'Upper_Group_2', 'parent': 0, 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'cstate': 'true', 'parentname': 'Default', 'class': 'DEFAULT::UPPER_GROUP_2', 'field': 'DEFAULT::upper_group_2', 'state': True, 'parentclass': 'DEFAULT', 'groups': [], 'parameters': [{'srcline': 75, 'description': 'Some param', 'max': 2147483647, 'cconsttype': 'const int', 'ctype': 'int', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'name': 'some_param', 'edit_method': '', 'default': 20, 'level': 0, 'min': -2147483648, 'type': 'int'}], 'type': '', 'id': 4}], 'parameters': [{'srcline': 293, 'description': 'Int enum', 'max': 3, 'cconsttype': 'const int', 'ctype': 'int', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'name': 'int_enum_', 'edit_method': "{'enum_description': 'An enum to set the size.', 'enum': [{'srcline': 45, 'description': 'A small constant', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'cconsttype': 'const int', 'value': 0, 'ctype': 'int', 'type': 'int', 'name': 'Small'}, {'srcline': 46, 'description': 'A medium value', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'cconsttype': 'const int', 'value': 1, 'ctype': 'int', 'type': 'int', 'name': 'Medium'}, {'srcline': 47, 'description': 'A large value', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'cconsttype': 'const int', 'value': 2, 'ctype': 'int', 'type': 'int', 'name': 'Large'}, {'srcline': 48, 'description': 'An extra large value', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/cfg/Test.cfg', 'cconsttype': 'const int', 'value': 3, 'ctype': 'int', 'type': 'int', 'name': 'ExtraLarge'}]}", 'default': 0, 'level': 1, 'min': 0, 'type': 'int'}, {'srcline': 293, 'description': 'Int parameter', 'max': 10, 'cconsttype': 'const int', 'ctype': 'int', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'name': 'int_', 'edit_method': '', 'default': 0, 'level': 1, 'min': -10, 'type': 'int'}, {'srcline': 293, 'description': 'double parameter', 'max': 10.0, 'cconsttype': 'const double', 'ctype': 'double', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'name': 'double_', 'edit_method': '', 'default': 0.0, 'level': 2, 'min': -2.0, 'type': 'double'}, {'srcline': 293, 'description': 'double parameter without boundaries', 'max': inf, 'cconsttype': 'const double', 'ctype': 'double', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'name': 'double_no_minmax', 'edit_method': '', 'default': 1.0, 'level': 2, 'min': -inf, 'type': 'double'}, {'srcline': 293, 'description': 'double parameter without max value', 'max': inf, 'cconsttype': 'const double', 'ctype': 'double', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'name': 'double_no_max', 'edit_method': '', 'default': 2.0, 'level': 2, 'min': 0.0, 'type': 'double'}, {'srcline': 293, 'description': 'String parameter', 'max': '', 'cconsttype': 'const char * const', 'ctype': 'std::string', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'name': 'str_', 'edit_method': '', 'default': 'foo', 'level': 4, 'min': '', 'type': 'str'}, {'srcline': 293, 'description': 'Multibyte String parameter', 'max': '', 'cconsttype': 'const char * const', 'ctype': 'std::string', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'name': 'mstr_', 'edit_method': '', 'default': 'bar', 'level': 4, 'min': '', 'type': 'str'}, {'srcline': 293, 'description': 'Boolean parameter', 'max': True, 'cconsttype': 'const bool', 'ctype': 'bool', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'name': 'bool_', 'edit_method': '', 'default': False, 'level': 8, 'min': False, 'type': 'bool'}, {'srcline': 293, 'description': 'Contains the level of the previous change', 'max': 2147483647, 'cconsttype': 'const int', 'ctype': 'int', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'name': 'level', 'edit_method': '', 'default': 0, 'level': 16, 'min': -2147483648, 'type': 'int'}, {'srcline': 293, 'description': 'Checks against regression of #4499', 'max': 2147483647, 'cconsttype': 'const int', 'ctype': 'int', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'name': 'int_nodefault', 'edit_method': '', 'default': 0, 'level': 0, 'min': -2147483648, 'type': 'int'}, {'srcline': 293, 'description': 'Checks against regression of https://github.com/ros/dynamic_reconfigure/issues/6', 'max': 2147483647, 'cconsttype': 'const int', 'ctype': 'int', 'srcfile': '/home/ubuntu/baidu/adu-lab/apollo/modules/ros/dynamic_reconfigure/src/dynamic_reconfigure/parameter_generator_catkin.py', 'name': 'i', 'edit_method': '', 'default': 0, 'level': 0, 'min': -2147483648, 'type': 'int'}], 'type': '', 'id': 0}
min = {}
max = {}
defaults = {}
level = {}
type = {}
all_level = 0
#def extract_params(config):
# params = []
# params.extend(config['parameters'])
# for group in config['groups']:
# params.extend(extract_params(group))
# return params
for param in extract_params(config_description):
min[param['name']] = param['min']
max[param['name']] = param['max']
defaults[param['name']] = param['default']
level[param['name']] = param['level']
type[param['name']] = param['type']
all_level = all_level | param['level']
Test_int_const = 5
Test_double_const = 5.6
Test_str_const = 'foo'
Test_bool_const = True
Test_Small = 0
Test_Medium = 1
Test_Large = 2
Test_ExtraLarge = 3
|
[
"14552258@qq.com"
] |
14552258@qq.com
|
db0ec3865a75078674e752309dad2296cd1bbd26
|
f305f84ea6f721c2391300f0a60e21d2ce14f2a5
|
/19_数学/计算几何/直线/practice/面试题 16.14. 最佳直线 copy.py
|
9a95efaf08f17ae51ca4cf2e9edb0dae3b4f6f05
|
[] |
no_license
|
981377660LMT/algorithm-study
|
f2ada3e6959338ae1bc21934a84f7314a8ecff82
|
7e79e26bb8f641868561b186e34c1127ed63c9e0
|
refs/heads/master
| 2023-09-01T18:26:16.525579
| 2023-09-01T12:21:58
| 2023-09-01T12:21:58
| 385,861,235
| 225
| 24
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,033
|
py
|
from typing import List
from collections import defaultdict
def gcd(a, b):
return b if a == 0 else gcd(b % a, b)
class Solution:
def bestLine(self, points: List[List[int]]) -> List[int]:
n = len(points)
res = []
maxCount = 0
for i in range(n):
x1, y1 = points[i]
counter = defaultdict(int)
firstpair = defaultdict(list)
for j in range(i + 1, n):
x2, y2 = points[j]
A, B = (y2 - y1), (x2 - x1)
if B == 0:
key = (0, 0)
else:
gcd_ = gcd(A, B)
key = (A / gcd_, B / gcd_)
counter[key] += 1
firstpair.setdefault(key, [i, j])
if counter[key] > maxCount: # 只有更多，才更新
maxCount = counter[key]
res = firstpair[key]
return res
print(
Solution().bestLine(
[
[-24272, -29606],
[-37644, -4251],
[2691, -22513],
[-14592, -33765],
[-21858, 28550],
[-22264, 41303],
[-6960, 12785],
[-39133, -41833],
[25151, -26643],
[-19416, 28550],
[-17420, 22270],
[-8793, 16457],
[-4303, -25680],
[-14405, 26607],
[-49083, -26336],
[22629, 20544],
[-23939, -25038],
[-40441, -26962],
[-29484, -30503],
[-32927, -18287],
[-13312, -22513],
[15026, 12965],
[-16361, -23282],
[7296, -15750],
[-11690, -21723],
[-34850, -25928],
[-14933, -16169],
[23459, -9358],
[-45719, -13202],
[-26868, 28550],
[4627, 16457],
[-7296, -27760],
[-32230, 8174],
[-28233, -8627],
[-26520, 28550],
[5515, -26001],
[-16766, 28550],
[21888, -3740],
[1251, 28550],
[15333, -26322],
[-27677, -19790],
[20311, 7075],
[-10751, 16457],
[-47762, -44638],
[20991, 24942],
[-19056, -11105],
[-26639, 28550],
[-19862, 16457],
[-27506, -4251],
[-20172, -5440],
[-33757, -24717],
[-9411, -17379],
[12493, 29906],
[0, -21755],
[-36885, -16192],
[-38195, -40088],
[-40079, 7667],
[-29294, -34032],
[-55968, 23947],
[-22724, -22513],
[20362, -11530],
[-11817, -23957],
[-33742, 5259],
[-10350, -4251],
[-11690, -22513],
[-20241, -22513],
]
)
)
|
[
"lmt2818088@gmail.com"
] |
lmt2818088@gmail.com
|
0ac33827a9a2da4ec675edc41ce481fc5157e0f5
|
a7f43722f91b6cc75b46924daa08d856e9c4793c
|
/env/bin/pip3
|
8ad698ab09c3dd8b9c007b1e05cada42de0aee9b
|
[] |
no_license
|
bodevone/django-blog
|
b226b998d609dd6726053857fd38c5abc2c98734
|
ee4e5dbafa94b2fe18261cf229ace3c741c97203
|
refs/heads/master
| 2020-05-03T10:11:02.256327
| 2019-03-30T15:08:28
| 2019-03-30T15:08:28
| 178,573,157
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 257
|
#!/home/bodevan/Documents/coding/django-blog/env/bin/python3
# -*- coding: utf-8 -*-
import re
import sys
from pip._internal import main
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(main())
|
[
"aliby.bbb@gmail.com"
] |
aliby.bbb@gmail.com
|
|
0335df4074ddc3d154d3724fb2fef2df225be97f
|
76f05bd66e0585d1f0ef9c6829be936332706f2a
|
/yibanApi/__init__.py
|
30d7de0a0830f48a6a09d044d0cf34b8149d0bad
|
[
"MIT"
] |
permissive
|
vincijy/yibanApi
|
b48da529b962b176f08c9e4227727d0499836caa
|
57bf9b821fb5b5154e8df7a3f7f4bdb2245dfcbf
|
refs/heads/master
| 2020-03-13T20:03:36.363584
| 2018-05-02T10:29:24
| 2018-05-02T10:29:24
| 131,266,046
| 5
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 39
|
py
|
from .yibanApi import AccessToken, api
|
[
"awefight@qq.com"
] |
awefight@qq.com
|
94d8d69b957710067f870841aeea79b4d0747e2f
|
7dbe84760c95ee2ef15b28724bc73c173fab1f1a
|
/download2-8-1.py
|
c2c0a4db78e9230a650e421f354d1c8aceb7af0c
|
[] |
no_license
|
seil3377/python_section2
|
f0af3342df24d2317f21081d59a4f5f42e4f0d32
|
eb5af490480cd53031e93d833ed74d20e7367933
|
refs/heads/master
| 2020-03-27T13:06:33.114567
| 2018-09-18T08:11:26
| 2018-09-18T08:11:26
| 146,586,648
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,262
|
py
|
from bs4 import BeautifulSoup
import urllib.request as req
import urllib.parse as rep
import sys
import io
import os
sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding = 'utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding = 'utf-8')
#403error : 헤더(Header)정보를 심어서 User-agent 정보를 같이 보내는 코드를 통해 해결
opener = req.build_opener()
opener.addheaders = [('User-agent', 'Mozilla/5.0')]
req.install_opener(opener)
# HTML 가져오기
base = "https://search.naver.com/search.naver?where=image&query="
quote = rep.quote_plus("사자")
url = base + quote
res = req.urlopen(url)
savePath = "D:/Atom_Workspace/section2/img/"
#폴더 생성 & 예외처리
try:
if not(os.path.isdir(savePath)):
os.makedirs(os.path.join(savePath))
except OSError as e:
if e.errno != errno.EEXIST:
print("폴더 만들기 실패!")
raise
soup = BeautifulSoup(res, "html.parser")
img_list = soup.select("div.img_area > a.thumb._thumb > img")
#print("test", img_list)
for i, div in enumerate(img_list,1):
print("div =", div['data-source'])
fullfilename = os.path.join(savePath, savePath+str(i)+'.jpg')
print(fullfilename)
req.urlretrieve(div['data-source'],fullfilename)
print(i)
|
[
"seil3377@naver.com"
] |
seil3377@naver.com
|
d1d2cb8fa62f4abf11d0f3c031e100adb3008d82
|
6ed01f4503fc9de234a561c945adff7cf4b1c81b
|
/ncar_lib/incites_authors/incites_people_reporter.py
|
24328f4c760673ff83a6c2cbdde1365ae3f9d3f8
|
[] |
no_license
|
ostwald/python-lib
|
b851943c913a68424a05ce3c7b42878ff9519f68
|
9acd97ffaa2f57b3e9e632e1b75016549beb29e5
|
refs/heads/master
| 2021-10-28T06:33:34.156095
| 2021-10-21T23:54:49
| 2021-10-21T23:54:49
| 69,060,616
| 0
| 1
| null | 2018-06-21T16:05:30
| 2016-09-23T21:04:46
|
Roff
|
UTF-8
|
Python
| false
| false
| 5,465
|
py
|
"""
"""
import os, sys
from UserList import UserList
from find_person import PersonFinder, resolveFullName
from data_filter import FilteredAuthorData
from HyperText.HTML40 import *
from html import HtmlDocument
class InCitesAuthorInfo:
def __init__ (self, id, finder, matches):
"""
names are derived from inCitesAuthor data
matches come from peopleDB
"""
self.id = id
# self.inCitesName = fullname
for attr in ['fullname', 'firstName', 'middleName', 'lastName', 'note']:
setattr (self, attr, getattr (finder, attr))
self.matches = matches
self.numMatches = len(matches)
class SimpleReporter (UserList):
def __init__ (self):
self.data = []
self.recordsToReport = 10
self.errors = []
self.notes = []
self.people = FilteredAuthorData().people # UniquePeople
# self.report()
self.getAuthorMatchInfo()
def getAuthorMatchInfo (self):
person_counter = 1
max_count = self.recordsToReport or len(self.people.keys())
for fullname in self.people.keys()[:max_count]:
try:
finder = PersonFinder (fullname)
candidates = finder.candidates
id = 'author-%d' % person_counter
person_counter += 1
# print 'processing authorInfo for ' + fullname
authorInfo = InCitesAuthorInfo (id, finder, candidates)
self.append(authorInfo)
except KeyError, e:
print 'ERROR', e
self.errors.append(fullname + ": " + str(e))
def report(self):
for authorInfo in self:
try:
if authorInfo.numMatches == 1:
continue
if authorInfo.note:
self.notes.append(authorInfo.note)
## print '\n%s (%d)' % (fullname, size)
print "\n%d candidates found for '%s' (%s | %s)" % \
(len(authorInfo.matches),
authorInfo.fullname,
authorInfo.lastName,
authorInfo.firstName)
for person in authorInfo.matches:
print '- ', person
except Exception, e:
self.errors.append(authorInfo.fullname + ": " + str(e))
def showErrors (self):
if self.errors:
print '\nNames that could not be parsed'
for error in self.errors:
print error
else:
print '\nAll names were parsed'
def showNotes(self):
if self.notes:
print '\nNotes'
for note in notes:
print note
else:
print '\nNo notes generated'
class HtmlReporter (SimpleReporter):
results_columns = ['numMatches', 'inCitesName', 'peopleDBlink']
def __init__ (self):
SimpleReporter.__init__ (self)
self.htmlDoc = None
print '%d authorInfo instances' % len(self.data)
def asHtmlDoc (self):
if self.htmlDoc is None:
mockup_link = Href ("../reporter-mockup.html", 'to Mockup')
reportTable = self.makeReportHtml()
javascript = [
'javascript/prototype.js',
'javascript/scriptaculous-js-1.9.0/scriptaculous.js',
'javascript/toggler.js',
'javascript/decorate_upids.js'
]
self.htmlDoc = HtmlDocument(mockup_link,
reportTable,
title="inCites Author Reporter",
stylesheet="styles.css",
javascript=javascript)
return self.htmlDoc
def getInCitesAuthorInfo (self, authorInfo):
"""
make the html for a inCitesAuthor & its matches
"""
print 'getInCitesAuthorInfo with ' + authorInfo.fullname
id = authorInfo.id
togglerClass = authorInfo.matches and "toggler" or ""
toggler = DIV (id=id, klass=togglerClass)
if authorInfo.numMatches > 0:
togglerLnkClass = "inCitesAuthor togglerClosed"
else:
togglerLnkClass = "inCitesAuthor noTogglerClosed"
# print "%s %s" % (authorInfo.inCitesName, authorInfo.numMatches)
togglerLnk = DIV(id='toggler-lnk-'+id, klass=togglerLnkClass)
toggler.append(togglerLnk)
authorTable = TABLE(klass="authorTable")
togglerLnk.append(authorTable)
matchesContent = '(%d matches)' % authorInfo.numMatches
authorTable.append(
TR(
TD (authorInfo.fullname, klass="author"),
TD (matchesContent, klass="matches")
)
)
if authorInfo.numMatches > 0:
togglerCon = DIV(id='toggler-con-'+id, style="display:none")
toggler.append(togglerCon)
matchTable = TABLE(klass="matchTable")
togglerCon.append(matchTable)
for match in authorInfo.matches:
match_row = TR (klass="peopleDBmatch", id=match.upid)
match_row.append (
TD (match.getName(), klass="match-name"),
TD (match.upid, klass="match-upid"))
matchTable.append(match_row);
return toggler
def makeReportHtml (self):
report = DIV (id='reportTable')
person_counter = 1
max_count = self.recordsToReport or len(self.people.keys())
for authorInfo in self:
# print authorInfo.fullname, authorInfo.numMatches
try:
if authorInfo.numMatches == 1:
continue
if authorInfo.note:
self.notes.append(authorInfo.note)
# print 'processing authorInfo for ' + fullname
report.append (HR (klass="divider"))
report.append(self.getInCitesAuthorInfo (authorInfo))
except Exception, e:
self.errors.append(authorInfo.fullname + ": " + str(e))
return report
def writeHtmlDoc (self, path=None):
path = path or "report_html/INCITES_REPORT.html"
fp = open (path, 'w')
fp.write (self.asHtmlDoc().__str__())
fp.close()
print "wrote to " + path
if __name__ == '__main__':
# findPeople()
if 0:
reporter = SimpleReporter()
reporter.report()
if 1:
reporter = HtmlReporter()
print reporter.asHtmlDoc()
# reporter.writeHtmlDoc()
reporter.showErrors()
reporter.showNotes()
# print reporter.asHtmlDoc()
|
[
"ostwald@ucar.edu"
] |
ostwald@ucar.edu
|
29274b90fb731a1e2a67393d3e011a6ce556f727
|
965a462e251e705dee793cc2ab9ef2acaa1f2b1f
|
/SCons_zipit.py
|
752f39714f7581bb78d9b78fe6771c68640fcc24
|
[] |
no_license
|
Embedded-Systems-Spring-2020/lab4
|
786e4dca964c6294b606ae136ce151ef26d64e6b
|
916539dbe90fd11e869fa20c6233359d20f640b9
|
refs/heads/master
| 2021-01-02T12:55:17.007775
| 2020-02-24T17:03:27
| 2020-02-24T17:03:27
| 239,633,582
| 0
| 1
| null | 2020-02-24T05:06:52
| 2020-02-10T23:15:58
|
C
|
UTF-8
|
Python
| false
| false
| 2,355
|
py
|
# .. "Copyright (c) 2008 Robert B. Reese, Bryan A. Jones, J. W. Bruce ("AUTHORS")"
# All rights reserved.
# (R. Reese, reese_AT_ece.msstate.edu, Mississippi State University)
# (B. A. Jones, bjones_AT_ece.msstate.edu, Mississippi State University)
# (J. W. Bruce, jwbruce_AT_ece.msstate.edu, Mississippi State University)
#
# Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose, without fee, and without written agreement is
# hereby granted, provided that the above copyright notice, the following
# two paragraphs and the authors appear in all copies of this software.
#
# IN NO EVENT SHALL THE "AUTHORS" BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
# OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE "AUTHORS"
# HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# THE "AUTHORS" SPECIFICALLY DISCLAIMS ANY WARRANTIES,
# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
# AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
# ON AN "AS IS" BASIS, AND THE "AUTHORS" HAS NO OBLIGATION TO
# PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
#
# Please maintain this header in its entirety when copying/modifying
# these files.
#
# ***************************************************************
# SCons_zipit.py - Build docs then create a .zip for distribution
# ***************************************************************
# Bring in path for SCons use.
import os
env = Environment(ENV = {'PATH' : os.environ['PATH']})
# Update docs.
env.Execute('doxygen')
# Copy updated CodeChat docs into Doxygen output.
env.Execute('sphinx-build -d _build\\doctrees . _build\\html')
env.Execute(Delete('docs/sphinx', must_exist = 0))
env.Execute(Copy('docs/sphinx', '_build/html'))
# Define a single target to build the zip file.
zip_file = '../pic24_code_examples.zip'
env.Default(env.Zip(zip_file, [
'readme.txt',
'standard_header.txt',
'bin',
'bootloader',
'docs',
'hex',
'chap03',
'chap04',
'chap06',
'chap07',
'chap08',
'chap09',
'chap10',
'chap11',
'chap12',
'chap13',
'BUILD_DIR',
'esos',
'lib/lkr',
'lib/src',
'lib/include',
'explorer16_100p',
'util' ]))
|
[
"49951619+ryan-shoemake@users.noreply.github.com"
] |
49951619+ryan-shoemake@users.noreply.github.com
|
5540e36a51a6dfcea256b55d35fa3fa736c86e2e
|
e96bab82cc398aec30b8969288def8403c033207
|
/36_Data types function.py
|
dcceb7b9db3682f5ce76e3d3a2bec556373faceb
|
[] |
no_license
|
shiyanshirani/w3s-150-questions
|
125c7df920d6cc04e71232f0d994673aaa0d8d15
|
3d532ab7a70767d905f86423185e2abbee6d7c2b
|
refs/heads/master
| 2022-11-05T03:30:19.738858
| 2020-06-27T14:17:50
| 2020-06-27T14:17:50
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 165
|
py
|
def typesfunction(a, b):
if type(a)==int and type(b)==int:
print(a+b)
else:
print("Different types")
typesfunction("google", 5)
typesfunction(111,0)
|
[
"shiyan99@gmail.com"
] |
shiyan99@gmail.com
|
9193f6aad6ce7c106a99eac8bfc6eb8b4001266e
|
5f6fd8232989e9d033506c84083b909117d0086b
|
/thread/thread_listen_coding - 副本.py
|
bb7a3b4a7b13fe86e6a603f4739d428959d85913
|
[] |
no_license
|
seryte/int_python_pro
|
a4a9fd085c21adf6161bc8173f77b6b4c191adb2
|
fc0a1bc8d64f01d07cc63690f4bad04c7a20b07f
|
refs/heads/master
| 2020-03-09T06:02:35.139890
| 2018-05-16T03:42:20
| 2018-05-16T03:42:20
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 996
|
py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Date : 2018-04-17 20:04:07
# @Author : Your Name (you@example.org)
# @Link : http://example.org
# @Version : $Id$
import threading,time
def listen(name,now):
print("listening:%s %s" %(name,now))
time.sleep(2)
print("listening 执行结束 %s"%time.strftime("%Y-%m-%d %H:%M:%S"))
def coding(name,now):
print("coding:%s %s"%(name,now))
time.sleep(5)
print("coding 执行结束 %s"%time.strftime("%Y-%m-%d %H:%M:%S"))
print("单线程调用：")
listen("如果没有如果",time.strftime("%Y-%m-%d %H:%M:%S"))
coding("python", time.strftime("%Y-%m-%d %H:%M:%S"))
thread = []
t1 = threading.Thread(target=listen, args=("说散就散",time.strftime("%Y-%m-%d %H:%M:%S")))
t2 = threading.Thread(target=coding, args=("codename",time.strftime("%Y-%m-%d %H:%M:%S")))
thread.append(t1)
thread.append(t2)
# print(thread)
print("\n多线程调用：")
# t1.start()
# t2.start()
for i in thread:
i.setDaemon(True)
i.start()
i.join()
|
[
"382643558@qq.com"
] |
382643558@qq.com
|
aba125b8f91634b95df90b074b7664738b3c06a0
|
7f74e34fedf47766fdb280404eed5336b03c1461
|
/MII/Sede/forms.py
|
25cc0808ceaa6031fca8e2d8956257d290b79a8c
|
[] |
no_license
|
ExiledGod/Universidad
|
bcbdd6a11b6cbb134064792701380419ac290ca0
|
bb6cc13b83630b63b0ac594b3bee436a0a21eabe
|
refs/heads/master
| 2022-12-14T16:15:25.261425
| 2020-08-27T05:28:23
| 2020-08-27T05:28:23
| 290,684,166
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 722
|
py
|
from Sede.models import Sede, DireccionSede
from django import forms
class Sede_form(forms.ModelForm):
model = Sede
fields = [
'nombre',
]
labels = {
'nombre': 'Nombre: ',
}
class DireccionForm(forms.ModelForm):
class Meta:
model = DireccionSede
fields = [
'region',
'provincia',
'comuna',
'direccion',
]
labels = {
'region': 'Región',
'provincia': 'Provincia',
'comuna': 'Comuna',
'direccion': 'Dirección',
}
widgets = {
'region': forms.Select(attrs={'class':'form-control'}),
'provincia': forms.Select(attrs={'class':'form-control'}),
'comuna': forms.Select(attrs={'class':'form-control'}),
'direccion': forms.TextInput(attrs={'class':'form-control'}),
}
|
[
"66937061+ExiledGod@users.noreply.github.com"
] |
66937061+ExiledGod@users.noreply.github.com
|
abdf25273170a0e464ee6c988a08c42a21bbd8b0
|
f3a1629a46f5c3cbf7314c54fc36be3156146517
|
/venv/bin/sqlformat
|
f01aa4e0e6285b25c7aec0571805920953267bed
|
[] |
no_license
|
AlexsandroMO/qualiy_applications
|
ec4cdbcbacc9f403d7d34ca9573af44df9c9230a
|
08656c8368f10d54e5b9c8e4a758989239224dc6
|
refs/heads/main
| 2023-01-13T03:50:21.779274
| 2020-11-14T19:05:20
| 2020-11-14T19:05:20
| 305,471,783
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 284
|
#!/Users/alexsandromonteiro/Desktop/Prog_Python/qualiy_applications/venv/bin/python3.8
# -*- coding: utf-8 -*-
import re
import sys
from sqlparse.__main__ import main
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
sys.exit(main())
|
[
"sandrobass@hotmail.com"
] |
sandrobass@hotmail.com
|
|
6831b0fbb7a6dadcaef55a6df4497df57ec91df1
|
2b45cbccd03fb09be78b2241d05beeae171a2e18
|
/字节跳动测试开发工程师面试准备/reverseList.py
|
58fa0f6880134d2ea79618baafedb614640d8d8f
|
[] |
no_license
|
MaoningGuan/LeetCode
|
c90f78ce87a8116458a86c49dbe32e172036f7b4
|
62419b49000e79962bcdc99cd98afd2fb82ea345
|
refs/heads/master
| 2023-01-03T14:52:04.278708
| 2020-11-01T12:15:41
| 2020-11-01T12:15:41
| 282,859,997
| 3
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,567
|
py
|
# -*- coding: utf-8 -*-
"""
206. 反转链表
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
"""
# Definition for singly-linked list.
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
def generateList(l: list) -> ListNode:
prenode = ListNode(0)
lastnode = prenode
for val in l:
lastnode.next = ListNode(val)
lastnode = lastnode.next
return prenode.next
def printList(l: ListNode):
while l:
print("%d, " % (l.val), end='')
l = l.next
print('')
class Solution:
def reverseList_recursive(self, head: ListNode) -> ListNode:
"""
递归解法
:type head: ListNode
:rtype: ListNode
"""
# 递归终止条件是当前为空，或者下一个节点为空
if (head == None or head.next == None):
return head
# 这里的cur就是最后一个节点
cur = self.reverseList_recursive(head.next)
# 这里请配合动画演示理解
# 如果链表是 1->2->3->4->5，那么此时的cur就是5
# 而head是4，head的下一个是5，下下一个是空
# 所以head.next.next 就是5->4
head.next.next = head
# 防止链表循环，需要将head.next设置为空(如：5 -> 4 -> 3 -> 2 <-> 1)
# if head.val == 1:
# head.next = None
head.next = None
# 每层递归函数都返回cur，也就是最后一个节点
return cur
def reverseList_iterate(self, head: ListNode) -> ListNode:
"""
迭代解法
:type head: ListNode
:rtype: ListNode
"""
# 申请两个节点，pre和 cur，pre指向None
pre = None
cur = head
# 遍历链表，while循环里面的内容其实可以写成一行
# 这里只做演示，就不搞那么骚气的写法了
while cur:
# pre, cur.next, cur = cur, pre, cur.next
# 记录当前节点的下一个节点
tmp = cur.next
# 然后将当前节点指向pre
cur.next = pre
# pre和cur节点都前进一位
pre = cur
cur = tmp
return pre
if __name__ == '__main__':
solution = Solution()
nodes = [1, 2, 3, 4, 5]
linked_list = generateList(nodes)
reversed_link = solution.reverseList_iterate(linked_list)
printList(reversed_link)
|
[
"1812711281@qq.com"
] |
1812711281@qq.com
|
8095b9c0a7bae6822334409e1ce923939046e30c
|
141b42d9d72636c869ff2ce7a2a9f7b9b24f508b
|
/myvenv/Lib/site-packages/cairosvg/colors.py
|
d77cb275f83cb564c24eb127821c4d38243acfbb
|
[
"BSD-3-Clause"
] |
permissive
|
Fa67/saleor-shop
|
105e1147e60396ddab6f006337436dcbf18e8fe1
|
76110349162c54c8bfcae61983bb59ba8fb0f778
|
refs/heads/master
| 2021-06-08T23:51:12.251457
| 2018-07-24T08:14:33
| 2018-07-24T08:14:33
| 168,561,915
| 1
| 0
|
BSD-3-Clause
| 2021-04-18T07:59:12
| 2019-01-31T17:00:39
|
Python
|
UTF-8
|
Python
| false
| false
| 11,254
|
py
|
# This file is part of CairoSVG
# Copyright © 2010-2015 Kozea
#
# This library is free software: you can redistribute it and/or modify it under
# the terms of the GNU Lesser General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option) any
# later version.
#
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with CairoSVG. If not, see <http://www.gnu.org/licenses/>.
"""
SVG colors.
"""
import re
COLORS = {
'aliceblue': (240 / 255, 248 / 255, 255 / 255, 1),
'antiquewhite': (250 / 255, 235 / 255, 215 / 255, 1),
'aqua': (0 / 255, 255 / 255, 255 / 255, 1),
'aquamarine': (127 / 255, 255 / 255, 212 / 255, 1),
'azure': (240 / 255, 255 / 255, 255 / 255, 1),
'beige': (245 / 255, 245 / 255, 220 / 255, 1),
'bisque': (255 / 255, 228 / 255, 196 / 255, 1),
'black': (0 / 255, 0 / 255, 0 / 255, 1),
'blanchedalmond': (255 / 255, 235 / 255, 205 / 255, 1),
'blue': (0 / 255, 0 / 255, 255 / 255, 1),
'blueviolet': (138 / 255, 43 / 255, 226 / 255, 1),
'brown': (165 / 255, 42 / 255, 42 / 255, 1),
'burlywood': (222 / 255, 184 / 255, 135 / 255, 1),
'cadetblue': (95 / 255, 158 / 255, 160 / 255, 1),
'chartreuse': (127 / 255, 255 / 255, 0 / 255, 1),
'chocolate': (210 / 255, 105 / 255, 30 / 255, 1),
'coral': (255 / 255, 127 / 255, 80 / 255, 1),
'cornflowerblue': (100 / 255, 149 / 255, 237 / 255, 1),
'cornsilk': (255 / 255, 248 / 255, 220 / 255, 1),
'crimson': (220 / 255, 20 / 255, 60 / 255, 1),
'cyan': (0 / 255, 255 / 255, 255 / 255, 1),
'darkblue': (0 / 255, 0 / 255, 139 / 255, 1),
'darkcyan': (0 / 255, 139 / 255, 139 / 255, 1),
'darkgoldenrod': (184 / 255, 134 / 255, 11 / 255, 1),
'darkgray': (169 / 255, 169 / 255, 169 / 255, 1),
'darkgreen': (0 / 255, 100 / 255, 0 / 255, 1),
'darkgrey': (169 / 255, 169 / 255, 169 / 255, 1),
'darkkhaki': (189 / 255, 183 / 255, 107 / 255, 1),
'darkmagenta': (139 / 255, 0 / 255, 139 / 255, 1),
'darkolivegreen': (85 / 255, 107 / 255, 47 / 255, 1),
'darkorange': (255 / 255, 140 / 255, 0 / 255, 1),
'darkorchid': (153 / 255, 50 / 255, 204 / 255, 1),
'darkred': (139 / 255, 0 / 255, 0 / 255, 1),
'darksalmon': (233 / 255, 150 / 255, 122 / 255, 1),
'darkseagreen': (143 / 255, 188 / 255, 143 / 255, 1),
'darkslateblue': (72 / 255, 61 / 255, 139 / 255, 1),
'darkslategray': (47 / 255, 79 / 255, 79 / 255, 1),
'darkslategrey': (47 / 255, 79 / 255, 79 / 255, 1),
'darkturquoise': (0 / 255, 206 / 255, 209 / 255, 1),
'darkviolet': (148 / 255, 0 / 255, 211 / 255, 1),
'deeppink': (255 / 255, 20 / 255, 147 / 255, 1),
'deepskyblue': (0 / 255, 191 / 255, 255 / 255, 1),
'dimgray': (105 / 255, 105 / 255, 105 / 255, 1),
'dimgrey': (105 / 255, 105 / 255, 105 / 255, 1),
'dodgerblue': (30 / 255, 144 / 255, 255 / 255, 1),
'firebrick': (178 / 255, 34 / 255, 34 / 255, 1),
'floralwhite': (255 / 255, 250 / 255, 240 / 255, 1),
'forestgreen': (34 / 255, 139 / 255, 34 / 255, 1),
'fuchsia': (255 / 255, 0 / 255, 255 / 255, 1),
'gainsboro': (220 / 255, 220 / 255, 220 / 255, 1),
'ghostwhite': (248 / 255, 248 / 255, 255 / 255, 1),
'gold': (255 / 255, 215 / 255, 0 / 255, 1),
'goldenrod': (218 / 255, 165 / 255, 32 / 255, 1),
'gray': (128 / 255, 128 / 255, 128 / 255, 1),
'grey': (128 / 255, 128 / 255, 128 / 255, 1),
'green': (0 / 255, 128 / 255, 0 / 255, 1),
'greenyellow': (173 / 255, 255 / 255, 47 / 255, 1),
'honeydew': (240 / 255, 255 / 255, 240 / 255, 1),
'hotpink': (255 / 255, 105 / 255, 180 / 255, 1),
'indianred': (205 / 255, 92 / 255, 92 / 255, 1),
'indigo': (75 / 255, 0 / 255, 130 / 255, 1),
'ivory': (255 / 255, 255 / 255, 240 / 255, 1),
'khaki': (240 / 255, 230 / 255, 140 / 255, 1),
'lavender': (230 / 255, 230 / 255, 250 / 255, 1),
'lavenderblush': (255 / 255, 240 / 255, 245 / 255, 1),
'lawngreen': (124 / 255, 252 / 255, 0 / 255, 1),
'lemonchiffon': (255 / 255, 250 / 255, 205 / 255, 1),
'lightblue': (173 / 255, 216 / 255, 230 / 255, 1),
'lightcoral': (240 / 255, 128 / 255, 128 / 255, 1),
'lightcyan': (224 / 255, 255 / 255, 255 / 255, 1),
'lightgoldenrodyellow': (250 / 255, 250 / 255, 210 / 255, 1),
'lightgray': (211 / 255, 211 / 255, 211 / 255, 1),
'lightgreen': (144 / 255, 238 / 255, 144 / 255, 1),
'lightgrey': (211 / 255, 211 / 255, 211 / 255, 1),
'lightpink': (255 / 255, 182 / 255, 193 / 255, 1),
'lightsalmon': (255 / 255, 160 / 255, 122 / 255, 1),
'lightseagreen': (32 / 255, 178 / 255, 170 / 255, 1),
'lightskyblue': (135 / 255, 206 / 255, 250 / 255, 1),
'lightslategray': (119 / 255, 136 / 255, 153 / 255, 1),
'lightslategrey': (119 / 255, 136 / 255, 153 / 255, 1),
'lightsteelblue': (176 / 255, 196 / 255, 222 / 255, 1),
'lightyellow': (255 / 255, 255 / 255, 224 / 255, 1),
'lime': (0 / 255, 255 / 255, 0 / 255, 1),
'limegreen': (50 / 255, 205 / 255, 50 / 255, 1),
'linen': (250 / 255, 240 / 255, 230 / 255, 1),
'magenta': (255 / 255, 0 / 255, 255 / 255, 1),
'maroon': (128 / 255, 0 / 255, 0 / 255, 1),
'mediumaquamarine': (102 / 255, 205 / 255, 170 / 255, 1),
'mediumblue': (0 / 255, 0 / 255, 205 / 255, 1),
'mediumorchid': (186 / 255, 85 / 255, 211 / 255, 1),
'mediumpurple': (147 / 255, 112 / 255, 219 / 255, 1),
'mediumseagreen': (60 / 255, 179 / 255, 113 / 255, 1),
'mediumslateblue': (123 / 255, 104 / 255, 238 / 255, 1),
'mediumspringgreen': (0 / 255, 250 / 255, 154 / 255, 1),
'mediumturquoise': (72 / 255, 209 / 255, 204 / 255, 1),
'mediumvioletred': (199 / 255, 21 / 255, 133 / 255, 1),
'midnightblue': (25 / 255, 25 / 255, 112 / 255, 1),
'mintcream': (245 / 255, 255 / 255, 250 / 255, 1),
'mistyrose': (255 / 255, 228 / 255, 225 / 255, 1),
'moccasin': (255 / 255, 228 / 255, 181 / 255, 1),
'navajowhite': (255 / 255, 222 / 255, 173 / 255, 1),
'navy': (0 / 255, 0 / 255, 128 / 255, 1),
'oldlace': (253 / 255, 245 / 255, 230 / 255, 1),
'olive': (128 / 255, 128 / 255, 0 / 255, 1),
'olivedrab': (107 / 255, 142 / 255, 35 / 255, 1),
'orange': (255 / 255, 165 / 255, 0 / 255, 1),
'orangered': (255 / 255, 69 / 255, 0 / 255, 1),
'orchid': (218 / 255, 112 / 255, 214 / 255, 1),
'palegoldenrod': (238 / 255, 232 / 255, 170 / 255, 1),
'palegreen': (152 / 255, 251 / 255, 152 / 255, 1),
'paleturquoise': (175 / 255, 238 / 255, 238 / 255, 1),
'palevioletred': (219 / 255, 112 / 255, 147 / 255, 1),
'papayawhip': (255 / 255, 239 / 255, 213 / 255, 1),
'peachpuff': (255 / 255, 218 / 255, 185 / 255, 1),
'peru': (205 / 255, 133 / 255, 63 / 255, 1),
'pink': (255 / 255, 192 / 255, 203 / 255, 1),
'plum': (221 / 255, 160 / 255, 221 / 255, 1),
'powderblue': (176 / 255, 224 / 255, 230 / 255, 1),
'purple': (128 / 255, 0 / 255, 128 / 255, 1),
'red': (255 / 255, 0 / 255, 0 / 255, 1),
'rosybrown': (188 / 255, 143 / 255, 143 / 255, 1),
'royalblue': (65 / 255, 105 / 255, 225 / 255, 1),
'saddlebrown': (139 / 255, 69 / 255, 19 / 255, 1),
'salmon': (250 / 255, 128 / 255, 114 / 255, 1),
'sandybrown': (244 / 255, 164 / 255, 96 / 255, 1),
'seagreen': (46 / 255, 139 / 255, 87 / 255, 1),
'seashell': (255 / 255, 245 / 255, 238 / 255, 1),
'sienna': (160 / 255, 82 / 255, 45 / 255, 1),
'silver': (192 / 255, 192 / 255, 192 / 255, 1),
'skyblue': (135 / 255, 206 / 255, 235 / 255, 1),
'slateblue': (106 / 255, 90 / 255, 205 / 255, 1),
'slategray': (112 / 255, 128 / 255, 144 / 255, 1),
'slategrey': (112 / 255, 128 / 255, 144 / 255, 1),
'snow': (255 / 255, 250 / 255, 250 / 255, 1),
'springgreen': (0 / 255, 255 / 255, 127 / 255, 1),
'steelblue': (70 / 255, 130 / 255, 180 / 255, 1),
'tan': (210 / 255, 180 / 255, 140 / 255, 1),
'teal': (0 / 255, 128 / 255, 128 / 255, 1),
'thistle': (216 / 255, 191 / 255, 216 / 255, 1),
'tomato': (255 / 255, 99 / 255, 71 / 255, 1),
'turquoise': (64 / 255, 224 / 255, 208 / 255, 1),
'violet': (238 / 255, 130 / 255, 238 / 255, 1),
'wheat': (245 / 255, 222 / 255, 179 / 255, 1),
'white': (255 / 255, 255 / 255, 255 / 255, 1),
'whitesmoke': (245 / 255, 245 / 255, 245 / 255, 1),
'yellow': (255 / 255, 255 / 255, 0 / 255, 1),
'yellowgreen': (154 / 255, 205 / 255, 50 / 255, 1),
'activeborder': (0, 0, 1, 1),
'activecaption': (0, 0, 1, 1),
'appworkspace': (1, 1, 1, 1),
'background': (1, 1, 1, 1),
'buttonface': (0, 0, 0, 1),
'buttonhighlight': (0.8, 0.8, 0.8, 1),
'buttonshadow': (0.2, 0.2, 0.2, 1),
'buttontext': (0, 0, 0, 1),
'captiontext': (0, 0, 0, 1),
'graytext': (0.2, 0.2, 0.2, 1),
'highlight': (0, 0, 1, 1),
'highlighttext': (0.8, 0.8, 0.8, 1),
'inactiveborder': (0.2, 0.2, 0.2, 1),
'inactivecaption': (0.8, 0.8, 0.8, 1),
'inactivecaptiontext': (0.2, 0.2, 0.2, 1),
'infobackground': (0.8, 0.8, 0.8, 1),
'infotext': (0, 0, 0, 1),
'menu': (0.8, 0.8, 0.8, 1),
'menutext': (0.2, 0.2, 0.2, 1),
'scrollbar': (0.8, 0.8, 0.8, 1),
'threeddarkshadow': (0.2, 0.2, 0.2, 1),
'threedface': (0.8, 0.8, 0.8, 1),
'threedhighlight': (1, 1, 1, 1),
'threedlightshadow': (0.2, 0.2, 0.2, 1),
'threedshadow': (0.2, 0.2, 0.2, 1),
'window': (0.8, 0.8, 0.8, 1),
'windowframe': (0.8, 0.8, 0.8, 1),
'windowtext': (0, 0, 0, 1),
'none': (0, 0, 0, 0),
'transparent': (0, 0, 0, 0),
}
RGBA = re.compile(r'rgba\([ \n\r\t]*(.+?)[ \n\r\t]*\)')
RGB = re.compile(r'rgb\([ \n\r\t]*(.+?)[ \n\r\t]*\)')
HEX_RRGGBB = re.compile('#[0-9a-f]{6}')
HEX_RGB = re.compile('#[0-9a-f]{3}')
def color(string, opacity=1):
"""Replace ``string`` representing a color by a RGBA tuple.
See http://www.w3.org/TR/SVG/types.html#DataTypeColor
"""
if not string:
return (0, 0, 0, 0)
string = string.strip().lower()
if string in COLORS:
r, g, b, a = COLORS[string]
return (r, g, b, a * opacity)
match = RGBA.search(string)
if match:
r, g, b, a = tuple(
float(i.strip(' %')) / 100 if '%' in i else float(i) / 255
for i in match.group(1).split(','))
return (r, g, b, a * 255 * opacity)
match = RGB.search(string)
if match:
r, g, b = tuple(
float(i.strip(' %')) / 100 if '%' in i else float(i) / 255
for i in match.group(1).split(','))
return (r, g, b, opacity)
match = HEX_RRGGBB.search(string)
if match:
plain_color = tuple(
int(value, 16) / 255 for value in (
string[1:3], string[3:5], string[5:7]))
return plain_color + (opacity,)
match = HEX_RGB.search(string)
if match:
plain_color = tuple(
int(value, 16) / 15 for value in (
string[1], string[2], string[3]))
return plain_color + (opacity,)
return (0, 0, 0, 1)
|
[
"gruzdevasch@gmail.com"
] |
gruzdevasch@gmail.com
|
94ef4b15b8b61bb1acb9913ad5c3069aaed77362
|
e1b6cce87a76d967817cb979a9de8713abe66764
|
/forwards/pc_0.py
|
6a538d8b6afa2c7462bbdaed91bf2d20f0207c06
|
[] |
no_license
|
MaxAndrewNZ/AutonomousNavigation
|
816c773461f96446c02df23c2dbaacfa2448a35c
|
b70474c4f1f315c4609482fa3156430c64be7003
|
refs/heads/main
| 2023-02-02T05:26:52.874174
| 2020-12-07T22:46:03
| 2020-12-07T22:46:03
| 317,351,128
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 6,668
|
py
|
import sys
sys.path.insert(1, '../side_camera_test/')
import time,zmq,pickle
import numpy as np
import pyrealsense2 as rs
import open3d as o3d
import vehicle as veh
import pointcloud as pc
import visualise_pointclouds as visualise
import display_information as display
import cv2
import math
import random
import os
def fit_line_to_points(points):
X = points[:,0]
Y = points[:,1]
xbar = sum(X)/len(X)
ybar = sum(Y)/len(Y)
n = len(X) # or len(Y)
numer = sum([xi*yi for xi,yi in zip(X, Y)]) - n * xbar * ybar
denum = sum([xi**2 for xi in X]) - n * xbar**2
b = numer / denum
a = ybar - b * xbar
print('best fit line:\ny = {:.2f} + {:.2f}x'.format(a, b))
return a, b
def get_test_pointcloud(moving, shift_x, shift_y, delay=0.3):
# Use saved pointcloud file
filename = "1.ply"
pcd = o3d.io.read_point_cloud(filename)
npCloud = np.asarray(pcd.points)
# Flips points to align with those from the landrov
offset = np.array([-1.8 + shift_x, 0, -0.5 - shift_y])
pcd = pc.npToPcd(npCloud * np.array([1, -1, -1]) + offset)
# Simulate delays in recieving pointcloud
time.sleep(delay)
if moving:
shift_x += 0.05 * random.randint(0, 3)
shift_y += 0.05 * random.randint(0, 3)
return pcd, shift_x, shift_y
def flatten_cloud(cloud):
np_cloud = np.asarray(cloud.pcd.points)
removed_y = np.delete(np_cloud, 1, axis=1)
removed_dups = np.unique(removed_y, axis=0)
return removed_dups
def main():
"""
This method is the heart of the Landrov navigation.
It handles controling the multi-step navigation.
The navigation settings can be configured within this.
"""
############ Configuration ##################
testing = True
plotting_error = True
moving = True
target_distance = 1.0 # Meters
speed = 0 # 0 - 1
# Proportional and derivative constants
linear_p_const = 0
angular_p_const = 1
# Data lists
linear_errors = []
angular_errors = []
linear_velocities = []
angular_velocities = []
# Region of interest
minX = -2.5
maxX = 0
minY = -1.5
maxY = -0.25
minZ = 0.01
maxZ = 2.0
region_min = [minX, minY, minZ]
region_max = [maxX, maxY, maxZ]
vehicle = veh.Vehicle("tcp://192.168.8.106", "5556", "5557")
if testing == False:
vehicle.connect_control()
print('Connected to vehicle server')
found_cloud = False
updated_cloud = False
time_start = time.time()
shift_x = 0.1
shift_y = 0.1
try:
while 1:
time_start = time.time()
if (testing):
pcd, shift_x, shift_y = get_test_pointcloud(moving, shift_x, shift_y)
time_start = time.time()
found_cloud = True
if not found_cloud:
vehicle.connect_pointcloud()
while not found_cloud:
if len(zmq.select([vehicle.sensor_socket],[],[],0)[0]):
topic,buf = vehicle.sensor_socket.recv_multipart()
if topic == b'pointcloud':
np_pcd = np.fromstring(buf, dtype=np.float32)
num_points = np_pcd.size // 3
reshaped_pcd = np.resize(np_pcd, (num_points, 3))
pcd = o3d.geometry.PointCloud()
pcd.points = o3d.utility.Vector3dVector(reshaped_pcd)
print("Time get cloud", round(time.time() - time_start, 2))
time_start = time.time()
found_cloud = True
vehicle.sensor_socket.close()
else:
downpcd = pcd.voxel_down_sample(voxel_size=0.1)
cloud = pc.PointCloud(downpcd, [0, 0, 0], region_min, region_max)
cloud.pcd, ind = cloud.pcd.remove_statistical_outlier(nb_neighbors=20, std_ratio=2.0)
updated_cloud = True
if len(cloud.pcd.points) == 0:
break
flat_cloud = flatten_cloud(cloud)
# Print status
print("*" * 64)
template = "Points in cloud {}"
print(template.format(len(cloud.pcd.points)))
#TODO: Fit line to cloud.
a, b = fit_line_to_points(flat_cloud)
#TODO: Calculate angle error and distance error.
angle = - (math.atan(b) + (math.pi / 2))
a_error = angle
angular_p = angular_p_const * a_error
distance = abs(a / (math.sqrt((b ** 2 + 1))))
d_error = distance - target_distance
current_time = time.time()
if len(linear_errors) == 0:
linear_errors.append((current_time - 1, 0))
linear_p = linear_p_const * d_error
linear_errors.append((current_time, d_error))
# Wall angle error
angular_errors.append((current_time, a_error))
#TODO: Make a navigation adjustment from this information.
angular_velocity = max(min(angular_p + linear_p, 2), -2)
linear_velocity = speed
print("Target Distance:", target_distance, "Distance:", round(distance, 2), "D error:", round(d_error, 2))
print("Angle Degrees:", round(math.degrees(angle), 2), "Angle Rad:", round(angle, 2), "A error:", round(a_error, 2))
print("Linear velocity:", round(linear_velocity, 2), "Angular velocity:", round(angular_velocity, 2))
linear_velocities.append((current_time, linear_velocity))
angular_velocities.append((current_time, angular_velocity))
# Plot this information
if plotting_error:
display.display_line_follow(flat_cloud, a, b, region_min, region_max, linear_errors, angular_errors, linear_velocities, angular_velocities)
if updated_cloud:
print("Time processing", round(time.time() - time_start, 2))
if updated_cloud and not testing:
if moving:
vehicle.velocity_to_motor_command(linear_velocity, angular_velocity)
found_cloud = False
updated_cloud = False
except KeyboardInterrupt:
print("Force Close")
if not testing:
vehicle.stop()
display.display_errors(linear_errors, angular_errors)
main()
|
[
"mla138@uclive.ac.nz"
] |
mla138@uclive.ac.nz
|
c4501bbe8f20b230b42ebcc48b2dc670340da586
|
573307ca913f2bc73bcc498efee67cf61fc29800
|
/lessThanList.py
|
dbe067a8601c65e27c6c6b186513e280875254e8
|
[] |
no_license
|
JstD/PPL_FP
|
553d7af369f19a98e7c20d2a37216f253d01a2aa
|
e45e6d7412e60528d1faef9f9ccf09acdb57d30a
|
refs/heads/master
| 2023-03-29T20:12:34.713100
| 2021-04-03T07:00:39
| 2021-04-03T07:00:39
| 354,223,373
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 92
|
py
|
def lessThan(lst,num):
return [x for x in lst if x<num]
print(lessThan([1,2,3,4,5],4))
|
[
"dung.truong2000@hcmut.edu.vn"
] |
dung.truong2000@hcmut.edu.vn
|
935fa502303057323606ce4a66327440a1ef0018
|
f150f2dce61cdbaaa244e118c9e81e83a4886458
|
/eigenpro/training.py
|
5b296f7d919e0d707bb159e6248c2a240aa00f39
|
[
"MIT"
] |
permissive
|
johannespitz/kernel-overfitting
|
e060ca00fef7f7e563616dcc68909737a4449b5a
|
a654aaa49afc302d4e96a99cafebed0f5bbbd825
|
refs/heads/master
| 2020-05-23T22:34:07.844753
| 2020-04-24T19:50:19
| 2020-04-24T19:50:19
| 186,976,752
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 9,093
|
py
|
#!/usr/bin/env python
# coding: utf-8
# In[28]:
'''
Modified version of https://github.com/EigenPro/EigenPro-tensorflow
in particular run_expr.py
'''
from __future__ import print_function
import keras
import numpy as np
import time
import warnings
from dataclasses import dataclass
from scipy.stats import bernoulli
from distutils.version import StrictVersion
from keras.layers import Dense, Input
from keras.models import Model
from keras import backend as K
from eigenpro import kernels
from eigenpro import mnist
from eigenpro import ciphar
from eigenpro import synthetic
from eigenpro import utils
from eigenpro.backend_extra import hasGPU
from eigenpro.layers import KernelEmbedding, RFF
from eigenpro.optimizers import PSGD, SGD
assert StrictVersion(keras.__version__) >= StrictVersion('2.0.8'), "Requires Keras (>=2.0.8)."
if StrictVersion(keras.__version__) > StrictVersion('2.0.8'):
warnings.warn('\n\nEigenPro-tensorflow has been tested with Keras 2.0.8. '
'If the\ncurrent version (%s) fails, '
'switch to 2.0.8 by command,\n\n'
'\tpip install Keras==2.0.8\n\n' %(keras.__version__), Warning)
assert keras.backend.backend() == u'tensorflow', "Requires Tensorflow (>=1.2.1)."
assert hasGPU(), "Requires GPU."
# In[29]:
'''
Modified version of https://github.com/EigenPro/EigenPro-tensorflow
in particular kernels.py
'''
def D2(X, Y):
XX = np.sum(np.square(X), axis = 1, keepdims=True)
if X is Y:
YY = XX
else:
YY = np.sum(np.square(Y), axis = 1, keepdims=True)
XY = np.dot(X, np.transpose(Y))
d2 = np.reshape(XX, (np.shape(X)[0], 1)) + np.reshape(YY, (1, np.shape(Y)[0])) - 2 * XY
return d2
def Gaussian(X, Y, s):
assert s > 0
d2 = D2(X, Y)
gamma = np.float32(1. / (2 * s ** 2))
G = np.exp(-gamma * np.clip(d2, 0, None))
return G
def Laplace(X, Y, s):
assert s > 0
d2 = np.clip(D2(X, Y), 0, None)
d = np.sqrt(d2)
G = np.exp(- d / s)
return G
# In[30]:
def add_noise(y, noise):
n, dim = y.shape
y = np.argmax(y, axis=1)
change = np.array(bernoulli.rvs(noise / 100, size=n))
change = change * np.random.randint(dim, size=n)
y = np.mod(y + change, dim)
if noise == 100:
y = np.random.randint(dim, size=n)
return keras.utils.to_categorical(y, dim)
def my_norm(alpha, K):
cross_norm = alpha.T.dot(K).dot(alpha)
return np.sum(np.sqrt(np.diag(cross_norm)))
# In[38]:
def training(data_set_dict, kernel_dict, size_list, noise_list, MAXEPOCH=100):
trainers = {}
for dataset_name, ((x_train_full, y_train_full), (x_test_full, y_test_full)) in data_set_dict.items():
_, num_classes = y_train_full.shape
for kernel_name, (kernel_sgd, kernel_inv) in kernel_dict.items():
for size in size_list:
for noise in noise_list:
name = 'D:' + dataset_name + ' K:' + kernel_name + ' S:' + str(size) + ' N:' + str(noise)
print(name)
trainer = {'dataset': dataset_name, 'kernel': kernel_name, 'size': size, 'noise': noise}
x_train = x_train_full[0:size]
x_test = x_test_full
y_train = add_noise(y_train_full[0:size], noise)
y_test = add_noise(y_test_full, noise)
# Set the hyper-parameters.
bs = 256 # size of the mini-batch
M = min(size, 5000) # (EigenPro) subsample size
k = min(size - 1, 160) # (EigenPro) top-k eigensystem
n, D = x_train.shape # (n_sample, n_feature)
# Calculate step size and (Primal) EigenPro preconditioner.
kf, scale, s0 = utils.asm_eigenpro_f(
x_train, kernel_sgd, M, k, 1, in_rkhs=True)
eta = np.float32(1.5 / s0) # 1.5 / s0
eta = eta * num_classes # correction due to mse loss
input_shape = (D+1,) # n_feature, (sample) index
ix = Input(shape=input_shape, dtype='float32', name='indexed-feat-')
x, index = utils.separate_index(ix) # features, sample_id
kfeat = KernelEmbedding(kernel_sgd, x_train, input_shape=(D,))(x)
# Assemble kernel EigenPro trainer.
y = Dense(num_classes, input_shape=(n,),
activation='linear',
kernel_initializer='zeros',
use_bias=False,
name='trainable')(kfeat)
model = Model(ix, y)
model.compile(loss='mse', optimizer=PSGD(pred_t=y,
index_t=index,
eta=scale*eta,
eigenpro_f=lambda g: kf(g, kfeat)),
metrics=['accuracy'])
model.summary(print_fn=print)
print()
initial_epoch=0
np.random.seed(1) # Keras uses numpy random number generator
train_ts = 0 # training time in seconds
print("Stochastic Gradient Descent")
for epoch in range(1, MAXEPOCH + 1):
start = time.time()
model.fit(
utils.add_index(x_train), y_train,
batch_size=bs, epochs=epoch, verbose=0,
validation_data=(utils.add_index(x_test), y_test),
initial_epoch=initial_epoch)
train_ts += time.time() - start
tr_score = model.evaluate(utils.add_index(x_train), y_train, verbose=0)
te_score = model.evaluate(utils.add_index(x_test), y_test, verbose=0)
initial_epoch = epoch
if tr_score[1] == 1.0:
trainer['sgd_ce'] = 1 - te_score[1]
trainer['iterations'] = epoch
print("train error: %.2f%%\ttest error: %.2f%% (%d epochs, %.2f seconds)" %
((1 - tr_score[1]) * 100, (1 - te_score[1]) * 100, epoch, train_ts))
print("Zero Train Error")
print()
break
if epoch == MAXEPOCH:
trainer['sgd_ce'] = 1 - te_score[1]
trainer['iterations'] = 999999
print("train error: %.2f%%\ttest error: %.2f%% (%d epochs, %.2f seconds)" %
((1 - tr_score[1]) * 100, (1 - te_score[1]) * 100, epoch, train_ts))
print("Did not reach Zero Train Error")
print()
break
if epoch % 5 == 1:
print("train error: %.2f%%\ttest error: %.2f%% (%d epochs, %.2f seconds)" %
((1 - tr_score[1]) * 100, (1 - te_score[1]) * 100, epoch, train_ts))
alpah_sgd = np.array(model.get_layer("trainable").get_weights()[0])
del model
utils.reset()
# linear system
K_train = kernel_inv(x_train, x_train)
if size <= 20000:
alpha = np.linalg.solve(K_train, y_train)
## this was a test -> alpha and the trainable layer are interchangable
# alpha = model.get_layer("trainable").get_weights()[0]
K_test = kernel_inv(x_train, x_test)
pred = K_test.T.dot(alpha)
miss_count = np.count_nonzero(np.argmax(pred, axis=1) - np.argmax(y_test, axis=1))
miss_rate = miss_count / y_test.shape[0]
trainer['inv_ce'] = miss_rate
print("Linear Interpolation")
print("Classification Error = " + str(miss_rate))
print()
trainer['inv_norm'] = my_norm(alpha, K_train)
trainer['sgd_norm'] = my_norm(alpah_sgd, K_train)
trainers[name] = trainer
K_train = None
K_test = None
utils.reset()
print()
print()
print(trainers)
print()
print()
print("Done")
return trainers
|
[
"johannes.pitz@tum.de"
] |
johannes.pitz@tum.de
|
c137360796290d8e49d6e99af906017dcf7bd04d
|
8908ac4efbb943e05cda86d84b11264f4e31a59e
|
/addons/to_paypal_unsupported_currencies/models/account_payment.py
|
a39199982bd52ca42d5d1361dcf480db69ee07a3
|
[
"Unlicense"
] |
permissive
|
kit9/vocal_v12
|
c38c17921a647c16a839110d3452dddcaf3f0036
|
480990e919c9410903e06e7813ee92800bd6a569
|
refs/heads/master
| 2023-02-01T15:55:13.461862
| 2020-12-15T12:06:06
| 2020-12-15T12:06:06
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,057
|
py
|
from odoo import models, fields
class AccountPayment(models.Model):
_inherit = 'account.payment'
paypal_original_unsupported_currency_id = fields.Many2one('res.currency', string='Paypal Original Unsupported Currency',
help="A technical field to store the original Paypal unsupported currency"
" in case of payment with Paypal using a currency that is not supported by Paypal.")
paypal_original_unsupported_currency_amount = fields.Monetary(string='Paypal Original Unsupported Currency Amount',
currency_field='paypal_original_unsupported_currency_id',
help="A technical field to store the original Paypal unsupported currency amount"
" in case of payment with Paypal using a currency that is not supported by Paypal.")
|
[
"vijay+admin@wearme.me"
] |
vijay+admin@wearme.me
|
3c8054330d2faa9eac755a30f468ca9a147bf06a
|
673f1a46e00cd3239e459138d9e592ce34dc5b26
|
/demo/migrations/0001_initial.py
|
90360a97867d16368e68e66a47ba3821b8256616
|
[] |
no_license
|
jw1174184386/rolemanage
|
59db121dfc91fb557d036c8066f7328a9df3c87a
|
e0f844b6890c70702d3c4333741336570b6a384f
|
refs/heads/master
| 2020-04-15T12:13:19.330381
| 2019-01-08T14:24:08
| 2019-01-08T14:24:08
| 164,665,320
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 4,849
|
py
|
# Generated by Django 2.1.2 on 2019-01-08 03:47
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Action',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=50, verbose_name='动作名')),
('action', models.CharField(max_length=50, verbose_name='具体动作')),
],
options={
'verbose_name': '动作表',
'verbose_name_plural': '动作表',
},
),
migrations.CreateModel(
name='Menu',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=20, verbose_name='菜单名')),
('parent', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='demo.Menu')),
],
options={
'verbose_name': '菜单表',
'verbose_name_plural': '菜单表',
},
),
migrations.CreateModel(
name='Permission',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=50, verbose_name='权限名称')),
('url', models.CharField(max_length=200, verbose_name='权限URL')),
('menu', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='demo.Menu')),
],
options={
'verbose_name': '权限表',
'verbose_name_plural': '权限表',
},
),
migrations.CreateModel(
name='PermissionAction',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('action', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='demo.Action', verbose_name='动作')),
('permission', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='demo.Permission', verbose_name='权限')),
],
options={
'verbose_name': '权限动作中间表',
'verbose_name_plural': '权限动作中间表',
},
),
migrations.CreateModel(
name='Role',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=50, verbose_name='角色名称')),
],
options={
'verbose_name': '角色表',
'verbose_name_plural': '角色表',
},
),
migrations.CreateModel(
name='RolePermissionAction',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('permission_action', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='demo.PermissionAction')),
('role', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='demo.Role')),
],
options={
'verbose_name': '角色和权限动作中间表',
'verbose_name_plural': '角色和权限动作中间表',
},
),
migrations.CreateModel(
name='User',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('username', models.CharField(max_length=50, verbose_name='用户名')),
('password', models.CharField(max_length=32, verbose_name='密码')),
],
options={
'verbose_name': '用户表',
'verbose_name_plural': '用户表',
},
),
migrations.CreateModel(
name='UserRole',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('role', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='demo.Role')),
('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='demo.User')),
],
options={
'verbose_name': '用户和角色之间的中间表',
'verbose_name_plural': '用户和角色之间的中间表',
},
),
]
|
[
"jw1174184386@163.com"
] |
jw1174184386@163.com
|
16bdf1311ec0dd7bb5b4d66680fad7469efdf356
|
2f4b95f4b17337f02c21f33f7aa2ce11476898ff
|
/superlists/lists/tests/test_models.py
|
17334b2a932fbd11564264621a19bfdffdf5f4b6
|
[] |
no_license
|
Wowip/EjerciciosTDD
|
6c891d03250462408dbb25d5d36004c092d6dbe2
|
940c0fcae6a95998c1c013a35f92e659167de67b
|
refs/heads/master
| 2020-08-01T02:13:03.887136
| 2016-11-20T19:18:49
| 2016-11-20T19:18:49
| 73,586,488
| 0
| 0
| null | 2016-11-18T06:59:20
| 2016-11-13T00:21:46
|
Python
|
UTF-8
|
Python
| false
| false
| 1,914
|
py
|
from django.core.exceptions import ValidationError
from django.test import TestCase
from lists.models import Item, List
class ItemModelTest(TestCase):
def test_default_text(self):
item = Item()
self.assertEqual(item.text, '')
def test_item_is_related_to_list(self):
list_ = List.objects.create()
item = Item()
item.list = list_
item.save()
self.assertIn(item, list_.item_set.all())
def test_cannot_save_empty_list_items(self):
list_ = List.objects.create()
item = Item(list=list_, text='')
with self.assertRaises(ValidationError):
item.save()
item.full_clean()
def test_duplicate_items_are_invalid(self):
list_ = List.objects.create()
Item.objects.create(list=list_, text='bla')
with self.assertRaises(ValidationError):
item = Item(list=list_, text='bla')
item.full_clean()
def test_CAN_save_same_item_to_different_lists(self):
list1 = List.objects.create()
list2 = List.objects.create()
Item.objects.create(list=list1, text='bla')
item = Item(list=list2, text='bla')
item.full_clean() # should not raise
def test_list_ordering(self):
list1 = List.objects.create()
item1 = Item.objects.create(list=list1, text='i1')
item2 = Item.objects.create(list=list1, text='item 2')
item3 = Item.objects.create(list=list1, text='3')
self.assertEqual(
list(Item.objects.all()),
[item1, item2, item3]
)
def test_string_representation(self):
item = Item(text='some text')
self.assertEqual(str(item), 'some text')
class ListModelTest(TestCase):
def test_get_absolute_url(self):
list_ = List.objects.create()
self.assertEqual(list_.get_absolute_url(), '/lists/%d/' % (list_.id,))
|
[
"arturoinosencio@gmail.com"
] |
arturoinosencio@gmail.com
|
fcc0647cba72938ea38d2263d8274cac61efb22f
|
e29713b4e094b17ee6e0fdc88624825cd649abc4
|
/Python Codes 2/phone_letters.py
|
48a727c375ee1bb9e2ec702d9ca9f5aa6f0cae22
|
[] |
no_license
|
debolina-ca/my-projects
|
272fca1c961cc68b85e28226a2afc6d4929ba26e
|
b8c433d5a35645da8ad2fcb28238a40daa18bc9b
|
refs/heads/master
| 2020-12-27T18:42:06.248234
| 2020-02-03T19:31:31
| 2020-02-03T19:31:31
| 238,008,068
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 304
|
py
|
# Phone Letters
phone_letters = [
"1 = ''", "2 = 'ABC'", "3 = 'DEF'",
"4 = 'GHI'", "5 = 'JKL'", "6 = 'MNO'",
"7 = 'PQRS'", "8 = 'TUV'", "9 = 'WXYZ'",
"*", "0 = ' '", "#"
]
print(phone_letters[0:3])
print(phone_letters[3:6])
print(phone_letters[6:9])
print(phone_letters[9:12])
|
[
"noreply@github.com"
] |
noreply@github.com
|
72f4df5dc0c06e943c09f1516ec2cc3850c46820
|
a6ceb9e0429f02275159d95142e515b01a6d47b5
|
/bmi3d/open_hdf_tables.py
|
ca29b86e76d62db2388d3ccfc665e2a6865cca1f
|
[] |
no_license
|
m-nolan/aopy_dev
|
0e699236ea0b82deed1781cf8dcecbe9ecc56c27
|
794200222e0ac73dc98cf2adc28c63b8e4f18040
|
refs/heads/main
| 2023-04-02T13:15:21.098852
| 2021-03-30T20:01:39
| 2021-03-30T20:01:39
| 344,970,001
| 0
| 0
| null | 2021-03-25T23:11:58
| 2021-03-06T00:35:16
|
Python
|
UTF-8
|
Python
| false
| false
| 566
|
py
|
import tables
import numpy
import matplotlib.pyplot as plt
#replace this with your hdf filename
#fname = 'c:\\Users\\Si Jia\\AppData\\Local\\Temp\\tmp9fswwtwp.h5'
fname = '/tmp/tmpdcbqn2zo.h5'
hdffile = tables.open_file(fname,'r') #read-onl
print(hdffile)
#get table information
# more methods refer to this
# https://www.pytables.org/usersguide/libref/structured_storage.html#tables.Table
table = hdffile.root.task
print(table.description)
#look at cursor trajectory
cursor_coor = table.col('cursor')
plt.plot(cursor_coor[:,0], cursor_coor[:,2])
plt.show()
|
[
"manolan@uw.edu"
] |
manolan@uw.edu
|
a54d47e36ae5a6c355b6eeb86ee81846d8e817a5
|
206f9385bcb87bf59f5a577043c0abfed8ab0066
|
/Asynchronous_IO/event_loop_dif_thread.py
|
13ad2d93012b41d1f008674bf0294785baf6e367
|
[] |
no_license
|
XiangSugar/Python
|
7bca1ea5a90d880f1ed4f0b3dd4fc3310caf7fdc
|
2356dc3342dbc9c474cf0d9f25b1dc7930bc8814
|
refs/heads/master
| 2021-04-12T01:51:26.751494
| 2018-09-04T01:25:48
| 2018-09-04T01:25:48
| 125,846,325
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 890
|
py
|
# coding = utf-8
from threading import Thread, currentThread
import asyncio
import time
now = lambda: time.time()
def start_loop(loop):
asyncio.set_event_loop(loop)
loop.run_forever()
def more_work(x):
print('%s' % currentThread())
print('More work {}'.format(x))
time.sleep(x)
print('Finished more work {}'.format(x))
start = now()
new_loop = asyncio.new_event_loop()
t = Thread(target=start_loop, args=(new_loop,))
t.start()
print('TIME: {}'.format(time.time() - start))
print('%s' % currentThread())
new_loop.call_soon_threadsafe(more_work, 6)
new_loop.call_soon_threadsafe(more_work, 3)
# '''
# 启动上述代码之后，当前线程不会被 block，新线程中会按照顺序执行
# call_soon_threadsafe 方法注册的 more_work 方法，后者因为
# time.sleep 操作是同步阻塞的，因此运行完毕 more_work 需要大致 6 + 3
# '''
|
[
"suxiang@hust.edu.cn"
] |
suxiang@hust.edu.cn
|
9c39ba0a267b3fb8b32d1167382688f2d07176a5
|
5950e578d3c6239987bc189951334cc87ca1a966
|
/198. House Robber.py
|
fc45a3e04b49703b17b6b5bbbecf92e6bf7d5771
|
[] |
no_license
|
a5135324/leetcode
|
0aa5ddc42569f9a619394197afcd1b29e856687e
|
c3eb9000154859669ed18054eca04c44023ef496
|
refs/heads/master
| 2021-02-14T14:40:52.336373
| 2020-12-27T09:03:59
| 2020-12-27T09:03:59
| 244,812,348
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 536
|
py
|
'''
Detail:
Runtime: 20 ms, faster than 98.54% of Python3 online submissions for House Robber.
Memory Usage: 12.8 MB, less than 100.00% of Python3 online submissions for House Robber.
Submit time: 2020/03/06 13:37(UTC+8)
'''
class Solution:
def rob(self, nums: List[int]) -> int:
n = len(nums)
dp = [0,0,0]
ans = 0
for i in range(3,n+3):
dp.append(max(dp[i-3]+nums[i-3], dp[i-2]+nums[i-3]))
if dp[i] > ans:
ans = dp[i]
return ans
|
[
"a5135324@gmail.com"
] |
a5135324@gmail.com
|
2d11d716b8d9b87ddcac994061c1cbae63557549
|
b2599eaa38eb035555b1aebab1cb188fa4e01cbe
|
/whileloop.py
|
37e3b220880f685cb4263dcc38659e66243c34a4
|
[] |
no_license
|
surut555/basicpython
|
c1f14c136480f4cda92eae1eeecdf407f974b6fb
|
7ae86bfb488c91243a802760646d1f3f0441435f
|
refs/heads/main
| 2023-01-04T02:42:20.987473
| 2020-11-01T02:33:46
| 2020-11-01T02:33:46
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 163
|
py
|
i = 1
while i <= 10:
if i == 10:
print(i)
else:
print(i, end=',')
i = i+1
a = 1
while True: # infinity loop
print(a)
a = a+1
|
[
"63528254+surut555@users.noreply.github.com"
] |
63528254+surut555@users.noreply.github.com
|
2a5de420a068fa3e361c24ec82beef335291f181
|
527af4c3c48678d8b167cb9b23d90d57c7606dd3
|
/src/tests/test_models.py
|
927c23c7b071ebbd61d368716e1052348f0afaae
|
[
"MIT"
] |
permissive
|
PRByTheBackDoor/ElectionRunner
|
8713e398e8fc2fece65eb22e4dc5193bccac108e
|
77f822b5ac4e21fa567950a762a9595a8ca08007
|
refs/heads/master
| 2020-04-06T04:30:56.959287
| 2014-12-27T00:22:11
| 2014-12-27T00:22:11
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 5,443
|
py
|
# The MIT License (MIT)
#
# Copyright (c) 2014 PRByTheBackDoor
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""Provides unit tests for the ``models'' package."""
from unittest import TestCase, main
from models import Election, Constituency, Party, Candidate, Outcome
class ElectionTests(TestCase):
"""Test all public functions provided by the Election() class."""
def setUp(self):
pass
def test_election(self):
"""Test the public ``add_candidate'' function provided by the
Election() class.
"""
el = Election()
con1 = Constituency("test")
con2 = Constituency("test2")
party1 = Party("party1")
party2 = Party("party2")
candidate1 = Candidate("candidate1", party1, con1)
candidate2 = Candidate("candidate2", party2, con1)
candidate3 = Candidate("candidate3", party2, con2)
el.add_candidate(candidate1)
self.assertTrue(candidate1 in el.candidates)
self.assertTrue(party1 in el.parties)
self.assertTrue(con1 in el.constituencies)
with self.assertRaises(AssertionError):
el.add_candidate(candidate1)
el.add_candidate(candidate2)
self.assertTrue(candidate2 in el.candidates)
self.assertTrue(party1 in el.parties)
self.assertTrue(con1 in el.constituencies)
self.assertEqual(len(el.candidates), 2)
self.assertEqual(len(el.parties), 2)
self.assertEqual(len(el.constituencies), 1)
el.add_candidate(candidate3)
self.assertTrue(candidate3 in el.candidates)
self.assertTrue(party2 in el.parties)
self.assertTrue(con2 in el.constituencies)
self.assertEqual(len(el.candidates), 3)
self.assertEqual(len(el.parties), 2)
self.assertEqual(len(el.constituencies), 2)
class ConstituencyTests(TestCase):
"""Test all public functions provided by the Constituency() class."""
def setUp(self):
pass
def test_add_candidate(self):
"""Test the public ``add_candidate'' function provided by the
Constituency() class.
"""
con = Constituency("test")
con2 = Constituency("test2")
party1 = Party("party1")
party2 = Party("party2")
party3 = Party("party3")
candidate1 = Candidate("candidate1", party1, con)
candidate2 = Candidate("candidate2", party2, con)
candidate3 = Candidate("candidate3", party3, con2)
candidate4 = Candidate("candidate4", party2, con)
con.add_candidate(candidate1)
self.assertTrue(candidate1 in con.candidates)
self.assertEqual(len(con.candidates), 1)
# attempt to add a candidate twice
with self.assertRaises(AssertionError):
con.add_candidate(candidate1)
self.assertEqual(len(con.candidates), 1)
self.assertEqual(len(con.parties), 1)
con.add_candidate(candidate2)
self.assertTrue(candidate1 in con.candidates)
self.assertTrue(candidate2 in con.candidates)
self.assertEqual(len(con.candidates), 2)
self.assertEqual(len(con.parties), 2)
# attempt to add a candidate with the wrong constituency
with self.assertRaises(AssertionError):
con.add_candidate(candidate3)
self.assertEqual(len(con.candidates), 2)
# attempt to add a candidate with the same party
with self.assertRaises(AssertionError):
con.add_candidate(candidate4)
self.assertEqual(len(con.candidates), 2)
class OutcomeTests(TestCase):
"""Test all public functions provided by the Outcome() class."""
def setUp(self):
pass
def test_add_winner(self):
"""Test the public ``add_winner'' function provided by the
Outcome() class.
"""
con = Constituency("test")
con2 = Constituency("test2")
party1 = Party("party1")
party2 = Party("party2")
candidate1 = Candidate("candidate1", party1, con)
candidate2 = Candidate("candidate2", party2, con2)
outcome = Outcome()
outcome.add_winner(candidate1)
self.assertEqual(len(outcome.winners), 1)
self.assertTrue(candidate1 in outcome.winners)
# attempt to add the same candidate
with self.assertRaises(AssertionError):
outcome.add_winner(candidate1)
if __name__ == '__main__':
main()
|
[
"oghm2-github@srcf.net"
] |
oghm2-github@srcf.net
|
9484689e364e1a12491127ddc0afa4929c215d8d
|
9f541271263dceb0b7b0134ab6cff5ed324c6444
|
/json/conf.py
|
cb6e2722d1f1194238a9bb9841615fcfe3adf803
|
[] |
no_license
|
shannondec/bonaventureli.github.io
|
bd0fa5286ab4077b690f2621425ddd78f16e72dc
|
ab442ff704dc539b5c9da1d7cacb826256392c17
|
refs/heads/main
| 2023-06-04T10:34:40.224571
| 2021-06-29T08:38:53
| 2021-06-29T08:38:53
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,837
|
py
|
# Configuration file for the Sphinx documentation builder.
#
# This file only contains a selection of the most common options. For a full
# list see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# -- Path setup --------------------------------------------------------------
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
# import os
# import sys
# sys.path.insert(0, os.path.abspath('.'))
# -- Project information -----------------------------------------------------
project = 'JSON'
copyright = '2021, bona'
author = 'bona'
# -- General configuration ---------------------------------------------------
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path.
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = 'alabaster'
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
|
[
"lfwendula@msn.cn"
] |
lfwendula@msn.cn
|
26c93247ee4200baadf6355f694c14262a0ea35e
|
0d09e32620e2e82f243ba86e2cc7bec19e521b1b
|
/Exercises/01-Sequential-Structure/ex06.py
|
ac27e05e4d8dd83905a5665183e94f38cefa3c27
|
[] |
no_license
|
hikarocarvalho/Python_Wiki
|
401f7466377f2053cda8bfa850afd0bd64cce047
|
01f755ecc18de13a9ded794ece9e7a8bd4ad7d9e
|
refs/heads/main
| 2023-06-14T08:37:10.728067
| 2021-07-12T20:24:41
| 2021-07-12T20:24:41
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 270
|
py
|
#the user gives the ray value
#o usuário dá o valor do raio
ray = float(input("Enter with the ray value: "))
#calculate the area of a circle
#calcula a área do circulo
area = ray**2 * 3.14
#Show the result
#mostra o resultado
print("The area of this circle is:",area)
|
[
"hikarofcarvalho@gmail.com"
] |
hikarofcarvalho@gmail.com
|
91a53658d1e9736bda6759fad4317665e4ce9a63
|
796654a4e4961a764b2d7e036971da049a3b3cae
|
/project_2/bayes.py
|
f92b6ac248af1dce8b40d01e11b6b5a9c33f129f
|
[] |
no_license
|
nattip/CIS678
|
9cfe6ab6fbec855456140e98234b2ed358c20403
|
aceffe9144577727e10feb40a7e8ae9e2948e4a5
|
refs/heads/master
| 2022-07-09T11:12:45.863383
| 2020-04-02T15:15:25
| 2020-04-02T15:15:25
| 231,259,734
| 0
| 1
| null | 2022-06-22T01:15:18
| 2020-01-01T20:20:40
|
Python
|
UTF-8
|
Python
| false
| false
| 11,604
|
py
|
# Written by Natalie Tipton
# February 2, 20202
# CIS 678 - Machine Learning
# Dr. Greg Wolffe
# Spam/Ham Classification of text messages using
# the Naive Bayes algorithm
from collections import Counter
import string
import math
import heapq
import matplotlib.pyplot as plt
import numpy as np
#################################################
# Function to clean incoming data:
# Turn all letters lower case
# Remove all punctuation
# Remove all numeric-only strings
def clean_words(all_words):
cleaned_words = []
for word in all_words:
word = word.lower()
for character in word:
if character in string.punctuation:
word = word.replace(character, "")
if not word.isnumeric() and word != "":
cleaned_words.append(word)
return cleaned_words
#################################################
if __name__ == "__main__":
# Raw text sorting
ham_raw = []
spam_raw = []
# Unique words for ham or spam
all_words = []
vocab = set()
# Probabilities of words in each class
prob_ham = {}
prob_spam = {}
prob_diff = {}
# initial counts for number of ham/spam messages
ham_count = 0
spam_count = 0
# read in file one line at a time
with open("./train.data") as f:
lines = f.readlines()
# Read all of the lines and append them to their classification
for line in lines:
if line.startswith("ham"):
# Get the whole string
ham_count += 1
raw_text = "".join(line.split("ham"))[1:].rstrip()
# split string by spaces and append each word appropriately
for val in raw_text.split(" "):
all_words.append(val)
ham_raw.append(val)
if line.startswith("spam"):
spam_count += 1
raw_text = "".join(line.split("spam"))[1:].rstrip()
for val in raw_text.split(" "):
all_words.append(val)
spam_raw.append(val)
# clean words in all classifications
cleaned_words = clean_words(all_words)
cleaned_ham_words = clean_words(ham_raw)
cleaned_spam_words = clean_words(spam_raw)
# count up occurrences of each word in all places
cleaned_words_counts = Counter(cleaned_words)
cleaned_ham_word_counts = Counter(cleaned_ham_words)
cleaned_spam_word_counts = Counter(cleaned_spam_words)
# create vocabulary with no repeating words
vocab = set(cleaned_words)
# remove 5 most common words in all messages
vocab.remove("to")
vocab.remove("i")
vocab.remove("you")
vocab.remove("a")
vocab.remove("the")
# find sizes of all different sets of words
vocab_size = len(vocab)
spam_size = len(cleaned_spam_words)
ham_size = len(cleaned_ham_words)
# make dictionaries of spam and ham words with the probability
# that each word will occur in either classification
for word in vocab:
prob_spam[word] = (cleaned_spam_word_counts[word] + 1) / (
spam_size + vocab_size
)
prob_ham[word] = (cleaned_ham_word_counts[word] + 1) / (
ham_size + vocab_size
)
# find the difference between spam and ham probabilities
# for future analysis of most obvious classifications
prob_diff[word] = prob_ham[word] - prob_spam[word]
# Use this to find words that are common in everything
# and maybe not count those for bayes
# print(cleaned_words_counts.most_common(5))
# calculate overall percentage of spam and ham messages in training
prob_of_ham_message = ham_count / (ham_count + spam_count)
prob_of_spam_message = spam_count / (ham_count + spam_count)
# lists of true and hypothesized classifications
true_class = []
hyp_class = []
# open test data line by line
with open("./test.data") as f:
lines = f.readlines()
# set counters for true and hypothesized classes to 0
test_ham_count = 0
test_spam_count = 0
hyp_ham_count = 0
hyp_spam_count = 0
# go through lines 1 at a time
for line in lines:
# reset the big product for naive bayes calculation back to 0
big_product_ham = 0
big_product_spam = 0
# pull the true classification off the message into a list
true_class.append(line.split()[0])
# count up the true occurrences for percentage calculations
if line.split()[0] == "ham":
test_ham_count += 1
if line.split()[0] == "spam":
test_spam_count += 1
# leave only the message w/o the classification remaining
message = line.split()[1:]
# for each word in the message
for word in message:
# do not count if word is not in vocabulary
if word not in vocab:
continue
# naive bayes formula using log rules
big_product_ham += math.log10(prob_ham[word])
big_product_spam += math.log10(prob_spam[word])
cnb_ham = math.log10(prob_of_ham_message) + big_product_ham
cnb_spam = math.log10(prob_of_spam_message) + big_product_spam
# classify message
if cnb_ham > cnb_spam:
hyp_class.append("ham")
hyp_ham_count += 1
elif cnb_ham < cnb_spam:
hyp_class.append("spam")
hyp_spam_count += 1
else:
hyp_class.append("ham")
hyp_ham_count += 1
true_pos = 0
true_neg = 0
false_pos = 0
false_neg = 0
# count up true and false pos and negs
for i in range(0, len(true_class)):
if true_class[i] == "spam" and hyp_class[i] == "spam":
true_pos += 1
elif true_class[i] == "ham" and hyp_class[i] == "ham":
true_neg += 1
elif true_class[i] == "spam" and hyp_class[i] == "ham":
false_neg += 1
elif true_class[i] == "ham" and hyp_class[i] == "spam":
false_pos += 1
# calculate metrics for model
correct = (
100 * (true_pos + true_neg) / (true_pos + true_neg + false_pos + false_neg)
)
recall = 100 * (true_pos / (true_pos + false_neg))
tnr = 100 * (true_neg / (true_neg + false_pos))
precision = 100 * (true_pos / (true_pos + false_pos))
#################################################
# Output
# Printed metrics
# Pie Charts
# Bar Charts
print("\ntrue positives =", true_pos)
print("true negatives =", true_neg)
print("false positives =", false_pos)
print("false negatives =", false_neg)
print("\nRecall =", recall)
print("Precision =", precision)
print("True Negative Rate =", tnr)
print("correct classification =", correct, "\n")
# determining what the most telling spam and ham words are
# print(heapq.nlargest(5, prob_diff, key=prob_diff.get))
# print(heapq.nsmallest(5, prob_diff, key=prob_diff.get))
# create pie charts to show percentage of spam and ham
# messages in training and testing and what the model
# determined for the testing set
labels = "Spam", "Ham"
sizes = [prob_of_spam_message, prob_of_ham_message]
explode = (0.1, 0) # only "explode" the 2nd slice (i.e. 'Hogs')
fig1, ax1 = plt.subplots()
ax1.pie(
sizes,
explode=explode,
labels=labels,
autopct="%1.1f%%",
shadow=True,
startangle=90,
)
ax1.axis("equal") # Equal aspect ratio ensures that pie is drawn as a circle.
plt.title("True Training Percentages")
plt.show()
labels = "Spam", "Ham"
sizes = [
test_spam_count / (test_spam_count + test_ham_count),
test_ham_count / (test_spam_count + test_ham_count),
]
explode = (0.1, 0) # only "explode" the 2nd slice (i.e. 'Hogs')
fig2, ax1 = plt.subplots()
ax1.pie(
sizes,
explode=explode,
labels=labels,
autopct="%1.1f%%",
shadow=True,
startangle=90,
)
ax1.axis("equal") # Equal aspect ratio ensures that pie is drawn as a circle.
plt.title("True Testing Percentages")
plt.show()
labels = "Spam", "Ham"
sizes = [
hyp_spam_count / (hyp_spam_count + hyp_ham_count),
hyp_ham_count / (hyp_spam_count + hyp_ham_count),
]
explode = (0.1, 0) # only "explode" the 2nd slice (i.e. 'Hogs')
fig3, ax1 = plt.subplots()
ax1.pie(
sizes,
explode=explode,
labels=labels,
autopct="%1.1f%%",
shadow=True,
startangle=90,
)
ax1.axis("equal") # Equal aspect ratio ensures that pie is drawn as a circle.
plt.title("Hypothesized Testing Percentages")
plt.show()
# create stacked bar charts to show the probability of spam or ham
# for the most telling spam words and then the most telling ham words
plt.figure(4)
N = 5
# showing probability for the words determined to be most telling for spam
top_spam_probs = (
prob_spam["call"],
prob_spam["free"],
prob_spam["txt"],
prob_spam["claim"],
prob_spam["your"],
)
low_ham_probs = (
prob_ham["call"],
prob_ham["free"],
prob_ham["txt"],
prob_ham["claim"],
prob_ham["your"],
)
ind = np.arange(N) # the x locations for the groups
width = 0.35 # the width of the bars: can also be len(x) sequence
p1 = plt.bar(ind, low_ham_probs, width)
p2 = plt.bar(ind, top_spam_probs, width, bottom=low_ham_probs)
plt.ylabel("Probability of Word")
plt.title("Probability of Spam or Ham\nFor Most Telling Spam Words")
plt.xticks(ind, ("call", "free", "txt", "claim", "your"))
plt.legend((p1[0], p2[0]), ("Ham", "Spam"))
plt.show()
plt.figure(5)
N = 5
# showing probability for the words determined to be most telling for ham
low_spam_probs = (
prob_spam["my"],
prob_spam["me"],
prob_spam["in"],
prob_spam["it"],
prob_spam["u"],
)
top_ham_probs = (
prob_ham["my"],
prob_ham["me"],
prob_ham["in"],
prob_ham["it"],
prob_ham["u"],
)
ind = np.arange(N) # the x locations for the groups
width = 0.35 # the width of the bars: can also be len(x) sequence
p1 = plt.bar(ind, low_spam_probs, width)
p2 = plt.bar(ind, top_ham_probs, width, bottom=low_spam_probs)
plt.ylabel("Probability of Word")
plt.title("Probability of Spam or Ham\nFor Most Telling Ham Words")
plt.xticks(ind, ("my", "me", "in", "it", "u"))
plt.legend((p1[0], p2[0]), ("Spam", "Ham"))
plt.show()
|
[
"tiptonna@mail.gvsu.edu"
] |
tiptonna@mail.gvsu.edu
|
e5159573514325ddff9f0569957cbbf720a52f0e
|
a34ec07c3464369a88e68c9006fa1115f5b61e5f
|
/B_HashTable/Basic/L1_2593_Find_Score_of_an_Array_After_Marking_All_Elements.py
|
c21970e05cffcfd0aa4f1a71aaa041f071a3ed8a
|
[] |
no_license
|
824zzy/Leetcode
|
9220f2fb13e03d601d2b471b5cfa0c2364dbdf41
|
93b7f4448a366a709214c271a570c3399f5fc4d3
|
refs/heads/master
| 2023-06-27T02:53:51.812177
| 2023-06-16T16:25:39
| 2023-06-16T16:25:39
| 69,733,624
| 14
| 3
| null | 2022-05-25T06:48:38
| 2016-10-01T10:56:07
|
Python
|
UTF-8
|
Python
| false
| false
| 493
|
py
|
""" https://leetcode.com/problems/find-score-of-an-array-after-marking-all-elements/
Implement the problem description using a seen array
"""
from header import *
class Solution:
def findScore(self, A: List[int]) -> int:
seen = [0]*(len(A)+2)
ans = 0
for i, x in sorted(enumerate(A), key=lambda x: x[1]):
if not seen[i]:
ans += x
seen[i] = 1
seen[i-1] = 1
seen[i+1] = 1
return ans
|
[
"zhengyuan.zhu@mavs.uta.edu"
] |
zhengyuan.zhu@mavs.uta.edu
|
60cda957b628771dede0236cb5bbb72670ae6f12
|
e95d6f6842e7d32a2933676e12d73cbe8cf9d7d4
|
/JSON_BOOK_Programs/1_Theano_example.py
|
505d5f01450e75013c437208ed149f090545f781
|
[] |
no_license
|
MehreenTariq12/mehru
|
87acda07c564f37107aa8a3e2da247216c734d35
|
af5da763197696394dfe751d2c54e3caab7d3f62
|
refs/heads/master
| 2022-06-24T03:59:54.542892
| 2020-05-10T06:03:05
| 2020-05-10T06:03:05
| 256,930,770
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 160
|
py
|
import theano
from theano import tensor
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a, b], c)
result = f(1, 2)
print(result)
|
[
"noreply@github.com"
] |
noreply@github.com
|
f6a2b705d388a7c343310c3da3e8ed2698926621
|
14e3ecd6a5bfc4cba3b990d561a3d6db70f43430
|
/UDA/main.py
|
37d29c6ca6da7c86a831b725c3200b77e446e89d
|
[] |
no_license
|
zuiwufenghua/Multi-Cell_LSTM
|
61d487645e1c2d3f93f95bda2e8f46fabd8a3b3a
|
c4938222a559d93aa8377d4e1a46a27aff86457c
|
refs/heads/master
| 2023-01-23T06:20:56.883335
| 2020-12-02T09:41:32
| 2020-12-02T09:41:32
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 31,861
|
py
|
# -*- coding: utf-8 -*-
from __future__ import print_function
import time
import sys
import math
import argparse
import random
import torch
import gc
import torch.nn as nn
import torch.optim as optim
import numpy as np
from utils.metric import get_ner_fmeasure
from model.seqlabel import SeqLabel
from model.sentclassifier import SentClassifier
from utils.data import Data
import os
try:
import cPickle as pickle
except ImportError:
import pickle
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
seed_num = 42
random.seed(seed_num)
torch.manual_seed(seed_num)
np.random.seed(seed_num)
CAT = ['PER', 'ORG', 'LOC', 'MISC']
POSITION = ['I', 'B', 'E', 'S']
LABEL_INDEX = ['O'] + ["{}-{}".format(position, cat) for cat in CAT for position in POSITION]
def data_initialization(data):
data.initial_feature_alphabets()
if data.task == 'NER':
for tag in LABEL_INDEX:
data.label_alphabet.add(tag)
data.entity_type.append('O')
for entity_name in CAT:
data.entity_type.append(entity_name)
for entity in data.entity_type:
data.entity_alphabet.add(entity)
for pos_name in POSITION:
data.position_type.append(pos_name)
data.build_alphabet(data.train_dir)
data.build_alphabet(data.dev_dir)
data.build_alphabet(data.test_dir)
data.build_alphabet_raw(data.raw_data_dir)
data.fix_alphabet()
for i in range(data.label_alphabet.size()-1):
print(data.label_alphabet.instances[i])
data.build_entity_dict(data.entity_dict_dir)
def predict_check(pred_variable, gold_variable, mask_variable, sentence_classification=False):
"""
input:
pred_variable (batch_size, sent_len): pred tag result, in numpy format
gold_variable (batch_size, sent_len): gold result variable
mask_variable (batch_size, sent_len): mask variable
"""
pred = pred_variable.cpu().data.numpy()
gold = gold_variable.cpu().data.numpy()
mask = mask_variable.cpu().data.numpy()
overlaped = (pred == gold)
if sentence_classification:
# print(overlaped)
# print(overlaped*pred)
right_token = np.sum(overlaped)
total_token = overlaped.shape[0] ## =batch_size
else:
right_token = np.sum(overlaped * mask)
total_token = mask.sum()
# print("right: %s, total: %s"%(right_token, total_token))
return right_token, total_token
def recover_label(pred_variable, gold_variable, mask_variable, label_alphabet, word_recover, sentence_classification=False):
"""
input:
pred_variable (batch_size, sent_len): pred tag result
gold_variable (batch_size, sent_len): gold result variable
mask_variable (batch_size, sent_len): mask variable
"""
pred_variable = pred_variable[word_recover]
gold_variable = gold_variable[word_recover]
mask_variable = mask_variable[word_recover]
batch_size = gold_variable.size(0)
if sentence_classification:
pred_tag = pred_variable.cpu().data.numpy().tolist()
gold_tag = gold_variable.cpu().data.numpy().tolist()
pred_label = [label_alphabet.get_instance(pred) for pred in pred_tag]
gold_label = [label_alphabet.get_instance(gold) for gold in gold_tag]
else:
seq_len = gold_variable.size(1)
mask = mask_variable.cpu().data.numpy()
pred_tag = pred_variable.cpu().data.numpy()
gold_tag = gold_variable.cpu().data.numpy()
batch_size = mask.shape[0]
pred_label = []
gold_label = []
for idx in range(batch_size):
pred = [label_alphabet.get_instance(pred_tag[idx][idy]) for idy in range(seq_len) if mask[idx][idy] != 0]
gold = [label_alphabet.get_instance(gold_tag[idx][idy]) for idy in range(seq_len) if mask[idx][idy] != 0]
assert(len(pred)==len(gold))
pred_label.append(pred)
gold_label.append(gold)
return pred_label, gold_label
def recover_nbest_label(pred_variable, mask_variable, label_alphabet, word_recover):
"""
input:
pred_variable (batch_size, sent_len, nbest): pred tag result
mask_variable (batch_size, sent_len): mask variable
word_recover (batch_size)
output:
nbest_pred_label list: [batch_size, nbest, each_seq_len]
"""
# exit(0)
pred_variable = pred_variable[word_recover]
mask_variable = mask_variable[word_recover]
batch_size = pred_variable.size(0)
seq_len = pred_variable.size(1)
nbest = pred_variable.size(2)
mask = mask_variable.cpu().data.numpy()
pred_tag = pred_variable.cpu().data.numpy()
batch_size = mask.shape[0]
pred_label = []
for idx in range(batch_size):
pred = []
for idz in range(nbest):
each_pred = [label_alphabet.get_instance(pred_tag[idx][idy][idz]) for idy in range(seq_len) if mask[idx][idy] != 0]
pred.append(each_pred)
pred_label.append(pred)
return pred_label
def lr_decay(optimizer, epoch, decay_rate, init_lr):
lr = init_lr/(1+decay_rate*epoch)
print(" Learning rate is set as:", lr)
for param_group in optimizer.param_groups:
param_group['lr'] = lr
return optimizer
def evaluate(data, model, name, nbest=None):
if name == "train":
instances = data.train_Ids
elif name == "dev":
instances = data.dev_Ids
elif name == 'test':
instances = data.test_Ids
elif name == 'raw':
instances = data.raw_Ids
else:
print("Error: wrong evaluate name,", name)
exit(1)
right_token = 0
whole_token = 0
nbest_pred_results = []
pred_scores = []
pred_results = []
gold_results = []
gold_entity_results = []
pred_entity_results = []
gold_probs_results = []
pred_probs_results = []
## set model in eval model
model.eval()
batch_size = data.HP_batch_size
start_time = time.time()
train_num = len(instances)
total_batch = train_num//batch_size+1
for batch_id in range(total_batch):
start = batch_id*batch_size
end = (batch_id+1)*batch_size
if end > train_num:
end = train_num
instance = instances[start:end]
if not instance:
continue
original_words_batch, batch_word, batch_features, batch_wordlen, batch_wordrecover, batch_char, batch_charlen, batch_charrecover, batch_label, batch_entity, lm_seq_tensor, mask = batchify_with_label(instance, data.HP_gpu, False, data.sentence_classification)
if nbest and not data.sentence_classification:
scores, nbest_tag_seq, entity_seq, atten_probs_seq = model.decode_nbest(original_words_batch, batch_word, batch_features, batch_wordlen, batch_char, batch_charlen, batch_charrecover, mask, nbest)
nbest_pred_result = recover_nbest_label(nbest_tag_seq, mask, data.label_alphabet, batch_wordrecover)
nbest_pred_results += nbest_pred_result
pred_scores += scores[batch_wordrecover].cpu().data.numpy().tolist()
## select the best sequence to evalurate
tag_seq = nbest_tag_seq[:,:,0]
else:
tag_seq, entity_seq, atten_probs_seq = model(original_words_batch, batch_word, batch_features, batch_wordlen, batch_char, batch_charlen, batch_charrecover, mask)
# print("tag:",tag_seq)
pred_entity, gold_entity = recover_label(entity_seq, batch_entity, mask, data.entity_alphabet, batch_wordrecover, data.sentence_classification)
pred_entity_results += pred_entity
gold_entity_results += gold_entity
pred_probs, gold_probs = recover_label(atten_probs_seq, batch_entity, mask, data.entity_alphabet, batch_wordrecover, data.sentence_classification)
pred_probs_results += pred_probs
gold_probs_results += gold_probs
pred_label, gold_label = recover_label(tag_seq, batch_label, mask, data.label_alphabet, batch_wordrecover, data.sentence_classification)
pred_results += pred_label
gold_results += gold_label
decode_time = time.time() - start_time
speed = len(instances)/decode_time
print("word acc:")
acc, p, r, f = get_ner_fmeasure(gold_results, pred_results, data.tagScheme)
print("entity acc:")
entity_acc, _, _, _ = get_ner_fmeasure(gold_entity_results, pred_entity_results, "entity predict")
print("probs acc:")
probs_acc, _, _, _ = get_ner_fmeasure(gold_probs_results, pred_probs_results, "probs predict")
if nbest and not data.sentence_classification:
return speed, acc, p, r, f, nbest_pred_results, pred_scores
return speed, acc, p, r, f, pred_results, pred_scores
def batchify_with_label(input_batch_list, gpu, if_train=True, sentence_classification=False):
if sentence_classification:
return batchify_sentence_classification_with_label(input_batch_list, gpu, if_train)
else:
return batchify_sequence_labeling_with_label(input_batch_list, gpu, if_train)
def batchify_sequence_labeling_with_label(input_batch_list, gpu, if_train=True):
"""
input: list of words, chars and labels, various length. [[words, features, chars, labels],[words, features, chars,labels],...]
words: word ids for one sentence. (batch_size, sent_len)
features: features ids for one sentence. (batch_size, sent_len, feature_num)
chars: char ids for on sentences, various length. (batch_size, sent_len, each_word_length)
labels: label ids for one sentence. (batch_size, sent_len)
output:
zero padding for word and char, with their batch length
word_seq_tensor: (batch_size, max_sent_len) Variable
feature_seq_tensors: [(batch_size, max_sent_len),...] list of Variable
word_seq_lengths: (batch_size,1) Tensor
char_seq_tensor: (batch_size*max_sent_len, max_word_len) Variable
char_seq_lengths: (batch_size*max_sent_len,1) Tensor
char_seq_recover: (batch_size*max_sent_len,1) recover char sequence order
label_seq_tensor: (batch_size, max_sent_len)
mask: (batch_size, max_sent_len)
"""
device = torch.device('cuda' if gpu and torch.cuda.is_available() else 'cpu')
batch_size = len(input_batch_list)
words = [sent[0] for sent in input_batch_list]
features = [np.asarray(sent[1]) for sent in input_batch_list]
feature_num = len(features[0][0])
chars = [sent[2] for sent in input_batch_list]
labels = [sent[3] for sent in input_batch_list]
entities = [sent[4] for sent in input_batch_list]
original_words = [sent[5] for sent in input_batch_list]
word_seq_lengths = torch.LongTensor(list(map(len, words)))
max_seq_len = word_seq_lengths.max().item()
word_seq_tensor = torch.zeros((batch_size, max_seq_len), requires_grad=if_train).long()
label_seq_tensor = torch.zeros((batch_size, max_seq_len), requires_grad=if_train).long()
entity_seq_tensor = torch.zeros((batch_size, max_seq_len), requires_grad=if_train).long()
lm_forward_seq_tensor = torch.zeros((batch_size, max_seq_len), requires_grad=if_train).long()
lm_backward_seq_tensor = torch.zeros((batch_size, max_seq_len), requires_grad=if_train).long()
feature_seq_tensors = []
for idx in range(feature_num):
feature_seq_tensors.append(torch.zeros((batch_size, max_seq_len),requires_grad = if_train).long())
mask = torch.zeros((batch_size, max_seq_len), requires_grad = if_train).byte()
for idx, (seq, label, entity, seqlen) in enumerate(zip(words, labels, entities, word_seq_lengths)):
seqlen = seqlen.item()
word_seq_tensor[idx, :seqlen] = torch.LongTensor(seq)
if seqlen > 1:
lm_forward_seq_tensor[idx, 0: seqlen - 1] = word_seq_tensor[idx, 1: seqlen]
lm_forward_seq_tensor[idx, seqlen - 1] = torch.LongTensor([1]) # unk word
lm_backward_seq_tensor[idx, 1: seqlen] = word_seq_tensor[idx, 0: seqlen - 1]
lm_backward_seq_tensor[idx, 0] = torch.LongTensor([1]) # unk word
else:
lm_forward_seq_tensor[idx, 0] = torch.LongTensor([1]) # unk word
lm_backward_seq_tensor[idx, 0] = torch.LongTensor([1]) # unk word
label_seq_tensor[idx, :seqlen] = torch.LongTensor(label)
entity_seq_tensor[idx, :seqlen] = torch.LongTensor(entity)
mask[idx, :seqlen] = torch.Tensor([1]*seqlen)
for idy in range(feature_num):
feature_seq_tensors[idy][idx,:seqlen] = torch.LongTensor(features[idx][:,idy])
word_seq_lengths, word_perm_idx = word_seq_lengths.sort(0, descending=True)
word_seq_lengths = word_seq_lengths.to(device)
word_seq_tensor = word_seq_tensor[word_perm_idx].to(device)
# reorder sentence index
new_original_words = [] # list[list[word]]
for i in word_perm_idx:
new_original_words.append(original_words[i])
for idx in range(feature_num):
feature_seq_tensors[idx] = feature_seq_tensors[idx][word_perm_idx].to(device)
lm_forward_seq_tensor = lm_forward_seq_tensor[word_perm_idx].to(device)
lm_backward_seq_tensor = lm_backward_seq_tensor[word_perm_idx].to(device)
label_seq_tensor = label_seq_tensor[word_perm_idx].to(device)
entity_seq_tensor = entity_seq_tensor[word_perm_idx].to(device)
mask = mask[word_perm_idx].to(device)
### deal with char
# pad_chars (batch_size, max_seq_len)
pad_chars = [chars[idx] + [[0]] * (max_seq_len-len(chars[idx])) for idx in range(len(chars))]
length_list = [list(map(len, pad_char)) for pad_char in pad_chars]
max_word_len = max(map(max, length_list))
char_seq_tensor = torch.zeros((batch_size, max_seq_len, max_word_len), requires_grad = if_train).long()
char_seq_lengths = torch.LongTensor(length_list)
for idx, (seq, seqlen) in enumerate(zip(pad_chars, char_seq_lengths)):
for idy, (word, wordlen) in enumerate(zip(seq, seqlen)):
# print len(word), wordlen
char_seq_tensor[idx, idy, :wordlen] = torch.LongTensor(word)
char_seq_tensor = char_seq_tensor[word_perm_idx].view(batch_size*max_seq_len,-1)
char_seq_lengths = char_seq_lengths[word_perm_idx].view(batch_size*max_seq_len,)
char_seq_lengths, char_perm_idx = char_seq_lengths.sort(0, descending=True)
char_seq_tensor = char_seq_tensor[char_perm_idx].to(device)
_, char_seq_recover = char_perm_idx.sort(0, descending=False)
char_seq_recover = char_seq_recover.to(device)
_, word_seq_recover = word_perm_idx.sort(0, descending=False)
word_seq_recover = word_seq_recover.to(device)
lm_seq_tensor = [lm_forward_seq_tensor, lm_backward_seq_tensor]
return new_original_words, word_seq_tensor,feature_seq_tensors, word_seq_lengths, word_seq_recover, char_seq_tensor, char_seq_lengths, char_seq_recover, label_seq_tensor, entity_seq_tensor, lm_seq_tensor, mask
def batchify_sentence_classification_with_label(input_batch_list, gpu, if_train=True):
"""
input: list of words, chars and labels, various length. [[words, features, chars, labels],[words, features, chars,labels],...]
words: word ids for one sentence. (batch_size, sent_len)
features: features ids for one sentence. (batch_size, feature_num), each sentence has one set of feature
chars: char ids for on sentences, various length. (batch_size, sent_len, each_word_length)
labels: label ids for one sentence. (batch_size,), each sentence has one set of feature
output:
zero padding for word and char, with their batch length
word_seq_tensor: (batch_size, max_sent_len) Variable
feature_seq_tensors: [(batch_size,), ... ] list of Variable
word_seq_lengths: (batch_size,1) Tensor
char_seq_tensor: (batch_size*max_sent_len, max_word_len) Variable
char_seq_lengths: (batch_size*max_sent_len,1) Tensor
char_seq_recover: (batch_size*max_sent_len,1) recover char sequence order
label_seq_tensor: (batch_size, )
mask: (batch_size, max_sent_len)
"""
device = torch.device('cuda' if gpu and torch.cuda.is_available() else 'cpu')
batch_size = len(input_batch_list)
words = [sent[0] for sent in input_batch_list]
features = [np.asarray(sent[1]) for sent in input_batch_list]
feature_num = len(features[0])
chars = [sent[2] for sent in input_batch_list]
labels = [sent[3] for sent in input_batch_list]
word_seq_lengths = torch.LongTensor(list(map(len, words)))
max_seq_len = word_seq_lengths.max().item()
word_seq_tensor = torch.zeros((batch_size, max_seq_len), requires_grad = if_train).long()
label_seq_tensor = torch.zeros((batch_size, ), requires_grad = if_train).long()
feature_seq_tensors = []
for idx in range(feature_num):
feature_seq_tensors.append(torch.zeros((batch_size, max_seq_len),requires_grad = if_train).long())
mask = torch.zeros((batch_size, max_seq_len), requires_grad = if_train).byte()
label_seq_tensor = torch.LongTensor(labels)
# exit(0)
for idx, (seq, seqlen) in enumerate(zip(words, word_seq_lengths)):
seqlen = seqlen.item()
word_seq_tensor[idx, :seqlen] = torch.LongTensor(seq)
mask[idx, :seqlen] = torch.Tensor([1]*seqlen)
for idy in range(feature_num):
feature_seq_tensors[idy][idx,:seqlen] = torch.LongTensor(features[idx][:,idy])
word_seq_lengths, word_perm_idx = word_seq_lengths.sort(0, descending=True)
word_seq_lengths = word_seq_lengths.to(device)
word_seq_tensor = word_seq_tensor[word_perm_idx].to(device)
for idx in range(feature_num):
feature_seq_tensors[idx] = feature_seq_tensors[idx][word_perm_idx].to(device)
label_seq_tensor = label_seq_tensor[word_perm_idx].to(device)
mask = mask[word_perm_idx].to(device)
### deal with char
# pad_chars (batch_size, max_seq_len)
pad_chars = [chars[idx] + [[0]] * (max_seq_len-len(chars[idx])) for idx in range(len(chars))]
length_list = [list(map(len, pad_char)) for pad_char in pad_chars]
max_word_len = max(map(max, length_list))
char_seq_tensor = torch.zeros((batch_size, max_seq_len, max_word_len), requires_grad = if_train).long()
char_seq_lengths = torch.LongTensor(length_list)
for idx, (seq, seqlen) in enumerate(zip(pad_chars, char_seq_lengths)):
for idy, (word, wordlen) in enumerate(zip(seq, seqlen)):
# print len(word), wordlen
char_seq_tensor[idx, idy, :wordlen] = torch.LongTensor(word)
char_seq_tensor = char_seq_tensor[word_perm_idx].view(batch_size*max_seq_len,-1)
char_seq_lengths = char_seq_lengths[word_perm_idx].view(batch_size*max_seq_len,)
char_seq_lengths, char_perm_idx = char_seq_lengths.sort(0, descending=True)
char_seq_tensor = char_seq_tensor[char_perm_idx].to(device)
char_seq_tensor = char_seq_tensor.to(device)
_, char_seq_recover = char_perm_idx.sort(0, descending=False)
char_seq_recover = char_seq_recover.to(device)
_, word_seq_recover = word_perm_idx.sort(0, descending=False)
word_seq_recover = word_seq_recover.to(device)
return word_seq_tensor, feature_seq_tensors, word_seq_lengths, word_seq_recover, char_seq_tensor, char_seq_lengths, char_seq_recover, label_seq_tensor, mask
def train(data):
print("Training model...")
device = torch.device('cuda' if torch.cuda.is_available() and data.HP_gpu else 'cpu')
data.show_data_summary()
save_data_name = data.model_dir +".dset"
data.save(save_data_name)
if data.sentence_classification:
model = SentClassifier(data).to(device)
else:
model = SeqLabel(data).to(device)
for name, param in model.named_parameters():
if param.requires_grad:
print(name)
## compute model parameter num
n_all_param = sum([p.nelement() for p in model.parameters()])
n_emb_param = sum([p.nelement() for p in (model.word_hidden.wordrep.word_embedding.weight, model.word_hidden.wordrep.char_feature.char_embeddings.weight, model._LM_softmax.softmax_w, model._LM_softmax.softmax_b)])
print("all parameters=%s, emb parameters=%s, other parameters=%s" % (n_all_param, n_emb_param, n_all_param-n_emb_param))
## not update the word embedding
#model.word_hidden.wordrep.word_embedding.weight.requires_grad = False
if data.optimizer.lower() == "sgd":
optimizer = optim.SGD(model.parameters(), lr=data.HP_lr, momentum=data.HP_momentum,weight_decay=data.HP_l2)
elif data.optimizer.lower() == "adagrad":
optimizer = optim.Adagrad(model.parameters(), lr=data.HP_lr, weight_decay=data.HP_l2)
elif data.optimizer.lower() == "adadelta":
optimizer = optim.Adadelta(model.parameters(), lr=data.HP_lr, weight_decay=data.HP_l2)
elif data.optimizer.lower() == "rmsprop":
optimizer = optim.RMSprop(model.parameters(), lr=data.HP_lr, weight_decay=data.HP_l2)
elif data.optimizer.lower() == "adam":
optimizer = optim.Adam(model.parameters(), lr=data.HP_lr, weight_decay=data.HP_l2)
else:
print("Optimizer illegal: %s"%(data.optimizer))
exit(1)
best_dev = -10
test_f = []
dev_f = []
best_epoch = 0
# data.HP_iteration = 1
## start training
for idx in range(data.HP_iteration):
epoch_start = time.time()
temp_start = epoch_start
print("Epoch: %s/%s" %(idx,data.HP_iteration))
if data.optimizer == "SGD":
optimizer = lr_decay(optimizer, idx, data.HP_lr_decay, data.HP_lr)
instance_count = 0
sample_id = 0
sample_loss = 0
total_loss = 0
total_perplexity = 0
right_entity = 0
right_atten_probs = 0
right_token = 0
whole_token = 0
random.shuffle(data.train_Ids)
random.shuffle(data.raw_data_Ids)
print("Shuffle: first input word list:", data.train_Ids[0][0])
## set model in train model
model.train()
model.zero_grad()
batch_size = data.HP_batch_size
batch_id = 0
train_num = len(data.train_Ids)
raw_data_num = len(data.raw_data_Ids)
total_batch = train_num//batch_size+1
raw_batch_size = raw_data_num//total_batch
for batch_id in range(total_batch):
start = batch_id*batch_size
end = (batch_id+1)*batch_size
if end > train_num:
end = train_num
instance = data.train_Ids[start:end]
start_raw = batch_id * raw_batch_size
end_raw = (batch_id+1) * raw_batch_size
if end_raw > raw_data_num:
end_raw = raw_data_num
instance_raw = data.raw_data_Ids[start_raw:end_raw]
if not instance:
continue
instance_count += 1
instances = [instance, instance_raw]
loss_ = 0.0
for mode_idx, mode in enumerate(['train', 'raw']):
if len(instance[mode_idx]) < 1:
continue
# print(instance[1])
original_words_batch, batch_word, batch_features, batch_wordlen, batch_wordrecover, batch_char, batch_charlen, batch_charrecover, batch_label, batch_entity, lm_seq_tensor, mask = batchify_with_label(instances[mode_idx], data.HP_gpu, True, data.sentence_classification)
if mode == 'train':
loss, tag_seq, entity_seq, atten_probs_seq = model.calculate_loss(original_words_batch, batch_word, batch_features, batch_wordlen, batch_char, batch_charlen, batch_charrecover, batch_label, batch_entity, mask)
right, whole = predict_check(tag_seq, batch_label, mask, data.sentence_classification)
entity_right, entity_whole = predict_check(entity_seq, batch_entity, mask, data.sentence_classification)
atten_probs_right, atten_probs_whole = predict_check(atten_probs_seq, batch_entity, mask, data.sentence_classification)
right_token += right
whole_token += whole
right_entity += entity_right
right_atten_probs += atten_probs_right
elif mode == 'raw':
loss, perplexity, _,_ = model.raw_loss(original_words_batch, batch_word, batch_features, batch_wordlen, batch_char, batch_charlen, batch_charrecover, batch_label, batch_entity, lm_seq_tensor, mask)
total_perplexity += perplexity.item()
loss_ += loss
sample_loss += loss_.item()
total_loss += loss_.item()
loss_.backward()
optimizer.step()
model.zero_grad()
LM_perplex = math.exp(total_perplexity / total_batch)
temp_time = time.time()
temp_cost = temp_time - temp_start
print(" Instance: %s; Time: %.2fs; loss: %.4f; acc: %s/%s=%.4f"%(end, temp_cost, sample_loss, right_token, whole_token, (right_token+0.)/whole_token))
print(" total perplexity: %.4f" % (LM_perplex))
print(" entity acc: %.4f"%((right_entity+0.)/whole_token))
print(" atten probs acc: %.4f" % ((right_atten_probs + 0.) / whole_token))
epoch_finish = time.time()
epoch_cost = epoch_finish - epoch_start
print("Epoch: %s training finished. Time: %.2fs, speed: %.2fst/s, total loss: %s"%(idx, epoch_cost, train_num/epoch_cost, total_loss))
print("totalloss:", total_loss)
if total_loss > 1e8 or str(total_loss) == "nan":
print("ERROR: LOSS EXPLOSION (>1e8) ! PLEASE SET PROPER PARAMETERS AND STRUCTURE! EXIT....")
exit(1)
# continue
speed, acc, p, r, f, _,_ = evaluate(data, model, "dev")
dev_finish = time.time()
dev_cost = dev_finish - epoch_finish
if data.seg:
current_score = f
print("Dev: time: %.2fs, speed: %.2fst/s; acc: %.4f, p: %.4f, r: %.4f, f: %.4f"%(dev_cost, speed, acc, p, r, f))
else:
current_score = acc
print("Dev: time: %.2fs speed: %.2fst/s; acc: %.4f"%(dev_cost, speed, acc))
dev_f.append(current_score)
if current_score > best_dev:
best_epoch = idx
if data.seg:
print("Exceed previous best f score:", best_dev)
else:
print("Exceed previous best acc score:", best_dev)
model_name = data.model_dir + ".model"
print("Save current best model in file:", model_name)
torch.save(model.state_dict(), model_name)
best_dev = current_score
# ## decode test
speed, acc, p, r, f, _,_ = evaluate(data, model, "test")
test_finish = time.time()
test_cost = test_finish - dev_finish
if data.seg:
test_f.append(f)
print("Test: time: %.2fs, speed: %.2fst/s; acc: %.4f, p: %.4f, r: %.4f, f: %.4f"%(test_cost, speed, acc, p, r, f))
else:
test_f.append(acc)
print("Test: time: %.2fs, speed: %.2fst/s; acc: %.4f"%(test_cost, speed, acc))
gc.collect()
print("The best f in eopch%s, dev:%.4f, test:%.4f" % (best_epoch, dev_f[best_epoch], test_f[best_epoch]))
def load_model_decode(data, name):
print("Load Model from file: ", data.model_dir)
device = torch.device('cuda' if torch.cuda.is_available() and data.HP_gpu else 'cpu')
if data.sentence_classification:
model = SentClassifier(data).to(device)
else:
model = SeqLabel(data).to(device)
# model = SeqModel(data)
## load model need consider if the model trained in GPU and load in CPU, or vice versa
# if not gpu:
# model.load_state_dict(torch.load(model_dir))
# # model.load_state_dict(torch.load(model_dir), map_location=lambda storage, loc: storage)
# # model = torch.load(model_dir, map_location=lambda storage, loc: storage)
# else:
# model.load_state_dict(torch.load(model_dir))
# # model = torch.load(model_dir)
model.load_state_dict(torch.load(data.load_model_dir))
## compute model parameter num
n_all_param = sum([p.nelement() for p in model.parameters()])
n_emb_param = sum([p.nelement() for p in (model.word_hidden.wordrep.word_embedding.weight, model.word_hidden.wordrep.char_feature.char_embeddings.weight, model._LM_softmax.softmax_w, model._LM_softmax.softmax_b)])
print("all parameters=%s, emb parameters=%s, other parameters=%s" % (n_all_param, n_emb_param, n_all_param-n_emb_param))
print("Decode %s data, nbest: %s ..."%(name, data.nbest))
start_time = time.time()
speed, acc, p, r, f, pred_results, pred_scores = evaluate(data, model, name, data.nbest)
end_time = time.time()
time_cost = end_time - start_time
if data.seg:
print("%s: time:%.2fs, speed:%.2fst/s; acc: %.4f, p: %.4f, r: %.4f, f: %.4f"%(name, time_cost, speed, acc, p, r, f))
else:
print("%s: time:%.2fs, speed:%.2fst/s; acc: %.4f"%(name, time_cost, speed, acc))
return pred_results, pred_scores
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Tuning with NCRF++')
# parser.add_argument('--status', choices=['train', 'decode'], help='update algorithm', default='train')
parser.add_argument('--config', help='Configuration File', default='None')
parser.add_argument('--wordemb', help='Embedding for words', default='None')
parser.add_argument('--charemb', help='Embedding for chars', default='None')
parser.add_argument('--status', choices=['train', 'decode'], help='update algorithm', default='train')
parser.add_argument('--savemodel', default="data/model/saved_model.lstmcrf.")
parser.add_argument('--savedset', help='Dir of saved data setting')
parser.add_argument('--train', default="data/conll03/train.bmes")
parser.add_argument('--dev', default="data/conll03/dev.bmes" )
parser.add_argument('--test', default="data/conll03/test.bmes")
parser.add_argument('--seg', default="True")
parser.add_argument('--raw')
parser.add_argument('--loadmodel')
parser.add_argument('--output')
args = parser.parse_args()
data = Data()
if args.config == 'None':
data.train_dir = args.train
data.dev_dir = args.dev
data.test_dir = args.test
data.model_dir = args.savemodel
data.dset_dir = args.savedset
print("Save dset directory:",data.dset_dir)
save_model_dir = args.savemodel
data.word_emb_dir = args.wordemb
data.char_emb_dir = args.charemb
if args.seg.lower() == 'true':
data.seg = True
else:
data.seg = False
print("Seed num:",seed_num)
else:
data.read_config(args.config)
# data.show_data_summary()
status = data.status.lower()
print("Seed num:",seed_num)
if status == 'train':
print("MODEL: train")
data_initialization(data)
data.generate_instance('train')
data.generate_instance('dev')
data.generate_instance('test')
data.build_pretrain_emb()
train(data)
elif status == 'decode':
print("MODEL: decode")
data.load(data.dset_dir)
data.read_config(args.config)
print(data.raw_dir)
# exit(0)
data.show_data_summary()
data.generate_instance('raw')
print("nbest: %s"%(data.nbest))
decode_results, pred_scores = load_model_decode(data, 'raw')
if data.nbest and not data.sentence_classification:
data.write_nbest_decoded_results(decode_results, pred_scores, 'raw')
else:
data.write_decoded_results(decode_results, 'raw')
else:
print("Invalid argument! Please use valid arguments! (train/test/decode)")
|
[
"noreply@github.com"
] |
noreply@github.com
|
dcebdc63fede722d67b16b2fb6757f67c3e20076
|
59f03c7528c9c806e3e25b9864db89f25dfa73c2
|
/tests/conftest.py
|
340ea85a5b213e3a629d9ba903138e93c3473583
|
[
"MIT"
] |
permissive
|
OneGov/onegov-cloud
|
8d8cd6d0378991ebc2333b62337246719102e723
|
c706b38d5b67692b4146cdf14ef24d971a32c6b8
|
refs/heads/master
| 2023-08-24T15:37:52.536958
| 2023-08-24T14:15:54
| 2023-08-24T14:15:54
| 189,431,418
| 17
| 4
|
MIT
| 2023-09-14T20:39:37
| 2019-05-30T14:47:14
|
Python
|
UTF-8
|
Python
| false
| false
| 34
|
py
|
pytest_plugins = ['tests.shared']
|
[
"denis.krienbuehl@seantis.ch"
] |
denis.krienbuehl@seantis.ch
|
2337dbfe31cf2f3bcaceca10f0429a098ea2c2b1
|
d59b11ac0465a430b7f7402f7928b6bd1c5bc9f1
|
/config.py
|
63e1cc63b674484defdb6ca379d035703491d7f7
|
[
"Apache-2.0",
"MIT"
] |
permissive
|
mmmika/MAX-Audio-Sample-Generator
|
c94222a701f6c6e76089687c49929623f488ea62
|
5d22b6cea0a42fe8e1a088201972baf9acbe5089
|
refs/heads/master
| 2020-03-31T12:57:56.322625
| 2018-10-05T22:34:19
| 2018-10-05T22:34:19
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 855
|
py
|
# Flask settings
DEBUG = False
# Flask-restplus settings
RESTPLUS_MASK_SWAGGER = False
# Application settings
# API metadata
API_TITLE = 'Model Asset Exchange Server'
API_DESC = 'An API for serving models'
API_VERSION = '0.1'
# default model
MODEL_NAME = 'wavegan'
DEFAULT_MODEL_PATH = 'assets/models'
MODEL_LICENSE = 'Apache2'
# generator model options and default
DEFAULT_MODEL = 'lofi-instrumentals'
MODELS = ['lofi-instrumentals','up','down','left','right','stop','go']
INPUT_TENSOR = 'z:0'
OUTPUT_TENSOR = 'G_z:0'
MODEL_META_DATA = {
'id': '{}'.format(MODEL_NAME.lower()),
'name': 'WaveGAN audio generation model'.format(MODEL_NAME),
'description': 'Generative Adversarial Network, trained using TensorFlow on spoken commands and lo-fi instrumental music',
'type': 'audio-modeling',
'license': '{}'.format(MODEL_LICENSE)
}
|
[
"1996anoojpatel@gmail.com"
] |
1996anoojpatel@gmail.com
|
e5349826b1bf5d97988e22e049ad10187fab4a4b
|
677869880e88f669a436c78cd77dc3eee2a66569
|
/pythonkatas/primefactors/main.py
|
6ec728df598d050073646ad580f72a03c1689277
|
[] |
no_license
|
ErinLMoore/CodeKatas
|
36c6b5a860ee374497f1509b49adab4713e34de1
|
a6e77e0ecdc3c54e84901eabeff9270c65a96e1b
|
refs/heads/master
| 2020-04-06T07:02:12.463774
| 2016-09-29T02:23:26
| 2016-09-29T02:23:26
| 53,079,444
| 0
| 1
| null | 2016-07-06T15:56:13
| 2016-03-03T20:05:00
|
HTML
|
UTF-8
|
Python
| false
| false
| 196
|
py
|
import sys
sys.path.append('~/workspace/CodeKatas/pythonkatas/src')
from src.primefactors import primeFactors
class main():
int_to_factor = int(sys.argv[1])
print (primeFactors(int_to_factor))
|
[
"emoore@pillartechnology.com"
] |
emoore@pillartechnology.com
|
8ed5e9e3a463510b06a68a5076cb0cca96428c2a
|
65930b71495a028bb4a78f6c07a0e0e971aa503d
|
/mobee/new/migrations/0004_auto_20210905_2353.py
|
8fc2245611c23d97033458315b173cfb333ba354
|
[] |
no_license
|
sangmu1126/mobee
|
6111bd3287d9669ab61c2c8f805f0673194bf78a
|
a801abfcf65d1597a4eb281b88972945658f66fa
|
refs/heads/master
| 2023-07-18T08:51:00.396757
| 2021-09-05T15:54:46
| 2021-09-05T15:54:46
| 403,346,408
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 593
|
py
|
# Generated by Django 3.2.7 on 2021-09-05 14:53
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('new', '0003_rename_restaurant_review_movie'),
]
operations = [
migrations.AddField(
model_name='movie',
name='image',
field=models.CharField(default=None, max_length=500, null=True),
),
migrations.AddField(
model_name='movie',
name='password',
field=models.CharField(default=None, max_length=20, null=True),
),
]
|
[
"sangmu1126@gmail.com"
] |
sangmu1126@gmail.com
|
e0cd1ebb5f222778682b48bf62bdbed9a7a2faef
|
3439c585e5f06ddf17c5690a07f0800c4372531d
|
/scripts/led.py
|
0be798fe4ac0e13cba93f3c9ce51fe1cc1bc6121
|
[] |
no_license
|
squidsoup/young-coders-2016
|
f24b9a2ee13c6b24d46f80f63ba8a548ef1698d4
|
b4b757dfd6414aa0ae9ec38fdf07ee6224475a1d
|
refs/heads/master
| 2020-07-08T20:49:13.182804
| 2017-04-11T23:35:38
| 2017-04-11T23:35:38
| 67,831,536
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 185
|
py
|
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
GPIO.setup(7,GPIO.OUT)
while True:
GPIO.output(7,False)
time.sleep(0.5)
GPIO.output(7,True)
time.sleep(0.5)
|
[
"kit@nocturne.net.nz"
] |
kit@nocturne.net.nz
|
65e75880a88ed030115589f4646788aa413fd91e
|
7f7213fe407f252b2323025c9b9e381a73474b7d
|
/drag_sheet/sds/check_files.py
|
077feba9a15d97280ae0c711e7c9b67f9866a925
|
[] |
no_license
|
ahy3nz/graphene_build
|
0ce62c2123b8c39248048d2cafbd0aafdd06ff9a
|
44590b8db799136929fc06e490151f450ad30029
|
refs/heads/master
| 2021-06-20T07:28:20.958807
| 2019-07-03T19:48:24
| 2019-07-03T19:48:24
| 135,504,561
| 0
| 1
| null | 2018-08-06T21:47:17
| 2018-05-30T22:40:17
|
Python
|
UTF-8
|
Python
| false
| false
| 572
|
py
|
import os
import itertools as it
curr_dir = os.getcwd()
sds_folders = ['10sds', '20sds', '30sds', '40sds', '50sds', '60sds',
'70sds', '80sds', '90sds', '100sds']
k_folders = ['k50']
angle_folders = ['0']
trials = ['a', 'b', 'c']
for combo in it.product(sds_folders, k_folders, angle_folders,trials):
sim_dir = os.path.join(curr_dir, '{0}/{1}_{2}_{3}'.format(*combo))
if os.path.isdir(sim_dir):
os.chdir(sim_dir)
if not os.path.isfile('pull.gro'):
print(sim_dir)
else:
print("{} doesn't exist".format(sim_dir))
|
[
"alexander.h.yang@vanderbilt.edu"
] |
alexander.h.yang@vanderbilt.edu
|
1cb4aefd9a5b1077a5c844f51cf26e0e25ef605b
|
f6761bd4b74ed9c3bc0e8f62e5a1db70c03096f0
|
/torch/nn/quantized/dynamic/modules/linear.py
|
7574dd53eb761570aa1b6445bc8593eba60de6c2
|
[
"BSD-2-Clause",
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla",
"Apache-2.0"
] |
permissive
|
MarisaKirisame/pytorch
|
b638790a0997d776ad4c5e4c77badc77e5dc94f9
|
59c5de4d0eda8d4f5494602034093933600d0a3d
|
refs/heads/master
| 2021-06-19T10:44:33.846286
| 2019-10-31T22:56:55
| 2019-10-31T22:58:28
| 218,881,408
| 2
| 0
|
NOASSERTION
| 2019-11-01T00:02:51
| 2019-11-01T00:02:51
| null |
UTF-8
|
Python
| false
| false
| 3,423
|
py
|
from __future__ import absolute_import, division, print_function, unicode_literals
import torch
from ....modules.linear import Linear as NNLinear
import torch.nn.quantized as nnq
class Linear(nnq.Linear):
r"""
A dynamic quantized linear module with quantized tensor as inputs and outputs.
We adopt the same interface as `torch.nn.Linear`, please see
https://pytorch.org/docs/stable/nn.html#torch.nn.Linear for documentation.
Similar to :class:`torch.nn.Linear`, attributes will be randomly
initialized at module creation time and will be overwritten later
Attributes:
weight (Tensor): the non-learnable quantized weights of the module which are of
shape :math:`(\text{out\_features}, \text{in\_features})`.
bias (Tensor): the non-learnable bias of the module of shape :math:`(\text{out\_features})`.
If :attr:`bias` is ``True``, the values are initialized to zero.
Examples::
>>> m = nn.quantized.dynamic.Linear(20, 30)
>>> input = torch.randn(128, 20)
>>> output = m(input)
>>> print(output.size())
torch.Size([128, 30])
"""
def __init__(self, in_features, out_features, bias_=True):
super(Linear, self).__init__(in_features, out_features, bias_)
# We don't muck around with buffers or attributes or anything here
# to keep the module simple. *everything* is simply a Python attribute.
# Serialization logic is explicitly handled in the below serialization and
# deserialization modules
def forward(self, x):
# Note that we can handle self.bias == None case.
Y = torch.ops.quantized.linear_dynamic(
x, self._packed_params)
return Y.to(x.dtype)
def _get_name(self):
return 'DynamicQuantizedLinear'
def extra_repr(self):
return 'in_features={}, out_features={}'.format(
self.in_features, self.out_features
)
@classmethod
def from_float(cls, mod):
r"""Create a dynamic quantized module from a float module or qparams_dict
Args:
mod (Module): a float module, either produced by torch.quantization
utilities or provided by the user
"""
assert type(mod) == NNLinear, 'nn.quantized.dynamic.Linear.from_float only works for nn.Linear'
assert hasattr(mod, 'qconfig'), 'Input float module must have qconfig defined'
if mod.qconfig is not None and mod.qconfig.weight is not None:
weight_observer = mod.qconfig.weight()
else:
# We have the circular import issues if we import the qconfig in the beginning of this file:
# https://github.com/pytorch/pytorch/pull/24231. The current workaround is to postpone the
# import until we need it.
from torch.quantization.qconfig import default_dynamic_qconfig
weight_observer = default_dynamic_qconfig.weight()
assert weight_observer.dtype == torch.qint8, 'Weight observer must have dtype torch.qint8'
weight_observer(mod.weight)
wt_scale, wt_zp = weight_observer.calculate_qparams()
qweight = torch.quantize_per_tensor(mod.weight.float(), float(wt_scale), int(wt_zp), torch.qint8)
qlinear = Linear(mod.in_features, mod.out_features)
qlinear.set_weight_bias(qweight, mod.bias)
return qlinear
|
[
"facebook-github-bot@users.noreply.github.com"
] |
facebook-github-bot@users.noreply.github.com
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.