Datasets:

ytzi

/

the-stack-dedup-python-filtered-docstrings

like 0

0d607dd9d30fd2b66bf03406a4293eb03eebd09f

py

Python

june-challenge/min-cost-stairs.py

kd82/interview-preparation

a47de06c677b37c8160d1429f43e38288c157754

june-challenge/min-cost-stairs.py

kd82/interview-preparation

a47de06c677b37c8160d1429f43e38288c157754

june-challenge/min-cost-stairs.py

kd82/interview-preparation

a47de06c677b37c8160d1429f43e38288c157754

from collections import List

from collections import List def minCostClimbingStairs(cost: List[int]) -> int: def dfs(cost, i): if i >= len(cost): return 0 if dp[i] > -1: return dp[i] res = cost[i] + min(dfs(cost, i + 1), dfs(cost, i + 2)) dp[i] = res return res dp = [-1]*(len(cost)) return min(dfs(cost, 0), dfs(cost, 1)) def dfsbu(cost): d1, d2 = 0, 0 for i in range(2, len(cost) + 1): temp = d1 d1 = min(cost[i - 1] + d1, cost[i - 2] + d2) d2 = temp return d1

4b4e3ddd829c54567bd78d89e6a6a0b6affd419f

py

Python

portlab/evaluate/lib/backtest.py

sqt-aliu/portlab

366755c2cfe7bb53c1b236688684fc2c9d8bf4d1

2017-11-06T06:01:24.000Z

2017-11-06T06:01:24.000Z

portlab/evaluate/lib/backtest.py

sqt-aliu/portlab

366755c2cfe7bb53c1b236688684fc2c9d8bf4d1

portlab/evaluate/lib/backtest.py

sqt-aliu/portlab

366755c2cfe7bb53c1b236688684fc2c9d8bf4d1

import numpy as np # core functions totalreturn = lambda x: (x[-1]/x[0])-1 finalreturn = lambda x: x[-1] sharpe = lambda x: np.sqrt(12) * (np.mean(x) / np.std(x)) ann_vol = lambda x: np.sqrt(12) * np.std(x) cagr = lambda x: ((((x[-1]) / x[0])) ** (12.0/(x.count()-1))) - 1 cagr2 = lambda x: ((np.mean(x)+1) ** 12) -1

import numpy as np # core functions totalreturn = lambda x: (x[-1]/x[0])-1 finalreturn = lambda x: x[-1] sharpe = lambda x: np.sqrt(12) * (np.mean(x) / np.std(x)) ann_vol = lambda x: np.sqrt(12) * np.std(x) cagr = lambda x: ((((x[-1]) / x[0])) ** (12.0/(x.count()-1))) - 1 cagr2 = lambda x: ((np.mean(x)+1) ** 12) -1 def max_drawdown(X): mdd = 0 peak = X[0] for x in X: if x > peak: peak = x dd = (peak - x) if dd > mdd: mdd = dd return mdd def avg_max_drawdown(X): ldd = [] mdd = 0 peak = X[0] for x in X: if x > peak: peak = x dd = (peak - x) if dd > mdd: mdd = dd ldd.append(mdd) return 0 if len(ldd) == 0 else np.mean(ldd) def bca_max_drawdown(X): mdd = 0 peak = X[0] for x in X: if x > peak: peak = x if peak != 0: dd = 1-x/peak if dd > mdd: mdd = dd return mdd

18efce23cede35e1ce11c9f84824727b1df23f9d

py

Python

sample_scripts/retarget_campaign.py

decisive/api-demo-python

58cd14e9e1f6373a3cd927536fd29f5f286940a0

sample_scripts/retarget_campaign.py

decisive/api-demo-python

58cd14e9e1f6373a3cd927536fd29f5f286940a0

sample_scripts/retarget_campaign.py

decisive/api-demo-python

58cd14e9e1f6373a3cd927536fd29f5f286940a0

import sys # NOTE: for exiting import requests import datetime import pprint import ujson as json # NOTE: faster json API_KEY = '' # TODO: input api key here!!! if not API_KEY: sys.exit('Please insert your Decisive API key') print print 'Creating session to always add API key...' # NOTE: you can also use decisive.DecisiveApiClient session = requests.Session() session.auth = (API_KEY,'') API_HOST = 'https://ads.decisive.is' print print 'Selecting ads...' ads = get('ads', offset=1, limit=5, approved='true') ad_ids = [a['ad_id'] for a in ads] print 'selected', ad_ids print print 'Creating retargeting campaign...' to_retargeting_id = lambda a: 'clicks_{}'.format(ad['ad_id']) # TODO: fill in your own campaign details new_ad = {'url':'http://google.com', 'name':'example ad name', 'budget':1984, 'bidmode':'Manual', 'cpm_bid':3.1415, 'creative_urls':['https://www.google.com.au/images/srpr/logo11w.png'], 'start_date':datetime.datetime.now().isoformat(), 'end_date':datetime.datetime.now().isoformat(), 'blacklist':{'country':['Canada','France'],'site': ['tmz.com', 'dogecoin.com']} } ad['targeting'] = {'device_groups':map(to_retargeting_id, ad_ids)} # NOTE: retargeting print post(ad, 'ads')

import sys # NOTE: for exiting import requests import datetime import pprint import ujson as json # NOTE: faster json API_KEY = '' # TODO: input api key here!!! if not API_KEY: sys.exit('Please insert your Decisive API key') print print 'Creating session to always add API key...' # NOTE: you can also use decisive.DecisiveApiClient session = requests.Session() session.auth = (API_KEY,'') API_HOST = 'https://ads.decisive.is' def to_uri(*paths, **get_args): path = '/'.join(p.strip('/') if isinstance(p,(str,unicode)) else unicode(p) for p in paths) args = '&'.join('{}={}'.format(*i) for i in get_args.items()) return '{}/{}?{}'.format(API_HOST, path, args) def get(*paths, **get_args): uri = to_uri(*paths, **get_args) response = session.get(uri) response.raise_for_status() return response.json() def put(updated_ad): uri = to_uri('ads',updated_ad['ad_id']) response = session.put(uri, data=json.dumps(updated_ad)) response.raise_for_status() return True def post(data, *paths): uri = to_uri(*paths) response = session.post(uri, data=json.dumps(data)) response.raise_for_status() return response.json() print print 'Selecting ads...' ads = get('ads', offset=1, limit=5, approved='true') ad_ids = [a['ad_id'] for a in ads] print 'selected', ad_ids print print 'Creating retargeting campaign...' to_retargeting_id = lambda a: 'clicks_{}'.format(ad['ad_id']) # TODO: fill in your own campaign details new_ad = {'url':'http://google.com', 'name':'example ad name', 'budget':1984, 'bidmode':'Manual', 'cpm_bid':3.1415, 'creative_urls':['https://www.google.com.au/images/srpr/logo11w.png'], 'start_date':datetime.datetime.now().isoformat(), 'end_date':datetime.datetime.now().isoformat(), 'blacklist':{'country':['Canada','France'],'site': ['tmz.com', 'dogecoin.com']} } ad['targeting'] = {'device_groups':map(to_retargeting_id, ad_ids)} # NOTE: retargeting print post(ad, 'ads')

9975b4944c84ea643a71a8fe95b55e6ebcf03607

py

Python

taaontia/commands/registry.py

Kagaminara/taaontia.py

5f31f22fd26767903f8351eab209848fe1ddb6b0

taaontia/commands/registry.py

Kagaminara/taaontia.py

5f31f22fd26767903f8351eab209848fe1ddb6b0

taaontia/commands/registry.py

Kagaminara/taaontia.py

5f31f22fd26767903f8351eab209848fe1ddb6b0

commands = CommandsRegistry()

class CommandsRegistry: def __init__(self): self.commands = {} def register(self, command): self.commands[command.trigger] = command() return command def get(self, command): from .helper import HelpCommand return self.commands.get(command, HelpCommand()) commands = CommandsRegistry()

de76335bf95488a9cd521c5b94630a6f3bfab345

py

Python

src/graph_transpiler/webdnn/frontend/tensorflow/ops/gen_nn_ops.py

steerapi/webdnn

1df51cc094e5a528cfd3452c264905708eadb491

2021-04-09T15:55:35.000Z

2021-04-09T15:55:35.000Z

src/graph_transpiler/webdnn/frontend/tensorflow/ops/gen_nn_ops.py

steerapi/webdnn

1df51cc094e5a528cfd3452c264905708eadb491

src/graph_transpiler/webdnn/frontend/tensorflow/ops/gen_nn_ops.py

steerapi/webdnn

1df51cc094e5a528cfd3452c264905708eadb491

from typing import Tuple, List import numpy as np import tensorflow as tf from webdnn.frontend.tensorflow.converter import TensorFlowConverter from webdnn.frontend.tensorflow.util import unary_op_handler, check_data_format, convert_odd_padding_to_concat, parse_padding from webdnn.graph.axis import Axis from webdnn.graph.operators.average_pooling_2d import AveragePooling2D from webdnn.graph.operators.clipped_relu import ClippedRelu from webdnn.graph.operators.concat import Concat from webdnn.graph.operators.convolution2d import Convolution2D from webdnn.graph.operators.deconvolution2d import Deconvolution2D from webdnn.graph.operators.elu import Elu from webdnn.graph.operators.max_pooling_2d import MaxPooling2D from webdnn.graph.operators.relu import Relu from webdnn.graph.operators.softmax import Softmax from webdnn.graph.operators.softplus import Softplus from webdnn.graph.operators.softsign import Softsign from webdnn.graph.order import Order from webdnn.graph.variables.constant_variable import ConstantVariable from webdnn.util import console @TensorFlowConverter.register_handler("AvgPool") @TensorFlowConverter.register_handler("AvgPool3D") @TensorFlowConverter.register_handler("AvgPool3DGrad") @TensorFlowConverter.register_handler("AvgPoolGrad") @TensorFlowConverter.register_handler("BatchNormWithGlobalNormalization") @TensorFlowConverter.register_handler("BatchNormWithGlobalNormalizationGrad") @TensorFlowConverter.register_handler("BiasAdd") @TensorFlowConverter.register_handler("BiasAddGrad") @TensorFlowConverter.register_handler("BiasAddV1") @TensorFlowConverter.register_handler("Conv2D") @TensorFlowConverter.register_handler("Conv2DBackpropFilter") @TensorFlowConverter.register_handler("Conv2DBackpropInput") @TensorFlowConverter.register_handler("Conv3D") @TensorFlowConverter.register_handler("Conv3DBackpropFilter") @TensorFlowConverter.register_handler("Conv3DBackpropFilterV2") @TensorFlowConverter.register_handler("Conv3DBackpropInput") @TensorFlowConverter.register_handler("Conv3DBackpropInputV2") @TensorFlowConverter.register_handler("DepthwiseConv2dNative") @TensorFlowConverter.register_handler("DepthwiseConv2dNativeBackpropFilter") @TensorFlowConverter.register_handler("DepthwiseConv2dNativeBackpropInput") @TensorFlowConverter.register_handler("Dilation2D") @TensorFlowConverter.register_handler("Dilation2DBackpropFilter") @TensorFlowConverter.register_handler("Dilation2DBackpropInput") TensorFlowConverter.register_handler("Elu")(unary_op_handler(Elu)) @TensorFlowConverter.register_handler("EluGrad") @TensorFlowConverter.register_handler("FractionalAvgPoolGrad") @TensorFlowConverter.register_handler("FractionalMaxPoolGrad") @TensorFlowConverter.register_handler("FusedBatchNorm") @TensorFlowConverter.register_handler("FusedPadConv2D") @TensorFlowConverter.register_handler("FusedResizeAndPadConv2D") @TensorFlowConverter.register_handler("InTopK") @TensorFlowConverter.register_handler("InTopKV2") @TensorFlowConverter.register_handler("L2Loss") @TensorFlowConverter.register_handler("LRN") @TensorFlowConverter.register_handler("LRNGrad") @TensorFlowConverter.register_handler("LogSoftmax") @TensorFlowConverter.register_handler("MaxPool") @TensorFlowConverter.register_handler("MaxPool3D") @TensorFlowConverter.register_handler("MaxPool3DGrad") @TensorFlowConverter.register_handler("MaxPool3DGradGrad") @TensorFlowConverter.register_handler("MaxPoolGrad") @TensorFlowConverter.register_handler("MaxPoolGradGrad") @TensorFlowConverter.register_handler("MaxPoolGradGradWithArgmax") @TensorFlowConverter.register_handler("MaxPoolGradWithArgmax") @TensorFlowConverter.register_handler("MaxPoolWithArgmax") @TensorFlowConverter.register_handler("QuantizedAvgPool") @TensorFlowConverter.register_handler("QuantizedBatchNormWithGlobalNormalization") @TensorFlowConverter.register_handler("QuantizedBiasAdd") @TensorFlowConverter.register_handler("QuantizedConv2D") @TensorFlowConverter.register_handler("QuantizedMaxPool") @TensorFlowConverter.register_handler("QuantizedRelu") @TensorFlowConverter.register_handler("QuantizedRelu6") @TensorFlowConverter.register_handler("QuantizedReluX") TensorFlowConverter.register_handler("Relu")(unary_op_handler(Relu)) @TensorFlowConverter.register_handler("Relu6") @TensorFlowConverter.register_handler("Relu6Grad") @TensorFlowConverter.register_handler("ReluGrad") @TensorFlowConverter.register_handler("Softmax") @TensorFlowConverter.register_handler("SoftmaxCrossEntropyWithLogits") @TensorFlowConverter.register_handler("Softplus") @TensorFlowConverter.register_handler("SoftplusGrad") TensorFlowConverter.register_handler("Softsign")(unary_op_handler(Softsign)) @TensorFlowConverter.register_handler("SoftsignGrad") @TensorFlowConverter.register_handler("SparseSoftmaxCrossEntropyWithLogits") @TensorFlowConverter.register_handler("TopK") @TensorFlowConverter.register_handler("TopKV2")

from typing import Tuple, List import numpy as np import tensorflow as tf from webdnn.frontend.tensorflow.converter import TensorFlowConverter from webdnn.frontend.tensorflow.util import unary_op_handler, check_data_format, convert_odd_padding_to_concat, parse_padding from webdnn.graph.axis import Axis from webdnn.graph.operators.average_pooling_2d import AveragePooling2D from webdnn.graph.operators.clipped_relu import ClippedRelu from webdnn.graph.operators.concat import Concat from webdnn.graph.operators.convolution2d import Convolution2D from webdnn.graph.operators.deconvolution2d import Deconvolution2D from webdnn.graph.operators.elu import Elu from webdnn.graph.operators.max_pooling_2d import MaxPooling2D from webdnn.graph.operators.relu import Relu from webdnn.graph.operators.softmax import Softmax from webdnn.graph.operators.softplus import Softplus from webdnn.graph.operators.softsign import Softsign from webdnn.graph.order import Order from webdnn.graph.variables.constant_variable import ConstantVariable from webdnn.util import console @TensorFlowConverter.register_handler("AvgPool") def avg_pool_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): x = converter.get_variable(tf_op.inputs[0]) data_format = tf_op.get_attr("data_format") check_data_format(x, data_format) ksize = tuple(tf_op.get_attr("ksize")) # type: Tuple[int,...] assert ksize[x.order.axes_dict[Axis.N]] == 1 assert ksize[x.order.axes_dict[Axis.C]] == 1 ksize = (ksize[x.order.axes_dict[Axis.H]], ksize[x.order.axes_dict[Axis.W]]) stride = tuple(tf_op.get_attr("strides")) # type: Tuple[int,...] assert stride[x.order.axes_dict[Axis.N]] == 1 assert stride[x.order.axes_dict[Axis.C]] == 1 stride = (stride[x.order.axes_dict[Axis.H]], stride[x.order.axes_dict[Axis.W]]) padding = ( parse_padding(tf_op.get_attr("padding"), ksize[0], 1), parse_padding(tf_op.get_attr("padding"), ksize[1], 1), ) x, padding = convert_odd_padding_to_concat(x, padding=padding) if any(p > 0 for p in padding): console.warning( "[KerasConverter] keras.layers.AveragePooling computes average by dividing number of valid elements in window " "(without padding element), but WebDNN divides it by the number of elements including padding element, so different " "result will be generated on the edge.") y, = AveragePooling2D(None, ksize=ksize, stride=stride, padding=padding, cover_all=False)(x) converter.set_variable(tf_op.outputs[0], y) @TensorFlowConverter.register_handler("AvgPool3D") def avg_pool3_d_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): # FIXME raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("AvgPool3DGrad") def avg_pool3_d_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("AvgPoolGrad") def avg_pool_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("BatchNormWithGlobalNormalization") def batch_norm_with_global_normalization_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): # FIXME raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("BatchNormWithGlobalNormalizationGrad") def batch_norm_with_global_normalization_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("BiasAdd") def bias_add_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): x = converter.get_variable(tf_op.inputs[0]) b = converter.get_variable(tf_op.inputs[1]) data_format = tf_op.get_attr("data_format") if data_format == b"NCHW": b.order.axes[0].unify(x.order.axes[1]) elif data_format == b"NHWC": b.order.axes[0].unify(x.order.axes[-1]) else: raise NotImplementedError("Unknown data format") y = x + b converter.set_variable(tf_op.outputs[0], y) @TensorFlowConverter.register_handler("BiasAddGrad") def bias_add_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("BiasAddV1") def bias_add_v1_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): # FIXME raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("Conv2D") def conv2_d_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): x = converter.get_variable(tf_op.inputs[0]) data_format = tf_op.get_attr("data_format") check_data_format(x, data_format) w = converter.get_variable(tf_op.inputs[1]) # HWCN w.order.unify(Order([Axis.KH, Axis.KW, Axis.C, Axis.N])) ksize = (w.shape_dict[Axis.KH], w.shape_dict[Axis.KW]) stride = tuple(tf_op.get_attr("strides")) # type: Tuple[int,...] assert stride[x.order.axes_dict[Axis.N]] == 1 assert stride[x.order.axes_dict[Axis.C]] == 1 stride = (stride[x.order.axes_dict[Axis.H]], stride[x.order.axes_dict[Axis.W]]) input_size = np.array([x.shape_dict[Axis.H], x.shape_dict[Axis.W]]) padding = np.array([ parse_padding(tf_op.get_attr("padding"), ksize[0], 1), parse_padding(tf_op.get_attr("padding"), ksize[1], 1) ]) apron_size = (input_size + padding.sum(axis=1) - ksize) % stride # cancel padding by apron if possible for i in (0, 1): if padding[i, 0] > apron_size[i]: padding[i, 0] -= apron_size[i] apron_size[i] = 0 else: apron_size[i] -= padding[i, 0] padding[i, 0] = 0 if padding[i, 1] > apron_size[i]: padding[i, 1] -= apron_size[i] apron_size[i] = 0 else: apron_size[i] -= padding[i, 1] padding[i, 1] = 0 padding_list = padding.tolist() # type: List[Tuple[int, int]] x, padding = convert_odd_padding_to_concat(x, padding=padding_list) y, = Convolution2D(None, ksize=ksize, stride=stride, padding=padding)(x, w) converter.set_variable(tf_op.outputs[0], y) @TensorFlowConverter.register_handler("Conv2DBackpropFilter") def conv2_d_backprop_filter_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("Conv2DBackpropInput") def conv2_d_backprop_input_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): input_sizes = converter.get_variable(tf_op.inputs[0]) if not isinstance(input_sizes, ConstantVariable): raise NotImplementedError( "[TensorFlowConverter] Conv2DBackpropInput with dynamic shape of output (input of convolution) variable is not supported.") input_sizes = tuple(input_sizes.data.astype(np.int32).tolist()) w = converter.get_variable(tf_op.inputs[1]) # HWNC w.order.unify(Order([Axis.KH, Axis.KW, Axis.N, Axis.C])) gy = converter.get_variable(tf_op.inputs[2]) # NHWC data_format = tf_op.get_attr("data_format") check_data_format(gy, data_format) input_size = np.array([input_sizes[gy.order.axes_dict[Axis.H]], input_sizes[gy.order.axes_dict[Axis.W]]]) ksize = np.array([w.shape_dict[Axis.KH], w.shape_dict[Axis.KW]]) stride = np.array(tf_op.get_attr("strides")) assert stride[gy.order.axes_dict[Axis.N]] == 1 assert stride[gy.order.axes_dict[Axis.C]] == 1 stride = stride[[gy.order.axes_dict[Axis.H], gy.order.axes_dict[Axis.W]]] padding = np.array([ parse_padding(tf_op.get_attr("padding"), ksize[0], 1), parse_padding(tf_op.get_attr("padding"), ksize[1], 1) ]) x, = Deconvolution2D(None, ksize=ksize.tolist(), stride=stride.tolist(), padding=0)(gy, w) # Actual padding size is depend on 2 factors # 1. padding mode # 2. extra apron size (= (input size of convolution) - (size of the tensor expanded by deconvolution)) expanded_size = np.array([x.shape_dict[Axis.H], x.shape_dict[Axis.W]]) apron_size = input_size - (expanded_size - padding.sum(axis=1)) # cancel padding by apron if possible for i in (0, 1): if padding[i, 0] > apron_size[i]: padding[i, 0] -= apron_size[i] apron_size[i] = 0 else: apron_size[i] -= padding[i, 0] padding[i, 0] = 0 if padding[i, 1] > apron_size[i]: padding[i, 1] -= apron_size[i] apron_size[i] = 0 else: apron_size[i] -= padding[i, 1] padding[i, 1] = 0 # append extra apron for i, axis in enumerate((Axis.H, Axis.W)): if apron_size[i] == 0: continue data = np.zeros([apron_size[i] if a == axis else x.shape_dict[a] for a in x.order.axes]) x, = Concat(None, axis=axis)(x, ConstantVariable(data, x.order)) # crop without padding padding_list = padding.tolist() # type: List[List[int]] slice_h = slice(None) if padding_list[0] == [0, 0] else slice(padding_list[0][0], -padding_list[0][1]) slice_w = slice(None) if padding_list[1] == [0, 0] else slice(padding_list[1][0], -padding_list[1][1]) if data_format == b"NCHW": x = x[:, :, slice_h, slice_w] elif data_format == b"NHWC": x = x[:, slice_h, slice_w, :] else: raise NotImplementedError(f"Unknown data format: {data_format}") converter.set_variable(tf_op.outputs[0], x) @TensorFlowConverter.register_handler("Conv3D") def conv3_d_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("Conv3DBackpropFilter") def conv3_d_backprop_filter_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("Conv3DBackpropFilterV2") def conv3_d_backprop_filter_v2_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("Conv3DBackpropInput") def conv3_d_backprop_input_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("Conv3DBackpropInputV2") def conv3_d_backprop_input_v2_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("DepthwiseConv2dNative") def depthwise_conv2d_native_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): # FIXME raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("DepthwiseConv2dNativeBackpropFilter") def depthwise_conv2d_native_backprop_filter_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("DepthwiseConv2dNativeBackpropInput") def depthwise_conv2d_native_backprop_input_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("Dilation2D") def dilation2_d_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): # FIXME raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("Dilation2DBackpropFilter") def dilation2_d_backprop_filter_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("Dilation2DBackpropInput") def dilation2_d_backprop_input_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") TensorFlowConverter.register_handler("Elu")(unary_op_handler(Elu)) @TensorFlowConverter.register_handler("EluGrad") def elu_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("FractionalAvgPoolGrad") def fractional_avg_pool_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("FractionalMaxPoolGrad") def fractional_max_pool_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("FusedBatchNorm") def fused_batch_norm_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): x = converter.get_variable(tf_op.inputs[0]) scale = converter.get_variable(tf_op.inputs[1]) offset = converter.get_variable(tf_op.inputs[2]) mean = converter.get_variable(tf_op.inputs[3]) variance = converter.get_variable(tf_op.inputs[4]) epsilon = tf_op.get_attr("epsilon") data_format = tf_op.get_attr("data_format") if data_format == b"NHWC": channel_axis = x.order.axes[3] elif data_format == b"NCHW": channel_axis = x.order.axes[1] else: raise NotImplementedError("Unknown data format") scale.order.axes[0].unify(channel_axis) offset.order.axes[0].unify(channel_axis) mean.order.axes[0].unify(channel_axis) variance.order.axes[0].unify(channel_axis) y = (x - mean) / ((variance + epsilon) ** 0.5) * scale + offset converter.set_variable(tf_op.outputs[0], y) @TensorFlowConverter.register_handler("FusedPadConv2D") def fused_pad_conv2_d_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): # FIXME raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("FusedResizeAndPadConv2D") def fused_resize_and_pad_conv2_d_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): # FIXME raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("InTopK") def in_top_k_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("InTopKV2") def in_top_kv2_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("L2Loss") def l2_loss_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("LRN") def lrn_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): # FIXME raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("LRNGrad") def lrn_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("LogSoftmax") def log_softmax_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): # FIXME raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("MaxPool") def max_pool_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): x = converter.get_variable(tf_op.inputs[0]) data_format = tf_op.get_attr("data_format") check_data_format(x, data_format) ksize = tuple(tf_op.get_attr("ksize")) # type: Tuple[int,...] assert ksize[x.order.axes_dict[Axis.N]] == 1 assert ksize[x.order.axes_dict[Axis.C]] == 1 ksize = (ksize[x.order.axes_dict[Axis.H]], ksize[x.order.axes_dict[Axis.W]]) stride = tuple(tf_op.get_attr("strides")) # type: Tuple[int,...] assert stride[x.order.axes_dict[Axis.N]] == 1 assert stride[x.order.axes_dict[Axis.C]] == 1 stride = (stride[x.order.axes_dict[Axis.H]], stride[x.order.axes_dict[Axis.W]]) padding = ( parse_padding(tf_op.get_attr("padding"), ksize[0], 1), parse_padding(tf_op.get_attr("padding"), ksize[1], 1), ) x, padding = convert_odd_padding_to_concat(x, padding=padding, value=-1.0e10) y, = MaxPooling2D(None, ksize=ksize, stride=stride, padding=padding, cover_all=False)(x) converter.set_variable(tf_op.outputs[0], y) @TensorFlowConverter.register_handler("MaxPool3D") def max_pool3_d_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): # FIXME raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("MaxPool3DGrad") def max_pool3_d_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("MaxPool3DGradGrad") def max_pool3_d_grad_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("MaxPoolGrad") def max_pool_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("MaxPoolGradGrad") def max_pool_grad_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("MaxPoolGradGradWithArgmax") def max_pool_grad_grad_with_argmax_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("MaxPoolGradWithArgmax") def max_pool_grad_with_argmax_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("MaxPoolWithArgmax") def max_pool_with_argmax_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("QuantizedAvgPool") def quantized_avg_pool_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("QuantizedBatchNormWithGlobalNormalization") def quantized_batch_norm_with_global_normalization_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("QuantizedBiasAdd") def quantized_bias_add_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("QuantizedConv2D") def quantized_conv2_d_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("QuantizedMaxPool") def quantized_max_pool_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("QuantizedRelu") def quantized_relu_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("QuantizedRelu6") def quantized_relu6_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("QuantizedReluX") def quantized_relu_x_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") TensorFlowConverter.register_handler("Relu")(unary_op_handler(Relu)) @TensorFlowConverter.register_handler("Relu6") def relu6_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): x = converter.get_variable(tf_op.inputs[0]) y, = ClippedRelu(None, cap=6)(x) converter.set_variable(tf_op.outputs[0], y) @TensorFlowConverter.register_handler("Relu6Grad") def relu6_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("ReluGrad") def relu_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("Softmax") def softmax_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): x = converter.get_variable(tf_op.inputs[0]) y, = Softmax(None, axis=x.order.axes[-1])(x) converter.set_variable(tf_op.outputs[0], y) @TensorFlowConverter.register_handler("SoftmaxCrossEntropyWithLogits") def softmax_cross_entropy_with_logits_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("Softplus") def softplus_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): x = converter.get_variable(tf_op.inputs[0]) y, = Softplus(None, beta=1)(x) converter.set_variable(tf_op.outputs[0], y) @TensorFlowConverter.register_handler("SoftplusGrad") def softplus_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") TensorFlowConverter.register_handler("Softsign")(unary_op_handler(Softsign)) @TensorFlowConverter.register_handler("SoftsignGrad") def softsign_grad_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("SparseSoftmaxCrossEntropyWithLogits") def sparse_softmax_cross_entropy_with_logits_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("TopK") def top_k_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.") @TensorFlowConverter.register_handler("TopKV2") def top_kv2_handler(converter: TensorFlowConverter, tf_op: "tf.Operation"): raise NotImplementedError(f"[TensorFlowConverter] {tf_op.type} is not supported yet.")

7162d76d7a0f15ece55362aaf305b6e9001bee7f

py

Python

GF2.py

JediKoder/coursera-CodeMatrix

1ac461d22ebaf2777eabdcf31d76d709c33f472a

2015-09-18T02:07:21.000Z

2020-04-22T17:05:11.000Z

GF2.py

JediKoder/coursera-CodeMatrix

1ac461d22ebaf2777eabdcf31d76d709c33f472a

GF2.py

JediKoder/coursera-CodeMatrix

1ac461d22ebaf2777eabdcf31d76d709c33f472a

2015-09-05T03:54:00.000Z

2020-04-21T12:56:40.000Z

from numbers import Number one = One() zero = 0

from numbers import Number class One: def __add__(self, other): return self if other == 0 else 0 __sub__ = __add__ def __mul__(self, other): if isinstance(other, Number): return 0 if other == 0 else self return other def __div__(self, other): if other == 0: raise ZeroDivisionError return self __truediv__ = __div__ def __rdiv__(self,other): return other __rtruediv__ = __rdiv__ __radd__ = __add__ __rsub__ = __add__ __rmul__ = __mul__ def __str__(self): return 'one' __repr__ = __str__ def __neg__(self): return self def __bool__(self): return True one = One() zero = 0

1cf508199cbd0764682bf5bdcd24b98f81e53734

py

Python

tonks/vision/helpers.py

vanderveld/tonks

e87afbd9614b276b443b4a7527fd1fda01a8be4c

tonks/vision/helpers.py

vanderveld/tonks

e87afbd9614b276b443b4a7527fd1fda01a8be4c

tonks/vision/helpers.py

vanderveld/tonks

e87afbd9614b276b443b4a7527fd1fda01a8be4c

from creevey.ops.image import centercrop import numpy as np from PIL import Image import torch.nn as nn def center_crop_pil_image(img): """ Helper function to crop the center out of images. Utilizes the centercrop function from `creevey` Parameters ---------- img: array PIL image array Returns ------- PIL.Image: Slice of input image corresponding to a cropped area around the center """ img = np.array(img) cropped_img = centercrop(img, reduction_factor=.4) return Image.fromarray(cropped_img) class _Identity(nn.Module): """ Used to pass penultimate layer features to the the ensemble Motivation for this is that the features from the penultimate layer are likely more informative than the 1000 way softmax that was used in the multi_output_model_v2. """

from creevey.ops.image import centercrop import numpy as np from PIL import Image import torch.nn as nn def center_crop_pil_image(img): """ Helper function to crop the center out of images. Utilizes the centercrop function from `creevey` Parameters ---------- img: array PIL image array Returns ------- PIL.Image: Slice of input image corresponding to a cropped area around the center """ img = np.array(img) cropped_img = centercrop(img, reduction_factor=.4) return Image.fromarray(cropped_img) class _Identity(nn.Module): """ Used to pass penultimate layer features to the the ensemble Motivation for this is that the features from the penultimate layer are likely more informative than the 1000 way softmax that was used in the multi_output_model_v2. """ def __init__(self): super().__init__() def forward(self, x): return x def _dense_block(in_f, out_f, reg): return nn.Sequential(nn.Linear(in_f, out_f), nn.BatchNorm1d(out_f, eps=reg), nn.ReLU() )

711d9ac3055874d62d06bdb20403fb0a203b8348

py

Python

cornflow_client/schema/manager.py

baobabsoluciones/cornflow-client

f9996f0b841885d26639cb63c8ba6090387de57f

2021-05-12T11:21:26.000Z

2022-02-22T19:23:46.000Z

cornflow_client/schema/manager.py

baobabsoluciones/cornflow-client

f9996f0b841885d26639cb63c8ba6090387de57f

2021-03-14T17:09:46.000Z

2022-02-28T19:12:37.000Z

cornflow_client/schema/manager.py

baobabsoluciones/cornflow-client

f9996f0b841885d26639cb63c8ba6090387de57f

2020-10-03T20:00:19.000Z

2022-03-24T11:52:22.000Z

""" Class to help create and manage data schema and to validate json files. """ from jsonschema import Draft7Validator from copy import deepcopy from genson import SchemaBuilder from .dictSchema import DictSchema from cornflow_client.core.tools import load_json, save_json class SchemaManager: """ A schema manager between json-schema, dict-schema and marshmallow """ def __init__(self, schema, validator=Draft7Validator): """ Class to help create and manage data schema. Once a schema is loaded, allow the validation of data. :param schema: a json schema """ self.validator = validator self.jsonschema = schema @classmethod def from_filepath(cls, path): """ Load a json schema from a json file. :param path the file path return The SchemaManager instance """ schema = cls.load_json(path) return cls(schema) def get_jsonschema(self): """ Return a copy of the stored jsonschema. """ return deepcopy(self.jsonschema) def get_validation_errors(self, data): """ Validate json data according to the loaded jsonschema and return a list of errors. Return an empty list if data is valid. :param dict data: data to validate. :return: A list of validation errors. For more details about the error format, see: https://python-jsonschema.readthedocs.io/en/latest/errors/#jsonschema.exceptions.ValidationError """ v = self.validator(self.get_jsonschema()) if not v.is_valid(data): error_list = [e for e in v.iter_errors(data)] return error_list return [] def validate_data(self, data, print_errors=False): """ Validate json data according to the loaded jsonschema. :param dict data: the data to validate. :param bool print_errors: If true, will print the errors. :return: True if data format is valid, else False. """ errors_list = self.get_validation_errors(data) if print_errors: for e in errors_list: print(e) return len(errors_list) == 0 def get_file_errors(self, path): """ Get json file errors according to the loaded jsonschema. :param path the file path :return: A list of validation errors. For more details about the error format, see: https://python-jsonschema.readthedocs.io/en/latest/errors/#jsonschema.exceptions.ValidationError """ data = self.load_json(path) return self.get_validation_errors(data) def validate_file(self, path, print_errors=False): """ Validate a json file according to the loaded jsonschema. :param path the file path :param print_errors: If true, will print the errors. :return: True if the data is valid and False if it is not. """ data = self.load_json(path) return self.validate_data(data, print_errors=print_errors) def to_dict_schema(self): """ Transform a jsonschema into a dictionary format :return: The schema dictionary """ return self.to_schema_dict_obj().get_schema() def to_schema_dict_obj(self): """ Returns an DictSchema object equivalent of the jsonschema """ return DictSchema(self.get_jsonschema()) @property def to_marshmallow(self): """ Create marshmallow schemas :return: a dict containing the flask marshmallow schemas :rtype: Schema() """ return self.to_schema_dict_obj().to_marshmallow() def export_schema_dict(self, path): """ Print the schema_dict in a json file. :param path: the path where to save the dict.format :return: nothing """ self.save_json(self.to_dict_schema(), path) def draft_schema_from(self, path, save_path=None): """ Create a draft jsonschema from a json file of data. :param path: path to the json file. :param save_path: path where to save the generated schema. :return: the generated schema. """ file = self.load_json(path) builder = SchemaBuilder() builder.add_schema({"type": "object", "properties": {}}) builder.add_object(file) draft_schema = builder.to_json() if save_path is not None: with open(save_path, "w") as outfile: outfile.write(draft_schema) return draft_schema def to_template(self): """ This function assumes certain structure for the jsonschema. For now, three types of tables exist: array of objects, arrays and objects. { table1: [{col1: a, col2: b}, {col1: aa, col2: bb}, ...], table2: [1, 2, 3, ], table3: {config1: a, config2: b}, } """ master_table_name = "_README" type_table_name = "_TYPES" tables = {master_table_name: [], type_table_name: []} # we update the master table of tables: real_props = [ (k, v) for (k, v) in self.jsonschema["properties"].items() if not k.startswith("$") ] for key, value in real_props: tables[master_table_name].append( dict(table=key, description=value.get("description", "")) ) # then we get each table for key, value in real_props: tables[key] = self._get_table(value) # then we get column types example_inv = {1: "integer", "string": "string"} for key, value in real_props: rows = [] if len(tables[key]) > 1: rows = [ dict(table=key, column=v, type="string") for v in ["key", "value"] ] if len(tables[key]) == 1: row1 = tables[key][0] rows = [ dict(table=key, column=k, type=example_inv[v]) for k, v in row1.items() ] tables[type_table_name].extend(rows) return tables @staticmethod @staticmethod def load_json(path): """ Load a json file :param path: the path of the json file.json return the json content. """ return load_json(path) @staticmethod """ Aliases: """ dict_to_flask = to_marshmallow load_schema = from_filepath jsonschema_to_flask = to_marshmallow jsonschema_to_dict = to_dict_schema

""" Class to help create and manage data schema and to validate json files. """ from jsonschema import Draft7Validator from copy import deepcopy from genson import SchemaBuilder from .dictSchema import DictSchema from cornflow_client.core.tools import load_json, save_json class SchemaManager: """ A schema manager between json-schema, dict-schema and marshmallow """ def __init__(self, schema, validator=Draft7Validator): """ Class to help create and manage data schema. Once a schema is loaded, allow the validation of data. :param schema: a json schema """ self.validator = validator self.jsonschema = schema @classmethod def from_filepath(cls, path): """ Load a json schema from a json file. :param path the file path return The SchemaManager instance """ schema = cls.load_json(path) return cls(schema) def get_jsonschema(self): """ Return a copy of the stored jsonschema. """ return deepcopy(self.jsonschema) def get_validation_errors(self, data): """ Validate json data according to the loaded jsonschema and return a list of errors. Return an empty list if data is valid. :param dict data: data to validate. :return: A list of validation errors. For more details about the error format, see: https://python-jsonschema.readthedocs.io/en/latest/errors/#jsonschema.exceptions.ValidationError """ v = self.validator(self.get_jsonschema()) if not v.is_valid(data): error_list = [e for e in v.iter_errors(data)] return error_list return [] def validate_data(self, data, print_errors=False): """ Validate json data according to the loaded jsonschema. :param dict data: the data to validate. :param bool print_errors: If true, will print the errors. :return: True if data format is valid, else False. """ errors_list = self.get_validation_errors(data) if print_errors: for e in errors_list: print(e) return len(errors_list) == 0 def get_file_errors(self, path): """ Get json file errors according to the loaded jsonschema. :param path the file path :return: A list of validation errors. For more details about the error format, see: https://python-jsonschema.readthedocs.io/en/latest/errors/#jsonschema.exceptions.ValidationError """ data = self.load_json(path) return self.get_validation_errors(data) def validate_file(self, path, print_errors=False): """ Validate a json file according to the loaded jsonschema. :param path the file path :param print_errors: If true, will print the errors. :return: True if the data is valid and False if it is not. """ data = self.load_json(path) return self.validate_data(data, print_errors=print_errors) def to_dict_schema(self): """ Transform a jsonschema into a dictionary format :return: The schema dictionary """ return self.to_schema_dict_obj().get_schema() def to_schema_dict_obj(self): """ Returns an DictSchema object equivalent of the jsonschema """ return DictSchema(self.get_jsonschema()) @property def schema_dict(self): return self.to_dict_schema() def to_marshmallow(self): """ Create marshmallow schemas :return: a dict containing the flask marshmallow schemas :rtype: Schema() """ return self.to_schema_dict_obj().to_marshmallow() def export_schema_dict(self, path): """ Print the schema_dict in a json file. :param path: the path where to save the dict.format :return: nothing """ self.save_json(self.to_dict_schema(), path) def draft_schema_from(self, path, save_path=None): """ Create a draft jsonschema from a json file of data. :param path: path to the json file. :param save_path: path where to save the generated schema. :return: the generated schema. """ file = self.load_json(path) builder = SchemaBuilder() builder.add_schema({"type": "object", "properties": {}}) builder.add_object(file) draft_schema = builder.to_json() if save_path is not None: with open(save_path, "w") as outfile: outfile.write(draft_schema) return draft_schema def to_template(self): """ This function assumes certain structure for the jsonschema. For now, three types of tables exist: array of objects, arrays and objects. { table1: [{col1: a, col2: b}, {col1: aa, col2: bb}, ...], table2: [1, 2, 3, ], table3: {config1: a, config2: b}, } """ master_table_name = "_README" type_table_name = "_TYPES" tables = {master_table_name: [], type_table_name: []} # we update the master table of tables: real_props = [ (k, v) for (k, v) in self.jsonschema["properties"].items() if not k.startswith("$") ] for key, value in real_props: tables[master_table_name].append( dict(table=key, description=value.get("description", "")) ) # then we get each table for key, value in real_props: tables[key] = self._get_table(value) # then we get column types example_inv = {1: "integer", "string": "string"} for key, value in real_props: rows = [] if len(tables[key]) > 1: rows = [ dict(table=key, column=v, type="string") for v in ["key", "value"] ] if len(tables[key]) == 1: row1 = tables[key][0] rows = [ dict(table=key, column=k, type=example_inv[v]) for k, v in row1.items() ] tables[type_table_name].extend(rows) return tables @staticmethod def _get_table(contents): example = dict(integer=1, string="string") # several cases here: if contents["type"] == "object": # two columns: key-value in two columns properties = contents["properties"] return [ dict(key=k, value=example[v["type"]]) for k, v in properties.items() ] # we're here, we're probably in an array assert contents["type"] == "array" items = contents["items"] if items["type"] != "object": # only one column with name return [example[items["type"]]] # here is a regular table: props = items["properties"] # if there are array of single values, we flatten them into one column: p_arrays = { k: v["items"] for k, v in props.items() if v["type"] == "array" and v["items"]["type"] != "object" } # if a column is an array of objects: we flatten the object into several columns p_arrays_objects = { "{}.{}".format(k, kk): vv["items"] for k, v in props.items() if v["type"] == "array" and v["items"]["type"] == "object" for kk, vv in v["items"]["properties"].items() } # the rest of columns stay the same p_no_array = {k: v for k, v in props.items() if v["type"] != "array"} props = {**p_arrays, **p_no_array, **p_arrays_objects} required = items["required"] rm_keys = props.keys() - set(required) # order is: first required in order, then the rest: one_line = {k: example[props[k]["type"]] for k in required} for k in rm_keys: one_line[k] = example[props[k]["type"]] return [one_line] @staticmethod def load_json(path): """ Load a json file :param path: the path of the json file.json return the json content. """ return load_json(path) @staticmethod def save_json(data, path): return save_json(data, path) """ Aliases: """ dict_to_flask = to_marshmallow load_schema = from_filepath jsonschema_to_flask = to_marshmallow jsonschema_to_dict = to_dict_schema

0048849928d11e99a79abed4f15fdfd4ce533927

py

Python

src/summary/trigger.py

latonaio/template-matching-summary-server

2f0e792d38f897a08d6f792012dbfdad6d7c695b

2021-09-22T07:17:02.000Z

2021-11-05T01:26:19.000Z

src/summary/trigger.py

latonaio/template-matching-summary-server

2f0e792d38f897a08d6f792012dbfdad6d7c695b

src/summary/trigger.py

latonaio/template-matching-summary-server

2f0e792d38f897a08d6f792012dbfdad6d7c695b

from src import log from src.summary.base import BaseSummary if __name__ == "__main__": import json with open('json/C_TemplateMatchingSummary.json') as f: _dict = json.load(f) dicts = _dict['metadata'][0]['value'] summary = TriggerSummary() should_be_reset = summary.should_be_reset(dicts) log.print(should_be_reset) if should_be_reset: summary.reset() summary.set(dicts) trigger = summary.get_trigger() log.print(trigger) end = summary.get_end() log.print(end) metadata = summary.get_metadata() log.print(metadata) summary.stack()

from src import log from src.summary.base import BaseSummary class TriggerSummary(BaseSummary): def __init__(self): self.vehicle_name = None self.reset() def reset(self): super().reset() return def should_be_reset(self, dicts): new_vehicle_name = None if dicts[0]['templates']: new_vehicle_name = dicts[0]['templates'][0]['vehicle_name'] if (self.vehicle_name or new_vehicle_name) and self.vehicle_name != new_vehicle_name: self.vehicle_name = new_vehicle_name return True return False def get_trigger(self): res = { 'status': False, 'values': [] } if len(self._template_dicts) == 0: return res # status res['status'] = True # values res['values'] = self._template_dicts return res if __name__ == "__main__": import json with open('json/C_TemplateMatchingSummary.json') as f: _dict = json.load(f) dicts = _dict['metadata'][0]['value'] summary = TriggerSummary() should_be_reset = summary.should_be_reset(dicts) log.print(should_be_reset) if should_be_reset: summary.reset() summary.set(dicts) trigger = summary.get_trigger() log.print(trigger) end = summary.get_end() log.print(end) metadata = summary.get_metadata() log.print(metadata) summary.stack()

8ab448056412da458a047ede6337a58d5e53cdfb

py

Python

thrift/protocol/__init__.py

getlove555/getbotline

639e157495849e12ac7dd4bae6012841cf511892

2020-04-30T09:03:36.000Z

2021-02-21T17:45:35.000Z

thrift/protocol/__init__.py

getlove555/getbotline

639e157495849e12ac7dd4bae6012841cf511892

2020-08-01T10:10:14.000Z

2021-01-03T00:55:05.000Z

thrift/protocol/__init__.py

LOUREN03/lourenelle

5448a8634d438f35df98e43ad135f232cf74d2b1

2020-05-11T08:53:30.000Z

2021-07-16T09:50:20.000Z

#LICENCE : http://www.apache.org/licenses/LICENSE-2.0 #CREATOR BY : PRANKBOT #MOD BY ACIL __all__ = ['fastbinary', 'TBase', 'TBinaryProtocol', 'TCompactProtocol', 'TJSONProtocol', 'TProtocol']

#LICENCE : http://www.apache.org/licenses/LICENSE-2.0 #CREATOR BY : PRANKBOT #MOD BY ACIL __all__ = ['fastbinary', 'TBase', 'TBinaryProtocol', 'TCompactProtocol', 'TJSONProtocol', 'TProtocol']

63eaa450af3c58a5dba398f2348a71fa45fd20c0

py

Python

navigation_events.py

gkovacs/invideo-quizzes-analysis-las2016

6ec8686ef0d3ffa5e994f8dec41590fea87e9539

navigation_events.py

gkovacs/invideo-quizzes-analysis-las2016

6ec8686ef0d3ffa5e994f8dec41590fea87e9539

navigation_events.py

gkovacs/invideo-quizzes-analysis-las2016

6ec8686ef0d3ffa5e994f8dec41590fea87e9539

#!/usr/bin/env python # md5: a2cb6a826f222fa843ab488ae8a2de22 # coding: utf-8 import json

#!/usr/bin/env python # md5: a2cb6a826f222fa843ab488ae8a2de22 # coding: utf-8 import json class SeekEvent: def __init__(self, timestamp, start, end, paused, user): self.timestamp = timestamp self.start = start self.end = end self.event_type = 'seeked' self.paused = bool(paused) if self.end >= self.start: self.direction = 'forward' else: self.direction = 'back' self.user = user def __str__(self): return json.dumps(self.__dict__) def __repr__(self): return str(self) class SeekChain: def __init__(self, seek_events): assert len(seek_events) > 0 self.seek_events = seek_events self.start = seek_events[0].start self.end = seek_events[-1].end self.event_type = 'seek_chain' if self.end >= self.start: self.direction = 'forward' else: self.direction = 'back' self.timestamp = seek_events[0].timestamp self.timestamp_end = seek_events[-1].timestamp self.user = seek_events[0].user def __str__(self): output = {} for k,v in self.__dict__.items(): output[k] = v output['seek_events'] = [x.__dict__ for x in output['seek_events']] return json.dumps(output) def __repr__(self): return str(self) class PlayEvent: def __init__(self, timestamp, start, playback_rate): self.timestamp = timestamp self.start = start self.playback_rate = playback_rate self.event_type = 'play' class PlaySpan: def __init__(self, timestamp, timestamp_end, start, end, playback_rate): self.timestamp = timestamp self.timestamp_end = timestamp_end self.start = start self.end = end self.playback_rate = playback_rate self.event_type = 'play_span' if self.timestamp == None: raise DataException('PlaySpan timestamp cannot be None') if self.timestamp_end == None: raise DataException('PlaySpan timestamp_end cannot be None') if self.start == None: raise DataException('PlaySpan start cannot be None') if self.end == None: raise DataException('PlaySpan end cannot be None') if self.playback_rate == None: raise DataException('PlaySpan playback_rate cannot be None') def __str__(self): return '(' + str(self.start) + ', ' + str(self.end) + ')' def __repr__(self): return self.__str__() class PauseEvent: def __init__(self, timestamp, start): self.timestamp = timestamp self.start = start self.event_type = 'pause' class RateChangeEvent: def __init__(self, timestamp, start, playback_rate, paused): self.timestamp = timestamp self.start = start self.playback_rate = playback_rate self.event_type = 'ratechange' self.paused = bool(paused)

9930cfc3b8857f7d8d5760e9dc01072e8dcd4337

py

Python

sketch n draw.py

Ayush2007A/Code-master

fafe4a020adc3f8e78c78f6b8b2b08b5c3005613

2021-02-05T10:29:30.000Z

2021-02-05T10:29:30.000Z

sketch n draw.py

Ayush2007A/Code-master

fafe4a020adc3f8e78c78f6b8b2b08b5c3005613

sketch n draw.py

Ayush2007A/Code-master

fafe4a020adc3f8e78c78f6b8b2b08b5c3005613

import turtle from turtle import Turtle, Screen a = turtle.Turtle() screen = Screen() a.shape('turtle') print('Welcome to sketch n draw') print('select your color 1 and 2') color_1 = (input('color 1: ')) color_2 = (input('color 2: ')) print('ok! your colors are ' + color_1 + (' and ') + color_2) print("changed pad's color according to the requirments") a.color(color_1, color_2) print('So now you can proceed to draw') while 1 == 1: x = (input('enter command: ')) if x == ('For()'): y = int(input('enter the distance: ')) a.forward(y) if x == ('size-pen()'): z = int(input('enter new pensize: ')) a.pensize(z) if x == ('Bac()'): o = int(input('select distance: ')) a.backward(o) if x == ('dir;dig()'): ol = int(input('enter degrees: ')) olv = input('enter direction: ') if olv == ('right'): a.right(ol) if olv == ('left'): a.left(ol) if x == ('set-cor()'): color_1 = (input('color 1: ')) color_2 = (input('color 2: ')) a.color(color_1, color_2) if x == ('"'): import sys sys.exit() if x == ('on-mouse'): print('sketch with mouse enabled, now you can not use any other function') main()

import turtle from turtle import Turtle, Screen a = turtle.Turtle() screen = Screen() a.shape('turtle') print('Welcome to sketch n draw') print('select your color 1 and 2') color_1 = (input('color 1: ')) color_2 = (input('color 2: ')) print('ok! your colors are ' + color_1 + (' and ') + color_2) print("changed pad's color according to the requirments") a.color(color_1, color_2) print('So now you can proceed to draw') while 1 == 1: x = (input('enter command: ')) if x == ('For()'): y = int(input('enter the distance: ')) a.forward(y) if x == ('size-pen()'): z = int(input('enter new pensize: ')) a.pensize(z) if x == ('Bac()'): o = int(input('select distance: ')) a.backward(o) if x == ('dir;dig()'): ol = int(input('enter degrees: ')) olv = input('enter direction: ') if olv == ('right'): a.right(ol) if olv == ('left'): a.left(ol) if x == ('set-cor()'): color_1 = (input('color 1: ')) color_2 = (input('color 2: ')) a.color(color_1, color_2) if x == ('"'): import sys sys.exit() if x == ('on-mouse'): print('sketch with mouse enabled, now you can not use any other function') def drag(x, y): a.ondrag(None) a.setheading(a.towards(x, y)) a.goto(x, y) a.ondrag(drag) def cr(): a.clear() def main(): turtle.listen() a.ondrag(drag) turtle.onscreenclick(cr(), 3) screen.mainloop() main()

0741193fb2dfb937b0530c65ea59f7bbd0aebd09

py

Python

ppln/experiment.py

Mikhail-M/ppln

11bacc40ec6808c0b7bae0f9fb6b36b860294417

ppln/experiment.py

Mikhail-M/ppln

11bacc40ec6808c0b7bae0f9fb6b36b860294417

ppln/experiment.py

Mikhail-M/ppln

11bacc40ec6808c0b7bae0f9fb6b36b860294417

import torch.distributed as dist from torch.utils.data import DataLoader from .data.transforms import make_albumentations from .factory import make_model from .hooks import DistSamplerSeedHook, IterTimerHook, LogBufferHook

import torch.distributed as dist from torch.utils.data import DataLoader from .data.transforms import make_albumentations from .factory import make_model from .hooks import DistSamplerSeedHook, IterTimerHook, LogBufferHook class BaseExperiment: def __init__(self, cfg): self.cfg = cfg self._model = None @property def optimizers(self): raise NotImplementedError @property def model(self): if self._model is None: self._model = make_model(self.cfg.model) return self._model def transform(self, mode): return make_albumentations(self.cfg.transforms[mode]) def dataset(self, mode): raise NotImplementedError def sampler(self, mode, dataset): raise NotImplementedError def dataloader(self, mode): dataset = self.dataset(mode) sampler = self.sampler(mode, dataset) return DataLoader( dataset=dataset, sampler=sampler, batch_size=self.cfg.data.images_per_gpu, num_workers=self.cfg.data.workers_per_gpu, pin_memory=self.cfg.data.pin_memory, drop_last=mode == 'train' ) @property def hooks(self): hooks = self.cfg['hooks'] if dist.is_initialized(): hooks.append(DistSamplerSeedHook()) return self.cfg['hooks'] + [IterTimerHook(), LogBufferHook()] @property def work_dir(self): return self.cfg.work_dir

48c7bf8eab29ebaf195b176af688e2d1694ca5d3

py

Python

backend_server/tests/test_pybackend_urilib.py

ismir-net/open-eval

ebb4612ff5a6c6f7b6fbc908d837857f8377d95a

2016-08-09T18:34:18.000Z

2016-08-12T01:58:05.000Z

backend_server/tests/test_pybackend_urilib.py

cosmir/openmic-annotator

ebb4612ff5a6c6f7b6fbc908d837857f8377d95a

2016-08-13T14:35:00.000Z

2016-08-13T14:37:25.000Z

backend_server/tests/test_pybackend_urilib.py

ismir-net/open-eval

ebb4612ff5a6c6f7b6fbc908d837857f8377d95a

import pytest import pybackend.urilib as U

import pytest import pybackend.urilib as U def test_validate(): U.validate("x:y") with pytest.raises(ValueError): U.validate(":x") with pytest.raises(ValueError): U.validate("y:") with pytest.raises(ValueError): U.validate(":") with pytest.raises(ValueError): U.validate("x:x:y") def test_split(): assert U.split("x:y") == ("x", "y") with pytest.raises(ValueError): U.split(":x") def test_join(): assert U.join("x", "y") == "x:y" with pytest.raises(ValueError): U.join("x") with pytest.raises(ValueError): U.join("x", "y", "z") with pytest.raises(ValueError): U.join(":x", "y")

60bade3775753250997ff137e10f278ae7d7d12a

py

Python

examples/slit_channel.py

cwaluga/singularities_dolfin

dd379f71f384717a63906fd701df542a1603b03b

examples/slit_channel.py

cwaluga/singularities_dolfin

dd379f71f384717a63906fd701df542a1603b03b

examples/slit_channel.py

cwaluga/singularities_dolfin

dd379f71f384717a63906fd701df542a1603b03b

#! /usr/bin/env python # coding=utf-8 """ Example from the paper Rüde/Waluga/Wohlmuth 2013 """ __author__ = "Christian Waluga (waluga@ma.tum.de)" __copyright__ = "Copyright (c) 2013 %s" % __author__ from dolfin import * from energy_correction.correction import * from energy_correction.meshtools import * from energy_correction.singular import * from energy_correction.extrapolate import * import math set_log_level(ERROR) # convergence rates # boundary definition for error if __name__ == '__main__': # main program parameters["allow_extrapolation"] = True maxlevel = 7 # maximum level (this is where 'exact' solution is computed) compute = False # does the 'exact' solution need to be computed? gzip = True # gzip the 'exact' solution once computed and saved? correct = False # do we want energy-correction mesh_filename = 'meshes/slit-channel-crossed.xml.gz' cachedgamma = False # use cached values of gamma or recompute with method specified below? method = 'one-level-inexact' #method = 'two-level-inexact' # beyond the L-shape, we have to symmetrize if we want to use only one correction per corner. # (set to 2pi if the mesh is already symmetric at the corners) symmetrization_threshold = 2.0*pi output_weight = False # output the weighting function to VTK? # find reentrant corners mesh, corners, angles, corner_meshes \ = generate_corner_info(Mesh(mesh_filename), symmetrization_threshold) weight = WeightingFunction(corners, angles, 4.0) #plot(mesh); interactive() gammas_cached = [0.27914627419934601, 0.27914440403310525, 0.27916755164797358, 0.27912214602624991, 0.27908848023107002, 0.27915828177500074, 0.2791861111329178] if correct: if cachedgamma: print 'using cached gammas' gammas = gammas_cached else: print 'computing gammas' funcs = [ math.cos for c in corners ] # all Neumann gammas = extrapolate_gammas(corners, angles, corner_meshes, method = method, \ start_at = maxlevel, extrapolation = 'richardson', \ maxlevel = maxlevel+2, funcs = funcs)[0] else: gammas = [0.0 for i in range(len(corners))] print 'gammas =', gammas # generate series of refined meshes print 'generating meshes' meshes = [ mesh ] for i in xrange(maxlevel): meshes.append(refine(meshes[-1])) if output_weight: File('output/weight.pvd') << interpolate(weight, FunctionSpace(meshes[3], 'Lagrange', 1)) filename = 'output/uh_fine_{0}'.format(maxlevel) if compute: print 'computing fine solution' if not correct: print 'warning: computing fine solution without correction' uh_fine = solve_problem(meshes[-1], corners, gammas) File(filename + '.xml') << uh_fine File(filename + '.pvd') << uh_fine if gzip: from subprocess import call call(['gzip', '-f', filename + '.xml']) else: print 'loading fine solution' V_fine = FunctionSpace(meshes[-1], 'Lagrange', 1) uh_fine = Function(V_fine, filename + '.xml.gz' if gzip else '') errors = [] print 'solving' # perform a convergence study for i, mesh in enumerate(meshes[:-2]): uh = solve_problem(mesh, corners, gammas) intorder, intmesh = 1, meshes[i+2] U = project(uh_fine, FunctionSpace(intmesh, 'Lagrange', intorder)) File('output/uh-{0}.pvd'.format(i)) << uh right_boundary = RightBoundary() boundaries = FacetFunction("size_t", intmesh) boundaries.set_all(0) right_boundary.mark(boundaries, 1) dG = Measure("ds")[boundaries] #h = CellSize(mesh) h = Constant(mesh.hmin()) # compute errors between current level and highest level solutions err1 = sqrt(assemble((uh - U)**2*dx, mesh = intmesh)) err2 = sqrt(assemble(weight*(uh - U)**2*dx, mesh = intmesh)) #err2 = sqrt(assemble(h*(Dn(uh) - Dn(U))**2*dG(1), mesh = intmesh)) errors.append((err1, err2)) print_rates(errors)

#! /usr/bin/env python # coding=utf-8 """ Example from the paper Rüde/Waluga/Wohlmuth 2013 """ __author__ = "Christian Waluga (waluga@ma.tum.de)" __copyright__ = "Copyright (c) 2013 %s" % __author__ from dolfin import * from energy_correction.correction import * from energy_correction.meshtools import * from energy_correction.singular import * from energy_correction.extrapolate import * import math set_log_level(ERROR) def solve_problem(mesh, corners, gammas): # right hand side f = Constant(0.0) # correct coefficient V0 = FunctionSpace(mesh, 'DG', 0) k = interpolate(Constant(1.0), V0) k = correct_corner_stiffness(k, mesh, corners, gammas) #plot(k) # variational form V = FunctionSpace(mesh, 'Lagrange', 1) u = TrialFunction(V) v = TestFunction(V) a = k*inner(grad(u), grad(v))*dx L = f*v*dx # boundary conditions #bcs = [ DirichletBC(V, Expression('1.0', c = 0.25), 'on_boundary && (x[0] == -2.0)'), \ # DirichletBC(V, Expression('0.0', c = 0.25), 'on_boundary && (x[0] == +2.0)') ] bcs = [ DirichletBC(V, Expression('1.0+c*cos(pi*x[1])', c = 0.25), 'on_boundary && (x[0] == -2.0)'), \ DirichletBC(V, Expression('0.0+c*cos(pi*x[1])', c = 0.25), 'on_boundary && (x[0] == +2.0)') ] # solve the variational problem uh = Function(V) print 'problem size:', V.dim() solver_parameters = { \ "linear_solver": "bicgstab", \ "preconditioner": "petsc_amg" } solve(a == L, uh, bcs, solver_parameters = solver_parameters) return uh # convergence rates def print_rates(E): from math import log as lg print '%.4e - %.4e - ' \ %(E[0][0], E[0][1]) for i in range(1, len(E)): r1 = lg(E[i-1][0]/E[i][0], 2) r2 = lg(E[i-1][1]/E[i][1], 2) print '%.4e %.2f %.4e %.2f' \ %(E[i][0], r1, E[i][1], r2) print '\n' # boundary definition for error class RightBoundary(SubDomain): def inside(self, x, on_boundary): return on_boundary and near(x[0], 2.0) if __name__ == '__main__': # main program parameters["allow_extrapolation"] = True maxlevel = 7 # maximum level (this is where 'exact' solution is computed) compute = False # does the 'exact' solution need to be computed? gzip = True # gzip the 'exact' solution once computed and saved? correct = False # do we want energy-correction mesh_filename = 'meshes/slit-channel-crossed.xml.gz' cachedgamma = False # use cached values of gamma or recompute with method specified below? method = 'one-level-inexact' #method = 'two-level-inexact' # beyond the L-shape, we have to symmetrize if we want to use only one correction per corner. # (set to 2pi if the mesh is already symmetric at the corners) symmetrization_threshold = 2.0*pi output_weight = False # output the weighting function to VTK? # find reentrant corners mesh, corners, angles, corner_meshes \ = generate_corner_info(Mesh(mesh_filename), symmetrization_threshold) weight = WeightingFunction(corners, angles, 4.0) #plot(mesh); interactive() gammas_cached = [0.27914627419934601, 0.27914440403310525, 0.27916755164797358, 0.27912214602624991, 0.27908848023107002, 0.27915828177500074, 0.2791861111329178] if correct: if cachedgamma: print 'using cached gammas' gammas = gammas_cached else: print 'computing gammas' funcs = [ math.cos for c in corners ] # all Neumann gammas = extrapolate_gammas(corners, angles, corner_meshes, method = method, \ start_at = maxlevel, extrapolation = 'richardson', \ maxlevel = maxlevel+2, funcs = funcs)[0] else: gammas = [0.0 for i in range(len(corners))] print 'gammas =', gammas # generate series of refined meshes print 'generating meshes' meshes = [ mesh ] for i in xrange(maxlevel): meshes.append(refine(meshes[-1])) if output_weight: File('output/weight.pvd') << interpolate(weight, FunctionSpace(meshes[3], 'Lagrange', 1)) filename = 'output/uh_fine_{0}'.format(maxlevel) if compute: print 'computing fine solution' if not correct: print 'warning: computing fine solution without correction' uh_fine = solve_problem(meshes[-1], corners, gammas) File(filename + '.xml') << uh_fine File(filename + '.pvd') << uh_fine if gzip: from subprocess import call call(['gzip', '-f', filename + '.xml']) else: print 'loading fine solution' V_fine = FunctionSpace(meshes[-1], 'Lagrange', 1) uh_fine = Function(V_fine, filename + '.xml.gz' if gzip else '') errors = [] print 'solving' # perform a convergence study for i, mesh in enumerate(meshes[:-2]): uh = solve_problem(mesh, corners, gammas) intorder, intmesh = 1, meshes[i+2] U = project(uh_fine, FunctionSpace(intmesh, 'Lagrange', intorder)) File('output/uh-{0}.pvd'.format(i)) << uh right_boundary = RightBoundary() boundaries = FacetFunction("size_t", intmesh) boundaries.set_all(0) right_boundary.mark(boundaries, 1) dG = Measure("ds")[boundaries] #h = CellSize(mesh) h = Constant(mesh.hmin()) # compute errors between current level and highest level solutions err1 = sqrt(assemble((uh - U)**2*dx, mesh = intmesh)) err2 = sqrt(assemble(weight*(uh - U)**2*dx, mesh = intmesh)) #err2 = sqrt(assemble(h*(Dn(uh) - Dn(U))**2*dG(1), mesh = intmesh)) errors.append((err1, err2)) print_rates(errors)

a7c5fe548eda7fb588f956399f68c6d16da1faec

py

Python

ca_on_wellesley/people.py

dcycle/scrapers-ca

4c7a6cd01d603221b5b3b7a400d2e5ca0c6e916f

2015-05-26T03:18:50.000Z

2022-01-31T03:27:41.000Z

ca_on_wellesley/people.py

dcycle/scrapers-ca

4c7a6cd01d603221b5b3b7a400d2e5ca0c6e916f

2015-01-09T06:09:35.000Z

2022-01-20T23:05:05.000Z

ca_on_wellesley/people.py

dcycle/scrapers-ca

4c7a6cd01d603221b5b3b7a400d2e5ca0c6e916f

2015-11-23T05:00:10.000Z

2021-09-15T16:03:33.000Z

from utils import CanadianScraper, CanadianPerson as Person import re COUNCIL_PAGE = 'http://www.wellesley.ca/council/councillors/?q=council/councillors'

from utils import CanadianScraper, CanadianPerson as Person import re COUNCIL_PAGE = 'http://www.wellesley.ca/council/councillors/?q=council/councillors' def post_number(name): return { 'Ward One': 'Ward 1', 'Ward Two': 'Ward 2', 'Ward Three': 'Ward 3', 'Ward Four': 'Ward 4' }[name] class WellesleyPersonScraper(CanadianScraper): def scrape(self): page = self.lxmlize(COUNCIL_PAGE) members = [el for el in page.xpath('//div[@id="printAreaContent"]//td') if el.text_content().strip().lower().split()[0] in ["mayor", "councillor"]][1:] assert len(members) == 5 for member in members: position = member.text_content().split()[0] srch = re.search(r'\w+(.+?) is.*? for (.+?)\.', member.text_content().strip()) name = srch.group(1).strip() district = srch.group(2).strip() phone = self.get_phone(member) if position == "Mayor": district = "Wellesley" else: district = post_number(district) p = Person(primary_org='legislature', name=name, district=district, role=position) p.add_contact('voice', phone, 'legislature') p.add_source(COUNCIL_PAGE) yield p

fb53dcf3b5f85da5350281d96e99a77c6877114e

py

Python

api/client/src/test/test_update_cluster_bad_request_exception_response_content.py

maclema/aws-parallelcluster

ade6e5e76201ee43c6e222fcd1c2891aba938838

2018-11-13T15:02:15.000Z

2022-03-31T15:26:06.000Z

api/client/src/test/test_update_cluster_bad_request_exception_response_content.py

maclema/aws-parallelcluster

ade6e5e76201ee43c6e222fcd1c2891aba938838

2018-11-13T16:16:27.000Z

2022-03-31T13:57:10.000Z

api/client/src/test/test_update_cluster_bad_request_exception_response_content.py

yuleiwan/aws-parallelcluster

aad2a3019ef4ad08d702f5acf41b152b3f7a0b46

2018-11-14T22:47:46.000Z

2022-03-22T11:33:22.000Z

""" ParallelCluster ParallelCluster API # noqa: E501 The version of the OpenAPI document: 3.0.0 Generated by: https://openapi-generator.tech """ import sys import unittest import pcluster.client from pcluster.client.model.change import Change from pcluster.client.model.config_validation_message import ConfigValidationMessage from pcluster.client.model.update_error import UpdateError globals()['Change'] = Change globals()['ConfigValidationMessage'] = ConfigValidationMessage globals()['UpdateError'] = UpdateError from pcluster.client.model.update_cluster_bad_request_exception_response_content import UpdateClusterBadRequestExceptionResponseContent class TestUpdateClusterBadRequestExceptionResponseContent(unittest.TestCase): """UpdateClusterBadRequestExceptionResponseContent unit test stubs""" def testUpdateClusterBadRequestExceptionResponseContent(self): """Test UpdateClusterBadRequestExceptionResponseContent""" # FIXME: construct object with mandatory attributes with example values # model = UpdateClusterBadRequestExceptionResponseContent() # noqa: E501 pass if __name__ == '__main__': unittest.main()

""" ParallelCluster ParallelCluster API # noqa: E501 The version of the OpenAPI document: 3.0.0 Generated by: https://openapi-generator.tech """ import sys import unittest import pcluster.client from pcluster.client.model.change import Change from pcluster.client.model.config_validation_message import ConfigValidationMessage from pcluster.client.model.update_error import UpdateError globals()['Change'] = Change globals()['ConfigValidationMessage'] = ConfigValidationMessage globals()['UpdateError'] = UpdateError from pcluster.client.model.update_cluster_bad_request_exception_response_content import UpdateClusterBadRequestExceptionResponseContent class TestUpdateClusterBadRequestExceptionResponseContent(unittest.TestCase): """UpdateClusterBadRequestExceptionResponseContent unit test stubs""" def setUp(self): pass def tearDown(self): pass def testUpdateClusterBadRequestExceptionResponseContent(self): """Test UpdateClusterBadRequestExceptionResponseContent""" # FIXME: construct object with mandatory attributes with example values # model = UpdateClusterBadRequestExceptionResponseContent() # noqa: E501 pass if __name__ == '__main__': unittest.main()

87793261619b7cb430625fdd5dd5441808c7b619

py

Python

qiskit/providers/aer/pulse/de_solvers/pulse_de_solver.py

SooluThomas/qiskit-aer

1602b1cc35a18f5a008c38433f607c7ad0870ce9

2019-05-19T10:30:03.000Z

2019-05-19T10:30:03.000Z

qiskit/providers/aer/pulse/de_solvers/pulse_de_solver.py

stefan-woerner/qiskit-aer

cef92153dad6e9acded627b2e3cb10c5a1d7851a

qiskit/providers/aer/pulse/de_solvers/pulse_de_solver.py

stefan-woerner/qiskit-aer

cef92153dad6e9acded627b2e3cb10c5a1d7851a

# -*- coding: utf-8 -*- # This code is part of Qiskit. # # (C) Copyright IBM 2018, 2019, 2020. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory # of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. # # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. # This file is part of QuTiP: Quantum Toolbox in Python. # # Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. # All rights reserved. # pylint: disable=no-value-for-parameter, invalid-name, import-error """Pulse DE solver for problems in qutip format.""" import numpy as np from scipy.integrate import ode from scipy.integrate._ode import zvode # pylint: disable=no-name-in-module from .pulse_utils import td_ode_rhs_static def construct_pulse_zvode_solver(exp, op_system): """ Constructs a scipy ODE solver for a given exp and op_system Parameters: exp (dict): dict containing experimental op_system (PulseSimDescription): container for simulation information Returns: ode: scipy ode """ # extract relevant data from op_system global_data = op_system.global_data ode_options = op_system.ode_options channels = dict(op_system.channels) # Init register register = np.ones(global_data['n_registers'], dtype=np.uint8) ODE = ode(td_ode_rhs_static) ODE.set_f_params(global_data, exp, op_system.system, channels, register) ODE._integrator = qiskit_zvode(method=ode_options.method, order=ode_options.order, atol=ode_options.atol, rtol=ode_options.rtol, nsteps=ode_options.nsteps, first_step=ode_options.first_step, min_step=ode_options.min_step, max_step=ode_options.max_step ) # Forces complex ODE solving if not ODE._y: ODE.t = 0.0 ODE._y = np.array([0.0], complex) ODE._integrator.reset(len(ODE._y), ODE.jac is not None) # Since all experiments are defined to start at zero time. ODE.set_initial_value(global_data['initial_state'], 0) return ODE class qiskit_zvode(zvode): """Modifies the stepper for ZVODE so that it always stops at a given time in tlist; by default, it over shoots the time. """

# -*- coding: utf-8 -*- # This code is part of Qiskit. # # (C) Copyright IBM 2018, 2019, 2020. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory # of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. # # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. # This file is part of QuTiP: Quantum Toolbox in Python. # # Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. # All rights reserved. # pylint: disable=no-value-for-parameter, invalid-name, import-error """Pulse DE solver for problems in qutip format.""" import numpy as np from scipy.integrate import ode from scipy.integrate._ode import zvode # pylint: disable=no-name-in-module from .pulse_utils import td_ode_rhs_static def construct_pulse_zvode_solver(exp, op_system): """ Constructs a scipy ODE solver for a given exp and op_system Parameters: exp (dict): dict containing experimental op_system (PulseSimDescription): container for simulation information Returns: ode: scipy ode """ # extract relevant data from op_system global_data = op_system.global_data ode_options = op_system.ode_options channels = dict(op_system.channels) # Init register register = np.ones(global_data['n_registers'], dtype=np.uint8) ODE = ode(td_ode_rhs_static) ODE.set_f_params(global_data, exp, op_system.system, channels, register) ODE._integrator = qiskit_zvode(method=ode_options.method, order=ode_options.order, atol=ode_options.atol, rtol=ode_options.rtol, nsteps=ode_options.nsteps, first_step=ode_options.first_step, min_step=ode_options.min_step, max_step=ode_options.max_step ) # Forces complex ODE solving if not ODE._y: ODE.t = 0.0 ODE._y = np.array([0.0], complex) ODE._integrator.reset(len(ODE._y), ODE.jac is not None) # Since all experiments are defined to start at zero time. ODE.set_initial_value(global_data['initial_state'], 0) return ODE class qiskit_zvode(zvode): """Modifies the stepper for ZVODE so that it always stops at a given time in tlist; by default, it over shoots the time. """ def step(self, *args): itask = self.call_args[2] self.rwork[0] = args[4] self.call_args[2] = 5 r = self.run(*args) self.call_args[2] = itask return r

8424167fac0970dd1983c3a928d7777a5ac90453

py

Python

TEST/RPLCD_CharLCD.py

sireline/raspi

f3f1879d3c8cc4e702b8f0f7c5fcc4d9bf5901c1

TEST/RPLCD_CharLCD.py

sireline/raspi

f3f1879d3c8cc4e702b8f0f7c5fcc4d9bf5901c1

2019-03-14T11:42:15.000Z

2019-03-14T11:42:15.000Z

TEST/RPLCD_CharLCD.py

sireline/raspi

f3f1879d3c8cc4e702b8f0f7c5fcc4d9bf5901c1

from RPLCD import CharLCD import RPi.GPIO as GPIO lcd = CharLCD(numbering_mode=GPIO.BOARD, cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23]) lcd.write_string(u'Hello World')

from RPLCD import CharLCD import RPi.GPIO as GPIO lcd = CharLCD(numbering_mode=GPIO.BOARD, cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23]) lcd.write_string(u'Hello World')

30ac7343bb8e51ff66295aa68294f848fe139c9b

py

Python

indicators/tests/iptt_tests/indicator_report_data_queries.py

mercycorps/toladata

4d5f9b45905a81af9981b586690e020d5b3bfc60

indicators/tests/iptt_tests/indicator_report_data_queries.py

mercycorps/toladata

4d5f9b45905a81af9981b586690e020d5b3bfc60

2020-03-31T15:46:59.000Z

2022-03-31T18:01:08.000Z

indicators/tests/iptt_tests/indicator_report_data_queries.py

mercycorps/toladata

4d5f9b45905a81af9981b586690e020d5b3bfc60

2021-01-05T01:58:24.000Z

2021-01-05T01:58:24.000Z

"""Tests for the IPTT Report Data Indicators (TP/TVA) to ensure their query counts stay O(n) and not O(n^2) - api_report_data takes program_pk and frequency, calls IPTT<TVA/TP>ReportIndicatorSerializer.load_report - IPTT<TVA/TP>ReportIndicatorSerializer.load_report takes program_pk and frequency - queries for program data (start/end dates) - queries for disaggregations data ?? - calls IPTTIndicator.tva/timperiods - IPTTIndicator - get queryset adds prefetch - with_annotations adds lop_target lop_actual, lop_percent_met, and old_level if necessary - with_disaggaggregation_annotations takes disaggregation_category_pks and adds lop_actual for each - with_frequency_annotations takes freq, start, end, and disaggregation_category_pks and adds frequency_disaggregation_actual for each disaggregation and overall frequency actual (if TVA also adds overall frequency target and percent met) """ from django import test from indicators.models import Indicator, PeriodicTarget from indicators.queries.iptt_queries import IPTTIndicator from factories import ( indicators_models as i_factories, workflow_models as w_factories ) QUERIES_PREFETCH = 8 QUERIES_FREQUENCIES = QUERIES_PREFETCH + 0 QUERIES_DISAGG_FREQUENCIES = QUERIES_FREQUENCIES + 0 TP_QUERYSET = IPTTIndicator.timeperiods TVA_QUERYSET = IPTTIndicator.tva

"""Tests for the IPTT Report Data Indicators (TP/TVA) to ensure their query counts stay O(n) and not O(n^2) - api_report_data takes program_pk and frequency, calls IPTT<TVA/TP>ReportIndicatorSerializer.load_report - IPTT<TVA/TP>ReportIndicatorSerializer.load_report takes program_pk and frequency - queries for program data (start/end dates) - queries for disaggregations data ?? - calls IPTTIndicator.tva/timperiods - IPTTIndicator - get queryset adds prefetch - with_annotations adds lop_target lop_actual, lop_percent_met, and old_level if necessary - with_disaggaggregation_annotations takes disaggregation_category_pks and adds lop_actual for each - with_frequency_annotations takes freq, start, end, and disaggregation_category_pks and adds frequency_disaggregation_actual for each disaggregation and overall frequency actual (if TVA also adds overall frequency target and percent met) """ from django import test from indicators.models import Indicator, PeriodicTarget from indicators.queries.iptt_queries import IPTTIndicator from factories import ( indicators_models as i_factories, workflow_models as w_factories ) QUERIES_PREFETCH = 8 QUERIES_FREQUENCIES = QUERIES_PREFETCH + 0 QUERIES_DISAGG_FREQUENCIES = QUERIES_FREQUENCIES + 0 TP_QUERYSET = IPTTIndicator.timeperiods TVA_QUERYSET = IPTTIndicator.tva class TestIPTTIndicatorQuerysetPrefetch(test.TestCase): @classmethod def setUpClass(cls): super().setUpClass() cls.standard_disagg = i_factories.DisaggregationTypeFactory( standard=True, country=None, disaggregation_type="Test Standard Disagg", labels=["Test SD Label {}".format(c+1) for c in range(5)] ) cls.country = w_factories.CountryFactory(country="TestLand", code="TL") cls.country_disagg = i_factories.DisaggregationTypeFactory( standard=False, country=cls.country, disaggregation_type="Test Country Disagg", labels=["Test CD Label {}".format(c+1) for c in range(5)] ) cls.category_pks = [ label.pk for disagg in [cls.standard_disagg, cls.country_disagg] for label in disagg.labels ] cls.program = w_factories.RFProgramFactory() cls.program.country.set([cls.country]) cls.periods = {} for frequency in Indicator.REGULAR_TARGET_FREQUENCIES: cls.periods[frequency] = [p for p in PeriodicTarget.generate_for_frequency(frequency)( cls.program.reporting_period_start, cls.program.reporting_period_end )] cls.indicators = [] cls.results = [] cls.disaggs = [] for frequency, _ in Indicator.TARGET_FREQUENCIES[:-1]: indicator = i_factories.RFIndicatorFactory( program=cls.program, target_frequency=frequency, targets=1000, results=True ) indicator.disaggregation.set([cls.standard_disagg, cls.country_disagg]) results = 0 disaggs = 0 for result in indicator.result_set.all(): results += result.achieved disaggs += 2 for label in [label for disagg in indicator.disaggregation.all() for label in disagg.labels]: i_factories.DisaggregatedValueFactory( result=result, category=label, value=2 ) cls.indicators.append(indicator) cls.results.append(results) cls.disaggs.append(disaggs) cls.period_results = [ [], [], [], [[], [10,], [20,], [10,], [20,], [30,], [40,], [120,]], [[], [10, None], [20, None], [10, None], [10, 10], [20, 10], [20, 20], [60, 60]], [[], [10, None, None], [20, None, None], [10, None, None], [10, 10, None], [10, 10, 10], [20, 10, 10], [40, 40, 40]] ] def test_indicator_queryset_queries_one_indicator(self): filters = {'pk': self.indicators[0].pk} for queryset in [TP_QUERYSET, TVA_QUERYSET]: with self.assertNumQueries(QUERIES_PREFETCH): indicator = queryset.filter(**filters).first() # has rf marked self.assertTrue(indicator.using_results_framework) self.assertEqual(indicator.lop_target_calculated, 1000) self.assertEqual(indicator.lop_actual, self.results[0]) self.assertAlmostEqual(indicator.lop_percent_met, float(self.results[0])/1000) self.assertCountEqual(indicator.disaggregation_category_pks, self.category_pks) for queryset in [TP_QUERYSET, TVA_QUERYSET]: with self.assertNumQueries(QUERIES_PREFETCH): indicator = queryset.filter(**filters).with_disaggregation_lop_annotations(self.category_pks).first() for category_pk in self.category_pks: self.assertEqual( getattr(indicator, f'disaggregation_{category_pk}_lop_actual'), self.disaggs[0] ) for frequency in Indicator.REGULAR_TARGET_FREQUENCIES: period_count = len(self.periods[frequency]) with self.assertNumQueries(QUERIES_FREQUENCIES): indicator = TP_QUERYSET.filter(**filters).with_disaggregation_lop_annotations( self.category_pks ).with_frequency_annotations( frequency, self.program.reporting_period_start, self.program.reporting_period_end, ).first() self.assertEqual(getattr(indicator, f'frequency_{frequency}_count'), period_count) for c in range(period_count): self.assertEqual( getattr(indicator, f'frequency_{frequency}_period_{c}'), 10 if c == 0 else None ) with self.assertNumQueries(QUERIES_DISAGG_FREQUENCIES): indicator = TP_QUERYSET.filter(**filters).with_disaggregation_lop_annotations( self.category_pks ).with_frequency_annotations( frequency, self.program.reporting_period_start, self.program.reporting_period_end ).with_disaggregation_frequency_annotations( frequency, self.program.reporting_period_start, self.program.reporting_period_end, disaggregations=self.category_pks ).first() for c in range(period_count): for category_pk in self.category_pks: self.assertEqual( getattr(indicator, f'disaggregation_{category_pk}_frequency_{frequency}_period_{c}'), 2 if c == 0 else None ) def test_indicator_queryset_queries_two_indicators(self): filters = {'pk__in': [self.indicators[0].pk, self.indicators[1].pk]} for queryset in [TP_QUERYSET, TVA_QUERYSET]: with self.assertNumQueries(QUERIES_PREFETCH): indicators = [indicator for indicator in queryset.filter(**filters)] for c, indicator in enumerate(indicators): self.assertTrue(indicator.using_results_framework) self.assertEqual(indicator.lop_target_calculated, 1000) self.assertEqual(indicator.lop_actual, self.results[c]) self.assertAlmostEqual(indicator.lop_percent_met, float(self.results[c])/1000) self.assertCountEqual(indicator.disaggregation_category_pks, self.category_pks) with self.assertNumQueries(QUERIES_PREFETCH): indicators = [indicator for indicator in queryset.filter( **filters ).with_disaggregation_lop_annotations(self.category_pks)] for c, indicator in enumerate(indicators): for category_pk in self.category_pks: self.assertEqual( getattr(indicator, 'disaggregation_{}_lop_actual'.format(category_pk)), self.disaggs[c] ) for frequency in Indicator.REGULAR_TARGET_FREQUENCIES: period_count = len(self.periods[frequency]) with self.assertNumQueries(QUERIES_FREQUENCIES): indicators = [indicator for indicator in TP_QUERYSET.filter( **filters ).with_disaggregation_lop_annotations(self.category_pks).with_frequency_annotations( frequency, self.program.reporting_period_start, self.program.reporting_period_end, )] for indicator in indicators: self.assertEqual(getattr(indicator, 'frequency_{}_count'.format(frequency)), period_count) for c in range(period_count): achieved = getattr(indicator, 'frequency_{}_period_{}'.format(frequency, c)) if frequency in [1, 2, 3, 4, 5]: self.assertEqual( achieved, self.period_results[frequency][indicator.target_frequency][c] ) with self.assertNumQueries(QUERIES_DISAGG_FREQUENCIES): indicators = [ indicator for indicator in TP_QUERYSET.filter(**filters).with_disaggregation_lop_annotations( self.category_pks ).with_frequency_annotations( frequency, self.program.reporting_period_start, self.program.reporting_period_end ).with_disaggregation_frequency_annotations( frequency, self.program.reporting_period_start, self.program.reporting_period_end, disaggregations=self.category_pks )] for indicator in indicators: for c in range(period_count): for category_pk in self.category_pks: d_value = getattr( indicator, f'disaggregation_{category_pk}_frequency_{frequency}_period_{c}' ) if frequency in [1, 2, 3, 4, 5]: expected = self.period_results[frequency][indicator.target_frequency][c] if expected is not None: expected = expected/5 self.assertEqual( d_value, expected ) def test_indicator_queryset_queries_multiple_indicators(self): filters = {'program': self.program} for queryset in [TP_QUERYSET, TVA_QUERYSET]: with self.assertNumQueries(QUERIES_PREFETCH): indicators = [indicator for indicator in queryset.filter(**filters)] for c, indicator in enumerate(indicators): self.assertTrue(indicator.using_results_framework) self.assertEqual(indicator.lop_target_calculated, 1000) self.assertEqual(indicator.lop_actual, self.results[c]) self.assertAlmostEqual(indicator.lop_percent_met, float(self.results[c])/1000) self.assertCountEqual(indicator.disaggregation_category_pks, self.category_pks) with self.assertNumQueries(QUERIES_PREFETCH): indicators = [ indicator for indicator in queryset.filter( **filters ).with_disaggregation_lop_annotations(self.category_pks)] for c, indicator in enumerate(indicators): for category_pk in self.category_pks: self.assertEqual( getattr(indicator, 'disaggregation_{}_lop_actual'.format(category_pk)), self.disaggs[c] ) for frequency in Indicator.REGULAR_TARGET_FREQUENCIES: period_count = len(self.periods[frequency]) with self.assertNumQueries(QUERIES_FREQUENCIES): indicators = [indicator for indicator in TP_QUERYSET.filter( **filters ).with_disaggregation_lop_annotations(self.category_pks).with_frequency_annotations( frequency, self.program.reporting_period_start, self.program.reporting_period_end )] for indicator in indicators: self.assertEqual(getattr(indicator, 'frequency_{}_count'.format(frequency)), period_count) for c in range(period_count): achieved = getattr(indicator, 'frequency_{}_period_{}'.format(frequency, c)) if frequency in [1, 2, 3, 4, 5]: self.assertEqual( achieved, self.period_results[frequency][indicator.target_frequency][c] ) with self.assertNumQueries(QUERIES_DISAGG_FREQUENCIES): indicators = [indicator for indicator in TP_QUERYSET.filter( **filters ).with_disaggregation_lop_annotations( self.category_pks ).with_frequency_annotations( frequency, self.program.reporting_period_start, self.program.reporting_period_end ).with_disaggregation_frequency_annotations( frequency, self.program.reporting_period_start, self.program.reporting_period_end, disaggregations=self.category_pks )] for indicator in indicators: for c in range(period_count): for category_pk in self.category_pks: d_value = getattr( indicator, f'disaggregation_{category_pk}_frequency_{frequency}_period_{c}' ) if frequency in [1, 2, 3, 4, 5]: expected = self.period_results[frequency][indicator.target_frequency][c] if expected is not None: expected = expected/5 self.assertEqual( d_value, expected )

5dfc3ef0fa75c74b1c61d2f529a6109260b3259f

py

Python

MAOL/personal_list/models.py

noxlock/my-anime-openings-list

4ab7660f226af5f06b941c657b8ff611ec8c63bc

MAOL/personal_list/models.py

noxlock/my-anime-openings-list

4ab7660f226af5f06b941c657b8ff611ec8c63bc

2021-12-31T07:56:10.000Z

2021-12-31T09:43:27.000Z

MAOL/personal_list/models.py

noxlock/my-anime-openings-list

4ab7660f226af5f06b941c657b8ff611ec8c63bc

from django.db import models from django.db.models.signals import post_save from django.contrib.auth.models import User from django.core.validators import MaxValueValidator from imagekit.models import ProcessedImageField from imagekit.processors import ResizeToFill from home.models import ModelAbstract, Song class Profile(ModelAbstract): """ A user's profile. Data like profile picture/banner is stored here, but also anything else that should probably be extending the default User model. It takes hard work to set a custom User model once you've already started a project, and most of the things I want would fit nicely in a model like this anyways. """ user = models.OneToOneField(User, on_delete=models.CASCADE) avatar = ProcessedImageField( upload_to='avatars', default='avatars/placeholder.png', processors=[ResizeToFill(256, 256)], format="PNG" ) banner = ProcessedImageField( upload_to='banners', default='banners/placeholder.png', processors=[ResizeToFill(1300, 400)], format="PNG" ) # def get_recent_ratings(self, limit=20): # """ # Get the user's recently rated songs. # @limit: How many songs to get # """ # ratings = self.user.songlist.songrating_set.all() # songs = Song.objects.filter(songrating__in=ratings).values('video_link', 'anime__cover', 'pk').order_by( # '-songrating__last_modified')[:limit] # return songs def get_top_ratings(self, limit=20): """ Get the user's recently rated songs. Gets very little details, mainly just used for carousels. @limit: How many songs to get (default 20) """ # Grab all the user's ratings ratings = self.user.songlist.songrating_set.all() # Filter through the highest rated, and then most recently rated songs rated by the user. songs = Song.objects.filter(songrating__in=ratings).values('video_link', 'anime__cover', 'pk').order_by( '-songrating__rating', 'songrating__last_modified')[:limit] return songs def get_rated_songs(self, limit=None): """ Grab all songs that a User has rated. Used for the user's list. @limit: How many songs to get """ # Grab all the user's SongRatings, along with details about the song. ratings = SongRating.objects.filter(parent_list=self.user.songlist).values( 'song__anime__cover', 'song__anime__english_name', 'song__song_type', 'song__number', 'rating', 'song__video_link', 'song__pk').order_by( '-rating', '-last_modified' ) return ratings # On User creation, make a profile as well post_save.connect(create_profile, sender=User) class SongList(ModelAbstract): """ A user's list of songs """ user = models.OneToOneField(User, on_delete=models.CASCADE) # On User creation, make a profile as well post_save.connect(create_songlist, sender=User) class SongRating(ModelAbstract): """ How a user has rated a song in their list """ song = models.ForeignKey('home.Song', on_delete=models.CASCADE) parent_list = models.ForeignKey(SongList, on_delete=models.CASCADE) rating = models.PositiveIntegerField(null=True, blank=True, validators=[MaxValueValidator(10)])

from django.db import models from django.db.models.signals import post_save from django.contrib.auth.models import User from django.core.validators import MaxValueValidator from imagekit.models import ProcessedImageField from imagekit.processors import ResizeToFill from home.models import ModelAbstract, Song class Profile(ModelAbstract): """ A user's profile. Data like profile picture/banner is stored here, but also anything else that should probably be extending the default User model. It takes hard work to set a custom User model once you've already started a project, and most of the things I want would fit nicely in a model like this anyways. """ user = models.OneToOneField(User, on_delete=models.CASCADE) avatar = ProcessedImageField( upload_to='avatars', default='avatars/placeholder.png', processors=[ResizeToFill(256, 256)], format="PNG" ) banner = ProcessedImageField( upload_to='banners', default='banners/placeholder.png', processors=[ResizeToFill(1300, 400)], format="PNG" ) # def get_recent_ratings(self, limit=20): # """ # Get the user's recently rated songs. # @limit: How many songs to get # """ # ratings = self.user.songlist.songrating_set.all() # songs = Song.objects.filter(songrating__in=ratings).values('video_link', 'anime__cover', 'pk').order_by( # '-songrating__last_modified')[:limit] # return songs def get_top_ratings(self, limit=20): """ Get the user's recently rated songs. Gets very little details, mainly just used for carousels. @limit: How many songs to get (default 20) """ # Grab all the user's ratings ratings = self.user.songlist.songrating_set.all() # Filter through the highest rated, and then most recently rated songs rated by the user. songs = Song.objects.filter(songrating__in=ratings).values('video_link', 'anime__cover', 'pk').order_by( '-songrating__rating', 'songrating__last_modified')[:limit] return songs def get_rated_songs(self, limit=None): """ Grab all songs that a User has rated. Used for the user's list. @limit: How many songs to get """ # Grab all the user's SongRatings, along with details about the song. ratings = SongRating.objects.filter(parent_list=self.user.songlist).values( 'song__anime__cover', 'song__anime__english_name', 'song__song_type', 'song__number', 'rating', 'song__video_link', 'song__pk').order_by( '-rating', '-last_modified' ) return ratings def __str__(self): return self.user.username + '\'s Profile' # On User creation, make a profile as well def create_profile(sender, instance, created, **kwargs): if created: Profile.objects.create(user=instance) post_save.connect(create_profile, sender=User) class SongList(ModelAbstract): """ A user's list of songs """ user = models.OneToOneField(User, on_delete=models.CASCADE) def __str__(self): return self.user.username + '\'s List' # On User creation, make a profile as well def create_songlist(sender, instance, created, **kwargs): if created: SongList.objects.create(user=instance) post_save.connect(create_songlist, sender=User) class SongRating(ModelAbstract): """ How a user has rated a song in their list """ song = models.ForeignKey('home.Song', on_delete=models.CASCADE) parent_list = models.ForeignKey(SongList, on_delete=models.CASCADE) rating = models.PositiveIntegerField(null=True, blank=True, validators=[MaxValueValidator(10)]) class Meta: # You should only be able to have one rating per song. constraints = [ models.UniqueConstraint(fields=['parent_list', 'song'], name='one_rating_only') ] def __str__(self): return str(self.rating) + ' ' + str(self.song)

9afa88946cd84c21fe6fd73d3c1f70f534351283

py

Python

backend/app/db/mongodb.py

soumitdas/xmeme

a0a39c55e1cb11f9cd3d001f88df88d2913efbd9

backend/app/db/mongodb.py

soumitdas/xmeme

a0a39c55e1cb11f9cd3d001f88df88d2913efbd9

backend/app/db/mongodb.py

soumitdas/xmeme

a0a39c55e1cb11f9cd3d001f88df88d2913efbd9

from motor.motor_asyncio import AsyncIOMotorClient db = Database()

from motor.motor_asyncio import AsyncIOMotorClient class Database: client: AsyncIOMotorClient = None db = Database() async def get_database() -> AsyncIOMotorClient: return db.client

1873b48a08443ccfc17f1f4b9fdf04d22a02923d

py

Python

shrinky/glsl_block_struct.py

xyproto/shrinky

8f318d2f62f8ef3cffae6bd5db1b36c95067aac6

2019-03-16T11:03:50.000Z

2021-12-26T12:41:57.000Z

shrinky/glsl_block_struct.py

xyproto/shrinky

8f318d2f62f8ef3cffae6bd5db1b36c95067aac6

2022-02-12T16:22:37.000Z

2022-02-12T16:22:37.000Z

shrinky/glsl_block_struct.py

xyproto/shrinky

8f318d2f62f8ef3cffae6bd5db1b36c95067aac6

from shrinky.glsl_block import GlslBlock from shrinky.glsl_block import extract_tokens from shrinky.glsl_block_member import glsl_parse_member_list ######################################## # GlslBlockStruct ###################### ######################################## class GlslBlockStruct(GlslBlock): """Struct declaration.""" def __init__(self, type_name, members, name=None, size=0): """Constructor.""" GlslBlock.__init__(self) self.__type_name = type_name self.__members = members self.__name = name self.__size = size self.__member_accesses = [] # Hierarchy. name.setType(type_name) self.addNamesDeclared(name) self.addNamesUsed(name) def format(self, force): """Return formatted output.""" lst = "".join([x.format(force) for x in self.__members]) ret = ("struct %s{%s}" % (self.__type_name.format(force), lst, self.__name.format(force))) if self.__name: ret += self.__name.format(force) if self.__size: ret += "[%s]" % (self.__size.format(force)) return ret + ";" def getMembers(self): """Accessor.""" return self.__members def getMemberAccesses(self): """Accessor.""" return self.__member_accesses def getName(self): """Accessor.""" return self.__name def getTypeName(self): """Accessor.""" return self.__type_name def setMemberAccesses(self, lst): """Set collected member accesses.""" self.__member_accesses = lst def __str__(self): """String representation.""" return "Struct(%i)" % (len(self.__content)) ######################################## # Functions ############################ ######################################## def glsl_parse_struct(source): """Parse struct block.""" (type_name, scope, content) = extract_tokens(source, ("struct", "?n", "?{")) if not type_name: return (None, source) # Get potential name and size. (name, size, remaining) = extract_tokens(content, ("?n", "[", "?i", "]", ";")) if not name: size = None (name, remaining) = extract_tokens(content, ("?n", ";")) if not name: name = None (terminator, remaining) = extract_tokens(content, ("?;",)) if not terminator: return (None, source) # Parse members members = glsl_parse_member_list(scope) if not members: raise RuntimeError("empty member list for struct") return (GlslBlockStruct(type_name, members, name, size), remaining) def is_glsl_block_struct(op): """Tell if given object is GlslBlockInout.""" return isinstance(op, GlslBlockStruct)

from shrinky.glsl_block import GlslBlock from shrinky.glsl_block import extract_tokens from shrinky.glsl_block_member import glsl_parse_member_list ######################################## # GlslBlockStruct ###################### ######################################## class GlslBlockStruct(GlslBlock): """Struct declaration.""" def __init__(self, type_name, members, name=None, size=0): """Constructor.""" GlslBlock.__init__(self) self.__type_name = type_name self.__members = members self.__name = name self.__size = size self.__member_accesses = [] # Hierarchy. name.setType(type_name) self.addNamesDeclared(name) self.addNamesUsed(name) def format(self, force): """Return formatted output.""" lst = "".join([x.format(force) for x in self.__members]) ret = ("struct %s{%s}" % (self.__type_name.format(force), lst, self.__name.format(force))) if self.__name: ret += self.__name.format(force) if self.__size: ret += "[%s]" % (self.__size.format(force)) return ret + ";" def getMembers(self): """Accessor.""" return self.__members def getMemberAccesses(self): """Accessor.""" return self.__member_accesses def getName(self): """Accessor.""" return self.__name def getTypeName(self): """Accessor.""" return self.__type_name def setMemberAccesses(self, lst): """Set collected member accesses.""" self.__member_accesses = lst def __str__(self): """String representation.""" return "Struct(%i)" % (len(self.__content)) ######################################## # Functions ############################ ######################################## def glsl_parse_struct(source): """Parse struct block.""" (type_name, scope, content) = extract_tokens(source, ("struct", "?n", "?{")) if not type_name: return (None, source) # Get potential name and size. (name, size, remaining) = extract_tokens(content, ("?n", "[", "?i", "]", ";")) if not name: size = None (name, remaining) = extract_tokens(content, ("?n", ";")) if not name: name = None (terminator, remaining) = extract_tokens(content, ("?;",)) if not terminator: return (None, source) # Parse members members = glsl_parse_member_list(scope) if not members: raise RuntimeError("empty member list for struct") return (GlslBlockStruct(type_name, members, name, size), remaining) def is_glsl_block_struct(op): """Tell if given object is GlslBlockInout.""" return isinstance(op, GlslBlockStruct)

1a50f81d932843336b3e69b5e740b3960191e4df

py

Python

wtiproj04/zad_6_mean_user.py

kwitnacy/wti

9ee659bf2912f5b2fe6229bbda5074d4f3ebb3d4

wtiproj04/zad_6_mean_user.py

kwitnacy/wti

9ee659bf2912f5b2fe6229bbda5074d4f3ebb3d4

wtiproj04/zad_6_mean_user.py

kwitnacy/wti

9ee659bf2912f5b2fe6229bbda5074d4f3ebb3d4

import pandas as pd import numpy as np from typing import List user_ID = 78 query = 'userID == ' + str(user_ID) # head = my_join() head = ['Action', 'Adventure', 'Animation', 'Children', 'Comedy', 'Crime', 'Documentary', 'Drama', 'Fantasy', 'Film-Noir', 'Horror', 'IMAX', 'Musical', 'Mystery', 'Romance', 'Sci-Fi', 'Short', 'Thriller', 'War', 'Western'] joined = pd.read_csv('/home/kwitnoncy/Documents/politechnika/wti/wtiproj03/data/joined.dat', sep='\t') joined = joined.query(query).to_numpy() print([np.nanmean([(row[2] * row[genre + 9]) if row[genre + 9] != 0 else np.nan for row in joined]) for genre in range(len(head))])

import pandas as pd import numpy as np from typing import List user_ID = 78 query = 'userID == ' + str(user_ID) # head = my_join() head = ['Action', 'Adventure', 'Animation', 'Children', 'Comedy', 'Crime', 'Documentary', 'Drama', 'Fantasy', 'Film-Noir', 'Horror', 'IMAX', 'Musical', 'Mystery', 'Romance', 'Sci-Fi', 'Short', 'Thriller', 'War', 'Western'] joined = pd.read_csv('/home/kwitnoncy/Documents/politechnika/wti/wtiproj03/data/joined.dat', sep='\t') joined = joined.query(query).to_numpy() print([np.nanmean([(row[2] * row[genre + 9]) if row[genre + 9] != 0 else np.nan for row in joined]) for genre in range(len(head))])

7a5e99161a963ae3dbd40cd45ad6fc98263f2ffb

py

Python

uPython/clock/main.py

c3dprk/split-flap

0b4a8bc4e540f38ad24d0b790ed6268a0b832a2f

2017-12-11T12:25:49.000Z

2022-03-02T11:44:09.000Z

uPython/clock/main.py

c3dprk/split-flap

0b4a8bc4e540f38ad24d0b790ed6268a0b832a2f

uPython/clock/main.py

c3dprk/split-flap

0b4a8bc4e540f38ad24d0b790ed6268a0b832a2f

2018-01-01T16:15:48.000Z

2020-04-07T23:44:03.000Z

from machine import Pin, RTC from time import sleep, sleep_ms, sleep_us from json import load as jload from ntptime import settime ADDR_DELAY_US = 100 GOTO_DELAY_MS = 20 HOUR_LUT = jload(open("hour_lut.json")) MINUTE_LUT = jload(open("minute_lut.json")) TIME_ZONE = +2 encoder_pins = [Pin(i, Pin.IN, Pin.PULL_UP) for i in [0, 2, 4, 5, 12, 13]] run = Pin(16, Pin.OUT) run.off() adc_hour = Pin(14, Pin.OUT) adc_hour.off() adc_minute = Pin(15, Pin.OUT) adc_minute.off() try: settime() except: pass rtc = RTC() while True: update_time() sleep(5)

from machine import Pin, RTC from time import sleep, sleep_ms, sleep_us from json import load as jload from ntptime import settime ADDR_DELAY_US = 100 GOTO_DELAY_MS = 20 HOUR_LUT = jload(open("hour_lut.json")) MINUTE_LUT = jload(open("minute_lut.json")) TIME_ZONE = +2 encoder_pins = [Pin(i, Pin.IN, Pin.PULL_UP) for i in [0, 2, 4, 5, 12, 13]] run = Pin(16, Pin.OUT) run.off() adc_hour = Pin(14, Pin.OUT) adc_hour.off() adc_minute = Pin(15, Pin.OUT) adc_minute.off() try: settime() except: pass rtc = RTC() def select(adc, adl): if None != adc: adc.on() if None != adl: adl.on() def deselect(adc, adl): if None != adc: adc.off() if None != adl: adl.off() def start(adc, adl): select(adc, adl) run.on() sleep_us(ADDR_DELAY_US) deselect(adc, adl) def stop(adc, adl): select(adc, adl) run.off() sleep_us(ADDR_DELAY_US) deselect(adc, adl) def get_pos(adc, adl): select(adc, adl) sleep_us(ADDR_DELAY_US) retval = 0 for pin in encoder_pins: retval <<= 1 retval += pin.value() deselect(adc, adl) return retval def go_to(adc, adl, val): while get_pos(adc, adl) != val: start(adc, adl) sleep_ms(GOTO_DELAY_MS) stop(adc, adl) def update_time(): hour, minute = rtc.datetime()[4:6] hour = (hour+int(TIME_ZONE))%24 if 0 == minute: try: settime() except: pass go_to(adc_hour, None, HOUR_LUT[hour]) go_to(adc_minute, None, MINUTE_LUT[minute]) def test_62(adc, adl): for i in range(62, 0, -1): go_to(adc, adl, i) print(i) while True: update_time() sleep(5)

5cfc29885daabd72bd7e5d74a2904b6dbfab5b1f

py

Python

conftest.py

MatPoliquin/retro

c70c174a9818d1e97bc36e61abb4694d28fc68e1

2018-04-05T18:28:50.000Z

2022-03-29T16:56:59.000Z

conftest.py

MatPoliquin/retro

c70c174a9818d1e97bc36e61abb4694d28fc68e1

2018-04-05T22:30:42.000Z

2022-03-19T01:55:11.000Z

conftest.py

MatPoliquin/retro

c70c174a9818d1e97bc36e61abb4694d28fc68e1

2018-04-05T19:10:34.000Z

2022-03-28T13:33:32.000Z

import pytest import retro.data inttypes = { 'exp': retro.data.Integrations.EXPERIMENTAL_ONLY, 'contrib': retro.data.Integrations.CONTRIB_ONLY, }

import pytest import retro.data inttypes = { 'exp': retro.data.Integrations.EXPERIMENTAL_ONLY, 'contrib': retro.data.Integrations.CONTRIB_ONLY, } def pytest_collection_modifyitems(items): def test(*args, **kwargs): print(kwargs) return False for item in items: if item.originalname in ('test_load', 'test_rom', 'test_state', 'test_hash'): for key in item.keywords.keys(): if '[' + key + ']' not in item.nodeid: continue game = key.split('_') gamename = '%s-%s' % (game[0], game[1]) try: retro.data.get_romfile_path(gamename, inttypes[game[2]] if len(game) > 2 else retro.data.Integrations.STABLE) except (FileNotFoundError, KeyError): item.add_marker(pytest.mark.skip)

67146385598397f73fdfde407de56e453e1380c1

py

Python

examples/futures/market/funding_rate.py

AlfonsoAgAr/binance-futures-connector-python

f0bd2c7b0576503bf526ce6be329ca2dae90fefe

2021-11-22T11:46:27.000Z

2022-03-30T06:58:53.000Z

examples/futures/market/funding_rate.py

sanjeevan121/binance-futures-connector-python

d820b73a15e9f64c80891a13694ca0c5d1693b90

2021-12-15T22:40:52.000Z

2022-03-29T22:08:31.000Z

examples/futures/market/funding_rate.py

sanjeevan121/binance-futures-connector-python

d820b73a15e9f64c80891a13694ca0c5d1693b90

2021-12-10T03:56:13.000Z

2022-03-25T22:23:44.000Z

#!/usr/bin/env python from binance.futures import Futures as Client import logging from binance.lib.utils import config_logging config_logging(logging, logging.DEBUG) futures_client = Client() logging.info(futures_client.funding_rate("BTCUSDT",**{'limit':100}))

#!/usr/bin/env python from binance.futures import Futures as Client import logging from binance.lib.utils import config_logging config_logging(logging, logging.DEBUG) futures_client = Client() logging.info(futures_client.funding_rate("BTCUSDT",**{'limit':100}))

6a497cd03b5c018bcfd778acb4c7bc5cc9a8d147

py

Python

perfkitbenchmarker/providers/aws/aws_capacity_reservation.py

Nowasky/PerfKitBenchmarker

cfa88e269eb373780910896ed4bdc8db09469753

2018-04-28T13:06:14.000Z

2020-06-09T02:39:44.000Z

perfkitbenchmarker/providers/aws/aws_capacity_reservation.py

Nowasky/PerfKitBenchmarker

cfa88e269eb373780910896ed4bdc8db09469753

2021-09-09T07:43:25.000Z

2021-09-09T10:47:56.000Z

perfkitbenchmarker/providers/aws/aws_capacity_reservation.py

Nowasky/PerfKitBenchmarker

cfa88e269eb373780910896ed4bdc8db09469753

2019-06-11T18:59:57.000Z

2021-03-02T19:14:42.000Z

# Copyright 2019 PerfKitBenchmarker Authors. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """CapacityReservation for AWS virtual machines. AWS EC2 has the concept of capacity reservations which allow the user to request a reservation for a given number of VMs of a specified shape (machine type and os type) in a given zone, for an optionally-supplied duration. This module implements this functionaly. A useful feature of using AwsCapacityReservation is that it allows the user to specify a region instead of a zone, and this module will automatically pick a zone that has capacity, and the VM(s) will then be launched in that zone. AwsCapacityReservation modifies all the VMs in a given vm_group in the following way: 1. The capacity_reservation_id attribute on the VM is set after the reservation is created. The VM needs to reference this id during creation. 2. If the user supplied a region instead of zone, then this module will update the zone attribute on the VM, as well as the zone attribute on the VM's network instance. A run of PKB may have several capacity reservations; there is a 1:1 mapping from AWS vm_groups to AwsCapacityReservation instances. This is because all VMs in a VM group share the same shape and zone. """ import datetime import json import logging from absl import flags from perfkitbenchmarker import capacity_reservation from perfkitbenchmarker import errors from perfkitbenchmarker import os_types from perfkitbenchmarker import vm_util from perfkitbenchmarker.providers import aws from perfkitbenchmarker.providers.aws import util FLAGS = flags.FLAGS _INSUFFICIENT_CAPACITY = 'InsufficientInstanceCapacity' class AwsCapacityReservation(capacity_reservation.BaseCapacityReservation): """An object representing an AWS EC2 CapacityReservation.""" CLOUD = aws.CLOUD def _Create(self): """Creates the AWS CapacaityReservation. A reservation will be created given the VM shape in self.vm_groups. Count is determined by the number of VMs in said group. The reservation will have a lifetime determined by the general PKB concept of timeout_minutes. If the reservation exceeds this timeout, AWS will cancel it automatically. The VMs in the reservation will not be deleted. Note that an empty capacity reservation will encur costs for the VM shape / count, even if no VMs are using it. After the reservation is created, this method updates all the VMs in self.vm_groups by setting the capacity_reservation_id, as well as the zone attributes on the VM, and the VM's network instance. Raises: UnsupportedOsTypeError: If creating a capacity reservation for the given os type is not supported. CreationError: If a capacity reservation cannot be created in the region (typically indicates a stockout). """ if self.os_type in os_types.LINUX_OS_TYPES: instance_platform = 'Linux/UNIX' elif self.os_type in os_types.WINDOWS_OS_TYPES: instance_platform = 'Windows' else: raise UnsupportedOsTypeError( 'Unsupported os_type for AWS CapacityReservation: %s.' % self.os_type) # If the user did not specify an AZ, we need to try to create the # CapacityReservation in a specifc AZ until it succeeds. # Then update the zone attribute on all the VMs in the group, # as well as the zone attribute on the VMs' network instance. if util.IsRegion(self.zone_or_region): zones_to_try = util.GetZonesInRegion(self.region) else: zones_to_try = [self.zone_or_region] end_date = ( datetime.datetime.utcnow() + datetime.timedelta(minutes=FLAGS.timeout_minutes)) for zone in zones_to_try: cmd = util.AWS_PREFIX + [ 'ec2', 'create-capacity-reservation', '--instance-type=%s' % self.machine_type, '--instance-platform=%s' % instance_platform, '--availability-zone=%s' % zone, '--instance-count=%s' % self.vm_count, '--instance-match-criteria=targeted', '--region=%s' % self.region, '--end-date-type=limited', '--end-date=%s' % end_date.isoformat(), ] stdout, stderr, retcode = vm_util.IssueCommand(cmd, raise_on_failure=False) if retcode: logging.info('Unable to create CapacityReservation in %s. ' 'This may be retried. Details: %s', zone, stderr) if _INSUFFICIENT_CAPACITY in stderr: logging.error(util.STOCKOUT_MESSAGE) raise errors.Benchmarks.InsufficientCapacityCloudFailure( util.STOCKOUT_MESSAGE + ' CapacityReservation in ' + zone) continue json_output = json.loads(stdout) self.capacity_reservation_id = ( json_output['CapacityReservation']['CapacityReservationId']) self._UpdateVmsInGroup(self.capacity_reservation_id, zone) return raise CreationError('Unable to create CapacityReservation in any of the ' 'following zones: %s.' % zones_to_try) def _Delete(self): """Deletes the capacity reservation.""" cmd = util.AWS_PREFIX + [ 'ec2', 'cancel-capacity-reservation', '--capacity-reservation-id=%s' % self.capacity_reservation_id, '--region=%s' % self.region, ] vm_util.IssueCommand(cmd, raise_on_failure=False) def _Exists(self): """Returns true if the underlying reservation exists and is active.""" cmd = util.AWS_PREFIX + [ 'ec2', 'describe-capacity-reservations', '--capacity-reservation-id=%s' % self.capacity_reservation_id, '--region=%s' % self.region, ] stdout, _, retcode = vm_util.IssueCommand(cmd, raise_on_failure=False) if retcode != 0: return False json_output = json.loads(stdout) return json_output['CapacityReservations'][0]['State'] == 'active' def _UpdateVmsInGroup(self, capacity_reservation_id, zone): """Updates the VMs in a group with necessary reservation details. AWS virtual machines need to reference the capacity reservation id during creation, so it is set on all VMs in the group. Additionally, this class may determine which zone to run in, so that needs to be updated too (on the VM, and the VM's network instance). Args: capacity_reservation_id: ID of the reservation created by this instance. zone: Zone chosen by this class, or if it was supplied, the zone provided by the user. In the latter case, setting the zone is equivalent to a no-op. """ for vm in self.vm_group: vm.capacity_reservation_id = capacity_reservation_id vm.zone = zone vm.network.zone = zone

# Copyright 2019 PerfKitBenchmarker Authors. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """CapacityReservation for AWS virtual machines. AWS EC2 has the concept of capacity reservations which allow the user to request a reservation for a given number of VMs of a specified shape (machine type and os type) in a given zone, for an optionally-supplied duration. This module implements this functionaly. A useful feature of using AwsCapacityReservation is that it allows the user to specify a region instead of a zone, and this module will automatically pick a zone that has capacity, and the VM(s) will then be launched in that zone. AwsCapacityReservation modifies all the VMs in a given vm_group in the following way: 1. The capacity_reservation_id attribute on the VM is set after the reservation is created. The VM needs to reference this id during creation. 2. If the user supplied a region instead of zone, then this module will update the zone attribute on the VM, as well as the zone attribute on the VM's network instance. A run of PKB may have several capacity reservations; there is a 1:1 mapping from AWS vm_groups to AwsCapacityReservation instances. This is because all VMs in a VM group share the same shape and zone. """ import datetime import json import logging from absl import flags from perfkitbenchmarker import capacity_reservation from perfkitbenchmarker import errors from perfkitbenchmarker import os_types from perfkitbenchmarker import vm_util from perfkitbenchmarker.providers import aws from perfkitbenchmarker.providers.aws import util FLAGS = flags.FLAGS _INSUFFICIENT_CAPACITY = 'InsufficientInstanceCapacity' class InvalidVmGroupSizeError(Exception): pass class UnsupportedOsTypeError(Exception): pass class CreationError(Exception): pass class AwsCapacityReservation(capacity_reservation.BaseCapacityReservation): """An object representing an AWS EC2 CapacityReservation.""" CLOUD = aws.CLOUD def __init__(self, vm_group): if not vm_group: raise InvalidVmGroupSizeError( 'AwsCapacityReservation must be initialized with at least one ' 'VM in the vm_group.') super(AwsCapacityReservation, self).__init__(vm_group) self.zone_or_region = vm_group[0].zone self.region = util.GetRegionFromZone(self.zone_or_region) self.machine_type = vm_group[0].machine_type self.os_type = vm_group[0].OS_TYPE self.vm_count = len(vm_group) def _Create(self): """Creates the AWS CapacaityReservation. A reservation will be created given the VM shape in self.vm_groups. Count is determined by the number of VMs in said group. The reservation will have a lifetime determined by the general PKB concept of timeout_minutes. If the reservation exceeds this timeout, AWS will cancel it automatically. The VMs in the reservation will not be deleted. Note that an empty capacity reservation will encur costs for the VM shape / count, even if no VMs are using it. After the reservation is created, this method updates all the VMs in self.vm_groups by setting the capacity_reservation_id, as well as the zone attributes on the VM, and the VM's network instance. Raises: UnsupportedOsTypeError: If creating a capacity reservation for the given os type is not supported. CreationError: If a capacity reservation cannot be created in the region (typically indicates a stockout). """ if self.os_type in os_types.LINUX_OS_TYPES: instance_platform = 'Linux/UNIX' elif self.os_type in os_types.WINDOWS_OS_TYPES: instance_platform = 'Windows' else: raise UnsupportedOsTypeError( 'Unsupported os_type for AWS CapacityReservation: %s.' % self.os_type) # If the user did not specify an AZ, we need to try to create the # CapacityReservation in a specifc AZ until it succeeds. # Then update the zone attribute on all the VMs in the group, # as well as the zone attribute on the VMs' network instance. if util.IsRegion(self.zone_or_region): zones_to_try = util.GetZonesInRegion(self.region) else: zones_to_try = [self.zone_or_region] end_date = ( datetime.datetime.utcnow() + datetime.timedelta(minutes=FLAGS.timeout_minutes)) for zone in zones_to_try: cmd = util.AWS_PREFIX + [ 'ec2', 'create-capacity-reservation', '--instance-type=%s' % self.machine_type, '--instance-platform=%s' % instance_platform, '--availability-zone=%s' % zone, '--instance-count=%s' % self.vm_count, '--instance-match-criteria=targeted', '--region=%s' % self.region, '--end-date-type=limited', '--end-date=%s' % end_date.isoformat(), ] stdout, stderr, retcode = vm_util.IssueCommand(cmd, raise_on_failure=False) if retcode: logging.info('Unable to create CapacityReservation in %s. ' 'This may be retried. Details: %s', zone, stderr) if _INSUFFICIENT_CAPACITY in stderr: logging.error(util.STOCKOUT_MESSAGE) raise errors.Benchmarks.InsufficientCapacityCloudFailure( util.STOCKOUT_MESSAGE + ' CapacityReservation in ' + zone) continue json_output = json.loads(stdout) self.capacity_reservation_id = ( json_output['CapacityReservation']['CapacityReservationId']) self._UpdateVmsInGroup(self.capacity_reservation_id, zone) return raise CreationError('Unable to create CapacityReservation in any of the ' 'following zones: %s.' % zones_to_try) def _Delete(self): """Deletes the capacity reservation.""" cmd = util.AWS_PREFIX + [ 'ec2', 'cancel-capacity-reservation', '--capacity-reservation-id=%s' % self.capacity_reservation_id, '--region=%s' % self.region, ] vm_util.IssueCommand(cmd, raise_on_failure=False) def _Exists(self): """Returns true if the underlying reservation exists and is active.""" cmd = util.AWS_PREFIX + [ 'ec2', 'describe-capacity-reservations', '--capacity-reservation-id=%s' % self.capacity_reservation_id, '--region=%s' % self.region, ] stdout, _, retcode = vm_util.IssueCommand(cmd, raise_on_failure=False) if retcode != 0: return False json_output = json.loads(stdout) return json_output['CapacityReservations'][0]['State'] == 'active' def _UpdateVmsInGroup(self, capacity_reservation_id, zone): """Updates the VMs in a group with necessary reservation details. AWS virtual machines need to reference the capacity reservation id during creation, so it is set on all VMs in the group. Additionally, this class may determine which zone to run in, so that needs to be updated too (on the VM, and the VM's network instance). Args: capacity_reservation_id: ID of the reservation created by this instance. zone: Zone chosen by this class, or if it was supplied, the zone provided by the user. In the latter case, setting the zone is equivalent to a no-op. """ for vm in self.vm_group: vm.capacity_reservation_id = capacity_reservation_id vm.zone = zone vm.network.zone = zone

cb4016d8c942b829044e83083af5b694d65e6752

py

Python

jieba-0.38/jieba/analyse/__init__.py

scmsqhn/changhongmall

41ce7a42e6484be0e4d4d3912b9e23b96a281d4a

2016-02-13T08:36:45.000Z

2017-05-07T22:43:34.000Z

jieba-0.38/jieba/analyse/__init__.py

scmsqhn/changhongmall

41ce7a42e6484be0e4d4d3912b9e23b96a281d4a

jieba-0.38/jieba/analyse/__init__.py

scmsqhn/changhongmall

41ce7a42e6484be0e4d4d3912b9e23b96a281d4a

from __future__ import absolute_import from .tfidf import TFIDF from .textrank import TextRank try: from .analyzer import ChineseAnalyzer except ImportError: pass default_tfidf = TFIDF() default_textrank = TextRank() extract_tags = tfidf = default_tfidf.extract_tags set_idf_path = default_tfidf.set_idf_path textrank = default_textrank.extract_tags

from __future__ import absolute_import from .tfidf import TFIDF from .textrank import TextRank try: from .analyzer import ChineseAnalyzer except ImportError: pass default_tfidf = TFIDF() default_textrank = TextRank() extract_tags = tfidf = default_tfidf.extract_tags set_idf_path = default_tfidf.set_idf_path textrank = default_textrank.extract_tags def set_stop_words(stop_words_path): default_tfidf.set_stop_words(stop_words_path) default_textrank.set_stop_words(stop_words_path)

267f7a0745f4981f02d8619bb346037688232eb9

py

Python

elastica/rod/factory_function.py

bhosale2/PyElastica

520374672cbd6b0c89a912c5019559e66c5535e3

elastica/rod/factory_function.py

bhosale2/PyElastica

520374672cbd6b0c89a912c5019559e66c5535e3

elastica/rod/factory_function.py

bhosale2/PyElastica

520374672cbd6b0c89a912c5019559e66c5535e3

__doc__ = """ Factory function to allocate variables for Cosserat Rod""" __all__ = ["allocate"] import typing from typing import Optional, Tuple import warnings import logging import numpy as np from numpy.testing import assert_allclose from elastica.utils import MaxDimension, Tolerance from elastica._linalg import _batch_cross, _batch_norm, _batch_dot def _position_validity_checker(position, start, n_elements): """Checker on user-defined position validity""" _assert_shape(position, (MaxDimension.value(), n_elements + 1), "position") # Check if the start position of the rod and first entry of position array are the same assert_allclose( position[..., 0], start, atol=Tolerance.atol(), err_msg=str( "First entry of position" + " (" + str(position[..., 0]) + " ) " " is different than start " + " (" + str(start) + " ) " ), ) def _directors_validity_checker(directors, tangents, n_elements): """Checker on user-defined directors validity""" _assert_shape( directors, (MaxDimension.value(), MaxDimension.value(), n_elements), "directors" ) # Check if d1, d2, d3 are unit vectors d1 = directors[0, ...] d2 = directors[1, ...] d3 = directors[2, ...] assert_allclose( _batch_norm(d1), np.ones((n_elements)), atol=Tolerance.atol(), err_msg=(" d1 vector of input director matrix is not unit vector "), ) assert_allclose( _batch_norm(d2), np.ones((n_elements)), atol=Tolerance.atol(), err_msg=(" d2 vector of input director matrix is not unit vector "), ) assert_allclose( _batch_norm(d3), np.ones((n_elements)), atol=Tolerance.atol(), err_msg=(" d3 vector of input director matrix is not unit vector "), ) # Check if d3xd1 = d2 assert_allclose( _batch_cross(d3, d1), d2, atol=Tolerance.atol(), err_msg=(" d3 x d1 != d2 of input director matrix"), ) # Check if computed tangents from position is the same with d3 assert_allclose( tangents, d3, atol=Tolerance.atol(), err_msg=" Tangent vector computed using node positions is different than d3 vector of input directors", )

__doc__ = """ Factory function to allocate variables for Cosserat Rod""" __all__ = ["allocate"] import typing from typing import Optional, Tuple import warnings import logging import numpy as np from numpy.testing import assert_allclose from elastica.utils import MaxDimension, Tolerance from elastica._linalg import _batch_cross, _batch_norm, _batch_dot def allocate( n_elements, start, direction, normal, base_length, base_radius, density, nu, youngs_modulus: float, nu_for_torques: Optional[float] = None, shear_modulus: Optional[float] = None, position: Optional[np.ndarray] = None, directors: Optional[np.ndarray] = None, rest_sigma: Optional[np.ndarray] = None, rest_kappa: Optional[np.ndarray] = None, *args, **kwargs, ): log = logging.getLogger() if "poisson_ratio" in kwargs: # Deprecation warning for poission_ratio raise NameError( "Poisson's ratio is deprecated for Cosserat Rod for clarity. Please provide shear_modulus instead." ) # sanity checks here assert n_elements > 1 assert base_length > Tolerance.atol() assert np.sqrt(np.dot(normal, normal)) > Tolerance.atol() assert np.sqrt(np.dot(direction, direction)) > Tolerance.atol() # check if position is given. if position is None: # Generate straight and uniform rod # Set the position array position = np.zeros((MaxDimension.value(), n_elements + 1)) end = start + direction * base_length for i in range(0, 3): position[i, ...] = np.linspace(start[i], end[i], n_elements + 1) _position_validity_checker(position, start, n_elements) # Compute rest lengths and tangents position_diff = position[..., 1:] - position[..., :-1] rest_lengths = _batch_norm(position_diff) tangents = position_diff / rest_lengths normal /= np.linalg.norm(normal) if directors is None: # Generate straight uniform rod # Set the directors matrix directors = np.zeros((MaxDimension.value(), MaxDimension.value(), n_elements)) # Construct directors using tangents and normal normal_collection = np.repeat(normal[:, np.newaxis], n_elements, axis=1) # Check if rod normal and rod tangent are perpendicular to each other otherwise # directors will be wrong!! assert_allclose( _batch_dot(normal_collection, tangents), 0, atol=Tolerance.atol(), err_msg=(" Rod normal and tangent are not perpendicular to each other!"), ) directors[0, ...] = normal_collection directors[1, ...] = _batch_cross(tangents, normal_collection) directors[2, ...] = tangents _directors_validity_checker(directors, tangents, n_elements) # Set radius array radius = np.zeros((n_elements)) # Check if the user input radius is valid radius_temp = np.array(base_radius) _assert_dim(radius_temp, 2, "radius") radius[:] = radius_temp # Check if the elements of radius are greater than tolerance assert np.all(radius > Tolerance.atol()), " Radius has to be greater than 0." # Set density array density_array = np.zeros((n_elements)) # Check if the user input density is valid density_temp = np.array(density) _assert_dim(density_temp, 2, "density") density_array[:] = density_temp # Check if the elements of density are greater than tolerance assert np.all( density_array > Tolerance.atol() ), " Density has to be greater than 0." # Second moment of inertia A0 = np.pi * radius * radius I0_1 = A0 * A0 / (4.0 * np.pi) I0_2 = I0_1 I0_3 = 2.0 * I0_2 I0 = np.array([I0_1, I0_2, I0_3]).transpose() # Mass second moment of inertia for disk cross-section mass_second_moment_of_inertia = np.zeros( (MaxDimension.value(), MaxDimension.value(), n_elements), np.float64 ) mass_second_moment_of_inertia_temp = np.einsum( "ij,i->ij", I0, density * rest_lengths ) for i in range(n_elements): np.fill_diagonal( mass_second_moment_of_inertia[..., i], mass_second_moment_of_inertia_temp[i, :], ) # sanity check of mass second moment of inertia if (mass_second_moment_of_inertia < Tolerance.atol()).all(): message = "Mass moment of inertia matrix smaller than tolerance, please check provided radius, density and length." log.warning(message) # Inverse of second moment of inertia inv_mass_second_moment_of_inertia = np.zeros( (MaxDimension.value(), MaxDimension.value(), n_elements) ) for i in range(n_elements): # Check rank of mass moment of inertia matrix to see if it is invertible assert ( np.linalg.matrix_rank(mass_second_moment_of_inertia[..., i]) == MaxDimension.value() ) inv_mass_second_moment_of_inertia[..., i] = np.linalg.inv( mass_second_moment_of_inertia[..., i] ) # Shear/Stretch matrix if not shear_modulus: log.info( """Shear modulus is not explicitly given.\n In such case, we compute shear_modulus assuming poisson's ratio of 0.5""" ) shear_modulus = youngs_modulus / (2.0 * (1.0 + 0.5)) # Value taken based on best correlation for Poisson ratio = 0.5, from # "On Timoshenko's correction for shear in vibrating beams" by Kaneko, 1975 alpha_c = 0.964 shear_matrix = np.zeros( (MaxDimension.value(), MaxDimension.value(), n_elements), np.float64 ) for i in range(n_elements): np.fill_diagonal( shear_matrix[..., i], [ alpha_c * shear_modulus * A0[i], alpha_c * shear_modulus * A0[i], youngs_modulus * A0[i], ], ) # Bend/Twist matrix bend_matrix = np.zeros( (MaxDimension.value(), MaxDimension.value(), n_elements), np.float64 ) for i in range(n_elements): np.fill_diagonal( bend_matrix[..., i], [ youngs_modulus * I0_1[i], youngs_modulus * I0_2[i], shear_modulus * I0_3[i], ], ) for i in range(0, MaxDimension.value()): assert np.all( bend_matrix[i, i, :] > Tolerance.atol() ), " Bend matrix has to be greater than 0." # Compute bend matrix in Voronoi Domain bend_matrix = ( bend_matrix[..., 1:] * rest_lengths[1:] + bend_matrix[..., :-1] * rest_lengths[0:-1] ) / (rest_lengths[1:] + rest_lengths[:-1]) # Compute volume of elements volume = np.pi * radius ** 2 * rest_lengths # Compute mass of elements mass = np.zeros(n_elements + 1) mass[:-1] += 0.5 * density * volume mass[1:] += 0.5 * density * volume # Set dissipation constant or nu array dissipation_constant_for_forces = np.zeros((n_elements)) # Check if the user input nu is valid nu_temp = np.array(nu) _assert_dim(nu_temp, 2, "dissipation constant (nu) for forces)") dissipation_constant_for_forces[:] = nu # Check if the elements of dissipation constant greater than tolerance assert np.all( dissipation_constant_for_forces >= 0.0 ), " Dissipation constant(nu) has to be equal or greater than 0." # Custom nu for torques if nu_for_torques is None: dissipation_constant_for_torques = dissipation_constant_for_forces.copy() else: dissipation_constant_for_torques = np.asarray(nu_for_torques) _assert_dim( dissipation_constant_for_torques, 2, "dissipation constant (nu) for torque)" ) # Generate rest sigma and rest kappa, use user input if defined # set rest strains and curvature to be zero at start # if found in kwargs modify (say for curved rod) if rest_sigma is None: rest_sigma = np.zeros((MaxDimension.value(), n_elements)) _assert_shape(rest_sigma, (MaxDimension.value(), n_elements), "rest_sigma") if rest_kappa is None: rest_kappa = np.zeros((MaxDimension.value(), n_elements - 1)) _assert_shape(rest_kappa, (MaxDimension.value(), n_elements - 1), "rest_kappa") # Compute rest voronoi length rest_voronoi_lengths = 0.5 * (rest_lengths[1:] + rest_lengths[:-1]) # Allocate arrays for Cosserat Rod equations velocities = np.zeros((MaxDimension.value(), n_elements + 1)) omegas = np.zeros((MaxDimension.value(), n_elements)) accelerations = 0.0 * velocities angular_accelerations = 0.0 * omegas # _vector_states = np.hstack( # (position, velocities, omegas, accelerations, angular_accelerations) # ) # _matrix_states = directors.copy() internal_forces = 0.0 * accelerations internal_torques = 0.0 * angular_accelerations external_forces = 0.0 * accelerations external_torques = 0.0 * angular_accelerations lengths = np.zeros((n_elements)) tangents = np.zeros((3, n_elements)) dilatation = np.zeros((n_elements)) voronoi_dilatation = np.zeros((n_elements - 1)) dilatation_rate = np.zeros((n_elements)) sigma = np.zeros((3, n_elements)) kappa = np.zeros((3, n_elements - 1)) internal_stress = np.zeros((3, n_elements)) internal_couple = np.zeros((3, n_elements - 1)) damping_forces = np.zeros((3, n_elements + 1)) damping_torques = np.zeros((3, n_elements)) return ( n_elements, position, velocities, omegas, accelerations, angular_accelerations, directors, radius, mass_second_moment_of_inertia, inv_mass_second_moment_of_inertia, shear_matrix, bend_matrix, density_array, volume, mass, dissipation_constant_for_forces, dissipation_constant_for_torques, internal_forces, internal_torques, external_forces, external_torques, lengths, rest_lengths, tangents, dilatation, dilatation_rate, voronoi_dilatation, rest_voronoi_lengths, sigma, kappa, rest_sigma, rest_kappa, internal_stress, internal_couple, damping_forces, damping_torques, ) def _assert_dim(vector, max_dim: int, name: str): assert vector.ndim < max_dim, ( f"Input {name} dimension is not correct {vector.shape}" + f" It should be maximum {max_dim}D vector or single floating number." ) def _assert_shape(array: np.ndarray, expected_shape: Tuple[int], name: str): assert array.shape == expected_shape, ( f"Given {name} shape is not correct, it should be " + str(expected_shape) + " but instead " + str(array.shape) ) def _position_validity_checker(position, start, n_elements): """Checker on user-defined position validity""" _assert_shape(position, (MaxDimension.value(), n_elements + 1), "position") # Check if the start position of the rod and first entry of position array are the same assert_allclose( position[..., 0], start, atol=Tolerance.atol(), err_msg=str( "First entry of position" + " (" + str(position[..., 0]) + " ) " " is different than start " + " (" + str(start) + " ) " ), ) def _directors_validity_checker(directors, tangents, n_elements): """Checker on user-defined directors validity""" _assert_shape( directors, (MaxDimension.value(), MaxDimension.value(), n_elements), "directors" ) # Check if d1, d2, d3 are unit vectors d1 = directors[0, ...] d2 = directors[1, ...] d3 = directors[2, ...] assert_allclose( _batch_norm(d1), np.ones((n_elements)), atol=Tolerance.atol(), err_msg=(" d1 vector of input director matrix is not unit vector "), ) assert_allclose( _batch_norm(d2), np.ones((n_elements)), atol=Tolerance.atol(), err_msg=(" d2 vector of input director matrix is not unit vector "), ) assert_allclose( _batch_norm(d3), np.ones((n_elements)), atol=Tolerance.atol(), err_msg=(" d3 vector of input director matrix is not unit vector "), ) # Check if d3xd1 = d2 assert_allclose( _batch_cross(d3, d1), d2, atol=Tolerance.atol(), err_msg=(" d3 x d1 != d2 of input director matrix"), ) # Check if computed tangents from position is the same with d3 assert_allclose( tangents, d3, atol=Tolerance.atol(), err_msg=" Tangent vector computed using node positions is different than d3 vector of input directors", )

edebf6391ea5ad0a5b7782e9f778bed9cb045eb3

py

Python

rl_vs_rand.py

yangmuzhi/wuziqi

7bdee51ef2a37373b0823b00c4536138560ec3bb

rl_vs_rand.py

yangmuzhi/wuziqi

7bdee51ef2a37373b0823b00c4536138560ec3bb

rl_vs_rand.py

yangmuzhi/wuziqi

7bdee51ef2a37373b0823b00c4536138560ec3bb

from env_wrapper import wzq_env from policy.rand_policy import rand_agent from policy.algo.ppo import PPO from policy.net.net_v0 import policy_net from policy.net.net_v0 import value_net from policy.rl_policy import ppo_agent import time import numpy as np agent0 = ppo_agent(size=15) agent1 = rand_agent(size=15) env = wzq_env([agent0, agent1]) env.run()

from env_wrapper import wzq_env from policy.rand_policy import rand_agent from policy.algo.ppo import PPO from policy.net.net_v0 import policy_net from policy.net.net_v0 import value_net from policy.rl_policy import ppo_agent import time import numpy as np agent0 = ppo_agent(size=15) agent1 = rand_agent(size=15) env = wzq_env([agent0, agent1]) env.run()

7f879e3d16877aed4273aa22fc10b7ba833b6e0c

py

Python

catalog/bindings/gmd/md_application_schema_information_type.py

NIVANorge/s-enda-playground

56ae0a8978f0ba8a5546330786c882c31e17757a

catalog/bindings/gmd/md_application_schema_information_type.py

NIVANorge/s-enda-playground

56ae0a8978f0ba8a5546330786c882c31e17757a

catalog/bindings/gmd/md_application_schema_information_type.py

NIVANorge/s-enda-playground

56ae0a8978f0ba8a5546330786c882c31e17757a

from dataclasses import dataclass, field from typing import Optional from bindings.gmd.abstract_object_type import AbstractObjectType from bindings.gmd.binary_property_type import BinaryPropertyType from bindings.gmd.character_string_property_type import CharacterStringPropertyType from bindings.gmd.ci_citation_type import CiCitationPropertyType __NAMESPACE__ = "http://www.isotc211.org/2005/gmd" @dataclass class MdApplicationSchemaInformationType(AbstractObjectType): """ Information about the application schema used to build the dataset. """ name: Optional[CiCitationPropertyType] = field( default=None, metadata={ "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", "required": True, }, ) schema_language: Optional[CharacterStringPropertyType] = field( default=None, metadata={ "name": "schemaLanguage", "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", "required": True, }, ) constraint_language: Optional[CharacterStringPropertyType] = field( default=None, metadata={ "name": "constraintLanguage", "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", "required": True, }, ) schema_ascii: Optional[CharacterStringPropertyType] = field( default=None, metadata={ "name": "schemaAscii", "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", }, ) graphics_file: Optional[BinaryPropertyType] = field( default=None, metadata={ "name": "graphicsFile", "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", }, ) software_development_file: Optional[BinaryPropertyType] = field( default=None, metadata={ "name": "softwareDevelopmentFile", "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", }, ) software_development_file_format: Optional[CharacterStringPropertyType] = field( default=None, metadata={ "name": "softwareDevelopmentFileFormat", "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", }, )

from dataclasses import dataclass, field from typing import Optional from bindings.gmd.abstract_object_type import AbstractObjectType from bindings.gmd.binary_property_type import BinaryPropertyType from bindings.gmd.character_string_property_type import CharacterStringPropertyType from bindings.gmd.ci_citation_type import CiCitationPropertyType __NAMESPACE__ = "http://www.isotc211.org/2005/gmd" @dataclass class MdApplicationSchemaInformationType(AbstractObjectType): """ Information about the application schema used to build the dataset. """ class Meta: name = "MD_ApplicationSchemaInformation_Type" name: Optional[CiCitationPropertyType] = field( default=None, metadata={ "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", "required": True, }, ) schema_language: Optional[CharacterStringPropertyType] = field( default=None, metadata={ "name": "schemaLanguage", "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", "required": True, }, ) constraint_language: Optional[CharacterStringPropertyType] = field( default=None, metadata={ "name": "constraintLanguage", "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", "required": True, }, ) schema_ascii: Optional[CharacterStringPropertyType] = field( default=None, metadata={ "name": "schemaAscii", "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", }, ) graphics_file: Optional[BinaryPropertyType] = field( default=None, metadata={ "name": "graphicsFile", "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", }, ) software_development_file: Optional[BinaryPropertyType] = field( default=None, metadata={ "name": "softwareDevelopmentFile", "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", }, ) software_development_file_format: Optional[CharacterStringPropertyType] = field( default=None, metadata={ "name": "softwareDevelopmentFileFormat", "type": "Element", "namespace": "http://www.isotc211.org/2005/gmd", }, )

ff3169fa89df03f86c76a1e4195a8f9a48e7d51f

py

Python

semibandits/plotting_script.py

akshaykr/oracle_cb

68f10fce5eca8ebe3f57fd5a56a0ef8d82537ab4

2017-08-02T19:58:06.000Z

2021-11-03T06:31:01.000Z

semibandits/plotting_script.py

akshaykr/oracle_cb

68f10fce5eca8ebe3f57fd5a56a0ef8d82537ab4

2020-03-03T06:06:32.000Z

2020-03-03T06:06:32.000Z

semibandits/plotting_script.py

akshaykr/oracle_cb

68f10fce5eca8ebe3f57fd5a56a0ef8d82537ab4

2017-06-02T19:34:38.000Z

2022-03-22T10:38:51.000Z

import pickle import matplotlib.pyplot as plt import matplotlib.patches import matplotlib as mpl import numpy as np import sys, argparse sys.path.append("../") import Plotting Names = { 'mini_gb2': 'VC-GB2', 'mini_gb5': 'VC-GB5', 'mini_lin': 'VC-Lin', 'epsall_gb2': '$\epsilon$-GB2', 'epsall_gb5': '$\epsilon$-GB5', 'epsall_lin': '$\epsilon$-Lin', 'lin': 'LinUCB' } Styles = { 'mini_gb2': ['k', 'solid'], 'mini_gb5': ['r', 'solid'], 'mini_lin': ['g', 'solid'], 'epsall_gb2': ['k', 'dashed'], 'epsall_gb5': ['r', 'dashed'], 'epsall_lin': ['g', 'dashed'], 'lin': ['b', 'solid'] } parser = argparse.ArgumentParser() parser.add_argument('--save', dest='save', action='store_true') Args = parser.parse_args(sys.argv[1:]) D1 = Plotting.read_dir("../results/mslr30k_T=36000_L=3_e=0.1/") D2 = Plotting.read_dir("../results/yahoo_T=40000_L=2_e=0.5/") print(mpl.rcParams['figure.figsize']) fig = plt.figure(figsize=(mpl.rcParams['figure.figsize'][0]*2, mpl.rcParams['figure.figsize'][1]-1)) ax = fig.add_subplot(111,frameon=False) ax1 = fig.add_subplot(121) ax2 = fig.add_subplot(122) ax.spines['top'].set_color('none') ax.spines['bottom'].set_color('none') ax.spines['left'].set_color('none') ax.spines['right'].set_color('none') ax.tick_params(labelcolor='none', top='off', bottom='off', left='off', right='off') std = True legendHandles = [] keys = ['epsall_lin', 'mini_lin', 'epsall_gb2', 'mini_gb2', 'epsall_gb5', 'mini_gb5', 'lin'] for k in keys: params = [] mus = [] stds = [] for (k1,v1) in D1[0].items(): if k1.find(k) == 0 and len(D1[0][k1]) != 0: x = np.arange(100, 10*len(D1[0][k1][0])+1, 100) mus.append(np.mean(D1[0][k1],axis=0)[9::10]/x) stds.append(2/np.sqrt(len(D1[0][k1]))*(np.std(D1[0][k1],axis=0)[9::10]/x)) params.append(k1.split("_")[-1]) if len(mus) == 0: continue A = np.vstack(mus) B = np.vstack(stds) ids = np.argmax(A, axis=0) mu = np.array([A[ids[i], i] for i in range(len(ids))]) stdev = np.array([B[ids[i], i] for i in range(len(ids))]) if k == 'mini_gb5': mu = np.mean(D1[0]['mini_gb5_0.008'], axis=0)[9::10]/x stdev = 2/np.sqrt(len(D1[0]['mini_gb5_0.008']))*(np.std(D1[0]['mini_gb5_0.008'], axis=0)[9::10]/x) l1 = ax1.plot(x,mu,rasterized=True, linewidth=2.0, label=Names[k], color=Styles[k][0], linestyle=Styles[k][1]) legendHandles.append((matplotlib.patches.Patch(color=l1[0].get_color(), label=Names[k]), Names[k])) if std and k=='mini_gb5' or k=='lin': ax1.fill_between(x, mu - stdev, mu + stdev, color = l1[0].get_color(), alpha=0.2, rasterized = True) for k in keys: params = [] mus = [] stds = [] for (k1,v1) in D2[0].items(): if k1.find(k) == 0 and len(D2[0][k1]) != 0: x = np.arange(100, 10*len(D2[0][k1][0])+1, 100) mus.append(np.mean(D2[0][k1],axis=0)[9::10]/x) stds.append(2/np.sqrt(len(D2[0][k1]))*(np.std(D2[0][k1],axis=0)[9::10]/x)) params.append(k1.split("_")[-1]) if len(mus) == 0: continue A = np.vstack(mus) B = np.vstack(stds) ids = np.argmax(A, axis=0) mu = np.array([A[ids[i], i] for i in range(len(ids))]) stdev = np.array([B[ids[i], i] for i in range(len(ids))]) if k == 'mini_gb5': mu = np.mean(D2[0]['mini_gb5_0.008'], axis=0)[9::10]/x stdev = 2/np.sqrt(len(D2[0]['mini_gb5_0.008']))*(np.std(D2[0]['mini_gb5_0.008'], axis=0)[9::10]/x) l1 = ax2.plot(x,mu,rasterized=True, linewidth=2.0, label=Names[k], color=Styles[k][0], linestyle=Styles[k][1]) if std and k=='mini_gb5' or k=='lin': ax2.fill_between(x, mu - stdev, mu + stdev, color = l1[0].get_color(), alpha=0.2, rasterized = True) plt.rc('font', size=18) plt.rcParams['text.usetex'] = True plt.rc('font', family='sans-serif') ## Ax1 is MSLR ticks=ax1.get_yticks() print(ticks) ax1.set_ylim(2.15, 2.35) print("Setting ylim to %0.2f, %0.2f" % (ticks[3], ticks[len(ticks)-2])) ticks = ax1.get_yticks() print(ticks) ticks = ["", "", "2.2", "", "2.3", ""] ax1.set_yticklabels(ticks,size=20) ticks = ['', '', '10000', '', '20000', '', '30000'] ax1.set_xlim(1000, 31000) ax1.set_xticklabels(ticks,size=20) # Ax2 is Yahoo! ticks=ax2.get_yticks() print(ticks) ax2.set_ylim(2.90,3.12) print("Setting ylim to %0.2f, %0.2f" % (ticks[3], 3.15)) ticks=ax2.get_yticks() print(ticks) ticks = ["", "2.9", "", "3.0", "", "3.1"] ax2.set_yticklabels(ticks,size=20) ticks = ['', '', '10000', '', '20000', '', '30000'] ax2.set_xlim(1000, 32000) ax2.set_xticklabels(ticks,size=20) plt.sca(ax) plt.ylabel('Average reward') plt.xlabel('Number of interactions (T)') leg = ax2.legend([x[1] for x in legendHandles], loc='upper center', bbox_to_anchor=(-0.1, -0.15), fancybox=False, shadow=False, ncol=7, frameon=False,fontsize=18) for legobj in leg.legendHandles: legobj.set_linewidth(4.0) plt.sca(ax1) tt1 = plt.title('Dataset: MSLR',fontsize=18) tt1.set_position([0.5, 1.02]) plt.sca(ax2) tt2 = plt.title('Dataset: Yahoo!',fontsize=18) tt2.set_position([0.5, 1.02]) plt.gcf().subplots_adjust(bottom=0.25) if Args.save: plt.savefig("../figs/plots_grouped.png", format='png', dpi=100, bbox_inches='tight') plt.savefig("../figs/plots_grouped.pdf", format='pdf', dpi=100, bbox_inches='tight') else: plt.show() ## (DONE) No band ## (DONE) markers + update legend ## (DONE) No legend frame ## (DONE) font is too big ## space between title and plot ## space between ylabel and yticks ## Get P-values (paired ttest and regular ttest)

import pickle import matplotlib.pyplot as plt import matplotlib.patches import matplotlib as mpl import numpy as np import sys, argparse sys.path.append("../") import Plotting Names = { 'mini_gb2': 'VC-GB2', 'mini_gb5': 'VC-GB5', 'mini_lin': 'VC-Lin', 'epsall_gb2': '$\epsilon$-GB2', 'epsall_gb5': '$\epsilon$-GB5', 'epsall_lin': '$\epsilon$-Lin', 'lin': 'LinUCB' } Styles = { 'mini_gb2': ['k', 'solid'], 'mini_gb5': ['r', 'solid'], 'mini_lin': ['g', 'solid'], 'epsall_gb2': ['k', 'dashed'], 'epsall_gb5': ['r', 'dashed'], 'epsall_lin': ['g', 'dashed'], 'lin': ['b', 'solid'] } parser = argparse.ArgumentParser() parser.add_argument('--save', dest='save', action='store_true') Args = parser.parse_args(sys.argv[1:]) D1 = Plotting.read_dir("../results/mslr30k_T=36000_L=3_e=0.1/") D2 = Plotting.read_dir("../results/yahoo_T=40000_L=2_e=0.5/") print(mpl.rcParams['figure.figsize']) fig = plt.figure(figsize=(mpl.rcParams['figure.figsize'][0]*2, mpl.rcParams['figure.figsize'][1]-1)) ax = fig.add_subplot(111,frameon=False) ax1 = fig.add_subplot(121) ax2 = fig.add_subplot(122) ax.spines['top'].set_color('none') ax.spines['bottom'].set_color('none') ax.spines['left'].set_color('none') ax.spines['right'].set_color('none') ax.tick_params(labelcolor='none', top='off', bottom='off', left='off', right='off') std = True legendHandles = [] keys = ['epsall_lin', 'mini_lin', 'epsall_gb2', 'mini_gb2', 'epsall_gb5', 'mini_gb5', 'lin'] for k in keys: params = [] mus = [] stds = [] for (k1,v1) in D1[0].items(): if k1.find(k) == 0 and len(D1[0][k1]) != 0: x = np.arange(100, 10*len(D1[0][k1][0])+1, 100) mus.append(np.mean(D1[0][k1],axis=0)[9::10]/x) stds.append(2/np.sqrt(len(D1[0][k1]))*(np.std(D1[0][k1],axis=0)[9::10]/x)) params.append(k1.split("_")[-1]) if len(mus) == 0: continue A = np.vstack(mus) B = np.vstack(stds) ids = np.argmax(A, axis=0) mu = np.array([A[ids[i], i] for i in range(len(ids))]) stdev = np.array([B[ids[i], i] for i in range(len(ids))]) if k == 'mini_gb5': mu = np.mean(D1[0]['mini_gb5_0.008'], axis=0)[9::10]/x stdev = 2/np.sqrt(len(D1[0]['mini_gb5_0.008']))*(np.std(D1[0]['mini_gb5_0.008'], axis=0)[9::10]/x) l1 = ax1.plot(x,mu,rasterized=True, linewidth=2.0, label=Names[k], color=Styles[k][0], linestyle=Styles[k][1]) legendHandles.append((matplotlib.patches.Patch(color=l1[0].get_color(), label=Names[k]), Names[k])) if std and k=='mini_gb5' or k=='lin': ax1.fill_between(x, mu - stdev, mu + stdev, color = l1[0].get_color(), alpha=0.2, rasterized = True) for k in keys: params = [] mus = [] stds = [] for (k1,v1) in D2[0].items(): if k1.find(k) == 0 and len(D2[0][k1]) != 0: x = np.arange(100, 10*len(D2[0][k1][0])+1, 100) mus.append(np.mean(D2[0][k1],axis=0)[9::10]/x) stds.append(2/np.sqrt(len(D2[0][k1]))*(np.std(D2[0][k1],axis=0)[9::10]/x)) params.append(k1.split("_")[-1]) if len(mus) == 0: continue A = np.vstack(mus) B = np.vstack(stds) ids = np.argmax(A, axis=0) mu = np.array([A[ids[i], i] for i in range(len(ids))]) stdev = np.array([B[ids[i], i] for i in range(len(ids))]) if k == 'mini_gb5': mu = np.mean(D2[0]['mini_gb5_0.008'], axis=0)[9::10]/x stdev = 2/np.sqrt(len(D2[0]['mini_gb5_0.008']))*(np.std(D2[0]['mini_gb5_0.008'], axis=0)[9::10]/x) l1 = ax2.plot(x,mu,rasterized=True, linewidth=2.0, label=Names[k], color=Styles[k][0], linestyle=Styles[k][1]) if std and k=='mini_gb5' or k=='lin': ax2.fill_between(x, mu - stdev, mu + stdev, color = l1[0].get_color(), alpha=0.2, rasterized = True) plt.rc('font', size=18) plt.rcParams['text.usetex'] = True plt.rc('font', family='sans-serif') ## Ax1 is MSLR ticks=ax1.get_yticks() print(ticks) ax1.set_ylim(2.15, 2.35) print("Setting ylim to %0.2f, %0.2f" % (ticks[3], ticks[len(ticks)-2])) ticks = ax1.get_yticks() print(ticks) ticks = ["", "", "2.2", "", "2.3", ""] ax1.set_yticklabels(ticks,size=20) ticks = ['', '', '10000', '', '20000', '', '30000'] ax1.set_xlim(1000, 31000) ax1.set_xticklabels(ticks,size=20) # Ax2 is Yahoo! ticks=ax2.get_yticks() print(ticks) ax2.set_ylim(2.90,3.12) print("Setting ylim to %0.2f, %0.2f" % (ticks[3], 3.15)) ticks=ax2.get_yticks() print(ticks) ticks = ["", "2.9", "", "3.0", "", "3.1"] ax2.set_yticklabels(ticks,size=20) ticks = ['', '', '10000', '', '20000', '', '30000'] ax2.set_xlim(1000, 32000) ax2.set_xticklabels(ticks,size=20) plt.sca(ax) plt.ylabel('Average reward') plt.xlabel('Number of interactions (T)') leg = ax2.legend([x[1] for x in legendHandles], loc='upper center', bbox_to_anchor=(-0.1, -0.15), fancybox=False, shadow=False, ncol=7, frameon=False,fontsize=18) for legobj in leg.legendHandles: legobj.set_linewidth(4.0) plt.sca(ax1) tt1 = plt.title('Dataset: MSLR',fontsize=18) tt1.set_position([0.5, 1.02]) plt.sca(ax2) tt2 = plt.title('Dataset: Yahoo!',fontsize=18) tt2.set_position([0.5, 1.02]) plt.gcf().subplots_adjust(bottom=0.25) if Args.save: plt.savefig("../figs/plots_grouped.png", format='png', dpi=100, bbox_inches='tight') plt.savefig("../figs/plots_grouped.pdf", format='pdf', dpi=100, bbox_inches='tight') else: plt.show() ## (DONE) No band ## (DONE) markers + update legend ## (DONE) No legend frame ## (DONE) font is too big ## space between title and plot ## space between ylabel and yticks ## Get P-values (paired ttest and regular ttest)

010b5e0043bc5876ab1a0b032ec3c37d63f3d2ba

py

Python

pacmill/filtering/mothur_uchime.py

xapple/pacmill

1fde2316968251eaaf72618fd3d104ba524d6d12

pacmill/filtering/mothur_uchime.py

xapple/pacmill

1fde2316968251eaaf72618fd3d104ba524d6d12

pacmill/filtering/mothur_uchime.py

xapple/pacmill

1fde2316968251eaaf72618fd3d104ba524d6d12

#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Written by Lucas Sinclair. MIT Licensed. Contact at www.sinclair.bio """ # Built-in modules # import os # First party modules # from fasta import FASTQ from plumbing.check_cmd_found import check_cmd from plumbing.cache import property_cached from autopaths.tmp_path import new_temp_dir, new_temp_path # Third party modules # import sh ############################################################################### class MothurUchime: """ Takes care of detecting and removing chimeric reads, by calling `mothur.uchime` as seen in: https://github.com/novigit/broCode/blob/master/pbamp/readCurationPipeline.sh#L103 mothur "#chimera.uchime(fasta=roi.$sample.rhq.trim.fwdrev.pol.fasta, reference=self, chunks=16, abskew=1, chimealns=T)" mothur "#remove.seqs(fasta=roi.$sample.rhq.trim.fwdrev.pol.fasta, accnos=roi.$sample.rhq.trim.fwdrev.pol.denovo.uchime.accnos)" In case of missing output see: https://forum.mothur.org/t/chimera-uchime-does-not-produce-any-output/20621 """ #------------------------------ Running ----------------------------------# #------------------------------- Results ---------------------------------# def __bool__(self): """ Return True if the chimeras software was run already and the results are stored on the filesystem. Return False if it was not yet run. """ return self.dest.exists @property_cached ############################################################################### class ChimerasResults(FASTQ): """A file with the results from chimeras.""" pass

#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Written by Lucas Sinclair. MIT Licensed. Contact at www.sinclair.bio """ # Built-in modules # import os # First party modules # from fasta import FASTQ from plumbing.check_cmd_found import check_cmd from plumbing.cache import property_cached from autopaths.tmp_path import new_temp_dir, new_temp_path # Third party modules # import sh ############################################################################### class MothurUchime: """ Takes care of detecting and removing chimeric reads, by calling `mothur.uchime` as seen in: https://github.com/novigit/broCode/blob/master/pbamp/readCurationPipeline.sh#L103 mothur "#chimera.uchime(fasta=roi.$sample.rhq.trim.fwdrev.pol.fasta, reference=self, chunks=16, abskew=1, chimealns=T)" mothur "#remove.seqs(fasta=roi.$sample.rhq.trim.fwdrev.pol.fasta, accnos=roi.$sample.rhq.trim.fwdrev.pol.denovo.uchime.accnos)" In case of missing output see: https://forum.mothur.org/t/chimera-uchime-does-not-produce-any-output/20621 """ def __repr__(self): msg = '<%s object on "%s">' return msg % (self.__class__.__name__, self.source.path) def __init__(self, source, dest=None): # Source is the FASTA or FASTQ file # self.source = FASTQ(source) # Destination is a FASTQ file that contains the results # if dest is None: dest = self.source.prefix_path + '.chimeras.fastq' self.dest = FASTQ(dest) #------------------------------ Running ----------------------------------# def __call__(self, verbose=True): # Message # if verbose: print("Running chimeras detection on '%s'" % self.source) # Check it is installed # check_cmd('mothur', True) # Check version # assert "1.42.1" in sh.mothur('--version') # Make new temporary directory # tmp_dir = new_temp_dir() source = tmp_dir + 'reads.fasta' # If the input is a FASTQ we need to make a FASTA first # if self.source.endswith('fastq'): FASTQ(self.source).to_fasta(source) else: self.source.copy_to(source) # Make the long command as a string # command = "#chimera.uchime(" \ "fasta=%s," \ "reference=self," \ "chunks=16," \ "chimealns=T," \ "abskew=1)" # Mothur pollutes with so much files, have to cwd # current_dir = os.getcwd() os.chdir(tmp_dir) # Run the command on the input FASTA file # sh.mothur(command % source) # Restore current directory # os.chdir(current_dir) # Move files # pass #TODO # Return # return self.dest #------------------------------- Results ---------------------------------# def __bool__(self): """ Return True if the chimeras software was run already and the results are stored on the filesystem. Return False if it was not yet run. """ return self.dest.exists @property_cached def results(self): # Check it was run # if not self: msg = "You can't access results from chimeras " \ "before running the tool." raise Exception(msg) # Return the results # return ChimerasResults(self.dest) ############################################################################### class ChimerasResults(FASTQ): """A file with the results from chimeras.""" pass

098723ab33dce0dbfff39bd8321132e24734ccf0

py

Python

olypy/oio.py

akhand2222/olypy

d2b62a590c416a7d919e6e7bfcabf35873bc13c4

olypy/oio.py

akhand2222/olypy

d2b62a590c416a7d919e6e7bfcabf35873bc13c4

olypy/oio.py

akhand2222/olypy

d2b62a590c416a7d919e6e7bfcabf35873bc13c4

''' Read and write Olympia state files. ''' import os import os.path import sys from contextlib import redirect_stdout from .oid import to_oid from .formatters import print_one_thing, read_oly_file def fixup_ms(data): ''' For whatever reason, the value in IM/ms needs to have a trailing space ''' for box in data: if 'IM' in data[box]: if 'ms' in data[box]['IM']: value = data[box]['IM']['ms'] value[0] = value[0].strip() + ' ' data[box]['IM']['ms'] = value def write_oly_file(data, kind=False, verbose=False): ''' The main function that drives outputting a file ''' fixup_ms(data) order = sorted([int(box) for box in data.keys()]) count = 0 for box in order: box = str(box) if kind: if ' '+kind+' ' not in data[box].get('firstline', '')[0]: continue print_one_thing(data[box]) del data[box] count += 1 if verbose: print('wrote', count, verbose, 'boxes.', file=sys.stderr) def read_players(dir, verbose=False): ''' read every fie in dir whose name is an integer ''' ret = {} files = os.listdir(dir) for name in files: if name.isdigit(): data = read_oly_file(os.path.join(dir, name), verbose='player ' + name) ret.update(data) return ret

''' Read and write Olympia state files. ''' import os import os.path import sys from contextlib import redirect_stdout from .oid import to_oid from .formatters import print_one_thing, read_oly_file def fixup_ms(data): ''' For whatever reason, the value in IM/ms needs to have a trailing space ''' for box in data: if 'IM' in data[box]: if 'ms' in data[box]['IM']: value = data[box]['IM']['ms'] value[0] = value[0].strip() + ' ' data[box]['IM']['ms'] = value def write_oly_file(data, kind=False, verbose=False): ''' The main function that drives outputting a file ''' fixup_ms(data) order = sorted([int(box) for box in data.keys()]) count = 0 for box in order: box = str(box) if kind: if ' '+kind+' ' not in data[box].get('firstline', '')[0]: continue print_one_thing(data[box]) del data[box] count += 1 if verbose: print('wrote', count, verbose, 'boxes.', file=sys.stderr) def write_player(data, box, verbose=False): player_box = box boxlist = data[box].get('PL', {}).get('un', {}) print_one_thing(data[box]) del data[box] count = 0 for box in boxlist: print_one_thing(data[box]) del data[box] count += 1 if verbose: print('wrote', count, 'characters for player', to_oid(int(player_box)), file=sys.stderr) def read_players(dir, verbose=False): ''' read every fie in dir whose name is an integer ''' ret = {} files = os.listdir(dir) for name in files: if name.isdigit(): data = read_oly_file(os.path.join(dir, name), verbose='player ' + name) ret.update(data) return ret def write_players(data, dir, verbose=False): boxlist = list(data.keys()) # we're deleting as we go for box in boxlist: if data.get(box) is None: continue if ' player ' in data[box]['firstline'][0]: fact = os.path.join(dir, 'fact') if not os.path.isdir(fact): os.mkdir(fact) filename = os.path.join(dir, 'fact', box) with open(filename, 'w') as f: with redirect_stdout(f): write_player(data, box, verbose=verbose) def write_system_file(data): fr = None lt = 1 tr = None ur = None hr = None hp = None nr = None nl = None cr = None for k, v in data.items(): fl = v['firstline'][0] try: na = v['na'][0] except KeyError: na = '' if ' player pl_regular' in fl: lt = max(lt, int(v['PL']['lt'][0])) if fr is None and ' loc region' in fl and na == 'Faery': if v.get('LI', {}).get('hl'): fr = k else: fr = 0 if tr is None and ' loc region' in fl and na == 'Undercity': if data[k].get('LI', {}).get('hl'): tr = k else: tr = 0 if ur is None and ' loc region' in fl and na == 'Subworld': if data[k].get('LI', {}).get('hl'): ur = k else: ur = 0 if hr is None and ' loc region' in fl and na == 'Hades': if data[k].get('LI', {}).get('hl'): hr = k else: hr = 0 if hp is None and fl.endswith(' loc pit'): # normal pits are 'pits' hp = k if nr is None and ' loc region' in fl and na == 'Nowhere': nr = k nl = v['LI']['hl'][0] if cr is None and ' loc region' in fl and na == 'Cloudlands': if data[k].get('LI', {}).get('hl'): cr = k else: cr = 0 if hp is None: # not surprising for a player sim # if I wanted to do this right I have to also create City of the Dead in a provinces. # fake it. hp = hr days_per_month = 30 days_since_epoch = lt * days_per_month system = '''sysclock: {} {} {} indep_player=100 gm_player=200 skill_player=202 from_host=foo@example.com reply_host=foo@example.com game_title=SIMULATION post=1 init=1 fr={} tr={} ur={} fp=204 hr={} hp={} hl=205 nr={} nl={} np=206 cr={} cp=210 '''.format(lt, days_per_month, days_since_epoch, fr, tr, ur, hr, hp, nr, nl, cr) if 'None' in system: raise ValueError('failed to find some stuff for system:\n' + system) print(system) def read_lib(libdir): if not os.path.isdir(libdir): raise ValueError('libdir {} is not a directory'.format(libdir)) data = read_oly_file(os.path.join(libdir, 'loc'), verbose='loc') data.update(read_oly_file(os.path.join(libdir, 'item'), verbose='item')) data.update(read_oly_file(os.path.join(libdir, 'skill'), verbose='skill')) data.update(read_oly_file(os.path.join(libdir, 'gate'), verbose='gate')) data.update(read_oly_file(os.path.join(libdir, 'road'), verbose='road')) data.update(read_oly_file(os.path.join(libdir, 'ship'), verbose='ship')) data.update(read_oly_file(os.path.join(libdir, 'unform'), verbose='unform')) data.update(read_oly_file(os.path.join(libdir, 'misc'), verbose='misc')) data.update(read_players(os.path.join(libdir, 'fact'), verbose=True)) return data def write_lib(data, libdir): if os.path.exists(libdir): if not os.path.isdir(libdir): raise ValueError('libdir {} is not a directory'.format(libdir)) else: os.mkdir(libdir) with open(os.path.join(libdir, 'system'), 'w') as f: with redirect_stdout(f): write_system_file(data) with open(os.path.join(libdir, 'loc'), 'w') as f: with redirect_stdout(f): write_oly_file(data, kind='loc', verbose='loc') with open(os.path.join(libdir, 'item'), 'w') as f: with redirect_stdout(f): write_oly_file(data, kind='item', verbose='item') with open(os.path.join(libdir, 'skill'), 'w') as f: with redirect_stdout(f): write_oly_file(data, kind='skill', verbose='skill') with open(os.path.join(libdir, 'gate'), 'w') as f: with redirect_stdout(f): write_oly_file(data, kind='gate', verbose='gate') with open(os.path.join(libdir, 'road'), 'w') as f: with redirect_stdout(f): write_oly_file(data, kind='road', verbose='road') with open(os.path.join(libdir, 'ship'), 'w') as f: with redirect_stdout(f): write_oly_file(data, kind='ship', verbose='ship') with open(os.path.join(libdir, 'unform'), 'w') as f: with redirect_stdout(f): write_oly_file(data, kind='unform', verbose='unform') write_players(data, libdir, verbose=True) with open(os.path.join(libdir, 'misc'), 'w') as f: with redirect_stdout(f): write_oly_file(data, verbose='misc') # catchall

4ec1d714cb3bf6af4fe8c713411aefe484a53f23

py

Python

flat/announce/migrations/0002_auto_20150916_0830.py

bilbeyt/ITURO-Giant_Flat

5a3f766ab1394cefd3589a30c07b5a68b48be00e

flat/announce/migrations/0002_auto_20150916_0830.py

bilbeyt/ITURO-Giant_Flat

5a3f766ab1394cefd3589a30c07b5a68b48be00e

flat/announce/migrations/0002_auto_20150916_0830.py

bilbeyt/ITURO-Giant_Flat

5a3f766ab1394cefd3589a30c07b5a68b48be00e

# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import models, migrations

# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import models, migrations class Migration(migrations.Migration): dependencies = [ ('announce', '0001_initial'), ] operations = [ migrations.RenameField( model_name='announce', old_name='content', new_name='content_en', ), migrations.AddField( model_name='announce', name='content_tr', field=models.CharField(default=1, max_length=100), preserve_default=False, ), ]

b8458625ce4634483d199c8fcd5007dd84bf4c6b

py

Python

CondTools/L1Trigger/python/L1ConfigTSCPayloads_cff.py

ckamtsikis/cmssw

ea19fe642bb7537cbf58451dcf73aa5fd1b66250

2015-01-11T21:03:51.000Z

2022-03-25T21:14:00.000Z

CondTools/L1Trigger/python/L1ConfigTSCPayloads_cff.py

ckamtsikis/cmssw

ea19fe642bb7537cbf58451dcf73aa5fd1b66250

2015-01-02T00:14:40.000Z

2022-03-31T23:26:05.000Z

CondTools/L1Trigger/python/L1ConfigTSCPayloads_cff.py

ckamtsikis/cmssw

ea19fe642bb7537cbf58451dcf73aa5fd1b66250

2015-01-02T05:53:18.000Z

2022-03-31T17:24:21.000Z

from L1TriggerConfig.CSCTFConfigProducers.CSCTFConfigOnline_cfi import * #from L1TriggerConfig.CSCTFConfigProducers.CSCTFAlignmentOnline_cfi import * from L1TriggerConfig.CSCTFConfigProducers.L1MuCSCPtLutConfigOnline_cfi import * from L1TriggerConfig.DTTrackFinder.L1MuDTEtaPatternLutOnline_cfi import * from L1TriggerConfig.DTTrackFinder.L1MuDTExtLutOnline_cfi import * from L1TriggerConfig.DTTrackFinder.L1MuDTPhiLutOnline_cfi import * from L1TriggerConfig.DTTrackFinder.L1MuDTPtaLutOnline_cfi import * from L1TriggerConfig.DTTrackFinder.L1MuDTQualPatternLutOnline_cfi import * from L1TriggerConfig.DTTrackFinder.L1MuDTTFParametersOnline_cfi import * from L1TriggerConfig.RPCTriggerConfig.L1RPCConfigOnline_cfi import * from L1TriggerConfig.RPCTriggerConfig.L1RPCConeDefinitionOnline_cfi import * from L1TriggerConfig.RPCTriggerConfig.L1RPCBxOrConfigOnline_cfi import * from L1TriggerConfig.RPCTriggerConfig.L1RPCHsbConfigOnline_cfi import * from L1TriggerConfig.GMTConfigProducers.L1MuGMTParametersOnlineProducer_cfi import * from L1TriggerConfig.L1ScalesProducers.L1MuTriggerPtScaleOnlineProducer_cfi import * from L1TriggerConfig.L1ScalesProducers.L1MuTriggerScalesOnlineProducer_cfi import * L1MuGMTParametersOnlineProducer.ignoreVersionMismatch = True from L1TriggerConfig.RCTConfigProducers.L1RCTParametersOnline_cfi import * from L1TriggerConfig.L1ScalesProducers.L1EmEtScaleConfigOnline_cfi import * from L1TriggerConfig.L1ScalesProducers.L1CaloEcalScaleConfigOnline_cfi import * from L1TriggerConfig.L1ScalesProducers.L1CaloHcalScaleConfigOnline_cfi import * from L1TriggerConfig.GctConfigProducers.L1GctJetFinderParamsOnline_cfi import * from L1TriggerConfig.L1ScalesProducers.L1HtMissScaleOnline_cfi import * from L1TriggerConfig.L1ScalesProducers.L1HfRingEtScaleOnline_cfi import * from L1TriggerConfig.L1ScalesProducers.L1JetEtScaleOnline_cfi import * from L1TriggerConfig.L1GtConfigProducers.l1GtParametersOnline_cfi import * from L1TriggerConfig.L1GtConfigProducers.l1GtPsbSetupOnline_cfi import * from L1TriggerConfig.L1GtConfigProducers.l1GtTriggerMenuOnline_cfi import *

from L1TriggerConfig.CSCTFConfigProducers.CSCTFConfigOnline_cfi import * #from L1TriggerConfig.CSCTFConfigProducers.CSCTFAlignmentOnline_cfi import * from L1TriggerConfig.CSCTFConfigProducers.L1MuCSCPtLutConfigOnline_cfi import * from L1TriggerConfig.DTTrackFinder.L1MuDTEtaPatternLutOnline_cfi import * from L1TriggerConfig.DTTrackFinder.L1MuDTExtLutOnline_cfi import * from L1TriggerConfig.DTTrackFinder.L1MuDTPhiLutOnline_cfi import * from L1TriggerConfig.DTTrackFinder.L1MuDTPtaLutOnline_cfi import * from L1TriggerConfig.DTTrackFinder.L1MuDTQualPatternLutOnline_cfi import * from L1TriggerConfig.DTTrackFinder.L1MuDTTFParametersOnline_cfi import * from L1TriggerConfig.RPCTriggerConfig.L1RPCConfigOnline_cfi import * from L1TriggerConfig.RPCTriggerConfig.L1RPCConeDefinitionOnline_cfi import * from L1TriggerConfig.RPCTriggerConfig.L1RPCBxOrConfigOnline_cfi import * from L1TriggerConfig.RPCTriggerConfig.L1RPCHsbConfigOnline_cfi import * from L1TriggerConfig.GMTConfigProducers.L1MuGMTParametersOnlineProducer_cfi import * from L1TriggerConfig.L1ScalesProducers.L1MuTriggerPtScaleOnlineProducer_cfi import * from L1TriggerConfig.L1ScalesProducers.L1MuTriggerScalesOnlineProducer_cfi import * L1MuGMTParametersOnlineProducer.ignoreVersionMismatch = True from L1TriggerConfig.RCTConfigProducers.L1RCTParametersOnline_cfi import * from L1TriggerConfig.L1ScalesProducers.L1EmEtScaleConfigOnline_cfi import * from L1TriggerConfig.L1ScalesProducers.L1CaloEcalScaleConfigOnline_cfi import * from L1TriggerConfig.L1ScalesProducers.L1CaloHcalScaleConfigOnline_cfi import * from L1TriggerConfig.GctConfigProducers.L1GctJetFinderParamsOnline_cfi import * from L1TriggerConfig.L1ScalesProducers.L1HtMissScaleOnline_cfi import * from L1TriggerConfig.L1ScalesProducers.L1HfRingEtScaleOnline_cfi import * from L1TriggerConfig.L1ScalesProducers.L1JetEtScaleOnline_cfi import * from L1TriggerConfig.L1GtConfigProducers.l1GtParametersOnline_cfi import * from L1TriggerConfig.L1GtConfigProducers.l1GtPsbSetupOnline_cfi import * from L1TriggerConfig.L1GtConfigProducers.l1GtTriggerMenuOnline_cfi import *

9290a51e42313a8d3b64495f00e57922277cdd9a

py

Python

powerdnsadmin/models/domain_template_record.py

warf/PowerDNS-Admin

3bf6e6e9f119d2af7f2faff46c41a2152b84d3ab

2019-12-31T04:51:02.000Z

2019-12-31T04:51:02.000Z

powerdnsadmin/models/domain_template_record.py

warf/PowerDNS-Admin

3bf6e6e9f119d2af7f2faff46c41a2152b84d3ab

2021-03-11T06:55:41.000Z

2021-03-11T06:55:41.000Z

powerdnsadmin/models/domain_template_record.py

warf/PowerDNS-Admin

3bf6e6e9f119d2af7f2faff46c41a2152b84d3ab

from .base import db

from .base import db class DomainTemplateRecord(db.Model): __tablename__ = "domain_template_record" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255)) type = db.Column(db.String(64)) ttl = db.Column(db.Integer) data = db.Column(db.Text) comment = db.Column(db.Text) status = db.Column(db.Boolean) template_id = db.Column(db.Integer, db.ForeignKey('domain_template.id')) template = db.relationship('DomainTemplate', back_populates='records') def __repr__(self): return '<DomainTemplateRecord {0}>'.format(self.id) def __init__(self, id=None, name=None, type=None, ttl=None, data=None, comment=None, status=None): self.id = id self.name = name self.type = type self.ttl = ttl self.data = data self.comment = comment self.status = status def apply(self): try: db.session.commit() except Exception as e: logging.error( 'Can not update domain template table. Error: {0}'.format(e)) db.session.rollback() return { 'status': 'error', 'msg': 'Can not update domain template table' }

884efdb2fa9981926fc3d98ed7f25106e9e285d7

py

Python

test/math/TestUniverse.py

pulsar-chem/BPModule

f8e64e04fdb01947708f098e833600c459c2ff0e

test/math/TestUniverse.py

pulsar-chem/BPModule

f8e64e04fdb01947708f098e833600c459c2ff0e

test/math/TestUniverse.py

pulsar-chem/BPModule

f8e64e04fdb01947708f098e833600c459c2ff0e

import pulsar as psr

import pulsar as psr def run_test(): tester = psr.PyTester("Testing Universe Python Interface") #Constructors and assignment U0, U1=psr.DoubleUniverse(),psr.DoubleUniverse() tester.test_equal("Default constructor",U0,U1) U2=psr.DoubleUniverse([1.0,2.0,3.0]) U3=psr.DoubleUniverse([1.0,2.0,3.0]) tester.test_equal("Variadic initializer",U2,U3); U4=psr.DoubleUniverse(U3); tester.test_equal("Copy constructor",U3,U4); U0=U2; tester.test_equal("Assignment",U0,U3); #Basic properties tester.test_return("Size",True,3,U0.size) tester.test_return("Count",True,True,U0.count,1.0) tester.test_return("Get index",True,2,U3.idx,3.0) tester.test_call("Get non-existant index",False,U3.idx,5.0) tester.test_return("Get hash U0",True,U0.my_hash(),U3.my_hash) tester.test_return("Get hash U3",True,U0.my_hash(),U4.my_hash) #Element access/modification tester.test_return("Subscript operator",True,3.0,U0.__getitem__,2) tester.test_call("Subscript operator (out of range)",False,U0.__getitem__,9) tester.test_return("at function",True,3.0,U0.at,2) tester.test_call("at function (out of range)",False,U0.at,9) U0.insert(4.0) tester.test_return("insert elements",True,U0,U3.insert,4.0) #U0=U3=1-4; U1=empty; U2=U4=1-3 #Set operations U5=psr.DoubleUniverse([4.0,5.0,6.0]) U8=psr.DoubleUniverse([1.0,2.0,3.0,4.0,5.0,6.0]) tester.test_return("union assign",True,U8,U0.union_assign,U5) tester.test_return("union",True,U8,U3.set_union,U5) U9=psr.DoubleUniverse([1.0,2.0]) U10=psr.DoubleUniverse([1.0,2.0,15.0,16.0]) tester.test_return("intersection assign",True,U9,U0.intersection_assign,U10) print(U10) tester.test_return("intersection",True,U9,U3.intersection,U10) U11=psr.DoubleUniverse([3.0,4.0,5.0,6.0]) tester.test_return("difference",True,U11,U8.difference,U9) tester.test_return("difference assign",True,U11,U8.difference_assign,U9) #Comparison operators tester.test_return("not equal",True,True,U9.__ne__,U11) tester.test_return("superset equal",True,True,U11.is_superset_of,U8) tester.test_return("superset true",True,True,U10.is_superset_of,U9) tester.test_return("superset false",True,False,U9.is_superset_of,U10) tester.test_return("proper superset equal",True,False,U11.is_proper_superset_of,U8) tester.test_return("proper supserset true",True,True,U10.is_proper_superset_of,U9) tester.test_return("proper superset false",True,False,U9.is_proper_superset_of,U10) tester.test_return("subset equal",True,True,U11.is_subset_of,U8) tester.test_return("subset true",True,True,U9.is_subset_of,U10) tester.test_return("subset false",True,False,U10.is_subset_of,U9) tester.test_return("proper subset equal",True,False,U11.is_proper_subset_of,U8) tester.test_return("proper subset true",True,True,U9.is_proper_subset_of,U10) tester.test_return("proper subset false",True,False,U10.is_proper_subset_of,U9) tester.print_results() return tester.nfailed()

9215d936336e65cb6f3b980e5620414869829e05

py

Python

orchard/system_status/__init__.py

BMeu/Orchard

cd595c9942e4e1ad0032193059f2b39fdf3bcfba

2016-10-06T21:19:32.000Z

2016-10-06T21:58:04.000Z

orchard/system_status/__init__.py

BMeu/Orchard

cd595c9942e4e1ad0032193059f2b39fdf3bcfba

2016-10-06T17:13:30.000Z

2021-01-15T04:15:38.000Z

orchard/system_status/__init__.py

BMeu/Orchard

cd595c9942e4e1ad0032193059f2b39fdf3bcfba

# -*- coding: utf-8 -*- """ This package includes the Flask blueprint and all related functionality for displaying system information. """ from .blueprint import blueprint from .status_item import StatusItem from .status_group import StatusGroup import orchard.system_status.views # NOQA __all__ = ['blueprint', 'StatusGroup', 'StatusItem']

# -*- coding: utf-8 -*- """ This package includes the Flask blueprint and all related functionality for displaying system information. """ from .blueprint import blueprint from .status_item import StatusItem from .status_group import StatusGroup import orchard.system_status.views # NOQA __all__ = ['blueprint', 'StatusGroup', 'StatusItem']

e1f06e37830afaf38b03d65459b500198005e166

py

Python

PP4E/Examples/PP4E/Integrate/Embed/prioredition-2x/Inventory/validate1.py

BeacherHou/Python-_Markdown-

015d79a02d32f49395b80ca10919b3a09b72c4df

PP4E/Examples/PP4E/Integrate/Embed/prioredition-2x/Inventory/validate1.py

BeacherHou/Python-_Markdown-

015d79a02d32f49395b80ca10919b3a09b72c4df

PP4E/Examples/PP4E/Integrate/Embed/prioredition-2x/Inventory/validate1.py

BeacherHou/Python-_Markdown-

015d79a02d32f49395b80ca10919b3a09b72c4df

# embedded validation code, run from C # input vars: PRODUCT, QUANTITY, BUYER # output vars: ERRORS, WARNINGS import string # all python tools are available to embedded code import inventory # plus C extensions, Python modules, classes,.. msgs, errs = [], [] # warning, error message lists first, last = BUYER[0], BUYER[1:] # code is changeable on-site: if first not in string.uppercase: # this file is run as one long errs.append('buyer-name:' + first) # code-string, with input and if BUYER not in inventory.buyers(): # output vars used by the C app msgs.append('new-buyer-added') inventory.add_buyer(BUYER) validate_order() ERRORS = ' '.join(errs) # add a space between messages WARNINGS = ' '.join(msgs) # pass out as strings: "" == none

# embedded validation code, run from C # input vars: PRODUCT, QUANTITY, BUYER # output vars: ERRORS, WARNINGS import string # all python tools are available to embedded code import inventory # plus C extensions, Python modules, classes,.. msgs, errs = [], [] # warning, error message lists def validate_order(): if PRODUCT not in inventory.skus(): # this function could be imported errs.append('bad-product') # from a user-defined module too elif QUANTITY > inventory.stock(PRODUCT): errs.append('check-quantity') else: inventory.reduce(PRODUCT, QUANTITY) if inventory.stock(PRODUCT) / QUANTITY < 2: msgs.append('reorder-soon:' + `PRODUCT`) first, last = BUYER[0], BUYER[1:] # code is changeable on-site: if first not in string.uppercase: # this file is run as one long errs.append('buyer-name:' + first) # code-string, with input and if BUYER not in inventory.buyers(): # output vars used by the C app msgs.append('new-buyer-added') inventory.add_buyer(BUYER) validate_order() ERRORS = ' '.join(errs) # add a space between messages WARNINGS = ' '.join(msgs) # pass out as strings: "" == none

7014bf2c3e6cadc190f879e6754e67fbb619c0e2

py

Python

examples/auracog_suggestions/sessions/sessions.py

Telefonica/clipspy

87d1d63604a209e2271efd3d3b8df0943836a504

examples/auracog_suggestions/sessions/sessions.py

Telefonica/clipspy

87d1d63604a209e2271efd3d3b8df0943836a504

examples/auracog_suggestions/sessions/sessions.py

Telefonica/clipspy

87d1d63604a209e2271efd3d3b8df0943836a504

from typing import Any, Dict, Iterable, List, Text from ..common import FeatureSet class SessionFeatureSet(FeatureSet): """ This class represents a session's set of features. """ def __init__(self, features: Dict[Text, Any], aura_id_name="AURA_ID", aura_id_global_name="AURA_ID_GLOBAL", session_id_name="SESSION_ID"): """ :param features: dictionary of features. :param aura_id_name: the name of the aura_id feature. :param aura_id_global_name: the name of the aura_id_global feature. :param session_id_name: the name of the session_id feature. """ super().__init__(features) self.aura_id_name = aura_id_name self.aura_id_global_name = aura_id_global_name self.session_id_name = session_id_name @property @property @property @classmethod def build_from_row(cls, values: List[Any], names: List[Text], aura_id_name="AURA_ID", aura_id_global_name="AURA_ID_GLOBAL"): """ Build a SessionFeaturesSet from the contents of a row (composed of a list of values and corresponding names). :param values: list of feature values. :param names: list of the corresponding names. :param aura_id_name: the name of the aura_id feature. :param aura_id_global_name: the name of the aura_id_global feature. :param session_id_name: the name of the session_id feature. """ return SessionFeatureSet(cls.build_features(values, names), aura_id_name=aura_id_name, aura_id_global_name=aura_id_global_name, session_id_name=aura_id_global_name) class SessionClusterModel(object): """ This class represents a clustering model for sessions. """ def predict(self, X: Iterable[SessionFeatureSet], **kwargs) -> List[int]: """ Predict the fittest cluster for a list of sessions. :param X: List of sessions to cluster. :return: List with the ids of the fittest clusters. """ raise NotImplementedError("{} is an abstract class and cannot be directly instantiated. " "The method predict must be implemented!".format(self.__class__)) def fit(self, X: Iterable[SessionFeatureSet], **kwargs): """ :param X: List of sessions to cluster. :param kwargs: """ raise NotImplementedError("{} is an abstract class and cannot be directly instantiated. " "The method fit must be implemented!".format(self.__class__))

from typing import Any, Dict, Iterable, List, Text from ..common import FeatureSet class SessionFeatureSet(FeatureSet): """ This class represents a session's set of features. """ def __init__(self, features: Dict[Text, Any], aura_id_name="AURA_ID", aura_id_global_name="AURA_ID_GLOBAL", session_id_name="SESSION_ID"): """ :param features: dictionary of features. :param aura_id_name: the name of the aura_id feature. :param aura_id_global_name: the name of the aura_id_global feature. :param session_id_name: the name of the session_id feature. """ super().__init__(features) self.aura_id_name = aura_id_name self.aura_id_global_name = aura_id_global_name self.session_id_name = session_id_name @property def aura_id(self): return self.get_feature(self.aura_id_name) @property def aura_id_global(self): return self.get_feature(self.aura_id_global_name) @property def session_id(self): return self.get_feature(self.session_id_name) @classmethod def build_from_row(cls, values: List[Any], names: List[Text], aura_id_name="AURA_ID", aura_id_global_name="AURA_ID_GLOBAL"): """ Build a SessionFeaturesSet from the contents of a row (composed of a list of values and corresponding names). :param values: list of feature values. :param names: list of the corresponding names. :param aura_id_name: the name of the aura_id feature. :param aura_id_global_name: the name of the aura_id_global feature. :param session_id_name: the name of the session_id feature. """ return SessionFeatureSet(cls.build_features(values, names), aura_id_name=aura_id_name, aura_id_global_name=aura_id_global_name, session_id_name=aura_id_global_name) class SessionClusterModel(object): """ This class represents a clustering model for sessions. """ def predict(self, X: Iterable[SessionFeatureSet], **kwargs) -> List[int]: """ Predict the fittest cluster for a list of sessions. :param X: List of sessions to cluster. :return: List with the ids of the fittest clusters. """ raise NotImplementedError("{} is an abstract class and cannot be directly instantiated. " "The method predict must be implemented!".format(self.__class__)) def fit(self, X: Iterable[SessionFeatureSet], **kwargs): """ :param X: List of sessions to cluster. :param kwargs: """ raise NotImplementedError("{} is an abstract class and cannot be directly instantiated. " "The method fit must be implemented!".format(self.__class__))

f4d42441b96321040a54f16e2b431bb5d1c4b18d

py

Python

include/server/bw/tools/__init__.py

spacebeam/bw

8f975a2925f309b0038c876f1234595df9798c98

2019-10-30T04:26:21.000Z

2019-10-31T17:26:59.000Z

include/server/bw/tools/__init__.py

spacebeam/bw

8f975a2925f309b0038c876f1234595df9798c98

2019-08-21T17:13:45.000Z

2020-08-06T00:38:56.000Z

include/server/bw/tools/__init__.py

spacebeam/bw

8f975a2925f309b0038c876f1234595df9798c98

# -*- coding: utf-8 -*- # This file is part of bw. # Distributed under the terms of the last AGPL License. __author__ = 'Jean Chassoul' import arrow import ujson as json import logging import uuid from tornado import gen def validate_uuid4(uuid_string): ''' Validate that a UUID string is in fact a valid uuid4. Happily, the uuid module does the actual checking for us. ''' try: val = uuid.UUID(uuid_string, version=4) except ValueError: # If it's a value error, then the string # is not a valid hex code for a UUID. return False return str(val) == uuid_string def get_average(total, marks): ''' Get average from signals ''' return float(total) / len(marks) def get_percentage(part, whole): ''' Get percentage of part and whole. ''' return "{0:.0f}%".format(float(part)/whole * 100) @gen.coroutine def check_json(struct): ''' Check for malformed JSON ''' try: message = json.loads(struct) except Exception as error: message = json.dumps({'error': 400}) raise error return message @gen.coroutine def check_times(start, end): ''' Check times ''' try: start = (arrow.get(start) if start else arrow.get(arrow.utcnow().date())) end = (arrow.get(end) if end else start.replace(days=+1)) message = {'start': start.timestamp, 'end': end.timestamp} except Exception as error: logging.exception(error) raise error return message @gen.coroutine def check_times_get_timestamp(start, end): ''' Check times get timestamp ''' try: start = (arrow.get(start) if start else arrow.get(arrow.utcnow().date())) end = (arrow.get(end) if end else start.replace(days=+1)) message = {'start': start.timestamp, 'end': end.timestamp} except Exception as error: logging.exception(error) raise error return message @gen.coroutine def check_times_get_datetime(start, end): ''' Check times get datetime ''' try: start = (arrow.get(start) if start else arrow.get(arrow.utcnow().date())) end = (arrow.get(end) if end else start.replace(days=+1)) message = {'start': start.naive, 'end': end.naive} except Exception as error: logging.exception(error) raise error return message def clean_message(struct): ''' clean message ''' struct = struct.to_native() struct = { key: struct[key] for key in struct if struct[key] is not None } return struct def clean_structure(struct): ''' clean structure ''' struct = struct.to_primitive() struct = { key: struct[key] for key in struct if struct[key] is not None } return struct def clean_results(results): ''' clean results ''' results = results.to_primitive() results = results.get('results') results = [ { key: dic[key] for key in dic if dic[key] is not None } for dic in results ] return {'results': results} def str2bool(boo): ''' String to boolean ''' return boo.lower() in ('yes', 'true', 't', '1')

# -*- coding: utf-8 -*- # This file is part of bw. # Distributed under the terms of the last AGPL License. __author__ = 'Jean Chassoul' import arrow import ujson as json import logging import uuid from tornado import gen def validate_uuid4(uuid_string): ''' Validate that a UUID string is in fact a valid uuid4. Happily, the uuid module does the actual checking for us. ''' try: val = uuid.UUID(uuid_string, version=4) except ValueError: # If it's a value error, then the string # is not a valid hex code for a UUID. return False return str(val) == uuid_string def get_average(total, marks): ''' Get average from signals ''' return float(total) / len(marks) def get_percentage(part, whole): ''' Get percentage of part and whole. ''' return "{0:.0f}%".format(float(part)/whole * 100) @gen.coroutine def check_json(struct): ''' Check for malformed JSON ''' try: message = json.loads(struct) except Exception as error: message = json.dumps({'error': 400}) raise error return message @gen.coroutine def check_times(start, end): ''' Check times ''' try: start = (arrow.get(start) if start else arrow.get(arrow.utcnow().date())) end = (arrow.get(end) if end else start.replace(days=+1)) message = {'start': start.timestamp, 'end': end.timestamp} except Exception as error: logging.exception(error) raise error return message @gen.coroutine def check_times_get_timestamp(start, end): ''' Check times get timestamp ''' try: start = (arrow.get(start) if start else arrow.get(arrow.utcnow().date())) end = (arrow.get(end) if end else start.replace(days=+1)) message = {'start': start.timestamp, 'end': end.timestamp} except Exception as error: logging.exception(error) raise error return message @gen.coroutine def check_times_get_datetime(start, end): ''' Check times get datetime ''' try: start = (arrow.get(start) if start else arrow.get(arrow.utcnow().date())) end = (arrow.get(end) if end else start.replace(days=+1)) message = {'start': start.naive, 'end': end.naive} except Exception as error: logging.exception(error) raise error return message def clean_message(struct): ''' clean message ''' struct = struct.to_native() struct = { key: struct[key] for key in struct if struct[key] is not None } return struct def clean_structure(struct): ''' clean structure ''' struct = struct.to_primitive() struct = { key: struct[key] for key in struct if struct[key] is not None } return struct def clean_results(results): ''' clean results ''' results = results.to_primitive() results = results.get('results') results = [ { key: dic[key] for key in dic if dic[key] is not None } for dic in results ] return {'results': results} def str2bool(boo): ''' String to boolean ''' return boo.lower() in ('yes', 'true', 't', '1')

2aa9e4e31a22f81d608b3540fff2696084e6a97e

py

Python

pyox/webhdfs.py

alexmilowski/webhdfs

c549f2db2f05fbe2348117870522c519c8da4613

2018-10-25T04:31:22.000Z

2021-08-05T20:12:14.000Z

pyox/webhdfs.py

alexmilowski/webhdfs

c549f2db2f05fbe2348117870522c519c8da4613

2018-02-09T08:34:08.000Z

2018-03-22T18:56:17.000Z

pyox/webhdfs.py

alexmilowski/webhdfs

c549f2db2f05fbe2348117870522c519c8da4613

2019-01-29T19:17:53.000Z

2020-12-30T15:47:17.000Z

from pyox.client import Client, ServiceError

from pyox.client import Client, ServiceError def absolute_path(path): if len(path)>0 and path[0]!='/': path = '/'+path return path class WebHDFS(Client): def __init__(self,**kwargs): super().__init__(**kwargs) self.service = 'webhdfs' self.read_chunk_size = 65536 def list_directory(self,path): path = absolute_path(path) url = '{}{}'.format(self.service_url(),path) req = self.get(url,params={'op':'LISTSTATUS'},allow_redirects=False) #print(req.url) #req = requests.get(url,auth=None) if req.status_code==200: data = req.json() result = {} for entry in data['FileStatuses']['FileStatus']: result[entry['pathSuffix']] = entry return result else: raise ServiceError(req.status_code,'Cannot access path {}'.format(path),req) def open(self,path,offset=None,length=None,buffersize=None): path = absolute_path(path) url = '{}{}?op=OPEN'.format(self.service_url(),path) if offset is not None: url += '&offset={}'.format(offset) if length is not None: url += '&length={}'.format(length) if buffersize is not None: url += '&buffersize={}'.format(buffersize) #print(url) #open_req = self.get(url) #if open_req.status_code==200: # return open_req.iter_content(chunk_size=self.read_chunk_size) open_req = self.get(url,allow_redirects=False) if open_req.status_code==307: location = open_req.headers['Location']; read_req = self.get(location,allow_redirects=False,stream=True) if read_req.status_code==200: return read_req.iter_content(chunk_size=self.read_chunk_size) else: raise ServiceError(read_req.status_code,'Cannot open datanode location {}'.format(location),read_req) else: raise ServiceError(open_req.status_code,'Cannot open path {}'.format(path),open_req) def make_directory(self,path,permission=None): path = absolute_path(path) url = '{}{}?op=MKDIRS'.format(self.service_url(),path) if permission is not None: url += '&permission={}'.format(permission) #print(url) req = self.put(url) if req.status_code!=200: raise ServiceError(req.status_code,'Cannot create path {}'.format(path),req) msg = req.json() return msg['boolean'] def move(self,sourcepath,destpath): sourcepath = absolute_path(sourcepath) destpath = absolute_path(destpath) url = '{}{}?op=RENAME&destination={}'.format(self.service_url(),sourcepath,destpath) #print(url) req = self.put(url) if req.status_code!=200: raise ServiceError(req.status_code,'Cannot move path {} to {}'.format(sourcepath,destpath),req) msg = req.json() return msg['boolean'] def remove(self,path,recursive=False): path = absolute_path(path) recursiveParam = 'true' if recursive else 'false' url = '{}{}?op=DELETE&recursive={}'.format(self.service_url(),path,recursiveParam) #print(url) req = self.delete(url) if req.status_code!=200: raise ServiceError(req.status_code,'Cannot delete path {}'.format(path),req) msg = req.json() return msg['boolean'] def status(self,path): url = '{}{}?op=GETFILESTATUS'.format(self.service_url(),absolute_path(path)) #print(url) req = self.get(url) if req.status_code!=200: raise ServiceError(req.status_code,'Cannot status path {}'.format(path),req) msg = req.json() return msg['FileStatus'] def copy(self,data,path,size=-1,overwrite=False): path = absolute_path(path) overwriteParam = 'true' if overwrite else 'false' url = '{}{}?op=CREATE&overwrite={}'.format(self.service_url(),path,overwriteParam) #print(url) headers = {} headers['Content-Type'] = 'application/octet-stream' if size >= 0: headers['Content-Length'] = str(size) open_req = self.put( url, allow_redirects=False, headers={'Content-Length' : '0'}) if open_req.status_code==307: location = open_req.headers['Location']; #print(location) req = self.put( location, data=data, headers=headers) if req.status_code!=201: raise ServiceError(req.status_code,'Cannot copy to path {}'.format(path),req) else: raise ServiceError(req.status_code,'Cannot open path {}'.format(path),open_req) return True def append(self,data,path,size=-1,buffersize=None): path = absolute_path(path) url = '{}{}?op=APPEND&overwrite={}'.format(self.service_url(),path) if buffersize is not None: url += '&buffersize={}'.format(buffersize) #print(url) open_req = self.post( url, allow_redirects=False, headers={'Content-Length' : '0'}) if open_req.status_code==307: headers = {} headers['Content-Type'] = 'application/octet-stream' if size >= 0: headers['Content-Length'] = str(size) location = open_req.headers['Location']; #print(location) req = self.post( location, data=data, headers=headers) if req.status_code!=200: raise ServiceError(req.status_code,'Cannot append to path {}'.format(path),req) else: raise ServiceError(req.status_code,'Cannot append path {}'.format(path),open_req) return True

356caf4ee17cfa856f9452e5b81fc78885d6f859

py

Python

utils/poweroff_restart.py

ndkjing/usv

132e021432a0344a22914aaf68da7d7955d7331f

utils/poweroff_restart.py

ndkjing/usv

132e021432a0344a22914aaf68da7d7955d7331f

utils/poweroff_restart.py

ndkjing/usv

132e021432a0344a22914aaf68da7d7955d7331f

2021-09-04T10:27:30.000Z

2021-09-04T10:27:30.000Z

from os import system # 重启电脑

from os import system # 重启电脑 def restart(): system('sudo reboot') def poweroff(): system('sudo shutdown now')

33b53b231a99d94ff5cc752b86bbc0159b2e1fb3

py

Python

pyctrl/flask/server.py

ComplexArts/pyctrl-core

a72bd53924410c2e7f1e71c8188a0391550febdd

2017-06-20T13:20:40.000Z

2021-01-18T00:12:10.000Z

pyctrl/flask/server.py

mcdeoliveira/beaglebone

6c6062c6d1e9902178500abcd10be6ac0bcf043d

2017-06-12T15:17:24.000Z

2018-01-30T18:22:19.000Z

pyctrl/flask/server.py

mcdeoliveira/beaglebone

6c6062c6d1e9902178500abcd10be6ac0bcf043d

2017-09-25T12:19:19.000Z

2019-01-31T21:46:24.000Z

from flask import Flask, request, render_template, jsonify, make_response, redirect, flash, url_for from functools import wraps import re import pyctrl from pyctrl.block import Logger import warnings import importlib import traceback, sys, io from pyctrl.flask import JSONEncoder, JSONDecoder encoder = JSONEncoder(sort_keys = True, indent = 4) decoder = JSONDecoder() # decorators # decode # decode_kwargs_aux # decode_kwargs # json_response # Server class if __name__ == "__main__": try: import os os.environ['RCPY_NO_HANDLERS'] = 't' from pyctrl.rc import Controller debug = False RCPY = True except: from pyctrl.timer import Controller debug = True RCPY = False try: app = Server(__name__) app.config['SECRET_KEY'] = 'secret!' # initialize controller app.set_controller(controller = Controller(period = .01)) # run app app.run(host='0.0.0.0', debug = debug) except: pass finally: sys.exit(0)

from flask import Flask, request, render_template, jsonify, make_response, redirect, flash, url_for from functools import wraps import re import pyctrl from pyctrl.block import Logger import warnings import importlib import traceback, sys, io from pyctrl.flask import JSONEncoder, JSONDecoder encoder = JSONEncoder(sort_keys = True, indent = 4) decoder = JSONDecoder() # decorators # decode def decode_value(f): @wraps(f) def wrapper(label, value, *args, **kwargs): return f(label, decoder.decode(value), *args, **kwargs) return wrapper # decode_kwargs_aux def decode_kwargs_aux(e): if len(e) == 1: return decoder.decode(e[0]) elif len(e) > 1: return [decoder.decode(v) for v in e] else: return None # decode_kwargs def decode_kwargs(f): @wraps(f) def wrapper(*args, **kwargs): try: kwargs.update({k: decode_kwargs_aux(request.args.getlist(k)) for k in request.args.keys()}) except: raise Exception("Arguments '{}' are not json compatible".format(request.args)) #print('>>> kwargs = {}'.format(kwargs)) return f(*args, **kwargs) return wrapper # json_response def json_response(f): @wraps(f) def wrapper(*args, **kwargs): try: retval = f(*args, **kwargs) if retval is None: retval = { 'status': 'success' } except Exception as e: message = io.StringIO() traceback.print_exc(file=message) retval = { 'status': 'error', 'message': message.getvalue() } next = request.args.get('next', None) if next: if 'status' in retval and retval['status'] == 'error': flash(retval['message']) return redirect(url_for(next)) else: return jsonify(retval) return wrapper # Server class class Server(Flask): def __init__(self, *args, **kwargs): self.controller = None self.base_url = '' # call super super().__init__(*args, **kwargs) # change json_encoder self.json_encoder = JSONEncoder # set api entry points # index, info and scope self.add_url_rule(self.base_url + '/', view_func = self.index) self.add_url_rule(self.base_url + '/info', view_func = self.info) self.add_url_rule(self.base_url + '/scope/<path:label>', view_func = self.scope) # download controller self.add_url_rule(self.base_url + '/download', view_func = self.download) # upload controller self.add_url_rule(self.base_url + '/upload', methods=['GET', 'POST'], view_func = self.upload) # reset self.add_url_rule(self.base_url + '/reset', view_func = self.reset) # set controller self.add_url_rule(self.base_url + '/set/controller/<module>/<pyctrl_class>', view_func = self.reset_controller) # start and stop self.add_url_rule(self.base_url + '/start', view_func = self.start) self.add_url_rule(self.base_url + '/stop', view_func = self.stop) # signals self.add_url_rule(self.base_url + '/add/signal/<path:label>', view_func = self.add_signal) self.add_url_rule(self.base_url + '/remove/signal/<path:label>', view_func = self.remove_signal) self.add_url_rule(self.base_url + '/get/signal/<path:label>', view_func = self.get_signal) self.add_url_rule(self.base_url + '/set/signal/<path:label>/<value>', view_func = self.set_signal) self.add_url_rule(self.base_url + '/list/signals', view_func = self.list_signals) # sources self.add_url_rule(self.base_url + '/add/source/<path:label>/<module_name>/<class_name>', view_func = self.add_source) self.add_url_rule(self.base_url + '/remove/source/<path:label>', view_func = self.remove_source) self.add_url_rule(self.base_url + '/get/source/<path:label>', view_func = self.get_source) self.add_url_rule(self.base_url + '/set/source/<path:label>', view_func = self.set_source) self.add_url_rule(self.base_url + '/html/source/<path:label>', view_func = self.html_source) # filters self.add_url_rule(self.base_url + '/add/filter/<path:label>/<module_name>/<class_name>', view_func = self.add_filter) self.add_url_rule(self.base_url + '/remove/filter/<path:label>', view_func = self.remove_filter) self.add_url_rule(self.base_url + '/get/filter/<path:label>', view_func = self.get_filter) self.add_url_rule(self.base_url + '/set/filter/<path:label>', view_func = self.set_filter) self.add_url_rule(self.base_url + '/html/filter/<path:label>', view_func = self.html_filter) # sinks self.add_url_rule(self.base_url + '/add/sink/<path:label>/<module_name>/<class_name>', view_func = self.add_sink) self.add_url_rule(self.base_url + '/remove/sink/<path:label>', view_func = self.remove_sink) self.add_url_rule(self.base_url + '/get/sink/<path:label>', view_func = self.get_sink) self.add_url_rule(self.base_url + '/set/sink/<path:label>', view_func = self.set_sink) self.add_url_rule(self.base_url + '/html/sink/<path:label>', view_func = self.html_sink) # timers self.add_url_rule(self.base_url + '/add/timer/<path:label>/<module_name>/<class_name>', view_func = self.add_timer) self.add_url_rule(self.base_url + '/remove/timer/<path:label>', view_func = self.remove_timer) self.add_url_rule(self.base_url + '/get/timer/<path:label>', view_func = self.get_timer) self.add_url_rule(self.base_url + '/set/timer/<path:label>', view_func = self.set_timer) self.add_url_rule(self.base_url + '/html/timer/<path:label>', view_func = self.html_timer) def set_controller(self, **kwargs): # Create new controller? if 'module' in kwargs or 'pyctrl_class' in kwargs: module = kwargs.pop('module', 'pyctrl') pyctrl_class = kwargs.pop('pyctrl_class', 'Controller') ckwargs = kwargs.pop('kwargs', {}) if len(kwargs) > 0: raise Exception("webserver.reset():: Unknown parameter(s) '{}'".format(', '.join(str(k) for k in kwargs.keys()))) try: if True: warnings.warn("> Installing new instance of '{}.{}({})' as controller".format(module, pyctrl_class, ckwargs)) obj_class = getattr(importlib.import_module(module), pyctrl_class) controller = obj_class(**ckwargs) # print('obj_class = {}'.format(obj_class)) # print('_controller = {}'.format(_controller)) # Make sure it is an instance of pyctrl.Controller if not isinstance(controller, pyctrl.Controller): raise Exception("Object '{}.{}' is not and instance of pyctrl.Controller".format(module, pyctrl_class)) self.controller = controller except Exception as e: raise Exception("Error resetting controller: {}".format(e)) elif 'controller' in kwargs: controller = kwargs.pop('controller') # Make sure it is an instance of pyctrl.Controller if not isinstance(controller, pyctrl.Controller): raise Exception("Object '{}.{}' is not and instance of pyctrl.Controller".format(module, pyctrl_class)) self.controller = controller # auxiliary def get_keys(self, method, type_name, label, **kwargs): # get keys keys = kwargs.get('keys', '') if keys and not isinstance(keys, (list,tuple)): keys = [keys] print('keys = {}'.format(keys)) # get container (container,label) = self.controller.resolve_label(label) if keys: # return attributes if len(keys) > 1: return method(label, *keys) else: return {keys[0]: method(label, *keys)} else: # return container return {label: getattr(container, type_name)[label]['block']} # handlers def index(self): sinks = [ {'label': k, 'is_logger': isinstance(v['block'], Logger)} for (k,v) in self.controller.sinks.items() ] return render_template('index.html', baseurl = self.base_url, class_name = self.controller.info('class'), signals = sorted(self.controller.list_signals()), sources = self.controller.list_sources(), filters = self.controller.list_filters(), sinks = sinks, timers = self.controller.list_timers(), is_running = self.controller.get_signal('is_running')) def info(self): return self.controller.html() def scope(self, label, *args, **kwargs): return render_template('scope.html', baseurl = self.base_url, logger = label) def download(self): response = make_response(jsonify(self.controller)) response.headers["Content-Disposition"] \ = "attachment; filename=controller.json" return response def upload(self, **kwargs): # post? if request.method == 'POST': # check if the post request has the file part if 'file' not in request.files: flash("Form has no field 'part'") else: # has file file = request.files['file'] # empty filename? if not file or file.filename == '': flash('No file selected') else: # there is a file try: controller = decoder.decode(file.read().decode('utf-8')) # print('controller = {}'.format(controller)) self.set_controller(controller = controller) flash('New controller succesfully loaded.') except Exception as e: message = io.StringIO() traceback.print_exc(file=message) flash('Could not load controller.') flash(message.getvalue()) return redirect(self.base_url + '/') @json_response @decode_kwargs def reset(self, **kwargs): return self.controller.reset(**kwargs) @decode_kwargs def reset_controller(self, **kwargs): # set new controller self.set_controller(**kwargs) # redirect to base return redirect(self.base_url + '/') @json_response def start(self): return self.controller.start() @json_response def stop(self): return self.controller.stop() @json_response def add_signal(self, *args, **kwargs): return self.controller.add_signal(*args, **kwargs) @json_response def remove_signal(self, *args, **kwargs): return self.controller.remove_signal(*args, **kwargs) @json_response def get_signal(self, label, *args, **kwargs): return {label: self.controller.get_signal(label, *args, **kwargs)} @json_response @decode_value def set_signal(self, *args, **kwargs): return self.controller.set_signal(*args, **kwargs) @json_response def list_signals(self): return self.controller.list_signals() # sources @json_response @decode_kwargs def add_source(self, label, module_name, class_name, **kwargs): return self.controller.add_source(label, (module_name, class_name), **kwargs) @json_response def remove_source(self, *args, **kwargs): return self.controller.remove_source(*args, **kwargs) @json_response @decode_kwargs def get_source(self, label, *args, **kwargs): return self.get_keys(self.controller.get_source, 'sources', label, *args, **kwargs) @json_response @decode_kwargs def set_source(self, *args, **kwargs): return self.controller.set_source(*args, **kwargs) @decode_kwargs def html_source(self, label, *args, **kwargs): # get container (container,label) = self.controller.resolve_label(label) return self.controller.sources[label]['block'].html(); # filters @json_response @decode_kwargs def add_filter(self, label, module_name, class_name, **kwargs): return self.controller.add_filter(label, (module_name, class_name), **kwargs) @json_response def remove_filter(self, *args, **kwargs): return self.controller.remove_filter(*args, **kwargs) @json_response @decode_kwargs def get_filter(self, label, *args, **kwargs): return self.get_keys(self.controller.get_filter, 'filters', label, *args, **kwargs) @json_response @decode_kwargs def set_filter(self, *args, **kwargs): return self.controller.set_filter(*args, **kwargs) @decode_kwargs def html_filter(self, label, *args, **kwargs): # get container (container,label) = self.controller.resolve_label(label) return self.controller.filters[label]['block'].html(); # sinks @json_response @decode_kwargs def add_sink(self, label, module_name, class_name, **kwargs): return self.controller.add_sink(label, (module_name, class_name), **kwargs) @json_response def remove_sink(self, *args, **kwargs): return self.controller.remove_sink(*args, **kwargs) @json_response @decode_kwargs def get_sink(self, label, *args, **kwargs): return self.get_keys(self.controller.get_sink, 'sinks', label, *args, **kwargs) @json_response @decode_kwargs def set_sink(self, *args, **kwargs): return self.controller.set_sink(*args, **kwargs) @decode_kwargs def html_sink(self, label, *args, **kwargs): # get container (container,label) = self.controller.resolve_label(label) return self.controller.sinks[label]['block'].html(); # timers @json_response @decode_kwargs def add_timer(self, label, module_name, class_name, **kwargs): return self.controller.add_timer(label, (module_name, class_name), **kwargs) @json_response def remove_timer(self, *args, **kwargs): return self.controller.remove_timer(*args, **kwargs) @json_response @decode_kwargs def get_timer(self, label, *args, **kwargs): return self.get_keys(self.controller.get_timer, 'timers', label, *args, **kwargs) @json_response @decode_kwargs def set_timer(self, *args, **kwargs): return self.controller.set_timer(*args, **kwargs) @decode_kwargs def html_timer(self, label, *args, **kwargs): # get container (container,label) = self.controller.resolve_label(label) return self.controller.timers[label]['block'].html(); if __name__ == "__main__": try: import os os.environ['RCPY_NO_HANDLERS'] = 't' from pyctrl.rc import Controller debug = False RCPY = True except: from pyctrl.timer import Controller debug = True RCPY = False try: app = Server(__name__) app.config['SECRET_KEY'] = 'secret!' # initialize controller app.set_controller(controller = Controller(period = .01)) # run app app.run(host='0.0.0.0', debug = debug) except: pass finally: sys.exit(0)

0dc7c93fd4a387857947da414073d7a073aa653c

py

Python

posts/api/views.py

loafbaker/django_blog

abd912962318527473654c9d2043f4a361a4abf1

posts/api/views.py

loafbaker/django_blog

abd912962318527473654c9d2043f4a361a4abf1

posts/api/views.py

loafbaker/django_blog

abd912962318527473654c9d2043f4a361a4abf1

from django.db.models import Q from rest_framework.filters import SearchFilter, OrderingFilter from rest_framework.generics import ListAPIView, CreateAPIView, RetrieveAPIView, RetrieveUpdateAPIView, DestroyAPIView from rest_framework.permissions import IsAuthenticated, IsAuthenticatedOrReadOnly from posts.models import Post from .pagination import PostPageNumberPagination from .permissions import IsOwnerOrReadOnly from .serializers import PostCreateUpdateSerializer, PostDetailSerializer, PostListSerializer

from django.db.models import Q from rest_framework.filters import SearchFilter, OrderingFilter from rest_framework.generics import ListAPIView, CreateAPIView, RetrieveAPIView, RetrieveUpdateAPIView, DestroyAPIView from rest_framework.permissions import IsAuthenticated, IsAuthenticatedOrReadOnly from posts.models import Post from .pagination import PostPageNumberPagination from .permissions import IsOwnerOrReadOnly from .serializers import PostCreateUpdateSerializer, PostDetailSerializer, PostListSerializer class PostListAPIView(ListAPIView): queryset = Post.objects.all() serializer_class = PostListSerializer filter_backends = [SearchFilter, OrderingFilter] search_fields = ['title', 'content', 'user__first_name', 'user__last_name'] pagination_class = PostPageNumberPagination def get_queryset(self): queryset_list = super(PostListAPIView, self).get_queryset() query = self.request.GET.get('q') if query: queryset_list = queryset_list.filter( Q(title__icontains=query) | Q(content__icontains=query) | Q(user__first_name=query) | Q(user__last_name=query) ) return queryset_list class PostCreateAPIView(CreateAPIView): permission_classes = [IsAuthenticated] queryset = Post.objects.all() serializer_class = PostCreateUpdateSerializer def perform_create(self, serializer): serializer.save(user=self.request.user) class PostDetailAPIView(RetrieveAPIView): queryset = Post.objects.all() serializer_class = PostDetailSerializer lookup_field = 'slug' class PostUpdateAPIView(RetrieveUpdateAPIView): permission_classes = [IsAuthenticatedOrReadOnly, IsOwnerOrReadOnly] queryset = Post.objects.all() serializer_class = PostCreateUpdateSerializer lookup_field = 'slug' class PostDeleteAPIView(DestroyAPIView): permission_classes = [IsAuthenticatedOrReadOnly, IsOwnerOrReadOnly] queryset = Post.objects.all() serializer_class = PostListSerializer lookup_field = 'slug'

5f6900da0b97f7cb9568e67607b74fc2b4feca0c

py

Python

proxy-alpha.py

ARTRoyale/ZapRoyale

984d72ee942b29f18250eae130d083d29151bd68

proxy-alpha.py

ARTRoyale/ZapRoyale

984d72ee942b29f18250eae130d083d29151bd68

proxy-alpha.py

ARTRoyale/ZapRoyale

984d72ee942b29f18250eae130d083d29151bd68

# by ARTRoyale (A. Lebedev) for ZapRoyale import socket import threading import struct import os import uuid import random # начинаем дебаг global debugmode debugmode = True global gl_server_address gl_server_address = ('***.***.*.**', 9339) if __name__ == "__main__": port_num = 9339 print('[INFO] Proksi podkluchaetsa k portu', port_num) ThreadedServer('0.0.0.0',port_num).listen()

# by ARTRoyale (A. Lebedev) for ZapRoyale import socket import threading import struct import os import uuid import random # начинаем дебаг global debugmode debugmode = True def debug(debmessage): if debmessage: if debugmode: print('[DEBUG]',debmessage) else: pass else: pass def randomBytes(n): return bytes(random.getrandbits(8) for i in range(n)) def mockrcv(mock): rdata = mock.recv(10086) if not rdata: return "nulldata" return rdata def serverlisten(mock, client): ndata=mockrcv(mock) if(ndata=="nulldata"): print('[WARNING] Net proksi!') return False else: lmessage_id = int(str(struct.unpack('>H', ndata[:2]))[1:-2]) if (lmessage_id >= 30000 or lmessage_id < 10000): lmessage_id = 'Neizvestniy messadzh' elif len(str(lmessage_id)) is not 5: lmessage_id = 'Neizvestniy messadzh' print('[OK] Servak => Proksi', lmessage_id) response = ndata try: client.send(response) except ConnectionAbortedError: client.close() debug('closed') global gl_server_address gl_server_address = ('***.***.*.**', 9339) class ThreadedServer(object): def __init__(self, host, port): self.host = host self.port = port self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.bind((self.host, self.port)) print('[OK] Zapusk Proksi') def listen(self): self.sock.listen(5) while True: client, address = self.sock.accept() print('[INFO] Klient => Proksi', address, 'podklucheno') client.settimeout(60) #таймаут mock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) print("[INFO] Proksi =><= Server pudkluchen k",gl_server_address[0],'on port',gl_server_address[1]) mock.connect(gl_server_address) print('[INFO] Proksi =><= Server podkluchen') threading.Thread(target = self.listenToClient,args = (client,address,mock)).start() def listenToClient(self, client, address, mock): while True: try: data = client.recv(4098) except: debug('closed') mock.close() try: message_id = int(str(struct.unpack('>H', data[:2]))[1:-2]) except: message_id = 'Neizvestniy messadzh' try: if (message_id >= 30000 or message_id < 10000): message_id = 'Neizvestniy messadzh' except: message_id = 'Neizvestniy messadzh' try: if len(str(message_id)) is not 5: message_id = 'Neizvestniy messadzh' except: message_id = 'Neizvestniy messadzh' print('[OK] Klient => Proksi', message_id) fmessage = data try: mock.sendall(fmessage) except: debug('done closing?') break print('[OK] Proksi => Server', message_id) while 1: debug('Slushayu servak') r = serverlisten(mock, client); if r == False: debug('Net infy ot servaka') break else: debug('Danniye polucheny ot servaka') break if __name__ == "__main__": port_num = 9339 print('[INFO] Proksi podkluchaetsa k portu', port_num) ThreadedServer('0.0.0.0',port_num).listen()

a5087d2093117c0c8a944443b7263a2f96effcb6

py

Python

api/api_scheme.py

raywu60kg/tensorlfow-project-demo

acd1085788da289ec7ed21ec0d46c9599188e32c

api/api_scheme.py

raywu60kg/tensorlfow-project-demo

acd1085788da289ec7ed21ec0d46c9599188e32c

api/api_scheme.py

raywu60kg/tensorlfow-project-demo

acd1085788da289ec7ed21ec0d46c9599188e32c

from pydantic import BaseModel # class MetricsOutput(BaseModel): # name: str # metrics: dict

from pydantic import BaseModel class HealthCheckOutput(BaseModel): health: bool # class MetricsOutput(BaseModel): # name: str # metrics: dict class RetrainModelOutput(BaseModel): train: bool

de32d45449405b3ec00b4326a7b6348906ee8392

py

Python

api/blueprints/users/views/roles.py

mohamed040406/API

40ceb2b35271938d90e4309a6cdcf63ba0c17f0b

2021-05-01T02:25:27.000Z

2021-05-01T02:25:27.000Z

api/blueprints/users/views/roles.py

mohamed040406/API

40ceb2b35271938d90e4309a6cdcf63ba0c17f0b

api/blueprints/users/views/roles.py

mohamed040406/API

40ceb2b35271938d90e4309a6cdcf63ba0c17f0b

from quart import request, jsonify import time from api.models import User from .. import bp import utils request: utils.Request @bp.route("/<int:user_id>/roles", methods=["GET"]) @utils.auth_required async def fetch_user_roles(user_id: int): """Fetch the specific users roles""" query = """ SELECT json_agg(json_build_object( 'name', r.name, 'base', r.base, 'id', r.id::TEXT, 'color', r.color, 'position', r.position, 'permissions', r.permissions::TEXT )) FROM roles r WHERE r.id IN ( SELECT ur.role_id FROM userroles WHERE ur.user_id = $1 ) """ record = await User.pool.fetchval(query, user_id) return jsonify(roles=record)

from quart import request, jsonify import time from api.models import User from .. import bp import utils request: utils.Request @bp.route("/<int:user_id>/roles", methods=["GET"]) @utils.auth_required async def fetch_user_roles(user_id: int): """Fetch the specific users roles""" query = """ SELECT json_agg(json_build_object( 'name', r.name, 'base', r.base, 'id', r.id::TEXT, 'color', r.color, 'position', r.position, 'permissions', r.permissions::TEXT )) FROM roles r WHERE r.id IN ( SELECT ur.role_id FROM userroles WHERE ur.user_id = $1 ) """ record = await User.pool.fetchval(query, user_id) return jsonify(roles=record)

d262a3348286d2c2acf7e83331728949dbe00b99

py

Python

mkgta.py

shaun95/Tacotron2-PyTorch

b1761fd7660e56adf39f3c8d02852fbaec1da2c5

2022-03-10T20:02:58.000Z

2022-03-10T20:02:58.000Z

mkgta.py

shaun95/Tacotron2-PyTorch

b1761fd7660e56adf39f3c8d02852fbaec1da2c5

mkgta.py

shaun95/Tacotron2-PyTorch

b1761fd7660e56adf39f3c8d02852fbaec1da2c5

import os import torch import argparse import numpy as np import matplotlib.pylab as plt from text import text_to_sequence from model.model import Tacotron2 from hparams import hparams as hps from utils.util import mode, to_var, to_arr from utils.audio import load_wav, save_wav, melspectrogram if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('-c', '--ckpt_pth', type = str, default = '', required = True, help = 'path to load checkpoints') parser.add_argument('-n', '--npy_pth', type = str, default = 'dump', help = 'path to save mels') args = parser.parse_args() torch.backends.cudnn.enabled = True torch.backends.cudnn.benchmark = False model = load_model(args.ckpt_pth) flist = files_to_list() for x in flist: ret = infer(x[0], x[1], model) name = x[0].split('/')[-1].split('.wav')[0] if args.npy_pth != '': save_mel(ret, args.npy_pth, name)

import os import torch import argparse import numpy as np import matplotlib.pylab as plt from text import text_to_sequence from model.model import Tacotron2 from hparams import hparams as hps from utils.util import mode, to_var, to_arr from utils.audio import load_wav, save_wav, melspectrogram def files_to_list(fdir = 'data'): f_list = [] with open(os.path.join(fdir, 'metadata.csv'), encoding = 'utf-8') as f: for line in f: parts = line.strip().split('|') wav_path = os.path.join(fdir, 'wavs', '%s.wav' % parts[0]) f_list.append([wav_path, parts[1]]) return f_list def load_model(ckpt_pth): ckpt_dict = torch.load(ckpt_pth) model = Tacotron2() model.load_state_dict(ckpt_dict['model']) model = mode(model, True).eval() model.decoder.train() model.postnet.train() return model def infer(wav_path, text, model): sequence = text_to_sequence(text, hps.text_cleaners) sequence = to_var(torch.IntTensor(sequence)[None, :]).long() mel = melspectrogram(load_wav(wav_path)) mel_in = to_var(torch.Tensor([mel])) r = mel_in.shape[2]%hps.n_frames_per_step if r != 0: mel_in = mel_in[:, :, :-r] sequence = torch.cat([sequence, sequence], 0) mel_in = torch.cat([mel_in, mel_in], 0) _, mel_outputs_postnet, _, _ = model.teacher_infer(sequence, mel_in) ret = mel if r != 0: ret[:, :-r] = to_arr(mel_outputs_postnet[0]) else: ret = to_arr(mel_outputs_postnet[0]) return ret def save_mel(res, pth, name): out = os.path.join(pth, name) np.save(out, res) if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('-c', '--ckpt_pth', type = str, default = '', required = True, help = 'path to load checkpoints') parser.add_argument('-n', '--npy_pth', type = str, default = 'dump', help = 'path to save mels') args = parser.parse_args() torch.backends.cudnn.enabled = True torch.backends.cudnn.benchmark = False model = load_model(args.ckpt_pth) flist = files_to_list() for x in flist: ret = infer(x[0], x[1], model) name = x[0].split('/')[-1].split('.wav')[0] if args.npy_pth != '': save_mel(ret, args.npy_pth, name)

78a847a9735c69df68fbcc09cc32244397b197f6

py

Python

doors-detector/doors_detector/dataset/dataset_doors_final/datasets_creator_doors_final.py

micheleantonazzi/master-thesis-robust-door-detector

685c2d13a6617978c8fc0324e92aab82f5a04b85

doors-detector/doors_detector/dataset/dataset_doors_final/datasets_creator_doors_final.py

micheleantonazzi/master-thesis-robust-door-detector

685c2d13a6617978c8fc0324e92aab82f5a04b85

doors-detector/doors_detector/dataset/dataset_doors_final/datasets_creator_doors_final.py

micheleantonazzi/master-thesis-robust-door-detector

685c2d13a6617978c8fc0324e92aab82f5a04b85

from typing import Union, Tuple import pandas as pd from sklearn.utils import shuffle from doors_detector.dataset.torch_dataset import TRAIN_SET, TEST_SET, SET from generic_dataset.dataset_manager import DatasetManager from doors_detector.dataset.dataset_doors_final.door_sample import DoorSample, DOOR_LABELS from sklearn.model_selection import train_test_split from doors_detector.dataset.dataset_doors_final.final_doors_dataset import DatasetDoorsFinal

from typing import Union, Tuple import pandas as pd from sklearn.utils import shuffle from doors_detector.dataset.torch_dataset import TRAIN_SET, TEST_SET, SET from generic_dataset.dataset_manager import DatasetManager from doors_detector.dataset.dataset_doors_final.door_sample import DoorSample, DOOR_LABELS from sklearn.model_selection import train_test_split from doors_detector.dataset.dataset_doors_final.final_doors_dataset import DatasetDoorsFinal class DatasetsCreatorDoorsFinal: def __init__(self, dataset_path: str): self._dataset_path = dataset_path self._dataset_manager = DatasetManager(dataset_path=dataset_path, sample_class=DoorSample) self._dataframe = self._dataset_manager.get_dataframe() self._experiment = 1 self._folder_name = None self._use_negatives = False def get_labels(self): return DOOR_LABELS def set_experiment_number(self, experiment: int, folder_name: str) -> 'DatasetsCreatorDoorsFinal': """ This method is used to set up the experiment to run. 1) This first experiment involves training the model using k-1 folders and testing it with all the examples in the remaining folder. 2) The second experiment involves fine-tuning the previously trained model using some examples of the test data used in experiment 1. This new training data belongs to a new environment, never seen in the first training phase. The remaining sample of the k-th folder are used as a test set. :param experiment: the number of the experiment to perform. It's value must be 0 or 1 :param folder_name: the name of the folder to use as a test set in experiment 1 or to split into training a test sets in experiment 2. :return: the instance of DatasetsCreatorDoorsFinal """ assert experiment == 1 or experiment == 2 self._experiment = experiment self._folder_name = folder_name return self def use_negatives(self, use_negatives: bool) -> 'DatasetsCreatorDoorsFinal': """ Sets the presence of the negative samples in the test set. :param use_negatives: True for including the negatives samples (samples with no doors) in the test set, False to use only positives ones :return: the instance of DatasetsDoorsF """ self._use_negatives = use_negatives return self def create_datasets(self, train_size: float = 0.1, random_state: int = 42) -> Tuple[DatasetDoorsFinal, DatasetDoorsFinal]: """ This method returns the training and test sets. :param train_size: the size of the training set in experiment 2. For the first experiment this parameter is not considered, all samples of folders k-1 are considered. """ if isinstance(train_size, float): assert 0.0 < train_size < 1.0 shuffled_dataframe = shuffle(self._dataframe, random_state=random_state) if self._experiment == 1: train_dataframe = shuffled_dataframe[(shuffled_dataframe.folder_name != self._folder_name) & (shuffled_dataframe.label == 1)] test_dataframe = shuffled_dataframe[shuffled_dataframe.folder_name == self._folder_name] if not self._use_negatives: test_dataframe = test_dataframe[test_dataframe.label == 1] elif self._experiment == 2: shuffled_dataframe = shuffled_dataframe[shuffled_dataframe.folder_name == self._folder_name] positive_dataframe = shuffled_dataframe[shuffled_dataframe.label == 1] negative_dataframe = shuffled_dataframe[shuffled_dataframe.label == 0] train, test = train_test_split(positive_dataframe.index.tolist(), test_size=0.25, random_state=random_state) if train_size < 0.75: train, _ = train_test_split(train, train_size=train_size * (4 / 3), random_state=random_state) train_dataframe = shuffled_dataframe.loc[train] test_dataframe = shuffle(pd.concat([shuffled_dataframe.loc[test], negative_dataframe]), random_state=random_state) if not self._use_negatives: test_dataframe = test_dataframe[test_dataframe.label == 1] def print_information(dataframe): print(f' - total samples = {len(dataframe.index)}\n' f' - Folders considered: {sorted(dataframe.folder_name.unique())}\n' f' - Labels considered: {sorted(dataframe.label.unique())}\n' f' - Total samples in folder: ') for folder in sorted(dataframe.folder_name.unique()): print(f' - {folder}: {len(dataframe[dataframe.folder_name == folder])} samples') if DoorSample.GET_LABEL_SET(): print(f' Samples per label:') for label in sorted(list(DoorSample.GET_LABEL_SET())): print(f' - {label}: {len(dataframe[(dataframe.folder_name == folder) & (dataframe.label == label)])}') print() for m, d in zip(['Datasets summary:', 'Train set summary:', 'Test set summary:'], [self._dataframe, train_dataframe, test_dataframe]): print(m) print_information(d) return (DatasetDoorsFinal(self._dataset_path, train_dataframe, TRAIN_SET, std_size=256, max_size=800, scales=[256 + i * 32 for i in range(11)]), DatasetDoorsFinal(self._dataset_path, test_dataframe, TEST_SET, std_size=256, max_size=800, scales=[256 + i * 32 for i in range(11)]))

005dfd3bd6b99b749c3643626e7c275bbe2acb28

py

Python

com/Leetcode/981.TimeBasedKey-ValueStore.py

samkitsheth95/InterviewPrep

6be68c19bcaab4e64a8f646cc64f651bade8ba86

com/Leetcode/981.TimeBasedKey-ValueStore.py

samkitsheth95/InterviewPrep

6be68c19bcaab4e64a8f646cc64f651bade8ba86

com/Leetcode/981.TimeBasedKey-ValueStore.py

samkitsheth95/InterviewPrep

6be68c19bcaab4e64a8f646cc64f651bade8ba86

from collections import defaultdict from bisect import bisect # Your TimeMap object will be instantiated and called as such: # obj = TimeMap() # obj.set(key,value,timestamp) # param_2 = obj.get(key,timestamp)

from collections import defaultdict from bisect import bisect class TimeMap: def binarySearch(self, a, key): if key < a[0][1]: return '' elif key >= a[-1][1]: return a[-1][0] low = 0 high = len(a) - 1 while low <= high: mid = low + (high - low) // 2 if a[mid][1] == key: return a[mid][0] elif a[mid][1] > key: high = mid - 1 else: low = mid + 1 return a[high][0] def __init__(self): """ Initialize your data structure here. """ self.d = defaultdict(list) def set(self, key: str, value: str, timestamp: int) -> None: self.d[key].append((value, timestamp)) def get(self, key: str, timestamp: int) -> str: return self.binarySearch(self.d[key], timestamp) def getBisect(self, key, timestamp): A = self.M.get(key, None) if A is None: return "" i = bisect.bisect(A, (timestamp, chr(127))) return A[i-1][1] if i else "" # Your TimeMap object will be instantiated and called as such: # obj = TimeMap() # obj.set(key,value,timestamp) # param_2 = obj.get(key,timestamp)

5017ac97f2b5056a11800f28fde484ec4a35c1b3

py

Python

sstvis.py

mdjong1/sstvis

927590b1295491a062a77634008a9146e783c617

sstvis.py

mdjong1/sstvis

927590b1295491a062a77634008a9146e783c617

sstvis.py

mdjong1/sstvis

927590b1295491a062a77634008a9146e783c617

import fileinput import sys import math import time import os import click # prevent pygame from printing their welcome message os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide" import pygame # Define some basic colors for easy use white = (255, 255, 255) red = (255, 0, 0) black = (0, 0, 0) green = (0, 255, 0) blue = (0, 0, 255) # Screen resolution to use window_dimensions = (1200, 800) # Higher frequency is less updates, lower frequency is more updates (it's a x % frequency == 0) UPDATE_FREQUENCY = 1000 # Only updates every nth triangle, increases clarity in high density datasets # Can also put this to 1 and make the scaling factor larger THINNING_FACTOR = 1 pygame.init() screen = pygame.display.set_mode(window_dimensions) screen.fill(white) font = pygame.font.SysFont("Arial", 12) # TODO: Split label and value for each statistics field time_taken = font.render("time:", True, white, blue) tt_rect = time_taken.get_rect(bottomright=(80, window_dimensions[1] - 65)) screen.blit(time_taken, tt_rect) time_taken_val = font.render(" ", True, white, blue) tt_rect2 = time_taken_val.get_rect(bottomleft=(80, window_dimensions[1] - 65)) screen.blit(time_taken_val, tt_rect2) points_per_second = font.render("avg #pts/s:", True, white, blue) pps_rect = points_per_second.get_rect(bottomright=(80, window_dimensions[1] - 45)) screen.blit(points_per_second, pps_rect) points_per_second_val = font.render(" ", True, white, blue) pps_rect2 = points_per_second_val.get_rect(bottomleft=(80, window_dimensions[1] - 45)) screen.blit(points_per_second_val, pps_rect2) # points_last_minute = font.render(" # pts last minute:", True, white, blue) # plm_rect = points_last_minute.get_rect(bottomright=(80, window_dimensions[1] - 95)) # screen.blit(points_last_minute, plm_rect) # points_last_minute_val = font.render(" ", True, white, blue) # plm_rect2 = points_last_minute_val.get_rect(bottomleft=(80, window_dimensions[1] - 95)) # screen.blit(points_last_minute_val, plm_rect2) total_points = font.render("# pts:", True, white, blue) tp_rect = total_points.get_rect(bottomright=(80, window_dimensions[1] - 25)) screen.blit(total_points, tp_rect) total_points_val = font.render(" ", True, white, blue) tp_rect2 = total_points_val.get_rect(bottomleft=(80, window_dimensions[1] - 25)) screen.blit(total_points_val, tp_rect2) total_triangles = font.render("# triangles:", True, white, blue) ttr_rect = total_triangles.get_rect(bottomright=(80, window_dimensions[1] - 5)) screen.blit(total_triangles, ttr_rect) total_triangles_val = font.render(" ", True, white, blue) ttr_rect2 = total_triangles_val.get_rect(bottomleft=(80, window_dimensions[1] - 5)) screen.blit(total_triangles_val, ttr_rect2) pygame.display.set_caption('sstvis') pygame.display.flip() @click.command() @click.option('--thinning', default=THINNING_FACTOR, help='thinning factor (1 = no thinning)') @click.option('--frequency', default=UPDATE_FREQUENCY, help='Higher frequency is less updates, lower frequency is more updates') if __name__ == "__main__": main()

import fileinput import sys import math import time import os import click # prevent pygame from printing their welcome message os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide" import pygame # Define some basic colors for easy use white = (255, 255, 255) red = (255, 0, 0) black = (0, 0, 0) green = (0, 255, 0) blue = (0, 0, 255) # Screen resolution to use window_dimensions = (1200, 800) # Higher frequency is less updates, lower frequency is more updates (it's a x % frequency == 0) UPDATE_FREQUENCY = 1000 # Only updates every nth triangle, increases clarity in high density datasets # Can also put this to 1 and make the scaling factor larger THINNING_FACTOR = 1 pygame.init() screen = pygame.display.set_mode(window_dimensions) screen.fill(white) font = pygame.font.SysFont("Arial", 12) # TODO: Split label and value for each statistics field time_taken = font.render("time:", True, white, blue) tt_rect = time_taken.get_rect(bottomright=(80, window_dimensions[1] - 65)) screen.blit(time_taken, tt_rect) time_taken_val = font.render(" ", True, white, blue) tt_rect2 = time_taken_val.get_rect(bottomleft=(80, window_dimensions[1] - 65)) screen.blit(time_taken_val, tt_rect2) points_per_second = font.render("avg #pts/s:", True, white, blue) pps_rect = points_per_second.get_rect(bottomright=(80, window_dimensions[1] - 45)) screen.blit(points_per_second, pps_rect) points_per_second_val = font.render(" ", True, white, blue) pps_rect2 = points_per_second_val.get_rect(bottomleft=(80, window_dimensions[1] - 45)) screen.blit(points_per_second_val, pps_rect2) # points_last_minute = font.render(" # pts last minute:", True, white, blue) # plm_rect = points_last_minute.get_rect(bottomright=(80, window_dimensions[1] - 95)) # screen.blit(points_last_minute, plm_rect) # points_last_minute_val = font.render(" ", True, white, blue) # plm_rect2 = points_last_minute_val.get_rect(bottomleft=(80, window_dimensions[1] - 95)) # screen.blit(points_last_minute_val, plm_rect2) total_points = font.render("# pts:", True, white, blue) tp_rect = total_points.get_rect(bottomright=(80, window_dimensions[1] - 25)) screen.blit(total_points, tp_rect) total_points_val = font.render(" ", True, white, blue) tp_rect2 = total_points_val.get_rect(bottomleft=(80, window_dimensions[1] - 25)) screen.blit(total_points_val, tp_rect2) total_triangles = font.render("# triangles:", True, white, blue) ttr_rect = total_triangles.get_rect(bottomright=(80, window_dimensions[1] - 5)) screen.blit(total_triangles, ttr_rect) total_triangles_val = font.render(" ", True, white, blue) ttr_rect2 = total_triangles_val.get_rect(bottomleft=(80, window_dimensions[1] - 5)) screen.blit(total_triangles_val, ttr_rect2) pygame.display.set_caption('sstvis') pygame.display.flip() class Vertex: def __init__(self, x, y, z): self.x = float(x) self.y = float(y) self.z = float(z) class Processor: def __init__(self): self.bbox = [] self.vertices = {} self.count = 0 self.vertex_count = 1 self.triangle_count = 0 self.scale = 1 self.start_time = time.time() self.points_per_time = {} def transform(self, x, y): rex = (float(x) - self.bbox[0]) * self.scale + 5 rey = (float(y) - self.bbox[1]) * self.scale return rex, rey def increment_count(self): self.count += 1 def update_statistics(self): current_epoch = int(time.time()) time_taken_val = font.render(" " + str(round(current_epoch - self.start_time)) + "s ", True, black, white) screen.blit(time_taken_val, tt_rect2) points_in_past_minute = 0 for i in range(current_epoch - 60, current_epoch): if i in self.points_per_time: points_in_past_minute += self.points_per_time[i] points_per_second_val = font.render(" " + str(round(points_in_past_minute / 60)) + " ", True, black, white) screen.blit(points_per_second_val, pps_rect2) # points_last_minute_val = font.render(" " + str(points_in_past_minute) + " ", True, black, white) # screen.blit(points_last_minute_val, plm_rect2) total_points_val = font.render(" " + str(self.vertex_count - 1) + " ", True, black, white) screen.blit(total_points_val, tp_rect2) total_triangles_val = font.render(" " + str(self.triangle_count) + " ", True, black, white) screen.blit(total_triangles_val, ttr_rect2) # Keep these on top for legibility screen.blit(time_taken, tt_rect) screen.blit(points_per_second, pps_rect) # screen.blit(points_last_minute, plm_rect) screen.blit(total_points, tp_rect) screen.blit(total_triangles, ttr_rect) def process_line(self, line): pygame.event.get() split_line = line.rstrip("\n").split(" ") if split_line[0] == "#": return elif split_line[0] == "b": self.bbox.append(float(split_line[1])) self.bbox.append(float(split_line[2])) self.bbox.append(float(split_line[3])) self.bbox.append(float(split_line[4])) delta_x = self.bbox[2] - self.bbox[0] delta_y = self.bbox[3] - self.bbox[1] largest_delta = delta_y if delta_y > delta_x else delta_x self.scale = math.floor(window_dimensions[1] / largest_delta) minx, miny = self.transform(self.bbox[0], self.bbox[1]) maxx, maxy = self.transform(self.bbox[2], self.bbox[3]) pygame.draw.lines( surface=screen, color=red, closed=True, points=( (minx, window_dimensions[1] - miny - 5), (maxx, window_dimensions[1] - miny - 5), (maxx, window_dimensions[1] - maxy - 5), (minx, window_dimensions[1] - maxy - 5) ), width=3 ) pygame.display.update() elif split_line[0] == "v": # Add vertex count per unit current_epoch = int(time.time()) if current_epoch not in self.points_per_time: self.points_per_time[current_epoch] = 1 else: self.points_per_time[current_epoch] += 1 # Transform x and y into current scale for visualization, then store that version in the Vertex x, y = self.transform(split_line[1], split_line[2]) z = split_line[3] self.vertices[self.vertex_count] = Vertex(x, y, z) self.vertex_count += 1 elif split_line[0] == "f": f1 = int(split_line[1]) f2 = int(split_line[2]) f3 = int(split_line[3]) if self.count % THINNING_FACTOR == 0: pygame.draw.lines( surface=screen, color=black, closed=True, points=( (self.vertices[f1].x, window_dimensions[1] - self.vertices[f1].y - 5), (self.vertices[f2].x, window_dimensions[1] - self.vertices[f2].y - 5), (self.vertices[f3].x, window_dimensions[1] - self.vertices[f3].y - 5) ), width=1) # pygame.draw.circle(screen, black, ((vertices[f1].x, vertices[f1].y)), 1) self.update_statistics() if self.count % UPDATE_FREQUENCY == 0: pygame.display.update() self.triangle_count += 1 @click.command() @click.option('--thinning', default=THINNING_FACTOR, help='thinning factor (1 = no thinning)') @click.option('--frequency', default=UPDATE_FREQUENCY, help='Higher frequency is less updates, lower frequency is more updates') def main(thinning, frequency): global THINNING_FACTOR global UPDATE_FREQUENCY THINNING_FACTOR = thinning UPDATE_FREQUENCY = frequency processor = Processor() for stdin_line in sys.stdin: if stdin_line == "": continue processor.process_line(stdin_line) processor.increment_count() sys.stdout.write(stdin_line) # Last update of statistics to ensure uniformity processor.update_statistics() # Do a final update; because of update frequency a final update in processing loop is not guaranteed pygame.display.update() # Keep the pygame window running so you can view the final result running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE): running = False if __name__ == "__main__": main()

c566c62bfc91343391f87b835b9e079719e2045b

py

Python

neo4j/_async/io/_bolt.py

matilda-me/neo4j-python-driver

4fb25a266841bf2a861f00d5dcf257bd5ae5c686

neo4j/_async/io/_bolt.py

matilda-me/neo4j-python-driver

4fb25a266841bf2a861f00d5dcf257bd5ae5c686

neo4j/_async/io/_bolt.py

matilda-me/neo4j-python-driver

4fb25a266841bf2a861f00d5dcf257bd5ae5c686

# Copyright (c) "Neo4j" # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # 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. import abc import asyncio from collections import deque from logging import getLogger from time import perf_counter from ..._async_compat.network import AsyncBoltSocket from ..._async_compat.util import AsyncUtil from ..._exceptions import ( BoltError, BoltHandshakeError, SocketDeadlineExceeded, ) from ...addressing import Address from ...api import ( ServerInfo, Version, ) from ...conf import PoolConfig from ...exceptions import ( AuthError, DriverError, IncompleteCommit, ServiceUnavailable, SessionExpired, ) from ...meta import get_user_agent from ...packstream import ( Packer, Unpacker, ) from ._common import ( AsyncInbox, CommitResponse, Outbox, ) # Set up logger log = getLogger("neo4j") class AsyncBolt: """ Server connection for Bolt protocol. A :class:`.Bolt` should be constructed following a successful .open() Bolt handshake and takes the socket over which the handshake was carried out. """ MAGIC_PREAMBLE = b"\x60\x60\xB0\x17" PROTOCOL_VERSION = None # flag if connection needs RESET to go back to READY state is_reset = False # The socket in_use = False # When the connection was last put back into the pool idle_since = float("-inf") # The socket _closing = False _closed = False # The socket _defunct = False #: The pool of which this connection is a member pool = None # Store the id of the most recent ran query to be able to reduce sent bits by # using the default (-1) to refer to the most recent query when pulling # results for it. most_recent_qid = None @property @abc.abstractmethod def supports_multiple_results(self): """ Boolean flag to indicate if the connection version supports multiple queries to be buffered on the server side (True) or if all results need to be eagerly pulled before sending the next RUN (False). """ pass @property @abc.abstractmethod def supports_multiple_databases(self): """ Boolean flag to indicate if the connection version supports multiple databases. """ pass @classmethod def protocol_handlers(cls, protocol_version=None): """ Return a dictionary of available Bolt protocol handlers, keyed by version tuple. If an explicit protocol version is provided, the dictionary will contain either zero or one items, depending on whether that version is supported. If no protocol version is provided, all available versions will be returned. :param protocol_version: tuple identifying a specific protocol version (e.g. (3, 5)) or None :return: dictionary of version tuple to handler class for all relevant and supported protocol versions :raise TypeError: if protocol version is not passed in a tuple """ # Carry out Bolt subclass imports locally to avoid circular dependency issues. from ._bolt3 import AsyncBolt3 from ._bolt4 import ( AsyncBolt4x1, AsyncBolt4x2, AsyncBolt4x3, AsyncBolt4x4, ) from ._bolt5 import AsyncBolt5x0 handlers = { AsyncBolt3.PROTOCOL_VERSION: AsyncBolt3, # 4.0 unsupported because no space left in the handshake AsyncBolt4x1.PROTOCOL_VERSION: AsyncBolt4x1, AsyncBolt4x2.PROTOCOL_VERSION: AsyncBolt4x2, AsyncBolt4x3.PROTOCOL_VERSION: AsyncBolt4x3, AsyncBolt4x4.PROTOCOL_VERSION: AsyncBolt4x4, AsyncBolt5x0.PROTOCOL_VERSION: AsyncBolt5x0, } if protocol_version is None: return handlers if not isinstance(protocol_version, tuple): raise TypeError("Protocol version must be specified as a tuple") if protocol_version in handlers: return {protocol_version: handlers[protocol_version]} return {} @classmethod def version_list(cls, versions, limit=4): """ Return a list of supported protocol versions in order of preference. The number of protocol versions (or ranges) returned is limited to four. """ # In fact, 4.3 is the fist version to support ranges. However, the # range support got backported to 4.2. But even if the server is too # old to have the backport, negotiating BOLT 4.1 is no problem as it's # equivalent to 4.2 first_with_range_support = Version(4, 2) result = [] for version in versions: if (result and version >= first_with_range_support and result[-1][0] == version[0] and result[-1][1][1] == version[1] + 1): # can use range to encompass this version result[-1][1][1] = version[1] continue result.append(Version(version[0], [version[1], version[1]])) if len(result) == 4: break return result @classmethod def get_handshake(cls): """ Return the supported Bolt versions as bytes. The length is 16 bytes as specified in the Bolt version negotiation. :return: bytes """ supported_versions = sorted(cls.protocol_handlers().keys(), reverse=True) offered_versions = cls.version_list(supported_versions) return b"".join(version.to_bytes() for version in offered_versions).ljust(16, b"\x00") @classmethod async def ping(cls, address, *, timeout=None, **config): """ Attempt to establish a Bolt connection, returning the agreed Bolt protocol version if successful. """ config = PoolConfig.consume(config) try: s, protocol_version, handshake, data = \ await AsyncBoltSocket.connect( address, timeout=timeout, custom_resolver=config.resolver, ssl_context=config.get_ssl_context(), keep_alive=config.keep_alive, ) except (ServiceUnavailable, SessionExpired, BoltHandshakeError): return None else: AsyncBoltSocket.close_socket(s) return protocol_version @classmethod async def open( cls, address, *, auth=None, timeout=None, routing_context=None, **pool_config ): """Open a new Bolt connection to a given server address. :param address: :param auth: :param timeout: the connection timeout in seconds :param routing_context: dict containing routing context :param pool_config: :return: connected AsyncBolt instance :raise BoltHandshakeError: raised if the Bolt Protocol can not negotiate a protocol version. :raise ServiceUnavailable: raised if there was a connection issue. """ t0 = perf_counter() pool_config = PoolConfig.consume(pool_config) socket_connection_timeout = pool_config.connection_timeout if socket_connection_timeout is None: socket_connection_timeout = time_remaining() elif timeout is not None: socket_connection_timeout = min(pool_config.connection_timeout, time_remaining()) s, pool_config.protocol_version, handshake, data = \ await AsyncBoltSocket.connect( address, timeout=socket_connection_timeout, custom_resolver=pool_config.resolver, ssl_context=pool_config.get_ssl_context(), keep_alive=pool_config.keep_alive, ) # Carry out Bolt subclass imports locally to avoid circular dependency # issues. if pool_config.protocol_version == (3, 0): from ._bolt3 import AsyncBolt3 bolt_cls = AsyncBolt3 # Implementation for 4.0 exists, but there was no space left in the # handshake to offer this version to the server. Hence, the server # should never request us to speak bolt 4.0. # elif pool_config.protocol_version == (4, 0): # from ._bolt4 import AsyncBolt4x0 # bolt_cls = AsyncBolt4x0 elif pool_config.protocol_version == (4, 1): from ._bolt4 import AsyncBolt4x1 bolt_cls = AsyncBolt4x1 elif pool_config.protocol_version == (4, 2): from ._bolt4 import AsyncBolt4x2 bolt_cls = AsyncBolt4x2 elif pool_config.protocol_version == (4, 3): from ._bolt4 import AsyncBolt4x3 bolt_cls = AsyncBolt4x3 elif pool_config.protocol_version == (4, 4): from ._bolt4 import AsyncBolt4x4 bolt_cls = AsyncBolt4x4 elif pool_config.protocol_version == (5, 0): from ._bolt5 import AsyncBolt5x0 bolt_cls = AsyncBolt5x0 else: log.debug("[#%04X] S: <CLOSE>", s.getsockname()[1]) AsyncBoltSocket.close_socket(s) supported_versions = cls.protocol_handlers().keys() raise BoltHandshakeError( "The Neo4J server does not support communication with this " "driver. This driver has support for Bolt protocols " "{}".format(tuple(map(str, supported_versions))), address=address, request_data=handshake, response_data=data ) connection = bolt_cls( address, s, pool_config.max_connection_lifetime, auth=auth, user_agent=pool_config.user_agent, routing_context=routing_context ) try: connection.socket.set_deadline(time_remaining()) try: await connection.hello() except SocketDeadlineExceeded as e: # connection._defunct = True raise ServiceUnavailable( "Timeout during initial handshake occurred" ) from e finally: connection.socket.set_deadline(None) except Exception: await connection.close_non_blocking() raise return connection @property @abc.abstractmethod @property @abc.abstractmethod @property @abc.abstractmethod @abc.abstractmethod async def hello(self): """ Appends a HELLO message to the outgoing queue, sends it and consumes all remaining messages. """ pass @abc.abstractmethod async def route(self, database=None, imp_user=None, bookmarks=None): """ Fetch a routing table from the server for the given `database`. For Bolt 4.3 and above, this appends a ROUTE message; for earlier versions, a procedure call is made via the regular Cypher execution mechanism. In all cases, this is sent to the network, and a response is fetched. :param database: database for which to fetch a routing table Requires Bolt 4.0+. :param imp_user: the user to impersonate Requires Bolt 4.4+. :param bookmarks: iterable of bookmark values after which this transaction should begin :return: dictionary of raw routing data """ pass @abc.abstractmethod def run(self, query, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, **handlers): """ Appends a RUN message to the output queue. :param query: Cypher query string :param parameters: dictionary of Cypher parameters :param mode: access mode for routing - "READ" or "WRITE" (default) :param bookmarks: iterable of bookmark values after which this transaction should begin :param metadata: custom metadata dictionary to attach to the transaction :param timeout: timeout for transaction execution (seconds) :param db: name of the database against which to begin the transaction Requires Bolt 4.0+. :param imp_user: the user to impersonate Requires Bolt 4.4+. :param handlers: handler functions passed into the returned Response object :return: Response object """ pass @abc.abstractmethod def discard(self, n=-1, qid=-1, **handlers): """ Appends a DISCARD message to the output queue. :param n: number of records to discard, default = -1 (ALL) :param qid: query ID to discard for, default = -1 (last query) :param handlers: handler functions passed into the returned Response object :return: Response object """ pass @abc.abstractmethod def pull(self, n=-1, qid=-1, **handlers): """ Appends a PULL message to the output queue. :param n: number of records to pull, default = -1 (ALL) :param qid: query ID to pull for, default = -1 (last query) :param handlers: handler functions passed into the returned Response object :return: Response object """ pass @abc.abstractmethod def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, **handlers): """ Appends a BEGIN message to the output queue. :param mode: access mode for routing - "READ" or "WRITE" (default) :param bookmarks: iterable of bookmark values after which this transaction should begin :param metadata: custom metadata dictionary to attach to the transaction :param timeout: timeout for transaction execution (seconds) :param db: name of the database against which to begin the transaction Requires Bolt 4.0+. :param imp_user: the user to impersonate Requires Bolt 4.4+ :param handlers: handler functions passed into the returned Response object :return: Response object """ pass @abc.abstractmethod def commit(self, **handlers): """ Appends a COMMIT message to the output queue.""" pass @abc.abstractmethod def rollback(self, **handlers): """ Appends a ROLLBACK message to the output queue.""" pass @abc.abstractmethod async def reset(self): """ Appends a RESET message to the outgoing queue, sends it and consumes all remaining messages. """ pass @abc.abstractmethod def goodbye(self): """Append a GOODBYE message to the outgoing queued.""" pass def _append(self, signature, fields=(), response=None): """ Appends a message to the outgoing queue. :param signature: the signature of the message :param fields: the fields of the message as a tuple :param response: a response object to handle callbacks """ with self.outbox.tmp_buffer(): self.packer.pack_struct(signature, fields) self.outbox.wrap_message() self.responses.append(response) async def send_all(self): """ Send all queued messages to the server. """ if self.closed(): raise ServiceUnavailable( "Failed to write to closed connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) if self.defunct(): raise ServiceUnavailable( "Failed to write to defunct connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) await self._send_all() @abc.abstractmethod async def _process_message(self, details, summary_signature, summary_metadata): """ Receive at most one message from the server, if available. :return: 2-tuple of number of detail messages and number of summary messages fetched """ pass async def fetch_all(self): """ Fetch all outstanding messages. :return: 2-tuple of number of detail messages and number of summary messages fetched """ detail_count = summary_count = 0 while self.responses: response = self.responses[0] while not response.complete: detail_delta, summary_delta = await self.fetch_message() detail_count += detail_delta summary_count += summary_delta return detail_count, summary_count _stale = False async def close(self): """Close the connection.""" if self._closed or self._closing: return self._closing = True if not self._defunct: self.goodbye() try: await self._send_all() except (OSError, BoltError, DriverError): pass log.debug("[#%04X] C: <CLOSE>", self.local_port) try: self.socket.close() except OSError: pass finally: self._closed = True async def close_non_blocking(self): """Set the socket to non-blocking and close it. This will try to send the `GOODBYE` message (given the socket is not marked as defunct). However, should the write operation require blocking (e.g., a full network buffer), then the socket will be closed immediately (without `GOODBYE` message). """ if self._closed or self._closing: return self.socket.settimeout(0) await self.close() def is_idle_for(self, timeout): """Check if connection has been idle for at least the given timeout. :param timeout: timeout in seconds :type timeout: float :rtype: bool """ return perf_counter() - self.idle_since > timeout AsyncBoltSocket.Bolt = AsyncBolt

# Copyright (c) "Neo4j" # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # 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. import abc import asyncio from collections import deque from logging import getLogger from time import perf_counter from ..._async_compat.network import AsyncBoltSocket from ..._async_compat.util import AsyncUtil from ..._exceptions import ( BoltError, BoltHandshakeError, SocketDeadlineExceeded, ) from ...addressing import Address from ...api import ( ServerInfo, Version, ) from ...conf import PoolConfig from ...exceptions import ( AuthError, DriverError, IncompleteCommit, ServiceUnavailable, SessionExpired, ) from ...meta import get_user_agent from ...packstream import ( Packer, Unpacker, ) from ._common import ( AsyncInbox, CommitResponse, Outbox, ) # Set up logger log = getLogger("neo4j") class AsyncBolt: """ Server connection for Bolt protocol. A :class:`.Bolt` should be constructed following a successful .open() Bolt handshake and takes the socket over which the handshake was carried out. """ MAGIC_PREAMBLE = b"\x60\x60\xB0\x17" PROTOCOL_VERSION = None # flag if connection needs RESET to go back to READY state is_reset = False # The socket in_use = False # When the connection was last put back into the pool idle_since = float("-inf") # The socket _closing = False _closed = False # The socket _defunct = False #: The pool of which this connection is a member pool = None # Store the id of the most recent ran query to be able to reduce sent bits by # using the default (-1) to refer to the most recent query when pulling # results for it. most_recent_qid = None def __init__(self, unresolved_address, sock, max_connection_lifetime, *, auth=None, user_agent=None, routing_context=None): self.unresolved_address = unresolved_address self.socket = sock self.server_info = ServerInfo(Address(sock.getpeername()), self.PROTOCOL_VERSION) # so far `connection.recv_timeout_seconds` is the only available # configuration hint that exists. Therefore, all hints can be stored at # connection level. This might change in the future. self.configuration_hints = {} self.outbox = Outbox() self.inbox = AsyncInbox(self.socket, on_error=self._set_defunct_read) self.packer = Packer(self.outbox) self.unpacker = Unpacker(self.inbox) self.responses = deque() self._max_connection_lifetime = max_connection_lifetime self._creation_timestamp = perf_counter() self.routing_context = routing_context self.idle_since = perf_counter() # Determine the user agent if user_agent: self.user_agent = user_agent else: self.user_agent = get_user_agent() # Determine auth details if not auth: self.auth_dict = {} elif isinstance(auth, tuple) and 2 <= len(auth) <= 3: from neo4j import Auth self.auth_dict = vars(Auth("basic", *auth)) else: try: self.auth_dict = vars(auth) except (KeyError, TypeError): raise AuthError("Cannot determine auth details from %r" % auth) # Check for missing password try: credentials = self.auth_dict["credentials"] except KeyError: pass else: if credentials is None: raise AuthError("Password cannot be None") def __del__(self): if not asyncio.iscoroutinefunction(self.close): self.close() @property @abc.abstractmethod def supports_multiple_results(self): """ Boolean flag to indicate if the connection version supports multiple queries to be buffered on the server side (True) or if all results need to be eagerly pulled before sending the next RUN (False). """ pass @property @abc.abstractmethod def supports_multiple_databases(self): """ Boolean flag to indicate if the connection version supports multiple databases. """ pass @classmethod def protocol_handlers(cls, protocol_version=None): """ Return a dictionary of available Bolt protocol handlers, keyed by version tuple. If an explicit protocol version is provided, the dictionary will contain either zero or one items, depending on whether that version is supported. If no protocol version is provided, all available versions will be returned. :param protocol_version: tuple identifying a specific protocol version (e.g. (3, 5)) or None :return: dictionary of version tuple to handler class for all relevant and supported protocol versions :raise TypeError: if protocol version is not passed in a tuple """ # Carry out Bolt subclass imports locally to avoid circular dependency issues. from ._bolt3 import AsyncBolt3 from ._bolt4 import ( AsyncBolt4x1, AsyncBolt4x2, AsyncBolt4x3, AsyncBolt4x4, ) from ._bolt5 import AsyncBolt5x0 handlers = { AsyncBolt3.PROTOCOL_VERSION: AsyncBolt3, # 4.0 unsupported because no space left in the handshake AsyncBolt4x1.PROTOCOL_VERSION: AsyncBolt4x1, AsyncBolt4x2.PROTOCOL_VERSION: AsyncBolt4x2, AsyncBolt4x3.PROTOCOL_VERSION: AsyncBolt4x3, AsyncBolt4x4.PROTOCOL_VERSION: AsyncBolt4x4, AsyncBolt5x0.PROTOCOL_VERSION: AsyncBolt5x0, } if protocol_version is None: return handlers if not isinstance(protocol_version, tuple): raise TypeError("Protocol version must be specified as a tuple") if protocol_version in handlers: return {protocol_version: handlers[protocol_version]} return {} @classmethod def version_list(cls, versions, limit=4): """ Return a list of supported protocol versions in order of preference. The number of protocol versions (or ranges) returned is limited to four. """ # In fact, 4.3 is the fist version to support ranges. However, the # range support got backported to 4.2. But even if the server is too # old to have the backport, negotiating BOLT 4.1 is no problem as it's # equivalent to 4.2 first_with_range_support = Version(4, 2) result = [] for version in versions: if (result and version >= first_with_range_support and result[-1][0] == version[0] and result[-1][1][1] == version[1] + 1): # can use range to encompass this version result[-1][1][1] = version[1] continue result.append(Version(version[0], [version[1], version[1]])) if len(result) == 4: break return result @classmethod def get_handshake(cls): """ Return the supported Bolt versions as bytes. The length is 16 bytes as specified in the Bolt version negotiation. :return: bytes """ supported_versions = sorted(cls.protocol_handlers().keys(), reverse=True) offered_versions = cls.version_list(supported_versions) return b"".join(version.to_bytes() for version in offered_versions).ljust(16, b"\x00") @classmethod async def ping(cls, address, *, timeout=None, **config): """ Attempt to establish a Bolt connection, returning the agreed Bolt protocol version if successful. """ config = PoolConfig.consume(config) try: s, protocol_version, handshake, data = \ await AsyncBoltSocket.connect( address, timeout=timeout, custom_resolver=config.resolver, ssl_context=config.get_ssl_context(), keep_alive=config.keep_alive, ) except (ServiceUnavailable, SessionExpired, BoltHandshakeError): return None else: AsyncBoltSocket.close_socket(s) return protocol_version @classmethod async def open( cls, address, *, auth=None, timeout=None, routing_context=None, **pool_config ): """Open a new Bolt connection to a given server address. :param address: :param auth: :param timeout: the connection timeout in seconds :param routing_context: dict containing routing context :param pool_config: :return: connected AsyncBolt instance :raise BoltHandshakeError: raised if the Bolt Protocol can not negotiate a protocol version. :raise ServiceUnavailable: raised if there was a connection issue. """ def time_remaining(): if timeout is None: return None t = timeout - (perf_counter() - t0) return t if t > 0 else 0 t0 = perf_counter() pool_config = PoolConfig.consume(pool_config) socket_connection_timeout = pool_config.connection_timeout if socket_connection_timeout is None: socket_connection_timeout = time_remaining() elif timeout is not None: socket_connection_timeout = min(pool_config.connection_timeout, time_remaining()) s, pool_config.protocol_version, handshake, data = \ await AsyncBoltSocket.connect( address, timeout=socket_connection_timeout, custom_resolver=pool_config.resolver, ssl_context=pool_config.get_ssl_context(), keep_alive=pool_config.keep_alive, ) # Carry out Bolt subclass imports locally to avoid circular dependency # issues. if pool_config.protocol_version == (3, 0): from ._bolt3 import AsyncBolt3 bolt_cls = AsyncBolt3 # Implementation for 4.0 exists, but there was no space left in the # handshake to offer this version to the server. Hence, the server # should never request us to speak bolt 4.0. # elif pool_config.protocol_version == (4, 0): # from ._bolt4 import AsyncBolt4x0 # bolt_cls = AsyncBolt4x0 elif pool_config.protocol_version == (4, 1): from ._bolt4 import AsyncBolt4x1 bolt_cls = AsyncBolt4x1 elif pool_config.protocol_version == (4, 2): from ._bolt4 import AsyncBolt4x2 bolt_cls = AsyncBolt4x2 elif pool_config.protocol_version == (4, 3): from ._bolt4 import AsyncBolt4x3 bolt_cls = AsyncBolt4x3 elif pool_config.protocol_version == (4, 4): from ._bolt4 import AsyncBolt4x4 bolt_cls = AsyncBolt4x4 elif pool_config.protocol_version == (5, 0): from ._bolt5 import AsyncBolt5x0 bolt_cls = AsyncBolt5x0 else: log.debug("[#%04X] S: <CLOSE>", s.getsockname()[1]) AsyncBoltSocket.close_socket(s) supported_versions = cls.protocol_handlers().keys() raise BoltHandshakeError( "The Neo4J server does not support communication with this " "driver. This driver has support for Bolt protocols " "{}".format(tuple(map(str, supported_versions))), address=address, request_data=handshake, response_data=data ) connection = bolt_cls( address, s, pool_config.max_connection_lifetime, auth=auth, user_agent=pool_config.user_agent, routing_context=routing_context ) try: connection.socket.set_deadline(time_remaining()) try: await connection.hello() except SocketDeadlineExceeded as e: # connection._defunct = True raise ServiceUnavailable( "Timeout during initial handshake occurred" ) from e finally: connection.socket.set_deadline(None) except Exception: await connection.close_non_blocking() raise return connection @property @abc.abstractmethod def encrypted(self): pass @property @abc.abstractmethod def der_encoded_server_certificate(self): pass @property @abc.abstractmethod def local_port(self): pass @abc.abstractmethod async def hello(self): """ Appends a HELLO message to the outgoing queue, sends it and consumes all remaining messages. """ pass @abc.abstractmethod async def route(self, database=None, imp_user=None, bookmarks=None): """ Fetch a routing table from the server for the given `database`. For Bolt 4.3 and above, this appends a ROUTE message; for earlier versions, a procedure call is made via the regular Cypher execution mechanism. In all cases, this is sent to the network, and a response is fetched. :param database: database for which to fetch a routing table Requires Bolt 4.0+. :param imp_user: the user to impersonate Requires Bolt 4.4+. :param bookmarks: iterable of bookmark values after which this transaction should begin :return: dictionary of raw routing data """ pass @abc.abstractmethod def run(self, query, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, **handlers): """ Appends a RUN message to the output queue. :param query: Cypher query string :param parameters: dictionary of Cypher parameters :param mode: access mode for routing - "READ" or "WRITE" (default) :param bookmarks: iterable of bookmark values after which this transaction should begin :param metadata: custom metadata dictionary to attach to the transaction :param timeout: timeout for transaction execution (seconds) :param db: name of the database against which to begin the transaction Requires Bolt 4.0+. :param imp_user: the user to impersonate Requires Bolt 4.4+. :param handlers: handler functions passed into the returned Response object :return: Response object """ pass @abc.abstractmethod def discard(self, n=-1, qid=-1, **handlers): """ Appends a DISCARD message to the output queue. :param n: number of records to discard, default = -1 (ALL) :param qid: query ID to discard for, default = -1 (last query) :param handlers: handler functions passed into the returned Response object :return: Response object """ pass @abc.abstractmethod def pull(self, n=-1, qid=-1, **handlers): """ Appends a PULL message to the output queue. :param n: number of records to pull, default = -1 (ALL) :param qid: query ID to pull for, default = -1 (last query) :param handlers: handler functions passed into the returned Response object :return: Response object """ pass @abc.abstractmethod def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, **handlers): """ Appends a BEGIN message to the output queue. :param mode: access mode for routing - "READ" or "WRITE" (default) :param bookmarks: iterable of bookmark values after which this transaction should begin :param metadata: custom metadata dictionary to attach to the transaction :param timeout: timeout for transaction execution (seconds) :param db: name of the database against which to begin the transaction Requires Bolt 4.0+. :param imp_user: the user to impersonate Requires Bolt 4.4+ :param handlers: handler functions passed into the returned Response object :return: Response object """ pass @abc.abstractmethod def commit(self, **handlers): """ Appends a COMMIT message to the output queue.""" pass @abc.abstractmethod def rollback(self, **handlers): """ Appends a ROLLBACK message to the output queue.""" pass @abc.abstractmethod async def reset(self): """ Appends a RESET message to the outgoing queue, sends it and consumes all remaining messages. """ pass @abc.abstractmethod def goodbye(self): """Append a GOODBYE message to the outgoing queued.""" pass def _append(self, signature, fields=(), response=None): """ Appends a message to the outgoing queue. :param signature: the signature of the message :param fields: the fields of the message as a tuple :param response: a response object to handle callbacks """ with self.outbox.tmp_buffer(): self.packer.pack_struct(signature, fields) self.outbox.wrap_message() self.responses.append(response) async def _send_all(self): data = self.outbox.view() if data: try: await self.socket.sendall(data) except OSError as error: await self._set_defunct_write(error) self.outbox.clear() self.idle_since = perf_counter() async def send_all(self): """ Send all queued messages to the server. """ if self.closed(): raise ServiceUnavailable( "Failed to write to closed connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) if self.defunct(): raise ServiceUnavailable( "Failed to write to defunct connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) await self._send_all() @abc.abstractmethod async def _process_message(self, details, summary_signature, summary_metadata): """ Receive at most one message from the server, if available. :return: 2-tuple of number of detail messages and number of summary messages fetched """ pass async def fetch_message(self): if self._closed: raise ServiceUnavailable( "Failed to read from closed connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) if self._defunct: raise ServiceUnavailable( "Failed to read from defunct connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) if not self.responses: return 0, 0 # Receive exactly one message details, summary_signature, summary_metadata = \ await AsyncUtil.next(self.inbox) res = await self._process_message( details, summary_signature, summary_metadata ) self.idle_since = perf_counter() return res async def fetch_all(self): """ Fetch all outstanding messages. :return: 2-tuple of number of detail messages and number of summary messages fetched """ detail_count = summary_count = 0 while self.responses: response = self.responses[0] while not response.complete: detail_delta, summary_delta = await self.fetch_message() detail_count += detail_delta summary_count += summary_delta return detail_count, summary_count async def _set_defunct_read(self, error=None, silent=False): message = "Failed to read from defunct connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) await self._set_defunct(message, error=error, silent=silent) async def _set_defunct_write(self, error=None, silent=False): message = "Failed to write data to connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) await self._set_defunct(message, error=error, silent=silent) async def _set_defunct(self, message, error=None, silent=False): from ._pool import AsyncBoltPool direct_driver = isinstance(self.pool, AsyncBoltPool) if error: log.debug("[#%04X] %s", self.socket.getsockname()[1], error) log.error(message) # We were attempting to receive data but the connection # has unexpectedly terminated. So, we need to close the # connection from the client side, and remove the address # from the connection pool. self._defunct = True if not self._closing: # If we fail while closing the connection, there is no need to # remove the connection from the pool, nor to try to close the # connection again. await self.close() if self.pool: await self.pool.deactivate(address=self.unresolved_address) # Iterate through the outstanding responses, and if any correspond # to COMMIT requests then raise an error to signal that we are # unable to confirm that the COMMIT completed successfully. if silent: return for response in self.responses: if isinstance(response, CommitResponse): if error: raise IncompleteCommit(message) from error else: raise IncompleteCommit(message) if direct_driver: if error: raise ServiceUnavailable(message) from error else: raise ServiceUnavailable(message) else: if error: raise SessionExpired(message) from error else: raise SessionExpired(message) def stale(self): return (self._stale or (0 <= self._max_connection_lifetime <= perf_counter() - self._creation_timestamp)) _stale = False def set_stale(self): self._stale = True async def close(self): """Close the connection.""" if self._closed or self._closing: return self._closing = True if not self._defunct: self.goodbye() try: await self._send_all() except (OSError, BoltError, DriverError): pass log.debug("[#%04X] C: <CLOSE>", self.local_port) try: self.socket.close() except OSError: pass finally: self._closed = True async def close_non_blocking(self): """Set the socket to non-blocking and close it. This will try to send the `GOODBYE` message (given the socket is not marked as defunct). However, should the write operation require blocking (e.g., a full network buffer), then the socket will be closed immediately (without `GOODBYE` message). """ if self._closed or self._closing: return self.socket.settimeout(0) await self.close() def closed(self): return self._closed def defunct(self): return self._defunct def is_idle_for(self, timeout): """Check if connection has been idle for at least the given timeout. :param timeout: timeout in seconds :type timeout: float :rtype: bool """ return perf_counter() - self.idle_since > timeout AsyncBoltSocket.Bolt = AsyncBolt

9578398d67c4ab380e45b5e1357b9a225ddd1afc

py

Python

examples/ex09/process.py

oditorium/PageBuilder

74fa95285d41ed390f46f22129a45900c1d8b474

examples/ex09/process.py

oditorium/PageBuilder

74fa95285d41ed390f46f22129a45900c1d8b474

examples/ex09/process.py

oditorium/PageBuilder

74fa95285d41ed390f46f22129a45900c1d8b474

#!/usr/bin/env python3 """ process data generated by PageBuilder """ import json INFN = "document.json" OUTFN = "_DATA.json" print ("PROCESSING ===========================================================") ######################################################################## ## READING THE INPUT FILE print ("reading", INFN) with open(INFN, "r") as f: document_json = f.read() print ("parsing", INFN) document_data = json.loads(document_json) print ("analysing {} ({} records)".format(INFN, len(document_data))) data = [] FIELDS = ["_filename", "data"] for r in document_data: data.append({ k: r.get(k, None) for k in FIELDS}) print ("extracted {} records".format(len(data))) print ("EXTRACTED DATA:", data) ######################################################################## ## PROCESSING out_sums = {} for i in range(len(data)): d = data[i] sdata = d['data'].split(",") sdata = map(int, sdata) out_sums[d["_filename"]] = {"sum": sum(sdata)} ######################################################################## ## WRITING THE OUTPUT FILE out = { "_select": out_sums, # the key `_select` is special; it MUST contain a dict where the # dict keys are the filename (from the `_filename` field); when # a specific file `filename` is processed, the content of # out["_select"][filename] (which must be a dict) is added to # the environment, and can be added in the template #"sums": 1, } with open(OUTFN, "w") as f: f.write(json.dumps(out)) print("OUT:", out) print ("END PROCESSING =======================================================")

#!/usr/bin/env python3 """ process data generated by PageBuilder """ import json INFN = "document.json" OUTFN = "_DATA.json" print ("PROCESSING ===========================================================") ######################################################################## ## READING THE INPUT FILE print ("reading", INFN) with open(INFN, "r") as f: document_json = f.read() print ("parsing", INFN) document_data = json.loads(document_json) print ("analysing {} ({} records)".format(INFN, len(document_data))) data = [] FIELDS = ["_filename", "data"] for r in document_data: data.append({ k: r.get(k, None) for k in FIELDS}) print ("extracted {} records".format(len(data))) print ("EXTRACTED DATA:", data) ######################################################################## ## PROCESSING out_sums = {} for i in range(len(data)): d = data[i] sdata = d['data'].split(",") sdata = map(int, sdata) out_sums[d["_filename"]] = {"sum": sum(sdata)} ######################################################################## ## WRITING THE OUTPUT FILE out = { "_select": out_sums, # the key `_select` is special; it MUST contain a dict where the # dict keys are the filename (from the `_filename` field); when # a specific file `filename` is processed, the content of # out["_select"][filename] (which must be a dict) is added to # the environment, and can be added in the template #"sums": 1, } with open(OUTFN, "w") as f: f.write(json.dumps(out)) print("OUT:", out) print ("END PROCESSING =======================================================")

18e2ff9e48d9884824271b259f5494d590944f7d

py

Python

cyder/api/v1/endpoints/dhcp/vrf/__init__.py

drkitty/cyder

1babc443cc03aa51fa3c1015bcd22f0ea2e5f0f8

2015-04-16T23:18:22.000Z

2020-08-25T22:50:13.000Z

cyder/api/v1/endpoints/dhcp/vrf/__init__.py

drkitty/cyder

1babc443cc03aa51fa3c1015bcd22f0ea2e5f0f8

2015-01-01T00:18:57.000Z

2015-10-14T00:01:13.000Z

cyder/api/v1/endpoints/dhcp/vrf/__init__.py

drkitty/cyder

1babc443cc03aa51fa3c1015bcd22f0ea2e5f0f8

2015-03-23T00:57:09.000Z

2019-09-09T22:42:37.000Z

from cyder.api.v1.endpoints.dhcp.vrf import api

from cyder.api.v1.endpoints.dhcp.vrf import api

8a8cfc04c5c7ae8b231f967292f73edd9f04f568

py

Python

oogli/Texture.py

brianbruggeman/oogli

6a6f681468d609035924ede27d895afcc9d432b6

2016-01-18T22:10:51.000Z

2016-06-10T16:02:55.000Z

oogli/Texture.py

brianbruggeman/oogli

6a6f681468d609035924ede27d895afcc9d432b6

oogli/Texture.py

brianbruggeman/oogli

6a6f681468d609035924ede27d895afcc9d432b6

#!/usr/bin/env python # -*- coding: utf-8 -*-

#!/usr/bin/env python # -*- coding: utf-8 -*- class Texture(object): def __init__(self, *args, **kwds): '''TODO: something'''

a2787fee555cd02e69dfc120dfda3be28257df6b

py

Python

pyramids/rules/token_set.py

leomauro/pyramids

4f7a8e97e13a5ee0b037dc528e5ba72f31ac36e5

2015-09-04T22:33:40.000Z

2019-04-11T14:05:11.000Z

pyramids/rules/token_set.py

leomauro/pyramids

4f7a8e97e13a5ee0b037dc528e5ba72f31ac36e5

2015-09-04T22:31:44.000Z

2017-07-29T04:11:53.000Z

pyramids/rules/token_set.py

hosford42/pyramids

4f7a8e97e13a5ee0b037dc528e5ba72f31ac36e5

2015-10-14T12:41:26.000Z

2022-01-08T19:43:47.000Z

import os from sys import intern from typing import Iterable, FrozenSet, Optional from pyramids.categorization import Category from pyramids.rules.leaf import LeafRule from pyramids.word_sets import WordSetUtils

import os from sys import intern from typing import Iterable, FrozenSet, Optional from pyramids.categorization import Category from pyramids.rules.leaf import LeafRule from pyramids.word_sets import WordSetUtils class SetRule(LeafRule): @classmethod def from_word_set(cls, file_path: str, verbose: bool = False) -> 'SetRule': """Load a word set and return it as a set rule.""" from pyramids.grammar import GrammarSyntaxError, GrammarParser folder, filename = os.path.split(file_path) category_definition = os.path.splitext(filename)[0] try: category = GrammarParser.parse_category(category_definition) except GrammarSyntaxError as error: raise IOError("Badly named word set file: " + file_path) from error if verbose: print("Loading category", str(category), "from", file_path, "...") return SetRule(category, WordSetUtils.load_word_set(file_path), _word_set_path=file_path) def __init__(self, category: Category, tokens: Iterable[str], *, _word_set_path: str = None): super().__init__(category) self._tokens = frozenset(intern(token.lower()) for token in tokens) self._hash = hash(self._category) ^ hash(self._tokens) self._word_set_path = _word_set_path def __hash__(self) -> int: return self._hash def __eq__(self, other: 'SetRule') -> bool: if not isinstance(other, SetRule): return NotImplemented return self is other or (self._hash == other._hash and self._category == other._category and self._tokens == other._tokens) def __ne__(self, other: 'SetRule') -> bool: if not isinstance(other, SetRule): return NotImplemented return not (self == other) def __contains__(self, token: str) -> bool: return token.lower() in self._tokens def __repr__(self) -> str: if self._word_set_path is None: if len(self.tokens) > 10: return '<%s: %s>' % (type(self).__name__, str(self)) else: return type(self).__name__ + repr((self.category, sorted(self.tokens))) else: return '%s.from_word_set(%r)' % (type(self).__name__, self.word_set_path,) def __str__(self) -> str: return str(self.category) + '.ctg' @property def tokens(self) -> FrozenSet[str]: return self._tokens @property def word_set_path(self) -> Optional[str]: return self._word_set_path

fc7058a10d7e658bef7595f63f5638b9966e1a4c

py

Python

neutron/common/config.py

plumgrid/plumgrid-quantum

dbd7e472ca28d22d694eeeba47e0738985583961

2016-04-23T21:33:31.000Z

2016-04-23T21:33:31.000Z

neutron/common/config.py

plumgrid/plumgrid-quantum

dbd7e472ca28d22d694eeeba47e0738985583961

neutron/common/config.py

plumgrid/plumgrid-quantum

dbd7e472ca28d22d694eeeba47e0738985583961

2015-04-14T10:06:51.000Z

2019-10-02T01:28:34.000Z

# vim: tabstop=4 shiftwidth=4 softtabstop=4 # Copyright 2011 Nicira Networks, Inc. # 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. """ Routines for configuring Neutron """ import os from oslo.config import cfg from paste import deploy from neutron.api.v2 import attributes from neutron.common import utils from neutron.openstack.common.db.sqlalchemy import session as db_session from neutron.openstack.common import log as logging from neutron.openstack.common import rpc from neutron.version import version_info as neutron_version LOG = logging.getLogger(__name__) core_opts = [ cfg.StrOpt('bind_host', default='0.0.0.0', help=_("The host IP to bind to")), cfg.IntOpt('bind_port', default=9696, help=_("The port to bind to")), cfg.StrOpt('api_paste_config', default="api-paste.ini", help=_("The API paste config file to use")), cfg.StrOpt('api_extensions_path', default="", help=_("The path for API extensions")), cfg.StrOpt('policy_file', default="policy.json", help=_("The policy file to use")), cfg.StrOpt('auth_strategy', default='keystone', help=_("The type of authentication to use")), cfg.StrOpt('core_plugin', help=_("The core plugin Neutron will use")), cfg.ListOpt('service_plugins', default=[], help=_("The service plugins Neutron will use")), cfg.StrOpt('base_mac', default="fa:16:3e:00:00:00", help=_("The base MAC address Neutron will use for VIFs")), cfg.IntOpt('mac_generation_retries', default=16, help=_("How many times Neutron will retry MAC generation")), cfg.BoolOpt('allow_bulk', default=True, help=_("Allow the usage of the bulk API")), cfg.BoolOpt('allow_pagination', default=False, help=_("Allow the usage of the pagination")), cfg.BoolOpt('allow_sorting', default=False, help=_("Allow the usage of the sorting")), cfg.StrOpt('pagination_max_limit', default="-1", help=_("The maximum number of items returned in a single " "response, value was 'infinite' or negative integer " "means no limit")), cfg.IntOpt('max_dns_nameservers', default=5, help=_("Maximum number of DNS nameservers")), cfg.IntOpt('max_subnet_host_routes', default=20, help=_("Maximum number of host routes per subnet")), cfg.IntOpt('max_fixed_ips_per_port', default=5, help=_("Maximum number of fixed ips per port")), cfg.IntOpt('dhcp_lease_duration', default=86400, deprecated_name='dhcp_lease_time', help=_("DHCP lease duration")), cfg.BoolOpt('dhcp_agent_notification', default=True, help=_("Allow sending resource operation" " notification to DHCP agent")), cfg.BoolOpt('allow_overlapping_ips', default=False, help=_("Allow overlapping IP support in Neutron")), cfg.StrOpt('host', default=utils.get_hostname(), help=_("The hostname Neutron is running on")), cfg.BoolOpt('force_gateway_on_subnet', default=False, help=_("Ensure that configured gateway is on subnet")), ] core_cli_opts = [ cfg.StrOpt('state_path', default='/var/lib/neutron', help=_("Where to store Neutron state files. " "This directory must be writable by the agent.")), ] # Register the configuration options cfg.CONF.register_opts(core_opts) cfg.CONF.register_cli_opts(core_cli_opts) # Ensure that the control exchange is set correctly rpc.set_defaults(control_exchange='neutron') _SQL_CONNECTION_DEFAULT = 'sqlite://' # Update the default QueuePool parameters. These can be tweaked by the # configuration variables - max_pool_size, max_overflow and pool_timeout db_session.set_defaults(sql_connection=_SQL_CONNECTION_DEFAULT, sqlite_db='', max_pool_size=10, max_overflow=20, pool_timeout=10) def setup_logging(conf): """Sets up the logging options for a log with supplied name. :param conf: a cfg.ConfOpts object """ product_name = "neutron" logging.setup(product_name) LOG.info(_("Logging enabled!")) def load_paste_app(app_name): """Builds and returns a WSGI app from a paste config file. :param app_name: Name of the application to load :raises ConfigFilesNotFoundError when config file cannot be located :raises RuntimeError when application cannot be loaded from config file """ config_path = cfg.CONF.find_file(cfg.CONF.api_paste_config) if not config_path: raise cfg.ConfigFilesNotFoundError( config_files=[cfg.CONF.api_paste_config]) config_path = os.path.abspath(config_path) LOG.info(_("Config paste file: %s"), config_path) try: app = deploy.loadapp("config:%s" % config_path, name=app_name) except (LookupError, ImportError): msg = (_("Unable to load %(app_name)s from " "configuration file %(config_path)s.") % {'app_name': app_name, 'config_path': config_path}) LOG.exception(msg) raise RuntimeError(msg) return app

# vim: tabstop=4 shiftwidth=4 softtabstop=4 # Copyright 2011 Nicira Networks, Inc. # 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. """ Routines for configuring Neutron """ import os from oslo.config import cfg from paste import deploy from neutron.api.v2 import attributes from neutron.common import utils from neutron.openstack.common.db.sqlalchemy import session as db_session from neutron.openstack.common import log as logging from neutron.openstack.common import rpc from neutron.version import version_info as neutron_version LOG = logging.getLogger(__name__) core_opts = [ cfg.StrOpt('bind_host', default='0.0.0.0', help=_("The host IP to bind to")), cfg.IntOpt('bind_port', default=9696, help=_("The port to bind to")), cfg.StrOpt('api_paste_config', default="api-paste.ini", help=_("The API paste config file to use")), cfg.StrOpt('api_extensions_path', default="", help=_("The path for API extensions")), cfg.StrOpt('policy_file', default="policy.json", help=_("The policy file to use")), cfg.StrOpt('auth_strategy', default='keystone', help=_("The type of authentication to use")), cfg.StrOpt('core_plugin', help=_("The core plugin Neutron will use")), cfg.ListOpt('service_plugins', default=[], help=_("The service plugins Neutron will use")), cfg.StrOpt('base_mac', default="fa:16:3e:00:00:00", help=_("The base MAC address Neutron will use for VIFs")), cfg.IntOpt('mac_generation_retries', default=16, help=_("How many times Neutron will retry MAC generation")), cfg.BoolOpt('allow_bulk', default=True, help=_("Allow the usage of the bulk API")), cfg.BoolOpt('allow_pagination', default=False, help=_("Allow the usage of the pagination")), cfg.BoolOpt('allow_sorting', default=False, help=_("Allow the usage of the sorting")), cfg.StrOpt('pagination_max_limit', default="-1", help=_("The maximum number of items returned in a single " "response, value was 'infinite' or negative integer " "means no limit")), cfg.IntOpt('max_dns_nameservers', default=5, help=_("Maximum number of DNS nameservers")), cfg.IntOpt('max_subnet_host_routes', default=20, help=_("Maximum number of host routes per subnet")), cfg.IntOpt('max_fixed_ips_per_port', default=5, help=_("Maximum number of fixed ips per port")), cfg.IntOpt('dhcp_lease_duration', default=86400, deprecated_name='dhcp_lease_time', help=_("DHCP lease duration")), cfg.BoolOpt('dhcp_agent_notification', default=True, help=_("Allow sending resource operation" " notification to DHCP agent")), cfg.BoolOpt('allow_overlapping_ips', default=False, help=_("Allow overlapping IP support in Neutron")), cfg.StrOpt('host', default=utils.get_hostname(), help=_("The hostname Neutron is running on")), cfg.BoolOpt('force_gateway_on_subnet', default=False, help=_("Ensure that configured gateway is on subnet")), ] core_cli_opts = [ cfg.StrOpt('state_path', default='/var/lib/neutron', help=_("Where to store Neutron state files. " "This directory must be writable by the agent.")), ] # Register the configuration options cfg.CONF.register_opts(core_opts) cfg.CONF.register_cli_opts(core_cli_opts) # Ensure that the control exchange is set correctly rpc.set_defaults(control_exchange='neutron') _SQL_CONNECTION_DEFAULT = 'sqlite://' # Update the default QueuePool parameters. These can be tweaked by the # configuration variables - max_pool_size, max_overflow and pool_timeout db_session.set_defaults(sql_connection=_SQL_CONNECTION_DEFAULT, sqlite_db='', max_pool_size=10, max_overflow=20, pool_timeout=10) def parse(args): cfg.CONF(args=args, project='neutron', version='%%prog %s' % neutron_version.release_string()) # Validate that the base_mac is of the correct format msg = attributes._validate_regex(cfg.CONF.base_mac, attributes.MAC_PATTERN) if msg: msg = _("Base MAC: %s") % msg raise Exception(msg) def setup_logging(conf): """Sets up the logging options for a log with supplied name. :param conf: a cfg.ConfOpts object """ product_name = "neutron" logging.setup(product_name) LOG.info(_("Logging enabled!")) def load_paste_app(app_name): """Builds and returns a WSGI app from a paste config file. :param app_name: Name of the application to load :raises ConfigFilesNotFoundError when config file cannot be located :raises RuntimeError when application cannot be loaded from config file """ config_path = cfg.CONF.find_file(cfg.CONF.api_paste_config) if not config_path: raise cfg.ConfigFilesNotFoundError( config_files=[cfg.CONF.api_paste_config]) config_path = os.path.abspath(config_path) LOG.info(_("Config paste file: %s"), config_path) try: app = deploy.loadapp("config:%s" % config_path, name=app_name) except (LookupError, ImportError): msg = (_("Unable to load %(app_name)s from " "configuration file %(config_path)s.") % {'app_name': app_name, 'config_path': config_path}) LOG.exception(msg) raise RuntimeError(msg) return app

b12bdd3b7613ac6f1ca82e2ac22d65ec1929d997

py

Python

code/tmp_rtrip/test/test_structmembers.py

emilyemorehouse/ast-and-me

3f58117512e125e1ecbe3c72f2f0d26adb80b7b3

2018-01-23T05:28:40.000Z

2021-04-13T20:52:59.000Z

code/tmp_rtrip/test/test_structmembers.py

emilyemorehouse/ast-and-me

3f58117512e125e1ecbe3c72f2f0d26adb80b7b3

2017-12-21T18:32:31.000Z

2018-12-18T17:09:50.000Z

code/tmp_rtrip/test/test_structmembers.py

emilyemorehouse/ast-and-me

3f58117512e125e1ecbe3c72f2f0d26adb80b7b3

import unittest from test import support support.import_module('_testcapi') from _testcapi import _test_structmembersType, CHAR_MAX, CHAR_MIN, UCHAR_MAX, SHRT_MAX, SHRT_MIN, USHRT_MAX, INT_MAX, INT_MIN, UINT_MAX, LONG_MAX, LONG_MIN, ULONG_MAX, LLONG_MAX, LLONG_MIN, ULLONG_MAX, PY_SSIZE_T_MAX, PY_SSIZE_T_MIN ts = _test_structmembersType(False, 1, 2, 3, 4, 5, 6, 7, 8, 23, 9.99999, 10.101010101, 'hi') if __name__ == '__main__': unittest.main()

import unittest from test import support support.import_module('_testcapi') from _testcapi import _test_structmembersType, CHAR_MAX, CHAR_MIN, UCHAR_MAX, SHRT_MAX, SHRT_MIN, USHRT_MAX, INT_MAX, INT_MIN, UINT_MAX, LONG_MAX, LONG_MIN, ULONG_MAX, LLONG_MAX, LLONG_MIN, ULLONG_MAX, PY_SSIZE_T_MAX, PY_SSIZE_T_MIN ts = _test_structmembersType(False, 1, 2, 3, 4, 5, 6, 7, 8, 23, 9.99999, 10.101010101, 'hi') class ReadWriteTests(unittest.TestCase): def test_bool(self): ts.T_BOOL = True self.assertEqual(ts.T_BOOL, True) ts.T_BOOL = False self.assertEqual(ts.T_BOOL, False) self.assertRaises(TypeError, setattr, ts, 'T_BOOL', 1) def test_byte(self): ts.T_BYTE = CHAR_MAX self.assertEqual(ts.T_BYTE, CHAR_MAX) ts.T_BYTE = CHAR_MIN self.assertEqual(ts.T_BYTE, CHAR_MIN) ts.T_UBYTE = UCHAR_MAX self.assertEqual(ts.T_UBYTE, UCHAR_MAX) def test_short(self): ts.T_SHORT = SHRT_MAX self.assertEqual(ts.T_SHORT, SHRT_MAX) ts.T_SHORT = SHRT_MIN self.assertEqual(ts.T_SHORT, SHRT_MIN) ts.T_USHORT = USHRT_MAX self.assertEqual(ts.T_USHORT, USHRT_MAX) def test_int(self): ts.T_INT = INT_MAX self.assertEqual(ts.T_INT, INT_MAX) ts.T_INT = INT_MIN self.assertEqual(ts.T_INT, INT_MIN) ts.T_UINT = UINT_MAX self.assertEqual(ts.T_UINT, UINT_MAX) def test_long(self): ts.T_LONG = LONG_MAX self.assertEqual(ts.T_LONG, LONG_MAX) ts.T_LONG = LONG_MIN self.assertEqual(ts.T_LONG, LONG_MIN) ts.T_ULONG = ULONG_MAX self.assertEqual(ts.T_ULONG, ULONG_MAX) def test_py_ssize_t(self): ts.T_PYSSIZET = PY_SSIZE_T_MAX self.assertEqual(ts.T_PYSSIZET, PY_SSIZE_T_MAX) ts.T_PYSSIZET = PY_SSIZE_T_MIN self.assertEqual(ts.T_PYSSIZET, PY_SSIZE_T_MIN) @unittest.skipUnless(hasattr(ts, 'T_LONGLONG'), 'long long not present') def test_longlong(self): ts.T_LONGLONG = LLONG_MAX self.assertEqual(ts.T_LONGLONG, LLONG_MAX) ts.T_LONGLONG = LLONG_MIN self.assertEqual(ts.T_LONGLONG, LLONG_MIN) ts.T_ULONGLONG = ULLONG_MAX self.assertEqual(ts.T_ULONGLONG, ULLONG_MAX) ts.T_LONGLONG = 3 self.assertEqual(ts.T_LONGLONG, 3) ts.T_ULONGLONG = 4 self.assertEqual(ts.T_ULONGLONG, 4) def test_bad_assignments(self): integer_attributes = ['T_BOOL', 'T_BYTE', 'T_UBYTE', 'T_SHORT', 'T_USHORT', 'T_INT', 'T_UINT', 'T_LONG', 'T_ULONG', 'T_PYSSIZET'] if hasattr(ts, 'T_LONGLONG'): integer_attributes.extend(['T_LONGLONG', 'T_ULONGLONG']) for nonint in (None, 3.2j, 'full of eels', {}, []): for attr in integer_attributes: self.assertRaises(TypeError, setattr, ts, attr, nonint) def test_inplace_string(self): self.assertEqual(ts.T_STRING_INPLACE, 'hi') self.assertRaises(TypeError, setattr, ts, 'T_STRING_INPLACE', 's') self.assertRaises(TypeError, delattr, ts, 'T_STRING_INPLACE') class TestWarnings(unittest.TestCase): def test_byte_max(self): with support.check_warnings(('', RuntimeWarning)): ts.T_BYTE = CHAR_MAX + 1 def test_byte_min(self): with support.check_warnings(('', RuntimeWarning)): ts.T_BYTE = CHAR_MIN - 1 def test_ubyte_max(self): with support.check_warnings(('', RuntimeWarning)): ts.T_UBYTE = UCHAR_MAX + 1 def test_short_max(self): with support.check_warnings(('', RuntimeWarning)): ts.T_SHORT = SHRT_MAX + 1 def test_short_min(self): with support.check_warnings(('', RuntimeWarning)): ts.T_SHORT = SHRT_MIN - 1 def test_ushort_max(self): with support.check_warnings(('', RuntimeWarning)): ts.T_USHORT = USHRT_MAX + 1 if __name__ == '__main__': unittest.main()

ace8a02a07baa1d3676ee33620ccb26e1bf748c5

py

Python

src/predict.py

jamesmcclain/algae-model

45e3e83544034022aba16ad1ed254f1445e4bb1b

src/predict.py

jamesmcclain/algae-model

45e3e83544034022aba16ad1ed254f1445e4bb1b

src/predict.py

jamesmcclain/algae-model

45e3e83544034022aba16ad1ed254f1445e4bb1b

#!/usr/bin/env python3 import argparse import copy import logging import sys import warnings import numpy as np import rasterio as rio import torch import torch.hub import tqdm from rasterio.windows import Window BACKBONES = [ 'vgg16', 'densenet161', 'shufflenet_v2_x1_0', 'mobilenet_v2', 'mobilenet_v3_large', 'mobilenet_v3_small', 'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152', 'efficientnet_b0', 'efficientnet_b1', 'efficientnet_b2', 'efficientnet_b3', 'efficientnet_b4', 'efficientnet_b5', 'efficientnet_b6', 'efficientnet_b7', 'fpn_resnet18', 'fpn_resnet34', 'fpn_resnet50' ] if __name__ == '__main__': warnings.filterwarnings('ignore') args = cli_parser().parse_args() logging.basicConfig(stream=sys.stderr, level=logging.INFO, format='%(asctime)-15s %(message)s') log = logging.getLogger() n = args.window_size device = torch.device(args.device) model = torch.hub.load('jamesmcclain/algae-classifier:730726f5bccc679fa334da91fe4dc4cb71a35208', 'make_algae_model', in_channels=[4, 12, 224], prescale=args.prescale, backbone_str=args.backbone, pretrained=False) model.load_state_dict(torch.load(args.pth_load)) model.to(device) model.eval() if args.outfile is None: model_name = args.pth_load.split('/')[-1].split('.')[0] args.outfile = [transmute(f) for f in args.infile] for (infile, outfile) in zip(args.infile, args.outfile): log.info(outfile) with rio.open(infile, 'r') as infile_ds, torch.no_grad(): out_raw_profile = copy.deepcopy(infile_ds.profile) out_raw_profile.update({ 'compress': 'lzw', 'dtype': np.float32, 'count': 1, 'bigtiff': 'yes', 'sparse_ok': 'yes', 'tiled': 'yes', }) width = infile_ds.width height = infile_ds.height bandcount = infile_ds.count ar_out = torch.zeros((1, height, width), dtype=torch.float32).to(device) pixel_hits = torch.zeros((1, height, width), dtype=torch.uint8).to(device) if bandcount == 224: indexes = list(range(1, 224 + 1)) elif bandcount in {12, 13}: indexes = list(range(1, 12 + 1)) # NOTE: 13 bands does not indicate L1C support, this is # for Franklin COGs that have an extra band. bandcount = 12 elif bandcount == 4: indexes = list(range(1, 4 + 1)) elif bandcount == 5: indexes = [1, 2, 3, 5] bandcount = 4 else: raise Exception(f'bands={bandcount}') # gather up batches batches = [] for i in range(0, width - n, args.stride): for j in range(0, height - n, args.stride): batches.append((i, j)) batches = [batches[i:i + args.chunksize] for i in range(0, len(batches), args.chunksize)] for batch in tqdm.tqdm(batches): windows = [infile_ds.read(indexes, window=Window(i, j, n, n)) for (i, j) in batch] windows = [w.astype(np.float32) for w in windows] if args.ndwi_mask: windows = [w * (((w[2] - w[7]) / (w[2] + w[7])) > 0.0) for w in windows] try: windows = np.stack(windows, axis=0) except: continue windows = torch.from_numpy(windows).to(dtype=torch.float32, device=device) prob = model(windows) for k, (i, j) in enumerate(batch): if 'seg' in prob: _prob = torch.sigmoid(prob.get('seg')[k, 1]) - torch.sigmoid(prob.get('seg')[k, 0]) ar_out[0, j:(j + n), i:(i + n)] += _prob else: ar_out[0, j:(j + n), i:(i + n)] += torch.sigmoid(prob.get('class')[k, 0]) pixel_hits[0, j:(j + n), i:(i + n)] += 1 # Bring results back to CPU ar_out /= pixel_hits ar_out = ar_out.cpu().numpy() # Write results to file with rio.open(outfile, 'w', **out_raw_profile) as outfile_raw_ds: outfile_raw_ds.write(ar_out[0], indexes=1)

#!/usr/bin/env python3 import argparse import copy import logging import sys import warnings import numpy as np import rasterio as rio import torch import torch.hub import tqdm from rasterio.windows import Window BACKBONES = [ 'vgg16', 'densenet161', 'shufflenet_v2_x1_0', 'mobilenet_v2', 'mobilenet_v3_large', 'mobilenet_v3_small', 'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152', 'efficientnet_b0', 'efficientnet_b1', 'efficientnet_b2', 'efficientnet_b3', 'efficientnet_b4', 'efficientnet_b5', 'efficientnet_b6', 'efficientnet_b7', 'fpn_resnet18', 'fpn_resnet34', 'fpn_resnet50' ] def cli_parser(): parser = argparse.ArgumentParser() parser.add_argument('--backbone', required=True, type=str, choices=BACKBONES) parser.add_argument('--chunksize', required=False, type=int, default=256) parser.add_argument('--device', required=False, type=str, default='cuda', choices=['cuda', 'cpu']) parser.add_argument('--infile', required=True, type=str, nargs='+') parser.add_argument('--outfile', required=False, default=None, type=str, nargs='+') parser.add_argument('--prescale', required=False, type=int, default=1) parser.add_argument('--pth-load', required=True, type=str) parser.add_argument('--stride', required=False, type=int, default=13) parser.add_argument('--window-size', required=False, type=int, default=32) parser.add_argument('--ndwi-mask', required=False, dest='ndwi_mask', action='store_true') parser.set_defaults(ndwi_mask=False) return parser if __name__ == '__main__': warnings.filterwarnings('ignore') args = cli_parser().parse_args() logging.basicConfig(stream=sys.stderr, level=logging.INFO, format='%(asctime)-15s %(message)s') log = logging.getLogger() n = args.window_size device = torch.device(args.device) model = torch.hub.load('jamesmcclain/algae-classifier:730726f5bccc679fa334da91fe4dc4cb71a35208', 'make_algae_model', in_channels=[4, 12, 224], prescale=args.prescale, backbone_str=args.backbone, pretrained=False) model.load_state_dict(torch.load(args.pth_load)) model.to(device) model.eval() if args.outfile is None: model_name = args.pth_load.split('/')[-1].split('.')[0] def transmute(filename): filename = filename.split('/')[-1] filename = f"./predict-{model_name}-{filename}" if not filename.endswith('.tiff'): filename = filename.replace('.tif', '.tiff') return filename args.outfile = [transmute(f) for f in args.infile] for (infile, outfile) in zip(args.infile, args.outfile): log.info(outfile) with rio.open(infile, 'r') as infile_ds, torch.no_grad(): out_raw_profile = copy.deepcopy(infile_ds.profile) out_raw_profile.update({ 'compress': 'lzw', 'dtype': np.float32, 'count': 1, 'bigtiff': 'yes', 'sparse_ok': 'yes', 'tiled': 'yes', }) width = infile_ds.width height = infile_ds.height bandcount = infile_ds.count ar_out = torch.zeros((1, height, width), dtype=torch.float32).to(device) pixel_hits = torch.zeros((1, height, width), dtype=torch.uint8).to(device) if bandcount == 224: indexes = list(range(1, 224 + 1)) elif bandcount in {12, 13}: indexes = list(range(1, 12 + 1)) # NOTE: 13 bands does not indicate L1C support, this is # for Franklin COGs that have an extra band. bandcount = 12 elif bandcount == 4: indexes = list(range(1, 4 + 1)) elif bandcount == 5: indexes = [1, 2, 3, 5] bandcount = 4 else: raise Exception(f'bands={bandcount}') # gather up batches batches = [] for i in range(0, width - n, args.stride): for j in range(0, height - n, args.stride): batches.append((i, j)) batches = [batches[i:i + args.chunksize] for i in range(0, len(batches), args.chunksize)] for batch in tqdm.tqdm(batches): windows = [infile_ds.read(indexes, window=Window(i, j, n, n)) for (i, j) in batch] windows = [w.astype(np.float32) for w in windows] if args.ndwi_mask: windows = [w * (((w[2] - w[7]) / (w[2] + w[7])) > 0.0) for w in windows] try: windows = np.stack(windows, axis=0) except: continue windows = torch.from_numpy(windows).to(dtype=torch.float32, device=device) prob = model(windows) for k, (i, j) in enumerate(batch): if 'seg' in prob: _prob = torch.sigmoid(prob.get('seg')[k, 1]) - torch.sigmoid(prob.get('seg')[k, 0]) ar_out[0, j:(j + n), i:(i + n)] += _prob else: ar_out[0, j:(j + n), i:(i + n)] += torch.sigmoid(prob.get('class')[k, 0]) pixel_hits[0, j:(j + n), i:(i + n)] += 1 # Bring results back to CPU ar_out /= pixel_hits ar_out = ar_out.cpu().numpy() # Write results to file with rio.open(outfile, 'w', **out_raw_profile) as outfile_raw_ds: outfile_raw_ds.write(ar_out[0], indexes=1)

ed5cc620f755b91673991e6e44482f82fb01cfdf

py

Python

tz_detect/defaults.py

dkirkham/django-tz-detect

ec3c66a967e2518adf070bfd42a9076471f1bc2a