Datasets:

jon-tow

/

starcoderdata-python-edu

like 4

gpypi/__init__.py

tastuteche/g-pypi-py3

12798951

<gh_stars>1-10 #!/usr/bin/env python # -*- coding: utf-8 -*- import pkg_resources __version__ = pkg_resources.get_distribution('g-pypi').version.replace('dev', '')

Codes/optimization/src/preprocess/calibration.py

dychen24/magx

12798952

<reponame>dychen24/magx import numpy as np from .data_reader import read_data def calibrate(path): data = read_data(path) # cut = int(data.shape[0]/10) # data = data[cut: -cut] nsensor = int(data.shape[1] / 3) offX = np.zeros(nsensor) offY = np.zeros(nsensor) offZ = np.zeros(nsensor) scaleX = np.zeros(nsensor) scaleY = np.zeros(nsensor) scaleZ = np.zeros(nsensor) for i in range(nsensor): mag = data[:, i * 3:i * 3 + 3] H = np.array([mag[:, 0], mag[:, 1], mag[:, 2], - mag[:, 1] ** 2, - mag[:, 2] ** 2, np.ones_like(mag[:, 0])]).T w = mag[:, 0] ** 2 tmp = np.matmul(np.linalg.inv(np.matmul(H.T, H)), H.T) X = np.matmul(np.linalg.inv(np.matmul(H.T, H)), H.T).dot(w) # print(X.shape) offX[i] = X[0] / 2 offY[i] = X[1] / (2 * X[3]) offZ[i] = X[2] / (2 * X[4]) temp = X[5] + offX[i] ** 2 + X[3] * offY[i]**2 + X[4] * offZ[i] ** 2 scaleX[i] = np.sqrt(temp) scaleY[i] = np.sqrt(temp / X[3]) scaleZ[i] = np.sqrt(temp / X[4]) offset = np.stack([offX, offY, offZ], axis=0).T offset = offset.reshape(1, -1) scale = np.stack([scaleX, scaleY, scaleZ], axis=0).T scale = scale.reshape(1, -1) return [offset, scale]

my_test/calc.py

irux/test-bump

12798953

def summcalc(a,b): return a+b

setup.py

PontusHultkrantz/tcapy

12798954

<filename>setup.py from setuptools import setup, find_packages long_description = """tcapy is a transaction cost analysis library for determining calculating your trading costs""" setup(name='tcapy', version='0.1.0', description='Tranasction cost analysis library', author='<NAME>', author_email='<EMAIL>', license='Apache 2.0', long_description=long_description, keywords=['pandas', 'TCA', 'transaction cost analysis'], url='https://github.com/cuemacro/tcapy', packages=find_packages(), include_package_data=True, install_requires=[], zip_safe=False)

gitScrabber/scrabTasks/report/easeOfUseEstimation.py

Eyenseo/gitScrabber

12798955

<reponame>Eyenseo/gitScrabber<filename>gitScrabber/scrabTasks/report/easeOfUseEstimation.py """ The MIT License (MIT) Copyright (c) 2017 <NAME> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ from ..scrabTask import ReportTask from utils import containedStructure name = "EaseOfUseEstimation" version = "1.0.0" class MissingManualData(Exception): """ Helper class to filter specific exceptions """ pass class Limit(): """ Convenience class to hold the upper and lower limits of the project sizes :param name: The name :param lower: The lower :param upper: The upper """ def __init__(self, name, lower, upper): self.name = name self.lower = lower self.upper = upper class ScoreData(): """ Convenience class that gathers the necessary data for the ease of use estimation for the projects. :param project_report: The project report to gather the data from """ def __init__(self, project_report): self.website = None self.download = None self.readme = None self.apis = None self.examples = None self.explanations = None self.high = None self.low = None self.__gather_existence(project_report) self.__gather_completness(project_report) self.__gather_interface_level(project_report) def __gather_existence(self, project_report): """ Gathers the documentation existence data :param project_report: The project report to gather the data from """ required = {'generalData': {'documentation': { 'exists': {'readme': False, 'website': False, 'download': False}}}} if (not containedStructure(required, project_report)): raise MissingManualData( "Data for the ease of use calculation is missing - " "generalData.documentation.exists.*" ) exists = project_report['generalData']['documentation']['exists'] self.download = exists['download'] self.readme = exists['readme'] self.website = exists['website'] def __gather_completness(self, project_report): """ Gathers the documentation completeness data :param project_report: The project report to gather the data from """ required = {'generalData': {'documentation': { 'completeness': {'apis': False, 'examples': False, 'explanations': False}}}} if (not containedStructure(required, project_report)): raise MissingManualData( "Data for the ease of use calculation is missing - " "generalData.documentation.completeness.*" ) comp = project_report['generalData']['documentation']['completeness'] self.apis = comp['apis'] self.examples = comp['examples'] self.explanations = comp['explanations'] def __gather_interface_level(self, project_report): """ Gathers the projects interface level data :param project_report: The project report to gather the data from """ required = {'generalData': {'interfaceLevel': {'high': False, 'low': False}}} if (not containedStructure(required, project_report)): raise MissingManualData( "Data for the ease of use calculation is missing - " "generalData.interfaceLevel.*" ) inter = project_report['generalData']['interfaceLevel'] self.high = inter['high'] self.low = inter['low'] class Weight(object): """ Convenience class that holds all weights needed for the ease of use estimation """ def __init__(self): self.website = 3 self.download = 2 self.readme = 1 self.apis = 3 self.examples = 2 self.explanations = 1 self.high_low = 6 self.high = 5 self.low = 1 class EaseOfUseEstimation(ReportTask): """ Class to estimate how easy it is to use a project. This is based on the following data: manual: generalData: documentation: exists: readme: false website: false download: false completeness: apis: false examples: false explanations: false interfaceLevel: high: true low: true Example: EaseOfUseEstimation: difficult :param parameter: Parameter given explicitly for this task, for all projects, defined in the task.yaml :param global_args: Arguments that will be passed to all tasks. They _might_ contain something that is useful for the task, but the task has to check if it is _there_ as these are user provided. If they are needed to work that check should happen in the argHandler. """ def __init__(self, parameter, global_args): super(EaseOfUseEstimation, self).__init__(name, version, parameter, global_args) self.__limits = [ Limit(name='easy', upper=24, lower=17), Limit(name='normal', upper=16, lower=9), Limit(name='difficult', upper=8, lower=1) ] self.__weight = Weight() def __estimate_ease_of_use(self, project_report): """ Estimates how easy it is to use a project. The basic formula is existence * (completeness + level) :param project_report: The project report containing the data to base the estimation on :returns: The ease of use score """ data = ScoreData(project_report) score = ( data.apis*self.__weight.apis + data.examples*self.__weight.examples + data.explanations*self.__weight.explanations ) if data.high and data.low: score += self.__weight.high_low elif data.high: score += self.__weight.high elif data.low: score += self.__weight.low if data.website: score *= self.__weight.website elif data.download: score *= self.__weight.download elif data.readme: score *= self.__weight.readme return score def scrab(self, report): """ The scrab task estimates how easy it is to use a project. :param report: The report to analyse _and_ change :returns: Report that contains all scrabbed information Example: EaseOfUseEstimation: difficult """ projects = report['projects'] try: for project in projects: project_report = projects[project] eou_score = self.__estimate_ease_of_use(project_report) if eou_score is None: continue for limit in self.__limits: if(eou_score <= limit.upper and eou_score >= limit.lower): projects[project]['EaseOfUseEstimation'] = limit.name except Exception as e: raise Exception( "While estimating ease of use for the project '{}' with " "the report\n{}".format( project, projects[project]) ) from e return report

neuro_evolutional_net/genetic_algorithm.py

DominikSpiljak/Fuzzy-Evolutionary-and-Neuro-computing

12798956

from individual import Individual class GeneticAlgorithm: def __init__(self, population_generation, num_iter, selection, combination, mutation, solution, goal_error): self.population_generation = population_generation self.num_iter = num_iter self.selection = selection self.combination = combination self.mutation = mutation self.solution = solution self.goal_error = goal_error def evolution(self, neural_net): # Template method population = self.population_generation() min_error = self.solution(population).error for i in range(self.num_iter): population, comb_population = self.selection(population) combined_population = self.combination(comb_population) mutated_population = self.mutation(combined_population) population.extend(mutated_population) iteration_min_error = self.solution(population).error if i % 1000 == 0: if iteration_min_error < min_error: min_error = iteration_min_error print("Found new best, iteration = {}, {}".format( i, self.solution(population))) if iteration_min_error < self.goal_error: print("Reached goal error, terminating.") break return self.solution(population)

pyanimate/__init__.py

martinmcbride/sympl

12798957

name = "pyanimate"

server/app/api/lib/notify.py

Lazarus118/virtual-queue

12798958

import twilio import twilio.rest class Notify(object): def __init__(self, account_sid, auth_token, phone_number): self.account_sid = account_sid self.auth_token = auth_token self.phone_number = phone_number def _request(self, to_number, message): try: client = twilio.rest.TwilioRestClient(self.account_sid, self.auth_token) message = client.messages.create( body=message, to=to_number, from_=self.phone_number ) except twilio.TwilioRestException as e: print e def send_message(self, to_number, message): return self._request(to_number, message)

custom_components/fritzbox_tools/binary_sensor.py

jloehr/ha-fritzbox-tools

12798959

<reponame>jloehr/ha-fritzbox-tools """AVM Fritz!Box connectivitiy sensor""" import logging from collections import defaultdict import datetime try: from homeassistant.components.binary_sensor import ENTITY_ID_FORMAT, BinarySensorEntity except ImportError: from homeassistant.components.binary_sensor import ENTITY_ID_FORMAT, BinarySensorDevice as BinarySensorEntity from homeassistant.config_entries import ConfigEntry from homeassistant.helpers.typing import HomeAssistantType from . import DATA_FRITZ_TOOLS_INSTANCE, DOMAIN _LOGGER = logging.getLogger(__name__) SCAN_INTERVAL = datetime.timedelta(seconds=60) async def async_setup_entry( hass: HomeAssistantType, entry: ConfigEntry, async_add_entities ) -> None: _LOGGER.debug("Setting up sensors") fritzbox_tools = hass.data[DOMAIN][DATA_FRITZ_TOOLS_INSTANCE][entry.entry_id] if "WANIPConn1" in fritzbox_tools.connection.services: """ We do not support repeaters at the moment """ async_add_entities([FritzBoxConnectivitySensor(fritzbox_tools)], True) return True class FritzBoxConnectivitySensor(BinarySensorEntity): name = "FRITZ!Box Connectivity" icon = "mdi:router-wireless" device_class = "connectivity" def __init__(self, fritzbox_tools): self.fritzbox_tools = fritzbox_tools self.entity_id = ENTITY_ID_FORMAT.format(f"fritzbox_{self.fritzbox_tools.fritzbox_model}_connectivity") self._is_on = True # We assume the fritzbox to be online initially self._is_available = ( True # set to False if an error happend during toggling the switch ) self._attributes = defaultdict(str) super().__init__() @property def is_on(self) -> bool: return self._is_on @property def unique_id(self): return f"{self.fritzbox_tools.unique_id}-{self.entity_id}" @property def device_info(self): return self.fritzbox_tools.device_info @property def available(self) -> bool: return self._is_available @property def device_state_attributes(self) -> dict: return self._attributes async def _async_fetch_update(self): self._is_on = True try: if "WANCommonInterfaceConfig1" in self.fritzbox_tools.connection.services: connection = lambda: self.fritzbox_tools.connection.call_action("WANCommonInterfaceConfig1", "GetCommonLinkProperties")["NewPhysicalLinkStatus"] is_up = await self.hass.async_add_executor_job(connection) self._is_on = is_up == "Up" else: self._is_on = self.hass.async_add_executor_job(self.fritzbox_tools.fritzstatus.is_connected) self._is_available = True status = self.fritzbox_tools.fritzstatus uptime_seconds = await self.hass.async_add_executor_job(lambda: getattr(status, "uptime")) last_reconnect = datetime.datetime.now() - datetime.timedelta(seconds=uptime_seconds) self._attributes["last_reconnect"] = last_reconnect.replace(microsecond=0).isoformat() for attr in [ "modelname", "external_ip", "external_ipv6", ]: self._attributes[attr] = await self.hass.async_add_executor_job(lambda: getattr(status, attr)) except Exception: _LOGGER.error("Error getting the state from the FRITZ!Box", exc_info=True) self._is_available = False async def async_update(self) -> None: _LOGGER.debug("Updating Connectivity sensor...") await self._async_fetch_update()

solutions/python3/667.py

sm2774us/amazon_interview_prep_2021

12798960

class Solution: def constructArray(self, n, k): """ :type n: int :type k: int :rtype: List[int] """ left, right, res = 0, n+1, [None]*n for i in range(n): if k == 1: if i%2 == 0: while i<n: res[i], right, i = right - 1, right - 1, i + 1 else: while i<n: res[i], left, i = left + 1, left + 1, i + 1 return res else: if i%2 != 0: res[i], right = right - 1, right - 1 else: res[i], left = left + 1, left + 1 if i != 0: k -= 1

mozi/layers/normalization.py

hycis/Mozi

12798961

<gh_stars>100-1000 from mozi.layers.template import Template from mozi.utils.theano_utils import shared_zeros, sharedX, shared_ones from mozi.weight_init import UniformWeight import theano.tensor as T import theano class BatchNormalization(Template): def __init__(self, dim, layer_type, gamma_init=UniformWeight(), short_memory=0.01): ''' REFERENCE: Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift PARAMS: short_memory: short term memory y_t is the latest value, the moving average x_tp1 is calculated as x_tp1 = memory * y_t + (1-memory) * x_t, the larger the short term memory, the more weight is put on contempory. layer_type: fc or conv epsilon: denominator min value for preventing division by zero in computing std dim: for fc layers, shape is the layer dimension, for conv layers, shape is the number of feature maps ''' assert layer_type in ['fc', 'conv'] self.layer_type = layer_type self.epsilon = 1e-6 self.dim = dim self.mem = short_memory if self.layer_type == 'fc': input_shape = (1, dim) self.broadcastable = (True, False) elif self.layer_type == 'conv': input_shape = (1, dim, 1, 1) self.broadcastable = (True, False, True, True) self.gamma = gamma_init(input_shape, name='gamma') self.beta = shared_zeros(input_shape, name='beta') self.params = [self.gamma, self.beta] self.moving_mean = 0 self.moving_var = 1 def _train_fprop(self, state_below): if self.layer_type == 'fc': miu = state_below.mean(axis=0) var = T.mean((state_below - miu)**2, axis=0) elif self.layer_type == 'conv': miu = state_below.mean(axis=(0,2,3), keepdims=True) var = T.mean((state_below - miu)**2, axis=(0,2,3), keepdims=True) self.moving_mean = self.mem * miu + (1-self.mem) * self.moving_mean self.moving_var = self.mem * var + (1-self.mem) * self.moving_var Z = (state_below - self.moving_mean) / T.sqrt(self.moving_var + self.epsilon) gamma = T.patternbroadcast(self.gamma, self.broadcastable) beta = T.patternbroadcast(self.beta, self.broadcastable) return gamma * Z + beta def _test_fprop(self, state_below): Z = (state_below - self.moving_mean) / T.sqrt(self.moving_var + self.epsilon) gamma = T.patternbroadcast(self.gamma, self.broadcastable) beta = T.patternbroadcast(self.beta, self.broadcastable) return gamma * Z + beta def _layer_stats(self, state_below, layer_output): return [('moving_mean', T.mean(self.moving_mean)), ('moving_std', T.mean(self.moving_var)), ('gamma_mean', T.mean(self.gamma)), ('beta_mean', T.mean(self.beta)), ('gamma_max', T.max(self.gamma))] # class LRN(Template): # """ # Adapted from pylearn2 # Local Response Normalization # """ # # def __init__(self, n=5, alpha=0.0001, beta=0.75, k=2): # super(LRN, self).__init__() # self.n = n # self.alpha = alpha # self.beta = beta # self.k = k # assert self.n % 2 == 1, 'only odd n is supported' # # def _train_fprop(self, state_below): # half = self.n / 2 # sq = T.sqr(state_below) # b, ch, r, c = state_below.shape # extra_channels = T.alloc(0., b, ch + 2*half, r, c) # sq = T.set_subtensor(extra_channels[:,half:half+ch,:,:], sq) # scale = self.k # # for i in xrange(self.n): # scale += self.alpha * sq[:,i:i+ch,:,:] # # scale = scale ** self.beta # return state_below / scale # # def _test_fprop(self, state_below): # return self._train_fprop(state_below)

task1/learning.py

EgorOrachyov/MachineLearning

12798962

from csv import reader from sklearn import preprocessing from plotly import graph_objects def import_data(path): return [[float(f) for f in r] for r in reader(open(path, "r"))] def normalize_data(dataset): scaler = preprocessing.MinMaxScaler(feature_range=(0,1)) normalized = scaler.fit_transform(dataset) return normalized.tolist() def cross_validation_split(dataset, cross_validation_k): size = len(dataset) splits = [int(size / cross_validation_k) for _ in range(cross_validation_k)] splits[cross_validation_k - 1] = size - sum(splits[0:cross_validation_k-1]) sets = list() offset = 0 for s in splits: sets.append([dataset[i] for i in range(offset, offset + s)]) offset += s return sets def compute_y(model, row): m = len(row) y = 0.0 for i in range(m): y += row[i] * model[i] return y + model[m] def compute_grad_mse(model, row, actual): m = len(row) grad = [0.0 for _ in range(m + 1)] diff = compute_y(model, row) - actual for i in range(m): grad[i] += 2.0 * row[i] * diff grad[m] += 2.0 * diff return grad def learn_stochastic_gradient_decent_mse(fold, actuals, learning_rate, iterations_count): m = len(fold[0]) model = [0.0 for _ in range(m + 1)] for i in range(iterations_count): for j in range(len(fold)): row = fold[j] actual = actuals[j] grad = compute_grad_mse(model, row, actual) model = [model[k] - learning_rate / (1 + i) * grad[k] for k in range(m + 1)] return model def compute_rmse(prediction, actual): mse = 0.0 n = len(prediction) for i in range(n): mse += ((prediction[i] - actual[i]) ** 2) / float(n) return mse ** 0.5 def compute_r2(prediction, actual): nominator = 0.0 denominator = 0.0 expect = 0.0 for i in range(len(actual)): nominator += (actual[i] - prediction[i]) ** 2 for i in range(len(actual)): expect += actual[i] / float(len(actual)) for i in range(len(actual)): denominator += (actual[i] - expect) ** 2 return 1 - float(nominator) / float(denominator) def run_learning(sets, learning_rate, iterations_count): models = [] rmses = [] r2s = [] rmses_test = [] r2s_test = [] for set in sets: fold = list(sets) fold.remove(set) fold = sum(fold, []) test = set fold_actual = [r[-1] for r in fold] fold = [r[0:-1] for r in fold] test_actual = [r[-1] for r in test] test = [r[0:-1] for r in test] model = learn_stochastic_gradient_decent_mse(fold, fold_actual, learning_rate, iterations_count) fold_pred = [compute_y(model, row) for row in fold] test_pred = [compute_y(model, row) for row in test] rmses.append(compute_rmse(fold_pred, fold_actual)) r2s.append(compute_r2(fold_pred, fold_actual)) rmses_test.append(compute_rmse(test_pred, test_actual)) r2s_test.append(compute_r2(test_pred, test_actual)) models.append(model) return models, rmses, r2s, rmses_test, r2s_test def compute_stat(data): n = len(data) expectation = 0.0 for d in data: expectation += d / float(n) sd = 0.0 for d in data: sd += ((d - expectation) ** 2) / float(n) return expectation, sd ** 0.5 filepath = "features_var_1.csv" cv_k = 5 learn_rate = 0.01 iterations = 50 dataset = normalize_data(import_data(filepath)) sets = cross_validation_split(dataset, cv_k) models, rmse_train, r2_train, rmse_test, r2_test = run_learning(sets, learn_rate, iterations) models_tr = [[models[i][j] for i in range(cv_k)] for j in range(len(dataset[0]))] stats = [compute_stat(data) for data in [rmse_train, r2_train, rmse_test, r2_test] + models_tr] values = ["X"] + ["Fold" + str(i) for i in range(cv_k)] + ["E","SD"] cells = [ ["RMSE (train)", "R2 (train)", "RMSE (test)", "R2 (test)"] + ["f" + str(i) for i in range(len(dataset[0]))] ] + \ [ [rmse_train[i], r2_train[i], rmse_test[i], r2_test[i]] + models[i] for i in range(cv_k) ] + \ [ [stats[j][i] for j in range(len(stats))] for i in range(2) ] table = graph_objects.Table(header=dict(values=values), cells=dict(values=cells)) figure = graph_objects.Figure(data=[table]) figure.show()

Week 02/summationerror_BSW.py

bswood9321/PHYS-3210

12798963

<reponame>bswood9321/PHYS-3210 # -*- coding: utf-8 -*- """ Spyder Editor This is a temporary script file. """ import numpy as np import matplotlib.pyplot as plt N = int(input("Pick a number: ")) n, a, sum1, m, b, sum2 = 1, 0, 0, N, 0, 0 while (n<=N): a = 1/n sum1+=a n = n+1 while (m>=1): b = 1/m sum2+=b m = m-1 error = (sum1 - sum2)/(np.absolute(sum1)+np.absolute(sum2)) print("For N = :",N,", the error is: ",error) N1=1 Ns=[] Errors=[] while N1<=N: n1, a1, sum11, m1, b1, sum21 = 1, 0, 0, N1, 0, 0 while (n1<=N1): a1 = 1/n1 sum11+=a1 n1 = n1+1 while (m1>=1): b1 = 1/m1 sum21+=b1 m1 = m1-1 Ns.append(N1) error1 = (sum11 - sum21)/(np.absolute(sum11)+np.absolute(sum21)) Errors.append(error1) N1=N1+1 plt.plot(Ns,Errors,'r-') plt.xlabel("N") plt.ylabel("Error(x10^-16)") plt.title("N vs. Error") plt.show() print("The down summation is more precise because the error of the number is proportional to the number you are summing, therefore as the number decreases, there is less error, versus starting with a small number, and adding more error for every summation.")

imix/models/vqa_models/lxmert/lxmert_task.py

linxi1158/iMIX

12798964

<gh_stars>0 from imix.models.builder import VQA_MODELS import torch import copy ''' from transformers.modeling_bert import ( BertConfig, BertEmbeddings, BertEncoder, # BertLayerNorm, BertPreTrainedModel, ) ''' from .lxmert import LXMERTForPretraining from imix.models.vqa_models.base_model import BaseModel from .lxmert_qa_answer_table import load_lxmert_qa import json from .lxmert import ClassificationModel @VQA_MODELS.register_module() class LXMERT(BaseModel): def __init__(self, **kwargs): super().__init__() args = kwargs['params'] freeze_base = args['freeze_base'] training_head_type = args['training_head_type'] self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') if training_head_type == 'pretraining': self.model = LXMERTForPretraining(**args) self.forward_train = self.forward_train_pretrain else: self.model = ClassificationModel(**args) pretrained_path = args['pretrained_path'] if pretrained_path is not None: if training_head_type in ['vqa2', 'gqa']: self.label2ans = json.load(open(args.label2ans_path)) load_lxmert_qa(pretrained_path, self.model, label2ans=self.label2ans) elif training_head_type == 'nlvr2': self.model.lxrt_encoder.load(pretrained_path) if freeze_base: for p in self.model.bert.parameters(): p.requires_grad = False def forward_train(self, data, **kwargs): # ques_id = data['ques_id'].to(self.device) feats = data['feats'].to(self.device) boxes = data['boxes'].to(self.device) sent = data['ques'] target = data['target'].to(self.device) output_dict = self.model(feats, boxes, sent) model_output = { 'scores': output_dict['scores'], 'target': target, } return model_output def forward_test(self, data): model_output = self.forward_train(data) return model_output def forward_train_pretrain(self, data): params = copy.deepcopy(data) if params.get('feats') is not None and params.get('image_dim') is not None: image_mask = (torch.arange(params['feats'].size(-2)).expand(*params['feats'].size()[:-1])) if len(params['image_dim'].size()) < len(image_mask.size()): params['image_dim'] = data['image_dim'].unsqueeze(-1) assert len(params['image_dim'].size()) == len(image_mask.size()) image_mask = image_mask < params['image_dim'] params['visual_attention_mask'] = image_mask.long() else: params['visual_attention_mask'] = None output_dict = self.model( input_ids=params['input_ids'].cuda(), token_type_ids=params['segment_ids'].cuda(), attention_mask=params['input_mask'].cuda(), visual_feats=params['feats'].cuda(), visual_pos=params['pos'].cuda(), visual_attention_mask=params['visual_attention_mask'].cuda() if params['visual_attention_mask'] is not None else params['visual_attention_mask'], ) target_dict = { 'masked_lm_labels': params['lm_label_ids'].cuda(), 'matched_label': params['is_matched'].cuda(), 'ans': params['ans'].cuda(), 'obj_labels': { 'obj': (params['det_obj_labels'].cuda(), params['det_obj_confs'].cuda()), 'attr': (params['det_attr_labels'].cuda(), params['det_attr_confs'].cuda()), 'feat': (params['det_feat'].cuda(), params['det_feat_mask'].cuda()), } } model_output = {'scores': output_dict, 'target': target_dict} return model_output

srun.py

qaqcxh/lectureHack

12798965

#!/bin/python3 from selenium import webdriver from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.common.by import By from selenium.webdriver.support import expected_conditions as EC from selenium.common.exceptions import NoSuchElementException import sys,os options = webdriver.ChromeOptions() options.add_argument('--ignore-certificate-errors') options.add_argument('--headless') options.add_argument('--no-sandbox') options.add_argument('--disable-gpu') browser = webdriver.Chrome(options=options) browser.get("http://172.16.31.10/") try: browser.find_element_by_xpath('//*[@id="logout"]') print('网络已连接!') browser.quit() sys.exit() except NoSuchElementException: pass username_='2020xxxxxxxxxxx' password_='<PASSWORD>' # 输入用户名,密码 username = browser.find_element_by_xpath('//*[@id="username"]') password = browser.find_element_by_xpath('//*[@id="password"]') username.clear() username.send_keys(username_) password.clear() password.send_keys(password_) login_btn = browser.find_element_by_xpath('//*[@id="login-account"]') login_btn.click() try: # 页面一直循环，直到显示连接成功 element = WebDriverWait(browser, 10).until( EC.presence_of_element_located((By.XPATH, '//*[@id="logout"]')) ) print("网络已连接!") finally: browser.quit() browser.quit()

users/migrations/0005_auto_20190911_2212.py

nhy17-thu/ImageProcessingWebsite

12798966

# Generated by Django 2.2.4 on 2019-09-11 14:12 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('users', '0004_auto_20190907_1334'), ] operations = [ migrations.AddField( model_name='pic', name='classification152', field=models.TextField(blank=True), ), migrations.AddField( model_name='pic', name='classification18', field=models.TextField(blank=True), ), migrations.AddField( model_name='pic', name='transfer', field=models.ImageField(blank=True, upload_to=''), ), ]

project_2/scripts/graph.py

jsbruglie/adrc

12798967

<gh_stars>0 import prio_dict class Graph: def __init__(self): self.vertices = {} def __str__(self): return str([key for key in self.vertices.keys()]) def __iter__(self): return iter(self.vertices.values()) def add_vertex(self, node): self.vertices[node] = {} def get_vertex(self, node): if node in self.vertices: return self.vertices[node] else: return None def get_vertices(self): return self.vertices.keys() def add_edge(self, src, dst, weight=0): if src not in self.vertices: self.add_vertex(src) if dst not in self.vertices: self.add_vertex(dst) self.vertices[src][dst] = weight def find_path(self, src, dst, path=None): if path is None: path = [] graph = self.vertices path = path + [src] if src == dst: return path if src not in graph: return None for v in graph[src]: if v not in path: temp = self.find_path(v, dst, path) if temp: return temp return None def find_all_paths(self, src, dst, path=None): if path is None: path = [] graph = self.vertices path = path + [src] if src == dst: return [path] if src not in graph: return [] paths = [] for v in graph[src]: if v not in path: temp = self.find_all_paths(v, dst, path) for p in temp: paths.append(p) return paths def find_shortest_path(self, src, dst, path=None): if path is None: path = [] graph = self.vertices path = path + [src] if src == dst: return path if src not in graph: return None shortest_path = None for v in graph[src]: if v not in path: temp = self.find_shortest_path(v, dst, path) if temp: if not shortest_path or len(temp) < len(shortest_path): shortest_path = temp return shortest_path def is_connected(self, visited=None, src=None): if visited is None: visited = set() graph = self.vertices vertices = list(graph.keys()) if src is None: src = vertices[0] visited.add(src) if len(visited) != len(vertices): for v in graph[src]: if v not in visited: if self.is_connected(visited, v): return True else: return True return False def Dijkstra(self, G, src, dst=None): D = {} P = {} Q = prio_dict.PriorityDictionary() Q[src] = 0 for v in Q: D[v] = Q[v] if v == dst: break for w in G[v]: vw_length = D[v] + G[v][w] if w in D: if vw_length < D[w]: raise ValueError elif w not in Q or vw_length < Q[w]: Q[w] = vw_length P[w] = v return (D,P) def shortest_path(self, G, src, dst): D,P = self.Dijkstra(G, src, dst) path = [] while True: path.append(dst) if dst == src: break dst = P[dst] path.reverse() return path

algorithms/289. Game of Life.py

woozway/py3-leetcode

12798968

<reponame>woozway/py3-leetcode<gh_stars>1-10 """ 1. Clarification 2. Possible solutions - Simulation v1 - Simulation optimised v2 3. Coding 4. Tests """ # T=O(m*n), S=O(m*n) class Solution: def gameOfLife(self, board: List[List[int]]) -> None: neighbors = [(1,0), (1,-1), (0,-1), (-1,-1), (-1,0), (-1,1), (0,1), (1,1)] rows = len(board) cols = len(board[0]) copy_board = [[board[row][col] for col in range(cols)] for row in range(rows)] for row in range(rows): for col in range(cols): live_neighbors = 0 for neighbor in neighbors: r = (row + neighbor[0]) c = (col + neighbor[1]) if (rows > r >= 0) and (cols > c >= 0) and (copy_board[r][c] == 1): live_neighbors += 1 if copy_board[row][col] == 1 and (live_neighbors < 2 or live_neighbors > 3): board[row][col] = 0 if copy_board[row][col] == 0 and live_neighbors == 3: board[row][col] = 1 # T=O(m*n), S=O(1) class Solution: def gameOfLife(self, board: List[List[int]]) -> None: neighbors = [(1,0), (1,-1), (0,-1), (-1,-1), (-1,0), (-1,1), (0,1), (1,1)] rows = len(board) cols = len(board[0]) copy_board = [[board[row][col] for col in range(cols)] for row in range(rows)] for row in range(rows): for col in range(cols): live_neighbors = 0 for neighbor in neighbors: r = (row + neighbor[0]) c = (col + neighbor[1]) if (rows > r >= 0) and (cols > c >= 0) and (copy_board[r][c] == 1): live_neighbors += 1 if copy_board[row][col] == 1 and (live_neighbors < 2 or live_neighbors > 3): board[row][col] = 0 if copy_board[row][col] == 0 and live_neighbors == 3: board[row][col] = 1

src/dbxdeploy/package/PackageDependencyLoader.py

Kukuksumusu/dbx-deploy

12798969

<reponame>Kukuksumusu/dbx-deploy import tomlkit from tomlkit.items import Table from typing import List from pathlib import Path from dbxdeploy.package.Dependency import Dependency from dbxdeploy.package.RequirementsLineConverter import RequirementsLineConverter from dbxdeploy.package.RequirementsGenerator import RequirementsGenerator from dbxdeploy.package.RequirementsConfig import RequirementsConfig class PackageDependencyLoader: def __init__( self, requirements_line_converter: RequirementsLineConverter, requirements_generator: RequirementsGenerator, ): self.__requirements_generator = requirements_generator self.__requirements_line_converter = requirements_line_converter def load(self, project_base_dir: Path) -> List[Dependency]: poetry_lock_path = project_base_dir.joinpath("poetry.lock") poetry_lock_dependencies = self.__load_poetry_lock_dependencies(poetry_lock_path) main_dependencies = self.__load_main_dependencies() dependencies = [] for dependency in main_dependencies: dependency_name = dependency[0] dependencies.append( Dependency(dependency_name, self.__find_poetry_lock_version_by_name(poetry_lock_dependencies, dependency_name)) ) return dependencies def __load_main_dependencies(self) -> list: requirements_config = RequirementsConfig() requirements_config.exclude_index_info() requirements_txt = self.__requirements_generator.generate(requirements_config) return list(map(self.__requirements_line_converter.parse, requirements_txt.splitlines())) def __load_poetry_lock_dependencies(self, lockfile_path: Path) -> List[Table]: with lockfile_path.open("r") as f: config = tomlkit.parse(f.read()) return [package for package in config["package"] if package["category"] == "main" and package["name"]] def __find_poetry_lock_version_by_name(self, dependencies: List[Table], dependency_name: str) -> str: for dependency in dependencies: if dependency["name"].lower() == dependency_name.lower(): return dependency["version"] raise Exception(f"Dependency {dependency_name} not found in poetry.lock")

open_spiel/python/mfg/algorithms/EGTA/egta.py

wyz2368/open_spiel

12798970

# Copyright 2019 DeepMind Technologies Ltd. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ The trainer of EGTA for mean field game.""" from open_spiel.python.mfg.algorithms import distribution from open_spiel.python.mfg.algorithms.EGTA import meta_strategies from open_spiel.python.mfg.algorithms.EGTA import inner_loop from open_spiel.python.mfg.algorithms.EGTA import init_oracle class MFGMetaTrainer(object): """ Empirical game-theoretic analysis (EGTA) for MFGs. """ def __init__(self, mfg_game, oracle_type, num_inner_iters=None, initial_policy=None, meta_strategy_method="nash", **kwargs): """ Initialize the MFG Trainer. :param mfg_game: a mean-field game. :param oracle_type: "BR" exact best response or "DQN" RL approximate best response. :param num_inner_iters: the number of iterations for the inner loop (finding BR target based on the empirical game) if needed. :param initial_policies: initial policies. Uniform policies by default. :param meta_strategy_method: method for the inner loop. """ self._mfg_game = mfg_game self._oracle_type = oracle_type self._num_players = mfg_game.num_players() self._num_inner_iters = num_inner_iters self._initial_policy = initial_policy self._meta_strategy_method = meta_strategy_method self.initialize_policies_and_distributions() #TODO: check if policy and dist are being updated. self._meta_strategy_method = meta_strategies.MFG_META_STRATEGY_METHODS[meta_strategy_method](mfg_game=mfg_game, policies=self._policies, distributions=self._distributions, num_iterations=num_inner_iters) self._inner_loop = inner_loop.InnerLoop(self._meta_strategy_method) self._output_policy = None self._current_outer_iter = 0 def initialize_policies_and_distributions(self): """ Initialize policies and corresponding distributions. """ if self._oracle_type == "BR": self._oracle, self._policies, self._distributions = init_oracle.init_br_oracle(game=self._mfg_game, initial_policy=self._initial_policy) elif self._oracle_type == "DQN": raise NotImplementedError else: raise ValueError("Suggested oracle has not been implemented.") def reset(self): """ Reset the trainer. """ self._current_outer_iter = 0 self.initialize_policies_and_distributions() self._meta_strategy_method = meta_strategies.MFG_META_STRATEGY_METHODS[self._meta_strategy_method](mfg_game=self._mfg_game, policies=self._policies, distributions=self._distributions, num_iterations=self._num_inner_iters) self._inner_loop = inner_loop.InnerLoop(self._meta_strategy_method) self._output_policy = None def iteration(self): """ Main training iteration. """ self._current_outer_iter += 1 self._meta_strategy_method.reset() self._output_policy = self._inner_loop.run_inner_loop() self.update_policies(self._output_policy) def final_step(self): """ Final analysis of all generated policies. """ self._meta_strategy_method.reset() self._output_policy = self._inner_loop.run_inner_loop() def update_policies(self, output_merged_policy): """ Adding new best-response policies to the empirical game. :param output_merged_policy: a merged policy induced by inner loop. :return: """ output_distribution = distribution.DistributionPolicy(self._mfg_game, output_merged_policy) greedy_pi = self._oracle(self._mfg_game, output_distribution) self._policies.append(greedy_pi) self._distributions.append(distribution.DistributionPolicy(self._mfg_game, greedy_pi)) def get_original_policies_and_weights(self): """ Return original policies in the empirical game and corresponding output mixed strategies. """ weights = self._meta_strategy_method.get_weights_on_orig_policies() return self._policies, weights def get_merged_policy(self): """ Return the output merged policy. Equivalent to merge policies and weights from get_original_policies_and_weights(). """ return self._output_policy def get_policies(self): return self._policies def get_distrbutions(self): return self._distributions

OpenGLCffi/GLX/EXT/SGI/swap_control.py

cydenix/OpenGLCffi

12798971

<reponame>cydenix/OpenGLCffi<filename>OpenGLCffi/GLX/EXT/SGI/swap_control.py from OpenGLCffi.GLX import params @params(api='glx', prms=['interval']) def glXSwapIntervalSGI(interval): pass

snsim/io_utils.py

bcarreres/snsim

12798972

<reponame>bcarreres/snsim """This module contains io stuff.""" import os import warnings import pickle import pandas as pd import numpy as np try: import json import pyarrow as pa import pyarrow.parquet as pq json_pyarrow = True except ImportError: json_pyarrow = False from . import salt_utils as salt_ut class NpEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, np.integer): return int(obj) elif isinstance(obj, np.floating): return float(obj) elif isinstance(obj, np.ndarray): return obj.tolist() else: return super(NpEncoder, self).default(obj) def write_sim(wpath, name, formats, header, data): """Write simulated lcs. Parameters ---------- wpath : str The path where to write file. name : str Simulation name. formats : np.array(str) List of files fopprmats to write. header : dict The simulation header. data : pandas.DataFrame Dataframe containing lcs. Returns ------- None Just write files. """ # Export lcs as pickle if 'pkl' in formats: with open(wpath + name + '.pkl', 'wb') as file: pkl_dic = {'name': name, 'lcs': data.to_dict(), 'meta': data.attrs, 'header': header} pickle.dump(pkl_dic, file) if 'parquet' in formats and json_pyarrow: lcs = pa.Table.from_pandas(data) lcmeta = json.dumps(data.attrs, cls=NpEncoder) header = json.dumps(header, cls=NpEncoder) meta = {'name'.encode(): name.encode(), 'attrs'.encode(): lcmeta.encode(), 'header'.encode(): header.encode()} lcs = lcs.replace_schema_metadata(meta) pq.write_table(lcs, wpath + name + '.parquet') elif 'parquet' in formats and not json_pyarrow: warnings.warn('You need pyarrow and json modules to use .parquet format', UserWarning) def read_sim_file(file_path): """Read a sim file. Parameters ---------- file_path : str Path of the file. Returns ------- str, dict, pandas.DataFrame The name, the header and the lcs of the simulation. """ file_path, file_ext = os.path.splitext(file_path) if file_ext == '.pkl': with open(file_path + file_ext, 'rb') as f: pkl_dic = pickle.load(f) lcs = pd.DataFrame.from_dict(pkl_dic['lcs']) lcs.index.set_names(['ID', 'epochs'], inplace=True) lcs.attrs = pkl_dic['meta'] name = pkl_dic['name'] header = pkl_dic['header'] elif file_ext == '.parquet': if json_pyarrow: table = pq.read_table(file_path + file_ext) lcs = table.to_pandas() lcs.set_index(['ID', 'epochs'], inplace=True) lcs.attrs = {int(k): val for k, val in json.loads(table.schema.metadata['attrs'.encode()]).items()} name = table.schema.metadata['name'.encode()].decode() header = json.loads(table.schema.metadata['header'.encode()]) else: warnings.warn("You need pyarrow and json module to write parquet formats", UserWarning) return name, header, lcs def write_fit(sim_lcs_meta, fit_res, directory, sim_meta={}): """Write fit into a fits file. Parameters ---------- sim_lcs_meta : dict{list} Meta data of all lightcurves. fit_res : list(sncosmo.utils.Result) List of sncosmo fit results for each lightcurve. directory : str Destination of write file. sim_meta : dict General simulation meta data. Returns ------- None Just write a file. """ data = sim_lcs_meta.copy() fit_keys = ['t0', 'e_t0', 'chi2', 'ndof'] MName = sim_meta['model_name'] if MName[:5] in ('salt2', 'salt3'): fit_keys += ['x0', 'e_x0', 'mb', 'e_mb', 'x1', 'e_x1', 'c', 'e_c', 'cov_x0_x1', 'cov_x0_c', 'cov_mb_x1', 'cov_mb_c', 'cov_x1_c'] for k in fit_keys: data[k] = [] for obj_ID in fit_res: fd = fit_res[obj_ID]['params'] snc_out = fit_res[obj_ID]['snc_out'] if snc_out != 'NaN': data['t0'].append(fd['t0']) data['e_t0'].append(np.sqrt(snc_out['covariance'][0, 0])) if MName[:5] in ('salt2', 'salt3'): par_cov = snc_out['covariance'][1:, 1:] mb_cov = salt_ut.cov_x0_to_mb(fd['x0'], par_cov) data['x0'].append(fd['x0']) data['e_x0'].append(np.sqrt(par_cov[0, 0])) data['mb'].append(fd['mb']) data['e_mb'].append(np.sqrt(mb_cov[0, 0])) data['x1'].append(fd['x1']) data['e_x1'].append(np.sqrt(par_cov[1, 1])) data['c'].append(fd['c']) data['e_c'].append(np.sqrt(par_cov[2, 2])) data['cov_x0_x1'].append(par_cov[0, 1]) data['cov_x0_c'].append(par_cov[0, 2]) data['cov_x1_c'].append(par_cov[1, 2]) data['cov_mb_x1'].append(mb_cov[0, 1]) data['cov_mb_c'].append(mb_cov[0, 2]) data['chi2'].append(snc_out['chisq']) data['ndof'].append(snc_out['ndof']) else: for k in fit_keys: data[k].append(np.nan) for k, v in sim_lcs_meta.items(): data[k] = v df = pd.DataFrame(data) table = pa.Table.from_pandas(df) header = json.dumps(sim_meta, cls=NpEncoder) table = table.replace_schema_metadata({'header'.encode(): header.encode()}) pq.write_table(table, directory + '.parquet') print(f"Fit result output file : {directory}.parquet") def open_fit(file): """USe to open fit file. Parameters ---------- file : str Fit results parquet file Returns ------- pandas.DataFrame The fit results. """ table = pq.read_table(file) fit = table.to_pandas() fit.attrs = json.loads(table.schema.metadata['header'.encode()]) fit.set_index(['ID'], inplace=True) return fit

submission_json.py

selva604/DA_TBN

12798973

<filename>submission_json.py import json from pathlib import Path import numpy as np import pandas as pd from epic_kitchens.meta import training_labels, test_timestamps def softmax(x): ''' >>> res = softmax(np.array([0, 200, 10])) >>> np.sum(res) 1.0 >>> np.all(np.abs(res - np.array([0, 1, 0])) < 0.0001) True >>> res = softmax(np.array([[0, 200, 10], [0, 10, 200], [200, 0, 10]])) >>> np.sum(res, axis=1) array([ 1., 1., 1.]) >>> res = softmax(np.array([[0, 200, 10], [0, 10, 200]])) >>> np.sum(res, axis=1) array([ 1., 1.]) ''' if x.ndim == 1: x = x.reshape((1, -1)) max_x = np.max(x, axis=1).reshape((-1, 1)) exp_x = np.exp(x - max_x) return exp_x / np.sum(exp_x, axis=1).reshape((-1, 1)) def top_scores(scores): top_n_scores_idx = np.argsort(scores)[:, ::-1] top_n_scores = scores[np.arange(0, len(scores)).reshape(-1, 1), top_n_scores_idx] return top_n_scores_idx, top_n_scores def compute_action_scores(verb_scores, noun_scores, n=100): top_verbs, top_verb_scores = top_scores(verb_scores) top_nouns, top_noun_scores = top_scores(noun_scores) top_verb_probs = softmax(top_verb_scores) top_noun_probs = softmax(top_noun_scores) action_probs_matrix = top_verb_probs[:, :n, np.newaxis] * top_noun_probs[:, np.newaxis, :] instance_count = action_probs_matrix.shape[0] action_ranks = action_probs_matrix.reshape(instance_count, -1).argsort(axis=-1)[:, ::-1] verb_ranks_idx, noun_ranks_idx = np.unravel_index(action_ranks[:, :n], dims=(action_probs_matrix.shape[1:])) # TODO: Reshape, argsort, then convert back to verb/noun indices segments = np.arange(0, instance_count).reshape(-1, 1) return ((top_verbs[segments, verb_ranks_idx], top_nouns[segments, noun_ranks_idx]), action_probs_matrix.reshape(instance_count, -1)[segments, action_ranks[:, :n]]) def action_scores_to_json(actions, scores, prior): entries = [] for verbs, nouns, segment_scores in zip(*actions, scores): if prior is None: entries.append({"{},{}".format(verb, noun): float(score) for verb, noun, score in zip(verbs, nouns, segment_scores)}) else: entries.append({"{},{}".format(verb, noun): (float(prior[(verb, noun)]) if (verb, noun) in prior else 0.0) * float(score) for verb, noun, score in zip(verbs, nouns, segment_scores)}) return entries def scores_to_json(scores): entries = [] for classes, segment_scores in zip(*top_scores(scores)): entries.append({str(cls): float(score) for cls, score in zip(classes, segment_scores)}) return entries def compute_score_dicts(results, prior): verb_scores = results['scores']['verb'] if len(verb_scores.shape) == 4: verb_scores = verb_scores.mean(axis=(1, 2)) noun_scores = results['scores']['noun'] if len(noun_scores.shape) == 4: noun_scores = noun_scores.mean(axis=(1, 2)) actions, action_scores = compute_action_scores(verb_scores, noun_scores) verb_scores_dict = scores_to_json(verb_scores) noun_scores_dict = scores_to_json(noun_scores) action_scores_dict = action_scores_to_json(actions, action_scores, prior) return verb_scores_dict, noun_scores_dict, action_scores_dict def to_json(uids, verb_scores_dict, noun_scores_dict, action_scores_dict): entries = {} for uid, segment_verb_scores_dict, segment_noun_scores_dict, segment_action_scores_dict in zip(uids, verb_scores_dict, noun_scores_dict, action_scores_dict): entries[str(uid)] = { 'verb': segment_verb_scores_dict, 'noun': segment_noun_scores_dict, 'action': segment_action_scores_dict } return { 'version': '0.1', 'challenge': 'action_recognition', 'results': entries, } def dump_scores_to_json(results, uids, filepath, prior): verb_scores_dict, noun_scores_dict, action_scores_dict = compute_score_dicts(results, prior) results_dict = to_json(uids, verb_scores_dict, noun_scores_dict, action_scores_dict) filepath.parent.mkdir(exist_ok=True, parents=True) with open(filepath, 'w', encoding='utf8') as f: json.dump(results_dict, f) return results_dict def main(args): if not args.submission_json.exists(): args.submission_json.mkdir(parents=True, exist_ok=True) for test_set in ['seen', 'unseen']: if test_set == 'unseen': action_counts = training_labels().apply(lambda d: (d['verb_class'], d['noun_class']), axis=1).value_counts() prior_action = action_counts.div(action_counts.sum()) prior = prior_action else: prior = None results = pd.read_pickle(args.results_dir / ('test_' + test_set + '.pkl')) uids = np.zeros(results['scores']['verb'].shape[0], dtype=np.int) timestamps = test_timestamps(test_set) for i, (idx, row) in enumerate(timestamps.iterrows()): uids[i] = str(idx) dump_scores_to_json(results, uids, args.submission_json / (test_set + '.json'), prior) if __name__ == '__main__': import argparse parser = argparse.ArgumentParser( description="Produce submission JSON from results pickle", formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument("results_dir", type=Path) parser.add_argument("submission_json", type=Path) main(parser.parse_args())

AWS_Services/showPlacementCompany.py

demirkirans/PlaDat-BLG411E

12798974

<gh_stars>0 import json import boto3 import time import decimal from boto3.dynamodb.conditions import Key,Attr from botocore.exceptions import ClientError class DecimalEncoder(json.JSONEncoder): def default(self, o): if isinstance(o, decimal.Decimal): # wanted a simple yield str(o) in the next line, # but that would mean a yield on the line with super(...), # which wouldn't work (see my comment below), so... return (str(o) for o in [o]) return super(DecimalEncoder, self).default(o) dynamodb = boto3.resource('dynamodb', region_name = 'us-east-2') def lambda_handler(event, context): queryStringParameters = event['queryStringParameters'] #get company id Company_ID = int(queryStringParameters['id']) ### GET CONTACT ### table = dynamodb.Table('Jobs') #scan for given student id response = table.scan(FilterExpression=Attr('Company_ID').eq(Company_ID)) responseBody = { } placements = [] if response['Count'] == 0: #no matching item print("No item was found :/") return { "statusCode": 500, 'body': json.dumps('Internal server error- No item found in contact_student table *-*') } else: #extract id for item in response['Items']: Placement_ID = item['ID'] #we got placement id placement = {} ##################### Add attributes from Jobs TAble ########################## placement['Company_ID'] = int(item['Company_ID']) placement['Placement_ID'] = int(item['ID']) placement['Company_name'] = item['Company_name'] placement['title'] = item['title'] placement['description'] = item['description'] placement['category'] = item['category'] placement['contact_info'] = item['contact_info'] placement['department_name'] = item['department_name'] placement['degree'] = item['degree'] placement['location'] = item['location'] placement['salaries'] = int(item['salaries']) ################3 Add attributes from Skills_jobs table ######################### table = dynamodb.Table('Skills_jobs') skills = [] db_response = table.scan(FilterExpression=Attr('Jobs_Company_ID').eq(Company_ID)&Attr('Jobs_ID').eq(Placement_ID)) if db_response['Count'] == 0: return { "statusCode": 500, "body": json.dumps('Internal Server Error - No matching skills for placement') } else: for attribute in db_response['Items']: skills.append(attribute['name']) #add skills to placement placement['skills'] = skills #################### Add attributes from Benefits table ################# table = dynamodb.Table('Benefits') benefits = [] db_response = table.scan(FilterExpression=Attr('Jobs_Company_ID').eq(Company_ID)&Attr('Jobs_ID').eq(Placement_ID)) if db_response['Count'] == 0: return { "statusCode": 500, "body": json.dumps('Internal Server Error - No matching benefits for placement') } else: for attribute in db_response['Items']: benefits.append(attribute['name']) #add skills to placement placement['benefits'] = benefits #################### Add attributes from Certificates_job table ################# table = dynamodb.Table('Certificates_job') certificates = [] db_response = table.scan(FilterExpression=Attr('Jobs_Company_ID').eq(Company_ID)&Attr('Jobs_ID').eq(Placement_ID)) if db_response['Count'] == 0: print("No matching certificates for placement") else: for attribute in db_response['Items']: certificates.append(attribute['name']) #add skills to placement placement['certificates'] = certificates ############ WE GOT ALL ATTRIBUTES FOR A SINGLE PLACEMENT ################# placements.append(placement) responseBody['placements'] = placements return { "statusCode": 200, "body": json.dumps(responseBody) }

BackEnd/FaceDetector/FaceExt.py

RickyYXY/The-Mask

12798975

# encoding:utf-8 import os, sys basepath = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.append(os.path.join(basepath, 'FaceDetector')) import requests import base64 import cv2 import numpy as np import urllib.request import base64 def fetchImageFromHttp(image_url, timeout_s=1): # 该函数是读取url图片 if image_url: resp = urllib.request.urlopen(image_url, timeout=timeout_s) image = np.asarray(bytearray(resp.read()), dtype="uint8") image = cv2.imdecode(image, cv2.IMREAD_COLOR) return image else: return [] def FaceExtract(img: str, imgtype: str, imgpos: str, facenum=120): # 该函数的作用是提取图中人脸 message = {} # client_id 为官网获取的AK， client_secret 为官网获取的SK host = 'https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=DXN8o5eNaheZahxK558I8GOs&client_secret=<KEY>' response = requests.get(host) if response: # print(response.json()['access_token']) access_token = response.json()['access_token'] request_url = "https://aip.baidubce.com/rest/2.0/face/v3/detect" if imgtype == 'Local': with open(img, "rb") as f: # 转为二进制格式 base64_data = base64.b64encode(f.read()) # 使用base64进行加密 base64_data = base64_data.decode() params = "\"image\":\"{}\",\"image_type\":\"BASE64\", \"max_face_num\":\"120\"".format(base64_data) params = '{' + params + '}' elif imgtype == 'url': params = "\"image\":\"{}\",\"image_type\":\"URL\", \"max_face_num\":\"120\"".format(img) params = '{' + params + '}' # print(params['image']) request_url = request_url + "?access_token=" + access_token headers = {'content-type': 'application/json'} response = requests.post(request_url, data=params, headers=headers) if response: print (response.json()) # 提取检测到的所有人脸信息 if response.json()['error_code'] != 0: message['Error Code'] = response.json()['error_code'] message['Error Message'] = response.json()['error_msg'] message['Data'] = None return message # raise Exception('人脸检测失败，失败码为{}，失败信息为:{}'.format(response.json()['error_code'], response.json()['error_msg'])) face_number = response.json()['result']['face_num'] face_List = [] for num in range(face_number): face_loc_left = int(response.json()['result']['face_list'][num]['location']['left']) face_loc_top = int(response.json()['result']['face_list'][num]['location']['top']) face_loc_width = int(response.json()['result']['face_list'][num]['location']['width']) face_loc_height = int(response.json()['result']['face_list'][num]['location']['height']) face_List.append([face_loc_left, face_loc_top, face_loc_width, face_loc_height]) # 这里是读取图像并画框 if imgtype == 'Local': image = cv2.imread(img) elif imgtype == 'url': image = fetchImageFromHttp(img) # 图片编号起始 search_all_path = [] num = 0 for pos in face_List: lefttopx = pos[0] lefttopy = pos[1] rightbottomx = lefttopx + pos[2] rightbottomy = lefttopy + pos[3] # print(lefttopx, lefttopy, rightbottomx, rightbottomy) cv2.rectangle(image, (lefttopx, lefttopy), (rightbottomx, rightbottomy), (0, 255, 0), 2) if imgpos == 'Example': savepath = os.path.join(basepath, 'FaceStatic', 'ExampleFace', 'example_face_' + str(num) + '.jpg') elif imgpos == 'Search': pos_name = ','.join([str(lefttopx), str(lefttopy), str(rightbottomx), str(rightbottomy)]) savepath = os.path.join(basepath, 'FaceStatic', 'SearchFace', pos_name + '.jpg') search_all_path.append(savepath) # cv2.imwrite("C:/WorkSpace/test/detect_face_"+str(num)+'.jpg', image[lefttopy:rightbottomy, lefttopx:rightbottomx]) cv2.imwrite(savepath, image[lefttopy:rightbottomy, lefttopx:rightbottomx]) num += 1 message['Error Code'] = response.json()['error_code'] message['Error Message'] = message['Error Message'] = response.json()['error_msg'] if imgpos == 'Example': full_face_path = os.path.join(basepath, 'FaceStatic', 'FullFace', 'Result.jpg') cv2.imwrite(full_face_path, image) message['Data'] = {'ExampleFaces': savepath, 'FacesNum': num, 'FullFace': full_face_path} elif imgpos == 'Search': # full_face_path = os.path.join(basepath, 'FaceStatic', 'FullFace', 'Search.jpg') # cv2.imwrite(full_face_path, image) message['Data'] = {'ExampleFaces': search_all_path, 'FacesNum': num, 'FullFace': None} return message if __name__ == "__main__": # imgpath = 'http://xinan.ziqiang.net.cn/ThreeFace.jpeg' imgpath = 'http://xinan.ziqiang.net.cn/Fq-PpUCF25C61q0muvXAHCok0uK2' wycpath = 'http://xinan.ziqiang.net.cn/AsFace.jpg' fetchImageFromHttp(wycpath) # result = FaceExtract(imgpath, 'url') # result = FaceExtract(imgpath, 'Local', 'Search') # cv2.imshow('image', result) # cv2.waitKey(0)

courses/bxx-python/b01/s08-compound-interest.py

vinaynk/nooromtech_tutorials

12798976

# # compound interest # # P - principal # r - annual rate (%) # n - compounding frequency # y - number of years # # Py = P0 (1 + r/n) ** (ny) # P = 1000 r = 2.5 # % n = 4 # quarterly y = 5 amount = P print('Amount (Starting):', amount) for year in range(1, y+1): for period in range(1, n+1): amount *= (1 + r/100/n) # r/100 since r is in % print('Amount ( year:', year, ', period:', period, ') :', round(amount, 2))

ecomstore/caching.py

Pythonian/ecomstore

12798977

<filename>ecomstore/caching.py from django.core.cache import cache from .settings import CACHE_TIMEOUT def cache_update(sender, **kwargs): """ signal for updating a model instance in the cache; any Model class using this signal must have a uniquely identifying 'cache_key' property. """ item = kwargs.get('instance') cache.set(item.cache_key, item, CACHE_TIMEOUT) def cache_evict(sender, **kwargs): """ signal for updating a model instance in the cache; any Model class using this signal must have a uniquely identifying 'cache_key' property. """ item = kwargs.get('instance') cache.delete(item.cache_key)

openmaptiles/pgutils.py

ldgeo/openmaptiles-tools

12798978

<reponame>ldgeo/openmaptiles-tools<filename>openmaptiles/pgutils.py import re from typing import Tuple, Dict from asyncpg import UndefinedFunctionError, UndefinedObjectError, Connection from openmaptiles.perfutils import COLOR async def show_settings(conn: Connection) -> Tuple[Dict[str, str], bool]: postgis_version = False results = {} def parse_postgis_ver(value) -> None: nonlocal postgis_version m = re.match(r'POSTGIS="(\d+\.\d+)', value) postgis_version = float(m.group(1)) settings = { 'version()': None, 'postgis_full_version()': parse_postgis_ver, 'jit': lambda v: 'disable JIT in PG 11-12 for complex queries' if v != 'off' else '', 'shared_buffers': None, 'work_mem': None, 'maintenance_work_mem': None, 'max_connections': None, 'max_worker_processes': None, 'max_parallel_workers': None, 'max_parallel_workers_per_gather': None, } key_len = max((len(v) for v in settings)) for setting, validator in settings.items(): q = f"{'SELECT' if '(' in setting else 'SHOW'} {setting};" prefix = '' suffix = '' try: res = await conn.fetchval(q) if validator: msg = validator(res) if msg: prefix, suffix = COLOR.RED, f" {msg}{COLOR.RESET}" except (UndefinedFunctionError, UndefinedObjectError) as ex: res = ex.message prefix, suffix = COLOR.RED, COLOR.RESET print(f"* {setting:{key_len}} = {prefix}{res}{suffix}") results[setting] = res return results, postgis_version

bluesky_widgets/models/_tests/test_image.py

bsobhani/bluesky-widgets

12798979

<gh_stars>0 from bluesky_live.run_builder import build_simple_run import numpy from ..plot_builders import Images from ..plot_specs import AxesSpec, FigureSpec from ...headless.figures import HeadlessFigure def test_image(): "Test Images with a 2D array." run = build_simple_run({"ccd": numpy.random.random((11, 13))}) model = Images("ccd") view = HeadlessFigure(model.figure) assert not model.figure.axes[0].images model.add_run(run) assert model.figure.axes[0].images view.close() def test_image_reduction(): "Test Images with higher-dimensional arrays." dims = (5, 7, 11, 13, 17, 19) for i in range(3, len(dims)): run = build_simple_run({"ccd": numpy.random.random(dims[:i])}) model = Images("ccd") view = HeadlessFigure(model.figure) model.add_run(run) view.close() def test_properties(): "Touch various accessors" run = build_simple_run({"ccd": numpy.random.random((11, 13))}) model = Images("c * ccd", namespace={"c": 3}) view = HeadlessFigure(model.figure) model.add_run(run) assert model.runs[0] is run assert model.field == "c * ccd" assert dict(model.namespace) == {"c": 3} assert model.needs_streams == ("primary",) view.close() def test_figure_set_after_instantiation(): axes = AxesSpec() model = Images("ccd", axes=axes) assert model.figure is None figure = FigureSpec((axes,), title="") assert model.figure is figure view = HeadlessFigure(model.figure) view.close()

hw3/Fast_Map.py

tian-yu/INF552

12798980

# # INF 552 Homework 3 # Part 2: Fast Map # Group Members: <NAME> (zhan198), <NAME> (minyihua), <NAME> (jeffyjac) # Date: 2/27/2018 # Programming Language: Python 3.6 # import numpy as np import matplotlib.pyplot as plt DIMENSION = 2 DATA_SIZE = 10 # WORDS = ["acting", "activist", "compute", "coward","forward","interaction","activity","odor","order","international"] WORDS = [] data_file_name = "fastmap-data.txt" words_file_name = 'fastmap-wordlist.txt' table = np.zeros(shape=(DATA_SIZE, DATA_SIZE)) cood = np.zeros(shape=(DATA_SIZE, DIMENSION)) pivot = [] def main(): readFile(data_file_name) print("\nOriginal table:") readWords(words_file_name) print(WORDS) printTable() for i in range(DIMENSION): print("\n\nThe {i}st cood: ".format(i=i+1)) pickLongestPair() calculateCoordinate(i) print("\nUpdate table: ") updateTable(i) printTable() plotResult() def readFile(filename): with open(filename, "r") as file: print("Original input:") for line in file: line_array = line.split() print(line_array) table[int(line_array[0]) - 1][int(line_array[1]) - 1] = \ table[int(line_array[1]) - 1][int(line_array[0]) - 1] = float(line_array[2]) def readWords(filename): global WORDS with open(filename) as file: WORDS = file.read().splitlines() def printTable(): for row in table: print(row) def pickLongestPair(): max = np.amax(table) indices = list(zip(*np.where(table == max))) print("The longest distance pair is {pair}".format(pair = indices[0])) print("Pivot is piont {piv}".format(piv = indices[0][0])) pivot.append(indices[0]) def calculateCoordinate(dimen): a = pivot[dimen][0] b = pivot[dimen][1] print("The coordinate table") for i in range(len(table)): cood[i][dimen] = (np.power(table[a][i],2) + np.power(table[a][b],2) - np.power(table[i][b],2))/ (2 * table[a][b]) print ("{i}\t({x}, {y})".format(i=i, x= round(cood[i][0], 3),y=round(cood[i][1], 3))) def updateTable(dimen): for i in range(0, DATA_SIZE): for j in range(0, DATA_SIZE): table[i][j] = np.sqrt(np.power(table[i][j],2) - np.power((cood[i][dimen] - cood[j][dimen]),2)) def plotResult(): x = cood[:, 0] y = cood[:, 1] fig, ax = plt.subplots() ax.set_xlabel('X axis') ax.set_ylabel('Y axis') ax.scatter(x, y) plt.scatter(x, y, color="red", s=30) plt.title("Fast Map Result") for i, txt in enumerate(WORDS): ax.annotate(txt, (x[i], y[i])) plt.show() main()

waves/WAVtoMIF.py

willzhang05/fpga-synthesizer

12798981

<filename>waves/WAVtoMIF.py<gh_stars>1-10 #!/usr/bin/python import wave, sys if len(sys.argv) < 2: print("Missing args.") print("Expected: input") waveReader = wave.open(sys.argv[1], 'rb') depth = waveReader.getnframes() width = 16 # wav is 16 bits radix = "HEX" # address and data in hex print("DEPTH =", str(depth)+";") print("WIDTH =", str(width)+";") print("ADDRESS_RADIX =", radix+";") print("DATA_RADIX =", radix+";") print("CONTENT") print("BEGIN\n") for i in range(waveReader.getnframes()): frameAddr = "%X" % i frameValue = waveReader.readframes(1) hexFrame = "%02X%02X" % (frameValue[1], frameValue[0]) print(frameAddr, ":", hexFrame+";") print("\nEND;")

algorithms/python/leetcode/UniquePaths.py

ytjia/coding-pratice

12798982

<filename>algorithms/python/leetcode/UniquePaths.py # -*- coding: utf-8 -*- # Authors: <NAME> <<EMAIL>> """ A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below). The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below). How many possible unique paths are there? https://leetcode.com/problems/unique-paths/description/ """ class Solution(object): def uniquePaths(self, m, n): """ :type m: int :type n: int :rtype: int """ # C^m_m+n num = 1 den = 1 for i in range(m + n - 2, n - 1, -1): num *= i for i in range(m - 1, 0, -1): den *= i return num / den

datascience/sympy/evaluating2.py

janbodnar/Python-Course

12798983

<reponame>janbodnar/Python-Course #!/usr/bin/python import numpy from sympy import Symbol, lambdify, sin, pprint a = numpy.arange(10) x = Symbol('x') expr = sin(x) f = lambdify(x, expr, "numpy") pprint(f(a))

app/backend-test/core_datasets/run05_test_directory_size_calculation.py

SummaLabs/DLS

12798984

#!/usr/bin/python # -*- coding: utf-8 -*- __author__ = 'ar' import os import glob from app.backend.core.utils import getDirectorySizeInBytes, humanReadableSize if __name__ == '__main__': path='../../../data/datasets' for ii,pp in enumerate(glob.glob('%s/*' % path)): tbn=os.path.basename(pp) tsize = getDirectorySizeInBytes(pp) tsizeHuman = humanReadableSize(tsize) print ('[%d] %s : %s (%d)' % (ii, tbn, tsizeHuman, tsize))

tests/cli/_trivial.py

pcarranzav2/pyuavcan

12798985

# # Copyright (c) 2019 UAVCAN Development Team # This software is distributed under the terms of the MIT License. # Author: <NAME> <<EMAIL>> # import pytest import subprocess from ._subprocess import run_cli_tool def _unittest_trivial() -> None: run_cli_tool('show-transport', timeout=2.0) with pytest.raises(subprocess.CalledProcessError): run_cli_tool(timeout=2.0) with pytest.raises(subprocess.CalledProcessError): run_cli_tool('invalid-command', timeout=2.0) with pytest.raises(subprocess.CalledProcessError): run_cli_tool('dsdl-gen-pkg', 'nonexistent/path', timeout=2.0) with pytest.raises(subprocess.CalledProcessError): # Look-up of a nonexistent package requires large timeout run_cli_tool('pub', 'nonexistent.data.Type.1.0', '{}', '--tr=Loopback(None)', timeout=5.0)

insomnia/agents/d4pg_learner.py

takeru1205/Insomnia

12798986

import time import numpy as np import torch import torch.nn as nn import torch.optim as optim import queue from insomnia.utils import empty_torch_queue from insomnia.explores.gaussian_noise import GaussianActionNoise from insomnia.numeric_models import d4pg from insomnia.numeric_models.misc import l2_projection class LearnerD4PG(object): """Policy and value network update routine. """ def __init__(self, policy_net, target_policy_net, learner_w_queue, alpha, beta, input_dims, n_actions, fc1_dims, fc2_dims, name, v_min, v_max, n_atoms=51): self.v_min = v_min self.v_max = v_max self.num_atoms = n_atoms self.num_train_steps = 10000 self.batch_size = 256 self.tau = 0.001 self.gamma = 0.998 self.prioritized_replay = 0 self.learner_w_queue = learner_w_queue self.delta_z = (self.v_max - self.v_min) / (self.num_atoms - 1) self.device = 'cuda' if torch.cuda.is_available() else 'cpu' # Noise process self.noise = GaussianActionNoise(mu=np.zeros(n_actions)) # Value and policy nets self.value_net = d4pg.CriticNetwork(beta, input_dims, fc1_dims, fc2_dims, n_actions, name, self.v_min, self.v_max, self.num_atoms) self.policy_net = policy_net self.target_value_net = d4pg.CriticNetwork(beta, input_dims, fc1_dims, fc2_dims, n_actions, name, self.v_min, self.v_max, self.num_atoms) self.target_policy_net = target_policy_net for target_param, param in zip(self.target_value_net.parameters(), self.value_net.parameters()): target_param.data.copy_(param.data) for target_param, param in zip(self.target_policy_net.parameters(), self.policy_net.parameters()): target_param.data.copy_(param.data) self.value_optimizer = optim.Adam(self.value_net.parameters(), lr=beta) self.policy_optimizer = optim.Adam(self.policy_net.parameters(), lr=alpha) self.value_criterion = nn.BCELoss(reduction='none') def _update_step(self, batch, replay_priority_queue, update_step): update_time = time.time() state, action, reward, next_state, done, gamma, weights, inds = batch state = np.asarray(state) action = np.asarray(action) reward = np.asarray(reward) next_state = np.asarray(next_state) done = np.asarray(done) weights = np.asarray(weights) inds = np.asarray(inds).flatten() state = torch.from_numpy(state).float().to(self.device) next_state = torch.from_numpy(next_state).float().to(self.device) action = torch.from_numpy(action).float().to(self.device) reward = torch.from_numpy(reward).float().to(self.device) done = torch.from_numpy(done).float().to(self.device) # ------- Update critic ------- # Predict next actions with target policy network next_action = self.target_policy_net(next_state) # Predict Z distribution with target value network target_value = self.target_value_net.get_probs(next_state, next_action.detach()) # Get projected distribution target_z_projected = l2_projection._l2_project(next_distr_v=target_value, rewards_v=reward, dones_mask_t=done, gamma=self.gamma ** 5, n_atoms=self.num_atoms, v_min=self.v_min, v_max=self.v_max, delta_z=self.delta_z) target_z_projected = torch.from_numpy(target_z_projected).float().to(self.device) critic_value = self.value_net.get_probs(state, action) critic_value = critic_value.to(self.device) value_loss = self.value_criterion(critic_value, target_z_projected) value_loss = value_loss.mean(axis=1) # Update priorities in buffer td_error = value_loss.cpu().detach().numpy().flatten() priority_epsilon = 1e-4 if self.prioritized_replay: weights_update = np.abs(td_error) + priority_epsilon replay_priority_queue.put((inds, weights_update)) value_loss = value_loss * torch.tensor(weights).float().to(self.device) # Update step value_loss = value_loss.mean() self.value_optimizer.zero_grad() value_loss.backward() self.value_optimizer.step() # -------- Update actor ----------- policy_loss = self.value_net.get_probs(state, self.policy_net(state)) policy_loss = policy_loss * torch.from_numpy(self.value_net.z_atoms).float().to(self.device) policy_loss = torch.sum(policy_loss, dim=1) policy_loss = -policy_loss.mean() self.policy_optimizer.zero_grad() policy_loss.backward() self.policy_optimizer.step() for target_param, param in zip(self.target_value_net.parameters(), self.value_net.parameters()): target_param.data.copy_( target_param.data * (1.0 - self.tau) + param.data * self.tau ) for target_param, param in zip(self.target_policy_net.parameters(), self.policy_net.parameters()): target_param.data.copy_( target_param.data * (1.0 - self.tau) + param.data * self.tau ) # Send updated learner to the queue if update_step.value % 100 == 0: try: params = [p.data.cpu().detach().numpy() for p in self.policy_net.parameters()] self.learner_w_queue.put(params) except: pass def run(self, training_on, batch_queue, replay_priority_queue, update_step): while update_step.value < self.num_train_steps: try: batch = batch_queue.get_nowait() except queue.Empty: continue self._update_step(batch, replay_priority_queue, update_step) update_step.value += 1 if update_step.value % 1000 == 0: print("Training step ", update_step.value) training_on.value = 0 empty_torch_queue(self.learner_w_queue) empty_torch_queue(replay_priority_queue) print("Exit learner.")

OPCDataTransfer/OPC/OPC.py

Shanginre/OPCDataTransfer

12798987

<reponame>Shanginre/OPCDataTransfer<filename>OPCDataTransfer/OPC/OPC.py #!/usr/bin/env python3.6 # -*- coding: UTF-8 -*- import OpenOPC import pywintypes import datetime from builtins import print import json import copy import logging import os class ConnectionOPC: def __init__(self, conf_settings): self._debug = None self._logger = None self._verbose = None self._frequency = None self._client = None self._param_list = None self._dict_codes_plotting_names = None self._dict_opc_names_codes = None self._dict_code_keys_opc_names = None self._parameters_name_string = None self._debug = conf_settings['debug'] self._set_logger(conf_settings) self._verbose = conf_settings['verbose'] self._set_frequency(conf_settings) self._set_opc_client(conf_settings['opc_server']) # get a list of all parameter names from the OPC server self._param_list = self._client.list(conf_settings['tags_branch_opc_server'], recursive=True) # get dictionaries of tag codes and their OPC names tags_settings_dicts = self._get_settings_dicts(conf_settings) self._set_dict_codes_plotting_names(tags_settings_dicts['codes_and_plotting_names']) self._dict_opc_names_codes = tags_settings_dicts['opc_names_and_codes'] self._set_dict_code_keys_opc_names() self._set_parameters_name_string() def __enter__(self): return self def __exit__(self, *args): self.close() def close(self): groups = self._client.groups() self._client.remove(copy.deepcopy(list(groups))) self._client.close() self._print('OPC client close the connection') def write(self, list_data_string): try: self._client.write(list_data_string) except OpenOPC.TimeoutError: self._print("Timeout error OPC occured") def _print(self, message): if self._verbose: print(message) if self._debug: self._logger.info(message) def get_list_of_current_values(self): current_date_string = datetime.datetime.now() param_array = list() try: if not self._client.groups(): # Read 1 times the values and determine the group of opc tags, which will continue to use for name, value, quality, timeRecord in self._client.iread(self._param_list, group='Group0', update=1): param_array.append(self._get_dict_from_opc_data(name, value, current_date_string)) else: for name, value, quality, timeRecord in self._client.iread(group='Group0', update=1): param_array.append(self._get_dict_from_opc_data(name, value, current_date_string)) if self._debug or self._verbose: self._print('Data has been read from the OPC') for item in param_array: self._print(item) except OpenOPC.TimeoutError: self._print("OPC TimeoutError occured") return param_array def convert_simulation_data_to_opc_data(self, current_values_list): list_opc_values = list() for value_dict in current_values_list: cur_time = value_dict.pop('time', None) cur_value = value_dict.pop('value', None) opc_tag_name = self._get_opc_tag_name(value_dict) list_opc_values.append((opc_tag_name, cur_value)) if self._debug or self._verbose: self._print((opc_tag_name, cur_value, cur_time)) return list_opc_values def _set_opc_client(self, opc_server_name): pywintypes.datetime = pywintypes.TimeType self._client = OpenOPC.client() self._client.connect(opc_server_name) self._print('connected to OPC server ' + opc_server_name) def _set_logger(self, conf_settings): if self._debug: logs_file_path = conf_settings['logs_file_path'] if not logs_file_path: logs_file_path = os.path.abspath( os.path.realpath( os.path.join(os.path.dirname(os.path.realpath(__file__)), '../Data/logs.log'))) debug_level_string = conf_settings['debug_level'] if debug_level_string: debug_level = logging.getLevelName(debug_level_string) else: debug_level = logging.DEBUG logging.basicConfig(level=debug_level, format='%(asctime)s %(name)s %(levelname)s:%(message)s', filename=logs_file_path) self._logger = logging.getLogger(__name__) def _set_frequency(self, conf_settings): frequency = conf_settings['frequency'] if frequency is None: self._frequency = 5 self._print('data refresh rate is set by default ' + str(self._frequency)) else: self._frequency = frequency def get_frequency(self): return self._frequency @staticmethod def _get_settings_dicts(conf_settings): # TODO in production, preferably an HTTP request tags_settings_file_path = conf_settings['tags_settings_file_path'] if not tags_settings_file_path: tags_settings_file_path = os.path.abspath( os.path.realpath( os.path.join(os.path.dirname(os.path.realpath(__file__)), '../Data/tags_settings_sample.json'))) with open(tags_settings_file_path, 'r') as read_file: tags_settings_dicts = json.load(read_file) return tags_settings_dicts def _set_dict_codes_plotting_names(self, dict_codes_plotting_names): dict_with_tuple_keys = dict() for tag_name, list_codes_plotting_names in dict_codes_plotting_names.items(): for code_plotting_name_dict in list_codes_plotting_names: dict_with_tuple_keys[(tag_name, code_plotting_name_dict['key'])] = code_plotting_name_dict['value'] self._dict_codes_plotting_names = dict_with_tuple_keys def _set_dict_code_keys_opc_names(self): dict_with_tuple_keys = dict() for opc_name, codes_dict in self._dict_opc_names_codes.items(): dict_with_tuple_keys[self._get_sorted_tuple_values_from_dict(codes_dict)] = opc_name self._dict_code_keys_opc_names = dict_with_tuple_keys def get_codes_plotting_names_dict(self): return self._dict_codes_plotting_names def get_opc_names_codes_dict(self): return self._dict_opc_names_codes def _get_dict_from_opc_data(self, parameter_name, value, current_date_string): dict_param_value = {**self._dict_opc_names_codes.get(parameter_name), 'value': value, 'time': current_date_string} return dict_param_value @staticmethod def _get_sorted_tuple_values_from_dict(_dict): values_list = list() for k in sorted(_dict.keys()): values_list.append(_dict[k]) return tuple(values_list) def _get_opc_tag_name(self, value_dict): keys_tuple = self._get_sorted_tuple_values_from_dict(value_dict) return self._dict_code_keys_opc_names.get(keys_tuple) def _set_parameters_name_string(self): if self._dict_opc_names_codes: dict_codes_first_value = next(iter(self._dict_opc_names_codes.values())) self._parameters_name_string = ','.join(list(dict_codes_first_value.keys())) + ',value,time' else: self._parameters_name_string = '' def get_parameters_name_string(self): return self._parameters_name_string

test/test_si7021.py

arkjedrz/si7021

12798988

<gh_stars>0 import unittest import si7021 class Si7021SensorTests(unittest.TestCase): def setUp(self): # TODO: checks for Windows, but should check for embedded platform import os if os.name == 'Windows': raise OSError self._sensor = si7021.Si7021Sensor() def _assert_in_range(self, action, param_name, min, max): value = action() self.assertGreaterEqual(value, min, f'{param_name} must be greater or equal to {min}.') self.assertLessEqual(value, max, f'{param_name} must be less or equal to {max}.') def test_read_humidity(self): self._assert_in_range(self._sensor.humidity, 'Humidity', 0, 80) def test_read_temperature(self): self._assert_in_range(self._sensor.temperature, 'Temperature', -10, 85) if __name__ == '__main__': unittest.main()

dlcli/api/user.py

outlyerapp/dlcli

12798989

import logging from wrapper import * logger = logging.getLogger(__name__) # noinspection PyUnusedLocal def get_user(url='', key='', timeout=60, **kwargs): return get(url + '/user', headers={'Authorization': "Bearer " + key}, timeout=timeout).json() # noinspection PyUnusedLocal def get_user_tokens(url='', key='', timeout=60, **kwargs): return get(url + '/user/tokens', headers={'Authorization': "Bearer " + key}, timeout=timeout).json() # noinspection PyUnusedLocal def create_user_token(url='', key='', token_name='', timeout=60, **kwargs): return post(url + '/user/tokens', headers={'Authorization': "Bearer " + key}, data={'name': token_name}, timeout=timeout).json() # noinspection PyUnusedLocal def delete_user_token(url='', key='', token_name='', timeout=60, **kwargs): return delete(url + '/user/tokens/' + token_name, headers={'Authorization': "Bearer " + key}, timeout=timeout)

galaxy/objectstore/lwr.py

jmchilton/lwr

12798990

from __future__ import absolute_import # Need to import lwr_client absolutely. from ..objectstore import ObjectStore try: from galaxy.jobs.runners.lwr_client.manager import ObjectStoreClientManager except ImportError: from lwr.lwr_client.manager import ObjectStoreClientManager class LwrObjectStore(ObjectStore): """ Object store implementation that delegates to a remote LWR server. This may be more aspirational than practical for now, it would be good to Galaxy to a point that a handler thread could be setup that doesn't attempt to access the disk files returned by a (this) object store - just passing them along to the LWR unmodified. That modification - along with this implementation and LWR job destinations would then allow Galaxy to fully manage jobs on remote servers with completely different mount points. This implementation should be considered beta and may be dropped from Galaxy at some future point or significantly modified. """ def __init__(self, config, config_xml): self.lwr_client = self.__build_lwr_client(config_xml) def exists(self, obj, **kwds): return self.lwr_client.exists(**self.__build_kwds(obj, **kwds)) def file_ready(self, obj, **kwds): return self.lwr_client.file_ready(**self.__build_kwds(obj, **kwds)) def create(self, obj, **kwds): return self.lwr_client.create(**self.__build_kwds(obj, **kwds)) def empty(self, obj, **kwds): return self.lwr_client.empty(**self.__build_kwds(obj, **kwds)) def size(self, obj, **kwds): return self.lwr_client.size(**self.__build_kwds(obj, **kwds)) def delete(self, obj, **kwds): return self.lwr_client.delete(**self.__build_kwds(obj, **kwds)) # TODO: Optimize get_data. def get_data(self, obj, **kwds): return self.lwr_client.get_data(**self.__build_kwds(obj, **kwds)) def get_filename(self, obj, **kwds): return self.lwr_client.get_filename(**self.__build_kwds(obj, **kwds)) def update_from_file(self, obj, **kwds): return self.lwr_client.update_from_file(**self.__build_kwds(obj, **kwds)) def get_store_usage_percent(self): return self.lwr_client.get_store_usage_percent() def get_object_url(self, obj, extra_dir=None, extra_dir_at_root=False, alt_name=None): return None def __build_kwds(self, obj, **kwds): kwds['object_id'] = obj.id return kwds pass def __build_lwr_client(self, config_xml): url = config_xml.get("url") private_token = config_xml.get("private_token", None) transport = config_xml.get("transport", None) manager_options = dict(transport=transport) client_options = dict(url=url, private_token=private_token) lwr_client = ObjectStoreClientManager(**manager_options).get_client(client_options) return lwr_client def shutdown(self): pass

Algorithm/String/242. Valid Anagram.py

smsubham/Data-Structure-Algorithms-Questions

12798991

#https://leetcode.com/problems/valid-anagram/ #https://leetcode.com/problems/valid-anagram/discuss/66499/Python-solutions-(sort-and-dictionary). def isAnagram1(self, s, t): dic1, dic2 = {}, {} for item in s: dic1[item] = dic1.get(item, 0) + 1 for item in t: dic2[item] = dic2.get(item, 0) + 1 return dic1 == dic2 def isAnagram2(self, s, t): dic1, dic2 = [0]*26, [0]*26 for item in s: dic1[ord(item)-ord('a')] += 1 for item in t: dic2[ord(item)-ord('a')] += 1 return dic1 == dic2 def isAnagram3(self, s, t): return sorted(s) == sorted(t)

pyshtools/constant/Mars.py

dilkins/SHTOOLS

12798992

<filename>pyshtools/constant/Mars.py """ pyshtools constants for the planet Mars. Each object is an astropy Constant that possesses the attributes name, value, unit, uncertainty, and reference. """ from __future__ import absolute_import as _absolute_import from __future__ import division as _division from __future__ import print_function as _print_function import numpy as _np from astropy.constants import Constant as _Constant from astropy.constants import G as _G gm_mars = _Constant( abbrev='gm_mars', name='Gravitational constant times the mass of Mars', value=0.4282837581575610e+14, unit='m3 / s2', uncertainty=0.18167460e+6, reference='<NAME>., <NAME>, <NAME> (2016). ' 'An improved JPL Mars gravity field and orientation from Mars orbiter ' 'and lander tracking data, Icarus, 274, 253-260, ' 'doi:10.1016/j.icarus.2016.02.052') mass_mars = _Constant( abbrev='mass_mars', name='Mass of Mars', value=gm_mars.value / _G.value, unit='kg', uncertainty=_np.sqrt((gm_mars.uncertainty / _G.value)**2 + (gm_mars.value * _G.uncertainty / _G.value**2)**2 ), reference='Derived from gm_mars and G.') r_mars = _Constant( abbrev='r_mars', name='Mean radius of Mars', value=3389.500e3, unit='m', uncertainty=0.0, reference='MarsTopo2600: Wieczorek, <NAME>. (2015). Gravity and ' 'topography of the terrestrial planets. In <NAME> & <NAME> ' '(Eds.), Treatise on Geophysics, 2nd ed., Vol. 10, pp. 153-193). ' 'Oxford, Elsevier-Pergamon, doi:10.1016/B978-0-444-53802-4.00169-X.') density_mars = _Constant( abbrev='density_mars', name='Mean density of Mars', value=3 * mass_mars.value / (_np.pi * 4 * r_mars.value**3), unit='kg / m3', uncertainty=_np.sqrt((3 * mass_mars.uncertainty / (_np.pi * 4 * r_mars.value**3))**2 + (3 * 3 * mass_mars.value * r_mars.uncertainty / (_np.pi * 4 * r_mars.value**4))**2 ), reference='Derived from mass_mars and r_mars.') g0_mars = _Constant( abbrev='g0_mars', name='Mean surface gravity of Mars at mean planetary radius, ' 'ignoring rotation and tides', value=gm_mars.value / r_mars.value**2, unit='m / s2', uncertainty=_np.sqrt((gm_mars.uncertainty / r_mars.value**2)**2 + (2 * gm_mars.value * r_mars.uncertainty / r_mars.value**3)**2 ), reference='Derived from gm_mars and r_mars.') omega_mars = _Constant( abbrev='omega_mars', name='Angular spin rate of Mars', value=350.891985307 * 2 * _np.pi / 360 / (24 * 60 * 60), unit='rad / s', uncertainty=0.000000003 * 2 * _np.pi / 360 / (24 * 60 * 60), reference='<NAME>., <NAME>, <NAME> (2016). ' 'An improved JPL Mars gravity field and orientation from Mars orbiter ' 'and lander tracking data, Icarus, 274, 253-260, ' 'doi:10.1016/j.icarus.2016.02.052') a_mars = _Constant( abbrev='a_mars', name='Semimajor axis of the Mars reference ellipsoid', value=3395428.0, unit='m', uncertainty=19.0, reference='<NAME>, <NAME>, and <NAME> (2010). ' 'A new reference equipotential surface, and reference ellipsoid for ' 'the planet Mars. Earth, Moon, and Planets, 106, 1-13, ' 'doi:10.1007/s11038-009-9342-7.') b_mars = _Constant( abbrev='b_mars', name='Semiminor axis of the Mars reference ellipsoid', value=3377678.0, unit='m', uncertainty=19.0, reference='<NAME>, <NAME>, and <NAME> (2010). ' 'A new reference equipotential surface, and reference ellipsoid for ' 'the planet Mars. Earth, Moon, and Planets, 106, 1-13, ' 'doi:10.1007/s11038-009-9342-7.') f_mars = _Constant( abbrev='f_mars', name='Flattening of the Mars reference ellipsoid', value=(a_mars.value - b_mars.value) / a_mars.value, unit='', uncertainty=_np.sqrt((a_mars.uncertainty * (a_mars.value - b_mars.value) / a_mars.value**2)**2 + (_np.sqrt(a_mars.uncertainty**2 + b_mars.uncertainty**2) / a_mars.value)**2 ), reference='<NAME>, <NAME>, and <NAME> (2010). ' 'A new reference equipotential surface, and reference ellipsoid for ' 'the planet Mars. Earth, Moon, and Planets, 106, 1-13, ' 'doi:10.1007/s11038-009-9342-7.') u0_mars = _Constant( abbrev='u0_mars', name='Theoretical normal gravity potential of the reference ellipsoid', value=12654875.0, unit='m2 / s2', uncertainty=69.0, reference='<NAME>, <NAME>, and <NAME> (2010). ' 'A new reference equipotential surface, and reference ellipsoid for ' 'the planet Mars. Earth, Moon, and Planets, 106, 1-13, ' 'doi:10.1007/s11038-009-9342-7.')

hard-gists/3791168/snippet.py

jjhenkel/dockerizeme

12798993

""" Demo of json_required decorator for API input validation/error handling """ import inspect import functools import json from traceback import format_exception from flask import jsonify, request import sys from flask.exceptions import JSONBadRequest from flask import Flask import re app = Flask(__name__) def api_error_response(code=404, message="Requested resource was not found", errors=list()): """ Convenience function for returning a JSON response that includes appropriate error messages and code. """ response = jsonify(dict(code=code, message=message, errors=errors, success=False)) response.status_code = code return response def bad_json_error_response(): """ Convenience function for returning an error message related to malformed/missing JSON data. """ return api_error_response(code=400, message="There was a problem parsing the supplied JSON data. Please send valid JSON.") def json_required(func=None, required_fields={}, validations=[]): """ Decorator used to validate JSON input to an API request """ if func is None: return functools.partial(json_required, required_fields=required_fields, validations=validations) @functools.wraps(func) def decorated_function(*args, **kwargs): try: #If no JSON was supplied (or it didn't parse correctly) try: if request.json is None: return bad_json_error_response() except JSONBadRequest: return bad_json_error_response() #Check for specific fields errors = [] def check_required_fields(data, fields): for field, requirements in fields.iteritems(): nested_fields = type(requirements) == dict if data.get(field) in (None, ''): if nested_fields: error_msg = requirements.get('message') else: error_msg = requirements errors.append({'field': field, 'message': error_msg}) elif nested_fields: check_required_fields(data[field], requirements.get('fields', {})) check_required_fields(request.json, required_fields) for validation_field, validation_message, validation_func in validations: func_args = inspect.getargspec(validation_func).args func_params = [] for arg in func_args: func_params.append(request.json.get(arg)) if not validation_func(*func_params): errors.append({'field': validation_field, 'message': validation_message}) if errors: return api_error_response(code=422, message="JSON Validation Failed", errors=errors) except Exception: #For internal use, nice to have the traceback in the API response for debugging #Probably don't want to include for public APIs etype, value, tb = sys.exc_info() error_info = ''.join(format_exception(etype, value, tb)) return api_error_response(code=500, message="Internal Error validating API input", errors=[{'message':error_info}]) return func(*args, **kwargs) return decorated_function EMAIL_REGEX = re.compile(r"[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?\.)+[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?") def verify_account_available(email): """ Check to see if this email is already registered """ #Run a query, use an ORM, use Twilio to call someone and ask them :-) return True def valid_date_of_birth(date_of_birth): """ Does the supplied date string meet our criteria for a date of birth """ #Do whatever you need to do... return True @app.route("/do/something", methods=['POST']) @json_required( required_fields={ 'first_name':"Please provide your first name.", 'last_name':"Please provide your last name.", 'email':'Please specify a valid email address', 'date_of_birth':'Please provide your date of birth' }, validations=[ ('email', 'Please provide a valid email address', lambda email: email is not None and EMAIL_REGEX.match(email)), ('email', "This email is already in use. Please try a different email address.", verify_account_available), ('date_of_birth', 'Please provide a valid date of birth', valid_date_of_birth) ] ) def do_something_useful(): #Confidently use the data in request.json... return jsonify(dict(status='OK')) if __name__ == "__main__": with app.test_client() as client: response = client.post( '/do/something', data=json.dumps({ "first_name": "Brian", "last_name": "Corbin", "email": "<EMAIL>", "date_of_birth": "01/01/1970" }), follow_redirects=True, content_type='application/json') response_dict = json.loads(response.data) assert response_dict['status'] == 'OK' response = client.post( '/do/something', data=json.dumps({ "last_name": "Corbin", "email": "<EMAIL>", "date_of_birth": "01/01/1970" }), follow_redirects=True, content_type='application/json') response_dict = json.loads(response.data) assert response.status_code == 422 assert response_dict['code'] == 422 assert response_dict['message'] == "JSON Validation Failed" assert len(response_dict['errors']) == 1 assert response_dict['errors'][0]['field'] == 'first_name' assert response_dict['errors'][0]['message'] == 'Please provide your first name.'

ACME/render/camera_extrinsics.py

mauriziokovacic/ACME

12798994

import torch from ..math.cross import * from ..math.normvec import * class CameraExtrinsic(object): """ A class representing the camera extrinsic properties Attributes ---------- position : Tensor the camera position target : Tensor the camera target up_vector : Tensor the camera up vector device : str or torch.device the device to store the tensors to Methods ------- look_at(target) sets the camera target look_from(position) sets the camera position direction() returns the camera direction view_matrix() returns the current view matrix to(**kwargs) changes extrinsic dtype and/or device """ def __init__(self, position=(0, 0, 0), target=(0, 0, 1), up_vector=(0, 1, 0), device='cuda:0'): """ Parameters ---------- position : list or tuple (optional) the camera position (default is (0, 0, 0)) target : list or tuple (optional) the camera target (default is (0, 0, 1)) up_vector : list or tuple (optional) the camera up vector (default is (0, 1, 0)) device : str or torch.device (optional) the device to store the tensors to (default is 'cuda:0') """ self.position = torch.tensor(position, dtype=torch.float, device=device) self.target = torch.tensor(target, dtype=torch.float, device=device) self.up_vector = torch.tensor(up_vector, dtype=torch.float, device=device) self._device = device def look_at(self, target): """ Sets the camera target Parameters ---------- target : Tensor the (3,) target tensor Returns ------- CameraExtrinsic the extrinsic itself """ self.target = target return self def look_from(self, position): """ Sets the camera position Parameters ---------- position : Tensor the (3,) position tensor Returns ------- CameraExtrinsic the extrinsic itself """ self.position = position return self def direction(self): """ Returns the camera direction Returns ------- Tensor the (3,) direction tensor """ return self.target - self.position def view_matrix(self): """ Returns the current view matrix Returns ------- Tensor a (4,4,) view matrix """ z = normr(self.direction().unsqueeze(0)) x = normr(cross(self.up_vector.unsqueeze(0), z)) y = cross(z, x) p = self.position.unsqueeze(0) M = torch.cat((torch.cat((x.t(), y.t(), z.t(), -p.t()), dim=1), torch.tensor([[0, 0, 0, 1]], dtype=torch.float, device=self.device)), dim=0) return M def to(self, **kwargs): """ Changes the extrinsic dtype and/or device Parameters ---------- kwargs : ... Returns ------- CameraExtrinsic the extrinsic itself """ if 'device' in kwargs: self._device = kwargs['device'] self.position = self.position.to(**kwargs) self.target = self.target.to(**kwargs) self.up_vector = self.up_vector.to(**kwargs) return self @property def device(self): return self._device @device.setter def device(self, value): self._device = value self.position = self.position.to(self.device) self.target = self.target.to(self.device) self.up_vector = self.up_vector.to(self.device)

jupyter_d3/scatter_plot.py

nicolemoiseyev/jupyter-d3

12798995

import uuid from textwrap import dedent from IPython.core.display import display, HTML from string import Template import numpy as np # function to initialize a scatter plot def init_chart(data,features): chart_id = 'mychart-' + str(uuid.uuid4()) feature_types = {} # map each feature to type num_feature_ranges = {} for x in features: if data[x].dtype in ["int64", "float64"]: feature_domain = [min(data[x].dropna()), max(data[x].dropna())] if feature_domain[1] == feature_domain[0]: feature_types[x] = "categorical" else: feature_types[x] = data[x].dtype.name num_feature_ranges[x] = feature_domain else: feature_types[x] = "categorical" display(HTML('<script src="/static/components/requirejs/require.js"></script>')) display(HTML(Template(dedent(''' <style> body { font: 11px sans-serif; color: #2A3F5E } .chart { background-color: #E5ECF6; display: relative; } .axis path, .axis line { fill: none; stroke: #2A3F5E; shape-rendering: crispEdges; } .label { color: #2A3F5E; } .selection { margin-bottom: 20px; } .dot { stroke: #fff; opacity: 0.8; } .grid line { stroke: #fff; stroke-opacity: 0.7; stroke-width: 2px; shape-rendering: crispEdges; } .grid path { stroke-width: 0; } .tooltip { position: absolute; font-size: 12px; width: auto; height: auto; pointer-events: none; background-color: white; padding: 5px; } .legend { background-color: white; position: absolute; left: 650px; top: 20px; width: auto; height: 500px; } </style> <script> require.config({ paths: { 'd3': 'https://cdnjs.cloudflare.com/ajax/libs/d3/5.16.0/d3.min', } }) // If we configure mychart via url, we can eliminate this define here define($chart_id, ['d3'], function(d3) { return function (figure_id, legend_id, select_id, data, xCat, yCat, sizeCat, axes) { var initialFeature = d3.select("#" + select_id).property("value") var margin = {top: 40, right: 10, bottom: 50, left: 50}, width = 650 - margin.left - margin.right, height = 400 - margin.top - margin.bottom; // append the svg object to the body of the page var svg = d3.select('#' + figure_id) .attr("width", width + margin.left + margin.right) .attr("height", height + margin.top + margin.bottom) .append("g") .attr("transform", "translate(" + margin.left + "," + margin.top + ")"); // X and Y scales and Axis var x = d3.scaleLinear() .domain(axes["x"]) .range([0, width]); var y = d3.scaleLinear() .domain(axes["y"]) .range([height, 0]); // Add X-axis and label svg .append('g') .attr("class", "x axis") .attr("transform", "translate(0," + height + ")") .call(d3.axisBottom(x)) svg.append("text") .attr("class", "label") .attr("x", width / 2) .attr("y", height + 35) .style("text-anchor", "end") .text(xCat); // Add Y-axis and label svg .append('g') .call(d3.axisLeft(y)); svg.append("text") .attr("class", "label") .attr("x", -(height - 15)/ 2 ) .attr("y", -30) .attr("transform", "rotate(-90)") .style("text-anchor", "end") .text(yCat); // gridlines in x axis function function make_x_gridlines() { return d3.axisBottom(x) .ticks(5) } // gridlines in y axis function function make_y_gridlines() { return d3.axisLeft(y) .ticks(5) } // add grid lines // add the X gridlines svg.append("g") .attr("class", "grid") .attr("transform", "translate(0," + height + ")") .call(make_x_gridlines() .tickSize(-height) .tickFormat("") ) // add the Y gridlines svg.append("g") .attr("class", "grid") .call(make_y_gridlines() .tickSize(-width) .tickFormat("") ) // Add the datapoints var dots = svg .selectAll() .data(data) .enter() .append("circle") // Add the tooltip container to the body container // it's invisible and its position/contents are defined during mouseover var tooltip = d3.select("body").append("div") .attr("class", "tooltip") .style("opacity", 0); // Add the legend container to the body container var legend = d3.select("#" + legend_id).attr("y", 0); // tooltip mouseover event handler var tipMouseover = d => { // x and y numeric labels let html = xCat + ": " + Number((d[xCat]).toFixed(3)) + "<br>" + yCat + ": " + Number((d[yCat]).toFixed(3)) + "<br><br>" // color feature label html += colorFeature + ": " + d[colorFeature] tooltip.html(html) .style("left", (d3.event.pageX + 10) + "px") .style("top", (d3.event.pageY - 15) + "px") .transition() .style("opacity", .9) }; function updateLegendCat(featureColors) { // create the categorical legend var legend = d3.select("#" + legend_id).html("") // clear current legend content legend.append("text") .attr("x", 15) .attr("y", 10) .text(colorFeature) .attr("font-size", "14px") let i = 0 Object.keys(featureColors).forEach(feature => { legend.append("circle") .attr("cx",20) .attr("cy",30 + 20*i) .attr("r", 4) .style("fill", featureColors[feature]) legend.append("text") .attr("x", 40) .attr("y", 30 + 20*i ) .text(feature) .style("font-size", "14px") .attr("alignment-baseline","middle") i += 1 }) } function updateLegendNum(domain) { // create the continuous (numerical) legend var legend = d3.select("#" + legend_id).html("") var width = 30, height = 300; // add legend title legend.append("text") .attr("x", 15) .attr("y", 10) .text(colorFeature) .attr("font-size", "14px") var textHeight = 1; var linearGradient = legend.append("defs") .append("linearGradient") .attr("id", "linear-gradient") .attr("gradientTransform", "rotate(90)"); var color = d3.scaleSequential(d3.interpolatePlasma).domain([0,100]) for (let i = 0; i <= 100; i += 5) linearGradient.append("stop") .attr("offset", i + "%") .attr("stop-color", color(100-i)); // to get the right orientation of gradient const legendScale = num => { var scale = d3.scaleLinear() .domain([5, 0]) .range(domain) return Number((scale(num))).toFixed(0) } legend.append("rect") .attr("x", 20) .attr("y", 30) .attr("width", width) .attr("height", height) .style("fill", "url(#linear-gradient)"); for (let i = 0; i <= 5; i += 1) { legend.append("text") .attr("x", 55) .attr("y", 30 + textHeight/2 + ((height-textHeight*6)/5)*i) .text(legendScale(i)) .style("font-size", "14px") .attr("alignment-baseline","middle"); } } // tooltip mouseout event handler var tipMouseout = d => { tooltip.transition() .duration(0) // ms .style("opacity", 0); // don't care about position! }; var sizeScale = d3.scaleLinear() .domain(sizeCat["range"]) .range([3,7]) dots.attr("class", "dot") .attr("cx", d => x(d[xCat]) ) .attr("cy", d => y(d[yCat]) ) .attr("r", d => sizeScale(d[sizeCat["label"]])) .on("mouseover", tipMouseover) .on("mouseout", tipMouseout) update(initialFeature) // A function that update the chart with the new color coding scheme function update(feature) { colorFeature = feature var colors = ['#636EFA', '#EF553B', '#00CC96', '#AB63FA', '#FFA15A', '#19D3F3', '#FF6692', '#B6E880', '#FF97FF', '#FECB52'] var color; let type = $feature_types[feature]; if (type === "categorical") { color = d3.scaleOrdinal(colors); let featureColors = {} dots .attr("fill", d => { let dotColor = color(d[feature]) featureColors[d[feature]] = dotColor return dotColor }) updateLegendCat(featureColors) // update the legend with the new color map } else { let feature_domain = $num_feature_ranges[feature] color = d3.scaleSequential(d3.interpolatePlasma).domain(feature_domain) dots .attr("fill", d => { let dotColor = color(d[feature]) return dotColor }) updateLegendNum(feature_domain) } } d3.select("#" + select_id).on("change", function(d) { // recover the option that has been chosen var selectedOption = d3.select(this).property("value") // run the updateChart function with this selected option update(selectedOption) }); } }) </script> ''')).substitute({ 'chart_id': repr(chart_id), 'feature_types': repr(feature_types), 'num_feature_ranges': repr(num_feature_ranges)}))) return chart_id def scatter_plot(data,x_cat,y_cat,axes,features): chart_id = init_chart(data,features) features_html_options = "".join([ f"<option value ='{x}'>{x}</option>" for x in features ]) dict_data = data.replace(np.nan, "N/A").to_dict("records") size_cat = { "label": "n_reads", "range": [min(data["n_reads"]), max(data["n_reads"])] } display(HTML(Template(dedent(''' <div class="selection"> <label for="colorFeature" style="display: inline-block; width: 240px; text-align: right"> <span> Color by feature: </span> </label> <select id=$select_id> $options </select> </div> <div style="position: relative"> <svg id=$figure_id class='chart'></svg> <div class="legend"><svg id=$legend_id height=500 width=400></svg></div> </div> <script> require([$chart_id], function(mychart) { mychart($figure_id, $legend_id, $select_id, $data, $x_cat, $y_cat, $size_cat, $axes ) }) </script> ''')).substitute({ 'chart_id': repr(chart_id), 'figure_id': repr('fig-' + str(uuid.uuid4())), 'legend_id': repr('leg-' + str(uuid.uuid4())), 'select_id': repr('sel-' + str(uuid.uuid4())), 'data': repr(dict_data), 'axes': repr(axes), 'x_cat': repr(x_cat), 'y_cat': repr(y_cat), 'size_cat': repr(size_cat), 'options': repr(features_html_options) })))

methods/methods.py

ZhangShuang92/csslab

12798996

# -*- coding:utf-8 -*- ''' 目的：提供一些文件操作 和 数据处理的方法 方法： # 功能 # - # 方法 # * 读取文件较大的csv - read_csv * 获取当前目录下所有子目录 - get_subdirs * 获取当前目录下所有该类型的文件名 - get_files * 获取当前目录和所有子目录下所有该类型的文件名 - get_files_all * 数据表随机长度的抽样 - random_dataframe_sample * 计算概率密度分布 - distribution_pdf * 计算累计概率密度分布 - distribution_cdf * 计算频率分布 - distribution_fre * 数据归一化到某个区间 - normlize 备注： * 2017.10.16 - dataframe_filter方法还需要修改 * 2018.4.12 - 修改完善，oh yeah! * 2018.11.27 - hex2rgb 与 rgb2hex，转到colorfly去了 ''' import os import random import pandas as pd import numpy as np import matplotlib.pyplot as plt def read_csv(readpath,**kwargs): ''' 分块读取大文件的 csv :param readpath: filepath :return: pd.DataFrame ''' print(' - - start to read - - %s'%readpath) reader = pd.read_csv(readpath,iterator=True,**kwargs) loop = True chunkSize = 100000 chunks = [] while loop: try: chunk = reader.get_chunk(chunkSize) chunks.append(chunk) except StopIteration: loop = False data = pd.concat(chunks,ignore_index=True) return data def get_files(filedir, filetype=None, return_type='abspath'): ''' 返回当前目录下的所有该类型文件名或地址 :param filedir: str,目录 :param filetype: str,文件格式 :param return_type: 只是文件名 或 绝对地址 :return: list ''' files = [] for filename in os.listdir(filedir): if (filetype is None or os.path.splitext(filename)[1] == filetype): files.append(os.path.splitext(filename)[0]) if return_type == 'name': return files elif return_type == 'abspath': files = [os.path.join(filedir, each + filetype) for each in files] return files return files def get_files_all(filedir,filetype=None): ''' 返回目录和子目录下所以该类型的文件列表 :param filedir: str,目录 :param filetype: str,文件格式 :return: list ''' files = [] for each in os.walk(filedir): if len(each[-1]) >= 1: for file_i in each[-1]: if(filetype is None or os.path.splitext(file_i)[1] == filetype) files.append(os.path.join(each[0], file_i)) return files def get_subdir(sup_dir): sub_dirs = [] for subdir in os.listdir(sup_dir): abs_path = os.path.join(sup_dir,subdir) if os.path.isdir(abs_path): sub_dirs.append(abs_path) return sub_dirs def random_dataframe_sample(df, num): ''' 返回dataframe的随机数量的样本，不放回。 如果出现KeyError的话，把下面的 df.ix 改成 df.loc 试试 ! :param df: Dataframe,数据 :param num: 样本数量，也可以是比例，例如 0.2 :return: Dataframe ''' length = len(df) if num < 1: num = int(length * num) inds = list(df.index) if num <= length: ind_sample = random.sample(inds, num) df_sample = df.loc[ind_sample, :] else: df_sample = df return df_sample def distribution_fre(data): ''' 计算数据的频率密度分布,最后的概率值加起来都等于1 :param data: list 或者 pandas.Series. :return: pandas.Series ''' if data is None: return None if not isinstance(data, pd.Series): data = pd.Series(data) data_count = data.value_counts().sort_index() data_p = data_count / data_count.sum() return data_p def distribution_pdf(data, bins=None): ''' 用频率密度直方图来估计概率密度分布 :param data: 数据 :return: data_pdf，pandas.Series ''' if data is None: return None if bins is None: bins = 200 if isinstance(data,pd.Series): data = data.values density, xdata = np.histogram(data, bins=bins, density=True) xdata = (xdata + np.roll(xdata, -1))[:-1] / 2.0 data_pdf = pd.Series(density, index=xdata) return data_pdf def distribution_cdf(data, bins=None): pdf = distribution_pdf(data, bins) cdf = [] for ind in pdf.index: cdf.append(pdf[:ind].sum()) cdf = pd.Series(cdf, index=pdf.index) cdf = cdf / cdf.max() return cdf def plot_distribution(data, subplot=2, data_norm=False, cmp=False, grid=True): ''' :param data: Series数据 :param subplot: 绘制原始的，log 和 log-log :param data_norm: 数据是否归一化，例如normlized degree :param cmp: 是否绘制累计密度概率 :param grid: 网格线是否显示 :return: None ''' if data_norm: data_normed = normlize(data.values,0,1) name = 'Normlized'+ str(data.name) data = pd.Series(data_normed,name=name) ylabel = 'Prob' if cmp: data = distribution_cdf(data) ylabel = 'CCDF' else: data = distribution_pdf(data) fg = plt.figure() axes = [] for i in range(subplot): axes.append(fg.add_subplot(1,subplot,i+1)) data.plot(ax=axes[0], style='*-') axes[0].set_title('Distribution') if subplot>=2: data.plot(ax=axes[1], style='*', logy=True, logx=True) axes[1].set_title('log-log') #axes[1].set_xlim([0, 50]) if subplot>=3: data.plot(ax=axes[2], style='*-', logy=True) axes[2].set_title('semi-log') for i in range(subplot): axes[i].set_ylabel(ylabel) axes[i].set_xlabel(data.name) axes[i].set_xlim([0, max(data.index)*1.1]) axes[i].grid(grid, alpha=0.8) return axes def normlize(data,lower=0,upper=1): ''' 将数据规范化到某个区间 :param data: 可以是list，array, ndarray等 :param lower: 规范化的下界 :param upper: 规范化的上界 :return: 规范化的数据 ''' xmax = np.max(data) xmin = np.min(data) data_new = (upper - lower) * (data - xmin) / (xmax - xmin) + lower return data_new

yardstick/benchmark/scenarios/lib/create_image.py

upfront710/yardstick

12798997

############################################################################## # Copyright (c) 2017 Huawei Technologies Co.,Ltd and others. # # All rights reserved. This program and the accompanying materials # are made available under the terms of the Apache License, Version 2.0 # which accompanies this distribution, and is available at # http://www.apache.org/licenses/LICENSE-2.0 ############################################################################## import logging from yardstick.benchmark.scenarios import base from yardstick.common import openstack_utils from yardstick.common import exceptions LOG = logging.getLogger(__name__) class CreateImage(base.Scenario): """Create an OpenStack image""" __scenario_type__ = "CreateImage" def __init__(self, scenario_cfg, context_cfg): self.scenario_cfg = scenario_cfg self.context_cfg = context_cfg self.options = self.scenario_cfg["options"] self.name = self.options["image_name"] self.file_name = self.options.get("file_name") self.container = self.options.get("container", 'images') self.md5 = self.options.get("md5") self.sha256 = self.options.get("sha256") self.disk_format = self.options.get("disk_format") self.container_format = self.options.get("container_format",) self.disable_vendor_agent = self.options.get("disable_vendor_agent", True) self.wait = self.options.get("wait", True) self.timeout = self.options.get("timeout", 3600) self.allow_duplicates = self.options.get("allow_duplicates", False) self.meta = self.options.get("meta") self.volume = self.options.get("volume") self.shade_client = openstack_utils.get_shade_client() self.setup_done = False def setup(self): """scenario setup""" self.setup_done = True def run(self, result): """execute the test""" if not self.setup_done: self.setup() image_id = openstack_utils.create_image( self.shade_client, self.name, filename=self.file_name, container=self.container, md5=self.md5, sha256=self.sha256, disk_format=self.disk_format, container_format=self.container_format, disable_vendor_agent=self.disable_vendor_agent, wait=self.wait, timeout=self.timeout, allow_duplicates=self.allow_duplicates, meta=self.meta, volume=self.volume) if not image_id: result.update({"image_create": 0}) LOG.error("Create image failed!") raise exceptions.ScenarioCreateImageError result.update({"image_create": 1}) LOG.info("Create image successful!") keys = self.scenario_cfg.get("output", '').split() values = [image_id] return self._push_to_outputs(keys, values)

tests/blueprints/test_network.py

tssujt/remote

12798998

<reponame>tssujt/remote from unittest.mock import patch import pyipip from dns.exception import DNSException from remote.blueprints.network import IPRecord from tests.test_app import TestBase class TestNetwork(TestBase): _test_domain = "example.com" _test_ip = "127.0.0.1" def test_ip(self): response = self.client.get("/ip") self.assertEqual(response.status_code, 200) _json_body = response.json self.assertIn("success", _json_body) self.assertEqual(_json_body["ip"], response.request.remote_addr) self.assertIn("ipv4", _json_body) self.assertIn("ipv6_available", _json_body) def test_ipip(self): ipdb_func = "remote.blueprints.network._get_ipdb" mock_func = "remote.blueprints.network.pyipip.IPIPDatabase.lookup" fake_ip_fields = "\t".join(map(str, range(len(IPRecord._fields) - 2))) with ( patch(ipdb_func, return_value=pyipip.IPIPDatabase), patch(mock_func, return_value=fake_ip_fields), ): response = self.client.get(f"/ipip/{self._test_ip}") self.assertEqual(response.status_code, 200) _json_body = response.json self.assertIn("success", _json_body) self.assertIn("continent_code", _json_body) self.assertIn("cn_division_code", _json_body) self.assertEqual(set(_json_body.keys()), set(IPRecord._fields)) def test_ipip_error_1(self): response = self.client.get("/ipip/FF:FF") self.assertEqual(response.status_code, 400) _json_body = response.json self.assertIn("IPv6", _json_body["message"]) self.assertEqual(_json_body["status"], "error") self.assertFalse(_json_body["success"]) def test_ipip_error_2(self): response = self.client.get("/ipip/FAKE_IP") self.assertEqual(response.status_code, 400) _json_body = response.json self.assertIn("Invalid", _json_body["message"]) self.assertEqual(_json_body["status"], "error") self.assertFalse(_json_body["success"]) def test_ipip_error_3(self): ipdb_func = "remote.blueprints.network._get_ipdb" with patch(ipdb_func, side_effect=Exception("Mock Exception")): response = self.client.get(f"/ipip/{self._test_ip}") self.assertEqual(response.status_code, 404) _json_body = response.json self.assertIn("not found", _json_body["message"]) self.assertEqual(_json_body["status"], "error") self.assertFalse(_json_body["success"]) def test_resolve(self): response = self.client.get(f"/dns/resolve?domain={self._test_domain}") self.assertEqual(response.status_code, 200) _json_body = response.json self.assertIn("nameservers", _json_body) self.assertIn("ttl", _json_body) self.assertIsInstance(_json_body["answers"], list) def test_resolve_error_1(self): response = self.client.get("/dns/resolve") self.assertEqual(response.status_code, 400) _json_body = response.json self.assertEqual("error", _json_body["status"]) self.assertFalse(_json_body["success"]) self.assertIn("missing", _json_body["message"]) def test_resolve_error_2(self): mock_func = "remote.blueprints.network.dns.resolver.Resolver.resolve" with patch(mock_func, side_effect=DNSException("Mock Exception")): response = self.client.get(f"/dns/resolve?domain={self._test_domain}") self.assertEqual(response.status_code, 400) _json_body = response.json self.assertEqual("error", _json_body["status"]) self.assertFalse(_json_body["success"]) self.assertIn("Unable", _json_body["message"])

api/Mongo/abc_dbops.py

AutoCoinDCF/NEW_API

12798999

<filename>api/Mongo/abc_dbops.py<gh_stars>0 '''AbstractDbOps: 数据库操作接口抽象类 @author: <EMAIL> @last_modified: 2019.6.20 ''' from abc import ABC, abstractmethod class AbstractDbOps(ABC): @abstractmethod def __init__(self): '''初始化 eg: Initialize db instance ''' raise NotImplementedError

card.py

akaeme/BlackJackBot

12799000

#encoding: utf8 __author__ = '<NAME>' __email__ = '<EMAIL>' __license__ = "GPL" __version__ = "0.1" import random class Card(object): suit_names = ["♠️", "♣️", "♦️", "♥️"] rank_names = [None, "Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"] def __init__(self, suit=0, rank=1): self.suit = suit self.rank = rank def __str__(self): """Returns a human-readable string representation.""" return '{}{} '.format(Card.rank_names[self.rank], Card.suit_names[self.suit]) def __repr__(self): return self.__str__() def value(self): return self.rank if self.rank < 10 else 10 def is_ace(self): if self.rank == 1: return True return False def is_ten(self): if self.rank >= 10: return True return False def value(hand): v = sum([c.value() for c in hand]) if len([c for c in hand if c.is_ace()]) > 0 and v <= 11: #if there is an Ace and we don't bust by take the Ace as an eleven return v+10 return v def blackjack(hand): if len(hand) == 2 and hand[0].is_ace() and hand[1].is_ten(): return True if len(hand) == 2 and hand[1].is_ace() and hand[0].is_ten(): return True return False if __name__ == '__main__': shoe = Shoe() shoe.shuffle() print(shoe.deal_cards(2))

Aula04/Exemplo_Arquivos.py

MateusPeschke/CursoPython

12799001

<reponame>MateusPeschke/CursoPython # "r" read - abre o arquivo # "w" write - cria ou substitui um arquivo # "a" append - adiciona novas informações import matplotlib.pyplot as plt import numpy as np arquivo = open(r"C:\Users\67184\Documents\Desenvolvimento_Agil_em_Python_1_2020\aula4\exemplos\cadastro.txt","r") lista_cadastro = [] for pessoa in arquivo: pessoa = pessoa.strip() pessoa = pessoa.split(';') lista_cadastro.append(pessoa) arquivo.close() # for pessoa in lista_cadastro: # if pessoa[0].upper() == '300': # print(pessoa) # break # for pessoa in lista_cadastro: # if pessoa[3].upper() == 'F': # print(pessoa) # # break # for pessoa in lista_cadastro: # if not ('0' in pessoa[0]) and not ('A' in pessoa[1]): # print(pessoa) # # break mulher = [] contador_mulher = 0 for pessoa in lista_cadastro: if pessoa[3] == 'f': mulher.append(pessoa) contador_mulher = contador_mulher + 1 # break arquivo = open(r'C:\Users\67184\Documents\Desenvolvimento_Agil_em_Python_1_2020\aula4\exemplos\mulher.txt','w') for pessoa in mulher: pessoa_str = ';'.join(pessoa)+"\n" arquivo.write(pessoa_str) arquivo.close() homens = [] contador_homens = 0 for pessoa in lista_cadastro: if pessoa[3] == 'm': homens.append(pessoa) contador_homens = contador_homens + 1 # break arquivo = open(r'C:\Users\67184\Documents\Desenvolvimento_Agil_em_Python_1_2020\aula4\exemplos\homens.txt','w') for pessoa in homens: pessoa_str = ';'.join(pessoa)+"\n" arquivo.write(pessoa_str) arquivo.close() maior_idade = [] contador_maior = 0 for pessoa in lista_cadastro: if int(pessoa[2]) >= 18: maior_idade.append(pessoa) contador_maior = contador_maior + 1 # break arquivo = open(r'C:\Users\67184\Documents\Desenvolvimento_Agil_em_Python_1_2020\aula4\exemplos\maior_idade.txt','w') for pessoa in maior_idade: pessoa_str = ';'.join(pessoa)+"\n" arquivo.write(pessoa_str) arquivo.close() menor_idade = [] contador_menor = 0 for pessoa in lista_cadastro: if int(pessoa[2]) < 18: menor_idade.append(pessoa) contador_menor = contador_menor + 1 # break arquivo = open(r'C:\Users\67184\Documents\Desenvolvimento_Agil_em_Python_1_2020\aula4\exemplos\menor_idade.txt','w') for pessoa in menor_idade: pessoa_str = ';'.join(pessoa)+"\n" arquivo.write(pessoa_str) arquivo.close() x = np.linspace(0,2 * np.pi,400) y = np.sin(x ** 2) genero = ("Homens", "Mulheres") quantidade_genero = (contador_homens,contador_mulher) Idade = ('maior','menor') quantidade_idade = (contador_maior,contador_menor) plt.subplot(2,1,1) plt.bar(genero,quantidade_genero) plt.subplot(2,1,2) plt.bar(Idade,quantidade_idade) plt.show()

models.py

foamliu/i-Cloud

12799002

<filename>models.py import math import torch import torch.nn.functional as F import torch.utils.model_zoo as model_zoo from torch import nn from torch.nn import Parameter from config import device, num_classes __all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152'] model_urls = { 'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth', 'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth', 'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth', 'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth', 'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth', } def conv3x3(in_planes, out_planes, stride=1): """3x3 convolution with padding""" return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False) class BasicBlock(nn.Module): expansion = 1 def __init__(self, inplanes, planes, stride=1, downsample=None): super(BasicBlock, self).__init__() self.conv1 = conv3x3(inplanes, planes, stride) self.bn1 = nn.BatchNorm2d(planes) self.relu = nn.ReLU(inplace=True) self.conv2 = conv3x3(planes, planes) self.bn2 = nn.BatchNorm2d(planes) self.downsample = downsample self.stride = stride def forward(self, x): residual = x out = self.conv1(x) out = self.bn1(out) out = self.relu(out) out = self.conv2(out) out = self.bn2(out) if self.downsample is not None: residual = self.downsample(x) out += residual out = self.relu(out) return out class Bottleneck(nn.Module): expansion = 4 def __init__(self, inplanes, planes, stride=1, downsample=None): super(Bottleneck, self).__init__() self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False) self.bn1 = nn.BatchNorm2d(planes) self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(planes) self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False) self.bn3 = nn.BatchNorm2d(planes * 4) self.relu = nn.ReLU(inplace=True) self.downsample = downsample self.stride = stride def forward(self, x): residual = x out = self.conv1(x) out = self.bn1(out) out = self.relu(out) out = self.conv2(out) out = self.bn2(out) out = self.relu(out) out = self.conv3(out) out = self.bn3(out) if self.downsample is not None: residual = self.downsample(x) out += residual out = self.relu(out) return out class SEBlock(nn.Module): def __init__(self, channel, reduction=16): super(SEBlock, self).__init__() self.avg_pool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Sequential( nn.Linear(channel, channel // reduction), nn.PReLU(), nn.Linear(channel // reduction, channel), nn.Sigmoid() ) def forward(self, x): b, c, _, _ = x.size() y = self.avg_pool(x).view(b, c) y = self.fc(y).view(b, c, 1, 1) return x * y class IRBlock(nn.Module): expansion = 1 def __init__(self, inplanes, planes, stride=1, downsample=None, use_se=True): super(IRBlock, self).__init__() self.bn0 = nn.BatchNorm2d(inplanes) self.conv1 = conv3x3(inplanes, inplanes) self.bn1 = nn.BatchNorm2d(inplanes) self.prelu = nn.PReLU() self.conv2 = conv3x3(inplanes, planes, stride) self.bn2 = nn.BatchNorm2d(planes) self.downsample = downsample self.stride = stride self.use_se = use_se if self.use_se: self.se = SEBlock(planes) def forward(self, x): residual = x out = self.bn0(x) out = self.conv1(out) out = self.bn1(out) out = self.prelu(out) out = self.conv2(out) out = self.bn2(out) if self.use_se: out = self.se(out) if self.downsample is not None: residual = self.downsample(x) out += residual out = self.prelu(out) return out class ResNet(nn.Module): def __init__(self, block, layers, use_se=True, im_size=112): self.inplanes = 64 self.use_se = use_se super(ResNet, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, bias=False) self.bn1 = nn.BatchNorm2d(64) self.prelu = nn.PReLU() self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2) self.layer1 = self._make_layer(block, 64, layers[0]) self.layer2 = self._make_layer(block, 128, layers[1], stride=2) self.layer3 = self._make_layer(block, 256, layers[2], stride=2) self.layer4 = self._make_layer(block, 512, layers[3], stride=2) self.bn2 = nn.BatchNorm2d(512) self.dropout = nn.Dropout() if im_size == 112: self.fc = nn.Linear(512 * 7 * 7, 512) else: # 224 self.fc = nn.Linear(512 * 14 * 14, 512) self.bn3 = nn.BatchNorm1d(512) for m in self.modules(): if isinstance(m, nn.Conv2d): nn.init.xavier_normal_(m.weight) elif isinstance(m, nn.BatchNorm2d) or isinstance(m, nn.BatchNorm1d): nn.init.constant_(m.weight, 1) nn.init.constant_(m.bias, 0) elif isinstance(m, nn.Linear): nn.init.xavier_normal_(m.weight) nn.init.constant_(m.bias, 0) def _make_layer(self, block, planes, blocks, stride=1): downsample = None if stride != 1 or self.inplanes != planes * block.expansion: downsample = nn.Sequential( nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(planes * block.expansion), ) layers = [] layers.append(block(self.inplanes, planes, stride, downsample, use_se=self.use_se)) self.inplanes = planes for i in range(1, blocks): layers.append(block(self.inplanes, planes, use_se=self.use_se)) return nn.Sequential(*layers) def forward(self, x): x = self.conv1(x) x = self.bn1(x) x = self.prelu(x) x = self.maxpool(x) x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) x = self.layer4(x) x = self.bn2(x) x = self.dropout(x) x = x.view(x.size(0), -1) x = self.fc(x) x = self.bn3(x) return x def resnet18(args, **kwargs): model = ResNet(IRBlock, [2, 2, 2, 2], use_se=args.use_se, **kwargs) if args.pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet18'])) return model def resnet34(args, **kwargs): model = ResNet(IRBlock, [3, 4, 6, 3], use_se=args.use_se, **kwargs) if args.pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet34'])) return model def resnet50(args, **kwargs): model = ResNet(IRBlock, [3, 4, 6, 3], use_se=args.use_se, im_size=args.im_size, **kwargs) if args.pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet50'])) return model def resnet101(args, **kwargs): model = ResNet(IRBlock, [3, 4, 23, 3], use_se=args.use_se, **kwargs) if args.pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet101'])) return model def resnet152(args, **kwargs): model = ResNet(IRBlock, [3, 8, 36, 3], use_se=args.use_se, **kwargs) if args.pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet152'])) return model class ArcMarginModel(nn.Module): def __init__(self, args): super(ArcMarginModel, self).__init__() self.weight = Parameter(torch.FloatTensor(num_classes, args.emb_size)) nn.init.xavier_uniform_(self.weight) self.easy_margin = args.easy_margin self.m = args.margin_m self.s = args.margin_s self.cos_m = math.cos(self.m) self.sin_m = math.sin(self.m) self.th = math.cos(math.pi - self.m) self.mm = math.sin(math.pi - self.m) * self.m def forward(self, input, label): x = F.normalize(input) W = F.normalize(self.weight) cosine = F.linear(x, W) sine = torch.sqrt(1.0 - torch.pow(cosine, 2)) phi = cosine * self.cos_m - sine * self.sin_m # cos(theta + m) if self.easy_margin: phi = torch.where(cosine > 0, phi, cosine) else: phi = torch.where(cosine > self.th, phi, cosine - self.mm) one_hot = torch.zeros(cosine.size(), device=device) one_hot.scatter_(1, label.view(-1, 1).long(), 1) output = (one_hot * phi) + ((1.0 - one_hot) * cosine) output *= self.s return output from torchvision import models class FrameDetectionModel(nn.Module): def __init__(self): super(FrameDetectionModel, self).__init__() resnet = models.resnet50(pretrained=True) # Remove linear layer (since we're not doing classification) modules = list(resnet.children())[:-1] self.resnet = nn.Sequential(*modules) self.fc = nn.Linear(2048, 8) self.sigmoid = nn.Sigmoid() def forward(self, images): x = self.resnet(images) # [N, 2048, 1, 1] x = x.view(-1, 2048) # [N, 2048] x = self.fc(x) x = self.sigmoid(x) # [N, 8] return x class FaceAttributeModel(nn.Module): def __init__(self): super(FaceAttributeModel, self).__init__() resnet = models.resnet50(pretrained=True) # Remove linear and pool layers (since we're not doing classification) modules = list(resnet.children())[:-1] self.resnet = nn.Sequential(*modules) self.fc = nn.Linear(2048, 17) self.sigmoid = nn.Sigmoid() self.softmax = nn.Softmax(dim=-1) def forward(self, images): x = self.resnet(images) # [N, 2048, 1, 1] x = x.view(-1, 2048) # [N, 2048] x = self.fc(x) reg = self.sigmoid(x[:, :5]) # [N, 8] expression = self.softmax(x[:, 5:8]) gender = self.softmax(x[:, 8:10]) glasses = self.softmax(x[:, 10:13]) race = self.softmax(x[:, 13:17]) return reg, expression, gender, glasses, race class FaceExpressionModel(nn.Module): def __init__(self): super(FaceExpressionModel, self).__init__() resnet = models.resnet101(pretrained=True) # Remove linear and pool layers (since we're not doing classification) modules = list(resnet.children())[:-2] self.resnet = nn.Sequential(*modules) self.dropout = nn.Dropout() self.avgpool = nn.AvgPool2d(kernel_size=4) self.fc = nn.Linear(2048, 7) self.softmax = nn.Softmax(dim=-1) def forward(self, images): x = self.resnet(images) # [N, 2048, 1, 1] x = self.dropout(x) x = self.avgpool(x) x = x.view(-1, 2048) # [N, 2048] x = self.fc(x) out = self.softmax(x) return out class EastModel(nn.Module): def __init__(self, args): super(EastModel, self).__init__() if args.network == 'r18': self.resnet = resnet18(args) elif args.network == 'r34': self.resnet = resnet34(args) elif args.network == 'r50': self.resnet = resnet50(args) elif args.network == 'r101': self.resnet = resnet101(args) else: # args.network == 'r152': self.resnet = resnet152(args) self.relu = nn.ReLU() self.sigmoid = nn.Sigmoid() self.conv1 = nn.Conv2d(in_channels=3072, out_channels=128, kernel_size=1) self.bn1 = nn.BatchNorm2d(128) self.conv2 = nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, padding=1) self.bn2 = nn.BatchNorm2d(128) self.conv3 = nn.Conv2d(in_channels=640, out_channels=64, kernel_size=1) self.bn3 = nn.BatchNorm2d(64) self.conv4 = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, padding=1) self.bn4 = nn.BatchNorm2d(64) self.conv5 = nn.Conv2d(in_channels=320, out_channels=64, kernel_size=1) self.bn5 = nn.BatchNorm2d(64) self.conv6 = nn.Conv2d(in_channels=64, out_channels=32, kernel_size=3, padding=1) self.bn6 = nn.BatchNorm2d(32) self.conv7 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=1) self.bn7 = nn.BatchNorm2d(32) self.conv8 = nn.Conv2d(in_channels=32, out_channels=1, kernel_size=1) self.conv9 = nn.Conv2d(in_channels=32, out_channels=4, kernel_size=1) self.conv10 = nn.Conv2d(in_channels=32, out_channels=1, kernel_size=1) self.unpool1 = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False) self.unpool2 = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False) self.unpool3 = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False) def forward(self, images): _, f = self.resnet(images) h = f[3] # bs 2048 w/32 h/32 g = (self.unpool1(h)) # bs 2048 w/16 h/16 c = self.conv1(torch.cat((g, f[2]), 1)) c = self.bn1(c) c = self.relu(c) h = self.conv2(c) # bs 128 w/16 h/16 h = self.bn2(h) h = self.relu(h) g = self.unpool2(h) # bs 128 w/8 h/8 c = self.conv3(torch.cat((g, f[1]), 1)) c = self.bn3(c) c = self.relu(c) h = self.conv4(c) # bs 64 w/8 h/8 h = self.bn4(h) h = self.relu(h) g = self.unpool3(h) # bs 64 w/4 h/4 c = self.conv5(torch.cat((g, f[0]), 1)) c = self.bn5(c) c = self.relu(c) h = self.conv6(c) # bs 32 w/4 h/4 h = self.bn6(h) h = self.relu(h) g = self.conv7(h) # bs 32 w/4 h/4 g = self.bn7(g) g = self.relu(g) score = self.conv8(g) # bs 1 w/4 h/4 score = self.sigmoid(score) geo_map = self.conv9(g) geo_map = self.sigmoid(geo_map) * 512 angle_map = self.conv10(g) angle_map = self.sigmoid(angle_map) angle_map = (angle_map - 0.5) * math.pi / 2 geo = torch.cat((geo_map, angle_map), 1) # bs 5 w/4 w/4 return score, geo

src/test/data_pipe_test/basic_index_test.py

random-python/data_pipe

12799003

""" """ from data_pipe.basic_index import * from data_pipe_test.verify_index import * def test_log2(): print() assert integer_log2(1) == 0 assert integer_log2(2) == 1 assert integer_log2(4) == 2 assert integer_log2(8) == 3 def test_index_store(): index_store = BasicIndex() verify_index(index_store)

mopidy_radioworld/radioworld.py

anabolyc/Mopidy-RadioWorld

12799004

<filename>mopidy_radioworld/radioworld.py import requests from time import sleep from contextlib import closing import logging logger = logging.getLogger(__name__) class RadioWorld(object): def __init__(self): self._base_uri = 'https://radioworld-api-prod.azurewebsites.net/%s' #self._base_uri = 'http://localhost:5000/%s' self._session = requests.Session() def root(self): results = [{ 'type': 'directory', 'schema': 'rnd', 'id': None, 'text': 'Feeling lucky' }] countries = self._query('countries') if countries is not None: for location in sorted(countries, key=lambda loc: loc['name']): results.append({ 'type': 'directory', 'schema': 'location', 'id': location['id'], 'text': location['name'] }) return results def rnd(self): station = self._query('station/rnd') if station is None: return [] return { 'type': 'track', 'schema': 'station', 'id': station['id'], 'text': station['text'] } def stations(self, id): stations = self._query('location/{}/stations'.format(id)) if stations is None or stations == []: logger.warning("empty response from API") return [] results = [] for station in sorted(stations, key=lambda sta: sta['text']): results.append({ 'type': 'track', 'schema': 'station', 'id': station['id'], 'text': station['text'] }) return results def station(self, id): station = self._query('station/%s' % id) if station is None: logger.warning("empty response from API") return station def image(self, id): return self._base_uri % ("station/{}/image".format(id)) def search(self, q, location_id): results = [] search = self._query("stations/search/{}".format(q)) if location_id is None else self._query("location/{}/search/{}".format(location_id, q)) stations = search['stations'] for station in stations: results.append({ 'type': 'track', 'schema': 'station', 'id': station['id'], 'text': station['text'] }) return results def _query(self, path): uri = (self._base_uri % path) logger.info('RadioWorld request: %s', uri) try: while True: with closing(self._session.get(uri)) as r: r.raise_for_status() logger.debug("RadioWorld response: %s", r.status_code) if r.status_code != 204: return r.json() else: sleep(0.25) except Exception as e: logger.info('RadioWorld API request for %s failed: %s' % (path, e)) return None

pingsweeper.py

allanvictor/pingsweeper

12799005

<filename>pingsweeper.py #!/usr/bin/python import logging logging.getLogger('scapy.runtime').setLevel(logging.ERROR) from scapy.all import * from netaddr import * import socket import sys, getopt def getlive(): for i in live: print('live {0}'.format(i[0].dst)) def getdead(): for j in dead: print('dead {0}'.format(j[0].dst)) def usage(): print('Usage: pingsweeper [options] <ip>\n\t-l show live hosts\n\t-d show dead hosts\n\n--Development By <NAME>--') exit() if(len(sys.argv)>1): opts, args = getopt.getopt(sys.argv[1:],'ldh') try: target=args[0] except: usage() try: ip_range=IPNetwork(target) for ip in ip_range: if str(ip_range.cidr) != str(ip)+'/32': if ip == ip_range.network or ip == ip_range.broadcast: continue live,dead=sr(IP(dst=str(ip))/ICMP(), timeout=1, verbose=0) if not opts: getlive() getdead() else: for opt in opts: if ('-l' in opt): getlive() elif ('-d' in opt): getdead() elif ('h' in opt): usage() except: logging.getLogger(__name__).warning('ERROR:Illegal IP') usage() else: usage()

build.py

Lzhiyong/android-sdk-tools

12799006

#!/usr/bin/env python # # Copyright © 2022 Github Lzhiyong # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # pylint: disable=not-callable, line-too-long, no-else-return import time import argparse import subprocess from pathlib import Path def format_time(seconds): minute, sec = divmod(seconds, 60) hour, minute = divmod(minute, 60) if hour > 0: return "{}h{:02d}m{:02d.2f}s".format(hour, minute, sec) elif minute > 0: return "{}m{:02d.2f}s".format(minute, sec) else: return "{:.2f}s".format(sec) def build(cc, cxx, args): command = ["cmake", "-GNinja", "-B {}".format(args.build), "-DCMAKE_C_COMPILER={}".format(cc), "-DCMAKE_CXX_COMPILER={}".format(cxx), "-DTARGET_ABI={}".format(args.arch), "-DCMAKE_BUILD_TYPE=Release"] if args.protoc is not None and len(str(args.protoc)) > 0: command.append("-DPROTOC_PATH={}".format(args.protoc)) result = subprocess.run(command) start = time.time() if result.returncode == 0: if args.target == "all": result = subprocess.run(["ninja", "-C", args.build, "-j {}".format(args.job)]) else: result = subprocess.run(["ninja", "-C", args.build, args.target, "-j {}".format(args.job)]) if result.returncode == 0: end = time.time() print("\033[1;32mbuild success cost time: {}\033[0m".format(format_time(end - start))) def configure(args): ndk = Path(args.ndk) if not ndk.exists() or not ndk.is_dir(): raise ValueError("cannot find the ndk") toolchain = ndk / "toolchains/llvm/prebuilt/linux-x86_64" cc: Path = Path() cxx: Path = Path() if args.arch == "aarch64": cc = toolchain / "bin" / "aarch64-linux-android{}-clang".format(args.api) cxx = toolchain / "bin" / "aarch64-linux-android{}-clang++".format(args.api) elif args.arch == "arm": cc = toolchain / "bin" / "armv7a-linux-androideabi{}-clang".format(args.api) cxx = toolchain / "bin" / "armv7a-linux-androideabi{}-clang++".format(args.api) elif args.arch == "x86": cc = toolchain / "bin" / "i686-linux-android{}-clang".format(args.api) cxx = toolchain / "bin" / "i686-linux-android{}-clang++".format(args.api) else: cc = toolchain / "bin" / "x86_64-linux-android{}-clang".format(args.api) cxx = toolchain / "bin" / "x86_64-linux-android{}-clang++".format(args.api) if not cc.exists() or not cxx.exists(): print("cc is {}".format(cc)) print("cxx is {}".format(cxx)) raise ValueError("error: cannot find the clang compiler") # start building build(str(cc), str(cxx), args) def main(): parser = argparse.ArgumentParser() parser.add_argument("--ndk", required=True, help="set the ndk toolchain path") parser.add_argument("--arch", choices=["aarch64", "arm", "x86", "x86_64"], required=True, help="build for the specified architecture") parser.add_argument("--api", default=30, help="set android platform level, min api is 30") parser.add_argument("--build", default="build", help="the build directory") parser.add_argument("--job", default=16, help="run N jobs in parallel, default is 16") parser.add_argument("--target", default="all", help="build specified targets such as aapt2 adb fastboot, etc") parser.add_argument("--protoc", help="set the host protoc path") args = parser.parse_args() configure(args) if __name__ == "__main__": main()

airflow_ml_dags/dags/model_train.py

made-ml-in-prod-2021/liliyamakhmutova-

12799007

import pathlib from datetime import timedelta from airflow import DAG from airflow.operators.python import PythonOperator import pandas as pd from sklearn.compose import ColumnTransformer from sklearn.pipeline import Pipeline from sklearn.preprocessing import OneHotEncoder from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression import pickle from sklearn.metrics import accuracy_score, f1_score, roc_auc_score import json from airflow.utils.dates import days_ago def _preprocess_data(): data_df = pd.read_csv("/opt/airflow/data/raw/{{ ds }}/data.csv") target_df = pd.read_csv("/opt/airflow/data/raw/{{ ds }}/target.csv") print(f"data before transform: {data_df}") data_df.drop(columns=["fbs"], inplace=True) data_df["target"] = target_df print(f"data after transform: {data_df}") pathlib.Path("/opt/airflow/data/processed/{{ ds }}").mkdir(parents=True, exist_ok=True) processed_path = "/opt/airflow/data/processed/{{ ds }}/data.csv" print(f"saving processed data to {processed_path}") data_df.to_csv(processed_path, index=False) def _train_val_split(): data = pd.read_csv("/opt/airflow/data/processed/{{ ds }}/data.csv") train_data, test_data = train_test_split(data, train_size=0.8) train_data.to_csv("/opt/airflow/data/processed/{{ ds }}/train.csv", index=False) test_data.to_csv("/opt/airflow/data/processed/{{ ds }}/test.csv", index=False) def _train_model(): train_data = pd.read_csv("/opt/airflow/data/processed/{{ ds }}/train.csv") target = train_data["target"] train_data.drop(columns=["target"], inplace=True) transformer = ColumnTransformer( [ ( 'num', Pipeline([('scaler', StandardScaler())]), ["age", "trestbps", "chol", "thalach", "oldpeak"], ), ( 'cat', Pipeline([('onehot', OneHotEncoder(handle_unknown='ignore'))]), ["sex", "cp", "restecg", "exang", "slope", "ca", "thal"], ), ] ) transformer.fit_transform(train_data) model = LogisticRegression() model.fit(train_data, target) pathlib.Path("/opt/airflow/data/models/{{ ds }}").mkdir(parents=True, exist_ok=True) with open("/opt/airflow/data/models/{{ ds }}/model.pkl", "wb") as f: pickle.dump(model, f) with open("/opt/airflow/data/models/{{ ds }}/transformer.pkl", "wb") as f: pickle.dump(transformer, f) def _test_model(): test_data = pd.read_csv("/opt/airflow/data/processed/{{ ds }}/test.csv") target = test_data["target"] test_data.drop(columns=["target"], inplace=True) model = pickle.load(open("/opt/airflow/data/models/{{ ds }}/model.pkl", "rb")) transformer = pickle.load(open("/opt/airflow/data/models/{{ ds }}/transformer.pkl", "rb")) transformer.transform(test_data) predicts = model.predict(test_data) metrics = { "accuracy": accuracy_score(target, predicts), "f1": f1_score(target, predicts), "roc_auc": roc_auc_score(target, predicts), } pathlib.Path("/opt/airflow/data/metrics/{{ ds }}").mkdir(parents=True, exist_ok=True) with open("/opt/airflow/data/metrics/{{ ds }}/metrics.json", "w") as metric_file: json.dump(metrics, metric_file) with DAG( dag_id="model_train", description="This DAG trains model on synthetic data", start_date=days_ago(0), schedule_interval=timedelta(days=1), ) as dag: preprocess_data = PythonOperator( task_id="data_preprocessing", python_callable=_preprocess_data, dag=dag, ) train_val_split = PythonOperator( task_id="split_data", python_callable=_train_val_split, dag=dag ) train_model = PythonOperator( task_id="train_model", python_callable=_train_model, dag=dag ) test_model = PythonOperator( task_id="test_model", python_callable=_test_model, dag=dag ) preprocess_data >> train_val_split >> train_model >> test_model

core/utils.py

mannyfin/aioget

12799008

<gh_stars>1-10 import os from pathlib import Path import shutil import json import asyncio import concurrent.futures from functools import partial from datetime import datetime, timedelta from typing import Union, List, Coroutine, Callable, Tuple, Optional from multiprocessing import cpu_count import pickle from deprecated.sphinx import deprecated from configs.base import consts from core import logger basiclogger = logger.rabbit_logger(__name__) def pop_arb_field_if_exists(msg: dict) -> Tuple[dict, dict]: """values in the arb field exepected to be a dictionary.""" if 'arb' in msg: arb = msg.pop('arb') return arb, msg return {}, msg def set_arb(msg: dict, arb: dict) -> dict: if arb: msg['arb'] = arb return msg def load_config(path: str) -> dict: """ Provide path to load the JSON config Args: path: str, should be path to JSON file Returns: Any JSON-serializable data. Usually a dict for the config files. """ with open(path, 'r') as f: config = json.load(f) return config def make_config(paths): configs = {} for fp in paths: business_driver = Path(fp).parent.stem #os.path.split(fp[0])[1] #fp.rsplit('/', 2)[1] if business_driver not in configs: configs[business_driver] = {} newconfig = load_config(fp) for key, val in newconfig.items(): configs[business_driver][key] = val return configs def load_model(path: str, mode: str = 'rb', response_encoding=None): with open(path, mode) as f: model = pickle.load(f) return model def merge_configs(driver: dict, client: dict) -> dict: """ Merge Driver and Client config. The Client configs will overwrite matching keys in the Driver config. Args: driver (dict): driver dictionary of configs client (dict): client dictionary of configs Returns: Merged configs (dict) """ return {**driver, **client} # def process_pool(workers: int, # func: Callable, # iterable: Union[list, tuple, asyncio.Queue]) -> List[Coroutine]: # """ # Pass an iterable to a process pool and return a list of asyncio futures. # # Args: # workers: Number of workers in the Process Pool # func: function # iterable: unique values you will pass to each process # args: additional values passed to every process # kwargs: additional values passed to every process # # Returns: # List of asyncio.Futures # # Examples: # # .. code-block:: python # :linenos: # # def cpu_bound_func(a, b=b): # # CPU-bound operations will block the event loop: # # in general it is preferable to run them in a # # process pool. Simulating this. with arg and kwarg. # time.sleep(1) # return a**2, b*-1 # # def async_process_pool(workers: int, func: Callable, iterable, *args, **kwargs) -> list: # if workers <= 0: # workers = cpu_count() # loop = asyncio.get_running_loop() # with concurrent.futures.ProcessPoolExecutor(workers) as pool: # return [loop.run_in_executor(pool, partial(func, _ , *args, **kwargs)) for _ in iterable] # # # submitting futures to the process pool and getting results as completed. Not necessarily in order. # async def exhaust_async_process_pool(): # for _ in asyncio.as_completed(async_process_pool(0, cpu_bound_func, list(range(8)), b=2)): # result = await _ # print(result) # # start = time.time() # asyncio.run(exhaust_async_process_pool()) # end = time.time() - start # print(end) # should take a littler longer than math.ceil(8/workers) due to process overhead. # # # Output: # # (1, -2) # (0, -2) # (9, -2) # (4, -2) # (16, -2) # (25, -2) # (36, -2) # # .. todo:: make this work with async queues correctly... # """ # if workers <= 0: # workers = cpu_count() # loop = asyncio.get_running_loop() # with concurrent.futures.ProcessPoolExecutor(workers) as pool: # if isinstance(iterable, (list, tuple)): # return [loop.run_in_executor(pool, partial(func, **value)) for value in iterable] # elif isinstance(iterable, asyncio.Queue): # # todo make this work # futures = [] # for ctr in range(iterable.qsize()): # value = iterable.get_nowait() # futures.append(loop.run_in_executor(pool, partial(func, **value))) # iterable.task_done() # return futures async def parse_consumer(next_queue: asyncio.Queue, write_queue: asyncio.Queue, func: Optional[Callable] = None): """ Parses the response html in a concurrent.futures.ProcessPoolExcecutor Process Pool. This function checks if next_queue is empty. If it is not, then it empties it by getting each item in next_queue and passing to the Process Pool and returing a future. The future is then put on the write_queue. If queue's requests are completed and next_queue has completed (i.e. no unfinished tasks in either queue), then break. .. todo:: this could be refactored by async_queue.worker Args: next_queue: queue containing the responses write_queue: queue to put the list of asyncio.Futures on queue: queue containing the requests to be made. It is used to know when to finish this task func: function to use in the process pool. This is self.parse Returns: None """ pool = concurrent.futures.ProcessPoolExecutor(max(cpu_count(), 8)) # pool = concurrent.futures.ProcessPoolExecutor(1) # useful for debugging loop = asyncio.get_running_loop() while True: await asyncio.sleep(consts.ASYNC_SLEEP) if not next_queue.empty(): value = await next_queue.get() if not func: func = value.pop('parse_func') futs = loop.run_in_executor(pool, partial(func, **value)) await write_queue.put(futs) func = None # futures.append(loop.run_in_executor(pool, partial(func, **value))) next_queue.task_done() # if not queue._unfinished_tasks and not next_queue._unfinished_tasks: # break pool.shutdown() # not very useful...

qaboard/runners/celery_app.py

Samsung/qaboard

12799009

<reponame>Samsung/qaboard import os import subprocess from celery import Celery app = Celery('celery_app') app.conf.update( broker_url=os.environ.get('CELERY_BROKER_URL', 'pyamqp://guest@localhost//'), result_backend=os.environ.get('CELERY_RESULT_BACKEND', 'rpc://'), task_serializer='pickle', accept_content=['pickle'], result_serializer='pickle', enable_utc=True, ) from qaboard.config import config celery_config = config.get('runners', {}).get('celery', {}) app.conf.update(**celery_config) @app.task(bind=True, name=celery_config.get('qaboard_task_name', "qaboard")) def start(self, job, cwd=None): # https://docs.celeryproject.org/en/stable/userguide/tasks.html#task-request-info print('Executing task id {0.id}, groupID: {0.group}'.format(self.request)) pipe = subprocess.PIPE with subprocess.Popen(job.run_context.command, shell=True, encoding='utf-8', # Avoid issues with code outputing malformed unicode # https://docs.python.org/3/library/codecs.html#error-handlers errors='surrogateescape', cwd=cwd if cwd else job.run_context.job_options['cwd'], stdout=pipe, stderr=pipe) as process: for line in process.stdout: print(line, end='') process.wait() return process.returncode

src/tf_frodo/__init__.py

xarion/tf_frodo

12799010

from .frodo import FRODO

day10/python/subesokun/main.py

matason/aoc-2018

12799011

<gh_stars>10-100 INPUT_FILE_NAME = 'input.txt' def parseSpotInput(text): tmp_split = text.split('>') pos_str, velo_str = tmp_split[0], tmp_split[1] pos = tuple([int(coord) for coord in pos_str.replace(' ', '').split('<')[1].split(',')]) velo = tuple([int(velo) for velo in velo_str.replace(' ', '').split('<')[1].split(',')]) return [pos, velo] def hasSpotAt(x, y, spots): for spot in spots: if spot[0] == (x,y): return True return False def printSpots(spots): min_x = min(spots, key = lambda s: s[0][0])[0][0] max_x = max(spots, key = lambda s: s[0][0])[0][0] min_y = min(spots, key = lambda s: s[0][1])[0][1] max_y = max(spots, key = lambda s: s[0][1])[0][1] for y in range(min_y, max_y + 1): print(''.join(['#' if hasSpotAt(x, y, spots) else ' ' for x in range(min_x, max_x + 1)])) def tick(spots, dir=1): for spot in spots: spot[0] = (spot[0][0] + dir * spot[1][0], spot[0][1] + dir * spot[1][1]) def searchAndPrint(spots): current_min_delta_y = None current_second = 0 while True: tick(spots) current_second += 1 min_y = min(spots, key = lambda s: s[0][1])[0][1] max_y = max(spots, key = lambda s: s[0][1])[0][1] min_delta_y = max_y - min_y if current_min_delta_y == None or min_delta_y < current_min_delta_y: current_min_delta_y = min_delta_y else: tick(spots, -1) printSpots(spots) return current_second - 1 spots = [] with open(INPUT_FILE_NAME) as input_file: for line in input_file: spots.append(parseSpotInput(line.rstrip())) print('Solution to part 1:') seconds = searchAndPrint(spots) print('Solution to part 2: %i' % (seconds,))

register_api/views.py

BrenonOrtega/bug_catcher

12799012

<filename>register_api/views.py from django.conf import settings from django.contrib.auth.models import User from django.http.response import Http404 from django.contrib.auth import get_user from django.shortcuts import render from rest_framework import status, mixins from rest_framework.response import Response from rest_framework.views import APIView, View from .models import Bug from .serializers import BugReadSerializer, BugWriteSerializer, UserReadSerializer class BugList(APIView): def get(self, request): bug = Bug.objects.all() serializer = BugReadSerializer(bug, many=True) return Response(serializer.data, status=status.HTTP_200_OK) """ def post(self, request): serializer = BugWriteSerializer(data=request.data) """ def post(self, request): author = get_user(request) if author.is_authenticated : serializer = BugWriteSerializer(data = request.data) if serializer.is_valid(): serializer.save(author=author) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) else: return Response(status=status.HTTP_403_FORBIDDEN) class BugDetails(APIView, mixins.DestroyModelMixin): def get_object(self, pk): try: bug_object = Bug.objects.get(pk=pk) return bug_object except: raise Http404 def get(self, request, pk): bug = self.get_object(pk) serializer = BugReadSerializer(bug) return Response(serializer.data, status=status.HTTP_200_OK) def put(self, request, pk): bug = self.get_object(pk) serializer = BugWriteSerializer(bug, request.data) modifier = get_user(request) if modifier.is_authenticated: if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) else: return Response(status=status.HTTP_403_FORBIDDEN) ##################################################################################### class BugListPage(View): def get(self, request): bugs = Bug.objects.all() context = {"bugs": bugs} return render(request, "home.html", context) class GetUserBugs(APIView): def get(self, request): user = User.objects.all() serializer = UserReadSerializer(user, many=True) return Response(serializer.data, status=status.HTTP_200_OK)

resources/tools/presentation/pal.py

nidhyanandhan/csit

12799013

<gh_stars>0 # Copyright (c) 2019 Cisco and/or its affiliates. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at: # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """CSIT Presentation and analytics layer. """ import sys import argparse import logging from pal_errors import PresentationError from environment import Environment, clean_environment from specification_parser import Specification from input_data_parser import InputData from generator_tables import generate_tables from generator_plots import generate_plots from generator_files import generate_files from static_content import prepare_static_content from generator_report import generate_report from generator_cpta import generate_cpta from generator_alerts import Alerting, AlertingError def parse_args(): """Parse arguments from cmd line. :returns: Parsed arguments. :rtype: ArgumentParser """ parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter ) parser.add_argument( u"-s", u"--specification", required=True, type=argparse.FileType(u'r'), help=u"Specification YAML file." ) parser.add_argument( u"-r", u"--release", default=u"master", type=str, help=u"Release string of the product." ) parser.add_argument( u"-w", u"--week", default=u"1", type=str, help=u"Calendar week when the report is published." ) parser.add_argument( u"-l", u"--logging", choices=[u"DEBUG", u"INFO", u"WARNING", u"ERROR", u"CRITICAL"], default=u"ERROR", help=u"Logging level." ) parser.add_argument( u"-f", u"--force", action=u"store_true", help=u"Force removing the old build(s) if present." ) parser.add_argument( u"-o", u"--print-all-oper-data", action=u"store_true", help=u"Print all operational data to console. Be careful, the output " u"can be really long." ) parser.add_argument( u"-i", u"--input-file", type=str, default=u"", help=u"XML file generated by RobotFramework which will be processed " u"instead of downloading the data from Nexus and/or Jenkins. In " u"this case, the section 'input' in the specification file is " u"ignored." ) parser.add_argument( u"-d", u"--input-directory", type=str, default=u"", help=u"Directory with XML file(s) generated by RobotFramework or with " u"sub-directories with XML file(s) which will be processed " u"instead of downloading the data from Nexus and/or Jenkins. In " u"this case, the section 'input' in the specification file is " u"ignored." ) return parser.parse_args() def main(): """Main function.""" log_levels = {u"NOTSET": logging.NOTSET, u"DEBUG": logging.DEBUG, u"INFO": logging.INFO, u"WARNING": logging.WARNING, u"ERROR": logging.ERROR, u"CRITICAL": logging.CRITICAL} args = parse_args() logging.basicConfig(format=u"%(asctime)s: %(levelname)s: %(message)s", datefmt=u"%Y/%m/%d %H:%M:%S", level=log_levels[args.logging]) logging.info(u"Application started.") try: spec = Specification(args.specification) spec.read_specification() except PresentationError: logging.critical(u"Finished with error.") return 1 if spec.output[u"output"] not in (u"none", u"report", u"trending"): logging.critical( f"The output {spec.output[u'output']} is not supported." ) return 1 ret_code = 1 try: env = Environment(spec.environment, args.force) env.set_environment() prepare_static_content(spec) data = InputData(spec) if args.input_file: data.process_local_file(args.input_file) elif args.input_directory: data.process_local_directory(args.input_directory) else: data.download_and_parse_data(repeat=1) if args.print_all_oper_data: data.print_all_oper_data() generate_tables(spec, data) generate_plots(spec, data) generate_files(spec, data) if spec.output[u"output"] == u"report": generate_report(args.release, spec, args.week) elif spec.output[u"output"] == u"trending": sys.stdout.write(generate_cpta(spec, data)) try: alert = Alerting(spec) alert.generate_alerts() except AlertingError as err: logging.warning(repr(err)) else: logging.info("No output will be generated.") logging.info(u"Successfully finished.") ret_code = 0 except AlertingError as err: logging.critical(f"Finished with an alerting error.\n{repr(err)}") except PresentationError as err: logging.critical(f"Finished with a PAL error.\n{str(err)}") except (KeyError, ValueError) as err: logging.critical(f"Finished with an error.\n{repr(err)}") finally: if spec is not None: clean_environment(spec.environment) return ret_code if __name__ == u"__main__": sys.exit(main())

machine_learning/classification.py

soikkea/python-algorithms

12799014

"""Classification methods.""" import numpy as np from machine_learning.constants import N_CLASSES, FOLDS, MAX_K, RANDOM_SEED from machine_learning.utilities import k_fold_split_indexes, get_k_nn def classification(method, error_func, train, test, **kwargs): """Perform classification for data and return error. Arguments: method {function} -- Classification method. error_func {function} -- Error function. train {DataTuple} -- Training data. test {DataTuple} -- Test data. All extra keyword arguments are passed to method. Returns: float -- Error value returned by error_func. """ y_pred = method(train, test, **kwargs) return error_func(y_pred, test.y.values) def max_classifier(train, test): """Maximum classifier. Classifies using the most common class in training data. Arguments: train {DataTuple} -- Training data. test {DataTuple} -- Test data. Returns: ndarray -- Predicted values. """ max_category = max_classifier_fit(train.X, train.y) y_pred = max_classifier_predict(test.X, max_category) return y_pred def max_classifier_fit(X, y): """Determines the most common class in input. Arguments: X {DataFrame} -- Indendent variables. y {DataFrame} -- Dependent variable. Returns: int -- Most common class. """ y = y.values max_category = np.bincount(y.astype(int)).argmax() return max_category def max_classifier_predict(X, max_category): """Classify using max classifier. Arguments: X {DataFrame} -- Independent variables. max_category {int} -- Class to classify to. Returns: ndarray -- Predicted values. """ y_pred = np.ones((X.shape[0], 1), dtype=np.int) * max_category return y_pred def multinomial_naive_bayes_classifier(train, test, n_classes=N_CLASSES): """Multinomial naive bayes classifier. See more at: https://en.wikipedia.org/wiki/Naive_Bayes_classifier#Multinomial_naive_Bayes Arguments: train {DataTuple} -- Training data. test {DataTuple} -- Test data. Keyword Arguments: n_classes {int} -- Number of classes. (default: {N_CLASSES}) Returns: ndarray -- Predicted values. """ train_X = train.X.values train_y = train.y.values test_X = test.X.values class_priors, feature_likelihoods = mnb_classifier_fit(train_X, train_y, n_classes) y_pred = mnb_classifier_predict(test_X, class_priors, feature_likelihoods) return y_pred def mnb_classifier_fit(X, y, n_classes): """Fit MNB classifier. Calculates class priors and feature likelihoods. Arguments: X {ndarray} -- Independent variables. y {ndarray} -- Dependent variables. n_classes {int} -- Number of classes. Returns: ndarray -- Class priors. ndarray -- Feature likelihoods. """ class_priors = mnb_class_priors(y, n_classes) feature_likelihoods = mnb_feature_likelihoods(X, y, n_classes) return class_priors, feature_likelihoods def mnb_class_priors(y, n_classes): """Calculates the logaritm of the probability of belonging to each class. Arguments: y {ndarray} -- Class labels. n_classes {int} -- Number of class labels. Returns: ndarray -- Log of prior probabilities. """ priors = np.zeros(n_classes) for c in range(n_classes): priors[c] = np.log(np.sum(y == c) / y.size) return priors def mnb_feature_likelihoods(X, y, n_classes): """Calculates the probability of feature j, given class k, using Laplace smoothing. Arguments: X {ndarray} -- Features. y {ndarray} -- Class labels. n_classes {int} -- Number of classes. Returns: ndarray -- Logs of feature likelihoods. """ n_features = X.shape[1] p_ij = np.zeros((n_classes, n_features)) for c in range(n_classes): Fc_sum = np.sum(X[y == c, :]) for j in range(n_features): Fnc = np.sum(X[y == c, j]) p_ij[c, j] = np.log((1.0 + Fnc) / (n_features + Fc_sum)) return p_ij def mnb_classifier_predict(X, class_priors, feature_likelihoods): """Classify using MNB classifier. Arguments: X {ndarray} -- Independent variables. class_priors {ndarray} -- Class priors. feature_likelihoods {ndarray} -- Feature likelihoods. Returns: ndarray -- Predicted values. """ n_classes = class_priors.size N = X.shape[0] posterior = np.zeros((N, n_classes)) for i in range(N): posterior[i, :] = feature_likelihoods.dot(X[i, :]) for c in range(n_classes): posterior[:, c] = posterior[:, c] + class_priors[c] y_pred = np.argmax(posterior, axis=1) return y_pred def k_nn_classifier(train, test, k): """K-nearest neighbors classifier. Arguments: train {DataTuple} -- Training data. test {DataTuple} -- Test data. k {int} -- Value for k. Returns: ndarray -- Predicted values. """ y_pred = k_nn_classifier_predict(test.X, train.X, train.y, k) return y_pred def k_nn_classifier_fit(train, n_folds=FOLDS, max_k=MAX_K): """'Fit' K-nearest neighbors classifier by finding optimal value for k using cross validation. Arguments: train {DataTuple} -- Training data. Keyword Arguments: n_folds {int} -- Number of folds to use for validation. (default: {FOLDS}) max_k {int} -- Maximum value for k. (default: {MAX_K}) Returns: int -- Optimal value for k. float -- Error for selected k. """ # TODO: combine with k_nn_regression_fit()? X = train.X.values y = train.y.values N = X.shape[0] folds = k_fold_split_indexes(N, n_folds) min_error = np.infty best_k = 1 for k in range(1, max_k): errors = np.zeros(n_folds) for i in range(n_folds): tmp_folds = folds[:] valid_ix = tmp_folds.pop(i) train_ix = np.concatenate(tmp_folds) y_pred = k_nn_classifier_predict(X[valid_ix, :], X[train_ix, :], y[train_ix], k) error = classification_error(y_pred, y[valid_ix]) errors[i] = (valid_ix.size * error) mean_error = np.sum(errors) / N if mean_error < min_error: min_error = mean_error best_k = k return int(best_k), min_error def k_nn_classifier_predict(X, X_train, y_train, k, n_classes=N_CLASSES): """Classify using K-nearest neighbors classifier. Assigns class labels based on the most common class in k-nearest neighbors. Arguments: X {DataFrame} -- Independent variables. X_train {DataFrame} -- Independent training variables. y_train {DataFrame} -- Dependent training variables. k {int} -- Value of k. Keyword Arguments: n_classes {int} -- Number of classes. (default: {N_CLASSES}) Returns: ndarray -- Predicted variables. """ try: X = X.values except AttributeError: pass try: X_train = X_train.values except AttributeError: pass try: y_train = y_train.values except AttributeError: pass assert X.shape[1] == X_train.shape[1] N = X.shape[0] y_pred = np.zeros((N, 1)) for i in range(N): point = X[i, :] neighbors, _ = get_k_nn(point, X_train, k) train_labels = y_train[neighbors] class_sums = [np.sum(train_labels == i) for i in range(n_classes)] y_pred[i] = k_nn_assign_label(class_sums) return y_pred def k_nn_assign_label(class_sums): """Assing label according the most common class. If there are multiple candidates, pick one randomly. Arguments: class_sums {list} -- Class frequencies. Returns: int -- Assinged class label. """ order = np.argsort(class_sums)[::-1] candidates = [x for x in order if x == order[0]] return np.random.RandomState(RANDOM_SEED).choice(candidates) def classification_error(y_pred, y_true): """Return classification error. Sum of incorrectly assinged classes divided by the number of points. Arguments: y_pred {ndarray} -- Predicted values. y_true {ndarray} -- True values. Returns: float -- Error. """ y_true = y_true.reshape(y_pred.shape) return np.sum(y_pred.astype(np.int) != y_true.astype(np.int)) / float(y_pred.size)

test/unit/test_providers_raw_master_key_config.py

farleyb-amazon/aws-encryption-sdk-python

12799015

<filename>test/unit/test_providers_raw_master_key_config.py<gh_stars>10-100 # Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"). You # may not use this file except in compliance with the License. A copy of # the License is located at # # http://aws.amazon.com/apache2.0/ # # or in the "license" file accompanying this file. This file is # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF # ANY KIND, either express or implied. See the License for the specific # language governing permissions and limitations under the License. """Unit test suite to validate aws_encryption_sdk.key_providers.raw.RawMasterKeyConfig""" import pytest import six from aws_encryption_sdk.identifiers import EncryptionKeyType, WrappingAlgorithm from aws_encryption_sdk.internal.crypto.wrapping_keys import WrappingKey from aws_encryption_sdk.key_providers.base import MasterKeyConfig from aws_encryption_sdk.key_providers.raw import RawMasterKeyConfig from .unit_test_utils import all_invalid_kwargs, all_valid_kwargs pytestmark = [pytest.mark.unit, pytest.mark.local] STATIC_WRAPPING_KEY = WrappingKey( wrapping_algorithm=WrappingAlgorithm.AES_256_GCM_IV12_TAG16_NO_PADDING, wrapping_key=b"_________a symmetric key________", wrapping_key_type=EncryptionKeyType.SYMMETRIC, ) VALID_KWARGS = { RawMasterKeyConfig: [ dict(key_id=b"a raw key", provider_id="a provider", wrapping_key=STATIC_WRAPPING_KEY), dict(key_id=b"a raw key", provider_id=b"a provider", wrapping_key=STATIC_WRAPPING_KEY), ] } @pytest.mark.parametrize("cls, kwargs", all_valid_kwargs(VALID_KWARGS)) def test_attributes_valid_kwargs(cls, kwargs): cls(**kwargs) @pytest.mark.parametrize("cls, kwargs", all_invalid_kwargs(VALID_KWARGS)) def test_attributes_invalid_kwargs(cls, kwargs): with pytest.raises(TypeError): cls(**kwargs) def test_parent(): assert issubclass(RawMasterKeyConfig, MasterKeyConfig) @pytest.mark.parametrize("cls, kwargs", all_valid_kwargs(VALID_KWARGS)) def test_attributes_converts(cls, kwargs): test = cls(**kwargs) assert isinstance(test.provider_id, six.string_types)

spatiotemporal/db/functions.py

ResonantGeoData/django-image-annotations

12799016

"""Django database functions. This module supplements Django's own coverage of Postgres and PostGIS functions. https://docs.djangoproject.com/en/4.0/ref/models/expressions/#func-expressions-1 """ from django.contrib.gis.db.models import GeometryField, LineStringField, PointField from django.db.models import FloatField, Func class Box3D(Func): """Compute the 3D bounding box of a geometry.""" function = "Box3D" output_field = GeometryField() class XMax(Func): """Returns the X maxima of a 2D or 3D bounding box or a geometry.""" function = "ST_XMax" output_field = FloatField() class XMin(Func): """Returns the X minima of a 2D or 3D bounding box or a geometry.""" function = "ST_XMin" output_field = FloatField() class YMax(Func): """Returns the Y maxima of a 2D or 3D bounding box or a geometry.""" function = "ST_YMax" output_field = FloatField() class YMin(Func): """Returns the Y minima of a 2D or 3D bounding box or a geometry.""" function = "ST_YMin" output_field = FloatField() class ZMax(Func): """Returns the Z maxima of a 2D or 3D bounding box or a geometry.""" function = "ST_ZMax" output_field = FloatField() class ZMin(Func): """Returns the Z minima of a 2D or 3D bounding box or a geometry.""" function = "ST_ZMin" output_field = FloatField() class MakePoint(Func): """Compute the pixel type of the first band of a raster.""" function = "ST_MakePoint" output_field = PointField(srid=0) class MakeLine(Func): """Compute the pixel type of the first band of a raster.""" function = "ST_MakeLine" output_field = LineStringField(srid=0)

reskit/util/leap_day.py

OfficialCodexplosive/RESKit

12799017

import numpy as np import pandas as pd from . import ResError def remove_leap_day(timeseries): """Removes leap days from a given timeseries Parameters ---------- timeseries : array_like The time series data to remove leap days from * If something array_like is given, the length must be 8784 * If a pandas DataFrame or Series is given, time indexes will be used directly Returns ------- Array """ if isinstance(timeseries, np.ndarray): if timeseries.shape[0] == 8760: return timeseries elif timeseries.shape[0] == 8784: times = pd.date_range("01-01-2000 00:00:00", "12-31-2000 23:00:00", freq="H") sel = np.logical_and((times.day == 29), (times.month == 2)) if len(timeseries.shape) == 1: return timeseries[~sel] else: return timeseries[~sel, :] else: raise ResError('Cannot handle array shape ' + str(timeseries.shape)) elif isinstance(timeseries, pd.Series) or isinstance(timeseries, pd.DataFrame): times = timeseries.index sel = np.logical_and((times.day == 29), (times.month == 2)) if isinstance(timeseries, pd.Series): return timeseries[~sel] else: return timeseries.loc[~sel] else: return remove_leap_day(np.array(timeseries))

accounts/migrations/0002_auto_20190727_1159.py

Alwin1847207/Hackathon

12799018

# Generated by Django 2.2.3 on 2019-07-27 06:29 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('accounts', '0001_initial'), ] operations = [ migrations.CreateModel( name='Article', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('title', models.CharField(max_length=1000)), ('desc', models.CharField(max_length=1000)), ], ), migrations.CreateModel( name='UserProfile', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('type_usr', models.IntegerField()), ('phone', models.CharField(max_length=15)), ], ), migrations.AddField( model_name='registration', name='userType', field=models.CharField(blank=True, max_length=50), ), ]

pipekit/__init__.py

DrDub/pipekit

12799019

<reponame>DrDub/pipekit #!/usr/bin/env python3 from .pipe import NullPipe # noqa: W0611

djforms/alumni/urls.py

carthagecollege/django-djforms

12799020

<gh_stars>1-10 # -*- coding: utf-8 -*- from django.urls import path from django.views.generic import TemplateView from djforms.alumni.classnotes import views as classnotes from djforms.alumni.distinguished import views as distinguished from djforms.alumni.memory import views as memory urlpatterns = [ path( 'success/', TemplateView.as_view(template_name='alumni/data_entered.html'), ), # classnotes path( 'classnotes/carthaginian/', classnotes.screenscrape, name='classnotes_carthaginian', ), path( 'classnotes/success/', TemplateView.as_view(template_name='alumni/classnotes/done.html'), name='classnotes_success', ), path( 'classnotes/archives/<int:year>/', classnotes.archives, name='classnotes_archives_year', ), path( 'classnotes/archives/', classnotes.archives, name='classnotes_archives', ), path( 'classnotes/inmemoriam/', classnotes.obits, name='classnotes_obits', ), path( 'classnotes/', classnotes.contact, name='classnotes_form', ), # distinguised alumni nomination path( 'distinguished/nomination/success/', TemplateView.as_view(template_name='alumni/data_entered.html'), name='distinguished_nomination_success', ), path( 'distinguished/nomination/', distinguished.nomination_form, name='distinguished_nomination_form', ), # fond memories path( 'memory/success/', TemplateView.as_view(template_name='alumni/memory/done.html'), name='memory_questionnaire_success', ), path( 'memory/archives/', memory.questionnaire_archives, name='memory_questionnaire_archives', ), path( 'memory/<int:quid>/detail/', memory.questionnaire_detail, name='memory_questionnaire_detail', ), path( 'memory/<str:campaign>/', memory.questionnaire_form, name='memory_questionnaire_promo_form', ), path( 'memory/', memory.questionnaire_form, name='memory_questionnaire_form', ), ]

utils/messages/create-welsh-translations.py

hmrc/cds-reimbursement-claim-frontend

12799021

import csv import sys def write_welsh_translations(csv_file_name, output_file_name): with open(csv_file_name, newline='') as csv_file: messages = csv.reader(csv_file, delimiter=',') output_file = open(output_file_name, 'w+') # skip headers for i in range(2): next(messages, None) # write translations try: invalid = [] for message in messages: key = message[0].strip() welsh = message[2].strip() if not key: output_file.write('\n') elif key.startswith('#'): if len(key) == 1: output_file.write(key + '===================================================\n') else: output_file.write(key + '\n') elif len(welsh) > 0: output_file.write('{}={}\n'.format(key, welsh)) else: invalid.append(message) print('Finished') print('Invalid records: ', len(invalid)) for x in invalid: print('* {}'.format(x)) except IOError: print("Error writing translations") output_file.close() if __name__ == '__main__': output_file_name = "messages.cy" if len(sys.argv) < 2: print('Error: please provide the source CSV file name including fullpath in command line arguments') print('Usage: create_welsh_messages.py [CSV file name] [output file name]\n') print('Note: output file name is optional, default name is "{}"'.format(output_file_name)) else: write_welsh_translations(sys.argv[1], sys.argv[2] if len(sys.argv) == 3 else output_file_name)

dtu-api/dtu_api/model/database.py

demitri/DtU_api

12799022

<reponame>demitri/DtU_api #!/usr/bin/python ''' This file handles a database connection. It can simply be deleted if not needed. The example given is for a PostgreSQL database, but can be modified for any other. ''' import psycopg2 from ..config import AppConfig from ..designpatterns import singleton config = AppConfig() @singleton class MyApplicationDatabase(object): def __init__(self): self.pool = None def pool(self, release): ''' Return the pool of database connections for the database connected. ''' # ----------------------------------- # Database connection setup & methods # ----------------------------------- # Ref: http://initd.org/psycopg/docs/module.html # Ref: http://packages.python.org/psycopg2/pool.html#module-psycopg2.pool # dsn = data source name if self.pool is None: db_info = {} #for key in self.config.options(""): # db_info[key] = config. return self.pool ### etc. ### ## TODO: create a sample db file for PostgreSQL, SQLite, and SQLAlchemy

polarization/profiles.py

woutergins/polarization

12799023

<reponame>woutergins/polarization<filename>polarization/profiles.py """ .. module:: profiles :platform: Windows :synopsis: Implementation of classes for different lineshapes, creating callables for easy and intuitive calculations. .. moduleauthor:: <NAME> <<EMAIL>> .. moduleauthor:: <NAME> <<EMAIL>> """ import numpy as np from scipy.special import wofz from scipy.interpolate import interp1d __all__ = ['Gaussian', 'Lorentzian', 'Voigt', 'PseudoVoigt', 'ExtendedVoigt', 'Irrational', 'HyperbolicSquared'] sqrt2 = 2 ** 0.5 sqrt2pi = (2 * np.pi) ** 0.5 sqrt2log2t2 = 2 * np.sqrt(2 * np.log(2)) base_e = np.exp(1) class Profile(object): def __init__(self, fwhm=None, mu=None, amp=None, ampIsArea=False): super(Profile, self).__init__() self.ampIsArea = ampIsArea self.fwhm = np.abs(fwhm) if fwhm is not None else np.abs(1.0) self.mu = mu if mu is not None else 0.0 self.amp = amp if amp is not None else 1.0 def __repr__(self): s = str(type(self)) + 'FWHM: {}, mu: {}, amp: {}' s = s.format(self.fwhm, self.mu, self.amp) return s def __call__(self, vals): if self.ampIsArea: factor = 1.0 else: factor = self._normFactor vals = vals / factor return self.amp * vals class Gaussian(Profile): r"""A callable normalized Gaussian profile. Parameters ---------- fwhm: float Full Width At Half Maximum, defaults to 1. mu: float Location of the center, defaults to 0. amp: float Amplitude of the profile, defaults to 1. Returns ------- Gaussian Callable instance, evaluates the Gaussian profile in the arguments supplied. Note ---- The used formula is taken from the MathWorld webpage http://mathworld.wolfram.com/GaussianFunction.html: .. math:: G(x;\mu, \sigma) &= \frac{\exp\left(-\frac{1}{2}\left(\frac{x-\mu} {\sigma}\right)^2\right)}{\sqrt{2\pi}\sigma} FWHM &= s\sqrt{2\ln\left(2\right)}\sigma""" def __init__(self, fwhm=None, mu=None, amp=None, **kwargs): super(Gaussian, self).__init__(fwhm=fwhm, mu=mu, amp=amp, **kwargs) @property def fwhm(self): return self._fwhm @fwhm.setter def fwhm(self, value): self._fwhm = value self.sigma = self.fwhm / (sqrt2log2t2) if not self.ampIsArea: self._normFactor = (self.sigma * sqrt2pi) ** (-1) def __call__(self, x): x = x - self.mu expPart = np.exp(-0.5 * (x / self.sigma) ** 2) normPart = self.sigma * sqrt2pi return super(Gaussian, self).__call__(expPart / normPart) class Lorentzian(Profile): r"""A callable normalized Lorentzian profile. Parameters ---------- fwhm: float Full Width At Half Maximum, defaults to 1. mu: float Location of the center, defaults to 0. amp: float Amplitude of the profile, defaults to 1. Returns ------- Lorentzian Callable instance, evaluates the Lorentzian profile in the arguments supplied. Note ---- The formula used is taken from the MathWorld webpage http://mathworld.wolfram.com/LorentzianFunction.html: .. math:: \mathcal{L}\left(x; \mu, \gamma\right) &= \frac{\gamma} {\pi\left(\left(x-\mu\right)^2+\gamma^2\right)} FWHM &= 2\gamma""" def __init__(self, fwhm=None, mu=None, amp=None, **kwargs): super(Lorentzian, self).__init__(fwhm=fwhm, mu=mu, amp=amp, **kwargs) @property def fwhm(self): return self._fwhm @fwhm.setter def fwhm(self, value): self._fwhm = value self.gamma = 0.5 * self.fwhm if not self.ampIsArea: self._normFactor = 1.0 / (self.gamma * np.pi) def __call__(self, x): x = x - self.mu topPart = self.gamma bottomPart = (x ** 2 + self.gamma ** 2) * np.pi return super(Lorentzian, self).__call__(topPart / bottomPart) class Voigt(Profile): r"""A callable normalized Voigt profile. Parameters ---------- fwhm: list of 2 floats Full Width At Half Maximum of the components, defaults to 1. Ordered as Gaussian, then Lorentzian. mu: float Location of the center, defaults to 0. amp: float Amplitude of the profile, defaults to 1. Attributes ---------- totalfwhm: float Approximation of the width based on the underlying widths. Returns ------- Voigt Callable instance, evaluates the Voigt profile in the arguments supplied. Note ---- The formula used is taken from the Wikipedia webpage http://en.wikipedia.org/wiki/Voigt_profile, with :math:`w(z)` the Faddeeva function, and the values supplied as FWHM are appropriately transformed to :math:`\sigma` and :math:`\gamma`: .. math:: V\left(x;\mu, \sigma, \gamma\right) &= \frac{\Re\left[w\left(z\right) \right]}{\sigma\sqrt{2\pi}} z&=\frac{x+i\gamma}{\sigma\sqrt{2\pi}}""" def __init__(self, fwhm=None, mu=None, amp=None, **kwargs): self._fwhmNorm = np.array([sqrt2log2t2, 2]) super(Voigt, self).__init__(fwhm=fwhm, mu=mu, amp=amp, **kwargs) @property def fwhm(self): return self._fwhm @fwhm.setter def fwhm(self, value): if isinstance(value, (list, tuple, np.ndarray)): seperate = value[0:2] self.fwhmG, self.fwhmL = seperate G, L = seperate self._fwhm = 0.5346 * self.fwhmL + \ (0.2166 * self.fwhmL ** 2 + self.fwhmG ** 2) ** 0.5 self.sigma, self.gamma = seperate / self._fwhmNorm else: self.fwhmG, self.fwhmL = value, value self._fwhm = 0.6144031129489123 * value self.sigma, self.gamma = self._fwhm / self._fwhmNorm if not self.ampIsArea: z = (0 + 1j * self.gamma) / (self.sigma * sqrt2) top = wofz(z).real / (self.sigma * sqrt2pi) self._normFactor = top def __call__(self, x): x = x - self.mu z = (x + 1j * self.gamma) / (self.sigma * sqrt2) top = wofz(z).real / (self.sigma * sqrt2pi) return super(Voigt, self).__call__(top) class Irrational(Profile): r"""A callable normalized Irrational profile. Parameters ---------- fwhm: float Full Width At Half Maximum, defaults to 1. mu: float Location of the center, defaults to 0. amp: float Amplitude of the profile, defaults to 1. Returns ------- Irrational Callable instance, evaluates the irrational profile in the arguments supplied. Note ---- The used formula is taken from T. Ida et al. :cite:`Ida2000`, code inspired by the PhD thesis of Deyan Yordanov :cite:`Yordanov2007`. .. math:: \mathcal{I}\left(x; \mu, g\right) &= \frac{g}{2}\left[1+\left(\frac{x- \mu}{g}\right)^2\right]^{-3/2} FWHM &= \sqrt{2^{2/3}-1}g""" def __init__(self, fwhm=None, mu=None, amp=None, **kwargs): super(Irrational, self).__init__(fwhm=fwhm, mu=mu, amp=amp, **kwargs) @property def fwhm(self): return self._fwhm @fwhm.setter def fwhm(self, value): self._fwhm = value self.gamma = self.fwhm / np.sqrt(np.power(2, 2.0 / 3) - 1) if not self.ampIsArea: self._normFactor = (1.0 ** (-1.5)) / (2 * self.gamma) def __call__(self, x): x = x - self.mu val = ((1.0 + (x / self.gamma) ** 2) ** (-1.5)) / (2 * self.gamma) return super(Irrational, self).__call__(val) class HyperbolicSquared(Profile): r"""A callable normalized HyperbolicSquared profile. Parameters ---------- fwhm: float Full Width At Half Maximum, defaults to 1. mu: float Location of the center, defaults to 0. amp: float Amplitude of the profile, defaults to 1. Returns ------- Hyperbolic Callable instance, evaluates the hyperbolic profile in the arguments supplied. Note ---- The used formula is taken from T. Ida et al. :cite:`Ida2000`, code inspired by the PhD thesis of <NAME> :cite:`Yordanov2007`. .. math:: H\left(x;\mu, g\right) &= \frac{1}{2g}\cosh^{-2}\left(\frac{x-\mu}{g} \right) FWHM &= 2g\ln\left(\sqrt{2}+1\right)""" def __init__(self, fwhm=None, mu=None, amp=None, **kwargs): super(HyperbolicSquared, self).__init__(fwhm=fwhm, mu=mu, amp=amp, **kwargs) @property def fwhm(self): return self._fwhm @fwhm.setter def fwhm(self, value): self._fwhm = value self.gamma = self.fwhm / (2 * np.log(np.sqrt(2) + 1)) if not self.ampIsArea: self._normFactor = 1.0 / (2 * self.gamma) def __call__(self, x): x = x - self.mu coshPart = (1.0 / np.cosh(x / self.gamma)) ** 2 simplePart = 2 * self.gamma return super(HyperbolicSquared, self).__call__(coshPart / simplePart) class PseudoVoigt(Profile): r"""A callable normalized PseudoVoigt profile. Parameters ---------- fwhm: float Full Width At Half Maximum, defaults to 1. mu: float Location of the center, defaults to 0. amp: float Amplitude of the profile, defaults to 1. Returns ------- PseudoVoigt Callable instance, evaluates the pseudovoigt profile in the arguments supplied. Note ---- The formula used is taken from the webpage http://en.wikipedia.org/wiki/Voigt_profile#Pseudo-Voigt_Approximation, and the supplied FWHM is appropriately transformed for the Gaussian and Lorentzian lineshapes: .. math:: \mathcal{V}\left(x; \mu, \eta, \sigma, \gamma\right) = \eta \mathcal{L} (x; \gamma, \mu) + (1-\eta) G(x; \sigma, \mu)""" def __init__(self, eta=None, fwhm=None, mu=None, amp=None, **kwargs): self.L = Lorentzian(**kwargs) self.G = Gaussian(**kwargs) self._n = np.abs(eta) if eta is not None else 0.5 if self._n > 1: self._n = self._n - int(self._n) super(PseudoVoigt, self).__init__(fwhm=fwhm, mu=mu, amp=amp, **kwargs) @property def fwhm(self): return self._fwhm @fwhm.setter def fwhm(self, value): self._fwhm = value self.L.fwhm = value self.G.fwhm = value if not self.ampIsArea: self._normFactor = self.n * self.L(0) self._normFactor += (1.0 - self.n) * self.G(0) @property def n(self): return self._n @n.setter def n(self, value): value = np.abs(value) if value > 1: value = value - int(value) self._n = value if not self.ampIsArea: self._normFactor = self.n * self.L(0) self._normFactor += (1.0 - self.n) * self.G(0) def __call__(self, x): x = x - self.mu val = self.n * self.L(x) + (1.0 - self.n) * self.G(x) return super(PseudoVoigt, self).__call__(val) class ExtendedVoigt(Profile): r"""A callable normalized extended Voigt profile. Parameters ---------- fwhm: list of 2 floats Full Width At Half Maximum, defaults to 1, ordered as Gaussian and Lorentzian width. mu: float Location of the center, defaults to 0. amp: float Amplitude of the profile, defaults to 1. Attributes ---------- totalfwhm: float Approximation of the total width, based on the underlying widths. Returns ------- ExtendedVoigt Callable instance, evaluates the extended Voigt profile in the arguments supplied. Note ---- Formula taken from <NAME> et al. :cite:`Ida2000`, code inspired by the PhD thesis of <NAME> :cite:`Yordanov2007`. This class uses a weighted sum of the Gaussian, Lorentzian, Irrational and HyperbolicSquared profiles.""" def __init__(self, fwhm=None, mu=None, amp=None, **kwargs): self.kwargs = kwargs super(ExtendedVoigt, self).__init__(fwhm=fwhm, mu=mu, amp=amp, **kwargs) @property def fwhm(self): return self._fwhm @fwhm.setter def fwhm(self, value): if isinstance(value, (list, tuple, np.ndarray)): seperate = value[0:2] self.fwhmG, self.fwhmL = seperate self._fwhm = 0.5346 * self.fwhmL + \ np.sqrt(0.2166 * self.fwhmL ** 2 + self.fwhmG ** 2) else: self.fwhmG, self.fwhmL = value, value self._fwhm = 0.6144031129489123 * value self.setParams() def setParams(self): a = np.array( [-2.95553, 8.48252, -9.48291, 4.74052, -1.24984, 0.15021, 0.66]) b = np.array( [3.19974, -16.50453, 29.14158, -23.45651, 10.30003, -1.25693, -0.42179]) c = np.array( [-17.80614, 57.92559, -73.61822, 47.06071, -15.36331, 1.43021, 1.19913]) d = np.array( [-1.26571, 4.05475, -4.55466, 2.76622, -0.68688, -0.47745, 1.10186]) f = np.array( [3.7029, -21.18862, 34.96491, -24.10743, 9.3155, -1.38927, -0.30165]) g = np.array( [9.76947, -24.12407, 22.10544, -11.09215, 3.23653, -0.14107, 0.25437]) h = np.array( [-10.02142, 32.83023, -39.71134, 23.59717, -9.21815, 1.50429, 1.01579]) self.rho = self.fwhmL / (self.fwhmL + self.fwhmG) self.wG = np.polyval(a, self.rho) self.wL = np.polyval(b, self.rho) self.wI = np.polyval(c, self.rho) self.wH = np.polyval(d, self.rho) self.nL = np.polyval(f, self.rho) self.nI = np.polyval(g, self.rho) self.nH = np.polyval(h, self.rho) self.wG = s * (1 - self.rho * self.wG) self.wL = s * (1 - (1 - self.rho) * self.wL) self.wI = s * self.wI self.wH = s * self.wH self.nL = self.rho * (1 + (1 - self.rho) * self.nL) self.nI = self.rho * (1 - self.rho) * self.nI self.nH = self.rho * (1 - self.rho) * self.nH self.G = Gaussian(fwhm=self.wG, **self.kwargs) self.L = Lorentzian(fwhm=self.wL, **self.kwargs) self.I = Irrational(fwhm=self.wI, **self.kwargs) self.H = HyperbolicSquared(fwhm=self.wH, **self.kwargs) self.fwhmV = (self.fwhmG ** 5 + 2.69269 * (self.fwhmG ** 4) * self.fwhmL + 2.42843 * (self.fwhmG ** 3) * (self.fwhmL ** 2) + 4.47163 * (self.fwhmG ** 2) * (self.fwhmL ** 3) + 0.07842 * self.fwhmG * (self.fwhmL ** 4) + self.fwhmL ** 5 ) ** (1.0 / 5) if not self.ampIsArea: Gauss = (1 - self.nL - self.nI - self.nH) * self.G(0) Lorentz = self.nL * self.L(0) Irrat = self.nI * self.I(0) Hyper = self.nH * self.H(0) val = Gauss + Lorentz + Irrat + Hyper self._normFactor = val def __call__(self, x): x = x - self.mu Gauss = (1 - self.nL - self.nI - self.nH) * self.G(x) Lorentz = self.nL * self.L(x) Irrat = self.nI * self.I(x) Hyper = self.nH * self.H(x) val = Gauss + Lorentz + Irrat + Hyper return super(ExtendedVoigt, self).__call__(val)

blueprints/tdmaps/tdmaps.py

filipecosta90/im2modelpy_api

12799024

from flask import Flask, render_template, request, redirect, Blueprint from flask_jsonpify import jsonpify from werkzeug import secure_filename import urllib.request import urllib.error import urllib.parse import os import json import sys import ase.io.cif from ase import Atoms import zlib import sqlite3 import ntpath import numpy as np from matplotlib import pyplot as plt import sys #so that we can import globals sys.path.append('../..') from globals import * #backgroud save_cells_unitcells_data job def save_tdmaps_setup_data( id, tdmap_setup_json, tdmapsDBPath, tdmapsDBSchema): inserted_key = None sqlite3_conn = create_or_open_db(tdmapsDBPath, tdmapsDBSchema) sql = '''insert into tdmaps ( id ) VALUES( ? );''' id_key = None sqlite3_conn.execute( sql,[ id_key ] ) sqlite3_conn.commit() cur = sqlite3_conn.cursor() sql_select = "SELECT last_insert_rowid();" cur.execute(sql_select) result_string = cur.fetchone() if result_string: inserted_key = result_string[0] sqlite3_conn.close() return inserted_key def get_tdmaps_data( id, tdmapsDBPath, tdmapsDBSchema ): result = None inserted_key = None sqlite3_conn = create_or_open_db(tdmapsDBPath, tdmapsDBPath) cur = sqlite3_conn.cursor() sql = "SELECT id , exp_setup_conf_id, cells_conf_id, slices_conf_id, waves_conf_id, dats_conf_id, simgrids_conf_id FROM tdmaps WHERE id = {0}".format(id) cur.execute(sql) result_binary = cur.fetchone() if result_binary: result = { 'id': result_binary[0], 'exp_setup_conf_id': result_binary[1], 'cells_conf_id': result_binary[2], 'slices_conf_id': result_binary[3], 'waves_conf_id': result_binary[4], 'dats_conf_id': result_binary[5], 'simgrids_conf_id': result_binary[6] } sqlite3_conn.close() return result ##################################################### ##################### BLUEPRINT ##################### ##################################################### tdmaps = Blueprint( 'tdmaps', #name of module __name__, template_folder='templates' # templates folder ) @tdmaps.route('/') def index_tdmaps(): return render_template('index_tdmaps.html') @tdmaps.route('/<string:tdmapid>', methods = ['GET']) def api_tdmaps_get(tdmapid): global apiVersion global tdmapsDBPath global tdmapsDBSchema status = None result = None data = get_tdmaps_data(tdmapid, tdmapsDBPath, tdmapsDBSchema) if data is None: result = { "apiVersion": apiVersion, "params": request.args, "method": request.method, "took": 0, "error" : { "code": 404, "message": "Something went wrong.", "url": request.url, }, } return_code = 404 else: tdmap_link = "{0}api/tdmaps/{1}".format( request.host_url, tdmapid ) result = { "apiVersion": apiVersion, "params": request.args, "method": request.method, "took": 0, "data" : data, "links" : { "tdmap" : { "self" : tdmap_link } }, } return_code = 200 return jsonpify(result), return_code @tdmaps.route('/setup', methods = ['POST']) def api_tdmaps_setup(): global apiVersion global tdmapsDBPath global tdmapsDBSchema status = None data_dict = None if len(request.data) > 0: data_dict = json.loads( request.data ) data = {} inserted_tdmap_id = save_tdmaps_setup_data(None, data_dict, tdmapsDBPath, tdmapsDBSchema) tdmap_link = "{0}api/tdmaps/{1}".format( request.host_url, inserted_tdmap_id ) status = True data = { 'id' : inserted_tdmap_id } if status is None: result = { "apiVersion": apiVersion, "params": request.args, "method": request.method, "took": 0, "error" : { "code": 404, "message": "Something went wrong.", "url": request.url, }, } return_code = 404 else: result = { "apiVersion": apiVersion, "params": request.args, "method": request.method, "took": 0, "data" : data, "links" : { "tdmap" : { "self" : tdmap_link } }, } return_code = 200 return jsonpify(result), return_code

src/localmodule.py

lostanlen/ismir2018-lbd

12799025

from joblib import Memory import math import music21 as m21 import numpy as np import os from scipy.fftpack import fft, ifft def get_composers(): return ["Haydn", "Mozart"] def get_data_dir(): return "/scratch/vl1019/nemisig2018_data" def get_dataset_name(): return "nemisig2018" def concatenate_layers(Sx, depth): layers = [] for m in range(depth+1): layers.append(Sx[m].flatten()) return np.concatenate(layers) def frequential_filterbank(dim, J_fr, xi=0.4, sigma=0.16): N = 2**J_fr filterbank = np.zeros((N, 1, 2*(J_fr-2)+1)) for j in range(J_fr-2): xi_j = xi * 2**(-j) sigma_j = sigma * 2**(-j) center = xi_j * N den = 2 * sigma_j * sigma_j * N * N psi = morlet(center, den, N, n_periods=4) filterbank[:, 0, j] = psi for j in range(J_fr-2, 2*(J_fr-2)): psi = filterbank[:, 0, j - (J_fr-2)] rev_psi = np.concatenate((psi[0:1], psi[1:][::-1])) filterbank[:, 0, j] = rev_psi sigma_phi = 2.0 * sigma * 2**(-(J_fr-2)) center_phi = 0.0 den_phi = sigma_phi * sigma_phi * N * N phi = gabor(center_phi, den_phi, N) rev_phi = np.concatenate((phi[0:1], phi[1:][::-1])) phi = phi + rev_phi phi[0] = 1.0 filterbank[:, 0, -1] = phi for m in range(dim): filterbank = np.expand_dims(filterbank, axis=2) return filterbank def gabor(center, den, N): omegas = np.array(range(N)) return gauss(omegas - center, den) def gauss(omega, den): return np.exp(- omega*omega / den) def is_even(n): return (n%2 == 0) def morlet(center, den, N, n_periods): half_N = N >> 1 p_start = - ((n_periods-1) >> 1) - is_even(n_periods) p_stop = ((n_periods-1) >> 1) + 1 omega_start = p_start * N omega_stop = p_stop * N omegas = np.array(range(omega_start, omega_stop)) gauss_center = gauss(omegas - center, den) corrective_gaussians = np.zeros((N*n_periods, n_periods)) for p in range(n_periods): offset = (p_start + p) * N corrective_gaussians[:, p] = gauss(omegas - offset, den) p_range = range(p_start, p_stop) b = np.array([gauss(p*N - center, den) for p in p_range]) A = np.array([gauss((q-p)*N, den) for p in range(n_periods) for q in range(n_periods)]).reshape(n_periods, n_periods) corrective_factors = np.linalg.solve(A, b) y = gauss_center - np.dot(corrective_gaussians, corrective_factors) y = np.fft.fftshift(y) y = np.reshape(y, (n_periods, N)) y = np.sum(y, axis=0) return y def scatter(U, filterbank, dim): U_ft = fft(U, axis=dim) U_ft = np.expand_dims(U_ft, axis=-1) Y_ft = U_ft * filterbank Y = ifft(Y_ft, axis=dim) return Y def setup_timefrequency_scattering(J_tm, J_fr, depth): filterbanks_tm = [] filterbanks_fr = [] for m in range(depth): filterbank_tm = temporal_filterbank(2*m, J_tm) filterbank_fr = frequential_filterbank(2*m+1, J_fr) filterbanks_tm.append(filterbank_tm) filterbanks_fr.append(filterbank_fr) return (filterbanks_tm, filterbanks_fr) def temporal_filterbank(dim, J_tm, xi=0.4, sigma=0.16): N = 2**J_tm filterbank = np.zeros((1, N, J_tm-2)) for j in range(J_tm-2): xi_j = xi * 2**(-j) sigma_j = sigma * 2**(-j) center = xi_j * N den = 2 * sigma_j * sigma_j * N * N psi = morlet(center, den, N, n_periods=4) filterbank[0, :, j] = psi for m in range(dim): filterbank = np.expand_dims(filterbank, axis=2) return filterbank def temporal_scattering(pianoroll, filterbanks, nonlinearity): depth = len(filterbanks) Us = [pianoroll] Ss = [] for m in range(depth): U = Us[m] S = np.sum(U, axis=(0, 1)) filterbank = filterbanks[m] Y = scatter(U, filterbank, 1) if nonlinearity == "abs": U = np.abs(Y) else: raise NotImplementedError Us.append(U) Ss.append(S) S = np.sum(U, axis=(0, 1)) Ss.append(S) return Ss def timefrequency_scattering(pianoroll, filterbanks, nonlinearity): filterbanks_tm = filterbanks[0] filterbanks_fr = filterbanks[1] depth = len(filterbanks_tm) Us = [pianoroll] Ss = [] for m in range(depth): U = Us[m] S = np.sum(U, axis=(0,1)) filterbank_tm = filterbanks_tm[m] filterbank_fr = filterbanks_fr[m] Y_tm = scatter(U, filterbank_tm, 1) Y_fr = scatter(Y_tm, filterbank_fr, 0) if nonlinearity == "abs": U = np.abs(Y_fr) else: raise NotImplementedError Us.append(U) Ss.append(S) S = np.sum(U, axis=(0, 1)) Ss.append(S) return Ss

tests/test_web.py

natumbri/mopidy-bandcamp

12799026

<filename>tests/test_web.py from unittest import mock import tornado.testing import tornado.web import tornado.websocket import mopidy.config as config from mopidy_bandcamp import Extension class BaseTest(tornado.testing.AsyncHTTPTestCase): def get_app(self): extension = Extension() self.config = config.Proxy({}) return tornado.web.Application(extension.factory(self.config, mock.Mock())) class WebHandlerTest(BaseTest): def test_index(self): response = self.fetch("/", method="GET") assert response.code == 200 response = self.fetch("/?url=https%3A%2F%2Fgoogle.com%2F", method="GET") assert response.code == 200 body = tornado.escape.to_unicode(response.body) assert "<title>Error</title>" in body response = self.fetch( "/?url=https%3A%2F%2Flouiezong.bandcamp.com%2Ftrack%2Fbrain-age", method="GET", ) assert response.code == 200 body = tornado.escape.to_unicode(response.body) assert "<title>URL Added</title>" in body

nodes/1.x/python/Material.Properties.py

jdehotin/Clockworkfordynamo

12799027

<gh_stars>100-1000 import clr clr.AddReference('RevitAPI') from Autodesk.Revit.DB import * mats = UnwrapElement(IN[0]) colorlist = list() glowlist = list() classlist = list() shinylist = list() smoothlist = list() translist = list() for mat in mats: colorlist.append(mat.Color) if mat.Glow: glowlist.append(True) else: glowlist.append(False) classlist.append(mat.MaterialClass) shinylist.append(mat.Shininess) smoothlist.append(mat.Smoothness) translist.append(mat.Transparency) OUT = (classlist,colorlist,glowlist,shinylist,smoothlist,translist)

meta_tagger/cms_sitemap.py

dreipol/meta-tagger

12799028

from cms.sitemaps import CMSSitemap class MetaTagRobotsSiteMap(CMSSitemap): def items(self): return super(MetaTagRobotsSiteMap, self).items().exclude(page__metatagpageextension__robots_indexing=False)

project2/api/simulator.py

fabiorodp/IN_STK5000_Adaptive_methods_for_data_based_decision_making

12799029

## Comborbidities: ## Comborbidities: ## Asthma, Obesity, Smoking, Diabetes, Heart diseae, Hypertension ## Symptom list: Covid-Recovered, Covid-Positive, Taste, Fever, Headache, # Pneumonia, Stomach, Myocarditis, Blood-Clots, Death ## Mild symptoms: Taste, Fever, Headache, Stomach ## Critical symptoms: Pneumonia, Myocarditis, Blood-Clots import numpy as np import pickle class Person: def __init__(self, pop): self.genes = np.random.choice(2, size=pop.n_genes) self.gender = np.random.choice(2, 1) self.age = np.random.gamma(3, 11) self.age_adj = self.age / 100 # age affects everything self.income = np.random.gamma(1, 10000) self.comorbidities = [0] * pop.n_comorbidities self.comorbidities[0] = pop.asthma self.comorbidities[1] = pop.obesity * self.age_adj self.comorbidities[2] = pop.smoking self.diab = pop.diabetes + self.comorbidities[1] * 0.5 self.HT = pop.htension + self.comorbidities[2] * 0.5 self.comorbidities[3] = self.diab self.comorbidities[4] = pop.heart * self.age_adj self.comorbidities[5] = self.HT * self.age_adj for i in range(pop.n_comorbidities): if (np.random.uniform() < self.comorbidities[i]): self.comorbidities[i] = 1 else: self.comorbidities[i] = 0 self.symptom_baseline = np.array( [pop.historical_prevalence, pop.prevalence, 0.01, 0.05, 0.05, 0.01, 0.02, 0.001, 0.001, 0.001]); self.symptom_baseline = np.array( np.matrix(self.genes) * pop.G).flatten() * self.symptom_baseline self.symptom_baseline[0] = pop.historical_prevalence; self.symptom_baseline[1] = pop.prevalence; if (self.gender == 1): self.symptom_baseline[8] += 0.01 else: self.symptom_baseline[7] += 0.01 self.symptom_baseline[9] += 0.01 # Initially no symptoms apart from Covid+/CovidPre self.symptoms = [0] * pop.n_symptoms if (np.random.uniform() <= self.symptom_baseline[0]): self.symptoms[0] = 1 # increase symptom probabilities for symptoms when covid+ if (np.random.uniform() <= self.symptom_baseline[1]): self.symptoms[1] = 1 self.symptom_baseline = np.array( [pop.historical_prevalence, pop.prevalence, 0.3, 0.2, 0.05, 0.2, 0.02, 0.05, 0.2, 0.1]); self.vaccines = [0] * pop.n_vaccines # use vaccine = -1 if no vaccine is given def vaccinate(self, vaccine_array, pop): ## Vaccinated if (sum(vaccine_array) >= 0): vaccinated = True else: vaccinated = False if (vaccinated): vaccine = np.argmax(vaccine_array) self.vaccines = vaccine_array self.symptom_baseline[1] *= pop.baseline_efficacy[vaccine] if (vaccinated and self.symptoms[1] == 1): self.symptom_baseline[[2, 3, 4, 6]] *= pop.mild_efficacy[vaccine] self.symptom_baseline[[5, 7, 8]] *= pop.critical_efficacy[vaccine] self.symptom_baseline[9] *= pop.death_efficacy[vaccine] if (self.symptoms[0] == 1): self.symptom_baseline *= 0.5 # baseline symptoms of non-covid patients if (self.symptoms[0] == 0 and self.symptoms[1] == 0): self.symptom_baseline = np.array( [0, 0, 0.001, 0.01, 0.02, 0.002, 0.005, 0.001, 0.002, 0.0001]) ## Common side-effects if (vaccine == 1): self.symptom_baseline[8] += 0.01 self.symptom_baseline[9] += 0.001 if (vaccine == 2): self.symptom_baseline[7] += 0.01 if (vaccine >= 0): self.symptom_baseline[3] += 0.2 self.symptom_baseline[4] += 0.1 # model long covid sufferers by increasing the chances of various # symptoms slightly if (self.symptoms[0] == 1 and self.symptoms[1] == 0): self.symptom_baseline += np.array( [0, 0, 0.06, 0.04, 0.01, 0.04, 0.004, 0.01, 0.04, 0.01]); # genetic factors self.symptom_baseline = np.array( np.matrix(self.genes) * pop.G).flatten() * self.symptom_baseline # print("V:", vaccine, symptom_baseline) for s in range(2, pop.n_symptoms): if (np.random.uniform() < self.symptom_baseline[s]): self.symptoms[s] = 1 class Population: def __init__(self, n_genes, n_vaccines, n_treatments): self.n_genes = n_genes self.n_comorbidities = 6; self.n_symptoms = 10 self.n_vaccines = n_vaccines self.n_treatments = n_treatments self.G = np.random.uniform(size=[self.n_genes, self.n_symptoms]) self.G /= sum(self.G) self.A = np.random.uniform(size=[self.n_treatments, self.n_symptoms]) self.asthma = 0.08 self.obesity = 0.3 self.smoking = 0.2 self.diabetes = 0.1 self.heart = 0.15 self.htension = 0.3 self.baseline_efficacy = [0.5, 0.6, 0.7] self.mild_efficacy = [0.6, 0.7, 0.8] self.critical_efficacy = [0.8, 0.75, 0.85] self.death_efficacy = [0.9, 0.95, 0.9] self.vaccination_rate = [0.7, 0.1, 0.1, 0.1] self.prevalence = 0.1 self.historical_prevalence = 0.1 ## Generates data with the following structure: ## X: characteristics before treatment, including whether or not they # were vaccinated ## The generated population may already be vaccinated. def generate(self, n_individuals): """Generate a population. Call this function before anything else is done. Calling this function again generates a completely new population sample, purging the previous one from memory. :param int n_individuals: the number of individuals to generate """ self.n_individuals = n_individuals X = np.zeros([n_individuals, 3 + self.n_genes + self.n_comorbidities + self.n_vaccines + self.n_symptoms]) Y = np.zeros([n_individuals, self.n_treatments, self.n_symptoms]) self.persons = [] for t in range(n_individuals): person = Person(self) vaccine = np.random.choice(4, p=self.vaccination_rate) - 1 vaccine_array = np.zeros(self.n_vaccines) if (vaccine >= 0): vaccine_array[vaccine] = 1 person.vaccinate(vaccine_array, self) self.persons.append(person) x_t = np.concatenate( [person.symptoms, [person.age, person.gender, person.income], person.genes, person.comorbidities, person.vaccines]) X[t, :] = x_t self.X = X return X def vaccinate(self, person_index, vaccine_array): """ Give a vaccine to a specific person. Args: person_index (int array), indices of person in the population vaccine_array (n*|A| array), array indicating which vaccines are to be given to each patient Returns: The symptoms of the selected individuals Notes: Currently only one vaccine dose is implemented, but in the future multiple doses may be modelled. """ outcome = np.zeros([len(person_index), self.n_symptoms]) i = 0 for t in person_index: self.persons[t].vaccinate(vaccine_array[i], self) outcome[i] = self.persons[i].symptoms i += 1 return outcome def treat(self, person_index, treatment): """ Treat a patient. Args: person_index (int array), indices of persons in the population to treat treatment_array (n*|A| array), array indicating which treatments are to be given to each patient Returns: The symptoms of the selected individuals """ N = len(person_index) result = np.zeros([N, self.n_symptoms]) # use i to index the treated # use t to index the original population # print(treatment) for i in range(N): t = person_index[i] r = np.array(np.matrix(treatment[i]) * self.A).flatten() for k in range(self.n_symptoms): if (k <= 1): result[i, k] = self.X[t, k] else: if (np.random.uniform() < r[k]): result[i, k] = 0 else: result[i, k] = self.X[t, k] return result def get_features(self, person_index): x_t = np.concatenate([self.persons[t].symptoms, [self.persons[t].age, self.persons[t].gender, self.persons[t].income], self.persons[t].genes, self.persons[t].comorbidities, self.persons[t].vaccines]) return x_t ## Treats a population def treatment(self, X, policy): treatments = np.zeros([X.shape[0], self.n_treatments]) result = np.zeros([X.shape[0], self.n_symptoms]) for t in range(X.shape[0]): # print ("X:", result[t]) treatments[t][policy.get_action(X[t])] = 1 r = np.array(np.matrix(treatments[t]) * self.A).flatten() for k in range(self.n_symptoms): if (k <= 1): result[t, k] = X[t, k] else: if (np.random.uniform() < r[k]): result[t, k] = 0 else: result[t, k] = X[t, k] ##print("X:", X[t,:self.n_symptoms] , "Y:", result[t]) return treatments, result # main if __name__ == "__main__": import pandas try: import policy except: import project2.src.covid.policy n_symptoms = 10 n_genes = 128 n_vaccines = 3 n_treatments = 4 pop = Population(n_genes, n_vaccines, n_treatments) n_observations = 1000 X_observation = pop.generate(n_observations) pandas.DataFrame(X_observation).to_csv('observation_features.csv', header=False, index=False) n_treated = 1000 X_treatment = pop.generate(n_treated) X_treatment = X_treatment[X_treatment[:, 1] == 1] print("Generating treatment outcomes") a, y = pop.treatment(X_treatment, policy.RandomPolicy(n_treatments)) pandas.DataFrame(X_treatment).to_csv('treatment_features.csv', header=False, index=False) pandas.DataFrame(a).to_csv('treatment_actions.csv', header=False, index=False) pandas.DataFrame(y).to_csv('treatment_outcomes.csv', header=False, index=False)

code_samples/vec2d_use.py

xanewton/PygameCreepsGame

12799030

<reponame>xanewton/PygameCreepsGame #! /usr/bin/env python import sys sys.path.append('..') from vec2d import vec2d v = vec2d(-1, 1) print (v.angle)

tarakania_rpg/db/redis.py

tarakania/discord-bot

12799031

from typing import Any, Dict from asyncio import sleep from logging import getLogger import aioredis log = getLogger(__name__) class _ConnectionsPool(aioredis.ConnectionsPool): def __init__( self, *args: Any, retry_count: int = 5, retry_interval: int = 2, **kwargs: Any ) -> None: super().__init__(*args, **kwargs) self._retry_count = retry_count self._retry_interval = retry_interval async def execute(self, command: str, *args: Any, **kwargs: Any) -> Any: exc: Exception for i in range(self._retry_count): try: return await super().execute(command, *args, **kwargs) except ( aioredis.ConnectionClosedError, aioredis.PoolClosedError, ConnectionRefusedError, ) as e: log.debug( f"Command {command} failed, remaining attempts: {self._retry_count - i}" ) exc = e await sleep(self._retry_interval) log.error(f"Command {command} has failed after {self._retry_count} retries") raise exc async def create_redis_pool(config: Dict[str, Any]) -> _ConnectionsPool: config = config.copy() address = (config.pop("host"), config.pop("port")) return await aioredis.create_pool(address, pool_cls=_ConnectionsPool, **config)

train.py

AlexMetsai/pytorch-time-series-autoencoder

12799032

# <NAME> # <EMAIL> # MIT License # As-simple-as-possible training loop for an autoencoder. import torch import numpy as np import torch.optim as optim from torch import nn from torch.utils.data import DataLoader, TensorDataset from model.shallow_autoencoder import ConvAutoencoder # load model definition model = ConvAutoencoder() model = model.double() # tackles a type error # define loss and optimizer criterion = nn.MSELoss() optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) # Toy data: # Using separate input and output variables to cover all cases, # since Y could differ from X (e.g. for denoising autoencoders). X = np.random.random((300, 1, 100)) Y = X # prepare pytorch dataloader dataset = TensorDataset(torch.tensor(X), torch.tensor(Y)) dataloader = DataLoader(dataset, batch_size=256, shuffle=True) # Training loop for epoch in range(200): for x, y in dataloader: optimizer.zero_grad() # forward and backward pass out = model(x) loss = criterion(out, y) loss.backward() optimizer.step() print(loss.item()) # loss should be decreasing

regtests/bench/copy_list-typed-stack.py

secureosv/pythia

12799033

<reponame>secureosv/pythia<filename>regtests/bench/copy_list-typed-stack.py '''copy list micro benchmark''' from time import clock from runtime import * with stack: def copy_list( a:[]int, n ) -> [][]int: x = [][]int() for i in range(n): b = a[:] for j in range(10): b.push_back( j ) x.push_back( b ) return x def test(): a = range(1000) times = []double() for i in range(4): t0 = clock() res = copy_list(addr(a), 10000) tk = clock() times.append(tk - t0) avg = sumd(times) / len(times) print(avg) def main(): test() main()

examples/expander.py

furimu1234/discord-ext-utils

12799034

<reponame>furimu1234/discord-ext-utils from discord.ext.utils import MinimalExpander from discord.ext import commands bot = commands.Bot(command_prefix=commands.when_mentioned) # Expand simple. bot.load_extension("discord.ext.utils.cogs.minimal_expander") # Expand all. # self.load_extension("discord.ext.utils.cogs.expander") # Expand all and send with webhook. # self.load_extension("discord.ext.utils.cogs.webhook_expander") class Expander(MinimalExpander): async def check_global_expand(self, guild_id): # guild_id is the id of the guild that has the message to expand. # If this function returns True, allow the message to be expanded to another guild. pass # Customize the behavior of the deployment. # All Cogs are named ExpanderCog. bot.get_cog("ExpanderCog").expander = Expander bot.run("TOKEN")

apps/quotes/quote_fetcher/quote_fetcher.py

Ev1dentSnow/ArtemisAPI_django

12799035

<gh_stars>0 import json import requests from apps.quotes import models def fetch_quote(): pass

standalone.py

askehill/covis2

12799036

<reponame>askehill/covis2 #! /usr/bin/python3 import seeed_mlx9064x import time,board,busio import numpy as np import adafruit_mlx90640 import matplotlib.pyplot as plt from scipy import ndimage import argparse parser = argparse.ArgumentParser(description='Thermal Camera Program') parser.add_argument('--mirror', dest='imageMirror', action='store_const', default='false', const='imageMirror', help='Flip the image for selfie (default: false)') args = parser.parse_args() imageMirror = args.imageMirror if(imageMirror == 'false'): print('Mirror mode: false') else: imageMirror = 'true' print('Mirror mode: true') mlx = seeed_mlx9064x.grove_mxl90641() frame = [0] * 192 mlx.refresh_rate = seeed_mlx9064x.RefreshRate.REFRESH_8_HZ mlx_shape = (12,16) # mlx90641 shape mlx_interp_val = 10 # interpolate # on each dimension mlx_interp_shape = (mlx_shape[0]*mlx_interp_val, mlx_shape[1]*mlx_interp_val) # new shape fig = plt.figure(figsize=(12,9)) # start figure ax = fig.add_subplot(111) # add subplot fig.subplots_adjust(0.05,0.05,0.95,0.95) # get rid of unnecessary padding therm1 = ax.imshow(np.zeros(mlx_interp_shape),interpolation='none', cmap=plt.cm.bwr,vmin=25,vmax=45) # preemptive image cbar = fig.colorbar(therm1) # setup colorbar cbar.set_label('Temperature [$^{\circ}$C]',fontsize=14) # colorbar label fig.canvas.draw() # draw figure to copy background ax_background = fig.canvas.copy_from_bbox(ax.bbox) # copy background ax.text(-75, 125, 'Max:', color='red') textMaxValue = ax.text(-75, 150, 'test1', color='black') fig.show() # show the figure before blitting def plot_update(): fig.canvas.restore_region(ax_background) # restore background mlx.getFrame(frame) # read mlx90640 data_array = np.fliplr(np.reshape(frame,mlx_shape)) # reshape, flip data if(imageMirror == 'true'): data_array = np.flipud(data_array) data_array = ndimage.zoom(data_array,mlx_interp_val) # interpolate therm1.set_array(data_array) # set data therm1.set_clim(vmin=np.min(data_array),vmax=np.max(data_array)) # set bounds cbar.on_mappable_changed(therm1) # update colorbar range plt.pause(0.001) ax.draw_artist(therm1) # draw new thermal image textMaxValue.set_text(str(np.round(np.max(data_array), 1))) fig.canvas.blit(ax.bbox) # draw background fig.canvas.flush_events() # show the new image fig.show() return t_array = [] while True: t1 = time.monotonic() # for determining frame rate try: plot_update() # update plot except: continue # approximating frame rate t_array.append(time.monotonic()-t1) if len(t_array)>10: t_array = t_array[1:] # recent times for frame rate approx print('Frame Rate: {0:2.1f}fps'.format(len(t_array)/np.sum(t_array)))

tloen/domain/transports.py

josiah-wolf-oberholtzer/tloen

12799037

import asyncio import dataclasses import enum from typing import Dict, Optional, Set, Tuple from supriya.clocks import AsyncTempoClock, Moment from ..bases import Event from .bases import ApplicationObject from .parameters import ParameterGroup, ParameterObject class Transport(ApplicationObject): ### CLASS VARIABLES ### class EventType(enum.IntEnum): CHANGE = 0 SCHEDULE = 1 MIDI_PERFORM = 2 DEVICE_NOTE_OFF = 3 DEVICE_NOTE_ON = 4 CLIP_LAUNCH = 5 CLIP_EDIT = 6 CLIP_PERFORM = 7 ### INITIALIZER ### def __init__(self): ApplicationObject.__init__(self) self._parameter_group = ParameterGroup() self._parameters: Dict[str, ParameterObject] = {} self._clock = AsyncTempoClock() self._dependencies: Set[ApplicationObject] = set() self._mutate(slice(None), [self._parameter_group]) self._tick_event_id = None ### PRIVATE METHODS ### async def _application_perform_callback(self, clock_context, midi_message): await self.application.perform( [midi_message], moment=clock_context.current_moment ) @classmethod async def _deserialize(cls, data, transport_object): await transport_object.set_tempo(data["spec"]["tempo"]) await transport_object.set_time_signature(*data["spec"]["time_signature"]) def _serialize(self): return { "kind": type(self).__name__, "spec": { "tempo": self._clock.beats_per_minute, "time_signature": list(self._clock.time_signature), }, } def _tick_callback(self, clock_context): self.application.pubsub.publish(TransportTicked(clock_context.desired_moment)) return 1 / clock_context.desired_moment.time_signature[1] / 4 ### PUBLIC METHODS ### async def cue(self, *args, **kwargs) -> int: return self._clock.cue(*args, **kwargs) async def cancel(self, *args, **kwargs) -> Optional[Tuple]: return self._clock.cancel(*args, **kwargs) async def perform(self, midi_messages): if ( self.application is None or self.application.status != self.application.Status.REALTIME ): return self._debug_tree( self, "Perform", suffix=repr([type(_).__name__ for _ in midi_messages]) ) await self.schedule(self._application_perform_callback, args=midi_messages) if not self.is_running: await self.start() async def reschedule(self, *args, **kwargs) -> Optional[int]: return self._clock.reschedule(*args, **kwargs) async def schedule(self, *args, **kwargs) -> int: return self._clock.schedule(*args, **kwargs) async def set_tempo(self, beats_per_minute: float): self._clock.change(beats_per_minute=beats_per_minute) async def set_time_signature(self, numerator, denominator): self._clock.change(time_signature=[numerator, denominator]) async def start(self): async with self.lock([self]): self._tick_event_id = await self.cue(self._tick_callback) await asyncio.gather(*[_._start() for _ in self._dependencies]) await self._clock.start() self.application.pubsub.publish(TransportStarted()) async def stop(self): await self._clock.stop() async with self.lock([self]): await asyncio.gather(*[_._stop() for _ in self._dependencies]) await self.application.flush() await self.cancel(self._tick_event_id) self.application.pubsub.publish(TransportStopped()) ### PUBLIC PROPERTIES ### @property def clock(self): return self._clock @property def is_running(self): return self._clock.is_running @property def parameters(self): return self._parameters @dataclasses.dataclass class TransportStarted(Event): pass @dataclasses.dataclass class TransportStopped(Event): pass @dataclasses.dataclass class TransportTicked(Event): # TODO: ClipView needs to know start delta moment: Moment

django/app/hivernants/admin.py

jeanpommier/ker51

12799038

<gh_stars>0 from django.contrib.gis import admin from .models import Hivernant, Phone, Email class PhoneInline(admin.TabularInline): model = Phone extra = 1 class EmailInline(admin.TabularInline): model = Email extra = 1 class HivernantAdmin(admin.OSMGeoAdmin): default_lon = 300000 default_lat = 6000000 # default_lon = 2 # default_lat = 42 default_zoom = 2 list_display = ('names', 'fulladdress', 'comments') inlines = [PhoneInline, EmailInline] admin.site.register(Hivernant, HivernantAdmin)

sagas/ofbiz/rpc_artifacts.py

samlet/stack

12799039

<reponame>samlet/stack from concurrent import futures import time import grpc import requests import json import blueprints_pb2_grpc import blueprints_pb2 from sagas.ofbiz.blackboard import Blackboard, BlackboardReceiver _ONE_DAY_IN_SECONDS = 60 * 60 * 24 """ $ start as # or: python -m sagas.ofbiz.rpc_artifacts """ #$ ./query.py talk "hi" #$ ./query.py talk "/joke" def talk(sender, a_str): headers = { 'content-type': 'application/json', } # data = '{'+'"message": "{}"'.format(a_str)+'}' data={'sender':sender, 'message':a_str} response = requests.post('http://localhost:5005/webhooks/rest/webhook', headers=headers, data=json.dumps(data)) # print(response.text) return response.json() class ArtifactService(blueprints_pb2_grpc.ArtifactServiceServicer): def Talk(self, request, context): rs=talk(request.sender, request.message) recips = [] for r in rs: recips.append(blueprints_pb2.BotRecipient(id=r['recipient_id'], text=r['text'])) return blueprints_pb2.BotResponse(recipients=recips) def SetSlot(self, request, context): return super().SetSlot(request, context) def __init__(self, artifacts): self.artifacts=artifacts def Ping(self, request, context): print('get %s'%request) self.artifacts.blackboard.send(request.message) return blueprints_pb2.PingResponse(response="world") class Artifacts(object): def __init__(self, port='0.0.0.0:20051'): self.server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) blueprints_pb2_grpc.add_ArtifactServiceServicer_to_server(ArtifactService(self), self.server) self.port=port self.server.add_insecure_port(port) self.blackboard=Blackboard() # self.receiver=BlackboardReceiver() def serve(self, blocking=True): self.server.start() print(".. artifacts servant started on", self.port) if blocking: try: while True: time.sleep(_ONE_DAY_IN_SECONDS) except KeyboardInterrupt: self.server.stop(0) self.blackboard.close() # else: # self.receiver.serve('anonymous.info') if __name__ == '__main__': # import asyncio # from sagas.tests.bus.aio.receive_logs_topic import main # # message receiver # loop = asyncio.get_event_loop() # loop.create_task(main(loop)) # we enter a never-ending loop that waits for # data and runs callbacks whenever necessary. print(" [*] Waiting for messages ..") # rpc and message sender s=Artifacts() s.serve() # loop.run_forever()

1 - Beginner/1789.py

andrematte/uri-submissions

12799040

<filename>1 - Beginner/1789.py # URI Online Judge 1789 while True: try: N = int(input()) entrada = [int(i) for i in input().split()] if max(entrada) < 10: print(1) elif max(entrada) >= 10 and max(entrada) < 20: print(2) elif max(entrada) >= 20: print(3) except EOFError: break

database/postgresql.py

andreformento/querido-diario-data-processing

12799041

<filename>database/postgresql.py from typing import Generator import os import logging import psycopg2 from tasks import DatabaseInterface def get_database_name(): return os.environ["POSTGRES_DB"] def get_database_user(): return os.environ["POSTGRES_USER"] def get_database_password(): return os.environ["POSTGRES_PASSWORD"] def get_database_host(): return os.environ["POSTGRES_HOST"] def get_database_port(): return os.environ["POSTGRES_PORT"] def create_database_interface() -> DatabaseInterface: return PostgreSQL( get_database_host(), get_database_name(), get_database_user(), get_database_password(), get_database_port(), ) class PostgreSQL(DatabaseInterface): SELECT_PENDING_GAZETTES = """SELECT gazettes.id, gazettes.source_text, gazettes.date, gazettes.edition_number, gazettes.is_extra_edition, gazettes.power, gazettes.file_checksum, gazettes.file_path, gazettes.file_url, gazettes.scraped_at, gazettes.created_at, gazettes.territory_id, gazettes.processed, territories.name as territory_name, territories.state_code FROM gazettes INNER JOIN territories ON territories.id = gazettes.territory_id WHERE processed is False;""" UPDATE_GAZETTE_AS_PROCESSED = """UPDATE gazettes SET processed = True WHERE id = %(id)s AND file_checksum = %(file_checksum)s;""" def __init__(self, host, database, user, password, port): self._connection = psycopg2.connect( dbname=database, user=user, password=password, host=host, port=port ) def format_gazette_data(self, data): return { "id": data[0], "source_text": data[1], "date": data[2], "edition_number": data[3], "is_extra_edition": data[4], "power": data[5], "file_checksum": data[6], "file_path": data[7], "file_url": data[8], "scraped_at": data[9], "created_at": data[10], "territory_id": data[11], "processed": data[12], "territory_name": data[13], "state_code": data[14], } def get_pending_gazettes(self) -> Generator: with self._connection.cursor() as cursor: cursor.execute(self.SELECT_PENDING_GAZETTES) logging.debug(cursor.query) for gazette_data in cursor: logging.debug(gazette_data) yield self.format_gazette_data(gazette_data) logging.debug("No more gazettes to be processed") def set_gazette_as_processed(self, id: int, gazette_file_checksum: str) -> None: logging.debug(f"Marking {id}({gazette_file_checksum}) as processed") with self._connection.cursor() as cursor: cursor.execute( self.UPDATE_GAZETTE_AS_PROCESSED, {"id": id, "file_checksum": gazette_file_checksum}, ) self._connection.commit()

hard-gists/df9ad5ef01d16c02d68d9a8c17c75b73/snippet.py

jjhenkel/dockerizeme

12799042

# # twitter csv process # write by @jiyang_viz # # require: # https://github.com/edburnett/twitter-text-python # # download csv file from: # https://github.com/bpb27/political_twitter_archive/tree/master/realdonaldtrump # import json import csv from ttp import ttp from dateutil import parser as date_parser # read csv to Dict with open('realdonaldtrump.csv', 'r') as f: reader = csv.DictReader(f, delimiter = ',') data = list(reader) # write to json file (same fields as csv) with open('realdonaldtrump.json', 'w') as f: for item in data: f.write(json.dumps(item) + '\n') # get more info from text message parser = ttp.Parser() for item in data: result = parser.parse(item['text']) item['tags'] = result.tags item['users'] = result.users item['reply'] = result.reply item['tweet_time'] = str(date_parser.parse(item['created_at'])) # write to json file (more fields) with open('realdonaldtrump_more.json', 'w') as f: for item in data: f.write(json.dumps(item) + '\n')

thebotplatform.py

TheBotPlatform/POCInteractionEndPoint

12799043

<filename>thebotplatform.py import requests import json from decouple import config import time #Creating and getting my bearer token LastToken = False LastTokenTime = False TokenLifespan = 58 * 60 def BearerTokenGrab(): global LastToken global LastTokenTime now = time.time() if LastToken and LastTokenTime > now - TokenLifespan: return LastToken url = "https://api.thebotplatform.com/oauth2/token" payload = "client_id=" + config("TBP_CLIENT_ID") + "&client_secret=" + config("TBP_CLIENT_SECRET") + "&grant_type=client_credentials" headers = { "Accept": "application/json", "Content-Type": "application/x-www-form-urlencoded" } response = requests.post(url, data=payload, headers=headers) jsonResponse = response.json() LastToken = jsonResponse['access_token'] LastTokenTime = now return jsonResponse['access_token'] #Creates a User ID for the current user def CreateUserID(): url = "https://api.thebotplatform.com/v1.0/interaction/user" payload = [] headers = { "Content-Type": "application/x-www-form-urlencoded", "Authorization": "Bearer " + BearerTokenGrab() } response = requests.post(url, data=payload, headers=headers) jsonResponse = response.json() return jsonResponse['data']['attributes']['user']['id'] def getBotResponse(UserID, input): url = "https://api.thebotplatform.com/v1.0/interaction" headers = { "Content-Type": "application/json", "Authorization": "Bearer " + BearerTokenGrab() } payloaddict = { "data": { "type": "interaction", "attributes": { "user": { "id": UserID }, "input": input } } } response = requests.post(url, headers=headers, json=payloaddict) jsonResponse = response.json() formatJsonresp = json.dumps(jsonResponse, indent=4, sort_keys=True) return formatJsonresp print("Running the proxy server")

freeCodeCamp/01-scientific-computing-with-python/src/02-functions.py

aysedemirel/python-journey

12799044

<gh_stars>1-10 def sum(a,b): return a+b a = input("Enter first number: ") b = input("Enter first number: ") sum_numbers = sum(int(a),int(b)) print("Sum: ", sum_numbers)

batch_generator.py

mr4msm/cramer_gan_chainer

12799045

<gh_stars>1-10 # -*- coding: utf-8 -*- """Batch generator definition.""" import cv2 import numpy as np class ImageBatchGenerator(object): """Batch generator for training on general images.""" def __init__(self, input_files, batch_size, height, width, channel=3, shuffle=False, flip_h=False): assert batch_size > 0, batch_size assert channel == 3 or channel == 1, channel if channel == 3: self._imread_flag = cv2.IMREAD_COLOR else: self._imread_flag = cv2.IMREAD_GRAYSCALE self._input_files = input_files self._batch_size = batch_size self._height = height self._width = width self._shuffle = shuffle self._flip_h = flip_h for ifile in input_files: image = cv2.imread(ifile, cv2.IMREAD_UNCHANGED) assert isinstance(image, np.ndarray) assert image.shape[:2] == ( height, width), (image.shape[:2], (height, width)) print('verify ' + ifile) self._batch_generator = self.__get_batch_generator() def __get_batch_generator(self): batch = [] while True: if self._shuffle: file_index = np.random.permutation(self.n_samples) else: file_index = range(self.n_samples) for idx in file_index: image = cv2.imread(self._input_files[idx], self._imread_flag) if self._flip_h: if np.random.randint(2) == 0: image = image[:, ::-1] if image.ndim == 2: image = image.reshape((1,) + image.shape) else: image = image.transpose((2, 0, 1)) image = image.astype(np.float32) image = ((image / 255.) - 0.5) * 2. batch.append(image) if len(batch) == self._batch_size: yield np.asarray(batch) batch = [] @property def n_samples(self): return len(self._input_files) def __next__(self): self._batch = next(self._batch_generator) return self._batch def next(self): return self.__next__()

libraries/graphite2-1.3.12/tests/corrupt.py

myzhang1029/zmymingw

12799046

#!/usr/bin/env python import optparse import os import shutil import sys def revert(path): bkup = path + os.path.extsep + options.backup_suffix if os.access(bkup, os.R_OK): shutil.copy2(bkup, path) os.remove(bkup) def corrupt(path, offset, value): if options.backup: shutil.copy2(path, path + os.path.extsep + options.backup_suffix) with open(path, 'r+b', buffering=0) as f: f.seek(offset) f.write(bytes(chr(value))) parser = optparse.OptionParser( usage='usage: %prog file byte-offset replacment-value') parser.add_option("", "--revert", action="store_true", default=False, help="restore the path to pristine condition if possible.") parser.add_option("-b", "--backup", action="store_true", default=True, dest="backup", help="create a backup of the uncorrupted original" " [default: %default]") parser.add_option("", "--no-backup", action="store_false", dest="backup", help="do not create a backup of the uncorrupted original.") parser.add_option("", "--backup-suffix", type="string", default="pristine", help="suffix for uncorrupted copy of the file" " [default: %default]") (options, args) = parser.parse_args() if options.revert: if len(args) != 1: parser.print_help() sys.exit(1) elif len(args) != 3: parser.print_help() sys.exit(1) path = args[0] revert(path) if not options.revert: offset = int(eval(args[1])) value = int(eval(args[2])) corrupt(path, offset, value)

parser.py

veer66/vtimeline

12799047

<reponame>veer66/vtimeline #-*- coding: UTF-8 -*- # # Copyright 2009 <NAME> # # Permission is hereby granted, free of charge, to any person # obtaining a copy of this software and associated documentation # files (the "Software"), to deal in the Software without # restriction, including without limitation the rights to use, # copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following # conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES # OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. import re def parse_date(txt): pat = re.compile('^(?P<day>\d+)/(?P<month>\d+)/(?P<year>\d+)$') m = pat.match(txt) if m: d = m.groupdict() d_ = {} for k, v in d.items(): d_[k] = int(v) d = d_ else: pat2 = re.compile('^(?P<month>\d+)/(?P<year>\d+)$') m2 = pat2.match(txt) if m2: d = m2.groupdict() d_ = {} for k, v in d.items(): d_[k] = int(v) d = d_ d['day'] = None else: raise RuntimeError, "cannot parse date" + " :" + txt + ":" return d def parse_activity(m, statements): desc = m.group(2).strip() statements.append({'type': 'activity', 'desc': desc}) def parse_act_start(m): date = parse_date(m.groupdict()['date'].strip()) return ('start', date) def parse_act_end(m): date = parse_date(m.groupdict()['date'].strip()) return ('end', date) def parse_act_complete(m): percent = int(m.groupdict()['percent'].strip()) return ('complete', percent) def parse_activity_detail(m, statements): pats = [(u"^ตั้งแต่(?P<date>.+)", parse_act_start), (u"^ถึง(?P<date>.+)", parse_act_end), (u"^สำเร็จร้อยละ\s*(?P<percent>\d+)", parse_act_complete)] pats = map(lambda pat: (re.compile(pat[0]), pat[1]), pats) result = None for pat in pats: m_ = pat[0].match(m.group(2).strip()) if m_: result = pat[1](m_) break if result is None: raise RuntimeError, "Cannot parse activity detail" if len(statements) == 0 or statements[-1]['type'] != 'activity': raise RuntimeError, "There is no activity before activity detail" statements[-1][result[0]] = result[1] def parse_start(m, statements): statements.append({'type': 'start', 'date': parse_date(m.group(2).strip())}) def parse_end(m, statements): statements.append({'type': 'end', 'date': parse_date(m.group(2).strip())}) def parse_resolution(m, statements): m_ = re.match(u"^(\d+)\s+เดือน$", m.group(2).strip()) if m_: statements.append({'type': 'resolution', 'day': 0, 'year': 0, 'month': int(m_.group(1))}) else: raise RuntimeError, "Cannot parse resolution" def parse_width(m, statements): m_ = re.match(u"^(\d+)$", m.group(2).strip()) if m_: statements.append({'type': 'width', 'value': int(m_.group(1))}) else: raise RuntimeError, "Cannot parse width" def parse_first_column_width(m, statements): m_ = re.match(u"^(\d+)$", m.group(2).strip()) if m_: statements.append({'type': '1st_col_width', 'value': int(m_.group(1))}) else: raise RuntimeError, "Cannot parse first column width" def parse(txt): start_pats = [(u"(^กิจกรรม)(.+)", parse_activity) , (u"(^\*)(.+)", parse_activity_detail), (u"(^เริ่ม)(.+)", parse_start), ( u"(^สิ้นสุด)(.+)", parse_end ), (u"(^ความละเอียด)(.+)", parse_resolution), (u"(^ช่องกว้าง)(.+)", parse_width), (u"(^ช่องแรกกว้าง)(.+)", parse_first_column_width)] start_pats = map(lambda pat: (re.compile(pat[0]), pat[1]), start_pats) statements = [] for line in txt.replace("\r", "").split("\n"): line = line.strip() if line != '': for pat in start_pats: m = pat[0].match(line) if m: pat[1](m, statements) break return statements

tests/telnet.py

cmu-sei/usersim

12799048

# Copyright 2017 <NAME>. See LICENSE.md file for terms. import socket import threading import api import usersim TCP_IP = 'localhost' TCP_PORT = 5005 def run_test(): telnet_config = {'type': 'telnet', 'config': {'host': TCP_IP, 'username': 'admin', 'password': 'password', 'commandlist': ['printstuff', 'do other stuff', 'do this thing'], 'port': TCP_PORT}} sim = usersim.UserSim(True) task_id = api.validate_config(telnet_config) def start_server(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind((TCP_IP, TCP_PORT)) s.listen(1) conn, addr = s.accept() print('Connection Address: ' + str(addr)) while True: data = conn.recv(20) if not data: break print('received data: ' + str(data)) conn.send(data) conn.close() if __name__ == '__main__': run_test()

polichart/api/views.py

cjmabry/PoliChart

12799049

<filename>polichart/api/views.py # -*- coding: utf-8 -*- from flask import Blueprint, current_app, request, jsonify from flask.ext.login import login_user, current_user, logout_user from ..extensions import db from polichart import models api = Blueprint('api', __name__, url_prefix='/api')

guillotina/contrib/swagger/services.py

Qiwn/guillotina

12799050

import copy import json import os from urllib.parse import urlparse import pkg_resources from guillotina import app_settings from guillotina import configure from guillotina.api.service import Service from guillotina.component import getMultiAdapter from guillotina.interfaces import IAbsoluteURL from guillotina.utils import get_authenticated_user from guillotina.utils import get_full_content_path from guillotina.utils import get_request_scheme from guillotina.utils import get_security_policy from guillotina.utils import resolve_dotted_name from zope.interface import Interface from zope.interface.interfaces import ComponentLookupError here = os.path.dirname(os.path.realpath(__file__)) @configure.service( method="GET", context=Interface, name="@swagger", permission="guillotina.swagger.View", ignore=True, ) class SwaggerDefinitionService(Service): __allow_access__ = True def get_data(self, data): if callable(data): data = data(self.context) return data def load_swagger_info(self, api_def, path, method, tags, service_def): path = path.rstrip("/") if path not in api_def: api_def[path or "/"] = {} desc = self.get_data(service_def.get("description", "")) swagger_conf = service_def.get("swagger", {}) if swagger_conf.get("display_permission", True): if desc: desc += f" 〜 permission: {service_def['permission']}" else: desc += f"permission: {service_def['permission']}" api_def[path or "/"][method.lower()] = { "tags": swagger_conf.get("tags", [""]) or tags, "parameters": self.get_data(service_def.get("parameters", {})), "produces": self.get_data(service_def.get("produces", [])), "summary": self.get_data(service_def.get("summary", "")), "description": desc, "responses": self.get_data(service_def.get("responses", {})), } def get_endpoints(self, iface_conf, base_path, api_def, tags=None): tags = tags or [] for method in iface_conf.keys(): if method == "endpoints": for name in iface_conf["endpoints"]: self.get_endpoints( iface_conf["endpoints"][name], os.path.join(base_path, name), api_def, tags=[name.strip("@")], ) else: if method.lower() == "options": continue service_def = iface_conf[method] swagger_conf = service_def.get("swagger", {}) if (service_def.get("ignore") or service_def.get("swagger_ignore") or swagger_conf.get("ignore")): continue if not self.policy.check_permission( service_def["permission"], self.context ): continue for sub_path in [""] + swagger_conf.get("extra_paths", []): path = os.path.join(base_path, sub_path) if "traversed_service_definitions" in service_def: trav_defs = service_def[ "traversed_service_definitions" ] if isinstance(trav_defs, dict): for sub_path, sub_service_def in trav_defs.items(): sub_service_def["permission"] = service_def[ "permission" ] self.load_swagger_info( api_def, os.path.join(path, sub_path), method, tags, sub_service_def, ) else: self.load_swagger_info( api_def, path, method, tags, service_def ) async def __call__(self): user = get_authenticated_user() self.policy = get_security_policy(user) definition = copy.deepcopy( app_settings["swagger"]["base_configuration"] ) vhm = self.request.headers.get("X-VirtualHost-Monster") if vhm: parsed_url = urlparse(vhm) definition["host"] = parsed_url.netloc definition["schemes"] = [parsed_url.scheme] definition["basePath"] = parsed_url.path else: definition["host"] = self.request.host definition["schemes"] = [get_request_scheme(self.request)] if 'version' not in definition['info']: definition["info"]["version"] = pkg_resources.get_distribution( "guillotina" ).version api_defs = app_settings["api_definition"] path = get_full_content_path(self.context) for dotted_iface in api_defs.keys(): iface = resolve_dotted_name(dotted_iface) if iface.providedBy(self.context): iface_conf = api_defs[dotted_iface] self.get_endpoints(iface_conf, path, definition["paths"]) definition["definitions"] = app_settings["json_schema_definitions"] return definition AUTH_HTML = ''' <form id='api_selector'> <div id="auth_container"> <div> <a class="authorize__btn" href="#">Authorize</a> </div> </div> </form> ''' @configure.service( method="GET", context=Interface, name="@docs", permission="guillotina.swagger.View", ignore=True, ) async def render_docs_index(context, request): if app_settings['swagger'].get('index_html'): index_file = app_settings['swagger']['index_html'] else: index_file = os.path.join(here, "index.html") with open(index_file) as fi: html = fi.read() swagger_settings = app_settings["swagger"] url = swagger_settings["base_url"] or request.headers.get( "X-VirtualHost-Monster" ) if url is None: try: url = getMultiAdapter((context, request), IAbsoluteURL)() except ComponentLookupError: url = "{}://{}".format(get_request_scheme(request), request.host) swagger_settings["initial_swagger_url"] = url if swagger_settings['authentication_allowed']: auth = AUTH_HTML else: auth = '' return html.format( app_settings=app_settings, request=request, swagger_settings=json.dumps(swagger_settings), base_url=url, static_url="{}/swagger_static/".format(url if url != "/" else ""), auth=auth, title=swagger_settings['base_configuration']['info']['title'] )