content
stringlengths 7
928k
| avg_line_length
float64 3.5
33.8k
| max_line_length
int64 6
139k
| alphanum_fraction
float64 0.08
0.96
| licenses
sequence | repository_name
stringlengths 7
104
| path
stringlengths 4
230
| size
int64 7
928k
| lang
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|
# Copyright 2020 gRPC authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""The Python AsyncIO implementation of the GRPC helloworld.Greeter server."""
import logging
import asyncio
import grpc
import helloworld_pb2
import helloworld_pb2_grpc
class Greeter(helloworld_pb2_grpc.GreeterServicer):
async def SayHello(
self, request: helloworld_pb2.HelloRequest,
context: grpc.aio.ServicerContext) -> helloworld_pb2.HelloReply:
return helloworld_pb2.HelloReply(message='Hello, %s!' % request.name)
async def serve() -> None:
server = grpc.aio.server()
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
listen_addr = '[::]:50051'
server.add_insecure_port(listen_addr)
logging.info("Starting server on %s", listen_addr)
await server.start()
try:
await server.wait_for_termination()
except KeyboardInterrupt:
# Shuts down the server with 0 seconds of grace period. During the
# grace period, the server won't accept new connections and allow
# existing RPCs to continue within the grace period.
await server.stop(0)
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO)
asyncio.run(serve())
| 34.215686 | 78 | 0.731805 | [
"Apache-2.0"
] | 1261385937/grpc | examples/python/helloworld/async_greeter_server.py | 1,745 | Python |
import scipy.sparse as sp
import numpy as np
import torch
import time
import os
from configparser import ConfigParser
import sys
sys.path.append('/home/shiyan/project/gcn_for_prediction_of_protein_interactions/')
from src.util.load_data import load_data, sparse_to_tuple, mask_test_edges, preprocess_graph
from src.util.loss import arga_loss_function, varga_loss_function
from src.util.metrics import get_roc_score
from src.util import define_optimizer
from src.graph_nheads_att_gan.model import NHGATModelGAN
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
class Train():
def __init__(self):
pass
def train_model(self, config_path):
if os.path.exists(config_path) and (os.path.split(config_path)[1].split('.')[0] == 'config') and (
os.path.splitext(config_path)[1].split('.')[1] == 'cfg'):
# load config file
config = ConfigParser()
config.read(config_path)
section = config.sections()[0]
# data catalog path
data_catalog = config.get(section, "data_catalog")
# train file path
train_file_name = config.get(section, "train_file_name")
# model save/load path
model_path = config.get(section, "model_path")
# model param config
hidden_dim1 = config.getint(section, "hidden_dim1")
hidden_dim2 = config.getint(section, "hidden_dim2")
hidden_dim3 = config.getint(section, 'hidden_dim3')
num_heads = config.getint(section, 'num_heads')
dropout = config.getfloat(section, "dropout")
vae_bool = config.getboolean(section, 'vae_bool')
alpha = config.getfloat(section, 'alpha')
lr = config.getfloat(section, "lr")
lr_decay = config.getfloat(section, 'lr_decay')
weight_decay = config.getfloat(section, "weight_decay")
gamma = config.getfloat(section, "gamma")
momentum = config.getfloat(section, "momentum")
eps = config.getfloat(section, "eps")
clip = config.getfloat(section, "clip")
epochs = config.getint(section, "epochs")
optimizer_name = config.get(section, "optimizer")
# 加载相关数据
adj = load_data(os.path.join(data_catalog, train_file_name))
num_nodes = adj.shape[0]
num_edges = adj.sum()
features = sparse_to_tuple(sp.identity(num_nodes))
num_features = features[2][1]
# 去除对角线元素
# 下边的右部分为：返回adj_orig的对角元素（一维），并增加一维，抽出adj_orig的对角元素并构建只有这些对角元素的对角矩阵
adj_orig = adj - sp.dia_matrix((adj.diagonal()[np.newaxis, :], [0]), shape=adj.shape)
adj_orig.eliminate_zeros()
adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges(adj_orig)
adj = adj_train
# 返回D^{-0.5}SD^{-0.5}的coords, data, shape，其中S=A+I
adj_norm = preprocess_graph(adj)
adj_label = adj_train + sp.eye(adj_train.shape[0])
# adj_label = sparse_to_tuple(adj_label)
adj_label = torch.FloatTensor(adj_label.toarray()).to(DEVICE)
'''
注意，adj的每个元素非1即0。pos_weight是用于训练的邻接矩阵中负样本边（既不存在的边）和正样本边的倍数（即比值），这个数值在二分类交叉熵损失函数中用到，
如果正样本边所占的比例和负样本边所占比例失衡，比如正样本边很多，负样本边很少，那么在求loss的时候可以提供weight参数，将正样本边的weight设置小一点，负样本边的weight设置大一点，
此时能够很好的平衡两类在loss中的占比，任务效果可以得到进一步提升。参考：https://www.zhihu.com/question/383567632
负样本边的weight都为1，正样本边的weight都为pos_weight
'''
pos_weight = float(adj.shape[0] * adj.shape[0] - num_edges) / num_edges
norm = adj.shape[0] * adj.shape[0] / float((adj.shape[0] * adj.shape[0] - adj.sum()) * 2)
# create model
print('create model ...')
model = NHGATModelGAN(num_features, hidden_dim1=hidden_dim1, hidden_dim2=hidden_dim2, hidden_dim3=hidden_dim3, num_heads=num_heads, dropout=dropout, alpha=alpha, vae_bool=vae_bool)
# define optimizer
if optimizer_name == 'adam':
optimizer = define_optimizer.define_optimizer_adam(model, lr=lr, weight_decay=weight_decay)
elif optimizer_name == 'adamw':
optimizer = define_optimizer.define_optimizer_adamw(model, lr=lr, weight_decay=weight_decay)
elif optimizer_name == 'sgd':
optimizer = define_optimizer.define_optimizer_sgd(model, lr=lr, momentum=momentum,
weight_decay=weight_decay)
elif optimizer_name == 'adagrad':
optimizer = define_optimizer.define_optimizer_adagrad(model, lr=lr, lr_decay=lr_decay,
weight_decay=weight_decay)
elif optimizer_name == 'rmsprop':
optimizer = define_optimizer.define_optimizer_rmsprop(model, lr=lr, weight_decay=weight_decay,
momentum=momentum)
elif optimizer_name == 'adadelta':
optimizer = define_optimizer.define_optimizer_adadelta(model, lr=lr, weight_decay=weight_decay)
else:
raise NameError('No define optimization function name!')
model = model.to(DEVICE)
# 稀疏张量被表示为一对致密张量：一维张量和二维张量的索引。可以通过提供这两个张量来构造稀疏张量
adj_norm = torch.sparse.FloatTensor(torch.LongTensor(adj_norm[0].T),
torch.FloatTensor(adj_norm[1]),
torch.Size(adj_norm[2]))
features = torch.sparse.FloatTensor(torch.LongTensor(features[0].T),
torch.FloatTensor(features[1]),
torch.Size(features[2])).to_dense()
adj_norm = adj_norm.to(DEVICE)
features = features.to(DEVICE)
norm = torch.FloatTensor(np.array(norm)).to(DEVICE)
pos_weight = torch.tensor(pos_weight).to(DEVICE)
num_nodes = torch.tensor(num_nodes).to(DEVICE)
print('start training...')
best_valid_roc_score = float('-inf')
hidden_emb = None
model.train()
for epoch in range(epochs):
t = time.time()
optimizer.zero_grad()
# 解码后的邻接矩阵，判别器
recovered, dis_real, dis_fake, mu, logvar = model(features, adj_norm)
if vae_bool:
loss = varga_loss_function(preds=recovered, labels=adj_label,
mu=mu, logvar=logvar,
dis_real=dis_real, dis_fake=dis_fake,
n_nodes=num_nodes,
norm=norm, pos_weight=pos_weight)
else:
loss = arga_loss_function(preds=recovered, labels=adj_label,
dis_real=dis_real, dis_fake=dis_fake,
norm=norm, pos_weight=pos_weight)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), clip)
cur_loss = loss.item()
optimizer.step()
hidden_emb = mu.data.cpu().numpy()
# 评估验证集，val set
roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, val_edges, val_edges_false)
# 保存最好的roc score
if roc_score > best_valid_roc_score:
best_valid_roc_score = roc_score
# 不需要保存整个model，只需保存hidden_emb，因为后面的解码是用hidden_emb内积的形式作推断
np.save(model_path, hidden_emb)
print("Epoch:", '%04d' % (epoch + 1), "train_loss = ", "{:.5f}".format(cur_loss),
"val_roc_score = ", "{:.5f}".format(roc_score),
"average_precision_score = ", "{:.5f}".format(ap_score),
"time=", "{:.5f}".format(time.time() - t)
)
print("Optimization Finished!")
# 评估测试集，test set
roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false)
print('test roc score: {}'.format(roc_score))
print('test ap score: {}'.format(ap_score))
else:
raise FileNotFoundError('File config.cfg not found : ' + config_path)
if __name__ == '__main__':
config_path = os.path.join(os.getcwd(), 'config.cfg')
train = Train()
train.train_model(config_path)
| 47.351351 | 192 | 0.574543 | [
"Apache-2.0"
] | jiangnanboy/gcn_for_prediction_of_protein_interactions | src/graph_nheads_att_gan/train.py | 9,490 | Python |
# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for backend_context."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import operator
try:
# python version >= 3.3
from unittest import mock
except ImportError:
import mock # pylint: disable=unused-import
import tensorflow as tf
from google.protobuf import text_format
from tensorboard import context
from tensorboard.backend.event_processing import data_provider
from tensorboard.backend.event_processing import event_accumulator
from tensorboard.backend.event_processing import plugin_event_multiplexer
from tensorboard.compat.proto import summary_pb2
from tensorboard.plugins import base_plugin
from tensorboard.plugins.hparams import api_pb2
from tensorboard.plugins.hparams import backend_context
from tensorboard.plugins.hparams import metadata
from tensorboard.plugins.hparams import plugin_data_pb2
from tensorboard.plugins.scalar import metadata as scalars_metadata
DATA_TYPE_EXPERIMENT = "experiment"
DATA_TYPE_SESSION_START_INFO = "session_start_info"
DATA_TYPE_SESSION_END_INFO = "session_end_info"
class BackendContextTest(tf.test.TestCase):
# Make assertProtoEquals print all the diff.
maxDiff = None # pylint: disable=invalid-name
def setUp(self):
self._mock_tb_context = base_plugin.TBContext()
# TODO(#3425): Remove mocking or switch to mocking data provider
# APIs directly.
self._mock_multiplexer = mock.create_autospec(
plugin_event_multiplexer.EventMultiplexer
)
self._mock_tb_context.multiplexer = self._mock_multiplexer
self._mock_multiplexer.PluginRunToTagToContent.side_effect = (
self._mock_plugin_run_to_tag_to_content
)
self._mock_multiplexer.AllSummaryMetadata.side_effect = (
self._mock_all_summary_metadata
)
self._mock_multiplexer.SummaryMetadata.side_effect = (
self._mock_summary_metadata
)
self._mock_tb_context.data_provider = data_provider.MultiplexerDataProvider(
self._mock_multiplexer, "/path/to/logs"
)
self.session_1_start_info_ = ""
self.session_2_start_info_ = ""
self.session_3_start_info_ = ""
def _mock_all_summary_metadata(self):
result = {}
hparams_content = {
"exp/session_1": {
metadata.SESSION_START_INFO_TAG: self._serialized_plugin_data(
DATA_TYPE_SESSION_START_INFO, self.session_1_start_info_
),
},
"exp/session_2": {
metadata.SESSION_START_INFO_TAG: self._serialized_plugin_data(
DATA_TYPE_SESSION_START_INFO, self.session_2_start_info_
),
},
"exp/session_3": {
metadata.SESSION_START_INFO_TAG: self._serialized_plugin_data(
DATA_TYPE_SESSION_START_INFO, self.session_3_start_info_
),
},
}
scalars_content = {
"exp/session_1": {"loss": b"", "accuracy": b""},
"exp/session_1/eval": {"loss": b"",},
"exp/session_1/train": {"loss": b"",},
"exp/session_2": {"loss": b"", "accuracy": b"",},
"exp/session_2/eval": {"loss": b"",},
"exp/session_2/train": {"loss": b"",},
"exp/session_3": {"loss": b"", "accuracy": b"",},
"exp/session_3/eval": {"loss": b"",},
"exp/session_3xyz/": {"loss2": b"",},
}
for (run, tag_to_content) in hparams_content.items():
result.setdefault(run, {})
for (tag, content) in tag_to_content.items():
m = summary_pb2.SummaryMetadata()
m.data_class = summary_pb2.DATA_CLASS_TENSOR
m.plugin_data.plugin_name = metadata.PLUGIN_NAME
m.plugin_data.content = content
result[run][tag] = m
for (run, tag_to_content) in scalars_content.items():
result.setdefault(run, {})
for (tag, content) in tag_to_content.items():
m = summary_pb2.SummaryMetadata()
m.data_class = summary_pb2.DATA_CLASS_SCALAR
m.plugin_data.plugin_name = scalars_metadata.PLUGIN_NAME
m.plugin_data.content = content
result[run][tag] = m
return result
def _mock_plugin_run_to_tag_to_content(self, plugin_name):
result = {}
for (
run,
tag_to_metadata,
) in self._mock_multiplexer.AllSummaryMetadata().items():
for (tag, metadata) in tag_to_metadata.items():
if metadata.plugin_data.plugin_name != plugin_name:
continue
result.setdefault(run, {})
result[run][tag] = metadata.plugin_data.content
return result
def _mock_summary_metadata(self, run, tag):
return self._mock_multiplexer.AllSummaryMetadata()[run][tag]
def test_experiment_with_experiment_tag(self):
experiment = """
description: 'Test experiment'
metric_infos: [
{ name: { tag: 'current_temp' } }
]
"""
run = "exp"
tag = metadata.EXPERIMENT_TAG
m = summary_pb2.SummaryMetadata()
m.data_class = summary_pb2.DATA_CLASS_TENSOR
m.plugin_data.plugin_name = metadata.PLUGIN_NAME
m.plugin_data.content = self._serialized_plugin_data(
DATA_TYPE_EXPERIMENT, experiment
)
self._mock_multiplexer.AllSummaryMetadata.side_effect = None
self._mock_multiplexer.AllSummaryMetadata.return_value = {run: {tag: m}}
ctxt = backend_context.Context(self._mock_tb_context)
request_ctx = context.RequestContext()
self.assertProtoEquals(
experiment,
ctxt.experiment_from_metadata(
request_ctx, "123", ctxt.hparams_metadata(request_ctx, "123")
),
)
def test_experiment_without_experiment_tag(self):
self.session_1_start_info_ = """
hparams: [
{key: 'batch_size' value: {number_value: 100}},
{key: 'lr' value: {number_value: 0.01}},
{key: 'model_type' value: {string_value: 'CNN'}}
]
"""
self.session_2_start_info_ = """
hparams:[
{key: 'batch_size' value: {number_value: 200}},
{key: 'lr' value: {number_value: 0.02}},
{key: 'model_type' value: {string_value: 'LATTICE'}}
]
"""
self.session_3_start_info_ = """
hparams:[
{key: 'batch_size' value: {number_value: 300}},
{key: 'lr' value: {number_value: 0.05}},
{key: 'model_type' value: {string_value: 'CNN'}}
]
"""
expected_exp = """
hparam_infos: {
name: 'batch_size'
type: DATA_TYPE_FLOAT64
},
hparam_infos: {
name: 'lr'
type: DATA_TYPE_FLOAT64
},
hparam_infos: {
name: 'model_type'
type: DATA_TYPE_STRING
domain_discrete: {
values: [{string_value: 'CNN'},
{string_value: 'LATTICE'}]
}
}
metric_infos: {
name: {group: '', tag: 'accuracy'}
}
metric_infos: {
name: {group: '', tag: 'loss'}
}
metric_infos: {
name: {group: 'eval', tag: 'loss'}
}
metric_infos: {
name: {group: 'train', tag: 'loss'}
}
"""
ctxt = backend_context.Context(self._mock_tb_context)
request_ctx = context.RequestContext()
actual_exp = ctxt.experiment_from_metadata(
request_ctx, "123", ctxt.hparams_metadata(request_ctx, "123")
)
_canonicalize_experiment(actual_exp)
self.assertProtoEquals(expected_exp, actual_exp)
def test_experiment_without_experiment_tag_different_hparam_types(self):
self.session_1_start_info_ = """
hparams:[
{key: 'batch_size' value: {number_value: 100}},
{key: 'lr' value: {string_value: '0.01'}}
]
"""
self.session_2_start_info_ = """
hparams:[
{key: 'lr' value: {number_value: 0.02}},
{key: 'model_type' value: {string_value: 'LATTICE'}}
]
"""
self.session_3_start_info_ = """
hparams:[
{key: 'batch_size' value: {bool_value: true}},
{key: 'model_type' value: {string_value: 'CNN'}}
]
"""
expected_exp = """
hparam_infos: {
name: 'batch_size'
type: DATA_TYPE_STRING
domain_discrete: {
values: [{string_value: '100.0'},
{string_value: 'true'}]
}
}
hparam_infos: {
name: 'lr'
type: DATA_TYPE_STRING
domain_discrete: {
values: [{string_value: '0.01'},
{string_value: '0.02'}]
}
}
hparam_infos: {
name: 'model_type'
type: DATA_TYPE_STRING
domain_discrete: {
values: [{string_value: 'CNN'},
{string_value: 'LATTICE'}]
}
}
metric_infos: {
name: {group: '', tag: 'accuracy'}
}
metric_infos: {
name: {group: '', tag: 'loss'}
}
metric_infos: {
name: {group: 'eval', tag: 'loss'}
}
metric_infos: {
name: {group: 'train', tag: 'loss'}
}
"""
ctxt = backend_context.Context(self._mock_tb_context)
request_ctx = context.RequestContext()
actual_exp = ctxt.experiment_from_metadata(
request_ctx, "123", ctxt.hparams_metadata(request_ctx, "123")
)
_canonicalize_experiment(actual_exp)
self.assertProtoEquals(expected_exp, actual_exp)
def test_experiment_without_experiment_tag_many_distinct_values(self):
self.session_1_start_info_ = """
hparams:[
{key: 'batch_size' value: {number_value: 100}},
{key: 'lr' value: {string_value: '0.01'}}
]
"""
self.session_2_start_info_ = """
hparams:[
{key: 'lr' value: {number_value: 0.02}},
{key: 'model_type' value: {string_value: 'CNN'}}
]
"""
self.session_3_start_info_ = """
hparams:[
{key: 'batch_size' value: {bool_value: true}},
{key: 'model_type' value: {string_value: 'CNN'}}
]
"""
expected_exp = """
hparam_infos: {
name: 'batch_size'
type: DATA_TYPE_STRING
}
hparam_infos: {
name: 'lr'
type: DATA_TYPE_STRING
}
hparam_infos: {
name: 'model_type'
type: DATA_TYPE_STRING
domain_discrete: {
values: [{string_value: 'CNN'}]
}
}
metric_infos: {
name: {group: '', tag: 'accuracy'}
}
metric_infos: {
name: {group: '', tag: 'loss'}
}
metric_infos: {
name: {group: 'eval', tag: 'loss'}
}
metric_infos: {
name: {group: 'train', tag: 'loss'}
}
"""
ctxt = backend_context.Context(
self._mock_tb_context, max_domain_discrete_len=1
)
request_ctx = context.RequestContext()
actual_exp = ctxt.experiment_from_metadata(
request_ctx, "123", ctxt.hparams_metadata(request_ctx, "123"),
)
_canonicalize_experiment(actual_exp)
self.assertProtoEquals(expected_exp, actual_exp)
def _serialized_plugin_data(self, data_oneof_field, text_protobuffer):
oneof_type_dict = {
DATA_TYPE_EXPERIMENT: api_pb2.Experiment,
DATA_TYPE_SESSION_START_INFO: plugin_data_pb2.SessionStartInfo,
DATA_TYPE_SESSION_END_INFO: plugin_data_pb2.SessionEndInfo,
}
protobuffer = text_format.Merge(
text_protobuffer, oneof_type_dict[data_oneof_field]()
)
plugin_data = plugin_data_pb2.HParamsPluginData()
getattr(plugin_data, data_oneof_field).CopyFrom(protobuffer)
return metadata.create_summary_metadata(plugin_data).plugin_data.content
def _canonicalize_experiment(exp):
"""Sorts the repeated fields of an Experiment message."""
exp.hparam_infos.sort(key=operator.attrgetter("name"))
exp.metric_infos.sort(key=operator.attrgetter("name.group", "name.tag"))
for hparam_info in exp.hparam_infos:
if hparam_info.HasField("domain_discrete"):
hparam_info.domain_discrete.values.sort(
key=operator.attrgetter("string_value")
)
if __name__ == "__main__":
tf.test.main()
| 37.452128 | 84 | 0.569805 | [
"Apache-2.0"
] | aryaman4/tensorboard | tensorboard/plugins/hparams/backend_context_test.py | 14,082 | Python |
#!/usr/bin/env python2
# Copyright (c) 2014-2015 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import *
# Create one-input, one-output, no-fee transaction:
class RawTransactionsTest(BitcoinTestFramework):
def setup_chain(self):
print("Initializing test directory "+self.options.tmpdir)
initialize_chain_clean(self.options.tmpdir, 4)
def setup_network(self, split=False):
self.nodes = start_nodes(4, self.options.tmpdir)
connect_nodes_bi(self.nodes,0,1)
connect_nodes_bi(self.nodes,1,2)
connect_nodes_bi(self.nodes,0,2)
connect_nodes_bi(self.nodes,0,3)
self.is_network_split=False
self.sync_all()
def run_test(self):
print "Mining blocks..."
min_relay_tx_fee = self.nodes[0].getnetworkinfo()['relayfee']
# This test is not meant to test fee estimation and we'd like
# to be sure all txs are sent at a consistent desired feerate
for node in self.nodes:
node.settxfee(min_relay_tx_fee)
# if the fee's positive delta is higher than this value tests will fail,
# neg. delta always fail the tests.
# The size of the signature of every input may be at most 2 bytes larger
# than a minimum sized signature.
# = 2 bytes * minRelayTxFeePerByte
feeTolerance = 2 * min_relay_tx_fee/1000
self.nodes[2].generate(1)
self.sync_all()
self.nodes[0].generate(121)
self.sync_all()
watchonly_address = self.nodes[0].getnewaddress()
watchonly_pubkey = self.nodes[0].validateaddress(watchonly_address)["pubkey"]
watchonly_amount = Decimal(2000)
self.nodes[3].importpubkey(watchonly_pubkey, "", True)
watchonly_txid = self.nodes[0].sendtoaddress(watchonly_address, watchonly_amount)
self.nodes[0].sendtoaddress(self.nodes[3].getnewaddress(), watchonly_amount / 10)
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 15)
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10)
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 50)
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
###############
# simple test #
###############
inputs = [ ]
outputs = { self.nodes[0].getnewaddress() : 10 }
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
fee = rawtxfund['fee']
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
assert(len(dec_tx['vin']) > 0) #test if we have enought inputs
##############################
# simple test with two coins #
##############################
inputs = [ ]
outputs = { self.nodes[0].getnewaddress() : 22 }
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
fee = rawtxfund['fee']
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
assert(len(dec_tx['vin']) > 0) #test if we have enough inputs
##############################
# simple test with two coins #
##############################
inputs = [ ]
outputs = { self.nodes[0].getnewaddress() : 26 }
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
fee = rawtxfund['fee']
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
assert(len(dec_tx['vin']) > 0)
assert_equal(dec_tx['vin'][0]['scriptSig']['hex'], '')
################################
# simple test with two outputs #
################################
inputs = [ ]
outputs = { self.nodes[0].getnewaddress() : 26, self.nodes[1].getnewaddress() : 25 }
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
fee = rawtxfund['fee']
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
totalOut = 0
for out in dec_tx['vout']:
totalOut += out['value']
assert(len(dec_tx['vin']) > 0)
assert_equal(dec_tx['vin'][0]['scriptSig']['hex'], '')
#########################################################################
# test a fundrawtransaction with a VIN greater than the required amount #
#########################################################################
utx = False
listunspent = self.nodes[2].listunspent()
for aUtx in listunspent:
if aUtx['amount'] == 50:
utx = aUtx
break
assert(utx!=False)
inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
outputs = { self.nodes[0].getnewaddress() : 10 }
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
fee = rawtxfund['fee']
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
totalOut = 0
for out in dec_tx['vout']:
totalOut += out['value']
assert_equal(fee + totalOut, utx['amount']) #compare vin total and totalout+fee
#####################################################################
# test a fundrawtransaction with which will not get a change output #
#####################################################################
utx = False
listunspent = self.nodes[2].listunspent()
for aUtx in listunspent:
if aUtx['amount'] == 50:
utx = aUtx
break
assert(utx!=False)
inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
outputs = { self.nodes[0].getnewaddress() : Decimal(50) - fee - feeTolerance }
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
fee = rawtxfund['fee']
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
totalOut = 0
for out in dec_tx['vout']:
totalOut += out['value']
assert_equal(rawtxfund['changepos'], -1)
assert_equal(fee + totalOut, utx['amount']) #compare vin total and totalout+fee
#########################################################################
# test a fundrawtransaction with a VIN smaller than the required amount #
#########################################################################
utx = False
listunspent = self.nodes[2].listunspent()
for aUtx in listunspent:
if aUtx['amount'] == 10:
utx = aUtx
break
assert(utx!=False)
inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
outputs = { self.nodes[0].getnewaddress() : 10 }
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
# 4-byte version + 1-byte vin count + 36-byte prevout then script_len
rawtx = rawtx[:82] + "0100" + rawtx[84:]
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
assert_equal("00", dec_tx['vin'][0]['scriptSig']['hex'])
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
fee = rawtxfund['fee']
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
totalOut = 0
matchingOuts = 0
for i, out in enumerate(dec_tx['vout']):
totalOut += out['value']
if out['scriptPubKey']['addresses'][0] in outputs:
matchingOuts+=1
else:
assert_equal(i, rawtxfund['changepos'])
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
assert_equal("00", dec_tx['vin'][0]['scriptSig']['hex'])
assert_equal(matchingOuts, 1)
assert_equal(len(dec_tx['vout']), 2)
###########################################
# test a fundrawtransaction with two VINs #
###########################################
utx = False
utx2 = False
listunspent = self.nodes[2].listunspent()
for aUtx in listunspent:
if aUtx['amount'] == 10:
utx = aUtx
if aUtx['amount'] == 50:
utx2 = aUtx
assert(utx!=False)
inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']},{'txid' : utx2['txid'], 'vout' : utx2['vout']} ]
outputs = { self.nodes[0].getnewaddress() : 60 }
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
fee = rawtxfund['fee']
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
totalOut = 0
matchingOuts = 0
for out in dec_tx['vout']:
totalOut += out['value']
if out['scriptPubKey']['addresses'][0] in outputs:
matchingOuts+=1
assert_equal(matchingOuts, 1)
assert_equal(len(dec_tx['vout']), 2)
matchingIns = 0
for vinOut in dec_tx['vin']:
for vinIn in inputs:
if vinIn['txid'] == vinOut['txid']:
matchingIns+=1
assert_equal(matchingIns, 2) #we now must see two vins identical to vins given as params
#########################################################
# test a fundrawtransaction with two VINs and two vOUTs #
#########################################################
utx = False
utx2 = False
listunspent = self.nodes[2].listunspent()
for aUtx in listunspent:
if aUtx['amount'] == 10:
utx = aUtx
if aUtx['amount'] == 50:
utx2 = aUtx
assert(utx!=False)
inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']},{'txid' : utx2['txid'], 'vout' : utx2['vout']} ]
outputs = { self.nodes[0].getnewaddress() : 60, self.nodes[0].getnewaddress() : 10 }
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
fee = rawtxfund['fee']
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
totalOut = 0
matchingOuts = 0
for out in dec_tx['vout']:
totalOut += out['value']
if out['scriptPubKey']['addresses'][0] in outputs:
matchingOuts+=1
assert_equal(matchingOuts, 2)
assert_equal(len(dec_tx['vout']), 3)
##############################################
# test a fundrawtransaction with invalid vin #
##############################################
listunspent = self.nodes[2].listunspent()
inputs = [ {'txid' : "1c7f966dab21119bac53213a2bc7532bff1fa844c124fd750a7d0b1332440bd1", 'vout' : 0} ] #invalid vin!
outputs = { self.nodes[0].getnewaddress() : 10}
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
try:
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
raise AssertionError("Spent more than available")
except JSONRPCException as e:
assert("Insufficient" in e.error['message'])
############################################################
#compare fee of a standard pubkeyhash transaction
inputs = []
outputs = {self.nodes[1].getnewaddress():11}
rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
fundedTx = self.nodes[0].fundrawtransaction(rawTx)
#create same transaction over sendtoaddress
txId = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 11)
signedFee = self.nodes[0].getrawmempool(True)[txId]['fee']
#compare fee
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
assert(feeDelta >= 0 and feeDelta <= feeTolerance)
############################################################
############################################################
#compare fee of a standard pubkeyhash transaction with multiple outputs
inputs = []
outputs = {self.nodes[1].getnewaddress():11,self.nodes[1].getnewaddress():12,self.nodes[1].getnewaddress():1,self.nodes[1].getnewaddress():13,self.nodes[1].getnewaddress():2,self.nodes[1].getnewaddress():3}
rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
fundedTx = self.nodes[0].fundrawtransaction(rawTx)
#create same transaction over sendtoaddress
txId = self.nodes[0].sendmany("", outputs)
signedFee = self.nodes[0].getrawmempool(True)[txId]['fee']
#compare fee
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
assert(feeDelta >= 0 and feeDelta <= feeTolerance)
############################################################
############################################################
#compare fee of a 2of2 multisig p2sh transaction
# create 2of2 addr
addr1 = self.nodes[1].getnewaddress()
addr2 = self.nodes[1].getnewaddress()
addr1Obj = self.nodes[1].validateaddress(addr1)
addr2Obj = self.nodes[1].validateaddress(addr2)
mSigObj = self.nodes[1].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey']])
inputs = []
outputs = {mSigObj:11}
rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
fundedTx = self.nodes[0].fundrawtransaction(rawTx)
#create same transaction over sendtoaddress
txId = self.nodes[0].sendtoaddress(mSigObj, 11)
signedFee = self.nodes[0].getrawmempool(True)[txId]['fee']
#compare fee
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
assert(feeDelta >= 0 and feeDelta <= feeTolerance)
############################################################
############################################################
#compare fee of a standard pubkeyhash transaction
# create 4of5 addr
addr1 = self.nodes[1].getnewaddress()
addr2 = self.nodes[1].getnewaddress()
addr3 = self.nodes[1].getnewaddress()
addr4 = self.nodes[1].getnewaddress()
addr5 = self.nodes[1].getnewaddress()
addr1Obj = self.nodes[1].validateaddress(addr1)
addr2Obj = self.nodes[1].validateaddress(addr2)
addr3Obj = self.nodes[1].validateaddress(addr3)
addr4Obj = self.nodes[1].validateaddress(addr4)
addr5Obj = self.nodes[1].validateaddress(addr5)
mSigObj = self.nodes[1].addmultisigaddress(4, [addr1Obj['pubkey'], addr2Obj['pubkey'], addr3Obj['pubkey'], addr4Obj['pubkey'], addr5Obj['pubkey']])
inputs = []
outputs = {mSigObj:11}
rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
fundedTx = self.nodes[0].fundrawtransaction(rawTx)
#create same transaction over sendtoaddress
txId = self.nodes[0].sendtoaddress(mSigObj, 11)
signedFee = self.nodes[0].getrawmempool(True)[txId]['fee']
#compare fee
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
assert(feeDelta >= 0 and feeDelta <= feeTolerance)
############################################################
############################################################
# spend a 2of2 multisig transaction over fundraw
# create 2of2 addr
addr1 = self.nodes[2].getnewaddress()
addr2 = self.nodes[2].getnewaddress()
addr1Obj = self.nodes[2].validateaddress(addr1)
addr2Obj = self.nodes[2].validateaddress(addr2)
mSigObj = self.nodes[2].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey']])
# send 12 ESMA to msig addr
txId = self.nodes[0].sendtoaddress(mSigObj, 12)
self.sync_all()
self.nodes[1].generate(1)
self.sync_all()
oldBalance = self.nodes[1].getbalance()
inputs = []
outputs = {self.nodes[1].getnewaddress():11}
rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
fundedTx = self.nodes[2].fundrawtransaction(rawTx)
signedTx = self.nodes[2].signrawtransaction(fundedTx['hex'])
txId = self.nodes[2].sendrawtransaction(signedTx['hex'])
self.sync_all()
self.nodes[1].generate(1)
self.sync_all()
# make sure funds are received at node1
assert_equal(oldBalance+Decimal('11.0000000'), self.nodes[1].getbalance())
############################################################
# locked wallet test
self.nodes[1].encryptwallet("test")
self.nodes.pop(1)
stop_nodes(self.nodes)
wait_bitcoinds()
self.nodes = start_nodes(4, self.options.tmpdir)
# This test is not meant to test fee estimation and we'd like
# to be sure all txs are sent at a consistent desired feerate
for node in self.nodes:
node.settxfee(min_relay_tx_fee)
connect_nodes_bi(self.nodes,0,1)
connect_nodes_bi(self.nodes,1,2)
connect_nodes_bi(self.nodes,0,2)
connect_nodes_bi(self.nodes,0,3)
self.is_network_split=False
self.sync_all()
try:
self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 12)
raise AssertionError("Wallet unlocked without passphrase")
except JSONRPCException as e:
assert('walletpassphrase' in e.error['message'])
oldBalance = self.nodes[0].getbalance()
inputs = []
outputs = {self.nodes[0].getnewaddress():11}
rawTx = self.nodes[1].createrawtransaction(inputs, outputs)
fundedTx = self.nodes[1].fundrawtransaction(rawTx)
#now we need to unlock
self.nodes[1].walletpassphrase("test", 100)
signedTx = self.nodes[1].signrawtransaction(fundedTx['hex'])
txId = self.nodes[1].sendrawtransaction(signedTx['hex'])
self.sync_all()
self.nodes[1].generate(1)
self.sync_all()
# make sure funds are received at node1
assert_equal(oldBalance+Decimal('511.0000000'), self.nodes[0].getbalance())
###############################################
# multiple (~19) inputs tx test | Compare fee #
###############################################
#empty node1, send some small coins from node0 to node1
self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), self.nodes[1].getbalance(), "", "", True)
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
for i in range(0,20):
self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.01)
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
#fund a tx with ~20 small inputs
inputs = []
outputs = {self.nodes[0].getnewaddress():0.15,self.nodes[0].getnewaddress():0.04}
rawTx = self.nodes[1].createrawtransaction(inputs, outputs)
fundedTx = self.nodes[1].fundrawtransaction(rawTx)
#create same transaction over sendtoaddress
txId = self.nodes[1].sendmany("", outputs)
signedFee = self.nodes[1].getrawmempool(True)[txId]['fee']
#compare fee
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
assert(feeDelta >= 0 and feeDelta <= feeTolerance*19) #~19 inputs
#############################################
# multiple (~19) inputs tx test | sign/send #
#############################################
#again, empty node1, send some small coins from node0 to node1
self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), self.nodes[1].getbalance(), "", "", True)
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
for i in range(0,20):
self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.01)
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
#fund a tx with ~20 small inputs
oldBalance = self.nodes[0].getbalance()
inputs = []
outputs = {self.nodes[0].getnewaddress():0.15,self.nodes[0].getnewaddress():0.04}
rawTx = self.nodes[1].createrawtransaction(inputs, outputs)
fundedTx = self.nodes[1].fundrawtransaction(rawTx)
fundedAndSignedTx = self.nodes[1].signrawtransaction(fundedTx['hex'])
txId = self.nodes[1].sendrawtransaction(fundedAndSignedTx['hex'])
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
assert_equal(oldBalance+Decimal('500.19000000'), self.nodes[0].getbalance()) #0.19+block reward
#####################################################
# test fundrawtransaction with OP_RETURN and no vin #
#####################################################
rawtx = "0100000000010000000000000000066a047465737400000000"
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
assert_equal(len(dec_tx['vin']), 0)
assert_equal(len(dec_tx['vout']), 1)
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
assert_greater_than(len(dec_tx['vin']), 0) # at least one vin
assert_equal(len(dec_tx['vout']), 2) # one change output added
##################################################
# test a fundrawtransaction using only watchonly #
##################################################
inputs = []
outputs = {self.nodes[2].getnewaddress() : watchonly_amount / 2}
rawtx = self.nodes[3].createrawtransaction(inputs, outputs)
result = self.nodes[3].fundrawtransaction(rawtx, True)
res_dec = self.nodes[0].decoderawtransaction(result["hex"])
assert_equal(len(res_dec["vin"]), 1)
assert_equal(res_dec["vin"][0]["txid"], watchonly_txid)
assert("fee" in result.keys())
assert_greater_than(result["changepos"], -1)
###############################################################
# test fundrawtransaction using the entirety of watched funds #
###############################################################
inputs = []
outputs = {self.nodes[2].getnewaddress() : watchonly_amount}
rawtx = self.nodes[3].createrawtransaction(inputs, outputs)
result = self.nodes[3].fundrawtransaction(rawtx, True)
res_dec = self.nodes[0].decoderawtransaction(result["hex"])
assert_equal(len(res_dec["vin"]), 2)
assert(res_dec["vin"][0]["txid"] == watchonly_txid or res_dec["vin"][1]["txid"] == watchonly_txid)
assert_greater_than(result["fee"], 0)
assert_greater_than(result["changepos"], -1)
assert_equal(result["fee"] + res_dec["vout"][result["changepos"]]["value"], watchonly_amount / 10)
signedtx = self.nodes[3].signrawtransaction(result["hex"])
assert(not signedtx["complete"])
signedtx = self.nodes[0].signrawtransaction(signedtx["hex"])
assert(signedtx["complete"])
self.nodes[0].sendrawtransaction(signedtx["hex"])
if __name__ == '__main__':
RawTransactionsTest().main()
| 40.438017 | 214 | 0.556019 | [
"MIT"
] | alik918/esmacoin | qa/rpc-tests/fundrawtransaction.py | 24,465 | Python |
# Copyright (c) 2017, John Skinner
import unittest
import numpy as np
import arvet.database.tests.database_connection as dbconn
from arvet.config.path_manager import PathManager
import arvet.batch_analysis.task as task
class MockTask(task.Task):
def run_task(self, path_manager: PathManager):
pass
def get_unique_name(self) -> str:
return "mock_task_{0}".format(self.pk)
class TestTaskDatabase(unittest.TestCase):
@classmethod
def setUpClass(cls):
dbconn.connect_to_test_db()
def setUp(self):
# Remove the collection as the start of the test, so that we're sure it's empty
task.Task._mongometa.collection.drop()
@classmethod
def tearDownClass(cls):
# Clean up after ourselves by dropping the collection for this model
task.Task._mongometa.collection.drop()
def test_stores_and_loads_simple(self):
obj = MockTask(state=task.JobState.UNSTARTED)
obj.save()
# Load all the entities
all_entities = list(task.Task.objects.all())
self.assertGreaterEqual(len(all_entities), 1)
self.assertEqual(all_entities[0], obj)
all_entities[0].delete()
def test_stores_and_loads_all_params(self):
obj = MockTask(
state=task.JobState.RUNNING,
node_id='test-hpc',
job_id=15,
num_cpus=3,
num_gpus=150,
memory_requirements='4KB',
expected_duration='100:00:00'
)
obj.save()
# Load all the entities
all_entities = list(task.Task.objects.all())
self.assertGreaterEqual(len(all_entities), 1)
self.assertEqual(all_entities[0], obj)
all_entities[0].delete()
def test_stores_and_loads_after_change_state(self):
obj = MockTask(
state=task.JobState.RUNNING,
node_id='test-hpc',
job_id=15,
num_cpus=3,
num_gpus=150,
memory_requirements='4KB',
expected_duration='100:00:00'
)
obj.save()
all_entities = list(task.Task.objects.all())
self.assertGreaterEqual(len(all_entities), 1)
self.assertEqual(all_entities[0], obj)
obj.mark_job_failed()
obj.save()
all_entities = list(task.Task.objects.all())
self.assertGreaterEqual(len(all_entities), 1)
self.assertEqual(all_entities[0], obj)
obj.mark_job_started('test_node', 143)
obj.save()
all_entities = list(task.Task.objects.all())
self.assertGreaterEqual(len(all_entities), 1)
self.assertEqual(all_entities[0], obj)
obj.mark_job_complete()
obj.save()
all_entities = list(task.Task.objects.all())
self.assertGreaterEqual(len(all_entities), 1)
self.assertEqual(all_entities[0], obj)
class TestTask(unittest.TestCase):
def test_mark_job_started_changes_unstarted_to_running(self):
subject = MockTask(state=task.JobState.UNSTARTED)
self.assertTrue(subject.is_unstarted)
self.assertFalse(subject.is_running)
subject.mark_job_started('test', 12)
self.assertFalse(subject.is_unstarted)
self.assertTrue(subject.is_running)
def test_mark_job_started_doesnt_affect_already_running_jobs(self):
subject = MockTask(state=task.JobState.RUNNING, node_id='external', job_id=3)
self.assertFalse(subject.is_unstarted)
self.assertTrue(subject.is_running)
self.assertFalse(subject.is_finished)
subject.mark_job_started('test', 12)
self.assertFalse(subject.is_unstarted)
self.assertTrue(subject.is_running)
self.assertFalse(subject.is_finished)
self.assertEqual('external', subject.node_id)
self.assertEqual(3, subject.job_id)
def test_mark_job_started_doesnt_affect_finished_jobs(self):
subject = MockTask(state=task.JobState.DONE)
self.assertFalse(subject.is_unstarted)
self.assertFalse(subject.is_running)
self.assertTrue(subject.is_finished)
subject.mark_job_started('test', 12)
self.assertFalse(subject.is_unstarted)
self.assertFalse(subject.is_running)
self.assertTrue(subject.is_finished)
self.assertIsNone(subject.node_id)
self.assertIsNone(subject.job_id)
def test_mark_job_failed_changes_running_to_unstarted(self):
subject = MockTask(state=task.JobState.RUNNING, node_id='test', job_id=5)
self.assertFalse(subject.is_unstarted)
self.assertTrue(subject.is_running)
subject.mark_job_failed()
self.assertTrue(subject.is_unstarted)
self.assertFalse(subject.is_running)
self.assertIsNone(subject.node_id)
self.assertIsNone(subject.job_id)
def test_mark_job_failed_increases_failed_count(self):
subject = MockTask(state=task.JobState.RUNNING, node_id='test', job_id=5, failure_count=4)
self.assertFalse(subject.is_unstarted)
self.assertTrue(subject.is_running)
subject.mark_job_failed()
self.assertTrue(subject.is_unstarted)
self.assertFalse(subject.is_running)
self.assertEqual(5, subject.failure_count)
def test_mark_job_failed_doesnt_affect_unstarted_jobs(self):
subject = MockTask(state=task.JobState.UNSTARTED)
self.assertTrue(subject.is_unstarted)
self.assertFalse(subject.is_finished)
subject.mark_job_failed()
self.assertTrue(subject.is_unstarted)
self.assertFalse(subject.is_finished)
self.assertEqual(0, subject.failure_count)
def test_mark_job_failed_doesnt_affect_finished_jobs(self):
subject = MockTask(state=task.JobState.DONE)
self.assertFalse(subject.is_unstarted)
self.assertFalse(subject.is_running)
self.assertTrue(subject.is_finished)
subject.mark_job_failed()
self.assertFalse(subject.is_unstarted)
self.assertFalse(subject.is_running)
self.assertTrue(subject.is_finished)
self.assertIsNone(subject.node_id)
self.assertIsNone(subject.job_id)
def test_mark_job_complete_changes_running_to_finished(self):
subject = MockTask(state=task.JobState.RUNNING, node_id='test', job_id=5)
self.assertFalse(subject.is_unstarted)
self.assertTrue(subject.is_running)
subject.mark_job_complete()
self.assertFalse(subject.is_running)
self.assertTrue(subject.is_finished)
self.assertIsNone(subject.node_id)
self.assertIsNone(subject.job_id)
def test_mark_job_complete_doesnt_affect_unstarted_jobs(self):
subject = MockTask(state=task.JobState.UNSTARTED)
self.assertTrue(subject.is_unstarted)
self.assertFalse(subject.is_running)
self.assertFalse(subject.is_finished)
subject.mark_job_complete()
self.assertTrue(subject.is_unstarted)
self.assertFalse(subject.is_running)
self.assertFalse(subject.is_finished)
def test_mark_job_complete_doesnt_affect_finished_jobs(self):
subject = MockTask(state=task.JobState.DONE)
self.assertFalse(subject.is_unstarted)
self.assertFalse(subject.is_running)
self.assertTrue(subject.is_finished)
subject.mark_job_complete()
self.assertFalse(subject.is_unstarted)
self.assertFalse(subject.is_running)
self.assertTrue(subject.is_finished)
self.assertIsNone(subject.node_id)
self.assertIsNone(subject.job_id)
def test_change_job_id_doesnt_affect_state(self):
subject = MockTask(state=task.JobState.RUNNING)
self.assertFalse(subject.is_unstarted)
self.assertTrue(subject.is_running)
self.assertFalse(subject.is_finished)
subject.change_job_id('test', 12)
self.assertFalse(subject.is_unstarted)
self.assertTrue(subject.is_running)
self.assertFalse(subject.is_finished)
def test_change_job_id_changes_job_info(self):
subject = MockTask(state=task.JobState.RUNNING, node_id='external', job_id=3)
self.assertEqual('external', subject.node_id)
self.assertEqual(3, subject.job_id)
subject.change_job_id('test', 12)
self.assertEqual('test', subject.node_id)
self.assertEqual(12, subject.job_id)
def test_change_job_id_doesnt_affect_unstarted_jobs(self):
subject = MockTask(state=task.JobState.UNSTARTED)
self.assertTrue(subject.is_unstarted)
subject.change_job_id('test', 12)
self.assertTrue(subject.is_unstarted)
self.assertIsNone(subject.node_id)
self.assertIsNone(subject.job_id)
def test_change_job_id_doesnt_affect_finished_jobs(self):
subject = MockTask(state=task.JobState.DONE, node_id='external', job_id=3)
self.assertTrue(subject.is_finished)
self.assertEqual('external', subject.node_id)
self.assertEqual(3, subject.job_id)
subject.change_job_id('test', 12)
self.assertTrue(subject.is_finished)
self.assertEqual('external', subject.node_id)
self.assertEqual(3, subject.job_id)
def test_state_remains_consistent(self):
random = np.random.RandomState(144135)
subject = MockTask(state=task.JobState.UNSTARTED)
for idx in range(50):
change = random.randint(0, 4 if idx > 30 else 3)
if idx > 30 and change == 3:
subject.mark_job_complete()
elif change == 2:
subject.change_job_id('external', random.randint(0, 1000))
elif change == 1:
subject.mark_job_started('test', random.randint(0, 1000))
else:
subject.mark_job_failed()
# Make sure that the node id and job id match the state
if subject.is_unstarted or subject.is_finished:
self.assertIsNone(subject.node_id)
self.assertIsNone(subject.job_id)
else:
self.assertIsNotNone(subject.node_id)
self.assertIsNotNone(subject.job_id)
| 38.830769 | 98 | 0.682448 | [
"BSD-2-Clause"
] | jskinn/arvet | arvet/batch_analysis/tests/test_task.py | 10,096 | Python |
from datetime import datetime
import uuid
from django.db import models
import django.forms as forms
import django_filters.fields as filter_fields
from apps.ineedstudent.models import Hospital
from .filters import StudentJobRequirementsFilter
from .models import * # noqa: F401, F403
from .models import COUNTRY_CODE_CHOICES
class LocationFilterModel(models.Model):
plz = models.CharField(max_length=5, null=True)
distance = models.IntegerField(default=0)
countrycode = models.CharField(max_length=2, choices=COUNTRY_CODE_CHOICES, default="DE",)
uuid = models.CharField(max_length=100, blank=True, unique=True, default=uuid.uuid4)
class StudentListFilterModel(models.Model):
hospital = models.ForeignKey(Hospital, on_delete=models.CASCADE)
location = LocationFilterModel
uuid = models.CharField(max_length=100, blank=True, unique=True, default=uuid.uuid4)
registration_date = models.DateTimeField(default=datetime.now, blank=True, null=True)
name = models.CharField(max_length=100)
jrf = StudentJobRequirementsFilter()
for f_name, jr_filter in jrf.base_filters.items():
if type(jr_filter.field) == forms.NullBooleanField:
StudentListFilterModel.add_to_class(
f_name, models.NullBooleanField(default=None, null=True)
)
elif type(jr_filter.field) == forms.DecimalField:
StudentListFilterModel.add_to_class(f_name, models.IntegerField(default=0))
elif type(jr_filter.field) == filter_fields.ChoiceField:
StudentListFilterModel.add_to_class(
f_name, models.IntegerField(default=0, choices=jr_filter.field.choices)
)
elif type(jr_filter.field) == forms.DateField:
StudentListFilterModel.add_to_class(
f_name, models.DateField(null=True, default=datetime.now)
)
else:
raise ValueError(
"I do not know what to do with field type '%s' for '%s'"
% (type(jr_filter.field), f_name)
)
| 34.666667 | 93 | 0.730263 | [
"MIT"
] | match4healthcare/match4healthcare | backend/apps/iamstudent/models_persistent_filter.py | 1,976 | Python |
# coding: utf-8
"""
vautoscaling
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
import pprint
import re # noqa: F401
import six
from ncloud_vautoscaling.model.process import Process # noqa: F401,E501
class ResumeProcessesResponse(object):
"""NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
"""
"""
Attributes:
swagger_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
swagger_types = {
'request_id': 'str',
'return_code': 'str',
'return_message': 'str',
'total_rows': 'int',
'process_list': 'list[Process]'
}
attribute_map = {
'request_id': 'requestId',
'return_code': 'returnCode',
'return_message': 'returnMessage',
'total_rows': 'totalRows',
'process_list': 'processList'
}
def __init__(self, request_id=None, return_code=None, return_message=None, total_rows=None, process_list=None): # noqa: E501
"""ResumeProcessesResponse - a model defined in Swagger""" # noqa: E501
self._request_id = None
self._return_code = None
self._return_message = None
self._total_rows = None
self._process_list = None
self.discriminator = None
if request_id is not None:
self.request_id = request_id
if return_code is not None:
self.return_code = return_code
if return_message is not None:
self.return_message = return_message
if total_rows is not None:
self.total_rows = total_rows
if process_list is not None:
self.process_list = process_list
@property
def request_id(self):
"""Gets the request_id of this ResumeProcessesResponse. # noqa: E501
:return: The request_id of this ResumeProcessesResponse. # noqa: E501
:rtype: str
"""
return self._request_id
@request_id.setter
def request_id(self, request_id):
"""Sets the request_id of this ResumeProcessesResponse.
:param request_id: The request_id of this ResumeProcessesResponse. # noqa: E501
:type: str
"""
self._request_id = request_id
@property
def return_code(self):
"""Gets the return_code of this ResumeProcessesResponse. # noqa: E501
:return: The return_code of this ResumeProcessesResponse. # noqa: E501
:rtype: str
"""
return self._return_code
@return_code.setter
def return_code(self, return_code):
"""Sets the return_code of this ResumeProcessesResponse.
:param return_code: The return_code of this ResumeProcessesResponse. # noqa: E501
:type: str
"""
self._return_code = return_code
@property
def return_message(self):
"""Gets the return_message of this ResumeProcessesResponse. # noqa: E501
:return: The return_message of this ResumeProcessesResponse. # noqa: E501
:rtype: str
"""
return self._return_message
@return_message.setter
def return_message(self, return_message):
"""Sets the return_message of this ResumeProcessesResponse.
:param return_message: The return_message of this ResumeProcessesResponse. # noqa: E501
:type: str
"""
self._return_message = return_message
@property
def total_rows(self):
"""Gets the total_rows of this ResumeProcessesResponse. # noqa: E501
:return: The total_rows of this ResumeProcessesResponse. # noqa: E501
:rtype: int
"""
return self._total_rows
@total_rows.setter
def total_rows(self, total_rows):
"""Sets the total_rows of this ResumeProcessesResponse.
:param total_rows: The total_rows of this ResumeProcessesResponse. # noqa: E501
:type: int
"""
self._total_rows = total_rows
@property
def process_list(self):
"""Gets the process_list of this ResumeProcessesResponse. # noqa: E501
:return: The process_list of this ResumeProcessesResponse. # noqa: E501
:rtype: list[Process]
"""
return self._process_list
@process_list.setter
def process_list(self, process_list):
"""Sets the process_list of this ResumeProcessesResponse.
:param process_list: The process_list of this ResumeProcessesResponse. # noqa: E501
:type: list[Process]
"""
self._process_list = process_list
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
return result
def to_str(self):
"""Returns the string representation of the model"""
return pprint.pformat(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, ResumeProcessesResponse):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""Returns true if both objects are not equal"""
return not self == other
| 28.453704 | 129 | 0.607062 | [
"MIT"
] | NaverCloudPlatform/ncloud-sdk-python | lib/services/vautoscaling/ncloud_vautoscaling/model/resume_processes_response.py | 6,146 | Python |
#!/usr/bin/env python3
# Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
from . import css_checker
from os import path as os_path
import re
from sys import path as sys_path
import unittest
_HERE = os_path.dirname(os_path.abspath(__file__))
sys_path.append(os_path.join(_HERE, '..', '..'))
from PRESUBMIT_test_mocks import MockInputApi, MockOutputApi, MockFile
class CssCheckerTest(unittest.TestCase):
def setUp(self):
super(CssCheckerTest, self).setUp()
self.input_api = MockInputApi()
self.checker = css_checker.CSSChecker(self.input_api, MockOutputApi())
def _create_file(self, contents, filename):
self.input_api.files.append(MockFile(filename, contents.splitlines()))
def VerifyContentIsValid(self, contents, filename='fake.css'):
self._create_file(contents, filename)
results = self.checker.RunChecks()
self.assertEqual(len(results), 0)
def VerifyContentsProducesOutput(self, contents, output, filename='fake.css'):
self._create_file(contents, filename)
results = self.checker.RunChecks()
self.assertEqual(len(results), 1)
self.assertEqual(results[0].message, filename + ':\n' + output.strip())
def testCssAlphaWithAtBlock(self):
self.VerifyContentsProducesOutput("""
<include src="../shared/css/cr/ui/overlay.css">
<include src="chrome://resources/totally-cool.css" />
/* A hopefully safely ignored comment and @media statement. /**/
@media print {
div {
display: block;
color: red;
}
}
.rule {
z-index: 5;
<if expr="not is macosx">
background-image: url(chrome://resources/BLAH); /* TODO(dbeam): Fix this. */
background-color: rgb(235, 239, 249);
</if>
<if expr="is_macosx">
background-color: white;
background-image: url(chrome://resources/BLAH2);
</if>
color: black;
}
<if expr="is_macosx">
.language-options-right {
visibility: hidden;
opacity: 1; /* TODO(dbeam): Fix this. */
}
</if>
@media (prefers-color-scheme: dark) {
a[href] {
z-index: 3;
color: blue;
}
}""", """
- Alphabetize properties and list vendor specific (i.e. -webkit) above standard.
display: block;
color: red;
z-index: 5;
color: black;
z-index: 3;
color: blue;""")
def testCssStringWithAt(self):
self.VerifyContentIsValid("""
#logo {
background-image: url(images/google_logo.png@2x);
}
body.alternate-logo #logo {
-webkit-mask-image: url(images/google_logo.png@2x);
background: none;
}
div {
margin-inline-start: 5px;
}
.stuff1 {
}
.stuff2 {
}
""")
def testCssAlphaWithNonStandard(self):
self.VerifyContentsProducesOutput("""
div {
/* A hopefully safely ignored comment and @media statement. /**/
color: red;
-webkit-margin-before-collapse: discard;
}""", """
- Alphabetize properties and list vendor specific (i.e. -webkit) above standard.
color: red;
-webkit-margin-before-collapse: discard;""")
def testCssAlphaWithLongerDashedProps(self):
self.VerifyContentsProducesOutput("""
div {
border-inline-start: 5px; /* A hopefully removed comment. */
border: 5px solid red;
}""", """
- Alphabetize properties and list vendor specific (i.e. -webkit) above standard.
border-inline-start: 5px;
border: 5px solid red;""")
def testCssAlphaWithVariables(self):
self.VerifyContentIsValid("""
#id {
--zzyxx-xylophone: 3px;
--aardvark-animal: var(--zzyxz-xylophone);
}
""")
def testCssBracesHaveSpaceBeforeAndNothingAfter(self):
self.VerifyContentsProducesOutput("""
/* Hello! */div/* Comment here*/{
display: block;
}
blah /* hey! */
{
rule: value;
}
.mixed-in {
display: none;
}
.this.is { /* allowed */
rule: value;
}""", """
- Start braces ({) end a selector, have a space before them and no rules after.
div{
{""")
def testMixins(self):
self.VerifyContentsProducesOutput(
"""
.mixed-in {
--css-mixin: {
color: red;
}
}""", """
- Avoid using CSS mixins. Use CSS shadow parts, CSS variables, or common CSS \
classes instead.
--css-mixin: {""")
def testCssClassesUseDashes(self):
self.VerifyContentsProducesOutput("""
.className,
.ClassName,
.class-name /* We should not catch this. */,
.class_name,
[i18n-values*='.innerHTML:'] {
display: block;
}""", """
- Classes use .dash-form.
.className,
.ClassName,
.class_name,""")
def testCssCloseBraceOnNewLine(self):
self.VerifyContentsProducesOutput("""
@-webkit-keyframe blah {
from { height: rotate(-10turn); }
100% { height: 500px; }
}
#id { /* $i18n{*} and $i18nRaw{*} should be ignored. */
rule: $i18n{someValue};
rule2: $i18nRaw{someValue};
}
#rule {
rule: value; }""", """
- Always put a rule closing brace (}) on a new line.
rule: value; }""")
def testCssColonsHaveSpaceAfter(self):
self.VerifyContentsProducesOutput("""
div:not(.class):not([attr=5]), /* We should not catch this. */
div:not(.class):not([attr]) /* Nor this. */ {
background: url(data:image/jpeg,asdfasdfsadf); /* Ignore this. */
background: -webkit-linear-gradient(left, red,
80% blah blee blar);
color: red;
display:block;
}""", """
- Colons (:) should have a space after them.
display:block;
- Don't use data URIs in source files. Use grit instead.
background: url(data:image/jpeg,asdfasdfsadf);""")
def testCssFavorSingleQuotes(self):
self.VerifyContentsProducesOutput("""
html[dir="rtl"] body,
html[dir=ltr] body /* TODO(dbeam): Require '' around rtl in future? */ {
font-family: "Open Sans";
<if expr="is_macosx">
blah: blee;
</if>
}""", """
- Use single quotes (') instead of double quotes (") in strings.
html[dir="rtl"] body,
font-family: "Open Sans";""")
def testCssHexCouldBeShorter(self):
self.VerifyContentsProducesOutput("""
#abc,
#abc-,
#abc-ghij,
#abcdef-,
#abcdef-ghij,
#aaaaaa,
#bbaacc {
background-color: #336699; /* Ignore short hex rule if not gray. */
color: #999999;
color: #666;
}""", """
- Use abbreviated hex (#rgb) when in form #rrggbb.
color: #999999; (replace with #999)
- Use rgb() over #hex when not a shade of gray (like #333).
background-color: #336699; (replace with rgb(51, 102, 153))""")
def testCssUseMillisecondsForSmallTimes(self):
self.VerifyContentsProducesOutput("""
.transition-0s /* This is gross but may happen. */ {
transform: one 0.2s;
transform: two .1s;
transform: tree 1s;
transform: four 300ms;
}""", """
- Use milliseconds for time measurements under 1 second.
transform: one 0.2s; (replace with 200ms)
transform: two .1s; (replace with 100ms)""")
def testCssNoDataUrisInSourceFiles(self):
self.VerifyContentsProducesOutput("""
img {
background: url( data:image/jpeg,4\/\/350|\/|3|2 );
}""", """
- Don't use data URIs in source files. Use grit instead.
background: url( data:image/jpeg,4\/\/350|\/|3|2 );""")
def testCssNoMixinShims(self):
self.VerifyContentsProducesOutput("""
:host {
--good-property: red;
--not-okay-mixin_-_not-okay-property: green;
}""", """
- Don't override custom properties created by Polymer's mixin shim. Set \
mixins or documented custom properties directly.
--not-okay-mixin_-_not-okay-property: green;""")
def testCssNoQuotesInUrl(self):
self.VerifyContentsProducesOutput("""
img {
background: url('chrome://resources/images/blah.jpg');
background: url("../../folder/hello.png");
}""", """
- Use single quotes (') instead of double quotes (") in strings.
background: url("../../folder/hello.png");
- Don't use quotes in url().
background: url('chrome://resources/images/blah.jpg');
background: url("../../folder/hello.png");""")
def testCssOneRulePerLine(self):
self.VerifyContentsProducesOutput("""
a:not([hidden]):not(.custom-appearance):not([version=1]):first-of-type,
a:not([hidden]):not(.custom-appearance):not([version=1]):first-of-type ~
input[type='checkbox']:not([hidden]),
div {
background: url(chrome://resources/BLAH);
rule: value; /* rule: value; */
rule: value; rule: value;
}
""", """
- One rule per line (what not to do: color: red; margin: 0;).
rule: value; rule: value;""")
def testCssOneSelectorPerLine(self):
self.VerifyContentsProducesOutput(
"""
a,
div,a,
div,/* Hello! */ span,
#id.class([dir=rtl]):not(.class):any(a, b, d),
div :is(:not(a), #b, .c) {
rule: value;
}
a,
div,a {
some-other: rule here;
}""", """
- One selector per line (what not to do: a, b {}).
div,a,
div, span,
div,a {""")
def testCssPseudoElementDoubleColon(self):
self.VerifyContentsProducesOutput("""
a:href,
br::after,
::-webkit-scrollbar-thumb,
a:not([empty]):hover:focus:active, /* shouldn't catch here and above */
abbr:after,
.tree-label:empty:after,
b:before,
:-WebKit-ScrollBar {
rule: value;
}""", """
- Pseudo-elements should use double colon (i.e. ::after).
:after (should be ::after)
:after (should be ::after)
:before (should be ::before)
:-WebKit-ScrollBar (should be ::-WebKit-ScrollBar)
""")
def testCssRgbIfNotGray(self):
self.VerifyContentsProducesOutput(
"""
#abc,
#aaa,
#aabbcc {
background: -webkit-linear-gradient(left, from(#abc), to(#def));
color: #bad;
color: #bada55;
}""", """
- Use rgb() over #hex when not a shade of gray (like #333).
background: -webkit-linear-gradient(left, from(#abc), to(#def)); """
"""(replace with rgb(170, 187, 204), rgb(221, 238, 255))
color: #bad; (replace with rgb(187, 170, 221))
color: #bada55; (replace with rgb(186, 218, 85))""")
def testPrefixedLogicalAxis(self):
self.VerifyContentsProducesOutput("""
.test {
-webkit-logical-height: 50%;
-webkit-logical-width: 50%;
-webkit-max-logical-height: 200px;
-webkit-max-logical-width: 200px;
-webkit-min-logical-height: 100px;
-webkit-min-logical-width: 100px;
}
""", """
- Unprefix logical axis property.
-webkit-logical-height: 50%; (replace with block-size)
-webkit-logical-width: 50%; (replace with inline-size)
-webkit-max-logical-height: 200px; (replace with max-block-size)
-webkit-max-logical-width: 200px; (replace with max-inline-size)
-webkit-min-logical-height: 100px; (replace with min-block-size)
-webkit-min-logical-width: 100px; (replace with min-inline-size)""")
def testPrefixedLogicalSide(self):
self.VerifyContentsProducesOutput("""
.test {
-webkit-border-after: 1px solid blue;
-webkit-border-after-color: green;
-webkit-border-after-style: dotted;
-webkit-border-after-width: 10px;
-webkit-border-before: 2px solid blue;
-webkit-border-before-color: green;
-webkit-border-before-style: dotted;
-webkit-border-before-width: 20px;
-webkit-border-end: 3px solid blue;
-webkit-border-end-color: green;
-webkit-border-end-style: dotted;
-webkit-border-end-width: 30px;
-webkit-border-start: 4px solid blue;
-webkit-border-start-color: green;
-webkit-border-start-style: dotted;
-webkit-border-start-width: 40px;
-webkit-margin-after: 1px;
-webkit-margin-after-collapse: discard;
-webkit-margin-before: 2px;
-webkit-margin-before-collapse: discard;
-webkit-margin-end: 3px;
-webkit-margin-end-collapse: discard;
-webkit-margin-start: 4px;
-webkit-margin-start-collapse: discard;
-webkit-padding-after: 1px;
-webkit-padding-before: 2px;
-webkit-padding-end: 3px;
-webkit-padding-start: 4px;
}
""", """
- Unprefix logical side property.
-webkit-border-after: 1px solid blue; (replace with border-block-end)
-webkit-border-after-color: green; (replace with border-block-end-color)
-webkit-border-after-style: dotted; (replace with border-block-end-style)
-webkit-border-after-width: 10px; (replace with border-block-end-width)
-webkit-border-before: 2px solid blue; (replace with border-block-start)
-webkit-border-before-color: green; (replace with border-block-start-color)
-webkit-border-before-style: dotted; (replace with border-block-start-style)
-webkit-border-before-width: 20px; (replace with border-block-start-width)
-webkit-border-end: 3px solid blue; (replace with border-inline-end)
-webkit-border-end-color: green; (replace with border-inline-end-color)
-webkit-border-end-style: dotted; (replace with border-inline-end-style)
-webkit-border-end-width: 30px; (replace with border-inline-end-width)
-webkit-border-start: 4px solid blue; (replace with border-inline-start)
-webkit-border-start-color: green; (replace with border-inline-start-color)
-webkit-border-start-style: dotted; (replace with border-inline-start-style)
-webkit-border-start-width: 40px; (replace with border-inline-start-width)
-webkit-margin-after: 1px; (replace with margin-block-end)
-webkit-margin-before: 2px; (replace with margin-block-start)
-webkit-margin-end: 3px; (replace with margin-inline-end)
-webkit-margin-start: 4px; (replace with margin-inline-start)
-webkit-padding-after: 1px; (replace with padding-block-end)
-webkit-padding-before: 2px; (replace with padding-block-start)
-webkit-padding-end: 3px; (replace with padding-inline-end)
-webkit-padding-start: 4px; (replace with padding-inline-start)""")
def testStartEndInsteadOfLeftRight(self):
self.VerifyContentsProducesOutput("""
.inline-node {
--var-is-ignored-left: 10px;
--var-is-ignored-right: 10px;
border-left-color: black;
border-right: 1px solid blue; /* csschecker-disable-line left-right */
margin-right: 5px;
padding-left: 10px; /* csschecker-disable-line some-other-thing */
text-align: right;
}""", """
- Use -start/end instead of -left/right (https://goo.gl/gQYY7z, add /* csschecker-disable-line left-right */ to suppress)
border-left-color: black; (replace with border-inline-start-color)
margin-right: 5px; (replace with margin-inline-end)
padding-left: 10px; (replace with padding-inline-start)
text-align: right; (replace with text-align: end)
""")
def testCssZeroWidthLengths(self):
self.VerifyContentsProducesOutput("""
@-webkit-keyframe anim {
0% { /* Ignore key frames */
width: 0px;
}
10% {
width: 10px;
}
50% { background-image: url(blah.svg); }
100% {
width: 100px;
}
}
#logo {
background-image: url(images/google_logo.png@2x);
}
body.alternate-logo #logo {
-webkit-mask-image: url(images/google_logo.png@2x);
}
/* http://crbug.com/359682 */
#spinner-container #spinner {
-webkit-animation-duration: 1.0s;
background-image: url(images/google_logo0.svg);
}
.media-button.play > .state0.active,
.media-button[state='0'] > .state0.normal /* blah */, /* blee */
.media-button[state='0']:not(.disabled):hover > .state0.hover {
-webkit-animation: anim 0s;
-webkit-animation-duration: anim 0ms;
-webkit-transform: scale(0%);
background-position-x: 0em;
background-position-y: 0ex;
border-width: 0em;
color: hsl(0, 0%, 85%); /* Shouldn't trigger error. */
opacity: .0;
opacity: 0.0;
opacity: 0.;
}
@page {
border-width: 0mm;
height: 0cm;
width: 0in;
}""", """
- Use "0" for zero-width lengths (i.e. 0px -> 0)
width: 0px;
-webkit-transform: scale(0%);
background-position-x: 0em;
background-position-y: 0ex;
border-width: 0em;
opacity: .0;
opacity: 0.0;
opacity: 0.;
border-width: 0mm;
height: 0cm;
width: 0in;
""")
def testInlineStyleInHtml(self):
self.VerifyContentsProducesOutput("""<!doctype html>
<html>
<head>
<!-- Don't warn about problems outside of style tags
html,
body {
margin: 0;
height: 100%;
}
-->
<style>
body {
flex-direction:column;
}
</style>
</head>
</html>""", """
- Colons (:) should have a space after them.
flex-direction:column;
""", filename='test.html')
def testInlineStyleInHtmlWithIncludes(self):
self.VerifyContentsProducesOutput("""<!doctype html>
<html>
<style include="fake-shared-css other-shared-css">
body {
flex-direction:column;
}
</style>
</head>
</html>""", """
- Colons (:) should have a space after them.
flex-direction:column;
""", filename='test.html')
def testInlineStyleInHtmlWithTagsInComments(self):
self.VerifyContentsProducesOutput("""<!doctype html>
<html>
<style>
body {
/* You better ignore the <tag> in this comment! */
flex-direction:column;
}
</style>
</head>
</html>""", """
- Colons (:) should have a space after them.
flex-direction:column;
""", filename='test.html')
def testRemoveAtBlocks(self):
self.assertEqual(self.checker.RemoveAtBlocks("""
@media (prefers-color-scheme: dark) {
.magic {
color: #000;
}
}"""), """
.magic {
color: #000;
}""")
self.assertEqual(self.checker.RemoveAtBlocks("""
@media (prefers-color-scheme: dark) {
.magic {
--mixin-definition: {
color: red;
};
}
}"""), """
.magic {
--mixin-definition: {
color: red;
};
}""")
self.assertEqual(self.checker.RemoveAtBlocks("""
@keyframes jiggle {
from { left: 0; }
50% { left: 100%; }
to { left: 10%; }
}"""), """
from { left: 0; }
50% { left: 100%; }
to { left: 10%; }""")
self.assertEqual(self.checker.RemoveAtBlocks("""
@media print {
.rule1 {
color: black;
}
.rule2 {
margin: 1in;
}
}"""), """
.rule1 {
color: black;
}
.rule2 {
margin: 1in;
}""")
self.assertEqual(self.checker.RemoveAtBlocks("""
@media (prefers-color-scheme: dark) {
.rule1 {
color: gray;
}
.rule2 {
margin: .5in;
}
@keyframe dark-fade {
0% { background: black; }
100% { background: darkgray; }
}
}"""), """
.rule1 {
color: gray;
}
.rule2 {
margin: .5in;
}
0% { background: black; }
100% { background: darkgray; }""")
self.assertEqual(self.checker.RemoveAtBlocks("""
@-webkit-keyframe anim {
0% { /* Ignore key frames */
width: 0px;
}
10% {
width: 10px;
}
50% { background-image: url(blah.svg); }
100% {
width: 100px;
}
}"""), """
0% { /* Ignore key frames */
width: 0px;
}
10% {
width: 10px;
}
50% { background-image: url(blah.svg); }
100% {
width: 100px;
}""")
if __name__ == '__main__':
unittest.main()
| 27.007418 | 121 | 0.658683 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | Alan-love/chromium | tools/web_dev_style/css_checker_test.py | 18,203 | Python |
from typing import Dict, List, Optional
from db.sql.dal.general import sanitize
from db.sql.utils import query_to_dicts
class Region:
admin: str
admin_id: str
region_type: str
country: str
country_id: str
admin1: Optional[str]
admin1_id: Optional[str]
admin2: Optional[str]
admin2_id: Optional[str]
admin3: Optional[str]
admin3_id: Optional[str]
region_coordinate: Optional[str]
alias: Optional[str]
COUNTRY = 'Q6256'
ADMIN1 = 'Q10864048'
ADMIN2 = 'Q13220204'
ADMIN3 = 'Q13221722'
def __init__(self, **kwargs):
self.admin = kwargs['admin']
self.admin_id = kwargs['admin_id']
self.region_type = kwargs['region_type']
self.country = kwargs['country']
self.country_id = kwargs['country_id']
self.admin1 = kwargs.get('admin1')
self.admin1_id = kwargs.get('admin1_id')
self.admin2 = kwargs.get('admin2')
self.admin2_id = kwargs.get('admin2_id')
self.admin3 = kwargs.get('admin3')
self.admin3_id = kwargs.get('admin3_id')
self.region_coordinate = kwargs.get('region_coordinate')
self.alias = kwargs.get('alias')
# country, admin1 and admin2 queries return both admin and country,admin1,admin2 fields.
# admin3 queries do not, so we need to feel these fields ourselves
if self.region_type == Region.ADMIN3:
self.admin3_id, self.admin_3 = self.admin_id, self.admin
def __getitem__(self, key: str) -> str:
return getattr(self, key)
def query_country_qnodes(countries: List[str]) -> Dict[str, Optional[str]]:
# Translates countries to Q-nodes. Returns a dictionary of each input country and its QNode (None if not found)
# We look for countries in a case-insensitive fashion.
if not countries:
return {}
regions = query_countries(countries)
result_dict: Dict[str, Optional[str]] = {region.country: region.country_id for region in regions}
# The result dictionary contains all the countries we have found, we need to add those we did not find
found_countries = set([country.lower() for country in result_dict.keys()])
for country in countries:
if country.lower() not in found_countries:
result_dict[country] = None
return result_dict
def list_to_where(field: str, elements: List[str], lower=False) -> Optional[str]:
if not elements:
return None
if lower:
elements = [element.lower() for element in elements]
field = f"LOWER({field})"
santized = [sanitize(element) for element in elements]
quoted = [f"'{element}'" for element in santized]
joined = ', '.join(quoted)
return f"{field} IN ({joined})"
def region_where_clause(region_field: str, region_list: List[str], region_id_field: str,
region_id_list: List[str], alias_field: Optional[str] = None) -> str:
if not region_list and not region_id_list:
return "1=1"
region_where = list_to_where(region_field, region_list, lower=True) or "0=1"
if alias_field:
alias_where = list_to_where(alias_field, region_list, lower=True) or "0=1"
else:
alias_where = "0=1"
region_id_where = list_to_where(region_id_field, region_id_list) or "0=1"
return f'({region_where} OR {region_id_where} OR {alias_where})'
def _query_regions(query: str) -> List[Region]:
dicts = query_to_dicts(query)
return [Region(**d) for d in dicts]
def query_countries(countries: List[str] = [], country_ids: List[str] = []) -> List[Region]:
""" Returns a list of countries:
If countries or country_ids are not empty, only those countries are returned (all of those in both lists)
Otherwise, all countries are returned
"""
where = region_where_clause('s_country_label.text', countries, 'e_country.node1', country_ids)
query = f'''
SELECT e_country.node1 AS admin_id,
s_country_label.text AS admin,
'Q6256' AS region_type,
e_country.node1 AS country_id,
s_country_label.text AS country,
NULL as admin1_id,
NULL as admin1,
NULL as admin2_id,
NULL as admin2,
NULL as admin3_id,
NULL as admin3
FROM edges e_country
JOIN edges e_country_label JOIN strings s_country_label ON (e_country_label.id=s_country_label.edge_id)
ON (e_country.node1=e_country_label.node1 AND e_country_label.label='label')
WHERE e_country.label='P31' AND e_country.node2='Q6256' AND {where}
ORDER BY country
'''
return _query_regions(query)
def query_admin1s(country: Optional[str] = None, country_id: Optional[str] = None, admin1s: List[str] = [],
admin1_ids: List[str] = []) -> List[Region]:
"""
Returns a list of admin1s. If country or country_id is specified, return the admin1s only of that country.
If admin1s or admin1_ids are provided, only those admins are returned.
If all arguments are empty, all admin1s in the system are returned.
"""
if country and country_id:
raise ValueError('Only one of country, country_id may be specified')
if country_id:
country_where = f"e_country.node2='{country_id}'"
elif country: # We are certain country is not None here, but need an `elif` because mypy isn't certain
country_where = f"LOWER(s_country_label.text)='{country.lower()}'"
else:
country_where = "1=1"
admin1_where = region_where_clause('s_admin1_label.text', admin1s, 'e_admin1.node1', admin1_ids)
query = f'''
SELECT e_admin1.node1 AS admin_id,
s_admin1_label.text AS admin,
'Q10864048' AS region_type,
e_country.node2 AS country_id,
s_country_label.text AS country,
e_admin1.node1 as admin1_id,
s_admin1_label.text as admin1,
NULL as admin2_id,
NULL as admin2,
NULL as admin3_id,
NULL as admin3
FROM edges e_admin1
JOIN edges e_admin1_label JOIN strings s_admin1_label ON (e_admin1_label.id=s_admin1_label.edge_id)
ON (e_admin1.node1=e_admin1_label.node1 AND e_admin1_label.label='label')
JOIN edges e_country ON (e_country.node1=e_admin1.node1 AND e_country.label='P17')
JOIN edges e_country_label JOIN strings s_country_label ON (e_country_label.id=s_country_label.edge_id)
ON (e_country.node2=e_country_label.node1 AND e_country_label.label='label')
WHERE e_admin1.label='P31' AND e_admin1.node2='Q10864048' AND {country_where} AND {admin1_where}
ORDER BY admin1
'''
return _query_regions(query)
def query_admin2s(admin1: Optional[str] = None, admin1_id: Optional[str] = None, admin2s: List[str] = [],
admin2_ids: List[str] = []) -> List[Region]:
"""
Returns a list of admin2s. If admin1 or admin1_id is specified, return the admin2s only of that admin1.
If admin2s or admin2_ids are provided, only those admins are returned.
If all arguments are empty, all admin2s in the system are returned.
"""
if admin1 and admin1_id:
raise ValueError('Only one of admin1, admin1_id may be specified')
if admin1_id:
admin1_where = f"e_admin1.node2='{admin1_id}'"
elif admin1:
admin1_where = f"LOWER(s_admin1_label.text)=LOWER('{admin1}')"
else:
admin1_where = "1=1"
admin2_where = region_where_clause('s_admin2_label.text', admin2s, 'e_admin2.node1', admin2_ids)
query = f'''
SELECT e_admin2.node1 AS admin_id,
s_admin2_label.text AS admin,
'Q13220204' AS region_type,
e_country.node2 AS country_id,
s_country_label.text AS country,
e_admin1.node2 AS admin1_id,
s_admin1_label.text AS admin1,
e_admin2.node1 AS admin2_id,
s_admin2_label.text AS admin2,
NULL as admin3_id,
NULL as admin3
FROM edges e_admin2
JOIN edges e_admin2_label JOIN strings s_admin2_label ON (e_admin2_label.id=s_admin2_label.edge_id)
ON (e_admin2.node1=e_admin2_label.node1 AND e_admin2_label.label='label')
JOIN edges e_admin1 ON (e_admin1.node1=e_admin2.node1 AND e_admin1.label='P2006190001')
JOIN edges e_admin1_label JOIN strings s_admin1_label ON (e_admin1_label.id=s_admin1_label.edge_id)
ON (e_admin1.node2=e_admin1_label.node1 AND e_admin1_label.label='label')
JOIN edges e_country ON (e_country.node1=e_admin1.node2 AND e_country.label='P17')
JOIN edges e_country_label JOIN strings s_country_label ON (e_country_label.id=s_country_label.edge_id)
ON (e_country.node2=e_country_label.node1 AND e_country_label.label='label')
WHERE e_admin2.label='P31' AND e_admin2.node2='Q13220204' AND {admin1_where} AND {admin2_where}
ORDER BY admin2
'''
return _query_regions(query)
def query_admin3s(admin2: Optional[str] = None, admin2_id: Optional[str] = None, admin3s: List[str] = [],
admin3_ids: List[str] = [], debug=False) -> List[Region]:
"""
Returns a list of admin3s. If admin2 or admin2_id is specified, return the admin3s only of that admin2.
If admin3s or admin3_ids are provided, only those admins are returned.
If all arguments are empty, all admin3s in the system are returned.
"""
if admin2 and admin2_id:
raise ValueError('Only one of admin2, admin2_id may be specified')
if admin2_id:
admin2_where = f"e_admin2.node2='{admin2_id}'"
elif admin2:
admin2_where = f"LOWER(s_admin2_label.text)=LOWER('{admin2}')"
else:
admin2_where = "1=1"
admin3_where = region_where_clause('s_admin3_label.text', admin3s, 'e_admin3.node1', admin3_ids)
query = f'''
SELECT e_admin3.node1 AS admin_id,
s_admin3_label.text AS admin,
'Q13221722' AS region_type,
e_country.node2 AS country_id,
s_country_label.text AS country,
e_admin1.node2 AS admin1_id,
s_admin1_label.text AS admin1,
e_admin2.node2 AS admin2_id,
s_admin2_label.text AS admin2,
e_admin2.node1 AS admin3_id,
s_admin3_label.text AS admin3
FROM
edges e_admin3
JOIN edges e_admin3_label JOIN strings s_admin3_label ON (e_admin3_label.id=s_admin3_label.edge_id)
ON (e_admin3.node1=e_admin3_label.node1 AND e_admin3_label.label='label')
JOIN edges e_admin2 ON (e_admin2.node1=e_admin3.node1 AND e_admin2.label='P2006190002')
JOIN edges e_admin2_label JOIN strings s_admin2_label ON (e_admin2_label.id=s_admin2_label.edge_id)
ON (e_admin2.node2=e_admin2_label.node1 AND e_admin2_label.label='label')
JOIN edges e_admin1 ON (e_admin1.node1=e_admin2.node1 AND e_admin1.label='P2006190001')
JOIN edges e_admin1_label JOIN strings s_admin1_label ON (e_admin1_label.id=s_admin1_label.edge_id)
ON (e_admin1.node2=e_admin1_label.node1 AND e_admin1_label.label='label')
JOIN edges e_country ON (e_country.node1=e_admin1.node2 AND e_country.label='P17')
JOIN edges e_country_label JOIN strings s_country_label ON (e_country_label.id=s_country_label.edge_id)
ON (e_country.node2=e_country_label.node1 AND e_country_label.label='label')
WHERE e_admin3.label='P31' AND e_admin3.node2='Q13221722' AND {admin2_where} AND {admin3_where}
ORDER BY admin3
'''
if debug:
print(query)
return _query_regions(query)
def query_admins(admins: List[str] = [], admin_ids: List[str] = [], debug=False) -> List[Region]:
where = region_where_clause('s_region_label.text', admins, 'e_region.node1', admin_ids, 's_region_alias.text')
query = f'''
SELECT e_region.node1 AS admin_id, s_region_label.text AS admin, e_region.node2 AS region_type,
e_country.node2 AS country_id, s_country_label.text AS country,
e_admin1.node2 AS admin1_id, s_admin1_label.text AS admin1,
e_admin2.node2 AS admin2_id, s_admin2_label.text AS admin2,
'POINT(' || c_coordinate.longitude || ' ' || c_coordinate.latitude || ')' as region_coordinate,
s_region_alias.text AS alias
FROM edges e_region
JOIN edges e_region_label ON (e_region_label.node1=e_region.node1 AND e_region_label.label='label')
JOIN strings s_region_label ON (e_region_label.id=s_region_label.edge_id)
JOIN edges e_country
JOIN edges e_country_label
JOIN strings s_country_label
ON (s_country_label.edge_id=e_country_label.id)
ON (e_country.node2=e_country_label.node1 AND e_country_label.label='label')
ON (e_region.node1=e_country.node1 AND e_country.label='P17')
LEFT JOIN edges e_admin1
JOIN edges e_admin1_label
JOIN strings s_admin1_label
ON (s_admin1_label.edge_id=e_admin1_label.id)
ON (e_admin1.node2=e_admin1_label.node1 AND e_admin1_label.label='label')
ON (e_region.node1=e_admin1.node1 AND e_admin1.label='P2006190001')
LEFT JOIN edges e_admin2
JOIN edges e_admin2_label
JOIN strings s_admin2_label
ON (s_admin2_label.edge_id=e_admin2_label.id)
ON (e_admin2.node2=e_admin2_label.node1 AND e_admin2_label.label='label')
ON (e_region.node1=e_admin2.node1 AND e_admin2.label='P2006190002')
LEFT JOIN edges e_coordinate
JOIN coordinates c_coordinate
ON (c_coordinate.edge_id=e_coordinate.id)
ON (e_region.node1=e_coordinate.node1 AND e_coordinate.label='P625')
LEFT JOIN edges e_region_alias
JOIN strings s_region_alias
ON (s_region_alias.edge_id=e_region_alias.id)
ON (e_region.node1=e_region_alias.node1 AND e_region_alias.label='alias')
WHERE e_region.label='P31' AND e_region.node2 IN ('Q6256', 'Q10864048', 'Q13220204', 'Q13221722') AND {where}
'''
if debug:
print(query)
return _query_regions(query)
| 44.449686 | 115 | 0.678882 | [
"MIT"
] | Otamio/datamart-api | db/sql/dal/regions.py | 14,135 | Python |
# -*- coding: utf-8 -*-
import json
import csv
import scrapy
import re
from locations.items import GeojsonPointItem
COOKIES = {
"bm_sz": "04B124C1C96D68082A9F61BAAAF0B6D5~YAAQdjsvF22E8Xl6AQAACr1VfAxPEt+enarZyrOZrBaNvyuX71lK5QPuDR/FgDEWBZVMRhjiIf000W7Z1PiAjxobrz2Y5LcYMH3CvUNvpdS3MjVLUMGwMEBCf9L5nD5Gs9ho2YL8T7Tz7lYvpolvaOlJnKrHyhCFxxk/uyBZ2G/0QrGKLwSaCQShDsz7ink=",
"_abck": "440E40C406E69413DCCC08ABAA3E9022~-1~YAAQdjsvF26E8Xl6AQAACr1VfAYznoJdJhX7TNIZW1Rfh6qRhzquXg+L1TWoaL7nZUjXlNls2iPIKFQrCdrWqY/CNXW+mHyXibInMflIXJi5VVB/Swq53kABYJDuXYSlCunYvJAzMSr1q12NOYswz134Y8HRNzVWhkb2jMS5whmHxS/v0vniIvS1TQtKjEQlMGzQYmN41CmLX0JobipQhDtUB4VyNwztb2DCAZiqDX8BLwWg7h/DtPd4158qU69hNhayFTgWmD76/MiR8/T536tMmcoRyWLl4fEtP/XUmKOcksuZO7dbfNxXBffTxIXPYwf1eO77LNuZTCQq5kfsGZLJX8ODju2KSjnIF1vdnyHAe98FDIm+hw==~-1~-1~-1"
}
HEADERS = {
'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
'accept-encoding': 'gzip, deflate, br',
'cache-control': 'max-age=0',
'referer': 'https://www.aldi.co.uk/store-finder',
'sec-ch-ua': '" Not;A Brand";v="99", "Google Chrome";v="91", "Chromium";v="91"',
'sec-ch-ua-mobile': '?0',
'sec-fetch-dest': 'document',
'sec-fetch-mode': 'navigate',
'sec-fetch-site': 'same-origin',
'sec-fetch-user': '?1',
'upgrade-insecure-requests': '1',
'user-agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36',
}
class AldiUKSpider(scrapy.Spider):
name = "aldi_uk"
item_attributes = {'brand': "Aldi"}
allowed_domains = ['aldi.co.uk']
download_delay = 0.5
custom_settings = {
'USER_AGENT': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36',
}
def start_requests(self):
url = 'https://www.aldi.co.uk/sitemap/store-en_gb-gbp'
yield scrapy.http.FormRequest(
url=url,
method='GET',
dont_filter=True,
cookies=COOKIES,
headers=HEADERS,
callback=self.parse
)
def parse(self, response):
response.selector.remove_namespaces()
store_urls = response.xpath('//url/loc/text()').extract()
for store_url in store_urls:
yield scrapy.http.FormRequest(
url=store_url,
method='GET',
dont_filter=True,
cookies=COOKIES,
headers=HEADERS,
callback=self.parse_store
)
def parse_store(self, response):
store_js = response.xpath('//script[@type="text/javascript"]/text()').extract_first()
json_data = re.search('gtmData =(.+?);', store_js).group(1)
data = json.loads(json_data)
geojson_data = response.xpath('//script[@class="js-store-finder-initial-state"][@type="application/json"]/text()').extract_first()
geodata = json.loads(geojson_data)
properties = {
'name': data['seoData']['name'],
'ref': data['seoData']['name'],
'addr_full': data['seoData']['address']['streetAddress'],
'city': data['seoData']['address']['addressLocality'],
'postcode': data['seoData']['address']['postalCode'],
'country': data['seoData']['address']['addressCountry'],
'website': response.request.url,
'opening_hours': str(data['seoData']['openingHours']).replace('[','').replace(']','').replace("'",''),
'lat': geodata['store']['latlng']['lat'],
'lon': geodata['store']['latlng']['lng'],
}
yield GeojsonPointItem(**properties)
| 42.988636 | 436 | 0.636532 | [
"MIT"
] | ChrisSoderberg/alltheplaces | locations/spiders/aldi_uk.py | 3,783 | Python |
import argparse
import logging
from pprint import pformat
from . import guide
from . import settings
log = logging.getLogger(__name__)
def cli(settingsobject=None):
parser = argparse.ArgumentParser(description='Create a CSS/LESS/SASS style guide.')
if not settingsobject:
parser.add_argument('-f', '--settingsfile',
dest='settingsfile', default='vitalstyles.json',
help='Path to settings file. Defaults to "vitalstyles.json".')
parser.add_argument('-l', '--loglevel',
dest='loglevel', default='INFO',
choices=['DEBUG', 'INFO', 'ERROR'], help='Loglevel.')
args = parser.parse_args()
loglevel = getattr(logging, args.loglevel)
logging.basicConfig(
format='[%(name)s] %(levelname)s: %(message)s',
level=loglevel
)
if loglevel > logging.DEBUG:
markdownlogger = logging.getLogger('MARKDOWN')
markdownlogger.setLevel(logging.WARNING)
if not settingsobject:
settingsobject = settings.Settings(args.settingsfile)
logging.debug('Creating vitalstyles styleguide with the following settings:\n%s',
pformat(settingsobject.settings))
guide.Guide(settingsobject).render()
if __name__ == '__main__':
cli()
| 29.880952 | 87 | 0.67012 | [
"BSD-3-Clause"
] | appressoas/vitalstyles | vitalstyles/cli.py | 1,255 | Python |
class Player():
def __init__(self):
print("PLYR FAK SUM BODIE")
| 15.4 | 35 | 0.597403 | [
"MIT"
] | reecebenson/DADSA-Tennis-PartA | .history/classes/Player_20171106170937.py | 77 | Python |
#!/usr/bin/env python
# vim: set sts=4 sw=4 et:
import time
import xmlrpc.client
from . import players
from . import rpc
from .common import GameState, CardSet, GameError, RuleError, ProtocolError, simple_decorator
from .events import EventList, CardPlayedEvent, MessageEvent, TrickPlayedEvent, TurnEvent, StateChangedEvent
@simple_decorator
def error2fault(func):
"""
Catch known exceptions and translate them to
XML-RPC faults.
"""
def catcher(*args):
try:
return func(*args)
except GameError as error:
raise xmlrpc.client.Fault(GameError.rpc_code, str(error))
except RuleError as error:
raise xmlrpc.client.Fault(RuleError.rpc_code, str(error))
except ProtocolError as error:
raise xmlrpc.client.Fault(ProtocolError.rpc_code, str(error))
return catcher
@simple_decorator
def fault2error(func):
"""
Catch known XML-RPC faults and translate them to
custom exceptions.
"""
def catcher(*args):
try:
return func(*args)
except xmlrpc.client.Fault as error:
error_classes = (GameError, RuleError, ProtocolError)
for klass in error_classes:
if error.faultCode == klass.rpc_code:
raise klass(error.faultString)
raise error
return catcher
class XMLRPCCliPlayer(players.CliPlayer):
"""
XML-RPC command line interface human player.
"""
def __init__(self, player_name):
players.CliPlayer.__init__(self, player_name)
self.game_state = GameState()
self.hand = None
def handle_event(self, event):
if isinstance(event, CardPlayedEvent):
self.card_played(event.player, event.card, event.game_state)
elif isinstance(event, MessageEvent):
self.send_message(event.sender, event.message)
elif isinstance(event, TrickPlayedEvent):
self.trick_played(event.player, event.game_state)
elif isinstance(event, TurnEvent):
self.game_state.update(event.game_state)
state = self.controller.get_state(self.id)
self.hand = state['hand']
self.game_state.update(state['game_state'])
elif isinstance(event, StateChangedEvent):
self.game_state.update(event.game_state)
else:
print("unknown event: %s" % event)
def wait_for_turn(self):
"""
Wait for this player's turn.
"""
while True:
time.sleep(0.5)
if self.controller is not None:
events = self.controller.get_events(self.id)
for event in events:
self.handle_event(event)
if self.game_state.turn_id == self.id:
break
class XMLRPCProxyController():
"""
Client-side proxy object for the server/GameController.
"""
def __init__(self, server_uri):
super(XMLRPCProxyController, self).__init__()
if not server_uri.startswith('http://') and \
not server_uri.startswith('https://'):
server_uri = 'http://' + server_uri
self.server = xmlrpc.client.ServerProxy(server_uri)
self.game_id = None
self.akey = None
@fault2error
def play_card(self, _player, card):
self.server.game.play_card(self.akey, self.game_id, rpc.rpc_encode(card))
@fault2error
def get_events(self, _player_id):
return rpc.rpc_decode(EventList, self.server.get_events(self.akey))
@fault2error
def get_state(self, _player_id):
state = self.server.game.get_state(self.akey, self.game_id)
state['game_state'] = rpc.rpc_decode(GameState, state['game_state'])
state['hand'] = rpc.rpc_decode(CardSet, state['hand'])
return state
@fault2error
def player_quit(self, _player_id):
self.server.player.quit(self.akey)
@fault2error
def register_player(self, player):
player.controller = self
plr_data = self.server.player.register(rpc.rpc_encode(player))
player.id = plr_data['id']
self.akey = plr_data['akey']
@fault2error
def start_game_with_bots(self):
return self.server.game.start_with_bots(self.akey, self.game_id)
@fault2error
def create_game(self):
self.game_id = self.server.game.create(self.akey)
return self.game_id
| 31.621429 | 108 | 0.63813 | [
"BSD-3-Clause"
] | jait/tupelo | tupelo/xmlrpc.py | 4,427 | Python |
import time
import numpy as np
import tensorflow as tf
import layers as L
import vat
FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_string('device', '/gpu:0', "device")
tf.app.flags.DEFINE_string('dataset', 'cifar10', "{cifar10, svhn}")
tf.app.flags.DEFINE_string('log_dir', "", "log_dir")
tf.app.flags.DEFINE_integer('seed', 1, "initial random seed")
tf.app.flags.DEFINE_bool('validation', False, "")
tf.app.flags.DEFINE_integer('batch_size', 32, "the number of examples in a batch")
tf.app.flags.DEFINE_integer('ul_batch_size', 128, "the number of unlabeled examples in a batch")
tf.app.flags.DEFINE_integer('eval_batch_size', 100, "the number of eval examples in a batch")
tf.app.flags.DEFINE_integer('eval_freq', 5, "")
tf.app.flags.DEFINE_integer('num_epochs', 120, "the number of epochs for training")
tf.app.flags.DEFINE_integer('epoch_decay_start', 80, "epoch of starting learning rate decay")
tf.app.flags.DEFINE_integer('num_iter_per_epoch', 400, "the number of updates per epoch")
tf.app.flags.DEFINE_float('learning_rate', 0.001, "initial leanring rate")
tf.app.flags.DEFINE_float('mom1', 0.9, "initial momentum rate")
tf.app.flags.DEFINE_float('mom2', 0.5, "momentum rate after epoch_decay_start")
tf.app.flags.DEFINE_string('method', 'vat', "{vat, vatent, baseline}")
if FLAGS.dataset == 'cifar10':
from cifar10 import inputs, unlabeled_inputs
elif FLAGS.dataset == 'svhn':
from svhn import inputs, unlabeled_inputs
else:
raise NotImplementedError
NUM_EVAL_EXAMPLES = 5000
def build_training_graph(x, y, ul_x, ul_u, lr, mom):
global_step = tf.get_variable(
name="global_step",
shape=[],
dtype=tf.float32,
initializer=tf.constant_initializer(0.0),
trainable=False,
)
logit = vat.forward(x)
nll_loss = L.ce_loss(logit, y)
with tf.variable_scope(tf.get_variable_scope(), reuse=True):
if FLAGS.method == 'vat':
ul_logit = vat.forward(ul_x, is_training=True, update_batch_stats=False)
vat_loss, ul_u_updated = vat.virtual_adversarial_loss(ul_x, ul_u, ul_logit)
additional_loss = vat_loss
elif FLAGS.method == 'vatent':
ul_logit = vat.forward(ul_x, is_training=True, update_batch_stats=False)
vat_loss, ul_u_updated = vat.virtual_adversarial_loss(ul_x, ul_u, ul_logit)
ent_loss = L.entropy_y_x(ul_logit)
additional_loss = vat_loss + ent_loss
elif FLAGS.method == 'baseline':
additional_loss = 0
else:
raise NotImplementedError
loss = nll_loss + additional_loss
opt = tf.train.AdamOptimizer(learning_rate=lr, beta1=mom)
tvars = tf.trainable_variables()
grads_and_vars = opt.compute_gradients(loss, tvars)
train_op = opt.apply_gradients(grads_and_vars, global_step=global_step)
return loss, train_op, global_step, ul_u_updated
def build_eval_graph(x, y, ul_x, ul_u):
losses = {}
logit = vat.forward(x, is_training=False, update_batch_stats=False)
nll_loss = L.ce_loss(logit, y)
losses['NLL'] = nll_loss
acc = L.accuracy(logit, y)
losses['Acc'] = acc
scope = tf.get_variable_scope()
scope.reuse_variables()
# at_loss = vat.adversarial_loss(x, y, nll_loss, is_training=False)
# losses['AT_loss'] = at_loss
ul_logit = vat.forward(ul_x, is_training=False, update_batch_stats=False)
vat_loss = vat.virtual_adversarial_loss(ul_x, ul_u, ul_logit, is_training=False)
losses['VAT_loss'] = vat_loss
return losses
def main(_):
print(FLAGS.epsilon, FLAGS.top_bn)
np.random.seed(seed=FLAGS.seed)
tf.set_random_seed(np.random.randint(1234))
with tf.Graph().as_default() as g:
with tf.device("/cpu:0"):
images, labels = inputs(batch_size=FLAGS.batch_size,
train=True,
validation=FLAGS.validation,
shuffle=True)
ul_images = tf.placeholder(shape=images.shape, dtype=tf.float32)
'''unlabeled_inputs(batch_size=FLAGS.ul_batch_size,
validation=FLAGS.validation,
shuffle=True)'''
images_eval_train, labels_eval_train = inputs(batch_size=FLAGS.eval_batch_size,
train=True,
validation=FLAGS.validation,
shuffle=True)
ul_images_eval_train = unlabeled_inputs(batch_size=FLAGS.eval_batch_size,
validation=FLAGS.validation,
shuffle=True)
images_eval_test, labels_eval_test = inputs(batch_size=FLAGS.eval_batch_size,
train=False,
validation=FLAGS.validation,
shuffle=True)
def placeholder_like(x, name=None):
return tf.placeholder(shape=x.shape, dtype=tf.float32, name=name)
def random_sphere(shape):
n = tf.random_normal(shape=shape, dtype=tf.float32)
n = tf.reshape(n, shape=(int(shape[0]), -1))
n = tf.nn.l2_normalize(n, dim=1)
n = tf.reshape(n, shape)
return n
def random_sphere_numpy(shape):
n = np.random.normal(size=shape)
proj_shape = tuple([n.shape[0]] + [1 for _ in range(len(shape) - 1)])
return n / np.linalg.norm(n.reshape((n.shape[0], -1)), axis=1).reshape(proj_shape)
print(ul_images.shape)
# ul_u = random_sphere(ul_images.shape)
# ul_u_eval_train = random_sphere(ul_images_eval_train.shape)
# ul_u_eval_test = random_sphere(images_eval_test.shape)
ul_u = placeholder_like(ul_images, "ul_u")
ul_u_eval_train = placeholder_like(ul_images_eval_train, "ul_u_eval_train")
ul_u_eval_test = placeholder_like(images_eval_test, "ul_u_eval_test")
with tf.device(FLAGS.device):
lr = tf.placeholder(tf.float32, shape=[], name="learning_rate")
mom = tf.placeholder(tf.float32, shape=[], name="momentum")
with tf.variable_scope("CNN") as scope:
# Build training graph
loss, train_op, global_step, ul_u_updated = build_training_graph(
images, labels, ul_images, ul_u, lr, mom)
scope.reuse_variables()
# Build eval graph
losses_eval_train = build_eval_graph(images_eval_train, labels_eval_train, ul_images_eval_train, ul_u_eval_train)
losses_eval_test = build_eval_graph(images_eval_test, labels_eval_test, images_eval_test, ul_u_eval_test)
init_op = tf.global_variables_initializer()
if not FLAGS.log_dir:
logdir = None
writer_train = None
writer_test = None
else:
logdir = FLAGS.log_dir
writer_train = tf.summary.FileWriter(FLAGS.log_dir + "/train", g)
writer_test = tf.summary.FileWriter(FLAGS.log_dir + "/test", g)
saver = tf.train.Saver(tf.global_variables())
sv = tf.train.Supervisor(
is_chief=True,
logdir=logdir,
init_op=init_op,
init_feed_dict={lr: FLAGS.learning_rate, mom: FLAGS.mom1},
saver=saver,
global_step=global_step,
summary_op=None,
summary_writer=None,
save_model_secs=150, recovery_wait_secs=0)
ul_images_np = np.load("train_images.npy").reshape((-1, 32, 32, 3))
print("TRUNCATING UL DATA")
ul_images_np = ul_images_np[:FLAGS.batch_size]
ul_u_np = random_sphere_numpy(ul_images_np.shape)
print(ul_images_np.shape, ul_u_np.shape)
print("Training...")
with sv.managed_session() as sess:
for ep in range(FLAGS.num_epochs):
if sv.should_stop():
break
if ep < FLAGS.epoch_decay_start:
feed_dict = {lr: FLAGS.learning_rate, mom: FLAGS.mom1}
else:
decayed_lr = ((FLAGS.num_epochs - ep) / float(
FLAGS.num_epochs - FLAGS.epoch_decay_start)) * FLAGS.learning_rate
feed_dict = {lr: decayed_lr, mom: FLAGS.mom2}
sum_loss = 0
start = time.time()
for i in range(FLAGS.num_iter_per_epoch):
picked = range(FLAGS.batch_size) # np.random.choice(len(ul_images_np), size=FLAGS.batch_size, replace=False)
feed_dict[ul_images] = ul_images_np[picked]
feed_dict[ul_u] = ul_u_np[picked]
ul_u_updated_np, _, batch_loss, _ = sess.run([ul_u_updated, train_op, loss, global_step],
feed_dict=feed_dict)
delta = ul_u_updated_np - ul_u_np[picked]
# print("pos", ul_u_updated_np.reshape((FLAGS.batch_size, -1))[0, :4])
# print("delta", np.linalg.norm(delta.reshape((FLAGS.batch_size, -1)), axis=1)[:4])
print(np.linalg.norm(ul_u_updated_np - ul_u_np[picked]), ul_u_updated_np.reshape((FLAGS.batch_size, -1))[0, :3])
ul_u_np[picked] = ul_u_updated_np
sum_loss += batch_loss
end = time.time()
print("Epoch:", ep, "CE_loss_train:", sum_loss / FLAGS.num_iter_per_epoch, "elapsed_time:", end - start)
if (ep + 1) % FLAGS.eval_freq == 0 or ep + 1 == FLAGS.num_epochs:
# Eval on training data
act_values_dict = {}
feed_dict = {ul_u_eval_train: random_sphere_numpy(ul_u_eval_train.shape)}
for key, _ in losses_eval_train.iteritems():
act_values_dict[key] = 0
n_iter_per_epoch = NUM_EVAL_EXAMPLES / FLAGS.eval_batch_size
for i in range(n_iter_per_epoch):
values = losses_eval_train.values()
act_values = sess.run(values, feed_dict=feed_dict)
for key, value in zip(act_values_dict.keys(), act_values):
act_values_dict[key] += value
summary = tf.Summary()
current_global_step = sess.run(global_step)
for key, value in act_values_dict.iteritems():
print("train-" + key, value / n_iter_per_epoch)
summary.value.add(tag=key, simple_value=value / n_iter_per_epoch)
if writer_train is not None:
writer_train.add_summary(summary, current_global_step)
# Eval on test data
act_values_dict = {}
print("HOW COME THIS DOES NOT DEPEND ON ul_images_eval_train? SOMETHING'S WRONG HERE.")
feed_dict = {ul_u_eval_test: random_sphere_numpy(ul_u_eval_test.shape)}
for key, _ in losses_eval_test.iteritems():
act_values_dict[key] = 0
n_iter_per_epoch = NUM_EVAL_EXAMPLES / FLAGS.eval_batch_size
for i in range(n_iter_per_epoch):
values = losses_eval_test.values()
act_values = sess.run(values, feed_dict=feed_dict)
for key, value in zip(act_values_dict.keys(), act_values):
act_values_dict[key] += value
summary = tf.Summary()
current_global_step = sess.run(global_step)
for key, value in act_values_dict.iteritems():
print("test-" + key, value / n_iter_per_epoch)
summary.value.add(tag=key, simple_value=value / n_iter_per_epoch)
if writer_test is not None:
writer_test.add_summary(summary, current_global_step)
saver.save(sess, sv.save_path, global_step=global_step)
sv.stop()
if __name__ == "__main__":
tf.app.run()
| 47.778626 | 132 | 0.582202 | [
"MIT"
] | danielvarga/vat_tf | train_semisup.py | 12,518 | Python |
"""
File: Milestone1.py
Name: 黃科諺
-----------------------
This file tests the milestone 1 for
our babyname.py project
"""
import sys
def add_data_for_name(name_data, year, rank, name):
name_info = {year: rank}
if name in name_data:
if year in name_data[name]:
exist_rank = int(name_data[name][year])
if int(rank) < exist_rank:
name_data[name][year] = rank
else:
name_data[name][year] = rank
else:
name_data[name] = name_info
# ------------- DO NOT EDIT THE CODE BELOW THIS LINE ---------------- #
def test1():
name_data = {'Kylie': {'2010': '57'}, 'Nick': {'2010': '37'}}
add_data_for_name(name_data, '2010', '208', 'Kate')
print('--------------------test1----------------------')
print(str(name_data))
print('-----------------------------------------------')
def test2():
name_data = {'Kylie': {'2010': '57'}, 'Nick': {'2010': '37'}}
add_data_for_name(name_data, '2000', '104', 'Kylie')
print('--------------------test2----------------------')
print(str(name_data))
print('-----------------------------------------------')
def test3():
name_data = {'Kylie': {'2010': '57'}, 'Sammy': {'1980': '451', '1990': '200'}, 'Kate': {'2000': '100'}}
add_data_for_name(name_data, '1990', '900', 'Sammy')
add_data_for_name(name_data, '2010', '400', 'Kylie')
add_data_for_name(name_data, '2000', '20', 'Kate')
print('-------------------test3-----------------------')
print(str(name_data))
print('-----------------------------------------------')
def test4():
name_data = {'Kylie': {'2010': '57'}, 'Nick': {'2010': '37'}}
add_data_for_name(name_data, '2010', '208', 'Kate')
add_data_for_name(name_data, '2000', '108', 'Kate')
add_data_for_name(name_data, '1990', '200', 'Sammy')
add_data_for_name(name_data, '1990', '90', 'Sammy')
add_data_for_name(name_data, '2000', '104', 'Kylie')
print('--------------------test4----------------------')
print(str(name_data))
print('-----------------------------------------------')
def main():
args = sys.argv[1:]
if len(args) == 1 and args[0] == 'test1':
test1()
elif len(args) == 1 and args[0] == 'test2':
test2()
elif len(args) == 1 and args[0] == 'test3':
test3()
elif len(args) == 1 and args[0] == 'test4':
test4()
if __name__ == "__main__":
main()
| 31.307692 | 107 | 0.47502 | [
"MIT"
] | kenhuang1204/stanCode_projects | stanCode_projects/name_searching_system/milestone1.py | 2,448 | Python |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from compas.utilities import await_callback
from compas_fab.backends.interfaces import AddCollisionMesh
from compas_fab.backends.ros.messages import ApplyPlanningSceneRequest
from compas_fab.backends.ros.messages import ApplyPlanningSceneResponse
from compas_fab.backends.ros.messages import CollisionObject
from compas_fab.backends.ros.messages import PlanningScene
from compas_fab.backends.ros.messages import PlanningSceneWorld
from compas_fab.backends.ros.service_description import ServiceDescription
__all__ = [
'MoveItAddCollisionMesh',
]
class MoveItAddCollisionMesh(AddCollisionMesh):
"""Callable to add a collision mesh to the planning scene."""
APPLY_PLANNING_SCENE = ServiceDescription('/apply_planning_scene',
'ApplyPlanningScene',
ApplyPlanningSceneRequest,
ApplyPlanningSceneResponse,
)
def __init__(self, ros_client):
self.ros_client = ros_client
def add_collision_mesh(self, collision_mesh, options=None):
"""Add a collision mesh to the planning scene.
Parameters
----------
collision_mesh : :class:`compas_fab.robots.CollisionMesh`
Object containing the collision mesh to be added.
options : dict, optional
Unused parameter.
Returns
-------
``None``
"""
kwargs = {}
kwargs['collision_mesh'] = collision_mesh
kwargs['errback_name'] = 'errback'
return await_callback(self.add_collision_mesh_async, **kwargs)
def add_collision_mesh_async(self, callback, errback, collision_mesh):
co = CollisionObject.from_collision_mesh(collision_mesh)
co.operation = CollisionObject.ADD
world = PlanningSceneWorld(collision_objects=[co])
scene = PlanningScene(world=world, is_diff=True)
request = scene.to_request(self.ros_client.ros_distro)
self.APPLY_PLANNING_SCENE(self.ros_client, request, callback, errback)
| 38.362069 | 78 | 0.681798 | [
"MIT"
] | gramaziokohler/compas_fab | src/compas_fab/backends/ros/backend_features/move_it_add_collision_mesh.py | 2,225 | Python |
"""
libquantum example 3: 03_sweep_linear.py
Construct classic linear chirp and illustrate CWT and STFT TRFs.
"""
import os
from pathlib import Path
import numpy as np
import scipy.io.wavfile
import matplotlib.pyplot as plt
from libquantum import atoms, entropy, scales, spectra, utils, synthetics
import libquantum.plot_templates.plot_time_frequency_reps as pltq
if __name__ == "__main__":
"""
Exercises with classic linear sweep
Option of exporting to wav
"""
# Do you want to export a wav file? True or False
do_save_wave = False
# If True, saves to home directory
home_dir: str = str(Path.home())
# Or can specify a preferred wav file directory
# home_dir: str = "/Users/mgarces/Documents/DATA_API_M/synthetics"
output_wav_directory = os.path.join(home_dir, "wav")
EVENT_NAME = "redshift_linear_sweep"
print("Event Name: " + EVENT_NAME)
wav_filename = EVENT_NAME
order_number_input = 3
station_id_str = 'Synth'
run_time_epoch_s = utils.datetime_now_epoch_s()
# Chirp type
is_redshift = True
sig_wf_sample_rate_hz = 8000.
sig_frequency_hz_start = 40.
sig_frequency_hz_end = 400.
sig_duration_s = 13.19675
head_s = 0.5
# sig_wf_sample_rate_hz = 8000.
# sig_frequency_hz_start = 40.
# sig_frequency_hz_end = 400.
# sig_duration_s = 13.19675
# head_s = 0.5
# Blueshift sweep
sig_wf_blu, sig_wf_epoch_s = synthetics.chirp_linear_in_noise(snr_bits=12.,
sample_rate_hz=sig_wf_sample_rate_hz,
duration_s=sig_duration_s,
frequency_start_hz=sig_frequency_hz_start,
frequency_end_hz=sig_frequency_hz_end,
intro_s=head_s,
outro_s=head_s)
sig_wf_red = np.flipud(sig_wf_blu)
# Choose origin and red/blue shift
sig_wf_epoch_s += run_time_epoch_s
sig_wf = np.copy(sig_wf_red)
# Antialias filter synthetic
synthetics.antialias_halfNyquist(synth=sig_wf)
# Export to wav directory
if do_save_wave:
wav_sample_rate_hz = 8000.
export_filename = os.path.join(output_wav_directory, wav_filename + "_8kz.wav")
synth_wav = 0.9 * np.real(sig_wf) / np.max(np.abs((np.real(sig_wf))))
scipy.io.wavfile.write(export_filename, int(wav_sample_rate_hz), synth_wav)
# Frame to mic start and end and plot
event_reference_time_epoch_s = sig_wf_epoch_s[0]
max_time_s, min_frequency_hz = scales.from_duration(band_order_Nth=order_number_input,
sig_duration_s=sig_duration_s)
print('\nRequest Order N=', order_number_input)
print('Lowest frequency in hz that can support this order for this signal duration is ', min_frequency_hz)
print('Scale with signal duration and to Nyquist, default G2 base re F1')
# Select plot frequencies
fmin = np.ceil(min_frequency_hz)
fmax = sig_wf_sample_rate_hz/2.
# TFR SECTION
# Compute complex wavelet transform (cwt) from signal duration
if is_redshift:
mic_cwt, mic_cwt_bits, mic_cwt_time_s, mic_cwt_frequency_hz = \
atoms.cwt_chirp_from_sig(sig_wf=sig_wf,
frequency_sample_rate_hz=sig_wf_sample_rate_hz,
band_order_Nth=order_number_input,
dictionary_type="tone",
index_shift=-1)
else:
mic_cwt, mic_cwt_bits, mic_cwt_time_s, mic_cwt_frequency_hz = \
atoms.cwt_chirp_from_sig(sig_wf=sig_wf,
frequency_sample_rate_hz=sig_wf_sample_rate_hz,
band_order_Nth=order_number_input,
dictionary_type="tone")
mic_cwt_snr, mic_cwt_snr_bits, mic_cwt_snr_entropy = entropy.snr_mean_max(tfr_coeff_complex=mic_cwt)
pltq.plot_wf_mesh_mesh_vert(redvox_id=station_id_str,
wf_panel_2_sig=sig_wf,
wf_panel_2_time=sig_wf_epoch_s,
mesh_time=mic_cwt_time_s,
mesh_frequency=mic_cwt_frequency_hz,
mesh_panel_1_trf=mic_cwt_bits,
mesh_panel_1_colormap_scaling="range",
mesh_panel_0_tfr=mic_cwt_snr_entropy,
wf_panel_2_units="Norm",
mesh_panel_1_cbar_units="bits",
mesh_panel_0_cbar_units="eSNR bits",
start_time_epoch=event_reference_time_epoch_s,
figure_title="CWT for " + EVENT_NAME,
frequency_hz_ymin=fmin,
frequency_hz_ymax=fmax)
# Compute short term Fourier transform (STFT) from segmented signal duration
mic_stft, mic_stft_bits, mic_stft_time_s, mic_stft_frequency_hz = \
spectra.stft_from_sig(sig_wf=sig_wf,
frequency_sample_rate_hz=sig_wf_sample_rate_hz,
band_order_Nth=order_number_input)
mic_stft_snr, mic_stft_snr_bits, mic_stft_snr_entropy = entropy.snr_mean_max(tfr_coeff_complex=mic_stft)
# Log frequency is the default, for linear use frequency_scaling="linear",
pltq.plot_wf_mesh_mesh_vert(frequency_scaling="log",
redvox_id=station_id_str,
wf_panel_2_sig=sig_wf,
wf_panel_2_time=sig_wf_epoch_s,
mesh_time=mic_stft_time_s,
mesh_frequency=mic_stft_frequency_hz,
mesh_panel_1_trf=mic_stft_bits,
mesh_panel_1_colormap_scaling="range",
mesh_panel_0_tfr=mic_stft_snr_entropy,
wf_panel_2_units="Norm",
mesh_panel_1_cbar_units="bits",
mesh_panel_0_cbar_units="eSNR bits",
figure_title="STFT for " + EVENT_NAME,
frequency_hz_ymin=fmin,
frequency_hz_ymax=fmax)
plt.show()
| 44.13245 | 110 | 0.579232 | [
"Apache-2.0"
] | RedVoxInc/libquantum | examples/03_sweep_linear.py | 6,664 | Python |
import hashlib
from fastecdsa import keys, curve, ecdsa
from hashlib import sha256
from uuid import uuid4
class Transaction:
def __init__(self, from_address, to_address, amount):
self.from_address = from_address
self.to_address = to_address
self.amount = amount
self.id = str(uuid4()).replace('-', '')
self.signature = None
def calculate_hash(self):
return sha256((str(self.from_address) + str(self.to_address) + str(self.amount) + self.id).encode()).hexdigest()
def sign_tx(self, priv_key):
hash_tx = self.calculate_hash()
self.signature = ecdsa.sign(hash_tx, priv_key, hashfunc=sha256)
def is_valid(self):
if self.signature is None:
return True
if len(self.signature) == 0 and self.to_address is None:
return False
hash_tx = self.calculate_hash()
pubkey = keys.get_public_keys_from_sig(self.signature, hash_tx, curve=curve.P256, hashfunc=sha256)
valid = ecdsa.verify(self.signature, hash_tx, pubkey[0], hashfunc=sha256)
return valid
def serialize(self):
return {
'id': self.id,
'from_address': self.from_address,
'to_address': self.to_address,
'amount': self.amount
}
| 30.928571 | 120 | 0.635874 | [
"MIT"
] | ephremdeme/voting | blockchain/Transaction.py | 1,299 | Python |
# -*- coding: utf-8 -*-
from app.libs.utils import data_decode
import socket, socketserver, threading
import traceback
class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):
ip = ""
port = 0
timeOut = 100
def __init__(self, request, client_address, server):
from app.service.device import Device
self.socket = None
self.addr = None
self.cloud_id = None
self.device = Device()
self.sign = None
self.device_id = None
self.timestamp = None
super().__init__(request, client_address, server)
def setup(self):
self.ip = self.client_address[0].strip()
self.port = self.client_address[1]
self.request.settimeout(self.timeOut)
self.addr = self.ip + str(self.port)
self.socket = self.request
print(self.ip)
def handle(self):
try:
while True:
try:
# time.sleep(1)
data = self.request.recv(1024)
except socket.timeout:
print(self.ip + ":" + str(self.port) + "接收超时")
break
if data:
data = data_decode(data)
self.device.parse_data(data, self)
else:
break
except Exception as e:
with open("err_log.log", "a+") as f:
f.write(traceback.format_exc()+'\r\r')
print(self.client_address, "连接断开")
finally:
self.request.close()
def finish(self):
if self.cloud_id is None:
print(self.ip + ":" + str(self.port) + "断开连接！")
else:
get_instance().remove_client(self.cloud_id)
print(self.ip + ":" + str(self.port) + self.cloud_id + "断开连接！")
class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass
class TCPServer:
instance = None
@staticmethod
def get_instance():
print("start")
if TCPServer.instance is None:
TCPServer.instance = TCPServer()
return TCPServer.instance
def __init__(self):
self.clients = {}
self.server = None
try:
self.server = ThreadedTCPServer(("0.0.0.0", 5002), ThreadedTCPRequestHandler)
server_thread = threading.Thread(target=self.server.serve_forever)
server_thread.daemon = True
server_thread.start()
# server_thread.join()
except (KeyboardInterrupt, SystemExit, Exception) as e:
print(e)
print("end")
self.server.shutdown()
self.server.close()
def add_client(self, cloud, sock):
self.clients[cloud] = sock
print("this is clients", self.clients)
def remove_client(self, cloud):
if cloud in self.clients:
print("删除设备" + cloud)
from app.service.device import Device
Device.offline_alarm(self.clients[cloud])
self.clients.pop(cloud)
def get_instance():
return TCPServer.get_instance()
| 30.126214 | 89 | 0.565259 | [
"Apache-2.0"
] | mohansd/cyx-xElec-server | app/service/socketservice.py | 3,147 | Python |
from django.conf.urls import patterns, url
from django.contrib.contenttypes.models import ContentType
from kitsune.questions.feeds import (
QuestionsFeed, AnswersFeed, TaggedQuestionsFeed)
from kitsune.questions.models import Question, Answer
from kitsune.flagit import views as flagit_views
urlpatterns = patterns(
'kitsune.questions.views',
url(r'^$', 'product_list', name='questions.home'),
url(r'^/answer-preview-async$', 'answer_preview_async',
name='questions.answer_preview_async'),
url(r'^/dashboard/metrics$', 'metrics', name='questions.metrics'),
url(r'^/dashboard/metrics/(?P<locale_code>[^/]+)$', 'metrics',
name='questions.locale_metrics'),
# AAQ
url(r'^/new$', 'aaq', name='questions.aaq_step1'),
url(r'^/new/confirm$', 'aaq_confirm', name='questions.aaq_confirm'),
url(r'^/new/(?P<product_key>[\w\-]+)$',
'aaq_step2', name='questions.aaq_step2'),
url(r'^/new/(?P<product_key>[\w\-]+)/(?P<category_key>[\w\-]+)$',
'aaq_step3', name='questions.aaq_step3'),
url(r'^/new/(?P<product_key>[\w\-]+)/(?P<category_key>[\w\-]+)/search$',
'aaq_step4', name='questions.aaq_step4'),
url(r'^/new/(?P<product_key>[\w\-]+)/(?P<category_key>[\w\-]+)/form$',
'aaq_step5', name='questions.aaq_step5'),
# AAQ flow for Marketplace
url(r'^/marketplace$', 'marketplace', name='questions.marketplace_aaq'),
url(r'^/marketplace/success$',
'marketplace_success', name='questions.marketplace_aaq_success'),
url(r'^/marketplace/refund$', 'marketplace_refund',
name='questions.marketplace_refund'),
url(r'^/marketplace/developer-request$', 'marketplace_developer_request',
name='questions.marketplace_developer_request'),
url(r'^/marketplace/(?P<category_slug>[\w\-]+)$',
'marketplace_category', name='questions.marketplace_aaq_category'),
# TODO: Factor out `/(?P<question_id>\d+)` below
url(r'^/(?P<question_id>\d+)$', 'question_details',
name='questions.details'),
url(r'^/(?P<question_id>\d+)/edit$',
'edit_question', name='questions.edit_question'),
url(r'^/(?P<question_id>\d+)/edit-details$',
'edit_details', name='questions.edit_details'),
url(r'^/(?P<question_id>\d+)/reply$', 'reply', name='questions.reply'),
url(r'^/(?P<question_id>\d+)/delete$', 'delete_question',
name='questions.delete'),
url(r'^/(?P<question_id>\d+)/lock$', 'lock_question',
name='questions.lock'),
url(r'^/(?P<question_id>\d+)/archive$', 'archive_question',
name='questions.archive'),
url(r'^/(?P<question_id>\d+)/delete/(?P<answer_id>\d+)$',
'delete_answer', name='questions.delete_answer'),
url(r'^/(?P<question_id>\d+)/edit/(?P<answer_id>\d+)$', 'edit_answer',
name='questions.edit_answer'),
url(r'^/(?P<question_id>\d+)/solve/(?P<answer_id>\d+)$', 'solve',
name='questions.solve'),
url(r'^/(?P<question_id>\d+)/unsolve/(?P<answer_id>\d+)$', 'unsolve',
name='questions.unsolve'),
url(r'^/(?P<question_id>\d+)/vote$', 'question_vote',
name='questions.vote'),
url(r'^/(?P<question_id>\d+)/vote/(?P<answer_id>\d+)$',
'answer_vote', name='questions.answer_vote'),
url(r'^/(?P<question_id>\d+)/add-tag$', 'add_tag',
name='questions.add_tag'),
url(r'^/(?P<question_id>\d+)/remove-tag$', 'remove_tag',
name='questions.remove_tag'),
url(r'^/(?P<question_id>\d+)/add-tag-async$', 'add_tag_async',
name='questions.add_tag_async'),
url(r'^/(?P<question_id>\d+)/remove-tag-async$', 'remove_tag_async',
name='questions.remove_tag_async'),
# Feeds
# Note: this needs to be above questions.list because "feed"
# matches the product slug regex.
url(r'^/feed$', QuestionsFeed(), name='questions.feed'),
url(r'^/(?P<question_id>\d+)/feed$', AnswersFeed(),
name='questions.answers.feed'),
url(r'^/tagged/(?P<tag_slug>[\w\-]+)/feed$', TaggedQuestionsFeed(),
name='questions.tagged_feed'),
# Mark as spam
url(r'^/mark_spam$', 'mark_spam', name='questions.mark_spam'),
url(r'^/unmark_spam$', 'unmark_spam', name='questions.unmark_spam'),
# Question lists
url(r'^/(?P<product_slug>[\w+\-\,]+)$', 'question_list',
name='questions.list'),
# Flag content ("Report this post")
url(r'^/(?P<object_id>\d+)/flag$', flagit_views.flag,
{'content_type': ContentType.objects.get_for_model(Question).id},
name='questions.flag'),
url(r'^/(?P<question_id>\d+)/flag/(?P<object_id>\d+)$', flagit_views.flag,
{'content_type': ContentType.objects.get_for_model(Answer).id},
name='questions.answer_flag'),
# Subcribe by email
url(r'^/(?P<question_id>\d+)/watch$', 'watch_question',
name='questions.watch'),
url(r'^/(?P<question_id>\d+)/unwatch$', 'unwatch_question',
name='questions.unwatch'),
url(r'^/confirm/(?P<watch_id>\d+)/(?P<secret>\w+)$', 'activate_watch',
name='questions.activate_watch'),
url(r'^/unsubscribe/(?P<watch_id>\d+)/(?P<secret>\w+)$',
'unsubscribe_watch', name='questions.unsubscribe'),
)
| 45.778761 | 78 | 0.626329 | [
"BSD-3-Clause"
] | 983834572/kitsune | kitsune/questions/urls.py | 5,173 | Python |
# -*- coding: utf-8 -*-
# -*- coding: utf8 -*-
"""Autogenerated file - DO NOT EDIT
If you spot a bug, please report it on the mailing list and/or change the generator."""
from nipype.interfaces.base import (
CommandLine,
CommandLineInputSpec,
SEMLikeCommandLine,
TraitedSpec,
File,
Directory,
traits,
isdefined,
InputMultiPath,
OutputMultiPath,
)
import os
class ExtractSkeletonInputSpec(CommandLineInputSpec):
InputImageFileName = File(position=-2, desc="Input image", exists=True, argstr="%s")
OutputImageFileName = traits.Either(
traits.Bool,
File(),
position=-1,
hash_files=False,
desc="Skeleton of the input image",
argstr="%s",
)
type = traits.Enum(
"1D", "2D", desc="Type of skeleton to create", argstr="--type %s"
)
dontPrune = traits.Bool(
desc="Return the full skeleton, not just the maximal skeleton",
argstr="--dontPrune ",
)
numPoints = traits.Int(
desc="Number of points used to represent the skeleton", argstr="--numPoints %d"
)
pointsFile = traits.Str(
desc="Name of the file to store the coordinates of the central (1D) skeleton points",
argstr="--pointsFile %s",
)
class ExtractSkeletonOutputSpec(TraitedSpec):
OutputImageFileName = File(
position=-1, desc="Skeleton of the input image", exists=True
)
class ExtractSkeleton(SEMLikeCommandLine):
"""title: Extract Skeleton
category: Filtering
description: Extract the skeleton of a binary object. The skeleton can be limited to being a 1D curve or allowed to be a full 2D manifold. The branches of the skeleton can be pruned so that only the maximal center skeleton is returned.
version: 0.1.0.$Revision: 2104 $(alpha)
documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ExtractSkeleton
contributor: Pierre Seroul (UNC), Martin Styner (UNC), Guido Gerig (UNC), Stephen Aylward (Kitware)
acknowledgements: The original implementation of this method was provided by ETH Zurich, Image Analysis Laboratory of Profs Olaf Kuebler, Gabor Szekely and Guido Gerig. Martin Styner at UNC, Chapel Hill made enhancements. Wrapping for Slicer was provided by Pierre Seroul and Stephen Aylward at Kitware, Inc.
"""
input_spec = ExtractSkeletonInputSpec
output_spec = ExtractSkeletonOutputSpec
_cmd = "ExtractSkeleton "
_outputs_filenames = {"OutputImageFileName": "OutputImageFileName.nii"}
| 33.986486 | 310 | 0.702584 | [
"Apache-2.0"
] | AnnaD15/nipype | nipype/interfaces/slicer/filtering/extractskeleton.py | 2,515 | Python |
import subprocess
import time
import os
TEST_TYPE = os.getenv("TEST_TYPE", "bdd")
def before_scenario(context, scenario):
if f"{TEST_TYPE}" == "bdd":
proc = subprocess.Popen(["make", "start"])
time.sleep(4)
context.proc = proc
context.root_url = "http://localhost:5000"
else:
context.root_url = os.getenv("ROOT_ENDPOINT")
def after_scenario(context, scenario):
if f"{TEST_TYPE}" == "bdd":
proc = context.proc
proc.terminate()
| 21.73913 | 53 | 0.622 | [
"MIT"
] | abhisheksr01/zero-2-hero-python-flask-microservice | features/environment.py | 500 | Python |
class Solution:
def coinChange(self, coins, amount):
"""
:type coins: List[int]
:type amount: int
:rtype: int
"""
# max value taken as amount+1 because in worst case, it can be amount - when denoms of only 1
res = [amount+1]*(amount+1)
res[0] = 0
for i in range(1, amount+1):
for j in coins:
if j <= i:
res[i] = min(res[i], res[i-j] + 1)
if res[amount] > amount:
return -1
else:
return res[amount]
| 27.238095 | 101 | 0.461538 | [
"MIT"
] | vedantc6/LCode | Session1_2018/coinChange.py | 572 | Python |
import xml.etree.ElementTree as ET
from .exceptions import UnpopulatedPropertyError
from .property_decorators import property_not_nullable, property_is_boolean
from .tag_item import TagItem
from ..datetime_helpers import parse_datetime
import copy
class FlowItem(object):
def __init__(self, project_id, name=None):
self._webpage_url = None
self._created_at = None
self._id = None
self._initial_tags = set()
self._project_name = None
self._updated_at = None
self.name = name
self.owner_id = None
self.project_id = project_id
self.tags = set()
self.description = None
self._connections = None
self._permissions = None
@property
def connections(self):
if self._connections is None:
error = 'Flow item must be populated with connections first.'
raise UnpopulatedPropertyError(error)
return self._connections()
@property
def permissions(self):
if self._permissions is None:
error = "Project item must be populated with permissions first."
raise UnpopulatedPropertyError(error)
return self._permissions()
@property
def webpage_url(self):
return self._webpage_url
@property
def created_at(self):
return self._created_at
@property
def id(self):
return self._id
@property
def project_id(self):
return self._project_id
@project_id.setter
@property_not_nullable
def project_id(self, value):
self._project_id = value
@property
def description(self):
return self._description
@description.setter
def description(self, value):
self._description = value
@property
def project_name(self):
return self._project_name
@property
def flow_type(self):
return self._flow_type
@property
def updated_at(self):
return self._updated_at
def _set_connections(self, connections):
self._connections = connections
def _set_permissions(self, permissions):
self._permissions = permissions
def _parse_common_elements(self, flow_xml, ns):
if not isinstance(flow_xml, ET.Element):
flow_xml = ET.fromstring(flow_xml).find('.//t:flow', namespaces=ns)
if flow_xml is not None:
(_, _, _, _, _, updated_at, _, project_id, project_name, owner_id) = self._parse_element(flow_xml, ns)
self._set_values(None, None, None, None, None, updated_at, None, project_id,
project_name, owner_id)
return self
def _set_values(self, id, name, description, webpage_url, created_at,
updated_at, tags, project_id, project_name, owner_id):
if id is not None:
self._id = id
if name:
self.name = name
if description:
self.description = description
if webpage_url:
self._webpage_url = webpage_url
if created_at:
self._created_at = created_at
if updated_at:
self._updated_at = updated_at
if tags:
self.tags = tags
self._initial_tags = copy.copy(tags)
if project_id:
self.project_id = project_id
if project_name:
self._project_name = project_name
if owner_id:
self.owner_id = owner_id
@classmethod
def from_response(cls, resp, ns):
all_flow_items = list()
parsed_response = ET.fromstring(resp)
all_flow_xml = parsed_response.findall('.//t:flow', namespaces=ns)
for flow_xml in all_flow_xml:
(id_, name, description, webpage_url, created_at, updated_at,
tags, project_id, project_name, owner_id) = cls._parse_element(flow_xml, ns)
flow_item = cls(project_id)
flow_item._set_values(id_, name, description, webpage_url, created_at, updated_at,
tags, None, project_name, owner_id)
all_flow_items.append(flow_item)
return all_flow_items
@staticmethod
def _parse_element(flow_xml, ns):
id_ = flow_xml.get('id', None)
name = flow_xml.get('name', None)
description = flow_xml.get('description', None)
webpage_url = flow_xml.get('webpageUrl', None)
created_at = parse_datetime(flow_xml.get('createdAt', None))
updated_at = parse_datetime(flow_xml.get('updatedAt', None))
tags = None
tags_elem = flow_xml.find('.//t:tags', namespaces=ns)
if tags_elem is not None:
tags = TagItem.from_xml_element(tags_elem, ns)
project_id = None
project_name = None
project_elem = flow_xml.find('.//t:project', namespaces=ns)
if project_elem is not None:
project_id = project_elem.get('id', None)
project_name = project_elem.get('name', None)
owner_id = None
owner_elem = flow_xml.find('.//t:owner', namespaces=ns)
if owner_elem is not None:
owner_id = owner_elem.get('id', None)
return (id_, name, description, webpage_url, created_at, updated_at, tags, project_id,
project_name, owner_id)
| 32.484663 | 114 | 0.628706 | [
"CC0-1.0",
"MIT"
] | BenevolentHighPriestess/server-client-python | tableauserverclient/models/flow_item.py | 5,295 | Python |
from interpolate import interpolate_doc
foo = """
hello
world
"""
bar = "foo bar\nbaz"
class Foo:
# cf matplotlib's kwdoc.
__kw__ = "the kw of foo"
@interpolate_doc
def func():
"""
this is a docstring
{interpolate_example.foo}
{bar}
{Foo!K}
"""
try:
@interpolate_doc
def bad_doc():
"""
fields {must} be preceded by whitespace
"""
except ValueError:
print("error correctly caught")
| 12.756757 | 47 | 0.576271 | [
"MIT"
] | anntzer/structured-docstrings | interpolate_example.py | 472 | Python |
import discord
from discord.ext import commands
# Set slash commands=True when constructing your bot to enable all slash commands
# if your bot is only for a couple of servers, you can use the parameter
# `slash_command_guilds=[list, of, guild, ids]` to specify this,
# then the commands will be much faster to upload.
bot = commands.Bot("!", intents=discord.Intents(guilds=True, messages=True), slash_commands=True)
@bot.event
async def on_ready():
print(f"Logged in as {bot.user} (ID: {bot.user.id})")
print("------")
@bot.command()
# You can use commands.Option to define descriptions for your options, and converters will still work fine.
async def ping(
ctx: commands.Context, emoji: bool = commands.Option(description="whether to use an emoji when responding")
):
# This command can be used with slash commands or message commands
if emoji:
await ctx.send("\U0001f3d3")
else:
await ctx.send("Pong!")
@bot.command(message_command=False)
async def only_slash(ctx: commands.Context):
# This command can only be used with slash commands
await ctx.send("Hello from slash commands!")
@bot.command(slash_command=False)
async def only_message(ctx: commands.Context):
# This command can only be used with a message
await ctx.send("Hello from message commands!")
bot.run("token")
| 31.97619 | 111 | 0.724497 | [
"MIT"
] | Astrea49/enhanced-discord.py | examples/slash_commands.py | 1,343 | Python |
from io import BytesIO
from typing import Tuple, Sequence
import attr
from PIL import Image
from ebl.changelog import Changelog
from ebl.ebl_ai_client import EblAiClient
from ebl.files.application.file_repository import FileRepository
from ebl.fragmentarium.application.annotations_repository import AnnotationsRepository
from ebl.fragmentarium.application.annotations_schema import AnnotationsSchema
from ebl.fragmentarium.application.cropped_sign_image import CroppedSign
from ebl.fragmentarium.application.cropped_sign_images_repository import (
CroppedSignImage,
CroppedSignImagesRepository,
)
from ebl.fragmentarium.application.fragment_repository import FragmentRepository
from ebl.fragmentarium.domain.annotation import (
Annotations,
AnnotationValueType,
)
from ebl.transliteration.domain.line_label import LineLabel
from ebl.transliteration.domain.museum_number import MuseumNumber
from ebl.users.domain.user import User
@attr.attrs(auto_attribs=True, frozen=True)
class AnnotationsService:
_ebl_ai_client: EblAiClient
_annotations_repository: AnnotationsRepository
_photo_repository: FileRepository
_changelog: Changelog
_fragments_repository: FragmentRepository
_photos_repository: FileRepository
_cropped_sign_images_repository: CroppedSignImagesRepository
def generate_annotations(
self, number: MuseumNumber, threshold: float = 0.3
) -> Annotations:
fragment_image = self._photo_repository.query_by_file_name(f"{number}.jpg")
return self._ebl_ai_client.generate_annotations(
number, fragment_image, threshold
)
def find(self, number: MuseumNumber) -> Annotations:
return self._annotations_repository.query_by_museum_number(number)
def _label_by_line_number(
self, line_number_to_match: int, labels: Sequence[LineLabel]
) -> str:
matching_label = None
for label in labels:
label_line_number = label.line_number
if label_line_number and label_line_number.is_matching_number(
line_number_to_match
):
matching_label = label
return matching_label.formatted_label if matching_label else ""
def _cropped_image_from_annotations_helper(
self,
annotations: Annotations,
image: Image.Image,
script: str,
labels: Sequence[LineLabel],
) -> Tuple[Annotations, Sequence[CroppedSignImage]]:
cropped_sign_images = []
updated_cropped_annotations = []
for annotation in annotations.annotations:
label = (
self._label_by_line_number(annotation.data.path[0], labels)
if annotation.data.type != AnnotationValueType.BLANK
else ""
)
cropped_image = annotation.crop_image(image)
cropped_sign_image = CroppedSignImage.create(cropped_image)
cropped_sign_images.append(cropped_sign_image)
updated_cropped_annotation = attr.evolve(
annotation,
cropped_sign=CroppedSign(
cropped_sign_image.image_id,
script,
label,
),
)
updated_cropped_annotations.append(updated_cropped_annotation)
return (
attr.evolve(annotations, annotations=updated_cropped_annotations),
cropped_sign_images,
)
def _cropped_image_from_annotations(
self, annotations: Annotations
) -> Tuple[Annotations, Sequence[CroppedSignImage]]:
fragment = self._fragments_repository.query_by_museum_number(
annotations.fragment_number
)
fragment_image = self._photos_repository.query_by_file_name(
f"{annotations.fragment_number}.jpg"
)
image_bytes = fragment_image.read()
image = Image.open(BytesIO(image_bytes), mode="r")
return self._cropped_image_from_annotations_helper(
annotations, image, fragment.script, fragment.text.labels
)
def update(self, annotations: Annotations, user: User) -> Annotations:
old_annotations = self._annotations_repository.query_by_museum_number(
annotations.fragment_number
)
_id = str(annotations.fragment_number)
schema = AnnotationsSchema()
(
annotations_with_image_ids,
cropped_sign_images,
) = self._cropped_image_from_annotations(annotations)
self._annotations_repository.create_or_update(annotations_with_image_ids)
self._cropped_sign_images_repository.create_many(cropped_sign_images)
self._changelog.create(
"annotations",
user.profile,
{"_id": _id, **schema.dump(old_annotations)},
{"_id": _id, **schema.dump(annotations_with_image_ids)},
)
return annotations_with_image_ids
| 37.755725 | 86 | 0.697736 | [
"MIT"
] | ElectronicBabylonianLiterature/dictionary | ebl/fragmentarium/application/annotations_service.py | 4,946 | Python |
def number_of_occurrences(s, xs):
return xs.count(s) | 28 | 33 | 0.732143 | [
"MIT"
] | anubhab-code/Competitive-Programming | CodeWars/7 Kyu/Number Of Occurrences.py | 56 | Python |
#Python program to get the size of an object in bytes
import sys
Object = input("Enter any object: ")
print(f'The size of the object {Object} is {sys.getsizeof(Object)} bytes')
| 29.666667 | 74 | 0.735955 | [
"MIT"
] | CodedLadiesInnovateTech/-python-challenge-solutions | GodwillOnyewuchi/Phase 1/Python Basic 2/day 9 task/task 9.py | 178 | Python |
from .chain import *
from .element import *
| 14.666667 | 22 | 0.727273 | [
"MIT"
] | ArcletProject/Edoves | arclet/edoves/main/message/__init__.py | 44 | Python |
from importlib import import_module, reload
import pytest
import sys
from unittest.mock import patch
from rest_framework import status
from django.contrib.auth.models import Permission, Group
from django.conf import settings
from django.urls import clear_url_caches
from django.urls import reverse
from .factories import UserFactory
from groups.models import GroupInfo
from users.models import UserProfile
BLANK_CHOICE = ('', '---------')
USER_DETAILS = {
'username': 'test',
'email': '[email protected]',
'first_name': 'Foo',
'last_name': 'Bar',
}
USER_DETAILS_CREATE = USER_DETAILS.copy()
USER_DETAILS_CREATE.update(password1='pass', password2='pass')
USER_DETAILS_CHANGING = {
'username': 'johnsmith',
'email': '[email protected]',
'first_name': 'John',
'last_name': 'Smith',
}
@pytest.mark.django_db
def test_create_user_view_get(admin_client):
url = reverse('wagtailusers_users:add')
response = admin_client.get(url)
assert response.status_code == status.HTTP_200_OK
@pytest.mark.django_db
def test_create_user_view(admin_client):
url = reverse('wagtailusers_users:add')
response = admin_client.post(url, data=USER_DETAILS_CREATE)
assert response.context['message'] == 'User test created.'
assert response.status_code == status.HTTP_302_FOUND
assert response.url == reverse('wagtailusers_users:index')
@pytest.mark.django_db
def test_create_user_view_invalid_form(admin_client):
url = reverse('wagtailusers_users:add')
post_data = USER_DETAILS.copy()
post_data.update(email='This is not an email address')
response = admin_client.post(url, post_data)
message = response.context['message']
assert message == 'The user could not be created due to errors.'
assert response.status_code == status.HTTP_200_OK
@pytest.mark.django_db
def test_get_edit_user_view(admin_client):
user = UserFactory(**USER_DETAILS)
url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk})
response = admin_client.get(url)
assert response.status_code == status.HTTP_200_OK
assert response.context['can_delete'] is True
@pytest.mark.django_db
def test_edit_user_view(team_leaders_group, admin_client):
user = UserFactory(**USER_DETAILS)
url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk})
# We'll add the user to a group, as well as changing their details
post_data = USER_DETAILS_CHANGING.copy()
post_data['groups'] = [team_leaders_group.pk]
response = admin_client.post(url, data=post_data)
assert response.context['message'] == 'User johnsmith updated.'
assert response.status_code == status.HTTP_302_FOUND
assert response.url == reverse('wagtailusers_users:index')
# The user's details should have changed to reflect the posted values
user.refresh_from_db()
for field_name, changed_value in USER_DETAILS_CHANGING.items():
assert getattr(user, field_name) == changed_value
# And they should have been added to a group
group_ids = set(user.groups.values_list('id', flat=True))
assert group_ids == {team_leaders_group.pk}
@pytest.mark.django_db
def test_edit_user_view_invalid_form(admin_client, approved_user):
url = reverse('wagtailusers_users:edit', kwargs={'pk': approved_user.pk})
post_data = USER_DETAILS.copy()
post_data.update(email='This is not an email address')
response = admin_client.post(url, post_data)
message = response.context['message']
assert message == 'The user could not be saved due to errors.'
assert response.status_code == status.HTTP_200_OK
@pytest.mark.django_db
def test_edit_user_view_cannot_change_personal_details_when_sso_enforced(
admin_client
):
# Set this flag to True and repeat previous test
settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = True
user = UserFactory(**USER_DETAILS)
# Post changes to the view
url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk})
admin_client.post(url, data=USER_DETAILS_CHANGING)
# The users details should remain unchanged, because the
# personal detail fields should all be disabled
user.refresh_from_db()
for field_name, original_value in USER_DETAILS.items():
assert getattr(user, field_name) == original_value
# Change this back to avoid cross-test pollution
settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = False
reload_urlconf()
@pytest.mark.django_db
def test_edit_user_view_preserves_ability_to_update_is_active(admin_client):
# Set this flag to True and actions if previous test
settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = True
# Create an 'inactive' user to test with
user = UserFactory(**USER_DETAILS)
user.is_active = False
user.save()
# Post using the same details + 'is_active=on'
post_data = USER_DETAILS.copy()
post_data.update(is_active='on')
url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk})
admin_client.post(url, data=post_data)
# The change to 'is_active' should have been applied, because that field
# is not disabled along with the personal detail ones
user.refresh_from_db()
assert user.is_active is True
# Reset flag to avoid cross-test pollution
settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = False
reload_urlconf()
@pytest.mark.django_db
def test_edit_user_view_warns_administrator_if_user_is_awaiting_approval(
admin_client, user_awaiting_approval
):
# This flag must be set for the warning to show
settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = True
user = user_awaiting_approval
url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk})
response = admin_client.get(url)
message = response.context['message']
assert "This user is awaiting approval" in message
assert "requested to be added to the 'Moderators' group" in message
# Reset flag to avoid cross-test pollution
settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = False
reload_urlconf()
@pytest.mark.django_db
def test_edit_user_view_marks_user_as_approved_if_added_to_group(
admin_client, admin_user, user_awaiting_approval
):
# This flag must be set for the warning to show
settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = True
user = user_awaiting_approval
profile = user_awaiting_approval.userprofile
url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk})
group = Group.objects.get(pk=profile.self_assigned_group_id)
group.permissions.add(Permission.objects.get(codename='access_admin'))
with patch('users.views.notify_user_of_access_request_approval', autospec=True) as mocked_method:
response = admin_client.post(url, {
'username': user.username,
'first_name': user.first_name,
'last_name': user.last_name,
'email': user.email,
'is_active': True,
'groups': [group.pk],
})
# Ensure the post was successful
assert response.context['message'] == 'User %s updated.' % user.username
assert response.status_code == status.HTTP_302_FOUND
assert response.url == reverse('wagtailusers_users:index')
# The UserProfile should have been updated
profile.refresh_from_db()
assert profile.assignment_status == UserProfile.STATUS_APPROVED
assert profile.approved_by_id == admin_user.id
assert profile.approved_at is not None
# A notification should have been triggered for the user
expected_call_args = dict(
request=response.wsgi_request,
user_email=user.email,
user_name=user.first_name,
reviewer_name=admin_user.get_full_name(),
)
mocked_method.assert_called_with(**expected_call_args)
# Reset flag to avoid cross-test pollution
settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = False
reload_urlconf()
@pytest.mark.django_db
def test_edit_user_view_does_not_mark_user_as_approved_if_not_added_to_a_group(admin_client, groups_with_info):
user = UserFactory(username='some-user')
profile = user.userprofile
profile.assignment_status = UserProfile.STATUS_AWAITING_APPROVAL
profile.self_assigned_group_id = groups_with_info[0].id
profile.save()
url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk})
with patch(
'users.views.notify_user_of_access_request_approval'
) as mocked_method:
response = admin_client.post(url, {
'username': user.username,
'first_name': user.first_name,
'last_name': user.last_name,
'email': user.email,
'is_active': True,
})
# Ensure the post was successful
assert response.context['message'] == 'User %s updated.' % user.username
assert response.status_code == status.HTTP_302_FOUND
assert response.url == reverse('wagtailusers_users:index')
# The UserProfile should NOT have been updated
profile.refresh_from_db()
assert profile.assignment_status == UserProfile.STATUS_AWAITING_APPROVAL
assert profile.approved_by_id is None
assert profile.approved_at is None
# no notification should have been triggered
mocked_method.assert_not_called()
def reload_urlconf(urlconf=None):
clear_url_caches()
if urlconf is None:
urlconf = settings.ROOT_URLCONF
if urlconf in sys.modules:
reload(sys.modules[urlconf])
else:
import_module(urlconf)
@pytest.mark.django_db
def test_force_staff_sso(client):
"""Test that URLs and redirects are in place."""
settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = True
settings.AUTHBROKER_CLIENT_ID = 'debug'
settings.AUTHBROKER_CLIENT_SECRET = 'debug'
settings.AUTHBROKER_URL = 'https://test.com'
reload_urlconf()
assert reverse('authbroker_client:login') == '/auth/login/'
assert reverse('authbroker_client:callback') == '/auth/callback/'
response = client.get('/admin/login/')
assert response.status_code == 302
assert response.url == '/auth/login/'
settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = False
reload_urlconf()
@pytest.mark.parametrize('assignment_status, expected_status_code', (
(UserProfile.STATUS_CREATED, 200),
(UserProfile.STATUS_AWAITING_APPROVAL, 302),
(UserProfile.STATUS_APPROVED, 302)
))
@pytest.mark.django_db
def test_ssorequestaccessview_responds_based_on_assignment_status(
admin_client, admin_user, assignment_status, expected_status_code
):
url = reverse('sso:request_access')
profile = admin_user.userprofile
profile.assignment_status = assignment_status
profile.save()
response = admin_client.get(url)
assert response.status_code == expected_status_code
@pytest.mark.django_db
def test_ssorequestaccessview_shows_unlimited_visibilty_groups_only(
admin_client, groups_with_info
):
url = reverse('sso:request_access')
# Visbility is set to 'unrestricted' for all groups in `groups_with_info`,
# so choices should reflect that by default
expected_choices = tuple(
(g.id, g.info.name_singular) for g in groups_with_info
)
# Confirm the choices in the form are as expected
response = admin_client.get(url)
group_field = response.context['form']['self_assigned_group'].field
actual_choices = tuple(group_field.choices)
assert actual_choices == expected_choices
# Change the visibility of groups and try again
GroupInfo.objects.all().update(
visibility=GroupInfo.VISIBILITY_MANAGERS_ONLY)
# Choices should be empty now
response = admin_client.get(url)
group_field = response.context['form']['self_assigned_group'].field
assert tuple(group_field.choices) == ()
@pytest.mark.django_db
def test_ssorequestaccessview_with_no_team_leaders_group(admin_client):
# If no 'team leaders group' has been designated, the 'team_leaders'
# field should only have a 'blank' option
url = reverse('sso:request_access')
response = admin_client.get(url)
team_leader_field = response.context['form']['team_leader'].field
assert tuple(team_leader_field.choices) == (BLANK_CHOICE,)
@pytest.mark.django_db
def test_ssorequestaccessview_with_team_leaders_group_but_no_members(
admin_client, team_leaders_group
):
# If the designated 'team leaders group' has no members, the 'team_leaders'
# field should only have a 'blank' option
url = reverse('sso:request_access')
response = admin_client.get(url)
team_leader_field = response.context['form']['team_leader'].field
assert team_leaders_group.user_set.all().exists() is False
assert tuple(team_leader_field.choices) == (BLANK_CHOICE,)
@pytest.mark.django_db
def test_ssorequestaccessview_with_team_leaders(
admin_client, team_leaders_group, team_leaders
):
url = reverse('sso:request_access')
# When team leaders are defined, they will appear as choices
# for the 'team_leaders' field
expected_choices = [BLANK_CHOICE]
expected_choices.extend(list(
(tl.id, "{} <{}>".format(tl.get_full_name(), tl.email))
for tl in team_leaders
))
# Confirm the choices in the form are as expected
response = admin_client.get(url)
team_leader_field = response.context['form']['team_leader'].field
actual_choices = list(team_leader_field.choices)
assert actual_choices == expected_choices
@pytest.mark.django_db
def test_ssorequestaccessview_fails_validation_if_form_incomplete(
admin_client, groups_with_info, team_leaders
):
url = reverse('sso:request_access')
response = admin_client.post(url, data={})
# Should still be on the same view
assert response.status_code == 200
# Both form fields should have errors
assert 'self_assigned_group' in response.context['form'].errors
assert 'team_leader' in response.context['form'].errors
@pytest.mark.django_db
def test_ssorequestaccessview_post_with_complete_data(
admin_client, admin_user, groups_with_info, team_leaders
):
group = groups_with_info[0]
team_leader = team_leaders[0]
with patch(
'users.views.notify_team_leader_of_pending_access_request',
autospec=True
) as mocked_method:
response = admin_client.post(
reverse('sso:request_access'),
data={
'self_assigned_group': group.id,
'team_leader': team_leader.id,
}
)
# Should be redirected to the success url
success_url = reverse('sso:request_access_success')
assert response.url == success_url
# The UserProfile for `admin_user` should have been updated
profile = admin_user.userprofile
assert profile.self_assigned_group_id == group.id
assert profile.team_leader_id == team_leader.id
assert profile.assignment_status == UserProfile.STATUS_AWAITING_APPROVAL # noqa
# A notification should have been triggered for the user
expected_call_args = dict(
request=response.wsgi_request,
team_leader_email=team_leader.email,
team_leader_name=team_leader.first_name,
user_id=admin_user.id,
user_name=admin_user.get_full_name(),
user_email=admin_user.email,
user_role=group.info.name_singular,
)
mocked_method.assert_called_with(**expected_call_args)
@pytest.mark.django_db
@pytest.mark.parametrize('url', (
reverse('sso:request_access'),
reverse('sso:request_access_success'),
))
def test_ssorequestaccess_views_only_available_to_authenticated_users(
client, admin_client, url
):
# When not authenticated, the user is redirected to the login page
response = client.get(url)
assert response.status_code == 302
assert response.url.startswith(settings.LOGIN_URL)
# When authenticated, things work fine
response = admin_client.get(url)
assert response.status_code == 200
| 34.45 | 111 | 0.730927 | [
"MIT"
] | uktrade/directory-cms | tests/users/test_views.py | 15,847 | Python |
# -*- coding: utf-8 -*-
# !/usr/bin/env python
"""
-------------------------------------------------
File Name： DbClient.py
Description : DB工厂类
Author : JHao
date： 2016/12/2
-------------------------------------------------
Change Activity:
2016/12/02: DB工厂类
2020/07/03: 取消raw_proxy储存
-------------------------------------------------
"""
__author__ = 'JHao'
import os
import sys
from util.six import urlparse, withMetaclass
from util.singleton import Singleton
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
class DbClient(withMetaclass(Singleton)):
"""
DbClient DB工厂类 提供get/put/update/pop/delete/exists/getAll/clean/getCount/changeTable方法
抽象方法定义：
get(): 随机返回一个proxy;
put(proxy): 存入一个proxy;
pop(): 顺序返回并删除一个proxy;
update(proxy): 更新指定proxy信息;
delete(proxy): 删除指定proxy;
exists(proxy): 判断指定proxy是否存在;
getAll(): 返回所有代理;
clean(): 清除所有proxy信息;
getCount(): 返回proxy统计信息;
changeTable(name): 切换操作对象
所有方法需要相应类去具体实现：
ssdb: ssdbClient.py
redis: redisClient.py
mongodb: mongodbClient.py
"""
def __init__(self, db_conn):
"""
init
:return:
"""
self.parseDbConn(db_conn)
self.__initDbClient()
@classmethod
def parseDbConn(cls, db_conn):
db_conf = urlparse(db_conn)
cls.db_type = db_conf.scheme.upper().strip()
cls.db_host = db_conf.hostname
cls.db_port = db_conf.port
cls.db_user = db_conf.username
cls.db_pwd = db_conf.password
cls.db_name = db_conf.path[1:]
return cls
def __initDbClient(self):
"""
init DB Client
:return:
"""
__type = None
if "SSDB" == self.db_type:
__type = "ssdbClient"
elif "REDIS" == self.db_type:
__type = "redisClient"
elif "POSTGRESQL" == self.db_type:
__type = "postgresqlClient"
else:
pass
assert __type, 'type error, Not support DB type: {}'.format(self.db_type)
self.client = getattr(__import__(__type), "%sClient" % self.db_type.title())(host=self.db_host,
port=self.db_port,
username=self.db_user,
password=self.db_pwd,
db=self.db_name)
def get(self, **kwargs):
return self.client.get(**kwargs)
def put(self, key, **kwargs):
return self.client.put(key, **kwargs)
def update(self, key, value, **kwargs):
return self.client.update(key, value, **kwargs)
def delete(self, key, **kwargs):
return self.client.delete(key, **kwargs)
def exists(self, key, **kwargs):
return self.client.exists(key, **kwargs)
def pop(self, **kwargs):
return self.client.pop(**kwargs)
def getAll(self):
return self.client.getAll()
def clear(self):
return self.client.clear()
def changeTable(self, name):
self.client.changeTable(name)
def getCount(self):
return self.client.getCount()
def test(self):
return self.client.test()
| 28.487805 | 107 | 0.50742 | [
"MIT"
] | dota2heqiuzhi/proxy_pool | db/dbClient.py | 3,708 | Python |
# coding: utf-8
"""
Kubernetes
No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
OpenAPI spec version: v1.13.1
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
from __future__ import absolute_import
import os
import sys
import unittest
import kubernetes.client
from kubernetes.client.rest import ApiException
from kubernetes.client.models.v1alpha1_priority_class import V1alpha1PriorityClass
class TestV1alpha1PriorityClass(unittest.TestCase):
""" V1alpha1PriorityClass unit test stubs """
def setUp(self):
pass
def tearDown(self):
pass
def testV1alpha1PriorityClass(self):
"""
Test V1alpha1PriorityClass
"""
# FIXME: construct object with mandatory attributes with example values
#model = kubernetes.client.models.v1alpha1_priority_class.V1alpha1PriorityClass()
pass
if __name__ == '__main__':
unittest.main()
| 22.266667 | 105 | 0.720559 | [
"Apache-2.0"
] | MiaoRachelYu/python | kubernetes/test/test_v1alpha1_priority_class.py | 1,002 | Python |
"""Forms related to import operations."""
from __future__ import unicode_literals
from django import forms
from django.utils.translation import ugettext_lazy
class ImportDataForm(forms.Form):
"""Base form to import objects."""
sourcefile = forms.FileField(label=ugettext_lazy("Select a file"))
sepchar = forms.CharField(
label=ugettext_lazy("Separator"),
max_length=1,
required=False,
widget=forms.TextInput(attrs={"class": "form-control"})
)
continue_if_exists = forms.BooleanField(
label=ugettext_lazy("Continue on error"), required=False,
help_text=ugettext_lazy("Don't treat duplicated objects as error")
)
def __init__(self, *args, **kwargs):
super(ImportDataForm, self).__init__(*args, **kwargs)
self.fields["sepchar"].widget.attrs = {"class": "col-md-1 form-control"}
def clean_sepchar(self):
if self.cleaned_data["sepchar"] == "":
return ";"
return self.cleaned_data["sepchar"]
class ImportIdentitiesForm(ImportDataForm):
"""A form to import identities."""
crypt_password = forms.BooleanField(
label=ugettext_lazy("Crypt passwords"), required=False,
help_text=ugettext_lazy(
"Check this option if passwords contained in your file "
"are not crypted"
)
)
| 29.521739 | 80 | 0.662003 | [
"ISC"
] | antoniotrento/modoboa | modoboa/admin/forms/import_.py | 1,358 | Python |
from fork.util.ints import uint64
from .constants import ConsensusConstants
testnet_kwargs = {
"SLOT_BLOCKS_TARGET": 32,
"MIN_BLOCKS_PER_CHALLENGE_BLOCK": 16, # Must be less than half of SLOT_BLOCKS_TARGET
"MAX_SUB_SLOT_BLOCKS": 128, # Must be less than half of SUB_EPOCH_BLOCKS
"NUM_SPS_SUB_SLOT": 64, # Must be a power of 2
"SUB_SLOT_ITERS_STARTING": 2 ** 27,
# DIFFICULTY_STARTING is the starting difficulty for the first epoch, which is then further
# multiplied by another factor of DIFFICULTY_CONSTANT_FACTOR, to be used in the VDF iter calculation formula.
"DIFFICULTY_CONSTANT_FACTOR": 2 ** 64,
"DIFFICULTY_STARTING": 13,
"DIFFICULTY_CHANGE_MAX_FACTOR": 3, # The next difficulty is truncated to range [prev / FACTOR, prev * FACTOR]
# These 3 constants must be changed at the same time
"SUB_EPOCH_BLOCKS": 384, # The number of blocks per sub-epoch, mainnet 384
"EPOCH_BLOCKS": 4608, # The number of blocks per epoch, mainnet 4608. Must be multiple of SUB_EPOCH_SB
"SIGNIFICANT_BITS": 8, # The number of bits to look at in difficulty and min iters. The rest are zeroed
"DISCRIMINANT_SIZE_BITS": 1024, # Max is 1024 (based on ClassGroupElement int size)
"NUMBER_ZERO_BITS_PLOT_FILTER": 9, # H(plot signature of the challenge) must start with these many zeroes
"MIN_PLOT_SIZE": 32, # 32 for mainnet
"MAX_PLOT_SIZE": 50,
"SUB_SLOT_TIME_TARGET": 600, # The target number of seconds per slot, mainnet 600
"NUM_SP_INTERVALS_EXTRA": 3, # The number of sp intervals to add to the signage point
"MAX_FUTURE_TIME": 5 * 60, # The next block can have a timestamp of at most these many seconds in the future
"NUMBER_OF_TIMESTAMPS": 11, # Than the average of the last NUMBER_OF_TIMESTAMPS blocks
# Used as the initial cc rc challenges, as well as first block back pointers, and first SES back pointer
# We override this value based on the chain being run (testnet0, testnet1, mainnet, etc)
# Default used for tests is std_hash(b'')
"GENESIS_CHALLENGE": bytes.fromhex("be6bbdf83a789fd2b7e5ac8e2954f510e92115bb9e1c84591f6adb4055a3b845"),
# Forks of fork should change this value to provide replay attack protection. This is set to mainnet genesis chall
"AGG_SIG_ME_ADDITIONAL_DATA": bytes.fromhex("3800a9169891c0554775b12cbf5d79f6eb50ccb5f95630536a4cecd7a18aa34b"),
"GENESIS_PRE_FARM_POOL_PUZZLE_HASH": bytes.fromhex(
"75e5849b1a27d71e74de1390a4fc81c38b4ed8ce24d4efb2c9a5807d0e82106c"
),
"GENESIS_PRE_FARM_FARMER_PUZZLE_HASH": bytes.fromhex(
"75e5849b1a27d71e74de1390a4fc81c38b4ed8ce24d4efb2c9a5807d0e82106c"
),
"MAX_VDF_WITNESS_SIZE": 64,
# Size of mempool = 50x the size of block
"MEMPOOL_BLOCK_BUFFER": 50,
# Max coin amount, fits into 64 bits
"MAX_COIN_AMOUNT": uint64((1 << 64) - 1),
# Max block cost in clvm cost units
"MAX_BLOCK_COST_CLVM": 11000000000,
# The cost per byte of generator program
"COST_PER_BYTE": 12000,
"WEIGHT_PROOF_THRESHOLD": 2,
"BLOCKS_CACHE_SIZE": 4608 + (128 * 4),
"WEIGHT_PROOF_RECENT_BLOCKS": 1000,
"MAX_BLOCK_COUNT_PER_REQUESTS": 32, # Allow up to 32 blocks per request
"INITIAL_FREEZE_END_TIMESTAMP": 1620061200, # Mon May 03 2021 17:00:00 GMT+0000
"NETWORK_TYPE": 0,
"MAX_GENERATOR_SIZE": 1000000,
"MAX_GENERATOR_REF_LIST_SIZE": 512, # Number of references allowed in the block generator ref list
"POOL_SUB_SLOT_ITERS": 37600000000, # iters limit * NUM_SPS
}
DEFAULT_CONSTANTS = ConsensusConstants(**testnet_kwargs) # type: ignore
| 57.967742 | 118 | 0.741514 | [
"Apache-2.0"
] | Fork-Network/fork-blockchain | fork/consensus/default_constants.py | 3,594 | Python |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
import os
import os.path
import sys
import io
import logging
import datetime
from pprint import pprint
import yaml
import tzlocal
class ConfigFileNotFound(Exception):
pass
def _set_default_config():
config = {
"url": "",
"title": "",
"keywords": "",
"description": "",
"author": "",
"root": "/",
"source": "content",
"destination": "output",
"attach": "attach",
"themes_dir": "themes",
"theme": "simple2",
"default_ext": "md",
"pygments": True,
"debug": False,
"time": datetime.datetime.now(tzlocal.get_localzone()),
}
return config
def _post_process(config):
for k, v in config.items():
if v is None:
config[k] = ""
if config["url"].endswith("/"):
config["url"] = config["url"][:-1]
return config
def get_default_config():
return _post_process(_set_default_config())
def parse_config(config_file):
if not os.path.exists(config_file):
raise ConfigFileNotFound("{0} not exists".format(config_file))
default_config = _set_default_config()
with io.open(config_file, "rt", encoding="utf-8") as fd:
config = yaml.load(fd, Loader=yaml.FullLoader)
default_config.update(config)
config = _post_process(default_config)
return config
if __name__ == "__main__":
# pylint: disable=pointless-string-statement
"""
Usage:
python -m simiki.config : to test config template
python -m simiki.config _config.yml : to test _config.yml file in \
curren dir
"""
if len(sys.argv) == 1:
base_dir = os.path.dirname(__file__)
_config_file = os.path.join(base_dir, "conf_templates",
"_config.yml.in")
elif len(sys.argv) == 2:
base_dir = os.getcwd()
_config_file = os.path.join(base_dir, sys.argv[1])
else:
logging.error("Use the template config file by default, "
"you can specify the config file to parse. \n"
"Usage: `python -m simiki.config [_config.yml]'")
sys.exit(1)
pprint(parse_config(_config_file))
| 24.989362 | 75 | 0.585355 | [
"MIT"
] | 418sec/simiki | simiki/config.py | 2,349 | Python |
# Copyright 2018 The TensorFlow Probability Authors.
#
# 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.
# ============================================================================
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
# Dependency imports
import numpy as np
from scipy import stats
import tensorflow.compat.v2 as tf
import tensorflow_probability as tfp
from tensorflow_probability.python.internal import test_util
tfd = tfp.distributions
@test_util.test_all_tf_execution_regimes
class ZipfTest(test_util.TestCase):
def assertBetween(self, x, minimum, maximum):
self.assertGreaterEqual(x, minimum)
self.assertLessEqual(x, maximum)
def assertAllBetween(self, a, minval, maxval, atol=1e-6):
a = self._GetNdArray(a)
minval = self._GetNdArray(minval)
maxval = self._GetNdArray(maxval)
self.assertEqual(a.shape, minval.shape)
self.assertEqual(a.shape, maxval.shape)
for idx, _ in np.ndenumerate(a):
self.assertBetween(a[idx], minval[idx] - atol, maxval[idx] + atol)
def testZipfShape(self):
power = tf.constant([3.0] * 5)
zipf = tfd.Zipf(power=power, validate_args=True)
self.assertEqual(self.evaluate(zipf.batch_shape_tensor()), (5,))
self.assertEqual(zipf.batch_shape, tf.TensorShape([5]))
self.assertAllEqual(self.evaluate(zipf.event_shape_tensor()), [])
self.assertEqual(zipf.event_shape, tf.TensorShape([]))
def testInvalidPower(self):
invalid_powers = [-.02, 0.5, -2., .99, 1.]
for power in invalid_powers:
with self.assertRaisesOpError("Condition x > y"):
zipf = tfd.Zipf(power=power, validate_args=True)
self.evaluate(zipf.mean())
def testNanPower(self):
zipf = tfd.Zipf(power=np.nan, validate_args=False)
self.assertAllNan(self.evaluate(zipf.power))
def testValidPower_ImplicitlyConvertsToFloat32(self):
powers = [2, 10, 1.1]
for power in powers:
zipf = tfd.Zipf(power=power, validate_args=True)
self.assertEqual(zipf.power.dtype, tf.float32)
def testEventDtype(self):
for power_dtype in [tf.float32, tf.float64]:
for event_dtype in [tf.int32, tf.int64, tf.float32, tf.float64]:
power_dtype = tf.float32
event_dtype = tf.int32
power = tf.constant(5., dtype=power_dtype)
zipf = tfd.Zipf(power=power, dtype=event_dtype, validate_args=True)
self.assertEqual(zipf.dtype, event_dtype)
self.assertEqual(
zipf.dtype, zipf.sample(10, seed=test_util.test_seed()).dtype)
self.assertEqual(
zipf.dtype, zipf.sample(1, seed=test_util.test_seed()).dtype)
self.assertEqual(zipf.dtype, zipf.mode().dtype)
def testInvalidEventDtype(self):
with self.assertRaisesWithPredicateMatch(
TypeError, "power.dtype .* not a supported .* type"):
power = tf.constant(5., dtype=tf.float16)
zipf = tfd.Zipf(power=power, dtype=tf.int32, validate_args=True)
self.evaluate(zipf.sample(seed=test_util.test_seed()))
def testZipfLogPmf_InvalidArgs(self):
power = tf.constant([4.0])
# Non-integer samples are rejected if validate_args is True and
# interpolate_nondiscrete is False.
zipf = tfd.Zipf(
power=power, interpolate_nondiscrete=False, validate_args=True)
non_integer_samples = [0.99, 4.5, 5.001, 1e-5]
for x in non_integer_samples:
with self.assertRaisesOpError("cannot contain fractional components"):
self.evaluate(zipf.log_prob(x))
with self.assertRaisesOpError("cannot contain fractional components"):
self.evaluate(zipf.prob(x))
# Negative samples are rejected if validate_args is True.
zipf = tfd.Zipf(power=power, validate_args=True)
negative_samples = [-3, -2, -1]
for x in negative_samples:
with self.assertRaisesOpError("must be non-negative"):
self.evaluate(zipf.log_prob(x))
with self.assertRaisesOpError("must be non-negative"):
self.evaluate(zipf.prob(x))
def testZipfLogPmf_IntegerArgs(self):
batch_size = 9
power = tf.constant([3.0] * batch_size)
power_v = 3.0
x = np.array([-3., -0., 0., 2., 3., 4., 5., 6., 7.], dtype=np.float32)
zipf = tfd.Zipf(power=power, validate_args=False)
log_pmf = zipf.log_prob(x)
self.assertEqual((batch_size,), log_pmf.shape)
self.assertAllClose(self.evaluate(log_pmf), stats.zipf.logpmf(x, power_v))
pmf = zipf.prob(x)
self.assertEqual((batch_size,), pmf.shape)
self.assertAllClose(self.evaluate(pmf), stats.zipf.pmf(x, power_v))
def testZipfLogPmf_NonIntegerArgs(self):
batch_size = 12
power = tf.constant([3.0] * batch_size)
power_v = 3.0
x = [-3., -0.5, 0., 2., 2.2, 3., 3.1, 4., 5., 5.5, 6., 7.2]
zipf = tfd.Zipf(power=power, validate_args=False)
log_pmf = zipf.log_prob(x)
self.assertEqual((batch_size,), log_pmf.shape)
# Check that log_pmf(x) of tfd.Zipf is between the values of
# stats.zipf.logpmf for ceil(x) and floor(x).
log_pmf_values = self.evaluate(log_pmf)
floor_x = np.floor(x)
ceil_x = np.ceil(x)
self.assertAllBetween(log_pmf_values, stats.zipf.logpmf(ceil_x, power_v),
stats.zipf.logpmf(floor_x, power_v))
# Check that pmf(x) of tfd.Zipf is between the values of stats.zipf.pmf for
# ceil(x) and floor(x).
pmf = zipf.prob(x)
self.assertEqual((batch_size,), pmf.shape)
pmf_values = self.evaluate(pmf)
self.assertAllBetween(pmf_values, stats.zipf.pmf(ceil_x, power_v),
stats.zipf.pmf(floor_x, power_v))
def testZipfLogPmf_NonIntegerArgsNoInterpolation(self):
batch_size = 12
power = tf.constant([3.0] * batch_size)
power_v = 3.0
x = [-3., -0.5, 0., 2., 2.2, 3., 3.1, 4., 5., 5.5, 6., 7.2]
zipf = tfd.Zipf(
power=power, interpolate_nondiscrete=False, validate_args=False)
log_pmf = zipf.log_prob(x)
self.assertEqual((batch_size,), log_pmf.shape)
log_pmf_values = self.evaluate(log_pmf)
self.assertAllClose(log_pmf_values, stats.zipf.logpmf(x, power_v))
pmf = zipf.prob(x)
self.assertEqual((batch_size,), pmf.shape)
pmf_values = self.evaluate(pmf)
self.assertAllClose(pmf_values, stats.zipf.pmf(x, power_v))
def testZipfLogPmfMultidimensional_IntegerArgs(self):
batch_size = 6
power = tf.constant([[2.0, 4.0, 5.0]] * batch_size)
power_v = [2.0, 4.0, 5.0]
x = np.array([[2.1, 3.5, 4.9, 5., 6.6, 7.]], dtype=np.int32).T
zipf = tfd.Zipf(power=power, validate_args=True)
log_pmf = zipf.log_prob(x)
self.assertEqual((6, 3), log_pmf.shape)
self.assertAllClose(self.evaluate(log_pmf), stats.zipf.logpmf(x, power_v))
pmf = zipf.prob(x)
self.assertEqual((6, 3), pmf.shape)
self.assertAllClose(self.evaluate(pmf), stats.zipf.pmf(x, power_v))
def testZipfLogPmfMultidimensional_NonIntegerArgs(self):
batch_size = 6
power = tf.constant([[2.0, 4.0, 5.0]] * batch_size)
power_v = [2.0, 4.0, 5.0]
x = np.array([[2., 3.2, 4.3, 5.5, 6.9, 7.]], dtype=np.float32).T
floor_x = np.floor(x)
ceil_x = np.ceil(x)
zipf = tfd.Zipf(power=power, validate_args=True)
log_pmf = zipf.log_prob(x)
self.assertEqual((6, 3), log_pmf.shape)
self.assertAllBetween(
self.evaluate(log_pmf), stats.zipf.logpmf(ceil_x, power_v),
stats.zipf.logpmf(floor_x, power_v))
pmf = zipf.prob(x)
self.assertEqual((6, 3), pmf.shape)
self.assertAllBetween(
self.evaluate(pmf), stats.zipf.pmf(ceil_x, power_v),
stats.zipf.pmf(floor_x, power_v))
def testZipfCdf_IntegerArgs(self):
batch_size = 12
power = tf.constant([3.0] * batch_size)
power_v = 3.0
x = [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]
zipf = tfd.Zipf(power=power, validate_args=False)
log_cdf = zipf.log_cdf(x)
self.assertEqual((batch_size,), log_cdf.shape)
self.assertAllClose(self.evaluate(log_cdf), stats.zipf.logcdf(x, power_v))
cdf = zipf.cdf(x)
self.assertEqual((batch_size,), cdf.shape)
self.assertAllClose(self.evaluate(cdf), stats.zipf.cdf(x, power_v))
def testZipfCdf_NonIntegerArgsNoInterpolation(self):
batch_size = 12
power = tf.constant([3.0] * batch_size)
power_v = 3.0
x = [-3.5, -0.5, 0., 1, 1.1, 2.2, 3.1, 4., 5., 5.5, 6.4, 7.8]
zipf = tfd.Zipf(
power=power, interpolate_nondiscrete=False, validate_args=False)
log_cdf = zipf.log_cdf(x)
self.assertEqual((batch_size,), log_cdf.shape)
self.assertAllClose(self.evaluate(log_cdf), stats.zipf.logcdf(x, power_v))
cdf = zipf.cdf(x)
self.assertEqual((batch_size,), cdf.shape)
self.assertAllClose(self.evaluate(cdf), stats.zipf.cdf(x, power_v))
def testZipfCdf_NonIntegerArgsInterpolated(self):
batch_size = 12
power = tf.constant([3.0] * batch_size)
power_v = 3.0
x = [-3.5, -0.5, 0., 1, 1.1, 2.2, 3.1, 4., 5., 5.5, 6.4, 7.8]
floor_x = np.floor(x)
ceil_x = np.ceil(x)
zipf = tfd.Zipf(power=power, validate_args=False)
log_cdf = zipf.log_cdf(x)
self.assertEqual((batch_size,), log_cdf.shape)
self.assertAllBetween(
self.evaluate(log_cdf), stats.zipf.logcdf(floor_x, power_v),
stats.zipf.logcdf(ceil_x, power_v))
cdf = zipf.cdf(x)
self.assertEqual((batch_size,), cdf.shape)
self.assertAllBetween(
self.evaluate(cdf), stats.zipf.cdf(floor_x, power_v),
stats.zipf.cdf(ceil_x, power_v))
def testZipfCdf_NonIntegerArgs(self):
batch_size = 12
power = tf.constant([3.0] * batch_size)
power_v = 3.0
x = [-3.5, -0.5, 0., 1, 1.1, 2.2, 3.1, 4., 5., 5.5, 6.4, 7.8]
floor_x = np.floor(x)
ceil_x = np.ceil(x)
zipf = tfd.Zipf(power=power, validate_args=False)
log_cdf = zipf.log_cdf(x)
self.assertEqual((batch_size,), log_cdf.shape)
self.assertAllBetween(
self.evaluate(log_cdf), stats.zipf.logcdf(floor_x, power_v),
stats.zipf.logcdf(ceil_x, power_v))
cdf = zipf.cdf(x)
self.assertEqual((batch_size,), cdf.shape)
self.assertAllBetween(
self.evaluate(cdf), stats.zipf.cdf(floor_x, power_v),
stats.zipf.cdf(ceil_x, power_v))
def testZipfCdfMultidimensional_IntegerArgs(self):
batch_size = 6
power = tf.constant([[2.0, 4.0, 5.0]] * batch_size)
power_v = [2.0, 4.0, 5.0]
x = np.array([[2., 3., 4., 5., 6., 7.]], dtype=np.float32).T
zipf = tfd.Zipf(power=power, validate_args=True)
log_cdf = zipf.log_cdf(x)
self.assertEqual((6, 3), log_cdf.shape)
self.assertAllClose(self.evaluate(log_cdf), stats.zipf.logcdf(x, power_v))
cdf = zipf.cdf(x)
self.assertEqual((6, 3), cdf.shape)
self.assertAllClose(self.evaluate(cdf), stats.zipf.cdf(x, power_v))
def testZipfCdfMultidimensional_NonIntegerArgs(self):
batch_size = 6
power = tf.constant([[2.0, 4.0, 5.0]] * batch_size)
power_v = [2.0, 4.0, 5.0]
x = np.array([[2.3, 3.5, 4.1, 5.5, 6.8, 7.9]], dtype=np.float32).T
floor_x = np.floor(x)
ceil_x = np.ceil(x)
zipf = tfd.Zipf(power=power, validate_args=True)
log_cdf = zipf.log_cdf(x)
self.assertEqual((6, 3), log_cdf.shape)
self.assertAllBetween(
self.evaluate(log_cdf), stats.zipf.logcdf(floor_x, power_v),
stats.zipf.logcdf(ceil_x, power_v))
cdf = zipf.cdf(x)
self.assertEqual((6, 3), cdf.shape)
self.assertAllBetween(
self.evaluate(cdf), stats.zipf.cdf(floor_x, power_v),
stats.zipf.cdf(ceil_x, power_v))
def testZipfMean(self):
power_v = [2.0, 3.0, 2.5]
zipf = tfd.Zipf(power=power_v, validate_args=True)
self.assertEqual((3,), zipf.mean().shape)
self.assertAllClose(self.evaluate(zipf.mean()), stats.zipf.mean(power_v))
def testZipfVariance(self):
power_v = [4.0, 3.0, 5.5] # var is undefined for power <= 3
zipf = tfd.Zipf(power=power_v, validate_args=True)
self.assertEqual((3,), zipf.variance().shape)
stat_vars = np.vectorize(stats.zipf.var)(power_v)
self.assertAllClose(self.evaluate(zipf.variance()), stat_vars)
def testZipfStd(self):
power_v = [4.0, 3.5, 4.5]
zipf = tfd.Zipf(power=power_v, validate_args=True)
self.assertEqual((3,), zipf.stddev().shape)
stat_stddevs = np.vectorize(stats.zipf.std)(power_v)
self.assertAllClose(self.evaluate(zipf.stddev()), stat_stddevs)
def testZipfMode(self):
power_v = [10.0, 3.0, 2.5, 3.2, 1.1, 0.05]
zipf = tfd.Zipf(power=power_v, validate_args=False)
self.assertEqual((6,), zipf.mode().shape)
self.assertAllClose(self.evaluate(zipf.mode()), np.ones_like(power_v))
def testZipfSample(self):
power_v = 5.
n = int(500e4)
for power_dtype in [tf.float32, tf.float64]:
power = tf.constant(power_v, dtype=power_dtype)
for dtype in [tf.int32, tf.int64, tf.float32, tf.float64]:
zipf = tfd.Zipf(power=power, dtype=dtype, validate_args=True)
samples = zipf.sample(n, seed=test_util.test_seed())
sample_values = self.evaluate(samples)
self.assertEqual((n,), samples.shape)
self.assertEqual((n,), sample_values.shape)
self.assertAllClose(
sample_values.mean(), stats.zipf.mean(power_v), rtol=.01)
self.assertAllClose(
sample_values.std(), stats.zipf.std(power_v), rtol=.03)
def testZipfSample_ValidateArgs(self):
power_v = 3.
n = int(100e3)
for power_dtype in [tf.float32, tf.float64]:
power = tf.constant(power_v, dtype=power_dtype)
for dtype in [tf.int32, tf.int64, tf.float32, tf.float64]:
zipf = tfd.Zipf(power=power, dtype=dtype, validate_args=True)
samples = zipf.sample(n, seed=test_util.test_seed())
self.evaluate(samples)
def testZipfSampleMultidimensionalMean(self):
power_v = np.array([np.arange(5, 15, dtype=np.float32)]) # 1 x 10
zipf = tfd.Zipf(power=power_v, validate_args=True)
n = int(100e3)
samples = zipf.sample(n, seed=test_util.test_seed())
sample_values = self.evaluate(samples)
self.assertEqual((n, 1, 10,), samples.shape)
self.assertEqual((n, 1, 10,), sample_values.shape)
# stats.zipf wants float64 params.
stats_mean = np.vectorize(stats.zipf.mean)(power_v.astype(np.float64))
self.assertAllClose(sample_values.mean(axis=0), stats_mean, rtol=.01)
def testZipfSampleMultidimensionalStd(self):
power_v = np.array([np.arange(5, 10, dtype=np.float32)]) # 1 x 5
zipf = tfd.Zipf(power=power_v, validate_args=True)
n = int(100e4)
samples = zipf.sample(n, seed=test_util.test_seed())
sample_values = self.evaluate(samples)
self.assertEqual((n, 1, 5), samples.shape)
self.assertEqual((n, 1, 5), sample_values.shape)
# stats.zipf wants float64 params.
stats_std = np.vectorize(stats.zipf.std)(power_v.astype(np.float64))
self.assertAllClose(sample_values.std(axis=0), stats_std, rtol=.04)
# Test that sampling with the same seed twice gives the same results.
def testZipfSampleMultipleTimes(self):
n = 1000
seed = test_util.test_seed()
power = 1.5
zipf1 = tfd.Zipf(power=power, name="zipf1", validate_args=True)
tf.random.set_seed(seed)
samples1 = self.evaluate(zipf1.sample(n, seed=seed))
zipf2 = tfd.Zipf(power=power, name="zipf2", validate_args=True)
tf.random.set_seed(seed)
samples2 = self.evaluate(zipf2.sample(n, seed=seed))
self.assertAllEqual(samples1, samples2)
def testZipfSample_AvoidsInfiniteLoop(self):
zipf = tfd.Zipf(power=1., validate_args=False)
n = 1000
self.evaluate(zipf.sample(n, seed=test_util.test_seed()))
if __name__ == "__main__":
tf.test.main()
| 37.299304 | 79 | 0.669818 | [
"Apache-2.0"
] | OrenBochman/probability | tensorflow_probability/python/distributions/zipf_test.py | 16,076 | Python |
"""
Tensorflow implementation of DeepFM
"""
import numpy as np
import tensorflow as tf
import tensorflow.compat.v1 as tf1
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.metrics import roc_auc_score
from time import time
from tensorflow.contrib.layers.python.layers import batch_norm as batch_norm
from sklearn import metrics
# from yellowfin import YFOptimizer
import os
import sys
import json
"""
关于 X_i 和 X_v
为什么要把训练数据分成两个矩阵？
FM模型需要为每个特征训练一个embedding vector，
在模型计算过程中使用 embedding_lookup + index matrix 可以方便计算。
首先把特征分成两种，一种是不需要one hot(数值类)，一种是需要one hot（枚举类）。
然后定义，one hot 之前的特征称为 field，one hot 之后的特征为 feature。
- X_i 表示 feat_index
- X_v 表示 feat_value
**feat_index**
feat_index 存储的是样本的 field 的"feature索引"，shape=(N,field_size)。
feat_index[i,j]表示的是第i个样本第j个field的 feature_index。
如果当前 field 不需要 one hot，此 field 就只会映射成一个 feature；
如果当前 field 需要 one hot，此 field 就会被映射成多个 feature ，
每个枚举值是一个 feature，其实就是进行 one hot 编码。
比如 feat_index[i,j]=c，表示 第i个样本第j个 field 的对应着第c个feature，
c是 feature_index。
当然如果 field_j 是数值 field，所有样本的j列都是一样的值，因为 field_j 不需要onehot。
如果 field_j 需要one hot，c的值就是其原来的枚举值onehot后映射对应的 feature_index。
feat_index 是给 embedding_lookup是用的。
**feat_value**
feat_value 存储的是样本field的"值"，shape=(N,field_size)。
feat_value[i,j]表示的是第i个样本第j个field的值。
如果当前field 不需要 one hot，feat_value[i,j]就是原始数据值；
如果当前field 需要 one hot，feat_value[i,j]就是常量1；
注意：这里有一个前提条件，就是 one_hot 的 field 变量只能取一个值，一个变量可以有多个取值的情况是不支持的。
"""
class DeepFM(BaseEstimator, TransformerMixin):
def __init__(self, feature_size, field_size,
embedding_size=8, dropout_fm=[1.0, 1.0],
deep_layers=[32, 32], dropout_deep=[0.5, 0.5, 0.5],
deep_layers_activation=tf.nn.relu,
epoch=10, batch_size=256,
learning_rate=0.001, optimizer_type="adam",
batch_norm=0, batch_norm_decay=0.995,
verbose=False, random_seed=2016,
use_fm=True, use_deep=True,
loss_type="logloss", eval_metric=roc_auc_score,
l2_reg=0.0, greater_is_better=True, threshold=0.5
):
assert (use_fm or use_deep)
assert loss_type in ["logloss", "mse"], \
"loss_type can be either 'logloss' for classification task or 'mse' for regression task"
self.feature_size = feature_size # 259 denote as M, size of the feature dictionary
self.field_size = field_size # 39 denote as F, size of the feature fields
self.embedding_size = embedding_size # 8 denote as K, size of the feature embedding
self.dropout_fm = dropout_fm
self.deep_layers = deep_layers
self.dropout_deep = dropout_deep
self.deep_layers_activation = deep_layers_activation
self.use_fm = use_fm
self.use_deep = use_deep
self.l2_reg = l2_reg
self.epoch = epoch
self.batch_size = batch_size
self.learning_rate = learning_rate
self.optimizer_type = optimizer_type
self.batch_norm = batch_norm
self.batch_norm_decay = batch_norm_decay
self.verbose = verbose # 是否打印参数总量
self.random_seed = random_seed
self.loss_type = loss_type
self.eval_metric = eval_metric
self.greater_is_better = greater_is_better # 是否值越大越好
self.train_result, self.valid_result = [], []
self.sess = None
self.graph = None
self._config = None
self.threshold = threshold
def _make_config_pack(self):
self._config = {
"feature_size": self.feature_size, # 259 denote as M, size of the feature dictionary
"field_size ": self.field_size, # 39 denote as F, size of the feature fields
"embedding_size ": self.embedding_size, # 8 denote as K, size of the feature embedding
"dropout_fm ": self.dropout_fm,
"deep_layers ": self.deep_layers,
"dropout_deep ": self.dropout_deep,
"deep_layers_activation ": self.deep_layers_activation,
"use_fm ": self.use_fm,
"use_deep ": self.use_deep,
"l2_reg ": self.l2_reg,
"epoch ": self.epoch,
"batch_size ": self.batch_size,
"learning_rate ": self.learning_rate,
"optimizer_type ": self.optimizer_type,
"batch_norm ": self.batch_norm,
"batch_norm_decay ": self.batch_norm_decay,
"verbose ": self.verbose, # 是否打印参数总量
"random_seed ": self.random_seed,
"loss_type": self.loss_type,
"eval_metric ": self.eval_metric,
"greater_is_better ": self.greater_is_better, # 是否值越大越好
}
# self.model_path = '%s/deepfm' % (save_path)
# self._init_graph()
def init_graph(self):
if self.sess is not None:
return
self.graph = tf.Graph()
with self.graph.as_default():
tf1.set_random_seed(self.random_seed)
self.feat_index = tf1.placeholder(tf.int32, shape=[None, None],
name="feat_index") # None * F
self.feat_value = tf1.placeholder(tf.float32, shape=[None, None],
name="feat_value") # None * F
self.label = tf1.placeholder(tf.float32, shape=[None, 1], name="label") # None * 1
self.dropout_keep_fm = tf1.placeholder(tf.float32, shape=[None], name="dropout_keep_fm")
self.dropout_keep_deep = tf1.placeholder(tf.float32, shape=[None], name="dropout_keep_deep")
self.train_phase = tf1.placeholder(tf.bool, name="train_phase")
self.weights = self._initialize_weights()
# 每一个feature 有一个 embedding
# feature_embeddings.shape=(self.feature_size, self.embedding_size)
# feat_index[i,j] 存储的是 第i条样本第j个field 对应的 feature_index
# 1. 如果 field_j 是非 one hot 特征，则 field_j 不需要拆成多个 feature，
# feat_index[:,j] 所有样本行都是同一个值，对应同一个 feature_index。
# 2. 如果 field_j 是 one hot 特征，则 field_j 需要拆成多个 feature，每个枚举值独立成一个 feature，
# 此时 feat_index[:,j] 不同行是不同值，其值表示 枚举值Value(field_j) 对应的 feature_index.
# 比如，第i=3行样本，第j=5个field表示颜色，其值是红色，红色被 onehot成 feature_index=13.则 feat_index[3,5]=13
# shape=(N样本数量 * field_size * K)
# N 表示样本的数量
# K 是嵌入向量的长度,
# 取出所有样本，每个 feature 的嵌入向量
# 对于one_hot 的 field，相当于只取出来枚举值对应的 feature_index 的嵌入向量，
# 相当于每个 field 取一个，最终每条样本嵌入向量的数量还是 field 。
self.embeddings = tf.nn.embedding_lookup(
self.weights["feature_embeddings"], # shape=(self.feature_size, self.embedding_size)
self.feat_index # N * field_size
)
# shape=(None * F * 1)
#
feat_value = tf.reshape(self.feat_value, shape=[-1, self.field_size, 1]) # None * F * 1
# FM部分的公式是 (x_i * x_j)(v_i*v_j)=(x_i*v_i)(x_j*v_j)
# 这里先把每个特征的向量乘上其特征值。
self.embeddings = tf.multiply(self.embeddings, feat_value) # None * F * K
# ---------- first order term ----------
# 对于k维，tf.reduce_sum(x,axis=k-1)的结果是对最里面一维所有元素进行求和
self.y_first_order = tf.nn.embedding_lookup(self.weights["feature_bias"], self.feat_index) # None * F * 1
self.y_first_order = tf.reduce_sum(tf.multiply(self.y_first_order, feat_value), 2) # None * F
self.y_first_order = tf.nn.dropout(self.y_first_order, rate=1 - self.dropout_keep_fm[0]) # None * F
# ---------- second order term ---------------
# sum_square part
self.summed_features_emb = tf.reduce_sum(self.embeddings, 1) # None * K
self.summed_features_emb_square = tf.square(self.summed_features_emb) # None * K
# square_sum part
self.squared_features_emb = tf.square(self.embeddings)
self.squared_sum_features_emb = tf.reduce_sum(self.squared_features_emb, 1) # None * K
# second order
self.y_second_order = 0.5 * tf.subtract(self.summed_features_emb_square,
self.squared_sum_features_emb) # None * K
self.y_second_order = tf.nn.dropout(self.y_second_order, rate=1 - self.dropout_keep_fm[1]) # None * K
# ---------- Deep component ----------
self.y_deep = tf.reshape(self.embeddings, shape=[-1, self.field_size * self.embedding_size]) # None * (F*K)
self.y_deep = tf.nn.dropout(self.y_deep, rate=1 - self.dropout_keep_deep[0])
for i in range(0, len(self.deep_layers)):
self.y_deep = tf.add(tf.matmul(self.y_deep, self.weights["layer_%d" % i]),
self.weights["bias_%d" % i]) # None * layer[i] * 1
if self.batch_norm:
self.y_deep = self.batch_norm_layer(self.y_deep, train_phase=self.train_phase,
scope_bn="bn_%d" % i) # None * layer[i] * 1
self.y_deep = self.deep_layers_activation(self.y_deep)
self.y_deep = tf.nn.dropout(self.y_deep,
rate=1 - self.dropout_keep_deep[1 + i]) # dropout at each Deep layer
# ---------- DeepFM ----------
if self.use_fm and self.use_deep:
concat_input = tf.concat([self.y_first_order, self.y_second_order, self.y_deep], axis=1)
elif self.use_fm:
concat_input = tf.concat([self.y_first_order, self.y_second_order], axis=1)
elif self.use_deep:
concat_input = self.y_deep
self.out = tf.add(tf.matmul(concat_input, self.weights["concat_projection"]), self.weights["concat_bias"])
# loss
if self.loss_type == "logloss":
self.out = tf.nn.sigmoid(self.out, name='out')
self.loss = tf1.losses.log_loss(self.label, self.out)
elif self.loss_type == "mse":
self.loss = tf.nn.l2_loss(tf.subtract(self.label, self.out))
# l2 regularization on weights 正则
if self.l2_reg > 0:
self.loss += tf.contrib.layers.l2_regularizer(
self.l2_reg)(self.weights["concat_projection"])
if self.use_deep:
for i in range(len(self.deep_layers)):
self.loss += tf.contrib.layers.l2_regularizer(
self.l2_reg)(self.weights["layer_%d" % i])
# optimizer
# 这里可以使用现成的ftrl优化损失
# optimizer = tf.train.FtrlOptimizer(lr) # lr: learningRate
# gradients = optimizer.compute_gradients(loss) # cost
# train_op = optimizer.apply_gradients(gradients, global_step=global_step)
if self.optimizer_type == "adam":
self.optimizer = tf1.train.AdamOptimizer(learning_rate=self.learning_rate, beta1=0.9, beta2=0.999,
epsilon=1e-8).minimize(self.loss)
elif self.optimizer_type == "adagrad":
self.optimizer = tf1.train.AdagradOptimizer(learning_rate=self.learning_rate,
initial_accumulator_value=1e-8).minimize(self.loss)
elif self.optimizer_type == "gd":
self.optimizer = tf1.train.GradientDescentOptimizer(learning_rate=self.learning_rate).minimize(
self.loss)
elif self.optimizer_type == "momentum":
self.optimizer = tf1.train.MomentumOptimizer(learning_rate=self.learning_rate, momentum=0.95).minimize(
self.loss)
# elif self.optimizer_type == "yellowfin":
# self.optimizer = YFOptimizer(learning_rate=self.learning_rate, momentum=0.0).minimize(
# self.loss)
# init
self.saver = tf1.train.Saver()
init = tf1.global_variables_initializer()
self.sess = self._init_session()
self.sess.run(init)
# number of params
total_parameters = 0
for variable in self.weights.values():
shape = variable.get_shape()
variable_parameters = 1
for dim in shape:
variable_parameters *= dim.value
total_parameters += variable_parameters
if self.verbose > 0:
print("#params: %d" % total_parameters)
def _init_session(self):
config = tf1.ConfigProto(device_count={"gpu": 0})
config.gpu_options.allow_growth = True # 根据运行情况分配GPU内存
return tf1.Session(config=config)
def _initialize_weights(self):
weights = dict() # 定义参数字典
# embeddings
weights["feature_embeddings"] = tf.Variable(
tf.random.normal([self.feature_size, self.embedding_size], 0.0, 0.01),
# tf.random_normal([self.feature_size, self.embedding_size], 0.0, 0.01),
name="feature_embeddings") # feature_size * K
weights["feature_bias"] = tf.Variable(
# tf.random_uniform([self.feature_size, 1], 0.0, 1.0), name="feature_bias") # feature_size * 1
tf.random.uniform([self.feature_size, 1], 0.0, 1.0), name="feature_bias") # feature_size * 1
# deep layers
num_layer = len(self.deep_layers) # 层数
input_size = self.field_size * self.embedding_size
glorot = np.sqrt(2.0 / (input_size + self.deep_layers[0])) # 正态分布的标准差
weights["layer_0"] = tf.Variable(
np.random.normal(loc=0, scale=glorot, size=(input_size, self.deep_layers[0])), dtype=np.float32)
weights["bias_0"] = tf.Variable(np.random.normal(loc=0, scale=glorot, size=(1, self.deep_layers[0])),
dtype=np.float32) # 1 * layers[0]
for i in range(1, num_layer):
glorot = np.sqrt(2.0 / (self.deep_layers[i - 1] + self.deep_layers[i]))
weights["layer_%d" % i] = tf.Variable(
np.random.normal(loc=0, scale=glorot, size=(self.deep_layers[i - 1], self.deep_layers[i])),
dtype=np.float32) # layers[i-1] * layers[i]
weights["bias_%d" % i] = tf.Variable(
np.random.normal(loc=0, scale=glorot, size=(1, self.deep_layers[i])),
dtype=np.float32) # 1 * layer[i]
# final concat projection layer
if self.use_fm and self.use_deep:
input_size = self.field_size + self.embedding_size + self.deep_layers[-1]
elif self.use_fm:
input_size = self.field_size + self.embedding_size
elif self.use_deep:
input_size = self.deep_layers[-1]
glorot = np.sqrt(2.0 / (input_size + 1))
weights["concat_projection"] = tf.Variable(
np.random.normal(loc=0, scale=glorot, size=(input_size, 1)),
dtype=np.float32) # layers[i-1]*layers[i]
weights["concat_bias"] = tf.Variable(tf.constant(0.01), dtype=np.float32)
return weights
def batch_norm_layer(self, x, train_phase, scope_bn):
bn_train = batch_norm(x, decay=self.batch_norm_decay, center=True, scale=True, updates_collections=None,
is_training=True, reuse=None, trainable=True, scope=scope_bn)
bn_inference = batch_norm(x, decay=self.batch_norm_decay, center=True, scale=True, updates_collections=None,
is_training=False, reuse=True, trainable=True, scope=scope_bn)
z = tf.cond(train_phase, lambda: bn_train, lambda: bn_inference)
return z
def get_batch(self, Xi, Xv, y, batch_size, index):
start = index * batch_size
end = (index + 1) * batch_size
end = end if end < len(y) else len(y)
return Xi[start:end], Xv[start:end], [[y_] for y_ in y[start:end]]
# shuffle three lists simutaneously
def shuffle_in_unison_scary(self, a, b, c):
rng_state = np.random.get_state()
np.random.shuffle(a)
np.random.set_state(rng_state)
np.random.shuffle(b)
np.random.set_state(rng_state)
np.random.shuffle(c)
def fit_on_batch(self, Xi, Xv, y):
feed_dict = {self.feat_index: Xi,
self.feat_value: Xv,
self.label: y,
self.dropout_keep_fm: self.dropout_fm,
self.dropout_keep_deep: self.dropout_deep,
self.train_phase: True}
out, loss, opt = self.sess.run((self.out, self.loss, self.optimizer), feed_dict=feed_dict)
return out, loss
def fit(self, Xi_train, Xv_train, y_train,
Xi_valid=None, Xv_valid=None, y_valid=None,
early_stopping=False, refit=False):
"""
:param Xi_train: [[ind1_1, ind1_2, ...], [ind2_1, ind2_2, ...], ..., [indi_1, indi_2, ..., indi_j, ...], ...]
indi_j is the feature index of feature field j of sample i in the training set
:param Xv_train: [[val1_1, val1_2, ...], [val2_1, val2_2, ...], ..., [vali_1, vali_2, ..., vali_j, ...], ...]
vali_j is the feature value of feature field j of sample i in the training set
vali_j can be either binary (1/0, for binary/categorical features) or float (e.g., 10.24, for numerical features)
:param y_train: label of each sample in the training set
:param Xi_valid: list of list of feature indices of each sample in the validation set
:param Xv_valid: list of list of feature values of each sample in the validation set
:param y_valid: label of each sample in the validation set
:param early_stopping: perform early stopping or not
:param refit: refit the model on the train+valid dataset or not
:return: None
"""
has_valid = Xv_valid is not None
Xi_train = Xi_train.copy()
Xv_train = Xv_train.copy()
y_train = y_train.copy()
for epoch in range(self.epoch):
t1 = time()
self.shuffle_in_unison_scary(Xi_train, Xv_train, y_train)
total_batch = int(len(y_train) / self.batch_size)
for i in range(total_batch):
Xi_batch, Xv_batch, y_batch = self.get_batch(Xi_train, Xv_train, y_train, self.batch_size, i)
trian_out, train_loss = self.fit_on_batch(Xi_batch, Xv_batch, y_batch)
# print(trian_out, file=sys.stderr)
if i % 1000 == 0:
# print(trian_out, file=sys.stderr)
print("epoch:%d batch:%d train_loss=%.4f" % (epoch, i, train_loss), file=sys.stderr)
# evaluate training and validation datasets
train_me = self.evaluate(Xi_train, Xv_train, y_train)
self.train_result.append(train_me)
if has_valid:
valid_me = self.evaluate(Xi_valid, Xv_valid, y_valid)
self.valid_result.append(valid_me)
if self.verbose > 0 and epoch % self.verbose == 0:
print("[%d] [train] auc=%.4f acc=%.4f mse=%.4f precision_1=%.4f recall_1=%.4f [%.1f s]"
% (epoch + 1,
train_me['auc'],
train_me['acc'],
train_me['mse'],
train_me['precision_1'],
train_me['recall_1'],
time() - t1))
if has_valid:
print(
"[%d] [valid] auc=%.4f acc=%.4f mse=%.4f precision_1=%.4f recall_1=%.4f [%.1f s]"
% (epoch + 1,
valid_me['auc'],
valid_me['acc'],
valid_me['mse'],
valid_me['precision_1'],
valid_me['recall_1'],
time() - t1))
if has_valid and early_stopping and self.training_termination(self.valid_result):
break
# fit a few more epoch on train+valid until result reaches the best_train_score
if has_valid and refit:
if self.greater_is_better:
best_valid_score = max(self.valid_result)
else:
best_valid_score = min(self.valid_result)
best_epoch = self.valid_result.index(best_valid_score)
best_train_score = self.train_result[best_epoch]
Xi_train = Xi_train + Xi_valid
Xv_train = Xv_train + Xv_valid
y_train = y_train + y_valid
for epoch in range(100):
self.shuffle_in_unison_scary(Xi_train, Xv_train, y_train)
total_batch = int(len(y_train) / self.batch_size)
for i in range(total_batch):
Xi_batch, Xv_batch, y_batch = self.get_batch(Xi_train, Xv_train, y_train,
self.batch_size, i)
self.fit_on_batch(Xi_batch, Xv_batch, y_batch)
# check
train_result = self.evaluate(Xi_train, Xv_train, y_train)
if abs(train_result - best_train_score) < 0.001 or \
(self.greater_is_better and train_result > best_train_score) or \
((not self.greater_is_better) and train_result < best_train_score):
break
def training_termination(self, valid_result):
if len(valid_result) > 5:
if self.greater_is_better:
if valid_result[-1] < valid_result[-2] and \
valid_result[-2] < valid_result[-3] and \
valid_result[-3] < valid_result[-4] and \
valid_result[-4] < valid_result[-5]:
return True
else:
if valid_result[-1] > valid_result[-2] \
and valid_result[-2] > valid_result[-3] \
and valid_result[-3] > valid_result[-4] \
and valid_result[-4] > valid_result[-5]:
return True
return False
def predict(self, Xi, Xv):
"""
:param Xi: list of list of feature indices of each sample in the dataset
:param Xv: list of list of feature values of each sample in the dataset
:return: predicted probability of each sample
"""
dummy_y = [1] * len(Xi)
batch_index = 0
Xi_batch, Xv_batch, y_batch = self.get_batch(Xi, Xv, dummy_y, self.batch_size, batch_index)
y_pred = None
while len(Xi_batch) > 0:
num_batch = len(y_batch)
feed_dict = {self.feat_index: Xi_batch,
self.feat_value: Xv_batch,
# self.label: y_batch,
self.dropout_keep_fm: [1.0] * len(self.dropout_fm),
self.dropout_keep_deep: [1.0] * len(self.dropout_deep),
self.train_phase: False}
batch_out = self.sess.run(self.out, feed_dict=feed_dict)
if batch_index == 0:
y_pred = np.reshape(batch_out, (num_batch,))
else:
y_pred = np.concatenate((y_pred, np.reshape(batch_out, (num_batch,))))
batch_index += 1
Xi_batch, Xv_batch, y_batch = self.get_batch(Xi, Xv, dummy_y, self.batch_size, batch_index)
return y_pred
def evaluate(self, Xi, Xv, y_true):
"""
:param Xi: list of list of feature indices of each sample in the dataset
:param Xv: list of list of feature values of each sample in the dataset
:param y: label of each sample in the dataset
:return: metric of the evaluation
"""
size = y_true.shape[0]
y_pred = self.predict(Xi, Xv)
error = y_true - y_pred
mse = (error * error).sum() / size
y_pred_m = y_pred.copy()
y_pred_m[y_pred_m >= self.threshold] = 1
y_pred_m[y_pred_m < self.threshold] = 0
# accuracy = metrics.accuracy_score(y_true, y_pred_m)
cm = metrics.confusion_matrix(y_true, y_pred_m, labels=[1, 0])
# 实际正样本数量
real_1_count = cm[0, :].sum()
# 预测为正样本数量
predict_1_count = cm[:, 0].sum()
# 正样本 预测正确的数量
right_1_count = cm[0, 0]
if predict_1_count == 0:
precision_1 = 0
else:
# 正样本精确率
precision_1 = right_1_count / predict_1_count
if real_1_count == 0:
recall_1 = 0
else:
# 正样本召回率
recall_1 = right_1_count / real_1_count
return {
"size": size,
"acc": (cm[0, 0] + cm[1, 1]) / size,
# "实际退费人次": cm[0, :].sum(),
# "预测退费人次": cm[:, 0].sum(),
# "预测正确人次": cm[0, 0],
# "预测错误人次": cm[1, 0],
"precision_1": precision_1,
"recall_1": recall_1,
"auc": self.eval_metric(y_true, y_pred),
"mse": mse
}
def save(self, save_path):
model_prefix = os.path.join(save_path, 'deepfm')
print("Save model...", save_path, file=sys.stderr)
self.saver.save(self.sess, model_prefix)
if self._config is not None:
config_path = os.path.join(save_path, "config.json")
with open(config_path, 'w') as fp:
json.dump(fp)
print("Save model done.", save_path, file=sys.stderr)
def load(self, model_path):
if self.sess is not None:
self.sess.close()
if self.graph is not None:
self.graph = None
model_prefix = os.path.join(model_path, 'deepfm')
# self.sess = tf.Session()
# with tf.Session() as sess:
# print('load model', file=sys.stderr)
# t1 = time()
print("Load model...", model_path, file=sys.stderr)
self.sess = tf1.Session()
saver = tf1.train.import_meta_graph(model_prefix + '.meta', clear_devices=True)
saver.restore(self.sess, model_prefix)
self.feat_index = tf1.get_default_graph().get_tensor_by_name('feat_index:0')
self.feat_value = tf1.get_default_graph().get_tensor_by_name('feat_value:0')
self.dropout_keep_fm = tf1.get_default_graph().get_tensor_by_name('dropout_keep_fm:0')
self.dropout_keep_deep = tf1.get_default_graph().get_tensor_by_name('dropout_keep_deep:0')
self.train_phase = tf1.get_default_graph().get_tensor_by_name('train_phase:0')
self.out = tf1.get_default_graph().get_tensor_by_name('out:0')
config_path = os.path.join(model_path, "config.json")
if os.path.exists(config_path):
with open(config_path) as fp:
self._config = json.load(fp)
else:
self._config = None
print("Load model done", model_path, file=sys.stderr)
| 45.732323 | 146 | 0.57817 | [
"MIT"
] | zhangzhenhu/zzh | zzh/mllib/model/_deep_fm.py | 28,639 | Python |
from django.test import TestCase
from django.contrib.auth import get_user_model
from django.urls import reverse
from rest_framework.test import APIClient
from rest_framework import status
CREATE_USER_URL = reverse('user:create')
TOKEN_URL = reverse('user:token')
def create_user(**params):
return get_user_model().objects.create_user(**params)
class PublicUserApiTests(TestCase):
"""The the user API (public)"""
def setUp(self):
self.client = APIClient()
def test_create_valid_user_successful(self):
"""Test creating user with valid payload is successful"""
payload = {
'email': '[email protected]',
'password': 'testpass',
'name': 'John Doe'
}
res = self.client.post(CREATE_USER_URL, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
user = get_user_model().objects.get(**res.data)
self.assertTrue(user.check_password(payload['password']))
self.assertNotIn('password', res.data)
def test_user_exists(self):
payload = {
'email': '[email protected]',
'password': 'testpass',
"name": 'John Doe'
}
create_user(**payload)
res = self.client.post(CREATE_USER_URL, payload)
self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
def test_password_too_short(self):
"""tests that the password must be more than 5 characters"""
payload = {
'email': '[email protected]',
'password': 'pass',
"name": 'John Doe'
}
res = self.client.post(CREATE_USER_URL, payload)
self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
user_exists = get_user_model().objects.filter(
email=payload['email']
).exists()
self.assertFalse(user_exists)
def test_create_token_for_user(self):
"""Test that a token is created for a user"""
payload = {'email': '[email protected]', 'password': 'testpass'}
create_user(**payload)
res = self.client.post(TOKEN_URL, payload)
self.assertTrue(res.status_code, status.HTTP_200_OK)
self.assertIn('token', res.data)
def test_create_token_invalid_credentials(self):
"""Test that token is not created if invalid credentials are given"""
create_user(email='[email protected]', password='testpass')
payload = {'email': '[email protected]', 'password': 'wrong'}
res = self.client.post(TOKEN_URL, payload)
self.assertTrue(res.status_code, status.HTTP_400_BAD_REQUEST)
self.assertNotIn('token', res.data)
def test_create_token_no_user(self):
"""Test that token is not created if user does not exist"""
payload = {'email': '[email protected]', 'password': 'wrong'}
res = self.client.post(TOKEN_URL, payload)
self.assertTrue(res.status_code, status.HTTP_400_BAD_REQUEST)
self.assertNotIn('token', res.data)
def test_create_token_no_missing_field(self):
"""Test that token is not created if email/password not given"""
res = self.client.post(
TOKEN_URL,
{'email': '[email protected]', 'password': ''})
self.assertTrue(res.status_code, status.HTTP_400_BAD_REQUEST)
self.assertNotIn('token', res.data)
| 37.577778 | 77 | 0.63631 | [
"MIT"
] | reallyusefulengine/django_rest_recipe | app/user/tests/test_user_api.py | 3,382 | Python |
# Copyright 2019 Grabtaxi Holdings PTE LTE (GRAB), All rights reserved.
# Use of this source code is governed by an MIT-style license that can be found in the LICENSE file
import subprocess
import re
import os
import glob
from utils.fileutils import FileUtils
from utils.ziputils import ZipUtils
from functools import wraps
from utils.logger import logger
from utils.step import step
# PREBUILD POD LIBS FLOW
# Normal build, it automatically:
# 1. Fetch binary cache from separated repo and unzip it to pod-binary folder.
# 2. pod-binary hook pod install and will use those cached libraries.
# When upgrade a library, need to do:
# 1. Need to run this script to prebuild/delete the libs which have change.
# 2. Commit binary changes to cache repo, set tag for it.
# 3. Update tag in this file. Then submit a new MR.
def print_func_name(func):
@wraps(func)
def echo_func(*func_args, **func_kwargs):
logger.info('🚀 Start func: {}'.format(func.__name__))
return func(*func_args, **func_kwargs)
return echo_func
class PrebuildLib:
def __init__(self, config):
self.cache_repo = config.cache_repo
self.cache_path = config.cache_path
self.prebuild_path = config.prebuild_path
self.generated_dir_name = config.generated_dir_name
self.delta_path = config.delta_path
self.manifest_file = config.manifest_file
self.devpod_cache_repo = config.devpod_cache_repo
self.devpod_cache_path = config.devpod_cache_path
self.devpod_prebuild_output = config.devpod_prebuild_output
self.generated_path = config.generated_path
self.cache_libs_path = config.cache_libs_path
self.devpod_cache_libs_path = config.devpod_cache_libs_path
@print_func_name
def zip_to_cache(self, libName):
if os.path.exists(self.cache_libs_path + libName + '.zip'):
logger.info('Warning: lib {} already exist'.format(libName))
else:
ZipUtils.zip_dir(
'{}/{}'.format(self.generated_path, libName),
'{}/{}.zip'.format(self.cache_libs_path, libName)
)
@print_func_name
def clean_cache(self, libName):
FileUtils.remove_file(self.cache_libs_path + libName + ".zip")
@print_func_name
def zip_all_libs_to_cache(self):
os.system('rm -rf ' + self.cache_libs_path + '/*')
FileUtils.create_dir(self.cache_libs_path)
for dir in FileUtils.listdir_nohidden(self.generated_path):
ZipUtils.zip_dir(self.generated_path + '/' + dir, self.cache_libs_path + '/' + dir + '.zip')
FileUtils.copy_file_or_dir(self.prebuild_path + self.manifest_file, self.cache_path)
def clean_and_pull(self, git_repo_dir):
subprocess.run(['git', '-C', git_repo_dir, 'reset', '--hard'])
subprocess.run(['git', '-C', git_repo_dir, 'clean', '-df'])
subprocess.run(['git', '-C', git_repo_dir, 'checkout', 'master'])
subprocess.run(['git', '-C', git_repo_dir, 'pull', '-X', 'theirs'])
@print_func_name
def fetch_cache(self):
with step('fetch_prebuild_libs'):
if not os.path.exists(self.cache_path):
subprocess.run(['git', 'clone', '--depth=1', self.cache_repo, self.cache_path])
else:
self.clean_and_pull(self.cache_path)
@print_func_name
def unzip_cache(self):
with step('unzip_prebuild_libs'):
FileUtils.remove_dir(self.prebuild_path)
FileUtils.create_dir(self.generated_path)
FileUtils.copy_file_or_dir(self.cache_path + self.manifest_file, self.prebuild_path)
# Unzip libs to pod-binary folder
for zipPath in glob.iglob(self.cache_libs_path + '/*.zip'):
ZipUtils.unzip(zipPath, self.generated_path)
@print_func_name
def fetch_and_apply_cache(self):
self.fetch_cache()
self.unzip_cache()
@print_func_name
def fetch_and_apply_devpod_cache(self):
with step('fetch_and_apply_devpod_cache'):
logger.info('Fetching devpod cache to {}'.format(self.devpod_cache_path))
if not os.path.exists(self.devpod_cache_path):
subprocess.run(['git', 'clone', '--depth=1', self.devpod_cache_repo, self.devpod_cache_path])
else:
self.clean_and_pull(self.devpod_cache_path)
# Unzip devpod libs
devpod_temp_dir = self.prebuild_path + 'devpod/'
logger.info('Unzip from: {} to: {}'.format(self.devpod_cache_libs_path, devpod_temp_dir))
for zip_path in glob.iglob(self.devpod_cache_libs_path + '/*.zip'):
ZipUtils.unzip(zip_path, devpod_temp_dir)
@print_func_name
def has_libs_change(self):
if os.path.exists(self.delta_path):
return True
return False
def push_all_to_git(self, git_dir):
git_input_path = 'git -C ' + self.cache_path
os.system('{} add .'.format(git_input_path))
os.system('{} commit -m "Prebuild pod libs"'.format(git_input_path))
os.system('{} push'.format(git_input_path))
@print_func_name
def prebuild_if_needed(self):
self.fetch_and_apply_cache()
subprocess.run(['bundle', 'exec', 'pod', 'install'], check=True)
# Sync with cache directory
if not os.path.isfile(self.delta_path):
logger.info('No change in prebuilt frameworks')
return
try:
with open(self.delta_path) as f:
FileUtils.create_dir(self.cache_path)
data = f.read()
data = re.sub('"', '', data)
updatedMatches = re.findall(r'Updated: \[(.*)\]', data)
if updatedMatches:
updated = updatedMatches[0].strip()
logger.info("Updated frameworks: {}".format(updated))
if len(updated):
libs = updated.split(',')
for lib in libs:
libName = lib.strip()
self.clean_cache(libName)
self.zip_to_cache(libName)
deletedMatches = re.findall(r'Deleted: \[(.*)\]', data)
if deletedMatches:
deleted = deletedMatches[0].strip()
logger.info('Deleted frameworks: {}'.format(deleted))
if len(deleted):
libs = deleted.split(',')
for lib in libs:
self.clean_cache(lib.strip())
# Copy manifest file
FileUtils.copy_file_or_dir(self.prebuild_path + self.manifest_file, self.cache_path)
self.push_all_to_git(self.cache_path)
except Exception as e:
raise e
@print_func_name
def prebuild_devpod(self):
self.fetch_and_apply_cache()
self.fetch_and_apply_devpod_cache()
subprocess.run(['bundle', 'exec', 'fastlane', 'run', 'cocoapods', 'try_repo_update_on_error:true'], check=True)
| 41.711765 | 119 | 0.624313 | [
"MIT"
] | qalandarov/cocoapods-binary-cache | lib/command/PythonScripts/prebuild_lib.py | 7,094 | Python |
#!/usr/bin/python
#
# Copyright (C) 2012 Google Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""Script for testing ganeti.tools.prepare_node_join"""
import unittest
import shutil
import tempfile
import os.path
from ganeti import errors
from ganeti import constants
from ganeti import pathutils
from ganeti import compat
from ganeti import utils
from ganeti.tools import prepare_node_join
from ganeti.tools import common
import testutils
_JoinError = prepare_node_join.JoinError
_DATA_CHECK = prepare_node_join._DATA_CHECK
class TestVerifyCertificate(testutils.GanetiTestCase):
def setUp(self):
testutils.GanetiTestCase.setUp(self)
self.tmpdir = tempfile.mkdtemp()
def tearDown(self):
testutils.GanetiTestCase.tearDown(self)
shutil.rmtree(self.tmpdir)
def testNoCert(self):
common.VerifyCertificateSoft({}, error_fn=prepare_node_join.JoinError,
_verify_fn=NotImplemented)
def testGivenPrivateKey(self):
cert_filename = testutils.TestDataFilename("cert2.pem")
cert_pem = utils.ReadFile(cert_filename)
self.assertRaises(_JoinError, common._VerifyCertificateSoft,
cert_pem, _JoinError, _check_fn=NotImplemented)
def testInvalidCertificate(self):
self.assertRaises(errors.X509CertError,
common._VerifyCertificateSoft,
"Something that's not a certificate",
_JoinError, _check_fn=NotImplemented)
@staticmethod
def _Check(cert):
assert cert.get_subject()
def testSuccessfulCheck(self):
cert_filename = testutils.TestDataFilename("cert1.pem")
cert_pem = utils.ReadFile(cert_filename)
common._VerifyCertificateSoft(cert_pem, _JoinError,
_check_fn=self._Check)
class TestUpdateSshDaemon(unittest.TestCase):
def setUp(self):
unittest.TestCase.setUp(self)
self.tmpdir = tempfile.mkdtemp()
self.keyfiles = {
constants.SSHK_RSA:
(utils.PathJoin(self.tmpdir, "rsa.private"),
utils.PathJoin(self.tmpdir, "rsa.public")),
constants.SSHK_DSA:
(utils.PathJoin(self.tmpdir, "dsa.private"),
utils.PathJoin(self.tmpdir, "dsa.public")),
constants.SSHK_ECDSA:
(utils.PathJoin(self.tmpdir, "ecdsa.private"),
utils.PathJoin(self.tmpdir, "ecdsa.public")),
}
def tearDown(self):
unittest.TestCase.tearDown(self)
shutil.rmtree(self.tmpdir)
def testNoKeys(self):
data_empty_keys = {
constants.SSHS_SSH_HOST_KEY: [],
}
for data in [{}, data_empty_keys]:
for dry_run in [False, True]:
prepare_node_join.UpdateSshDaemon(data, dry_run,
_runcmd_fn=NotImplemented,
_keyfiles=NotImplemented)
self.assertEqual(os.listdir(self.tmpdir), [])
def _TestDryRun(self, data):
prepare_node_join.UpdateSshDaemon(data, True, _runcmd_fn=NotImplemented,
_keyfiles=self.keyfiles)
self.assertEqual(os.listdir(self.tmpdir), [])
def testDryRunRsa(self):
self._TestDryRun({
constants.SSHS_SSH_HOST_KEY: [
(constants.SSHK_RSA, "rsapriv", "rsapub"),
],
})
def testDryRunDsa(self):
self._TestDryRun({
constants.SSHS_SSH_HOST_KEY: [
(constants.SSHK_DSA, "dsapriv", "dsapub"),
],
})
def testDryRunEcdsa(self):
self._TestDryRun({
constants.SSHS_SSH_HOST_KEY: [
(constants.SSHK_ECDSA, "ecdsapriv", "ecdsapub"),
],
})
def _RunCmd(self, fail, cmd, interactive=NotImplemented):
self.assertTrue(interactive)
self.assertEqual(cmd, [pathutils.DAEMON_UTIL, "reload-ssh-keys"])
if fail:
exit_code = constants.EXIT_FAILURE
else:
exit_code = constants.EXIT_SUCCESS
return utils.RunResult(exit_code, None, "stdout", "stderr",
utils.ShellQuoteArgs(cmd),
NotImplemented, NotImplemented)
def _TestUpdate(self, failcmd):
data = {
constants.SSHS_SSH_HOST_KEY: [
(constants.SSHK_DSA, "dsapriv", "dsapub"),
(constants.SSHK_ECDSA, "ecdsapriv", "ecdsapub"),
(constants.SSHK_RSA, "rsapriv", "rsapub"),
],
constants.SSHS_SSH_KEY_TYPE: "dsa",
constants.SSHS_SSH_KEY_BITS: 1024,
}
runcmd_fn = compat.partial(self._RunCmd, failcmd)
if failcmd:
self.assertRaises(_JoinError, prepare_node_join.UpdateSshDaemon,
data, False, _runcmd_fn=runcmd_fn,
_keyfiles=self.keyfiles)
else:
prepare_node_join.UpdateSshDaemon(data, False, _runcmd_fn=runcmd_fn,
_keyfiles=self.keyfiles)
self.assertEqual(sorted(os.listdir(self.tmpdir)), sorted([
"rsa.public", "rsa.private",
"dsa.public", "dsa.private",
"ecdsa.public", "ecdsa.private",
]))
self.assertEqual(utils.ReadFile(utils.PathJoin(self.tmpdir, "rsa.public")),
"rsapub")
self.assertEqual(utils.ReadFile(utils.PathJoin(self.tmpdir, "rsa.private")),
"rsapriv")
self.assertEqual(utils.ReadFile(utils.PathJoin(self.tmpdir, "dsa.public")),
"dsapub")
self.assertEqual(utils.ReadFile(utils.PathJoin(self.tmpdir, "dsa.private")),
"dsapriv")
self.assertEqual(utils.ReadFile(utils.PathJoin(
self.tmpdir, "ecdsa.public")), "ecdsapub")
self.assertEqual(utils.ReadFile(utils.PathJoin(
self.tmpdir, "ecdsa.private")), "ecdsapriv")
def testSuccess(self):
self._TestUpdate(False)
def testFailure(self):
self._TestUpdate(True)
class TestUpdateSshRoot(unittest.TestCase):
def setUp(self):
unittest.TestCase.setUp(self)
self.tmpdir = tempfile.mkdtemp()
self.sshdir = utils.PathJoin(self.tmpdir, ".ssh")
def tearDown(self):
unittest.TestCase.tearDown(self)
shutil.rmtree(self.tmpdir)
def _GetHomeDir(self, user):
self.assertEqual(user, constants.SSH_LOGIN_USER)
return self.tmpdir
def testDryRun(self):
data = {
constants.SSHS_SSH_ROOT_KEY: [
(constants.SSHK_RSA, "aaa", "bbb"),
]
}
prepare_node_join.UpdateSshRoot(data, True,
_homedir_fn=self._GetHomeDir)
self.assertEqual(os.listdir(self.tmpdir), [".ssh"])
self.assertEqual(os.listdir(self.sshdir), [])
def testUpdate(self):
data = {
constants.SSHS_SSH_ROOT_KEY: [
(constants.SSHK_DSA, "privatedsa", "ssh-dss pubdsa"),
],
constants.SSHS_SSH_KEY_TYPE: "dsa",
constants.SSHS_SSH_KEY_BITS: 1024,
}
prepare_node_join.UpdateSshRoot(data, False,
_homedir_fn=self._GetHomeDir)
self.assertEqual(os.listdir(self.tmpdir), [".ssh"])
self.assertEqual(sorted(os.listdir(self.sshdir)),
sorted(["authorized_keys", "id_dsa", "id_dsa.pub"]))
self.assertTrue(utils.ReadFile(utils.PathJoin(self.sshdir, "id_dsa"))
is not None)
pub_key = utils.ReadFile(utils.PathJoin(self.sshdir, "id_dsa.pub"))
self.assertTrue(pub_key is not None)
self.assertEquals(utils.ReadFile(utils.PathJoin(self.sshdir,
"authorized_keys")),
pub_key)
if __name__ == "__main__":
testutils.GanetiTestProgram()
| 34.177165 | 80 | 0.665592 | [
"BSD-2-Clause"
] | YSelfTool/ganeti | test/py/ganeti.tools.prepare_node_join_unittest.py | 8,681 | Python |
from ewah.hooks.base import EWAHBaseHook
import requests
import time
class EWAHAircallHook(EWAHBaseHook):
_ATTR_RELABEL = {
"api_id": "login",
"api_token": "password",
}
conn_name_attr = "ewah_aircall_conn_id"
default_conn_name = "ewah_aircall_default"
conn_type = "ewah_aircall"
hook_name = "EWAH Aircall Connection"
_RESOURCES = {
"users": {"incremental": True},
"teams": {},
"calls": {"incremental": True},
"numbers": {"incremental": True},
"contacts": {"incremental": True},
"tags": {},
}
_BASE_URL = "https://api.aircall.io/v1/{0}"
@staticmethod
def get_ui_field_behaviour():
return {
"hidden_fields": ["port", "schema", "extra", "host"],
"relabeling": {
"login": "Basic Auth API ID",
"password": "Baisc Auth API Token",
},
}
def get_data_in_batches(
self,
resource,
data_from=None,
data_until=None,
batch_size=10000,
batch_call_pause_seconds=1,
):
_msg = "batch_size param must be a positive integer <= 10k "
assert isinstance(batch_size, int), _msg
assert batch_size > 0, _msg
assert batch_size <= 10000, _msg
page_size = 50 # maximum page size is 50
auth = requests.auth.HTTPBasicAuth(
self.conn.api_id,
self.conn.api_token,
)
url = self._BASE_URL.format(resource)
params = {
"per_page": page_size,
}
if data_from:
params["from"] = int(time.mktime(data_from.timetuple()))
if data_until:
params["to"] = int(time.mktime((data_until).timetuple()))
data = []
while url:
time.sleep(batch_call_pause_seconds)
request = requests.get(url, params=params, auth=auth)
assert request.status_code == 200, request.text
response = request.json()
url = response.get("meta", {}).get("next_page_link")
data += response.get(resource, [])
if (not url) or (len(data) + page_size > batch_size):
yield data
data = []
| 28.846154 | 69 | 0.549778 | [
"MIT"
] | Gemma-Analytics/ewah | ewah/hooks/aircall.py | 2,250 | Python |
# python 3.7
"""Utility functions to invert a given image back to a latent code."""
from tqdm import tqdm
import cv2
import numpy as np
import torch
from models.stylegan_generator import StyleGANGenerator
from models.stylegan_encoder import StyleGANEncoder
from models.perceptual_model import PerceptualModel
__all__ = ['StyleGANInverter']
def _softplus(x):
"""Implements the softplus function."""
return torch.nn.functional.softplus(x, beta=1, threshold=10000)
def _get_tensor_value(tensor):
"""Gets the value of a torch Tensor."""
return tensor.cpu().detach().numpy()
class StyleGANInverter(object):
"""Defines the class for StyleGAN inversion.
Even having the encoder, the output latent code is not good enough to recover
the target image satisfyingly. To this end, this class optimize the latent
code based on gradient descent algorithm. In the optimization process,
following loss functions will be considered:
(1) Pixel-wise reconstruction loss. (required)
(2) Perceptual loss. (optional, but recommended)
(3) Regularization loss from encoder. (optional, but recommended for in-domain
inversion)
NOTE: The encoder can be missing for inversion, in which case the latent code
will be randomly initialized and the regularization loss will be ignored.
"""
def __init__(self,
model_name,
learning_rate=1e-2,
iteration=100,
reconstruction_loss_weight=1.0,
perceptual_loss_weight=5e-5,
regularization_loss_weight=2.0,
logger=None):
"""Initializes the inverter.
NOTE: Only Adam optimizer is supported in the optimization process.
Args:
model_name: Name of the model on which the inverted is based. The model
should be first registered in `models/model_settings.py`.
logger: Logger to record the log message.
learning_rate: Learning rate for optimization. (default: 1e-2)
iteration: Number of iterations for optimization. (default: 100)
reconstruction_loss_weight: Weight for reconstruction loss. Should always
be a positive number. (default: 1.0)
perceptual_loss_weight: Weight for perceptual loss. 0 disables perceptual
loss. (default: 5e-5)
regularization_loss_weight: Weight for regularization loss from encoder.
This is essential for in-domain inversion. However, this loss will
automatically ignored if the generative model does not include a valid
encoder. 0 disables regularization loss. (default: 2.0)
"""
self.logger = logger
self.model_name = model_name
self.gan_type = 'stylegan'
self.G = StyleGANGenerator(self.model_name, self.logger)
self.E = StyleGANEncoder(self.model_name, self.logger)
self.F = PerceptualModel(min_val=self.G.min_val, max_val=self.G.max_val)
self.encode_dim = [self.G.num_layers, self.G.w_space_dim]
self.run_device = self.G.run_device
assert list(self.encode_dim) == list(self.E.encode_dim)
assert self.G.gan_type == self.gan_type
assert self.E.gan_type == self.gan_type
self.learning_rate = learning_rate
self.iteration = iteration
self.loss_pix_weight = reconstruction_loss_weight
self.loss_feat_weight = perceptual_loss_weight
self.loss_reg_weight = regularization_loss_weight
assert self.loss_pix_weight > 0
def preprocess(self, image):
"""Preprocesses a single image.
This function assumes the input numpy array is with shape [height, width,
channel], channel order `RGB`, and pixel range [0, 255].
The returned image is with shape [channel, new_height, new_width], where
`new_height` and `new_width` are specified by the given generative model.
The channel order of returned image is also specified by the generative
model. The pixel range is shifted to [min_val, max_val], where `min_val` and
`max_val` are also specified by the generative model.
"""
if not isinstance(image, np.ndarray):
raise ValueError(f'Input image should be with type `numpy.ndarray`!')
if image.dtype != np.uint8:
raise ValueError(f'Input image should be with dtype `numpy.uint8`!')
if image.ndim != 3 or image.shape[2] not in [1, 3]:
raise ValueError(f'Input should be with shape [height, width, channel], '
f'where channel equals to 1 or 3!\n'
f'But {image.shape} is received!')
if image.shape[2] == 1 and self.G.image_channels == 3:
image = np.tile(image, (1, 1, 3))
if image.shape[2] != self.G.image_channels:
raise ValueError(f'Number of channels of input image, which is '
f'{image.shape[2]}, is not supported by the current '
f'inverter, which requires {self.G.image_channels} '
f'channels!')
if self.G.image_channels == 3 and self.G.channel_order == 'BGR':
image = image[:, :, ::-1]
if image.shape[1:3] != [self.G.resolution, self.G.resolution]:
image = cv2.resize(image, (self.G.resolution, self.G.resolution))
image = image.astype(np.float32)
image = image / 255.0 * (self.G.max_val - self.G.min_val) + self.G.min_val
image = image.astype(np.float32).transpose(2, 0, 1)
return image
def get_init_code(self, image):
"""Gets initial latent codes as the start point for optimization.
The input image is assumed to have already been preprocessed, meaning to
have shape [self.G.image_channels, self.G.resolution, self.G.resolution],
channel order `self.G.channel_order`, and pixel range [self.G.min_val,
self.G.max_val].
"""
x = image[np.newaxis]
x = self.G.to_tensor(x.astype(np.float32))
z = _get_tensor_value(self.E.net(x).view(1, *self.encode_dim))
return z.astype(np.float32)
def invert(self, image, num_viz=0):
"""Inverts the given image to a latent code.
Basically, this function is based on gradient descent algorithm.
Args:
image: Target image to invert, which is assumed to have already been
preprocessed.
num_viz: Number of intermediate outputs to visualize. (default: 0)
Returns:
A two-element tuple. First one is the inverted code. Second one is a list
of intermediate results, where first image is the input image, second
one is the reconstructed result from the initial latent code, remainings
are from the optimization process every `self.iteration // num_viz`
steps.
"""
x = image[np.newaxis]
x = self.G.to_tensor(x.astype(np.float32))
x.requires_grad = False
init_z = self.get_init_code(image)
z = torch.Tensor(init_z).to(self.run_device)
z.requires_grad = True
optimizer = torch.optim.Adam([z], lr=self.learning_rate)
viz_results = []
viz_results.append(self.G.postprocess(_get_tensor_value(x))[0])
x_init_inv = self.G.net.synthesis(z)
viz_results.append(self.G.postprocess(_get_tensor_value(x_init_inv))[0])
pbar = tqdm(range(1, self.iteration + 1), leave=True)
for step in pbar:
loss = 0.0
# Reconstruction loss.
x_rec = self.G.net.synthesis(z)
loss_pix = torch.mean((x - x_rec) ** 2)
loss = loss + loss_pix * self.loss_pix_weight
log_message = f'loss_pix: {_get_tensor_value(loss_pix):.3f}'
# Perceptual loss.
if self.loss_feat_weight:
x_feat = self.F.net(x)
x_rec_feat = self.F.net(x_rec)
loss_feat = torch.mean((x_feat - x_rec_feat) ** 2)
loss = loss + loss_feat * self.loss_feat_weight
log_message += f', loss_feat: {_get_tensor_value(loss_feat):.3f}'
# Regularization loss.
if self.loss_reg_weight:
z_rec = self.E.net(x_rec).view(1, *self.encode_dim)
loss_reg = torch.mean((z - z_rec) ** 2)
loss = loss + loss_reg * self.loss_reg_weight
log_message += f', loss_reg: {_get_tensor_value(loss_reg):.3f}'
log_message += f', loss: {_get_tensor_value(loss):.3f}'
pbar.set_description_str(log_message)
if self.logger:
self.logger.debug(f'Step: {step:05d}, '
f'lr: {self.learning_rate:.2e}, '
f'{log_message}')
# Do optimization.
optimizer.zero_grad()
loss.backward()
optimizer.step()
if num_viz > 0 and step % (self.iteration // num_viz) == 0:
viz_results.append(self.G.postprocess(_get_tensor_value(x_rec))[0])
return _get_tensor_value(z), viz_results
def easy_invert(self, image, num_viz=0):
"""Wraps functions `preprocess()` and `invert()` together."""
return self.invert(self.preprocess(image), num_viz)
def diffuse(self,
target,
context,
center_x,
center_y,
crop_x,
crop_y,
num_viz=0):
"""Diffuses the target image to a context image.
Basically, this function is a motified version of `self.invert()`. More
concretely, the encoder regularizer is removed from the objectives and the
reconstruction loss is computed from the masked region.
Args:
target: Target image (foreground).
context: Context image (background).
center_x: The x-coordinate of the crop center.
center_y: The y-coordinate of the crop center.
crop_x: The crop size along the x-axis.
crop_y: The crop size along the y-axis.
num_viz: Number of intermediate outputs to visualize. (default: 0)
Returns:
A two-element tuple. First one is the inverted code. Second one is a list
of intermediate results, where first image is the direct copy-paste
image, second one is the reconstructed result from the initial latent
code, remainings are from the optimization process every
`self.iteration // num_viz` steps.
"""
image_shape = (self.G.image_channels, self.G.resolution, self.G.resolution)
mask = np.zeros((1, *image_shape), dtype=np.float32)
xx = center_x - crop_x // 2
yy = center_y - crop_y // 2
mask[:, :, yy:yy + crop_y, xx:xx + crop_x] = 1.0
target = target[np.newaxis]
context = context[np.newaxis]
x = target * mask + context * (1 - mask)
x = self.G.to_tensor(x.astype(np.float32))
x.requires_grad = False
mask = self.G.to_tensor(mask.astype(np.float32))
mask.requires_grad = False
init_z = _get_tensor_value(self.E.net(x).view(1, *self.encode_dim))
init_z = init_z.astype(np.float32)
z = torch.Tensor(init_z).to(self.run_device)
z.requires_grad = True
optimizer = torch.optim.Adam([z], lr=self.learning_rate)
viz_results = []
viz_results.append(self.G.postprocess(_get_tensor_value(x))[0])
x_init_inv = self.G.net.synthesis(z)
viz_results.append(self.G.postprocess(_get_tensor_value(x_init_inv))[0])
pbar = tqdm(range(1, self.iteration + 1), leave=True)
for step in pbar:
loss = 0.0
# Reconstruction loss.
x_rec = self.G.net.synthesis(z)
loss_pix = torch.mean(((x - x_rec) * mask) ** 2)
loss = loss + loss_pix * self.loss_pix_weight
log_message = f'loss_pix: {_get_tensor_value(loss_pix):.3f}'
# Perceptual loss.
if self.loss_feat_weight:
x_feat = self.F.net(x * mask)
x_rec_feat = self.F.net(x_rec * mask)
loss_feat = torch.mean((x_feat - x_rec_feat) ** 2)
loss = loss + loss_feat * self.loss_feat_weight
log_message += f', loss_feat: {_get_tensor_value(loss_feat):.3f}'
log_message += f', loss: {_get_tensor_value(loss):.3f}'
pbar.set_description_str(log_message)
if self.logger:
self.logger.debug(f'Step: {step:05d}, '
f'lr: {self.learning_rate:.2e}, '
f'{log_message}')
# Do optimization.
optimizer.zero_grad()
loss.backward()
optimizer.step()
if num_viz > 0 and step % (self.iteration // num_viz) == 0:
viz_results.append(self.G.postprocess(_get_tensor_value(x_rec))[0])
return _get_tensor_value(z), viz_results
def easy_diffuse(self, target, context, *args, **kwargs):
"""Wraps functions `preprocess()` and `diffuse()` together."""
return self.diffuse(self.preprocess(target),
self.preprocess(context),
*args, **kwargs)
| 39.209524 | 80 | 0.6644 | [
"MIT"
] | Twizwei/idinvert_pytorch | utils/inverter.py | 12,351 | Python |
"""
Copyright (c) 2017 Robbin Bouwmeester
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE."""
__author__ = "Robbin Bouwmeester"
__copyright__ = "Copyright 2017"
__credits__ = ["Robbin Bouwmeester"]
__license__ = "MIT"
__version__ = "0.1"
__maintainer__ = "Robbin Bouwmeester"
__email__ = "[email protected]"
__status__ = "nightly funzies"
import pandas as pd
from itertools import groupby
import logging
class LipidBLAST_entry():
def __init__(self,
name="",
ion="",
mw=0.0,
chem_form="",
num_ms2_peaks=0,
f_acyl_lengths=[],
unsats=[],
ms2=[]):
self.name = name
self.ion = ion
self.mw = mw
self.chem_form = chem_form
self.num_ms2_peaks = num_ms2_peaks
self.ms2 = ms2
self.f_acyl_lengths = f_acyl_lengths
self.unsats = unsats
def __str__(self):
ret_string = []
ret_string.append("================")
ret_string.append("")
ret_string.append("Lipid: %s" % (self.name))
ret_string.append("MW: %s" % (self.mw))
ret_string.append("Formula: %s" % (self.chem_form))
ret_string.append ("")
for f in self.ms2:
ret_string.append("%s\t%s\t%s" % (f[0],f[1],f[2]))
ret_string.append("")
ret_string.append("================")
return("\n".join(ret_string))
class LipidBLAST():
def __init__(self,
f_names=["LipidBlast-pos.msp","LipidBlast-neg.msp"],
min_acyl_length=10,
exclude_lyso=False,
include_ions=["[M-H]-"], #,"[M+]","[M+H]+","[M+NH4]+","[M-H]-","[M-2H](2-)","[M-Ac-H]-","[M+Na2-H]+","[M+]","[M+NH4]+","[M+Na]+","[M-2H](2-)","[M-Ac-H]-" "[M+]","[M+H]+","[M+NH4]+","[M-H]-","[M-2H](2-)","[M-Ac-H]-","[M+Na2-H]+","[M+]","[M+NH4]+","[M+Na]+","[M-2H](2-)","[M-Ac-H]-"
include_class=["PE","GPSer","GPCho","PC","GPA","PE","GPIns","GPEtn","GPGro"], #,"SM","TG","CL", #,"SM","TG","CL","GPSer","GPCho","PC","GPA","PE","GPIns","GPEtn","GPGro
aggregate_acyls=False,
use_simplified_names=True,
dalt_diff_lookup_bin=1):
self.f_names = f_names
self.min_acyl_length = min_acyl_length
self.exclude_lyso = exclude_lyso
self.include_ions = include_ions
self.include_class = include_class
self.use_simplified_names = use_simplified_names
self.dalt_diff_lookup_bin = dalt_diff_lookup_bin
self.aggregate_acyls = aggregate_acyls
self.lpb_dict = {}
self.ms1_dict = {}
self.ms1_dict_lookup = {}
self.tot_entr_read = 0
if len(self.f_names) > 0:
for f_name in f_names:
self.read_lpb(f_name)
def __str__(self):
ret_string = []
ret_string.append("Filenames: %s" % (self.f_names))
ret_string.append("Min acyl length: %s" % (self.min_acyl_length))
ret_string.append("Exclude lyso: %s" % (self.exclude_lyso))
ret_string.append("Include ions: %s" % (self.include_ions))
ret_string.append("Include lipid classes: %s" % (self.include_class))
ret_string.append("Use simplified names: %s" % (self.use_simplified_names))
ret_string.append("Lookup diff: %s Da" % (self.dalt_diff_lookup_bin))
ret_string.append("Total entries read: %s" % (self.tot_entr_read))
return("\n".join(ret_string))
def read_lpb(self,f_name):
def _get_general_info(name):
# Currently limited to max 9 unsats
unsats = [n[0] for n in name.split(":")[1:]]
class_name = name.split("(")[0]
if "-" in class_name:
name_split = name.split("(")
name_split[0] = name.split("(")[0].replace("-","")
name = "(".join(name_split)
acyl_lengths = name.split(":")
acyl_lengths.pop()
f_acyl_lengths = []
for acl in acyl_lengths:
try:
if "/" in acl:
f_acyl_lengths.append(acl.split("/")[1].replace("d","").replace("methyl-",""))
elif "-" in acl:
f_acyl_lengths.append(acl.split("-")[1].replace("d","").replace("methyl-",""))
else:
f_acyl_lengths.append(acl.split("(")[1].replace("d","").replace("methyl-",""))
except:
logging.warning("Could not format to get acyl lengths: %s" % (name))
return([0],[0],"")
try:
f_acyl_lengths = list(map(int,f_acyl_lengths))
unsats = list(map(int,unsats))
except:
logging.warning("Could not format to get acyl lengths: %s" % (name))
return([0],[0],"")
return(f_acyl_lengths,unsats,class_name)
def _simplify_name(class_name,acyls,unsats):
simplified_name = ""
simplified_name += class_name
simplified_name += "("
if not self.aggregate_acyls:
for f,u in zip(f_acyl_lengths,unsats):
simplified_name += str(f)
simplified_name += ":"
simplified_name += str(u)
simplified_name += "/"
simplified_name = simplified_name[:-1]
else:
simplified_name += str(sum(f_acyl_lengths))
simplified_name += ":"
simplified_name += str(sum(unsats))
simplified_name += ")"
return(simplified_name)
def _get_chem_form(chem_form_native,ion):
chem_form_ion = ""
for i,c in enumerate(chem_form_native):
if i+1 >= len(chem_form_native):
if c.isdigit(): chem_form_ion += c
else:
chem_form_ion += c
chem_form_ion += "1"
elif c.isdigit(): chem_form_ion += c
elif c.isupper() and chem_form_native[i+1].isdigit(): chem_form_ion += c
elif c.isupper() and chem_form_native[i+1].isupper():
chem_form_ion += c
chem_form_ion += "1"
elif chem_form_native[i+1].isdigit(): chem_form_ion += c
list_chem= [''.join(g) for _, g in groupby(chem_form_ion, str.isalpha)]
chem_form_ion = dict(zip(list_chem[::2],map(int,list_chem[1::2])))
if "+" not in ion:
if "[M-H]-" in ion:
try: chem_form_ion["H"] -= 1
except KeyError: logging.critical("ERROR: could not subtract atom when getting the ionized form from the molecule")
if "[M-2H](2-)" in ion:
try: chem_form_ion["H"] -= 2
except KeyError: logging.critical("ERROR: could not subtract atom when getting the ionized form from the molecule")
if "[M-Ac-H]-" in ion:
try:
chem_form_ion["C"] += 2
chem_form_ion["H"] += 3
chem_form_ion["O"] += 2
except KeyError: logging.critical("ERROR: could not subtract atom when getting the ionized form from the molecule")
else:
if "[M+H]+" in ion:
try: chem_form_ion["H"] += 1
except KeyError: logging.critical("ERROR: could not add atom when getting the ionized form from the molecule")
if "[M+NH4]+" in ion:
try:
if chem_form_ion.has_key("N"): chem_form_ion["N"] += 1
else: chem_form_ion["N"] = 1
chem_form_ion["H"] += 4
except KeyError: logging.critical("ERROR: could not add atom when getting the ionized form from the molecule")
if "[M+Na]+" in ion:
try:
if chem_form_ion.has_key("Na"): chem_form_ion["Na"] += 1
else: chem_form_ion["Na"] = 1
except KeyError: logging.critical("ERROR: could not add atom when getting the ionized form from the molecule")
if "[M+Na2-H]+" in ion:
try:
if chem_form_ion.has_key("Na"): chem_form_ion["Na"] += 2
else: chem_form_ion["Na"] = 2
chem_form_ion["H"] -= 1
except KeyError: logging.critical("ERROR: could not add atom when getting the ionized form from the molecule")
return("".join([atom+str(num_atom) for atom,num_atom in sorted(chem_form_ion.items())]))
with open(f_name) as infile:
fragments = []
pre_c_mass = 0.0
name = ""
ion = ""
for line in infile:
line = line.strip()
#print(line)
if len(line) == 0:
f_acyl_lengths,unsats,class_name = _get_general_info(name)
f_acyl_lengths_error = [a for a in f_acyl_lengths if a < self.min_acyl_length and a != 0]
if (len(class_name) == 0) or \
(ion_type not in self.include_ions) or \
(len([c for c in self.include_class if c in name]) == 0) or \
(self.exclude_lyso and "/0:0" in name) or \
(len(f_acyl_lengths_error) > 0):
fragments = []
pre_c_mass = 0.0
name = ""
ion_type = ""
continue
simplified_name = _simplify_name(class_name,f_acyl_lengths,unsats)
new_entry = LipidBLAST_entry(name=name,
ion=ion_type,
mw=pre_c_mass,
chem_form=chem_form_ion,
num_ms2_peaks=num_peaks,
ms2=fragments,
f_acyl_lengths=f_acyl_lengths,
unsats=unsats)
self.lpb_dict["%s|%s" % (simplified_name,ion_type)] = new_entry
loc_dict = int(pre_c_mass) - int(pre_c_mass) % self.dalt_diff_lookup_bin
if loc_dict in self.ms1_dict_lookup.keys():
self.ms1_dict_lookup[loc_dict]["%s|%s" % (simplified_name,ion_type)] = new_entry
else:
self.ms1_dict_lookup[loc_dict] = {}
self.ms1_dict_lookup[loc_dict]["%s|%s" % (simplified_name,ion_type)] = new_entry
self.tot_entr_read += 1
fragments = []
pre_c_mass = 0.0
name = ""
ion_type = ""
elif ":" in line:
if line.startswith("PRECURSORMZ"):
pre_c_mass = float(line.split(": ")[1])
if line.startswith("Name: "):
name = line.split("; ")[-1]
ion_type = line.split("; ")[1]
if line.startswith("Comment: "):
# Some of the chemical formulas contain a ";" at the end; remove
chem_form_native = line.split("; ")[-1].replace(";","")
#print(chem_form_native)
chem_form_ion = _get_chem_form(chem_form_native,ion_type)
if line.startswith("Num Peaks:"):
num_peaks = int(line.split(": ")[-1])
else:
if line=="\x1a": #EOF
continue
fragments.append([float(line.split(" ")[0]),float(line.split(" ")[1]),line.split(" ")[2].replace("\"","")])
class PrecursorFilter():
def __init__(self,db,ppm=10):
self.db = db
self.ppm = ppm
def retrieve_entry_pre_c_mass(self,pre_c_mass):
mass_error_threshold = (pre_c_mass*self.ppm)/1000000
ret_entries = []
loc_dict = int(pre_c_mass) - int(pre_c_mass) % self.db.dalt_diff_lookup_bin
loc_dict_lower = (int(pre_c_mass-mass_error_threshold)) - (int(pre_c_mass-mass_error_threshold)) % self.db.dalt_diff_lookup_bin
loc_dict_upper = (int(pre_c_mass+mass_error_threshold)) - (int(pre_c_mass+mass_error_threshold)) % self.db.dalt_diff_lookup_bin
# TODO set does not have to be list
locs_to_search = list(set([loc_dict,loc_dict_lower,loc_dict_upper]))
for loc in locs_to_search:
try:
for name,entr in self.db.ms1_dict_lookup[loc].items():
mass_error = abs(entr.mw-pre_c_mass)
if mass_error < mass_error_threshold:
ret_entries.append([name,mass_error,entr])
except KeyError:
logging.warning("Could not find an entry in the database for prec mass: %s" % (pre_c_mass))
continue
return(ret_entries)
if __name__ == "__main__":
logging.basicConfig(filename="prec_filter.log",
level=logging.DEBUG,
filemode="w",
format="%(levelname)s:%(created)f:%(asctime)s:%(message)s")
logging.info("Reading the LPB database ...")
lpb = LipidBLAST()
logging.info("Done reading the LPB database ...")
logging.info(lpb)
step_three_df = pd.read_csv("stepone_new.csv")
precf = Precursor_filter(lpb)
prec_filt_result = []
for index,row in step_three_df.iterrows():
if (index % 10000==0):
logging.info("Analyzing row number and m/z: %s - %s" % (index,row["mz"]))
prec_hits = precf.retrieve_entry_pre_c_mass(row["mz"])
for hit in prec_hits:
prec_filt_result.append([row["mz"],hit[2].mw,hit[1],hit[0].split("|")[0],hit[2].chem_form,hit[0].split("|")[1]])
prec_filt_result = pd.DataFrame(prec_filt_result)
prec_filt_result.columns = ["Input Mass","Matched Mass","Delta","Abbreviation","Formula","Ion"]
prec_filt_result.to_excel("batch_results.xlsx",index=False)
| 36.162319 | 303 | 0.655579 | [
"Apache-2.0"
] | RobbinBouwmeester/LIT | src/lpb.py | 12,476 | Python |
"""
Support for MQTT discovery.
For more details about this component, please refer to the documentation at
https://home-assistant.io/components/mqtt/#discovery
"""
import asyncio
import json
import logging
import re
from homeassistant.components import mqtt
from homeassistant.components.mqtt import CONF_STATE_TOPIC, ATTR_DISCOVERY_HASH
from homeassistant.const import CONF_PLATFORM
from homeassistant.helpers.discovery import async_load_platform
from homeassistant.helpers.dispatcher import async_dispatcher_send
from homeassistant.helpers.typing import HomeAssistantType
_LOGGER = logging.getLogger(__name__)
TOPIC_MATCHER = re.compile(
r'(?P<prefix_topic>\w+)/(?P<component>\w+)/'
r'(?:(?P<node_id>[a-zA-Z0-9_-]+)/)?(?P<object_id>[a-zA-Z0-9_-]+)/config')
SUPPORTED_COMPONENTS = [
'binary_sensor', 'camera', 'cover', 'fan',
'light', 'sensor', 'switch', 'lock', 'climate',
'alarm_control_panel', 'vacuum']
CONFIG_ENTRY_COMPONENTS = [
'binary_sensor',
'camera',
'cover',
'light',
'lock',
'sensor',
'switch',
'climate',
'alarm_control_panel',
'fan',
'vacuum',
]
DEPRECATED_PLATFORM_TO_SCHEMA = {
'light': {
'mqtt_json': 'json',
'mqtt_template': 'template',
}
}
ALREADY_DISCOVERED = 'mqtt_discovered_components'
DATA_CONFIG_ENTRY_LOCK = 'mqtt_config_entry_lock'
CONFIG_ENTRY_IS_SETUP = 'mqtt_config_entry_is_setup'
MQTT_DISCOVERY_UPDATED = 'mqtt_discovery_updated_{}'
MQTT_DISCOVERY_NEW = 'mqtt_discovery_new_{}_{}'
TOPIC_BASE = '~'
ABBREVIATIONS = {
'aux_cmd_t': 'aux_command_topic',
'aux_stat_tpl': 'aux_state_template',
'aux_stat_t': 'aux_state_topic',
'avty_t': 'availability_topic',
'away_mode_cmd_t': 'away_mode_command_topic',
'away_mode_stat_tpl': 'away_mode_state_template',
'away_mode_stat_t': 'away_mode_state_topic',
'bri_cmd_t': 'brightness_command_topic',
'bri_scl': 'brightness_scale',
'bri_stat_t': 'brightness_state_topic',
'bri_val_tpl': 'brightness_value_template',
'clr_temp_cmd_tpl': 'color_temp_command_template',
'bat_lev_t': 'battery_level_topic',
'bat_lev_tpl': 'battery_level_template',
'chrg_t': 'charging_topic',
'chrg_tpl': 'charging_template',
'clr_temp_cmd_t': 'color_temp_command_topic',
'clr_temp_stat_t': 'color_temp_state_topic',
'clr_temp_val_tpl': 'color_temp_value_template',
'cln_t': 'cleaning_topic',
'cln_tpl': 'cleaning_template',
'cmd_t': 'command_topic',
'curr_temp_t': 'current_temperature_topic',
'dev_cla': 'device_class',
'dock_t': 'docked_topic',
'dock_tpl': 'docked_template',
'err_t': 'error_topic',
'err_tpl': 'error_template',
'fanspd_t': 'fan_speed_topic',
'fanspd_tpl': 'fan_speed_template',
'fanspd_lst': 'fan_speed_list',
'fx_cmd_t': 'effect_command_topic',
'fx_list': 'effect_list',
'fx_stat_t': 'effect_state_topic',
'fx_val_tpl': 'effect_value_template',
'exp_aft': 'expire_after',
'fan_mode_cmd_t': 'fan_mode_command_topic',
'fan_mode_stat_tpl': 'fan_mode_state_template',
'fan_mode_stat_t': 'fan_mode_state_topic',
'frc_upd': 'force_update',
'hold_cmd_t': 'hold_command_topic',
'hold_stat_tpl': 'hold_state_template',
'hold_stat_t': 'hold_state_topic',
'ic': 'icon',
'init': 'initial',
'json_attr': 'json_attributes',
'max_temp': 'max_temp',
'min_temp': 'min_temp',
'mode_cmd_t': 'mode_command_topic',
'mode_stat_tpl': 'mode_state_template',
'mode_stat_t': 'mode_state_topic',
'name': 'name',
'on_cmd_type': 'on_command_type',
'opt': 'optimistic',
'osc_cmd_t': 'oscillation_command_topic',
'osc_stat_t': 'oscillation_state_topic',
'osc_val_tpl': 'oscillation_value_template',
'pl_arm_away': 'payload_arm_away',
'pl_arm_home': 'payload_arm_home',
'pl_avail': 'payload_available',
'pl_cls': 'payload_close',
'pl_disarm': 'payload_disarm',
'pl_hi_spd': 'payload_high_speed',
'pl_lock': 'payload_lock',
'pl_lo_spd': 'payload_low_speed',
'pl_med_spd': 'payload_medium_speed',
'pl_not_avail': 'payload_not_available',
'pl_off': 'payload_off',
'pl_on': 'payload_on',
'pl_open': 'payload_open',
'pl_osc_off': 'payload_oscillation_off',
'pl_osc_on': 'payload_oscillation_on',
'pl_stop': 'payload_stop',
'pl_unlk': 'payload_unlock',
'pow_cmd_t': 'power_command_topic',
'ret': 'retain',
'rgb_cmd_tpl': 'rgb_command_template',
'rgb_cmd_t': 'rgb_command_topic',
'rgb_stat_t': 'rgb_state_topic',
'rgb_val_tpl': 'rgb_value_template',
'send_cmd_t': 'send_command_topic',
'send_if_off': 'send_if_off',
'set_pos_tpl': 'set_position_template',
'set_pos_t': 'set_position_topic',
'spd_cmd_t': 'speed_command_topic',
'spd_stat_t': 'speed_state_topic',
'spd_val_tpl': 'speed_value_template',
'spds': 'speeds',
'stat_clsd': 'state_closed',
'stat_off': 'state_off',
'stat_on': 'state_on',
'stat_open': 'state_open',
'stat_t': 'state_topic',
'stat_val_tpl': 'state_value_template',
'sup_feat': 'supported_features',
'swing_mode_cmd_t': 'swing_mode_command_topic',
'swing_mode_stat_tpl': 'swing_mode_state_template',
'swing_mode_stat_t': 'swing_mode_state_topic',
'temp_cmd_t': 'temperature_command_topic',
'temp_stat_tpl': 'temperature_state_template',
'temp_stat_t': 'temperature_state_topic',
'tilt_clsd_val': 'tilt_closed_value',
'tilt_cmd_t': 'tilt_command_topic',
'tilt_inv_stat': 'tilt_invert_state',
'tilt_max': 'tilt_max',
'tilt_min': 'tilt_min',
'tilt_opnd_val': 'tilt_opened_value',
'tilt_status_opt': 'tilt_status_optimistic',
'tilt_status_t': 'tilt_status_topic',
't': 'topic',
'uniq_id': 'unique_id',
'unit_of_meas': 'unit_of_measurement',
'val_tpl': 'value_template',
'whit_val_cmd_t': 'white_value_command_topic',
'whit_val_stat_t': 'white_value_state_topic',
'whit_val_tpl': 'white_value_template',
'xy_cmd_t': 'xy_command_topic',
'xy_stat_t': 'xy_state_topic',
'xy_val_tpl': 'xy_value_template',
}
async def async_start(hass: HomeAssistantType, discovery_topic, hass_config,
config_entry=None) -> bool:
"""Initialize of MQTT Discovery."""
async def async_device_message_received(topic, payload, qos):
"""Process the received message."""
match = TOPIC_MATCHER.match(topic)
if not match:
return
_prefix_topic, component, node_id, object_id = match.groups()
if component not in SUPPORTED_COMPONENTS:
_LOGGER.warning("Component %s is not supported", component)
return
if payload:
try:
payload = json.loads(payload)
except ValueError:
_LOGGER.warning("Unable to parse JSON %s: '%s'",
object_id, payload)
return
payload = dict(payload)
for key in list(payload.keys()):
abbreviated_key = key
key = ABBREVIATIONS.get(key, key)
payload[key] = payload.pop(abbreviated_key)
if TOPIC_BASE in payload:
base = payload[TOPIC_BASE]
for key, value in payload.items():
if isinstance(value, str) and value:
if value[0] == TOPIC_BASE and key.endswith('_topic'):
payload[key] = "{}{}".format(base, value[1:])
if value[-1] == TOPIC_BASE and key.endswith('_topic'):
payload[key] = "{}{}".format(value[:-1], base)
# If present, the node_id will be included in the discovered object id
discovery_id = ' '.join((node_id, object_id)) if node_id else object_id
discovery_hash = (component, discovery_id)
if payload:
if CONF_PLATFORM in payload and 'schema' not in payload:
platform = payload[CONF_PLATFORM]
if (component in DEPRECATED_PLATFORM_TO_SCHEMA and
platform in DEPRECATED_PLATFORM_TO_SCHEMA[component]):
schema = DEPRECATED_PLATFORM_TO_SCHEMA[component][platform]
payload['schema'] = schema
_LOGGER.warning('"platform": "%s" is deprecated, '
'replace with "schema":"%s"',
platform, schema)
payload[CONF_PLATFORM] = 'mqtt'
if CONF_STATE_TOPIC not in payload:
payload[CONF_STATE_TOPIC] = '{}/{}/{}{}/state'.format(
discovery_topic, component,
'%s/' % node_id if node_id else '', object_id)
payload[ATTR_DISCOVERY_HASH] = discovery_hash
if ALREADY_DISCOVERED not in hass.data:
hass.data[ALREADY_DISCOVERED] = {}
if discovery_hash in hass.data[ALREADY_DISCOVERED]:
# Dispatch update
_LOGGER.info(
"Component has already been discovered: %s %s, sending update",
component, discovery_id)
async_dispatcher_send(
hass, MQTT_DISCOVERY_UPDATED.format(discovery_hash), payload)
elif payload:
# Add component
_LOGGER.info("Found new component: %s %s", component, discovery_id)
hass.data[ALREADY_DISCOVERED][discovery_hash] = None
if component not in CONFIG_ENTRY_COMPONENTS:
await async_load_platform(
hass, component, 'mqtt', payload, hass_config)
return
config_entries_key = '{}.{}'.format(component, 'mqtt')
async with hass.data[DATA_CONFIG_ENTRY_LOCK]:
if config_entries_key not in hass.data[CONFIG_ENTRY_IS_SETUP]:
await hass.config_entries.async_forward_entry_setup(
config_entry, component)
hass.data[CONFIG_ENTRY_IS_SETUP].add(config_entries_key)
async_dispatcher_send(hass, MQTT_DISCOVERY_NEW.format(
component, 'mqtt'), payload)
hass.data[DATA_CONFIG_ENTRY_LOCK] = asyncio.Lock()
hass.data[CONFIG_ENTRY_IS_SETUP] = set()
await mqtt.async_subscribe(
hass, discovery_topic + '/#', async_device_message_received, 0)
return True
| 36.734043 | 79 | 0.646491 | [
"Apache-2.0"
] | arnisoph/home-assistant | homeassistant/components/mqtt/discovery.py | 10,359 | Python |
from lingloss import Lingloss
| 15 | 29 | 0.866667 | [
"MIT"
] | captainalan/linglosspy | __init__.py | 30 | Python |
#!/usr/bin/python
import os
import json
def get_db_config():
# read config file and return data
data = {}
with open('config.json', 'r') as infile:
data = json.loads(infile.read())
return data
| 19.727273 | 44 | 0.631336 | [
"MIT"
] | sjsafranek/pomegranate | Config.py | 217 | Python |
# (C) Datadog, Inc. 2018
# All rights reserved
# Licensed under a 3-clause BSD style license (see LICENSE)
import os
import re
from datetime import datetime
from uuid import uuid4
from .utils import normalize_package_name
from ..utils import (
create_file,
dir_exists,
ensure_parent_dir_exists,
path_join,
read_file,
read_file_binary,
write_file,
write_file_binary
)
TEMPLATES_DIR = path_join(os.path.dirname(os.path.abspath(__file__)), 'templates')
BINARY_EXTENSIONS = ('.png', )
SIMPLE_NAME = r'^\w+$'
def get_valid_templates():
return sorted(os.listdir(TEMPLATES_DIR))
def construct_template_fields(integration_name, repo_choice, **kwargs):
normalized_integration_name = normalize_package_name(integration_name)
check_name_cap = (
integration_name.capitalize()
if re.match(SIMPLE_NAME, integration_name)
else integration_name
)
if repo_choice == 'core':
author = 'Datadog'
email = '[email protected]'
email_packages = '[email protected]'
install_info = (
'The {check_name_cap} check is included in the [Datadog Agent][2] package, so you do not\n'
'need to install anything else on your server.'.format(check_name_cap=check_name_cap)
)
license_header = (
'# (C) Datadog, Inc. {year}\n'
'# All rights reserved\n'
'# Licensed under a 3-clause BSD style license (see LICENSE)\n'
.format(year=str(datetime.now().year))
)
support_type = 'core'
tox_base_dep = '../datadog_checks_base[deps]'
else:
author = 'U.N. Owen'
email = email_packages = '[email protected]'
install_info = (
'The {} check is not included in the [Datadog Agent][2] package, so you will\n'
'need to install it yourself.'.format(check_name_cap)
)
license_header = ''
support_type = 'contrib'
tox_base_dep = 'datadog-checks-base[deps]'
config = {
'author': author,
'check_class': '{}Check'.format(
''.join(part.capitalize() for part in normalized_integration_name.split('_'))
),
'check_name': normalized_integration_name,
'check_name_cap': check_name_cap,
'email': email,
'email_packages': email_packages,
'guid': uuid4(),
'license_header': license_header,
'install_info': install_info,
'repo_choice': repo_choice,
'support_type': support_type,
'tox_base_dep': tox_base_dep,
}
config.update(kwargs)
return config
def create_template_files(template_name, new_root, config, read=False):
files = []
template_root = path_join(TEMPLATES_DIR, template_name)
if not dir_exists(template_root):
return files
for root, _, template_files in os.walk(template_root):
for template_file in template_files:
template_path = path_join(root, template_file)
file_path = template_path.replace(template_root, '')
file_path = '{}{}'.format(new_root, file_path.format(**config))
files.append(
File(
file_path,
template_path,
config,
read=read
)
)
return files
class File(object):
def __init__(self, file_path, template_path, config, read=False):
self.file_path = file_path
self.template_path = template_path
self.config = config
self.binary = template_path.endswith(BINARY_EXTENSIONS)
self._read = read_file_binary if self.binary else read_file
self._write = write_file_binary if self.binary else write_file
self.contents = None
if read:
self.read()
def read(self):
contents = self._read(self.template_path)
if self.binary:
self.contents = contents
else:
self.contents = contents.format(**self.config)
def write(self):
if self.contents is None:
create_file(self.file_path)
else:
ensure_parent_dir_exists(self.file_path)
self._write(self.file_path, self.contents)
| 30.719424 | 103 | 0.622951 | [
"BSD-3-Clause"
] | zaquaz/integrations-core | datadog_checks_dev/datadog_checks/dev/tooling/create.py | 4,270 | Python |
import numpy as np
import math
from chefboost.training import Training
#from training import Training
def processContinuousFeatures(algorithm, df, column_name, entropy, config):
#if True:
if df[column_name].nunique() <= 20:
unique_values = sorted(df[column_name].unique())
else:
unique_values = []
df_mean = df[column_name].mean()
df_std = df[column_name].std(ddof=0)
df_min = df[column_name].min()
df_max = df[column_name].max()
unique_values.append(df[column_name].min())
unique_values.append(df[column_name].max())
unique_values.append(df[column_name].mean())
scales = list(range(-3,+4, 1))
for scale in scales:
if df_mean + scale * df_std > df_min and df_mean + scale * df_std < df_max:
unique_values.append(df_mean + scale * df_std)
unique_values.sort()
#print(column_name,"->",unique_values)
subset_gainratios = []; subset_gains = []; subset_ginis = []; subset_red_stdevs = []; subset_chi_squares = []
if len(unique_values) == 1:
winner_threshold = unique_values[0]
df[column_name] = np.where(df[column_name] <= winner_threshold, "<="+str(winner_threshold), ">"+str(winner_threshold))
return df
for i in range(0, len(unique_values)-1):
threshold = unique_values[i]
subset1 = df[df[column_name] <= threshold]
subset2 = df[df[column_name] > threshold]
subset1_rows = subset1.shape[0]; subset2_rows = subset2.shape[0]
total_instances = df.shape[0] #subset1_rows+subset2_rows
subset1_probability = subset1_rows / total_instances
subset2_probability = subset2_rows / total_instances
if algorithm == 'ID3' or algorithm == 'C4.5':
threshold_gain = entropy - subset1_probability*Training.calculateEntropy(subset1, config) - subset2_probability*Training.calculateEntropy(subset2, config)
subset_gains.append(threshold_gain)
if algorithm == 'C4.5': #C4.5 also need gain in the block above. That's why, instead of else if we used direct if condition here
threshold_splitinfo = -subset1_probability * math.log(subset1_probability, 2)-subset2_probability*math.log(subset2_probability, 2)
gainratio = threshold_gain / threshold_splitinfo
subset_gainratios.append(gainratio)
elif algorithm == 'CART':
decision_for_subset1 = subset1['Decision'].value_counts().tolist()
decision_for_subset2 = subset2['Decision'].value_counts().tolist()
gini_subset1 = 1; gini_subset2 = 1
for j in range(0, len(decision_for_subset1)):
gini_subset1 = gini_subset1 - math.pow((decision_for_subset1[j]/subset1_rows),2)
for j in range(0, len(decision_for_subset2)):
gini_subset2 = gini_subset2 - math.pow((decision_for_subset2[j]/subset2_rows),2)
gini = (subset1_rows/total_instances)*gini_subset1 + (subset2_rows/total_instances) * gini_subset2
subset_ginis.append(gini)
elif algorithm == "CHAID":
#subset1 = high, subset2 = normal
unique_decisions = df['Decision'].unique() #Yes, No
num_of_decisions = len(unique_decisions) #2
subset1_expected = subset1.shape[0] / num_of_decisions
subset2_expected = subset2.shape[0] / num_of_decisions
chi_square = 0
for d in unique_decisions: #Yes, No
#decision = Yes
subset1_d = subset1[subset1["Decision"] == d] #high, yes
subset2_d = subset2[subset2["Decision"] == d] #normal, yes
subset1_d_chi_square = math.sqrt(((subset1_d.shape[0] - subset1_expected) * (subset1_d.shape[0] - subset1_expected))/subset1_expected)
subset2_d_chi_square = math.sqrt(((subset2_d.shape[0] - subset2_expected) * (subset2_d.shape[0] - subset2_expected))/subset2_expected)
chi_square = chi_square + subset1_d_chi_square + subset2_d_chi_square
subset_chi_squares.append(chi_square)
#----------------------------------
elif algorithm == 'Regression':
superset_stdev = df['Decision'].std(ddof=0)
subset1_stdev = subset1['Decision'].std(ddof=0)
subset2_stdev = subset2['Decision'].std(ddof=0)
threshold_weighted_stdev = (subset1_rows/total_instances)*subset1_stdev + (subset2_rows/total_instances)*subset2_stdev
threshold_reducted_stdev = superset_stdev - threshold_weighted_stdev
subset_red_stdevs.append(threshold_reducted_stdev)
#----------------------------------
if algorithm == "C4.5":
winner_one = subset_gainratios.index(max(subset_gainratios))
elif algorithm == "ID3": #actually, ID3 does not support for continuous features but we can still do it
winner_one = subset_gains.index(max(subset_gains))
elif algorithm == "CART":
winner_one = subset_ginis.index(min(subset_ginis))
elif algorithm == "CHAID":
winner_one = subset_chi_squares.index(max(subset_chi_squares))
elif algorithm == "Regression":
winner_one = subset_red_stdevs.index(max(subset_red_stdevs))
winner_threshold = unique_values[winner_one]
#print(column_name,": ", winner_threshold," in ", unique_values)
#print("theshold is ",winner_threshold," for ",column_name)
df[column_name] = np.where(df[column_name] <= winner_threshold, "<="+str(winner_threshold), ">"+str(winner_threshold))
return df
| 39.18797 | 158 | 0.700691 | [
"MIT"
] | ARTeriosclerosis/chefboost | chefboost/training/Preprocess.py | 5,212 | Python |
import math
import torch
import torch.nn as nn
import torch.utils.checkpoint as cp
from mmcv.cnn import (build_conv_layer, build_norm_layer, constant_init,
kaiming_init)
from mmcv.runner import load_checkpoint
from torch.nn.modules.batchnorm import _BatchNorm
from mmdet.utils import get_root_logger
from ..builder import BACKBONES
from .resnet import Bottleneck as _Bottleneck
from .resnet import ResNet
class Bottle2neck(_Bottleneck):
expansion = 4
def __init__(self,
inplanes,
planes,
scales=4,
base_width=26,
base_channels=64,
stage_type='normal',
**kwargs):
"""Bottle2neck block for Res2Net.
If style is "pytorch", the stride-two layer is the 3x3 conv layer, if
it is "caffe", the stride-two layer is the first 1x1 conv layer.
"""
super(Bottle2neck, self).__init__(inplanes, planes, **kwargs)
assert scales > 1, 'Res2Net degenerates to ResNet when scales = 1.'
width = int(math.floor(self.planes * (base_width / base_channels)))
self.norm1_name, norm1 = build_norm_layer(
self.norm_cfg, width * scales, postfix=1)
self.norm3_name, norm3 = build_norm_layer(
self.norm_cfg, self.planes * self.expansion, postfix=3)
self.conv1 = build_conv_layer(
self.conv_cfg,
self.inplanes,
width * scales,
kernel_size=1,
stride=self.conv1_stride,
bias=False)
self.add_module(self.norm1_name, norm1)
if stage_type == 'stage' and self.conv2_stride != 1:
self.pool = nn.AvgPool2d(
kernel_size=3, stride=self.conv2_stride, padding=1)
convs = []
bns = []
fallback_on_stride = False
if self.with_dcn:
fallback_on_stride = self.dcn.pop('fallback_on_stride', False)
if not self.with_dcn or fallback_on_stride:
for i in range(scales - 1):
convs.append(
build_conv_layer(
self.conv_cfg,
width,
width,
kernel_size=3,
stride=self.conv2_stride,
padding=self.dilation,
dilation=self.dilation,
bias=False))
bns.append(
build_norm_layer(self.norm_cfg, width, postfix=i + 1)[1])
self.convs = nn.ModuleList(convs)
self.bns = nn.ModuleList(bns)
else:
assert self.conv_cfg is None, 'conv_cfg must be None for DCN'
for i in range(scales - 1):
convs.append(
build_conv_layer(
self.dcn,
width,
width,
kernel_size=3,
stride=self.conv2_stride,
padding=self.dilation,
dilation=self.dilation,
bias=False))
bns.append(
build_norm_layer(self.norm_cfg, width, postfix=i + 1)[1])
self.convs = nn.ModuleList(convs)
self.bns = nn.ModuleList(bns)
self.conv3 = build_conv_layer(
self.conv_cfg,
width * scales,
self.planes * self.expansion,
kernel_size=1,
bias=False)
self.add_module(self.norm3_name, norm3)
self.stage_type = stage_type
self.scales = scales
self.width = width
delattr(self, 'conv2')
delattr(self, self.norm2_name)
def forward(self, x):
"""Forward function."""
def _inner_forward(x):
identity = x
out = self.conv1(x)
out = self.norm1(out)
out = self.relu(out)
if self.with_plugins:
out = self.forward_plugin(out, self.after_conv1_plugin_names)
spx = torch.split(out, self.width, 1)
sp = self.convs[0](spx[0].contiguous())
sp = self.relu(self.bns[0](sp))
out = sp
for i in range(1, self.scales - 1):
if self.stage_type == 'stage':
sp = spx[i]
else:
sp = sp + spx[i]
sp = self.convs[i](sp.contiguous())
sp = self.relu(self.bns[i](sp))
out = torch.cat((out, sp), 1)
if self.stage_type == 'normal' or self.conv2_stride == 1:
out = torch.cat((out, spx[self.scales - 1]), 1)
elif self.stage_type == 'stage':
out = torch.cat((out, self.pool(spx[self.scales - 1])), 1)
if self.with_plugins:
out = self.forward_plugin(out, self.after_conv2_plugin_names)
out = self.conv3(out)
out = self.norm3(out)
if self.with_plugins:
out = self.forward_plugin(out, self.after_conv3_plugin_names)
if self.downsample is not None:
identity = self.downsample(x)
out += identity
return out
if self.with_cp and x.requires_grad:
out = cp.checkpoint(_inner_forward, x)
else:
out = _inner_forward(x)
out = self.relu(out)
return out
class Res2Layer(nn.Sequential):
"""Res2Layer to build Res2Net style backbone.
Args:
block (nn.Module): block used to build ResLayer.
inplanes (int): inplanes of block.
planes (int): planes of block.
num_blocks (int): number of blocks.
stride (int): stride of the first block. Default: 1
avg_down (bool): Use AvgPool instead of stride conv when
downsampling in the bottle2neck. Default: False
conv_cfg (dict): dictionary to construct and config conv layer.
Default: None
norm_cfg (dict): dictionary to construct and config norm layer.
Default: dict(type='BN')
scales (int): Scales used in Res2Net. Default: 4
base_width (int): Basic width of each scale. Default: 26
"""
def __init__(self,
block,
inplanes,
planes,
num_blocks,
stride=1,
avg_down=True,
conv_cfg=None,
norm_cfg=dict(type='BN'),
scales=4,
base_width=26,
**kwargs):
self.block = block
downsample = None
if stride != 1 or inplanes != planes * block.expansion:
downsample = nn.Sequential(
nn.AvgPool2d(
kernel_size=stride,
stride=stride,
ceil_mode=True,
count_include_pad=False),
build_conv_layer(
conv_cfg,
inplanes,
planes * block.expansion,
kernel_size=1,
stride=1,
bias=False),
build_norm_layer(norm_cfg, planes * block.expansion)[1],
)
layers = []
layers.append(
block(
inplanes=inplanes,
planes=planes,
stride=stride,
downsample=downsample,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg,
scales=scales,
base_width=base_width,
stage_type='stage',
**kwargs))
inplanes = planes * block.expansion
for i in range(1, num_blocks):
layers.append(
block(
inplanes=inplanes,
planes=planes,
stride=1,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg,
scales=scales,
base_width=base_width,
**kwargs))
super(Res2Layer, self).__init__(*layers)
@BACKBONES.register_module()
class Res2Net(ResNet):
"""Res2Net backbone.
Args:
scales (int): Scales used in Res2Net. Default: 4
base_width (int): Basic width of each scale. Default: 26
depth (int): Depth of res2net, from {50, 101, 152}.
in_channels (int): Number of input image channels. Default: 3.
num_stages (int): Res2net stages. Default: 4.
strides (Sequence[int]): Strides of the first block of each stage.
dilations (Sequence[int]): Dilation of each stage.
out_indices (Sequence[int]): Output from which stages.
style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two
layer is the 3x3 conv layer, otherwise the stride-two layer is
the first 1x1 conv layer.
deep_stem (bool): Replace 7x7 conv in input stem with 3 3x3 conv
avg_down (bool): Use AvgPool instead of stride conv when
downsampling in the bottle2neck.
frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
-1 means not freezing any parameters.
norm_cfg (dict): Dictionary to construct and config norm layer.
norm_eval (bool): Whether to set norm layers to eval mode, namely,
freeze running stats (mean and var). Note: Effect on Batch Norm
and its variants only.
plugins (list[dict]): List of plugins for stages, each dict contains:
- cfg (dict, required): Cfg dict to build plugin.
- position (str, required): Position inside block to insert
plugin, options are 'after_conv1', 'after_conv2', 'after_conv3'.
- stages (tuple[bool], optional): Stages to apply plugin, length
should be same as 'num_stages'.
with_cp (bool): Use checkpoint or not. Using checkpoint will save some
memory while slowing down the training speed.
zero_init_residual (bool): Whether to use zero init for last norm layer
in resblocks to let them behave as identity.
Example:
>>> from mmdet.models import Res2Net
>>> import torch
>>> self = Res2Net(depth=50, scales=4, base_width=26)
>>> self.eval()
>>> inputs = torch.rand(1, 3, 32, 32)
>>> level_outputs = self.forward(inputs)
>>> for level_out in level_outputs:
... print(tuple(level_out.shape))
(1, 256, 8, 8)
(1, 512, 4, 4)
(1, 1024, 2, 2)
(1, 2048, 1, 1)
"""
arch_settings = {
50: (Bottle2neck, (3, 4, 6, 3)),
101: (Bottle2neck, (3, 4, 23, 3)),
152: (Bottle2neck, (3, 8, 36, 3))
}
def __init__(self,
scales=4,
base_width=26,
style='pytorch',
deep_stem=True,
avg_down=True,
**kwargs):
self.scales = scales
self.base_width = base_width
super(Res2Net, self).__init__(
style='pytorch', deep_stem=True, avg_down=True, **kwargs)
def make_res_layer(self, **kwargs):
return Res2Layer(
scales=self.scales,
base_width=self.base_width,
base_channels=self.base_channels,
**kwargs)
def init_weights(self, pretrained=None):
"""Initialize the weights in backbone.
Args:
pretrained (str, optional): Path to pre-trained weights.
Defaults to None.
"""
if isinstance(pretrained, str):
logger = get_root_logger()
load_checkpoint(self, pretrained, strict=False, logger=logger)
elif pretrained is None:
for m in self.modules():
if isinstance(m, nn.Conv2d):
kaiming_init(m)
elif isinstance(m, (_BatchNorm, nn.GroupNorm)):
constant_init(m, 1)
if self.dcn is not None:
for m in self.modules():
if isinstance(m, Bottle2neck):
# dcn in Res2Net bottle2neck is in ModuleList
for n in m.convs:
if hasattr(n, 'conv_offset'):
constant_init(n.conv_offset, 0)
if self.zero_init_residual:
for m in self.modules():
if isinstance(m, Bottle2neck):
constant_init(m.norm3, 0)
else:
raise TypeError('pretrained must be a str or None')
| 36.008523 | 79 | 0.527732 | [
"MIT"
] | 007gzs/insightface | detection/scrfd/mmdet/models/backbones/res2net.py | 12,675 | Python |
"""
eveparser.parsers.assets
~~~~~~~~~~~~~~~~~~~~~~~
Parse eve online asset lists. This also invludes inventory listings.
"""
import re
from eveparser.utils import regex_match_lines, f_int
ASSET_LIST_RE = re.compile(r"""^([\S ]*) # name
\t([\d,'\.]*) # quantity
(\t([\S ]*))? # group
(\t([\S ]*))? # category
(\t(XLarge|Large|Medium|Small|))? # size
(\t(High|Medium|Low|Rigs|[\d ]*))? # slot
(\t([\d ,\.]* m3))? # volume
(\t([\d]+|))? # meta level
(\t([\d]+|))?$ # tech level
""", re.X)
def parse_assets(lines):
""" Parse asset list
:param string paste_string: An asset list string
"""
matches, bad_lines = regex_match_lines(ASSET_LIST_RE, lines)
result = [{'name': name,
'quantity': f_int(quantity) or 1,
'group': group,
'category': category,
'size': size,
'slot': slot,
'volume': volume,
'meta_level': meta_level,
'tech_level': tech_level}
for (name,
quantity,
_, group,
_, category,
_, size,
_, slot,
_, volume,
_, meta_level,
_, tech_level) in matches]
return result, bad_lines
| 35.346939 | 79 | 0.363164 | [
"MIT"
] | Nothing4You/eveparser | eveparser/parsers/assets.py | 1,732 | Python |
import os
import platform
import threading
from asyncio import current_task, iscoroutinefunction
from collections.abc import Coroutine
from contextlib import AsyncExitStack
from datetime import datetime, timezone
from functools import partial
from logging import Logger, getLogger
from traceback import format_exc
from typing import Any, Callable, Dict, Optional, Set
from anyio import create_event, create_task_group, open_cancel_scope, run_sync_in_worker_thread
from anyio.abc import CancelScope, Event, TaskGroup
from ..abc import DataStore, Job
from ..events import EventHub, JobDeadlineMissed, JobFailed, JobSuccessful, JobUpdated
class AsyncWorker(EventHub):
"""Runs jobs locally in a task group."""
_task_group: Optional[TaskGroup] = None
_stop_event: Optional[Event] = None
_running: bool = False
_running_jobs: int = 0
_acquire_cancel_scope: Optional[CancelScope] = None
def __init__(self, data_store: DataStore, *, max_concurrent_jobs: int = 100,
identity: Optional[str] = None, logger: Optional[Logger] = None,
run_sync_functions_in_event_loop: bool = True):
super().__init__()
self.data_store = data_store
self.max_concurrent_jobs = max_concurrent_jobs
self.identity = identity or f'{platform.node()}-{os.getpid()}-{threading.get_ident()}'
self.logger = logger or getLogger(__name__)
self.run_sync_functions_in_event_loop = run_sync_functions_in_event_loop
self._acquired_jobs: Set[Job] = set()
self._exit_stack = AsyncExitStack()
if self.max_concurrent_jobs < 1:
raise ValueError('max_concurrent_jobs must be at least 1')
async def __aenter__(self):
await self._exit_stack.__aenter__()
# Initialize the data store
await self._exit_stack.enter_async_context(self.data_store)
# Start the actual worker
self._task_group = create_task_group()
await self._exit_stack.enter_async_context(self._task_group)
start_event = create_event()
await self._task_group.spawn(self.run, start_event)
await start_event.wait()
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
await self.stop(force=exc_type is not None)
await self._exit_stack.__aexit__(exc_type, exc_val, exc_tb)
async def run(self, start_event: Optional[Event] = None) -> None:
self._stop_event = create_event()
self._running = True
if start_event:
await start_event.set()
while self._running:
limit = self.max_concurrent_jobs - self._running_jobs
jobs = []
async with open_cancel_scope() as self._acquire_cancel_scope:
try:
jobs = await self.data_store.acquire_jobs(self.identity, limit)
finally:
del self._acquire_cancel_scope
for job in jobs:
await self._task_group.spawn(self._run_job, job)
await self._stop_event.set()
del self._stop_event
del self._task_group
async def _run_job(self, job: Job) -> None:
# Check if the job started before the deadline
now = datetime.now(timezone.utc)
if job.start_deadline is not None:
if now.timestamp() > job.start_deadline.timestamp():
self.logger.info('Missed the deadline of job %r', job.id)
event = JobDeadlineMissed(
now, job_id=job.id, task_id=job.task_id, schedule_id=job.schedule_id,
scheduled_fire_time=job.scheduled_fire_time, start_time=now,
start_deadline=job.start_deadline
)
await self.publish(event)
return
# Set the job as running and publish a job update event
self.logger.info('Started job %r', job.id)
job.started_at = now
event = JobUpdated(
timestamp=now, job_id=job.id, task_id=job.task_id, schedule_id=job.schedule_id
)
await self.publish(event)
self._running_jobs += 1
try:
return_value = await self._call_job_func(job.func, job.args, job.kwargs)
except BaseException as exc:
self.logger.exception('Job %r raised an exception', job.id)
event = JobFailed(
timestamp=datetime.now(timezone.utc), job_id=job.id, task_id=job.task_id,
schedule_id=job.schedule_id, scheduled_fire_time=job.scheduled_fire_time,
start_time=now, start_deadline=job.start_deadline,
traceback=format_exc(), exception=exc
)
else:
self.logger.info('Job %r completed successfully', job.id)
event = JobSuccessful(
timestamp=datetime.now(timezone.utc), job_id=job.id, task_id=job.task_id,
schedule_id=job.schedule_id, scheduled_fire_time=job.scheduled_fire_time,
start_time=now, start_deadline=job.start_deadline, return_value=return_value
)
self._running_jobs -= 1
await self.data_store.release_jobs(self.identity, [job])
await self.publish(event)
async def _call_job_func(self, func: Callable, args: tuple, kwargs: Dict[str, Any]):
if not self.run_sync_functions_in_event_loop and not iscoroutinefunction(func):
wrapped = partial(func, *args, **kwargs)
return await run_sync_in_worker_thread(wrapped)
return_value = func(*args, **kwargs)
if isinstance(return_value, Coroutine):
return_value = await return_value
return return_value
async def stop(self, force: bool = False) -> None:
self._running = False
if self._acquire_cancel_scope:
await self._acquire_cancel_scope.cancel()
if force and self._task_group:
await self._task_group.cancel_scope.cancel()
async def wait_until_stopped(self) -> None:
if self._stop_event:
await self._stop_event.wait()
| 40.278146 | 95 | 0.65735 | [
"MIT"
] | Ghosque/apscheduler | apscheduler/workers/async_.py | 6,082 | Python |
#!/usr/bin/env python3
import json
import os, sys, os.path
import string
from configparser import ConfigParser
J2_CONF_PATH='autobuild/configs/'
def write_file(filename, data):
with open(filename, "w") as fname:
json.dump(data, fname, indent = 4)
return
def get_wallet_conf(path):
wallet_conf_parser = ConfigParser()
with open(path) as wallet_stream:
wallet_conf_parser.read_string("[top]\n" + wallet_stream.read())
return dict(wallet_conf_parser.items('top'))
def get_xbridge_conf(path, ticker):
xbridge_conf_parser = ConfigParser()
xbridge_conf_parser.read(path)
return dict(xbridge_conf_parser.items(ticker))
with open('manifest.json') as json_file:
data = json.load(json_file)
tickers = list(set([chain['ticker'] for chain in data]))
tickers.sort(key = lambda t:t, reverse = False)
for ticker in tickers:
chains = [chain for chain in data if chain['ticker'] == ticker]
chains.sort(key = lambda c:c['ver_id'], reverse = False)
template_data = {}
# get latest version
latest_version_chain = chains[-1]
xbridge_conf_data = get_xbridge_conf('xbridge-confs/' + latest_version_chain['xbridge_conf'], latest_version_chain['ticker'])
wallet_conf_data = get_wallet_conf('wallet-confs/' + latest_version_chain['wallet_conf'])
template_data['Title'] = xbridge_conf_data['title']
template_data['Address'] = xbridge_conf_data['address']
template_data['Ip'] = xbridge_conf_data['ip']
template_data['rpcPort'] = '{{ rpcPort|default(' + wallet_conf_data['rpcport'] + ')}}'
template_data['p2pPort'] = '{{ p2pPort|default(' + wallet_conf_data['port'] + ')}}'
template_data['Username'] = '{{ rpcusername }}'
template_data['Password'] = '{{ rpcpassword }}'
if 'addressprefix' in xbridge_conf_data:
template_data['AddressPrefix'] = xbridge_conf_data['addressprefix']
if 'scriptprefix' in xbridge_conf_data:
template_data['ScriptPrefix'] = xbridge_conf_data['scriptprefix']
if 'secretprefix' in xbridge_conf_data:
template_data['SecretPrefix'] = xbridge_conf_data['secretprefix']
if 'coin' in xbridge_conf_data:
template_data['COIN'] = xbridge_conf_data['coin']
if 'minimumamount' in xbridge_conf_data:
template_data['MinimumAmount'] = xbridge_conf_data['minimumamount']
if 'dustamount' in xbridge_conf_data:
template_data['DustAmount'] = xbridge_conf_data['dustamount']
if 'createtxmethod' in xbridge_conf_data:
template_data['CreateTxMethod'] = xbridge_conf_data['createtxmethod']
if 'getnewkeysupported' in xbridge_conf_data:
template_data['GetNewKeySupported'] = xbridge_conf_data['getnewkeysupported']
if 'importwithnoscansupported' in xbridge_conf_data:
template_data['ImportWithNoScanSupported'] = xbridge_conf_data['importwithnoscansupported']
if 'mintxfee' in xbridge_conf_data:
template_data['MinTxFee'] = xbridge_conf_data['mintxfee']
if 'blocktime' in xbridge_conf_data:
template_data['BlockTime'] = xbridge_conf_data['blocktime']
if 'txversion' in xbridge_conf_data:
template_data['TxVersion'] = xbridge_conf_data['txversion']
if 'feeperbyte' in xbridge_conf_data:
template_data['FeePerByte'] = xbridge_conf_data['feeperbyte']
if 'confirmations' in xbridge_conf_data:
template_data['Confirmations'] = xbridge_conf_data['confirmations']
coin_base_j2_data_versions = {}
for chain in chains:
wallet_conf_data = get_wallet_conf('wallet-confs/' + chain['wallet_conf'])
xbridge_conf_data = get_xbridge_conf('xbridge-confs/' + chain['xbridge_conf'], chain['ticker'])
# get first of versions list of chain
version = chain['versions'][0]
coin_base_j2_data_versions[version] = {
'legacy': 'addresstype' in wallet_conf_data,
'deprecatedrpc': 'deprecatedrpc' in wallet_conf_data,
'xbridge_conf': chain['xbridge_conf'],
'wallet_conf': chain['wallet_conf'],
'GetNewKeySupported': 'GetNewKeySupported' in xbridge_conf_data
}
template_data['versions'] = coin_base_j2_data_versions
template = {}
template[ticker] = template_data
write_file(J2_CONF_PATH + chain['ticker'].lower() + '.base.j2', template)
print(','.join(tickers)) | 45.460784 | 133 | 0.659694 | [
"MIT"
] | mastrip2/blockchain-configuration-files | autobuild/create-j2-confs.py | 4,637 | Python |
from electrum.plugins import hook
from .digitalbitbox import DigitalBitboxPlugin
from ..hw_wallet import CmdLineHandler
class Plugin(DigitalBitboxPlugin):
handler = CmdLineHandler()
@hook
def init_keystore(self, keystore):
if not isinstance(keystore, self.keystore_class):
return
keystore.handler = self.handler
| 29.416667 | 57 | 0.736544 | [
"MIT"
] | AlecZadikian9001/electrum | plugins/digitalbitbox/cmdline.py | 353 | Python |
"""
interface.py
DNAC parsers for the following show commands:
* /dna/intent/api/v1/interface
"""
import os
import logging
import pprint
import re
import unittest
from genie import parsergen
from collections import defaultdict
from ats.log.utils import banner
from genie.metaparser import MetaParser
from genie.metaparser.util import merge_dict, keynames_convert
from genie.metaparser.util.schemaengine import Schema, \
Any, \
Optional, \
Or, \
And, \
Default, \
Use
# import parser utils
from genie.libs.parser.utils.common import Common
logger = logging.getLogger(__name__)
# ============================================
# Schema for '/dna/intent/api/v1/interface'
# ============================================
class InterfaceSchema(MetaParser):
"""schema for /dna/intent/api/v1/interface, /dna/intent/api/v1/interface/{interface}"""
schema = {
Any(): {
"adminStatus": str,
Optional("className"): str,
Optional("description"): str,
"deviceId": str,
Optional("duplex"): str,
Optional("id"): str,
"ifIndex": str,
Optional("instanceTenantId"): str,
Optional("instanceUuid"): str,
"interfaceType": str,
Optional("ipv4Address"): str,
Optional("ipv4Mask"): str,
"isisSupport": str,
"lastUpdated": str,
Optional("macAddress"): str,
Optional("mappedPhysicalInterfaceId"): str,
Optional("mappedPhysicalInterfaceName"): str,
Optional("mediaType"): str,
Optional("nativeVlanId"): str,
"ospfSupport": str,
"pid": str,
"portMode": str,
"portName": str,
Optional("portType"): str,
"serialNo": str,
"series": str,
Optional("speed"): str,
"status": str,
Optional("vlanId"): str,
Optional("voiceVlan"): str
}
}
# ============================================
# Parser for '/dna/intent/api/v1/interface'
# ============================================
class Interface(InterfaceSchema):
"""parser for /dna/intent/api/v1/interface, /dna/intent/api/v1/interface/{interface}"""
cli_command = ['/dna/intent/api/v1/interface', '/dna/intent/api/v1/interface/{interface}']
def cli(self,interface="", output=None):
if output is None:
if interface:
cmd = self.cli_command[1].format(interface=interface)
else:
cmd = self.cli_command[0]
out = self.device.get(cmd).json()['response']
else:
out = output
result_dict={}
for intf_dict in out:
# remove None values
result_dict[intf_dict['portName']] = {k: v for k, v in intf_dict.items() if v is not None}
return result_dict
| 35.806122 | 102 | 0.455685 | [
"Apache-2.0"
] | devbollinger/genieparser | src/genie/libs/parser/dnac/interface.py | 3,509 | Python |
###############################################################################
# Name: __init__.py #
# Purpose: Import the required base modules needed for launching Editra into #
# into the namespace. #
# Author: Cody Precord <[email protected]> #
# Copyright: (c) 2007 Cody Precord <[email protected]> #
# Licence: wxWindows Licence #
###############################################################################
"""Main package module"""
__author__ = "Cody Precord <[email protected]>"
__svnid__ = "$Id: __init__.py 49807 2007-11-10 07:08:33Z CJP $"
__revision__ = "$Revision: 49807 $"
| 58.357143 | 79 | 0.383109 | [
"MIT"
] | CrankySupertoon01/Toontown-2 | dependencies/panda/Panda3D-1.10.0-x64/python/Lib/site-packages/wx-3.0-msw/wx/tools/Editra/src/__init__.py | 817 | Python |
import pytest
from temp import (download_to_file, ensure_datafile, records_from_lines, make_record, make_value, min_spread_record,
min_spread_day_num, parse_header)
def test_download_to_file(tmpdir):
file = tmpdir.join('test.txt')
download_to_file(file.strpath, 'https://httpbin.org/get?testParam=1')
assert 'testParam' in file.read()
def test_ensure_datafile_downloads(tmpdir):
file = tmpdir.join('test.txt')
ensure_datafile(file.strpath, 'https://httpbin.org/get?testParam=1')
assert 'testParam' in file.read()
def test_ensure_datafile_uses_existing(tmpdir):
file = tmpdir.join('test.txt')
file.write('content')
ensure_datafile(file.strpath, 'https://httpbin.org/get?testParam=1')
assert file.read() == 'content'
def test_make_record():
header = {'One': (0, 1), 'Two': (3, 3), 'Three': (7, 2), 'Four': (10, 4)}
line = "1 2.2 3* FOUR"
rv = make_record(header, line)
assert set(rv.keys()) == set(header)
assert all(list(rv.values()))
def test_parse_header_rv():
rv = parse_header(" One Two Three")
assert len(rv) == 3
assert rv['One'] == (1, 4)
assert rv['Two'] == (5, 4)
assert rv['Three'] == (9, 6)
def test_make_value():
assert make_value('123') == 123
assert make_value('ASDF') == 'ASDF'
assert make_value('123.45') == 123.45
assert make_value('123*') == 123
assert make_value(' ') == None
def test_records_from_lines_skips_empty():
lines = iter(['One', ' ', 'Two'])
assert len(list(records_from_lines(lines))) == 1
def test_min_spread_record_rv():
records = [
{'max': 10, 'min': 0},
{'max': 1, 'min': 0}, # this one should be returned
{'max': None, 'min': None}
]
assert min_spread_record(records, 'max', 'min') == {'max': 1, 'min': 0}
def test_min_spread_day_num_rv():
records = [
{'Dy': 1, 'MxT': 10, 'MnT': 0},
{'Dy': 2, 'MxT': 5, 'MnT': 0},
]
rv = min_spread_day_num(records)
assert rv == 2
| 28.366197 | 116 | 0.619662 | [
"MIT"
] | notapresent/codekata | python/kata04/test_temp.py | 2,014 | Python |
# -*- coding: utf-8 -*-
import scrapy
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule
from scrapy_splash import SplashRequest
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import sys
from ..utils import extract_CN_from_content
from ..items import ScrapySpiderItem
import re
import requests
class A55CrawlSpider(CrawlSpider):
name = '55_crawl'
allowed_domains = ['fsx.sxxz.gov.cn']
# start_urls = ['http://fsx.sxxz.gov.cn/fsxzw/zwgk/xxgkzn/']
start_urls = ['http://fsx.sxxz.gov.cn/fsxzw/zwgk/wj/']
# start_urls = ['http://fsx.sxxz.gov.cn/fsxzw/zwgk/jgsz_6342/']
rules = (
Rule(LinkExtractor(restrict_xpaths='/html/body/div[2]/div/div[1]/ul/li[5]/ul/li/ul//li'), follow=True),
Rule(LinkExtractor(restrict_xpaths='/html/body/div[2]/div/div[1]/ul/li[5]/ul/li/ul/li[1]/dl//dd'), follow=True),
Rule(LinkExtractor(restrict_xpaths='/html/body/div[2]/div/div[1]/ul/li[5]/ul/li/ul/li[5]/dl//dd'), follow=True),
Rule(LinkExtractor(restrict_xpaths='/html/body/div[2]/div/div[1]/ul/li[5]/ul/li/ul/li[10]/dl//dd'), follow=True),
Rule(LinkExtractor(allow=r'/\d+/t\d+_\d+\.html'), callback='parse_item', follow=True),
Rule(LinkExtractor(restrict_xpaths='//*[@id="searchsection"]/div[2]/a[3]'), follow=True),
Rule(LinkExtractor(allow=r'index_\d+\.html/'), follow=True),
)
# def start_requests(self):
# for url in self.start_urls:
# yield scrapy.Request(url)
def _build_request(self, rule, link):
r = SplashRequest(url=link.url, callback=self._response_downloaded, args={"wait": 0.5})
r.meta.update(rule=rule, link_text=link.text)
return r
def _requests_to_follow(self, response):
# if not isinstance(response, HtmlResponse):
# return
seen = set()
for n, rule in enumerate(self._rules):
links = [lnk for lnk in rule.link_extractor.extract_links(response)
if lnk not in seen]
if links and rule.process_links:
links = rule.process_links(links)
for link in links:
seen.add(link)
r = self._build_request(n, link)
yield rule.process_request(r)
def parse_item(self, response):
try:
item = ScrapySpiderItem()
item['url'] = response.url
date = response.xpath('/html/body/div[2]/div/div/div[1]/p').extract_first()
date = re.search(r"(\d{4}-\d{2}-\d{2})", date).groups()[0]
item['date'] = date
title = response.xpath('/html/body/div[2]/div/div/div[1]/h2[1]/text()').extract_first()
item['title'] = title
contents = response.xpath('//div[@class="article-con"]').extract()
item['contents'] = extract_CN_from_content(contents)
return item
except:
try:
item = ScrapySpiderItem()
item['url'] = response.url
date = response.xpath('/html/body/div[2]/div/div/div[2]/p').extract_first()
date = re.search(r"(\d{4}-\d{2}-\d{2})", date).groups()[0]
item['date'] = date
title = response.xpath('/html/body/div[2]/div/div/div[2]/h2/text()').extract_first()
item['title'] = title
contents = response.xpath('//div[@class="article-con"]').extract()
item['contents'] = extract_CN_from_content(contents)
return item
except:
try:
item = ScrapySpiderItem()
item['url'] = response.url
date = response.xpath('/html/body/div[3]/div[2]/div/div[1]/ul/li[8]').extract_first()
date = re.search(r"(\d{4}年\d{2}月\d{2}日)", date).groups()[0]
item['date'] = date
title = response.xpath('/html/body/div[3]/div[2]/div/div[1]/ul/li[6]/text()').extract_first()
item['title'] = title
contents = response.xpath('//div[@class="article-body"]').extract()
item['contents'] = extract_CN_from_content(contents)
return item
except:
pass
| 41.701923 | 121 | 0.572516 | [
"Apache-2.0"
] | senlyu163/crawler | spiders/a55_crawl.py | 4,343 | Python |
from sys import argv
from requests import get
import re
app_name = argv[1]
result = get('https://nvd.nist.gov/view/vuln/search-results?query={0}'.format(app_name))
cves = re.findall(r"CVE-\d{4}-\d+", result.text)
for cve in reversed(cves):
result = get('https://nvd.nist.gov/vuln/detail/' + cve)
cpes = re.findall(r">(cpe.*?)</a>", result.text)
if cpes:
print("{0}.tb:{1}".format(app_name, cpes[0]))
break
| 27.0625 | 88 | 0.642032 | [
"Apache-2.0"
] | FCG-LLC/aucote | scripts/what_web_fetch_cpes.py | 433 | Python |
from ..remote import RemoteModel
from infoblox_netmri.utils.utils import check_api_availability
class SpmHistoryEndHostHistoryGridRemote(RemoteModel):
"""
This table lists the end host history within the user specified period of time for a given end host.
| ``id:`` The internal NetMRI identifier of the grid entry.
| ``attribute type:`` number
| ``FirstSeen:`` The timestamp of when NetMRI first discovered this end host.
| ``attribute type:`` datetime
| ``LastSeen:`` The timestamp of when NetMRI last polled data from this end host.
| ``attribute type:`` datetime
| ``HostIPNumeric:`` The numerical value of the end host IP address.
| ``attribute type:`` number
| ``HostIPAddress:`` The management IP address of the end host, in dotted (or colon-delimited for IPv6) format.
| ``attribute type:`` string
| ``HostName:`` The NetMRI name of the end host; this will be either the same as DeviceSysName or DeviceDNSName, depending on your NetMRI configuration.
| ``attribute type:`` string
| ``DeviceID:`` The NetMRI internal identifier for the switch.
| ``attribute type:`` number
| ``DeviceType:`` The NetMRI-determined device type of the switch.
| ``attribute type:`` string
| ``DeviceName:`` The NetMRI name of the switch; this will be either the same as DeviceSysName or DeviceDNSName, depending on your NetMRI configuration.
| ``attribute type:`` string
| ``InterfaceID:`` The internal NetMRI identifier for the interface on the switch configured with this address.
| ``attribute type:`` number
| ``ifIndex:`` The SNMP interface index of the interface on the switch configured with this address.
| ``attribute type:`` string
| ``Interface:`` The interface on the switch configured with this address.
| ``attribute type:`` string
| ``ifMAC:`` The interface Media Access Controller (MAC) address of this interface.
| ``attribute type:`` string
| ``ifOperStatus:`` The operational status (up/down) of this interface.
| ``attribute type:`` string
| ``VlanIndex:`` The numerical VLAN number (VLAN ID).
| ``attribute type:`` number
| ``VlanName:`` The name of the VLAN on the root bridge.
| ``attribute type:`` string
| ``VlanID:`` The internal NetMRI identifier of the VLAN.
| ``attribute type:`` number
| ``VTPDomain:`` Management domain name if VLAN is VTP managed.
| ``attribute type:`` string
| ``Network:`` The name of the Network View associated.
| ``attribute type:`` string
| ``VirtualNetworkID:`` Internal identifier for the network view.
| ``attribute type:`` number
| ``HostMAC:`` The MAC Address of the end host.
| ``attribute type:`` string
"""
properties = ("id",
"FirstSeen",
"LastSeen",
"HostIPNumeric",
"HostIPAddress",
"HostName",
"DeviceID",
"DeviceType",
"DeviceName",
"InterfaceID",
"ifIndex",
"Interface",
"ifMAC",
"ifOperStatus",
"VlanIndex",
"VlanName",
"VlanID",
"VTPDomain",
"Network",
"VirtualNetworkID",
"HostMAC",
)
| 30.857143 | 157 | 0.566176 | [
"Apache-2.0"
] | IngmarVG-IB/infoblox-netmri | infoblox_netmri/api/remote/models/spm_history_end_host_history_grid_remote.py | 3,672 | Python |
# -*- Python -*-
import os
import platform
import re
import lit.formats
# Get shlex.quote if available (added in 3.3), and fall back to pipes.quote if
# it's not available.
try:
import shlex
sh_quote = shlex.quote
except:
import pipes
sh_quote = pipes.quote
def get_required_attr(config, attr_name):
attr_value = getattr(config, attr_name, None)
if attr_value == None:
lit_config.fatal(
"No attribute %r in test configuration! You may need to run "
"tests from your build directory or add this attribute "
"to lit.site.cfg.py " % attr_name)
return attr_value
# Setup config name.
config.name = 'MemProfiler' + config.name_suffix
# Platform-specific default MEMPROF_OPTIONS for lit tests.
default_memprof_opts = list(config.default_sanitizer_opts)
default_memprof_opts_str = ':'.join(default_memprof_opts)
if default_memprof_opts_str:
config.environment['MEMPROF_OPTIONS'] = default_memprof_opts_str
config.substitutions.append(('%env_memprof_opts=',
'env MEMPROF_OPTIONS=' + default_memprof_opts_str))
# Setup source root.
config.test_source_root = os.path.dirname(__file__)
libdl_flag = '-ldl'
# Setup default compiler flags used with -fmemory-profile option.
# FIXME: Review the set of required flags and check if it can be reduced.
target_cflags = [get_required_attr(config, 'target_cflags')]
target_cxxflags = config.cxx_mode_flags + target_cflags
clang_memprof_static_cflags = (['-fmemory-profile',
'-mno-omit-leaf-frame-pointer',
'-fno-omit-frame-pointer',
'-fno-optimize-sibling-calls'] +
config.debug_info_flags + target_cflags)
clang_memprof_static_cxxflags = config.cxx_mode_flags + clang_memprof_static_cflags
memprof_dynamic_flags = []
if config.memprof_dynamic:
memprof_dynamic_flags = ['-shared-libsan']
config.available_features.add('memprof-dynamic-runtime')
else:
config.available_features.add('memprof-static-runtime')
clang_memprof_cflags = clang_memprof_static_cflags + memprof_dynamic_flags
clang_memprof_cxxflags = clang_memprof_static_cxxflags + memprof_dynamic_flags
def build_invocation(compile_flags):
return ' ' + ' '.join([config.clang] + compile_flags) + ' '
config.substitutions.append( ("%clang ", build_invocation(target_cflags)) )
config.substitutions.append( ("%clangxx ", build_invocation(target_cxxflags)) )
config.substitutions.append( ("%clang_memprof ", build_invocation(clang_memprof_cflags)) )
config.substitutions.append( ("%clangxx_memprof ", build_invocation(clang_memprof_cxxflags)) )
if config.memprof_dynamic:
shared_libmemprof_path = os.path.join(config.compiler_rt_libdir, 'libclang_rt.memprof{}.so'.format(config.target_suffix))
config.substitutions.append( ("%shared_libmemprof", shared_libmemprof_path) )
config.substitutions.append( ("%clang_memprof_static ", build_invocation(clang_memprof_static_cflags)) )
config.substitutions.append( ("%clangxx_memprof_static ", build_invocation(clang_memprof_static_cxxflags)) )
# Some tests uses C++11 features such as lambdas and need to pass -std=c++11.
config.substitutions.append(("%stdcxx11 ", '-std=c++11 '))
config.substitutions.append( ("%libdl", libdl_flag) )
config.available_features.add('memprof-' + config.bits + '-bits')
config.available_features.add('fast-unwinder-works')
# Set LD_LIBRARY_PATH to pick dynamic runtime up properly.
new_ld_library_path = os.path.pathsep.join(
(config.compiler_rt_libdir, config.environment.get('LD_LIBRARY_PATH', '')))
config.environment['LD_LIBRARY_PATH'] = new_ld_library_path
# Default test suffixes.
config.suffixes = ['.c', '.cpp']
config.substitutions.append(('%fPIC', '-fPIC'))
config.substitutions.append(('%fPIE', '-fPIE'))
config.substitutions.append(('%pie', '-pie'))
# Only run the tests on supported OSs.
if config.host_os not in ['Linux']:
config.unsupported = True
if not config.parallelism_group:
config.parallelism_group = 'shadow-memory'
| 38.653846 | 123 | 0.746766 | [
"Apache-2.0"
] | AaronBallman/llvm | compiler-rt/test/memprof/lit.cfg.py | 4,020 | Python |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# Copyright (c) 2017-2020 Rhilip <[email protected]>
import re
import time
from flask import Blueprint, request, jsonify
from app import mysql, app, cache
from pymysql import escape_string
ptboard_blueprint = Blueprint('ptboard', __name__)
search_default = app.config.get("PTBOARD_SEARCH", "")
site_default = app.config.get("PTBOARD_SITE", "")
no_site_default = app.config.get("PTBOARD_NO_SITE", "")
order_default = app.config.get("PTBOARD_ORDER", "desc")
limit_default = app.config.get("PTBOARD_LIMIT", 100)
offset_default = app.config.get("PTBOARD_OFFSET", 0)
start_time_default = app.config.get("PTBOARD_START_TIME", 0)
end_time_default = app.config.get("PTBOARD_END_TIME", "CURRENT_TIMESTAMP")
predb_prefix = "https://trace.corrupt-net.org/?q="
def recover_int_to_default(value, default):
try:
ret = int(value)
except(ValueError, TypeError):
ret = default
return ret
def warp_str(string):
return "({})".format(string)
@ptboard_blueprint.route("/ptboard", methods=["GET"])
def ptboard():
t0 = time.time()
ret = {
"success": False,
"error": None
}
token = request.args.get("token") or ""
@cache.memoize(timeout=86400)
def token_valid(token_):
if len(token_) != 32:
return False
row, data = mysql.exec("SELECT * FROM `api`.`ptboard_token` WHERE token = %s", token_, ret_row=True)
if row > 0:
return True
else:
return False
if not token_valid(token):
ret["error"] = "Token is not exist."
return jsonify(ret)
mysql.exec('UPDATE `api`.`ptboard_token` set `useage_count` = `useage_count` + 1 WHERE token = %s', (token,))
# 1. Get user requests
search_raw = request.args.get("search") or search_default
order_raw = request.args.get("order") or order_default
site_raw = request.args.get("site") or site_default
no_site_raw = request.args.get("no_site") or no_site_default
limit = request.args.get("limit") or limit_default
offset = request.args.get("offset") or offset_default
start_time = request.args.get("start_time") or start_time_default
end_time = request.args.get("end_time") or end_time_default
# 2. Clean user requests
search = re.sub(r"[ _\-,.+]", " ", search_raw)
search = search.split()
search = list(filter(lambda l: len(l) > 1, search)) # Remove those too short letter
search = search[:10]
search_opt = site_opt = no_site_opt = "1=1"
if search:
search_opt = warp_str(" AND ".join(map(lambda i: "title LIKE '%{}%'".format(escape_string(i)), search)))
start_time = recover_int_to_default(start_time, start_time_default)
end_time = recover_int_to_default(end_time, end_time_default)
time_opt = warp_str("ptboard_record.pubDate BETWEEN {start} AND {end}".format(start=start_time, end=end_time))
@cache.cached(timeout=86400)
def get_site_list():
return [i[0] for i in mysql.exec("SELECT `site` FROM `api`.`ptboard_site`", fetch_all=True)]
site_list = get_site_list()
site = list(filter(lambda i: i in site_list, site_raw.split(",")))
no_site = list(filter(lambda i: i in site_list, no_site_raw.split(",")))
if site:
site_opt = warp_str(" OR ".join(["ptboard_record.site = '{site}'".format(site=s) for s in site]))
if no_site:
no_site_opt = warp_str(" AND ".join(["ptboard_record.site != '{site}'".format(site=s) for s in no_site]))
limit = recover_int_to_default(limit, limit_default)
offset = recover_int_to_default(offset, offset_default)
if limit > 200:
limit = 200
order = "desc" if order_raw.lower() not in ["desc", "asc"] else order_raw
# 3. Get response data from Database
opt = " AND ".join([time_opt, site_opt, no_site_opt, search_opt])
sql = ("SELECT ptboard_record.sid, ptboard_site.site, ptboard_record.title, "
"concat(ptboard_site.torrent_prefix,ptboard_record.sid, ptboard_site.torrent_suffix) AS link, "
"ptboard_record.pubDate FROM api.ptboard_record "
"INNER JOIN api.ptboard_site ON api.ptboard_site.site = api.ptboard_record.site "
"WHERE {opt} ORDER BY `pubDate` {_da} "
"LIMIT {_offset}, {_limit}".format(opt=opt, _da=order.upper(), _offset=offset, _limit=limit)
)
record_count, rows_data = mysql.exec(sql=sql, r_dict=True, fetch_all=True, ret_row=True)
# 4. Sort Response data
if app.config.get("DEBUG"):
ret["sql"] = sql
def fix_predb(d: dict):
if d["site"] == "PreDB":
d["link"] = predb_prefix + d["title"].split(" | ")[1]
return d
ret.update({
"success": True,
"rows": list(map(fix_predb, rows_data)),
"total": record_count if search else mysql.exec("SELECT count(*) FROM `api`.`ptboard_record`")[0],
})
ret["cost"] = time.time() - t0
return jsonify(ret)
| 35.669065 | 114 | 0.656313 | [
"MIT"
] | Rhilip/PT-help | modules/ptboard/__init__.py | 4,958 | Python |
import os
import unittest
from unit import Unit
from unit.models.authorization import *
class AuthorizationsE2eTests(unittest.TestCase):
token = os.environ.get("token")
client = Unit("https://api.s.unit.sh", token)
def test_list_and_get_authorization(self):
authorizations = self.client.authorizations.list()
for authorization in authorizations.data:
response = self.client.authorizations.get(authorization.id)
self.assertTrue(response.data.type == "authorization")
def test_list_with_parameters(self):
params = AuthorizationListParams(10, 0, "", "49423")
authorizations = self.client.authorizations.list(params)
for authorization in authorizations.data:
response = self.client.authorizations.get(authorization.id)
self.assertTrue(response.data.type == "authorization")
def test_list_with_wrong_parameters(self):
params = AuthorizationListParams(10, 0, "", "-1")
response = self.client.authorizations.list(params)
self.assertTrue(response.data == [])
if __name__ == '__main__':
unittest.main()
| 34.484848 | 71 | 0.695958 | [
"MPL-2.0",
"MPL-2.0-no-copyleft-exception"
] | unit-finance/unit-python-sdk | e2e_tests/authorization_test.py | 1,138 | Python |
# -*- coding: utf-8 -*- #
# Copyright 2014 Google LLC. 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.
"""Common classes and functions for zones."""
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
from googlecloudsdk.api_lib.compute import request_helper
from googlecloudsdk.api_lib.compute import utils
from googlecloudsdk.calliope import exceptions as calliope_exceptions
from googlecloudsdk.core.console import console_io
class ZoneResourceFetcher(object):
"""A (small) collection of utils for working with zones."""
def __init__(self, compute_client):
"""Instantiate ZoneResourceFetcher and embed all required data into it.
ZoneResourceFetcher is a class depending on "base_classes"
class layout (properties side-derived from one of base_class class). This
function can be used to avoid unfeasible inheritance and use composition
instead when refactoring away from base_classes into stateless style.
This constructor embeds following properties into ZoneResourceFetcher
instance:
- compute
- messages
- http
- batch_url
Example:
compute_holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = compute_holder.client
zone_resource_fetcher = ZoneResourceFetcher(client)
or
zone_resource_fetcher = ZoneResourceFetcher(self.compute_client)
to use in a class derived from some of base_classes
zone_resource_fetcher.WarnForZonalCreation(...)
Args:
compute_client: compute_holder.client
"""
self._compute = compute_client.apitools_client
self._messages = compute_client.messages
self._http = compute_client.apitools_client.http
self._batch_url = compute_client.batch_url
def GetZones(self, resource_refs):
"""Fetches zone resources."""
errors = []
requests = []
zone_names = set()
for resource_ref in resource_refs:
if resource_ref.zone not in zone_names:
zone_names.add(resource_ref.zone)
requests.append((
self._compute.zones,
'Get',
self._messages.ComputeZonesGetRequest(
project=resource_ref.project,
zone=resource_ref.zone)))
res = list(request_helper.MakeRequests(
requests=requests,
http=self._http,
batch_url=self._batch_url,
errors=errors))
if errors:
return None
else:
return res
def WarnForZonalCreation(self, resource_refs):
"""Warns the user if a zone has upcoming deprecation."""
zones = self.GetZones(resource_refs)
if not zones:
return
prompts = []
zones_with_deprecated = []
for zone in zones:
if zone.deprecated:
zones_with_deprecated.append(zone)
if not zones_with_deprecated:
return
if zones_with_deprecated:
phrases = []
if len(zones_with_deprecated) == 1:
phrases = ('zone is', 'this zone', 'the')
else:
phrases = ('zones are', 'these zones', 'their')
title = ('\n'
'WARNING: The following selected {0} deprecated.'
' All resources in {1} will be deleted after'
' {2} turndown date.'.format(phrases[0], phrases[1], phrases[2]))
printable_deprecated_zones = []
for zone in zones_with_deprecated:
if zone.deprecated.deleted:
printable_deprecated_zones.append(('[{0}] {1}').format(zone.name,
zone.deprecated
.deleted))
else:
printable_deprecated_zones.append('[{0}]'.format(zone.name))
prompts.append(utils.ConstructList(title, printable_deprecated_zones))
final_message = ' '.join(prompts)
if not console_io.PromptContinue(message=final_message):
raise calliope_exceptions.ToolException('Creation aborted by user.')
| 35.0625 | 80 | 0.679367 | [
"MIT"
] | bopopescu/JobSniperRails | gcloud/google-cloud-sdk/.install/.backup/lib/googlecloudsdk/api_lib/compute/zone_utils.py | 4,488 | Python |
"""
Implementation of gaussian filter algorithm
"""
from cv2 import imread, cvtColor, COLOR_BGR2GRAY, imshow, waitKey
from numpy import pi, mgrid, exp, square, zeros, ravel, dot, uint8
from itertools import product
def gen_gaussian_kernel(k_size, sigma):
center = k_size // 2
x, y = mgrid[0 - center : k_size - center, 0 - center : k_size - center]
g = 1 / (2 * pi * sigma) * exp(-(square(x) + square(y)) / (2 * square(sigma)))
return g
def gaussian_filter(image, k_size, sigma):
height, width = image.shape[0], image.shape[1]
# dst image height and width
dst_height = height - k_size + 1
dst_width = width - k_size + 1
# im2col, turn the k_size*k_size pixels into a row and np.vstack all rows
image_array = zeros((dst_height * dst_width, k_size * k_size))
row = 0
for i, j in product(range(dst_height), range(dst_width)):
window = ravel(image[i : i + k_size, j : j + k_size])
image_array[row, :] = window
row += 1
# turn the kernel into shape(k*k, 1)
gaussian_kernel = gen_gaussian_kernel(k_size, sigma)
filter_array = ravel(gaussian_kernel)
# reshape and get the dst image
dst = dot(image_array, filter_array).reshape(dst_height, dst_width).astype(uint8)
return dst
if __name__ == "__main__":
# read original image
img = imread(r"../image_data/lena.jpg")
# turn image in gray scale value
gray = cvtColor(img, COLOR_BGR2GRAY)
# get values with two different mask size
gaussian3x3 = gaussian_filter(gray, 3, sigma=1)
gaussian5x5 = gaussian_filter(gray, 5, sigma=0.8)
# show result images
imshow("gaussian filter with 3x3 mask", gaussian3x3)
imshow("gaussian filter with 5x5 mask", gaussian5x5)
waitKey()
| 32.537037 | 85 | 0.669892 | [
"MIT"
] | 13261922481/Python | digital_image_processing/filters/gaussian_filter.py | 1,757 | Python |
# Copyright (C) 2018-2021 Intel Corporation
# SPDX-License-Identifier: Apache-2.0
import os
import re
import tensorflow as tf
import numpy as np
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
def load_graph(model_file, output_nodes_for_freeze=None):
is_meta = os.path.splitext(model_file)[-1] == ".meta"
tf.compat.v1.reset_default_graph()
graph = tf.Graph()
graph_def = tf.compat.v1.GraphDef() if not is_meta else tf.compat.v1.MetaGraphDef()
with open(model_file, "rb") as f:
graph_def.ParseFromString(f.read())
nodes_to_clear_device = graph_def.node if isinstance(graph_def, tf.compat.v1.GraphDef) else graph_def.graph_def.node
for node in nodes_to_clear_device:
node.device = ""
if is_meta:
with tf.compat.v1.Session() as sess:
restorer = tf.compat.v1.train.import_meta_graph(graph_def)
restorer.restore(sess, re.sub('\.meta$', '', model_file))
graph_def = tf.compat.v1.graph_util.convert_variables_to_constants(sess, graph_def.graph_def, output_nodes_for_freeze)
with graph.as_default():
tf.import_graph_def(graph_def, name='')
return graph
def collect_tf_references(model_path, feed_dict, out_layer, output_nodes_for_freeze=None):
_feed_dict = dict()
graph = load_graph(model_path, output_nodes_for_freeze)
output_tensors_list = list()
outputs_list = list()
for input in feed_dict:
input_node = [node for node in graph.as_graph_def().node if node.name == input][0]
if input_node.op == "Placeholder":
tensor = graph.get_tensor_by_name(input + ":0")
_feed_dict[tensor] = feed_dict[input]
else:
for parrent_input in input_node.input:
in_node = [node for node in graph.as_graph_def().node if node.name == parrent_input][0]
if in_node.op in ['Const', 'Assign', 'NoOp', 'Assert']:
continue
else:
tensor = graph.get_tensor_by_name(parrent_input + ":0")
_feed_dict[tensor] = feed_dict[input]
for output in out_layer:
tensor = graph.get_tensor_by_name(output + ":0")
output_tensors_list.append(tensor)
outputs_list.append(output)
with graph.as_default():
with tf.compat.v1.Session(graph=graph) as sess:
outputs = sess.run(output_tensors_list, feed_dict=_feed_dict)
out_dict = dict(zip(outputs_list, outputs))
return out_dict
def children(op, graph):
op = graph.get_operation_by_name(op)
return set(op for out in op.outputs for op in out.consumers())
def summarize_graph(model_path, output_nodes_for_freeze=None, reshape_net=None):
placeholders = dict()
variables = list()
outputs = list()
graph = load_graph(model_path, output_nodes_for_freeze)
unlikely_output_types = ['Const', 'Assign', 'NoOp', 'Placeholder', 'Assert', 'switch_t', 'switch_f']
for node in graph.as_graph_def().node:
if node.op == 'Placeholder':
node_dict = dict()
node_dict['type'] = tf.DType(node.attr['dtype'].type).name
node_dict['shape'] = str(node.attr['shape'].shape.dim).replace('\n', '').replace(' ', '').replace(
'size:', '').replace('[', '').replace(']', '')
node_dict['shape'] = tuple(map(lambda x: int(x), node_dict['shape'].split(',')))
placeholders[node.name] = node_dict
if node.op == "Variable" or node.op == "VariableV2":
variables.append(node.name)
if len(children(node.name, graph)) == 0:
if node.op not in unlikely_output_types and node.name.split('/')[-1] not in unlikely_output_types:
outputs.append(node.name)
result = dict()
result['inputs'] = placeholders
result['outputs'] = outputs
if reshape_net:
out_layer = list(result['inputs'].keys()) + result['outputs']
feed_dict = {}
for inputl in reshape_net:
feed_dict.update({inputl: np.ones(shape=reshape_net[inputl])})
scoring_res = collect_tf_references(model_path=model_path, feed_dict=feed_dict, out_layer=out_layer)
for layer in scoring_res:
if layer in result['inputs']:
result['inputs'][layer]['shape'] = scoring_res[layer].shape
return result
| 39.336364 | 130 | 0.645251 | [
"Apache-2.0"
] | AkillesAILimited/openvino | tests/layer_tests/common/utils/tf_utils.py | 4,327 | Python |
# content of test_electricity.py
from premise import DATA_DIR
from premise.electricity import Electricity
from premise.data_collection import IAMDataCollection
REGION_MAPPING_FILEPATH = (DATA_DIR / "regionmappingH12.csv")
PRODUCTION_PER_TECH = (DATA_DIR / "electricity" / "electricity_production_volumes_per_tech.csv")
LOSS_PER_COUNTRY = (DATA_DIR / "electricity" / "losses_per_country.csv")
LHV_FUELS = (DATA_DIR / "fuels_lower_heating_value.txt")
def get_db():
dummy_db = [{
'name': 'fake activity',
'reference product': 'fake product',
'location': 'IAI Area, Africa',
'unit': 'kilogram',
'exchanges': [
{'name': 'fake activity',
'product': 'fake product',
'amount': 1,
'type': 'production',
'unit': 'kilogram',
'input': ('dummy_db', '6543541'), },
{'name': '1,4-Butanediol',
'categories': ('air', 'urban air close to ground'),
'amount': 1,
'type': 'biosphere',
'unit': 'kilogram',
'input': ('dummy_bio', '123'),
},
]
}]
version = 3.5
return dummy_db, version
rdc = IAMDataCollection(model="remind", pathway='SSP2-Base', year=2012, filepath_iam_files=DATA_DIR / "iam_output_files")
db, _ = get_db()
el = Electricity(db=db, iam_data=rdc, model="remind", pathway='SSP2-Base', year=2012)
def test_losses():
assert len(el.losses) == 174
assert el.losses['AL']['Production volume'] == 7630
def test_fuels_lhv():
assert float(el.fuels_lhv['hard coal']) == 20.1
def test_powerplant_map():
s = el.powerplant_map['Biomass IGCC CCS']
assert isinstance(s, set)
def test_emissions_map():
s = el.emissions_map['Sulfur dioxide']
assert isinstance(s, str)
| 30.25 | 121 | 0.616529 | [
"BSD-3-Clause"
] | kais-siala/premise | tests/test_electricity.py | 1,815 | Python |
#!/usr/bin/python2.6
'''
Creates a MyU3 class that adds higher-level functionality to the base
LabJack U3 class.
'''
from __future__ import division
import u3
from time import sleep
import math
def getU3(**kargs):
'''Returns an open MyU3 object but retries until successful if errors occur.'''
while True:
try:
return MyU3(**kargs)
except:
sleep(2)
print('Trying to Open U3...')
class MyU3(u3.U3):
'''
Class that adds some functionality to the base u3.U3 class, which
operates a U3 data acquisition device.
'''
def __init__(self, **kargs):
# call the constructor in the base class
u3.U3.__init__(self, **kargs)
def getRMS(self, ch, signalFreq=60, numCycles=4):
'''
Returns the RMS voltage of a stream of readings on a channel.
'ch' is the channel to sample.
'signalFreq' is the fundamental frequency of the signal being sampled.
'numCycles' is the number of full cycles of the signal that you want to
sample for purposes of calculating the RMS value.
I found that for 60 Hz signals, sampling 4 cycles produces stable
readings.
NOTE: there are limits to the frequency calculation below. Getting
a packet from the U3 in streaming mode is limited to 1 second I think,
and it will reduces the # of samples if the frequency is set so that
less than 1200 samples arrive in 1 second.
'''
# There are 1200 samples in one streaming request of the U3. Calculate
# the required streaming frequency from that and the other input parameters.
freq = int(signalFreq / numCycles * 1200.0)
freq = min(50000, freq) # cap at 50 kHz
# the U3 must operate at lower resolution if the streaming is very fast.
if freq < 2500:
resolution = 0
elif freq < 10000:
resolution = 1
elif freq < 20000:
resolution = 2
else:
resolution = 3
self.streamConfig( NumChannels = 1,
PChannels = [ ch ],
NChannels = [ 31 ], # 31 indicates single-ended read
Resolution = resolution,
SampleFrequency = freq )
try:
self.streamStart()
for r in self.streamData():
# calculate the sum of the squares, average that, and take square root
# to determine RMS
vals = r['AIN' + str(ch)]
sum_sqr = reduce(lambda x,y: x + y*y, vals, 0.0)
return math.sqrt(sum_sqr / len(vals))
finally:
self.streamStop()
def getAvg(self, ch, reads=8, specialRange=False, longSettle=True):
'''
Returns an analog reading of channel 'ch', but samples
multiple times = 'reads' and then averages. If 'specialRange'
is True, uses the higher voltage range for the channel.
If 'longSettle' is True, a higher source impedance can be tolerated.
'''
if specialRange:
negCh = 32
else:
negCh = 31
tot = 0.0
for i in range(reads):
tot += self.getAIN(ch, negCh, longSettle=longSettle)
return tot / reads
# Could add a routine to average an analog reading across
# 4 60 Hz cycles using the stream function as in getRMS().
def getDutyCycle(self, timer, reads=8):
'''
Returns the duty cycle measured by a timer. Assumes that the timer is already
set to Mode = 4 for reading duty cycles.
timer - the timer number, either 0 or 1.
reads - the number of times to read the duty cycle and average
'''
tot = 0.0 # used to average the duty cycle readings
for i in range(reads):
val = self.getFeedback(u3.Timer(timer=timer))[0]
hi = float(val % 2**16)
lo = float(val / 2**16)
tot += hi / (lo + hi)
return tot / reads
if __name__=='__main__':
# create the device object
d = MyU3()
# Set all possible inputs to Analog
# Create a bit mask indicating which channels are analog:
FIOEIOAnalog = ( 2 ** 16 ) - 1;
fios = FIOEIOAnalog & (0xFF) # the bottom 8 bits
eios = FIOEIOAnalog/256 # shift 8 places to get top 8 bits
d.configIO( FIOAnalog = fios, EIOAnalog = int(eios) )
try:
while True:
#print '%.3f' % d.getAvg(6)
#print '%.2f' % ( (d.getAvg(30) - 273.15)*1.8 + 32.0 )
print '%.3f' % d.getRMS(6)
sleep(0.5)
finally:
d.close() | 32.29078 | 84 | 0.597408 | [
"Apache-2.0"
] | dayne/mini-monitor | readers/myU3.py | 4,553 | Python |
import os
import threading
import uuid
from ipaddress import ip_address, ip_interface, ip_network
import yaml
from django.db import models
from ansible_api.models.mixins import AbstractExecutionModel
from cloud_provider import get_cloud_client
from common import models as common_models
from fit2ansible import settings
from django.utils.translation import ugettext_lazy as _
from kubeops_api.models.host import Host
class CloudProviderTemplate(models.Model):
id = models.UUIDField(default=uuid.uuid4, primary_key=True)
name = models.CharField(max_length=20, unique=True, verbose_name=_('Name'))
meta = common_models.JsonTextField(blank=True, null=True, verbose_name=_('Meta'))
date_created = models.DateTimeField(auto_now_add=True, verbose_name=_('Date created'))
template_dir = os.path.join(settings.BASE_DIR, 'resource', 'clouds')
@property
def path(self):
return os.path.join(self.template_dir, self.name)
@classmethod
def lookup(cls):
for d in os.listdir(cls.template_dir):
full_path = os.path.join(cls.template_dir, d)
meta_path = os.path.join(full_path, 'meta.yml')
if not os.path.isdir(full_path) or not os.path.isfile(meta_path):
continue
with open(meta_path) as f:
metadata = yaml.load(f)
defaults = {'name': d, 'meta': metadata}
cls.objects.update_or_create(defaults=defaults, name=d)
class Region(models.Model):
id = models.UUIDField(default=uuid.uuid4, primary_key=True)
name = models.CharField(max_length=20, unique=True, verbose_name=_('Name'))
date_created = models.DateTimeField(auto_now_add=True, verbose_name=_('Date created'))
template = models.ForeignKey('CloudProviderTemplate', on_delete=models.SET_NULL, null=True)
cloud_region = models.CharField(max_length=128, null=True, default=None)
vars = common_models.JsonDictTextField(default={})
comment = models.CharField(max_length=128, blank=True, null=True, verbose_name=_("Comment"))
@property
def zone_size(self):
zones = Zone.objects.filter(region=self)
return len(zones)
@property
def cluster_size(self):
clusters = []
plans = Plan.objects.filter(region=self)
for plan in plans:
from kubeops_api.models.cluster import Cluster
cs = Cluster.objects.filter(plan=plan)
for c in cs:
clusters.append(c)
return len(clusters)
@property
def image_ovf_path(self):
return self.vars['image_ovf_path']
@property
def image_vmdk_path(self):
return self.vars['image_vmdk_path']
@property
def image_name(self):
return self.vars['image_name']
def set_vars(self):
meta = self.template.meta.get('region', None)
if meta:
_vars = meta.get('vars', {})
self.vars.update(_vars)
self.save()
def on_region_create(self):
self.set_vars()
def to_dict(self):
dic = {
"region": self.cloud_region
}
dic.update(self.vars)
return dic
class Zone(models.Model):
ZONE_STATUS_READY = "READY"
ZONE_STATUS_INITIALIZING = "INITIALIZING"
ZONE_STATUS_ERROR = "ERROR"
ZONE_STATUS_CHOICES = (
(ZONE_STATUS_READY, 'READY'),
(ZONE_STATUS_INITIALIZING, 'INITIALIZING'),
(ZONE_STATUS_ERROR, 'ERROR'),
)
id = models.UUIDField(default=uuid.uuid4, primary_key=True)
name = models.CharField(max_length=20, unique=True, verbose_name=_('Name'))
date_created = models.DateTimeField(auto_now_add=True, verbose_name=_('Date created'))
vars = common_models.JsonDictTextField(default={})
region = models.ForeignKey('Region', on_delete=models.CASCADE, null=True)
cloud_zone = models.CharField(max_length=128, null=True, default=None)
ip_used = common_models.JsonListTextField(null=True, default=[])
status = models.CharField(max_length=64, choices=ZONE_STATUS_CHOICES, null=True)
@property
def host_size(self):
hosts = Host.objects.filter(zone=self)
return len(hosts)
def change_status(self, status):
self.status = status
self.save()
def create_image(self):
try:
self.change_status(Zone.ZONE_STATUS_INITIALIZING)
client = get_cloud_client(self.region.vars)
client.create_image(zone=self)
self.change_status(Zone.ZONE_STATUS_READY)
except Exception as e:
self.change_status(Zone.ZONE_STATUS_ERROR)
def on_zone_create(self):
thread = threading.Thread(target=self.create_image)
thread.start()
def allocate_ip(self):
ip = self.ip_pools().pop()
self.ip_used.append(ip)
self.save()
return ip
def recover_ip(self, ip):
self.ip_used.remove(ip)
self.save()
def to_dict(self):
dic = {
"key": "z" + str(self.id).split("-")[3],
"name": self.cloud_zone,
"zone_name": self.name,
"ip_pool": self.ip_pools()
}
dic.update(self.vars)
return dic
def ip_pools(self):
ip_pool = []
ip_start = ip_address(self.vars['ip_start'])
ip_end = ip_address(self.vars['ip_end'])
if self.region.template.name == 'openstack':
while ip_start <= ip_end:
ip_pool.append(str(ip_start))
ip_start += 1
for ip in self.ip_used:
if ip in ip_pool:
ip_pool.remove(ip)
return ip_pool
net_mask = self.vars['net_mask']
interface = ip_interface("{}/{}".format(str(ip_start), net_mask))
network = interface.network
for host in network.hosts():
if ip_start <= host <= ip_end:
ip_pool.append(str(host))
for ip in self.ip_used:
if ip in ip_pool:
ip_pool.remove(ip)
return ip_pool
def ip_available_size(self):
return len(self.ip_pools())
@property
def provider(self):
return self.region.template.name
class Plan(models.Model):
DEPLOY_TEMPLATE_SINGLE = "SINGLE"
DEPLOY_TEMPLATE_MULTIPLE = "MULTIPLE"
DEPLOY_TEMPLATE_CHOICES = (
(DEPLOY_TEMPLATE_SINGLE, 'single'),
(DEPLOY_TEMPLATE_MULTIPLE, 'multiple'),
)
id = models.UUIDField(default=uuid.uuid4, primary_key=True)
name = models.CharField(max_length=20, unique=True, verbose_name=_('Name'))
date_created = models.DateTimeField(auto_now_add=True, verbose_name=_('Date created'))
zone = models.ForeignKey('Zone', null=True, on_delete=models.CASCADE)
region = models.ForeignKey('Region', null=True, on_delete=models.CASCADE)
zones = models.ManyToManyField('Zone', related_name='zones')
deploy_template = models.CharField(choices=DEPLOY_TEMPLATE_CHOICES, default=DEPLOY_TEMPLATE_SINGLE, max_length=128)
vars = common_models.JsonDictTextField(default={})
@property
def mixed_vars(self):
_vars = self.vars.copy()
_vars.update(self.region.to_dict())
zones = self.get_zones()
zone_dicts = []
for zone in zones:
zone_dicts.append(zone.to_dict())
_vars['zones'] = zone_dicts
return _vars
def get_zones(self):
zones = []
if self.zone:
zones.append(self.zone)
if self.zones:
zones.extend(self.zones.all())
return zones
@property
def compute_models(self):
return {
"master": self.vars.get('master_model', None),
"worker": self.vars.get('worker_model', None)
}
| 33.626087 | 119 | 0.641195 | [
"Apache-2.0"
] | 99fu/KubeOperator | api/cloud_provider/models.py | 7,734 | Python |
class DirectionNotDetermined(BaseException):
def __init__(self, message="Hand did not move in only one direction. Direction of movement cannot be determined."):
self.message = message
super().__init__(self.message)
class ConfigError(BaseException):
def __init__(self, message="Possible error in syntax of config."):
self.message = message
super().__init__(self.message)
class GestureNotDetermined(BaseException):
def __init__(self, message="The Gesture did not match with any registered gestures"):
self.message = message
super().__init__(self.message)
| 35 | 119 | 0.703175 | [
"MIT"
] | david-0609/OpenCV-Hand-Gesture-Control | modules/Exceptions.py | 630 | Python |
import asyncio
import collections
import math
import signal
import sys
from functools import wraps
class Spy(object):
"""Spy is the debugging system for farc.
farc contains a handful of Spy.on_*() methods
placed at useful locations in the framework.
It is up to a Spy driver (such as the included VcdSpy)
to implement the Spy.on_*() methods.
The programmer calls Spy.enable_spy(<Spy implementation class>)
to activate the Spy system; otherwise, Spy does nothing.
Therefore, this class is designed so that calling Spy.anything()
is inert unless the application first calls Spy.enable_spy()
"""
_actv_cls = None
@staticmethod
def enable_spy(spy_cls):
"""Sets the Spy to use the given class
and calls its initializer.
"""
Spy._actv_cls = spy_cls
spy_cls.init()
def __getattr__(*args):
"""Returns
1) the enable_spy static method if requested by name, or
2) the attribute from the active class (if active class was set), or
3) a function that swallows any arguments and does nothing.
"""
if args[1] == "enable_spy":
return Spy.enable_spy
if Spy._actv_cls:
return getattr(Spy._actv_cls, args[1])
return lambda *x: None
# Singleton pattern:
# Turn Spy into an instance of itself so __getattribute__ works
# on anyone who calls "import Spy; Spy.foo()"
# This prevents Spy() from creating a new instance
# and gives everyone who calls "import Spy" the same object
Spy = Spy()
class Signal(object):
"""An asynchronous stimulus that triggers reactions.
A unique identifier that, along with a value, specifies an Event.
p. 154
"""
_registry = {} # signame:str to sigid:int
_lookup = [] # sigid:int to signame:str
@staticmethod
def exists(signame):
"""Returns True if signame is in the Signal registry.
"""
return signame in Signal._registry
@staticmethod
def register(signame):
"""Registers the signame if it is not already registered.
Returns the signal number for the signame.
"""
assert type(signame) is str
if signame in Signal._registry:
# TODO: emit warning that signal is already registered
return Signal._registry[signame]
else:
sigid = len(Signal._lookup)
Signal._registry[signame] = sigid
Signal._lookup.append(signame)
Spy.on_signal_register(signame, sigid)
return sigid
def __getattr__(self, signame):
assert type(signame) is str
return Signal._registry[signame]
# Singleton pattern:
# Turn Signal into an instance of itself so getattr works.
# This also prevents Signal() from creating a new instance.
Signal = Signal()
# Register the reserved (system) signals
Signal.register("EMPTY") # 0
Signal.register("ENTRY") # 1
Signal.register("EXIT") # 2
Signal.register("INIT") # 3
# Signals that mirror POSIX signals
Signal.register("SIGINT") # (i.e. Ctrl+C)
Signal.register("SIGTERM") # (i.e. kill <pid>)
Event = collections.namedtuple("Event", ["signal", "value"])
Event.__doc__ = """Events are a tuple of (signal, value) that are passed from
one AHSM to another. Signals are defined in each AHSM's source code
by name, but resolve to a unique number. Values are any python value,
including containers that contain even more values. Each AHSM state
(static method) accepts an Event as the parameter and handles the event
based on its Signal."""
# Instantiate the reserved (system) events
Event.EMPTY = Event(Signal.EMPTY, None)
Event.ENTRY = Event(Signal.ENTRY, None)
Event.EXIT = Event(Signal.EXIT, None)
Event.INIT = Event(Signal.INIT, None)
# Events for POSIX signals
Event.SIGINT = Event(Signal.SIGINT, None) # (i.e. Ctrl+C)
Event.SIGTERM = Event(Signal.SIGTERM, None) # (i.e. kill <pid>)
# The order of this tuple MUST match their respective signals
Event.reserved = (Event.EMPTY, Event.ENTRY, Event.EXIT, Event.INIT)
class Hsm(object):
"""A Hierarchical State Machine (HSM).
Full support for hierarchical state nesting.
Guaranteed entry/exit action execution on arbitrary state transitions.
Full support of nested initial transitions.
Support for events with arbitrary parameters.
"""
# Every state handler must return one of these values
RET_HANDLED = 0
RET_IGNORED = 1
RET_TRAN = 2
RET_SUPER = 3
def __init__(self,):
"""Sets this Hsm's current state to Hsm.top(), the default state
and stores the given initial state.
"""
# self.state is the Hsm/act's current active state.
# This instance variable references the message handler (method)
# that will be called whenever a message is sent to this Hsm.
# We initialize this to self.top, the default message handler
self.state = self.top
# Farc differs from QP here in that we hardcode
# the initial state to be "_initial"
self.initial_state = self._initial
def _initial(self, event):
"""Raises a NotImplementedError to force the derived class
to implement its own initial state.
"""
raise NotImplementedError
def state(func):
"""A decorator that identifies which methods are states.
The presence of the farc_state attr, not the value of the attr,
determines statehood.
The Spy debugging system uses the farc_state attribute
to determine which methods inside a class are actually states.
Other uses of the attribute may come in the future.
"""
@wraps(func)
def func_wrap(self, evt):
result = func(self, evt)
Spy.on_state_handler_called(func_wrap, evt, result)
return result
setattr(func_wrap, "farc_state", True)
return staticmethod(func_wrap)
# Helper functions to process reserved events through the current state
@staticmethod
def trig(me, state_func, signal): return state_func(me, Event.reserved[signal])
@staticmethod
def enter(me, state_func): return state_func(me, Event.ENTRY)
@staticmethod
def exit(me, state_func): return state_func(me, Event.EXIT)
# Other helper functions
@staticmethod
def handled(me, event): return Hsm.RET_HANDLED
@staticmethod
def tran(me, nextState): me.state = nextState; return Hsm.RET_TRAN
@staticmethod
def super(me, superState): me.state = superState; return Hsm.RET_SUPER # p. 158
@state
def top(me, event):
"""This is the default state handler.
This handler ignores all signals except
the POSIX-like events, SIGINT/SIGTERM.
Handling SIGINT/SIGTERM here causes the Exit path
to be executed from the application's active state
to top/here.
The application may put something useful
or nothing at all in the Exit path.
"""
# Handle the Posix-like events to force the HSM
# to execute its Exit path all the way to the top
if Event.SIGINT == event:
return Hsm.RET_HANDLED
if Event.SIGTERM == event:
return Hsm.RET_HANDLED
# All other events are quietly ignored
return Hsm.RET_IGNORED # p. 165
@staticmethod
def _perform_init_chain(me, current):
"""Act on the chain of initializations required starting from current.
"""
t = current
while Hsm.trig(me, t if t != Hsm.top else me.initial_state, Signal.INIT) == Hsm.RET_TRAN:
# The state handles the INIT message and needs to make a transition. The
# "top" state is special in that it does not handle INIT messages, so we
# defer to me.initial_state in this case
path = [] # Trace the path back to t via superstates
while me.state != t:
path.append(me.state)
Hsm.trig(me, me.state, Signal.EMPTY)
# Restore the state to the target state
me.state = path[0]
assert len(path) < 32 # MAX_NEST_DEPTH
# Perform ENTRY action for each state from current to the target
path.reverse() # in-place
for s in path:
Hsm.enter(me, s)
# The target state has now to be checked to see if it responds to the INIT message
t = path[-1] # -1 because path was reversed
return t
@staticmethod
def _perform_transition(me, source, target):
# Handle the state transition from source to target in the HSM.
s, t = source, target
path = [t]
if s == t: # Case (a), transition to self
Hsm.exit(me,s)
Hsm.enter(me,t)
else:
# Find parent of target
Hsm.trig(me, t, Signal.EMPTY)
t = me.state # t is now parent of target
if s == t: # Case (b), source is parent of target
Hsm.enter(me, path[0])
else:
# Find parent of source
Hsm.trig(me, s, Signal.EMPTY)
if me.state == t: # Case (c), source and target share a parent
Hsm.exit(me, s)
Hsm.enter(me, path[0])
else:
if me.state == path[0]: # Case (d), target is parent of source
Hsm.exit(me, s)
else: # Check if the source is an ancestor of the target (case (e))
lca_found = False
path.append(t) # Populates path[1]
t = me.state # t is now parent of source
# Find and save ancestors of target into path
# until we find the source or hit the top
me.state = path[1]
while me.state != Hsm.top:
Hsm.trig(me, me.state, Signal.EMPTY)
path.append(me.state)
assert len(path) < 32 # MAX_NEST_DEPTH
if me.state == s:
lca_found = True
break
if lca_found: # This is case (e), enter states to get to target
for st in reversed(path[:-1]):
Hsm.enter(me, st)
else:
Hsm.exit(me, s) # Exit the source for cases (f), (g), (h)
me.state = t # Start at parent of the source
while me.state not in path:
# Keep exiting up into superstates until we reach the LCA.
# Depending on whether the EXIT signal is handled, we may also need
# to send the EMPTY signal to make me.state climb to the superstate.
if Hsm.exit(me, me.state) == Hsm.RET_HANDLED:
Hsm.trig(me, me.state, Signal.EMPTY)
t = me.state
# Step into children until we enter the target
for st in reversed(path[:path.index(t)]):
Hsm.enter(me, st)
@staticmethod
def init(me, event = None):
"""Transitions to the initial state. Follows any INIT transitions
from the inital state and performs ENTRY actions as it proceeds.
Use this to pass any parameters to initialize the state machine.
p. 172
"""
# TODO: The initial state MUST transition to another state
# The code that formerly did this was:
# status = me.initial_state(me, event)
# assert status == Hsm.RET_TRAN
# But the above code is commented out so an Ahsm's _initial()
# isn't executed twice.
me.state = Hsm._perform_init_chain(me, Hsm.top)
@staticmethod
def dispatch(me, event):
"""Dispatches the given event to this Hsm.
Follows the application's state transitions
until the event is handled or top() is reached
p. 174
"""
Spy.on_hsm_dispatch_event(event)
# Save the current state
t = me.state
# Proceed to superstates if event is not handled, we wish to find the superstate
# (if any) that does handle the event and to record the path to that state
exit_path = []
r = Hsm.RET_SUPER
while r == Hsm.RET_SUPER:
s = me.state
exit_path.append(s)
Spy.on_hsm_dispatch_pre(s)
r = s(me, event) # invoke state handler
# We leave the while loop with s at the state which was able to respond
# to the event, or to Hsm.top if none did
Spy.on_hsm_dispatch_post(exit_path)
# If the state handler for s requests a transition
if r == Hsm.RET_TRAN:
t = me.state
# Store target of transition
# Exit from the current state to the state s which handles
# the transition. We do not exit from s=exit_path[-1] itself.
for st in exit_path[:-1]:
r = Hsm.exit(me, st)
assert (r == Hsm.RET_SUPER) or (r == Hsm.RET_HANDLED)
s = exit_path[-1]
# Transition to t through the HSM
Hsm._perform_transition(me, s, t)
# Do initializations starting at t
t = Hsm._perform_init_chain(me, t)
# Restore the state
me.state = t
class Framework(object):
"""Framework is a composite class that holds:
- the asyncio event loop
- the registry of AHSMs
- the set of TimeEvents
- the handle to the next TimeEvent
- the table subscriptions to events
"""
_event_loop = asyncio.get_event_loop()
# The Framework maintains a registry of Ahsms in a list.
_ahsm_registry = []
# The Framework maintains a dict of priorities in use
# to prevent duplicates.
# An Ahsm's priority is checked against this dict
# within the Ahsm.start() method
# when the Ahsm is added to the Framework.
# The dict's key is the priority (integer) and the value is the Ahsm.
_priority_dict = {}
# The Framework maintains a group of TimeEvents in a dict. The next
# expiration of the TimeEvent is the key and the event is the value.
# Only the event with the next expiration time is scheduled for the
# timeEventCallback(). As TimeEvents are added and removed, the scheduled
# callback must be re-evaluated. Periodic TimeEvents should only have
# one entry in the dict: the next expiration. The timeEventCallback() will
# add a Periodic TimeEvent back into the dict with its next expiration.
_time_events = {}
# When a TimeEvent is scheduled for the timeEventCallback(),
# a handle is kept so that the callback may be cancelled if necessary.
_tm_event_handle = None
# The Subscriber Table is a dictionary. The keys are signals.
# The value for each key is a list of Ahsms that are subscribed to the
# signal. An Ahsm may subscribe to a signal at any time during runtime.
_subscriber_table = {}
@staticmethod
def post(event, act):
"""Posts the event to the given Ahsm's event queue.
The argument, act, is an Ahsm instance.
"""
assert isinstance(act, Ahsm)
act.postFIFO(event)
@staticmethod
def post_by_name(event, act_name):
"""Posts the event to the given Ahsm's event queue.
The argument, act, is a string of the name of the class
to which the event is sent. The event will post to all actors
having the given classname.
"""
assert type(act_name) is str
for act in Framework._ahsm_registry:
if act.__class__.__name__ == act_name:
act.postFIFO(event)
@staticmethod
def publish(event):
"""Posts the event to the message queue of every Ahsm
that is subscribed to the event's signal.
"""
if event.signal in Framework._subscriber_table:
for act in Framework._subscriber_table[event.signal]:
act.postFIFO(event)
# Run to completion
Framework._event_loop.call_soon_threadsafe(Framework.run)
@staticmethod
def subscribe(signame, act):
"""Adds the given Ahsm to the subscriber table list
for the given signal. The argument, signame, is a string of the name
of the Signal to which the Ahsm is subscribing. Using a string allows
the Signal to be created in the registry if it is not already.
"""
sigid = Signal.register(signame)
if sigid not in Framework._subscriber_table:
Framework._subscriber_table[sigid] = []
Framework._subscriber_table[sigid].append(act)
@staticmethod
def addTimeEvent(tm_event, delta):
"""Adds the TimeEvent to the list of time events in the Framework.
The event will fire its signal (to the TimeEvent's target Ahsm)
after the delay, delta.
"""
expiration = Framework._event_loop.time() + delta
Framework.addTimeEventAt(tm_event, expiration)
@staticmethod
def addTimeEventAt(tm_event, abs_time):
"""Adds the TimeEvent to the list of time events in the Framework.
The event will fire its signal (to the TimeEvent's target Ahsm)
at the given absolute time (_event_loop.time()).
"""
assert tm_event not in Framework._time_events.values()
Framework._insortTimeEvent(tm_event, abs_time)
@staticmethod
def _insortTimeEvent(tm_event, expiration):
"""Inserts a TimeEvent into the list of time events,
sorted by the next expiration of the timer.
If the expiration time matches an existing expiration,
we add the smallest amount of time to the given expiration
to avoid a key collision in the Dict
and make the identically-timed events fire in a FIFO fashion.
"""
# If the event is to happen in the past, post it now
now = Framework._event_loop.time()
if expiration < now:
tm_event.act.postFIFO(tm_event)
# TODO: if periodic, need to schedule next?
# If an event already occupies this expiration time,
# increase this event's expiration by the smallest measurable amount
while expiration in Framework._time_events.keys():
m, e = math.frexp(expiration)
expiration = (m + sys.float_info.epsilon) * 2**e
Framework._time_events[expiration] = tm_event
# If this is the only active TimeEvent, schedule its callback
if len(Framework._time_events) == 1:
Framework._tm_event_handle = Framework._event_loop.call_at(
expiration, Framework.timeEventCallback, tm_event, expiration)
# If there are other TimeEvents,
# check if this one should replace the scheduled one
else:
if expiration < min(Framework._time_events.keys()):
Framework._tm_event_handle.cancel()
Framework._tm_event_handle = Framework._event_loop.call_at(
expiration, Framework.timeEventCallback, tm_event,
expiration)
@staticmethod
def removeTimeEvent(tm_event):
"""Removes the TimeEvent from the list of active time events.
Cancels the TimeEvent's callback if there is one.
Schedules the next event's callback if there is one.
"""
for k,v in Framework._time_events.items():
if v is tm_event:
# If the event being removed is scheduled for callback,
# cancel and schedule the next event if there is one
if k == min(Framework._time_events.keys()):
del Framework._time_events[k]
if Framework._tm_event_handle:
Framework._tm_event_handle.cancel()
if len(Framework._time_events) > 0:
next_expiration = min(Framework._time_events.keys())
next_event = Framework._time_events[next_expiration]
Framework._tm_event_handle = \
Framework._event_loop.call_at(
next_expiration, Framework.timeEventCallback,
next_event, next_expiration)
else:
Framework._tm_event_handle = None
else:
del Framework._time_events[k]
break
@staticmethod
def timeEventCallback(tm_event, expiration):
"""The callback function for all TimeEvents.
Posts the event to the event's target Ahsm.
If the TimeEvent is periodic, re-insort the event
in the list of active time events.
"""
assert expiration in Framework._time_events.keys(), (
"Exp:%d _time_events.keys():%s" %
(expiration, Framework._time_events.keys()))
# Remove this expired TimeEvent from the active list
del Framework._time_events[expiration]
Framework._tm_event_handle = None
# Post the event to the target Ahsm
tm_event.act.postFIFO(tm_event)
# If this is a periodic time event, schedule its next expiration
if tm_event.interval > 0:
Framework._insortTimeEvent(tm_event,
expiration + tm_event.interval)
# If not set already and there are more events, set the next event callback
if (Framework._tm_event_handle == None and
len(Framework._time_events) > 0):
next_expiration = min(Framework._time_events.keys())
next_event = Framework._time_events[next_expiration]
Framework._tm_event_handle = Framework._event_loop.call_at(
next_expiration, Framework.timeEventCallback, next_event,
next_expiration)
# Run to completion
Framework._event_loop.call_soon_threadsafe(Framework.run)
@staticmethod
def add(act):
"""Makes the framework aware of the given Ahsm.
"""
Framework._ahsm_registry.append(act)
assert act.priority not in Framework._priority_dict, (
"Priority MUST be unique")
Framework._priority_dict[act.priority] = act
Spy.on_framework_add(act)
@staticmethod
def run():
"""Dispatches an event to the highest priority Ahsm
until all event queues are empty (i.e. Run To Completion).
"""
getPriority = lambda x : x.priority
while True:
allQueuesEmpty = True
sorted_acts = sorted(Framework._ahsm_registry, key=getPriority)
for act in sorted_acts:
if act.has_msgs():
event_next = act.pop_msg()
act.dispatch(act, event_next)
allQueuesEmpty = False
break
if allQueuesEmpty:
return
@staticmethod
def stop():
"""EXITs all Ahsms and stops the event loop.
"""
# Disable the timer callback
if Framework._tm_event_handle:
Framework._tm_event_handle.cancel()
Framework._tm_event_handle = None
# Post EXIT to all Ahsms
for act in Framework._ahsm_registry:
Framework.post(Event.EXIT, act)
# Run to completion and stop the asyncio event loop
Framework.run()
Framework._event_loop.stop()
Spy.on_framework_stop()
@staticmethod
def print_info():
"""Prints the name and current state
of each actor in the framework.
Meant to be called when ctrl+T (SIGINFO/29) is issued.
"""
for act in Framework._ahsm_registry:
print(act.__class__.__name__, act.state.__name__)
# Bind a useful set of POSIX signals to the handler
# (ignore a NotImplementedError on Windows)
try:
_event_loop.add_signal_handler(signal.SIGINT, lambda: Framework.stop())
_event_loop.add_signal_handler(signal.SIGTERM, lambda: Framework.stop())
_event_loop.add_signal_handler(29, print_info.__func__)
except NotImplementedError:
pass
def run_forever():
"""Runs the asyncio event loop with and
ensures state machines are exited upon a KeyboardInterrupt.
"""
loop = asyncio.get_event_loop()
try:
loop.run_forever()
except KeyboardInterrupt:
Framework.stop()
loop.close()
class Ahsm(Hsm):
"""An Augmented Hierarchical State Machine (AHSM); a.k.a. ActiveObject/AO.
Adds a priority, message queue and methods to work with the queue.
"""
def start(self, priority, initEvent=None):
# must set the priority before Framework.add() which uses the priority
self.priority = priority
Framework.add(self)
self.mq = collections.deque()
self.init(self, initEvent)
# Run to completion
Framework._event_loop.call_soon_threadsafe(Framework.run)
def postLIFO(self, evt):
self.mq.append(evt)
def postFIFO(self, evt):
self.mq.appendleft(evt)
def pop_msg(self,):
return self.mq.pop()
def has_msgs(self,):
return len(self.mq) > 0
class TimeEvent(object):
"""TimeEvent is a composite class that contains an Event.
A TimeEvent is created by the application and added to the Framework.
The Framework then emits the event after the given delay.
A one-shot TimeEvent is created by calling either postAt() or postIn().
A periodic TimeEvent is created by calling the postEvery() method.
"""
def __init__(self, signame):
assert type(signame) == str
self.signal = Signal.register(signame)
self.value = None
def postAt(self, act, abs_time):
"""Posts this TimeEvent to the given Ahsm at a specified time.
"""
assert issubclass(type(act), Ahsm)
self.act = act
self.interval = 0
Framework.addTimeEventAt(self, abs_time)
def postIn(self, act, delta):
"""Posts this TimeEvent to the given Ahsm after the time delta.
"""
assert issubclass(type(act), Ahsm)
self.act = act
self.interval = 0
Framework.addTimeEvent(self, delta)
def postEvery(self, act, delta):
"""Posts this TimeEvent to the given Ahsm after the time delta
and every time delta thereafter until disarmed.
"""
assert issubclass(type(act), Ahsm)
self.act = act
self.interval = delta
Framework.addTimeEvent(self, delta)
def disarm(self):
"""Removes this TimeEvent from the Framework's active time events.
"""
self.act = None
Framework.removeTimeEvent(self)
from .VcdSpy import VcdSpy
| 37.072306 | 101 | 0.614668 | [
"MIT"
] | SzeMengTan/farc | farc/__init__.py | 27,174 | Python |
#!/usr/bin/env python
# encoding: utf-8
"""
@author: zhanghe
@software: PyCharm
@file: type_bank.py
@time: 2019-08-17 18:23
"""
from __future__ import unicode_literals
from flask_babel import lazy_gettext as _
from app_common.maps.default import DEFAULT_SEARCH_CHOICES_INT, DEFAULT_SELECT_CHOICES_INT
# 银行类型（1:基本账户,2:一般账户）
TYPE_BANK_BASIC = 1
TYPE_BANK_GENERAL = 2
TYPE_BANK_DICT = {
TYPE_BANK_BASIC: _('Basic Account'), # 基本账户（对公）
TYPE_BANK_GENERAL: _('General Account'), # 一般账户（对公）
}
TYPE_BANK_SELECT_CHOICES = DEFAULT_SELECT_CHOICES_INT + TYPE_BANK_DICT.items() # 选择
TYPE_BANK_SEARCH_CHOICES = DEFAULT_SEARCH_CHOICES_INT + TYPE_BANK_DICT.items() # 搜索
| 24.035714 | 90 | 0.768202 | [
"MIT"
] | zhanghe06/bearing_project | app_common/maps/type_bank.py | 741 | Python |
"""
Django settings for mycalendar project.
Generated by 'django-admin startproject' using Django 3.2.8.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.2/ref/settings/
"""
from pathlib import Path
from decouple import config
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.2/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = config('SECRET_KEY')
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'main',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
#'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'mycalendar.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [BASE_DIR / 'templates']
,
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'mycalendar.wsgi.application'
# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
# Password validation
# https://docs.djangoproject.com/en/3.2/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.2/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'Europe/Copenhagen'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.2/howto/static-files/
STATIC_URL = '/static/'
# Default primary key field type
# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
| 25.307692 | 91 | 0.700912 | [
"MIT"
] | spralja/mycalendar | mycalendar/settings.py | 3,290 | Python |
import logging
from Models import Values
from classes import PlayerActions, OnePosition
from ActionsDispatcher import Action
class PositionsManagerDBException(RuntimeError):
pass
class PositionsManager(object):
def __init__(self, models, accountId, logger=None):
self.models = models
self.accountId = accountId
if logger is None:
logger = logging.getLogger()
self.logger = logger
self.restore()
def restore(self):
models = self.models
profitThres = models.Values.get(Values.PositionThresProfit,
accountId=self.accountId)
if profitThres is None:
raise PositionsManagerDBException('Settings "{k}" not initialized.'
.format(k=Values.PositionThresProfit))
self.profitThres = profitThres
lossCutThres = models.Values.get(Values.PositionThresLossCut,
accountId=self.accountId)
if lossCutThres is None:
raise PositionsManagerDBException('Settings "{k}" not initialized.'
.format(k=Values.PositionThresLossCut))
self.lossCutThres = lossCutThres
@staticmethod
def calcVariation(onetick, oneposition):
"""
(tick: OneTick, position: OnePosition) -> float
"""
created = oneposition.priceMean()
if oneposition.side == OnePosition.SideLong:
current = onetick.bid
else:
current = onetick.ask
return current / created
def makeDecision(self, positions):
tick = self.models.Ticks.one()
for p in positions:
onePosition = p.positions[0]
oneTick = tick[onePosition.exchanger]
var = PositionsManager.calcVariation(oneTick, onePosition)
if onePosition.side == OnePosition.SideLong:
if var >= self.profitThres:
return [(PlayerActions.CloseForProfit, p)] # Long, Profit
elif var <= self.lossCutThres:
return [(PlayerActions.CloseForLossCut, p)] # Long, LossCut
else:
if var <= 1.0 / self.profitThres:
return [(PlayerActions.CloseForProfit, p)] # Short, Profit
elif var >= 1.0 / self.lossCutThres:
return [(PlayerActions.CloseForLossCut, p)] # Short, LossCut
return []
def getOpenPositions(self):
return self.models.Positions.currentOpen(accountId=self.accountId)
def createAction(self):
positions = self.getOpenPositions()
positions = filter(lambda p:p.isOpen(), positions)
closes = self.makeDecision(positions)
self.logger.debug('Completed decision, #close={n}.'.format(n=len(closes)))
if len(closes) > 0:
actionType, position = closes[0]
return Action(actionType, position)
else:
return None
| 35.402597 | 79 | 0.657373 | [
"Apache-2.0"
] | kikei/btc-bot-ai | apps/trade/src/PositionsManager.py | 2,726 | Python |
from django.contrib import admin
from user.models import *
# 此处设置页面头部标题
admin.site.site_title = '新码农站点后台'
# 此处设置页面显示标题
admin.site.site_header = '新码农后台管理系统'
@admin.register(User)
class Useradmin(admin.ModelAdmin):
list_display = ['id', 'username', 'password', 'nickname', 'birthday', 'gender', 'photo', 'phone', 'email', 'desc',
'addtime']
# list_display_links 设置其他字段也可以点击链接进入编辑界面
list_display_links = ['id', 'username']
list_per_page = 50
list_filter = ['gender', 'birthday']
search_fields = ['username', 'nickname', 'phone']
# list_editable 设置默认可编辑字段
list_editable = ['nickname', 'birthday', 'gender', 'phone', 'email', 'desc']
ordering = ['-addtime']
# date_hierarchy 详细时间分层筛选
date_hierarchy = 'addtime'
@admin.register(Leavemsg)
class Leavemsgadmin(admin.ModelAdmin):
list_display = ['id', 'content', 'user', 'addtime']
# list_display_links 设置其他字段也可以点击链接进入编辑界面
list_display_links = ['id', 'user']
list_per_page = 50
list_filter = ['user']
search_fields = ['user']
# list_editable 设置默认可编辑字段
list_editable = ['content']
ordering = ['-addtime']
# date_hierarchy 详细时间分层筛选
date_hierarchy = 'addtime'
| 30.35 | 118 | 0.666392 | [
"Apache-2.0"
] | guoxianru/newcoder | apps/user/admin.py | 1,434 | Python |
from typing import Optional, List
import autofit as af
import autoarray as aa
import autogalaxy as ag
from autogalaxy.aggregator.imaging import _imaging_from
from autogalaxy.aggregator.abstract import AbstractAgg
from autolens.imaging.fit_imaging import FitImaging
from autolens.analysis.preloads import Preloads
from autolens.aggregator.tracer import _tracer_from
def _fit_imaging_from(
fit: af.Fit,
galaxies: List[ag.Galaxy],
settings_imaging: aa.SettingsImaging = None,
settings_pixelization: aa.SettingsPixelization = None,
settings_inversion: aa.SettingsInversion = None,
use_preloaded_grid: bool = True,
use_hyper_scaling: bool = True,
) -> FitImaging:
"""
Returns a `FitImaging` object from a PyAutoFit database `Fit` object and an instance of galaxies from a non-linear
search model-fit.
This function adds the `hyper_model_image` and `hyper_galaxy_image_path_dict` to the galaxies before performing the
fit, if they were used.
Parameters
----------
fit
A PyAutoFit database Fit object containing the generators of the results of PyAutoGalaxy model-fits.
galaxies
A list of galaxies corresponding to a sample of a non-linear search and model-fit.
Returns
-------
FitImaging
The fit to the imaging dataset computed via an instance of galaxies.
"""
imaging = _imaging_from(fit=fit, settings_imaging=settings_imaging)
tracer = _tracer_from(fit=fit, galaxies=galaxies)
settings_pixelization = settings_pixelization or fit.value(
name="settings_pixelization"
)
settings_inversion = settings_inversion or fit.value(name="settings_inversion")
preloads = Preloads(use_w_tilde=False)
if use_preloaded_grid:
sparse_grids_of_planes = fit.value(name="preload_sparse_grids_of_planes")
if sparse_grids_of_planes is not None:
preloads = Preloads(
sparse_image_plane_grid_pg_list=sparse_grids_of_planes,
use_w_tilde=False,
)
if len(preloads.sparse_image_plane_grid_pg_list) == 2:
if type(preloads.sparse_image_plane_grid_pg_list[1]) != list:
preloads.sparse_image_plane_grid_pg_list[1] = [
preloads.sparse_image_plane_grid_pg_list[1]
]
return FitImaging(
dataset=imaging,
tracer=tracer,
settings_pixelization=settings_pixelization,
settings_inversion=settings_inversion,
preloads=preloads,
use_hyper_scaling=use_hyper_scaling,
)
class FitImagingAgg(AbstractAgg):
def __init__(
self,
aggregator: af.Aggregator,
settings_imaging: Optional[aa.SettingsImaging] = None,
settings_pixelization: Optional[aa.SettingsPixelization] = None,
settings_inversion: Optional[aa.SettingsInversion] = None,
use_preloaded_grid: bool = True,
use_hyper_scaling: bool = True,
):
"""
Wraps a PyAutoFit aggregator in order to create generators of fits to imaging data, corresponding to the
results of a non-linear search model-fit.
"""
super().__init__(aggregator=aggregator)
self.settings_imaging = settings_imaging
self.settings_pixelization = settings_pixelization
self.settings_inversion = settings_inversion
self.use_preloaded_grid = use_preloaded_grid
self.use_hyper_scaling = use_hyper_scaling
def make_object_for_gen(self, fit, galaxies) -> FitImaging:
"""
Creates a `FitImaging` object from a `ModelInstance` that contains the galaxies of a sample from a non-linear
search.
Parameters
----------
fit
A PyAutoFit database Fit object containing the generators of the results of PyAutoGalaxy model-fits.
galaxies
A list of galaxies corresponding to a sample of a non-linear search and model-fit.
Returns
-------
FitImaging
A fit to imaging data whose galaxies are a sample of a PyAutoFit non-linear search.
"""
return _fit_imaging_from(
fit=fit,
galaxies=galaxies,
settings_imaging=self.settings_imaging,
settings_pixelization=self.settings_pixelization,
settings_inversion=self.settings_inversion,
use_preloaded_grid=self.use_preloaded_grid,
use_hyper_scaling=self.use_hyper_scaling,
)
| 35.738462 | 120 | 0.667456 | [
"MIT"
] | Jammy2211/AutoLens | autolens/aggregator/fit_imaging.py | 4,646 | Python |
# -*- coding: utf-8 -*-
"""
Created on Tue May 12 14:25:43 2020
@author: greg6
"""
import numpy as np
t = [i for i in range(3)]
lam = [100+i*10 for i in range(2)]
com = ["A","B","C"]
S = dict()
for l in lam:
for u,c in enumerate(com):
S[(l,c)] = l+0.1*u
C = dict()
for i in t:
for u,c in enumerate(com):
C[(i,c)] = (i+0.1*u)
nt = len(t)
nw = len(lam)
nc = len(com)
nparams = 2
nd = nw*nt
ntheta = nc*(nw+nt)+nparams
B_matrix = np.zeros((ntheta,nw*nt))
for i, t in enumerate(t):
for j, l in enumerate(lam):
for k, c in enumerate(com):
# r_idx1 = k*nt+i
r_idx1 = i * nc + k
r_idx2 = j * nc + k + nc * nt
# r_idx2 = j * nc + k + nc * nw
# c_idx = i+j*nt
c_idx = i * nw + j
# print(j, k, r_idx2)
B_matrix[r_idx1, c_idx] = S[l, c]
# try:
B_matrix[r_idx2, c_idx] = C[t, c] | 20.666667 | 45 | 0.476344 | [
"BSD-3-Clause"
] | kuanhanl/k_aug | Reduce_hessian/tests/B1.py | 930 | Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'mikeeiei.ui'
#
# Created by: PyQt4 UI code generator 4.11.4
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
def _fromUtf8(s):
return s
try:
_encoding = QtGui.QApplication.UnicodeUTF8
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig)
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.resize(954, 600)
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.formLayoutWidget = QtGui.QWidget(self.centralwidget)
self.formLayoutWidget.setGeometry(QtCore.QRect(80, 240, 160, 141))
self.formLayoutWidget.setObjectName(_fromUtf8("formLayoutWidget"))
self.formLayout = QtGui.QFormLayout(self.formLayoutWidget)
self.formLayout.setObjectName(_fromUtf8("formLayout"))
self.kaojai = QtGui.QPushButton(self.formLayoutWidget)
self.kaojai.setStyleSheet(_fromUtf8("int main(int argc, char *argv[])\n"
"\n"
"#upLeft {\n"
"background-color: transparent;\n"
"border-image: url(:/images/frame.png);\n"
"background: none;\n"
"border: none;\n"
"background-repeat: none;\n"
"}\n"
"{\n"
"border-image: url(:mike2.jpg);\n"
"}"))
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8(":/mike/mike.jpg")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.kaojai.setIcon(icon)
self.kaojai.setObjectName(_fromUtf8("kaojai"))
self.formLayout.setWidget(0, QtGui.QFormLayout.LabelRole, self.kaojai)
self.maikaojai = QtGui.QPushButton(self.formLayoutWidget)
self.maikaojai.setObjectName(_fromUtf8("maikaojai"))
self.formLayout.setWidget(1, QtGui.QFormLayout.LabelRole, self.maikaojai)
self.vote = QtGui.QPushButton(self.formLayoutWidget)
self.vote.setObjectName(_fromUtf8("vote"))
self.formLayout.setWidget(2, QtGui.QFormLayout.LabelRole, self.vote)
self.question = QtGui.QPushButton(self.formLayoutWidget)
self.question.setObjectName(_fromUtf8("question"))
self.formLayout.setWidget(3, QtGui.QFormLayout.LabelRole, self.question)
self.frame = QtGui.QFrame(self.centralwidget)
self.frame.setGeometry(QtCore.QRect(0, 0, 331, 161))
self.frame.setFrameShape(QtGui.QFrame.StyledPanel)
self.frame.setFrameShadow(QtGui.QFrame.Raised)
self.frame.setObjectName(_fromUtf8("frame"))
self.tabWidget = QtGui.QTabWidget(self.frame)
self.tabWidget.setGeometry(QtCore.QRect(100, 110, 135, 80))
self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
self.tab = QtGui.QWidget()
self.tab.setObjectName(_fromUtf8("tab"))
self.tabWidget.addTab(self.tab, _fromUtf8(""))
self.tab_2 = QtGui.QWidget()
self.tab_2.setObjectName(_fromUtf8("tab_2"))
self.tabWidget.addTab(self.tab_2, _fromUtf8(""))
self.label = QtGui.QLabel(self.centralwidget)
self.label.setGeometry(QtCore.QRect(60, 100, 831, 271))
self.label.setText(_fromUtf8(""))
self.label.setPixmap(QtGui.QPixmap(_fromUtf8("")))
self.label.setObjectName(_fromUtf8("label"))
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
self.toolBar = QtGui.QToolBar(MainWindow)
self.toolBar.setObjectName(_fromUtf8("toolBar"))
MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
self.actionSend = QtGui.QAction(MainWindow)
self.actionSend.setIcon(icon)
self.actionSend.setObjectName(_fromUtf8("actionSend"))
self.toolBar.addAction(self.actionSend)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow", None))
self.kaojai.setText(_translate("MainWindow", "PushButton", None))
self.maikaojai.setText(_translate("MainWindow", "PushButton", None))
self.vote.setText(_translate("MainWindow", "PushButton", None))
self.question.setText(_translate("MainWindow", "d", None))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab), _translate("MainWindow", "Tab 1", None))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2), _translate("MainWindow", "Tab 2", None))
self.toolBar.setWindowTitle(_translate("MainWindow", "toolBar", None))
self.actionSend.setText(_translate("MainWindow", "send", None))
if __name__ == "__main__":
import sys
app = QtGui.QApplication(sys.argv)
MainWindow = QtGui.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
| 45.661017 | 111 | 0.68467 | [
"MIT"
] | pection-zz/Interactionstudent | PyqtProject/test2.py | 5,388 | Python |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""ModelBuilderRLF.py:
"""
__author__ = "Antonio Jesús Banegas-Luna"
__version__ = "1.0"
__maintainer__ = "Antonio"
__email__ = "[email protected]"
__status__ = "Development"
from BaseModelBuilder import BaseModelBuilder
class ModelBuilderRLF(BaseModelBuilder):
def get_default_model(self):
p = {}
p['model'] = self.model_name
p['train_grid'] = 'NONE'
p['type_ml'] = 'classification'
p['n_jobs'] = 8
p['params'] = {}
p['params']['tree_size'] = 4
p['params']['sample_fract'] = 'default'
p['params']['max_rules'] = 2000
p['params']['memory_par'] = 0.01
p['params']['rfmode'] = 'classify'
p['params']['lin_trim_quantile'] = 0.025
p['params']['lin_standardise'] = True
p['params']['exp_rand_tree_size'] = True
p['params_grid'] = {}
return p
| 24.972973 | 48 | 0.580087 | [
"Apache-2.0"
] | bio-hpc/sibila | Scripts/GridSearch/ModelBuilderRLF.py | 925 | Python |
import warnings
from textwrap import indent
import astropy.units as u
import numpy as np
from astropy.constants import c
from astropy.coordinates import (ICRS,
CartesianDifferential,
CartesianRepresentation, SkyCoord)
from astropy.coordinates.spectral_quantity import SpectralQuantity
from astropy.coordinates.baseframe import (BaseCoordinateFrame,
frame_transform_graph)
from astropy.utils.exceptions import AstropyUserWarning
__all__ = ['SpectralCoord']
class NoVelocityWarning(AstropyUserWarning):
pass
class NoDistanceWarning(AstropyUserWarning):
pass
KMS = u.km / u.s
C_KMS = c.to(KMS)
ZERO_VELOCITIES = CartesianDifferential([0, 0, 0] * KMS)
# Default distance to use for target when none is provided
DEFAULT_DISTANCE = 1e6 * u.kpc
# We don't want to run doctests in the docstrings we inherit from Quantity
__doctest_skip__ = ['SpectralCoord.*']
def _velocity_to_redshift(velocity):
"""
Convert a velocity to a relativistic redshift.
"""
beta = velocity / C_KMS
return np.sqrt((1 + beta) / (1 - beta)) - 1
def _redshift_to_velocity(redshift):
"""
Convert a relativistic redshift to a velocity.
"""
zponesq = (1 + redshift) ** 2
return (C_KMS * (zponesq - 1) / (zponesq + 1))
def _apply_relativistic_doppler_shift(scoord, velocity):
"""
Given a `SpectralQuantity` and a velocity, return a new `SpectralQuantity`
that is Doppler shifted by this amount.
Note that the Doppler shift applied is the full relativistic one, so
`SpectralQuantity` currently expressed in velocity and not using the
relativistic convention will temporarily be converted to use the
relativistic convention while the shift is applied.
Positive velocities are assumed to redshift the spectral quantity,
while negative velocities blueshift the spectral quantity.
"""
# NOTE: we deliberately don't keep sub-classes of SpectralQuantity intact
# since we can't guarantee that their metadata would be correct/consistent.
squantity = scoord.view(SpectralQuantity)
beta = velocity / c
doppler_factor = np.sqrt((1 + beta) / (1 - beta))
if squantity.unit.is_equivalent(u.m): # wavelength
return squantity * doppler_factor
elif (squantity.unit.is_equivalent(u.Hz) or
squantity.unit.is_equivalent(u.eV) or
squantity.unit.is_equivalent(1 / u.m)):
return squantity / doppler_factor
elif squantity.unit.is_equivalent(KMS): # velocity
return (squantity.to(u.Hz) / doppler_factor).to(squantity.unit)
else: # pragma: no cover
raise RuntimeError(f"Unexpected units in velocity shift: {squantity.unit}. "
"This should not happen, so please report this in the "
"astropy issue tracker!")
def update_differentials_to_match(original, velocity_reference, preserve_observer_frame=False):
"""
Given an original coordinate object, update the differentials so that
the final coordinate is at the same location as the original coordinate
but co-moving with the velocity reference object.
If preserve_original_frame is set to True, the resulting object will be in
the frame of the original coordinate, otherwise it will be in the frame of
the velocity reference.
"""
if not velocity_reference.data.differentials:
raise ValueError("Reference frame has no velocities")
# If the reference has an obstime already defined, we should ignore
# it and stick with the original observer obstime.
if 'obstime' in velocity_reference.frame_attributes and hasattr(original, 'obstime'):
velocity_reference = velocity_reference.replicate(obstime=original.obstime)
# We transform both coordinates to ICRS for simplicity and because we know
# it's a simple frame that is not time-dependent (it could be that both
# the original and velocity_reference frame are time-dependent)
original_icrs = original.transform_to(ICRS())
velocity_reference_icrs = velocity_reference.transform_to(ICRS())
differentials = velocity_reference_icrs.data.represent_as(CartesianRepresentation,
CartesianDifferential).differentials
data_with_differentials = (original_icrs.data.represent_as(CartesianRepresentation)
.with_differentials(differentials))
final_icrs = original_icrs.realize_frame(data_with_differentials)
if preserve_observer_frame:
final = final_icrs.transform_to(original)
else:
final = final_icrs.transform_to(velocity_reference)
return final.replicate(representation_type=CartesianRepresentation,
differential_type=CartesianDifferential)
def attach_zero_velocities(coord):
"""
Set the differentials to be stationary on a coordinate object.
"""
new_data = coord.cartesian.with_differentials(ZERO_VELOCITIES)
return coord.realize_frame(new_data)
def _get_velocities(coord):
if 's' in coord.data.differentials:
return coord.velocity
else:
return ZERO_VELOCITIES
class SpectralCoord(SpectralQuantity):
"""
A spectral coordinate with its corresponding unit.
.. note:: The |SpectralCoord| class is new in Astropy v4.1 and should be
considered experimental at this time. Note that we do not fully
support cases where the observer and target are moving
relativistically relative to each other, so care should be taken
in those cases. It is possible that there will be API changes in
future versions of Astropy based on user feedback. If you have
specific ideas for how it might be improved, please let us know
on the `astropy-dev mailing list`_ or at
http://feedback.astropy.org.
Parameters
----------
value : ndarray or `~astropy.units.Quantity` or `SpectralCoord`
Spectral values, which should be either wavelength, frequency,
energy, wavenumber, or velocity values.
unit : str or `~astropy.units.Unit`
Unit for the given spectral values.
observer : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord`, optional
The coordinate (position and velocity) of observer. If no velocities
are present on this object, the observer is assumed to be stationary
relative to the frame origin.
target : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord`, optional
The coordinate (position and velocity) of target. If no velocities
are present on this object, the target is assumed to be stationary
relative to the frame origin.
radial_velocity : `~astropy.units.Quantity`, optional
The radial velocity of the target with respect to the observer. This
can only be specified if ``redshift`` is not specified.
redshift : float, optional
The relativistic redshift of the target with respect to the observer.
This can only be specified if ``radial_velocity`` cannot be specified.
doppler_rest : `~astropy.units.Quantity`, optional
The rest value to use when expressing the spectral value as a velocity.
doppler_convention : str, optional
The Doppler convention to use when expressing the spectral value as a velocity.
"""
@u.quantity_input(radial_velocity=u.km/u.s)
def __new__(cls, value, unit=None,
observer=None, target=None,
radial_velocity=None, redshift=None,
**kwargs):
obj = super().__new__(cls, value, unit=unit, **kwargs)
# There are two main modes of operation in this class. Either the
# observer and target are both defined, in which case the radial
# velocity and redshift are automatically computed from these, or
# only one of the observer and target are specified, along with a
# manually specified radial velocity or redshift. So if a target and
# observer are both specified, we can't also accept a radial velocity
# or redshift.
if target is not None and observer is not None:
if radial_velocity is not None or redshift is not None:
raise ValueError("Cannot specify radial velocity or redshift if both "
"target and observer are specified")
# We only deal with redshifts here and in the redshift property.
# Otherwise internally we always deal with velocities.
if redshift is not None:
if radial_velocity is not None:
raise ValueError("Cannot set both a radial velocity and redshift")
redshift = u.Quantity(redshift)
# For now, we can't specify redshift=u.one in quantity_input above
# and have it work with plain floats, but if that is fixed, for
# example as in https://github.com/astropy/astropy/pull/10232, we
# can remove the check here and add redshift=u.one to the decorator
if not redshift.unit.is_equivalent(u.one):
raise u.UnitsError('redshift should be dimensionless')
radial_velocity = _redshift_to_velocity(redshift)
# If we're initializing from an existing SpectralCoord, keep any
# parameters that aren't being overridden
if observer is None:
observer = getattr(value, 'observer', None)
if target is None:
target = getattr(value, 'target', None)
# As mentioned above, we should only specify the radial velocity
# manually if either or both the observer and target are not
# specified.
if observer is None or target is None:
if radial_velocity is None:
radial_velocity = getattr(value, 'radial_velocity', None)
obj._radial_velocity = radial_velocity
obj._observer = cls._validate_coordinate(observer, label='observer')
obj._target = cls._validate_coordinate(target, label='target')
return obj
def __array_finalize__(self, obj):
super().__array_finalize__(obj)
self._radial_velocity = getattr(obj, '_radial_velocity', None)
self._observer = getattr(obj, '_observer', None)
self._target = getattr(obj, '_target', None)
@staticmethod
def _validate_coordinate(coord, label=''):
"""
Checks the type of the frame and whether a velocity differential and a
distance has been defined on the frame object.
If no distance is defined, the target is assumed to be "really far
away", and the observer is assumed to be "in the solar system".
Parameters
----------
coord : `~astropy.coordinates.BaseCoordinateFrame`
The new frame to be used for target or observer.
label : str, optional
The name of the object being validated (e.g. 'target' or 'observer'),
which is then used in error messages.
"""
if coord is None:
return
if not issubclass(coord.__class__, BaseCoordinateFrame):
if isinstance(coord, SkyCoord):
coord = coord.frame
else:
raise TypeError(f"{label} must be a SkyCoord or coordinate frame instance")
# If the distance is not well-defined, ensure that it works properly
# for generating differentials
# TODO: change this to not set the distance and yield a warning once
# there's a good way to address this in astropy.coordinates
# https://github.com/astropy/astropy/issues/10247
with np.errstate(all='ignore'):
distance = getattr(coord, 'distance', None)
if distance is not None and distance.unit.physical_type == 'dimensionless':
coord = SkyCoord(coord, distance=DEFAULT_DISTANCE)
warnings.warn(
"Distance on coordinate object is dimensionless, an "
f"abritrary distance value of {DEFAULT_DISTANCE} will be set instead.",
NoDistanceWarning)
# If the observer frame does not contain information about the
# velocity of the system, assume that the velocity is zero in the
# system.
if 's' not in coord.data.differentials:
warnings.warn(
"No velocity defined on frame, assuming {}.".format(
ZERO_VELOCITIES),
NoVelocityWarning)
coord = attach_zero_velocities(coord)
return coord
def replicate(self, value=None, unit=None,
observer=None, target=None,
radial_velocity=None, redshift=None,
doppler_convention=None, doppler_rest=None,
copy=False):
"""
Return a replica of the `SpectralCoord`, optionally changing the
values or attributes.
Note that no conversion is carried out by this method - this keeps
all the values and attributes the same, except for the ones explicitly
passed to this method which are changed.
If ``copy`` is set to `True` then a full copy of the internal arrays
will be made. By default the replica will use a reference to the
original arrays when possible to save memory.
Parameters
----------
value : ndarray or `~astropy.units.Quantity` or `SpectralCoord`, optional
Spectral values, which should be either wavelength, frequency,
energy, wavenumber, or velocity values.
unit : str or `~astropy.units.Unit`
Unit for the given spectral values.
observer : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord`, optional
The coordinate (position and velocity) of observer.
target : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord`, optional
The coordinate (position and velocity) of target.
radial_velocity : `~astropy.units.Quantity`, optional
The radial velocity of the target with respect to the observer.
redshift : float, optional
The relativistic redshift of the target with respect to the observer.
doppler_rest : `~astropy.units.Quantity`, optional
The rest value to use when expressing the spectral value as a velocity.
doppler_convention : str, optional
The Doppler convention to use when expressing the spectral value as a velocity.
copy : bool, optional
If `True`, and ``value`` is not specified, the values are copied to
the new `SkyCoord` - otherwise a reference to the same values is used.
Returns
-------
sc : `SpectralCoord` object
Replica of this object
"""
if isinstance(value, u.Quantity):
if unit is not None:
raise ValueError("Cannot specify value as a Quantity and also specify unit")
else:
value, unit = value.value, value.unit
value = value if value is not None else self.value
unit = unit or self.unit
observer = self._validate_coordinate(observer) or self.observer
target = self._validate_coordinate(target) or self.target
doppler_convention = doppler_convention or self.doppler_convention
doppler_rest = doppler_rest or self.doppler_rest
# If value is being taken from self and copy is Tru
if copy:
value = value.copy()
# Only include radial_velocity if it is not auto-computed from the
# observer and target.
if (self.observer is None or self.target is None) and radial_velocity is None and redshift is None:
radial_velocity = self.radial_velocity
with warnings.catch_warnings():
warnings.simplefilter('ignore', NoVelocityWarning)
return self.__class__(value=value, unit=unit,
observer=observer, target=target,
radial_velocity=radial_velocity, redshift=redshift,
doppler_convention=doppler_convention, doppler_rest=doppler_rest, copy=False)
@property
def quantity(self):
"""
Convert the ``SpectralCoord`` to a `~astropy.units.Quantity`.
Equivalent to ``self.view(u.Quantity)``.
Returns
-------
`~astropy.units.Quantity`
This object viewed as a `~astropy.units.Quantity`.
"""
return self.view(u.Quantity)
@property
def observer(self):
"""
The coordinates of the observer.
If set, and a target is set as well, this will override any explicit
radial velocity passed in.
Returns
-------
`~astropy.coordinates.BaseCoordinateFrame`
The astropy coordinate frame representing the observation.
"""
return self._observer
@observer.setter
def observer(self, value):
if self.observer is not None:
raise ValueError("observer has already been set")
self._observer = self._validate_coordinate(value, label='observer')
# Switch to auto-computing radial velocity
if self._target is not None:
self._radial_velocity = None
@property
def target(self):
"""
The coordinates of the target being observed.
If set, and an observer is set as well, this will override any explicit
radial velocity passed in.
Returns
-------
`~astropy.coordinates.BaseCoordinateFrame`
The astropy coordinate frame representing the target.
"""
return self._target
@target.setter
def target(self, value):
if self.target is not None:
raise ValueError("target has already been set")
self._target = self._validate_coordinate(value, label='target')
# Switch to auto-computing radial velocity
if self._observer is not None:
self._radial_velocity = None
@property
def radial_velocity(self):
"""
Radial velocity of target relative to the observer.
Returns
-------
`~astropy.units.Quantity`
Radial velocity of target.
Notes
-----
This is different from the ``.radial_velocity`` property of a
coordinate frame in that this calculates the radial velocity with
respect to the *observer*, not the origin of the frame.
"""
if self._observer is None or self._target is None:
if self._radial_velocity is None:
return 0 * KMS
else:
return self._radial_velocity
else:
return self._calculate_radial_velocity(self._observer, self._target,
as_scalar=True)
@property
def redshift(self):
"""
Redshift of target relative to observer. Calculated from the radial
velocity.
Returns
-------
float
Redshift of target.
"""
return _velocity_to_redshift(self.radial_velocity)
@staticmethod
def _calculate_radial_velocity(observer, target, as_scalar=False):
"""
Compute the line-of-sight velocity from the observer to the target.
Parameters
----------
observer : `~astropy.coordinates.BaseCoordinateFrame`
The frame of the observer.
target : `~astropy.coordinates.BaseCoordinateFrame`
The frame of the target.
as_scalar : bool
If `True`, the magnitude of the velocity vector will be returned,
otherwise the full vector will be returned.
Returns
-------
`~astropy.units.Quantity`
The radial velocity of the target with respect to the observer.
"""
# Convert observer and target to ICRS to avoid finite differencing
# calculations that lack numerical precision.
observer_icrs = observer.transform_to(ICRS())
target_icrs = target.transform_to(ICRS())
pos_hat = SpectralCoord._normalized_position_vector(observer_icrs, target_icrs)
d_vel = target_icrs.velocity - observer_icrs.velocity
vel_mag = pos_hat.dot(d_vel)
if as_scalar:
return vel_mag
else:
return vel_mag * pos_hat
@staticmethod
def _normalized_position_vector(observer, target):
"""
Calculate the normalized position vector between two frames.
Parameters
----------
observer : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord`
The observation frame or coordinate.
target : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord`
The target frame or coordinate.
Returns
-------
pos_hat : `BaseRepresentation`
Position representation.
"""
d_pos = (target.cartesian.without_differentials() -
observer.cartesian.without_differentials())
dp_norm = d_pos.norm()
# Reset any that are 0 to 1 to avoid nans from 0/0
dp_norm[dp_norm == 0] = 1 * dp_norm.unit
pos_hat = d_pos / dp_norm
return pos_hat
@u.quantity_input(velocity=u.km/u.s)
def with_observer_stationary_relative_to(self, frame, velocity=None, preserve_observer_frame=False):
"""
A new `SpectralCoord` with the velocity of the observer altered,
but not the position.
If a coordinate frame is specified, the observer velocities will be
modified to be stationary in the specified frame. If a coordinate
instance is specified, optionally with non-zero velocities, the
observer velocities will be updated so that the observer is co-moving
with the specified coordinates.
Parameters
----------
frame : str, `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord`
The observation frame in which the observer will be stationary. This
can be the name of a frame (e.g. 'icrs'), a frame class, frame instance
with no data, or instance with data. This can optionally include
velocities.
velocity : `~astropy.units.Quantity` or `~astropy.coordinates.CartesianDifferential`, optional
If ``frame`` does not contain velocities, these can be specified as
a 3-element `~astropy.units.Quantity`. In the case where this is
also not specified, the velocities default to zero.
preserve_observer_frame : bool
If `True`, the final observer frame class will be the same as the
original one, and if `False` it will be the frame of the velocity
reference class.
Returns
-------
new_coord : `SpectralCoord`
The new coordinate object representing the spectral data
transformed based on the observer's new velocity frame.
"""
if self.observer is None or self.target is None:
raise ValueError("This method can only be used if both observer "
"and target are defined on the SpectralCoord.")
# Start off by extracting frame if a SkyCoord was passed in
if isinstance(frame, SkyCoord):
frame = frame.frame
if isinstance(frame, BaseCoordinateFrame):
if not frame.has_data:
frame = frame.realize_frame(CartesianRepresentation(0 * u.km, 0 * u.km, 0 * u.km))
if frame.data.differentials:
if velocity is not None:
raise ValueError('frame already has differentials, cannot also specify velocity')
# otherwise frame is ready to go
else:
if velocity is None:
differentials = ZERO_VELOCITIES
else:
differentials = CartesianDifferential(velocity)
frame = frame.realize_frame(frame.data.with_differentials(differentials))
if isinstance(frame, (type, str)):
if isinstance(frame, type):
frame_cls = frame
elif isinstance(frame, str):
frame_cls = frame_transform_graph.lookup_name(frame)
if velocity is None:
velocity = 0 * u.m / u.s, 0 * u.m / u.s, 0 * u.m / u.s
elif velocity.shape != (3,):
raise ValueError('velocity should be a Quantity vector with 3 elements')
frame = frame_cls(0 * u.m, 0 * u.m, 0 * u.m,
*velocity,
representation_type='cartesian',
differential_type='cartesian')
observer = update_differentials_to_match(self.observer, frame,
preserve_observer_frame=preserve_observer_frame)
# Calculate the initial and final los velocity
init_obs_vel = self._calculate_radial_velocity(self.observer, self.target, as_scalar=True)
fin_obs_vel = self._calculate_radial_velocity(observer, self.target, as_scalar=True)
# Apply transformation to data
new_data = _apply_relativistic_doppler_shift(self, fin_obs_vel - init_obs_vel)
new_coord = self.replicate(value=new_data, observer=observer)
return new_coord
def with_radial_velocity_shift(self, target_shift=None, observer_shift=None):
"""
Apply a velocity shift to this spectral coordinate.
The shift can be provided as a redshift (float value) or radial
velocity (`~astropy.units.Quantity` with physical type of 'speed').
Parameters
----------
target_shift : float or `~astropy.units.Quantity`
Shift value to apply to current target.
observer_shift : float or `~astropy.units.Quantity`
Shift value to apply to current observer.
Returns
-------
`SpectralCoord`
New spectral coordinate with the target/observer velocity changed
to incorporate the shift. This is always a new object even if
``target_shift`` and ``observer_shift`` are both `None`.
"""
if observer_shift is not None and (self.target is None or
self.observer is None):
raise ValueError("Both an observer and target must be defined "
"before applying a velocity shift.")
for arg in [x for x in [target_shift, observer_shift] if x is not None]:
if isinstance(arg, u.Quantity) and not arg.unit.is_equivalent((u.one, KMS)):
raise u.UnitsError("Argument must have unit physical type "
"'speed' for radial velocty or "
"'dimensionless' for redshift.")
# The target or observer value is defined but is not a quantity object,
# assume it's a redshift float value and convert to velocity
if target_shift is None:
if self._observer is None or self._target is None:
return self.replicate()
target_shift = 0 * KMS
else:
target_shift = u.Quantity(target_shift)
if target_shift.unit.physical_type == 'dimensionless':
target_shift = _redshift_to_velocity(target_shift)
if self._observer is None or self._target is None:
return self.replicate(value=_apply_relativistic_doppler_shift(self, target_shift),
radial_velocity=self.radial_velocity + target_shift)
if observer_shift is None:
observer_shift = 0 * KMS
else:
observer_shift = u.Quantity(observer_shift)
if observer_shift.unit.physical_type == 'dimensionless':
observer_shift = _redshift_to_velocity(observer_shift)
target_icrs = self._target.transform_to(ICRS())
observer_icrs = self._observer.transform_to(ICRS())
pos_hat = SpectralCoord._normalized_position_vector(observer_icrs, target_icrs)
target_velocity = _get_velocities(target_icrs) + target_shift * pos_hat
observer_velocity = _get_velocities(observer_icrs) + observer_shift * pos_hat
target_velocity = CartesianDifferential(target_velocity.xyz)
observer_velocity = CartesianDifferential(observer_velocity.xyz)
new_target = (target_icrs
.realize_frame(target_icrs.cartesian.with_differentials(target_velocity))
.transform_to(self._target))
new_observer = (observer_icrs
.realize_frame(observer_icrs.cartesian.with_differentials(observer_velocity))
.transform_to(self._observer))
init_obs_vel = self._calculate_radial_velocity(observer_icrs, target_icrs, as_scalar=True)
fin_obs_vel = self._calculate_radial_velocity(new_observer, new_target, as_scalar=True)
new_data = _apply_relativistic_doppler_shift(self, fin_obs_vel - init_obs_vel)
return self.replicate(value=new_data,
observer=new_observer,
target=new_target)
def to_rest(self):
"""
Transforms the spectral axis to the rest frame.
"""
if self.observer is not None and self.target is not None:
return self.with_observer_stationary_relative_to(self.target)
result = _apply_relativistic_doppler_shift(self, -self.radial_velocity)
return self.replicate(value=result, radial_velocity=0. * KMS, redshift=None)
def __repr__(self):
prefixstr = '<' + self.__class__.__name__ + ' '
try:
radial_velocity = self.radial_velocity
redshift = self.redshift
except ValueError:
radial_velocity = redshift = 'Undefined'
repr_items = [f'{prefixstr}']
if self.observer is not None:
observer_repr = indent(repr(self.observer), 14 * ' ').lstrip()
repr_items.append(f' observer: {observer_repr}')
if self.target is not None:
target_repr = indent(repr(self.target), 12 * ' ').lstrip()
repr_items.append(f' target: {target_repr}')
if (self._observer is not None and self._target is not None) or self._radial_velocity is not None:
if self.observer is not None and self.target is not None:
repr_items.append(' observer to target (computed from above):')
else:
repr_items.append(' observer to target:')
repr_items.append(f' radial_velocity={radial_velocity}')
repr_items.append(f' redshift={redshift}')
if self.doppler_rest is not None or self.doppler_convention is not None:
repr_items.append(f' doppler_rest={self.doppler_rest}')
repr_items.append(f' doppler_convention={self.doppler_convention}')
arrstr = np.array2string(self.view(np.ndarray), separator=', ',
prefix=' ')
if len(repr_items) == 1:
repr_items[0] += f'{arrstr}{self._unitstr:s}'
else:
repr_items[1] = ' (' + repr_items[1].lstrip()
repr_items[-1] += ')'
repr_items.append(f' {arrstr}{self._unitstr:s}')
return '\n'.join(repr_items) + '>'
| 41.219922 | 111 | 0.638107 | [
"MIT"
] | honeybhardwaj/Language_Identification | LI/lib/python3.8/site-packages/astropy/coordinates/spectral_coordinate.py | 31,863 | Python |
"""项目配置"""
# 图灵机器人，99元一月付费版，尽情享用！
tuling_api_key = '88f17f853d974387af64955bed9466f4'
# 自动回复
is_friend_auto_reply = False # 好友自动回复
is_group_reply = False # 此项表示群中是否回复
is_group_at_reply = False # 上一项开启后此项才生效
is_forward_revoke_msg = True # 开启防撤回模式
is_forward_group_at_msg = False # 转发群@我的消息
# 机器人主人
bot_master_name = '' # 使用备注名更安全，只允许一个，可远程控制机器人，如果不设置(空)则将文件助手设置为管理员，但不具备远程控制功能
# 监听某些好友群聊，如老板
is_listen_friend = False
listen_friend_names = '猪哥' # 需要监听的人名称，使用备注名更安全，允许多个用|分隔，如：主管|项目经理|产品狗
listen_friend_groups = 'Python新手交流' # 在这些群里监听好友说的话，匹配模式：包含“唯一集团工作群”的群
# 转发信息至群
is_forward_mode = False # 打开转发模式，主人发送给机器人的消息都将转发至forward_groups群
forward_groups = 'Python新手交流' # 需要将消息转发的群，匹配模式同上
# 群分享监控
is_listen_sharing = False
listen_sharing_groups = 'Python新手交流' # 监控群分享，匹配模式同上
| 25.322581 | 79 | 0.782166 | [
"MIT"
] | ChriXChan/tools | pyp/wxrobot-master/config.py | 1,349 | Python |
# -*- coding: utf-8 -*-
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
# sys.path.insert(0, os.path.abspath('.'))
# -- Hack for ReadTheDocs ------------------------------------------------------
# This hack is necessary since RTD does not issue `sphinx-apidoc` before running
# `sphinx-build -b html . _build/html`. See Issue:
# https://github.com/rtfd/readthedocs.org/issues/1139
# DON'T FORGET: Check the box "Install your project inside a virtualenv using
# setup.py install" in the RTD Advanced Settings.
import os
on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
if on_rtd:
import inspect
from sphinx import apidoc
__location__ = os.path.join(os.getcwd(), os.path.dirname(
inspect.getfile(inspect.currentframe())))
output_dir = os.path.join(__location__, "../docs/api")
module_dir = os.path.join(__location__, "../cortex")
cmd_line_template = "sphinx-apidoc -f -o {outputdir} {moduledir}"
cmd_line = cmd_line_template.format(outputdir=output_dir, moduledir=module_dir)
apidoc.main(cmd_line.split(" "))
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.todo',
'sphinx.ext.autosummary', 'sphinx.ext.viewcode', 'sphinx.ext.coverage',
'sphinx.ext.doctest', 'sphinx.ext.ifconfig', 'sphinx.ext.pngmath',
'sphinx.ext.napoleon']
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
# source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'cortex'
copyright = u'2017, sherazkhan'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '' # Is set by calling `setup.py docs`
# The full version, including alpha/beta/rc tags.
release = '' # Is set by calling `setup.py docs`
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
# language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
# today = ''
# Else, today_fmt is used as the format for a strftime call.
# today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all documents.
# default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
# add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
# add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
# show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
# modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
# keep_warnings = False
# -- Options for HTML output ---------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'alabaster'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
# html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
# html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
try:
from cortex import __version__ as version
except ImportError:
pass
else:
release = version
# A shorter title for the navigation bar. Default is the same as html_title.
# html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
# html_logo = ""
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
# html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
# html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
# html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
# html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
# html_additional_pages = {}
# If false, no module index is generated.
# html_domain_indices = True
# If false, no index is generated.
# html_use_index = True
# If true, the index is split into individual pages for each letter.
# html_split_index = False
# If true, links to the reST sources are added to the pages.
# html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
# html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
# html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
# html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
# html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'cortex-doc'
# -- Options for LaTeX output --------------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
# 'preamble': '',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
('index', 'user_guide.tex', u'cortex Documentation',
u'sherazkhan', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
# latex_logo = ""
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
# latex_use_parts = False
# If true, show page references after internal links.
# latex_show_pagerefs = False
# If true, show URL addresses after external links.
# latex_show_urls = False
# Documents to append as an appendix to all manuals.
# latex_appendices = []
# If false, no module index is generated.
# latex_domain_indices = True
# -- External mapping ------------------------------------------------------------
python_version = '.'.join(map(str, sys.version_info[0:2]))
intersphinx_mapping = {
'sphinx': ('http://sphinx.pocoo.org', None),
'python': ('http://docs.python.org/' + python_version, None),
'matplotlib': ('http://matplotlib.sourceforge.net', None),
'numpy': ('http://docs.scipy.org/doc/numpy', None),
'sklearn': ('http://scikit-learn.org/stable', None),
'pandas': ('http://pandas.pydata.org/pandas-docs/stable', None),
'scipy': ('http://docs.scipy.org/doc/scipy/reference/', None),
}
| 34.768 | 85 | 0.70168 | [
"MIT"
] | SherazKhan/cortex | docs/conf.py | 8,692 | Python |
# -*- coding: UTF-8 -*-
# Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.
#
# You may assume no duplicates in the array.
#
# Here are few examples.
# [1,3,5,6], 5 → 2
# [1,3,5,6], 2 → 1
# [1,3,5,6], 7 → 4
# [1,3,5,6], 0 → 0
#
# Python, Python 3 all accepted.
class SearchInsertPosition(object):
def searchInsert(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: int
"""
if nums is None or len(nums) == 0:
return 0
for i in range(0, len(nums)):
if nums[i] == target:
return i
elif nums[i] < target:
if (i + 1 < len(nums) and nums[i + 1] > target) or i + 1 == len(nums):
return i + 1
return 0
| 26.69697 | 156 | 0.523269 | [
"MIT"
] | TonnyL/Windary | Python/SearchInsertPosition.py | 889 | Python |
import math
import numpy as np
from kinematics.forward import ForwardKinematics
from kinematics.kinematics import Kinematics
from kinematics.solution import InverseKinematicsShoulderSolution, InverseKinematicsSpecificSolution, \
InverseKinematicsSolution, InverseKinematicsWristSolution
class InverseKinematics(Kinematics):
def __init__(self):
super().__init__()
self.forward_kinematics = ForwardKinematics()
def __clamp_cos_sin_within_threshold(self, cos_or_sin):
new_val = cos_or_sin
if 1 < new_val <= 1.2:
new_val = 1.0
elif -1.2 <= new_val < -1:
new_val = -1.0
return new_val
def __compute_solution_for_theta_1(self, T06, theta_1, debug=False):
wrist_solution = InverseKinematicsWristSolution()
# Theta 5
P06 = T06[:, 3]
theta_5_1 = None
theta_5_2 = None
theta_5_cos = (P06[0] * math.sin(theta_1) - P06[1] * np.cos(
theta_1) - self.joint4_dh.d) / self.joint6_dh.d
theta_5_cos = self.__clamp_cos_sin_within_threshold(theta_5_cos)
if -1 <= theta_5_cos <= 1:
theta_5_1 = math.acos(theta_5_cos)
theta_5_2 = -math.acos(theta_5_cos)
sigma = 0.00001
if theta_5_1 is not None and not -sigma <= math.sin(theta_5_1) <= sigma:
wrist_solution.solution_wrist_up = self.__compute_solution_for_wrist(theta_1, theta_5_1, T06)
else:
wrist_solution.solution_wrist_up.is_valid_solution = False
if theta_5_2 is not None and not -sigma <= math.sin(theta_5_2) <= sigma:
wrist_solution.solution_wrist_down = self.__compute_solution_for_wrist(theta_1, theta_5_2, T06)
else:
wrist_solution.solution_wrist_down.is_valid_solution = False
if not wrist_solution.solution_wrist_up.is_valid_solution and not wrist_solution.solution_wrist_down.is_valid_solution:
wrist_solution.is_valid_solution = False
if debug:
print(f"Theta 5: {theta_5_1:.3f}, {theta_5_2:.3f}")
return wrist_solution
def __compute_solution_for_wrist(self, theta_1, theta_5, T06, debug=False):
shoulder_solution = InverseKinematicsShoulderSolution()
# Theta 6
T60 = np.linalg.inv(T06)
X60 = T60[:, 0]
Y60 = T60[:, 1]
theta_6_cos = (X60[0] * math.sin(theta_1) - Y60[0] * math.cos(theta_1)) / math.sin(
theta_5) # only using one of the theta 5's for now..
theta_6_sin = (-X60[1] * math.sin(theta_1) + Y60[1] * math.cos(theta_1)) / math.sin(
theta_5) # only using one of the theta 5's for now..
theta_6 = math.atan2(theta_6_sin, theta_6_cos)
if debug:
print(f"Theta 6: {theta_6:.3f}")
tm_dict = {}
# Theta 3
T01 = self.compute_transformation_matrix(theta_1, self.joint1_dh)
T45 = self.compute_transformation_matrix(theta_5, self.joint5_dh)
T56 = self.compute_transformation_matrix(theta_6, self.joint6_dh)
T46 = np.matmul(T45, T56)
T64 = np.linalg.inv(T46)
T10 = np.linalg.inv(T01)
T14 = np.matmul(np.matmul(T10, T06), T64)
P14 = T14[:, 3]
tm_dict["T06"] = T06
tm_dict["T01"] = T01
tm_dict["T45"] = T45
tm_dict["T56"] = T56
tm_dict["T64"] = T64
tm_dict["T10"] = T10
tm_dict["T14"] = T14
tm_dict["P14"] = P14
theta_3_cos = (math.sqrt(
P14[0] ** 2 + P14[2] ** 2) ** 2 - self.joint3_dh.a ** 2 - self.joint4_dh.a ** 2) / (
2 * (-self.joint3_dh.a) * (-self.joint4_dh.a))
if debug:
print("theta3_cos: ", theta_3_cos)
theta_3_cos = self.__clamp_cos_sin_within_threshold(theta_3_cos)
if not -1 <= theta_3_cos <= 1:
shoulder_solution.is_valid_solution = False
return shoulder_solution
theta_3_up = math.acos(theta_3_cos)
theta_3_down = -math.acos(theta_3_cos)
if debug:
print(f"Theta 3: Up: {theta_3_up:.3f} Down: {theta_3_down:.3f}")
shoulder_solution.solution_elbow_up = self.__compute_specific_solution(theta_1, theta_3_up, theta_5, theta_6, tm_dict)
shoulder_solution.solution_elbow_down = self.__compute_specific_solution(theta_1, theta_3_down, theta_5, theta_6, tm_dict)
return shoulder_solution
def __compute_specific_solution(self, theta_1, theta_3, theta_5, theta_6, tm_dict, debug=False):
specific_solution = InverseKinematicsSpecificSolution()
P14 = tm_dict["P14"]
phi_1 = math.atan2(-P14[2], -P14[0])
phi_2 = math.asin((-self.joint4_dh.a * math.sin(theta_3)) / math.sqrt(P14[0]**2 + P14[2]**2))
theta_2 = phi_1 - phi_2
if debug:
print(f"Theta 2: {theta_2:.3f}")
T01 = tm_dict["T01"]
T12 = self.compute_transformation_matrix(theta_2, self.joint2_dh)
T23 = self.compute_transformation_matrix(theta_3, self.joint3_dh)
T45 = tm_dict["T45"]
T56 = tm_dict["T56"]
T06 = tm_dict["T06"]
T03 = np.matmul(np.matmul(T01, T12), T23)
T30 = np.linalg.inv(T03)
T64 = tm_dict["T64"]
T34 = np.matmul(np.matmul(T30, T06), T64)
X34 = T34[:, 0]
theta_4 = math.atan2(X34[1], X34[0])
if debug:
print(f"Theta 4: {theta_4:.3f}")
specific_solution.thetas = [theta_1, theta_2, theta_3, theta_4, theta_5, theta_6]
return specific_solution
def __print_all_solutions(self, solution):
print("Inverse Solutions:")
if solution.solution_shoulder_left.is_valid_solution:
if solution.solution_shoulder_left.solution_wrist_up.is_valid_solution:
if solution.solution_shoulder_left.solution_wrist_up.solution_elbow_up.is_valid_solution:
print(
f"Shoulder left, wrist up, elbow up: {solution.solution_shoulder_left.solution_wrist_up.solution_elbow_up.thetas}")
if solution.solution_shoulder_left.solution_wrist_up.solution_elbow_down.is_valid_solution:
print(
f"Shoulder left, wrist up, elbow down: {solution.solution_shoulder_left.solution_wrist_up.solution_elbow_down.thetas}")
if solution.solution_shoulder_left.solution_wrist_down.is_valid_solution:
if solution.solution_shoulder_left.solution_wrist_down.solution_elbow_up.is_valid_solution:
print(
f"Shoulder left, wrist down, elbow up: {solution.solution_shoulder_left.solution_wrist_down.solution_elbow_up.thetas}")
if solution.solution_shoulder_left.solution_wrist_down.solution_elbow_down:
print(
f"Shoulder left, wrist down, elbow down: {solution.solution_shoulder_left.solution_wrist_down.solution_elbow_down.thetas}")
if solution.solution_shoulder_right.is_valid_solution:
if solution.solution_shoulder_right.solution_wrist_up.is_valid_solution:
if solution.solution_shoulder_right.solution_wrist_up.solution_elbow_up.is_valid_solution:
print(
f"Shoulder right, wrist up, elbow up: {solution.solution_shoulder_right.solution_wrist_up.solution_elbow_up.thetas}")
if solution.solution_shoulder_right.solution_wrist_up.solution_elbow_down.is_valid_solution:
print(
f"Shoulder right, wrist up, elbow down: {solution.solution_shoulder_right.solution_wrist_up.solution_elbow_up.thetas}")
if solution.solution_shoulder_right.solution_wrist_down.is_valid_solution:
if solution.solution_shoulder_right.solution_wrist_down.solution_elbow_up.is_valid_solution:
print(
f"Shoulder right, wrist down, elbow up: {solution.solution_shoulder_right.solution_wrist_down.solution_elbow_up.thetas}")
if solution.solution_shoulder_right.solution_wrist_down.solution_elbow_down.is_valid_solution:
print(
f"Shoulder right, wrist down, elbow down: {solution.solution_shoulder_right.solution_wrist_down.solution_elbow_up.thetas}")
def compute_joint_angles(self, T06, debug=False):
solution = InverseKinematicsSolution()
#Theta 1
P05 = np.dot(T06, [0, 0, -self.joint6_dh.d, 1])
phi_1 = math.atan2(P05[1], P05[0])
phi_2_cos = self.joint4_dh.d / math.sqrt(P05[0]**2 + P05[1]**2)
phi_2 = math.acos(phi_2_cos)
theta_1_1 = phi_1 + phi_2 + (np.pi / 2)
theta_1_2 = phi_1 - phi_2 + (np.pi / 2)
if debug:
print(f"Theta 1: {theta_1_1:.3f}, {theta_1_2:.3f}")
if not math.isnan(theta_1_1):
solution.solution_shoulder_left = self.__compute_solution_for_theta_1(T06, theta_1_1, debug)
else:
solution.solution_shoulder_left = InverseKinematicsWristSolution().is_valid_solution = False
if not math.isnan(theta_1_2):
solution.solution_shoulder_right = self.__compute_solution_for_theta_1(T06, theta_1_2, debug)
else:
solution.solution_shoulder_right = InverseKinematicsWristSolution().is_valid_solution = False
if debug:
self.__print_all_solutions(solution)
return solution
def get_solution_for_config_id(self, solution, config_id):
if config_id == 0:
return solution.solution_shoulder_left.solution_wrist_up.solution_elbow_up.thetas
elif config_id == 1:
return solution.solution_shoulder_left.solution_wrist_up.solution_elbow_down.thetas
elif config_id == 2:
return solution.solution_shoulder_left.solution_wrist_down.solution_elbow_up.thetas
elif config_id == 3:
return solution.solution_shoulder_left.solution_wrist_down.solution_elbow_down.thetas
elif config_id == 4:
return solution.solution_shoulder_right.solution_wrist_up.solution_elbow_up.thetas
elif config_id == 5:
return solution.solution_shoulder_right.solution_wrist_up.solution_elbow_down.thetas
elif config_id == 6:
return solution.solution_shoulder_right.solution_wrist_down.solution_elbow_up.thetas
elif config_id == 7:
return solution.solution_shoulder_right.solution_wrist_down.solution_elbow_down.thetas
else:
raise Exception("invalid config solution id")
def get_best_solution_for_config_id(self, T06, config_id):
solution = self.compute_joint_angles(T06)
if self.is_valid_solution_by_config_id(solution, config_id):
return self.get_solution_for_config_id(solution, config_id)
else:
index = config_id + 1
checked_all = False
while not checked_all:
if index >= 8:
index = 0
if index == config_id:
print('Found no valid solutions..')
return None
if self.is_valid_solution_by_config_id(solution, index):
return self.get_solution_for_config_id(solution, index)
index += 1
def is_valid_solution_by_config_id(self, solution, config_id):
if 0 <= config_id < 4 and solution.solution_shoulder_left.is_valid_solution:
if 0 <= config_id < 2 and solution.solution_shoulder_left.solution_wrist_up.is_valid_solution:
if config_id == 0 and solution.solution_shoulder_left.solution_wrist_up.solution_elbow_up.is_valid_solution:
return True
if config_id == 1 and solution.solution_shoulder_left.solution_wrist_up.solution_elbow_down.is_valid_solution:
return True
if 2 <= config_id < 4 and solution.solution_shoulder_left.solution_wrist_down.is_valid_solution:
if config_id == 2 and solution.solution_shoulder_left.solution_wrist_down.solution_elbow_up.is_valid_solution:
return True
if config_id == 3 and solution.solution_shoulder_left.solution_wrist_down.solution_elbow_down:
return True
if 4 <= config_id < 8 and solution.solution_shoulder_right.is_valid_solution:
if 4 <= config_id < 6 and solution.solution_shoulder_right.solution_wrist_up.is_valid_solution:
if config_id == 4 and solution.solution_shoulder_right.solution_wrist_up.solution_elbow_up.is_valid_solution:
return True
if config_id == 5 and solution.solution_shoulder_right.solution_wrist_up.solution_elbow_down.is_valid_solution:
return True
if 6 <= config_id < 8 and solution.solution_shoulder_right.solution_wrist_down.is_valid_solution:
if config_id == 6 and solution.solution_shoulder_right.solution_wrist_down.solution_elbow_up.is_valid_solution:
return True
if config_id == 7 and solution.solution_shoulder_right.solution_wrist_down.solution_elbow_down.is_valid_solution:
return True
else:
return False
def get_current_configuration_id(self, joint_angles):
T06 = self.forward_kinematics.compute_0_to_6_matrix(joint_angles)
solution = self.compute_joint_angles(T06)
differences = np.full(8, 1000)
if solution.solution_shoulder_left.is_valid_solution:
if solution.solution_shoulder_left.solution_wrist_up.is_valid_solution:
if solution.solution_shoulder_left.solution_wrist_up.solution_elbow_up.is_valid_solution:
differences[0] = 0
if solution.solution_shoulder_left.solution_wrist_up.solution_elbow_down.is_valid_solution:
differences[1] = 0
if solution.solution_shoulder_left.solution_wrist_down.is_valid_solution:
if solution.solution_shoulder_left.solution_wrist_down.solution_elbow_up.is_valid_solution:
differences[2] = 0
if solution.solution_shoulder_left.solution_wrist_down.solution_elbow_down:
differences[3] = 0
if solution.solution_shoulder_right.is_valid_solution:
if solution.solution_shoulder_right.solution_wrist_up.is_valid_solution:
if solution.solution_shoulder_right.solution_wrist_up.solution_elbow_up.is_valid_solution:
differences[4] = 0
if solution.solution_shoulder_right.solution_wrist_up.solution_elbow_down.is_valid_solution:
differences[5] = 0
if solution.solution_shoulder_right.solution_wrist_down.is_valid_solution:
if solution.solution_shoulder_right.solution_wrist_down.solution_elbow_up.is_valid_solution:
differences[6] = 0
if solution.solution_shoulder_right.solution_wrist_down.solution_elbow_down.is_valid_solution:
differences[7] = 0
for i in range(6):
if solution.solution_shoulder_left.is_valid_solution:
if solution.solution_shoulder_left.solution_wrist_up.is_valid_solution:
if solution.solution_shoulder_left.solution_wrist_up.solution_elbow_up.is_valid_solution:
differences[0] += abs(joint_angles[i] - solution.solution_shoulder_left.solution_wrist_up.solution_elbow_up.thetas[i])
if solution.solution_shoulder_left.solution_wrist_up.solution_elbow_down.is_valid_solution:
differences[1] += abs(joint_angles[i] - solution.solution_shoulder_left.solution_wrist_up.solution_elbow_down.thetas[i])
if solution.solution_shoulder_left.solution_wrist_down.is_valid_solution:
if solution.solution_shoulder_left.solution_wrist_down.solution_elbow_up.is_valid_solution:
differences[2] += abs(joint_angles[i] - solution.solution_shoulder_left.solution_wrist_down.solution_elbow_up.thetas[i])
if solution.solution_shoulder_left.solution_wrist_down.solution_elbow_down:
differences[3] += abs(joint_angles[i] - solution.solution_shoulder_left.solution_wrist_down.solution_elbow_down.thetas[i])
if solution.solution_shoulder_right.is_valid_solution:
if solution.solution_shoulder_right.solution_wrist_up.is_valid_solution:
if solution.solution_shoulder_right.solution_wrist_up.solution_elbow_up.is_valid_solution:
differences[4] += abs(joint_angles[i] - solution.solution_shoulder_right.solution_wrist_up.solution_elbow_up.thetas[i])
if solution.solution_shoulder_right.solution_wrist_up.solution_elbow_down.is_valid_solution:
differences[5] += abs(joint_angles[i] - solution.solution_shoulder_right.solution_wrist_up.solution_elbow_down.thetas[i])
if solution.solution_shoulder_right.solution_wrist_down.is_valid_solution:
if solution.solution_shoulder_right.solution_wrist_down.solution_elbow_up.is_valid_solution:
differences[6] += abs(joint_angles[i] - solution.solution_shoulder_right.solution_wrist_down.solution_elbow_up.thetas[i])
if solution.solution_shoulder_right.solution_wrist_down.solution_elbow_down.is_valid_solution:
differences[7] += abs(joint_angles[i] - solution.solution_shoulder_right.solution_wrist_down.solution_elbow_down.thetas[i])
print(differences)
return np.argmin(differences)
| 53.836364 | 147 | 0.672295 | [
"MIT"
] | EmilRyberg/P8LH7Grounding | webots/controllers/ur_controller/kinematics/inverse.py | 17,766 | Python |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
das developers note:
This a is modification of the original SpacePy pycdf package. All
refereneces to the greater spacepy package have been removed to create
a small standalone module.
--cwp 2018-10-18
The libcdf.so location code has been changed to find the version installed
in anaconda.
--cwp 2020-04-06
This package provides a Python interface to the Common Data Format (CDF)
library used for many NASA missions, available at http://cdf.gsfc.nasa.gov/.
It is targeted at Python 2.6+ and should work without change on either
Python 2 or Python 3.
The interface is intended to be 'pythonic' rather than reproducing the
C interface. To open or close a CDF and access its variables, see the :class:`CDF`
class. Accessing data within the variables is via the :class:`Var`
class. The :data:`lib` object provides access to some routines
that affect the functionality of the library in general. The
:mod:`~pycdf.const` module contains constants useful for accessing
the underlying library.
Authors: Jon Niehof
Institution: University of New Hampshire
Contact: [email protected]
Copyright 2010-2015 Los Alamos National Security, LLC.
"""
__contact__ = 'Jon Niehof, [email protected]'
try:
from collections.abc import MutableMapping, MutableSequence
except ImportError:
from collections import MutableMapping, MutableSequence
import ctypes
import ctypes.util
import datetime
import operator
import os
import os.path
import shutil
import sys
import tempfile
import warnings
import weakref
import numpy
import numpy.ma
#Import const AFTER library loaded, so failed load doesn't leave half-imported
#from . import const
try:
str_classes = (str, bytes, unicode)
except NameError:
str_classes = (str, bytes)
class Library(object):
"""
Abstraction of the base CDF C library and its state.
Not normally intended for end-user use. An instance of this class
is created at package load time as the :data:`~pycdf.lib` variable, providing
access to the underlying C library if necessary. The CDF library itself
is described in section 2.1 of the CDF user's guide, as well as the CDF
C reference manual.
Calling the C library directly requires knowledge of
:mod:`ctypes`.
Instantiating this object loads the C library, see :doc:`/pycdf` docs
for details.
.. autosummary::
~Library.call
~Library.check_status
~Library.datetime_to_epoch
~Library.datetime_to_epoch16
~Library.datetime_to_tt2000
~Library.epoch_to_datetime
~Library.epoch_to_epoch16
~Library.epoch_to_num
~Library.epoch_to_tt2000
~Library.epoch16_to_datetime
~Library.epoch16_to_epoch
~Library.epoch16_to_tt2000
~Library.set_backward
supports_int8
~Library.tt2000_to_datetime
~Library.tt2000_to_epoch
~Library.tt2000_to_epoch16
v_datetime_to_epoch
v_datetime_to_epoch16
v_datetime_to_tt2000
v_epoch_to_datetime
v_epoch_to_tt2000
v_epoch16_to_datetime
v_epoch16_to_tt2000
v_tt2000_to_datetime
v_tt2000_to_epoch
v_tt2000_to_epoch16
libpath
version
.. automethod:: call
.. automethod:: check_status
.. automethod:: datetime_to_epoch
.. automethod:: datetime_to_epoch16
.. automethod:: datetime_to_tt2000
.. automethod:: epoch_to_datetime
.. automethod:: epoch_to_epoch16
.. automethod:: epoch_to_num
.. automethod:: epoch_to_tt2000
.. automethod:: epoch16_to_datetime
.. automethod:: epoch16_to_epoch
.. automethod:: epoch16_to_tt2000
.. automethod:: set_backward
.. attribute:: supports_int8
True if this library supports INT8 and TIME_TT2000 types; else False.
.. automethod:: tt2000_to_datetime
.. automethod:: tt2000_to_epoch
.. automethod:: tt2000_to_epoch16
.. method:: v_datetime_to_epoch(datetime)
A vectorized version of :meth:`datetime_to_epoch` which takes a
numpy array of datetimes as input and returns an array of epochs.
.. method:: v_datetime_to_epoch16(datetime)
A vectorized version of :meth:`datetime_to_epoch16` which takes a
numpy array of datetimes as input and returns an array of epoch16.
.. method:: v_datetime_to_tt2000(datetime)
A vectorized version of :meth:`datetime_to_tt2000` which takes a
numpy array of datetimes as input and returns an array of TT2000.
.. method:: v_epoch_to_datetime(epoch)
A vectorized version of :meth:`epoch_to_datetime` which takes a
numpy array of epochs as input and returns an array of datetimes.
.. method:: v_epoch_to_tt2000(epoch)
A vectorized version of :meth:`epoch_to_tt2000` which takes a
numpy array of epochs as input and returns an array of tt2000s.
.. method:: v_epoch16_to_datetime(epoch0, epoch1)
A vectorized version of :meth:`epoch16_to_datetime` which takes
a numpy array of epoch16 as input and returns an array of datetimes.
An epoch16 is a pair of doubles; the input array's last dimension
must be two (and the returned array will have one fewer dimension).
.. method:: v_epoch16_to_tt2000(epoch16)
A vectorized version of :meth:`epoch16_to_tt2000` which takes
a numpy array of epoch16 as input and returns an array of tt2000s.
An epoch16 is a pair of doubles; the input array's last dimension
must be two (and the returned array will have one fewer dimension).
.. method:: v_tt2000_to_datetime(tt2000)
A vectorized version of :meth:`tt2000_to_datetime` which takes
a numpy array of tt2000 as input and returns an array of datetimes.
.. method:: v_tt2000_to_epoch(tt2000)
A vectorized version of :meth:`tt2000_to_epoch` which takes
a numpy array of tt2000 as input and returns an array of epochs.
.. method:: v_tt2000_to_epoch16(tt2000)
A vectorized version of :meth:`tt2000_to_epoch16` which takes
a numpy array of tt2000 as input and returns an array of epoch16.
.. attribute:: libpath
The path where pycdf found the CDF C library, potentially useful in
debugging. If this contains just the name of a file (with no path
information), then the system linker found the library for pycdf.
On Linux, ``ldconfig -p`` may be useful for displaying the system's
library resolution.
.. attribute:: version
Version of the CDF library, (version, release, increment, subincrement)
"""
def __init__(self, libpath=None, library=None):
"""Load the CDF C library.
Searches for the library in the order:
1. Appropriately-named file in CDF_LIB
2. Appropriately-named file in CDF_BASE
3. Standard library search path
@raise CDFError: BAD_DATA_TYPE if can't map types properly
"""
if not 'CDF_TMP' in os.environ:
os.environ['CDF_TMP'] = tempfile.gettempdir()
if not library:
if not libpath:
self.libpath, self._library = self._find_lib()
if self._library is None:
raise Exception((
'Cannot load CDF C library; checked {0}. '
'Try \'os.environ["CDF_LIB"] = library_directory\' '
'before import.').format(', '.join(self.libpath)))
else:
self._library = ctypes.CDLL(libpath)
self.libpath = libpath
else:
self._library = library
self.libpath = libpath
self._library.CDFlib.restype = ctypes.c_long #commonly used, so set it up here
self._library.EPOCHbreakdown.restype = ctypes.c_long
self._library.computeEPOCH.restype = ctypes.c_double
self._library.computeEPOCH.argtypes = [ctypes.c_long] * 7
self._library.computeEPOCH16.restype = ctypes.c_double
self._library.computeEPOCH16.argtypes = [ctypes.c_long] * 10 + \
[ctypes.POINTER(ctypes.c_double * 2)]
if hasattr(self._library, 'CDFsetFileBackward'):
self._library.CDFsetFileBackward.restype = None
self._library.CDFsetFileBackward.argtypes = [ctypes.c_long]
#Map old name to the 3.7.1+ name
if not hasattr(self._library, 'computeTT2000') \
and hasattr(self._library, 'CDF_TT2000_from_UTC_parts'):
self._library.computeTT2000 \
= self._library.CDF_TT2000_from_UTC_parts
if hasattr(self._library, 'computeTT2000'):
self._library.computeTT2000.restype = ctypes.c_longlong
self._library.computeTT2000.argtypes = \
[ctypes.c_double] *9
#Map old name to the 3.7.1+ name
if not hasattr(self._library, 'breakdownTT2000') \
and hasattr(self._library, 'CDF_TT2000_to_UTC_parts'):
self._library.breakdownTT2000 \
= self._library.CDF_TT2000_to_UTC_parts
if hasattr(self._library, 'breakdownTT2000'):
self._library.breakdownTT2000.restype = None
self._library.breakdownTT2000.argtypes = \
[ctypes.c_longlong] + [ctypes.POINTER(ctypes.c_double)] * 9
if hasattr(self._library, 'CDF_TT2000_to_UTC_EPOCH'):
self._library.CDF_TT2000_to_UTC_EPOCH.restype = ctypes.c_double
self._library.CDF_TT2000_to_UTC_EPOCH.argtypes = [ctypes.c_longlong]
if hasattr(self._library, 'CDF_TT2000_from_UTC_EPOCH'):
self._library.CDF_TT2000_from_UTC_EPOCH.restype = ctypes.c_longlong
self._library.CDF_TT2000_from_UTC_EPOCH.argtypes = [ctypes.c_double]
if hasattr(self._library, 'CDF_TT2000_to_UTC_EPOCH16'):
self._library.CDF_TT2000_to_UTC_EPOCH16.restype = ctypes.c_double
self._library.CDF_TT2000_to_UTC_EPOCH16.argtypes = \
[ctypes.c_longlong, ctypes.POINTER(ctypes.c_double * 2)]
if hasattr(self._library, 'CDF_TT2000_from_UTC_EPOCH16'):
self._library.CDF_TT2000_from_UTC_EPOCH16.restype = \
ctypes.c_longlong
self._library.CDF_TT2000_from_UTC_EPOCH16.argtypes = \
[ctypes.POINTER(ctypes.c_double * 2)]
#Get CDF version information
ver = ctypes.c_long(0)
rel = ctypes.c_long(0)
inc = ctypes.c_long(0)
sub = ctypes.c_char(b' ')
self.call(const.GET_, const.LIB_VERSION_, ctypes.byref(ver),
const.GET_, const.LIB_RELEASE_, ctypes.byref(rel),
const.GET_, const.LIB_INCREMENT_, ctypes.byref(inc),
const.GET_, const.LIB_subINCREMENT_, ctypes.byref(sub))
ver = ver.value
rel = rel.value
inc = inc.value
sub = sub.value
self.version = (ver, rel, inc, sub)
self._del_middle_rec_bug = ver < 3 or (ver == 3 and
(rel < 4 or
(rel == 4 and inc < 1)))
self.supports_int8 = (ver > 3 or (ver == 3 and rel >=4))
self.cdftypenames = {const.CDF_BYTE.value: 'CDF_BYTE',
const.CDF_CHAR.value: 'CDF_CHAR',
const.CDF_INT1.value: 'CDF_INT1',
const.CDF_UCHAR.value: 'CDF_UCHAR',
const.CDF_UINT1.value: 'CDF_UINT1',
const.CDF_INT2.value: 'CDF_INT2',
const.CDF_UINT2.value: 'CDF_UINT2',
const.CDF_INT4.value: 'CDF_INT4',
const.CDF_UINT4.value: 'CDF_UINT4',
const.CDF_INT8.value: 'CDF_INT8',
const.CDF_FLOAT.value: 'CDF_FLOAT',
const.CDF_REAL4.value: 'CDF_REAL4',
const.CDF_DOUBLE.value: 'CDF_DOUBLE',
const.CDF_REAL8.value: 'CDF_REAL8',
const.CDF_EPOCH.value: 'CDF_EPOCH',
const.CDF_EPOCH16.value: 'CDF_EPOCH16',
const.CDF_TIME_TT2000.value: 'CDF_TIME_TT2000',
}
self.numpytypedict = {const.CDF_BYTE.value: numpy.int8,
const.CDF_CHAR.value: numpy.int8,
const.CDF_INT1.value: numpy.int8,
const.CDF_UCHAR.value: numpy.uint8,
const.CDF_UINT1.value: numpy.uint8,
const.CDF_INT2.value: numpy.int16,
const.CDF_UINT2.value: numpy.uint16,
const.CDF_INT4.value: numpy.int32,
const.CDF_UINT4.value: numpy.uint32,
const.CDF_INT8.value: numpy.int64,
const.CDF_FLOAT.value: numpy.float32,
const.CDF_REAL4.value: numpy.float32,
const.CDF_DOUBLE.value: numpy.float64,
const.CDF_REAL8.value: numpy.float64,
const.CDF_EPOCH.value: numpy.float64,
const.CDF_EPOCH16.value:
numpy.dtype((numpy.float64, 2)),
const.CDF_TIME_TT2000.value: numpy.int64,
}
self.timetypes = [const.CDF_EPOCH.value,
const.CDF_EPOCH16.value,
const.CDF_TIME_TT2000.value]
if not self.supports_int8:
del self.cdftypenames[const.CDF_INT8.value]
del self.numpytypedict[const.CDF_INT8.value]
del self.cdftypenames[const.CDF_TIME_TT2000.value]
del self.numpytypedict[const.CDF_TIME_TT2000.value]
elif sys.platform.startswith('linux') \
and os.uname()[4].startswith('arm') \
and hasattr(self._library, 'computeTT2000') \
and self._library.computeTT2000(
2010, 1, 1, 0, 0, 0, 0, 0, 0) != 315576066184000000:
#TT2000 call failed, so probably need to type-pun
#double arguments to variadic functions.
#Calling convention for non-variadic functions with floats
#is unique, but convention for ints is same as variadic.
#So type-pun arguments to integers to force that calling
#convention.
if ctypes.sizeof(ctypes.c_longlong) != \
ctypes.sizeof(ctypes.c_double):
warnings.warn('ARM with unknown type sizes; '
'TT2000 functions will not work.')
else:
self._library.computeTT2000.argtypes = \
[ctypes.c_longlong] * 9
c_ll_p = ctypes.POINTER(ctypes.c_longlong)
if self._library.computeTT2000(
ctypes.cast(ctypes.pointer(ctypes.c_double(
2010)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
1)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
1)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
0)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
0)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
0)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
0)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
0)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
0)), c_ll_p).contents) != 315576066184000000:
warnings.warn('ARM with unknown calling convention; '
'TT2000 functions will not work.')
self.datetime_to_tt2000 = self._datetime_to_tt2000_typepunned
v_epoch16_to_datetime = numpy.frompyfunc(
self.epoch16_to_datetime, 2, 1)
self.v_epoch16_to_datetime = \
lambda x: v_epoch16_to_datetime(x[..., 0], x[..., 1])
self.v_epoch_to_datetime = numpy.frompyfunc(
self.epoch_to_datetime, 1, 1)
self.v_tt2000_to_datetime = numpy.frompyfunc(
self.tt2000_to_datetime, 1, 1)
self.v_datetime_to_epoch = numpy.vectorize(
self.datetime_to_epoch, otypes=[numpy.float64])
v_datetime_to_epoch16 = numpy.frompyfunc(
self.datetime_to_epoch16, 1, 2)
#frompyfunc returns a TUPLE of the returned values,
#implicitly the 0th dimension. We want everything from one
#call paired, so this rolls the 0th dimension to the last
#(via the second-to-last)
def _v_datetime_to_epoch16(x):
retval = numpy.require(v_datetime_to_epoch16(x),
dtype=numpy.float64)
if len(retval.shape) > 1:
return numpy.rollaxis(
numpy.rollaxis(retval, 0, -1),
-1, -2)
else:
return retval
self.v_datetime_to_epoch16 = _v_datetime_to_epoch16
self.v_datetime_to_tt2000 = numpy.vectorize(
self.datetime_to_tt2000, otypes=[numpy.int64])
self.v_epoch_to_tt2000 = numpy.vectorize(
self.epoch_to_tt2000, otypes=[numpy.int64])
self.v_tt2000_to_epoch = numpy.vectorize(
self.tt2000_to_epoch, otypes=[numpy.float64])
v_epoch16_to_tt2000 = numpy.frompyfunc(
self.epoch16_to_tt2000, 2, 1)
self.v_epoch16_to_tt2000 = \
lambda x: v_epoch16_to_tt2000(x[..., 0], x[..., 1])
v_tt2000_to_epoch16 = numpy.frompyfunc(
self.tt2000_to_epoch16, 1, 2)
#frompyfunc returns a TUPLE of the returned values,
#implicitly the 0th dimension. We want everything from one
#call paired, so this rolls the 0th dimension to the last
#(via the second-to-last)
def _v_tt2000_to_epoch16(x):
retval = numpy.require(v_tt2000_to_epoch16(x),
dtype=numpy.float64)
if len(retval.shape) > 1:
return numpy.rollaxis(
numpy.rollaxis(retval, 0, -1),
-1, -2)
else:
return retval
self.v_tt2000_to_epoch16 = _v_tt2000_to_epoch16
if not self.supports_int8:
self.datetime_to_tt2000 = self._bad_tt2000
self.tt2000_to_datetime = self._bad_tt2000
self.v_datetime_to_tt2000 = self._bad_tt2000
self.v_tt2000_to_datetime = self._bad_tt2000
self.epoch_to_tt2000 = self._bad_tt2000
self.v_epoch_to_tt2000 = self._bad_tt2000
self.tt2000_to_epoch = self._bad_tt2000
self.v_tt2000_to_epoch = self._bad_tt2000
self.epoch_16_to_tt2000 = self._bad_tt2000
self.v_epoch16_to_tt2000 = self._bad_tt2000
self.tt2000_to_epoch16 = self._bad_tt2000
self.v_tt2000_to_epoch16 = self._bad_tt2000
#Default to V2 CDF
self.set_backward(True)
@staticmethod
def _find_lib():
"""
Search for the CDF library
Searches in likely locations for CDF libraries and attempts to load
them. Stops at first successful load and, if fails, reports all
the files that were tried as libraries.
Returns
=======
out : tuple
This is either (path to library, loaded library)
or, in the event of failure, (None, list of libraries tried)
"""
failed = []
for libpath in Library._lib_paths():
try:
lib = ctypes.CDLL(libpath)
except:
failed.append(libpath)
else:
return libpath, lib
return (failed, None)
@staticmethod
def _lib_paths():
"""Find candidate paths for the CDF library
Does not check that the library is actually in any particular directory,
just returns a list of possible locations, in priority order.
Returns
=======
out : generator of str
paths that look like the CDF library
"""
#What the library might be named
names = { 'win32': ['cdf.dll'],
'darwin': ['libcdf.dylib', 'cdf.dylib', 'libcdf.so'],
'linux2': ['libcdf.so'],
'linux': ['libcdf.so'],
}
names = names.get(sys.platform, ['libcdf.so'])
#All existing CDF-library-like paths within a directory
search_dir = lambda x: \
[os.path.join(x, fname) for fname in names
if os.path.exists(os.path.join(x, fname))]
# Only use anaconda locations...
# Defined during builds ...
if 'PREFIX' in os.environ:
if sys.platform == 'win32':
for p in search_dir(os.path.join(os.environ['PREFIX'], 'Library', 'bin')):
yield p
else:
for p in search_dir(os.path.join(os.environ['PREFIX'], 'lib')):
yield p
# defined when conda is activated ...
if 'CONDA_PREFIX' in os.environ:
if sys.platform == 'win32':
for p in search_dir(os.path.join(os.environ['CONDA_PREFIX'], 'Library', 'bin')):
yield p
else:
for p in search_dir(os.path.join(os.environ['CONDA_PREFIX'], 'lib')):
yield p
# Special subdirectory for anaconda unix packages on windows
if 'LIBRARY_BIN' in os.environ:
for p in search_dir(os.environ['LIBRARY_BIN']):
yield p
ctypespath = ctypes.util.find_library(
'cdf.dll' if sys.platform == 'win32' else 'cdf')
if ctypespath:
yield ctypespath
def check_status(self, status, ignore=()):
"""
Raise exception or warning based on return status of CDF call
Parameters
==========
status : int
status returned by the C library
Other Parameters
================
ignore : sequence of ctypes.c_long
CDF statuses to ignore. If any of these is returned by CDF library,
any related warnings or exceptions will *not* be raised.
(Default none).
Raises
======
CDFError : if status < CDF_WARN, indicating an error
Warns
=====
CDFWarning : if CDF_WARN <= status < CDF_OK, indicating a warning.
Returns
=======
out : int
status (unchanged)
"""
if status == const.CDF_OK or status in ignore:
return status
if status < const.CDF_WARN:
raise CDFError(status)
else:
warning = CDFWarning(status)
warning.warn()
return status
def call(self, *args, **kwargs):
"""
Call the CDF internal interface
Passes all parameters directly through to the CDFlib routine of the
CDF library's C internal interface. Checks the return value with
:meth:`check_status`.
Terminal NULL is automatically added to args.
Parameters
==========
args : various, see :mod:`ctypes`
Passed directly to the CDF library interface. Useful
constants are defined in the :mod:`~pycdf.const` module.
Other Parameters
================
ignore : sequence of CDF statuses
sequence of CDF statuses to ignore. If any of these
is returned by CDF library, any related warnings or
exceptions will *not* be raised.
Returns
=======
out : int
CDF status from the library
Raises
======
CDFError : if CDF library reports an error
Warns
=====
CDFWarning : if CDF library reports a warning
"""
if 'ignore' in kwargs:
return self.check_status(self._library.CDFlib(
*(args + (const.NULL_, ))
), kwargs['ignore'])
else:
return self.check_status(self._library.CDFlib(
*(args + (const.NULL_, ))
))
def set_backward(self, backward=True):
"""
Set backward compatibility mode for new CDFs
Unless backward compatible mode is set, CDF files created by
the version 3 library can not be read by V2.
Parameters
==========
backward : boolean
Set backward compatible mode if True; clear it if False.
Raises
======
ValueError : if backward=False and underlying CDF library is V2
"""
if self.version[0] < 3:
if not backward:
raise ValueError(
'Cannot disable backward-compatible mode for CDF version 2.')
else:
return
self._library.CDFsetFileBackward(const.BACKWARDFILEon if backward
else const.BACKWARDFILEoff)
def epoch_to_datetime(self, epoch):
"""
Converts a CDF epoch value to a datetime
Parameters
==========
epoch : float
epoch value from CDF
Returns
=======
out : :class:`datetime.datetime`
date and time corresponding to epoch. Invalid values are set to
usual epoch invalid value, i.e. last moment of year 9999.
See Also
========
v_epoch_to_datetime
"""
yyyy = ctypes.c_long(0)
mm = ctypes.c_long(0)
dd = ctypes.c_long(0)
hh = ctypes.c_long(0)
min = ctypes.c_long(0)
sec = ctypes.c_long(0)
msec = ctypes.c_long(0)
self._library.EPOCHbreakdown(ctypes.c_double(epoch),
ctypes.byref(yyyy), ctypes.byref(mm),
ctypes.byref(dd),
ctypes.byref(hh), ctypes.byref(min),
ctypes.byref(sec), ctypes.byref(msec))
if yyyy.value <= 0:
return datetime.datetime(9999, 12, 13, 23, 59, 59, 999000)
else:
return datetime.datetime(yyyy.value, mm.value, dd.value,
hh.value, min.value, sec.value,
msec.value * 1000)
def datetime_to_epoch(self, dt):
"""
Converts a Python datetime to a CDF Epoch value
Parameters
==========
dt : :class:`datetime.datetime`
date and time to convert
Returns
=======
out : float
epoch corresponding to dt
See Also
========
v_datetime_to_epoch
"""
if dt.tzinfo != None and dt.utcoffset() != None:
dt = dt - dt.utcoffset()
dt.replace(tzinfo=None)
micro = dt.microsecond % 1000
if micro >= 500 and dt.year < 9999:
dt += datetime.timedelta(0, 0, 1000)
return self._library.computeEPOCH(dt.year, dt.month, dt.day, dt.hour,
dt.minute, dt.second,
int(dt.microsecond / 1000))
def epoch16_to_datetime(self, epoch0, epoch1):
"""
Converts a CDF epoch16 value to a datetime
.. note::
The call signature has changed since SpacePy 0.1.2. Formerly
this method took a single argument with two values; now it
requires two arguments (one for each value). To convert existing
code, replace ``epoch16_to_datetime(epoch)`` with
``epoch16_to_datetime(*epoch)``.
Parameters
==========
epoch0 : float
epoch16 value from CDF, first half
epoch1 : float
epoch16 value from CDF, second half
Raises
======
EpochError : if input invalid
Returns
=======
out : :class:`datetime.datetime`
date and time corresponding to epoch. Invalid values are set to
usual epoch invalid value, i.e. last moment of year 9999.
See Also
========
v_epoch16_to_datetime
"""
yyyy = ctypes.c_long(0)
mm = ctypes.c_long(0)
dd = ctypes.c_long(0)
hh = ctypes.c_long(0)
min = ctypes.c_long(0)
sec = ctypes.c_long(0)
msec = ctypes.c_long(0)
usec = ctypes.c_long(0)
nsec = ctypes.c_long(0)
psec = ctypes.c_long(0)
self._library.EPOCH16breakdown((ctypes.c_double * 2)(epoch0, epoch1),
ctypes.byref(yyyy), ctypes.byref(mm),
ctypes.byref(dd),
ctypes.byref(hh), ctypes.byref(min),
ctypes.byref(sec), ctypes.byref(msec),
ctypes.byref(usec), ctypes.byref(nsec),
ctypes.byref(psec))
if yyyy.value <= 0:
return datetime.datetime(9999, 12, 13, 23, 59, 59, 999999)
micro = int(float(msec.value) * 1000 + float(usec.value) +
float(nsec.value) / 1000 + float(psec.value) / 1e6 + 0.5)
if micro < 1000000:
return datetime.datetime(yyyy.value, mm.value, dd.value,
hh.value, min.value, sec.value,
micro)
else:
add_sec = int(micro / 1000000)
try:
return datetime.datetime(yyyy.value, mm.value, dd.value,
hh.value, min.value, sec.value,
micro - add_sec * 1000000) + \
datetime.timedelta(seconds=add_sec)
except OverflowError:
return datetime.datetime(datetime.MAXYEAR, 12, 31,
23, 59, 59,
999999)
def datetime_to_epoch16(self, dt):
"""
Converts a Python datetime to a CDF Epoch16 value
Parameters
==========
dt : :class:`datetime.datetime`
date and time to convert
Returns
=======
out : list of float
epoch16 corresponding to dt
See Also
========
v_datetime_to_epoch16
"""
if dt.tzinfo != None and dt.utcoffset() != None:
dt = dt - dt.utcoffset()
dt.replace(tzinfo=None)
#Default to "illegal epoch"
epoch16 = (ctypes.c_double * 2)(-1., -1.)
if self._library.computeEPOCH16(dt.year, dt.month, dt.day, dt.hour,
dt.minute, dt.second,
int(dt.microsecond / 1000),
dt.microsecond % 1000, 0, 0,
epoch16):
return (-1., -1.) #Failure, so illegal epoch
return (epoch16[0], epoch16[1])
def epoch_to_epoch16(self, epoch):
"""
Converts a CDF EPOCH to a CDF EPOCH16 value
Parameters
==========
epoch : double
EPOCH to convert. Lists and numpy arrays are acceptable.
Returns
=======
out : (double, double)
EPOCH16 corresponding to epoch
"""
e = numpy.require(epoch, numpy.float64)
s = numpy.trunc(e / 1000.0)
#ugly numpy stuff, probably a better way....
res = numpy.hstack((s, (e - s * 1000.0) * 1e9))
if len(res) <= 2:
return res
newshape = list(res.shape[0:-2])
newshape.append(res.shape[-1] // 2)
newshape.append(2)
return numpy.rollaxis(res.reshape(newshape), -1, -2)
def epoch_to_num(self, epoch):
"""
Convert CDF EPOCH to matplotlib number.
Same output as :func:`~matplotlib.dates.date2num` and useful for
plotting large data sets without converting the times through datetime.
Parameters
==========
epoch : double
EPOCH to convert. Lists and numpy arrays are acceptable.
Returns
=======
out : double
Floating point number representing days since 0001-01-01.
"""
#date2num day 1 is 1/1/1 00UT
#epoch 1/1/1 00UT is 31622400000.0 (millisecond)
return (epoch - 31622400000.0) / (24 * 60 * 60 * 1000.0) + 1.0
def epoch16_to_epoch(self, epoch16):
"""
Converts a CDF EPOCH16 to a CDF EPOCH value
Parameters
==========
epoch16 : (double, double)
EPOCH16 to convert. Lists and numpy arrays are acceptable.
LAST dimension should be 2: the two pairs of EPOCH16
Returns
=======
out : double
EPOCH corresponding to epoch16
"""
e = numpy.require(epoch16, numpy.float64)
return e[..., 0] * 1000.0 + numpy.round(e[..., 1] / 1e9)
def tt2000_to_datetime(self, tt2000):
"""
Converts a CDF TT2000 value to a datetime
.. note::
Although TT2000 values support leapseconds, Python's datetime
object does not. Any times after 23:59:59.999999 will
be truncated to 23:59:59.999999.
Parameters
==========
tt2000 : int
TT2000 value from CDF
Raises
======
EpochError : if input invalid
Returns
=======
out : :class:`datetime.datetime`
date and time corresponding to epoch. Invalid values are set to
usual epoch invalid value, i.e. last moment of year 9999.
See Also
========
v_tt2000_to_datetime
"""
yyyy = ctypes.c_double(0)
mm = ctypes.c_double(0)
dd = ctypes.c_double(0)
hh = ctypes.c_double(0)
min = ctypes.c_double(0)
sec = ctypes.c_double(0)
msec = ctypes.c_double(0)
usec = ctypes.c_double(0)
nsec = ctypes.c_double(0)
self._library.breakdownTT2000(
ctypes.c_longlong(tt2000),
ctypes.byref(yyyy), ctypes.byref(mm), ctypes.byref(dd),
ctypes.byref(hh), ctypes.byref(min), ctypes.byref(sec),
ctypes.byref(msec), ctypes.byref(usec), ctypes.byref(nsec))
if yyyy.value <= 0:
return datetime.datetime(9999, 12, 13, 23, 59, 59, 999999)
sec = int(sec.value)
if sec >= 60:
return datetime.datetime(
int(yyyy.value), int(mm.value), int(dd.value),
int(hh.value), int(min.value), 59, 999999)
micro = int(msec.value * 1000 + usec.value + nsec.value / 1000 + 0.5)
if micro < 1000000:
return datetime.datetime(
int(yyyy.value), int(mm.value), int(dd.value),
int(hh.value), int(min.value), sec, micro)
else:
add_sec = int(micro / 1000000)
try:
return datetime.datetime(
int(yyyy.value), int(mm.value), int(dd.value),
int(hh.value), int(min.value), sec,
micro - add_sec * 1000000) + \
datetime.timedelta(seconds=add_sec)
except OverflowError:
return datetime.datetime(datetime.MAXYEAR, 12, 31,
23, 59, 59, 999999)
def datetime_to_tt2000(self, dt):
"""
Converts a Python datetime to a CDF TT2000 value
Parameters
==========
dt : :class:`datetime.datetime`
date and time to convert
Returns
=======
out : int
tt2000 corresponding to dt
See Also
========
v_datetime_to_tt2000
"""
if dt.tzinfo != None and dt.utcoffset() != None:
dt = dt - dt.utcoffset()
dt = dt.replace(tzinfo=None)
if dt == datetime.datetime.max:
return -2**63
return self._library.computeTT2000(
dt.year, dt.month, dt.day, dt.hour,
dt.minute, dt.second,
int(dt.microsecond / 1000),
dt.microsecond % 1000, 0)
def _datetime_to_tt2000_typepunned(self, dt):
"""
Converts a Python datetime to a CDF TT2000 value
Typepunned version that passes doubles as longlongs, to get around
ARM calling convention oddness.
Parameters
==========
dt : :class:`datetime.datetime`
date and time to convert
Returns
=======
out : int
tt2000 corresponding to dt
See Also
========
v_datetime_to_tt2000
"""
c_ll_p = ctypes.POINTER(ctypes.c_longlong)
if dt.tzinfo != None and dt.utcoffset() != None:
dt = dt - dt.utcoffset()
dt = dt.replace(tzinfo=None)
if dt == datetime.datetime.max:
return -2**63
return self._library.computeTT2000(
ctypes.cast(ctypes.pointer(ctypes.c_double(
dt.year)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
dt.month)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
dt.day)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
dt.hour)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
dt.minute)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
dt.second)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
dt.microsecond // 1000)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
dt.microsecond % 1000)), c_ll_p).contents,
ctypes.cast(ctypes.pointer(ctypes.c_double(
0)), c_ll_p).contents)
def epoch_to_tt2000(self, epoch):
"""
Converts a CDF EPOCH to a CDF TT2000 value
Parameters
==========
epoch : double
EPOCH to convert
Returns
=======
out : int
tt2000 corresponding to epoch
See Also
========
v_epoch_to_tt2000
"""
return self._library.CDF_TT2000_from_UTC_EPOCH(epoch)
def tt2000_to_epoch(self, tt2000):
"""
Converts a CDF TT2000 value to a CDF EPOCH
.. note::
Although TT2000 values support leapseconds, CDF EPOCH values
do not. Times during leapseconds are rounded up to beginning
of the next day.
Parameters
==========
tt2000 : int
TT2000 value from CDF
Raises
======
EpochError : if input invalid
Returns
=======
out : double
EPOCH corresponding to the TT2000 input time
See Also
========
v_tt2000_to_epoch
"""
return self._library.CDF_TT2000_to_UTC_EPOCH(tt2000)
def epoch16_to_tt2000(self, epoch0, epoch1):
"""
Converts a CDF epoch16 value to TT2000
.. note::
Because TT2000 does not support picoseconds, the picoseconds
value in epoch is ignored (i.e., truncated.)
Parameters
==========
epoch0 : float
epoch16 value from CDF, first half
epoch1 : float
epoch16 value from CDF, second half
Raises
======
EpochError : if input invalid
Returns
=======
out : long
TT2000 corresponding to epoch.
See Also
========
v_epoch16_to_tt2000
"""
return self._library.CDF_TT2000_from_UTC_EPOCH16(
(ctypes.c_double * 2)(epoch0, epoch1))
def tt2000_to_epoch16(self, tt2000):
"""
Converts a CDF TT2000 value to a CDF EPOCH16
.. note::
Although TT2000 values support leapseconds, CDF EPOCH16 values
do not. Times during leapseconds are rounded up to beginning
of the next day.
Parameters
==========
tt2000 : int
TT2000 value from CDF
Raises
======
EpochError : if input invalid
Returns
=======
out : double, double
EPOCH16 corresponding to the TT2000 input time
See Also
========
v_tt2000_to_epoch16
"""
#Default to "illegal epoch" if isn't populated
epoch16 = (ctypes.c_double * 2)(-1., -1.)
if self._library.CDF_TT2000_to_UTC_EPOCH16(tt2000, epoch16):
return (-1., -1.) #Failure; illegal epoch
return (epoch16[0], epoch16[1])
def _bad_tt2000(*args, **kwargs):
"""Convenience function for complaining that TT2000 not supported"""
raise NotImplementedError(
'TT2000 functions require CDF library 3.4.0 or later')
def download_library():
"""Download and install the CDF library"""
if sys.platform != 'win32':
raise NotImplementedError(
'CDF library install only supported on Windows')
try:
import html.parser as HTMLParser
except ImportError:
import HTMLParser
#https://stackoverflow.com/questions/1713038/super-fails-with-error-typeerror-argument-1-must-be-type-not-classobj
class LinkParser(HTMLParser.HTMLParser, object):
def __init__(self, *args, **kwargs):
self.links_found = []
super(LinkParser, self).__init__(*args, **kwargs)
def handle_starttag(self, tag, attrs):
if tag != 'a' or attrs[0][0] != 'href':
return
self.links_found.append(attrs[0][1])
import re
import subprocess
try:
import urllib.request as u
except ImportError:
import urllib as u
# Removed reference to spacepy
#import spacepy
#if spacepy.config.get('user_agent', None):
# class AppURLopener(u.FancyURLopener):
# version = spacepy.config['user_agent']
# u._urlopener = AppURLopener()
baseurl = 'https://spdf.sci.gsfc.nasa.gov/pub/software/cdf/dist/'
url = u.urlopen(baseurl)
listing = url.read()
url.close()
p = LinkParser()
p.feed(listing)
cdfdist = [l for l in p.links_found if re.match('^cdf3\d_\d(?:_\d)?/$', l)]
if not cdfdist:
raise RuntimeError(
"Couldn't find CDF distribution directory to download")
cdfdist.sort(key=lambda x: x.rstrip('/').split('_'))
cdfverbase = cdfdist[-1].rstrip('/')
instfname = cdfverbase + ('_0' if cdfverbase.count('_') == 1 else '') + \
'-setup-{0}.exe'.format(len('%x' % sys.maxsize)*4)
insturl = baseurl + cdfverbase + '/windows/' + instfname
tmpdir = tempfile.mkdtemp()
try:
fname, status = u.urlretrieve(insturl, os.path.join(tmpdir, instfname))
subprocess.check_call([fname, '/install', '/q1'], shell=False)
finally:
shutil.rmtree(tmpdir)
_libpath, _library = Library._find_lib()
if _library is None:
raise Exception(('Cannot load CDF C library; checked {0}. '
'Try \'os.environ["CDF_LIB"] = library_directory\' '
'before import.').format(', '.join(_libpath)))
from . import const
lib = Library(_libpath, _library)
"""Module global library object.
Initalized at module load time so all classes have ready
access to the CDF library and a common state. E.g:
>>> import pycdf
>>> pycdf.lib.version
(3, 3, 0, ' ')
"""
class CDFException(Exception):
"""
Base class for errors or warnings in the CDF library.
Not normally used directly, but in subclasses :class:`CDFError`
and :class:`CDFWarning`.
Error messages provided by this class are looked up from the underlying
C library.
"""
def __init__(self, status):
"""
Create a CDF Exception
Uses CDF C library to look up an appropriate error message.
Parameters
==========
status : ctypes.c_long
CDF status
"""
self.status = status
self.string = 'CDF error ' + repr(status) + ', unable to get details.'
message = ctypes.create_string_buffer(const.CDF_STATUSTEXT_LEN + 1)
try:
retval = lib._library.CDFlib(const.SELECT_, const.CDF_STATUS_,
ctypes.c_long(status),
const.GET_, const.STATUS_TEXT_, message,
const.NULL_)
if retval == const.CDF_OK:
if isinstance(message.value, str):
self.string = message.value
elif isinstance(message.value, bytes):
self.string = message.value.decode()
except:
pass
def __str__(self):
"""
Error string associated with the library error.
Returns
=======
out : str
Error message from the CDF library.
"""
return self.string
class CDFError(CDFException):
"""Raised for an error in the CDF library."""
pass
class CDFWarning(CDFException, UserWarning):
"""Used for a warning in the CDF library."""
def warn(self, level=4):
"""
Issues a warning based on the information stored in my exception
Intended for use in check_status or similar wrapper function.
Other Parameters
================
level : int
optional (default 3), how far up the stack the warning should
be reported. Passed directly to :class:`warnings.warn`.
"""
warnings.warn(self, self.__class__, level)
class EpochError(Exception):
"""Used for errors in epoch routines"""
pass
def _compress(obj, comptype=None, param=None):
"""Set or check the compression of a :py:class:`pycdf.CDF` or :py:class:`pycdf.Var`
@param obj: object on which to set or check compression
@type obj: :py:class:`pycdf.CDF` or :py:class:`pycdf.Var`
@param comptype: type of compression to change to, see CDF C reference
manual section 4.10. Constants for this parameter
are in :py:mod:`pycdf.const`. If not specified, will not change
compression.
@type comptype: ctypes.c_long
@param param: Compression parameter, see CDF CRM 4.10 and :py:mod:`pycdf.const`.
If not specified, will choose reasonable default (5 for
gzip; other types have only one possible parameter.)
@type param: ctypes.c_long
@return: (comptype, param) currently in effect
@rtype: tuple
"""
if isinstance(obj, CDF):
COMPRESSION_ = const.CDF_COMPRESSION_
elif isinstance(obj, Var):
COMPRESSION_ = const.zVAR_COMPRESSION_
else:
raise ValueError('Must specify a CDF or Var type.')
validparams = {const.NO_COMPRESSION.value: [ctypes.c_long(0)],
const.RLE_COMPRESSION.value: [const.RLE_OF_ZEROs],
const.HUFF_COMPRESSION.value:
[const.OPTIMAL_ENCODING_TREES],
const.AHUFF_COMPRESSION.value:
[const.OPTIMAL_ENCODING_TREES],
const.GZIP_COMPRESSION.value: [ctypes.c_long(5),
ctypes.c_long(1),
ctypes.c_long(2),
ctypes.c_long(3),
ctypes.c_long(4),
ctypes.c_long(6),
ctypes.c_long(7),
ctypes.c_long(8),
ctypes.c_long(9),
],
}
comptypes = [const.NO_COMPRESSION, const.RLE_COMPRESSION,
const.HUFF_COMPRESSION, const.AHUFF_COMPRESSION,
const.GZIP_COMPRESSION]
comptypevalues = [i.value for i in comptypes]
if comptype != None:
if not hasattr(comptype, 'value'):
comptype = ctypes.c_long(comptype)
if param is None:
if not comptype.value in validparams:
raise CDFError(const.BAD_COMPRESSION)
param = validparams[comptype.value][0]
paramlist = (ctypes.c_long * 1)(param)
obj._call(const.PUT_, COMPRESSION_,
comptype, paramlist)
params = (ctypes.c_long *
const.CDF_MAX_PARMS)(*([0] * const.CDF_MAX_PARMS))
comptype = ctypes.c_long(0)
percent = ctypes.c_long(0)
obj._call(const.GET_, COMPRESSION_,
ctypes.byref(comptype), ctypes.byref(params),
ctypes.byref(percent))
param = params[0]
if not comptype.value in comptypevalues:
raise CDFError(const.BAD_COMPRESSION)
validparamvalues = [i.value for i in validparams[comptype.value]]
if not param in validparamvalues:
raise CDFError(const.BAD_COMPRESSION_PARM)
comptype = comptypes[comptypevalues.index(comptype.value)]
if comptype in (const.RLE_COMPRESSION, const.HUFF_COMPRESSION,
const.AHUFF_COMPRESSION):
param = validparams[comptype.value][validparamvalues.index(param)]
return (comptype, param)
class CDF(MutableMapping):
"""
Python object representing a CDF file.
Open or create a CDF file by creating an object of this class.
Parameters
==========
pathname : string
name of the file to open or create
masterpath : string
name of the master CDF file to use in creating
a new file. If not provided, an existing file is
opened; if provided but evaluates to ``False``
(e.g., ``''``), an empty new CDF is created.
create : bool
Create a new CDF even if masterpath isn't provided
readonly : bool
Open the CDF read-only. Default True if opening an
existing CDF; False if creating a new one. A readonly
CDF with many variables may be slow to close. See
:meth:`readonly`.
Raises
======
CDFError
if CDF library reports an error
Warns
=====
CDFWarning
if CDF library reports a warning and interpreter
is set to error on warnings.
Examples
========
Open a CDF by creating a CDF object, e.g.:
>>> cdffile = pycdf.CDF('cdf_filename.cdf')
Be sure to :meth:`close` or :meth:`save` when
done.
.. note::
Existing CDF files are opened read-only by default, see
:meth:`readonly` to change.
CDF supports the `with
<http://docs.python.org/tutorial/inputoutput.html#methods-of-file-objects>`_
keyword, like other file objects, so:
>>> with pycdf.CDF('cdf_filename.cdf') as cdffile:
... #do brilliant things with the CDF
will open the CDF, execute the indented statements, and close the CDF when
finished or when an error occurs. The `python docs
<http://docs.python.org/reference/compound_stmts.html#with>`_ include more
detail on this 'context manager' ability.
CDF objects behave like a python `dictionary
<http://docs.python.org/tutorial/datastructures.html#dictionaries>`_,
where the keys are names of variables in the CDF, and the values,
:class:`Var` objects. As a dictionary, they are also `iterable
<http://docs.python.org/tutorial/classes.html#iterators>`_ and it is easy
to loop over all of the variables in a file. Some examples:
#. List the names of all variables in the open CDF ``cdffile``:
>>> cdffile.keys()
>>> for k in cdffile: #Alternate
... print(k)
#. Get a :class:`Var` object for the variable named ``Epoch``:
>>> epoch = cdffile['Epoch']
#. Determine if a CDF contains a variable named ``B_GSE``:
>>> if 'B_GSE' in cdffile:
... print('B_GSE is in the file')
... else:
... print('B_GSE is not in the file')
#. Find how many variables are in the file:
>>> print(len(cdffile))
#. Delete the variable ``Epoch`` from the open CDF file ``cdffile``:
>>> del cdffile['Epoch']
#. Display a summary of variables and types in open CDF file ``cdffile``:
>>> print(cdffile)
#. Open the CDF named ``cdf_filename.cdf``, read *all* the data from
all variables into dictionary ``data``, and close it when done or
if an error occurs:
>>> with pycdf.CDF('cdf_filename.cdf') as cdffile:
... data = cdffile.copy()
This last example can be very inefficient as it reads the entire CDF.
Normally it's better to treat the CDF as a dictionary and access only
the data needed, which will be pulled transparently from disc. See
:class:`Var` for more subtle examples.
Potentially useful dictionary methods and related functions:
- `in <http://docs.python.org/reference/expressions.html#in>`_
- `keys <http://docs.python.org/tutorial/datastructures.html#dictionaries>`_
- :py:func:`len`
- `list comprehensions
<http://docs.python.org/tutorial/datastructures.html#list-comprehensions>`_
- :py:func:`sorted`
- :py:func:`~spacepy.toolbox.dictree`
The CDF user's guide section 2.2 has more background information on CDF
files.
The :attr:`~CDF.attrs` Python attribute acts as a dictionary
referencing CDF attributes (do not confuse the two); all the
dictionary methods above also work on the attribute dictionary.
See :class:`gAttrList` for more on the dictionary of global
attributes.
Creating a new CDF from a master (skeleton) CDF has similar syntax to
opening one:
>>> cdffile = pycdf.CDF('cdf_filename.cdf', 'master_cdf_filename.cdf')
This creates and opens ``cdf_filename.cdf`` as a copy of
``master_cdf_filename.cdf``.
Using a skeleton CDF is recommended over making a CDF entirely from
scratch, but this is possible by specifying a blank master:
>>> cdffile = pycdf.CDF('cdf_filename.cdf', '')
When CDFs are created in this way, they are opened read-write, see
:py:meth:`readonly` to change.
By default, new CDFs (without a master) are created in version 2
(backward-compatible) format. To create a version 3 CDF, use
:meth:`Library.set_backward`:
>>> pycdf.lib.set_backward(False)
>>> cdffile = pycdf.CDF('cdf_filename.cdf', '')
Add variables by direct assignment, which will automatically set type
and dimension based on the data provided:
>>> cdffile['new_variable_name'] = [1, 2, 3, 4]
or, if more control is needed over the type and dimensions, use
:py:meth:`new`.
Although it is supported to assign Var objects to Python variables
for convenience, there are some minor pitfalls that can arise when
changing a CDF that will not affect most users. This is only a
concern when assigning a zVar object to a Python variable, changing the
CDF through some other variable, and then trying to use the zVar
object via the originally assigned variable.
Deleting a variable:
>>> var = cdffile['Var1']
>>> del cdffile['Var1']
>>> var[0] #fail, no such variable
Renaming a variable:
>>> var = cdffile['Var1']
>>> cdffile['Var1'].rename('Var2')
>>> var[0] #fail, no such variable
Renaming via the same variable works:
>>> var = cdffile['Var1']
>>> var.rename('Var2')
>>> var[0] #succeeds, aware of new name
Deleting a variable and then creating another variable with the same name
may lead to some surprises:
>>> var = cdffile['Var1']
>>> var[...] = [1, 2, 3, 4]
>>> del cdffile['Var1']
>>> cdffile.new('Var1', data=[5, 6, 7, 8]
>>> var[...]
[5, 6, 7, 8]
.. autosummary::
~CDF.attr_num
~CDF.attrs
~CDF.add_attr_to_cache
~CDF.add_to_cache
~CDF.backward
~CDF.checksum
~CDF.clear_attr_from_cache
~CDF.clear_from_cache
~CDF.clone
~CDF.close
~CDF.col_major
~CDF.compress
~CDF.copy
~CDF.from_data
~CDF.new
~CDF.raw_var
~CDF.readonly
~CDF.save
~CDF.var_num
~CDF.version
.. attribute:: CDF.attrs
Global attributes for this CDF in a dict-like format.
See :class:`gAttrList` for details.
.. attribute:: CDF.backward
True if this CDF was created in backward-compatible mode
(for opening with CDF library before 3.x)
.. automethod:: add_to_cache
.. automethod:: add_attr_to_cache
.. automethod:: attr_num
.. automethod:: checksum
.. automethod:: clear_from_cache
.. automethod:: clear_attr_from_cache
.. automethod:: clone
.. automethod:: close
.. automethod:: col_major
.. automethod:: compress
.. automethod:: copy
.. automethod:: from_data
.. automethod:: new
.. automethod:: raw_var
.. automethod:: readonly
.. automethod:: save
.. automethod:: var_num
.. automethod:: version
"""
def __init__(self, pathname, masterpath=None, create=None, readonly=None):
"""Open or create a CDF file.
Parameters
==========
pathname : string
name of the file to open or create
masterpath : string
name of the master CDF file to use in creating
a new file. If not provided, an existing file is
opened; if provided but evaluates to ``False``
(e.g., ``''``), an empty new CDF is created.
create : bool
Create a new CDF even if masterpath isn't provided
readonly : bool
Open the CDF read-only. Default True if opening an
existing CDF; False if creating a new one.
Raises
======
CDFError
if CDF library reports an error
CDFWarning
if CDF library reports a warning and interpreter
is set to error on warnings.
Examples
========
Open a CDF by creating a CDF object, e.g.:
>>> cdffile = pycdf.CDF('cdf_filename.cdf')
Be sure to :py:meth:`pycdf.CDF.close` or :py:meth:`pycdf.CDF.save`
when done.
"""
if masterpath is not None: #Looks like we want to create
if create is False:
raise ValueError('Cannot specify a master CDF without creating a CDF')
if readonly is True:
raise ValueError('Cannot create a CDF in readonly mode')
if create and readonly:
raise ValueError('Cannot create a CDF in readonly mode')
try:
self.pathname = pathname.encode()
except AttributeError:
raise ValueError(
'pathname must be string-like: {0}'.format(pathname))
self._handle = ctypes.c_void_p(None)
self._opened = False
if masterpath is None and not create:
self._open(True if readonly is None else readonly)
elif masterpath:
self._from_master(masterpath.encode())
else:
self._create()
lib.call(const.SELECT_, const.CDF_zMODE_, ctypes.c_long(2))
self._attrlistref = weakref.ref(gAttrList(self))
self.backward = self.version()[0] < 3
self._var_nums = {}
"""Cache of name-to-number mappings for variables in this CDF"""
self._attr_info = {}
"""Cache of name-to-(number, global) mappings for attributes
in this CDF"""
def __del__(self):
"""Destructor; called when CDF object is destroyed.
Close CDF file if there is still a valid handle.
.. note::
To avoid data loss, explicitly call :py:meth:`pycdf.CDF.close`
or :py:meth:`pycdf.CDF.save`.
"""
if self._opened:
self.close()
def __delitem__(self, name):
"""Delete a zVariable in this CDF, by name or number
Parameters
==========
name : string or int
Name or number of the CDF variable
.. note:
Variable numbers may change if variables are added or removed.
Examples
========
Delete the variable ``Epoch`` from the open CDF file ``cdffile``.
>>> del cdffile['Epoch']
"""
self[name]._delete()
def __enter__(self):
"""Context manager entrance function."""
return self
def __exit__(self, type, value, traceback):
"""Context manager exit function.
Close CDF file.
"""
self.close()
def __getitem__(self, name):
"""Gets a zVariable in this CDF, by name or number
The CDF acts like a dict
@param name: Name or number of the CDF variable
@type name: string or int
@return: CDF variable named or numbered L{name}
@rtype: :py:class:`pycdf.Var`
@raise KeyError: for pretty much any problem in lookup
@note: variable numbers may change if variables are added or removed.
"""
try:
return Var(self, name)
except CDFException as e:
raise KeyError('{0}: {1}'.format(name, e))
def __setitem__(self, name, data):
"""Writes data to a zVariable in this CDF
If the zVariable does not exist, will create one matching
L{data}. If it does exist, will attempt to write L{data}
to it without changing the type or dimensions.
@param name: name or number of the variable to write
@type name: str or int
@param data: data to write, or a :py:class:`pycdf.Var` to copy
"""
if isinstance(data, Var):
self.clone(data, name)
elif name in self:
self[name][...] = data
if hasattr(data, 'attrs'):
self[name].attrs.clone(data.attrs)
else:
self.new(name, data)
def __iter__(self, current = 0):
"""Iterates over zVars in CDF
Iterators for dicts return keys
@note: Returned in variable-number order
"""
while current < self.__len__():
name = self[current].name()
value = (yield name)
if value is None:
current += 1
else:
current = self[value]._num()
current += 1
def __len__(self):
"""Implements 'length' of CDF (number of zVars)
@return: number of zVars in the CDF
@rtype: int
"""
count = ctypes.c_long(0)
self._call(const.GET_, const.CDF_NUMzVARS_, ctypes.byref(count))
return count.value
def __contains__(self, key):
"""Determines whether a particular variable name is in the CDF
@note: Essentially an efficiency function; L{__iter__} is called
if this isn't defined
@param key: key/variable name to check
@type key: string
@return: True if L{key} is the name of a variable in CDF, else False
@rtype: Boolean
"""
try:
foo = self[key]
return True
except KeyError as e:
expected = str(key) + \
": NO_SUCH_VAR: Named variable not found in this CDF."
if expected in e.args:
return False
raise
def __repr__(self):
"""Returns representation of CDF
Cannot return anything that can be eval'd to create a copy of the
CDF, so just wrap the informal representation in angle brackets.
@return: all the data in this list of attributes
@rtype: str
"""
return '<CDF:\n' + str(self) + '\n>'
def __str__(self):
"""Returns a string representation of the CDF
This is an 'informal' representation in that it cannot be evaluated
directly to create a :py:class:`pycdf.CDF`, just the names, types, and sizes of all
variables. (Attributes are not listed.)
@return: description of the variables in the CDF
@rtype: str
"""
if self._opened:
return '\n'.join([key + ': ' + str(value)
for (key, value) in sorted(self.items())])
#can get away with this sort because second value in tuple isn't
#compared unless first are different, and variable name is unique.
else:
if isinstance(self.pathname, str):
return 'Closed CDF {0}'.format(self.pathname)
else:
return 'Closed CDF {0}'.format(self.pathname.decode('ascii'))
def _open(self, readonly=True):
"""Opens the CDF file (called on init)
Will open an existing CDF file read/write.
Raises
======
CDFError : if CDF library reports an error
CDFWarning : if CDF library reports a warning and interpreter
is set to error on warnings.
.. note:
Not intended for direct call; pass parameters to
:py:class:`pycdf.CDF` constructor.
"""
lib.call(const.OPEN_, const.CDF_, self.pathname, ctypes.byref(self._handle))
self._opened = True
if readonly: #Default is RW
self.readonly(readonly)
def _create(self):
"""Creates (and opens) a new CDF file
Created at ``pathname``.
Assumes zero-dimension r variables
Raises
======
CDFError : if CDF library reports an error
CDFWarning : if CDF library reports a warning and interpreter
is set to error on warnings.
.. note:
Not intended for direct call; pass parameters to
:py:class:`pycdf.CDF` constructor.
"""
lib.call(const.CREATE_, const.CDF_, self.pathname, ctypes.c_long(0),
(ctypes.c_long * 1)(0), ctypes.byref(self._handle))
self._opened = True
def _from_master(self, master_path):
"""Creates a new CDF from a master CDF file
``master_path`` is copied to ``pathname`` and opened.
Parameters
==========
master_path : string
location of the master CDF file
Raises
======
CDFError : if CDF library reports an error
CDFWarning : if CDF library reports a warning and interpreter
is set to error on warnings.
.. note:
Not intended for direct call; pass parameters to
:py:class:`pycdf.CDF` constructor.
"""
if os.path.exists(self.pathname):
raise CDFError(const.CDF_EXISTS)
shutil.copy2(master_path, self.pathname)
self._open(False)
def _call(self, *args, **kwargs):
"""Select this CDF as current and call the CDF internal interface
Adds call to select this CDF to L{args} and passes all parameters
directly through to the CDFlib routine of the CDF library's C internal
interface. Checks the return value with L{Library.check_status}.
Parameters
==========
args : various, see :py:mod:`ctypes`.
Passed directly to the CDF library interface. Useful
constants are defined in the :doc:`const <pycdf_const>`
module of this package.
Returns
=======
out : ctypes.c_long
CDF status from the library
.. note:
Terminal NULL_ is automatically added to ``args``.
Raises
======
CDFError : if CDF library reports an error
CDFWarning : if CDF library reports a warning and interpreter
is set to error on warnings.
"""
return lib.call(const.SELECT_, const.CDF_, self._handle,
*args, **kwargs)
def clone(self, zVar, name=None, data=True):
"""
Clone a zVariable (from another CDF or this) into this CDF
Parameters
==========
zVar : :py:class:`Var`
variable to clone
Other Parameters
================
name : str
Name of the new variable (default: name of the original)
data : boolean (optional)
Copy data, or only type, dimensions, variance, attributes?
(default: True, copy data as well)
Returns
=======
out : :py:class:`Var`
The newly-created zVar in this CDF
"""
if name is None:
name = zVar.name()
if name in self:
del self[name]
self.new(name, type=zVar.type(), recVary=zVar.rv(),
dimVarys=zVar.dv(), dims=zVar._dim_sizes(),
n_elements=zVar._nelems())
self[name].compress(*zVar.compress())
self[name].attrs.clone(zVar.attrs)
if data:
r = zVar._raw
zVar._raw = True
self.raw_var(name)[...] = zVar[...]
zVar._raw = r
return zVar
def col_major(self, new_col=None):
"""
Finds the majority of this CDF file
Other Parameters
================
new_col : boolean
Specify True to change to column-major, False to change to
row major, or do not specify to check the majority
rather than changing it.
(default is check only)
Returns
=======
out : boolean
True if column-major, false if row-major
"""
if new_col != None:
new_maj = const.COLUMN_MAJOR if new_col else const.ROW_MAJOR
self._call(const.PUT_, const.CDF_MAJORITY_, new_maj)
maj = ctypes.c_long(0)
self._call(const.GET_, const.CDF_MAJORITY_, ctypes.byref(maj))
if not maj.value in (const.ROW_MAJOR.value, const.COLUMN_MAJOR.value):
raise CDFError(const.BAD_MAJORITY)
return maj.value == const.COLUMN_MAJOR.value
def readonly(self, ro=None):
"""
Sets or check the readonly status of this CDF
If the CDF has been changed since opening, setting readonly mode
will have no effect.
.. note::
Closing a CDF that has been opened readonly, or setting readonly
False, may take a substantial amount of time if there are many
variables in the CDF, as a (potentially large) cache needs to
be cleared. Consider specifying ``readonly=False`` when opening
the file if this is an issue. However, this may make some reading
operations slower.
Other Parameters
================
ro : Boolean
True to set the CDF readonly, False to set it read/write,
or leave out to check only.
Returns
=======
out : Boolean
True if CDF is read-only, else False
Raises
======
CDFError : if bad mode is set
"""
if ro == True:
self._call(const.SELECT_, const.CDF_READONLY_MODE_,
const.READONLYon)
elif ro == False:
self._call(const.SELECT_, const.CDF_READONLY_MODE_,
const.READONLYoff)
mode = ctypes.c_long(0)
self._call(const.CONFIRM_, const.CDF_READONLY_MODE_,
ctypes.byref(mode))
if mode.value == const.READONLYon.value:
return True
elif mode.value == const.READONLYoff.value:
return False
else:
raise CDFError(const.BAD_READONLY_MODE.value)
def checksum(self, new_val=None):
"""
Set or check the checksum status of this CDF. If checksums
are enabled, the checksum will be verified every time the file
is opened.
Other Parameters
================
new_val : boolean
True to enable checksum, False to disable, or leave out
to simply check.
Returns
=======
out : boolean
True if the checksum is enabled or False if disabled
"""
if new_val != None:
self._call(const.PUT_, const.CDF_CHECKSUM_,
const.MD5_CHECKSUM if new_val else const.NO_CHECKSUM)
chk = ctypes.c_long(0)
self._call(const.GET_, const.CDF_CHECKSUM_, ctypes.byref(chk))
if not chk.value in (const.MD5_CHECKSUM.value,
const.NO_CHECKSUM.value):
raise CDFError(const.BAD_CHECKSUM)
return chk.value == const.MD5_CHECKSUM.value
def close(self):
"""
Closes the CDF file
Although called on object destruction (:meth:`~CDF.__del__`),
to ensure all data are saved, the user should explicitly call
:meth:`~CDF.close` or :meth:`~CDF.save`.
Raises
======
CDFError : if CDF library reports an error
Warns
=====
CDFWarning : if CDF library reports a warning
"""
self._call(const.CLOSE_, const.CDF_)
self._opened = False
def compress(self, comptype=None, param=None):
"""
Set or check the compression of this CDF
Sets compression on entire *file*, not per-variable.
See section 2.6 of the CDF user's guide for more information on
compression.
Other Parameters
================
comptype : ctypes.c_long
type of compression to change to, see CDF C reference manual
section 4.10. Constants for this parameter are in
:mod:`~pycdf.const`. If not specified, will not change
compression.
param : ctypes.c_long
Compression parameter, see CDF CRM 4.10 and
:mod:`~pycdf.const`.
If not specified, will choose reasonable default (5 for gzip;
other types have only one possible parameter.)
Returns
=======
out : tuple
(comptype, param) currently in effect
See Also
========
:meth:`Var.compress`
Examples
========
Set file ``cdffile`` to gzip compression, compression level 9:
>>> cdffile.compress(pycdf.const.GZIP_COMPRESSION, 9)
"""
return _compress(self, comptype, param)
def new(self, name, data=None, type=None, recVary=True, dimVarys=None,
dims=None, n_elements=None, compress=None, compress_param=None):
"""
Create a new zVariable in this CDF
.. note::
Either ``data`` or ``type`` must be specified. If type is not
specified, it is guessed from ``data``.
Parameters
==========
name : str
name of the new variable
Other Parameters
================
data
data to store in the new variable. If this has a an ``attrs``
attribute (e.g., :class:`~spacepy.datamodel.dmarray`), it
will be used to populate attributes of the new variable.
type : ctypes.c_long
CDF type of the variable, from :mod:`~pycdf.const`.
See section 2.5 of the CDF user's guide for more information on
CDF data types.
recVary : boolean
record variance of the variable (default True)
dimVarys : list of boolean
dimension variance of each dimension, default True for all
dimensions.
dims : list of int
size of each dimension of this variable, default zero-dimensional.
Note this is the dimensionality as defined by CDF, i.e., for
record-varying variables it excludes the leading record dimension.
See :py:class:`Var`.
n_elements : int
number of elements, should be 1 except for CDF_CHAR,
for which it's the length of the string.
compress : ctypes.c_long
Compression to apply to this variable, default None.
See :py:meth:`Var.compress`.
compress_param : ctypes.c_long
Compression parameter if compression used; reasonable default
is chosen. See :py:meth:`Var.compress`.
Returns
=======
out : :py:class:`Var`
the newly-created zVariable
Raises
======
ValueError : if neither data nor sufficient typing information
is provided.
Notes
=====
Any given data may be representable by a range of CDF types; if
the type is not specified, pycdf will guess which
the CDF types which can represent this data. This breaks down to:
#. If input data is a numpy array, match the type of that array
#. Proper kind (numerical, string, time)
#. Proper range (stores highest and lowest number provided)
#. Sufficient resolution (EPOCH16 required if datetime has
microseconds or below.)
If more than one value satisfies the requirements, types are returned
in preferred order:
#. Type that matches precision of data first, then
#. integer type before float type, then
#. Smallest type first, then
#. signed type first, then
#. specifically-named (CDF_BYTE) vs. generically named (CDF_INT1)
So for example, EPOCH_16 is preferred over EPOCH if ``data`` specifies
below the millisecond level (rule 1), but otherwise EPOCH is preferred
(rule 2).
For floats, four-byte is preferred unless eight-byte is required:
#. absolute values between 0 and 3e-39
#. absolute values greater than 1.7e38
This will switch to an eight-byte double in some cases where four bytes
would be sufficient for IEEE 754 encoding, but where DEC formats would
require eight.
"""
if type in (const.CDF_EPOCH16, const.CDF_INT8, const.CDF_TIME_TT2000) \
and self.backward:
raise ValueError('Cannot use EPOCH16, INT8, or TIME_TT2000 '
'in backward-compatible CDF')
if not lib.supports_int8 and \
type in (const.CDF_INT8, const.CDF_TIME_TT2000):
raise ValueError('INT8 and TIME_TT2000 require CDF library 3.4.0')
if data is None:
if type is None:
raise ValueError('Must provide either data or a CDF type.')
if dims is None:
dims = []
if n_elements is None:
n_elements = 1
else:
(guess_dims, guess_types, guess_elements) = _Hyperslice.types(data)
if dims is None:
if recVary:
if guess_dims == ():
raise ValueError(
'Record-varying data cannot be scalar. '
'Specify NRV with CDF.new() or put data in array.')
dims = guess_dims[1:]
else:
dims = guess_dims
if type is None:
type = guess_types[0]
if type == const.CDF_EPOCH16.value and self.backward:
type = const.CDF_EPOCH
if n_elements is None:
n_elements = guess_elements
if dimVarys is None:
dimVarys = [True for i in dims]
recVary = const.VARY if recVary else const.NOVARY
dimVarys = [const.VARY if dimVary else const.NOVARY
for dimVary in dimVarys]
if not hasattr(type, 'value'):
type = ctypes.c_long(type)
if type.value == const.CDF_INT8.value and not lib.supports_int8:
raise ValueError(
'64-bit integer support require CDF library 3.4.0')
if type.value in (const.CDF_EPOCH16.value, const.CDF_INT8.value,
const.CDF_TIME_TT2000.value) \
and self.backward:
raise ValueError('Data requires EPOCH16, INT8, or TIME_TT2000; '
'incompatible with backward-compatible CDF')
new_var = Var(self, name, type, n_elements, dims, recVary, dimVarys)
if compress != None:
new_var.compress(compress, compress_param)
if data is not None:
new_var[...] = data
if hasattr(data, 'attrs'):
new_var.attrs.clone(data.attrs)
return new_var
def raw_var(self, name):
"""
Get a "raw" :class:`Var` object.
Normally a :class:`Var` will perform translation of values for
certain types (to/from Unicode for CHAR variables on Py3k,
and to/from datetime for all time types). A "raw" object
does not perform this translation, on read or write.
This does *not* affect the data on disk, and in fact it
is possible to maintain multiple Python objects with access
to the same zVariable.
Parameters
==========
name : str
name or number of the zVariable
"""
v = self[name]
v._raw = True
return v
def save(self):
"""
Saves the CDF file but leaves it open.
If closing the CDF, :meth:`close` is sufficient;
there is no need to call
:meth:`save` before :meth:`close`.
.. note::
Relies on an undocumented call of the CDF C library, which is
also used in the Java interface.
Raises
======
CDFError : if CDF library reports an error
Warns
=====
CDFWarning : if CDF library reports a warning
"""
self._call(const.SAVE_, const.CDF_)
def copy(self):
"""
Make a copy of all data and attributes in this CDF
Returns
=======
out : :py:class:`CDFCopy`
:class:`~spacepy.datamodel.SpaceData`-like object of all data
"""
return CDFCopy(self)
def version(self):
"""
Get version of library that created this CDF
Returns
=======
out : tuple
version of CDF library, in form (version, release, increment)
"""
ver = ctypes.c_long(0)
rel = ctypes.c_long(0)
inc = ctypes.c_long(0)
self._call(const.GET_, const.CDF_VERSION_, ctypes.byref(ver),
const.GET_, const.CDF_RELEASE_, ctypes.byref(rel),
const.GET_, const.CDF_INCREMENT_, ctypes.byref(inc))
return (ver.value, rel.value, inc.value)
def _get_attrs(self):
"""Get attribute list
Provide access to the CDF's attribute list without holding a
strong reference, as the attribute list has a (strong)
back-reference to its parent.
Either deref a weak reference (to try and keep the object the same),
or make a new AttrList instance and assign it to the weak reference
for next time.
"""
al = self._attrlistref()
if al is None:
al = gAttrList(self)
self._attrlistref = weakref.ref(al)
return al
def _set_attrs(self, value):
"""Assign to the attribute list
Clears all elements of the attribute list and copies from value
"""
self.attrs.clone(value)
attrs = property(
_get_attrs, _set_attrs, None,
"""Global attributes for this CDF in a dict-like format.
See :class:`gAttrList` for details.
""")
def var_num(self, varname):
"""Get the variable number of a particular variable name
This maintains a cache of name-to-number mappings for zVariables
to keep from having to query the CDF library constantly. It's mostly
an internal function.
Parameters
==========
varname : bytes
name of the zVariable. Not this is NOT a string in Python 3!
Raises
======
CDFError : if variable is not found
Returns
=======
out : int
Variable number of this zvariable.
"""
num = self._var_nums.get(varname, None)
if num is None: #Copied from Var._get, which can hopefully be thinned
varNum = ctypes.c_long(0)
self._call(const.GET_, const.zVAR_NUMBER_, varname,
ctypes.byref(varNum))
num = varNum.value
self._var_nums[varname] = num
return num
def attr_num(self, attrname):
"""Get the attribute number and scope by attribute name
This maintains a cache of name-to-number mappings for attributes
to keep from having to query the CDF library constantly. It's mostly
an internal function.
Parameters
==========
attrname : bytes
name of the zVariable. Not this is NOT a string in Python 3!
Raises
======
CDFError : if variable is not found
Returns
=======
out : tuple
attribute number, scope (True for global) of this attribute
"""
res = self._attr_info.get(attrname, None)
if res is None: #Copied from Var._get, which can hopefully be thinned
attrNum = ctypes.c_long(0)
self._call(const.GET_, const.ATTR_NUMBER_, attrname,
ctypes.byref(attrNum))
scope = ctypes.c_long(0)
self._call(const.SELECT_, const.ATTR_, attrNum,
const.GET_, const.ATTR_SCOPE_, ctypes.byref(scope))
if scope.value == const.GLOBAL_SCOPE.value:
scope = True
elif scope.value == const.VARIABLE_SCOPE.value:
scope = False
else:
raise CDFError(const.BAD_SCOPE)
res = (attrNum.value, scope)
self._attr_info[attrname] = res
return res
def clear_attr_from_cache(self, attrname):
"""Mark an attribute deleted in the name-to-number cache
Will remove an attribute, and all attributes with higher numbers,
from the attribute cache.
Does NOT delete the variable!
This maintains a cache of name-to-number mappings for attributes
to keep from having to query the CDF library constantly. It's mostly
an internal function.
Parameters
==========
attrname : bytes
name of the attribute. Not this is NOT a string in Python 3!
"""
num, scope = self.attr_num(attrname)
#All numbers higher than this are renumbered
for a, n in list(self._attr_info.items()):
if n[0] >= num:
del self._attr_info[a]
def clear_from_cache(self, varname):
"""Mark a variable deleted in the name-to-number cache
Will remove a variable, and all variables with higher numbers,
from the variable cache.
Does NOT delete the variable!
This maintains a cache of name-to-number mappings for zVariables
to keep from having to query the CDF library constantly. It's mostly
an internal function.
Parameters
==========
varname : bytes
name of the zVariable. Not this is NOT a string in Python 3!
"""
num = self.var_num(varname)
#All numbers higher than this are renumbered
for v, n in list(self._var_nums.items()):
if n >= num:
del self._var_nums[v]
def add_attr_to_cache(self, attrname, num, scope):
"""Add an attribute to the name-to-number cache
This maintains a cache of name-to-number mappings for attributes
to keep from having to query the CDF library constantly. It's mostly
an internal function.
Parameters
==========
varname : bytes
name of the zVariable. Not this is NOT a string in Python 3!
num : int
number of the variable
scope : bool
True if global scope; False if variable scope.
"""
self._attr_info[attrname] = (num, scope)
def add_to_cache(self, varname, num):
"""Add a variable to the name-to-number cache
This maintains a cache of name-to-number mappings for zVariables
to keep from having to query the CDF library constantly. It's mostly
an internal function.
Parameters
==========
varname : bytes
name of the zVariable. Not this is NOT a string in Python 3!
num : int
number of the variable
"""
self._var_nums[varname] = num
#Note there is no function for delete, currently handled in Var.rename
#and Attr.rename by just deleting from the dict directly. Maybe this
#should be differen (maybe should be possible to follow a variable across
#a rename...)
class Var(MutableSequence):
"""
A CDF variable.
This object does not directly store the data from the CDF; rather,
it provides access to the data in a format that much like a Python
list or numpy :class:`~numpy.ndarray`.
General list information is available in the python docs:
`1 <http://docs.python.org/tutorial/introduction.html#lists>`_,
`2 <http://docs.python.org/tutorial/datastructures.html#more-on-lists>`_,
`3 <http://docs.python.org/library/stdtypes.html#typesseq>`_.
The CDF user's guide, section 2.3, provides background on variables.
.. note::
Not intended to be created directly; use methods of :class:`CDF` to gain access to a variable.
A record-varying variable's data are viewed as a hypercube of dimensions
n_dims+1 (the extra dimension is the record number). They are indexed in
row-major fashion, i.e. the last index changes most frequently / is
contiguous in memory. If the CDF is column-major, the data are
transformed to row-major before return.
Non record-varying variables are similar, but do not have the extra
dimension of record number.
Variables can be subscripted by a multidimensional index to return the
data. Indices are in row-major order with the first dimension
representing the record number. If the CDF is column major,
the data are reordered to row major. Each dimension is specified
by standard Python
`slice <http://docs.python.org/tutorial/introduction.html#strings>`_
notation, with dimensions separated by commas. The ellipsis fills in
any missing dimensions with full slices. The returned data are
lists; Python represents multidimensional arrays as nested lists.
The innermost set of lists represents contiguous data.
.. note::
numpy 'fancy indexing' is *not* supported.
Degenerate dimensions are 'collapsed', i.e. no list of only one
element will be returned if a single subscript is specified
instead of a range. (To avoid this, specify a slice like 1:2,
which starts with 1 and ends before 2).
Two special cases:
1. requesting a single-dimension slice for a
record-varying variable will return all data for that
record number (or those record numbers) for that variable.
2. Requests for multi-dimensional variables may skip the record-number
dimension and simply specify the slice on the array itself. In that
case, the slice of the array will be returned for all records.
In the event of ambiguity (e.g., single-dimension slice on a one-dimensional
variable), case 1 takes priority.
Otherwise, mismatch between the number of dimensions specified in
the slice and the number of dimensions in the variable will cause
an :exc:`~exceptions.IndexError` to be thrown.
This all sounds very complicated but it is essentially attempting
to do the 'right thing' for a range of slices.
An unusual case is scalar (zero-dimensional) non-record-varying variables.
Clearly they cannot be subscripted normally. In this case, use the
``[...]`` syntax meaning 'access all data.':
>>> import pycdf
>>> testcdf = pycdf.CDF('test.cdf', '')
>>> variable = testcdf.new('variable', recVary=False,
... type=pycdf.const.CDF_INT4)
>>> variable[...] = 10
>>> variable
<Var:
CDF_INT4 [] NRV
>
>>> variable[...]
10
Reading any empty non-record-varying variable will return an empty
with the same *number* of dimensions, but all dimensions will be
of zero length. The scalar is, again, a special case: due to the
inability to have a numpy array which is both zero-dimensional and empty,
reading an NRV scalar variable with no data will return an empty
one-dimensional array. This is really not recommended.
As a list type, variables are also `iterable
<http://docs.python.org/tutorial/classes.html#iterators>`_; iterating
over a variable returns a single complete record at a time.
This is all clearer with examples. Consider a variable ``B_GSM``, with
three elements per record (x, y, z components) and fifty records in
the CDF. Then:
1. ``B_GSM[0, 1]`` is the y component of the first record.
2. ``B_GSM[10, :]`` is a three-element list, containing x, y, and z
components of the 11th record. As a shortcut, if only one dimension
is specified, it is assumed to be the record number, so this
could also be written ``B_GSM[10]``.
3. ``B_GSM[...]`` reads all data for ``B_GSM`` and returns it as a
fifty-element list, each element itself being a three-element
list of x, y, z components.
Multidimensional example: consider fluxes stored as a function of
pitch angle and energy. Such a variable may be called Flux and
stored as a two-dimensional array, with the first dimension
representing (say) ten energy steps and the second, eighteen
pitch angle bins (ten degrees wide, centered from 5 to 175 degrees).
Assume 100 records stored in the CDF (i.e. 100 different times).
1. ``Flux[4]`` is a list of ten elements, one per energy step,
each element being a list of 18 fluxes, one per pitch bin.
All are taken from the fifth record in the CDF.
2. ``Flux[4, :, 0:4]`` is the same record, all energies, but
only the first four pitch bins (roughly, field-aligned).
3. ``Flux[..., 0:4]`` is a 100-element list (one per record),
each element being a ten-element list (one per energy step),
each containing fluxes for the first four pitch bins.
This slicing notation is very flexible and allows reading
specifically the desired data from the CDF.
All data are, on read, converted to appropriate Python data
types; EPOCH, EPOCH16, and TIME_TT2000 types are converted to
:class:`~datetime.datetime`. Data are returned in numpy arrays.
.. note::
Although pycdf supports TIME_TT2000 variables, the Python
:class:`~datetime.datetime` object does not support leap
seconds. Thus, on read, any seconds past 59 are truncated
to 59.999999 (59 seconds, 999 milliseconds, 999 microseconds).
Potentially useful list methods and related functions:
- `count <http://docs.python.org/tutorial/datastructures.html#more-on-lists>`_
- `in <http://docs.python.org/reference/expressions.html#in>`_
- `index <http://docs.python.org/tutorial/datastructures.html#more-on-lists>`_
- `len <http://docs.python.org/library/functions.html#len>`_
- `list comprehensions
<http://docs.python.org/tutorial/datastructures.html#list-comprehensions>`_
- `sorted <http://docs.python.org/library/functions.html#sorted>`_
The topic of array majority can be very confusing; good background material
is available at `IDL Array Storage and Indexing
<http://www.idlcoyote.com/misc_tips/colrow_major.html>`_. In brief,
*regardless of the majority stored in the CDF*, pycdf will always present
the data in the native Python majority, row-major order, also known as
C order. This is the default order in `NumPy
<http://docs.scipy.org/doc/numpy/reference/arrays.ndarray.html
#internal-memory-layout-of-an-ndarray>`_.
However, packages that render image data may expect it in column-major
order. If the axes seem 'swapped' this is likely the reason.
The :attr:`~Var.attrs` Python attribute acts as a dictionary referencing
zAttributes (do not confuse the two); all the dictionary methods above
also work on the attribute dictionary. See :class:`zAttrList` for more on
the dictionary of attributes.
With writing, as with reading, every attempt has been made to match the
behavior of Python lists. You can write one record, many records, or even
certain elements of all records. There is one restriction: only the record
dimension (i.e. dimension 0) can be resized by write, as all records
in a variable must have the same dimensions. Similarly, only whole
records can be deleted.
.. note::
Unusual error messages on writing data usually mean that pycdf is
unable to interpret the data as a regular array of a single type
matching the type and shape of the variable being written.
A 5x4 array is supported; an irregular array where one row has
five columns and a different row has six columns is not. Error messages
of this type include:
- ``Data must be well-formed, regular array of number, string, or datetime``
- ``setting an array element with a sequence.``
- ``shape mismatch: objects cannot be broadcast to a
single shape``
For these examples, assume Flux has 100 records and dimensions [2, 3].
Rewrite the first record without changing the rest:
>>> Flux[0] = [[1, 2, 3], [4, 5, 6]]
Writes a new first record and delete all the rest:
>>> Flux[...] = [[1, 2, 3], [4, 5, 6]]
Write a new record in the last position and add a new record after:
>>> Flux[99:] = [[[1, 2, 3], [4, 5, 6]],
... [[11, 12, 13], [14, 15, 16]]]
Insert two new records between the current number 5 and 6:
>>> Flux[5:6] = [[[1, 2, 3], [4, 5, 6]], [[11, 12, 13],
... [14, 15, 16]]]
This operation can be quite slow, as it requires reading and
rewriting the entire variable. (CDF does not directly support
record insertion.)
Change the first element of the first two records but leave other
elements alone:
>>> Flux[0:2, 0, 0] = [1, 2]
Remove the first record:
>>> del Flux[0]
Removes record 5 (the sixth):
>>> del Flux[5]
Due to the need to work around a bug in the CDF library, this operation
can be quite slow.
Delete *all data* from ``Flux``, but leave the variable definition intact:
>>> del Flux[...]
.. note::
Although this interface only directly supports zVariables, zMode is
set on opening the CDF so rVars appear as zVars. See p.24 of the
CDF user's guide; pyCDF uses zMode 2.
.. autosummary::
~Var.attrs
~Var.compress
~Var.copy
~Var.dtype
~Var.dv
~Var.insert
~Var.name
~Var.rename
~Var.rv
~Var.shape
~Var.type
.. attribute:: Var.attrs
zAttributes for this zVariable in a dict-like format.
See :class:`zAttrList` for details.
.. automethod:: compress
.. automethod:: copy
.. autoattribute:: dtype
.. automethod:: dv
.. automethod:: insert
.. automethod:: name
.. automethod:: rename
.. automethod:: rv
.. autoattribute:: shape
.. automethod:: type
"""
def __init__(self, cdf_file, var_name, *args):
"""Create or locate a variable
Parameters
==========
cdf_file : :py:class:`pycdf.CDF`
CDF file containing this variable
var_name : string
name of this variable
Other Parameters
================
args
additional arguments passed to :py:meth:`_create`. If none,
opens an existing variable. If provided, creates a
new one.
Raises
======
CDFError
if CDF library reports an error
Warns
=====
CDFWarning
if CDF library reports a warning
"""
self.cdf_file = cdf_file
#This is the definitive "identify" of variable
self._name = None
self._type = None #CDF type (long)
self._raw = False #Raw access (skip all conversions)
if len(args) == 0:
self._get(var_name)
else:
self._create(var_name, *args)
#Weak reference to attribute list (use attrs instead)
#This avoids a reference loop
self._attrlistref = weakref.ref(zAttrList(self))
def __getitem__(self, key):
"""Returns a slice from the data array. Details under :py:class:`pycdf.Var`.
@return: The data from this variable
@rtype: list-of-lists of appropriate type.
@raise IndexError: if L{key} is out of range, mismatches dimensions,
or simply unparseable.
@raise CDFError: for errors from the CDF library
"""
hslice = _Hyperslice(self, key)
#Hyperslice mostly catches this sort of thing, but
#an empty variable is a special case, since we might want to
#WRITE to 0th record (which Hyperslice also supports) but
#can't READ from it, and iterating over tries to read from it.
if hslice.rv:
if hslice.dimsizes[0] == 0 and hslice.degen[0] and \
hslice.starts[0] == 0:
raise IndexError('record index out of range')
#For NRV, again hslice will assume 0th record exists since we might
#want to write. So ANY degenerate dim other than the glued-on 0th
#suggests an explicit index that should fail. None degenerate suggests
#make an empty array.
#Note this is pulling a lot of hyperslice stuff into getitem!
elif hslice.dimsizes[0] == 0:
if len(hslice.degen) > 1 and max(hslice.degen[1:]):
raise IndexError('record index out of range')
else:
#The zero-length dimension is degenerate so it gets chopped,
#and you can't have a zero-length numpy array that still
#maintains the size of all other dimensions. So just force
#a zero-dim array and the rest will follow
hslice.counts[...] = 0
#If this is a scalar, need to make a single non-degenerate
#dimension so it can be empty.
if len(hslice.counts) == 1:
hslice.degen[0] = False
result = hslice.create_array()
if hslice.counts[0] != 0:
hslice.select()
lib.call(const.GET_, const.zVAR_HYPERDATA_,
result.ctypes.data_as(ctypes.c_void_p))
return hslice.convert_input_array(result)
def __delitem__(self, key):
"""Removes a record (or set of records) from the CDF
Only whole records can be deleted, so the del call must either specify
only one dimension or it must specify all elements of the non-record
dimensions. This is *not* a way to resize a variable!
Deleting records from the middle of a variable may be very slow in
some circumstances. To work around a bug in CDF library versions
3.4.0 and before, all the data must be read in, the requested deletions
done, and then all written back out.
@param key: index or slice to delete
@type key: int or slice
@raise TypeError: if an attempt is made to delete from a non
record-varying variable, or to delete below
the record level
"""
if not self.rv():
raise TypeError('Cannot delete records from non-record-varying '
'variable.')
hslice = _Hyperslice(self, key)
if hslice.dims > 1 and (hslice.counts[1:] != hslice.dimsizes[1:]).any():
raise TypeError('Can only delete entire records.')
if hslice.counts[0] == 0:
return
start = hslice.starts[0]
count = hslice.counts[0]
interval = hslice.intervals[0]
dimsize = hslice.dimsizes[0]
self._call()
dangerous_delete = False
if lib._del_middle_rec_bug and \
(interval != 1 or (start != 0 and start + count < dimsize)):
#delete from middle is dangerous if only have one index entry
entries = ctypes.c_long(0)
lib.call(const.GET_, const.zVAR_nINDEXENTRIES_,
ctypes.byref(entries))
dangerous_delete = (entries.value == 1)
if dangerous_delete:
data = self[...]
data = numpy.delete(
data,
numpy.arange(start, start + count * interval, interval),
0)
self[0:dimsize - count] = data
first_rec = dimsize - count
last_rec = dimsize - 1
lib.call(const.DELETE_, const.zVAR_RECORDS_,
ctypes.c_long(first_rec), ctypes.c_long(last_rec))
elif interval == 1:
first_rec = ctypes.c_long(start)
last_rec = ctypes.c_long(start + count - 1)
lib.call(const.DELETE_, const.zVAR_RECORDS_,
first_rec, last_rec)
else:
self._call()
#delete from end to avoid renumbering of records
for recno in range(start + (count - 1) * interval,
start - 1, -1 * interval):
lib.call(const.DELETE_, const.zVAR_RECORDS_,
ctypes.c_long(recno), ctypes.c_long(recno))
def __setitem__(self, key, data):
"""Puts a slice into the data array. Details under :py:class:`pycdf.Var`.
@param key: index or slice to store
@type key: int or slice
@param data: data to store
@type data: numpy.array
@raise IndexError: if L{key} is out of range, mismatches dimensions,
or simply unparseable. IndexError will
@raise CDFError: for errors from the CDF library
"""
hslice = _Hyperslice(self, key)
n_recs = hslice.counts[0]
hslice.expand(data)
cdf_type = self.type()
if cdf_type == const.CDF_EPOCH16.value:
if not self._raw:
try:
data = lib.v_datetime_to_epoch16(data)
except AttributeError:
pass
data = numpy.require(data, requirements=('C', 'A', 'W'),
dtype=numpy.float64)
elif cdf_type == const.CDF_EPOCH.value:
if not self._raw:
try:
data = lib.v_datetime_to_epoch(data)
except AttributeError:
pass
data = numpy.require(data, requirements=('C', 'A', 'W'),
dtype=numpy.float64)
elif cdf_type == const.CDF_TIME_TT2000.value:
if not self._raw:
try:
data = lib.v_datetime_to_tt2000(data)
except AttributeError:
pass
data = numpy.require(data, requirements=('C', 'A', 'W'),
dtype=numpy.int64)
else:
data = numpy.require(data, requirements=('C', 'A', 'W'),
dtype=self._np_type())
if cdf_type == const.CDF_EPOCH16.value:
datashape = data.shape[:-1]
else:
datashape = data.shape
#Check data sizes
if datashape != tuple(hslice.expected_dims()):
raise ValueError('attempt to assign data of dimensions ' +
str(datashape) + ' to slice of dimensions ' +
str(tuple(hslice.expected_dims())))
#Flip majority and reversed dimensions, see convert_input_array
data = hslice.convert_output_array(data)
#Handle insertions and similar weirdness
if hslice.counts[0] > n_recs and \
hslice.starts[0] + n_recs < hslice.dimsizes[0]:
#Specified slice ends before last record, so insert in middle
saved_data = self[hslice.starts[0] + n_recs:]
if hslice.counts[0] > 0:
hslice.select()
lib.call(const.PUT_, const.zVAR_HYPERDATA_,
data.ctypes.data_as(ctypes.c_void_p))
if hslice.counts[0] < n_recs:
first_rec = hslice.starts[0] + hslice.counts[0]
last_rec = hslice.dimsizes[0] - 1
lib.call(const.DELETE_, const.zVAR_RECORDS_,
ctypes.c_long(first_rec), ctypes.c_long(last_rec))
elif hslice.counts[0] > n_recs and \
hslice.starts[0] + n_recs < hslice.dimsizes[0]:
#Put saved data in after inserted data
self[hslice.starts[0] + hslice.counts[0]:] = saved_data
def extend(self, data):
"""
Append multiple values to the end of this variable
This is an efficiency function which overrides the base implementation
in MutableSequence.
Parameters
----------
data :
the data to append
"""
self[len(self):] = data
def insert(self, index, data):
"""
Inserts a *single* record before an index
Parameters
----------
index : int
index before which to insert the new record
data :
the record to insert
"""
self[index:index] = [data]
def _create(self, var_name, datatype, n_elements = 1, dims = (),
recVary = const.VARY, dimVarys = None):
"""Creates a new zVariable
@param var_name: name of this variable
@type var_name: string
@param datatype: CDF data type
@type datatype: ctypes.c_long
@param n_elements: number of elements (should be 1 except for
CDF_CHAR variables).
@type n_elements: long
@param dims: size of each dimension for multi-dimensional variable,
or empty for a zero-dimensional
@type dims: sequence of long
@param recVary: record variance for this variable (VARY/NOVARY)
@type recVary: long
@param dimVarys: array of VARY or NOVARY, variance for each dimension
@type dimVarys: sequence of long
@return: new variable with this name
@rtype: :py:class:`pycdf.Var`
@raise CDFError: if CDF library reports an error
@raise CDFWarning: if CDF library reports a warning and interpreter
is set to error on warnings.
@note: Not intended to be used directly; use L{CDF.new}.
"""
dim_array = (ctypes.c_long * len(dims))(*dims)
enc_name = var_name.encode('ascii')
if dimVarys is None:
dim_vary_array = (ctypes.c_long * (len(dims) if len(dims) > 0 else 1))(const.VARY)
else:
dim_vary_array = (ctypes.c_long * len(dims))(*dimVarys)
varNum = ctypes.c_long(0)
self.cdf_file._call(const.CREATE_, const.zVAR_, enc_name, datatype,
ctypes.c_long(n_elements), ctypes.c_long(len(dims)), dim_array,
recVary, dim_vary_array, ctypes.byref(varNum))
self._name = enc_name
self.cdf_file.add_to_cache(enc_name, varNum.value)
def _delete(self):
"""Removes this zVariable from the CDF
@raise CDFError: if CDF library reports an error
@raise CDFWarning: if CDF library reports a warning and interpreter
is set to error on warnings.
"""
self._call(const.DELETE_, const.zVAR_)
self.cdf_file.clear_from_cache(self._name)
self._name = None
def _get(self, var_name):
"""Gets an existing zVariable
@param var_name: name of this variable
@type var_name: string
@return: variable with this name
@rtype: :py:class:`pycdf.Var`
@raise CDFError: if CDF library reports an error
@raise CDFWarning: if CDF library reports a warning and interpreter
is set to error on warnings.
@note: Not intended to be used directly; use L{CDF.__getitem__}.
"""
if isinstance(var_name, str_classes):
try:
enc_name = var_name.encode('ascii').rstrip()
except AttributeError:
enc_name = var_name.rstrip() #already in ASCII
#'touch' CDF to cause an error if the name isn't there; get number
varNum = ctypes.c_long(0)
self.cdf_file._call(const.GET_, const.zVAR_NUMBER_, enc_name, ctypes.byref(varNum))
self._name = enc_name
self.cdf_file.add_to_cache(enc_name, varNum.value)
else: #Looking up by number
name = ctypes.create_string_buffer(const.CDF_VAR_NAME_LEN256+1)
self.cdf_file._call(const.SELECT_, const.zVAR_, ctypes.c_long(var_name),
const.GET_, const.zVAR_NAME_, name)
self._name = name.value.rstrip()
self.cdf_file.add_to_cache(self._name, var_name)
def _num(self):
"""Returns the zVar number for this variable
@return: number of this zVar
@rtype: int
"""
return self.cdf_file.var_num(self._name)
def __len__(self):
"""Get number of records for this variable in this file
@return: Number of records
@rtype: long
@raise CDFError: if CDF library reports an error
@raise CDFWarning: if CDF library reports a warning and interpreter
is set to error on warnings.
"""
count = ctypes.c_long(0)
self._call(const.GET_, const.zVAR_MAXREC_, ctypes.byref(count))
return (count.value + 1)
def __repr__(self):
"""Returns representation of the variable
Cannot return anything that can be eval'd to create a copy,
so just wrap the informal representation in angle brackets.
@return: info on this zVar
@rtype: str
"""
return '<Var:\n' + str(self) + '\n>'
def __str__(self):
"""Returns a string representation of the variable
This is an 'informal' representation in that it cannot be evaluated
directly to create a :py:class:`pycdf.Var`.
@return: info on this zVar, CDFTYPE [dimensions] NRV
(if not record-varying)
@rtype: str
"""
if self.cdf_file._opened:
cdftype = self.type()
chartypes = (const.CDF_CHAR.value, const.CDF_UCHAR.value)
rv = self.rv()
typestr = lib.cdftypenames[cdftype] + \
('*' + str(self._nelems()) if cdftype in chartypes else '' )
if rv:
sizestr = str([len(self)] + self._dim_sizes())
else:
sizestr = str(self._dim_sizes())
return typestr + ' ' + sizestr + ('' if rv else ' NRV')
else:
if isinstance(self._name, str):
return 'zVar "{0}" in closed CDF {1}'.format(
self._name, self.cdf_file.pathname)
else:
return 'zVar "{0}" in closed CDF {1}'.format(
self._name.decode('ascii'),
self.cdf_file.pathname.decode('ascii'))
def _n_dims(self):
"""Get number of dimensions for this variable
@return: the number of dimensions
@rtype: long
"""
n_dims = ctypes.c_long(0)
self._call(const.GET_, const.zVAR_NUMDIMS_, ctypes.byref(n_dims))
return n_dims.value
def _dim_sizes(self):
"""Get the dimension sizes for this variable
@return: sequence of sizes
@rtype: sequence of long
@note: This will always be in Python order (i.e. row major, last index
iterates most quickly), *regardless* of the majority of the CDF.
"""
sizes = (ctypes.c_long * const.CDF_MAX_DIMS)(0)
self._call(const.GET_, const.zVAR_DIMSIZES_, sizes)
sizes = sizes[0:self._n_dims()]
return sizes
def rv(self, new_rv=None):
"""
Gets or sets whether this variable has record variance
If the variance is unknown, True is assumed
(this replicates the apparent behavior of the CDF library on
variable creation).
Other Parameters
================
new_rv : boolean
True to change to record variance, False to change to NRV,
unspecified to simply check variance.
Returns
=======
out : Boolean
True if record varying, False if NRV
"""
if new_rv != None:
self._call(const.PUT_, const.zVAR_RECVARY_,
const.VARY if new_rv else const.NOVARY)
vary = ctypes.c_long(0)
self._call(const.GET_, const.zVAR_RECVARY_, ctypes.byref(vary))
return vary.value != const.NOVARY.value
def dv(self, new_dv=None):
"""
Gets or sets dimension variance of each dimension of variable.
If the variance is unknown, True is assumed
(this replicates the apparent behavior of the
CDF library on variable creation).
Parameters
==========
new_dv : list of boolean
Each element True to change that dimension to dimension
variance, False to change to not dimension variance.
(Unspecified to simply check variance.)
Returns
=======
out : list of boolean
True if that dimension has variance, else false.
"""
ndims = self._n_dims()
if new_dv != None:
if len(new_dv) != ndims:
raise ValueError('Must specify variance for ' +
str(ndims) + 'dimensions.')
varies = (ctypes.c_long * ndims)(
*[const.VARY if dv else const.NOVARY for dv in new_dv])
self._call(const.PUT_, const.zVAR_DIMVARYS_,
varies)
if ndims == 0:
return []
varies = (ctypes.c_long * const.CDF_MAX_DIMS)()
self._call(const.GET_, const.zVAR_DIMVARYS_, varies)
return [dv != const.NOVARY.value for dv in varies[0:ndims]]
def _call(self, *args, **kwargs):
"""Select this CDF and variable and call the CDF internal interface
Adds call to select this CDF to L{args} and passes all parameters
directly through to the CDFlib routine of the CDF library's C internal
interface. Checks the return value with L{Library.check_status}.
@param args: Passed directly to the CDF library interface. Useful
constants are defined in the :py:mod:`pycdf.const` module of this package.
@type args: various, see :py:mod:`ctypes`.
@return: CDF status from the library
@rtype: ctypes.c_long
@note: Terminal NULL_ is automatically added to L{args}.
@raise CDFError: if CDF library reports an error
@raise CDFWarning: if CDF library reports a warning and interpreter
is set to error on warnings.
"""
return self.cdf_file._call(
const.SELECT_, const.zVAR_,
ctypes.c_long(self.cdf_file.var_num(self._name)), *args, **kwargs)
def _np_type(self):
"""Returns the numpy type of this variable
This is the numpy type that will come directly out of the CDF;
see :meth:`dtype` for the representation post-conversion.
Raises
======
CDFError : for library-reported error or failure to find numpy type
Returns
=======
out : dtype
numpy dtype that will hold value from this variable
"""
cdftype = self.type()
if cdftype == const.CDF_CHAR.value or cdftype == const.CDF_UCHAR.value:
return numpy.dtype('S' + str(self._nelems()))
try:
return lib.numpytypedict[cdftype]
except KeyError:
raise CDFError(const.BAD_DATA_TYPE)
def type(self, new_type=None):
"""
Returns or sets the CDF type of this variable
Parameters
==========
new_type : ctypes.c_long
the new type from :mod:`~pycdf.const`
Returns
=======
out : int
CDF type
"""
if new_type != None:
if not hasattr(new_type, 'value'):
new_type = ctypes.c_long(new_type)
n_elements = ctypes.c_long(self._nelems())
self._call(const.PUT_, const.zVAR_DATASPEC_,
new_type, n_elements)
self._type = None
if self._type is None:
cdftype = ctypes.c_long(0)
self._call(const.GET_, const.zVAR_DATATYPE_,
ctypes.byref(cdftype))
self._type = cdftype.value
return self._type
def _nelems(self):
"""Number of elements for each value in this variable
This is the length of strings for CHAR and UCHAR,
should be 1 otherwise.
@return: length of strings
@rtype: int
"""
nelems = ctypes.c_long(0)
self._call(const.GET_, const.zVAR_NUMELEMS_, ctypes.byref(nelems))
return nelems.value
def name(self):
"""
Returns the name of this variable
Returns
=======
out : str
variable's name
"""
if isinstance(self._name, str):
return self._name
elif isinstance(self._name, bytes):
return self._name.decode()
def compress(self, comptype=None, param=None):
"""
Set or check the compression of this variable
Compression may not be changeable on variables with data already
written; even deleting the data may not permit the change.
See section 2.6 of the CDF user's guide for more information on
compression.
Other Parameters
================
comptype : ctypes.c_long
type of compression to change to, see CDF C reference
manual section 4.10. Constants for this parameter
are in :mod:`~pycdf.const`. If not specified, will not
change compression.
param : ctypes.c_long
Compression parameter, see CDF CRM 4.10 and
:mod:`~pycdf.const`.
If not specified, will choose reasonable default (5 for
gzip; other types have only one possible parameter.)
Returns
=======
out : tuple
the (comptype, param) currently in effect
"""
return _compress(self, comptype, param)
def copy(self):
"""
Copies all data and attributes from this variable
Returns
=======
out : :class:`VarCopy`
list of all data in record order
"""
return VarCopy(self)
def rename(self, new_name):
"""
Renames this variable
Parameters
==========
new_name : str
the new name for this variable
"""
try:
enc_name = new_name.encode('ascii')
except AttributeError:
enc_name = new_name
if len(enc_name) > const.CDF_VAR_NAME_LEN256:
raise CDFError(const.BAD_VAR_NAME)
self._call(const.PUT_, const.zVAR_NAME_, enc_name)
self.cdf_file.add_to_cache(
enc_name,
self.cdf_file.var_num(self._name)) #Still in cache
del self.cdf_file._var_nums[self._name]
self._name = enc_name
@property
def shape(self):
"""
Provides the numpy array-like shape of this variable.
Returns a tuple; first element is number of records (RV variable
only) And the rest provide the dimensionality of the variable.
.. note::
Assigning to this attribute will not change the shape.
"""
if self.rv():
return tuple([len(self)] + self._dim_sizes())
else:
return tuple(self._dim_sizes())
@property
def dtype(self):
"""
Provide the numpy dtype equivalent to the CDF type of this variable.
Data from this variable will be returned in numpy arrays of this type.
See Also
--------
type
"""
cdftype = self.type()
if cdftype in (const.CDF_CHAR.value, const.CDF_UCHAR.value) and \
str is not bytes and not self._raw:
return numpy.dtype('U' + str(self._nelems()))
if cdftype in (const.CDF_EPOCH.value, const.CDF_EPOCH16.value,
const.CDF_TIME_TT2000.value) and not self._raw:
return numpy.dtype('O')
return self._np_type()
def _get_attrs(self):
"""Get attribute list
Provide access to the zVar's attribute list without holding a
strong reference, as the attribute list has a (strong)
back-reference to its parent.
Either deref a weak reference (to try and keep the object the same),
or make a new AttrList instance and assign it to the weak reference
for next time.
"""
al = self._attrlistref()
if al is None:
al = zAttrList(self)
self._attrlistref = weakref.ref(al)
return al
def _set_attrs(self, value):
"""Assign to the attribute list
Clears all elements of the attribute list and copies from value
"""
self.attrs.clone(value)
attrs = property(
_get_attrs, _set_attrs, None,
"""zAttributes for this zVariable in a dict-like format.
See :class:`zAttrList` for details.
""")
class _Hyperslice(object):
"""Represents a CDF 'slice' used for the hyper CDF functions
For internal module use only.
@ivar dims: number of dimensions to this slice, usually
number of dimensions to the variable plus one
for the record, which represents the 0th
(least rapidly varying) dimension.
@type dims: int
@ivar dimsizes: size of each dimension (0th is number of records)
@type dimsizes: list of int
@ivar starts: index of the start value for each dimension
('dimension indices' in CDF speak)
@type starts: list of int
@ivar counts: number of values to get from each dimension.
Final result will be the product of everything
in counts.
('dimension counts' in CDF speak)
@type counts: numpy.array
@ivar intervals: interval between successive indices
to use for each dimension.
('dimension invervals' in CDF speak)
@type intervals: list of int
@ivar degen: is this dimension degenerate, i.e. should be
removed in the returned dataset. A 3D array
with one dimension degenerate will be returned
as a 2D array (i.e. list-of-lists.)
@type degen: numpy.array
@ivar rev: should this dimension be returned in reverse order?
@type rev: numpy.array
@ivar column: is this slice in column-major mode (if false, row-major)
@type column: boolean
@ivar zvar: what CDF variable this object slices on
@type zvar: :py:class:`pycdf.Var`
@ivar expanded_key: fully-expanded version of the key passed to the
constructor (all dimensions filled in)
@type expanded_key: tuple
@note: All dimension-related variables are stored row-major
(Python order)
"""
def __init__(self, zvar, key):
"""Create a Hyperslice
@param zvar: zVariable that this slices
@type zvar: :py:class:`pycdf.Var`
@param key: Python multi-dimensional slice as passed to
__getitem__
@type key: tuple of slice and/or int
@raise IndexError: if slice is out of range, mismatches dimensions, or
otherwise unparsable.
@raise ValueError: if slice has invalid values
"""
self.zvar = zvar
self.rv = self.zvar.rv()
#dim of records, + 1 record dim (NRV always is record 0)
self.dims = zvar._n_dims() + 1
self.dimsizes = [len(zvar)] + \
zvar._dim_sizes()
self.starts = [0] * self.dims
self.counts = numpy.empty((self.dims,), dtype=numpy.int32)
self.counts.fill(1)
self.intervals = [1] * self.dims
self.degen = numpy.zeros(self.dims, dtype=numpy.bool)
self.rev = numpy.zeros(self.dims, dtype=numpy.bool)
#key is:
#1. a single value (integer or slice object) if called 1D
#2. a tuple (of integers and/or slice objects) if called nD
#3. Each item is either a single value (degenerate dim)
# or a slice object.
if not hasattr(key, '__len__'): #Not a container object, pack in tuple
key = (key, )
if not self.rv:
key = (0, ) + key #NRV, so always get 0th record (degenerate)
key = self.expand_ellipsis(key, self.dims)
if self.rv: #special-cases for RV variables
if len(key) == 1: #get all data for this record(s)
key = self.expand_ellipsis(key + (Ellipsis, ), self.dims)
elif len(key) == self.dims - 1: #get same slice from each record
key = (slice(None, None, None), ) + key
if len(key) == self.dims:
self.expanded_key = key
for i in range(self.dims):
idx = key[i]
if hasattr(idx, 'start'): #slice
(self.starts[i], self.counts[i],
self.intervals[i], self.rev[i]) = \
self.convert_range(idx.start, idx.stop,
idx.step, self.dimsizes[i])
else: #Single degenerate value
if idx < 0:
idx += self.dimsizes[i]
if idx != 0 and (idx >= self.dimsizes[i] or idx < 0):
raise IndexError('list index out of range')
self.starts[i] = idx
self.degen[i] = True
else:
raise IndexError('Slice does not match dimensions for zVar ' +
str(zvar._name))
self.column = zvar.cdf_file.col_major()
def expected_dims(self, data=None):
"""Calculate size of non-degenerate dimensions
Figures out size, in each dimension, of expected input data
@return: size of each dimension for this slice, excluding degenerate
@rtype: list of int
"""
return [self.counts[i] for i in range(self.dims) if not self.degen[i]]
def expand(self, data):
"""Expands the record dimension of this slice to hold a set of data
If the length of data (outermost dimension) is larger than the record
count (counts[0]) for this slice, expand the slice to hold all the data.
This requires that the record dimension of the slice not be degenerate,
and also that it not have been completely specified when the hyperslice
was created (i.e. record dimension either ellipsis or no specified
stop.)
Does *not* expand any other dimension, since that's Very Hard in CDF.
@param data: the data which are intended to be stored in this slice
@type data: list
"""
rec_slice = self.expanded_key[0]
if not self.rv or isinstance(data, str_classes) or self.degen[0] or \
not hasattr(rec_slice, 'stop'):
return
if len(data) < self.counts[0]: #Truncate to fit data
if rec_slice.stop is None and rec_slice.step in (None, 1):
self.counts[0] = len(data)
elif len(data) > self.counts[0]: #Expand to fit data
if rec_slice.step in (None, 1):
self.counts[0] = len(data)
def create_array(self):
"""Creates a numpy array to hold the data from this slice
Returns
=======
out : numpy.array
array sized, typed, and dimensioned to hold data from
this slice
"""
counts = self.counts
degen = self.degen
if self.column:
counts = self.reorder(counts)
degen = self.reorder(degen)
#TODO: Forcing C order for now, revert to using self.column later
array = numpy.empty(
[counts[i] for i in range(len(counts)) if not degen[i]],
self.zvar._np_type(), order='C')
return numpy.require(array, requirements=('C', 'A', 'W'))
def convert_input_array(self, buffer):
"""Converts a buffer of raw data from this slice
EPOCH(16) variables always need to be converted.
CHAR need converted to Unicode if py3k
Parameters
==========
buffer : numpy.array
data as read from the CDF file
Returns
=======
out : numpy.array
converted data
"""
result = self._flip_array(buffer)
#Convert to derived types
cdftype = self.zvar.type()
if not self.zvar._raw:
if cdftype in (const.CDF_CHAR.value, const.CDF_UCHAR.value) and \
str != bytes:
dt = numpy.dtype('U{0}'.format(result.dtype.itemsize))
result = numpy.require(numpy.char.array(result).decode(),
dtype=dt)
elif cdftype == const.CDF_EPOCH.value:
result = lib.v_epoch_to_datetime(result)
elif cdftype == const.CDF_EPOCH16.value:
result = lib.v_epoch16_to_datetime(result)
elif cdftype == const.CDF_TIME_TT2000.value:
result = lib.v_tt2000_to_datetime(result)
return result
def convert_output_array(self, buffer):
"""Convert a buffer of data that will go into this slice
Parameters
==========
buffer : numpy.array
data to go into the CDF file
Returns
=======
out : numpy.array
input with majority flipped and dimensions reversed to be
suitable to pass directly to CDF library.
"""
buffer = self._flip_array(buffer)
return numpy.require(buffer, requirements=('C', 'A', 'W'))
def _flip_array(self, data):
"""
Operations for majority, etc. common between convert_input and _output
"""
cdftype = self.zvar.type()
#Flip majority if any non-degenerate dimensions exist
if self.column and not min(self.degen):
#Record-number dim degen, swap whole thing
if self.degen[0]:
if cdftype == const.CDF_EPOCH16.value:
#Maintain last dimension
data = data.transpose(
list(range(len(data.shape) - 2, 0, -1)) +
[len(data.shape) - 1]
)
else:
data = data.transpose()
#Record-number dimension is not degenerate, so keep it first
else:
if cdftype == const.CDF_EPOCH16.value:
data = data.transpose(
[0] + list(range(len(data.shape) - 2, 0, -1)) +
[len(data.shape) - 1]
)
else:
data = data.transpose(
[0] + list(range(len(data.shape) - 1, 0, -1)))
#Reverse non-degenerate dimensions in rev
#Remember that the degenerate indices are already gone!
if self.rev.any():
sliced = [(slice(None, None, -1) if self.rev[i] else slice(None))
for i in range(self.dims) if not self.degen[i]]
if cdftype == const.CDF_EPOCH16.value: #don't reverse last dim
sliced.extend(slice(None))
data = operator.getitem(data, tuple(sliced))
return data
def select(self):
"""Selects this hyperslice in the CDF
Calls the CDF library to select the CDF, variable, records, and
array elements corresponding to this slice.
"""
args = (const.SELECT_, const.zVAR_RECNUMBER_, ctypes.c_long(self.starts[0]),
const.SELECT_, const.zVAR_RECCOUNT_, ctypes.c_long(self.counts[0]),
const.SELECT_, const.zVAR_RECINTERVAL_,
ctypes.c_long(self.intervals[0]))
if self.dims > 1:
dims = self.dims - 1
args += (const.SELECT_, const.zVAR_DIMINDICES_,
(ctypes.c_long * dims)(*self.starts[1:]),
const.SELECT_, const.zVAR_DIMCOUNTS_,
(ctypes.c_long * dims)(*self.counts[1:]),
const.SELECT_, const.zVAR_DIMINTERVALS_,
(ctypes.c_long * dims)(*self.intervals[1:]))
self.zvar._call(*args)
@staticmethod
def expand_ellipsis(slices, n_dims):
"""Expands any ellipses into correct number of full-size slices
@param slices: tuple of slices, integers, or ellipse objects
@type slices: tuple
@param n_dims: number of dimensions this slice is over
@type n_dims: int
@return: L{slices} with ellipses replaced by appropriate number of
full-dimension slices
@rtype: tuple
@raise IndexError: if ellipses specified when already have enough
dimensions
"""
if slices is Ellipsis:
return tuple([slice(None, None, None)
for i in range(n_dims)])
#Elements might be numpy arrays, so can't use in/index
idx = [i for i, v in enumerate(slices) if v is Ellipsis]
if not idx: #no ellipsis
return slices
if len(idx) > 1: #multiples!
raise IndexError('Ellipses can only be used once per slice.')
idx = idx[0]
#how many dims to expand ellipsis to
#remember the ellipsis is in len(slices) and must be replaced!
extra = n_dims - len(slices) + 1
if extra < 0:
raise IndexError('too many indices')
result = slices[0:idx] + (slice(None), ) * extra + slices[idx+1:]
return result
@staticmethod
def check_well_formed(data):
"""Checks if input data is well-formed, regular array"""
d = numpy.asanyarray(data)
if d.dtype == numpy.object: #this is probably going to be bad
try:
len(d.flat[0])
except TypeError: #at least it's not a list
pass
else:
raise ValueError(
'Data must be well-formed, regular array of number, '
'string, or datetime')
@staticmethod
def dimensions(data):
"""Finds the dimensions of a nested list-of-lists
@param data: data of which dimensions are desired
@type data: list (of lists)
@return: dimensions of L{data}, in order outside-in
@rtype: list of int
@raise ValueError: if L{data} has irregular dimensions
"""
d = numpy.asanyarray(data)
_Hyperslice.check_well_formed(d)
return d.shape
@staticmethod
def types(data, backward=False):
"""Find dimensions and valid types of a nested list-of-lists
Any given data may be representable by a range of CDF types; infer
the CDF types which can represent this data. This breaks down to:
1. Proper kind (numerical, string, time)
2. Proper range (stores highest and lowest number)
3. Sufficient resolution (EPOCH16 required if datetime has
microseconds or below.)
If more than one value satisfies the requirements, types are returned
in preferred order:
1. Type that matches precision of data first, then
2. integer type before float type, then
3. Smallest type first, then
4. signed type first, then
5. specifically-named (CDF_BYTE) vs. generically named (CDF_INT1)
So for example, EPOCH_16 is preferred over EPOCH if L{data} specifies
below the millisecond level (rule 1), but otherwise EPOCH is preferred
(rule 2).
For floats, four-byte is preferred unless eight-byte is required:
1. absolute values between 0 and 3e-39
2. absolute values greater than 1.7e38
This will switch to an eight-byte double in some cases where four bytes
would be sufficient for IEEE 754 encoding, but where DEC formats would
require eight.
@param data: data for which dimensions and CDF types are desired
@type data: list (of lists)
@param backward: limit to pre-CDF3 types
@type backward: bool
@return: dimensions of L{data}, in order outside-in;
CDF types which can represent this data;
number of elements required (i.e. length of longest string)
@rtype: 3-tuple of lists ([int], [ctypes.c_long], [int])
@raise ValueError: if L{data} has irregular dimensions
"""
d = numpy.asanyarray(data)
dims = d.shape
elements = 1
types = []
_Hyperslice.check_well_formed(d)
if d.dtype.kind in ('S', 'U'): #it's a string
types = [const.CDF_CHAR, const.CDF_UCHAR]
elements = d.dtype.itemsize
if d.dtype.kind == 'U': #UTF-8 uses 4 bytes per
elements //= 4
elif d.size and hasattr(numpy.ma.getdata(d).flat[0], 'microsecond'):
if max((dt.microsecond % 1000 for dt in d.flat)) > 0:
types = [const.CDF_EPOCH16, const.CDF_EPOCH,
const.CDF_TIME_TT2000]
else:
types = [const.CDF_EPOCH, const.CDF_EPOCH16,
const.CDF_TIME_TT2000]
if backward:
del types[types.index(const.CDF_EPOCH16)]
del types[-1]
elif not lib.supports_int8:
del types[-1]
elif d is data or isinstance(data, numpy.generic):
#numpy array came in, use its type (or byte-swapped)
types = [k for k in lib.numpytypedict
if (lib.numpytypedict[k] == d.dtype
or lib.numpytypedict[k] == d.dtype.newbyteorder())
and not k in lib.timetypes]
if (not lib.supports_int8 or backward) \
and const.CDF_INT8.value in types:
del types[types.index(const.CDF_INT8.value)]
#Maintain priority to match the ordered lists below:
#float/double (44, 45) before real (21/22), and
#byte (41) before int (1) before char (51). So hack.
#Consider making typedict an ordered dict once 2.6 is dead.
types.sort(key=lambda x: x % 50, reverse=True)
if not types: #not a numpy array, or can't parse its type
if d.dtype.kind == 'O': #Object. Try to make it numeric
#Can't do safe casting from Object, so try and compare
#Basically try most restrictive to least restrictive
trytypes = (numpy.uint64, numpy.int64, numpy.float64)
for t in trytypes:
try:
newd = d.astype(dtype=t)
except: #Failure to cast, try next type
continue
if (newd == d).all(): #Values preserved, use this type
d = newd
#Continue with normal guessing, as if a list
break
else:
#fell through without a match
raise ValueError(
'Cannot convert generic objects to CDF type.')
if d.dtype.kind in ('i', 'u'): #integer
minval = numpy.min(d)
maxval = numpy.max(d)
if minval < 0:
types = [const.CDF_BYTE, const.CDF_INT1,
const.CDF_INT2, const.CDF_INT4, const.CDF_INT8,
const.CDF_FLOAT, const.CDF_REAL4,
const.CDF_DOUBLE, const.CDF_REAL8]
cutoffs = [2 ** 7, 2 ** 7, 2 ** 15, 2 ** 31, 2 ** 63,
1.7e38, 1.7e38, 8e307, 8e307]
else:
types = [const.CDF_BYTE, const.CDF_INT1, const.CDF_UINT1,
const.CDF_INT2, const.CDF_UINT2,
const.CDF_INT4, const.CDF_UINT4,
const.CDF_INT8,
const.CDF_FLOAT, const.CDF_REAL4,
const.CDF_DOUBLE, const.CDF_REAL8]
cutoffs = [2 ** 7, 2 ** 7, 2 ** 8,
2 ** 15, 2 ** 16, 2 ** 31, 2 ** 32, 2 ** 63,
1.7e38, 1.7e38, 8e307, 8e307]
types = [t for (t, c) in zip(types, cutoffs) if c > maxval
and (minval >= 0 or minval >= -c)]
if (not lib.supports_int8 or backward) \
and const.CDF_INT8 in types:
del types[types.index(const.CDF_INT8)]
else: #float
if dims is ():
if d != 0 and (abs(d) > 1.7e38 or abs(d) < 3e-39):
types = [const.CDF_DOUBLE, const.CDF_REAL8]
else:
types = [const.CDF_FLOAT, const.CDF_REAL4,
const.CDF_DOUBLE, const.CDF_REAL8]
else:
absolutes = numpy.abs(d[d != 0])
if len(absolutes) > 0 and \
(numpy.max(absolutes) > 1.7e38 or
numpy.min(absolutes) < 3e-39):
types = [const.CDF_DOUBLE, const.CDF_REAL8]
else:
types = [const.CDF_FLOAT, const.CDF_REAL4,
const.CDF_DOUBLE, const.CDF_REAL8]
types = [t.value if hasattr(t, 'value') else t for t in types]
return (dims, types, elements)
@staticmethod
def reorder(seq):
"""Reorders seq to switch array majority
Used to take an array of subscripts between row
and column majority. First element is not touched,
being the record number.
@param seq: a sequence of *subscripts*
@type seq: sequence of integers
@return: seq with all but element 0 reversed in order
@rtype: sequence of integers
"""
return numpy.concatenate((seq[0:1],
numpy.flipud(seq)[:-1]))
@staticmethod
def convert_range(start, stop, step, size):
"""Converts a start/stop/step range to start/count/interval
(i.e. changes from Python-style slice to CDF-style)
@param start: index to start a slice at, may be none or negative
@type start: int
@param stop: index at end of slice (one-past, standard Python),
may be none or negative
@type stop: int
@param step: interval for stepping through stlice
@type step: int
@param size: size of list to slice
@type size: int
@return: (start, count, interval, rev) where:
1. start is the start index, normalized to be within
the size of the list and negatives handled
2. count is the number of records in the slice,
guaranteed to stop before the end
3. interval is the skip between records
4. rev indicates whether the sequence should be reversed
@rtype: (int, int, int, boolean)
"""
(start, stop, step) = slice(start, stop, step).indices(size)
if step < 0:
step *= -1
count = int((start - stop + step - 1) / step)
start = start - (count - 1) * step
rev = True
else:
count = int((stop - start + step - 1) / step)
rev = False
if count < 0:
count = 0
start = 0
return (start, count, step, rev)
class Attr(MutableSequence):
"""An attribute, g or z, for a CDF
.. warning::
This class should not be used directly, but only in its
subclasses, :class:`gAttr` and :class:`zAttr`. The methods
listed here are safe to use in the subclasses.
Represents a CDF attribute, providing access to the Entries in a format
that looks like a Python
list. General list information is available in the python docs:
`1 <http://docs.python.org/tutorial/introduction.html#lists>`_,
`2 <http://docs.python.org/tutorial/datastructures.html#more-on-lists>`_,
`3 <http://docs.python.org/library/stdtypes.html#typesseq>`_.
An introduction to CDF attributes can be found in section 2.4 of
the CDF user's guide.
Each element of the list is a single Entry of the appropriate type.
The index to the elements is the Entry number.
Multi-dimensional slicing is *not* supported; an Entry with multiple
elements will have all elements returned (and can thus be sliced itself).
Example:
>>> first_three = attribute[5, 0:3] #will fail
>>> first_three = attribute[5][0:3] #first three elements of 5th Entry
.. autosummary::
~Attr.append
~Attr.has_entry
~Attr.insert
~Attr.max_idx
~Attr.new
~Attr.number
~Attr.rename
~Attr.type
.. automethod:: append
.. automethod:: has_entry
.. automethod:: insert
.. automethod:: max_idx
.. automethod:: new
.. automethod:: number
.. automethod:: rename
.. automethod:: type
"""
def __init__(self, cdf_file, attr_name, create=False):
"""Initialize this attribute
@param cdf_file: CDF file containing this attribute
@type cdf_file: :py:class:`pycdf.CDF`
@param attr_name: Name of this attribute
@type attr_name: str
@param create: True to create attribute, False to look up existing.
@type create: bool
"""
self._cdf_file = cdf_file
self._raw = False
if isinstance(attr_name, str_classes):
try:
self._name = attr_name.encode('ascii')
except AttributeError:
self._name = attr_name
attrno = ctypes.c_long()
if create:
self._cdf_file._call(const.CREATE_, const.ATTR_,
self._name, self.SCOPE,
ctypes.byref(attrno))
self._cdf_file.add_attr_to_cache(
self._name, attrno.value, self.SCOPE == const.GLOBAL_SCOPE)
else: #Ensure exists, and populate cache. See scope note below
attrno, scope = self._cdf_file.attr_num(self._name)
else:
name = ctypes.create_string_buffer(const.CDF_ATTR_NAME_LEN256 + 1)
scope = ctypes.c_long(0)
self._cdf_file._call(const.SELECT_, const.ATTR_,
ctypes.c_long(attr_name))
#Because it's possible to create a gAttr Python objecting
#referencing an Attribute with variable scope, and vice-versa,
#do NOT assume the scope matches
#(Higher level code checks for that being a bad thing.)
self._cdf_file._call(
const.GET_, const.ATTR_NAME_, name,
const.GET_, const.ATTR_SCOPE_, ctypes.byref(scope))
self._name = name.value.rstrip()
if scope.value == const.GLOBAL_SCOPE.value:
scope = True
elif scope.value == const.VARIABLE_SCOPE.value:
scope = False
else:
raise CDFError(const.BAD_SCOPE)
self._cdf_file.add_attr_to_cache(self._name, attr_name, scope)
def __getitem__(self, key):
"""Return a slice of Entries.
Because Attributes may be sparse, a multi-element slice will return
None for those elements which do not have associated Entries.
@param key: index or range of Entry number to return
@type key: slice or int
@return: a list of entries, appropriate type.
@raise IndexError: if L{key} is an int and that Entry number does not
exist.
"""
if key is Ellipsis:
key = slice(None, None, None)
if hasattr(key, 'indices'):
idx = range(*key.indices(self.max_idx() + 1))
return [self._get_entry(i) if self.has_entry(i) else None
for i in idx]
else:
if self.has_entry(key):
return self._get_entry(key)
else:
raise IndexError('list index ' + str(key) + ' out of range.')
def _check_other_entries(self, types):
"""Try to get the type of this entry from others in the Attribute
For zAttrs, checks if all other Entries are the same type, and at
least one doesn't match its zVar, i.e. Entry type dominates (otherwise
assumption is the Var type dominates).
For gAttrs, checks all other Entries, and gives priority to the
one that's earliest in the possible type list and exists in other
Entries.
This is only one component of Entry type guessing!
:param list types: CDF types that are candidates (match the data)
:return: The type discerned from other Entries, or None
"""
if self.ENTRY_ == const.zENTRY_:
#If everything else is the same entry type,
#and one is not the same as its var, probably
#all entries should be of that type
cand_et = None #The Entry type that might work
one_var_diff = False #One Var has a type different from Entry
for num in range(self.max_idx() + 1):
if not self.has_entry(num):
continue
vartype = self._cdf_file[num].type()
entrytype = self.type(num)
if vartype != entrytype:
one_var_diff = True
if cand_et is None:
if not entrytype in types:
return None #One var has Entry with "impossible" type
cand_et = entrytype
elif cand_et != entrytype:
return None #Two vars have Entries with different types
if one_var_diff and cand_et is not None:
return cand_et
else:
# Of those types which exist in other entries,
# find the one which is earliest
# in types, i.e. the preferred type
entrytypes = [self.type(num) for num in
range(self.max_idx() + 1)
if self.has_entry(num)]
entrytypes = [et for et in entrytypes if et in types]
if entrytypes:
return types[
min([types.index(et) for et in entrytypes])]
return None
def __setitem__(self, key, data):
"""Set a slice of Entries.
@param key: index or range of Entry numbers to set
@type key: slice or int
@param data: the data to set these entries to. Normally each entry should
be a sequence; if a scalar is provided, it is treated
as a single-element list.
@type data: scalar or list
@raise ValueError: if size of {data} does not match size of L{key}
@note: Attributes do not 'grow' or 'shrink' as entries are added
or removed. Indexes of entries never change and there is no
way to 'insert'.
"""
if key is Ellipsis:
key = slice(None, None, None)
if not hasattr(key, 'indices'):
#Single value, promote everything a dimension
idx = (key, key + 1, 1)
data = [data]
else:
idx = key.indices(self.max_idx() + 1)
if key.step is None or key.step > 0:
#Iterating forward, extend slice to match data
if len(data) > len(range(*idx)):
idx = (idx[0], idx[0] + idx[2] * len(data), idx[2])
#get, and check, types and sizes for all data
#checks first so don't have error after changing half the Entries
data_idx = -1
typelist = []
for i in range(*idx):
data_idx += 1
if data_idx >= len(data):
continue
datum = data[data_idx]
if datum is None:
typelist[i] = (None, None, None)
continue
(dims, types, elements) = _Hyperslice.types(
datum, backward=self._cdf_file.backward)
if len(types) <= 0:
raise ValueError('Cannot find a matching CDF type.')
if len(dims) > 1:
raise ValueError('Entries must be scalar or 1D.')
elif len(dims) == 1 and isinstance(datum[0], str_classes):
raise ValueError('Entry strings must be scalar.')
entry_type = None
if self.has_entry(i): #If the entry already exists, match its type
entry_type = self.type(i)
if not entry_type in types:
entry_type = None
if entry_type is None: #Check other entries for this attribute
entry_type = self._check_other_entries(types)
if entry_type is None and self.ENTRY_ == const.zENTRY_:
#Fall back to zVar type
vartype = self._cdf_file[i].type()
if vartype in types:
entry_type = vartype
else:
entry_type = types[0]
elif entry_type is None:
entry_type = types[0]
if not entry_type in lib.numpytypedict:
raise ValueError('Cannot find a matching numpy type.')
typelist.append((dims, entry_type, elements))
data_idx = -1
for i in range(*idx):
data_idx += 1
if data_idx >= len(data) or data[data_idx] is None:
if self.has_entry(i):
del self[i]
continue
datum = data[data_idx]
(dims, entry_type, elements) = typelist[data_idx]
self._write_entry(i, datum, entry_type, dims, elements)
def __delitem__(self, key):
"""Delete a slice of Entries.
@param key: index or range of Entry numbers to delete
@type key: slice or int
@note: Attributes do not 'grow' or 'shrink' as entries are added
or removed. Indexes of entries never change and there is no
way to 'insert'.
"""
if key is Ellipsis:
key = slice(None, None, None)
if not hasattr(key, 'indices'):
idx = (key, key + 1, 1)
else:
idx = key.indices(self.max_idx() + 1)
for i in range(*idx):
self._call(const.SELECT_, self.ENTRY_, ctypes.c_long(i),
const.DELETE_, self.ENTRY_)
def __iter__(self, current=0):
"""Iterates over all entries in this Attribute
Returns data from one entry at a time until reaches the end.
@note: Returned in entry-number order.
"""
while current <= self.max_idx():
if self.has_entry(current):
value = yield(self._get_entry(current))
if value != None:
current = value
current += 1
def __reversed__(self, current=None):
"""Iterates over all entries in this Attribute
Returns data from one entry at a time, starting at end and going
to beginning.
@note: Returned in entry-number order.
"""
if current is None:
current = self.max_idx()
while current >= 0:
if self.has_entry(current):
value = yield(self._get_entry(current))
if value != None:
current = value
current -= 1
def __len__(self):
"""Number of Entries for this Attr. NOT same as max Entry number.
@return: Number of Entries
@rtype: int
"""
count = ctypes.c_long(0)
self._call(const.GET_, self.ATTR_NUMENTRIES_, ctypes.byref(count))
return count.value
def __repr__(self):
"""Returns representation of an attribute
Cannot return anything that can be eval'd to create a copy of the
attribtute, so just wrap the informal representation in angle brackets.
@return: all the data in this attribute
@rtype: str
"""
return '<\n' + str(self) + '\n>'
def __str__(self):
"""Returns a string representation of the attribute
This is an 'informal' representation in that it cannot be evaluated
directly to create an L{Attr}.
@return: all the data in this attribute
@rtype: str
"""
if self._cdf_file._opened:
return '\n'.join([str(item) for item in self])
else:
if isinstance(self._name, str):
return 'Attribute "{0}" in closed CDF {1}'.format(
self._name, self._cdf_file.pathname)
else:
return 'Attribute "{0}" in closed CDF {1}'.format(
self._name.decode('ascii'),
self._cdf_file.pathname.decode('ascii'))
def insert(self, index, data):
"""Insert an entry at a particular number
Inserts entry at particular number while moving all subsequent
entries to one entry number later. Does not close gaps.
Parameters
==========
index : int
index where to put the new entry
data :
data for the new entry
"""
max_entry = self.max_idx()
if index > max_entry: #Easy case
self[index] = data
return
for i in range(max_entry, index - 1, -1):
if self.has_entry(i+1):
self.__delitem__(i+1)
if self.has_entry(i):
self.new(self.__getitem__(i), type=self.type(i), number=i+1)
self[index] = data
def append(self, data):
"""Add an entry to end of attribute
Puts entry after last defined entry (does not fill gaps)
Parameters
==========
data :
data for the new entry
"""
self[self.max_idx() + 1] = data
def _call(self, *args, **kwargs):
"""Select this CDF and Attr and call the CDF internal interface
@param args: Passed directly to the CDF library interface.
@type args: various, see :py:mod:`ctypes`.
@return: CDF status from the library
@rtype: ctypes.c_long
@note: Terminal NULL_ is automatically added to L{args}.
@raise CDFError: if CDF library reports an error
@raise CDFWarning: if CDF library reports a warning and interpreter
is set to error on warnings.
"""
return self._cdf_file._call(
const.SELECT_, const.ATTR_,
ctypes.c_long(self._cdf_file.attr_num(self._name)[0]),
*args, **kwargs)
def _entry_len(self, number):
"""Number of elements in an Entry
@param number: number of Entry
@type number: int
@return: number of elements
@rtype: int
"""
if not self.has_entry(number):
raise IndexError('list index ' + str(number) + ' out of range.')
count = ctypes.c_long(0)
self._call(
const.SELECT_, self.ENTRY_, ctypes.c_long(number),
const.GET_, self.ENTRY_NUMELEMS_, ctypes.byref(count))
return count.value
def type(self, number, new_type=None):
"""Find or change the CDF type of a particular Entry number
Parameters
==========
number : int
number of Entry to check or change
Other Parameters
================
new_type
type to change this Entry to, from :mod:`~pycdf.const`.
Omit to only check type.
Returns
=======
out : int
CDF variable type, see :mod:`~pycdf.const`
Notes
=====
If changing types, old and new must be equivalent, see CDF
User's Guide section 2.5.5 pg. 57
"""
if new_type != None:
if not hasattr(new_type, 'value'):
new_type = ctypes.c_long(new_type)
size = ctypes.c_long(self._entry_len(number))
status = self._call(const.SELECT_, self.ENTRY_, ctypes.c_long(number),
const.PUT_, self.ENTRY_DATASPEC_, new_type, size,
ignore=(const.NO_SUCH_ENTRY,))
if status == const.NO_SUCH_ENTRY:
raise IndexError('list index ' + str(number) + ' out of range.')
cdftype = ctypes.c_long(0)
status = self._call(const.SELECT_, self.ENTRY_, ctypes.c_long(number),
const.GET_, self.ENTRY_DATATYPE_, ctypes.byref(cdftype),
ignore=(const.NO_SUCH_ENTRY,))
if status == const.NO_SUCH_ENTRY:
raise IndexError('list index ' + str(number) + ' out of range.')
return cdftype.value
def has_entry(self, number):
"""Check if this attribute has a particular Entry number
Parameters
==========
number : int
number of Entry to check or change
Returns
=======
out : bool
True if ``number`` is a valid entry number; False if not
"""
status = self._call(const.CONFIRM_, self.ENTRY_EXISTENCE_,
ctypes.c_long(number),
ignore=(const.NO_SUCH_ENTRY, ))
return not status == const.NO_SUCH_ENTRY
def max_idx(self):
"""Maximum index of Entries for this Attr
Returns
=======
out : int
maximum Entry number
"""
count = ctypes.c_long(0)
self._call(const.GET_, self.ATTR_MAXENTRY_, ctypes.byref(count))
return count.value
def new(self, data, type=None, number=None):
"""Create a new Entry in this Attribute
.. note:: If ``number`` is provided and an Entry with that number
already exists, it will be overwritten.
Parameters
==========
data
data to put in the Entry
Other Parameters
================
type : int
type of the new Entry, from :mod:`~pycdf.const`
(otherwise guessed from ``data``)
number : int
Entry number to write, default is lowest available number.
"""
if number is None:
number = 0
while self.has_entry(number):
number += 1
(dims, types, elements) = _Hyperslice.types(
data, backward=self._cdf_file.backward)
if type is None:
#Guess based on other entries
type = self._check_other_entries(types)
if type is None and self.ENTRY_ == const.zENTRY_:
#Try to match variable type
vartype = self._cdf_file[number].type()
if vartype in types:
type = vartype
if type is None:
type = types[0]
elif hasattr(type, 'value'):
type = type.value
self._write_entry(number, data, type, dims, elements)
def number(self):
"""Find the attribute number for this attribute
Returns
=======
out : int
attribute number
"""
no = ctypes.c_long(0)
self._cdf_file._call(const.GET_, const.ATTR_NUMBER_,
self._name, ctypes.byref(no))
return no.value
def global_scope(self):
"""Determine scope of this attribute.
Returns
=======
out : bool
True if global (i.e. gAttr), False if zAttr
"""
return self._cdf_file.attr_num(self._name)[1]
def rename(self, new_name):
"""Rename this attribute
Renaming a zAttribute renames it for *all* zVariables in this CDF!
Parameters
==========
new_name : str
the new name of the attribute
"""
try:
enc_name = new_name.encode('ascii')
except AttributeError:
enc_name = new_name
if len(enc_name) > const.CDF_ATTR_NAME_LEN256:
raise CDFError(const.BAD_ATTR_NAME)
self._call(const.PUT_, const.ATTR_NAME_, enc_name)
self._cdf_file.add_attr_to_cache(
enc_name,
*self._cdf_file.attr_num(self._name)) #still in cache
del self._cdf_file._attr_info[self._name]
self._name = enc_name
def _get_entry(self, number):
"""Read an Entry associated with this L{Attr}
@param number: number of Entry to return
@type number: int
@return: data from entry numbered L{number}
@rtype: list or str
"""
if not self.has_entry(number):
raise IndexError('list index ' + str(number) + ' out of range.')
#Make a big enough buffer
length = self._entry_len(number)
cdftype = self.type(number)
if cdftype in (const.CDF_CHAR.value, const.CDF_UCHAR.value):
buff = numpy.empty((), 'S{0}'.format(length), order='C')
else:
if not cdftype in lib.numpytypedict:
raise CDFError(const.BAD_DATA_TYPE)
buff = numpy.empty((length,), lib.numpytypedict[cdftype],
order='C')
buff = numpy.require(buff, requirements=('C', 'A', 'W'))
self._call(const.SELECT_, self.ENTRY_, ctypes.c_long(number),
const.GET_, self.ENTRY_DATA_,
buff.ctypes.data_as(ctypes.c_void_p))
#decode
if cdftype in (const.CDF_CHAR.value, const.CDF_UCHAR.value):
if str == bytes or self._raw: #Py2k, leave as bytes
result = bytes(buff)
else: #Py3k, make unicode
result = str(numpy.char.array(buff).decode())
else:
if not self._raw:
if cdftype == const.CDF_EPOCH.value:
result = lib.v_epoch_to_datetime(buff)
elif cdftype == const.CDF_EPOCH16.value:
result = lib.v_epoch16_to_datetime(buff)
elif cdftype == const.CDF_TIME_TT2000.value:
result = lib.v_tt2000_to_datetime(buff)
else:
result = buff
else:
result = buff
if length == 1:
result = result[0]
return result
def _write_entry(self, number, data, cdf_type, dims, elements):
"""Write an Entry to this Attr.
@param number: number of Entry to write
@type number: int
@param data: data to write
@param cdf_type: the CDF type to write, from :py:mod:`pycdf.const`
@param dims: dimensions of L{data}
@type dims: list
@param elements: number of elements in L{data}, 1 unless it is a string
@type elements: int
"""
if len(dims) == 0:
n_write = 1
else:
n_write = dims[0]
if cdf_type in (const.CDF_CHAR.value, const.CDF_UCHAR.value):
data = numpy.require(data, requirements=('C', 'A', 'W'),
dtype=numpy.dtype('S' + str(elements)))
n_write = elements
elif cdf_type == const.CDF_EPOCH16.value:
if not self._raw:
try:
data = lib.v_datetime_to_epoch16(data)
except AttributeError:
pass
data = numpy.require(data, requirements=('C', 'A', 'W'),
dtype=numpy.float64)
elif cdf_type == const.CDF_EPOCH.value:
if not self._raw:
try:
data = lib.v_datetime_to_epoch(data),
except AttributeError:
pass
data = numpy.require(data, requirements=('C', 'A', 'W'),
dtype=numpy.float64)
elif cdf_type == const.CDF_TIME_TT2000.value:
if not self._raw:
try:
data = lib.v_datetime_to_tt2000(data)
except AttributeError:
pass
data = numpy.require(data, requirements=('C', 'A', 'W'),
dtype=numpy.int64)
elif cdf_type in lib.numpytypedict:
data = numpy.require(data, requirements=('C', 'A', 'W'),
dtype=lib.numpytypedict[cdf_type])
else:
raise CDFError(const.BAD_DATA_TYPE)
self._call(const.SELECT_, self.ENTRY_, ctypes.c_long(number),
const.PUT_, self.ENTRY_DATA_, ctypes.c_long(cdf_type),
ctypes.c_long(n_write),
data.ctypes.data_as(ctypes.c_void_p))
def _delete(self):
"""Delete this Attribute
Also deletes all Entries associated with it.
"""
self._call(const.DELETE_, const.ATTR_)
self._cdf_file.clear_attr_from_cache(self._name)
self._name = None
class zAttr(Attr):
"""zAttribute for zVariables within a CDF.
.. warning::
Because zAttributes are shared across all variables in a CDF,
directly manipulating them may have unexpected consequences.
It is safest to operate on zEntries via :class:`zAttrList`.
.. note::
When accessing a zAttr, pyCDF exposes only the zEntry corresponding
to the associated zVariable.
See Also
========
:class:`Attr`
"""
ENTRY_ = const.zENTRY_
ENTRY_DATA_ = const.zENTRY_DATA_
SCOPE = const.VARIABLE_SCOPE
ENTRY_EXISTENCE_ = const.zENTRY_EXISTENCE_
ATTR_NUMENTRIES_ = const.ATTR_NUMzENTRIES_
ATTR_MAXENTRY_ = const.ATTR_MAXzENTRY_
ENTRY_NUMELEMS_ = const.zENTRY_NUMELEMS_
ENTRY_DATATYPE_ = const.zENTRY_DATATYPE_
ENTRY_DATASPEC_ = const.zENTRY_DATASPEC_
def insert(self, index, data):
"""Insert entry at particular index number
Since there can only be one zEntry per zAttr, this cannot be
implemented.
Raises
======
NotImplementedError : always
"""
raise NotImplementedError
def append(self, index, data):
"""Add entry to end of attribute list
Since there can only be one zEntry per zAttr, this cannot be
implemented.
Raises
======
NotImplementedError : always
"""
raise NotImplementedError
class gAttr(Attr):
"""Global Attribute for a CDF
Represents a CDF attribute, providing access to the gEntries in a format
that looks like a Python list. General list information is available in
the python docs:
`1 <http://docs.python.org/tutorial/introduction.html#lists>`_,
`2 <http://docs.python.org/tutorial/datastructures.html#more-on-lists>`_,
`3 <http://docs.python.org/library/stdtypes.html#typesseq>`_.
Normally accessed by providing a key to a :class:`gAttrList`:
>>> attribute = cdffile.attrs['attribute_name']
>>> first_gentry = attribute[0]
Each element of the list is a single gEntry of the appropriate type.
The index to the elements is the gEntry number.
A gEntry may be either a single string or a 1D array of numerical type.
Entries of numerical type (everything but CDF_CHAR and CDF_UCHAR)
with a single element are returned as scalars; multiple-element entries
are returned as a list. No provision is made for accessing below
the entry level; the whole list is returned at once (but Python's
slicing syntax can be used to extract individual items from that list.)
Multi-dimensional slicing is *not* supported; an entry with multiple
elements will have all elements returned (and can thus be sliced itself).
Example:
>>> first_three = attribute[5, 0:3] #will fail
>>> first_three = attribute[5][0:3] #first three elements of 5th Entry
gEntries are *not* necessarily contiguous; a gAttribute may have an
entry 0 and entry 2 without an entry 1. :meth:`~Attr.len` will return the
*number* of gEntries; use :meth:`~Attr.max_idx` to find the highest defined
gEntry number and :meth:`~Attr.has_entry` to determine if a particular
gEntry number exists. Iterating over all entries is also supported::
>>> entrylist = [entry for entry in attribute]
Deleting gEntries will leave a "hole":
>>> attribute[0:3] = [1, 2, 3]
>>> del attribute[1]
>>> attribute.has_entry(1)
False
>>> attribute.has_entry(2)
True
>>> print attribute[0:3]
[1, None, 3]
Multi-element slices over nonexistent gEntries will return ``None`` where
no entry exists. Single-element indices for nonexistent gEntries will
raise ``IndexError``. Assigning ``None`` to a gEntry will delete it.
When assigning to a gEntry, the type is chosen to match the data;
subject to that constraint, it will try to match
(in order):
#. existing gEntry of the same number in this gAttribute
#. other gEntries in this gAttribute
#. data-matching constraints described in :meth:`CDF.new`.
See Also
========
:class:`Attr`
"""
ENTRY_ = const.gENTRY_
ENTRY_DATA_ = const.gENTRY_DATA_
SCOPE = const.GLOBAL_SCOPE
ENTRY_EXISTENCE_ = const.gENTRY_EXISTENCE_
ATTR_NUMENTRIES_ = const.ATTR_NUMgENTRIES_
ATTR_MAXENTRY_ = const.ATTR_MAXgENTRY_
ENTRY_NUMELEMS_ = const.gENTRY_NUMELEMS_
ENTRY_DATATYPE_ = const.gENTRY_DATATYPE_
ENTRY_DATASPEC_ = const.gENTRY_DATASPEC_
class AttrList(MutableMapping):
"""Object representing a list of attributes.
.. warning::
This class should not be used directly, but only via its
subclasses, :class:`gAttrList` and :class:`zAttrList`.
Methods listed here are safe to use from the subclasses.
.. autosummary::
~AttrList.clone
~AttrList.copy
~AttrList.from_dict
~AttrList.new
~AttrList.rename
.. automethod:: clone
.. automethod:: copy
.. automethod:: from_dict
.. automethod:: new
.. automethod:: rename
"""
def __init__(self, cdf_file, special_entry=None):
"""Initialize the attribute collection
@param cdf_file: CDF these attributes are in
@type cdf_file: :py:class:`pycdf.CDF`
@param special_entry: callable which returns a "special" entry number,
used to limit results for zAttrs to those which match the zVar
(i.e. the var number)
@type special_entry: callable
"""
self._cdf_file = cdf_file
self.special_entry = special_entry
def __getitem__(self, name):
"""Find an Attribute by name
@param name: name of the Attribute to return
@type name: str
@return: attribute named L{name}
@rtype: L{Attr}
@raise KeyError: if there is no attribute named L{name}
@raise CDFError: other errors in CDF library
"""
try:
attrib = self.AttrType(self._cdf_file, name)
except CDFError:
(t, v, tb) = sys.exc_info()
if v.status == const.NO_SUCH_ATTR:
raise KeyError(name + ': ' + str(v))
else:
raise
if attrib.global_scope() != self.global_scope:
raise KeyError(name + ': no ' + self.attr_name + ' by that name.')
return attrib
def __setitem__(self, name, data):
"""Create an Attribute or change its entries
@param name: name of Attribute to change
@type name: str
@param data: Entries to populate this Attribute with.
Any existing Entries will be deleted!
Another C{Attr} may be specified, in which
case all its entries are copied.
@type data: scalar, list, or L{Attr}
"""
if isinstance(data, AttrList):
if name in self:
del self[name]
attr = self._get_or_create(name)
for entryno in range(data.max_idx()):
if data.has_entry(entryno):
attr.new(data[entryno], data.type(entryno), entryno)
else:
attr = self._get_or_create(name)
if isinstance(data, str_classes):
data = [data]
else:
try:
junk = len(data)
except TypeError:
data = [data]
attr[:] = data
del attr[len(data):]
def __delitem__(self, name):
"""Delete an Attribute (and all its entries)
@param name: name of Attribute to delete
@type name: str
"""
try:
attr = self.AttrType(self._cdf_file, name)
except CDFError:
(t, v, tb) = sys.exc_info()
if v.status == const.NO_SUCH_ATTR:
raise KeyError(name + ': ' + str(v))
else:
raise
if attr.global_scope() != self.global_scope:
raise KeyError(name + ': not ' + self.attr_name)
attr._delete()
def __iter__(self, current=0):
"""Iterates over all Attr in this CDF or variable
Returns name of one L{Attr} at a time until reaches the end.
@note: Returned in number order.
"""
count = ctypes.c_long(0)
self._cdf_file._call(const.GET_, const.CDF_NUMATTRS_,
ctypes.byref(count))
while current < count.value:
candidate = self.AttrType(self._cdf_file, current)
if candidate.global_scope() == self.global_scope:
if self.special_entry is None or \
candidate.has_entry(self.special_entry()):
if str == bytes:
value = yield(candidate._name)
else:
value = yield(candidate._name.decode())
if value != None:
current = self[value].number()
current += 1
def __repr__(self):
"""Returns representation of attribute list
Cannot return anything that can be eval'd to create a copy of the
list, so just wrap the informal representation in angle brackets.
@return: all the data in this list of attributes
@rtype: str
"""
return '<' + self.__class__.__name__ + ':\n' + str(self) + '\n>'
def __str__(self):
"""Returns a string representation of the attribute list
This is an 'informal' representation in that it cannot be evaluated
directly to create an L{AttrList}.
@return: all the data in this list of attributes
@rtype: str
"""
if self._cdf_file._opened:
return '\n'.join([key + ': ' + (
('\n' + ' ' * (len(key) + 2)).join(
[str(value[i]) + ' [' + lib.cdftypenames[value.type(i)] + ']'
for i in range(value.max_idx() + 1) if value.has_entry(i)])
if isinstance(value, Attr)
else str(value) +
' [' + lib.cdftypenames[self.type(key)] + ']'
)
for (key, value) in sorted(self.items())])
else:
if isinstance(self._cdf_file.pathname, str):
return 'Attribute list in closed CDF {0}'.format(
self._cdf_file.pathname)
else:
return 'Attribute list in closed CDF {0}'.format(
self._cdf_file.pathname.decode('ascii'))
def clone(self, master, name=None, new_name=None):
"""
Clones another attribute list, or one attribute from it, into this
list.
Parameters
==========
master : AttrList
the attribute list to copy from. This can be any dict-like object.
Other Parameters
================
name : str (optional)
name of attribute to clone (default: clone entire list)
new_name : str (optional)
name of the new attribute, default ``name``
"""
if name is None:
self._clone_list(master)
else:
self._clone_attr(master, name, new_name)
def copy(self):
"""
Create a copy of this attribute list
Returns
=======
out : dict
copy of the entries for all attributes in this list
"""
return dict((key, value[:] if isinstance(value, Attr) else value)
for (key, value) in self.items())
def new(self, name, data=None, type=None):
"""
Create a new Attr in this AttrList
Parameters
==========
name : str
name of the new Attribute
Other Parameters
================
data
data to put into the first entry in the new Attribute
type
CDF type of the first entry from :mod:`~pycdf.const`.
Only used if data are specified.
Raises
======
KeyError : if the name already exists in this list
"""
if name in self:
raise KeyError(name + ' already exists.')
#A zAttr without an Entry in this zVar will be a "get" not "create"
attr = self._get_or_create(name)
if data is not None:
if self.special_entry is None:
attr.new(data, type)
else:
attr.new(data, type, self.special_entry())
def rename(self, old_name, new_name):
"""
Rename an attribute in this list
Renaming a zAttribute renames it for *all* zVariables in this CDF!
Parameters
==========
old_name : str
the current name of the attribute
new_name : str
the new name of the attribute
"""
AttrList.__getitem__(self, old_name).rename(new_name)
def from_dict(self, in_dict):
"""
Fill this list of attributes from a dictionary
.. deprecated:: 0.1.5
Use :meth:`~pycdf.AttrList.clone` instead; it supports
cloning from dictionaries.
Parameters
==========
in_dict : dict
Attribute list is populated entirely from this dictionary;
all existing attributes are deleted.
"""
warnings.warn("from_dict is deprecated and will be removed. Use clone.",
DeprecationWarning)
for k in in_dict:
self[k] = in_dict[k]
for k in list(self):
if not k in in_dict:
del self[k]
def _clone_attr(self, master, name, new_name=None):
"""Clones a single attribute from one in this list or another
Copies data and types from the master attribute to the new one
@param master: attribute list to copy attribute from
@type master: L{AttrList}
@param name: name of attribute to copy
@type name: str
@param new_name: name of the new attribute, default L{name}
@type new_name: str
"""
if new_name is None:
new_name = name
self[new_name] = master[name]
def _clone_list(self, master):
"""Clones this attribute list from another
@param master: the attribute list to copy from
@type master: L{AttrList}
"""
for name in master:
self._clone_attr(master, name)
for name in list(self): #Can't iterate over a list we're changing
if not name in master:
del self[name]
def _get_or_create(self, name):
"""Retrieve L{Attr} or create it if it doesn't exist
@param name: name of the attribute to look up or create
@type name: str
@return: attribute with this name
@rtype: L{Attr}
"""
attr = None
try:
attr = self.AttrType(self._cdf_file, name)
except CDFError:
(t, v, tb) = sys.exc_info()
if v.status != const.NO_SUCH_ATTR:
raise
if attr is None:
attr = self.AttrType(self._cdf_file, name, True)
elif attr.global_scope() != self.global_scope:
raise KeyError(name + ': not ' + self.attr_name)
return attr
class gAttrList(AttrList):
"""
Object representing *all* the gAttributes in a CDF.
Normally accessed as an attribute of an open :class:`CDF`:
>>> global_attribs = cdffile.attrs
Appears as a dictionary: keys are attribute names; each value is an
attribute represented by a :class:`gAttr` object. To access the global
attribute TEXT:
>>> text_attr = cdffile.attrs['TEXT']
See Also
========
:class:`AttrList`
"""
AttrType = gAttr
attr_name = 'gAttribute'
global_scope = True
def __len__(self):
"""
Number of gAttributes in this CDF
Returns
=======
out : int
number of gAttributes in the CDF
"""
count = ctypes.c_long(0)
self._cdf_file._call(const.GET_, const.CDF_NUMgATTRS_,
ctypes.byref(count))
return count.value
class zAttrList(AttrList):
"""Object representing *all* the zAttributes in a zVariable.
Normally accessed as an attribute of a :class:`Var` in an open
CDF:
>>> epoch_attribs = cdffile['Epoch'].attrs
Appears as a dictionary: keys are attribute names, values are
the value of the zEntry associated with the appropriate zVariable.
Each vAttribute in a CDF may only have a *single* entry associated
with each variable. The entry may be a string, a single numerical value,
or a series of numerical values. Entries with multiple values are returned
as an entire list; direct access to the individual elements is not
possible.
Example: finding the first dependency of (ISTP-compliant) variable
``Flux``:
>>> print cdffile['Flux'].attrs['DEPEND_0']
zAttributes are shared among zVariables, one zEntry allowed per zVariable.
(pyCDF hides this detail.) Deleting the last zEntry for a zAttribute will
delete the underlying zAttribute.
zEntries are created and destroyed by the usual dict methods on the
zAttrlist:
>>> epoch_attribs['new_entry'] = [1, 2, 4] #assign a list to new zEntry
>>> del epoch_attribs['new_entry'] #delete the zEntry
The type of the zEntry is guessed from data provided. The type is chosen to
match the data; subject to that constraint, it will try to match
(in order):
#. existing zEntry corresponding to this zVar
#. other zEntries in this zAttribute
#. the type of this zVar
#. data-matching constraints described in :py:meth:`CDF.new`
See Also
========
:class:`AttrList`
"""
AttrType = zAttr
attr_name = 'zAttribute'
global_scope = False
def __init__(self, zvar):
"""Initialize the attribute collection
@param zvar: zVariable these attributes are in
@param zvar: :py:class:`pycdf.Var`
"""
super(zAttrList, self).__init__(zvar.cdf_file, zvar._num)
self._zvar = zvar
def __getitem__(self, name):
"""Find an zEntry by name
@param name: name of the zAttribute to return
@type name: str
@return: attribute named L{name}
@rtype: L{zAttr}
@raise KeyError: if there is no attribute named L{name} associated
with this zVariable
@raise CDFError: other errors in CDF library
"""
attrib = super(zAttrList, self).__getitem__(name)
zvar_num = self._zvar._num()
if attrib.has_entry(zvar_num):
attrib._raw = self._zvar._raw
return attrib[zvar_num]
else:
raise KeyError(name + ': no such attribute for variable ' +
self._zvar.name())
def __delitem__(self, name):
"""Delete an zEntry by name
@param name: name of the zEntry to delete
@type name: str
@raise KeyError: if there is no attribute named L{name} associated
with this zVariable
@raise CDFError: other errors in CDF library
@note: If this is the only remaining entry, the Attribute will be
deleted.
"""
attrib = super(zAttrList, self).__getitem__(name)
zvar_num = self._zvar._num()
if not attrib.has_entry(zvar_num):
raise KeyError(str(name) + ': no such attribute for variable ' +
str(self._zvar._name))
del attrib[zvar_num]
if len(attrib) == 0:
attrib._delete()
def __setitem__(self, name, data):
"""Sets a zEntry by name
The type of the zEntry is guessed from L{data}. The type is chosen to
match the data; subject to that constraint, it will try to match
(in order):
1. existing zEntry corresponding to this zVar
2. other zEntries in this zAttribute
3. the type of this zVar
4. data-matching constraints described in L{_Hyperslice.types}
@param name: name of zAttribute; zEntry for this zVariable will be set
in zAttribute by this name
@type name: str
@raise CDFError: errors in CDF library
@raise ValueError: if unable to find a valid CDF type matching L{data},
or if L{data} is the wrong dimensions.
"""
try:
attr = super(zAttrList, self).__getitem__(name)
except KeyError:
attr = zAttr(self._cdf_file, name, True)
attr._raw = self._zvar._raw
attr[self._zvar._num()] = data
def __len__(self):
"""Number of zAttributes in this variable
@return: number of zAttributes in the CDF
which have entries for this variable.
@rtype: int
"""
length = 0
count = ctypes.c_long(0)
self._cdf_file._call(const.GET_, const.CDF_NUMATTRS_,
ctypes.byref(count))
current = 0
while current < count.value:
candidate = zAttr(self._cdf_file, current)
if not candidate.global_scope():
if candidate.has_entry(self._zvar._num()):
length += 1
current += 1
return length
def type(self, name, new_type=None):
"""Find or change the CDF type of a zEntry in this zVar
@param name: name of the zAttr to check or change
@type name: str
@param new_type: type to change it to, see :py:mod:`pycdf.const`
@type new_type: ctypes.c_long
@return: CDF variable type, see :py:mod:`pycdf.const`
@rtype: int
@note: If changing types, old and new must be equivalent, see CDF
User's Guide section 2.5.5 pg. 57
"""
attrib = super(zAttrList, self).__getitem__(name)
zvar_num = self._zvar._num()
if not attrib.has_entry(zvar_num):
raise KeyError(name + ': no such attribute for variable ' +
self._zvar.name())
return attrib.type(zvar_num, new_type)
def _clone_attr(self, master, name, new_name=None):
"""Clones a single attribute from one in this list or another
Copies data and types from the master attribute to the new one
@param master: attribute list to copy attribute from
@type master: L{zAttrList}
@param name: name of attribute to copy
@type name: str
@param new_name: name of the new attribute, default L{name}
@type new_name: str
"""
if new_name is None:
new_name = name
if new_name in self:
del self[new_name]
self.new(new_name, master[name],
master.type(name) if hasattr(master, 'type') else None)
| 37.378262 | 118 | 0.572838 | [
"Unlicense"
] | cpiker/condaCDF | pycdf/__init__.py | 199,114 | Python |
# -*- coding: utf-8 -*- #
# Copyright 2016 Google LLC. 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.
"""Functions for creating GCE container (Docker) deployments."""
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
import itertools
import re
import enum
from googlecloudsdk.api_lib.compute import exceptions
from googlecloudsdk.api_lib.compute import metadata_utils
from googlecloudsdk.api_lib.compute.operations import poller
from googlecloudsdk.api_lib.util import waiter
from googlecloudsdk.calliope import exceptions as calliope_exceptions
from googlecloudsdk.core import yaml
from googlecloudsdk.core.util import files
from googlecloudsdk.core.util import times
import six
USER_INIT_TEMPLATE = """#cloud-config
runcmd:
- ['/usr/bin/kubelet',
'--allow-privileged=%s',
'--manifest-url=http://metadata.google.internal/computeMetadata/v1/instance/attributes/google-container-manifest',
'--manifest-url-header=Metadata-Flavor:Google',
'--config=/etc/kubernetes/manifests']
"""
MANIFEST_DISCLAIMER = """# DISCLAIMER:
# This container declaration format is not a public API and may change without
# notice. Please use gcloud command-line tool or Google Cloud Console to run
# Containers on Google Compute Engine.
"""
USER_DATA_KEY = 'user-data'
CONTAINER_MANIFEST_KEY = 'google-container-manifest'
GCE_CONTAINER_DECLARATION = 'gce-container-declaration'
STACKDRIVER_LOGGING_AGENT_CONFIGURATION = 'google-logging-enabled'
GKE_DOCKER = 'gci-ensure-gke-docker'
ALLOWED_PROTOCOLS = ['TCP', 'UDP']
# Prefix of all COS image major release names
COS_MAJOR_RELEASE_PREFIX = 'cos-stable-'
# Pin this version of gcloud to COS image major release version
COS_MAJOR_RELEASE = COS_MAJOR_RELEASE_PREFIX + '55'
COS_PROJECT = 'cos-cloud'
_MIN_PREFERRED_COS_VERSION = 63
# Translation from CLI to API wording
RESTART_POLICY_API = {
'never': 'Never',
'on-failure': 'OnFailure',
'always': 'Always'
}
class MountVolumeMode(enum.Enum):
READ_ONLY = 1,
READ_WRITE = 2,
def isReadOnly(self):
return self == MountVolumeMode.READ_ONLY
_DEFAULT_MODE = MountVolumeMode.READ_WRITE
def _GetUserInit(allow_privileged):
"""Gets user-init metadata value for COS image."""
allow_privileged_val = 'true' if allow_privileged else 'false'
return USER_INIT_TEMPLATE % (allow_privileged_val)
class Error(exceptions.Error):
"""Base exception for containers."""
class InvalidMetadataKeyException(Error):
"""InvalidMetadataKeyException is for not allowed metadata keys."""
def __init__(self, metadata_key):
super(InvalidMetadataKeyException, self).__init__(
'Metadata key "{0}" is not allowed when running containerized VM.'
.format(metadata_key))
class NoGceContainerDeclarationMetadataKey(Error):
"""Raised on attempt to update-container on instance without containers."""
def __init__(self):
super(NoGceContainerDeclarationMetadataKey, self).__init__(
"Instance doesn't have {} metadata key - it is not a container.".format(
GCE_CONTAINER_DECLARATION))
def ValidateUserMetadata(metadata):
"""Validates if user-specified metadata.
Checks if it contains values which may conflict with container deployment.
Args:
metadata: user-specified VM metadata.
Raises:
InvalidMetadataKeyException: if there is conflict with user-provided
metadata
"""
for entry in metadata.items:
if entry.key in [USER_DATA_KEY, CONTAINER_MANIFEST_KEY, GKE_DOCKER]:
raise InvalidMetadataKeyException(entry.key)
def CreateTagsMessage(messages, tags):
"""Create tags message with parameters for container VM or VM templates."""
if tags:
return messages.Tags(items=tags)
def GetLabelsMessageWithCosVersion(
labels, image_uri, resources, resource_class):
"""Returns message with labels for instance / instance template.
Args:
labels: dict, labels to assign to the resource.
image_uri: URI of image used as a base for the resource. The function
extracts COS version from the URI and uses it as a value of
`container-vm` label.
resources: object that can parse image_uri.
resource_class: class of the resource to which labels will be assigned.
Must contain LabelsValue class and
resource_class.LabelsValue must contain AdditionalProperty
class.
"""
cos_version = resources.Parse(
image_uri, collection='compute.images').Name().replace('/', '-')
if labels is None:
labels = {}
labels['container-vm'] = cos_version
additional_properties = [
resource_class.LabelsValue.AdditionalProperty(key=k, value=v)
for k, v in sorted(six.iteritems(labels))]
return resource_class.LabelsValue(additionalProperties=additional_properties)
class NoCosImageException(Error):
"""Raised when COS image could not be found."""
def __init__(self):
super(NoCosImageException, self).__init__(
'Could not find COS (Cloud OS) for release family \'{0}\''
.format(COS_MAJOR_RELEASE))
def ExpandCosImageFlag(compute_client):
"""Select a COS image to run Docker."""
compute = compute_client.apitools_client
images = compute_client.MakeRequests([(
compute.images,
'List',
compute_client.messages.ComputeImagesListRequest(project=COS_PROJECT)
)])
return _SelectNewestCosImage(images)
def _SelectNewestCosImage(images):
"""Selects newest COS image from the list."""
cos_images = sorted([image for image in images
if image.name.startswith(COS_MAJOR_RELEASE)],
key=lambda x: times.ParseDateTime(x.creationTimestamp))
if not cos_images:
raise NoCosImageException()
return cos_images[-1].selfLink
def _ValidateAndParsePortMapping(port_mappings):
"""Parses and validates port mapping."""
ports_config = []
for port_mapping in port_mappings:
mapping_match = re.match(r'^(\d+):(\d+):(\S+)$', port_mapping)
if not mapping_match:
raise calliope_exceptions.InvalidArgumentException(
'--port-mappings',
'Port mappings should follow PORT:TARGET_PORT:PROTOCOL format.')
port, target_port, protocol = mapping_match.groups()
if protocol not in ALLOWED_PROTOCOLS:
raise calliope_exceptions.InvalidArgumentException(
'--port-mappings',
'Protocol should be one of [{0}]'.format(
', '.join(ALLOWED_PROTOCOLS)))
ports_config.append({
'containerPort': int(target_port),
'hostPort': int(port),
'protocol': protocol})
return ports_config
def ExpandKonletCosImageFlag(compute_client):
"""Select a COS image to run Konlet.
This function scans three families in order:
- stable
- beta
- dev
looking for the first image with version at least _MIN_PREFERRED_COS_VERSION.
Args:
compute_client: ClientAdapter, The Compute API client adapter
Returns:
COS image at version _MIN_PREFERRED_COS_VERSION or later.
Raises:
NoCosImageException: No COS image at version at least
_MIN_PREFERRED_COS_VERSION was found. This should not happen if backend is
healthy.
"""
compute = compute_client.apitools_client
images = compute_client.MakeRequests(
[(compute.images,
'List',
compute_client.messages.ComputeImagesListRequest(project=COS_PROJECT))])
name_re_template = r'cos-{}-(\d+)-.*'
image_families = ['stable', 'beta', 'dev']
for family in image_families:
name_re = name_re_template.format(family)
def MakeCreateComparisonKey(name_re):
def CreateComparisonKey(image):
version = int(re.match(name_re, image.name).group(1))
timestamp = times.ParseDateTime(image.creationTimestamp)
return version, timestamp
return CreateComparisonKey
cos_images = sorted(
[image for image in images if re.match(name_re, image.name)],
key=MakeCreateComparisonKey(name_re))
if (cos_images and MakeCreateComparisonKey(name_re)(cos_images[-1])[0] >=
_MIN_PREFERRED_COS_VERSION):
return cos_images[-1].selfLink
raise NoCosImageException()
def _ReadDictionary(filename):
# pylint:disable=line-too-long
r"""Read environment variable from file.
File format:
It is intended (but not guaranteed) to follow standard docker format
[](https://docs.docker.com/engine/reference/commandline/run/#set-environment-variables--e---env---env-file)
but without capturing environment variables from host machine.
Lines starting by "#" character are comments.
Empty lines are ignored.
Below grammar production follow in EBNF format.
file = (whitespace* statement '\n')*
statement = comment
| definition
whitespace = ' '
| '\t'
comment = '#' [^\n]*
definition = [^#=\n] [^= \t\n]* '=' [^\n]*
Args:
filename: str, name of the file to read
Returns:
A dictionary mapping environment variable names to their values.
"""
env_vars = {}
if not filename:
return env_vars
with files.FileReader(filename) as f:
for i, line in enumerate(f):
# Strip whitespace at the beginning and end of line
line = line.strip()
# Ignore comments and empty lines
if len(line) <= 1 or line[0] == '#':
continue
# Find first left '=' character
assignment_op_loc = line.find('=')
if assignment_op_loc == -1:
raise calliope_exceptions.BadFileException(
'Syntax error in {}:{}: Expected VAR=VAL, got {}'.format(
filename, i, line))
env = line[:assignment_op_loc]
val = line[assignment_op_loc+1:]
if ' ' in env or '\t' in env:
raise calliope_exceptions.BadFileException(
'Syntax error in {}:{} Variable name cannot contain whitespaces,'
' got "{}"'.format(filename, i, env))
env_vars[env] = val
return env_vars
def _GetHostPathDiskName(idx):
return 'host-path-{}'.format(idx)
def _GetTmpfsDiskName(idx):
return 'tmpfs-{}'.format(idx)
def _GetPersistentDiskName(idx):
return 'pd-{}'.format(idx)
def _AddMountedDisksToManifest(container_mount_disk, volumes, volume_mounts,
used_names=None, disks=None):
"""Add volume specs from --container-mount-disk."""
used_names = used_names or []
disks = disks or []
idx = 0
for mount_disk in container_mount_disk:
while _GetPersistentDiskName(idx) in used_names:
idx += 1
device_name = mount_disk.get('name')
partition = mount_disk.get('partition')
def _GetMatchingVolume(device_name, partition):
for volume_spec in volumes:
pd = volume_spec.get('gcePersistentDisk', {})
if (pd.get('pdName') == device_name
and pd.get('partition') == partition):
return volume_spec
repeated = _GetMatchingVolume(device_name, partition)
if repeated:
name = repeated['name']
else:
name = _GetPersistentDiskName(idx)
used_names.append(name)
if not device_name:
# This should not be needed - any command that accepts container mount
# disks should validate that there is only one disk before calling this
# function.
if len(disks) != 1:
raise calliope_exceptions.InvalidArgumentException(
'--container-mount-disk',
'Must specify the name of the disk to be mounted unless exactly '
'one disk is attached to the instance.')
device_name = disks[0].get('name')
if disks[0].get('device-name', device_name) != device_name:
raise exceptions.InvalidArgumentException(
'--container-mount-disk',
'Must not have a device-name that is different from disk name if '
'disk is being attached to the instance and mounted to a container:'
' [{}]'.format(disks[0].get('device-name')))
volume_mounts.append({
'name': name,
'mountPath': mount_disk['mount-path'],
'readOnly': mount_disk.get('mode', _DEFAULT_MODE).isReadOnly()})
if repeated:
continue
volume_spec = {
'name': name,
'gcePersistentDisk': {
'pdName': device_name,
'fsType': 'ext4'}}
if partition:
volume_spec['gcePersistentDisk'].update({'partition': partition})
volumes.append(volume_spec)
idx += 1
def _CreateContainerManifest(args, instance_name,
container_mount_disk_enabled=False,
container_mount_disk=None):
"""Create container manifest from argument namespace and instance name."""
container = {'image': args.container_image, 'name': instance_name}
if args.container_command is not None:
container['command'] = [args.container_command]
if args.container_arg is not None:
container['args'] = args.container_arg
container['stdin'] = args.container_stdin
container['tty'] = args.container_tty
container['securityContext'] = {'privileged': args.container_privileged}
env_vars = _ReadDictionary(args.container_env_file)
for env_var_dict in args.container_env or []:
for env, val in six.iteritems(env_var_dict):
env_vars[env] = val
if env_vars:
container['env'] = [{
'name': env,
'value': val
} for env, val in six.iteritems(env_vars)]
volumes = []
volume_mounts = []
for idx, volume in enumerate(args.container_mount_host_path or []):
volumes.append({
'name': _GetHostPathDiskName(idx),
'hostPath': {
'path': volume['host-path']
},
})
volume_mounts.append({
'name': _GetHostPathDiskName(idx),
'mountPath': volume['mount-path'],
'readOnly': volume.get('mode', _DEFAULT_MODE).isReadOnly()
})
for idx, tmpfs in enumerate(args.container_mount_tmpfs or []):
volumes.append(
{'name': _GetTmpfsDiskName(idx), 'emptyDir': {'medium': 'Memory'}})
volume_mounts.append(
{'name': _GetTmpfsDiskName(idx), 'mountPath': tmpfs['mount-path']})
if container_mount_disk_enabled:
container_mount_disk = container_mount_disk or []
disks = (args.disk or []) + (args.create_disk or [])
_AddMountedDisksToManifest(container_mount_disk, volumes, volume_mounts,
disks=disks)
container['volumeMounts'] = volume_mounts
manifest = {
'spec': {
'containers': [container],
'volumes': volumes,
'restartPolicy': RESTART_POLICY_API[args.container_restart_policy]
}
}
return manifest
def DumpYaml(data):
"""Dumps data dict to YAML in format expected by Konlet."""
return MANIFEST_DISCLAIMER + yaml.dump(data)
def _CreateYamlContainerManifest(args, instance_name,
container_mount_disk_enabled=False,
container_mount_disk=None):
"""Helper to create the container manifest."""
return DumpYaml(_CreateContainerManifest(
args, instance_name,
container_mount_disk_enabled=container_mount_disk_enabled,
container_mount_disk=container_mount_disk))
def CreateKonletMetadataMessage(messages, args, instance_name, user_metadata,
container_mount_disk_enabled=False,
container_mount_disk=None):
"""Helper to create the metadata for konlet."""
konlet_metadata = {
GCE_CONTAINER_DECLARATION:
_CreateYamlContainerManifest(
args, instance_name,
container_mount_disk_enabled=container_mount_disk_enabled,
container_mount_disk=container_mount_disk),
# Since COS 69, having logs for Container-VMs written requires enabling
# Stackdriver Logging agent.
STACKDRIVER_LOGGING_AGENT_CONFIGURATION: 'true',
}
return metadata_utils.ConstructMetadataMessage(
messages, metadata=konlet_metadata, existing_metadata=user_metadata)
def UpdateInstance(holder, client, instance_ref, instance, args,
container_mount_disk_enabled=False,
container_mount_disk=None):
"""Update an instance and its container metadata."""
# find gce-container-declaration metadata entry
for metadata in instance.metadata.items:
if metadata.key == GCE_CONTAINER_DECLARATION:
UpdateMetadata(
holder, metadata, args, instance,
container_mount_disk_enabled=container_mount_disk_enabled,
container_mount_disk=container_mount_disk)
# update Google Compute Engine resource
operation = client.apitools_client.instances.SetMetadata(
client.messages.ComputeInstancesSetMetadataRequest(
metadata=instance.metadata, **instance_ref.AsDict()))
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.zoneOperations')
operation_poller = poller.Poller(client.apitools_client.instances)
set_metadata_waiter = waiter.WaitFor(
operation_poller, operation_ref,
'Updating specification of container [{0}]'.format(
instance_ref.Name()))
if (instance.status ==
client.messages.Instance.StatusValueValuesEnum.TERMINATED):
return set_metadata_waiter
elif (instance.status ==
client.messages.Instance.StatusValueValuesEnum.SUSPENDED):
return _StopVm(holder, client, instance_ref)
else:
_StopVm(holder, client, instance_ref)
return _StartVm(holder, client, instance_ref)
raise NoGceContainerDeclarationMetadataKey()
def _StopVm(holder, client, instance_ref):
"""Stop the Virtual Machine."""
operation = client.apitools_client.instances.Stop(
client.messages.ComputeInstancesStopRequest(
**instance_ref.AsDict()))
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.zoneOperations')
operation_poller = poller.Poller(client.apitools_client.instances)
return waiter.WaitFor(
operation_poller, operation_ref,
'Stopping instance [{0}]'.format(instance_ref.Name()))
def _StartVm(holder, client, instance_ref):
"""Start the Virtual Machine."""
operation = client.apitools_client.instances.Start(
client.messages.ComputeInstancesStartRequest(
**instance_ref.AsDict()))
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.zoneOperations')
operation_poller = poller.Poller(client.apitools_client.instances)
return waiter.WaitFor(
operation_poller, operation_ref,
'Starting instance [{0}]'.format(instance_ref.Name()))
def UpdateMetadata(holder, metadata, args, instance,
container_mount_disk_enabled=False,
container_mount_disk=None):
"""Update konlet metadata entry using user-supplied data."""
# precondition: metadata.key == GCE_CONTAINER_DECLARATION
manifest = yaml.load(metadata.value)
if args.IsSpecified('container_image'):
manifest['spec']['containers'][0]['image'] = args.container_image
if args.IsSpecified('container_command'):
manifest['spec']['containers'][0]['command'] = [args.container_command]
if args.IsSpecified('clear_container_command'):
manifest['spec']['containers'][0].pop('command', None)
if args.IsSpecified('container_arg'):
manifest['spec']['containers'][0]['args'] = args.container_arg
if args.IsSpecified('clear_container_args'):
manifest['spec']['containers'][0].pop('args', None)
if args.container_privileged is True:
manifest['spec']['containers'][0]['securityContext']['privileged'] = True
if args.container_privileged is False:
manifest['spec']['containers'][0]['securityContext']['privileged'] = False
if container_mount_disk_enabled:
container_mount_disk = container_mount_disk or []
disks = instance.disks
else:
container_mount_disk = []
# Only need disks for updating the container mount disk.
disks = []
_UpdateMounts(holder, manifest, args.remove_container_mounts or [],
args.container_mount_host_path or [],
args.container_mount_tmpfs or [],
container_mount_disk,
disks)
_UpdateEnv(manifest,
itertools.chain.from_iterable(args.remove_container_env or []),
args.container_env_file, args.container_env or [])
if args.container_stdin is True:
manifest['spec']['containers'][0]['stdin'] = True
if args.container_stdin is False:
manifest['spec']['containers'][0]['stdin'] = False
if args.container_tty is True:
manifest['spec']['containers'][0]['tty'] = True
if args.container_tty is False:
manifest['spec']['containers'][0]['tty'] = False
if args.IsSpecified('container_restart_policy'):
manifest['spec']['restartPolicy'] = RESTART_POLICY_API[
args.container_restart_policy]
metadata.value = DumpYaml(manifest)
def _UpdateMounts(holder, manifest, remove_container_mounts,
container_mount_host_path, container_mount_tmpfs,
container_mount_disk, disks):
"""Updates mounts in container manifest."""
_CleanupMounts(manifest, remove_container_mounts, container_mount_host_path,
container_mount_tmpfs,
container_mount_disk=container_mount_disk)
used_names = [volume['name'] for volume in manifest['spec']['volumes']]
volumes = []
volume_mounts = []
next_volume_index = 0
for volume in container_mount_host_path:
while _GetHostPathDiskName(next_volume_index) in used_names:
next_volume_index += 1
name = _GetHostPathDiskName(next_volume_index)
next_volume_index += 1
volumes.append({
'name': name,
'hostPath': {
'path': volume['host-path']
},
})
volume_mounts.append({
'name': name,
'mountPath': volume['mount-path'],
'readOnly': volume.get('mode', _DEFAULT_MODE).isReadOnly()
})
for tmpfs in container_mount_tmpfs:
while _GetTmpfsDiskName(next_volume_index) in used_names:
next_volume_index += 1
name = _GetTmpfsDiskName(next_volume_index)
next_volume_index += 1
volumes.append({'name': name, 'emptyDir': {'medium': 'Memory'}})
volume_mounts.append({'name': name, 'mountPath': tmpfs['mount-path']})
if container_mount_disk:
# Convert to dict to match helper input needs.
# The disk must already have a device name that matches its
# name. For disks that were attached to the instance already.
disks = [{'device-name': disk.deviceName,
'name': holder.resources.Parse(disk.source).Name()}
for disk in disks]
_AddMountedDisksToManifest(container_mount_disk, volumes, volume_mounts,
used_names=used_names, disks=disks)
manifest['spec']['containers'][0]['volumeMounts'].extend(volume_mounts)
manifest['spec']['volumes'].extend(volumes)
def _CleanupMounts(manifest, remove_container_mounts, container_mount_host_path,
container_mount_tmpfs, container_mount_disk=None):
"""Remove all specified mounts from container manifest."""
container_mount_disk = container_mount_disk or []
# volumeMounts stored in this list should be removed
mount_paths_to_remove = remove_container_mounts[:]
for host_path in container_mount_host_path:
mount_paths_to_remove.append(host_path['mount-path'])
for tmpfs in container_mount_tmpfs:
mount_paths_to_remove.append(tmpfs['mount-path'])
for disk in container_mount_disk:
mount_paths_to_remove.append(disk['mount-path'])
# volumeMounts stored in this list are used
used_mounts = []
used_mounts_names = []
removed_mount_names = []
for mount in manifest['spec']['containers'][0].get('volumeMounts', []):
if mount['mountPath'] not in mount_paths_to_remove:
used_mounts.append(mount)
used_mounts_names.append(mount['name'])
else:
removed_mount_names.append(mount['name'])
# override volumeMounts
manifest['spec']['containers'][0]['volumeMounts'] = used_mounts
# garbage collect volumes which become orphaned, skip volumes orphaned before
# start of the procedure
used_volumes = []
for volume in manifest['spec'].get('volumes', []):
if (volume['name'] in used_mounts_names or
volume['name'] not in removed_mount_names):
used_volumes.append(volume)
# override volumes
manifest['spec']['volumes'] = used_volumes
def _UpdateEnv(manifest, remove_container_env, container_env_file,
container_env):
"""Update environment variables in container manifest."""
current_env = {}
for env_val in manifest['spec']['containers'][0].get('env', []):
current_env[env_val['name']] = env_val['value']
for env in remove_container_env:
current_env.pop(env, None)
current_env.update(_ReadDictionary(container_env_file))
for env_var_dict in container_env:
for env, val in six.iteritems(env_var_dict):
current_env[env] = val
if current_env:
manifest['spec']['containers'][0]['env'] = [{
'name': env,
'value': val
} for env, val in six.iteritems(current_env)]
| 34.512129 | 117 | 0.694275 | [
"MIT"
] | bopopescu/JobSniperRails | gcloud/google-cloud-sdk/.install/.backup/lib/googlecloudsdk/api_lib/compute/containers_utils.py | 25,608 | Python |
#!/usr/bin/evn python
# -*- coding: utf-8 -*-
# python version 2.7.6
import magic
mime = magic.Magic(mime=True)
print mime.from_file("/Users/mac/Documents/data/fastq/8.fastq") | 19.777778 | 63 | 0.696629 | [
"BSD-3-Clause"
] | sdyz5210/python | files/judgeFileType.py | 178 | Python |
import tensorflow as tf
import tensorflow.contrib.distributions as tfd
import numpy as np
import os.path as opth
import tqdm
import os
from sklearn.utils import shuffle
import argparse
HOME = os.path.expanduser('~')
os.environ["CUDA_VISIBLE_DEVICES"] = "2";
layers = tf.keras.layers
parser = argparse.ArgumentParser()
def define_generator():
def conv1d_block(filters, upsample=True, activation=tf.nn.relu, index=0):
if upsample:
model.add(layers.UpSampling1D(name="UpSampling" + str(index), size=2))
model.add(layers.Conv1D(filters=filters, kernel_size=5, padding='same', name="Conv1D" + str(index),
activation=activation))
model.add(layers.BatchNormalization())
model = tf.keras.models.Sequential(name="Generator")
model.add(layers.Dense(int(316), activation=tf.nn.relu, name="NoiseToSpatial")) #50
model.add(layers.BatchNormalization())
model.add(layers.Reshape((int(316),1)))
conv1d_block(filters=512, upsample=True, index=0)
conv1d_block(filters=512, upsample=True, index=1)
conv1d_block(filters=256, upsample=True, index=2)
conv1d_block(filters=256, upsample=True, index=3)
conv1d_block(filters=128, upsample=False, index=4)
conv1d_block(filters=128, upsample=False, index=5)
conv1d_block(filters=64, upsample=False, index=6)
conv1d_block(filters=64, upsample=False, index=7)
conv1d_block(filters=1, upsample=False, activation=tf.nn.tanh, index=8)
return model
class Discriminator:
def __init__(self):
self.tail = self._define_tail()
self.head = self._define_head()
def _define_tail(self, name="Discriminator"):
feature_model = tf.keras.models.Sequential(name=name)
def conv1d_dropout(filters, strides, index=0):
suffix = str(index)
feature_model.add(layers.Conv1D(filters=filters, strides=strides, name="Conv{}".format(suffix), padding='same',
kernel_size=5, activation=tf.nn.leaky_relu))
feature_model.add(layers.Dropout(name="Dropout{}".format(suffix), rate=0.3))
conv1d_dropout(filters=32, strides=2, index=5)
conv1d_dropout(filters=32, strides=2, index=6)
conv1d_dropout(filters=64, strides=2, index=0)
conv1d_dropout(filters=64, strides=2, index=1)
conv1d_dropout(filters=128, strides=2, index=2)
conv1d_dropout(filters=128, strides=2, index=3)
conv1d_dropout(filters=256, strides=1, index=4) #64
conv1d_dropout(filters=256, strides=1, index=7)
feature_model.add(layers.Flatten(name="Flatten")) # This is feature layer for FM loss !!
return feature_model
def _define_head(self):
head_model = tf.keras.models.Sequential(name="DiscriminatorHead")
head_model.add(layers.Dense(units=2048, activation='relu'))
head_model.add(layers.Dropout(rate=0.5))
head_model.add(layers.Dense(units=2048, activation='relu'))
head_model.add(layers.Dropout(rate=0.5))
head_model.add(layers.Dense(units=1024, activation='relu'))
head_model.add(layers.Dropout(rate=0.5))
head_model.add(layers.Dense(units=512, activation='relu'))
head_model.add(layers.Dropout(rate=0.5))
head_model.add(layers.Dense(units=args.num_classes, activation=None, name="Logits"))
return head_model
@property
def trainable_variables(self):
return self.tail.trainable_variables + self.head.trainable_variables
def __call__(self, x, *args, **kwargs):
features = self.tail(x, *args, **kwargs)
print(features.shape)
return self.head(features, *args, **kwargs), features
def accuracy(logits, labels):
preds = tf.argmax(logits, axis=1)
return tf.reduce_mean(tf.to_float(tf.equal(preds, labels)))
def main(args):
global best_acc
best_acc = 0
with tf.Graph().as_default():
print("Input data preprocessing...")
with tf.name_scope("DataPreprocess"):
r_train = 500.0 / 6.0
r_test = 100.0 / 6.0
nClass = 100 # 95 # 100
mon_instance = 2498.0 # 1000.0 # 300.0
unClass = 0 # 40000 # 30000
unmon_instance = unClass
dim = 5000
with tf.device('/cpu:0'):
(train_x, train_y, test_x_data, test_y_data) = split_awf_closed(r_train, r_test, nClass, mon_instance,
unmon_instance, dim)
def reshape_and_scale(x, img_shape=(-1, dim, 1)):
return x.reshape(img_shape).astype(np.float32)
train_x = reshape_and_scale(train_x)
test_x_data = reshape_and_scale(test_x_data)
# Use AWF2 for unlabled set
awf_data2 = np.load (HOME+'/datasets/awf2.npz', allow_pickle=True)
train_x_unlabeled = awf_data2['data']
train_y_unlabeled = awf_data2['labels']
train_x_unlabeled = reshape_and_scale(train_x_unlabeled)
X, y = shuffle(train_x, train_y)
print(X.shape)
print(y.shape)
print("Setup the input pipeline...")
with tf.name_scope("InputPipeline"):
train_x_labeled, train_y_labeled = [], []
for i in range(args.num_classes):
print(i)
train_x_labeled.append(X[y == i][:args.num_labeled_examples])
train_y_labeled.append(y[y == i][:args.num_labeled_examples])
train_x_labeled_data = np.concatenate(train_x_labeled)
train_y_labeled_data = np.concatenate(train_y_labeled)
train_x_unlabeled_data = train_x_unlabeled#np.concatenate(train_x_unlabeled)
train_y_unlabeled_data = train_y_unlabeled#np.concatenate(train_y_unlabeled)
train_x_unlabeled2, train_y_unlabeled2 = shuffle(train_x_unlabeled, train_y_unlabeled)
train_x_unlabeled2_data = train_x_unlabeled2#np.concatenate(train_x_unlabeled2)
train_y_unlabeled2_data = train_y_unlabeled2#np.concatenate(train_y_unlabeled2)
labeled_X = tf.placeholder(tf.float32, shape=[None, dim, 1])
labeled_y = tf.placeholder(tf.int64, shape=[None])
unlabeled_X = tf.placeholder(tf.float32, shape=[None, dim, 1])
unlabeled_y = tf.placeholder(tf.int64, shape=[None])
unlabeled_X2 = tf.placeholder(tf.float32, shape=[None, dim, 1])
unlabeled_y2 = tf.placeholder(tf.int64, shape=[None])
test_X = tf.placeholder(tf.float32, shape=[None, dim, 1])
test_y = tf.placeholder(tf.int64, shape=[None])
train_labeled_dataset = tf.data.Dataset.from_tensor_slices((labeled_X, labeled_y)) \
.shuffle(buffer_size=len(train_x_labeled_data)) \
.repeat()
train_labeled_dataset = train_labeled_dataset.batch(args.batch_size)
iterator_labeled = train_labeled_dataset.make_initializable_iterator()
traces_lab, labels_lab = iterator_labeled.get_next()
train_unlabeled_dataset = tf.data.Dataset.from_tensor_slices(
(unlabeled_X, unlabeled_y, unlabeled_X2, unlabeled_y2)) \
.shuffle(buffer_size=len(train_x_labeled_data)) \
.repeat()
train_unlabeled_dataset = train_unlabeled_dataset.batch(args.batch_size)
iterator_unlabeled = train_unlabeled_dataset.make_initializable_iterator()
traces_unl, labels_unl, traces_unl2, labels_unl2 = iterator_unlabeled.get_next()
test_dataset = tf.data.Dataset.from_tensor_slices((test_X, test_y)) \
.repeat()
test_dataset = test_dataset.batch(args.batch_size)
iterator_test = test_dataset.make_initializable_iterator()
traces_test, labels_test = iterator_test.get_next()
with tf.name_scope("BatchSize"):
batch_size_tensor = tf.shape(traces_lab)[0]
z, z_perturbed = define_noise(batch_size_tensor,args)
with tf.name_scope("Generator"):
g_model = define_generator()
traces_fake = g_model(z)
traces_fake_perturbed = g_model(z_perturbed)
with tf.name_scope("Discriminator") as discriminator_scope:
d_model = Discriminator()
logits_fake, features_fake = d_model(traces_fake, training=True)
logits_fake_perturbed, _ = d_model(traces_fake_perturbed, training=True)
logits_real_unl, features_real_unl = d_model(traces_unl, training=True)
logits_real_lab, features_real_lab = d_model(traces_lab, training=True) # 1) For supervised loss
logits_train, _ = d_model(traces_lab, training=False)
with tf.name_scope("DiscriminatorLoss"):
loss_supervised = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=labels_lab, logits=logits_real_lab))
logits_sum_real = tf.reduce_logsumexp(logits_real_unl, axis=1)
logits_sum_fake = tf.reduce_logsumexp(logits_fake, axis=1)
loss_unsupervised = 0.5 * (
tf.negative(tf.reduce_mean(logits_sum_real)) +
tf.reduce_mean(tf.nn.softplus(logits_sum_real)) +
tf.reduce_mean(tf.nn.softplus(logits_sum_fake)))
loss_d = loss_supervised + loss_unsupervised
if args.man_reg:
loss_d += 1e-3 * tf.nn.l2_loss(logits_fake - logits_fake_perturbed) \
/ tf.to_float(batch_size_tensor)
with tf.name_scope("Train") as train_scope:
optimizer = tf.train.AdamOptimizer(args.lr * 0.25)
optimize_d = optimizer.minimize(loss_d, var_list=d_model.trainable_variables)
train_accuracy_op = accuracy(logits_train, labels_lab)
with tf.name_scope(discriminator_scope):
with tf.control_dependencies([optimize_d]):
logits_fake, features_fake = d_model(traces_fake, training=True)
logits_real_unl, features_real_unl = d_model(traces_unl2, training=True)
with tf.name_scope("GeneratorLoss"):
feature_mean_real = tf.reduce_mean(features_real_unl, axis=0)
feature_mean_fake = tf.reduce_mean(features_fake, axis=0)
# L1 distance of features is the loss for the generator
loss_g = tf.reduce_mean(tf.abs(feature_mean_real - feature_mean_fake))
with tf.name_scope(train_scope):
optimizer = tf.train.AdamOptimizer(args.lr, beta1=0.5)
train_op = optimizer.minimize(loss_g, var_list=g_model.trainable_variables)
with tf.name_scope(discriminator_scope):
with tf.name_scope("Test"):
logits_test, _ = d_model(traces_test, training=False)
test_accuracy_op = accuracy(logits_test, labels_test)
with tf.name_scope("Summaries"):
summary_op = tf.summary.merge([
tf.summary.scalar("LossDiscriminator", loss_d),
tf.summary.scalar("LossGenerator", loss_g),
tf.summary.scalar("ClassificationAccuracyTrain", train_accuracy_op),
tf.summary.scalar("ClassificationAccuracyTest", test_accuracy_op)])
writer = tf.summary.FileWriter(_next_logdir("tensorboard/wfi5_cw"))
print("Run training...")
steps_per_epoch = (len(train_x_labeled_data) + len(
train_x_unlabeled_data)) // args.batch_size
steps_per_test = test_x_data.shape[0] // args.batch_size
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
step = 0
for epoch in range(args.train_epochs):
losses_d, losses_g, accuracies = [], [], []
print("Epoch {}".format(epoch))
pbar = tqdm.trange(steps_per_epoch)
sess.run(iterator_labeled.initializer,
feed_dict={labeled_X: train_x_labeled_data, labeled_y: train_y_labeled_data})
sess.run(iterator_unlabeled.initializer,
feed_dict={unlabeled_X: train_x_unlabeled_data, unlabeled_y: train_y_unlabeled_data,
unlabeled_X2: train_x_unlabeled2_data, unlabeled_y2: train_y_unlabeled2_data})
sess.run(iterator_test.initializer, feed_dict={test_X: test_x_data, test_y: test_y_data})
for _ in pbar:
if step % 1000 == 0:
_, loss_g_batch, loss_d_batch, summ, accuracy_batch = sess.run(
[train_op, loss_g, loss_d, summary_op, train_accuracy_op])
writer.add_summary(summ, global_step=step)
else:
_, loss_g_batch, loss_d_batch, accuracy_batch = sess.run(
[train_op, loss_g, loss_d, train_accuracy_op])
pbar.set_description("Discriminator loss {0:.3f}, Generator loss {1:.3f}"
.format(loss_d_batch, loss_g_batch))
losses_d.append(loss_d_batch)
losses_g.append(loss_g_batch)
accuracies.append(accuracy_batch)
step += 1
print("Discriminator loss: {0:.4f}, Generator loss: {1:.4f}, "
"Train accuracy: {2:.4f}"
.format(np.mean(losses_d), np.mean(losses_g), np.mean(accuracies)))
accuracies = [sess.run(test_accuracy_op) for _ in range(steps_per_test)]
if np.mean (accuracies) > best_acc:
best_acc = np.mean (accuracies)
if epoch == (int(args.train_epochs)-1):
print ("Test accuracy: {0:.4f}".format (np.mean (accuracies)))
print ("Best accuracy: {0:.4f}".format (best_acc))
def define_noise(batch_size_tensor, args):
with tf.name_scope("LatentNoiseVector"):
z = tfd.Normal(loc=0.0, scale=args.stddev).sample(
sample_shape=(batch_size_tensor, args.z_dim_size))
z_perturbed = z + tfd.Normal(loc=0.0, scale=args.stddev).sample(
sample_shape=(batch_size_tensor, args.z_dim_size)) * 1e-5
return z, z_perturbed
def split_awf_closed(r_train, r_test, nClass, mon_instance, unmon_instance, dim):
mon_data = np.load(HOME+'/datasets/awf1.npz', allow_pickle=True)
mon_x = mon_data['feature']
## We need to uniformly random selection over each monitored class
print('mon_instance',mon_instance)
print('unmon_instance',unmon_instance)
num_mtrain_instance = mon_instance * (r_train / (r_train + r_test)) ## number of monitored training instances for each class
mon_random = np.array(range(int(mon_instance)))
np.random.shuffle(mon_random)
mon_train_ins = mon_random[:int(num_mtrain_instance)] #1666
mon_test_ins = mon_random[int(num_mtrain_instance):]
print('mon_test_ins', len(mon_test_ins))
# Due to the memory error, initialize np arrays here first
train_feature = np.zeros((nClass*len(mon_train_ins), dim), dtype=int)
test_feature = np.zeros((nClass*len(mon_test_ins),dim), dtype=int)
print('test_feature', len(test_feature))
train_label = np.zeros((nClass*len(mon_train_ins),), dtype=int)
test_label = np.zeros((nClass*len(mon_test_ins),), dtype=int)
print(len(mon_train_ins))
print(len(mon_test_ins))
i = 0
mon_instance = int(mon_instance)
print('Monitored training set partitioning...')
print(nClass)
print(len(mon_train_ins))
for c in range(nClass):
c=int(c)
print(c)
for instance in mon_train_ins:
train_label[i] = c
train_feature[i] = mon_x[(c*mon_instance)+instance][:dim]
i += 1
print(i)
print('Monitored testing set partitioning...')
j = 0
for c in range(nClass):
c = int(c)
for instance in mon_test_ins:
test_label[j]=c
test_feature[j]=mon_x[(c*mon_instance)+instance][:dim]
j += 1
print(j)
print(j)
print('train_feature: ', len(train_feature))
print('train_label: ', len(train_label))
print('test_feature: ', len(test_feature))
print('test_label: ', len(test_label))
print('train_dim: ', len(train_feature[0]))
print('test_dim: ', len(test_feature[0]))
return train_feature, train_label, test_feature, test_label
def _next_logdir(path):
if not os.path.exists(path):
os.makedirs(path)
subdirs = [d for d in os.listdir(path) if opth.isdir(opth.join(path, d))]
logdir = opth.join(path, "run" + str(len(subdirs)).zfill(4))
if not os.path.exists(logdir):
os.makedirs(logdir)
return logdir
if __name__ == "__main__":
parser.add_argument ('--batch_size', required=False, default=32)
parser.add_argument ('--train_epochs', required=False, default=12)
parser.add_argument ('--lr', required=False, default=2e-4)
parser.add_argument ('--stddev', required=False, default=1e-2)
parser.add_argument ('--num_classes', required=False, default=100)
parser.add_argument ('--z_dim_size', required=False, default=100)
parser.add_argument ('--num_labeled_examples', required=False, default=5)
parser.add_argument ('--man_reg', required=False, default=True)
args = parser.parse_args ()
for i in range(5):
main(args)
| 44.868895 | 129 | 0.641744 | [
"MIT"
] | traffic-analysis/gandalf | wfi/cw/wfi-cw5.py | 17,454 | Python |
# Copyright 2018 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import hashlib
import json
import os
_ENV_DIR = '/var/db/factory/umpire'
_CONFIG_PATH = os.path.join(_ENV_DIR, 'active_umpire.json')
def SaveNewActiveConfig(config):
"""Serialize and saves the configuration as new active config file."""
json_config = json.dumps(
config, indent=2, separators=(',', ': '), sort_keys=True) + '\n'
json_name = 'umpire.%s.json' % (
hashlib.md5(json_config.encode('utf-8')).hexdigest())
json_path = os.path.join('resources', json_name)
with open(os.path.join(_ENV_DIR, json_path), 'w') as f:
f.write(json_config)
os.unlink(_CONFIG_PATH)
os.symlink(json_path, _CONFIG_PATH)
def Migrate():
with open('/var/db/factory/umpire/active_umpire.json') as f:
config = json.load(f)
if 'rulesets' in config:
for r in config['rulesets']:
r.pop('match', None)
SaveNewActiveConfig(config)
| 29.285714 | 72 | 0.702439 | [
"BSD-3-Clause"
] | arccode/factory | py/umpire/server/migrations/0010.py | 1,025 | Python |
'''
Created by auto_sdk on 2021.03.10
'''
from dingtalk.api.base import RestApi
class OapiCateringUnfreezeRequest(RestApi):
def __init__(self,url=None):
RestApi.__init__(self,url)
self.order_id = None
self.rule_code = None
self.userid = None
def getHttpMethod(self):
return 'POST'
def getapiname(self):
return 'dingtalk.oapi.catering.unfreeze'
| 21.235294 | 43 | 0.747922 | [
"Apache-2.0"
] | hth945/pytest | other/dingding/dingtalk/api/rest/OapiCateringUnfreezeRequest.py | 361 | Python |
# Autogenerated file.
from .client import MidiOutputClient # type: ignore
| 24.666667 | 51 | 0.797297 | [
"MIT"
] | microsoft/jacdac-python | jacdac/midi_output/__init__.py | 74 | Python |
# 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.
from oslo_config import cfg
from oslo_log import log as logging
from nova.compute import power_state
from nova.compute import rpcapi as compute_rpcapi
from nova import exception
from nova.i18n import _
from nova import image
from nova import objects
from nova.scheduler import client as scheduler_client
from nova.scheduler import utils as scheduler_utils
from nova import servicegroup
from nova import utils
LOG = logging.getLogger(__name__)
migrate_opt = cfg.IntOpt('migrate_max_retries',
default=-1,
help='Number of times to retry live-migration before failing. '
'If == -1, try until out of hosts. '
'If == 0, only try once, no retries.')
CONF = cfg.CONF
CONF.register_opt(migrate_opt)
class LiveMigrationTask(object):
def __init__(self, context, instance, destination,
block_migration, disk_over_commit):
self.context = context
self.instance = instance
self.destination = destination
self.block_migration = block_migration
self.disk_over_commit = disk_over_commit
self.source = instance.host
self.migrate_data = None
self.compute_rpcapi = compute_rpcapi.ComputeAPI()
self.servicegroup_api = servicegroup.API()
self.scheduler_client = scheduler_client.SchedulerClient()
self.image_api = image.API()
def execute(self):
self._check_instance_is_active()
self._check_host_is_up(self.source)
if not self.destination:
self.destination = self._find_destination()
else:
self._check_requested_destination()
# TODO(johngarbutt) need to move complexity out of compute manager
# TODO(johngarbutt) disk_over_commit?
return self.compute_rpcapi.live_migration(self.context,
host=self.source,
instance=self.instance,
dest=self.destination,
block_migration=self.block_migration,
migrate_data=self.migrate_data)
def rollback(self):
# TODO(johngarbutt) need to implement the clean up operation
# but this will make sense only once we pull in the compute
# calls, since this class currently makes no state changes,
# except to call the compute method, that has no matching
# rollback call right now.
raise NotImplementedError()
def _check_instance_is_active(self):
if self.instance.power_state not in (power_state.RUNNING,
power_state.PAUSED):
raise exception.InstanceInvalidState(
instance_uuid = self.instance.uuid,
attr = 'power_state',
state = self.instance.power_state,
method = 'live migrate')
def _check_host_is_up(self, host):
try:
service = objects.Service.get_by_compute_host(self.context, host)
except exception.NotFound:
raise exception.ComputeServiceUnavailable(host=host)
if not self.servicegroup_api.service_is_up(service):
raise exception.ComputeServiceUnavailable(host=host)
def _check_requested_destination(self):
self._check_destination_is_not_source()
self._check_host_is_up(self.destination)
self._check_destination_has_enough_memory()
self._check_compatible_with_source_hypervisor(self.destination)
self._call_livem_checks_on_host(self.destination)
def _check_destination_is_not_source(self):
if self.destination == self.source:
raise exception.UnableToMigrateToSelf(
instance_id=self.instance.uuid, host=self.destination)
def _check_destination_has_enough_memory(self):
avail = self._get_compute_info(self.destination)['free_ram_mb']
mem_inst = self.instance.memory_mb
if not mem_inst or avail <= mem_inst:
instance_uuid = self.instance.uuid
dest = self.destination
reason = _("Unable to migrate %(instance_uuid)s to %(dest)s: "
"Lack of memory(host:%(avail)s <= "
"instance:%(mem_inst)s)")
raise exception.MigrationPreCheckError(reason=reason % dict(
instance_uuid=instance_uuid, dest=dest, avail=avail,
mem_inst=mem_inst))
def _get_compute_info(self, host):
return objects.ComputeNode.get_first_node_by_host_for_old_compat(
self.context, host)
def _check_compatible_with_source_hypervisor(self, destination):
source_info = self._get_compute_info(self.source)
destination_info = self._get_compute_info(destination)
source_type = source_info['hypervisor_type']
destination_type = destination_info['hypervisor_type']
if source_type != destination_type:
raise exception.InvalidHypervisorType()
source_version = source_info['hypervisor_version']
destination_version = destination_info['hypervisor_version']
if source_version > destination_version:
raise exception.DestinationHypervisorTooOld()
def _call_livem_checks_on_host(self, destination):
self.migrate_data = self.compute_rpcapi.\
check_can_live_migrate_destination(self.context, self.instance,
destination, self.block_migration, self.disk_over_commit)
def _find_destination(self):
# TODO(johngarbutt) this retry loop should be shared
attempted_hosts = [self.source]
image = utils.get_image_from_system_metadata(
self.instance.system_metadata)
request_spec = scheduler_utils.build_request_spec(self.context, image,
[self.instance])
host = None
while host is None:
self._check_not_over_max_retries(attempted_hosts)
filter_properties = {'ignore_hosts': attempted_hosts}
scheduler_utils.setup_instance_group(self.context, request_spec,
filter_properties)
host = self.scheduler_client.select_destinations(self.context,
request_spec, filter_properties)[0]['host']
try:
self._check_compatible_with_source_hypervisor(host)
self._call_livem_checks_on_host(host)
except exception.Invalid as e:
LOG.debug("Skipping host: %(host)s because: %(e)s",
{"host": host, "e": e})
attempted_hosts.append(host)
host = None
return host
def _check_not_over_max_retries(self, attempted_hosts):
if CONF.migrate_max_retries == -1:
return
retries = len(attempted_hosts) - 1
if retries > CONF.migrate_max_retries:
msg = (_('Exceeded max scheduling retries %(max_retries)d for '
'instance %(instance_uuid)s during live migration')
% {'max_retries': retries,
'instance_uuid': self.instance.uuid})
raise exception.NoValidHost(reason=msg)
def execute(context, instance, destination,
block_migration, disk_over_commit):
task = LiveMigrationTask(context, instance,
destination,
block_migration,
disk_over_commit)
# TODO(johngarbutt) create a superclass that contains a safe_execute call
return task.execute()
| 41.948454 | 78 | 0.652249 | [
"Apache-2.0"
] | alvarolopez/nova | nova/conductor/tasks/live_migrate.py | 8,138 | Python |
# Problem: N soldiers are standing in a circle and
# first person has sword and he kills the 2nd person
# and gives the sword to the third person and so on
# till 99th person kills the 100th person gives the
# sword back to the first person, this goes on till
# only one person survives. Print the survivor.
def josephus(people, step=2):
if step<=1:
print("Enter step value, greater than 1")
else:
step -= 1 # translated to zero-based indexing
kill = step # kill will hold the index of current person to die
while(len(people) > 1):
print(people.pop(kill)) # pop method removes the element from the list
kill = (kill + step) % len(people)
print(people[0], "is safe")
num = int(input("Enter the number of soldiers: "))
soldiers = [i for i in range(1, num+1)] # generates a list of 1..num
josephus(soldiers)
| 37.608696 | 76 | 0.678613 | [
"MIT"
] | GarvitArya/Python-Interview-Problems-for-Practice | josephus.py | 865 | Python |
import paddle
import paddle.nn as nn
import paddle.nn.functional as F
class BiEncoder(nn.Layer):
def __init__(self,question_encoder,context_encoder,dropout,output_emb_size = 768,state=None):
super(BiEncoder, self).__init__()
self.state = state
if self.state == None:
self.question_encoder = question_encoder
self.context_encoder = context_encoder
elif self.state == "FORQUESTION":
self.question_encoder = question_encoder
elif self.state == "FORCONTEXT":
self.context_encoder = context_encoder
self.dropout = nn.Dropout(dropout if dropout is not None else 0.1)
weight_attr = paddle.ParamAttr(initializer=paddle.nn.initializer.TruncatedNormal(std=0.02))
self.emb_reduce_linear = paddle.nn.Linear(
768, output_emb_size, weight_attr=weight_attr)
def get_question_pooled_embedding(self,
input_ids,
token_type_ids=None,
position_ids=None,
attention_mask=None):
_, cls_embedding = self.question_encoder(input_ids, token_type_ids, position_ids,attention_mask)
"""cls_embedding = self.emb_reduce_linear(cls_embedding)
cls_embedding = self.dropout(cls_embedding)
cls_embedding = F.normalize(cls_embedding, p=2, axis=-1)"""
return cls_embedding
def get_context_pooled_embedding(self,
input_ids,
token_type_ids=None,
position_ids=None,
attention_mask=None):
_, cls_embedding = self.context_encoder(input_ids, token_type_ids, position_ids,attention_mask)
"""cls_embedding = self.emb_reduce_linear(cls_embedding)
cls_embedding = self.dropout(cls_embedding)
cls_embedding = F.normalize(cls_embedding, p=2, axis=-1)"""
return cls_embedding
def forward(self,
question_id,
question_segments,
question_attn_mask,
context_ids,
context_segments,
context_attn_mask,
):
question_pooled_out = self.get_question_pooled_embedding(question_id,question_segments,question_attn_mask)
context_pooled_out = self.get_context_pooled_embedding(context_ids,context_segments,context_attn_mask)
return question_pooled_out,context_pooled_out
class BiEncoderNllLoss(object):
def calc(self,
q_vectors,
ctx_vectors,
positive_idx_per_question,
loss_scale=None):
scorces = paddle.matmul(q_vectors,paddle.transpose(ctx_vectors,[0,1]))
if len(q_vectors.size()) > 1:
q_num = q_vectors.size(0)
scores = scorces.view(q_num, -1)
softmax_scorces = F.log_softmax(scores,axis=1)
loss = F.nll_loss(softmax_scorces,paddle.to_tensor(positive_idx_per_question))
max_score = paddle.max(softmax_scorces,axis=1)
correct_predictions_count = (None)
if loss_scale:
loss.mul_(loss_scale)
return loss,correct_predictions_count | 37.988235 | 114 | 0.633013 | [
"Apache-2.0"
] | Elvisambition/PaddleNLP | examples/semantic_indexing/biencoder_base_model.py | 3,229 | Python |
import sys
sys.path.append('../scripts')
from detect_duplicates import df
def test_nan_names():
assert df.name.isnull().sum() == 0
def test_dup_pid():
assert df.patient_id.duplicated().sum() == 0
def test_phone_dup():
assert df.phone_number.duplicated().sum() == 0 | 23.583333 | 50 | 0.689046 | [
"MIT"
] | monkeyusage/duplicates | tests/test.py | 283 | Python |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import json
from alipay.aop.api.response.AlipayResponse import AlipayResponse
from alipay.aop.api.domain.SettlementbillOpenApiDTO import SettlementbillOpenApiDTO
class AlipayBossFncSettleSettlementbillCreateResponse(AlipayResponse):
def __init__(self):
super(AlipayBossFncSettleSettlementbillCreateResponse, self).__init__()
self._result_set = None
@property
def result_set(self):
return self._result_set
@result_set.setter
def result_set(self, value):
if isinstance(value, SettlementbillOpenApiDTO):
self._result_set = value
else:
self._result_set = SettlementbillOpenApiDTO.from_alipay_dict(value)
def parse_response_content(self, response_content):
response = super(AlipayBossFncSettleSettlementbillCreateResponse, self).parse_response_content(response_content)
if 'result_set' in response:
self.result_set = response['result_set']
| 33.466667 | 120 | 0.74004 | [
"Apache-2.0"
] | Anning01/alipay-sdk-python-all | alipay/aop/api/response/AlipayBossFncSettleSettlementbillCreateResponse.py | 1,004 | Python |
#!/usr/bin/python
import argparse
import subprocess
import json
parser = argparse.ArgumentParser()
parser.add_argument("--list", action="store_true")
args = parser.parse_args()
result = {"_meta": {"hostvars": {}}}
if args.list:
output = subprocess.check_output([
"cd ../terraform/stage; terraform show -json"
], shell=True)
data = json.loads(output)
group_list = set()
try:
for module in data["values"]["root_module"]["child_modules"]:
try:
for resource in module["resources"]:
if resource["type"] == "null_resource":
continue
group_name = resource["name"]
values = resource["values"]
host_name = values["name"]
ip = values["network_interface"][0]["nat_ip_address"]
if group_name not in result:
result[group_name] = {"hosts": []}
group_list.add(group_name)
result[group_name]["hosts"].append(host_name)
result["_meta"]["hostvars"][host_name] = {
"ansible_host": ip
}
except KeyError:
continue
result["all"] = {"children": list(group_list), "hosts": [], "vars": {}}
except KeyError:
pass
print(json.dumps(result))
else:
print(json.dumps(result))
| 28.94 | 79 | 0.520387 | [
"MIT"
] | Otus-DevOps-2020-08/ValeriyTyutyunnik_infra | ansible/environments/stage/dynamic_inventory.py | 1,447 | Python |
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
from typing import TYPE_CHECKING
import warnings
from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error
from azure.core.pipeline import PipelineResponse
from azure.core.pipeline.transport import HttpRequest, HttpResponse
from azure.mgmt.core.exceptions import ARMErrorFormat
from .. import models as _models
if TYPE_CHECKING:
# pylint: disable=unused-import,ungrouped-imports
from typing import Any, Callable, Dict, Generic, Optional, TypeVar
T = TypeVar('T')
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
class ServiceAssociationLinksOperations(object):
"""ServiceAssociationLinksOperations operations.
You should not instantiate this class directly. Instead, you should create a Client instance that
instantiates it for you and attaches it as an attribute.
:ivar models: Alias to model classes used in this operation group.
:type models: ~azure.mgmt.network.v2019_04_01.models
:param client: Client for service requests.
:param config: Configuration of service client.
:param serializer: An object model serializer.
:param deserializer: An object model deserializer.
"""
models = _models
def __init__(self, client, config, serializer, deserializer):
self._client = client
self._serialize = serializer
self._deserialize = deserializer
self._config = config
def list(
self,
resource_group_name, # type: str
virtual_network_name, # type: str
subnet_name, # type: str
**kwargs # type: Any
):
# type: (...) -> "_models.ServiceAssociationLinksListResult"
"""Gets a list of service association links for a subnet.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param virtual_network_name: The name of the virtual network.
:type virtual_network_name: str
:param subnet_name: The name of the subnet.
:type subnet_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: ServiceAssociationLinksListResult, or the result of cls(response)
:rtype: ~azure.mgmt.network.v2019_04_01.models.ServiceAssociationLinksListResult
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.ServiceAssociationLinksListResult"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2019-04-01"
accept = "application/json"
# Construct URL
url = self.list.metadata['url'] # type: ignore
path_format_arguments = {
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'virtualNetworkName': self._serialize.url("virtual_network_name", virtual_network_name, 'str'),
'subnetName': self._serialize.url("subnet_name", subnet_name, 'str'),
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
deserialized = self._deserialize('ServiceAssociationLinksListResult', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
list.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}/ServiceAssociationLinks'} # type: ignore
| 46.899083 | 223 | 0.689358 | [
"MIT"
] | 4thel00z/microsoft-crap-that-doesnt-work | sdk/network/azure-mgmt-network/azure/mgmt/network/v2019_04_01/operations/_service_association_links_operations.py | 5,112 | Python |
from .util import rms
from .util import moving_average
from .util import moving_avg_conv
from .util import moving_avg_fft
from .util import normalize
from .util import next_pow2
from .util import top_and_tail
from .util import extrapolate
from .util import nearest
from .util import deprecated
from .util import apply_along_axis
from .util import sigmoid
from .util import power
from .util import root
| 26.8 | 34 | 0.825871 | [
"Apache-2.0"
] | EvanBianco/bruges | bruges/util/__init__.py | 402 | Python |
# -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: google/cloud/securitycenter_v1beta1/proto/securitycenter_service.proto
import sys
_b = sys.version_info[0] < 3 and (lambda x: x) or (lambda x: x.encode("latin1"))
from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from google.protobuf import reflection as _reflection
from google.protobuf import symbol_database as _symbol_database
from google.protobuf import descriptor_pb2
# @@protoc_insertion_point(imports)
_sym_db = _symbol_database.Default()
from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2
from google.cloud.securitycenter_v1beta1.proto import (
asset_pb2 as google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_asset__pb2,
)
from google.cloud.securitycenter_v1beta1.proto import (
finding_pb2 as google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_finding__pb2,
)
from google.cloud.securitycenter_v1beta1.proto import (
organization_settings_pb2 as google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_organization__settings__pb2,
)
from google.cloud.securitycenter_v1beta1.proto import (
security_marks_pb2 as google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_security__marks__pb2,
)
from google.cloud.securitycenter_v1beta1.proto import (
source_pb2 as google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_source__pb2,
)
from google.iam.v1 import iam_policy_pb2 as google_dot_iam_dot_v1_dot_iam__policy__pb2
from google.iam.v1 import policy_pb2 as google_dot_iam_dot_v1_dot_policy__pb2
from google.longrunning import (
operations_pb2 as google_dot_longrunning_dot_operations__pb2,
)
from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2
from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
from google.protobuf import field_mask_pb2 as google_dot_protobuf_dot_field__mask__pb2
from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2
from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2
DESCRIPTOR = _descriptor.FileDescriptor(
name="google/cloud/securitycenter_v1beta1/proto/securitycenter_service.proto",
package="google.cloud.securitycenter.v1beta1",
syntax="proto3",
serialized_pb=_b(
'\nFgoogle/cloud/securitycenter_v1beta1/proto/securitycenter_service.proto\x12#google.cloud.securitycenter.v1beta1\x1a\x1cgoogle/api/annotations.proto\x1a\x35google/cloud/securitycenter_v1beta1/proto/asset.proto\x1a\x37google/cloud/securitycenter_v1beta1/proto/finding.proto\x1a\x45google/cloud/securitycenter_v1beta1/proto/organization_settings.proto\x1a>google/cloud/securitycenter_v1beta1/proto/security_marks.proto\x1a\x36google/cloud/securitycenter_v1beta1/proto/source.proto\x1a\x1egoogle/iam/v1/iam_policy.proto\x1a\x1agoogle/iam/v1/policy.proto\x1a#google/longrunning/operations.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a google/protobuf/field_mask.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto"y\n\x14\x43reateFindingRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12\x12\n\nfinding_id\x18\x02 \x01(\t\x12=\n\x07\x66inding\x18\x03 \x01(\x0b\x32,.google.cloud.securitycenter.v1beta1.Finding"b\n\x13\x43reateSourceRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12;\n\x06source\x18\x02 \x01(\x0b\x32+.google.cloud.securitycenter.v1beta1.Source".\n\x1eGetOrganizationSettingsRequest\x12\x0c\n\x04name\x18\x01 \x01(\t" \n\x10GetSourceRequest\x12\x0c\n\x04name\x18\x01 \x01(\t"\xd1\x01\n\x12GroupAssetsRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12\x0e\n\x06\x66ilter\x18\x02 \x01(\t\x12\x10\n\x08group_by\x18\x03 \x01(\t\x12\x33\n\x10\x63ompare_duration\x18\x04 \x01(\x0b\x32\x19.google.protobuf.Duration\x12-\n\tread_time\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x12\n\npage_token\x18\x07 \x01(\t\x12\x11\n\tpage_size\x18\x08 \x01(\x05"\xa9\x01\n\x13GroupAssetsResponse\x12J\n\x10group_by_results\x18\x01 \x03(\x0b\x32\x30.google.cloud.securitycenter.v1beta1.GroupResult\x12-\n\tread_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\t"\x9e\x01\n\x14GroupFindingsRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12\x0e\n\x06\x66ilter\x18\x02 \x01(\t\x12\x10\n\x08group_by\x18\x03 \x01(\t\x12-\n\tread_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x12\n\npage_token\x18\x05 \x01(\t\x12\x11\n\tpage_size\x18\x06 \x01(\x05"\xab\x01\n\x15GroupFindingsResponse\x12J\n\x10group_by_results\x18\x01 \x03(\x0b\x32\x30.google.cloud.securitycenter.v1beta1.GroupResult\x12-\n\tread_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\t"\xbd\x01\n\x0bGroupResult\x12T\n\nproperties\x18\x01 \x03(\x0b\x32@.google.cloud.securitycenter.v1beta1.GroupResult.PropertiesEntry\x12\r\n\x05\x63ount\x18\x02 \x01(\x03\x1aI\n\x0fPropertiesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12%\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.Value:\x02\x38\x01"K\n\x12ListSourcesRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12\x12\n\npage_token\x18\x02 \x01(\t\x12\x11\n\tpage_size\x18\x07 \x01(\x05"l\n\x13ListSourcesResponse\x12<\n\x07sources\x18\x01 \x03(\x0b\x32+.google.cloud.securitycenter.v1beta1.Source\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\t"\x80\x02\n\x11ListAssetsRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12\x0e\n\x06\x66ilter\x18\x02 \x01(\t\x12\x10\n\x08order_by\x18\x03 \x01(\t\x12-\n\tread_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x33\n\x10\x63ompare_duration\x18\x05 \x01(\x0b\x32\x19.google.protobuf.Duration\x12.\n\nfield_mask\x18\x07 \x01(\x0b\x32\x1a.google.protobuf.FieldMask\x12\x12\n\npage_token\x18\x08 \x01(\t\x12\x11\n\tpage_size\x18\t \x01(\x05"\xd6\x03\n\x12ListAssetsResponse\x12\x65\n\x13list_assets_results\x18\x01 \x03(\x0b\x32H.google.cloud.securitycenter.v1beta1.ListAssetsResponse.ListAssetsResult\x12-\n\tread_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\t\x12\x12\n\ntotal_size\x18\x04 \x01(\x05\x1a\xfc\x01\n\x10ListAssetsResult\x12\x39\n\x05\x61sset\x18\x01 \x01(\x0b\x32*.google.cloud.securitycenter.v1beta1.Asset\x12]\n\x05state\x18\x02 \x01(\x0e\x32N.google.cloud.securitycenter.v1beta1.ListAssetsResponse.ListAssetsResult.State"N\n\x05State\x12\x15\n\x11STATE_UNSPECIFIED\x10\x00\x12\n\n\x06UNUSED\x10\x01\x12\t\n\x05\x41\x44\x44\x45\x44\x10\x02\x12\x0b\n\x07REMOVED\x10\x03\x12\n\n\x06\x41\x43TIVE\x10\x04"\xcd\x01\n\x13ListFindingsRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12\x0e\n\x06\x66ilter\x18\x02 \x01(\t\x12\x10\n\x08order_by\x18\x03 \x01(\t\x12-\n\tread_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12.\n\nfield_mask\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.FieldMask\x12\x12\n\npage_token\x18\x06 \x01(\t\x12\x11\n\tpage_size\x18\x07 \x01(\x05"\xb2\x01\n\x14ListFindingsResponse\x12>\n\x08\x66indings\x18\x01 \x03(\x0b\x32,.google.cloud.securitycenter.v1beta1.Finding\x12-\n\tread_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\t\x12\x12\n\ntotal_size\x18\x04 \x01(\x05"\x99\x01\n\x16SetFindingStateRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x41\n\x05state\x18\x02 \x01(\x0e\x32\x32.google.cloud.securitycenter.v1beta1.Finding.State\x12.\n\nstart_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp"*\n\x18RunAssetDiscoveryRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t"\x86\x01\n\x14UpdateFindingRequest\x12=\n\x07\x66inding\x18\x01 \x01(\x0b\x32,.google.cloud.securitycenter.v1beta1.Finding\x12/\n\x0bupdate_mask\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.FieldMask"\xae\x01\n!UpdateOrganizationSettingsRequest\x12X\n\x15organization_settings\x18\x01 \x01(\x0b\x32\x39.google.cloud.securitycenter.v1beta1.OrganizationSettings\x12/\n\x0bupdate_mask\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.FieldMask"\x83\x01\n\x13UpdateSourceRequest\x12;\n\x06source\x18\x01 \x01(\x0b\x32+.google.cloud.securitycenter.v1beta1.Source\x12/\n\x0bupdate_mask\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.FieldMask"\xc9\x01\n\x1aUpdateSecurityMarksRequest\x12J\n\x0esecurity_marks\x18\x01 \x01(\x0b\x32\x32.google.cloud.securitycenter.v1beta1.SecurityMarks\x12/\n\x0bupdate_mask\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.FieldMask\x12.\n\nstart_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp2\x80\x1c\n\x0eSecurityCenter\x12\xb0\x01\n\x0c\x43reateSource\x12\x38.google.cloud.securitycenter.v1beta1.CreateSourceRequest\x1a+.google.cloud.securitycenter.v1beta1.Source"9\x82\xd3\xe4\x93\x02\x33")/v1beta1/{parent=organizations/*}/sources:\x06source\x12\xbf\x01\n\rCreateFinding\x12\x39.google.cloud.securitycenter.v1beta1.CreateFindingRequest\x1a,.google.cloud.securitycenter.v1beta1.Finding"E\x82\xd3\xe4\x93\x02?"4/v1beta1/{parent=organizations/*/sources/*}/findings:\x07\x66inding\x12\x90\x01\n\x0cGetIamPolicy\x12".google.iam.v1.GetIamPolicyRequest\x1a\x15.google.iam.v1.Policy"E\x82\xd3\xe4\x93\x02?":/v1beta1/{resource=organizations/*/sources/*}:getIamPolicy:\x01*\x12\xd7\x01\n\x17GetOrganizationSettings\x12\x43.google.cloud.securitycenter.v1beta1.GetOrganizationSettingsRequest\x1a\x39.google.cloud.securitycenter.v1beta1.OrganizationSettings"<\x82\xd3\xe4\x93\x02\x36\x12\x34/v1beta1/{name=organizations/*/organizationSettings}\x12\xa2\x01\n\tGetSource\x12\x35.google.cloud.securitycenter.v1beta1.GetSourceRequest\x1a+.google.cloud.securitycenter.v1beta1.Source"1\x82\xd3\xe4\x93\x02+\x12)/v1beta1/{name=organizations/*/sources/*}\x12\xbb\x01\n\x0bGroupAssets\x12\x37.google.cloud.securitycenter.v1beta1.GroupAssetsRequest\x1a\x38.google.cloud.securitycenter.v1beta1.GroupAssetsResponse"9\x82\xd3\xe4\x93\x02\x33"./v1beta1/{parent=organizations/*}/assets:group:\x01*\x12\xcd\x01\n\rGroupFindings\x12\x39.google.cloud.securitycenter.v1beta1.GroupFindingsRequest\x1a:.google.cloud.securitycenter.v1beta1.GroupFindingsResponse"E\x82\xd3\xe4\x93\x02?":/v1beta1/{parent=organizations/*/sources/*}/findings:group:\x01*\x12\xaf\x01\n\nListAssets\x12\x36.google.cloud.securitycenter.v1beta1.ListAssetsRequest\x1a\x37.google.cloud.securitycenter.v1beta1.ListAssetsResponse"0\x82\xd3\xe4\x93\x02*\x12(/v1beta1/{parent=organizations/*}/assets\x12\xc1\x01\n\x0cListFindings\x12\x38.google.cloud.securitycenter.v1beta1.ListFindingsRequest\x1a\x39.google.cloud.securitycenter.v1beta1.ListFindingsResponse"<\x82\xd3\xe4\x93\x02\x36\x12\x34/v1beta1/{parent=organizations/*/sources/*}/findings\x12\xb3\x01\n\x0bListSources\x12\x37.google.cloud.securitycenter.v1beta1.ListSourcesRequest\x1a\x38.google.cloud.securitycenter.v1beta1.ListSourcesResponse"1\x82\xd3\xe4\x93\x02+\x12)/v1beta1/{parent=organizations/*}/sources\x12\xb3\x01\n\x11RunAssetDiscovery\x12=.google.cloud.securitycenter.v1beta1.RunAssetDiscoveryRequest\x1a\x1d.google.longrunning.Operation"@\x82\xd3\xe4\x93\x02:"5/v1beta1/{parent=organizations/*}/assets:runDiscovery:\x01*\x12\xc6\x01\n\x0fSetFindingState\x12;.google.cloud.securitycenter.v1beta1.SetFindingStateRequest\x1a,.google.cloud.securitycenter.v1beta1.Finding"H\x82\xd3\xe4\x93\x02\x42"=/v1beta1/{name=organizations/*/sources/*/findings/*}:setState:\x01*\x12\x90\x01\n\x0cSetIamPolicy\x12".google.iam.v1.SetIamPolicyRequest\x1a\x15.google.iam.v1.Policy"E\x82\xd3\xe4\x93\x02?":/v1beta1/{resource=organizations/*/sources/*}:setIamPolicy:\x01*\x12\xb6\x01\n\x12TestIamPermissions\x12(.google.iam.v1.TestIamPermissionsRequest\x1a).google.iam.v1.TestIamPermissionsResponse"K\x82\xd3\xe4\x93\x02\x45"@/v1beta1/{resource=organizations/*/sources/*}:testIamPermissions:\x01*\x12\xc7\x01\n\rUpdateFinding\x12\x39.google.cloud.securitycenter.v1beta1.UpdateFindingRequest\x1a,.google.cloud.securitycenter.v1beta1.Finding"M\x82\xd3\xe4\x93\x02G2</v1beta1/{finding.name=organizations/*/sources/*/findings/*}:\x07\x66inding\x12\x8a\x02\n\x1aUpdateOrganizationSettings\x12\x46.google.cloud.securitycenter.v1beta1.UpdateOrganizationSettingsRequest\x1a\x39.google.cloud.securitycenter.v1beta1.OrganizationSettings"i\x82\xd3\xe4\x93\x02\x63\x32J/v1beta1/{organization_settings.name=organizations/*/organizationSettings}:\x15organization_settings\x12\xb7\x01\n\x0cUpdateSource\x12\x38.google.cloud.securitycenter.v1beta1.UpdateSourceRequest\x1a+.google.cloud.securitycenter.v1beta1.Source"@\x82\xd3\xe4\x93\x02:20/v1beta1/{source.name=organizations/*/sources/*}:\x06source\x12\xd0\x02\n\x13UpdateSecurityMarks\x12?.google.cloud.securitycenter.v1beta1.UpdateSecurityMarksRequest\x1a\x32.google.cloud.securitycenter.v1beta1.SecurityMarks"\xc3\x01\x82\xd3\xe4\x93\x02\xbc\x01\x32\x45/v1beta1/{security_marks.name=organizations/*/assets/*/securityMarks}:\x0esecurity_marksZc2Q/v1beta1/{security_marks.name=organizations/*/sources/*/findings/*/securityMarks}:\x0esecurity_marksB~\n\'com.google.cloud.securitycenter.v1beta1P\x01ZQgoogle.golang.org/genproto/googleapis/cloud/securitycenter/v1beta1;securitycenterb\x06proto3'
),
dependencies=[
google_dot_api_dot_annotations__pb2.DESCRIPTOR,
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_asset__pb2.DESCRIPTOR,
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_finding__pb2.DESCRIPTOR,
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_organization__settings__pb2.DESCRIPTOR,
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_security__marks__pb2.DESCRIPTOR,
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_source__pb2.DESCRIPTOR,
google_dot_iam_dot_v1_dot_iam__policy__pb2.DESCRIPTOR,
google_dot_iam_dot_v1_dot_policy__pb2.DESCRIPTOR,
google_dot_longrunning_dot_operations__pb2.DESCRIPTOR,
google_dot_protobuf_dot_duration__pb2.DESCRIPTOR,
google_dot_protobuf_dot_empty__pb2.DESCRIPTOR,
google_dot_protobuf_dot_field__mask__pb2.DESCRIPTOR,
google_dot_protobuf_dot_struct__pb2.DESCRIPTOR,
google_dot_protobuf_dot_timestamp__pb2.DESCRIPTOR,
],
)
_LISTASSETSRESPONSE_LISTASSETSRESULT_STATE = _descriptor.EnumDescriptor(
name="State",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsResponse.ListAssetsResult.State",
filename=None,
file=DESCRIPTOR,
values=[
_descriptor.EnumValueDescriptor(
name="STATE_UNSPECIFIED", index=0, number=0, options=None, type=None
),
_descriptor.EnumValueDescriptor(
name="UNUSED", index=1, number=1, options=None, type=None
),
_descriptor.EnumValueDescriptor(
name="ADDED", index=2, number=2, options=None, type=None
),
_descriptor.EnumValueDescriptor(
name="REMOVED", index=3, number=3, options=None, type=None
),
_descriptor.EnumValueDescriptor(
name="ACTIVE", index=4, number=4, options=None, type=None
),
],
containing_type=None,
options=None,
serialized_start=2754,
serialized_end=2832,
)
_sym_db.RegisterEnumDescriptor(_LISTASSETSRESPONSE_LISTASSETSRESULT_STATE)
_CREATEFINDINGREQUEST = _descriptor.Descriptor(
name="CreateFindingRequest",
full_name="google.cloud.securitycenter.v1beta1.CreateFindingRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="parent",
full_name="google.cloud.securitycenter.v1beta1.CreateFindingRequest.parent",
index=0,
number=1,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="finding_id",
full_name="google.cloud.securitycenter.v1beta1.CreateFindingRequest.finding_id",
index=1,
number=2,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="finding",
full_name="google.cloud.securitycenter.v1beta1.CreateFindingRequest.finding",
index=2,
number=3,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=699,
serialized_end=820,
)
_CREATESOURCEREQUEST = _descriptor.Descriptor(
name="CreateSourceRequest",
full_name="google.cloud.securitycenter.v1beta1.CreateSourceRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="parent",
full_name="google.cloud.securitycenter.v1beta1.CreateSourceRequest.parent",
index=0,
number=1,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="source",
full_name="google.cloud.securitycenter.v1beta1.CreateSourceRequest.source",
index=1,
number=2,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=822,
serialized_end=920,
)
_GETORGANIZATIONSETTINGSREQUEST = _descriptor.Descriptor(
name="GetOrganizationSettingsRequest",
full_name="google.cloud.securitycenter.v1beta1.GetOrganizationSettingsRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="name",
full_name="google.cloud.securitycenter.v1beta1.GetOrganizationSettingsRequest.name",
index=0,
number=1,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
)
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=922,
serialized_end=968,
)
_GETSOURCEREQUEST = _descriptor.Descriptor(
name="GetSourceRequest",
full_name="google.cloud.securitycenter.v1beta1.GetSourceRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="name",
full_name="google.cloud.securitycenter.v1beta1.GetSourceRequest.name",
index=0,
number=1,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
)
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=970,
serialized_end=1002,
)
_GROUPASSETSREQUEST = _descriptor.Descriptor(
name="GroupAssetsRequest",
full_name="google.cloud.securitycenter.v1beta1.GroupAssetsRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="parent",
full_name="google.cloud.securitycenter.v1beta1.GroupAssetsRequest.parent",
index=0,
number=1,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="filter",
full_name="google.cloud.securitycenter.v1beta1.GroupAssetsRequest.filter",
index=1,
number=2,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="group_by",
full_name="google.cloud.securitycenter.v1beta1.GroupAssetsRequest.group_by",
index=2,
number=3,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="compare_duration",
full_name="google.cloud.securitycenter.v1beta1.GroupAssetsRequest.compare_duration",
index=3,
number=4,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="read_time",
full_name="google.cloud.securitycenter.v1beta1.GroupAssetsRequest.read_time",
index=4,
number=5,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="page_token",
full_name="google.cloud.securitycenter.v1beta1.GroupAssetsRequest.page_token",
index=5,
number=7,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="page_size",
full_name="google.cloud.securitycenter.v1beta1.GroupAssetsRequest.page_size",
index=6,
number=8,
type=5,
cpp_type=1,
label=1,
has_default_value=False,
default_value=0,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=1005,
serialized_end=1214,
)
_GROUPASSETSRESPONSE = _descriptor.Descriptor(
name="GroupAssetsResponse",
full_name="google.cloud.securitycenter.v1beta1.GroupAssetsResponse",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="group_by_results",
full_name="google.cloud.securitycenter.v1beta1.GroupAssetsResponse.group_by_results",
index=0,
number=1,
type=11,
cpp_type=10,
label=3,
has_default_value=False,
default_value=[],
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="read_time",
full_name="google.cloud.securitycenter.v1beta1.GroupAssetsResponse.read_time",
index=1,
number=2,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="next_page_token",
full_name="google.cloud.securitycenter.v1beta1.GroupAssetsResponse.next_page_token",
index=2,
number=3,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=1217,
serialized_end=1386,
)
_GROUPFINDINGSREQUEST = _descriptor.Descriptor(
name="GroupFindingsRequest",
full_name="google.cloud.securitycenter.v1beta1.GroupFindingsRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="parent",
full_name="google.cloud.securitycenter.v1beta1.GroupFindingsRequest.parent",
index=0,
number=1,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="filter",
full_name="google.cloud.securitycenter.v1beta1.GroupFindingsRequest.filter",
index=1,
number=2,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="group_by",
full_name="google.cloud.securitycenter.v1beta1.GroupFindingsRequest.group_by",
index=2,
number=3,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="read_time",
full_name="google.cloud.securitycenter.v1beta1.GroupFindingsRequest.read_time",
index=3,
number=4,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="page_token",
full_name="google.cloud.securitycenter.v1beta1.GroupFindingsRequest.page_token",
index=4,
number=5,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="page_size",
full_name="google.cloud.securitycenter.v1beta1.GroupFindingsRequest.page_size",
index=5,
number=6,
type=5,
cpp_type=1,
label=1,
has_default_value=False,
default_value=0,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=1389,
serialized_end=1547,
)
_GROUPFINDINGSRESPONSE = _descriptor.Descriptor(
name="GroupFindingsResponse",
full_name="google.cloud.securitycenter.v1beta1.GroupFindingsResponse",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="group_by_results",
full_name="google.cloud.securitycenter.v1beta1.GroupFindingsResponse.group_by_results",
index=0,
number=1,
type=11,
cpp_type=10,
label=3,
has_default_value=False,
default_value=[],
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="read_time",
full_name="google.cloud.securitycenter.v1beta1.GroupFindingsResponse.read_time",
index=1,
number=2,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="next_page_token",
full_name="google.cloud.securitycenter.v1beta1.GroupFindingsResponse.next_page_token",
index=2,
number=3,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=1550,
serialized_end=1721,
)
_GROUPRESULT_PROPERTIESENTRY = _descriptor.Descriptor(
name="PropertiesEntry",
full_name="google.cloud.securitycenter.v1beta1.GroupResult.PropertiesEntry",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="key",
full_name="google.cloud.securitycenter.v1beta1.GroupResult.PropertiesEntry.key",
index=0,
number=1,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="value",
full_name="google.cloud.securitycenter.v1beta1.GroupResult.PropertiesEntry.value",
index=1,
number=2,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=_descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b("8\001")),
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=1840,
serialized_end=1913,
)
_GROUPRESULT = _descriptor.Descriptor(
name="GroupResult",
full_name="google.cloud.securitycenter.v1beta1.GroupResult",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="properties",
full_name="google.cloud.securitycenter.v1beta1.GroupResult.properties",
index=0,
number=1,
type=11,
cpp_type=10,
label=3,
has_default_value=False,
default_value=[],
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="count",
full_name="google.cloud.securitycenter.v1beta1.GroupResult.count",
index=1,
number=2,
type=3,
cpp_type=2,
label=1,
has_default_value=False,
default_value=0,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[_GROUPRESULT_PROPERTIESENTRY],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=1724,
serialized_end=1913,
)
_LISTSOURCESREQUEST = _descriptor.Descriptor(
name="ListSourcesRequest",
full_name="google.cloud.securitycenter.v1beta1.ListSourcesRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="parent",
full_name="google.cloud.securitycenter.v1beta1.ListSourcesRequest.parent",
index=0,
number=1,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="page_token",
full_name="google.cloud.securitycenter.v1beta1.ListSourcesRequest.page_token",
index=1,
number=2,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="page_size",
full_name="google.cloud.securitycenter.v1beta1.ListSourcesRequest.page_size",
index=2,
number=7,
type=5,
cpp_type=1,
label=1,
has_default_value=False,
default_value=0,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=1915,
serialized_end=1990,
)
_LISTSOURCESRESPONSE = _descriptor.Descriptor(
name="ListSourcesResponse",
full_name="google.cloud.securitycenter.v1beta1.ListSourcesResponse",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="sources",
full_name="google.cloud.securitycenter.v1beta1.ListSourcesResponse.sources",
index=0,
number=1,
type=11,
cpp_type=10,
label=3,
has_default_value=False,
default_value=[],
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="next_page_token",
full_name="google.cloud.securitycenter.v1beta1.ListSourcesResponse.next_page_token",
index=1,
number=2,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=1992,
serialized_end=2100,
)
_LISTASSETSREQUEST = _descriptor.Descriptor(
name="ListAssetsRequest",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="parent",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsRequest.parent",
index=0,
number=1,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="filter",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsRequest.filter",
index=1,
number=2,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="order_by",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsRequest.order_by",
index=2,
number=3,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="read_time",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsRequest.read_time",
index=3,
number=4,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="compare_duration",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsRequest.compare_duration",
index=4,
number=5,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="field_mask",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsRequest.field_mask",
index=5,
number=7,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="page_token",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsRequest.page_token",
index=6,
number=8,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="page_size",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsRequest.page_size",
index=7,
number=9,
type=5,
cpp_type=1,
label=1,
has_default_value=False,
default_value=0,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=2103,
serialized_end=2359,
)
_LISTASSETSRESPONSE_LISTASSETSRESULT = _descriptor.Descriptor(
name="ListAssetsResult",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsResponse.ListAssetsResult",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="asset",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsResponse.ListAssetsResult.asset",
index=0,
number=1,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="state",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsResponse.ListAssetsResult.state",
index=1,
number=2,
type=14,
cpp_type=8,
label=1,
has_default_value=False,
default_value=0,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[_LISTASSETSRESPONSE_LISTASSETSRESULT_STATE],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=2580,
serialized_end=2832,
)
_LISTASSETSRESPONSE = _descriptor.Descriptor(
name="ListAssetsResponse",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsResponse",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="list_assets_results",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsResponse.list_assets_results",
index=0,
number=1,
type=11,
cpp_type=10,
label=3,
has_default_value=False,
default_value=[],
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="read_time",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsResponse.read_time",
index=1,
number=2,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="next_page_token",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsResponse.next_page_token",
index=2,
number=3,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="total_size",
full_name="google.cloud.securitycenter.v1beta1.ListAssetsResponse.total_size",
index=3,
number=4,
type=5,
cpp_type=1,
label=1,
has_default_value=False,
default_value=0,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[_LISTASSETSRESPONSE_LISTASSETSRESULT],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=2362,
serialized_end=2832,
)
_LISTFINDINGSREQUEST = _descriptor.Descriptor(
name="ListFindingsRequest",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="parent",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsRequest.parent",
index=0,
number=1,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="filter",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsRequest.filter",
index=1,
number=2,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="order_by",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsRequest.order_by",
index=2,
number=3,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="read_time",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsRequest.read_time",
index=3,
number=4,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="field_mask",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsRequest.field_mask",
index=4,
number=5,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="page_token",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsRequest.page_token",
index=5,
number=6,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="page_size",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsRequest.page_size",
index=6,
number=7,
type=5,
cpp_type=1,
label=1,
has_default_value=False,
default_value=0,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=2835,
serialized_end=3040,
)
_LISTFINDINGSRESPONSE = _descriptor.Descriptor(
name="ListFindingsResponse",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsResponse",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="findings",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsResponse.findings",
index=0,
number=1,
type=11,
cpp_type=10,
label=3,
has_default_value=False,
default_value=[],
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="read_time",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsResponse.read_time",
index=1,
number=2,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="next_page_token",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsResponse.next_page_token",
index=2,
number=3,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="total_size",
full_name="google.cloud.securitycenter.v1beta1.ListFindingsResponse.total_size",
index=3,
number=4,
type=5,
cpp_type=1,
label=1,
has_default_value=False,
default_value=0,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=3043,
serialized_end=3221,
)
_SETFINDINGSTATEREQUEST = _descriptor.Descriptor(
name="SetFindingStateRequest",
full_name="google.cloud.securitycenter.v1beta1.SetFindingStateRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="name",
full_name="google.cloud.securitycenter.v1beta1.SetFindingStateRequest.name",
index=0,
number=1,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="state",
full_name="google.cloud.securitycenter.v1beta1.SetFindingStateRequest.state",
index=1,
number=2,
type=14,
cpp_type=8,
label=1,
has_default_value=False,
default_value=0,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="start_time",
full_name="google.cloud.securitycenter.v1beta1.SetFindingStateRequest.start_time",
index=2,
number=3,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=3224,
serialized_end=3377,
)
_RUNASSETDISCOVERYREQUEST = _descriptor.Descriptor(
name="RunAssetDiscoveryRequest",
full_name="google.cloud.securitycenter.v1beta1.RunAssetDiscoveryRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="parent",
full_name="google.cloud.securitycenter.v1beta1.RunAssetDiscoveryRequest.parent",
index=0,
number=1,
type=9,
cpp_type=9,
label=1,
has_default_value=False,
default_value=_b("").decode("utf-8"),
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
)
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=3379,
serialized_end=3421,
)
_UPDATEFINDINGREQUEST = _descriptor.Descriptor(
name="UpdateFindingRequest",
full_name="google.cloud.securitycenter.v1beta1.UpdateFindingRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="finding",
full_name="google.cloud.securitycenter.v1beta1.UpdateFindingRequest.finding",
index=0,
number=1,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="update_mask",
full_name="google.cloud.securitycenter.v1beta1.UpdateFindingRequest.update_mask",
index=1,
number=2,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=3424,
serialized_end=3558,
)
_UPDATEORGANIZATIONSETTINGSREQUEST = _descriptor.Descriptor(
name="UpdateOrganizationSettingsRequest",
full_name="google.cloud.securitycenter.v1beta1.UpdateOrganizationSettingsRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="organization_settings",
full_name="google.cloud.securitycenter.v1beta1.UpdateOrganizationSettingsRequest.organization_settings",
index=0,
number=1,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="update_mask",
full_name="google.cloud.securitycenter.v1beta1.UpdateOrganizationSettingsRequest.update_mask",
index=1,
number=2,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=3561,
serialized_end=3735,
)
_UPDATESOURCEREQUEST = _descriptor.Descriptor(
name="UpdateSourceRequest",
full_name="google.cloud.securitycenter.v1beta1.UpdateSourceRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="source",
full_name="google.cloud.securitycenter.v1beta1.UpdateSourceRequest.source",
index=0,
number=1,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="update_mask",
full_name="google.cloud.securitycenter.v1beta1.UpdateSourceRequest.update_mask",
index=1,
number=2,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=3738,
serialized_end=3869,
)
_UPDATESECURITYMARKSREQUEST = _descriptor.Descriptor(
name="UpdateSecurityMarksRequest",
full_name="google.cloud.securitycenter.v1beta1.UpdateSecurityMarksRequest",
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name="security_marks",
full_name="google.cloud.securitycenter.v1beta1.UpdateSecurityMarksRequest.security_marks",
index=0,
number=1,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="update_mask",
full_name="google.cloud.securitycenter.v1beta1.UpdateSecurityMarksRequest.update_mask",
index=1,
number=2,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
_descriptor.FieldDescriptor(
name="start_time",
full_name="google.cloud.securitycenter.v1beta1.UpdateSecurityMarksRequest.start_time",
index=2,
number=3,
type=11,
cpp_type=10,
label=1,
has_default_value=False,
default_value=None,
message_type=None,
enum_type=None,
containing_type=None,
is_extension=False,
extension_scope=None,
options=None,
file=DESCRIPTOR,
),
],
extensions=[],
nested_types=[],
enum_types=[],
options=None,
is_extendable=False,
syntax="proto3",
extension_ranges=[],
oneofs=[],
serialized_start=3872,
serialized_end=4073,
)
_CREATEFINDINGREQUEST.fields_by_name[
"finding"
].message_type = (
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_finding__pb2._FINDING
)
_CREATESOURCEREQUEST.fields_by_name[
"source"
].message_type = (
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_source__pb2._SOURCE
)
_GROUPASSETSREQUEST.fields_by_name[
"compare_duration"
].message_type = google_dot_protobuf_dot_duration__pb2._DURATION
_GROUPASSETSREQUEST.fields_by_name[
"read_time"
].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
_GROUPASSETSRESPONSE.fields_by_name["group_by_results"].message_type = _GROUPRESULT
_GROUPASSETSRESPONSE.fields_by_name[
"read_time"
].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
_GROUPFINDINGSREQUEST.fields_by_name[
"read_time"
].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
_GROUPFINDINGSRESPONSE.fields_by_name["group_by_results"].message_type = _GROUPRESULT
_GROUPFINDINGSRESPONSE.fields_by_name[
"read_time"
].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
_GROUPRESULT_PROPERTIESENTRY.fields_by_name[
"value"
].message_type = google_dot_protobuf_dot_struct__pb2._VALUE
_GROUPRESULT_PROPERTIESENTRY.containing_type = _GROUPRESULT
_GROUPRESULT.fields_by_name["properties"].message_type = _GROUPRESULT_PROPERTIESENTRY
_LISTSOURCESRESPONSE.fields_by_name[
"sources"
].message_type = (
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_source__pb2._SOURCE
)
_LISTASSETSREQUEST.fields_by_name[
"read_time"
].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
_LISTASSETSREQUEST.fields_by_name[
"compare_duration"
].message_type = google_dot_protobuf_dot_duration__pb2._DURATION
_LISTASSETSREQUEST.fields_by_name[
"field_mask"
].message_type = google_dot_protobuf_dot_field__mask__pb2._FIELDMASK
_LISTASSETSRESPONSE_LISTASSETSRESULT.fields_by_name[
"asset"
].message_type = (
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_asset__pb2._ASSET
)
_LISTASSETSRESPONSE_LISTASSETSRESULT.fields_by_name[
"state"
].enum_type = _LISTASSETSRESPONSE_LISTASSETSRESULT_STATE
_LISTASSETSRESPONSE_LISTASSETSRESULT.containing_type = _LISTASSETSRESPONSE
_LISTASSETSRESPONSE_LISTASSETSRESULT_STATE.containing_type = (
_LISTASSETSRESPONSE_LISTASSETSRESULT
)
_LISTASSETSRESPONSE.fields_by_name[
"list_assets_results"
].message_type = _LISTASSETSRESPONSE_LISTASSETSRESULT
_LISTASSETSRESPONSE.fields_by_name[
"read_time"
].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
_LISTFINDINGSREQUEST.fields_by_name[
"read_time"
].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
_LISTFINDINGSREQUEST.fields_by_name[
"field_mask"
].message_type = google_dot_protobuf_dot_field__mask__pb2._FIELDMASK
_LISTFINDINGSRESPONSE.fields_by_name[
"findings"
].message_type = (
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_finding__pb2._FINDING
)
_LISTFINDINGSRESPONSE.fields_by_name[
"read_time"
].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
_SETFINDINGSTATEREQUEST.fields_by_name[
"state"
].enum_type = (
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_finding__pb2._FINDING_STATE
)
_SETFINDINGSTATEREQUEST.fields_by_name[
"start_time"
].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
_UPDATEFINDINGREQUEST.fields_by_name[
"finding"
].message_type = (
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_finding__pb2._FINDING
)
_UPDATEFINDINGREQUEST.fields_by_name[
"update_mask"
].message_type = google_dot_protobuf_dot_field__mask__pb2._FIELDMASK
_UPDATEORGANIZATIONSETTINGSREQUEST.fields_by_name[
"organization_settings"
].message_type = (
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_organization__settings__pb2._ORGANIZATIONSETTINGS
)
_UPDATEORGANIZATIONSETTINGSREQUEST.fields_by_name[
"update_mask"
].message_type = google_dot_protobuf_dot_field__mask__pb2._FIELDMASK
_UPDATESOURCEREQUEST.fields_by_name[
"source"
].message_type = (
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_source__pb2._SOURCE
)
_UPDATESOURCEREQUEST.fields_by_name[
"update_mask"
].message_type = google_dot_protobuf_dot_field__mask__pb2._FIELDMASK
_UPDATESECURITYMARKSREQUEST.fields_by_name[
"security_marks"
].message_type = (
google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_security__marks__pb2._SECURITYMARKS
)
_UPDATESECURITYMARKSREQUEST.fields_by_name[
"update_mask"
].message_type = google_dot_protobuf_dot_field__mask__pb2._FIELDMASK
_UPDATESECURITYMARKSREQUEST.fields_by_name[
"start_time"
].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
DESCRIPTOR.message_types_by_name["CreateFindingRequest"] = _CREATEFINDINGREQUEST
DESCRIPTOR.message_types_by_name["CreateSourceRequest"] = _CREATESOURCEREQUEST
DESCRIPTOR.message_types_by_name[
"GetOrganizationSettingsRequest"
] = _GETORGANIZATIONSETTINGSREQUEST
DESCRIPTOR.message_types_by_name["GetSourceRequest"] = _GETSOURCEREQUEST
DESCRIPTOR.message_types_by_name["GroupAssetsRequest"] = _GROUPASSETSREQUEST
DESCRIPTOR.message_types_by_name["GroupAssetsResponse"] = _GROUPASSETSRESPONSE
DESCRIPTOR.message_types_by_name["GroupFindingsRequest"] = _GROUPFINDINGSREQUEST
DESCRIPTOR.message_types_by_name["GroupFindingsResponse"] = _GROUPFINDINGSRESPONSE
DESCRIPTOR.message_types_by_name["GroupResult"] = _GROUPRESULT
DESCRIPTOR.message_types_by_name["ListSourcesRequest"] = _LISTSOURCESREQUEST
DESCRIPTOR.message_types_by_name["ListSourcesResponse"] = _LISTSOURCESRESPONSE
DESCRIPTOR.message_types_by_name["ListAssetsRequest"] = _LISTASSETSREQUEST
DESCRIPTOR.message_types_by_name["ListAssetsResponse"] = _LISTASSETSRESPONSE
DESCRIPTOR.message_types_by_name["ListFindingsRequest"] = _LISTFINDINGSREQUEST
DESCRIPTOR.message_types_by_name["ListFindingsResponse"] = _LISTFINDINGSRESPONSE
DESCRIPTOR.message_types_by_name["SetFindingStateRequest"] = _SETFINDINGSTATEREQUEST
DESCRIPTOR.message_types_by_name["RunAssetDiscoveryRequest"] = _RUNASSETDISCOVERYREQUEST
DESCRIPTOR.message_types_by_name["UpdateFindingRequest"] = _UPDATEFINDINGREQUEST
DESCRIPTOR.message_types_by_name[
"UpdateOrganizationSettingsRequest"
] = _UPDATEORGANIZATIONSETTINGSREQUEST
DESCRIPTOR.message_types_by_name["UpdateSourceRequest"] = _UPDATESOURCEREQUEST
DESCRIPTOR.message_types_by_name[
"UpdateSecurityMarksRequest"
] = _UPDATESECURITYMARKSREQUEST
_sym_db.RegisterFileDescriptor(DESCRIPTOR)
CreateFindingRequest = _reflection.GeneratedProtocolMessageType(
"CreateFindingRequest",
(_message.Message,),
dict(
DESCRIPTOR=_CREATEFINDINGREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for creating a finding.
Attributes:
parent:
Resource name of the new finding's parent. Its format should
be "organizations/[organization\_id]/sources/[source\_id]".
finding_id:
Unique identifier provided by the client within the parent
scope. It must be alphanumeric and less than or equal to 32
characters and greater than 0 characters in length.
finding:
The Finding being created. The name and security\_marks will
be ignored as they are both output only fields on this
resource.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.CreateFindingRequest)
),
)
_sym_db.RegisterMessage(CreateFindingRequest)
CreateSourceRequest = _reflection.GeneratedProtocolMessageType(
"CreateSourceRequest",
(_message.Message,),
dict(
DESCRIPTOR=_CREATESOURCEREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for creating a source.
Attributes:
parent:
Resource name of the new source's parent. Its format should be
"organizations/[organization\_id]".
source:
The Source being created, only the display\_name and
description will be used. All other fields will be ignored.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.CreateSourceRequest)
),
)
_sym_db.RegisterMessage(CreateSourceRequest)
GetOrganizationSettingsRequest = _reflection.GeneratedProtocolMessageType(
"GetOrganizationSettingsRequest",
(_message.Message,),
dict(
DESCRIPTOR=_GETORGANIZATIONSETTINGSREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for getting organization settings.
Attributes:
name:
Name of the organization to get organization settings for. Its
format is
"organizations/[organization\_id]/organizationSettings".
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.GetOrganizationSettingsRequest)
),
)
_sym_db.RegisterMessage(GetOrganizationSettingsRequest)
GetSourceRequest = _reflection.GeneratedProtocolMessageType(
"GetSourceRequest",
(_message.Message,),
dict(
DESCRIPTOR=_GETSOURCEREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for getting a source.
Attributes:
name:
Relative resource name of the source. Its format is
"organizations/[organization\_id]/source/[source\_id]".
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.GetSourceRequest)
),
)
_sym_db.RegisterMessage(GetSourceRequest)
GroupAssetsRequest = _reflection.GeneratedProtocolMessageType(
"GroupAssetsRequest",
(_message.Message,),
dict(
DESCRIPTOR=_GROUPASSETSREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for grouping by assets.
Attributes:
parent:
Name of the organization to groupBy. Its format is
"organizations/[organization\_id]".
filter:
Expression that defines the filter to apply across assets. The
expression is a list of zero or more restrictions combined via
logical operators ``AND`` and ``OR``. Parentheses are not
supported, and ``OR`` has higher precedence than ``AND``.
Restrictions have the form ``<field> <operator> <value>`` and
may have a ``-`` character in front of them to indicate
negation. The fields map to those defined in the Asset
resource. Examples include: - name -
security\_center\_properties.resource\_name -
resource\_properties.a\_property -
security\_marks.marks.marka The supported operators are: -
``=`` for all value types. - ``>``, ``<``, ``>=``, ``<=`` for
integer values. - ``:``, meaning substring matching, for
strings. The supported value types are: - string literals
in quotes. - integer literals without quotes. - boolean
literals ``true`` and ``false`` without quotes. For example,
``resource_properties.size = 100`` is a valid filter string.
group_by:
Expression that defines what assets fields to use for
grouping. The string value should follow SQL syntax: comma
separated list of fields. For example: "security\_center\_prop
erties.resource\_project,security\_center\_properties.project"
. The following fields are supported when compare\_duration
is not set: - security\_center\_properties.resource\_project
- security\_center\_properties.resource\_type -
security\_center\_properties.resource\_parent The following
fields are supported when compare\_duration is set: -
security\_center\_properties.resource\_type
compare_duration:
When compare\_duration is set, the Asset's "state" property is
updated to indicate whether the asset was added, removed, or
remained present during the compare\_duration period of time
that precedes the read\_time. This is the time between
(read\_time - compare\_duration) and read\_time. The state
value is derived based on the presence of the asset at the two
points in time. Intermediate state changes between the two
times don't affect the result. For example, the results aren't
affected if the asset is removed and re-created again.
Possible "state" values when compare\_duration is specified:
- "ADDED": indicates that the asset was not present before
compare\_duration, but present at reference\_time. -
"REMOVED": indicates that the asset was present at the start
of compare\_duration, but not present at reference\_time. -
"ACTIVE": indicates that the asset was present at both the
start and the end of the time period defined by
compare\_duration and reference\_time. This field is
ignored if ``state`` is not a field in ``group_by``.
read_time:
Time used as a reference point when filtering assets. The
filter is limited to assets existing at the supplied time and
their values are those at that specific time. Absence of this
field will default to the API's version of NOW.
page_token:
The value returned by the last ``GroupAssetsResponse``;
indicates that this is a continuation of a prior
``GroupAssets`` call, and that the system should return the
next page of data.
page_size:
The maximum number of results to return in a single response.
Default is 10, minimum is 1, maximum is 1000.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.GroupAssetsRequest)
),
)
_sym_db.RegisterMessage(GroupAssetsRequest)
GroupAssetsResponse = _reflection.GeneratedProtocolMessageType(
"GroupAssetsResponse",
(_message.Message,),
dict(
DESCRIPTOR=_GROUPASSETSRESPONSE,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Response message for grouping by assets.
Attributes:
group_by_results:
Group results. There exists an element for each existing
unique combination of property/values. The element contains a
count for the number of times those specific property/values
appear.
read_time:
Time used for executing the groupBy request.
next_page_token:
Token to retrieve the next page of results, or empty if there
are no more results.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.GroupAssetsResponse)
),
)
_sym_db.RegisterMessage(GroupAssetsResponse)
GroupFindingsRequest = _reflection.GeneratedProtocolMessageType(
"GroupFindingsRequest",
(_message.Message,),
dict(
DESCRIPTOR=_GROUPFINDINGSREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for grouping by findings.
Attributes:
parent:
Name of the source to groupBy. Its format is
"organizations/[organization\_id]/sources/[source\_id]". To
groupBy across all sources provide a source\_id of ``-``. For
example: organizations/123/sources/-
filter:
Expression that defines the filter to apply across findings.
The expression is a list of one or more restrictions combined
via logical operators ``AND`` and ``OR``. Parentheses are not
supported, and ``OR`` has higher precedence than ``AND``.
Restrictions have the form ``<field> <operator> <value>`` and
may have a ``-`` character in front of them to indicate
negation. Examples include: - name -
source\_properties.a\_property - security\_marks.marks.marka
The supported operators are: - ``=`` for all value types. -
``>``, ``<``, ``>=``, ``<=`` for integer values. - ``:``,
meaning substring matching, for strings. The supported value
types are: - string literals in quotes. - integer literals
without quotes. - boolean literals ``true`` and ``false``
without quotes. For example, ``source_properties.size = 100``
is a valid filter string.
group_by:
Expression that defines what assets fields to use for grouping
(including ``state``). The string value should follow SQL
syntax: comma separated list of fields. For example:
"parent,resource\_name". The following fields are supported:
- resource\_name - category - state - parent
read_time:
Time used as a reference point when filtering findings. The
filter is limited to findings existing at the supplied time
and their values are those at that specific time. Absence of
this field will default to the API's version of NOW.
page_token:
The value returned by the last ``GroupFindingsResponse``;
indicates that this is a continuation of a prior
``GroupFindings`` call, and that the system should return the
next page of data.
page_size:
The maximum number of results to return in a single response.
Default is 10, minimum is 1, maximum is 1000.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.GroupFindingsRequest)
),
)
_sym_db.RegisterMessage(GroupFindingsRequest)
GroupFindingsResponse = _reflection.GeneratedProtocolMessageType(
"GroupFindingsResponse",
(_message.Message,),
dict(
DESCRIPTOR=_GROUPFINDINGSRESPONSE,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Response message for group by findings.
Attributes:
group_by_results:
Group results. There exists an element for each existing
unique combination of property/values. The element contains a
count for the number of times those specific property/values
appear.
read_time:
Time used for executing the groupBy request.
next_page_token:
Token to retrieve the next page of results, or empty if there
are no more results.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.GroupFindingsResponse)
),
)
_sym_db.RegisterMessage(GroupFindingsResponse)
GroupResult = _reflection.GeneratedProtocolMessageType(
"GroupResult",
(_message.Message,),
dict(
PropertiesEntry=_reflection.GeneratedProtocolMessageType(
"PropertiesEntry",
(_message.Message,),
dict(
DESCRIPTOR=_GROUPRESULT_PROPERTIESENTRY,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2"
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.GroupResult.PropertiesEntry)
),
),
DESCRIPTOR=_GROUPRESULT,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Result containing the properties and count of a groupBy request.
Attributes:
properties:
Properties matching the groupBy fields in the request.
count:
Total count of resources for the given properties.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.GroupResult)
),
)
_sym_db.RegisterMessage(GroupResult)
_sym_db.RegisterMessage(GroupResult.PropertiesEntry)
ListSourcesRequest = _reflection.GeneratedProtocolMessageType(
"ListSourcesRequest",
(_message.Message,),
dict(
DESCRIPTOR=_LISTSOURCESREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for listing sources.
Attributes:
parent:
Resource name of the parent of sources to list. Its format
should be "organizations/[organization\_id]".
page_token:
The value returned by the last ``ListSourcesResponse``;
indicates that this is a continuation of a prior
``ListSources`` call, and that the system should return the
next page of data.
page_size:
The maximum number of results to return in a single response.
Default is 10, minimum is 1, maximum is 1000.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.ListSourcesRequest)
),
)
_sym_db.RegisterMessage(ListSourcesRequest)
ListSourcesResponse = _reflection.GeneratedProtocolMessageType(
"ListSourcesResponse",
(_message.Message,),
dict(
DESCRIPTOR=_LISTSOURCESRESPONSE,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Response message for listing sources.
Attributes:
sources:
Sources belonging to the requested parent.
next_page_token:
Token to retrieve the next page of results, or empty if there
are no more results.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.ListSourcesResponse)
),
)
_sym_db.RegisterMessage(ListSourcesResponse)
ListAssetsRequest = _reflection.GeneratedProtocolMessageType(
"ListAssetsRequest",
(_message.Message,),
dict(
DESCRIPTOR=_LISTASSETSREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for listing assets.
Attributes:
parent:
Name of the organization assets should belong to. Its format
is "organizations/[organization\_id]".
filter:
Expression that defines the filter to apply across assets. The
expression is a list of zero or more restrictions combined via
logical operators ``AND`` and ``OR``. Parentheses are not
supported, and ``OR`` has higher precedence than ``AND``.
Restrictions have the form ``<field> <operator> <value>`` and
may have a ``-`` character in front of them to indicate
negation. The fields map to those defined in the Asset
resource. Examples include: - name -
security\_center\_properties.resource\_name -
resource\_properties.a\_property -
security\_marks.marks.marka The supported operators are: -
``=`` for all value types. - ``>``, ``<``, ``>=``, ``<=`` for
integer values. - ``:``, meaning substring matching, for
strings. The supported value types are: - string literals
in quotes. - integer literals without quotes. - boolean
literals ``true`` and ``false`` without quotes. For example,
``resource_properties.size = 100`` is a valid filter string.
order_by:
Expression that defines what fields and order to use for
sorting. The string value should follow SQL syntax: comma
separated list of fields. For example:
"name,resource\_properties.a\_property". The default sorting
order is ascending. To specify descending order for a field, a
suffix " desc" should be appended to the field name. For
example: "name desc,resource\_properties.a\_property".
Redundant space characters in the syntax are insignificant.
"name desc,resource\_properties.a\_property" and " name desc ,
resource\_properties.a\_property " are equivalent.
read_time:
Time used as a reference point when filtering assets. The
filter is limited to assets existing at the supplied time and
their values are those at that specific time. Absence of this
field will default to the API's version of NOW.
compare_duration:
When compare\_duration is set, the ListAssetResult's "state"
attribute is updated to indicate whether the asset was added,
removed, or remained present during the compare\_duration
period of time that precedes the read\_time. This is the time
between (read\_time - compare\_duration) and read\_time. The
state value is derived based on the presence of the asset at
the two points in time. Intermediate state changes between the
two times don't affect the result. For example, the results
aren't affected if the asset is removed and re-created again.
Possible "state" values when compare\_duration is specified:
- "ADDED": indicates that the asset was not present before
compare\_duration, but present at read\_time. - "REMOVED":
indicates that the asset was present at the start of
compare\_duration, but not present at read\_time. - "ACTIVE":
indicates that the asset was present at both the start and
the end of the time period defined by compare\_duration and
read\_time. If compare\_duration is not specified, then the
only possible state is "UNUSED", which indicates that the
asset is present at read\_time.
field_mask:
Optional. A field mask to specify the ListAssetsResult fields
to be listed in the response. An empty field mask will list
all fields.
page_token:
The value returned by the last ``ListAssetsResponse``;
indicates that this is a continuation of a prior
``ListAssets`` call, and that the system should return the
next page of data.
page_size:
The maximum number of results to return in a single response.
Default is 10, minimum is 1, maximum is 1000.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.ListAssetsRequest)
),
)
_sym_db.RegisterMessage(ListAssetsRequest)
ListAssetsResponse = _reflection.GeneratedProtocolMessageType(
"ListAssetsResponse",
(_message.Message,),
dict(
ListAssetsResult=_reflection.GeneratedProtocolMessageType(
"ListAssetsResult",
(_message.Message,),
dict(
DESCRIPTOR=_LISTASSETSRESPONSE_LISTASSETSRESULT,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Result containing the Asset and its State.
Attributes:
asset:
Asset matching the search request.
state:
State of the asset.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.ListAssetsResponse.ListAssetsResult)
),
),
DESCRIPTOR=_LISTASSETSRESPONSE,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Response message for listing assets.
Attributes:
list_assets_results:
Assets matching the list request.
read_time:
Time used for executing the list request.
next_page_token:
Token to retrieve the next page of results, or empty if there
are no more results.
total_size:
The total number of assets matching the query.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.ListAssetsResponse)
),
)
_sym_db.RegisterMessage(ListAssetsResponse)
_sym_db.RegisterMessage(ListAssetsResponse.ListAssetsResult)
ListFindingsRequest = _reflection.GeneratedProtocolMessageType(
"ListFindingsRequest",
(_message.Message,),
dict(
DESCRIPTOR=_LISTFINDINGSREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for listing findings.
Attributes:
parent:
Name of the source the findings belong to. Its format is
"organizations/[organization\_id]/sources/[source\_id]". To
list across all sources provide a source\_id of ``-``. For
example: organizations/123/sources/-
filter:
Expression that defines the filter to apply across findings.
The expression is a list of one or more restrictions combined
via logical operators ``AND`` and ``OR``. Parentheses are not
supported, and ``OR`` has higher precedence than ``AND``.
Restrictions have the form ``<field> <operator> <value>`` and
may have a ``-`` character in front of them to indicate
negation. Examples include: - name -
source\_properties.a\_property - security\_marks.marks.marka
The supported operators are: - ``=`` for all value types. -
``>``, ``<``, ``>=``, ``<=`` for integer values. - ``:``,
meaning substring matching, for strings. The supported value
types are: - string literals in quotes. - integer literals
without quotes. - boolean literals ``true`` and ``false``
without quotes. For example, ``source_properties.size = 100``
is a valid filter string.
order_by:
Expression that defines what fields and order to use for
sorting. The string value should follow SQL syntax: comma
separated list of fields. For example:
"name,resource\_properties.a\_property". The default sorting
order is ascending. To specify descending order for a field, a
suffix " desc" should be appended to the field name. For
example: "name desc,source\_properties.a\_property". Redundant
space characters in the syntax are insignificant. "name
desc,source\_properties.a\_property" and " name desc ,
source\_properties.a\_property " are equivalent.
read_time:
Time used as a reference point when filtering findings. The
filter is limited to findings existing at the supplied time
and their values are those at that specific time. Absence of
this field will default to the API's version of NOW.
field_mask:
Optional. A field mask to specify the Finding fields to be
listed in the response. An empty field mask will list all
fields.
page_token:
The value returned by the last ``ListFindingsResponse``;
indicates that this is a continuation of a prior
``ListFindings`` call, and that the system should return the
next page of data.
page_size:
The maximum number of results to return in a single response.
Default is 10, minimum is 1, maximum is 1000.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.ListFindingsRequest)
),
)
_sym_db.RegisterMessage(ListFindingsRequest)
ListFindingsResponse = _reflection.GeneratedProtocolMessageType(
"ListFindingsResponse",
(_message.Message,),
dict(
DESCRIPTOR=_LISTFINDINGSRESPONSE,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Response message for listing findings.
Attributes:
findings:
Findings matching the list request.
read_time:
Time used for executing the list request.
next_page_token:
Token to retrieve the next page of results, or empty if there
are no more results.
total_size:
The total number of findings matching the query.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.ListFindingsResponse)
),
)
_sym_db.RegisterMessage(ListFindingsResponse)
SetFindingStateRequest = _reflection.GeneratedProtocolMessageType(
"SetFindingStateRequest",
(_message.Message,),
dict(
DESCRIPTOR=_SETFINDINGSTATEREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for updating a finding's state.
Attributes:
name:
The relative resource name of the finding. See: https://cloud.
google.com/apis/design/resource\_names#relative\_resource\_nam
e Example: "organizations/123/sources/456/finding/789".
state:
The desired State of the finding.
start_time:
The time at which the updated state takes effect.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.SetFindingStateRequest)
),
)
_sym_db.RegisterMessage(SetFindingStateRequest)
RunAssetDiscoveryRequest = _reflection.GeneratedProtocolMessageType(
"RunAssetDiscoveryRequest",
(_message.Message,),
dict(
DESCRIPTOR=_RUNASSETDISCOVERYREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for running asset discovery for an organization.
Attributes:
parent:
Name of the organization to run asset discovery for. Its
format is "organizations/[organization\_id]".
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.RunAssetDiscoveryRequest)
),
)
_sym_db.RegisterMessage(RunAssetDiscoveryRequest)
UpdateFindingRequest = _reflection.GeneratedProtocolMessageType(
"UpdateFindingRequest",
(_message.Message,),
dict(
DESCRIPTOR=_UPDATEFINDINGREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for updating or creating a finding.
Attributes:
finding:
The finding resource to update or create if it does not
already exist. parent, security\_marks, and update\_time will
be ignored. In the case of creation, the finding id portion
of the name must alphanumeric and less than or equal to 32
characters and greater than 0 characters in length.
update_mask:
The FieldMask to use when updating the finding resource. This
field is ignored if the finding does not already exist and the
finding is created.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.UpdateFindingRequest)
),
)
_sym_db.RegisterMessage(UpdateFindingRequest)
UpdateOrganizationSettingsRequest = _reflection.GeneratedProtocolMessageType(
"UpdateOrganizationSettingsRequest",
(_message.Message,),
dict(
DESCRIPTOR=_UPDATEORGANIZATIONSETTINGSREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for updating an organization's settings.
Attributes:
organization_settings:
The organization settings resource to update.
update_mask:
The FieldMask to use when updating the settings resource.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.UpdateOrganizationSettingsRequest)
),
)
_sym_db.RegisterMessage(UpdateOrganizationSettingsRequest)
UpdateSourceRequest = _reflection.GeneratedProtocolMessageType(
"UpdateSourceRequest",
(_message.Message,),
dict(
DESCRIPTOR=_UPDATESOURCEREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for updating a source.
Attributes:
source:
The source resource to update.
update_mask:
The FieldMask to use when updating the source resource.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.UpdateSourceRequest)
),
)
_sym_db.RegisterMessage(UpdateSourceRequest)
UpdateSecurityMarksRequest = _reflection.GeneratedProtocolMessageType(
"UpdateSecurityMarksRequest",
(_message.Message,),
dict(
DESCRIPTOR=_UPDATESECURITYMARKSREQUEST,
__module__="google.cloud.securitycenter_v1beta1.proto.securitycenter_service_pb2",
__doc__="""Request message for updating a SecurityMarks resource.
Attributes:
security_marks:
The security marks resource to update.
update_mask:
The FieldMask to use when updating the security marks
resource.
start_time:
The time at which the updated SecurityMarks take effect.
""",
# @@protoc_insertion_point(class_scope:google.cloud.securitycenter.v1beta1.UpdateSecurityMarksRequest)
),
)
_sym_db.RegisterMessage(UpdateSecurityMarksRequest)
DESCRIPTOR.has_options = True
DESCRIPTOR._options = _descriptor._ParseOptions(
descriptor_pb2.FileOptions(),
_b(
"\n'com.google.cloud.securitycenter.v1beta1P\001ZQgoogle.golang.org/genproto/googleapis/cloud/securitycenter/v1beta1;securitycenter"
),
)
_GROUPRESULT_PROPERTIESENTRY.has_options = True
_GROUPRESULT_PROPERTIESENTRY._options = _descriptor._ParseOptions(
descriptor_pb2.MessageOptions(), _b("8\001")
)
_SECURITYCENTER = _descriptor.ServiceDescriptor(
name="SecurityCenter",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter",
file=DESCRIPTOR,
index=0,
options=None,
serialized_start=4076,
serialized_end=7660,
methods=[
_descriptor.MethodDescriptor(
name="CreateSource",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.CreateSource",
index=0,
containing_service=None,
input_type=_CREATESOURCEREQUEST,
output_type=google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_source__pb2._SOURCE,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
'\202\323\344\223\0023")/v1beta1/{parent=organizations/*}/sources:\006source'
),
),
),
_descriptor.MethodDescriptor(
name="CreateFinding",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.CreateFinding",
index=1,
containing_service=None,
input_type=_CREATEFINDINGREQUEST,
output_type=google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_finding__pb2._FINDING,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
'\202\323\344\223\002?"4/v1beta1/{parent=organizations/*/sources/*}/findings:\007finding'
),
),
),
_descriptor.MethodDescriptor(
name="GetIamPolicy",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.GetIamPolicy",
index=2,
containing_service=None,
input_type=google_dot_iam_dot_v1_dot_iam__policy__pb2._GETIAMPOLICYREQUEST,
output_type=google_dot_iam_dot_v1_dot_policy__pb2._POLICY,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
'\202\323\344\223\002?":/v1beta1/{resource=organizations/*/sources/*}:getIamPolicy:\001*'
),
),
),
_descriptor.MethodDescriptor(
name="GetOrganizationSettings",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.GetOrganizationSettings",
index=3,
containing_service=None,
input_type=_GETORGANIZATIONSETTINGSREQUEST,
output_type=google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_organization__settings__pb2._ORGANIZATIONSETTINGS,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
"\202\323\344\223\0026\0224/v1beta1/{name=organizations/*/organizationSettings}"
),
),
),
_descriptor.MethodDescriptor(
name="GetSource",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.GetSource",
index=4,
containing_service=None,
input_type=_GETSOURCEREQUEST,
output_type=google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_source__pb2._SOURCE,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
"\202\323\344\223\002+\022)/v1beta1/{name=organizations/*/sources/*}"
),
),
),
_descriptor.MethodDescriptor(
name="GroupAssets",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.GroupAssets",
index=5,
containing_service=None,
input_type=_GROUPASSETSREQUEST,
output_type=_GROUPASSETSRESPONSE,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
'\202\323\344\223\0023"./v1beta1/{parent=organizations/*}/assets:group:\001*'
),
),
),
_descriptor.MethodDescriptor(
name="GroupFindings",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.GroupFindings",
index=6,
containing_service=None,
input_type=_GROUPFINDINGSREQUEST,
output_type=_GROUPFINDINGSRESPONSE,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
'\202\323\344\223\002?":/v1beta1/{parent=organizations/*/sources/*}/findings:group:\001*'
),
),
),
_descriptor.MethodDescriptor(
name="ListAssets",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.ListAssets",
index=7,
containing_service=None,
input_type=_LISTASSETSREQUEST,
output_type=_LISTASSETSRESPONSE,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
"\202\323\344\223\002*\022(/v1beta1/{parent=organizations/*}/assets"
),
),
),
_descriptor.MethodDescriptor(
name="ListFindings",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.ListFindings",
index=8,
containing_service=None,
input_type=_LISTFINDINGSREQUEST,
output_type=_LISTFINDINGSRESPONSE,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
"\202\323\344\223\0026\0224/v1beta1/{parent=organizations/*/sources/*}/findings"
),
),
),
_descriptor.MethodDescriptor(
name="ListSources",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.ListSources",
index=9,
containing_service=None,
input_type=_LISTSOURCESREQUEST,
output_type=_LISTSOURCESRESPONSE,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
"\202\323\344\223\002+\022)/v1beta1/{parent=organizations/*}/sources"
),
),
),
_descriptor.MethodDescriptor(
name="RunAssetDiscovery",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.RunAssetDiscovery",
index=10,
containing_service=None,
input_type=_RUNASSETDISCOVERYREQUEST,
output_type=google_dot_longrunning_dot_operations__pb2._OPERATION,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
'\202\323\344\223\002:"5/v1beta1/{parent=organizations/*}/assets:runDiscovery:\001*'
),
),
),
_descriptor.MethodDescriptor(
name="SetFindingState",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.SetFindingState",
index=11,
containing_service=None,
input_type=_SETFINDINGSTATEREQUEST,
output_type=google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_finding__pb2._FINDING,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
'\202\323\344\223\002B"=/v1beta1/{name=organizations/*/sources/*/findings/*}:setState:\001*'
),
),
),
_descriptor.MethodDescriptor(
name="SetIamPolicy",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.SetIamPolicy",
index=12,
containing_service=None,
input_type=google_dot_iam_dot_v1_dot_iam__policy__pb2._SETIAMPOLICYREQUEST,
output_type=google_dot_iam_dot_v1_dot_policy__pb2._POLICY,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
'\202\323\344\223\002?":/v1beta1/{resource=organizations/*/sources/*}:setIamPolicy:\001*'
),
),
),
_descriptor.MethodDescriptor(
name="TestIamPermissions",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.TestIamPermissions",
index=13,
containing_service=None,
input_type=google_dot_iam_dot_v1_dot_iam__policy__pb2._TESTIAMPERMISSIONSREQUEST,
output_type=google_dot_iam_dot_v1_dot_iam__policy__pb2._TESTIAMPERMISSIONSRESPONSE,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
'\202\323\344\223\002E"@/v1beta1/{resource=organizations/*/sources/*}:testIamPermissions:\001*'
),
),
),
_descriptor.MethodDescriptor(
name="UpdateFinding",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.UpdateFinding",
index=14,
containing_service=None,
input_type=_UPDATEFINDINGREQUEST,
output_type=google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_finding__pb2._FINDING,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
"\202\323\344\223\002G2</v1beta1/{finding.name=organizations/*/sources/*/findings/*}:\007finding"
),
),
),
_descriptor.MethodDescriptor(
name="UpdateOrganizationSettings",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.UpdateOrganizationSettings",
index=15,
containing_service=None,
input_type=_UPDATEORGANIZATIONSETTINGSREQUEST,
output_type=google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_organization__settings__pb2._ORGANIZATIONSETTINGS,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
"\202\323\344\223\002c2J/v1beta1/{organization_settings.name=organizations/*/organizationSettings}:\025organization_settings"
),
),
),
_descriptor.MethodDescriptor(
name="UpdateSource",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.UpdateSource",
index=16,
containing_service=None,
input_type=_UPDATESOURCEREQUEST,
output_type=google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_source__pb2._SOURCE,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
"\202\323\344\223\002:20/v1beta1/{source.name=organizations/*/sources/*}:\006source"
),
),
),
_descriptor.MethodDescriptor(
name="UpdateSecurityMarks",
full_name="google.cloud.securitycenter.v1beta1.SecurityCenter.UpdateSecurityMarks",
index=17,
containing_service=None,
input_type=_UPDATESECURITYMARKSREQUEST,
output_type=google_dot_cloud_dot_securitycenter__v1beta1_dot_proto_dot_security__marks__pb2._SECURITYMARKS,
options=_descriptor._ParseOptions(
descriptor_pb2.MethodOptions(),
_b(
"\202\323\344\223\002\274\0012E/v1beta1/{security_marks.name=organizations/*/assets/*/securityMarks}:\016security_marksZc2Q/v1beta1/{security_marks.name=organizations/*/sources/*/findings/*/securityMarks}:\016security_marks"
),
),
),
],
)
_sym_db.RegisterServiceDescriptor(_SECURITYCENTER)
DESCRIPTOR.services_by_name["SecurityCenter"] = _SECURITYCENTER
# @@protoc_insertion_point(module_scope)
| 38.48368 | 10,592 | 0.64356 | [
"Apache-2.0"
] | Abd-Elrazek/google-cloud-python | securitycenter/google/cloud/securitycenter_v1beta1/proto/securitycenter_service_pb2.py | 116,721 | Python |