Datasets:

ytzi

/

the-stack-dedup-python-scored

like 0

26c8199913901f96201fe9b8091ee36c1351a53e

py

Python

examples/prompt.py

nelice/bullet

aafec4d0ca8f628d2be9b0667c50477929c2cca7

2021-03-22T07:55:30.000Z

2021-03-22T07:55:30.000Z

examples/prompt.py

nelice/bullet

aafec4d0ca8f628d2be9b0667c50477929c2cca7

examples/prompt.py

nelice/bullet

aafec4d0ca8f628d2be9b0667c50477929c2cca7

from bullet import Bullet, Prompt, Check, Input, YesNo from bullet import styles cli = Prompt( [ Bullet("Choose from a list: ", **styles.Example), Check("Choose from a list: ", **styles.Example), Input("Who are you? "), YesNo("Are you a student? ") ], spacing = 2 ) result = cli.launch() print(result)

26c8a00c561378714f8ad7990f244b2a1e695121

py

Python

testsuite/tests/T618-047__Ada_2012/run_test.py

AdaCore/style_checker

17108ebfc44375498063ecdad6c6e4430458e60a

2017-10-22T18:04:26.000Z

2020-03-06T11:07:41.000Z

testsuite/tests/T618-047__Ada_2012/run_test.py

AdaCore/style_checker

17108ebfc44375498063ecdad6c6e4430458e60a

testsuite/tests/T618-047__Ada_2012/run_test.py

AdaCore/style_checker

17108ebfc44375498063ecdad6c6e4430458e60a

2018-05-22T12:08:54.000Z

2020-12-14T15:25:27.000Z

def test_pck_2012_adb(style_checker): """Style check test against pck_2012.adb.""" style_checker.set_year(2006) p = style_checker.run_style_checker('repo_name', 'pck_2012.ads') style_checker.assertEqual(p.status, 0, p.image) style_checker.assertRunOutputEmpty(p) def test_pck_2012_adb_with_alt_config_forcing_gnat2012(style_checker): """Style check test against pck_2012.adb with gnat12 config option.""" style_checker.set_year(2006) p = style_checker.run_style_checker( '--config', 'gnat2012_config.yaml', 'repo_name', 'pck_2012.ads') style_checker.assertEqual(p.status, 0, p.image) style_checker.assertRunOutputEmpty(p)

26cacd8b2394e2ededf66d1f7ced4b0560e95348

py

Python

src/volume_0/0011_Drawing_Lots.py

DaikiShimada/aoj-exercise

dd4b70d4fd64aa28bc4cc75f5cdb8d02ea796803

src/volume_0/0011_Drawing_Lots.py

DaikiShimada/aoj-exercise

dd4b70d4fd64aa28bc4cc75f5cdb8d02ea796803

src/volume_0/0011_Drawing_Lots.py

DaikiShimada/aoj-exercise

dd4b70d4fd64aa28bc4cc75f5cdb8d02ea796803

# -*- coding: utf-8 -*- import sys def amida(w, side_bar): result = [] side_bar.reverse() for x in range(1, w+1): status = x for bar in side_bar: if status == bar[0]: status = bar[1] elif status == bar[1]: status = bar[0] result.append(status) return result def main(): W = int(input()) N = int(input()) side_bar = [tuple(map(int, input().split(','))) for line in range(N)] result = amida(W, side_bar) for r in result: print(r) if __name__ == '__main__': main()

26cbd6df4059d6dbdf0c29f052b92ccdc1a7a881

py

Python

mglg/util/profiler.py

aforren1/mglg

a9b703e109a66377dd404929fc0b13ccc12b5214

mglg/util/profiler.py

aforren1/mglg

a9b703e109a66377dd404929fc0b13ccc12b5214

2019-08-05T21:11:09.000Z

2021-11-18T18:19:33.000Z

mglg/util/profiler.py

aforren1/mglg

a9b703e109a66377dd404929fc0b13ccc12b5214

from timeit import default_timer import numpy as np class Profiler: __slots__ = ('active', 'gpuquery', 't0', 'cpubuffer', 'gpubuffer', 'counter', '_size', 'worst_cpu', 'worst_gpu') def __init__(self, gpu=False, ctx=None, buffer_size=200): self.active = False self.gpuquery = None if gpu and ctx is not None: self.gpuquery = ctx.query(time=True) self.cpubuffer = np.zeros(buffer_size, dtype='f4') self.gpubuffer = np.zeros(buffer_size, dtype='f4') self._size = buffer_size self.counter = 0 self.worst_cpu = 0 self.worst_gpu = 0 def begin(self): if self.active: if self.gpuquery: self.gpuquery.mglo.begin() self.t0 = default_timer() def end(self): t1 = default_timer() if self.active: if self.gpuquery: self.gpuquery.mglo.end() if self.counter < self._size: self.worst_gpu = 0 self.worst_cpu = 0 cpu_time = (t1 - self.t0) * 1000 # ms self.cpubuffer[self.counter % self._size] = cpu_time self.worst_cpu = cpu_time if cpu_time > self.worst_cpu else self.worst_cpu if self.gpuquery: gpu_time = self.gpuquery.elapsed/1000000.0 # ms self.gpubuffer[self.counter % self._size] = gpu_time self.worst_gpu = gpu_time if gpu_time > self.worst_gpu else self.worst_gpu self.counter += 1 def reset(self): self.cpubuffer[:] = 0 self.gpubuffer[:] = 0 self.counter = 0 self.worst_cpu = 0 self.worst_gpu = 0 def __enter__(self): self.begin() return self def __exit__(self, *args): self.end()

26ccd5bc1d5e387e612a0f077f3e861929e6b021

py

Python

toolbox/exp/Experiment.py

LinXueyuanStdio/KGE-toolbox

916842835e61ba99dde1409592977a2ec55f8aae

2021-10-17T17:50:24.000Z

2021-12-13T05:22:46.000Z

toolbox/exp/Experiment.py

LinXueyuanStdio/KGE-toolbox

916842835e61ba99dde1409592977a2ec55f8aae

toolbox/exp/Experiment.py

LinXueyuanStdio/KGE-toolbox

916842835e61ba99dde1409592977a2ec55f8aae

import numpy as np from toolbox.exp.OutputSchema import OutputSchema from toolbox.utils.LaTeXSotre import EvaluateLaTeXStoreSchema from toolbox.utils.MetricLogStore import MetricLogStoreSchema from toolbox.utils.ModelParamStore import ModelParamStoreSchema from toolbox.utils.Visualize import VisualizeSchema class Experiment: def __init__(self, output: OutputSchema, local_rank: int = -1): self.output = output self.local_rank = local_rank self.debug = self.log_in_main_node(output.logger.debug) self.log = self.log_in_main_node(output.logger.info) self.warn = self.log_in_main_node(output.logger.warn) self.error = self.log_in_main_node(output.logger.error) self.critical = self.log_in_main_node(output.logger.critical) self.success = self.log_in_main_node(output.logger.success) self.fail = self.log_in_main_node(output.logger.failed) self.vis = VisualizeSchema(str(output.pathSchema.dir_path_visualize)) self.model_param_store = ModelParamStoreSchema(output.pathSchema) self.metric_log_store = MetricLogStoreSchema(str(output.pathSchema.dir_path_log)) self.latex_store = EvaluateLaTeXStoreSchema(output.pathSchema) def re_init(self, output: OutputSchema, local_rank: int = -1): self.output = output self.local_rank = local_rank self.debug = self.log_in_main_node(output.logger.debug) self.log = self.log_in_main_node(output.logger.info) self.warn = self.log_in_main_node(output.logger.warn) self.error = self.log_in_main_node(output.logger.error) self.critical = self.log_in_main_node(output.logger.critical) self.success = self.log_in_main_node(output.logger.success) self.fail = self.log_in_main_node(output.logger.failed) self.vis = VisualizeSchema(str(output.pathSchema.dir_path_visualize)) self.model_param_store = ModelParamStoreSchema(output.pathSchema) self.metric_log_store = MetricLogStoreSchema(str(output.pathSchema.dir_path_log)) self.latex_store = EvaluateLaTeXStoreSchema(output.pathSchema) def log_in_main_node(self, log_func): if self.local_rank == 0: return log_func return lambda x: [x] def dump_model(self, model): self.debug(model) self.debug("") self.debug("Trainable parameters:") num_params = 0 for name, param in model.named_parameters(): if param.requires_grad: ps = np.prod(param.size()) num_params += ps self.debug(f"{name}: {sizeof_fmt(ps)}") self.log('Total Parameters: %s' % sizeof_fmt(num_params)) self.debug("") def sizeof_fmt(num, suffix='B'): for unit in ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi']: if abs(num) < 1024.0: return "%3.1f%s%s" % (num, unit, suffix) num /= 1024.0 return "%.1f%s%s" % (num, 'Yi', suffix)

26cdda5a2dd54f427c59a8a3d865986d8ec6b5ee

py

Python

src/dataloader/tests/runner.py

ODM2/ODM2DataSharingPortal

4ea1d633fe8e1cc39916e83041f2dbc830339e55

2018-11-27T11:57:24.000Z

2022-03-19T16:52:35.000Z

src/dataloader/tests/runner.py

ODM2/ODM2DataSharingPortal

4ea1d633fe8e1cc39916e83041f2dbc830339e55

2018-02-21T16:27:00.000Z

2022-03-31T18:48:48.000Z

src/dataloader/tests/runner.py

ODM2/ODM2DataSharingPortal

4ea1d633fe8e1cc39916e83041f2dbc830339e55

2018-07-04T17:13:09.000Z

2021-12-19T22:51:40.000Z

import json import os from django.core.management import call_command from django.test.runner import DiscoverRunner from django.db import connections from dataloader.tests.data import data_manager class ODM2TestRunner(DiscoverRunner): test_connection = None database_alias = u'odm2' def setup_test_environment(self, **kwargs): data_manager.load_models_data() call_command('makemigrations', 'dataloader') super(ODM2TestRunner, self).setup_test_environment(**kwargs) def setup_databases(self, **kwargs): old_names = [] self.test_connection = connections[self.database_alias] old_names.append((self.test_connection, self.test_connection.settings_dict['NAME'], True)) self.test_connection.creation.create_test_db( verbosity=self.verbosity, keepdb=self.keepdb ) return old_names

26cf29a0e44e798901be0b42a84cea83caaf14fe

py

Python

plugins/rain.py

xditya/PikaBotPlugins

2c5c52716158cd8964220bcc71fa383ccaf1210a

2021-02-16T05:35:41.000Z

2021-05-25T16:59:47.000Z

plugins/rain.py

xditya/PikaBotPlugins

2c5c52716158cd8964220bcc71fa383ccaf1210a

plugins/rain.py

xditya/PikaBotPlugins

2c5c52716158cd8964220bcc71fa383ccaf1210a

2021-02-07T03:09:40.000Z

2021-05-25T16:59:59.000Z

#Originally created By KingMars ✅ Rain Sequence 2 {Updated} from telethon import events import asyncio from collections import deque @ItzSjDude(outgoing=True, pattern=r"km_rain2") async def _(event): if event.fwd_from: return deq = deque(list("☁️⛈Ř/~\İŇ🌬⚡🌪")) for _ in range(100): await asyncio.sleep(0.1) await event.edit("".join(deq)) deq.rotate(1)

26cf746287a13ed33dacec35f0898c4fe183c37a

py

Python

preprocessing/__init__.py

WiktorSa/Music-Generation-with-LSTM-and-.wav-files

37b713b5e6193788a7710cc0fac4134efb74fa62

2022-03-09T20:13:57.000Z

2022-03-09T20:13:57.000Z

preprocessing/__init__.py

WiktorSa/Music-Generation-with-LSTM-and-.wav-files

37b713b5e6193788a7710cc0fac4134efb74fa62

2021-10-01T16:20:06.000Z

2021-10-01T17:25:30.000Z

preprocessing/__init__.py

WiktorSa/Music-Generation-with-LSTM-and-.wav-files

37b713b5e6193788a7710cc0fac4134efb74fa62

from preprocessing.generate_and_save_data import generate_and_save_data

26cfb507f5245413925f5d6ffbbfcea4aa484298

py

Python

plot.py

lizzieayton/PrimordialOozebot

1e330b1ac6f27bd167734ad6c6ecff70f816986a

plot.py

lizzieayton/PrimordialOozebot

1e330b1ac6f27bd167734ad6c6ecff70f816986a

plot.py

lizzieayton/PrimordialOozebot

1e330b1ac6f27bd167734ad6c6ecff70f816986a

import matplotlib.pyplot as plt import csv import statistics import math plt.title('Population Diversity') plt.ylabel('Diversity Score') plt.xlabel('Iteration Number') random = [] randombars = [] rmin = [] rmax = [] hill = [] hillbars = [] hmin = [] hmax = [] evo = [] emin = [] emax = [] evobars = [] cross = [] crossbars = [] cmin = [] cmax = [] numRuns = 5 numIterations = 100000000 sqrtRuns = math.sqrt(numRuns) iterationDataRandom = [] iterationDataHill = [] iterationDataEvo = [] iterationDataCross = [] indicesToPlot = [10, 15, 20, 25] index = 60 while indicesToPlot[-1] < numIterations: indicesToPlot.append(index) index = int(index * 1.02) indicesToPlot[-1] = numIterations - 1 #xtiks = [] #for i in range(10): # xtiks.append(int(numIterations / 5 * i)) #plt.xticks(xtiks) for i in range(1, numRuns + 1): iterationDataRandom.append({}) iterationDataHill.append({}) iterationDataEvo.append({}) iterationDataCross.append({}) with open('rand' + str(i) + '.csv', newline='') as csvfile: reader = csv.reader(csvfile, delimiter=' ', quotechar='|') index = 0 for row in reversed(list(reader)): vals = row[0].split(',') iteration = int(vals[0]) val = float(vals[1]) while index < len(indicesToPlot) - 1 and indicesToPlot[index + 1] < iteration: index += 1 iterationDataRandom[-1][indicesToPlot[index]] = val with open('hill' + str(i) + '.csv', newline='') as csvfile: reader = csv.reader(csvfile, delimiter=' ', quotechar='|') index = 0 for row in reversed(list(reader)): vals = row[0].split(',') iteration = int(vals[0]) val = float(vals[2]) while index < len(indicesToPlot) - 1 and indicesToPlot[index] < iteration: index += 1 iterationDataHill[-1][indicesToPlot[index]] = val with open('evo' + str(i) + '.csv', newline='') as csvfile: reader = csv.reader(csvfile, delimiter=' ', quotechar='|') index = 0 for row in reversed(list(reader)): vals = row[0].split(',') iteration = int(vals[0]) * 100 val = float(vals[2]) while index < len(indicesToPlot) - 1 and indicesToPlot[index] < iteration: index += 1 iterationDataEvo[-1][indicesToPlot[index]] = val with open('ed' + str(i) + '.csv', newline='') as csvfile: reader = csv.reader(csvfile, delimiter=' ', quotechar='|') index = 0 for row in reversed(list(reader)): vals = row[0].split(',') iteration = int(vals[0]) val = float(vals[2]) while index < len(indicesToPlot) - 1 and indicesToPlot[index] < iteration: index += 1 iterationDataCross[-1][indicesToPlot[index]] = val print("Done reading data") unifiedRandom = [] unifiedHill = [] unifiedEvo = [] unifiedCross = [] index = 0 for iteration in indicesToPlot: currentRandom = [] currentHill = [] currentEvo = [] currentCross = [] unifiedRandom.append(currentRandom) unifiedHill.append(currentHill) unifiedEvo.append(currentEvo) unifiedCross.append(currentCross) for run in range(numRuns): valRandom = -1 if iteration in iterationDataRandom[run]: valRandom = iterationDataRandom[run][iteration] else: # unchanged valRandom = unifiedRandom[-2][run] currentRandom.append(valRandom) valHill = -1 if iteration in iterationDataHill[run]: valHill = iterationDataHill[run][iteration] else: # unchanged valHill = unifiedHill[-2][run] currentHill.append(valHill) valEvo = -1 if iteration in iterationDataEvo[run]: valEvo = iterationDataEvo[run][iteration] else: #unchanged valEvo = unifiedEvo[-2][run] currentEvo.append(valEvo) valCross = -1 if iteration in iterationDataCross[run]: valCross = iterationDataCross[run][iteration] else: #unchanged valCross = unifiedCross[-2][run] currentCross.append(valCross) randomAverage = statistics.mean(currentRandom) randomError = statistics.stdev(currentRandom) / sqrtRuns random.append(randomAverage) randombars.append(randomError) hillAverage = statistics.mean(currentHill) hillError = statistics.stdev(currentHill) / sqrtRuns hill.append(hillAverage) hillbars.append(hillError) evoAverage = statistics.mean(currentEvo) evoError = statistics.stdev(currentEvo) / sqrtRuns evo.append(evoAverage) evobars.append(evoError) crossAverage = statistics.mean(currentCross) crossError = statistics.stdev(currentCross) / sqrtRuns cross.append(crossAverage) crossbars.append(crossError) for i in range(len(random)): rmin.append(random[i] - randombars[i]) rmax.append(random[i] + randombars[i]) hmin.append(hill[i] - hillbars[i]) hmax.append(hill[i] + hillbars[i]) emin.append(evo[i] - evobars[i]) emax.append(evo[i] + evobars[i]) cmin.append(cross[i] - crossbars[i]) cmax.append(cross[i] + crossbars[i]) print("Done processing data") plt.xscale('log') #plt.yscale('log') #plt.plot(indicesToPlot, random, color='blue', linewidth=1, label='Random Search') plt.plot(indicesToPlot, hill, color='green', linewidth=1, label='Parallel Hill Climb') plt.plot(indicesToPlot, evo, color='red', linewidth=1, label='Weighted Selection') plt.plot(indicesToPlot, cross, color='blue', linewidth=1, label='Parental Replacement') plt.fill_between(indicesToPlot, hmin, hmax, facecolor='green', lw=0, alpha=0.5) plt.fill_between(indicesToPlot, emin, emax, facecolor='red', lw=0, alpha=0.5) plt.fill_between(indicesToPlot, cmin, cmax, facecolor='blue', lw=0, alpha=0.5) #plt.fill_between(indicesToPlot, rmin, rmax, facecolor='blue', lw=0, alpha=0.5) plt.legend(loc='best') plt.savefig('diversityp.png', dpi=500) plt.show()

26cfea22c43edc42786c9199d503d77927f66e4d

py

Python

python/obra_hacks/backend/commands.py

brandond/obra-hacks

df451c6c6cd78b48f6e32bbd102a8e8a6bd77cb3

python/obra_hacks/backend/commands.py

brandond/obra-hacks

df451c6c6cd78b48f6e32bbd102a8e8a6bd77cb3

python/obra_hacks/backend/commands.py

brandond/obra-hacks

df451c6c6cd78b48f6e32bbd102a8e8a6bd77cb3

#!/usr/bin/env python # -*- coding: utf-8 -*- from __future__ import unicode_literals import logging from datetime import date import click from .data import DISCIPLINE_MAP from .outputs import OUTPUT_MAP @click.command() @click.option('--discipline', type=click.Choice(DISCIPLINE_MAP.keys()), required=True) @click.option('--output', type=click.Choice(sorted(OUTPUT_MAP.keys())), default='text') @click.option('--scrape/--no-scrape', default=True) @click.option('--debug/--no-debug', default=False) def cli(discipline, output, scrape, debug): log_level = 'DEBUG' if debug else 'INFO' logging.basicConfig(level=log_level, format='%(levelname)s:%(module)s.%(funcName)s:%(message)s') # Import these after setting up logging otherwise we don't get logs from .scrapers import clean_events, scrape_year, scrape_new, scrape_parents, scrape_recent from .upgrades import confirm_pending_upgrades, recalculate_points, print_points, sum_points from .rankings import calculate_race_ranks from .models import db with db.atomic('IMMEDIATE'): if scrape: # Scrape last 5 years of results cur_year = date.today().year for year in range(cur_year - 6, cur_year + 1): scrape_year(year, discipline) scrape_parents(year, discipline) clean_events(year, discipline) # Load in anything new scrape_new(discipline) # Check for updates to anything touched in the last three days scrape_recent(discipline, 3) # Calculate points from new data if recalculate_points(discipline, incremental=False): calculate_race_ranks(discipline, incremental=False) sum_points(discipline) confirm_pending_upgrades(discipline) # Finally, output data print_points(discipline, output) if __name__ == '__main__': cli()

26d2a8925926b05405485ed3b4fa01550942c26f

py

Python

join_json.py

ryavorsky/med_robo

56f8d2067921ef7208166380e50af0600c10032a

join_json.py

ryavorsky/med_robo

56f8d2067921ef7208166380e50af0600c10032a

join_json.py

ryavorsky/med_robo

56f8d2067921ef7208166380e50af0600c10032a

import json with open('bibliography.json', 'r', encoding='utf-8') as bib_data: bib = sorted(json.load(bib_data), key=lambda d: d['ID']) with open('abstracts.json', 'r', encoding='utf-8') as tex_data: tex = sorted(json.load(tex_data), key=lambda d: d['ID']) ID1 = [b['ID'] for b in bib] ID2 = [t['ID'] for t in tex] for i in range(len(ID1)): bib[i]['reference'] = tex[i]['title'] bib[i]['abstract'] = tex[i]['abstract'] print('Done') with open('med_robo_papers.json', 'w', encoding='utf-8') as res_file: res_file.write(json.dumps(bib, indent=4, ensure_ascii=False, sort_keys=True)) res_file.close()

26d58240f4233e1d13f48a78a83f734ca262cc13

py

Python

Qcover/simulator/__init__.py

BAQIS-Quantum/Qcover

ca3776ed73fefa0cfef08042143a8cf842f8dad5

2021-12-22T03:12:01.000Z

2022-03-17T06:57:10.000Z

Qcover/simulator/__init__.py

BAQIS-Quantum/Qcover

ca3776ed73fefa0cfef08042143a8cf842f8dad5

Qcover/simulator/__init__.py

BAQIS-Quantum/Qcover

ca3776ed73fefa0cfef08042143a8cf842f8dad5

2021-12-22T07:32:44.000Z

2022-02-28T06:47:41.000Z

from .qton import Qcircuit, Qcodes import warnings warnings.filterwarnings("ignore") __all__ = [ # 'Simulator', 'Qcircuit', 'Qcodes' ]

26d8d630adbf36e69e2b1f614c164c0bdbf94301

py

Python

pizzerias/pizzerias_search.py

LiushaHe0317/pizzerias_block_search

16dd7fb20b1a29a4f16b28ac7e5a84b30f7f9a7b

pizzerias/pizzerias_search.py

LiushaHe0317/pizzerias_block_search

16dd7fb20b1a29a4f16b28ac7e5a84b30f7f9a7b

pizzerias/pizzerias_search.py

LiushaHe0317/pizzerias_block_search

16dd7fb20b1a29a4f16b28ac7e5a84b30f7f9a7b

from typing import Sequence import numpy class PizzeriasSearcher: """ This object takes the size of the city and number of shops, and construct the matrices each shop delivery can cover and number of delivery for each cell in the city. It can also computes number of delivery for a given cell, maximum of number of delivery, and a sequence of cell coordinates which have the maximum. :param n_of_block: An integer which indicates the size of the city. :param shop_covers: A sequence of sequences, each sequence contains a tuple of two integers representing the coordinate of a pizzerias shop and an integer representing the distance the shop could cover. """ def __init__(self, n_of_block: int, shop_covers: Sequence): self.n_of_block = n_of_block self.shop_covers = shop_covers def each_shop_matrix(self, shop_loc: Sequence): """ This method takes the location of a shop and dimensionality of the city, converts to a 2D ``numpy.ndarray`` which indicates the whole area a pizzerias shop delivery service can cover. :param shop_loc: A sequence containing a tuple of two integers which indicate the coordinates on x- and y- axis and an integer which indicates the farthest distance a delivery guy can go. :return: A 2D ``numpy.ndarray``. """ (x_initial, y_initial), r = shop_loc matrix = numpy.zeros([self.n_of_block, self.n_of_block]) # convert x, y coordinates x_center = x_initial - 1 # in numpy, x axis = 1 y_center = self.n_of_block - y_initial # in numpy, y axis = 0 # create a list of x or y coordinate which indicates the cells the shop could cover x_list = [x for x in range(x_center-r, x_center+r+1) if x >= 0 and x < self.n_of_block] # y_list = [y for y in range(y_center-r, y_center+r+1) if y >= 0 and y <= n_of_block-1] for d1 in x_list: high_bound = y_center + r - numpy.abs(d1 - x_center) + 1 low_bound = y_center - r + numpy.abs(d1 - x_center) matrix[low_bound:high_bound, d1] = 1 return matrix def area_matrix(self, loc: Sequence, radius: int): """ This method takes a tuple of coordinates and a radius, construct a sub-matrix of the city matrix accordingly. :param loc: A tuple of integers. :param radius: An integer. :return: A 2D ``numpy.ndarray``. """ x_initial, y_initial = loc if y_initial < 0 or x_initial > self.n_of_block or x_initial < 0 or y_initial > self.n_of_block: raise ValueError('The location is out of city range.') else: y_center = self.n_of_block - y_initial x_center = x_initial - 1 low0 = y_center - radius if y_center - radius >= 0 else 0 high0 = y_center + radius + 1 if y_center + radius + 1 <= self.n_of_block else self.n_of_block left1 = x_center - radius if x_center - radius >= 0 else 0 right1 = x_center + radius + 1 if x_center + radius + 1 <= self.n_of_block else self.n_of_block return self.pizzerias_matrix[low0: high0, left1: right1] def maximum_in_matrix(self, matrix=None): """ This method returns the maximum a city block could have. :param matrix: A ``numpy.ndarray``. :return: An integer. """ if isinstance(matrix, numpy.ndarray): return int(numpy.amax(matrix)) elif matrix is None: return int(numpy.amax(self.pizzerias_matrix)) else: raise Exception('Accept numpy.ndarray only!') def max_locations(self, matrix=None, d0_start=0, d1_start=0): """ This method returns a set of cells which have maximum. :param matrix: A ``numpy.ndarray`. :param d0_start: An integer. :param d1_start: An integer. :return: A set of tuples. """ if matrix is None: d0, d1 = numpy.where(self.pizzerias_matrix == numpy.amax(self.pizzerias_matrix)) return {(x + 1, self.n_of_block - d0[i]) for i, x in enumerate(d1)} elif isinstance(matrix, numpy.ndarray): d0, d1 = numpy.where(matrix == numpy.amax(matrix)) return {(x + 1 + d1_start, self.n_of_block - (d0[i] + d0_start)) for i, x in enumerate(d1)} else: raise Exception('Accept numpy.ndarray only!') @property def no_of_pizzeriass(self): """ This method returns the total number of shops in the city. """ return len(self.shop_covers) @property def pizzerias_matrix(self): """ This method returns a matrix indicating the whole picture of pizzerias delivery services. """ p_matrix = numpy.zeros([self.n_of_block, self.n_of_block]) for shop_loc in self.shop_covers: p_matrix += self.each_shop_matrix(shop_loc) return p_matrix def check_location(self, home_loc: Sequence, report=False): """ This method takes a tuple of two integers which indicate the coordinate of a given home location. :param home_loc: A tuple of integers. :return: number of delivery in the current location. """ num = self.pizzerias_matrix[self.n_of_block - home_loc[1], home_loc[0] - 1] if report: if num == 0: print("Unfortunately, there is no delivery service in your current location.") else: print(f'Cool, {int(num)} pizzerias could cover your current location.') return num def check_area(self, loc: Sequence, radius: int, report=False): """ This method takes a location coordinate and a radius and search the delivery services around this specified area. :param loc: A tuple of integers. :param radius: An integer. :param report: A boolean that indicates whether or not print a report. return: - A sub-matrix of the pizzerias matrix which is created in terms of specified range. - A maximum in this area. - A set of cells that have maximum. """ matrix = self.area_matrix(loc, radius) x_initial, y_initial = loc y_center = self.n_of_block - y_initial x_center = x_initial - 1 low0 = y_center - radius if y_center - radius >= 0 else 0 left1 = x_center - radius if x_center - radius >= 0 else 0 maximum = self.maximum_in_matrix(matrix) max_set = self.max_locations(matrix=matrix, d0_start=low0, d1_start=left1) if report: print(f"In the given area, there are {len(max_set)} areas where {maximum} Pizzerias delivery service " f"can cover, they are: ", max_set) return matrix, maximum, max_set def check_city(self, report=False): """ This method returns the matrix, the maximum and a set of maximum tuple of cells. :param report: A boolean indicating whether or not print report. :return: - The pizzerias matrix. - A maximum in this the pizzerias matrix. - A set of cells that have maximum. """ if report: print(f"There are {len(self.max_locations())} area(s) where {self.maximum_in_matrix()} Pizzerias can cover, " f"they are: ", self.max_locations()) return self.pizzerias_matrix, self.maximum_in_matrix(), self.max_locations()

26d8feef12cddd2dca60e0f08ac5f863599108a2

py

Python

analysis/hist_javelin.py

LiyrAstroph/MICA

2592b8ad3011880898f557a69b22cad63fcd47e0

2016-10-25T06:32:33.000Z

2016-10-25T06:32:33.000Z

analysis/hist_javelin.py

LiyrAstroph/MICA

2592b8ad3011880898f557a69b22cad63fcd47e0

analysis/hist_javelin.py

LiyrAstroph/MICA

2592b8ad3011880898f557a69b22cad63fcd47e0

2016-12-29T06:04:13.000Z

2020-04-12T11:48:42.000Z

import numpy as np import matplotlib.pyplot as plt import corner mcmc = np.loadtxt("mychain1.dat") ntheta = mcmc.shape[1] fig = plt.figure(1, figsize=(15, 6)) ax = fig.add_subplot(231) ax.hist(mcmc[:, 0]/np.log(10.0), 100, normed=True, range=(-0.9, -0.1)) ax = fig.add_subplot(232) ax.hist(mcmc[:, 1]/np.log(10.0), 100, normed=True, range=(0.0, 2.0)) ax = fig.add_subplot(234) ax.hist(mcmc[:, 2], 100, normed=True, range=(1.0, 2.8)) ax = fig.add_subplot(235) ax.hist(mcmc[:, 3], 100, normed=True, range=(0.0, 1.2)) ax = fig.add_subplot(236) ax.hist(mcmc[:, 4], 100, normed=True, range=(5, 13)) mcmc = np.loadtxt("../data/mcmc.txt") ntheta = mcmc.shape[1] nb = 20000 fig = plt.figure(2, figsize=(15, 6)) ax = fig.add_subplot(231) ax.hist( (mcmc[nb:, 1]+0.5*mcmc[nb:, 2]-0.5*np.log(2.0))/np.log(10.0), 100, normed=True, range=(-0.9, -0.1)) ax = fig.add_subplot(232) ax.hist(mcmc[nb:, 2]/np.log(10), 100, normed=True, range=(0.0, 2.0)) ax = fig.add_subplot(234) ax.hist(mcmc[nb:, 5], 100, normed=True, range=(1.0, 2.8)) ax = fig.add_subplot(235) ax.hist(mcmc[nb:, 3], 100, normed=True, range=(0.0, 1.2)) ax = fig.add_subplot(236) ax.hist(mcmc[nb:, 4], 100, normed=True, range=(5, 13)) plt.show()

26da85c2640497939b911d5705595d7671906491

py

Python

tests/test_stats.py

janjaappape/pastas

521b27efd921e240df0717038f8389d62099b8ff

2017-01-25T05:48:53.000Z

2022-03-31T17:46:37.000Z

tests/test_stats.py

janjaappape/pastas

521b27efd921e240df0717038f8389d62099b8ff

2017-02-14T10:59:01.000Z

2022-03-31T09:17:37.000Z

tests/test_stats.py

janjaappape/pastas

521b27efd921e240df0717038f8389d62099b8ff

2017-02-14T10:26:54.000Z

2022-03-11T14:04:48.000Z

import numpy as np import pandas as pd import pastas as ps def acf_func(**kwargs): index = pd.to_datetime(np.arange(0, 100, 1), unit="D", origin="2000") data = np.sin(np.linspace(0, 10 * np.pi, 100)) r = pd.Series(data=data, index=index) acf_true = np.cos(np.linspace(0.0, np.pi, 11))[1:] acf = ps.stats.acf(r, lags=np.arange(1.0, 11.), min_obs=1, **kwargs).values return acf, acf_true def test_acf_rectangle(): acf, acf_true = acf_func(bin_method="rectangle") assert abs((acf - acf_true)).max() < 0.05 def test_acf_gaussian(): acf, acf_true = acf_func(bin_method="gaussian") assert abs((acf - acf_true)).max() < 0.05 def test_runs_test(): """ http://www.itl.nist.gov/div898/handbook/eda/section3/eda35d.htm True Z-statistic = 2.69 Read NIST test data """ data = pd.read_csv("tests/data/nist.csv") test, _ = ps.stats.runs_test(data) assert test[0] - 2.69 < 0.02 def test_stoffer_toloi(): res = pd.Series(index=pd.date_range(start=0, periods=1000, freq="D"), data=np.random.rand(1000)) _, pval = ps.stats.stoffer_toloi(res) assert pval > 1e-10

26db23f57ee2cf9c420d9e5404d2b60d7671991a

py

Python

venv/lib64/python3.8/site-packages/tld/registry.py

nrfkhira/dnx-engine

99a326d83058bcfe54a0f455672d90637fe753c6

venv/lib64/python3.8/site-packages/tld/registry.py

nrfkhira/dnx-engine

99a326d83058bcfe54a0f455672d90637fe753c6

venv/lib64/python3.8/site-packages/tld/registry.py

nrfkhira/dnx-engine

99a326d83058bcfe54a0f455672d90637fe753c6

import warnings from .base import Registry __author__ = "Artur Barseghyan" __copyright__ = "2013-2021 Artur Barseghyan" __license__ = "MPL-1.1 OR GPL-2.0-only OR LGPL-2.1-or-later" __all__ = ("Registry",) warnings.warn( "The `Registry` class is moved from `tld.registry` to `tld.base`.", DeprecationWarning, )

26dc6cf0e3afad0c2ebf41ec4b792f1e330897c5

py

Python

hvo_api/model/gps.py

wtollett-usgs/hvo_api

cdd39cb74d28a931cac4b843a71c5d8435f4620c

hvo_api/model/gps.py

wtollett-usgs/hvo_api

cdd39cb74d28a931cac4b843a71c5d8435f4620c

hvo_api/model/gps.py

wtollett-usgs/hvo_api

cdd39cb74d28a931cac4b843a71c5d8435f4620c

# -*- coding: utf-8 -*- from valverest.database import db7 as db from sqlalchemy.ext.hybrid import hybrid_property class Solution(db.Model): __tablename__ = 'solutions' __bind_key__ = 'gps' sid = db.Column(db.Integer, primary_key=True) cid = db.Column(db.Integer, primary_key=True) x = db.Column(db.Float) y = db.Column(db.Float) z = db.Column(db.Float) sxx = db.Column(db.Float) syy = db.Column(db.Float) szz = db.Column(db.Float) sxy = db.Column(db.Float) sxz = db.Column(db.Float) syz = db.Column(db.Float) # Relationships source = db.relationship('GPSSource', uselist=False) channel = db.relationship('GPSChannel', uselist=False) class GPSSource(db.Model): __tablename__ = 'sources' __bind_key__ = 'gps' sid = db.Column(db.Integer, db.ForeignKey('solutions.sid'), primary_key=True) name = db.Column(db.String(255)) hash = db.Column(db.String(32)) date0 = db.Column('j2ksec0', db.Float, primary_key=True) date1 = db.Column('j2ksec1', db.Float, primary_key=True) rid = db.Column(db.Integer) # Relationships rank = db.relationship('GPSRank', uselist=False) @hybrid_property def avgdate(self): return (self.date0 + self.date1) / 2 class GPSChannel(db.Model): __tablename__ = 'channels' __bind_key__ = 'gps' cid = db.Column(db.Integer, db.ForeignKey('solutions.cid'), primary_key=True) code = db.Column(db.String(16)) name = db.Column(db.String(255)) lon = db.Column(db.Float) lat = db.Column(db.Float) height = db.Column(db.Float) ctid = db.Column(db.Integer) class GPSRank(db.Model): __tablename__ = 'ranks' __bind_key__ = 'gps' rid = db.Column(db.Integer, db.ForeignKey('sources.rid'), primary_key=True) name = db.Column(db.String(24)) rank = db.Column(db.Integer) class GPSDataPoint(object): def __init__(self, t, r, x, y, z, sxx, syy, szz, sxy, sxz, syz, nlen): self._t = t self._r = r self._x = x self._y = y self._z = z self._sxx = sxx self._syy = syy self._szz = szz self._sxy = sxy self._sxz = sxz self._syz = syz self._nlen = nlen @property def t(self): return self._t @property def r(self): return self._r @property def x(self): return self._x @property def y(self): return self._y @property def z(self): return self._z @property def sxx(self): return self._sxx @property def syy(self): return self._syy @property def szz(self): return self._szz @property def sxy(self): return self._sxy @property def sxz(self): return self._sxz @property def syz(self): return self._syz @property def nlen(self): return self._nlen

26ddb52d2be72d7d4dbeca2609c7ac5ce525625e

py

Python

SingleIRdetection/get_data.py

biqute/QTLab2122

4d53d4c660bb5931615d8652e698f6d689a4dead

2021-11-30T18:41:11.000Z

2021-12-12T12:27:14.000Z

SingleIRdetection/get_data.py

biqute/QTLab2122

4d53d4c660bb5931615d8652e698f6d689a4dead

SingleIRdetection/get_data.py

biqute/QTLab2122

4d53d4c660bb5931615d8652e698f6d689a4dead

from instruments import VNA_handler, Fridge_handler import os import time from datetime import date, datetime today = date.today() d1 = today.strftime("_%d_%m") directory = "data"+d1 dir_path=os.path.join(os.path.dirname(os.path.abspath(__file__)),directory) if not os.path.isdir(dir_path): try: os.mkdir(directory) except: pass VNA_lab=VNA_handler() Fridge=Fridge_handler() temps=[] freqs1=[] freqs2=[] r = Fridge.execute("C3") file_log = open(directory + "\\log.txt", "w") def log_sensori(): file_log.write(f"\n{datetime.now():%H:%M:%S}") for i in range(0, 36): file_log.write(f"\n\tsens({i}): {Fridge.get_T(i)}") with open('temperatures_gap.txt', encoding='utf-8') as file: for line in file: line = line.replace('\n', '') temps.append(int(line)) with open('frequency_ranges_gap_1.txt', encoding='utf-8') as file: for line in file: line = line.replace('\n', '') splitted = [float(x) for x in line.split('\t')] freqs1.append(splitted) with open('frequency_ranges_gap_2.txt', encoding='utf-8') as file: for line in file: line = line.replace('\n', '') splitted = [float(x) for x in line.split('\t')] freqs2.append(splitted) for T in temps: try: print("Set temp: " + str(T)) print(f"{datetime.now():%H:%M:%S}\tsens_1:{Fridge.get_T(1)}\tsens_2:{Fridge.get_T(2)}\tsens_3:{Fridge.get_T(3)}\tG1: {Fridge.get_T(14)}\tG2: {Fridge.get_T(15)}") log_sensori() time.sleep(10) Fridge.wait_for_T(T) if T >= 200: freqs = freqs2 else: freqs = freqs1 for idx,f in enumerate(freqs): file_name=str(T)+'mK_range'+str(idx+1)+'.txt' print("Set freqs: " + str(f[0]) + " - "+ str(f[1])) VNA_lab.set_sweep_freq(f[0],f[1]) VNA_lab.inst.write('AVERREST;') time.sleep(40) VNA_lab.save_sweep_data(directory + '\\' + file_name, 'polar') except: pass log_sensori() Fridge.set_T(0) log_sensori() file_log.close()

26ddc48f78a12f6195556b4fffb431166aa3a248

py

Python

repos.py

gigamonkey/git-utils

ac26ccab836b276fb7061167b4b2dc2a6bd87e66

repos.py

gigamonkey/git-utils

ac26ccab836b276fb7061167b4b2dc2a6bd87e66

2021-05-04T19:45:16.000Z

2021-05-04T19:45:16.000Z

repos.py

gigamonkey/git-utils

ac26ccab836b276fb7061167b4b2dc2a6bd87e66

#!/usr/bin/env python3 """ Get a json dump of all the repos belonging to a GitHub org or user. """ import json import os import sys from functools import reduce import requests url = "https://api.github.com/graphql" token = os.environ["GITHUB_TOKEN"] headers = {"Authorization": "bearer {}".format(token)} FIELDS = [ "name", "description", "sshUrl", "isArchived", "isFork", "isPrivate", "pushedAt", ] def query(who, after): args = f'first:100, after:"{after}"' if after else "first:100" fields = " ".join(FIELDS) return f'query {{ organization(login: "{who}") {{ repositories({args}) {{ edges {{ cursor node {{{fields} defaultBranchRef {{ name }} }} }} }} }} }}' def maybe_get(top, *path): return reduce(lambda d, k: None if d is None else d.get(k), path, top) def node(edge): n = edge["node"] return { **{f: n.get(f) for f in FIELDS}, "defaultBranch": maybe_get(n, "defaultBranchRef", "name"), } if __name__ == "__main__": who = sys.argv[1] edges = True after = None while edges: r = requests.post(url, json={"query": query(who, after)}, headers=headers) edges = json.loads(r.text)["data"]["organization"]["repositories"]["edges"] for e in edges: print(json.dumps(node(e))) after = edges[-1]["cursor"]

26de76c7a526dbcb257d0562f65b8f5f56302812

py

Python

tfLego/logger/BasicLogger.py

FrancescoSaverioZuppichini/tfLego

485653eff6d3b8c6677b600a4e0d3623c844749f

tfLego/logger/BasicLogger.py

FrancescoSaverioZuppichini/tfLego

485653eff6d3b8c6677b600a4e0d3623c844749f

tfLego/logger/BasicLogger.py

FrancescoSaverioZuppichini/tfLego

485653eff6d3b8c6677b600a4e0d3623c844749f

class BasicLogger: def __init__(self): self.loss_history = [] self.accuracy_history = [] self.val_loss_history = [] self.val_accuracy_history = [] self.initialise() def initialise(self): self.total_loss = 0 self.total_accuracy = 0 self.current = 0 def log_batch(self, loss, outputs, accuracy, *args, **kwargs): self.current += 1 self.total_loss += loss self.total_accuracy += accuracy def log_epoch(self, i, X, is_val=False, *args, **kwargs): loss = self.total_loss / len(X) accuracy = self.total_accuracy / len(X) if(is_val): self.val_loss_history.append(loss) self.val_accuracy_history.append(accuracy) else: self.loss_history.append(loss) self.accuracy_history.append(accuracy) print('EPOCH: {0}. AVG Loss: {1:0.4f} Acc: {2:0.4f}'.format(i,loss, accuracy)) self.initialise()

26def15c65ab2e4480b9091dca33bf04179a4722

py

Python

test_package/conanfile.py

sintef-ocean/conan-casadi

70a14829ca3b3ec4cdff8b254e3c060b345c1e79

test_package/conanfile.py

sintef-ocean/conan-casadi

70a14829ca3b3ec4cdff8b254e3c060b345c1e79

test_package/conanfile.py

sintef-ocean/conan-casadi

70a14829ca3b3ec4cdff8b254e3c060b345c1e79

from conans import ConanFile, CMake, tools, RunEnvironment class CasadiTestConan(ConanFile): settings = "os", "compiler", "build_type", "arch" generators = ("cmake_paths", "cmake", "virtualrunenv", "virtualenv") _cmake = None def _configure_cmake(self): if self._cmake is None: self._cmake = CMake(self) cmake = self._cmake # TODO: non-free interfaces # ampl, cplex, gurobi, knitro, ooqp, snopt, sqic, worhp # TODO: swig_json, swig_matlab, swig_octave, clang_jit # TODO: opencl, hpmpc, blasfeo, dsdp(?) # LinSol cmake.definitions["CASADI_CONAN_CSPARSE"] = self.options["casadi"].csparse cmake.definitions["CASADI_CONAN_LAPACK"] = self.options["casadi"].lapack cmake.definitions["CASADI_CONAN_MUMPS"] = self.options["casadi"].mumps cmake.definitions["CASADI_CONAN_HSL"] = self.options["casadi"].hsl # Conic cmake.definitions["CASADI_CONAN_HPMPC"] = self.options["casadi"].hpmpc cmake.definitions["CASADI_CONAN_OSQP"] = self.options["casadi"].osqp cmake.definitions["CASADI_CONAN_QPOASES"] = self.options["casadi"].qpoases cmake.definitions["CASADI_CONAN_SUPERSCS"] = self.options["casadi"].superscs # NLP cmake.definitions["CASADI_CONAN_BLOCKSQP"] = self.options["casadi"].blocksqp cmake.definitions["CASADI_CONAN_IPOPT"] = self.options["casadi"].ipopt # Integration cmake.definitions["CASADI_CONAN_SUNDIALS"] = self.options["casadi"].sundials # Other cmake.definitions["CASADI_CONAN_SLICOT"] = self.options["casadi"].slicot cmake.definitions["CASADI_CONAN_BLASFEO"] = self.options["casadi"].blasfeo cmake.definitions["CASADI_CONAN_BONMIN"] = self.options["casadi"].bonmin cmake.definitions["CASADI_CONAN_CBC"] = self.options["casadi"].cbc cmake.definitions["CASADI_CONAN_CLP"] = self.options["casadi"].clp cmake.definitions["CASADI_CONAN_DSDP"] = self.options["casadi"].dsdp cmake.definitions["CASADI_CONAN_TINYXML"] = self.options["casadi"].tinyxml self._cmake.configure() return self._cmake def build(self): if not tools.cross_building(self.settings): cmake = self._configure_cmake() cmake.build() def test(self): if tools.cross_building(self.settings): print("NOT RUN (cross-building)") return # swig_python if self.options["casadi"].swig_python: self.output.info("Try to load 'casadi' python module") try: import casadi A = casadi.SX.eye(2) if casadi.trace(A) == 2: self.output.info("Completed conanized casadi climax") except ModuleNotFoundError: try: import numpy except ModuleNotFoundError: self.output.error("Casadi requires 'numpy', but it was not found") self.output.error("Unable to proplerly load python casadi module") self.output.info("Run consumer tests for library interfaces") cmake = self._configure_cmake() if self.options["casadi"].hpmpc: self.output.warn("HPMPC plugin interface is not tested") if self.options["casadi"].dsdp: self.output.warn("DSDP interface is not tested(?)") env_build = RunEnvironment(self) with tools.environment_append(env_build.vars): cmake.test() self.output.info("Casadi OK!")

26e0374db2378f11fc9bfc31927fa2a8ccdcf58c

py

Python

src/blog/templatetags/timediffer.py

codewithrakib/first-django-blog

339f5833025b0758f391c7c8e0979ca2eefd1b52

src/blog/templatetags/timediffer.py

codewithrakib/first-django-blog

339f5833025b0758f391c7c8e0979ca2eefd1b52

2021-03-19T02:00:00.000Z

2022-02-10T10:26:38.000Z

src/blog/templatetags/timediffer.py

codewithrakib/first-django-blog

339f5833025b0758f391c7c8e0979ca2eefd1b52

from django import template from datetime import datetime from datetime import date from datetime import time from datetime import timedelta register = template.Library() @register.filter def timediffer(now, posttime): posttime = posttime.replace(tzinfo=None) timedif= now -posttime timestr="" if timedif.days >= 365: gettime = (int)(timedif.days/365) if gettime==1: timestr = f"about {gettime} year ago" else: timestr = f"about {gettime} years ago" elif timedif.days >= 30 and timedif.days < 365: gettime = (int)(timedif.days/30) if gettime==1: timestr= f"about {gettime} month ago" else: timestr= f"about {gettime} months ago" elif timedif.days>=7 and timedif.days < 30: gettime = (int)(timedif.days/7) if gettime==1: timestr=f"about {gettime} week ago" else: timestr=f"about {gettime} weeks ago" elif timedif.days>=1 and timedif.days < 7: gettime = (int)(timedif.days) if gettime==1: timestr=f"about {gettime} day ago" else: timestr=f"about {gettime} days ago" elif timedif.seconds>=3600 and timedif.days < 1: gettime = (int)(timedif.seconds/3600) if gettime==1: timestr=f"about {gettime} hour ago" else: timestr=f"about {gettime} hours ago" elif timedif.seconds>=60 and timedif.seconds < 3600: gettime = (int)(timedif.seconds/60) if gettime==1: timestr = f"about {gettime} minute ago" else: timestr = f"about {gettime} minutes ago" elif timedif.seconds>=1 and timedif.seconds < 60: gettime = (int)(timedif.seconds) if gettime==1: timestr = f"about {gettime} second ago" else: timestr = f"about {gettime} seconds ago" else: timestr='now' return timestr

26e08af32bb2b5d0bbed9fd354924f064bde0ecf

py

Python

ma.py

AmandaKhol/DLT-Blockchain

ee464b0d7b55bffe791eb0b814513620430bfa1c

2021-04-05T18:59:04.000Z

2021-04-05T18:59:04.000Z

ma.py

AmandaKhol/DLT-Blockchain

ee464b0d7b55bffe791eb0b814513620430bfa1c

ma.py

AmandaKhol/DLT-Blockchain

ee464b0d7b55bffe791eb0b814513620430bfa1c

""" title : ma.py description : Marshmallow object author : Amanda Garcia-Garcia version : 0 usage : python server_api.py python_version : 3.6.1 """ from flask_marshmallow import Marshmallow ma = Marshmallow()

26e3cb56bf5c43ffe1ebc53ce33bf565445ae974

py

Python

FGMabiotic.py

tjscott214/long-term-conflict-with-1nFGM

1c701e83c71ebe21fbc1192ca3d523a000614819

2019-09-13T13:46:33.000Z

2020-05-14T17:21:09.000Z

FGMabiotic.py

tjscott214/long-term-conflict-with-1nFGM

1c701e83c71ebe21fbc1192ca3d523a000614819

FGMabiotic.py

tjscott214/long-term-conflict-with-1nFGM

1c701e83c71ebe21fbc1192ca3d523a000614819

#!/usr/bin/env python ### This program simulates Fisher's geometric model with abiotic change equal to fixations during conflict simulations (from FGMconflict.py) ### ### python3 FGMabiotic.py -help for input options ### ### Written by Trey J Scott 2018 ### ### python --version ### ### Python 3.5.2 :: Anaconda 4.2.0 (x86_64) ### # Import programs import random import numpy as np from scipy.spatial import distance as dist from scipy.stats import norm import scipy.stats as stats import matplotlib.pyplot as plt import pandas as pd import argparse import scipy.special as spc from itertools import groupby ### FUNCTIONS ### # Function to generate random mutations with a specified average size def generate_random_vector(): if distribution == 'uniform': radial = np.random.uniform(0,uni) if distribution == 'chi': radial = np.random.chisquare(n) if distribution == 'exponential': radial = np.random.exponential(expo) if distribution == 'normal': radial = abs(np.random.normal(0, sd_1d)) vector = np.array(radial * (-1)**random.randint(1,2)) return radial, vector # Gaussian fitness function def fitness_function(distance,d): return np.exp(-(d*(distance**Q))) # Calculates probability of fixation for new mutations def calculate_u(new_distance, old_distance, N = 'infinite', denominator = 0.5): fitness_new = fitness_function(new_distance, denominator) fitness_old = fitness_function(old_distance, denominator) s_coefficient = (fitness_new/fitness_old) - 1 if N == 'infinite': probability_of_fixation = (1 - np.exp(-2*s_coefficient)) elif N > 0: probability_of_fixation = ((1 - np.exp(-2*s_coefficient))/(1 - np.exp(-4*s_coefficient*N))) return probability_of_fixation, s_coefficient # Functon that simulates adaptation to a moving optimum with Fisher's geometric model def abiotic_change(position, optimum, mut_list, samp): counter = 0 distance_to_optimum = dist.euclidean(position, optimum) moving_optimum = optimum for d in range(0,len(mut_list)): moving_optimum = moving_optimum + (mut_list[d])*((-1)**(random.randint(1,2))) distance_to_optimum = dist.euclidean(position, moving_optimum) mutation_size, vector = generate_random_vector() future_position = position + vector new_dist_to_optimum = dist.euclidean(future_position, moving_optimum) u, s = calculate_u(new_dist_to_optimum, distance_to_optimum, N_1,d1) if random.random() <= u: mutation_fitness = vector position = future_position distance_to_optimum = dist.euclidean(position, moving_optimum) if counter >= burn_in: output.write(str(d) + ',' + str(samp) + ',' + str(position[0]) + ',' + str(s) + ',' + str(mutation_size) + ',' + str(fitness_function(distance_to_optimum,d1)) + ',Abiotic Change,Fixed\n') else: if counter >= burn_in: output.write(str(d) + ',' + str(samp) + ',' + str(position[0]) + ',' + str(s) + ',' + str(mutation_size)+ ',' + str(fitness_function(distance_to_optimum,d1)) + ',Abiotic Change,Unfixed\n') counter += 1 # Runs simulations multiple times def run_simulations(position, num_samples): df = pd.read_csv(shake_file) optimum = np.array([(-(1/d1)*np.log(r))**(1/Q)]) master_mut_list = df.groupby('Population')['Mutation'].apply(list)[1] index = 0 for sample in range(num_samples): mut_list = master_mut_list[index:index + m] abiotic_change(position, optimum, mut_list, sample) index += m output.close() ### SET ARGUMENTS ap = argparse.ArgumentParser() ap.add_argument('-x', '--samples', help = 'number of resamples', type = int) ap.add_argument('-p', '--population_size1', help = 'population size for one population', type = int) ap.add_argument('-pp', '--population_size2', help = 'population size for second population', type = int) ap.add_argument('-m', '--mutations', help = 'mutation distribution for mutation vectors') ap.add_argument('-q', '--Q', help = 'changes Q parameter in fitness function', type = float) ap.add_argument('-z', '--attempts', help = 'number of generations per walk', type = int) ap.add_argument('-c', '--init_fit', help = 'changes the distance optimal values by a factor of the input value', type = float) ap.add_argument('-r', '--rate', help = 'mutation rate for population 1', type = int) ap.add_argument('-b', '--burn_in', help = 'define burn in period for equilibrium', type = int) ap.add_argument('-a', '--ave_mut', help = 'average mutation norm', type = float) ap.add_argument('-d', '--selection', help = 'Adjust strength of selection', type = float) ap.add_argument('-mut', '--changes', help = 'mutation file for moving optimum', type = str) args = ap.parse_args() # get arguments if args.samples: samples = args.samples else: samples = 500 # Define initial position and optima position1 = np.zeros(1) position = position1 position2 = position1 if args.init_fit: r = 1-args.init_fit else: r = 1-0.2 # Set average norm size for mutations if args.ave_mut: average_mutation = args.ave_mut else: average_mutation = 0.1 # Get population sizes # Population 1 if args.population_size1: N_1 = 10**(args.population_size1) else: N_1 = 'infinite' # Population 2 if args.population_size2: N_2 = 10**(args.population_size2) else: N_2 = 'infinite' # Get distributions # Mutation distribution (default is uniform) if args.mutations: distribution = args.mutations else: distribution = 'normal' # Number of mutations if args.attempts: m = args.attempts else: m = 50000 # Get mutation rate if args.rate: rate = args.rate else: rate = 1 # Calculate normalization factor (used in mutation function) sd_1d = average_mutation*((np.pi)**(1/2))/(2**(1/2)) uni = 2*average_mutation expo = average_mutation if args.burn_in: burn_in = args.burn_in else: burn_in = 0 if args.Q: Q = args.Q q_string = 'Q_' + str(Q) + '_' else: Q = 2 q_string = '' if args.selection: d1 = args.selection else: d1 = 0.5 if args.changes: shake_file = args.changes[:-7] + 'mut.csv' # Open output file output = open('abiotic_data.csv', 'w') output.write('Iteration,Simulation,z,s,Mutation Size,Fitness,Population,Status\n') ### Run simulations run_simulations(position, samples)

26e5678c410804c82e1a66c1a1c30cc2e8b118d5

py

Python

epdif.py

cvasqxz/rpi-epd

b7921190dd84b1187364902f0e3059cba5a1973f

epdif.py

cvasqxz/rpi-epd

b7921190dd84b1187364902f0e3059cba5a1973f

epdif.py

cvasqxz/rpi-epd

b7921190dd84b1187364902f0e3059cba5a1973f

import spidev import RPi.GPIO as GPIO import time import yaml with open("config.yml", 'r') as f: cfg = yaml.load(f, Loader=yaml.FullLoader) # Pin definition RST_PIN = cfg['pinout']['RST_PIN'] DC_PIN = cfg['pinout']['DC_PIN'] CS_PIN = cfg['pinout']['CS_PIN'] BUSY_PIN = cfg['pinout']['BUSY_PIN'] # SPI device, bus = 0, device = 0 SPI = spidev.SpiDev(0, 0) def epd_digital_write(pin, value): GPIO.output(pin, value) def epd_digital_read(pin): return GPIO.input(BUSY_PIN) def epd_delay_ms(delaytime): time.sleep(delaytime / 1000.0) def spi_transfer(data): SPI.writebytes(data) def epd_init(): GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) GPIO.setup(RST_PIN, GPIO.OUT) GPIO.setup(DC_PIN, GPIO.OUT) GPIO.setup(CS_PIN, GPIO.OUT) GPIO.setup(BUSY_PIN, GPIO.IN) SPI.max_speed_hz = 2000000 SPI.mode = 0b00 return 0;

26e616bae86ed51b35013c799f67005f184552f2

py

Python

main.py

amankumarjsr/BinanceDataScrapper

e3d56c4bd274a8e472de1fbe1c9603c9e94e1d14

main.py

amankumarjsr/BinanceDataScrapper

e3d56c4bd274a8e472de1fbe1c9603c9e94e1d14

main.py

amankumarjsr/BinanceDataScrapper

e3d56c4bd274a8e472de1fbe1c9603c9e94e1d14

from datetime import date from unicodedata import name from urllib import request import requests from bs4 import BeautifulSoup as bs import pandas as pd import datetime import os import zipfile import glob CoinName= input('Enter the coin name: ').upper() duration= input('Enter the duration of data you want(1m,1h,2h): ').lower() start_date= input ('Enter the date (dd-mm-yyyy): ') end_date= input('Enter the end date (dd-mm-yyyy): ') coin= requests.get('https://data.binance.vision/?prefix=data/spot/daily/klines/') ucoin= bs(coin.content , 'html.parser') start = datetime.datetime.strptime(start_date, "%d-%m-%Y") end = datetime.datetime.strptime(end_date, "%d-%m-%Y") date_generated = [start + datetime.timedelta(days=x) for x in range(0, (end-start).days)] date_list=[] for date in date_generated: x=date.strftime("%Y-%m-%d") date_list.append(x) file_name_list= [] cols=['opening time', 'opening price','highest price','lowest price','closing price','volume','closing time','turnover','number of transactions','active buy volume','NA','NAN'] for item in date_list: try: file_name=(f'{CoinName}-{duration}-{item}.zip') download_mainurl= (f'https://data.binance.vision/data/spot/daily/klines/{CoinName}/{duration}/{CoinName}-{duration}-{item}.zip') download= requests.get(download_mainurl, allow_redirects= True) print(f'Scrapping data of {item} ') with open(file_name, 'wb') as f: f.write(download.content) with zipfile.ZipFile(file_name, 'r') as zip_ref: zip_ref.extractall('C:/Users/rocka/Desktop/Practice python/Binance data scrapper/data') file_name_list.append(file_name+'.csv') os.remove(file_name) except: print('skipped') continue master_df= pd.DataFrame() for file in os.listdir('C:/Users/rocka/Desktop/Practice python/Binance data scrapper/data'): if file.endswith('.csv'): master_df= master_df.append(pd.read_csv('C:/Users/rocka/Desktop/Practice python/Binance data scrapper/data/'+file, names= cols)) master_df.to_csv(f'{CoinName}-{duration}-master file.csv', index=False) for file in os.listdir('C:/Users/rocka/Desktop/Practice python/Binance data scrapper/data'): if file.endswith('.csv'): os.remove('C:/Users/rocka/Desktop/Practice python/Binance data scrapper/data/'+file) print('Data Scrapped sucessfully!!!')

26e61f306df9220c42f34738c067514777287317

py

Python

api/api.py

geoai-lab/GeoAnnotator

6d5ee22888571f5ffefdb1d2f2455eaa9e5054f3

2022-02-14T20:43:41.000Z

2022-02-14T20:43:41.000Z

api/api.py

geoai-lab/GeoAnnotator

6d5ee22888571f5ffefdb1d2f2455eaa9e5054f3

api/api.py

geoai-lab/GeoAnnotator

6d5ee22888571f5ffefdb1d2f2455eaa9e5054f3

from flask import Flask, jsonify, request, session,redirect, url_for import bcrypt from flask_sqlalchemy import SQLAlchemy from sqlalchemy.sql import func from sqlalchemy.exc import IntegrityError import os from sqlalchemy.orm import load_only from flask_bcrypt import Bcrypt import urllib.parse from itertools import groupby from operator import attrgetter import json from flask_cors import CORS, cross_origin from flask_session import Session import redis from werkzeug.utils import secure_filename from datetime import datetime, timedelta, timezone from models import db, tweet_database, User, LoginForm, Project, Submission, CompareSubmission from dotenv import load_dotenv from flask_login import LoginManager, login_required, login_user, current_user, logout_user from sqlalchemy.orm import sessionmaker import pandas as pd import requests from sqlalchemy.types import String, DateTime import io load_dotenv() app = Flask(__name__,static_folder="../build", static_url_path='/')# app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///HarveyTwitter.db" app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True app.config["SECRET_KEY"] = "6236413AA53537DE57D1F6931653B" app.config['SQLALCHEMY_ECHO'] = True app.config['SESSION_TYPE'] = "filesystem" # causes bugs right here this needs to be in redis soon need to download reddis and do some reddis cli stuff app.config['SESSION_USE_SIGNER'] = True #app.config['SESSION_COOKIE_NAME'] #app.config['SESSION_COOKIE_DOMAIN] #app.config['SESSIO N_COOKies] #app.config['SESSION_COOKIE_SECURE'] = True # add this to make the cookies invisible or something bcrypt = Bcrypt(app) # this is encyrpt the app CORS(app, supports_credentials=True) server_session = Session(app) db.__init__(app) with app.app_context(): db.create_all() login_manager = LoginManager() login_manager.init_app(app) with app.app_context(): # before intialization of the app, commands under here are ran first # Replace with the commented when running the command gunicorn3 -w 3 GeoAnnotator.api:app optionsData = jsonify(json.load(open('../../createProjectOptions.json'))) # 'GeoAnnotator/api/createProjectOptions.json' configurationsData = json.load(open('../../configuration_data.json')) # 'GeoAnnotator/api/configuration_data.json' @login_manager.user_loader def load_user(user_id): """ Loads current user data --- """ return User.query.filter_by(id=user_id).first() @app.route('/') def index(): """ Initialization of flask object --- return: returns an index.html object built by react's build file. """ return app.send_static_file("index.html") @app.route("/@me", methods = ["GET"]) # might need to change def get_current_user(): """ User session data is retrieved through this callback. --- GET: description: Get session data security: - Session Token responses: 200: content: User/json """ if not session["project_name"]: return jsonify({"error": "did not select project"}), 401 if not current_user.is_authenticated: return jsonify({"error": "Unauthorized"}), 401 return jsonify({ "id": str(current_user.id), "email": current_user.email, "username": current_user.username, "projectName":session["project_name"] }),200 @app.route("/login", methods=["POST"]) def login(): """ Function that handles login of user --- POST: description: Add new user in the session responses: 200: description: Successfuly log in user onto the session. 401: description: User entered wrong username/password that does not match any data on the database. """ loginform = LoginForm() email = request.json["email"] password = request.json["password"] project_name = request.json["project"] session["project_name"] = project_name user = User.query.filter_by(email=loginform.email.data).first() if user is None: return jsonify({"error": "Wrong Email/Password"}), 401 if not bcrypt.check_password_hash(user.password, loginform.password.data): return jsonify({"error": "Wrong Email/Password"}), 401 login_user(user) return jsonify({ "id": str(user.id), "email": user.email }),200 @app.route("/logout", methods=["POST"]) @login_required def logout(): """ Function that handles logout of user --- POST: description: remove curent user in the session responses: 200: description: Successfuly log out user from the session. """ logout_user() # flask logout library return redirect("/", code=200) # successful log out will redirect to the homepage @app.route("/createprojects", methods=["GET"]) @login_required def create(): """ Function that returns state geojson at the create projects page. --- GET: data: optionsData => responses: 200: description: Successfuly log out user from the session. """ return optionsData, 200 @app.route("/project+descriptions", methods=["GET"]) def project_descriptions(): """ Function that returns data from the project database that are not deleted by the user. --- GET: responses: 200: data: {"project-name": <Project.project_name>, "geo_json":<Project.geo_json>} """ projects = Project.query.filter_by(isDeleted = 0).all() print(projects) list_of_projects = [] for project in projects: list_of_projects.append({"project-name": project.project_name, "geo_json": project.geo_json}) return jsonify(list_of_projects), 200 @app.route("/createproject-submit", methods=["POST"]) @login_required def createproject_submission(): """ Creation of a new project --- POST: description: adds a new project item onto the Projects table of the database responses: 200: description: new project added 409: description: * if the project name given already exists within the database """ projectName = request.json["Project Name"] mapLayers = request.json["map-layers"] project_exists = Project.query.filter_by(project_name = projectName).first() is not None if(project_exists): return jsonify({"error": "project already exists"}), 409 session['project_name'] = projectName new_project = Project(project_name = projectName, geo_json = mapLayers, isDeleted = 0 ) db.session.add(new_project) db.session.commit() return jsonify({"success": "project created"}), 200 @app.route("/register", methods=["POST"]) def register_user(): """ By registering a new user in the database, you may add new user data to the database. --- POST: description: Add new user in the database responses: 200: description: new username and password are added onto the database. 409: description: * if the username used to register already exists in the database * if the password entered and the password retyped do not match """ email = request.json["email"] password = request.json["password"] retype = request.json["retypepassword"] username = request.json["username"] user_exists = User.query.filter_by(email=email).first() is not None if user_exists: return jsonify({"error": "User already exists"}), 409 elif password != retype: return jsonify({"error":"password do not match"}), 409 hashed_password = bcrypt.generate_password_hash(password) new_user = User(email=email, username=username ,password=hashed_password) db.session.add(new_user) db.session.commit() return jsonify({ "id": str(new_user.id), "email": new_user.email }), 200 @app.route('/comparison', methods =['GET']) @login_required def compare_data(): """ Obtain information for the comparative page. When the user who is the resolver requests data to compare, this method must deliver data that the resolver has not resolved previously. That would be the value of the notYet_submitted variable. --- GET: responses: 200: data: list of data that the resolver can compare and resolve format: { text:<tweet_database.text>, submission_id:<Submission.submission_id>, annotation:<Submission.annotation>, username:<Submission.username>, projectGeojson:<Project.geo_json>, tweetid:<tweet_database.id>, userid:<Submission.userid> } where current_user=Submission.id values are not in current_user=CompareSubmission.id values """ project_name = session["project_name"] to_send_data = [] alreadySubmitted_ids = [idvid for subid in CompareSubmission.query.filter_by(userid = current_user.id).options(load_only(CompareSubmission.submissionid_1, CompareSubmission.submissionid_2)).all() for idvid in [subid.submissionid_1,subid.submissionid_2]] # need to change the tweet id here later on # grab submissions you haven't looked at yet notYet_submitted = Submission.query.filter_by(project_name= project_name).filter(Submission.submission_id.notin_(alreadySubmitted_ids)) \ .join(tweet_database, Submission.tweetid == tweet_database.id) \ .join(Project, Submission.project_name == project_name) \ .filter_by(project_name = project_name).add_columns(tweet_database.text, Submission.submission_id, Submission.annotation,Submission.username, Project.geo_json, tweet_database.id, Submission.userid) df = pd.DataFrame(notYet_submitted, columns = ["SubmissionObject","text","submission_id","annotation","username","geo_json","id","userid"]).astype(str) to_iterate =None # grab the first group of unique IDS # an alternate to implementing the for loop below is by doing df.grouby('id',sort=False).first() for name, group in df.groupby('id',sort=False): to_iterate = group break for index,filtered_submission in to_iterate.iterrows(): # each group is a tweet set to_send_data.append({"text": filtered_submission.text, "submission_id": str(filtered_submission.submission_id), "annotation": json.loads(filtered_submission.annotation)["annotation"], "username":filtered_submission.username, "projectGeojson": json.loads(filtered_submission.geo_json), "tweetid":str(filtered_submission.id), "userid":str(filtered_submission.userid)}) return jsonify(to_send_data), 200 @app.route('/api-grab/<tweetid>', methods=['GET']) @login_required def app_data(tweetid): """ Obtain information for the Annotation page page. When the user who is the annotator requests data to annotate, this method must deliver data that the annotatoer has not annotated previously. --- @param: tweetid: Grab the data in the database where Tweet_database.id == tweetid if this parameter exists. --- GET: responses: 200: data: data that the annotator can annotate format: { id:<tweet_database.id>, content:<tweet_data.text>, neuro_result: Model rest api data, project_description:{label:<Project.project_name>,geo_json:<Project.geo_json>} } 409: description: * If the data from the Model prediction link did not yield any results (i.g. response from the UB servers are not 200) * If there is no project in session """ submissions_exists = Submission.query.filter_by(userid = current_user.id) is not None if(submissions_exists): # if User already annotated data before, find data that the user has not annotated before and return that tweet_ids = [ids.tweetid for ids in Submission.query.filter_by(userid = current_user.id, project_name = session["project_name"]).options(load_only(Submission.tweetid)).all()] tweets = tweet_database.query.filter_by(projectName = session["project_name"]).filter(tweet_database.id.notin_(tweet_ids)).first() else: # It's the user's first time annotating, therefore pick the first tweet in the database tweets = tweet_database.query.filter_by(projectName = session["project_name"]).first() if(tweetid != 'any'): tweets = tweet_database.query.filter_by(id = str(tweetid)).first() content = tweets.text project_name = session["project_name"] if project_name: # if the session has a project, then query the project GeoJson project_json = Project.query.filter_by(project_name = project_name).first() else: # Since users must first register a project before signing in, this is extremely unlikely to occur. return jsonify({"error": "No Project on session"}), 409 urlEncoded = urllib.parse.quote(tweets.text) #encode the text content of a tweet so that it may be converted into a url format toRequestModel = "{}={}".format(configurationsData['modelLink'],urlEncoded) # Using the model url link from configuration.json, get a request using the URLencoded method. response = requests.get(toRequestModel) if response.status_code != 200: # If the model url link does not return a response of 200, send a 409 since we do not have model prediction data. # Cases of where the code fires here is when the servers at the University at Buffalo are down. return jsonify({"error": "Rest Api Model unable to grab data"}), 409 neuro_results_json = response.json()['annotation'] # data from the response toSend = {'id': str(tweets.id), 'content': content, 'neuro_result':neuro_results_json, 'project_description': {"label":project_json.project_name, "geo_json": json.loads(project_json.geo_json)}} return jsonify(toSend), 200 @app.route('/uploadfile', methods=['POST']) @login_required def uploading_textFile(): """ This method is related to the create project part, since if a user submits twitter data, it must first go via this method to be preprocessed and stored in the database. --- POST: responses: 200: description: The data from tweets has been successfully preprocessed and should now be available in the database. 401: description: * Preprocessing failed due to data format. """ try: projectName = request.form['projectName'] #The name of the project on which the user wishes to upload new tweets project_exists = Project.query.filter_by(project_name = projectName).first() is not None if project_exists: # if the project name already exists, then tell the user return jsonify({"error":"Project Name Already Exists"}), 401 file = request.files['file'] df = pd.read_json(file.stream.read().decode("UTF8"), lines=True, encoding="utf8")[['text','id','created_at']] df['projectName'] = projectName dtype={"text": String(),"id":String(), "created_at":DateTime(), "projectName":String()} rowsAffected = df.to_sql(name = 'TwitterDataSet',con = db.engine, index = False, if_exists='append',dtype=dtype) # upload onto the database except Exception as e: #If the entire procedure above fails, publish the line number where the error occurred. print( type(e).__name__, # TypeError __file__, # /tmp/example.py e.__traceback__.tb_lineno # 2 ) return jsonify({"error": "File Upload Fail"}), 401 return jsonify({"success": "Upload Complete"}), 200 @app.route('/deleteproject', methods=['POST']) @login_required def deleting_projects(): """ This approach replaces the value on the isDeleted part of the Project column by one. If we replace the column value with 1, we will not display the user this project since they requested that it be removed. --- POST: responses: 200: description: Project data has successfuly been deleted/hidden fromn the user's view """ projects = request.json['projects'] # contains a list of projects that the user desires to get deleted queried_projects = Project.query.filter(Project.project_name.in_(projects)) for query in queried_projects: # we replace the value with 1 query.isDeleted = 1 db.session.commit() return jsonify({"success": "Upload Complete"}), 200 @app.route('/api/submit', methods=['POST']) @login_required def submission(): """ This method handles the event when a user submits an annotation. --- POST: responses: 200: description: adds a new row value in the Submission table on the HarveyTwitter.db """ json_object = request.json tweetid =json_object["tweetid"] project = session["project_name"] highlight = json_object["highlight"] spatial_footprint = json_object["spatial-footprint"] timestamp = json_object["timestamp"] category = json_object["category"] annotation = json.dumps({"annotation": { "highlight": highlight , "spatial-footprint": spatial_footprint, "category": category }}) new_submission = Submission(userid = current_user.id, tweetid = tweetid, project_name = project, timestamp = timestamp, annotation = annotation, username = current_user.username) db.session.add(new_submission) db.session.commit() return jsonify("Success"), 200 @app.route('/compare/submit', methods=['POST']) @login_required def compare_submission(): """ When a resolver submits a resolution from the compare submissions page, this method handles the event. --- POST: responses: 200: description: adds a new row value in the compare-submission table on the HarveyTwitter.db """ json_object = request.json userId1 = json_object['submission-userid-1'] userId2 = json_object['submission-userid-2'] submissionid1 = json_object['submissionid-1'] submissionid2 = json_object['submissionid-2'] choosenId = json_object['choosing-correct-submission'] CurrentUserId = current_user.id new_submission = CompareSubmission(userid = CurrentUserId, submission_userid_1 = userId1, submission_userid_2 = userId2, submissionid_1 = submissionid1, submissionid_2 = submissionid2, choosing_correct_submission = choosenId) db.session.add(new_submission) db.session.commit() return jsonify("Success"), 200 if __name__ == '__main__': app.run(host='0.0.0.0')

26e97e5ea8220154eb41374939938275b9e537b0

py

Python

AppPython/app/core/src/forms.py

denalme/AplicacionPython

eb99af3c21f003135192ad040a0a04a40b63ea70

AppPython/app/core/src/forms.py

denalme/AplicacionPython

eb99af3c21f003135192ad040a0a04a40b63ea70

AppPython/app/core/src/forms.py

denalme/AplicacionPython

eb99af3c21f003135192ad040a0a04a40b63ea70

from django import forms from .pqrsf import pqrsf class ContactForm(forms.Form): #Atributos del formulario de contacto usuario = forms.CharField(label="Nombre", required=True, widget=forms.TextInput(attrs={'class':'formulario input', 'placeholder':'Nombre'})) correo = forms.EmailField(label="Correo Electrónico", required=True,widget=forms.EmailInput(attrs={'class':'formulario input','placeholder':'Correo Electrónico'})) tipomsj = forms.ChoiceField(label="Asunto", required=True, choices=pqrsf, widget=forms.Select(attrs={'class':'formulario input'})) mensaje = forms.CharField(label="Mensaje", required=True, widget=forms.Textarea(attrs={'class':'formulario input', 'rows':'5','placeholder':'Escribe tu Mensaje'}))

26ec29318bc12813be99da269d94707649d0104c

py

Python

prisma/generated/models.py

mao-shonen/prisma-client-py-tortoise-orm

e26d8451ea0775bd7ddfec42f663510434537a77

prisma/generated/models.py

mao-shonen/prisma-client-py-tortoise-orm

e26d8451ea0775bd7ddfec42f663510434537a77

prisma/generated/models.py

mao-shonen/prisma-client-py-tortoise-orm

e26d8451ea0775bd7ddfec42f663510434537a77

__doc__ = ''' This file is generated by the `prisma-client-py-tortoise-orm (0.2.2)`, Please do not modify directly. repository: https://github.com/mao-shonen/prisma-client-py-tortoise-orm ''' import typing from enum import Enum from tortoise import fields from tortoise.models import Model from prisma import base as base class Role(str, Enum): ''' - USER - ADMIN ''' USER = 'USER' ADMIN = 'ADMIN' class User(base.User, Model): ''' model comment fields: - 🔟 id [Int] 🔑 - default: auto_increment() - doc: field comment - 🆎 *password [String] - 🆎 *email [String] 📌 - 🔟 weight [Float?] - ✅ is18 [Boolean?] - 🆎 name [String?] - 🔟 *wallet [Decimal] - 🪢 successor [User?] - 🪢 predecessor [User?] - 🪢 role [Role] - default: Role.USER - 🪢 posts [Post] - 🪢 *biography [Json] - 🪢 group [group?] - 🕑 createdAt [DateTime] - default: now() - 🕑 *updatedAt [DateTime] ''' id = fields.IntField(pk=True, description='field comment') password = fields.CharField(max_length=255) email = fields.CharField(max_length=255, unique=True) weight = fields.FloatField(null=True) is_18 = fields.BooleanField(null=True) name = fields.CharField(max_length=255, null=True) wallet = fields.DecimalField(max_digits=12, decimal_places=2) successor: fields.OneToOneRelation[typing.Union['User', typing.Any]] = fields.OneToOneField(source_field='successorId', model_name='models.User', to_field='id', related_name='predecessor', null=True) predecessor: fields.ReverseRelation['User'] role = fields.CharEnumField(enum_type=Role, default=Role.USER) posts: fields.ReverseRelation['Post'] biography = fields.JSONField() group: fields.ForeignKeyRelation[typing.Union['Group', typing.Any]] = fields.ForeignKeyField(source_field='groupId', model_name='models.Group', to_field='id', related_name='user', null=True) created_at = fields.DatetimeField(auto_now_add=True) updated_at = fields.DatetimeField(auto_now=True) class Meta(base.User.Meta): table = 'User' def __str__(self) -> str: return f'User<{self.id}>' class Post(base.Post, Model): ''' fields: - 🔟 id [Int] 🔑 - default: auto_increment() - 🪢 user [User?] ''' id = fields.IntField(pk=True) user: fields.ForeignKeyRelation[typing.Union['User', typing.Any]] = fields.ForeignKeyField(model_name='models.User', to_field='id', related_name='posts', on_delete=fields.SET_NULL, null=True) class Meta: table = 'Post' def __str__(self) -> str: return f'Post<{self.id}>' class Group(base.Group, Model): ''' fields: - 🔟 id [Int] 🔑 - default: auto_increment() - 🆎 name [String] - default: default - ✅ public [Boolean] - default: true - 🪢 User [User] ''' id = fields.IntField(pk=True) name = fields.CharField(max_length=255, default='default') public = fields.BooleanField(default=True) user: fields.ReverseRelation['User'] class Meta: table = 'groups' def __str__(self) -> str: return f'Group<{self.id}>' __all__ = ['Role', 'User', 'Post', 'Group']

26ed69ff9590d721e4368e521015afe41d5f9df5

py

Python

samples/people_on_stairs/classify_overspeeding/classify_overspeeding.py

vgvoleg/gst-video-analytics

7e4006551f38334bc59b2ef3d205273d07d40ce4

samples/people_on_stairs/classify_overspeeding/classify_overspeeding.py

vgvoleg/gst-video-analytics

7e4006551f38334bc59b2ef3d205273d07d40ce4

samples/people_on_stairs/classify_overspeeding/classify_overspeeding.py

vgvoleg/gst-video-analytics

7e4006551f38334bc59b2ef3d205273d07d40ce4

2020-05-14T15:30:03.000Z

2020-05-14T15:30:03.000Z

from os.path import join, realpath from os import listdir, environ import shlex import subprocess import pickle import json import pickle as pkl import time import numpy as np from copy import copy MODEL_PATH = ("/root/Projects/models/intel/person-detection-retail-0013/FP32" "/person-detection-retail-0013.xml") DATASET_PATH = "/root/Projects/train/" ALPHA = 0.1 ALPHA_HW = 0.01 RES_PATH = ("/root/Projects/gst-video-analytics-0.7.0/samples/" "people_on_stairs/classify_overspeeding/res.json") SVM_PATH = '/root/Projects/models/overspeed_classify/SVM_Classifier_without_interval.sav' CLASSIFY_PIPELINE_TEMPLATE = """gst-launch-1.0 filesrc \ location={} \ ! decodebin ! videoconvert ! video/x-raw,format=BGRx ! gvadetect \ model={} ! queue \ ! gvaspeedometer alpha={} alpha-hw={} interval=0.03333333 \ ! gvapython module={} class=OverspeedClassifier arg=[\\"{}\\"] \ ! fakesink sync=false""" class OverspeedClassifier(): def __init__(self, out_path=RES_PATH): self.velocities = [] self._result_path = out_path self.frames_processed = 0 def process_frame(self, frame): for region in frame.regions(): for tensor in region.tensors(): if tensor.has_field("velocity"): self.velocities.append(tensor['velocity']) self.__updateJSON() self.frames_processed += 1 def __updateJSON(self): with open(self._result_path, "w") as write_file: json.dump(self.velocities, write_file, indent=4, sort_keys=True) def __dump_data(self): with open(self._result_path, "a") as write_file: write_file.write("{} \n".format(self.velocities)) if __name__ == "__main__": svclassifier = pickle.load(open(SVM_PATH, 'rb')) for file_name in listdir(DATASET_PATH): if file_name.endswith(".mp4"): video_path = join(DATASET_PATH, file_name) pipeline_str = CLASSIFY_PIPELINE_TEMPLATE.format( video_path, MODEL_PATH, ALPHA, ALPHA_HW, realpath(__file__), join(DATASET_PATH, file_name.replace('.mp4', '.json')) ) print(pipeline_str) proc = subprocess.run( shlex.split(pipeline_str), env=environ.copy()) if proc.returncode != 0: print("Error while running pipeline") exit(-1)

26f0496f5cee5563d72ece3864af6c3cc42f430c

py

Python

indicators/migrations/0035_make_indicators_programs_foreignkey.py

mercycorps/TolaWorkflow

59542132fafd611081adb0e8cfaa04abc5886d7a

indicators/migrations/0035_make_indicators_programs_foreignkey.py

mercycorps/TolaWorkflow

59542132fafd611081adb0e8cfaa04abc5886d7a

2020-03-31T15:46:59.000Z

2022-03-31T18:01:08.000Z

indicators/migrations/0035_make_indicators_programs_foreignkey.py

Falliatcom-sa/falliatcom

39fb926de072c296ed32d50cccfb8003ca870739

2021-01-05T01:58:24.000Z

2021-01-05T01:58:24.000Z

# -*- coding: utf-8 -*- # Generated by Django 1.11.2 on 2018-11-06 08:34 from __future__ import unicode_literals from django.db import migrations, models import django.db.models.deletion def set_temp_program_id(apps, schema_editor): Indicator = apps.get_model('indicators', 'Indicator') for indicator in Indicator.objects.all(): if indicator.program.all().count() == 0: program_id = None else: program_id = indicator.program.all().first().id indicator.program_temp = program_id indicator.save() def move_temp_program_id(apps, schema_editor): Indicator = apps.get_model('indicators', 'Indicator') for indicator in Indicator.objects.all(): indicator.program_id = indicator.program_temp indicator.save() def test_program_id_uniqueness(apps, schema_editor): Indicator = apps.get_model('indicators', 'Indicator') for indicator in Indicator.objects.all(): if indicator.program.all().count() > 1: raise Exception('Indicator {0} has more than 1 program, fix then rerun'.format(indicator.id)) class Migration(migrations.Migration): dependencies = [ ('workflow', '0020_auto_20180918_1554'), ('indicators', '0034_ipttindicator_programwithmetrics'), ] operations = [ migrations.RunPython(test_program_id_uniqueness), migrations.AddField( model_name='historicalindicator', name='program', field=models.ForeignKey( blank=True, db_constraint=False, null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='+', to='workflow.Program'), ), # first add a temp field to hold the foreign key migrations.AddField( model_name='indicator', name='program_temp', field=models.IntegerField( null=True, blank=True, help_text=b'Program Temp', verbose_name='Program Temp'), preserve_default=False, ), # put the value of the program the indicator is assigned to there migrations.RunPython(set_temp_program_id), migrations.RemoveField( model_name='indicator', name='program', ), # add the real foreign key migrations.AddField( model_name='indicator', name='program', field=models.ForeignKey( null=True, blank=True, help_text=b'Program', on_delete=django.db.models.deletion.CASCADE, to='workflow.Program', verbose_name='Program'), preserve_default=False, ), # copy the temp key over migrations.RunPython(move_temp_program_id), migrations.RemoveField( model_name='indicator', name='program_temp', ), ]

26f1b913f1ee12f1e92139c51f5d8c9e44276d06

py

Python

pymockserver/client.py

MXWest/py-mockserver

cd0783aac2e5c1b8a021c29a4c70ef5414b7f7cc

2018-06-14T19:44:05.000Z

2020-12-14T04:33:21.000Z

pymockserver/client.py

MXWest/py-mockserver

cd0783aac2e5c1b8a021c29a4c70ef5414b7f7cc

2020-02-01T16:20:18.000Z

2021-03-23T14:43:54.000Z

pymockserver/client.py

MXWest/py-mockserver

cd0783aac2e5c1b8a021c29a4c70ef5414b7f7cc

2020-02-01T16:25:50.000Z

2021-03-23T13:06:25.000Z

import requests import json from urllib3.exceptions import HTTPError class Client(object): """Client to connect to the mockserver""" def __init__(self, host='localhost', port=1080): """ Class initialization :param str host: host of the mockserver :param int port: port of the mockserver """ self.host = host self.port = port self.headers = { 'Content-Type': 'application/json' } def _get_url(self): """Get full URL of the mockserver :return str url of the mockserver """ return 'http://{}:{}'.format(self.host, self.port) def expectation(self, request, response, times=None): """create expectation on mockserver :param request httpRequest object :param response httpResponse object """ data = { 'httpRequest': request.dict(), 'httpResponse': response.dict(), 'times': { 'remainingTimes': 1, 'unlimited': True } } if times: data['times'] = vars(times) req = requests.put('{}/expectation'.format(self._get_url()), json.dumps(data)) return req def forward(self, request, forward, times=None): """create forwarding on mockserver :param times: times object (optional) :param request httpRequest object :param forward httpResponse object """ data = { 'httpRequest': request.dict(), 'httpForward': forward.dict(), 'times': { 'remainingTimes': 1, 'unlimited': True } } if times: data['times'] = vars(times) req = requests.put('{}/expectation'.format(self._get_url()), json.dumps(data)) return req def active_expectations(self): """Get list of active expectations :return Array active expectations """ req = requests.put( '{}/retrieve'.format(self._get_url()), params={'type': 'active_expectations'}) if req.status_code == 200: try: return req.json() except ValueError: return [] return [] def retrieve_requests(self, request=None): """Get all recorded requests :return Array recorded requests """ data = {} if request: data = request.dict() req = requests.put('{}/retrieve'.format(self._get_url()), params={'type': 'requests'}, data=json.dumps(data)) if req.status_code == 200: try: return req.json() except ValueError: return [] return [] def verify(self, request, times=None): """Verify if a request has been received in specific number of times :param Request request: Request object to verify :param Times times: Times object for count. Default=None, count=1 :return Boolean true if verified, false if not """ data = { 'httpRequest': request.dict() } if times: data['times'] = vars(times) else: data['times'] = { 'count': 1, 'exact': True } req = requests.put('{}/verify'.format(self._get_url()), headers=self.headers, data=json.dumps(data)) resp = { 'status': 'OK', 'reason': req.content.decode('utf-8'), 'found': None } if req.status_code == 202: resp['reason'] = None resp['found'] = True elif req.status_code == 406: resp['found'] = False else: resp['status'] = 'ERROR' return resp def reset(self): """delete all active expectations and recorded requests""" requests.put('{}/reset'.format(self._get_url())) def clear(self, request): """Delete active expectation and recorded request :param Request request: Request to clear """ requests.put('{}/clear'.format(self._get_url()), data=request.json())

26f481dfc45ad24d352172f8f79006991163fc28

py

Python

workflow/executors/validation_tasks.py

mettadatalabs1/oncoscape-datapipeline

9c3209ba88831c3f1c598182c719ce45b4724fff

workflow/executors/validation_tasks.py

mettadatalabs1/oncoscape-datapipeline

9c3209ba88831c3f1c598182c719ce45b4724fff

workflow/executors/validation_tasks.py

mettadatalabs1/oncoscape-datapipeline

9c3209ba88831c3f1c598182c719ce45b4724fff

from validators.validation_configurator import ValidationConfigurator from pipeline.models import InputFile class HugoValidator(object): # hugo_genes_map (Dictionary): a dictionary that has the hugo genes and # respective aliases. Each entry is db:{gene: Set(aliases),}. # This is created the first time the class is loaded and is static. # We use set because alias look up will be O(1) and the overall complexity # for each row is O(n), yielding a total complexity of O(n^2) # for an input file. The assumption is that different projects might have # different gene maps and we want to create the map per project once. hugo_genes_map = {} @classmethod def populate_hugo_genes_map(cls, mongo_connector,collection): """ Populates the hugo_genes_map for a given database. Args: mongo_connector (db.mongo_connector.MongoConnector): The mongo connection holding the db name and the connection to the db collection: the name of the collection to query """ db = mongo_connector.db.name if db not in HugoValidator.hugo_genes_map: gene_maps_from_db = mongo_connector.find(query=None, collection=collection) gene_maps_local = {} for gene_map in gene_maps_from_db: gene_maps_local[gene_map["hugo"]] =\ frozenset(gene_map["symbols"]) HugoValidator.hugo_genes_map[db] = gene_maps_local print (len(HugoValidator.hugo_genes_map[db])) @classmethod def validate_hugo(cls, db, gene_symbol): """ Validates if a given gene symbol is a gene name, an alias, or is an invalid entry. Args: db (string): The database in which we want to check gene_symbol (string): The gene symbol to checking Returns: (string, string): A 2 tuple with gene_symbol that was sent and the parent if it is an alias. If a match, the tuple is (None, gene_symbol). If invalid, the tuple is (None, None) """ gene_valid_status = (None, None) db_genes_map = HugoValidator.hugo_genes_map[db] if gene_symbol in db_genes_map: gene_valid_status = (None, gene_symbol) else: for gene in db_genes_map: if gene_symbol in db_genes_map[gene]: gene_valid_status = (gene_symbol, gene) break return gene_valid_status def validate_file(input_file_obj): if not input_file_obj.directory and not input_file_obj.s3_path: return None if not input_file_obj.file: return None input_file = (input_file_obj.directory if input_file_obj.directory else input_file_obj.s3_path) input_file += "/" + input_file_obj.file # validation_configurator (ValidationConfigurator) validation_configurator = ValidationConfigurator(input_file_obj.datatype) with open(input_file, "r") as file_to_validate: header = file_to_validate.readline().strip("\n") # header row: gene sample1 sample2 sample 3 # valid_samples(list(dictionary): A list of dictionary to store all the # valid rows for a given sample. The dictionary has sample as the key # and a dictionary with 2 lists, one for valid values and other for # the genes. The values and genes are 1-1 meaning value[0] corresponds # to the value of the first gene for the sample. If we have an invalid # value, then we will not store the gene for the sample. # todo: add documentation link to the datastructure. valid_samples = [{"sample": sample, "values":[],"genes":[],} for sample in header.split("\t")[1:]] print (valid_samples[-1]) for line in file_to_validate: line_tokens = line.strip("\n").split("\t") gene = line_tokens[0] hugo_validation = HugoValidator.validate_hugo("tcga", gene) gene_valid = False if hugo_validation[1]: # the gene is alias if first token is not None else valid gene_valid = "alias" if hugo_validation[0] else "valid" enumerated_tokens = enumerate(line_tokens[1:]) # parse rest of the line only for valid genes for idx,line_token in enumerated_tokens: # the element is valid is_valid, value = validation_configurator.validate( line_token) if is_valid: # the index refers to the sample location in valid_samples. # append the gene and the value at the end valid_samples[idx]["genes"].append(gene) valid_samples[idx]["values"].append(value) # THIS HAS TO CHANGE. IF THERE IS ONE INVALID ENTRY # the whole sample should change. # HANDLE NULL. Default is NA. Put this in job_config # sklearn.decomposition.PCA lib for PCA input_file_obj.valid_samples = valid_samples

26f602e46a5eecf3c443505b6bc8ba0c321a760e

py

Python

pytglib/api/types/input_message_video_note.py

iTeam-co/pytglib

e5e75e0a85f89b77762209b32a61b0a883c0ae61

2019-10-30T08:57:27.000Z

2021-02-08T14:17:43.000Z

pytglib/api/types/input_message_video_note.py

iTeam-co/python-telegram

e5e75e0a85f89b77762209b32a61b0a883c0ae61

2021-08-19T05:44:10.000Z

2021-08-19T07:14:56.000Z

pytglib/api/types/input_message_video_note.py

iTeam-co/python-telegram

e5e75e0a85f89b77762209b32a61b0a883c0ae61

2019-12-04T05:30:39.000Z

2021-05-21T18:23:32.000Z

from ..utils import Object class InputMessageVideoNote(Object): """ A video note message Attributes: ID (:obj:`str`): ``InputMessageVideoNote`` Args: video_note (:class:`telegram.api.types.InputFile`): Video note to be sent thumbnail (:class:`telegram.api.types.inputThumbnail`): Video thumbnail, if available duration (:obj:`int`): Duration of the video, in seconds length (:obj:`int`): Video width and height; must be positive and not greater than 640 Returns: InputMessageContent Raises: :class:`telegram.Error` """ ID = "inputMessageVideoNote" def __init__(self, video_note, thumbnail, duration, length, **kwargs): self.video_note = video_note # InputFile self.thumbnail = thumbnail # InputThumbnail self.duration = duration # int self.length = length # int @staticmethod def read(q: dict, *args) -> "InputMessageVideoNote": video_note = Object.read(q.get('video_note')) thumbnail = Object.read(q.get('thumbnail')) duration = q.get('duration') length = q.get('length') return InputMessageVideoNote(video_note, thumbnail, duration, length)

26f6c233aae91fb0635319c24ac7a5452088a65f

py

Python

gdc_readgroups/exceptions.py

NCI-GDC/gdc-readgroups

874387bb3473b0a0680551339e50b072cc058eb6

gdc_readgroups/exceptions.py

NCI-GDC/gdc-readgroups

874387bb3473b0a0680551339e50b072cc058eb6

gdc_readgroups/exceptions.py

NCI-GDC/gdc-readgroups

874387bb3473b0a0680551339e50b072cc058eb6

2020-01-23T22:07:10.000Z

2020-01-23T22:07:10.000Z

""" Exceptions for Read Group headers """ class NoReadGroupError(Exception): """NoReadGroupError""" class SamtoolsViewError(Exception): """SamtoolsViewError""" class InvalidPlatformError(Exception): """InvalidPlatformError""" class InvalidPlatformModelError(Exception): """InvalidPlatformError""" class MissingReadgroupIdError(Exception): """MissingReadgroupIdError""" class InvalidDatetimeError(Exception): """InvalidDatetimeError""" class NotABamError(Exception): """NotABamError"""

26f984eeef056e7ffe65f198d0e3689278e5fc57

py

Python

aiida_logger/calculations/test_calculations.py

SINTEF/aiida-logger

d97aced2ec8967cb359f488d2218cc3b47c92f6b

aiida_logger/calculations/test_calculations.py

SINTEF/aiida-logger

d97aced2ec8967cb359f488d2218cc3b47c92f6b

aiida_logger/calculations/test_calculations.py

SINTEF/aiida-logger

d97aced2ec8967cb359f488d2218cc3b47c92f6b

""" Tests for calculations. """ from __future__ import print_function from __future__ import absolute_import import os import numpy as np def test_process(logger_code): """ Test running a calculation. Also checks its outputs. """ from aiida.plugins import DataFactory, CalculationFactory from aiida.engine import run from aiida.common.extendeddicts import AttributeDict from aiida_logger.tests import TEST_DIR # pylint: disable=wrong-import-position # Prepare input parameters parameters = AttributeDict() parameters.comment_string = '#' parameters.labels = True # Define input files to use SinglefileData = DataFactory('singlefile') datafile = SinglefileData( file=os.path.join(TEST_DIR, 'input_files', 'datafile')) # Set up calculation inputs = { 'code': logger_code, 'parameters': DataFactory('dict')(dict=parameters), 'datafiles': { 'datafile': datafile }, 'metadata': { 'options': { 'resources': { 'num_machines': 1, 'num_mpiprocs_per_machine': 1 }, 'parser_name': 'logger', 'withmpi': False, 'output_filename': 'logger.out' }, 'description': 'Test job submission with the aiida_logger plugin' }, } result = run(CalculationFactory('logger'), **inputs) assert 'data' in result assert 'metadata' in result data = result['data'] metadata = result['metadata'] metadata = metadata.get_dict() assert 'labels' in metadata assert 'comments' in metadata assert metadata['labels'] == ['time', 'param1', 'param2', 'param3'] assert metadata['comments'][0] == '# This is an example file' test_array = np.array([[1.0e+00, 3.0e+00, 4.0e+00, 5.0e+00], [2.0e+00, 4.0e+00, 5.7e+00, -1.0e-01], [3.0e+00, 1.0e-03, 1.0e+03, 8.0e-01]]) np.testing.assert_allclose(data.get_array('content'), test_array)

26fb61ab1de0e800a79d50ca5f9597cf8788e433

py

Python

db_sheet/sheet_table.py

chowmean/DBSheet

3f1c521320cb3564c4ff55cd70c8a1978dd32a4c

2017-08-18T20:04:12.000Z

2021-01-08T12:23:43.000Z

db_sheet/sheet_table.py

chowmean/DBSheet

3f1c521320cb3564c4ff55cd70c8a1978dd32a4c

2021-06-01T23:13:57.000Z

2021-06-01T23:13:57.000Z

db_sheet/sheet_table.py

chowmean/DBSheet

3f1c521320cb3564c4ff55cd70c8a1978dd32a4c

class Table: def __init__(self, columns, name): self.columns = columns self.name = name class CreateTable: def __init__(self, table_obj, sheet_obj): self.table = table_obj self.sheet = sheet_obj def create_table(self): cols = len(self.table.columns) name = self.table.name rows = 1 wk_sheet = self.sheet.add_worksheet(name, rows, cols) return self.addRows(wk_sheet) def addRows(self,worksheet): worksheet.append_row(self.table.columns) worksheet.delete_row(1) return True class WorkingTable: def __init__(self, name, sheet_obj): for i in range(0,100): self.wk_sheet = sheet_obj.get_worksheet(i) if self.wk_sheet.title == name: break elif self.wk_sheet.title == "": return "No sheet with this name found" def get_all(self): return self.wk_sheet.get_all_records() def insert(self, row): if len(row) != self.wk_sheet.col_count: return "Column count doest match" return self.wk_sheet.append_row(row) def get_one(self,key, value): return self.find(key, value, 1) def get_attr(self, key, value): return self.find(key,value) def find(self,key, value, count=-1): all_data = self.get_all() matched_rows = [] matched_count = 0 for each_d in all_data: if each_d[key] == value: matched_rows.append(each_d) matched_count = matched_count +1 if matched_count == count: break; return matched_rows def get_index(self,key, value): all_data = self.get_all() matched_rows = [] index = 1 for each_d in all_data: if each_d[key] == value: return index + 1 index = index + 1 return -1 def delete(self,key, value): index = self.get_index(key, value) print index while index != -1: self.wk_sheet.delete_row(index) index = self.get_index(key, value)

26fd4d122991c7a14eaad9bffe766e315791616a

py

Python

root/ilikeit/MySQLCrashCourse/dbcom/tests/__init__.py

ChyiYaqing/chyidlTutorial

77e7f6f84f21537a58a8a8a42e31cf2e3dd31996

2018-10-17T05:57:39.000Z

2021-07-05T15:38:24.000Z

root/ilikeit/MySQLCrashCourse/dbcom/tests/__init__.py

ChyiYaqing/chyidlTutorial

77e7f6f84f21537a58a8a8a42e31cf2e3dd31996

2021-04-14T00:48:43.000Z

2021-04-14T02:20:50.000Z

root/ilikeit/MySQLCrashCourse/dbcom/tests/__init__.py

ChyiYaqing/chyidlTutorial

77e7f6f84f21537a58a8a8a42e31cf2e3dd31996

2019-03-02T14:36:19.000Z

2022-03-18T10:12:09.000Z

#!/usr/bin/env python3 # -*- coding:utf-8 -*- """Requests test package initialisation."""

26fdabbca3431190e788d02f52c14a320298b8ac

py

Python

discopy/components/sense/explicit/bert_conn_sense.py

rknaebel/discopy

5507d656987af2df9e595434a82c0a12bbc713e4

2019-04-14T16:10:23.000Z

2022-03-09T14:56:10.000Z

discopy/components/sense/explicit/bert_conn_sense.py

rknaebel/discopy

5507d656987af2df9e595434a82c0a12bbc713e4

2019-04-15T16:44:40.000Z

2021-11-23T17:36:41.000Z

discopy/components/sense/explicit/bert_conn_sense.py

rknaebel/discopy

5507d656987af2df9e595434a82c0a12bbc713e4

2020-02-28T23:36:35.000Z

2020-02-28T23:36:35.000Z

import json import logging import os from typing import List, Dict import click import numpy as np import tensorflow as tf from sklearn.metrics import cohen_kappa_score, precision_recall_fscore_support, accuracy_score from tqdm import tqdm from discopy.components.component import Component from discopy.components.connective.base import get_connective_candidates from discopy.evaluate.conll import evaluate_docs, print_results from discopy.utils import init_logger from discopy_data.data.doc import Document from discopy_data.data.loaders.conll import load_bert_conll_dataset from discopy_data.data.relation import Relation logger = logging.getLogger('discopy') def get_conn_model(in_size, out_size, hidden_size, hidden_size2=256): x = y = tf.keras.layers.Input(shape=(in_size,), name='connective') y = tf.keras.layers.Dense(hidden_size, kernel_initializer='lecun_normal', activation='selu')(y) y = tf.keras.layers.Dropout(0.3)(y) y = tf.keras.layers.Dense(hidden_size2, kernel_initializer='lecun_normal', activation='selu')(y) y = tf.keras.layers.Dropout(0.3)(y) y = tf.keras.layers.Dense(out_size, activation='softmax')(y) model = tf.keras.models.Model(x, y) optimizer = tf.keras.optimizers.RMSprop() model.compile(optimizer, 'sparse_categorical_crossentropy', metrics=[ "accuracy", ]) return model def get_bert_features(idxs, doc_bert, used_context=0): idxs = list(idxs) pad = np.zeros_like(doc_bert[0]) embd = doc_bert[idxs].mean(axis=0) if used_context > 0: left = [doc_bert[i] if i >= 0 else pad for i in range(min(idxs) - used_context, min(idxs))] right = [doc_bert[i] if i < len(doc_bert) else pad for i in range(max(idxs) + 1, max(idxs) + 1 + used_context)] embd = np.concatenate(left + [embd] + right).flatten() return embd def generate_pdtb_features(docs: List[Document], sense_map: Dict[str, int], used_context=0): features = [] for doc in tqdm(docs): doc_bert = doc.get_embeddings() global_id_map = {(s_i, t.local_idx): t.idx for s_i, s in enumerate(doc.sentences) for t in s.tokens} conns = {tuple(t.idx for t in r.conn.tokens): r.senses[0] for r in doc.get_explicit_relations()} for sent_i, sentence in enumerate(doc.sentences): for connective_candidate in get_connective_candidates(sentence): conn_idxs = tuple(global_id_map[(sent_i, i)] for i, c in connective_candidate) if conn_idxs in conns: sense = sense_map.get(conns[conn_idxs]) if not sense: continue features.append((get_bert_features(conn_idxs, doc_bert, used_context), sense)) else: features.append((get_bert_features(conn_idxs, doc_bert, used_context), 0)) x, y = list(zip(*features)) return np.stack(x), np.array(y) def get_sense_mapping(docs): sense_map = { 'NoSense': 0, } senses = sorted({s for doc in docs for rel in doc.relations for s in rel.senses}) i = 1 for s in senses: if s in sense_map: sense_map[s] = sense_map[s] else: sense_map[s] = i i += 1 classes = [] for sense, sense_id in sorted(sense_map.items(), key=lambda x: x[1]): if len(classes) > sense_id: continue classes.append(sense) return sense_map, classes class ConnectiveSenseClassifier(Component): model_name = 'explicit_sense_bert_classifier' used_features = ['vectors'] def __init__(self, input_dim, used_context: int = 0, hidden_dim: int = 2048): self.input_dim = input_dim self.used_context = used_context self.in_size = input_dim + 2 * used_context * input_dim self.hidden_dim = hidden_dim self.sense_map = {} self.classes = [] self.model = None self.batch_size = 512 def get_config(self): return { 'model_name': self.model_name, 'input_dim': self.input_dim, 'hidden_dim': self.hidden_dim, 'used_context': self.used_context, 'sense_map': self.sense_map, 'classes': self.classes, } @staticmethod def from_config(config: dict): clf = ConnectiveSenseClassifier(config['input_dim'], config['used_context'], config['hidden_dim']) clf.sense_map = config['sense_map'] clf.classes = config['classes'] return clf def load(self, path): self.sense_map = json.load(open(os.path.join(path, self.model_name, 'senses.json'), 'r')) self.classes = [] for sense, sense_id in sorted(self.sense_map.items(), key=lambda x: x[1]): if len(self.classes) > sense_id: continue self.classes.append(sense) if not os.path.exists(os.path.join(path, self.model_name)): raise FileNotFoundError("Model not found.") self.model = tf.keras.models.load_model(os.path.join(path, self.model_name), compile=False) def save(self, path): if not os.path.exists(path): os.makedirs(path) self.model.save(os.path.join(path, self.model_name)) json.dump(self.sense_map, open(os.path.join(path, self.model_name, 'senses.json'), 'w')) def fit(self, docs_train: List[Document], docs_val: List[Document] = None): if docs_val is None: raise ValueError("Validation data is missing.") self.sense_map, self.classes = get_sense_mapping(docs_train) self.model = get_conn_model(self.in_size, len(self.sense_map), self.hidden_dim, 128) self.model.summary() print(self.sense_map, self.classes) x_train, y_train = generate_pdtb_features(docs_train, self.sense_map, used_context=self.used_context) x_val, y_val = generate_pdtb_features(docs_val, self.sense_map, used_context=self.used_context) self.model.fit(x_train, y_train, validation_data=(x_val, y_val), verbose=1, shuffle=True, epochs=20, batch_size=self.batch_size, callbacks=[ tf.keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0.001, patience=7, verbose=0, restore_best_weights=True), tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.75, patience=3, verbose=0) ]) def score_on_features(self, x, y): y_pred = self.model.predict(x, batch_size=self.batch_size).argmax(-1) logger.info("Evaluation: Connective") logger.info(" Acc : {:<06.4}".format(accuracy_score(y, y_pred))) prec, recall, f1, support = precision_recall_fscore_support(y, y_pred, average='macro') logger.info(" Macro: P {:<06.4} R {:<06.4} F1 {:<06.4}".format(prec, recall, f1)) logger.info(" Kappa: {:<06.4}".format(cohen_kappa_score(y, y_pred))) def score(self, docs: List[Document]): if not self.model: raise ValueError("Score of untrained model.") x, y = generate_pdtb_features(docs, self.sense_map, used_context=self.used_context) self.score_on_features(x, y) def parse(self, doc: Document, relations=None, **kwargs): if not self.model: raise ValueError("Score of untrained model.") relations: List[Relation] = [] doc_bert = doc.get_embeddings() global_id_map = {(s_i, t.local_idx): t.idx for s_i, s in enumerate(doc.sentences) for t in s.tokens} for sent_i, sent in enumerate(doc.sentences): for connective_candidate in get_connective_candidates(sent): conn_idxs = tuple(global_id_map[(sent_i, i)] for i, c in connective_candidate) features = get_bert_features(conn_idxs, doc_bert, self.used_context) pred = self.model.predict(np.expand_dims(features, axis=0)).argmax(-1).flatten()[0] if pred > 0: conn_tokens = [sent.tokens[i] for i, c in connective_candidate] relations.append(Relation( conn=conn_tokens, type='Explicit', senses=[self.classes[pred]] )) return relations @click.command() @click.argument('conll-path') def main(conll_path): logger = init_logger() docs_val = load_bert_conll_dataset(os.path.join(conll_path, 'en.dev'), cache_dir=os.path.join(conll_path, 'en.dev.bert-base-cased.joblib')) docs_train = load_bert_conll_dataset(os.path.join(conll_path, 'en.train'), cache_dir=os.path.join(conll_path, 'en.train.bert-base-cased.joblib')) clf = ConnectiveSenseClassifier(input_dim=docs_val[0].get_embedding_dim(), used_context=2) logger.info('Train model') clf.fit(docs_train, docs_val) logger.info('Evaluation on TRAIN') clf.score(docs_train) logger.info('Evaluation on TEST') clf.score(docs_val) # logger.info('Parse one document') # print(docs_val[0].to_json()) print(clf.parse(docs_val[0], [])) preds = [d.with_relations(clf.parse(d)) for d in docs_val] print_results(evaluate_docs(docs_val, preds)) if __name__ == "__main__": main()

f80409abd20022882a95d524c2584bb72123403a

py

Python

Perfect Squares.py

ngdeva99/Fulcrum

3a5c69005bbaf2a5aebe13d1907f13790210fb32

Perfect Squares.py

ngdeva99/Fulcrum

3a5c69005bbaf2a5aebe13d1907f13790210fb32

Perfect Squares.py

ngdeva99/Fulcrum

3a5c69005bbaf2a5aebe13d1907f13790210fb32

class Solution: def numSquares(self, n: int) -> int: if n==0: return 0 dp = [float('inf')]*(n+1) dp[0] = 0 c = n n = int(sqrt(n)) a = [i**2 for i in range(1,n+1)] for i in range(1,len(dp)): for j in a: if i-j>=0: dp[i] = min(dp[i-j]+1,dp[i]) print(dp) if dp[n]==float('inf'): return -1 return dp[c]

f8053be6ee69e87199ea558062ed1fe681dca092

py

Python

busshaming/models/agency.py

katharosada/busshaming

c8d7cd4baf9ff049cda49c92da4d5ca10f68e6a9

2018-01-20T01:12:25.000Z

2022-02-02T01:40:17.000Z

busshaming/models/agency.py

katharosada/busshaming

c8d7cd4baf9ff049cda49c92da4d5ca10f68e6a9

2018-01-24T03:58:17.000Z

2018-06-10T01:05:57.000Z

busshaming/models/agency.py

katharosada/busshaming

c8d7cd4baf9ff049cda49c92da4d5ca10f68e6a9

2018-01-24T05:49:13.000Z

2018-12-03T08:47:43.000Z

from django.db import models class Agency(models.Model): gtfs_agency_id = models.CharField(max_length=200) feed = models.ForeignKey('Feed') name = models.CharField(max_length=200) class Meta: unique_together = ('gtfs_agency_id', 'feed') def __str__(self): return f'{self.feed.slug} - {self.gtfs_agency_id} ({self.name})'

f805d1c83458a20d7c8be553923b41b8d8630a7f

py

Python

sqltask/base/dq.py

mjalo/sqltask

f6eefd624614a464ae5697ac61405416244518e2

2019-10-09T15:34:13.000Z

2022-02-21T07:44:03.000Z

sqltask/base/dq.py

mjalo/sqltask

f6eefd624614a464ae5697ac61405416244518e2

2019-10-09T15:20:01.000Z

2020-02-08T11:51:24.000Z

sqltask/base/dq.py

mjalo/sqltask

f6eefd624614a464ae5697ac61405416244518e2

2019-10-09T15:20:51.000Z

2020-02-11T08:43:03.000Z

from enum import Enum class Priority(Enum): MANDATORY = "mandatory" HIGH = "high" MEDIUM = "medium" LOW = "low" class Source(Enum): SOURCE = "source" TRANSFORM = "transform" LOOKUP = "lookup" class Category(Enum): MISSING = "missing" INCORRECT = "incorrect" DUPLICATE = "duplicate"

f80628afca18060801db523544822b454ace8ecb

py

Python

main.py

deadpoool69/MediCare

eb45149dd14dc3792ef3ea724c61d46a29718068

main.py

deadpoool69/MediCare

eb45149dd14dc3792ef3ea724c61d46a29718068

main.py

deadpoool69/MediCare

eb45149dd14dc3792ef3ea724c61d46a29718068

from flask import Flask, render_template, request, url_for, redirect from forms import * from model import generate_recommendations, get_desc import os app = Flask(__name__) SECRET_KEY = os.urandom(32) app.config['SECRET_KEY'] = SECRET_KEY @app.route('/', methods=["GET", "POST"]) def landing(): title = 'Neurolens' form = DiagnosisForm() form_name = 'Try your tailored neurological treatment' if request.method == 'POST': diagnosis = request.form.get("diagnosis") return redirect(url_for('drugs', diagnosis=diagnosis)) return render_template('landing.html', title = title, form = form, form_name = form_name) @app.route('/drugs', methods=["GET", "POST"]) def drugs(): title = 'Neurolens' diagnosis = request.args.get("diagnosis") if diagnosis == 'Schizophrenia': form = SchizophreniaDrugForm() else: form = DepressionDrugForm() form_name = 'Select your prescribed drug' if request.method == 'POST': drug = request.form.get("drug") return redirect(url_for('symptoms', diagnosis=diagnosis, drug=drug)) return render_template('drugs.html', title=title, form=form, form_name=form_name) @app.route('/symptoms', methods=["GET", "POST"]) def symptoms(): title = 'Neurolens' diagnosis = request.args.get("diagnosis") drug = request.args.get("drug") form = SymptomsForm() form_name = 'Tell us how {drug} has treated you'.format(drug=drug) if request.method == 'POST': symptoms = request.form return redirect(url_for('results', diagnosis=diagnosis, drug=drug, **symptoms)) return render_template('symptoms.html', title=title, form=form, form_name=form_name) @app.route('/results', methods=["GET", "POST"]) def results(): title = 'Based on your responses, we recommend' data = request.args recs = generate_recommendations(data) drug_1 = recs[0] # Score, name, description, id list drug_1 = (int(drug_1[0][0]), drug_1[1], get_desc(drug_1[1]), drug_1[0][1]) drug_2 = recs[1] drug_2 = (int(drug_2[0][0]), drug_2[1], get_desc(drug_2[1]), drug_2[0][1]) drug_3 = recs[2] drug_3 = (int(drug_3[0][0]), drug_3[1], get_desc(drug_3[1]), drug_3[0][1]) return render_template('results.html', title = title, drug_1=drug_1, drug_2=drug_2, drug_3=drug_3) if __name__ == '__main__': app.run(debug=True, host='0.0.0.0')

f8065cbbdc71ae71f6d602d2671a71b28b0eea4a

py

Python

tools/draw_comparison_head_design_choices.py

twangnh/Calibration_mrcnn

e5f3076cefbe35297a403a753bb57e11503db818

2020-07-24T01:28:39.000Z

2021-08-29T08:40:18.000Z

tools/draw_comparison_head_design_choices.py

twangnh/Calibration_mrcnn

e5f3076cefbe35297a403a753bb57e11503db818

2020-09-27T12:59:28.000Z

2022-01-06T13:14:08.000Z

tools/draw_comparison_head_design_choices.py

twangnh/Calibration_mrcnn

e5f3076cefbe35297a403a753bb57e11503db818

2020-09-05T04:37:19.000Z

2021-12-13T02:25:48.000Z

import matplotlib import matplotlib.pyplot as plt import numpy as np labels = ['AP on bin (0,10)', 'AP on bin (10,100)'] baseline = [0.0, 13.3] fc2_ncm = [6.0, 18.9] fc2 = [8.6, 22.0] fc3_rand = [9.1, 18.8] fc3_ft = [13.2, 23.1] x = np.arange(len(labels)) # the label locations width = 0.15 # the width of the bars matplotlib.rcParams.update({'font.size': 16}) # plt.rc('ytick', labelsize=10) fig, ax = plt.subplots() # rects1 = ax.bar(x - width, baseline, width, label='baseline') # rects2 = ax.bar(x - width/2, fc2_ncm, width, label='2fc_ncm') # rects3 = ax.bar(x , baseline, fc2, label='baseline') # rects4 = ax.bar(x + width/2, fc3_rand, width, label='2fc_ncm') # rects5 = ax.bar(x + width, fc3_ft, width, label='baseline') # Set position of bar on X axis r1 = np.arange(len(labels)) r2 = [x + width for x in r1] r3 = [x + width for x in r2] r4 = [x + width for x in r3] r5 = [x + width for x in r4] # Make the plot rects1 = ax.bar(r1, baseline, color='#7f6d5f', width=width, edgecolor='white', label='baseline') rects2 = ax.bar(r2, fc2_ncm, color='#557f2d', width=width, edgecolor='white', label='2fc_ncm') rects3 = ax.bar(r3, fc2, width=width, edgecolor='white', label='2fc_rand') rects4 = ax.bar(r4, fc3_rand, width=width, edgecolor='white', label='3fc_rand') rects5 = ax.bar(r5, fc3_ft, width=width, edgecolor='white', label='3fc_ft') ax.set_ylim([0,25]) ax.set_xticks([0.3, 1.3]) ax.set_xticklabels(labels) ax.legend() def autolabel(rects): """Attach a text label above each bar in *rects*, displaying its height.""" for rect in rects: height = rect.get_height() ax.annotate('{}'.format(height), xy=(rect.get_x() + rect.get_width() / 2, height), xytext=(0, 3), # 3 points vertical offset textcoords="offset points", ha='center', va='bottom') autolabel(rects1) autolabel(rects2) autolabel(rects3) autolabel(rects4) autolabel(rects5) fig.tight_layout() plt.savefig('head_design_choices.eps', format='eps', dpi=1000) plt.show()

f807e6a714508c55a5204cce88f3927910a26a1e

py

Python

src/entry.py

akilmarshall/vash-2

5307bc414afba24b235ae0ae9b2583c33ea69b1f

src/entry.py

akilmarshall/vash-2

5307bc414afba24b235ae0ae9b2583c33ea69b1f

src/entry.py

akilmarshall/vash-2

5307bc414afba24b235ae0ae9b2583c33ea69b1f

from datetime import datetime from itertools import count from tkinter import * import tkinter.ttk as ttk from functools import partial from tkcalendar import DateEntry from case import COD, CONTRIES, Case, INCIDENT, ORGANIZATION, POLICESTATION, STATES from db import referred_other_agency from preview import CasePreview class CaseEntry(ttk.Frame): def __init__(self, parent): Frame.__init__(self, parent) row = count(0, 1) # first name r = next(row) ttk.Label(self, text='First Name').grid(row=r, column=0) self.first_name = StringVar() self.fname_entry = ttk.Entry(self, textvariable=self.first_name) self.fname_entry.grid(row=r, column=1) # last name r = next(row) ttk.Label(self, text='Last name').grid(row=r, column=0) self.last_name = StringVar() self.lname_entry = ttk.Entry(self, textvariable=self.last_name) self.lname_entry.grid(row=r, column=1) # incident date r = next(row) ttk.Label(self, text='Incident Date (m/d/y)').grid(row=r, column=0) self.date = StringVar() DateEntry(self, textvariable=self.date).grid(row=r, column=1) # incident type self.other_incident_death_label = None self.other_incident_label = None def variable_incident_entry(value): if self.incident.get() == 'death': self.destroy_other_incident() self.other_incident_death_label = ttk.Label(self, text='Cause of Death') self.other_incident_death_label.grid(row=incident_row, column=2) self.cod = StringVar() self.cod_combobox = ttk.Combobox(self, textvariable=self.cod) self.cod_combobox['values'] = [''] + COD self.cod_combobox.set('') self.cod_combobox.grid(row=incident_row, column=3) elif self.incident.get() == 'other': self.destroy_other_death() self.other_incident = StringVar() self.other_incident_label = ttk.Label(self, text='Other Incident') self.other_incident_label.grid(row=incident_row, column=2) self.other_incident_entry = ttk.Entry(self, textvariable=self.other_incident) self.other_incident_entry.grid(row=incident_row, column=3) else: self.destroy_other_incident() self.destroy_other_death() incident_row = r = next(row) ttk.Label(self, text='Incident Type').grid(row=r, column=0) self.incident = StringVar() incident = ttk.Combobox(self, textvariable=self.incident) incident.bind('<<ComboboxSelected>>', variable_incident_entry) incident['values'] = [''] + INCIDENT incident.set('') incident.grid(row=r, column=1) # water related? r = next(row) ttk.Label(self, text='Water Related?').grid(row=r, column=0) self.water_related = StringVar() ttk.Radiobutton(self, text='True', value=True, variable=self.water_related).grid(row=r, column=1) ttk.Radiobutton(self, text='False', value=False, variable=self.water_related).grid(row=r, column=2) # party size r = next(row) ttk.Label(self, text='Party Size').grid(row=r, column=0) self.party_size = StringVar() party_size = ttk.Combobox(self, textvariable=self.party_size) party_size['values'] = list(range(1, 10)) party_size.set(1) party_size.grid(row=r, column=1) # incident location r = next(row) ttk.Label(self, text='Incident Location').grid(row=r, column=0) self.location = StringVar() ttk.Entry(self, textvariable=self.location).grid(row=r, column=1) # referred by self.other_referred_label = None self.other_referred = StringVar() def referred_entry(_): if self.referred.get() == 'other': self.other_referred_label = ttk.Label(self, text='Other Agency') self.other_referred_label.grid(row=referred_row, column=2) self.other_referred_entry = ttk.Entry(self, textvariable=self.other_referred) self.other_referred_entry.grid(row=referred_row, column=3) else: self.destroy_other_referred() referred_row = r = next(row) ttk.Label(self, text='Referred by').grid(row=r, column=0) self.referred = StringVar() referred = ttk.Combobox(self, textvariable=self.referred) referred.bind('<<ComboboxSelected>>', referred_entry) referred['values'] = [''] + ORGANIZATION referred.set('') referred.grid(row=r, column=1) # police station r = next(row) ttk.Label(self, text='Police Station').grid(row=r, column=0) self.police = StringVar() police = ttk.Combobox(self, textvariable=self.police) police['values'] = [''] + POLICESTATION police.grid(row=r, column=1) # visitor type r = next(row) ttk.Label(self, text='Visitor Type').grid(row=r, column=0) self.visitor_type = StringVar() visitor_type = ttk.Combobox(self, textvariable=self.visitor_type) visitor_type['values'] = ['land', 'cruise'] visitor_type.grid(row=r, column=1) # country of origin self.state_label = None def state_entry(_): if self.country.get() == 'United States': # state of origin self.state = StringVar() self.state_label = ttk.Label(self, text='State') self.state_label.grid(row=country_row, column=2) self.state_combobox = ttk.Combobox(self, textvariable=self.state) self.state_combobox['values'] = [''] + STATES self.state_combobox.set('') self.state_combobox.grid(row=country_row, column=3) else: self.destroy_other_state() country_row = r = next(row) ttk.Label(self, text='Country').grid(row=r, column=0) self.country = StringVar() country = ttk.Combobox(self, textvariable=self.country) country.bind('<<ComboboxSelected>>', state_entry) country['values'] = [''] + CONTRIES country.set('') country.grid(row=r, column=1) # case notes r = next(row) self.notes = Text(self, height=10) ttk.Label(self, text='Notes').grid(row=r, column=0) self.notes.grid(row=r, column=1) # Buttons r = next(row) ttk.Button(self, text='Submit', command=self.submit).grid( row=r, column=1) r = next(row) ttk.Button(self, text='Clear', command=self.clear).grid( row=r, column=1) r = next(row) def destroy_other_incident(self): if self.other_incident_label is not None: self.other_incident_label.destroy() self.other_incident_entry.destroy() def destroy_other_death(self): if self.other_incident_death_label is not None: self.other_incident_death_label.destroy() self.cod_combobox.destroy() def destroy_other_referred(self): if self.other_referred_label is not None: self.other_referred_label.destroy() self.other_referred_entry.destroy() def destroy_other_state(self): if self.state_label is not None: self.state_label.destroy() self.state_combobox.destroy() def submit(self): fname = self.first_name.get() lname = self.last_name.get() date = datetime.strptime(self.date.get(), '%m/%d/%y') incident = self.incident.get() cod = '' incident_other = '' if incident == 'death': cod = self.cod.get() elif incident == 'other': incident_other = self.other_incident_entry.get() party_size = int(self.party_size.get()) location = self.location.get() water_related = True if self.water_related.get() == '1' else False referred = self.referred.get() referred_other = self.other_referred.get() if referred == 'other' else '' police = self.police.get() visitor_type = self.visitor_type.get() country = self.country.get() state = self.state.get() if country == 'United States' else '' notes = self.notes.get('1.0', 'end') case = Case( fname, lname, date, incident, incident_other, cod, party_size, location, water_related, referred, referred_other, police, visitor_type, country, state, notes ) CasePreview(self, case) # self.clear() # somehow need pass an asyn message and check # if the write was successfull def clear(self): self.first_name.set('') self.first_name.set('') date = datetime.today() y, m, d = date.year, date.month, date.day self.date.set(f'{m}/{d}/{y - 2000}') self.last_name.set('') self.incident.set('') # self.cod.set('') self.party_size.set(1) self.location.set('') self.water_related.set('') self.referred.set('') self.police.set('') self.visitor_type.set('') self.country.set('') # self.state.set('') self.notes.delete('1.0', END) self.destroy_other_state() self.destroy_other_referred() self.destroy_other_death() self.destroy_other_incident() if __name__ == '__main__': root = Tk() entry = CaseEntry(root) entry.pack() root.mainloop()

f8082f1e3f5f385cac811686714cd680277f4584

py

Python

repro_eval/__main__.py

irgroup/repro_eval

35a4cf083dbb5f4b29d6ef602a604f0686a537c9

2020-10-27T02:11:53.000Z

2022-03-02T11:00:10.000Z

repro_eval/__main__.py

irgroup/repro_eval

35a4cf083dbb5f4b29d6ef602a604f0686a537c9

2021-01-25T19:59:39.000Z

2021-12-07T09:29:01.000Z

repro_eval/__main__.py

irgroup/repro_eval

35a4cf083dbb5f4b29d6ef602a604f0686a537c9

2021-04-16T16:21:16.000Z

2021-04-16T16:21:16.000Z

""" Use repro_eval from the command line with e.g. python -m repro_eval -t rpd -q qrel_orig -r orig_b rpd_b python -m repro_eval -t rpd -q qrel_orig -r orig_b orig_a rpd_b rpd_a python -m repro_eval -t rpd -m rmse -q qrel_orig -r orig_b rpd_b python -m repro_eval -t rpl -q qrel_orig qrel_rpl -r orig_b rpl_b python -m repro_eval -t rpl -q qrel_orig qrel_rpl -r orig_b orig_a rpl_b rpl_a after having installed the Python package. For other more specific examples also have a look at the README file. Depending on the provided parameters and input run files, evaluation measures will be printed. """ import argparse from repro_eval.Evaluator import RpdEvaluator, RplEvaluator from repro_eval.util import print_simple_line, print_base_adv from repro_eval.util import arp def main(): parser = argparse.ArgumentParser() parser.add_argument('-t', '--type') parser.add_argument('-m', '--measure', nargs='+') parser.add_argument('-q', '--qrels', nargs='+') parser.add_argument('-r', '--runs', nargs='+') args = parser.parse_args() if args.type in ['rpd', 'reproducibility']: if len(args.runs) == 4: rpd_eval = RpdEvaluator(qrel_orig_path=args.qrels[0], run_b_orig_path=args.runs[0], run_a_orig_path=args.runs[1], run_b_rep_path=args.runs[2], run_a_rep_path=args.runs[3]) if len(args.runs) == 2: rpd_eval = RpdEvaluator(qrel_orig_path=args.qrels[0], run_b_orig_path=args.runs[0], run_a_orig_path=None, run_b_rep_path=args.runs[1], run_a_rep_path=None) rpd_eval.trim() rpd_eval.evaluate() measure_list = args.measure if args.measure is not None else [] # KTU if 'ktu' in measure_list or args.measure is None: ktu = rpd_eval.ktau_union() print("Kendall's tau Union (KTU)") print('------------------------------------------------------------------') for topic, value in ktu.get('baseline').items(): value_adv = ktu.get('advanced').get(topic) if ktu.get('advanced') is not None else None print_base_adv(topic, 'KTU', value, value_adv) value_adv = arp(ktu.get('advanced')) if ktu.get('advanced') is not None else None print_base_adv('ARP', 'KTU', arp(ktu.get('baseline')), value_adv) print() # RBO if 'rbo' in measure_list or args.measure is None: rbo = rpd_eval.rbo() print("Rank-biased Overlap (RBO)") print('------------------------------------------------------------------') for topic, value in rbo.get('baseline').items(): value_adv = rbo.get('advanced').get(topic) if rbo.get('advanced') is not None else None print_base_adv(topic, 'RBO', value, value_adv) value_adv = arp(rbo.get('advanced')) if rbo.get('advanced') is not None else None print_base_adv('ARP', 'RBO', arp(rbo.get('baseline')), value_adv) print() # RMSE if 'rmse' in measure_list or args.measure is None: rmse = rpd_eval.rmse() print("Root mean square error (RMSE)") print('------------------------------------------------------------------') for measure, value in rmse.get('baseline').items(): value_adv = rmse.get('advanced').get(measure) if rmse.get('advanced') is not None else None print_base_adv(measure, 'RMSE', value, value_adv) print() # ER if 'er' in measure_list or args.measure is None and len(args.runs) == 4: print("Effect ratio (ER)") print('------------------------------------------------------------------') er = rpd_eval.er() for measure, value in er.items(): print_simple_line(measure, 'ER', value) print() # DRI if 'dri' in measure_list or args.measure is None and len(args.runs) == 4: print("Delta Relative Improvement (DRI)") print('------------------------------------------------------------------') dri = rpd_eval.dri() for measure, value in dri.items(): print_simple_line(measure, 'DRI', value) print() # ttest if 'ttest' in measure_list or args.measure is None: pvals = rpd_eval.ttest() print("Two-tailed paired t-test (p-value)") print('------------------------------------------------------------------') for measure, value in pvals.get('baseline').items(): value_adv = pvals.get('advanced').get(measure) if pvals.get('advanced') is not None else None print_base_adv(measure, 'PVAL', value, value_adv) print() if args.type in ['rpl', 'replicability']: if len(args.runs) == 4: rpl_eval = RplEvaluator(qrel_orig_path=args.qrels[0], run_b_orig_path=args.runs[0], run_a_orig_path=args.runs[1], run_b_rep_path=args.runs[2], run_a_rep_path=args.runs[3], qrel_rpl_path=args.qrels[1]) if len(args.runs) == 2: rpl_eval = RplEvaluator(qrel_orig_path=args.qrels[0], run_b_orig_path=args.runs[0], run_a_orig_path=None, run_b_rep_path=args.runs[1], run_a_rep_path=None, qrel_rpl_path=args.qrels[1]) rpl_eval.trim() rpl_eval.evaluate() measure_list = args.measure if args.measure is not None else [] # ER if 'er' in measure_list or args.measure is None and len(args.runs) == 4: print("Effect ratio (ER)") print('------------------------------------------------------------------') er = rpl_eval.er() for measure, value in er.items(): print_simple_line(measure, 'ER', value) print() # DRI if 'dri' in measure_list or args.measure is None and len(args.runs) == 4: print("Delta Relative Improvement (DRI)") print('------------------------------------------------------------------') dri = rpl_eval.dri() for measure, value in dri.items(): print_simple_line(measure, 'DRI', value) print() # ttest if 'ttest' in measure_list or args.measure is None: pvals = rpl_eval.ttest() print("Two-tailed unpaired t-test (p-value)") print('------------------------------------------------------------------') for measure, value in pvals.get('baseline').items(): value_adv = pvals.get('advanced').get(measure) if pvals.get('advanced') is not None else None print_base_adv(measure, 'PVAL', value, value_adv) print() if __name__ == "__main__": main()

f809139d6c632c257d27b2da4aee81ff3ca5dcc2

py

Python

main.py

juligreen/towerdefense-prototype

1cdac58acf697ca856a60dec6533caed17acf656

main.py

juligreen/towerdefense-prototype

1cdac58acf697ca856a60dec6533caed17acf656

main.py

juligreen/towerdefense-prototype

1cdac58acf697ca856a60dec6533caed17acf656

import math from game_objects import Turret, Troop players = [] class Location: def __init__(self, x: int, y: int): self.x = x self.y = y class Lane: # for this prototype we are going to imagine our lanes as straight lines def __init__(self, left_start_location: Location, right_start_location: Location): self.left_start_location = left_start_location self.right_start_location = right_start_location def calculate_distance(entity1: Location, entity2: Location) -> float: # distance between vectors: https://brilliant.org/wiki/distance-formula/ distance = math.sqrt((entity1.x - entity2.x) ** 2 + (entity1.y + entity2.y) ** 2) return distance class Player: def __init__(self, position: str, location: Location): self.position = position self.location = location self.turrets = [] self.troops = [] self.enemy_player: Player = Player() self.health = 100 def add_turret(self, grid_location: Location, strenght_level: int): turret = Turret(grid_location, strenght_level) self.turrets.append(turret) def add_troops(self, lane: Lane, count: int, strength_level: int): troops = [] for _ in range(count): troop = Troop(lane, strength_level, self.enemy_player.position, self.enemy_player) troops.append(troop) self.troops.append(troops) def turret_fire_check(self): for turret in self.turrets: for troop in self.enemy_player.troops: distance = calculate_distance(turret.location, troop.location) if distance < turret.range: turret.attack(troop) break def init(): players[0] = Player('left') players[1] = Player('right') players[0].enemy_player = players[1] players[1].enemy_player = players[0] init() while True: # most of this is pseudocode, as I have no way of handling user input currently for index, player in enumerate(players): if 'player places turret': player.add_turret(Location(1, 1)) if 'player places troops': player.add_troops('bla') for troop in player.troops: troop.move() player.turret_fire_check() if player.health <= 0: print(f'Player {index} won the game!')

f8094b25e0893a5bce69fe2d108d090003595a0e

py

Python

bib_processing.py

GAIGResearch/GAIGResearch.github.io

90d0555348ad8f3f500b6480168ad65fa0226dce

bib_processing.py

GAIGResearch/GAIGResearch.github.io

90d0555348ad8f3f500b6480168ad65fa0226dce

bib_processing.py

GAIGResearch/GAIGResearch.github.io

90d0555348ad8f3f500b6480168ad65fa0226dce

2019-07-09T11:08:15.000Z

2020-12-04T14:55:00.000Z

import os from pathlib import Path from difflib import SequenceMatcher supported_bibtex_types = {"article", "book", "booklet", "inbook", "incollection", "inproceedings", "manual", "mastersthesis", "misc", "phdthesis", "proceedings", "techreport", "unpublished"} supported_fields = ["author", "title", "year", "month", "pages", "note", "journal", "booktitle", "volume", "number", "series", "edition", "editor", "publisher", "address", "howpublished", "type", "chapter", "organization", "school", "institution"] extra_fields = ["doi", "issn", "isbn", "keywords", "abstract", "url", "archivePrefix", "eprint", "timestamp", "biburl", "bibsource"] data_path = Path("_data/papers.yml") bib_path = Path("bibfiles") year_from = 2017 similarity_threshold = 0.8 def find_all_files(path_to_search): """Recursively find all bib files in root path given""" list_of_files = os.listdir(path_to_search) all_files = [] # Iterate over all the entries for e in list_of_files: # Create full path full_path = path_to_search / e # If entry is a directory then get the list of files in this directory if os.path.isdir(full_path): all_files = all_files + find_all_files(full_path) elif full_path.with_suffix(".bib"): all_files.append(full_path) return all_files def process_entry(entry_to_process): """ Turns a string of an entry into a dictionary mapping from fields to field values :param entry_to_process :return: dictionary. """ dict_entry = {} entry_lines = entry_to_process.split("\n") first_line = entry_lines[0].split("=") entry_type = first_line[0].replace("@", "") entry_id = first_line[1] # Type validation if entry_type.lower() not in supported_bibtex_types: print("Type " + entry_type + " not supported for bibtex entry " + entry_id) return dict_entry dict_entry["id"] = entry_id dict_entry["type"] = entry_type # Process the rest of the fields field_value = "" # Keep this up here to be able to access previous values in case of multi-line field field = "" for l in entry_lines: split_line = l.split("=") if len(split_line) == 1 and field != "": # No = found on this line, it's a multi-line field field_value += " " + split_line[0].strip() dict_entry[field] = field_value.strip() else: field = split_line[0].strip() field_value = split_line[1].strip() if field.lower() in supported_fields or field.lower() in extra_fields: if field.lower() == "pages" and "--" not in field_value: field_value = field_value.replace("-", "--") dict_entry[field] = field_value # Try to find pdf of this paper pdf = find_pdf(entry_id, dict_entry["year"]) dict_entry["pdf"] = str(pdf).lower() return dict_entry def find_pdf(entry_id, year): """ Returns true if a pdf for this paper exists in the pdf/pub/year directory (must have name as paper ID) """ return os.path.isfile("pdf/pub/" + year + "/" + entry_id + ".pdf") def output_entries(entries): """ Prints the given bibtex entries into yaml supported format """ with open(data_path.absolute(), 'w+', encoding='utf-8') as wf: for entry in entries: if int(entry["year"]) < year_from: continue wf.write("- id: " + entry["id"] + "\n") for e in entry: if e != "id": if ":" in entry[e]: entry[e] = '"' + entry[e] + '"' wf.write(" " + e + ": " + entry[e] + "\n") def check_equality(entry1, entry2): """ Checks if 2 entries are the same """ sim_fields = 0 common_fields = 0 for field1 in entry1: for field2 in entry2: if field1 == field2: common_fields += 1 if similar(entry1[field1], entry2[field2]) >= similarity_threshold: sim_fields += 1 if common_fields == 0: return False if sim_fields / common_fields >= similarity_threshold: return True return False def similar(a, b): """ Checks if 2 strings are similar, returns a similarity measure. """ return SequenceMatcher(None, a, b).ratio() def process_yml_entries(lines): """ Processes entries in yml format :param lines: list of lines from yml file to process :return: list of entries as dictionaries """ entry_list = [] entry = {} ln = 0 for line in lines: if "- id:" in line or ln == len(lines) - 1: # Starting a new entry if len(entry) > 0: entry_list.append(entry) entry = {} line = line.replace("\"", "") if "- id:" in line: line = line[1:] # Ignore first dash stripped_line = line.strip() if stripped_line != "": # Adding to current entry split_line = stripped_line.split(':') entry[split_line[0].strip()] = ':'.join(split_line[1:]).strip() ln += 1 return entry_list def main(): """ Main function to process bibtex entries in a given path and output a file in yaml supported format. """ # Read in current entries lines = data_path.read_text(encoding='utf-8').split('\n') entries = process_yml_entries(lines) # Find new entries files = find_all_files(bib_path) for bibfile in files: entry = "" full_pth = Path(bibfile) lines = full_pth.read_text(encoding='utf-8').split('\n') line_number = 0 for line in lines: if "@" in line or line_number == len(lines)-1: # Starting a new entry if entry != "": entry = entry.translate({ord(c): None for c in '\\"{}~\'"'}) processed_entry = process_entry(entry) entries.append(processed_entry) entry = "" if "@" in line: line = line.replace("{", "=") stripped_line = line.strip() if stripped_line != "": # Adding to current entry if stripped_line.endswith(","): stripped_line = stripped_line[:-1] entry += stripped_line + "\n" line_number += 1 # Check for duplication duplicate_entries = [] for i in range(len(entries)-1): for j in range(i+1, len(entries)): if check_equality(entries[i], entries[j]): print("Duplicate found: " + entries[i]["id"] + " = " + entries[j]["id"]) duplicate_entries.append(j) duplicate_entries.sort() for i in range(len(duplicate_entries)): e = duplicate_entries[i] - i del entries[e] # Finally, save entries output_entries(entries) if __name__ == "__main__": main()

f80a066211d5845a2d19529db9ed13271bcad6dc

py

Python

browser.py

7Cortez7/instagram-giveaway-bot

43246e3ded06ea3a6cbf2ef20164b229fe90ee0e

browser.py

7Cortez7/instagram-giveaway-bot

43246e3ded06ea3a6cbf2ef20164b229fe90ee0e

browser.py

7Cortez7/instagram-giveaway-bot

43246e3ded06ea3a6cbf2ef20164b229fe90ee0e

from selenium import webdriver import time import userdata as udata import random randomUsers = set() class Browser: def __init__(self, link): self.link = link self.browser = webdriver.Chrome() Browser.Instagram(self) Browser.Login(self) Browser.goFollowers(self) def Instagram(self): self.browser.get(self.link) time.sleep(2) def goFollowers(self): self.browser.find_element_by_xpath("//*[@id=\"react-root\"]/section/main/div/header/section/ul/li[2]/a").click() time.sleep(5) Browser.scrollDown(self) followers = self.browser.find_elements_by_css_selector("._7UhW9.xLCgt.qyrsm.KV-D4.se6yk.T0kll") for follower in followers: randomUsers.add(follower.text) print("Çekiliş başlıyor! {totaluser} kişi katılmaya hak kazandı.".format(totaluser = len(randomUsers))) time.sleep(5) randomUsersList = list(randomUsers) print("Kazanan:", random.choice(randomUsersList)) time.sleep(5) exit() def scrollDown(self): jsCode = """ page = document.querySelector(".isgrP"); page.scrollTo(0, page.scrollHeight); var pageEnd = page.scrollHeight; return pageEnd; """ pageEnd = self.browser.execute_script(jsCode) while True: end = pageEnd time.sleep(1) pageEnd = self.browser.execute_script(jsCode) if end == pageEnd: break def Login(self): username = self.browser.find_element_by_name("username") password = self.browser.find_element_by_name("password") loginBtn = self.browser.find_element_by_css_selector("#loginForm > div > div:nth-child(3) > button > div") username.send_keys(udata.username) password.send_keys(udata.password) time.sleep(1) loginBtn.click() time.sleep(2) self.browser.get(self.link + udata.username) time.sleep(2)

f80b2ee49671a1d6b544de429dd777345fa6df27

py

Python

HackerRank/PythonHackerRankSolutions/Numpy/LinearAlgebra.py

accidentalgenius09/competitive-programming-solution

210746a7928dcd601ad9a735de52cf7135851070

2020-08-03T01:53:13.000Z

2022-01-09T14:47:58.000Z

HackerRank/PythonHackerRankSolutions/Numpy/LinearAlgebra.py

accidentalgenius09/competitive-programming-solution

210746a7928dcd601ad9a735de52cf7135851070

HackerRank/PythonHackerRankSolutions/Numpy/LinearAlgebra.py

accidentalgenius09/competitive-programming-solution

210746a7928dcd601ad9a735de52cf7135851070

2020-09-29T11:28:53.000Z

2021-06-02T15:34:55.000Z

''' Title : Linear Algebra Subdomain : Numpy Domain : Python Author : codeperfectplus Created : 10 May 2020 ''' import numpy n=int(input()) a=numpy.array([input().split() for _ in range(n)],float) print(round(numpy.linalg.det(a),2))

f80c608952146d7fe3d7ed75d5f4bc0dc27ba8ce

py

Python

pyretri/index/dim_processor/dim_processors_impl/l2_normalize.py

dongan-beta/PyRetri

8756d5d5813a5211b58855373b6c6cd33d7a11f6

2020-04-21T12:42:05.000Z

2022-03-31T06:32:50.000Z

pyretri/index/dim_processor/dim_processors_impl/l2_normalize.py

dongan-beta/PyRetri

8756d5d5813a5211b58855373b6c6cd33d7a11f6

2020-05-07T07:24:19.000Z

2022-02-02T23:49:23.000Z

pyretri/index/dim_processor/dim_processors_impl/l2_normalize.py

dongan-beta/PyRetri

8756d5d5813a5211b58855373b6c6cd33d7a11f6

2020-04-26T04:33:11.000Z

2022-03-17T02:58:45.000Z

# -*- coding: utf-8 -*- import numpy as np from ..dim_processors_base import DimProcessorBase from ...registry import DIMPROCESSORS from sklearn.preprocessing import normalize from typing import Dict, List @DIMPROCESSORS.register class L2Normalize(DimProcessorBase): """ L2 normalize the features. """ default_hyper_params = dict() def __init__(self, feature_names: List[str], hps: Dict or None = None): """ Args: feature_names (list): a list of features names to be loaded. hps (dict): default hyper parameters in a dict (keys, values). """ super(L2Normalize, self).__init__(feature_names, hps) def __call__(self, fea: np.ndarray) -> np.ndarray: return normalize(fea, norm="l2")

f80ccbd3e3b59f33892aafb3cc6b1f95f360dd40

py

Python

test_csv_write.py

wandyrandy/Groupme-Group-Stats-Report