blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 2 616 | content_id stringlengths 40 40 | detected_licenses listlengths 0 69 | license_type stringclasses 2
values | repo_name stringlengths 5 118 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringlengths 4 63 | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 2.91k 686M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 220
values | src_encoding stringclasses 30
values | language stringclasses 1
value | is_vendor bool 2
classes | is_generated bool 2
classes | length_bytes int64 2 10.3M | extension stringclasses 257
values | content stringlengths 2 10.3M | authors listlengths 1 1 | author_id stringlengths 0 212 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
97a3249b850d30dfb9567e51be4dfdeb0a7efa4f | e2cd460e16d1e6fa8333204ad6797f593b3bd266 | /Lab 4/Q2_compound_interest.py | 43e505e4daf02f5a12028c72a138b9efc42b6826 | [] | no_license | CharlieWeld/OOP | 8380650106ba122cdccbf93e872776769e20c3ab | 872412800db96e8e5f0fe6e3f8c63e6f8e66135a | refs/heads/master | 2021-01-10T18:14:06.691641 | 2015-10-12T10:09:22 | 2015-10-12T10:09:22 | 44,099,210 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 938 | py | from math import pow
def simple_interest(principle, rate, periods):
balance = principle*(1 + (rate/100)*periods)
return balance
def compound_interest(principle, rate, periods, compounds):
balance = principle * pow((1 + ((rate/100)/12)), (periods*compounds))
return balance
def main():
principle = float(input("Enter the principle amount: "))
rate = float(input("Enter the percentage interest rate: "))
if rate < 1:
rate *= 100
periods = float(input("Enter the number of years: "))
compounds = float(input("Enter the number of periods per year: "))
balance1 = simple_interest(principle, rate, periods)
balance2 = compound_interest(principle, rate, periods, compounds)
print("The balance is: ", "%.2f" % balance1)
print("The compound interest is: ", "%.2f" % balance2)
print("The difference is: ", "%.2f" % (balance2-balance1))
main()
| [
"charles.weld@mydit.ie"
] | charles.weld@mydit.ie |
3b7cc6a948527a8bb090f5c2899f32daf6733962 | b991108e35f96ecfe8d9fb06ae16c1071cb935ad | /FlaskDeployment/model.py | 2864afbfe2997f753db207471398a9dec614b7b4 | [] | no_license | RahulReady/Inspection-Central | 0029d203056c135bd644d5fcec436cfb171ab390 | fa216e64378c7066c65a780ad6b03d1e20eccfac | refs/heads/master | 2023-08-03T09:48:48.490874 | 2021-09-21T00:56:47 | 2021-09-21T00:56:47 | 234,825,537 | 1 | 1 | null | null | null | null | UTF-8 | Python | false | false | 688 | py |
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import pickle
from sklearn.externals import joblib
# Reading data
dataset = pd.read_csv('*******')
# Creating model and dump as pickle file
# Ex linear regression
from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
#Fitting model with trainig data
regressor.fit(X, y)
# Saving model as pickle file
# pickle.dump(regressor, open('model.pkl','wb'))
## Saving model as joblib filename
#joblib.dump(model, "model.joblib", compress = 1) # Compression into 1 filename
# Loading model to compare the results
model = pickle.load(open('model.pkl','rb'))
#print(model.predict([[2, 9, 6]]))
| [
"noreply@github.com"
] | RahulReady.noreply@github.com |
e8f83690c0e100b2f068f6ef68fec6c1288fb545 | b723d93591bddcc362e93be8d281d8f118eb3b16 | /ene_009_renewable_generation_annually/ene_009_renewable_generation_annually_processing.py | 1a5d29bf369f61e0464cc4c7a15dba3a789b8482 | [
"MIT"
] | permissive | resource-watch/data-pre-processing | 8f810c2f1ff7994090b49162e4d2e74967708073 | e5288d14513036b4c06a5efbf5f375bcf9895030 | refs/heads/master | 2023-06-14T05:41:44.297324 | 2023-05-31T19:54:47 | 2023-05-31T19:54:47 | 175,611,699 | 12 | 8 | MIT | 2023-05-31T19:54:48 | 2019-03-14T11:50:33 | Python | UTF-8 | Python | false | false | 5,295 | py | """Script to transform and upload IRENA's capacity data to Resource Watch.
IRENA information is available through a Tableau applet.
This data must be downloaded manually, it is not possible to acquire
through an HTTP GET as we can tell.
Once downloaded, only minor transformation is needed to prepare it for upload.
The core issue is that the information does not fall into a data cube without
aggregating some rows to fit with expectations around data dimensionality.
It seems the data should be keyed on the dimensions:
- country
- year
- most granular technology (e.g. "offshore wind" not "wind")
- on-grid/off-grid
When keyed in this way there are still many compound keys
that have multiple rows and need to be summed to produce the
values expressed in Tableau visualization.
"""
import os
import pandas as pd
from zipfile import ZipFile
import shutil
utils_path = os.path.join(os.path.abspath(os.getenv('PROCESSING_DIR')),'utils')
if utils_path not in sys.path:
sys.path.append(utils_path)
import util_files
import util_cloud
import util_carto
import logging
# Set up logging
# Get the top-level logger object
logger = logging.getLogger()
for handler in logger.handlers: logger.removeHandler(handler)
logger.setLevel(logging.INFO)
# make it print to the console.
console = logging.StreamHandler()
logger.addHandler(console)
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# name of table on Carto where you want to upload data
# this should be a table name that is not currently in use
dataset_name = 'ene_009_renewable_generation_annually'
logger.info('Executing script for dataset: ' + dataset_name)
# create a new sub-directory within your specified dir called 'data'
# within this directory, create files to store raw and processed data
data_dir = util_files.prep_dirs(dataset_name)
'''
Download data and save to your data directory
'''
# data can be downloaded by following the steps in the 'Data Acquisition' section of the README file
# generate path to downloaded data file
download = os.path.join(os.path.expanduser("~"), 'Downloads', 'Export_Full_Data_data.csv')
# Move this file into your data directory
raw_data_file = os.path.join(data_dir, os.path.basename(download))
shutil.move(download,raw_data_file)
'''
Process data
'''
# read in csv file as Dataframe
df = pd.read_csv(raw_data_file, dtype=str)
# filter pumped storage plants just like IRENA default
df = df[df['Sub-technology'] != 'Pumped Storage']
# convert values from string to float because summing later
df['Values_asfloat'] = df['Values'].astype(float)
# subset into generation
generation_data = df[df['DataType'] == 'Electricity Generation']
# assuming GWh everywhere, check that; yes the field name has a space at the end
assert (generation_data['Unit '] == 'GWh').all()
# group by the key dimensions
grouped = generation_data.groupby(['ISO', 'Years', 'Sub-technology', 'Type'])
# ensure Technology is mapped 1:1 with Sub-technology
assert grouped.agg({'Technology': lambda x: len(set(x)) == 1}).Technology.all()
# create the data frame, renaming values and organizing the column order
data = grouped.agg({
'Values_asfloat': 'sum', # sum the numeric capacity value
'IRENA Label': 'first', # take a long name for the country
'Technology': 'first', # take the technology (superclass)
}).reset_index().rename(columns={
'ISO': 'iso_a3',
'Years': 'year',
'Sub-technology': 'subtechnology',
'Technology': 'technology',
'Type': 'grid_connection',
'IRENA Label': 'country_name',
'Values_asfloat': 'generation_GWh',
})[[ # set a new column order
'iso_a3', # key
'country_name', # 1:1 with iso_a3
'year', # key
'subtechnology', # key
'technology', # 1:n with subtechnology
'grid_connection', # key
'generation_GWh' # the numeric generation value in gigawatt-hours
]]
#save processed dataset to csv
processed_data_file = os.path.join(data_dir, dataset_name+'_edit.csv')
data.to_csv(processed_data_file, index=False)
'''
Upload processed data to Carto
'''
logger.info('Uploading processed data to Carto.')
util_carto.upload_to_carto(processed_data_file, 'LINK')
'''
Upload original data and processed data to Amazon S3 storage
'''
# initialize AWS variables
aws_bucket = 'wri-public-data'
s3_prefix = 'resourcewatch/'
logger.info('Uploading original data to S3.')
# Upload raw data file to S3
# Copy the raw data into a zipped file to upload to S3
raw_data_dir = os.path.join(data_dir, dataset_name+'.zip')
with ZipFile(raw_data_dir,'w') as zip:
zip.write(raw_data_file, os.path.basename(raw_data_file))
# Upload raw data file to S3
uploaded = util_cloud.aws_upload(raw_data_dir, aws_bucket, s3_prefix+os.path.basename(raw_data_dir))
logger.info('Uploading processed data to S3.')
# Copy the processed data into a zipped file to upload to S3
processed_data_dir = os.path.join(data_dir, dataset_name+'_edit.zip')
with ZipFile(processed_data_dir,'w') as zip:
zip.write(processed_data_file, os.path.basename(processed_data_file))
# Upload processed data file to S3
uploaded = util_cloud.aws_upload(processed_data_dir, aws_bucket, s3_prefix+os.path.basename(processed_data_dir)) | [
"amelia.marie.snyder@gmail.com"
] | amelia.marie.snyder@gmail.com |
7bf852941f82f134e97b78634f0c21a6e8cb175b | cc2855d6c10700179f40f3debebb1a17c2ac8cd8 | /src/communication/manual_bt_control.py | 3d7ee77eabc279bcadd663b5216962feadfddbd1 | [] | no_license | KaistParking/parking-pkg | 2157e0be11363bc79e190eb9f2501d986ea0e3b4 | cb8d0de9721375fec9b1936c8348db3008785837 | refs/heads/master | 2023-01-28T15:52:47.958913 | 2020-12-08T13:32:51 | 2020-12-08T13:32:51 | 314,158,124 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 282 | py | from bluetooth import *
client_socket = BluetoothSocket(RFCOMM)
client_socket.connect(("98:d3:31:fd:3e:0d", 1))
print("connected")
while True:
msg = input("send :")
print(msg)
client_socket.send(msg.encode(encoding="utf-8"))
print("finished")
client_socket.close()
| [
"parkinkon1@naver.com"
] | parkinkon1@naver.com |
1ee5c951d89a1f679fdaa1c55e2abbf4be55c566 | 339a7fbffdc6a17d5711ae21111db6dfdbf96b71 | /models/SIIS/__init__.py | 338d9a26272cec1dbacd2ad188717ccb379eb90c | [
"MIT"
] | permissive | HenryOsborne/SemanticSegmentation | 6b0059fe4de25977d00e2f25d1063e282b610c2d | d41549c3fd22731d7a12cdb1b438f730b0ebfcbc | refs/heads/master | 2023-01-30T10:23:49.200630 | 2020-12-19T15:39:56 | 2020-12-19T15:39:56 | 318,069,213 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,051 | py | from models.SIIS.HF_FCN import HF_FCN
from models.SIIS.DeeplabV3_plus import DeeplabV3_plus
from models.SIIS.ContrastNets import ResUnet, ResUnet_SIIS
from models.SIIS.SIIS_NET import (
Vgg_SIIS, Resnet_SIIS, Deeplab_SIIS
)
from models.SIIS.UNet import UNet, UNet_SIIS
def build_model(num_classes, siis_size=None, net_num='12345678'):
'''
Args:
net_num: A string of eight numbers,
The first number represents the arch of the models:
if net_num[0] <= 5
1 - /
2 - UNet_SIIS
3 - ResUnet_SIIS
4 - deeplabv3+
The second number represents the arch of SIIS
X0 - no SIIS
X1 - SIIS1 exp
X2 - SIIS2 exp
X3 - SIIS3 exp
X4 - SIIS4 (Conv3d-RNN)
X5 - SIIS5 exp
X6 - SIIS6 exp
X7 - SIIS7 (conv1d)
The third number represents the width of SIIS:
XXn - width=n
The fourth number represents the kw of SIIS:
XXXn - kw = [3, 5, 7, 9, 11, 13](n)
The fifth number represents the dim of SIIS:
XXXXn - dim = [128, 256](n)
if backbone of models is resnt:
The sixth number represents the arch of resnet:
XXXXXn - resnet_arch = ['resnet50', 'resnet101'](n)
The seventh number represents the layer_num of resnet:
XXXXXXn - layer_num = n
The eighth number represents the out_stride of resnet:
XXXXXXXn - out_stride = [8, 16, 32](n)
elif net_num[0] > 5:
6 - depplabV3+
The second number represents the scheme of ASPP_Rate:
The third number represents the arch of resnet:
XXn - resnet_arch = ['resnet50', 'resnet101'](n)
The fourth number represents the layer_num of resnet:
XXXn - layer_num = n
The fifth number represents the out_stride of resnet:
XXXXn - out_stride = [8, 16, 32](n)
7 - ResUnet
8 - HF_FCN
9 - UNet
'''
assert type(net_num) == str
paras = [int(n) for n in net_num] # str -> int
model_name = {
# 1: 'Vgg_SIIS', 2: 'Resnet_scnIIS
1: 'DinkNet34', 2: 'UNet_SIIS',
3: 'ResUnet_SIIS', 4: 'Deeplab_SIIS',
6: 'DeeplabV3_plus', 7: 'ResUnet', 8: 'HF_FCN', 9: 'UNet'
}
print('-' * 50, '\n', 'Net_num: ', net_num)
commen_str = model_name[paras[0]] + '(' + 'num_classes'
# 解析net_num
if paras[0] < 6:
# Nets with SIIS
if siis_size is not None:
commen_str += ', siis_size'
commen_str += ', arch=%d' % paras[1]
commen_str += ', width=%d' % paras[2]
commen_str += ', kw=%d' % [3, 5, 7, 9, 11, 13][paras[3]]
commen_str += ', dim=%d' % [128, 256, 512][paras[4]]
if paras[0] > 3: # use resnet as basic encoder
commen_str += ', resnet_arch=%s' % ["'resnet50'", "'resnet101'"][paras[5]]
commen_str += ', layer_num=%d' % paras[6]
commen_str += ', output_stride=%d' % [8, 16, 32][paras[7]]
elif paras[0] == 6:
commen_str += ', aspp_rate=%d' % paras[1]
commen_str += ', resnet_arch=%s' % ["'resnet50'", "'resnet101'"][paras[2]]
commen_str += ', layer_num=%d' % paras[3]
commen_str += ', output_stride=%d' % [8, 16, 32][paras[4]]
commen_str += ')'
print(commen_str)
model = eval(commen_str) # Build models
return model
if __name__ == '__main__':
import torch
device = 'cuda:0' if torch.cuda.is_available() else 'cpu'
model = build_model(2, [32, 32], '44330020').to(device)
inpu = torch.randn(2, 3, 512, 512).to(device)
output = model(inpu)
print(output.size())
| [
"wk1009519920@gmail.com"
] | wk1009519920@gmail.com |
9aab1377cb39c4a79cf491dc25d8fc8382eabee7 | 1b265743a1d9521ee7e106c3a42960b8be3c029f | /gd/model/pst_ridge.py | 55a79c3b4a15b5d9bf182eab6986dbbe02c6b3e0 | [] | no_license | wangsw09/optim_algo | 201cd52c076965b96da39c45e3749d7a8114d8b4 | 7b8bd22f2bc97eadbf36e7b61a5d97671abd6c0d | refs/heads/master | 2021-01-24T11:27:29.436476 | 2018-02-27T06:43:51 | 2018-02-27T06:43:51 | 123,084,314 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 791 | py | import numpy as np
from scipy.linalg import eigh as max_eigval
from .. import loss_reg as lr
from .. import proj
from .. import lib
def linear_pst_ridge(y, X, lam, max_iter=1000, tol=1e-7, algo="proj_gd"):
n, p = X.shape
x = np.zeros(p)
XTX = np.dot(X.T, X)
XTy = np.dot(X.T, y)
ss = 1.0 / (max_eigval(XTX, eigvals_only=True, eigvals=(p-1, p-1),
check_finite=False)[0] + lam)
ridge_obj = lambda x: lr.l2_loss_obj(x, y, X) + lam * lr.l2_reg_obj(x)
ridge_grad = lambda x, XTy, XTX: lr.l2_loss_grad2(x, XTy, XTX) + lam * lr.l2_reg_grad(x)
if algo == "proj_gd":
x_hat = lib.proj_gd(x, ridge_grad, proj.pst_quadrant,
ss, ridge_obj, max_iter, tol,
grad={"XTX" : XTX, "XTy" : XTy}, proj={} )
return x_hat
| [
"sw2853@columbia.edu"
] | sw2853@columbia.edu |
099cb4b2dbc1f97665892c9ac15529dffaaa8d6a | c8b7904e0aff789097f3ca1b190f5947cc54c5df | /nested_loops.py | 75d378475b97f2c1ccb53c2014f34b046299f06d | [] | no_license | TiaanVenter/pythonlearningprograms | 2ea7ee523bfadba6c59ba4f8a7925a99e578f940 | a46fca40dda06050f9dd00de2f1b2b6586c7f046 | refs/heads/main | 2023-07-10T08:46:27.542918 | 2021-08-07T08:43:34 | 2021-08-07T08:43:34 | 300,843,373 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 159 | py | for x in range(5):
for y in range(2):
for z in range(7):
print(x, y, z)
#simple example of 3-dimensional nested for loop. | [
"noreply@github.com"
] | TiaanVenter.noreply@github.com |
1850ef406a79d9da0f1c4ba84ea46946f7c36611 | f83d5ae67d4ead9fc0f7ea1a680813dcd571e9f4 | /manage.py | 7797e122946313ab9829079fec059f9b3ebc6ff3 | [] | no_license | reshadbinharun/physiosense | b7fe77874fbd0195fe44b0a11e61725d24a807bc | 0413202760d7e40ea120c597faaa6c85835e304a | refs/heads/master | 2023-08-15T17:08:59.413272 | 2020-06-23T04:43:38 | 2020-06-23T04:43:38 | 274,308,176 | 0 | 0 | null | 2021-09-22T19:17:35 | 2020-06-23T04:26:27 | Python | UTF-8 | Python | false | false | 631 | py | #!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys
def main():
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'physiosense.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line(sys.argv)
if __name__ == '__main__':
main()
| [
"reshadbinharun@gmail.com"
] | reshadbinharun@gmail.com |
7620c16b70a5011be660188673a3d70cf943f517 | f305f84ea6f721c2391300f0a60e21d2ce14f2a5 | /4_set/6265. 统计相似字符串对的数目-frozenset.py | a37db3b54e7eb3a906c7279c7abccaff4e9548a7 | [] | 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 | 786 | py | from typing import List
from collections import Counter
# 给你一个下标从 0 开始的字符串数组 words 。
# 如果两个字符串由相同的字符组成，则认为这两个字符串 相似 。
# 例如，"abca" 和 "cba" 相似，因为它们都由字符 'a'、'b'、'c' 组成。
# 然而，"abacba" 和 "bcfd" 不相似，因为它们不是相同字符组成的。
# 请你找出满足字符串 words[i] 和 words[j] 相似的下标对 (i, j) ，并返回下标对的数目，其中 0 <= i < j <= word.length - 1 。
class Solution:
def similarPairs(self, words: List[str]) -> int:
counter = Counter()
for word in words:
counter[frozenset(word)] += 1
return sum(v * (v - 1) // 2 for v in counter.values())
| [
"lmt2818088@gmail.com"
] | lmt2818088@gmail.com |
92cd204e3987396ace013dc3e2ef25d7abdc50a0 | 3a958811aaecab99efd57c35613aa88251eae0ec | /dissection/Dataset.py | 9afa94378f4aec07df122067c391e788b0e66a8e | [
"Apache-2.0"
] | permissive | jstephenj14/openrec | 99c74f7c600b000828fa355bc66653b3857391a4 | 82e7644d062be5fbe62eec80975023c8acd7ba69 | refs/heads/master | 2022-11-08T04:13:09.901161 | 2020-07-01T17:03:02 | 2020-07-01T17:03:02 | 275,661,063 | 0 | 0 | Apache-2.0 | 2020-06-28T20:15:29 | 2020-06-28T20:15:29 | null | UTF-8 | Python | false | false | 7,420 | py | from openrec.tf2.data import _ParallelDataset
from openrec.tf2.data import _DataStore
import tensorflow as tf
import numpy as np
import random
def _pairwise_generator(datastore):
while True:
entry = datastore.next_random_record()
user_id = entry['user_id']
p_item_id = entry['item_id']
n_item_id = datastore.sample_negative_items(user_id)[0]
yield {'user_id': user_id,
'p_item_id': p_item_id,
'n_item_id': n_item_id}
def _stratified_pointwise_generator(datastore, pos_ratio):
while True:
if random.random() <= pos_ratio:
entry = datastore.next_random_record()
yield {'user_id': entry['user_id'],
'item_id': entry['item_id'],
'label': 1.0}
else:
user_id = random.randint(0, datastore.total_users() - 1)
item_id = random.randint(0, datastore.total_items() - 1)
while datastore.is_positive(user_id, item_id):
user_id = random.randint(0, datastore.total_users() - 1)
item_id = random.randint(0, datastore.total_items() - 1)
yield {'user_id': user_id,
'item_id': item_id,
'label': 0.0}
def _per_pos_stratified_pointwise_generator(datastore, pos_ratio):
num_negative_per_positive = int((1 - pos_ratio) / pos_ratio)
while True:
entry = datastore.next_random_record()
user_id = entry['user_id']
p_item_id = entry['item_id']
yield {'user_id': user_id,
'item_id': p_item_id,
'label': 1.0}
count = 0
for n_item_id in random.sample(range(datastore.total_items()), k=num_negative_per_positive + 1):
if n_item_id == p_item_id:
continue
yield {'user_id': user_id,
'item_id': n_item_id,
'label': 0.0}
count += 1
if count >= num_negative_per_positive:
break
def _evaluation_generator(datastore, excl_datasets):
eval_users = datastore.warm_users()
for user_id in eval_users:
pos_mask_npy = np.zeros(datastore.total_items(), dtype=np.bool) # Reset pos_mask
positive_items = datastore.get_positive_items(user_id)
pos_mask_npy[positive_items] = True
if datastore.contain_negatives():
excl_mask_npy = np.ones(datastore.total_items(), dtype=np.bool) # Reset excl_mask
excl_mask_npy[positive_items] = False
negative_items = datastore.get_negative_items(user_id)
excl_mask_npy[negative_items] = False
else:
excl_mask_npy = np.zeros(datastore.total_items(), dtype=np.bool) # Reset excl_mask
excl_positive_items = []
for excl_d in excl_datasets:
excl_positive_items += excl_d.datastore.get_positive_items(user_id)
excl_mask_npy[excl_positive_items] = True
yield {'user_id': user_id,
'pos_mask': pos_mask_npy,
'excl_mask': excl_mask_npy}
class Dataset:
def __init__(self, raw_data, total_users, total_items, implicit_negative=True,
num_negatives=None, seed=None, sortby=None, asc=True, name=None):
self.datastore = _DataStore(raw_data=raw_data,
total_users=total_users,
total_items=total_items,
implicit_negative=implicit_negative,
num_negatives=num_negatives,
seed=seed, sortby=sortby, name=name, asc=asc)
def _build_dataset(self, generator, generator_params, output_types, output_shapes,
batch_size, num_parallel_calls, take=None):
return _ParallelDataset(generator=generator,
generator_params=generator_params,
output_types=output_types,
output_shapes=output_shapes,
batch_size=batch_size,
num_parallel_calls=num_parallel_calls,
take=take)
def pairwise(self, batch_size, num_parallel_calls=1, take=None):
output_types = {'user_id': tf.int32,
'p_item_id': tf.int32,
'n_item_id': tf.int32}
output_shapes = {'user_id': [],
'p_item_id': [],
'n_item_id': []}
return self._build_dataset(generator=_pairwise_generator,
generator_params=(self.datastore,),
output_types=output_types,
output_shapes=output_shapes,
batch_size=batch_size,
num_parallel_calls=num_parallel_calls,
take=take)
def stratified_pointwise(self, batch_size, pos_ratio=0.5, num_parallel_calls=1, take=None):
output_types = {'user_id': tf.int32,
'item_id': tf.int32,
'label': tf.float32}
output_shapes = {'user_id': [],
'item_id': [],
'label': []}
return self._build_dataset(generator=_stratified_pointwise_generator,
generator_params=(self.datastore, pos_ratio),
output_types=output_types,
output_shapes=output_shapes,
batch_size=batch_size,
num_parallel_calls=num_parallel_calls,
take=take)
def per_pos_stratified_pointwise(self, batch_size, pos_ratio=0.5, num_parallel_calls=1, take=None):
output_types = {'user_id': tf.int32,
'item_id': tf.int32,
'label': tf.float32}
output_shapes = {'user_id': [],
'item_id': [],
'label': []}
return self._build_dataset(generator=_per_pos_stratified_pointwise_generator,
generator_params=(self.datastore, pos_ratio),
output_types=output_types,
output_shapes=output_shapes,
batch_size=batch_size,
num_parallel_calls=num_parallel_calls,
take=take)
def evaluation(self, batch_size, excl_datasets=[]):
output_types = {'user_id': tf.int32,
'pos_mask': tf.bool,
'excl_mask': tf.bool}
output_shapes = {'user_id': [],
'pos_mask': [self.datastore.total_items()],
'excl_mask': [self.datastore.total_items()]}
return self._build_dataset(generator=_evaluation_generator,
generator_params=(self.datastore, excl_datasets),
output_types=output_types,
output_shapes=output_shapes,
batch_size=batch_size,
num_parallel_calls=1)
| [
"aruls001@umn.edu"
] | aruls001@umn.edu |
556738410f5b98c9396f0e40a449638de4dd25f1 | f56b89c15db4f0c51aca2b292a8c3d3441046809 | /ANALYSE_RESULTS_support.py | 7816a74fb52b334034b39c218c3b468f3d2d5df2 | [] | no_license | rakesh684/grade-management-system | 16493ed7ce11b4f03614417e924bc0b677173713 | e23331c61ad6f06df0d64aafd66d496184389c93 | refs/heads/master | 2020-05-02T19:00:03.181157 | 2019-03-28T07:25:32 | 2019-03-28T07:25:32 | 178,146,080 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 643 | py | #! /usr/bin/env python
# -*- coding: utf-8 -*-
# Sep 26, 2018 01:17:01 PM
import sys
try:
from Tkinter import *
except ImportError:
from tkinter import *
try:
import ttk
py3 = False
except ImportError:
import tkinter.ttk as ttk
py3 = True
def init(top, gui, *args, **kwargs):
global w, top_level, root
w = gui
top_level = top
root = top
def destroy_window():
# Function which closes the window.
global top_level
top_level.destroy()
top_level = None
if __name__ == '__main__':
import ANALYSE_RESULTS
ANALYSE_RESULTS.vp_start_gui()
| [
"noreply@github.com"
] | rakesh684.noreply@github.com |
991da657a7710d1a2c205abaab58b63970b26c8c | 2543b827079cf9abe49e142411719ddc829b861c | /p005.py | 7ba66c2bf309e97008e900b835df48bb86ccda81 | [] | no_license | andreafresco/Project-Euler | 5ac6022b89dfa3ee96d950788bb83f3b42982e7d | 91b364c21f8df72fa6ee1a06d04f458b4a210038 | refs/heads/main | 2023-08-22T23:04:01.907905 | 2021-10-11T20:38:18 | 2021-10-11T20:38:18 | 415,856,350 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 687 | py | #
# Solution to Project Euler problem 5
# Copyright (c) Andrea Fresco. All rights reserved.
#
# https://projecteuler.net/problem=5
# https://github.com/andreafresco/Project-Euler
#
def GCD(a,b): # Greatest common divisor with EULER FORMULA
while a!=b:
if a>b:
a = a-b
if b>a:
b = b-a
return a
def mcm(a,b): # minimum common multiple
return a*b//GCD(a,b)
def SmallestMultiple(N_max):
prod = 1
for i in range(1, N_max+1):
prod = mcm(prod, i) # minimum common multiple of all the numbers
# between 1 and N_max
return prod
if __name__ == "__main__":
print(SmallestMultiple(20))
| [
"andreafresco6@gmail.com"
] | andreafresco6@gmail.com |
cdf1f6647a9fc4706e071adbe6df342711d540e7 | 383836b31b80e789cad33ac0db01a23bdc08a253 | /ascii.py | 03c99caecb3a24e9a00c3b37b4070bbc965e1b86 | [] | no_license | Shofuuu/malesi | 8bc7ebb7e446620cb5a322a44cf83aafec6e2fc4 | d894e92c2ce1e094b65e183a6c1d5dbc4e2ab512 | refs/heads/master | 2021-05-17T11:24:58.092900 | 2020-04-07T15:05:36 | 2020-04-07T15:05:36 | 253,192,068 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 221 | py | #!/usr/bin/python3
data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ,. :1234567890()/\"&*"
datalwr = data.lower()
for x in range(len(data)):
print(str(x+1) + ").", data[x], "=", ord(data[x]), " | ", datalwr[x], "=", ord(datalwr[x]))
| [
"hadoepan@gmail.com"
] | hadoepan@gmail.com |
8a249b5a861e4e6cc019ddca4e6921206e3e1fdd | 3eadb07e36ec61962fd37cf7d4601888687939f7 | /dataset/yearPredictionMSD/scripts/preprossing.py | 05494a8aab5ae41b9855c88f013336a45b1ccf58 | [] | no_license | YaweiZhao/simulation_based_machine_learning_library | 530ac4c14fd4bbba83d638c451dd93a5282af711 | 130a73596df9b50e25907bc329a8b6360ec7395d | refs/heads/master | 2021-05-09T19:11:52.780137 | 2018-01-27T02:20:02 | 2018-01-27T02:20:02 | 118,633,987 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,108 | py | #This python script is used to pre-process YearPredictionSMD
#each sample contains 90 features
import re
import fileinput
def process(str):
#print("pre-processing...\n")
pattern = re.compile(':(-?[0-9]+\.?[0-9]*)')
res=pattern.findall(str)
count=0
str=''
for data in res:
#if count==0:
# count = count+1;
# continue''''
if count==89:
str=str+data
else:
str=str+data+' '
count = count+1
if count!=90:
print("ERROR\n")#verify whether dataset has been parsed correctly
return -1
str = str+'\n'
write2file(str,'train_sample.txt','a+')
def write2file(text, filename2, mod):
f = open(filename2,mod)
f.write(text)
f.close()
def process_label_file(line):
label=line[:4]
label=label+"\n"
write2file(label,'train_label.txt','a+')
filename='YearPredictionMSD'
f = open(filename)
num=0
for line in fileinput.input(filename):
if len(line)<10:
continue
do_right=process(line)
if do_right==-1:
break#something goes wrong
process_label_file(line)
num=num+1
precent = 1.0*num/463715
print(precent)
f.close()
| [
"zhaoyawei@nudt.edu.cn"
] | zhaoyawei@nudt.edu.cn |
d7ae0618630a3acbedbd9c61089248bc1fea314b | c70e189514cf4696c98c544750d897ab46fa0994 | /rna_seq/get_percent_mapped.py | 219fdb11b28910d3c561f35660b6559b115c6f65 | [] | no_license | pjtorres/Bioinformatics-BC | 42dde9fc64a23b1735d6229f05c53981d4cf3f1b | fbd3f186b412da6414f0c1f78d24e3a78e5a8246 | refs/heads/master | 2023-07-19T22:53:32.351396 | 2023-07-13T19:47:17 | 2023-07-13T19:47:17 | 81,875,725 | 6 | 3 | null | 2019-02-28T07:45:36 | 2017-02-13T21:52:30 | Jupyter Notebook | UTF-8 | Python | false | false | 1,481 | py | import os, argparse
# infile='1RAD_1027298.star.starLog.final.out'
# outfile='1RAD_1027298.star.starLog.final.out.percent.tsv'
#--------Command line arguments----------
parser=argparse.ArgumentParser(description="Script will allow you to percent mapped and unmaped reads in a STAR output log file.")
parser.add_argument('-i','--input', help='File should have suffuc star.starLog.final.out. ', required=True)
#Pass arguments
args = parser.parse_args()
infile=args.input
outfile = infile+'.percent.tsv'
fin = open(infile, 'r+')
fout = open(outfile,'w+')
for line in fin:
line=line.strip().split('|')
if line[0]=='Number of input reads ':
total = line[1].strip()
if line[0]=='Uniquely mapped reads % ':
unique_mapped = line[1].strip()
if line[0]=='% of reads mapped to multiple loci ':
multi_mapped = line[1].strip()
if line[0]=='% of reads mapped to too many loci ':
toomany_mapped = line[1].strip()
if line[0]=='% of reads unmapped: too short ':
too_short = line[1].strip()
if line[0]=='% of reads unmapped: other ':
other_unmapped = line[1].strip()
total_unmapped = str(float(other_unmapped.strip('%')) +float(too_short.strip('%')))
total_mapped = str(float(unique_mapped.strip('%')) +float(multi_mapped.strip('%')) + float(toomany_mapped.strip('%')))
fout.write('percent_mapped'+'\t'+'percent_unmapped'+'\n')
fout.write(total_mapped+'\t'+total_unmapped)
fout.close()
fin.close()
| [
"noreply@github.com"
] | pjtorres.noreply@github.com |
c9dbff1dbed99bbf48764f09006d52fd94f90e4f | 3d7fdfc2d5f94db201d2769ec914b5c42509eeb1 | /main/forms.py | d2313aea65f26c6054c546d3167971254be24aa5 | [] | no_license | artyomLisovskij/django-celery-rabbitmq-docker-compose-httpsify | d95dfcb82fc28b3f82a431445bbd0e7a2100bbaa | 21c0dd469d2d4e7c7fbc4519fd73548ee2e8afee | refs/heads/master | 2020-05-18T17:26:49.210611 | 2019-05-02T10:03:54 | 2019-05-02T10:03:54 | 184,556,029 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 167 | py | from .import_libs import *
from .models import *
from django import forms
''' Forms '''
class RecallForm(forms.Form):
date_next = forms.DateField(required=False)
| [
"artyom@lisovskij.ru"
] | artyom@lisovskij.ru |
8ba8ac218525fe114aef069e508dbd337d9c8b19 | eeeba145ae4b6df7b5d95cc70d476a01dba6c5fe | /PythonStudy/func_test/lambda_test.py | 52286c0eb1edd88d86870e484d66ce35fd90a1e7 | [] | no_license | liujinguang/pystudy | 0ceb58652777f99d4cfe3e143ff11ea44c7e3a74 | d2e4366cfd5e74197fc9ec560eb50dbd508cbcc2 | refs/heads/master | 2020-12-23T13:11:42.556255 | 2017-06-28T13:03:26 | 2017-06-28T13:03:26 | 92,559,516 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 356 | py | #/usr/bin/python
# -*- coding: UTF-8 -*-
'''
Created on 2017年5月31日
@author: bob
'''
def multipliers():
return [lambda x : i * x for i in range(4)]
print [m(2) for m in multipliers()]
def multipliers_v1():
for i in range(4):
yield lambda x: i * x
print [m(2) for m in multipliers_v1()]
if __name__ == '__main__':
pass | [
"jinguang.liu@qq.com"
] | jinguang.liu@qq.com |
d31988b13f42acd2ad1577ce07a0b7e8506e7ce8 | 925dc0d981391e4538401a7af88fcac25921ccab | /emission/net/api/metrics.py | 20e6b0f9fd1e9cee84bd6847b0c0a85cce6b0ff9 | [
"BSD-3-Clause"
] | permissive | gtfierro/e-mission-server | 0e75742301b3de8d8dd71e6bc3a6e7c0bfe48ee7 | b10c5da080b741b28eccf8cb7413ace3063eaaac | refs/heads/master | 2021-01-19T11:58:24.441986 | 2016-09-30T09:00:54 | 2016-09-30T09:00:54 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,203 | py | import logging
import emission.analysis.result.metrics.time_grouping as earmt
import emission.analysis.result.metrics.simple_metrics as earms
def summarize_by_timestamp(user_id, start_ts, end_ts, freq, metric_name):
return _call_group_fn(earmt.group_by_timestamp, user_id, start_ts, end_ts,
freq, metric_name)
def summarize_by_local_date(user_id, start_ld, end_ld, freq_name, metric_name):
local_freq = earmt.LocalFreq[freq_name]
return _call_group_fn(earmt.group_by_local_date, user_id, start_ld, end_ld,
local_freq, metric_name)
def _call_group_fn(group_fn, user_id, start_time, end_time, freq, metric_name):
summary_fn = earms.get_summary_fn(metric_name)
logging.debug("%s -> %s" % (metric_name, summary_fn))
aggregate_metrics = group_fn(None, start_time, end_time,
freq, summary_fn)
ret_dict = {"aggregate_metrics": aggregate_metrics["result"]}
if user_id is not None:
user_metrics = group_fn(user_id, start_time, end_time,
freq, summary_fn)
ret_dict.update({"user_metrics": user_metrics["result"]})
return ret_dict
| [
"shankari@eecs.berkeley.edu"
] | shankari@eecs.berkeley.edu |
dc3be60231a9805f5ff1fb7b297a0f76340ee5c4 | 02bc2b859de43ea96b212c72220749d90da9cdc7 | /tuples_and_sets_EXERCISES/battle_of_names.py | 2dfc410fd9e722ead477a0d2f6063fc6ddf4a3a3 | [] | no_license | BilyanaRumenova/Python-Advanced | b637f78d8ca8a7e5fc50298af04a631849fcfc16 | 92110abfc06958c5a5e652ef8dd982249a0a719d | refs/heads/main | 2023-05-05T15:34:27.633218 | 2021-05-21T15:53:54 | 2021-05-21T15:53:54 | 368,782,986 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 730 | py | n = int(input())
even_sum = set()
odd_sum = set()
for line in range(1, n+1):
name = input()
current_sum = sum([ord(el) for el in name]) // line
if current_sum % 2 == 0:
even_sum.add(current_sum)
else:
odd_sum.add(current_sum)
total_sum_even = sum(even_sum)
total_sum_odd = sum(odd_sum)
if total_sum_even == total_sum_odd:
modified_set = [str(el) for el in even_sum.union(odd_sum)]
print(f"{', '.join(modified_set)}")
elif total_sum_odd > total_sum_even:
modified_set = [str(el) for el in odd_sum.difference(even_sum)]
print(f"{', '.join(modified_set)}")
else:
modified_set = [str(el) for el in odd_sum.symmetric_difference(even_sum)]
print(f"{', '.join(modified_set)}") | [
"biliana_rk@students.softuni.bg"
] | biliana_rk@students.softuni.bg |
7ef1c53c084d6e08565f033b47949466a98213bd | 1cd17a9960f711ac299b78dd2ba92a0f92a59bad | /post.py | e0e5b3dad324c726e780e7bcc467071cebc1e703 | [] | no_license | Edennyk/python_blog | 6f92858f0a3e480164ec50f52fb2ab0f0580bb7f | 747cf9a6d6e67a5d4ee62ceb0dde818b51eee471 | refs/heads/main | 2023-08-03T18:55:49.074601 | 2021-08-31T14:59:23 | 2021-08-31T14:59:23 | 400,861,018 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 921 | py |
class Post:
"""
board class
param id
param title
param content
param view_count
"""
def __init__(self, id , title, content, view_count):
self.id = id
self.title = title
self.content = content
self.view_count = view_count
def set_post(self, id , title, content, view_count):
self.id = id
self.title = title
self.content = content
self.view_count = view_count
def add_view_count(self):
self.view_count += 1
def get_id(self):
return self.id
def get_title(self):
return self.title
def get_cotent(self):
return self.content
def get_view_count(self):
return self.view_count
# if __name__ == "__main__":
# post = Post(1, "Test", "This is a Test", 0)
# post.set_post(1, "Test2", "This is a Test2", 0)
# post.add_view_count()
# print(f"{post.get_id()} {post.get_title()} {post.get_cotent()} {post.get_view_count()}") | [
"edennyk@gmail.com"
] | edennyk@gmail.com |
6f16a80baf9f79ad32336a1e28cba9cdc22c702e | 3fcb45d9a3d8e17facae7bb21a4ed00e83368d61 | /Model/Entrenamiento.py | e26bacd9db76034b389fcbf9123eb42fa5770bec | [] | no_license | Feymus/AutoCaras | 147bbf758fc978ebd2fb0be59b5b12d652f131fe | 3dcd7c5ed42cc3c9b3e96d7cefcc98dfbadb385e | refs/heads/master | 2021-08-14T14:19:20.087654 | 2017-11-15T23:54:21 | 2017-11-15T23:54:21 | 100,324,963 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,305 | py | '''
Created on Nov 3, 2017
@author: HP
'''
class Entrenamiento(object):
'''
Clase Entrenamiento
Esta clase es la representacion abstracta de un entrenamiento
'''
def __init__(self, dict_entrenamiento):
'''
Constructor de la clase
El constructor guarda lo necesario para realizar la clasificacion
@param auto_vectores, los auto vectores en el entrenamiento
@param mean, la cara promedio
@param pesos, las imagenes proyectadas
@param imgs_usadas, las imagenes usadas para entrenar
'''
self.auto_vectores = dict_entrenamiento["auto_vectores"]
self.mean = dict_entrenamiento["mean"]
self.pesos = dict_entrenamiento["pesos"]
self.imgs = dict_entrenamiento["imgs_usadas"]
self.prefijo = dict_entrenamiento["prefijo"]
def get_entrenamiento(self):
"""
Metodo get_entrenamiento
Metodo simple que regresa todos sus atributos para la carga
del entrenamiento
@param null
"""
return (self.auto_vectores, self.mean, self.pesos, self.imgs)
def get_prefijo(self):
"""
Metodo get_prefijo
Metodo que devuelve el prefijo del entrenamiento
@return el prefijo
"""
return self.prefijo
| [
"michaelchoque62@gmail.com"
] | michaelchoque62@gmail.com |
0e97ec8f693cc985bc3b52f120faf4afdbbadbe2 | 0b0ccedf376d5e9571b9150c1d707411fdbb753c | /api/api/models/nomination.py | 4293aca307ed83d2f63f06280e96aacadb12b9e8 | [
"Apache-2.0"
] | permissive | andrewsosa/hackfsu_com | 7eec3c5b58179e74d60d2a8127bd2a30cc0eaae9 | fad97c21e2643e5df9759ebf260881b26e918d7c | refs/heads/master | 2021-01-25T07:55:41.510335 | 2018-03-22T15:44:17 | 2018-03-22T15:44:17 | 93,691,310 | 0 | 0 | null | 2017-07-09T19:42:49 | 2017-06-08T00:28:49 | Python | UTF-8 | Python | false | false | 1,864 | py | from django.contrib import admin
from django.db import models
from django.db.models.manager import BaseManager
from hackfsu_com.admin import hackfsu_admin
from api.models import JudgingCriteria
class NominationQuerySet(models.QuerySet):
pass
class Nomination(models.Model):
objects = BaseManager.from_queryset(NominationQuerySet)()
hack = models.ForeignKey(to='api.Hack', on_delete=models.CASCADE)
superlative = models.ForeignKey(to='api.JudgingCriteria', on_delete=models.CASCADE)
class SuperlativeNameFilter(admin.SimpleListFilter):
title = 'Superlative'
parameter_name = 'superlative'
def lookups(self, request, model_admin):
superlative_categories = JudgingCriteria.objects.all()
superlative_names = list(superlative_categories.values_list('name', flat=True))
return zip(superlative_names, superlative_names)
def queryset(self, request, queryset):
superlative_categories = JudgingCriteria.objects.all()
superlative_names = list(superlative_categories.values_list('name', flat=True))
if self.value() in superlative_names:
return queryset.filter(superlative__name = self.value())
return queryset
@admin.register(Nomination, site=hackfsu_admin)
class NominationAdmin(admin.ModelAdmin):
list_filter = (SuperlativeNameFilter, )
list_display = ('id', 'hack_name', 'superlative_name', 'hack_superlative_total')
list_display_links = ('id',)
search_fields = ('hack_name', 'superlative_name')
def hack_name(self, obj: Nomination):
return obj.hack.name
hack_name.admin_order_field = "hack__name"
def superlative_name(self, obj: Nomination):
return obj.superlative.name
def hack_superlative_total(self, obj: Nomination):
return len(Nomination.objects.filter(hack=obj.hack, superlative=obj.superlative))
| [
"andrewsosa001@gmail.com"
] | andrewsosa001@gmail.com |
d64f8af94913744aae852b93afce62975dfc0792 | 6c0cfe1782acd184b2b5f60eedf93b075af5c772 | /src/main/conf/res/scripts/createDocument.py | caf6b704dc0a9ba51d3efde3c797a5d63b63cc99 | [
"Apache-2.0"
] | permissive | juniper-project/modelling-mongodb | 00965356c6bcaa8c0987e9bb0f9f091802f5064a | 129d3f6ff001a5df1982559dd9a4b49f36caecca | refs/heads/master | 2021-01-10T09:30:53.750329 | 2015-11-10T15:10:25 | 2015-11-10T15:10:25 | 45,918,801 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 773 | py | #
# Copyright 2014 Modeliosoft
#
# 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.
#
document = modelingSession.getModel().createClass('Document', selectedElements.get(0), 'MongoDBModeler', 'Document')
document.addStereotype('PersistentProfile','Entity')
createdElement = document | [
"MAURELIO1234@GMAIL.COM"
] | MAURELIO1234@GMAIL.COM |
1f695516677ea4ce8ee9afaa0e7d1a481ae97e6e | d7f3bfa6f0e04f3abb545ebf8d5a5ec65bb31c12 | /api/vk_api.py | dec2e4a13b24a8d4ae68ced4a3e9dd818758c719 | [] | no_license | ayeffkay/Verbal-aggression-detection | 8b76c02fc030039821613f4874a39914d3ca15ea | 2653c73466562ee75b0c3a40ce89b48e1fa36e96 | refs/heads/master | 2022-04-16T14:57:31.426930 | 2020-04-18T05:11:29 | 2020-04-18T05:11:29 | 233,842,818 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,702 | py | import vk
import re
from datetime import datetime, date
import time
import api
class VkApi:
def __init__(self, version=5.74):
self.access_token = api.vk_token
self.session = vk.Session(access_token=self.access_token)
self.api = vk.API(self.session, v=version)
self.groups_lim = 15
self.topics_lim = 100
self.comments_lim = 100
def groups_search(self, query):
groups = self.api.groups.search(q=query, type="group, page",
sort=4, count=self.groups_lim,
fields="description,members_count")
return groups['items']
@staticmethod
def to_datetime(time):
return datetime.fromtimestamp(time).strftime('%Y-%m-%d %H:%M:%S')
def get_topics(self, id, count=100):
offset = 0
total_topics = []
for i in range(count, 0, -self.topics_lim):
topics = self.api.wall.get(owner_id=-id, count=self.topics_lim, offset=offset)["items"]
total_topics += topics
offset += self.topics_lim
for topic in total_topics:
topic["date"] = self.to_datetime(topic["date"])
count = topic.pop("comments", None)
topic["comments"] = count["count"]
likes = topic.pop("likes", None)
topic["likes"] = likes["count"]
reposts = topic.pop("reposts", None)
topic["reposts"] = reposts["count"]
return total_topics
def get_comments(self, owner_id, post_id, count=100):
total_comments = []
j = 0 # offset
for i in range(count, 0, -self.comments_lim):
ct = i if i <= self.comments_lim else self.comments_lim
comments = self.api.wall.getComments(owner_id=-owner_id,
post_id=post_id,
need_likes=1,
count=ct,
offset=j)["items"]
total_comments += comments
j += self.comments_lim
time.sleep(1)
for comment in total_comments:
comment["date"] = self.to_datetime(comment["date"])
likes = comment.pop("likes", None)
comment["likes"] = likes["count"]
reply = comment.pop("reply_to_comment", None)
comment["reply_to_comment"] = reply
reply = comment.pop("reply_to_user", None)
comment["reply_to_user"] = reply
return total_comments
def is_member(self, group_id, user_id):
return self.api.groups.isMember(group_id=group_id, user_id=user_id)
def user_info(self, user_id):
fields = "bdate,city,counters,sex"
usr = self.api.users.get(user_ids=user_id, fields=fields)[0]
bdate = usr.pop("bdate", None)
usr["age"] = self.calculate_age(bdate) if bdate else None
city = usr.pop("city", None)
usr["city"] = city["title"] if city else None
counters = usr.pop("counters", None)
usr["friends"] = counters["friends"] if counters else None
return usr
@staticmethod
def calculate_age(bdate):
bdate_pattern = re.compile(r'\d+\.\d+\.\d{4}', re.DOTALL)
bdate_match = bdate_pattern.fullmatch(bdate)
if not bdate_match:
return None
today = date.today()
bdate = datetime.strptime(bdate_match.group(0), '%d.%m.%Y')
age = today.year - bdate.year
full_year_passed = (today.month, today.day) < (bdate.month, bdate.day)
if not full_year_passed:
age -= 1
return age
| [
"chatton1@mail.ru"
] | chatton1@mail.ru |
d7778577560f178d02fcd89e23d0592007c3a25a | 1a331a84be0b8b1de41ca6d455b1be2c59cb59f7 | /src/ui/ui.py | 80aae50ba2268ba138933f92d95a6eb963394bc0 | [] | no_license | katriryt/ot-harjoitustyo | 81b4189e2e1e03bd9f5b83c88821d568ca169d5e | ce2f3b1f34242009acebe43259eb38923bc91e0f | refs/heads/master | 2023-04-21T09:56:02.110399 | 2021-05-16T14:24:26 | 2021-05-16T14:24:26 | 349,752,793 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,165 | py | from tkinter import Frame, Button
from ui.openingview import OpeningView
from ui.introview import IntroView
from ui.optionsview import OptionsView
from ui.gameview import GameView
from ui.fonts import Fonts
class UI:
"""Purpose of the class is to set the common UI specifications
and elements across all of the views.
"""
def __init__(self, root, input_width, input_height):
"""Constructor for the class. Sets window given by the
index.py as the baseline view for the game.
"""
self._root = root
self.fonts = Fonts()
self._root_width = input_width
self._root_height = input_height
self._bottom_height = 50
self._current_view = None
def start(self):
"""Methods sets the common frames across all of the views, as well as
a common list of action buttons (e.g. start, exit) at the bottom of all the views.
"""
self._root.grid_rowconfigure(0, weight=1)
self._root.grid_columnconfigure(0, weight=1)
center_frame = Frame(
self._root,
width=self._root_width,
heigh=self._root_height - self._bottom_height,
)
bottom_frame = Frame(
self._root,
bg="black",
width=self._root_width,
height=self._bottom_height,
)
center_frame.grid(
row=0,
column=0,
sticky="nsew"
)
bottom_frame.grid(
row=1,
column=0,
sticky="nsew"
)
bottom_frame.grid_rowconfigure(1)
bottom_frame.grid_columnconfigure(
[0, 1, 2, 3, 4, 5, 6, 7], minsize=(self._root_width/8))
bottom_frame_headlines = ["Intro", "Options", "Start", "Exit"]
commands = [lambda: self._show_intro_view(center_frame),
lambda: self._show_options_view(center_frame),
lambda: self._show_game_view(center_frame),
self._quit]
for j in range(0, len(bottom_frame_headlines)):
button = Button(
bottom_frame,
text=bottom_frame_headlines[j],
compound="center",
width=12,
height=1,
background="red",
activebackground="red",
font=self.fonts.small_text_font,
command=commands[j]
)
button.grid(
row=0,
column=j,
padx=12,
pady=12
)
self._show_opening_view(center_frame)
def _show_opening_view(self, screen):
"""Method draws the opening view on the common frame.
Args:
screen (frame): Method is given a frame defined in the common UI.
"""
new_center_frame = Frame(
screen,
width=self._root_width,
heigh=self._root_height - self._bottom_height,
)
new_center_frame.grid(
row=0,
column=0,
sticky="nsew"
)
self._current_view = OpeningView(
new_center_frame
)
def _show_intro_view(self, screen):
"""Method draws the introduction view on the common frame.
Args:
screen (frame): Method is given a frame defined in the common UI.
"""
new_center_frame = Frame(
screen,
width=self._root_width,
heigh=self._root_height - self._bottom_height,
)
new_center_frame.grid(
row=0,
column=0,
sticky="nsew"
)
self._current_view = IntroView(
new_center_frame
)
def _show_options_view(self, screen):
"""Method draws the options view on the common frame.
Args:
screen (frame): Method is given a frame defined in the common UI.
"""
new_center_frame = Frame(
screen,
width=self._root_width,
heigh=self._root_height - self._bottom_height,
)
new_center_frame.grid(
row=0,
column=0,
sticky="nsew"
)
self._current_view = OptionsView(
new_center_frame
)
def _show_game_view(self, screen):
"""Method draws the games view on the common frame.
Args:
screen (frame): Method is given a frame defined in the common UI.
"""
new_center_frame = Frame(
screen,
width=self._root_width,
heigh=self._root_height - self._bottom_height,
)
new_center_frame.grid(
row=0,
column=0,
sticky="nsew"
)
self._current_view = GameView(
new_center_frame
)
def _hide_current_view(self):
"""Method hides the currently active view.
"""
if self._current_view:
self._current_view.destroy()
self._current_view = None
def _quit(self):
"""Method exits the game.
"""
self._root.destroy()
| [
"katri.rytkonen@outlook.com"
] | katri.rytkonen@outlook.com |
3e26b4b260a638dd7558ed7c203aa85025ec94fa | ef98efab177e1c3febb81505081ebf24dfa8d2e2 | /miUniversidad/asgi.py | 58f9ce0b99df2019f0ee62d2d666f279e2295210 | [] | no_license | dfgarciac1/miUniversidad | 44c4ae6f28c434475e7efa34e68c3b1891139689 | 3a77a24c45f31d328123b9297798b3acccf386e3 | refs/heads/master | 2023-08-26T09:08:39.297136 | 2021-10-21T16:45:21 | 2021-10-21T16:45:21 | 419,800,363 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 403 | py | """
ASGI config for miUniversidad project.
It exposes the ASGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/howto/deployment/asgi/
"""
import os
from django.core.asgi import get_asgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'miUniversidad.settings')
application = get_asgi_application()
| [
"david.garcia@jikkosoft.com"
] | david.garcia@jikkosoft.com |
9c263e0f31066de90cfb7168e44d3f1faaff0d99 | a3d6556180e74af7b555f8d47d3fea55b94bcbda | /ios/chrome/browser/flags/DEPS | 458d0f02f4f533615b90bc6bce32a1ece69f84f1 | [
"BSD-3-Clause"
] | permissive | chromium/chromium | aaa9eda10115b50b0616d2f1aed5ef35d1d779d6 | a401d6cf4f7bf0e2d2e964c512ebb923c3d8832c | refs/heads/main | 2023-08-24T00:35:12.585945 | 2023-08-23T22:01:11 | 2023-08-23T22:01:11 | 120,360,765 | 17,408 | 7,102 | BSD-3-Clause | 2023-09-10T23:44:27 | 2018-02-05T20:55:32 | null | UTF-8 | Python | false | false | 405 | specific_include_rules = {
# Flag list can depends on everything.
"^about_flags.mm": [
"+ios/chrome/browser",
],
"^ios_chrome_field_trials.mm": [
"+ios/chrome/browser/variations",
"+ios/chrome/browser/ui/content_suggestions",
"+ios/chrome/browser/ui/first_run",
"+ios/chrome/browser/ui/ntp",
],
"^system_flags.mm": [
"+ios/chrome/browser/ui/ui_feature_flags.h",
]
}
| [
"chromium-scoped@luci-project-accounts.iam.gserviceaccount.com"
] | chromium-scoped@luci-project-accounts.iam.gserviceaccount.com | |
08b1e2ddf2cb6a083fbc4f909b9ea14d66e2f0d4 | 4741d475262349f97a1625365cce61381f36acca | /ex47/setup.py | 4ff3c5b3209a7b39c50361eb032651b801c474b3 | [] | no_license | superjoefly/LearningPythonTheHardWay | be27c6bf7e1aa5fc0a5a9071e728a1a890534ba8 | 471be14f24362eddbdc66e901206ae5ace1f3ca1 | refs/heads/master | 2021-09-13T22:25:27.559748 | 2018-05-05T04:53:00 | 2018-05-05T04:53:00 | 115,237,805 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 400 | py | try:
from setuptools import setup
except ImportError:
from distutils.core import setup
config = [
'description': 'LPHW Exercise 47',
'author': 'JoeFly',
'url': 'none',
'download_url': 'none',
'author_email': 'newitup@gmail.com',
'version': '0.0.1',
'install_requires': ['nose'],
'packages': ['ex47'],
'scripts': [],
'name': 'ex47'
]
setup(**config)
| [
"superjoefly@gmail.com"
] | superjoefly@gmail.com |
8b2ef72a5d7eeff4a09b6ce6de12106fb39aafa9 | bbdc3830d5da1eb419895d538615ca2f748e6ede | /MinimumFallingPathSum.py | 4653768ee29a690a628c7f5672401da0d7df22e7 | [] | no_license | TanvirKaur17/DP-3 | 6740b9ceab49d50e46730e1e940879c9cb5f745a | ed7f692993b7246038aec8aa13079145369800fc | refs/heads/master | 2020-09-22T04:31:01.699488 | 2019-11-30T17:55:35 | 2019-11-30T17:55:35 | 225,049,777 | 0 | 0 | null | 2019-11-30T17:54:50 | 2019-11-30T17:54:50 | null | UTF-8 | Python | false | false | 656 | py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Nov 30 09:20:42 2019
@author: tanvirkaur
"""
# time complexity = O(n*n)
# space complexity = O(1)
class Solution:
def minFallingPathSum(self, A: List[List[int]]) -> int:
for i in range(1,len(A)):
for j in range(len(A)):
if j == 0:
A[i][j] = A[i][j] + min(A[i-1][j],A[i-1][j+1])
elif j == len(A)-1:
A[i][j] = A[i][j] + min(A[i-1][j],A[i-1][j-1])
else:
A[i][j] = A[i][j] + min(A[i-1][j],A[i-1][j-1],A[i-1][j+1])
return min(A[-1])
| [
"noreply@github.com"
] | TanvirKaur17.noreply@github.com |
3bac6bd5636df3f744849c2d5a03cce9ae5bdea3 | c3a77008057a76befc05ec6ff03fa17f47ef1a7e | /blackjack.py | 65dfcb1c9c8fc978445d9f2e0c3516aca4769a54 | [] | no_license | rzuletav99/BlackjackApp | 763a2f7bf276cae58c84f0ab7c53aa3508f5a9a6 | fffaa60a6ba9a28d9609cf0326db2ba68c6ed4ca | refs/heads/master | 2021-03-24T13:42:12.151964 | 2017-08-11T02:32:23 | 2017-08-11T02:32:23 | 99,981,225 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,805 | py | import random
#
# Blackjack game
#
# From Tim Buchalka's Learn Python course
# Copyright (c) 2015-2016 Tim Buchalka
# Contact author at: http://timbuchalka.com
#
try:
import tkinter
except ImportError: # python 2
import Tkinter as tkinter
def load_images(card_images):
suits = ['heart', 'club', 'diamond', 'spade']
face_cards = ['jack', 'queen', 'king']
if tkinter.TkVersion >= 8.6:
extension = 'png'
else:
extension = 'ppm'
# for each suit, retrieve the image for the cards
for suit in suits:
# first the number cards 1 to 10
for card in range(1, 11):
name = 'cards/{}_{}.{}'.format(str(card), suit, extension)
image = tkinter.PhotoImage(file=name)
card_images.append((card, image,))
# next the face cards
for card in face_cards:
name = 'cards/{}_{}.{}'.format(str(card), suit, extension)
image = tkinter.PhotoImage(file=name)
card_images.append((10, image,))
def deal_card(frame):
# pop the next card off the top of the deck
next_card = deck.pop(0)
# and add it to back of the pack
deck.append(next_card)
# add the image to a Label and display the label
tkinter.Label(frame, image=next_card[1], relief='raised').pack(side='left')
# now return the card's face value
return next_card
def score_hand(hand):
# Calculate the total score of all cards in the list.
# Only one ace can have the value 11, and this will be reduce to 1 if the hand would bust.
score = 0
ace = False
for next_card in hand:
card_value = next_card[0]
if card_value == 1 and not ace:
ace = True
card_value = 11
score += card_value
# if we would bust, check if there is an ace and subtract 10
if score > 21 and ace:
score -= 10
ace = False
return score
def deal_dealer():
dealer_score = score_hand(dealer_hand)
while 0 < dealer_score < 17:
dealer_hand.append(deal_card(dealer_card_frame))
dealer_score = score_hand(dealer_hand)
dealer_score_label.set(dealer_score)
player_score = score_hand(player_hand)
if player_score > 21:
result_text.set("Dealer wins!")
elif dealer_score > 21 or dealer_score < player_score:
result_text.set("Player wins!")
elif dealer_score > player_score:
result_text.set("Dealer wins!")
else:
result_text.set("Draw!")
def deal_player():
player_hand.append(deal_card(player_card_frame))
player_score = score_hand(player_hand)
player_score_label.set(player_score)
if player_score > 21:
result_text.set("Dealer Wins!")
def new_game():
global dealer_card_frame
global player_card_frame
global dealer_hand
global player_hand
# embedded frame to hold the card images
dealer_card_frame.destroy()
dealer_card_frame = tkinter.Frame(card_frame, background='green')
dealer_card_frame.grid(row=0, column=1, sticky='ew', rowspan=2)
# embedded frame to hold the card images
player_card_frame = tkinter.Frame(card_frame, background="green")
player_card_frame.grid(row=2, column=1, sticky='ew', rowspan=2)
result_text.set("")
# Create the list to store the dealer's and player's hands
dealer_hand = []
player_hand = []
deal_player()
dealer_hand.append(deal_card(dealer_card_frame))
dealer_score_label.set(score_hand(dealer_hand))
deal_player()
def shuffle():
random.shuffle(deck)
def tim():
print("Timoteo dice Hola")
mainWindow = tkinter.Tk()
# Set up the screen and frames for the dealer and player
mainWindow.title("Black Jack")
mainWindow.geometry("640x480")
mainWindow.configure(background='green')
result_text = tkinter.StringVar()
result = tkinter.Label(mainWindow, textvariable=result_text)
result.grid(row=0, column=0, columnspan=3)
card_frame = tkinter.Frame(mainWindow, relief="sunken", borderwidth=1, background="green")
card_frame.grid(row=1, column=0, sticky='ew', columnspan=3, rowspan=2)
dealer_score_label = tkinter.IntVar()
tkinter.Label(card_frame, text="Dealer", background="green", fg='white').grid(row=0, column=0)
tkinter.Label(card_frame, textvariable=dealer_score_label, background="green", fg="white").grid(row=1, column=0)
# embedded frame to hold the card images
dealer_card_frame = tkinter.Frame(card_frame, background="green")
dealer_card_frame.grid(row=0, column=1, sticky="ew", rowspan=2)
player_score_label = tkinter.IntVar()
tkinter.Label(card_frame, text="Player", background="green", fg="white").grid(row=2, column=0)
tkinter.Label(card_frame, textvariable=player_score_label, background="green", fg="white").grid(row=3, column=0)
# embedded frame to hold the card images
player_card_frame = tkinter.Frame(card_frame, background="green")
player_card_frame.grid(row=2, column=1, sticky='ew', rowspan=2)
button_frame = tkinter.Frame(mainWindow)
button_frame.grid(row=3, column=0, columnspan=3, sticky='w')
dealer_button = tkinter.Button(button_frame, text="Dealer", command=deal_dealer)
dealer_button.grid(row=0, column=0)
player_button = tkinter.Button(button_frame, text="Player", command=deal_player)
player_button.grid(row=0, column=1)
new_game_button = tkinter.Button(button_frame, text="New Game", command=new_game)
new_game_button.grid(row=0, column=2)
shuffle_button = tkinter.Button(button_frame, text="Shuffle", command=shuffle)
shuffle_button.grid(row=0, column=3)
# load cards
cards = []
load_images(cards)
print(cards)
# Create a new deck of cards and shuffle them
deck = list(cards) + list(cards) + list(cards)
shuffle()
# Create the list to store the dealer's and player's hands
dealer_hand = []
player_hand = []
new_game()
mainWindow.mainloop()
| [
"rzuletav99@outlook.com"
] | rzuletav99@outlook.com |
202bd74519110da4032c6492c70dc9da7cc90c4a | 269a5fe2e0c0c66d570939db9347e59c3a70d2d7 | /itest/model/m_mark_field.py | 4338408b5f5a9f0ac60aede141cc1801cee0913e | [] | no_license | hamliy/itest-server | 2f6c2102541062c00eb3c5f2635ec96b434562cf | f3d75e969e8b1c7e177217a3b7ff2ec5045918ac | refs/heads/master | 2020-04-02T09:11:38.405021 | 2019-03-01T09:00:10 | 2019-03-01T09:00:10 | 154,120,654 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,471 | py | # encoding: utf-8
"""
@author: han.li
@file : m_mark_field.py
@time : 11/5/18 10:58 AM
@dec : 数据标签字段类
"""
from datetime import datetime
from mongoengine import Document, EmbeddedDocument
from mongoengine.fields import (
DateTimeField, EmbeddedDocumentField, FloatField, IntField, DictField,
ListField, ReferenceField, StringField, ObjectIdField, BooleanField
)
from .m_project import Project
class MarkFieldItem(EmbeddedDocument):
"""打标字段定义项"""
name = StringField() # 标签字段名
itemType = IntField(default=0) # 数据类型 0 字符串 1 数字 2 list
desc = StringField() # 描述
class MarkField(Document):
"""打标字段定义数据"""
meta = {'collection': 'mark_field'}
projectId = ReferenceField(Project)
name = StringField(required=True) # 标签定义名
fieldType = IntField(required=True, default=0) # 标签类型 0 文本 1 位置 2 文本+位置
fieldItems = ListField(EmbeddedDocumentField(MarkFieldItem), default=[]) # 标签字段定义
createTime = DateTimeField(default=datetime.utcnow()) # 创建时间
modifiedTime = DateTimeField(default=datetime.utcnow()) # 更新时间
isDeleted = BooleanField(default=False) # 是否删除
desc = StringField(default="") # 描述
| [
"gb2012@163.com"
] | gb2012@163.com |
4f8dbd2f12caf526c40c7d0a5d346279fdd57c1f | fc89c8e45f5eca4a5cd51b3c100dd11464abbdb7 | /hempioclub/blueprints/user/validations.py | 97a84d3f35d8b51f5b14f8c32ab8223ef99060e9 | [] | no_license | Laddergrowth/hempiocoins | bd23fcb1f9572de9dabc39812d2eb2c49071a2f3 | 3810e8cab3a0e3671b880631ad86fa6477325966 | refs/heads/master | 2023-02-17T20:20:12.300228 | 2021-01-19T18:59:14 | 2021-01-19T18:59:14 | 331,045,281 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 846 | py | from wtforms.validators import ValidationError
from hempioclub.blueprints.user.models import User
def ensure_identity_exists(form, field):
"""
Ensure an identity exists.
:param form: wtforms Instance
:param field: Field being passed in
:return: None
"""
user = User.find_by_identity(field.data)
if not user:
raise ValidationError('Unable to locate account.')
def ensure_existing_password_matches(form, field):
"""
Ensure that the current password matches their existing password.
:param form: wtforms Instance
:param field: Field being passed in
:return: None
"""
user = User.query.get(form._obj.id)
print(user)
print(user.authenticated(password=field.data))
if not user.authenticated(password=field.data):
raise ValidationError('Does not match.')
| [
"info.mildp@gmail.com"
] | info.mildp@gmail.com |
865e42f9823db183fe0a661b7ee6ecce678f9a25 | ae411ea0e0c373d18681d707800995264379be25 | /mic.py | df6a5aaf7b2e2a2e146caccea681f70963c889f7 | [] | no_license | Symfomany/tensor | 22ad4b0710d705d1ec47e3512431c2ca74ca3948 | 2b8471f7aab6a7a234bd89942118bbadf4058352 | refs/heads/master | 2022-12-21T14:53:03.349221 | 2019-02-21T10:39:31 | 2019-02-21T10:39:31 | 171,100,643 | 0 | 0 | null | 2022-12-09T13:17:30 | 2019-02-17T08:51:46 | Jupyter Notebook | UTF-8 | Python | false | false | 4,912 | py | #!/usr/bin/env python
import pyaudio
import struct
import math
import time,sys
import threading
INITIAL_TAP_THRESHOLD = 0.010
FORMAT = pyaudio.paInt16
SHORT_NORMALIZE = (1.0/32768.0)
CHANNELS = 1
RATE = 16000
INPUT_BLOCK_TIME = 0.05
INPUT_FRAMES_PER_BLOCK = int(RATE*INPUT_BLOCK_TIME)
OVERSENSITIVE = 15.0/INPUT_BLOCK_TIME
UNDERSENSITIVE = 120.0/INPUT_BLOCK_TIME # if we get this many quiet blocks in a row, decrease the threshold
MAX_TAP_BLOCKS = 0.15/INPUT_BLOCK_TIME # if the noise was longer than this many blocks, it's not a 'tap'
def get_rms(block):
# L’amplitude d’un son est la caractéristique la plus simple que l’on puisse imaginer.
# Elle caractérise directement l’intensité du son c’est à dire son volume, ou encore la force avec laquelle elle excite l’oreille de l’auditeur. S
# Le son qui engendre une vibration d’un corps physique,
# crée des variations de pression qui exercent une force sur les autres corps physiques en contact avec l’air (l’air étant un milieu dit « élastique »).
# Cette force n’étant pas constante (si elle l’est, il n’y a pas de son) le corps en question ne bouge pas mais vibre (si tant est qu’il ne soit pas trop rigide).
# L’amplitude d’un signal est sa valeur maximale.
# Ici l’amplitude du signal qui varie entre la valeur +max et -max est +max.
# En somme, le maximum réel de la fonction sur un intervalle de temps donné.
# Dans le cas d’un signal sinusoïdal (tel que celui ci-dessus) on peut exprimer simplement la valeur efficace du signal par la formule suivante :
# En fait, la valeur efficace, qui est très utilisée (parce que renvoyée par les instruments de mesures :
# un voltmètre par exemple) est la valeur quadratique moyenne.
# Par exemple si la valeur du signal en fonction du temps est donnée par la fonction Y(t)
# on a la formule générale suivante qui donne la valeur efficace du signal sur un intervalle de temps donné :
# Valeur max et valeur efficace sont à mettre en relation avec ce que l’on appelle
# les puissances max et les puissances efficaces.
# Par exemple un amplificateur de puissance 100 W efficace (ou RMS) fournit une puissance crête (max) de 200W voire 400W sur des impulsions très brèves (s’il ne grille pas avant).
# Cette puissance impulsionnelle qui ne veut pas dire grand chose est parfois indiquée comme étant la puissance Musicale de l’amplificateur.
# RMS amplitude is defined as the square root of the
# mean over time of the square of the amplitude.
# so we need to convert this string of bytes into
# a string of 16-bit samples...
# we will get one short out for each
# two chars in the string.
count = len(block)/2
format = "%dh"%(count)
shorts = struct.unpack( format, block )
# iterate over the block.
sum_squares = 0.0
for sample in shorts:
# sample is a signed short in +/- 32768.
# normalize it to 1.0
n = sample * SHORT_NORMALIZE
sum_squares += n*n
return math.sqrt( sum_squares / count )
pa = pyaudio.PyAudio() #]
#|
stream = pa.open(format = FORMAT, #|
channels = CHANNELS, #|---- You always use this in pyaudio...
rate = RATE, #|
input = True, #|
frames_per_buffer = INPUT_FRAMES_PER_BLOCK) #]
tap_threshold = INITIAL_TAP_THRESHOLD #]
noisycount = MAX_TAP_BLOCKS+1 #|---- Variables for noise detector...
quietcount = 0 #|
errorcount = 0 #]
for i in range(1000):
try: #]
block = stream.read(INPUT_FRAMES_PER_BLOCK) #|
except (IOError,e): #|---- just in case there is an error!
errorcount += 1 #|
print( "(%d) Error recording: %s"%(errorcount,e) ) #|
noisycount = 1 #]
amplitude = get_rms(block) # Root mean Square va permettre de calculer l'amplitude d'un son en streaming
print(amplitude)
if amplitude > tap_threshold: # if its to loud... bruyant
quietcount = 0
noisycount += 1
if noisycount > OVERSENSITIVE:
tap_threshold *= 1.1 # turn down the sensitivity
else: # if its to quiet...
if 1 <= noisycount <= MAX_TAP_BLOCKS:
print('tap!')
noisycount = 0
quietcount += 1
if quietcount > UNDERSENSITIVE:
tap_threshold *= 0.9 # turn up the sensitivity
| [
"you@example.com"
] | you@example.com |
0c08e7fdf1486234f4334d1752b83f9f1d2e5000 | 21f9b641237cb6358667aecf1305163a61722278 | /model/dataloader/samplers.py | 3ebff6aeec0909ee3e5f1138e9907eb259dd0844 | [
"MIT"
] | permissive | Blair129/FEAT-master | 153d57aad653fd27f5a21330dbb4f83a33ccd5b2 | 459e05000a8cca5421fafb7d2f33f19418378df7 | refs/heads/master | 2023-06-15T14:42:46.370304 | 2021-07-10T15:34:29 | 2021-07-10T15:34:29 | 384,730,337 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,656 | py | import torch
import numpy as np
class CategoriesSampler():
def __init__(self, label, n_batch, n_cls, n_per):
self.n_batch = n_batch
self.n_cls = n_cls
self.n_per = n_per
label = np.array(label)
print("label"+str(label))
self.m_ind = []
for i in range(max(label) + 1):
ind = np.argwhere(label == i).reshape(-1)
print("ind" + str(ind))
ind = torch.from_numpy(ind)
self.m_ind.append(ind)
def __len__(self):
return self.n_batch
def __iter__(self):
for i_batch in range(self.n_batch):
batch = []
classes = torch.randperm(len(self.m_ind))[:self.n_cls]
for c in classes:
l = self.m_ind[c]
pos = torch.randperm(len(l))[:self.n_per]
batch.append(l[pos])
batch = torch.stack(batch).t().reshape(-1)
yield batch
class RandomSampler():
def __init__(self, label, n_batch, n_per):
self.n_batch = n_batch
self.n_per = n_per
self.label = np.array(label)
self.num_label = self.label.shape[0]
def __len__(self):
return self.n_batch
def __iter__(self):
for i_batch in range(self.n_batch):
batch = torch.randperm(self.num_label)[:self.n_per]
yield batch
# sample for each class
class ClassSampler():
def __init__(self, label, n_per=None):
self.n_per = n_per
label = np.array(label)
self.m_ind = []
for i in range(max(label) + 1):
ind = np.argwhere(label == i).reshape(-1)
ind = torch.from_numpy(ind)
self.m_ind.append(ind)
def __len__(self):
return len(self.m_ind)
def __iter__(self):
classes = torch.arange(len(self.m_ind))
for c in classes:
l = self.m_ind[int(c)]
if self.n_per is None:
pos = torch.randperm(len(l))
else:
pos = torch.randperm(len(l))[:self.n_per]
yield l[pos]
# for ResNet Fine-Tune, which output the same index of task examples several times
class InSetSampler():
def __init__(self, n_batch, n_sbatch, pool): # pool is a tensor
self.n_batch = n_batch
self.n_sbatch = n_sbatch
self.pool = pool
self.pool_size = pool.shape[0]
def __len__(self):
return self.n_batch
def __iter__(self):
for i_batch in range(self.n_batch):
batch = self.pool[torch.randperm(self.pool_size)[:self.n_sbatch]]
yield batch | [
"44133060+Blair129@users.noreply.github.com"
] | 44133060+Blair129@users.noreply.github.com |
be4d49ba596bf4518c682db0e41043d4170af6a6 | 2a89c59d893bd920df1f4e1c117e0a1387296c78 | /pro2_con_stfs.py | 94ba8f437b97e28b86185caefae8701c85a5c442 | [] | no_license | wew053/Array_codes | bedc103c86419176f4b90efc46da05bb455279f4 | 6090d7dac7074abb91d8278b1ff9e708a17d8337 | refs/heads/master | 2022-04-13T19:09:47.524889 | 2020-03-31T15:23:15 | 2020-03-31T15:23:15 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,694 | py | #!/usr/bin/env python
# this program convolves a time function with an mseed file
# John Vidale 6/2019
def pro2_convstf(eq_file, conv_file):
from obspy import UTCDateTime
from obspy import Stream, Trace
from obspy import read
# from obspy.signal import correlate_template
import os
import time
import numpy as np
import sys # don't show any warnings
import warnings
if not sys.warnoptions:
warnings.simplefilter('ignore')
print('Running pro2_con_stfs')
start_time_wc = time.time()
#%%
taper_frac = .05 #Fraction of window tapered on both ends
# conv_file = 'HD1971-11-06_stf'
#%% input event data with 1-line file of format
# event 2016-05-28T09:47:00.000 -56.241 -26.935 78
file = open('EvLocs/' + eq_file, 'r')
lines=file.readlines()
split_line = lines[0].split()
# ids.append(split_line[0]) ignore label for now
t = UTCDateTime(split_line[1])
date_label = split_line[1][0:10]
print('date_label ' + date_label + ' time ' + str(t))
#%% Load waveforms and convolution trace
st = Stream()
con_trace = Stream()
st_out = Stream()
tr = Trace()
fname_sel = 'Pro_Files/HD' + date_label + 'sel.mseed'
st = read(fname_sel)
fname = conv_file
con_trace = read(fname)
con_trace.taper(0.5) # added June 10, 2019 to shorten stf
nt = len(st[0].data)
dt = st[0].stats.delta
print('Read in:\n' + str(len(st)) + ' traces' + ' from file ' + fname +
', ' + str(nt) + ' time pts, time sampling of '
+ str(dt) + ' and thus duration of ' + str((nt-1)*dt))
#%% detrend, taper, decimate
st.detrend(type='simple')
st.taper(taper_frac)
# st3 = Stream()
# st3 = correlate_template(st, con_trace, normalize='none')
done = 0
for tr in st: # traces one by one, find lat-lon by searching entire inventory. Inefficient but cheap
# print('con_trace data has length ' + str(len(con_trace[0].data)))
# print('Tr data has length ' + str(len(tr.data)) + ' con_trace data has length ' + str(len(con_trace[0].data)))
tr.data = np.convolve(tr.data, con_trace[0].data)
# print('Now, Tr data has length ' + str(len(tr.data)))
st_out += tr
done += 1
if done%50 == 0:
print('Done stacking ' + str(done) + ' out of ' + str(len(st)) + ' stations.')
nt = len(st_out[0].data)
dt = st_out[0].stats.delta
print('After decimation:\n' + str(len(st_out)) + ' traces written to file ' + fname_sel +
', ' + str(nt) + ' time pts, time sampling of '
+ str(dt) + ' and thus duration of ' + str((nt-1)*dt))
# Save processed files
st_out.write(fname_sel,format = 'MSEED')
elapsed_time_wc = time.time() - start_time_wc
print('This job took ' + str(elapsed_time_wc) + ' seconds')
os.system('say "Done"') | [
"seismoguy@mac.com"
] | seismoguy@mac.com |
2975fada24e5de6073f3665b576d5bfed9ad8568 | 17c280ade4159d4d8d5a48d16ba3989470eb3f46 | /16/data/ExoDiBosonResonances/EDBRTreeMaker/test/7.py | 78cf2c490288af70a24998316d1b5ba736dd0d07 | [] | no_license | chengchen1993/run2_ntuple | 798ff18489ff5185dadf3d1456a4462e1dbff429 | c16c2b203c05a3eb77c769f63a0bcdf8b583708d | refs/heads/master | 2021-06-25T18:27:08.534795 | 2021-03-15T06:08:01 | 2021-03-15T06:08:01 | 212,079,804 | 0 | 2 | null | null | null | null | UTF-8 | Python | false | false | 27,621 | py | import FWCore.ParameterSet.Config as cms
process = cms.Process( "TEST" )
#process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(True))
process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(True),allowUnscheduled=cms.untracked.bool(True))
#,
# SkipEvent = cms.untracked.vstring('ProductNotFound'))
filterMode = False # True
######## Sequence settings ##########
corrJetsOnTheFly = True
runOnMC = False
runOnSig = False
DOHLTFILTERS = True
#useJSON = not (runOnMC)
#JSONfile = 'Cert_246908-258750_13TeV_PromptReco_Collisions15_25ns_JSON.txt'
#****************************************************************************************************#
#process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_cff')
process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_condDBv2_cff')
from Configuration.AlCa.GlobalTag import GlobalTag
if runOnMC:
process.GlobalTag.globaltag = '80X_mcRun2_asymptotic_2016_TrancheIV_v8'#'MCRUN2_74_V9::All'
#process.GlobalTag.globaltag = '94X_mc2017_realistic_v14'#'MCRUN2_74_V9::All'
elif not(runOnMC):
process.GlobalTag.globaltag = '80X_dataRun2_2016SeptRepro_v7'
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMiniAOD2015#ETmiss_filters
# For the RunIISummer15DR74 MC campaing, the process name in PAT.
# For Run2015B PromptReco Data, the process name is RECO.
# For Run2015B re-MiniAOD Data 17Jul2015, the process name is PAT.
hltFiltersProcessName = 'RECO'
if runOnMC:
hltFiltersProcessName = 'PAT' #'RECO'
#if DOHLTFILTERS and not(runOnMC):
process.load('CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi')
process.HBHENoiseFilterResultProducer.minZeros = cms.int32(99999)
process.HBHENoiseFilterResultProducer.IgnoreTS4TS5ifJetInLowBVRegion=cms.bool(False)
process.HBHENoiseFilterResultProducer.defaultDecision = cms.string("HBHENoiseFilterResultRun2Loose")
process.ApplyBaselineHBHENoiseFilter = cms.EDFilter('BooleanFlagFilter',
inputLabel = cms.InputTag('HBHENoiseFilterResultProducer','HBHENoiseFilterResult'),
reverseDecision = cms.bool(False)
)
process.ApplyBaselineHBHEIsoNoiseFilter = cms.EDFilter('BooleanFlagFilter',
inputLabel = cms.InputTag('HBHENoiseFilterResultProducer','HBHEIsoNoiseFilterResult'),
reverseDecision = cms.bool(False)
)
######### read JSON file for data ##########
'''if not(runOnMC) and useJSON:
import FWCore.PythonUtilities.LumiList as LumiList
import FWCore.ParameterSet.Types as CfgTypes
process.source.lumisToProcess = CfgTypes.untracked(CfgTypes.VLuminosityBlockRange())
myLumis = LumiList.LumiList(filename = JSONfile).getCMSSWString().split(',')
process.source.lumisToProcess.extend(myLumis)
'''
# ---------------------------------------------------------
# DeepAK8: set up TransientTrackBuilder
process.load('Configuration.StandardSequences.MagneticField_cff')
process.TransientTrackBuilderESProducer = cms.ESProducer("TransientTrackBuilderESProducer",
ComponentName=cms.string('TransientTrackBuilder')
)
# ---------------------------------------------------------
####### Redo Jet clustering sequence ##########
from RecoJets.Configuration.RecoPFJets_cff import ak4PFJetsCHS, ak8PFJetsCHS, ak8PFJetsCHSPruned, ak8PFJetsCHSSoftDrop, ak8PFJetsCHSPrunedMass, ak8PFJetsCHSSoftDropMass# , ak8PFJetsCSTrimmed, ak8PFJetsCSFiltered, ak8PFJetsCHSFilteredMass, ak8PFJetsCHSTrimmedMass
from CommonTools.PileupAlgos.Puppi_cff import puppi
process.puppi = puppi.clone()
process.puppi.useExistingWeights = True
process.puppi.candName = cms.InputTag('packedPFCandidates')
process.puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
process.ak8PFJetsCHS = ak8PFJetsCHS.clone( src = 'puppi', jetPtMin = 100.0 )
process.ak8PFJetsCHSPruned = ak8PFJetsCHSPruned.clone( src = 'puppi', jetPtMin = 100.0 )
process.ak8PFJetsCHSPrunedMass = ak8PFJetsCHSPrunedMass.clone()
process.ak8PFJetsCHSSoftDrop = ak8PFJetsCHSSoftDrop.clone( src = 'puppi', jetPtMin = 100.0 )
process.ak8PFJetsCHSSoftDropMass = ak8PFJetsCHSSoftDropMass.clone()
process.NjettinessAK8 = cms.EDProducer("NjettinessAdder",
src = cms.InputTag("ak8PFJetsCHS"),
Njets = cms.vuint32(1, 2, 3, 4),
# variables for measure definition :
measureDefinition = cms.uint32( 0 ), # CMS default is normalized measure
beta = cms.double(1.0), # CMS default is 1
R0 = cms.double( 0.8 ), # CMS default is jet cone size
Rcutoff = cms.double( 999.0), # not used by default
# variables for axes definition :
axesDefinition = cms.uint32( 6 ), # CMS default is 1-pass KT axes
nPass = cms.int32(0), # not used by default
akAxesR0 = cms.double(-999.0) # not used by default
)
process.substructureSequence = cms.Sequence()
process.substructureSequence+=process.puppi
process.substructureSequence+=process.ak8PFJetsCHS
process.substructureSequence+=process.NjettinessAK8
process.substructureSequence+=process.ak8PFJetsCHSPruned
process.substructureSequence+=process.ak8PFJetsCHSPrunedMass
process.substructureSequence+=process.ak8PFJetsCHSSoftDrop
process.substructureSequence+=process.ak8PFJetsCHSSoftDropMass
####### Redo pat jets sequence ##########
process.redoPatJets = cms.Sequence()
process.redoPrunedPatJets = cms.Sequence()
process.redoSoftDropPatJets = cms.Sequence()
from ExoDiBosonResonances.EDBRJets.redoPatJets_cff import patJetCorrFactorsAK8, patJetsAK8, selectedPatJetsAK8
# Redo pat jets from ak8PFJetsCHS
process.patJetCorrFactorsAK8 = patJetCorrFactorsAK8.clone( src = 'ak8PFJetsCHS' )
process.patJetsAK8 = patJetsAK8.clone( jetSource = 'ak8PFJetsCHS' )
process.patJetsAK8.userData.userFloats.src = [ cms.InputTag("ak8PFJetsCHSPrunedMass"), cms.InputTag("ak8PFJetsCHSSoftDropMass"), cms.InputTag("NjettinessAK8:tau1"), cms.InputTag("NjettinessAK8:tau2"), cms.InputTag("NjettinessAK8:tau3"), cms.InputTag("NjettinessAK8:tau4")]
process.patJetsAK8.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("patJetCorrFactorsAK8") )
process.selectedPatJetsAK8 = selectedPatJetsAK8.clone( cut = cms.string('pt > 100') )
process.redoPatJets+=process.patJetCorrFactorsAK8
process.redoPatJets+=process.patJetsAK8
process.redoPatJets+=process.selectedPatJetsAK8
# Redo pat jets ak8PFJetsCHSPruned
process.patJetCorrFactorsAK8Pruned = patJetCorrFactorsAK8.clone( src = 'ak8PFJetsCHSPruned' )
process.patJetsAK8Pruned = patJetsAK8.clone( jetSource = 'ak8PFJetsCHSPruned' )
process.patJetsAK8Pruned.userData.userFloats.src = [ "" ]
#process.patJetsAK8Pruned.userData.userFloats =cms.PSet(src = cms.VInputTag(""))
process.patJetsAK8Pruned.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("patJetCorrFactorsAK8Pruned") )
process.selectedPatJetsAK8Pruned = selectedPatJetsAK8.clone(cut = 'pt > 100', src = "patJetsAK8Pruned")
process.redoPrunedPatJets+=process.patJetCorrFactorsAK8Pruned
process.redoPrunedPatJets+=process.patJetsAK8Pruned
process.redoPrunedPatJets+=process.selectedPatJetsAK8Pruned
# Redo pat jets ak8PFJetsCHSSoftDrop
process.patJetCorrFactorsAK8Softdrop = patJetCorrFactorsAK8.clone( src = 'ak8PFJetsCHSSoftDrop' )
process.patJetsAK8Softdrop = patJetsAK8.clone( jetSource = 'ak8PFJetsCHSSoftDrop' )
process.patJetsAK8Softdrop.userData.userFloats.src = [ "" ]
#process.patJetsAK8Softdrop.userData.userFloats =cms.PSet(src = cms.VInputTag(""))
process.patJetsAK8Softdrop.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("patJetCorrFactorsAK8Softdrop") )
process.selectedPatJetsAK8Softdrop = selectedPatJetsAK8.clone(cut = 'pt > 100', src = "patJetsAK8Softdrop")
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
## PATify soft drop subjets
addJetCollection(
process,
labelName = 'AK8SoftDropSubjets',
jetSource = cms.InputTag('ak8PFJetsCHSSoftDrop','SubJets'),
algo = 'ak', # needed for subjet flavor clustering
rParam = 0.8, # needed for subjet flavor clustering
getJetMCFlavour = False,
pvSource = cms.InputTag( 'offlineSlimmedPrimaryVertices' ),
genJetCollection = cms.InputTag('slimmedGenJets'),
genParticles = cms.InputTag( 'prunedGenParticles' ),
btagDiscriminators = ['None'],
jetCorrections = ('AK4PFPuppi', ['L2Relative', 'L3Absolute'], 'None'),
# explicitJTA = True, # needed for subjet b tagging
# svClustering = True, # needed for subjet b tagging
# fatJets=cms.InputTag('ak8PFJetsCHS'), # needed for subjet flavor clustering
# groomedFatJets=cms.InputTag('ak8PFJetsCHSSoftDrop') # needed for subjet flavor clustering
)
#'''
#from RecoBTag.DeepFlavour.DeepFlavourJetTagsProducer_cfi import *
# this loads all available b-taggers
#process.load("RecoBTag.Configuration.RecoBTag_cff")
#process.load("RecoBTag.DeepFlavour.DeepFlavourJetTagsProducer_cfi")
#process.load("RecoBTag.DeepFlavour.deepFlavour_cff")
#'''
from RecoBTag.Configuration.RecoBTag_EventContent_cff import *
from RecoBTag.Configuration.RecoBTag_cff import *
from RecoBTag.DeepFlavour.DeepFlavourJetTagsProducer_cfi import deepFlavourJetTags
from RecoBTag.DeepFlavour.deepFlavour_cff import *
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
labelName = 'DeepFlavour',
jetSource = cms.InputTag('cleanPuppiAK4'),
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'),
svSource = cms.InputTag('slimmedSecondaryVertices'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
btagDiscriminators = ['deepFlavourJetTags:probb', 'deepFlavourJetTags:probbb','deepFlavourJetTags:probc','deepFlavourJetTags:probudsg','deepFlavourJetTags:probcc'],
postfix='NewDFTraining'
)
#process.selectedUpdatedPatJetsDeepFlavourNewDFTraining.userData.userFloats.src =[]
#'''
'''
process.patjets = cms.EDAnalyzer('EDBRTreeMaker',
PatJets = cms.InputTag("selectedUpdatedPatJets"),
PTMin = cms.double(-1),
BTag = cms.string("deepFlavourJetTags:probb"),
)
'''
process.selectedPatJetsAK8SoftDropPacked = cms.EDProducer("BoostedJetMerger",
jetSrc = cms.InputTag("selectedPatJetsAK8Softdrop"),
subjetSrc = cms.InputTag("selectedPatJetsAK8SoftDropSubjets")
)
process.redoSoftDropPatJets+=process.patJetCorrFactorsAK8Softdrop
process.redoSoftDropPatJets+=process.patJetsAK8Softdrop
process.redoSoftDropPatJets+=process.selectedPatJetsAK8Softdrop
option = 'RECO'
process.load("ExoDiBosonResonances.EDBRCommon.goodMuons_cff")
process.load("ExoDiBosonResonances.EDBRCommon.goodElectrons_cff")
process.load("ExoDiBosonResonances.EDBRCommon.goodJets_cff")
process.load("ExoDiBosonResonances.EDBRCommon.leptonicW_cff")
process.load("ExoDiBosonResonances.EDBRCommon.hadronicW_cff")
process.load("ExoDiBosonResonances.EDBRCommon.goodPuppi_cff")
if option == 'RECO':
process.goodMuons.src = "slimmedMuons"
process.goodElectrons.src = "slimmedElectrons"
process.goodJets.src = "slimmedJetsAK8"
# process.goodJets.src = "selectedPatJetsAK8"
process.Wtoenu.MET = "slimmedMETs"
process.Wtomunu.MET = "slimmedMETs"
process.goodPuppi.src = "selectedPatJetsAK8"
process.goodOfflinePrimaryVertex = cms.EDFilter("VertexSelector",
src = cms.InputTag("offlineSlimmedPrimaryVertices"),
cut = cms.string("chi2!=0 && ndof >= 4.0 && abs(z) <= 24.0 && abs(position.Rho) <= 2.0"),
filter = cms.bool(True)
)
if option == 'RECO':
process.hadronicV.cut = ' '
if option == 'GEN':
process.hadronicV.cut = ' '
WBOSONCUT = "pt > 200.0"
process.leptonicVSelector = cms.EDFilter("CandViewSelector",
src = cms.InputTag("leptonicV"),
cut = cms.string( WBOSONCUT ),
filter = cms.bool(True)
)
process.leptonicVFilter = cms.EDFilter("CandViewCountFilter",
src = cms.InputTag("leptonicV"),
minNumber = cms.uint32(1),
filter = cms.bool(True)
)
process.hadronicVFilter = cms.EDFilter("CandViewCountFilter",
src = cms.InputTag("hadronicV"),
minNumber = cms.uint32(1),
filter = cms.bool(True)
)
process.graviton = cms.EDProducer("CandViewCombiner",
decay = cms.string("leptonicV hadronicV"),
checkCharge = cms.bool(False),
cut = cms.string("mass > 180"),
roles = cms.vstring('leptonicV', 'hadronicV'),
)
process.gravitonFilter = cms.EDFilter("CandViewCountFilter",
src = cms.InputTag("graviton"),
minNumber = cms.uint32(1),
filter = cms.bool(True)
)
from PhysicsTools.SelectorUtils.tools.vid_id_tools import *
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff']
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
process.leptonSequence = cms.Sequence(process.muSequence +
process.egmGsfElectronIDSequence*process.eleSequence +
process.leptonicVSequence +
process.leptonicVSelector +
process.leptonicVFilter )
process.jetSequence = cms.Sequence(process.substructureSequence +
process.redoPatJets +
process.redoPrunedPatJets+
process.redoSoftDropPatJets+
process.fatJetsSequence +
process.fatPuppiSequence+
process.hadronicV +
process.hadronicVFilter)
process.gravitonSequence = cms.Sequence(process.graviton +
process.gravitonFilter)
if filterMode == False:
process.goodOfflinePrimaryVertex.filter = False
process.Wtomunu.cut = ''
process.Wtoenu.cut = ''
process.leptonicVSelector.filter = False
process.leptonicVSelector.cut = ''
process.hadronicV.cut = ''
process.graviton.cut = ''
process.leptonicVFilter.minNumber = 0
process.hadronicVFilter.minNumber = 0
process.gravitonFilter.minNumber = 0
process.load('RecoMET.METFilters.BadPFMuonFilter_cfi')
process.load("RecoMET.METFilters.BadChargedCandidateFilter_cfi")
process.BadPFMuonFilter.muons = cms.InputTag("slimmedMuons")
process.BadPFMuonFilter.PFCandidates = cms.InputTag("packedPFCandidates")
process.BadChargedCandidateFilter.muons = cms.InputTag("slimmedMuons")
process.BadChargedCandidateFilter.PFCandidates = cms.InputTag("packedPFCandidates")
process.metfilterSequence = cms.Sequence(process.BadPFMuonFilter+process.BadChargedCandidateFilter)
######### JEC ########
METS = "slimmedMETs"
jetsAK8 = "slimmedJetsAK8"
jetsAK8pruned = "slimmedJetsAK8"
jetsAK8softdrop = "slimmedJetsAK8"
jetsAK8puppi = "cleanPuppi"
if runOnMC:
jecLevelsAK8chs = [
'Summer16_23Sep2016V3_MC_L1FastJet_AK8PFchs.txt',
'Summer16_23Sep2016V3_MC_L2Relative_AK8PFchs.txt',
'Summer16_23Sep2016V3_MC_L3Absolute_AK8PFchs.txt'
]
jecLevelsAK8chsGroomed = [
'Summer16_23Sep2016V3_MC_L2Relative_AK8PFchs.txt',
'Summer16_23Sep2016V3_MC_L3Absolute_AK8PFchs.txt'
]
jecLevelsAK8puppi = [
'Summer16_23Sep2016V3_MC_L1FastJet_AK8PFPuppi.txt',
'Summer16_23Sep2016V3_MC_L2Relative_AK8PFPuppi.txt',
'Summer16_23Sep2016V3_MC_L3Absolute_AK8PFPuppi.txt'
]
jecLevelsAK8puppiGroomed = [
'Summer16_23Sep2016V3_MC_L2Relative_AK8PFPuppi.txt',
'Summer16_23Sep2016V3_MC_L3Absolute_AK8PFPuppi.txt'
]
BjecLevelsAK4chs = [
'Summer16_23Sep2016V3_MC_L1FastJet_AK4PFPuppi.txt',
'Summer16_23Sep2016V3_MC_L2Relative_AK4PFPuppi.txt',
'Summer16_23Sep2016V3_MC_L3Absolute_AK4PFPuppi.txt'
]
jecLevelsAK4chs = [
'Summer16_23Sep2016V3_MC_L1FastJet_AK4PFchs.txt',
'Summer16_23Sep2016V3_MC_L2Relative_AK4PFchs.txt',
'Summer16_23Sep2016V3_MC_L3Absolute_AK4PFchs.txt'
]
else:
jecLevelsAK8chs = [
'Summer16_23Sep2016BCDV4_DATA_L1FastJet_AK8PFchs.txt',
'Summer16_23Sep2016BCDV4_DATA_L2Relative_AK8PFchs.txt',
'Summer16_23Sep2016BCDV4_DATA_L3Absolute_AK8PFchs.txt',
'Summer16_23Sep2016BCDV4_DATA_L2L3Residual_AK8PFchs.txt'
]
jecLevelsAK8chsGroomed = [
'Summer16_23Sep2016BCDV4_DATA_L2Relative_AK8PFchs.txt',
'Summer16_23Sep2016BCDV4_DATA_L3Absolute_AK8PFchs.txt',
'Summer16_23Sep2016BCDV4_DATA_L2L3Residual_AK8PFchs.txt'
]
jecLevelsAK8puppi = [
'Summer16_23Sep2016BCDV4_DATA_L1FastJet_AK8PFPuppi.txt',
'Summer16_23Sep2016BCDV4_DATA_L2Relative_AK8PFPuppi.txt',
'Summer16_23Sep2016BCDV4_DATA_L3Absolute_AK8PFPuppi.txt',
'Summer16_23Sep2016BCDV4_DATA_L2L3Residual_AK8PFPuppi.txt'
]
jecLevelsAK8puppiGroomed = [
'Summer16_23Sep2016BCDV4_DATA_L2Relative_AK8PFPuppi.txt',
'Summer16_23Sep2016BCDV4_DATA_L3Absolute_AK8PFPuppi.txt',
'Summer16_23Sep2016BCDV4_DATA_L2L3Residual_AK8PFPuppi.txt'
]
BjecLevelsAK4chs = [
'Summer16_23Sep2016BCDV4_DATA_L1FastJet_AK8PFPuppi.txt',
'Summer16_23Sep2016BCDV4_DATA_L2Relative_AK8PFPuppi.txt',
'Summer16_23Sep2016BCDV4_DATA_L3Absolute_AK8PFPuppi.txt',
'Summer16_23Sep2016BCDV4_DATA_L2L3Residual_AK8PFPuppi.txt'
]
jecLevelsAK4chs = [
'Summer16_23Sep2016BCDV4_DATA_L1FastJet_AK4PFPuppi.txt',
'Summer16_23Sep2016BCDV4_DATA_L2Relative_AK4PFPuppi.txt',
'Summer16_23Sep2016BCDV4_DATA_L3Absolute_AK4PFPuppi.txt',
'Summer16_23Sep2016BCDV4_DATA_L2L3Residual_AK4PFPuppi.txt'
]
process.treeDumper = cms.EDAnalyzer("EDBRTreeMaker",
originalNEvents = cms.int32(1),
crossSectionPb = cms.double(1),
targetLumiInvPb = cms.double(1.0),
EDBRChannel = cms.string("VW_CHANNEL"),
lhe = cms.InputTag("externalLHEProducer"),
isGen = cms.bool(False),
isJEC = cms.bool(corrJetsOnTheFly),
RunOnMC = cms.bool(runOnMC),
RunOnSig = cms.bool(runOnSig),
generator = cms.InputTag("generator"),
genSrc = cms.InputTag("prunedGenParticles"),
pileup = cms.InputTag("slimmedAddPileupInfo"),
leptonicVSrc = cms.InputTag("leptonicV"),
gravitonSrc = cms.InputTag("graviton"),
looseMuonSrc = cms.InputTag("looseMuons"),
looseElectronSrc = cms.InputTag("looseElectrons"),
vetoMuonSrc = cms.InputTag("vetoMuons"),
vetoElectronSrc = cms.InputTag("vetoElectrons"),
goodMuSrc = cms.InputTag("goodMuons"),
MuSrc = cms.InputTag("slimmedMuons"),
EleSrc = cms.InputTag("slimmedElectrons"),
t1muSrc = cms.InputTag("slimmedMuons"),
metSrc = cms.InputTag("slimmedMETs"),
mets = cms.InputTag(METS),
#ak4jetsSrc = cms.InputTag("cleanAK4Jets"),
ak4jetsSrc = cms.InputTag("selectedUpdatedPatJetsDeepFlavourNewDFTraining"),
#ak4jetsSrc = cms.InputTag("slimmedJetPuppi"),
hadronicVSrc = cms.InputTag("hadronicV"),
hadronicVSrc_raw = cms.InputTag("slimmedJetsAK8"),
hadronicVSoftDropSrc = cms.InputTag("selectedPatJetsAK8SoftDropPacked"),
jets = cms.InputTag("slimmedJets"),
ak8JetSrc = cms.InputTag(jetsAK8),
fatjets = cms.InputTag(jetsAK8),
prunedjets = cms.InputTag(jetsAK8pruned),
softdropjets = cms.InputTag(jetsAK8softdrop),
puppijets = cms.InputTag(jetsAK8puppi),
jecAK8chsPayloadNames = cms.vstring( jecLevelsAK8chs ),
jecAK8chsPayloadNamesGroomed = cms.vstring( jecLevelsAK8chsGroomed ),
jecAK4chsPayloadNames = cms.vstring( jecLevelsAK4chs ),
BjecAK4chsPayloadNames = cms.vstring( BjecLevelsAK4chs ),
jecAK8puppiPayloadNames = cms.vstring( jecLevelsAK8puppi ),
jecAK8puppiPayloadNamesGroomed = cms.vstring( jecLevelsAK8puppiGroomed ),
jecpath = cms.string(''),
rho = cms.InputTag("fixedGridRhoFastjetAll"),
electronIDs = cms.InputTag("heepElectronID-HEEPV50-CSA14-25ns"),
muons = cms.InputTag("slimmedMuons"),
vertices = cms.InputTag("offlineSlimmedPrimaryVertices"),
hltToken = cms.InputTag("TriggerResults","","HLT"),
muPaths1 = cms.vstring("HLT_PFHT650_WideJetMJJ900DEtaJJ1p5_v*"),
muPaths2 = cms.vstring("HLT_PFHT800_v*"),
muPaths3 = cms.vstring("HLT_PFHT900_v*"),
muPaths4 = cms.vstring("HLT_PFJet450_v*"),
muPaths5 = cms.vstring("HLT_PFJet500_v*"),
muPaths6 = cms.vstring("HLT_AK8PFJet450_v*"),
muPaths7 = cms.vstring("HLT_AK8PFJet500_v*"),
muPaths8 = cms.vstring("HLT_AK8PFJet360_TrimMass30_v*"),
muPaths9 = cms.vstring("HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v*"),
muPaths10 = cms.vstring("HLT_PFHT650_WideJetMJJ950DEtaJJ1p5_v*"),
el1 = cms.vstring("HLT_Ele45_WPLoose_Gsf_v*"),
el2 = cms.vstring("HLT_Ele115_CaloIdVT_GsfTrkIdT_v*"),#("HLT_Ele35_WPLoose_Gsf_v*"),
el3 = cms.vstring("HLT_Ele27_WPTight_Gsf_v*"),
mu1 = cms.vstring("HLT_Mu50_v*"), #B2G-15-005
mu2 = cms.vstring("HLT_TkMu50_v*"), #B2G-15-005
mu3 = cms.vstring("HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_v*"),
mu4 = cms.vstring("HLT_PFMETNoMu110_PFMHTNoMu110_IDTight_v*"),
noiseFilter = cms.InputTag('TriggerResults','', hltFiltersProcessName),
noiseFilterSelection_HBHENoiseFilter = cms.string('Flag_HBHENoiseFilter'),
noiseFilterSelection_HBHENoiseIsoFilter = cms.string("Flag_HBHENoiseIsoFilter"),
noiseFilterSelection_GlobalTightHaloFilter = cms.string('Flag_globalTightHalo2016Filter'),
noiseFilterSelection_EcalDeadCellTriggerPrimitiveFilter = cms.string('Flag_EcalDeadCellTriggerPrimitiveFilter'),
noiseFilterSelection_goodVertices = cms.string('Flag_goodVertices'),
noiseFilterSelection_eeBadScFilter = cms.string('Flag_eeBadScFilter'),
noiseFilterSelection_badMuon = cms.InputTag('BadPFMuonFilter'),
noiseFilterSelection_badChargedHadron = cms.InputTag('BadChargedCandidateFilter'),
)
if option=='GEN':
process.treeDumper.metSrc = 'genMetTrue'
process.treeDumper.isGen = True
process.analysis = cms.Path(process.leptonSequence +
#process.substructureSequence+
#process.redoPatJets+
#process.redoPrunedPatJets+
#process.redoSoftDropPatJets+
process.HBHENoiseFilterResultProducer+
process.ApplyBaselineHBHENoiseFilter+
process.ApplyBaselineHBHEIsoNoiseFilter+
process.jetSequence +
process.metfilterSequence +
process.gravitonSequence +
process.treeDumper)
if option=='RECO':
process.analysis.replace(process.leptonSequence, process.goodOfflinePrimaryVertex + process.leptonSequence)
process.load("ExoDiBosonResonances.EDBRCommon.data.RSGravitonToWW_kMpl01_M_1000_Tune4C_13TeV_pythia8")
process.source.fileNames = [
"/store/data/Run2016B/JetHT/MINIAOD/23Sep2016-v1/90000/EAF9587D-8082-E611-A783-0CC47A13CD56.root"
#"/store/data/Run2016B/JetHT/MINIAOD/23Sep2016-v1/90000/FE47EB9B-EB81-E611-B475-24BE05CEEB81.root"
#"/store/data/Run2016E/JetHT/MINIAOD/23Sep2016-v1/50000/483CEE4F-FB86-E611-94C8-0CC47A7C3572.root"
]
process.maxEvents.input = 2000
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = 5000
process.MessageLogger.cerr.FwkReport.limit = 99999999
process.TFileService = cms.Service("TFileService",
fileName = cms.string("RStreeEDBR_pickup7.root")
)
| [
"c.chen@cern.ch"
] | c.chen@cern.ch |
b956a071a1cd830747a03be5cfbe515c771eb205 | 5eba0ee342adf574664ef2c5b2a9787f28ad9e4a | /core/utils/auth.py | 35059117c9a7332bc93e926280bf0e24a81a7e90 | [] | no_license | nagibator95/ejudge-front | 2775875bd8d8367674b3c5c372b5fafa77167aac | ca355f473702561047da030b7d4a12af06539395 | refs/heads/master | 2020-04-10T06:59:53.873278 | 2018-12-20T20:15:36 | 2018-12-20T20:15:36 | 160,870,700 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 568 | py | from flask import request
from werkzeug.exceptions import Forbidden
def get_api_key_checker(key) -> callable:
""" Function which returns function which checks request api key
Basic usage:
app = Flask()
app.before_request(get_api_key_checker(<my-secret-string>))
Raises
------
Forbidden: when api key is bad or not allowed
"""
def check_api_key():
requested_key = request.headers.get('api-key')
if key != requested_key:
raise Forbidden('API key is not valid!')
return check_api_key
| [
"n.pakhtusov@tinkoff.ru"
] | n.pakhtusov@tinkoff.ru |
19d91073ca04ae3be1da48fd4fb375195f5fe1f1 | 5601d2659a0a51c7c5b8095c3942d5e8da060d6c | /rvd/forms/User.py | 5aeedce0f15d98cc40a5be47a33b77dec52cee3f | [] | no_license | equalitie/RVD-webapp | 17db53e11d513e50700cb6a4abdcf6aa87522e14 | 8de4fc4eb65d5a8e0e8e7baf6ae54d278ceb6299 | refs/heads/master | 2020-05-17T19:29:53.660109 | 2019-01-08T16:48:36 | 2019-01-08T16:48:36 | 32,819,207 | 1 | 0 | null | 2018-07-12T16:24:27 | 2015-03-24T19:08:32 | Python | UTF-8 | Python | false | false | 816 | py | from flask_babel import lazy_gettext as ___
from wtforms.ext.sqlalchemy.fields import QuerySelectField
from wtforms import validators
from wtforms_alchemy import ModelForm
from rvd.forms import user_org_factory
from rvd.models import User
from wtforms.fields import PasswordField, SelectField
from wtforms_components import EmailField
class UserForm(ModelForm):
class Meta:
model = User
exclude = ['password_salt']
email = EmailField(validators=[validators.required()])
password = PasswordField(validators=[validators.required()])
organisation = QuerySelectField(query_factory=user_org_factory, get_label='name', allow_blank=True)
is_admin = SelectField(
___('Is admin'), validators=[validators.required()], choices=[(1, ___('Yes')), (0, ___('No'))], coerce=bool
) | [
"l@laurierrochon.com"
] | l@laurierrochon.com |
d73d667c6a92240fe046be4a465394b6368eb941 | fe1ba64992e78149b162255cf11ea53f9e2396c6 | /ngram.py | 10c1ef889a77879ec914e78636a26b57cf338d09 | [] | no_license | berkekadam/NLP-Ngrams | 268c99a307e62cde01709eacf8fdf288c877852e | 676f1a0fd2ede8d0fc93bd25c6d0d227eaa06882 | refs/heads/master | 2022-07-06T04:38:41.435437 | 2020-05-08T12:50:11 | 2020-05-08T12:50:11 | 260,207,062 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 2,799 | py | import os.path # to checking file
import glob # for file reading
from tkinter import * # for removing punctuations
import time
start_time = time.time()
fileExist = True
if os.path.exists('result.txt') != fileExist:
read_files = glob.glob("*.txt")
with open("result.txt", "wb") as outfile: # merge all txt's in one
for f in read_files:
with open(f, "rb") as infile:
outfile.write(infile.read())
with open('result.txt', 'r') as myFile: # txt to String
novelAsString = myFile.read()
exe = True
while exe:
n = int(input("Press 1 for Unigram, 2 for Digram, 3 for Trigram: ")) # take input
wordsSplit = [] # firstly words will be splitted
wordsCombined = [] # then will be combined according to selected ngram
wordsCounted = [] # checked words will be gathered in this array
counts = [] # this will control the number of frequencies
text = novelAsString.lower()
x = re.sub(r"[^\w\s]", "", text) # remove punctuation characters
wordsSplit = x.split() # split and store in wordsSplit as a list
returnString = "Total number of words = " + str(len(wordsSplit)) + "\n" # will be the output
for i in range(len(wordsSplit) - n + 1):
j = i
array = []
for j in range(j, j + n, 1): # making word combinations
array.append(wordsSplit[j])
temp = ""
for j in range(len(array)):
if j == 0:
temp = array[j]
else:
temp = temp + " " + array[j]
wordsCombined.append(temp)
for i in range(len(wordsCombined)):
controlrepeat = True
counter = 0
wordIsChecking = wordsCombined[i] # select the word that will be checked
if wordIsChecking in wordsCounted: # if the word checked before, select another
controlrepeat = False
if controlrepeat:
counter = wordsCombined.count(wordIsChecking) # counter equals to frequency of word, will be at least 1
if counter > 1:
wordsCounted.append(wordIsChecking)
counts.append(counter)
counterNew = 1
for i in range(100):
numbersPrinting = max(counts) # get the max frequency
indexer = counts.index(max(counts))
returnString = str(returnString) + str(counterNew) + ")" + str(wordsCounted[indexer]) + "--" + str(numbersPrinting) + "\n"
wordsCounted.remove(wordsCounted[indexer]) # remove the printed word
counts.remove(counts[indexer]) # remove word's frequency value
counterNew = counterNew + 1
print("Completion Time is " + str(time.time() - start_time) + " seconds for " + str(n) + "gram")
print(returnString)
| [
"noreply@github.com"
] | berkekadam.noreply@github.com |
584ad267ce7955f8c106bee89d02951dec69a5f3 | 2c6e4f0f2370640c390de7c5061f23e396bdf797 | /arctic/race5setup.py | a130e9fbdc209299a330a7d03592359b1eb45c4e | [] | no_license | PlumpMath/Turbo_Racers | f8d8d46bd8dae046bd47f7e060744c14fefebe43 | a1b5c46f121b627c7bc3ebb338946c1554499ecd | refs/heads/master | 2021-01-25T06:55:53.328261 | 2016-09-18T21:01:46 | 2016-09-18T21:01:46 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 9,799 | py | from pandac.PandaModules import *
from direct.showbase.DirectObject import DirectObject
import random, sys, os, math
from level_editor_data import *
class RaceSetup(DirectObject):
def __init__(self, editor):
editor.bgr = 0.0334966816008
editor.bgg = 0.0
editor.bgb = 0.149158328772
editor.loadTerrain("arctic/world/aw")
editor.terrain.setScale(VBase3(3.5, 3.5, 3.5))
editor.terrain.setZ(0.0)
editor.alightBrightness = 0.114617533982
editor.dlightBrightness = 0.0794800668955
editor.ships.append(setupShip(-258.0, -4.0, 0, 0.0))
editor.ships.append(setupShip(-270.0, -4.0, 1, 0.0))
editor.ships.append(setupShip(-282.0, -4.0, 2, 0.0))
editor.ships.append(setupShip(-296.0, -4.0, 3, 0.0))
editor.ships.append(setupShip(-283.0, -21.0, 4, 0.0))
editor.ships.append(setupShip(-270.0, -21.0, 5, 0.0))
editor.barriers.append(setupBarrier(-153.0, -120.0, 244.0))
editor.barriers.append(setupBarrier(-154.0, -139.0, 293.0))
editor.barriers.append(setupBarrier(-144.0, -152.0, 319.0))
editor.barriers.append(setupBarrier(-133.0, -161.0, 319.0))
editor.barriers.append(setupBarrier(-151.0, 186.0, 420.0))
editor.barriers.append(setupBarrier(-144.0, 198.0, 420.0))
editor.barriers.append(setupBarrier(-142.0, 197.0, 236.0))
editor.barriers.append(setupBarrier(-148.0, 186.0, 236.0))
editor.barriers.append(setupBarrier(191.0, 309.0, 287.0))
editor.barriers.append(setupBarrier(153.0, -112.0, 226.0))
editor.barriers.append(setupBarrier(-24.0, -182.0, -25.0))
editor.barriers.append(setupBarrier(69.0, -205.0, -25.0))
editor.barriers.append(setupBarrier(191.0, 239.0, 250.0))
editor.barriers.append(setupBarrier(161.0, 185.0, 250.0))
editor.checkpoints.append(setupCheckpoint(-106.0, 264.0, -52.0, 0, 5))
editor.checkpoints.append(setupCheckpoint(173.0, 268.0, -184.0, 1, 9))
editor.checkpoints.append(setupCheckpoint(-46.0, 69.0, 225.0, 2, 18))
editor.checkpoints.append(setupCheckpoint(69.0, 15.0, -139.0, 3, 20))
editor.checkpoints.append(setupCheckpoint(-96.0, -163.0, -127.0, 4, 33))
editor.checkpoints.append(setupCheckpoint(269.0, -154.0, -33.0, 5, 38))
editor.checkpoints.append(setupCheckpoint(228.0, 212.0, 114.0, 6, 43))
editor.checkpoints.append(setupCheckpoint(-145.0, 96.0, 181.0, 8, 50))
editor.checkpoints.append(setupCheckpoint(-47.0, 16.0, 292.0, 9, 55))
editor.checkpoints.append(setupCheckpoint(82.0, 65.0, 274.0, 10, 58))
editor.checkpoints.append(setupCheckpoint(105.0, -124.0, 124.0, 11, 64))
editor.checkpoints.append(setupCheckpoint(-98.0, -249.0, 105.0, 12, 68))
editor.checkpoints.append(setupCheckpoint(-255.0, -218.0, 63.0, 13, 70))
editor.startingline = setupStartingline(-271.0, 15.0, 0.0)
editor.powerups.append(setupPowerup(-234.0, 105.0))
editor.powerups.append(setupPowerup(-199.0, 162.0))
editor.powerups.append(setupPowerup(-195.0, 129.0))
editor.powerups.append(setupPowerup(-195.0, 93.0))
editor.powerups.append(setupPowerup(-125.0, 182.0))
editor.powerups.append(setupPowerup(-131.0, 192.0))
editor.powerups.append(setupPowerup(-139.0, 198.0))
editor.powerups.append(setupPowerup(-149.0, 202.0))
editor.powerups.append(setupPowerup(-161.0, 203.0))
editor.powerups.append(setupPowerup(296.0, 159.0))
editor.powerups.append(setupPowerup(315.0, 159.0))
editor.powerups.append(setupPowerup(334.0, 159.0))
editor.powerups.append(setupPowerup(253.0, -175.0))
editor.powerups.append(setupPowerup(212.0, -206.0))
editor.powerups.append(setupPowerup(4.0, -212.0))
editor.powerups.append(setupPowerup(4.0, -196.0))
editor.powerups.append(setupPowerup(4.0, -232.0))
editor.powerups.append(setupPowerup(-198.0, -248.0))
editor.powerups.append(setupPowerup(-200.0, -266.0))
editor.powerups.append(setupPowerup(-284.0, -95.0))
editor.powerups.append(setupPowerup(-277.0, -87.0))
editor.powerups.append(setupPowerup(-266.0, -76.0))
editor.powerups.append(setupPowerup(-113.0, 26.0))
editor.powerups.append(setupPowerup(138.0, 20.0))
editor.powerups.append(setupPowerup(30.0, 6.0))
editor.powerups.append(setupPowerup(30.0, 19.0))
editor.powerups.append(setupPowerup(30.0, 30.0))
editor.powerups.append(setupPowerup(30.0, 68.0))
editor.powerups.append(setupPowerup(30.0, 84.0))
editor.powerups.append(setupPowerup(30.0, 100.0))
editor.powerups.append(setupPowerup(44.0, 46.0))
editor.powerups.append(setupPowerup(59.0, 46.0))
editor.powerups.append(setupPowerup(73.0, 46.0))
editor.powerups.append(setupPowerup(8.0, 48.0))
editor.powerups.append(setupPowerup(-4.0, 48.0))
editor.powerups.append(setupPowerup(-15.0, 48.0))
editor.powerh.append(setupPowerh(-294.0, 81.0))
editor.powerh.append(setupPowerh(84.0, 220.0))
editor.powerh.append(setupPowerh(84.0, 232.0))
editor.powerh.append(setupPowerh(84.0, 246.0))
editor.powerh.append(setupPowerh(84.0, 300.0))
editor.powerh.append(setupPowerh(84.0, 314.0))
editor.powerh.append(setupPowerh(84.0, 323.0))
editor.powerh.append(setupPowerh(256.0, -198.0))
editor.powerh.append(setupPowerh(212.0, -190.0))
editor.powerh.append(setupPowerh(-197.0, -234.0))
editor.powerh.append(setupPowerh(-54.0, -67.0))
editor.powerh.append(setupPowerh(-59.0, 137.0))
editor.waypoints.append(setupWaypoint(-254.0, 55.0, 0))
editor.waypoints.append(setupWaypoint(-236.0, 104.0, 1))
editor.waypoints.append(setupWaypoint(-226.0, 135.0, 2))
editor.waypoints.append(setupWaypoint(-199.0, 161.0, 3))
editor.waypoints.append(setupWaypoint(-166.0, 191.0, 4))
editor.waypoints.append(setupWaypoint(-42.0, 300.0, 6))
editor.waypoints.append(setupWaypoint(66.0, 314.0, 7))
editor.waypoints.append(setupWaypoint(156.0, 300.0, 8))
editor.waypoints.append(setupWaypoint(151.0, 193.0, 10))
editor.waypoints.append(setupWaypoint(124.0, 166.0, 11))
editor.waypoints.append(setupWaypoint(89.0, 156.0, 12))
editor.waypoints.append(setupWaypoint(25.0, 142.0, 13))
editor.waypoints.append(setupWaypoint(-42.0, 144.0, 14))
editor.waypoints.append(setupWaypoint(-59.0, 136.0, 15))
editor.waypoints.append(setupWaypoint(-66.0, 111.0, 16))
editor.waypoints.append(setupWaypoint(-61.0, 88.0, 17))
editor.waypoints.append(setupWaypoint(86.0, -5.0, 21))
editor.waypoints.append(setupWaypoint(95.0, -25.0, 22))
editor.waypoints.append(setupWaypoint(95.0, -46.0, 23))
editor.waypoints.append(setupWaypoint(88.0, -63.0, 24))
editor.waypoints.append(setupWaypoint(67.0, -72.0, 25))
editor.waypoints.append(setupWaypoint(41.0, -73.0, 26))
editor.waypoints.append(setupWaypoint(-53.0, -68.0, 27))
editor.waypoints.append(setupWaypoint(-79.0, -67.0, 28))
editor.waypoints.append(setupWaypoint(-103.0, -72.0, 29))
editor.waypoints.append(setupWaypoint(-119.0, -84.0, 30))
editor.waypoints.append(setupWaypoint(-132.0, -108.0, 31))
editor.waypoints.append(setupWaypoint(-135.0, -136.0, 32))
editor.waypoints.append(setupWaypoint(-33.0, -207.0, 34))
editor.waypoints.append(setupWaypoint(65.0, -225.0, 35))
editor.waypoints.append(setupWaypoint(181.0, -214.0, 36))
editor.waypoints.append(setupWaypoint(241.0, -195.0, 37))
editor.waypoints.append(setupWaypoint(281.0, -85.0, 39))
editor.waypoints.append(setupWaypoint(298.0, 37.0, 40))
editor.waypoints.append(setupWaypoint(318.0, 159.0, 41))
editor.waypoints.append(setupWaypoint(290.0, 215.0, 42))
editor.waypoints.append(setupWaypoint(127.0, 226.0, 45))
editor.waypoints.append(setupWaypoint(23.0, 233.0, 46))
editor.waypoints.append(setupWaypoint(-80.0, 220.0, 47))
editor.waypoints.append(setupWaypoint(-126.0, 196.0, 48))
editor.waypoints.append(setupWaypoint(-144.0, 156.0, 49))
editor.waypoints.append(setupWaypoint(-141.0, 60.0, 51))
editor.waypoints.append(setupWaypoint(-132.0, 41.0, 52))
editor.waypoints.append(setupWaypoint(-112.0, 27.0, 53))
editor.waypoints.append(setupWaypoint(-77.0, 14.0, 54))
editor.waypoints.append(setupWaypoint(34.0, 30.0, 56))
editor.waypoints.append(setupWaypoint(108.0, 60.0, 59))
editor.waypoints.append(setupWaypoint(126.0, 46.0, 60))
editor.waypoints.append(setupWaypoint(137.0, 20.0, 61))
editor.waypoints.append(setupWaypoint(137.0, -80.0, 62))
editor.waypoints.append(setupWaypoint(138.0, -95.0, 63))
editor.waypoints.append(setupWaypoint(50.0, -161.0, 65))
editor.waypoints.append(setupWaypoint(32.0, -195.0, 66))
editor.waypoints.append(setupWaypoint(-24.0, -216.0, 67))
editor.waypoints.append(setupWaypoint(-198.0, -248.0, 69))
editor.waypoints.append(setupWaypoint(-276.0, -184.0, 71))
editor.waypoints.append(setupWaypoint(-268.0, -120.0, 72))
editor.waypoints.append(setupWaypoint(-280.0, -63.0, 73))
editor.waypoints.append(setupWaypoint(-272.0, 1.0, 74))
editor.waypoints.append(setupWaypoint(191.0, 206.0, 44))
editor.waypoints.append(setupWaypoint(14.0, 30.0, 19))
editor.laps = 2
editor.winCredits = 850
editor.minPlace = 1
editor.setValues() | [
"jtfedd@gmail.com"
] | jtfedd@gmail.com |
6cc834bba9ebced42abd80dea249bc07d5da3e07 | 427af49149a35d41efe911f43b99e2fb9e6f2139 | /Recursion and Backtracking/printSubsequence.py | 8b6dcc343479dc3377750fa7dc1782828b516d02 | [] | no_license | ullas0601/My_Coding_Interview_Prepration_Guide_for_FAANG | fb67176c6cbdec6f2bb2a3c10ed8f0602345de9f | 29750ab9781cdf4575ea74b24d56d9aa762c178f | refs/heads/master | 2023-05-24T03:46:09.100268 | 2021-06-20T05:39:29 | 2021-06-20T05:39:29 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 172 | py | def subSeq(s, out):
if len(s) == 0:
print(out)
return ['']
output = subSeq(s[1:], out)
output = subSeq(s[1:], out+s[0])
s = "abc"
subSeq(s, '') | [
"schandan696@gmail.com"
] | schandan696@gmail.com |
3eb3e352a1c39461f03ba3987f46e58cff8a3419 | b5b117371b463ba68be14345549f16098bb311ef | /faculd_impacta/tec_prg_1sem/AC2_tec_prog/ex02.py | a6d706f854e5fabc2a02e8fd6dc0ce3fc7aea054 | [] | no_license | thuurzz/Python | f1d0f5038ed97fbf4dc83c352102efcdde25ace8 | 7bd61180fe7594aad7d6cb787772a384f18ced87 | refs/heads/master | 2022-11-05T17:22:02.661665 | 2021-05-17T02:59:37 | 2021-05-17T02:59:37 | 245,733,534 | 0 | 1 | null | 2022-10-23T12:20:43 | 2020-03-08T01:34:31 | Python | UTF-8 | Python | false | false | 211 | py | #Arthur Vinicius Santos Silva RA:1903665
idade = int(input())
if idade < 16:
print('nao eleitor')
elif idade >= 18 and idade <= 65:
print('eleitor obrigatorio')
else:
print('eleitor facultativo')
| [
"thuur.vss@gmail.com"
] | thuur.vss@gmail.com |
9d0770314c647062f179038fdd26dc5844498c36 | 417c346d4200cd4d620742cd454e7c70168e849c | /app/logger.py | 3d2913167fe8a624182ace32d70f34f7f197de3a | [] | no_license | t1fan-prog/final-bot | f4a11593f308eb8807336a3b81b9b98804ff1d57 | 0f5c00072ddedff2e39950f3bc03175a61987f44 | refs/heads/master | 2023-07-10T21:52:23.222484 | 2021-08-17T10:54:17 | 2021-08-17T10:54:17 | 395,057,712 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 424 | py | import logging
def create_logger(name: str):
logger = logging.getLogger(name)
logger.setLevel(logging.INFO)
logger_handler = logging.FileHandler('bot_logger.log')
logger_handler.setLevel(logging.INFO)
logger_formatter = logging.Formatter('%(name)s - %(asctime)s - %(levelname)s - %(message)s')
logger_handler.setFormatter(logger_formatter)
logger.addHandler(logger_handler)
return logger
| [
"artem.t1fan@gmail.com"
] | artem.t1fan@gmail.com |
9ac19c4aea106efafa3ec76b9113214d59ee531f | d20d7d0887e044cb369687629eee04d03bc6ac15 | /grano/logic/projects.py | cc54f580a84a76c3afff8ddffdeb95bdd13d3aa3 | [
"MIT"
] | permissive | nimblemachine/grano | 947812bdd2a861e7d62bd081423df2723891989a | ffbd3f974867334d396d536bd000a20a314f9fc6 | refs/heads/master | 2021-01-18T11:24:51.750426 | 2014-03-24T10:39:35 | 2014-03-24T10:39:35 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,796 | py | import colander
from datetime import datetime
from grano.core import app, db, url_for
from grano.lib.exc import NotImplemented
from grano.logic.validation import database_name
from grano.logic.references import AccountRef
from grano.logic import accounts
from grano.model import Project
def validate(data, project):
same_project = lambda s: Project.by_slug(s) == project
same_project = colander.Function(same_project, message="Project exists")
class ProjectValidator(colander.MappingSchema):
slug = colander.SchemaNode(colander.String(),
validator=colander.All(database_name, same_project))
label = colander.SchemaNode(colander.String(),
validator=colander.Length(min=3))
private = colander.SchemaNode(colander.Boolean(),
missing=False)
author = colander.SchemaNode(AccountRef())
settings = colander.SchemaNode(colander.Mapping(),
missing={})
validator = ProjectValidator()
return validator.deserialize(data)
def save(data, project=None):
""" Create or update a project with a given slug. """
data = validate(data, project)
if project is None:
project = Project()
project.slug = data.get('slug')
project.author = data.get('author')
from grano.logic import permissions as permissions_logic
permissions_logic.save({
'account': data.get('author'),
'project': project,
'admin': True
})
project.settings = data.get('settings')
project.label = data.get('label')
project.private = data.get('private')
project.updated_at = datetime.utcnow()
db.session.add(project)
# TODO: make this nicer - separate files?
from grano.logic.schemata import import_schema
with app.open_resource('fixtures/base.yaml') as fh:
import_schema(project, fh)
db.session.flush()
return project
def delete(project):
raise NotImplemented()
def to_rest_index(project):
return {
'slug': project.slug,
'label': project.label,
'api_url': url_for('projects_api.view', slug=project.slug)
}
def to_rest_index_stats(project):
data = to_rest_index(project)
data['entities_count'] = project.entities.count()
data['relations_count'] = project.relations.count()
return data
def to_rest(project):
data = to_rest_index_stats(project)
data['settings'] = project.settings
data['author'] = accounts.to_rest_index(project.author)
data['schemata_index_url'] = url_for('schemata_api.index', slug=project.slug)
data['entities_index_url'] = url_for('entities_api.index', project=project.slug)
data['relations_index_url'] = url_for('relations_api.index', project=project.slug)
return data
| [
"friedrich@pudo.org"
] | friedrich@pudo.org |
16cfbb999c9d7dd7424544815e87ac7cc04b2044 | 666459e6596836a8014c9945d038d1d9690c11ef | /mcctl/src/python/m_test1.py | 8dae96e8b1ca160851ae6a818b1454a64983cf6f | [] | no_license | ataraken/formal-methods | 99c78c62758f12428f99892b9b20f429d65861b0 | 2564c9a846f93056015f6bd1be1716d81b02d1b8 | refs/heads/master | 2022-12-18T22:15:33.669470 | 2020-08-31T15:07:46 | 2020-08-31T15:07:46 | 290,504,412 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,924 | py | import sys
import copy
import mcctl
sys.path.append('../../../ddsv/src/python')
import ddsv
class SharedVars(ddsv.SharedVarsInterface):
def __init__(self):
self.x = 0
self.y = 0
self.z = 0
def clone(self):
return copy.deepcopy(self)
def equal(self, target):
return (self.x == target.x) and (self.y == target.y) and (self.z == target.z)
def to_str(self):
return 'x={0} y={1} z={2}'.format(self.x, self.y, self.z)
def to_graph_str(self):
return self.to_str()
class ActionX1(ddsv.Action):
def exec(self, process, dest, src):
dest.shared_vars.x = 1
class ActionY0(ddsv.Action):
def exec(self, process, dest, src):
dest.shared_vars.y = 0
class ActionY1(ddsv.Action):
def exec(self, process, dest, src):
dest.shared_vars.y = 1
class ActionZ1(ddsv.Action):
def exec(self, process, dest, src):
dest.shared_vars.z = 1
state_trans_list = [
ddsv.StateTransition('0', [ddsv.Transition('x=1', '1', ddsv.GuardTrue(), ActionX1())]),
ddsv.StateTransition('1', [ddsv.Transition('y=1', '2', ddsv.GuardTrue(), ActionY1())]),
ddsv.StateTransition('2', [ddsv.Transition('z=1', '3', ddsv.GuardTrue(), ActionZ1())]),
ddsv.StateTransition('3', [ddsv.Transition('y=0', '4', ddsv.GuardTrue(), ActionY0())]),
ddsv.StateTransition('4', [])
]
def func0(shared_vars):
return shared_vars.x == 1
def func1(shared_vars):
return shared_vars.y > 0
def func2(shared_vars):
return shared_vars.z == 0
P = ddsv.Process('P', state_trans_list)
process_list = [P]
lts_tbl = ddsv.concurrent_composition(process_list, SharedVars(), 'm_test1')
f = mcctl.Or(mcctl.And(mcctl.Prop('x=1', func0), mcctl.Prop('y>0', func1)), mcctl.Not(mcctl.Prop('z=0', func2)))
marker = mcctl.LtsTblMarker(lts_tbl, f)
marker.save_graph('m_test1')
| [
"Yusuke.Shinmi@gmail.com"
] | Yusuke.Shinmi@gmail.com |
3bb5492fa60064dd7f3420aa2d23536e24e8709f | 3ea6ef4a7a1e12f85210bbc188214ab33d6697df | /main.py | bc79a1a4a4d827fe53c9ea691e5210951c411415 | [] | no_license | ruancastro/Subscription_Aceleradev_Codenation2020 | 5443a2e70f72f5c377544226c31326e8809d03ea | 7cea9498239af1e80ff1ff0327cf42bfd4fbf4ac | refs/heads/master | 2022-09-08T22:39:48.227713 | 2020-06-04T17:20:28 | 2020-06-04T17:20:28 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 585 | py | import pandas as pd
import numpy as np
# df_train = pd.read_csv("/home/ruan/Área de Trabalho/codes/CodeNation/Aceleradev_Codenation2020/input/train.csv")
# print(df_train.head())
# # print(df_train.describe())
# print(df_train.columns)
# # print(df_train.index()
# print(df_train.shape)
df_dicionario = pd.read_excel("/home/ruan/Área de Trabalho/codes/CodeNation/Aceleradev_Codenation2020/input/Dicionario_Microdados_Enem_2016.xlsx")
print(df_dicionario.head())
# print(df_dicionario.describe())
print(df_dicionario.columns)
# print(df_dicionario.index()
print(df_dicionario.shape) | [
"ruancastro15@gmail.com"
] | ruancastro15@gmail.com |
4006301004c60b6201889100090f58224a56b128 | d357efbca8294c745270e2a40cd83c9cb363f613 | /PricingProfile_Uniform.py | 8a7c1c1d4f3b47457b326a78fcc427162715028f | [] | no_license | icavrak/SmartHomeSim | 1f84b88542ae850f04dc526d450ddf5374300b5f | 106ebdfea0c6436f89d2926f482d156b4576ba80 | refs/heads/master | 2020-05-19T19:39:20.119633 | 2019-05-21T15:25:24 | 2019-05-21T15:25:24 | 185,185,564 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 240 | py | from PricingProfile import PricingProfile
class PricingProfile_Uniform(PricingProfile):
def __init__(self):
self.current_price = 1.0
def __init__(self, init_arguments):
self.current_price = float(init_arguments)
| [
"igor.cavrak@fer.hr"
] | igor.cavrak@fer.hr |
2a7f70925be3844266a29d8d9c3d9824794a0c0f | dfab6798ece135946aebb08f93f162c37dd51791 | /core/luban/controller/Actor.py | 8452c92ace1f56996ae2ccc29b60f307a6a30f4f | [] | no_license | yxqd/luban | 405f5f7dcf09015d214079fe7e23d644332be069 | 00f699d15c572c8bf160516d582fa37f84ac2023 | refs/heads/master | 2020-03-20T23:08:45.153471 | 2012-05-18T14:52:43 | 2012-05-18T14:52:43 | 137,831,650 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,679 | py | # -*- Python -*-
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
# Jiao Lin
# California Institute of Technology
# (C) 2006-2011 All Rights Reserved
#
# {LicenseText}
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
class Actor(object):
# properties
name = None # name of the actor
controller = None # the controller
# exceptions
from .exceptions import RoutineNotFound
# methods
def perform(self, routine=None, *args, **kwds):
if routine is None:
routine = "default"
if routine.startswith('_'):
raise RuntimeError("%s is private" % routine)
try:
behavior = getattr(self, routine)
except AttributeError:
msg = "actor %r: routine %r is not yet implemented" % (
self.name, routine)
raise self.RoutineNotFound(msg)
# special name "kwds"
if 'kwds' in kwds:
kwds2 = kwds['kwds']
if isinstance(kwds2, strbase):
from ..weaver.web._utils import jsonDecode
kwds2 = jsonDecode(kwds2)
for k in kwds2:
if k in kwds:
raise RuntimeError("conflict key: %s" % k)
continue
kwds.update(kwds2)
del kwds['kwds']
return behavior(*args, **kwds)
pass # end of Actor
from luban import py_major_ver
if py_major_ver == 2:
strbase = basestring
elif py_major_ver == 3:
strbase = str
# End of file
| [
"linjiao@caltech.edu"
] | linjiao@caltech.edu |
5bcff8ae4c42c2bafb1c80881769ed67f44ea8e9 | f2889a13368b59d8b82f7def1a31a6277b6518b7 | /256.py | d94465af0b09e0a288eb3073779e9c08ea3bc589 | [] | no_license | htl1126/leetcode | dacde03de5c9c967e527c4c3b29a4547154e11b3 | c33559dc5e0bf6879bb3462ab65a9446a66d19f6 | refs/heads/master | 2023-09-01T14:57:57.302544 | 2023-08-25T15:50:56 | 2023-08-25T15:50:56 | 29,514,867 | 7 | 1 | null | null | null | null | UTF-8 | Python | false | false | 452 | py | # ref: https://discuss.leetcode.com/topic/21337/1-lines-ruby-python
class Solution(object):
def minCost(self, costs):
"""
:type costs: List[List[int]]
:rtype: int
"""
prev = [0] * 3
for now in costs:
prev = [now[i] + min(prev[:i] + prev[i + 1:]) for i in xrange(3)]
return min(prev)
if __name__ == '__main__':
sol = Solution()
print sol.minCost([[1, 2, 3], [3, 2, 1]])
| [
"b93902098@ntu.edu.tw"
] | b93902098@ntu.edu.tw |
0df69e3db7af12577fa662d3a36c94d62a749ea6 | 303bac96502e5b1666c05afd6c2e85cf33f19d8c | /solutions/python3/257.py | de9a0c8a3c1cbc818b3466259db95a34a7020459 | [
"MIT"
] | permissive | jxhangithub/leetcode | 5e82f4aeee1bf201e93e889e5c4ded2fcda90437 | 0de1af607557d95856f0e4c2a12a56c8c57d731d | refs/heads/master | 2022-05-22T12:57:54.251281 | 2022-03-09T22:36:20 | 2022-03-09T22:36:20 | 370,508,127 | 1 | 0 | MIT | 2022-03-09T22:36:20 | 2021-05-24T23:16:10 | null | UTF-8 | Python | false | false | 678 | py | # Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def binaryTreePaths(self, root: TreeNode) -> List[str]:
def dfs(node, arr):
if not node.right and not node.left:
#print(arr)
self.res += ['->'.join(str(num) for num in arr)]
if node.left:
dfs(node.left, arr + [node.left.val])
if node.right:
dfs(node.right, arr + [node.right.val])
self.res = []
if not root: return []
dfs(root, [root.val])
return self.res | [
"cenkay.arapsagolu@gmail.com"
] | cenkay.arapsagolu@gmail.com |
af601425fa4a237f555329b8ba41c9b99a1fb5ba | b1a20bd5b57aa3cd3b2363bcbbe9c04f47969856 | /polls/migrations/0005_employee_photo.py | 16d508d8ea79e6c66f73834fb85069c08f33270c | [] | no_license | jatinsinghal1921/DRF-Experiment | ea19da30a5421e53d5603ffdd9d0f0bac6773186 | cffb16622f518de14fba743aed84583449661cf3 | refs/heads/main | 2023-01-03T15:47:39.808519 | 2020-10-24T07:43:12 | 2020-10-24T07:43:12 | 306,832,192 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 419 | py | # Generated by Django 3.0.3 on 2020-04-01 13:43
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('polls', '0004_auto_20200330_1203'),
]
operations = [
migrations.AddField(
model_name='employee',
name='photo',
field=models.FileField(blank=True, default=None, null=True, upload_to=''),
),
]
| [
"jatin.singhal@wdc.com"
] | jatin.singhal@wdc.com |
1326e2a9cd8cb8e3556d61bffde19af203165fa8 | 9bce961e2dfd2f4092f9dfd4801e6e75bb7515d3 | /prilogenie111/admin.py | a011af8dfbc9cab075aa369e3a495f37ca597909 | [] | no_license | maxim218/test_db_django_restaring_view | 6787b87ada64f90884a18bdf5288765da892d0cf | 0c91a81f93b285388ded24b8cdebb9b4a42ae2d4 | refs/heads/master | 2021-04-15T15:21:55.352594 | 2018-03-23T23:20:55 | 2018-03-23T23:20:55 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 133 | py | from django.contrib import admin
from .models import MyModelTest
admin.site.register(MyModelTest)
#
# gunicorn max_test_db.wsgi
# | [
"maxim218maxim218@yandex.ru"
] | maxim218maxim218@yandex.ru |
ad9783940dbcd03cf49e5263db628120df285a47 | 514710d2385a4999980378d26e766b1a8415ec91 | /Import_from_sql.py | ddcaacb50b620b3f0dc83b519970d8c10dd5f569 | [] | no_license | silveira-alysson/Python_Visualization_Week7 | f8f4d6ce37ddd81ba871f0950cdcbcbc7f9222fa | 9ed1cc2613c7d90448da44329bd03da6c9bb40a2 | refs/heads/master | 2022-04-12T01:27:02.989218 | 2020-04-02T23:59:38 | 2020-04-02T23:59:38 | 252,540,681 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 564 | py | # -*- coding: utf-8 -*-
"""
Created on Thu Apr 2 18:07:40 2020
@author: alyss
"""
import pandas as pd
from sqlalchemy import create_engine
# Connect to sqlite db
db_file = r'C:\Users\alyss\Desktop\MS BAIS\Spring 2020\ISM6419_Data_Visualization\Week_7_Python\datasets\datasets\gradedata.db'
engine = create_engine('sqlite:///C:/Users/alyss/Desktop/MS BAIS/Spring 2020/ISM6419_Data_Visualization/Week_7_Python/datasets/datasets/gradedata.db')
sql = 'SELECT * from test where Grades in (76,77,78)'
sales_data_df = pd.read_sql(sql, engine)
sales_data_df | [
"noreply@github.com"
] | silveira-alysson.noreply@github.com |
1eae30a926b5d473bf445c92ec93be1e002c843b | 474dc08d65e9a29970e29504e33f5cbda99ec03c | /python/hcheckers/field.py | 3dade5c0ffe525d8c6a8424fa1964efba82dffff | [] | no_license | ttldtor/hcheckers | f26a9b01c876d27e31bcee15b252ffaaaf07705b | 835a12cb8cbb6a6257809a3bdafa325cc6250e6a | refs/heads/master | 2023-03-21T09:21:28.625027 | 2021-03-08T09:24:38 | 2021-03-08T09:24:38 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,724 | py |
from PyQt5.QtGui import QPainter, QPixmap
from PyQt5.QtCore import QRect, Qt
from PyQt5.QtWidgets import QApplication, QWidget
from hcheckers import common
class Field(object):
def __init__(self):
self._show_frame = False
self._moveable = False
self._last_moved = False
self._show_label = False
self._pattern_id = None
self._piece = None
self._possible_piece = None
self._label = None
self._notation = None
self._notation_above = False
self._pixmap = None
self._rect = None
self._theme = None
self._hide_piece = False
self._captured = False
self.invert_colors = False
self.usable = False
def get_captured(self):
return self._captured
def set_captured(self, value):
self._captured = value
self.invalidate()
captured = property(get_captured, set_captured)
def get_label(self):
return self._label
def set_label(self, label):
self._label = label
self.invalidate()
label = property(get_label, set_label)
def get_notation(self):
return self._notation
def set_notation(self, value):
self._notation = value
self.invalidate()
notation = property(get_notation, set_notation)
def get_show_frame(self):
return self._show_frame
def set_show_frame(self, value):
self._show_frame = value
self.invalidate()
show_frame = property(get_show_frame, set_show_frame)
def get_moveable(self):
return self._moveable
def set_moveable(self, value):
self._moveable = value
self.invalidate()
moveable = property(get_moveable, set_moveable)
def get_last_moved(self):
return self._last_moved
def set_last_moved(self, value):
self._last_moved = value
self.invalidate()
last_moved = property(get_last_moved, set_last_moved)
def get_theme(self):
return self._theme
def set_theme(self, theme):
self._theme = theme
self.invalidate()
theme = property(get_theme, set_theme)
def get_notation_above(self):
return self._notation_above
def set_notation_above(self, value):
self._notation_above = value
self.invalidate()
notation_above = property(get_notation_above, set_notation_above)
def get_pattern_id(self):
return self._pattern_id
def set_pattern_id(self, i):
self._pattern_id = i
self.invalidate()
pattern_id = property(get_pattern_id, set_pattern_id)
def get_piece(self):
return self._piece
def set_piece(self, piece):
self._piece = piece
self.invalidate()
piece = property(get_piece, set_piece)
def get_possible_piece(self):
return self._possible_piece
def set_possible_piece(self, piece):
self._possible_piece = piece
self.invalidate()
possible_piece = property(get_possible_piece, set_possible_piece)
def get_hide_piece(self):
return self._hide_piece
def set_hide_piece(self, hide):
self._hide_piece = hide
self.invalidate()
hide_piece = property(get_hide_piece, set_hide_piece)
def get_show_label(self):
return self._show_label
def set_show_label(self, value):
self._show_label = value
self.invalidate()
show_label = property(get_show_label, set_show_label)
def invalidate(self):
self._pixmap = None
def rect(self):
return self._rect
def _draw_piece(self, painter):
piece = self._theme.get_piece(self.piece, invert=self.invert_colors)
possible_piece = self._theme.get_piece(self.possible_piece, invert=self.invert_colors)
if piece is not None and not self.hide_piece:
painter.drawPixmap(0, 0, piece)
elif possible_piece is not None:
painter.setOpacity(0.5)
painter.drawPixmap(0, 0, possible_piece)
painter.setOpacity(1.0)
def _draw(self):
if self._pixmap is not None:
return
self._pixmap = QPixmap(self._rect.width(), self._rect.height())
self._pixmap.fill(Qt.white)
painter = QPainter()
painter.begin(self._pixmap)
if self._pattern_id:
pattern = self._theme.get_pattern(self._pattern_id)
painter.drawPixmap(0, 0, pattern)
if self.show_frame:
frame = self._theme.get_frame()
painter.drawPixmap(0, 0, frame)
elif self.last_moved:
frame = self._theme.get_last_moved()
if frame:
painter.drawPixmap(0, 0, frame)
elif self.moveable:
frame = self._theme.get_moveable()
if frame:
painter.drawPixmap(0, 0, frame)
# notation
painter.setPen(Qt.white)
notation_rect = painter.boundingRect(2, 2, 0, 0, Qt.AlignLeft, self.notation)
if self.notation_above:
self._draw_piece(painter)
if self.show_label:
painter.fillRect(notation_rect, Qt.black)
painter.drawText(notation_rect, Qt.AlignTop | Qt.AlignLeft, self.notation)
else:
if self.show_label:
painter.drawText(notation_rect, Qt.AlignTop | Qt.AlignLeft, self.notation)
self._draw_piece(painter)
if self.captured:
captured = self._theme.get_captured()
painter.drawPixmap(0, 0, captured)
painter.end()
def draw(self, painter, rect):
self._rect = rect
self._draw()
painter.drawPixmap(rect.x(), rect.y(), self._pixmap)
| [
"portnov@bk.ru"
] | portnov@bk.ru |
f743f5a65702a430c6a45ce8a715d6babd8501f4 | f2e902bb1fd05d4f2cda3e5c3a4d3b75cb63d945 | /Exercise5/localization/ParticleCloud.py | 97bfa426e419a5aac5a77f69aea20b4d074f9313 | [] | no_license | CptainWho/AR_MSI_Project | 4576b5d8cec161617a6a98f3c4b2ebbfa8319ff2 | babfcbae5febb33b77e7c7af9c82f48eab5c3f86 | refs/heads/master | 2016-09-01T17:22:06.227714 | 2015-07-21T15:22:17 | 2015-07-21T15:22:17 | 33,983,219 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 15,991 | py | # -*- coding: utf-8 -*-
""" Module ParticleCloud
"""
__project__ = 'Exercise 5'
__module__ = 'ParticleCloud'
__author__ = 'Philipp Lohrer'
__date__ = '16.07.2015'
__version__ = '1.0'
# Standard library imports
from math import pi, sqrt, sin, cos
import bisect
import random
# Local imports
from Exercise5.util import Calculations as Calc
class ParticleCloud:
""" class description:
"""
def __init__(self, world_ref, robot_ref, localization='landmark', draw=None):
"""
:param world_ref: reference of World
:param robot_ref: reference of Robot
:return:
"""
self.particles = []
self.world_ref = world_ref
self.robot_ref = robot_ref
if localization == 'distance_field':
self.localization = 'distance_field'
else:
self.localization = 'landmark'
self.draw_particle = False
self.draw_number = False
self.draw_estimation = False
if draw == 'particle':
self.draw_particle = True
elif draw == 'particle_number':
self.draw_particle = True
self.draw_number = True
elif draw == 'estimation':
self.draw_estimation = True
elif draw == 'particle_estimation':
self.draw_particle = True
self.draw_estimation = True
# Robot parameters [v_max, omega_max, noise_d, noise_theta, noise_drift, time_step]
self.motion_params = self.robot_ref.getMotionParams()
self.sum_weight_particles = 0
self.sum_weight_particles_normed = 0
# Estimated robot location
self.est_robot_pos = None
self.theta_est_old = 0
def __iter__(self):
return iter(self.particles)
def __len__(self):
return len(self.particles)
def __contains__(self, particle):
return True if particle in self.particles else False
def add_particle(self, x, y, theta, number=None):
if number is None or number < len(self.particles):
number = len(self.particles)
particle = Particle(number, x, y, theta, self.world_ref)
self.append(particle)
def append(self, particle):
self.particles.append(particle)
# Draw Particle in world
if self.draw_particle:
# Draw particle in world
particle.draw(draw_number=self.draw_number)
def remove(self, particle):
self.particles.remove(particle)
# Undraw particle in world
if self.draw_particle:
# Undraw particle in world
particle.undraw()
def update(self, particles):
""" Delete all elements in current particle_cloud and set up new particle_cloud
:param particles: (list) particles
:return:
"""
if self.draw_particle:
for particle in self.particles:
particle.undraw()
self.particles = particles
if self.draw_particle:
for particle in self.particles:
particle.draw(draw_number=self.draw_number)
def create_particles(self, amount, position=None):
""" Create and randomly place a given amount of particles in given world's boundaries
If given position is not None, place particles at give position.
:param amount: (int) amount of particles to create
:param position: [x, y, theta]
:return: -
"""
size_world = self.world_ref.get_size()
for n in xrange(int(amount)):
if position is None:
# Random particle position
p_x = round(random.random() * size_world[0], 2)
p_y = round(random.random() * size_world[1], 2)
p_theta = random.random() * 2 * pi
if p_theta > pi:
p_theta -= 2 * pi
else:
# Place particle at given position
p_x, p_y, p_theta = position
# Append particle to particle_cloud
self.add_particle(p_x, p_y, p_theta)
def move_particles(self, motion):
""" Move all particles
:param motion: [v, omega]
:return: -
"""
# counter = 0
for particle in self.particles:
# rnd = True if counter % 50 == 0 else False
# counter += 1
particle.move(motion, self.motion_params, random_movement=False)
if self.draw_particle:
# Redraw particle in world
particle.undraw()
particle.draw(draw_number=self.draw_number)
def weight_particles(self, landmark_positions=None, sensor_data=None, laser_sensor_data=None, likelihoodfield=None, debug=False):
""" Calculate weight for each particle
:param landmark_positions:
:param sensor_data:
:return:
"""
self.sum_weight_particles = 0
if self.localization == 'landmark' and landmark_positions is not None and sensor_data is not None:
landmark_numbers, landmark_distances, landmark_angles = sensor_data
for particle in self.particles:
weight = particle.calculate_weight_landmarks(landmark_positions, landmark_distances, landmark_angles, debug=debug)
self.sum_weight_particles += weight
elif self.localization == 'distance_field' and laser_sensor_data is not None and laser_sensor_data is not None:
for particle in self.particles:
weight = particle.calculate_weight_beams(laser_sensor_data, likelihoodfield)
self.sum_weight_particles += weight
def get_weight_particles(self):
""" Returns the weight of all particles normed between [0...1]
Sum of all weights is 1.0
:return: (list) weights [w1, w2, ..., w_n]
"""
weight_list = []
# best_weight = 0
# best_weight_index = 0
self.sum_weight_particles_normed = 0
for particle in self.particles:
weight = particle.get_weight()
# Change weight order
weight = (1 - weight)
weight_list.append(weight)
return weight_list
def resample(self, debug=False):
"""
:param debug: default=False
:return:
"""
# 1. Set up empty particle_cloud
particles_resampled = []
# 2. Calculate weight for each particle
weights = self.get_weight_particles()
if debug:
for i, weight in enumerate(weights):
print '\tWeight particle %d: %0.5f' % (i, weight)
# 3. Initialize WeightedRandomGenerator with weights
wrg = WeightedRandomGenerator(weights)
indexes = []
# 4. Resample particles
for i in xrange(len(self)):
# 4.1 Pick one particle randomly via weighted choice
# particle = np.random.choice(self.particles, p=weights)
index = wrg()
indexes.append(index)
try:
particle = self.particles[index]
except IndexError as e:
print e
if debug:
print '\tResampling: selected particle: %d' % particle.get_number()
# 4.2 Create new particle with parameters of selected particle
p_x, p_y, p_theta = particle.get_pos()
particle_new = Particle(i, p_x, p_y, p_theta, self.world_ref)
# 4.3 Append new particle to resampled particle_cloud
particles_resampled.append(particle_new)
# 4. Update particles
self.update(particles_resampled)
def get_est_location(self):
""" Calculate estimated robot location via mean values of particle locations
:return: estimated location of robot due to particle locations
"""
x_est, y_est, theta_est = [0, 0, 0]
list_angle = []
for particle in self.particles:
p_x, p_y, p_theta = particle.get_pos()
x_est += p_x
y_est += p_y
list_angle.append(p_theta)
# Calculate average angle
theta_est = Calc.get_average_angle(list_angle)
# If average_angle is None (= not defined), use old theta_est
if theta_est is None:
theta_est = self.theta_est_old
x_est /= float(len(self.particles))
y_est /= float(len(self.particles))
if self.draw_estimation:
self.world_ref.draw_estimated_position(x_est, y_est, theta_est)
return [x_est, y_est, theta_est]
class Particle:
""" class description:
"""
def __init__(self, number, x, y, theta, world_ref):
""" Initialize particle
:param x: coord
:param y: coord
:param theta: angle (orientation)
:param world_ref: world reference
:return:
"""
self.number = number
self.x, self.y, self.theta = x, y, theta
self.world_ref = world_ref
self.particle_weight = 1
# noises
self.likelihood_dist_noise = 0.01
def get_pos(self):
return [self.x, self.y, self.theta]
def set_pos(self, x, y, theta):
self.x, self.y, self.theta = x, y, theta
def get_theta(self):
return self.theta
def get_number(self):
return self.number
def get_weight(self):
return self.particle_weight
def set_weight(self, weight):
self.particle_weight = weight
def draw(self, draw_number=False):
number = None
if draw_number:
number = self.get_number()
self.world_ref.draw_particle(self, color='black', number=number)
def undraw(self):
self.world_ref.undraw_particle(self)
def move(self, motion, motion_params, random_movement=False):
""" Move particle in a way similar to Robot.move() and save new particle position
:param motion: [v, omega]
:param motion_params [v_max, omega_max, noise_d, noise_theta, noise_drift, time_step]
:param random_movement: default=False
:return: -
"""
v_max, omega_max, noise_d, noise_theta, noise_drift, time_step = motion_params
# Add gain to noise
noise_d *= 2.0
noise_theta *= 2.0
noise_drift *= 2.0
if random_movement:
v_noisy = random.random() * v_max
omega_noisy = random.random() * omega_max
if random.random() < 0.5:
omega_noisy *= -1.0
else:
v = motion[0]
omega = motion[1]
# translational and rotational speed is limited:
if omega > omega_max:
omega = omega_max
if omega < -omega_max:
omega = -omega_max
if v > v_max:
v = v_max
if v < -v_max:
v = -v_max
# Add noise to v:
sigma_v_2 = (noise_d / time_step) * abs(v)
v_noisy = v + random.gauss(0.0, sqrt(sigma_v_2))
# Add noise to omega:
sigma_omega_tr_2 = (noise_theta / time_step) * abs(omega) # turning rate noise
sigma_omega_drift_2 = (noise_drift / time_step) * abs(v) # drift noise
omega_noisy = omega + random.gauss(0.0, sqrt(sigma_omega_tr_2))
omega_noisy += random.gauss(0.0, sqrt(sigma_omega_drift_2))
# Move particle in the world (with noise):
d_noisy = v_noisy * time_step
d_theta_noisy = omega_noisy * time_step
# Get current particle position
x, y, theta = self.get_pos()
dx = d_noisy * cos(theta + 0.5 * d_theta_noisy)
dy = d_noisy * sin(theta + 0.5 * d_theta_noisy)
theta_new = (theta + d_theta_noisy) % (2 * pi)
### Test
# rnd_x = random.random() * 0.05
# dx += rnd_x if random.random() > 0.5 else (- 1.0 * rnd_x)
# rnd_y = random.random() * 0.01
# dy += rnd_y if random.random() > 0.5 else (- 1.0 * rnd_y)
# Update particle position
self.set_pos(x+dx, y+dy, theta_new)
# self.world_ref.move_particle(self, d_noisy, d_theta_noisy, time_step)
def calculate_weight_landmarks(self, landmark_positions, landmark_distances, landmark_angles, debug=False):
"""
:param landmark_positions: landmark positions [[x1, y1], [x2, y2], ..., [x_n, y_n]]
:param landmark_distances: measured distance from robot to landmark [dist1, dist2, ..., dist_n]
:param landmark_angles: measured angle from robot to landmark [theta1, theta2, ..., theta_n]
:return: (float) particle_weight
"""
# Reset weight
self.particle_weight = 1
if debug:
print 'Particle %d:' % self.number
print '\tp_theta = %0.2f' % (self.theta / pi * 180.0)
for i in xrange(len(landmark_positions)):
# Calculate estimated distance and angle from particle to given landmark
est_dist_to_landmark = Calc.get_dist_from_point_to_point([self.x, self.y], landmark_positions[i])
est_angle_to_landmark = Calc.get_angle_from_point_to_point([self.x, self.y], landmark_positions[i])
rel_angle_to_landmark = Calc.diff(self.theta, est_angle_to_landmark)
# Calculate particle_weight
dist = abs(landmark_distances[i] - est_dist_to_landmark)
dist += random.gauss(0.0, sqrt(0.01 ** 2 * dist))
d_theta = abs(Calc.add_angles(landmark_angles[i], -rel_angle_to_landmark))
d_theta += random.gauss(0.0, sqrt(0.01 ** 2 * d_theta))
self.particle_weight = self.particle_weight * dist * d_theta
if debug:
print '\test dist to landmark %d: %0.2f' % (i, est_dist_to_landmark),
print '--> diff = %0.2f' % (landmark_distances[i] - est_dist_to_landmark)
print '\test angle to landmark %d: %0.2f' % (i, rel_angle_to_landmark / pi * 180.0),
print '--> diff = %0.2f' % (Calc.add_angles(landmark_angles[i], -rel_angle_to_landmark) / pi * 180)
print '\t\t--> resulting weight: %0.8f' % self.particle_weight
return self.particle_weight
def calculate_weight_beams(self, laser_sensor_data, likelihoodfield):
"""
:param laser_sensor_data: data from the laser sensors (distance and angle)
:param likelihoodfield: the brushfire grid that is used for the distance to next wall
:return: calculated weight in reverse (0 => highest weight)
"""
p=1
# go through all data points
for [distance, angle] in laser_sensor_data:
# obstacle point from particle position
lokal_obstacle_point = Calc.polar_2_cartesian(distance, angle)
x_z = lokal_obstacle_point[0] + self.x
y_z = lokal_obstacle_point[1] + self.y
obstacle_point = [x_z, y_z]
# get distance value from likelihoodfield
dist_val = 1.0 - likelihoodfield.getValue(obstacle_point)
# apply gauss curve
sigma2 = self.likelihood_dist_noise ** 2 * dist_val
dist_val += random.gauss(0.0, sqrt(sigma2))
p *= dist_val
self.particle_weight = 1 - p
return self.particle_weight
class WeightedRandomGenerator(object):
"""
source: http://eli.thegreenplace.net/2010/01/22/weighted-random-generation-in-python
"""
def __init__(self, weights):
self.totals = []
running_total = 0
for w in weights:
running_total += w
self.totals.append(running_total)
def next(self):
rnd = random.random() * self.totals[-1]
index = bisect.bisect_right(self.totals, rnd)
return index # len(self.totals) - 1 if index >= len(self.totals) else index
def __call__(self):
return self.next()
| [
"phlohrer@htwg-konstanz.de"
] | phlohrer@htwg-konstanz.de |
3fbb4786ff15759eb93e82bc5ad3d7e00e55e2b8 | ebd5c4632bb5f85c9e3311fd70f6f1bf92fae53f | /Sourcem8/pirates/quest/DialogProcess.py | dd929c9b374131c5d5005f5d444192c13516197e | [] | no_license | BrandonAlex/Pirates-Online-Retribution | 7f881a64ec74e595aaf62e78a39375d2d51f4d2e | 980b7448f798e255eecfb6bd2ebb67b299b27dd7 | refs/heads/master | 2020-04-02T14:22:28.626453 | 2018-10-24T15:33:17 | 2018-10-24T15:33:17 | 154,521,816 | 2 | 1 | null | null | null | null | UTF-8 | Python | false | false | 17,677 | py | from direct.showbase.PythonUtil import makeTuple
from pirates.piratesbase.PythonUtil import POD
from direct.showbase.DirectObject import DirectObject
from direct.interval.IntervalGlobal import *
from direct.gui.DirectGui import *
from pandac.PandaModules import *
from pirates.piratesgui import PiratesGuiGlobals
from pirates.piratesgui import GuiButton
from pirates.piratesbase import PiratesGlobals
from pirates.piratesbase import PLocalizer
from pirates.quest import QuestOffer
from pirates.quest.QuestPrereq import *
from pirates.effects import CombatEffect
from pirates.audio import SoundGlobals
from pirates.audio.SoundGlobals import loadSfx
class DialogProcess(POD, DirectObject):
DataSet = {
'prereq': [],
'dialogId': None,
'delayCleanup': False }
def avCanParticipate(self, av):
for prereq in self.prereq:
if not prereq.avIsReady(av):
return False
continue
return True
def avCanParticipateAI(self, av):
for prereq in self.prereq:
if not prereq.avIsReadyAI(av):
return False
continue
return True
def handleEscapeKey(self):
pass
def begin(self, npc, dialogId):
self.accept('escape', self.handleEscapeKey)
self.dialogId = dialogId
self.npc = npc
def end(self):
self.ignore('escape')
messenger.send('DialogProcessEnded')
def cleanup(self):
pass
class Prereq(DialogProcess):
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
self.end()
class NPCDialog(DialogProcess):
DataSet = {
'textId': None }
def _NPCDialog__getDialogText(self):
return PLocalizer.DialogStringDict.get(self.dialogId).get(self.textId).get('dialog')
def _NPCDialog__getDialogEmotes(self):
return PLocalizer.DialogStringDict.get(self.dialogId).get(self.textId).get('emotes')
def _NPCDialog__handleNextChatPage(self, pageNumber, elapsed):
if pageNumber == base.localAvatar.guiMgr.dialogSubtitler.getNumChatPages() - 1:
localAvatar.guiMgr.dialogSubtitler.confirmButton.hide()
self.ignore('nextChatPage')
self.end()
else:
self._NPCDialog__playAnimation(pageNumber)
def _NPCDialog__playAnimation(self, index):
if self.animationIval:
self.animationIval.finish()
self.animationIval = None
if self.dialogAnimSet:
if len(self.dialogAnimSet) > index and self.dialogAnimSet[index]:
self.npc.gameFSM.request('Emote')
self.npc.playEmote(self.dialogAnimSet[index])
def cleanup(self):
self.ignore('nextChatPage')
self.ignore('doneChatPage')
if self.dialogBox:
self.dialogBox.remove_node()
if self.nametagLabel:
self.nametagLabel.destroy()
def handleEscapeKey(self):
localAvatar.guiMgr.dialogSubtitler.advancePageNumber()
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
self.animationIval = None
self.dialogAnimSet = []
self.defaultAnim = None
self.dialogBox = loader.loadModel('models/gui/pir_m_gui_frm_questChat')
self.dialogBox.reparentTo(aspect2d)
self.dialogBox.setScale(25.5)
self.dialogBox.setPos(-0.48, 0, -0.58)
self.dialogBox.find('**/pointer_left').hide()
self.dialogBox.find('**/pointer_none').hide()
self.dialogBox.setBin('gui-fixed', 0)
self.nametagLabel = DirectLabel(parent = aspect2d, relief = None, text = self.npc.getName(), text_font = PiratesGlobals.getPirateFont(), text_shadow = PiratesGuiGlobals.TextShadow, text_align = TextNode.ARight, text_fg = PiratesGuiGlobals.TextFG8, text_scale = 0.055, pos = (0.3, 0, -0.44))
self.nametagLabel.setBin('gui-fixed', 1)
dialogStr = self._NPCDialog__getDialogText()
self.dialogAnimSet = self._NPCDialog__getDialogEmotes()
localAvatar.guiMgr.dialogSubtitler.setPageChat(dialogStr)
self._NPCDialog__playAnimation(0)
if localAvatar.guiMgr.dialogSubtitler.getNumChatPages() == 1:
self._NPCDialog__handleNextChatPage(0, 0)
else:
self.accept('nextChatPage', self._NPCDialog__handleNextChatPage)
self.accept('doneChatPage', self.end)
def end(self):
if self.animationIval:
self.animationIval.finish()
self.animationIval = None
DialogProcess.end(self)
class PlayerDialog(DialogProcess):
DataSet = {
'textId': 0 }
def _PlayerDialog__getDialogText(self):
return PLocalizer.DialogStringDict.get(self.dialogId).get(self.textId).get('dialog')
def _PlayerDialog__getDialogEmotes(self):
return PLocalizer.DialogStringDict.get(self.dialogId).get(self.textId).get('emotes')
def _PlayerDialog__handleNextChatPage(self, pageNumber, elapsed):
if pageNumber == base.localAvatar.guiMgr.dialogSubtitler.getNumChatPages() - 1:
localAvatar.guiMgr.dialogSubtitler.confirmButton.hide()
self.ignore('nextChatPage')
self.end()
else:
self._PlayerDialog__playAnimation(pageNumber)
def _PlayerDialog__playAnimation(self, index):
if self.animationIval:
self.animationIval.finish()
self.animationIval = None
if self.dialogAnimSet:
if not self.defaultAnim:
self.defaultAnim = self.npc.getCurrentAnim()
if len(self.dialogAnimSet) > index and self.dialogAnimSet[index]:
localAvatar.playEmote(self.dialogAnimSet[index])
def cleanup(self):
self.ignore('nextChatPage')
self.ignore('doneChatPage')
localAvatar.guiMgr.dialogSubtitler.clearText()
if self.dialogBox:
self.dialogBox.remove_node()
if self.nametagLabel:
self.nametagLabel.destroy()
def handleEscapeKey(self):
localAvatar.guiMgr.dialogSubtitler.advancePageNumber()
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
self.animationIval = None
self.dialogAnimSet = []
self.defaultAnim = None
self.dialogBox = loader.loadModel('models/gui/pir_m_gui_frm_questChat')
self.dialogBox.reparentTo(aspect2d)
self.dialogBox.setScale(25.5)
self.dialogBox.setPos(-0.48, 0, -0.58)
self.dialogBox.find('**/pointer_right').hide()
self.dialogBox.find('**/pointer_none').hide()
self.dialogBox.setBin('gui-fixed', 0)
self.nametagLabel = DirectLabel(parent = aspect2d, relief = None, text = localAvatar.getName(), text_font = PiratesGlobals.getPirateFont(), text_shadow = PiratesGuiGlobals.TextShadow, text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG8, text_scale = 0.055, pos = (-0.6, 0, -0.44))
self.nametagLabel.setBin('gui-fixed', 1)
dialogStr = self._PlayerDialog__getDialogText()
self.dialogAnimSet = self._PlayerDialog__getDialogEmotes()
localAvatar.guiMgr.dialogSubtitler.setPageChat(dialogStr)
self._PlayerDialog__playAnimation(0)
if localAvatar.guiMgr.dialogSubtitler.getNumChatPages() == 1:
self._PlayerDialog__handleNextChatPage(0, 0)
else:
self.accept('nextChatPage', self._PlayerDialog__handleNextChatPage)
self.accept('doneChatPage', self.end)
class StepChoice(DialogProcess):
DataSet = {
'choices': tuple() }
def _StepChoice__getDialogChoiceText(self, stepId, index = 0):
DialogDict = DialogDict
import pirates.quest.DialogTree
textId = DialogDict.get(self.npc.getUniqueId()).get(self.dialogId).get(stepId)[index].getTextId()
if 'choice' in PLocalizer.DialogStringDict.get(self.dialogId).get(textId):
return PLocalizer.DialogStringDict.get(self.dialogId).get(textId).get('choice')
else:
return PLocalizer.DialogStringDict.get(self.dialogId).get(textId).get('dialog')
def highlightIcon(self, buttonIndex, event):
self.choiceButtons[buttonIndex]['image_color'] = PiratesGuiGlobals.TextFG8
def unhighlightIcon(self, buttonIndex, event):
self.choiceButtons[buttonIndex]['image_color'] = PiratesGuiGlobals.TextFG2
def buttonClicked(self, stepId):
messenger.send('SwitchStep', [
stepId])
def handleEscapeKey(self):
pass
def displayStepChoices(self):
DialogDict = DialogDict
import pirates.quest.DialogTree
self.choiceLabels = []
self.choiceButtons = []
gui = loader.loadModel('models/gui/compass_main')
choiceIcon = gui.find('**/icon_sphere')
for i in xrange(len(self.choices)):
index = 0
process = DialogDict.get(self.npc.getUniqueId()).get(self.dialogId).get(self.choices[i])[index]
while not isinstance(process, PlayerDialog):
index += 1
process = DialogDict.get(self.npc.getUniqueId()).get(self.dialogId).get(self.choices[i])[index]
while not process.avCanParticipate(localAvatar):
index += 1
process = DialogDict.get(self.npc.getUniqueId()).get(self.dialogId).get(self.choices[i])[index]
if process.avCanParticipate(localAvatar) and isinstance(process, PlayerDialog):
choiceButton = GuiButton.GuiButton(parent = aspect2d, relief = None, text = self._StepChoice__getDialogChoiceText(self.choices[i], index), text_font = PiratesGlobals.getPirateFont(), text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = None, text_align = TextNode.ALeft, text_scale = 0.055, text0_fg = PiratesGuiGlobals.TextFG2, text1_fg = PiratesGuiGlobals.TextFG8, text2_fg = PiratesGuiGlobals.TextFG8, text3_fg = PiratesGuiGlobals.TextFG9, image = choiceIcon, image_scale = 0.29999999999999999, image_pos = (-0.050000000000000003, 0, 0.0070000000000000001), geom = None, pos = (-1.1499999999999999, 0, -0.47999999999999998 - i * 0.074999999999999997), command = self.buttonClicked, extraArgs = [
self.choices[i]])
choiceButton.setBin('gui-fixed', 1)
choiceButton.bind(DGG.ENTER, self.highlightIcon, extraArgs = [
i])
choiceButton.bind(DGG.EXIT, self.unhighlightIcon, extraArgs = [
i])
self.choiceButtons.append(choiceButton)
continue
def cleanUpStepChoices(self):
for button in self.choiceButtons:
button.destroy()
self.choiceButtons = []
def cleanup(self):
self.cleanUpStepChoices()
if self.dialogBox:
self.dialogBox.remove_node()
self.dialogBox = None
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
self.dialogBox = loader.loadModel('models/gui/pir_m_gui_frm_questChat')
self.dialogBox.reparentTo(aspect2d)
self.dialogBox.setScale(25.5)
self.dialogBox.setPos(-0.48, 0, -0.58)
self.dialogBox.find('**/pointer_left').hide()
self.dialogBox.find('**/pointer_right').hide()
self.dialogBox.setBin('gui-fixed', 0)
self.displayStepChoices()
localAvatar.guiMgr.dialogSubtitler.confirmButton.hide()
class SwitchStep(DialogProcess):
DataSet = {
'stepId': 0 }
class ExitDialog(DialogProcess):
def begin(self, npc, dialogId):
npc.requestExit()
self.end()
class OfferQuest(DialogProcess):
DataSet = {
'questId': None }
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
self.acceptOnce('setDialogQuestOffer', self._OfferQuest__gotQuestOffer)
npc.requestDialogQuestOffer(self.questId, dialogId)
def _OfferQuest__gotQuestOffer(self):
def handleOption(option):
if option == PLocalizer.Accept:
self.npc.assignDialogQuestOffer()
self.end()
self.npc.showDialogQuestOffer()
localAvatar.guiMgr.dialogSubtitler.setPageChat('', options = [
PLocalizer.Decline,
PLocalizer.Accept], callback = handleOption)
def handleEscapeKey(self):
pass
class AssignQuest(DialogProcess):
DataSet = {
'questId': None }
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
self.acceptOnce('setDialogQuestOffer', self._AssignQuest__gotQuestAssigned)
npc.requestDialogQuestAssignment(self.questId, dialogId)
def end(self):
self.npc.cleanUpQuestDetails()
DialogProcess.end(self)
def _AssignQuest__gotQuestAssigned(self):
def handleOption(option):
self.end()
self.npc.showDialogQuestOffer()
localAvatar.guiMgr.dialogSubtitler.setPageChat('', options = [
PLocalizer.Accept], callback = handleOption)
def handleEscapeKey(self):
pass
class AdvanceQuest(DialogProcess):
DataSet = {
'questId': None }
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
npc.requestDialogQuestAdvancement(self.questId, dialogId)
self.end()
class ShowGivenQuest(DialogProcess):
def begin(self, npc, dialogId):
npc.displayNewQuests()
def handleEscapeKey(self):
pass
class ShowRewards(DialogProcess):
def begin(self, npc, dialogId):
npc.showQuestRewards()
self.end()
class HideRewards(DialogProcess):
def begin(self, npc, dialogId):
npc.hideQuestRewards()
self.end()
class MakeNPCHostile(DialogProcess):
DataSet = {
'npcId': None }
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
npc.requestNPCHostile(self.npcId, dialogId)
self.end()
class PlayCombatEffectOnNPC(DialogProcess):
DataSet = {
'effectId': None }
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
combatEffect = CombatEffect.CombatEffect(self.effectId, attacker = localAvatar)
combatEffect.reparentTo(render)
combatEffect.setPos(npc.getPos(render) + Point3(0, 0, 2.5))
combatEffect.play()
self.end()
class FadeOutGhost(DialogProcess):
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
npc.fadeOutGhost()
self.end()
class Delay(DialogProcess):
DataSet = {
'duration': 0 }
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
taskMgr.doMethodLater(self.duration, self.endWaitTask, 'endDialogProcess')
def endWaitTask(self, task):
self.end()
def cleanup(self):
taskMgr.remove('endDialogProcess')
class SwitchVisualModeNPC(DialogProcess):
DataSet = {
'mode': None,
'skipHide': False }
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
npc.switchVisualMode(self.mode, self.skipHide)
self.end()
class PlayNPCEmote(DialogProcess):
DataSet = {
'emoteId': None,
'npcId': None }
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
if self.npcId:
npcDoId = base.cr.uidMgr.getDoId(self.npcId)
self.npc = base.cr.doId2do.get(npcDoId)
self.npc.gameFSM.request('Emote')
self.npc.playEmote(self.emoteId)
self.end()
class PlayPlayerEmote(DialogProcess):
DataSet = {
'emoteId': None }
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
localAvatar.playEmote(self.emoteId)
self.end()
class PlayerDrawPistolAndAim(DialogProcess):
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
weaponId = 2001
Pistol = Pistol
import pirates.battle
localAvatar.dialogProp = Pistol.Pistol(weaponId)
self.animIval = Sequence(localAvatar.dialogProp.getDrawIval(localAvatar), Func(localAvatar.loop, 'gun_aim_idle'), Func(self.end)).start()
def end(self):
if self.animIval:
self.animIval.pause()
self.animIval = None
DialogProcess.end(self)
def cleanup(self):
if localAvatar.dialogProp:
localAvatar.dialogProp.detachNode()
class PlayerHidePistol(DialogProcess):
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
self.animIval = None
if localAvatar.dialogProp:
self.animIval = Sequence(localAvatar.dialogProp.getReturnIval(localAvatar), Func(localAvatar.loop, 'idle'), Func(self.end)).start()
else:
self.end()
def end(self):
if self.animIval:
self.animIval.pause()
self.animIval = None
localAvatar.dialogProp = None
DialogProcess.end(self)
class PlayChickenFly(DialogProcess):
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
self.npc.play('fly', startFrame = 20)
self.end()
class PlaySfx(DialogProcess):
DataSet = {
'sfxId': None }
sfxList = {
SoundGlobals.SFX_SKILL_CLEANSE: loadSfx(SoundGlobals.SFX_SKILL_CLEANSE) }
def begin(self, npc, dialogId):
DialogProcess.begin(self, npc, dialogId)
sfx = self.sfxList.get(self.sfxId)
base.playSfx(sfx, volume = 0.75)
self.end()
| [
"brandoncarden12345@gmail.com"
] | brandoncarden12345@gmail.com |
7c670fb44e9d7883ba0da7fba534ff88954e8da3 | 5a6efaabc2de2ca7abe30050c0533fae84c897e2 | /cfHelper.py | 5fbb6c4ef7b33064aaafe1ec3424001a326cdb7f | [
"MIT"
] | permissive | Just-kiy/contestHelper | 263a3130ae6c3f08aa4fd22d0762a01a29995c11 | 36649b023dff73dadc7e3f2070ac545d00773d10 | refs/heads/master | 2020-05-03T02:25:25.109519 | 2015-08-08T17:54:53 | 2015-08-08T17:54:53 | 40,411,081 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,848 | py | # coding : utf8
__author__ = 'Kovaler'
import os
import sys
import shutil
import argparse
TEMPLATE_NAME = 'header.cpp'
default_folder = os.getcwd()
default_problem_set = "ABCDE"
default_contest_name = "CF Round #300"
def create_contest(name, problems, folder):
"""Creating directory with contest name, then creating folders for all problems in problem set
and copying header to source files. Template header should be located in the same directory as script """
contest_folder = os.sep.join([folder, name])
os.mkdir(contest_folder)
for problem in problems:
problem_folder = os.sep.join([contest_folder, problem])
print(problem_folder)
os.mkdir(problem_folder)
shutil.copy(os.sep.join([os.getcwd(), TEMPLATE_NAME]), problem_folder)
os.rename(os.sep.join([problem_folder, TEMPLATE_NAME]), os.sep.join([problem_folder, problem])+'.cpp')
def create_path(path):
""" Checking for chosen folder. If the path does not exists, then will create it """
print(path)
if not os.path.exists(path):
os.makedirs(path)
return
def create_parser():
parser = argparse.ArgumentParser()
parser.add_argument('-n', '--name', default=default_contest_name)
parser.add_argument('-p', '--problem_set', default=default_problem_set)
parser.add_argument('-f', '--folder', default=default_folder)
return parser
if __name__ == '__main__':
arg_parser = create_parser()
args = arg_parser.parse_args(sys.argv[1:])
contest_name = args.name
problem_set = args.problem_set
active_folder = args.folder
if len(problem_set) == 1:
char = problem_set
problem_set = [chr(i) for i in xrange(ord('A'), ord(char.upper()) + 1)]
print problem_set
create_path(active_folder)
create_contest(contest_name, problem_set, active_folder)
| [
"kovaler.kun@gmail.com"
] | kovaler.kun@gmail.com |
220d2369e9819542e4cee0bc7be2700232947c7b | 260238540e21529ecb0db3eba1a395f26b4d4023 | /aionApp/migrations/0020_auto_20180311_1528.py | 024345635f8da2be8278b36409c272b7544be343 | [] | no_license | dexvillar/SECPROG | 0284bd0d23596859a8aec31bf3d2c6296d86aa6c | 0f68bdeefdb65e9ac211dccc9cd83f6250acf9d2 | refs/heads/master | 2021-04-27T00:11:27.004493 | 2018-04-19T23:52:27 | 2018-04-19T23:52:27 | 123,765,412 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 399 | py | # -*- coding: utf-8 -*-
# Generated by Django 1.11.10 on 2018-03-11 15:28
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('aionApp', '0019_auto_20180311_1505'),
]
operations = [
migrations.RenameModel(
old_name='buy_watche',
new_name='hello',
),
]
| [
"dextervillar55@gmail.com"
] | dextervillar55@gmail.com |
d22cf8a285c59ddf0e21693168cc10d8de3a8edf | 0729155365ebd2e8761068bda78060f0c2d6e6a7 | /Class And Object Programs/3__Calculate the Area and Perimeter of Circle Using The Class.py | 412cc99095898ee61f62e70e3823075e3ba7c024 | [] | no_license | mukeshrock7897/Class-And-Object-Programs | a0ce41b19ebdd87bb037ca742069f98c59c21847 | a6cf378ab4c5a3d95a46867b5414b44955838782 | refs/heads/master | 2020-04-24T05:04:53.234277 | 2019-02-20T18:10:25 | 2019-02-20T18:10:25 | 171,724,815 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 378 | py | import math
class Circle:
def __init__(self,radius):
self.radius=radius
def area(self):
return math.pi*(self.radius**2)
def perimeter(self):
return 2*math.pi*self.radius
radius=int(input("Enter The Radius Of Circle::"))
obj=Circle(radius)
print("Area Of Circle::",round(obj.area(),2))
print("Perimeter of Circle::",round(obj.perimeter(),2))
| [
"mukeshrock7897@gmail.com"
] | mukeshrock7897@gmail.com |
22f2f5ecdd5deb9467fd7e1469f2b3a16d971d5a | 1bd2535e12d10c9a6def7777c48c33c0161d1226 | /image_capture.py | bb313526d973dc9e1d87f7b7355b84ef5f344c84 | [] | no_license | bensonmat8/MyDroneProject | c8dcd922c577e76f0d092377312faa61d42cb8e7 | 568b59b277020506dfa9935a8f9629d34f0cb32c | refs/heads/main | 2023-05-01T08:29:12.835352 | 2021-05-12T22:36:15 | 2021-05-12T22:36:15 | 342,456,044 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 244 | py | from djitellopy import tello
from time import sleep
import cv2
me = tello.Tello()
me.connect()
me.streamon()
while True:
img = me.get_frame_read().frame
img = cv2.resize(img, (360, 240))
cv2.imshow('Image', img)
cv2.waitKey(2) | [
"37485710+bensonmat8@users.noreply.github.com"
] | 37485710+bensonmat8@users.noreply.github.com |
d853b47dc9a4bf084492eabbba8965446909f80b | 4c194be07ed4a8d0694e84ff79b8c19dbad90b0e | /libs/utils/getFreeProxy.py | 334d5b298a76d5a9d2b312470d1a7fc435a6cf4d | [] | no_license | zhangtao7750/proxy_pool_tornado | 17db2dcfe59593d985089cebe2ff7ef9484ba3d6 | ca4874f4b9003723439af3c5cb2784047bddd182 | refs/heads/master | 2021-10-09T09:35:04.025323 | 2018-12-25T09:45:06 | 2018-12-25T09:45:06 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 10,805 | py | """
-------------------------------------------------
File Name： GetFreeProxy.py
Description : 抓取免费代理
Author : Tc
date： 2018/12/24
-------------------------------------------------
"""
import re
import sys
import requests
from WebRequest import WebRequest
from utilFunction import getHtmlTree
# for debug to disable insecureWarning
requests.packages.urllib3.disable_warnings()
"""
66ip.cn
data5u.com
xicidaili.com
goubanjia.com
xdaili.cn
kuaidaili.com
cn-proxy.com
proxy-list.org
www.mimiip.com to do
"""
class GetFreeProxy(object):
"""
proxy getter
"""
@staticmethod
def freeProxyFirst(page=10):
"""
无忧代理 http://www.data5u.com/
几乎没有能用的
:param page: 页数
:return:
"""
url_list = [
'http://www.data5u.com/',
'http://www.data5u.com/free/gngn/index.shtml',
'http://www.data5u.com/free/gnpt/index.shtml'
]
for url in url_list:
html_tree = getHtmlTree(url)
ul_list = html_tree.xpath('//ul[@class="l2"]')
for ul in ul_list:
try:
yield ':'.join(ul.xpath('.//li/text()')[0:2])
except Exception as e:
print(e)
@staticmethod
def freeProxySecond(area=33, page=1):
"""
代理66 http://www.66ip.cn/
:param area: 抓取代理页数，page=1北京代理页，page=2上海代理页......
:param page: 翻页
:return:
"""
area = 33 if area > 33 else area
for area_index in range(1, area + 1):
for i in range(1, page + 1):
url = "http://www.66ip.cn/areaindex_{}/{}.html".format(
area_index, i)
html_tree = getHtmlTree(url)
tr_list = html_tree.xpath(
"//*[@id='footer']/div/table/tr[position()>1]")
if len(tr_list) == 0:
continue
for tr in tr_list:
yield tr.xpath("./td[1]/text()")[0] + ":" + tr.xpath(
"./td[2]/text()")[0]
break
@staticmethod
def freeProxyThird(days=1):
"""
ip181 http://www.ip181.com/ 不能用了
:param days:
:return:
"""
url = 'http://www.ip181.com/'
html_tree = getHtmlTree(url)
try:
tr_list = html_tree.xpath('//tr')[1:]
for tr in tr_list:
yield ':'.join(tr.xpath('./td/text()')[0:2])
except Exception as e:
pass
@staticmethod
def freeProxyFourth(page_count=2):
"""
西刺代理 http://www.xicidaili.com
:return:
"""
url_list = [
'http://www.xicidaili.com/nn/', # 高匿
'http://www.xicidaili.com/nt/', # 透明
]
for each_url in url_list:
for i in range(1, page_count + 1):
page_url = each_url + str(i)
tree = getHtmlTree(page_url)
proxy_list = tree.xpath(
'.//table[@id="ip_list"]//tr[position()>1]')
for proxy in proxy_list:
try:
yield ':'.join(proxy.xpath('./td/text()')[0:2])
except Exception as e:
pass
@staticmethod
def freeProxyFifth():
"""
guobanjia http://www.goubanjia.com/
:return:
"""
url = "http://www.goubanjia.com/"
tree = getHtmlTree(url)
proxy_list = tree.xpath('//td[@class="ip"]')
# 此网站有隐藏的数字干扰，或抓取到多余的数字或.符号
# 需要过滤掉<p style="display:none;">的内容
xpath_str = """.//*[not(contains(@style, 'display: none'))
and not(contains(@style, 'display:none'))
and not(contains(@class, 'port'))
]/text()
"""
for each_proxy in proxy_list:
try:
# :符号裸放在td下，其他放在div span p中，先分割找出ip，再找port
ip_addr = ''.join(each_proxy.xpath(xpath_str))
port = each_proxy.xpath(
".//span[contains(@class, 'port')]/text()")[0]
yield '{}:{}'.format(ip_addr, port)
except Exception as e:
pass
@staticmethod
def freeProxySixth():
"""
讯代理 http://www.xdaili.cn/
:return:
"""
url = 'http://www.xdaili.cn/ipagent/freeip/getFreeIps?page=1&rows=10'
request = WebRequest()
try:
res = request.get(url, timeout=10).json()
for row in res['RESULT']['rows']:
yield '{}:{}'.format(row['ip'], row['port'])
except Exception as e:
pass
@staticmethod
def freeProxySeventh():
"""
快代理 https://www.kuaidaili.com
"""
url_list = [
'https://www.kuaidaili.com/free/inha/{page}/',
'https://www.kuaidaili.com/free/intr/{page}/'
]
for url in url_list:
for page in range(1, 2):
page_url = url.format(page=page)
tree = getHtmlTree(page_url)
proxy_list = tree.xpath('.//table//tr')
for tr in proxy_list[1:]:
yield ':'.join(tr.xpath('./td/text()')[0:2])
@staticmethod
def freeProxyEight():
"""
秘密代理 http://www.mimiip.com
"""
url_gngao = ['http://www.mimiip.com/gngao/%s' % n for n in range(1, 2)
] # 国内高匿
url_gnpu = ['http://www.mimiip.com/gnpu/%s' % n for n in range(1, 2)
] # 国内普匿
url_gntou = ['http://www.mimiip.com/gntou/%s' % n for n in range(1, 2)
] # 国内透明
url_list = url_gngao + url_gnpu + url_gntou
request = WebRequest()
for url in url_list:
r = request.get(url, timeout=10)
proxies = re.findall(
r'<td>(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})</td>[\w\W].*<td>(\d+)</td>',
r.text)
for proxy in proxies:
yield ':'.join(proxy)
@staticmethod
def freeProxyNinth():
"""
码农代理 https://proxy.coderbusy.com/
:return:
"""
urls = ['https://proxy.coderbusy.com/classical/country/cn.aspx?page=1']
request = WebRequest()
for url in urls:
r = request.get(url, timeout=10)
proxies = re.findall(
'data-ip="(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})".+?>(\d+)</td>',
r.text)
for proxy in proxies:
yield ':'.join(proxy)
@staticmethod
def freeProxyTen():
"""
云代理 http://www.ip3366.net/free/
:return:
"""
urls = ['http://www.ip3366.net/free/']
request = WebRequest()
for url in urls:
r = request.get(url, timeout=10)
proxies = re.findall(
r'<td>(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})</td>[\s\S]*?<td>(\d+)</td>',
r.text)
for proxy in proxies:
yield ":".join(proxy)
@staticmethod
def freeProxyEleven():
"""
IP海 http://www.iphai.com/free/ng
:return:
"""
urls = [
'http://www.iphai.com/free/ng', 'http://www.iphai.com/free/np',
'http://www.iphai.com/free/wg', 'http://www.iphai.com/free/wp'
]
request = WebRequest()
for url in urls:
r = request.get(url, timeout=10)
proxies = re.findall(
r'<td>\s*?(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\s*?</td>[\s\S]*?<td>\s*?(\d+)\s*?</td>',
r.text)
for proxy in proxies:
yield ":".join(proxy)
@staticmethod
def freeProxyTwelve(page_count=2):
"""
guobanjia http://ip.jiangxianli.com/?page=
免费代理库
超多量
:return:
"""
for i in range(1, page_count + 1):
url = 'http://ip.jiangxianli.com/?page={}'.format(i)
html_tree = getHtmlTree(url)
tr_list = html_tree.xpath(
"/html/body/div[1]/div/div[1]/div[2]/table/tbody/tr")
if len(tr_list) == 0:
continue
for tr in tr_list:
yield tr.xpath("./td[2]/text()")[0] + ":" + tr.xpath(
"./td[3]/text()")[0]
@staticmethod
def freeProxyWallFirst():
"""
墙外网站 cn-proxy
:return:
"""
urls = ['http://cn-proxy.com/', 'http://cn-proxy.com/archives/218']
request = WebRequest()
for url in urls:
r = request.get(url, timeout=10)
proxies = re.findall(
r'<td>(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})</td>[\w\W]<td>(\d+)</td>',
r.text)
for proxy in proxies:
yield ':'.join(proxy)
@staticmethod
def freeProxyWallSecond():
"""
https://proxy-list.org/english/index.php
:return:
"""
urls = [
'https://proxy-list.org/english/index.php?p=%s' % n
for n in range(1, 10)
]
request = WebRequest()
import base64
for url in urls:
r = request.get(url, timeout=10)
proxies = re.findall(r"Proxy\('(.*?)'\)", r.text)
for proxy in proxies:
yield base64.b64decode(proxy).decode()
@staticmethod
def freeProxyWallThird():
urls = ['https://list.proxylistplus.com/Fresh-HTTP-Proxy-List-1']
request = WebRequest()
for url in urls:
r = request.get(url, timeout=10)
proxies = re.findall(
r'<td>(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})</td>[\s\S]*?<td>(\d+)</td>',
r.text)
for proxy in proxies:
yield ':'.join(proxy)
if __name__ == '__main__':
from CheckProxy import CheckProxy
# CheckProxy.checkGetProxyFunc(GetFreeProxy.freeProxyFirst)
# CheckProxy.checkGetProxyFunc(GetFreeProxy.freeProxySecond)
# CheckProxy.checkGetProxyFunc(GetFreeProxy.freeProxyThird)
# CheckProxy.checkGetProxyFunc(GetFreeProxy.freeProxyFourth)
# CheckProxy.checkGetProxyFunc(GetFreeProxy.freeProxyFifth)
# CheckProxy.checkGetProxyFunc(GetFreeProxy.freeProxySixth)
# CheckProxy.checkGetProxyFunc(GetFreeProxy.freeProxySeventh)
# CheckProxy.checkGetProxyFunc(GetFreeProxy.freeProxyEight)
# CheckProxy.checkGetProxyFunc(GetFreeProxy.freeProxyNinth)
# CheckProxy.checkGetProxyFunc(GetFreeProxy.freeProxyTen)
# CheckProxy.checkGetProxyFunc(GetFreeProxy.freeProxyEleven)
CheckProxy.checkGetProxyFunc(GetFreeProxy.freeProxyTwelve)
# CheckProxy.checkAllGetProxyFunc()
| [
"tangchen2018"
] | tangchen2018 |
e0004b0b6df60bd3030ff004ed0bbefc869e38b4 | 10ddfb2d43a8ec5d47ce35dc0b8acf4fd58dea94 | /Python/minimum-string-length-after-removing-substrings.py | 48bab73ecbf57ba9c36b9cfb91378585932a9056 | [
"MIT"
] | permissive | kamyu104/LeetCode-Solutions | f54822059405ef4df737d2e9898b024f051fd525 | 4dc4e6642dc92f1983c13564cc0fd99917cab358 | refs/heads/master | 2023-09-02T13:48:26.830566 | 2023-08-28T10:11:12 | 2023-08-28T10:11:12 | 152,631,182 | 4,549 | 1,651 | MIT | 2023-05-31T06:10:33 | 2018-10-11T17:38:35 | C++ | UTF-8 | Python | false | false | 381 | py | # Time: O(n)
# Space: O(n)
# stack
class Solution(object):
def minLength(self, s):
"""
:type s: str
:rtype: int
"""
stk = []
for c in s:
if stk and ((stk[-1] == 'A' and c == 'B') or (stk[-1] == 'C' and c == 'D')):
stk.pop()
continue
stk.append(c)
return len(stk)
| [
"noreply@github.com"
] | kamyu104.noreply@github.com |
606477f67edd3313746f9af6bd76d0bcc0b0f20d | 9743d5fd24822f79c156ad112229e25adb9ed6f6 | /xai/brain/wordbase/otherforms/_salaams.py | 1de6f8529dce67507995a11f6402f5e970de1ab1 | [
"MIT"
] | permissive | cash2one/xai | de7adad1758f50dd6786bf0111e71a903f039b64 | e76f12c9f4dcf3ac1c7c08b0cc8844c0b0a104b6 | refs/heads/master | 2021-01-19T12:33:54.964379 | 2017-01-28T02:00:50 | 2017-01-28T02:00:50 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 222 | py |
#calss header
class _SALAAMS():
def __init__(self,):
self.name = "SALAAMS"
self.definitions = salaam
self.parents = []
self.childen = []
self.properties = []
self.jsondata = {}
self.basic = ['salaam']
| [
"xingwang1991@gmail.com"
] | xingwang1991@gmail.com |
8487e62e951e283108f26a41f0b4cdc654850a72 | b7fd5752b1d0020ae9c68fcfc32107864b0705e5 | /take_data_git.py | 9e6ffbe374807d36aacd715c302f44af691e66b4 | [] | no_license | salmonellix/covid_classifiers | 3d7aadd2f394d807b19b96a0aace025c146cf98e | 4fac8382a1c74c58a4db0c301a496e2d456074e8 | refs/heads/master | 2022-06-02T03:36:57.793252 | 2020-05-06T06:02:50 | 2020-05-06T06:02:50 | 259,626,345 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,913 | py | from __future__ import print_function
import pandas as pd
import re
import os
import sys
import git
import numpy as np
from tqdm import tqdm
from time import strftime
from dateutil.parser import parse
from datetime import datetime, date, time
# DATA PREP
#
REPO = 'https://github.com/CSSEGISandData/COVID-19.git'
TMP_FOLDER = '/tmp/corona/'
TMP_GIT = os.path.join(TMP_FOLDER, REPO.split('/')[-1].split('.')[0])
DATA = os.path.join(TMP_GIT, 'csse_covid_19_data', 'csse_covid_19_daily_reports')
LOG_TOP_N_COUNTRIES = 10
#
# FORECASTING
#
DAYS_IN_FUTURE = 10 # Amount of days you want to forecast into future
PERC_SPLIT = 0.95 # Train / test split for forecasting model.
#
# DATA VISUALIZATION
#
FIG_SIZE = (14,10)
#Github cols
KEEP_COLS = ['country',
'province',
'confirmed',
'deaths',
'recovered',
'date',
'datetime',
'file_date']
NUMERIC_COLS = ['confirmed',
'deaths',
'recovered']
def clean_sheet_names(new_ranges):
# Remove all sheets that dont have a numeric header
return [x for x in new_ranges if re.search(r'\d', x)]
def clone_repo(TMP_FOLDER, REPO):
print('Cloning Data Repo...')
git.Git(TMP_FOLDER).clone(REPO)
clone_repo(TMP_FOLDER, REPO)
def get_date(last_update):
return parse(str(last_update).split(' ')[0]).strftime("%Y-%m-%d")
def get_csv_date(f):
return get_date(f.split('.')[0] + ' ')
def fix_country_names(tmp_df):
'''
Cleaning up after JHU's bullshit data management
'''
# Asian Countries
tmp_df['country'] = np.where((tmp_df['country'] == 'Mainland China'), 'China', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Korea, South'), 'South Korea', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Republic of Korea'), 'South Korea', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Hong Kong SAR'), 'Hong Kong', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Taipei and environs'), 'Taiwan', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Taiwan*'), 'Taiwan', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Macao SAR'), 'Macau', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Iran (Islamic Republic of)'), 'Iran', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Viet Nam'), 'Vietnam', tmp_df['country'])
# European Countries
tmp_df['country'] = np.where((tmp_df['country'] == 'UK'), 'United Kingdom', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == ' Azerbaijan'), 'Azerbaijan', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Bosnia and Herzegovina'), 'Bosnia', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Czech Republic'), 'Czechia', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Republic of Ireland'), 'Ireland', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'North Ireland'), 'Ireland', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Republic of Moldova'), 'Moldova', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Russian Federation'), 'Russia', tmp_df['country'])
# African Countries
tmp_df['country'] = np.where((tmp_df['country'] == 'Congo (Brazzaville)'), 'Congo', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Congo (Kinshasa)'), 'Congo', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Republic of the Congo'), 'Congo', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Gambia, The'), 'Gambia', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'The Gambia'), 'Gambia', tmp_df['country'])
# Western Countries
tmp_df['country'] = np.where((tmp_df['country'] == 'USA'), 'America', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'US'), 'America', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Bahamas, The'), 'The Bahamas', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'Bahamas'), 'The Bahamas', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'st. Martin'), 'Saint Martin', tmp_df['country'])
tmp_df['country'] = np.where((tmp_df['country'] == 'St. Martin'), 'Saint Martin', tmp_df['country'])
# Others
tmp_df['country'] = np.where((tmp_df['country'] == 'Cruise Ship'), 'Others', tmp_df['country'])
return tmp_df
# Now that we have all the data we now need to clean it
# - Fill null values
# - remore suspected values
# - change column names
def clean_data(df):
tmp_df = df.copy()
if 'Demised' in tmp_df.columns:
tmp_df.rename(columns={'Demised': 'deaths'}, inplace=True)
if 'Country/Region' in tmp_df.columns:
tmp_df.rename(columns={'Country/Region': 'country'}, inplace=True)
if 'Country_Region' in tmp_df.columns:
tmp_df.rename(columns={'Country_Region': 'country'}, inplace=True)
if 'Province/State' in tmp_df.columns:
tmp_df.rename(columns={'Province/State': 'province'}, inplace=True)
if 'Province_State' in tmp_df.columns:
tmp_df.rename(columns={'Province_State': 'province'}, inplace=True)
if 'Last Update' in tmp_df.columns:
tmp_df.rename(columns={'Last Update': 'datetime'}, inplace=True)
if 'Last_Update' in tmp_df.columns:
tmp_df.rename(columns={'Last_Update': 'datetime'}, inplace=True)
# Lower case all col names
tmp_df.columns = map(str.lower, tmp_df.columns)
for col in tmp_df[NUMERIC_COLS]:
tmp_df[col] = tmp_df[col].fillna(0)
tmp_df[col] = tmp_df[col].astype(int)
return tmp_df
def get_data(cleaned_sheets):
all_csv = []
# Import all CSV's
for f in tqdm(sorted(cleaned_sheets), desc='... loading data: '):
if 'csv' in f:
try:
tmp_df = pd.read_csv(os.path.join(DATA, f), index_col=None, header=0, parse_dates=['Last Update'])
except:
# Temporary fix for JHU's bullshit data management
tmp_df = pd.read_csv(os.path.join(DATA, f), index_col=None, header=0, parse_dates=['Last_Update'])
tmp_df = clean_data(tmp_df)
tmp_df['date'] = tmp_df['datetime'].apply(get_date) # remove time to get date
tmp_df['file_date'] = get_csv_date(f) # Get date of csv from file name
tmp_df = tmp_df[KEEP_COLS]
tmp_df['province'].fillna(tmp_df['country'], inplace=True) # If no region given, fill it with country
all_csv.append(tmp_df)
df_raw = pd.concat(all_csv, axis=0, ignore_index=True, sort=True) # concatenate all csv's into one df
df_raw = fix_country_names(df_raw) # Fix mispelled country names
df_raw = df_raw.sort_values(by=['datetime'])
return df_raw
# use this function to fetch the data
def get():
# Create Tmp Folder
if not os.path.isdir(TMP_FOLDER):
print('Creating folder...')
print('...', TMP_FOLDER)
os.mkdir(TMP_FOLDER)
# Check if repo exists
# git pull if it does
if not os.path.isdir(TMP_GIT):
clone_repo(TMP_FOLDER, REPO)
else:
try:
print('git pull from', REPO)
rep = git.Repo(TMP_GIT)
rep.remotes.origin.pull()
except:
print('Could not pull from', REPO)
sys.exit(1)
sheets = os.listdir(DATA)
# Clean the result to the sheet tabs we want
print('Getting sheets...')
cleaned_sheets = clean_sheet_names(sheets)
# Aggregate all the data from sheets
df = get_data(cleaned_sheets)
# Clean the column names
return df
get()
| [
"samolix0gmail.com"
] | samolix0gmail.com |
e0a001fca791b06a772558c84bf3d8c100a2c4dd | ba3a705ecb3628641793854292aa9a3ff8fc1221 | /10_API/FlaskIntroduction/app.py | 0a23ab3144d2a8d92dd00599475768d8da80d806 | [] | no_license | mortenhaahr/NGK | d98ada8d63a07ea6447768ab6a23ad1346634b56 | a9e89afb452dd7953cba4403b4e8bc2c0ff2ba1e | refs/heads/master | 2022-07-01T20:39:02.063251 | 2020-05-11T15:40:26 | 2020-05-11T15:40:26 | 242,725,171 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,516 | py | from flask import Flask, render_template, url_for, request, redirect
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
app = Flask(__name__) #__name__ = filename
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db' # 3 forward slashes for relative path
db = SQLAlchemy(app) # Pass in app to database and init db
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String(200), nullable=False) #Max 200 chars and dont allow it to be blank
date_created = db.Column(db.DateTime, default=datetime.utcnow) #Never has to be set manually
# Everytime we make a new taks, it shall return the ID of that task:
def __repr__(self):
return '<Task %r' % self.id
#Must setup database manually in python ONCE, to create the db in env:
# Type following in console:
# python3 [enter] from app import db [enter] db.create_all() [enter] exit() [enter]
@app.route('/', methods=['POST', 'GET']) #root directory. POST and GET defines that the directory accepts POST and GET requests
def index():
if request.method == 'POST':
task_content = request.form['content']
new_task = Todo(content=task_content)
try:
db.session.add(new_task)
db.session.commit()
return redirect('/')
except:
return 'There was an issue adding your task'
else:
tasks = Todo.query.order_by(Todo.date_created).all() # Return all database instances in order created
#return "Hello, World!" # return basic string on website
return render_template('index.html', tasks=tasks) #return index page.
# make delete route
@app.route('/delete/<int:id>')
def delete(id):
task_to_delete = Todo.query.get_or_404(id) # Get object by id, if it fails, throw 404
try:
db.session.delete(task_to_delete)
db.session.commit()
return redirect('/')
except:
return 'There was a problem deleting that task'
@app.route('/update/<int:id>', methods=['GET', 'POST'])
def update(id):
task = Todo.query.get_or_404(id) #define our task variable for this function
if request.method == 'POST':
task.content = request.form['content']
try:
db.session.commit()
return redirect('/')
except:
return 'There was an issue updating your task'
else:
return render_template('update.html', task=task)
if __name__ == "__main__":
app.run(debug=True) | [
"you@example.com"
] | you@example.com |
54e28cecd337e8e1681fece4e481eda2c283bbc5 | 7af468a95c25bbdcc108f5a0fc441669161bbe35 | /src/lib/gamble.py | 3e7259781de90e3b6d7613f28bc14f010d81d630 | [] | no_license | MAkzent/betminionbot0.1 | 3b9ad4ca79aed81daaacbcd290abd622cb4f4433 | 8565262061a17ac0995479f52df30ccb06c2c8a4 | refs/heads/master | 2021-01-01T05:42:59.580911 | 2016-05-18T02:11:04 | 2016-05-18T02:11:04 | 59,072,680 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 4,142 | py | from src.lib.queries import Database
import random
import globals
import time
from threading import Thread
import sys
def initialize(channel, user, delay, points):
GambleThread(globals.irc, channel, delay, user, points).start()
class GambleThread(Thread):
def __init__(self, irc, channel, delay, user, points):
Thread.__init__(self, target=self.main)
self.daemon = True
self.delay = delay
self.now = time.time()
self.channel = "#" + channel.lstrip("#")
self.chan = channel
self.irc = irc
self.user = user
if self.channel not in globals.channel_info:
globals.channel_info[self.chan]["gamble"] = {
"time": None, "users": {}, "points": 0}
globals.channel_info[self.chan]['gamble'] = {
"time": time.time(), "users": {
self.user: True}, "points": points}
self.points = globals.channel_info[self.chan]['gamble']["points"]
self.g = Gamble(self.chan, self.user, self.points)
def main(self):
chan = self.channel.lstrip("#")
begin_resp = "Gambling has begun!"
end_resp = "Gambling has finished!"
time_left = "{0} seconds of gambling remain!".format(self.delay / 2)
self.g.initiate_gamble()
self.irc.send_message(self.channel, begin_resp)
time.sleep(float(self.delay / 2))
self.irc.send_message(self.channel, time_left)
time.sleep(float(self.delay / 2))
self.g.terminate_gamble()
self.irc.send_message(self.channel, end_resp)
participants = globals.channel_info[self.chan]['gamble']["users"]
winner = random.choice(participants.keys())
winner_points = self.points * (len(participants) - 1)
try:
del participants[winner]
except KeyError:
pass
for participant in participants.keys():
self.g.apply_yield(self.chan, participant, self.points * -1)
self.g.apply_yield(self.chan, winner, winner_points)
win_resp = "Congratulations, {0}, you won {1} cash!".format(
winner, winner_points)
self.irc.send_message(self.channel, win_resp)
sys.exit()
class Gamble:
def __init__(self, channel="testchannel", user="testuser", points=0):
self.db = Database()
self.channel = channel
self.user = user
self.points = points
def initiate_gamble(self):
if self.channel not in globals.channel_info:
globals.channel_info[self.channel]["gamble"] = {
"time": None, "users": {}, "points": 0}
globals.channel_info[self.channel]['gamble'] = {
"time": time.time(), "users": {
self.user: True}, "points": self.points}
def terminate_gamble(self):
globals.channel_info[self.channel]['gamble']["time"] = None
def check_gamble(self):
if self.channel not in globals.channel_info:
globals.channel_info[self.channel]["gamble"] = {
"time": None, "users": {}}
if globals.channel_info[self.channel]['gamble']["time"]:
return globals.channel_info[self.channel]['gamble']["time"]
else:
return None
def get_gamble_user(self, user):
user_value = globals.channel_info[globals.CURRENT_CHANNEL]['gamble'][
"users"].get(user)
if user_value:
return True
else:
return False
def rob_yield(self, multiplier=1):
points_yield = random.choice(range(1, 11))
points = 0
if points_yield > 9:
points = random.choice(range(1, 301)) * multiplier
elif points_yield <= 9 and points_yield > 5:
points = random.choice(range(1, 21)) * multiplier
elif points_yield <= 5 and points_yield > 1:
points = random.choice(range(1, 11)) * multiplier
else:
points = self.points
if bool(random.getrandbits(1)):
points *= -1
return points
def apply_yield(self, channel, user, points):
self.db.modify_points(user, channel, points)
| [
"arnold.michael91@gmail.com"
] | arnold.michael91@gmail.com |
393267ba2fca5a36bba7334d69ab49829c14bc68 | 84d84096b413e84f502468a2985780a3005457a1 | /api/orders/views.py | 1daaf6e39ac7835363150b9c1afaa1afd0c60dcf | [
"MIT"
] | permissive | joeltio/np-train | 0fd28fe45bdc9c29aee99819ca07798392e13fd1 | dc852321b674be3ddc1d1c0dd4eff694825d02fa | refs/heads/master | 2020-04-14T18:56:57.714933 | 2019-01-10T01:58:09 | 2019-01-10T01:58:09 | 164,039,036 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,984 | py | import json
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from orders.models import Order
import base.helpers as base_helpers
@csrf_exempt
@require_POST
def uncompleted_order(request):
# Get the latest uncompleted order
order = Order.objects.filter(
status=Order.STATUS_NOT_ACTIVE).order_by("id").first()
if order is not None:
return base_helpers.create_json_response(
data=order.as_json()
)
else:
return base_helpers.create_json_response(
message="There are no uncompleted orders",
empty_data=True,
)
@csrf_exempt
@require_POST
def new_order(request):
# Read json
try:
json_data = json.loads(request.body)
except json.decoder.JSONDecodeError:
return base_helpers.create_json_response(
success=False,
message="Bad JSON",
status=400
)
# Check if there is a destination and color
if not base_helpers.has_keys({"destination", "color"}, json_data):
return base_helpers.create_json_response(
success=False,
message="Missing destination or color",
status=400,
)
destination = json_data["destination"]
color = json_data["color"]
if not base_helpers.validate_positive_int(color, include_zero=True):
return base_helpers.create_json_response(
success=False,
message="The color is not a non-negative integer",
status=400,
)
if not isinstance(destination, str):
return base_helpers.create_json_response(
success=False,
message="The destination must be a string",
status=400,
)
order = Order.objects.create(
destination=destination, color=color,
status=Order.STATUS_NOT_ACTIVE)
return base_helpers.create_json_response(
data={"id": order.pk}
)
@csrf_exempt
@require_POST
def update_order(request):
# Read json
try:
json_data = json.loads(request.body)
except json.decoder.JSONDecodeError:
return base_helpers.create_json_response(
success=False,
message="Bad JSON",
status=400
)
if not base_helpers.has_keys({"id", "new_status"}, json_data):
return base_helpers.create_json_response(
success=False,
message="Missing id or new_status",
status=400,
)
if not base_helpers.validate_positive_int(
json_data["id"], include_zero=True):
return base_helpers.create_json_response(
success=False,
message="Bad id",
status=400,
)
elif not json_data["new_status"] in Order.STATUS_FLOW:
return base_helpers.create_json_response(
success=False,
message="Bad new_status",
status=400,
)
new_status = json_data["new_status"]
# Find the order
try:
order = Order.objects.get(pk=int(json_data["id"]))
except Order.DoesNotExist:
return base_helpers.create_json_response(
success=False,
message="There is no order with that id",
status=400,
)
# Only allow changes in this order:
# NOT_ACTIVE > ACTIVE > COMPLETED
if order.status == Order.STATUS_FLOW[-1]:
return base_helpers.create_json_response(
success=False,
message="The order is already complete",
status=400,
)
elif new_status - order.status != 1:
return base_helpers.create_json_response(
success=False,
message="Cannot update status beyond 1 step",
status=400,
)
order.status = new_status
order.save()
return base_helpers.create_json_response()
@csrf_exempt
@require_POST
def order_status(request):
# Read json
try:
json_data = json.loads(request.body)
except json.decoder.JSONDecodeError:
return base_helpers.create_json_response(
success=False,
message="Bad JSON",
status=400
)
if "id" not in json_data:
return base_helpers.create_json_response(
success=False,
message="Missing id",
status=400,
)
if not base_helpers.validate_positive_int(
json_data["id"], include_zero=True):
return base_helpers.create_json_response(
success=False,
message="Bad id",
status=400,
)
# Get the order
try:
order = Order.objects.get(pk=json_data["id"])
except Order.DoesNotExist:
return base_helpers.create_json_response(
success=False,
message="There is no order with that id",
status=400,
)
return base_helpers.create_json_response(
data={"status": order.status}
)
| [
"joeltiojinhon@gmail.com"
] | joeltiojinhon@gmail.com |
6e4fb4fbb02ebc5edb966b8d7c94bc9d508f2e94 | 0ac0949d082e5e8476a04f96d19fcfebf6d94da2 | /src/tools/test_ndn.py | ce2a87155876889374ef575e2739da7c7f159d14 | [
"MIT"
] | permissive | P-Song/QCANet | 5e27271dcd99dbb59c1e60b6ce7cd957581ea543 | 062fd2abaefab217491512792ee78810294a7d4a | refs/heads/master | 2023-02-21T05:53:43.947812 | 2021-01-16T10:30:08 | 2021-01-16T10:30:08 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 10,481 | py | # -*- coding: utf-8 -*-
import csv
import sys
import time
import random
import copy
import math
import os
import numpy as np
import os.path as pt
from skimage import io
from skimage import transform as tr
from skimage import morphology as mor
from argparse import ArgumentParser
from chainer import cuda
sys.path.append(os.getcwd())
from src.lib.model import Model_L2, Model_L3, Model_L4
from src.lib.utils import mirror_extension_image
class TestNDN():
def __init__(
self,
model=None,
patchsize=128,
stride=64,
resolution=(1.0, 1.0, 2.18),
scaling=True,
delv=3,
opbase=None,
gpu=False,
ndim=3
):
self.model = model
self.patchsize = (patchsize, patchsize, patchsize)
self.stride = (stride, stride, stride)
self.resolution = resolution
self.scaling = scaling
self.delv = delv
self.opbase = opbase
self.gpu = gpu
self.psep = '/'
self.ndim = ndim
def NuclearDetection(self, image_path):
segbase = 'DetectionImages'
if not (pt.exists(self.opbase + self.psep + segbase)):
os.mkdir(self.opbase + self.psep + segbase)
labbase = 'LabelingDetectionImages'
if not (pt.exists(self.opbase + self.psep + labbase)):
os.mkdir(self.opbase + self.psep + labbase)
image = io.imread(image_path)
im_size = image.shape
if self.ndim == 2:
ip_size = (int(image.shape[0] * self.resolution[1]), int(image.shape[1] * self.resolution[0]))
sh = [int(self.stride[0]/2), int(self.stride[1]/2)]
elif self.ndim == 3:
ip_size = (int(image.shape[0] * self.resolution[2]), int(image.shape[1] * self.resolution[1]), int(image.shape[2] * self.resolution[0]))
sh = [int(self.stride[0]/2), int(self.stride[1]/2), int(self.stride[2]/2)]
image = tr.resize(image, ip_size, order = 1, preserve_range = True)
im_size_ip = image.shape
# Scaling
if self.scaling:
image = image.astype(np.float32)
#image = image / image.max()
image = (image - image.min()) / (image.max() - image.min())
''' calculation for pad size'''
#if np.min(self.patchsize) > np.max(im_size):
if np.min(self.patchsize) > np.max(np.array(im_size) + np.array(sh)*2):
if self.ndim == 2:
pad_size = [self.patchsize[0], self.patchsize[1]]
elif self.ndim == 3:
pad_size = [self.patchsize[0], self.patchsize[1], self.patchsize[2]]
else:
pad_size = []
for axis in range(len(im_size_ip)):
if (im_size_ip[axis] + 2*sh[axis] - self.patchsize[axis]) % self.stride[axis] == 0:
stride_num = int((im_size_ip[axis] + 2*sh[axis] - self.patchsize[axis]) / self.stride[axis])
else:
stride_num = int((im_size_ip[axis] + 2*sh[axis] - self.patchsize[axis]) / self.stride[axis]) + 1
pad_size.append(int(self.stride[axis] * stride_num + self.patchsize[axis]))
pre_img = np.zeros(pad_size)
if self.ndim == 2:
image = mirror_extension_image(image=image, ndim=self.ndim, length=int(np.max(self.patchsize)))[self.patchsize[0]-sh[0]:self.patchsize[0]-sh[0]+pad_size[0], self.patchsize[1]-sh[1]:self.patchsize[1]-sh[1]+pad_size[1]]
for y in range(0, pad_size[0]-self.stride[0], self.stride[0]):
for x in range(0, pad_size[1]-self.stride[1], self.stride[1]):
x_patch = image[y:y+self.patchsize[0], x:x+self.patchsize[1]]
x_patch = np.expand_dims(np.expand_dims(x_patch.astype(np.float32), axis=0), axis=0)
if self.gpu >= 0:
x_patch = cuda.to_gpu(x_patch)
s_output = self.model(x=x_patch, t=None, seg=True)
if self.gpu >= 0:
s_output = cuda.to_cpu(s_output)
pred = copy.deepcopy((0 < (s_output[0][1] - s_output[0][0])) * 255)
# Add segmentation image
pre_img[y:y+self.stride[0], x:x+self.stride[1]] += pred[sh[0]:-sh[0], sh[1]:-sh[1]]
seg_img = (pre_img > 0) * 255
seg_img = seg_img[0:im_size_ip[0], 0:im_size_ip[1]]
elif self.ndim == 3:
image = mirror_extension_image(image=image, ndim=self.ndim, length=int(np.max(self.patchsize)))[self.patchsize[0]-sh[0]:self.patchsize[0]-sh[0]+pad_size[0], self.patchsize[1]-sh[1]:self.patchsize[1]-sh[1]+pad_size[1], self.patchsize[2]-sh[2]:self.patchsize[2]-sh[2]+pad_size[2]]
for z in range(0, pad_size[0]-self.stride[0], self.stride[0]):
for y in range(0, pad_size[1]-self.stride[1], self.stride[1]):
for x in range(0, pad_size[2]-self.stride[2], self.stride[2]):
x_patch = image[z:z+self.patchsize[0], y:y+self.patchsize[1], x:x+self.patchsize[2]]
x_patch = np.expand_dims(np.expand_dims(x_patch.astype(np.float32), axis=0), axis=0)
if self.gpu >= 0:
x_patch = cuda.to_gpu(x_patch)
s_output = self.model(x=x_patch, t=None, seg=True)
if self.gpu >= 0:
s_output = cuda.to_cpu(s_output)
pred = copy.deepcopy((0 < (s_output[0][1] - s_output[0][0])) * 255)
# Add segmentation image
pre_img[z:z+self.stride[0], y:y+self.stride[1], x:x+self.stride[2]] += pred[sh[0]:-sh[0], sh[1]:-sh[1], sh[2]:-sh[2]]
seg_img = (pre_img > 0) * 255
seg_img = seg_img[0:im_size_ip[0], 0:im_size_ip[1], 0:im_size_ip[2]]
seg_img = (tr.resize(seg_img, im_size, order = 1, preserve_range = True) > 0) * 255
filename = os.path.join(self.opbase, segbase, os.path.basename(image_path)[:os.path.basename(image_path).rfind('.')] + '.tif')
# filename = self.opbase + self.psep + segbase + self.psep + 'detimg_t{0:03d}.tif'.format(int(image_path[image_path.rfind('/')+1:image_path.rfind('.')]))
io.imsave(filename, seg_img.astype(np.uint8))
lab_img = mor.label(seg_img.astype(np.uint16), neighbors=4)
mask_size = np.unique(lab_img, return_counts=True)[1] < (self.delv + 1)
remove_voxel = mask_size[lab_img]
lab_img[remove_voxel] = 0
labels = np.unique(lab_img)
lab_img = np.searchsorted(labels, lab_img)
filename = os.path.join(self.opbase, labbase, os.path.basename(image_path)[:os.path.basename(image_path).rfind('.')] + '.tif')
# filename = self.opbase + self.psep + labbase + self.psep + 'labimg_t{0:03d}.tif'.format(int(image_path[image_path.rfind('/')+1:image_path.rfind('.')]))
io.imsave(filename, lab_img.astype(np.uint16))
return lab_img.astype(np.uint16)
if __name__ == '__main__':
start_time = time.time()
ap = ArgumentParser(description='python test_ndn.py')
ap.add_argument('--indir', '-i', nargs='?', default='../images/example_input', help='Specify input image')
ap.add_argument('--outdir', '-o', nargs='?', default='result_test_ndn', help='Specify output files directory for create detection image')
ap.add_argument('--model', '-m', nargs='?', default='../models/p128/learned_ndn.model', help='Specify loading file path of learned NDN Model')
ap.add_argument('--gpu', '-g', type=int, default=-1, help='Specify GPU ID (negative value indicates CPU)')
ap.add_argument('--patchsize', '-p', type=int, default=128, help='Specify patch size')
ap.add_argument('--stride', type=int, default=64, help='Specify stride size')
ap.add_argument('--delete', '-d', type=int, default=0, help='Specify Pixel Size of Delete Region')
ap.add_argument('--scaling', '-s', action='store_true', help='Specify Image-wise Scaling Flag')
ap.add_argument('--resolution_x', '-x', type=float, default=1.0, help='Specify microscope resolution of x axis (default=1.0)')
ap.add_argument('--resolution_y', '-y', type=float, default=1.0, help='Specify microscope resolution of y axis (default=1.0)')
ap.add_argument('--resolution_z', '-z', type=float, default=2.18, help='Specify microscope resolution of z axis (default=2.18)')
args = ap.parse_args()
argvs = sys.argv
util = Utils()
psep = '/'
opbase = util.createOpbase(args.outdir)
patchsize = args.patchsize
stride = args.stride
print('Patch Size: {}'.format(patchsize))
print('Stride Size: {}'.format(stride))
print('Delete Voxels: {}'.format(args.delete))
with open(opbase + psep + 'result.txt', 'w') as f:
f.write('python ' + ' '.join(argvs) + '\n')
f.write('[Properties of parameter]\n')
f.write('Output Directory: {}\n'.format(opbase))
f.write('Patch Size: {}\n'.format(patchsize))
f.write('Stride Size: {}\n'.format(stride))
f.write('Delete Voxels: {}\n'.format(args.delete))
# Create Model
class_weight = np.array([1, 1]).astype(np.float32)
if args.gpu >= 0:
class_weight = cuda.to_gpu(class_weight)
# Adam
ndn = Model_L4(class_weight=class_weight, n_class=2, init_channel=12,
kernel_size=5, pool_size=2, ap_factor=2, gpu=args.gpu)
# SGD
# ndn = Model_L3(class_weight=class_weight, n_class=2, init_channel=16,
# kernel_size=3, pool_size=2, ap_factor=2, gpu=args.gpu)
# Load Model
if not args.model == '0':
util.loadModel(args.model, ndn)
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
ndn.to_gpu()
# Detection Phase
test_ndn = TestNDN(model=ndn, patchsize=patchsize, stride=stride,
resolution=(args.resolution_x, args.resolution_y, args.resolution_z),
scaling=args.scaling, delv=args.delete,
opbase=opbase, gpu=args.gpu)
dlist = os.listdir(args.indir)
for l in dlist:
test_ndn.NuclearDetection(args.indir + psep + l)
end_time = time.time()
etime = end_time - start_time
print('Elapsed time is (sec) {}'.format(etime))
with open(opbase + psep + 'result.txt', 'a') as f:
f.write('======================================\n')
f.write('Elapsed time is (sec) {} \n'.format(etime))
print('NDN Test Completed Process!')
| [
"tokuoka@fun.bio.keio.ac.jp"
] | tokuoka@fun.bio.keio.ac.jp |
3dcadaa240a921e97bab29a8008a1b83bac8c93d | f3081f31875dc539529d1ef24a6ddedbb1cd5ad3 | /website_sale/tests/test_website_sale_cart_recovery.py | ac597616882ce66ce7ca4ffa447974a46ef75571 | [] | no_license | babarlhr/human_website_13 | 5ef144c65c8eb268b40c144e0073d8d2084014ed | e9d68d29959a7df3f56eadebe413556b11957ace | refs/heads/master | 2022-11-06T09:02:17.301645 | 2020-06-21T10:32:16 | 2020-06-21T10:32:16 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,475 | py | # -*- coding: utf-8 -*-
# Part of Eagle. See LICENSE file for full copyright and licensing details.
from eagle.tests import tagged
from eagle.tests.common import HttpCase, TransactionCase
@tagged('post_install', '-at_install')
class TestWebsiteSaleCartRecovery(HttpCase):
def test_01_info_cart_recovery_tour(self):
"""The goal of this test is to make sure cart recovery works."""
self.start_tour("/", 'info_cart_recovery', login="portal")
@tagged('post_install', '-at_install')
class TestWebsiteSaleCartRecoveryServer(TransactionCase):
def setUp(self):
res = super(TestWebsiteSaleCartRecoveryServer, self).setUp()
self.customer = self.env['res.partner'].create({
'name': 'a',
'email': 'a@example.com',
})
self.recovery_template_default = self.env.ref('website_sale.mail_template_sale_cart_recovery')
self.recovery_template_custom1 = self.recovery_template_default.copy()
self.recovery_template_custom2 = self.recovery_template_default.copy()
self.website0 = self.env['website'].create({
'name': 'web0',
'cart_recovery_mail_template_id': self.recovery_template_default.id,
})
self.website1 = self.env['website'].create({
'name': 'web1',
'cart_recovery_mail_template_id': self.recovery_template_custom1.id,
})
self.website2 = self.env['website'].create({
'name': 'web2',
'cart_recovery_mail_template_id': self.recovery_template_custom2.id,
})
self.so0 = self.env['sale.order'].create({
'partner_id': self.customer.id,
'website_id': self.website0.id,
'is_abandoned_cart': True,
'cart_recovery_email_sent': False,
})
self.so1 = self.env['sale.order'].create({
'partner_id': self.customer.id,
'website_id': self.website1.id,
'is_abandoned_cart': True,
'cart_recovery_email_sent': False,
})
self.so2 = self.env['sale.order'].create({
'partner_id': self.customer.id,
'website_id': self.website2.id,
'is_abandoned_cart': True,
'cart_recovery_email_sent': False,
})
return res
def test_cart_recovery_mail_template(self):
"""Make sure that we get the correct cart recovery templates to send."""
self.assertEqual(
self.so1._get_cart_recovery_template(),
self.recovery_template_custom1,
"We do not return the correct mail template"
)
self.assertEqual(
self.so2._get_cart_recovery_template(),
self.recovery_template_custom2,
"We do not return the correct mail template"
)
# Orders that belong to different websites; we should get the default template
self.assertEqual(
(self.so1 + self.so2)._get_cart_recovery_template(),
self.recovery_template_default,
"We do not return the correct mail template"
)
def test_cart_recovery_mail_template_send(self):
"""The goal of this test is to make sure cart recovery works."""
orders = self.so0 + self.so1 + self.so2
self.assertFalse(
any(orders.mapped('cart_recovery_email_sent')),
"The recovery mail should not have been sent yet."
)
self.assertFalse(
any(orders.mapped('access_token')),
"There should not be an access token yet."
)
orders._cart_recovery_email_send()
self.assertTrue(
all(orders.mapped('cart_recovery_email_sent')),
"The recovery mail should have been sent."
)
self.assertTrue(
all(orders.mapped('access_token')),
"All tokens should have been generated."
)
sent_mail = {}
for order in orders:
mail = self.env["mail.mail"].search([
('record_name', '=', order['name'])
])
sent_mail.update({order: mail})
self.assertTrue(
all(len(sent_mail[order]) == 1 for order in orders),
"Each cart recovery mail has been sent exactly once."
)
self.assertTrue(
all(order.access_token in sent_mail[order].body for order in orders),
"Each mail should contain the access token of the corresponding SO."
)
| [
"rapidgrps@princegroup-bd.com"
] | rapidgrps@princegroup-bd.com |
51a07e0d65cb1b371d2bd13a78da51bcdb23a186 | e2e08d7c97398a42e6554f913ee27340226994d9 | /pyautoTest-master（ICF-7.5.0）/test_case/scg/scg_OSPF/test_c140943.py | 12482ba174a604d783884977f16e6d32bb34b597 | [] | no_license | lizhuoya1111/Automated_testing_practice | 88e7be512e831d279324ad710946232377fb4c01 | b3a532d33ddeb8d01fff315bcd59b451befdef23 | refs/heads/master | 2022-12-04T08:19:29.806445 | 2020-08-14T03:51:20 | 2020-08-14T03:51:20 | 287,426,498 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,490 | py |
import pytest
import time
import sys
from os.path import dirname, abspath
sys.path.insert(0, dirname(dirname(abspath(__file__))))
from page_obj.scg.scg_def_ospf import *
from page_obj.scg.scg_def_vlan_interface import *
from page_obj.scg.scg_def_bridge import *
from page_obj.common.rail import *
from page_obj.scg.scg_def_physical_interface import *
from page_obj.common.ssh import *
from page_obj.scg.scg_def_dhcp import *
from page_obj.scg.scg_dev import *
from page_obj.scg.scg_def_ifname_OEM import *
test_id = 140943
def test_c140943(browser):
try:
login_web(browser, url=dev1)
start_ospf_jyl(browser)
time.sleep(0.5)
ospf_general_jyl(browser, route_id="manual", manual_ip="192.168.1.1", static="yes", static_num="16777215", save="yes")
alert = browser.switch_to_alert()
# print(alert.text)
web_info = alert.text
# print(web_info)
# 接受告警
browser.switch_to_alert().accept()
ospf_general_jyl(browser, route_id="auto", static="no", save="yes")
stop_ospf_jyl(browser)
try:
assert "输入数字错误" in web_info
rail_pass(test_run_id, test_id)
except:
rail_fail(test_run_id, test_id)
assert "输入数字错误" in web_info
except Exception as err:
# 如果上面的步骤有报错，重新设备，恢复配置
print(err)
reload(hostip=dev1)
rail_fail(test_run_id, test_id)
assert False
if __name__ == '__main__':
pytest.main(["-v", "-s", "test_c" + str(test_id) + ".py"])
| [
"15501866985@163.com"
] | 15501866985@163.com |
5d635a8b03cfb360411bed2715e152f9905483f0 | 399dae0b5ad9ca27cde175d25b5435958674eb50 | /Script Monitors/Generates Alert if Windows Update is not Downloaded for 60 Days/generates-alert-if-windows-update-is-not-downloaded-for-60-days.py | 1cf0fac3bd8feb56d27fbdf8ec5719d79ccc253a | [] | no_license | kannanch/pythonscripts | 61e3ea9e8ebf6a6b0ec2a4a829664e4507b803ba | 843a522236f9c2cc2aadc68d504c71bb72600bd9 | refs/heads/master | 2020-06-12T11:18:00.404673 | 2019-06-28T11:24:37 | 2019-06-28T11:24:37 | 194,282,297 | 1 | 0 | null | 2019-06-28T13:55:56 | 2019-06-28T13:55:56 | null | UTF-8 | Python | false | false | 2,778 | py | # The script is a template to check UAC status on device.
import os
import sys
import _winreg
def alert(arg):
sys.stderr.write("%d%d%d" % (arg, arg, arg))
vbs=r'''
Set objSession = CreateObject("Microsoft.Update.Session")
Set objSearcher = objSession.CreateUpdateSearcher
Set colHistory = objSearcher.QueryHistory(0, 1)
For Each objEntry in colHistory
Wscript.Echo "Title: " & objEntry.Title
Wscript.Echo "Update application date: " & objEntry.Date
Next
'''
import os
import ctypes
import re
class disable_file_system_redirection:
_disable = ctypes.windll.kernel32.Wow64DisableWow64FsRedirection
_revert = ctypes.windll.kernel32.Wow64RevertWow64FsRedirection
def __enter__(self):
self.old_value = ctypes.c_long()
self.success = self._disable(ctypes.byref(self.old_value))
def __exit__(self, type, value, traceback):
if self.success:
self._revert(self.old_value)
def runvbs(vbs):
workdir=os.environ['PROGRAMDATA']+r'\temp'
if not os.path.isdir(workdir):
os.mkdir(workdir)
with open(workdir+r'\temprun.vbs',"w") as f :
f.write(vbs)
with disable_file_system_redirection():
output=os.popen('cscript.exe "'+workdir+r'\temprun.vbs"').read()
if os.path.isfile(workdir+r'\temprun.vbs'):
os.remove(workdir+r'\temprun.vbs')
return output
output=runvbs(vbs)
sam=re.findall("Update\sapplication\sdate:(.*)",output)[0]
sam1=sam.split(' ')[1]
d1=sam1
import platform
ki=platform.platform()
if "Windows-8" in ki:
print "Win 8"
f = d1.split("/")
d1=f[1] + "/" + f[0].rjust(2,"0") + "/" + f[2].rjust(2,"0")
elif "Windows-10" in ki:
print "win 10"
if 'PROCESSOR_ARCHITEW6432' in os.environ:
f = d1.split("/")
d1=f[1] + "/" + f[0].rjust(2,"0") + "/" + f[2].rjust(2,"0")
else:
f = d1.split("/")
d1=f[0] + "/" + f[1].rjust(2,"0") + "/" + f[2].rjust(2,"0")
elif "Windows-7" in ki:
print "windows 7"
f = d1.split("/")
d1=f[1] + "/" + f[0].rjust(2,"0") + "/" + f[2].rjust(2,"0")
import time
d2=time.strftime("%d/%m/%Y")
from datetime import datetime
date_format = "%d/%m/%Y"
date_format1= "%m/%d/%Y"
if "Windows-10" in ki:
a = datetime.strptime(d1, date_format1)
b = datetime.strptime(d2, date_format)
delta = b - a
else:
a = datetime.strptime(d1, date_format)
b = datetime.strptime(d2, date_format)
delta = b - a
print str(delta.days) + " days Since the last update"
if delta.days >=60:
print "Updates are not working properly"
alert(1)
else:
print "Updates are perfectly working"
alert(0)
| [
"noreply@github.com"
] | kannanch.noreply@github.com |
522942ffc46498d40ed0fdc39b7045079ac662cf | 37d7ecc7cce5229599669800c508ea9ab4bb2582 | /Part 5/Loop.py | 866237b6a0cfc047c0a4693efed9340f2aad829c | [] | no_license | MohamedAbdekader/Interpreter | 374aeff4bb3f8b24eaf05883c795e8b0bd693362 | c58390e96d365c7c808c227867f557cd87c10605 | refs/heads/main | 2023-04-21T02:44:08.714541 | 2021-05-11T16:42:50 | 2021-05-11T16:42:50 | 360,742,910 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,186 | py | from Core import Core
from Cond import Cond
import StmtSeq
class Loop:
def parse(self, parser):
parser.scanner.nextToken()
self.cond = Cond()
self.cond.parse(parser)
parser.expectedToken(Core.BEGIN)
parser.scanner.nextToken()
self.ss = StmtSeq.StmtSeq()
self.ss.parse(parser)
parser.expectedToken(Core.ENDWHILE)
parser.scanner.nextToken()
def semantic(self, parser):
self.cond.semantic(parser)
parser.scopes.append([])
self.ss.semantic(parser)
parser.scopes.pop()
def print(self, indent):
for x in range(indent):
print(" ", end='')
print("while ", end='')
self.cond.print()
print(" begin\n", end='')
self.ss.print(indent+1)
for x in range(indent):
print(" ", end='')
print("endwhile\n", end='')
def execute(self, executor):
while self.cond.execute(executor):
#Add a map for the new local scope, pop when done
before = executor.before
executor.pushScope()
self.ss.execute(executor)
executor.popScope()
while len(executor.gc) != before and len(executor.gc)!=0:
executor.before = executor.before - 1
executor.gc.pop()
print("gc:"+str(len(executor.gc))) | [
"mohamadsaber480@gmail.com"
] | mohamadsaber480@gmail.com |
de913faf03c1ba2443bdd1f1204f6961846f2379 | bdf664f03613551e703ac00f9b3cd1138e8b1e9b | /labb6/meny.py | 9838625a14832cc7ae89fa44971d7c2000589768 | [] | no_license | linwes/labb_6_final | 747b4bd53e2595d02f4e7bedd967874b876a7860 | d8427dcfce9f4a8f5162947eadb5b49dec21b660 | refs/heads/master | 2021-05-18T22:08:57.048845 | 2020-03-30T23:03:26 | 2020-03-30T23:03:26 | 251,445,973 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,023 | py | import os
import sys
import cv2
import numpy as np
import time
from PIL import Image
import face
def meny ():
print("1. Face detect and data gathering")
print("2. Face training")
print("3. ansikts igenkänning")
print("4. avsluta")
svar = input("Välj ett alternativ: ")
while not svar == "":
if svar == "1":
face.spara()
tillbaka()
break
elif svar == "2":
face.träna()
tillbaka()
break
elif svar == "3":
face.igenkänning()
tillbaka()
break
elif svar == "4":
sys.exit(0)
def tillbaka():
svar = input("vill du gå tillbacka till menyn skriv ja, vill du avsluta programet klicka vallfri knapp ")
if svar == "Ja" or svar == "j" or svar == "J" or svar =="ja":
meny()
else:
sys.exit()
if __name__ == "__main__":
meny()
| [
"noreply@github.com"
] | linwes.noreply@github.com |
795451f72b9ef19b07d24bd207ab4e7e75ad797a | 9a9a943e0e5666d9abd1e225a61e4d769b3cd7f3 | /third_party/cleverhans/cleverhans/utils_mnist.py | e85f031e8ebb03e751dd64c801601c6750bd52e0 | [
"BSD-2-Clause",
"MIT"
] | permissive | ptrcarta/neural-fingerprinting | edee091677d74c5e1c446263fd1fa45a8233daa4 | 01fa8cb592f6fa7497c6884861adf7680ffa7f29 | refs/heads/master | 2020-04-08T19:55:14.763296 | 2018-11-29T16:27:21 | 2018-11-29T16:27:21 | 159,676,331 | 0 | 1 | BSD-3-Clause | 2018-11-29T14:11:37 | 2018-11-29T14:11:37 | null | UTF-8 | Python | false | false | 3,664 | py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import array
import functools
import gzip
import operator
import os
import struct
import tempfile
import numpy as np
from cleverhans import utils
def maybe_download_mnist_file(file_name, datadir=None, force=False):
try:
from urllib.parse import urljoin
from urllib.request import urlretrieve
except ImportError:
from urlparse import urljoin
from urllib import urlretrieve
if not datadir:
datadir = tempfile.gettempdir()
dest_file = os.path.join(datadir, file_name)
if force or not os.path.isfile(file_name):
url = urljoin('http://yann.lecun.com/exdb/mnist/', file_name)
urlretrieve(url, dest_file)
return dest_file
def download_and_parse_mnist_file(file_name, datadir=None, force=False):
file_name = maybe_download_mnist_file(file_name, datadir=datadir,
force=force)
# Open the file and unzip it if necessary
if os.path.splitext(file_name)[1] == '.gz':
open_fn = gzip.open
else:
open_fn = open
# Parse the file
with open_fn(file_name, 'rb') as file_descriptor:
header = file_descriptor.read(4)
assert len(header) == 4
zeros, data_type, n_dims = struct.unpack('>HBB', header)
assert zeros == 0
hex_to_data_type = {
0x08: 'B',
0x09: 'b',
0x0b: 'h',
0x0c: 'i',
0x0d: 'f',
0x0e: 'd'}
data_type = hex_to_data_type[data_type]
dim_sizes = struct.unpack(
'>' + 'I' * n_dims,
file_descriptor.read(4 * n_dims))
data = array.array(data_type, file_descriptor.read())
data.byteswap()
desired_items = functools.reduce(operator.mul, dim_sizes)
assert len(data) == desired_items
return np.array(data).reshape(dim_sizes)
def data_mnist(datadir='/tmp/', train_start=0, train_end=60000, test_start=0,
test_end=10000):
"""
Load and preprocess MNIST dataset
:param datadir: path to folder where data should be stored
:param train_start: index of first training set example
:param train_end: index of last training set example
:param test_start: index of first test set example
:param test_end: index of last test set example
:return: tuple of four arrays containing training data, training labels,
testing data and testing labels.
"""
assert isinstance(train_start, int)
assert isinstance(train_end, int)
assert isinstance(test_start, int)
assert isinstance(test_end, int)
X_train = download_and_parse_mnist_file(
'train-images-idx3-ubyte.gz', datadir=datadir) / 255.
Y_train = download_and_parse_mnist_file(
'train-labels-idx1-ubyte.gz', datadir=datadir)
X_test = download_and_parse_mnist_file(
't10k-images-idx3-ubyte.gz', datadir=datadir) / 255.
Y_test = download_and_parse_mnist_file(
't10k-labels-idx1-ubyte.gz', datadir=datadir)
X_train = np.expand_dims(X_train, -1)
X_test = np.expand_dims(X_test, -1)
X_train = X_train[train_start:train_end]
Y_train = Y_train[train_start:train_end]
X_test = X_test[test_start:test_end]
Y_test = Y_test[test_start:test_end]
Y_train = utils.to_categorical(Y_train, num_classes=10)
Y_test = utils.to_categorical(Y_test, num_classes=10)
return X_train, Y_train, X_test, Y_test
if __name__ == '__main__':
X_train, Y_train, X_test, Y_test = data_mnist()
| [
"sdathath@caltech.edu"
] | sdathath@caltech.edu |
c2321c30432183d23b15ae143923eaf6ad07ae89 | 7cdb18e0a7ef01a34ec602bb31aa915c482fcd24 | /hujian_api/API_service/Course/c_class.py | 3025bce96eba7f43eb8eea3acbd91dd212fd1b56 | [] | no_license | wangdan377/Python_API | 6adac56974f9c6af238895a3101db0e3f0667ba1 | 38b31d4d02740d359a7e47fb3a3975045f00288e | refs/heads/master | 2023-02-18T14:39:03.009815 | 2021-01-20T12:59:52 | 2021-01-20T12:59:52 | 311,855,608 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 2,712 | py | import pytest
import allure
import requests
import json
import time
import random
from Common import Post
from Common import Get
from Common import Assert
from Common import Consts
class Editor_filter:
#登录
def filter_00(self):
sessionX = requests.session()
post_req = Post.Post()
ass = Assert.Assertions()
url = 'http://47.99.180.185:3999/login'
params = {'username':'admin@zhiyun-tech.com', 'password':'helloworld'}
res = post_req.post_model_b(sessionX, url, params)
resCode = res['code']
resText = res['text']
assert ass.assert_code(resCode, 200)
assert ass.assert_in_text(resText, '成功')
Consts.RESULT_LIST.append('True')
return sessionX
#获取教程分类列表
def filter_01(self):
sessionX = requests.session()
get_req = Get.Get()
ass = Assert.Assertions()
times = int(time.time())
rNumber = random.randint(1,100)
url = 'http://47.99.180.185:2999/v1/courses/getProductType?lang=zh_cn&productId=3'
res = get_req.get_model_a(sessionX, url)
print(res)
resCode = res['code']
resText = res['text']
assert ass.assert_code(resCode, 200)
assert ass.assert_in_text(resText, '成功')
Consts.RESULT_LIST.append('True')
#获取分类下教程列表
def filter_02(self,id):
sessionX = requests.session()
get_req = Get.Get()
ass = Assert.Assertions()
times = int(time.time())
rNumber = random.randint(1,100)
url = 'http://47.99.180.185:2999/v1/music/list?page=1&pageSize=10&albumId='+id
res = get_req.get_model_a(sessionX, url)
print(res)
resCode = res['code']
resText = res['text']
assert ass.assert_code(resCode, 200)
assert ass.assert_in_text(resText, '成功')
Consts.RESULT_LIST.append('True')
#查询教程产品下的说明书
def filter_03(self):
sessionX = requests.session()
get_req = Get.Get()
ass = Assert.Assertions()
times = int(time.time())
rNumber = random.randint(1,100)
url = 'http://47.99.180.185:2999/v1/music/hot/list?page=1&pageSize=10'
res = get_req.get_model_a(sessionX, url)
print(res)
resCode = res['code']
resText = res['text']
assert ass.assert_code(resCode, 200)
assert ass.assert_in_text(resText, '成功')
Consts.RESULT_LIST.append('True')
#查询投放的教程产品
#模糊查询分类
#分类下视频获取
#获取zfilm首页展示分类列表
if __name__ == '__main__':
a = Editor_filter()
a.filter_02('62')
| [
"1065913054@qq.com"
] | 1065913054@qq.com |
1d046a634c8d776255b88afd16f6a14e1b8f1e0e | f68cd3a3cfd8b973e8b46b868b833df060d8303c | /nodes/ardrone_control/lib/Sensors.py | a0df0b8897ca7331667c7319dd1dd2e0b458f0f3 | [] | no_license | sebascuri/QUACS | 2905f12b1c01694f86bbf205dce7640f2d1e4a41 | 4787e446f5fb7678043397616d2ee41099cb4295 | refs/heads/master | 2020-05-19T22:58:53.158814 | 2014-04-24T21:33:41 | 2014-04-24T21:33:41 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 22,738 | py | #!/usr/bin/env python
from math import pi, cos, sin, sqrt, atan2, asin
import numpy as np
import numpy.matlib as matlib
import utm
import rospy;
# import gps_transforms
from BasicObject import BasicObject, SixDofObject, Quaternion
from Filter import ExtendedKalmanFilter, MagdwickFilter, MahoneyFilter
from ROS import ROS_Object
from geometry_msgs.msg import Vector3Stamped; global Vector3Stamped
try:
import tf;
except ImportError:
import roslib; roslib.load_manifest('ardrone_control')
import tf;
class Sensor(BasicObject, object):
"""docstring for Sensor
There are two sets of data, measured variables and state variables
Transformation between state variables and measured variables can be the identity or something more complex.
To go from measured variables to state variables use measure method
Measure method uses object variables and changes state of object. New measurements are passed by argument
It returns None.
To go from state variables to measured variables use map method
Map method uses argument variables and does not change state of object
It returns the mapping in measurement space.
There is a list that maps Z (measurement vector) and measurement properties named measurementList
"""
def __init__(self, **kwargs):
super(Sensor, self).__init__( **kwargs )
self.properties.update( measurementList = kwargs.get('measurementList', self.measurementList ),
stateList = kwargs.get('stateList',self.stateList ) )
for attribute in self.measurementList:
setattr(self, attribute, kwargs.get(attribute, 0.) )
for key in self.stateList:
attribute = key.split('.')[1]
setattr( self, attribute, kwargs.get(attribute, 0.) )
self.properties.update(
Z = kwargs.get('Z', matlib.zeros( [len(self), 1] )),
StateMap = kwargs.get('StateMap', matlib.zeros( [len(self) , 1] )),
MeasurementJacobian = kwargs.get('MeasurementJacobian', matlib.eye( len(self) ) ),
MeasurementCovariance = kwargs.get('MeasurementCovariance', 0.3 * matlib.eye( len(self) )),
)
# self.Z = kwargs.get('Z', matlib.zeros( [len(self), 1] ))
# self.StateMap = kwargs.get('StateMap', matlib.zeros( [len(self) , 1] ))
# self.MeasurementJacobian = kwargs.get('MeasurementJacobian', matlib.eye( len(self) ) )
# self.MeasurementCovariance = kwargs.get('MeasurementCovariance', 0.3 * matlib.eye( len(self) ))
self.set_Z()
def __len__(self):
return np.size(self.measurementList)
def __eq__(self, data):
return str(self) == data
def measure(self, **kwargs):
""" input sensor values and assing them to state Vector"""
for key in self.stateList:
attribute = key.split('.')[1]
setattr( self, attribute, kwargs.get(attribute, getattr(self, attribute) ) ) #input new value or stay with same value
self.set_Z()
def map(self, **kwargs):
""" map state variables from Quadrotor and returns a vector of what it should have been measured """
i = 0
for key in self.stateList:
attribute = key.split('.')[1]
self.StateMap[ i ] = kwargs.get(attribute, self.StateMap[ i ])
i += 1
"""
for key, value in kwargs.items():
for name in self.stateList:
attribute = name.split('.')[1]
if attribute == key:
self.StateMap[ self.stateList.index(name) ] = value
"""
def get_state(self):
state_dict = dict( )
for key in self.stateList:
attribute = key.split('.')[1]
state_dict[attribute] = getattr(self, attribute)
return state_dict
def get_measurement(self):
measure_dict = dict( )
for key in self.properties.keys():
if key in self.measurementList:
measure_dict[key] = getattr(self, key)
return measure_dict
def get_measurementvector(self):
l = []
for measure in self.measurementList:
l.append(getattr(self, measure))
return np.array(l).transpose()
def get_measurementList(self):
return self.measurementList
def set_Z(self):
i = 0
for key in self.measurementList:
# attribute = key.split('.')[1]
self.Z[i] = getattr(self, key)
i += 1
@property
def Z(self):
return self.properties.get('Z', matlib.zeros( [len(self), 1] ) )
@Z.setter
def Z(self, *args, **kwargs):
for arg in args:
if type(arg) == type( matlib.zeros(1) ):
self.properties['Z'] = arg
elif type(arg) == type( dict() ):
for key, value in arg.items():
self.Z[ self.stateList.index(key) ][0] = value
for key, value in kwargs.items():
self.Z[ self.stateList.index(key) ][0] = value
@Z.deleter
def Z(self):
del self.properties['Z']
@property
def StateMap(self):
return self.properties.get('StateMap', matlib.zeros( [len(self), 1] ) )
@StateMap.setter
def StateMap(self, *args, **kwargs):
for arg in args:
if type(arg) == type( matlib.zeros(1) ):
self.properties['StateMap'] = arg
elif type(arg) == type( dict() ):
for key, value in arg.items():
self.StateMap[ self.stateList.index(key) ][0] = value
for key, value in kwargs.items():
self.StateMap[ self.stateList.index(key) ][0] = value
@StateMap.deleter
def StateMap(self):
del self.properties['StateMap']
@property
def MeasurementJacobian(self):
return self.properties.get('MeasurementJacobian', matlib.eye( len(self) ) )
@MeasurementJacobian.setter
def MeasurementJacobian(self, H):
self.properties['MeasurementJacobian'] = H
@MeasurementJacobian.deleter
def MeasurementJacobian(self):
del self.properties['MeasurementJacobian']
@property
def MeasurementCovariance(self):
return self.properties.get('MeasurementCovariance', 0.3 * matlib.eye( len(self) ) )
@MeasurementCovariance.setter
def MeasurementCovariance(self, R):
self.properties['MeasurementCovariance'] = R
@MeasurementCovariance.deleter
def MeasurementCovariance(self):
del self.properties['MeasurementCovariance']
@property
def stateList(self):
return self.properties.get('stateList', list())
@stateList.setter
def stateList(self, stateList):
self.properties['stateList'] = stateList
@stateList.deleter
def stateList(self):
del self.properties['stateList']
@property
def measurementList(self):
return self.properties.get('measurementList', list())
@measurementList.setter
def measurementList(self, measurementList):
self.properties['measurementList'] = measurementList
@measurementList.deleter
def measurementList(self):
del self.properties['measurementList']
class DummyYaw(Sensor, object):
measurementList = ['yaw']
stateList = ['position.yaw']
"""docstring for DummyYaw
just a Dummy object used for Kalman Filtering Convergence.
Input is a Yaw, Output is the same Yaw
"""
def __init__(self, **kwargs):
super(DummyYaw, self).__init__(stateList = DummyYaw.stateList, measurementList = DummyYaw.measurementList, **kwargs)
self.MeasurementCovariance = matlib.zeros( (len(self), len(self)) )
# self.x = 0
# self.y = 0
# self.z = 0
# self.w = 1
def measure(self, imu_raw):
q = imu_raw.orientation
euler = tf.transformations.euler_from_quaternion( (q.x, q.y, q.z, q.w), axes = 'sxyz' )
super(DummyYaw, self).measure(yaw = euler[2] )
@property
def yaw(self):
return self.properties.get('yaw', 0.0)
@yaw.setter
def yaw(self, yaw):
self.properties['yaw'] = yaw
@yaw.deleter
def yaw(self):
del self.properties['yaw']
class GPS(Sensor, object):
"""docstring for GPS
x is easting
y is northing
z is altitude
the gps_zero['yaw'] is a rotation around Z between northing, easting to global xyz.
"""
measurementList = ['x', 'y', 'z']
stateList = ['position.x', 'position.y', 'position.z']
def __init__(self, **kwargs):
super(GPS, self).__init__(**kwargs)
self.MeasurementCovariance= 0.4 * matlib.eye( len(self.measurementList) )
easting, northing, number, letter = utm.from_latlon( kwargs.get('latitude', 0) , kwargs.get('longitude', 0) )
self.gps_zero = dict( x = easting, y = northing, z = kwargs.get('altitude', utm.conversion.R), yaw = pi/2)
self.calibrated = False
def set_zero(self, fix_zero):
easting, northing, number, letter = utm.from_latlon( fix_zero.latitude, fix_zero.longitude )
self.gps_zero['x'] = easting
self.gps_zero['y'] = northing
self.gps_zero['z'] = fix_zero.altitude
def set_zero_yaw(self, yaw):
self.gps_zero['yaw'] = yaw
def measure(self, fix_data):
# set measurements
# for key in self.measurementList:
# setattr(self, key, getattr(fix_data, key) )
# transform latitude longitude to easting, northing
easting, northing, number, letter = utm.from_latlon( fix_data.latitude, fix_data.longitude )
enu_x = easting - self.gps_zero['x']
enu_y = northing - self.gps_zero['y']
enu_yaw = self.gps_zero['yaw']
super(GPS, self).measure(
x = enu_x * cos( enu_yaw ) - enu_y * sin( enu_yaw ),
y = enu_x * sin( enu_yaw ) + enu_y * cos( enu_yaw ) ,
z = fix_data.altitude - self.gps_zero['z'] )
self.set_Z()
@property
def latitude(self):
return self.properties.get('latitude', 0.0 )
@latitude.setter
def latitude(self, latitude):
self.properties['latitude'] = latitude
@latitude.deleter
def latitude(self):
del self.properties['latitude']
@property
def longitude(self):
return self.properties.get('longitude', 0.0)
@longitude.setter
def longitude(self, longitude):
self.properties['longitude'] = longitude
@longitude.deleter
def longitude(self):
del self.properties['longitude']
@property
def altitude(self):
return self.properties.get('altitude', utm.conversion.R )
@altitude.setter
def altitude(self, altitude):
self.properties['altitude'] = altitude
@altitude.deleter
def altitude(self):
del self.properties['altitude']
@property
def x(self):
return self.properties.get('x', 0.0)
@x.setter
def x(self, x):
self.properties['x'] = x
@x.deleter
def x(self):
del self.properties['x']
@property
def y(self):
return self.properties.get('y', 0.0)
@y.setter
def y(self, y):
self.properties['y'] = y
@y.deleter
def y(self):
del self.properties['y']
@property
def z(self):
return self.properties.get('z', 0.0)
@z.setter
def z(self, z):
self.properties['z'] = z
@z.deleter
def z(self):
del self.properties['z']
class Camera(Sensor, object):
"""docstring for Camera"""
def __init__(self, **kwargs):
super(Camera, self).__init__()
class Gyroscope(Sensor, object):
"""docstring for Gyroscope
Reads roll, pitch and yaw velocities as input as assing them to outputs.
"""
measurementList = ['roll', 'pitch', 'yaw']
stateList = ['velocity.roll', 'velocity.pitch', 'velocity.yaw']
Angles_MAP = dict(
roll = 'x',
pitch = 'y',
yaw = 'z'
)
def __init__(self, roll = 0, pitch = 0, yaw = 0, **kwargs):
super(Gyroscope, self).__init__(stateList = Gyroscope.stateList, measurementList = Gyroscope.measurementList, **kwargs)
self.MeasurementCovariance= 0.4 * matlib.eye( len(self.measurementList) )
def measure(self, imu_raw):
for measure in self.measurementList:
setattr(self, measure, getattr(imu_raw.angular_velocity, self.Angles_MAP[measure] ) )
self.set_Z()
def get_quaternion(self):
return (self.roll, self.pitch, self.yaw, 0)
@property
def yaw(self):
return self.properties.get('yaw', 0.0)
@yaw.setter
def yaw(self, yaw):
self.properties['yaw'] = yaw
@yaw.deleter
def yaw(self):
del self.properties['yaw']
@property
def pitch(self):
return self.properties.get('pitch', 0.0)
@pitch.setter
def pitch(self, pitch):
self.properties['pitch'] = pitch
@pitch.deleter
def pitch(self):
del self.properties['pitch']
@property
def roll(self):
return self.properties.get('roll', 0.0)
@roll.setter
def roll(self, roll):
self.properties['roll'] = roll
@roll.deleter
def roll(self):
del self.properties['roll']
class Accelerometer(Sensor, object):
"""docstring for Accelerometer
Reads ax, ay and az and calculates roll and pitch of the vehicle.
"""
measurementList = ['ax', 'ay', 'az']
stateList = ['position.roll', 'position.pitch']
def __init__(self, **kwargs):
super(Accelerometer, self).__init__(stateList = Accelerometer.stateList, measurementList = Accelerometer.measurementList, **kwargs)
def measure(self, imu_raw):
for measure in self.measurementList:
setattr(self, measure, getattr(imu_raw.linear_acceleration, measure[1] ) )
g = sqrt(self.ax**2 + self.ay**2 + self.az**2)
self.roll = atan2(-self.ax, self.az)
self.pitch = -asin(self.ay/g)
self.set_Z()
@property
def pitch(self):
return self.properties.get('pitch', 0.0)
@pitch.setter
def pitch(self, pitch):
self.properties['pitch'] = pitch
@pitch.deleter
def pitch(self):
del self.properties['pitch']
@property
def roll(self):
return self.properties.get('roll', 0.0)
@roll.setter
def roll(self, roll):
self.properties['roll'] = roll
@roll.deleter
def roll(self):
del self.properties['roll']
@property
def ax(self):
return self.properties.get('ax', 0.0)
@ax.setter
def ax(self, ax):
self.properties['ax'] = ax
@ax.deleter
def ax(self):
del self.properties['ax']
@property
def ay(self):
return self.properties.get('ay', 0.0)
@ay.setter
def ay(self, ay):
self.properties['ay'] = ay
@ay.deleter
def ay(self):
del self.properties['ay']
@property
def az(self):
return self.properties.get('az', 0.0)
@az.setter
def az(self, az):
self.properties['az'] = az
@az.deleter
def az(self):
del self.properties['az']
class Magnetomer(Sensor, object):
"""docstring for Magnetomer
Reads Hx, Hy and Hz and calculates global yaw of the vehicle.
"""
measurementList = ['Hx', 'Hy', 'Hz']
stateList = ['position.yaw']
def __init__(self, **kwargs):
super(Magnetomer, self).__init__(stateList = Magnetomer.stateList, measurementList = Magnetomer.measurementList, **kwargs)
def set_pitchroll(self, *args, **kwargs):
if len(args) == 2:
self.pitch = args[0]
self.roll = args[1]
elif len(args) == 1:
arg = args[0]
if type(arg) == dict():
return set_pitchroll(**arg)
else:
self.pitch = arg[0]
self.roll = arg[1]
for key, value in kwargs.items():
setattr(self, key, value)
def measure(self, navdata):
self.Hx = navdata.magX
self.Hy = navdata.magY
self.Hz = navdata.magZ
self.yaw = atan2( self.Hz * sin( self.roll ) - self.Hy * cos( self.roll ),
self.Hx * cos( self.pitch ) + (self.Hy * sin( self.roll ) + self.Hz * cos( self.roll ) ) * sin( self.pitch ) )
super(GPS, self).measure(yaw = self.yaw)
@property
def Hx(self):
return self.properties.get('Hx', 0.0)
@Hx.setter
def Hx(self, Hx):
self.properties['Hx'] = Hx
@Hx.deleter
def Hx(self):
del self.properties['Hx']
@property
def Hy(self):
return self.properties.get('Hy', 0.0)
@Hy.setter
def Hy(self, Hy):
self.properties['Hy'] = Hy
@Hy.deleter
def Hy(self):
del self.properties['Hy']
@property
def Hz(self):
return self.properties.get('Hz', 0.0)
@Hz.setter
def Hz(self, Hz):
self.properties['Hz'] = Hz
@Hz.deleter
def Hz(self):
del self.properties['Hz']
@property
def yaw(self):
return self.properties.get('yaw', 0.0)
@yaw.setter
def yaw(self, yaw):
self.properties['yaw'] = yaw
@yaw.deleter
def yaw(self):
del self.properties['yaw']
@property
def pitch(self):
return self.properties.get('pitch', 0.0)
@pitch.setter
def pitch(self, pitch):
self.properties['pitch'] = pitch
@pitch.deleter
def pitch(self):
del self.properties['pitch']
@property
def roll(self):
return self.properties.get('roll', 0.0)
@roll.setter
def roll(self, roll):
self.properties['roll'] = roll
@roll.deleter
def roll(self):
del self.properties['roll']
class RangeSensor(BasicObject, ROS_Object, object):
"""docstring for RangeSensor
This Sensor recieves a Range() message and publishes a tf
with the location of the nearer object.
Convention used is that the range object measures distance in Z and
The rotation from /drone_local tf to range tf is done by yaw-pitch-roll euler angles and then
xyz translation in z
methods isFar and isNear publish boolean messages for landing and detection of objects
"""
def __init__(self, **kwargs):
super(RangeSensor, self).__init__()
self.max_range = kwargs.get('max_range', 3000.0)
self.min_range = kwargs.get('min_range', 0.0)
self.range = kwargs.get('range', 0.0)
self.min_safe = kwargs.get('min_safe', None)
self.zero = dict(
x = kwargs.get('x', 0),
y = kwargs.get('y', 0),
z = kwargs.get('z', 0),
roll = kwargs.get('roll', 0),
pitch = kwargs.get('pitch', 0),
yaw = kwargs.get('yaw', 0)
)
self.name = kwargs.get('name', 'range')
self.tf_broadcaster.update(range_tf = tf.TransformBroadcaster())
self.Broadcast()
def measure(self, range_data):
self.max_range = range_data.max_range
self.min_range = range_data.min_range
self.range = range_data.range
def isFar(self):
return self.range >= self.max_range
def isNear(self):
return self.range <= self.min_range or self.range <= self.min_safe
def Broadcast(self):
# print "Broadcasting"
time = rospy.Time.now()
self.tf_broadcaster['range_tf'].sendTransform( (self.zero['x'], self.zero['y'], self.zero['z'] + self.range ),
tf.transformations.quaternion_from_euler(self.zero['roll'], self.zero['pitch'], self.zero['yaw']),
time,
"/drone_local",
self.name
)
@property
def range(self):
return self.properties.get('range', None)
@range.setter
def range(self, new_range):
self.properties['range'] = new_range
@range.deleter
def range(self):
del self.properties['range']
@property
def max_range(self):
return self.properties.get('max_range', None)
@max_range.setter
def max_range(self, max_range):
self.properties['max_range'] = max_range
@max_range.deleter
def max_range(self):
del self.properties['max_range']
@property
def min_range(self):
return self.properties.get('min_range', None)
@min_range.setter
def min_range(self, min_range):
self.properties['min_range'] = min_range
@min_range.deleter
def min_range(self):
del self.properties['min_range']
class IMU(BasicObject, object):
"""docstring for IMU"""
measurementList = ['roll', 'pitch', 'yaw']
def __init__(self, **kwargs):
super(IMU, self).__init__(**kwargs)
self.sensors = dict(
dummy_yaw = DummyYaw(),
gyroscope = Gyroscope(),
accelerometer = Accelerometer()
)
def measure(self, imu_raw):
for sensor in self.sensors.values():
sensor.measure(imu_raw)
@property
def sensors(self):
return self.properties.get('sensors', None)
@sensors.setter
def sensors(self, sensors):
self.properties['sensors'] = sensors
@sensors.deleter
def sensors(self):
del self.properties['sensors']
class Velocity(SixDofObject, Sensor, object):
"""docstring for Velocity"""
measurementList = ['x', 'y', 'z']
stateList = ['velocity.x', 'velocity.y', 'velocity.z']
def __init__(self, **kwargs):
super(Velocity, self).__init__(**kwargs)
if not hasattr(self, 'velocity'):
self.velocity = SixDofObject()
self.velocity.x = self.x
self.velocity.y = self.y
self.velocity.z = self.z
def measure(self, navdata):
for measure in self.measurementList:
setattr(self, measure, getattr(navdata, 'v%s'%measure)/1000.0 )
self.set_Z()
self.set_velocities()
def set_velocities(self):
for measure in self.measurementList:
setattr(self.velocity, measure, getattr(self, measure))
@property
def x(self):
return self.properties.get('x', 0.0)
@x.setter
def x(self, x):
self.properties['x'] = x
@x.deleter
def x(self):
del self.properties['x']
@property
def y(self):
return self.properties.get('y', 0.0)
@y.setter
def y(self, y):
self.properties['y'] = y
@y.deleter
def y(self):
del self.properties['y']
@property
def z(self):
return self.properties.get('z', 0.0)
@z.setter
def z(self, z):
self.properties['z'] = z
@z.deleter
def z(self):
del self.properties['z']
def yaw_test():
yaw_sensor = DummyYaw(yaw = pi/2 )
print yaw_sensor.yaw
print yaw_sensor.Z
print yaw_sensor.StateMap
print yaw_sensor.MeasurementCovariance
yaw_sensor.map(yaw = 1.56)
yaw_sensor.measure(yaw = 1.57)
print yaw_sensor.Z
print yaw_sensor.StateMap
print yaw_sensor.MeasurementJacobian
def velocity_test():
import roslib; roslib.load_manifest('ardrone_control')
from ardrone_autonomy.msg import Navdata
sensor = Velocity()
msg = Navdata()
msg.vx = 0.1
msg.vy = -0.2
sensor.measure(msg)
sensor.measure(msg)
print sensor.properties
print sensor.velocity
print sensor.x
def gps():
print utm.conversion.R
import roslib; roslib.load_manifest('ardrone_control')
import rospy; global rospy
from sensor_msgs.msg import NavSatFix
# rospy.init_node('test')
gps = GPS()
#print gps
m = NavSatFix()
m.latitude = 45.0
m.altitude = utm.conversion.R
m.longitude = 20.0
gps.set_zero(m)
gps.measure(m)
print gps.get_state()
print gps.Z
m.latitude = 45.1
m.altitude = utm.conversion.R
m.longitude = 20.0
gps.measure(m)
print gps.get_state()
print gps.Z
gps.set_zero_yaw( 30 * pi/180 )
gps.measure(m)
print gps.get_state()
print gps.get_measurement()
print gps.Z
for i in range(10000):
gps.measure(m)
gps.Broadcast()
rospy.spin()
def range_test():
from sensor_msgs.msg import Range
sensor = RangeSensor()
print sensor
m = Range()
m.range = 2000.0
m.max_range = 3000.0
m.min_range = 2.01
sensor.min_safe = 500
sensor.measure(m)
print sensor
print sensor.isNear()
print sensor.isFar()
m.range = 4000
sensor.measure(m)
print sensor
print sensor.isNear()
print sensor.isFar()
m.range = -2000
sensor.measure(m)
print sensor
print sensor.isNear()
print sensor.isFar()
m.range = 300
sensor.measure(m)
print sensor
print sensor.isNear()
print sensor.isFar()
def imu_test():
g = 9.81
from sensor_msgs.msg import Imu
import roslib; roslib.load_manifest('ardrone_control')
import rospy; global rospy
import tf; global tf;
# sensor = IMU()
msg = Imu()
msg.angular_velocity.z = 1.0
msg.linear_acceleration.z = -9.81
msg.linear_acceleration.x = -0.01
msg.orientation.z = 1/sqrt(2)
msg.orientation.w = 1/sqrt(2)
# msg.linear_acceleration.z = g
# sensor.measure(msg)
# for sensor in sensor.sensors.values():
# print sensor.properties
sensor = IMU()
#sensor = IMU_Mahoney( Ts = 0.01)
#sensor = IMU_Magdwick( Ts = 0.01)
sensor.measure(msg)
print sensor.sensors['accelerometer']
print sensor.sensors['gyroscope']
print sensor.sensors['dummy_yaw']
# print sensor.X
# sensor.predict()
# sensor.predict()
# sensor.predict()
# sensor.predict()
# print sensor.X
# sensor.correct()
# print sensor.get_quaternion()
# print sensor.get_eulers()
def main():
#gps_test()
#yaw_test()
gps()
#range_test()
#imu_test()
velocity_test()
if __name__ == '__main__': main() | [
"sebascuri@gmail.com"
] | sebascuri@gmail.com |
2e42eed62a4d8e9d20c318b9c955183fa56f6af1 | 2a471e8d6f3a6007d4bce8f6fc5a5b6902ed7337 | /ai.py | c008f48bc90fa6ba8e2d3df35127a5f4030ea601 | [
"MIT"
] | permissive | ClownMonster/ChessAI | a9b38445013bee10ea29790b28058827037d04e4 | c282a362fc59483f77b854d6fad1d24914620b9c | refs/heads/master | 2022-12-10T11:11:33.651508 | 2020-09-08T01:55:03 | 2020-09-08T01:55:03 | 293,546,019 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,696 | py | import board, pieces, numpy
class Heuristics:
# The tables denote the points scored for the position of the chess pieces on the board.
PAWN_TABLE = numpy.array([
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 5, 10, 10,-20,-20, 10, 10, 5],
[ 5, -5,-10, 0, 0,-10, -5, 5],
[ 0, 0, 0, 20, 20, 0, 0, 0],
[ 5, 5, 10, 25, 25, 10, 5, 5],
[10, 10, 20, 30, 30, 20, 10, 10],
[50, 50, 50, 50, 50, 50, 50, 50],
[ 0, 0, 0, 0, 0, 0, 0, 0]
])
KNIGHT_TABLE = numpy.array([
[-50, -40, -30, -30, -30, -30, -40, -50],
[-40, -20, 0, 5, 5, 0, -20, -40],
[-30, 5, 10, 15, 15, 10, 5, -30],
[-30, 0, 15, 20, 20, 15, 0, -30],
[-30, 5, 15, 20, 20, 15, 0, -30],
[-30, 0, 10, 15, 15, 10, 0, -30],
[-40, -20, 0, 0, 0, 0, -20, -40],
[-50, -40, -30, -30, -30, -30, -40, -50]
])
BISHOP_TABLE = numpy.array([
[-20, -10, -10, -10, -10, -10, -10, -20],
[-10, 5, 0, 0, 0, 0, 5, -10],
[-10, 10, 10, 10, 10, 10, 10, -10],
[-10, 0, 10, 10, 10, 10, 0, -10],
[-10, 5, 5, 10, 10, 5, 5, -10],
[-10, 0, 5, 10, 10, 5, 0, -10],
[-10, 0, 0, 0, 0, 0, 0, -10],
[-20, -10, -10, -10, -10, -10, -10, -20]
])
ROOK_TABLE = numpy.array([
[ 0, 0, 0, 5, 5, 0, 0, 0],
[-5, 0, 0, 0, 0, 0, 0, -5],
[-5, 0, 0, 0, 0, 0, 0, -5],
[-5, 0, 0, 0, 0, 0, 0, -5],
[-5, 0, 0, 0, 0, 0, 0, -5],
[-5, 0, 0, 0, 0, 0, 0, -5],
[ 5, 10, 10, 10, 10, 10, 10, 5],
[ 0, 0, 0, 0, 0, 0, 0, 0]
])
QUEEN_TABLE = numpy.array([
[-20, -10, -10, -5, -5, -10, -10, -20],
[-10, 0, 5, 0, 0, 0, 0, -10],
[-10, 5, 5, 5, 5, 5, 0, -10],
[ 0, 0, 5, 5, 5, 5, 0, -5],
[ -5, 0, 5, 5, 5, 5, 0, -5],
[-10, 0, 5, 5, 5, 5, 0, -10],
[-10, 0, 0, 0, 0, 0, 0, -10],
[-20, -10, -10, -5, -5, -10, -10, -20]
])
@staticmethod
def evaluate(board):
material = Heuristics.get_material_score(board)
pawns = Heuristics.get_piece_position_score(board, pieces.Pawn.PIECE_TYPE, Heuristics.PAWN_TABLE)
knights = Heuristics.get_piece_position_score(board, pieces.Knight.PIECE_TYPE, Heuristics.KNIGHT_TABLE)
bishops = Heuristics.get_piece_position_score(board, pieces.Bishop.PIECE_TYPE, Heuristics.BISHOP_TABLE)
rooks = Heuristics.get_piece_position_score(board, pieces.Rook.PIECE_TYPE, Heuristics.ROOK_TABLE)
queens = Heuristics.get_piece_position_score(board, pieces.Queen.PIECE_TYPE, Heuristics.QUEEN_TABLE)
return material + pawns + knights + bishops + rooks + queens
# Returns the score for the position of the given type of piece.
# A piece type can for example be: pieces.Pawn.PIECE_TYPE.
# The table is the 2d numpy array used for the scoring. Example: Heuristics.PAWN_TABLE
@staticmethod
def get_piece_position_score(board, piece_type, table):
white = 0
black = 0
for x in range(board.Board.WIDTH):
for y in range(board.Board.HEIGHT):
piece = board.pieces[x][y]
if (piece != 0):
if (piece.piece_type == piece_type):
if (piece.color == pieces.Piece.WHITE):
white += table[x][y]
else:
black += table[7 - x][y]
return white - black
@staticmethod
def get_material_score(board):
white = 0
black = 0
for x in range(board.Board.WIDTH):
for y in range(board.Board.HEIGHT):
piece = board.pieces[x][y]
if (piece != 0):
if (piece.color == pieces.Piece.WHITE):
white += piece.value
else:
black += piece.value
return white - black
class AI:
INFINITE = 10000000
@staticmethod
def get_ai_move(board, invalid_moves):
best_move = 0
best_score = AI.INFINITE
for move in board.get_possible_moves(pieces.Piece.BLACK):
if (AI.is_invalid_move(move, invalid_moves)):
continue
copy = board.Board.clone(board)
copy.perform_move(move)
score = AI.alphabeta(copy, 3, -AI.INFINITE, AI.INFINITE, True)
if (score < best_score):
best_score = score
best_move = move
# Checkmate.
if (best_move == 0):
return 0
copy = board.Board.clone(board)
copy.perform_move(best_move)
if (copy.is_check(pieces.Piece.BLACK)):
invalid_moves.append(best_move)
return AI.get_ai_move(board, invalid_moves)
return best_move
@staticmethod
def is_invalid_move(move, invalid_moves):
for invalid_move in invalid_moves:
if (invalid_move.equals(move)):
return True
return False
@staticmethod
def minimax(board, depth, maximizing):
if (depth == 0):
return Heuristics.evaluate(board)
if (maximizing):
best_score = -AI.INFINITE
for move in board.get_possible_moves(pieces.Piece.WHITE):
copy = board.Board.clone(board)
copy.perform_move(move)
score = AI.minimax(copy, depth-1, False)
best_score = max(best_score, score)
return best_score
else:
best_score = AI.INFINITE
for move in board.get_possible_moves(pieces.Piece.BLACK):
copy = board.Board.clone(board)
copy.perform_move(move)
score = AI.minimax(copy, depth-1, True)
best_score = min(best_score, score)
return best_score
@staticmethod
def alphabeta(board, depth, a, b, maximizing):
if (depth == 0):
return Heuristics.evaluate(board)
if (maximizing):
best_score = -AI.INFINITE
for move in board.get_possible_moves(pieces.Piece.WHITE):
copy = board.Board.clone(board)
copy.perform_move(move)
best_score = max(best_score, AI.alphabeta(copy, depth-1, a, b, False))
a = max(a, best_score)
if (b <= a):
break
return best_score
else:
best_score = AI.INFINITE
for move in board.get_possible_moves(pieces.Piece.BLACK):
copy = board.Board.clone(board)
copy.perform_move(move)
best_score = min(best_score, AI.alphabeta(copy, depth-1, a, b, True))
b = min(b, best_score)
if (b <= a):
break
return best_score
class Move:
def __init__(self, xfrom, yfrom, xto, yto, castling_move):
self.xfrom = xfrom
self.yfrom = yfrom
self.xto = xto
self.yto = yto
self.castling_move = castling_move
# Returns true iff (xfrom,yfrom) and (xto,yto) are the same.
def equals(self, other_move):
return self.xfrom == other_move.xfrom and self.yfrom == other_move.yfrom and self.xto == other_move.xto and self.yto == other_move.yto
def to_string(self):
return "(" + str(self.xfrom) + ", " + str(self.yfrom) + ") -> (" + str(self.xto) + ", " + str(self.yto) + ")" | [
"mk6386223@gmail.com"
] | mk6386223@gmail.com |
72a060428592795437ae3329b7ec56762c28a05b | 7275f7454ce7c3ce519aba81b3c99994d81a56d3 | /Programming-Collective-Intelligence/ch07/main.py | cea965bec22a5c20cdc4081bc9c0948547ffe229 | [] | no_license | chengqiangaoci/back | b4c964b17fb4b9e97ab7bf0e607bdc13e2724f06 | a26da4e4f088afb57c4122eedb0cd42bb3052b16 | refs/heads/master | 2020-03-22T08:36:48.360430 | 2018-08-10T03:53:55 | 2018-08-10T03:53:55 | 139,777,994 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 1,135 | py | import treepredict
# main function
# print('<----DivideSet---->')
# for item in treepredict.divideset(treepredict.my_data, 2, 'yes'):
# print(item)
#
print('\n<----Build and Display the Tree---->')
tree = treepredict.buildtree(treepredict.my_data)
treepredict.printtree(tree)
#
# print('\n<----Graphical Display---->')
# path = 'output/treeview.jpg'
# treepredict.drawtree(tree, jpeg=path)
# print("picture has been saved in " + path)
#
# print('\n<----Classify and prune---->')
# test = ['(direct)', 'USA', 'yes', 5]
# print(test)
# print(treepredict.classify(test, tree), '\n')
#
# print('Before pune:')
# treepredict.printtree(tree)
# treepredict.prune(tree, 1.0)
# print('\nAfter pune:')
# treepredict.printtree(tree)
# print('<----Zillow API---->')
# import zillow
# # housedata = zillow.getpricelist()
# # print('house data saved!')
# housedata = zillow.getdata('input/housedata.txt')
# print('house data read!')
# housetree = treepredict.buildtree(housedata, scoref=treepredict.variance)
# treepredict.printtree(housetree)
# treepredict.drawtree(housetree, 'output/housetree.jpg')
# HotOrNot API is deprecated since 2008
| [
"2395618655@qq.com"
] | 2395618655@qq.com |
ada9eb0e3ce075ebc01f1203fd530aaf833dafc4 | 4bdb8e324a833c10380bb7b1f436d1e9629c873c | /Ekeopara_Praise/Phase 1/Python Basic 1/Day2 Tasks/Task 5.py | 1d1d5cde955ffa3a4b7be09d0ba0fa45cd7803f2 | [
"MIT"
] | permissive | dreamchild7/python-challenge-solutions | e3831a57447f6132dd098be8b941cc27db92ace2 | 29e2ca780e86fc8a3e9d4def897c26bfa6d6493d | refs/heads/master | 2022-11-08T17:23:57.763110 | 2020-06-19T08:38:20 | 2020-06-19T08:38:20 | 263,923,130 | 0 | 0 | MIT | 2020-05-14T13:29:33 | 2020-05-14T13:29:32 | null | UTF-8 | Python | false | false | 253 | py | #5. Write a Python program which accepts the user's first and last name and print them in reverse order with a space between them.
f_name = str(input("Enter your first name: "))
l_name = str(input("Enter your last name: "))
print(f"{l_name} {f_name}") | [
"60721962+Ekeopara-Praise@users.noreply.github.com"
] | 60721962+Ekeopara-Praise@users.noreply.github.com |
aeee0d73e9f7dcabe76fb4619a04c8b7d5388da9 | 9c39488de0679e225c0d5a7d700c15bf18b4d44f | /app/app.py | 8f75acf66243a9549127f0c31f76c520c20391ba | [] | no_license | louishenrifranc/question_answering | a3843e2e378cc49336dd73933139d81c64d6a14c | a05125e8c765bb945f40a01a4f060080ce1ff324 | refs/heads/master | 2021-01-11T22:31:24.552576 | 2017-01-10T17:07:30 | 2017-01-10T17:07:30 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 657 | py | import os
import sys; sys.path.append("backend");
import mimetypes
import falcon
from question_answerer import QuestionAnswerer, Static, Index
app = application = falcon.API()
def static(req, res, static_dir="static", index_file="index.html"):
path = static_dir + req.path
if req.path == "/":
path += index_file
if os.path.isfile(path):
res.content_type = mimetypes.guess_type(path)[0]
res.status = falcon.HTTP_200
res.stream = open(path)
else:
res.status = falcon.HTTP_404
app.add_route("/ask", QuestionAnswerer())
app.add_route("/", Index())
app.add_route("/static/{file_name}", Static())
| [
"antoinelb7@gmail.com"
] | antoinelb7@gmail.com |
b7561861692b05aff15218f147026b6fb7405751 | 0103f28c9ecd6223679f560e6556ac8b9078c25a | /module_0/main.py | 08fd680be47b58083ad2510b7a3b33c844925ab8 | [] | no_license | lunathirteen/skillfactory_rds | 05f0eb1f9d71016a4a50df93b9438797fe0610ec | 2a44f87558ef588e161c1438bba85edd727beda6 | refs/heads/master | 2021-02-12T12:47:07.834886 | 2020-03-03T14:53:27 | 2020-03-03T14:53:27 | 244,593,628 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,971 | py | import numpy as np
def game_core_v1(number):
'''Просто угадываем на random,
никак не используя информацию о больше или меньше.
Функция принимает загаданное число и возвращает число попыток'''
count = 0
while True:
count += 1
predict = np.random.randint(1, 101) # предполагаемое число
if number == predict:
return(count) # выход из цикла, если угадали
def score_game(game_core_v1):
'''Запускаем игру 1000 раз, чтобы узнать, как быстро игра угадывает число'''
count_ls = []
np.random.seed(1) # фиксируем RANDOM SEED, чтобы ваш эксперимент был воспроизводим!
random_array = np.random.randint(1, 101, size=(1000))
for number in random_array:
count_ls.append(game_core_v1(number))
score = int(np.mean(count_ls))
print(f"Ваш алгоритм угадывает число в среднем за {score} попыток")
return(score)
score_game(game_core_v1) # запускаем
def game_core_v2(number):
'''Сначала устанавливаем любое random число,
а потом уменьшаем или увеличиваем его в зависимости от того,
больше оно или меньше нужного.
Функция принимает загаданное число и возвращает число попыток'''
count = 0
predict = np.random.randint(1, 100)
while number != predict:
count += 1
if number > predict:
predict += 1
elif number < predict:
predict -= 1
return(count) # выход из цикла, если угадали
score_game(game_core_v2) # Проверяем
def game_core_v3(number: int):
'''Сначала устанавливаем значения левой и правой границ
возможного диапазона загадываемых чисел.
Выбираем начальное значение в середине диапазона.
Далее в зависимости больше или меньше наше число, чем загаданное,
сдвигаем границы диапазона поиска.
Функция принимает загаданное число и возвращает число попыток'''
count = 0
left = 1
right = 100
predict = (right+left)//2
while number != predict:
count += 1
if number > predict:
left = predict + 1
else:
right = predict - 1
predict = (left+right) // 2
return count
score_game(game_core_v3) # Проверяем
| [
"r.v.lunev@gmail.com"
] | r.v.lunev@gmail.com |
fb8a08b8bbdf6bf3afa474fe3af2792d7633067d | 1137003e5c109777d41fd9ab170dd9ac911c45fb | /fov_functions.py | 5b8c232a348cdf37e52c990858bc016175e66560 | [] | no_license | ScythepX/roguelike_tcod | 8f35e4b16c078b7aa671cabf97d221db56cd5699 | 8eabf70b3108394f167a6d74cef048fdf2ceb539 | refs/heads/master | 2020-05-25T11:10:00.019203 | 2019-05-23T11:03:50 | 2019-05-23T11:03:50 | 187,774,331 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 540 | py | import tcod as libtcod
def initialize_fov(game_map):
fov_map = libtcod.map_new(game_map.width, game_map.height)
for y in range(game_map.height):
for x in range(game_map.width):
libtcod.map_set_properties(fov_map, x, y, not game_map.tiles[x][y].block_sight,
not game_map.tiles[x][y].blocked)
return fov_map
def recompute_fov(fov_map, x, y, radius, ligth_walls=True, algorithm=0):
libtcod.map_compute_fov(fov_map, int(x), int(y), radius, ligth_walls, algorithm) | [
"misha.magero@gmail.com"
] | misha.magero@gmail.com |
2a6407239aee2496019cd227020032e970bfe846 | 554050b560f8f8cc4bcb322a8b22820533894f3a | /tests/resource/create_resource_mixin.py | 040ea49f3d4d45a7a3e384af2e455901f885a917 | [
"BSD-3-Clause"
] | permissive | lvieirajr/mongorest | 4b33ff691b09c44f1112aa4fffd5455929d8a305 | 00f4487ded33254434bc51ff09d48c7a936bd465 | refs/heads/master | 2020-05-21T22:16:22.743550 | 2016-12-09T06:50:32 | 2016-12-09T06:50:32 | 34,149,734 | 16 | 2 | BSD-3-Clause | 2019-10-23T00:38:01 | 2015-04-18T02:43:38 | Python | UTF-8 | Python | false | false | 2,853 | py | # -*- encoding: UTF-8 -*-
from __future__ import absolute_import, unicode_literals
from mongorest.collection import Collection
from mongorest.resource import CreateResourceMixin
from mongorest.testcase import TestCase
from mongorest.utils import serialize
from mongorest.wrappers import Response
from mongorest.wsgi import WSGIDispatcher
class TestCreateResourceMixin(TestCase):
def setUp(self):
class Test(Collection):
schema = {'test': {'required': True, 'type': 'integer'}}
class TestCollectionCreate(CreateResourceMixin):
collection = Test
self.create_client = self.client(
WSGIDispatcher(resources=[TestCollectionCreate]),
Response
)
def test_create_mixin_rule(self):
rules = CreateResourceMixin.rules
self.assertEqual(len(rules), 1)
self.assertEqual(rules[0].rule, '/')
self.assertEqual(rules[0].methods, set(['POST']))
self.assertEqual(rules[0].endpoint, 'create')
def test_create_mixin_url_map(self):
urls = list(CreateResourceMixin.url_map.iter_rules())
self.assertEqual(len(urls), 1)
self.assertEqual(urls[0].rule, '/')
self.assertEqual(urls[0].methods, set(['POST']))
self.assertEqual(urls[0].endpoint, 'create')
def test_create_mixin_returns_errors_if_invalid_data(self):
response = self.create_client.post('/', data=serialize({}))
self.assertEqual(response.status_code, 400)
errors = response.json
errors['document'].pop('created_at')
errors['document'].pop('updated_at')
self.assertEqual(
errors,
{
'error_code': 21,
'error_type': 'DocumentValidationError',
'error_message': 'Validation of document from collection \'Test\' failed.',
'errors': [
{
'error_code': 23,
'error_type': 'RequiredFieldError',
'error_message': 'Field \'test\' on collection \'Test\' is required.',
'collection': 'Test',
'field': 'test',
},
],
'collection': 'Test',
'schema': {'test': {'required': True, 'type': 'integer'}},
'document': {},
}
)
def test_create_mixin_returns_201_and_created_documents_id(self):
response = self.create_client.post(
'/', data=serialize({'test': 1, '_id': 1})
)
data = response.json
data.pop('created_at')
data.pop('updated_at')
self.assertEqual(response.status_code, 201)
self.assertEqual(data, {'test': 1, '_id': 1})
self.assertEqual(self.db.test.find_one({'_id': 1})['test'], 1)
| [
"lvieira@lvieira.com"
] | lvieira@lvieira.com |
c9a24b3c10c28953acf6df09ef18154d5a0d41ed | c1916fe3b38679cdcbc547a9ae7a90ec4c50bc09 | /todo_app/urls.py | 77ec9fb573df36b6e98298bb7e8e7b06a87244b7 | [] | no_license | Temirbay/Todo-Contact-List-App | e6f7dd14b4bf32ac65809f06765e418ee29445ee | ad3b2ac69c8688913ff7cbe1030e362dd3e7366d | refs/heads/master | 2020-03-07T18:54:43.053156 | 2018-04-04T13:54:45 | 2018-04-04T13:54:45 | 127,656,401 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,080 | py | from django.urls import path
from . import views
urlpatterns = [
path('', views.index, name="index"),
path('todos/', views.todo_list, name="todo_list"),
path('todos/<int:todo_id>', views.todo_detail, name="todo_detail"),
path('todos/add', views.todo_add, name="todo_add"),
path('todos/complete/<int:todo_id>', views.todo_complete, name="todo_complete"),
path('todos/delete/<int:todo_id>', views.todo_delete, name="todo_delete"),
path('todos/update/<int:todo_id>', views.todo_update, name="todo_update"),
path('todos/sort/<int:sort_id>', views.todo_sort, name="todo_sort"),
path('contacts', views.contact_list, name="contact_list"),
path('contacts/<int:contact_id>', views.contact_detail, name="contact_detail"),
path('contacts/add', views.contact_add, name="contact_add"),
path('contacts/delete/<int:contact_id>', views.contact_delete, name="contact_delete"),
path('contacts/sort/<int:sort_id>', views.contact_sort, name="contact_sort"),
path('contact/<int:contact_id>', views.contact_update, name="contact_update"),
]
| [
"temirbaymiras.ktl@gmail.com"
] | temirbaymiras.ktl@gmail.com |
186c553da83db53ac91681c5d1650c41cc85b315 | c4702d1a06640555829b367852138cc93ba4a161 | /dym_work_order/report/dym_work_order_wip_report.py | 5f8b0c3e31094e8bc280dd6611091fac61612f93 | [] | no_license | Rizalimami/dym | 0ecadf9c049b22ebfebf92e4eab6eaad17dd3e26 | af1bcf7b77a3212bc8a8a0e41e6042a134587ed4 | refs/heads/master | 2020-04-08T10:56:43.605698 | 2018-11-27T06:44:08 | 2018-11-27T06:44:08 | 159,287,876 | 0 | 2 | null | null | null | null | UTF-8 | Python | false | false | 2,475 | py | # -*- coding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
import time
from openerp.osv import osv
from openerp.report import report_sxw
class dym_work_order_wip(report_sxw.rml_parse):
def __init__(self, cr, uid, name, context):
super(dym_work_order_wip, self).__init__(cr, uid, name, context=context)
self.localcontext.update({
'time': time,
'get_pricelist': self._get_pricelist,
'lines_a': self._lines_a,
'no_urut': self.no_urut,
})
self.no = 0
def no_urut(self):
self.no+=1
return self.no
def _get_pricelist(self, pricelist_id):
pricelist = self.pool.get('product.pricelist').read(self.cr, self.uid, [pricelist_id], ['name'], context=self.localcontext)[0]
return pricelist['name']
def _lines_a(self, accounts):
self.cr.execute("SELECT wo.name as name, wo.date as date, wo.no_pol as no_pol, wo.type as type, wo.state as state, wo.state_wo as state_wo, emp.name_related as mekanik_name from dym_work_order wo left join hr_employee emp on wo.mekanik_id = emp.id where state !='draft' and state !='done'")
res = self.cr.dictfetchall()
return res
class report_dym_work_order_wip(osv.AbstractModel):
_name = 'report.dym_work_order.dym_work_order_wip_report'
_inherit = 'report.abstract_report'
_template = 'dym_work_order.dym_work_order_wip_report'
_wrapped_report_class = dym_work_order_wip
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
| [
"rizal@portcities.net"
] | rizal@portcities.net |
1391bb52bb270468289ad821ec31fe06344f3cc9 | c9b944b4067ac85503d34672cec5b7fb249b54bf | /core/user/client/connection.py | 2e9ad94465e975f7dd8e0156b856e77e4d402701 | [
"MIT"
] | permissive | kumardot93/Socket-Programmin-with-Asynchronous-Security | 941d45f5080cfb80b1e16f806319c9b8cb3c0377 | ad6096a27c50858a4655702800bf50a9617a9f48 | refs/heads/master | 2023-03-05T12:29:08.361870 | 2021-02-13T10:46:45 | 2021-02-13T10:46:45 | 338,530,460 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 413 | py | import socket
import sys
from core.utils.custom_logger import Log
def create_connection(addr):
host, port = addr
# Attempt connection to server
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))
return sock
except (ValueError, OSError):
Log.critical("Could not make a connection to the server\nQuitting")
sys.exit(0)
| [
"kumar.93@iitj.ac.in"
] | kumar.93@iitj.ac.in |
bb9ab96cc802555e1662ac1e7fd7fd937592aa76 | b3ab40f730ff69bdfbab407a6470ec79dbcea54f | /script/prepft.py | 995053c9ba5617929a75d27f0cfb0fd4511150ff | [] | no_license | KLMTestBench/libScintMod | 01479c36e915f27de0d9846bbbcbb8fab8d3d364 | df4a4bbcf960a388f5b8de5181f4fab86d720cb5 | refs/heads/master | 2020-03-26T09:53:24.720121 | 2018-11-10T04:02:43 | 2018-11-10T04:02:43 | 144,770,460 | 0 | 0 | null | 2018-08-14T20:46:13 | 2018-08-14T20:46:13 | null | UTF-8 | Python | false | false | 538 | py | class prepft_conf:
devices = ""
lookBackWindow = 0x0
TL_NumberOfTrigger = 0
TL_timeInMicroSeconds = 0
use_EKLM = False
def prepft(ftsw,config=prepft_conf()):
ret = ""
ret += ftsw.reset()
ret += ftsw.set_trigger_limiter(config.TL_NumberOfTrigger,config.TL_timeInMicroSeconds)
ret += ftsw.set_lookBackWindow(config.lookBackWindow)
ret += ftsw.utime()
ret += ftsw.reset_ttaddr(config.use_EKLM)
ret += ftsw.prepare_devices(config.devices,config.use_EKLM)
ret += ftsw.reset()
return ret | [
"peschke@hawaii.edu"
] | peschke@hawaii.edu |
753ad43022f7a3191bb72fa131af59d5a1d65fe8 | b92fb53a2bebb8fd534258666b5ac9b9703af44b | /backend/home/migrations/0002_load_initial_data.py | 64a22060ef08f587e02ba57b0fdf868eb35edced | [] | no_license | crowdbotics-apps/my-books-17969 | 7d017780d7c51210820d153dcab35e1196cb9652 | 3f4f66c998bce11289b1fd2bdd74d2cf769cc2f0 | refs/heads/master | 2022-10-07T11:09:54.346439 | 2020-06-09T18:14:21 | 2020-06-09T18:14:21 | 271,076,921 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,286 | py | from django.db import migrations
def create_customtext(apps, schema_editor):
CustomText = apps.get_model("home", "CustomText")
customtext_title = "My Books"
CustomText.objects.create(title=customtext_title)
def create_homepage(apps, schema_editor):
HomePage = apps.get_model("home", "HomePage")
homepage_body = """
<h1 class="display-4 text-center">My Books</h1>
<p class="lead">
This is the sample application created and deployed from the Crowdbotics app.
You can view list of packages selected for this application below.
</p>"""
HomePage.objects.create(body=homepage_body)
def create_site(apps, schema_editor):
Site = apps.get_model("sites", "Site")
custom_domain = "my-books-17969.botics.co"
site_params = {
"name": "My Books",
}
if custom_domain:
site_params["domain"] = custom_domain
Site.objects.update_or_create(defaults=site_params, id=1)
class Migration(migrations.Migration):
dependencies = [
("home", "0001_initial"),
("sites", "0002_alter_domain_unique"),
]
operations = [
migrations.RunPython(create_customtext),
migrations.RunPython(create_homepage),
migrations.RunPython(create_site),
]
| [
"team@crowdbotics.com"
] | team@crowdbotics.com |
cadb25b28b47ee60afcfcf645997fe117dc41969 | 3a458d9efb62c055542beb6685c7250910bc4fdc | /awx/main/migrations/0142_update_ee_image_field_description.py | 20830abc2b3c1399f548cf271992c74dcf7e7f90 | [
"Apache-2.0"
] | permissive | aperigault/awx | 2e1b8c56592fdc20812b0c3841fb836d1a7a61a8 | 2ef840ce128a8028fe63b01b47bc5be5304062b2 | refs/heads/devel | 2021-11-21T03:28:31.346758 | 2021-10-12T18:19:40 | 2021-11-16T15:27:27 | 125,395,064 | 0 | 0 | Apache-2.0 | 2018-07-13T13:37:14 | 2018-03-15T16:22:23 | Python | UTF-8 | Python | false | false | 601 | py | # Generated by Django 2.2.16 on 2021-05-12 20:08
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('main', '0141_remove_isolated_instances'),
]
operations = [
migrations.AlterField(
model_name='executionenvironment',
name='image',
field=models.CharField(
help_text='The full image location, including the container registry, image name, and version tag.',
max_length=1024,
verbose_name='image location',
),
),
]
| [
"yo@jakemcdermott.me"
] | yo@jakemcdermott.me |
d0d7c67f5d6ef9431b5f03584b15b17ea988c483 | a5f6645429f07b47dc30596018a0ec9e1a2adcfc | /controllers/scripts.py | 1575c43b48d9078536f9e0b07d040c356e252c6c | [
"MIT"
] | permissive | dotskapes/dotSkapes | 78702f3198906226949732b3dd4ea1a343bc8e79 | 50228926f42a9c3bbc050b08922342a83a974755 | refs/heads/master | 2016-09-06T08:54:44.384933 | 2012-06-29T03:18:03 | 2012-06-29T03:18:03 | 2,167,460 | 2 | 7 | null | null | null | null | UTF-8 | Python | false | false | 286 | py | def data():
return {'data': get_datatypes ()}
def tree():
return {'data': get_datatypes ()}
def grid():
return {'data': get_datatypes ()}
def base():
return {
'dev_role': check_role (dev_role),
'admin_role': check_role (admin_role),
}
| [
""
] | |
064d618f96c40de76588156e4fdd8de7be2d3d93 | 39ee0c09d2850edd0c637dd496c81399a59778e1 | /apps/operation/urls.py | f180ed92e167023e72bcf219e088fb3a880485e6 | [] | no_license | txowner/XMooc | 6af062c6e8030b74527186d268b3c2f624604120 | 58bcab94b5b4837fbcaf53b2753cec507c1f4f11 | refs/heads/master | 2021-05-14T06:12:17.264024 | 2019-01-24T04:15:10 | 2019-01-24T04:15:10 | 114,453,898 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 201 | py |
from django.conf.urls import url
from .views import UserAskView, FavView
urlpatterns = [
url(r'^ask/$', UserAskView.as_view(), name='ask'),
url(r'^fav/$', FavView.as_view(), name='fav'),
]
| [
"46785647@qq.com"
] | 46785647@qq.com |
44be92edbd4686e354ce691569964fad2a11f50e | b54ba6923597138d744c890c21f09ceb768ea0ac | /Python 8 to 9AM/BasicExamples/Demo11.py | eb5a3414b5d2f196b98720855020d0c7a65b179c | [] | no_license | ashokreddy7013/python | ad3893e598a827bf520a97ed63e7441ce5ebea62 | e9032166ad32001e5fc89903b62d419d6d68b6d0 | refs/heads/master | 2020-05-01T08:54:19.106039 | 2019-03-24T08:19:18 | 2019-03-24T08:19:18 | 171,410,344 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 89 | py |
class Employee:
def __init__(self):
print("I am Default Const")
Employee()
| [
"45504918+ashokreddy7013@users.noreply.github.com"
] | 45504918+ashokreddy7013@users.noreply.github.com |
985c728468f6fbe9ab6b45e9ca899adcd75daede | d0e1b4dec910078d085dbc32787ec10900730c21 | /run_calc.py | 881d28f8a31245f4be6e56c84d23548e6fdeb0c5 | [] | no_license | jcaber4/calculator-macos | 28d2c3e5b5bb3e559da9f6d2c40d3a0f20feb418 | 64bd95555cb5c650fca74ce8fc66afae01316292 | refs/heads/main | 2023-02-11T01:25:58.350531 | 2021-01-07T19:18:28 | 2021-01-07T19:18:28 | 325,688,980 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 559 | py | from tkinter import *
from screen import Screen
from buttons import *
from calc import Calc
if __name__ == "__main__":
window = Tk()
window.configure(background="lightblue")
#window.resizable(0, 0)
window.title("Calculator")
window.geometry("255x142")
screenvar = StringVar()
screen_field = Screen(window, textvariable=screenvar)
screen_field.grid(row=0)
calculator = Calc(screen_field, master=window)
calculator.grid(row=1)
calculator.bind('<Return>', command=screen_field.evaluate)
calculator.mainloop()
| [
"jabercrombie4th@gmail.com"
] | jabercrombie4th@gmail.com |
d81a2e762af10997573acc02d62026a65ff1799c | 8fcbbe17b25c5400218fbe8eff6638026420dc73 | /admins/views.py | a4c081b88b4a21e0a873f3d9e6ab6ec6d6fa0ebe | [] | no_license | fred18811/geekshop-server | 6b8dff37833f760a454ef82910716537839bc0b0 | 93f52036f4880685207d2603d33fcbc2726124bd | refs/heads/main | 2023-07-28T06:29:11.883175 | 2021-08-30T08:16:17 | 2021-08-30T08:16:17 | 380,208,882 | 0 | 0 | null | 2021-08-31T07:15:32 | 2021-06-25T10:53:36 | CSS | UTF-8 | Python | false | false | 6,273 | py | from django.shortcuts import render, HttpResponseRedirect
from django.urls import reverse_lazy
from django.contrib.auth.decorators import user_passes_test
from django.views.generic.list import ListView
from django.views.generic.edit import CreateView, UpdateView, DeleteView
from django.utils.decorators import method_decorator
from users.models import User
from products.models import Product
from orders.models import Order
from admins.forms import UserAdminRegistrationForm, UserAdminProfileForm, ProdactForm, OrderForm
@user_passes_test(lambda u: u.is_staff)
def index(request):
context = {
'title': 'GeekShop - Admin',
}
return render(request, 'admins/index.html', context)
class UserListView(ListView):
model = User
template_name = 'admins/admin-users-read.html'
def get_context_data(self, **kwargs):
context = super(UserListView, self).get_context_data()
context['title'] = 'GeekShop - Пользователи'
return context
@method_decorator(user_passes_test(lambda u: u.is_staff))
def dispatch(self, request, *args, **kwargs):
return super(UserListView, self).dispatch(request, *args, **kwargs)
class UserCreateView(CreateView):
model = User
template_name = 'admins/admin-users-create.html'
form_class = UserAdminRegistrationForm
success_url = reverse_lazy('admins:admin_users')
def get_context_data(self, **kwargs):
context = super(UserCreateView, self).get_context_data()
context['title'] = 'GeekShop - Создание пользователя'
return context
@method_decorator(user_passes_test(lambda u: u.is_staff))
def dispatch(self, request, *args, **kwargs):
return super(UserCreateView, self).dispatch(request, *args, **kwargs)
class UserUpdateView(UpdateView):
model = User
template_name = 'admins/admin-users-update-delete.html'
form_class = UserAdminProfileForm
success_url = reverse_lazy('admins:admin_users')
def get_context_data(self, **kwargs):
context = super(UserUpdateView, self).get_context_data()
context['title'] = 'GeekShop - Обновление\удаление пользователя'
return context
@method_decorator(user_passes_test(lambda u: u.is_staff))
def dispatch(self, request, *args, **kwargs):
return super(UserUpdateView, self).dispatch(request, *args, **kwargs)
class UserDeleteView(DeleteView):
model = User
template_name = 'admins/admin-users-update-delete.html'
success_url = reverse_lazy('admins:admin_users')
def delete(self, request, *args, **kwargs):
self.object = self.get_object()
self.object.is_active = False
self.object.save()
return HttpResponseRedirect(self.get_success_url())
@method_decorator(user_passes_test(lambda u: u.is_staff))
def dispatch(self, request, *args, **kwargs):
return super(UserDeleteView, self).dispatch(request, *args, **kwargs)
class ProdactListView(ListView):
model = Product
template_name = 'admins/admin-prodacts-read.html'
def get_context_data(self, *, object_list=None, **kwargs):
context = super(ProdactListView, self).get_context_data()
context['title'] = 'GeekShop - Продукты'
return context
@method_decorator(user_passes_test(lambda u: u.is_staff))
def dispatch(self, request, *args, **kwargs):
return super(ProdactListView, self).dispatch(request, *args, **kwargs)
class ProdactCreateView(CreateView):
model = Product
template_name = 'admins/admin-prodacts-create.html'
form_class = ProdactForm
success_url = reverse_lazy('admins:admin_prodacts')
def get_context_data(self, *, object_list=None, **kwargs):
context = super(ProdactCreateView, self).get_context_data()
context['title'] = 'GeekShop - Создание пользователя'
return context
@method_decorator(user_passes_test(lambda u: u.is_staff))
def dispatch(self, request, *args, **kwargs):
return super(ProdactCreateView, self).dispatch(request, *args, **kwargs)
class ProdactUpdateView(UpdateView):
model = Product
template_name = 'admins/admin-prodacts-update-delete.html'
form_class = ProdactForm
success_url = reverse_lazy('admins:admin_prodacts')
def get_context_data(self, *, object_list=None, **kwargs):
context = super(ProdactUpdateView, self).get_context_data()
context['title'] = 'GeekShop - Обновление\удаление товара'
return context
@method_decorator(user_passes_test(lambda u: u.is_staff))
def dispatch(self, request, *args, **kwargs):
return super(ProdactUpdateView, self).dispatch(request, *args, **kwargs)
class ProdactDeleteView(DeleteView):
model = Product
template_name = 'admins/admin-prodacts-update-delete.html'
success_url = reverse_lazy('admins:admin_prodacts')
@method_decorator(user_passes_test(lambda u: u.is_staff))
def dispatch(self, request, *args, **kwargs):
return super(ProdactDeleteView, self).dispatch(request, *args, **kwargs)
class OrderListView(ListView):
model = Order
template_name = 'admins/admin-orders-read.html'
def get_context_data(self, *, object_list=None, **kwargs):
context = super(OrderListView, self).get_context_data()
context['title'] = 'GeekShop - Заказы'
return context
@method_decorator(user_passes_test(lambda u: u.is_staff))
def dispatch(self, request, *args, **kwargs):
return super(OrderListView, self).dispatch(request, *args, **kwargs)
class OrderUpdateView(UpdateView):
model = Order
template_name = 'admins/admin-orders-update.html'
form_class = OrderForm
success_url = reverse_lazy('admins:admin_orders')
def get_context_data(self, *, object_list=None, **kwargs):
context = super(OrderUpdateView, self).get_context_data()
context['title'] = 'GeekShop - Обновление статуса заказа'
return context
@method_decorator(user_passes_test(lambda u: u.is_staff))
def dispatch(self, request, *args, **kwargs):
return super(OrderUpdateView, self).dispatch(request, *args, **kwargs)
| [
"fred17@mail.ru"
] | fred17@mail.ru |
e97a307494c2907da54a761cfd8c43031d7c256a | f835a26a9bc4ba63996a6a3faa82aa958e983d3c | /deep-rl/bin/viewer.py | 115c35c717ff73c80372449afd97f82d145ab7df | [
"MIT"
] | permissive | ShujaKhalid/deep-rl | ed6d21db2ffdf70a25c77a5a12fe964771bc3ce0 | 99c6ba6c3095d1bfdab81bd01395ced96bddd611 | refs/heads/master | 2021-07-25T00:04:53.856027 | 2017-11-05T23:21:18 | 2017-11-05T23:21:18 | 109,617,245 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,051 | py | #!/home/shuja/Desktop/deep-rl/deep-rl/bin/python2
#
# The Python Imaging Library
# $Id$
#
from __future__ import print_function
import sys
if sys.version_info[0] > 2:
import tkinter
else:
import Tkinter as tkinter
from PIL import Image, ImageTk
#
# an image viewer
class UI(tkinter.Label):
def __init__(self, master, im):
if im.mode == "1":
# bitmap image
self.image = ImageTk.BitmapImage(im, foreground="white")
tkinter.Label.__init__(self, master, image=self.image, bd=0,
bg="black")
else:
# photo image
self.image = ImageTk.PhotoImage(im)
tkinter.Label.__init__(self, master, image=self.image, bd=0)
#
# script interface
if __name__ == "__main__":
if not sys.argv[1:]:
print("Syntax: python viewer.py imagefile")
sys.exit(1)
filename = sys.argv[1]
root = tkinter.Tk()
root.title(filename)
im = Image.open(filename)
UI(root, im).pack()
root.mainloop()
| [
"shuja.khalid@mail.utoronto.ca"
] | shuja.khalid@mail.utoronto.ca |
c69db3c497c0fe95c68bdce48964a390d6701412 | 9a346083a840659319f304e4bdf209d5db81254b | /is_valid_play.py | cde7d251c4809e4f792a49689b311ccdb0c98c2d | [] | no_license | kcuzner/sevens | e0c37261a1998a2b312b9f47250dd1f556141a07 | fbae46afc0f909032e0c92c5bb65a6f31c6a2664 | refs/heads/master | 2021-01-20T12:54:54.293810 | 2017-05-25T03:57:59 | 2017-05-25T03:57:59 | 90,427,029 | 1 | 0 | null | 2017-05-06T00:37:02 | 2017-05-06T00:37:02 | null | UTF-8 | Python | false | false | 794 | py | from is_logic_valid_play import is_logic_valid_play
# This function checks if the card_played is able to be played based on if the previous necessary cards have been played. It also checks if the player contained the card_played in his hand.
def is_valid_play(card_played, gs):
if card_played is None:
return True
else:
#player must have that card in hand, and it must be playable
#check if player had that card in hand
in_hand = False
for card in gs['player_hands'][gs['player_turn']-1]:
if card_played == card:
in_hand = True
break
if in_hand == False:
return False
#code below only runs if card is in player's hand
return is_logic_valid_play(card_played, gs)
| [
"Adam.Lewis@utexas.edu"
] | Adam.Lewis@utexas.edu |
ba21906203694c8b683dadcff57df26802787018 | 9524b00494484dc0a04ef55bef67cc6181202210 | /models/pasantias.py | baed6568af1dca8690f3025d9e94182c965b7b0e | [] | no_license | crisyelit/pasantias | 4dd3f70ab82d3369d92f2cea5611079f43cb9381 | cd4d183221159d99f5dc00bc7bc39262ab5c98e3 | refs/heads/master | 2023-01-20T13:06:10.726375 | 2020-11-24T22:09:02 | 2020-11-24T22:09:02 | 273,825,149 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 14,152 | py | # -*- coding: utf-8 -*-
##############################################################################
#
# ODOO, Solución ERP de código abierto
#
# Este programa es software libre: se puede redistribuir y / o modificar
# bajo los términos de la GNU Affero General Public License
#
# Debería haber recibido una copia de la Licencia Pública General GNU Affero
# Junto con este programa. Si no es así, consulte <http://www.gnu.org/licenses/>.
#
##############################################################################
from odoo import api, fields, models, api, exceptions;
from datetime import timedelta;
class pasantias(models.Model):
"""Tabla de Registro Maestro de Pasantias"""
_name = 'pasantias'
_description = "Pasantias"
_order = 'convenios_id'
#_rec_name = ''
pasante_id = fields.Many2one('res.partner', string='Pasante', required=True, readonly=False, help='Pasante que realiza esta pasantia')
convenios_id = fields.Many2one('convenios',string= 'Convenio', required=True, readonly=False, help='Convenio dentro del cual se incorporo esta pasantia')
promotor_id = fields.Many2one('promotores', string='Promotor', required=True, readonly=False, help='Promotor asignado')
departamento_area = fields.Char(string='Departamento asignado o area', default='Departamento asignado', size=64,required='True', traslate=True, readonly=False, copy=True, help='Departameto asignado o area donde realiza pasantia')
tipo_pasantias_id = fields.Many2one('tipos.pasantias', string='Tipo de pasantia', required=True, readonly=False, help='Tipo de pasantia realizada')
condicion_nofirmantes_id = fields.Many2one('condicion.nofirmante',string='Condicion no firmante', requered=True, readonly=False, help='Empresas o Institucines que no firman convenio')
pasantia_desde = fields.Date(string='Pasantia desde', required=True, readonly=False, copy=False, help='Fecha de inicio de pasantia')
pasantia_hasta = fields.Date(string='Pasantia hasta', required=True, readonly=False, copy=False, help='Fecha culminacion de pasantia')
numero_semana = fields.Integer(string='Numero de semana',default=0, size=2,required='True', readonly=False, copy=False, help='Numero de semanas de duracion de la pasantia')
turnos_id = fields.Many2one('turnos', string='Turno', required=True, readonly=False, copy=False, help='Turno de la pasantia')
fecha_recepcion = fields.Date(string='Fecha de Recepcion documentos', required=True, readonly=False, copy=False, help='Fecha de recepcion de pasantia')
prorroga_desde = fields.Date(string='Prorroga desde', required=False, readonly=False, copy=False, help='Fecha de inicio Prorroga de Pasantia')
prorroga_hasta = fields.Date(string='Prorroga hasta', required=False, readonly=False, copy=False, help='Fecha de culminacion Prorroga')
semana_prorroga = fields.Integer(string='Semana Prorroga', default=0, required=False, readonly=False, copy=False, help='Numero de semanas de prorroga')
turno_prorroga_id = fields.Many2one('turnos', string='Turno de la prorroga', required=False, readonly=False, copy=False, help='Turno de la prorroga')
condiciones_registro_id = fields.Many2one('condiciones.registro', string='Condicion de registro', required=True, readonly=False, copy=False, help='Condicion del registro de pasante')
observacion = fields.Text('Observaciones', help='Observaciones de pasantia')
observaciones_prorroga = fields.Text('Observacion de prorroga', help='Observaciones de la prorroga')
nivel_academico_id = fields.Many2one('nivel_academico', string='Nivel Academico de la Pasantia', required=True, readonly=False, copy=False, help='Indica el nivel academico en la cual realizara su pasantia')
nombre_instituto_id = fields.Many2one('instituciones', string='Instituto Procedente', required=True, readonly=False, copy=False, help='Instituto que procede el estudiante a realiza la pasantia')
beneficiario_ids = fields.One2many('beneficiarios', 'beneficiario_id', string='Beneficiario', required=False, readonly=False, copy=False, help='Beneficiario de los aporte del seguro del pasante en caso de accidentes')
active = fields.Boolean(string="Activo", help="activar o desactivar el registro", default=True)
tipo_especialidades_id = fields.Many2one('tipo.especialidades', string='tipo especialidades', required=True, readonly=False, copy=False, help='Tipo de especialidad a realizar')
class tipos_alergias(models.Model):
"""Tabla referencial de tipos de alergias"""
_name = 'tipos.alergias'
#_rec_name = ''
codigo = fields.Char(string='Codigo', default='Codigo', size=3, traslate=True, readonly=False, required=False, copy=True, help='Codigo de identificacion del tipo de alergia')
tipo_alergia = fields.Char(string='Tipo de Alergia', default='Tipo', size=20, traslate=True, readonly=False, required=False, copy=True, help='Indique el tipo de alergia')
class instituciones(models.Model):
"""Tabla Registro Maestro de Instituciones"""
_inherit = 'res.company'
#_rec_name = ''
rif = fields.Char(string='RIF de la Institucion',default='RIF', traslate=True, readonly=False, size=20, required=False, copy=True, help='RIF de la institucion')
acronimo = fields.Char(string='Acronimo de la Institucion', default='Acronimo', size=20, traslate=True, readonly=False, required=False, copy=True, help='Acronimo de la Institucion')
tipo_instituciones_id = fields.Many2one('tipos.instituciones', string='Tipo de Institucion', required=True, readonly=False, help='Tipo de Institucion')
user_ids = fields.Many2many('res.users', 'instituciones_users_rel', 'cid', 'user_id', string='Accepted Users')
class tipos_pasantias(models.Model):
"""Tabla referencial de tipos de pasantias"""
_name = 'tipos.pasantias'
#_rec_name = ''
codigo = fields.Char(string='Codigo', default='Codigo', size=3, traslate=True, readonly=False, required=False, copy=True, help='Codigo de identificacion de tipo de pasantia')
tipo_pasantia = fields.Char(string='Tipo de pasantia', default='Tipo', size=3, traslate=True, readonly=False, required=False, copy=True, help='Nombre el tipo de pasantia')
class pasantes(models.Model):
"""Tabla de Registro Maestro de Pasantes"""
# _name = 'pasantes'
_inherit = 'res.partner'
#_rec_name = ''
cedula = fields.Integer(string='Numero de cedula', default=0, size=20, traslate=True, readonly=False, required=False, copy=True, help='Codigo de identificacion del pasante')
zurdo = fields.Selection([('si', 'SI'),('no', 'NO')],string='Es Zurdo?', default='no', store=True, readonly=False, copy=False, help='Es Zurdo?')
alergias = fields.Selection([('si','SI'),('no','NO')], string='Es alergico?', default='no', store=True, readonly=False, copy=False, help='Es alergico?')
tipo_alergia = fields.Many2one('tipos.alergias','Indique alergia', help='Tipos de alergias que posee')
especialidad = fields.Many2one('tipo.especialidades', string='Tipo de Especialidad', required=True, readonly=False, help='Tipos de especialidades que posee')
nivel_educativo = fields.Selection([('tm','TM'),('tsu','TSU'),('univ','UNIV')],string= 'Nivel de Educacion', default='tm', store=True, readonly=False, copy=False, help='Indique el nivel academico que posee')
# channel_ids = fields.Many2many('mail.channel', string='Canales')
# visitor_ids = ''
# meeting_ids = ''
#razon_social_ids = fields.One2many('res.company','Empresa', string='Razon social de la Institucion',default='Razon social', traslate=True, size=20, required='True', copy=True, help='Razon social de la Institucion')
empresa_ids = fields.One2many('convenios', 'empresa_id', string="Empresa", readonly=True, required=True, copy=False, help='Empresa donde se ejecuta la pasantia')
instructor = fields.Boolean("Instructor", default=False)
class tipo_especialidades(models.Model):
"""Tabla referencial de tipos de Especialidades"""
_name = 'tipo.especialidades'
#_rec_name = ''
codigo = fields.Char(string='Codigo', default='Codigo', size=3, traslate=True, readonly=False, required=False, copy=True, help='Codigo de identificacion del tipo de alergia')
tipo_especialidades = fields.Char(string='Tipo de Especialidad', default='Tipo', size=20, traslate=True, readonly=False, required=False, copy=True, help='Nombre de la especialidad que posee')
class convenios(models.Model):
"""Tabla de Registro Maestro de Convenios"""
_name = 'convenios'
#_rec_name = ''
codigo = fields.Char(string='Codigo de Convenio', default='Convenio', size=10, traslate=True, readonly=False, required=False, copy=True, help='Codigo de identificacion del Convenio')
empresa_id = fields.Many2one('res.partner', string='Empresa', required=True, readonly=False, help='Empresa con la que se celebra el convenio')
fecha_inicio = fields.Date(string='Fecha inicio', required=False, readonly=False, copy=False, help='Fecha de inicio de pasantia')
fecha_final = fields.Date(string='Fecha Final', required=False, readonly=False, copy=False, help='Fecha Final ')
promotor_id = fields.Many2one('promotores', string='Promotor', required=True, readonly=False, help='Promotor que atiende la empresa')
_sql_constraints = [('codigo_unid','UNIQUE(codigo)','El codigo debe ser unica!')]
class promotores(models.Model):
"""Tabla de Registro Maestro de Promotores"""
_name = 'promotores'
#_rec_name = ''
cedula = fields.Char(string='Cedula', default='Cedula', size=10, traslate=True, readonly=False, required=False, copy=True, help='Cedula del promotor')
nombre_promotor = fields.Char(string='Nombre del Promotor', default='Promotor', size=50, traslate=True, readonly=False, required=False, copy=True, help='Nombre del promotor')
apellido_promotor = fields.Char(string='Apellido del promotor', default='Apellido', size=50, traslate=True, readonly=False, required=False, copy=True, help='Apellido del promotor')
class condicion_nofirmante(models.Model):
"""Tabla referencial de con dicion de no Firmantes"""
_name = 'condicion.nofirmante'
#_rec_name = ''
codigo = fields.Char(string='Codigo', default='Codigo', size=3, traslate=True, readonly=False, required=False, copy=True, help='Codigo de identificacion del tipo de alergia')
condicion_nofirmante = fields.Char(string='Condicion de no firmante', default='Condicion de no firmante', size=3, traslate=True, readonly=False, required=False, copy=True, help='Condicion de no firmar de convenio')
class tipo_instituciones(models.Model):
"""Tabla referencial de tipos de Instituciones"""
_name = 'tipo.instituciones'
#_rec_name = ''
codigo = fields.Char(string='Codigo', default='Codigo', size=3, traslate=True, readonly=False, required=False, copy=True, help='Codigo de identificacion del tipo de alergia')
tipo_instituciones = fields.Char(string='Tipo de Instituciones', default='Tipo', size=20, traslate=True, readonly=False, required=False, copy=True, help='Nombre de los tipos de Instituciones existente')
class beneficiarios(models.Model):
"""Tabla de Registro Maestro de Beneficiarios"""
_name = 'beneficiarios'
#_rec_name = ''
beneficiario_id = fields.Many2one('pasantias', string='Beneficiarios', required=True, readonly=False, help='Beneficiario del pasante')
nombre_beneficiario = fields.Char(string='Nombre del Beneficiario', default='Nombre', size=50, traslate=True, readonly=False, required=False, copy=True, help='Nombre del Beneficiario')
apellido_beneficiario = fields.Char('Apellido del Beneficiario', default='Apellidos', size=50, traslate=True, readonly=False, required=False, copy=True, help='Apellido del Beneficiario')
parentesco_beneficiario_id = fields.Many2one('parentescos', string='Parentesco del Beneficiario', required=True, readonly=False, help='Parentesco del Beneficiario')
porcentaje = fields.Integer(string='Porcentaje', default=0, required=True, readonly=False, copy=False, help='Porcentaje del Beneficiario')
beneficiario_id = fields.Many2one('pasantias', string='Beneficiario', required=False, readonly=False, copy=False, help='Beneficiario de los aporte del seguro del pasante en caso de accidentes')
class parentescos(models.Model):
"""Tabla referencial de Parentesco"""
_name = 'parentescos'
#_rec_name = ''
codigo = fields.Char(string='Codigo', default='Codigo', size=3, traslate=True, readonly=False, required=False, copy=True, help='Codigo de identificacion del tipo de alergia')
parentesco = fields.Char(string='Parentesco', size=120, required='True', traslate=True, readonly=False, copy=True, help='Tipo de parentesco')
class nivel_academico(models.Model):
"""Tabla de refer3encial de Niveles Academicos"""
_name = 'nivel.academico'
#_rec_name = ''
codigo = fields.Char(string='Codigo', default='Codigo', size=3, required='True', traslate=True, readonly=False, copy=True, help='Codigo de identificacion del nivel academico')
nivel_academico = fields.Char(string='Nivel Educativo', size=120, required='True', traslate=True, readonly=False, copy=True, help='Descripcion corta del nivel educativo')
class condiciones_registro(models.Model):
"""Tabla referencial de Condiciones de Registro"""
_name = 'condiciones.registro'
#_rec_name = ''
codigo = fields.Char(string='Codigo', default='Codigo', size=3, required='True', traslate=True, readonly=False, copy=True, help='Codigo de identificacion de tipo de pasantia')
condicion_registro = fields.Char(string='Condicion de Registro', default='Condicion de Registro', size=50, required='True', traslate=True, readonly=False, copy=True, help='Condicion deRegistro del pasante')
class turnos(models.Model):
"""Tabla referencial de turnos"""
_name = 'turnos'
#_rec_name = ''
codigo = fields.Char(string='Codigo', default='Codigo', size=3, required='True', traslate=True, readonly=False, copy=True, help='Codigo de identificacion de turnos')
turno = fields.Char(string='Turno', default='Turno', size=120, required='True', traslate=True, readonly=False, copy=True, help='Turno en la que cursa') | [
"crisyelit@gmail.com"
] | crisyelit@gmail.com |
adf6baec3c9d0fd83c0e674363c6dcaf4ebeb69a | b6f113b6e78a8c1af5e3283545841dce8df58818 | /analyser/testing/connectiondb.py | 3c9795c12539f8348809c7009bd4c67fd74d9650 | [] | no_license | immanuel-joseph/ITS--Student-Model | 994019d0cf7bddb03663899d4f66b448a045408d | 28e2a2f88daf21ed06f6b9a8495f21ecde54bde4 | refs/heads/master | 2023-02-22T23:38:21.211050 | 2021-01-30T17:39:33 | 2021-01-30T17:39:33 | 292,445,211 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 351 | py |
import mysql.connector
# import testingmodel
#connecting database
mydb = mysql.connector.connect(
host="simba.cs.csusm.edu",
user="anton031",
password="anton031",
database="anton031"
)
mycursor = mydb.cursor()
#retrieving data
mycursor.execute("SELECT * FROM pictures_data")
myresult = mycursor.fetchall()
# def run_model():
| [
"aij.immanuel@gmail.com"
] | aij.immanuel@gmail.com |
2df879f455d01dcc3f57810c164749f1b78fde95 | 4d5c2c4d03760ccc7fe1c9053884e39c4ea7895e | /split-a-string-in-balanced-strings.py | 9da003708a4d45a1725a910208aaf34eb39a820b | [] | no_license | surajrimal/coding_challenges | 993fd824bdc65c8b2d0d605cd5f5e17945b616ab | ca9eb4743250e43f6093177dd2b4b8c6eaa9142d | refs/heads/main | 2023-07-14T18:45:39.826680 | 2021-08-21T03:23:50 | 2021-08-21T03:23:50 | 352,389,037 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 669 | py | #link https://leetcode.com/problems/split-a-string-in-balanced-strings/submissions/
class Solution(object):
def balancedStringSplit(self, s):
"""
:type s: str
:rtype: int
"""
print(s)
stack = []
stack.append(s[0])
prev = s[0]
count = 0
for i in range(1,len(s)):
if(s[i]== prev or len(stack)==0):
stack.append(s[i])
prev = s[i]
else:
stack.pop()
if(len(stack)== 0 ):
count = count +1
return count
| [
"noreply@github.com"
] | surajrimal.noreply@github.com |
dc757c59fdf8ee93aa9bf252e1823c13c8c21ba9 | 9bd82e484b3d32c4059ef57dec70e64bced8dde7 | /OTB/OTB/pipelines.py | 693eeb3a38760be718dbda4b5478b7a5cebc9419 | [
"MIT"
] | permissive | houzw/knowledge-base-data | 8a4df88558edcc5fcc25bac82788c6eb96119854 | 60771e8bf300227e1a26c9e77f56b09d23acd64a | refs/heads/master | 2021-06-02T02:28:09.624790 | 2020-10-21T07:02:26 | 2020-10-21T07:02:26 | 148,170,033 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 284 | py | # -*- coding: utf-8 -*-
# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html
class OtbPipeline(object):
def process_item(self, item, spider):
return item
| [
"yesqincheng@sina.com"
] | yesqincheng@sina.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.