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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
4731da9d96c4ef1421303672f8b8b4c0f711c63d | d59bad348c88026e444c084e6e68733bb0211bc2 | /problema_arg_padrao_mutavel.py | 616a4efc8c311158f135deac65c9f0a80b8121e6 | [] | no_license | dersonf/udemy-python | f96ec883decb21a68233b2e158c82db1c8878c7a | 92471c607d8324902902774284f7ca81d2f25888 | refs/heads/master | 2022-09-25T00:18:49.833210 | 2020-06-05T18:18:38 | 2020-06-05T18:18:38 | 262,049,238 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 352 | py | #!/usr/bin/python3.6
def fibonacci(sequencia=[0, 1]):
# Uso de mutáveis como valor default (armadilha)
sequencia.append(sequencia[-1] + sequencia[-2])
return sequencia
if __name__ == '__main__':
inicio = fibonacci()
print(inicio, id(inicio))
print(fibonacci(inicio))
restart = fibonacci()
print(restart, id(restart))
| [
"anderson@ferneda.com.br"
] | anderson@ferneda.com.br |
932c60b434fa614cfd705c8dff56b1d9747a712c | d8270002e8b5c2850d8bf16d70728d24eff6a897 | /speech/speechAudio.py | 824ac17e31db076489daacee6a792c170777b648 | [] | no_license | imratnesh/audioanalysis | 05ac1b535dd99e2ad91bed993e3339e33b5da06c | 7783f2c6eea19333ebf577eea6caae3117b7abfc | refs/heads/master | 2020-07-17T09:54:05.133336 | 2019-09-03T06:50:53 | 2019-09-03T06:50:53 | 205,997,923 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,463 | py | from ibm_watson import SpeechToTextV1
from os.path import join, dirname
import json
from ibm_watson.websocket import RecognizeCallback, AudioSource
speech_to_text = SpeechToTextV1(
iam_apikey='GFT9-N0g7zSU9FIM1YLNL7ZyzLdIJ1s_EkluUjYK8B1s',
url='https://gateway-lon.watsonplatform.net/speech-to-text/api'
)
#with open(join(dirname(__file__), './.', 'audio1.wav'),
# 'rb') as audio_file:
# speech_to_text.add_audio(
# '{customization_id}',
# 'audio1',
# audio_file,
# content_type='audio/wav'
# )
# Poll for audio status.
class MyRecognizeCallback(RecognizeCallback):
def __init__(self):
RecognizeCallback.__init__(self)
def on_data(self, data):
print(json.dumps(data['results'][0]['alternatives'][0]['transcript'], indent=2))
def on_error(self, error):
print('Error received: {}'.format(error))
def on_inactivity_timeout(self, error):
print('Inactivity timeout: {}'.format(error))
myRecognizeCallback = MyRecognizeCallback()
with open(join(dirname(__file__), 'audio-file.flac'), 'rb') as audio_file:
audio_source = AudioSource(audio_file)
speech_to_text.recognize_using_websocket(
audio=audio_source,
content_type='audio/flac',
recognize_callback=myRecognizeCallback,
model='en-US_BroadbandModel',
keywords=['colorado', 'tornado', 'tornadoes'],
keywords_threshold=0.5,
max_alternatives=3) | [
"ratnesh.kushwaha@icorprated.com"
] | ratnesh.kushwaha@icorprated.com |
d30d5c62676e592a5f71a0be2cfb4c773f8613f1 | b0d451376c1fa503db52bcc51f36d41d5d87edb9 | /information.py | 3067af8917863a10e1a1afe7c875348a56c7b090 | [] | no_license | roamerboss/first-personal-work | b404def42c5334c077c8a07758c3233ea2a46fd5 | fa578c9d4a9901c975576f6b00c298bfc2a01e05 | refs/heads/main | 2023-03-08T21:46:37.359540 | 2021-02-26T10:10:13 | 2021-02-26T10:10:13 | 341,454,707 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,540 | py | import requests
import re
import json
headers = {
"User-Agent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Safari/605.1.15"
}
list1 = []
list2 = []
list3 = []
list4 = []
list_all = []
i = 1614066736711
j = 0
url = "https://video.coral.qq.com/varticle/5963120294/comment/v2?callback=_varticle5963120294commentv2&orinum=10&oriorder=o&pageflag=1&cursor="+str(j)+"&scorecursor=0&orirepnum=2&reporder=o&reppageflag=1&source=132&_="+str(i)
html = requests.get(url,headers=headers).content.decode()
list1 = re.findall('"content":"(.*?)"',html,re.S)
#print(list1)
j = re.findall('"last":"(.*?)"',html,re.S)
i = i+3
url = "https://video.coral.qq.com/varticle/5963120294/comment/v2?callback=_varticle5963120294commentv2&orinum=10&oriorder=o&pageflag=1&cursor="+str(j[0])+"&scorecursor=0&orirepnum=2&reporder=o&reppageflag=1&source=132&_="+str(i)
html = requests.get(url,headers=headers).content.decode()
list2 = re.findall('"content":"(.*?)"',html,re.S)
#print(list2)
for k in range(1,1168,1):
i += 1
j = re.findall('"last":"(.*?)"',html,re.S)
url = "https://video.coral.qq.com/varticle/5963120294/comment/v2?callback=_varticle5963120294commentv2&orinum=10&oriorder=o&pageflag=1&cursor="+str(j[0])+"&scorecursor=0&orirepnum=2&reporder=o&reppageflag=1&source=132&_="+str(i)
html = requests.get(url,headers=headers).content.decode()
list3 = re.findall('"content":"(.*?)"',html,re.S)
list4 += list3
#print(list4)
list_all = list1 + list2 + list4
print(list_all)
| [
"1273915146@qq.com"
] | 1273915146@qq.com |
3c413b53ad95c4028caa2456ffe78e4b195e2572 | d17c8bf9f9b3a075ed239b7adef4b4130be073a5 | /ecom/api/order/migrations/0002_order_is_paid.py | aee3b0abaec8148f2cc353b9abcd02b505434b1e | [] | no_license | joilshubham/Nerdy-T-shirt-store | 3daf3f45b57160d7aec5686648eb8f70da08854c | a2162d58929284a806b507a506fbb6de8720365d | refs/heads/master | 2023-04-27T20:31:01.077384 | 2021-05-11T02:48:08 | 2021-05-11T02:48:08 | 354,576,992 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 374 | py | # Generated by Django 3.1.7 on 2021-04-03 10:51
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('order', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='order',
name='is_paid',
field=models.BooleanField(default=False),
),
]
| [
"shubham.joil@stits.co"
] | shubham.joil@stits.co |
8cc15d1e5237607661d9a462a86e9f2eb81593f5 | 58d9ed3ea04d22449f03fafdb7cdc0aad8ff87f1 | /pyCardiac/signal/analysis/phase_singularity.py | 28c30c964cf036f2b12f678c3cbb16faf46560d2 | [
"MIT"
] | permissive | Lokynik/pyCardiac | 2401c25cabff4fb0018e7d4ed365e251b87de8da | f0ad0868af233830eb2c4c6cba6136e4c80265c1 | refs/heads/master | 2020-09-05T06:23:10.072867 | 2019-05-24T18:32:23 | 2019-05-24T18:32:23 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,770 | py | import numpy as np
from ...routines import phase_difference
def phase_singularity_detection_lasso(phase_array: np.ndarray, result: list,
i_range: tuple = None, j_range: tuple = None):
"""Detects phase singularity points (PS) in ``phase_array`` with lasso method.
Parameters
----------
``phase_array``: np.ndarray, shape=(X, Y)
``result`` : list
list to append coordinates of PS
``i_range`` : tuple, optional
range along first axis to process ``phase_array``
``j_range`` : tuple, optional
range along seconf axis to process ``phase_array``
Returns
-------
None
use ``result`` to return PS coordinates
"""
if type(result) is not list:
raise Exception("Invalid value of the argument: <result> must be a list!")
if (i_range == None): # => j_range == None too
i_range = (0, phase_array.shape[0])
j_range = (0, phase_array.shape[1])
i_min, i_max = i_range
j_min, j_max = j_range
i_middle, j_middle = (i_max + i_min) // 2, (j_max + j_min) // 2
N, M = i_max - i_min, j_max - j_min # phase shape
diff = 0
for i in range(i_min + 1, i_max):
diff += phase_difference(phase_array[i-1, j_min], phase_array[i, j_min])
diff -= phase_difference(phase_array[i-1, j_max-1], phase_array[i, j_max-1])
for j in range(j_min + 1, j_max):
diff -= phase_difference(phase_array[i_min, j-1], phase_array[i_min, j])
diff += phase_difference(phase_array[i_max-1, j-1], phase_array[i_max-1, j])
number_of_ps = np.round(abs(diff) / (2 * np.pi))
if number_of_ps > 0:
if ((N <= 3) and (M <= 3)):
x = i_middle
y = j_middle
result.append([x, y])
elif (N >= M):
phase_singularity_detection_lasso(phase_array, result, (i_min, i_middle+1), (j_min, j_max))
phase_singularity_detection_lasso(phase_array, result, (i_middle-1, i_max), (j_min, j_max))
elif (M > N):
phase_singularity_detection_lasso(phase_array, result, (i_min, i_max), (j_min, j_middle+1))
phase_singularity_detection_lasso(phase_array, result, (i_min, i_max), (j_middle-1, j_max))
return number_of_ps
def phase_singularity_detection(phase_array: np.ndarray) -> np.ndarray:
"""Detects phase singularity points (PS) in ``phase_array``.
Parameters
----------
``phase_array``: np.ndarray, shape=(X, Y)
Returns
-------
np.ndarray, shape=(N, 2)
x and y coordinates of PS
"""
i_list, j_list = [], []
for i in range(1, phase_array.shape[0] - 1):
for j in range(1, phase_array.shape[1] - 1):
k11 = phase_difference(phase_array[i-1, j], phase_array[i-1, j-1])
k21 = phase_difference(phase_array[i-1, j+1], phase_array[i-1, j])
k31 = phase_difference(phase_array[i, j+1], phase_array[i-1, j+1])
k32 = phase_difference(phase_array[i+1, j+1], phase_array[i, j+1])
k33 = phase_difference(phase_array[i+1, j], phase_array[i+1, j+1])
k23 = phase_difference(phase_array[i+1, j-1], phase_array[i+1, j])
k13 = phase_difference(phase_array[i, j-1], phase_array[i+1, j-1])
k12 = phase_difference(phase_array[i-1, j-1], phase_array[i, j-1])
k = k11 + k21 + k32 + k33 + k23 + k13 + k12
if np.abs(k) >= 3.0:
i_list.append(i)
j_list.append(j)
result = np.array([i_list, j_list]).transpose()
return result | [
"pikunov@phystech.edu"
] | pikunov@phystech.edu |
1e173b0d0f6cebec0e25b023d5dc35c3ce20abf4 | 04d0cb0e687c4cd7e433393c8ae35cd9725bb9f1 | /plugins/operators/stage_s3.py | 4c7648190f49a8e45cc022dfd08c97bbda6d34d3 | [] | no_license | mrthlinh/Covid_GoogleTrend | 98ec973e3f60484be858457727c1ca0d11202ea9 | 6f9b09213ff0d580577bc8f37b2e0c31126d8357 | refs/heads/master | 2022-11-15T03:11:07.261896 | 2020-07-13T14:46:51 | 2020-07-13T14:46:51 | 278,245,251 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,637 | py | from airflow.models import BaseOperator
from airflow.contrib.hooks.aws_hook import AwsHook
from airflow.hooks.S3_hook import S3Hook
from airflow.utils.decorators import apply_defaults
import requests
import json
class StateToS3Operator(BaseOperator):
state_code = ['AL','AK','AZ','AR','CA','CO','CT','DE','FL','GA',
'HI','ID','IL','IN','IA','KS','KY','LA','ME','MD',
'MA','MI','MN','MS','MO','MT','NE','NV','NH','NJ',
'NM','NY','NC','ND','OH','OK','OR','PA','RI','SC',
'SD','TN','TX','UT','VT','VA','WA','WV','WI','WY']
@apply_defaults
def __init__(self,
aws_conn_id="",
s3_bucket="",
*args, **kwargs):
super(StateToS3Operator, self).__init__(*args, **kwargs)
self.aws_conn_id = aws_conn_id
self.s3_bucket = s3_bucket
def execute(self, context):
# aws = AwsHook(self.aws_conn_id)
# Create S3 connection
s3 = S3Hook(self.aws_conn_id)
# self.log.info(s3.list_keys(bucket_name=self.s3_bucket))
for state in self.state_code:
URL = "https://covidtracking.com/api/v1/states/" + state + "/daily.json"
self.log.info(URL)
# Get the return request
response = requests.get(URL)
dict2str = [json.dumps(i,sort_keys=True) for i in response.json()]
json_output = "\n".join(dict2str)
key = "Test"+ "/" + state + "/" + "daily.json"
s3.load_string(json_output,key,bucket_name=self.s3_bucket)
# def upload_stat_state(self):
# """
# Get daily stat for each state
# """
# s3 = self.S3Connection.s3
# for state in self.state_code:
# URL = "https://covidtracking.com/api/v1/states/" + state + "/daily.json"
# # URL = "https://covidtracking.com/api/v1/states/" + state + "/current.json"
# print(URL)
# response = requests.get(URL)
# file_name = self.sub_dir + "/" + state + "/" + "daily.json"
# file_object = s3.Object(self.s3bucket_name, file_name)
# # Convert dict to string
# # dict2str = [str(i) for i in response.json()]
# dict2str = [json.dumps(i,sort_keys=True) for i in response.json()]
# json_output = "\n".join(dict2str)
# # print(json_output)
# file_object.put(Body=json_output)
# # file_object.put(Body = json.dumps(response.json()[0], indent=2))
# # file_object.put(Body=bytes(response.content))
| [
"linhtruong@linhs-mbp.lan"
] | linhtruong@linhs-mbp.lan |
59d53bbb855c0d3cd5405009b5d4442fc843e8fb | 4eb779ea222c91c3a0c33421a75560bed5e9d2f2 | /Practice/code2.py | fd3bac578802934803de4f02e7f135697ca6a1b7 | [] | no_license | sunamya/Python | b632bd2349f4a0b70635a90b8ef18a8728317518 | 6911906d0c98885bcf84657e6f2240a622e9d150 | refs/heads/main | 2023-04-05T07:27:44.601337 | 2021-04-18T12:36:14 | 2021-04-18T12:36:14 | 359,138,552 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 270 | py | from __future__ import print_function
n=int(input("Enter Number Of Test Cases : "))
no=int(input("Enter Number OF Houses : "))
for i in range(1,no):
road=input().split(" ") #Fetching data in single line
road=[int(x) for x in road] #Converting into integer
print(road)
| [
"sunamyagupta@gmail.com"
] | sunamyagupta@gmail.com |
0fa2efac723fc725c9158f538efed0a34196dc90 | bd8a0b708629ccf66758f5b66e340ae2b3665b72 | /praktika/maksimaalne_rida.py | f4b27fbc95e7a6d753723de8b320391397749544 | [] | no_license | akaimar/python | d6f0ef16cce980f20fa896a65ce561349052b75b | 6030faf8cc6fcb5719c21c230a2a8f7a55735273 | refs/heads/main | 2023-01-10T07:13:26.148593 | 2020-10-27T21:15:12 | 2020-10-27T21:15:12 | 302,347,566 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,134 | py | """
+ Küsib kasutajalt failinime (maksimaalne_rida_fail.txt)
+ Pärib failist read
# Summerib read kokku
# Leiab suurima summaga rea numbri failis (algab 1st)
# Väljastab rea järjekorranumbri ekraanile
# Näide väljundist: Suurim summa on failis 2. real ja see on 99
"""
# KASUTAJA PÄRINGUD
failinimi = input('Sisestage failinimi: ')
fail = open(failinimi, encoding='UTF-8')
# ANDMETE VÕTMINE FAILIST
andmed = [] #read ühte järjendisse
for rida in fail:
andmed.append(rida)
table = [] #iga rea jaoks oma järjend
for el in andmed:
table.append(el.split())
# RIDADE SUMMEERIMINE TABELIS
summad = [] #siia paigutan kõik ridade summad
for n in range(len(table)): #saan kätte, kui mitu järjendit on tabelis
x = 0
for i in range(len(table[n])): #saan kätte igast järjendist tabelis elemendid
x = x + int(table[n][i]) #liidan kokku
summad.append(x) #lisan summad järjendisse
suurim_summa = summad.index(max(summad)) + 1
print("Summade nimekiri on järgmine:", summad)
print("Suurim summa on failis " + str(suurim_summa) + ". real ja see on " + str(max(summad)))
| [
"noreply@github.com"
] | akaimar.noreply@github.com |
129f43f2cbae6b867ee668ca2a8e26db25bc6b6a | 1e22dfbff2874d376620cd49cf6b934ceac2a7d3 | /traffic_fluctuation.py | 54b066ec465957a8077d1996920ad69294cf56cd | [] | no_license | rodrigo-tinini/CFRAN-Simulator | 737a296ced2bd2bfe683f20b4c00452301d1c8c0 | 6151eb50f034ffe922b79dde5cc4d33584e066cd | refs/heads/master | 2021-06-22T11:25:00.016319 | 2019-06-26T20:03:47 | 2019-06-26T20:03:47 | 115,743,088 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,693 | py | import simpy
import functools
import random as np
import time
from enum import Enum
from scipy.stats import norm
#inter arrival rate of the users requests
arrival_rate = 1
#distribution for arrival of packets
distribution = lambda x: np.expovariate(1/arrival_rate)
#service time of a request
service_time = lambda x: np.randint(1, 600)
#total generated requests per timestamp
total_period_requests = 0
#timestamp to change the load
change_time = 15
#traffic generator - generates requests considering the distribution
class Traffic_Generator(object):
def __init__(self, env, distribution, service, cp):
self.env = env
self.dist = distribution
self.service = service
self.cp = cp
self.req_count = 0
self.action = self.env.process(self.run())
self.load_variation = self.env.process(self.change_load())
#generation of requests
def run(self):
global total_period_requests
while True:
yield self.env.timeout(self.dist(self))
self.req_count += 1
total_period_requests +=1
r = Request(self.env, self.req_count, self.service, self.cp)
self.cp.requests.put(r)
#changing of load
def change_load(self):
while True:
global arrival_rate
global total_period_requests
yield self.env.timeout(change_time)
arrival_rate -= 0.005
print("Arrival rate now is {} at {} and was generated {}".format(arrival_rate, self.env.now, total_period_requests))
total_period_requests = 0
#user request
class Request(object):
def __init__(self, env, aId, service, cp):
self.env = env
self.id = aId
self.service_time = service
self.cp = cp
#self.action = self.env.process(self.run())
#executes this request and send it to deallocation after its service time
def run(self):
yield self.env.timeout(self.service_time(self))
print("Request {} departing".format(self.id))
self.cp.departs.put(self)
#control plane that controls the allocations and deallocations
class Control_Plane(object):
def __init__(self, env):
self.env = env
self.requests = simpy.Store(self.env)
self.departs = simpy.Store(self.env)
self.action = self.env.process(self.run())
#take requests and tries to allocate
def run(self):
while True:
r = yield self.requests.get()
print("Allocating request {}".format(r.id))
self.env.process(r.run())
#starts the deallocation of a request
def depart_request(self):
while True:
r = yield self.departs.get()
print("Deallocating request {}".format(r.id))
env = simpy.Environment()
cp = Control_Plane(env)
t = Traffic_Generator(env, distribution, service_time, cp)
print("\Begin at "+str(env.now))
env.run(until = 3600)
print("Total generated requests {}".format(t.req_count))
print("\End at "+str(env.now)) | [
"tinini.89@gmail.com"
] | tinini.89@gmail.com |
55db676d6f2b08faed2614d8fe254670b6fed986 | 34ceb80ae1bdd52de915b12747aec0eb395dbbfe | /blog/migrations/0009_blog_programmingskills.py | 19dad1ce12b2cd2aa9bccdb8ce53bce5ecedc674 | [] | no_license | dhirajkumar2020/resume | e5b300b7bf02f305d89e7ace9207e24bd9d070ba | aeb80eb8bfda2e864c16c50e410f944baecfc1eb | refs/heads/master | 2020-09-14T09:56:56.450620 | 2019-11-22T10:17:03 | 2019-11-22T10:17:03 | 223,096,737 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 416 | py | # Generated by Django 2.2.7 on 2019-11-22 06:53
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('blog', '0008_blog_softwareskills'),
]
operations = [
migrations.AddField(
model_name='blog',
name='programmingskills',
field=models.CharField(blank=True, default='', max_length=255),
),
]
| [
"dhiraj.kumar@nescode.com"
] | dhiraj.kumar@nescode.com |
7d6c50e0939edae8e06e84d3f0739b57bfd24119 | 641563f61bb4061a3488d047f5744d332b33ea05 | /TesterRunner/runner/testcases/chaoyue_master_zzmj_2019_09_30_03_01.py | ad031de804568dc6fca60e88dac256d9bd2c8cf5 | [] | no_license | Zhaohb2017/test_platform_back | 4c1de839c2939b44146e3ad399bdd99ddbd276db | 4209bbf26204ea39c21bcf9d0a31ef3347bf07e0 | refs/heads/master | 2021-06-20T19:50:06.026273 | 2020-05-17T05:14:20 | 2020-05-17T05:14:20 | 199,758,231 | 0 | 1 | null | 2021-06-10T21:47:34 | 2019-07-31T01:56:14 | Python | UTF-8 | Python | false | false | 1,867 | py | import sys
import os
cur_path = os.path.abspath(os.path.dirname(__file__))
last_path = os.path.split(cur_path)[0]
last_path_len = last_path.split("/")[-1]
root_path = last_path[:len(last_path) - len(last_path_len)]
sys.path.append(root_path)
import time
import unittest
from chaoyue.master.phz.api import *
class PHZTestCase(unittest.TestCase):
def test_task(self):
player1 = UserBehavior(127641,127641,True)
player2 = UserBehavior(127643)
time.sleep(2)
player1.SetGameType = "转转麻将"
player2.SetGameType = "转转麻将"
create_room_data = {'o_player': 2, 'o_round': 5, 'o_double_plus_new': False, 'o_zimohu': '可抢杠胡', 'o_sevenPair': True, 'o_xianjia': False, 'o_hongzhonglaizi': False, 'o_youpaibihu': False, 'o_qigang': False, 'o_zhuaMa': 2, 'o_double': 0, 'o_double_score': '', 'o_double_plus': 2, 'o_doublePlusNewScore': 10, 'o_159zhongma': False, 'o_bankerzhongniao': False, 'roomTypeVuale': '普通创房', 'clubRoomTypeVuale': '', 'o_club_id': ''}
player1.CreateRoom(create_room_data)
time.sleep(2)
cards_data = {"1":["1W","1W","2W","2W","3W","3W","4W","4W","5W","5W","6W","6W","7W","7W","8W","8W","9W","9W","HZ","HZ"],
"2":["1S","1S","3S","3S","5S","5S","1T","1T","3T","3T","5T","5T","6W","6T"],
"3":["2S","2S","4S","4S","6S","6S","2T","2T","4T","4T","6T","6T","6T"],
"4":["1T","1T","2S","2W","2T","2S","3W","3T","3S","4W","4T","4S","8W"],
"5":["HZ","HZ","9W","6W","6W","6W","6W","9S","9T","9S","9T","6T","6S"]}
player1.maker_card(cards_data,player1.room_id)
time.sleep(2)
player2.ApplyEnterRoom(player1.room_id,0)
player1.OperateApi('胡')
time.sleep(5)
player1.ConnectClose()
player2.ConnectClose()
if __name__=='__main__':
unittest.main() | [
"540383428@qq.com"
] | 540383428@qq.com |
198e1bc91c2353ff7b712aad20d49e61c56292dd | 33b1d5eedcf7e75a83483d9e9cb95288ab35cf88 | /专题研究/专题三：12.获取城市坐标.py | bffc2f8b45b49d4471bf514f3f9536d973f5fca0 | [
"MIT"
] | permissive | Ringo-li/urban_data_analysis | 66baa5ca57f514db9c72b351f5c207e7b6382d12 | c03c92f838849a4cfd34814ef8ddf956e4a9f375 | refs/heads/master | 2021-03-14T23:17:58.022980 | 2020-06-17T15:11:14 | 2020-06-17T15:11:14 | 246,802,436 | 5 | 1 | null | null | null | null | UTF-8 | Python | false | false | 988 | py | # -*- coding: utf-8 -*-
import arcpy
import pandas as pd
#中国城市地图位置
fc = r'D:\rui\code_analysis\file\subject\chapter3\市界_region.shp'
#设置空间参照坐标系，在arcgis中设置好中国城市地图坐标系，右击图层layer——属性——坐标系——另存坐标系文件
sr = arcpy.SpatialReference(r'D:\rui\code_analysis\file\subject\chapter3\Xian 1980 3 Degree GK CM 108E.prj')
#创建游标，遍历表格,获取城市名称，X/Y坐标
with arcpy.da.SearchCursor(fc,['NAME','shape@X','shape@Y'],spatial_reference=sr) as cursor:
ls = []
for row in cursor:
#游标获取元组数据，转换为列表
print list(row)
data = list(row)
#将获得的列表数据保存到ls中
ls.append(data)
#ls为二维数值形式，将其转换为pandas对象并导出，注意导出编码为utf8
pd.DataFrame(ls).to_csv(r'D:\rui\code_analysis\file\subject\chapter3\coor_xian80.csv',encoding='utf8')
| [
"ry.li@qq.com"
] | ry.li@qq.com |
a08ba34f8acffacbc09afb49fda4f3c7c36d7a31 | 0448321097219bd8991809ced2816c743677656a | /graph_classes/graphclass_cycle.py | 6c135edc42518906830b1f7b4990de890ba50f2f | [] | no_license | WonkySpecs/mutant-network-sim | 508bc976997fbd9ed92f286c1064773fb85860bb | 29ca68da5ce0956d18a9c5cd9a3278f3fad6b17c | refs/heads/master | 2021-01-11T02:04:05.589870 | 2017-05-07T23:50:24 | 2017-05-07T23:50:24 | 70,815,153 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 682 | py | import networkx as nx
import graph_classes.graphclass as gc
class GraphClass_Cycle(gc.GraphClass):
def buildGraph(self, parameters):
convertedParams = self.checkParamsValid(parameters)
#Check if error (Will return an error message)
if type(convertedParams) == str:
return convertedParams
nodes = convertedParams['nodes']
G = nx.Graph()
for i in range(nodes - 1):
G.add_edge(i, i + 1)
G.add_edge(0, nodes - 1)
return G
metadata = {
"name" : "cycle",
"display_name" : "Cycle",
"parameters" : {"nodes" : {'type' : 'int'}},
"description" : ( "Basic graph class - each node has 2 neighbours"
"\nnodes parameter is the number of nodes")
}
| [
"w1ll100@hotmail.co.uk"
] | w1ll100@hotmail.co.uk |
450b8912a42d43ebcefc08d7362f8d72543645b0 | d51a07fe227a1cdb3c5bded913a4ac22895afbd1 | /app/controllers/test_auth_controller.py | 9cfe8288db2591430ed613b30509d7909d8a4ad7 | [] | no_license | serlesen/PyDB | 08c1abb9bdba9e1fd3025271810ba98a95d85f69 | 4e6762f180bfe61c5c86610cb53b3b19692b3736 | refs/heads/master | 2023-02-22T14:10:47.559916 | 2021-11-02T08:39:12 | 2021-11-02T08:39:12 | 219,302,097 | 0 | 1 | null | 2023-02-15T22:57:59 | 2019-11-03T13:04:45 | Python | UTF-8 | Python | false | false | 3,015 | py | import json
import unittest
from app.controllers import app
from app.test.collections_simulator import CollectionsSimulator
from app.tools.database_context import DatabaseContext
from app.threads.threads_manager import ThreadsManager
class AuthControllerTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
if DatabaseContext.THREADS_MANAGER_CYCLING == False:
DatabaseContext.THREADS_MANAGER_CYCLING = True
ThreadsManager().start()
CollectionsSimulator.build_users_col()
def setUp(self):
app.config["TESTING"] = True
app.config["DEBUG"] = True
self.app = app.test_client()
@classmethod
def tearDownClass(cls):
CollectionsSimulator.clean()
DatabaseContext.THREADS_MANAGER_CYCLING = False
def test_login(self):
response = self.app.post('/auth/login', data=json.dumps({'login': 'admin', 'password': 'admin'}), content_type='application/json')
self.assertEqual(response.status_code, 200)
login_info = json.loads(response.data)
self.assertEqual(login_info['login'], 'admin')
self.assertTrue('token' in login_info)
def test_logout(self):
response = self.app.post('/auth/login', data=json.dumps({'login': 'admin', 'password': 'admin'}), content_type='application/json')
token = json.loads(response.data)['token']
response = self.app.post('/auth/logout', headers={'Authorization': 'Bearer {}'.format(token)})
self.assertEqual(response.status_code, 200)
def test_create_user(self):
response = self.app.post('/auth/login', data=json.dumps({'login': 'admin', 'password': 'admin'}), content_type='application/json')
token = json.loads(response.data)['token']
response = self.app.post('/auth/user', data=json.dumps({'login': 'new-user', 'password': 'new-user'}), headers={'Authorization': 'Bearer {}'.format(token)}, content_type='application/json')
self.assertEqual(response.status_code, 200)
response = self.app.post('/auth/login', data=json.dumps({'login': 'new-user', 'password': 'new-user'}), content_type='application/json')
self.assertEqual(response.status_code, 200)
login_info = json.loads(response.data)
self.assertEqual(login_info['login'], 'new-user')
self.assertTrue('token' in login_info)
def test_get_user(self):
response = self.app.post('/auth/login', data=json.dumps({'login': 'admin', 'password': 'admin'}), content_type='application/json')
token = json.loads(response.data)['token']
response = self.app.get('/auth/user', headers={'Authorization': 'Bearer {}'.format(token)}, content_type='application/json')
self.assertEqual(response.status_code, 200)
user = json.loads(response.data)
self.assertEqual(user['login'], 'admin')
self.assertNotEqual(user['password'], 'admin')
def suite():
return unittest.TestLoader().loadTestsFromTestCase(AuthControllerTest)
| [
"sergio.lema@ekino.fr"
] | sergio.lema@ekino.fr |
1078c72e567126b5c3bae58f97f4f36b32696eaf | 240c4398e2886256099cb18b7c4cbcfbc08a3ff8 | /efb-v2/res/bak_config/modules/filter.py | 341bfb67fdbada89fc84eecae9159095447fbe20 | [] | no_license | bmwcto/docker | f1d0674dda1c1bce0735b60acff0f0516bbc49fe | 504949a8dfa233f50e599cbebd929dcdb7a3b8b9 | refs/heads/main | 2023-04-01T12:15:42.560212 | 2021-04-12T16:02:51 | 2021-04-12T16:02:51 | 355,555,018 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 9,308 | py | import pathlib
import shelve
import atexit
import uuid
from collections.abc import Mapping
from threading import Timer
from typing import Optional, Union, Dict
from typing_extensions import overload, Literal
from ruamel.yaml import YAML
from ehforwarderbot import Middleware, Message, Status, coordinator, utils
from ehforwarderbot.chat import Chat, SystemChat
from ehforwarderbot.types import ModuleID, MessageID, InstanceID, ChatID
from ehforwarderbot.message import MsgType, MessageCommands, MessageCommand
from ehforwarderbot.status import MessageRemoval, ReactToMessage, MessageReactionsUpdate
class FilterMiddleware(Middleware):
"""
Filter middleware.
A demo of advanced user interaction with master channel.
"""
middleware_id: ModuleID = ModuleID("filter.FilterMiddleware")
middleware_name: str = "Filter Middleware"
__version__: str = '1.1.1'
message_cache: Dict[MessageID, Message] = {}
def __init__(self, instance_id: Optional[InstanceID] = None):
super().__init__(instance_id)
# load config
self.yaml = YAML()
conf_path = utils.get_config_path(self.middleware_id)
if not conf_path.exists():
conf_path.touch()
self.config = self.yaml.load(conf_path)
self.filters = [
self.chat_id_based_filter
]
# Mapping
self.FILTER_MAPPING = {
"chat_name_contains": self.chat_name_contains_filter,
"chat_name_matches": self.chat_name_matches_filter,
"message_contains": self.message_contains_filter,
"ews_mp": self.ews_mp_filter
}
# Chat ID based filter init
shelve_path = str(utils.get_data_path(self.middleware_id) / "chat_id_filter.db")
self.chat_id_filter_db = shelve.open(shelve_path)
atexit.register(self.atexit)
# load other filters
if isinstance(self.config, Mapping):
for i in self.config.keys():
f = self.FILTER_MAPPING.get(i)
if f:
self.filters.append(f)
def atexit(self):
self.chat_id_filter_db.close()
def process_message(self, message: Message) -> Optional[Message]:
# Only collect the message when it's a text message match the
# hotword "filter`"
if message.type == MsgType.Text and message.text == "filter`" and \
message.deliver_to != coordinator.master:
reply = self.make_status_message(message)
self.message_cache[reply.uid] = message
coordinator.master.send_message(reply)
return None
# Do not filter messages from master channel
if message.deliver_to != coordinator.master:
return message
# Try to filter all other messages.
return self.filter(message)
def make_status_message(self, msg_base: Message = None, mid: MessageID = None) -> Message:
if mid is not None:
msg = self.message_cache[mid]
elif msg_base is not None:
msg = msg_base
else:
raise ValueError
reply = Message(
type=MsgType.Text,
chat=msg.chat,
author=msg.chat.make_system_member(uid=ChatID("filter_info"), name="Filter middleware", middleware=self),
deliver_to=coordinator.master,
)
if mid:
reply.uid = mid
else:
reply.uid = str(uuid.uuid4())
status = self.filter_reason(msg)
if not status:
# Blue circle emoji
status = "\U0001F535 This chat is not filtered."
else:
# Red circle emoji
status = "\U0001F534 " + status
reply.text = "Filter status for chat {chat_id} from {module_id}:\n" \
"\n" \
"{status}\n".format(
module_id=msg.chat.module_id,
chat_id=msg.chat.id,
status=status
)
command = MessageCommand(
name="%COMMAND_NAME%",
callable_name="toggle_filter_by_chat_id",
kwargs={
"mid": reply.uid,
"module_id": msg.chat.module_id,
"chat_id": msg.chat.id
}
)
if self.is_chat_filtered_by_id(msg.chat):
command.name = "Unfilter by chat ID"
command.kwargs['value'] = False
else:
command.name = "Filter by chat ID"
command.kwargs['value'] = True
reply.commands = MessageCommands([command])
return reply
def toggle_filter_by_chat_id(self, mid: str, module_id: str,
chat_id: str, value: bool):
self.chat_id_filter_db[str((module_id, chat_id))] = value
reply = self.make_status_message(mid=mid)
reply.edit = True
# Timer(0.5, coordinator.master.send_message, args=(reply,)).start()
coordinator.master.send_message(reply)
return None
@staticmethod
def get_chat_key(chat: Chat) -> str:
return str((chat.module_id, chat.id))
def process_status(self, status: Status) -> Optional[Status]:
for i in self.filters:
if i(status, False):
return None
return status
def filter_reason(self, message: Message):
for i in self.filters:
reason = i(message, True)
if reason is not False:
return reason
return False
def filter(self, message: Message):
for i in self.filters:
if i(message, False):
return None
return message
@staticmethod
def get_chat_from_entity(entity: Union[Message, Status]) -> Optional[Chat]:
if isinstance(entity, Message):
return entity.chat
elif isinstance(entity, MessageRemoval):
return entity.message.chat
elif isinstance(entity, ReactToMessage):
return entity.chat
elif isinstance(entity, MessageReactionsUpdate):
return entity.chat
else:
return None
# region [Filters]
"""
Filters
Filter must take only two argument apart from self
- ``entity`` (``Union[Message, Status]``)
The message entity to filter
- ``reason`` (``bool``)
Determine whether or not to return the reason to block a message
To allow a message to be delivered, return ``False``.
Otherwise, return ``True`` or a string to explain the reason of filtering
if ``reason`` is ``True``.
"""
@overload
def chat_id_based_filter(self,
entity: Union[Message, Status],
reason: Literal[True]) -> Union[bool, str]:
...
@overload
def chat_id_based_filter(self,
entity: Union[Message, Status],
reason: Literal[False]) -> bool:
...
def chat_id_based_filter(self,
entity: Union[Message, Status],
reason: bool) -> Union[bool, str]:
chat = self.get_chat_from_entity(entity)
if not chat:
return False
if self.is_chat_filtered_by_id(chat):
if reason:
return "Chat is manually filtered."
else:
return True
else:
return False
def is_chat_filtered_by_id(self, chat: Chat) -> bool:
key = str((chat.module_id, chat.id))
if key in self.chat_id_filter_db:
return self.chat_id_filter_db[key]
return False
def chat_name_contains_filter(self, entity, reason):
chat = self.get_chat_from_entity(entity)
if not chat:
return False
for i in self.config['chat_name_contains']:
if i in chat.display_name:
if reason:
return "Chat is filtered because its name contains \"{}\".".format(i)
else:
return True
return False
def chat_name_matches_filter(self, entity, reason):
chat = self.get_chat_from_entity(entity)
if not chat:
return False
for i in self.config['chat_name_matches']:
if i == chat.display_name:
if reason:
return "Chat is filtered because its name matches \"{}\".".format(i)
else:
return True
return False
def message_contains_filter(self, entity, reason):
if not isinstance(entity, Message):
return False
for i in self.config['message_contains']:
if i in entity.text:
if reason:
return "Message is filtered because its contains \"{}\".".format(i)
else:
return True
return False
def ews_mp_filter(self, entity, reason):
chat = self.get_chat_from_entity(entity)
if not chat:
return False
if chat.vendor_specific.get('is_mp'):
if reason:
return "Chat is filtered as it's a EWS \"WeChat Official Account\" chat."
else:
return True
return False
# endregion [Filters]
| [
"wowjoint@gmail.com"
] | wowjoint@gmail.com |
ece95817e254bad4af662002d4394d82856327f1 | 4fc3604c2e2f5e54b7cf19578c7013f0525e2ee7 | /generators/utils/3bitPathDist.py | 056413a2dc87b7de99080b49067fb9dd9813c160 | [] | no_license | nbermudezs/bracketology | d4fd4aad1052505dd3287310cdd5b9df97b75705 | 86ef2d495842350120e015260fe89cf0f12a392c | refs/heads/master | 2020-05-05T05:57:27.290588 | 2019-07-08T14:39:40 | 2019-07-08T14:39:40 | 179,770,315 | 0 | 0 | null | 2019-06-30T02:38:39 | 2019-04-06T00:06:35 | Python | UTF-8 | Python | false | false | 3,639 | py | from __future__ import print_function
__author__ = "Nestor Bermudez"
__license__ = "MIT"
__version__ = "1.0.0"
__email__ = "nab6@illinois.edu"
__status__ = "Development"
import json
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import rpy2
import rpy2.robjects as robjects
import seaborn as sns
from scipy.stats import chisquare
paths = {
'P_S1': [0, 8, 12],
'P_S8': [1, 8, 12],
'P_S5': [2, 9, 12],
'P_S4': [3, 9, 12],
'P_S6': [4, 10, 13],
'P_S3': [5, 10, 13],
'P_S7': [6, 11, 13],
'P_S2': [7, 11, 13],
'P_R2_1': [8, 12, 14],
'P_R2_2': [9, 12, 14],
'P_R2_3': [10, 13, 14],
'P_R2_4': [11, 13, 14]
}
plt.style.use('seaborn-white')
sns.set_palette('colorblind')
def load_brackets(fmt='TTT'):
with open('allBrackets{}.json'.format(fmt)) as f:
brackets = json.load(f)['brackets']
return brackets
def observed_dist(brackets, year, bits):
vectors = [list(bracket['bracket']['fullvector'])
for bracket in brackets
if int(bracket['bracket']['year']) < year]
vectors = np.array(vectors, dtype=int)
vectors = vectors[:, :60].reshape(-1, 15)
triplets = vectors[:, bits]
triplets, counts = np.unique(triplets, axis=0, return_counts=True)
triplet_labels = np.apply_along_axis(''.join, 1, triplets.astype(str))
for t in ['000', '001', '010', '011', '100', '101', '110', '111']:
if t not in triplet_labels:
triplet_labels = np.append(triplet_labels, t)
counts = np.append(counts, 0)
return {l: c for l, c in zip(triplet_labels, counts)}
def expected_dist(brackets, year, bits):
vectors = [list(bracket['bracket']['fullvector'])
for bracket in brackets
if int(bracket['bracket']['year']) < year]
vectors = np.array(vectors, dtype=int)
vectors = vectors[:, :60].reshape(-1, 15)
triplets = vectors[:, bits]
p_1 = np.mean(triplets, axis=0)
p_0 = 1 - p_1
p = [p_0, p_1]
result = {}
for t in ['000', '001', '010', '011', '100', '101', '110', '111']:
values = [int(x) for x in list(t)]
triplet_p = np.prod([p[values[i]][i] for i in range(3)])
result[t] = (year - 1985) * 4 * triplet_p
return result
def uniformity_check(observed, expected):
chi, p = chisquare(observed, expected)
print('Uniformity chi-square test p-value', p)
def plot_dist(brackets, year, bits, name):
observed = observed_dist(brackets, year, bits)
expected = expected_dist(brackets, year, bits)
data = {'Observed': observed, 'Expected (ind)': expected}
df = pd.DataFrame.from_dict(data)
df.plot.bar(rot=0)
# plt.show()
plt.title('3-bit path value distribution - {}'.format(name))
plt.savefig('DistPlots/TTT/3bit_path-{}.png'.format(name))
plt.cla()
plt.clf()
values = list(observed.values())
keys = list(observed.keys())
arr = 'array(c{}, dim=c(2, 2, 2))'.format(
tuple(np.array(values)[np.argsort(keys)].astype(int).tolist()))
res = robjects.r('library(hypergea); hypergeom.test(' + arr + ")['p.value']")
p_value = np.array(res[0])[0]
print('Independence Fisher exact test p-value', p_value)
uniformity_check(list(observed.values()), np.repeat((year - 1985) * 4 / 8, 8))
print()
# print('m = array(c{}, dim=c(2, 2, 2))'.format(tuple(np.array(list(observed.values()))[np.argsort(observed.keys())].astype(int).tolist())))
if __name__ == '__main__':
brackets = load_brackets()
for name, bits in paths.items():
print('path {}'.format(name))
plot_dist(brackets, 2019, bits, name)
| [
"nestor.bermudez@agilityfeat.com"
] | nestor.bermudez@agilityfeat.com |
e810dad75980e35a6c7789a53d2a848683a6677c | e0a83b46e5fbd2e80ccafb7b1d4f792d31d516b8 | /pascal/alerts/serializer.py | ac5866f1ce7e250f818022e15cec1dc9efa30c99 | [] | no_license | helloworld76757/pascal | f74ad1a5b13f01fa1613d2786b9f4c0f763eb034 | 37b5b12cba862336742e609475e874c4b0f3efbf | refs/heads/master | 2020-06-13T05:15:55.037124 | 2016-12-03T00:59:08 | 2016-12-03T00:59:08 | 75,442,115 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 223 | py | from rest_framework import serializers
from .models import Alert, AlertResponse
class AlertSerializer(serializers.ModelSerializer):
class Meta:
model = Alert
fields = ('timestamp', 'name', 'value')
| [
"helloworld76757@mailinator.com"
] | helloworld76757@mailinator.com |
852ecca1e2ce71ff84694ec84775776ecab7d1c6 | 3521f78c180ed2b403c5f9d66dcd1ea7240c0eff | /2015/table.py | 83c075c6a1e3a408ebb0cd8ce8539099b3e525d6 | [
"BSD-3-Clause"
] | permissive | timm/sbse14 | f5b683a4cebbf8655f50b10215ac328a61c54185 | 006df700af17566ee2b66cd53de9587004558772 | refs/heads/master | 2016-09-06T09:36:06.618949 | 2014-09-17T03:24:21 | 2014-09-17T03:24:21 | 23,025,059 | 15 | 5 | null | null | null | null | UTF-8 | Python | false | false | 2,069 | py | from __future__ import division
import sys,random,math,re
sys.dont_write_bytecode = True
class o():
"Anonymous container"
def __init__(i,**fields): i.has().update(fields)
def has(i) : return i.__dict__
#def __getattr__(i,k) : return i.__dict__[k]
#def __setattr__(i,k,v) : i.__dict__[k] = v; return v
def __repr__(i):
name = i.__class__.__name__
return name+'{'+' '.join([':%s %s' % (k,i.has()[k])
for k in i.public()])+ '}'
def public(i):
return [k for k in sorted(i.has().keys())
if not "_" in k]
about = classmethod
akos = dict(nums = r'^[\$<>]',
syms = r'^[^\$<>]',
klass = r'^[=]',
indep = r'^[^<>=]',
dep = r'^[=<>]',
less = r'^[<]',
more = r'^[>]',
ignore = r'^[/]')
class Log:
def __repr__(i): return '%s(%s,%s)' % (i.__class__.__name__,i.txt,i.col)
def log(i,val): pass
def __init__(i,txt="",col=None,w=1):
i.txt, i.col,i.w=txt,col,w
class Num(Log): pass
class Thing(Num): pass
class Sym(Log): pass
class Row:
fields = {'gender' :Sym,
'age' :Num,
'$shoesize' :Num,
'>lifeExpectancy':Thing}
seen=re.match
def complete(klass):
skip="\?"
klass.cols = o()
cols = klass.cols.has()
for ako in akos.keys():
cols[ako]=[]
cols["eden"] = []
for c,(name,klass) in enumerate(klass.fields.items()):
if not seen(skip, name):
cols["eden"] += [(c,name,klass)]
for ako,pattern in akos.items():
if seen(pattern,name):
cols[ako] += [c]
return klass
class Table:
def __init__(i,about):
i.about = complete(about)
i.rows = []
i.cols = i.headers0(about.cols.eden)
def headers0(i,pairs):
return [klass(name,c) for
c,name,klass in pairs]
def cellhead(i,row,*whats):
for what in whats:
return row[c],i.headers[c]
def log(i,row):
for h in i.headers:
h.log(row[h.col])
tbl = Table(Row)
print tbl.cols
print tbl.about.cols
| [
"tim@menzies.us"
] | tim@menzies.us |
a3a3312b93fd1130507887a28abc6e2859e972c6 | 6fcfb638fa725b6d21083ec54e3609fc1b287d9e | /python/Guanghan_ROLO/ROLO-master/update/utils/utils_draw_coord.py | cb75d7c64e6e32251001750fef1e6f67b093e62e | [] | no_license | LiuFang816/SALSTM_py_data | 6db258e51858aeff14af38898fef715b46980ac1 | d494b3041069d377d6a7a9c296a14334f2fa5acc | refs/heads/master | 2022-12-25T06:39:52.222097 | 2019-12-12T08:49:07 | 2019-12-12T08:49:07 | 227,546,525 | 10 | 7 | null | 2022-12-19T02:53:01 | 2019-12-12T07:29:39 | Python | UTF-8 | Python | false | false | 2,002 | py | from utils_convert_coord import coord_regular_to_decimal, coord_decimal_to_regular
import cv2
def debug_decimal_coord(img, coord_decimal, prob = None, class_id = None):
img_cp = img.copy()
img_ht, img_wid, nchannels = img.shape
coord_regular = coord_decimal_to_regular(coord_decimal, img_wid, img_ht)
debug_regular_coord(img, coord_regular, prob, class_id)
def debug_regular_coord(img, coord_regular, prob = None, class_id = None):
img_cp = img.copy()
[x_topleft, y_topleft, w_box, h_box] = coord_regular
cv2.rectangle(img_cp,
(x_topleft, y_topleft),
(x_topleft + w_box, y_topleft + h_box),
(0,255,0), 2)
if prob is not None and class_id is not None:
assert(isinstance(prob, (float)))
assert(isinstance(class_id, (int, long)))
cv2.rectangle(img_cp,
(x_topleft, y_topleft - 20),
(x_topleft + w_box, y_topleft),
(125,125,125),-1)
cv2.putText(img_cp,
str(class_id) + ' : %.2f' % prob,
(x_topleft + 5, y_topleft - 7),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,0,0), 1)
cv2.imshow('debug_detection',img_cp)
cv2.waitKey(1)
def debug_3_locations( img, gt_location, yolo_location, rolo_location):
img_cp = img.copy()
for i in range(3): # b-g-r channels
if i== 0: location= gt_location; color= (0, 0, 255) # red for gt
elif i ==1: location= yolo_location; color= (255, 0, 0) # blur for yolo
elif i ==2: location= rolo_location; color= (0, 255, 0) # green for rolo
x = int(location[0])
y = int(location[1])
w = int(location[2])
h = int(location[3])
if i == 1 or i== 2: cv2.rectangle(img_cp,(x-w//2, y-h//2),(x+w//2,y+h//2), color, 2)
elif i== 0: cv2.rectangle(img_cp,(x,y),(x+w,y+h), color, 2)
cv2.imshow('3 locations',img_cp)
cv2.waitKey(100)
return img_cp
| [
"659338505@qq.com"
] | 659338505@qq.com |
8ce92bccb334b194201db3ad0db027122a10c3f5 | a01aa15daf3f625420a0ab1bee18674361dee717 | /code/processAcData.py | c900423cb8e1a90fc357bf0a1d0397b9788979a7 | [] | no_license | sirinda-p/sna_utcc | f6ddf92a2ce81ec7a9f69f8da0deafdf2dcc1fc2 | 39276ebd838a9d2d6ee209a4a50fe25e721473a3 | refs/heads/master | 2020-04-03T15:29:38.820434 | 2016-03-25T09:40:09 | 2016-03-25T09:40:09 | 39,806,492 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 650 | py | import os
from igraph import *
# Remove nodes and corresponding edges that are not in the colledted class section
def removeNodeAndEdge():
# keep nodes from 5702100227 to 5702100312
path = "/home/amm/Desktop/sna-project/sna-git/data/gml/"
flist = ["Ac57-all_bf.gml","Ac57-all_friend.gml","Ac57-all_study.gml" ]
for fname in flist:
newfname = fname.replace("-all","-1sec")
print newfname
#f_w = open(path+fname, "w")
g = read(path+fname, format="gml")
vlist = []
for v in g.vs():
if int(v['id']) in range(227, 312):
vlist.append(v)
newg = g.subgraph(vlist)
write(newg, path+newfname)
removeNodeAndEdge()
| [
"sirinda111@gmail.com"
] | sirinda111@gmail.com |
ac8073d5c442216c2a5bad5feb1918bfd8d7af96 | d8f146faafd1d9c0da015c401a49e48d84e10db3 | /app.py | 1e46b529917f631e2da4bf036b839bc8202e4745 | [] | no_license | vincentiuskedang/pdacapstone | 86ab0e53d2e7221789fb88779f38d0c9efdb5e48 | 2b0a8c708f85a6f87804556d6fc752bbfe584872 | refs/heads/main | 2023-08-27T20:46:10.344855 | 2021-10-25T20:21:54 | 2021-10-25T20:21:54 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,222 | py | from flask import Flask, render_template
import pandas as pd
import matplotlib
import matplotlib.pyplot as plt
from io import BytesIO
import base64
from bs4 import BeautifulSoup
import requests
#don't change this
matplotlib.use('Agg')
app = Flask(__name__) #do not change this
#insert the scrapping here
url_get = requests.get('https://www.coingecko.com/en/coins/ethereum/historical_data/usd?start_date=2020-01-01&end_date=2021-06-30#panel')
soup = BeautifulSoup(url_get.content,"html.parser")
#find your right key here
table = soup.find('table',attrs={'class':'table table-striped text-sm text-lg-normal'})
row = soup.find_all('th',attrs={'class':'font-semibold text-center'})
row_length = len(row)
temp = [] #initiating a tuple
for i in range(0, row_length):
#finding all Dates in table
Date = soup.find_all('th',attrs={'class':'font-semibold text-center'})[i].text
Date = Date.strip('\n')
# finding all Volume in table
Volume = soup.find_all('td',attrs={'class':'text-center'})[i*4+1].text
Volume = Volume.strip('\n')
#append the data that has been obtained, into an array.
temp.append((Date, Volume))
#reverse the order of the list
temp = temp[::-1]
#change into dataframe
df = pd.DataFrame(temp,columns=('Date', 'Volume'))
#insert data wrangling here
#change to datetime64 type
df['Date'] = df['Date'].astype('datetime64')
#cleaning the data so we can analyze much better
df['Volume'] = df['Volume'].str.replace('$','')
df['Volume'] = df['Volume'].str.replace(',','')
#change to int64 type
df['Volume'] = df['Volume'].astype('float64')
#make Date as index
df = df.set_index('Date')
#end of data wranggling
@app.route("/")
def index():
card_data = f'{df["Volume"].mean().round(2)}' #be careful with the " and '
# generate plot
ax = df.plot(figsize = (10,5))
# Rendering plot
# Do not change this
figfile = BytesIO()
plt.savefig(figfile, format='png', transparent=True)
figfile.seek(0)
figdata_png = base64.b64encode(figfile.getvalue())
plot_result = str(figdata_png)[2:-1]
# render to html
return render_template('index.html',
card_data = card_data,
plot_result=plot_result
)
if __name__ == "__main__":
app.run(debug=True) | [
"noreply@github.com"
] | vincentiuskedang.noreply@github.com |
1220ea2bbb065d2ac6dacade7ee3ed01983d7ba7 | 1e8feb9c9f0028a264a2f882f4911b4349dc5348 | /bingraphvis/angr/annotator.py | b7786294843ca13de7b86d7305fd85b12d9bfba4 | [
"BSD-2-Clause"
] | permissive | AmesianX/bingraphvis | b90b99454291ff104d3d0a9d245376a6c655ee25 | ebdd0b7d8f5d9cec81a7b1edb9dc78b7b0157117 | refs/heads/master | 2021-01-13T13:04:18.620480 | 2016-11-02T23:59:12 | 2016-11-02T23:59:12 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 10,663 | py |
from ..base import *
import capstone
import pyvex
class AngrColorSimprocedures(NodeAnnotator):
def __init__(self):
super(AngrColorSimprocedures, self).__init__()
def annotate_node(self, node):
if node.obj.is_simprocedure:
if node.obj.simprocedure_name in ['PathTerminator','ReturnUnconstrained','UnresolvableTarget']:
node.style = 'filled'
node.fillcolor = '#ffcccc'
else:
node.style = 'filled'
node.fillcolor = '#dddddd'
class AngrColorExit(NodeAnnotator):
def __init__(self):
super(AngrColorExit, self).__init__()
def annotate_node(self, node):
if not node.obj.is_simprocedure:
found = False
for e in self.graph.edges:
if e.src == node:
found = True
if 'jumpkind' in e.meta and e.meta['jumpkind'] == 'Ijk_Ret':
node.style = 'filled'
node.fillcolor = '#ddffdd'
if not found:
node.style = 'filled'
node.fillcolor = '#ddffdd'
class AngrColorEntry(NodeAnnotator):
def __init__(self):
super(AngrColorEntry, self).__init__()
def annotate_node(self, node):
if not node.obj.is_simprocedure:
if hasattr(node.obj, 'function_address') and node.obj.addr == node.obj.function_address:
node.style = 'filled'
node.fillcolor = '#ffffcc'
class AngrColorEdgesVex(EdgeAnnotator):
EDGECOLOR_CONDITIONAL_TRUE = 'green'
EDGECOLOR_CONDITIONAL_FALSE = 'red'
EDGECOLOR_UNCONDITIONAL = 'blue'
EDGECOLOR_CALL = 'black'
EDGECOLOR_RET = 'grey'
EDGECOLOR_UNKNOWN = 'yellow'
def __init__(self):
super(AngrColorEdgesVex, self).__init__()
def annotate_edge(self, edge):
vex = None
if 'vex' in edge.src.content:
vex = edge.src.content['vex']['vex']
if 'jumpkind' in edge.meta:
jk = edge.meta['jumpkind']
if jk == 'Ijk_Ret':
edge.color = self.EDGECOLOR_RET
elif jk == 'Ijk_FakeRet':
edge.color = self.EDGECOLOR_RET
edge.style = 'dashed'
elif jk == 'Ijk_Call':
edge.color = self.EDGECOLOR_CALL
if len (vex.next.constants) == 1 and vex.next.constants[0].value != edge.dst.obj.addr:
edge.style='dotted'
elif jk == 'Ijk_Boring':
if len(vex.constant_jump_targets) > 1:
if len (vex.next.constants) == 1:
if edge.dst.obj.addr == vex.next.constants[0].value:
edge.color=self.EDGECOLOR_CONDITIONAL_FALSE
else:
edge.color=self.EDGECOLOR_CONDITIONAL_TRUE
else:
edge.color=self.EDGECOLOR_UNKNOWN
else:
edge.color=self.EDGECOLOR_UNCONDITIONAL
else:
#TODO warning
edge.color = self.EDGECOLOR_UNKNOWN
class AngrPathAnnotator(EdgeAnnotator, NodeAnnotator):
def __init__(self, path):
super(AngrPathAnnotator, self).__init__()
self.path = path
self.trace = list(path.addr_trace)
def set_graph(self, graph):
super(AngrPathAnnotator, self).set_graph(graph)
self.vaddr = self.valid_addrs()
ftrace = filter(lambda _: _ in self.vaddr, self.trace)
self.edges_hit = set(zip(ftrace[:-1], ftrace[1:]))
def valid_addrs(self):
vaddr = set()
for n in self.graph.nodes:
vaddr.add(n.obj.addr)
return vaddr
#TODO add caching
#TODO not sure if this is valid
def node_hit(self, node):
ck = list(node.callstack_key)
ck.append(node.addr)
rtrace = list(reversed(self.trace))
found = True
si = 0
for c in reversed(ck):
if c == None:
break
try:
si = rtrace[si:].index(c)
except:
found = False
break
return found
def annotate_edge(self, edge):
key = (edge.src.obj.addr, edge.dst.obj.addr)
if key in self.edges_hit:
edge.width = 3
def annotate_node(self, node):
if self.node_hit(node.obj):
node.width = 3
class AngrBackwardSliceAnnotatorVex(ContentAnnotator):
def __init__(self, bs):
super(AngrBackwardSliceAnnotatorVex, self).__init__('vex')
self.bs = bs
self.targets = set(self.bs._targets)
def register(self, content):
content.add_column_before('taint')
def annotate_content(self, node, content):
if node.obj.is_simprocedure or node.obj.is_syscall:
return
st = self.bs.chosen_statements[node.obj.addr]
for k in range(len(content['data'])):
c = content['data'][k]
if k in st:
c['addr']['style'] = 'B'
c['statement']['style'] = 'B'
c['taint'] = {
'content':'[*]',
'style':'B'
}
if (node.obj, k) in self.targets:
c['addr']['color'] = 'red'
c['statement']['color'] = 'red'
class AngrBackwardSliceAnnotatorAsm(ContentAnnotator):
def __init__(self, bs):
super(AngrBackwardSliceAnnotatorAsm, self).__init__('asm')
self.bs = bs
self.targets = set(self.bs._targets)
def register(self, content):
content.add_column_before('taint')
def annotate_content(self, node, content):
if node.obj.is_simprocedure or node.obj.is_syscall:
return
st = self.bs.chosen_statements[node.obj.addr]
staddr = set()
#TODO
vex = self.bs.project.factory.block(addr=node.obj.addr, max_size=node.obj.size).vex
caddr = None
for j, s in enumerate(vex.statements):
if isinstance(s, pyvex.stmt.IMark):
caddr = s.addr
if j in st:
staddr.add(caddr)
for c in content['data']:
if c['_addr'] in staddr:
c['addr']['style'] = 'B'
c['mnemonic']['style'] = 'B'
c['operands']['style'] = 'B'
c['taint'] = {
'content':'[*]',
'style':'B'
}
class AngrColorDDGStmtEdges(EdgeAnnotator):
def __init__(self,project=None):
super(AngrColorDDGStmtEdges, self).__init__()
self.project = project
def annotate_edge(self, edge):
if 'type' in edge.meta:
if edge.meta['type'] == 'tmp':
edge.color = 'blue'
edge.label = 't'+ str(edge.meta['data'])
elif edge.meta['type'] == 'reg':
edge.color = 'green'
if self.project:
edge.label = self.project.arch.register_names[edge.meta['data'].reg] + " " + str(edge.meta['data'].size)
else:
edge.label = "reg"+str(edge.meta['data'].reg) + " " + str(edge.meta['data'].size)
elif edge.meta['type'] == 'mem':
edge.color = 'red'
edge.label = str(edge.meta['data'])
else:
edge.label = edge.meta['type']
edge.style = 'dotted'
class AngrColorDDGData(EdgeAnnotator, NodeAnnotator):
def __init__(self,project=None, labels=False):
super(AngrColorDDGData, self).__init__()
self.project = project
self.labels = labels
def annotate_edge(self, edge):
if 'type' in edge.meta:
if edge.meta['type'] == 'kill':
edge.color = 'red'
elif edge.meta['type'] == 'mem_addr':
edge.color = 'blue'
edge.style = 'dotted'
elif edge.meta['type'] == 'mem_data':
edge.color = 'blue'
else:
edge.color = 'yellow'
if self.labels:
edge.label = edge.meta['type']
def annotate_node(self, node):
if node.obj.initial:
node.fillcolor = '#ccffcc'
node.style = 'filled'
class AngrActionAnnotatorVex(ContentAnnotator):
def __init__(self):
super(AngrActionAnnotatorVex, self).__init__('vex')
def register(self, content):
content.add_column_after('action_type')
content.add_column_after('action_addr')
content.add_column_after('action_data')
def annotate_content(self, node, content):
from simuvex.s_action import SimActionData
if node.obj.is_simprocedure or node.obj.is_syscall:
return
if len(node.obj.final_states) > 0:
state = node.obj.final_states[0]
for action in state.log.actions:
if isinstance(action, SimActionData):
c = content['data'][action.stmt_idx]
c['action_type'] = {
'content': action.type+"/"+action.action+"("+str(action.size.ast)+")",
'align': 'LEFT'
}
#TODO
if str(action.addr) != 'None':
c['action_addr'] = {
'content': str(action.addr.ast),
'align': 'LEFT'
}
if str(action.data) != 'None':
c['action_data'] = {
'content': str(action.data.ast),
'align': 'LEFT'
}
#EXPERIMENTAL
class AngrCodelocLogAnnotator(ContentAnnotator):
def __init__(self, cllog):
super(AngrCodelocLogAnnotator, self).__init__('vex')
self.cllog = cllog
def register(self, content):
content.add_column_after('log')
def annotate_content(self, node, content):
if node.obj.is_simprocedure or node.obj.is_syscall:
return
for k in range(len(content['data'])):
c = content['data'][k]
key = (node.obj.addr, k)
if key in self.cllog:
c['log'] = {
'content': self.cllog[key],
'align':'LEFT'
}
| [
"axt@load.hu"
] | axt@load.hu |
aae4fe954783bb2351c32680008744a147445fac | 2aa45e68f6ad580e3e19139b5df88ca53f7f275a | /CreateLabelPermutation.py | 2c414faf42b6bf41b2502065a4f607dd3815455e | [
"MIT"
] | permissive | GISU2KM/GraphLearning | a97d80474137f8bac68e3005132ae0265a51600b | c7cdb71982463297f26635e92b6b27cefdc0b47f | refs/heads/master | 2022-12-23T06:14:17.137655 | 2020-10-09T03:06:51 | 2020-10-09T03:06:51 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,372 | py | import graphlearning as gl
import numpy as np
import sys, getopt
import os.path as path
def print_help():
print('=======================================================')
print('GraphLearning: Python package for graph-based learning.')
print('=======================================================')
print('=======================================================')
print('Create Label Permutation')
print('=======================================================')
print(' ')
print('Options:')
print(' -d (--dataset=): MNIST, FashionMNIST,...more soon (default=MNIST)')
print(' -m (--NumLabels=): Number of labels per class for each trial (default=1,2,3,4,5)')
print(' -t (--NumTrials=): Number of trials (default=100)')
print(' -n (--name=): Permutation name in form dataset<name>_permutations.npz (default is empty)')
print(' -s (--multiplier=): List of multipliers for each class, to produce unbalanced experiments (default is balanced 1,1,1,1,1)')
print(' -o (--overwrite=): Overwrite existing file.')
#Default settings
dataset = 'MNIST'
m = '1,2,3,4,5'
multiplier = None
t = 100
name = ''
overwrite = False
#Read command line arguments
try:
opts, args = getopt.getopt(sys.argv[1:],"hd:m:t:n:s:o",["dataset=","NumLabels=","NumTrials=","name=","multiplier=","overwrite"])
except getopt.GetoptError:
print_help()
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print_help()
sys.exit()
elif opt in ("-d", "--dataset"):
dataset = arg
elif opt in ("-m", "--NumLabels"):
m = arg
elif opt in ("-t", "--NumTrials"):
t = int(arg)
elif opt in ("-s", "--multiplier"):
multiplier = arg
multiplier = [float(e) for e in multiplier.split(',')]
elif opt in ("-n", "--name"):
name = arg
elif opt in ("-o", "--overwrite"):
overwrite = True
outfile = "LabelPermutations/"+dataset+name+"_permutations.npz"
#Print basic info
print('=======================================================')
print('GraphLearning: Python package for graph-based learning.')
print('=======================================================')
print('=======================================================')
print('Compute Label Permutations')
print('=======================================================')
print(' ')
print('Dataset: '+dataset)
print('Number of Labels per trial: '+m)
print('Number of Trials: %d'%t)
print('Output file: '+outfile)
print(' ')
print('=======================================================')
print(' ')
#Load labels
try:
M = np.load("Data/"+dataset+"_labels.npz",allow_pickle=True)
except:
print('Cannot find dataset Data/'+dataset+'_labels.npz')
sys.exit(2)
#Extract labels
labels = M['labels']
#Convert string to int list
m = [int(e) for e in m.split(',')]
#Create label permutations
perm = gl.create_label_permutations(labels,t,m,multiplier)
#Save weight matrix to file
if path.isfile(outfile) and not overwrite:
print('Output file: '+outfile+' already exists. Aborting...')
sys.exit(2)
else:
np.savez_compressed(outfile,perm=perm)
| [
"noreply@github.com"
] | GISU2KM.noreply@github.com |
beac6bfdd31b5bcf3da0c1b5ef8b6693220e0f26 | 4c43932dbfef8603c4414d88ab98dda1b9e163b8 | /mix_id_increment.py | 9c01c2ac8b59995266508b1b6262300c28c6f4a1 | [] | no_license | edison12347/usefull_code | 7ffe030422edf72fd668b3d3adcecaa57a8a3490 | 4d41e397e21620ec20a1c8da936771f62f46ea39 | refs/heads/master | 2021-10-12T03:18:49.593399 | 2019-02-01T08:17:16 | 2019-02-01T08:17:16 | 103,551,930 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,279 | py | stmt = text("SELECT ListID FROM {} ORDER BY ListID DESC LIMIT 1".format(table))
select_last_list_id = connect.execute(stmt)
last_list_id = select_last_list_id.fetchone()[0]
prefix, _ = last_list_id.split('-')
incremented_prefix = copy.copy(prefix)
incrementation_list = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
rotated_prefix = ''.join([prefix[-i] for i in range(1, len(prefix))]) + prefix[0]
for position, symbol in enumerate(rotated_prefix):
tail_position = len(prefix) - 1 - position
if symbol != 'Z':
next_index = incrementation_list.index(symbol) + 1
next_symbol = incrementation_list[next_index]
incremented_prefix_list = [letter for letter in incremented_prefix]
incremented_prefix_list[tail_position] = next_symbol
incremented_prefix = ''.join(incremented_prefix_list)
break
else:
incremented_prefix_list = [letter for letter in incremented_prefix]
incremented_prefix_list[tail_position] = '0'
incremented_prefix = ''.join(incremented_prefix_list)
list_id = incremented_prefix + '-' + str(random.randint(1000000000, 9999999999)) | [
"noreply@github.com"
] | edison12347.noreply@github.com |
9829e741774cc716fa4e10fe0dbf778cbe079821 | 041122bdc412b8c311eeb68c9aa3a4bac5249145 | /crawlers/socials/pikabu.ru.py | e379ddf762d7da5e13301e9290f60243cab37d14 | [
"Apache-2.0"
] | permissive | fostroll/ru_corner | 5df269ab88bddf9d02f8c6967a063cb9b0b56515 | defb681aa9311c2dd6ed98d1b934453c29e9a750 | refs/heads/master | 2023-06-23T18:38:34.218504 | 2021-07-27T12:16:51 | 2021-07-27T12:16:51 | 314,045,739 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 12,196 | py | #!/usr/bin/python -u
#-*- encoding: utf-8 -*-
from collections import OrderedDict
import json
import os
import random
import re
import time
###
import sys
sys.path.append('../')
###
import utils
import _utils
SEED = 42
ROOT_URL = 'https://pikabu.ru'
INIT_URL = ROOT_URL + '/new?twitmode=1&of=v2&page={}&_={}'
HEADERS = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:84.0) Gecko/20100101 Firefox/84.0',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
'Accept-Language': 'en-US,en;q=0.5',
'Accept-Encoding': 'gzip, deflate, br',
'Connection': 'keep-alive',
'Upgrade-Insecure-Requests': '1',
'TE': 'Trailers'
}
AUTHORS_IGNORE_FN = os.path.join(utils.PAGES_DIR, 'authors_ignore')
POSTS_IGNORE_FN = os.path.join(utils.PAGES_DIR, 'posts_ignore')
MAX_FILES = 10000
MIN_DEPTH = 4
SKIP_FIRST = 100
SILENT = False
if SEED:
random.seed(SEED)
'''===========================================================================
Texts download and parse
==========================================================================='''
page_fns = utils.get_file_list(utils.PAGES_DIR, MAX_FILES)
if len(page_fns) < utils.TEXTS_FOR_SOURCE:
need_enter = False
texts_total = 0
re0 = re.compile(r'\W|\d')
re1 = re.compile(r'[^ЁА-Яёа-я]')
re2 = re.compile(r'[^\S\n]+')
re3 = re.compile(r'\n+')
re4 = re.compile(r'#\b\S+\b')
re5 = re.compile(r'\W')
re6 = re.compile(r'[a-z]+://\S+')
re7 = re.compile(r'<p>((?:.|\n)*?)</p>')
re8 = re.compile(r'<blockquote(?:.|\n)+?</blockquote>')
re9 = re.compile(r'<figure(?:.|\n)+?</figure>')
re10 = re.compile(r'<(?:.|\n)*?>')
re11 = re.compile(r'#comment_\d+$')
def parse_comments(comments, header, authors_ignore):
res, lines, authors = False, [], {}
for comment, author in comments:
if authors_ignore and author in authors_ignore:
break
authors[author] = author
line = re7.sub(r'\n\g<1>\n', comment)
line = line.replace('<br>', '\n').replace('<hr>', '\n')
line = re10.sub('', re9.sub('', re8.sub('', line)))
line = re2.sub(' ', re3.sub('\n', utils.norm_text2(line)))
if not line or line.startswith('Комментарий удален.') \
or re11.match(line):
break
lines.append((line, author))
text = None
while True:
if len(lines) < MIN_DEPTH:
break
text_ = '\n'.join(x[0] for x in lines)
text = '\n'.join(x[1] + '\t' + x[0].replace('\n', '\n\t') \
for x in lines)
if not SILENT:
print(text)
text_ = re6.sub('', text_)
text0 = re0.sub('', text_)
text1 = re1.sub('', text0)
if text0 and len(text1) / len(text0) >= .9:
num_words = len([x for x in re4.sub('', text_).split()
if re5.sub('', x)])
if not SILENT:
print('<russian>')
print(num_words)
if num_words < _utils.MIN_CHUNK_WORDS:
break
if num_words > _utils.MAX_CHUNK_WORDS:
lines = lines[:-1]
continue
res = True
break
elif not SILENT:
print('<foreign>')
lines = lines[:-1]
continue
if res:
page_fn = utils.get_data_path(utils.PAGES_DIR, MAX_FILES,
texts_total)
text_fn = utils.get_data_path(utils.TEXTS_DIR, MAX_FILES,
texts_total)
with open(page_fn, 'wt', encoding='utf-8') as f:
print(header, file=f)
json.dump(comments, f, indent=4, ensure_ascii=False)
with open(text_fn, 'wt', encoding='utf-8') as f:
print('{} ({})'.format(texts_total, header), file=f)
f.write(text)
if authors_ignore is not None:
need_enter = os.path.isfile(AUTHORS_IGNORE_FN)
with open(AUTHORS_IGNORE_FN, 'at', encoding='utf-8') as f:
if need_enter:
print(file=f)
f.write('\n'.join('\t'.join(x) for x in authors.items()))
authors_ignore.update(authors)
print('\r{} (of {})'.format(texts_total, utils.TEXTS_FOR_SOURCE),
end='')
return res
for texts_total, page_fn in enumerate(page_fns, start=1):
if os.path.isfile(page_fn.replace(utils.PAGES_DIR, utils.TEXTS_DIR)):
continue
with open(page_fn, 'rt', encoding='utf-8') as f:
header = f.readline().strip()
comments = json.load(f)
parse_comments(comments, header, None)
texts_total += 1
if os.path.isfile(AUTHORS_IGNORE_FN):
with open(AUTHORS_IGNORE_FN, 'rt', encoding='utf-8') as f:
authors_ignore = OrderedDict(x.split('\t')
for x in f.read().split('\n')
if x)
else:
authors_ignore = OrderedDict()
if os.path.isfile(POSTS_IGNORE_FN):
with open(POSTS_IGNORE_FN, 'rt', encoding='utf-8') as f:
posts_ignore = set(x for x in f.read().split('\n') if x)
else:
posts_ignore = set()
url, last_success_url = None, None
retry = False
try:
page_no = SKIP_FIRST
while True:
page_no += 1
url = INIT_URL.format(page_no, time.time_ns() // 1000000)
if not SILENT:
print(url)
res = utils.get_url(url, headers=HEADERS)
res = res.json()
#with open('000.json', 'wt', encoding='utf-8') as f:
# from pprint import pprint
# pprint(res, stream=f)
#exit()
data = res['data']['stories']
for post in data:
post, post_id = post['html'], post['id']
if post_id in posts_ignore:
print('WARNING: Post was already processed. Skipping')
continue
match = re.search(
'<span class="story__comments-link-count">(\d+)</span>',
post
)
if not match:
print('WARNING: Number of comments is not found')
continue
last_success_url = url
num_comments = int(match.group(1))
if num_comments < 12:
continue
match = re.search(
'href="({}/story/\S+?_{})#comments">' \
.format(ROOT_URL, post_id),
post
)
if not match:
print('WARNING: Link to comments is not found')
continue
url = match.group(1)
res = utils.get_url(url, headers=HEADERS)
res = res.text
#with open('111.html', 'wt', encoding='utf-8') as f:
# print(res, file=f)
#exit()
pos = res.find(
'<div class="comments__container_main comments__container" data-story-id="{}">'
.format(post_id)
)
if pos < 0:
print('ERROR: Invalid format')
with open('error.log', 'wt', encoding='utf-8') as f:
print(url, file=f)
print(res, file=f)
assert 0
def store_post_id(post_id):
posts_ignore.add(post_id)
with open(POSTS_IGNORE_FN, 'at',
encoding='utf-8') as f:
print(post_id, file=f)
if texts_total > utils.TEXTS_FOR_SOURCE:
raise OverflowError()
comments, num_comments = [], 0
inprogress = False
while True:
res = res[pos:]
pos = res.find('<div class="comment"')
if pos < 0:
if inprogress and num_comments >= MIN_DEPTH \
and parse_comments(comments, url,
authors_ignore):
texts_total += 1
need_enter = True
store_post_id(post_id)
break
res = res[pos:]
token = 'data-indent="'
pos = res.find(token)
res = res[pos + len(token):]
pos = res.find('"')
depth = int(res[:pos])
if depth == 0:
inprogress = True
if inprogress and depth < num_comments \
and num_comments >= MIN_DEPTH \
and parse_comments(comments, url,
authors_ignore):
texts_total += 1
need_enter = True
store_post_id(post_id)
inprogress = False
if inprogress:
token = '<div class="comment__user"'
pos = res.find(token)
author = res[pos + len(token):]
token = 'data-name="'
pos = author.find(token)
author = author[pos + len(token):]
pos = author.find('"')
author = author[:pos]
token = '<div class="comment__content">'
pos = res.find(token)
comment = res[pos + len(token):]
pos = comment.find('<div class="comment__controls')
comment = comment[:pos].rstrip()
for token in ['<!--noindex-->', '</div>']:
if not comment.endswith(token):
print('ERROR: Invalid format')
with open('error.log', 'wt',
encoding='utf-8') as f:
print(url, file=f)
print(comment, file=f)
print(file=f)
print(res, file=f)
assert 0
comment = comment[:-len(token)].strip()
comments[depth:] = [(comment, author)]
num_comments = depth
with open('error.log', 'wt',
encoding='utf-8') as f:
print('NO POSTS. Last success url:', file=f)
print(last_success_url, file=f)
assert 0
except OverflowError:
pass
if need_enter:
print()
if os.path.isfile(utils.get_data_path(utils.CHUNKS_DIR, MAX_FILES, 1)):
print('WARNING: Chunks are already exist. '
'Delete them if you want to recreate')
exit()
page_fns = utils.get_file_list(utils.PAGES_DIR, MAX_FILES)
text_fns = utils.get_file_list(utils.TEXTS_DIR, MAX_FILES)
assert len(page_fns) == len(text_fns)
#new_order = utils.shuffle_file_list(page_fns)
utils.shuffle_file_list(text_fns, new_order=None)
'''===========================================================================
Chunks creation
==========================================================================='''
_utils.make_chunks(MAX_FILES)
'''===========================================================================
Tokenization
==========================================================================='''
utils.tokenize(MAX_FILES, isdialog=True)
| [
"fostroll@gmail.com"
] | fostroll@gmail.com |
08875ef94e180b533919903f03a36659ac43e79f | fee1678e11e413049604eb1c4f087e1dff6b16b5 | /read_and_write_to_file_functions.py | c33664c199340a0817e61c83387643355fc05d76 | [] | no_license | scttohara/python_card_game | 037c5bd58c1dfff34ef027287865500421c8b4e8 | bfb577ad14c3627dd38b8a4f3d66e09877bdb079 | refs/heads/master | 2020-12-10T22:29:50.395039 | 2020-09-27T04:56:05 | 2020-09-27T04:56:05 | 233,729,633 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,772 | py | import csv
import animals_list
def get_animal_names():
"""
@return: animals_list
@rtype: list of lists
"""
# try catch for opening and reader from animal name file
animals_list_of_lists = []
try:
with open('animal_names.txt', newline='\n') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
for row in csv_reader:
animals_list_of_lists.append(row)
csv_file.close()
except PermissionError:
print('\nALERT:\nCannot open file for reading')
print('File might be open in another program.')
print('The default list of animals will be used\n')
pass
except FileNotFoundError:
print('\nALERT:\nCheck that the animal_names.txt file exist in the folder this game is in')
print('The default list of animals will be used\n')
pass
except FileExistsError:
print('\nALERT:\nIssue with reading in animal names from external file. Will use default list\n')
pass
# checks that the list has all the animals if not the animals list is set to a
# pre-existing list
try:
if int(animals_list_of_lists[19][0]) != 10:
raise IndexError
except IndexError:
animals_list_of_lists = animals_list.animals_list_function()
return animals_list_of_lists
# noinspection PyUnboundLocalVariable,PyUnboundLocalVariable,PyUnboundLocalVariable
def get_game_results_record(path_choice=1):
"""
try catch for opening and reader from animal name file
@param path_choice: 1 if user wants to attempt to load past records. 2 if they want to start with new records
@type path_choice: int
@return: list of records, player1's record, player2's record, and the draw record
@rtype: tuple
"""
records_list_of_lists = []
if path_choice == 1: # loads from saved results
try:
with open('results_record.txt', newline='\n') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
for row in csv_reader:
# print(row)
records_list_of_lists.append(row)
# print(animals_list_of_list[19][0])
csv_file.close()
except PermissionError:
print('\nALERT:\nCannot open file for reading')
print('File might be open in another program.\n')
print('Past records will be set to zero for this session\n')
pass
except FileNotFoundError:
print('\nALERT:\nCheck that the results_record.txt file exist in the folder this game is in')
print('Past records will be set to zero for this session\n')
pass
except FileExistsError:
print('\nALERT:\nCheck that the results_record.txt file exist in the folder this game is in')
print('Past records will be set to zero for this session\n')
pass
if path_choice == 1 or path_choice == 2: # checks results load or sets results to 0 depending on situation
# makes sure something is in records_list_of_lists when it is returned
try:
player1 = int(records_list_of_lists[-3][1])
player2 = int(records_list_of_lists[-2][1])
draws = int(records_list_of_lists[-1][1])
except IndexError:
player1 = 0
player2 = 0
draws = 0
records_list_of_lists.append(['player1', str(player1)])
records_list_of_lists.append(['player2', str(player2)])
records_list_of_lists.append(['draws', str(draws)])
return records_list_of_lists, player1, player2, draws
def write_game_results_record_to_file(results_record, player1, player2, draws):
"""
try catch for opening and reader from animal name file.
@param results_record: holds records
@type results_record: list
@param player1: count of player1 wins
@type player1: int
@param player2: count of player2 wins
@type player2: int
@param draws: count of draws
@type draws: int
@return: none
@rtype: none
"""
try:
results_record.append(['player1', str(player1)])
results_record.append(['player2', str(player2)])
results_record.append(['draws', str(draws)])
csv_file = open('results_record.txt', 'a', newline='\n')
csv_writer = csv.writer(csv_file)
count = -3
while count < 0:
line_to_write = [results_record[count][0], results_record[count][1]]
csv_writer.writerow(line_to_write)
count += 1
csv_file.close()
except PermissionError:
print('Cannot open file for writing')
print('File might be open in another program.')
| [
"noreply@github.com"
] | scttohara.noreply@github.com |
d6655f4db0445ea8000cfd7c7f697c12e129b47d | b99b57dad607408d4e39423a60654bd9927fbbfe | /2017/15.py | b6021cfa5914f0d3971a60a65b23b82385a8630e | [] | no_license | fbrizu/AdventOfCode | 1ef00bae110e1dc0add4477ba0ecabfcb1cb1dfb | 6978b8bab6ee77260f208008c43565a780375af2 | refs/heads/master | 2020-11-29T16:20:28.866599 | 2019-12-31T04:16:06 | 2019-12-31T04:16:06 | 230,165,982 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 665 | py | def p1():
f1 = 16807
f2 = 48271
g1 = 703
g2 = 516
count = 0
for _ in range(40000000):
g1 = g1 * f1 % 2147483647
g2 = g2 * f2 % 2147483647
if g1%65536 == g2%65536:
count += 1
print(count)
def p2():
f1 = 16807
f2 = 48271
g1 = 703
g2 = 516
count = 0
for _ in range(5000000):
t1 = True
t2 = True
while t1 or g1%4 != 0:
g1 = g1 * f1 % 2147483647
t1 = False
while t2 or g2%8 != 0:
g2 = g2 * f2 % 2147483647
t2 = False
if g1%65536 == g2%65536:
count += 1
print(count)
p1()
p2() | [
"frank.brizuela@mail.mcgill.ca"
] | frank.brizuela@mail.mcgill.ca |
e168407eb15bcececca9947e72682be0c3429267 | 47596e586b3e21b31cf360be7cd1c7d3a5dc6163 | /Google/trafficSnapshot.py | 2dd2859f31fd1a85b4610e8d672e415ce5a7e784 | [] | no_license | jasonlingo/RoadSafety | bfef06abe0668a9cb8ead5b183008a53eabdefa2 | b20af54b915daf7635204e3b942b3ae4624887d7 | refs/heads/master | 2021-03-19T13:51:13.736277 | 2015-09-17T03:49:43 | 2015-09-17T03:49:43 | 36,019,601 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,140 | py | import sys
import os
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from GPS.GPSPoint import GPSPoint
from File.Directory import createDirectory
import webbrowser
from Google.findTimeZone import findTimeZone
from time import sleep
from PIL import Image
import datetime, pytz
from config import TRAFFIC_IMAGE_DIRECTORY
def trafficSnapshot(gpsPoint, numOfShot, interval, size):
"""
Capture traffic snapshots periodically using Google MAP traffic and store those images
Args:
(GPSPoint) gpsPoint: the center of the map from which we capture traffic images
(int) numOfShot: the total number of images that are going to captured
(int) interval: the interval (in seconds) between two captured images
(int) size: the size of the map (from 3(big) to 21(detail))
"""
# Create Google MAP with traffic info request url
url = "https://www.google.com/maps/@"
gps = str(gpsPoint.lat) + ',' + str(gpsPoint.lng)
# The scale of the map.
size = str(size) + "z"
# Street view parameter.
traffic_param = "/data=!5m1!1e1"
# Combine request url
url = url + gps + "," + size + traffic_param
# Create the output directory if it doesn't exist.
createDirectory(TRAFFIC_IMAGE_DIRECTORY)
for i in range(numOfShot):
# Open the Google MAP street view on a web browser.
webbrowser.open(url)
# Wait for the page opens
sleep(5)
# Get the current time of the location
timezone, current_time = findTimeZone(gpsPoint)
imgName = TRAFFIC_IMAGE_DIRECTORY + "traffic-" + current_time + ".png"
command = "screencapture " + imgName
# Screen shot
os.system(command)
im = Image.open(imgName)
# Get captured image size
width, height = im.size
# Crop the captured area, need to be customized depending on different computer
im.crop((500, 350, width-300, height-30)).save(imgName)
print imgName + " captured!"
# Program sleeps for the interval time
sleep(interval)
| [
"jasonlingo@gmail.com"
] | jasonlingo@gmail.com |
c45f75d35e6c01f5b2a81a8d4f19fa45c755bca5 | 38acc071960622ab7923435fa085f2efaebe2144 | /pyemm/annular_sdd.py | a2f594249fef7befda94c050059d6d753ccd29b0 | [
"Apache-2.0"
] | permissive | drix00/pyelectronmicroscopymodeling | 72db4b7589d5cb9da0412e7bf7b847705412dc42 | 6a6d3bd174a8d6092332b59cae55c6b71dbba6d9 | refs/heads/master | 2022-11-02T15:59:34.744539 | 2020-06-18T00:12:59 | 2020-06-18T00:12:59 | 105,061,500 | 0 | 0 | Apache-2.0 | 2020-06-18T00:00:44 | 2017-09-27T19:40:10 | Python | UTF-8 | Python | false | false | 1,451 | py | #!/usr/bin/env python
"""
.. py:currentmodule:: annular_sdd
.. moduleauthor:: Hendrix Demers <hendrix.demers@mail.mcgill.ca>
Modeling of the McGill annular SDD.
"""
# Script information for the file.
__author__ = "Hendrix Demers (hendrix.demers@mail.mcgill.ca)"
__version__ = "0.1"
__date__ = "Apr 14, 2015"
__copyright__ = "Copyright (c) 2015 Hendrix Demers"
__license__ = "GPL 3"
# Standard library modules.
import logging
# Third party modules.
from xraylib import KL3_LINE
# Local modules.
# Project modules
from pyemm.montecarlo.xray_engine import create_xray_detector
from pyemm.montecarlo.xray import CharacteristicXRay
# Globals and constants variables.
def run():
number_photons = 200
xray_atomic_numbers = [5, 6, 7, 8, 14]
for xray_atomic_numbers in xray_atomic_numbers:
logging.info("Simulating %i", xray_atomic_numbers)
engine = create_xray_detector()
for photon_ID in range(number_photons):
logging.info("photon ID %i", photon_ID)
xray = CharacteristicXRay(xray_atomic_numbers, KL3_LINE, direction=(0, 0, -1))
engine.simulate(xray)
print("Backscattered: %.4f" % engine.getBackscatteredCoefficient())
print("Absorbed: %.4f" % engine.getAbsorbedCoefficient())
print("Transmitted: %.4f" % engine.getTranmittedCoefficient())
if __name__ == '__main__': #pragma: no cover
run() | [
"12611589+drix00@users.noreply.github.com"
] | 12611589+drix00@users.noreply.github.com |
769fe78fbed72ed38ddaaf8886043f57213b6e36 | a687ba436b2b4926cde9fa327e3c932c3442ae1f | /models/official/transformer/transformer_main.py | b9543ee9c49f6fe691eb9364cf9d8901059f6fad | [
"Apache-2.0"
] | permissive | youlingwangzi/TensorFlow | 1bf4e5a9ac5c9eeaa4510c3dad71ac18dc473ecf | b7dd462d553d868dfe446b3d6d467935333647d3 | refs/heads/master | 2022-12-22T09:43:44.069358 | 2018-07-18T16:41:41 | 2018-07-18T16:41:41 | 136,822,259 | 5 | 1 | Apache-2.0 | 2022-12-17T14:25:20 | 2018-06-10T15:46:30 | Python | UTF-8 | Python | false | false | 23,341 | py | # Copyright 2018 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Train and evaluate the Transformer model.
See README for description of setting the training schedule and evaluating the
BLEU score.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import functools
import os
import tempfile
# pylint: disable=g-bad-import-order
from six.moves import xrange # pylint: disable=redefined-builtin
from absl import app as absl_app
from absl import flags
import tensorflow as tf
# pylint: enable=g-bad-import-order
from official.transformer import compute_bleu
from official.transformer import translate
from official.transformer.data_download import VOCAB_FILE
from official.transformer.model import model_params
from official.transformer.model import transformer
from official.transformer.utils import dataset
from official.transformer.utils import metrics
from official.transformer.utils import schedule
from official.transformer.utils import tokenizer
from official.utils.accelerator import tpu as tpu_util
from official.utils.flags import core as flags_core
from official.utils.logs import hooks_helper
from official.utils.logs import logger
from official.utils.misc import model_helpers
PARAMS_MAP = {
"tiny": model_params.TINY_PARAMS,
"base": model_params.BASE_PARAMS,
"big": model_params.BIG_PARAMS,
}
DEFAULT_TRAIN_EPOCHS = 10
BLEU_DIR = "bleu"
INF = int(1e9)
# Dictionary containing tensors that are logged by the logging hooks. Each item
# maps a string to the tensor name.
TENSORS_TO_LOG = {
"learning_rate": "model/get_train_op/learning_rate/learning_rate",
"cross_entropy_loss": "model/cross_entropy"}
def model_fn(features, labels, mode, params):
"""Defines how to train, evaluate and predict from the transformer model."""
with tf.variable_scope("model"):
inputs, targets = features, labels
# Create model and get output logits.
model = transformer.Transformer(params, mode == tf.estimator.ModeKeys.TRAIN)
logits = model(inputs, targets)
# When in prediction mode, the labels/targets is None. The model output
# is the prediction
if mode == tf.estimator.ModeKeys.PREDICT:
if params["use_tpu"]:
raise NotImplementedError("Prediction is not yet supported on TPUs.")
return tf.estimator.EstimatorSpec(
tf.estimator.ModeKeys.PREDICT,
predictions=logits)
# Explicitly set the shape of the logits for XLA (TPU). This is needed
# because the logits are passed back to the host VM CPU for metric
# evaluation, and the shape of [?, ?, vocab_size] is too vague. However
# it is known from Transformer that the first two dimensions of logits
# are the dimensions of targets. Note that the ambiguous shape of logits is
# not a problem when computing xentropy, because padded_cross_entropy_loss
# resolves the shape on the TPU.
logits.set_shape(targets.shape.as_list() + logits.shape.as_list()[2:])
# Calculate model loss.
# xentropy contains the cross entropy loss of every nonpadding token in the
# targets.
xentropy, weights = metrics.padded_cross_entropy_loss(
logits, targets, params["label_smoothing"], params["vocab_size"])
loss = tf.reduce_sum(xentropy) / tf.reduce_sum(weights)
# Save loss as named tensor that will be logged with the logging hook.
tf.identity(loss, "cross_entropy")
if mode == tf.estimator.ModeKeys.EVAL:
if params["use_tpu"]:
# host call functions should only have tensors as arguments.
# functools.partial() pre-populates params so that metric_fn is
# TPUEstimator compliant.
metric_fn = functools.partial(metrics.get_eval_metrics, params=params)
eval_metrics = (metric_fn, [logits, labels])
return tf.contrib.tpu.TPUEstimatorSpec(
mode=mode, loss=loss, predictions={"predictions": logits},
eval_metrics=eval_metrics)
return tf.estimator.EstimatorSpec(
mode=mode, loss=loss, predictions={"predictions": logits},
eval_metric_ops=metrics.get_eval_metrics(logits, labels, params))
else:
train_op, metric_dict = get_train_op_and_metrics(loss, params)
# Epochs can be quite long. This gives some intermediate information
# in TensorBoard.
metric_dict["minibatch_loss"] = loss
if params["use_tpu"]:
return tf.contrib.tpu.TPUEstimatorSpec(
mode=mode, loss=loss, train_op=train_op,
host_call=tpu_util.construct_scalar_host_call(
metric_dict=metric_dict, model_dir=params["model_dir"],
prefix="training/")
)
record_scalars(metric_dict)
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)
def record_scalars(metric_dict):
for key, value in metric_dict.items():
tf.contrib.summary.scalar(name=key, tensor=value)
def get_learning_rate(learning_rate, hidden_size, learning_rate_warmup_steps):
"""Calculate learning rate with linear warmup and rsqrt decay."""
with tf.name_scope("learning_rate"):
warmup_steps = tf.to_float(learning_rate_warmup_steps)
step = tf.to_float(tf.train.get_or_create_global_step())
learning_rate *= (hidden_size ** -0.5)
# Apply linear warmup
learning_rate *= tf.minimum(1.0, step / warmup_steps)
# Apply rsqrt decay
learning_rate *= tf.rsqrt(tf.maximum(step, warmup_steps))
# Create a named tensor that will be logged using the logging hook.
# The full name includes variable and names scope. In this case, the name
# is model/get_train_op/learning_rate/learning_rate
tf.identity(learning_rate, "learning_rate")
return learning_rate
def get_train_op_and_metrics(loss, params):
"""Generate training op and metrics to save in TensorBoard."""
with tf.variable_scope("get_train_op"):
learning_rate = get_learning_rate(
learning_rate=params["learning_rate"],
hidden_size=params["hidden_size"],
learning_rate_warmup_steps=params["learning_rate_warmup_steps"])
# Create optimizer. Use LazyAdamOptimizer from TF contrib, which is faster
# than the TF core Adam optimizer.
optimizer = tf.contrib.opt.LazyAdamOptimizer(
learning_rate,
beta1=params["optimizer_adam_beta1"],
beta2=params["optimizer_adam_beta2"],
epsilon=params["optimizer_adam_epsilon"])
if params["use_tpu"] and params["tpu"] != tpu_util.LOCAL:
optimizer = tf.contrib.tpu.CrossShardOptimizer(optimizer)
# Calculate and apply gradients using LazyAdamOptimizer.
global_step = tf.train.get_global_step()
tvars = tf.trainable_variables()
gradients = optimizer.compute_gradients(
loss, tvars, colocate_gradients_with_ops=True)
train_op = optimizer.apply_gradients(
gradients, global_step=global_step, name="train")
metrics = {"learning_rate": learning_rate}
if not params["use_tpu"]:
# gradient norm is not included as a summary when running on TPU, as
# it can cause instability between the TPU and the host controller.
gradient_norm = tf.global_norm(list(zip(*gradients))[0])
metrics["global_norm/gradient_norm"] = gradient_norm
return train_op, metrics
def translate_and_compute_bleu(estimator, subtokenizer, bleu_source, bleu_ref):
"""Translate file and report the cased and uncased bleu scores."""
# Create temporary file to store translation.
tmp = tempfile.NamedTemporaryFile(delete=False)
tmp_filename = tmp.name
translate.translate_file(
estimator, subtokenizer, bleu_source, output_file=tmp_filename,
print_all_translations=False)
# Compute uncased and cased bleu scores.
uncased_score = compute_bleu.bleu_wrapper(bleu_ref, tmp_filename, False)
cased_score = compute_bleu.bleu_wrapper(bleu_ref, tmp_filename, True)
os.remove(tmp_filename)
return uncased_score, cased_score
def get_global_step(estimator):
"""Return estimator's last checkpoint."""
return int(estimator.latest_checkpoint().split("-")[-1])
def evaluate_and_log_bleu(estimator, bleu_source, bleu_ref, vocab_file_path):
"""Calculate and record the BLEU score."""
subtokenizer = tokenizer.Subtokenizer(vocab_file_path)
uncased_score, cased_score = translate_and_compute_bleu(
estimator, subtokenizer, bleu_source, bleu_ref)
tf.logging.info("Bleu score (uncased):", uncased_score)
tf.logging.info("Bleu score (cased):", cased_score)
return uncased_score, cased_score
def run_loop(
estimator, schedule_manager, train_hooks=None, benchmark_logger=None,
bleu_source=None, bleu_ref=None, bleu_threshold=None, vocab_file_path=None):
"""Train and evaluate model, and optionally compute model's BLEU score.
**Step vs. Epoch vs. Iteration**
Steps and epochs are canonical terms used in TensorFlow and general machine
learning. They are used to describe running a single process (train/eval):
- Step refers to running the process through a single or batch of examples.
- Epoch refers to running the process through an entire dataset.
E.g. training a dataset with 100 examples. The dataset is
divided into 20 batches with 5 examples per batch. A single training step
trains the model on one batch. After 20 training steps, the model will have
trained on every batch in the dataset, or, in other words, one epoch.
Meanwhile, iteration is used in this implementation to describe running
multiple processes (training and eval).
- A single iteration:
1. trains the model for a specific number of steps or epochs.
2. evaluates the model.
3. (if source and ref files are provided) compute BLEU score.
This function runs through multiple train+eval+bleu iterations.
Args:
estimator: tf.Estimator containing model to train.
schedule_manager: A schedule.Manager object to guide the run loop.
train_hooks: List of hooks to pass to the estimator during training.
benchmark_logger: a BenchmarkLogger object that logs evaluation data
bleu_source: File containing text to be translated for BLEU calculation.
bleu_ref: File containing reference translations for BLEU calculation.
bleu_threshold: minimum BLEU score before training is stopped.
vocab_file_path: Path to vocabulary file used to subtokenize bleu_source.
"""
evaluate_bleu = bleu_source is not None and bleu_ref is not None
if evaluate_bleu and schedule_manager.use_tpu:
raise ValueError("BLEU score can not be computed when training with a TPU, "
"as it requires estimator.predict which is not yet "
"supported.")
# Print details of training schedule.
tf.logging.info("Training schedule:")
tf.logging.info(
"\t1. Train for {}".format(schedule_manager.train_increment_str))
tf.logging.info("\t2. Evaluate model.")
if evaluate_bleu:
tf.logging.info("\t3. Compute BLEU score.")
if bleu_threshold is not None:
tf.logging.info("Repeat above steps until the BLEU score reaches %f" %
bleu_threshold)
if not evaluate_bleu or bleu_threshold is None:
tf.logging.info("Repeat above steps %d times." %
schedule_manager.train_eval_iterations)
if evaluate_bleu:
# Create summary writer to log bleu score (values can be displayed in
# Tensorboard).
bleu_writer = tf.summary.FileWriter(
os.path.join(estimator.model_dir, BLEU_DIR))
if bleu_threshold is not None:
# Change loop stopping condition if bleu_threshold is defined.
schedule_manager.train_eval_iterations = INF
# Loop training/evaluation/bleu cycles
for i in xrange(schedule_manager.train_eval_iterations):
tf.logging.info("Starting iteration %d" % (i + 1))
# Train the model for single_iteration_train_steps or until the input fn
# runs out of examples (if single_iteration_train_steps is None).
estimator.train(
dataset.train_input_fn,
steps=schedule_manager.single_iteration_train_steps,
hooks=train_hooks)
eval_results = estimator.evaluate(
input_fn=dataset.eval_input_fn,
steps=schedule_manager.single_iteration_eval_steps)
tf.logging.info("Evaluation results (iter %d/%d):" %
(i + 1, schedule_manager.train_eval_iterations))
tf.logging.info(eval_results)
benchmark_logger.log_evaluation_result(eval_results)
# The results from estimator.evaluate() are measured on an approximate
# translation, which utilize the target golden values provided. The actual
# bleu score must be computed using the estimator.predict() path, which
# outputs translations that are not based on golden values. The translations
# are compared to reference file to get the actual bleu score.
if evaluate_bleu:
uncased_score, cased_score = evaluate_and_log_bleu(
estimator, bleu_source, bleu_ref, vocab_file_path)
# Write actual bleu scores using summary writer and benchmark logger
global_step = get_global_step(estimator)
summary = tf.Summary(value=[
tf.Summary.Value(tag="bleu/uncased", simple_value=uncased_score),
tf.Summary.Value(tag="bleu/cased", simple_value=cased_score),
])
bleu_writer.add_summary(summary, global_step)
bleu_writer.flush()
benchmark_logger.log_metric(
"bleu_uncased", uncased_score, global_step=global_step)
benchmark_logger.log_metric(
"bleu_cased", cased_score, global_step=global_step)
# Stop training if bleu stopping threshold is met.
if model_helpers.past_stop_threshold(bleu_threshold, uncased_score):
bleu_writer.close()
break
def define_transformer_flags():
"""Add flags and flag validators for running transformer_main."""
# Add common flags (data_dir, model_dir, train_epochs, etc.).
flags_core.define_base(multi_gpu=False, num_gpu=False, export_dir=False)
flags_core.define_performance(
num_parallel_calls=True,
inter_op=False,
intra_op=False,
synthetic_data=False,
max_train_steps=False,
dtype=False
)
flags_core.define_benchmark()
flags_core.define_device(tpu=True)
# Set flags from the flags_core module as "key flags" so they're listed when
# the '-h' flag is used. Without this line, the flags defined above are
# only shown in the full `--helpful` help text.
flags.adopt_module_key_flags(flags_core)
# Add transformer-specific flags
flags.DEFINE_enum(
name="param_set", short_name="mp", default="big",
enum_values=["base", "big", "tiny"],
help=flags_core.help_wrap(
"Parameter set to use when creating and training the model. The "
"parameters define the input shape (batch size and max length), "
"model configuration (size of embedding, # of hidden layers, etc.), "
"and various other settings. The big parameter set increases the "
"default batch size, embedding/hidden size, and filter size. For a "
"complete list of parameters, please see model/model_params.py."))
flags.DEFINE_bool(
name="static_batch", default=False,
help=flags_core.help_wrap(
"Whether the batches in the dataset should have static shapes. In "
"general, this setting should be False. Dynamic shapes allow the "
"inputs to be grouped so that the number of padding tokens is "
"minimized, and helps model training. In cases where the input shape "
"must be static (e.g. running on TPU), this setting will be ignored "
"and static batching will always be used."))
# Flags for training with steps (may be used for debugging)
flags.DEFINE_integer(
name="train_steps", short_name="ts", default=None,
help=flags_core.help_wrap("The number of steps used to train."))
flags.DEFINE_integer(
name="steps_between_evals", short_name="sbe", default=1000,
help=flags_core.help_wrap(
"The Number of training steps to run between evaluations. This is "
"used if --train_steps is defined."))
# BLEU score computation
flags.DEFINE_string(
name="bleu_source", short_name="bls", default=None,
help=flags_core.help_wrap(
"Path to source file containing text translate when calculating the "
"official BLEU score. --bleu_source, --bleu_ref, and --vocab_file "
"must be set. Use the flag --stop_threshold to stop the script based "
"on the uncased BLEU score."))
flags.DEFINE_string(
name="bleu_ref", short_name="blr", default=None,
help=flags_core.help_wrap(
"Path to source file containing text translate when calculating the "
"official BLEU score. --bleu_source, --bleu_ref, and --vocab_file "
"must be set. Use the flag --stop_threshold to stop the script based "
"on the uncased BLEU score."))
flags.DEFINE_string(
name="vocab_file", short_name="vf", default=VOCAB_FILE,
help=flags_core.help_wrap(
"Name of vocabulary file containing subtokens for subtokenizing the "
"bleu_source file. This file is expected to be in the directory "
"defined by --data_dir."))
flags_core.set_defaults(data_dir="/tmp/translate_ende",
model_dir="/tmp/transformer_model",
batch_size=None,
train_epochs=None)
@flags.multi_flags_validator(
["train_epochs", "train_steps"],
message="Both --train_steps and --train_epochs were set. Only one may be "
"defined.")
def _check_train_limits(flag_dict):
return flag_dict["train_epochs"] is None or flag_dict["train_steps"] is None
@flags.multi_flags_validator(
["data_dir", "bleu_source", "bleu_ref", "vocab_file"],
message="--bleu_source, --bleu_ref, and/or --vocab_file don't exist. "
"Please ensure that the file paths are correct.")
def _check_bleu_files(flags_dict):
"""Validate files when bleu_source and bleu_ref are defined."""
if flags_dict["bleu_source"] is None or flags_dict["bleu_ref"] is None:
return True
# Ensure that bleu_source, bleu_ref, and vocab files exist.
vocab_file_path = os.path.join(
flags_dict["data_dir"], flags_dict["vocab_file"])
return all([
tf.gfile.Exists(flags_dict["bleu_source"]),
tf.gfile.Exists(flags_dict["bleu_ref"]),
tf.gfile.Exists(vocab_file_path)])
flags_core.require_cloud_storage(["data_dir", "model_dir"])
def construct_estimator(flags_obj, params, schedule_manager):
"""Construct an estimator from either Estimator or TPUEstimator.
Args:
flags_obj: The FLAGS object parsed from command line.
params: A dict of run specific parameters.
schedule_manager: A schedule.Manager object containing the run schedule.
Returns:
An estimator object to be used for training and eval.
"""
if not params["use_tpu"]:
return tf.estimator.Estimator(
model_fn=model_fn, model_dir=flags_obj.model_dir, params=params)
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu=flags_obj.tpu,
zone=flags_obj.tpu_zone,
project=flags_obj.tpu_gcp_project
)
tpu_config = tf.contrib.tpu.TPUConfig(
iterations_per_loop=schedule_manager.single_iteration_train_steps,
num_shards=flags_obj.num_tpu_shards)
run_config = tf.contrib.tpu.RunConfig(
cluster=tpu_cluster_resolver,
model_dir=flags_obj.model_dir,
session_config=tf.ConfigProto(
allow_soft_placement=True, log_device_placement=True),
tpu_config=tpu_config)
return tf.contrib.tpu.TPUEstimator(
model_fn=model_fn,
use_tpu=params["use_tpu"] and flags_obj.tpu != tpu_util.LOCAL,
train_batch_size=schedule_manager.batch_size,
eval_batch_size=schedule_manager.batch_size,
params={
# TPUEstimator needs to populate batch_size itself due to sharding.
key: value for key, value in params.items() if key != "batch_size"},
config=run_config)
def run_transformer(flags_obj):
"""Create tf.Estimator to train and evaluate transformer model.
Args:
flags_obj: Object containing parsed flag values.
"""
# Add flag-defined parameters to params object
params = PARAMS_MAP[flags_obj.param_set]
params["data_dir"] = flags_obj.data_dir
params["model_dir"] = flags_obj.model_dir
params["num_parallel_calls"] = flags_obj.num_parallel_calls
params["tpu"] = flags_obj.tpu
params["use_tpu"] = bool(flags_obj.tpu) # was a tpu specified.
params["batch_size"] = flags_obj.batch_size or (
params["default_batch_size_tpu"] if params["use_tpu"]
else params["default_batch_size"])
params["static_batch"] = flags_obj.static_batch or params["use_tpu"]
params["allow_ffn_pad"] = not params["use_tpu"]
schedule_manager = schedule.Manager(
train_steps=flags_obj.train_steps,
steps_between_evals=flags_obj.steps_between_evals,
train_epochs=flags_obj.train_epochs,
epochs_between_evals=flags_obj.epochs_between_evals,
default_train_epochs=DEFAULT_TRAIN_EPOCHS,
batch_size=params["batch_size"],
max_length=params["max_length"],
use_tpu=params["use_tpu"],
num_tpu_shards=flags_obj.num_tpu_shards
)
params["repeat_dataset"] = schedule_manager.repeat_dataset
# Create hooks that log information about the training and metric values
train_hooks = hooks_helper.get_train_hooks(
flags_obj.hooks,
tensors_to_log=TENSORS_TO_LOG, # used for logging hooks
batch_size=schedule_manager.batch_size, # for ExamplesPerSecondHook
use_tpu=params["use_tpu"] # Not all hooks can run with TPUs
)
benchmark_logger = logger.get_benchmark_logger()
benchmark_logger.log_run_info(
model_name="transformer",
dataset_name="wmt_translate_ende",
run_params=params,
test_id=flags_obj.benchmark_test_id)
# Train and evaluate transformer model
estimator = construct_estimator(flags_obj, params, schedule_manager)
run_loop(
estimator=estimator,
# Training arguments
schedule_manager=schedule_manager,
train_hooks=train_hooks,
benchmark_logger=benchmark_logger,
# BLEU calculation arguments
bleu_source=flags_obj.bleu_source,
bleu_ref=flags_obj.bleu_ref,
bleu_threshold=flags_obj.stop_threshold,
vocab_file_path=os.path.join(flags_obj.data_dir, flags_obj.vocab_file))
def main(_):
with logger.benchmark_context(flags.FLAGS):
run_transformer(flags.FLAGS)
if __name__ == "__main__":
tf.logging.set_verbosity(tf.logging.INFO)
define_transformer_flags()
absl_app.run(main)
| [
"yuanxiaokun@bbktel.com"
] | yuanxiaokun@bbktel.com |
6f08e80ed6c86615f0e0953c321c153964153361 | f450ed5c70c0e6a9df0b78ed92b7823ec61256e7 | /src/init.py | 840958dce68aaf75f6f86a57ae3a60aa99c50c06 | [
"MIT"
] | permissive | thakreyn/drive-sink | 5508d371fc68ae9faa500cdc3cd481ccdee3ed90 | 0b2674f23e4ece7273c32112478ec0a24befd287 | refs/heads/main | 2023-07-18T09:24:13.777790 | 2021-09-08T20:15:10 | 2021-09-08T20:15:10 | 400,298,504 | 19 | 2 | null | null | null | null | UTF-8 | Python | false | false | 7,080 | py | """
init.py:
Responsible for setting up the directory for synchronisation and setting up
the user profile.
- Checks the directory if already initialised.
- Setups up directory structure
- Asks user data
- Sets up user Files and preferences
- Confirms creation and prints help message
"""
import os
import shutil
from datetime import datetime
from termcolor import colored
import configparser
from . import scan as user_scan
from . import drive as user_drive
CURRENT_LOCATION = os.getcwd()
def check_pre_init():
""" Checks if folder has been inititalised for sync and returns bool
True -> Already init
False -> Not init
"""
# filename = CURRENT_LOCATION + "\.sink"
filename = os.path.join(CURRENT_LOCATION, '.sink')
if os.path.exists(filename):
return True
return False
def generate_config_file():
"""
Generates the initial config.ini file for the user
File contains the following data :
2 sections -> general, user
"""
config = configparser.ConfigParser()
# General config details
config['general'] = {
"root" : CURRENT_LOCATION,
"drive_status" : False,
"populated" : False
}
# User config details
config['user'] = {
"folder_name" : CURRENT_LOCATION,
"folder_id" : ""
}
path = os.path.join(os.getcwd(), '.sink', 'config', 'config.ini')
with open(path, "w") as configfile:
config.write(configfile)
# Also available in utility.py
def read_config_file(section = "general", attr = "root"):
""" Returns the mentioned attr from a given section
(Default: returns the init directory)
"""
config = configparser.ConfigParser()
path = os.path.join(os.getcwd(), '.sink', 'config', 'config.ini')
config.read(path)
return config[section][attr]
def edit_config_file(section, attr, new_attr):
""" Edits the mentioned section and attr in the config.ini """
edit = configparser.ConfigParser()
# edit.read(read_config_file() + "/.sink/config/config.ini")
edit.read(os.path.join(read_config_file() , '.sink', 'config', 'config.ini'))
edit_section = edit[section]
edit_section[attr] = new_attr
with open( os.path.join(read_config_file() , '.sink', 'config', 'config.ini') , "w") as configfile:
edit.write(configfile)
def main_init_process():
"""
Main initialisation routine
Init steps:
1. Establish '.sink' directory
2. Create subfolders (log, config, meta)
3. Generate config file
4. Generate ignore file
5. Generate log files (usage, commit)
6. Complete first scan and write to metadata
7. Establish the drive-sink directory in users folder
"""
if not check_pre_init():
print("Initialising at : " + CURRENT_LOCATION)
directory = ".sink"
path = os.path.join(CURRENT_LOCATION, directory)
os.mkdir(path)
subdirectories = ["log", "config", "meta"]
# Create mentioned subdirectories
for subdirectory in subdirectories:
path = os.path.join(CURRENT_LOCATION , ".sink" , subdirectory)
os.mkdir(path)
# Check if drive-sink is available in users directory, else -> initialise it (with name .drive-sink)
user_folder_path = os.path.expanduser("~")
user_folder_path = os.path.join(user_folder_path, ".drive-sink")
if not os.path.exists(user_folder_path):
os.mkdir(user_folder_path)
# config file
generate_config_file()
# ignore files
with open(os.path.join('.', '.sink', 'ignore.txt'), "w+") as file:
text = "!__pycache__\n!.sink\n!sink\ncredentials.json\ntoken.json"
file.write(text)
# usage log
with open(os.path.join('.','.sink','log','usage.log'), "w+") as file:
time = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
log_message = f"[{time}] : Initialised Folder at -> {CURRENT_LOCATION}"
file.write(log_message)
# commit log
with open(os.path.join('.', '.sink', 'log', 'commit.log'), "w+") as file:
time = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
log_message = f"[{time}] : Initialised Folder at -> {CURRENT_LOCATION}"
file.write(log_message)
# Check if credentials already exist, then inform the user about the file being used
# and give option to use local credentials file
if os.path.exists(os.path.join(user_folder_path, 'credentials.json')):
print(f"\nCredentials.json already found at global location {colored(user_folder_path, 'green')} using it by default.")
print(f"""
{colored("Folder has been successfully initialised at " + CURRENT_LOCATION, 'green')}
Run command:
'{colored("sink initdrive", 'green')}' to enable the drive and verify.
(optional) If you want to use local credentials, please copy 'credentials.json' to '.sink/config'
and then run `sink initdrive`.
If you don't have a credentials.json file, see documentation for instructions to generate one.
If this directory was initialised by mistake, use 'sink clean' to cancel.
""")
else:
print(f"""
{colored("Folder has been successfully initialised at " + CURRENT_LOCATION, 'green')}
{colored("No global 'credentials.json' found!", 'red')}
Please copy 'credentials.json' to '{user_folder_path}' for global access or
to '.sink/config' if you want to use different local credentials.
Then run :
'{colored("sink initdrive", 'green')}' to enable drive and verify.
If you don't have a credentials.json file, see documentation for instructions to generate one.
If this directory was initialised by mistake, use 'sink clean' to cancel.
""")
else:
print(colored("[Error] : A folder has already been initilised here !", 'red'))
def clean_setup():
"""
Completely deletes the sink directory with all config files and
option to delete the drive folder as well
"""
if check_pre_init():
location = read_config_file()
dir = ".sink"
path = os.path.join(location, dir)
if input("Do you want to delete drive folder as well ? (y/n) : ").lower() == 'y':
if read_config_file("general", "drive_status") == 'True':
mydrive = user_drive.MyDrive()
root_id = read_config_file("user", "folder_id")
mydrive.delete_file(root_id)
shutil.rmtree(path)
print(colored("Successfully deleted and cleaned the setup",'green'))
else:
print("No directory found to clean!!") | [
"yash.nthakre@gmail.com"
] | yash.nthakre@gmail.com |
653b22d6a16be1a36b54ae84a8fc932711d61ef1 | c239be070a4cf3dfdfdaad0b5cfd18224ed0a7ae | /main.py | 11de4360c99b210bd6b10bb1ce0bfa414b4c236a | [] | no_license | zubayerkader/Human-Activity-Classifier | e0f943f215076168690da3a493bf53e5666d41f3 | be613be606eba45ee2836eadc9e7118f1f779a7a | refs/heads/main | 2023-04-26T02:52:20.299839 | 2021-05-24T08:03:56 | 2021-05-24T08:03:56 | 370,272,734 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 230 | py | import filter_data
import ml_input
import analysis
import left_right_foot_classification
if __name__ == '__main__':
filter_data.main()
ml_input.createMlData()
analysis.main()
left_right_foot_classification.main()
| [
"zubayerkader@gmail.com"
] | zubayerkader@gmail.com |
793efb87761ef8c69620a2da9deafd73d517872d | d2a030f7a050a641fddd657e895651ee0310ae41 | /givers/forms.py | 9b644910b52b4a7d64e77046e0ac842fe866489a | [] | no_license | Shawen17/Giveawaynow | f052a1055a96f2d0a392aaf748adcafbec2a5135 | 92f3bc0b359a712776661348e239b492894b81a1 | refs/heads/master | 2023-09-05T00:28:59.237486 | 2021-10-24T21:12:37 | 2021-10-24T21:12:37 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,232 | py | from django.db import models
from django.forms.models import ALL_FIELDS
from .models import Give,Profile,ContactUs,states,Vendor
from django.forms import ModelForm, fields
from django import forms
from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm
from .models import validate_num
class ContactUsForm(ModelForm):
class Meta:
model= ContactUs
fields = ('email','subject','ticket','body')
class GiveForm(ModelForm):
class Meta:
model= Give
fields = ('name','category','description','image','quantity','state','giver_number','address')
class SignupForm(UserCreationForm):
password1 = forms.CharField(widget=forms.PasswordInput(attrs={'class':'form-control','placeholder':'Password'}))
password2 = forms.CharField(widget=forms.PasswordInput(attrs={'class':'form-control','placeholder':'Password Again'}))
email = forms.EmailField(max_length=100,widget=forms.TextInput(attrs={'class':'form-control','placeholder':'Email'}))
firstname = forms.CharField(max_length= 100,widget=forms.TextInput(attrs={'class':'form-control','placeholder':'First Name'}))
lastname = forms.CharField(max_length= 100,widget=forms.TextInput(attrs={'class':'form-control','placeholder':'Last Name'}))
username = forms.CharField(max_length= 200,widget=forms.TextInput(attrs={'class':'form-control','placeholder':'Username'}))
phone_number=forms.IntegerField(required=True)
class Meta:
model = User
fields = ('firstname','lastname','username','email','phone_number','password1','password2')
class Profileform(ModelForm):
firstname = forms.CharField(max_length= 100)
lastname = forms.CharField(max_length= 100)
email = forms.EmailField(max_length=100)
phone_number=forms.IntegerField(required=True)
class Meta:
model = Profile
fields = ('profile_pic','firstname','lastname','email','sex','state','phone_number','bio')
class VendorForm(GiveForm):
state=forms.ChoiceField(widget=forms.Select(attrs={'placeholder':'State of Residence'}),choices=states)
class Meta:
model = Vendor
fields=('receiver_number','state','delivery_address')
| [
"shawen022@yahoo.com"
] | shawen022@yahoo.com |
e085ceeb417ebc929fd54fd1c1667da85a497a9a | a25c8c2789750a0b95c2af9b27dde72a8c49b395 | /test/functional/xaya_trading.py | 78a629c3e5ee1521232038231d9d54e9c0aa53fb | [
"MIT"
] | permissive | gripen89/xaya | 65d38dd1cad6a7c21addea51cb4b697fa424fb46 | db0cb3601d9eff01e35ebd4a764aa7ff859e61be | refs/heads/master | 2022-11-21T22:47:45.072342 | 2019-10-21T23:26:24 | 2019-10-21T23:26:24 | 216,678,870 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 11,237 | py | #!/usr/bin/env python3
# Copyright (c) 2019 The Xaya developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Tests trading with atomic name updates."""
from test_framework.test_framework import BitcoinTestFramework
from test_framework.messages import (
COIN,
COutPoint,
CTransaction,
CTxIn,
CTxOut,
)
from test_framework.script import (
CScript,
OP_2DROP,
OP_DROP,
OP_NAME_UPDATE,
)
from test_framework.util import (
assert_equal,
assert_greater_than,
hex_str_to_bytes,
)
from decimal import Decimal
import io
import json
# The fee paid for example transactions.
FEE = Decimal ('0.01')
class AtomicTradingTest (BitcoinTestFramework):
def set_test_params (self):
self.setup_clean_chain = True
self.num_nodes = 2
def generate (self, n, ind = 0):
"""
Mines n blocks with rewards sent to an address that is in the wallet
of none of the test nodes. This ensures that balances are stable and
not changing except through the test.
"""
addr = "chirt1qcmdxwpu35mqlzxz3alc9u9ztp22edsuc5s7zzk"
self.nodes[ind].generatetoaddress (n, addr)
def buildTxOut (self, addr, amount):
"""
Builds a CTxOut message that sends the given amount of CHI to the
given address.
"""
addrData = self.nodes[0].validateaddress (addr)
addrScript = hex_str_to_bytes (addrData["scriptPubKey"])
return CTxOut (int (amount * COIN), addrScript)
def buildNameUpdate (self, name, value, addr, amount):
"""
Builds a name_update output with the given data.
"""
addrData = self.nodes[0].validateaddress (addr)
addrScript = hex_str_to_bytes (addrData["scriptPubKey"])
bname = name.encode ("utf-8")
bvalue = value.encode ("utf-8")
nameScript = CScript ([OP_NAME_UPDATE, bname, bvalue, OP_2DROP, OP_DROP])
# Adding two CScript instances together pushes the second operand
# as data, rather than simply concatenating the scripts. Thus we do
# the concatenation as raw bytes.
nameScriptBytes = bytes (nameScript)
return CTxOut (int (amount * COIN), nameScriptBytes + addrScript)
def findOutput (self, node, amount):
"""
Finds an unspent output in the given node with at least the required
amount. Returns the matching COutPoint as well as its value.
"""
for u in node.listunspent ():
if u["amount"] >= amount:
outp = COutPoint (int (u["txid"], 16), u["vout"])
return outp, Decimal (u["amount"])
raise AssertionError ("No output found with value >= %.8f" % amount)
def parseHexTx (self, txHex):
"""
Converts a transaction in hex format to a CTransaction instance.
"""
data = hex_str_to_bytes (txHex)
tx = CTransaction ()
tx.deserialize (io.BytesIO (data))
return tx
def getBalances (self):
"""
Returns an array with the balances of both nodes.
"""
return [self.nodes[i].getbalance () for i in range (2)]
def assertBalanceChange (self, before, changes):
"""
Asserts that the balances of the nodes have changed compared to
the values of "before" in the given amount.
"""
after = self.getBalances ()
assert_equal (len (before), len (changes))
assert_equal (after, [before[i] + changes[i] for i in range (len (before))])
def getTxFee (self, node, txid):
"""
Computes the paid transaction fee in the given tx. All inputs to the
transaction must be in the node's wallet.
"""
txHex = node.gettransaction (txid)["hex"]
data = node.decoderawtransaction (txHex)
inSum = Decimal ('0.00000000')
for vin in data["vin"]:
prevTxHex = node.gettransaction (vin["txid"])["hex"]
prevTx = node.decoderawtransaction (prevTxHex)
inSum += Decimal (prevTx["vout"][vin["vout"]]["value"])
outSum = Decimal ('0.00000000')
for vout in data["vout"]:
outSum += Decimal (vout["value"])
assert_greater_than (inSum, outSum)
return inSum - outSum
def buildBid (self, node, name, value, price):
"""
Builds a partially signed "bid" offer for updating the name to the
given value and paying the given price for that. The node is used as
the bidder (i.e. the price is funded from it).
The partially signed bid transaction is returned as hex string.
"""
nameData = node.name_show (name)
addr = nameData["address"]
namePrevOut = node.gettxout (nameData["txid"], nameData["vout"])
assert_equal (namePrevOut["scriptPubKey"]["addresses"], [addr])
nameValue = namePrevOut["value"]
tx = CTransaction ()
nameOut = COutPoint (int (nameData["txid"], 16), nameData["vout"])
tx.vin.append (CTxIn (nameOut))
tx.vout.append (self.buildNameUpdate (name, value, addr, nameValue))
tx.vout.append (self.buildTxOut (addr, price))
inp, inValue = self.findOutput (node, price)
tx.vin.append (CTxIn (inp))
change = inValue - price - FEE
assert_greater_than (change, 0)
changeAddr = node.getnewaddress ()
tx.vout.append (self.buildTxOut (changeAddr, change))
txHex = tx.serialize ().hex ()
signed = node.signrawtransactionwithwallet (txHex)
assert not signed["complete"]
return signed["hex"]
def buildAsk (self, node, name, value, price):
"""
Builds a partially signed "ask" offer for updating the name as given.
The problem with prebuilt asks is that the seller does not know
which inputs the buyer uses to pay. This is solved by signing the
name input with SINGLE|ANYONECANPAY and sending the ask price
*into the name*. (It can be recovered later, as the only requirement
for the locked amount is that it always stays >= 0.01 CHI.)
The node is the seller, who owns the name.
Note that this type of order is rather useless for most real-world
situations of trading game assets (since the name value would need to
contain a transfer of assets to the seller, which is not known yet).
There may still be some situations where it can be useful, but it is
mainly interesting since the same method can be applied for
"sentinel inputs" as well; the only difference there is that the
input/output pair created does not involve any names at all.
"""
nameData = node.name_show (name)
namePrevOut = node.gettxout (nameData["txid"], nameData["vout"])
nameValue = namePrevOut["value"]
addr = node.getnewaddress ()
tx = CTransaction ()
nameOut = COutPoint (int (nameData["txid"], 16), nameData["vout"])
tx.vin.append (CTxIn (nameOut))
tx.vout.append (self.buildNameUpdate (name, value, addr, nameValue + price))
txHex = tx.serialize ().hex ()
signed = node.signrawtransactionwithwallet (txHex, [],
"SINGLE|ANYONECANPAY")
assert signed["complete"]
return signed["hex"]
def run_test (self):
# Mine initial blocks so that both nodes have matured coins and no
# more are mined for them in the future (so we can check balances).
self.nodes[0].generate (10)
self.nodes[1].generate (10)
self.generate (110, ind=0)
# Register a name for testing.
self.nodes[0].name_register ("p/test", "{}")
self.generate (1, ind=0)
# Make sure everything is as expected.
self.sync_blocks ()
for node in self.nodes:
info = node.getwalletinfo ()
assert_equal (info["immature_balance"], 0)
# Run individual tests.
self.testBidOffer ()
self.testAskOffer ()
def testBidOffer (self):
self.log.info ("Testing trading by taking a bid offer...")
# Build the bid transaction.
name = "p/test"
newValue = json.dumps ({"data": "bid taken"})
bid = self.buildBid (self.nodes[1], name, newValue, 10)
# The seller must not change the name-update value (this will invalidate
# the signature on the bid).
wrongValue = json.dumps ({"data": "wrong"})
addr = self.nodes[0].getnewaddress ()
tx = self.parseHexTx (bid)
tx.vout[0] = self.buildNameUpdate (name, wrongValue, addr, 0.01)
txHex = tx.serialize ().hex ()
signed = self.nodes[0].signrawtransactionwithwallet (txHex)
assert not signed["complete"]
# The seller also must not change the amount he gets.
tx = self.parseHexTx (bid)
tx.vout[1].nValue = 20 * COIN
txHex = tx.serialize ().hex ()
signed = self.nodes[0].signrawtransactionwithwallet (txHex)
assert not signed["complete"]
# Take the bid successfully and verify the expected changes.
signed = self.nodes[0].signrawtransactionwithwallet (bid)
assert signed["complete"]
oldValue = self.nodes[0].name_show (name)["value"]
assert oldValue != newValue
before = self.getBalances ()
self.nodes[0].sendrawtransaction (signed["hex"])
self.generate (1)
self.sync_blocks ()
self.assertBalanceChange (before, [10, -10 - FEE])
nameData = self.nodes[0].name_show (name)
assert nameData["ismine"]
assert_equal (nameData["value"], newValue)
def testAskOffer (self):
self.log.info ("Testing trading by taking an ask offer...")
# Build the ask transaction.
price = 10
name = "p/test"
newValue = json.dumps ({"data": "ask taken"})
ask = self.buildAsk (self.nodes[0], name, newValue, price)
# Complete it by funding properly.
tx = self.parseHexTx (ask)
inp, inValue = self.findOutput (self.nodes[1], price)
tx.vin.append (CTxIn (inp))
change = inValue - price - FEE
assert_greater_than (change, 0)
changeAddr = self.nodes[1].getnewaddress ()
tx.vout.append (self.buildTxOut (changeAddr, change))
ask = tx.serialize ().hex ()
# The transaction should be invalid if the amount received by the seller
# is changed.
tx = self.parseHexTx (ask)
tx.vout[0].nValue = COIN
txHex = tx.serialize ().hex ()
signed = self.nodes[1].signrawtransactionwithwallet (txHex)
assert not signed["complete"]
# The transaction should be invalid if the name-output script is changed
# to something else.
wrongValue = json.dumps ({"data": "wrong"})
addr = self.nodes[0].getnewaddress ()
tx = self.parseHexTx (ask)
tx.vout[0] = self.buildNameUpdate (name, wrongValue, addr, 10.01)
txHex = tx.serialize ().hex ()
signed = self.nodes[1].signrawtransactionwithwallet (txHex)
assert not signed["complete"]
# Take the ask successfully.
signed = self.nodes[1].signrawtransactionwithwallet (ask)
assert signed["complete"]
oldValue = self.nodes[0].name_show (name)["value"]
assert oldValue != newValue
before = self.getBalances ()
self.nodes[0].sendrawtransaction (signed["hex"])
self.generate (1)
self.sync_blocks ()
nameData = self.nodes[0].name_show (name)
assert nameData["ismine"]
assert_equal (nameData["value"], newValue)
# Recover the locked price and verify wallet balances.
txid = self.nodes[0].name_update (name, "{}")
self.generate (1, ind=0)
feeUpdate = self.getTxFee (self.nodes[0], txid)
assert_greater_than (0.001, feeUpdate)
self.assertBalanceChange (before, [10 - feeUpdate, -10 - FEE])
if __name__ == '__main__':
AtomicTradingTest ().main ()
| [
"d@domob.eu"
] | d@domob.eu |
81a24d352f994fb5d8d4865d93e5c1cbd9dcc4cd | 498b0f8a8f5ff26835efe855adc2fea8ed9c213f | /blockchain_drf/users/urls.py | 84207894598d20db554b7ee121caec04ef480ffb | [] | no_license | cryptobuks/blockchain-drf-app | cb87deca729d555f0f44db9e35ab192b578e20e5 | 97efa62c34e90ac62ce32b4d758f9daf5b31c5d4 | refs/heads/master | 2020-05-28T08:15:41.304110 | 2019-01-26T23:11:01 | 2019-01-26T23:11:01 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 335 | py | from django.urls import path
from users.views.users import (
CreateUserView, CreateTokenView,
ManageUserView
)
app_name = 'users'
urlpatterns = [
path('create/', CreateUserView.as_view(), name='create'),
path('token/', CreateTokenView.as_view(), name='token'),
path('me/', ManageUserView.as_view(), name='me'),
]
| [
"agcastro.py@yahoo.com"
] | agcastro.py@yahoo.com |
02ee7135b39cd74dfd1c357da4f0953d13ca1358 | 3965f8e3b1efcf1586859a079ca8b799e04f4109 | /sorting_algorithms.py | 6462a9ab6008ddf16d4a911a047c3483d7d2bac3 | [
"MIT"
] | permissive | linvieson/sorting-algorithms | 67c435138b3d47568cf6200efd9a3e1ce25d9096 | 22fcc3b1860b3181a30eb4256aec5374b49678f1 | refs/heads/main | 2023-08-28T10:01:15.415044 | 2021-10-06T13:41:13 | 2021-10-06T13:41:13 | 414,223,607 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,762 | py | def selection_sort(arr: list) -> list:
'''
Perform selection sort, return sorted array and number of comparisons.
'''
comparisons = 0
length = len(arr)
if length <= 1:
return arr, comparisons
for index in range(length):
current_min = index
for index_in_unsorted in range(index + 1, length):
comparisons += 1
if arr[current_min] > arr[index_in_unsorted]:
current_min = index_in_unsorted
arr[index], arr[current_min] = arr[current_min], arr[index]
return arr, comparisons
def insertion_sort(arr: list) -> list:
'''
Perform insertion sort, return sorted array and number of comparisons.
'''
comparisons = 0
length = len(arr)
if length <= 1:
return arr, comparisons
for index in range(length):
inner_ind = index
while (inner_ind > 0) and (arr[inner_ind] < arr[inner_ind - 1]):
comparisons += 1
arr[inner_ind], arr[inner_ind - 1] = arr[inner_ind - 1], arr[inner_ind]
inner_ind -= 1
return arr, comparisons
def merge_sort(arr: list) -> list:
'''
Perform merge sort, return sorted array and number of comparisons.
'''
comparisons = 0
length = len(arr)
if length <= 1:
return arr, comparisons
middle = length // 2
left, right = arr[:middle], arr[middle:]
merge_sort(left), merge_sort(right)
ind_left = ind_right = curr_ind = 0
while ind_left < len(left) and ind_right < len(right):
if left[ind_left] < right[ind_right]:
arr[curr_ind] = left[ind_left]
ind_left += 1
else:
arr[curr_ind] = right[ind_right]
ind_right += 1
comparisons += 1
curr_ind += 1
while ind_left < len(left):
arr[curr_ind] = left[ind_left]
ind_left += 1
curr_ind += 1
while ind_right < len(right):
arr[curr_ind] = right[ind_right]
ind_right += 1
curr_ind += 1
return arr, comparisons
def shellsort(arr: list) -> list:
'''
Perform shellsort, return sorted array and number of comparisons.
'''
comparisons = 0
length = len(arr)
gap = 1
if length <= 1:
return arr, comparisons
gap = 1
while gap < (length / 3):
gap = 3 * gap + 1
while gap >= 1:
for index in range(gap, length):
for inner_ind in range(index, gap - 1, -gap):
comparisons += 1
if arr[inner_ind] < arr[inner_ind - gap]:
arr[inner_ind], arr[inner_ind - gap] = arr[inner_ind - gap], arr[inner_ind]
else:
break
gap //= 3
return arr, comparisons
| [
"alina.voronina@ucu.edu.ua"
] | alina.voronina@ucu.edu.ua |
85ae65707ad634936086129bb17d2ebc16ab0115 | eef39fd96ef4ed289c1567f56fde936d5bc42ea4 | /BaekJoon/Bronze2/2744.py | 15ea7e4ea8c55e3f6546f94a24d170bd01b27fa9 | [] | no_license | dudwns9331/PythonStudy | 3e17da9417507da6a17744c72835c7c2febd4d2e | b99b9ef2453af405daadc6fbf585bb880d7652e1 | refs/heads/master | 2023-06-15T12:19:56.019844 | 2021-07-15T08:46:10 | 2021-07-15T08:46:10 | 324,196,430 | 4 | 0 | null | null | null | null | UTF-8 | Python | false | false | 753 | py | # 대소문자 바꾸기
"""
2021-01-20 오후 4:09
안영준
문제
영어 소문자와 대문자로 이루어진 단어를 입력받은 뒤, 대문자는 소문자로, 소문자는 대문자로 바꾸어 출력하는 프로그램을 작성하시오.
입력
첫째 줄에 영어 소문자와 대문자로만 이루어진 단어가 주어진다. 단어의 길이는 최대 100이다.
출력
첫째 줄에 입력으로 주어진 단어에서 대문자는 소문자로, 소문자는 대문자로 바꾼 단어를 출력한다.
"""
String = input()
result = list()
for i in range(len(String)):
if String[i].islower():
result.append(String[i].upper())
else:
result.append(String[i].lower())
print(''.join(map(str, result)))
| [
"dudwns1045@naver.com"
] | dudwns1045@naver.com |
e74ac4d8165a99e360c067617af481624a327184 | 82435e420ff48fac5464ac0880b258de48eee63f | /mechMechanics.py | 53d7b0a3fd1ad3e5582d4eaabb7420c788cb1ce9 | [] | no_license | NiharikaRay/HearthstoneAnalysis | 6910aa5dccacc1e8a3dd5a0a0c269bf70832fe10 | 72165c37cda98efad284eceeb57402b27edf0e10 | refs/heads/master | 2021-01-18T13:00:18.844903 | 2015-02-04T01:32:06 | 2015-02-04T01:32:06 | 29,810,871 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,829 | py | import json
import numpy as np
import csv
from pprint import pprint
import matplotlib.pyplot as plt
from matplotlib.figure import Figure
def _decode_list(data):
rv = []
for item in data:
if isinstance(item, unicode):
item = item.encode('utf-8')
elif isinstance(item, list):
item = _decode_list(item)
elif isinstance(item, dict):
item = _decode_dict(item)
rv.append(item)
return rv
def _decode_dict(data):
rv = {}
for key, value in data.iteritems():
if isinstance(key, unicode):
key = key.encode('utf-8')
if isinstance(value, unicode):
value = value.encode('utf-8')
elif isinstance(value, list):
value = _decode_list(value)
elif isinstance(value, dict):
value = _decode_dict(value)
rv[key] = value
return rv
def getMechCards():
json_data = open("AllSets.enUS.json")
data = json.load(json_data, object_hook=_decode_dict)
json_data.close()
missionCards = filter(lambda x: ("collectible" in x), data["Missions"])
classicCards = filter(lambda x: ("collectible" in x), data["Classic"])
naxCards = filter(lambda x: ("collectible" in x), data["Curse of Naxxramas"])
systemCards = filter(lambda x: ("collectible" in x),data["System"])
creditsCards = filter(lambda x: ("collectible" in x),data["Credits"])
basicCards = filter(lambda x: ("collectible" in x),data["Basic"])
debugCards = filter(lambda x: ("collectible" in x),data["Debug"])
promotionCards = filter(lambda x: ("collectible" in x),data["Promotion"])
rewardCards = filter(lambda x: ("collectible" in x),data["Reward"])
gvgCards = filter(lambda x: ("collectible" in x),data["Goblins vs Gnomes"])
allCards = missionCards + classicCards + naxCards + systemCards + creditsCards + basicCards + debugCards + promotionCards + rewardCards + gvgCards
allCards = filter(lambda x: (x["type"] == "Minion"), allCards)
mechCards = []
for card in allCards:
if ("race" in card):
race = card["race"]
if (race == "Mech"):
mechCards += [card]
return mechCards
def countMechanics():
mechCards = getMechCards()
mechanicsCount = {}
mechanicsToCards = {}
for card in mechCards:
if ("mechanics" in card):
mechanics = card["mechanics"]
for m in mechanics:
if (m in mechanicsCount):
mechanicsCount[m] += 1
else:
mechanicsCount[m] = 1
if (m in mechanicsToCards):
mechanicsToCards[m] += [card["name"]]
else:
mechanicsToCards[m] = [card["name"]]
for (k, v) in mechanicsCount.iteritems():
print "There are " + str(v) + " cards with " + k
print "The cards with " + k + " are: "
pprint(mechanicsToCards[k])
print "\n"
countMechanics()
| [
"YOUR-EMAIL@DOMAIN.COM"
] | YOUR-EMAIL@DOMAIN.COM |
5c5db34ac82587b820a9710f2e8318425496725b | e4b24fe980b1639a2dc73fe76fe38c1c920b8fc7 | /zoopy/models/plan.py | 7b8090836a21717951d8ff8d6a9580def6a6f0b5 | [] | no_license | andersonqueiroz/zoopy | 8f16e6d03974708af0c2726df9bae76ce5f35f00 | d43b14aa6814aec132622915f6c54cd0630ad090 | refs/heads/master | 2021-10-13T12:56:10.689381 | 2021-09-30T20:52:24 | 2021-09-30T20:52:24 | 239,834,336 | 1 | 1 | null | 2021-09-30T20:52:47 | 2020-02-11T18:27:57 | Python | UTF-8 | Python | false | false | 943 | py | from zoopy.utils import get, put, post, delete, get_marketplace_id
from zoopy.models import marketplace
BASE_MODEL_URL = '/plans'
def get_full_url():
return BASE_MODEL_URL
def list(params={}, is_beta=False):
url = f'{marketplace.get_full_url()}{BASE_MODEL_URL}'
return get(url, params=params, is_beta=is_beta)
def details(plan_id, is_beta=False):
url = f'{marketplace.get_full_url()}{BASE_MODEL_URL}/{plan_id}'
return get(url, is_beta=is_beta)
def create(params, is_beta=False):
url = f'{marketplace.get_full_url()}{get_full_url()}'
return post(end_point=url, data=params, is_beta=is_beta)
def update(plan_id, params, is_beta=False):
url = f'{marketplace.get_full_url()}{get_full_url()}/{plan_id}'
return put(end_point=url, data=params, is_beta=is_beta)
def remove(plan_id, is_beta=False):
url = f'{marketplace.get_full_url()}{BASE_MODEL_URL}/{plan_id}'
return delete(url, is_beta=is_beta)
| [
"andersonkeiroz@gmail.com"
] | andersonkeiroz@gmail.com |
be507621c7e451be5c73f45c1b26ac6457984c09 | 041293fc11f0af8b8d7e3640f5f3a2d221ebf1e7 | /milestone3/sink.py | eaffbd025c6220f67a985e67d13480ec27006a78 | [] | no_license | cearto/pidgeot | a480000de1eaf8dae4a3b830e2348b1066e21c2a | 16343af7f5c27ab2da728c156691f44f5741e8f8 | refs/heads/master | 2020-05-17T23:39:01.227890 | 2013-06-04T12:20:02 | 2013-06-04T12:20:02 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,037 | py | # audiocom library: Source and sink functions
from common_srcsink import *
import Image
from graphs import *
import binascii
import random
import os
import heapq # for huffman tree
class Sink:
def __init__(self):
# no initialization required for sink
print 'Sink:'
def process(self, recd_bits):
# Process the recd_bits to form the original transmitted
# file.
# Here recd_bits is the array of bits that was
# passed on from the receiver. You can assume, that this
# array starts with the header bits (the preamble has
# been detected and removed). However, the length of
# this array could be arbitrary. Make sure you truncate
# it (based on the payload length as mentioned in
# header) before converting into a file.
# If its an image, save it as "rcd-image.png"
# If its a text, just print out the text
# Return the received payload for comparison purposes
[srctype, payload_length, padding] = self.read_type_size(recd_bits[:HEADER_GEN_LEN])
if srctype != SRCTYPE_MON:
stats = self.read_stat(recd_bits[HEADER_GEN_LEN:HEADER_GEN_LEN + HEADER_STATS_LEN])
rcd_payload = self.huffman_decode(stats, recd_bits[HEADER_GEN_LEN + HEADER_STATS_LEN:HEADER_GEN_LEN + HEADER_STATS_LEN + payload_length], padding)
else:
rcd_payload = recd_bits[HEADER_GEN_LEN - PADDING_BITS:HEADER_GEN_LEN - PADDING_BITS + payload_length]
print rcd_payload, len(rcd_payload)
print '\tRecd ', len(recd_bits) - HEADER_GEN_LEN, ' data bits'
if srctype == SRCTYPE_TXT:
print '\tText recd: ', self.bits2text(rcd_payload)
elif srctype == SRCTYPE_IMG:
self.image_from_bits(rcd_payload, "rcd-image.png")
return rcd_payload
def huffman_decode(self, stats, bits, padding):
# print "len of undecoded bits", len(bits)
mapping = huffman_reverse_lookup_table(stats)
# print "huffman_decode lookup table", mapping
decoded_str = ''
i = 0
while i < len(bits):
key = str(bits[i])
i = i + 1
while i < len(bits) and key not in mapping:
key = key + str(bits[i])
i = i + 1
decoded_str = decoded_str + mapping[key]
decoded_str = decoded_str[:len(decoded_str) - padding]
# print "huffman_decode bits, len", decoded_str, len(decoded_str)
decoded_bits = list(decoded_str)
decoded_bits = [int(b) for b in decoded_bits]
return decoded_bits
def bits2text(self, bits):
# Convert the received payload to text (string)
#array to binary string
text = ''.join(str(e) for e in bits)
#binary to hex
text = "%x" % int(text, 2)
#hex to ascii
text = binascii.unhexlify(text)
return text
def image_from_bits(self, bits,filename):
# Convert the received payload to an image and save it
# No return value required .
data = ''.join(str(e) for e in bits)
data = "%x" % int(data, 2)
imgSize = (32, 32)
data = binascii.unhexlify(data)
img = Image.fromstring('L', imgSize, data)
img.save(filename)
pass
def read_stat(self, ext_header):
stats = []
klist = []
generate_keys(klist)
for i in xrange(0, len(ext_header), STATSIZE):
freq_bits = ext_header[i:i+STATSIZE]
freq_str = str_from_arr(numpy.array(freq_bits))
freq = int(freq_str, 2)
if freq > 0:
tp = (freq, klist[i/STATSIZE])
stats.append(tp)
return stats
def read_type_size(self, header_bits):
# Given the header bits, compute the payload length
# and source type (compatible with get_header on source)
src_str = ''.join(map(str, header_bits[0:2]))
src_int = int(src_str, 2)
if src_int == SRCTYPE_MON:
srctype = SRCTYPE_MON
srctypestr = 'monotone'
elif src_int == SRCTYPE_IMG:
srctype = SRCTYPE_IMG
srctypestr = 'image'
elif src_int == SRCTYPE_TXT:
srctype = SRCTYPE_TXT
srctypestr = 'text'
else:
print "INVALID SRCTYPE"
payload_str = ''.join(map(str, header_bits[2:18]))
payload_length = int(payload_str, 2)
print '\tRecd header: ', header_bits
print '\tSource type: ', srctypestr
print '\tLength from header: ', payload_length
if src_int != SRCTYPE_MON:
padding_str = ''.join(map(str, header_bits[18:20]))
padding = int(padding_str, 2)
print '\tPadding: ', padding
else:
padding = 0
return srctype, payload_length, padding
| [
"itsmaxine@gmail.com"
] | itsmaxine@gmail.com |
8661ca4dd6a72591400f8f8aab510c0a5d703243 | 40dc3f774f264f3c2d41bbd0c9cf9e07459ee000 | /Code/Python/Factorial.py | 989f30fd257fce02853f3f02e67929ac074ac820 | [
"LicenseRef-scancode-free-unknown",
"MIT"
] | permissive | krishna-NIT/Algo-Tree | 8a5f66b5baef0b7b38a22c41fe090cc9754d8a67 | 1cdb2c3682c6ab85ae8af0b57f42697c15a10554 | refs/heads/main | 2023-05-08T23:39:00.964136 | 2021-05-31T04:07:24 | 2021-05-31T04:07:24 | 371,605,115 | 3 | 0 | MIT | 2021-05-28T06:38:42 | 2021-05-28T06:38:42 | null | UTF-8 | Python | false | false | 604 | py | '''
Factorial function instruct to multiply all whole number from input number down to 1.
The formula for n factorial can be defined as n! = n×(n−1)!
Factorial zero is defined as equal to 1
'''
#This is a recursive function to find the factorial of an integer
def factorial(num):
if num == 0:
return 1
else:
temp = factorial(num-1)
return num * temp
num = int(input("Input: "))
print('Output:',factorial(num))
'''
Test cases:
Input: 7
Output: 5040
Input: 0
Output: 1
Time complexity: O(n)
Space Complexity: O(1)
'''
| [
"noreply@github.com"
] | krishna-NIT.noreply@github.com |
f0d7d985d89cc20f937eb52a76241d951d86e384 | b8a18888062bf7253a1c32761e210bbc4875b62d | /U009_Organized_Window.py | 8111ec4c4aea1891a18a70b924ccee3a209af203 | [] | no_license | yudhastyawan/Tutorial-Python-PyQt5-Basic | 1c993847e2f7ee0e45ce3e33f561370fe778a2af | b1e412e493cc41f04cbcf3f18965f50c3d7f152a | refs/heads/master | 2020-03-18T13:42:50.692765 | 2018-11-03T13:26:37 | 2018-11-03T13:26:37 | 134,802,940 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 827 | py | from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
import sys
import time
class Main(QMainWindow):
def __init__(self, parent = None):
super(Main, self).__init__(parent)
# self.setWindowFlag(Qt.WindowCloseButtonHint, False)
# self.setWindowFlag(Qt.WindowMinMaxButtonsHint, False)
# self.setWindowFlag(Qt.FramelessWindowHint,True)
if __name__ == '__main__':
App = QApplication(sys.argv)
# Create and display the splash screen
splash_pix = QPixmap('tux.png')
splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
splash.setMask(splash_pix.mask())
splash.show()
App.processEvents()
# Simulate something that takes time
time.sleep(2)
main = Main()
main.show()
splash.finish(main)
sys.exit(App.exec_()) | [
"39240883+yudhastyawan@users.noreply.github.com"
] | 39240883+yudhastyawan@users.noreply.github.com |
792e20b7f15bf1b906999ff8891ac9c607365a3d | f22a8078d87b873235c458ed0593c6eb3e6807a2 | /apps/flujo/admin.py | 907fdb39ceca793901f847228b9fd5d8b1e230a9 | [] | no_license | nabilchamas/is2 | d5d9bb393facddcb0a68f8e9f96d08b76dc9cb35 | bd4e55661f7897d2294a27ce240c044192385102 | refs/heads/master | 2020-04-18T21:13:08.062527 | 2015-06-19T21:40:04 | 2015-06-19T21:40:04 | 33,631,498 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 139 | py | from django.contrib import admin
from apps.flujo.models import Flujo, Actividad
admin.site.register(Flujo)
admin.site.register(Actividad)
| [
"nabilchamasi@gmail.com"
] | nabilchamasi@gmail.com |
5798de8ec0cb78d787b255aa68313cfba3467723 | 10bad3cbbfb5c9105f045527711ca84c6bce0360 | /portal/Jobs/init.py | 4c01327fe3beacad01bb81909a1e5c84722a2549 | [] | no_license | alekhyamanomay/Timesheet_Portal | 9ede4bea74c45ea7263a9e0dbd7a46518a939f62 | 05140ca86c15a08ebb2439ec43cf31f23c72be7d | refs/heads/master | 2023-02-06T19:26:10.820401 | 2020-12-16T06:17:04 | 2020-12-16T06:17:04 | 312,593,779 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,123 | py | import os
import sys
import logging
from logging import Formatter
from logging.handlers import RotatingFileHandler
LOG = logging
def init_logger(app):
global LOG
log_file = os.path.join(app.config['LOG_DIR'], 'remainder.log')
log_level = logging.DEBUG
log_format = Formatter(f'%(asctime)s-%(levelname)s-%(message)s')
TWO_MEGABYTE = 2_000_000
file_handler = RotatingFileHandler(filename=log_file, maxBytes=TWO_MEGABYTE, backupCount=3)
file_handler.setFormatter(log_format)
app.logger.addHandler(file_handler)
app.logger.setLevel(log_level)
LOG = app.logger
LOG.info('Initialized logger with level %s', log_level)
print("working")
print(LOG)
basepath =os.path.abspath(os.path.join(os.getcwd(),"..\.."))
print(basepath)
sys.path.insert(1,basepath)
# create instance of flask app
from flask import Flask
app = Flask(__name__)
configfile = os.path.abspath(os.path.join(basepath,'config','development.py'))
app.config.from_pyfile(configfile)
# create instance of sql alchemy
import portal.models as models
models.init_app(app)
init_logger(app)
app.app_context().push()
| [
"57211933+unofficialfarooqsheikh@users.noreply.github.com"
] | 57211933+unofficialfarooqsheikh@users.noreply.github.com |
51ef475926c1fe3bb2fb1c490a227bcaa3740d0b | 21bd66da295baa48603ca9f169d870792e9db110 | /cgp/utils/failwith.py | 3647d91543301dbab771107a4c9d604d07544190 | [] | no_license | kristto/cgptoolbox | e6c01ccea1da06e35e26ffbca227258023377e48 | 8bbaf462e9c1320f237dd3c1ae6d899e1d01ade7 | refs/heads/master | 2021-01-16T20:38:45.097722 | 2012-03-01T09:18:10 | 2012-03-01T09:18:10 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,964 | py | """Modify a function to return a default value in case of error."""
from functools import wraps
import logging
from contextlib import contextmanager
import numpy as np
class NullHandler(logging.Handler):
def emit(self, record):
pass
logger = logging.getLogger("failwith")
logger.addHandler(NullHandler())
@contextmanager
def silenced(logger, level=logging.CRITICAL):
"""
Silence a logger for the duration of the 'with' block.
>>> logger.error("Error as usual.")
Error as usual.
>>> with silenced(logger):
... logger.error("Silenced error.")
>>> logger.error("Back to normal.")
Back to normal.
You may specify a different temporary level if you like.
>>> with silenced(logger, logging.INFO):
... logger.error("Breaking through the silence.")
Breaking through the silence.
"""
oldlevel = logger.level
try:
logger.setLevel(level)
yield logger
finally:
logger.setLevel(oldlevel)
def nans_like(x):
"""
Returns an array of nans with the same shape and type as a given array.
This also works recursively with tuples, lists or dicts whose leaf nodes
are arrays.
>>> x = np.arange(3.0)
>>> nans_like(x)
array([ nan, nan, nan])
>>> y = x.view([(k, float) for k in "a", "b", "c"])
>>> nans_like(y)
array([(nan, nan, nan)], dtype=[('a', '<f8'), ('b', '<f8'), ('c', '<f8')])
>>> nans_like(y.view(np.recarray))
rec.array([(nan, nan, nan)], dtype=[('a', '<f8'), ('b', '<f8'), ('c', '<f8')])
Tuple, list, dict.
>>> nans_like((x, y))
[array([ nan, nan, nan]), array([(nan, nan, nan)],
dtype=[('a', '<f8'), ('b', '<f8'), ('c', '<f8')])]
>>> nans_like([x, y])
[array([ nan, nan, nan]), array([(nan, nan, nan)],
dtype=[('a', '<f8'), ('b', '<f8'), ('c', '<f8')])]
>>> nans_like(dict(a=x, b=y))
{'a': array([ nan, nan, nan]), 'b': array([(nan, nan, nan)],
dtype=[('a', '<f8'), ('b', '<f8'), ('c', '<f8')])}
Nested list and dict.
>>> nans_like([x, [x, y]])
[array([ nan, nan, nan]), [array([ nan, nan, nan]), array([(nan, nan, nan)],
dtype=[('a', '<f8'), ('b', '<f8'), ('c', '<f8')])]]
>>> nans_like(dict(a=x, b=dict(c=x, d=y)))
{'a': array([ nan, nan, nan]),
'b': {'c': array([ nan, nan, nan]), 'd': array([(nan, nan, nan)],
dtype=[('a', '<f8'), ('b', '<f8'), ('c', '<f8')])}}
Note that there is no nan for integers.
>>> nans_like((1, 2, 3))
Traceback (most recent call last):
AssertionError: nan is only defined for float types, not int...
This works because the 1.0 makes Numpy interpret the tuple as a float array.
>>> nans_like((1.0, 2, 3))
array([ nan, nan, nan])
"""
try:
return dict((k, nans_like(v)) for k, v in x.iteritems())
except AttributeError:
try:
xc = np.copy(x)
try:
xc = x.__array_wrap__(xc)
except AttributeError:
pass
msg = "nan is only defined for float types, not %s" % xc.dtype
assert not xc.dtype.kind == "i", msg
xc.view(np.float).fill(np.nan)
return xc
except TypeError:
return [nans_like(i) for i in x]
def failwith(default=None):
"""
Modify a function to return a default value in case of error.
>>> @failwith("Default")
... def f(x):
... raise Exception("Failure")
>>> f(1)
'Default'
Exceptions are logged, but the default handler doesn't do anything.
This example adds a handler so exceptions are logged to :data:`sys.stdout`.
>>> import sys
>>> logger.addHandler(logging.StreamHandler(sys.stdout))
>>> f(2)
Failure in <function f at 0x...>. Default: Default. args = (2,), kwargs = {}
Traceback (most recent call last):...
Exception: Failure
'Default'
>>> del logger.handlers[-1] # Removing the handler added by the doctest
"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
try:
result = func(*args, **kwargs)
except Exception, exc:
msg = "Failure in %s. Default: %s. args = %s, kwargs = %s"
logger.exception(msg, func, default, args, kwargs)
result = default
return result
return wrapper
return decorator
def failwithnanlikefirst(func):
"""
Like :func:`failwith`, but the default is set to `nan` + result on first evaluation.
>>> @failwithnanlikefirst
... def f(x):
... return 1.0 / x
>>> f(1)
1.0
>>> f(0)
array(nan)
Exceptions are logged, but the default handler doesn't do anything.
This example adds a handler so exceptions are logged to :data:`sys.stdout`.
>>> import sys
>>> logger.addHandler(logging.StreamHandler(sys.stdout))
>>> f(0)
Failure in <function f at 0x...>. Default: nan. args = (0,), kwargs = {}
Traceback (most recent call last):...
ZeroDivisionError: float division...
array(nan)
If the first evaluation fails, the exception is logged with an explanatory
note, then re-raised.
>>> @failwithnanlikefirst
... def g():
... raise Exception("Failure")
>>> try:
... g()
... except Exception, exc:
... print "Caught exception:", exc
<function g at 0x...> failed on first evaluation, or result could not be
interpreted as array of float. args = (), kwargs = {}
Traceback (most recent call last):...Exception: Failure
Caught exception: Failure
"""
d = {} # mutable container to store the default between evaluations
@wraps(func)
def wrapper(*args, **kwargs):
if not d:
# First evaluation
try:
result = func(*args, **kwargs)
d["default"] = nans_like(result)
except Exception, exc:
msg = "%s failed on first evaluation, "
msg += "or result could not be interpreted as array of float. "
msg += "args = %s, kwargs = %s"
logger.exception(msg, func, args, kwargs)
raise
else:
# Not first evaluation, so default is defined
try:
result = func(*args, **kwargs)
except Exception, exc:
msg = "Failure in %s. Default: %s. args = %s, kwargs = %s"
logger.exception(msg, func, d["default"], args, kwargs)
result = d["default"]
return result
return wrapper
def failwithnan_asfor(*args, **kwargs):
"""
Like :func:`failwith`, but the default is set to `nans_like(func(*args, **kwargs))`.
>>> @failwithnan_asfor(2.0, 3)
... def f(value, length):
... return [value] * length
>>> f()
array([ nan, nan, nan])
"""
def decorator(func):
default = nans_like(func(*args, **kwargs))
return failwith(default)(func)
return decorator
def failwithdefault_asfor(*args, **kwargs):
"""
Like :func:`failwith`, but the default is set to `func(*args, **kwargs)`.
>>> @failwithdefault_asfor(2, 3)
... def f(value, length):
... return [value] * length
>>> f()
[2, 2, 2]
"""
def decorator(func):
default = func(*args, **kwargs)
return failwith(default)(func)
return decorator
if __name__ == "__main__":
import doctest
doctest.testmod(optionflags=doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS)
| [
"jonovik@gmail.com"
] | jonovik@gmail.com |
c7cc769036318b5263632ef6db922b0a4ffa72cf | 0533d0ceb5966f7327f40d54bbd17e08e13d36bf | /python/HashMap/Maximum Number of Balloons/Maximum Number of Balloons.py | 485eee52af17f72c857b5f35d3beacd6b25b3591 | [] | no_license | danwaterfield/LeetCode-Solution | 0c6178952ca8ca879763a87db958ef98eb9c2c75 | d89ebad5305e4d1a185b0c6f101a88691602b523 | refs/heads/master | 2023-03-19T01:51:49.417877 | 2020-01-11T14:17:42 | 2020-01-11T14:17:42 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 262 | py | from collections import Counter
class Solution(object):
def maxNumberOfBalloons(self, text):
"""
:type text: str
:rtype: int
"""
c = Counter(text)
return min(c["b"], c["a"], c["l"] // 2, c["o"] // 2, c["n"])
| [
"zjuzjj@gmail.com"
] | zjuzjj@gmail.com |
0ea743b25376fd94f0a2b9297d804aee3562820d | b44adadcc087f86d523042084b5d10f612a11365 | /src/combat.py | 4cf27440b47b62817cb31df96fa5dc3259ad0865 | [] | no_license | e-stan/covid_19_analysis | f1cd3e50d14cf0880d7266e768586cac428e31de | 55ca37c2bff68b170d97f8aa2dd588f41af44987 | refs/heads/master | 2023-06-09T18:49:47.830901 | 2021-06-29T17:28:05 | 2021-06-29T17:28:05 | 297,370,604 | 3 | 0 | null | null | null | null | UTF-8 | Python | false | false | 6,919 | py | import pandas as pd
import patsy
import sys
import numpy.linalg as la
import numpy as np
def adjust_nums(numerical_covariates, drop_idxs):
# if we dropped some values, have to adjust those with a larger index.
if numerical_covariates is None: return drop_idxs
return [nc - sum(nc < di for di in drop_idxs) for nc in numerical_covariates]
def design_mat(mod, numerical_covariates, batch_levels):
# require levels to make sure they are in the same order as we use in the
# rest of the script.
design = patsy.dmatrix("~ 0 + C(batch, levels=%s)" % str(batch_levels),
mod, return_type="dataframe")
mod = mod.drop(["batch"], axis=1)
numerical_covariates = list(numerical_covariates)
sys.stderr.write("found %i batches\n" % design.shape[1])
other_cols = [c for i, c in enumerate(mod.columns)
if not i in numerical_covariates]
factor_matrix = mod[other_cols]
design = pd.concat((design, factor_matrix), axis=1)
if numerical_covariates is not None:
sys.stderr.write("found %i numerical covariates...\n"
% len(numerical_covariates))
for i, nC in enumerate(numerical_covariates):
cname = mod.columns[nC]
sys.stderr.write("\t{0}\n".format(cname))
design[cname] = mod[mod.columns[nC]]
sys.stderr.write("found %i categorical variables:" % len(other_cols))
sys.stderr.write("\t" + ", ".join(other_cols) + '\n')
return design
def combat(data, batch, model=None, numerical_covariates=None):
"""Correct for batch effects in a dataset
Parameters
----------
data : pandas.DataFrame
A (n_features, n_samples) dataframe of the expression or methylation
data to batch correct
batch : pandas.Series
A column corresponding to the batches in the data, with index same as
the columns that appear in ``data``
model : patsy.design_info.DesignMatrix, optional
A model matrix describing metadata on the samples which could be
causing batch effects. If not provided, then will attempt to coarsely
correct just from the information provided in ``batch``
numerical_covariates : list-like
List of covariates in the model which are numerical, rather than
categorical
Returns
-------
corrected : pandas.DataFrame
A (n_features, n_samples) dataframe of the batch-corrected data
"""
if isinstance(numerical_covariates, str):
numerical_covariates = [numerical_covariates]
if numerical_covariates is None:
numerical_covariates = []
if model is not None and isinstance(model, pd.DataFrame):
model["batch"] = list(batch)
else:
model = pd.DataFrame({'batch': batch})
batch_items = model.groupby("batch").groups.items()
batch_levels = [k for k, v in batch_items]
batch_info = [v for k, v in batch_items]
n_batch = len(batch_info)
n_batches = np.array([len(v) for v in batch_info])
n_array = float(sum(n_batches))
# drop intercept
drop_cols = [cname for cname, inter in ((model == 1).all()).iteritems() if inter == True]
drop_idxs = [list(model.columns).index(cdrop) for cdrop in drop_cols]
model = model[[c for c in model.columns if not c in drop_cols]]
numerical_covariates = [list(model.columns).index(c) if isinstance(c, str) else c
for c in numerical_covariates if not c in drop_cols]
design = design_mat(model, numerical_covariates, batch_levels)
sys.stderr.write("Standardizing Data across genes.\n")
B_hat = np.dot(np.dot(la.inv(np.dot(design.T, design)), design.T), data.T)
grand_mean = np.dot((n_batches / n_array).T, B_hat[:n_batch,:])
var_pooled = np.dot(((data - np.dot(design, B_hat).T)**2), np.ones((int(n_array), 1)) / int(n_array))
stand_mean = np.dot(grand_mean.T.reshape((len(grand_mean), 1)), np.ones((1, int(n_array))))
tmp = np.array(design.copy())
tmp[:,:n_batch] = 0
stand_mean += np.dot(tmp, B_hat).T
s_data = ((data - stand_mean) / np.dot(np.sqrt(var_pooled), np.ones((1, int(n_array)))))
sys.stderr.write("Fitting L/S model and finding priors\n")
batch_design = design[design.columns[:n_batch]]
gamma_hat = np.dot(np.dot(la.inv(np.dot(batch_design.T, batch_design)), batch_design.T), s_data.T)
delta_hat = []
for i, batch_idxs in enumerate(batch_info):
#batches = [list(model.columns).index(b) for b in batches]
delta_hat.append(s_data[batch_idxs].var(axis=1))
gamma_bar = gamma_hat.mean(axis=1)
t2 = gamma_hat.var(axis=1)
a_prior = list(map(aprior, delta_hat))
b_prior = list(map(bprior, delta_hat))
sys.stderr.write("Finding parametric adjustments\n")
gamma_star, delta_star = [], []
for i, batch_idxs in enumerate(batch_info):
#print '18 20 22 28 29 31 32 33 35 40 46'
#print batch_info[batch_id]
temp = it_sol(s_data[batch_idxs], gamma_hat[i],
delta_hat[i], gamma_bar[i], t2[i], a_prior[i], b_prior[i])
gamma_star.append(temp[0])
delta_star.append(temp[1])
sys.stdout.write("Adjusting data\n")
bayesdata = s_data
gamma_star = np.array(gamma_star)
delta_star = np.array(delta_star)
for j, batch_idxs in enumerate(batch_info):
dsq = np.sqrt(delta_star[j,:])
dsq = dsq.reshape((len(dsq), 1))
denom = np.dot(dsq, np.ones((1, n_batches[j])))
numer = np.array(bayesdata[batch_idxs] - np.dot(batch_design.loc[batch_idxs], gamma_star).T)
bayesdata[batch_idxs] = numer / denom
vpsq = np.sqrt(var_pooled).reshape((len(var_pooled), 1))
bayesdata = bayesdata * np.dot(vpsq, np.ones((1, int(n_array)))) + stand_mean
return bayesdata
def it_sol(sdat, g_hat, d_hat, g_bar, t2, a, b, conv=0.0001):
n = (1 - np.isnan(sdat)).sum(axis=1)
g_old = g_hat.copy()
d_old = d_hat.copy()
change = 1
count = 0
while change > conv:
#print g_hat.shape, g_bar.shape, t2.shape
g_new = postmean(g_hat, g_bar, n, d_old, t2)
sum2 = ((sdat - np.dot(g_new.values.reshape((g_new.shape[0], 1)), np.ones((1, sdat.shape[1])))) ** 2).sum(axis=1)
d_new = postvar(sum2, n, a, b)
change = max((abs(g_new - g_old) / g_old).max(), (abs(d_new - d_old) / d_old).max())
g_old = g_new #.copy()
d_old = d_new #.copy()
count = count + 1
adjust = (g_new, d_new)
return adjust
def aprior(gamma_hat):
m = gamma_hat.mean()
s2 = gamma_hat.var()
return (2 * s2 +m**2) / s2
def bprior(gamma_hat):
m = gamma_hat.mean()
s2 = gamma_hat.var()
return (m*s2+m**3)/s2
def postmean(g_hat, g_bar, n, d_star, t2):
return (t2*n*g_hat+d_star * g_bar) / (t2*n+d_star)
def postvar(sum2, n, a, b):
return (0.5 * sum2 + b) / (n / 2.0 + a - 1.0) | [
"estancl1234@gmail.com"
] | estancl1234@gmail.com |
5ae4b198d2a7269a72cc1d693548079756c4fb9b | e16d7d8f60145c68640b25aa7c259618be60d855 | /django_test/webtest/testapp/urls.py | 32d935549071646c1d172c99ccd6ba69db2bd72b | [] | no_license | zongqiqi/mypython | bbe212223002dabef773ee0dbeafbad5986b4639 | b80f3ce6c30a0677869a7b49421a757c16035178 | refs/heads/master | 2020-04-21T07:39:59.594233 | 2017-12-11T00:54:44 | 2017-12-11T00:54:44 | 98,426,286 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 115 | py | from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^$', views.index,name='index'),
]
| [
"544136329@qq.com"
] | 544136329@qq.com |
0710b3ada6e27cc9d82d7532b608ce1ab6c6bad7 | f71f9c4736f5279ade23382fc39a6b4f6243bc42 | /finalsalad/wsgi.py | 51de96e59fb786703a467b376f3cc535698f0cfb | [] | no_license | Pancakem/saladmaster | b62143fb41a00e78a0fb6f68c64c8af72956cb89 | 234b388addc45cb74b1021608f888e1efd5d9292 | refs/heads/master | 2020-03-25T08:29:36.398546 | 2018-10-08T10:51:07 | 2018-10-08T10:51:07 | 142,886,081 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 171 | py | import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "finalsalad.settings")
application = get_wsgi_application()
| [
"pancakesdeath@protonmail.com"
] | pancakesdeath@protonmail.com |
bacebe743480b18f6233b694f509ca0713abd2d4 | 0e61801612672a7e302d0996eea4587d68127b54 | /src/grid_inference.py | d4b8ec4587e0cd8207b4f2880644663186bd6bfa | [] | no_license | DongjoonLim/EvoLSTM | a2c501c2842958cf62b0017b4d2415a5558e0975 | c192488eb30131f77c3111c638b6cf683a0185ca | refs/heads/master | 2023-06-29T23:09:59.928447 | 2023-06-13T20:34:49 | 2023-06-13T20:34:49 | 237,307,918 | 4 | 0 | null | 2022-12-08T11:38:59 | 2020-01-30T21:20:05 | Jupyter Notebook | UTF-8 | Python | false | false | 10,519 | py |
# coding: utf-8
# In[1]:
# !pip3 install -U scikit-learn
# !pip3 install keras
# !pip3 install cudnnenv
# !pip3 install tensorflow-gpu
# !pip3 install matplotlib
# !conda uninstall -c anaconda cudatoolkit
#!nvidia-smi
from keras.utils.vis_utils import plot_model
import numpy as np
from keras.models import Sequential
from keras.layers import Activation, LSTM, TimeDistributed, Dense, RepeatVector, CuDNNLSTM, GRU, Bidirectional, Input, CuDNNGRU
from keras.utils import np_utils
from keras.callbacks import TensorBoard
import tensorflow as tf
import os
from keras import backend as K
from keras.models import Model
from keras.layers.core import Dense, Reshape
from keras.layers.wrappers import TimeDistributed
from keras.layers import concatenate
import difflib
from keras.models import load_model
import keras
from keras import losses
import matplotlib.pyplot as plt
import random
from random import choice
import re
import pickle
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
import math
seq_length = 10
test_size = 50000
val_size = 30000
nucleotide = ['0', 'A', 'C', 'G', 'T', '-']
#model5 = load_model('model/seq2seq_nogap_camFam3_1mut.h5')
def decoder(array):
result = ""
size = len(array)
for i in range(size):
if array[i].tolist() == [1, 0, 0, 0, 0, 0]:
result=result+"0"
elif array[i].tolist() == [0, 1, 0, 0, 0, 0]:
result=result+"A"
elif array[i].tolist() == [0, 0, 1, 0, 0, 0]:
result=result+"C"
elif array[i].tolist() == [0, 0, 0, 1, 0, 0]:
result=result+"G"
elif array[i].tolist() == [0, 0, 0, 0, 1, 0]:
result=result+"T"
elif array[i].tolist() == [0, 0, 0, 0, 0, 1]:
result=result+"-"
return result
#model5 = load_model('model/seq2seq_nogap_camFam3_1mut.h5')
def decoderY(array):
result = ""
size = len(array)
if array.tolist() == [1, 0, 0, 0, 0, 0]:
result=result+"0"
elif array.tolist() == [0, 1, 0, 0, 0, 0]:
result=result+"A"
elif array.tolist() == [0, 0, 1, 0, 0, 0]:
result=result+"C"
elif array.tolist() == [0, 0, 0, 1, 0, 0]:
result=result+"G"
elif array.tolist() == [0, 0, 0, 0, 1, 0]:
result=result+"T"
elif array.tolist() == [0, 0, 0, 0, 0, 1]:
result=result+"-"
return result
def printHitMiss(a,b):
if a==b:
return 'Hit'
else:
return 'Miss'
def accuracy(a, b):
count = 0
for i in range(len(a)):
if a[i] == b[i]:
count = count+1
return count/len(a)
def accuracy2(a, b, c):
count = 0
count2 =0
for i in range(len(a)):
if a[i] != c[i]:
count2 = count2 +1
if a[i] != c[i] and b[i]==c[i]:
count = count+1
return count/count2
def isMutation(a, b):
if a!= b:
print("mutation")
def decode_sequence(input_seq, model, encoder_model, decoder_model):
nucleotide = ['0', 'A', 'C', 'G', 'T', '-']
# Encode the input as state vectors.
#print(input_seq[0,0])
index = 0
states_value = encoder_model.predict(input_seq)
#print(len(states_value))
#print(states_value)
# Generate empty target sequence of length 1.
target_seq = np.zeros((1, 1, 12))
target_seq[0][0]= np.hstack((input_seq[0,index], np.array([1,0,0,0,0,0])))
#print(target_seq)
# Populate the first character of target sequence with the start character.
# Sampling loop for a batch of sequences
# (to simplify, here we assume a batch of size 1).
stop_condition = False
decoded_sentence = ''
probability = 1
while not stop_condition:
index = index +1
output_tokens, h, c = decoder_model.predict(
[target_seq] + states_value)
# Sample a token
sampled_token_index = np.argmax(output_tokens[0, -1, :])
print(output_tokens)
#sampled_token_index = np.random.choice(6, 1, p=output_tokens[0, -1, :])[0]
#print(output_tokens[0, -1, :])
sampled_char = nucleotide[sampled_token_index]
decoded_sentence += sampled_char
#print(decoded_sentence)
# Exit condition: either hit max length
# or find stop character.
if (len(decoded_sentence) == seq_length):
break
# Update the target sequence (of length 1).
target_seq = np.zeros((1, 1, 12))
temp = np.zeros((6))
temp[sampled_token_index] = 1
target_seq[0][0]= np.hstack((input_seq[0, index], temp))
# target_seq[0, 0, sampled_token_index] = 1
# Update states
states_value = [h, c]
return decoded_sentence
def get_prob(input_seq, target, model, encoder_model, decoder_model):
nucleotide = ['0', 'A', 'C', 'G', 'T', '-']
# Encode the input as state vectors.
index = 0
states_value = encoder_model.predict(input_seq)
target_seq = np.zeros((1, 1, 12))
target_seq[0][0]= np.hstack((input_seq[0,index], np.array([1,0,0,0,0,0])))
stop_condition = False
decoded_sentence = ''
probability = []
while not stop_condition:
index = index +1
output_tokens, h, c = decoder_model.predict(
[target_seq] + states_value)
# Sample a token
#print(output_tokens[0, -1, :])
sampled_token_index = np.argmax(target[index-1])
#sampled_token_index = np.random.choice(6, 1, p=output_tokens[0, -1, :])[0]
#probability[index-1] = probability[index-1] * output_tokens[0, -1, :][sampled_token_index]
probability.append(output_tokens[0, -1, :][sampled_token_index])
#print(output_tokens[0, -1, :])
sampled_char = nucleotide[sampled_token_index]
decoded_sentence += sampled_char
#print(decoded_sentence)
# Exit condition: either hit max length
# or find stop character.
if (len(decoded_sentence) == seq_length):
break
# Update the target sequence (of length 1).
target_seq = np.zeros((1, 1, 12))
temp = np.zeros((6))
temp[sampled_token_index] = 1
target_seq[0][0]= np.hstack((input_seq[0, index], temp))
# target_seq[0, 0, sampled_token_index] = 1
# Update states
states_value = [h, c]
return decoded_sentence, probability
def diffList(a, b):
count = 0
length = len(a)
for i in range(length):
if a[i] != b[i]:
count = count+1
return count
#for seq_index in range(1):
def predict2(X_test, y_test, model, encoder_model, decoder_model, gru=False):
x_true =[]
y_hat =[]
y_true =[]
probList=[]
productProb = [0]*seq_length
for seq_index in range(len(X_test)):
input_seq = X_test[seq_index: seq_index + 1]
#print(input_seq[0])
if gru:
decoded_sentence = decode_gru(input_seq, model, encoder_model, decoder_model)
else :
decoded_sentence = decode_sequence(input_seq, model, encoder_model, decoder_model)
_, prob = get_prob(input_seq, y_test[seq_index], model, encoder_model, decoder_model)
probList.append(prob)
prob = [math.log(x) for x in prob]
productProb = [sum(x) for x in zip(productProb, prob)]
input_sen = decoder(input_seq[0])
print(input_sen, ' -> ',
decoded_sentence, 'True:', decoder(y_test[seq_index]),
printHitMiss(decoded_sentence, decoder(y_test[seq_index])),
diffList(input_sen, decoded_sentence)
)
print(input_sen, ' -> ',
decoder(y_test[seq_index]), 'True:', decoder(y_test[seq_index]),
prob,
printHitMiss(decoded_sentence, decoder(y_test[seq_index])),
diffList(input_sen, decoded_sentence)
)
print()
x_true.append(input_sen)
y_hat.append(decoded_sentence)
y_true.append(decoder(y_test[seq_index]))
productProb = [x/test_size for x in productProb]
print("Mean and std of probabilities : {} , {} ".format(np.mean(probList), np.std(probList)))
print("Sum of log probabilities : {}".format(productProb))
print("Percentage of target and prediction being identical: {}".format(accuracy(y_hat, y_true)))
print("Percentage of training and prediction being identical: {}".format(accuracy(y_hat, x_true)))
print("Accuracy given mutation happened : {}".format(accuracy2(x_true, y_hat, y_true)))
#print("Test loss : {}".format(keras.losses.categorical_crossentropy(y_true, y_hat)))
#return x_true, y_hat, y_true
def grid_predict(train_size, half, epoch, X_test, y_test):
model1 = load_model("models/{}_{}_{}.h5".format(train_size,half,epoch))
encoder_model1 = load_model("models/E{}_{}_{}.h5".format(train_size,half, epoch))
decoder_model1 =load_model("models/D{}_{}_{}.h5".format(train_size,half, epoch))
predict2(X_test, y_test, model1, encoder_model1, decoder_model1, gru=False)
# In[3]:
def concat(input1, input2):
result = []
for x, y in zip(input1, input2):
result.append(np.hstack((x, y)))
return np.array(result)
def get_data(trainInd, valInd, testInd):
X_train=np.load('prepData/X_train_camFam3_1mut_v3_chr2.npy')[:trainInd]
X_val=np.load('prepData/X_val_camFam3_1mut_v3_chr2.npy')[:valInd]
X_test=np.load('prepData/X_test_camFam3_1mut_v3_chr2.npy')[:testInd]
y_train=np.load('prepData/y_train_camFam3_1mut_v3_chr2.npy')[:trainInd]
y_val=np.load('prepData/y_val_camFam3_1mut_v3_chr2.npy')[:valInd]
y_test=np.load('prepData/y_test_camFam3_1mut_v3_chr2.npy')[:testInd]
y_train1 = np.load('prepData/y_train1_camFam3_1mut_v3_chr2.npy')[:trainInd]
y_val1 = np.load('prepData/y_val1_camFam3_1mut_v3_chr2.npy')[:valInd]
y_test1 = np.load('prepData/y_test1_camFam3_1mut_v3_chr2.npy')[:testInd]
y_train1 = concat(X_train, y_train1)
y_val1 = concat(X_val, y_val1)
y_test1 = concat(X_test, y_test1)
return X_test, y_test
train_size = 0
hidden = [16,32, 64,128,256,512]
epoch = [5, 5, 5, 5, 5, 5]
X_test, y_test = get_data(train_size, val_size, test_size)
for h, e in zip(hidden, epoch):
print("Train size = {}, hidden_size = {}, epoch = {}".format(train_size, h, e))
grid_predict(train_size, h, e, X_test, y_test)
print("The end of Train size = {}, hidden_size = {}, epoch = {}".format(train_size, h, e))
| [
"noreply@github.com"
] | DongjoonLim.noreply@github.com |
a56cc49b7af3847ff824b21c622bd6cfb1a5aba0 | 9c6c92f1df99b1cd996b99defda2a68b8f672215 | /detection.py | 28322274600d4f5cd2ada7e0072d405322d10835 | [] | no_license | oanders/Object_detection | 98d27630400bc174dc693afd20d11d27014beca4 | 328d0f2c3004e48c4b3289bb81ea4a5a2076ef1b | refs/heads/master | 2021-01-10T05:50:29.449343 | 2016-04-10T19:14:49 | 2016-04-10T19:14:49 | 54,318,149 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 10,865 | py | import cv2
import numpy as np
from matplotlib import pyplot as plot
import os
#from os import listdir, makedirs
#from os.path import isfile, join, isdir
import copy
from class_sift import Sift
from class_akaze import AKaze
from class_orb import ORB
from class_detector import Detector
MIN_MATCH_COUNT = 10
def main():
choice = int(raw_input("To run a single tests, press (1). To run all test, press (2). : "))
if choice == 1:
m1()
elif choice == 2:
m2()
else:
main()
#Main method, it calls other functions and
#tests different detection algortithms on images
def m1():
#Ask wich object we are running tests on
folder = choose_folder()
test = choose_test(folder)
#Path for a result directory to be created
directory = 'test_results_kaze_2/' + folder + '/' + test #Quick test, remove 2 later
#Path for Training image
path = 'Images/' + folder + '/' + test
img1 = path + '/' + 'tr.jpg'
print('using training image: ' + img1)
tr_img, tr_grey = load__greyScale(img1)
#Loop through test images
nr = read_nr_images(path)
i = 1
while i < nr:
img2 = path + '/' + 't' + str(i) + '.jpg'
print('using test image: ' + img2)
test_img, test_grey = load__greyScale(img2)
#Run algorithms
res_sift_img, good_matches_sift, time_sift, res_kaze_img, good_matches_kaze, time_kaze, res_akaze_img, good_matches_akaze, time_akaze, res_orb_img, good_matches_orb, time_orb = run_test_algorithms(tr_grey, test_grey, tr_img, test_img)
#Table containing the number of matches for each algorithm
table_img = create_table(res_orb_img, good_matches_sift, time_sift, good_matches_akaze, time_akaze, good_matches_orb, time_orb)
#Draw plots for the resulting images
draw_plots(res_sift_img, res_kaze_img, res_akaze_img, res_orb_img, table_img, i, directory, folder, test)
#go to next image in the folder
i = i+1
#Runs all tests
def m2():
folders = read_folders('Images')
nr_folders = len(folders)
curr_folder = 0
for folder in folders:
tests = read_folders('Images/' + folder)
nr_tests = len(tests)
curr_test = 1
curr_folder = curr_folder + 1
for test in tests:
print('----Working on object ' + str(curr_folder) + ' out of ' + str(nr_folders) + ' and test ' + str(curr_test) + ' out of ' + str(nr_tests) + '----')
curr_test = curr_test + 1
#Path for a result directory to be created
directory = 'test_results_kaze_2/' + folder + '/' + test #Quick test, remove 2 later
#Path for Training image
path = 'Images/' + folder + '/' + test
img1 = path + '/' + 'tr.jpg'
print('using training image: ' + img1)
tr_img, tr_grey = load__greyScale(img1)
#Loop through test images
nr = read_nr_images(path)
i = 1
while i < nr:
img2 = path + '/' + 't' + str(i) + '.jpg'
print('using test image: ' + img2)
test_img, test_grey = load__greyScale(img2)
#Run algorithms
res_sift_img, good_matches_sift, time_sift, res_kaze_img, good_matches_kaze, time_kaze, res_akaze_img, good_matches_akaze, time_akaze, res_orb_img, good_matches_orb, time_orb = run_test_algorithms(tr_grey, test_grey, tr_img, test_img)
#Table containing the number of matches for each algorithm
table_img = create_table(res_orb_img, good_matches_sift, time_sift, good_matches_akaze, time_akaze, good_matches_orb, time_orb)
#Draw plots for the resulting images
draw_plots(res_sift_img, res_kaze_img, res_akaze_img, res_orb_img, table_img, i, directory, folder, test)
#go to next image in the folder
i = i+1
#Method that goes to a desired folder
def choose_folder():
print('\nAvailable objects:\n')
folders = read_folders('Images')
i = 1
while i <= len(folders):
print('(' + str(i) + '): ' + folders[i-1])
i = i+1
choice = int(raw_input('\nChoose a folder nr: '))
folder = folders[choice-1]
return folder
#Read a folder containing images and return a list of urls
def read_folders(path):
#List of names of all training images
names = [f for f in os.listdir(path)]
return names
#choses a folder with one test
def choose_test(folder):
print('\nAvailable tests:\n')
tests = read_folders('Images/' + folder)
i = 1
for test in tests:
print('(' + str(i) + '): ' + test)
i = i+1
chosen_test = int(raw_input('\nChoose test nr: '))
test = tests[chosen_test-1]
return test
#Returns the number of images of the given path/folder
def read_nr_images(path):
images = [im for im in os.listdir(path) if os.path.isfile(os.path.join(path, im))]
return len(images)
#Read an image and return its grey picture
def load__greyScale(image):
print('Loading: ' + image)
img = cv2.imread(image)
h, w, d = img.shape
grey = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
return img, grey
#Runs all 3 algorithms on the same object and test.
#Returns 1 image for the result of each algorithm tested.
def run_test_algorithms(tr_grey, test_grey, tr_img, test_img):
#Create detectors
sift_algo = cv2.xfeatures2d.SIFT_create()
kaze_algo = cv2.KAZE_create()
akaze_algo = cv2.AKAZE_create()
orb_algo = cv2.ORB_create()
sift = Detector(sift_algo, 'N')
kaze = Detector(kaze_algo, 'N')
akaze = Detector(akaze_algo, 'N')
orb = Detector(orb_algo, 'NORM_HAMMING')
#Call sift
kpAS, descAS, kpBS, descBS, good_matches_sift, time_sift = sift.match(tr_grey, test_grey)
#Call Kaze
kpAK, descAK, kpBK, descBK, good_matches_kaze, time_kaze = kaze.match(tr_grey, test_grey)
#Call Akaze class
kpAAK, descAAK, kpBAK, descBAK, good_matches_akaze, time_akaze = akaze.match(tr_grey, test_grey)
#Call ORB class
kpAorb, descAorb, kpBorb, descBorb, good_matches_orb, time_orb = orb.match(tr_grey, test_grey)
#Mask for all three algorithms
maskS, dtsS = location_extraction(kpAS, kpBS, good_matches_sift,tr_img)
maskK, dtsK = location_extraction(kpAK, kpBK, good_matches_kaze,tr_img)
maskAK, dtsAK = location_extraction(kpAAK, kpBAK, good_matches_akaze,tr_img)
maskorb, dtsorb = location_extraction(kpAorb, kpBorb, good_matches_orb,tr_img)
#Copy of image so that lines from first method do not last to second.
tmp_img1 = copy.copy(test_img)
tmp_img2 = copy.copy(test_img)
tmp_img3 = copy.copy(test_img)
res_sift_img = create_results(tr_img, test_img, kpAS, kpBS, dtsS,
maskS, good_matches_sift)
res_kaze_img = create_results(tr_img, tmp_img1, kpAK, kpBK, dtsK,
maskK, good_matches_kaze)
res_orb_img = create_results(tr_img, tmp_img2, kpAorb, kpBorb, dtsorb,
maskorb, good_matches_orb)
res_akaze_img = create_results(tr_img, tmp_img3, kpAAK, kpBAK, dtsAK,
maskAK, good_matches_akaze)
return res_sift_img, good_matches_sift, time_sift, res_kaze_img, good_matches_kaze, time_kaze, res_akaze_img, good_matches_akaze, time_akaze, res_orb_img, good_matches_orb, time_orb
#Takes keypoint descriptor and extracts its location
def location_extraction(kpA, kpB, good_matches, tr_img):
if len(good_matches) > MIN_MATCH_COUNT:
src_pts = np.float32([kpA[m.queryIdx].pt for m in good_matches]).reshape(-1,1,2)
dst_pts = np.float32([kpB[m.trainIdx].pt for m in good_matches]).reshape(-1,1,2)
M,mask = cv2.findHomography(src_pts,dst_pts, cv2.RANSAC, 5.0)
matchesMask = mask.ravel().tolist()
h,w,d = tr_img.shape
pts = np.float32( [ [0,0], [0,h-1], [w-1,h-1],[w-1,0] ] ).reshape(-1,1,2)
dst = cv2.perspectiveTransform(pts,M)
return matchesMask, dst
else:
print("Not enough matches")
matchesMask = None
return matchesMask, None
#Create a result image showing the detected matches if the algorithm
#successfully found the object. Otherwise it presents an image with
#all the detected keypoints
def create_results(tr_img, tmp_img, kpA, kpB, dst, matchesMask, good_matches):
if dst != None:
tmp_img = cv2.polylines(tmp_img,[np.int32(dst)],True, 255,3,cv2.LINE_AA)
draw_params = dict(matchColor = (0, 255, 0),
singlePointColor = None,
matchesMask = matchesMask, # draw only inliers
flags = 2)
res_img = cv2.drawMatches(tr_img,kpA,tmp_img,kpB,good_matches,None,**draw_params)
return res_img
else:
#Draw keypoints that were detected for each picture
res_img1 = cv2.drawKeypoints(tr_img, kpA, None, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
res_img2 = cv2.drawKeypoints(tmp_img, kpB, None, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
#Get size of both pictures
h1, w1 , d1 = res_img1.shape
h2, w2, d2 = res_img2.shape
#create an empty array with the size to hold both pictures
res_img = np.zeros((max(h1,h2), w1+w2, d1), np.uint8)
res_img[:h1, :w1] = res_img1
res_img[:h2, w1:w1+w2] = res_img2
return res_img
#Creates a table with the number of matches that each algortihm found
#for the object.
def create_table(res_orb_img, good_matches_sift, time_sift, good_matches_akaze, time_akaze, good_matches_orb, time_orb):
h, w, d = res_orb_img.shape
table_img = np.zeros((h,w,d), np.uint8)
font = cv2.FONT_HERSHEY_SIMPLEX
nr_matches_sift = 'Time of detection SIFT: ' + str(time_sift)
cv2.putText(table_img, nr_matches_sift, (100, 100), font, 1, (255,255,255), 2, cv2.LINE_AA)
nr_matches_akaze = 'Time of detection KAZE: ' + str(time_akaze)
cv2.putText(table_img, nr_matches_akaze, (100, 200), font, 1, (255,255,255), 2, cv2.LINE_AA)
nr_matches_orb = 'Time of detection ORB: ' + str(time_orb)
cv2.putText(table_img, nr_matches_orb, (100, 300), font, 1, (255,255,255), 2, cv2.LINE_AA)
return table_img
def draw_plots(sift, kaze, akaze, orb, table, index, directory, folder, test):
plot.subplot(221), plot.imshow(sift), plot.title('Sift')
plot.subplot(222), plot.imshow(kaze), plot.title('KAZE')
plot.subplot(223), plot.imshow(akaze), plot.title('AKAZE')
plot.subplot(224), plot.imshow(orb), plot.title('ORB')
if not os.path.isdir(directory):
os.makedirs(directory)
number = index
fig_name = directory + '/' + folder+'_'+test+'_'+str(index) + '.png'
plot.savefig(fig_name, format ='png', dpi = 600)
main()
| [
"oanders@kth.se"
] | oanders@kth.se |
3bf31dc5541a71a9313fdcce75a2fbb612fe9083 | 41941d61fdb1c2f6b50613de20376ca882678946 | /restaurant/migrations/0038_auto_20200903_1340.py | 0977001525108cdcddd8cf1b3672d34d74571759 | [] | no_license | ankitgadewal/saleor_server | 1000ac6dbfa9fb8fa6b8172a03ceb82a86002f0a | 0c743545ea3567eba7bfc402f53abe5413a564b6 | refs/heads/master | 2022-12-11T01:31:28.518059 | 2020-09-09T09:16:19 | 2020-09-09T09:16:19 | 293,053,275 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 368 | py | # Generated by Django 3.1 on 2020-09-03 08:10
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('restaurant', '0037_auto_20200903_1304'),
]
operations = [
migrations.RenameField(
model_name='order',
old_name='payment_id',
new_name='payment',
),
]
| [
"ankitgadewal@hotmail.com"
] | ankitgadewal@hotmail.com |
9d2ecf89e34e3fcd68ce945948faae0d1b839664 | 1bc67a91d85a7106106ca31307ef9ee93f1d1a20 | /src/py/flwr/server/strategy/dpfedavg_fixed.py | 43dc2249736e6cde6e8488d6afaf39ac3b2c9ab4 | [
"Apache-2.0"
] | permissive | adap/flower | 4915d143c674eb675504d585e1e90ed06833812f | 55be690535e5f3feb33c888c3e4a586b7bdbf489 | refs/heads/main | 2023-08-17T01:18:12.168723 | 2023-08-16T17:17:48 | 2023-08-16T17:17:48 | 241,095,326 | 2,999 | 658 | Apache-2.0 | 2023-09-14T15:43:22 | 2020-02-17T11:51:29 | Python | UTF-8 | Python | false | false | 6,995 | py | # Copyright 2020 Adap GmbH. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""DP-FedAvg [McMahan et al., 2018] strategy.
Paper: arxiv.org/pdf/1710.06963.pdf
"""
from typing import Dict, List, Optional, Tuple, Union
from flwr.common import EvaluateIns, EvaluateRes, FitIns, FitRes, Parameters, Scalar
from flwr.common.dp import add_gaussian_noise
from flwr.common.parameter import ndarrays_to_parameters, parameters_to_ndarrays
from flwr.server.client_manager import ClientManager
from flwr.server.client_proxy import ClientProxy
from flwr.server.strategy.strategy import Strategy
class DPFedAvgFixed(Strategy):
"""Wrapper for configuring a Strategy for DP with Fixed Clipping."""
# pylint: disable=too-many-arguments,too-many-instance-attributes
def __init__(
self,
strategy: Strategy,
num_sampled_clients: int,
clip_norm: float,
noise_multiplier: float = 1,
server_side_noising: bool = True,
) -> None:
super().__init__()
self.strategy = strategy
# Doing fixed-size subsampling as in https://arxiv.org/abs/1905.03871.
self.num_sampled_clients = num_sampled_clients
if clip_norm <= 0:
raise Exception("The clipping threshold should be a positive value.")
self.clip_norm = clip_norm
if noise_multiplier < 0:
raise Exception("The noise multiplier should be a non-negative value.")
self.noise_multiplier = noise_multiplier
self.server_side_noising = server_side_noising
def __repr__(self) -> str:
"""Compute a string representation of the strategy."""
rep = "Strategy with DP with Fixed Clipping enabled."
return rep
def _calc_client_noise_stddev(self) -> float:
return float(
self.noise_multiplier * self.clip_norm / (self.num_sampled_clients ** (0.5))
)
def initialize_parameters(
self, client_manager: ClientManager
) -> Optional[Parameters]:
"""Initialize global model parameters using given strategy."""
return self.strategy.initialize_parameters(client_manager)
def configure_fit(
self, server_round: int, parameters: Parameters, client_manager: ClientManager
) -> List[Tuple[ClientProxy, FitIns]]:
"""Configure the next round of training incorporating Differential Privacy (DP).
Configuration of the next training round includes information related to DP,
such as clip norm and noise stddev.
Parameters
----------
server_round : int
The current round of federated learning.
parameters : Parameters
The current (global) model parameters.
client_manager : ClientManager
The client manager which holds all currently connected clients.
Returns
-------
fit_configuration : List[Tuple[ClientProxy, FitIns]]
A list of tuples. Each tuple in the list identifies a `ClientProxy` and the
`FitIns` for this particular `ClientProxy`. If a particular `ClientProxy`
is not included in this list, it means that this `ClientProxy`
will not participate in the next round of federated learning.
"""
additional_config = {"dpfedavg_clip_norm": self.clip_norm}
if not self.server_side_noising:
additional_config[
"dpfedavg_noise_stddev"
] = self._calc_client_noise_stddev()
client_instructions = self.strategy.configure_fit(
server_round, parameters, client_manager
)
for _, fit_ins in client_instructions:
fit_ins.config.update(additional_config)
return client_instructions
def configure_evaluate(
self, server_round: int, parameters: Parameters, client_manager: ClientManager
) -> List[Tuple[ClientProxy, EvaluateIns]]:
"""Configure the next round of evaluation using the specified strategy.
Parameters
----------
server_round : int
The current round of federated learning.
parameters : Parameters
The current (global) model parameters.
client_manager : ClientManager
The client manager which holds all currently connected clients.
Returns
-------
evaluate_configuration : List[Tuple[ClientProxy, EvaluateIns]]
A list of tuples. Each tuple in the list identifies a `ClientProxy` and the
`EvaluateIns` for this particular `ClientProxy`. If a particular
`ClientProxy` is not included in this list, it means that this
`ClientProxy` will not participate in the next round of federated
evaluation.
"""
return self.strategy.configure_evaluate(
server_round, parameters, client_manager
)
def aggregate_fit(
self,
server_round: int,
results: List[Tuple[ClientProxy, FitRes]],
failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
"""Aggregate training results using unweighted aggregation."""
if failures:
return None, {}
# Forcing unweighted aggregation, as in https://arxiv.org/abs/1905.03871.
for _, fit_res in results:
fit_res.num_examples = 1
fit_res.parameters = ndarrays_to_parameters(
add_gaussian_noise(
parameters_to_ndarrays(fit_res.parameters),
self._calc_client_noise_stddev(),
)
)
return self.strategy.aggregate_fit(server_round, results, failures)
def aggregate_evaluate(
self,
server_round: int,
results: List[Tuple[ClientProxy, EvaluateRes]],
failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
) -> Tuple[Optional[float], Dict[str, Scalar]]:
"""Aggregate evaluation losses using the given strategy."""
return self.strategy.aggregate_evaluate(server_round, results, failures)
def evaluate(
self, server_round: int, parameters: Parameters
) -> Optional[Tuple[float, Dict[str, Scalar]]]:
"""Evaluate model parameters using an evaluation function from the strategy."""
return self.strategy.evaluate(server_round, parameters)
| [
"noreply@github.com"
] | adap.noreply@github.com |
cca5b0ff8e93a51f7a513b999bef95ba4627b04e | 9cce59649373fa58104641c71cd31c350dd93836 | /server.py | da1a36dfba16ed41a0df4fb24b1a2fec0b46efe4 | [] | no_license | ravi-oli/hackernews | 21a1f8230367a9fbc556d7c3813186c12da750c4 | fd8ac029ca8536fb94be7853430953e1eb72b4a4 | refs/heads/master | 2022-11-30T22:36:30.030884 | 2020-08-06T14:04:12 | 2020-08-06T14:04:12 | 285,585,600 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,199 | py | # Import libraries
import os
import flask
from flask import request
from google.cloud import bigquery
# Initialize flask application
app_flask = flask.Flask(__name__,
static_url_path="/",
static_folder="./interface")
# Define API route
@app_flask.route("/")
def root():
return app_flask.send_static_file("index.html")
@app_flask.route("/story-details")
def fetch_story_details(methods=['GET']):
# Fetch query parameter
query_params = request.args
story_id = query_params["storyid"]
# Fetch details from DB
# 1. Establish credentials
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "provide-path-to-service-account-credentials.json"
# 2. Establish BQ client
client = bigquery.Client()
# 3. Query
sql_query = """
SELECT
A.id,
A.by,
A.score,
A.title
FROM
`dev-mantarays.HACKERNEWS.stories` as A
WHERE
A.id = {story_id}
"""
# 4. Fetch results
result = list(client.query(sql_query.format(story_id = story_id)))
print(result)
# Return response to
return "Story Id: {}, Published by: {}, Score: {}, Title: {}".format(result[0]['id'],
result[0]['by'], result[0]['score'], result[0]['title']), 200
app_flask.run(port=8000, host='0.0.0.0')
| [
"omrrjcravi@gmail.com"
] | omrrjcravi@gmail.com |
3b5771126a3de74c7f3d369f13baba24a89456bb | 1b300019417ea1e25c59dd6f00fbffb60ec5a123 | /python/example/run_demo.py | 1bcd9cc24764d75872a145135941ce238fefc7d5 | [
"MIT"
] | permissive | Wendong-Huo/diff_stokes_flow | 9176210b162e9a8c7b9910274fe4c699814fa7d7 | 55eb7c0f3a9d58a50c1a09c2231177b81e0da84e | refs/heads/master | 2023-03-16T13:16:17.028974 | 2020-12-11T03:55:44 | 2020-12-11T03:55:44 | 576,797,332 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,729 | py | import sys
sys.path.append('../')
from pathlib import Path
import numpy as np
from importlib import import_module
import scipy.optimize
import time
import matplotlib.pyplot as plt
from tqdm import tqdm
import pickle
import os
from py_diff_stokes_flow.common.common import print_info, print_ok, print_error, print_warning, ndarray
from py_diff_stokes_flow.common.grad_check import check_gradients
from py_diff_stokes_flow.common.display import export_gif
# Update this dictionary if you would like to add new demos.
all_demo_names = {
# ID: (module name, class name).
'amplifier': ('amplifier_env_2d', 'AmplifierEnv2d'),
'flow_averager': ('flow_averager_env_3d', 'FlowAveragerEnv3d'),
'superposition_gate': ('superposition_gate_env_3d', 'SuperpositionGateEnv3d'),
'funnel': ('funnel_env_3d', 'FunnelEnv3d'),
'fluidic_twister': ('fluidic_twister_env_3d', 'FluidicTwisterEnv3d'),
'fluidic_switch': ('fluidic_switch_env_3d', 'FluidicSwitchEnv3d'),
}
if __name__ == '__main__':
# Input check.
if len(sys.argv) != 2:
print_error('Usage: python run_demo.py [demo_name]')
sys.exit(0)
demo_name = sys.argv[1]
assert demo_name in all_demo_names
# Hyperparameters which are loaded from the config file.
config_file_name = 'config/{}.txt'.format(demo_name)
config = {}
with open(config_file_name, 'r') as f:
lines = f.readlines()
for line in lines:
key, val = line.strip().split(':')
key = key.strip()
val = val.strip()
config[key] = val
seed = int(config['seed'])
sample_num = int(config['sample_num'])
solver = config['solver']
rel_tol = float(config['rel_tol'])
max_iter = int(config['max_iter'])
enable_grad_check = config['enable_grad_check'] == 'True'
spp = int(config['spp'])
fps = int(config['fps'])
# Load class.
module_name, env_name = all_demo_names[demo_name]
Env = getattr(import_module('py_diff_stokes_flow.env.{}'.format(module_name)), env_name)
env = Env(seed, demo_name)
# Global search: randomly sample initial guesses and pick the best.
samples = []
losses = []
best_sample = None
best_loss = np.inf
print_info('Randomly sampling initial guesses...')
for _ in tqdm(range(sample_num)):
x = env.sample()
loss, _ = env.solve(x, False, { 'solver': solver })
losses.append(loss)
samples.append(ndarray(x).copy())
if loss < best_loss:
best_loss = loss
best_sample = np.copy(x)
unit_loss = np.mean(losses)
pickle.dump((losses, samples, unit_loss, best_sample), open('{}/sample.data'.format(demo_name), 'wb'))
# Load from file.
losses, _, unit_loss, best_sample = pickle.load(open('{}/sample.data'.format(demo_name), 'rb'))
print_info('Randomly sampled {:d} initial guesses.'.format(sample_num))
print_info('Loss (min, max, mean): ({:4f}, {:4f}, {:4f}).'.format(
np.min(losses), np.max(losses), np.mean(losses)
))
print_info('Normalized loss (min, max, mean): ({:4f}, {:4f}, {:4f}).'.format(
np.min(losses) / unit_loss, np.max(losses) / unit_loss, 1
))
# Local optimization: run L-BFGS from best_sample.
x_init = np.copy(best_sample)
bounds = scipy.optimize.Bounds(env.lower_bound(), env.upper_bound())
def loss_and_grad(x):
t_begin = time.time()
loss, grad, _ = env.solve(x, True, { 'solver': solver })
# Normalize loss and grad.
loss /= unit_loss
grad /= unit_loss
t_end = time.time()
print('loss: {:3.6e}, |grad|: {:3.6e}, time: {:3.6f}s'.format(loss, np.linalg.norm(grad), t_end - t_begin))
return loss, grad
if enable_grad_check:
print_info('Checking gradients...')
# Sanity check gradients.
success = check_gradients(loss_and_grad, x_init)
if success:
print_ok('Gradient check succeeded.')
else:
print_error('Gradient check failed.')
sys.exit(0)
# File index + 1 = len(opt_history).
loss, grad = loss_and_grad(x_init)
opt_history = [(x_init.copy(), loss, grad.copy())]
pickle.dump(opt_history, open('{}/{:04d}.data'.format(demo_name, 0), 'wb'))
def callback(x):
loss, grad = loss_and_grad(x)
global opt_history
cnt = len(opt_history)
print_info('Summary of iteration {:4d}'.format(cnt))
opt_history.append((x.copy(), loss, grad.copy()))
print_info('loss: {:3.6e}, |grad|: {:3.6e}, |x|: {:3.6e}'.format(
loss, np.linalg.norm(grad), np.linalg.norm(x)))
# Save data to the folder.
pickle.dump(opt_history, open('{}/{:04d}.data'.format(demo_name, cnt), 'wb'))
results = scipy.optimize.minimize(loss_and_grad, x_init.copy(), method='L-BFGS-B', jac=True, bounds=bounds,
callback=callback, options={ 'ftol': rel_tol, 'maxiter': max_iter})
if not results.success:
print_warning('Local optimization fails to reach the optimal condition and will return the last solution.')
print_info('Data saved to {}/{:04d}.data.'.format(demo_name, len(opt_history) - 1))
# Load results from demo_name.
cnt = 0
while True:
data_file_name = '{}/{:04d}.data'.format(demo_name, cnt)
if not os.path.exists(data_file_name):
cnt -= 1
break
cnt += 1
data_file_name = '{}/{:04d}.data'.format(demo_name, cnt)
print_info('Loading data from {}.'.format(data_file_name))
opt_history = pickle.load(open(data_file_name, 'rb'))
# Plot the optimization progress.
plt.rc('pdf', fonttype=42)
plt.rc('font', size=18)
plt.rc('axes', titlesize=18)
plt.rc('axes', labelsize=18)
fig = plt.figure(figsize=(18, 12))
ax_loss = fig.add_subplot(121)
ax_grad = fig.add_subplot(122)
ax_loss.set_position((0.12, 0.2, 0.33, 0.6))
iterations = np.arange(len(opt_history))
ax_loss.plot(iterations, [l for _, l, _ in opt_history], color='tab:red')
ax_loss.set_xlabel('Iteration')
ax_loss.set_ylabel('Loss')
ax_loss.set_yscale('log')
ax_loss.grid(True, which='both')
ax_grad.set_position((0.55, 0.2, 0.33, 0.6))
ax_grad.plot(iterations, [np.linalg.norm(g) + np.finfo(np.float).eps for _, _, g in opt_history],
color='tab:green')
ax_grad.set_xlabel('Iteration')
ax_grad.set_ylabel('|Gradient|')
ax_grad.set_yscale('log')
ax_grad.grid(True, which='both')
plt.show()
fig.savefig('{}/progress.pdf'.format(demo_name))
# Render the results.
print_info('Rendering optimization history in {}/'.format(demo_name))
# 000k.png renders opt_history[k], which is also the last element in 000k.data.
cnt = len(opt_history)
for k in range(cnt - 1):
xk0, _, _ = opt_history[k]
xk1, _, _ = opt_history[k + 1]
for i in range(fps):
t = i / fps
xk = (1 - t) * xk0 + t * xk1
env.render(xk, '{:04d}.png'.format(k * fps + i), { 'solver': solver, 'spp': spp })
print_info('{}/mode_[0-9]*/{:04d}.png is ready.'.format(demo_name, k * fps + i))
env.render(opt_history[-1][0], '{:04d}.png'.format((cnt - 1) * fps), { 'solver': solver, 'spp': spp })
print_info('{}/mode_[0-9]*/{:04d}.png is ready.'.format(demo_name, (cnt - 1) * fps))
# Get mode number.
mode_num = 0
while True:
mode_folder = Path(demo_name) / 'mode_{:04d}'.format(mode_num)
if not mode_folder.exists():
break
export_gif(mode_folder, '{}_{:04d}.gif'.format(demo_name, mode_num), fps=fps)
print_info('Video {}_{:04d}.gif is ready.'.format(demo_name, mode_num))
mode_num += 1 | [
"taodu@csail.mit.edu"
] | taodu@csail.mit.edu |
4d1729f71d00955ffc428891f9ef09e4d06f2ef4 | 8221fc863fa51c2723a78888e9af010d056ad7a2 | /WebServer.py | 446cd65e94d061aa6ad9f258fe26bebcb381ef05 | [] | no_license | hxyalee/CS3331 | 87021ef2c5862b4b86b4039bb52d2fe144db8e67 | bcf5082870a082fc4907e684687aa2ffcca02067 | refs/heads/master | 2023-01-23T09:02:20.769727 | 2020-12-05T17:16:21 | 2020-12-05T17:16:21 | 306,234,626 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,108 | py | #!/usr/bin/env python3
import sys
from socket import *
# No valid arguments
try:
if(len(sys.argv) != 2):
raise Exception()
tmp = int(sys.argv[1])
if(type(tmp) != int):
raise Exception()
except Exception:
print("Usage: ./Webserver.py {port}")
exit()
# Extract host and port
server_host = 'localhost'
server_port = int(sys.argv[1])
# Set server's TCP socket
serverSocket = socket(AF_INET, SOCK_STREAM)
serverSocket.bind((server_host, server_port))
serverSocket.listen(1)
# Display that the server is ready
print("--- The server is ready to receive --- \n")
while True:
connectionSocket, addr = serverSocket.accept()
# Get and parse the request; assuming only GET requests
request = connectionSocket.recv(2048).decode('utf-8')
print(request)
request_list = request.split(' ')
# If the method is not a GET request, then return error message
method = request_list[0]
resource = request_list[1]
if(method != "GET"):
header = "HTTP/1.1 405 Method Not Allowed\nContent-Type: " + "text/html" + "\n\n"
message = """<html>\n\t<body>\n\t<h3>Error 405: Method Not Allowed</h3>\n\t</body>\n</html>"""
response = header + message
response = request.encode('utf-8')
connectionSocket.send(response)
connectionSocket.close()
continue
# Parse the requested resource
if(resource == "/"):
resource = 'index.html'
else:
resource = resource[1:]
try:
# Build header for success case
header = "HTTP/1.1 200 OK\n"
# Check the type of the resource
if '.png' in resource.split():
mimetype = 'image/png'
else:
mimetype = 'text/html'
header += "Content-Type " + mimetype + '\n\n'
# Read requested resource to memory
file = open(resource, 'rb')
message = file.read()
file.close()
except Exception:
# File is not found
header = "HTTP/1.1 404 Not Found\nContent-Type: " + "text/html" + "\n\n"
message = """<html>\n<body>\t\n\t\t\n<h3>Error 404: Not Found</h3>\n\t</body>\n</html>""".encode('utf-8')
finally:
response = header.encode('utf-8') + message
connectionSocket.send(response)
connectionSocket.close()
# Close the TCP socket
serverSocket.close() | [
"z5226463@ad.unsw.edu.au"
] | z5226463@ad.unsw.edu.au |
ad614ea6517177899ac56fa3ee0f5c97ebe6eaed | 20e4eb529af631faed63ce213938a3d08c4c4533 | /maxsubarray.py | 87bdfc8a9df0415b413842f59ca45967c401c2a9 | [] | no_license | mmarat01/leet | 0c4ac88bcec5fc9c35769f151a10a0d588e30ed3 | fb7a41524b51f5fd08460acdde9a5fc44713583e | refs/heads/master | 2023-04-09T05:08:34.948408 | 2021-04-03T16:14:30 | 2021-04-03T16:14:30 | 319,825,195 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,102 | py | from typing import List
# Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
'''
traverse list starting from second element because
first element added to sum is the first element in array
we keep a moving sum ("up to this point"), defined as the maximum
of the previous moving sum + current number OR the current number alone.
the reason why we'd reset to the current number alone is because by
keeping track of the moving contiguous sum, if a new element is greater than
the whole thing, that must be the start of the new max subarray.
with negative numbers, there could potentially be a scenario where both
"curr_sum + curr_num" or "curr_num" are smaller than the sum that had been
found before.
* say you have a current sum of "-2", and the next number is "-4"
-2 + -4 = -6
so -4 it is --> new current sum, and smaller than the prev
that's why we want to keep track of the greatest "current sum"! if it
were all positives this would be trivial; you'd add them all up.
'''
if len(nums) == 1:
return nums[0]
curr_sum = max_sum = nums[0]
'''
cool syntax i should prob use
for i in nums[1:]:
curr_sum = max(curr_sum + i, i)
max_sum = max(max_sum, curr_sum)
'''
for i in range(1, len(nums)):
if curr_sum + nums[i] < nums[i]:
curr_sum = nums[i]
else:
curr_sum += nums[i]
if curr_sum > max_sum:
max_sum = curr_sum
return max_sum
s = Solution()
print(s.maxSubArray([-2,1,-3,4,-1,2,1,-5,4])) # 6
print(s.maxSubArray([0])) # 0
print(s.maxSubArray([-1])) # -1
print(s.maxSubArray([-2147483647])) # -2147483647 | [
"66384102+mmarat01@users.noreply.github.com"
] | 66384102+mmarat01@users.noreply.github.com |
c3003bd895edb9bdabce1c019fd28d0ab153b7af | 5e255845c19689f598d9221c7542df60e85f5923 | /setup.py | 01108ddb79b16904ea2ca5f26ffbb9cf402398ee | [
"MIT"
] | permissive | hulsmeier/best_voxelnet_ever | 48023522e109fa263622536b343ee6b310057856 | aeefd32711a5c986c6099d53c5a2efdf9e01ea48 | refs/heads/master | 2021-06-13T03:27:49.944036 | 2020-06-03T18:35:47 | 2020-06-03T18:35:47 | 254,420,901 | 0 | 0 | MIT | 2020-04-09T16:16:11 | 2020-04-09T16:16:09 | null | UTF-8 | Python | false | false | 427 | py | #!/usr/bin/env python
# -*- coding:UTF-8 -*-
# File Name : setup.py
# Purpose :
# Creation Date : 11-12-2017
# Last Modified : Sat 23 Dec 2017 03:18:37 PM CST
# Created By : Jeasine Ma [jeasinema[at]gmail[dot]com]
from distutils.core import setup
from Cython.Build import cythonize
import numpy
setup(
name='box overlaps',
ext_modules=cythonize('./utils/box_overlaps.pyx'),
include_dirs=[numpy.get_include()]
)
| [
"fschaeffler@gmx.de"
] | fschaeffler@gmx.de |
73dde30ee3e5e9b336b4af24f9c38c43d0e0cf60 | a5698f82064aade6af0f1da21f504a9ef8c9ac6e | /huaweicloud-sdk-cce/huaweicloudsdkcce/v3/region/cce_region.py | 8075aff2ddabc7a62cba30087f4176a99207fa16 | [
"Apache-2.0"
] | permissive | qizhidong/huaweicloud-sdk-python-v3 | 82a2046fbb7d62810984399abb2ca72b3b47fac6 | 6cdcf1da8b098427e58fc3335a387c14df7776d0 | refs/heads/master | 2023-04-06T02:58:15.175373 | 2021-03-30T10:47:29 | 2021-03-30T10:47:29 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,907 | py | # coding: utf-8
import types
from huaweicloudsdkcore.region.region import Region
class CceRegion:
def __init__(self):
pass
CN_NORTH_1 = Region(id="cn-north-1", endpoint="https://cce.cn-north-1.myhuaweicloud.com")
CN_NORTH_4 = Region(id="cn-north-4", endpoint="https://cce.cn-north-4.myhuaweicloud.com")
CN_SOUTH_1 = Region(id="cn-south-1", endpoint="https://cce.cn-south-1.myhuaweicloud.com")
CN_EAST_2 = Region(id="cn-east-2", endpoint="https://cce.cn-east-2.myhuaweicloud.com")
CN_EAST_3 = Region(id="cn-east-3", endpoint="https://cce.cn-east-3.myhuaweicloud.com")
CN_SOUTHWEST_2 = Region(id="cn-southwest-2", endpoint="https://cce.cn-southwest-2.myhuaweicloud.com")
AP_SOUTHEAST_1 = Region(id="ap-southeast-1", endpoint="https://cce.ap-southeast-1.myhuaweicloud.com")
AP_SOUTHEAST_2 = Region(id="ap-southeast-2", endpoint="https://cce.ap-southeast-2.myhuaweicloud.com")
AP_SOUTHEAST_3 = Region(id="ap-southeast-3", endpoint="https://cce.ap-southeast-3.myhuaweicloud.com")
AF_SOUTH_1 = Region(id="af-south-1", endpoint="https://cce.af-south-1.myhuaweicloud.com")
static_fields = types.MappingProxyType({
"cn-north-1": CN_NORTH_1,
"cn-north-4": CN_NORTH_4,
"cn-south-1": CN_SOUTH_1,
"cn-east-2": CN_EAST_2,
"cn-east-3": CN_EAST_3,
"cn-southwest-2": CN_SOUTHWEST_2,
"ap-southeast-1": AP_SOUTHEAST_1,
"ap-southeast-2": AP_SOUTHEAST_2,
"ap-southeast-3": AP_SOUTHEAST_3,
"af-south-1": AF_SOUTH_1,
})
@staticmethod
def value_of(region_id, static_fields=static_fields):
if region_id is None or len(region_id) == 0:
raise KeyError("Unexpected empty parameter: region_id.")
if not static_fields.get(region_id):
raise KeyError("Unexpected region_id: " + region_id)
return static_fields.get(region_id)
| [
"hwcloudsdk@huawei.com"
] | hwcloudsdk@huawei.com |
504f0658b7b7f9ae808c5d819daa2760c8f38d06 | f953784405bc32ea61c770664edeb534459f33d9 | /Shmup/main.py | d35d8c9c1ed44df5f28031ea5a63ccdd1bd83728 | [] | no_license | JLew15/Python | 7ba060baf71cefcf20fe0566b7a6f380134be550 | e735bacb2de433788bf173e9e8d50a187159e1c3 | refs/heads/master | 2023-04-28T06:36:55.734871 | 2021-05-11T15:47:49 | 2021-05-11T15:47:49 | 293,847,388 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 8,275 | py | import pygame as pg
import random as r
import math
from os import *
# Code written by Jaiden Lewis
# Artwork Credit Kenney.nl or www.kenney.nl
class Explosion(pg.sprite.Sprite):
def __init__(self, center):
super(Explosion, self).__init__()
self.image = explosionAnimation["lg"][0]
self.rect = self.image.get_rect()
self.rect.center = center
self.frame = 0
self.lastUpdate = pg.time.get_ticks()
self.frameRate = 50
def update(self):
now = pg.time.get_ticks()
if now - self.lastUpdate > self.frameRate:
self.lastUpdate = now
self.frame += 1
if self.frame == len(explosionAnimation["lg"]):
self.kill()
else:
center = self.rect.center
self.image = explosionAnimation["lg"][self.frame]
self.rect = self.image.get_rect()
self.rect.center = center
class Projectile(pg.sprite.Sprite):
def __init__(self, x, y):
super(Projectile, self).__init__()
# self.image = pg.Surface((5, 5))
# self.image.fill(WHITE)
self.image = bulletImg
self.image = pg.transform.scale(bulletImg, (5, 10))
self.rect = self.image.get_rect()
self.rect.centerx = x
self.rect.bottom = y - 1
self.speedY = -5
def update(self):
self.rect.y += self.speedY
if self.rect.bottom < 0:
self.kill()
class Player(pg.sprite.Sprite):
def __init__(self):
super(Player, self).__init__()
# self.image = pg.Surface((50, 40))
# self.image.fill(GREEN)
self.image = playerImg
self.image = pg.transform.scale(playerImg, (50, 40))
self.rect = self.image.get_rect()
self.rect.centerx = (WIDTH / 2)
self.rect.bottom = (HEIGHT - (HEIGHT * .05))
self.speedX = 0
self.shootDelay = 250
self.lastShot = pg.time.get_ticks()
def update(self):
self.speedX = 0
if self.rect.left < 0:
self.rect.left = 0
if self.rect.right > WIDTH:
self.rect.right = WIDTH
keystate = pg.key.get_pressed()
if keystate[pg.K_LEFT] or keystate[pg.K_a]:
self.speedX = -3
if keystate[pg.K_RIGHT] or keystate[pg.K_d]:
self.speedX = 3
if keystate[pg.K_SPACE]:
self.shoot()
self.rect.x += self.speedX
def shoot(self):
now = pg.time.get_ticks()
if now - self.lastShot > self.shootDelay:
self.lastShot = now
shootAudio.play()
bullet = Projectile(self.rect.centerx, self.rect.top)
projectileGroup.add(bullet)
allSprites.add(bullet)
class Mob(pg.sprite.Sprite):
def __init__(self):
super(Mob, self).__init__()
# self.image = pg.Surface((25, 25))
# self.image.fill(RED)
self.imageO = mobImg
self.imageO = pg.transform.scale(mobImg, (25, 25))
self.image = self.imageO.copy()
self.rect = self.image.get_rect()
self.rect.centerx = r.randint(13, WIDTH - 13)
self.rect.top = 0
self.speedY = r.randint(1, 10)
self.speedX = r.randint(-3, 3)
self.last_update = pg.time.get_ticks()
self.rot = 0
self.rotSpeed = r.randint(-8, 8)
def rotate(self):
now = pg.time.get_ticks()
if now - self.last_update > 60:
self.last_update = now
self.rot = (self.rot + self.rotSpeed) % 360
newImage = pg.transform.rotate(self.imageO, self.rot)
oldCenter = self.rect.center
self.image = newImage
self.rect = self.image.get_rect()
self.rect.center = oldCenter
def update(self):
self.rotate()
if self.rect.top > HEIGHT:
self.rect.top = 0
self.rect.centerx = r.randint(13, WIDTH - 13)
self.speedY = r.randint(1, 10)
self.speedX = r.randint(-3, 3)
self.rect.x += self.speedX
self.rect.y += self.speedY
def spawnNPC(self):
npc = Mob()
mobGroup.add(npc)
allSprites.add(npc)
# Game Constants
#################################
HEIGHT = 600
WIDTH = 300
FPS = 60
TITLE = "Shoot Em Up"
playerLives = 5
playerScore = 0
fontName = pg.font.match_font("arial")
# COLORS
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
YELLOW = (255, 255, 0)
PURPLE = (255, 0, 255)
TURQUOISE = (0, 255, 255)
SKYBLUE = (123, 255, 255)
PASTELGREEN = (123, 255, 123)
#################################
# Init Folders
#################################
gameFolder = path.dirname(__file__)
imgs = path.join(gameFolder, "img")
saveData = path.join(gameFolder, "data")
aud = path.join(gameFolder, "aud")
playerimgs = path.join(imgs, "player")
mobimgs = path.join(imgs, "mob")
bgimg = path.join(imgs, "bg")
anim = path.join(imgs, "ani")
print(imgs)
#################################
# Init pygame and create window
#################################
pg.init()
pg.mixer.init()
screen = pg.display.set_mode((WIDTH, HEIGHT))
pg.display.set_caption(TITLE)
clock = pg.time.Clock()
#################################
# Load images
#################################
bg = pg.image.load(bgimg + "/bg.png")
bgRect = bg.get_rect()
playerImg = pg.image.load(playerimgs + "/shooter.png")
playerRect = playerImg.get_rect()
bulletImg = pg.image.load(playerimgs + "/shot.png")
bulletRect = bulletImg.get_rect()
mobImg = pg.image.load(mobimgs + "/shooting.png")
mobRect = mobImg.get_rect()
explosionAnimation = {"lg": []}
for i in range(0, 8):
fn = "regularExplosion0{}.png".format(i)
img = pg.image.load(path.join(anim, fn)).convert()
img.set_colorkey(BLACK)
img = pg.transform.scale(img, (40, 40))
explosionAnimation["lg"].append(img)
#################################
# Sprite Groups
#################################
allSprites = pg.sprite.Group()
playerGroup = pg.sprite.Group()
mobGroup = pg.sprite.Group()
projectileGroup = pg.sprite.Group()
#################################
# Create Game Obj
#################################
player1 = Player()
mob1 = Mob()
for i in range(10):
mob1.spawnNPC()
#################################
# Add Obj to Sprite Groups
#################################
player1.add(playerGroup)
mob1.add(mobGroup)
for sprite in playerGroup:
sprite.add(allSprites)
for sprite in mobGroup:
sprite.add(allSprites)
#################################
shootAudio = pg.mixer.Sound(aud + "/sfx_wpn_laser2.wav")
def drawText(surf, text, size, x, y):
font = pg.font.Font(fontName, size)
txtSurface = font.render(text, True, WHITE)
textRect = txtSurface.get_rect()
textRect.midtop = (x, y)
surf.blit(txtSurface, textRect)
def drawHB(surf, x, y, pct):
if pct < 0:
pct = 0
barLength = 100
barHeight = 10
fill = (pct/100) * barLength
# Game loop
#################################
running = True
while running:
# Timing
#######
clock.tick(FPS)
#######
# Input
#######
for event in pg.event.get():
if event.type == pg.KEYDOWN:
if event.key == pg.K_ESCAPE:
running = False
if event.type == pg.QUIT:
running = False
#######
# Updates
#######
allSprites.update()
hits = pg.sprite.spritecollide(player1, mobGroup, True)
for hit in hits:
print("Player hit")
mob1.spawnNPC()
playerLives -= 1
playerScore -= 10
exp = Explosion(hit.rect.center)
allSprites.add(exp)
if playerLives <= 0:
player1.kill()
hits = pg.sprite.groupcollide(projectileGroup, mobGroup, True, True)
for hit in hits:
mob1.spawnNPC()
exp = Explosion(hit.rect.center)
allSprites.add(exp)
playerScore += 5
if playerScore % 100 == 0:
playerLives += 1
print("LIFE GAINED")
#######
# Render
#######
screen.fill(BLACK)
screen.blit(bg, bgRect)
allSprites.draw(screen)
drawText(screen,"Score: " + str(playerScore), 18, WIDTH/2, 10)
pg.display.flip()
#######
pg.quit()
#################################
| [
"zombears@icloud.com"
] | zombears@icloud.com |
dbbab268c0f12ac2bcfab7eab23967dd84e060e4 | 0252a277036b9ac7f95e5db3cad6c1a94b89c4ef | /eaif4_ws/build/turtlebot_apps/turtlebot_rapps/catkin_generated/pkg.installspace.context.pc.py | 5910a9329ceee27595e6b34e8f4452ce3011c710 | [] | no_license | maxwelldc/lidar_slam | 1e5af586cd2a908474fa29224b0d9f542923c131 | 560c8507ea1a47844f9ce6059f48937b0627967b | refs/heads/master | 2020-07-01T03:15:42.877900 | 2019-08-07T10:25:27 | 2019-08-07T10:25:27 | 201,025,062 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 378 | py | # generated from catkin/cmake/template/pkg.context.pc.in
CATKIN_PACKAGE_PREFIX = ""
PROJECT_PKG_CONFIG_INCLUDE_DIRS = "".split(';') if "" != "" else []
PROJECT_CATKIN_DEPENDS = "".replace(';', ' ')
PKG_CONFIG_LIBRARIES_WITH_PREFIX = "".split(';') if "" != "" else []
PROJECT_NAME = "turtlebot_rapps"
PROJECT_SPACE_DIR = "/home/wenhou/eaif4_ws/install"
PROJECT_VERSION = "2.3.7"
| [
"374931377@qq.com"
] | 374931377@qq.com |
c42484aa0e251a858cba80f1b7cbda8c5b61ad40 | b6fa182321756b891b84958e2b2c01e63b3f88b2 | /stepik/product _of_numbers.py | 61d44cf81b636fd8b2f1484dd3cedb783f9c8444 | [] | no_license | carden-code/python | 872da0dff5466070153cf945c428f1bc8309ea2b | 64e4df0d9893255ad362a904bb5d9677a383591c | refs/heads/master | 2023-07-05T05:14:16.479392 | 2021-08-22T21:27:36 | 2021-08-22T21:27:36 | 305,476,509 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,546 | py | # Напишите программу для определения, является ли число произведением двух чисел из данного набора,
# выводящую результат в виде ответа «ДА» или «НЕТ».
#
# Формат входных данных
# В первой строке подаётся число n, (0 < n < 1000) – количество чисел в наборе.
# В последующих n строках вводятся целые числа, составляющие набор (могут повторяться).
# Затем следует целое число, которое является или не является произведением двух каких-то чисел из набора.
#
# Формат выходных данных
# Программа должна вывести «ДА» или «НЕТ» в соответствии с условием задачи.
#
# Примечание.
# Само на себя число из набора умножиться не может, другими словами, два множителя должны иметь разные номера в наборе.
amount_numbers = int(input())
numbers_list = [int(input()) for _ in range(amount_numbers)]
product = int(input())
yes = False
for index, num in enumerate(numbers_list):
for i, n in enumerate(numbers_list):
if index != i and num * n == product:
yes = True
print('ДА' if yes else 'НЕТ')
| [
"carden.ruby@gmail.com"
] | carden.ruby@gmail.com |
4c005fbd4e54f24c9b1a2f8d6364a336338e0c60 | 0fd5793e78e39adbfe9dcd733ef5e42390b8cc9a | /python3/19_Concurrency_and_Parallel_Programming/02_multiprocessing/example2.py | b775c924c64d2785f7f994c9c8c606e50a2ae97e | [] | no_license | udhayprakash/PythonMaterial | 3ea282ceb4492d94d401e3bc8bad9bf6e9cfa156 | e72f44e147141ebc9bf9ec126b70a5fcdbfbd076 | refs/heads/develop | 2023-07-08T21:07:33.154577 | 2023-07-03T10:53:25 | 2023-07-03T10:53:25 | 73,196,374 | 8 | 5 | null | 2023-05-26T09:59:17 | 2016-11-08T14:55:51 | Jupyter Notebook | UTF-8 | Python | false | false | 1,073 | py | import collections
import multiprocessing as mp
Msg = collections.namedtuple("Msg", ["event", "args"])
class BaseProcess(mp.Process):
"""A process backed by an internal queue for simple one-way message passing."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queue = mp.Queue()
def send(self, event, *args):
"""Puts the event and args as a `Msg` on the queue"""
msg = Msg(event, args)
self.queue.put(msg)
def dispatch(self, msg):
event, args = msg
handler = getattr(self, "do_%s" % event, None)
if not handler:
raise NotImplementedError("Process has no handler for [%s]" % event)
handler(*args)
def run(self):
while True:
msg = self.queue.get()
self.dispatch(msg)
# usage
class MyProcess(BaseProcess):
def do_helloworld(self, arg1, arg2):
print(arg1, arg2)
if __name__ == "__main__":
process = MyProcess()
process.start()
process.send("helloworld", "hello", "world")
| [
"uday3prakash@gmail.com"
] | uday3prakash@gmail.com |
f10cdd86dd40f18b8d7c02cf3eabfd28b6204cf2 | 9f61f361a545825dd6ff650c2d81bc4d035649bd | /tests/test_document.py | e95f63d807e367b91125f2d53fc4b1218a64b17d | [
"MIT"
] | permissive | cassj/dexy | 53c9e7ce3f601d9af678816397dcaa3a111ba670 | fddfeb4db68c362a4126f496dbd019f4639d07ba | refs/heads/master | 2020-12-25T11:52:35.144908 | 2011-06-05T20:52:52 | 2011-06-05T20:52:52 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,699 | py | from dexy.controller import Controller
from dexy.document import Document
from dexy.artifacts.file_system_json_artifact import FileSystemJsonArtifact
import os
def setup_controller():
controller = Controller()
controller.artifacts_dir = 'artifacts'
if not os.path.isdir(controller.artifacts_dir):
os.mkdir(controller.artifacts_dir)
controller.artifact_class = FileSystemJsonArtifact
controller.allow_remote = True
controller.config = {
'tests/data' : {
"@simple.py|pyg" : {
"contents" : "x = 5\nx^2"
}
}
}
controller.setup_and_run()
return controller
def setup_doc():
controller = setup_controller()
doc = controller.members['tests/data/simple.py|pyg']
assert isinstance(doc, Document)
return doc
def setup_artifact():
doc = setup_doc()
return doc.final_artifact()
def test_artifact_hash_dict():
artifact = setup_artifact()
hash_dict = artifact.hash_dict()
for k in hash_dict.keys():
assert k in artifact.HASH_WHITELIST
# hashstring shouldn't change
hashstring = artifact.hashstring
artifact.set_hashstring
assert artifact.hashstring == hashstring
def test_init():
"""document: filters should be processed correctly"""
doc = Document(FileSystemJsonArtifact, "data/test.py|abc")
assert doc.name == "data/test.py"
assert doc.filters == ['abc']
doc.filters += ['def', 'xyz']
assert doc.filters == ['abc', 'def', 'xyz']
assert doc.key() == "data/test.py|abc|def|xyz"
def test_complete():
"""document: after controller has run"""
doc = setup_doc()
assert doc.key() == "tests/data/simple.py|pyg"
| [
"ana@ananelson.com"
] | ana@ananelson.com |
0d87632a4b2c03e675bb8726a5f7622be7f35e49 | 06e897ed3b6effc280eca3409907acc174cce0f5 | /plugins/pelican_unity_webgl/config.py | d7250678123196715136c46cfa982901234d38d6 | [
"LicenseRef-scancode-other-permissive",
"MIT",
"AGPL-3.0-only"
] | permissive | JackMcKew/jackmckew.dev | ae5a32da4f1b818333ae15c6380bca1329d38f1e | b5d68070b6f15677a183424c84e30440e128e1ea | refs/heads/main | 2023-09-02T14:42:19.010294 | 2023-08-15T22:08:19 | 2023-08-15T22:08:19 | 213,264,451 | 15 | 8 | MIT | 2023-02-14T21:50:28 | 2019-10-07T00:18:15 | JavaScript | UTF-8 | Python | false | false | 201 | py | # unity webgl options
DEFAULT_WIDTH = 960
DEFAULT_HEIGHT = 600
DEFAULT_ALIGN = "center"
# paths
GAMES_ROOT_DIR = "/games" # directory with games
TEMPLATE_PATH = "/games/utemplate" # template path
| [
"jackmckew2@gmail.com"
] | jackmckew2@gmail.com |
aeb31cb150012236b10aba55815c798a1a949273 | f559186ea67099b0a58a0e99c17aec291fd941e6 | /inscription/models/Contacts.py | ed32fa0c89f0980aaaca7c689f096372e10adb0b | [] | no_license | JairoDuarte/inscriptionLP | 611f17e9a03d1a0f25d862803d924622a95be501 | 2312d79b9f3f952691a7a529257e5f45175838e5 | refs/heads/master | 2020-05-25T18:16:02.494195 | 2017-09-09T10:52:10 | 2017-09-09T10:52:10 | 84,953,040 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,076 | py | from __future__ import unicode_literals
from django.db import models
from django.utils.translation import ugettext as _
from .Candidat import Candidat
class Contacts(models.Model):
candidat = models.OneToOneField(
Candidat,
on_delete=models.CASCADE,
verbose_name=_('Candidatinfo')
)
email = models.EmailField(
_('Email'),
max_length=80,
unique=True)
portable_phone = models.CharField(
_('Telephone portable'),
max_length=20,
unique=True)
fixe_phone = models.CharField(
_('Telephone fixe'),
max_length=20,
blank=True)
adresse = models.CharField(
_('adresse de résidence'),
max_length=255)
ville = models.CharField(
_('Ville de résidence'),
max_length=100)
pays = models.CharField(
_('pays de résidence'),
max_length=100)
def __str__(self):
return self.adresse + self.ville + "-" + self.pays
class Meta:
verbose_name_plural = 'contacts'
db_table = "contacts"
| [
"alfredojairo17@hotmail.com"
] | alfredojairo17@hotmail.com |
e87625a78f32a96dadb585f31cd7212e2872e95d | 2cd2746c16e0435d57282cac463da4969dc098ac | /metricas.py | 16dcd91c8c1a80470f05b747cbfaf8f813e9a8d0 | [] | no_license | joseallones/Flex | 06a4a1bad454eab28e841dbfe027b2f0c7751e9b | 363a185d6359c05452bbb203781c14fd387066df | refs/heads/master | 2023-03-11T21:48:09.491721 | 2021-02-16T19:11:04 | 2021-02-16T19:11:04 | 294,165,187 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,968 | py |
import os
#Do traducido automáticamente mira canto é de wordnet e canto de mymemmory
termos = 0
num_total_traducidos_gl_wordnet = 0
num_total_traducidos_pt_wordnet = 0
num_total_traducidos_gl_mymemmory = 0
num_total_traducidos_pt_mymemmory = 0
def obtenInfoPaqueteDoCsv(path_file):
global termos
global num_total_traducidos_gl_wordnet
global num_total_traducidos_pt_wordnet
global num_total_traducidos_gl_mymemmory
global num_total_traducidos_pt_mymemmory
f = open(path_file, encoding='utf-8')
for line in f:
print("\nLine: " + line.strip())
if("ili\tlema" in line):
continue
termos += 1
data_line = line.rstrip().split('\t')
print("data_line: " + str(data_line))
if(data_line[2]!='[]'):
num_total_traducidos_pt_wordnet += 1
if (data_line[3] != '[]'):
num_total_traducidos_gl_wordnet += 1
if (data_line[4] != '[]'):
print("data_line: " + data_line[4])
num_total_traducidos_pt_mymemmory += 1
if (data_line[5] != '[]'):
num_total_traducidos_gl_mymemmory += 1
rutaDirectorio = "/home/jose/PycharmProjects/Flex/paquete/output/" #RUTA SALIDA
if(os.path.isdir(rutaDirectorio)):
for file in os.listdir(rutaDirectorio):
if(file.endswith("servizoweb.xlsx")):
print(file)
rutaFichero = os.path.join(rutaDirectorio, file)
infoPaquete = obtenInfoPaqueteDoCsv(rutaFichero)
print(termos)
print(num_total_traducidos_pt_wordnet)
print(num_total_traducidos_gl_wordnet)
print(num_total_traducidos_pt_mymemmory)
print(num_total_traducidos_gl_mymemmory)
print(num_total_traducidos_pt_wordnet + num_total_traducidos_pt_mymemmory)
print(num_total_traducidos_gl_wordnet + num_total_traducidos_gl_mymemmory)
print('\n\nTotal')
print("num_total_termos " + str(termos))
print("num_total_traducidos_pt_wordnet " + str(num_total_traducidos_pt_wordnet ) + "\t" + str(num_total_traducidos_pt_wordnet * 100 / termos))
print("num_total_traducidos_gl_wordnet " + str(num_total_traducidos_gl_wordnet) + "\t" + str(num_total_traducidos_gl_wordnet * 100 / termos))
print("num_total_traducidos_pt_mymemmory " + str(num_total_traducidos_pt_mymemmory) + "\t" + str(num_total_traducidos_pt_mymemmory * 100 / termos))
print("num_total_traducidos_gl_mymemmory " + str(num_total_traducidos_gl_mymemmory) + "\t" + str(num_total_traducidos_gl_mymemmory * 100 / termos))
print("num_total_traducidos_pt " + str(num_total_traducidos_pt_wordnet + num_total_traducidos_pt_mymemmory) + "\t" + str((num_total_traducidos_pt_wordnet + num_total_traducidos_pt_mymemmory) * 100 / termos))
print("num_total_traducidos_gl " + str(num_total_traducidos_gl_wordnet + num_total_traducidos_gl_mymemmory) + "\t" + str((num_total_traducidos_gl_wordnet + num_total_traducidos_gl_mymemmory) * 100 / termos))
| [
"joseallones87@gmail.com"
] | joseallones87@gmail.com |
07051b2b2d87f429737993fa6057c7d0ccc452f6 | ef914133e0ade675ae201f7895c50d819180951b | /attacks_SF.py | 42181fb80340a753a0c25e769c15a8c2ee56057c | [] | no_license | vpahari/biconn | b094d6e7e6270f7601fde7de2f4d4528cd80aa20 | fd2259dfeb73a39bbdd4e616700f912cec8f17cf | refs/heads/master | 2021-06-01T18:54:09.477458 | 2020-09-22T14:49:48 | 2020-09-22T14:49:48 | 136,077,333 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 20,686 | py | import networkx as nx
import networkit as nk
import random
import sys
import math
from functools import reduce
import csv
from operator import itemgetter
import matplotlib.pyplot as plt
plt.switch_backend('agg')
import pickle
import igraph as ig
import numpy as np
import os
import itertools
def get_name_WS(initial_name, dim, size, nei, p, SEED,radius):
return initial_name + "_dim_" + str(dim) + "_size_" + str(size) + "_nei_" + str(nei) + "_p_" + str(p) + "_SEED_" + str(SEED) + "_radius_" + str(radius) + "_" + ".pickle"
def get_name_ER(initial_name, N, k, SEED,radius):
return initial_name + "_N_" + str(N) + "_k_" + str(k) + "_SEED_" + str(SEED) + "_radius_" + str(radius) + "_" + ".pickle"
def get_name_SF(initial_name,N,k,exp_out,SEED,radius):
return initial_name + "_N_" + str(N) + "_k_" + str(k) + "_expout_" + str(exp_out) + "_SEED_" + str(SEED) + "_radius_" + str(radius) + "_" + ".pickle"
def make_WS_graph(dim,size,nei,p,SEED):
N = size ** dim
random.seed(SEED)
igG = ig.Graph.Watts_Strogatz(dim,size,nei,p)
allEdges = igG.get_edgelist()
fixed_G = nx.Graph()
listOfNodes = [i for i in range(N)]
fixed_G.add_nodes_from(listOfNodes)
fixed_G.add_edges_from(allEdges)
G_nk = nk.nxadapter.nx2nk(fixed_G)
return G_nk
def make_SF_Graph(N,k,exp_out,SEED):
random.seed(SEED)
num_edges = int((N * k) / 2)
igG = ig.Graph.Static_Power_Law(N,num_edges,exp_out)
allEdges = igG.get_edgelist()
fixed_G = nx.Graph()
listOfNodes = [i for i in range(N)]
fixed_G.add_nodes_from(listOfNodes)
fixed_G.add_edges_from(allEdges)
G_nk = nk.nxadapter.nx2nk(fixed_G)
return G_nk
def make_ER_Graph(N,k,SEED):
G_nx = nx.erdos_renyi_graph(N, k/(N-1), seed = SEED)
G_nk = nk.nxadapter.nx2nk(G_nx)
return G_nk
def DA_attack(G_copy,num_nodes_to_remove):
G = copy_graph(G_copy)
GC_List = []
GC_List.append(get_GC(G))
degree = nk.centrality.DegreeCentrality(G)
degree.run()
degree_sequence = degree.ranking()
random.shuffle(degree_sequence)
degree_sequence.sort(key = itemgetter(1), reverse = True)
for i in range(num_nodes_to_remove):
node_to_remove = degree_sequence[i][0]
G.removeNode(node_to_remove)
GC_List.append(get_GC(G))
return GC_List
def ADA_attack(G_copy,num_nodes_to_remove):
G = copy_graph(G_copy)
GC_List = []
GC_List.append(get_GC(G))
for i in range(num_nodes_to_remove):
print(i)
degree = nk.centrality.DegreeCentrality(G)
degree.run()
degree_sequence = degree.ranking()
random.shuffle(degree_sequence)
degree_sequence.sort(key = itemgetter(1), reverse = True)
node_to_remove = degree_sequence[0][0]
G.removeNode(node_to_remove)
GC_List.append(get_GC(G))
return GC_List
def BA_attack(G_copy,num_nodes_to_remove):
G = copy_graph(G_copy)
GC_List = []
GC_List.append(get_GC(G))
between = nk.centrality.DynBetweenness(G)
between.run()
between_sequence = between.ranking()
random.shuffle(between_sequence)
between_sequence.sort(key = itemgetter(1), reverse = True)
for i in range(num_nodes_to_remove):
node_to_remove = between_sequence[i][0]
G.removeNode(node_to_remove)
GC_List.append(get_GC(G))
return GC_List
def ABA_attack(G_copy,num_nodes_to_remove):
G = copy_graph(G_copy)
GC_List = []
GC_List.append(get_GC(G))
for i in range(num_nodes_to_remove):
print(i)
between = nk.centrality.DynBetweenness(G)
between.run()
between_sequence = between.ranking()
between_sequence.sort(key = itemgetter(1), reverse = True)
node_to_remove = between_sequence[0][0]
G.removeNode(node_to_remove)
GC_List.append(get_GC(G))
return GC_List
def RA_attack(G_copy,num_nodes_to_remove):
G = copy_graph(G_copy)
GC_List = []
GC_List.append(get_GC(G))
all_nodes = random.sample(list(G.nodes()),num_nodes_to_remove)
for i in all_nodes:
G.removeNode(i)
GC_List.append(get_GC(G))
return GC_List
def big_RA_attack(G_copy,num_nodes_to_remove,num_sims):
big_GC_List = []
for i in range(num_sims):
GC_list = RA_attack(G_copy,num_nodes_to_remove)
big_GC_List.append(GC_list)
avg_list = get_avg_list(big_GC_List)
return avg_list
def get_betweenness_score(G, node):
between = nk.centrality.DynBetweenness(G)
between.run()
return between.score(node)
def get_degree_score(G,node):
return G.degree(node)
def get_coreness_score(G,node):
coreness = nk.centrality.CoreDecomposition(G)
coreness.run()
partition = coreness.getPartition()
core_number = partition.subsetOf(node)
return core_number
def get_betweenness_score_list(G, node_list):
between = nk.centrality.DynBetweenness(G)
between.run()
final_list = []
for node in node_list:
final_list.append(between.score(node))
return final_list
def get_degree_score_list(G,node_list):
final_list = []
for node in node_list:
final_list.append(G.degree(node))
return final_list
def get_coreness_score_list(G,node_list):
coreness = nk.centrality.CoreDecomposition(G)
coreness.run()
final_list = []
partition = coreness.getPartition()
for node in node_list:
final_list.append(partition.subsetOf(node))
return final_list
def add_into_set(s,new_s):
for i in new_s:
s.add(i)
return s
def take_out_list(dBall, ball):
new_list = []
for i in dBall:
if i in ball:
continue
new_list.append(i)
return new_list
#change this such that the neighbors are diff
def get_dBN(G,node,radius):
dBall = set([node])
ball = set([node])
for i in range(radius):
neighbor = []
for j in dBall:
for n in G.neighbors(j):
if n in ball:
continue
neighbor.append(n)
ball = add_into_set(ball,neighbor)
dBall = set(neighbor.copy())
return (list(dBall),list(ball))
def get_all_dBN(G,radius):
all_nodes = get_GC_nodes(G)
dict_nodes_dBall = {}
dict_nodes_ball = {}
dict_nodes_x_i = {}
for n in all_nodes:
(dBall,ball) = get_dBN(G,n,radius)
dict_nodes_dBall[n] = len(dBall)
dict_nodes_ball[n] = len(ball)
dict_nodes_x_i[n] = len(dBall) / len(ball)
return (dict_nodes_dBall,dict_nodes_ball,dict_nodes_x_i)
def make_partitions(dict_nodes_x_i, step_size):
counter = 0
values_list = list(dict_nodes_x_i.values())
num_partitions = int(1 / step_size)
all_values = [0 for i in range(num_partitions)]
for i in values_list:
box_to_put = int(i / step_size)
if box_to_put == num_partitions:
all_values[-1] = all_values[-1] + 1
continue
all_values[box_to_put] = all_values[box_to_put] + 1
return all_values
def get_all_same_x_i(sorted_list,x_i_value):
node_list = []
for i in sorted_list:
if i[1] == x_i_value:
node_list.append(i[0])
return node_list
def get_largest_dball(dball_dict,node_list):
largest_dball = 0
largest_node = 0
for i in node_list:
print(dball_dict[i])
if dball_dict[i] > largest_dball:
largest_dball = dball_dict[i]
largest_node = i
return largest_node
def get_random_dball(node_list):
return random.choice(node_list)
def dict_to_sorted_list(d):
new_list = list(d.items())
final_list = sorted(new_list, key = itemgetter(1))
final_list_no_0 = list(filter(lambda x : x[1] != 0, final_list))
if len(final_list_no_0) != 0:
x_i_value = final_list_no_0[0][1]
nodes_list = get_all_same_x_i(final_list_no_0, x_i_value)
return nodes_list
else:
return final_list_no_0
def get_GC_nodes(G):
comp = nk.components.DynConnectedComponents(G)
comp.run()
all_comp = comp.getComponents()
all_comp.sort(key = len)
return all_comp[-1]
def get_GC(G):
comp = nk.components.DynConnectedComponents(G)
comp.run()
all_comp_sizes = comp.getComponentSizes()
all_values = list(all_comp_sizes.values())
all_values.sort()
return all_values[-1]
def copy_graph(G):
G_copy = G.copyNodes()
edges = G.edges()
for (i,j) in edges:
G_copy.addEdge(i,j)
return G_copy
#dball, vball, degree, betweenness, coreness
def dBalls_attack(G_copy,radius):
G = copy_graph(G_copy)
GC_List = []
size_dball = []
size_ball = []
degree_list_mainNode = []
betweenness_list_mainNode = []
coreness_list_mainNode = []
degree_list_removedNode = []
betweenness_list_removedNode = []
coreness_list_removedNode = []
counter = 0
counter_list = []
GC_List.append(get_GC(G))
counter_list.append(counter)
num_nodes_to_remove = G.numberOfNodes()
while counter < num_nodes_to_remove:
print(counter)
(dict_nodes_dBall,dict_nodes_ball,dict_nodes_x_i) = get_all_dBN(G,radius)
list_to_remove = dict_to_sorted_list(dict_nodes_x_i)
if len(list_to_remove) == 0:
break
node = get_random_dball(list_to_remove)
(dBall,ball) = get_dBN(G,node,radius)
combined_list = [node] + dBall
between_list = get_betweenness_score_list(G,combined_list)
degree_list = get_degree_score_list(G,combined_list)
coreness_list = get_coreness_score_list(G,combined_list)
degree_list_mainNode.append(degree_list[0])
betweenness_list_mainNode.append(between_list[0])
coreness_list_mainNode.append(coreness_list[0])
degree_list_removedNode += degree_list[1:]
betweenness_list_removedNode += between_list[1:]
coreness_list_removedNode += coreness_list[1:]
size_dball.append(len(dBall))
size_ball.append(len(ball))
#print(dBall)
#print(ball)
for i in dBall:
G.removeNode(i)
counter += 1
GC_List.append(get_GC(G))
counter_list.append(counter)
return (GC_List,counter_list,size_dball,size_ball,degree_list_mainNode,betweenness_list_mainNode,coreness_list_mainNode,degree_list_removedNode,betweenness_list_removedNode,coreness_list_removedNode)
def dBalls_attack_NA(G_copy,radius):
G = copy_graph(G_copy)
GC_List = []
size_dball = []
size_ball = []
degree_list_mainNode = []
betweenness_list_mainNode = []
coreness_list_mainNode = []
degree_list_removedNode = []
betweenness_list_removedNode = []
coreness_list_removedNode = []
counter = 0
counter_list = []
GC_List.append(get_GC(G))
counter_list.append(counter)
num_nodes_to_remove = G.numberOfNodes()
(dict_nodes_dBall,dict_nodes_ball,dict_nodes_x_i) = get_all_dBN(G,radius)
list_to_remove = dict_to_sorted_list_NA(dict_nodes_x_i)
counter_for_nodes = 0
print(dict_nodes_x_i)
print(list_to_remove)
while counter_for_nodes < len(list_to_remove):
curr_nodes_set = set(list(G.nodes()))
node = list_to_remove[counter_for_nodes][0]
print(node,dict_nodes_dBall[node])
if node not in curr_nodes_set:
counter_for_nodes += 1
continue
(dBall,ball) = get_dBN(G,node,radius)
if len(dBall) == 0:
counter_for_nodes += 1
continue
size_dball.append(len(dBall))
size_ball.append(len(ball))
combined_list = [node] + dBall
between_list = get_betweenness_score_list(G,combined_list)
degree_list = get_degree_score_list(G,combined_list)
coreness_list = get_coreness_score_list(G,combined_list)
degree_list_mainNode.append(degree_list[0])
betweenness_list_mainNode.append(between_list[0])
coreness_list_mainNode.append(coreness_list[0])
degree_list_removedNode += degree_list[1:]
betweenness_list_removedNode += between_list[1:]
coreness_list_removedNode += coreness_list[1:]
for i in dBall:
G.removeNode(i)
counter += 1
GC_List.append(get_GC(G))
counter_list.append(counter)
counter_for_nodes += 1
return (GC_List,counter_list,size_dball,size_ball,degree_list_mainNode,betweenness_list_mainNode,coreness_list_mainNode,degree_list_removedNode,betweenness_list_removedNode,coreness_list_removedNode)
def dict_to_sorted_list_NA(d):
new_list = list(d.items())
random.shuffle(new_list)
final_list = sorted(new_list, key = itemgetter(1))
return final_list
def get_avg_list(big_list):
counter = 0
size_of_list = len(big_list[0])
avg_list = []
while counter < size_of_list:
index_list = list(map(lambda x : x[counter], big_list))
avg = sum(index_list) / len(index_list)
avg_list.append(avg)
counter += 1
return avg_list
def turn_lists_together(GC_List,num_nodes_removed):
final_list = []
pointer = 0
counter = 0
for i in num_nodes_removed:
diff = i - counter
for j in range(diff):
final_list.append(GC_List[pointer])
counter += 1
pointer += 1
return final_list
def random_ball_removal(G_copy,radius,num_nodes_to_remove):
G = copy_graph(G_copy)
counter = 0
GC_list = []
size_dball = []
size_ball = []
continue_counter = 0
N = G.numberOfNodes()
while counter < num_nodes_to_remove:
if continue_counter > (0.1 * N):
all_nodes = list(G.nodes())
node_sample = random.sample(all_nodes,(num_nodes_to_remove - counter))
for i in node_sample:
G.removeNode(i)
counter += 1
GC_list.append(get_GC(G))
break
print(counter)
all_nodes = get_GC_nodes(G)
node = random.choice(all_nodes)
(dBall,ball) = get_dBN(G,node,radius)
if len(dBall) == 0:
continue_counter += 1
continue
size_dball.append(len(dBall))
size_ball.append(len(ball))
for i in dBall:
G.removeNode(i)
counter += 1
GC_list.append(get_GC(G))
continue_counter = 0
return (GC_list,size_dball,size_ball)
def big_sim(N,k,SEED,radius,perc_to_remove,num_sims):
big_GC_List = []
big_size_dball = []
big_size_ball = []
big_dg_list = []
for i in range(num_sims):
G_nx = nx.erdos_renyi_graph(N, k/(N-1), seed = SEED * (i+1))
G_nk = nk.nxadapter.nx2nk(G_nx)
num_nodes_to_remove = int(perc_to_remove * N)
(GC_List,size_dball,size_ball,dg_list) = perc_process_dBalls(G_nk,radius,num_nodes_to_remove)
GC_List_to_append = GC_List[:num_nodes_to_remove]
big_GC_List.append(GC_List_to_append)
big_size_dball.append(size_dball)
big_size_ball.append(size_ball)
big_dg_list.append(dg_list)
return (big_GC_List,big_size_dball,big_size_ball,big_dg_list)
def big_sim_dball(N,k,SEED,radius,perc_to_remove,num_sims):
big_GC_List = []
big_size_dball = []
big_size_ball = []
big_dg_list = []
for i in range(num_sims):
G_nx = nx.erdos_renyi_graph(N, k/(N-1), seed = SEED * (i+1))
G_nk = nk.nxadapter.nx2nk(G_nx)
num_nodes_to_remove = int(perc_to_remove * N)
(GC_List,size_dball,size_ball,dg_list) = perc_process_dBalls_bigDBalls(G_nk,radius,num_nodes_to_remove)
GC_List_to_append = GC_List[:num_nodes_to_remove]
big_GC_List.append(GC_List_to_append)
big_size_dball.append(size_dball)
big_size_ball.append(size_ball)
big_dg_list.append(dg_list)
return (big_GC_List,big_size_dball,big_size_ball,big_dg_list)
def big_sim_SF(N,k,exp_out,radius,perc_to_remove,num_sims):
big_GC_List = []
big_size_ball = []
big_size_dball = []
big_dg_list = []
for i in range(num_sims):
G_nk = make_SF_Graph(N,k,exp_out)
num_nodes_to_remove = int(perc_to_remove * N)
(GC_List,size_dball,size_ball,degree_list) = perc_process_dBalls(G_nk,radius,num_nodes_to_remove)
GC_List_to_append = GC_List[:num_nodes_to_remove]
big_GC_List.append(GC_List_to_append)
big_size_ball.append(size_ball)
big_size_dball.append(size_dball)
big_dg_list.append(degree_list)
return (big_GC_List,big_size_dball,big_size_ball,big_dg_list)
def big_sim_changing_radius(G,start_radius,end_radius):
big_GC_List = []
big_counter_list = []
curr_radius = start_radius
while curr_radius <= end_radius:
(GC_List,size_dball,size_ball,degree_list,counter_list) = perc_process_dBalls_track_balls(G,curr_radius)
big_GC_List.append(GC_List)
big_counter_list.append(counter_list)
curr_radius += 1
return (big_GC_List,big_counter_list)
def get_results_NA(G, radius):
N = G.numberOfNodes()
GC_list_DA = DA_attack(G, int(N * 0.99))
GC_list_BA = BA_attack(G, int(N * 0.99))
GC_list_RAN = big_RA_attack(G,int(N * 0.99),20)
(GC_List_DB,counter_list,size_dball,size_ball,degree_list_mainNode,betweenness_list_mainNode,coreness_list_mainNode,degree_list_removedNode,betweenness_list_removedNode,coreness_list_removedNode) = dBalls_attack_NA(G_copy,radius)
return (GC_list_DA, GC_list_BA, GC_list_RAN, GC_List_DB, counter_list, size_dball, size_ball, degree_list_mainNode, betweenness_list_mainNode, coreness_list_mainNode, degree_list_removedNode, betweenness_list_removedNode, coreness_list_removedNode)
def get_result(G, radius):
N = G.numberOfNodes()
GC_list_ADA = ADA_attack(G, int(N * 0.99))
GC_list_ABA = ABA_attack(G, int(N * 0.99))
GC_list_RAN = big_RA_attack(G,int(N * 0.99),20)
(GC_List_DB,counter_list,size_dball,size_ball,degree_list_mainNode,betweenness_list_mainNode,coreness_list_mainNode,degree_list_removedNode,betweenness_list_removedNode,coreness_list_removedNode) = dBalls_attack(G,radius)
return (GC_list_ADA, GC_list_ABA, GC_list_RAN, GC_List_DB, counter_list, size_dball, size_ball, degree_list_mainNode, betweenness_list_mainNode, coreness_list_mainNode, degree_list_removedNode, betweenness_list_removedNode, coreness_list_removedNode)
N=int(sys.argv[1])
k=float(sys.argv[2])
exp_out = float(sys.argv[3])
SEED=int(sys.argv[4])
radius = int(sys.argv[5])
G = make_SF_Graph(N,k,exp_out,SEED)
(GC_list_ADA, GC_list_ABA, GC_list_RAN, GC_List_DB, counter_list, size_dball, size_ball, degree_list_mainNode, betweenness_list_mainNode, coreness_list_mainNode, degree_list_removedNode, betweenness_list_removedNode, coreness_list_removedNode) = get_result(G, radius)
"""
GC_list_DA = DA_attack(G,int(N * 0.99))
GC_list_BA = BA_attack(G,int(N * 0.99))
print(GC_list_DA)
print(GC_list_BA)
"""
init_name_GC_Deg = "attackDEG_SF_GC"
init_name_GC_Bet = "attackBET_SF_GC"
init_name_GC_Ran = "attackRAN_SF_GC"
init_name_GC_DB = "attackDB_SF_GC"
init_name_dball = "attackDB_SF_DBALL"
init_name_ball = "attackDB_SF_BALL"
init_name_CL = "attackDB_SF_CL"
init_name_deg_mainNode = "attackDB_SF_degMainNode"
init_name_deg_removedNode = "attackDB_SF_degRemovedNode"
init_name_bet_mainNode = "attackDB_SF_betMainNode"
init_name_bet_removedNode = "attackDB_SF_betRemovedNode"
init_name_core_mainNode = "attackDB_SF_coreMainNode"
init_name_core_removedNode = "attackDB_SF_coreRemovedNode"
GC_List_Deg_name = get_name_SF(init_name_GC_Deg, N,k,exp_out,SEED,radius)
GC_List_Bet_name = get_name_SF(init_name_GC_Bet, N,k,exp_out,SEED,radius)
GC_List_Ran_name = get_name_SF(init_name_GC_Ran, N,k,exp_out,SEED,radius)
GC_List_DB_name = get_name_SF(init_name_GC_DB, N,k,exp_out,SEED,radius)
CL_name = get_name_SF(init_name_CL, N,k,exp_out,SEED,radius)
dBall_name = get_name_SF(init_name_dball, N,k,exp_out,SEED,radius)
ball_name = get_name_SF(init_name_ball, N,k,exp_out,SEED,radius)
deg_mainNode_name = get_name_SF(init_name_deg_mainNode, N,k,exp_out,SEED,radius)
deg_removedNode_name = get_name_SF(init_name_deg_removedNode, N,k,exp_out,SEED,radius)
bet_mainNode_name = get_name_SF(init_name_bet_mainNode, N,k,exp_out,SEED,radius)
bet_removedNode_name = get_name_SF(init_name_bet_removedNode, N,k,exp_out,SEED,radius)
core_mainNode_name = get_name_SF(init_name_core_mainNode, N,k,exp_out,SEED,radius)
core_removedNode_name = get_name_SF(init_name_core_removedNode, N,k,exp_out,SEED,radius)
with open(GC_List_Deg_name,'wb') as handle:
pickle.dump(GC_list_ADA, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open(GC_List_Bet_name,'wb') as handle:
pickle.dump(GC_list_ABA, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open(GC_List_Ran_name,'wb') as handle:
pickle.dump(GC_list_RAN, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open(GC_List_DB_name,'wb') as handle:
pickle.dump(GC_List_DB, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open(CL_name,'wb') as handle:
pickle.dump(counter_list, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open(dBall_name,'wb') as handle:
pickle.dump(size_dball, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open(ball_name,'wb') as handle:
pickle.dump(size_ball, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open(deg_mainNode_name,'wb') as handle:
pickle.dump(degree_list_mainNode, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open(bet_mainNode_name,'wb') as handle:
pickle.dump(betweenness_list_mainNode, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open(core_mainNode_name,'wb') as handle:
pickle.dump(coreness_list_mainNode, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open(deg_removedNode_name,'wb') as handle:
pickle.dump(degree_list_removedNode, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open(bet_removedNode_name,'wb') as handle:
pickle.dump(betweenness_list_removedNode, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open(core_removedNode_name,'wb') as handle:
pickle.dump(coreness_list_removedNode, handle, protocol=pickle.HIGHEST_PROTOCOL)
print(degree_list_mainNode)
print(degree_list_removedNode)
print(betweenness_list_mainNode)
print(betweenness_list_removedNode)
print(coreness_list_mainNode)
print(coreness_list_removedNode)
| [
"vpahari@wesleyan.edu"
] | vpahari@wesleyan.edu |
8367d61559cdf696618b6d909051533b8def93b0 | 97899228dbe6c0811783f7c830212febfc54f4c3 | /algorithm_PS/BEAKJOON/String/1157.py | 68937ea53be20eecbe1ef6030f14cc57285ba17d | [] | no_license | ksy37667/Algorithm-study | f977abcd5c44582b71f78e589f4a8a174d35a8f0 | 51680e236cf6bba09a2e0824ec72536ee23bba31 | refs/heads/master | 2021-07-12T20:45:50.849105 | 2021-03-27T06:44:18 | 2021-03-27T06:44:18 | 241,117,162 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 240 | py | string = input().upper()
li = []
for i in set(string):
li.append(string.count(i))
idx = [i for i, x in enumerate(li) if x == max(li)]
print(idx)
if len(idx) > 1:
print("?")
else:
print(list(set(string))[li.index(max(li))])
| [
"ksy37667@gmail.com"
] | ksy37667@gmail.com |
9175323c790049f9662192795528961fbfa3ae6f | 0256a449bd686479aa91905a1763973548d9923c | /two_sum.py | 35b7d25d54872dd0bc05ae114b9aa529adf58ac5 | [] | no_license | zjgwhcn/StartCodingNow | 2aa776865788bec1c8d11e14bb4ef0c97280a68d | b235eb280cc11082c680563dc2a261dfc2f2cdce | refs/heads/master | 2021-06-13T03:47:31.435068 | 2017-02-19T13:25:34 | 2017-02-19T13:25:34 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 758 | py | #!/usr/bin/env python
# -*-coding:utf-8 -*-
# Time:16/9/2016
# 1
class Solution(object):
def twoSum(self, nums, target):
for i in range(len(nums)):
for j in range(i+1,len(nums)):
if target == nums[i] + nums[j]:
return [i,j]
#2
'''
num = [1,5,8,2,7]
target = 13
dict = {}
print dict
for i in xrange(len(num)):
x = num[i]
if target-x in dict:
print [dict[target-x], i]
dict[x] = i
print dict[x]
print dict
print dict[8]
'''
class Solution(object):
def twoSum(self, num, target):
dict = {}
for i in xrange(len(num)):
x = num[i]
if target-x in dict:
return (dict[target-x], i)
dict[x] = i
| [
"louchaooo@qq.com"
] | louchaooo@qq.com |
8581dd3dea171c93ad4e0fc231e5f70bdd96d430 | 0ca60d532c0a77c261f2b107c0e697e82af6000d | /svm/svmdemo1.py | 7cb5f27dd62519e6a8e909c08ad182c2ad32519c | [] | no_license | bnhalder/basic_ml | 6b3ad193622b0632fe449a83cc17a0a5211bdd5f | 91579c34adee090e75eb992f439fefd212741168 | refs/heads/master | 2020-03-10T01:35:09.090807 | 2018-04-11T15:29:41 | 2018-04-11T15:29:41 | 129,113,702 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,523 | py | #!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 18 22:54:30 2017
@author: jabong
"""
import numpy as np
import pylab as pl
iris = np.loadtxt('../data/iris_proc.data', delimiter=',')
imax = np.concatenate((iris.max(axis=0)*np.ones((1,5)),iris.min(axis=0)*np.ones((1,5))),axis=0).max(axis=0)
target = -np.ones((np.shape(iris)[0],3),dtype=float);
indices = np.where(iris[:,4]==0)
target[indices,0] = 1.
indices = np.where(iris[:,4]==1)
target[indices,1] = 1.
indices = np.where(iris[:,4]==2)
target[indices,2] = 1.
train = iris[::2,0:4]
traint = target[::2]
test = iris[1::2,0:4]
testt = target[1::2]
output = np.zeros((np.shape(test)[0],3))
import svm
reload(svm)
# Learn the full data
#svm0 = svm.svm(kernel='linear')
#svm0 = svm.svm(kernel='poly',C=0.1,degree=3)
svm0 = svm.svm(kernel='rbf')
svm0.train_svm(train,np.reshape(traint[:,0],(np.shape(train[:,:2])[0],1)))
output[:,0] = svm0.classifier(test,soft=True).T
#svm1 = svm.svm(kernel='linear')
#svm1 = svm.svm(kernel='poly',C=0.1,degree=3)
svm1 = svm.svm(kernel='rbf')
svm1.train_svm(train,np.reshape(traint[:,1],(np.shape(train[:,:2])[0],1)))
output[:,1] = svm1.classifier(test,soft=True).T
#svm2 = svm.svm(kernel='linear')
#svm2 = svm.svm(kernel='poly',C=0.1,degree=3)
svm2 = svm.svm(kernel='rbf')
svm2.train_svm(train,np.reshape(traint[:,2],(np.shape(train[:,:2])[0],1)))
output[:,2] = svm2.classifier(test,soft=True).T
bestclass = np.argmax(output,axis=1)
print bestclass
print iris[1::2,4]
err = np.where(bestclass!=iris[1::2,4])[0]
print err
print float(np.shape(testt)[0] - len(err))/ (np.shape(testt)[0]) , "test accuracy"
# Plot 2D version is below
#svm0 = svm.svm(kernel='linear')
svm0 = svm.svm(kernel='poly',degree=3)
#svm0 = svm.svm(kernel='rbf')
svm0.train_svm(train[:,:2],np.reshape(traint[:,0],(np.shape(train[:,:2])[0],1)))
output[:,0] = svm0.classifier(test[:,:2],soft=True).T
#svm1 = svm.svm(kernel='linear')
svm1 = svm.svm(kernel='poly',degree=3)
#svm1 = svm.svm(kernel='rbf')
svm1.train_svm(train[:,:2],np.reshape(traint[:,1],(np.shape(train[:,:2])[0],1)))
output[:,1] = svm1.classifier(test[:,:2],soft=True).T
#svm2 = svm.svm(kernel='linear')
svm2 = svm.svm(kernel='poly',degree=3)
#svm2 = svm.svm(kernel='rbf')
svm2.train_svm(train[:,:2],np.reshape(traint[:,2],(np.shape(train[:,:2])[0],1)))
output[:,2] = svm2.classifier(test[:,:2],soft=True).T
# Make a decision about which class
# Pick the one with the largest margin
bestclass = np.argmax(output,axis=1)
print bestclass
print iris[1::2,4]
err = np.where(bestclass!=iris[1::2,4])[0]
print err
print float(len(err))/ (np.shape(testt)[0]) , "test accuracy"
# Make a plot
pl.figure()
step=0.01
f0,f1 = np.meshgrid(np.arange(np.min(train[:,0])-0.5, np.max(train[:,0])+0.5, step), np.arange(np.min(train[:,1])-0.5, np.max(train[:,1])+0.5, step))
out = np.zeros((np.shape(f0.ravel())[0],3))
out[:,0] = svm0.classifier(np.c_[np.ravel(f0), np.ravel(f1)],soft=True).T
out[:,1] = svm1.classifier(np.c_[np.ravel(f0), np.ravel(f1)],soft=True).T
out[:,2]= svm2.classifier(np.c_[np.ravel(f0), np.ravel(f1)],soft=True).T
out = np.argmax(out[:,:3],axis=1)
print out
out = out.reshape(f0.shape)
pl.contourf(f0, f1, out, cmap=pl.cm.Paired)
#pl.axis('off')
# Plot also the training points
#traint = np.where(traint==-1,0,1)
pl.plot(train[svm0.sv,0],train[svm0.sv,1],'o',markerfacecolor=None,markeredgecolor='r',markeredgewidth=3)
pl.scatter(train[:, 0], train[:, 1], c=iris[::2,4], cmap=pl.cm.Paired)
#pl.plot(train[:, 0], train[:, 1],'o', c=traint, cmap=pl.cm.Paired)
| [
"biswanath.halder@jabong.com"
] | biswanath.halder@jabong.com |
e911275049761c3d34e3f24d5c1a7c806c6d85e4 | a70ff84caceb693723846542c19d300bea321deb | /coins_test/settings.py | 53bc0e9900f1b3562edf8ec612055aea94864f58 | [] | no_license | Greyvend/coins_test | 10420bffa7d4510de20bca9fe7b71bd7091c01b1 | a259907a160d482bc0217aeecbb97c1665db62dd | refs/heads/master | 2021-04-12T10:13:33.417998 | 2016-08-14T16:42:13 | 2016-08-14T16:42:13 | 65,676,097 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,245 | py | """
Django settings for coins_test project.
Generated by 'django-admin startproject' using Django 1.10.
For more information on this file, see
https://docs.djangoproject.com/en/1.10/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.10/ref/settings/
"""
import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.10/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '0)8vo9&t7i_=0ori8xz#*nfwohp#vusboee1h6pe_+@@5utgnp'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
DJANGO_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
]
THIRD_PARTY_APPS = [
'rest_framework',
]
LOCAL_APPS = [
'payments'
]
INSTALLED_APPS = DJANGO_APPS + THIRD_PARTY_APPS + LOCAL_APPS
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'coins_test.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'coins_test.wsgi.application'
# Database
# https://docs.djangoproject.com/en/1.10/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
# Password validation
# https://docs.djangoproject.com/en/1.10/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/1.10/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.10/howto/static-files/
STATIC_URL = '/static/'
| [
"svmosin@gmail.com"
] | svmosin@gmail.com |
9eb758de63ec95f04758e32b359b987bccabd53c | 10a79a489ae800b25332c12ec829f99f0480c6cf | /floreria/settings.py | 94470c918c589eb73cf0e8a9ca339410226fcef1 | [] | no_license | taamfernandez/floreria | 2af0855ee413fbd617926c24a55d95a5894ee06e | 7f04b85a1dc4cf186dbe7a5f1e367f97116bd232 | refs/heads/master | 2020-09-26T04:13:23.938569 | 2019-12-18T16:42:41 | 2019-12-18T16:42:41 | 226,162,344 | 1 | 1 | null | null | null | null | UTF-8 | Python | false | false | 4,582 | py | """
Django settings for floreria project.
Generated by 'django-admin startproject' using Django 3.0.
For more information on this file, see
https://docs.djangoproject.com/en/3.0/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.0/ref/settings/
"""
import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '723_q8l5(pd=u@#jgw@_25cho=a)th0q2=(1k)$nami@v*9e_*'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
LOGIN_REDIRECT_URL = '/'
LOGOUT_REDIRECT_URL = '/'
SOCIAL_AUTH_FACEBOOK_KEY = '826344021127651'
SOCIAL_AUTH_FACEBOOK_SECRET = 'dd6e96795ccda4ab50a60a9d1c5723f7'
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'core.apps.CoreConfig',
'crispy_forms',
'rest_framework',
'social_django',
'pwa',
'fcm_django',
]
CRISPY_TEMPLATE_PACK = 'bootstrap4'
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
'social_django.middleware.SocialAuthExceptionMiddleware',
]
ROOT_URLCONF = 'floreria.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
'social_django.context_processors.backends',
'social_django.context_processors.login_redirect',
],
},
},
]
WSGI_APPLICATION = 'floreria.wsgi.application'
# Database
# https://docs.djangoproject.com/en/3.0/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
# Password validation
# https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.0/topics/i18n/
LANGUAGE_CODE = 'es-mx'
TIME_ZONE = 'America/Santiago'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.0/howto/static-files/
STATIC_URL = '/static/'
#URL mediante la cual accederan a la simagenes que ya estan subidas
MEDIA_URL = "/media/"
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
#la ruta en donde quedan almacenada las imagenes
AUTHENTICATION_BACKENDS = (
'social_core.backends.facebook.FacebookOAuth2',
'django.contrib.auth.backends.ModelBackend',
)
PWA_SERVICE_WORKER_PATH = os.path.join(BASE_DIR, 'serviceworker.js')
FCM_DJANGO_SETTINGS = {
"APP_VERBOSE_NAME": "floreria",
# default: _('FCM Django')
"FCM_SERVER_KEY": "AIzaSyBYdNgB6IL05qJIOI7T7eQCfETWeaR8-5Q",
# true if you want to have only one active device per registered user at a time
# default: False
"ONE_DEVICE_PER_USER": False,
# devices to which notifications cannot be sent,
# are deleted upon receiving error response from FCM
# default: False
"DELETE_INACTIVE_DEVICES": True,
} | [
"ta.fernandeza@alumnos.duoc.cl"
] | ta.fernandeza@alumnos.duoc.cl |
8418693b0b7f600bc206c9513a976a8685d46f52 | 7a7ed5656b3a162523ba0fd351dd551db99d5da8 | /x11/library/wayland/actions.py | 73d6d6bb7fcd4510e4e0b35f12090d0231dd9fe0 | [] | no_license | klaipedetis/PisiLinux | acd4953340ebf14533ea6798275b8780ad96303b | 3384e5dfa1acd68fa19a26a6fa1cf717136bc878 | refs/heads/master | 2021-01-24T22:59:30.055059 | 2013-11-08T21:43:39 | 2013-11-08T21:43:39 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 755 | py | #!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright 2010 TUBITAK/BILGEM
# Licensed under the GNU General Public License, version 2.
# See the file http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
from pisi.actionsapi import shelltools
from pisi.actionsapi import autotools
from pisi.actionsapi import pisitools
from pisi.actionsapi import get
Libdir = "/usr/lib32" if get.buildTYPE() == "emul32" else "/usr/lib"
def setup():
autotools.autoreconf("-vif")
autotools.configure("--disable-documentation --disable-static")
def build():
autotools.make()
def install():
autotools.rawInstall("DESTDIR=%s" % get.installDIR())
if get.buildTYPE() == "emul32":
return
pisitools.dodoc("COPYING", "TODO", "README") | [
"namso-01@hotmail.it"
] | namso-01@hotmail.it |
b3c1357b284e6b73b5f72802de36f0a28ddb3683 | ce965cb69fd1f071dfae85e926b70a9a82eb560b | /main.py | d117bb7f83c82eef07f3af0121e6cee6a6ad88e0 | [] | no_license | tk14shiina/learningtool | c7a2c5ee1ce1ddb216534505df39e41426df2674 | e0bab8ce0c96d30683e01996e896b0e4ebfcbffa | refs/heads/main | 2023-04-29T14:39:22.443660 | 2021-05-18T20:48:36 | 2021-05-18T20:48:36 | 368,662,566 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,568 | py | from dbhelper import DBHelper
from tkinter import *
db = DBHelper()
root = Tk()
root.title('Quizlett')
root.geometry("700x550")
#root.resizable(width = False, height = False)
tk_ss = Entry(root, width = 30)
tk_ss.grid(row = 0, column = 1, padx = 20, pady = 5)
tk_ssLabel = Label(root, text = "New study set")
tk_ssLabel.grid(row = 0, column = 0)
tk_ssIdDel = Entry(root, width = 30)
tk_ssIdDel.grid(row = 2, column = 1, pady = 5)
tk_ssIdDelLabel = Label(root, text = "Study set ID")
tk_ssIdDelLabel.grid(row = 2, column = 0)
tk_ssIdUpd = Entry(root, width = 30)
tk_ssIdUpd.grid(row = 4, column = 1)
tk_ssIdUpdLabel = Label(root, text = "Study set ID")
tk_ssIdUpdLabel.grid(row = 4, column = 0)
tk_newSs = Entry(root, width = 30)
tk_newSs.grid(row = 5, column = 1, pady = 5)
tk_newSsLabel = Label(root, text = "Rename")
tk_newSsLabel.grid(row = 5, column = 0)
#mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
tk_ssword = Entry(root, width = 30)
tk_ssword.grid(row = 0, column = 4, padx = 20, pady = 5)
tk_sswordLabel = Label(root, text = "Study set Id")
tk_sswordLabel.grid(row = 0, column = 3)
tk_word = Entry(root, width = 30)
tk_word.grid(row = 1, column = 4, pady = 5)
tk_wordLabel = Label(root, text = "Word")
tk_wordLabel.grid(row = 1, column = 3)
tk_def = Entry(root, width = 30)
tk_def.grid(row = 2, column = 4, pady = 5)
tk_defLabel = Label(root, text = "Definition")
tk_defLabel.grid(row = 2, column = 3)
tk_sswordIdDel = Entry(root, width = 30)
tk_sswordIdDel.grid(row = 4, column = 4, pady = 20)
tk_sswordIdDelLabel = Label(root, text = "Study set ID")
tk_sswordIdDelLabel.grid(row = 4, column = 3)
tk_wordIdDel = Entry(root, width = 30)
tk_wordIdDel.grid(row = 5, column = 4, pady = 5)
tk_wordIdDelLabel = Label(root, text = "Word ID")
tk_wordIdDelLabel.grid(row = 5, column = 3)
tk_sswordIdUpd = Entry(root, width = 30)
tk_sswordIdUpd.grid(row = 7, column = 4)
tk_sswordIdUpdLabel = Label(root, text = "Study set ID")
tk_sswordIdUpdLabel.grid(row = 7, column = 3)
tk_wordIdUpd = Entry(root, width = 30)
tk_wordIdUpd.grid(row = 8, column = 4, pady = 5)
tk_wordIdUpdLabel = Label(root, text = "Word ID")
tk_wordIdUpdLabel.grid(row = 8, column = 3)
tk_newWord = Entry(root, width = 30)
tk_newWord.grid(row = 9, column = 4, pady = 5)
tk_newWordLabel = Label(root, text = "New word")
tk_newWordLabel.grid(row = 9, column = 3)
tk_newDef = Entry(root, width = 30)
tk_newDef.grid(row = 10, column = 4, pady = 5)
tk_newDefLabel = Label(root, text = "New definition")
tk_newDefLabel.grid(row = 10, column = 3)
def submitAdd1():
print(tk_ss.get())
db.insert_studySet(tk_ss.get())
tk_ss.delete(0, END)
def submitDel1():
print(tk_ssIdDel.get())
db.delete_studySet(tk_ssIdDel.get())
tk_ssIdDel.delete(0, END)
def submitUpd1():
print(tk_ssIdUpd.get())
print(tk_newSs.get())
db.update_studySet(tk_ssIdUpd.get(), tk_newSs.get())
tk_ssIdUpd.delete(0, END)
tk_newSs.delete(0, END)
def submitShow1():
print("all")
res = db.fetch_all_studySet()
id = 0
top = Toplevel()
top.geometry("200x200")
w = Label(top, text ='List of study sets', font = "50")
w.pack()
scroll_bar = Scrollbar(top)
scroll_bar.pack( side = RIGHT, fill = Y)
mylist = Listbox(top, yscrollcommand = scroll_bar.set)
for r in res:
mylist.insert(END, "Id: "+ str(r[0]))
mylist.insert(END, "Title: "+ r[1])
mylist.insert(END, "------------")
mylist.pack(side = LEFT, fill = BOTH)
scroll_bar.config(command = mylist.yview)
#>>>>>
def submitAdd2():
print(tk_ssword.get())
print(tk_word.get())
print(tk_def.get())
db.insert_word(tk_ssword.get(), tk_word.get(), tk_def.get())
tk_ssword.delete(0, END)
tk_word.delete(0, END)
tk_def.delete(0, END)
def submitDel2():
print(tk_sswordIdDel.get())
print(tk_wordIdDel.get())
db.delete_word(tk_sswordIdDel.get(), tk_wordIdDel.get())
tk_sswordIdDel.delete(0, END)
tk_wordIdDel.delete(0, END)
def submitUpd2():
print(tk_sswordIdUpd.get())
print(tk_wordIdUpd.get())
print(tk_newWord.get())
print(tk_newDef.get())
db.update_word(tk_sswordIdUpd.get(), tk_wordIdUpd.get(), tk_newWord.get(), tk_newDef.get())
tk_sswordIdUpd.delete(0, END)
tk_wordIdUpd.delete(0, END)
tk_newWord.delete(0, END)
tk_newDef.delete(0, END)
def submitShow2():
print("all")
res = db.fetch_all_word()
print(res)
top = Toplevel()
top.geometry("200x200")
w = Label(top, text ='Wordlist', font = "50")
w.pack()
scroll_bar = Scrollbar(top)
scroll_bar.pack(side = RIGHT, fill = Y)
mylist = Listbox(top, yscrollcommand = scroll_bar.set)
for r in res:
mylist.insert(END, "ID: "+ str(r[0]))
mylist.insert(END, "Study Set Id: "+ str(r[1]))
mylist.insert(END, "Word: "+ r[2])
mylist.insert(END, "Definition: "+ r[3])
mylist.insert(END, "------------")
mylist.pack( side = LEFT, fill = BOTH)
scroll_bar.config(command = mylist.yview)
addButton1 = Button(root, text = "Add", command = submitAdd1, bg = '#3399FF', fg = 'white')
addButton1.grid(row = 1, column = 1, columnspan = 2, ipadx = 20)
deleteButton1 = Button(root, text = "Delete", command = submitDel1, bg = '#3399FF', fg = 'white')
deleteButton1.grid(row = 3, column = 1, columnspan = 2, ipadx = 20)
updateButton1 = Button(root, text = "Update", command = submitUpd1, bg = '#3399FF', fg = 'white')
updateButton1.grid(row = 6, column = 1, columnspan = 2, padx = 10, ipadx = 20)
showButton1 = Button(root, text = "Show all", command = submitShow1, bg = '#3399FF', fg = 'white')
showButton1.grid(row = 7, column = 1, columnspan = 2, pady = 5, padx = 10, ipadx = 20)
addButton2 = Button(root, text = "Add", command = submitAdd2, bg = '#FF6699', fg = 'white')
addButton2.grid(row = 3, column = 4, columnspan = 2, ipadx = 20)
deleteButton2 = Button(root, text = "Delete", command = submitDel2, bg = '#FF6699', fg = 'white')
deleteButton2.grid(row = 6, column = 4, columnspan = 2, pady = 5, ipadx = 20)
updateButton2 = Button(root, text = "Update", command = submitUpd2, bg = '#FF6699', fg = 'white')
updateButton2.grid(row = 11, column = 4, columnspan = 2, pady = 5, padx = 10, ipadx = 20)
showButton2 = Button(root, text = "Show all", command = submitShow2, bg = '#FF6699', fg = 'white')
showButton2.grid(row = 12, column = 4, columnspan = 2, pady = 5, padx = 10, ipadx = 20)
tk_topic = Entry(root, width = 30)
tk_topic.grid(row = 9, column = 1, pady = 5)
tk_topicLabel = Label(root, text = "Choose study set")
tk_topicLabel.grid(row = 9, column = 0)
def submitLearn():
top = Toplevel()
top.title('Quiz')
top.geometry("100x100")
top.resizable(width = False, height = False)
data = db.fetch_one_word(int(tk_topic.get()))
qs = data[0]
ans = data[1]
w = Label(top, text = qs, font = "30")
w.pack()
scroll_bar = Scrollbar(top)
scroll_bar.pack( side = RIGHT, fill = Y)
mylist = Listbox(top, yscrollcommand = scroll_bar.set)
for i in range (0, 10):
mylist.insert(END, " ")
mylist.insert(END, " " + ans)
mylist.pack(side = LEFT, fill = BOTH)
scroll_bar.config(command = mylist.yview)
learnButton = Button(root, text = "Learn", command = submitLearn, bg = '#FF9900', fg = 'white')
learnButton.grid(row = 10, column = 1, columnspan = 1, pady = 5, ipadx = 50)
mainloop() | [
"noreply@github.com"
] | tk14shiina.noreply@github.com |
a88be55fbce8783a3e8e5780a1ad3fe6b790e992 | a4ab53aad0a6e1780f9eabd978c4d16f4822e38f | /Hexagon/Handlers/AcceptChallenge.py | ee4d575d8fc81f526b9c4c3e199ed1cc11f61d87 | [] | no_license | rywit/Hex | 8fc6af035bf37204cde8d2b8ede0b4590b1bf5ed | bdf43c53e491fcfa951013d10c29d9186877af9e | refs/heads/master | 2020-05-18T12:14:12.220213 | 2012-07-07T01:27:52 | 2012-07-07T01:27:52 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 771 | py | from Handlers.BaseHandler import BaseHandler
from Views.GameView import GameView
class AcceptChallenge( BaseHandler ):
def get(self):
## Make sure the user is logged in
if not self.user:
self.redirect( "/login" )
return
## Pull off the game id from the request
gameid = self.request.get( "gameid" )
if not gameid:
self.render( "error.html", message = "Could not find game ID in request" )
return
## Grab the game with this ID
game = GameView( gameid = gameid )
## Update the status of the game to "ACTIVE"
game.update_status( "ACTIVE" )
## Go to home page
self.redirect( "/home" )
| [
"witko.ryan@gmail.com"
] | witko.ryan@gmail.com |
88c6be80cd7eb38f457df5fa97ae76cdc8bb9cce | 2f3f48b87266a62a17d54c090f4b40f11d778f26 | /lib/utils/misc.py | 44179919e604f85ff607872d718a6e66a15eaf07 | [
"MIT"
] | permissive | DarioRugg/Self-Supervised_Pearson_Search | b9f78a2e61946f8709399bfbdeaabe1f303ff960 | 731ff0888b336076ec42c26808417809fb78e3cf | refs/heads/main | 2023-07-15T22:05:37.207853 | 2021-07-11T10:15:16 | 2021-07-11T10:15:16 | 379,900,903 | 0 | 0 | MIT | 2021-06-24T18:09:00 | 2021-06-24T11:24:10 | Python | UTF-8 | Python | false | false | 5,164 | py | # -*- coding: utf-8 -*-
# Reference:
# https://github.com/pytorch/vision/blob/fe3b4c8f2c/references/detection/utils.py
import argparse
import sys
import torch
import huepy as hue
from .serialization import read_json, write_json
class Nestedspace(argparse.Namespace):
def __setattr__(self, name, value):
if '.' in name:
group, name = name.split('.', 1)
ns = getattr(self, group, Nestedspace())
setattr(ns, name, value)
self.__dict__[group] = ns
else:
self.__dict__[name] = value
def __getattr__(self, name):
if '.' in name:
group, name = name.split('.', 1)
try:
ns = self.__dict__[group]
except KeyError:
raise AttributeError
return getattr(ns, name)
else:
raise AttributeError
def to_dict(self, args=None, prefix=None):
out = {}
args = self if args is None else args
for k, v in args.__dict__.items():
if isinstance(v, Nestedspace):
out.update(self.to_dict(v, prefix=k))
else:
if prefix is not None:
out.update({prefix + '.' + k: v})
else:
out.update({k: v})
return out
def from_dict(self, dic):
for k, v in dic.items():
self.__setattr__(k, v)
def export_to_json(self, file_path):
write_json(self.to_dict(), file_path)
def load_from_json(self, file_path):
self.from_dict(read_json(file_path))
def lazy_arg_parse(parser):
'''
Only parse the given flags.
'''
def parse_known_args():
args = sys.argv[1:]
namespace = Nestedspace()
try:
namespace, args = parser._parse_known_args(args, namespace)
if hasattr(namespace, '_unrecognized_args'):
args.extend(getattr(namespace, '_unrecognized_args'))
delattr(namespace, '_unrecognized_args')
return namespace, args
except argparse.ArgumentError:
err = sys.exc_info()[1]
parser.error(str(err))
args, argv = parse_known_args()
if argv:
msg = _('unrecognized arguments: %s')
parser.error(msg % ' '.join(argv))
return args
def ship_data_to_cuda(batch, device):
f = lambda sample: ship_data_to_cuda_singe_sample(
sample[0], sample[1], device=device)
return tuple(map(list, zip(*map(f, batch))))
def ship_data_to_cuda_singe_sample(img, target, device):
img = img.to(device)
if target is not None:
target['boxes'] = target['boxes'].to(device)
target['labels'] = target['labels'].to(device)
if 'heatmaps' in target:
target['heatmaps'] = target['heatmaps'].to(device)
return img, target
def resume_from_checkpoint(args, model, optimizer=None, lr_scheduler=None):
load_name = args.resume
checkpoint = torch.load(load_name)
args.train.start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['model'])
if optimizer is not None:
optimizer.load_state_dict(checkpoint['optimizer'])
if lr_scheduler is not None:
lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
print(hue.good('loaded checkpoint %s' % (load_name)))
print(hue.info('model was trained for %s epochs' % (args.train.start_epoch)))
return args, model, optimizer, lr_scheduler
def get_optimizer(args, model):
lr = args.train.lr
params = []
for key, value in dict(model.named_parameters()).items():
if value.requires_grad:
if 'bias' in key:
params += [{'params': [value], 'lr':lr * (args.train.double_bias + 1),
'weight_decay': args.train.bias_decay and args.train.weight_decay or 0}]
else:
params += [{'params': [value], 'lr':lr,
'weight_decay': args.train.weight_decay}]
optimizer = torch.optim.SGD(params, momentum=args.train.momentum)
return optimizer
def get_lr_scheduler(args, optimizer):
if args.train.lr_decay_milestones is not None:
scheduler = torch.optim.lr_scheduler.MultiStepLR(
optimizer, milestones=args.train.lr_decay_milestones,
gamma=args.train.lr_decay_gamma)
else:
scheduler = torch.optim.lr_scheduler.StepLR(
optimizer, step_size=args.train.lr_decay_step,
gamma=args.train.lr_decay_gamma)
return scheduler
def warmup_lr_scheduler(optimizer, warmup_iters, warmup_factor):
def f(x):
if x >= warmup_iters:
return 1
alpha = float(x) / warmup_iters
return warmup_factor * (1 - alpha) + alpha
return torch.optim.lr_scheduler.LambdaLR(optimizer, f)
def lucky_bunny(i):
print('')
print('|￣￣￣￣￣￣￣￣|')
print('| TRAINING |')
print('| epoch |')
print('| ' + hue.bold(hue.green(str(i))) + ' |')
print('| ＿＿＿_＿＿＿＿|')
print(' (\__/) ||')
print(' (•ㅅ•) || ')
print(' / づ')
print('')
| [
"munjalbharti@gmail.com"
] | munjalbharti@gmail.com |
ec6863f6fad89f0a79981b9ebe0b04003f60a4e1 | 38fa69b9334acd23a076372b340b8c1230265b05 | /Console.py | 5a713642b55f572d87502da149577781dccff197 | [
"Apache-2.0"
] | permissive | gauravssnl/IPViewer | c880a098e2300a95b63b8d73f6373d9491fed2ba | 3a04711aa3ba79a961e44e163a479e788de1d7bf | refs/heads/master | 2021-01-22T05:00:49.588000 | 2017-09-10T15:01:16 | 2017-09-10T15:01:16 | 81,607,532 | 6 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,955 | py |
#Console.py script for PyS60
import sys
import e32
import appuifw
ru = lambda text, : text.decode('utf-8', 'ignore')
class Console :
__module__ = __name__
def __init__(self, logger = False):
self.logger = logger
from e32 import Ao_lock as Ao_lock
from key_codes import EKeyEnter as EKeyEnter
self.input_wait_lock = Ao_lock()
self.input_stopped = False
self.control = self.text = appuifw.Text()
self.text.font = ('title', 16, None)
self.text.color = 0
self.savestderr = sys.stderr
self.savestdout = sys.stdout
self.savestdin = sys.stdin
sys.stderr = self
sys.stdout = self
sys.stdin = self
self.writebuf = []
self._doflush = self.clear()
self._flushgate = self.clear()
if self.logger :
def make_flusher(text, buf):
def doflush():
text.set_pos(text.len())
text.add(ru(''.join(buf)))
del buf[:]
return doflush
self._doflush = make_flusher(self.text, self.writebuf)
self._flushgate = e32.ao_callgate(self._doflush)
else :
self.logger = False
self.clear()
return None
def __del__(self):
sys.stderr = self.savestderr
sys.stdout = self.savestdout
sys.stdin = self.savestdin
self.control = self.text = None
return None
def stop_input(self):
self.input_stopped = True
self.input_wait_lock.signal()
def clear(self):
self.text.clear()
def write(self, obj):
self.writebuf.append(obj)
self.flush()
def writelines(self, list):
self.write(''.join(list))
def flush(self):
if len(self.writebuf) > 0 :
if e32.is_ui_thread() :
self._doflush()
else :
self._flushgate()
pass
def readline(self):
if not (e32.is_ui_thread()) :
raise IOError('Cannot call readline from non-UI thread')
pos = self.text.get_pos()
len = self.text.len()
save_exit_key_handler = appuifw.app.exit_key_handler
appuifw.app.exit_key_handler = self.stop_input
self.input_wait_lock.wait()
appuifw.app.exit_key_handler = save_exit_key_handler
if self.input_stopped :
self.text.add(u'\n')
self.input_stopped = False
raise EOFError
new_pos = self.text.get_pos()
new_len = self.text.len()
if (new_pos <= pos | (new_len - len) != (new_pos - pos)) :
new_pos = self.text.len()
self.text.set_pos(new_pos)
self.text.add(u'\n')
user_input = ''
else :
user_input = self.text.get(pos, ((new_pos - pos) - 1))
return user_input.encode('utf8')
| [
"noreply@github.com"
] | gauravssnl.noreply@github.com |
85d65df06168b2114299f77d388cbe712b4b7085 | 458c487a30df1678e6d22ffdb2ea426238197c88 | /ubcsp/add_gc.py | e6be0db995f628f5c02f95391bfd50d28fde12ec | [
"MIT"
] | permissive | pluck992/ubc | 04062d2cdeef8d983da1bfaa0ff640a3b25c72c2 | 54fc89ae6141775321d5ea770e973ff09be51c0c | refs/heads/master | 2023-02-19T05:01:42.401329 | 2021-01-21T06:32:15 | 2021-01-21T06:32:15 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 939 | py | import pp
from gdslib import plot_circuit
from simphony.library import siepic
from simphony.netlist import Subcircuit
def add_gc_te(circuit, gc=siepic.ebeam_gc_te1550):
""" add input and output gratings
Args:
circuit: needs to have `input` and `output` pins
gc: grating coupler
"""
c = Subcircuit(f"{circuit}_gc")
gc = pp.call_if_func(gc)
c.add([(gc, "gci"), (gc, "gco"), (circuit, "circuit")])
c.connect_many(
[("gci", "n1", "circuit", "input"), ("gco", "n1", "circuit", "output")]
)
# c.elements["circuit"].pins["input"] = "input_circuit"
# c.elements["circuit"].pins["output"] = "output_circuit"
c.elements["gci"].pins["n2"] = "input"
c.elements["gco"].pins["n2"] = "output"
return c
if __name__ == "__main__":
import matplotlib.pyplot as plt
from ubc.cm.mzi import mzi
c1 = mzi()
c2 = add_gc_te(c1)
plot_circuit(c2)
plt.show()
| [
"j"
] | j |
107f09e9df2f036798d34862b440c2ebd70a7a7a | a9117d287019a6860693e8f6dbfac152f5e92a75 | /fe/lda_fe.py | 3467205482cca57aa79025515bb32b7db3f508ca | [] | no_license | backonhighway/kaggle_elo | 48a2e4eda9ef5025665564b22f99bfe2cf296dc6 | 636c1ecc64d70c9f1375653687679b745b8bf6db | refs/heads/master | 2020-04-29T01:26:23.269169 | 2019-02-28T15:29:39 | 2019-02-28T15:29:39 | 175,730,137 | 1 | 1 | null | null | null | null | UTF-8 | Python | false | false | 3,351 | py | import numpy as np
import pandas as pd
import gc
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.decomposition import LatentDirichletAllocation
from typing import List, Tuple
from multiprocessing.pool import Pool
from functools import partial
import itertools
from concurrent import futures
class GoldenLDA:
def __init__(self, timer, name=None):
self.timer = timer
self.width = 5
self.name = "lda"
def create_document_term_matrix(self, df, col2):
word_list = self.create_word_list(df, col2)
vectorizer = CountVectorizer()
return vectorizer.fit_transform(word_list)
def compute_latent_vectors(self, col2, df) -> np.ndarray:
document_term_matrix = self.create_document_term_matrix(df, col2)
transformer = LatentDirichletAllocation(n_components=5, learning_method="online", random_state=99)
return transformer.fit_transform(document_term_matrix)
def create_features(self, df, target_cols) -> pd.DataFrame:
target_cols = target_cols
col2s = []
latent_vectors = []
future_list = list()
with futures.ProcessPoolExecutor(max_workers=len(target_cols)) as executor:
for c in target_cols:
col2s.append(c)
future_list.append(executor.submit(self.compute_latent_vectors, c, df))
future_results = [f.result() for f in future_list]
for res in future_results:
latent_vectors.append(res.astype(np.float32))
self.timer.time("done lda ")
# gc.collect()
# with Pool(15) as p:
# for col1, col2, latent_vector in p.map(
# partial(self.compute_latent_vectors, train, test), column_pairs):
# col1s.append(col1)
# col2s.append(col2)
# latent_vectors.append(latent_vector.astype(np.float32))
gc.collect()
return self.get_feature(df, col2s, latent_vectors)
def get_feature(self, df: pd.DataFrame, cs2: List[str], vs: List[np.ndarray]) -> pd.DataFrame:
card_set = list(set(df["card_id"]))
features = np.zeros(shape=(len(card_set), len(cs2) * self.width), dtype=np.float32)
columns = list()
for i, (col2, latent_vector) in enumerate(zip(cs2, vs)):
offset = i * self.width
for j in range(self.width):
columns.append(self.name + '-' + col2 + '-' + str(j))
for j, val1 in enumerate(card_set):
features[j, offset:offset + self.width] = latent_vector[val1]
ret_df = pd.DataFrame(data=features, columns=columns)
ret_df["card_id"] = card_set
return ret_df
@staticmethod
def create_word_list(df: pd.DataFrame, col2: str) -> List[str]:
# col1_size = df["card_id"].max() + 1
# col2_list = [[] for _ in range(col1_size)]
# for val2 in df[col2]:
# col2_list[val2].append(val2+10) # 1-9 is a stop word
# return [' '.join(map(str, a_list)) for a_list in col2_list]
card_set = list(set(df["card_id"]))
col2_list = list()
for val1 in card_set:
_df = df[df["card_id"] == val1]
col2_list.append(list(_df[col2]+10)) # add 10 to avoid stop-word
return [' '.join(map(str, a_list)) for a_list in col2_list]
| [
"shota.okubo@dena.com"
] | shota.okubo@dena.com |
4b0d73f1c9d3600690df7eb5b54d526f2b7a0427 | 2cf2df2807fff90d4c82c1cbbbece272a4b469c2 | /gplib/core/__init__.py | 1038489a4cd5070d90c14b2d9f7b42cb4ce8684d | [] | no_license | marcpalaci689/gplib | 826466f42da085b91d37297631fcc709c00edc3a | 859ed08d7b77b1a4f4ed3f0cdb5db8930ee95465 | refs/heads/master | 2021-09-01T12:19:30.683620 | 2017-12-27T00:11:02 | 2017-12-27T00:11:02 | 115,462,968 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 20 | py | from .gp import GP
| [
"marcpalaci689@gmail.com"
] | marcpalaci689@gmail.com |
1292e503e8b05cd9f288de556289ca29880a41cc | f31fda8014ecadf6af7d4e3392fb917c49e0352a | /HeavyIonsAnalysis/JetAnalysis/python/jets/akVs4CaloJetSequence_PbPb_jec_cff.py | 1138081e341c23d6cf41f8774dfe47930fc4f528 | [] | no_license | jniedzie/lightbylight | acea5051f053c49824a49a0b78bac3a2247ee75f | f5a4661fcf3fd3c0e9ccd8893a46a238e30c2aa8 | refs/heads/master | 2020-03-18T12:24:31.970468 | 2018-02-09T15:50:00 | 2018-02-09T15:50:00 | 134,724,759 | 0 | 1 | null | 2018-05-24T14:11:12 | 2018-05-24T14:11:12 | null | UTF-8 | Python | false | false | 14,330 | py |
import FWCore.ParameterSet.Config as cms
from HeavyIonsAnalysis.JetAnalysis.patHeavyIonSequences_cff import patJetGenJetMatch, patJetPartonMatch, patJetCorrFactors, patJets
from HeavyIonsAnalysis.JetAnalysis.inclusiveJetAnalyzer_cff import *
from HeavyIonsAnalysis.JetAnalysis.bTaggers_cff import *
from RecoJets.JetProducers.JetIDParams_cfi import *
from RecoJets.JetProducers.nJettinessAdder_cfi import Njettiness
akVs4Calomatch = patJetGenJetMatch.clone(
src = cms.InputTag("akVs4CaloJets"),
matched = cms.InputTag("ak4HiSignalGenJets"),
resolveByMatchQuality = cms.bool(True),
maxDeltaR = 0.4
)
akVs4CalomatchGroomed = patJetGenJetMatch.clone(
src = cms.InputTag("ak4HiGenJets"),
matched = cms.InputTag("ak4HiSignalGenJets"),
resolveByMatchQuality = cms.bool(True),
maxDeltaR = 0.4
)
akVs4Caloparton = patJetPartonMatch.clone(src = cms.InputTag("akVs4CaloJets")
)
akVs4Calocorr = patJetCorrFactors.clone(
useNPV = cms.bool(False),
useRho = cms.bool(False),
# primaryVertices = cms.InputTag("hiSelectedVertex"),
levels = cms.vstring('L2Relative','L3Absolute'),
src = cms.InputTag("akVs4CaloJets"),
payload = "AK4Calo_offline"
)
akVs4CaloJetID= cms.EDProducer('JetIDProducer', JetIDParams, src = cms.InputTag('akVs4CaloJets'))
#akVs4Caloclean = heavyIonCleanedGenJets.clone(src = cms.InputTag('ak4HiSignalGenJets'))
akVs4CalobTagger = bTaggers("akVs4Calo",0.4)
#create objects locally since they dont load properly otherwise
#akVs4Calomatch = akVs4CalobTagger.match
akVs4Caloparton = patJetPartonMatch.clone(src = cms.InputTag("akVs4CaloJets"), matched = cms.InputTag("hiSignalGenParticles"))
akVs4CaloPatJetFlavourAssociationLegacy = akVs4CalobTagger.PatJetFlavourAssociationLegacy
akVs4CaloPatJetPartons = akVs4CalobTagger.PatJetPartons
akVs4CaloJetTracksAssociatorAtVertex = akVs4CalobTagger.JetTracksAssociatorAtVertex
akVs4CaloJetTracksAssociatorAtVertex.tracks = cms.InputTag("highPurityTracks")
akVs4CaloSimpleSecondaryVertexHighEffBJetTags = akVs4CalobTagger.SimpleSecondaryVertexHighEffBJetTags
akVs4CaloSimpleSecondaryVertexHighPurBJetTags = akVs4CalobTagger.SimpleSecondaryVertexHighPurBJetTags
akVs4CaloCombinedSecondaryVertexBJetTags = akVs4CalobTagger.CombinedSecondaryVertexBJetTags
akVs4CaloCombinedSecondaryVertexV2BJetTags = akVs4CalobTagger.CombinedSecondaryVertexV2BJetTags
akVs4CaloJetBProbabilityBJetTags = akVs4CalobTagger.JetBProbabilityBJetTags
akVs4CaloSoftPFMuonByPtBJetTags = akVs4CalobTagger.SoftPFMuonByPtBJetTags
akVs4CaloSoftPFMuonByIP3dBJetTags = akVs4CalobTagger.SoftPFMuonByIP3dBJetTags
akVs4CaloTrackCountingHighEffBJetTags = akVs4CalobTagger.TrackCountingHighEffBJetTags
akVs4CaloTrackCountingHighPurBJetTags = akVs4CalobTagger.TrackCountingHighPurBJetTags
akVs4CaloPatJetPartonAssociationLegacy = akVs4CalobTagger.PatJetPartonAssociationLegacy
akVs4CaloImpactParameterTagInfos = akVs4CalobTagger.ImpactParameterTagInfos
akVs4CaloImpactParameterTagInfos.primaryVertex = cms.InputTag("offlinePrimaryVertices")
akVs4CaloJetProbabilityBJetTags = akVs4CalobTagger.JetProbabilityBJetTags
akVs4CaloSecondaryVertexTagInfos = akVs4CalobTagger.SecondaryVertexTagInfos
akVs4CaloSimpleSecondaryVertexHighEffBJetTags = akVs4CalobTagger.SimpleSecondaryVertexHighEffBJetTags
akVs4CaloSimpleSecondaryVertexHighPurBJetTags = akVs4CalobTagger.SimpleSecondaryVertexHighPurBJetTags
akVs4CaloCombinedSecondaryVertexBJetTags = akVs4CalobTagger.CombinedSecondaryVertexBJetTags
akVs4CaloCombinedSecondaryVertexV2BJetTags = akVs4CalobTagger.CombinedSecondaryVertexV2BJetTags
akVs4CaloSecondaryVertexNegativeTagInfos = akVs4CalobTagger.SecondaryVertexNegativeTagInfos
akVs4CaloNegativeSimpleSecondaryVertexHighEffBJetTags = akVs4CalobTagger.NegativeSimpleSecondaryVertexHighEffBJetTags
akVs4CaloNegativeSimpleSecondaryVertexHighPurBJetTags = akVs4CalobTagger.NegativeSimpleSecondaryVertexHighPurBJetTags
akVs4CaloNegativeCombinedSecondaryVertexBJetTags = akVs4CalobTagger.NegativeCombinedSecondaryVertexBJetTags
akVs4CaloPositiveCombinedSecondaryVertexBJetTags = akVs4CalobTagger.PositiveCombinedSecondaryVertexBJetTags
akVs4CaloNegativeCombinedSecondaryVertexV2BJetTags = akVs4CalobTagger.NegativeCombinedSecondaryVertexV2BJetTags
akVs4CaloPositiveCombinedSecondaryVertexV2BJetTags = akVs4CalobTagger.PositiveCombinedSecondaryVertexV2BJetTags
akVs4CaloSoftPFMuonsTagInfos = akVs4CalobTagger.SoftPFMuonsTagInfos
akVs4CaloSoftPFMuonsTagInfos.primaryVertex = cms.InputTag("offlinePrimaryVertices")
akVs4CaloSoftPFMuonBJetTags = akVs4CalobTagger.SoftPFMuonBJetTags
akVs4CaloSoftPFMuonByIP3dBJetTags = akVs4CalobTagger.SoftPFMuonByIP3dBJetTags
akVs4CaloSoftPFMuonByPtBJetTags = akVs4CalobTagger.SoftPFMuonByPtBJetTags
akVs4CaloNegativeSoftPFMuonByPtBJetTags = akVs4CalobTagger.NegativeSoftPFMuonByPtBJetTags
akVs4CaloPositiveSoftPFMuonByPtBJetTags = akVs4CalobTagger.PositiveSoftPFMuonByPtBJetTags
akVs4CaloPatJetFlavourIdLegacy = cms.Sequence(akVs4CaloPatJetPartonAssociationLegacy*akVs4CaloPatJetFlavourAssociationLegacy)
#Not working with our PU sub, but keep it here for reference
#akVs4CaloPatJetFlavourAssociation = akVs4CalobTagger.PatJetFlavourAssociation
#akVs4CaloPatJetFlavourId = cms.Sequence(akVs4CaloPatJetPartons*akVs4CaloPatJetFlavourAssociation)
akVs4CaloJetBtaggingIP = cms.Sequence(akVs4CaloImpactParameterTagInfos *
(akVs4CaloTrackCountingHighEffBJetTags +
akVs4CaloTrackCountingHighPurBJetTags +
akVs4CaloJetProbabilityBJetTags +
akVs4CaloJetBProbabilityBJetTags
)
)
akVs4CaloJetBtaggingSV = cms.Sequence(akVs4CaloImpactParameterTagInfos
*
akVs4CaloSecondaryVertexTagInfos
* (akVs4CaloSimpleSecondaryVertexHighEffBJetTags+
akVs4CaloSimpleSecondaryVertexHighPurBJetTags+
akVs4CaloCombinedSecondaryVertexBJetTags+
akVs4CaloCombinedSecondaryVertexV2BJetTags
)
)
akVs4CaloJetBtaggingNegSV = cms.Sequence(akVs4CaloImpactParameterTagInfos
*
akVs4CaloSecondaryVertexNegativeTagInfos
* (akVs4CaloNegativeSimpleSecondaryVertexHighEffBJetTags+
akVs4CaloNegativeSimpleSecondaryVertexHighPurBJetTags+
akVs4CaloNegativeCombinedSecondaryVertexBJetTags+
akVs4CaloPositiveCombinedSecondaryVertexBJetTags+
akVs4CaloNegativeCombinedSecondaryVertexV2BJetTags+
akVs4CaloPositiveCombinedSecondaryVertexV2BJetTags
)
)
akVs4CaloJetBtaggingMu = cms.Sequence(akVs4CaloSoftPFMuonsTagInfos * (akVs4CaloSoftPFMuonBJetTags
+
akVs4CaloSoftPFMuonByIP3dBJetTags
+
akVs4CaloSoftPFMuonByPtBJetTags
+
akVs4CaloNegativeSoftPFMuonByPtBJetTags
+
akVs4CaloPositiveSoftPFMuonByPtBJetTags
)
)
akVs4CaloJetBtagging = cms.Sequence(akVs4CaloJetBtaggingIP
*akVs4CaloJetBtaggingSV
*akVs4CaloJetBtaggingNegSV
# *akVs4CaloJetBtaggingMu
)
akVs4CalopatJetsWithBtagging = patJets.clone(jetSource = cms.InputTag("akVs4CaloJets"),
genJetMatch = cms.InputTag("akVs4Calomatch"),
genPartonMatch = cms.InputTag("akVs4Caloparton"),
jetCorrFactorsSource = cms.VInputTag(cms.InputTag("akVs4Calocorr")),
JetPartonMapSource = cms.InputTag("akVs4CaloPatJetFlavourAssociationLegacy"),
JetFlavourInfoSource = cms.InputTag("akVs4CaloPatJetFlavourAssociation"),
trackAssociationSource = cms.InputTag("akVs4CaloJetTracksAssociatorAtVertex"),
useLegacyJetMCFlavour = True,
discriminatorSources = cms.VInputTag(cms.InputTag("akVs4CaloSimpleSecondaryVertexHighEffBJetTags"),
cms.InputTag("akVs4CaloSimpleSecondaryVertexHighPurBJetTags"),
cms.InputTag("akVs4CaloCombinedSecondaryVertexBJetTags"),
cms.InputTag("akVs4CaloCombinedSecondaryVertexV2BJetTags"),
cms.InputTag("akVs4CaloJetBProbabilityBJetTags"),
cms.InputTag("akVs4CaloJetProbabilityBJetTags"),
#cms.InputTag("akVs4CaloSoftPFMuonByPtBJetTags"),
#cms.InputTag("akVs4CaloSoftPFMuonByIP3dBJetTags"),
cms.InputTag("akVs4CaloTrackCountingHighEffBJetTags"),
cms.InputTag("akVs4CaloTrackCountingHighPurBJetTags"),
),
jetIDMap = cms.InputTag("akVs4CaloJetID"),
addBTagInfo = True,
addTagInfos = True,
addDiscriminators = True,
addAssociatedTracks = True,
addJetCharge = False,
addJetID = False,
getJetMCFlavour = True,
addGenPartonMatch = True,
addGenJetMatch = True,
embedGenJetMatch = True,
embedGenPartonMatch = True,
# embedCaloTowers = False,
# embedPFCandidates = True
)
akVs4CaloNjettiness = Njettiness.clone(
src = cms.InputTag("akVs4CaloJets"),
R0 = cms.double( 0.4)
)
akVs4CalopatJetsWithBtagging.userData.userFloats.src += ['akVs4CaloNjettiness:tau1','akVs4CaloNjettiness:tau2','akVs4CaloNjettiness:tau3']
akVs4CaloJetAnalyzer = inclusiveJetAnalyzer.clone(jetTag = cms.InputTag("akVs4CalopatJetsWithBtagging"),
genjetTag = 'ak4HiGenJets',
rParam = 0.4,
matchJets = cms.untracked.bool(False),
matchTag = 'patJetsWithBtagging',
pfCandidateLabel = cms.untracked.InputTag('particleFlowTmp'),
trackTag = cms.InputTag("hiGeneralTracks"),
fillGenJets = True,
isMC = True,
doSubEvent = True,
useHepMC = cms.untracked.bool(False),
genParticles = cms.untracked.InputTag("genParticles"),
eventInfoTag = cms.InputTag("generator"),
doLifeTimeTagging = cms.untracked.bool(True),
doLifeTimeTaggingExtras = cms.untracked.bool(False),
bTagJetName = cms.untracked.string("akVs4Calo"),
jetName = cms.untracked.string("akVs4Calo"),
genPtMin = cms.untracked.double(5),
hltTrgResults = cms.untracked.string('TriggerResults::'+'HISIGNAL'),
doTower = cms.untracked.bool(True),
doSubJets = cms.untracked.bool(False),
doGenSubJets = cms.untracked.bool(False),
subjetGenTag = cms.untracked.InputTag("ak4GenJets"),
doGenTaus = True
)
akVs4CaloJetSequence_mc = cms.Sequence(
#akVs4Caloclean
#*
akVs4Calomatch
#*
#akVs4CalomatchGroomed
*
akVs4Caloparton
*
akVs4Calocorr
*
#akVs4CaloJetID
#*
akVs4CaloPatJetFlavourIdLegacy
#*
#akVs4CaloPatJetFlavourId # Use legacy algo till PU implemented
*
akVs4CaloJetTracksAssociatorAtVertex
*
akVs4CaloJetBtagging
*
akVs4CaloNjettiness
*
akVs4CalopatJetsWithBtagging
*
akVs4CaloJetAnalyzer
)
akVs4CaloJetSequence_data = cms.Sequence(akVs4Calocorr
*
#akVs4CaloJetID
#*
akVs4CaloJetTracksAssociatorAtVertex
*
akVs4CaloJetBtagging
*
akVs4CaloNjettiness
*
akVs4CalopatJetsWithBtagging
*
akVs4CaloJetAnalyzer
)
akVs4CaloJetSequence_jec = cms.Sequence(akVs4CaloJetSequence_mc)
akVs4CaloJetSequence_mb = cms.Sequence(akVs4CaloJetSequence_mc)
akVs4CaloJetSequence = cms.Sequence(akVs4CaloJetSequence_jec)
akVs4CaloJetAnalyzer.genPtMin = cms.untracked.double(1)
akVs4CaloJetAnalyzer.jetPtMin = cms.double(1)
| [
"rchudasa@cern.ch"
] | rchudasa@cern.ch |
4f5c3e036dff53545e0841fdd9c6bd81bce99281 | 56e1844ca3e1c7bcc8f1d2a8c1465bf7120b3c08 | /Hypothesis_Candy.py | c8aa330e8e736dd7a36bae62d4fc8a82f052bd38 | [] | no_license | rl9703/Artificial-Intelligence | d95c32ffcd83a63cdc5b0461842dea6366c65838 | e39736ba6c33136b5287968df4612be6044770d6 | refs/heads/master | 2022-02-14T23:57:30.674789 | 2022-01-30T08:13:58 | 2022-01-30T08:13:58 | 208,346,041 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,287 | py | '''
Author: Rishab Lalwani
Title: Q1 Generate a data set of length 100 and
plot the cor- responding graphs for P(hi|d1,...,dN) and P(DN+1=lime|d1,...,dN)
'''
import random as rand
import matplotlib.pyplot as plt
def P(x):
'''
:param x: Hypothesis of candy bags
:return: Graph plot of all hypothesis
'''
post = [0.1, 0.2, 0.4, 0.2, 0.1]
hypothesis1 = []
hypothesis2 = []
hypothesis3 = []
hypothesis4 = []
hypothesis5 = []
alpha = 1
train = []
for hype in range(10):
new_list = []
train.append(alpha)
for i in range(len(x)):
cherry = x[i].count('Lime')
new_list.append((((alpha * cherry) / len(x[i])) * post[i]))
alpha = 1 / sum(new_list)
post = new_list
hypothesis1.append(new_list[0])
hypothesis2.append(new_list[1])
hypothesis3.append(new_list[2])
hypothesis4.append(new_list[3])
hypothesis5.append(new_list[4])
number_of_obs=list(range(1,11))
#Plotting
plt.plot(number_of_obs, hypothesis1)
plt.plot(number_of_obs, hypothesis2)
plt.plot(number_of_obs, hypothesis3)
plt.plot(number_of_obs, hypothesis4)
plt.plot(number_of_obs, hypothesis5)
plt.show()
pred(x, post)
def pred(x,post):
'''
:param x: Hypothesis of candy bags
:param post: P(h/D) probabilities
:return: predicted output along with graph plot
'''
pred_output= []
post=[0.1, 0.2, 0.4, 0.2, 0.1]
for j in range(10):
list = []
for i in range(len(x)):
lime = x[i].count("Lime")
len_lime=(lime / len(x[i]))
formula=(len_lime) * post[i]
list.append(formula)
pred_output.append(1-sum(list))
post = list
print(pred_output)
plt.plot([1,2,3,4,5,6,7,8,9,10], pred_output)
plt.show()
def main():
'''
:return: Create hypothesis and call probability function
'''
h1 = ['Cherry'] * 100
h2 = ['Cherry'] * 75 + ['Lime'] * 25
h3 = ['Cherry'] * 50 + ['Lime'] * 50
h4 = ['Cherry'] * 25 + ['Lime'] * 75
h5 = ['Lime'] * 100
rand.shuffle(h2)
rand.shuffle(h3)
rand.shuffle(h4)
hypothesis = [h1,h2,h3,h4,h5]
P(hypothesis)
if __name__ == '__main__':
main() | [
"noreply@github.com"
] | rl9703.noreply@github.com |
f1404f7a787c775f3ce768b273fdb666e2071008 | 2d3dc770005c152f459be6f59062b736dc00aa69 | /2048/code/tkinter_event.py | 3d237a061bb54630c553e75a0c527c7db1110946 | [] | no_license | s-python-git/Python-The-code-base | 42394f9459cbcc6544486fb98ab04352eecad568 | b85052af64e5909d38649ee4ab576e608607ba50 | refs/heads/master | 2020-04-27T23:48:30.650696 | 2019-11-25T09:29:52 | 2019-11-25T09:29:52 | 174,791,058 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 609 | py | # tkinter_event.py
import tkinter
root = tkinter.Tk()
def onKeyDown(event):
print("有键盘按键被按下:event=", event)
print(event.keycode, event.keysym, event.char)
def onKeyUp(event):
print("有键盘按键抬起!", event)
root.bind('<KeyPress>', onKeyDown)
root.bind('<KeyRelease>', onKeyUp)
def mouseDown(e):
print("有鼠标按键按下在", e.x, e.y, e.x_root, e.y_root)
root.bind('<Button>', mouseDown)
def mouseUp(e):
print("有鼠标按键抬起", e.x, e.y)
if e.num == 2:
print("中间键抬起!!!")
root.bind("<ButtonRelease>", mouseUp)
root.mainloop()
| [
"noreply@github.com"
] | s-python-git.noreply@github.com |
33dfd9eb9fc3006a8361ccc098a0c07b7feb98b1 | b106f6d4b3776b14fca34864bee4ccf3fb5186a9 | /OLS(F, M).py | effaf45acf0a63c0e1e6b56d04e9b9acec62eb90 | [] | no_license | KalyakulinaAnastasiya/DNA | 935bdacb3d5a723abd1657008f63e50696ca4679 | 171287d9c9eba2e9140851a6f73982691f6febbd | refs/heads/master | 2020-09-09T15:18:30.442332 | 2020-05-05T18:51:32 | 2020-05-05T18:51:32 | 221,481,882 | 0 | 0 | null | 2019-11-13T14:46:44 | 2019-11-13T14:46:43 | null | UTF-8 | Python | false | false | 1,529 | py | import numpy as np
import statsmodels.api as sm
import pickle
import matplotlib.pyplot as plt
file = open('observables.txt', 'r')
age_key = 'age'
#pers_key = 'geo_accession'
gender_key = 'gender'
line = file.readline().rstrip()
line_list = line.split('\t')
#pers_id = line_list.index(pers_key)
age_id = line_list.index(age_key)
gender_id = line_list.index(gender_key)
line_age = []
line_m = []
line_f = []
age_m = []
age_f = []
i = 0
for line in file:
line_list = line.rstrip().split('\t')
line_age.append(int(line_list[age_id]))
if line_list[gender_id] == 'M':
line_m.append(i)
else:
line_f.append(i)
i += 1
file.close()
for i in line_m:
age_m.append(line_age[i])
for i in line_f:
age_f.append(line_age[i])
with open('gene_row', 'rb') as handle:
gene_row = pickle.load(handle)
gene_id = gene_row['ELOVL2']
data = np.load('gene_npz.txt.npz')
betas = data['arr_0']
cpg_betas = betas[gene_id]
betas_m = []
betas_f = []
for i in line_m:
betas_m.append(cpg_betas[i])
for i in line_f:
betas_f.append(cpg_betas[i])
X = sm.add_constant(age_m)
model = sm.OLS(betas_m, X)
results_m = model.fit()
Y = sm.add_constant(age_f)
model = sm.OLS(betas_f, Y)
results_f = model.fit()
plt.scatter(age_m, betas_m, label='', color='c', s=8)
plt.scatter(age_f, betas_f, label='', color='m', s=8)
plt.plot(X, results_m.predict(X), color='blue', linewidth=2)
plt.plot(Y, results_f.predict(Y), color='red', linewidth=2)
plt.title('ELOVL2')
plt.xlabel('age')
plt.ylabel('betas')
plt.show() | [
"aaron.blare@mail.ru"
] | aaron.blare@mail.ru |
a05cf8f5a0bbfbc66fc6366b15421295bcad5546 | 68e66947c2b2a2f1a1cac52a99363ce37f33e9bb | /getdata.py | 2eb211b79b5f329ebe7dad60d8c9b3cf6781e662 | [] | no_license | trmcdade/Manifesto | 30c424127bf734a63f9af13bb25671769077926a | 9a0d150783485492e8c45ebeb37ee41c9c31b253 | refs/heads/master | 2020-06-11T09:31:32.493158 | 2019-06-28T17:14:09 | 2019-06-28T17:14:09 | 193,917,576 | 1 | 0 | null | 2019-06-26T19:35:28 | 2019-06-26T14:10:24 | R | UTF-8 | Python | false | false | 950 | py | import urllib.request, json, ssl
#bypass SSL verification
context = ssl._create_unverified_context()
#you will need your own API. play around with key= parm also
with urllib.request.urlopen("https://manifesto-project.wzb.eu/tools/api_get_core.json?api_key=d00c54e1a64ef97f7a032c91ff45a627&key=MPDS2018b", context=context) as url:
cmp_test = json.loads(url.read().decode())
#returns a list
#basic packages
import pandas as pd
import numpy as np
#create index col
index= list(range(len(cmp_test)))
#turn imported data into pd dataframe
d = pd.DataFrame(data = cmp_test,columns=cmp_test[0], index=index)
#checks:
len(d) #this year N=3925
#say we want 2/3 to be the training set:
#train_amount = round(len(d)*2/3)
#and the rest to be the validation set:
#val_amount = 1- train_amount
#slice data (non-random):
#train_set = d.iloc[[1,train_amount],:]
#val_set = d.iloc[[train_amount + 1, len(d) - 1],:]
#carry on with the actual training
| [
"kylechan@unc.edu"
] | kylechan@unc.edu |
291e37a89529fee6456f713f03a74745d05ca459 | ef905b3f490049212ea7edf777f82eba85328741 | /hist_nsepy.py | 5ecf1a9717dedea68167734c50dd3c3d462a1bc8 | [] | no_license | ghoshsudipto/DA | 98d144541a7355efddd783bc304af396548af5e9 | dbd8725c64bfa9a7e55ff75ee5fa2e8fa270719a | refs/heads/master | 2023-08-18T04:58:12.607293 | 2023-07-27T09:11:07 | 2023-07-27T09:11:07 | 217,709,954 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,284 | py | import pandas as pd
from datetime import date
from nsepy import get_history
scrip = input('Scrip:')
series = date(2004, 1, 29), date(2004, 2, 26), date(2004, 3, 25), date(2004, 4, 29), date(2004, 5, 27), date(2004, 6, 24), date(2004, 7, 29),\
date(2004, 8, 26), date(2004, 9, 30), date(2004, 10, 28), date(2004, 11, 25), date(2004, 12, 30), date(2005, 1, 27), date(2005, 2, 24),\
date(2005, 3, 31), date(2005, 4, 28), date(2005, 5, 26), date(2005, 6, 30), date(2005, 7, 28), date(2005, 8, 25), date(2005, 9, 29),\
date(2005, 10, 27), date(2005, 11, 24), date(2005, 12, 29), date(2006, 1, 25), date(2006, 2, 23), date(2006, 3, 30), date(2006, 4, 27),\
date(2006, 5, 25), date(2006, 6, 29), date(2006, 7, 27), date(2006, 8, 31), date(2006, 9, 28), date(2006, 10, 26), date(2006, 11, 30),\
date(2006, 12, 28), date(2007, 1, 25), date(2007, 2, 22), date(2007, 3, 29), date(2007, 4, 26), date(2007, 5, 31), date(2007, 6, 28),\
date(2007, 7, 26), date(2007, 8, 30), date(2007, 9, 27), date(2007, 10, 25), date(2007, 11, 29), date(2007, 12, 27), date(2008, 1, 31), \
date(2008, 2, 28), date(2008, 3, 27), date(2008, 4, 24), date(2008, 5, 29), date(2008, 6, 26), date(2008, 7, 31), date(2008, 8, 28),\
date(2008, 9, 25), date(2008, 10, 29), date(2008, 11, 27), date(2008, 12, 25), date(2009, 1, 29), date(2009, 2, 26), date(2009, 3, 26),\
date(2009, 4, 30), date(2009, 5, 28), date(2009, 6, 25), date(2009, 7, 30), date(2009, 8, 27), date(2009, 9, 24), date(2009, 10, 29),\
date(2009, 11, 26), date(2009, 12, 31), date(2010, 1, 28), date(2010, 2, 25), date(2010, 3, 25), date(2010, 4, 29), date(2010, 5, 27),\
date(2010, 6, 24), date(2010, 7, 29), date(2010, 8, 26), date(2010, 9, 30), date(2010, 10, 28), date(2010, 11, 25), date(2010, 12, 30),\
date(2011, 1, 27), date(2011, 2, 24), date(2011, 3, 31), date(2011, 4, 28), date(2011, 5, 26), date(2011, 6, 30), date(2011, 7, 28),\
date(2011, 8, 25), date(2011, 9, 29), date(2011, 10, 25), date(2011, 11, 24), date(2011, 12, 29), date(2012, 1, 25), date(2012, 2, 23),\
date(2012, 3, 29), date(2012, 4, 26), date(2012, 5, 31), date(2012, 6, 28), date(2012, 7, 26), date(2012, 8, 30), date(2012, 9, 27),\
date(2012, 10, 25), date(2012, 11, 29), date(2012, 12, 27), date(2013, 1, 31), date(2013, 2, 28), date(2013, 3, 28), date(2013, 4, 25),\
date(2013, 5, 30), date(2013, 6, 27), date(2013, 7, 25), date(2013, 8, 29), date(2013, 9, 26), date(2013, 10, 31), date(2013, 11, 28),\
date(2013, 12, 26), date(2014, 1, 30), date(2014, 2, 26), date(2014, 3, 27), date(2014, 4, 24), date(2014, 5, 29), date(2014, 6, 26),\
date(2014, 7, 31), date(2014, 8, 28), date(2014, 9, 25), date(2014, 10, 30), date(2014, 11, 27), date(2014, 12, 24), date(2015, 1, 29),\
date(2015, 2, 26), date(2015, 3, 26), date(2015, 4, 30), date(2015, 5, 28), date(2015, 6, 25), date(2015, 7, 30), date(2015, 8, 27),\
date(2015, 9, 24), date(2015, 10, 29), date(2015, 11, 26), date(2015, 12, 31), date(2016, 1, 28), date(2016, 2, 25), date(2016, 3, 31),\
date(2016, 4, 28), date(2016, 5, 26), date(2016, 6, 30), date(2016, 7, 28), date(2016, 8, 25), date(2016, 9, 29), date(2016, 10, 27),\
date(2016, 11, 24), date(2016, 12, 29), date(2017, 1, 25), date(2017, 2, 23), date(2017, 3, 30), date(2017, 4, 27), date(2017, 5, 25),\
date(2017, 6, 29), date(2017, 7, 27), date(2017, 8, 31), date(2017, 9, 28), date(2017, 10, 26), date(2017, 11, 30), date(2017, 12, 28),\
date(2018, 1, 25), date(2018, 2, 22), date(2018, 3, 28), date(2018, 4, 26), date(2018, 5, 31), date(2018, 6, 28), date(2018, 7, 26),\
date(2018, 8, 30), date(2018, 9, 27), date(2018, 10, 25), date(2018, 11, 29), date(2018, 12, 27), date(2019, 1, 31), date(2019, 2, 28),\
date(2019, 3, 28), date(2019, 4, 25), date(2019, 5, 30), date(2019, 6, 27), date(2019, 7, 25), date(2019, 8, 29), date(2019, 9, 26), \
date(2019, 10, 31), date(2019, 11, 28), date(2019, 12, 26)
col = pd.DataFrame({'Date': [], 'Symbol': [], 'Expiry': [], 'Open': [], 'High': [], 'Low': [], 'Close': [], 'LTP': [], 'Settlement Price': [],
'Number of Contracts': [], 'Turnover': [], 'Open Interest': [], 'Change in OI': [], 'Underlying': []})
open(f'D:\homework\dataset\{scrip}.csv', 'w')
col.to_csv(f'D:\homework\dataset\{scrip}.csv', header=True, index=False)
for i in series:
df_fut = get_history(symbol=scrip, start=date(2000, 1, 1), end=date(2020, 1, 20), futures=True, expiry_date=i)
df_fut.to_csv(f'D:\homework\dataset\{scrip}.csv', mode='a', header=False)
Sub format()
Range("A1:Z5000").Find(what:="Open Interest").Offset(1).Select
Range(Selection, Selection.End(xlDown)).Select
Selection.Replace what:=",", Replacement:="", LookAt:=xlPart, _
SearchOrder:=xlByRows, MatchCase:=True, SearchFormat:=False, _
ReplaceFormat:=False
Range("A1:Z5000").Find(what:="open Interest Int").Offset(1).Select
ActiveCell.FormulaR1C1 = "=INT(RC[-3])"
ActiveCell.Offset(0, -1).Range("A1").Select
Selection.End(xlDown).Select
ActiveCell.Offset(0, 1).Range("A1").Select
Range(Selection, Selection.End(xlUp)).Select
Selection.FillDown
ActiveSheet.Calculate
Range("A1:Z5000").Find(what:="open Interest Int").Offset(1).Select
End Sub
| [
"noreply@github.com"
] | ghoshsudipto.noreply@github.com |
6b757a2650f5ee9d6947c57165ed1c0576b47485 | b628d0cf1717c466f193c90ce6a63fd40a1c3888 | /test.py | 5964dbe14b4c6bcc15952d1dbebe5e841e89d60a | [] | no_license | RduMarais/pioupiou | 8193cb00536e8479ac31b005916bd699baaa8636 | eafccc0dd3fa1071428a46b8d3680b1f75cf427d | refs/heads/master | 2020-06-02T15:34:48.038832 | 2019-06-10T18:21:53 | 2019-06-10T18:21:53 | 191,210,534 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,623 | py | #!/bin/python3
import datetime
import cryptography
from Crypto import Random
from Crypto.Cipher import AES as AES
from Crypto.Cipher import DES as DES
from Crypto.Cipher import DES3 as DES3
from Crypto.PublicKey import RSA as RSA
from Crypto.Cipher import Blowfish as Blowfish
# from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey as X25519
import matplotlib.pyplot as plt
def main():
resultats = []
resultats.extend(tester(32))
resultats.extend(tester(64))
resultats.extend(tester(128))
resultats.extend(tester(256))
resultats.extend(tester(512))
resultats.extend(tester(1024))
resultats.extend(tester(2048))
resultats.extend(tester(4096))
resultats.extend(tester(8192))
resultats.extend(tester(16384))
# print(resultats)
faire_graphe(resultats)
#genere le graphique
def faire_graphe(resultats):
rsa = []
# x25519 = []
aes = []
blow = []
des = []
des3 = []
for res in resultats:
(label,value) = res
if(label=='RSA'):
if(value):
rsa.append(value)
else:
rsa.append(0)
# if(label=='X25519'):
# x25519.append(value)
if(label=='AES'):
aes.append(value)
if(label=='DES'):
des.append(value)
if(label=='triple DES'):
des3.append(value)
if(label=='Blowfish'):
blow.append(value)
axe = [32,64,128,256,512,1024,2048,4096,8192,16384]
# plt.plot(axe,aes,'bs',axe,des3,'gs',axe,des,'g--',axe,blow,'b--',axe[:3],rsa[:3],'r^',axe,x25519,'r--')
# la ligne suivante genere le graphique :
# AES en carres bleus
# DES en pointiles verts
# 3DES en carres verts
# Blowfish en pointilles bleus
plt.plot(axe,aes,'bs',axe,des3,'gs',axe,des,'g--',axe,blow,'b--',axe[:3],rsa[:3],'r^')
plt.title('Vitesse des algorithmes en fonction de la taille du message à chiffrer')
# plt.show()
plt.savefig('resultats_tpe.jpg')
def tester(msgSize):
resultats = []
input_msg = Random.new().read(msgSize)
# print(input_msg)
#preparer AES
aes_IV = Random.new().read(AES.block_size )
aes_symKey = Random.new().read(AES.block_size )
cipher_aes = AES.new(aes_symKey,AES.MODE_CBC,aes_IV)
#preparer RSA
rsa_privKey = RSA.generate(1024, Random.new().read) #generate pub and priv key
rsa_publicKey = rsa_privKey.publickey() # pub key export for exchange
#preparer DES
des_symKey = b'8bytekey'
des_IV = Random.new().read(DES.block_size )
cipher_des = DES.new(des_symKey,DES.MODE_OFB,des_IV)
#preparer 3DES
des3_symKey = b'Sixteen byte key'
des3_IV = Random.new().read(DES3.block_size )
cipher_3des = DES3.new(des3_symKey,DES3.MODE_OFB,des3_IV)
#Préparer Blowfish
blow_symKey = b'une cle de taille arbitraire'
blow_IV = Random.new().read(Blowfish.block_size)
cipher_blow = Blowfish.new(blow_symKey, Blowfish.MODE_CBC,blow_IV)
#preparer X25519
# x25519_privKey = X25519.generate()
# x25519_pubKey = x25519_privKey.public_key()
resultats.append(chronometrer_rsa_1('RSA',rsa_privKey,rsa_publicKey, input_msg))
# resultats.append(chronometrer_x25519('X25519',x25519_privKey,x25519_pubKey,input_msg))
resultats.append(chronometrer_sym('AES', cipher_aes, input_msg))
resultats.append(chronometrer_sym('Blowfish',cipher_blow, input_msg))
resultats.append(chronometrer_sym('DES',cipher_des, input_msg))
resultats.append(chronometrer_sym('triple DES',cipher_3des, input_msg))
return resultats
### FONCTIONS POUR CHIFFRER ET CHRONOMETRER
# def chronometrer_x25519(algo,privKey,publicKey,input_msg):
# print(algo)
# chrono = None
# try:
# tstart = datetime.datetime.now()
# message = privKey.sign(input_msg)
# tfinish = datetime.datetime.now()
# chrono = (tfinish - tstart).microseconds
# except ValueError as e:
# print('### ERREUR : '+str(e)+' = (en français) : Le message à chiffrer est trop large')
# print(algo+' : fini en : '+str(chrono))
# return(algo, chrono)
def chronometrer_rsa_1(algo, privKey,publicKey, input_msg):
print(algo)
chrono = None
try:
tstart = datetime.datetime.now()
# message = publicKey.encrypt(input_msg,32)
message = privKey.sign(input_msg,32)
tfinish = datetime.datetime.now()
chrono = (tfinish - tstart).microseconds
except ValueError as e:
print('### ERREUR : '+str(e)+' = (en français) : Le message à chiffrer est trop large')
print(algo +' : fini en : '+str(chrono))
return(algo, chrono)
def chronometrer_sym(algo,cipher, input_msg):
print(algo)
tstart = datetime.datetime.now()
message = cipher.encrypt(input_msg)
# print(message)
tfinish = datetime.datetime.now()
chrono = (tfinish - tstart).microseconds
print(algo +' : fini en : '+str(chrono))
return(algo, chrono)
## POUR ROMAIN SEULEMENT
if __name__ == '__main__':
main()
| [
"rmichon@telecom-paristech.fr"
] | rmichon@telecom-paristech.fr |
1c7c615a5d5f6ffd5521a19f65c1f52ac3bc6411 | ee6b18145acdd00821b4a7578882ab7bac07b237 | /lab10/main.py | d396d90a7bc35119a4c779f98b3a6ca2dd319b45 | [] | no_license | Szymek13/Wizualizacja_danych | ec5238f074c686479fe1f318b2a87ddf7afcd7a8 | 01051f37cc863eb82dc6ee1a0364a79da217e1f7 | refs/heads/main | 2023-05-28T03:03:55.121856 | 2021-05-30T14:22:20 | 2021-05-30T14:22:20 | 343,164,922 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,415 | py | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# Zadanie 1
x = np.arange(20, 40, 1)
y = (1/x)
plt.plot(x, y, 'b-', label='f(x)')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.axis([20, 40, 0.02, 0.05])
plt.title('Wykres funkcji f(x)')
plt.show()
# Zadanie 2
x = np.arange(20, 40, 1)
y = (1/x)
plt.plot(x, y, 'bo--', label='f(x)')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.axis([20, 40, 0.02, 0.05])
plt.title('Wykres funkcji f(x)')
plt.show()
# Zadanie 3
x1 = np.arange(0, 45, 0.1)
x2 = np.arange(0, 45, 0.1)
y1 = np.sin(x1)
y2 = np.cos(x2)
plt.plot(x1, y1, '-', label='sin(x)')
plt.plot(x2, y2, '--', label='cos(x)')
plt.axis([0, 45, -1, 1])
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend(loc='lower right')
plt.show()
# Zadanie 4
x1 = np.arange(0, 45, 0.1)
x2 = np.arange(0, 45, 0.1)
y1 = np.sin(x1+np.pi)
y2 = np.sin(x2)+2
plt.plot(x1, y1, '-', label='sin(x)')
plt.plot(x2, y2, '--', label='sin(x)')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend(loc='lower right')
plt.show()
# Zadanie 5
pliczek = pd.read_csv('iris.data', header=None, sep=',', decimal='.')
wykres = {'c': np.random.randn(150),
'x': pliczek[0],
'y': pliczek[1],
's': abs(pliczek[0] - pliczek[1])}
plt.scatter('x', 'y', c='c', s='s', data=wykres)
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.show()
| [
"noreply@github.com"
] | Szymek13.noreply@github.com |
2f7739039404274a4296d6d5ede3692379b78d93 | c72069c173dcbc475d051ac23dde5c69017604f3 | /testcase/test02_home_search.py | 36eba48b20cf9a3e777424a0d53d671f226d81f5 | [] | no_license | NamedWu/test1 | de454907bbd2455ed1a45cc1b240b6525b3c5512 | db0f5d1f5737e4975cfe5d8f704f26aad84e169a | refs/heads/master | 2023-01-08T23:43:16.536079 | 2020-11-14T12:20:38 | 2020-11-14T12:20:38 | 312,811,866 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,130 | py | import pytest
from selenium import webdriver
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.select import Select
from selenium.webdriver.common.by import By
import time
def test_select():
driver = webdriver.Chrome()
path = 'https://www.hibobi.com/'
driver.get(path)
# 通过显示等待的方法判断元素是否出现
WebDriverWait(driver, 10).until(EC.visibility_of_element_located((By.XPATH, "//*[@id='c-header']/div[2]/div[3]/div/input")))
select = driver.find_element_by_xpath('//*[@id="c-header"]/div[2]/div[3]/div/input')
Select(select).select_by_visible_text('Boy')
time.sleep(2)
if __name__ == '__main__':
pytest.main()
# # 根据下标进行选择，从0开始
# Select(select).select_by_index(1)
# time.sleep(2)
# # 根据value的值选择
# Select(select).select_by_value('daily')
# time.sleep(2)
# # 根基text选择
#
#
# # 判断选择是否预期
# WebDriverWait(driver,20).until(EC.element_located_to_be_selected((By.XPATH,'//*[contains(text(),"关注了")]'))) | [
"dengqingqign@duiba.com.cn"
] | dengqingqign@duiba.com.cn |
c808420814784eb74158420818d1e193c2cff1fe | eed5c6267fe9ac9031c21eae6bc53010261505ac | /tests/metrics/test_default_metrics.py | 9609d6d88e052ff6a942b412ee06c84c93ff3b82 | [
"MIT"
] | permissive | voxmedia/thumbor | 3a07ae182143b5a850bf63c36887a1ee8e3ad617 | 29b92b69e4c241ddd5ba429f8269d775a1508e70 | refs/heads/master | 2022-08-25T13:07:12.136876 | 2022-08-18T16:15:00 | 2022-08-18T16:15:00 | 22,433,808 | 6 | 0 | MIT | 2019-09-13T18:05:03 | 2014-07-30T15:33:42 | Python | UTF-8 | Python | false | false | 1,049 | py | #!/usr/bin/python
# -*- coding: utf-8 -*-
# thumbor imaging service
# https://github.com/thumbor/thumbor/wiki
# Licensed under the MIT license:
# http://www.opensource.org/licenses/mit-license
# Copyright (c) 2011 globo.com thumbor@googlegroups.com
import mock
from preggy import expect
import thumbor.metrics
from thumbor.importer import Importer
from tests.base import TestCase
class DefaultMetricsTestCase(TestCase):
def get_importer(self):
importer = Importer(self.config)
importer.import_modules()
return importer
def test_can_create_context_with_default_metrics(self):
expect(self.context).not_to_be_null()
expect(self.context.metrics).to_be_instance_of(thumbor.metrics.logger_metrics.Metrics)
@mock.patch('thumbor.metrics.BaseMetrics.initialize')
def test_can_initizalize_when_request_comes(self, mocked_initialize):
expect(mocked_initialize.call_count).to_equal(0)
self.fetch('/unsafe/smart/image.jpg')
expect(mocked_initialize.call_count).to_equal(1)
| [
"rflorianobr@gmail.com"
] | rflorianobr@gmail.com |
18735fd8a03cafe6b5b2fa7d241a8f0e31a492b3 | 51d504622c8bde5096d954bf9b38789d48ba4ff7 | /Python/flask_mysql/crud/users/flask_app/__init__.py | f2767c96c43e0e7e60569fcd53ccee202e799e37 | [] | no_license | BLee1126/Dojo-Assignments | 36c8fb2294c5cd6a04c065415aae12225c0eb483 | d40d8f6569b1f504d1785d8f34d27c58eab406c8 | refs/heads/main | 2023-07-10T16:00:30.863709 | 2021-08-20T16:42:10 | 2021-08-20T16:42:10 | 368,209,920 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 91 | py | # __init__.py
from flask import Flask
app = Flask(__name__)
app.secret_key = "shhhhhh"
| [
"blee1126@gmail.com"
] | blee1126@gmail.com |
c48934190004c26d23b8ca37db448b5e6c9e7310 | 434c7afe36b1b5600d559ca46a096d9e75d8f385 | /home/migrations/0009_auto_20200823_1957.py | 438f6f6adf024020e79b767f6506aca084005db3 | [] | no_license | cangcang123/cangcang123.github.io | d7acc91ddff4576ae2e7016b9814cb1587ae9074 | a6288e8f4079654bf0bf1a2c1b0dad264ad32b63 | refs/heads/master | 2022-12-02T20:19:45.994139 | 2020-08-24T13:15:22 | 2020-08-24T13:15:22 | 289,930,526 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,089 | py | # Generated by Django 3.0.8 on 2020-08-23 12:57
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('home', '0008_auto_20200821_2035'),
]
operations = [
migrations.RemoveField(
model_name='giohang',
name='idpro',
),
migrations.AddField(
model_name='giohang',
name='Pro',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='giohang', to='home.Products'),
),
migrations.AddField(
model_name='giohang',
name='gia',
field=models.CharField(max_length=30, null=True),
),
migrations.AddField(
model_name='giohang',
name='name',
field=models.CharField(max_length=50, null=True),
),
migrations.AddField(
model_name='giohang',
name='soluong',
field=models.IntegerField(max_length=11, null=True),
),
]
| [
"muspassyou7@gmail.com"
] | muspassyou7@gmail.com |
3904595484ebcb6236abea517fee084c507f798d | 93fae0c225f6ff3ab810997c8d9fb23d1e29a88f | /metaclass.py | a2048fc07ae0ac62917bd0f7c1cb237bac6449bb | [] | no_license | rahulkmr/python3_musings | fdb5d7765da654dac602c3d93d187c2f063cb8eb | b82b3384aec34c0d1d3c1f202b3dae014e541dc1 | refs/heads/master | 2021-01-22T03:22:18.792041 | 2017-05-25T06:36:53 | 2017-05-25T06:36:53 | 92,372,821 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 272 | py | #!/usr/bin/env python
class Meta(type):
def __new__(meta, classname, supers, classdict):
return type.__new__(meta, classname, supers, classdict)
def __init__(cls, classname, supers, classdict):
pass
class Klass(object, metaclass=Meta):
pass
| [
"rahul@thoughtnirvana.com"
] | rahul@thoughtnirvana.com |
42a05627e3a98cc0ead95e20b03d32f2cefee727 | 67d99eaf3e2355664d6b476e0cdfb4a376f5ace3 | /setup.py | 931fc78bd4758db172c223643c75612eea8bf75f | [] | no_license | Jef808/TicTacToePython | 7e9868b2efd28f1c2714ddce2db7eaae2afda9ea | c60f40bb3f4dd4beeee4533cb2d05a0b9251e98e | refs/heads/master | 2022-12-11T06:25:27.343644 | 2020-08-26T01:18:10 | 2020-08-26T01:18:10 | 290,363,299 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 119 | py | from setuptools import setup, find_packages
setup(name='TicTacToePython', version='2.0', packages=find_packages())
| [
"jf.arbour@gmail.com"
] | jf.arbour@gmail.com |
7b7636db25b9e2e083fd418062f950259431149f | 35244ce6da8ec7e86ab085c2ff17611a36d3bcd4 | /DrawCodes/MaskMakerPro.py | f79f797389960c946574a535f43b2d0b43dfd96e | [] | no_license | MRitter95/GraphCodes | c68a0e45585a22feaecb0b6481ef3cca2ed36539 | 6a561f41e908202362eba0c89964bf914ec9e712 | refs/heads/master | 2023-06-13T08:08:52.742532 | 2021-06-22T20:33:45 | 2021-06-22T20:33:45 | 302,158,298 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 140,807 | py | # -*- coding: utf-8 -*-
"""
Created on Wednesday, Oct. 25 2017
MaskMakerPro. This provides a set of functions for drawing masks
@author: Mattias Fitzpatrick
"""
from . import sdxf
from math import floor
from . import sdxf
from math import sin,cos,pi,floor,asin,acos,tan,atan,sqrt
from .alphanum import alphanum_dict
from random import randrange
class MaskError:
"""MaskError is an exception to be raised whenever invalid parameters are used in one of the MaskMaker functions, value is just a string"""
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
#===============================================================================
# POINT-WISE OPERATIONS
#===============================================================================
def rotate_pt(p,angle,center=(0,0)):
"""rotates point p=(x,y) about point center (defaults to (0,0)) by CCW angle (in degrees)"""
dx=p[0]-center[0]
dy=p[1]-center[1]
theta=pi*angle/180
return (center[0]+dx*cos(theta)-dy * sin(theta),center[1]+dx * sin(theta)+dy * cos(theta))
def rotate_pts(points,angle,center=(0,0)):
"""Rotates an array of points one by one using rotate_pt"""
return [rotate_pt(p,angle,center) for p in points]
def translate_pt(p,offset):
"""Translates point p=(x,y) by offset=(x,y)"""
return (p[0]+offset[0],p[1]+offset[1])
def translate_pts(points,offset):
"""Translates an array of points one by one using translate_pt"""
return [translate_pt(p,offset) for p in points]
def orient_pt(p,angle,offset):
"""Orient_pt rotates point p=(x,y) by angle (in degrees) and then translates it to offset=(x,y)"""
return translate_pt(rotate_pt(p,angle),offset)
def orient_pts(points,angle,offset):
"""Orients an array of points one by one using orient_pt"""
return [orient_pt(p,angle,offset) for p in points]
def scale_pt(p,scale):
"""Scales p=(x,y) by scale"""
return (p[0]*scale[0],p[1]*scale[1])
def scale_pts(points,scale):
"""Scales an array of points one by one using scale_pt"""
return [scale_pt(p,scale) for p in points]
def mirror_pt(p, axis_angle,axis_pt):
"""Mirrors point p about a line at angle "axis_angle" intercepting point "axis_pt" """
theta=axis_angle*pi/180.
return (axis_pt[0] + (-axis_pt[0] + p[0])* cos(2 * theta ) + (-axis_pt[1] + p[1])*sin(2 *theta),
p[1] + 2 * (axis_pt[1] - p[1])* cos(theta)**2 + (-axis_pt[0] + p[0])* sin(2*theta) )
def mirror_pts(points,axis_angle,axis_pt):
"""Mirrors an array of points one by one using mirror_pt"""
return [mirror_pt(p,axis_angle,axis_pt) for p in points]
#===============================================================================
# MASK- and CHIP GENERATION
#===============================================================================
class WaferMask(sdxf.Drawing):
"""Mask class for placing chips on a wafer with a flat.
Contains functions which:
- layout the chips,
- add chips to the mask
- create a manifest of the mask.
- etchtype 'False' allows you to make a chip without the dicing borders for a positive mask
- etchtype 'True' is the standard version with dicing borders
"""
def __init__(self,name,diameter=50800.,flat_distance=24100.,wafer_padding=2000,chip_size=(7000.,2000.),dicing_border=200,textsize=(800,800),etchtype=True):
sdxf.Drawing.__init__(self)
self.name=name
self.fileName=name+".dxf"
self.diameter=diameter
self.flat_distance=flat_distance
self.textsize=textsize
self.border_width=200 #width of line used to align wafer edge
self.chip_size=chip_size
self.dicing_border=dicing_border
self.die_size=(chip_size[0]+dicing_border,chip_size[1]+dicing_border)
self.wafer_padding=wafer_padding
self.buffer=self.wafer_padding # + self.dicing_border/2
self.etchtype=etchtype
start_angle=270.+180./pi *acos(2.*flat_distance/diameter)
stop_angle=270.-180./pi* acos(2.*flat_distance/diameter)
iradius=(diameter-self.border_width)/2.
oradius=(diameter+self.border_width)/2.
starti=rotate_pt((iradius,0.),start_angle)
starto=rotate_pt((oradius,0.),start_angle)
stopi=rotate_pt((iradius,0.),stop_angle)
stopo=rotate_pt((oradius,0.),stop_angle)
#print "wafer info: iradis=%f, oradius=%f, start_angle=%f, stop_angle=%f" %(iradius,oradius,start_angle,stop_angle)
stop_angle+=360
opts=arc_pts(start_angle,stop_angle,oradius)
ipts=arc_pts(stop_angle,start_angle,iradius)
pts=opts
pts.append(opts[0])
pts.append(ipts[-1])
pts.extend(ipts)
pts.append(opts[0])
self.append(sdxf.PolyLine(pts))
#self.append(sdxf.Arc((0.,0.),iradius,start_angle,stop_angle))
#self.append(sdxf.Line( [ stopi,stopo]))
#self.append(sdxf.Arc((0.,0.),oradius,start_angle,stop_angle))
#self.append(sdxf.Line( [ starti,starto]))
#self.append(sdxf.PolyLine([stopi,starti,starto,stopo]))
self.chip_points=self.get_chip_points()
self.chip_slots=self.chip_points.__len__()
self.current_point=0
self.manifest=[]
self.num_chips=0
def randomize_layout(self):
"""Shuffle the order of the chip_points array so that chips will be inserted (pseudo-)randomly"""
seed=124279234
for ii in range(10000):
i1=randrange(self.chip_points.__len__())
i2=randrange(self.chip_points.__len__())
tp=self.chip_points[i1]
self.chip_points[i1]=self.chip_points[i2]
self.chip_points[i2]=tp
# def label_chip(self,chip,pt,maskid,chipid):
# """Labels chip on wafer at position pt where pt is the bottom left corner of chip"""
# AlphaNumText(self,maskid,chip.textsize,pt)
# AlphaNumText(self,chipid,chip.textsize,pt)
def add_chip(self,chip,copies):
"""Adds chip design 'copies' times into mask. chip must have a unique name as it will be inserted as a block"""
if self.etchtype:
ChipBorder(chip,self.dicing_border/2)
self.blocks.append(chip)
slots_remaining=self.chip_points.__len__()-self.current_point
for ii in range (copies):
if self.current_point>= self.chip_points.__len__():
raise MaskError("MaskError: Cannot add %d copies of chip '%s' Only %d slots on mask and %d remaining." % (copies,chip.name,self.chip_points.__len__(),slots_remaining))
p=self.chip_points[self.current_point]
self.current_point+=1
self.append(sdxf.Insert(chip.name,point=p))
chip.label_chip(self,maskid=self.name,chipid=chip.name+str(ii+1),offset=p)
self.num_chips+=1
self.manifest.append({'chip':chip,'name':chip.name,'copies':copies,'short_desc':chip.short_description(),'long_desc':chip.long_description()})
#print "%s\t%d\t%s" % (chip.name,copies,chip.short_description())
chip.save(fname=self.name+"-"+chip.name,maskid=self.name,chipid=chip.name)
def save_manifest(self,name=None):
if name is None: name=self.name
if name[-4:]!=".txt": name+="_manifest.txt"
f=open(name,'w')
f.write("Mask:\t%s\tTotal Chips:\t%d\n" % (self.name,self.current_point))
f.write("ID\tCopies\tShort Description\tChip Type\tChip Info\n")
for m in self.manifest:
f.write("%(name)s\t%(copies)d\t%(short_desc)s\n" %m )
for m in self.manifest:
f.write("______________________\n%(name)s\t%(copies)d\t%(long_desc)s\n\n" % m)
f.close()
def save_dxf(self,name=None):
if name is None: name=self.name
if name[-4:]!=".dxf": name+=".dxf"
#print name
f=open(name,'w')
f.write(str(self))
f.close()
def save(self,name=None):
#print "Saving mask"
self.save_dxf(name)
self.save_manifest(name)
def point_inside(self,pt):
"""True if point is on wafer"""
return (pt[0]**2+pt[1]**2<(self.diameter/2-self.buffer)**2) and (pt[1]>-self.flat_distance+self.buffer)
def die_inside(self,pt):
"""Tell if chip of size self.chip_size is completely on the wafer"""
return self.point_inside(pt) and self.point_inside(translate_pt(pt,(self.die_size[0],0))) and self.point_inside(translate_pt(pt,(self.die_size[0],self.die_size[1]))) and self.point_inside(translate_pt(pt,(0,self.die_size[1])))
def get_chip_points(self):
"""Get insertion points for all of the chips (layout wafer)"""
max_cols = int((self.diameter-2*self.buffer)/self.die_size[0])
max_rows = int((self.diameter-2*self.buffer)/self.die_size[1])
print("Maximum number of rows=%d and cols=%d" %(max_rows,max_cols))
#figure out offset for chips (centered on chip or between chips)
xoffset=-max_cols/2.*self.die_size[0]
yoffset=-max_rows/2.*self.die_size[1]
#if max_cols%2==1:
# print "offset X"
# xoffset+=self.chip_size[0]/2.
#if max_rows%2==1:
# yoffset+=self.chip_size[1]/2.
chip_points=[]
for ii in range(max_rows):
for jj in range(max_cols):
pt=(xoffset+jj*self.die_size[0],yoffset+ii*self.die_size[1])
if self.die_inside(pt):
chip_points.append(translate_pt(pt,(self.dicing_border/2,self.dicing_border/2)))
print("Room for %d chips on wafer." % chip_points.__len__())
return chip_points
class Chip(sdxf.Block):
"""Chip is a class which contains structures
Perhaps it will also be used to do some error checking
"""
def __init__(self,name,size=(7000.,2000.),mask_id_loc=(0,0),chip_id_loc=(0,0),textsize=(160,160)):
"""size is a tuple size=(xsize,ysize)"""
sdxf.Block.__init__(self,name)
self.size=size
self.mask_id_loc=mask_id_loc
self.chip_id_loc=chip_id_loc
# self.dicing_border=dicing_border
self.name=name
# self.maskid_struct=Structure(self,start=translate_pt(mask_id_loc,(dicing_border,dicing_border)),layer="id_text",color=3)
# self.chipid_struct=Structure(self,start=translate_pt(chip_id_loc,(dicing_border,dicing_border)),layer="id_text",color=3)
self.textsize=textsize
# if dicing_border>0:
# ChipBorder (self,border_thickness=dicing_border,layer="border",color=3)
# self.left_midpt=(dicing_border,(size[1]+2*dicing_border)/2)
# self.right_midpt=(size[0]+dicing_border,(size[1]+2*dicing_border)/2)
# self.top_midpt=((size[0]+2*dicing_border)/2,size[1]+dicing_border)
# self.bottom_midpt=((size[0]+2*dicing_border)/2,dicing_border)
self.left_midpt=(0,size[1]/2.)
self.right_midpt=(size[0],size[1]/2.)
self.top_midpt=(size[0]/2.,size[1])
self.bottom_midpt=(size[0]/2.,0)
self.midpt=(size[0]/2.,size[1]/2.)
self.bottomleft_corner=(0,0)
self.topleft_corner=(0,size[1])
self.topright_corner=(size[0],size[1])
self.bottomright_corner=(size[0],0)
def label_chip(self,drawing,maskid,chipid,offset=(0,0)):
"""Labels chip in drawing at locations given by mask_id_loc and chip_id_loc with an optional offset.
Note that the drawing can be a drawing or a Block including the chip itself"""
AlphaNumText(drawing,maskid,self.textsize,translate_pt(self.mask_id_loc,offset))
AlphaNumText(drawing,chipid,self.textsize,translate_pt(self.chip_id_loc,offset))
def save(self,fname=None,maskid=None,chipid=None):
"""Saves chip to .dxf, defaults naming file by the chip name, and will also label the chip, if a label is specified"""
if fname is None:
fname=self.name+'.dxf'
if fname[-4:]!='.dxf':
fname+='.dxf'
d=sdxf.Drawing()
d.blocks.append(self)
d.append(sdxf.Insert(self.name,point=(0,0)))
self.label_chip(d,maskid,chipid)
d.saveas(fname)
class Structure:
"""Structure keeps track of current location and direction,
defaults is a dictionary with default values that substructures can call
"""
def __init__(self,chip,start=(0,0),direction=0,layer="structures",color=1, defaults={}):
self.chip=chip
self.start=start
self.last=start
self.last_direction=direction
self.layer=layer
self.color=color
self.defaults=defaults.copy()
self.structures=[]
def append(self,shape):
"""gives a more convenient reference to the chips.append method"""
self.chip.append(shape)
#===============================================================================
# CPW COMPONENTS
#===============================================================================
class CPWStraight:
"""A straight section of CPW transmission line"""
def __init__(self, structure,length,pinw=None,gapw=None):
""" Adds a straight section of CPW transmission line of length = length to the structure"""
if length==0: return
s=structure
start=structure.last
if pinw is None: pinw=structure.defaults['pinw']
if gapw is None: gapw=structure.defaults['gapw']
gap1=[ (start[0],start[1]+pinw/2),
(start[0]+length,start[1]+pinw/2),
(start[0]+length,start[1]+pinw/2+gapw),
(start[0],start[1]+pinw/2+gapw),
(start[0],start[1]+pinw/2)
]
gap2=[ (start[0],start[1]-pinw/2),
(start[0]+length,start[1]-pinw/2),
(start[0]+length,start[1]-pinw/2-gapw),
(start[0],start[1]-pinw/2-gapw),
(start[0],start[1]-pinw/2)
]
gap1=rotate_pts(gap1,s.last_direction,start)
gap2=rotate_pts(gap2,s.last_direction,start)
stop=rotate_pt((start[0]+length,start[1]),s.last_direction,start)
s.last=stop
s.append(sdxf.PolyLine(gap1))
s.append(sdxf.PolyLine(gap2))
class CPWStraight_Bridges_Layer1:
"A straight section of CPW transmission line, that has markers on either side for making bridges"
def __init__(self, structure,length,br_base,br_width,pinw=None,gapw=None):
" Adds a straight section of CPW transmission line of length = length to the structure"
if length==0: return
s=structure
start=structure.last
if pinw is None: pinw=structure.defaults['pinw']
if gapw is None: gapw=structure.defaults['gapw']
"This shifts the edge of the bridge from the edge of the ground plane"
br_shift = 10.
gap1=[ (start[0],start[1]+pinw/2),
(start[0]+length,start[1]+pinw/2),
(start[0]+length,start[1]+pinw/2+gapw),
(start[0],start[1]+pinw/2+gapw),
(start[0],start[1]+pinw/2)
]
gap2=[ (start[0],start[1]-pinw/2),
(start[0]+length,start[1]-pinw/2),
(start[0]+length,start[1]-pinw/2-gapw),
(start[0],start[1]-pinw/2-gapw),
(start[0],start[1]-pinw/2)
]
if length < 5*br_width:
raise MaskError("Consider fewer bridges!!")
"The commented code makes holes on either side of the resonators"
# br_11=[ (start[0] + length/4 - br_width/2., start[1] - pinw/2 - gapw - br_shift - br_base),
# (start[0] + length/4 + br_width/2., start[1] - pinw/2 - gapw - br_shift - br_base),
# (start[0] + length/4 + br_width/2., start[1] - pinw/2 - gapw - br_shift),
# (start[0] + length/4 - br_width/2., start[1] - pinw/2 - gapw -br_shift),
# (start[0] + length/4 - br_width/2., start[1] - pinw/2 -gapw - br_shift - br_base)
# ]
# br_12=[ (start[0] + length/4 - br_width/2., start[1] + pinw/2 + gapw + br_shift + br_base),
# (start[0] + length/4 + br_width/2., start[1] + pinw/2 + gapw + br_shift + br_base),
# (start[0] + length/4 + br_width/2., start[1] + pinw/2 + gapw + br_shift),
# (start[0] + length/4 - br_width/2., start[1] + pinw/2 + gapw + br_shift),
# (start[0] + length/4 - br_width/2., start[1] + pinw/2 + gapw + br_shift + br_base)
# ]
#
# br_21=[ (start[0] + 3*length/4 - br_width/2., start[1] - pinw/2 - gapw - br_shift - br_base),
# (start[0] + 3*length/4 + br_width/2., start[1] - pinw/2 - gapw - br_shift - br_base),
# (start[0] + 3*length/4 + br_width/2., start[1] - pinw/2 - gapw - br_shift),
# (start[0] + 3*length/4 - br_width/2., start[1] - pinw/2 - gapw -br_shift),
# (start[0] + 3*length/4 - br_width/2., start[1] - pinw/2 -gapw - br_shift - br_base)
# ]
# br_22=[ (start[0] + 3*length/4 - br_width/2., start[1] + pinw/2 + gapw + br_shift + br_base),
# (start[0] + 3*length/4 + br_width/2., start[1] + pinw/2 + gapw + br_shift + br_base),
# (start[0] + 3*length/4 + br_width/2., start[1] + pinw/2 + gapw + br_shift),
# (start[0] + 3*length/4 - br_width/2., start[1] + pinw/2 + gapw + br_shift),
# (start[0] + 3*length/4 - br_width/2., start[1] + pinw/2 + gapw + br_shift + br_base)
# ]
brTop_11=[ (start[0] + length/4. - br_width/2., start[1] - pinw/2. - gapw - br_shift),
(start[0] + length/4 + br_width/2., start[1] - pinw/2. - gapw - br_shift),
(start[0] + length/4 + br_width/2., start[1] + pinw/2. + gapw + br_shift),
(start[0] + length/4 - br_width/2., start[1] + pinw/2. + gapw + br_shift),
(start[0] + length/4. - br_width/2., start[1] - pinw/2. - gapw - br_shift)
]
brTop_12=[ (start[0] + length/4. - br_width/2., start[1] - pinw/2. - gapw - br_shift - br_base),
(start[0] + length/4 + br_width/2., start[1] - pinw/2. - gapw - br_shift - br_base),
(start[0] + length/4 + br_width/2., start[1] + pinw/2. + gapw + br_shift + br_base),
(start[0] + length/4 - br_width/2., start[1] + pinw/2. + gapw + br_shift + br_base),
(start[0] + length/4. - br_width/2., start[1] - pinw/2. - gapw - br_shift - br_base)
]
brTop_21=[ (start[0] + 3*length/4. - br_width/2., start[1] - pinw/2. - gapw - br_shift),
(start[0] + 3*length/4 + br_width/2., start[1] - pinw/2. - gapw - br_shift),
(start[0] + 3*length/4 + br_width/2., start[1] + pinw/2. + gapw + br_shift),
(start[0] + 3*length/4 - br_width/2., start[1] + pinw/2. + gapw + br_shift),
(start[0] + 3*length/4. - br_width/2., start[1] - pinw/2. - gapw - br_shift)
]
brTop_22=[ (start[0] + 3*length/4. - br_width/2., start[1] - pinw/2. - gapw - br_shift - br_base),
(start[0] + 3*length/4 + br_width/2., start[1] - pinw/2. - gapw - br_shift - br_base),
(start[0] + 3*length/4 + br_width/2., start[1] + pinw/2. + gapw + br_shift + br_base),
(start[0] + 3*length/4 - br_width/2., start[1] + pinw/2. + gapw + br_shift + br_base),
(start[0] + 3*length/4. - br_width/2., start[1] - pinw/2. - gapw - br_shift - br_base)
]
brTop_11=rotate_pts(brTop_11,s.last_direction,start)
brTop_21=rotate_pts(brTop_21,s.last_direction,start)
brTop_12=rotate_pts(brTop_12,s.last_direction,start)
brTop_22=rotate_pts(brTop_22,s.last_direction,start)
gap1=rotate_pts(gap1,s.last_direction,start)
gap2=rotate_pts(gap2,s.last_direction,start)
stop=rotate_pt((start[0]+length,start[1]),s.last_direction,start)
s.last=stop
# s.layers.append(sdxf.Layer(name="BridgeLayer1"))
s.append(sdxf.PolyLine(gap1))
s.append(sdxf.PolyLine(gap2))
s.append(sdxf.PolyLine(brTop_11,layer="BridgeLayer1"))
s.append(sdxf.PolyLine(brTop_21,layer="BridgeLayer1"))
s.append(sdxf.PolyLine(brTop_12,layer="BridgeLayer2"))
s.append(sdxf.PolyLine(brTop_22,layer="BridgeLayer2"))
class CPWQubitNotch:
"A version of CPWStraight that cuts out a notch for a qubit"
def __init__(self,structure,notch_width,notch_height,pinw=None,gapw=None):
"""
Parameters
length= total length of section of CPW
notch_height = height of the qubit notch
notch_width = width of the qubit notch
"""
if notch_width == 0: return
s=structure
start=s.last
if pinw is None: pinw=structure.defaults['pinw']
if gapw is None: gapw=structure.defaults['gapw']
align_shift = 20.
align_width = 10.
# gap1=[ (start[0],start[1]+pinw/2),
# (start[0],start[1]+pinw/2+gapw),
# (start[0]+notch_width,start[1]+pinw/2+gapw),
# (start[0]+notch_width,start[1]+pinw/2+gapw+notch_height),
# (start[0]+2*notch_width,start[1]+pinw/2+gapw+notch_height),
# (start[0]+2*notch_width,start[1]+pinw/2+gapw),
# (start[0]+3*notch_width,start[1]+pinw/2+gapw),
# (start[0]+3*notch_width,start[1]+pinw/2),
# (start[0],start[1]+pinw/2)
# ]
gap1=[ (start[0],start[1]+pinw/2),
(start[0],start[1]+pinw/2+notch_height),
(start[0]+notch_width,start[1]+pinw/2+notch_height),
(start[0]+notch_width,start[1]+pinw/2),
(start[0],start[1]+pinw/2)
]
gap2=[ (start[0],start[1]-pinw/2),
(start[0]+notch_width,start[1]-pinw/2),
(start[0]+notch_width,start[1]-pinw/2-gapw),
(start[0],start[1]-pinw/2-gapw),
(start[0],start[1]-pinw/2)
]
"Qbit alignment marker"
alignment_marker1=[ (start[0]- align_shift,start[1] + align_shift + notch_height),
(start[0] - align_shift - align_width, start[1] + align_shift+ notch_height),
(start[0] - align_shift - align_width,start[1] + align_shift + align_width+ notch_height),
(start[0] - align_shift - 2*align_width,start[1] + align_shift + align_width+ notch_height),
(start[0] - align_shift - 2*align_width,start[1] + align_shift + 2*align_width+ notch_height),
(start[0] - align_shift - align_width,start[1] + align_shift + 2*align_width+ notch_height),
(start[0] - align_shift - align_width,start[1] + align_shift + 3*align_width+ notch_height),
(start[0] - align_shift,start[1] + align_shift + 3*align_width+ notch_height),
(start[0] - align_shift,start[1] + align_shift + 2*align_width+ notch_height),
(start[0] - align_shift + align_width,start[1] + align_shift + 2*align_width+ notch_height),
(start[0] - align_shift + align_width,start[1] + align_shift + align_width+ notch_height),
(start[0] - align_shift,start[1] + align_shift + align_width+ notch_height),
(start[0] - align_shift,start[1] + align_shift+ notch_height)
]
"Qbit alignment marker"
alignment_marker2=[ (start[0]+ align_shift + notch_width,start[1] + align_shift + notch_height),
(start[0] + align_shift + align_width+ notch_width, start[1] + align_shift+ notch_height),
(start[0] + align_shift + align_width+ notch_width,start[1] + align_shift + align_width+ notch_height),
(start[0] + align_shift + 2*align_width+ notch_width,start[1] + align_shift + align_width+ notch_height),
(start[0] + align_shift + 2*align_width+ notch_width,start[1] + align_shift + 2*align_width+ notch_height),
(start[0] + align_shift + align_width+ notch_width,start[1] + align_shift + 2*align_width+ notch_height),
(start[0] + align_shift + align_width+ notch_width,start[1] + align_shift + 3*align_width+ notch_height),
(start[0] + align_shift+ notch_width,start[1] + align_shift + 3*align_width+ notch_height),
(start[0] + align_shift+ notch_width,start[1] + align_shift + 2*align_width+ notch_height),
(start[0] + align_shift - align_width+ notch_width,start[1] + align_shift + 2*align_width+ notch_height),
(start[0] + align_shift - align_width+ notch_width,start[1] + align_shift + align_width+ notch_height),
(start[0] + align_shift+ notch_width,start[1] + align_shift + align_width+ notch_height),
(start[0] + align_shift+ notch_width,start[1] + align_shift+ notch_height)
]
gap1=rotate_pts(gap1,s.last_direction,start)
gap2=rotate_pts(gap2,s.last_direction,start)
alignment_marker1=rotate_pts(alignment_marker1,s.last_direction,start)
alignment_marker2=rotate_pts(alignment_marker2,s.last_direction,start)
stop=rotate_pt((start[0]+notch_width,start[1]),s.last_direction,start)
s.last=stop
s.append(sdxf.PolyLine(gap1))
s.append(sdxf.PolyLine(gap2))
s.append(sdxf.PolyLine(alignment_marker1))
s.append(sdxf.PolyLine(alignment_marker2))
class CPWQubitNotch_inverted:
"A version of CPWStraight that cuts out a notch for a qubit"
def __init__(self,structure,notch_width,notch_height,pinw=None,gapw=None):
"""
Parameters
length= total length of section of CPW
notch_height = height of the qubit notch
notch_width = width of the qubit notch
"""
if notch_width == 0: return
s=structure
start=s.last
if pinw is None: pinw=structure.defaults['pinw']
if gapw is None: gapw=structure.defaults['gapw']
align_shift = 20.
align_width = 10.
gap1=[ (start[0],start[1]-pinw/2),
(start[0],start[1]-pinw/2-notch_height),
(start[0]+notch_width,start[1]-pinw/2-notch_height),
(start[0]+notch_width,start[1]-pinw/2),
(start[0],start[1]-pinw/2)
]
gap2=[ (start[0],start[1]+pinw/2),
(start[0]+notch_width,start[1]+pinw/2),
(start[0]+notch_width,start[1]+pinw/2+gapw),
(start[0],start[1]+pinw/2+gapw),
(start[0],start[1]+pinw/2)
]
"Qbit alignment marker"
alignment_marker1=[ (start[0]- align_shift,start[1] - align_shift - notch_height),
(start[0] - align_shift - align_width, start[1] - align_shift- notch_height),
(start[0] - align_shift - align_width,start[1] - align_shift - align_width- notch_height),
(start[0] - align_shift - 2*align_width,start[1] - align_shift - align_width- notch_height),
(start[0] - align_shift - 2*align_width,start[1] - align_shift - 2*align_width- notch_height),
(start[0] - align_shift - align_width,start[1] - align_shift - 2*align_width- notch_height),
(start[0] - align_shift - align_width,start[1] - align_shift - 3*align_width- notch_height),
(start[0] - align_shift,start[1] - align_shift - 3*align_width - notch_height),
(start[0] - align_shift,start[1] - align_shift - 2*align_width - notch_height),
(start[0] - align_shift + align_width,start[1] - align_shift - 2*align_width- notch_height),
(start[0] - align_shift + align_width,start[1] - align_shift - align_width- notch_height),
(start[0] - align_shift,start[1] - align_shift - align_width - notch_height),
(start[0] - align_shift,start[1] - align_shift - notch_height)
]
"Qbit alignment marker"
alignment_marker2=[ (start[0]+ align_shift + notch_width,start[1] - align_shift - notch_height),
(start[0] + align_shift + align_width+ notch_width, start[1] - align_shift- notch_height),
(start[0] + align_shift + align_width+ notch_width,start[1] - align_shift - align_width - notch_height),
(start[0] + align_shift + 2*align_width+ notch_width,start[1] - align_shift - align_width - notch_height),
(start[0] + align_shift + 2*align_width+ notch_width,start[1] - align_shift - 2*align_width - notch_height),
(start[0] + align_shift + align_width+ notch_width,start[1] - align_shift - 2*align_width - notch_height),
(start[0] + align_shift + align_width+ notch_width,start[1] - align_shift - 3*align_width - notch_height),
(start[0] + align_shift+ notch_width,start[1] - align_shift - 3*align_width - notch_height),
(start[0] + align_shift+ notch_width,start[1] - align_shift - 2*align_width - notch_height),
(start[0] + align_shift - align_width+ notch_width,start[1] - align_shift - 2*align_width - notch_height),
(start[0] + align_shift - align_width+ notch_width,start[1] - align_shift - align_width - notch_height),
(start[0] + align_shift+ notch_width,start[1] - align_shift - align_width - notch_height),
(start[0] + align_shift+ notch_width,start[1] - align_shift - notch_height)
]
gap1=rotate_pts(gap1,s.last_direction,start)
gap2=rotate_pts(gap2,s.last_direction,start)
alignment_marker1=rotate_pts(alignment_marker1,s.last_direction,start)
alignment_marker2=rotate_pts(alignment_marker2,s.last_direction,start)
stop=rotate_pt((start[0]+notch_width,start[1]),s.last_direction,start)
s.last=stop
s.append(sdxf.PolyLine(gap1))
s.append(sdxf.PolyLine(gap2))
s.append(sdxf.PolyLine(alignment_marker1))
s.append(sdxf.PolyLine(alignment_marker2))
class CPWLinearTaper:
"""A section of CPW which (linearly) tapers from one set of start_pinw and start_gapw to stop_pinw and stop_gapw over length=length"""
def __init__(self, structure,length,start_pinw,stop_pinw,start_gapw,stop_gapw):
if length==0: return
#load attributes
s=structure
start=s.last
#define geometry of gaps
gap1= [
(start[0],start[1]+start_pinw/2),
(start[0]+length,start[1]+stop_pinw/2),
(start[0]+length,start[1]+stop_pinw/2+stop_gapw),
(start[0],start[1]+start_pinw/2+start_gapw),
(start[0],start[1]+start_pinw/2)
]
gap2= [
(start[0],start[1]-start_pinw/2),
(start[0]+length,start[1]-stop_pinw/2),
(start[0]+length,start[1]-stop_pinw/2-stop_gapw),
(start[0],start[1]-start_pinw/2-start_gapw),
(start[0],start[1]-start_pinw/2)
]
#rotate structure to proper orientation
gap1=rotate_pts(gap1,s.last_direction,start)
gap2=rotate_pts(gap2,s.last_direction,start)
#create polylines and append to drawing
s.append(sdxf.PolyLine(gap1))
s.append(sdxf.PolyLine(gap2))
#update last anchor position
stop=rotate_pt((start[0]+length,start[1]),s.last_direction,start)
s.last=stop
#----------------------------------------------------------------------------------------------------
class Inner_end_cap:
def __init__(self,structure,cap_length,cap_gap,start_pinw,stop_pinw,start_gapw,stop_gapw,capBuffer):
if cap_length==0: return
"""
Class that draws a singlehexagonal endcap for one part of the 3way coupling capacitor
variables:
cap_length= linear length of end cap
cap_gap= width of capacitive gap between end caps
start_pinw= beginning width of end cap
stop_pinw= width of end cap before taper
"""
"""
The issue with this code is that for small cap_gap, the space between the capacitor and ground plane isn't big enough.
"""
"Load attributes"
s=structure
start=s.last
cap_length = cap_length - cap_gap/2
start_taperX= cap_length-(stop_pinw/2)/tan(60*pi/180) # X-pos of where the centerpin taper starts
start_taperY=((cap_length-start_taperX)+cap_gap/2)*tan(60*pi/180)
"Intersection point calculations"
x_intersect=(start_pinw/2 + start_gapw - sqrt(3)*(cap_length+cap_gap/2))/(-sqrt(3)-(stop_gapw/start_taperX))
y_intersect=-sqrt(3)*(x_intersect-(cap_length+cap_gap/2))
"draw points that form the end cap geometry"
EndCap=[
(start[0],start[1]+start_pinw/2),
(start[0],start[1]+start_pinw/2+start_gapw),
(start[0]+x_intersect,start[1]+y_intersect),
(start[0]+cap_length+cap_gap/2,start[1]),
(start[0]+x_intersect,start[1]-y_intersect),
(start[0],start[1]-start_pinw/2-start_gapw),
(start[0],start[1]-start_pinw/2),
(start[0]+start_taperX,start[1]-stop_pinw/2),
(start[0]+cap_length,start[1]),
(start[0]+start_taperX,start[1]+stop_pinw/2),
(start[0],start[1]+start_pinw/2)
]
"rotate structure to proper orientation"
EndCap=rotate_pts(EndCap,s.last_direction,start)
"create polylines and append to drawing /connect the dots"
s.append(sdxf.PolyLine(EndCap))
"update last anchor position"
stop=rotate_pt((start[0]+cap_length+cap_gap/2,start[1]),s.last_direction,start)
s.last=stop
class Inner_end_cap_buffer:
def __init__(self,structure,cap_length,cap_gap,start_pinw,stop_pinw,start_gapw,stop_gapw,capBuffer,bufferDistance):
if cap_length==0: return
"""
Class that draws a singlehexagonal endcap for one part of the 3way coupling capacitor
variables:
cap_length= linear length of end cap
cap_gap= width of capacitive gap between end caps
start_pinw= beginning width of end cap
stop_pinw= width of end cap before taper
"""
"""
The issue with this code is that for small cap_gap, the space between the capacitor and ground plane isn't big enough.
"""
"Load attributes"
s=structure
start=s.last
cap_length = cap_length - cap_gap/2
start_taperX= cap_length-(stop_pinw/2)/tan(60*pi/180) # X-pos of where the centerpin taper starts
start_taperY=((cap_length-start_taperX)+cap_gap/2)*tan(60*pi/180)
"Intersection point calculations"
x_intersect=(start_pinw/2 + start_gapw - sqrt(3)*(cap_length+cap_gap/2))/(-sqrt(3)-(stop_gapw/start_taperX))
y_intersect=-sqrt(3)*(x_intersect-(cap_length+cap_gap/2))
"draw points that form the end cap geometry"
EndCap=[
(start[0]+bufferDistance,start[1]+start_pinw/2),
(start[0],start[1]+start_pinw/2),
(start[0],start[1]+start_pinw/2+start_gapw),
(start[0]+x_intersect,start[1]+y_intersect),
(start[0]+cap_length+cap_gap/2,start[1]),
(start[0]+x_intersect,start[1]-y_intersect),
(start[0],start[1]-start_pinw/2-start_gapw),
(start[0],start[1]-start_pinw/2),
(start[0]+bufferDistance,start[1]-start_pinw/2),
(start[0]+start_taperX,start[1]-stop_pinw/2),
(start[0]+cap_length,start[1]),
(start[0]+start_taperX,start[1]+stop_pinw/2),
(start[0]+bufferDistance,start[1]+start_pinw/2),
]
"rotate structure to proper orientation"
EndCap=rotate_pts(EndCap,s.last_direction,start)
"create polylines and append to drawing /connect the dots"
s.append(sdxf.PolyLine(EndCap))
"update last anchor position"
stop=rotate_pt((start[0]+cap_length+cap_gap/2,start[1]),s.last_direction,start)
s.last=stop
class Inner_end_cap_bondpad:
def __init__(self,structure,cap_length,cap_gap,start_pinw,stop_pinw,start_gapw,stop_gapw,capBuffer,start_pinwLinear,start_gapwLinear):
if cap_length==0: return
"""
Class that draws a singlehexagonal endcap for one part of the 3way coupling capacitor
variables:
cap_length= linear length of end cap
cap_gap= width of capacitive gap between end caps
start_pinw= beginning width of end cap
stop_pinw= width of end cap before taper
"""
"""
The issue with this code is that for small cap_gap, the space between the capacitor and ground plane isn't big enough.
"""
"Load attributes"
s=structure
start=s.last
cap_length = cap_length - cap_gap/2
start_taperX= cap_length-(stop_pinw/2)/tan(60*pi/180) # X-pos of where the centerpin taper starts
start_taperY=((cap_length-start_taperX)+cap_gap/2)*tan(60*pi/180)
"Intersection point calculations"
x_intersect=(start_pinw/2 + start_gapw - sqrt(3)*(cap_length+cap_gap/2))/(-sqrt(3)-(stop_gapw/start_taperX))
y_intersect=-sqrt(3)*(x_intersect-(cap_length+cap_gap/2))
"draw points that form the end cap geometry"
EndCap=[
(start[0],start[1]+start_pinwLinear/2),
(start[0],start[1]+start_pinwLinear/2+start_gapwLinear),
(start[0]+x_intersect,start[1]+y_intersect),
(start[0]+cap_length+cap_gap/2,start[1]),
(start[0]+x_intersect,start[1]-y_intersect),
(start[0],start[1]-start_pinwLinear/2-start_gapwLinear),
(start[0],start[1]-start_pinwLinear/2),
(start[0]+start_taperX,start[1]-stop_pinw/2),
(start[0]+cap_length,start[1]),
(start[0]+start_taperX,start[1]+stop_pinw/2),
(start[0],start[1]+start_pinwLinear/2)
]
"rotate structure to proper orientation"
EndCap=rotate_pts(EndCap,s.last_direction,start)
"create polylines and append to drawing /connect the dots"
s.append(sdxf.PolyLine(EndCap))
"update last anchor position"
stop=rotate_pt((start[0]+cap_length+cap_gap/2,start[1]),s.last_direction,start)
s.last=stop
class Inner_end_cap_bondpad_buffer:
def __init__(self,structure,cap_length,cap_gap,start_pinw,stop_pinw,start_gapw,stop_gapw,capBuffer,start_pinwLinear,start_gapwLinear,bufferDistance):
if cap_length==0: return
"""
Class that draws a singlehexagonal endcap for one part of the 3way coupling capacitor
variables:
cap_length= linear length of end cap
cap_gap= width of capacitive gap between end caps
start_pinw= beginning width of end cap
stop_pinw= width of end cap before taper
"""
"""
The issue with this code is that for small cap_gap, the space between the capacitor and ground plane isn't big enough.
"""
"Load attributes"
s=structure
start=s.last
cap_length = cap_length - cap_gap/2
start_taperX= cap_length-(stop_pinw/2)/tan(60*pi/180) # X-pos of where the centerpin taper starts
start_taperY=((cap_length-start_taperX)+cap_gap/2)*tan(60*pi/180)
"Intersection point calculations"
x_intersect=(start_pinw/2 + start_gapw - sqrt(3)*(cap_length+cap_gap/2))/(-sqrt(3)-(stop_gapw/start_taperX))
y_intersect=-sqrt(3)*(x_intersect-(cap_length+cap_gap/2))
"draw points that form the end cap geometry"
EndCap=[
(start[0]+bufferDistance,start[1]+start_pinwLinear/2),
(start[0],start[1]+start_pinwLinear/2),
(start[0],start[1]+start_pinwLinear/2+start_gapwLinear),
(start[0]+x_intersect,start[1]+y_intersect),
(start[0]+cap_length+cap_gap/2,start[1]),
(start[0]+x_intersect,start[1]-y_intersect),
(start[0],start[1]-start_pinwLinear/2-start_gapwLinear),
(start[0],start[1]-start_pinwLinear/2),
(start[0]+bufferDistance,start[1]-start_pinwLinear/2),
(start[0]+start_taperX,start[1]-stop_pinw/2),
(start[0]+cap_length,start[1]),
(start[0]+start_taperX,start[1]+stop_pinw/2),
(start[0]+bufferDistance,start[1]+start_pinwLinear/2)
]
"rotate structure to proper orientation"
EndCap=rotate_pts(EndCap,s.last_direction,start)
"create polylines and append to drawing /connect the dots"
s.append(sdxf.PolyLine(EndCap))
"update last anchor position"
stop=rotate_pt((start[0]+cap_length+cap_gap/2,start[1]),s.last_direction,start)
s.last=stop
class Outer_Pacman_cap:
def __init__(self,structure,cap_length,cap_gap,start_pinw,stop_pinw,start_gapw,stop_gapw,cap_gap_ext=0):
if cap_length==0: return
"""
Draws a pacman shaped capacitor that fits to the end of the
variables:
cap_length= linear length of end cap
cap_gap= width of capacitive gap b/n end caps
start_pinw= beginning width of end cap
stop_pinw= width of end cap before taper
"""
"""
The issue with this code is that for small cap_gap, the space between the capacitor and ground plane isn't big enough.
"""
"Load attributes"
s=structure
start=s.last
cap_length = cap_length - cap_gap/2
start_taperX= cap_length-(stop_pinw/2)/tan(60*pi/180) # X-pos of where the centerpin taper starts
start_taperY=((cap_length-start_taperX)+cap_gap/2)*tan(60*pi/180)
"Intersection point calculations"
x_intersect=(start_pinw/2 + start_gapw - sqrt(3)*(cap_length+cap_gap/2))/(-sqrt(3)-(stop_gapw/start_taperX))
y_intersect=-sqrt(3)*(x_intersect-(cap_length+cap_gap/2))
"draw points that form the end cap geometry"
EndCap=[
(start[0], start[1]+start_pinw/2),
(start[0] + cap_length-(stop_pinw/2.)/sqrt(3), start[1]+stop_pinw/2),
(start[0] + cap_length-(stop_pinw/2.)/sqrt(3)+2.*(stop_pinw/2.)/sqrt(3.), start[1] + stop_pinw/2),
(start[0] + cap_length, start[1]),
(start[0] + cap_length-(stop_pinw/2.)/sqrt(3)+2.*(stop_pinw/2.)/sqrt(3.), start[1]-stop_pinw/2),
(start[0] + cap_length-(stop_pinw/2.)/sqrt(3), start[1]-stop_pinw/2),
(start[0] , start[1] - start_pinw/2),
(start[0], start[1]-start_pinw/2-start_gapw),
(start[0] + x_intersect, start[1] - y_intersect),
(start[0] + cap_length + cap_gap/2 + y_intersect/sqrt(3) + cap_gap_ext, start[1] - y_intersect),
(start[0] + cap_length + cap_gap/2 + cap_gap_ext,start[1]),
(start[0] + cap_length + cap_gap/2 + y_intersect/sqrt(3) + cap_gap_ext, start[1] + y_intersect),
(start[0] + x_intersect, start[1] + y_intersect),
(start[0],start[1]+start_pinw/2 + start_gapw),
(start[0], start[1] + start_pinw/2)
]
"rotate structure to proper orientation"
EndCap=rotate_pts(EndCap,s.last_direction,start)
"create polylines and append to drawing /connect the dots"
s.append(sdxf.PolyLine(EndCap))
"update last anchor position"
stop=rotate_pt((start[0] + cap_length + cap_gap/2 + cap_gap_ext,start[1]),s.last_direction,start)
s.last=stop
class CPWBend:
"""A CPW bend"""
def __init__(self,structure,turn_angle,pinw=None,gapw=None,radius=None,polyarc=True,segments=60):
"""creates a CPW bend with pinw/gapw/radius
@param turn_angle: turn_angle is in degrees, positive is CCW, negative is CW
"""
#load default values if necessary
if turn_angle==0: return
s=structure
# print('radius',radius)
if radius is None: radius=s.defaults['radius']
if pinw is None: pinw=s.defaults['pinw']
if gapw is None: gapw=s.defaults['gapw']
self.structure=structure
self.turn_angle=turn_angle
self.pinw=pinw
self.gapw=gapw
self.radius=radius
self.segments=segments
self.start=s.last
self.start_angle=s.last_direction
self.stop_angle=self.start_angle+self.turn_angle
if turn_angle>0: self.asign=1
else: self.asign=-1
#DXF uses the angle of the radial vector for its start and stop angles
#so we have to rotate our angles by 90 degrees to get them right
#also it only knows about arcs with CCW sense to them, so we have to rotate our angles appropriately
self.astart_angle=self.start_angle-self.asign*90
self.astop_angle=self.stop_angle-self.asign*90
#calculate location of Arc center
self.center=rotate_pt( (self.start[0],self.start[1]+self.asign*self.radius),self.start_angle,self.start)
if polyarc: self.poly_arc_bend()
else: self.arc_bend()
self.structure.last=rotate_pt(self.start,self.stop_angle-self.start_angle,self.center)
self.structure.last_direction=self.stop_angle
def arc_bend(self):
#print "start: %d, stop: %d" % (start_angle,stop_angle)
if self.turn_angle>0:
self.astart_angle=self.start_angle-90
self.astop_angle=self.stop_angle-90
#calculate location of Arc center
self.center=rotate_pt( (self.start[0],self.start[1]+self.radius),self.start_angle,self.start)
else:
self.astart_angle=self.stop_angle+90
self.astop_angle=self.start_angle+90
#make endlines for inner arc
#start first gap
points1=[ (self.start[0],self.start[1]+self.pinw/2.),
(self.start[0],self.start[1]+self.pinw/2.+self.gapw)
]
points1=rotate_pts(points1,self.start_angle,self.start)
points2=rotate_pts(points1,self.stop_angle-self.start_angle,self.center)
#start 2nd gap
points3=[ (self.start[0],self.start[1]-self.pinw/2.),
(self.start[0],self.start[1]-self.pinw/2.-self.gapw)
]
points3=rotate_pts(points3,self.start_angle,self.start)
points4=rotate_pts(points3,self.stop_angle-self.start_angle,self.center)
#make inner arcs
self.structure.append(sdxf.Line(points1))
self.structure.append(sdxf.Arc(self.center,self.radius+self.pinw/2.,self.astart_angle,self.astop_angle))
self.structure.append(sdxf.Arc(self.center,self.radius+self.pinw/2.+self.gapw,self.astart_angle,self.astop_angle))
self.structure.append(sdxf.Line(points2))
self.structure.append(sdxf.Line(points3))
self.structure.append(sdxf.Arc(self.center,self.radius-self.pinw/2.,self.astart_angle,self.astop_angle))
self.structure.append(sdxf.Arc(self.center,self.radius-self.pinw/2.-self.gapw,self.astart_angle,self.astop_angle))
self.structure.append(sdxf.Line(points4))
def poly_arc_bend(self):
#lower gap
pts1=arc_pts(self.astart_angle,self.astop_angle,self.radius+self.pinw/2.+self.gapw,self.segments)
pts1.extend(arc_pts(self.astop_angle,self.astart_angle,self.radius+self.pinw/2.,self.segments))
pts1.append(pts1[0])
pts2=arc_pts(self.astart_angle,self.astop_angle,self.radius-self.pinw/2.,self.segments)
pts2.extend(arc_pts(self.astop_angle,self.astart_angle,self.radius-self.pinw/2.-self.gapw,self.segments))
pts2.append(pts2[0])
self.structure.append(sdxf.PolyLine(translate_pts(pts1,self.center)))
self.structure.append(sdxf.PolyLine(translate_pts(pts2,self.center)))
#class TaperedCPWFingerCap:
# def __init__(self, structure,num_fingers,finger_length=None,finger_width=None,finger_gap=None,gapw=None):
class CPWWiggles:
"""CPW Wiggles (meanders)"""
def __init__(self,structure,num_wiggles,total_length,start_up=True,radius=None,pinw=None,gapw=None):
"""
@param num_wiggles: a wiggle is from the center pin up/down and back
@param total_length: The total length of the meander
@param start_up: Start with a CCW 90 degree turn or a CW turn
"""
s=structure
start=structure.last
if pinw is None: pinw=s.defaults['pinw']
if gapw is None: gapw=s.defaults['gapw']
if radius is None: radius=s.defaults['radius']
#calculate vertical segment length:
#total length=number of 180 degree arcs + number of vertical segs + vertical radius spacers
#total_length=(1+num_wiggles)*(pi*radius)+2*num_wiggles*vlength+2*(num_wiggles-1)*radius
vlength=(total_length-((1+num_wiggles)*(pi*radius)+2*(num_wiggles-1)*radius))/(2*num_wiggles)
if vlength<0: print("Warning: length of vertical segments is less than 0, increase total_length or decrease num_wiggles")
if start_up: asign=1
else: asign=-1
CPWBend(s,asign*90,pinw,gapw,radius)
for ii in range(num_wiggles):
isign=2*(ii%2)-1
CPWStraight(s,vlength,pinw,gapw)
CPWBend(s,isign*asign*180,pinw,gapw,radius)
CPWStraight(s,vlength,pinw,gapw)
if ii<num_wiggles-1:
CPWStraight(s,2*radius,pinw,gapw)
CPWBend(s,-isign*asign*90,pinw,gapw,radius)
class CPWWigglesByLength:
"""An updated version of CPWWiggles which is more general.
Specifies a meander by length but allows for starting at different angles
and also allows meanders which are symmetric or asymmetric about the center pin.
"""
def __init__(self,structure,num_wiggles,total_length,start_bend_angle=None,symmetric=True,radius=None,pinw=None,gapw=None):
"""
@param num_wiggles: a wiggle is from the center pin up/down and back
@param total_length: The total length of the meander
@param start_bend_angle: Start with a start_bend_angle degree turn (CCW)
@param symmetric: If True then meander symmetric about current direction, other wise only above or below depending on start_bend_angle
"""
s=structure
start=structure.last
if pinw is None: pinw=s.defaults['pinw']
if gapw is None: gapw=s.defaults['gapw']
if radius is None: radius=s.defaults['radius']
if num_wiggles == 0 or total_length == 0:
self.vlength=0
return
if start_bend_angle is None:
start_bend_angle=0
if start_bend_angle>0:
asign=1
else:
asign=-1
if symmetric:
vlength=(total_length-2*(start_bend_angle*pi/180*radius)-num_wiggles*pi*radius-2*radius*(num_wiggles-1))/(2*num_wiggles)
else:
vlength=(total_length-2*(start_bend_angle*pi/180*radius)-pi*radius*(2*num_wiggles-1))/(2*num_wiggles)
if vlength<0:
raise MaskError("Warning: length of vertical segments is less than 0, increase total_length or decrease num_wiggles")
self.vlength=vlength
CPWBend(s,start_bend_angle,pinw,gapw,radius)
for ii in range(num_wiggles):
if symmetric:
isign=2*(ii%2)-1
else:
isign=-1
CPWStraight(s,vlength,pinw,gapw)
CPWBend(s,isign*asign*180,pinw,gapw,radius)
CPWStraight(s,vlength,pinw,gapw)
if ii<num_wiggles-1:
if symmetric:
CPWStraight(s,2*radius,pinw,gapw) #if symmetric must account for initial bend height
else:
CPWBend(s,asign*180,pinw,gapw,radius) #if asymmetric must turn around
CPWBend(s,-isign*start_bend_angle,pinw,gapw,radius)
class CPWWigglesByLength_EndStraight:
"""An updated version of CPWWigglesByLength.
At the end of the wiggles, the cpw does not curve back to the original direction defined byt the star_bend_angle,
but stays straight along the current direction.
"""
def __init__(self,structure,num_wiggles,total_length,start_bend_angle=None,symmetric=True,radius=None,pinw=None,gapw=None):
"""
@param num_wiggles: a wiggle is from the center pin up/down and back
@param total_length: The total length of the meander
@param start_bend_angle: Start with a start_bend_angle degree turn (CCW)
@param symmetric: If True then meander symmetric about current direction, other wise only above or below depending on start_bend_angle
"""
s=structure
start=structure.last
if pinw is None: pinw=s.defaults['pinw']
if gapw is None: gapw=s.defaults['gapw']
if radius is None: radius=s.defaults['radius']
if num_wiggles == 0 or total_length == 0:
self.vlength=0
return
if start_bend_angle is None:
start_bend_angle=0
if start_bend_angle>0:
asign=1
else:
asign=-1
if symmetric:
vlength=(total_length-2*(start_bend_angle*pi/180*radius)-num_wiggles*pi*radius-2*radius*(num_wiggles-1))/(2*num_wiggles)
else:
vlength=(total_length-2*(start_bend_angle*pi/180*radius)-pi*radius*(2*num_wiggles-1))/(2*num_wiggles)
if vlength<0:
raise MaskError("Warning: length of vertical segments is less than 0, increase total_length or decrease num_wiggles")
self.vlength=vlength
CPWBend(s,start_bend_angle,pinw,gapw,radius)
for ii in range(num_wiggles):
if symmetric:
isign=2*(ii%2)-1
else:
isign=-1
CPWStraight(s,vlength,pinw,gapw)
CPWBend(s,isign*asign*180,pinw,gapw,radius)
CPWStraight(s,vlength,pinw,gapw)
if ii<num_wiggles-1:
if symmetric:
CPWStraight(s,2*radius,pinw,gapw) #if symmetric must account for initial bend height
else:
CPWBend(s,asign*180,pinw,gapw,radius) #if asymmetric must turn around#
CPWBend(s,start_bend_angle,pinw,gapw,radius)
print(('vlength=', vlength))
class drawBondPad:
def __init__(self,drawing,pos,Ang,pinw,gapw,bond_pad_length=None,launcher_pinw=None,launcher_gapw=None,taper_length=None,launcher_padding=None,launcher_radius=None):
"""
Created on 08/09/2011
@author: Brendon Rose
Script appends a BondPad on drawing and position pos and Angle Ang relative to the positive x-axis CCW is positive
"""
"Set Self-attributes"
#Launcher parameters set to default if nothing was input
if bond_pad_length == None: bond_pad_length = 400.
if launcher_pinw == None: launcher_pinw = 150.
if launcher_gapw == None: launcher_gapw = 67.305
if taper_length == None: taper_length = 300.
if launcher_padding == None: launcher_padding = 67.
if launcher_radius == None: launcher_radius = 125.
s = drawing #define structure for writting bond pad to
s.last = pos #Position to put bond pad
s.last_direction = Ang #Angle to put bond pad
launcher_length=taper_length+bond_pad_length+launcher_padding
"Draw the BondPad and a curly wire to offset launcher"
CPWStraight(s,length=launcher_padding,pinw=0,gapw=launcher_pinw/2 + launcher_gapw)
CPWStraight(s,length=bond_pad_length,pinw=launcher_pinw,gapw=launcher_gapw)
CPWLinearTaper(s,length=taper_length,start_pinw=launcher_pinw,start_gapw=launcher_gapw,stop_pinw=pinw,stop_gapw=gapw)
class CPWWigglesByLength_KagRes1:
"""
An updated version of CPWWigglesByLength.
"""
def __init__(self,structure,num_wiggles,total_length,br_base,br_width,lattice_shift=None,start_bend_angle=None,symmetric=True,radius=None,pinw=None,gapw=None):
# def __init__(self,structure,num_wiggles,total_length,lattice_shift=None,start_bend_angle=None,symmetric=True,radius=None,pinw=None,gapw=None):
"""
@param num_wiggles: a wiggle is from the center pin up/down and back
@param total_length: The total length of the meander
@param start_bend_angle: Start with a start_bend_angle degree turn (CCW)
@param symmetric: If True then meander symmetric about current direction, other wise only above or below depending on start_bend_angle
"""
s=structure
start=structure.last
if lattice_shift is None: lattice_shift = 0
if pinw is None: pinw=s.defaults['pinw']
if gapw is None: gapw=s.defaults['gapw']
if radius is None: radius=s.defaults['radius']
if num_wiggles == 0 or total_length == 0:
self.vlength=0
return
if start_bend_angle is None:
start_bend_angle=0
if start_bend_angle>0:
asign=1
else:
asign=-1
if symmetric:
vlength=(total_length- radius*(num_wiggles)*pi - 2.*radius*(num_wiggles- 1.))/(2.*num_wiggles -1.)
else:
vlength=(total_length-(start_bend_angle*pi/180*radius)-pi*radius*(2*num_wiggles-1))/(2*num_wiggles)
if vlength<0:
raise MaskError("Warning: length of vertical segments is less than 0, increase total_length or decrease num_wiggles")
self.vlength=vlength
CPWBend(s,start_bend_angle,pinw,gapw,radius)
for ii in range(num_wiggles):
if symmetric:
isign=2*(ii%2)-1
else:
isign=-1
if ii <num_wiggles- 1:
CPWStraight_Bridges_Layer1(s,vlength-lattice_shift/(2*(num_wiggles - 1)),br_base,br_width,pinw,gapw)
# CPWStraight(s,vlength-lattice_shift/(2*(num_wiggles - 1)),pinw,gapw)
CPWBend(s,isign*asign*180,pinw,gapw,radius)
CPWStraight_Bridges_Layer1(s,vlength-lattice_shift/(2*(num_wiggles - 1)),br_base,br_width,pinw,gapw)
# CPWStraight(s,vlength-lattice_shift/(2*(num_wiggles - 1)),pinw,gapw)
if symmetric:
CPWStraight(s,2*radius,pinw,gapw) #if symmetric must account for initial bend height
else:
CPWBend(s,asign*180,pinw,gapw,radius) #if asymmetric must turn around
else:
CPWStraight_Bridges_Layer1(s,vlength,br_base,br_width,pinw,gapw)
# CPWStraight(s,vlength,pinw,gapw)
CPWBend(s,isign*asign*90,pinw,gapw,radius)
class CPWWigglesByLength_KagRes2:
"""An updated version of CPWWigglesByLength.
"""
def __init__(self,structure,num_wiggles,total_length,br_base,br_width,lattice_shift=None,start_bend_angle=None,symmetric=True,radius=None,pinw=None,gapw=None):
# def __init__(self,structure,num_wiggles,total_length,lattice_shift=None,start_bend_angle=None,symmetric=True,radius=None,pinw=None,gapw=None):
"""
@param num_wiggles: a wiggle is from the center pin up/down and back
@param total_length: The total length of the meander
@param start_bend_angle: Start with a start_bend_angle degree turn (CCW)
@param symmetric: If True then meander symmetric about current direction, other wise only above or below depending on start_bend_angle
"""
s=structure
start=structure.last
if lattice_shift is None: lattice_shift = 0
if pinw is None: pinw=s.defaults['pinw']
if gapw is None: gapw=s.defaults['gapw']
if radius is None: radius=s.defaults['radius']
if num_wiggles == 0 or total_length == 0:
self.vlength=0
return
if start_bend_angle is None:
start_bend_angle=0
if start_bend_angle>0:
asign=1
else:
asign=-1
vlength_overflow=0.0
if symmetric:
vlength=(total_length- radius*(num_wiggles + 2./3.)*pi - 2.*radius*(num_wiggles- 1. + 1./sqrt(3.)))/(2.*num_wiggles -1. +2./sqrt(3.))
else:
vlength=(total_length-(start_bend_angle*pi/180*radius)-pi*radius*(2*num_wiggles-1))/(2*num_wiggles)
if vlength<0:
raise MaskError("Warning: length of vertical segments is less than 0, increase total_length or decrease num_wiggles")
self.vlength=vlength
CPWBend(s,start_bend_angle,pinw,gapw,radius)
for ii in range(num_wiggles):
if symmetric:
isign=2*(ii%2)-1
else:
isign=-1
if ii<num_wiggles-1:
CPWStraight_Bridges_Layer1(s,vlength-lattice_shift/(2*(num_wiggles - 1)),br_base,br_width,pinw,gapw)
# CPWStraight(s,vlength-lattice_shift/(2*(num_wiggles-1)),pinw,gapw)
CPWBend(s,isign*asign*180,pinw,gapw,radius)
CPWStraight_Bridges_Layer1(s,vlength-lattice_shift/(2*(num_wiggles - 1)),br_base,br_width,pinw,gapw)
# CPWStraight(s,vlength-lattice_shift/(2*(num_wiggles-1)),pinw,gapw)
if symmetric:
CPWStraight(s,2*radius,pinw,gapw) #if symmetric must account for initial bend height
else:
CPWBend(s,asign*180,pinw,gapw,radius) #if asymmetric must turn around
else:
CPWStraight_Bridges_Layer1(s,vlength,br_base,br_width,pinw,gapw)
# CPWStraight(s,vlength,pinw,gapw)
CPWBend(s,isign*asign*90,pinw,gapw,radius)
CPWBend(s,isign*asign*60,pinw,gapw,radius)
CPWStraight(s,2.0/sqrt(3)*(vlength+radius),pinw,gapw)
CPWBend(s,-1*isign*asign*60,pinw,gapw,radius)
# if ii == num_wiggles:
# CPWBend(s,90,pinw,gapw,radius)
#CPWBend(s,-isign*start_bend_angle,pinw,gapw,radius)
class CPWWigglesByArea:
"""CPW Wiggles which fill an area specified by (length,width)"""
def __init__(self,structure,length,width,start_up=True,radius=None,pinw=None,gapw=None):
s=structure
if pinw is None:
pinw=s.defaults['pinw']
if gapw is None:
gapw=s.defaults['gapw']
if radius is None:
radius=s.defaults['radius']
#figure out how many wiggles you can fit
#length=2*(num_wiggles+1)*radius
num_wiggles=int(floor(length/(2*radius)-1))
padding=length-2*(num_wiggles+1)*radius
vlength=(width-4*radius)/2
total_length=(1+num_wiggles)*(pi*radius)+2*num_wiggles*vlength+2*(num_wiggles -1)*radius
self.num_wiggles=num_wiggles
self.padding=padding
self.vlength=vlength
self.total_length=total_length
self.properties= { 'num_wiggles':num_wiggles,'padding':padding,'vlength':vlength,'total_length':total_length}
CPWStraight(s,padding/2,pinw,gapw)
CPWWiggles(s,num_wiggles,total_length,start_up,radius,pinw,gapw)
CPWStraight(s,padding/2,pinw,gapw)
class CPWPaddedWiggles:
def __init__(self,structure,length,width,cpw_length,start_up=True,radius=None,pinw=None,gapw=None):
s=structure
if pinw is None:
pinw=s.defaults['pinw']
if gapw is None:
gapw=s.defaults['gapw']
if radius is None:
radius=s.defaults['radius']
if cpw_length<length+(2*pi-4)*radius:
raise MaskError("Error in CPWPaddedWiggles: cpw_length=%f needs less than one wiggle!" %(cpw_length))
#calculate maximum length possible in area
num_wiggles=int(floor(length/(2*radius)-1))
padding=length-2*(num_wiggles+1)*radius
vlength=(width-4*radius)/2
max_length=(1+num_wiggles)*(pi*radius)+2*num_wiggles*vlength+2*(num_wiggles-1)*radius
if cpw_length > max_length:
raise MaskError("Error in CPWPaddedWiggles: cpw_length=%f > max_length=%f that can be fit into alotted area!" %(cpw_length,max_length))
#to be finished
class ChipBorder(Structure):
"""Chip border for dicing"""
def __init__(self,chip,border_thickness,layer="border",color=1):
Structure.__init__(self,chip,layer=layer,color=color)
chip_size=(chip.size[0]+2*border_thickness,chip.size[1]+2*border_thickness)
pts1=[ (0,chip_size[1]),
(chip_size[0],chip_size[1]),
(chip_size[0],chip_size[1]-border_thickness),
(0,chip_size[1]-border_thickness),
(0,chip_size[1])
]
pts1=translate_pts(pts1,(-border_thickness,-border_thickness))
pts2=[ (0,0),
(chip_size[0],0),
(chip_size[0],border_thickness),
(0,border_thickness),
(0,0)
]
pts2=translate_pts(pts2,(-border_thickness,-border_thickness))
pts3=[ (0,border_thickness),
(border_thickness,border_thickness),
(border_thickness,chip_size[1]-border_thickness),
(0,chip_size[1]-border_thickness),
(0,border_thickness)
]
pts3=translate_pts(pts3,(-border_thickness,-border_thickness))
pts4=[ (chip_size[0]-border_thickness,border_thickness),
(chip_size[0],border_thickness),
(chip_size[0],chip_size[1]-border_thickness),
(chip_size[0]-border_thickness,chip_size[1]-border_thickness),
(chip_size[0]-border_thickness,border_thickness)
]
pts4=translate_pts(pts4,(-border_thickness,-border_thickness))
self.append(sdxf.PolyLine(pts1))
self.append(sdxf.PolyLine(pts2))
self.append(sdxf.PolyLine(pts3))
self.append(sdxf.PolyLine(pts4))
class CPWGapCap:
"""A CPW gap capacitor (really just a gap in the CPW center pin with no padding)"""
def __init__(self, gap,pinw=None,gapw=None,capacitance=0.0):
self.type='gap'
self.gap=gap
self.pinw=pinw
self.gapw=gapw
self.capacitance=capacitance
self.length=gap
def description(self):
return "Type:\t%s\tAssumed Capacitance:\t%f\tGap Distance:\t%f\tPin Width:\t%f\t,Gap Width:\t%f\t" % (
self.type,self.capacitance,self.gap,self.pinw,self.gapw
)
def draw(self,structure):
s=structure
start=structure.last
if self.pinw is None: self.pinw=structure.defaults['pinw']
if self.gapw is None: self.gapw=structure.defaults['gapw']
pinw=self.pinw
gapw=self.gapw
## gpoints=[ (start[0],start[1]+pinw/2+gapw),
## (start[0]+self.gap,start[1]+pinw/2+gapw),
## (start[0]+self.gap,start[1]-pinw/2-gapw),
## (start[0],start[1]-pinw/2-gapw),
## (start[0],start[1]+pinw/2+gapw)
## ]
##
## gpoints=rotate_pts(gpoints,s.last_direction,start)
gpoints=[ (0,pinw/2+gapw),
(self.gap,pinw/2+gapw),
(self.gap,-pinw/2-gapw),
(0,-pinw/2-gapw),
(0,pinw/2+gapw)
]
gpoints=orient_pts(gpoints,s.last_direction,start)
#create polylines and append to drawing
s.append(sdxf.PolyLine(gpoints))
#update last anchor position
#stop=rotate_pt((start[0]+self.gap,start[1]),s.last_direction,start)
s.last=orient_pt((self.gap,0),s.last_direction,start)
def ext_Q(frequency,impedance=50,resonator_type=0.5):
if self.capacitance==0:
return 0
frequency=frequency*1e9
q=2.*pi*frequency*self.capacitance*impedance
Q=0
if q!=0:
Q=resonator_type*pi*1/(q**2)
return Q
class CPWInductiveShunt:
"""An inductive shunt"""
def __init__(self,num_segments, segment_length, segment_width, segment_gap, taper_length = 0, pinw=None, inductance = 0.0):
self.type='inductive shunt'
self.inductance = inductance
self.num_segments = num_segments
self.segment_length = segment_length
self.segment_width = segment_width
self.segment_gap = segment_gap
self.taper_length = taper_length
self.pinw=pinw
#self.gapw=gapw
if (num_segments >0 ):
self.gapw = (num_segments+1)*segment_gap+num_segments*segment_width
else:
self.gapw = segment_length
def description(self):
#print self.type,self.inductance,self.num_segments,self.segment_length,self.segment_width,self.segment_gap,self.pinw,self.gapw
return "type:\t%s\tAssumed Inductance:\t%f pH\t# of segments:\t%d\tSegment length:\t%f\tSegment width:\t%f\tSegment gap:\t%f\tTotal inductor length:\t%f\tPin width:\t%f\tGap width:\t%f\tTaper length:\t%f" % (
self.type,self.inductance*1e12,self.num_segments,self.segment_length,self.segment_width,self.segment_gap,self.segment_length*self.num_segments+(self.num_segments+1)*self.segment_gap,self.pinw,self.gapw,self.taper_length
)
def draw(self,structure,pad_to_length = 0, flipped= False):
s=structure
if self.pinw is None: self.pinw=s.defaults['pinw']
pinw=self.pinw
gapw=self.gapw
self.flipped = flipped
if pad_to_length < self.segment_length+self.taper_length:
self.padding=0
else:
self.padding=pad_to_length-self.segment_length-self.taper_length
if not self.flipped: CPWStraight(s,self.padding)
CPWLinearTaper(s,length=self.taper_length,start_pinw=s.defaults['pinw'],start_gapw=s.defaults['gapw'],stop_pinw=pinw,stop_gapw=gapw)
start=structure.last
if self.num_segments >0:
gap = [ (0,0), (self.segment_length-self.segment_width,0), (self.segment_length-self.segment_width,self.segment_gap), (0,self.segment_gap), (0,0) ]
gaps=[]
if self.flipped:
flipped=1
else:
flipped=0
for ii in range (self.num_segments+1):
gaps.append(
orient_pts(
translate_pts(gap, (self.segment_width*((ii+flipped)%2),+pinw/2.0+ii*(self.segment_gap+self.segment_width))),
s.last_direction,start)
)
gaps.append(
orient_pts(
translate_pts(gap,(self.segment_width*((ii+flipped)%2),-(pinw/2.0+self.segment_gap+ii*(self.segment_gap+self.segment_width)))),
s.last_direction,start)
)
for pts in gaps:
s.append(sdxf.PolyLine(pts))
s.last=orient_pt((self.segment_length,0),s.last_direction,start)
else: #If num_segments == 0 then
ugap1 = [ (0,pinw/2.), (0, pinw/2.+self.segment_length), (self.segment_gap, pinw/2.+self.segment_length), (self.segment_gap, pinw/2.), (0,pinw/2.0) ]
ugap2 = translate_pts(ugap1,(self.segment_width+self.segment_gap,0))
lgap1 = mirror_pts(ugap1,0,(self.segment_width+self.segment_gap,0))
lgap2 = mirror_pts(ugap2,0,(self.segment_width+self.segment_gap,0))
ugap1 = orient_pts(ugap1,s.last_direction,s.last)
ugap2 = orient_pts(ugap2,s.last_direction,s.last)
lgap1 = orient_pts(lgap1,s.last_direction,s.last)
lgap2 = orient_pts(lgap2,s.last_direction,s.last)
for pts in [ugap1,ugap2,lgap1,lgap2]:
s.append(sdxf.PolyLine(pts))
s.last=orient_pt((2*self.segment_gap+self.segment_width,0),s.last_direction,s.last)
CPWLinearTaper(s,length=self.taper_length,start_pinw=pinw,start_gapw=gapw,stop_pinw=s.defaults['pinw'],stop_gapw=s.defaults['gapw'])
if self.flipped: CPWStraight(s,self.padding)
def ext_Q (self,frequency, impedance=50, resonator_type=0.5):
if (self.inductance !=0):
if resonator_type==0.5:
return (2/pi)*(impedance/(self.inductance*2*pi*frequency*1e9))**2
if resonator_type==0.25:
return (2./pi)*(impedance/(2*pi*frequency*1e9*self.inductance))**2
else:
return 0.0
def rectangle_points(size,orientation=0,center=(0,0)):
return orient_pts([ (-size[0]/2.,-size[1]/2.),(size[0]/2.,-size[1]/2.),(size[0]/2.,size[1]/2.),(-size[0]/2.,size[1]/2.),(-size[0]/2.,-size[1]/2.)],orientation,center)
class CPWFingerCap:
"""A CPW finger capacitor"""
def __init__(self,num_fingers,finger_length,finger_width,finger_gap,taper_length = 0, gapw=None,capacitance=0.0):
self.type='finger'
self.capacitance=capacitance #simulated capacitance
self.num_fingers=num_fingers #number of fingers
if num_fingers<2:
raise MaskError("CPWFingerCap must have at least 2 fingers!")
self.finger_length=finger_length #length of fingers
self.finger_width=finger_width #width of each finger
self.finger_gap=finger_gap
self.gapw = gapw #gap between "center pin" and gnd planes
self.pinw = num_fingers*finger_width+ (num_fingers-1)*finger_gap #effective center pin width sum of finger gaps and widths
self.length=finger_length+finger_gap
self.taper_length=taper_length
self.total_length=finger_length+finger_gap+2.*taper_length
def description(self):
return "type:\t%s\tAssumed Capacitance:\t%f\t# of fingers:\t%d\tFinger Length:\t%f\tFinger Width:\t%f\tFinger Gap:\t%f\tTotal Pin Width:\t%f\tGap Width:\t%f\tTaper Length:\t%f" % (
self.type,self.capacitance*1e15,self.num_fingers,self.finger_length,self.finger_width,self.finger_gap,self.pinw,self.gapw,self.taper_length
)
def draw(self,structure):
s=structure
pinw=self.pinw
if self.gapw is None: self.gapw=self.pinw*s.defaults['gapw']/s.defaults['pinw']
gapw=self.gapw
CPWLinearTaper(structure,length=self.taper_length,start_pinw=s.defaults['pinw'],start_gapw=s.defaults['gapw'],stop_pinw=pinw,stop_gapw=gapw)
start=structure.last
center_width=self.num_fingers*self.finger_width+ (self.num_fingers-1)*self.finger_gap
length=self.finger_length+self.finger_gap
gap1=[ (start[0],start[1]-center_width/2),
(start[0]+length,start[1]-center_width/2),
(start[0]+length,start[1]-center_width/2-gapw),
(start[0],start[1]-center_width/2-gapw),
(start[0],start[1]-center_width/2)
]
gap2=[ (start[0],start[1]+center_width/2),
(start[0]+length,start[1]+center_width/2),
(start[0]+length,start[1]+center_width/2+gapw),
(start[0],start[1]+center_width/2+gapw),
(start[0],start[1]+center_width/2)
]
gap1=rotate_pts(gap1,s.last_direction,start)
gap2=rotate_pts(gap2,s.last_direction,start)
stop=rotate_pt((start[0]+length,start[1]),s.last_direction,start)
s.last=stop
s.append(sdxf.PolyLine(gap1))
s.append(sdxf.PolyLine(gap2))
#draw finger gaps
for ii in range(self.num_fingers-1):
if ii%2==0:
pts=self.left_finger_points(self.finger_width,self.finger_length,self.finger_gap)
else:
pts=self.right_finger_points(self.finger_width,self.finger_length,self.finger_gap)
pts=translate_pts(pts,start)
pts=translate_pts(pts,(0,ii*(self.finger_width+self.finger_gap)-self.pinw/2))
pts=rotate_pts(pts,s.last_direction,start)
s.append(sdxf.PolyLine(pts))
#draw last little box to separate sides
pts = [ (0,0),(0,self.finger_width),(self.finger_gap,self.finger_width),(self.finger_gap,0),(0,0)]
pts=translate_pts(pts,start)
#if odd number of fingers add box on left otherwise on right
pts=translate_pts(pts,( ((self.num_fingers+1) %2)*(length-self.finger_gap),(self.num_fingers-1)*(self.finger_width+self.finger_gap)-self.pinw/2))
pts=rotate_pts(pts,s.last_direction,start)
s.append(sdxf.PolyLine(pts))
CPWLinearTaper(s,length=self.taper_length,start_pinw=pinw,start_gapw=gapw,stop_pinw=s.defaults['pinw'],stop_gapw=s.defaults['gapw'])
def left_finger_points(self,finger_width,finger_length,finger_gap):
pts= [ (0,0),
(0,finger_width+finger_gap),
(finger_length+finger_gap,finger_width+finger_gap),
(finger_length+finger_gap,finger_width),
(finger_gap,finger_width),
(finger_gap,0),
(0,0)
]
return pts
def right_finger_points(self,finger_width,finger_length,finger_gap):
pts = [ (finger_length+finger_gap,0),
(finger_length+finger_gap,finger_width+finger_gap),
(0,finger_width+finger_gap),
(0,finger_width),
(finger_length,finger_width),
(finger_length,0),
(finger_length+finger_gap,0)
]
return pts
def ext_Q(self,frequency,impedance=50,resonator_type=0.5):
if self.capacitance==0:
return 0
frequency=frequency*1e9
q=2.*pi*frequency*self.capacitance*impedance
Q=0
if q!=0:
Q=1/(resonator_type*pi) *1/ (q**2)
return Q
class CPWLCoupler:
"""A structure which is coupled to a CPW via an L coupler, used for medium to high Q hangers"""
def __init__(self,coupler_length,separation,flipped=False,padding_type=None,pad_to_length=None,pinw=None,gapw=None,radius=None,spinw=None,sgapw=None,capacitance=0.0):
self.type='L'
self.coupler_length=coupler_length
self.separation=separation
self.padding_type=padding_type
self.pad_to_length=pad_to_length
self.pinw=pinw
self.gapw=gapw
self.radius=radius
self.spinw=spinw
self.sgapw=sgapw
self.capacitance=capacitance
self.flipped=flipped
def description(self):
return "Type:\t%s\tEstimated Capacitance:\t%f\tCoupler Length:\t%f\tCoupler Separation:\t%f\tPin Width:\t%f\tGap Width:\t%f\tRadius:\t%f\tFeedline Pin Width:\t%f\tFeedline Gap Width:\t%f\t" % (
self.type,self.capacitance,self.coupler_length,self.separation,self.pinw,self.gapw,self.radius,self.spinw,self.sgapw
)
def draw(self,structure,padding_type=None,pad_to_length=0):
"""Draws the coupler and creates the new structure (self.coupled_structure) for building onto"""
s=structure
if self.pinw is None: self.pinw=s.defaults['pinw']
if self.gapw is None: self.gapw=s.defaults['gapw']
if self.radius is None: self.radius=s.defaults['radius']
self.padding_type=padding_type
self.pad_to_length=pad_to_length
self.spinw=s.defaults['pinw']
self.sgapw=s.defaults['gapw']
start=s.last
start_dir=s.last_direction
lstart_dir=start_dir+180
if self.flipped: flip_sign=-1
else: flip_sign=1
offset_length=0
if padding_type=='center': offset_length=pad_to_length/2
lstart=(offset_length+self.coupler_length+self.gapw+self.radius,flip_sign*self.separation)
if padding_type=='right': lstart=(pad_to_length-gapw,lstart[1])
lstart=rotate_pt(lstart,start_dir)
lstart=translate_pt(lstart,start)
self.coupled_structure=Structure(s.chip,start=lstart,direction=lstart_dir,layer=s.layer,color=s.color,defaults=s.defaults)
cs=self.coupled_structure
cs.defaults['pinw']=self.pinw
cs.defaults['gapw']=self.gapw
cs.defaults['radius']=self.radius
#Continue the feedline
self.feed_length=self.coupler_length+self.radius
if (not self.pad_to_length is None) and (self.pad_to_length > self.feed_length):
self.feed_length=self.pad_to_length
CPWStraight(s,self.feed_length,self.spinw,self.sgapw)
#make the coupler
CPWGapCap(gap=self.gapw).draw(cs)
CPWStraight(cs,self.coupler_length)
CPWBend(cs,-90*flip_sign)
def ext_Q(self,frequency,impedance=50,resonator_type=0.5):
if self.capacitance==0:
return 0
frequency=frequency*1e9
q=2.*pi*frequency*self.capacitance*impedance
Q=0
if q!=0:
Q=resonator_type*pi*1/(q**2)
return Q
class CPWTee(Structure):
"""CPWTee makes a Tee structure with padding"""
def __init__(self,structure,stub_length=None,feed_length=None,flipped=False,pinw=None,gapw=None,spinw=None,sgapw=None):
"""
stub_length is from center
flipped determines whether stub is on left or right of wrt current direction
pinw/gapw are the usual for the stub
spinw/sgapw are the usual for the continuing part
"""
s=structure
#print sgapw
if pinw is None: pinw=s.defaults['pinw']
if gapw is None: gapw=s.defaults['gapw']
if spinw is None: spinw=s.defaults['pinw']
if sgapw is None: sgapw=s.defaults['gapw']
#print "pinw: %f, gapw: %f, spinw: %f, sgapw: %f" % (pinw,gapw,spinw,sgapw)
#minimum feed_length is
if (feed_length is None) or (feed_length < 2*gapw+pinw):
feed_length=2*gapw+pinw
#minimum stub_length is
if (stub_length is None) or (stub_length < gapw+spinw):
stub_length=gapw+spinw/2
#print "pinw: %f, gapw: %f, spinw: %f, sgapw: %f" % (pinw,gapw,spinw,sgapw)
start=s.last
start_dir=s.last_direction
if flipped:
lstart_dir=start_dir-90
angle=start_dir+180
else:
lstart_dir=start_dir+90
angle=start_dir
#Bottom part of feed_line
pts1=[ (-feed_length/2.,-spinw/2.), (-feed_length/2.,-sgapw-spinw/2.0), (feed_length/2.,-sgapw-spinw/2.0),(feed_length/2.,-spinw/2.), (-feed_length/2.,-spinw/2.)]
#Top of feed_line
pts2=[ (-feed_length/2,spinw/2.), (-pinw/2.-gapw,spinw/2.), (-pinw/2.-gapw,gapw+spinw/2.), (-feed_length/2.,gapw+spinw/2.), (-feed_length/2,spinw/2.) ]
pts3=[ (feed_length/2,spinw/2.), (pinw/2.+gapw,spinw/2.), (pinw/2.+gapw,gapw+spinw/2.), (feed_length/2.,gapw+spinw/2.), (feed_length/2,spinw/2.) ]
#stub
pts4=[ (-pinw/2.,spinw/2.), (-pinw/2.,stub_length), (-pinw/2.-gapw,stub_length), (-pinw/2.-gapw,spinw/2.), (-pinw/2.,spinw/2.) ]
pts5=[ (pinw/2.,spinw/2.), (pinw/2.,stub_length), (pinw/2.+gapw,stub_length), (pinw/2.+gapw,spinw/2.), (pinw/2.,spinw/2.) ]
shapes=[pts1,pts2,pts3,pts4,pts5]
center=orient_pt((feed_length/2.,0),s.last_direction,s.last)
for pts in shapes:
pts=orient_pts(pts,angle,center)
s.append(sdxf.PolyLine(pts))
s.last=orient_pt((feed_length,0),s.last_direction,s.last)
lstart=orient_pt((stub_length,0),lstart_dir,center)
Structure.__init__(self,s.chip,start=lstart,direction=lstart_dir,layer=s.layer,color=s.color,defaults=s.defaults)
self.defaults['pinw']=pinw
self.defaults['gapw']=gapw
class FingerCoupler(Structure):
"""Finger coupler a CPWTee plus finger capacitor...not used yet..."""
def __init__(self,structure,cap_desc,stub_length=None,padding_length=None,flipped=False,pinw=None,gapw=None,taper_length=0,spinw=None,sgapw=None):
CPWTee.__init__(structure,stub_length,padding_length,flipped,spinw,sgapw)
if pinw is None: pinw=structure['pinw']
if gapw is None: gapw=structure['gapw']
CPWLinearTaper(self,taper_length,self.defaults['pinw'],cap_desc.pinw,self.defaults['gapw'],cap_desc.gapw)
cap_desc.draw_cap(self)
CPWLinearTaper(self,taper_length,cap_desc.pinw,pinw,cap_desc.gapw,gapw)
#===============================================================================
# NEW CLASSES FOR CHANNEL STRUCTURES & TWO-LAYER PHOTOLITHOGRAPHY
#===============================================================================
class LShapeAlignmentMarks:
def __init__(self,structure,width,armlength):
"""creates an L shaped alignment marker of width and armlength for photolitho"""
if width==0: return
if armlength==0: return
s=structure
start=s.last
box1=[ (start[0]-width/2.,start[1]-width/2.),
(start[0]+armlength-width/2.,start[1]-width/2.),
(start[0]+armlength-width/2.,start[1]+width/2.),
(start[0]+width/2.,start[1]+width/2.),
(start[0]+width/2.,start[1]+armlength-width/2.),
(start[0]-width/2.,start[1]+armlength-width/2.),
(start[0]-width/2.,start[1]-width/2.)]
box1=rotate_pts(box1,s.last_direction,start)
stop=rotate_pt((start[0]+armlength,start[1]),s.last_direction,start)
s.last=stop
s.append(sdxf.PolyLine(box1))
#----------------------------------------------------------------------------
class ArrowAlignmentMarks_L1:
def __init__(self,structure,height,width,buffer=30):
"""creates an arrow/triangle of height and base width for alignment"""
if height==0: return
if width==0: return
s=structure
start=s.last
triangle=[(start[0]+buffer,start[1]),(start[0]+buffer,start[1]+width),(start[0]+buffer+height,start[1]+width/2),(start[0]+buffer,start[1])]
triangle=rotate_pts(triangle,s.last_direction,start)
stop=rotate_pt((start[0]+height,start[1]),s.last_direction,start)
s.last=stop
s.append(sdxf.PolyLine(triangle))
#----------------------------------------------------------------------------
class ArrowAlignmentMarks_L2:
def __init__(self,structure,height,width,buffer=30):
"""creates an arrow/triangle of height and base width for alignment"""
if height==0: return
if width==0: return
s=structure
start=s.last
box=[(start[0],start[1]),(start[0],start[1]+width),(start[0]+buffer+height,start[1]+width),(start[0]+buffer+height,start[1]),(start[0],start[1])]
triangle=[(start[0]+buffer+height,start[1]+width/2),(start[0]+buffer+height+height,start[1]),(start[0]+buffer+height+height,start[1]+width),(start[0]+buffer+height,start[1]+width/2)]
box=rotate_pts(box,s.last_direction,start)
triangle=rotate_pts(triangle,s.last_direction,start)
stop=rotate_pt((start[0]+height,start[1]),s.last_direction,start)
s.last=stop
s.append(sdxf.PolyLine(box))
s.append(sdxf.PolyLine(triangle))
#----------------------------------------------------------------------------
class Channel:
"""A simple channel of given width and length"""
def __init__(self, structure,length,channelw):
""" Adds a channel of width=channelw and of length = length to the structure"""
if length==0: return
if channelw==0: return
s=structure
start=structure.last
ch1=[ (start[0],start[1]-channelw/2),
(start[0]+length,start[1]-channelw/2.),
(start[0]+length,start[1]+channelw/2),
(start[0],start[1]+channelw/2.),
(start[0],start[1]-channelw/2.)
]
ch1=rotate_pts(ch1,s.last_direction,start)
stop=rotate_pt((start[0]+length,start[1]),s.last_direction,start)
s.last=stop
s.append(sdxf.PolyLine(ch1))
#----------------------------------------------------------------------------
class ChannelLinearTaper:
"""A section of channel which (linearly) tapers from width=start_channelw to stop_channelw over length=length"""
def __init__(self, structure,length,start_channelw,stop_channelw):
if length==0: return
#load attributes
s=structure
start=s.last
#define geometry of channel
ch1= [
(start[0],start[1]-start_channelw/2),
(start[0]+length,start[1]-stop_channelw/2),
(start[0]+length,start[1]+stop_channelw/2),
(start[0],start[1]+start_channelw/2),
(start[0],start[1]-start_channelw/2)
]
#rotate structure to proper orientation
ch1=rotate_pts(ch1,s.last_direction,start)
#create polylines and append to drawing
s.append(sdxf.PolyLine(ch1))
#update last anchor position
stop=rotate_pt((start[0]+length,start[1]),s.last_direction,start)
s.last=stop
#------------------------------------------------------------------------------------------
#-------------------------------------------------------------------------------------------------
class ChannelLauncher:
"""creates a channel launcher with a pad of length=pad_length and width=padwidth and a taper of length=taper_length which
linearly tapers from padwidth to channelwidth"""
def __init__(self,structure,flipped=False,pad_length=500,taper_length=400,pad_to_length=1000,padwidth=300,channelwidth=None):
s=structure
padding = pad_to_length-pad_length-taper_length
if padding <0:
padding=0
self.length=pad_length+taper_length
else:
self.length=pad_to_length
if not flipped:
Channel(s,length=pad_length,channelw=padwidth)
ChannelLinearTaper(s,length=taper_length,start_channelw=padwidth,stop_channelw=channelwidth)
Channel(s,length=padding,channelw=channelwidth)
else:
Channel(s,length=padding,channelw=channelwidth)
ChannelLinearTaper(s,length=taper_length,start_channelw=channelwidth,stop_channelw=padwidth)
Channel(s,length=pad_length,channelw=padwidth)
#-------------------------------------------------------------------------------------------------
class ChannelBend:
"""A Channel bend - adapted from CPWBend"""
def __init__(self,structure,turn_angle,channelw=None,radius=None,polyarc=True,segments=60):
"""creates a channel bend with channelw/radius
@param turn_angle: turn_angle is in degrees, positive is CCW, negative is CW
"""
#load default values if necessary
if turn_angle==0: return
s=structure
if radius is None: radius=s.defaults['radius']
if channelw is None: channelw=s.defaults['channelw']
self.structure=structure
self.turn_angle=turn_angle
self.channelw=channelw
self.radius=radius
self.segments=segments
self.pinw=0
self.gapw=channelw/2
self.start=s.last
self.start_angle=s.last_direction
self.stop_angle=self.start_angle+self.turn_angle
if turn_angle>0: self.asign=1
else: self.asign=-1
#DXF uses the angle of the radial vector for its start and stop angles
#so we have to rotate our angles by 90 degrees to get them right
#also it only knows about arcs with CCW sense to them, so we have to rotate our angles appropriately
self.astart_angle=self.start_angle-self.asign*90
self.astop_angle=self.stop_angle-self.asign*90
#calculate location of Arc center
self.center=rotate_pt( (self.start[0],self.start[1]+self.asign*self.radius),self.start_angle,self.start)
if polyarc: self.poly_arc_bend()
else: self.arc_bend()
self.structure.last=rotate_pt(self.start,self.stop_angle-self.start_angle,self.center)
self.structure.last_direction=self.stop_angle
def arc_bend(self):
#print "start: %d, stop: %d" % (start_angle,stop_angle)
if self.turn_angle>0:
self.astart_angle=self.start_angle-90
self.astop_angle=self.stop_angle-90
#calculate location of Arc center
self.center=rotate_pt( (self.start[0],self.start[1]+self.radius),self.start_angle,self.start)
else:
self.astart_angle=self.stop_angle+90
self.astop_angle=self.start_angle+90
#make endlines for inner arc
#start first gap
#points1=[ (self.start[0],self.start[1]+self.pinw/2.),
# (self.start[0],self.start[1]+self.pinw/2.+self.gapw)
#]
points1=[ (self.start[0],self.start[1]+self.gapw),
(self.start[0],self.start[1]-self.gapw)
]
points1=rotate_pts(points1,self.start_angle,self.start)
points2=rotate_pts(points1,self.stop_angle-self.start_angle,self.center)
#start 2nd gap
#points3=[ (self.start[0],self.start[1]-self.pinw/2.),
# (self.start[0],self.start[1]-self.pinw/2.-self.gapw)
# ]
#points3=rotate_pts(points3,self.start_angle,self.start)
#points4=rotate_pts(points3,self.stop_angle-self.start_angle,self.center)
#make inner arcs
self.structure.append(sdxf.Line(points1))
self.structure.append(sdxf.Arc(self.center,self.radius+self.pinw/2.,self.astart_angle,self.astop_angle))
self.structure.append(sdxf.Arc(self.center,self.radius+self.pinw/2.+self.gapw,self.astart_angle,self.astop_angle))
self.structure.append(sdxf.Line(points2))
#self.structure.append(sdxf.Line(points3))
#self.structure.append(sdxf.Arc(self.center,self.radius-self.pinw/2.,self.astart_angle,self.astop_angle))
#self.structure.append(sdxf.Arc(self.center,self.radius-self.pinw/2.-self.gapw,self.astart_angle,self.astop_angle))
#self.structure.append(sdxf.Line(points4))
def poly_arc_bend(self):
#lower gap
pts1=arc_pts(self.astart_angle,self.astop_angle,self.radius+self.pinw/2.+self.gapw,self.segments)
pts1.extend(arc_pts(self.astop_angle,self.astart_angle,self.radius+self.pinw/2.,self.segments))
pts1.append(pts1[0])
pts2=arc_pts(self.astart_angle,self.astop_angle,self.radius-self.pinw/2.,self.segments)
pts2.extend(arc_pts(self.astop_angle,self.astart_angle,self.radius-self.pinw/2.-self.gapw,self.segments))
pts2.append(pts2[0])
self.structure.append(sdxf.PolyLine(translate_pts(pts1,self.center)))
self.structure.append(sdxf.PolyLine(translate_pts(pts2,self.center)))
#-------------------------------------------------------------------------------------------------
class ChannelWiggles:
"""Channel Wiggles (meanders) = adapted from CPWWiggles"""
def __init__(self,structure,num_wiggles,total_length,start_up=True,radius=None,channelw=None,endbending1=True,endbending2=True,inverted=False):
"""
@param num_wiggles: a wiggle is from the center pin up/down and back
@param total_length: The total length of the meander
@param start_up: Start with a CCW 90 degree turn or a CW turn
@param endbending: gives you the option of wheither or not to have an additional 90 degree bend back to horizontal at the two ends
"""
s=structure
start=structure.last
if channelw is None: channelw=s.defaults['channelw']
if radius is None: radius=s.defaults['radius']
#calculate vertical segment length:
#total length=number of 180 degree arcs + number of vertical segs + vertical radius spacers
#total_length=(1+num_wiggles)*(pi*radius)+2*num_wiggles*vlength+2*(num_wiggles-1)*radius
vlength=(total_length-((1+num_wiggles)*(pi*radius)+2*(num_wiggles-1)*radius))/(2*num_wiggles)
if vlength<0: print("Warning: length of vertical segments is less than 0, increase total_length or decrease num_wiggles")
if start_up: asign=1
else: asign=-1
if endbending1:
ChannelBend(s,asign*90,channelw,radius)
for ii in range(num_wiggles):
isign=2*(ii%2)-1
if inverted:
isign=-(2*(ii%2)-1)
Channel(s,vlength,channelw)
ChannelBend(s,isign*asign*180,channelw,radius)
Channel(s,vlength,channelw)
if ii<num_wiggles-1:
Channel(s,2*radius,channelw)
if endbending2:
ChannelBend(s,-isign*asign*90,channelw,radius)
#-------------------------------------------------------------------------------------------------
class ChannelTee(Structure):
"""ChannelTee makes a Tee structure with padding"""
def __init__(self,structure,stub_length=None,feed_length=None,flipped=False,channelw=None):
"""
stub_length is from center
flipped determines whether stub is on left or right of wrt current direction
pinw/gapw are the usual for the stub
spinw/sgapw are the usual for the continuing part
"""
s=structure
if channelw is None: channelw=s.defaults['channelw']
#minimum feed_length is
if (feed_length is None) or (feed_length < channelw):
feed_length=channelw
#minimum stub_length is
if (stub_length is None) or (stub_length < channelw):
stub_length=channelw
#print "pinw: %f, gapw: %f, spinw: %f, sgapw: %f" % (pinw,gapw,spinw,sgapw)
start=s.last
start_dir=s.last_direction
if flipped:
lstart_dir=start_dir-90
angle=start_dir+180
else:
lstart_dir=start_dir+90
angle=start_dir
#feed_line
pts1=[ (-feed_length/2.,-channelw/2.), (-feed_length/2.,channelw/2.), (feed_length/2.,channelw/2.),(feed_length/2.,-channelw/2.), (-feed_length/2.,-channelw/2.)]
#stub
pts2=[ (-channelw/2.,channelw/2),(-channelw/2.,stub_length),(channelw/2.,stub_length),(channelw/2.,channelw/2.),(-channelw/2.,channelw/2.) ]
shapes=[pts1,pts2]
center=orient_pt((feed_length/2.,0),s.last_direction,s.last)
for pts in shapes:
pts=orient_pts(pts,angle,center)
s.append(sdxf.PolyLine(pts))
s.last=orient_pt((feed_length,0),s.last_direction,s.last)
lstart=orient_pt((stub_length,0),lstart_dir,center)
Structure.__init__(self,s.chip,start=lstart,direction=lstart_dir,layer=s.layer,color=s.color,defaults=s.defaults)
self.defaults['channelw']=channelw
#----------------------------------------------------------------------------------
class CenterPinTee(Structure):
"""CCDChannelTee makes a Tee structure with microchannels attached"""
def __init__(self,structure,stub_length=None,feed_length=None,flipped=False,pinw=None,gapw=None,spinw=None,sgapw=None,notchwidth=10,couplinglength=100,channelwidth=8):
"""
stub_length is from center
flipped determines whether stub is on left or right of wrt current direction
pinw/gapw are the usual for the stub
spinw/sgapw are the usual for the continuing part
"""
s=structure
#print sgapw
if pinw is None: pinw=s.defaults['pinw']
if gapw is None: gapw=s.defaults['gapw']
if spinw is None: spinw=s.defaults['pinw']
if sgapw is None: sgapw=s.defaults['gapw']
#print "pinw: %f, gapw: %f, spinw: %f, sgapw: %f" % (pinw,gapw,spinw,sgapw)
#minimum feed_length is
if (feed_length is None) or (feed_length < 2*gapw+pinw):
feed_length=2*gapw+pinw
#minimum stub_length is
if (stub_length is None) or (stub_length < gapw+spinw):
stub_length=gapw+spinw/2
#print "pinw: %f, gapw: %f, spinw: %f, sgapw: %f" % (pinw,gapw,spinw,sgapw)
start=s.last
start_dir=s.last_direction
if flipped:
lstart_dir=start_dir-90
angle=start_dir+180
else:
lstart_dir=start_dir+90
angle=start_dir
#Bottom part of feed_line
pts1=[ (-feed_length/2.,-spinw/2.), (-feed_length/2.,-sgapw-spinw/2.0), (feed_length/2.,-sgapw-spinw/2.0),(feed_length/2.,-spinw/2.), (-feed_length/2.,-spinw/2.)]
#Top of feed_line
pts2=[ (-feed_length/2,spinw/2.), (-pinw/2.-gapw,spinw/2.), (-pinw/2.-gapw,gapw+spinw/2.), (-feed_length/2.,gapw+spinw/2.), (-feed_length/2,spinw/2.) ]
pts3=[ (feed_length/2,spinw/2.), (pinw/2.+gapw,spinw/2.), (pinw/2.+gapw,gapw+spinw/2.), (feed_length/2.,gapw+spinw/2.), (feed_length/2,spinw/2.) ]
#stub
pts4=[ (-pinw/2.,spinw/2.), (-pinw/2.,stub_length), (-pinw/2.-gapw,stub_length), (-pinw/2.-gapw,spinw/2.), (-pinw/2.,spinw/2.) ]
pts5=[ (pinw/2.,spinw/2.), (pinw/2.,stub_length), (pinw/2.+gapw,stub_length), (pinw/2.+gapw,spinw/2.), (pinw/2.,spinw/2.) ]
pts6=[ (-pinw/2.,stub_length), (-pinw/2.,stub_length+couplinglength), (-pinw/2.-notchwidth,stub_length+couplinglength), (-pinw/2.-notchwidth,stub_length), (-pinw/2.,stub_length) ]
pts7=[ (pinw/2.,stub_length), (pinw/2.,stub_length+couplinglength), (pinw/2.+notchwidth,stub_length+couplinglength), (pinw/2.+notchwidth,stub_length), (pinw/2.,stub_length) ]
shapes=[pts1,pts2,pts3,pts4,pts5,pts6,pts7]
center=orient_pt((0,0),s.last_direction,s.last)
for pts in shapes:
pts=orient_pts(pts,angle,center)
s.append(sdxf.PolyLine(pts))
s.last=orient_pt((feed_length,0),s.last_direction,s.last)
lstart=orient_pt((stub_length,0),lstart_dir,center)
Structure.__init__(self,s.chip,start=lstart,direction=lstart_dir,layer=s.layer,color=s.color,defaults=s.defaults)
self.defaults['pinw']=pinw
self.defaults['gapw']=gapw
#-------------------------------------------------------------------------------------------------
class CCDChannelTee(Structure):
"""CCDChannelTee makes a tee structure with microchannels attached;
This is the first layer structure, i.e. everything that's connected
to the center pin of the cavity, second layer see below"""
def __init__(self,structure,stub_length=None,feed_length=None,flipped=False,pinw=None,gapw=None,spinw=None,sgapw=None,ccdwidth=100,ccdlength=100,channelwidth=8):
s=structure
#print sgapw
if pinw is None: pinw=s.defaults['pinw']
if gapw is None: gapw=s.defaults['gapw']
if spinw is None: spinw=s.defaults['pinw']
if sgapw is None: sgapw=s.defaults['gapw']
#minimum feed_length is
if (feed_length is None) or (feed_length < 2*gapw+pinw):
feed_length=2*gapw+pinw
#minimum stub_length is
if (stub_length is None) or (stub_length < gapw+spinw):
stub_length=gapw+spinw/2
start=s.last
start_dir=s.last_direction
if flipped:
lstart_dir=start_dir-90
angle=start_dir+180
else:
lstart_dir=start_dir+90
angle=start_dir
#Bottom part of feed_line
pts1=[ (-feed_length/2.,-spinw/2.), (-feed_length/2.,-sgapw-spinw/2.0), (feed_length/2.,-sgapw-spinw/2.0),(feed_length/2.,-spinw/2.), (-feed_length/2.,-spinw/2.)]
#Top of feed_line
pts2=[ (-feed_length/2,spinw/2.), (-pinw/2.-gapw,spinw/2.), (-pinw/2.-gapw,gapw+spinw/2.), (-feed_length/2.,gapw+spinw/2.), (-feed_length/2,spinw/2.) ]
pts3=[ (feed_length/2,spinw/2.), (pinw/2.+gapw,spinw/2.), (pinw/2.+gapw,gapw+spinw/2.), (feed_length/2.,gapw+spinw/2.), (feed_length/2,spinw/2.) ]
#stub
pts4=[ (-pinw/2.,spinw/2.), (-pinw/2.,stub_length), (-pinw/2.-gapw,stub_length), (-pinw/2.-gapw,spinw/2.), (-pinw/2.,spinw/2.) ]
pts5=[ (pinw/2.,spinw/2.), (pinw/2.,stub_length), (pinw/2.+gapw,stub_length), (pinw/2.+gapw,spinw/2.), (pinw/2.,spinw/2.) ]
#channels/CCD
pts6=[(-pinw/2.,stub_length),(-pinw/2.,stub_length+gapw),(-pinw/2.-ccdwidth/2.,stub_length+gapw),(-pinw/2.-ccdwidth/2.,stub_length),(-pinw/2.,stub_length)]
pts7=[(pinw/2.,stub_length),(pinw/2.,stub_length+gapw),(pinw/2.+ccdwidth/2.,stub_length+gapw),(pinw/2.+ccdwidth/2.,stub_length),(pinw/2.,stub_length)]
pts8=[(-pinw/2.-ccdwidth/2.+gapw,stub_length+gapw),(-pinw/2.-ccdwidth/2.+gapw,stub_length+gapw+ccdlength-gapw),(-pinw/2.-ccdwidth/2.,stub_length+gapw+ccdlength-gapw),(-pinw/2.-ccdwidth/2.,stub_length+gapw),(-pinw/2.-ccdwidth/2.+gapw,stub_length+gapw)]
pts9=[(pinw/2.+ccdwidth/2.-gapw,stub_length+gapw),(pinw/2.+ccdwidth/2.-gapw,stub_length+gapw+ccdlength-gapw),(pinw/2.+ccdwidth/2.,stub_length+gapw+ccdlength-gapw),(pinw/2.+ccdwidth/2.,stub_length+gapw),(pinw/2.+ccdwidth/2.-gapw,stub_length+gapw)]
pts10=[(-pinw/2.,stub_length+ccdlength),(-pinw/2.,stub_length+gapw+ccdlength),(-pinw/2.-ccdwidth/2.,stub_length+gapw+ccdlength),(-pinw/2.-ccdwidth/2.,stub_length+ccdlength),(-pinw/2.,stub_length+ccdlength)]
pts11=[(pinw/2.,stub_length+ccdlength),(pinw/2.,stub_length+gapw+ccdlength),(pinw/2.+ccdwidth/2.,stub_length+gapw+ccdlength),(pinw/2.+ccdwidth/2.,stub_length+ccdlength),(pinw/2.,stub_length+ccdlength)]
shapes=[pts1,pts2,pts3,pts4,pts5,pts6,pts7,pts8,pts9,pts10,pts11]
numberofchannels=(ccdwidth-2*gapw+pinw-channelwidth)/(2*channelwidth)
numberofchannels=int(round(float(numberofchannels)))
totalchannelwidth=(2*numberofchannels-1)*channelwidth
padding=((ccdwidth+pinw-2*gapw)-totalchannelwidth)/2.
innerwidthstart=-pinw/2.-ccdwidth/2.+2*channelwidth+gapw #inner width of structure measured from left
self.numberofchannels=numberofchannels
self.channelwidth=channelwidth
for j in range(numberofchannels):
pts_temp=[(innerwidthstart+channelwidth+padding,stub_length+gapw+channelwidth),
(innerwidthstart+channelwidth+padding,stub_length+gapw+ccdlength-2*channelwidth-gapw),
(innerwidthstart+padding,stub_length+gapw+ccdlength-2*channelwidth-gapw),
(innerwidthstart+padding,stub_length+gapw+channelwidth),
(innerwidthstart+channelwidth+padding,stub_length+gapw+channelwidth)]
pts_temp=translate_pts(pts_temp,((j-1)*2*channelwidth,0))
shapes.append(pts_temp)
pts12=[(-innerwidthstart-padding+2*channelwidth,stub_length+gapw+ccdlength-2*channelwidth-gapw),
(-innerwidthstart-padding+2*channelwidth,stub_length+gapw+ccdlength-2*channelwidth-gapw+channelwidth),
(innerwidthstart+padding-2*channelwidth,stub_length+gapw+ccdlength-2*channelwidth-gapw+channelwidth),
(innerwidthstart+padding-2*channelwidth,stub_length+gapw+ccdlength-2*channelwidth-gapw),
(-innerwidthstart-padding+2*channelwidth,stub_length+gapw+ccdlength-2*channelwidth-gapw)]
shapes.append(pts12)
center=orient_pt((0,0),s.last_direction,s.last)
for pts in shapes:
pts=orient_pts(pts,angle,center)
s.append(sdxf.PolyLine(pts))
s.last=orient_pt((feed_length,0),s.last_direction,s.last)
lstart=orient_pt((stub_length,0),lstart_dir,center)
Structure.__init__(self,s.chip,start=lstart,direction=lstart_dir,layer=s.layer,color=s.color,defaults=s.defaults)
self.defaults['pinw']=pinw
self.defaults['gapw']=gapw
#-------------------------------------------------------------------------------------------------
class CCDChannelTeeL2(Structure):
"""CCDChannelTee makes a tee structure with microchannels attached
this is the second layer for the thin electrodes"""
def __init__(self,structure,stub_length=None,feed_length=None,flipped=False,pinw=None,gapw=None,spinw=None,sgapw=None,ccdwidth=100,ccdlength=100,channelwidth=8,electrodewidth=3):
"""
stub_length is from center
flipped determines whether stub is on left or right of wrt current direction
pinw/gapw are the usual for the stub
spinw/sgapw are the usual for the continuing part
"""
s=structure
#print sgapw
if pinw is None: pinw=s.defaults['pinw']
if gapw is None: gapw=s.defaults['gapw']
if spinw is None: spinw=s.defaults['pinw']
if sgapw is None: sgapw=s.defaults['gapw']
#print "pinw: %f, gapw: %f, spinw: %f, sgapw: %f" % (pinw,gapw,spinw,sgapw)
#minimum feed_length is
if (feed_length is None) or (feed_length < 2*gapw+pinw):
feed_length=2*gapw+pinw
#minimum stub_length is
if (stub_length is None) or (stub_length < gapw+spinw):
stub_length=gapw+spinw/2
#print "pinw: %f, gapw: %f, spinw: %f, sgapw: %f" % (pinw,gapw,spinw,sgapw)
start=s.last
start_dir=s.last_direction
if flipped:
lstart_dir=start_dir-90
angle=start_dir+180
else:
lstart_dir=start_dir
angle=start_dir
#useful definitions
numberofchannels=(ccdwidth-2*gapw+pinw-channelwidth)/(2*channelwidth)
numberofchannels=int(round(float(numberofchannels)))
totalchannelwidth=(2*numberofchannels-1)*channelwidth
padding=((ccdwidth+pinw-2*gapw)-totalchannelwidth)/2.
innerwidthstart=-pinw/2.-ccdwidth/2.+2*channelwidth+gapw #inner width of structure measured from left
self.numberofchannels=numberofchannels
self.channelwidth=channelwidth
shapes=[]
#make the fingers
for j in range(numberofchannels):
pts_temp=[(innerwidthstart+channelwidth+padding-electrodewidth,stub_length+gapw+channelwidth+electrodewidth),
(innerwidthstart+channelwidth+padding-electrodewidth,stub_length+gapw+ccdlength-2*channelwidth-gapw+electrodewidth),
(innerwidthstart+padding+electrodewidth,stub_length+gapw+ccdlength-2*channelwidth-gapw+electrodewidth),
(innerwidthstart+padding+electrodewidth,stub_length+gapw+channelwidth+electrodewidth),
(innerwidthstart+channelwidth+padding-electrodewidth,stub_length+gapw+channelwidth+electrodewidth)]
pts_temp=translate_pts(pts_temp,((j-1)*2*channelwidth,0))
shapes.append(pts_temp)
pts1=[(-innerwidthstart+2*channelwidth-padding-electrodewidth,stub_length+gapw+ccdlength-2*channelwidth-gapw+electrodewidth),
(-innerwidthstart+2*channelwidth-padding-electrodewidth,stub_length+gapw+ccdlength-2*channelwidth-gapw+channelwidth-electrodewidth),
(innerwidthstart-2*channelwidth+padding+electrodewidth,stub_length+gapw+ccdlength-2*channelwidth-gapw+channelwidth-electrodewidth),
(innerwidthstart-2*channelwidth+padding+electrodewidth,stub_length+gapw+ccdlength-2*channelwidth-gapw+electrodewidth),
(-innerwidthstart+2*channelwidth-padding-electrodewidth,stub_length+gapw+ccdlength-2*channelwidth-gapw+electrodewidth)]
shapes.append(pts1)
center=orient_pt((0,0),s.last_direction,s.last)
for pts in shapes:
pts=orient_pts(pts,angle,center)
s.append(sdxf.PolyLine(pts))
s.last=orient_pt((feed_length,0),s.last_direction,s.last)
lstart=orient_pt((stub_length,0),lstart_dir,center)
Structure.__init__(self,s.chip,start=lstart,direction=lstart_dir,layer=s.layer,color=s.color,defaults=s.defaults)
self.defaults['pinw']=pinw
self.defaults['gapw']=gapw
#-------------------------------------------------------------------------------------------------
class ChannelReservoirL1(Structure):
"""ChannelReservoir - first layer
width=total width of reservoir
length=total length of reservoir
channelw=width of individual channels"""
def __init__(self,structure,flipped=False,width=100,length=100,channelw=8):
s=structure
start=s.last
start_dir=s.last_direction
if flipped:
lstart_dir=start_dir-90
angle=start_dir+180
else:
lstart_dir=start_dir+90
angle=start_dir
#note: numberofchannels is twice the true number of channels since
#it also contains the spacing between the channels
numberofchannels=length/(2*channelw)
numberofchannels=int(round(float(numberofchannels)))
length=numberofchannels*2*channelw-channelw
self.numberofchannels=numberofchannels
leftchannel=[(-width/2.,0),(-channelw/2.,0),(-channelw/2.,channelw),(-width/2.,channelw),(-width/2.,0)]
rightchannel=[(width/2.,0),(channelw/2.,0),(channelw/2.,channelw),(width/2.,channelw),(width/2.,0)]
# add the first channels on lhs and rhs side of center
shapes=[leftchannel,rightchannel]
# add the other channels by translation
for j in range(1,numberofchannels):
pts_lhs=translate_pts(leftchannel,(0,j*2*channelw))
pts_rhs=translate_pts(rightchannel,(0,j*2*channelw))
shapes.append(pts_lhs)
shapes.append(pts_rhs)
centerbox=[(-channelw/2,0),(channelw/2.,0),(channelw/2.,length),(-channelw/2.,length),(-channelw/2.,0)]
shapes.append(centerbox)
center=orient_pt((0,0),s.last_direction,s.last)
for pts in shapes:
pts=orient_pts(pts,angle,center)
s.append(sdxf.PolyLine(pts))
s.last=orient_pt((0,length),s.last_direction,s.last)
lstart=orient_pt((0,0),lstart_dir,center)
Structure.__init__(self,s.chip,start=lstart,direction=lstart_dir,layer=s.layer,color=s.color,defaults=s.defaults)
#-------------------------------------------------------------------------------------------------
class ChannelReservoirL2(Structure):
"""ChannelReservoir - second layer
width=total width of reservoir
length=total length of reservoir
channelw=width of individual channels"""
def __init__(self,structure,flipped=False,width=100,length=100,channelw=8,electrodewidth=2):
s=structure
start=s.last
start_dir=s.last_direction
if flipped:
lstart_dir=start_dir-90
angle=start_dir+180
else:
lstart_dir=start_dir+90
angle=start_dir
#note: numberofchannels is twice the true number of channels since
#it also contains the spacing between the channels
numberofchannels=length/(2*channelw)
numberofchannels=int(round(float(numberofchannels)))
length=numberofchannels*2*channelw-channelw
self.numberofchannels=numberofchannels
delta=(channelw-electrodewidth)/2.
leftchannel=[(-width/2.+delta,delta),(-channelw/2.+delta,delta),(-channelw/2.+delta,delta+electrodewidth),(-width/2.+delta,delta+electrodewidth),(-width/2.+delta,delta)]
rightchannel=[(width/2.-delta,delta),(channelw/2.-delta,delta),(channelw/2.-delta,delta+electrodewidth),(width/2.-delta,delta+electrodewidth),(width/2.-delta,delta)]
# add the first channels on lhs and rhs side of center
shapes=[leftchannel,rightchannel]
# add the other channels by translation
for j in range(1,numberofchannels):
pts_lhs=translate_pts(leftchannel,(0,j*2*channelw))
pts_rhs=translate_pts(rightchannel,(0,j*2*channelw))
shapes.append(pts_lhs)
shapes.append(pts_rhs)
centerbox=[(-electrodewidth/2,0),(electrodewidth/2.,0),(electrodewidth/2.,length),(-electrodewidth/2.,length),(-electrodewidth/2.,0)]
shapes.append(centerbox)
center=orient_pt((0,0),s.last_direction,s.last)
for pts in shapes:
pts=orient_pts(pts,angle,center)
s.append(sdxf.PolyLine(pts))
s.last=orient_pt((0,length),s.last_direction,s.last)
lstart=orient_pt((0,0),lstart_dir,center)
Structure.__init__(self,s.chip,start=lstart,direction=lstart_dir,layer=s.layer,color=s.color,defaults=s.defaults)
#-------------------------------------------------------------------------------------------------
class ChannelFingerCap:
"""A Channel finger capacitor"""
def __init__(self,num_fingers,finger_length,finger_width,finger_gap,taper_length=10,channelw=2,capacitance=0.0):
self.type='Channel finger cap'
self.capacitance=capacitance #simulated capacitance
self.num_fingers=num_fingers #number of fingers
if num_fingers<2:
raise MaskError("ChannelFingerCap must have at least 2 fingers!")
self.finger_length=finger_length #length of fingers
self.finger_width=finger_width #width of each finger
self.finger_gap=finger_gap
self.pinw = num_fingers*finger_width+ (num_fingers-1)*finger_gap #effective center pin width sum of finger gaps and widths
self.length=finger_length+finger_gap
self.taper_length=taper_length
self.gapw=channelw
def description(self):
return "type:\t%s\tAssumed Capacitance:\t%f\t# of fingers:\t%d\tFinger Length:\t%f\tFinger Width:\t%f\tFinger Gap:\t%f\tTotal Pin Width:\t%f\tTaper Length:\t%f" % (
self.type,self.capacitance*1e15,self.num_fingers,self.finger_length,self.finger_width,self.finger_gap,self.pinw,self.taper_length
)
def draw(self,structure):
s=structure
pinw=self.pinw
ChannelLinearTaper(s,length=self.taper_length,start_channelw=self.gapw,stop_channelw=self.pinw)
start=s.last
center_width=self.num_fingers*self.finger_width+ (self.num_fingers-1)*self.finger_gap
length=self.finger_length+self.finger_gap
#draw finger gaps
pts1=self.left_finger_points(self.finger_width,self.finger_length,self.finger_gap)
pts1=translate_pts(pts1,start)
pts1=rotate_pts(pts1,s.last_direction,start)
#pts1=translate_pts(pts1,(self.finger_length+self.finger_gap,0))
s.append(sdxf.PolyLine(pts1))
pts2=self.right_finger_points(self.finger_width,self.finger_length,self.finger_gap)
pts2=translate_pts(pts2,start)
pts2=rotate_pts(pts2,s.last_direction,start)
#pts2=translate_pts(pts2,(self.finger_length+self.finger_gap,0))
s.append(sdxf.PolyLine(pts2))
stop=rotate_pt((start[0]+self.finger_length+self.finger_gap,start[1]),s.last_direction,start)
s.last=stop
ChannelLinearTaper(s,length=self.taper_length,start_channelw=self.pinw,stop_channelw=self.gapw+2.5)
def left_finger_points(self,finger_width,finger_length,finger_gap):
pts= [ (0,self.pinw/2.),
(finger_length,self.pinw/2.),
(finger_length,self.pinw/2.-finger_width),
(0,self.pinw/2.-finger_width),
(0,self.pinw/2.)
]
return pts
def right_finger_points(self,finger_width,finger_length,finger_gap):
pts= [ (finger_gap,-self.pinw/2.),
(finger_gap+finger_length,-self.pinw/2.),
(finger_gap+finger_length,-self.pinw/2.+finger_width),
(finger_gap,-self.pinw/2.+finger_width),
(finger_gap,-self.pinw/2.)
]
return pts
def ext_Q(self,frequency,impedance=50,resonator_type=0.5):
if self.capacitance==0:
return 0
frequency=frequency*1e9
q=2.*pi*frequency*self.capacitance*impedance
Q=0
if q!=0:
Q=1/(resonator_type*pi) *1/ (q**2)
return Q
#-------------------------------------------------------------------------------------------------
class ForkCoupler(Structure):
"""makes a fork-shaped structure of electrodes
fork_width is the total width of the fork"""
def __init__(self,structure,fork_width=None,fork_length=None,flipped=False,finger_width=None,channelw=None):
"""
"""
s=structure
start=s.last
start_dir=s.last_direction
if channelw is None: channelw=s.defaults['channelw']
#minimum fork_width is
if (fork_width is None) or (fork_width < channelw):
fork_width=channelw
if (fork_length is None) or (fork_length < channelw):
fork_length=channelw
if finger_width is None:
finger_width=channelw/2.
if flipped:
lstart_dir=start_dir-90
angle=start_dir+180
else:
lstart_dir=start_dir
angle=start_dir-90
#fork vertical
pts1=[ (-fork_width/2.,0), (-fork_width/2.,finger_width), (fork_width/2.,finger_width),(fork_width/2.,0), (-fork_width/2.,0)]
#fork finger one
pts2=[ (-fork_width/2.,finger_width),(-fork_width/2.,finger_width+fork_length),(-fork_width/2.+finger_width,finger_width+fork_length),(-fork_width/2.+finger_width,finger_width),(-fork_width/2.,finger_width)]
#fork finger two
pts3=[ (fork_width/2.,finger_width),(fork_width/2.,finger_width+fork_length),(fork_width/2.-finger_width,finger_width+fork_length),(fork_width/2.-finger_width,finger_width),(fork_width/2.,finger_width)]
shapes=[pts1,pts2,pts3]
center=orient_pt((0,0),s.last_direction,s.last)
for pts in shapes:
pts=orient_pts(pts,angle,center)
s.append(sdxf.PolyLine(pts))
s.last=orient_pt((fork_length,0),s.last_direction,s.last)
lstart=orient_pt((0,0),lstart_dir,center)
Structure.__init__(self,s.chip,start=lstart,direction=lstart_dir,layer=s.layer,color=s.color,defaults=s.defaults)
#s.last=orient_pt((0,0),s.last_direction,s.last)
#lstart=orient_pt((0,0),s.last_direction,s.last)
#Structure.__init__(self,s.chip,start=lstart,direction=0,layer=s.layer,color=s.color,defaults=s.defaults)
#self.defaults['channelw']=channelw
#=======================================================================
# MISC COMPONENTS/CLASSES
#=======================================================================
class CapDesc:
"""Description of a capacitor, including physical geometry and simulated capacitance
valid types are ('gap','finger','L')
!deprecated!CPWLinearTaper
"""
def __init__(self,capacitance,cap_gap,gapw,num_fingers=0,finger_length=0,finger_width=0,type='gap'):
self.capacitance=capacitance #simulated capacitance
self.num_fingers=num_fingers #number of fingers (0 means gap cap)
self.finger_length=finger_length #length of fingers
self.finger_width=finger_width #width of each finger
self.cap_gap = cap_gap #gap between fingers or center pins
self.finger_gap=cap_gap #for convenience set this to finger_gap
self.gapw = gapw #gap between "center pin" and gnd planes
self.pinw = num_fingers*finger_width+ (num_fingers-1)*cap_gap #effective center pin width sum of finger gaps and widths
def draw_cap(self,structure):
if self.num_fingers>0:
CPWFingerCap(structure,self.num_fingers,self.finger_length,self.finger_width,self.cap_gap,self.gapw)
else:
CPWGapCap(structure,self.cap_gap)
class AlphaNum:
"""A polyline representation of an alphanumeric character, does not use structures"""
def __init__(self,drawing,letter,size,point,direction=0):
if (letter=='') or (letter==' '):
return
#s=structure
scaled_size=(size[0]/16.,size[1]/16.)
for pts in alphanum_dict[letter.lower()]:
mpts = scale_pts(pts,scaled_size)
mpts = orient_pts(mpts,direction,point)
drawing.append(sdxf.PolyLine(mpts))
#s.last=orient_pt( (size[0],0),s.last_direction,s.last)
class AlphaNumText:
"""Renders a text string in polylines, does not use structures"""
def __init__(self,drawing,text,size,point,centered=False,direction=0):
self.text=text
if text is None:
return
if centered:
offset=(-size[0]*text.__len__()/2.,0)
point=orient_pt(offset,direction,point)
for letter in text:
AlphaNum(drawing,letter,size,point,direction)
point=orient_pt( (size[0],0),direction,point)
class AlignmentCross:
def __init__(self,drawing,linewidth,size,point):
lw=linewidth/2.
w=size[0]/2.
h=size[1]/2.
pts=[ (-lw,-h), (lw,-h), (lw,-lw),(w,-lw),(w,lw),(lw,lw),(lw,h),(-lw,h),(-lw,lw),(-w,lw),(-w,-lw),(-lw,-lw),(-lw,-h)]
pts=translate_pts(pts,point)
drawing.append(sdxf.PolyLine(pts))
def arc_pts(start_angle,stop_angle,radius,segments=360):
pts=[]
for ii in range(segments):
theta=(start_angle+ii/(segments-1.)*(stop_angle-start_angle))*pi/180.
p=(radius*cos(theta),radius*sin(theta))
pts.append(p)
return pts
class fluxWebBlock(sdxf.Block):
"""fluxWebBlock is block that will be tiled to
create the flux webbing
"""
def __init__(self,name,holeL=5.,period=10.,chipSize=(7000.,2000.)):
self.name=name
self.holeL=holeL
self.period=period
self.chipSize=chipSize
self.cols=int(floor(chipSize[0]/period))
self.rows=int(floor(chipSize[1]/period))
self.layer='fluxweb'
self.color=4
self.base=(0,0)
sdxf.Block.__init__(self,self.name,self.layer,self.base)
offset = (period-holeL)/2.
holePoints =[ (offset,offset),
(offset+holeL,offset),
(offset+holeL,offset+holeL),
(offset,offset+holeL),
(offset,offset),
]
self.append(sdxf.PolyLine(holePoints,layer=self.layer,color=self.color))
class QuarterMask(sdxf.Drawing):
"""Mask class for placing chips on a 1"x1" sapphire quarter.
"""
def __init__(self,name,chip_size=(7000.,2000.),dicing_border=350,cols=3,rows=10,labelToggle=True):
sdxf.Drawing.__init__(self)
self.name=name
self.fileName=name+".dxf"
self.chip_size=chip_size
self.dicing_border=dicing_border
self.cols=cols
self.rows=rows
self.labelToggle = labelToggle
#Creates Border Box
patternW = cols*chip_size[0]+(cols+1)*dicing_border
patternH = rows*chip_size[1]+(rows+1)*dicing_border
borderPadding = 5000.
border=Structure(self,start=(0,0),color=3,layer="border")
box=[ (0-borderPadding,0-borderPadding),
(patternW+borderPadding,0-borderPadding),
(patternW+borderPadding,patternH+borderPadding),
(0-borderPadding,patternH+borderPadding),
(0-borderPadding,0-borderPadding)
]
border.append(sdxf.PolyLine(box,layer=border.layer,color=border.color))
#Creates list of chip insert locations
chip_points=[]
for ii in range(rows):
for jj in range(cols):
x=jj*(chip_size[0]+dicing_border)+dicing_border
y=ii*(chip_size[1]+dicing_border)+dicing_border
pt = (x,y)
chip_points.append(pt)
self.chip_points=chip_points
self.chip_slots=chip_points.__len__()
self.current_point=0
self.manifest=[]
self.num_chips=0
def add_chip(self,chip,copies=1):
"""Adds chip design 'copies' times into mask. chip must have a unique name as it will be inserted as a block"""
#generate flux web block definition
if chip.makeWeb:
flux=fluxWebBlock(chip.name+'WEB',holeL=chip.fluxHoleLength,period=chip.fluxPeriod,chipSize=chip.size)
self.blocks.append(flux)
#add blocks to drawing
self.blocks.append(chip)
slots_remaining=self.chip_points.__len__()-self.current_point
for ii in range (copies):
if self.current_point>= self.chip_points.__len__():
raise MaskError("MaskError: Cannot add %d copies of chip '%s' Only %d slots on mask and %d remaining." % (copies,chip.name,self.chip_points.__len__(),slots_remaining))
p=self.chip_points[self.current_point]
self.current_point+=1
self.append(sdxf.Insert(chip.name,point=p))
if chip.makeWeb: self.append(sdxf.Insert(flux.name,point=p,cols=flux.cols,colspacing=flux.period,rows=flux.rows,rowspacing=flux.period))
if self.labelToggle: chip.label_chip(self,maskid=self.name,chipid=chip.name+str(ii+1),offset=p)
self.num_chips+=1
#self.manifest.append({'chip':chip,'name':chip.name,'copies':copies,'short_desc':chip.short_description(),'long_desc':chip.long_description()})
#print "%s\t%d\t%s" % (chip.name,copies,chip.short_description())
chip.save(fname=self.name+"-"+chip.name,maskid=self.name,chipid=chip.name)
def randomize_layout(self):
"""Shuffle the order of the chip_points array so that chips will be inserted (pseudo-)randomly"""
seed=124279234
for ii in range(10000):
i1=randrange(self.chip_points.__len__())
i2=randrange(self.chip_points.__len__())
tp=self.chip_points[i1]
self.chip_points[i1]=self.chip_points[i2]
self.chip_points[i2]=tp
"""
Updated functions to create various structures with advance protection options
they'll have the same name except with a p in front
"""
class pDrawBondPad:
def __init__(self,drawing,pos,Ang,bond_pad_length=None,launcher_pinw=None,launcher_gapw=None,taper_length=None, pinw=None, gapw=None):
"""
Created on 08/09/2011
@author: Brendon Rose
Script appends a BondPad on drawing and position pos and Angle Ang relative to the positive x-axis CCW is positive
"""
"Set Self-attributes"
#Launcher parameters set to default if nothing was input
if bond_pad_length == None: bond_pad_length = 400.
if launcher_pinw == None: launcher_pinw = 150.
if launcher_gapw == None: launcher_gapw = 67.305
if taper_length == None: taper_length = 300.
#if launcher_padding == None: launcher_padding = 350.
#if launcher_radius == None: launcher_radius = 125.
if pinw == None: pinw = drawing.defaults['pinw']
if gapw == None: gapw = drawing.defaults['gapw']
s = drawing #define structure for writting bond pad to
s.last = pos #Position to put bond pad
s.last_direction = Ang #Angle to put bond pad
#launcher_length=taper_length+bond_pad_length+launcher_padding
"Draw the BondPad and a curly wire to offset launcher"
pCPWStraight(s,length=bond_pad_length,pinw=launcher_pinw,gapw=launcher_gapw)
pCPWLinearTaper(s,length=taper_length,start_pinw=launcher_pinw,start_gapw=launcher_gapw,stop_pinw=pinw,stop_gapw=gapw)
class pCPWStraight:
"""A straight section of CPW transmission line"""
def __init__(self, structure,length,pinw=None,gapw=None,protect=None,centerPinHoleWidth=None):
""" Adds a straight section of CPW transmission line of length = length to the structure"""
if length==0: return
s=structure
start=structure.last
if pinw is None: pinw=structure.defaults['pinw']
if gapw is None: gapw=structure.defaults['gapw']
if protect is None: protect=structure.defaults['protect']
if centerPinHoleWidth is None: centerPinHoleWidth=structure.defaults['centerPinHoleWidth']
gap1=[ (start[0],start[1]+pinw/2),
(start[0]+length,start[1]+pinw/2),
(start[0]+length,start[1]+pinw/2+gapw),
(start[0],start[1]+pinw/2+gapw),
(start[0],start[1]+pinw/2)
]
gap2=[ (start[0],start[1]-pinw/2),
(start[0]+length,start[1]-pinw/2),
(start[0]+length,start[1]-pinw/2-gapw),
(start[0],start[1]-pinw/2-gapw),
(start[0],start[1]-pinw/2)
]
gap1=rotate_pts(gap1,s.last_direction,start)
gap2=rotate_pts(gap2,s.last_direction,start)
stop=rotate_pt((start[0]+length,start[1]),s.last_direction,start)
s.last=stop
s.append(sdxf.PolyLine(gap1))
s.append(sdxf.PolyLine(gap2))
"""adding code to create protect box"""
prow = pinw+2*gapw+2*protect
pro_inner = pinw/2-centerPinHoleWidth
pro1=[ (start[0],start[1]+pro_inner),
(start[0]+length,start[1]+pro_inner),
(start[0]+length,start[1]+prow/2),
(start[0],start[1]+prow/2),
(start[0],start[1]+pro_inner)
]
pro2=[ (start[0],start[1]-pro_inner),
(start[0]+length,start[1]-pro_inner),
(start[0]+length,start[1]-prow/2),
(start[0],start[1]-prow/2),
(start[0],start[1]-pro_inner)
]
pro1=rotate_pts(pro1,s.last_direction,start)
pro2=rotate_pts(pro2,s.last_direction,start)
s.append(sdxf.PolyLine(pro1,layer="ProtectLayer"))
s.append(sdxf.PolyLine(pro2,layer="ProtectLayer"))
class pCPWLinearTaper:
"""A section of CPW which (linearly) tapers from one set of start_pinw and start_gapw to stop_pinw and stop_gapw over length=length"""
def __init__(self, structure,length,start_pinw,stop_pinw,start_gapw,stop_gapw,protect=None,centerPinHoleWidth=None):
if length==0: return
if protect is None: protect=structure.defaults['protect']
if centerPinHoleWidth is None: centerPinHoleWidth=structure.defaults['centerPinHoleWidth']
#load attributes
s=structure
start=s.last
#define geometry of gaps
gap1= [
(start[0],start[1]+start_pinw/2),
(start[0]+length,start[1]+stop_pinw/2),
(start[0]+length,start[1]+stop_pinw/2+stop_gapw),
(start[0],start[1]+start_pinw/2+start_gapw),
(start[0],start[1]+start_pinw/2)
]
gap2= [
(start[0],start[1]-start_pinw/2),
(start[0]+length,start[1]-stop_pinw/2),
(start[0]+length,start[1]-stop_pinw/2-stop_gapw),
(start[0],start[1]-start_pinw/2-start_gapw),
(start[0],start[1]-start_pinw/2)
]
#rotate structure to proper orientation
gap1=rotate_pts(gap1,s.last_direction,start)
gap2=rotate_pts(gap2,s.last_direction,start)
#create polylines and append to drawing
s.append(sdxf.PolyLine(gap1))
s.append(sdxf.PolyLine(gap2))
#update last anchor position
stop=rotate_pt((start[0]+length,start[1]),s.last_direction,start)
s.last=stop
"""adding code to create protect box"""
start_prow = start_pinw+2*start_gapw+2*protect
start_pro_inner = start_pinw/2-centerPinHoleWidth
stop_prow = stop_pinw+2*stop_gapw+2*protect
stop_pro_inner = stop_pinw/2-centerPinHoleWidth
pro1=[ (start[0],start[1]+start_pro_inner),
(start[0]+length,start[1]+stop_pro_inner),
(start[0]+length,start[1]+stop_prow/2),
(start[0],start[1]+start_prow/2),
(start[0],start[1]+start_pro_inner)
]
pro2=[ (start[0],start[1]-start_pro_inner),
(start[0]+length,start[1]-stop_pro_inner),
(start[0]+length,start[1]-stop_prow/2),
(start[0],start[1]-start_prow/2),
(start[0],start[1]-start_pro_inner)
]
pro1=rotate_pts(pro1,s.last_direction,start)
pro2=rotate_pts(pro2,s.last_direction,start)
s.append(sdxf.PolyLine(pro1,layer="ProtectLayer"))
s.append(sdxf.PolyLine(pro2,layer="ProtectLayer")) | [
"maritter@umd.edu"
] | maritter@umd.edu |
8792f9fb40411dda7586be8db31e4e63b961154c | 2dd814284a1408706459e7dd6295a4575617c0c6 | /cupyx/scipy/special/digamma.py | af54d2a7fd9ec2e5072f91abcaa7fd7cf6a903c3 | [
"LicenseRef-scancode-unknown-license-reference",
"MIT"
] | permissive | dendisuhubdy/cupy | 4e31c646fa697f69abbb07f424910cc8e5f0e595 | b612827e858b8008455a76e8d9b396386c1e4467 | refs/heads/master | 2021-01-23T10:56:45.639699 | 2018-07-12T17:41:26 | 2018-07-12T17:41:26 | 93,111,021 | 0 | 0 | MIT | 2019-12-09T06:55:54 | 2017-06-02T00:31:07 | Python | UTF-8 | Python | false | false | 4,681 | py | # This source code contains SciPy's code.
# https://github.com/scipy/scipy/blob/master/scipy/special/cephes/psi.c
#
#
# Cephes Math Library Release 2.8: June, 2000
# Copyright 1984, 1987, 1992, 2000 by Stephen L. Moshier
#
#
# Code for the rational approximation on [1, 2] is:
#
# (C) Copyright John Maddock 2006.
# Use, modification and distribution are subject to the
# Boost Software License, Version 1.0. (See accompanying file
# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
import cupy
from cupy import core
_digamma_kernel = None
polevl_definition = '''
template<int N> static __device__ double polevl(double x, double coef[])
{
double ans;
double *p;
p = coef;
ans = *p++;
for (int i = 0; i < N; ++i){
ans = ans * x + *p++;
}
return ans;
}
'''
psi_definition = '''
__constant__ double A[] = {
8.33333333333333333333E-2,
-2.10927960927960927961E-2,
7.57575757575757575758E-3,
-4.16666666666666666667E-3,
3.96825396825396825397E-3,
-8.33333333333333333333E-3,
8.33333333333333333333E-2
};
__constant__ double PI = 3.141592653589793;
__constant__ double EULER = 0.5772156649015329;
__constant__ float Y = 0.99558162689208984f;
__constant__ double root1 = 1569415565.0 / 1073741824.0;
__constant__ double root2 = (381566830.0 / 1073741824.0) / 1073741824.0;
__constant__ double root3 = 0.9016312093258695918615325266959189453125e-19;
__constant__ double P[] = {
-0.0020713321167745952,
-0.045251321448739056,
-0.28919126444774784,
-0.65031853770896507,
-0.32555031186804491,
0.25479851061131551
};
__constant__ double Q[] = {
-0.55789841321675513e-6,
0.0021284987017821144,
0.054151797245674225,
0.43593529692665969,
1.4606242909763515,
2.0767117023730469,
1.0
};
static __device__ double digamma_imp_1_2(double x)
{
/*
* Rational approximation on [1, 2] taken from Boost.
*
* Now for the approximation, we use the form:
*
* digamma(x) = (x - root) * (Y + R(x-1))
*
* Where root is the location of the positive root of digamma,
* Y is a constant, and R is optimised for low absolute error
* compared to Y.
*
* Maximum Deviation Found: 1.466e-18
* At double precision, max error found: 2.452e-17
*/
double r, g;
g = x - root1 - root2 - root3;
r = polevl<5>(x - 1.0, P) / polevl<6>(x - 1.0, Q);
return g * Y + g * r;
}
static __device__ double psi_asy(double x)
{
double y, z;
if (x < 1.0e17) {
z = 1.0 / (x * x);
y = z * polevl<6>(z, A);
}
else {
y = 0.0;
}
return log(x) - (0.5 / x) - y;
}
double __device__ psi(double x)
{
double y = 0.0;
double q, r;
int i, n;
if (isnan(x)) {
return x;
}
else if (isinf(x)){
if(x > 0){
return x;
}else{
return nan("");
}
}
else if (x == 0) {
return -1.0/0.0;
}
else if (x < 0.0) {
/* argument reduction before evaluating tan(pi * x) */
r = modf(x, &q);
if (r == 0.0) {
return nan("");
}
y = -PI / tan(PI * r);
x = 1.0 - x;
}
/* check for positive integer up to 10 */
if ((x <= 10.0) && (x == floor(x))) {
n = (int)x;
for (i = 1; i < n; i++) {
y += 1.0 / i;
}
y -= EULER;
return y;
}
/* use the recurrence relation to move x into [1, 2] */
if (x < 1.0) {
y -= 1.0 / x;
x += 1.0;
}
else if (x < 10.0) {
while (x > 2.0) {
x -= 1.0;
y += 1.0 / x;
}
}
if ((1.0 <= x) && (x <= 2.0)) {
y += digamma_imp_1_2(x);
return y;
}
/* x is large, use the asymptotic series */
y += psi_asy(x);
return y;
}
'''
def _get_digamma_kernel():
global _digamma_kernel
if _digamma_kernel is None:
_digamma_kernel = core.ElementwiseKernel(
'T x', 'T y',
"""
y = psi(x)
""",
'digamma_kernel',
preamble=polevl_definition+psi_definition
)
return _digamma_kernel
def digamma(x):
"""The digamma function.
Args:
x (cupy.ndarray): The input of digamma function.
Returns:
cupy.ndarray: Computed value of digamma function.
.. seealso:: :data:`scipy.special.digamma`
"""
if x.dtype.char in '?ebBhH':
x = x.astype(cupy.float32)
elif x.dtype.char in 'iIlLqQ':
x = x.astype(cupy.float64)
y = cupy.zeros_like(x)
_get_digamma_kernel()(x, y)
return y
| [
"yoshikawa@preferred.jp"
] | yoshikawa@preferred.jp |
67488237676831d1edf9d909b0ec985b4bd2e48b | 4959dcaf240badfcde1bb3de484dad7bf6dd88c6 | /Python/fun.py | a3d55d7cbb60a3e1db41d539ec80ba23962f5a89 | [] | no_license | awoltman/Computer_Science | 1025540f5cd087b8e5188e84557b9b276549a8de | 412de1d7519edea2e5ee0759ab3033d6ddfc81f5 | refs/heads/master | 2020-06-17T07:48:21.603061 | 2019-08-12T13:02:18 | 2019-08-12T13:02:18 | 195,849,350 | 0 | 0 | null | 2019-07-17T20:10:16 | 2019-07-08T16:27:34 | C++ | UTF-8 | Python | false | false | 60 | py | #first Hello World
message="This is Bob!"
print(message)
| [
"woltmanap@gmail.com"
] | woltmanap@gmail.com |
e62ac7a0915b7c7f70a113110172c99d24e59e8f | 81638739f723dbca5e662e572a9cef790319a430 | /conductr_cli/test/test_sandbox_logs.py | 56d88dbe3bb0f4c75921fbf7daebfa183a99c4ba | [
"LicenseRef-scancode-unknown-license-reference",
"JSON",
"Apache-2.0"
] | permissive | typesafehub/conductr-cli | 2afe5909720a1bc6eae24dd7677ac66ec2c9822d | 0ed890284228ec8acc894d49a2ea2a598f16e130 | refs/heads/master | 2023-06-19T18:59:16.175762 | 2018-02-07T16:14:56 | 2018-02-07T16:14:56 | 28,919,275 | 14 | 20 | NOASSERTION | 2022-11-04T02:29:09 | 2015-01-07T15:04:13 | Python | UTF-8 | Python | false | false | 1,043 | py | from conductr_cli.test.cli_test_case import CliTestCase
from conductr_cli import sandbox_logs
from unittest.mock import MagicMock
import io
import tempfile
class TestSandboxLogs(CliTestCase):
def test_log_files_is_correct(self):
self.assertEqual(
['/image/dir/core/logs/conductr.log', '/image/dir/agent/logs/conductr-agent.log'],
sandbox_logs.log_files(MagicMock(**{'image_dir': '/image/dir'}))
)
def test_tail_reads_files(self):
one_fd, one_path = tempfile.mkstemp()
two_fd, two_path = tempfile.mkstemp()
one_file = open(one_path, 'w')
two_file = open(two_path, 'w')
output = io.StringIO()
one_file.write("line 1\nline 2\nline 3\n")
one_file.close()
two_file.write("line a\nline b\nline c\n")
two_file.close()
sandbox_logs.tail([one_path, two_path], False, output, 8, 0.25)
self.assertEqual(
"line 1\nline 2\nline 3\nline a\nline b\nline c\n",
output.getvalue()
)
| [
"longshorej@gmail.com"
] | longshorej@gmail.com |
ad7ed55ad4a24f93212d491b8b82e0afff803c67 | 6a389811490cf5c4bbb8bb46cacf37b5992f9f22 | /Villordo_Cristian/001/001.py | dcd18937829e5283fa9ebd6c61418b22424defe1 | [] | no_license | informatorio2020com07/actividades | 40e2ba899e1a9d8ea6ac312ed7a480218ee6b79a | b9b76a5f8bc0a7da17ff378f954b38564f41fa66 | refs/heads/master | 2022-12-20T05:02:21.567549 | 2020-10-06T22:41:03 | 2020-10-06T22:41:03 | 285,361,906 | 2 | 26 | null | 2020-10-06T22:41:31 | 2020-08-05T17:39:32 | Python | UTF-8 | Python | false | false | 327 | py | # 001-
# Programa que pregunte al usuario, el precio del producto y la cantidad de unidades vendidas.
# Informar el total de ventas.
print("PRECIO DE PRODUCTOS")
producto=float(input())
print("CANTIDAD DE UNDIDADES VENDIDAS EN EL MES")
unidades=float(input())
print("el total de las ventas del mes es ", producto*unidades) | [
"cristianndvillordo11@gmail.com"
] | cristianndvillordo11@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.