blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 2
616
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
69
| license_type
stringclasses 2
values | repo_name
stringlengths 5
118
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringlengths 4
63
| visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 2.91k
686M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 23
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 213
values | src_encoding
stringclasses 30
values | language
stringclasses 1
value | is_vendor
bool 2
classes | is_generated
bool 2
classes | length_bytes
int64 2
10.3M
| extension
stringclasses 246
values | content
stringlengths 2
10.3M
| authors
listlengths 1
1
| author_id
stringlengths 0
212
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
53ff9198dfe47a214fb9a2f6bd7b7738da26a9cf
|
dfe78d0296c2f2497d323bc6d0516e3d03f6e5c3
|
/learning_templates/app1/urls.py
|
ec7eefe116f7b638f3fae7bd3beb5c4ebd257c51
|
[] |
no_license
|
tekam47/django-deployement-trial
|
49ac22a6683d0156d694ec67432bdc8fa21e2514
|
c96b4bb8ef7104b6dbab2bd33b4fce65c627925a
|
refs/heads/master
| 2022-11-21T14:47:16.097166
| 2020-07-22T10:54:03
| 2020-07-22T10:54:03
| 281,641,203
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 211
|
py
|
from app1 import views
from django.conf.urls import url
#TEMPLATE TAGGING
app_name = "app1"
urlpatterns = [
url(r'^other',views.other,name="other"),
url(r'^relative',views.relative,name="relative"),
]
|
[
"kounatzepi@gmail.com"
] |
kounatzepi@gmail.com
|
e514273c815a754c9cc94115339b8f0ab6c3c284
|
58e8117c418a8931d56fe57ba0edd38214c79642
|
/ate/context.py
|
ed59e79081a32350eef9099c194c3270b9fc91da
|
[
"MIT"
] |
permissive
|
229051923/ApiTestEngine
|
90b495ee7be037a35f63ffa3b2c95f6ba24f43ce
|
4a529068f451c8880681286518ff6a643ecf9067
|
refs/heads/master
| 2021-01-01T16:09:10.737245
| 2017-07-19T15:29:29
| 2017-07-19T15:29:29
| 97,780,015
| 2
| 0
| null | 2017-07-20T02:09:36
| 2017-07-20T02:09:36
| null |
UTF-8
|
Python
| false
| false
| 7,621
|
py
|
import copy
import importlib
import re
import types
from collections import OrderedDict
from ate import exception, testcase, utils
def is_function(tup):
""" Takes (name, object) tuple, returns True if it is a function.
"""
name, item = tup
return isinstance(item, types.FunctionType)
class Context(object):
""" Manages context functions and variables.
context has two levels, testset and testcase.
"""
def __init__(self):
self.testset_config = {}
self.testset_shared_variables_mapping = dict()
self.testcase_config = {}
self.testcase_variables_mapping = dict()
self.init_context()
def init_context(self, level='testset'):
"""
testset level context initializes when a file is loaded,
testcase level context initializes when each testcase starts.
"""
if level == "testset":
self.testset_config["functions"] = {}
self.testset_config["variables"] = OrderedDict()
self.testset_config["request"] = {}
self.testset_shared_variables_mapping = {}
self.testcase_config["functions"] = {}
self.testcase_config["variables"] = OrderedDict()
self.testcase_config["request"] = {}
self.testcase_variables_mapping = copy.deepcopy(self.testset_shared_variables_mapping)
def import_requires(self, modules):
""" import required modules dynamicly
"""
for module_name in modules:
globals()[module_name] = importlib.import_module(module_name)
def bind_functions(self, function_binds, level="testcase"):
""" Bind named functions within the context
This allows for passing in self-defined functions in testing.
e.g. function_binds:
{
"add_one": lambda x: x + 1, # lambda function
"add_two_nums": "lambda x, y: x + y" # lambda function in string
}
"""
eval_function_binds = {}
for func_name, function in function_binds.items():
if isinstance(function, str):
function = eval(function)
eval_function_binds[func_name] = function
self.__update_context_config(level, "functions", eval_function_binds)
def import_module_functions(self, modules, level="testcase"):
""" import modules and bind all functions within the context
"""
for module_name in modules:
imported = importlib.import_module(module_name)
imported_functions_dict = dict(filter(is_function, vars(imported).items()))
self.__update_context_config(level, "functions", imported_functions_dict)
def register_variables_config(self, variable_binds, level="testcase"):
""" register variable configs
@param (list) variable_binds, variable can be value or custom function
e.g.
[
{"TOKEN": "debugtalk"},
{"random": "${gen_random_string(5)}"},
{"json": {'name': 'user', 'password': '123456'}},
{"md5": "${gen_md5($TOKEN, $json, $random)}"}
]
"""
if level == "testset":
for variable_bind in variable_binds:
self.testset_config["variables"].update(variable_bind)
elif level == "testcase":
self.testcase_config["variables"] = copy.deepcopy(self.testset_config["variables"])
for variable_bind in variable_binds:
self.testcase_config["variables"].update(variable_bind)
def register_request(self, request_dict, level="testcase"):
self.__update_context_config(level, "request", request_dict)
def __update_context_config(self, level, config_type, config_mapping):
"""
@param level: testset or testcase
@param config_type: functions, variables or request
@param config_mapping: functions config mapping or variables config mapping
"""
if level == "testset":
self.testset_config[config_type].update(config_mapping)
elif level == "testcase":
self.testcase_config[config_type].update(config_mapping)
def get_parsed_request(self):
""" get parsed request, with each variable replaced by bind value.
testcase request shall inherit from testset request configs,
but can not change testset configs, that's why we use copy.deepcopy here.
"""
testcase_request_config = utils.deep_update_dict(
copy.deepcopy(self.testset_config["request"]),
self.testcase_config["request"]
)
parsed_request = testcase.parse_template(
testcase_request_config,
self._get_evaluated_testcase_variables()
)
return parsed_request
def bind_extracted_variables(self, variables_mapping):
""" bind extracted variable to current testcase context and testset context.
since extracted variable maybe used in current testcase and next testcases.
"""
self.testset_shared_variables_mapping.update(variables_mapping)
self.testcase_variables_mapping.update(variables_mapping)
def get_testcase_variables_mapping(self):
return self.testcase_variables_mapping
def _get_evaluated_testcase_variables(self):
""" variables in variables_config will be evaluated each time
"""
testcase_functions_config = copy.deepcopy(self.testset_config["functions"])
testcase_functions_config.update(self.testcase_config["functions"])
self.testcase_config["functions"] = testcase_functions_config
testcase_variables_config = copy.deepcopy(self.testset_config["variables"])
testcase_variables_config.update(self.testcase_config["variables"])
self.testcase_config["variables"] = testcase_variables_config
for var_name, var_value in self.testcase_config["variables"].items():
self.testcase_variables_mapping[var_name] = self.get_eval_value(var_value)
return self.testcase_variables_mapping
def get_eval_value(self, data):
""" evaluate data recursively, each variable in data will be evaluated.
"""
if isinstance(data, (list, tuple)):
return [self.get_eval_value(item) for item in data]
if isinstance(data, dict):
evaluated_data = {}
for key, value in data.items():
evaluated_data[key] = self.get_eval_value(value)
return evaluated_data
if isinstance(data, (int, float)):
return data
# data is in string format here
data = "" if data is None else data.strip()
if utils.is_variable(data):
# variable marker: $var
variable_name = utils.parse_variable(data)
value = self.testcase_variables_mapping.get(variable_name)
if value is None:
raise exception.ParamsError(
"%s is not defined in bind variables!" % variable_name)
return value
elif utils.is_functon(data):
# function marker: ${func(1, 2, a=3, b=4)}
fuction_meta = utils.parse_function(data)
func_name = fuction_meta['func_name']
args = fuction_meta.get('args', [])
kwargs = fuction_meta.get('kwargs', {})
args = self.get_eval_value(args)
kwargs = self.get_eval_value(kwargs)
return self.testcase_config["functions"][func_name](*args, **kwargs)
else:
return data
|
[
"mail@debugtalk.com"
] |
mail@debugtalk.com
|
2272af86ec47659657698bd4b83b445ace287269
|
4b4ff2c0d135d3615caaeb80735c2ad6ee987914
|
/venv/bin/pip
|
f5f3cb0efa2f979b5fd036420c2b2dc08b10a062
|
[] |
no_license
|
Nicolas-Turck/Tuto-deployement-heroku
|
23060837b47f195d9af2eb280a85836d1a8f8efd
|
54d104054c06070420ae36b6bbb45089492da286
|
refs/heads/master
| 2023-08-01T07:18:13.563988
| 2021-05-20T16:07:56
| 2021-05-20T16:07:56
| 257,563,781
| 0
| 0
| null | 2021-09-22T18:54:33
| 2020-04-21T10:46:23
|
Python
|
UTF-8
|
Python
| false
| false
| 263
|
#!/home/nicos/PycharmProjects/Tuto-heroku/venv/bin/python
# -*- coding: utf-8 -*-
import re
import sys
from pip._internal.cli.main import main
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(main())
|
[
"nicolas.turck@gmail.com"
] |
nicolas.turck@gmail.com
|
|
a1df8914c35f5e949416165a0782c85926e4e9f7
|
2cf9f165cb4d6e8e9009d74b43020fe2d5c1964f
|
/chat/migrations/0001_initial.py
|
a2db3bb2cfb40b358f72ef4113b611bc648018b0
|
[] |
no_license
|
jimy1824/chat
|
29f5039c6284083b8328502932795bee586dec14
|
627ad4678c6215d37322737b38b3e5eb6d69696f
|
refs/heads/master
| 2023-04-27T15:10:51.316824
| 2019-11-08T05:00:12
| 2019-11-08T05:00:12
| 220,081,959
| 1
| 0
| null | 2023-04-21T20:40:47
| 2019-11-06T20:17:20
|
HTML
|
UTF-8
|
Python
| false
| false
| 1,194
|
py
|
# Generated by Django 2.2.6 on 2019-11-06 19:01
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Chat',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('is_active', models.BooleanField(default=True)),
('created_at', models.DateTimeField(auto_now_add=True)),
('updated_at', models.DateTimeField(auto_now=True)),
('message', models.TextField()),
('receiver', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='message_receiver', to=settings.AUTH_USER_MODEL)),
('sender', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='message_sender', to=settings.AUTH_USER_MODEL)),
],
options={
'abstract': False,
},
),
]
|
[
"jamshaid1824@gmail.com"
] |
jamshaid1824@gmail.com
|
4357f72ea71e855c96174c243f3d51a84d1b6c8e
|
57a8986e7622e471f392ffefa1e1d959c6a1bb7c
|
/mazeSolver.py
|
1e522304e60f9ee925eee57e47874b7821dff42c
|
[] |
no_license
|
pandyakaa/MazeProblem
|
394b5f99eef5ee61e0f4f206c29cc393ced2fa64
|
8ca7d6b5dd96697632326322ff1e3272d9d6fbea
|
refs/heads/master
| 2020-05-01T16:38:48.006105
| 2019-03-29T06:45:58
| 2019-03-29T06:45:58
| 177,577,738
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 6,601
|
py
|
import sys
from collections import deque
from point import Point
from priorityQueue import PriorityQueue
# Fungsi inputMaze, dengan parameter sebuah file
# digunakan untuk memasukkan matriks sebagai representasi dari maze
# dari file eksternal dengan nama filename
# Sekaligus mencari titik awal masuk dan keluar, disimpan dalam startb, startk, finishb dan finishk
def inputMaze(filename) :
arr = []
f = open("{}.txt".format(filename),"r")
for line in f :
arr.append([int(c) for c in line.strip()])
baris = len(arr)
kolom = len(arr[0])
f.close()
startb = -1
startk = -1
finishb = -1
finishk = -1
# Melakukan pencarian titik mulai dan akhir (case : kiri dan kanan)
for i in range(baris) :
if (arr[i][0] == 0) :
startb = i
startk = 0
if (arr[i][kolom-1] == 0) :
finishb = i
finishk = kolom-1
# Melakukan pencarian titik mulai dan akhir (case : atas dan bawah)
for i in range(kolom) :
if (arr[0][i] == 0) :
startb = 0
startk = i
if (arr[baris-1][i] == 0) :
finishb = baris-1
finishk = i
# Melakukan validasi apakah matriks bisa dimainkan atau tidak
if ( startb != -1 and startk != -1 and finishb != -1 and finishk != -1 ) :
valid = True
else :
valid = False
return arr,startb,startk,finishb,finishk,valid
# Fungsi printSolution, dengan parameter sebuah matriks m
# digunakan untuk melakukan output sebuah maze yang sudah ada solved
def printSolution(m) :
for i in m :
for j in i :
if (j == 1 ) :
print("# ",end = '')
elif (j == 3 or j == 2) :
print(" ",end = '')
elif ( j == 4 ) :
print("X ", end = '')
else :
print(" ", end = '')
print()
# Fungsi copy, dengan parameter sebuah matriks m1
# digunakan untuk melakukan DEEP COPY pada sebuah matriks
# sehingga tidak perlu membaca dari file eksternal lagi
def copy(m1) :
m2 = []
for i in range(len(m1)) :
temp = []
for j in range(len(m1[0])) :
temp.append(m1[i][j])
m2.append(temp)
return m2
# Fungsi isFeasible, dengan parameter sebuah matriks m, int x dan int y
# digunakan untuk melakukan validasi, apakah koordinat (x,y) valid atau tidak
# DEFINISI VALID : Lebih atau sama dengan 0 , dan kurang dari panjang atau kolom matriks
def isFeasible(m,x,y) :
if ( m[x][y]==0 and x >= 0 and x < len(m) and y >= 0 and y < len(m[0]) ) :
return True
return False
# Fungsi BFS, dengan parameter maze maze, int x, int y, dan point fp
# merupakan salah satu dari dua fungsi utama dalam program ini
# Memanfaatkan sebuah type data DEQUE, dan melakukan proses Breadth-First Searching
# Jika memiliki solusi, akan me-return sebuah point p
def BFS(maze,x,y,fp) :
de = deque()
de.append(Point(x,y,None))
while ( not(len(de) == 0) ) :
p = de.popleft()
maze[p.x][p.y] = 3
if (p.isEqual(fp)) :
return p
if(isFeasible(maze,p.x-1,p.y)) :
nextP = Point(p.x-1,p.y,p)
de.append(nextP)
if (isFeasible(maze,p.x+1,p.y)) :
nextP = Point(p.x+1,p.y,p)
de.append(nextP)
if(isFeasible(maze,p.x,p.y+1)) :
nextP = Point(p.x,p.y+1,p)
de.append(nextP)
if(isFeasible(maze,p.x,p.y-1)) :
nextP = Point(p.x,p.y-1,p)
de.append(nextP)
# Fungsi manhattanDist, dengan parameter point point_start dan point point_finish
# digunakan untuk mencari nilai h(n) pada algoritma A*
# Menggunakan manhattan distance karena hanya bisa bergerak ke empat arah
def manhattanDist(point_start,point_finish) :
return (abs(point_start.x - point_finish.x) + abs(point_start.y - point_finish.y))
# Fungsi AStar, dengan parameter maze maze, int x, int y, dan point fpoint
# merupakan salah satu dari dua fungsi utama dalam program ini
# Memanfaatkan type data Priority Queue, yang telah dibuat kelas sendiri sebelumnya
# Akan melakukan pencarian dengan algoritma AStar dengan :
# f(n) = g(n) + h(n)
# dengan g(n) adalah jarak sebenarnya sebuah titik ke titik akhir
# dan h(n) adalah jarak heuristik dari sebuah titik ke titik akhir dengan memanfaatkan manhattanDist
def AStar(maze,x,y,fpoint) :
startPoint = Point(x,y,None)
startPoint.f = startPoint.g = startPoint.h = 0
openList = PriorityQueue()
openList.insert(startPoint)
while ( not(openList.isEmpty()) ) :
current_node = openList.delete()
maze[current_node.x][current_node.y] = 3
if (current_node.isEqual(fpoint) ) :
return current_node
children = []
for pos in [(0, -1), (0, 1), (-1, 0), (1, 0)]:
curr_x = current_node.x + pos[0]
curr_y = current_node.y + pos[1]
if (not(isFeasible(maze,curr_x,curr_y))) :
continue
child = Point(curr_x,curr_y,current_node)
children.append(child)
for child in children :
child.g = current_node.g + 1
child.h = manhattanDist(child,fpoint)
child.f = child.g + child.h
openList.insert(child)
# Fungsi main, akan dipanggil saat program ini dijalankan
if __name__ == "__main__":
# Melakukan input nama file dari pengguna, dan memanggil fungsi inputMaze untuk
# memasukkannya ke dalam maze
file = input("Masukkan nama file : ")
maze, start_baris , start_kolom, finish_baris , finish_kolom , valid = inputMaze(file)
maze2 = copy(maze)
# Util yang diperlukan oleh fungsi-fungsi searching
fp = Point(finish_baris,finish_kolom,None)
if ( valid ) :
# Melakukan pemanggilan fungsi-fungsi Searching
p = BFS(maze,start_baris,start_kolom,fp)
q = AStar(maze2,start_baris,start_kolom,fp)
# Melakukan output dari algoritma DFS
maze[start_baris][start_kolom] = 4
while (p.getParent() != None ) :
maze[p.x][p.y] = 4
p = p.getParent()
print("\n \t \t Solution with BFS : \n")
printSolution(maze)
# Melakukan output dari algoritma A*
maze2[start_baris][start_kolom] = 4
while (q.getParent() != None ) :
maze2[q.x][q.y] = 4
q = q.getParent()
print("\n \t \t Solution with A-Star : \n")
printSolution(maze2)
else :
print("NOT FOUND")
|
[
"pandyaka.aptanagi@gmail.com"
] |
pandyaka.aptanagi@gmail.com
|
1b13c4cc42e2710f2aa2c196f9030cf2e7b9ae1d
|
7a2573f5539fe6de33fe4e355fde5df366cedb1f
|
/pl3.py
|
11eb70e73311b185b4cecea5fcc5e87fa406b57f
|
[] |
no_license
|
anujasubbarao/anuja
|
508c2d5e777d854cdc1387560590f7c345f25134
|
c840cdcf99986f3e2d842ee24045178e72da6e9c
|
refs/heads/master
| 2021-07-06T01:52:17.420722
| 2019-03-06T14:26:53
| 2019-03-06T14:26:53
| 142,555,136
| 0
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 101
|
py
|
n=int(raw_input())
rev=0
while n>0:
rem=n%10
rev=(rev*10)+rem
n=n//10
print rev
|
[
"noreply@github.com"
] |
anujasubbarao.noreply@github.com
|
554c7aabf1e3a0c07792dec86ac77d8c958f7099
|
37faa935d3af283be72423821a25d17172f2df6a
|
/projects/analysing_baseball_data/isp_baseball_template.py
|
b091cf8da7961c40e7fd65bcc195823b729a3dae
|
[] |
no_license
|
rogeriolaguilar/python
|
2b214fccbb32ca269c745b26fbc082cb20981c23
|
fef86ca360e5a47fcd86f9ab99c04c58d353705b
|
refs/heads/master
| 2020-03-19T11:00:51.367723
| 2018-09-16T12:56:39
| 2018-09-16T12:56:39
| 136,421,396
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 11,560
|
py
|
"""
Project for Week 4 of "Python Data Analysis".
Processing CSV files with baseball stastics.
Be sure to read the project description page for further information
about the expected behavior of the program.
"""
import csv
##
## Provided code from Week 3 Project
##
def read_csv_as_list_dict(filename, separator, quote):
"""
Inputs:
filename - name of CSV file
separator - character that separates fields
quote - character used to optionally quote fields
Output:
Returns a list of dictionaries where each item in the list
corresponds to a row in the CSV file. The dictionaries in the
list map the field names to the field values for that row.
"""
table = []
with open(filename, newline='') as csvfile:
csvreader = csv.DictReader(csvfile, delimiter=separator, quotechar=quote)
for row in csvreader:
table.append(row)
return table
def read_csv_as_nested_dict(filename, keyfield, separator, quote):
"""
Inputs:
filename - name of CSV file
keyfield - field to use as key for rows
separator - character that separates fields
quote - character used to optionally quote fields
Output:
Returns a dictionary of dictionaries where the outer dictionary
maps the value in the key_field to the corresponding row in the
CSV file. The inner dictionaries map the field names to the
field values for that row.
"""
table = {}
with open(filename, newline='') as csvfile:
csvreader = csv.DictReader(csvfile, delimiter=separator, quotechar=quote)
for row in csvreader:
rowid = row[keyfield]
table[rowid] = row
return table
##
## Provided formulas for common batting statistics
##
# Typical cutoff used for official statistics
MINIMUM_AB = 500
def batting_average(info, batting_stats):
"""
Inputs:
batting_stats - dictionary of batting statistics (values are strings)
Output:
Returns the batting average as a float
"""
hits = float(batting_stats[info["hits"]])
at_bats = float(batting_stats[info["atbats"]])
if at_bats >= MINIMUM_AB:
return hits / at_bats
else:
return 0
def onbase_percentage(info, batting_stats):
"""
Inputs:
batting_stats - dictionary of batting statistics (values are strings)
Output:
Returns the on-base percentage as a float
"""
hits = float(batting_stats[info["hits"]])
at_bats = float(batting_stats[info["atbats"]])
walks = float(batting_stats[info["walks"]])
if at_bats >= MINIMUM_AB:
return (hits + walks) / (at_bats + walks)
else:
return 0
def slugging_percentage(info, batting_stats):
"""
Inputs:
batting_stats - dictionary of batting statistics (values are strings)
Output:
Returns the slugging percentage as a float
"""
hits = float(batting_stats[info["hits"]])
doubles = float(batting_stats[info["doubles"]])
triples = float(batting_stats[info["triples"]])
home_runs = float(batting_stats[info["homeruns"]])
singles = hits - doubles - triples - home_runs
at_bats = float(batting_stats[info["atbats"]])
if at_bats >= MINIMUM_AB:
return (singles + 2 * doubles + 3 * triples + 4 * home_runs) / at_bats
else:
return 0
##
## Part 1: Functions to compute top batting statistics by year
##
def filter_by_year(statistics, year, yearid):
"""
Inputs:
statistics - List of batting statistics dictionaries
year - Year to filter by
yearid - Year ID field in statistics
Outputs:
Returns a list of batting statistics dictionaries that
are from the input year.
"""
return list(filter(lambda x: (x[yearid] == str(year)), statistics))
def top_player_ids(info, statistics, formula, numplayers):
"""
Inputs:
info - Baseball data information dictionary
statistics - List of batting statistics dictionaries
formula - function that takes an info dictionary and a
batting statistics dictionary as input and
computes a compound statistic
numplayers - Number of top players to return
Outputs:
Returns a list of tuples, player ID and compound statistic
computed by formula, of the top numplayers players sorted in
decreasing order of the computed statistic.
"""
table = []
for dic in statistics:
table.append((dic[info['playerid']], formula(info, dic)))
table = sorted(table, key=lambda x: x[1], reverse=True)
return table[0:numplayers]
def lookup_player_names(info, top_ids_and_stats):
"""
Inputs:
info - Baseball data information dictionary
top_ids_and_stats - list of tuples containing player IDs and
computed statistics
Outputs:
List of strings of the form "x.xxx --- FirstName LastName",
where "x.xxx" is a string conversion of the float stat in
the input and "FirstName LastName" is the name of the player
corresponding to the player ID in the input.
"""
stats = read_csv_as_list_dict(info['masterfile'], info['separator'], info['quote'])
template = '{0:.3f} --- {1} {2}'
table = []
for top in top_ids_and_stats:
for dit in stats:
if dit[info['playerid']] == top[0]:
table.append(template.format(top[1], dit[info['firstname']], dit[info['lastname']]))
return table
def compute_top_stats_year(info, formula, numplayers, year):
"""
Inputs:
info - Baseball data information dictionary
formula - function that takes an info dictionary and a
batting statistics dictionary as input and
computes a compound statistic
numplayers - Number of top players to return
year - Year to filter by
Outputs:
Returns a list of strings for the top numplayers in the given year
according to the given formula.
"""
b_stat = read_csv_as_list_dict(info['battingfile'], info['separator'], info['quote'])
sep_year = filter_by_year(b_stat, year, info['yearid'])
top_player = top_player_ids(info, sep_year, formula, numplayers)
player_name = lookup_player_names(info, top_player)
return player_name
##
## Part 2: Functions to compute top batting statistics by career
##
def aggregate_by_player_id(statistics, playerid, fields):
"""
Inputs:
statistics - List of batting statistics dictionaries
playerid - Player ID field name
fields - List of fields to aggregate
Output:
Returns a nested dictionary whose keys are player IDs and whose values
are dictionaries of aggregated stats. Only the fields from the fields
input will be aggregated in the aggregated stats dictionaries.
"""
dictt = {}
for stat in statistics:
dictt[stat[playerid]] = {}
for field in fields:
dictt[stat[playerid]][field] = 0
dictt[stat[playerid]][playerid] = stat[playerid]
for key, _val in dictt.items():
for dit in statistics:
if key == dit[playerid]:
for stat in fields:
dictt[key][stat] += int(dit[stat])
return dictt
def compute_top_stats_career(info, formula, numplayers):
"""
Inputs:
info - Baseball data information dictionary
formula - function that takes an info dictionary and a
batting statistics dictionary as input and
computes a compound statistic
numplayers - Number of top players to return
"""
bat_stat = read_csv_as_list_dict(info['battingfile'], info['separator'], info['quote'])
fieldnames = info['battingfields']
indiv_player_stat = aggregate_by_player_id(bat_stat, info['playerid'], fieldnames)
player_name = [k for k, v in indiv_player_stat.items()]
compounded_stat = []
for player in player_name:
compounded_stat.append((player, formula(info, indiv_player_stat[player])))
compounded_stat = sorted(compounded_stat, key=lambda x: x[1], reverse=True)
return lookup_player_names(info, compounded_stat[0:numplayers])
##
## Provided testing code
##
def test_baseball_statistics():
"""
Simple testing code.
"""
#
# Dictionary containing information needed to access baseball statistics
# This information is all tied to the format and contents of the CSV files
#
baseballdatainfo = {"masterfile": "Master_2016.csv", # Name of Master CSV file
"battingfile": "Batting_2016.csv", # Name of Batting CSV file
"separator": ",", # Separator character in CSV files
"quote": '"', # Quote character in CSV files
"playerid": "playerID", # Player ID field name
"firstname": "nameFirst", # First name field name
"lastname": "nameLast", # Last name field name
"yearid": "yearID", # Year field name
"atbats": "AB", # At bats field name
"hits": "H", # Hits field name
"doubles": "2B", # Doubles field name
"triples": "3B", # Triples field name
"homeruns": "HR", # Home runs field name
"walks": "BB", # Walks field name
"battingfields": ["AB", "H", "2B", "3B", "HR", "BB"]}
print("Top 5 batting averages in 1923")
top_batting_average_1923 = compute_top_stats_year(baseballdatainfo, batting_average, 5, 1923)
for player in top_batting_average_1923:
print(player)
print("")
print("Top 10 batting averages in 2010")
top_batting_average_2010 = compute_top_stats_year(baseballdatainfo, batting_average, 10, 2010)
for player in top_batting_average_2010:
print(player)
print("")
print("Top 10 on-base percentage in 2010")
top_onbase_2010 = compute_top_stats_year(baseballdatainfo, onbase_percentage, 10, 2010)
for player in top_onbase_2010:
print(player)
print("")
print("Top 10 slugging percentage in 2010")
top_slugging_2010 = compute_top_stats_year(baseballdatainfo, slugging_percentage, 10, 2010)
for player in top_slugging_2010:
print(player)
print("")
# You can also use lambdas for the formula
# This one computes onbase plus slugging percentage
print("Top 10 OPS in 2010")
top_ops_2010 = compute_top_stats_year(baseballdatainfo,
lambda info, stats: (onbase_percentage(info, stats) +
slugging_percentage(info, stats)),
10, 2010)
for player in top_ops_2010:
print(player)
print("")
print("Top 20 career batting averages")
top_batting_average_career = compute_top_stats_career(baseballdatainfo, batting_average, 20)
for player in top_batting_average_career:
print(player)
print("")
# Make sure the following call to test_baseball_statistics is
# commented out when submitting to OwlTest/CourseraTest.
#test_baseball_statistics()
|
[
"rogerio.l.aguilar@gmail.com"
] |
rogerio.l.aguilar@gmail.com
|
a6db9d0ebe8e9a8f0ab0a1cacff578441a2234ba
|
4fcfc6834f598954e069e9481e4f69d6f7205f3b
|
/Week1/day_3/Flask_Intro/first_flask_app/server.py
|
a7693151c6981a66648352d4cf8857f87de47de7
|
[] |
no_license
|
sadieBoBadie/jan_2020_python_stack
|
dadc77a8a76fd4b900bc31ad83ed4680a0802aa1
|
b91da3da23ea57a27c086075f4b86c5bfec413d0
|
refs/heads/main
| 2023-03-02T22:27:46.877290
| 2021-01-26T19:04:57
| 2021-01-26T19:04:57
| 326,852,429
| 0
| 3
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 543
|
py
|
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def puppies():
return "<h1 style='color: red'>Puppies are cute!</h1>"
@app.route('/<animal>/<color>')
@app.route('/<animal>')
@app.route('/<animal>/<color>/<int:num>')
def display_animal(animal, color="blue", num=5):
print(f"Animal: {animal}")
print(f"Color: {color}")
print("Type of the num var: ", type(num))
return render_template('index.html', animal=animal, color=color, num=num)
if __name__=="__main__":
app.run(debug=True)
|
[
"sflick@codingdojo.com"
] |
sflick@codingdojo.com
|
25724b55aa4d29b7d7541545d4b7a257d6a3af48
|
a2accf55b7b57a376344689e1f8fa4d64acdd6be
|
/salaray_to_csv.py
|
692da5634ca9d92a5b99a5746186df6cf7f8d942
|
[] |
no_license
|
Thybat/EulerProject
|
8e590455f2fbebceeec031e667ac77a97fd5d35c
|
54ee77fac34de4c13b33bf5459f6b6258d6cca1f
|
refs/heads/main
| 2022-12-27T23:19:25.058389
| 2020-10-09T09:57:54
| 2020-10-09T09:57:54
| 302,599,892
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 495
|
py
|
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import preprocessing
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
df = pd.read_csv("data_reg_age_salary.csv")
x = df.values #returns a numpy array
min_max_scaler = preprocessing.MinMaxScaler()
pd.DataFrame(min_max_scaler.fit_transform(df.T), columns=df.columns, index=df.index)
df = pd.DataFrame(x_scaled)
df.to_csv("data_reg_age_salary.csv", index=False)
|
[
"noreply@github.com"
] |
Thybat.noreply@github.com
|
3b930951163c7e85c90c1df23c7a762af58fc623
|
55c250525bd7198ac905b1f2f86d16a44f73e03a
|
/Python/Projects/pyinstaller/tests/unit/test_modulegraph/testpkg-relimport/pkg/relimport.py
|
0e76e39fedf777016e011f2daa0a233827236b57
|
[
"LicenseRef-scancode-other-permissive"
] |
permissive
|
NateWeiler/Resources
|
213d18ba86f7cc9d845741b8571b9e2c2c6be916
|
bd4a8a82a3e83a381c97d19e5df42cbababfc66c
|
refs/heads/master
| 2023-09-03T17:50:31.937137
| 2023-08-28T23:50:57
| 2023-08-28T23:50:57
| 267,368,545
| 2
| 1
| null | 2022-09-08T15:20:18
| 2020-05-27T16:18:17
| null |
UTF-8
|
Python
| false
| false
| 127
|
py
|
version https://git-lfs.github.com/spec/v1
oid sha256:b1c982ab98ef0425093ad8bafe4c9deb7aad009260b384b762696e8fc4c0e375
size 22
|
[
"nateweiler84@gmail.com"
] |
nateweiler84@gmail.com
|
0843c71fc383feb3fad8512aa89bc2e6a0434ce9
|
760b47b46574552c5371270036b391a6a3b7dc2f
|
/src/loggedfs/_core/fs.py
|
ced81b475209403f3dcd7fbc2e7e3a9c1a7796b4
|
[
"Apache-2.0"
] |
permissive
|
pleiszenburg/loggedfs-python
|
7ae2ba90780f700b3ec5153b8b7447452bf643c7
|
1c0740f6f38e7795d6f834d08d9bab59d911b454
|
refs/heads/master
| 2023-04-06T05:00:50.457663
| 2020-07-11T08:33:41
| 2020-07-11T08:33:41
| 113,670,055
| 31
| 3
|
Apache-2.0
| 2023-03-31T02:14:20
| 2017-12-09T13:07:44
|
Python
|
UTF-8
|
Python
| false
| false
| 14,726
|
py
|
# -*- coding: utf-8 -*-
"""
LoggedFS-python
Filesystem monitoring with Fuse and Python
https://github.com/pleiszenburg/loggedfs-python
src/loggedfs/_core/fs.py: File system core
Copyright (C) 2017-2020 Sebastian M. Ernst <ernst@pleiszenburg.de>
<LICENSE_BLOCK>
The contents of this file are subject to the Apache License
Version 2 ("License"). You may not use this file except in
compliance with the License. You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
https://github.com/pleiszenburg/loggedfs-python/blob/master/LICENSE
Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the
specific language governing rights and limitations under the License.
</LICENSE_BLOCK>
"""
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# IMPORT
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
import errno
import os
import stat
from refuse.high import (
FUSE,
fuse_get_context,
FuseOSError,
Operations
)
from .defaults import (
FUSE_ALLOWOTHER_DEFAULT,
FUSE_FOREGROUND_DEFAULT,
LIB_MODE_DEFAULT,
LOG_BUFFERS_DEFAULT,
LOG_ENABLED_DEFAULT,
LOG_JSON_DEFAULT,
LOG_ONLYMODIFYOPERATIONS_DEFAULT,
LOG_PRINTPROCESSNAME_DEFAULT,
LOG_SYSLOG_DEFAULT
)
from .filter import filter_pipeline_class
from .log import get_logger, log_msg
from .out import event
from .timing import time
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# ROUTINES
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
def loggedfs_factory(directory, **kwargs):
if not isinstance(directory, str):
raise TypeError('directory must be of type string')
if not os.path.isdir(directory):
raise ValueError('directory must be a path to an existing directory')
if not isinstance(kwargs.get('fuse_foreground', FUSE_FOREGROUND_DEFAULT), bool):
raise TypeError('fuse_foreground must be of type bool')
if not isinstance(kwargs.get('fuse_allowother', FUSE_ALLOWOTHER_DEFAULT), bool):
raise TypeError('fuse_allowother must be of type bool')
return FUSE(
_loggedfs(
directory,
**kwargs
),
directory,
raw_fi = True,
nothreads = True,
foreground = kwargs.get('fuse_foreground', FUSE_FOREGROUND_DEFAULT),
allow_other = kwargs.get('fuse_allowother', FUSE_ALLOWOTHER_DEFAULT),
default_permissions = kwargs.get('fuse_allowother', FUSE_ALLOWOTHER_DEFAULT),
attr_timeout = 0,
entry_timeout = 0,
negative_timeout = 0,
sync_read = False, # relying on fuse.Operations class defaults?
# max_readahead = 0, # relying on fuse.Operations class defaults?
# direct_io = True, # relying on fuse.Operations class defaults?
nonempty = True, # common options taken from LoggedFS
use_ino = True # common options taken from LoggedFS
)
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# CORE CLASS: Init and internal routines
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class _loggedfs(Operations):
flag_utime_omit_ok = 1
use_ns = True
_ST_FIELDS = tuple(i for i in dir(os.stat_result) if i.startswith('st_'))
_STVFS_FIELDS = tuple(i for i in dir(os.statvfs_result) if i.startswith('f_'))
def __init__(self,
directory,
fuse_foreground = FUSE_FOREGROUND_DEFAULT,
fuse_allowother = FUSE_ALLOWOTHER_DEFAULT,
lib_mode = LIB_MODE_DEFAULT,
log_buffers = LOG_BUFFERS_DEFAULT,
log_enabled = LOG_ENABLED_DEFAULT,
log_file = None,
log_filter = None,
log_json = LOG_JSON_DEFAULT,
log_only_modify_operations = LOG_ONLYMODIFYOPERATIONS_DEFAULT,
log_printprocessname = LOG_PRINTPROCESSNAME_DEFAULT,
log_syslog = LOG_SYSLOG_DEFAULT,
**kwargs
):
if log_filter is None:
log_filter = filter_pipeline_class()
if not isinstance(directory, str):
raise TypeError('directory must be of type string')
if not os.path.isdir(directory):
raise ValueError('directory must be a path to an existing directory')
if not os.access(directory, os.W_OK | os.R_OK):
raise ValueError('not sufficient permissions on "directory"')
if not isinstance(log_filter, filter_pipeline_class):
raise TypeError('log_filter must either be None or of type filter_pipeline_class')
if log_file is not None:
if not os.path.isdir(os.path.dirname(log_file)):
raise ValueError('path to logfile directory does not exist')
if os.path.exists(log_file) and not os.path.isfile(log_file):
raise ValueError('logfile exists and is not a file')
if os.path.isfile(log_file) and not os.access(log_file, os.W_OK):
raise ValueError('logfile exists and is not writeable')
if not os.path.exists(log_file) and not os.access(directory, os.W_OK):
raise ValueError('path to logfile directory is not writeable')
if not isinstance(log_syslog, bool):
raise TypeError('log_syslog must be of type bool')
if not isinstance(log_enabled, bool):
raise TypeError('log_enabled must be of type bool')
if not isinstance(log_printprocessname, bool):
raise TypeError('log_printprocessname must be of type bool')
if not isinstance(log_json, bool):
raise TypeError('log_json must be of type bool')
if not isinstance(log_buffers, bool):
raise TypeError('log_buffers must be of type bool')
if not isinstance(lib_mode, bool):
raise TypeError('lib_mode must be of type bool')
if not isinstance(log_only_modify_operations, bool):
raise TypeError('log_only_modify_operations must be of type bool')
if not isinstance(fuse_foreground, bool):
raise TypeError('fuse_foreground must be of type bool')
if not isinstance(fuse_allowother, bool):
raise TypeError('fuse_allowother must be of type bool')
self._root_path = directory
self._log_printprocessname = log_printprocessname
self._log_json = log_json
self._log_buffers = log_buffers
self._log_filter = log_filter
self._lib_mode = lib_mode
self._log_only_modify_operations = log_only_modify_operations
self._logger = get_logger('LoggedFS-python', log_enabled, log_file, log_syslog, self._log_json)
if fuse_foreground:
self._logger.info(log_msg(self._log_json, 'LoggedFS-python not running as a daemon'))
if fuse_allowother:
self._logger.info(log_msg(self._log_json, 'LoggedFS-python running as a public filesystem'))
if log_file is not None:
self._logger.info(log_msg(self._log_json, 'LoggedFS-python log file: %s' % log_file))
self._logger.info(log_msg(self._log_json, 'LoggedFS-python starting at %s' % directory))
try:
self._root_path_fd = os.open(directory, os.O_RDONLY)
except Exception as e:
self._logger.exception('Directory access failed.')
raise e
log_configfile = kwargs.pop('_log_configfile', None)
if log_configfile is not None:
self._logger.info(log_msg(self._log_json,
'LoggedFS-python using configuration file %s' % log_configfile
))
if len(kwargs) > 0:
raise ValueError('unknown keyword argument(s)')
def _full_path(self, partial_path):
if partial_path.startswith('/'):
partial_path = partial_path[1:]
path = os.path.join(self._root_path, partial_path)
return path
@staticmethod
def _rel_path(partial_path):
if len(partial_path) == 0:
return '.'
elif partial_path == '/':
return '.'
elif partial_path.startswith('/'):
return partial_path[1:]
elif partial_path.startswith('./'):
return partial_path[2:]
else:
return partial_path
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# CORE CLASS: Filesystem & file methods - STUBS
# ... addressing https://github.com/fusepy/fusepy/issues/81
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
def create(self, path, mode, fi = None):
raise FuseOSError(errno.ENOSYS)
def flush(self, path, fip):
raise FuseOSError(errno.ENOSYS)
def fsync(self, path, datasync, fip):
raise FuseOSError(errno.ENOSYS) # the original loggedfs just returns 0
def ioctl(self, path, cmd, arg, fh, flags, data):
raise FuseOSError(errno.ENOSYS)
def lock(self, path, fh, cmd, lock):
raise FuseOSError(errno.ENOSYS)
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# CORE CLASS: Filesystem & file methods - IMPLEMENTATION
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@event(format_pattern = '{param_path}')
def access(self, path, mode):
if not os.access(self._rel_path(path), mode, dir_fd = self._root_path_fd):
raise FuseOSError(errno.EACCES)
@event(format_pattern = '{param_path} to {param_mode}')
def chmod(self, path, mode):
os.chmod(self._rel_path(path), mode, dir_fd = self._root_path_fd)
@event(format_pattern = '{param_path} to {param_uid_name}({param_uid}):{param_gid_name}({param_gid})')
def chown(self, path, uid, gid):
os.chown(self._rel_path(path), uid, gid, dir_fd = self._root_path_fd, follow_symlinks = False)
@event(format_pattern = '{param_path}')
def destroy(self, path):
os.close(self._root_path_fd)
@event(format_pattern = '{param_path} (fh={param_fip})')
def getattr(self, path, fip):
if not fip:
try:
st = os.lstat(self._rel_path(path), dir_fd = self._root_path_fd)
except FileNotFoundError:
raise FuseOSError(errno.ENOENT)
else:
st = os.fstat(fip.fh)
ret_dict = {key: getattr(st, key) for key in self._ST_FIELDS}
for key in ['st_atime', 'st_ctime', 'st_mtime']:
ret_dict[key] = ret_dict.pop(key + '_ns')
return ret_dict
@event(format_pattern = '{param_path}')
def init(self, path):
pass
@event(format_pattern = '{param_source_path} to {param_target_path}')
def link(self, target_path, source_path):
target_rel_path = self._rel_path(target_path)
os.link(
self._rel_path(source_path), target_rel_path,
src_dir_fd = self._root_path_fd, dst_dir_fd = self._root_path_fd
)
uid, gid, pid = fuse_get_context()
os.chown(target_rel_path, uid, gid, dir_fd = self._root_path_fd, follow_symlinks = False)
@event(format_pattern = '{param_path} {param_mode}')
def mkdir(self, path, mode):
rel_path = self._rel_path(path)
os.mkdir(rel_path, mode, dir_fd = self._root_path_fd)
uid, gid, pid = fuse_get_context()
os.chown(rel_path, uid, gid, dir_fd = self._root_path_fd, follow_symlinks = False)
os.chmod(rel_path, mode, dir_fd = self._root_path_fd) # follow_symlinks = False
@event(format_pattern = '{param_path} {param_mode}')
def mknod(self, path, mode, dev):
rel_path = self._rel_path(path)
if stat.S_ISREG(mode):
res = os.open(
rel_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY, mode,
dir_fd = self._root_path_fd
) # TODO broken, applies umask to mode no matter what ...
if res >= 0:
os.close(res)
elif stat.S_ISFIFO(mode):
os.mkfifo(rel_path, mode, dir_fd = self._root_path_fd)
else:
os.mknod(rel_path, mode, dev, dir_fd = self._root_path_fd)
uid, gid, pid = fuse_get_context()
os.chown(rel_path, uid, gid, dir_fd = self._root_path_fd, follow_symlinks = False)
os.chmod(rel_path, mode, dir_fd = self._root_path_fd) # follow_symlinks = False
@event(format_pattern = '({param_fip}) {param_path} (fh={param_fip})')
def open(self, path, fip):
fip.fh = os.open(self._rel_path(path), fip.flags, dir_fd = self._root_path_fd)
return 0
@event(format_pattern = '{param_length} bytes from {param_path} at offset {param_offset} (fh={param_fip})')
def read(self, path, length, offset, fip):
ret = os.pread(fip.fh, length, offset)
return ret
@event(format_pattern = '{param_path}')
def readdir(self, path, fh):
rel_path = self._rel_path(path)
dirents = ['.', '..']
if stat.S_ISDIR(os.lstat(rel_path, dir_fd = self._root_path_fd).st_mode):
dir_fd = os.open(rel_path, os.O_RDONLY, dir_fd = self._root_path_fd)
dirents.extend(os.listdir(dir_fd))
os.close(dir_fd)
return dirents
@event(format_pattern = '{param_path}')
def readlink(self, path):
pathname = os.readlink(self._rel_path(path), dir_fd = self._root_path_fd)
if pathname.startswith('/'): # TODO check this ... actually required?
return os.path.relpath(pathname, self._root_path)
else:
return pathname
@event(format_pattern = '{param_path} (fh={param_fip})')
def release(self, path, fip):
os.close(fip.fh)
@event(format_pattern = '{param_old_path} to {param_new_path}')
def rename(self, old_path, new_path):
os.rename(
self._rel_path(old_path), self._rel_path(new_path),
src_dir_fd = self._root_path_fd, dst_dir_fd = self._root_path_fd
)
@event(format_pattern = '{param_path}')
def rmdir(self, path):
os.rmdir(self._rel_path(path), dir_fd = self._root_path_fd)
@event(format_pattern = '{param_path}')
def statfs(self, path):
fd = os.open(self._rel_path(path), os.O_RDONLY, dir_fd = self._root_path_fd)
stv = os.statvfs(fd)
os.close(fd)
return {key: getattr(stv, key) for key in self._STVFS_FIELDS}
@event(format_pattern = 'from {param_source_path} to {param_target_path_}')
def symlink(self, target_path_, source_path):
target_rel_path = self._rel_path(target_path_)
os.symlink(source_path, target_rel_path, dir_fd = self._root_path_fd)
uid, gid, pid = fuse_get_context()
os.chown(target_rel_path, uid, gid, dir_fd = self._root_path_fd, follow_symlinks = False)
@event(format_pattern = '{param_path} to {param_length} bytes (fh={param_fip})')
def truncate(self, path, length, fip = None):
if fip is None:
fd = os.open(self._rel_path(path), flags = os.O_WRONLY, dir_fd = self._root_path_fd)
ret = os.ftruncate(fd, length)
os.close(fd)
return ret
else:
return os.ftruncate(fip.fh, length)
@event(format_pattern = '{param_path}')
def unlink(self, path):
os.unlink(self._rel_path(path), dir_fd = self._root_path_fd)
@event(format_pattern = '{param_path}')
def utimens(self, path, times = None):
def _fix_time_(atime, mtime):
if None in (atime, mtime):
st = os.lstat(relpath, dir_fd = self._root_path_fd)
if atime is None:
atime = st.st_atime_ns
if mtime is None:
mtime = st.st_mtime_ns
return (atime, mtime)
relpath = self._rel_path(path)
os.utime(relpath, ns = _fix_time_(*times), dir_fd = self._root_path_fd, follow_symlinks = False)
@event(format_pattern = '{param_buf_len} bytes to {param_path} at offset {param_offset} (fh={param_fip})')
def write(self, path, buf, offset, fip):
res = os.pwrite(fip.fh, buf, offset)
return res
|
[
"ernst@pleiszenburg.de"
] |
ernst@pleiszenburg.de
|
f64c6ffb584cd043d80268c613a23fadf9f3d960
|
d0e268862f359bbeec426b00a0c45788f6fb0b4e
|
/lesson22-优化小实例/main.py
|
10fefdf9bbed196814d0bc20e94497752dbfa13d
|
[] |
no_license
|
jpegbert/PyTorch
|
f87c2e38572c51842785de5ed1b39bb641402ac6
|
482421c76a093312ffeff7e5af4ecd3ab0cdcf30
|
refs/heads/master
| 2023-08-27T03:56:26.883297
| 2021-11-08T06:03:30
| 2021-11-08T06:03:30
| 326,677,679
| 2
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 853
|
py
|
import numpy as np
from matplotlib import pyplot as plt
import torch
def himmelblau(x):
return (x[0] ** 2 + x[1] - 11) ** 2 + (x[0] + x[1] ** 2 - 7) ** 2
x = np.arange(-6, 6, 0.1)
y = np.arange(-6, 6, 0.1)
print('x,y range:', x.shape, y.shape)
X, Y = np.meshgrid(x, y)
print('X,Y maps:', X.shape, Y.shape)
Z = himmelblau([X, Y])
fig = plt.figure('himmelblau')
ax = fig.gca(projection='3d')
ax.plot_surface(X, Y, Z)
ax.view_init(60, -30)
ax.set_xlabel('x')
ax.set_ylabel('y')
plt.show()
# [1., 0.], [-4, 0.], [4, 0.]
x = torch.tensor([-4., 0.], requires_grad=True)
print(x)
optimizer = torch.optim.Adam([x], lr=1e-3)
for step in range(20000):
pred = himmelblau(x)
optimizer.zero_grad()
pred.backward()
optimizer.step()
if step % 2000 == 0:
print('step {}: x = {}, f(x) = {}'.format(step, x.tolist(), pred.item()))
|
[
"jiangpeng.jiang@zhaopin.com.cn"
] |
jiangpeng.jiang@zhaopin.com.cn
|
853ea408b40f36263a1ac3f6bb6b89829d2bbd39
|
a639206e5849432d6613c9af093b14f97e9dd794
|
/manage.py
|
3cda76ad753a5eb70246fda28e6126466f0d11c0
|
[
"MIT"
] |
permissive
|
Bazulenkov/primorsk-cup
|
6a37139b56b3b3df605f9fa49b1ef652a08d8020
|
13c227f9fb8289eb3e25d21e1de7a0fde8cb5f87
|
refs/heads/main
| 2023-06-10T00:21:27.939260
| 2021-06-30T12:36:04
| 2021-06-30T12:36:04
| 336,052,393
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 664
|
py
|
#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys
def main():
"""Run administrative tasks."""
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "primorsk.settings")
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line(sys.argv)
if __name__ == "__main__":
main()
|
[
"anton@bazul.ru"
] |
anton@bazul.ru
|
035504981c5c4ce873430a3439ea302e21244885
|
53c3462ff265b6273f4a4fa17f6d59688f69def0
|
/剑指offer/65_hasPath.py
|
fc4f3bf5633e263578be82adeacb409feea73759
|
[] |
no_license
|
17764591637/jianzhi_offer
|
b76e69a3ecb2174676da2c8d8d3372a3fc27b5c4
|
27e420ee302d5ab6512ecfdb8d469b043fb7102d
|
refs/heads/master
| 2023-08-03T01:32:51.588472
| 2019-10-13T07:56:21
| 2019-10-13T07:56:21
| 197,692,548
| 2
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,300
|
py
|
'''
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。
路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。
如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。
例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，
因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
分析：回溯算法
这是一个可以用回朔法解决的典型题。首先，在矩阵中任选一个格子作为路径的起点。如果路径上的第i个字符不是ch，
那么这个格子不可能处在路径上的第i个位置。如果路径上的第i个字符正好是ch，那么往相邻的格子寻找路径上的第i+1个字符。
除在矩阵边界上的格子之外，其他格子都有4个相邻的格子。重复这个过程直到路径上的所有字符都在矩阵中找到相应的位置。
由于回朔法的递归特性，路径可以被开成一个栈。当在矩阵中定位了路径中前n个字符的位置之后，在与第n个字符对应的格子
的周围都没有找到第n+1个字符，这个时候只要在路径上回到第n-1个字符，重新定位第n个字符。
由于路径不能重复进入矩阵的格子，还需要定义和字符矩阵大小一样的布尔值矩阵，用来标识路径是否已经进入每个格子。
当矩阵中坐标为（row,col）的格子和路径字符串中相应的字符一样时，从4个相邻的格子(row,col-1),(row-1,col),
(row,col+1)以及(row+1,col)中去定位路径字符串中下一个字符如果4个相邻的格子都没有匹配字符串中下一个的字符，
表明当前路径字符串中字符在矩阵中的定位不正确，我们需要回到前一个，然后重新定位。一直重复这个过程，
直到路径字符串上所有字符都在矩阵中找到合适的位置。
'''
class Solution:
def hasPath(self, matrix, rows, cols, path):
# write code here
for i in range(rows):
for j in range(cols):
if matrix[i*cols+j] == path[0]:
#print(i,j)
if self.find(list(matrix),rows,cols,path[1:],i,j):
return True
return False
def find(self,matrix,rows,cols,path,i,j):
if not path:
return True
matrix[i*cols+j]='0'#记录是否已经走过，0表示已经走过
if j+1<cols and matrix[i*cols+j+1]==path[0]:
return self.find(matrix,rows,cols,path[1:],i,j+1)#往右
elif j-1>=0 and matrix[i*cols+j-1]==path[0]:
return self.find(matrix,rows,cols,path[1:],i,j-1)#往左
elif i+1<rows and matrix[(i+1)*cols+j]==path[0]:
return self.find(matrix,rows,cols,path[1:],i+1,j)#往下
elif i-1>=0 and matrix[(i-1)*cols+j]==path[0]:
return self.find(matrix,rows,cols,path[1:],i-1,j)#往上
else:
return False
s = Solution()
res = s.hasPath(['a','b','c', 'e', 's' ,'f' ,'c', 's', 'a', 'd', 'e', 'e'],3,4,'bcced')
print(res)
|
[
"17764591637@163.com"
] |
17764591637@163.com
|
c672da054ce83d887363f44a14b4d22240729758
|
131d941a4d1df110afe09733fe010da816597bb4
|
/PASA/alameda/input/motion-detection-camera/mmal/motion-detected.py
|
5cf1a72a7454179e2769cc7877f1faf7f8313954
|
[] |
no_license
|
onebeartoe/electronic-signs
|
386cfb7288c211634a3afad55d334d4602178a95
|
621099b7d81995a9c7e977ca683bb3c3d02c9d17
|
refs/heads/master
| 2020-12-24T11:06:57.754906
| 2018-11-01T16:40:35
| 2018-11-01T16:40:35
| 13,177,627
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 120
|
py
|
#import sendint;
print "nothing happened in motion-detected.py"
#print "motion detected"
#sendint.sendInt(ser, '2')
|
[
"onebeartoe@gmail.com"
] |
onebeartoe@gmail.com
|
5c65745999dcd0d78e74ff5c2c30969e2bf57ef8
|
b75aedc25188b059189df7654dacd32818a86de2
|
/Facial Emotions/emotions.py
|
ef7d2650e5198354441345cbe25e5092c2c92730
|
[] |
no_license
|
scorpiocodes/ComputerVision
|
2308c9dcfb07fc85fdb8c46f45891ae0e4b106fa
|
a346ce69c81ae1a74cbd94f1ad8749a50aa44fbd
|
refs/heads/master
| 2020-03-22T01:53:54.861885
| 2019-06-11T18:39:34
| 2019-06-11T18:39:34
| 139,337,035
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,457
|
py
|
import cv2
import numpy as np
from keras.models import load_model
from statistics import mode
from utils.datasets import get_labels
from utils.inference import detect_faces
from utils.inference import draw_text
from utils.inference import draw_bounding_box
from utils.inference import apply_offsets
from utils.inference import load_detection_model
from utils.preprocessor import preprocess_input
USE_WEBCAM = True # If false, loads video file source
# parameters for loading data and images
emotion_model_path = './models/emotion_model.hdf5'
emotion_labels = get_labels('fer2013')
# hyper-parameters for bounding boxes shape
frame_window = 10
emotion_offsets = (20, 40)
# loading models
face_cascade = cv2.CascadeClassifier('./models/haarcascade_frontalface_default.xml')
emotion_classifier = load_model(emotion_model_path)
# getting input model shapes for inference
emotion_target_size = emotion_classifier.input_shape[1:3]
# starting lists for calculating modes
emotion_window = []
# starting video streaming
cv2.namedWindow('window_frame')
video_capture = cv2.VideoCapture(0)
# Select video or webcam feed
cap = None
if (USE_WEBCAM == True):
cap = cv2.VideoCapture(0) # Webcam source
else:
cap = cv2.VideoCapture('./demo/dinner.mp4') # Video file source
while cap.isOpened(): # True:
ret, bgr_image = cap.read()
#bgr_image = video_capture.read()[1]
gray_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2GRAY)
rgb_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2RGB)
faces = face_cascade.detectMultiScale(gray_image, scaleFactor=1.1, minNeighbors=5,
minSize=(30, 30), flags=cv2.CASCADE_SCALE_IMAGE)
for face_coordinates in faces:
x1, x2, y1, y2 = apply_offsets(face_coordinates, emotion_offsets)
gray_face = gray_image[y1:y2, x1:x2]
try:
gray_face = cv2.resize(gray_face, (emotion_target_size))
except:
continue
gray_face = preprocess_input(gray_face, True)
gray_face = np.expand_dims(gray_face, 0)
gray_face = np.expand_dims(gray_face, -1)
emotion_prediction = emotion_classifier.predict(gray_face)
emotion_probability = np.max(emotion_prediction)
emotion_label_arg = np.argmax(emotion_prediction)
emotion_text = emotion_labels[emotion_label_arg]
emotion_window.append(emotion_text)
if len(emotion_window) > frame_window:
emotion_window.pop(0)
try:
emotion_mode = mode(emotion_window)
except:
continue
if emotion_text == 'angry':
color = emotion_probability * np.asarray((255, 0, 0))
elif emotion_text == 'sad':
color = emotion_probability * np.asarray((0, 0, 255))
elif emotion_text == 'happy':
color = emotion_probability * np.asarray((255, 255, 0))
elif emotion_text == 'surprise':
color = emotion_probability * np.asarray((0, 255, 255))
else:
color = emotion_probability * np.asarray((0, 255, 0))
color = color.astype(int)
color = color.tolist()
draw_bounding_box(face_coordinates, rgb_image, color)
draw_text(face_coordinates, rgb_image, emotion_mode,
color, 0, -45, 1, 1)
bgr_image = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2BGR)
cv2.imshow('window_frame', bgr_image)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
|
[
"noreply@github.com"
] |
scorpiocodes.noreply@github.com
|
c8217fd5718d9e8ce56aa8984ec31a0f48ea85a3
|
d95cd6f18f9f83df625362dd28ab6b733fa98c90
|
/extract_bboxes.py
|
ca82fd055ca9f70678b1b8d0c449e0586a5e3a0a
|
[] |
no_license
|
hassony2/yolo2-pytorch
|
477196349ee1d44ad09376b8f02cb08cced559a2
|
b9e1e905115694df5dd33b8a7485977263e19caf
|
refs/heads/master
| 2021-01-20T21:41:48.529189
| 2017-09-21T13:24:54
| 2017-09-21T13:24:54
| 101,783,945
| 1
| 0
| null | 2017-09-21T13:24:56
| 2017-08-29T16:40:30
|
Python
|
UTF-8
|
Python
| false
| false
| 5,011
|
py
|
import numpy as np
import os
from PIL import Image
import torch
from torch.autograd import Variable
from torchvision import transforms
from tqdm import tqdm
import cfgs.config as cfg
from darknet import Darknet19
from datasets.gteagazeplusimage import GTEAGazePlusImage
from datasets.smthgimage import SmthgImage
from datasets.utils.visualize import plot_bboxes
import utils.network as net_utils
import utils.yolo as yolo_utils
def get_crop_params(bbox, img_shape, increase_ratio=2.2):
"""
returns x_min, y_min, x_max ,y_max crop coordinates according to rule
2.2 times max dimension of the bounding box
Args:
bbox(numpy.ndarray): x_min, y_min, x_max, y_max
img_shape(tuple): original image shape
increase_ratio(float): final bbox size / tight bbox size
"""
width = bbox[2] - bbox[0]
height = bbox[3] - bbox[1]
square_dim = max(width, height)
final_dim = square_dim * increase_ratio
center_x = bbox[0] + width / 2
center_y = bbox[1] + height / 2
new_x_min = int(center_x - final_dim / 2)
new_x_max = int(center_x + final_dim / 2)
new_y_min = int(center_y - final_dim / 2)
new_y_max = int(center_y + final_dim / 2)
if new_x_min >= 0 and new_y_min >= 0 and\
new_x_max <= img_shape[0] and new_y_max <= img_shape[1]:
success = True
else:
success = False
return success, (new_x_min, new_y_min, new_x_max, new_y_max)
def test_net(net, dataset, transform=None, max_per_image=300, thresh=0.5,
num_classes=1, vis=False, crop_folder=None):
# Initialize counter for number of cropped hands
extracted_hands = 0
# Run through dataset
for i, (img, annots) in tqdm(enumerate(dataset)):
original_img = img
np_original_img = np.array(original_img)
if transform is not None:
img = transform(img)
# Add batch dimension
img = img.unsqueeze(0)
# Create GPU variable
img_var = Variable(img.type(torch.FloatTensor))
img_var = img_var.cuda()
# Detect hands
bbox_pred, iou_pred, prob_pred = net(img_var)
# to numpy
bbox_pred = bbox_pred.data.cpu().numpy()
iou_pred = iou_pred.data.cpu().numpy()
prob_pred = prob_pred.data.cpu().numpy()
bboxes, scores, cls_inds = yolo_utils.postprocess(
bbox_pred, iou_pred, prob_pred,
np_original_img.shape[0:2], cfg, thresh)
for class_idx in range(num_classes):
# Extract class
inds = np.where(cls_inds == class_idx)[0]
class_bboxes = bboxes[inds]
class_scores = scores[inds]
class_scores = class_scores[:, np.newaxis]
# Create class detections in format
# [[x_min, y_min, x_max, y_max, score], ...]
if vis:
fig = plot_bboxes(np_original_img, class_bboxes,
class_scores)
fig.savefig('bboxes_{:03}.jpg'.format(i), bbox_inches='tight')
# Save crops to (368x368) images
if crop_folder is not None:
for i, bbox in enumerate(class_bboxes):
crop_success, crop_params = get_crop_params(bbox,
(original_img.width,
original_img.height))
if crop_success:
crop = original_img.crop((crop_params))
crop_name = 'rendered_{:03d}.jpg'.format(
extracted_hands)
crop = crop.resize((368, 368))
# if bbox[2] - bbox[0] > 100 and bbox[3] - bbox[1] > 100:
# Mirror left hands
if cls_inds[i] == 0:
crop = crop.transpose(Image.FLIP_LEFT_RIGHT)
print('saving image')
crop.save(os.path.join(crop_folder, crop_name))
extracted_hands += 1
if __name__ == "__main__":
vis = True
crop_folder = 'results/crops'
# Initialize dataset
dataset = GTEAGazePlusImage()
# dataset = SmthgImage()
# Initialize test image transform
test_transform = transforms.Compose([
transforms.Scale(cfg.inp_size),
transforms.ToTensor()])
# Initialise network
# trained_model = 'models/training/darknet19_all_exp1/darknet19_all_exp1_64.h5'
trained_model = 'models/training/darknet19_all_exp1/darknet19_all_exp1_15.h5'
net = Darknet19()
net_utils.load_net(trained_model, net)
net.cuda()
net.eval()
# Extract bounding boxes
test_net(net, dataset, transform=test_transform, vis=vis, thresh=0.5,
crop_folder=None)
|
[
"yana.hasson@inria.fr"
] |
yana.hasson@inria.fr
|
4b35f9e5c7f11f607452a11c9cd445ed2278b7b9
|
54e8ac0398bfa33d9a1d40e5a8d6477e3806bb17
|
/RaspberryPiCode/getHSV.py
|
f25d56d310c28ed15cd468d7255e72f710e71a4d
|
[] |
no_license
|
RoboLions/frc2016-vision
|
ac46a15ba3c85f713f2d86619bce8b27aa996174
|
c32e559485e956a33794fa5a453c7202d042c27c
|
refs/heads/master
| 2021-04-30T22:59:30.402487
| 2016-03-30T03:26:17
| 2016-03-30T03:26:17
| 50,622,375
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,193
|
py
|
import cv2
import numpy as np
# move u* and l* sliders to find upper and lower end of hsv range respectively.
# hit q to quit
cap=cv2.VideoCapture(0)
def nothing(x):
pass
cv2.namedWindow("result")
h,s,v=100,100,100
cv2.createTrackbar('lh', 'result', 0, 255, nothing)
cv2.createTrackbar('ls', 'result', 0, 255, nothing)
cv2.createTrackbar('lv', 'result', 0, 255, nothing)
cv2.createTrackbar('uh', 'result', 0, 255, nothing)
cv2.createTrackbar('us', 'result', 0, 255, nothing)
cv2.createTrackbar('uv', 'result', 0, 255, nothing)
while True:
_, frame = cap.read()
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV )
lh=cv2.getTrackbarPos('lh', 'result')
ls=cv2.getTrackbarPos('ls', 'result')
lv=cv2.getTrackbarPos('lv', 'result')
uh=cv2.getTrackbarPos('uh', 'result')
us=cv2.getTrackbarPos('us', 'result')
uv=cv2.getTrackbarPos('uv', 'result')
lower = np.array([lh,ls,lv])
upper = np.array([uh,us,uv])
mask = cv2.inRange(hsv, lower, upper)
result = cv2.bitwise_and(frame, frame, mask = mask )
cv2.imshow('result', result )
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
cap.release
cv2.destroyAllWindows()
|
[
"alan.glaser@gnail.com"
] |
alan.glaser@gnail.com
|
87e04c086ca8fcfe065781aaefdf79add1f73023
|
14a93d1114c26f1483b711793297cd00c1abd37f
|
/data/data_dav/export.py
|
2cc46ba94df22917591e14f70aef822629e3ec10
|
[] |
no_license
|
csmfindling/bci_eeg
|
7c50eca0c150e760a0e70892c1182f8862df3902
|
a5a4ab8456f0354904cae8d3817017861ebd192d
|
refs/heads/master
| 2021-05-09T21:34:35.513477
| 2018-01-29T16:10:54
| 2018-01-29T16:10:54
| 118,730,858
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,089
|
py
|
import pickle
import sys
import numpy as np
from scipy.signal import butter, lfilter, detrend
from numpy.fft import fft, fftfreq
import time as timelib
import pickle
# functions
def butter_bandpass(lowcut, highcut, fs, order=9):
nyq = 0.5 * fs
low = lowcut / nyq
high = highcut / nyq
b, a = butter(order, [low, high], btype='band')
return b, a
def butter_bandpass_filter(data, lowcut, highcut, fs, order=9):
b, a = butter_bandpass(lowcut, highcut, fs, order=order)
y = lfilter(b, a, data)
return y
def butter_lowpass(lowcut, fs, order=9):
nyq = 0.5 * fs
low = lowcut / nyq
b, a = butter(order, low, btype='low')
return b, a
def butter_lowpass_filter(data, lowcut, fs, order=9):
b, a = butter_lowpass(lowcut, fs, order=order)
y = lfilter(b, a, data)
return y
# data
ref = pickle.load(open('python_data/rawref.pkl'))
close = pickle.load(open('python_data/rawclose.pkl'))
eye = pickle.load(open('python_data/rawblink.pkl'))
# parameters
dt = 0.004 # sampling frequency is of 1/0.004 = 250Hz
# write in csv for reference = 30sec
nb_points = int(30 * 1./0.004)
data = ref[:, -nb_points:]
y = butter_lowpass_filter(data, 30., 1./dt) # low pass filter
y = (y - np.mean(y))/np.std(y) # normalize
concat = np.concatenate((data[:-1], y[:-1]), axis=0)
import csv
with open('csv_data/reference.csv', 'wb') as csvfile:
spamwriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)
spamwriter.writerow(['eye', 'channel 2', 'channel 3', 'alpha', 'eye filtered', 'channel 2 filtered', 'channel 3 filtered', 'alpha filtered'])
for idx in range(concat.shape[-1]):
spamwriter.writerow(concat[:,idx])
# write in csv for close_eye = 60 sec
nb_points = int(60 * 1./0.004)
data = close[:, -nb_points:]
y = butter_lowpass_filter(data, 30., 1./dt) # low pass filter
y = (y - np.mean(y))/np.std(y) # normalize
concat = np.concatenate((data[:-1], y[:-1]), axis=0)
import csv
with open('csv_data/close_eye.csv', 'wb') as csvfile:
spamwriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)
spamwriter.writerow(['eye', 'channel 2', 'channel 3', 'alpha', 'eye filtered', 'channel 2 filtered', 'channel 3 filtered', 'alpha filtered'])
for idx in range(concat.shape[-1]):
spamwriter.writerow(concat[:,idx])
# write in csv for close_eye = 30 sec
nb_points = int(30 * 1./0.004)
data = eye[:, -nb_points:]
y = butter_lowpass_filter(data, 30., 1./dt) # low pass filter
y = (y - np.mean(y))/np.std(y) # normalize
concat = np.concatenate((data[:-1], y[:-1]), axis=0)
import csv
with open('csv_data/blinks.csv', 'wb') as csvfile:
spamwriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)
spamwriter.writerow(['eye', 'channel 2', 'channel 3', 'alpha', 'eye filtered', 'channel 2 filtered', 'channel 3 filtered', 'alpha filtered'])
for idx in range(concat.shape[-1]):
spamwriter.writerow(concat[:,idx])
|
[
"charles.findling@gmail.com"
] |
charles.findling@gmail.com
|
e06e1100601a1bacb795bb1f1efe4a2e96a3d781
|
221d5405763d1a6ab3c6755583e557c14b9f3742
|
/gusregon/gus.py
|
ca34d58334fd1bd2383ff69dfbb77899f224cc07
|
[
"BSD-2-Clause"
] |
permissive
|
tpro/django-gusregon
|
4bd7253be9d43345376e36312d763d4653d0bbcd
|
75d4f291ae805bd986e1b4cb03b3b94e52a48076
|
refs/heads/master
| 2021-01-18T18:11:50.746453
| 2015-04-19T11:00:49
| 2015-04-19T11:00:49
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,656
|
py
|
import requests
import json
GUS_API_URL = 'https://wyszukiwarkaregon.stat.gov.pl/wsBIR/UslugaBIRzewnPubl.svc/ajaxEndpoint/'
LOGIN_ENDPOINT = 'Zaloguj'
CAPTCHA_ENDPOINT = 'PobierzCaptcha'
CHECK_CAPTCHA_ENDPOINT = 'SprawdzCaptcha'
SEARCH_ENDPOINT = 'daneSzukaj'
COMPANY_DETAILS_ENDPOINT = 'DanePobierzPelnyRaport'
class GUS(object):
sid = None
report_type = {
'F': 'DaneRaportFizycznaPubl',
'P': 'DaneRaportPrawnaPubl'}
prefix_data = {
'F': 'fiz_',
'P': 'praw_'}
def __init__(self, sid=None):
self.sid = sid
def login(self):
data = {'pKluczUzytkownika': 'aaaaaabbbbbcccccdddd'}
self.sid = self._post(LOGIN_ENDPOINT, data=json.dumps(data))
return self.sid
def get_captcha(self):
return self._post(CAPTCHA_ENDPOINT)
def check_captcha(self, captcha):
data = {'pCaptcha': captcha}
return self._post(
CHECK_CAPTCHA_ENDPOINT, data=json.dumps(data))
def search(self, nip=None, regon=None, krs=None,
detailed=True, no_prefix=True):
if not any([nip, regon, krs]):
raise AttributeError(
'At least one parameter (nip, regon, krs) is required.')
if nip:
search_params = {'Nip': nip}
elif regon:
search_params = {'Regon': regon}
else:
search_params = {'Krs': krs}
data = {'pParametryWyszukiwania': search_params}
basic_info = self._post(
SEARCH_ENDPOINT, data=json.dumps(data))
if not detailed or not basic_info:
return basic_info
basic_info = json.loads(basic_info)[0]
data = {
'pNazwaRaportu': self.report_type.get(basic_info['Typ']),
'pRegon': basic_info['Regon'],
'pSilosID': 1,
}
details = json.loads(self._post(
COMPANY_DETAILS_ENDPOINT, data=json.dumps(data)))[0]
if no_prefix:
return self._remove_prefix(details)
return details
def _post(self, url, **kwargs):
headers = {'Content-Type': 'application/json'}
if self.sid:
headers.update({'sid': self.sid})
url = '%s%s' % (GUS_API_URL, url)
response = requests.post(url, headers=headers, **kwargs)
return json.loads(response.content)['d']
def _remove_prefix(self, data):
data_without_prefix = {}
for key, value in data.iteritems():
if key.startswith(tuple(self.prefix_data.values())):
key = key[key.find('_') + 1:]
data_without_prefix[key] = value
return data_without_prefix
|
[
"adam@bogdal.pl"
] |
adam@bogdal.pl
|
3ec809e921148f10c35e5d7afb4098a0d5cfa51e
|
3a107debc014817103fd6cf18a346ba87cd4a896
|
/indexapp/views.py
|
19013ae175afb5a1629f37931d307a8c04c3468e
|
[] |
no_license
|
shuang3322/itsm_new_hj
|
20c979bb682af084d347a10f773591dc090e3a8d
|
a99384243ec0dc667e04edda30754e9cead96bbf
|
refs/heads/master
| 2021-08-22T22:30:20.032674
| 2018-11-27T06:17:27
| 2018-11-27T06:17:27
| 147,472,768
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 432
|
py
|
from django.shortcuts import render
# Create your views here.
from django.shortcuts import HttpResponse
from indexapp.models import IPdata
def visit(request):
ip = request.META.get('REMOTE_ADDR')
print(ip)
all = IPdata.objects.all()
# for item in request.META:
# print(item,request.META.get(item))
return render(request, "test.html", {'current_user': all,'re_ip':ip})
#
# def add_IP(request):
# for
|
[
"shuang0528@hotmail.com"
] |
shuang0528@hotmail.com
|
26c0479d73b4773d979b4de73b5383b4ceeb2883
|
ff5705d2813486da67b8aca48cfd5bf2c6cce068
|
/2_text_classification.py
|
0fa709be5b6d1b79dc77f3609155e88c78f26369
|
[] |
no_license
|
m-nasiruddin/text_blob
|
61934763586413115054f1557c62e0301ab70f87
|
1f95f7ee0632ddc6bc09cc619a0510114a6a93c6
|
refs/heads/master
| 2022-07-15T03:48:56.591056
| 2018-07-20T10:48:13
| 2018-07-20T10:48:13
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,714
|
py
|
from textblob.classifiers import NaiveBayesClassifier
from textblob import TextBlob
# creating a custom sentiment analyzer
# loading data and creating a classifier
train = [('I love this sandwich.', 'pos'),
('this is an amazing place!', 'pos'),
('I feel very good about these beers.', 'pos'),
('this is my best work.', 'pos'),
("what an awesome view", 'pos'),
('I do not like this restaurant', 'neg'),
('I am tired of this stuff.', 'neg'),
("I can't deal with this", 'neg'),
('he is my sworn enemy!', 'neg'),
('my boss is horrible.', 'neg')]
test = [('the beer was good.', 'pos'),
('I do not enjoy my job', 'neg'),
("I ain't feeling dandy today.", 'neg'),
("I feel amazing!", 'pos'),
('Gary is a friend of mine.', 'pos'),
("I can't believe I'm doing this.", 'neg')]
cl = NaiveBayesClassifier(train) # creating a naive bayes classifier
# or, open from a file
# with open('data/input/train.json', 'r') as fp:
# cl = NaiveBayesClassifier(fp, format="json")
# classifying text
print(cl.classify("This is an amazing library!"))
# get the label probability distribution
prob_dist = cl.prob_classify("This one's a doozy.")
print(prob_dist.max())
print(round(prob_dist.prob("pos"), 2))
print(round(prob_dist.prob("neg"), 2))
# classifying textblob
blob = TextBlob("The beer is good. But the hangover is horrible.", classifier=cl)
print(blob.classify())
for s in blob.sentences:
print(s)
print(s.classify())
# evaluating classifiers
print(cl.accuracy(test))
print(cl.show_informative_features(5)) # displaying a listing of the most informative features
# updating classifiers wth new data
new_data = [('She is my best friend.', 'pos'),
("I'm happy to have a new friend.", 'pos'),
("Stay thirsty, my friend.", 'pos'),
("He ain't from around here.", 'neg')]
print(cl.update(new_data))
print(cl.accuracy(test))
# feature extractors
# creating a feature extractor that just uses the first and last words of a document as its features
def end_word_extractor(document):
tokens = document.split()
first_word, last_word = tokens[0], tokens[-1]
feats = {}
feats["first({0})".format(first_word)] = True
feats["last({0})".format(last_word)] = False
return feats
features = end_word_extractor("I feel happy")
assert features == {'last(happy)': False, 'first(I)': True}
# using the feature extractor in a classifier by passing it as the second argument of the constructor
cl2 = NaiveBayesClassifier(test, feature_extractor=end_word_extractor)
blob = TextBlob("I'm excited to try my new classifier.", classifier=cl2)
print(blob.classify())
|
[
"mohammad.nasiruddin@gmail.com"
] |
mohammad.nasiruddin@gmail.com
|
842f5307feedb014785782c8f52774517fee51a9
|
969be1a2865722374293a286fa0923d6247d54d5
|
/language/bert/bert_code/fairseq/optim/lr_scheduler/fairseq_lr_scheduler.py
|
1732e2e495edd65fe93ea60644562119ae0b2e80
|
[
"MIT"
] |
permissive
|
Relwayg/Differentially-Private-Deep-Learning
|
36935e882cd37482f690b7f5888835065aa5e127
|
55eb9a1b75472895588d388de7567f012c9bc9ed
|
refs/heads/main
| 2023-09-06T01:23:44.915967
| 2021-11-23T06:53:29
| 2021-11-23T06:53:29
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,396
|
py
|
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from .. import FairseqOptimizer
class FairseqLRScheduler(object):
def __init__(self, args, optimizer):
super().__init__()
if not isinstance(optimizer, FairseqOptimizer):
raise ValueError('optimizer must be an instance of FairseqOptimizer')
self.args = args
self.optimizer = optimizer
self.best = None
@staticmethod
def add_args(parser):
"""Add arguments to the parser for this LR scheduler."""
pass
def state_dict(self):
"""Return the LR scheduler state dict."""
return {'best': self.best}
def load_state_dict(self, state_dict):
"""Load an LR scheduler state dict."""
self.best = state_dict['best']
def step(self, epoch, val_loss=None):
"""Update the learning rate at the end of the given epoch."""
if val_loss is not None:
if self.best is None:
self.best = val_loss
else:
self.best = min(self.best, val_loss)
def step_update(self, num_updates):
"""Update the learning rate after each update."""
return self.optimizer.get_lr()
def reinit(self, total_num_update, num_updates):
pass
|
[
"yudakuai18@163.com"
] |
yudakuai18@163.com
|
444b7127cd68eeab661ca9a41c8296181217f564
|
2a527f6fdee469bf1c3d76c2519149d916fa51d2
|
/python-client/victorops_client/models/on_call_log.py
|
870c6428c3097ccdca27122e1b5ff2514712c456
|
[] |
no_license
|
ArjunSangitrao/python-victorops
|
e261971800adb337da36b716f2c0fd0fc5c5973c
|
a9de3c93d141ad19213bdef6aa3790988bf03c66
|
refs/heads/master
| 2022-03-26T19:19:06.556731
| 2017-02-26T12:39:08
| 2017-02-26T12:39:08
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 5,018
|
py
|
# coding: utf-8
"""
VictorOps API
This API allows you to interact with the VictorOps platform in various ways. Your account may be limited to a total number of API calls per month. Also, some of these API calls have rate limits. NOTE: In this documentation when creating a sample curl request (clicking the TRY IT OUT! button), in some API viewing interfaces, the '@' in an email address may be encoded. Please note that the REST endpoints will not process the encoded version. Make sure that the encoded character '%40' is changed to its unencoded form before submitting the curl request.
OpenAPI spec version: 0.0.1
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
from pprint import pformat
from six import iteritems
import re
class OnCallLog(object):
"""
NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
"""
def __init__(self, team_slug=None, start=None, end=None, user_logs=None):
"""
OnCallLog - a model defined in Swagger
:param dict swaggerTypes: The key is attribute name
and the value is attribute type.
:param dict attributeMap: The key is attribute name
and the value is json key in definition.
"""
self.swagger_types = {
'team_slug': 'str',
'start': 'datetime',
'end': 'datetime',
'user_logs': 'list[UserLog]'
}
self.attribute_map = {
'team_slug': 'teamSlug',
'start': 'start',
'end': 'end',
'user_logs': 'userLogs'
}
self._team_slug = team_slug
self._start = start
self._end = end
self._user_logs = user_logs
@property
def team_slug(self):
"""
Gets the team_slug of this OnCallLog.
:return: The team_slug of this OnCallLog.
:rtype: str
"""
return self._team_slug
@team_slug.setter
def team_slug(self, team_slug):
"""
Sets the team_slug of this OnCallLog.
:param team_slug: The team_slug of this OnCallLog.
:type: str
"""
self._team_slug = team_slug
@property
def start(self):
"""
Gets the start of this OnCallLog.
:return: The start of this OnCallLog.
:rtype: datetime
"""
return self._start
@start.setter
def start(self, start):
"""
Sets the start of this OnCallLog.
:param start: The start of this OnCallLog.
:type: datetime
"""
self._start = start
@property
def end(self):
"""
Gets the end of this OnCallLog.
:return: The end of this OnCallLog.
:rtype: datetime
"""
return self._end
@end.setter
def end(self, end):
"""
Sets the end of this OnCallLog.
:param end: The end of this OnCallLog.
:type: datetime
"""
self._end = end
@property
def user_logs(self):
"""
Gets the user_logs of this OnCallLog.
:return: The user_logs of this OnCallLog.
:rtype: list[UserLog]
"""
return self._user_logs
@user_logs.setter
def user_logs(self, user_logs):
"""
Sets the user_logs of this OnCallLog.
:param user_logs: The user_logs of this OnCallLog.
:type: list[UserLog]
"""
self._user_logs = user_logs
def to_dict(self):
"""
Returns the model properties as a dict
"""
result = {}
for attr, _ in iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
return result
def to_str(self):
"""
Returns the string representation of the model
"""
return pformat(self.to_dict())
def __repr__(self):
"""
For `print` and `pprint`
"""
return self.to_str()
def __eq__(self, other):
"""
Returns true if both objects are equal
"""
if not isinstance(other, OnCallLog):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""
Returns true if both objects are not equal
"""
return not self == other
|
[
"vincent.desmet@honestbee.com"
] |
vincent.desmet@honestbee.com
|
eb66983747fd37d5bad2b03c62aa2cb5b9820300
|
6923f79f1eaaba0ab28b25337ba6cb56be97d32d
|
/A_Primer_on_Scientific_Programming_with_Python/input/c2f_cml_v3.py
|
9d13a354db2390ff9b57049d4ab8c67135d83538
|
[] |
no_license
|
burakbayramli/books
|
9fe7ba0cabf06e113eb125d62fe16d4946f4a4f0
|
5e9a0e03aa7ddf5e5ddf89943ccc68d94b539e95
|
refs/heads/master
| 2023-08-17T05:31:08.885134
| 2023-08-14T10:05:37
| 2023-08-14T10:05:37
| 72,460,321
| 223
| 174
| null | 2022-10-24T12:15:06
| 2016-10-31T17:24:00
|
Jupyter Notebook
|
UTF-8
|
Python
| false
| false
| 217
|
py
|
import sys
try:
C = float(sys.argv[1])
except:
print 'You failed to provide Celsius degrees as input '\
'on the command line!'
sys.exit(1) # abort
F = 9.0*C/5 + 32
print '%gC is %.1fF' % (C, F)
|
[
"bb@b.om"
] |
bb@b.om
|
625ab94e1d6b0ee32774ffd6931f538b4fdb913f
|
6298ff0f597ec09633696622c42321dd6bbaab6d
|
/znachkov_oleksandr/03/task3.1.py
|
061a601d2277c930b0c29708f2bee2eb8ab3078c
|
[] |
no_license
|
Neckmus/itea_python_basics_3
|
94db7ea756cbb164b8705445b1ab027bb5ff4d93
|
9d76fc3d081fa407805e98d12f7f9960c8976366
|
refs/heads/master
| 2022-05-28T08:28:00.415625
| 2020-04-22T11:03:25
| 2020-04-22T11:03:25
| 254,841,391
| 0
| 0
| null | 2020-04-11T10:14:57
| 2020-04-11T10:14:57
| null |
UTF-8
|
Python
| false
| false
| 455
|
py
|
from random import randint
ELEMENTS = 5
HIGHLIMIT = 10
exclusion_list = [4,2]
def array_diff(source_list):
print ("souerce list:", source_list)
print ("exclusion list:", exclusion_list)
#print (exclusion_list)
return [ elem for elem in source_list if not elem in exclusion_list]
source_list = lambda listsize, upper : [randint(0, upper) for index in range (listsize)]
print ("result:", array_diff(source_list(ELEMENTS, HIGHLIMIT)))
|
[
"alx.inferno@gmail.com"
] |
alx.inferno@gmail.com
|
2d46fb8bfbd693468cd059acdc41ca93221da9c6
|
c90b3ac3e5ad11cb93d4e6b76b9b9c4a19d0f512
|
/.history/copytest_20200502124009.py
|
413d6f42f34cf44c8b5ee71050cdd80e9dccb60d
|
[] |
no_license
|
rbafna6507/passwordstorageproject
|
6465585e36c81075856af8d565fe83e358b4a40a
|
480c30e358f7902ac0ef5c4e8d9556cb1d6d33f4
|
refs/heads/master
| 2022-11-25T12:05:02.625968
| 2020-07-27T21:33:38
| 2020-07-27T21:33:38
| 283,021,426
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 954
|
py
|
import pickle
import cryptography
from cryptography.fernet import Fernet
def encrypt(message: bytes, key: bytes) -> bytes:
return Fernet(key).encrypt(message)
def decrypt(token: bytes, key: bytes) -> bytes:
return Fernet(key).decrypt(token)
infile = open('jeff.pkl','rb')
z = pickle.load(infile)
key = Fernet.generate_key()
e_userpass = z
username = input("Username: ")
password = input("password: ")
website = input("Website: ")
e_username = encrypt(username.encode(), key)
e_password = encrypt(password.encode(), key)
e_list = [b"Username: " + e_username, b"Password: " + e_password]
e_userpass["Website: " + website] = e_list
outfile = open("jeff.pkl", "wb")
pickle.dump(e_userpass, outfile)
outfile.close()
infile = open('jeff.pkl','rb')
z = pickle.load(infile)
e_userpass = z
j = [e_userpass[k] for k in e_userpass]
e = [r.encode() for r in j]
q = decrypt(e, key)
"""for key, value in d_userpass.items():
print(key, ' : ', value)"""
|
[
"35872545+rbafna6507@users.noreply.github.com"
] |
35872545+rbafna6507@users.noreply.github.com
|
4ff5f832176e95271a6ca6a4df8efc6d8ebb25b5
|
2dba100f7ebbbb7b6f1850371b8640e0d3c0fc04
|
/ScientificProgramming/mu.py
|
1df2355ea7dc71793588406a3bf9cbbd0ecb49f6
|
[] |
no_license
|
lukasrieger-dev/python-beginner-projects
|
ea88fca0dc818ed2a63145305e49481dfa5b11af
|
d7cb2970a4067d150db57985e67e3cb6d3da7009
|
refs/heads/master
| 2023-01-04T12:19:34.881748
| 2020-11-06T18:10:52
| 2020-11-06T18:10:52
| 255,638,385
| 10
| 1
| null | 2020-10-03T07:25:23
| 2020-04-14T14:51:22
|
Python
|
UTF-8
|
Python
| false
| false
| 1,059
|
py
|
%matplotlib inline
import re
import matplotlib.pyplot as plt
def load_mu_data(path):
mu_data = dict()
with open(path, 'r') as file:
for line in file:
if re.match(r'(^ *$|^#.*$)', line):
# omit empty lines and comments
continue
*gas, C, T_0, mu_0 = line.split()
gas = ''.join(gas) # for names with more than one word
data = {'C':float(C), 'T_0':float(T_0), 'mu_0':float(mu_0)}
mu_data[gas] = data
return mu_data
def mu(T, gas, mu_data):
if not gas in mu_data:
raise ValueError
data = mu_data[gas]
T_0 = data['T_0']
C = data['C']
mu_0 = data['mu_0']
mu_T = mu_0 * (T_0-C)/(T+C) * (T/T_0)
return mu_T
path = 'viscosity_of_gases.dat'
mu_data = load_mu_data(path)
Ts = list(range(223, 374))
for gas in mu_data:
mu_values = [mu(T, gas, mu_data) for T in Ts]
plt.plot(Ts, mu_values)
plt.legend(list(mu_data))
plt.xlabel('temperatures')
plt.ylabel('viscosity')
plt.show()
|
[
"rieger.lks@gmail.com"
] |
rieger.lks@gmail.com
|
68870acb9c8c92e4ebbaf015abbd0b6109358e24
|
97aa1181a8305fab0cfc635954c92880460ba189
|
/torch/__init__.py
|
4442d7e952cc12a7e75937c35b091330e7c69570
|
[
"BSD-2-Clause"
] |
permissive
|
zhujiang73/pytorch_mingw
|
64973a4ef29cc10b96e5d3f8d294ad2a721ccacb
|
b0134a0acc937f875b7c4b5f3cef6529711ad336
|
refs/heads/master
| 2022-11-05T12:10:59.045925
| 2020-08-22T12:10:32
| 2020-08-22T12:10:32
| 123,688,924
| 8
| 4
|
NOASSERTION
| 2022-10-17T12:30:52
| 2018-03-03T12:15:16
|
C++
|
UTF-8
|
Python
| false
| false
| 14,830
|
py
|
r"""
The torch package contains data structures for multi-dimensional
tensors and mathematical operations over these are defined.
Additionally, it provides many utilities for efficient serializing of
Tensors and arbitrary types, and other useful utilities.
It has a CUDA counterpart, that enables you to run your tensor computations
on an NVIDIA GPU with compute capability >= 3.0.
"""
import os
import sys
import platform
import ctypes
if sys.version_info < (3,):
raise Exception("Python 2 has reached end-of-life and is no longer supported by PyTorch.")
from ._utils import _import_dotted_name
from ._utils_internal import get_file_path, prepare_multiprocessing_environment, \
USE_RTLD_GLOBAL_WITH_LIBTORCH, USE_GLOBAL_DEPS
#from .version import __version__
from ._six import string_classes as _string_classes
from typing import Set, Type
__all__ = [
'typename', 'is_tensor', 'is_storage', 'set_default_tensor_type',
'set_rng_state', 'get_rng_state', 'manual_seed', 'initial_seed', 'seed',
'save', 'load', 'set_printoptions', 'chunk', 'split', 'stack', 'matmul',
'no_grad', 'enable_grad', 'rand', 'randn',
'DoubleStorage', 'FloatStorage', 'LongStorage', 'IntStorage',
'ShortStorage', 'CharStorage', 'ByteStorage', 'BoolStorage',
'DoubleTensor', 'FloatTensor', 'LongTensor', 'IntTensor',
'ShortTensor', 'CharTensor', 'ByteTensor', 'BoolTensor', 'Tensor',
'lobpcg', '_set_deterministic', '_is_deterministic'
]
################################################################################
# Load the extension module
################################################################################
# See Note [Global dependencies]
def _load_global_deps():
if platform.system() == 'Windows':
return
lib_name = 'libtorch_global_deps' + ('.dylib' if platform.system() == 'Darwin' else '.so')
here = os.path.abspath(__file__)
lib_path = os.path.join(os.path.dirname(here), 'lib', lib_name)
ctypes.CDLL(lib_path, mode=ctypes.RTLD_GLOBAL)
if (USE_RTLD_GLOBAL_WITH_LIBTORCH or os.getenv('TORCH_USE_RTLD_GLOBAL')) and \
platform.system() != 'Windows':
# Do it the hard way. You might want to load libtorch with RTLD_GLOBAL in a
# few circumstances:
#
# 1. You're in a build environment (e.g., fbcode) where
# libtorch_global_deps is not available, but you still need
# to get mkl to link in with RTLD_GLOBAL or it will just
# not work.
#
# 2. You're trying to run PyTorch under UBSAN and you need
# to ensure that only one copy of libtorch is loaded, so
# vptr checks work properly
#
# If you're using this setting, you must verify that all the libraries
# you load consistently use the same libstdc++, or you may have
# mysterious segfaults.
#
import os as _dl_flags
if not hasattr(_dl_flags, 'RTLD_GLOBAL') or not hasattr(_dl_flags, 'RTLD_LAZY'):
try:
# next try if DLFCN exists
import DLFCN as _dl_flags # type: ignore
except ImportError:
# as a last attempt, use compile-time constants
import torch._dl as _dl_flags # type: ignore
old_flags = sys.getdlopenflags()
sys.setdlopenflags(_dl_flags.RTLD_GLOBAL | _dl_flags.RTLD_LAZY)
from torch._C import *
sys.setdlopenflags(old_flags)
del old_flags
del _dl_flags
else:
# Easy way. You want this most of the time, because it will prevent
# C++ symbols from libtorch clobbering C++ symbols from other
# libraries, leading to mysterious segfaults.
#
# If building in an environment where libtorch_global_deps isn't available
# like parts of fbsource, but where RTLD_GLOBAL causes segfaults, you will
# want USE_RTLD_GLOBAL_WITH_LIBTORCH = False and USE_GLOBAL_DEPS = False
#
# See Note [Global dependencies]
if USE_GLOBAL_DEPS:
_load_global_deps()
from torch._C import *
# Appease the type checker; ordinarily this binding is inserted by the
# torch._C module initialization code in C
if False:
import torch._C as _C
__all__ += [name for name in dir(_C)
if name[0] != '_' and
not name.endswith('Base')]
################################################################################
# Define basic utilities
################################################################################
def typename(o):
if isinstance(o, torch.Tensor):
return o.type()
module = ''
class_name = ''
if hasattr(o, '__module__') and o.__module__ != 'builtins' \
and o.__module__ != '__builtin__' and o.__module__ is not None:
module = o.__module__ + '.'
if hasattr(o, '__qualname__'):
class_name = o.__qualname__
elif hasattr(o, '__name__'):
class_name = o.__name__
else:
class_name = o.__class__.__name__
return module + class_name
def is_tensor(obj):
r"""Returns True if `obj` is a PyTorch tensor.
Note that this function is simply doing ``isinstance(obj, Tensor)``.
Using that ``isinstance`` check is better for typechecking with mypy,
and more explicit - so it's recommended to use that instead of
``is_tensor``.
Args:
obj (Object): Object to test
"""
return isinstance(obj, torch.Tensor)
def is_storage(obj):
r"""Returns True if `obj` is a PyTorch storage object.
Args:
obj (Object): Object to test
"""
return type(obj) in _storage_classes
def set_default_tensor_type(t):
r"""Sets the default ``torch.Tensor`` type to floating point tensor type
``t``. This type will also be used as default floating point type for
type inference in :func:`torch.tensor`.
The default floating point tensor type is initially ``torch.FloatTensor``.
Args:
t (type or string): the floating point tensor type or its name
Example::
>>> torch.tensor([1.2, 3]).dtype # initial default for floating point is torch.float32
torch.float32
>>> torch.set_default_tensor_type(torch.DoubleTensor)
>>> torch.tensor([1.2, 3]).dtype # a new floating point tensor
torch.float64
"""
if isinstance(t, _string_classes):
t = _import_dotted_name(t)
_C._set_default_tensor_type(t)
def set_default_dtype(d):
r"""Sets the default floating point dtype to :attr:`d`.
This dtype is:
1. The inferred dtype for python floats in :func:`torch.tensor`.
2. Used to infer dtype for python complex numbers. The default complex dtype is set to
``torch.complex128`` if default floating point dtype is ``torch.float64``,
otherwise it's set to ``torch.complex64``
The default floating point dtype is initially ``torch.float32``.
Args:
d (:class:`torch.dtype`): the floating point dtype to make the default
Example::
>>> # initial default for floating point is torch.float32
>>> torch.tensor([1.2, 3]).dtype
torch.float32
>>> # initial default for floating point is torch.complex64
>>> torch.tensor([1.2, 3j]).dtype
torch.complex64
>>> torch.set_default_dtype(torch.float64)
>>> torch.tensor([1.2, 3]).dtype # a new floating point tensor
torch.float64
>>> torch.tensor([1.2, 3j]).dtype # a new complex tensor
torch.complex128
"""
_C._set_default_dtype(d)
def _set_deterministic(d):
r"""Sets a global flag to force all operations to use a deterministic
implementation if available. If an operation that does not have a
deterministic implementation is called while this setting is True, the
operation will throw a RuntimeError.
Note that deterministic operations tend to have worse performance than
non-deterministic operations.
Args:
d (:class:`bool`): If True, force operations to be deterministic.
If False, allow non-deterministic operations.
.. warning::
This feature is experimental and not complete. The above docstring
represents what the future behavior is intended to be. Right now,
`_set_deterministic` will only affect `torch.bmm` and convolution
operators.
"""
_C._set_deterministic(d)
def _is_deterministic():
r"""Returns True if the global deterministic flag is turned on and
operations are being forced to use a deterministic implementation.
.. warning::
This feature is experimental and not complete. The above docstring
represents what the future behavior is intended to be. Right now,
the global deterministic flag will only affect `torch.bmm` and
convolution operators.
"""
return _C._get_deterministic()
# If you edit these imports, please update torch/__init__.py.in as well
from .random import set_rng_state, get_rng_state, manual_seed, initial_seed, seed
from .serialization import save, load
from ._tensor_str import set_printoptions
################################################################################
# Define Storage and Tensor classes
################################################################################
from .tensor import Tensor
from .storage import _StorageBase
class DoubleStorage(_C.DoubleStorageBase, _StorageBase):
pass
class FloatStorage(_C.FloatStorageBase, _StorageBase):
pass
class HalfStorage(_C.HalfStorageBase, _StorageBase):
pass
class LongStorage(_C.LongStorageBase, _StorageBase):
pass
class IntStorage(_C.IntStorageBase, _StorageBase):
pass
class ShortStorage(_C.ShortStorageBase, _StorageBase):
pass
class CharStorage(_C.CharStorageBase, _StorageBase):
pass
class ByteStorage(_C.ByteStorageBase, _StorageBase):
pass
class BoolStorage(_C.BoolStorageBase, _StorageBase):
pass
class BFloat16Storage(_C.BFloat16StorageBase, _StorageBase):
pass
class ComplexDoubleStorage(_C.ComplexDoubleStorageBase, _StorageBase):
pass
class ComplexFloatStorage(_C.ComplexFloatStorageBase, _StorageBase):
pass
class QUInt8Storage(_C.QUInt8StorageBase, _StorageBase):
pass
class QInt8Storage(_C.QInt8StorageBase, _StorageBase):
pass
class QInt32Storage(_C.QInt32StorageBase, _StorageBase):
pass
_storage_classes = {
DoubleStorage, FloatStorage, LongStorage, IntStorage, ShortStorage,
CharStorage, ByteStorage, HalfStorage, BoolStorage, QUInt8Storage, QInt8Storage,
QInt32Storage, BFloat16Storage, ComplexFloatStorage, ComplexDoubleStorage
}
# The _tensor_classes set is initialized by the call to _C._initialize_tensor_type_bindings()
_tensor_classes: Set[Type] = set()
################################################################################
# Initialize extension
################################################################################
def manager_path():
if platform.system() == 'Windows':
return b""
path = get_file_path('torch', 'bin', 'torch_shm_manager')
prepare_multiprocessing_environment(get_file_path('torch'))
if not os.path.exists(path):
raise RuntimeError("Unable to find torch_shm_manager at " + path)
return path.encode('utf-8')
# Shared memory manager needs to know the exact location of manager executable
_C._initExtension(manager_path())
del manager_path
# Appease the type checker: it can't deal with direct setting of globals().
# Note that we will see "too many" functions when reexporting this way; there
# is not a good way to fix this problem. Perhaps, try to redesign VariableFunctions
# so that this import is good enough
if False:
from torch._C._VariableFunctions import *
for name in dir(_C._VariableFunctions):
if name.startswith('__'):
continue
globals()[name] = getattr(_C._VariableFunctions, name)
__all__.append(name)
################################################################################
# Import interface functions defined in Python
################################################################################
# needs to be after the above ATen bindings so we can overwrite from Python side
from .functional import *
################################################################################
# Remove unnecessary members
################################################################################
del DoubleStorageBase
del FloatStorageBase
del LongStorageBase
del IntStorageBase
del ShortStorageBase
del CharStorageBase
del ByteStorageBase
del BoolStorageBase
del QUInt8StorageBase
del BFloat16StorageBase
del ComplexDoubleStorageBase
del ComplexFloatStorageBase
################################################################################
# Import most common subpackages
################################################################################
import torch.cuda
import torch.autograd
from torch.autograd import no_grad, enable_grad, set_grad_enabled
import torch.futures
import torch.nn
import torch.nn.intrinsic
import torch.nn.quantized
import torch.optim
import torch.multiprocessing
import torch.sparse
import torch.utils.backcompat
import torch.onnx
import torch.jit
import torch.hub
import torch.random
import torch.distributions
import torch.testing
import torch.backends.cuda
import torch.backends.mkl
import torch.backends.mkldnn
import torch.backends.openmp
import torch.backends.quantized
import torch.quantization
import torch.utils.data
import torch.__config__
import torch.__future__
_C._init_names(list(torch._storage_classes))
# attach docstrings to torch and tensor functions
from . import _torch_docs, _tensor_docs, _storage_docs
del _torch_docs, _tensor_docs, _storage_docs
def compiled_with_cxx11_abi():
r"""Returns whether PyTorch was built with _GLIBCXX_USE_CXX11_ABI=1"""
return _C._GLIBCXX_USE_CXX11_ABI
# Import the ops "namespace"
from torch._ops import ops
from torch._classes import classes
# Import the quasi random sampler
import torch.quasirandom
# If you are seeing this, it means that this call site was not checked if
# the memory format could be preserved, and it was switched to old default
# behaviour of contiguous
legacy_contiguous_format = contiguous_format
# Register fork handler to initialize OpenMP in child processes (see gh-28389)
from torch.multiprocessing._atfork import register_after_fork
register_after_fork(torch.get_num_threads)
del register_after_fork
# Import tools that require fully imported torch (for applying
# torch.jit.script as a decorator, for instance):
from ._lobpcg import lobpcg
# These were previously defined in native_functions.yaml and appeared on the
# `torch` namespace, but we moved them to c10 dispatch to facilitate custom
# class usage. We add these lines here to preserve backward compatbility.
quantized_lstm = torch.ops.aten.quantized_lstm
quantized_gru = torch.ops.aten.quantized_gru
|
[
"zhujiangmail@hotmail.com"
] |
zhujiangmail@hotmail.com
|
a19137e2bc295d4d4e9c77c15d61e3a9e4d708f9
|
ff20661ef00b2db927c78f95a08cd6c40f950ee0
|
/inputmorethanone.py
|
81994128fa875ec38b52ef7cf8ec19866fc7810f
|
[] |
no_license
|
Techsrijan/mppython2021
|
57ca26e1acdf5adad2afa692dd5ae23336273603
|
583a991f85e2414c6b8ffe0405f727f3f5d38eee
|
refs/heads/main
| 2023-06-18T22:05:44.602220
| 2021-07-16T00:42:26
| 2021-07-16T00:42:26
| 374,290,977
| 0
| 9
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 231
|
py
|
'''f=int(input("Enter the first number"))
s=int(input("Enter the Second number"))
'''
f,s=input("Enter two number").split(',')
print("F=",f,"S=",s)
j,k=input("Enter two number").split(' ')
print("j=",j,"k=",k)
print("add=",j+k)
|
[
"aswanibtech@gmail.com"
] |
aswanibtech@gmail.com
|
9436483bd9dce7f9bd3c1c1c7e5b4682ce2f8b80
|
e357f337ef80487aa6fafacb3e61cd5b56c78b60
|
/src/verification/__init__.py
|
9c7d02b050afd632c953e658bd2ee2c42fdd8642
|
[] |
no_license
|
kaleissin/django-verification
|
1537b7e78a8ca07a091bcad5fd014a4544809ba5
|
33f7d0b7d9cc1494269f16b6f07f6077ca974fff
|
refs/heads/master
| 2021-07-15T20:12:43.628199
| 2021-07-05T11:43:39
| 2021-07-05T13:08:50
| 18,205,426
| 12
| 2
| null | 2021-07-05T13:13:16
| 2014-03-28T08:19:41
|
Python
|
UTF-8
|
Python
| false
| false
| 60
|
py
|
default_app_config = 'verification.apps.VerificationConfig'
|
[
"kaleissin@gmail.com"
] |
kaleissin@gmail.com
|
ac8d8c76de9def04f8aad137f4e5827afd1ca93c
|
1d70ee049c5198b75567e0000c45ef879f6d39be
|
/JobMatchPonos/server/utils/word2vec/wordEmbeddings.py
|
7f5247842cca39719da0f18965c455959fc9dc9c
|
[] |
no_license
|
alexawl/Job-Match-Ponos-Back
|
95f28185f71c38733973bc6d730947455c2e6c93
|
c48b4bfddfbf2f4f5aa95409fd2c6ee4f469d9dd
|
refs/heads/master
| 2022-09-30T15:07:19.875016
| 2020-02-01T06:50:34
| 2020-02-01T06:50:34
| 237,575,072
| 0
| 0
| null | 2021-05-06T20:07:41
| 2020-02-01T06:49:35
|
Python
|
UTF-8
|
Python
| false
| false
| 4,009
|
py
|
from gensim.models import Word2Vec, KeyedVectors
from os import listdir
from os.path import isfile, join
import numpy as np
from scipy import spatial
from sklearn import decomposition
import matplotlib.pyplot as plt
from jobmatcher.server.utils.pattern import text
# def read_All_CV(filename):
# text = textract.process(filename)
# return text.decode('utf-8')
allText = " Chris Ware 789 E 901 N , Salt Lake City, UT 11111 E: cwse@fastmail.com P: 555-234-2345" \
"Professional Summary" \
"Experienced software engineer with a passion for developing innovative programs that expedite the efficiency and effectiveness of organizational success. Well-versed in technology and writing code to create systems that are reliable and user-friendly. Skilled leader who has the proven ability to motivate, educate, and manage a team of professionals to build software programs and effectively track changes. Confident communicator, strategic thinker, and innovative creator to develop software that is customized to meet a company’s organizational needs, highlight their core competencies, and further their success. " \
"Skills" \
"-Well-versed in software tools including HTML, JavaScript, CSS, BackBone and JQuery, among others. -Skilled at reading and writing code using viable inputs and outputs after accurate assessment of pre- and post-conditions. -Experienced at designing unit tests to measure the effectiveness of software programs, backend services, and user interfaces. -Confident problem-solving abilities to overcome glitches with creative solutions that are strategically designed to last long-term. -Strong communication skills and the ability to listen carefully to user feedback to determine modifications for optimal user-function." \
"Work Experience" \
"Software Engineer-April 2013 – present Rav Industries" \
"Developed and designed three critical software programs for financial tracking and reporting." \
"Optimized user effectiveness by creating a detailed feedback queue for users to discuss functionality, convenience, and effectiveness." \
"Oversee a team of four software developers and lead weekly discussions to brainstorm ideas in software development and to track changes made in existing programs." \
"Software Developer-February 2008 – April 2013 Brac Inc." \
"Participated in creating scalable systems for three primary departments, including human resources, marketing, and supply chain." \
"Ran monthly unit tests to determine software effectiveness and mend broken links or glitches in the system." \
"Gave quarterly reports to executive management regarding current developments, and tracked changes in existing software." \
"Education Internship2010-2011"\
"Estes Corp. Salt Lake City Utah Bachelor of Science 2010 in Computer Engineering 2010" \
"University of Utah Salt Lake City Utah"
def preprocess_training_data1():
s = text.parsetree('The cat sat on the mat.', relations=True, lemmata=True)
print(s)
# result = es.parsetree('The cat sat on the mat.', relations=True, lemmata=True)
#
# s = en.parse('The cat sat on the mat.', relations=True, lemmata=True)
#
#
#
# print(s)
# dircvs = [join(dir_cvs, f) for f in listdir(dir_cvs) if isfile(join(dir_cvs, f))]
# alltext = ' '
# for cv in dircvs:
# yd = read_All_CV(cv)
# alltext += yd + " "
# alltext = allText.lower()
# vector = []
# for sentence in es.parsetree(alltext, tokenize=True, lemmata=True, tags=True):
# temp = []
# for chunk in sentence.chunks:
# for word in chunk.words:
# if word.tag == 'NN' or word.tag == 'VB':
# temp.append(word.lemma)
# vector.append(temp)
# global model
# model = Word2Vec(vector, size=200, window=5, min_count=3, workers=4)
# # model.save(dir_model_name)
#
# print("model:")
# print(model)
|
[
"alexawl@bellsouth.net"
] |
alexawl@bellsouth.net
|
0fa20eaa5571bbbc09e2573aff18620152ed29dc
|
8f8d426ee581545cd3c58f9879305f6536a02426
|
/extractFramesEverySecond.py
|
d6cc95318f833a855b945a48b44f163a61dd46f9
|
[] |
no_license
|
tomtillo/video
|
bb0c0fabf93f804cf2e9bd7a6b2f781684a840d7
|
8be7eee7400fc3c5648e8eef90f14c667b7fc9c0
|
refs/heads/master
| 2020-06-11T20:32:44.092864
| 2019-06-27T11:35:43
| 2019-06-27T11:35:43
| 194,077,004
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,176
|
py
|
# ---------------------------- Function to get frames every second ( and not all the frames)
# Using tqdm to show progressbar
# Usage :extract_frames_every_second(videos1,OUT_DIR)
# Returns: times taken
import cv2
import math
import time
def extract_frames_every_second(video_file, output_folder):
import tqdm
t1= time.time()
cap = cv2.VideoCapture(video_file)
duration_seconds= cap.get(7) / cap.get(5)
pbar = tqdm.tqdm(total=duration_seconds)
ret = 1
frame_number = 1
frameRate = cap.get(5) # frame rate
while (ret):
frame_number += 1
frameId = cap.get(1) # current frame number
if (ret != True):
break
ret, frame = cap.read()
if (frameId % math.floor(frameRate) == 0):
pbar.update(1)
out_k2 = cv2.imwrite(output_folder + "im_" + str(frame_number) + ".jpg", frame)
cap.release()
t2 = time.time()
time_taken= t2-t1
return(time_taken)
# ----------------------------------- End Function ------------
videos1 = "./videos/video1.mp4"
OUT_DIR = "./output/"
t1 = extract_frames_every_second(videos1,OUT_DIR)
print("Time taken = %s " %(t1))
|
[
"noreply@github.com"
] |
tomtillo.noreply@github.com
|
ba3177e820dd8a4793158eb218326d48229866ef
|
bb372428bb90fa80f2e87820b3c8c5ba305dcd4c
|
/python/bot/eups.py
|
0e4812155219126d211b7dcd779287ab6d1ce9ec
|
[] |
no_license
|
TallJimbo/lsst-bot
|
7eb9b7a71a87a1ed416397c193931c80639bd746
|
0843afb2fdd5cc9ba62cf424a7dd73672b10e28f
|
refs/heads/master
| 2021-01-19T05:43:55.451321
| 2016-06-04T00:07:25
| 2016-06-04T00:07:25
| 60,484,354
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,534
|
py
|
#!/usr/bin/env python
from __future__ import absolute_import
import eups.table
import os
import logging
__all__ = "get_dependencies"
def get_dependencies(config, path, pkg, recursive=False):
"""Return immediate dependencies from inspecting a table file.
NOTE: recursive=True has not been tested.
"""
e = eups.Eups()
t = eups.table.Table(os.path.join(path, "ups", pkg + ".table"))
dependencies = t.dependencies(e, recursive=recursive)
if recursive:
dependencies.sort(key=lambda x: x[2])
for product, optional, depth in dependencies:
yield product.name, optional
def declare(config, path, pkg, version, tag_only=False):
e = eups.Eups()
if not tag_only:
logging.debug("Declaring {pkg} {version}.".format(pkg=pkg, version=version))
e.declare(productName=pkg, versionName=version, productDir=path)
for tmp in config.eups.tags:
tag = tmp.format(eups=config.eups)
logging.debug("Assigning tag {tag} to {pkg}.".format(pkg=pkg, tag=tag))
e.assignTag(tag, productName=pkg, versionName=version)
def undeclare(config, pkg, version):
e = eups.Eups()
e.undeclare(productName=pkg, versionName=version)
def setup(pkg, version, nodepend=False):
e = eups.Eups(max_depth=(0 if nodepend else -1))
e.setup(productName=pkg, versionName=version)
def tag(pkg, version, tag):
e = eups.Eups()
logging.debug("Assigning tag {tag} to {pkg}.".format(pkg=pkg, tag=tag))
e.assignTag(tag, productName=pkg, versionName=version)
|
[
"jbosch@astro.princeton.edu"
] |
jbosch@astro.princeton.edu
|
b3aaed8088ac0f6dc6a87eed88943c27eea6fcb9
|
c9dd27f95f7a1a25963e0bd107a8fd72033c2168
|
/src/main.py
|
562ecf88d07a12c56bdfd8f9c24e342b1632865e
|
[] |
no_license
|
RamazanDemirci/pythonML
|
3f807c5ec8e8881fe04197c75c98010b2feb7095
|
86d7e9286f03f099f64bf39615a9ee8841e3c021
|
refs/heads/main
| 2023-02-02T02:55:40.429272
| 2020-12-27T13:42:00
| 2020-12-27T13:42:00
| 319,462,234
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 62
|
py
|
if __name__ == "__main__":
print("Program Entry Point")
|
[
"radem18@gmail.com"
] |
radem18@gmail.com
|
f5762a0a3bcd4f5ba6d65173ea4d994aece629be
|
1eb73b6d3801156620cad8707ab9fe70baca3e7c
|
/library/writer.py
|
edf9aa2fa31712f34a5cb3209693bb4a227c47d2
|
[
"MIT"
] |
permissive
|
santiago26/vk4xmpp
|
732b75ef0a2a4c86d7d704da888e9be76953ec68
|
369f2550f2b422e6d27f06679ddda8ecd7cae026
|
refs/heads/master
| 2021-01-16T19:22:26.318690
| 2013-09-28T11:37:05
| 2013-09-28T11:37:05
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,194
|
py
|
# /* encoding: utf-8 */
# © simpleApps, 2010
import os, sys, time, logging, traceback
logger = logging.getLogger("vk4xmpp")
fixme = lambda msg: Print("\n#! fixme: \"%s\"." % msg)
lastErrorBody = None
def wFile(filename, data, mode = "w"):
with open(filename, mode, 0) as file:
file.write(data)
def rFile(filename):
with open(filename, "r") as file:
return file.read()
def crashLog(name, text = 0, fixMe = True):
global lastErrorBody
logger.error("writing crashlog %s" % name)
if fixMe:
fixme(name)
try:
File = "crash/%s.txt" % name
if not os.path.exists("crash"):
os.makedirs("crash")
exception = wException(True)
if exception not in ("None", lastErrorBody):
Timestamp = time.strftime("| %d.%m.%Y (%H:%M:%S) |\n")
wFile(File, Timestamp + exception + "\n", "a")
lastErrorBody = exception
except:
fixme("crashlog")
wException()
def Print(text, line = True):
try:
if line:
print text
else:
sys.stdout.write(text)
sys.stdout.flush()
except (IOError, OSError):
pass
def wException(File = False):
try:
exception = traceback.format_exc().strip()
if not File:
Print(exception)
return exception
except (IOError, OSError):
pass
|
[
"mrdoctorwho@gmail.com"
] |
mrdoctorwho@gmail.com
|
924236479976a262f093bcadbe5e2db823bb810b
|
a6aada9cb93cc23bd17e4213c7a0b5114905a34a
|
/introduction/lab6.py
|
fed0db889f02668cb3f0910318040399a0aece3a
|
[] |
no_license
|
SethKwashie/PythonLabs
|
90caf6a4fc5159536a892c84245b26bab4e48fbd
|
0a9578ce2f09fbec5ab0f1accb1e0d10f7792117
|
refs/heads/main
| 2023-01-04T12:57:54.497264
| 2020-11-02T14:46:18
| 2020-11-02T14:46:18
| 307,773,931
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 268
|
py
|
age = int(input("Enter your age >>> "))
total = 0
start = 1
while start <= age:
total += start
start +=1
month = total * 12
days = total * 365
hours = total * 8760
print(f"{total} years ----> {month} months ----> {days} days ----> {hours} hours")
|
[
"seth.kwashie@turntabl.io"
] |
seth.kwashie@turntabl.io
|
88a1436030cb0e0d641a755da900e1e5e1086035
|
d123e83108ffb222a2bceb57e4dcd5d7fd2b5b41
|
/api/controllers/jobscheduling/build/config.gypi
|
b4e5770be03aa67be34c86283b682796d7fe765f
|
[] |
no_license
|
ajaxtream/smart2
|
0aede425b17f8666750427e4a89e3817995e43b5
|
7701b98d66f3da201e096eee43a0724c9a494dd1
|
refs/heads/master
| 2021-01-10T14:58:08.529403
| 2015-12-16T04:42:33
| 2015-12-16T04:42:33
| 48,087,021
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,517
|
gypi
|
# Do not edit. File was generated by node-gyp's "configure" step
{
"target_defaults": {
"cflags": [],
"default_configuration": "Release",
"defines": [],
"include_dirs": [],
"libraries": []
},
"variables": {
"clang": 1,
"host_arch": "x64",
"icu_data_file": "icudt54l.dat",
"icu_data_in": "../../deps/icu/source/data/in/icudt54l.dat",
"icu_endianness": "l",
"icu_gyp_path": "tools/icu/icu-generic.gyp",
"icu_locales": "en,root",
"icu_path": "./deps/icu",
"icu_small": "true",
"icu_ver_major": "54",
"node_install_npm": "true",
"node_prefix": "",
"node_shared_cares": "false",
"node_shared_http_parser": "false",
"node_shared_libuv": "false",
"node_shared_openssl": "false",
"node_shared_v8": "false",
"node_shared_zlib": "false",
"node_tag": "",
"node_use_dtrace": "true",
"node_use_etw": "false",
"node_use_mdb": "false",
"node_use_openssl": "true",
"node_use_perfctr": "false",
"openssl_no_asm": 0,
"python": "/usr/bin/python",
"target_arch": "x64",
"uv_library": "static_library",
"uv_parent_path": "/deps/uv/",
"uv_use_dtrace": "true",
"v8_enable_gdbjit": 0,
"v8_enable_i18n_support": 1,
"v8_no_strict_aliasing": 1,
"v8_optimized_debug": 0,
"v8_random_seed": 0,
"v8_use_snapshot": "false",
"want_separate_host_toolset": 0,
"nodedir": "/Users/stream/.node-gyp/0.12.7",
"copy_dev_lib": "true",
"standalone_static_library": 1
}
}
|
[
"noEmail@anonymous.com"
] |
noEmail@anonymous.com
|
389f4af608abd72b7016e5c50c3de3b32f56bf4e
|
394e0b00b35c61f7f9c2d34b11cb6aa29f6a1eb5
|
/Used_Others/CRT-Button/g.log.py
|
0946926cce66bb3bd59dc504aa9555cffe710af9
|
[] |
no_license
|
congzheng-git/myProject
|
ecca28eafb129e014981b6fc74d4f8362ea3386b
|
da4cac92d87520d20036513616609bbffe9d9bef
|
refs/heads/master
| 2022-12-18T02:40:21.425117
| 2020-07-01T07:33:38
| 2020-07-01T07:33:38
| 207,499,868
| 0
| 0
| null | 2022-12-08T01:49:32
| 2019-09-10T08:03:20
|
Python
|
UTF-8
|
Python
| false
| false
| 311
|
py
|
# $language = "Python"
# $interface = "1.0"
import signal
def main():
crt.Screen.Send('\x03')
crt.Sleep(200)
crt.Screen.Send('cd ../../../opt/jelly_current/logs/' + '\r')
id = crt.Dialog.Prompt("输入要查的ID")
crt.Screen.Send('tail -f out.log |grep ' + id + '\r')
main()
|
[
"cczz1226@sina.com"
] |
cczz1226@sina.com
|
31a96cf391d906b0d3d59fcd37437e16f21f474b
|
fd326562890d4f1987c384fc7c60374938231222
|
/OOP/ExamPrep/Exam10April21/project/decoration/ornament.py
|
90d7980c034613da08f4ee857bf726562ac89427
|
[] |
no_license
|
miro-lp/SoftUni
|
cc3b0ff742218c9ceaf93f05c319ccfeed5bc8a4
|
283d9328537919de49f7f6a301e58593bae9ca2a
|
refs/heads/main
| 2023-08-23T21:22:07.856226
| 2021-08-25T15:10:18
| 2021-08-25T15:10:18
| 318,134,101
| 2
| 1
| null | 2021-08-10T12:51:54
| 2020-12-03T09:03:08
|
Python
|
UTF-8
|
Python
| false
| false
| 151
|
py
|
from project.decoration.base_decoration import BaseDecoration
class Ornament(BaseDecoration):
def __init__(self):
super().__init__(1, 5)
|
[
"miro_lp@abv.bg"
] |
miro_lp@abv.bg
|
4e6eca2f88c65a14f8f7950765320058fffc7784
|
6cd24d192fe83e2d4a23b2d7f2fe0c038940a5d9
|
/trip/models.py
|
c05e3e881cdb57c13e1a086d6c7b5744615c8a64
|
[] |
no_license
|
nabeelakhtar20/trip_app_sample
|
d5370864ae0c872b0bc24bd9c47361c2fcae413c
|
ae6ab820d9a39fa4072267f09349b2c0d794b979
|
refs/heads/master
| 2022-05-18T03:30:03.315671
| 2019-10-13T12:06:58
| 2019-10-13T12:06:58
| 214,809,376
| 1
| 0
| null | 2022-04-22T22:32:11
| 2019-10-13T11:38:27
|
Python
|
UTF-8
|
Python
| false
| false
| 1,491
|
py
|
from datetime import datetime
from neomodel import StringProperty, StructuredNode, RelationshipTo, \
IntegerProperty, DateTimeProperty, UniqueIdProperty, JSONProperty, DateProperty
from auth.models import User
class Trip(StructuredNode):
uid = UniqueIdProperty()
destination = StringProperty()
start_date = DateProperty()
end_date = DateProperty()
adults = IntegerProperty()
infants = IntegerProperty()
estimated_budget_start = IntegerProperty()
estimated_budget_end = IntegerProperty()
events = JSONProperty()
creation_date = DateTimeProperty(default=datetime.now())
last_updated = DateTimeProperty(default=datetime.now())
user = RelationshipTo(User, 'PLANNED_BY')
@property
def serialize(self):
return {
'node_properties': {
"id": self.uid,
"destination": self.destination,
"start_date": self.start_date,
"end_date": self.end_date,
"adults": self.adults,
"infants": self.infants,
"estimated_budget_start": self.estimated_budget_start,
"estimated_budget_end": self.estimated_budget_end,
"events": self.events,
},
}
@property
def serialize_connections(self):
return [
{
'nodes_type': 'User',
'nodes_related': self.serialize_relationships(self.user.all()),
},
]
|
[
"nabeel_akhtar20@hotmail.com"
] |
nabeel_akhtar20@hotmail.com
|
7dc8d99db40e13c4050036693a90c23d2732f5d1
|
6af90d24f1f081c1f1046346dc1c7cdb98bcaddb
|
/tests/django/run_unit_tests.py
|
9270e1793369a22bae93f3dd891a9bc5c60bb34c
|
[
"Apache-2.0"
] |
permissive
|
aolabNeuro/brain-python-interface
|
e4d8fd4682ed63611d44f83e7889f35a71a80b59
|
bc215d97fe95765c2bf40d1be793d6ffa83586d1
|
refs/heads/master
| 2023-08-18T09:53:24.212536
| 2023-08-17T21:22:01
| 2023-08-17T21:22:01
| 250,614,460
| 3
| 3
|
NOASSERTION
| 2023-09-08T16:44:08
| 2020-03-27T18:31:13
|
HTML
|
UTF-8
|
Python
| false
| false
| 240
|
py
|
from django.test.utils import get_runner
from django.conf import settings
from db.boot_django import boot_django
boot_django()
TestRunner = get_runner(settings)
test_runner = TestRunner()
failures = test_runner.run_tests(["tests/django"])
|
[
"leo.scholl@gmail.com"
] |
leo.scholl@gmail.com
|
70f76d0921495935a8af0e489fc2de27af2fdd67
|
0fb2607ba5dff6c86e806dd67ba16b158c68b7a3
|
/bellorest/takeaway/apps.py
|
8530766b1735e6d11564a7d76bae23c34f085d6f
|
[] |
no_license
|
shashankiit/Restaraunt-Mangement-System
|
204259b4b7c0dbd984f4d38dcdbbab39bef2ee02
|
8a246ff56023a04c996e7fcf0ffb7d9093de1446
|
refs/heads/main
| 2023-04-23T06:14:30.348021
| 2021-05-07T18:14:15
| 2021-05-07T18:14:15
| 358,109,274
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 148
|
py
|
from django.apps import AppConfig
class TakeawayConfig(AppConfig):
default_auto_field = 'django.db.models.BigAutoField'
name = 'takeaway'
|
[
"ambeloskar@iitb.ac.in"
] |
ambeloskar@iitb.ac.in
|
fad1fce49448f8fa4f4b57f21e6b48648aff90b7
|
282234bf6467224f769b67c923b111add740c775
|
/Course_2_Python_Data_Structures/ex_06_05/ex_06_05.py
|
82c9334e74a4ad3f1c8c105755813523c36f1ccb
|
[] |
no_license
|
gravitonGB/python_for_everybody
|
73d0767db1cf0c705144e287fba3fe66bc42ec43
|
8b3d197247bf52c66551867f2851d3006f7da484
|
refs/heads/master
| 2020-03-09T11:45:37.238749
| 2018-04-09T12:35:03
| 2018-04-09T12:35:03
| 128,765,513
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 197
|
py
|
#Exercise 6.5
#print("Excercise 6.5")
text = "X-DSPAM-Confidence: 0.8475";
pos = text.find(':')
t2 = text[pos+1:len(text)]
last_text = t2.strip()
last_value = float(last_text)
print(last_value)
|
[
"gokhanbegce@gmail.com"
] |
gokhanbegce@gmail.com
|
2725285e31284db439a824eacbd0d0ddf6681c04
|
7a6d30770cd56c2900aa7ef969b3ecfd679078a5
|
/WebGame/WebGame/game/classes/postgres.py
|
1dc642d5a3d31b85d596a939756c32fbda900e56
|
[] |
no_license
|
sherkd/zombiegame
|
519e1f7166e8e4ca192347682b2e55675757dff5
|
1438d2267ab2c615e14cf6e5d13525b38f7cb7a1
|
refs/heads/master
| 2020-06-14T12:54:40.043993
| 2017-01-05T12:24:31
| 2017-01-05T12:24:31
| 75,178,354
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,948
|
py
|
import psycopg2
import sys
class Postgres(object):
def __init__(self):
conn_string = "host='localhost' dbname='zombiegamers' user='postgres' password='project3'"
print("Connecting to database\n ->%s" % (conn_string))
self.connection = psycopg2.connect(conn_string)
self.cursor = self.connection.cursor()
def getConnection(self):
return self.connection
def createDatabase(self):
self.cursor.execute("CREATE TABLE Account(userid int NOT NULL, password varchar(255), username varchar(255), gender varchar(1), email varchar(255), birthday date, PRIMARY KEY(userid))")
self.cursor.execute("CREATE TABLE Player(userid int NOT NULL, health int, attack int , luck int, accuracy int, speed int, skillpoints int, weaponid int, FOREIGN KEY(userid) REFERENCES Account(userid))")
self.cursor.execute("CREATE TABLE Weapon(weaponid int NOT NULL, name varchar(255), class varchar(255), description varchar(255), level int, damage int, PRIMARY KEY(weaponid))")
self.cursor.execute("CREATE TABLE Player_Weapon(userid int NOT NULL, weaponid int NOT NULL, FOREIGN KEY(userid) REFERENCES Account(userid), FOREIGN KEY(weaponid) REFERENCES Weapon(weaponid))")
def getAccount(self):
self.cursor.execute("SELECT * FROM Account WHERE userid='12'")
return self.cursor.fetchone()
def insertAccount(self):
try:
self.cursor.execute("INSERT INTO Account (userid, password, username, gender, email, birthday) Values(12, 'pass', 'user', 'm', 'user@gmail.com', '2000-10-10')")
self.connection.commit()
except:
self.connection.rollback()
def insertTestPlayer(self):
try:
self.cursor.execute("DELETE FROM Player WHERE userid = '12'")
self.connection.commit()
except:
self.connection.rollback()
try:
self.cursor.execute("INSERT INTO Player(userid, health, attack, luck, accuracy, speed, skillpoints, weaponid) VALUES(12, 100, 10, 5, 10, 10, 0, 12);")
self.connection.commit()
except:
self.connection.rollback()
def getTestPlayer(self):
self.cursor.execute("SELECT * FROM Player WHERE userid='12'")
return self.cursor.fetchone()
def insertWeapon(self, weapon):
id = random.randint(0, 1000)
try:
self.cursor.execute("INSERT INTO Weapon (userid, name, class, description, level, damage) VALUES (" + str(id) + "," + weapon.getName() + "," + weapon.getClass() + "," + weapon.getDescription() + "," + str(weapon.getLevel()) + "," + str(weapon.getDamage()) + ")")
self.connection.commit()
except:
self.connection.rollback()
def getWeapon(self):
print(self.cursor.execute("SELECT * FROM Weapon WHERE userid='12'"))
def getWeapon(self, id):
pass
def getWeapons(self, username):
pass
|
[
"sivarwerrie@hotmail.nl"
] |
sivarwerrie@hotmail.nl
|
fbcf2fca48d9207fd6d531d83f43f44da2312148
|
0120813c649236fcb4732723c4b25f6538de04fb
|
/Image Stitching/Source/main.py
|
a232db81366c8c7dc347f44a463ca2d9345047ab
|
[] |
no_license
|
shubh0906/Computer-Vision
|
47f1e8e55f54138acd070f5f39b722b17a5747b2
|
e83bd827f1ed9de9218af5e973e69510d826d100
|
refs/heads/master
| 2021-01-25T11:15:36.124527
| 2018-03-06T09:01:35
| 2018-03-06T09:01:35
| 123,387,519
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 12,840
|
py
|
# Instructions:
# Do not change the output file names, use the helper functions as you see fit
import os
import sys
import cv2
import numpy as np
import matplotlib.pyplot as plt
import math
def help_message():
print("Usage: [Question_Number] [Input_Options] [Output_Options]")
print("[Question Number]")
print("1 Perspective warping")
print("2 Cylindrical warping")
print("3 Bonus perspective warping")
print("4 Bonus cylindrical warping")
print("[Input_Options]")
print("Path to the input images")
print("[Output_Options]")
print("Output directory")
print("Example usages:")
print(sys.argv[0] + " 1 " + "[path to input image1] " + "[path to input image2] " + "[path to input image3] " + "[output directory]")
'''
Detect, extract and match features between img1 and img2.
Using SIFT as the detector/extractor, but this is inconsequential to the user.
Returns: (pts1, pts2), where ptsN are points on image N.
The lists are "aligned", i.e. point i in pts1 matches with point i in pts2.
Usage example:
im1 = cv2.imread("image1.jpg", 0)
im2 = cv2.imread("image2.jpg", 0)
(pts1, pts2) = feature_matching(im1, im2)
plt.subplot(121)
plt.imshow(im1)
plt.scatter(pts1[:,:,0],pts1[:,:,1], 0.5, c='r', marker='x')
plt.subplot(122)
plt.imshow(im2)
plt.scatter(pts1[:,:,0],pts1[:,:,1], 0.5, c='r', marker='x')
'''
def feature_matching(img1, img2, savefig=False):
# Initiate SIFT detector
sift = cv2.xfeatures2d.SIFT_create()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(img1,None)
kp2, des2 = sift.detectAndCompute(img2,None)
# FLANN parameters
FLANN_INDEX_KDTREE = 1
index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
search_params = dict(checks=50) # or pass empty dictionary
flann = cv2.FlannBasedMatcher(index_params,search_params)
matches2to1 = flann.knnMatch(des2,des1,k=2)
matchesMask_ratio = [[0,0] for i in xrange(len(matches2to1))]
match_dict = {}
for i,(m,n) in enumerate(matches2to1):
if m.distance < 0.7*n.distance:
matchesMask_ratio[i]=[1,0]
match_dict[m.trainIdx] = m.queryIdx
good = []
recip_matches = flann.knnMatch(des1,des2,k=2)
matchesMask_ratio_recip = [[0,0] for i in xrange(len(recip_matches))]
for i,(m,n) in enumerate(recip_matches):
if m.distance < 0.7*n.distance: # ratio
if m.queryIdx in match_dict and match_dict[m.queryIdx] == m.trainIdx: #reciprocal
good.append(m)
matchesMask_ratio_recip[i]=[1,0]
if savefig:
draw_params = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask = matchesMask_ratio_recip,
flags = 0)
img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,recip_matches,None,**draw_params)
plt.figure(),plt.xticks([]),plt.yticks([])
plt.imshow(img3,)
plt.savefig("feature_matching.png",bbox_inches='tight')
return ([ kp1[m.queryIdx].pt for m in good ],[ kp2[m.trainIdx].pt for m in good ])
'''
Warp an image from cartesian coordinates (x, y) into cylindrical coordinates (theta, h)
Returns: (image, mask)
Mask is [0,255], and has 255s wherever the cylindrical images has a valid value.
Masks are useful for stitching
Usage example:
im = cv2.imread("myimage.jpg",0) #grayscale
h,w = im.shape
f = 700
K = np.array([[f, 0, w/2], [0, f, h/2], [0, 0, 1]]) # mock calibration matrix
imcyl = cylindricalWarpImage(im, K)
'''
def cylindricalWarpImage(img1, K, savefig=False):
f = K[0,0]
im_h,im_w = img1.shape
# go inverse from cylindrical coord to the image
# (this way there are no gaps)
cyl = np.zeros_like(img1)
cyl_mask = np.zeros_like(img1)
cyl_h,cyl_w = cyl.shape
x_c = float(cyl_w) / 2.0
y_c = float(cyl_h) / 2.0
for x_cyl in np.arange(0,cyl_w):
for y_cyl in np.arange(0,cyl_h):
theta = (x_cyl - x_c) / f
h = (y_cyl - y_c) / f
X = np.array([math.sin(theta), h, math.cos(theta)])
X = np.dot(K,X)
x_im = X[0] / X[2]
if x_im < 0 or x_im >= im_w:
continue
y_im = X[1] / X[2]
if y_im < 0 or y_im >= im_h:
continue
cyl[int(y_cyl),int(x_cyl)] = img1[int(y_im),int(x_im)]
cyl_mask[int(y_cyl),int(x_cyl)] = 255
if savefig:
plt.imshow(cyl, cmap='gray')
plt.savefig("cyl.png",bbox_inches='tight')
return (cyl,cyl_mask)
'''
Calculate the geometric transform (only affine or homography) between two images,
based on feature matching and alignment with a robust estimator (RANSAC).
Returns: (M, pts1, pts2, mask)
Where: M is the 3x3 transform matrix
pts1 are the matched feature points in image 1
pts2 are the matched feature points in image 2
mask is a binary mask over the lists of points that selects the transformation inliers
Usage example:
im1 = cv2.imread("image1.jpg", 0)
im2 = cv2.imread("image2.jpg", 0)
(M, pts1, pts2, mask) = getTransform(im1, im2)
# for example: transform im1 to im2's plane
# first, make some room around im2
im2 = cv2.copyMakeBorder(im2,200,200,500,500, cv2.BORDER_CONSTANT)
# then transform im1 with the 3x3 transformation matrix
out = cv2.warpPerspective(im1, M, (im1.shape[1],im2.shape[0]), dst=im2.copy(), borderMode=cv2.BORDER_TRANSPARENT)
plt.imshow(out, cmap='gray')
plt.show()
'''
def getTransform(src, dst, method='affine'):
pts1,pts2 = feature_matching(src,dst)
src_pts = np.float32(pts1).reshape(-1,1,2)
dst_pts = np.float32(pts2).reshape(-1,1,2)
if method == 'affine':
M, mask = cv2.estimateAffine2D(src_pts, dst_pts, cv2.RANSAC, ransacReprojThreshold=5.0)
#M = np.append(M, [[0,0,1]], axis=0)
if method == 'homography':
M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
matchesMask = mask.ravel().tolist()
return (M, pts1, pts2, mask)
# ===================================================
# ================ Perspective Warping ==============
# ===================================================
def Perspective_warping(im1, im2, im3):
im1 = cv2.copyMakeBorder(im1,200,200,500,500, cv2.BORDER_CONSTANT)
(M, pts1, pts2, mask) = getTransform(im2, im1, 'homography')
out = cv2.warpPerspective(im2, M, (im1.shape[1],im1.shape[0]), dst=im1.copy(), borderMode=cv2.BORDER_TRANSPARENT)
(M, pts1, pts2, mask) = getTransform(im3, out, 'homography')
out = cv2.warpPerspective(im3, M, (out.shape[1],out.shape[0]), dst=out.copy(), borderMode=cv2.BORDER_TRANSPARENT)
output_image = out # This is dummy output, change it to your output
# Write out the result
output_name = sys.argv[5] + "output_homography.png"
cv2.imwrite(output_name, output_image)
imM = cv2.imread('example_output1.png', 0);
#print '---q1---', RMSD(1, out, imM);
return True
def Bonus_perspective_warping(img1, img2, img3):
# Write your codes here
output_image = img1 # This is dummy output, change it to your output
# Write out the result
output_name = sys.argv[5] + "output_homography_lpb.png"
cv2.imwrite(output_name, output_image)
return True
# ===================================================
# =============== Cynlindrical Warping ==============
# ===================================================
def Cylindrical_warping(im1, im2, im3):
f = 500
h,w = im1.shape
K = np.array([[f, 0, w/2], [0, f, h/2], [0, 0, 1]]) # mock calibration matrix
im1, k1 = cylindricalWarpImage(im1, K)
h,w = im2.shape
K = np.array([[f, 0, w/2], [0, f, h/2], [0, 0, 1]]) # mock calibration matrix
im2, k2 = cylindricalWarpImage(im2, K)
h,w = im3.shape
K = np.array([[f, 0, w/2], [0, f, h/2], [0, 0, 1]]) # mock calibration matrix
im3, k3 = cylindricalWarpImage(im3, K)
im1 = cv2.copyMakeBorder(im1, 50, 50, 300, 300, cv2.BORDER_CONSTANT)
(M1, pts1, pts2, mask) = getTransform(im2, im1)
(M2, pts1, pts2, mask) = getTransform(im3, im1)
out1 = cv2.warpAffine(im2, M1, (im1.shape[1],im1.shape[0]))
outM1 = cv2.warpAffine(k2, M1, (im1.shape[1],im1.shape[0]))
r,c = im1.shape
for i in xrange(r):
for j in xrange(c):
if outM1[i,j] == 255:
im1[i, j] = out1[i, j]
(M, pts1, pts2, mask) = getTransform(im3, im1)
out = cv2.warpAffine(im3, M2, (out1.shape[1],out1.shape[0]))
outM = cv2.warpAffine(k3, M2, (out1.shape[1],out1.shape[0]))
r,c = im1.shape
for i in xrange(r):
for j in xrange(c):
if outM[i,j] == 255:
im1[i, j] = out[i, j]
output_image = im1 # This is dummy output, change it to your output
# Write out the result
output_name = sys.argv[5] + "output_cylindrical.png"
cv2.imwrite(output_name, output_image)
imM = cv2.imread('example_output2.png', 0);
#print RMSD(2, im1, imM);
return True
'''# Write your codes here
output_image = img1 # This is dummy output, change it to your output
# Write out the result
output_name = sys.argv[5] + "output_cylindrical.png"
cv2.imwrite(output_name, output_image)
return True'''
def Bonus_cylindrical_warping(img1, img2, img3):
# Write your codes here
output_image = img1 # This is dummy output, change it to your output
# Write out the result
output_name = sys.argv[5] + "output_cylindrical_lpb.png"
cv2.imwrite(output_name, output_image)
return True
'''
This exact function will be used to evaluate your results for HW2
Compare your result with master image and get the difference, the grading
criteria is posted on Piazza
'''
'''def RMSD(target, master):
# Get width, height, and number of channels of the master image
master_height, master_width = master.shape[:2]
master_channel = len(master.shape)
# Get width, height, and number of channels of the target image
target_height, target_width = target.shape[:2]
target_channel = len(target.shape)
# Validate the height, width and channels of the input image
if (master_height != target_height or master_width != target_width or master_channel != target_channel):
return -1
else:
total_diff = 0.0;
master_channels = cv2.split(master);
target_channels = cv2.split(target);
for i in range(0, len(master_channels), 1):
dst = cv2.absdiff(master_channels[i], target_channels[i])
dst = cv2.pow(dst, 2)
mean = cv2.mean(dst)
total_diff = total_diff + mean[0]**(1/2.0)
return total_diff;'''
def RMSD(questionID, target, master):
# Get width, height, and number of channels of the master image
master_height, master_width = master.shape[:2]
master_channel = len(master.shape)
# Get width, height, and number of channels of the target image
target_height, target_width = target.shape[:2]
target_channel = len(target.shape)
# Validate the height, width and channels of the input image
if (master_height != target_height or master_width != target_width or master_channel != target_channel):
return -1
else:
nonZero_target = cv2.countNonZero(target)
nonZero_master = cv2.countNonZero(master)
if (questionID == 1):
if (nonZero_target < 1200000):
return -1
elif(questionID == 2):
if (nonZero_target < 700000):
return -1
else:
return -1
total_diff = 0.0;
master_channels = cv2.split(master);
target_channels = cv2.split(target);
for i in range(0, len(master_channels), 1):
dst = cv2.absdiff(master_channels[i], target_channels[i])
dst = cv2.pow(dst, 2)
mean = cv2.mean(dst)
total_diff = total_diff + mean[0]**(1/2.0)
return total_diff;
if __name__ == '__main__':
question_number = -1
# Validate the input arguments
if (len(sys.argv) != 6):
help_message()
sys.exit()
else:
question_number = int(sys.argv[1])
if (question_number > 4 or question_number < 1):
print("Input parameters out of bound ...")
sys.exit()
input_image1 = cv2.imread(sys.argv[2], 0)
input_image2 = cv2.imread(sys.argv[3], 0)
input_image3 = cv2.imread(sys.argv[4], 0)
function_launch = {
1 : Perspective_warping(input_image1, input_image2, input_image3),
2 : Cylindrical_warping(input_image1, input_image2, input_image3),
3 : Bonus_perspective_warping(input_image1, input_image2, input_image3),
4 : Bonus_cylindrical_warping(input_image1, input_image2, input_image3),
}
# Call the function
function_launch[question_number]()
|
[
"noreply@github.com"
] |
shubh0906.noreply@github.com
|
efc58d0b9b812e8507cfe77bd976ff7d1d82c672
|
342b0835ad165d8fcb647792e13440ed8d0579c0
|
/posts/views.py
|
e7bd842707ebd9559bd68fbdda4e6b4983a21463
|
[] |
no_license
|
Str8jckn/mb
|
a2d1df745840a7654bef179e4088b2964f0608bc
|
d64fd91397eb979ca85e7cabefe7c290c04434e2
|
refs/heads/master
| 2023-02-23T11:37:24.684042
| 2021-01-25T05:10:35
| 2021-01-25T05:10:35
| 332,100,152
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 421
|
py
|
from django.shortcuts import render
from django.views.generic import ListView
from .models import Post
from django.contrib import admin
from django.urls import path, include
class HomePageView(ListView):
model = Post
template_name = 'home.html'
context_object_name = 'all_posts_list'
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('posts.urls')), # new
]
# Create your views here.
|
[
"jaebrownjr@gmail.com"
] |
jaebrownjr@gmail.com
|
fb935ebf7929bf8547c110f220afd9dd747ddc54
|
a90792aec007ab37cdd7d21dfb5340a88b87132f
|
/shorten/views.py
|
41aca3353713eacb4762171447c1d714b33da29e
|
[] |
no_license
|
chetangargnitd/url_shortener
|
fee4b837c79b118bf1cfea3f80582c05326a0c3d
|
b94c1f83ac56e623fedb3e2ca211a9f2f5b35ff2
|
refs/heads/master
| 2021-06-24T04:20:27.291801
| 2019-06-17T14:22:18
| 2019-06-17T14:22:18
| 191,707,083
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,451
|
py
|
from __future__ import unicode_literals
from django.shortcuts import render
from django.shortcuts import redirect
from django.http import HttpResponse
from django.http import Http404
from django.shortcuts import get_object_or_404
from .models import URLs
import urllib
import hashlib
def home(request):
context = URLs.objects.order_by('-created')[:5]
return render(request, 'shorten/index.html', {'context' : context})
def shrink(request):
url = (request.GET["url"])
c_url = (request.GET["c_url"])
print(type(c_url))
encoded_url = url.encode('utf-8')
hashObject = hashlib.md5(encoded_url)
shrinked_url = hashObject.hexdigest()[:8]
context = URLs.objects.order_by('-created')[:5]
if(c_url == ""):
try:
check = URLs.objects.get(shrinked_url = shrinked_url)
except URLs.DoesNotExist:
entry = URLs(shrinked_url = shrinked_url, original_url = url)
entry.save()
return render(request, 'shorten/index.html', {'shrinked_url' : shrinked_url, 'context' : context})
else:
try:
check = URLs.objects.get(shrinked_url = c_url)
except URLs.DoesNotExist:
entry = URLs(shrinked_url = c_url, original_url = url)
entry.save()
return render(request, 'shorten/index.html', {'shrinked_url' : c_url, 'context' : context})
def retrieve(request, id):
target = get_object_or_404(URLs, shrinked_url = id)
targetURL = target.original_url
if(targetURL[:4] != 'http'):
targetURL = 'http://'+targetURL
return redirect(targetURL)
|
[
"chetangarg1102@gmail.com"
] |
chetangarg1102@gmail.com
|
aee5135a64857c7423190a714cc62b15b207d49f
|
9612da0b14b7e9f883a2ae50f00af87571bccabc
|
/Analyzer.py
|
2f1b4c07946a7828146daa3d16607d8aad4e94ea
|
[] |
no_license
|
andrewghaly/HandwrittenEstimation
|
e56bb5489b5833a515dff529e0f9172ed7c380db
|
97424d64a4b3ae784499d0bcf660797f056fc026
|
refs/heads/master
| 2021-01-23T03:27:17.421327
| 2017-03-24T14:45:44
| 2017-03-24T14:45:44
| 86,078,278
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,685
|
py
|
import cv2
import numpy as np
drawing_averages = []
for imageNumber in range(1,51):
img = cv2.imread('C:\\Users\\ghalya\\Pictures\\Hands\\Saunders_hand\\al_r_' + str(imageNumber) + '.png', 0)
if img is None:
print "Error loading image"
exit()
newImg = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
#cv2.imshow('Image', img)
# define the list of boundaries
boundaries = [
([151], [255]),
]
# loop over the boundaries
for (lower, upper) in boundaries:
# create NumPy arrays from the boundaries
lower = np.array(lower, dtype="uint8")
upper = np.array(upper, dtype="uint8")
#apply the mask
mask = cv2.inRange(img, lower, upper)
output = cv2.bitwise_and(img, img, mask=mask)
# show the images
#cv2.imshow("images", np.hstack([img, output]))
#cv2.imwrite('C:\Users\ghalya\Pictures\lol_testlulz.png', np.hstack([img, output]))
height, width = img.shape
points = 0
xSum = 0
ySum = 0
for i in range(0, width):
for j in range(0, height):
if img[j][i] <= 150:
points += 1
xSum += i
ySum += j
xAvg = xSum/points
yAvg = ySum/points
drawing_averages.append([xAvg, yAvg])
#print("xAvg: ", xAvg, " yAvg: ", yAvg)
cv2.circle(newImg, (xAvg, yAvg), 5, (0, 0, 255), -1)
#cv2.imshow("image", newImg)
#cv2.imwrite("C:\Users\ghalya\Pictures\genLEL.png", newImg)
cv2.waitKey(0)
print drawing_averages
count = xTotal = yTotal = 0
for i, j in drawing_averages:
xTotal += i
yTotal += j
count += 1
print "average:", xTotal/count, yTotal/count,
|
[
"ghalya@wit.edu"
] |
ghalya@wit.edu
|
588948095f2db1f4d431c649e77a76b72ecf54b8
|
68f57fd1dd274be72af6d85762b67bbf8d2ef6d6
|
/tests/test_cosine.py
|
3ac719652f889a7529befb8bcbf87a328c003cfa
|
[] |
no_license
|
afcarl/simplecosine
|
287cbf40ef8aa2251ea538b7b3c2d28c5b6f2488
|
1ba869198ab3211dd4b0412e80e670308007f687
|
refs/heads/master
| 2020-03-17T23:56:28.854494
| 2017-06-15T21:33:36
| 2017-06-15T21:33:36
| 134,069,251
| 1
| 0
| null | 2018-05-19T14:29:05
| 2018-05-19T14:29:05
| null |
UTF-8
|
Python
| false
| false
| 2,909
|
py
|
import unittest
from simplecosine.cosine import CosineSetSimilarity, CosineTextSimilarity
import numpy
import pickle
class TestSetCosineClass(unittest.TestCase):
def setUp(self):
self.ilist = [('a', 'b', 'c'),
['b', 'c', 'd k'],
('d k', 'e', 'f')
]
def test_cosine(self):
cosine = CosineSetSimilarity(self.ilist)
s1 = self.ilist[0]
s2 = self.ilist[1]
cosine_sim = cosine(s1, s2)
self.assertAlmostEqual(cosine_sim, 0.378, places=3)
cosine_sim = cosine(('g', 'h', 'd k', 'd k'), s2)
self.assertAlmostEqual(cosine_sim, 0.267, places=3)
def test_cosine_na(self):
cosine = CosineSetSimilarity(self.ilist)
cosine_sim = cosine(self.ilist[0], ())
assert numpy.isnan(cosine_sim)
def test_cosine_identical(self):
cosine = CosineSetSimilarity(self.ilist)
cosine_sim = cosine(self.ilist[0], self.ilist[0])
self.assertAlmostEqual(cosine_sim, 1, places=5)
def test_cosine_cache(self):
cosine = CosineSetSimilarity(self.ilist)
s1 = self.ilist[0]
s2 = self.ilist[1]
cosine_sim = cosine(s1, s2)
self.assertAlmostEqual(cosine_sim, 0.378, places=3)
cosine_sim = cosine(s1, s2)
self.assertAlmostEqual(cosine_sim, 0.378, places=3)
def test_cosine_no_corpus(self):
cosine = CosineSetSimilarity([])
s1 = self.ilist[0]
s2 = self.ilist[1]
cosine_sim = cosine(s1, s2)
self.assertAlmostEqual(cosine_sim, 0.667, places=3)
cosine_sim = cosine(('g', 'h', 'd k'), s2)
self.assertAlmostEqual(cosine_sim, 0.333, places=3)
def test_cosine_pickle(self) :
cosine = CosineSetSimilarity(self.ilist)
s1 = self.ilist[0]
s2 = self.ilist[1]
cosine_sim = cosine(s1, s2)
pickle.dumps(cosine)
cosine = CosineSetSimilarity([])
s1 = self.ilist[0]
s2 = self.ilist[1]
cosine_sim = cosine(s1, s2)
pickle.dumps(cosine)
class TestTextCosineClass(unittest.TestCase):
def setUp(self):
self.ilist = ['a b c',
'b c d',
'd e f']
def test_cosine(self):
cosine = CosineTextSimilarity(self.ilist)
s1 = self.ilist[0]
s2 = self.ilist[1]
cosine_sim = cosine(s1, s2)
self.assertAlmostEqual(cosine_sim, 0.378, places=3)
def test_cosine_na(self):
cosine = CosineTextSimilarity(self.ilist)
cosine_sim = cosine(self.ilist[0], '')
assert numpy.isnan(cosine_sim)
def test_cosine_identical(self):
cosine = CosineTextSimilarity(self.ilist)
cosine_sim = cosine(self.ilist[0], self.ilist[0])
self.assertAlmostEqual(cosine_sim, 1, places=5)
if __name__ == '__main__':
unittest.main()
|
[
"fgregg@uchicago.edu"
] |
fgregg@uchicago.edu
|
362e1c5d6c3bd62bae910a57c6d2f267d85924f0
|
6cf9b92459bb6bc5d9941728f9b0d697bd5db29f
|
/task.py
|
121bdbcc4864c0ce62df6fde1bfd892db04b2cf0
|
[] |
no_license
|
mehar13hamza13/competetive-learning-using-python
|
6eb2da2ab6ccdc17bc47e432a27e5582ddd5186c
|
f62f079c1facd7536c51fb4dad3e8edf867482c3
|
refs/heads/master
| 2023-06-24T22:22:41.173546
| 2021-07-27T15:55:52
| 2021-07-27T15:55:52
| 390,043,235
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,303
|
py
|
import numpy as np
class CompetetiveLearning():
def __init__(self, input_nodes, output_nodes):
self.input_nodes = input_nodes
self.output_nodes = output_nodes
#initializing random weights
self.weights = np.random.uniform(low=0.0, high=1.0, size=(output_nodes, input_nodes)).round(1)
def train(self, train_x):
print("----training for "+str(len(train_x))+" samples------")
clustering = {"A": [], "B": [], "C": []}
count = 1
for i in train_x:
print("Iteration "+str(count))
x = i.reshape((6, 1)) # reshaping the ith input value so matrix multiplication can be applied
result = np.matmul(self.weights, x) #multiplying wieghts with input nodes (w11X1 + w21X2 + ....)
winning_unit = result.argmax() # index with maximum value will be the winning unit (only row with these weights will be updated)
print("Output Values for Iteration "+str(count)+": ")
print(result)
print("Winning Unit: "+str(winning_unit+1))
print("Adjusting the weight for only row "+str(winning_unit+1))
self.adjust_weights(0.5, winning_unit, x)
clustering[list(clustering.keys())[winning_unit]].append("R"+str(count))
count+=1
self.print_final_weights()
print("\nFinal Cluster Results: ")
print(clustering)
def print_final_weights(self):
print("\nFinal Weights for Output P: ")
print(self.weights[0])
print("Final Weights for Output Q: ")
print(self.weights[1])
print("Final Weights for Output R: ")
print(self.weights[2])
def adjust_weights(self, learning_rate, row_no, inputs):
for i in range(len(self.weights[row_no])):
#adjusting the weights
self.weights[row_no][i] = self.weights[row_no][i] + learning_rate*inputs[i]
#normalizing the weights
self.weights[row_no][i]/=2
def test(self, test_x):
print()
print("----testing for " + str(len(test_x)) + " samples------")
print()
count = 1
classes = ["Class A", "Class B", "Class C"]
for i in test_x:
print("Iteration " + str(count))
x = i.reshape((6, 1)) # reshaping the ith input value so matrix multiplication can be applied
result = np.matmul(self.weights, x) # multiplying wieghts with input nodes (w11X1 + w21X2 + ....)
winning_unit = result.argmax() # index with maximum value will be the winning unit (only row with these weights will be updated)
print("Output Values for t" + str(count) + ": ")
print(result)
print("Winning Unit: " + str(winning_unit + 1))
print("t"+str(count)+" belongs to "+classes[winning_unit])
count += 1
cl = CompetetiveLearning(6, 3)
train_x = np.array([
[1, 0, 0, 0, 0, 0],
[1, 0, 0, 1, 0, 0],
[1, 0, 0, 0, 1, 0],
[0, 0, 1, 1, 0, 1],
[0, 0, 1, 1, 0, 1],
[0, 0, 1, 0, 0, 1],
[0, 1, 0, 0, 0, 1],
[0, 1, 0, 0, 0, 1],
[0, 1, 0, 0, 1, 1],
[1, 0, 0, 0, 0, 0]
])
test_x = np.array([
[0, 0, 1, 1, 1, 1],
[1, 0, 0, 0, 1, 1],
[0, 1, 0, 1, 0, 1]
])
cl.train(train_x)
cl.test(test_x)
|
[
"hassaanfarooq71@gmail.com"
] |
hassaanfarooq71@gmail.com
|
71099406ad6fc49075c14031a16a80c20794895f
|
a5315e8edc48c5fabcf6aaaa56de737d9594cddf
|
/deepc/modules/resnet.py
|
6e109cf6e94138f8dae8fb9e4efd2080ec7f1fd4
|
[] |
no_license
|
elirshabat/deepc-pytorch
|
efead7622d09c0c14f2b2c941cc7202e0278bbc8
|
c946ad55c5a8fedff1055f34b92b1a8e9cb3df2a
|
refs/heads/master
| 2020-03-23T01:41:05.212437
| 2018-11-06T07:31:50
| 2018-11-06T07:31:50
| 140,931,467
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 4,955
|
py
|
import torch
from torchvision import models
import torch.nn.init as init
import numpy as np
def initialize_weights(method='kaiming', *models):
for model in models:
for module in model.modules():
if isinstance(module, torch.nn.Conv2d) or isinstance(module, torch.nn.ConvTranspose2d) or isinstance(module, torch.nn.Linear):
if method == 'kaiming':
init.kaiming_normal(module.weight.data, np.sqrt(2.0))
elif method == 'xavier':
init.xavier_normal(module.weight.data, np.sqrt(2.0))
elif method == 'orthogonal':
init.orthogonal(module.weight.data, np.sqrt(2.0))
elif method == 'normal':
init.normal(module.weight.data,mean=0, std=0.02)
if module.bias is not None:
init.constant_(module.bias.data,0)
class GlobalConvolutionBlock(torch.nn.Module):
def __init__(self, in_channels, out_channels, k):
super().__init__()
super(GlobalConvolutionBlock, self).__init__()
self.left = torch.nn.Sequential(torch.nn.Conv2d(in_channels, out_channels, kernel_size=(k[0],1), padding=(k[0]//2,0)),
torch.nn.Conv2d(out_channels, out_channels, kernel_size=(1,k[1]), padding=(0,k[1]//2)))
self.right = torch.nn.Sequential(torch.nn.Conv2d(in_channels, out_channels, kernel_size=(1,k[1]), padding=(0,k[1]//2)),
torch.nn.Conv2d(out_channels, out_channels, kernel_size=(k[0],1), padding=(k[0]//2,0)))
def forward(self, x):
left = self.left(x)
right = self.right(x)
return left + right
class BoundaryRefine(torch.nn.Module):
def __init__(self, in_channels):
super(BoundaryRefine, self).__init__()
self.layer = torch.nn.Sequential(torch.nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1),
torch.nn.BatchNorm2d(in_channels),
torch.nn.ReLU(inplace=True),
torch.nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1),
torch.nn.BatchNorm2d(in_channels))
def forward(self, x):
convs = self.layer(x)
return x.expand_as(convs)+convs
class ResnetMIS(torch.nn.Module):
def __init__(self, pretrained_resnet=True, out_channels=3):
super().__init__()
resent = models.resnet101(pretrained=pretrained_resnet)
self.layer0 = torch.nn.Sequential(resent.conv1, resent.bn1, resent.relu, resent.maxpool)
self.layer1 = resent.layer1
self.layer2 = resent.layer2
self.layer3 = resent.layer3
self.layer4 = resent.layer4
# Assuming input of size 240x320
self.gcn256 = GlobalConvolutionBlock(256, out_channels, (59, 79))
self.br256 = BoundaryRefine(out_channels)
self.gcn512 = GlobalConvolutionBlock(512, out_channels, (29, 39))
self.br512 = BoundaryRefine(out_channels)
self.gcn1024 = GlobalConvolutionBlock(1024, out_channels, (13, 19))
self.br1024 = BoundaryRefine(out_channels)
self.gcn2048 = GlobalConvolutionBlock(2048, out_channels, (7, 9))
self.br2048 = BoundaryRefine(out_channels)
self.br1 = BoundaryRefine(out_channels)
self.br2 = BoundaryRefine(out_channels)
self.br3 = BoundaryRefine(out_channels)
self.br4 = BoundaryRefine(out_channels)
self.br5 = BoundaryRefine(out_channels)
self.activation = torch.nn.Sigmoid()
self.deconv1 = torch.nn.ConvTranspose2d(out_channels, out_channels, 2, stride=2)
self.deconv2 = torch.nn.ConvTranspose2d(out_channels, out_channels, 2, stride=2)
initialize_weights(self.gcn256, self.gcn512, self.gcn1024, self.gcn2048,
self.br5, self.br4, self.br3, self.br2, self.br1,
self.br256, self.br512, self.br1024, self.br2048,
self.deconv1, self.deconv2)
def forward(self, x):
x = self.layer0(x)
layer1 = self.layer1(x)
layer2 = self.layer2(layer1)
layer3 = self.layer3(layer2)
layer4 = self.layer4(layer3)
enc1 = self.br256(self.gcn256(layer1))
enc2 = self.br512(self.gcn512(layer2))
enc3 = self.br1024(self.gcn1024(layer3))
enc4 = self.br2048(self.gcn2048(layer4))
dec1 = self.br1(torch.nn.functional.interpolate(enc4, size=enc3.size()[2:], mode='bilinear') + enc3)
dec2 = self.br2(torch.nn.functional.interpolate(dec1, size=enc2.size()[2:], mode='bilinear') + enc2)
dec3 = self.br3(torch.nn.functional.interpolate(dec2, size=enc1.size()[2:], mode='bilinear') + enc1)
dec4 = self.br4(self.deconv1(dec3))
score_map = self.br5(self.deconv2(dec4))
return self.activation(score_map)
|
[
"shabat.eliran@gmail.com"
] |
shabat.eliran@gmail.com
|
40c87a8686a9baae4fa8aeedbe59625b342a5fff
|
485384a2e1faa338d3372a8c000ccab6f6891cfa
|
/CGAT/Mali.py
|
6337aeb47d18672ec25b144ac94a69699dfb9d3a
|
[
"BSD-2-Clause"
] |
permissive
|
wangzhennan14/cgat
|
30c8ec4f8d1e14413c5d8193352348137d60a611
|
38ff24edc2a1f8b0da5716aea4fbf6a9328342b0
|
refs/heads/master
| 2021-01-18T15:43:02.544097
| 2017-03-16T15:27:11
| 2017-03-16T15:27:11
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 44,924
|
py
|
'''
Mali.py - Tools for multiple alignments
=======================================
:Author: Andreas Heger
:Release: $Id$
:Date: |today|
:Tags: Python
Code
----
'''
import re
import string
import math
import copy
import random
class AlignedString:
mGapChars = ("-", ".")
mGapChar = "-"
def __init__(self, identifier, fr, to, s, is_mangled=False):
self.mId = identifier
self.mFrom = fr
self.mTo = to
self.mString = s
self.mIsMangled = is_mangled
def __len__(self):
return len(self.mString)
def maskColumn(self, column, mask_char="x"):
self.maskColumns(self, [column, ], mask_char=mask_char)
def maskColumns(self, columns, mask_char="x"):
s = list(self.mString)
for c in columns:
if s[c] not in self.mGapChars:
s[c] = mask_char
self.mString = "".join(s)
def mapColumns(self, columns, map_function):
s = list(self.mString)
for c in columns:
if s[c] not in self.mGapChars:
s[c] = map_function(s[c])
self.mString = "".join(s)
def takeColumns(self, columns):
"""take columns.
not implemented yet: updating of residue numbers.
"""
s = []
for c in columns:
s.append(self.mString[c])
self.mString = "".join(s)
def truncate(self, first, last):
"""truncate aligned string.
not implemented yet: updating of residue numbers.
"""
self.mString = self.mString[first:last]
def insertColumns(self, position, num_columns, char="-"):
"""insert num_columns columns at position."""
self.mString = self.mString[:position] + \
char * num_columns + self.mString[position:]
def getIdentifier(self):
'''return demangled identifier.'''
if self.mIsMangled:
return self.mId.rsplit("_", 1)[0]
else:
return self.mId
def getResidueNumber(self, position):
x = self.mFrom
for c in self.mString[:position]:
if c not in self.mGapChars:
x += 1
return x
def getSequence(self):
"""return sequence without gaps."""
return re.sub("[%s]" % "".join(self.mGapChars), "", self.mString)
def getSegments(self, transitions, gap_chars="-."):
"""return segments of alignment according to
transitions.
Transitions is a list of residue numbers.
"""
segments = []
pos = self.mFrom
first_x = 0
for x in range(len(self.mString)):
char = self.mString[x]
if char not in gap_chars:
if pos in transitions:
if first_x != x:
segments.append((first_x, x))
first_x = x
pos += 1
# add last segment, unless it has already been added
# because it was part of the transitions
if first_x != x:
segments.append((first_x, len(self.mString)))
elif pos in transitions:
segments.append((first_x, len(self.mString)))
return segments
def threadSequence(self, new_sequence, map_old2new):
"""thread a new sequence onto this sequence replacing
characters in this sequence with those in new sequence.
``map_old2new`` lists the positions that should be replaced.
It maps non-gap positions in old to those in new. Non-gap
positions than are not mapped are set to :attr:`gapchar`.
"""
s = list(self.mString)
c = 0
for x in range(len(s)):
m = map_old2new.mapRowToCol(c)
if m >= 0:
s[c] = new_sequence[m]
else:
s[c] = self.mGapChar
if s[c] not in self.mGapChars:
c += 1
self.mString = "".join(s)
class MaliData:
def __init__(self, line, gap_chars="-.", mask_chars="Nn"):
self.mNGaps = len(re.sub("[^%s]" % gap_chars, "", line))
self.mNMasked = len(re.sub("[^%s]" % mask_chars, "", line))
self.mNAll = len(line)
self.mNChars = self.mNAll - self.mNMasked - self.mNGaps
def __str__(self):
return "%i\t%i\t%i\t%i" % (self.mNAll, self.mNChars,
self.mNGaps, self.mNMasked)
class Mali:
mGapChars = ("-", ".")
mGapPattern = re.compile("[.-]")
# character used for gaps
mGapChar = "-"
# admissable gap characters
mGapChars = ("-", ".")
mMaskChar = "X"
def __init__(self):
self.mIdentifiers = []
self.mMali = {}
self.mLength = 0
self.mAnnotations = {}
self.mName = None
# set to false, if ranges shall not be output.
self.mWriteRanges = True
def __contains__(self, key):
return key in self.mMali
def __getitem__(self, key):
return self.mMali[key].mString
def __len__(self):
return len(self.mIdentifiers)
def __delitem__(self, key):
del self.mMali[key]
self.mIdentifiers.remove(key)
def getClone(self):
return copy.deepcopy(self)
def iteritems(self):
return iter(self.mMali.items())
def items(self):
return list(self.mMali.items())
def values(self):
return list(self.mMali.values())
def keys(self):
return list(self.mMali.keys())
def getName(self):
return self.mName
def setName(self, name):
self.mName = name
def getIdentifiers(self):
return self.mIdentifiers
def getLength(self):
"""deprecated."""
return self.getNumSequences()
def getNumSequences(self):
return self.__len__()
def getNumColumns(self):
if self.mIdentifiers:
return len(self.mMali[self.mIdentifiers[0]])
else:
return 0
def getWidth(self):
"""deprecated."""
return self.getNumColumns()
def rename(self, old_name, new_name):
"""rename an entry."""
if old_name not in self.mMali:
raise KeyError("%s not in mali" % old_name)
self.mIdentifiers[self.mIdentifiers.index(old_name)] = new_name
self.mMali[new_name] = self.mMali[old_name]
del self.mMali[old_name]
def isEmpty(self):
return len(self.mMali) == 0
def getSequence(self, key):
return self.mMali[key]
def getResidueNumber(self, key, position):
"""return residue number in sequence key at position position."""
return self.mMali[key].getResidueNumber(position)
def setSequence(self, key, sequence):
# TODO: updating of residue numbers
self.mMali[key].mString = sequence
def getEntry(self, key):
return self.mMali[key]
def addEntry(self, s):
"""add an aligned string object."""
if s.mId in list(self.mMali.keys()):
raise KeyError("id %s already in mali" % s.mId)
self.mIdentifiers.append(s.mId)
self.mMali[s.mId] = s
def addSequence(self, id, fr, to, sequence):
if to < 0:
to = self.countCharacters(sequence)
s = AlignedString(id, fr, to, sequence)
self.addEntry(s)
def countCharacters(self, row):
return len(row) - len(self.mGapPattern.findall(row))
def deleteEntry(self, identifier):
if identifier not in self.mMali:
raise KeyError("identifier %s not in mali." % identifier)
del self.mMali[identifier]
self.mIdentifiers.remove(identifier)
def getColumns(self):
"""return mali in column orientation."""
args = [self.mMali[x].mString for x in self.mIdentifiers]
return ["".join(x) for x in zip(*args)]
def getConsensus(self, mark_with_gaps=False):
"""return consensus string.
The consensus string returns the most frequent character per column
that is not a gap.
If mark_with_gaps is set to True, positions with any gap characater are
set to gaps.
"""
columns = self.getColumns()
seq = []
for x in range(len(columns)):
s = columns[x]
counts = [(a, s.count(a))
for a in set(list(s)).difference(set(self.mGapChar))]
if mark_with_gaps and self.mGapChar in columns[x]:
seq.append(self.mGapChar)
else:
counts.sort(key=lambda x: -x[1])
seq.append(counts[0][0])
return "".join(seq)
def readFromFile(self, infile, format="fasta"):
"""read multiple alignment from file in various format."""
self.mMali = {}
self.mIdentifiers = []
pattern_parse_ranges = re.compile("(\S+)/(\d+)-(\d+)")
# read profiles - a profile possibly consists of several
# entries per file so treat it differently
if format.lower() == "profile":
while 1:
line = infile.readline()
if not line:
return False
if line[0] != "#":
break
if line[0] != ">":
raise "expected '>' at as first character in line %s" % line
try:
self.mName, length, width = re.match(
">profile=(\S+) length=(\d+) width=(\d+)", line).groups()
except AttributeError:
raise "could not parse header line %s" % line
width = int(width)
for x in range(0, width):
id = "seq%i" % x
self.mIdentifiers.append(id)
line = infile.readline()
if not line:
raise "expected %i sequences, only got %i" % (width, x)
self.mMali[id] = AlignedString(
id, 0, self.countCharacters(line[:-1]), line[:-1])
return True
if isinstance(infile, list) or \
isinstance(infile, tuple):
lines = infile
else:
lines = infile.readlines()
if format not in ("stockholm"):
# save comments
self.mComments = [x for x in lines if x[0] == "#"]
lines = [x for x in lines if x[0] != "#"]
else:
self.mComments = []
# remove empty lines
lines = [x for x in lines if x.strip()]
if not lines:
raise AttributeError("empty alignment")
def getId(id, s):
x = pattern_parse_ranges.match(id)
if x:
id, fr, to = x.groups()
fr, to = int(fr) - 1, int(to)
else:
fr, to = 0, self.countCharacters(s)
self.mWriteRanges = False
return id, fr, to
#######################################################################
if format.lower() == "plain":
for line in lines:
if not line.strip():
continue
data = line[:-1].split("\t")
id = data[3]
xid = id
x = 0
while xid in self.mMali:
xid = id + "-" + str(x)
x += 1
self.addEntry(
AlignedString(xid,
int(data[0]) - 1,
int(data[2]),
data[1]))
#######################################################################
elif format.lower() == "fasta":
pattern_identifier = "\S+"
id = None
fragments = []
for line in lines:
if line[0] == ">":
if id:
s = re.sub("\s", "", string.join(fragments, ""))
id, fr, to = getId(id, s)
self.addEntry(AlignedString(id, fr, to, s))
id = re.search(
"^(%s)" % pattern_identifier, line[1:-1]).group(0)
fragments = []
continue
fragments.append(line[:-1])
s = re.sub("\s", "", string.join(fragments, ""))
id, fr, to = getId(id, s)
self.addEntry(AlignedString(id, fr, to, s))
#######################################################################
elif format.lower() == "phylip":
nsequences, nchars = re.split("\s+", lines[0][:-1].strip())
nsequences = int(nsequences)
for line in lines[1:]:
l = line[:-1].strip()
if not l:
continue
id, sequence = re.match("(\S+)\s+(.*)", l).groups()
sequence = re.sub("\s", "", sequence)
if id not in self.mMali:
self.mIdentifiers.append(id)
self.mMali[id] = []
self.mMali[id].append(sequence)
for id, frags in list(self.mMali.items()):
s = "".join(frags)
fr, to = 0, self.countCharacters(s)
self.mMali[id] = AlignedString(id, fr, to, s)
#######################################################################
elif format.lower() == "clustal":
# skip header line
del lines[0]
fragments = {}
# prune lines
lines = [x.strip() for x in lines]
# remove empty lines
lines = [x for x in lines if len(x[:-1]) > 0]
for line in lines:
# remove consensus lines
if line[0] in ("*", ":"):
continue
data = re.split("\s+", line)
if len(data) != 2:
raise ValueError("parsing error in line %s" % line)
id, fragment = data
if id not in fragments:
fragments[id] = []
self.mIdentifiers.append(id)
fragments[id].append(fragment)
for id, f in list(fragments.items()):
s = re.sub("\s", "", string.join(f, ""))
self.mMali[id] = AlignedString(
id, 0, self.countCharacters(s), s)
elif format.lower() == "stockholm":
# skip header line
assert lines[0].startswith(
"# STOCKHOLM"), "file is not in stockholm format"
del lines[0]
fragments = {}
annotations = {}
# prune lines
lines = [x.strip() for x in lines]
# remove empty lines
lines = [x for x in lines if len(x[:-1]) > 0]
for line in lines:
data = re.split("\s+", line)
if data[0] == "//":
break
if line[0] == '#':
if data[0] == "#=GC":
id, fragment = data[1:3]
else:
self.mComments.append(line)
continue
if id not in annotations:
annotations[id] = []
annotations[id].append(fragment)
else:
if len(data) > 2:
raise ValueError("parsing error in line %s" % line)
elif len(data) == 1:
# treat empty alignments/lines
id = data[0]
fragment = ""
else:
id, fragment = data
if id not in fragments:
fragments[id] = []
self.mIdentifiers.append(id)
fragments[id].append(fragment)
n = []
for id in self.mIdentifiers:
f = fragments[id]
s = re.sub("\s", "", string.join(f, ""))
x = pattern_parse_ranges.match(id)
if x:
id, fr, to = x.groups()
fr, to = int(fr) - 1, int(to)
else:
fr, to = 0, self.countCharacters(s)
n.append(id)
self.mMali[id] = AlignedString(id, fr, to, s)
self.mIdentifiers = n
for id, f in list(annotations.items()):
s = re.sub("\s", "", string.join(f, ""))
annotations[id] = s
self.mAnnotations = annotations
else:
raise "unknown alignment format %s" % format
if len(self.mMali) == 0:
self.mLength = 0
else:
self.mLength = min(
[len(x.mString) for x in list(self.mMali.values())])
def writeToFile(self, outfile, write_ranges=True, format="plain",
options=None):
"""write alignment to file.
If options is given, these lines are output into the multiple
alignment.
"""
if format == "plain-fasta":
format = "fasta"
write_ranges = False
write_ranges = write_ranges and self.mWriteRanges
if format == "plain":
for identifier in self.mIdentifiers:
m = self.mMali[identifier]
outfile.write("%i\t%s\t%i\t%s\n" % (
m.mFrom + 1, m.mString, m.mTo, m.getIdentifier()))
elif format == "fasta":
for identifier in self.mIdentifiers:
m = self.mMali[identifier]
if write_ranges:
outfile.write(
">%s/%i-%i\n%s\n" % (m.getIdentifier(), m.mFrom + 1, m.mTo, m.mString))
else:
outfile.write(">%s\n%s\n" % (identifier, m.mString))
elif format == "stockholm":
outfile.write("# STOCKHOLM 1.0\n")
if options:
for o in options:
outfile.write("%s\n" % o)
# calculate offset:
max_l = 0
for identifier in self.mIdentifiers:
m = self.mMali[identifier]
id = m.getIdentifier()
# tab does not work as separator
if m.mTo and write_ranges:
x = "%s/%i-%i" % (id, m.mFrom + 1, m.mTo)
else:
x = "%s" % (id)
max_l = max(max_l, len(x))
for identifier in list(self.mAnnotations.keys()):
x = "#=GC %s" % identifier
max_l = max(max_l, len(x))
format = "%-" + str(max_l) + "s %s\n"
for identifier in self.mIdentifiers:
m = self.mMali[identifier]
id = m.getIdentifier()
# tab does not work as separator
if m.mTo and write_ranges:
x = "%s/%i-%i" % (id, m.mFrom + 1, m.mTo)
else:
x = "%s" % (id)
outfile.write(format % (x, m.mString))
for identifier, value in list(self.mAnnotations.items()):
x = "#=GC %s" % identifier
outfile.write(format % (x, value))
outfile.write("//\n")
elif format == "phylip":
outfile.write("%i %i\n" % (self.getLength(), self.getWidth()))
for identifier in self.mIdentifiers:
outfile.write("%s %s\n" %
(identifier, self.mMali[identifier].mString))
elif format.lower() == "profile":
if self.mName:
name = self.mName
else:
name = ",".join(self.mIdentifiers)
outfile.write(">profile=%s length=%i width=%i\n" %
(name, self.getWidth(), self.getLength()))
for identifier in self.mIdentifiers:
outfile.write("%s\n" % (self.mMali[identifier].mString))
elif format == "nexus":
# nexus formatted output - MrBayes conformant.
outfile.write("#NEXUS\n")
outfile.write("begin data;\n")
outfile.write(" dimensions ntax=%i nchar=%i;\n" %
(self.getLength(), self.getWidth()))
outfile.write(
" format datatype=dna interleave=no gap=%s;\n" % (self.mGapChar))
outfile.write(" matrix\n")
max_len = max([len(x) for x in self.mIdentifiers])
format = " %-" + str(max_len) + "s %s\n"
for identifier in self.mIdentifiers:
outfile.write(
format % (identifier, self.mMali[identifier].mString))
outfile.write(" ;\n")
outfile.write("end;\n")
else:
raise "unknown alignment format %s" % format
def removeUnalignedEnds(self):
"""remove unaligned ends in the multiple alignment.
unaligned ends correspond to lower-case characters.
"""
pattern_start = re.compile("^([- .a-z]+)")
pattern_unaligned = re.compile("[a-z]")
for s in list(self.mMali.values()):
first = pattern_start.match(s.mString)
if first:
first = first.groups()[0]
nchars = len(pattern_unaligned.findall(first))
s.mFrom += nchars
s.mString = self.mGapChar * len(first) + s.mString[len(first):]
# search from the back end by reversing. This is much faster than
# using $ from the back.
last = pattern_start.match(s.mString[::-1])
if last:
last = last.groups()[0]
nchars = len(pattern_unaligned.findall(last))
s.mTo -= nchars
l = len(s) - len(last)
s.mString = s.mString[:l] + self.mGapChar * l
def upperCase(self):
"""set all characters to upper case."""
for k, s in list(self.mMali.items()):
s.mString = s.mString.upper()
def lowerCase(self):
"""set all characters to lower case."""
for k, s in list(self.mMali.items()):
s.mString = s.mString.lower()
def removeEndGaps(self):
"""remove end gaps.
end gaps do not include any characters and thus
the alignment coordinates won't change.
"""
pattern_start_gaps = re.compile("^([- ]+)")
min_from = self.mLength
max_to = 0
for s in list(self.mMali.values()):
first = pattern_start_gaps.match(s.mString)
if first:
first = first.groups()[0]
min_from = min(min_from, len(first))
# search from the back end by reversing. This is much faster than
# using $ from the back.
last = pattern_start_gaps.search(s.mString[::-1])
if last:
last = last.groups()[0]
max_to = max(max_to, len(s) - len(last))
for s in list(self.mMali.values()):
s.mString = s.mString[min_from:max_to]
self.mLength = min([x.mString for x in list(self.mMali.values())])
def insertColumns(self, position, num_gaps, keep_fixed=None, char="-"):
"""insert gaps at position into multiple alignment.
if keep_constant is a list of identifiers, those are kept constant,
instead, gaps are added to the end.
"""
last_pos = min(self.getWidth(), position + num_gaps)
for id, seq in list(self.mMali.items()):
if keep_fixed and id in keep_fixed:
seq.insertColumns(last_pos, num_gaps, char)
else:
seq.insertColumns(position, num_gaps, char)
def removeGaps(self,
allowed_gaps=0,
minimum_gaps=1,
frame=1):
"""remove gappy columns.
allowed_gaps: number of gaps allowed for column to be kept
minimum_gaps: number of gaps for column to be removed
set minimum_gaps to the number of sequences to remove columns
with all gaps.
If frame is > 1 (3 most likely), then a whole codon is removed
as soon as there is one column to be removed.
"""
self.removePattern(
match_function=lambda x: x in self.mGapChars,
allowed_matches=allowed_gaps,
minimum_matches=minimum_gaps,
delete_frame=frame)
def removePattern(self,
match_function,
allowed_matches=0,
minimum_matches=1,
delete_frame=1,
search_frame=1):
"""remove columns (or group of columns), that match a certain pattern.
allowed_matches: number of matches allowed so that column is still kept
minimum_matches: number of matches required for column to be removed
set minimum_matches to the number of sequences to remove columns
with all gaps.
Patterns are matches in search_frame. For example, if frame is
3, whole codons are supplied to match_function.
delete_frame specifies the frame for deletion. If it is set to 3,
codons are removed if already one column matches.
Example: remove all columns that contain at least one stop-codon:
removePattern( lambda x: x.upper() in ("TAG", "TAA", "TGA"),
allowed_matches = 0,
minimum_matches = 1,
search_frame = 3,
delete_frame = 3)
"""
nmatches = [0] * self.getWidth()
for s in [x.mString for x in list(self.mMali.values())]:
for x in range(0, len(s), search_frame):
segment = s[x:x + search_frame]
if match_function(segment):
nmatches[x] += 1
columns = []
delete_columns = []
for x in range(len(nmatches)):
if nmatches[x] >= allowed_matches and nmatches[x] < minimum_matches:
columns.append(x)
else:
delete_columns.append(x)
if delete_frame != 1:
s = set(columns)
for x in delete_columns:
start = int(math.floor(float(x) / delete_frame) * delete_frame)
end = start + delete_frame
for c in range(start, end):
if c in s:
s.remove(c)
columns = list(s)
columns.sort()
self.takeColumns(columns)
def removeEmptySequences(self):
"""remove sequences that are completely empty.
"""
new_ids = []
for id in self.mIdentifiers:
if self.countCharacters(self.mMali[id].mString) == 0:
del self.mMali[id]
continue
new_ids.append(id)
self.mIdentifiers = new_ids
def upper(self):
"""convert all characters in mali to uppercase."""
for s in list(self.mMali.values()):
s.mString = s.mString.upper()
def lower(self):
"""convert all characters in mali to lowercase."""
for s in list(self.mMali.values()):
s.mString = s.mString.lower()
def shiftAlignment(self, map_id2offset):
"""shift alignment by offset."""
for identifier, m in list(self.mMali.items()):
if identifier in map_id2offset:
o = map_id2offset[identifier]
m.mFrom += o
m.mTo += o
def markCodons(self, mode="case"):
"""mark codons.
"""
for identifier, m in list(self.mMali.items()):
s = m.mString
if len(s) % 3 != 0:
raise "sequence %s not divisible by 3" % (m.mId)
is_upper = True
sequence = []
for x in range(0, len(s), 3):
if is_upper:
sequence.append(s[x:x + 3].upper())
is_upper = False
else:
sequence.append(s[x:x + 3].lower())
is_upper = True
m.mString = "".join(sequence)
def markTransitions(self, map_id2transitions, mode="case"):
"""mark transitions in the multiple alignment.
if mode == case, then upper/lower case is used for the transitions
Otherwise, a character given by mode is inserted.
"""
if mode in ("case", "keep-odd", "keep-even"):
# check, if the whole alignment needs to be masked/marked:
if "mali" in map_id2transitions:
transitions = map_id2transitions["mali"]
for identifier, s in list(self.mMali.items()):
new_chars = []
is_upper = True
is_first = False
for c in range(len(s)):
if c in transitions:
is_first = True
if is_upper:
is_upper = False
else:
is_upper = True
x = s.mString[c]
if mode == "case":
if x in string.lowercase:
x = self.mMaskChar
if is_upper:
x = string.upper(x)
else:
x = string.lower(x)
elif mode == "keep-even":
if is_upper:
x = self.mGapChar
elif mode == "keep-odd":
if not is_upper:
x = self.mGapChar
new_chars.append(x)
s.mString = "".join(new_chars)
# now do individual sequences
for identifier, s in list(self.mMali.items()):
if identifier not in map_id2transitions:
continue
new_chars = []
c = s.mFrom
is_upper = True
transitions = map_id2transitions[identifier]
for x in s.mString:
if x in self.mGapChars:
pass
else:
if c in map_id2transitions[identifier]:
if is_upper:
is_upper = False
else:
is_upper = True
c += 1
if x in string.lowercase:
x = self.mMaskChar
if mode == "case":
if is_upper:
x = string.upper(x)
else:
x = string.lower(x)
elif mode == "keep-even":
if is_upper:
x = self.mGapChar
elif mode == "keep-odd":
if not is_upper:
x = self.mGapChar
new_chars.append(x)
s.mString = "".join(new_chars)
else:
raise ValueError("character insertion not implemented yet")
def buildColumnMap(self, other, join_field=None):
"""build map of columns in other to this."""
if not join_field:
join_field = other.mIdentifiers[0]
if join_field not in other.mMali or \
join_field not in self.mMali:
raise "line %s not in both alignments." % (join_field)
this_seq = self.mMali[join_field]
other_seq = other.mMali[join_field]
if this_seq.mFrom != other_seq.mFrom or \
this_seq.mTo != other_seq.mTo:
raise ValueError("residue ranges for sequence %s doe not correspond." % (
join_field))
map_this2other = []
this_seq = this_seq.mString.upper()
other_seq = other_seq.mString.upper()
# position in other
o = 0
for c in this_seq:
if c in self.mGapChars:
map_this2other.append(None)
else:
while other_seq[o] != c:
o += 1
map_this2other.append(o)
o += 1
return map_this2other
def shuffle(self, frame=1):
"""shuffle multiple alignment.
The frame determines the block size for shuffling. Use 3 for codons in
a multiple alignment without frame-shifts.
"""
columns = list(range(self.getNumColumns() // frame))
random.shuffle(columns)
if frame > 1:
cc = []
for x in columns:
cc += [x * frame + y for y in range(frame)]
columns = cc
self.takeColumns(columns)
def propagateMasks(self, min_chars=1, mask_char="x"):
"""propagate masked characters to all rows of a multiple alignment
within a column.
If there is at least min_chars in a mali column, that are masks,
propagate the masks to all other rows.
"""
masks_per_column = {}
for identifier, s in list(self.mMali.items()):
r = s.mString.lower()
for x in range(len(r)):
if r[x] == mask_char:
if x not in masks_per_column:
masks_per_column[x] = 0
masks_per_column[x] += 1
columns_to_mask = []
for c, n in list(masks_per_column.items()):
if n >= min_chars:
columns_to_mask.append(c)
columns_to_mask.sort()
self.maskColumns(columns_to_mask, mask_char=mask_char)
def propagateTransitions(self, min_chars=1):
"""propagate lower case in a column to all residues.
"""
columns_to_change = set()
for identifier, s in list(self.mMali.items()):
r = s.mString
for x in range(len(r)):
if r[x] in string.lowercase:
columns_to_change.add(x)
columns_to_change = list(columns_to_change)
columns_to_change.sort()
self.mapColumns(columns_to_change, string.lower)
def takeColumns(self, columns):
"""restrict alignments to certain columns."""
for identifier, s in list(self.mMali.items()):
s.takeColumns(columns)
for key, anno in list(self.mAnnotations.items()):
self.mAnnotations[key] = "".join([anno[c] for c in columns])
def maskColumns(self, columns, mask_char="x"):
"""mask columns in a multiple alignment."""
for identifier, s in list(self.mMali.items()):
s.maskColumns(columns, mask_char=mask_char)
def mapColumns(self, columns, map_function):
"""apply map_function to all residues in columns."""
for identifier, s in list(self.mMali.items()):
s.mapColumns(columns, map_function)
def recount(self, reset_first=False):
"""recount residue in alignments."""
for id, seq in list(self.mMali.items()):
if reset_first:
seq.mFrom = 0
seq.mTo = seq.mFrom + self.countCharacters(seq.mString)
def maskColumn(self, column, mask_char="x"):
"""mask a column."""
for identifier, s in list(self.mMali.items()):
s.maskColumn(column, mask_char)
def copyAnnotations(self, other):
"""copy annotations from annother mali."""
map_this2other = self.buildColumnMap(other)
ncols = self.getWidth()
for key, annotation in list(other.mAnnotations.items()):
a = []
for x in range(ncols):
m = map_this2other[x]
if m is not None:
a.append(annotation[m])
else:
a.append(self.mGapChar)
self.mAnnotations[key] = "".join(a)
def getAnnotation(self, key):
"""return annotation associated with key."""
return self.mAnnotations[key]
def setAnnotation(self, key, value):
"""set annotation associated with key to value."""
self.mAnnotations[key] = value
def addAnnotation(self, key, annotation):
"""add annotation."""
xkey = key
n = 0
while xkey in self.mAnnotations:
xkey = "%s_%i" % (key, n)
self.mAnnotations[xkey] = re.sub("\s", "", annotation)
def truncate(self, first, last):
"""truncate alignment within range."""
for key, value in list(self.mMali.items()):
value.truncate(first, last)
def mapIdentifiers(self, map_old2new=None, pattern_identifier="ID%06i"):
"""map identifiers in multiple aligment.
if map_old2new is not given, a new map is created (map_new2old)
"""
new_identifiers = []
if map_old2new is not None:
for id in self.mIdentifiers:
new_id = map_old2new[id]
new_identifiers.append(new_id)
entry = self.mMali[id]
del self.mMali[id]
# entry.mId = new_id
self.mMali[new_id] = entry
else:
map_old2new = {}
n = 1
for id in self.mIdentifiers:
new_id = pattern_identifier % n
new_identifiers.append(new_id)
entry = self.mMali[id]
del self.mMali[id]
# entry.mId = new_id
self.mMali[new_id] = entry
map_old2new[new_id] = id
n += 1
self.mIdentifiers = new_identifiers
return map_old2new
def getAlphabet(self):
"""get alphabet from the multiple alignment.
Alphabet is "na", if more than 90% of characaters are "actgxn",
otherwise it is "aa".
"""
s = "".join([x.mString for x in list(self.values())]).lower()
s = re.sub("[%s]" % "".join(self.mGapChars), "", s)
ss = re.sub("[acgtxn]", "", s)
if float(len(ss)) < (len(s) * 0.1):
return "na"
else:
return "aa"
def checkLength(self):
"""check lengths of aligned strings.
Return false if they are inconsistent."""
l = None
for s in list(self.mMali.values()):
if l is None:
l = len(s.mString)
else:
if l != len(s.mString):
return False
return True
def clipByAnnotation(self, key, chars=""):
"""restrict alignment to positions where annotation identified by key
in chars.
if chars is empty, nothing is clipped.
"""
if key not in self.mAnnotations:
return
if chars == "":
return
if self.getNumColumns() == 0:
return
anno = self.mAnnotations[key]
columns = []
for x in range(len(anno)):
if anno[x] in chars:
columns.append(x)
self.takeColumns(columns)
def apply(self, f):
"""apply function f to every row in the multiple alignment."""
for s in list(self.mMali.values()):
f(s)
def filter(self, f):
'''filter multiple alignment using function *f*.
The function *f* should return True for entries that should be
kept and False for those that should be removed.
'''
ids, vals = [], []
for id in self.mIdentifiers:
s = self.mMali[id]
if f(s):
vals.append(s)
ids.append(id)
self.mIdentifiers = ids
self.mMali = vals
class SequenceCollection(Mali):
"""reads in a sequence collection, but permits several entries per id.
Note that this might cause problems with interleaved formats like
phylips or clustal.
This mapping is achieved by appending a numeric suffix. The suffix
is retained for the life-time of the object, but not output to a
file.
"""
def __init__(self):
Mali.__init__(self)
def addEntry(self, s):
"""add an aligned string object."""
id = s.mId
if id in list(self.mMali.keys()):
x = 1
while "%s_%i" % (id, x) in list(self.mMali.keys()):
x += 1
id = "%s_%i" % (id, x)
self.mIdentifiers.append(id)
s.mIsMangled = True
self.mMali[id] = s
def readFromFile(self, infile, format="fasta"):
"""read multiple alignment from file in various format."""
self.mMali = {}
self.mIdentifiers = []
pattern_parse_ranges = re.compile("(\S+)/(\d+)-(\d+)")
if isinstance(infile, list) or \
isinstance(infile, tuple):
lines = infile
else:
lines = infile.readlines()
if format not in ("stockholm"):
# save comments
self.mComments = [x for x in lines if x[0] == "#"]
lines = [x for x in lines if x[0] != "#"]
else:
self.mComments = []
def getId(id, s):
x = pattern_parse_ranges.match(id)
if x:
id, fr, to = x.groups()
fr, to = int(fr) - 1, int(to)
else:
fr, to = 0, self.countCharacters(s)
self.mWriteRanges = False
return id, fr, to
#######################################################################
if format.lower() == "plain":
for line in lines:
if not line.strip():
continue
data = line[:-1].split("\t")
id = data[3]
xid = id
x = 0
while xid in self.mMali:
xid = id + "-" + str(x)
x += 1
self.addEntry(
AlignedString(xid,
int(data[0]) - 1,
int(data[2]),
data[1]))
#######################################################################
elif format.lower() == "fasta":
pattern_identifier = "\S+"
id = None
fragments = []
for line in lines:
if line[0] == ">":
if id:
s = re.sub("\s", "", string.join(fragments, ""))
id, fr, to = getId(id, s)
self.addEntry(AlignedString(id, fr, to, s))
id = re.search(
"^(%s)" % pattern_identifier, line[1:-1]).group(0)
fragments = []
continue
fragments.append(line[:-1])
s = re.sub("\s", "", string.join(fragments, ""))
id, fr, to = getId(id, s)
self.addEntry(AlignedString(id, fr, to, s))
#######################################################################
elif format.lower() == "phylip":
raise ValueError("phylip not implemented")
#######################################################################
elif format.lower() == "clustal":
raise ValueError("clustal not implemented")
elif format.lower() == "stockholm":
raise ValueError("stockholm not implemented")
if len(self.mMali) == 0:
self.mLength = 0
else:
self.mLength = min(
[len(x.mString) for x in list(self.mMali.values())])
def convertMali2Alignlib(mali):
'''convert a multiple alignment of type :class:`Mali`
into an alignlib_lite.py_multiple alignment object.
'''
import alignlib_lite
m = alignlib_lite.py_makeMultipleAlignment()
for identifier in mali.getIdentifiers():
a = alignlib_lite.py_makeAlignatum(mali[identifier])
m.add(a)
return m
def convertAlignlib2Mali(mali, identifiers=None, seqs=None):
"""convert a multiple alignment into an alignlib_lite.py_multiple
alignment object."""
m = Mali()
if not identifiers:
identifiers = ["%i" % x for x in range(mali.getNumSequences())]
if seqs is None:
# old style MultipleAlignment
for x in range(mali.getNumSequences()):
a = mali.getRow(x)
m.addSequence(
identifiers[x], a.getFrom(), a.getTo(), a.getString())
else:
import alignlib_lite
output = alignlib_lite.py_MultAlignmentFormatPlain(mali, seqs)
for x in range(mali.getNumSequences()):
a = output.mData[x]
m.addSequence(
identifiers[x], a.getFrom(), a.getTo(), a.getString())
return m
|
[
"andreas.heger@gmail.com"
] |
andreas.heger@gmail.com
|
9e8faea111d72f8b2e5ec2a6e79cd03f082cad11
|
8f24e443e42315a81028b648e753c50967c51c78
|
/python/ray/train/examples/horovod/horovod_pytorch_example.py
|
f4d15ae0515b7fad3547711c35c685f4407f2ced
|
[
"MIT",
"BSD-3-Clause",
"Apache-2.0"
] |
permissive
|
simon-mo/ray
|
d07efdada8d05c6e10417f96e8dfc35f9ad33397
|
1e42e6cd15e2fb96c217cba8484e59ed0ef4b0c8
|
refs/heads/master
| 2023-03-06T00:09:35.758834
| 2022-12-23T18:46:48
| 2022-12-23T18:46:48
| 122,156,396
| 4
| 2
|
Apache-2.0
| 2023-03-04T08:56:56
| 2018-02-20T04:47:06
|
Python
|
UTF-8
|
Python
| false
| false
| 8,402
|
py
|
import argparse
from filelock import FileLock
import horovod.torch as hvd
import os
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.utils.data.distributed
from torchvision import datasets, transforms
from ray.air import session
from ray.air.config import ScalingConfig
from ray.train.horovod import HorovodTrainer
from ray.train.torch.torch_checkpoint import TorchCheckpoint
import ray.train.torch
def metric_average(val, name):
tensor = torch.tensor(val)
avg_tensor = hvd.allreduce(tensor, name=name)
return avg_tensor.item()
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.conv2_drop = nn.Dropout2d()
self.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 10)
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), 2))
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
x = x.view(-1, 320)
x = F.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.log_softmax(x)
def setup(config):
data_dir = config.get("data_dir", None)
seed = config.get("seed", 42)
batch_size = config.get("batch_size", 64)
use_adasum = config.get("use_adasum", False)
lr = config.get("lr", 0.01)
momentum = config.get("momentum", 0.5)
use_cuda = config.get("use_cuda", False)
# Horovod: initialize library.
hvd.init()
torch.manual_seed(seed)
if use_cuda:
# Horovod: pin GPU to local rank.
torch.cuda.set_device(hvd.local_rank())
torch.cuda.manual_seed(seed)
# Horovod: limit # of CPU threads to be used per worker.
torch.set_num_threads(1)
kwargs = {"pin_memory": True} if use_cuda else {}
data_dir = data_dir or "~/data"
with FileLock(os.path.expanduser("~/.horovod_lock")):
train_dataset = datasets.MNIST(
data_dir,
train=True,
download=True,
transform=transforms.Compose(
[transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))]
),
)
# Horovod: use DistributedSampler to partition the training data.
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset, num_replicas=hvd.size(), rank=hvd.rank()
)
# Note, don't set `num_workers` in DataLoader (not even 1),
# as that will separately start multiple processes (each corresponding to 1 worker)
# to load the data. This is known to cause issues with Ray.
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=batch_size, sampler=train_sampler, **kwargs
)
model = Net()
# By default, Adasum doesn't need scaling up learning rate.
lr_scaler = hvd.size() if not use_adasum else 1
if use_cuda:
# Move model to GPU.
model.cuda()
# If using GPU Adasum allreduce, scale learning rate by local_size.
if use_adasum and hvd.nccl_built():
lr_scaler = hvd.local_size()
# Horovod: scale learning rate by lr_scaler.
optimizer = optim.SGD(model.parameters(), lr=lr * lr_scaler, momentum=momentum)
# Horovod: wrap optimizer with DistributedOptimizer.
optimizer = hvd.DistributedOptimizer(
optimizer,
named_parameters=model.named_parameters(),
op=hvd.Adasum if use_adasum else hvd.Average,
)
return model, optimizer, train_loader, train_sampler
def train_epoch(
model, optimizer, train_sampler, train_loader, epoch, log_interval, use_cuda
):
loss = None
model.train()
# Horovod: set epoch to sampler for shuffling.
train_sampler.set_epoch(epoch)
for batch_idx, (data, target) in enumerate(train_loader):
if use_cuda:
data, target = data.cuda(), target.cuda()
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target)
loss.backward()
optimizer.step()
if batch_idx % log_interval == 0:
# Horovod: use train_sampler to determine the number of
# examples in this worker's partition.
print(
"Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}".format(
epoch,
batch_idx * len(data),
len(train_sampler),
100.0 * batch_idx / len(train_loader),
loss.item(),
)
)
return loss.item() if loss else None
def train_func(config):
num_epochs = config.get("num_epochs", 10)
log_interval = config.get("log_interval", 10)
use_cuda = config.get("use_cuda", False)
save_model_as_dict = config.get("save_model_as_dict", False)
model, optimizer, train_loader, train_sampler = setup(config)
results = []
for epoch in range(num_epochs):
loss = train_epoch(
model, optimizer, train_sampler, train_loader, epoch, log_interval, use_cuda
)
if save_model_as_dict:
checkpoint = TorchCheckpoint.from_state_dict(model.state_dict())
else:
checkpoint = TorchCheckpoint.from_model(model)
results.append(loss)
session.report(dict(loss=loss), checkpoint=checkpoint)
# Only used for testing.
return results
def main(num_workers, use_gpu, kwargs):
trainer = HorovodTrainer(
train_loop_per_worker=train_func,
train_loop_config={
"num_epochs": kwargs["num_epochs"],
"log_interval": kwargs["log_interval"],
"use_cuda": kwargs["use_cuda"],
},
scaling_config=ScalingConfig(num_workers=num_workers, use_gpu=use_gpu),
)
result = trainer.fit()
print(result)
if __name__ == "__main__":
# Training settings
parser = argparse.ArgumentParser(
description="PyTorch MNIST Example",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
parser.add_argument(
"--batch-size",
type=int,
default=64,
metavar="N",
help="input batch size for training (default: 64)",
)
parser.add_argument(
"--num-epochs",
type=int,
default=5,
metavar="N",
help="number of epochs to train (default: 10)",
)
parser.add_argument(
"--lr",
type=float,
default=0.01,
metavar="LR",
help="learning rate (default: 0.01)",
)
parser.add_argument(
"--momentum",
type=float,
default=0.5,
metavar="M",
help="SGD momentum (default: 0.5)",
)
parser.add_argument(
"--use-gpu", action="store_true", default=False, help="enables CUDA training"
)
parser.add_argument(
"--seed", type=int, default=42, metavar="S", help="random seed (default: 42)"
)
parser.add_argument(
"--log-interval",
type=int,
default=10,
metavar="N",
help="how many batches to wait before logging training status",
)
parser.add_argument(
"--use-adasum",
action="store_true",
default=False,
help="use adasum algorithm to do reduction",
)
parser.add_argument(
"--num-workers",
type=int,
default=2,
help="Number of Ray workers to use for training.",
)
parser.add_argument(
"--data-dir",
help="location of the training dataset in the local filesystem ("
"will be downloaded if needed)",
)
parser.add_argument(
"--address",
required=False,
type=str,
default=None,
help="Address of Ray cluster.",
)
args = parser.parse_args()
if args.address:
ray.init(args.address)
else:
ray.init()
use_cuda = args.use_gpu if args.use_gpu is not None else False
kwargs = {
"data_dir": args.data_dir,
"seed": args.seed,
"use_cuda": use_cuda,
"batch_size": args.batch_size,
"use_adasum": args.use_adasum if args.use_adasum else False,
"lr": args.lr,
"momentum": args.momentum,
"num_epochs": args.num_epochs,
"log_interval": args.log_interval,
}
main(num_workers=args.num_workers, use_gpu=use_cuda, kwargs=kwargs)
|
[
"noreply@github.com"
] |
simon-mo.noreply@github.com
|
188c2472291601922fddbb95d9c6cdbe3ca24173
|
d12e13bab06ba7083a41aba7e7f74fa40926f0cc
|
/seq2seq-affect-attention/model/Decoder.py
|
4205fde03a3c06a698c12fa5da91565c6a50e86d
|
[] |
no_license
|
HengYangDS/seq2seq-affect
|
39ca15998f7824f29932832c880cba416a478682
|
e5c40651540fea258a2d683be0fe532763168853
|
refs/heads/master
| 2020-09-25T16:09:53.663929
| 2019-12-05T02:10:13
| 2019-12-05T02:10:13
| 226,040,899
| 1
| 0
| null | 2019-12-05T07:21:28
| 2019-12-05T07:21:27
| null |
UTF-8
|
Python
| false
| false
| 1,031
|
py
|
import torch.nn as nn
# 解码器
class Decoder(nn.Module):
def __init__(self, cell_type, # rnn类型
input_size, # 输入维度
output_size, # 输出维度
num_layer, # rnn层数
dropout=0): # dropout
super(Decoder, self).__init__()
assert cell_type in ['GRU', 'LSTM'] # 限定rnn类型
self.cell_type = cell_type
self.rnncell = getattr(nn, cell_type)( # rnncell
input_size=input_size,
hidden_size=output_size,
num_layers=num_layer,
dropout=dropout)
def forward(self, input, # 输入 [seq, batch, dim] 或者单步输入 [1, batch, dim]
state): # 初始状态 [layers*directions, batch, dim]
# output = [seq, batch, dim*directions] 每个时间步的输出
# final_state = [layers*directions, batch, dim] # 每一层的最终状态
output, final_state = self.rnncell(input, state)
return output, final_state
|
[
"1759567121@qq.com"
] |
1759567121@qq.com
|
9cee7ee01989eaac94944331ddf1326936e6d652
|
b45df36da7d09b3170c503753dabf62ac28db8d8
|
/book/exercise/Key-valueOperations/Python/TweetService.py
|
da23adede52957c795737d066a9b02e35525edcb
|
[
"MIT"
] |
permissive
|
skatsuta/aerospike-training
|
42b9a6e9372bd396d3489ec73778df7c00f5829e
|
d08d1805e19277b08327df5670e4c335ee63b853
|
refs/heads/master
| 2023-08-16T13:03:09.930256
| 2014-12-12T17:18:02
| 2014-12-12T17:18:02
| 27,905,857
| 0
| 0
|
MIT
| 2023-08-03T19:46:21
| 2014-12-12T04:52:47
|
C#
|
UTF-8
|
Python
| false
| false
| 8,093
|
py
|
#!/usr/bin/env python
#
# * Copyright 2012-2014 by Aerospike.
# *
# * Permission is hereby granted, free of charge, to any person obtaining a copy
# * of this software and associated documentation files (the "Software"), to
# * deal in the Software without restriction, including without limitation the
# * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
# * sell copies of the Software, and to permit persons to whom the Software is
# * furnished to do so, subject to the following conditions:
# *
# * The above copyright notice and this permission notice shall be included in
# * all copies or substantial portions of the Software.
# *
# * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# * IN THE SOFTWARE.
#
from __future__ import print_function
import aerospike
import sys
import time
from aerospike import predicates as p
import random
AS_POLICY_W_EXISTS = "exists"
AS_POLICY_EXISTS_UNDEF = 0 # Use default value
AS_POLICY_EXISTS_IGNORE= 1 # Write the record, regardless of existence.
AS_POLICY_EXISTS_CREATE= 2 # Create a record, ONLY if it doesn't exist.
AS_POLICY_EXISTS_UPDATE= 3 # Update a record, ONLY if it exist (NOT YET IMPL).
class TweetService(object):
def __init__(self, client):
self.client = client
def createTweet(self):
print("\n********** Create Tweet **********\n")
# /*********************///
# /*****Data Model*****///
# Namespace: test
# Set: tweets
# Key: <username:<counter>>
# Bins:
# tweet - string
# ts - int (Stores epoch timestamp of the tweet)
# username - string
# Sample Key: dash:1
# Sample Record:
# { tweet: 'Put. A. Bird. On. It.',
# ts: 1408574221,
# username: 'dash'
# }
# /*********************///
userRecord = None
userKey = None
tweetKey = None
# Get username
username = str()
username = raw_input("Enter username: ")
if len(username) > 0:
# Check if username exists
# Exercise 2
print("\nTODO: Check if username exists")
meta = None
policy = None
record = {}
if userRecord:
# Set Tweet Count
if 'tweetcount' in userRecord:
nextTweetCount = int(userRecord['tweetcount']) + 1
else:
nextTweetCount = 1
# Get tweet
record['tweet'] = raw_input("Enter tweet for " + username + ":")
# Create timestamp to store along with the tweet so we can
# query, index and report on it
ts= self.getTimeStamp()
# TODO: Create WritePolicy instance
# Exercise 2
print("\nTODO: Create WritePolicy instance");
#TODO: Create Key and Bin instances for the tweet record. HINT: tweet key should be in username:nextTweetCount format
# Exercise 2
print("\nTODO: Create Key and Bin instances for the tweet record");
# TODO: Write tweet record
# Exercise 2
print("\nTODO: Write tweet record");
# TODO: Update tweet count and last tweeted timestamp in the user
# Exercise 2
print("\nINFO: Tweet record created!\n",record,tweetKey)
# Update tweet count and last tweet'd timestamp in the user record
else:
print("ERROR: User record not found!\n")
def scanAllTweetsForAllUsers(self):
# Initiate scan operation that invokes callback for outputting tweets on the console
# Exercise 4
print("\nTODO: Initiate scan operation that invokes callback for outputting tweets to the console")
def updateUser(self, client, userKey, policy, ts, tweetCount):
# TODO: Update tweet count and last tweeted timestamp in the user record
# Exercise 2
print("\nTODO: Update tweet count and last tweeted timestamp in the user record")
def updateUserUsingOperate(self, client, userKey, policy, ts):
""" operate not supported in Python Client """
print("\nINFO: The tweet count now is: ")
def queryTweetsByUsername(self):
print("\n********** Query Tweets By Username **********\n")
def queryUsersByTweetCount(self):
print("\n********** Query Users By Tweet Count Range **********\n")
def getTimeStamp(self):
return int(round(time.time() * 1000))
def createTweets(self):
randomTweets = ["For just $1 you get a half price download of half of the song and listen to it just once.", "People tell me my body looks like a melted candle", "Come on movie! Make it start!", "Byaaaayy", "Please, please, win! Meow, meow, meow!", "Put. A. Bird. On. It.", "A weekend wasted is a weekend well spent", "Would you like to super spike your meal?", "We have a mean no-no-bring-bag up here on aisle two.", "SEEK: See, Every, EVERY, Kind... of spot", "We can order that for you. It will take a year to get there.", "If you are pregnant, have a soda.", "Hear that snap? Hear that clap?", "Follow me and I may follow you", "Which is the best cafe in Portland? Discuss...", "Portland Coffee is for closers!", "Lets get this party started!", "How about them portland blazers!", "You got school'd, yo", "I love animals", "I love my dog", "What's up Portland", "Which is the best cafe in Portland? Discuss...", "I dont always tweet, but when I do it is on Tweetaspike"]
totalUsers = 10000
maxTweets = 20
username = str()
ts = 0
wr_policy = {
AS_POLICY_W_EXISTS: AS_POLICY_EXISTS_IGNORE
}
print("\nCreate up to " , maxTweets , " tweets each for " , totalUsers , " users. Press any key to continue...\n")
raw_input("..")
j = 0
while j < totalUsers:
username = "user" + str(random.randint(1,totalUsers))
userKey = ("test", "users", username)
meta = None
policy = None
ts = None
k = 0
(key, metadata,userRecord) = self.client.get(userKey,policy)
if userRecord:
totalTweets = random.randint(1,maxTweets)
while k <= totalTweets:
record = {}
ts = self.getTimeStamp()
tweetKey = ("test", "tweets", username + ":" + str(k))
record["tweet"] = random.choice(randomTweets)
record["ts"] = ts
record["username"]= username
self.client.put(tweetKey,record, meta, wr_policy)
k += 1
# Create timestamp to store along with the tweet so we can
# query, index and report on it
print("\nWrote " , totalTweets , " tweets for " , username , "!")
if totalTweets > 0:
# Update tweet count and last tweet'd timestamp in the user
# record
self.updateUser(self.client, userKey, wr_policy, ts, totalTweets)
j += 1
# Check if user record exists
# create up to maxTweets random tweets for this user
# Create timestamp to store along with the tweet so we can
# query, index and report on it
# Update tweet count and last tweet'd timestamp in the user
# record
print("\n\nDone creating up to " , maxTweets , " tweets each for " , totalUsers , " users!\n")
|
[
"katsuta_soshi@cyberagent.co.jp"
] |
katsuta_soshi@cyberagent.co.jp
|
73f8ddeef35504d0ce12496657651f487254073c
|
9edff345ec24494058d5ce01b4fb46012dc8bf29
|
/中级算法/回溯算法/单词搜索.py
|
180c8e196a24a8a9cd990344a4e486c18e38aac9
|
[] |
no_license
|
gump1368/leetcode-python
|
65909bb9931e3840d29743222d92af3a77902f33
|
2d4f47e21cc105700feccb0d525408bdc54c663c
|
refs/heads/master
| 2023-01-24T03:50:19.447898
| 2023-01-12T07:03:12
| 2023-01-12T07:03:12
| 235,063,257
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,073
|
py
|
#！ -*- coding: utf-8 -*-
"""
@Author: gump
@Create Time: 20220714
@Info: 单词搜索
"""
from typing import List
# def exist(board: List[List[str]], word: str) -> bool:
# """
# 输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
# 输出：false
#
# :param board:
# :param word:
# :return:
# """
# row_length = len(board)
# col_length = len(board[0])
# size = row_length * col_length
#
# def trace_back(value, k, last_position):
# if k >= len(word) or value < 0:
# return k
#
# while value < size:
# row = value // col_length
# col = value % col_length
# if board[row][col] == word[k]:
# left = value - 1
# right = value + 1
# up = value - row_length
# down = value + row_length
# k += 1
# k = trace_back(left, k, 'left') if last_position != 'right' else k
# k = trace_back(right, k, 'right') if last_position != 'left' else k
# k = trace_back(up, k, 'up') if last_position != 'down' else k
# k = trace_back(down, k, 'down') if last_position != 'up' else k
# else:
# value += 1
#
# if k >= len(word):
# break
#
# return k
#
# pos = trace_back(0, 0, 'None')
# return True if pos == len(word) else False
def exist(board: List[List[str]], word: str) -> bool:
"""
输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
输出：false
:param board:
:param word:
:return:
"""
row_length = len(board)
col_length = len(board[0])
def trace_back(i, j, k, temp_path):
if (i, j) in temp_path:
return k - 1
if k >= len(word):
return k
temp_path.append((i, j))
depth = k
if j-1 >= 0 and board[i][j-1] == word[k]:
temp_1 = trace_back(i, j-1, k+1, temp_path)
depth = temp_1 if temp_1 > depth else depth
if j+1 < col_length and board[i][j+1] == word[k]:
temp_1 = trace_back(i, j+1, k + 1, temp_path)
depth = temp_1 if temp_1 > depth else depth
if i-1 >= 0 and board[i-1][j] == word[k]:
temp_1 = trace_back(i-1, j, k+1, temp_path)
depth = temp_1 if temp_1 > depth else depth
if i+1 < row_length and board[i+1][j] == word[k]:
temp_1 = trace_back(i+1, j, k+1, temp_path)
depth = temp_1 if temp_1 > depth else depth
temp_path.pop(-1)
return depth
for row in range(row_length):
for col in range(col_length):
if board[row][col] == word[0]:
pos = trace_back(row, col, 1, [])
if pos >= len(word):
return True
return False
if __name__ == '__main__':
board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]]
word = "ABCCED"
print(exist(board, word))
|
[
"guan_dongpu@gowild.cn"
] |
guan_dongpu@gowild.cn
|
5db923fb9cbe244877c30b08690665cc6022a117
|
2b98c555e146487a08b0f9c2e94f2564977623dd
|
/main.py
|
14aeb66d5b362c719da26bf8648a29d9ed64f39f
|
[] |
no_license
|
RossT18/Binary-Tree
|
400eb9efc79f3c3072a46d6e5c7ae2e37be4940b
|
5f22c8d76208cfe6283f0bfef573b481002c209e
|
refs/heads/main
| 2023-03-27T00:25:06.151084
| 2021-03-28T17:57:01
| 2021-03-28T17:57:01
| 331,387,644
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 346
|
py
|
import BinaryTree as bt
# https://upload.wikimedia.org/wikipedia/commons/d/da/Binary_search_tree.svg
root = bt.Node(8)
tree = bt.BinaryTree(root)
tree.add(3)
tree.add(1)
tree.add(6)
tree.add(4)
tree.add(7)
tree.add(10)
tree.add(14)
tree.add(13)
# Expected output order:
# 1,3,4,6,7,8,10,13,14
print(tree)
print("Length: " + str(len(tree)))
|
[
"rtinsley1199@gmail.com"
] |
rtinsley1199@gmail.com
|
a06a1754d3ec0bbd190006a04d477e5c50c00b20
|
4e3f83be95d2225fd18047fc6eaf09992d4491ea
|
/src/utils/Datetimes.py
|
b01224589683651301f55b46dc3ec0fa6b2561c3
|
[
"Apache-2.0"
] |
permissive
|
Gabvaztor/TFBoost
|
7f1d56e44498a23f2e9d884fcd66942cb9e6d622
|
a37b906f5cb47becc3275def8282ff395d06ef45
|
refs/heads/master
| 2021-06-06T07:56:05.995559
| 2019-10-14T15:27:29
| 2019-10-14T15:36:43
| 83,965,500
| 9
| 3
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 119
|
py
|
from datetime import datetime
def date_from_format(date, format="%Y-%m-%d %H:%M:%S"):
return date.strftime(format)
|
[
"gabvaztor@gmail.com"
] |
gabvaztor@gmail.com
|
7adb46a971ce547c265474004b96ae65283904dc
|
a0cfde6971fbe3b2c1de726a7bfc1c60fba3a137
|
/userbot/plugins/git.py
|
8d3857c9917303b94e1f9cebb82f052502dce43e
|
[
"MIT"
] |
permissive
|
No-OnE-Kn0wS-Me/FridayUserbot
|
6efb25dfd2eb06674b99bc158a6bbddcd128012c
|
9ef60066b72fa085300408855010ea05b9026f82
|
refs/heads/master
| 2022-11-19T23:10:49.342679
| 2020-06-22T13:49:56
| 2020-06-22T13:49:56
| 274,447,417
| 2
| 1
|
MIT
| 2020-06-23T15:52:27
| 2020-06-23T15:52:26
| null |
UTF-8
|
Python
| false
| false
| 648
|
py
|
from telethon import events
import asyncio
@borg.on(events.NewMessage(pattern=r"\.(.*)", outgoing=True))
async def _(event):
if event.fwd_from:
return
animation_interval = 0.1
animation_ttl = range(0, 101)
input_str = event.pattern_match.group(1)
if input_str == "githubs":
await event.edit(input_str)
animation_chars = [
"https://github.com/midhunkm1294-bit/friday",
"https://github.com/midhunkm1294-bit/friday"
]
for i in animation_ttl:
await asyncio.sleep(animation_interval)
await event.edit(animation_chars[i % 2])
|
[
"66051049+StarkGang@users.noreply.github.com"
] |
66051049+StarkGang@users.noreply.github.com
|
48a149e36e40844f00d5d10b8710b2422b11ab35
|
4bbb4fca1829ec8b146f9c73d2358b897e28d4ae
|
/main/views.py
|
4070691290ea2909d585902532f0a46b40ad40be
|
[] |
no_license
|
richardwalkerdev/handofcards
|
e54e1bc4bf868b2a9e02c63a063706daf1573f98
|
312e77884695e5e1442bff40660b6be08623604b
|
refs/heads/master
| 2022-12-16T00:35:24.096302
| 2020-02-04T17:12:38
| 2020-02-04T17:12:38
| 234,924,220
| 0
| 0
| null | 2022-12-08T03:27:57
| 2020-01-19T15:49:12
|
Python
|
UTF-8
|
Python
| false
| false
| 959
|
py
|
from django.shortcuts import render
import requests
import os
from django.core.exceptions import ImproperlyConfigured
from .models import Hand
import datetime
def hand(request):
def get_env_value(env_variable):
try:
return os.environ[env_variable]
except KeyError:
error_msg = 'Set the {} environment variable'.format(env_variable)
raise ImproperlyConfigured(error_msg)
# Get environmant variable DECKOFCARDS_URL
DECKOFCARDS_URL = get_env_value('DECKOFCARDS_URL')
response = requests.get(DECKOFCARDS_URL)
deckdata = response.json()
hand = []
total = 0
for n in range(2):
hand.append(deckdata.pop(0))
for i in hand:
total = total + i.get("value")
handTotal = Hand()
handTotal.total = total
handTotal.created = datetime.datetime.now()
handTotal.save()
return render(request, 'main/index.html', {'array': hand, 'total': total})
|
[
"rwalker@rwalker.remote.csb"
] |
rwalker@rwalker.remote.csb
|
93e2cb9162dfaedfe3a58c9892ccb9936f9405c9
|
9e7d7b4d029554eed0f760a027cd94558b919ae2
|
/CHAPTER15/overlaying.py
|
e320bf396d4410f1a0cc189810fc886ac93deca0
|
[] |
no_license
|
pooja1506/AutomateTheBoringStuff_2e
|
8247b68a195d5e1976c6474f0e97d947906ffd35
|
5bab9ccdcdb22ee10fe1272c91042be40fd67c17
|
refs/heads/master
| 2022-04-10T19:21:44.402829
| 2020-04-05T12:10:32
| 2020-04-05T12:10:32
| 249,620,282
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 589
|
py
|
import PyPDF2
minutesFile = open('meetingminutes.pdf', 'rb')
pdfReader = PyPDF2.PdfFileReader(minutesFile)
minutesFirstPage = pdfReader.getPage(0)
pdfWatermarkReader = PyPDF2.PdfFileReader(open('watermark.pdf', 'rb'))
minutesFirstPage.mergePage(pdfWatermarkReader.getPage(0))
pdfWriter = PyPDF2.PdfFileWriter()
pdfWriter.addPage(minutesFirstPage)
for pageNum in range(1, pdfReader.numPages):
pageObj = pdfReader.getPage(pageNum)
pdfWriter.addPage(pageObj)
resultPdfFile = open('watermarkedCover.pdf', 'wb')
pdfWriter.write(resultPdfFile)
minutesFile.close()
resultPdfFile.close()
|
[
"pooja.dmehta15@gmail.com"
] |
pooja.dmehta15@gmail.com
|
b3d7305f178eead8c1316698c2989f3d44540d31
|
71b3715408330a42c62c7176a0f8fb1901d3ba6c
|
/src/day01/HelloWorld.py
|
3767e64837fc2b4f8dab04a81c60ccf1cac9530c
|
[] |
no_license
|
hubin9218/LearnPython
|
41fac40b4d883fde62c4a0f0405da76da0bda5df
|
a9fd0e55bddc5f1a2a07212a7f80c603ea2dc735
|
refs/heads/master
| 2021-02-17T06:13:48.945425
| 2020-03-23T09:49:39
| 2020-03-23T09:49:39
| 245,076,608
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,489
|
py
|
"""
绘制小猪佩奇...
"""
from turtle import *
def nose(x,y):
"""画鼻子"""
penup()
# 将海龟移动到指定的坐标
goto(x,y)
pendown()
# 设置海龟的方向（0-东、90-北、180-西、270-南）
setheading(-30)
begin_fill()
a = 0.4
for i in range(120):
if 0 <= i < 30 or 60 <= i <90:
a = a + 0.08
# 向左转3度
left(3)
# 向前走
forward(a)
else:
a = a - 0.08
left(3)
forward(a)
end_fill()
penup()
setheading(90)
forward(25)
setheading(0)
forward(10)
pendown()
# 设置画笔的颜色(红, 绿, 蓝)
pencolor(255, 155, 192)
setheading(10)
begin_fill()
circle(5)
color(160, 82, 45)
end_fill()
penup()
setheading(0)
forward(20)
pendown()
pencolor(255, 155, 192)
setheading(10)
begin_fill()
circle(5)
color(160, 82, 45)
end_fill()
def head(x, y):
"""画头"""
color((255, 155, 192), "pink")
penup()
goto(x,y)
setheading(0)
pendown()
begin_fill()
setheading(180)
circle(300, -30)
circle(100, -60)
circle(80, -100)
circle(150, -20)
circle(60, -95)
setheading(161)
circle(-300, 15)
penup()
goto(-100, 100)
pendown()
setheading(-30)
a = 0.4
for i in range(60):
if 0<= i < 30 or 60 <= i < 90:
a = a + 0.08
lt(3) #向左转3度
fd(a) #向前走a的步长
else:
a = a - 0.08
lt(3)
fd(a)
end_fill()
def ears(x,y):
"""画耳朵"""
color((255, 155, 192), "pink")
penup()
goto(x, y)
pendown()
begin_fill()
setheading(100)
circle(-50, 50)
circle(-10, 120)
circle(-50, 54)
end_fill()
penup()
setheading(90)
forward(-12)
setheading(0)
forward(30)
pendown()
begin_fill()
setheading(100)
circle(-50, 50)
circle(-10, 120)
circle(-50, 56)
end_fill()
def eyes(x,y):
"""画眼睛"""
color((255, 155, 192), "white")
penup()
setheading(90)
forward(-20)
setheading(0)
forward(-95)
pendown()
begin_fill()
circle(15)
end_fill()
color("black")
penup()
setheading(90)
forward(12)
setheading(0)
forward(-3)
pendown()
begin_fill()
circle(3)
end_fill()
color((255, 155, 192), "white")
penup()
seth(90)
forward(-25)
seth(0)
forward(40)
pendown()
begin_fill()
circle(15)
end_fill()
color("black")
penup()
setheading(90)
forward(12)
setheading(0)
forward(-3)
pendown()
begin_fill()
circle(3)
end_fill()
def cheek(x,y):
"""画脸颊"""
color((255, 155, 192))
penup()
goto(x,y)
pendown()
setheading(0)
begin_fill()
circle(30)
end_fill()
def mouth(x,y):
"""画嘴巴"""
color(239, 69, 19)
penup()
goto(x, y)
pendown()
setheading(-80)
circle(30, 40)
circle(40, 80)
def setting():
"""设置参数"""
pensize(4)
# 隐藏海龟
hideturtle()
colormode(255)
color((255, 155, 192), "pink")
setup(840, 500)
speed(10)
def main():
"""主函数"""
setting()
nose(-100, 100)
head(-69, 167)
ears(0, 160)
eyes(0, 140)
cheek(80, 10)
mouth(-20, 30)
done()
if __name__ == '__main__':
main()
|
[
"hubin9218@163.com"
] |
hubin9218@163.com
|
5a4ce30950656174d6f9d7daeedd4c6f6fb567c7
|
7e83e6b4e1f6c461e8b77eb620a9a1c851b611e8
|
/hello_django/hello_django/urls.py
|
f5dc4fe5f9d8a8d42a862b0098131600a0887911
|
[] |
no_license
|
guess3233qa/opendata
|
fa64e6331b1c1f08972d44a339966444dc45ff96
|
b3d95ce69ce6cfd23947a2f32b7ab2f058eb7ed2
|
refs/heads/master
| 2021-01-17T05:17:38.871841
| 2017-06-28T01:06:27
| 2017-06-28T01:06:27
| 95,610,418
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 818
|
py
|
"""hello_django URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.11/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.conf.urls import url, include
2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url , include
from django.contrib import admin
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'' , include('hello.urls')),
]
|
[
"noreply@github.com"
] |
guess3233qa.noreply@github.com
|
cce85590e54ae1deb81edc2cb58d4281f38508e8
|
2d27f9735aa104cffb0701683d70021d61729f57
|
/template.py
|
8d2e3a024ba2f3223f9cdd13efe292b2c6176d09
|
[] |
no_license
|
indexample/AOC2020
|
2b84f07fd479c4fc7df0b1b3c2b65176fcf6a7de
|
300363a693e933173f3a5edfc3bc1797428f0346
|
refs/heads/main
| 2023-02-06T03:19:43.667864
| 2020-12-22T13:04:18
| 2020-12-22T13:04:18
| 318,496,610
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,054
|
py
|
import os
import timeit
#import numpy as np
#from itertools import count
# ideas
# part1:
# part2:
def log(*args):
if LOGGING:
for i in args:
print( str(i) )
def timefunc(iter, function, *args):
def wrap():
function(*args)
t = timeit.Timer(wrap)
return t.timeit(iter) / iter #average
def solve1(d):
pass
LOGGING = 1
f_loc = 'D:/GIT/AOC2020-1/day14/input.txt'
#set = {}, list = [], generator = ()
#data = [int(x) for line in open(f_loc, 'r').read().rstrip().split("\n") for x in line.split(',') if x != 'x' ] #or read().splitlines()
#data = [x for line in open(f_loc, 'r').read().rstrip().split("\n") for x in line.split(',') ]
data = [line for line in open(f_loc, 'r').read().rstrip().split("\n") ]
#data = list(map(char_to_int, open(f_loc, 'r').readlines()))
#i = dict(enumerate(data))
print('\n---- part 1 ----')
print(f': {solve1(data)}')
print('\n---- part 2 ----')
#print(f': {solve2(data)}')
# timeit
#print(f'timeit: {timefunc(10, solve1, data)}' )
# part 1:
# part 2:
|
[
"3052927+devale@users.noreply.github.com"
] |
3052927+devale@users.noreply.github.com
|
03295f3478f5d7e47e2204ea64855e9de3926e54
|
121ab18bfbdb690a3365e84b7da6d1b143fb8768
|
/tabTools/add_tag.py
|
aacad3786e6de8bf2b6c20cec752c44ac4347af1
|
[] |
no_license
|
zy041225/python_bin
|
1661ef120ce22d63f7f8929dfe637bf12e7b31b4
|
4b0219b4a99394b48c3dad19727cbfb2038d2e3e
|
refs/heads/master
| 2020-09-13T15:34:02.145545
| 2019-11-20T02:07:34
| 2019-11-20T02:07:34
| 222,830,326
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 552
|
py
|
#!/usr/bin/env python3
import sys
import getopt
if len(sys.argv) != 6 or sys.argv[5] == '-':
sys.exit("python3 %s <tab> <tab_column> <tag_lst> <tag_column> <tag_name>\n<tag_name> should NOT be '-'"% (sys.argv[0]))
dict = {}
tag_lst = open(sys.argv[3])
for line in tag_lst:
line = line.rstrip()
tmp = line.split('\t')
dict[tmp[int(sys.argv[4])-1]] = 1
tab = open(sys.argv[1])
for line in tab:
line = line.rstrip()
tmp = line.split('\t')
tag = '-'
if tmp[int(sys.argv[2])-1] in dict:
tag = sys.argv[5]
line += '\t%s' % (tag)
print(line)
|
[
"zy041225@gmail.com"
] |
zy041225@gmail.com
|
d8db374595ea9b2c375ef52a5364a9fa9f258336
|
626a08cf643775368dff313e1049ba55d559e986
|
/libs/metrics/type_composite_index.py
|
01973da142755b0460a52ac3eddbd4907af9cfba
|
[] |
no_license
|
NashLea/SecuritiesAnalysisTools
|
3fd995a4d4d714cff81cd60cb6f885880c175d19
|
3fd5ae12714f56efd5dc395ae7a1e5acc7778aba
|
refs/heads/master
| 2022-11-06T06:43:09.399530
| 2020-06-20T03:27:22
| 2020-06-20T03:27:22
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 9,056
|
py
|
import os
import json
import pandas as pd
import numpy as np
from libs.tools import cluster_oscs
from libs.tools import windowed_moving_avg
from libs.utils import download_data_indexes
from libs.utils import dual_plotting, generic_plotting
from libs.utils import ProgressBar, index_appender
from libs.utils import STANDARD_COLORS
ERROR_COLOR = STANDARD_COLORS["error"]
WARNING = STANDARD_COLORS["warning"]
NORMAL = STANDARD_COLORS["normal"]
def type_composite_index(**kwargs) -> list:
"""Type Composite Index (MCI)
Similar to MCI, TCI compares broader market types (sensitive, cyclical, and defensive)
Optional Args:
config {dict} -- controlling config dictionary (default: {None})
plot_output {bool} -- True to render plot in realtime (default: {True})
period {str / list} -- time period for data (e.g. '2y') (default: {None})
clock {float} -- time for prog_bar (default: {None})
data {pd.DataFrame} -- fund datasets (default: {None})
sectors {list} -- list of sectors (default: {None})
returns:
list -- dict contains all tci information, data, sectors
"""
config = kwargs.get('config')
period = kwargs.get('period')
plot_output = kwargs.get('plot_output', True)
clock = kwargs.get('clock')
data = kwargs.get('data')
sectors = kwargs.get('sectors')
if config is not None:
period = config['period']
properties = config['properties']
elif period is None:
print(
f"{ERROR_COLOR}ERROR: config and period both provided {period} " +
f"for type_composite_index{NORMAL}")
return {}
else:
# Support for release 1 versions
period = period
properties = dict()
properties['Indexes'] = {}
properties['Indexes']['Type Sector'] = True
# Validate each index key is set to True in the --core file
if properties is not None:
if 'Indexes' in properties.keys():
props = properties['Indexes']
if 'Type Sector' in props.keys():
if props['Type Sector'] == True:
m_data = get_metrics_content()
if data is None or sectors is None:
data, sectors = metrics_initializer(
m_data, period='2y')
if data:
p = ProgressBar(
19, name='Type Composite Index', offset=clock)
p.start()
tci = dict()
composite = {}
for sect in sectors:
cluster = cluster_oscs(
data[sect],
plot_output=False,
function='market',
wma=False,
progress_bar=p
)
graph = cluster['tabular']
composite[sect] = graph
defensive = type_composites(
composite, m_data, type_type='Defensive')
p.uptick()
sensitive = type_composites(
composite, m_data, type_type='Sensitive')
p.uptick()
cyclical = type_composites(
composite, m_data, type_type='Cyclical')
p.uptick()
d_val = weighted_signals(
data, m_data, type_type='Defensive')
p.uptick()
s_val = weighted_signals(
data, m_data, type_type='Sensitive')
p.uptick()
c_val = weighted_signals(
data, m_data, type_type='Cyclical')
p.uptick()
d_val = windowed_moving_avg(d_val, 3, data_type='list')
c_val = windowed_moving_avg(c_val, 3, data_type='list')
s_val = windowed_moving_avg(s_val, 3, data_type='list')
p.uptick()
tci['defensive'] = {
"tabular": d_val,
"clusters": defensive
}
tci['sensitive'] = {
"tabular": s_val,
"clusters": sensitive
}
tci['cyclical'] = {
"tabular": c_val,
"clusters": cyclical
}
dates = data['VGT'].index
if plot_output:
dual_plotting(y1=d_val, y2=defensive, y1_label='Defensive Index',
y2_label='Clustered Osc', title='Defensive Index', x=dates)
dual_plotting(y1=s_val, y2=sensitive, y1_label='Sensitive Index',
y2_label='Clustered Osc', title='Sensitive Index', x=dates)
dual_plotting(y1=c_val, y2=cyclical, y1_label='Cyclical Index',
y2_label='Clustered Osc', title='Cyclical Index', x=dates)
generic_plotting([d_val, s_val, c_val], legend=[
'Defensive', 'Sensitive', 'Cyclical'], title='Type Indexes', x=dates)
else:
generic_plotting(
[d_val, s_val, c_val],
legend=['Defensive', 'Sensitive', 'Cyclical'],
title='Type Indexes',
x=dates,
saveFig=True,
ylabel='Normalized "Price"',
filename='tci.png'
)
p.end()
return tci, data, sectors
return {}, None, None
def metrics_initializer(m_data: dict, period='2y'):
"""Metrics Initializer
Keyword Arguments:
period {str} -- (default: {'2y'})
Returns:
list -- downloaded_data, sector_list, index, metrics_file data
"""
sectors = m_data['Components']
tickers = " ".join(sectors)
tickers = index_appender(tickers)
all_tickers = tickers.split(' ')
if isinstance(period, (list)):
period = period[0]
# tickers = index_appender(tickers)
print(" ")
print(f'Fetching Type Composite Index funds for {period}...')
data, _ = download_data_indexes(
indexes=sectors, tickers=all_tickers, period=period, interval='1d')
print(" ")
return data, sectors
def get_metrics_content() -> dict:
"""Get Metrics Content
Returns:
dict -- metrics file data
"""
metrics_file = os.path.join("resources", "sectors.json")
if not os.path.exists(metrics_file):
print(
f"{WARNING}WARNING: '{metrics_file}' not found for " +
f"'metrics_initializer'. Failed.{NORMAL}")
return None, [], None
with open(metrics_file) as m_file:
m_data = json.load(m_file)
m_file.close()
m_data = m_data.get("Type_Composite")
return m_data
def type_composites(composite: dict, m_data: dict, type_type='Defensive') -> list:
"""Type Composites
Create the summed clustered composites
Arguments:
composite {dict} -- composite dictionary
m_data {dict} -- data from sectors.json
Keyword Arguments:
type_type {str} -- key for each m_data (default: {'Defensive'})
Returns:
list -- summed list of composites
"""
sector_data = m_data[type_type]
start_key = list(sector_data.keys())[0]
new_composite = []
for i in range(len(composite[start_key])):
value = 0.0
for fund in sector_data:
value += float(composite[fund][i]) * sector_data[fund]
new_composite.append(value)
return new_composite
def weighted_signals(data: dict, m_data: dict, type_type='Defensive') -> list:
"""Weighted Signals
Arguments:
data {dict} -- tci data object
m_data {dict} -- sectors.json content
Keyword Arguments:
type_type {str} -- (default: {'Defensive'})
Returns:
list -- weighted signal
"""
sector_data = m_data[type_type]
start_key = list(sector_data.keys())[0]
new_composite = [25.0]
for i in range(1, len(data[start_key]['Close'])):
value = 0.0
for fund in sector_data:
value += (data[fund]['Close'][i] - data[fund]['Close'][i-1]) /\
data[fund]['Close'][i-1] * sector_data[fund]
value = new_composite[-1] * (1.0 + value)
new_composite.append(value)
return new_composite
|
[
"ngamell@mmm.com"
] |
ngamell@mmm.com
|
da60ebdb0c9f8856df41a22fbe7a5925c0a77927
|
a4d250ce393012dc251cb955096cb8f284c57439
|
/gunion/data/battle.py
|
2e86c5bc5fb1e0344791a01e941d7330c554ed7e
|
[] |
no_license
|
daxingyou/test-2
|
b02af312784d06a46e29acd42e756e92afee6ed9
|
a16c872ba781855a8c891eff41e8e651cd565ebf
|
refs/heads/master
| 2023-03-16T04:21:23.704482
| 2018-09-28T00:51:23
| 2018-09-28T00:51:23
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 11,188
|
py
|
#coding:utf8
"""
Created on 2016-07-28
@Author: jiangtaoran(jiangtaoran@ice-time.cn)
@Brief : 联盟战争
"""
import base64
from utils import logger
from utils import utils
from datalib.data_loader import data_loader
class UnionBattleInfo(object):
"""一场联盟战争
"""
BATTLE_STAGE_INVALID = 0 #非法
BATTLE_STAGE_IDLE = 1 #无战争
BATTLE_STAGE_PREPARE = 2 #备战阶段
BATTLE_STAGE_FIGHT = 3 #战斗阶段
BATTLE_STAGE_CLOSE = 4 #结束
__slots__ = [
"id",
"union_id",
"index",
"stage",
"rival_union_id",
"rival_battle_id",
"is_initiator", #是否战争发起方
"launch_time", #战争发起时间
"fight_time", #战争开战时间
"close_time", #战争结束时间
"finish_time", #战争生命周期终止时间，可以开始下一场战争
"is_deployed", #是否已经完成防御部署
"battle_count", #战斗的数量
"score", #胜场积分
"individuals_score", #成员战功之和
"drum",
"attack_level",
"attack_win_count_this_level", #本轮战斗中攻击胜利次数
"attack_lose_count_this_level", #本轮战斗中攻击失败次数
"defend_nodes_level", #防守方的节点level
"record_index",
"accepted_members", #大宝箱领取的记录
"accepted_names",
"accepted_icons",
"reward_items",
"reward_nums",
"accept_times"
]
def __init__(self):
self.id = 0
self.union_id = 0
self.index = 0
self.stage = UnionBattleInfo.BATTLE_STAGE_INVALID
self.rival_union_id = 0
self.rival_battle_id = 0
self.is_initiator = False
self.launch_time = 0
self.fight_time = 0
self.close_time = 0
self.finish_time = 0
self.is_deployed = False
self.battle_count = 0
self.score = 0
self.individuals_score = 0
self.drum = 0
self.attack_level = 1
self.attack_win_count_this_level = 0
self.attack_lose_count_this_level = 0
self.defend_nodes_level = ""
self.record_index = 0
@staticmethod
def generate_id(union_id, index):
id = union_id << 32 | index
return id
@staticmethod
def create(union_id, index, invalid):
battle = UnionBattleInfo()
battle.id = UnionBattleInfo.generate_id(union_id, index)
battle.union_id = union_id
battle.index = index
if invalid:
battle.stage = UnionBattleInfo.BATTLE_STAGE_INVALID #无法发起战争
else:
battle.stage = UnionBattleInfo.BATTLE_STAGE_IDLE
battle.rival_union_id = 0
battle.rival_battle_id = 0
battle.is_initiator = False
battle.launch_time = 0
battle.fight_time = 0
battle.close_time = 0
battle.finish_time = 0
battle.is_deployed = False
battle.battle_count = 0
battle.score = 0
battle.individuals_score = 0
battle.drum = 0
battle.attack_level = 1
battle.attack_win_count_this_level = 0
battle.attack_lose_count_this_level = 0
battle.defend_nodes_level = ""
battle.record_index = 0
battle.accepted_members = "" #奖励箱领取
battle.accepted_names = ""
battle.accepted_icons = ""
battle.reward_items = ""
battle.reward_nums = ""
battle.accept_times = ""
return battle
def force_update_fight_time(self, time):
"""强制改变开战时间（内部接口）
"""
assert self.stage == self.BATTLE_STAGE_PREPARE
self.fight_time = time
def force_update_close_time(self, time):
"""强制改变结束战斗时间（内部接口）
"""
assert self.stage == self.BATTLE_STAGE_FIGHT
self.close_time = time
def force_update_finish_time(self, time):
"""强制改变结束时间（内部接口）
"""
assert self.stage == self.BATTLE_STAGE_CLOSE
self.finish_time = time
def is_able_to_join(self):
"""是否可以参战
"""
return self.stage == self.BATTLE_STAGE_IDLE
def is_able_to_deploy(self):
"""是否可以部署防御
"""
return self.stage == self.BATTLE_STAGE_PREPARE
def is_able_to_drum(self):
"""是否可以擂鼓
"""
return self.stage == self.BATTLE_STAGE_FIGHT
def is_at_war(self):
"""是否在交战中
"""
return (self.stage == self.BATTLE_STAGE_PREPARE or
self.stage == self.BATTLE_STAGE_FIGHT or
self.stage == self.BATTLE_STAGE_CLOSE)
def launch(self, now, rival_union_id, rival_battle_id, initiative = True):
"""发起战争
"""
assert self.stage == self.BATTLE_STAGE_IDLE
self.stage = self.BATTLE_STAGE_PREPARE
self.rival_union_id = rival_union_id
self.rival_battle_id = rival_battle_id
self.is_initiator = initiative
self.launch_time = now
#self.fight_time = utils.get_spec_second(
# self.launch_time, "22:30") + utils.SECONDS_OF_DAY #launch time 次日22:30
#self.close_time = self.fight_time + utils.SECONDS_OF_DAY #fight time 次日22:30
#self.finish_time = utils.get_spec_second(
# self.close_time, "05:00" ) + utils.SECONDS_OF_DAY #close time 次日05:00
self.fight_time = utils.get_spec_second(self.launch_time, "21:00") #fight time 当日21:00
self.close_time = utils.get_spec_second(self.launch_time, "23:00") #close time 当日23:00
self.finish_time = utils.get_spec_second(self.launch_time, "05:00"
) + utils.SECONDS_OF_DAY #finish time 次日05:00
self.is_deployed = False
self.accepted_members = ""
self.accepted_names = ""
self.accepted_icons = ""
self.reward_items = ""
self.reward_nums = ""
self.accept_times = ""
def start_fight(self, now):
"""进入开战阶段
"""
assert self.stage == self.BATTLE_STAGE_PREPARE
self.stage = self.BATTLE_STAGE_FIGHT
self.is_deployed = True
self.attack_level = 1
def is_fight_closed(self, now):
"""战斗结算是否结束
"""
return self.launch_time != 0 and now >= self.close_time
def close_fight(self):
"""战争结束
"""
#assert self.stage == self.BATTLE_STAGE_FIGHT
self.stage = self.BATTLE_STAGE_CLOSE
def is_finished(self, now):
"""战争是否结束
"""
return self.launch_time != 0 and now >= self.finish_time and now >= self.close_time
def is_able_to_start(self):
"""是否可以开战
"""
return self.stage == self.BATTLE_STAGE_FIGHT
def beat_drum(self, value = 1):
"""擂鼓
"""
assert value >= 0
self.drum += value
def get_attack_buff_count(self):
"""获取当前攻击 buff 加成
"""
drum_ratio = int(float(
data_loader.UnionConfInfo_dict["attack_buff_count_per_drum"].value))
lose_ratio = int(float(
data_loader.UnionConfInfo_dict["attack_buff_count_per_lose"].value))
return self.drum * drum_ratio + self.attack_lose_count_this_level * lose_ratio
def get_attack_buff_temporary_count(self):
"""获取当前轮次临时攻击 buff 加成
"""
lose_ratio = int(float(
data_loader.UnionConfInfo_dict["attack_buff_count_per_lose"].value))
return self.attack_lose_count_this_level * lose_ratio
def mark_attack_result(self, win):
"""记录攻击结果
"""
if win:
self.attack_win_count_this_level += 1
#else:
# self.attack_lose_count_this_level += 1
#攻击进入下一轮
count = int(float(data_loader.UnionConfInfo_dict["battle_map_node_count"].value))
if self.attack_win_count_this_level >= count:
self.attack_level += 1
self.attack_win_count_this_level = 0
self.attack_lose_count_this_level = 0
def gain_union_score(self, value = 1):
"""增加联盟胜场积分
"""
assert value >= 0
self.score += value
def gain_individuals_score(self, value):
"""增加成员战功点数
"""
assert value >= 0
self.individuals_score += value
def get_next_record_index(self):
"""获取下一个战斗记录 index
"""
self.record_index += 1
return self.record_index
def is_able_to_accept_box(self):
"""是否可以领取大宝箱/
"""
if self.stage != self.BATTLE_STAGE_CLOSE:
return False
level = int(float(data_loader.UnionConfInfo_dict["battle_map_total_level"].value))
count = int(float(data_loader.UnionConfInfo_dict["battle_map_node_count"].value))
if level * count > self.score:
return False
return True
def get_accepted_members(self):
"""获取领取过奖励的成员"""
return utils.split_to_int(self.accepted_members)
def get_reward_record(self):
"""获取奖励领取记录"""
members = utils.split_to_int(self.accepted_members)
names = utils.split_to_string(self.accepted_names)
icons = utils.split_to_int(self.accepted_icons)
items_id = utils.split_to_int(self.reward_items)
items_num = utils.split_to_int(self.reward_nums)
times = utils.split_to_int(self.accept_times)
names = [base64.b64decode(name) for name in names]
return map(None, members, names, icons, items_id, items_num, times)
def add_reward_record(self, user_id, user_name, icon_id, item_id, item_num, now):
"""添加领奖记录"""
members = utils.split_to_int(self.accepted_members)
names = utils.split_to_string(self.accepted_names)
icons = utils.split_to_int(self.accepted_icons)
items_id = utils.split_to_int(self.reward_items)
items_num = utils.split_to_int(self.reward_nums)
times = utils.split_to_int(self.accept_times)
members.append(user_id)
names.append(user_name)
icons.append(icon_id)
items_id.append(item_id)
items_num.append(item_num)
times.append(now)
self.accepted_members = utils.join_to_string(members)
self.accepted_names = utils.join_to_string(names)
self.accepted_icons = utils.join_to_string(icons)
self.reward_items = utils.join_to_string(items_id)
self.reward_nums = utils.join_to_string(items_num)
self.accept_times = utils.join_to_string(times)
|
[
"luhongwei1@ice-time.cn"
] |
luhongwei1@ice-time.cn
|
64c56cb8b06a7ea97fa9eaa40bc7a4d99d330d48
|
11b0c124262ac40de87d756389082462d8452e4d
|
/keras/keras44_3_cancer_conv1d.py
|
7aaef711d66a0e504dbd364159570a7de778fe5d
|
[] |
no_license
|
Hyunwoo29/keras01
|
164b519f9bb70d55f7bfa91c66529cee4d012b24
|
494611a94420f8e268c37085ccf0b0de4aa71048
|
refs/heads/main
| 2023-08-06T07:19:13.288634
| 2021-10-05T14:03:56
| 2021-10-05T14:03:56
| 383,744,859
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,188
|
py
|
from sklearn.preprocessing import MaxAbsScaler, RobustScaler, QuantileTransformer, PowerTransformer, StandardScaler
from tensorflow.keras.callbacks import EarlyStopping
import numpy as np
from sklearn.datasets import load_breast_cancer
from icecream import ic
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, LSTM, Conv1D, Flatten
from tensorflow.keras.utils import to_categorical
from sklearn.model_selection import train_test_split
import time
from sklearn.metrics import r2_score
#1. 데이터
datasets = load_breast_cancer()
x = datasets.data
y = datasets.target
ic(x, y) # ic| x.shape: (569, 30), y.shape: (569,)
x_train, x_test, y_train, y_test = train_test_split(x,y, train_size=0.7, random_state=60) # train 309, test 133
# scaler = QuantileTransformer()
scaler = StandardScaler()
# scaler = PowerTransformer()
# scaler = RobustScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)
x_train = x_train.reshape(x_train.shape[0], x_train.shape[1], 1)
x_test = x_test.reshape(x_test.shape[0], x_test.shape[1], 1)
# ic(x_train.shape, x_test.shape)
# ic(np.unique(y))
model = Sequential()
model.add(LSTM(40, activation='relu', input_shape=(30,1), return_sequences=True))
model.add(Conv1D(128, 2))
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(64, activation='relu'))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(16, activation='relu'))
model.add(Flatten())
model.add(Dense(1,activation='sigmoid'))
model.summary()
#3. 컴파일, 훈련
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc'])
es = EarlyStopping(monitor='acc', patience=20, mode='auto', verbose=1)
start = time.time()
model.fit(x_train, y_train, epochs=100, verbose=1, validation_split=0.2, batch_size=32, shuffle=True, callbacks=[es])
걸린시간 = round((time.time() - start) /60,1)
#4. 평가, 예측
y_predict = model.predict(x_test)
loss = model.evaluate(x_test, y_test)
ic(loss[0])
ic(loss[1])
ic(f'{걸린시간}분')
# ic| loss[0]: 0.028651483356952667
# ic| loss[1]: 0.988304078578949
# ic| f'{걸린시간}분': '0.8분'
|
[
"nbaksa3@gamil.com"
] |
nbaksa3@gamil.com
|
da4d9970097abb9879bdaf10f8d859c5287053b0
|
5b8fcb1bf82a7c1ef5b6c2a939b1d1597bc7a24b
|
/create_json_for_airtable_operator.py
|
e00238b2f39eae43c6d55eae4974dcf2d194d262
|
[] |
no_license
|
katerinekhh/airflow_custom_stuff
|
2420c3ee95dab01e5eeeb8248500e253126e5b48
|
43ba78d96770a575ba7ab11a691b101e6d6604af
|
refs/heads/master
| 2022-10-12T13:55:01.916266
| 2020-06-12T13:17:06
| 2020-06-12T13:17:06
| 271,645,308
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,245
|
py
|
from datetime import datetime
import json
from airflow.utils.decorators import apply_defaults
from airflow.models.baseoperator import BaseOperator
from airflow.hooks.http_hook import HttpHook
class CreateJsonForAirtableOperator(BaseOperator):
@apply_defaults
def __init__(
self,
endpoint: str,
http_conn_id: str,
message_id_filepath: str,
update_filepath: str,
method='GET',
request_params=None,
*args, **kwargs,
):
super().__init__(*args, **kwargs)
self.http_conn_id = http_conn_id
self.request_params = request_params or {}
self.endpoint = endpoint
self.message_id_filepath = message_id_filepath
self.update_filepath = update_filepath
self.hook = HttpHook(
method=method,
http_conn_id=http_conn_id)
def execute(self, context):
response = self.hook.run(self.endpoint, data=self.request_params)
with open(self.message_id_filepath, 'r') as id_file:
message_id = id_file.read()
json_response = json.loads(response.text)
airtable_updates_data = {}
airtable_updates_data['records'] = []
for update in json_response['result']:
update_data_fields = {}
update_data = {}
if update['callback_query']['message']['message_id'] == int(message_id):
chat_id = update['callback_query']['message']['chat']['id']
username = update['callback_query']['from']['username']
triggered_at = datetime.fromtimestamp(
update['callback_query']['message']['date']).isoformat()[:-3] + "Z"
update_data['chat_id'] = chat_id
update_data['username'] = username
update_data['triggered_at'] = triggered_at
update_data['event_type'] = 'push_go_button'
update_data['reporter_name'] = 'khkaterina'
update_data_fields['fields'] = update_data
airtable_updates_data['records'].append(update_data_fields)
with open(self.update_filepath, 'w') as file:
json.dump(airtable_updates_data, file)
|
[
"you@example.com"
] |
you@example.com
|
cf4cd861229bcd84028e5670c4292b18a9ce0692
|
e0cf5219ff9ad4eab2000516739ee651d7aa4c8f
|
/models/nets.py
|
ca62b8e0f15aec8c1b12dff278ba3f28a6d8c6c6
|
[
"MIT"
] |
permissive
|
Perfec-Yu/Lifelong-ED
|
cbf32f6e2d3ccf393eec08e5dbfb29e5e3c1b28b
|
f1af49129dd6ed4ff545f84e680565cccdb5b55a
|
refs/heads/main
| 2023-07-19T23:52:41.932196
| 2021-09-02T15:26:36
| 2021-09-02T15:26:36
| 402,468,387
| 13
| 2
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 32,092
|
py
|
import numpy
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import autograd
import math
from typing import Any, Dict, Tuple, List, Union, Set
import warnings
from collections import OrderedDict
from torch.nn.modules.linear import Linear
from torchmeta.modules import MetaLinear, MetaSequential, MetaModule
from tqdm import tqdm
class LInEx(MetaModule):
def __init__(self,input_dim:int,hidden_dim:int,max_slots:int,init_slots:int,device:Union[torch.device, None]=None,**kwargs)->None:
super().__init__()
if input_dim != hidden_dim:
self.input_map = MetaSequential(OrderedDict({
"linear_0": MetaLinear(input_dim, hidden_dim),
"relu_0": nn.ReLU(),
"dropout_0": nn.Dropout(0.2),
"linear_1": MetaLinear(hidden_dim, hidden_dim),
"relu_1": nn.ReLU()
}))
else:
self.input_map = lambda x:x
self.classes = MetaLinear(hidden_dim, max_slots, bias=False)
_mask = torch.zeros(1, max_slots, dtype=torch.float, device=device)
_mask[:, init_slots:] = float("-inf")
self.register_buffer(name="_mask", tensor=_mask)
self.crit = nn.CrossEntropyLoss()
self.device = device
self.to(device=device)
self.nslots = init_slots
self.max_slots = max_slots
self.maml = True
self.outputs = {}
self.history = None
self.exemplar_features = None
self.exemplar_labels = None
self.dev_exemplar_features = None
self.dev_exemplar_labels = None
@property
def mask(self,):
self._mask[:, :self.nslots] = 0
self._mask[:, self.nslots:] = float("-inf")
return self._mask
def idx_mask(self, idx:Union[torch.LongTensor, int, List[int], None]=None, max_idx:Union[torch.LongTensor, int, None]=None):
assert (idx is not None) or (max_idx is not None)
assert (idx is None) or (max_idx is None)
mask = torch.zeros_like(self._mask) + float("-inf")
if idx is not None:
mask[:, idx] = 0
if max_idx is not None:
if isinstance(max_idx, torch.LongTensor):
max_idx = max_idx.item()
mask[:, :max_idx] = 0
return mask
@property
def features(self):
return self.classes.weight[:self.nslots]
def forward(self, batch, nslots:int=-1, exemplar:bool=False, exemplar_distill:bool=False, feature_distill:bool=False, mul_distill=False, distill:bool=False, return_loss:bool=True, return_feature:bool=False, tau:float=1.0, log_outputs:bool=True, params=None):
if isinstance(batch, (tuple, list)) and len(batch) == 2:
features, labels = batch
else:
features, labels = batch.features, batch.labels
inputs = self.input_map(features, params=self.get_subdict(params, "input_map"))
scores = self.classes(inputs, params=self.get_subdict(params, "classes"))
if torch.any(torch.isnan(scores)):
print(scores[0])
input('a')
if nslots == -1:
scores += self.mask
if torch.any(torch.isnan(scores)):
print(scores[0])
input()
nslots = self.nslots
else:
scores += self.idx_mask(max_idx=nslots)
scores[:, 0] = 0
if scores.size(0) != labels.size(0):
assert scores.size(0) % labels.size(0) == 0
labels = labels.repeat_interleave(scores.size(0) // labels.size(0), dim=0)
else:
labels = labels
if log_outputs:
pred = torch.argmax(scores, dim=1)
acc = torch.mean((pred == labels).float())
self.outputs["accuracy"] = acc.item()
self.outputs["prediction"] = pred.detach().cpu()
self.outputs["label"] = labels.detach().cpu()
self.outputs["input_features"] = features.detach().cpu()
self.outputs["encoded_features"] = inputs.detach().cpu()
if return_loss:
labels.masked_fill_(labels >= nslots, 0)
valid = labels < nslots
nvalid = torch.sum(valid.float())
if nvalid == 0:
loss = 0
else:
loss = self.crit(scores[valid], labels[valid])
if torch.isnan(loss):
print(labels, nslots, scores[:, :nslots])
input()
if distill and self.history is not None:
old_scores, old_inputs = self.forward(batch, nslots=self.history["nslots"], return_loss=False, log_outputs=False, return_feature=True, params=self.history["params"])
old_scores = old_scores.detach()
old_inputs = old_inputs.detach()
new_scores = scores[:, :self.history["nslots"]]
if mul_distill:
loss_distill = - torch.sum(torch.softmax(old_scores*tau, dim=1) * torch.log_softmax(new_scores*tau, dim=1), dim=1).mean()
old_dist = torch.softmax(old_scores/tau, dim=1)
old_valid = (old_dist[:, 0] < 0.9)
old_num = torch.sum(old_valid.float())
if old_num > 0:
# print(old_dist[old_valid].topk(5, dim=1), batch.labels[old_valid])
# input()
loss_mul_distill = - torch.sum(old_dist[old_valid] * torch.log_softmax(new_scores[old_valid], dim=1), dim=1).sum()
loss_distill = (loss_distill * old_dist.size(0) + loss_mul_distill) / (old_dist.size(0) + old_num)
else:
loss_distill = - torch.sum(torch.softmax(old_scores*tau, dim=1) * torch.log_softmax(new_scores*tau, dim=1), dim=1).mean()
if feature_distill:
loss_f_distill = (1 - (old_inputs / old_inputs.norm(dim=-1, keepdim=True) * inputs / inputs.norm(dim=-1, keepdim=True)).sum(dim=-1)).mean(dim=0)
loss_distill += loss_f_distill
d_weight = self.history["nslots"]
c_weight = (self.nslots - self.history["nslots"])
loss = ( d_weight * loss_distill+ c_weight* loss) / (d_weight+c_weight)
if torch.isnan(loss):
print(old_scores, new_scores)
input()
if exemplar and self.exemplar_features is not None:
if self.exemplar_features.size(0) < 128:
exemplar_inputs = self.input_map(self.exemplar_features.to(self.device), params=self.get_subdict(params, "input_map"))
exemplar_scores = self.classes(exemplar_inputs, params=self.get_subdict(params, "classes"))
else:
exemplar_scores = []
exemplar_inputs = []
for _beg in range(0, self.exemplar_features.size(0), 128):
_features = self.exemplar_features[_beg:_beg+128, :]
_inputs = self.input_map(_features.to(self.device), params=self.get_subdict(params, "input_map"))
exemplar_inputs.append(_inputs)
exemplar_scores.append(self.classes(_inputs, params=self.get_subdict(params, "classes")))
exemplar_inputs = torch.cat(exemplar_inputs, dim=0)
exemplar_scores = torch.cat(exemplar_scores, dim=0)
exemplar_scores[:, 0] = 0.
loss_exemplar = self.crit(exemplar_scores+self.mask, self.exemplar_labels.to(self.device))
if torch.isnan(loss_exemplar):
print(self.exemplar_labels, nslots)
input()
if exemplar_distill:
if self.exemplar_features.size(0) < 128:
exemplar_old_inputs = self.input_map(self.exemplar_features.to(self.device), params=self.get_subdict(self.history["params"], "input_map"))
exemplar_old_scores = self.classes(exemplar_old_inputs, params=self.get_subdict(self.history["params"], "classes"))
else:
exemplar_old_scores = []
exemplar_old_inputs = []
for _beg in range(0, self.exemplar_features.size(0), 128):
_features = self.exemplar_features[_beg:_beg+128, :]
_inputs = self.input_map(_features.to(self.device), params=self.get_subdict(self.history["params"], "input_map"))
exemplar_old_inputs.append(_inputs)
exemplar_old_scores.append(self.classes(_inputs, params=self.get_subdict(self.history["params"], "classes")))
exemplar_old_inputs = torch.cat(exemplar_old_inputs, dim=0)
exemplar_old_scores = torch.cat(exemplar_old_scores, dim=0)
exemplar_old_scores[:, 0] = 0.
exemplar_old_scores = exemplar_old_scores[:self.history["nslots"]]
loss_exemplar_distill = - torch.sum(torch.softmax(exemplar_old_scores[:self.history["nslots"]]*tau, dim=1) * torch.log_softmax(exemplar_scores[:self.history["nslots"]], dim=1), dim=1).mean()
if feature_distill:
loss_exemplar_feat_distill = (1 - (exemplar_old_inputs / exemplar_old_inputs.norm(dim=-1, keepdim=True) * exemplar_inputs / exemplar_inputs.norm(dim=-1, keepdim=True)).sum(dim=-1)).mean(dim=0)
loss_exemplar_distill += loss_exemplar_feat_distill
d_weight = self.history["nslots"]
c_weight = (self.nslots - self.history["nslots"])
loss_exemplar = (d_weight * loss_exemplar_distill+ c_weight* loss_exemplar) / (d_weight+c_weight)
e_weight = self.exemplar_features.size(0)
loss = (nvalid * loss + e_weight * loss_exemplar) / (nvalid + e_weight)
if torch.isnan(loss):
print(loss, loss_exemplar)
return loss
else:
if return_feature:
return scores[:, :nslots], inputs
else:
return scores[:, :nslots]
def score(self, *args, **kwargs):
return self.forward(*args, **kwargs)
def clone_params(self,):
return OrderedDict({k:v.clone().detach() for k,v in self.meta_named_parameters()})
def set_history(self,):
self.history = {"params": self.clone_params(), "nslots": self.nslots}
def set_exemplar(self, dataloader, q:int=20, params=None, label_sets:Union[List, Set, None]=None, collect_none:bool=False, use_input:bool=False, output_only:bool=False, output:Union[str, None]=None):
self.eval()
with torch.no_grad():
ifeat = []; ofeat = []; label = []
num_batches = len(dataloader)
for batch in tqdm(dataloader, "collecting exemplar", ncols=128):
batch = batch.to(self.device)
loss = self.forward(batch, params=params)
ifeat.append(self.outputs["input_features"])
if use_input:
ofeat.append(self.outputs["input_features"])
else:
ofeat.append(self.outputs["encoded_features"])
label.append(self.outputs["label"])
ifeat = torch.cat(ifeat, dim=0)
ofeat = torch.cat(ofeat, dim=0)
label = torch.cat(label, dim=0)
nslots = max(self.nslots, torch.max(label).item()+1)
exemplar = {}
if label_sets is None:
if collect_none:
label_sets = range(nslots)
else:
label_sets = range(1, nslots)
else:
if collect_none:
if 0 not in label_sets:
label_sets = sorted([0] + list(label_sets))
else:
label_sets = sorted(list(label_sets))
else:
label_sets = sorted([t for t in label_sets if t != 0])
for i in label_sets:
idx = (label == i)
if i == 0:
# random sample for none type
nidx = torch.nonzero(idx, as_tuple=True)[0].tolist()
exemplar[i] = numpy.random.choice(nidx, q, replace=False).tolist()
continue
if torch.any(idx):
exemplar[i] = []
nidx = torch.nonzero(idx, as_tuple=True)[0].tolist()
mfeat = torch.mean(ofeat[idx], dim=0, keepdims=True)
if len(nidx) < q:
exemplar[i].extend(nidx * (q // len(nidx)) + nidx[:(q % len(nidx))])
else:
for j in range(q):
if j == 0:
dfeat = torch.sum((ofeat[nidx] - mfeat)**2, dim=1)
else:
cfeat = ofeat[exemplar[i]].sum(dim=0, keepdims=True)
cnum = len(exemplar[i])
dfeat = torch.sum((mfeat * (cnum + 1) - ofeat[nidx] - cfeat)**2, )
tfeat = torch.argmin(dfeat)
exemplar[i].append(nidx[tfeat])
nidx.pop(tfeat.item())
exemplar = {i: ifeat[v] for i,v in exemplar.items()}
exemplar_features = []
exemplar_labels = []
for label, features in exemplar.items():
exemplar_features.append(features)
exemplar_labels.extend([label]*features.size(0))
exemplar_features = torch.cat(exemplar_features, dim=0).cpu()
exemplar_labels = torch.LongTensor(exemplar_labels).cpu()
if not output_only or output is not None:
if output == "train" or output is None:
if self.exemplar_features is None:
self.exemplar_features = exemplar_features
self.exemplar_labels = exemplar_labels
else:
self.exemplar_features = torch.cat((self.exemplar_features, exemplar_features), dim=0)
self.exemplar_labels = torch.cat((self.exemplar_labels, exemplar_labels), dim=0)
elif output == "dev":
if self.dev_exemplar_features is None:
self.dev_exemplar_features = exemplar_features
self.dev_exemplar_labels = exemplar_labels
else:
self.dev_exemplar_features = torch.cat((self.dev_exemplar_features, exemplar_features), dim=0)
self.dev_exemplar_labels = torch.cat((self.dev_exemplar_labels, exemplar_labels), dim=0)
return {i: v.cpu() for i,v in exemplar.items()}
def initialize(self, exemplar, ninstances:Dict[int, int], gamma:float=1.0, tau:float=1.0, alpha:float=0.5, params=None):
self.eval()
with torch.no_grad():
weight_norm = torch.norm(self.classes.weight[1:self.nslots], dim=1).mean(dim=0)
label_inits = []
label_kt = {}
for label, feats in exemplar.items():
exemplar_inputs = self.input_map(feats.to(self.device), params=self.get_subdict(params, "input_map"))
exemplar_scores = self.classes(exemplar_inputs, params=self.get_subdict(params, "classes"))
exemplar_scores = exemplar_scores + self.mask
exemplar_scores[:, 0] = 0
exemplar_weights = torch.softmax(exemplar_scores * tau, dim=1)
normalized_inputs = exemplar_inputs / torch.norm(exemplar_inputs, dim=1, keepdim=True) * weight_norm
proto = (exemplar_weights[:, :1] * normalized_inputs).mean(dim=0)
knowledge = torch.matmul(exemplar_weights[:, 1:self.nslots], self.classes.weight[1:self.nslots]).mean(dim=0)
gate = alpha * math.exp(- ninstances[label] * gamma)
# gate = 1 / (1 + ninstances[label] * gamma)
rnd = torch.randn_like(proto) * weight_norm / math.sqrt(self.classes.weight.size(1))
initvec = proto * gate + knowledge * gate + (1 - gate) * rnd
label_inits.append((label, initvec.cpu()))
label_kt[label] = exemplar_weights.mean(dim=0).cpu()
label_inits.sort(key=lambda t:t[0])
inits = []
for i, (label, init) in enumerate(label_inits):
assert label == self.nslots + i
inits.append(init)
inits = torch.stack(inits, dim=0)
self.outputs["new2old"] = label_kt
return inits.detach()
def initialize2(self, exemplar, ninstances:Dict[int, int], gamma:float=1.0, tau:float=1.0, alpha:float=0.5, delta:float=0.5, params=None):
self.eval()
def top_p(probs, p=0.9):
_val, _idx = torch.sort(probs, descending=True, dim=1)
top_mask = torch.zeros_like(probs).float() - float("inf")
for _type in range(probs.size(0)):
accumulated = 0
_n = 0
while accumulated < p or _n <= 1:
top_mask[_type, _idx[_type, _n]] = 0
accumulated += _val[_type, _n]
_n += 1
return top_mask
with torch.no_grad():
weight_norm = torch.norm(self.classes.weight[1:self.nslots], dim=1).mean(dim=0)
label_inits = []
label_kt = {}
for label, feats in exemplar.items():
exemplar_inputs = self.input_map(feats.to(self.device), params=self.get_subdict(params, "input_map"))
exemplar_scores = self.classes(exemplar_inputs, params=self.get_subdict(params, "classes"))
exemplar_scores = exemplar_scores + self.mask
exemplar_scores[:, 0] = 0
top_mask = top_p(torch.softmax(exemplar_scores, dim=1))
exemplar_scores = exemplar_scores + top_mask
exemplar_scores[:, 0] = 0
exemplar_weights = torch.softmax(exemplar_scores * tau, dim=1)
normalized_inputs = exemplar_inputs / torch.norm(exemplar_inputs, dim=1, keepdim=True) * weight_norm
proto = delta * (exemplar_weights[:, :1] * normalized_inputs).mean(dim=0)
kweight = (1 - exemplar_weights[:, :1])
knowledge = torch.matmul((1-delta*exemplar_weights[:, :1]) * (exemplar_weights[:, 1:self.nslots] + 1e-8) / torch.clamp(1 - exemplar_weights[:, :1], 1e-8), self.classes.weight[1:self.nslots]).mean(dim=0)
gate = alpha * math.exp(- ninstances[label] * gamma)
rnd = torch.randn_like(proto) * weight_norm / math.sqrt(self.classes.weight.size(1))
initvec = proto * gate + knowledge * gate + (1 - gate) * rnd
if torch.any(torch.isnan(initvec)):
print(proto, knowledge, rnd, gate, exemplar_weights[:, :1], exemplar_scores[-1, :self.nslots])
input()
label_inits.append((label, initvec.cpu()))
label_kt[label] = exemplar_weights.mean(dim=0).cpu()
label_inits.sort(key=lambda t:t[0])
inits = []
for i, (label, init) in enumerate(label_inits):
assert label == self.nslots + i
inits.append(init)
inits = torch.stack(inits, dim=0)
self.outputs["new2old"] = label_kt
return inits.detach()
def set(self, features:torch.tensor, ids:Union[int, torch.Tensor, List, None]=None, max_id:int=-1):
with torch.no_grad():
if isinstance(ids, (torch.Tensor, list)):
if torch.any(ids > self.nslots):
warnings.warn("Setting features to new classes. Using 'extend' or 'append' is preferred for new classes")
self.classes.weight[ids] = features
elif isinstance(ids, int):
self.classes.weight[ids] = features
else:
if max_id == -1:
raise ValueError(f"Need input for either ids or max_id")
self.classes.weight[:max_id] = features
def append(self, feature):
with torch.no_grad():
self.classes.weight[self.nslots] = feature
self.nslots += 1
def extend(self, features):
with torch.no_grad():
features = features.to(self.device)
if len(features.size()) == 1:
warnings.warn("Extending 1-dim feature vector. Using 'append' instead is preferred.")
self.append(features)
else:
nclasses = features.size(0)
self.classes.weight[self.nslots:self.nslots+nclasses] = features
self.nslots += nclasses
class BIC(LInEx):
def __init__(self,input_dim:int,hidden_dim:int,max_slots:int,init_slots:int,device:Union[torch.device, None]=None, **kwargs)->None:
super().__init__(input_dim,hidden_dim,max_slots,init_slots,device,**kwargs)
self.correction_weight = nn.Parameter(torch.ones(1, dtype=torch.float, device=self.device, requires_grad=True))
self.correction_bias = nn.Parameter(torch.zeros(1, dtype=torch.float, device=self.device, requires_grad=True))
self.correction_stream = [init_slots]
def add_stream(self, num_classes):
self.correction_stream.append(self.correction_stream[-1]+num_classes)
def forward(self, batch, nslots:int=-1, bias_correction:str="none", exemplar:bool=False, exemplar_distill:bool=False, distill:bool=False, return_loss:bool=True, tau:float=1.0, log_outputs:bool=True, params=None):
assert bias_correction in ["none", "last", "current"]
if distill:
assert bias_correction != "current"
if isinstance(batch, (tuple, list)) and len(batch) == 2:
features, labels = batch
else:
features, labels = batch.features, batch.labels
inputs = self.input_map(features, params=self.get_subdict(params, "input_map"))
scores = self.classes(inputs, params=self.get_subdict(params, "classes"))
if nslots == -1:
scores += self.mask
nslots = self.nslots
else:
scores += self.idx_mask(max_idx=nslots)
scores[:, 0] = 0
if bias_correction == "current":
assert len(self.correction_stream) >= 2
scores[:, self.correction_stream[-2]:self.correction_stream[-1]] *= self.correction_weight
scores[:, self.correction_stream[-2]:self.correction_stream[-1]] += self.correction_bias
if scores.size(0) != labels.size(0):
assert scores.size(0) % labels.size(0) == 0
labels = labels.repeat_interleave(scores.size(0) // labels.size(0), dim=0)
else:
labels = labels
if log_outputs:
pred = torch.argmax(scores, dim=1)
acc = torch.mean((pred == labels).float())
self.outputs["accuracy"] = acc.item()
self.outputs["prediction"] = pred.detach().cpu()
self.outputs["label"] = labels.detach().cpu()
self.outputs["input_features"] = features.detach().cpu()
self.outputs["encoded_features"] = inputs.detach().cpu()
if return_loss:
labels.masked_fill_(labels >= nslots, 0)
valid = labels < nslots
nvalid = torch.sum(valid.float())
if nvalid == 0:
loss = 0
else:
loss = self.crit(scores[valid], labels[valid])
if distill and self.history is not None:
old_scores = self.forward(batch, nslots=self.history["nslots"], return_loss=False, log_outputs=False, params=self.history["params"]).detach()
if bias_correction == "last":
old_scores[:, self.correction_stream[-2]:self.correction_stream[-1]] *= self.history['correction_weight']
old_scores[:, self.correction_stream[-2]:self.correction_stream[-1]] += self.history['correction_bias']
new_scores = scores[:, :self.history["nslots"]]
loss_distill = - torch.sum(torch.softmax(old_scores*tau, dim=1) * torch.log_softmax(new_scores*tau, dim=1), dim=1).mean()
d_weight = self.history["nslots"]
c_weight = (self.nslots - self.history["nslots"])
loss = ( d_weight * loss_distill+ c_weight* loss) / (d_weight+c_weight)
if exemplar and self.exemplar_features is not None:
if self.exemplar_features.size(0) < 128:
exemplar_inputs = self.input_map(self.exemplar_features.to(self.device), params=self.get_subdict(params, "input_map"))
exemplar_scores = self.classes(exemplar_inputs, params=self.get_subdict(params, "classes"))
else:
exemplar_scores = []
for _beg in range(0, self.exemplar_features.size(0), 128):
_features = self.exemplar_features[_beg:_beg+128, :]
_inputs = self.input_map(_features.to(self.device), params=self.get_subdict(params, "input_map"))
exemplar_scores.append(self.classes(_inputs, params=self.get_subdict(params, "classes")))
exemplar_scores = torch.cat(exemplar_scores, dim=0)
exemplar_scores[:, 0] = 0.
loss_exemplar = self.crit(exemplar_scores+self.mask, self.exemplar_labels.to(self.device))
if exemplar_distill:
if self.exemplar_features.size(0) < 128:
exemplar_old_inputs = self.input_map(self.exemplar_features.to(self.device), params=self.get_subdict(self.history["params"], "input_map"))
exemplar_old_scores = self.classes(exemplar_old_inputs, params=self.get_subdict(self.history["params"], "classes"))
else:
exemplar_old_scores = []
for _beg in range(0, self.exemplar_features.size(0), 128):
_features = self.exemplar_features[_beg:_beg+128, :]
_inputs = self.input_map(_features.to(self.device), params=self.get_subdict(self.history["params"], "input_map"))
exemplar_old_scores.append(self.classes(_inputs, params=self.get_subdict(self.history["params"], "classes")))
exemplar_old_scores = torch.cat(exemplar_old_scores, dim=0)
exemplar_old_scores[:, 0] = 0.
if bias_correction == "last":
exemplar_old_scores[:, self.correction_stream[-2]:self.correction_stream[-1]] *= self.history['correction_weight']
exemplar_old_scores[:, self.correction_stream[-2]:self.correction_stream[-1]] += self.history['correction_bias']
exemplar_old_scores = exemplar_old_scores[:self.history["nslots"]]
loss_exemplar_distill = - torch.sum(torch.softmax(exemplar_old_scores[:self.history["nslots"]]*tau, dim=1) * torch.log_softmax(exemplar_scores[:self.history["nslots"]], dim=1), dim=1).mean()
d_weight = self.history["nslots"]
c_weight = (self.nslots - self.history["nslots"])
loss_exemplar = (d_weight * loss_exemplar_distill+ c_weight* loss_exemplar) / (d_weight+c_weight)
e_weight = self.exemplar_features.size(0)
loss = (nvalid * loss + e_weight * loss_exemplar) / (nvalid + e_weight)
if torch.isnan(loss):
print(loss, loss_exemplar)
return loss
else:
return scores[:, :nslots]
def forward_correction(self, *args, **kwargs):
'''
training:
entropy: normal
distill:
old, last
Fold, Fold * correction_weight + correction_bias,
'''
if len(args) >= 3:
args[2] = "current"
else:
kwargs["bias_correction"] = "current"
return self.forward(*args,**kwargs)
def set_history(self):
super().set_history()
self.history["correction_weight"] = self.correction_weight.item()
self.history["correction_bias"] = self.correction_bias.item()
def score(self, *args, **kwargs):
if len(self.correction_stream) >= 2:
return self.forward_correction(*args, **kwargs)
else:
if len(args) >= 3:
args[2] = "none"
else:
kwargs["bias_correction"] = "none"
return self.forward(*args, **kwargs)
class ICARL(LInEx):
def __init__(self,input_dim:int,hidden_dim:int,max_slots:int,init_slots:int,device:Union[torch.device, None]=None, **kwargs)->None:
super().__init__(input_dim,hidden_dim,max_slots,init_slots,device,**kwargs)
self.none_feat = None
def set_none_feat(self, dataloader, params=None):
self.eval()
with torch.no_grad():
ifeat = []; ofeat = []; label = []
num_batches = len(dataloader)
for batch in tqdm(dataloader, "collecting exemplar"):
batch = batch.to(self.device)
loss = self.forward(batch, params=params)
ifeat.append(self.outputs["input_features"])
ofeat.append(self.outputs["encoded_features"])
label.append(self.outputs["label"])
ifeat = torch.cat(ifeat, dim=0)
ofeat = torch.cat(ofeat, dim=0)
label = torch.cat(label, dim=0)
nslots = max(self.nslots, torch.max(label).item()+1)
exemplar = {}
idx = (label == 0)
self.none_feat = ofeat[idx].mean(dim=0).cpu()
return self.none_feat
def score(self, batch, exemplar=None, params=None):
if exemplar is None:
exemplar_labels, exemplar_features = self.exemplar_labels, self.exemplar_features
else:
exemplar_labels, exemplar_features = exemplar
inputs = self.input_map(batch.features, params=self.get_subdict(params, "input_map"))
scores = []
scores.append(- torch.sum((inputs - self.none_feat.to(inputs.device).unsqueeze(0))**2, dim=1))
for i in range(1, self.nslots):
label_idx = (exemplar_labels == i)
label_features = exemplar_features[label_idx]
label_inputs = self.input_map(label_features.to(inputs.device), params=self.get_subdict(params, "input_map")).mean(dim=0, keepdim=True)
scores.append(- torch.sum((inputs - label_inputs)**2, dim=1))
scores = torch.stack(scores, dim=0).transpose(0, 1)
labels = batch.labels
if scores.size(0) != labels.size(0):
assert scores.size(0) % labels.size(0) == 0
labels = labels.repeat_interleave(scores.size(0) // labels.size(0), dim=0)
pred = torch.argmax(scores, dim=1)
acc = torch.mean((pred == labels).float())
labels.masked_fill_(labels >= self.nslots, 0)
valid = labels < self.nslots
nvalid = torch.sum(valid.float())
if nvalid == 0:
loss = 0
else:
loss = self.crit(scores[valid], labels[valid])
self.outputs["accuracy"] = acc.item()
self.outputs["prediction"] = pred.detach().cpu()
self.outputs["label"] = labels.detach().cpu()
self.outputs["input_features"] = batch.features.detach().cpu()
self.outputs["encoded_features"] = inputs.detach().cpu()
return loss
def test(): # sanity check
m = LInEx(nhead=8,nlayers=3,hidden_dim=512,input_dim=2048,max_slots=30,init_slots=9,device=torch.device("cpu"))
if __name__ == "__main__":
test()
|
[
"life4pf@163.com"
] |
life4pf@163.com
|
9dce78213c77274a834e67aa526b49d3187883d8
|
767318c4ddf2713a8a035aa3bf68cd8260409aa0
|
/travellow/urls.py
|
a644dc789f9aa6062a14454cf7171e52bf44b7fb
|
[] |
no_license
|
sag-coder/travelbooking
|
704573b145ca04587bbaf2415f4bbdb6ad50b26f
|
dfc482ca01d1be324aba900075b2a64dc2fd1d88
|
refs/heads/master
| 2023-06-11T23:22:44.114545
| 2021-07-10T23:47:37
| 2021-07-10T23:47:37
| 384,562,878
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 285
|
py
|
from django.urls import path
from . import views
from django.conf import settings
from django.conf.urls.static import static
urlpatterns=[
path('', views.index, name='index'),
]
urlpatterns = urlpatterns + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
|
[
"sagar@sagars-MacBook-Pro.local"
] |
sagar@sagars-MacBook-Pro.local
|
0757a5984a57b6a43f6f9c8dbc15fe28c3b58c96
|
9f77118ac2fdfbdc3174c1fdfaa32bcf2b5ead40
|
/ALL_FILES/poxresources.py
|
71b122023b8723299b5cc25a607861109073ad60
|
[
"Apache-2.0",
"MIT"
] |
permissive
|
gilneidp/FinalProject
|
309979cb65a115a980c58433decc921e295147bf
|
ec4f35d154bc4383ccde113126e493c1521ad21a
|
refs/heads/master
| 2021-01-01T18:42:30.789219
| 2015-10-30T10:40:47
| 2015-10-30T10:40:47
| 41,107,057
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 779
|
py
|
import os
import sys
import datetime
from datetime import timedelta
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "madapp.settings")
from django.core.management import execute_from_command_line
from django.db.models import Count, Avg
from madapp import settings
from madapp.mad.models import *
import psutil
cpu = psutil.cpu_times()
memory_used = psutil.virtual_memory()
memory_free = (memory_used.free/1024)/1024
#oxstats = UsageTable.objects.get(servername = 'POX')
#oxstats.cpu_usage = cpu
#oxstats.save()
print cpu
#print (((memory_used.used/1024)/1024)*100)/(((memory_used.free/1024)/1024) + ((memory_used.used/1024)/1024))
#print (memory_used.used/1024)/1024
#print ((memory_used.free/1024)/1024) + ((memory_used.used/1024)/1024)
#print cpu
#print memory_used.percent
|
[
"gilnei@gilnei.com.br"
] |
gilnei@gilnei.com.br
|
ff8cefcde863d2211483e1d36ab5250a2795db09
|
667e52d9501e04ad9d301c405a1ffc57dabc439e
|
/checkio/find_friends.py
|
dcb04ca3265d5c32614ffd7993960e1e3624939c
|
[] |
no_license
|
merryjane/python
|
c9ab15f09b83a0f0069b49fe5f2f7ed6e601831c
|
423aa3cdf226404b2bf9f5958b5d03fe84b93f74
|
refs/heads/master
| 2021-01-23T16:37:05.387564
| 2014-07-25T14:17:13
| 2014-07-25T14:17:13
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,690
|
py
|
#!/usr/bin/env python3
def look_for_neighbors(network,node):
neighbors = set()
for couples in network:
if couples.split('-')[0] == node:
neighbors.add(couples.split('-')[1])
elif couples.split('-')[1] == node:
neighbors.add(couples.split('-')[0])
return neighbors
def check_connection(network, first, second):
visited = set()
visited.add(first)
future = set()
future.update(look_for_neighbors(network,first))
for node in future:
if node == second:
return True
else:
visited.add(node)
future.remove(node)
print(future)
print(visited)
check_connection(
("dr101-mr99", "mr99-out00", "dr101-out00", "scout1-scout2",
"scout3-scout1", "scout1-scout4", "scout4-sscout", "sscout-super"),
"scout2", "scout3")
'''
if __name__ == '__main__':
#These "asserts" using only for self-checking and not necessary for auto-testing
assert check_connection(
("dr101-mr99", "mr99-out00", "dr101-out00", "scout1-scout2",
"scout3-scout1", "scout1-scout4", "scout4-sscout", "sscout-super"),
"scout2", "scout3") == True, "Scout Brotherhood"
assert check_connection(
("dr101-mr99", "mr99-out00", "dr101-out00", "scout1-scout2",
"scout3-scout1", "scout1-scout4", "scout4-sscout", "sscout-super"),
"super", "scout2") == True, "Super Scout"
assert check_connection(
("dr101-mr99", "mr99-out00", "dr101-out00", "scout1-scout2",
"scout3-scout1", "scout1-scout4", "scout4-sscout", "sscout-super"),
"dr101", "sscout") == False, "I don't know any scouts."
'''
|
[
"ibiryulin@qsoft.ru"
] |
ibiryulin@qsoft.ru
|
ef2911b4133217bc48dbf92e02a62bd1d9b5d171
|
e168a16fdd43d3023d16d8a643ccca318a44c327
|
/evm/logic/call.py
|
42acedd0f1791f1cebd63438077524bdee541b46
|
[] |
no_license
|
DavidKnott/py-evm
|
c589c88af55c121ea375bfdb0a53ecc6a4836119
|
66c47f58a62e995b5ce89e47007c8b03796c80b9
|
refs/heads/master
| 2021-01-01T04:08:39.921768
| 2017-07-18T13:03:45
| 2017-07-18T13:03:45
| 97,128,228
| 1
| 0
| null | 2017-07-13T13:54:57
| 2017-07-13T13:54:56
| null |
UTF-8
|
Python
| false
| false
| 7,349
|
py
|
from evm import constants
from evm.opcode import (
Opcode,
)
from evm.utils.address import (
force_bytes_to_address,
)
class BaseCall(Opcode):
def compute_msg_gas(self, computation, gas, to, value):
raise NotImplementedError("Must be implemented by subclasses")
def get_call_params(self, computation):
raise NotImplementedError("Must be implemented by subclasses")
def __call__(self, computation):
computation.gas_meter.consume_gas(
self.gas_cost,
reason=self.mnemonic,
)
(
gas,
value,
to,
sender,
code_address,
memory_input_start_position,
memory_input_size,
memory_output_start_position,
memory_output_size,
should_transfer_value,
) = self.get_call_params(computation)
computation.extend_memory(memory_input_start_position, memory_input_size)
computation.extend_memory(memory_output_start_position, memory_output_size)
call_data = computation.memory.read(memory_input_start_position, memory_input_size)
#
# Message gas allocation and fees
#
child_msg_gas, child_msg_gas_fee = self.compute_msg_gas(computation, gas, to, value)
computation.gas_meter.consume_gas(child_msg_gas_fee, reason=self.mnemonic)
# Pre-call checks
sender_balance = computation.state_db.get_balance(
computation.msg.storage_address,
)
insufficient_funds = should_transfer_value and sender_balance < value
stack_too_deep = computation.msg.depth + 1 > constants.STACK_DEPTH_LIMIT
if insufficient_funds or stack_too_deep:
if self.logger:
if insufficient_funds:
err_message = "Insufficient Funds: have: {0} | need: {1}".format(
sender_balance,
value,
)
elif stack_too_deep:
err_message = "Stack Limit Reached"
else:
raise Exception("Invariant: Unreachable code path")
self.logger.debug(
"%s failure: %s",
self.mnemonic,
err_message,
)
computation.gas_meter.return_gas(child_msg_gas)
computation.stack.push(0)
else:
if code_address:
code = computation.state_db.get_code(code_address)
else:
code = computation.state_db.get_code(to)
child_msg_kwargs = {
'gas': child_msg_gas,
'value': value,
'to': to,
'data': call_data,
'code': code,
'code_address': code_address,
'should_transfer_value': should_transfer_value,
}
if sender is not None:
child_msg_kwargs['sender'] = sender
child_msg = computation.prepare_child_message(**child_msg_kwargs)
if child_msg.is_create:
child_computation = computation.vm.apply_create_message(child_msg)
else:
child_computation = computation.vm.apply_message(child_msg)
computation.children.append(child_computation)
if child_computation.error:
computation.stack.push(0)
else:
actual_output_size = min(memory_output_size, len(child_computation.output))
computation.gas_meter.return_gas(child_computation.gas_meter.gas_remaining)
computation.memory.write(
memory_output_start_position,
actual_output_size,
child_computation.output[:actual_output_size],
)
computation.stack.push(1)
class Call(BaseCall):
def compute_msg_gas(self, computation, gas, to, value):
account_exists = computation.state_db.account_exists(to)
transfer_gas_fee = constants.GAS_CALLVALUE if value else 0
create_gas_fee = constants.GAS_NEWACCOUNT if not account_exists else 0
total_fee = gas + transfer_gas_fee + create_gas_fee
child_msg_gas = gas + (constants.GAS_CALLSTIPEND if value else 0)
return child_msg_gas, total_fee
def get_call_params(self, computation):
gas = computation.stack.pop(type_hint=constants.UINT256)
to = force_bytes_to_address(computation.stack.pop(type_hint=constants.BYTES))
(
value,
memory_input_start_position,
memory_input_size,
memory_output_start_position,
memory_output_size,
) = computation.stack.pop(num_items=5, type_hint=constants.UINT256)
return (
gas,
value,
to,
None, # sender
None, # code_address
memory_input_start_position,
memory_input_size,
memory_output_start_position,
memory_output_size,
True, # should_transfer_value,
)
class CallCode(BaseCall):
def compute_msg_gas(self, computation, gas, to, value):
transfer_gas_cost = constants.GAS_CALLVALUE if value else 0
total_fee = transfer_gas_cost + gas
child_msg_gas = gas + (constants.GAS_CALLSTIPEND if value else 0)
return child_msg_gas, total_fee
def get_call_params(self, computation):
gas = computation.stack.pop(type_hint=constants.UINT256)
code_address = force_bytes_to_address(computation.stack.pop(type_hint=constants.BYTES))
(
value,
memory_input_start_position,
memory_input_size,
memory_output_start_position,
memory_output_size,
) = computation.stack.pop(num_items=5, type_hint=constants.UINT256)
to = computation.msg.storage_address
sender = computation.msg.storage_address
return (
gas,
value,
to,
sender,
code_address,
memory_input_start_position,
memory_input_size,
memory_output_start_position,
memory_output_size,
True, # should_transfer_value,
)
class DelegateCall(CallCode):
def compute_msg_gas(self, computation, gas, to, value):
return gas, gas
def get_call_params(self, computation):
gas = computation.stack.pop(type_hint=constants.UINT256)
code_address = force_bytes_to_address(computation.stack.pop(type_hint=constants.BYTES))
(
memory_input_start_position,
memory_input_size,
memory_output_start_position,
memory_output_size,
) = computation.stack.pop(num_items=4, type_hint=constants.UINT256)
to = computation.msg.storage_address
sender = computation.msg.sender
value = computation.msg.value
return (
gas,
value,
to,
sender,
code_address,
memory_input_start_position,
memory_input_size,
memory_output_start_position,
memory_output_size,
False, # should_transfer_value,
)
|
[
"pipermerriam@gmail.com"
] |
pipermerriam@gmail.com
|
f0a82e1bd0914b8007e6b425025033a3628ec23c
|
3badd0d2ea861e56748f5c16beba67e1685dc7c3
|
/functional_tests.py
|
75114b2d2c52b96f38a980fbc54472aef4cb095d
|
[] |
no_license
|
chris-seals/tdd-book
|
a8b72c0ba83e1a27088783225a3fd30fc32bdb28
|
28d9742e19d510fd07fe21928ede7c316958f4fa
|
refs/heads/master
| 2022-11-22T03:34:23.940099
| 2020-07-19T14:27:00
| 2020-07-19T14:27:00
| 258,937,633
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,246
|
py
|
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
import time
import unittest
class NewVisitorTest(unittest.TestCase):
def setUp(self):
self.browser = webdriver.Firefox()
def tearDown(self):
self.browser.quit()
def test_can_start_a_list_and_retrieve_it_later(self):
# Edith has heard about a cool new online to-do app.
# She goes to check out the homepage.
self.browser.get('http://localhost:8000')
# She notices the page title and header mention to-do lists
self.assertIn('To-Do', self.browser.title)
header_text = self.browser.find_element_by_tag_name('h1').text
self.assertIn('To-Do', header_text)
# She is invited to enter a to-do item straight away
inputbox = self.browser.find_element_by_id('id_new_item')
self.assertEqual(
inputbox.get_attribute('placeholder'),
'Enter a to-do item'
)
# She types "Buy peacock feathers" into a text box (Edith's hobby is
# tying fly-fishing lures)
inputbox.send_keys('Buy peacock feathers')
# When she hits enter, the page updates, and now the page lists
# "1: Buy peacock feathers" as an item in a to-do lists
inputbox.send_keys(Keys.ENTER)
time.sleep(1)
table = self.browser.find_element_by_id('id_list_table')
rows = table.find_elements_by_tag_name('tr')
self.assertTrue(
any(row.text == '1: Buy peacock feathers' for row in rows),
"New to-do item did not appear in table"
)
# There is still a text box inviting her to add another item. She enters
# "Use peacock feathers to make a fly" (Edith is very methodical)
self.fail('Finish the test!')
# The page updates again, and now shows both items on her lists
# Edith wonders whether the site will remember her list. Then she sees
# that the site has generated a unique URL for her -- there is some
# explanatory text to that effect.
# She visits that URL - her to-do list is still there.
# Satisfied, she goes back to sleep
if __name__ == '__main__':
unittest.main(warnings='ignore')
|
[
"christopher.seals@gmail.com"
] |
christopher.seals@gmail.com
|
848257d62f49ecdcc747c38384d79aa0afb7700b
|
8db1ab4f9a2e47f7e8d69a685837d7e747bf9442
|
/cocos2d-x-tool/py_tool/syncResToProject.py
|
0773ceebfd0313dd7ab2c0df0f04cec7b688b661
|
[] |
no_license
|
tanzuoliang/python
|
051d6e46cebd7fdb74a0173aca0ca7a2b3ef5986
|
70f782cf3c72d2b7043727910509eb2d2f2fe065
|
refs/heads/master
| 2021-10-20T05:36:03.732738
| 2019-02-26T02:37:18
| 2019-02-26T02:37:18
| 111,288,598
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,595
|
py
|
#!/usr/bin/python
#encoding=utf-8
from myutil.utils import syncDir,checkSVNStatus
import os
fromRoot = '/Users/tanzuoliang/art_resource'
toRoot = "../res/new_ui"
toLanguage = "../res"
ll = [
('天天坦克/UI\ 效果图+输出\ 20170214\ 优化版/00\ icon','天天坦克/UI 效果图+输出 20170214 优化版/00 icon','icon'),
('天天坦克/UI\ 效果图+输出\ 20170214\ 优化版/00\ button','天天坦克/UI 效果图+输出 20170214 优化版/00 button','button'),
('天天坦克/UI\ 效果图+输出\ 20170214\ 优化版/00\ wenzi','天天坦克/UI 效果图+输出 20170214 优化版/00 wenzi','wenzi'),
('天天坦克/UI\ 效果图+输出\ 20170214\ 优化版/00\ 通用','天天坦克/UI 效果图+输出 20170214 优化版/00 通用','common'),
('天天坦克/UI\ 效果图+输出\ 20170214\ 优化版/00\ 字体','天天坦克/UI 效果图+输出 20170214 优化版/00 字体','fnt'),
('天天坦克/UI\ 效果图+输出\ 20170214\ 优化版/00\ BG','天天坦克/UI 效果图+输出 20170214 优化版/00 BG','bg')
]
"""
语言分类资源
"""
lll = [
('天天坦克/UI\ 效果图+输出\ 20170214\ 优化版/00\ 英文翻译','天天坦克/UI 效果图+输出 20170214 优化版/00 英文翻译','lang_en'),
('天天坦克/UI\ 效果图+输出\ 20170214\ 优化版/00\ 翻译原版','天天坦克/UI 效果图+输出 20170214 优化版/00 翻译原版','lang_chs')
]
from myutil.utils import getDirsize
import os
if os.path.exists('../res-new') and getDirsize('../res') < getDirsize('../res-new'):
print "当前res是压缩后的"
else:
os.system('svn up %s'%toLanguage)
for tu in ll:
fromDir = os.path.join(fromRoot, tu[0])
toDir = os.path.join(toRoot, tu[2])
os.system("svn up %s"%fromDir)
fromDir = os.path.join(fromRoot, tu[1])
syncDir(fromDir, toDir,False)
checkSVNStatus(toRoot,[tu[2]])
for tu in lll:
fromDir = os.path.join(fromRoot, tu[0])
toDir = os.path.join(toLanguage, "language_img", tu[2],"res","new_ui")
os.system("svn up %s"%fromDir)
fromDir = os.path.join(fromRoot, tu[1])
if not os.path.exists(toDir):
os.makedir(toDir)
syncDir(fromDir, toDir,False)
checkSVNStatus(os.path.join(toLanguage, "language_img"),[tu[2]])
"""
英文引导
"""
# os.system("cp %s %s"%(os.path.join(fromRoot,"天天坦克/UI\ 效果图+输出\ 20170214\ 优化版/00\ 英文翻译/Novice\ guide/controlexplain.jpg"),os.path.join(toRoot, "bg/lang_en_controlexplain.jpg")))
os.system("rm -rf %s"%(os.path.join(toLanguage,"language_img/lang_en/res/new_ui/Novice\ guide")))
os.system('svn ci %s -m "同步资源"'%toLanguage)
|
[
"ysjwdaypm@163.com"
] |
ysjwdaypm@163.com
|
3f60cafc9d44646bf3475d2b1f730a3648b8e27b
|
863c2fcfd5ebed9153c43a298488abeb6e96d627
|
/time_series_classification.py
|
ee0ba8dbea36985a0524ff0d3e4a63708bed7170
|
[] |
no_license
|
liang112233/time-series-classification
|
6d51dd7e80b044f6fbc7e64c2dd4e4bf6f1ae8f5
|
d5e847b302d855bb9dc975e888b2c0e50be32f8e
|
refs/heads/master
| 2022-11-25T13:18:35.772054
| 2020-07-30T15:16:58
| 2020-07-30T15:16:58
| 280,761,492
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 4,092
|
py
|
# https://www.analyticsvidhya.com/blog/2019/01/introduction-time-series-classification/
import os
import pandas as pd
import numpy as np
# matplotlib inline
import matplotlib.pyplot as plt
from os import listdir
import tensorflow as tf
gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
tf.config.experimental.set_virtual_device_configuration(gpus[0], [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=4096)])
from keras.preprocessing import sequence
import tensorflow as tf
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.optimizers import Adam
from keras.models import load_model
from tensorflow.python.keras.callbacks import ModelCheckpoint
from keras.callbacks import ModelCheckpoint
df1 = pd.read_csv('/home/liang/PycharmProjects/time-series-classification/MovementAAL/dataset/MovementAAL_RSS_1.csv')
df2 = pd.read_csv('/home/liang/PycharmProjects/time-series-classification/MovementAAL/dataset/MovementAAL_RSS_2.csv')
path = '/home/liang/PycharmProjects/time-series-classification/MovementAAL/dataset/MovementAAL_RSS_'
sequences = list()
for i in range(1,315):
file_path = path + str(i) + '.csv'
print(file_path)
df = pd.read_csv(file_path, header=0)
values = df.values
sequences.append(values)
targets = pd.read_csv('/home/liang/PycharmProjects/time-series-classification/MovementAAL/dataset/MovementAAL_target.csv')
targets = targets.values[:,1]
groups = pd.read_csv('MovementAAL/groups/MovementAAL_DatasetGroup.csv', header=0)
groups = groups.values[:,1]
len_sequences = []
for one_seq in sequences:
len_sequences.append(len(one_seq))
pd.Series(len_sequences).describe()
# Padding the sequence with the values in last row to max length
to_pad = 129
new_seq = []
for one_seq in sequences:
len_one_seq = len(one_seq)
last_val = one_seq[-1]
n = to_pad - len_one_seq
to_concat = np.repeat(one_seq[-1], n).reshape(4, n).transpose()
new_one_seq = np.concatenate([one_seq, to_concat])
new_seq.append(new_one_seq)
final_seq = np.stack(new_seq)
# truncate the sequence to length 60
seq_len = 60
final_seq = sequence.pad_sequences(final_seq, maxlen=seq_len, padding='post', dtype='float', truncating='post')
train = [final_seq[i] for i in range(len(groups)) if (groups[i]==2)]
validation = [final_seq[i] for i in range(len(groups)) if groups[i]==1]
test = [final_seq[i] for i in range(len(groups)) if groups[i]==3]
train_target = [targets[i] for i in range(len(groups)) if (groups[i]==2)]
validation_target = [targets[i] for i in range(len(groups)) if groups[i]==1]
test_target = [targets[i] for i in range(len(groups)) if groups[i]==3]
train = np.array(train)
validation = np.array(validation)
test = np.array(test)
train_target = np.array(train_target)
train_target = (train_target+1)/2
validation_target = np.array(validation_target)
validation_target = (validation_target+1)/2
test_target = np.array(test_target)
test_target = (test_target+1)/2
model = Sequential()
model.add(LSTM(256, input_shape=(seq_len, 4)))
model.add(Dense(1, activation='sigmoid'))
model.summary()
adam = Adam(lr=0.001)
# model_filename = "test-Epoch-{epoch:02d}"
# checkpoint_path = os.path.join('models/', model_filename)
chk = ModelCheckpoint(
'best_model.pkl',
monitor='val_accuracy',
verbose=1,
save_best_only=False,
save_weights_only=False,
mode='max')
# chk = ModelCheckpoint('best_model.pkl', monitor='val_acc', save_best_only=True, mode='max', verbose=1)
model.compile(loss='binary_crossentropy', optimizer=adam, metrics=['accuracy'])
model.fit(train, train_target, epochs=5, batch_size=128, callbacks=[chk], validation_data=(validation,validation_target))
#
# # #loading the model and checking accuracy on the test data
model = load_model('best_model.pkl')
#
from sklearn.metrics import accuracy_score
test_preds = model.predict_classes(test)
accuracy_score(test_target, test_preds)
print("score",accuracy_score(test_target, test_preds))
|
[
"sisheng.liang@ttu.edu"
] |
sisheng.liang@ttu.edu
|
87a0d04e73c54c1e0daef6dcf0e338c6af43be21
|
ef187d259d33e97c7b9ed07dfbf065cec3e41f59
|
/work/atcoder/abc/abc024/B/answers/111654_Gale.py
|
b31d17de7f8e5d4c0d019d4cbf95c0c6f7e11513
|
[] |
no_license
|
kjnh10/pcw
|
847f7295ea3174490485ffe14ce4cdea0931c032
|
8f677701bce15517fb9362cc5b596644da62dca8
|
refs/heads/master
| 2020-03-18T09:54:23.442772
| 2018-07-19T00:26:09
| 2018-07-19T00:26:09
| 134,586,379
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 197
|
py
|
n, t = map(int, input().split())
a = [int(input()) for i in range(n)]
ans = t
for i in range(1, n):
ans += t
if a[i] <= a[i - 1] + t:
ans = ans - (a[i - 1] + t - a[i])
print(ans)
|
[
"kojinho10@gmail.com"
] |
kojinho10@gmail.com
|
0b583e86f97c1a537be2b27d6980f3a3dd93df1a
|
528c811306faa4a34bf51fca7955b7a24ac2e30c
|
/Python/Valid Anagram.py
|
263508830b33b30fd769bcad02fa5dbf91901f61
|
[] |
no_license
|
ganjingcatherine/LeetCode-1
|
1addbd7e4d9254a146601f9d5e28b8becb8235a6
|
488782d3f1e759da2d32b4e82dbf55b96c431244
|
refs/heads/master
| 2021-05-11T03:15:16.810035
| 2016-02-06T06:19:18
| 2016-02-06T06:19:18
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 806
|
py
|
"""
Given two strings s and t, write a function to determine if t is an anagram of s.
For example,
s = "anagram", t = "nagaram", return true.
s = "rat", t = "car", return false.
Note:
You may assume the string contains only lowercase alphabets.
"""
class Solution(object):
def isAnagram(self, s, t):
"""
:type s: str
:type t: str
:rtype: bool
"""
if len(s) != len(t): return False
table = {}
for i in xrange(len(s)):
if s[i] not in table:
table[s[i]] = 1
else:
table[s[i]] += 1
for i in xrange(len(t)):
if t[i] in table and table[t[i]] > 0:
table[t[i]] -= 1
else:
return False
return True
|
[
"anthonyjin0619@gmail.com"
] |
anthonyjin0619@gmail.com
|
626be54fe2c402a3a685abc6d8479c10ea8a75aa
|
a5a99f646e371b45974a6fb6ccc06b0a674818f2
|
/CalibMuon/RPCCalibration/python/l1MuonOutputModule_cfi.py
|
6dbdc357f06e53ed7641a5fc49576123b5f1a25e
|
[
"Apache-2.0"
] |
permissive
|
cms-sw/cmssw
|
4ecd2c1105d59c66d385551230542c6615b9ab58
|
19c178740257eb48367778593da55dcad08b7a4f
|
refs/heads/master
| 2023-08-23T21:57:42.491143
| 2023-08-22T20:22:40
| 2023-08-22T20:22:40
| 10,969,551
| 1,006
| 3,696
|
Apache-2.0
| 2023-09-14T19:14:28
| 2013-06-26T14:09:07
|
C++
|
UTF-8
|
Python
| false
| false
| 419
|
py
|
import FWCore.ParameterSet.Config as cms
from CalibMuon.RPCCalibration.l1Muon_EventContent_cff import *
L1MuonEventContent = cms.OutputModule("PoolOutputModule",
l1Muon_EventContent,
l1MuonEventSelection,
datasets = cms.untracked.PSet(
filterName = cms.untracked.string('l1Muon_Filter'),
dataTier = cms.untracked.string('USER')
),
fileName = cms.untracked.string('l1Muon.root')
)
|
[
"giulio.eulisse@gmail.com"
] |
giulio.eulisse@gmail.com
|
73fb980e24519d85b6a114bf1263927c71ea7335
|
88deebcc2251f406c0c34325025cd0cbccb142e7
|
/Drosophila/ABC/melano_simulans_simulate_ms_ABC.py
|
0c443a1bf2620a4e48345ce53a52e4623d284f5e
|
[] |
no_license
|
cllong112s/CNN_spDelimitation_Piloso
|
27dab9269253c4ca360e6f8c4f1d70560bf15d84
|
5a5cae2498e89291357733f8614c5399558be7c0
|
refs/heads/master
| 2023-08-15T20:15:52.292721
| 2021-09-16T15:08:42
| 2021-09-16T15:08:42
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,287
|
py
|
#!/usr/bin/python
## in order to use this code you have to have ms installed on your computer
## ms can be freely downloaded from:
## http://home.uchicago.edu/rhudson1/source/mksamples.html
import random
import os
import math
### variable declarations
#define the number of simulations
Priorsize = 10000
## nDNA sample size of Dmelanogaster.
nDNADme = 3
## nDNA sample size of Dsimulans.
nDNADsi = 3
## nDNA sample sizes (number of alleles).
nDNANsam = nDNADme + nDNADsi
#number of segregating sites for each marker
segsites = [36,36]
## create a file to store parameters and one to store the models
parameters = file("parameters.txt","w")
models = file("models.txt","w")
### One Species Model
for i in range(Priorsize):
### Define parameters
## Theta values from 1 to 15
Theta = random.uniform(5,300)
## divergence time prior set to 0.
coalRootDivTime = 0
## ms commands
for s in range(len(segsites)):
## nDNA markers
com=os.system("./ms %d 1 -s %d -t %f -I 2 %d %d -ej %f 1 2 | sed '/prob/d' | perl msSS.pl >> simModel1.txt" % (nDNANsam, segsites[s],Theta, nDNADme, nDNADsi, coalRootDivTime))
## mtDNA marker
com=os.system("./ms %d 1 -s 36 -t %f -I 2 %d %d -ej %f 1 2 | sed '/prob/d' | perl msSS.pl >> simModel1.txt" % (nDNANsam, Theta/4, nDNADme, nDNADsi, coalRootDivTime/2))
## save parameter values and models
parameters.write("%f\t%f\n" % (Theta, coalRootDivTime))
models.write("1\n")
### Two Species Model
for i in range(Priorsize):
### Define parameters
## Theta values from 5 to 300
Theta = random.uniform(5,300)
## divergence time prior following an uniform distribution from 0.01 to 0.5.
coalRootDivTime = random.uniform(0.01,0.5)
## ms commands
for s in range(len(segsites)):
## nDNA markers
com=os.system("./ms %d 1 -s %d -t %f -I 2 %d %d -ej %f 1 2 | sed '/prob/d' | perl msSS.pl >> simModel2.txt" % (nDNANsam, segsites[s],Theta, nDNADme, nDNADsi, coalRootDivTime))
## mtDNA marker
com=os.system("./ms %d 1 -s 36 -t %f -I 2 %d %d -ej %f 1 2 | sed '/prob/d' | perl msSS.pl >> simModel2.txt" % (nDNANsam, Theta/4, nDNADme, nDNADsi, coalRootDivTime/2))
## save parameter values and models
parameters.write("%f\t%f\n" % (Theta, coalRootDivTime))
models.write("2\n")
com=os.system("cat simModel* > SuSt_melano_simulans.txt")
|
[
"manolo@macbook-pro-de-manolo.home"
] |
manolo@macbook-pro-de-manolo.home
|
fb82d01ee42c4f74d1b66246033ac584b40173c8
|
9bb28ccac08cbb00b3b973ed1283a4e63db045de
|
/venv/Scripts/pip3.8-script.py
|
6f8e9a2a91deacf7a08089af0bac8dcaf76cb0fa
|
[] |
no_license
|
sanghee5/polls_example2
|
762202280519efdddff7015cb4399cf80fac94d4
|
6f0511a6bf0994f46168902c54266ef8f9107519
|
refs/heads/master
| 2022-08-21T03:59:38.140488
| 2020-05-26T11:47:10
| 2020-05-26T11:47:10
| 267,026,974
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 422
|
py
|
#!C:\Users\woo\PycharmProjects\polls_example2\venv\Scripts\python.exe
# EASY-INSTALL-ENTRY-SCRIPT: 'pip==19.0.3','console_scripts','pip3.8'
__requires__ = 'pip==19.0.3'
import re
import sys
from pkg_resources import load_entry_point
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(
load_entry_point('pip==19.0.3', 'console_scripts', 'pip3.8')()
)
|
[
"dnstks12345@naver.com"
] |
dnstks12345@naver.com
|
2bff7ce472c638cc2952ee313e844673778ab37c
|
5faecec9b20d262150e48ac9f31c396f840b1f2f
|
/migrations/0010_auto_20200804_0913.py
|
f175b678b5857527caa863cd6db136e7bc3d803b
|
[] |
no_license
|
binkesi/blogsgn
|
fb767b0d22e3eb1c32ea7ee8fd0796766e3a8600
|
579b374f802a5651d20c3b3f85d8ff6a22476bdd
|
refs/heads/master
| 2022-11-27T23:24:45.574601
| 2020-08-04T10:06:28
| 2020-08-04T10:06:28
| 283,161,699
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 515
|
py
|
# Generated by Django 3.0.6 on 2020-08-04 01:13
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('blogsgn', '0009_auto_20200804_0653'),
]
operations = [
migrations.AlterField(
model_name='author',
name='nation',
field=models.CharField(choices=[('CH', 'China'), ('US', 'America'), ('UK', 'England'), ('GE', 'German'), ('CA', 'Canada')], max_length=80, verbose_name='Nationality'),
),
]
|
[
"sjtusgn@163.com"
] |
sjtusgn@163.com
|
7713fd10c64850e9770370122883e5b6ea01086f
|
e2ae96b74289a04a2386294bf51bacad92e2a830
|
/city_scrapers_core/spiders/legistar.py
|
29c3176db02b4b0851fd939f9f79845a629163c5
|
[
"MIT"
] |
permissive
|
will-snavely/city-scrapers-core
|
6afa9d78fb1c325420baaae030633b01111f11bb
|
cb865069e49d09ab251b7f99247df5e13c5d0241
|
refs/heads/main
| 2022-12-11T21:39:03.307347
| 2020-09-09T13:29:53
| 2020-09-09T13:29:53
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 4,265
|
py
|
from datetime import datetime
from typing import Iterable, List, Mapping, Optional, Tuple
from urllib.parse import urlparse
import scrapy
from legistar.events import LegistarEventsScraper
from ..items import Meeting
from .spider import CityScrapersSpider
LINK_TYPES = ["Agenda", "Minutes", "Video", "Summary", "Captions"]
class LegistarSpider(CityScrapersSpider):
"""Subclass of :class:`CityScrapersSpider` that handles processing Legistar sites,
which almost always share the same components and general structure.
Uses the `Legistar events scraper <https://github.com/opencivicdata/python-legistar-scraper/blob/master/legistar/events.py>`_
from the ```python-legistar-scraper`` library <https://github.com/opencivicdata/python-legistar-scraper>`.
Any methods that don't pull the correct values can be replaced.
""" # noqa
link_types = []
def parse(self, response: scrapy.http.Response) -> Iterable[Meeting]:
"""Parse response from the :class:`LegistarEventsScraper`. Ignores the ``scrapy``
:class:`Response` which is still requested to be able to hook into ``scrapy``
broadly.
:param response: Scrapy response to be ignored
:return: Iterable of processed meetings
"""
events = self._call_legistar()
return self.parse_legistar(events)
def parse_legistar(
self, events: Iterable[Tuple[Mapping, Optional[str]]]
) -> Iterable[Meeting]:
"""Method to be implemented by Spider classes that will handle the response from
Legistar. Functions similar to ``parse`` for other Spider classes.
:param events: Iterable consisting of tuples of a dict-like object of scraped
results from legistar and an agenda URL (if available)
:raises NotImplementedError: Must be implemented in subclasses
:return: [description]
"""
raise NotImplementedError("Must implement parse_legistar")
def _call_legistar(
self, since: int = None
) -> Iterable[Tuple[Mapping, Optional[str]]]:
les = LegistarEventsScraper()
les.BASE_URL = self.base_url
les.EVENTSPAGE = f"{self.base_url}/Calendar.aspx"
if not since:
since = datetime.today().year
return les.events(since=since)
def legistar_start(self, item: Mapping) -> datetime:
"""Pulls the start time from a Legistar item
:param item: Scraped item from Legistar
:return: Meeting start datetime
"""
start_date = item.get("Meeting Date")
start_time = item.get("Meeting Time")
if start_date and start_time:
try:
return datetime.strptime(
f"{start_date} {start_time}", "%m/%d/%Y %I:%M %p"
)
except ValueError:
return datetime.strptime(start_date, "%m/%d/%Y")
def legistar_links(self, item: Mapping) -> List[Mapping[str, str]]:
"""Pulls relevant links from a Legistar item
:param item: Scraped item from Legistar
:return: List of meeting links
"""
links = []
for link_type in LINK_TYPES + self.link_types:
if isinstance(item.get(link_type), dict) and item[link_type].get("url"):
links.append({"href": item[link_type]["url"], "title": link_type})
return links
def legistar_source(self, item: Mapping) -> str:
"""Pulls the source URL from a Legistar item. Pulls a specific meeting URL if
available, otherwise defaults to the general Legistar calendar page.
:param item: Scraped item from Legistar
:return: Source URL
"""
default_url = f"{self.base_url}/Calendar.aspx"
if isinstance(item.get("Name"), dict):
return item["Name"].get("url", default_url)
if isinstance(item.get("Meeting Details"), dict):
return item["Meeting Details"].get("url", default_url)
return default_url
@property
def base_url(self) -> str:
"""Property with the Legistar site's base URL
:return: Legistar base URL
"""
parsed_url = urlparse(self.start_urls[0])
return f"{parsed_url.scheme}://{parsed_url.netloc}"
|
[
"pjsier@gmail.com"
] |
pjsier@gmail.com
|
9d101de5dc8616d67f19ec37db6ac2e7ed86d8b1
|
fde2a3a4858b37cafcd02cf917d3bd69680084b3
|
/Spacegame/Spacegame/scoreboard.py
|
7cb820bd2744867f4d0c0ffc58127b56a0c6463a
|
[] |
no_license
|
CaptainBlowFish/AlienInvasion
|
34b1e013e97c8f2a69aa82e9e51786ffc5e2f78f
|
6ec7f399bbaa92901ad8b015047bc6ebe6dc708e
|
refs/heads/main
| 2023-08-29T20:04:38.130623
| 2021-11-12T13:45:19
| 2021-11-12T13:45:19
| 422,559,716
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,082
|
py
|
from pygame import font
from pygame.sprite import Group
from ship import Ship
class Scoreboard:
"""A class to report scoreings information"""
def __init__(self, ai_game):
"""Initialize scorekeeping attributes"""
self.ai_game = ai_game
self.screen = ai_game.screen
self.screen_rect = self.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
# Font settings for scoring information
self.text_color = (30,30,30)
self.font = font.SysFont(None, 48)
# Prepare the initial score image
self.prep_score()
self.prep_high_score()
self.prep_level()
self.ships = Group()
def prep_score(self):
"""Turn the score into a rendered image"""
rounded_score = round(self.stats.score, -1)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,None)
# Display the se at the top right of the screen
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 20
def prep_level(self):
"""Turn the level into a rendered image."""
level_str = str(self.stats.level)
self.level_image = self.font.render(level_str, True, self.text_color, None)
# Position the level below the score
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.score_rect.right
self.level_rect.top = self.score_rect.bottom + 10
def prep_high_score(self):
"""Turn the high score into a rendered image"""
rounded_high_score = round(self.stats.high_score, -1)
high_score_str = "{:,}".format(rounded_high_score)
self.high_score_image = self.font.render(high_score_str, True, self.text_color,None)
# Display the score at the top of the screen
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.right = self.screen_rect.centerx
self.high_score_rect.top = self.score_rect.top
def prep_ships(self):
"""Show howmany ships are left"""
self.ships.empty()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_game)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def show_score(self):
"""Draw the score to the screen."""
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.level_image, self.level_rect)
self.ships.draw(self.screen)
def check_high_score(self):
"""Check to see if there's a new high score."""
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.prep_high_score()
|
[
"noreply@github.com"
] |
CaptainBlowFish.noreply@github.com
|
9f0d1351e1fd94cb4f0674d16df5403e9b562544
|
c9ddbdb5678ba6e1c5c7e64adf2802ca16df778c
|
/cases/synthetic/sieve-big-7279.py
|
7b346f67e4f794d398658cee0c9138683fa18c0b
|
[] |
no_license
|
Virtlink/ccbench-chocopy
|
c3f7f6af6349aff6503196f727ef89f210a1eac8
|
c7efae43bf32696ee2b2ee781bdfe4f7730dec3f
|
refs/heads/main
| 2023-04-07T15:07:12.464038
| 2022-02-03T15:42:39
| 2022-02-03T15:42:39
| 451,969,776
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 31,612
|
py
|
# A resizable list of integers
class Vector(object):
items: [int] = None
size: int = 0
def __init__(self:"Vector"):
self.items = [0]
# Returns current capacity
def capacity(self:"Vector") -> int:
return len(self.items)
# Increases capacity of vector by one element
def increase_capacity(self:"Vector") -> int:
self.items = self.items + [0]
return self.capacity()
# Appends one item to end of vector
def append(self:"Vector", item: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends many items to end of vector
def append_all(self:"Vector", new_items: [int]) -> object:
item:int = 0
for item in new_items:
self.append(item)
# Removes an item from the middle of vector
def remove_at(self:"Vector", idx: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Retrieves an item at a given index
def get(self:"Vector", idx: int) -> int:
return self.items[idx]
# Retrieves the current size of the vector
def length(self:"Vector") -> int:
return self.size
# A resizable list of integers
class Vector2(object):
items: [int] = None
items2: [int] = None
size: int = 0
size2: int = 0
def __init__(self:"Vector2"):
self.items = [0]
# Returns current capacity
def capacity(self:"Vector2") -> int:
return len(self.items)
# Returns current capacity
def capacity2(self:"Vector2") -> int:
return len(self.items)
# Increases capacity of vector by one element
def increase_capacity(self:"Vector2") -> int:
self.items = self.items + [0]
return self.capacity()
# Increases capacity of vector by one element
def increase_capacity2(self:"Vector2") -> int:
self.items = self.items + [0]
return self.capacity()
# Appends one item to end of vector
def append(self:"Vector2", item: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends one item to end of vector
def append2(self:"Vector2", item: int, item2: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends many items to end of vector
def append_all(self:"Vector2", new_items: [int]) -> object:
item:int = 0
for item in new_items:
self.append(item)
# Appends many items to end of vector
def append_all2(self:"Vector2", new_items: [int], new_items2: [int]) -> object:
item:int = 0
item2:int = 0
for item in new_items:
self.append(item)
# Removes an item from the middle of vector
def remove_at(self:"Vector2", idx: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Removes an item from the middle of vector
def remove_at2(self:"Vector2", idx: int, idx2: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Retrieves an item at a given index
def get(self:"Vector2", idx: int) -> int:
return self.items[idx]
# Retrieves an item at a given index
def get2(self:"Vector2", idx: int, idx2: int) -> int:
return self.items[idx]
# Retrieves the current size of the vector
def length(self:"Vector2") -> int:
return self.size
# Retrieves the current size of the vector
def length2(self:"Vector2") -> int:
return self.size
# A resizable list of integers
class Vector3(object):
items: [int] = None
items2: [int] = None
items3: [int] = None
size: int = 0
size2: int = 0
size3: int = 0
def __init__(self:"Vector3"):
self.items = [0]
# Returns current capacity
def capacity(self:"Vector3") -> int:
return len(self.items)
# Returns current capacity
def capacity2(self:"Vector3") -> int:
return len(self.items)
# Returns current capacity
def capacity3(self:"Vector3") -> int:
return len(self.items)
# Increases capacity of vector by one element
def increase_capacity(self:"Vector3") -> int:
self.items = self.items + [0]
return self.capacity()
# Increases capacity of vector by one element
def increase_capacity2(self:"Vector3") -> int:
self.items = self.items + [0]
return self.capacity()
# Increases capacity of vector by one element
def increase_capacity3(self:"Vector3") -> int:
self.items = self.items + [0]
return self.capacity()
# Appends one item to end of vector
def append(self:"Vector3", item: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends one item to end of vector
def append2(self:"Vector3", item: int, item2: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends one item to end of vector
def append3(self:"Vector3", item: int, item2: int, item3: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends many items to end of vector
def append_all(self:"Vector3", new_items: [int]) -> object:
item:int = 0
for item in new_items:
self.append(item)
# Appends many items to end of vector
def append_all2(self:"Vector3", new_items: [int], new_items2: [int]) -> object:
item:int = 0
item2:int = 0
for item in new_items:
self.append(item)
# Appends many items to end of vector
def append_all3(self:"Vector3", new_items: [int], new_items2: [int], new_items3: [int]) -> object:
item:int = 0
item2:int = 0
item3:int = 0
for item in new_items:
self.append(item)
# Removes an item from the middle of vector
def remove_at(self:"Vector3", idx: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Removes an item from the middle of vector
def remove_at2(self:"Vector3", idx: int, idx2: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Removes an item from the middle of vector
def remove_at3(self:"Vector3", idx: int, idx2: int, idx3: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Retrieves an item at a given index
def get(self:"Vector3", idx: int) -> int:
return self.items[idx]
# Retrieves an item at a given index
def get2(self:"Vector3", idx: int, idx2: int) -> int:
return self.items[idx]
# Retrieves an item at a given index
def get3(self:"Vector3", idx: int, idx2: int, idx3: int) -> int:
return self.items[idx]
# Retrieves the current size of the vector
def length(self:"Vector3") -> int:
return self.size
# Retrieves the current size of the vector
def length2(self:"Vector3") -> int:
return self.size
# Retrieves the current size of the vector
def length3(self:"Vector3") -> int:
return self.size
# A resizable list of integers
class Vector4(object):
items: [int] = None
items2: [int] = None
items3: [int] = None
items4: [int] = None
size: int = 0
size2: int = 0
size3: int = 0
size4: int = 0
def __init__(self:"Vector4"):
self.items = [0]
# Returns current capacity
def capacity(self:"Vector4") -> int:
return len(self.items)
# Returns current capacity
def capacity2(self:"Vector4") -> int:
return len(self.items)
# Returns current capacity
def capacity3(self:"Vector4") -> int:
return len(self.items)
# Returns current capacity
def capacity4(self:"Vector4") -> int:
return len(self.items)
# Increases capacity of vector by one element
def increase_capacity(self:"Vector4") -> int:
self.items = self.items + [0]
return self.capacity()
# Increases capacity of vector by one element
def increase_capacity2(self:"Vector4") -> int:
self.items = self.items + [0]
return self.capacity()
# Increases capacity of vector by one element
def increase_capacity3(self:"Vector4") -> int:
self.items = self.items + [0]
return self.capacity()
# Increases capacity of vector by one element
def increase_capacity4(self:"Vector4") -> int:
self.items = self.items + [0]
return self.capacity()
# Appends one item to end of vector
def append(self:"Vector4", item: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends one item to end of vector
def append2(self:"Vector4", item: int, item2: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends one item to end of vector
def append3(self:"Vector4", item: int, item2: int, item3: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends one item to end of vector
def append4(self:"Vector4", item: int, item2: int, item3: int, item4: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends many items to end of vector
def append_all(self:"Vector4", new_items: [int]) -> object:
item:int = 0
for item in new_items:
self.append(item)
# Appends many items to end of vector
def append_all2(self:"Vector4", new_items: [int], new_items2: [int]) -> object:
item:int = 0
item2:int = 0
for item in new_items:
self.append(item)
# Appends many items to end of vector
def append_all3(self:"Vector4", new_items: [int], new_items2: [int], new_items3: [int]) -> object:
item:int = 0
item2:int = 0
item3:int = 0
for item in new_items:
self.append(item)
# Appends many items to end of vector
def append_all4(self:"Vector4", new_items: [int], new_items2: [int], new_items3: [int], new_items4: [int]) -> object:
item:int = 0
item2:int = 0
item3:int = 0
item4:int = 0
for item in new_items:
self.append(item)
# Removes an item from the middle of vector
def remove_at(self:"Vector4", idx: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Removes an item from the middle of vector
def remove_at2(self:"Vector4", idx: int, idx2: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Removes an item from the middle of vector
def remove_at3(self:"Vector4", idx: int, idx2: int, idx3: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Removes an item from the middle of vector
def remove_at4(self:"Vector4", idx: int, idx2: int, idx3: int, idx4: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Retrieves an item at a given index
def get(self:"Vector4", idx: int) -> int:
return self.items[idx]
# Retrieves an item at a given index
def get2(self:"Vector4", idx: int, idx2: int) -> int:
return self.items[idx]
# Retrieves an item at a given index
def get3(self:"Vector4", idx: int, idx2: int, idx3: int) -> int:
return self.items[idx]
# Retrieves an item at a given index
def get4(self:"Vector4", idx: int, idx2: int, idx3: int, idx4: int) -> int:
return self.items[idx]
# Retrieves the current size of the vector
def length(self:"Vector4") -> int:
return self.size
# Retrieves the current size of the vector
def length2(self:"Vector4") -> int:
return self.size
# Retrieves the current size of the vector
def length3(self:"Vector4") -> int:
return self.size
# Retrieves the current size of the vector
def length4(self:"Vector4") -> int:
return self.size
# A resizable list of integers
class Vector5(object):
items: [int] = None
items2: [int] = None
items3: [int] = None
items4: [int] = None
items5: [int] = None
size: int = 0
size2: int = 0
size3: int = 0
size4: int = 0
size5: int = 0
def __init__(self:"Vector5"):
self.items = [0]
# Returns current capacity
def capacity(self:"Vector5") -> int:
return len(self.items)
# Returns current capacity
def capacity2(self:"Vector5") -> int:
return len(self.items)
# Returns current capacity
def capacity3(self:"Vector5") -> int:
return len(self.items)
# Returns current capacity
def capacity4(self:"Vector5") -> int:
return len(self.items)
# Returns current capacity
def capacity5(self:"Vector5") -> int:
return len(self.items)
# Increases capacity of vector by one element
def increase_capacity(self:"Vector5") -> int:
self.items = self.items + [0]
return self.capacity()
# Increases capacity of vector by one element
def increase_capacity2(self:"Vector5") -> int:
self.items = self.items + [0]
return self.capacity()
# Increases capacity of vector by one element
def increase_capacity3(self:"Vector5") -> int:
self.items = self.items + [0]
return self.capacity()
# Increases capacity of vector by one element
def increase_capacity4(self:"Vector5") -> int:
self.items = self.items + [0]
return self.capacity()
# Increases capacity of vector by one element
def increase_capacity5(self:"Vector5") -> int:
self.items = self.items + [0]
return self.capacity()
# Appends one item to end of vector
def append(self:"Vector5", item: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends one item to end of vector
def append2(self:"Vector5", item: int, item2: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends one item to end of vector
def append3(self:"Vector5", item: int, item2: int, item3: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends one item to end of vector
def append4(self:"Vector5", item: int, item2: int, item3: int, item4: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends one item to end of vector
def append5(self:"Vector5", item: int, item2: int, item3: int, item4: int, item5: int) -> object:
if self.size == self.capacity():
self.increase_capacity()
self.items[self.size] = item
self.size = self.size + 1
# Appends many items to end of vector
def append_all(self:"Vector5", new_items: [int]) -> object:
item:int = 0
for item in new_items:
self.append(item)
# Appends many items to end of vector
def append_all2(self:"Vector5", new_items: [int], new_items2: [int]) -> object:
item:int = 0
item2:int = 0
for item in new_items:
self.append(item)
# Appends many items to end of vector
def append_all3(self:"Vector5", new_items: [int], new_items2: [int], new_items3: [int]) -> object:
item:int = 0
item2:int = 0
item3:int = 0
for item in new_items:
self.append(item)
# Appends many items to end of vector
def append_all4(self:"Vector5", new_items: [int], new_items2: [int], new_items3: [int], new_items4: [int]) -> object:
item:int = 0
item2:int = 0
item3:int = 0
item4:int = 0
for item in new_items:
self.append(item)
# Appends many items to end of vector
def append_all5(self:"Vector5", new_items: [int], new_items2: [int], new_items3: [int], new_items4: [int], new_items5: [int]) -> object:
item:int = 0
item2:int = 0
item3:int = 0
item4:int = 0
item5:int = 0
for item in new_items:
self.append(item)
# Removes an item from the middle of vector
def remove_at(self:"Vector5", idx: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Removes an item from the middle of vector
def remove_at2(self:"Vector5", idx: int, idx2: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Removes an item from the middle of vector
def remove_at3(self:"Vector5", idx: int, idx2: int, idx3: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Removes an item from the middle of vector
def remove_at4(self:"Vector5", idx: int, idx2: int, idx3: int, idx4: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Removes an item from the middle of vector
def remove_at5(self:"Vector5", idx: int, idx2: int, idx3: int, idx4: int, idx5: int) -> object:
if idx < 0:
return
while idx < self.size - 1:
self.items[idx] = self.items[idx + 1]
idx = idx + 1
self.size = self.size - 1
# Retrieves an item at a given index
def get(self:"Vector5", idx: int) -> int:
return self.items[idx]
# Retrieves an item at a given index
def get2(self:"Vector5", idx: int, idx2: int) -> int:
return self.items[idx]
# Retrieves an item at a given index
def get3(self:"Vector5", idx: int, idx2: int, idx3: int) -> int:
return self.items[idx]
# Retrieves an item at a given index
def get4(self:"Vector5", idx: int, idx2: int, idx3: int, idx4: int) -> int:
return self.items[idx]
# Retrieves an item at a given index
def get5(self:"Vector5", idx: int, idx2: int, idx3: int, idx4: int, idx5: int) -> int:
return self.items[idx]
# Retrieves the current size of the vector
def length(self:"Vector5") -> int:
return self.size
# Retrieves the current size of the vector
def length2(self:"Vector5") -> int:
return self.size
# Retrieves the current size of the vector
def length3(self:"Vector5") -> int:
return self.size
# Retrieves the current size of the vector
def length4(self:"Vector5") -> int:
return self.size
# Retrieves the current size of the vector
def length5(self:"Vector5") -> int:
return self.size
# A faster (but more memory-consuming) implementation of vector
class DoublingVector(Vector):
doubling_limit:int = 1000
# Overriding to do fewer resizes
def increase_capacity(self:"DoublingVector") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# A faster (but more memory-consuming) implementation of vector
class DoublingVector2(Vector):
doubling_limit:int = 1000
doubling_limit2:int = 1000
# Overriding to do fewer resizes
def increase_capacity(self:"DoublingVector2") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# Overriding to do fewer resizes
def increase_capacity2(self:"DoublingVector2") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# A faster (but more memory-consuming) implementation of vector
class DoublingVector3(Vector):
doubling_limit:int = 1000
doubling_limit2:int = 1000
doubling_limit3:int = 1000
# Overriding to do fewer resizes
def increase_capacity(self:"DoublingVector3") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# Overriding to do fewer resizes
def increase_capacity2(self:"DoublingVector3") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# Overriding to do fewer resizes
def increase_capacity3(self:"DoublingVector3") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# A faster (but more memory-consuming) implementation of vector
class DoublingVector4(Vector):
doubling_limit:int = 1000
doubling_limit2:int = 1000
doubling_limit3:int = 1000
doubling_limit4:int = 1000
# Overriding to do fewer resizes
def increase_capacity(self:"DoublingVector4") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# Overriding to do fewer resizes
def increase_capacity2(self:"DoublingVector4") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
$ElifElse
return self.capacity()
# Overriding to do fewer resizes
def increase_capacity3(self:"DoublingVector4") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# Overriding to do fewer resizes
def increase_capacity4(self:"DoublingVector4") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# A faster (but more memory-consuming) implementation of vector
class DoublingVector5(Vector):
doubling_limit:int = 1000
doubling_limit2:int = 1000
doubling_limit3:int = 1000
doubling_limit4:int = 1000
doubling_limit5:int = 1000
# Overriding to do fewer resizes
def increase_capacity(self:"DoublingVector5") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# Overriding to do fewer resizes
def increase_capacity2(self:"DoublingVector5") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# Overriding to do fewer resizes
def increase_capacity3(self:"DoublingVector5") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# Overriding to do fewer resizes
def increase_capacity4(self:"DoublingVector5") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# Overriding to do fewer resizes
def increase_capacity5(self:"DoublingVector5") -> int:
if (self.capacity() <= self.doubling_limit // 2):
self.items = self.items + self.items
else:
# If doubling limit has been reached, fall back to
# standard capacity increases
self.items = self.items + [0]
return self.capacity()
# Makes a vector in the range [i, j)
def vrange(i:int, j:int) -> Vector:
v:Vector = None
v = DoublingVector()
while i < j:
v.append(i)
i = i + 1
return v
def vrange2(i:int, j:int, i2:int, j2:int) -> Vector:
v:Vector = None
v2:Vector = None
v = DoublingVector()
while i < j:
v.append(i)
i = i + 1
return v
def vrange3(i:int, j:int, i2:int, j2:int, i3:int, j3:int) -> Vector:
v:Vector = None
v2:Vector = None
v3:Vector = None
v = DoublingVector()
while i < j:
v.append(i)
i = i + 1
return v
def vrange4(i:int, j:int, i2:int, j2:int, i3:int, j3:int, i4:int, j4:int) -> Vector:
v:Vector = None
v2:Vector = None
v3:Vector = None
v4:Vector = None
v = DoublingVector()
while i < j:
v.append(i)
i = i + 1
return v
def vrange5(i:int, j:int, i2:int, j2:int, i3:int, j3:int, i4:int, j4:int, i5:int, j5:int) -> Vector:
v:Vector = None
v2:Vector = None
v3:Vector = None
v4:Vector = None
v5:Vector = None
v = DoublingVector()
while i < j:
v.append(i)
i = i + 1
return v
# Sieve of Eratosthenes (not really)
def sieve(v:Vector) -> object:
i:int = 0
j:int = 0
k:int = 0
while i < v.length():
k = v.get(i)
j = i + 1
while j < v.length():
if v.get(j) % k == 0:
v.remove_at(j)
else:
j = j + 1
i = i + 1
def sieve2(v:Vector, v2:Vector) -> object:
i:int = 0
i2:int = 0
j:int = 0
j2:int = 0
k:int = 0
k2:int = 0
while i < v.length():
k = v.get(i)
j = i + 1
while j < v.length():
if v.get(j) % k == 0:
v.remove_at(j)
else:
j = j + 1
i = i + 1
def sieve3(v:Vector, v2:Vector, v3:Vector) -> object:
i:int = 0
i2:int = 0
i3:int = 0
j:int = 0
j2:int = 0
j3:int = 0
k:int = 0
k2:int = 0
k3:int = 0
while i < v.length():
k = v.get(i)
j = i + 1
while j < v.length():
if v.get(j) % k == 0:
v.remove_at(j)
else:
j = j + 1
i = i + 1
def sieve4(v:Vector, v2:Vector, v3:Vector, v4:Vector) -> object:
i:int = 0
i2:int = 0
i3:int = 0
i4:int = 0
j:int = 0
j2:int = 0
j3:int = 0
j4:int = 0
k:int = 0
k2:int = 0
k3:int = 0
k4:int = 0
while i < v.length():
k = v.get(i)
j = i + 1
while j < v.length():
if v.get(j) % k == 0:
v.remove_at(j)
else:
j = j + 1
i = i + 1
def sieve5(v:Vector, v2:Vector, v3:Vector, v4:Vector, v5:Vector) -> object:
i:int = 0
i2:int = 0
i3:int = 0
i4:int = 0
i5:int = 0
j:int = 0
j2:int = 0
j3:int = 0
j4:int = 0
j5:int = 0
k:int = 0
k2:int = 0
k3:int = 0
k4:int = 0
k5:int = 0
while i < v.length():
k = v.get(i)
j = i + 1
while j < v.length():
if v.get(j) % k == 0:
v.remove_at(j)
else:
j = j + 1
i = i + 1
# Input parameter
n:int = 50
n2:int = 50
n3:int = 50
n4:int = 50
n5:int = 50
# Data
v:Vector = None
v2:Vector = None
v3:Vector = None
v4:Vector = None
v5:Vector = None
i:int = 0
i2:int = 0
i3:int = 0
i4:int = 0
i5:int = 0
# Crunch
v = vrange(2, n)
v2 = vrange(2, n)
v3 = vrange(2, n)
v4 = vrange(2, n)
v5 = vrange(2, n)
sieve(v)
# Print
while i < v.length():
print(v.get(i))
i = i + 1
|
[
"647530+Virtlink@users.noreply.github.com"
] |
647530+Virtlink@users.noreply.github.com
|
3230d5448ef48ac2a50e98f9791b15a0ed770f9f
|
0147677b611e40ac695ba07f914264b3470a7401
|
/src/mac_address_info.py
|
4ad9f15c04cbbf5909df457315f089a8c5f1a0cb
|
[] |
no_license
|
mblomdahl/sniffer
|
a2aed3ee37bb9a39d3c13ad8455ce7c7a2fc58c7
|
9101c59f958bb94fe1443fd90e95d333a02b785f
|
refs/heads/master
| 2021-01-24T00:23:30.318623
| 2015-08-14T12:56:33
| 2015-08-14T12:56:33
| 41,627,533
| 0
| 0
| null | 2015-08-30T12:11:01
| 2015-08-30T12:11:01
| null |
UTF-8
|
Python
| false
| false
| 5,190
|
py
|
import json
import urllib2
import os
class MacAddressInfo:
def __init__(self):
self.mac_address = ""
self.company = ""
self.address1 = ""
self.address2 = ""
self.address3 = ""
self.country = ""
class MacAddressStorage:
def __init__(self):
self.data = [] # creates a new empty list
def mac_address_lookup_from_internet(self, mac_address):
try:
print "Load from Internet %s" % mac_address
# Set the request URL http://www.macvendorlookup.com/api/v2/08-86-3B-D4-90-C0
url = 'http://www.macvendorlookup.com/api/v2/' + mac_address
# Send the GET request
response = urllib2.urlopen(url)
resp = response.read()
mac_object = MacAddressInfo
data = []
if resp:
# Interpret the JSON response
#data = json.loads(resp.decode('utf8'))
data = json.loads(resp)
mac_object.mac_address = mac_address
for company in data:
mac_object.company = company['company']
for address1 in data:
mac_object.address1 = address1['addressL1']
for address2 in data:
mac_object.address2 = address2['addressL2']
for address3 in data:
mac_object.address3 = address3['addressL3']
for country in data:
mac_object.country = country['country']
else:
mac_object.mac_address = mac_address
mac_object.company = ""
mac_object.address1 = ""
mac_object.address2 = ""
mac_object.address3 = ""
mac_object.country = ""
return mac_object
except :
print "Unexpected error:", url, resp
return None
def mac_address_lookup_from_cache(self, mac_address):
try:
self.load_data_from_file()
count = len( self.data["mac addresses"] )
for index in range(count):
if self.data["mac addresses"][index]["macaddress"] == mac_address:
mac_object = MacAddressInfo
mac_object.mac_address = mac_address
mac_object.company = self.data["mac addresses"][index]["company"]
mac_object.address1 = self.data["mac addresses"][index]["address1"]
mac_object.address2 = self.data["mac addresses"][index]["address2"]
mac_object.address3 = self.data["mac addresses"][index]["address3"]
mac_object.country = self.data["mac addresses"][index]["country"]
return mac_object
return None
except :
print "mac_address_lookup_from_cache error:"
return None
def mac_address_lookup(self, mac_address):
try:
mac_object = self.mac_address_lookup_from_cache(mac_address)
if mac_object is None :
mac_object = self.mac_address_lookup_from_internet(mac_address)
if mac_object is not None :
#self.load_data_from_file()
print mac_address
self.data["mac addresses"].append( {"macaddress":mac_address, "company":mac_object.company, "address1":mac_object.address1, "address2":mac_object.address2, "address3":mac_object.address3, "country":mac_object.country} )
self.store_data_to_file()
else :
return None
return mac_object
except :
print "mac_address_lookup error:"
return None
def load_data_from_file(self):
if len( self.data ) == 0:
if os.path.exists("/home/pi/sniffer/mac_addresses.json"):
file_handel = open('/home/pi/sniffer/mac_addresses.json', 'r')
self.data = json.load(file_handel)
#print "Load"
else:
#file_handel = open('/home/pi/sniffer/mac_addresses.json', 'w')
self.data.append( {"mac addresses":[]} )
#print "new"
def store_data_to_file(self):
file_handel = open('/home/pi/sniffer/mac_addresses.json', 'w')
json.dump(self.data, file_handel, sort_keys=True, indent=2)
#file_handel.write('\n')
if __name__ == '__main__':
storage = MacAddressStorage()
mac_object = MacAddressInfo()
#mac_object = storage.mac_address_lookup("08:86:3B:D4:90:C0")
#mac_object = storage.mac_address_lookup("6C:F3:73:E6:0A:11")
mac_object = storage.mac_address_lookup("9C:6C:15:97:76:04")
#print storage.mac_address_lookup("08-86-3B-D4-90-C0").mac_address
if mac_object :
print mac_object.mac_address
print mac_object.company
print mac_object.address1
print mac_object.address2
print mac_object.address3
print mac_object.country
else :
print "Error"
|
[
"="
] |
=
|
49d5dabd0c8205c8eed6e8ec4291d98ee9d5549f
|
6ff024bfa3078c0e7f9f2f502c27bb066ae4a862
|
/ML_geron_1.py
|
f94f8cdbfe32e016666c5443242e0b396e8f9765
|
[] |
no_license
|
emvil/MLtraining
|
920b0f6808e9b3c675a62c90c548608beae8c292
|
6c9f37d6c6151bcb75d07b3cd6ee684062c5a7ed
|
refs/heads/master
| 2020-06-25T01:28:15.043324
| 2019-08-26T20:11:07
| 2019-08-26T20:11:07
| 199,154,180
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 3,377
|
py
|
# References:
# Book: Hands_on Machine Learning with Scikit-Learn and TensorFlow, Aurélien Géron, 2017.
# Chapter 2: End to end Machine Learning Project
# Objective: predict the district's median housing price in any block group of California.
# Current solution: manually estimated by experts, with a typical error of 15%.
# Framework: supervised multivariate regression problem, using batch learning.
# Performance measure: RMSE or MAE
import os
import tarfile
from six.moves import urllib
import pandas as pd
import matplotlib.pyplot as plt
from ML_tools import preprocessing
from sklearn.preprocessing import Imputer, LabelEncoder, OneHotEncoder, LabelBinarizer
# GET DATA
# DOWNLOAD_ROOT = "https://github.com/ageron/handson-ml/tree/master/"
HOUSING_PATH = "datasets/housing"
# HOUSING_URL = DOWNLOAD_ROOT + HOUSING_PATH + "/housing.tgz"
# -> downloaded
def load_housing_data(housing_path=HOUSING_PATH):
csv_path = os.path.join(housing_path, "housing.csv")
return pd.read_csv(csv_path)
# Explore data
housing_dataset = load_housing_data()
print(housing_dataset.head())
print(housing_dataset.info())
print(housing_dataset["ocean_proximity"].value_counts())
# stats for each variable
print(housing_dataset.describe())
# display histograms of variables
housing_dataset.hist(bins=50, figsize=(20, 15))
# plt.show()
# CREATE A TEST SET
housing_train, housing_test, tmp, tmp2 = preprocessing.split_data(housing_dataset, None, training_split_rate=0.80, display=True)
# PREPARE THE DATA FOR ML ALGORITHMS (p.59)
housing_labels = housing_train.loc[:, "median_house_value"].copy()
housing = housing_train.drop(labels="median_house_value", axis=1)
print(housing_labels.head())
print(housing.info())
# Data cleaning
""" 3 options to deal with missing values
- get rid of corresponding rows
- get rid of the whole attribute (columns)
- set the values to some value (zero, mean, median, etc)
"""
median_bedrooms = housing['total_bedrooms'].median()
print(median_bedrooms)
housing['total_bedrooms'].fillna(median_bedrooms, inplace=True)
print(housing.info())
# Data cleaning : other method
imputer = Imputer(strategy="median")
# compute df with only numerical values
housing_num = housing.drop('ocean_proximity', axis=1)
# fit the imputer with the training data
imputer.fit(housing_num)
print(imputer.statistics_)
print(housing_num.median().values)
# apply the imputer to all the numerical values (result is a numpy array)
X = imputer.transform(housing_num)
housing_tr = pd.DataFrame(X, columns=housing_num.columns)
# HANDLING TEXT AND CATEGORICAL ATTRIBUTES (p.62)
# to convert text labels into numbers
encoder = LabelEncoder()
housing_cat = housing["ocean_proximity"]
housing_cat_encoded = encoder.fit_transform(housing_cat)
print(housing_cat_encoded)
print(encoder.classes_)
# One-hot encoding : binary classes from the encoded category vector, output is sparse matrix
encoder = OneHotEncoder()
housing_cat_1hot = encoder.fit_transform(housing_cat_encoded.reshape(-1, 1))
print(housing_cat_1hot)
# do integer encoding and binary encoding more quickly, output is a dense numpy array by default
# unless you add sparse_output=True
encoder = LabelBinarizer()
housing_cat_1hot = encoder.fit_transform(housing_cat)
print(housing_cat_1hot)
# CUSTOM TRANSFORMERS (p.64)
|
[
"e.villeneuve@outlook.com"
] |
e.villeneuve@outlook.com
|
4d6b4640228f33cec47a54841e46353e8e26d85d
|
94f4b8a12cc09e3056cfc8d5304e5937b33ea6ec
|
/StemmingGUI.py
|
df3b3186cf7d4574b4fdb63f3d24f57296236b3b
|
[] |
no_license
|
Ehtisham09/Machine-Learning-Projects
|
8f1aaa7489bd84333491dbab8432cc76ed62915a
|
dd09308e555cc7aee0db74d91af6f5140e41d689
|
refs/heads/master
| 2020-07-13T03:12:27.513696
| 2019-10-20T18:25:43
| 2019-10-20T18:25:43
| 204,975,654
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,634
|
py
|
from tkinter import *
from tkinter import filedialog
from tkinter import messagebox
import tkinter.scrolledtext as tkscrolled
root = Tk()
root.title("Steming")
root.geometry("1160x600")
root.resizable(0,0)
def showOriginalText():
pass
def showStopWords():
pass
def showUniqueWords():
pass
def showInfix():
pass
def showPrefix():
pass
def showPostfix():
pass
def customization():
pass
def showPostProcessing():
pass
tabbuttons = Frame(root)
b1 = Button(tabbuttons,text="Original Text", command=showOriginalText, height=1, width=20)
b1.grid(row=1, column=0)
b2 = Button(tabbuttons,text="Stop Words", command=showStopWords, height=1, width=20)
b2.grid(row=1, column=1)
b3 = Button(tabbuttons,text="Unique Words", command=showUniqueWords, height=1, width=20)
b3.grid(row=1, column=2)
b4 = Button(tabbuttons,text="Prefix", command=showPrefix, height=1, width=20)
b4.grid(row=1, column=3)
b5 = Button(tabbuttons,text="Postfix", command=showPostfix, height=1, width=20)
b5.grid(row=1, column=4)
b6 = Button(tabbuttons,text="Post-Processing", command=showPostProcessing, height=1, width=20)
b6.grid(row=1, column=5)
b7 = Button(tabbuttons,text="Infix", command=showInfix, height=1, width=20)
b7.grid(row=1, column=6)
tabbuttons.grid(row=1, pady=(30,0))
textbox = tkscrolled.ScrolledText(root, height=20, width=132)
textbox.grid(row=2, pady=(0,20), padx=50)
def InputFile(): # Function For Browsing File
root.filename = filedialog.askopenfilename(title = "Select File", filetypes = [('Text files', '*.txt')])
f = open(root.filename,encoding="utf8")
content = f.read()
# data = str(content)
print(type(content))
textbox.insert(INSERT,content)
# print(content)
# data = content.split("۔")
def stemData():
pass
buttons = Frame(root) # Three Main Buttons Frame
clear = Button(buttons, text= "Clear" , command= lambda: textbox.delete(1.0,END), height=2, width=20) # Clear Button
browsebutton = Button(buttons, text ="Browse From Computer",command = InputFile, height=2) # Browse Button
browsebutton.grid(row=3,column=1, padx=4)
clear.grid(row=3,column=2, padx=4)
buttons.grid()
submitButton = Button(root, text="Stemming", command= stemData, width= 20, height= 2, bg = "yellow", font='bold') # Submit Button
submitButton.config(font=("Calibri", 15))
submitButton.grid(pady=(20,15))
root.mainloop()
|
[
"noreply@github.com"
] |
Ehtisham09.noreply@github.com
|
f6d96854d2e988c2c0d5f5a1574b5cc6c67840af
|
f31630adc1e677065975a4b57902db5e0700e4e9
|
/Exploratory Analysis.py
|
a0e87bf56446b76e8896020163885234c2d39435
|
[] |
no_license
|
kkoehncke/ML-Cheat-Sheets
|
8a5847a88b49e8d6b92ce5168a637347453fb3c5
|
2e85180a432a3b4b9aa591f6ac65dcbfe7721d2c
|
refs/heads/master
| 2020-03-11T20:08:33.822196
| 2018-04-19T14:40:55
| 2018-04-19T14:40:55
| 130,228,713
| 0
| 1
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 1,689
|
py
|
Exploratory Analysis:
# Dataframe dimensions
df.shape
# Column datatypes
df.dtypes
# Summarize numerical features
df.describe()
# Summarize categorical features
df.describe(include=['object'])
#Display first 5 rows; can speciy number inside to show n rows
df.head()
# Display last 5 rows of data
df.tail()
# Filter and display only df.dtypes that are 'object'
df.dtypes[df.dtypes == 'object']
# Segment by <> and display the means within each class; can do the same with .std()
df.groupby('<>').mean()
# Segment by <> and display the means and standard deviations within each class
df.groupby('<>').agg([np.mean, np.std])
# Loop through categorical feature names and print each one
for feature_names in df.dtypes[df.dtypes == 'object'].index:
print (feature_names)
# Plot bar plot for each categorical feature
for feature_names in df.dtypes[df.dtypes == 'object'].index:
sns.countplot(y = feature_names, data=df)
plt.show()
# Plot histogram grid
df.hist(figsize=(14,14), xrot=-45)
# Clear the text "residue"
plt.show()
# Bar plot for '<insert column name>'
sns.countplot(y = '<>', data=df)
# Boxplot of <> and <>
sns.boxplot(x = '<>', y = '<>', data = df)
# Violinplot of <> and <>
sns.violinplot(y = '<>', x = '<>', data = df)
# Make the figsize 10 x 8
plt.figure(figsize=(9,8))
# Plot heatmap of annotated correlations
sns.heatmap(correlations*100,annot = True ,fmt='.0f', cbar=False)
#For classification problems (bivariate)
sns.lmplot(x='<>', y='<>', hue='<binary target variable>', data=df, fit_reg=False)
# If we want scatter of only one of the target variables
sns.lmplot(x='<>', y='<>', data=df[df.<target column> == '<target value>'], fit_reg=False)
|
[
"kkoehncke@captechventures.com"
] |
kkoehncke@captechventures.com
|
1f905bbe4853784c2555aed917cc9767ada33140
|
5d0986d930daf567100130c66ae403e0d0cd043f
|
/train_segmentation.py
|
8f4eb9123b4c3a0861ff829789f87178289f8f38
|
[] |
no_license
|
and-jonas/HaloDetector
|
40d8f7d73cdd89f6c8aa51731ea29d79909a7ab1
|
ba0a1bd6f9d060d5ba1e035cb63d7d16a513e60c
|
refs/heads/master
| 2023-09-06T09:54:26.983910
| 2021-11-11T10:04:02
| 2021-11-11T10:04:02
| 426,910,093
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 6,049
|
py
|
# ======================================================================================================================
# Author: Jonas Anderegg, jonas.anderegg@usys.ethz.ch
# Extract training data from labelled patches and train segmentation algorithm
# Last modified: 2021-11-10
# ======================================================================================================================
from pathlib import Path
import pickle
import numpy as np
import pandas as pd
import glob
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import RandomizedSearchCV # Number of trees in random forest
from sklearn.model_selection import GridSearchCV # Create the parameter grid based on the results of random search
import SegmentationFunctions
# ======================================================================================================================
# (1) extract features and save to .csv
# ======================================================================================================================
workdir = 'Z:/Public/Jonas/001_LesionZoo/MRE'
# set directories to previously selected training patches
dir_positives = f'{workdir}/train_data_segmentation/Positives'
dir_negatives = f'{workdir}/train_data_segmentation/Negatives'
# extract feature data for all pixels in all patches
# output is stores in .csv files in the same directories
SegmentationFunctions.iterate_patches(dir_positives, dir_negatives)
# ======================================================================================================================
# (2) combine training data from all patches into single file
# ======================================================================================================================
# import all training data
# get list of files
files_pos = glob.glob(f'{dir_positives}/*.csv')
files_neg = glob.glob(f'{dir_negatives}/*.csv')
all_files = files_pos + files_neg
# load data
train_data = []
for i, file in enumerate(all_files):
print(i)
data = pd.read_csv(file)
data = data.iloc[::10, :] # only keep every 10th pixel of the patch
train_data.append(data)
# to single df
train_data = pd.concat(train_data)
# export, this may take a while
train_data.to_csv(f'{workdir}/train_data_segmentation/training_data.csv', index=False)
# ======================================================================================================================
# (3) train random forest classifier
# ======================================================================================================================
train_data = pd.read_csv(f'{workdir}/train_data_segmentation/training_data.csv')
# OPTIONAL: sample an equal number of rows per class for training
n_pos = train_data.groupby('response').count().iloc[0, 0]
n_neg = train_data.groupby('response').count().iloc[1, 0]
n_min = min(n_pos, n_neg)
train_data = train_data.groupby(['response']).apply(lambda grp: grp.sample(n=n_min))
n_estimators = [int(x) for x in np.linspace(start=20, stop=200, num=10)]
# Number of features to consider at every split
max_features = ['auto', 'sqrt']
# Maximum number of levels in tree
max_depth = [int(x) for x in np.linspace(10, 110, num=11)]
max_depth.append(None)
# Minimum number of samples required to split a node
min_samples_split = [2, 5, 10]
# Minimum number of samples required at each leaf node
min_samples_leaf = [1, 2, 4, 8]
# Method of selecting samples for training each tree
bootstrap = [True, False] # Create the random grid
random_grid = {'n_estimators': n_estimators,
'max_features': max_features,
'max_depth': max_depth,
'min_samples_split': min_samples_split,
'min_samples_leaf': min_samples_leaf,
'bootstrap': bootstrap}
# Use the random grid to search for best hyperparameters
# First create the base model to tune
rf = RandomForestClassifier()
# Random search of parameters, using 3 fold cross validation,
# search across 100 different combinations, and use all available cores
rf_random = RandomizedSearchCV(estimator=rf,
param_distributions= random_grid,
n_iter=100, cv=10,
verbose=3, random_state=42,
n_jobs=-1) # Fit the random search model
# predictor matrix
X = np.asarray(train_data)[:, 0:21]
# response vector
y = np.asarray(train_data)[:, 21]
model = rf_random.fit(X, y)
rf_random.best_params_
best_random = rf_random.best_estimator_
param_grid = {
'bootstrap': [True],
'max_depth': [60, 70, 80],
'max_features': [2, 4, 6, 8, 10],
'min_samples_leaf': [2, 4, 6, 8],
'min_samples_split': [8, 10, 12],
'n_estimators': [200, 300, 400]
}
# Create a based model
rf = RandomForestClassifier() # Instantiate the grid search model
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid,
cv=10, n_jobs=-1, verbose=3)
# Fit the grid search to the data
grid_search.fit(X, y)
grid_search.best_params_
# specify model hyper-parameters
clf = RandomForestClassifier(
max_depth=80, # maximum depth of 95 decision nodes for each decision tree
max_features=2, # maximum of 6 features (channels) are considered when forming a decision node
min_samples_leaf=8, # minimum of 6 samples needed to form a final leaf
min_samples_split=12, # minimum 4 samples needed to create a decision node
n_estimators=200, # maximum of 55 decision trees
bootstrap=False, # don't reuse samples
random_state=1,
n_jobs=-1
)
# fit random forest
model = clf.fit(X, y)
score = model.score(X, y)
# save model
path = f'{workdir}/Output/Models'
if not Path(path).exists():
Path(path).mkdir(parents=True, exist_ok=True)
pkl_filename = f'{path}/rf_segmentation.pkl'
with open(pkl_filename, 'wb') as file:
pickle.dump(model, file)
# ======================================================================================================================
|
[
"anjonas@student.ethz.ch"
] |
anjonas@student.ethz.ch
|
720b1ea6f006745bee5abcb72de9509ce028d5e6
|
a73cbe345107af388253ab3437992f09b1a033ed
|
/Aula 8/Aula8-Tuplas.py
|
04c116c1b911114ca5cfc5c9a746ea0c7bd79cc6
|
[
"MIT"
] |
permissive
|
ohanamirella/TrabalhosPython
|
09c586f897cf4ae33a1e49c8340883b17df832d2
|
453a97848654b0391d0d717bf102f6c466f79b3d
|
refs/heads/master
| 2020-09-05T22:54:46.245904
| 2020-02-03T14:51:39
| 2020-02-03T14:51:39
| 220,237,145
| 1
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 335
|
py
|
# Aula 8 - 18-11-2019
# Tuplas
numeros = [1,4,6]
usuario = {'nome':'user', 'passwd':123456 }
pessoa = ('maykon','granemann',0, 45.5, numeros)
# print(numeros)
# print(usuario)
# print(pessoa)
lista = [1]
numeros[1] = 5
usuario['passwd'] = 456123
lista_pessoas = []
lista_pessoas.append(pessoa)
#pessoa[4][1] = 6
print(pessoa[4][1])
|
[
"900153@proway.treina"
] |
900153@proway.treina
|
aa787dba2580b471a9d3b39d3d1b56d66c681e27
|
2d09e7e0b8c11e7a604580e54eb980fe7c97cffb
|
/ArrayOperation/canFinish.py
|
93d31a2bfc9c42d83e9db164208fbb1a546f3466
|
[] |
no_license
|
Philex5/codingPractice
|
8b67e53186c8f087c02214008269b3eb5d235d44
|
95dddb78bccd169d9d219a473627361fe739ab5e
|
refs/heads/master
| 2020-04-24T02:22:05.663438
| 2019-10-09T02:19:25
| 2019-10-09T02:19:25
| 171,634,380
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 2,652
|
py
|
# -*- coding: utf-8 -*-
# @Time : 2019/6/14 下午9:22
# @Author : Philex
# @File : canFinish.py
# @Software: PyCharm
"""
给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。
示例 1 :
输入:nums = [1,1,1], k = 2
输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。
说明 :
数组的长度为 [1, 20,000]。
数组中元素的范围是 [-1000, 1000] ，且整数 k 的范围是 [-1e7, 1e7]。
"""
class Solution:
# def subarraySum(self, nums, k):
# """
# 思路:连续子数组的和为一确定值
# 暴力法: 确定开始位置,向后遍历,累计从开始位置到当前位置的数字之和, 等于加入解集,大于终止,
# 把当前开始位置下一个位置作为开始位置
# 考虑的情况有点复杂,比如最后一个数字等于k,j=l不符合要求,不会进入while循环
# 还是会少考虑一些情况
# 直接简化,不用while,虽然会引入更多的计算
# 时间复杂度为: O(n^2)
# 空间复杂度为: O(1)
# 超出时间限制
# """
# if not nums or len(nums) == 0:
# return 0
# l = len(nums)
# res = 0
# for i in range(l):
# sums = 0
# for j in range(i, l):
# sums += nums[j]
# res += sums == k
# return res
def subarraySum(self, nums, k):
"""
思路: cumulative纪录从第一个位置到数组其他位置的和, cumulative[j] - cumulative[i]表示第j个元素
到第i个元素的和.
然后通过双重循环计算所有 两个元素之间的累计和
"""
if nums is None or len(nums) == 0:
return 0
l = len(nums)
cumu = [0] * (l+1)
res = 0
for i in range(1, l+1):
cumu[i] = cumu[i-1] + nums[i-1]
for i in range(l):
for j in range(i+1, l):
res += cumu[j+1] - cumu[i] == k
return res
def subarraySum1(self, nums, k):
"""
思路: 哈希表
利用字典存储 sum-k 出现的次数, sum-k = n -> sum = k + n, n存在, k肯定也存在
注意初始化0:1,保证结果能够累加
"""
sum, res, cul = 0, 0, {}
cul[0] = 1
for i in range(len(nums)):
sum += nums[i]
if sum - k in cul:
res += cul[sum-k]
if sum not in cul:
cul[sum] = 0
cul[sum] += 1
return res
so = Solution()
print(so.subarraySum1([1, 2, 3, 5], 3))
|
[
"Philexwoo@gmail.com"
] |
Philexwoo@gmail.com
|
f4e31986896cc7a6b49e731bcc2f5d073c79c3e2
|
0a643bb9bb8e864a439b7302ac9432eae8313de1
|
/main_app/migrations/0001_initial.py
|
3bbcc8ba2afffa21afce1c97cae20d1a61f24659
|
[] |
no_license
|
jamesgarcia2020/assess_3
|
f396a036cb04bb2f2b5b51c02702c8aabf0660ee
|
2644481ca7affa66fa7258dfc31f2b1443e51c43
|
refs/heads/master
| 2022-12-17T14:08:44.615862
| 2020-09-25T21:39:59
| 2020-09-25T21:39:59
| 298,646,492
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 545
|
py
|
# Generated by Django 3.1.1 on 2020-09-25 18:54
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Widget',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('description', models.CharField(max_length=50)),
('quantity', models.IntegerField()),
],
),
]
|
[
"jamesgarcia@Jamess-MacBook-Air.local"
] |
jamesgarcia@Jamess-MacBook-Air.local
|
4d6647ad50459cf616a4eaaa782651b3b18edf2d
|
1af1f89eb9a178b95d1ba023b209b7538fb151f0
|
/Algorithms/146. LRU Cache.py
|
09989dad11e2256fc8b9ce1d4d8a754a15563be9
|
[] |
no_license
|
0xtinyuk/LeetCode
|
77d690161cc52738e63a4c4b6595a6012fa5c21e
|
08bc96a0fc2b672282cda348c833c02218c356f1
|
refs/heads/master
| 2023-02-21T16:58:39.881908
| 2021-01-25T08:00:13
| 2021-01-25T08:00:13
| 292,037,842
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 826
|
py
|
from collections import OrderedDict
class LRUCache():
def __init__(self, capacity):
self.memory = OrderedDict()
self.capacity = capacity
def get(self, key):
if key not in self.memory:
return - 1
self.memory.move_to_end(key)
return self.memory[key]
def put(self, key, value):
if key in self.memory:
self.memory.move_to_end(key)
self.memory[key] = value
if len(self.memory) > self.capacity:
self.memory.popitem(last = False)
# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)
# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)
|
[
"xliu301@uottawa.ca"
] |
xliu301@uottawa.ca
|
e64030f4bfdc9f2ecd066eaf1ad8e5e2b067c849
|
e0eb81aef84ee0929aa3dfc166f29a343251c35b
|
/seafile-pro-server-7.0.10/pro/python/seafevents/tests/conftest.py
|
eadb20a149347ce0520fe528caab3c2e5768a7bc
|
[] |
no_license
|
Sandra-Z/filesharing
|
414fc56abe2f87b80ea390e0814a0bf86148a2bf
|
0e4e637f0c78f96949796b480b51df72d859c4ff
|
refs/heads/master
| 2022-12-11T12:28:07.155281
| 2019-11-19T08:39:51
| 2019-11-19T08:39:51
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 6,559
|
py
|
import os
import sys
import ConfigParser
import subprocess
from sqlalchemy import create_engine, text
from sqlalchemy.exc import DisconnectionError
from sqlalchemy.event import contains as has_event_listener, listen as add_event_listener
from urllib import quote_plus
from pytest import yield_fixture
from sqlalchemy.pool import Pool
from sqlalchemy.orm import sessionmaker
SEAHUB_DBNAME = ''
SEAFEVENTS_DBNAME = ''
TEST_DBNAME = ''
@yield_fixture(scope="module")
def test_db():
delete_all_table_if_exists()
# copy_db_from_seahub_with_no_data()
# copy_db_from_seafevent_with_no_data()
apply_tables()
yield None
# delete_all_table_if_exists()
def generate_tables_sql():
seahub_db = read_db_conf('SEAHUBDB')
seafevents_db = read_db_conf('SEAFEVENTSDB')
connection_data = [seahub_db[0]]
connection_data.extend(seahub_db[2:])
connection_data = tuple(connection_data)
cmd = "mysqldump -h%s -u%s -p%s --skip-add-locks --no-data --skip-add-drop-table --skip-comments %s > seahub.sql" % connection_data
cwd = ["bash", "-c", cmd]
subprocess.check_call(cwd, stdout=None, stderr=None)
connection_data = [seafevents_db[0]]
connection_data.extend(seafevents_db[2:])
connection_data = tuple(connection_data)
cmd = "mysqldump -h%s -u%s -p%s --skip-add-locks --no-data --skip-add-drop-table --skip-comments %s > seafevents.sql" % connection_data
cwd = ["bash", "-c", cmd]
subprocess.check_call(cwd, stdout=None, stderr=None)
merge_sql_file('raw_table_sql.sql')
def merge_sql_file(filename):
with open(filename, 'w') as fp:
for fname in ['seahub.sql', 'seafevents.sql']:
with open(fname) as tfp:
fp.write(tfp.read())
fp.write('\n')
def apply_tables():
seafevents_db = read_db_conf('TESTDB')
full_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'raw_table_sql.sql')
cmd = "mysql -h %s -u%s -p%s %s < %s" % (seafevents_db[0], seafevents_db[2], seafevents_db[3], seafevents_db[4], full_path)
cwd = ["bash", "-c", cmd]
try:
subprocess.check_call(cwd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
except Exception as e:
print e.output
def delete_all_table_if_exists():
session = None
try:
session = get_db_session('TESTDB')
session = get_db_session('TESTDB')
sql = text('SET FOREIGN_KEY_CHECKS = 0;')
session.execute(sql)
sql = text('SELECT table_name FROM information_schema.tables where table_schema= :db;')
tables = session.execute(sql, {'db': TEST_DBNAME}).fetchall()
if tables:
for tablename in tables:
del_sql = text('drop table %s' % tablename[0])
session.execute(del_sql)
sql = text('SET FOREIGN_KEY_CHECKS = 1;')
session.execute(sql)
except Exception as e:
sys.stdout.write(str(e))
finally:
if session:
session.close()
def copy_db_from_seahub_with_no_data():
test_session = None
seahub_session = None
try:
test_session = get_db_session('TESTDB')
seahub_session = get_db_session('SEAHUBDB')
sql = text('SELECT table_name FROM information_schema.tables where table_schema= :db')
tables = seahub_session.execute(sql, {'db': SEAHUB_DBNAME}).fetchall()
if tables:
for t_name in tables:
create_sql = text('create table %s like %s' % (t_name[0], "{0}.{1}".format(SEAHUB_DBNAME, t_name[0])))
test_session.execute(create_sql)
except Exception as e:
sys.stdout.write(str(e))
finally:
if seahub_session:
seahub_session.close()
if test_session:
test_session.close()
def copy_db_from_seafevent_with_no_data():
test_session = None
seahub_session = None
try:
test_session = get_db_session('TESTDB')
seahub_session = get_db_session('SEAFEVENTSDB')
sql = text('SELECT table_name FROM information_schema.tables where table_schema= :db')
tables = seahub_session.execute(sql, {'db': SEAFEVENTS_DBNAME}).fetchall()
if tables:
for t_name in tables:
create_sql = text('create table %s like %s' % (t_name[0], "{0}.{1}".format(SEAFEVENTS_DBNAME, t_name[0])))
test_session.execute(create_sql)
except Exception as e:
sys.stdout.write(str(e))
finally:
if seahub_session:
seahub_session.close()
if test_session:
test_session.close()
def get_db_session(section):
config = ConfigParser.ConfigParser()
config.read('./db.cnf')
if not config.has_section(section):
sys.stdout.write("no section: %s" % section)
return
host, port, username, passwd, dbname = read_db_conf(section)
db_url = "mysql+mysqldb://%s:%s@%s:%s/%s?charset=utf8" % (username, quote_plus(passwd), host, port, dbname)
global SEAHUB_DBNAME, SEAFEVENTS_DBNAME, TEST_DBNAME
if section == 'TESTDB':
TEST_DBNAME = dbname
elif section == 'SEAFEVENTSDB':
SEAFEVENTS_DBNAME = dbname
elif section == 'SEAHUBDB':
SEAHUB_DBNAME = dbname
kwargs = dict(pool_recycle=300, echo=False, echo_pool=False)
engine = create_engine(db_url, **kwargs)
if not has_event_listener(Pool, 'checkout', ping_connection):
add_event_listener(Pool, 'checkout', ping_connection)
Session = sessionmaker(bind=engine)
return Session()
def read_db_conf(section):
config = ConfigParser.ConfigParser()
config.read('./db.cnf')
if not config.has_section(section):
sys.stdout.write("no section: %s" % section)
return
if config.has_option(section, 'host'):
host = config.get(section, 'host').lower()
else:
host = 'localhost'
if config.has_option(section, 'port'):
port = config.getint(section, 'port')
else:
port = 3306
username = config.get(section, 'username')
passwd = config.get(section, 'password')
dbname = config.get(section, 'name')
return (host, port, username, passwd, dbname)
def ping_connection(dbapi_connection, connection_record, connection_proxy): # pylint: disable=unused-argument
cursor = dbapi_connection.cursor()
try:
cursor.execute("SELECT 1")
cursor.close()
except:
connection_proxy._pool.dispose() # pylint: disable=protected-access
# Raise DisconnectionError so the pool would create a new connection
raise DisconnectionError()
|
[
"deutschland.gray@gmail.com"
] |
deutschland.gray@gmail.com
|
85b871b51e585a914eea3800d452e2101a966e14
|
e211fdfc6fe8b79840409f7e2a2ee5e738bf9393
|
/main/migrations/0002_wishlist.py
|
4fcac7a1a83bc649d9aa74f9fdd14ab4a171ac52
|
[] |
no_license
|
Kuuhaku11/wishlist
|
ec28416c628d1df2c1e4a4f2ec8f767e255c1d3f
|
c97346c30c364da30d224edccf87a548b396a24c
|
refs/heads/master
| 2023-08-14T23:18:30.906645
| 2021-09-13T19:04:40
| 2021-09-13T19:04:40
| 404,098,496
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 897
|
py
|
# Generated by Django 3.2.7 on 2021-09-10 12:44
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('main', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Wishlist',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('title', models.CharField(max_length=120)),
('is_hidden', models.BooleanField(default=True)),
('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
('product', models.ManyToManyField(to='main.Product')),
],
),
]
|
[
"kuuhaku112121@gmail.com"
] |
kuuhaku112121@gmail.com
|
b5ca6f0bd9969bb338ebb2304402697b16cd66b8
|
78eea6b9b9ebada2d02360ff8747c804e4d3f2db
|
/load_image.py
|
0ed8141232b37f4d890dce638696d3666a93d76d
|
[] |
no_license
|
erkanercan/pyLogicGate
|
74c81cd714dff969c3aae496aab3cc297f6c295f
|
df19777da4299720131565eece40eebb93546a6c
|
refs/heads/master
| 2021-09-10T15:41:45.197118
| 2018-03-28T18:56:51
| 2018-03-28T18:56:51
| null | 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 501
|
py
|
import pygame,os
def load_image(name, colorkey=None):
fullname = os.path.join('data', name)
print(name)
try:
image = pygame.image.load(fullname)
except pygame.error as message:
print('Cannot load image:', fullname)
raise SystemExit(message)
image = image.convert()
if colorkey is not None:
if colorkey is -1:
colorkey = image.get_at((0,0))
image.set_colorkey(colorkey, pygame.RLEACCEL)
return image, image.get_rect()
|
[
"abajuradam@yahoo.com"
] |
abajuradam@yahoo.com
|
d090e5080697eb9ddc699d37c4656032fc8ef74a
|
31f85926c1bbafdb0621a43b320f48be2a1090ff
|
/matrix-cuda/extract_gpu.py
|
315584be16bc7aedece6334b2b66eb32c6cc9b13
|
[] |
no_license
|
subratpp/jetson_yolo
|
f1c3e32812c0c9c65883a4d58b817f5c0bdcc833
|
7e4c0edb55a70353a86e733914819077903b3f00
|
refs/heads/main
| 2023-03-03T10:28:01.331540
| 2021-02-12T17:17:22
| 2021-02-12T17:17:22
| 337,465,387
| 0
| 0
| null | null | null | null |
UTF-8
|
Python
| false
| false
| 342
|
py
|
import re
def gpu_workload(filename):
max_use = 0
with open(filename) as fp:
lines = fp.readlines()
for line in lines:
gpu = re.search(r'GR3D_FREQ (.*?)%', line).group(1)
if int(gpu) > max_use:
max_use = float(gpu)
return max_use
print(gpu_worklaod("matmul1000.txt"))
|
[
"subratprasad.mail@gmail.com"
] |
subratprasad.mail@gmail.com
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.