hexsha stringlengths 40 40 | size int64 3 1.03M | ext stringclasses 10
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 3 972 | max_stars_repo_name stringlengths 6 130 | max_stars_repo_head_hexsha stringlengths 40 78 | max_stars_repo_licenses listlengths 1 10 | max_stars_count int64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 3 972 | max_issues_repo_name stringlengths 6 130 | max_issues_repo_head_hexsha stringlengths 40 78 | max_issues_repo_licenses listlengths 1 10 | max_issues_count int64 1 116k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 3 972 | max_forks_repo_name stringlengths 6 130 | max_forks_repo_head_hexsha stringlengths 40 78 | max_forks_repo_licenses listlengths 1 10 | max_forks_count int64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 3 1.03M | avg_line_length float64 1.13 941k | max_line_length int64 2 941k | alphanum_fraction float64 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
75fc075cb2ef386121605b4a56a4add5335aea3c | 9,198 | py | Python | options/base_options.py | nguyennhuttin/cycleGAN_pix2pix | 6ef765ea119b9537ab87d63bf03e1df6e7349149 | [
"BSD-3-Clause"
] | null | null | null | options/base_options.py | nguyennhuttin/cycleGAN_pix2pix | 6ef765ea119b9537ab87d63bf03e1df6e7349149 | [
"BSD-3-Clause"
] | null | null | null | options/base_options.py | nguyennhuttin/cycleGAN_pix2pix | 6ef765ea119b9537ab87d63bf03e1df6e7349149 | [
"BSD-3-Clause"
] | null | null | null | import argparse
import os
from util import util
import torch
import models
import data
class BaseOptions():
"""This class defines options used during both training and test time.
It also implements several helper functions such as parsing, printing, and saving the options.
It also gathers additional options defined in <modify_commandline_options> functions in both dataset class and model class.
"""
def __init__(self):
"""Reset the class; indicates the class hasn't been initailized"""
self.initialized = False
def initialize(self, parser):
"""Define the common options that are used in both training and test."""
# basic parameters
parser.add_argument('--dataroot', required=True,
help='path to images (should have subfolders trainA, trainB, valA, valB, etc)')
parser.add_argument('--name', type=str, default='experiment_name',
help='name of the experiment. It decides where to store samples and models')
parser.add_argument(
'--use_wandb', action='store_true', help='use wandb')
parser.add_argument('--gpu_ids', type=str, default='0',
help='gpu ids: e.g. 0 0,1,2, 0,2. use -1 for CPU')
parser.add_argument('--checkpoints_dir', type=str,
default='./checkpoints', help='models are saved here')
# model parameters
parser.add_argument('--model', type=str, default='cycle_gan',
help='chooses which model to use. [cycle_gan | pix2pix | test | colorization]')
parser.add_argument('--input_nc', type=int, default=3,
help='# of input image channels: 3 for RGB and 1 for grayscale')
parser.add_argument('--output_nc', type=int, default=3,
help='# of output image channels: 3 for RGB and 1 for grayscale')
parser.add_argument('--ngf', type=int, default=64,
help='# of gen filters in the last conv layer')
parser.add_argument('--ndf', type=int, default=64,
help='# of discrim filters in the first conv layer')
parser.add_argument('--netD', type=str, default='basic',
help='specify discriminator architecture [basic | n_layers | pixel]. The basic model is a 70x70 PatchGAN. n_layers allows you to specify the layers in the discriminator')
parser.add_argument('--netG', type=str, default='resnet_9blocks',
help='specify generator architecture [resnet_9blocks | resnet_6blocks | unet_256 | unet_128]')
parser.add_argument('--n_layers_D', type=int,
default=3, help='only used if netD==n_layers')
parser.add_argument('--norm', type=str, default='instance',
help='instance normalization or batch normalization [instance | batch | none]')
parser.add_argument('--init_type', type=str, default='normal',
help='network initialization [normal | xavier | kaiming | orthogonal]')
parser.add_argument('--init_gain', type=float, default=0.02,
help='scaling factor for normal, xavier and orthogonal.')
parser.add_argument('--no_dropout', action='store_true',
help='no dropout for the generator')
# dataset parameters
parser.add_argument('--dataset_mode', type=str, default='unaligned',
help='chooses how datasets are loaded. [unaligned | aligned | single | colorization]')
parser.add_argument('--direction', type=str,
default='AtoB', help='AtoB or BtoA')
parser.add_argument('--serial_batches', action='store_true',
help='if true, takes images in order to make batches, otherwise takes them randomly')
parser.add_argument('--num_threads', default=4,
type=int, help='# threads for loading data')
parser.add_argument('--batch_size', type=int,
default=1, help='input batch size')
parser.add_argument('--load_size', type=int,
default=286, help='scale images to this size')
parser.add_argument('--crop_size', type=int,
default=256, help='then crop to this size')
parser.add_argument('--max_dataset_size', type=int, default=float("inf"),
help='Maximum number of samples allowed per dataset. If the dataset directory contains more than max_dataset_size, only a subset is loaded.')
parser.add_argument('--preprocess', type=str, default='resize_and_crop',
help='scaling and cropping of images at load time [resize_and_crop | crop | scale_width | scale_width_and_crop | none]')
parser.add_argument('--no_flip', action='store_true',
help='if specified, do not flip the images for data augmentation')
parser.add_argument('--display_winsize', type=int, default=256,
help='display window size for both visdom and HTML')
# additional parameters
parser.add_argument('--epoch', type=str, default='latest',
help='which epoch to load? set to latest to use latest cached model')
parser.add_argument('--load_iter', type=int, default='0',
help='which iteration to load? if load_iter > 0, the code will load models by iter_[load_iter]; otherwise, the code will load models by [epoch]')
parser.add_argument('--verbose', action='store_true',
help='if specified, print more debugging information')
parser.add_argument('--suffix', default='', type=str,
help='customized suffix: opt.name = opt.name + suffix: e.g., {model}_{netG}_size{load_size}')
self.initialized = True
# concat
parser.add_argument('--concat', action='store_true',
help='concat tool images')
return parser
def gather_options(self):
"""Initialize our parser with basic options(only once).
Add additional model-specific and dataset-specific options.
These options are defined in the <modify_commandline_options> function
in model and dataset classes.
"""
if not self.initialized: # check if it has been initialized
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser = self.initialize(parser)
# get the basic options
opt, _ = parser.parse_known_args()
# modify model-related parser options
model_name = opt.model
model_option_setter = models.get_option_setter(model_name)
parser = model_option_setter(parser, self.isTrain)
opt, _ = parser.parse_known_args() # parse again with new defaults
# modify dataset-related parser options
dataset_name = opt.dataset_mode
dataset_option_setter = data.get_option_setter(dataset_name)
parser = dataset_option_setter(parser, self.isTrain)
# save and return the parser
self.parser = parser
return parser.parse_args()
def print_options(self, opt):
"""Print and save options
It will print both current options and default values(if different).
It will save options into a text file / [checkpoints_dir] / opt.txt
"""
message = ''
message += '----------------- Options ---------------\n'
for k, v in sorted(vars(opt).items()):
comment = ''
default = self.parser.get_default(k)
if v != default:
comment = '\t[default: %s]' % str(default)
message += '{:>25}: {:<30}{}\n'.format(str(k), str(v), comment)
message += '----------------- End -------------------'
print(message)
# save to the disk
expr_dir = os.path.join(opt.checkpoints_dir, opt.name)
util.mkdirs(expr_dir)
file_name = os.path.join(expr_dir, '{}_opt.txt'.format(opt.phase))
with open(file_name, 'wt') as opt_file:
opt_file.write(message)
opt_file.write('\n')
def parse(self):
"""Parse our options, create checkpoints directory suffix, and set up gpu device."""
opt = self.gather_options()
opt.isTrain = self.isTrain # train or test
# process opt.suffix
if opt.suffix:
suffix = ('_' + opt.suffix.format(**vars(opt))
) if opt.suffix != '' else ''
opt.name = opt.name + suffix
self.print_options(opt)
# set gpu ids
str_ids = opt.gpu_ids.split(',')
opt.gpu_ids = []
for str_id in str_ids:
id = int(str_id)
if id >= 0:
opt.gpu_ids.append(id)
if len(opt.gpu_ids) > 0:
torch.cuda.set_device(opt.gpu_ids[0])
self.opt = opt
return self.opt
| 52.261364 | 198 | 0.593064 |
1eac733dfc4f89249cd0854f621b0e0fe146baa9 | 751 | py | Python | rj_gameplay/rj_gameplay/skill/seek.py | xiaoqingyu0113/robocup-software | 6127d25fc455051ef47610d0e421b2ca7330b4fa | [
"Apache-2.0"
] | null | null | null | rj_gameplay/rj_gameplay/skill/seek.py | xiaoqingyu0113/robocup-software | 6127d25fc455051ef47610d0e421b2ca7330b4fa | [
"Apache-2.0"
] | null | null | null | rj_gameplay/rj_gameplay/skill/seek.py | xiaoqingyu0113/robocup-software | 6127d25fc455051ef47610d0e421b2ca7330b4fa | [
"Apache-2.0"
] | null | null | null | import argparse
import py_trees
import sys
import time
from abc import ABC, abstractmethod
import stp.skill as skill
import stp.role as role
import stp.action as action
import stp.rc as rc
import numpy as np
from typing import Callable
class Seek(skill.ISkill):
"""
A seeker skill based off of some heuristic
"""
def __init__(self, role: role.Role, heuristic: Callable[np.array, float]) -> None:
# TODO: Properly implement using move action
pass
def tick(self, world_state: rc.WorldState, robot: rc.Robot) -> None:
# TODO: change so this properly returns the actions intent messages
pass
def __str__(self):
return f"Seek(robot={self.robot.id if self.robot is not None else '??'})"
| 25.033333 | 86 | 0.696405 |
7a9be60022a6897dfe3c5b7f39b70afa9e6c9232 | 4,201 | py | Python | cathetergen.py | srk1995/2D3DRegistration | 8d65d06c93532574d831055fce2d3f9bbe315f09 | [
"MIT"
] | 9 | 2020-09-16T16:29:28.000Z | 2021-07-28T11:23:09.000Z | cathetergen.py | srk1995/2D3DRegistration | 8d65d06c93532574d831055fce2d3f9bbe315f09 | [
"MIT"
] | null | null | null | cathetergen.py | srk1995/2D3DRegistration | 8d65d06c93532574d831055fce2d3f9bbe315f09 | [
"MIT"
] | 1 | 2020-09-24T07:37:27.000Z | 2020-09-24T07:37:27.000Z | import os
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = "4,5"
import torch
import numpy as np
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from utils import cartesian_product
import skeleton2
import utils
import visdom
def transform(img):
max_value = img.max()
img_tensor = torch.from_numpy(img.astype(np.int32))
img_tensor = img_tensor.float() / max_value
return img_tensor
class SegData(Dataset):
def __init__(self, root, train, transform):
"""
:param root: the path of data
:param transform: transforms to make the output tensor
"""
self.root = root
self.s = 1
self.dlist = [os.path.join(self.root, x) for x in os.listdir(root)]
self.transform = transform
self.zeros = np.array([0], dtype=np.float64).reshape(-1)
self.rotation = np.array([np.linspace(-30, 30, 15)] * self.s).reshape(-1)
self.translation = np.array([np.linspace(-5, 5, 3)] * self.s).reshape(-1)
self.label = cartesian_product(self.zeros, self.zeros, self.rotation, self.zeros, self.zeros, self.zeros)
self.CT = []
# self.drr_win = None
# self.vis = visdom.Visdom()
# self.num_samples = len(self.dlist)
if train:
file = open('train_zzz.csv', 'w')
else:
file = open('test_zzz.csv', 'w')
for f in self.dlist:
# path = os.path.join(f, 'xray')
# if not os.path.isdir(path):
# os.mkdir(path)
CT = os.path.join(f, 'numpy_RG_npy.npy')
CT = np.load(CT)
CT_out = np.expand_dims(np.array(CT, dtype=np.float32), axis=-1).transpose((3, 2, 1, 0))
CT_out = torch.tensor(CT_out)
catheter = []
while len(catheter) == 0:
a = skeleton2.mapping(CT)
skel = a.skel
xyz = np.where(skel == 1)
idx = np.random.randint(len(xyz[0]), size=2)
sp = np.array([xyz[0][idx[0]], xyz[1][idx[0]], xyz[2][idx[0]]])
fp = np.array([xyz[0][idx[1]], xyz[1][idx[1]], xyz[2][idx[1]]])
catheter = a.get_road(sp, fp)
catheter = np.array(catheter)
C = np.zeros_like(CT)
C[catheter[:, 0], catheter[:, 1], catheter[:, 2]] = 1
C = np.expand_dims(np.array(C, dtype=np.float32), axis=-1).transpose((3, 2, 1, 0))
C = torch.tensor(C)
# T = torch.zeros(6, dtype=torch.float32)
for i, T in enumerate(self.label, 1):
drr = utils.DRR_generation(C, torch.tensor(T, dtype=torch.float32).view(1, 6), 1, [256, 256])
drr_path = os.path.join(f, "{}_{}_{}_{}_{}_{}".format(str(T[0]), str(T[1]), str(T[2]), str(T[3]), str(T[4]), str(T[5])))
np.save(drr_path, drr.cpu().numpy())
# m = "{}_{}_{}_{}_{}_{}_{}\n".format(f, str(T[0]), str(T[1]), str(T[2]), str(T[3]), str(T[4]), str(T[5]))
# file.write(m)
# im = drr.view((960, 1240)).cpu().numpy()
# self.drr_win = utils.PlotImage(vis=self.vis, img=im, win=self.drr_win, title="DRR")
# ct_mean = torch.mean(CT_out)
# ct_std = torch.std(CT_out)
# CT_out = (CT_out - ct_mean) / ct_std
file.close()
def __getitem__(self, index):
"""
:param index:
:return: CT_out: [C, D, H, W] == [1, 393, 512, 512]
:return drr: [C, H, W]
:return T : [6]
"""
return 0
def __len__(self):
return self.label.size
if __name__ == "__main__":
# train_path = './registration/2D3D_Data/train'
# test_path = './registration/2D3D_Data/test'
train_path = '/home/srk1995/pub/db/Unet_1024/Train/'
test_path = '/home/srk1995/pub/db/Unet_1024/Test/'
# cTdataloader = Data(root, transform=transforms.ToTensor())
kdata_train = SegData(train_path, train=True, transform=transforms.ToTensor())
kdata_test = SegData(test_path, train=False, transform=transforms.ToTensor())
# for i, data in enumerate(trainloader):
# print(data)
print("EOP") | 35.008333 | 136 | 0.55701 |
6ef6eaa97ce29d52e2a80ccd1934783ebf608c2a | 6,062 | py | Python | video_structure/ops.py | pedersor/google-research | 6fa751dd261b3f6d918fd2cd35efef5d8bf3eea6 | [
"Apache-2.0"
] | null | null | null | video_structure/ops.py | pedersor/google-research | 6fa751dd261b3f6d918fd2cd35efef5d8bf3eea6 | [
"Apache-2.0"
] | null | null | null | video_structure/ops.py | pedersor/google-research | 6fa751dd261b3f6d918fd2cd35efef5d8bf3eea6 | [
"Apache-2.0"
] | null | null | null | # coding=utf-8
# Copyright 2022 The Google Research 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.
"""TensorFlow ops for the structured video representation model."""
import enum
import tensorflow.compat.v1 as tf
EPSILON = 1e-6 # Constant for numerical stability.
class Axis(enum.Enum):
"""Maps axes to image indices, assuming that 0th dimension is the batch."""
y = 1
x = 2
def maps_to_keypoints(heatmaps):
"""Turns feature-detector heatmaps into (x, y, scale) keypoints.
This function takes a tensor of feature maps as input. Each map is normalized
to a probability distribution and the location of the mean of the distribution
(in image coordinates) is computed. This location is used as a low-dimensional
representation of the heatmap (i.e. a keypoint).
To model keypoint presence/absence, the mean intensity of each feature map is
also computed, so that each keypoint is represented by an (x, y, scale)
triplet.
Args:
heatmaps: [batch_size, H, W, num_keypoints] tensors.
Returns:
A [batch_size, num_keypoints, 3] tensor with (x, y, scale)-triplets for each
keypoint. Coordinate range is [-1, 1] for x and y, and [0, 1] for scale.
"""
# Check that maps are non-negative:
map_min = tf.reduce_min(heatmaps)
assert_nonneg = tf.Assert(tf.greater_equal(map_min, 0.0), [map_min])
with tf.control_dependencies([assert_nonneg]):
heatmaps = tf.identity(heatmaps)
x_coordinates = _maps_to_coordinates(heatmaps, Axis.x)
y_coordinates = _maps_to_coordinates(heatmaps, Axis.y)
map_scales = tf.reduce_mean(heatmaps, axis=[1, 2])
# Normalize map scales to [0.0, 1.0] across keypoints. This removes a
# degeneracy between the encoder and decoder heatmap scales and ensures that
# the scales are in a reasonable range for the RNN:
map_scales /= (EPSILON + tf.reduce_max(map_scales, axis=-1, keepdims=True))
return tf.stack([x_coordinates, y_coordinates, map_scales], axis=-1)
def _maps_to_coordinates(maps, axis):
"""Reduces heatmaps to coordinates along one axis (x or y).
Args:
maps: [batch_size, H, W, num_keypoints] tensors.
axis: Axis Enum.
Returns:
A [batch_size, num_keypoints, 2] tensor with (x, y)-coordinates.
"""
width = maps.get_shape()[axis.value]
grid = _get_pixel_grid(axis, width)
shape = [1, 1, 1, 1]
shape[axis.value] = -1
grid = tf.reshape(grid, shape)
if axis == Axis.x:
marginalize_dim = 1
elif axis == Axis.y:
marginalize_dim = 2
# Normalize the heatmaps to a probability distribution (i.e. sum to 1):
weights = tf.reduce_sum(maps + EPSILON, axis=marginalize_dim, keep_dims=True)
weights /= tf.reduce_sum(weights, axis=axis.value, keep_dims=True)
# Compute the center of mass of the marginalized maps to obtain scalar
# coordinates:
coordinates = tf.reduce_sum(weights * grid, axis=axis.value, keep_dims=True)
return tf.squeeze(coordinates, axis=[1, 2])
def keypoints_to_maps(keypoints, sigma=1.0, heatmap_width=16):
"""Turns (x, y, scale)-tuples into pixel maps with a Gaussian blob at (x, y).
Args:
keypoints: [batch_size, num_keypoints, 3] tensor of keypoints where the last
dimension contains (x, y, scale) triplets.
sigma: Std. dev. of the Gaussian blob, in units of heatmap pixels.
heatmap_width: Width of output heatmaps in pixels.
Returns:
A [batch_size, heatmap_width, heatmap_width, num_keypoints] tensor.
"""
coordinates, map_scales = tf.split(keypoints, [2, 1], axis=-1)
def get_grid(axis):
grid = _get_pixel_grid(axis, heatmap_width)
shape = [1, 1, 1, 1]
shape[axis.value] = -1
return tf.reshape(grid, shape)
# Expand to [batch_size, 1, 1, num_keypoints] for broadcasting later:
x_coordinates = coordinates[:, tf.newaxis, tf.newaxis, :, 0]
y_coordinates = coordinates[:, tf.newaxis, tf.newaxis, :, 1]
# Create two 1-D Gaussian vectors (marginals) and multiply to get a 2-d map:
sigma = tf.cast(sigma, tf.float32)
keypoint_width = 2.0 * (sigma / heatmap_width) ** 2.0
x_vec = tf.exp(-tf.square(get_grid(Axis.x) - x_coordinates)/keypoint_width)
y_vec = tf.exp(-tf.square(get_grid(Axis.y) - y_coordinates)/keypoint_width)
maps = tf.multiply(x_vec, y_vec)
return maps * map_scales[:, tf.newaxis, tf.newaxis, :, 0]
def _get_pixel_grid(axis, width):
"""Returns an array of length `width` containing pixel coordinates."""
if axis == Axis.x:
return tf.linspace(-1.0, 1.0, width) # Left is negative, right is positive.
elif axis == Axis.y:
return tf.linspace(1.0, -1.0, width) # Top is positive, bottom is negative.
def add_coord_channels(image_tensor):
"""Adds channels containing pixel indices (x and y coordinates) to an image.
Note: This has nothing to do with keypoint coordinates. It is just a data
augmentation to allow convolutional networks to learn non-translation-
equivariant outputs. This is similar to the "CoordConv" layers:
https://arxiv.org/abs/1603.09382.
Args:
image_tensor: [batch_size, H, W, C] tensor.
Returns:
[batch_size, H, W, C + 2] tensor with x and y coordinate channels.
"""
batch_size = tf.shape(image_tensor)[0]
x_size = tf.shape(image_tensor)[2]
y_size = tf.shape(image_tensor)[1]
x_grid = tf.lin_space(-1.0, 1.0, x_size)
x_map = tf.tile(
x_grid[tf.newaxis, tf.newaxis, :, tf.newaxis], (batch_size, y_size, 1, 1))
y_grid = tf.lin_space(1.0, -1.0, y_size)
y_map = tf.tile(
y_grid[tf.newaxis, :, tf.newaxis, tf.newaxis], (batch_size, 1, x_size, 1))
return tf.concat([image_tensor, x_map, y_map], axis=-1)
| 35.450292 | 80 | 0.711151 |
5c3b7f2e6d7640b12d97cde00f45c8d4ae09f59c | 9,253 | py | Python | tencentcloud/aai/v20180522/models.py | liangzhengkang/tencentcloud-sdk-python | c8f990b33f3701e04149a3d613538829a88269eb | [
"Apache-2.0"
] | null | null | null | tencentcloud/aai/v20180522/models.py | liangzhengkang/tencentcloud-sdk-python | c8f990b33f3701e04149a3d613538829a88269eb | [
"Apache-2.0"
] | null | null | null | tencentcloud/aai/v20180522/models.py | liangzhengkang/tencentcloud-sdk-python | c8f990b33f3701e04149a3d613538829a88269eb | [
"Apache-2.0"
] | 1 | 2019-03-25T02:21:47.000Z | 2019-03-25T02:21:47.000Z | # -*- coding: utf8 -*-
# Copyright (c) 2017-2018 THL A29 Limited, a Tencent company. 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.
from tencentcloud.common.abstract_model import AbstractModel
class ChatRequest(AbstractModel):
"""Chat请求参数结构体
"""
def __init__(self):
"""
:param Text: 聊天输入文本
:type Text: str
:param ProjectId: 腾讯云项目 ID，可填 0，总长度不超过 1024 字节。
:type ProjectId: int
:param User: json格式，比如 {"id":"test","gender":"male"}。记录当前与机器人交互的用户id，非必须但强烈建议传入，否则多轮聊天功能会受影响
:type User: str
"""
self.Text = None
self.ProjectId = None
self.User = None
def _deserialize(self, params):
self.Text = params.get("Text")
self.ProjectId = params.get("ProjectId")
self.User = params.get("User")
class ChatResponse(AbstractModel):
"""Chat返回参数结构体
"""
def __init__(self):
"""
:param Answer: 聊天输出文本
:type Answer: str
:param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
:type RequestId: str
"""
self.Answer = None
self.RequestId = None
def _deserialize(self, params):
self.Answer = params.get("Answer")
self.RequestId = params.get("RequestId")
class SentenceRecognitionRequest(AbstractModel):
"""SentenceRecognition请求参数结构体
"""
def __init__(self):
"""
:param ProjectId: 腾讯云项目 ID，可填 0，总长度不超过 1024 字节。
:type ProjectId: int
:param SubServiceType: 子服务类型。2，一句话识别。
:type SubServiceType: int
:param EngSerViceType: 引擎类型。8k：电话 8k 通用模型；16k：16k 通用模型。只支持单声道音频识别。
:type EngSerViceType: str
:param SourceType: 语音数据来源。0：语音 URL；1：语音数据（post body）。
:type SourceType: int
:param VoiceFormat: 识别音频的音频格式（支持mp3,wav）。
:type VoiceFormat: str
:param UsrAudioKey: 用户端对此任务的唯一标识，用户自助生成，用于用户查找识别结果。
:type UsrAudioKey: str
:param Url: 语音 URL，公网可下载。当 SourceType 值为 0 时须填写该字段，为 1 时不填；URL 的长度大于 0，小于 2048，需进行urlencode编码。音频时间长度要小于60s。
:type Url: str
:param Data: 语音数据，当SourceType 值为1时必须填写，为0可不写。要base64编码(采用python语言时注意读取文件应该为string而不是byte，以byte格式读取后要decode()。编码后的数据不可带有回车换行符)。音频数据要小于600kB。
:type Data: str
:param DataLen: 数据长度，当 SourceType 值为1时必须填写，为0可不写（此数据长度为数据未进行base64编码时的数据长度）。
:type DataLen: int
"""
self.ProjectId = None
self.SubServiceType = None
self.EngSerViceType = None
self.SourceType = None
self.VoiceFormat = None
self.UsrAudioKey = None
self.Url = None
self.Data = None
self.DataLen = None
def _deserialize(self, params):
self.ProjectId = params.get("ProjectId")
self.SubServiceType = params.get("SubServiceType")
self.EngSerViceType = params.get("EngSerViceType")
self.SourceType = params.get("SourceType")
self.VoiceFormat = params.get("VoiceFormat")
self.UsrAudioKey = params.get("UsrAudioKey")
self.Url = params.get("Url")
self.Data = params.get("Data")
self.DataLen = params.get("DataLen")
class SentenceRecognitionResponse(AbstractModel):
"""SentenceRecognition返回参数结构体
"""
def __init__(self):
"""
:param Result: 识别结果。
:type Result: str
:param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
:type RequestId: str
"""
self.Result = None
self.RequestId = None
def _deserialize(self, params):
self.Result = params.get("Result")
self.RequestId = params.get("RequestId")
class SimultaneousInterpretingRequest(AbstractModel):
"""SimultaneousInterpreting请求参数结构体
"""
def __init__(self):
"""
:param ProjectId: 腾讯云项目 ID，可填 0，总长度不超过 1024 字节。
:type ProjectId: int
:param SubServiceType: 子服务类型。0：离线语音识别。1：实时流式识别，2，一句话识别。3：同传。
:type SubServiceType: int
:param RecEngineModelType: 识别引擎类型。8k_zh： 8k 中文会场模型；16k_zh：16k 中文会场模型，8k_en： 8k 英文会场模型；16k_en：16k 英文会场模型。当前仅支持16K。
:type RecEngineModelType: str
:param Data: 语音数据，要base64编码。
:type Data: str
:param DataLen: 数据长度。
:type DataLen: int
:param VoiceId: 声音id，标识一句话。
:type VoiceId: str
:param IsEnd: 是否是一句话的结束。
:type IsEnd: int
:param VoiceFormat: 声音编码的格式1:pcm，4:speex，6:silk，默认为1。
:type VoiceFormat: int
:param OpenTranslate: 是否需要翻译结果，1表示需要翻译，0是不需要。
:type OpenTranslate: int
:param SourceLanguage: 如果需要翻译，表示源语言类型，可取值：zh，en。
:type SourceLanguage: str
:param TargetLanguage: 如果需要翻译，表示目标语言类型，可取值：zh，en。
:type TargetLanguage: str
:param Seq: 表明当前语音分片的索引，从0开始
:type Seq: int
"""
self.ProjectId = None
self.SubServiceType = None
self.RecEngineModelType = None
self.Data = None
self.DataLen = None
self.VoiceId = None
self.IsEnd = None
self.VoiceFormat = None
self.OpenTranslate = None
self.SourceLanguage = None
self.TargetLanguage = None
self.Seq = None
def _deserialize(self, params):
self.ProjectId = params.get("ProjectId")
self.SubServiceType = params.get("SubServiceType")
self.RecEngineModelType = params.get("RecEngineModelType")
self.Data = params.get("Data")
self.DataLen = params.get("DataLen")
self.VoiceId = params.get("VoiceId")
self.IsEnd = params.get("IsEnd")
self.VoiceFormat = params.get("VoiceFormat")
self.OpenTranslate = params.get("OpenTranslate")
self.SourceLanguage = params.get("SourceLanguage")
self.TargetLanguage = params.get("TargetLanguage")
self.Seq = params.get("Seq")
class SimultaneousInterpretingResponse(AbstractModel):
"""SimultaneousInterpreting返回参数结构体
"""
def __init__(self):
"""
:param AsrText: 语音识别的结果
:type AsrText: str
:param NmtText: 机器翻译的结果
:type NmtText: str
:param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
:type RequestId: str
"""
self.AsrText = None
self.NmtText = None
self.RequestId = None
def _deserialize(self, params):
self.AsrText = params.get("AsrText")
self.NmtText = params.get("NmtText")
self.RequestId = params.get("RequestId")
class TextToVoiceRequest(AbstractModel):
"""TextToVoice请求参数结构体
"""
def __init__(self):
"""
:param Text: 合成语音的源文本
:type Text: str
:param SessionId: 一次请求对应一个SessionId，会原样返回，建议传入类似于uuid的字符串防止重复
:type SessionId: str
:param ModelType: 模型类型，1-默认模型
:type ModelType: int
:param Volume: 音量大小，范围：[0，10]，分别对应10个等级的音量，默认为0
:type Volume: float
:param Speed: 语速，范围：[-2，2]，分别对应不同语速：0.6倍，0.8倍，1.0倍，1.2倍，1.5倍，默认为0
:type Speed: float
:param ProjectId: 项目id，用户自定义，默认为0
:type ProjectId: int
:param VoiceType: 音色<li>0-女声1，亲和风格(默认)</li><li>1-男声1，成熟风格</li><li>2-男声2，成熟风格</li>
:type VoiceType: int
:param PrimaryLanguage: 主语言类型<li>1-中文，最大100个汉字（标点符号算一个汉子）</li><li>2-英文，最大支持400个字母（标点符号算一个字母）</li>
:type PrimaryLanguage: int
:param SampleRate: 音频采样率，16000：16k，8000：8k，默认16k
:type SampleRate: int
"""
self.Text = None
self.SessionId = None
self.ModelType = None
self.Volume = None
self.Speed = None
self.ProjectId = None
self.VoiceType = None
self.PrimaryLanguage = None
self.SampleRate = None
def _deserialize(self, params):
self.Text = params.get("Text")
self.SessionId = params.get("SessionId")
self.ModelType = params.get("ModelType")
self.Volume = params.get("Volume")
self.Speed = params.get("Speed")
self.ProjectId = params.get("ProjectId")
self.VoiceType = params.get("VoiceType")
self.PrimaryLanguage = params.get("PrimaryLanguage")
self.SampleRate = params.get("SampleRate")
class TextToVoiceResponse(AbstractModel):
"""TextToVoice返回参数结构体
"""
def __init__(self):
"""
:param Audio: base64编码的wav音频
:type Audio: str
:param SessionId: 一次请求对应一个SessionId
:type SessionId: str
:param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
:type RequestId: str
"""
self.Audio = None
self.SessionId = None
self.RequestId = None
def _deserialize(self, params):
self.Audio = params.get("Audio")
self.SessionId = params.get("SessionId")
self.RequestId = params.get("RequestId") | 31.688356 | 147 | 0.628121 |
1f1425617904942d6aa6ef8d30490d8a5db37fb6 | 1,366 | py | Python | ev3dev2simulator/robotpart/arm.py | jchmrt/ev3dev2simulator | 3a8968162d1658a82860a613caf9986c5428b124 | [
"MIT"
] | 2 | 2020-07-14T01:31:14.000Z | 2021-02-22T19:14:12.000Z | ev3dev2simulator/robotpart/arm.py | jchmrt/ev3dev2simulator | 3a8968162d1658a82860a613caf9986c5428b124 | [
"MIT"
] | 19 | 2020-02-16T08:11:23.000Z | 2020-12-10T10:06:36.000Z | ev3dev2simulator/robotpart/arm.py | jchmrt/ev3dev2simulator | 3a8968162d1658a82860a613caf9986c5428b124 | [
"MIT"
] | 10 | 2020-03-02T08:37:29.000Z | 2022-03-06T03:49:07.000Z | """
The module arm contains the small arm that is attached to the robot and not the one displayed in the sidebar.
"""
from ev3dev2simulator.config.config import get_simulation_settings
from ev3dev2simulator.robotpart.arm_large import ArmLarge
from ev3dev2simulator.robotpart.body_part import BodyPart
from ev3dev2simulator.util.dimensions import Dimensions
class Arm(BodyPart):
"""
Class representing the Arm of the simulated robot.
"""
def __init__(self, config, robot):
dims = get_simulation_settings()['body_part_sizes']['arm']
super(Arm, self).__init__(config, robot, Dimensions(dims['width'], dims['height']),
'arm', driver_name='lego-ev3-m-motor')
self.side_bar_arm = ArmLarge()
def setup_visuals(self, scale):
"""
Setup the visuals of the arm of the robot.
"""
vis_conf = get_simulation_settings()
self.init_sprite(vis_conf['image_paths']['arm'], scale)
def rotate_arm(self, degrees):
"""
Rotates the arm. As this cannot be seen on the robot, it is handled by the one displayed in the sidebar.
"""
self.side_bar_arm.rotate(degrees)
def reset(self):
"""
Reset the robot arm, by resetting the rotation of the arm shown in the sidebar.
"""
self.side_bar_arm.reset()
| 35.025641 | 112 | 0.661786 |
803cb78bfe75d5b9a6a9e402aefed90d66dcf021 | 409 | py | Python | color-depth-reduction/ImageNet/util.py | jfc43/pixel-discretization | 1543649e5172cb4f8226962a5ab5087091910418 | [
"Apache-2.0"
] | 6 | 2019-03-08T23:09:20.000Z | 2021-07-29T19:23:58.000Z | color-depth-reduction/ImageNet/util.py | jfc43/pixel-discretization | 1543649e5172cb4f8226962a5ab5087091910418 | [
"Apache-2.0"
] | null | null | null | color-depth-reduction/ImageNet/util.py | jfc43/pixel-discretization | 1543649e5172cb4f8226962a5ab5087091910418 | [
"Apache-2.0"
] | 1 | 2020-02-05T20:07:19.000Z | 2020-02-05T20:07:19.000Z | import numpy as np
from sklearn.neighbors import KDTree
def preprocess(images0, codes):
images = np.copy(images0).astype(float)
kd = KDTree(codes, metric='infinity')
new_images = []
for img in images:
points = img.reshape(-1,1)
inds = np.squeeze(kd.query(points,return_distance=False))
new_images.append(codes[inds].reshape(img.shape))
return np.array(new_images)
| 31.461538 | 65 | 0.684597 |
1465a8b1c3636397a9c3d4d22434c3a047cb9994 | 2,427 | py | Python | aliyun-python-sdk-hbr/aliyunsdkhbr/request/v20170908/UpdateHanaBackupPlanRequest.py | yndu13/aliyun-openapi-python-sdk | 12ace4fb39fe2fb0e3927a4b1b43ee4872da43f5 | [
"Apache-2.0"
] | 1,001 | 2015-07-24T01:32:41.000Z | 2022-03-25T01:28:18.000Z | aliyun-python-sdk-hbr/aliyunsdkhbr/request/v20170908/UpdateHanaBackupPlanRequest.py | yndu13/aliyun-openapi-python-sdk | 12ace4fb39fe2fb0e3927a4b1b43ee4872da43f5 | [
"Apache-2.0"
] | 363 | 2015-10-20T03:15:00.000Z | 2022-03-08T12:26:19.000Z | aliyun-python-sdk-hbr/aliyunsdkhbr/request/v20170908/UpdateHanaBackupPlanRequest.py | yndu13/aliyun-openapi-python-sdk | 12ace4fb39fe2fb0e3927a4b1b43ee4872da43f5 | [
"Apache-2.0"
] | 682 | 2015-09-22T07:19:02.000Z | 2022-03-22T09:51:46.000Z | # Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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 aliyunsdkcore.request import RpcRequest
from aliyunsdkhbr.endpoint import endpoint_data
class UpdateHanaBackupPlanRequest(RpcRequest):
def __init__(self):
RpcRequest.__init__(self, 'hbr', '2017-09-08', 'UpdateHanaBackupPlan','hbr')
self.set_protocol_type('https')
self.set_method('POST')
if hasattr(self, "endpoint_map"):
setattr(self, "endpoint_map", endpoint_data.getEndpointMap())
if hasattr(self, "endpoint_regional"):
setattr(self, "endpoint_regional", endpoint_data.getEndpointRegional())
def get_VaultId(self):
return self.get_query_params().get('VaultId')
def set_VaultId(self,VaultId):
self.add_query_param('VaultId',VaultId)
def get_ClusterId(self):
return self.get_query_params().get('ClusterId')
def set_ClusterId(self,ClusterId):
self.add_query_param('ClusterId',ClusterId)
def get_Token(self):
return self.get_query_params().get('Token')
def set_Token(self,Token):
self.add_query_param('Token',Token)
def get_Schedule(self):
return self.get_query_params().get('Schedule')
def set_Schedule(self,Schedule):
self.add_query_param('Schedule',Schedule)
def get_BackupPrefix(self):
return self.get_query_params().get('BackupPrefix')
def set_BackupPrefix(self,BackupPrefix):
self.add_query_param('BackupPrefix',BackupPrefix)
def get_PlanName(self):
return self.get_query_params().get('PlanName')
def set_PlanName(self,PlanName):
self.add_query_param('PlanName',PlanName)
def get_PlanId(self):
return self.get_query_params().get('PlanId')
def set_PlanId(self,PlanId):
self.add_query_param('PlanId',PlanId) | 32.36 | 79 | 0.754841 |
c65efb5286702e3f2918514419b43371ca216446 | 266 | py | Python | asecop/asecop/doctype/margen_ganancias_sec/margen_ganancias_sec.py | edwinorlando83/asecop | 950930feb0dea98e739e58809a9a36f732dd695c | [
"MIT"
] | null | null | null | asecop/asecop/doctype/margen_ganancias_sec/margen_ganancias_sec.py | edwinorlando83/asecop | 950930feb0dea98e739e58809a9a36f732dd695c | [
"MIT"
] | null | null | null | asecop/asecop/doctype/margen_ganancias_sec/margen_ganancias_sec.py | edwinorlando83/asecop | 950930feb0dea98e739e58809a9a36f732dd695c | [
"MIT"
] | 2 | 2021-05-06T14:59:24.000Z | 2021-08-20T21:21:20.000Z | # -*- coding: utf-8 -*-
# Copyright (c) 2021, orlando and contributors
# For license information, please see license.txt
from __future__ import unicode_literals
# import frappe
from frappe.model.document import Document
class margen_ganancias_sec(Document):
pass
| 24.181818 | 49 | 0.781955 |
5d3dd67ae8950efcc5c53836ac4df2e26320d939 | 2,185 | py | Python | app/db/asyncdb/workspace_repository.py | PSE-TECO-2020-TEAM1/e2e-ml_model-management | 7f01a008648e25a29c639a5e16124b2e399eb821 | [
"MIT"
] | 1 | 2021-05-04T08:46:19.000Z | 2021-05-04T08:46:19.000Z | app/db/asyncdb/workspace_repository.py | PSE-TECO-2020-TEAM1/e2e-ml_model-management | 7f01a008648e25a29c639a5e16124b2e399eb821 | [
"MIT"
] | null | null | null | app/db/asyncdb/workspace_repository.py | PSE-TECO-2020-TEAM1/e2e-ml_model-management | 7f01a008648e25a29c639a5e16124b2e399eb821 | [
"MIT"
] | 1 | 2022-01-28T21:21:32.000Z | 2022-01-28T21:21:32.000Z | from app.ml.training.training_state import TrainingState
from enum import Enum
from typing import Any
from app.models.domain.sensor import SensorComponent
from app.core.config import WORKSPACE_COLLECTION_NAME
from motor.motor_asyncio import AsyncIOMotorCollection, AsyncIOMotorDatabase
from bson.objectid import ObjectId
from app.models.domain.workspace import Workspace
from app.db.error.non_existent_error import NonExistentError
import dacite
class WorkspaceRepository():
def __init__(self, db: AsyncIOMotorDatabase):
self.collection: AsyncIOMotorCollection = db[WORKSPACE_COLLECTION_NAME]
async def get_workspace(self, workspace_id: ObjectId) -> Workspace:
workspace = await self.collection.find_one({"_id": workspace_id})
if workspace is None:
raise NonExistentError("Workspace with the given id does not exist")
return dacite.from_dict(data_class=Workspace, data=workspace, config=dacite.Config(cast=[SensorComponent, Enum]))
async def workspace_exists(self, workspace_id: ObjectId) -> bool:
return bool(await self.collection.find_one({"_id": workspace_id}))
async def add_workspace(self, workspace: Workspace) -> ObjectId:
workspace_dict = workspace.dict_for_db_insertion()
result = await self.collection.insert_one(workspace_dict)
if not result:
raise NonExistentError("Could not add workspace because of a database error")
return result.inserted_id
async def set_workspace_field(self, workspace_id: ObjectId, field: str, value: Any):
"""
field with dot notation
"""
result = await self.collection.update_one({"_id": workspace_id}, {"$set": {field: value}})
if not result:
raise NonExistentError("Could not set " + field)
async def set_training_state(self, workspace_id: ObjectId, training_state: TrainingState):
await self.set_workspace_field(workspace_id, "training_state", training_state)
async def delete_ml_model_ref(self, workspace_id: ObjectId, ml_model_ref: ObjectId):
await self.collection.update_one({"_id": workspace_id}, {"$pull": {"ml_model_refs": ml_model_ref}})
| 47.5 | 121 | 0.740961 |
7a98140ad60b38bdf1ca9179f08406df3e59decf | 428 | py | Python | Tutorial/Tkinter/Tkinter Label_Get Fonts List.py | DelftStack/DelftStack | a714bfe9c144e08915547109bb1e95b9907fa1ba | [
"MIT"
] | 5 | 2020-09-24T11:40:10.000Z | 2022-01-30T05:16:04.000Z | Tutorial/Tkinter/Tkinter Label_Get Fonts List.py | DelftStack/DelftStack | a714bfe9c144e08915547109bb1e95b9907fa1ba | [
"MIT"
] | null | null | null | Tutorial/Tkinter/Tkinter Label_Get Fonts List.py | DelftStack/DelftStack | a714bfe9c144e08915547109bb1e95b9907fa1ba | [
"MIT"
] | null | null | null | #!/usr/bin
# -*- coding: utf-8 -*-
"""
DelftStack Python Tkinter Tutorial
Author: Jinku Hu
URL: https://www.delftstack.com/tutorial/tkinter-tutorial/tkinter-label/
Website: https://www.delftstack.com
"""
from sys import version_info
if version_info.major == 2:
import Tkinter as tk
elif version_info.major == 3:
import tkinter as tk
import tkFont
from pprint import pprint
app = tk.Tk()
pprint(tkFont.families()) | 20.380952 | 72 | 0.721963 |
81245755037eae3c562e63629474c57e048f8ad5 | 14,441 | py | Python | faker/providers/python/__init__.py | mgorny/faker | b1176e01bf4d7f1aef408a4bb96a9e46188cc113 | [
"MIT"
] | 12,077 | 2015-01-01T18:30:07.000Z | 2022-03-31T23:22:01.000Z | faker/providers/python/__init__.py | mgorny/faker | b1176e01bf4d7f1aef408a4bb96a9e46188cc113 | [
"MIT"
] | 1,306 | 2015-01-03T05:18:55.000Z | 2022-03-31T02:43:04.000Z | faker/providers/python/__init__.py | mgorny/faker | b1176e01bf4d7f1aef408a4bb96a9e46188cc113 | [
"MIT"
] | 1,855 | 2015-01-08T14:20:10.000Z | 2022-03-25T17:23:32.000Z | import math
import string
import sys
import warnings
from decimal import Decimal
from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, Union, no_type_check
from .. import BaseProvider, ElementsType
ValueTypes = Optional[Union[List[str], Tuple[str, ...]]]
class Provider(BaseProvider):
default_value_types: ElementsType = (
'str', 'str', 'str', 'str', 'float', 'int', 'int', 'decimal',
'date_time', 'uri', 'email',
)
def _check_signature(self, value_types: ValueTypes, allowed_types: Tuple[str]) -> Tuple[str, ...]:
if value_types is not None and not isinstance(value_types, (list, tuple)):
value_types = [value_types]
warnings.warn(
'Passing value types as positional arguments is going to be '
'deprecated. Pass them as a list or tuple instead.',
PendingDeprecationWarning,
)
if value_types is None:
value_types = ()
return tuple(value_types) + allowed_types
def pybool(self):
return self.random_int(0, 1) == 1
def pystr(self, min_chars=None, max_chars=20):
"""
Generates a random string of upper and lowercase letters.
:type min_chars: int
:type max_chars: int
:return: String. Random of random length between min and max characters.
"""
if min_chars is None:
return "".join(self.random_letters(length=max_chars))
else:
assert (
max_chars >= min_chars), "Maximum length must be greater than or equal to minimum length"
return "".join(
self.random_letters(
length=self.generator.random.randint(min_chars, max_chars),
),
)
def pystr_format(self, string_format='?#-###{{random_int}}{{random_letter}}', letters=string.ascii_letters):
return self.bothify(self.generator.parse(string_format), letters=letters)
def pyfloat(self, left_digits=None, right_digits=None, positive=False,
min_value=None, max_value=None):
if left_digits is not None and left_digits < 0:
raise ValueError(
'A float number cannot have less than 0 digits in its '
'integer part')
if right_digits is not None and right_digits < 0:
raise ValueError(
'A float number cannot have less than 0 digits in its '
'fractional part')
if left_digits == 0 and right_digits == 0:
raise ValueError(
'A float number cannot have less than 0 digits in total')
if None not in (min_value, max_value) and min_value > max_value:
raise ValueError('Min value cannot be greater than max value')
if None not in (min_value, max_value) and min_value == max_value:
raise ValueError('Min and max value cannot be the same')
if positive and min_value is not None and min_value <= 0:
raise ValueError(
'Cannot combine positive=True with negative or zero min_value')
if left_digits is not None and max_value and math.ceil(math.log10(abs(max_value))) > left_digits:
raise ValueError('Max value must fit within left digits')
if left_digits is not None and min_value and math.ceil(math.log10(abs(min_value))) > left_digits:
raise ValueError('Min value must fit within left digits')
# Make sure at least either left or right is set
if left_digits is None and right_digits is None:
needed_left_digits = max(1, math.ceil(math.log10(max(abs(max_value or 1), abs(min_value or 1)))))
right_digits = self.random_int(1, sys.float_info.dig - needed_left_digits)
# If only one side is set, choose #digits for other side
if (left_digits is None) ^ (right_digits is None):
if left_digits is None:
left_digits = max(1, sys.float_info.dig - right_digits)
else:
right_digits = max(1, sys.float_info.dig - left_digits)
# Make sure we don't ask for too many digits!
if left_digits + right_digits > sys.float_info.dig:
raise ValueError(
f'Asking for too many digits ({left_digits} + {right_digits} == {left_digits + right_digits} > '
f'{sys.float_info.dig})',
)
sign = ''
if (min_value is not None) or (max_value is not None):
# Make sure left_digits still respected
if left_digits is not None:
if max_value is None:
max_value = 10 ** left_digits # minus smallest representable, adjusted later
if min_value is None:
min_value = -(10 ** left_digits) # plus smallest representable, adjusted later
if max_value is not None and max_value < 0:
max_value += 1 # as the random_int will be generated up to max_value - 1
if min_value is not None and min_value < 0:
min_value += 1 # as we then append digits after the left_number
left_number = self._safe_random_int(
min_value, max_value, positive,
)
else:
sign = '+' if positive else self.random_element(('+', '-'))
left_number = self.random_number(left_digits)
result = float(f'{sign}{left_number}.{self.random_number(right_digits)}')
if positive and result == 0:
if right_digits:
result = float('0.' + '0' * (right_digits - 1) + '1')
else:
result += sys.float_info.epsilon
if right_digits:
result = min(result, 10 ** left_digits - float(f'0.{"0" * (right_digits - 1)}1'))
result = max(result, -(10 ** left_digits + float(f'0.{"0" * (right_digits - 1)}1')))
else:
result = min(result, 10 ** left_digits - 1)
result = max(result, -(10 ** left_digits + 1))
return result
def _safe_random_int(self, min_value, max_value, positive):
orig_min_value = min_value
orig_max_value = max_value
if min_value is None:
min_value = max_value - self.random_int()
if max_value is None:
max_value = min_value + self.random_int()
if positive:
min_value = max(min_value, 0)
if min_value == max_value:
return self._safe_random_int(orig_min_value, orig_max_value, positive)
else:
return self.random_int(min_value, max_value - 1)
def pyint(self, min_value=0, max_value=9999, step=1):
return self.generator.random_int(min_value, max_value, step=step)
def pydecimal(self, left_digits=None, right_digits=None, positive=False,
min_value=None, max_value=None):
if left_digits is not None and left_digits < 0:
raise ValueError(
'A decimal number cannot have less than 0 digits in its '
'integer part')
if right_digits is not None and right_digits < 0:
raise ValueError(
'A decimal number cannot have less than 0 digits in its '
'fractional part')
if (left_digits is not None and left_digits == 0) and (right_digits is not None and right_digits == 0):
raise ValueError(
'A decimal number cannot have 0 digits in total')
if None not in (min_value, max_value) and min_value > max_value:
raise ValueError('Min value cannot be greater than max value')
if None not in (min_value, max_value) and min_value == max_value:
raise ValueError('Min and max value cannot be the same')
if positive and min_value is not None and min_value <= 0:
raise ValueError(
'Cannot combine positive=True with negative or zero min_value')
if left_digits is not None and max_value and math.ceil(math.log10(abs(max_value))) > left_digits:
raise ValueError('Max value must fit within left digits')
if left_digits is not None and min_value and math.ceil(math.log10(abs(min_value))) > left_digits:
raise ValueError('Min value must fit within left digits')
# if either left or right digits are not specified we randomly choose a length
max_random_digits = 100
minimum_left_digits = len(str(min_value)) if min_value is not None else 1
if left_digits is None and right_digits is None:
right_digits = self.random_int(1, max_random_digits)
left_digits = self.random_int(minimum_left_digits, max_random_digits)
if left_digits is not None and right_digits is None:
right_digits = self.random_int(1, max_random_digits)
if left_digits is None and right_digits is not None:
left_digits = self.random_int(minimum_left_digits, max_random_digits)
left_number = ''.join([str(self.random_digit()) for i in range(0, left_digits)]) or '0'
if right_digits is not None:
right_number = ''.join([str(self.random_digit()) for i in range(0, right_digits)])
else:
right_number = ''
if min_value is not None and min_value >= 0:
sign = '+'
elif max_value is not None and max_value <= 0:
sign = '-'
else:
sign = '+' if positive else self.random_element(('+', '-'))
result = Decimal(f'{sign}{left_number}.{right_number}')
# Because the random result might have the same number of decimals as max_value the random number
# might be above max_value or below min_value
if max_value is not None and result > max_value:
result = Decimal(max_value)
if min_value is not None and result < min_value:
result = Decimal(min_value)
return result
def pytuple(self, nb_elements=10, variable_nb_elements=True, value_types=None, *allowed_types):
return tuple(
self._pyiterable(
nb_elements,
variable_nb_elements,
value_types,
*allowed_types))
def pyset(self, nb_elements=10, variable_nb_elements=True, value_types=None, *allowed_types):
return set(
self._pyiterable(
nb_elements,
variable_nb_elements,
value_types,
*allowed_types))
def pylist(self, nb_elements=10, variable_nb_elements=True, value_types=None, *allowed_types):
return list(
self._pyiterable(
nb_elements,
variable_nb_elements,
value_types,
*allowed_types))
@no_type_check
def pyiterable(
self,
nb_elements: int = 10,
variable_nb_elements: bool = True,
value_types: ValueTypes = None,
*allowed_types: str) -> Iterable[Any]:
value_types = self._check_signature(value_types, allowed_types)
return self.random_element([self.pylist, self.pytuple, self.pyset])(
nb_elements, variable_nb_elements, value_types, *allowed_types)
def _random_type(self, type_list: List[str]) -> str:
value_type: str = self.random_element(type_list)
method_name = f'py{value_type}'
if hasattr(self, method_name):
value_type = method_name
return self.generator.format(value_type)
def _pyiterable(
self,
nb_elements: int = 10,
variable_nb_elements: bool = True,
value_types: ValueTypes = None,
*allowed_types: str) -> Iterator:
value_types = self._check_signature(value_types, allowed_types) # type: ignore
value_types = [t if isinstance(t, str) else getattr(t, '__name__', type(t).__name__).lower()
for t in value_types
# avoid recursion
if t not in ['iterable', 'list', 'tuple', 'dict', 'set']]
if not value_types:
value_types = self.default_value_types # type: ignore
if variable_nb_elements:
nb_elements = self.randomize_nb_elements(nb_elements, min=1)
for _ in range(nb_elements):
yield self._random_type(value_types)
def pydict(self, nb_elements=10, variable_nb_elements=True, value_types=None, *allowed_types):
"""
Returns a dictionary.
:nb_elements: number of elements for dictionary
:variable_nb_elements: is use variable number of elements for dictionary
:value_types: type of dictionary values
"""
if variable_nb_elements:
nb_elements = self.randomize_nb_elements(nb_elements, min=1)
return dict(zip(
self.generator.words(nb_elements, unique=True),
self._pyiterable(nb_elements, False, value_types, *allowed_types),
))
def pystruct(self, count: int = 10, value_types: ValueTypes = None, *allowed_types: str) -> Tuple[List, Dict, Dict]:
value_types = self._check_signature(value_types, allowed_types) # type: ignore
value_types = [t if isinstance(t, str) else getattr(t, '__name__', type(t).__name__).lower()
for t in value_types
# avoid recursion
if t != 'struct']
if not value_types:
value_types = self.default_value_types # type: ignore
types = []
d = {}
nd = {}
for i in range(count):
d[self.generator.word()] = self._random_type(value_types)
types.append(self._random_type(value_types))
nd[self.generator.word()] = {i: self._random_type(value_types),
i + 1: [self._random_type(value_types),
self._random_type(value_types),
self._random_type(value_types)],
i + 2: {i: self._random_type(value_types),
i + 1: self._random_type(value_types),
i + 2: [self._random_type(value_types),
self._random_type(value_types)]}}
return types, d, nd
| 44.847826 | 120 | 0.598297 |
c1a628e3a20adf3cfa2971c52e313fca0ae3af95 | 11,939 | py | Python | src/sage/plot/arc.py | bopopescu/sage-5 | 9d85b34956ca2edd55af307f99c5d3859acd30bf | [
"BSL-1.0"
] | 5 | 2015-01-04T07:15:06.000Z | 2022-03-04T15:15:18.000Z | src/sage/plot/arc.py | bopopescu/sage-5 | 9d85b34956ca2edd55af307f99c5d3859acd30bf | [
"BSL-1.0"
] | null | null | null | src/sage/plot/arc.py | bopopescu/sage-5 | 9d85b34956ca2edd55af307f99c5d3859acd30bf | [
"BSL-1.0"
] | 10 | 2016-09-28T13:12:40.000Z | 2022-02-12T09:28:34.000Z | """
Arcs of circles and ellipses
"""
#*****************************************************************************
# Copyright (C) 2010 Vincent Delecroix <20100.delecroix@gmail.com>,
#
# Distributed under the terms of the GNU General Public License (GPL)
#
# This code is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# The full text of the GPL is available at:
#
# http://www.gnu.org/licenses/
#*****************************************************************************
from sage.plot.primitive import GraphicPrimitive
from sage.plot.colors import to_mpl_color
from sage.plot.misc import options, rename_keyword
from math import fmod, sin, cos, pi, atan
class Arc(GraphicPrimitive):
"""
Primitive class for the Arc graphics type. See ``arc?`` for information
about actually plotting an arc of a circle or an ellipse.
INPUT:
- ``x,y`` - coordinates of the center of the arc
- ``r1``, ``r2`` - lengths of the two radii
- ``angle`` - angle of the horizontal with width
- ``sector`` - sector of angle
- ``options`` - dict of valid plot options to pass to constructor
EXAMPLES:
Note that the construction should be done using ``arc``::
sage: from sage.plot.arc import Arc
sage: print Arc(0,0,1,1,pi/4,pi/4,pi/2,{})
Arc with center (0.0,0.0) radii (1.0,1.0) angle 0.785398163397 inside the sector (0.785398163397,1.57079632679)
"""
def __init__(self, x, y, r1, r2, angle, s1, s2, options):
"""
Initializes base class ``Arc``.
EXAMPLES:
sage: A = arc((2,3),1,1,pi/4,(0,pi))
sage: A[0].x == 2
True
sage: A[0].y == 3
True
sage: A[0].r1 == 1
True
sage: A[0].r2 == 1
True
sage: bool(A[0].angle == pi/4)
True
sage: bool(A[0].s1 == 0)
True
sage: bool(A[0].s2 == pi)
True
TESTS::
sage: from sage.plot.arc import Arc
sage: a = Arc(0,0,1,1,0,0,1,{})
sage: print loads(dumps(a))
Arc with center (0.0,0.0) radii (1.0,1.0) angle 0.0 inside the sector (0.0,1.0)
"""
self.x = float(x)
self.y = float(y)
self.r1 = float(r1)
self.r2 = float(r2)
if self.r1 <= 0 or self.r2 <= 0:
raise ValueError, "the radii must be positive real numbers."
self.angle = float(angle)
self.s1 = float(s1)
self.s2 = float(s2)
if self.s2 < self.s1:
self.s1,self.s2=self.s2,self.s1
GraphicPrimitive.__init__(self, options)
def get_minmax_data(self):
"""
Returns a dictionary with the bounding box data.
The bounding box is computed as minimal as possible.
EXAMPLES:
An example without angle::
sage: p = arc((-2, 3), 1, 2)
sage: d = p.get_minmax_data()
sage: d['xmin']
-3.0
sage: d['xmax']
-1.0
sage: d['ymin']
1.0
sage: d['ymax']
5.0
The same example with a rotation of angle `\pi/2`::
sage: p = arc((-2, 3), 1, 2, pi/2)
sage: d = p.get_minmax_data()
sage: d['xmin']
-4.0
sage: d['xmax']
0.0
sage: d['ymin']
2.0
sage: d['ymax']
4.0
"""
from sage.plot.plot import minmax_data
twopi = 2*pi
s1 = self.s1
s2 = self.s2
s = s2-s1
s1 = fmod(s1,twopi)
if s1 < 0: s1 += twopi
s2 = fmod(s1 + s,twopi)
if s2 < 0: s2 += twopi
r1 = self.r1
r2 = self.r2
angle = fmod(self.angle,twopi)
if angle < 0: angle += twopi
epsilon = float(0.0000001)
cos_angle = cos(angle)
sin_angle = sin(angle)
if cos_angle > 1-epsilon:
xmin=-r1; ymin=-r2
xmax=r1; ymax=r2
axmin = pi; axmax = 0
aymin = 3*pi/2; aymax = pi/2
elif cos_angle < -1+epsilon:
xmin=-r1; ymin=-r2
xmax=r1; ymax=r2
axmin=0; axmax=pi
aymin=pi/2; aymax=3*pi/2
elif sin_angle > 1-epsilon:
xmin=-r2; ymin=-r1
xmax=r2; ymax=r1
axmin = pi/2; axmax = 3*pi/2
aymin = pi; aymax = 0
elif sin_angle < -1+epsilon:
xmin=-r2; ymin=-r1
xmax=r2; ymax=r1
axmin = 3*pi/2; axmax = pi/2
aymin = 0; aymax = pi
else:
tan_angle = sin_angle / cos_angle
axmax = atan(-r2/r1*tan_angle)
if axmax < 0: axmax += twopi
xmax = (
r1 * cos_angle * cos(axmax) -
r2 * sin_angle * sin(axmax))
if xmax < 0:
xmax = -xmax
axmax = fmod(axmax+pi,twopi)
xmin = -xmax
axmin = fmod(axmax + pi,twopi)
aymax = atan(r2/(r1*tan_angle))
if aymax < 0: aymax += twopi
ymax = (
r1 * sin_angle * cos(aymax) +
r2 * cos_angle * sin(aymax))
if ymax < 0:
ymax = -ymax
aymax = fmod(aymax+pi,twopi)
ymin = -ymax
aymin = fmod(aymax + pi, twopi)
if s < twopi-epsilon: # bb determined by the sector
def is_cyclic_ordered(x1,x2,x3):
return (
(x1 < x2 and x2 < x3) or
(x2 < x3 and x3 < x1) or
(x3 < x1 and x1 < x2))
x1 = cos_angle*r1*cos(s1) - sin_angle*r2*sin(s1)
x2 = cos_angle*r1*cos(s2) - sin_angle*r2*sin(s2)
y1 = sin_angle*r1*cos(s1) + cos_angle*r2*sin(s1)
y2 = sin_angle*r1*cos(s2) + cos_angle*r2*sin(s2)
if is_cyclic_ordered(s1,s2,axmin): xmin = min(x1,x2)
if is_cyclic_ordered(s1,s2,aymin): ymin = min(y1,y2)
if is_cyclic_ordered(s1,s2,axmax): xmax = max(x1,x2)
if is_cyclic_ordered(s1,s2,aymax): ymax = max(y1,y2)
return minmax_data([self.x + xmin, self.x + xmax],
[self.y + ymin, self.y + ymax],
dict=True)
def _allowed_options(self):
"""
Return the allowed options for the ``Arc`` class.
EXAMPLES::
sage: p = arc((3, 3), 1, 1)
sage: p[0]._allowed_options()['alpha']
'How transparent the figure is.'
"""
return {'alpha':'How transparent the figure is.',
'thickness':'How thick the border of the arc is.',
'hue':'The color given as a hue.',
'rgbcolor':'The color',
'zorder':'2D only: The layer level in which to draw',
'linestyle':"2D only: The style of the line, which is one of "
"'dashed', 'dotted', 'solid', 'dashdot', or '--', ':', '-', '-.', "
"respectively."}
def _repr_(self):
"""
String representation of ``Arc`` primitive.
EXAMPLES::
sage: from sage.plot.arc import Arc
sage: print Arc(2,3,2.2,2.2,0,2,3,{})
Arc with center (2.0,3.0) radii (2.2,2.2) angle 0.0 inside the sector (2.0,3.0)
"""
return "Arc with center (%s,%s) radii (%s,%s) angle %s inside the sector (%s,%s)" %(self.x,self.y,self.r1,self.r2,self.angle,self.s1,self.s2)
def _render_on_subplot(self, subplot):
"""
TESTS::
sage: A = arc((1,1),3,4,pi/4,(pi,4*pi/3)); A
"""
import matplotlib.patches as patches
from sage.plot.misc import get_matplotlib_linestyle
options = self.options()
p = patches.Arc(
(self.x,self.y),
2.*self.r1,
2.*self.r2,
fmod(self.angle,2*pi)*(180./pi),
self.s1*(180./pi),
self.s2*(180./pi))
p.set_linewidth(float(options['thickness']))
a = float(options['alpha'])
p.set_alpha(a)
z = int(options.pop('zorder',1))
p.set_zorder(z)
c = to_mpl_color(options['rgbcolor'])
p.set_linestyle(get_matplotlib_linestyle(options['linestyle'],return_type='long'))
p.set_edgecolor(c)
subplot.add_patch(p)
def plot3d(self):
r"""
TESTS::
sage: from sage.plot.arc import Arc
sage: Arc(0,0,1,1,0,0,1,{}).plot3d()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
@rename_keyword(color='rgbcolor')
@options(alpha=1, thickness=1, linestyle='solid', zorder=5,rgbcolor='blue',
aspect_ratio=1.0)
def arc(center, r1, r2=None, angle=0.0, sector=(0.0,2*pi), **options):
r"""
An arc (that is a portion of a circle or an ellipse)
Type ``arc.options`` to see all options.
INPUT:
- ``center`` - 2-tuple of real numbers - position of the center.
- ``r1``, ``r2`` - positive real numbers - radii of the ellipse. If only ``r1``
is set, then the two radii are supposed to be equal and this function returns
an arc of of circle.
- ``angle`` - real number - angle between the horizontal and the axis that
corresponds to ``r1``.
- ``sector`` - 2-tuple (default: (0,2*pi))- angles sector in which the arc will
be drawn.
OPTIONS:
- ``alpha`` - float (default: 1) - transparency
- ``thickness`` - float (default: 1) - thickness of the arc
- ``color``, ``rgbcolor`` - string or 2-tuple (default: 'blue') - the color
of the arc
- ``linestyle`` - string (default: ``'solid'``) - The style of the line,
which is one of ``'dashed'``, ``'dotted'``, ``'solid'``, ``'dashdot'``,
or ``'--'``, ``':'``, ``'-'``, ``'-.'``, respectively.
EXAMPLES:
Plot an arc of circle centered at (0,0) with radius 1 in the sector
`(\pi/4,3*\pi/4)`::
sage: arc((0,0), 1, sector=(pi/4,3*pi/4))
Plot an arc of an ellipse between the angles 0 and `\pi/2`::
sage: arc((2,3), 2, 1, sector=(0,pi/2))
Plot an arc of a rotated ellipse between the angles 0 and `\pi/2`::
sage: arc((2,3), 2, 1, angle=pi/5, sector=(0,pi/2))
Plot an arc of an ellipse in red with a dashed linestyle::
sage: arc((0,0), 2, 1, 0, (0,pi/2), linestyle="dashed", color="red")
sage: arc((0,0), 2, 1, 0, (0,pi/2), linestyle="--", color="red")
The default aspect ratio for arcs is 1.0::
sage: arc((0,0), 1, sector=(pi/4,3*pi/4)).aspect_ratio()
1.0
It is not possible to draw arcs in 3D::
sage: A = arc((0,0,0), 1)
Traceback (most recent call last):
...
NotImplementedError
"""
from sage.plot.all import Graphics
# Reset aspect_ratio to 'automatic' in case scale is 'semilog[xy]'.
# Otherwise matplotlib complains.
scale = options.get('scale', None)
if isinstance(scale, (list, tuple)):
scale = scale[0]
if scale == 'semilogy' or scale == 'semilogx':
options['aspect_ratio'] = 'automatic'
if len(center)==2:
if r2 is None: r2 = r1
g = Graphics()
g._set_extra_kwds(Graphics._extract_kwds_for_show(options))
if len(sector) != 2:
raise ValueError, "the sector must consist of two angles"
g.add_primitive(Arc(
center[0],center[1],
r1,r2,
angle,
sector[0],sector[1],
options))
return g
elif len(center)==3:
raise NotImplementedError
| 31.01039 | 149 | 0.511433 |
6e7102f9a178408022c57ff6c67de2b9cc5404ff | 1,123 | py | Python | animal.py | ckwen81/palg1 | 76d2a8a0720070200189afff10c84fd6e1c036ff | [
"MIT"
] | null | null | null | animal.py | ckwen81/palg1 | 76d2a8a0720070200189afff10c84fd6e1c036ff | [
"MIT"
] | null | null | null | animal.py | ckwen81/palg1 | 76d2a8a0720070200189afff10c84fd6e1c036ff | [
"MIT"
] | null | null | null | class Mammal:
population = 0
def __init__(self, name):
self.name = name
def __str__(self):
return f"I am an instance of {self.__class__}. My name is {self.name}. "
def __repr__(self):
return self.__str__()
def make_sound(self):
return f"{self.name} is trying to speak but its method doesn’t do much"
class Dog(Mammal):
def __init__(self, name, breed):
super().__init__(name)
self.breed = breed
def __str__(self):
return f"{super().__str__()}\nMy breed is {self.breed}"
def make_sound(self):
return f"{self.name} says woof!"
class Donkey(Mammal):
pass
animals = {"Ned": ("Donkey", None), "Rex": ("Dog", "mongrel"), "Sam": ("Dog", "labrador")}
animals_list = []
for k in animals:
if animals[k][1]:
animals_list.append(globals()[animals[k][0]](k, animals[k][1]))
else:
animals_list.append(globals()[animals[k][0]](k))
Mammal.population += 1
for animal in animals_list:
print(f"\n{animal}")
print(f"{animal.make_sound()}")
print(f"\nAnimal population is {Mammal.population}") | 23.395833 | 90 | 0.609973 |
0f739be0063bf6758a0f421bfe4876388800d651 | 5,377 | py | Python | klever/deploys/openstack/ssh.py | lutovna/klever | 29c0e4fa60def241032a2ea2b81103d817994eef | [
"Apache-2.0"
] | null | null | null | klever/deploys/openstack/ssh.py | lutovna/klever | 29c0e4fa60def241032a2ea2b81103d817994eef | [
"Apache-2.0"
] | null | null | null | klever/deploys/openstack/ssh.py | lutovna/klever | 29c0e4fa60def241032a2ea2b81103d817994eef | [
"Apache-2.0"
] | 1 | 2020-05-22T15:53:39.000Z | 2020-05-22T15:53:39.000Z | #
# Copyright (c) 2018 ISP RAS (http://www.ispras.ru)
# Ivannikov Institute for System Programming of the Russian Academy of Sciences
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import errno
import paramiko
import subprocess
import sys
import time
from klever.deploys.utils import execute_cmd, get_password
from klever.deploys.openstack.constants import OS_USER
class SSH:
CONNECTION_ATTEMPTS = 30
CONNECTION_RECOVERY_INTERVAL = 10
COMMAND_EXECUTION_CHECK_INTERVAL = 0.1
COMMAND_EXECUTION_STREAM_BUF_SIZE = 10000
def __init__(self, args, logger, name, floating_ip):
if not args.ssh_rsa_private_key_file:
logger.error('Please specify path to SSH RSA private key file with help of command-line option'
' --ssh-rsa-private-key-file')
sys.exit(errno.EINVAL)
self.args = args
self.logger = logger
self.name = name
self.floating_ip = floating_ip
def __enter__(self):
self.logger.info('Open SSH session to instance "{0}" (IP: {1})'.format(self.name, self.floating_ip))
self.ssh = paramiko.SSHClient()
self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
try:
k = paramiko.RSAKey.from_private_key_file(self.args.ssh_rsa_private_key_file)
except paramiko.ssh_exception.PasswordRequiredException:
if hasattr(self.args, 'key_password'):
key_password = self.args.key_password
else:
key_password = get_password(self.logger, 'Private key password: ')
try:
k = paramiko.RSAKey.from_private_key_file(self.args.ssh_rsa_private_key_file, key_password)
except paramiko.ssh_exception.SSHException:
self.logger.error('Incorrect password for private key')
sys.exit(errno.EACCES)
attempts = self.CONNECTION_ATTEMPTS
while attempts > 0:
try:
self.ssh.connect(hostname=self.floating_ip, username=self.args.ssh_username, pkey=k)
return self
except Exception:
attempts -= 1
self.logger.info('Could not open SSH session, wait for {0} seconds and try {1} times more'
.format(self.CONNECTION_RECOVERY_INTERVAL, attempts))
time.sleep(self.CONNECTION_RECOVERY_INTERVAL)
self.logger.error('Could not open SSH session')
sys.exit(errno.EPERM)
def __exit__(self, etype, value, traceback):
self.logger.info('Close SSH session to instance "{0}" (IP: {1})'.format(self.name, self.floating_ip))
self.ssh.close()
def execute_cmd(self, cmd, timeout=COMMAND_EXECUTION_CHECK_INTERVAL):
self.logger.info('Execute command over SSH on instance "{0}" (IP: {1})\n{2}'
.format(self.name, self.floating_ip, cmd))
chan = self.ssh.get_transport().open_session()
chan.setblocking(0)
chan.exec_command(cmd)
# Print command STDOUT and STDERR until it will be executed.
while not chan.exit_status_ready():
stderr = ''
while chan.recv_stderr_ready():
stderr += chan.recv_stderr(self.COMMAND_EXECUTION_STREAM_BUF_SIZE).decode(encoding='utf8')
stderr = stderr.rstrip()
if stderr:
print('Executed command STDERR:\n"{}"'.format(stderr))
stdout = ''
while chan.recv_ready():
stdout += chan.recv(self.COMMAND_EXECUTION_STREAM_BUF_SIZE).decode(encoding='utf8')
stdout = stdout.rstrip()
if stdout:
print(stdout)
time.sleep(timeout)
retcode = chan.recv_exit_status()
if retcode:
self.logger.error('Command exitted with {0}'.format(retcode))
sys.exit(errno.EPERM)
def open_shell(self):
self.logger.info('Open interactive SSH to instance "{0}" (IP: {1})'.format(self.name, self.floating_ip))
execute_cmd(self.logger, 'ssh', '-o', 'StrictHostKeyChecking=no', '-i', self.args.ssh_rsa_private_key_file,
'{0}@{1}'.format(self.args.ssh_username, self.floating_ip))
def rsync(self, host_path, instance_path):
if instance_path:
self.execute_cmd(f'mkdir -p {instance_path}')
else:
instance_path = "~/"
# stderr=subprocess.DEVNULL is required to suppress WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!
# maybe there is a better way to fix it
execute_cmd(
self.logger,
'rsync', '-ar',
'-e', f'ssh -o StrictHostKeyChecking=no -i {self.args.ssh_rsa_private_key_file}',
host_path,
f'{OS_USER}@{self.floating_ip}:{instance_path}',
stderr=subprocess.DEVNULL
)
| 38.683453 | 115 | 0.637902 |
3bd84ea754b08a839c493c721349c981365b87ae | 12,445 | py | Python | core/commands/intra_line_colorizer.py | timfjord/GitSavvy | c0a627c30da79cb10a5a33f30d92d177f78da0ab | [
"MIT"
] | 2,058 | 2015-02-27T19:06:31.000Z | 2019-10-17T13:42:11.000Z | core/commands/intra_line_colorizer.py | timfjord/GitSavvy | c0a627c30da79cb10a5a33f30d92d177f78da0ab | [
"MIT"
] | 1,057 | 2015-02-11T23:14:56.000Z | 2019-10-17T20:17:23.000Z | core/commands/intra_line_colorizer.py | divmain/GitGadget | 6452528d22a13c6f3169ad20619471d261e576bf | [
"MIT"
] | 180 | 2015-03-06T14:26:05.000Z | 2019-10-12T06:28:21.000Z | import difflib
from functools import lru_cache, partial
from itertools import groupby, zip_longest
import re
import time
import sublime
from ..fns import accumulate, filter_, flatten
from ..parse_diff import Hunk, SplittedDiff, Region
from ..utils import eat_but_log_errors, line_indentation
from ..runtime import cooperative_thread_hopper, AWAIT_WORKER
MYPY = False
if MYPY:
from typing import Callable, List, Tuple, Sequence
from ..parse_diff import HunkLine
from ..runtime import HopperR
Chunk = List[HunkLine]
MAX_BLOCK_TIME = 17
@eat_but_log_errors()
def annotate_intra_line_differences(view, diff_text=None, offset=0):
# type: (sublime.View, str, int) -> None
# import profile
# profile.runctx('compute_intra_line_diffs(view)', globals(), locals(), sort='cumtime')
if diff_text is None:
diff = SplittedDiff.from_view(view)
else:
diff = SplittedDiff.from_string(diff_text, offset)
compute_intra_line_diffs(view, diff)
def view_has_changed_factory(view):
# type: (sublime.View) -> Callable[[], bool]
cc = view.change_count()
def view_has_changed():
# type: () -> bool
return not view.is_valid() or view.change_count() != cc
return view_has_changed
def block_time_passed_factory(block_time=MAX_BLOCK_TIME):
start_time = time.perf_counter()
def block_time_passed():
nonlocal start_time
end_time = time.perf_counter()
duration = round((end_time - start_time) * 1000)
if duration > block_time:
start_time = time.perf_counter()
return True
else:
return False
return block_time_passed
@cooperative_thread_hopper
def compute_intra_line_diffs(view, diff):
# type: (sublime.View, SplittedDiff) -> HopperR
viewport = view.visible_region()
view_has_changed = view_has_changed_factory(view)
chunks = filter(is_modification_group, flatten(map(group_non_context_lines, diff.hunks)))
above_viewport, in_viewport, below_viewport = [], [], [] # type: Tuple[List[Chunk], List[Chunk], List[Chunk]]
for chunk in chunks:
chunk_region = compute_chunk_region(chunk)
container = (
in_viewport if chunk_region.intersects(viewport)
else above_viewport if chunk_region < viewport
else below_viewport
)
container.append(chunk)
from_regions = []
to_regions = []
for chunk in in_viewport:
new_from_regions, new_to_regions = intra_line_diff_for_chunk(chunk)
from_regions.extend(new_from_regions)
to_regions.extend(new_to_regions)
_draw_intra_diff_regions(view, to_regions, from_regions)
yield AWAIT_WORKER
if view_has_changed():
return
block_time_passed = block_time_passed_factory()
# Consider some chunks [1, 2, 3, 4] where 3 was *in* the viewport and thus
# rendered immediately. Now, [1, 2] + [4] await their render. The following
# `zip_longest(reversed` dance generates [2, 4, 1] as the unit of work, t.i.
# we move from the viewport to the edges (inside-out).
for chunk in filter_(flatten(zip_longest(reversed(above_viewport), below_viewport))):
new_from_regions, new_to_regions = intra_line_diff_for_chunk(chunk)
from_regions.extend(new_from_regions)
to_regions.extend(new_to_regions)
if block_time_passed():
if view_has_changed():
return
_draw_intra_diff_regions(view, to_regions, from_regions)
yield AWAIT_WORKER
if view_has_changed():
return
block_time_passed = block_time_passed_factory()
if view_has_changed():
return
_draw_intra_diff_regions(view, to_regions, from_regions)
def _draw_intra_diff_regions(view, added_regions, removed_regions):
view.add_regions(
"git-savvy-added-bold", added_regions, scope="diff.inserted.char.git-savvy.diff"
)
view.add_regions(
"git-savvy-removed-bold", removed_regions, scope="diff.deleted.char.git-savvy.diff"
)
def group_non_context_lines(hunk):
# type: (Hunk) -> List[Chunk]
"""Return groups of chunks(?) (without context) from a hunk."""
# A hunk can contain many modifications interleaved
# with context lines. Return just these modification
# lines grouped as units. Note that we process per
# column here which enables basic support for combined
# diffs.
# Note: No newline marker lines are just ignored t.i.
# skipped.
mode_len = hunk.mode_len()
content_lines = list(
line
for line in hunk.content().lines()
if not line.is_no_newline_marker() # <==
)
return [
list(lines)
for n in range(mode_len) # <== usually one except for combined diffs
for is_context, lines in groupby(
content_lines,
key=lambda line: line.mode[n] == ' '
)
if not is_context
]
def is_modification_group(lines):
# type: (Chunk) -> bool
"""Mark groups which have both + and - modes."""
# Since these groups are always sorted in git, from a to b,
# such a group starts with a "-" and ends with a "+".
return lines[0].is_from_line() and lines[-1].is_to_line()
def compute_chunk_region(lines):
# type: (Chunk) -> sublime.Region
return sublime.Region(lines[0].a, lines[-1].b)
def intra_line_diff_for_chunk(group):
# type: (Chunk) -> Tuple[List[Region], List[Region]]
from_lines, to_lines = [
list(lines)
for mode, lines in groupby(group, key=lambda line: line.is_from_line())
]
algo = (
intra_diff_line_by_line
if len(from_lines) == len(to_lines)
else intra_diff_general_algorithm
)
return algo(from_lines, to_lines)
@lru_cache(maxsize=512)
def match_sequences(a, b, is_junk=difflib.IS_CHARACTER_JUNK, max_token_length=250):
# type: (Sequence, Sequence, Callable[[str], bool], int) -> difflib.SequenceMatcher
if (len(a) + len(b)) > max_token_length:
return NullSequenceMatcher(is_junk, a='', b='')
matches = difflib.SequenceMatcher(is_junk, a=a, b=b)
matches.ratio() # for the side-effect of doing the computational work and caching it
return matches
class NullSequenceMatcher(difflib.SequenceMatcher):
def ratio(self):
return 0
def get_opcodes(self):
return []
def intra_diff_general_algorithm(from_lines, to_lines):
# type: (List[HunkLine], List[HunkLine]) -> Tuple[List[Region], List[Region]]
# Generally, if the two line chunks have different size, try to fit
# the smaller one into the bigger, or try to find how and where the
# smaller could be placed in the bigger one.
#
# E.g. you have 3 "+" lines, but 5 "-" lines. For now take the *first*
# "+" line, and match it against "-" lines. The highest match ratio wins,
# and we take it as the starting point for the intra-diff line-by-line
# algorithm.
if len(from_lines) < len(to_lines):
base_line = from_lines[0].content
matcher = partial(match_sequences, base_line)
# We want that the smaller list fits completely into the bigger,
# so we can't compare against *all* lines but have to stop
# somewhere earlier.
#
# E.g. a = [1, 2, 3, 4, 5]; b = [1, 2]. Then, the candidates are
# [1, 2, 3, 4] otherwise b won't fit anymore
# [1, 2]
match_candidates = to_lines[:len(to_lines) - len(from_lines) + 1]
to_lines = to_lines[find_best_slice(matcher, match_candidates)]
else:
base_line = to_lines[0].content
matcher = partial(match_sequences, b=base_line)
match_candidates = from_lines[:len(from_lines) - len(to_lines) + 1]
from_lines = from_lines[find_best_slice(matcher, match_candidates)]
if to_lines and from_lines:
return intra_diff_line_by_line(from_lines, to_lines)
else:
return [], []
def find_best_slice(matcher, lines):
# type: (Callable[[str], difflib.SequenceMatcher], List[HunkLine]) -> slice
scores = []
for n, line in enumerate(lines):
matches = matcher(line.content)
ratio = matches.ratio()
if ratio >= 0.85:
break
scores.append((ratio, n))
else:
ratio, n = max(scores)
if ratio < 0.75:
return slice(0)
return slice(n, None)
def intra_diff_line_by_line(from_lines, to_lines):
# type: (List[HunkLine], List[HunkLine]) -> Tuple[List[Region], List[Region]]
# Note: We have no guarantees here that from_lines and to_lines
# have the same length, we use `zip` currently which produces
# iterables of the shortest length of both!
from_regions = []
to_regions = []
for from_line, to_line in zip(from_lines, to_lines): # zip! see comment above
# Compare without the leading mode char using ".content", but
# also dedent both lines because leading common spaces will produce
# higher ratios and produce slightly more ugly diffs.
indentation = min(
line_indentation(from_line.content),
line_indentation(to_line.content)
)
a_input, b_input = from_line.content[indentation:], to_line.content[indentation:]
matches = match_sequences(a_input, b_input)
if matches.ratio() < 0.5:
# We just continue, so it is possible that for a given chunk
# *some* lines have markers, others not.
# A different implementation could be: if *any* line within a hunk
# is really low, like here 0.5, drop the hunk altogether.
continue
# Use tokenize strategy when there are "nearby" or fragmented splits
# because it produces more calm output.
if is_fragmented_match(matches):
a_input = tokenize_string(a_input) # type: ignore
b_input = tokenize_string(b_input) # type: ignore
matches = match_sequences(a_input, b_input)
a_offset = from_line.a + from_line.mode_len + indentation
b_offset = to_line.a + to_line.mode_len + indentation
from_offsets = tuple(accumulate(map(len, a_input), initial=a_offset))
to_offsets = tuple(accumulate(map(len, b_input), initial=b_offset))
for op, a_start, a_end, b_start, b_end in matches.get_opcodes():
if op == 'equal':
continue
if a_start != a_end:
from_regions.append(Region(from_offsets[a_start], from_offsets[a_end]))
if b_start != b_end:
to_regions.append(Region(to_offsets[b_start], to_offsets[b_end]))
return from_regions, to_regions
boundary = re.compile(r'(\W)')
OPERATOR_CHARS = '=!<>'
COMPARISON_SENTINEL = object()
def tokenize_string(input_str):
# type: (str) -> Sequence[str]
# Usually a simple split on "\W" suffices, but here we join some
# "operator" chars again.
# About the "operator" chars: we want to treat e.g. "==" and "!="
# as one token. It is not important to treat e.g. "&&" as one token
# because there is probably no "|&". That is to say, if all chars
# change we get a clean diff anyway, for the comparison operators
# often only *one* of the characters changes ("<" to "<=" or "=="
# to "!=") and then it looks better esp. with ligatures (!) if we
# treat them as one token.
return tuple(
flatten(
[''.join(chars)]
if ch is COMPARISON_SENTINEL
else list(chars)
for ch, chars in groupby(
filter(None, boundary.split(input_str)),
key=lambda x: COMPARISON_SENTINEL if x in OPERATOR_CHARS else x
)
)
)
def is_fragmented_match(matches):
# type: (difflib.SequenceMatcher) -> bool
a_input, b_input = matches.a, matches.b # type: ignore # stub bug?
return any(
(
op == 'equal'
and a_end - a_start == 1
and not a_input[a_start:a_end] == '\n'
)
or (
op == 'equal'
and b_end - b_start == 1
and not b_input[b_start:b_end] == '\n'
)
or (
op != 'equal'
and boundary.search(a_input[a_start:a_end] + b_input[b_start:b_end])
)
for op, a_start, a_end, b_start, b_end in matches.get_opcodes()
)
| 35.355114 | 114 | 0.64556 |
92b06c05f9671cab4f77ae7df0cc12f8202a81eb | 5,911 | py | Python | output/python37/Lib/test/test_frame.py | cy15196/FastCAE | 0870752ec2e590f3ea6479e909ebf6c345ac2523 | [
"BSD-3-Clause"
] | 117 | 2020-03-07T12:07:05.000Z | 2022-03-27T07:35:22.000Z | output/python37/Lib/test/test_frame.py | cy15196/FastCAE | 0870752ec2e590f3ea6479e909ebf6c345ac2523 | [
"BSD-3-Clause"
] | 4 | 2020-03-12T15:36:57.000Z | 2022-02-08T02:19:17.000Z | output/python37/Lib/test/test_frame.py | cy15196/FastCAE | 0870752ec2e590f3ea6479e909ebf6c345ac2523 | [
"BSD-3-Clause"
] | 76 | 2020-03-16T01:47:46.000Z | 2022-03-21T16:37:07.000Z | import re
import types
import unittest
import weakref
from test import support
class ClearTest(unittest.TestCase):
"""
Tests for frame.clear().
"""
def inner(self, x=5, **kwargs):
1/0
def outer(self, **kwargs):
try:
self.inner(**kwargs)
except ZeroDivisionError as e:
exc = e
return exc
def clear_traceback_frames(self, tb):
"""
Clear all frames in a traceback.
"""
while tb is not None:
tb.tb_frame.clear()
tb = tb.tb_next
def test_clear_locals(self):
class C:
pass
c = C()
wr = weakref.ref(c)
exc = self.outer(c=c)
del c
support.gc_collect()
# A reference to c is held through the frames
self.assertIsNot(None, wr())
self.clear_traceback_frames(exc.__traceback__)
support.gc_collect()
# The reference was released by .clear()
self.assertIs(None, wr())
def test_clear_generator(self):
endly = False
def g():
nonlocal endly
try:
yield
inner()
finally:
endly = True
gen = g()
next(gen)
self.assertFalse(endly)
# Clearing the frame closes the generator
gen.gi_frame.clear()
self.assertTrue(endly)
def test_clear_executing(self):
# Attempting to clear an executing frame is forbidden.
try:
1/0
except ZeroDivisionError as e:
f = e.__traceback__.tb_frame
with self.assertRaises(RuntimeError):
f.clear()
with self.assertRaises(RuntimeError):
f.f_back.clear()
def test_clear_executing_generator(self):
# Attempting to clear an executing generator frame is forbidden.
endly = False
def g():
nonlocal endly
try:
1/0
except ZeroDivisionError as e:
f = e.__traceback__.tb_frame
with self.assertRaises(RuntimeError):
f.clear()
with self.assertRaises(RuntimeError):
f.f_back.clear()
yield f
finally:
endly = True
gen = g()
f = next(gen)
self.assertFalse(endly)
# Clearing the frame closes the generator
f.clear()
self.assertTrue(endly)
@support.cpython_only
def test_clear_refcycles(self):
# .clear() doesn't leave any refcycle behind
with support.disable_gc():
class C:
pass
c = C()
wr = weakref.ref(c)
exc = self.outer(c=c)
del c
self.assertIsNot(None, wr())
self.clear_traceback_frames(exc.__traceback__)
self.assertIs(None, wr())
class FrameLocalsTest(unittest.TestCase):
"""
Tests for the .f_locals attribute.
"""
def make_frames(self):
def outer():
x = 5
y = 6
def inner():
z = x + 2
1/0
t = 9
return inner()
try:
outer()
except ZeroDivisionError as e:
tb = e.__traceback__
frames = []
while tb:
frames.append(tb.tb_frame)
tb = tb.tb_next
return frames
def test_locals(self):
f, outer, inner = self.make_frames()
outer_locals = outer.f_locals
self.assertIsInstance(outer_locals.pop('inner'), types.FunctionType)
self.assertEqual(outer_locals, {'x': 5, 'y': 6})
inner_locals = inner.f_locals
self.assertEqual(inner_locals, {'x': 5, 'z': 7})
def test_clear_locals(self):
# Test f_locals after clear() (issue #21897)
f, outer, inner = self.make_frames()
outer.clear()
inner.clear()
self.assertEqual(outer.f_locals, {})
self.assertEqual(inner.f_locals, {})
def test_locals_clear_locals(self):
# Test f_locals before and after clear() (to exercise caching)
f, outer, inner = self.make_frames()
outer.f_locals
inner.f_locals
outer.clear()
inner.clear()
self.assertEqual(outer.f_locals, {})
self.assertEqual(inner.f_locals, {})
class ReprTest(unittest.TestCase):
"""
Tests for repr(frame).
"""
def test_repr(self):
def outer():
x = 5
y = 6
def inner():
z = x + 2
1/0
t = 9
return inner()
offset = outer.__code__.co_firstlineno
try:
outer()
except ZeroDivisionError as e:
tb = e.__traceback__
frames = []
while tb:
frames.append(tb.tb_frame)
tb = tb.tb_next
else:
self.fail("should have raised")
f_this, f_outer, f_inner = frames
file_repr = re.escape(repr(__file__))
self.assertRegex(repr(f_this),
r"^<frame at 0x[0-9a-fA-F]+, file %s, line %d, code test_repr>$"
% (file_repr, offset + 23))
self.assertRegex(repr(f_outer),
r"^<frame at 0x[0-9a-fA-F]+, file %s, line %d, code outer>$"
% (file_repr, offset + 7))
self.assertRegex(repr(f_inner),
r"^<frame at 0x[0-9a-fA-F]+, file %s, line %d, code inner>$"
% (file_repr, offset + 5))
if __name__ == "__main__":
unittest.main()
| 28.834146 | 90 | 0.494163 |
d278d1698e45a05897c9fb5b08c729b250fd798f | 9,452 | py | Python | library/azure_rm_containerinstance_facts.py | wray/azure_modules | af2d84ffc4a0061f5ab4ed7e621faa0bbdbb2da5 | [
"MIT"
] | null | null | null | library/azure_rm_containerinstance_facts.py | wray/azure_modules | af2d84ffc4a0061f5ab4ed7e621faa0bbdbb2da5 | [
"MIT"
] | null | null | null | library/azure_rm_containerinstance_facts.py | wray/azure_modules | af2d84ffc4a0061f5ab4ed7e621faa0bbdbb2da5 | [
"MIT"
] | null | null | null | #!/usr/bin/python
#
# Copyright (c) 2017 Zim Kalinowski, <zikalino@microsoft.com>
#
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'community'}
DOCUMENTATION = '''
---
module: azure_rm_containerinstance_facts
version_added: "2.8"
short_description: Get Azure Container Instance facts.
description:
- Get facts of Container Instance.
options:
resource_group:
description:
- The name of the resource group.
required: True
name:
description:
- The name of the container instance.
tags:
description:
- Limit results by providing a list of tags. Format tags as 'key' or 'key:value'.
extends_documentation_fragment:
- azure
author:
- "Zim Kalinowski (@zikalino)"
'''
EXAMPLES = '''
- name: Get specific Container Instance facts
azure_rm_containerinstance_facts:
resource_group: resource_group_name
name: container_group_name
- name: List Container Instances in a specified resource group name
azure_rm_containerinstance_facts:
resource_group: resource_group_name
'''
RETURN = '''
container_groups:
description: A list of Container Instance dictionaries.
returned: always
type: complex
contains:
id:
description:
- The resource id.
returned: always
type: str
sample: "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/demo/providers/Microsoft.ContainerInstance/containerGroups/my
containers"
resource_group:
description:
- Resource group where the container exists.
returned: always
type: str
sample: testrg
name:
description:
- The resource name.
returned: always
type: str
sample: mycontainers
location:
description:
- The resource location.
returned: always
type: str
sample: westus
os_type:
description:
- The OS type of containers.
returned: always
type: str
sample: linux
ip_address:
description:
- IP address of the container instance.
returned: always
type: str
sample: 173.15.18.1
ports:
description:
- List of ports exposed by the container instance.
returned: always
type: list
sample: [ 80, 81 ]
containers:
description:
- The containers within the container group.
returned: always
type: complex
sample: containers
contains:
name:
description:
- The name of the container instance.
returned: always
type: str
sample: "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/demo/providers/Microsoft.ContainerInstance/containerGroups/my
containers"
image:
description:
- The container image name.
returned: always
type: str
sample: "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/demo/providers/Microsoft.ContainerInstance/containerGroups/my
containers"
memory:
description:
- The required memory of the containers in GB.
returned: always
type: float
sample: 1.5
cpu:
description:
- The required number of CPU cores of the containers.
returned: always
type: int
sample: 1
ports:
description:
- List of ports exposed within the container group.
returned: always
type: list
sample: [ 80, 81 ]
tags:
description: Tags assigned to the resource. Dictionary of string:string pairs.
type: dict
sample: { "tag1": "abc" }
'''
from ansible.module_utils.azure_rm_common import AzureRMModuleBase
try:
from msrestazure.azure_exceptions import CloudError
from msrestazure.azure_operation import AzureOperationPoller
from azure.mgmt.containerinstance import ContainerInstanceManagementClient
from msrest.serialization import Model
except ImportError:
# This is handled in azure_rm_common
pass
class AzureRMContainerInstanceFacts(AzureRMModuleBase):
def __init__(self):
# define user inputs into argument
self.module_arg_spec = dict(
resource_group=dict(
type='str',
required=True
),
name=dict(
type='str'
),
tags=dict(
type='list'
)
)
# store the results of the module operation
self.results = dict(
changed=False,
ansible_facts=dict()
)
self.resource_group = None
self.name = None
super(AzureRMContainerInstanceFacts, self).__init__(self.module_arg_spec, supports_tags=False)
def exec_module(self, **kwargs):
for key in self.module_arg_spec:
setattr(self, key, kwargs[key])
if (self.name is not None):
self.results['containerinstances'] = self.get()
elif (self.resource_group is not None):
self.results['containerinstances'] = self.list_by_resource_group()
else:
self.results['containerinstances'] = self.list_all()
return self.results
def get(self):
response = None
results = []
try:
response = self.containerinstance_client.container_groups.get(resource_group_name=self.resource_group,
container_group_name=self.name)
self.log("Response : {0}".format(response))
except CloudError as e:
self.log('Could not get facts for Container Instances.')
if response is not None and self.has_tags(response.tags, self.tags):
results.append(self.format_item(response))
return results
def list_by_resource_group(self):
response = None
results = []
try:
response = self.containerinstance_client.container_groups.list_by_resource_group(resource_group_name=self.resource_group)
self.log("Response : {0}".format(response))
except CloudError as e:
self.fail('Could not list facts for Container Instances.')
if response is not None:
for item in response:
if self.has_tags(item.tags, self.tags):
results.append(self.format_item(item))
return results
def list_all(self):
response = None
results = []
try:
response = self.containerinstance_client.container_groups.list()
self.log("Response : {0}".format(response))
except CloudError as e:
self.fail('Could not list facts for Container Instances.')
if response is not None:
for item in response:
if self.has_tags(item.tags, self.tags):
results.append(self.format_item(item))
return results
def format_item(self, item):
d = item.as_dict()
containers = d['containers']
ports = d['ip_address']['ports']
resource_group = d['id'].split('resourceGroups/')[1].split('/')[0]
for port_index in range(len(ports)):
ports[port_index] = ports[port_index]['port']
for container_index in range(len(containers)):
old_container = containers[container_index]
new_container = {
'name': old_container['name'],
'image': old_container['image'],
'memory': old_container['resources']['requests']['memory_in_gb'],
'cpu': old_container['resources']['requests']['cpu'],
'ports': []
}
for port_index in range(len(old_container['ports'])):
new_container['ports'].append(old_container['ports'][port_index]['port'])
containers[container_index] = new_container
d = {
'id': d['id'],
'resource_group': resource_group,
'name': d['name'],
'os_type': d['os_type'],
'ip_address': 'public' if d['ip_address']['type'] == 'Public' else 'none',
'ports': ports,
'location': d['location'],
'containers': containers,
'tags': d.get('tags', None)
}
return d
def main():
AzureRMContainerInstanceFacts()
if __name__ == '__main__':
main()
| 33.048951 | 157 | 0.559247 |
463bbf3eefb8e35bc6625d1f72b2ed4a47f5c318 | 543 | py | Python | image_shredder/scripts/image_shredder.py | HarmenBoers/ocr-playground | 8be775b5cea44eb1fad57561cca2e2fae980d81b | [
"MIT"
] | 1 | 2017-08-09T12:58:17.000Z | 2017-08-09T12:58:17.000Z | image_shredder/scripts/image_shredder.py | HarmenBoers/ocr-playground | 8be775b5cea44eb1fad57561cca2e2fae980d81b | [
"MIT"
] | null | null | null | image_shredder/scripts/image_shredder.py | HarmenBoers/ocr-playground | 8be775b5cea44eb1fad57561cca2e2fae980d81b | [
"MIT"
] | null | null | null | from PIL import Image
from random import shuffle
SHREDS = 10
image = Image.open('sample.png')
shredded = Image.new('RGBA', image.size)
width, height = image.size
shred_width = width/SHREDS
sequence = range(0, SHREDS)
shuffle(sequence)
for i, shred_index in enumerate(sequence):
shred_x1, shred_y1 = shred_width * shred_index, 0
shred_x2, shred_y2 = shred_x1 + shred_width, height
region = image.crop((shred_x1, shred_y1, shred_x2, shred_y2))
shredded.paste(region, (shred_width * i, 0))
shredded.save('sample_shredded.png') | 36.2 | 65 | 0.73849 |
611c4666255a39950bea7e09b6987f4ef0f2147d | 5,397 | py | Python | AFLink/dataset.py | dyhBUPT/StrongSORT | dbe13571e841e12003cf993cbbbf55bf6714ea71 | [
"Apache-2.0"
] | 65 | 2022-03-01T14:22:04.000Z | 2022-03-30T09:44:49.000Z | AFLink/dataset.py | dyhBUPT/StrongSORT | dbe13571e841e12003cf993cbbbf55bf6714ea71 | [
"Apache-2.0"
] | 12 | 2022-03-02T06:07:50.000Z | 2022-03-30T03:19:25.000Z | AFLink/dataset.py | dyhBUPT/StrongSORT | dbe13571e841e12003cf993cbbbf55bf6714ea71 | [
"Apache-2.0"
] | 11 | 2022-03-02T02:33:50.000Z | 2022-03-27T00:50:40.000Z | """
@Author: Du Yunhao
@Filename: dataset.py
@Contact: dyh_bupt@163.com
@Time: 2021/12/28 9:24
@Discription: dataset
"""
import torch
import numpy as np
from os.path import join
from random import randint, normalvariate
from torch.utils.data import Dataset, DataLoader
import AFLink.config as cfg
SEQ = {
'train': [
'MOT17-02-FRCNN',
'MOT17-04-FRCNN',
'MOT17-05-FRCNN',
'MOT17-09-FRCNN',
'MOT17-10-FRCNN',
'MOT17-11-FRCNN',
'MOT17-13-FRCNN'
],
'test': [
'MOT17-01-FRCNN',
'MOT17-03-FRCNN',
'MOT17-06-FRCNN',
'MOT17-07-FRCNN',
'MOT17-08-FRCNN',
'MOT17-12-FRCNN',
'MOT17-14-FRCNN'
]
}
class LinkData(Dataset):
def __init__(self, root, mode='train', minLen=cfg.model_minLen, inputLen=cfg.model_inputLen):
"""
:param minLen: 仅考虑长度超过该阈值的GT轨迹
:param inputLen: 网络输入轨迹长度
"""
self.minLen = minLen
self.inputLen = inputLen
if root:
assert mode in ('train', 'val')
self.root = root
self.mode = mode
self.id2info = self.initialize()
self.ids = list(self.id2info.keys())
def initialize(self):
id2info = dict()
for seqid, seq in enumerate(SEQ['train'], start=1):
path_gt = join(self.root, '{}/gt/gt_{}_half.txt'.format(seq, self.mode))
gts = np.loadtxt(path_gt, delimiter=',')
gts = gts[(gts[:, 6] == 1) * (gts[:, 7] == 1)] # 仅考虑“considered" & "pedestrian"
ids = set(gts[:, 1])
for objid in ids:
id_ = objid + seqid * 1e5
track = gts[gts[:, 1] == objid]
fxywh = [[t[0], t[2], t[3], t[4], t[5]] for t in track]
if len(fxywh) >= self.minLen:
id2info[id_] = np.array(fxywh)
return id2info
def fill_or_cut(self, x, former: bool):
"""
:param x: input
:param former: True代表该轨迹片段为连接时的前者
"""
lengthX, widthX = x.shape
if lengthX >= self.inputLen:
if former:
x = x[-self.inputLen:]
else:
x = x[:self.inputLen]
else:
zeros = np.zeros((self.inputLen - lengthX, widthX))
if former:
x = np.concatenate((zeros, x), axis=0)
else:
x = np.concatenate((x, zeros), axis=0)
return x
def transform(self, x1, x2):
# fill or cut
x1 = self.fill_or_cut(x1, True)
x2 = self.fill_or_cut(x2, False)
# min-max normalization
min_ = np.concatenate((x1, x2), axis=0).min(axis=0)
max_ = np.concatenate((x1, x2), axis=0).max(axis=0)
subtractor = (max_ + min_) / 2
divisor = (max_ - min_) / 2 + 1e-5
x1 = (x1 - subtractor) / divisor
x2 = (x2 - subtractor) / divisor
# numpy to torch
x1 = torch.tensor(x1, dtype=torch.float)
x2 = torch.tensor(x2, dtype=torch.float)
# unsqueeze channel=1
x1 = x1.unsqueeze(dim=0)
x2 = x2.unsqueeze(dim=0)
return x1, x2
def __getitem__(self, item):
info = self.id2info[self.ids[item]]
numFrames = info.shape[0]
if self.mode == 'train':
idxCut = randint(self.minLen//3, numFrames - self.minLen//3) # 随机裁剪点
# 样本对儿
info1 = info[:idxCut + int(normalvariate(-5, 3))] # 为索引添加随机偏差
info2 = info[idxCut + int(normalvariate(5, 3)):] # 为索引添加随机偏差
# 时域扰动
info2_t = info2.copy()
info2_t[:, 0] += (-1) ** randint(1, 2) * randint(30, 100)
# 空间扰动
info2_s = info2.copy()
info2_s[:, 1] += (-1) ** randint(1, 2) * randint(100, 500)
info2_s[:, 2] += (-1) ** randint(1, 2) * randint(100, 500)
else:
idxCut = numFrames // 2
# 样本对儿
info1 = info[:idxCut]
info2 = info[idxCut:]
# 时域扰动
info2_t = info2.copy()
info2_t[:, 0] += (-1) ** idxCut * 50
# 空间扰动
info2_s = info2.copy()
info2_s[:, 1] += (-1) ** idxCut * 300
info2_s[:, 2] += (-1) ** idxCut * 300
# 返回正负样本对儿
return self.transform(info1, info2), \
self.transform(info2, info1), \
self.transform(info1, info2_t), \
self.transform(info1, info2_s), \
(1, 0, 0, 0)
def __len__(self):
return len(self.ids)
if __name__ == '__main__':
dataset = LinkData(
root='/data/dyh/data/MOTChallenge/MOT17/train',
mode='train'
)
dataloader = DataLoader(
dataset=dataset,
batch_size=2,
shuffle=True,
num_workers=1,
drop_last=False
)
print(len(dataset))
print(len(dataloader))
for i, (pair1, pair2, pair3, pair4, labels) in enumerate(dataloader):
pairs_1 = torch.cat((pair1[0], pair2[0], pair3[0], pair4[0]), dim=0)
pairs_2 = torch.cat((pair1[1], pair2[1], pair3[1], pair4[1]), dim=0)
label = torch.cat(labels, dim=0)
print(pairs_1.shape)
print(label)
break | 32.908537 | 98 | 0.494534 |
ef9d71fb6c35d6657929488be8611f70708b71d7 | 73 | py | Python | LearnAF/ops/__init__.py | itsnarsi/LearnAF | 5c7d76a89ab824e8e3ea1bd83ac4f07c94ce0819 | [
"MIT"
] | null | null | null | LearnAF/ops/__init__.py | itsnarsi/LearnAF | 5c7d76a89ab824e8e3ea1bd83ac4f07c94ce0819 | [
"MIT"
] | null | null | null | LearnAF/ops/__init__.py | itsnarsi/LearnAF | 5c7d76a89ab824e8e3ea1bd83ac4f07c94ce0819 | [
"MIT"
] | null | null | null | from .autograd import *
from .trigonometry import *
from .matops import * | 24.333333 | 27 | 0.767123 |
a56bf081ac3ec7d1490901f98f35ee1ad521e5a0 | 2,261 | py | Python | projects/perception/lightweight_open_pose/demos/eval_demo.py | makistsantekidis/opendr | 07dee3b59d3487b9c5a93d6946317178a02c9890 | [
"Apache-2.0"
] | 3 | 2021-06-24T01:54:25.000Z | 2021-12-12T16:21:24.000Z | projects/perception/lightweight_open_pose/demos/eval_demo.py | makistsantekidis/opendr | 07dee3b59d3487b9c5a93d6946317178a02c9890 | [
"Apache-2.0"
] | 79 | 2021-06-23T10:40:10.000Z | 2021-12-16T07:59:42.000Z | projects/perception/lightweight_open_pose/demos/eval_demo.py | makistsantekidis/opendr | 07dee3b59d3487b9c5a93d6946317178a02c9890 | [
"Apache-2.0"
] | 5 | 2021-07-04T07:38:50.000Z | 2021-12-12T16:18:47.000Z | # Copyright 2020-2021 OpenDR European Project
#
# 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 opendr.perception.pose_estimation import LightweightOpenPoseLearner
import argparse
from os.path import join
from opendr.engine.datasets import ExternalDataset
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument("--onnx", help="Use ONNX", default=False, action="store_true")
parser.add_argument("--device", help="Device to use (cpu, cuda)", type=str, default="cuda")
parser.add_argument("--accelerate", help="Enables acceleration flags (e.g., stride)", default=False,
action="store_true")
args = parser.parse_args()
onnx, device, accelerate = args.onnx, args.device, args.accelerate
if accelerate:
stride = True
stages = 0
half_precision = True
else:
stride = False
stages = 2
half_precision = False
pose_estimator = LightweightOpenPoseLearner(device=device, num_refinement_stages=stages,
mobilenet_use_stride=stride,
half_precision=half_precision)
pose_estimator.download(path=".", verbose=True)
pose_estimator.load("openpose_default")
if onnx:
pose_estimator.optimize()
# Download a sample dataset
pose_estimator.download(path=".", mode="test_data")
eval_dataset = ExternalDataset(path=join("temp", "dataset"), dataset_type="COCO")
results_dict = pose_estimator.eval(eval_dataset, use_subset=False, verbose=True, silent=True,
images_folder_name="image", annotations_filename="annotation.json")
print("Evaluation results = ", results_dict)
| 39.666667 | 106 | 0.684211 |
08cd88d42bececef9b8d31ca97c04fc35e4959e7 | 356 | py | Python | send_script.py | nlpcl-lab/event-extraction | 05975c348bf7e278cdf086bc3a5171ad28fce14f | [
"Apache-2.0"
] | 23 | 2019-12-20T14:35:13.000Z | 2022-03-23T23:12:53.000Z | send_script.py | nlpcl-lab/event-extraction | 05975c348bf7e278cdf086bc3a5171ad28fce14f | [
"Apache-2.0"
] | 2 | 2020-09-20T05:20:58.000Z | 2022-03-20T10:28:36.000Z | send_script.py | nlpcl-lab/event-extraction | 05975c348bf7e278cdf086bc3a5171ad28fce14f | [
"Apache-2.0"
] | 4 | 2020-04-10T05:44:20.000Z | 2020-09-18T11:44:31.000Z | import requests
filenames = ['10_1_mic1.wav','10_1_mic2.wav']
files = dict()
for filename in filenames:
f = open(filename, 'rb')
files[filename] = f
res = requests.post('http://localhost:8080/upload', files=files)
print('res :', res)
r = requests.get('http://localhost:8080/download')
with open('result.wav', 'wb') as f:
f.write(r.content)
| 22.25 | 64 | 0.671348 |
2c3e379228b1172560adf14bde1a6dd5b2be7ad5 | 435 | py | Python | tests/test_sjd.py | StarkillerX42/ObserverTools | a3bc48179a1ed445e7f4232426dce8c1c28bb8e4 | [
"BSD-3-Clause"
] | null | null | null | tests/test_sjd.py | StarkillerX42/ObserverTools | a3bc48179a1ed445e7f4232426dce8c1c28bb8e4 | [
"BSD-3-Clause"
] | null | null | null | tests/test_sjd.py | StarkillerX42/ObserverTools | a3bc48179a1ed445e7f4232426dce8c1c28bb8e4 | [
"BSD-3-Clause"
] | null | null | null | #!/usr/bin/env python3
import pytest
from astropy.time import Time
from bin import sjd
class TestSJD():
def test_astropy(self):
"""Checks to see if astropy.time agrees with mjd.mjd"""
astropy_mjd = int(Time.now().mjd + 0.3)
mjd_mjd = sjd.sjd()
print(astropy_mjd, mjd_mjd)
assert astropy_mjd == mjd_mjd, "Astropy solution must match sjd.sjd"
if __name__ == '__main__':
pytest.main()
| 22.894737 | 76 | 0.652874 |
06b8d518d127234a5ac96cab10784921b5448808 | 148,849 | py | Python | FWCore/ParameterSet/python/Config.py | bisnupriyasahu/cmssw | 6cf37ca459246525be0e8a6f5172c6123637d259 | [
"Apache-2.0"
] | 1 | 2019-08-09T08:42:11.000Z | 2019-08-09T08:42:11.000Z | FWCore/ParameterSet/python/Config.py | bisnupriyasahu/cmssw | 6cf37ca459246525be0e8a6f5172c6123637d259 | [
"Apache-2.0"
] | null | null | null | FWCore/ParameterSet/python/Config.py | bisnupriyasahu/cmssw | 6cf37ca459246525be0e8a6f5172c6123637d259 | [
"Apache-2.0"
] | 1 | 2019-04-03T19:23:27.000Z | 2019-04-03T19:23:27.000Z | #!/usr/bin/env python
### command line options helper
from __future__ import print_function
from __future__ import absolute_import
import six
from .Options import Options
options = Options()
## imports
import sys
from .Mixins import PrintOptions,_ParameterTypeBase,_SimpleParameterTypeBase, _Parameterizable, _ConfigureComponent, _TypedParameterizable, _Labelable, _Unlabelable, _ValidatingListBase, _modifyParametersFromDict
from .Mixins import *
from .Types import *
from .Modules import *
from .Modules import _Module
from .SequenceTypes import *
from .SequenceTypes import _ModuleSequenceType, _Sequenceable #extend needs it
from .SequenceVisitors import PathValidator, EndPathValidator, ScheduleTaskValidator, NodeVisitor, CompositeVisitor, ModuleNamesFromGlobalsVisitor
from . import DictTypes
from .ExceptionHandling import *
#when building RECO paths we have hit the default recursion limit
if sys.getrecursionlimit()<5000:
sys.setrecursionlimit(5000)
def checkImportPermission(minLevel = 2, allowedPatterns = []):
"""
Raise an exception if called by special config files. This checks
the call or import stack for the importing file. An exception is raised if
the importing module is not in allowedPatterns and if it is called too deeply:
minLevel = 2: inclusion by top lvel cfg only
minLevel = 1: No inclusion allowed
allowedPatterns = ['Module1','Module2/SubModule1'] allows import
by any module in Module1 or Submodule1
"""
import inspect
import os
ignorePatterns = ['FWCore/ParameterSet/Config.py','<string>']
CMSSWPath = [os.environ['CMSSW_BASE'],os.environ['CMSSW_RELEASE_BASE']]
# Filter the stack to things in CMSSWPath and not in ignorePatterns
trueStack = []
for item in inspect.stack():
inPath = False
ignore = False
for pattern in CMSSWPath:
if item[1].find(pattern) != -1:
inPath = True
break
if item[1].find('/') == -1: # The base file, no path
inPath = True
for pattern in ignorePatterns:
if item[1].find(pattern) != -1:
ignore = True
break
if inPath and not ignore:
trueStack.append(item[1])
importedFile = trueStack[0]
importedBy = ''
if len(trueStack) > 1:
importedBy = trueStack[1]
for pattern in allowedPatterns:
if importedBy.find(pattern) > -1:
return True
if len(trueStack) <= minLevel: # Imported directly
return True
raise ImportError("Inclusion of %s is allowed only by cfg or specified cfi files."
% importedFile)
def findProcess(module):
"""Look inside the module and find the Processes it contains"""
class Temp(object):
pass
process = None
if isinstance(module,dict):
if 'process' in module:
p = module['process']
module = Temp()
module.process = p
if hasattr(module,'process'):
if isinstance(module.process,Process):
process = module.process
else:
raise RuntimeError("The attribute named 'process' does not inherit from the Process class")
else:
raise RuntimeError("no 'process' attribute found in the module, please add one")
return process
class Process(object):
"""Root class for a CMS configuration process"""
def __init__(self,name,*Mods):
"""The argument 'name' will be the name applied to this Process
Can optionally pass as additional arguments cms.Modifier instances
that will be used to modify the Process as it is built
"""
self.__dict__['_Process__name'] = name
if not name.isalnum():
raise RuntimeError("Error: The process name is an empty string or contains non-alphanumeric characters")
self.__dict__['_Process__filters'] = {}
self.__dict__['_Process__producers'] = {}
self.__dict__['_Process__switchproducers'] = {}
self.__dict__['_Process__source'] = None
self.__dict__['_Process__looper'] = None
self.__dict__['_Process__subProcesses'] = []
self.__dict__['_Process__schedule'] = None
self.__dict__['_Process__analyzers'] = {}
self.__dict__['_Process__outputmodules'] = {}
self.__dict__['_Process__paths'] = DictTypes.SortedKeysDict() # have to keep the order
self.__dict__['_Process__endpaths'] = DictTypes.SortedKeysDict() # of definition
self.__dict__['_Process__sequences'] = {}
self.__dict__['_Process__tasks'] = {}
self.__dict__['_Process__services'] = {}
self.__dict__['_Process__essources'] = {}
self.__dict__['_Process__esproducers'] = {}
self.__dict__['_Process__esprefers'] = {}
self.__dict__['_Process__aliases'] = {}
self.__dict__['_Process__psets']={}
self.__dict__['_Process__vpsets']={}
self.__dict__['_cloneToObjectDict'] = {}
# policy switch to avoid object overwriting during extend/load
self.__dict__['_Process__InExtendCall'] = False
self.__dict__['_Process__partialschedules'] = {}
self.__isStrict = False
self.__dict__['_Process__modifiers'] = Mods
for m in self.__modifiers:
m._setChosen()
def setStrict(self, value):
self.__isStrict = value
_Module.__isStrict__ = True
# some user-friendly methods for command-line browsing
def producerNames(self):
"""Returns a string containing all the EDProducer labels separated by a blank"""
return ' '.join(self.producers_().keys())
def switchProducerNames(self):
"""Returns a string containing all the SwitchProducer labels separated by a blank"""
return ' '.join(self.switchProducers_().keys())
def analyzerNames(self):
"""Returns a string containing all the EDAnalyzer labels separated by a blank"""
return ' '.join(self.analyzers_().keys())
def filterNames(self):
"""Returns a string containing all the EDFilter labels separated by a blank"""
return ' '.join(self.filters_().keys())
def pathNames(self):
"""Returns a string containing all the Path names separated by a blank"""
return ' '.join(self.paths_().keys())
def __setstate__(self, pkldict):
"""
Unpickling hook.
Since cloneToObjectDict stores a hash of objects by their
id() it needs to be updated when unpickling to use the
new object id values instantiated during the unpickle.
"""
self.__dict__.update(pkldict)
tmpDict = {}
for value in self._cloneToObjectDict.values():
tmpDict[id(value)] = value
self.__dict__['_cloneToObjectDict'] = tmpDict
def filters_(self):
"""returns a dict of the filters that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__filters)
filters = property(filters_, doc="dictionary containing the filters for the process")
def name_(self):
return self.__name
def setName_(self,name):
if not name.isalnum():
raise RuntimeError("Error: The process name is an empty string or contains non-alphanumeric characters")
self.__dict__['_Process__name'] = name
process = property(name_,setName_, doc="name of the process")
def producers_(self):
"""returns a dict of the producers that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__producers)
producers = property(producers_,doc="dictionary containing the producers for the process")
def switchProducers_(self):
"""returns a dict of the SwitchProducers that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__switchproducers)
switchProducers = property(switchProducers_,doc="dictionary containing the SwitchProducers for the process")
def source_(self):
"""returns the source that has been added to the Process or None if none have been added"""
return self.__source
def setSource_(self,src):
self._placeSource('source',src)
source = property(source_,setSource_,doc='the main source or None if not set')
def looper_(self):
"""returns the looper that has been added to the Process or None if none have been added"""
return self.__looper
def setLooper_(self,lpr):
self._placeLooper('looper',lpr)
looper = property(looper_,setLooper_,doc='the main looper or None if not set')
def subProcesses_(self):
"""returns a list of the subProcesses that have been added to the Process"""
return self.__subProcesses
subProcesses = property(subProcesses_,doc='the SubProcesses that have been added to the Process')
def analyzers_(self):
"""returns a dict of the analyzers that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__analyzers)
analyzers = property(analyzers_,doc="dictionary containing the analyzers for the process")
def outputModules_(self):
"""returns a dict of the output modules that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__outputmodules)
outputModules = property(outputModules_,doc="dictionary containing the output_modules for the process")
def paths_(self):
"""returns a dict of the paths that have been added to the Process"""
return DictTypes.SortedAndFixedKeysDict(self.__paths)
paths = property(paths_,doc="dictionary containing the paths for the process")
def endpaths_(self):
"""returns a dict of the endpaths that have been added to the Process"""
return DictTypes.SortedAndFixedKeysDict(self.__endpaths)
endpaths = property(endpaths_,doc="dictionary containing the endpaths for the process")
def sequences_(self):
"""returns a dict of the sequences that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__sequences)
sequences = property(sequences_,doc="dictionary containing the sequences for the process")
def tasks_(self):
"""returns a dict of the tasks that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__tasks)
tasks = property(tasks_,doc="dictionary containing the tasks for the process")
def schedule_(self):
"""returns the schedule that has been added to the Process or None if none have been added"""
return self.__schedule
def setPartialSchedule_(self,sch,label):
if label == "schedule":
self.setSchedule_(sch)
else:
self._place(label, sch, self.__partialschedules)
def setSchedule_(self,sch):
# See if every path and endpath has been inserted into the process
index = 0
try:
for p in sch:
p.label_()
index +=1
except:
raise RuntimeError("The path at index "+str(index)+" in the Schedule was not attached to the process.")
self.__dict__['_Process__schedule'] = sch
schedule = property(schedule_,setSchedule_,doc='the schedule or None if not set')
def services_(self):
"""returns a dict of the services that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__services)
services = property(services_,doc="dictionary containing the services for the process")
def es_producers_(self):
"""returns a dict of the esproducers that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__esproducers)
es_producers = property(es_producers_,doc="dictionary containing the es_producers for the process")
def es_sources_(self):
"""returns a the es_sources that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__essources)
es_sources = property(es_sources_,doc="dictionary containing the es_sources for the process")
def es_prefers_(self):
"""returns a dict of the es_prefers that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__esprefers)
es_prefers = property(es_prefers_,doc="dictionary containing the es_prefers for the process")
def aliases_(self):
"""returns a dict of the aliases that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__aliases)
aliases = property(aliases_,doc="dictionary containing the aliases for the process")
def psets_(self):
"""returns a dict of the PSets that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__psets)
psets = property(psets_,doc="dictionary containing the PSets for the process")
def vpsets_(self):
"""returns a dict of the VPSets that have been added to the Process"""
return DictTypes.FixedKeysDict(self.__vpsets)
vpsets = property(vpsets_,doc="dictionary containing the PSets for the process")
def isUsingModifier(self,mod):
"""returns True if the Modifier is in used by this Process"""
if mod._isChosen():
for m in self.__modifiers:
if m._isOrContains(mod):
return True
return False
def __setObjectLabel(self, object, newLabel) :
if not object.hasLabel_() :
object.setLabel(newLabel)
return
if newLabel == object.label_() :
return
if newLabel is None :
object.setLabel(None)
return
if (hasattr(self, object.label_()) and id(getattr(self, object.label_())) == id(object)) :
msg100 = "Attempting to change the label of an attribute of the Process\n"
msg101 = "Old label = "+object.label_()+" New label = "+newLabel+"\n"
msg102 = "Type = "+str(type(object))+"\n"
msg103 = "Some possible solutions:\n"
msg104 = " 1. Clone modules instead of using simple assignment. Cloning is\n"
msg105 = " also preferred for other types when possible.\n"
msg106 = " 2. Declare new names starting with an underscore if they are\n"
msg107 = " for temporaries you do not want propagated into the Process. The\n"
msg108 = " underscore tells \"from x import *\" and process.load not to import\n"
msg109 = " the name.\n"
msg110 = " 3. Reorganize so the assigment is not necessary. Giving a second\n"
msg111 = " name to the same object usually causes confusion and problems.\n"
msg112 = " 4. Compose Sequences: newName = cms.Sequence(oldName)\n"
raise ValueError(msg100+msg101+msg102+msg103+msg104+msg105+msg106+msg107+msg108+msg109+msg110+msg111+msg112)
object.setLabel(None)
object.setLabel(newLabel)
def __setattr__(self,name,value):
# check if the name is well-formed (only _ and alphanumerics are allowed)
if not name.replace('_','').isalnum():
raise ValueError('The label '+name+' contains forbiden characters')
# private variable exempt from all this
if name.startswith('_Process__'):
self.__dict__[name]=value
return
if not isinstance(value,_ConfigureComponent):
raise TypeError("can only assign labels to an object that inherits from '_ConfigureComponent'\n"
+"an instance of "+str(type(value))+" will not work - requested label is "+name)
if not isinstance(value,_Labelable) and not isinstance(value,Source) and not isinstance(value,Looper) and not isinstance(value,Schedule):
if name == value.type_():
# Only Services get handled here
self.add_(value)
return
else:
raise TypeError("an instance of "+str(type(value))+" can not be assigned the label '"+name+"'.\n"+
"Please either use the label '"+value.type_()+" or use the 'add_' method instead.")
#clone the item
if self.__isStrict:
newValue =value.copy()
try:
newValue._filename = value._filename
except:
pass
value.setIsFrozen()
else:
newValue =value
if not self._okToPlace(name, value, self.__dict__):
newFile='top level config'
if hasattr(value,'_filename'):
newFile = value._filename
oldFile='top level config'
oldValue = getattr(self,name)
if hasattr(oldValue,'_filename'):
oldFile = oldValue._filename
msg = "Trying to override definition of process."+name
msg += "\n new object defined in: "+newFile
msg += "\n existing object defined in: "+oldFile
raise ValueError(msg)
# remove the old object of the name (if there is one)
if hasattr(self,name) and not (getattr(self,name)==newValue):
# Complain if items in sequences or tasks from load() statements have
# degenerate names, but if the user overwrites a name in the
# main config, replace it everywhere
if newValue._isTaskComponent():
if not self.__InExtendCall:
self._replaceInTasks(name, newValue)
self._replaceInSchedule(name, newValue)
else:
if not isinstance(newValue, Task):
#should check to see if used in task before complaining
newFile='top level config'
if hasattr(value,'_filename'):
newFile = value._filename
oldFile='top level config'
oldValue = getattr(self,name)
if hasattr(oldValue,'_filename'):
oldFile = oldValue._filename
msg1 = "Trying to override definition of "+name+" while it is used by the task "
msg2 = "\n new object defined in: "+newFile
msg2 += "\n existing object defined in: "+oldFile
s = self.__findFirstUsingModule(self.tasks,oldValue)
if s is not None:
raise ValueError(msg1+s.label_()+msg2)
if isinstance(newValue, _Sequenceable) or newValue._isTaskComponent():
if not self.__InExtendCall:
self._replaceInSequences(name, newValue)
else:
#should check to see if used in sequence before complaining
newFile='top level config'
if hasattr(value,'_filename'):
newFile = value._filename
oldFile='top level config'
oldValue = getattr(self,name)
if hasattr(oldValue,'_filename'):
oldFile = oldValue._filename
msg1 = "Trying to override definition of "+name+" while it is used by the "
msg2 = "\n new object defined in: "+newFile
msg2 += "\n existing object defined in: "+oldFile
s = self.__findFirstUsingModule(self.sequences,oldValue)
if s is not None:
raise ValueError(msg1+"sequence "+s.label_()+msg2)
s = self.__findFirstUsingModule(self.paths,oldValue)
if s is not None:
raise ValueError(msg1+"path "+s.label_()+msg2)
s = self.__findFirstUsingModule(self.endpaths,oldValue)
if s is not None:
raise ValueError(msg1+"endpath "+s.label_()+msg2)
self._delattrFromSetattr(name)
self.__dict__[name]=newValue
if isinstance(newValue,_Labelable):
self.__setObjectLabel(newValue, name)
self._cloneToObjectDict[id(value)] = newValue
self._cloneToObjectDict[id(newValue)] = newValue
#now put in proper bucket
newValue._place(name,self)
def __findFirstUsingModule(self, seqsOrTasks, mod):
"""Given a container of sequences or tasks, find the first sequence or task
containing mod and return it. If none is found, return None"""
from FWCore.ParameterSet.SequenceTypes import ModuleNodeVisitor
l = list()
for seqOrTask in six.itervalues(seqsOrTasks):
l[:] = []
v = ModuleNodeVisitor(l)
seqOrTask.visit(v)
if mod in l:
return seqOrTask
return None
def _delHelper(self,name):
if not hasattr(self,name):
raise KeyError('process does not know about '+name)
elif name.startswith('_Process__'):
raise ValueError('this attribute cannot be deleted')
# we have to remove it from all dictionaries/registries
dicts = [item for item in self.__dict__.values() if (isinstance(item, dict) or isinstance(item, DictTypes.SortedKeysDict))]
for reg in dicts:
if name in reg: del reg[name]
# if it was a labelable object, the label needs to be removed
obj = getattr(self,name)
if isinstance(obj,_Labelable):
obj.setLabel(None)
if isinstance(obj,Service):
obj._inProcess = False
def __delattr__(self,name):
self._delHelper(name)
obj = getattr(self,name)
if not obj is None:
if not isinstance(obj, Sequence) and not isinstance(obj, Task):
# For modules, ES modules and services we can also remove
# the deleted object from Sequences, Paths, EndPaths, and
# Tasks. Note that for Sequences and Tasks that cannot be done
# reliably as the places where the Sequence or Task was used
# might have been expanded so we do not even try. We considered
# raising an exception if a Sequences or Task was explicitly
# deleted, but did not because when done carefully deletion
# is sometimes OK (for example in the prune function where it
# has been checked that the deleted Sequence is not used).
if obj._isTaskComponent():
self._replaceInTasks(name, None)
self._replaceInSchedule(name, None)
if isinstance(obj, _Sequenceable) or obj._isTaskComponent():
self._replaceInSequences(name, None)
# now remove it from the process itself
try:
del self.__dict__[name]
except:
pass
def _delattrFromSetattr(self,name):
"""Similar to __delattr__ but we need different behavior when called from __setattr__"""
self._delHelper(name)
# now remove it from the process itself
try:
del self.__dict__[name]
except:
pass
def add_(self,value):
"""Allows addition of components that do not have to have a label, e.g. Services"""
if not isinstance(value,_ConfigureComponent):
raise TypeError
if not isinstance(value,_Unlabelable):
raise TypeError
#clone the item
#clone the item
if self.__isStrict:
newValue =value.copy()
value.setIsFrozen()
else:
newValue =value
newValue._place('',self)
def _okToPlace(self, name, mod, d):
if not self.__InExtendCall:
# if going
return True
elif not self.__isStrict:
return True
elif name in d:
# if there's an old copy, and the new one
# hasn't been modified, we're done. Still
# not quite safe if something has been defined twice.
# Need to add checks
if mod._isModified:
if d[name]._isModified:
return False
else:
return True
else:
return True
else:
return True
def _place(self, name, mod, d):
if self._okToPlace(name, mod, d):
if self.__isStrict and isinstance(mod, _ModuleSequenceType):
d[name] = mod._postProcessFixup(self._cloneToObjectDict)
else:
d[name] = mod
if isinstance(mod,_Labelable):
self.__setObjectLabel(mod, name)
def _placeOutputModule(self,name,mod):
self._place(name, mod, self.__outputmodules)
def _placeProducer(self,name,mod):
self._place(name, mod, self.__producers)
def _placeSwitchProducer(self,name,mod):
self._place(name, mod, self.__switchproducers)
def _placeFilter(self,name,mod):
self._place(name, mod, self.__filters)
def _placeAnalyzer(self,name,mod):
self._place(name, mod, self.__analyzers)
def _placePath(self,name,mod):
self._validateSequence(mod, name)
try:
self._place(name, mod, self.__paths)
except ModuleCloneError as msg:
context = format_outerframe(4)
raise Exception("%sThe module %s in path %s is unknown to the process %s." %(context, msg, name, self._Process__name))
def _placeEndPath(self,name,mod):
self._validateSequence(mod, name)
try:
self._place(name, mod, self.__endpaths)
except ModuleCloneError as msg:
context = format_outerframe(4)
raise Exception("%sThe module %s in endpath %s is unknown to the process %s." %(context, msg, name, self._Process__name))
def _placeSequence(self,name,mod):
self._validateSequence(mod, name)
self._place(name, mod, self.__sequences)
def _placeESProducer(self,name,mod):
self._place(name, mod, self.__esproducers)
def _placeESPrefer(self,name,mod):
self._place(name, mod, self.__esprefers)
def _placeESSource(self,name,mod):
self._place(name, mod, self.__essources)
def _placeTask(self,name,task):
self._validateTask(task, name)
self._place(name, task, self.__tasks)
def _placeAlias(self,name,mod):
self._place(name, mod, self.__aliases)
def _placePSet(self,name,mod):
self._place(name, mod, self.__psets)
def _placeVPSet(self,name,mod):
self._place(name, mod, self.__vpsets)
def _placeSource(self,name,mod):
"""Allow the source to be referenced by 'source' or by type name"""
if name != 'source':
raise ValueError("The label '"+name+"' can not be used for a Source. Only 'source' is allowed.")
if self.__dict__['_Process__source'] is not None :
del self.__dict__[self.__dict__['_Process__source'].type_()]
self.__dict__['_Process__source'] = mod
self.__dict__[mod.type_()] = mod
def _placeLooper(self,name,mod):
if name != 'looper':
raise ValueError("The label '"+name+"' can not be used for a Looper. Only 'looper' is allowed.")
self.__dict__['_Process__looper'] = mod
self.__dict__[mod.type_()] = mod
def _placeSubProcess(self,name,mod):
self.__dict__['_Process__subProcess'] = mod
self.__dict__[mod.type_()] = mod
def addSubProcess(self,mod):
self.__subProcesses.append(mod)
def _placeService(self,typeName,mod):
self._place(typeName, mod, self.__services)
if typeName in self.__dict__:
self.__dict__[typeName]._inProcess = False
self.__dict__[typeName]=mod
def load(self, moduleName):
moduleName = moduleName.replace("/",".")
module = __import__(moduleName)
self.extend(sys.modules[moduleName])
def extend(self,other,items=()):
"""Look in other and find types that we can use"""
# enable explicit check to avoid overwriting of existing objects
self.__dict__['_Process__InExtendCall'] = True
seqs = dict()
tasksToAttach = dict()
mods = []
for name in dir(other):
#'from XX import *' ignores these, and so should we.
if name.startswith('_'):
continue
item = getattr(other,name)
if name == "source" or name == "looper":
# In these cases 'item' could be None if the specific object was not defined
if item is not None:
self.__setattr__(name,item)
elif isinstance(item,_ModuleSequenceType):
seqs[name]=item
elif isinstance(item,Task):
tasksToAttach[name] = item
elif isinstance(item,_Labelable):
self.__setattr__(name,item)
if not item.hasLabel_() :
item.setLabel(name)
elif isinstance(item,Schedule):
self.__setattr__(name,item)
elif isinstance(item,_Unlabelable):
self.add_(item)
elif isinstance(item,ProcessModifier):
mods.append(item)
elif isinstance(item,ProcessFragment):
self.extend(item)
#now create a sequence that uses the newly made items
for name,seq in six.iteritems(seqs):
if id(seq) not in self._cloneToObjectDict:
self.__setattr__(name,seq)
else:
newSeq = self._cloneToObjectDict[id(seq)]
self.__dict__[name]=newSeq
self.__setObjectLabel(newSeq, name)
#now put in proper bucket
newSeq._place(name,self)
for name, task in six.iteritems(tasksToAttach):
self.__setattr__(name, task)
#apply modifiers now that all names have been added
for item in mods:
item.apply(self)
self.__dict__['_Process__InExtendCall'] = False
def _dumpConfigNamedList(self,items,typeName,options):
returnValue = ''
for name,item in items:
returnValue +=options.indentation()+typeName+' '+name+' = '+item.dumpConfig(options)
return returnValue
def _dumpConfigUnnamedList(self,items,typeName,options):
returnValue = ''
for name,item in items:
returnValue +=options.indentation()+typeName+' = '+item.dumpConfig(options)
return returnValue
def _dumpConfigOptionallyNamedList(self,items,typeName,options):
returnValue = ''
for name,item in items:
if name == item.type_():
name = ''
returnValue +=options.indentation()+typeName+' '+name+' = '+item.dumpConfig(options)
return returnValue
def dumpConfig(self, options=PrintOptions()):
"""return a string containing the equivalent process defined using the old configuration language"""
config = "process "+self.__name+" = {\n"
options.indent()
if self.source_():
config += options.indentation()+"source = "+self.source_().dumpConfig(options)
if self.looper_():
config += options.indentation()+"looper = "+self.looper_().dumpConfig(options)
config+=self._dumpConfigNamedList(self.subProcesses_(),
'subProcess',
options)
config+=self._dumpConfigNamedList(six.iteritems(self.producers_()),
'module',
options)
config+=self._dumpConfigNamedList(six.iteritems(self.switchProducers_()),
'module',
options)
config+=self._dumpConfigNamedList(six.iteritems(self.filters_()),
'module',
options)
config+=self._dumpConfigNamedList(six.iteritems(self.analyzers_()),
'module',
options)
config+=self._dumpConfigNamedList(six.iteritems(self.outputModules_()),
'module',
options)
config+=self._dumpConfigNamedList(six.iteritems(self.sequences_()),
'sequence',
options)
config+=self._dumpConfigNamedList(six.iteritems(self.paths_()),
'path',
options)
config+=self._dumpConfigNamedList(six.iteritems(self.endpaths_()),
'endpath',
options)
config+=self._dumpConfigUnnamedList(six.iteritems(self.services_()),
'service',
options)
config+=self._dumpConfigNamedList(six.iteritems(self.aliases_()),
'alias',
options)
config+=self._dumpConfigOptionallyNamedList(
six.iteritems(self.es_producers_()),
'es_module',
options)
config+=self._dumpConfigOptionallyNamedList(
six.iteritems(self.es_sources_()),
'es_source',
options)
config += self._dumpConfigESPrefers(options)
for name,item in six.iteritems(self.psets):
config +=options.indentation()+item.configTypeName()+' '+name+' = '+item.configValue(options)
for name,item in six.iteritems(self.vpsets):
config +=options.indentation()+'VPSet '+name+' = '+item.configValue(options)
if self.schedule:
pathNames = [p.label_() for p in self.schedule]
config +=options.indentation()+'schedule = {'+','.join(pathNames)+'}\n'
# config+=self._dumpConfigNamedList(six.iteritems(self.vpsets),
# 'VPSet',
# options)
config += "}\n"
options.unindent()
return config
def _dumpConfigESPrefers(self, options):
result = ''
for item in six.itervalues(self.es_prefers_()):
result +=options.indentation()+'es_prefer '+item.targetLabel_()+' = '+item.dumpConfig(options)
return result
def _dumpPythonSubProcesses(self, l, options):
returnValue = ''
for item in l:
returnValue += item.dumpPython(options)+'\n\n'
return returnValue
def _dumpPythonList(self, d, options):
returnValue = ''
if isinstance(d, DictTypes.SortedKeysDict):
for name,item in d.items():
returnValue +='process.'+name+' = '+item.dumpPython(options)+'\n\n'
else:
for name,item in sorted(d.items()):
returnValue +='process.'+name+' = '+item.dumpPython(options)+'\n\n'
return returnValue
def _validateSequence(self, sequence, label):
# See if every module has been inserted into the process
try:
l = set()
visitor = NodeNameVisitor(l)
sequence.visit(visitor)
except:
raise RuntimeError("An entry in sequence "+label + ' has no label')
def _validateTask(self, task, label):
# See if every module and service has been inserted into the process
try:
l = set()
visitor = NodeNameVisitor(l)
task.visit(visitor)
except:
raise RuntimeError("An entry in task " + label + ' has not been attached to the process')
def _itemsInDependencyOrder(self, processDictionaryOfItems):
# The items can be Sequences or Tasks and the input
# argument should either be the dictionary of sequences
# or the dictionary of tasks from the process.
returnValue=DictTypes.SortedKeysDict()
# For each item, see what other items it depends upon
# For our purpose here, an item depends on the items it contains.
dependencies = {}
for label,item in six.iteritems(processDictionaryOfItems):
containedItems = []
if isinstance(item, Task):
v = TaskVisitor(containedItems)
else:
v = SequenceVisitor(containedItems)
try:
item.visit(v)
except RuntimeError:
if isinstance(item, Task):
raise RuntimeError("Failed in a Task visitor. Probably " \
"a circular dependency discovered in Task with label " + label)
else:
raise RuntimeError("Failed in a Sequence visitor. Probably a " \
"circular dependency discovered in Sequence with label " + label)
for containedItem in containedItems:
# Check for items that both have labels and are not in the process.
# This should not normally occur unless someone explicitly assigns a
# label without putting the item in the process (which should not ever
# be done). We check here because this problem could cause the code
# in the 'while' loop below to go into an infinite loop.
if containedItem.hasLabel_():
testItem = processDictionaryOfItems.get(containedItem.label_())
if testItem is None or containedItem != testItem:
if isinstance(item, Task):
raise RuntimeError("Task has a label, but using its label to get an attribute" \
" from the process yields a different object or None\n"+
"label = " + containedItem.label_())
else:
raise RuntimeError("Sequence has a label, but using its label to get an attribute" \
" from the process yields a different object or None\n"+
"label = " + containedItem.label_())
dependencies[label]=[dep.label_() for dep in containedItems if dep.hasLabel_()]
# keep looping until we get rid of all dependencies
while dependencies:
oldDeps = dict(dependencies)
for label,deps in six.iteritems(oldDeps):
if len(deps)==0:
returnValue[label]=processDictionaryOfItems[label]
#remove this as a dependency for all other tasks
del dependencies[label]
for lb2,deps2 in six.iteritems(dependencies):
while deps2.count(label):
deps2.remove(label)
return returnValue
def _dumpPython(self, d, options):
result = ''
for name, value in sorted(six.iteritems(d)):
result += value.dumpPythonAs(name,options)+'\n'
return result
def dumpPython(self, options=PrintOptions()):
"""return a string containing the equivalent process defined using python"""
specialImportRegistry._reset()
header = "import FWCore.ParameterSet.Config as cms"
result = "process = cms.Process(\""+self.__name+"\")\n\n"
if self.source_():
result += "process.source = "+self.source_().dumpPython(options)
if self.looper_():
result += "process.looper = "+self.looper_().dumpPython()
result+=self._dumpPythonList(self.psets, options)
result+=self._dumpPythonList(self.vpsets, options)
result+=self._dumpPythonSubProcesses(self.subProcesses_(), options)
result+=self._dumpPythonList(self.producers_(), options)
result+=self._dumpPythonList(self.switchProducers_(), options)
result+=self._dumpPythonList(self.filters_() , options)
result+=self._dumpPythonList(self.analyzers_(), options)
result+=self._dumpPythonList(self.outputModules_(), options)
result+=self._dumpPythonList(self.services_(), options)
result+=self._dumpPythonList(self.es_producers_(), options)
result+=self._dumpPythonList(self.es_sources_(), options)
result+=self._dumpPython(self.es_prefers_(), options)
result+=self._dumpPythonList(self._itemsInDependencyOrder(self.tasks), options)
result+=self._dumpPythonList(self._itemsInDependencyOrder(self.sequences), options)
result+=self._dumpPythonList(self.paths_(), options)
result+=self._dumpPythonList(self.endpaths_(), options)
result+=self._dumpPythonList(self.aliases_(), options)
if not self.schedule_() == None:
result += 'process.schedule = ' + self.schedule.dumpPython(options)
imports = specialImportRegistry.getSpecialImports()
if len(imports) > 0:
header += "\n" + "\n".join(imports)
header += "\n\n"
return header+result
def _replaceInSequences(self, label, new):
old = getattr(self,label)
#TODO - replace by iterator concatenation
for sequenceable in six.itervalues(self.sequences):
sequenceable.replace(old,new)
for sequenceable in six.itervalues(self.paths):
sequenceable.replace(old,new)
for sequenceable in six.itervalues(self.endpaths):
sequenceable.replace(old,new)
def _replaceInTasks(self, label, new):
old = getattr(self,label)
for task in six.itervalues(self.tasks):
task.replace(old, new)
def _replaceInSchedule(self, label, new):
if self.schedule_() == None:
return
old = getattr(self,label)
for task in self.schedule_()._tasks:
task.replace(old, new)
def globalReplace(self,label,new):
""" Replace the item with label 'label' by object 'new' in the process and all sequences/paths/tasks"""
if not hasattr(self,label):
raise LookupError("process has no item of label "+label)
setattr(self,label,new)
def _insertInto(self, parameterSet, itemDict):
for name,value in six.iteritems(itemDict):
value.insertInto(parameterSet, name)
def _insertOneInto(self, parameterSet, label, item, tracked):
vitems = []
if not item == None:
newlabel = item.nameInProcessDesc_(label)
vitems = [newlabel]
item.insertInto(parameterSet, newlabel)
parameterSet.addVString(tracked, label, vitems)
def _insertManyInto(self, parameterSet, label, itemDict, tracked):
l = []
for name,value in six.iteritems(itemDict):
value.appendToProcessDescList_(l, name)
value.insertInto(parameterSet, name)
# alphabetical order is easier to compare with old language
l.sort()
parameterSet.addVString(tracked, label, l)
def _insertSwitchProducersInto(self, parameterSet, labelModules, labelAliases, itemDict, tracked):
modules = parameterSet.getVString(tracked, labelModules)
aliases = parameterSet.getVString(tracked, labelAliases)
for name,value in six.iteritems(itemDict):
value.appendToProcessDescLists_(modules, aliases, name)
value.insertInto(parameterSet, name)
modules.sort()
aliases.sort()
parameterSet.addVString(tracked, labelModules, modules)
parameterSet.addVString(tracked, labelAliases, aliases)
def _insertSubProcessesInto(self, parameterSet, label, itemList, tracked):
l = []
subprocs = []
for value in itemList:
name = value.getProcessName()
newLabel = value.nameInProcessDesc_(name)
l.append(newLabel)
pset = value.getSubProcessPSet(parameterSet)
subprocs.append(pset)
# alphabetical order is easier to compare with old language
l.sort()
parameterSet.addVString(tracked, label, l)
parameterSet.addVPSet(False,"subProcesses",subprocs)
def _insertPaths(self, processPSet, nodeVisitor):
scheduledPaths = []
triggerPaths = []
endpaths = []
if self.schedule_() == None:
# make one from triggerpaths & endpaths
for name in self.paths_():
scheduledPaths.append(name)
triggerPaths.append(name)
for name in self.endpaths_():
scheduledPaths.append(name)
endpaths.append(name)
else:
for path in self.schedule_():
pathname = path.label_()
scheduledPaths.append(pathname)
if pathname in self.endpaths_():
endpaths.append(pathname)
else:
triggerPaths.append(pathname)
for task in self.schedule_()._tasks:
task.resolve(self.__dict__)
scheduleTaskValidator = ScheduleTaskValidator()
task.visit(scheduleTaskValidator)
task.visit(nodeVisitor)
processPSet.addVString(True, "@end_paths", endpaths)
processPSet.addVString(True, "@paths", scheduledPaths)
# trigger_paths are a little different
p = processPSet.newPSet()
p.addVString(True, "@trigger_paths", triggerPaths)
processPSet.addPSet(True, "@trigger_paths", p)
# add all these paths
pathValidator = PathValidator()
endpathValidator = EndPathValidator()
decoratedList = []
lister = DecoratedNodeNameVisitor(decoratedList)
pathCompositeVisitor = CompositeVisitor(pathValidator, nodeVisitor, lister)
endpathCompositeVisitor = CompositeVisitor(endpathValidator, nodeVisitor, lister)
for triggername in triggerPaths:
iPath = self.paths_()[triggername]
iPath.resolve(self.__dict__)
pathValidator.setLabel(triggername)
lister.initialize()
iPath.visit(pathCompositeVisitor)
iPath.insertInto(processPSet, triggername, decoratedList)
for endpathname in endpaths:
iEndPath = self.endpaths_()[endpathname]
iEndPath.resolve(self.__dict__)
endpathValidator.setLabel(endpathname)
lister.initialize()
iEndPath.visit(endpathCompositeVisitor)
iEndPath.insertInto(processPSet, endpathname, decoratedList)
processPSet.addVString(False, "@filters_on_endpaths", endpathValidator.filtersOnEndpaths)
def resolve(self,keepUnresolvedSequencePlaceholders=False):
for x in six.itervalues(self.paths):
x.resolve(self.__dict__,keepUnresolvedSequencePlaceholders)
for x in six.itervalues(self.endpaths):
x.resolve(self.__dict__,keepUnresolvedSequencePlaceholders)
if not self.schedule_() == None:
for task in self.schedule_()._tasks:
task.resolve(self.__dict__,keepUnresolvedSequencePlaceholders)
def prune(self,verbose=False,keepUnresolvedSequencePlaceholders=False):
""" Remove clutter from the process that we think is unnecessary:
tracked PSets, VPSets and unused modules and sequences. If a Schedule has been set, then Paths and EndPaths
not in the schedule will also be removed, along with an modules and sequences used only by
those removed Paths and EndPaths."""
# need to update this to only prune psets not on refToPSets
# but for now, remove the delattr
# for name in self.psets_():
# if getattr(self,name).isTracked():
# delattr(self, name)
for name in self.vpsets_():
delattr(self, name)
#first we need to resolve any SequencePlaceholders being used
self.resolve(keepUnresolvedSequencePlaceholders)
usedModules = set()
unneededPaths = set()
if self.schedule_():
usedModules=set(self.schedule_().moduleNames())
#get rid of unused paths
schedNames = set(( x.label_() for x in self.schedule_()))
names = set(self.paths)
names.update(set(self.endpaths))
unneededPaths = names - schedNames
for n in unneededPaths:
delattr(self,n)
else:
pths = list(six.itervalues(self.paths))
pths.extend(six.itervalues(self.endpaths))
temp = Schedule(*pths)
usedModules=set(temp.moduleNames())
unneededModules = self._pruneModules(self.producers_(), usedModules)
unneededModules.update(self._pruneModules(self.switchProducers_(), usedModules))
unneededModules.update(self._pruneModules(self.filters_(), usedModules))
unneededModules.update(self._pruneModules(self.analyzers_(), usedModules))
#remove sequences that do not appear in remaining paths and endpaths
seqs = list()
sv = SequenceVisitor(seqs)
for p in six.itervalues(self.paths):
p.visit(sv)
for p in six.itervalues(self.endpaths):
p.visit(sv)
keepSeqSet = set(( s for s in seqs if s.hasLabel_()))
availableSeqs = set(six.itervalues(self.sequences))
unneededSeqs = availableSeqs-keepSeqSet
unneededSeqLabels = []
for s in unneededSeqs:
unneededSeqLabels.append(s.label_())
delattr(self,s.label_())
if verbose:
print("prune removed the following:")
print(" modules:"+",".join(unneededModules))
print(" sequences:"+",".join(unneededSeqLabels))
print(" paths/endpaths:"+",".join(unneededPaths))
def _pruneModules(self, d, scheduledNames):
moduleNames = set(d.keys())
junk = moduleNames - scheduledNames
for name in junk:
delattr(self, name)
return junk
def fillProcessDesc(self, processPSet):
"""Used by the framework to convert python to C++ objects"""
class ServiceInjectorAdaptor(object):
def __init__(self,ppset,thelist):
self.__thelist = thelist
self.__processPSet = ppset
def addService(self,pset):
self.__thelist.append(pset)
def newPSet(self):
return self.__processPSet.newPSet()
#This adaptor is used to 'add' the method 'getTopPSet_'
# to the ProcessDesc and PythonParameterSet C++ classes.
# This method is needed for the PSet refToPSet_ functionality.
class TopLevelPSetAcessorAdaptor(object):
def __init__(self,ppset,process):
self.__ppset = ppset
self.__process = process
def __getattr__(self,attr):
return getattr(self.__ppset,attr)
def getTopPSet_(self,label):
return getattr(self.__process,label)
def newPSet(self):
return TopLevelPSetAcessorAdaptor(self.__ppset.newPSet(),self.__process)
def addPSet(self,tracked,name,ppset):
return self.__ppset.addPSet(tracked,name,self.__extractPSet(ppset))
def addVPSet(self,tracked,name,vpset):
return self.__ppset.addVPSet(tracked,name,[self.__extractPSet(x) for x in vpset])
def __extractPSet(self,pset):
if isinstance(pset,TopLevelPSetAcessorAdaptor):
return pset.__ppset
return pset
self.validate()
processPSet.addString(True, "@process_name", self.name_())
all_modules = self.producers_().copy()
all_modules.update(self.filters_())
all_modules.update(self.analyzers_())
all_modules.update(self.outputModules_())
adaptor = TopLevelPSetAcessorAdaptor(processPSet,self)
self._insertInto(adaptor, self.psets_())
self._insertInto(adaptor, self.vpsets_())
self._insertOneInto(adaptor, "@all_sources", self.source_(), True)
self._insertOneInto(adaptor, "@all_loopers", self.looper_(), True)
self._insertSubProcessesInto(adaptor, "@all_subprocesses", self.subProcesses_(), False)
self._insertManyInto(adaptor, "@all_esprefers", self.es_prefers_(), True)
self._insertManyInto(adaptor, "@all_aliases", self.aliases_(), True)
# This will visit all the paths and endpaths that are scheduled to run,
# as well as the Tasks associated to them and the schedule. It remembers
# the modules, ESSources, ESProducers, and services it visits.
nodeVisitor = NodeVisitor()
self._insertPaths(adaptor, nodeVisitor)
all_modules_onTasksOrScheduled = { key:value for key, value in six.iteritems(all_modules) if value in nodeVisitor.modules }
self._insertManyInto(adaptor, "@all_modules", all_modules_onTasksOrScheduled, True)
all_switches = self.switchProducers_().copy()
all_switches_onTasksOrScheduled = {key:value for key, value in six.iteritems(all_switches) if value in nodeVisitor.modules }
self._insertSwitchProducersInto(adaptor, "@all_modules", "@all_aliases", all_switches_onTasksOrScheduled, True)
# Same as nodeVisitor except this one visits all the Tasks attached
# to the process.
processNodeVisitor = NodeVisitor()
for pTask in six.itervalues(self.tasks):
pTask.visit(processNodeVisitor)
esProducersToEnable = {}
for esProducerName, esProducer in six.iteritems(self.es_producers_()):
if esProducer in nodeVisitor.esProducers or not (esProducer in processNodeVisitor.esProducers):
esProducersToEnable[esProducerName] = esProducer
self._insertManyInto(adaptor, "@all_esmodules", esProducersToEnable, True)
esSourcesToEnable = {}
for esSourceName, esSource in six.iteritems(self.es_sources_()):
if esSource in nodeVisitor.esSources or not (esSource in processNodeVisitor.esSources):
esSourcesToEnable[esSourceName] = esSource
self._insertManyInto(adaptor, "@all_essources", esSourcesToEnable, True)
#handle services differently
services = []
for serviceName, serviceObject in six.iteritems(self.services_()):
if serviceObject in nodeVisitor.services or not (serviceObject in processNodeVisitor.services):
serviceObject.insertInto(ServiceInjectorAdaptor(adaptor,services))
adaptor.addVPSet(False,"services",services)
return processPSet
def validate(self):
# check if there's some input
# Breaks too many unit tests for now
#if self.source_() == None and self.looper_() == None:
# raise RuntimeError("No input source was found for this process")
pass
def prefer(self, esmodule,*args,**kargs):
"""Prefer this ES source or producer. The argument can
either be an object label, e.g.,
process.prefer(process.juicerProducer) (not supported yet)
or a name of an ESSource or ESProducer
process.prefer("juicer")
or a type of unnamed ESSource or ESProducer
process.prefer("JuicerProducer")
In addition, you can pass as a labelled arguments the name of the Record you wish to
prefer where the type passed is a cms.vstring and that vstring can contain the
name of the C++ types in the Record that are being preferred, e.g.,
#prefer all data in record 'OrangeRecord' from 'juicer'
process.prefer("juicer", OrangeRecord=cms.vstring())
or
#prefer only "Orange" data in "OrangeRecord" from "juicer"
process.prefer("juicer", OrangeRecord=cms.vstring("Orange"))
or
#prefer only "Orange" data with label "ExtraPulp" in "OrangeRecord" from "juicer"
ESPrefer("ESJuicerProd", OrangeRecord=cms.vstring("Orange/ExtraPulp"))
"""
# see if this refers to a named ESProducer
if isinstance(esmodule, ESSource) or isinstance(esmodule, ESProducer):
raise RuntimeError("Syntax of process.prefer(process.esmodule) not supported yet")
elif self._findPreferred(esmodule, self.es_producers_(),*args,**kargs) or \
self._findPreferred(esmodule, self.es_sources_(),*args,**kargs):
pass
else:
raise RuntimeError("Cannot resolve prefer for "+repr(esmodule))
def _findPreferred(self, esname, d,*args,**kargs):
# is esname a name in the dictionary?
if esname in d:
typ = d[esname].type_()
if typ == esname:
self.__setattr__( esname+"_prefer", ESPrefer(typ,*args,**kargs) )
else:
self.__setattr__( esname+"_prefer", ESPrefer(typ, esname,*args,**kargs) )
return True
else:
# maybe it's an unnamed ESModule?
found = False
for name, value in six.iteritems(d):
if value.type_() == esname:
if found:
raise RuntimeError("More than one ES module for "+esname)
found = True
self.__setattr__(esname+"_prefer", ESPrefer(d[esname].type_()) )
return found
class ProcessFragment(object):
def __init__(self, process):
if isinstance(process, Process):
self.__process = process
elif isinstance(process, str):
self.__process = Process(process)
else:
raise TypeError('a ProcessFragment can only be constructed from an existig Process or from process name')
def __dir__(self):
return [ x for x in dir(self.__process) if isinstance(getattr(self.__process, x), _ConfigureComponent) ]
def __getattribute__(self, name):
if name == '_ProcessFragment__process':
return object.__getattribute__(self, '_ProcessFragment__process')
else:
return getattr(self.__process, name)
def __setattr__(self, name, value):
if name == '_ProcessFragment__process':
object.__setattr__(self, name, value)
else:
setattr(self.__process, name, value)
def __delattr__(self, name):
if name == '_ProcessFragment__process':
pass
else:
return delattr(self.__process, name)
class FilteredStream(dict):
"""a dictionary with fixed keys"""
def _blocked_attribute(obj):
raise AttributeError("An FilteredStream defintion cannot be modified after creation.")
_blocked_attribute = property(_blocked_attribute)
__setattr__ = __delitem__ = __setitem__ = clear = _blocked_attribute
pop = popitem = setdefault = update = _blocked_attribute
def __new__(cls, *args, **kw):
new = dict.__new__(cls)
dict.__init__(new, *args, **kw)
keys = sorted(kw.keys())
if keys != ['content', 'dataTier', 'name', 'paths', 'responsible', 'selectEvents']:
raise ValueError("The needed parameters are: content, dataTier, name, paths, responsible, selectEvents")
if not isinstance(kw['name'],str):
raise ValueError("name must be of type string")
if not isinstance(kw['content'], vstring) and not isinstance(kw['content'],str):
raise ValueError("content must be of type vstring or string")
if not isinstance(kw['dataTier'], string):
raise ValueError("dataTier must be of type string")
if not isinstance(kw['selectEvents'], PSet):
raise ValueError("selectEvents must be of type PSet")
if not isinstance(kw['paths'],(tuple, Path)):
raise ValueError("'paths' must be a tuple of paths")
return new
def __init__(self, *args, **kw):
pass
def __repr__(self):
return "FilteredStream object: %s" %self["name"]
def __getattr__(self,attr):
return self[attr]
class SubProcess(_Unlabelable):
"""Allows embedding another process within a parent process. This allows one to
chain processes together directly in one cmsRun job rather than having to run
separate jobs that are connected via a temporary file.
"""
def __init__(self,process, SelectEvents = untracked.PSet(), outputCommands = untracked.vstring()):
"""
"""
if not isinstance(process, Process):
raise ValueError("the 'process' argument must be of type cms.Process")
if not isinstance(SelectEvents,PSet):
raise ValueError("the 'SelectEvents' argument must be of type cms.untracked.PSet")
if not isinstance(outputCommands,vstring):
raise ValueError("the 'outputCommands' argument must be of type cms.untracked.vstring")
self.__process = process
self.__SelectEvents = SelectEvents
self.__outputCommands = outputCommands
def dumpPython(self,options=PrintOptions()):
out = "parentProcess"+str(hash(self))+" = process\n"
out += self.__process.dumpPython()
out += "childProcess = process\n"
out += "process = parentProcess"+str(hash(self))+"\n"
out += "process.addSubProcess(cms.SubProcess(process = childProcess, SelectEvents = "+self.__SelectEvents.dumpPython(options) +", outputCommands = "+self.__outputCommands.dumpPython(options) +"))"
return out
def getProcessName(self):
return self.__process.name_()
def process(self):
return self.__process
def SelectEvents(self):
return self.__SelectEvents
def outputCommands(self):
return self.__outputCommands
def type_(self):
return 'subProcess'
def nameInProcessDesc_(self,label):
return label
def _place(self,label,process):
process._placeSubProcess('subProcess',self)
def getSubProcessPSet(self,parameterSet):
topPSet = parameterSet.newPSet()
self.__process.fillProcessDesc(topPSet)
subProcessPSet = parameterSet.newPSet()
self.__SelectEvents.insertInto(subProcessPSet,"SelectEvents")
self.__outputCommands.insertInto(subProcessPSet,"outputCommands")
subProcessPSet.addPSet(False,"process",topPSet)
return subProcessPSet
class _ParameterModifier(object):
"""Helper class for Modifier that takes key/value pairs and uses them to reset parameters of the object"""
def __init__(self,args):
self.__args = args
def __call__(self,obj):
params = {}
for k in six.iterkeys(self.__args):
if hasattr(obj,k):
params[k] = getattr(obj,k)
_modifyParametersFromDict(params, self.__args, self._raiseUnknownKey)
for k in six.iterkeys(self.__args):
if k in params:
setattr(obj,k,params[k])
else:
#the parameter must have been removed
delattr(obj,k)
@staticmethod
def _raiseUnknownKey(key):
raise KeyError("Unknown parameter name "+key+" specified while calling Modifier")
class _BoolModifierBase(object):
"""A helper base class for _AndModifier, _InvertModifier, and _OrModifier to contain the common code"""
def __init__(self, lhs, rhs=None):
self._lhs = lhs
if rhs is not None:
self._rhs = rhs
def toModify(self,obj, func=None,**kw):
Modifier._toModifyCheck(obj,func,**kw)
if not self._isChosen():
return
Modifier._toModify(obj,func,**kw)
def toReplaceWith(self,toObj,fromObj):
Modifier._toReplaceWithCheck(toObj,fromObj)
if not self._isChosen():
return
Modifier._toReplaceWith(toObj,fromObj)
def makeProcessModifier(self,func):
"""This is used to create a ProcessModifer that can perform actions on the process as a whole.
This takes as argument a callable object (e.g. function) that takes as its sole argument an instance of Process.
In order to work, the value returned from this function must be assigned to a uniquely named variable."""
return ProcessModifier(self,func)
def __and__(self, other):
return _AndModifier(self,other)
def __invert__(self):
return _InvertModifier(self)
def __or__(self, other):
return _OrModifier(self,other)
class _AndModifier(_BoolModifierBase):
"""A modifier which only applies if multiple Modifiers are chosen"""
def __init__(self, lhs, rhs):
super(_AndModifier,self).__init__(lhs, rhs)
def _isChosen(self):
return self._lhs._isChosen() and self._rhs._isChosen()
class _InvertModifier(_BoolModifierBase):
"""A modifier which only applies if a Modifier is not chosen"""
def __init__(self, lhs):
super(_InvertModifier,self).__init__(lhs)
def _isChosen(self):
return not self._lhs._isChosen()
class _OrModifier(_BoolModifierBase):
"""A modifier which only applies if at least one of multiple Modifiers is chosen"""
def __init__(self, lhs, rhs):
super(_OrModifier,self).__init__(lhs, rhs)
def _isChosen(self):
return self._lhs._isChosen() or self._rhs._isChosen()
class Modifier(object):
"""This class is used to define standard modifications to a Process.
An instance of this class is declared to denote a specific modification,e.g. era2017 could
reconfigure items in a process to match our expectation of running in 2017. Once declared,
these Modifier instances are imported into a configuration and items that need to be modified
are then associated with the Modifier and with the action to do the modification.
The registered modifications will only occur if the Modifier was passed to
the cms.Process' constructor.
"""
def __init__(self):
self.__processModifiers = []
self.__chosen = False
def makeProcessModifier(self,func):
"""This is used to create a ProcessModifer that can perform actions on the process as a whole.
This takes as argument a callable object (e.g. function) that takes as its sole argument an instance of Process.
In order to work, the value returned from this function must be assigned to a uniquely named variable.
"""
return ProcessModifier(self,func)
@staticmethod
def _toModifyCheck(obj,func,**kw):
if func is not None and len(kw) != 0:
raise TypeError("toModify takes either two arguments or one argument and key/value pairs")
def toModify(self,obj, func=None,**kw):
"""This is used to register an action to be performed on the specific object. Two different forms are allowed
Form 1: A callable object (e.g. function) can be passed as the second. This callable object is expected to take one argument
that will be the object passed in as the first argument.
Form 2: A list of parameter name, value pairs can be passed
mod.toModify(foo, fred=cms.int32(7), barney = cms.double(3.14))
This form can also be used to remove a parameter by passing the value of None
#remove the parameter foo.fred
mod.toModify(foo, fred = None)
Additionally, parameters embedded within PSets can also be modified using a dictionary
#change foo.fred.pebbles to 3 and foo.fred.friend to "barney"
mod.toModify(foo, fred = dict(pebbles = 3, friend = "barney)) )
"""
Modifier._toModifyCheck(obj,func,**kw)
if not self._isChosen():
return
Modifier._toModify(obj,func,**kw)
@staticmethod
def _toModify(obj,func,**kw):
if func is not None:
func(obj)
else:
temp =_ParameterModifier(kw)
temp(obj)
@staticmethod
def _toReplaceWithCheck(toObj,fromObj):
if not isinstance(fromObj, type(toObj)):
raise TypeError("toReplaceWith requires both arguments to be the same class type")
def toReplaceWith(self,toObj,fromObj):
"""If the Modifier is chosen the internals of toObj will be associated with the internals of fromObj
"""
Modifier._toReplaceWithCheck(toObj,fromObj)
if not self._isChosen():
return
Modifier._toReplaceWith(toObj,fromObj)
@staticmethod
def _toReplaceWith(toObj,fromObj):
if isinstance(fromObj,_ModuleSequenceType):
toObj._seq = fromObj._seq
toObj._tasks = fromObj._tasks
elif isinstance(fromObj,Task):
toObj._collection = fromObj._collection
elif isinstance(fromObj,_Parameterizable):
#clear old items just incase fromObj is not a complete superset of toObj
for p in toObj.parameterNames_():
delattr(toObj,p)
for p in fromObj.parameterNames_():
setattr(toObj,p,getattr(fromObj,p))
if isinstance(fromObj,_TypedParameterizable):
toObj._TypedParameterizable__type = fromObj._TypedParameterizable__type
else:
raise TypeError("toReplaceWith does not work with type "+str(type(toObj)))
def _setChosen(self):
"""Should only be called by cms.Process instances"""
self.__chosen = True
def _isChosen(self):
return self.__chosen
def __and__(self, other):
return _AndModifier(self,other)
def __invert__(self):
return _InvertModifier(self)
def __or__(self, other):
return _OrModifier(self,other)
def _isOrContains(self, other):
return self == other
class ModifierChain(object):
"""A Modifier made up of a list of Modifiers
"""
def __init__(self, *chainedModifiers):
self.__chosen = False
self.__chain = chainedModifiers
def _applyNewProcessModifiers(self,process):
"""Should only be called by cms.Process instances
applies list of accumulated changes to the process"""
for m in self.__chain:
m._applyNewProcessModifiers(process)
def _setChosen(self):
"""Should only be called by cms.Process instances"""
self.__chosen = True
for m in self.__chain:
m._setChosen()
def _isChosen(self):
return self.__chosen
def copyAndExclude(self, toExclude):
"""Creates a new ModifierChain which is a copy of
this ModifierChain but excludes any Modifier or
ModifierChain in the list toExclude.
The exclusion is done recursively down the chain.
"""
newMods = []
for m in self.__chain:
if m not in toExclude:
s = m
if isinstance(m,ModifierChain):
s = m.__copyIfExclude(toExclude)
newMods.append(s)
return ModifierChain(*newMods)
def __copyIfExclude(self,toExclude):
shouldCopy = False
for m in toExclude:
if self._isOrContains(m):
shouldCopy = True
break
if shouldCopy:
return self.copyAndExclude(toExclude)
return self
def _isOrContains(self, other):
if self is other:
return True
for m in self.__chain:
if m._isOrContains(other):
return True
return False
class ProcessModifier(object):
"""A class used by a Modifier to affect an entire Process instance.
When a Process 'loads' a module containing a ProcessModifier, that
ProcessModifier will be applied to the Process if and only if the
Modifier passed to the constructor has been chosen.
"""
def __init__(self, modifier, func):
self.__modifier = modifier
self.__func = func
self.__seenProcesses = set()
def apply(self,process):
if self.__modifier._isChosen():
if process not in self.__seenProcesses:
self.__func(process)
self.__seenProcesses.add(process)
if __name__=="__main__":
import unittest
import copy
class TestMakePSet(object):
"""Has same interface as the C++ object that creates PSets
"""
def __init__(self):
self.values = dict()
def __insertValue(self,tracked,label,value):
self.values[label]=(tracked,value)
def __getValue(self,tracked,label):
pair = self.values[label]
if pair[0] != tracked:
raise Exception("Asked for %s parameter '%s', but it is %s" % ("tracked" if tracked else "untracked",
label,
"tracked" if pair[0] else "untracked"))
return pair[1]
def addInt32(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addVInt32(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addUInt32(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addVUInt32(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addInt64(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addVInt64(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addUInt64(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addVUInt64(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addDouble(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addVDouble(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addBool(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addString(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addVString(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def getVString(self,tracked,label):
return self.__getValue(tracked, label)
def addInputTag(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addVInputTag(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addESInputTag(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addVESInputTag(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addEventID(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addVEventID(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addLuminosityBlockID(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addLuminosityBlockID(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addEventRange(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addVEventRange(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addPSet(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addVPSet(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def addFileInPath(self,tracked,label,value):
self.__insertValue(tracked,label,value)
def newPSet(self):
return TestMakePSet()
class SwitchProducerTest(SwitchProducer):
def __init__(self, **kargs):
super(SwitchProducerTest,self).__init__(
dict(
test1 = lambda: (True, -10),
test2 = lambda: (True, -9),
test3 = lambda: (True, -8),
test4 = lambda: (True, -7)
), **kargs)
specialImportRegistry.registerSpecialImportForType(SwitchProducerTest, "from test import SwitchProducerTest")
class TestModuleCommand(unittest.TestCase):
def setUp(self):
"""Nothing to do """
None
def testParameterizable(self):
p = _Parameterizable()
self.assertEqual(len(p.parameterNames_()),0)
p.a = int32(1)
self.assert_('a' in p.parameterNames_())
self.assertEqual(p.a.value(), 1)
p.a = 10
self.assertEqual(p.a.value(), 10)
p.a = untracked(int32(1))
self.assertEqual(p.a.value(), 1)
self.failIf(p.a.isTracked())
p.a = untracked.int32(1)
self.assertEqual(p.a.value(), 1)
self.failIf(p.a.isTracked())
p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
self.assertEqual(p.foo.value(), 10)
self.assertEqual(p.bar.value(),1.0)
self.failIf(p.bar.isTracked())
self.assertRaises(TypeError,setattr,(p,'c',1))
p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
self.assertEqual(p.a.foo.value(),10)
self.assertEqual(p.a.bar.value(),1.0)
p.b = untracked(PSet(fii = int32(1)))
self.assertEqual(p.b.fii.value(),1)
self.failIf(p.b.isTracked())
#test the fact that values can be shared
v = int32(10)
p=_Parameterizable(a=v)
v.setValue(11)
self.assertEqual(p.a.value(),11)
p.a = 12
self.assertEqual(p.a.value(),12)
self.assertEqual(v.value(),12)
def testTypedParameterizable(self):
p = _TypedParameterizable("blah", b=int32(1))
#see if copy works deeply
other = p.copy()
other.b = 2
self.assertNotEqual(p.b,other.b)
def testProcessInsertion(self):
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
self.assert_( 'a' in p.analyzers_() )
self.assert_( 'a' in p.analyzers)
p.add_(Service("MessageLogger"))
self.assert_('MessageLogger' in p.services_())
self.assertEqual(p.MessageLogger.type_(), "MessageLogger")
p.Tracer = Service("Tracer")
self.assert_('Tracer' in p.services_())
self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
p.out = OutputModule("Outer")
self.assertEqual(p.out.type_(), 'Outer')
self.assert_( 'out' in p.outputModules_() )
p.geom = ESSource("GeomProd")
self.assert_('geom' in p.es_sources_())
p.add_(ESSource("ConfigDB"))
self.assert_('ConfigDB' in p.es_sources_())
p.aliasfoo1 = EDAlias(foo1 = VPSet(PSet(type = string("Foo1"))))
self.assert_('aliasfoo1' in p.aliases_())
def testProcessExtend(self):
class FromArg(object):
def __init__(self,*arg,**args):
for name in six.iterkeys(args):
self.__dict__[name]=args[name]
a=EDAnalyzer("MyAnalyzer")
t=EDAnalyzer("MyAnalyzer")
t.setLabel("foo")
s1 = Sequence(a)
s2 = Sequence(s1)
s3 = Sequence(s2)
d = FromArg(
a=a,
b=Service("Full"),
c=Path(a),
d=s2,
e=s1,
f=s3,
g=Sequence(s1+s2+s3)
)
p = Process("Test")
p.extend(d)
self.assertEqual(p.a.type_(),"MyAnalyzer")
self.assertEqual(p.a.label_(),"a")
self.assertRaises(AttributeError,getattr,p,'b')
self.assertEqual(p.Full.type_(),"Full")
self.assertEqual(str(p.c),'a')
self.assertEqual(str(p.d),'a')
z1 = FromArg(
a=a,
b=Service("Full"),
c=Path(a),
d=s2,
e=s1,
f=s3,
s4=s3,
g=Sequence(s1+s2+s3)
)
p1 = Process("Test")
#p1.extend(z1)
self.assertRaises(ValueError, p1.extend, z1)
z2 = FromArg(
a=a,
b=Service("Full"),
c=Path(a),
d=s2,
e=s1,
f=s3,
aaa=copy.deepcopy(a),
s4=copy.deepcopy(s3),
g=Sequence(s1+s2+s3),
t=t
)
p2 = Process("Test")
p2.extend(z2)
#self.assertRaises(ValueError, p2.extend, z2)
self.assertEqual(p2.s4.label_(),"s4")
#p2.s4.setLabel("foo")
self.assertRaises(ValueError, p2.s4.setLabel, "foo")
p2.s4.setLabel("s4")
p2.s4.setLabel(None)
p2.s4.setLabel("foo")
p2._Process__setObjectLabel(p2.s4, "foo")
p2._Process__setObjectLabel(p2.s4, None)
p2._Process__setObjectLabel(p2.s4, "bar")
def testProcessDumpPython(self):
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.p = Path(p.a)
p.s = Sequence(p.a)
p.r = Sequence(p.s)
p.p2 = Path(p.s)
p.schedule = Schedule(p.p2,p.p)
d=p.dumpPython()
self.assertEqual(d,
"""import FWCore.ParameterSet.Config as cms
process = cms.Process("test")
process.a = cms.EDAnalyzer("MyAnalyzer")
process.s = cms.Sequence(process.a)
process.r = cms.Sequence(process.s)
process.p = cms.Path(process.a)
process.p2 = cms.Path(process.s)
process.schedule = cms.Schedule(*[ process.p2, process.p ])
""")
#Reverse order of 'r' and 's'
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.p = Path(p.a)
p.r = Sequence(p.a)
p.s = Sequence(p.r)
p.p2 = Path(p.r)
p.schedule = Schedule(p.p2,p.p)
p.b = EDAnalyzer("YourAnalyzer")
d=p.dumpPython()
self.assertEqual(d,
"""import FWCore.ParameterSet.Config as cms
process = cms.Process("test")
process.a = cms.EDAnalyzer("MyAnalyzer")
process.b = cms.EDAnalyzer("YourAnalyzer")
process.r = cms.Sequence(process.a)
process.s = cms.Sequence(process.r)
process.p = cms.Path(process.a)
process.p2 = cms.Path(process.r)
process.schedule = cms.Schedule(*[ process.p2, process.p ])
""")
#use an anonymous sequence
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.p = Path(p.a)
s = Sequence(p.a)
p.r = Sequence(s)
p.p2 = Path(p.r)
p.schedule = Schedule(p.p2,p.p)
d=p.dumpPython()
self.assertEqual(d,
"""import FWCore.ParameterSet.Config as cms
process = cms.Process("test")
process.a = cms.EDAnalyzer("MyAnalyzer")
process.r = cms.Sequence((process.a))
process.p = cms.Path(process.a)
process.p2 = cms.Path(process.r)
process.schedule = cms.Schedule(*[ process.p2, process.p ])
""")
# include some tasks
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDProducer("bProducer")
p.c = EDProducer("cProducer")
p.d = EDProducer("dProducer")
p.e = EDProducer("eProducer")
p.f = EDProducer("fProducer")
p.g = EDProducer("gProducer")
p.task5 = Task()
p.task3 = Task()
p.task2 = Task(p.c, p.task3)
p.task4 = Task(p.f, p.task2)
p.task1 = Task(p.task5)
p.task3.add(p.task1)
p.p = Path(p.a)
s = Sequence(p.a)
p.r = Sequence(s)
p.p2 = Path(p.r, p.task1, p.task2)
p.schedule = Schedule(p.p2,p.p,tasks=[p.task3,p.task4, p.task5])
d=p.dumpPython()
self.assertEqual(d,
"""import FWCore.ParameterSet.Config as cms
process = cms.Process("test")
process.b = cms.EDProducer("bProducer")
process.c = cms.EDProducer("cProducer")
process.d = cms.EDProducer("dProducer")
process.e = cms.EDProducer("eProducer")
process.f = cms.EDProducer("fProducer")
process.g = cms.EDProducer("gProducer")
process.a = cms.EDAnalyzer("MyAnalyzer")
process.task5 = cms.Task()
process.task1 = cms.Task(process.task5)
process.task3 = cms.Task(process.task1)
process.task2 = cms.Task(process.c, process.task3)
process.task4 = cms.Task(process.f, process.task2)
process.r = cms.Sequence((process.a))
process.p = cms.Path(process.a)
process.p2 = cms.Path(process.r, process.task1, process.task2)
process.schedule = cms.Schedule(*[ process.p2, process.p ], tasks=[process.task3, process.task4, process.task5])
""")
# only tasks
p = Process("test")
p.d = EDProducer("dProducer")
p.e = EDProducer("eProducer")
p.f = EDProducer("fProducer")
p.g = EDProducer("gProducer")
p.task1 = Task(p.d, p.e)
task2 = Task(p.f, p.g)
p.schedule = Schedule(tasks=[p.task1,task2])
d=p.dumpPython()
self.assertEqual(d,
"""import FWCore.ParameterSet.Config as cms
process = cms.Process("test")
process.d = cms.EDProducer("dProducer")
process.e = cms.EDProducer("eProducer")
process.f = cms.EDProducer("fProducer")
process.g = cms.EDProducer("gProducer")
process.task1 = cms.Task(process.d, process.e)
process.schedule = cms.Schedule(tasks=[cms.Task(process.f, process.g), process.task1])
""")
# empty schedule
p = Process("test")
p.schedule = Schedule()
d=p.dumpPython()
self.assertEqual(d,
"""import FWCore.ParameterSet.Config as cms
process = cms.Process("test")
process.schedule = cms.Schedule()
""")
s = Sequence()
a = EDProducer("A")
s2 = Sequence(a)
s2 += s
process = Process("DUMP")
process.a = a
process.s2 = s2
d=process.dumpPython()
self.assertEqual(d,
"""import FWCore.ParameterSet.Config as cms
process = cms.Process("DUMP")
process.a = cms.EDProducer("A")
process.s2 = cms.Sequence(process.a)
""")
s = Sequence()
s1 = Sequence(s)
a = EDProducer("A")
s3 = Sequence(a+a)
s2 = Sequence(a+s3)
s2 += s1
process = Process("DUMP")
process.a = a
process.s2 = s2
d=process.dumpPython()
self.assertEqual(d,
"""import FWCore.ParameterSet.Config as cms
process = cms.Process("DUMP")
process.a = cms.EDProducer("A")
process.s2 = cms.Sequence(process.a+(process.a+process.a))
""")
def testSecSource(self):
p = Process('test')
p.a = SecSource("MySecSource")
self.assertEqual(p.dumpPython().replace('\n',''),'import FWCore.ParameterSet.Config as cmsprocess = cms.Process("test")process.a = cms.SecSource("MySecSource")')
def testGlobalReplace(self):
p = Process('test')
p.a = EDAnalyzer("MyAnalyzer")
old = p.a
p.b = EDAnalyzer("YourAnalyzer")
p.c = EDAnalyzer("OurAnalyzer")
p.d = EDProducer("MyProducer")
old2 = p.d
p.t1 = Task(p.d)
t2 = Task(p.d)
t3 = Task(p.d)
t4 = Task(p.d)
t5 = Task(p.d)
t6 = Task(p.d)
s = Sequence(p.a*p.b)
p.s4 = Sequence(p.a*p.b)
s.associate(t2)
p.s4.associate(t2)
p.p = Path(p.c+s+p.a)
p.e3 = EndPath(p.c+s+p.a)
new = EDAnalyzer("NewAnalyzer")
new2 = EDProducer("NewProducer")
visitor1 = NodeVisitor()
p.p.visit(visitor1)
self.assertTrue(visitor1.modules == set([old,old2,p.b,p.c]))
p.schedule = Schedule(tasks=[t6])
p.globalReplace("a",new)
p.globalReplace("d",new2)
visitor2 = NodeVisitor()
p.p.visit(visitor2)
self.assertTrue(visitor2.modules == set([new,new2,p.b,p.c]))
visitor3 = NodeVisitor()
p.e3.visit(visitor3)
self.assertTrue(visitor3.modules == set([new,new2,p.b,p.c]))
visitor4 = NodeVisitor()
p.s4.visit(visitor4)
self.assertTrue(visitor4.modules == set([new,new2,p.b]))
visitor5 = NodeVisitor()
p.t1.visit(visitor5)
self.assertTrue(visitor5.modules == set([new2]))
visitor6 = NodeVisitor()
listOfTasks = list(p.schedule._tasks)
listOfTasks[0].visit(visitor6)
self.assertTrue(visitor6.modules == set([new2]))
def testSequence(self):
p = Process('test')
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDAnalyzer("YourAnalyzer")
p.c = EDAnalyzer("OurAnalyzer")
p.s = Sequence(p.a*p.b)
self.assertEqual(str(p.s),'a+b')
self.assertEqual(p.s.label_(),'s')
path = Path(p.c+p.s)
self.assertEqual(str(path),'c+a+b')
p._validateSequence(path, 'p1')
notInProcess = EDAnalyzer('NotInProcess')
p2 = Path(p.c+p.s*notInProcess)
self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')
def testSequence2(self):
p = Process('test')
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDAnalyzer("YourAnalyzer")
p.c = EDAnalyzer("OurAnalyzer")
testseq = Sequence(p.a*p.b)
p.s = testseq
#p.y = testseq
self.assertRaises(ValueError, p.__setattr__, "y", testseq)
def testServiceInProcess(self):
service = Service("d")
self.assertFalse(service._inProcess)
process = Process("test")
process.d = service
self.assertTrue(service._inProcess)
service2 = Service("d")
process.d = service2
self.assertFalse(service._inProcess)
self.assertTrue(service2._inProcess)
del process.d
self.assertFalse(service2._inProcess)
def testTask(self):
# create some objects to use in tests
edanalyzer = EDAnalyzer("a")
edproducer = EDProducer("b")
edproducer2 = EDProducer("b2")
edproducer3 = EDProducer("b3")
edproducer4 = EDProducer("b4")
edproducer8 = EDProducer("b8")
edproducer9 = EDProducer("b9")
edfilter = EDFilter("c")
service = Service("d")
service3 = Service("d")
essource = ESSource("e")
esproducer = ESProducer("f")
testTask2 = Task()
# test adding things to Tasks
testTask1 = Task(edproducer, edfilter)
self.assertRaises(RuntimeError, testTask1.add, edanalyzer)
testTask1.add(essource, service)
testTask1.add(essource, esproducer)
testTask1.add(testTask2)
coll = testTask1._collection
self.assertTrue(edproducer in coll)
self.assertTrue(edfilter in coll)
self.assertTrue(service in coll)
self.assertTrue(essource in coll)
self.assertTrue(esproducer in coll)
self.assertTrue(testTask2 in coll)
self.assertTrue(len(coll) == 6)
self.assertTrue(len(testTask2._collection) == 0)
taskContents = []
for i in testTask1:
taskContents.append(i)
self.assertTrue(taskContents == [edproducer, edfilter, essource, service, esproducer, testTask2])
# test attaching Task to Process
process = Process("test")
process.mproducer = edproducer
process.mproducer2 = edproducer2
process.mfilter = edfilter
process.messource = essource
process.mesproducer = esproducer
process.d = service
testTask3 = Task(edproducer, edproducer2)
testTask1.add(testTask3)
process.myTask1 = testTask1
# test the validation that occurs when attaching a Task to a Process
# first a case that passes, then one the fails on an EDProducer
# then one that fails on a service
l = set()
visitor = NodeNameVisitor(l)
testTask1.visit(visitor)
self.assertTrue(l == set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
l2 = testTask1.moduleNames
self.assertTrue(l == set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
testTask4 = Task(edproducer3)
l.clear()
self.assertRaises(RuntimeError, testTask4.visit, visitor)
try:
process.myTask4 = testTask4
self.assertTrue(False)
except RuntimeError:
pass
testTask5 = Task(service3)
l.clear()
self.assertRaises(RuntimeError, testTask5.visit, visitor)
try:
process.myTask5 = testTask5
self.assertTrue(False)
except RuntimeError:
pass
process.d = service3
process.myTask5 = testTask5
# test placement into the Process and the tasks property
expectedDict = { 'myTask1' : testTask1, 'myTask5' : testTask5 }
expectedFixedDict = DictTypes.FixedKeysDict(expectedDict);
self.assertTrue(process.tasks == expectedFixedDict)
self.assertTrue(process.tasks['myTask1'] == testTask1)
self.assertTrue(process.myTask1 == testTask1)
# test replacing an EDProducer in a Task when calling __settattr__
# for the EDProducer on the Process.
process.mproducer2 = edproducer4
process.d = service
l = list()
visitor1 = ModuleNodeVisitor(l)
testTask1.visit(visitor1)
l.sort()
expectedList = sorted([edproducer,essource,esproducer,service,edfilter,edproducer,edproducer4])
self.assertTrue(expectedList == l)
process.myTask6 = Task()
process.myTask7 = Task()
process.mproducer8 = edproducer8
process.myTask8 = Task(process.mproducer8)
process.myTask6.add(process.myTask7)
process.myTask7.add(process.myTask8)
process.myTask1.add(process.myTask6)
process.myTask8.add(process.myTask5)
testDict = process._itemsInDependencyOrder(process.tasks)
expectedLabels = ["myTask5", "myTask8", "myTask7", "myTask6", "myTask1"]
expectedTasks = [process.myTask5, process.myTask8, process.myTask7, process.myTask6, process.myTask1]
index = 0
for testLabel, testTask in testDict.items():
self.assertTrue(testLabel == expectedLabels[index])
self.assertTrue(testTask == expectedTasks[index])
index += 1
pythonDump = testTask1.dumpPython(PrintOptions())
expectedPythonDump = 'cms.Task(process.d, process.mesproducer, process.messource, process.mfilter, process.mproducer, process.mproducer2, process.myTask6)\n'
self.assertTrue(pythonDump == expectedPythonDump)
process.myTask5 = Task()
process.myTask100 = Task()
process.mproducer9 = edproducer9
sequence1 = Sequence(process.mproducer8, process.myTask1, process.myTask5, testTask2, testTask3)
sequence2 = Sequence(process.mproducer8 + process.mproducer9)
process.sequence3 = Sequence((process.mproducer8 + process.mfilter))
sequence4 = Sequence()
process.path1 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+sequence4)
process.path1.associate(process.myTask1, process.myTask5, testTask2, testTask3)
process.path11 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+ sequence4,process.myTask1, process.myTask5, testTask2, testTask3, process.myTask100)
process.path2 = Path(process.mproducer)
process.path3 = Path(process.mproducer9+process.mproducer8,testTask2)
self.assertTrue(process.path1.dumpPython(PrintOptions()) == 'cms.Path(process.mproducer+process.mproducer8+cms.Sequence(process.mproducer8, cms.Task(), cms.Task(process.None, process.mproducer), process.myTask1, process.myTask5)+(process.mproducer8+process.mproducer9)+process.sequence3, cms.Task(), cms.Task(process.None, process.mproducer), process.myTask1, process.myTask5)\n')
self.assertTrue(process.path11.dumpPython(PrintOptions()) == 'cms.Path(process.mproducer+process.mproducer8+cms.Sequence(process.mproducer8, cms.Task(), cms.Task(process.None, process.mproducer), process.myTask1, process.myTask5)+(process.mproducer8+process.mproducer9)+process.sequence3, cms.Task(), cms.Task(process.None, process.mproducer), process.myTask1, process.myTask100, process.myTask5)\n')
# test NodeNameVisitor and moduleNames
l = set()
nameVisitor = NodeNameVisitor(l)
process.path1.visit(nameVisitor)
self.assertTrue(l == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
self.assertTrue(process.path1.moduleNames() == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
# test copy
process.mproducer10 = EDProducer("b10")
process.path21 = process.path11.copy()
process.path21.replace(process.mproducer, process.mproducer10)
self.assertTrue(process.path11.dumpPython(PrintOptions()) == 'cms.Path(process.mproducer+process.mproducer8+cms.Sequence(process.mproducer8, cms.Task(), cms.Task(process.None, process.mproducer), process.myTask1, process.myTask5)+(process.mproducer8+process.mproducer9)+process.sequence3, cms.Task(), cms.Task(process.None, process.mproducer), process.myTask1, process.myTask100, process.myTask5)\n')
# Some peculiarities of the way things work show up here. dumpPython sorts tasks and
# removes duplication at the level of strings. The Task and Sequence objects themselves
# remove duplicate tasks in their contents if the instances are the same (exact same python
# object id which is not the same as the string representation being the same).
# Also note that the mutating visitor replaces sequences and tasks that have
# modified contents with their modified contents, it does not modify the sequence
# or task itself.
self.assertTrue(process.path21.dumpPython(PrintOptions()) == 'cms.Path(process.mproducer10+process.mproducer8+process.mproducer8+(process.mproducer8+process.mproducer9)+process.sequence3, cms.Task(), cms.Task(process.None, process.mproducer10), cms.Task(process.d, process.mesproducer, process.messource, process.mfilter, process.mproducer10, process.mproducer2, process.myTask6), process.myTask100, process.myTask5)\n')
process.path22 = process.path21.copyAndExclude([process.d, process.mesproducer, process.mfilter])
self.assertTrue(process.path22.dumpPython(PrintOptions()) == 'cms.Path(process.mproducer10+process.mproducer8+process.mproducer8+(process.mproducer8+process.mproducer9)+process.mproducer8, cms.Task(), cms.Task(process.None, process.mproducer10), cms.Task(process.messource, process.mproducer10, process.mproducer2, process.myTask6), process.myTask100, process.myTask5)\n')
process.path23 = process.path22.copyAndExclude([process.messource, process.mproducer10])
self.assertTrue(process.path23.dumpPython(PrintOptions()) == 'cms.Path(process.mproducer8+process.mproducer8+(process.mproducer8+process.mproducer9)+process.mproducer8, cms.Task(), cms.Task(process.None), cms.Task(process.mproducer2, process.myTask6), process.myTask100, process.myTask5)\n')
process.a = EDAnalyzer("MyAnalyzer")
process.b = OutputModule("MyOutputModule")
process.c = EDFilter("MyFilter")
process.d = EDProducer("MyProducer")
process.e = ESProducer("MyESProducer")
process.f = ESSource("MyESSource")
process.g = ESProducer("g")
process.path24 = Path(process.a+process.b+process.c+process.d)
process.path25 = process.path24.copyAndExclude([process.a,process.b,process.c])
self.assertTrue(process.path25.dumpPython(None) == 'cms.Path(process.d)\n')
#print process.path3
#print process.dumpPython()
process.path200 = EndPath(Sequence(process.c,Task(process.e)))
process.path200.replace(process.c,process.b)
process.path200.replace(process.e,process.f)
self.assertEqual(process.path200.dumpPython(None), "cms.EndPath(process.b, cms.Task(process.f))\n")
process.path200.replace(process.b,process.c)
process.path200.replace(process.f,process.e)
self.assertEqual(process.path200.dumpPython(None), "cms.EndPath(process.c, cms.Task(process.e))\n")
process.path200.replace(process.c,process.a)
process.path200.replace(process.e,process.g)
self.assertEqual(process.path200.dumpPython(None), "cms.EndPath(process.a, cms.Task(process.g))\n")
process.path200.replace(process.a,process.c)
process.path200.replace(process.g,process.e)
self.assertEqual(process.path200.dumpPython(None), "cms.EndPath(process.c, cms.Task(process.e))\n")
def testPath(self):
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDAnalyzer("YourAnalyzer")
p.c = EDAnalyzer("OurAnalyzer")
path = Path(p.a)
path *= p.b
path += p.c
self.assertEqual(str(path),'a+b+c')
path = Path(p.a*p.b+p.c)
self.assertEqual(str(path),'a+b+c')
# path = Path(p.a)*p.b+p.c #This leads to problems with sequences
# self.assertEqual(str(path),'((a*b)+c)')
path = Path(p.a+ p.b*p.c)
self.assertEqual(str(path),'a+b+c')
path = Path(p.a*(p.b+p.c))
self.assertEqual(str(path),'a+b+c')
path = Path(p.a*(p.b+~p.c))
pathx = Path(p.a*(p.b+ignore(p.c)))
self.assertEqual(str(path),'a+b+~c')
p.es = ESProducer("AnESProducer")
self.assertRaises(TypeError,Path,p.es)
t = Path()
self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path()\n')
t = Path(p.a)
self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path(process.a)\n')
t = Path(Task())
self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path(cms.Task())\n')
t = Path(p.a, Task())
self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path(process.a, cms.Task())\n')
p.prod = EDProducer("prodName")
p.t1 = Task(p.prod)
t = Path(p.a, p.t1, Task(), p.t1)
self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path(process.a, cms.Task(), process.t1)\n')
def testCloneSequence(self):
p = Process("test")
a = EDAnalyzer("MyAnalyzer")
p.a = a
a.setLabel("a")
b = EDAnalyzer("YOurAnalyzer")
p.b = b
b.setLabel("b")
path = Path(a * b)
p.path = Path(p.a*p.b)
lookuptable = {id(a): p.a, id(b): p.b}
#self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
#lookuptable = p._cloneToObjectDict
#self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
self.assertEqual(str(path),str(p.path))
def testContains(self):
a = EDProducer("a")
b = EDProducer("b")
c = EDProducer("c")
d = EDProducer("d")
e = EDProducer("e")
f = EDProducer("f")
g = EDProducer("g")
h = EDProducer("h")
i = EDProducer("i")
j = EDProducer("j")
k = EDProducer("k")
l = EDProducer("l")
m = EDProducer("m")
n = EDProducer("n")
seq1 = Sequence(e)
task1 = Task(g)
path = Path(a * c * seq1, task1)
self.assertTrue(path.contains(a))
self.assertFalse(path.contains(b))
self.assertTrue(path.contains(c))
self.assertFalse(path.contains(d))
self.assertTrue(path.contains(e))
self.assertFalse(path.contains(f))
self.assertTrue(path.contains(g))
endpath = EndPath(h * i)
self.assertFalse(endpath.contains(b))
self.assertTrue(endpath.contains(i))
seq = Sequence(a * c)
self.assertFalse(seq.contains(b))
self.assertTrue(seq.contains(c))
task2 = Task(l)
task = Task(j, k, task2)
self.assertFalse(task.contains(b))
self.assertTrue(task.contains(j))
self.assertTrue(task.contains(k))
self.assertTrue(task.contains(l))
task3 = Task(m)
path2 = Path(n)
sch = Schedule(path, path2, tasks=[task,task3])
self.assertFalse(sch.contains(b))
self.assertTrue(sch.contains(a))
self.assertTrue(sch.contains(c))
self.assertTrue(sch.contains(e))
self.assertTrue(sch.contains(g))
self.assertTrue(sch.contains(n))
self.assertTrue(sch.contains(j))
self.assertTrue(sch.contains(k))
self.assertTrue(sch.contains(l))
self.assertTrue(sch.contains(m))
def testSchedule(self):
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDAnalyzer("YourAnalyzer")
p.c = EDAnalyzer("OurAnalyzer")
p.d = EDAnalyzer("OurAnalyzer")
p.path1 = Path(p.a)
p.path2 = Path(p.b)
p.path3 = Path(p.d)
s = Schedule(p.path1,p.path2)
self.assertEqual(s[0],p.path1)
self.assertEqual(s[1],p.path2)
p.schedule = s
self.assert_('b' in p.schedule.moduleNames())
self.assert_(hasattr(p, 'b'))
self.assert_(hasattr(p, 'c'))
self.assert_(hasattr(p, 'd'))
self.assert_(hasattr(p, 'path1'))
self.assert_(hasattr(p, 'path2'))
self.assert_(hasattr(p, 'path3'))
p.prune()
self.assert_('b' in p.schedule.moduleNames())
self.assert_(hasattr(p, 'b'))
self.assert_(not hasattr(p, 'c'))
self.assert_(not hasattr(p, 'd'))
self.assert_(hasattr(p, 'path1'))
self.assert_(hasattr(p, 'path2'))
self.assert_(not hasattr(p, 'path3'))
self.assertTrue(len(p.schedule._tasks) == 0)
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDAnalyzer("YourAnalyzer")
p.c = EDAnalyzer("OurAnalyzer")
p.d = EDAnalyzer("dAnalyzer")
p.e = EDProducer("eProducer")
p.f = EDProducer("fProducer")
p.Tracer = Service("Tracer")
p.path1 = Path(p.a)
p.path2 = Path(p.b)
p.path3 = Path(p.d)
p.task1 = Task(p.e)
p.task2 = Task(p.f, p.Tracer)
s = Schedule(p.path1,p.path2,tasks=[p.task1,p.task2,p.task1])
self.assertEqual(s[0],p.path1)
self.assertEqual(s[1],p.path2)
self.assertTrue(len(s._tasks) == 2)
self.assertTrue(p.task1 in s._tasks)
self.assertTrue(p.task2 in s._tasks)
listOfTasks = list(s._tasks)
self.assertTrue(len(listOfTasks) == 2)
self.assertTrue(p.task1 == listOfTasks[0])
self.assertTrue(p.task2 == listOfTasks[1])
p.schedule = s
self.assert_('b' in p.schedule.moduleNames())
process2 = Process("test")
process2.a = EDAnalyzer("MyAnalyzer")
process2.e = EDProducer("eProducer")
process2.path1 = Path(process2.a)
process2.task1 = Task(process2.e)
process2.schedule = Schedule(process2.path1,tasks=process2.task1)
listOfTasks = list(process2.schedule._tasks)
self.assertTrue(listOfTasks[0] == process2.task1)
# test Schedule copy
s2 = s.copy()
self.assertEqual(s2[0],p.path1)
self.assertEqual(s2[1],p.path2)
self.assertTrue(len(s2._tasks) == 2)
self.assertTrue(p.task1 in s2._tasks)
self.assertTrue(p.task2 in s2._tasks)
listOfTasks = list(s2._tasks)
self.assertTrue(len(listOfTasks) == 2)
self.assertTrue(p.task1 == listOfTasks[0])
self.assertTrue(p.task2 == listOfTasks[1])
names = s.moduleNames()
self.assertTrue(names == set(['a', 'b', 'e', 'Tracer', 'f']))
#adding a path not attached to the Process should cause an exception
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
path1 = Path(p.a)
s = Schedule(path1)
self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )
#make sure anonymous sequences work
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDAnalyzer("MyOtherAnalyzer")
p.c = EDProducer("MyProd")
path1 = Path(p.c*Sequence(p.a+p.b))
s = Schedule(path1)
self.assert_('a' in s.moduleNames())
self.assert_('b' in s.moduleNames())
self.assert_('c' in s.moduleNames())
p.path1 = path1
p.schedule = s
p.prune()
self.assert_('a' in s.moduleNames())
self.assert_('b' in s.moduleNames())
self.assert_('c' in s.moduleNames())
def testImplicitSchedule(self):
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDAnalyzer("YourAnalyzer")
p.c = EDAnalyzer("OurAnalyzer")
p.path1 = Path(p.a)
p.path2 = Path(p.b)
self.assert_(p.schedule is None)
pths = p.paths
keys = pths.keys()
self.assertEqual(pths[keys[0]],p.path1)
self.assertEqual(pths[keys[1]],p.path2)
p.prune()
self.assert_(hasattr(p, 'a'))
self.assert_(hasattr(p, 'b'))
self.assert_(not hasattr(p, 'c'))
self.assert_(hasattr(p, 'path1'))
self.assert_(hasattr(p, 'path2'))
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDAnalyzer("YourAnalyzer")
p.c = EDAnalyzer("OurAnalyzer")
p.path2 = Path(p.b)
p.path1 = Path(p.a)
self.assert_(p.schedule is None)
pths = p.paths
keys = pths.keys()
self.assertEqual(pths[keys[1]],p.path1)
self.assertEqual(pths[keys[0]],p.path2)
def testUsing(self):
p = Process('test')
p.block = PSet(a = int32(1))
p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
self.assertEqual(p.modu.a.value(),1)
self.assertEqual(p.modu.b.value(),2)
def testOverride(self):
p = Process('test')
a = EDProducer("A", a1=int32(0))
self.assert_(not a.isModified())
a.a1 = 1
self.assert_(a.isModified())
p.a = a
self.assertEqual(p.a.a1.value(), 1)
# try adding an unmodified module.
# should accept it
p.a = EDProducer("A", a1=int32(2))
self.assertEqual(p.a.a1.value(), 2)
# try adding a modified module. Should throw
# no longer, since the same (modified) say, geometry
# could come from more than one cff
b = EDProducer("A", a1=int32(3))
b.a1 = 4
#self.assertRaises(RuntimeError, setattr, *(p,'a',b))
ps1 = PSet(a = int32(1))
ps2 = PSet(a = int32(2))
self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))
def testExamples(self):
p = Process("Test")
p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
p.foos = EDProducer("FooProducer")
p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
p.bars.foos = 'Foosball'
self.assertEqual(p.bars.foos, InputTag('Foosball'))
p.p = Path(p.foos*p.bars)
p.e = EndPath(p.out)
p.add_(Service("MessageLogger"))
def testPrefers(self):
p = Process("Test")
p.add_(ESSource("ForceSource"))
p.juicer = ESProducer("JuicerProducer")
p.prefer("ForceSource")
p.prefer("juicer")
self.assertEqual(p.dumpConfig(),
"""process Test = {
es_module juicer = JuicerProducer {
}
es_source = ForceSource {
}
es_prefer = ForceSource {
}
es_prefer juicer = JuicerProducer {
}
}
""")
p.prefer("juicer",fooRcd=vstring("Foo"))
self.assertEqual(p.dumpConfig(),
"""process Test = {
es_module juicer = JuicerProducer {
}
es_source = ForceSource {
}
es_prefer = ForceSource {
}
es_prefer juicer = JuicerProducer {
vstring fooRcd = {
'Foo'
}
}
}
""")
self.assertEqual(p.dumpPython(),
"""import FWCore.ParameterSet.Config as cms
process = cms.Process("Test")
process.juicer = cms.ESProducer("JuicerProducer")
process.ForceSource = cms.ESSource("ForceSource")
process.prefer("ForceSource")
process.prefer("juicer",
fooRcd = cms.vstring('Foo')
)
""")
def testFreeze(self):
process = Process("Freeze")
m = EDProducer("M", p=PSet(i = int32(1)))
m.p.i = 2
process.m = m
# should be frozen
#self.assertRaises(ValueError, setattr, m.p, 'i', 3)
#self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
#self.assertRaises(ValueError, setattr, m.p, 'j', 1)
#self.assertRaises(ValueError, setattr, m, 'j', 1)
# But OK to change through the process
process.m.p.i = 4
self.assertEqual(process.m.p.i.value(), 4)
process.m.p = PSet(j=int32(1))
# should work to clone it, though
m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
m2.p.i = 6
m2.j = 8
def testSubProcess(self):
process = Process("Parent")
subProcess = Process("Child")
subProcess.a = EDProducer("A")
subProcess.p = Path(subProcess.a)
subProcess.add_(Service("Foo"))
process.addSubProcess(SubProcess(subProcess))
d = process.dumpPython()
equalD ="""import FWCore.ParameterSet.Config as cms
process = cms.Process("Parent")
parentProcess = process
import FWCore.ParameterSet.Config as cms
process = cms.Process("Child")
process.a = cms.EDProducer("A")
process.Foo = cms.Service("Foo")
process.p = cms.Path(process.a)
childProcess = process
process = parentProcess
process.addSubProcess(cms.SubProcess(process = childProcess, SelectEvents = cms.untracked.PSet(
), outputCommands = cms.untracked.vstring()))
"""
equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcesses_()[0])))
self.assertEqual(d,equalD)
p = TestMakePSet()
process.fillProcessDesc(p)
self.assertEqual((True,['a']),p.values["subProcesses"][1][0].values["process"][1].values['@all_modules'])
self.assertEqual((True,['p']),p.values["subProcesses"][1][0].values["process"][1].values['@paths'])
self.assertEqual({'@service_type':(True,'Foo')}, p.values["subProcesses"][1][0].values["process"][1].values["services"][1][0].values)
def testRefToPSet(self):
proc = Process("test")
proc.top = PSet(a = int32(1))
proc.ref = PSet(refToPSet_ = string("top"))
proc.ref2 = PSet( a = int32(1), b = PSet( refToPSet_ = string("top")))
proc.ref3 = PSet(refToPSet_ = string("ref"))
proc.ref4 = VPSet(PSet(refToPSet_ = string("top")),
PSet(refToPSet_ = string("ref2")))
p = TestMakePSet()
proc.fillProcessDesc(p)
self.assertEqual((True,1),p.values["ref"][1].values["a"])
self.assertEqual((True,1),p.values["ref3"][1].values["a"])
self.assertEqual((True,1),p.values["ref2"][1].values["a"])
self.assertEqual((True,1),p.values["ref2"][1].values["b"][1].values["a"])
self.assertEqual((True,1),p.values["ref4"][1][0].values["a"])
self.assertEqual((True,1),p.values["ref4"][1][1].values["a"])
def testSwitchProducer(self):
proc = Process("test")
proc.sp = SwitchProducerTest(test2 = EDProducer("Foo",
a = int32(1),
b = PSet(c = int32(2))),
test1 = EDProducer("Bar",
aa = int32(11),
bb = PSet(cc = int32(12))))
proc.a = EDProducer("A")
proc.s = Sequence(proc.a + proc.sp)
proc.t = Task(proc.a, proc.sp)
proc.p = Path()
proc.p.associate(proc.t)
p = TestMakePSet()
proc.fillProcessDesc(p)
self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
self.assertEqual((True, ["sp@test1", "sp@test2"]), p.values["sp"][1].values["@all_cases"])
self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
self.assertEqual(["a", "sp", "sp@test1", "sp@test2"], p.values["@all_modules"][1])
self.assertEqual((True,"EDProducer"), p.values["sp@test1"][1].values["@module_edm_type"])
self.assertEqual((True,"Bar"), p.values["sp@test1"][1].values["@module_type"])
self.assertEqual((True,"EDProducer"), p.values["sp@test2"][1].values["@module_edm_type"])
self.assertEqual((True,"Foo"), p.values["sp@test2"][1].values["@module_type"])
dump = proc.dumpPython()
self.assertEqual(dump.find('@'), -1)
self.assertEqual(specialImportRegistry.getSpecialImports(), ["from test import SwitchProducerTest"])
self.assertTrue(dump.find("\nfrom test import SwitchProducerTest\n") != -1)
# EDAlias as non-chosen case
proc = Process("test")
proc.sp = SwitchProducerTest(test2 = EDProducer("Foo",
a = int32(1),
b = PSet(c = int32(2))),
test1 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
proc.a = EDProducer("A")
proc.s = Sequence(proc.a + proc.sp)
proc.t = Task(proc.a, proc.sp)
proc.p = Path()
proc.p.associate(proc.t)
p = TestMakePSet()
proc.fillProcessDesc(p)
self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
self.assertEqual((True, ["sp@test1", "sp@test2"]), p.values["sp"][1].values["@all_cases"])
self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
self.assertEqual(["a", "sp", "sp@test2"], p.values["@all_modules"][1])
self.assertEqual(["sp@test1"], p.values["@all_aliases"][1])
self.assertEqual((True,"EDProducer"), p.values["sp@test2"][1].values["@module_edm_type"])
self.assertEqual((True,"Foo"), p.values["sp@test2"][1].values["@module_type"])
self.assertEqual((True,"EDAlias"), p.values["sp@test1"][1].values["@module_edm_type"])
self.assertEqual((True,"Bar"), p.values["sp@test1"][1].values["a"][1][0].values["type"])
# EDAlias as chosen case
proc = Process("test")
proc.sp = SwitchProducerTest(test1 = EDProducer("Foo",
a = int32(1),
b = PSet(c = int32(2))),
test2 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
proc.a = EDProducer("A")
proc.s = Sequence(proc.a + proc.sp)
proc.t = Task(proc.a, proc.sp)
proc.p = Path()
proc.p.associate(proc.t)
p = TestMakePSet()
proc.fillProcessDesc(p)
self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
self.assertEqual((True, ["sp@test1", "sp@test2"]), p.values["sp"][1].values["@all_cases"])
self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
self.assertEqual(["a", "sp", "sp@test1"], p.values["@all_modules"][1])
self.assertEqual(["sp@test2"], p.values["@all_aliases"][1])
self.assertEqual((True,"EDProducer"), p.values["sp@test1"][1].values["@module_edm_type"])
self.assertEqual((True,"Foo"), p.values["sp@test1"][1].values["@module_type"])
self.assertEqual((True,"EDAlias"), p.values["sp@test2"][1].values["@module_edm_type"])
self.assertEqual((True,"Bar"), p.values["sp@test2"][1].values["a"][1][0].values["type"])
def testPrune(self):
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDAnalyzer("YourAnalyzer")
p.c = EDAnalyzer("OurAnalyzer")
p.d = EDAnalyzer("OurAnalyzer")
p.s = Sequence(p.d)
p.path1 = Path(p.a)
p.path2 = Path(p.b)
self.assert_(p.schedule is None)
pths = p.paths
keys = pths.keys()
self.assertEqual(pths[keys[0]],p.path1)
self.assertEqual(pths[keys[1]],p.path2)
p.pset1 = PSet(parA = string("pset1"))
p.pset2 = untracked.PSet(parA = string("pset2"))
p.vpset1 = VPSet()
p.vpset2 = untracked.VPSet()
p.prune()
self.assert_(hasattr(p, 'a'))
self.assert_(hasattr(p, 'b'))
self.assert_(not hasattr(p, 'c'))
self.assert_(not hasattr(p, 'd'))
self.assert_(not hasattr(p, 's'))
self.assert_(hasattr(p, 'path1'))
self.assert_(hasattr(p, 'path2'))
# self.assert_(not hasattr(p, 'pset1'))
# self.assert_(hasattr(p, 'pset2'))
# self.assert_(not hasattr(p, 'vpset1'))
# self.assert_(not hasattr(p, 'vpset2'))
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDAnalyzer("YourAnalyzer")
p.c = EDAnalyzer("OurAnalyzer")
p.d = EDAnalyzer("OurAnalyzer")
p.e = EDAnalyzer("OurAnalyzer")
p.s = Sequence(p.d)
p.s2 = Sequence(p.b)
p.s3 = Sequence(p.e)
p.path1 = Path(p.a)
p.path2 = Path(p.b)
p.path3 = Path(p.b+p.s2)
p.path4 = Path(p.b+p.s3)
p.schedule = Schedule(p.path1,p.path2,p.path3)
pths = p.paths
keys = pths.keys()
self.assertEqual(pths[keys[0]],p.path1)
self.assertEqual(pths[keys[1]],p.path2)
p.prune()
self.assert_(hasattr(p, 'a'))
self.assert_(hasattr(p, 'b'))
self.assert_(not hasattr(p, 'c'))
self.assert_(not hasattr(p, 'd'))
self.assert_(not hasattr(p, 'e'))
self.assert_(not hasattr(p, 's'))
self.assert_(hasattr(p, 's2'))
self.assert_(not hasattr(p, 's3'))
self.assert_(hasattr(p, 'path1'))
self.assert_(hasattr(p, 'path2'))
self.assert_(hasattr(p, 'path3'))
self.assert_(not hasattr(p, 'path4'))
#test SequencePlaceholder
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDAnalyzer("YourAnalyzer")
p.s = Sequence(SequencePlaceholder("a")+p.b)
p.pth = Path(p.s)
p.prune()
self.assert_(hasattr(p, 'a'))
self.assert_(hasattr(p, 'b'))
self.assert_(hasattr(p, 's'))
self.assert_(hasattr(p, 'pth'))
#test unresolved SequencePlaceholder
p = Process("test")
p.b = EDAnalyzer("YourAnalyzer")
p.s = Sequence(SequencePlaceholder("a")+p.b)
p.pth = Path(p.s)
p.prune(keepUnresolvedSequencePlaceholders=True)
self.assert_(hasattr(p, 'b'))
self.assert_(hasattr(p, 's'))
self.assert_(hasattr(p, 'pth'))
self.assertEqual(p.s.dumpPython(''),'cms.Sequence(cms.SequencePlaceholder("a")+process.b)\n')
def testTaskPlaceholder(self):
p = Process("test")
p.a = EDProducer("ma")
p.b = EDAnalyzer("mb")
p.t1 = Task(TaskPlaceholder("c"))
p.t2 = Task(p.a, TaskPlaceholder("d"), p.t1)
p.t3 = Task(TaskPlaceholder("e"))
p.path1 = Path(p.b, p.t2, p.t3)
p.t5 = Task(p.a, TaskPlaceholder("g"), TaskPlaceholder("t4"))
p.t4 = Task(TaskPlaceholder("f"))
p.endpath1 = EndPath(p.b, p.t5)
p.t6 = Task(TaskPlaceholder("h"))
p.t7 = Task(p.a, TaskPlaceholder("i"), p.t6)
p.t8 = Task(TaskPlaceholder("j"))
p.schedule = Schedule(p.path1, p.endpath1,tasks=[p.t7,p.t8])
p.c = EDProducer("mc")
p.d = EDProducer("md")
p.e = EDProducer("me")
p.f = EDProducer("mf")
p.g = EDProducer("mg")
p.h = EDProducer("mh")
p.i = EDProducer("mi")
p.j = EDProducer("mj")
self.assertEqual(p.dumpPython(),
"""import FWCore.ParameterSet.Config as cms
process = cms.Process("test")
process.a = cms.EDProducer("ma")
process.c = cms.EDProducer("mc")
process.d = cms.EDProducer("md")
process.e = cms.EDProducer("me")
process.f = cms.EDProducer("mf")
process.g = cms.EDProducer("mg")
process.h = cms.EDProducer("mh")
process.i = cms.EDProducer("mi")
process.j = cms.EDProducer("mj")
process.b = cms.EDAnalyzer("mb")
process.t8 = cms.Task(cms.TaskPlaceholder("j"))
process.t6 = cms.Task(cms.TaskPlaceholder("h"))
process.t7 = cms.Task(cms.TaskPlaceholder("i"), process.a, process.t6)
process.t4 = cms.Task(cms.TaskPlaceholder("f"))
process.t5 = cms.Task(cms.TaskPlaceholder("g"), cms.TaskPlaceholder("t4"), process.a)
process.t3 = cms.Task(cms.TaskPlaceholder("e"))
process.t1 = cms.Task(cms.TaskPlaceholder("c"))
process.t2 = cms.Task(cms.TaskPlaceholder("d"), process.a, process.t1)
process.path1 = cms.Path(process.b, process.t2, process.t3)
process.endpath1 = cms.EndPath(process.b, process.t5)
process.schedule = cms.Schedule(*[ process.path1, process.endpath1 ], tasks=[process.t7, process.t8])
""")
p.resolve()
self.assertEqual(p.dumpPython(),
"""import FWCore.ParameterSet.Config as cms
process = cms.Process("test")
process.a = cms.EDProducer("ma")
process.c = cms.EDProducer("mc")
process.d = cms.EDProducer("md")
process.e = cms.EDProducer("me")
process.f = cms.EDProducer("mf")
process.g = cms.EDProducer("mg")
process.h = cms.EDProducer("mh")
process.i = cms.EDProducer("mi")
process.j = cms.EDProducer("mj")
process.b = cms.EDAnalyzer("mb")
process.t8 = cms.Task(process.j)
process.t6 = cms.Task(process.h)
process.t7 = cms.Task(process.a, process.i, process.t6)
process.t4 = cms.Task(process.f)
process.t5 = cms.Task(process.a, process.g, process.t4)
process.t3 = cms.Task(process.e)
process.t1 = cms.Task(process.c)
process.t2 = cms.Task(process.a, process.d, process.t1)
process.path1 = cms.Path(process.b, process.t2, process.t3)
process.endpath1 = cms.EndPath(process.b, process.t5)
process.schedule = cms.Schedule(*[ process.path1, process.endpath1 ], tasks=[process.t7, process.t8])
""")
def testDelete(self):
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer")
p.b = EDAnalyzer("YourAnalyzer")
p.c = EDAnalyzer("OurAnalyzer")
p.d = EDAnalyzer("OurAnalyzer")
p.e = EDAnalyzer("OurAnalyzer")
p.f = EDAnalyzer("OurAnalyzer")
p.g = EDProducer("OurProducer")
p.h = EDProducer("YourProducer")
p.t1 = Task(p.g, p.h)
t2 = Task(p.g, p.h)
t3 = Task(p.g, p.h)
p.s = Sequence(p.d+p.e)
p.path1 = Path(p.a+p.f+p.s,t2)
p.endpath1 = EndPath(p.b+p.f)
p.schedule = Schedule(tasks=[t3])
self.assertTrue(hasattr(p, 'f'))
self.assertTrue(hasattr(p, 'g'))
del p.e
del p.f
del p.g
self.assertFalse(hasattr(p, 'f'))
self.assertFalse(hasattr(p, 'g'))
self.assertTrue(p.t1.dumpPython(None) == 'cms.Task(process.h)\n')
self.assertTrue(p.s.dumpPython(None) == 'cms.Sequence(process.d)\n')
self.assertTrue(p.path1.dumpPython(None) == 'cms.Path(process.a+process.s, cms.Task(process.h))\n')
self.assertTrue(p.endpath1.dumpPython(None) == 'cms.EndPath(process.b)\n')
del p.s
self.assertTrue(p.path1.dumpPython(None) == 'cms.Path(process.a+(process.d), cms.Task(process.h))\n')
self.assertTrue(p.schedule_().dumpPython(None) == 'cms.Schedule(tasks=[cms.Task(process.h)])\n')
def testModifier(self):
m1 = Modifier()
p = Process("test",m1)
p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
def _mod_fred(obj):
obj.fred = 2
m1.toModify(p.a,_mod_fred)
self.assertEqual(p.a.fred.value(),2)
p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
m1.toModify(p.b, wilma = 2)
self.assertEqual(p.b.wilma.value(),2)
self.assert_(p.isUsingModifier(m1))
#check that Modifier not attached to a process doesn't run
m1 = Modifier()
p = Process("test")
p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
m1.toModify(p.a,_mod_fred)
p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
m1.toModify(p.b, wilma = 2)
self.assertEqual(p.a.fred.value(),1)
self.assertEqual(p.b.wilma.value(),1)
self.assertEqual(p.isUsingModifier(m1),False)
#make sure clones get the changes
m1 = Modifier()
p = Process("test",m1)
p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
m1.toModify(p.a, fred = int32(2))
p.b = p.a.clone(wilma = int32(3))
self.assertEqual(p.a.fred.value(),2)
self.assertEqual(p.a.wilma.value(),1)
self.assertEqual(p.b.fred.value(),2)
self.assertEqual(p.b.wilma.value(),3)
#test removal of parameter
m1 = Modifier()
p = Process("test",m1)
p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1), fintstones = PSet(fred = int32(1)))
m1.toModify(p.a, fred = None, fintstones = dict(fred = None))
self.assertEqual(hasattr(p.a, "fred"), False)
self.assertEqual(hasattr(p.a.fintstones, "fred"), False)
self.assertEqual(p.a.wilma.value(),1)
#test adding a parameter
m1 = Modifier()
p = Process("test",m1)
p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
m1.toModify(p.a, wilma = int32(2))
self.assertEqual(p.a.fred.value(), 1)
self.assertEqual(p.a.wilma.value(),2)
#test setting of value in PSet
m1 = Modifier()
p = Process("test",m1)
p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = int32(1), wilma = int32(1)))
m1.toModify(p.a, flintstones = dict(fred = int32(2)))
self.assertEqual(p.a.flintstones.fred.value(),2)
self.assertEqual(p.a.flintstones.wilma.value(),1)
#test proper exception from nonexisting parameter name
m1 = Modifier()
p = Process("test",m1)
p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = PSet(wilma = int32(1))))
self.assertRaises(KeyError, lambda: m1.toModify(p.a, flintstones = dict(imnothere = dict(wilma=2))))
self.assertRaises(KeyError, lambda: m1.toModify(p.a, foo = 1))
#test setting a value in a VPSet
m1 = Modifier()
p = Process("test",m1)
p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
m1.toModify(p.a, flintstones = {1:dict(wilma = int32(2))})
self.assertEqual(p.a.flintstones[0].fred.value(),1)
self.assertEqual(p.a.flintstones[1].wilma.value(),2)
#test setting a value in a list of values
m1 = Modifier()
p = Process("test",m1)
p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
m1.toModify(p.a, fred = {1:7})
self.assertEqual(p.a.fred[0],1)
self.assertEqual(p.a.fred[1],7)
self.assertEqual(p.a.fred[2],3)
#test IndexError setting a value in a list to an item key not in the list
m1 = Modifier()
p = Process("test",m1)
p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
raised = False
try: m1.toModify(p.a, fred = {5:7})
except IndexError as e: raised = True
self.assertEqual(raised, True)
#test TypeError setting a value in a list using a key that is not an int
m1 = Modifier()
p = Process("test",m1)
p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
raised = False
try: m1.toModify(p.a, flintstones = dict(bogus = int32(37)))
except TypeError as e: raised = True
self.assertEqual(raised, True)
#test that load causes process wide methods to run
def _rem_a(proc):
del proc.a
class ProcModifierMod(object):
def __init__(self,modifier,func):
self.proc_mod_ = modifier.makeProcessModifier(func)
class DummyMod(object):
def __init__(self):
self.a = EDAnalyzer("Dummy")
testMod = DummyMod()
p.extend(testMod)
self.assert_(hasattr(p,"a"))
m1 = Modifier()
p = Process("test",m1)
testProcMod = ProcModifierMod(m1,_rem_a)
p.extend(testMod)
p.extend(testProcMod)
self.assert_(not hasattr(p,"a"))
#test ModifierChain
m1 = Modifier()
mc = ModifierChain(m1)
p = Process("test",mc)
self.assert_(p.isUsingModifier(m1))
self.assert_(p.isUsingModifier(mc))
testMod = DummyMod()
p.b = EDAnalyzer("Dummy2", fred = int32(1))
m1.toModify(p.b, fred = int32(3))
p.extend(testMod)
testProcMod = ProcModifierMod(m1,_rem_a)
p.extend(testProcMod)
self.assert_(not hasattr(p,"a"))
self.assertEqual(p.b.fred.value(),3)
#check cloneAndExclude
m1 = Modifier()
m2 = Modifier()
mc = ModifierChain(m1,m2)
mclone = mc.copyAndExclude([m2])
self.assert_(not mclone._isOrContains(m2))
self.assert_(mclone._isOrContains(m1))
m3 = Modifier()
mc2 = ModifierChain(mc,m3)
mclone = mc2.copyAndExclude([m2])
self.assert_(not mclone._isOrContains(m2))
self.assert_(mclone._isOrContains(m1))
self.assert_(mclone._isOrContains(m3))
#check combining
m1 = Modifier()
m2 = Modifier()
p = Process("test",m1)
p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
(m1 & m2).toModify(p.a, fred = int32(2))
self.assertRaises(TypeError, lambda: (m1 & m2).toModify(p.a, 1, wilma=2))
self.assertEqual(p.a.fred, 1)
m1 = Modifier()
m2 = Modifier()
p = Process("test",m1,m2)
p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
(m1 & m2).toModify(p.a, fred = int32(2))
self.assertEqual(p.a.fred, 2)
m1 = Modifier()
m2 = Modifier()
m3 = Modifier()
p = Process("test",m1,m2,m3)
p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
(m1 & m2 & m3).toModify(p.a, fred = int32(2))
self.assertEqual(p.a.fred, 2)
(m1 & (m2 & m3)).toModify(p.a, fred = int32(3))
self.assertEqual(p.a.fred, 3)
((m1 & m2) & m3).toModify(p.a, fred = int32(4))
self.assertEqual(p.a.fred, 4)
#check inverse
m1 = Modifier()
m2 = Modifier()
p = Process("test", m1)
p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
(~m1).toModify(p.a, fred=2)
self.assertEqual(p.a.fred, 1)
(~m2).toModify(p.a, wilma=2)
self.assertEqual(p.a.wilma, 2)
self.assertRaises(TypeError, lambda: (~m1).toModify(p.a, 1, wilma=2))
self.assertRaises(TypeError, lambda: (~m2).toModify(p.a, 1, wilma=2))
# check or
m1 = Modifier()
m2 = Modifier()
m3 = Modifier()
p = Process("test", m1)
p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
(m1 | m2).toModify(p.a, fred=2)
self.assertEqual(p.a.fred, 2)
(m1 | m2 | m3).toModify(p.a, fred=3)
self.assertEqual(p.a.fred, 3)
(m3 | m2 | m1).toModify(p.a, fred=4)
self.assertEqual(p.a.fred, 4)
((m1 | m2) | m3).toModify(p.a, fred=5)
self.assertEqual(p.a.fred, 5)
(m1 | (m2 | m3)).toModify(p.a, fred=6)
self.assertEqual(p.a.fred, 6)
(m2 | m3).toModify(p.a, fred=7)
self.assertEqual(p.a.fred, 6)
self.assertRaises(TypeError, lambda: (m1 | m2).toModify(p.a, 1, wilma=2))
self.assertRaises(TypeError, lambda: (m2 | m3).toModify(p.a, 1, wilma=2))
# check combinations
m1 = Modifier()
m2 = Modifier()
m3 = Modifier()
m4 = Modifier()
p = Process("test", m1, m2)
p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
(m1 & ~m2).toModify(p.a, fred=2)
self.assertEqual(p.a.fred, 1)
(m1 & ~m3).toModify(p.a, fred=2)
self.assertEqual(p.a.fred, 2)
(m1 | ~m2).toModify(p.a, fred=3)
self.assertEqual(p.a.fred, 3)
(~m1 | ~m2).toModify(p.a, fred=4)
self.assertEqual(p.a.fred, 3)
(~m3 & ~m4).toModify(p.a, fred=4)
self.assertEqual(p.a.fred, 4)
((m1 & m3) | ~m4).toModify(p.a, fred=5)
self.assertEqual(p.a.fred, 5)
#check toReplaceWith
m1 = Modifier()
p = Process("test",m1)
p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
self.assertRaises(TypeError, lambda: m1.toReplaceWith(p.a, EDProducer("YourProducer")))
p.b =EDAnalyzer("BAn")
p.c =EDProducer("c")
p.d =EDProducer("d")
p.tc = Task(p.c)
p.td = Task(p.d)
p.s = Sequence(p.a, p.tc)
m1.toReplaceWith(p.s, Sequence(p.a+p.b, p.td))
self.assertEqual(p.a.wilma.value(),3)
self.assertEqual(p.a.type_(),"YourAnalyzer")
self.assertEqual(hasattr(p,"fred"),False)
self.assertTrue(p.s.dumpPython("") == "cms.Sequence(process.a+process.b, process.td)\n")
p.e =EDProducer("e")
m1.toReplaceWith(p.td, Task(p.e))
self.assertTrue(p.td._collection == OrderedSet([p.e]))
#check toReplaceWith doesn't activate not chosen
m1 = Modifier()
p = Process("test")
p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
self.assertEqual(p.a.type_(),"MyAnalyzer")
#check toReplaceWith and and/not/or combinations
m1 = Modifier()
m2 = Modifier()
m3 = Modifier()
m4 = Modifier()
p = Process("test", m1, m2)
p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
self.assertRaises(TypeError, lambda: (m1 & m2).toReplaceWith(p.a, EDProducer("YourProducer")))
self.assertRaises(TypeError, lambda: (m3 & m4).toReplaceWith(p.a, EDProducer("YourProducer")))
self.assertRaises(TypeError, lambda: (~m3).toReplaceWith(p.a, EDProducer("YourProducer")))
self.assertRaises(TypeError, lambda: (~m1).toReplaceWith(p.a, EDProducer("YourProducer")))
self.assertRaises(TypeError, lambda: (m1 | m3).toReplaceWith(p.a, EDProducer("YourProducer")))
self.assertRaises(TypeError, lambda: (m3 | m4).toReplaceWith(p.a, EDProducer("YourProducer")))
(m1 & m2).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer1"))
self.assertEqual(p.a.type_(), "YourAnalyzer1")
(m1 & m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
self.assertEqual(p.a.type_(), "YourAnalyzer1")
(~m1).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
self.assertEqual(p.a.type_(), "YourAnalyzer1")
(~m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
self.assertEqual(p.a.type_(), "YourAnalyzer2")
(m1 | m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer3"))
self.assertEqual(p.a.type_(), "YourAnalyzer3")
(m3 | m4).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer4"))
self.assertEqual(p.a.type_(), "YourAnalyzer3")
# EDAlias
a = EDAlias(foo2 = VPSet(PSet(type = string("Foo2"))))
m = Modifier()
m._setChosen()
# Modify parameters
m.toModify(a, foo2 = {0: dict(type = "Foo3")})
self.assertEqual(a.foo2[0].type, "Foo3")
# Add an alias
m.toModify(a, foo4 = VPSet(PSet(type = string("Foo4"))))
self.assertEqual(a.foo2[0].type, "Foo3")
self.assertEqual(a.foo4[0].type, "Foo4")
# Remove an alias
m.toModify(a, foo2 = None)
self.assertFalse(hasattr(a, "foo2"))
self.assertEqual(a.foo4[0].type, "Foo4")
# Replace (doesn't work out of the box because EDAlias is not _Parameterizable
m.toReplaceWith(a, EDAlias(bar = VPSet(PSet(type = string("Bar")))))
self.assertFalse(hasattr(a, "foo2"))
self.assertFalse(hasattr(a, "foo4"))
self.assertTrue(hasattr(a, "bar"))
self.assertEqual(a.bar[0].type, "Bar")
# SwitchProducer
sp = SwitchProducerTest(test1 = EDProducer("Foo",
a = int32(1),
b = PSet(c = int32(2))),
test2 = EDProducer("Bar",
aa = int32(11),
bb = PSet(cc = int32(12))))
m = Modifier()
m._setChosen()
# Modify parameters
m.toModify(sp,
test1 = dict(a = 4, b = dict(c = None)),
test2 = dict(aa = 15, bb = dict(cc = 45, dd = string("foo"))))
self.assertEqual(sp.test1.a.value(), 4)
self.assertEqual(sp.test1.b.hasParameter("c"), False)
self.assertEqual(sp.test2.aa.value(), 15)
self.assertEqual(sp.test2.bb.cc.value(), 45)
self.assertEqual(sp.test2.bb.dd.value(), "foo")
# Replace a producer
m.toReplaceWith(sp.test1, EDProducer("Fred", x = int32(42)))
self.assertEqual(sp.test1.type_(), "Fred")
self.assertEqual(sp.test1.x.value(), 42)
self.assertRaises(TypeError, lambda: m.toReplaceWith(sp.test1, EDAnalyzer("Foo")))
# Alternative way (only to be allow same syntax to be used as for adding)
m.toModify(sp, test2 = EDProducer("Xyzzy", x = int32(24)))
self.assertEqual(sp.test2.type_(), "Xyzzy")
self.assertEqual(sp.test2.x.value(), 24)
self.assertRaises(TypeError, lambda: m.toModify(sp, test2 = EDAnalyzer("Foo")))
# Add a producer
m.toModify(sp, test3 = EDProducer("Wilma", y = int32(24)))
self.assertEqual(sp.test3.type_(), "Wilma")
self.assertEqual(sp.test3.y.value(), 24)
self.assertRaises(TypeError, lambda: m.toModify(sp, test4 = EDAnalyzer("Foo")))
# Remove a producer
m.toModify(sp, test2 = None)
self.assertEqual(hasattr(sp, "test2"), False)
# Add an alias
m.toModify(sp, test2 = EDAlias(foo = VPSet(PSet(type = string("int")))))
self.assertTrue(hasattr(sp.test2, "foo"))
# Replace an alias
m.toReplaceWith(sp.test2, EDAlias(bar = VPSet(PSet(type = string("int")))))
self.assertTrue(hasattr(sp.test2, "bar"))
# Alternative way
m.toModify(sp, test2 = EDAlias(xyzzy = VPSet(PSet(type = string("int")))))
self.assertTrue(hasattr(sp.test2, "xyzzy"))
# Replace an alias with EDProducer
self.assertRaises(TypeError, lambda: m.toReplaceWith(sp.test2, EDProducer("Foo")))
m.toModify(sp, test2 = EDProducer("Foo"))
unittest.main()
| 43.843594 | 432 | 0.586205 |
089b73fc01b2119228e0d4eb64ac68cdd66fd048 | 229 | py | Python | beir/retrieval/models/__init__.py | tstadel/beir | 3abb52f9465d91a92d61b35b95b371cfbcd3a248 | [
"Apache-2.0"
] | 24 | 2022-03-20T18:48:52.000Z | 2022-03-31T08:28:42.000Z | beir/retrieval/models/__init__.py | tstadel/beir | 3abb52f9465d91a92d61b35b95b371cfbcd3a248 | [
"Apache-2.0"
] | 9 | 2022-03-19T14:50:30.000Z | 2022-03-30T17:31:18.000Z | beir/retrieval/models/__init__.py | tstadel/beir | 3abb52f9465d91a92d61b35b95b371cfbcd3a248 | [
"Apache-2.0"
] | 3 | 2022-03-25T15:45:14.000Z | 2022-03-25T17:51:23.000Z | from .sentence_bert import SentenceBERT
from .use_qa import UseQA
from .sparta import SPARTA
from .dpr import DPR
from .bpr import BinarySentenceBERT
from .unicoil import UniCOIL
from .splade import SPLADE
from .tldr import TLDR
| 25.444444 | 39 | 0.825328 |
319e651552082f44c17b6af0fc1e965678773f38 | 38,253 | py | Python | hapiclient/hapi.py | hapi-server/client-python | 4ba6d24e07dcb81ef02f0960b66c04508da2ed14 | [
"BSD-3-Clause"
] | 9 | 2018-07-12T20:05:00.000Z | 2022-02-02T20:34:07.000Z | hapiclient/hapi.py | hapi-server/client-python | 4ba6d24e07dcb81ef02f0960b66c04508da2ed14 | [
"BSD-3-Clause"
] | 38 | 2018-09-12T03:11:23.000Z | 2022-03-29T14:41:34.000Z | hapiclient/hapi.py | hapi-server/client-python | 4ba6d24e07dcb81ef02f0960b66c04508da2ed14 | [
"BSD-3-Clause"
] | 8 | 2018-09-10T11:03:37.000Z | 2021-08-09T02:07:15.000Z | import os
import re
import sys
import json
import time
import pickle
import warnings
from datetime import datetime, timedelta
import pandas
import isodate
import numpy as np
from joblib import Parallel, delayed
from hapiclient.hapitime import hapitime2datetime, hapitime_reformat
from hapiclient.util import setopts, log, warning, error
from hapiclient.util import urlopen, urlretrieve, jsonparse
def subset(meta, params):
"""Extract subset of parameters from meta object returned by hapi().
``metar = subset(meta, parameters)`` modifies ``meta["parameters"]`` array
so that it only contains elements for the time variable and the parameters
in the comma-separated string ``parameters``.
"""
if params == '':
return meta
p = params.split(',')
pm = [] # Parameter names in metadata
for i in range(0, len(meta['parameters'])):
pm.append(meta['parameters'][i]['name'])
# Check for parameters requested that are not in metadata
for i in range(0, len(p)):
if p[i] not in pm:
error('Parameter %s is not in meta' % p[i] + '\n')
return
pa = [meta['parameters'][0]] # First parameter is always the time parameter
params_reordered = [] # Re-ordered params
# If time parameter explicity requested, put it first in params_reordered.
if meta['parameters'][0]['name'] in p:
params_reordered = [meta['parameters'][0]['name']]
# Create subset of parameter metadata
for i in range(1, len(pm)):
if pm[i] in p:
pa.append(meta['parameters'][i])
params_reordered.append(pm[i])
meta['parameters'] = pa
params_reordered_str = ','.join(params_reordered)
if not params == params_reordered_str:
msg = "\n " + "Order requested: " + params
msg = msg + "\n " + "Order required: " + params_reordered_str
error('Order of requested parameters does not match order of ' \
'parameters in server info metadata.' + msg + '\n')
return meta
def cachedir(*args):
"""HAPI cache directory.
cachedir() returns tempfile.gettempdir() + os.path.sep + 'hapi-data'
cachdir(basedir, server) returns basedir + os.path.sep + server2dirname(server)
"""
import tempfile
if len(args) == 2:
# cachedir(base_dir, server)
return args[0] + os.path.sep + server2dirname(args[1])
else:
# cachedir()
return tempfile.gettempdir() + os.path.sep + 'hapi-data'
def server2dirname(server):
"""Convert a server URL to a directory name."""
urld = re.sub(r"https*://", "", server)
urld = re.sub(r'/', '_', urld)
return urld
def request2path(*args):
# request2path(server, dataset, parameters, start, stop)
# request2path(server, dataset, parameters, start, stop, cachedir)
if len(args) == 5:
# Use default if cachedir not given.
cachedirectory = cachedir()
else:
cachedirectory = args[5]
# url subdirectory
urldirectory = server2dirname(args[0])
fname = '%s_%s_%s_%s' % (re.sub('/', '_', args[1]),
re.sub(',', '-', args[2]),
re.sub(r'-|:|\.|Z', '', args[3]),
re.sub(r'-|:|\.|Z', '', args[4]))
return os.path.join(cachedirectory, urldirectory, fname)
def hapiopts():
"""Return dict of default options for hapi()
Used by hapiplot() and hapi().
format = 'binary' is used by default and CSV used if binary is not
available from server. This should option should be excluded from the help
string.
method = 'pandas' is used by default. Other methods
(numpy, pandasnolength, numpynolength) can be used for testing
CSV read methods. See test/test_hapi.py for comparison.
"""
# Default options
opts = {
'logging': False,
'cache': True,
'cachedir': cachedir(),
'usecache': False,
'server_list': 'https://github.com/hapi-server/servers/raw/master/all.txt',
'format': 'binary',
'method': 'pandas',
'parallel': False,
'n_parallel': 5,
'n_chunks': None,
'dt_chunk': None,
}
return opts
def hapi(*args, **kwargs):
"""Request data from a HAPI server.
Version: 0.2.1
Examples
----------
`Jupyter Notebook <https://colab.research.google.com/drive/11Zy99koiE90JKJ4u_KPTaEBMQFzbfU3P?usp=sharing>_`
Parameters
----------
server : str
A string with the URL to a HAPI compliant server. (A HAPI URL
always ends with "/hapi").
dataset : str
A string specifying a dataset from a `server`
parameters: str
A Comma-separated list of parameters in `dataset`
start: str
The start time of the requested data
stop: str
The end time of the requested data; end times are exclusive - the
last data record returned by a HAPI server should have a timestamp
before `start`.
options : dict
`logging` (False) - Log to console
`cache` (True) - Save responses and processed responses in cachedir
`cachedir` (./hapi-data)
`usecache` (True) - Use files in `cachedir` if found
`serverlist` (https://github.com/hapi-server/servers/raw/master/all.txt)
`parallel` (False) If true, make up to `n_parallel` requests to
server in parallel (uses threads)
`n_parallel` (5) Maximum number of parallel requests to server.
Max allowed is 5.
`n_chunks` (None) Get data by making `n_chunks` requests by splitting
requested time range. `dt_chunk` is ignored if `n_chunks` is
not `None`. Allowed values are integers > 1.
`dt_chunk` ('infer') For requests that span a time range larger
than the default chunk size for a given dataset cadence, the
client will split request into chunks if `dt_chunk` is not
`None`.
Allowed values of `dt_chunk` are 'infer', `None`, and an ISO 8601
duration that is unambiguous (durations that include Y and M are not
allowed). The default chunk size is determined based on the cadence
of the dataset requested according to
cadence < PT1S dt_chunk='PT1H'
PT1S <= cadence <= PT1H dt_chunk='P1D'
cadence > PT1H dt_chunk='P30D'
cadence >= P1D dt_chunk='P365D'
If the dataset does not have a cadence listed in its metadata, an
attempt is made to infer the cadence by requesting a small time range
of data and doubling the time range until 10 records are in the response.
The cadence used to determine the chunk size is then the average time
difference between records.
If requested time range is < 1/2 of chunk size, only one request is
made. Otherwise, start and/or stop are modified to be at hour, day,
month or year boundaries and requests are made for a time span of a
full chunk, and trimming is performed. For example,
Cadence = PT1M and request for
start/stop=1999-11-12T00:10:00/stop=1999-11-12T12:09:00
Chunk size is P1D and requested time range < 1/2 of this
=> Default behavior
Cadence = PT1M and request for
start/stop=1999-11-12T00:10:00/1999-11-12T12:10:00
Chunk size is P1D and requested time range >= 1/2 of this
=> One request with start/stop=1999-11-12/1999-11-13
and trim performed
Cadence = PT1M and request for
start/stop=1999-11-12T00:10:00/1999-11-13T12:09:00
Chunk size is P1D and requested time range > than this
=> Two requests:
(1) start/stop=1999-11-12/start=1999-11-13
(2) start/stop=1999-11-13/start=1999-11-14
and trim performed
Returns
-------
result : various
`result` depends on the input parameters.
servers = hapi() returns a list of available HAPI server URLs from
https://github.com/hapi-server/data-specification/blob/master/all.txt
dataset = hapi(server) returns a dict of datasets available from a
URL given by the string `server`. The dictionary structure follows the
HAPI JSON structure.
parameters = hapi(server, dataset) returns a dictionary of parameters
in the string `dataset`. The dictionary structure follows the HAPI JSON
structure.
metadata = hapi(server, dataset, parameters) returns metadata
associated each parameter in the comma-separated string `parameters`. The
dictionary structure follows the HAPI JSON structure.
data = hapi(server, dataset, parameters, start, stop) returns a
dictionary with elements corresponding to `parameters`, e.g., if
`parameters` = 'scalar,vector' and the number of records in the time
range `start` <= t < `stop` returned is N, then
data['scalar'] is a NumPy array of shape (N)
data['vector'] is a NumPy array of shape (N,3)
data['Time'] is a NumPy array of byte literals with shape (N).
Byte literal times can be converted to Python datetimes using
dtarray = hapitime2datetime(data['Time'])
data, meta = hapi(server, dataset, parameters, start, stop) returns
the metadata for parameters in `meta`.
References
----------
* `HAPI Server Definition <https://github.com/hapi-server/data-specification>`_
"""
nin = len(args)
if nin > 0:
SERVER = args[0]
if nin > 1:
DATASET = args[1]
if nin > 2:
PARAMETERS = args[2]
if nin > 3:
START = args[3]
if START[-1] != 'Z':
# TODO: Consider warning.
START = START + 'Z'
if nin > 4:
STOP = args[4]
if STOP[-1] != 'Z':
# TODO: Consider warning.
STOP = STOP + 'Z'
# Override defaults
opts = setopts(hapiopts(), kwargs)
assert (opts['logging'] in [True, False])
assert (opts['cache'] in [True, False])
assert (opts['usecache'] in [True, False])
assert (opts['format'] in ['binary', 'csv'])
assert (opts['method'] in ['', 'pandas', 'numpy', 'pandasnolength', 'numpynolength'])
assert (opts['parallel'] in [True, False])
assert (isinstance(opts['n_parallel'], int) and opts['n_parallel'] > 1)
assert (opts['n_chunks'] is None or isinstance(opts['n_chunks'], int) and opts['n_chunks'] > 0)
assert (opts['dt_chunk'] in [None, 'infer', 'PT1H', 'P1D', 'P1M', 'P1Y'])
from hapiclient import __version__
log('Running hapi.py version %s' % __version__, opts)
if nin == 0: # hapi()
log('Reading %s' % opts['server_list'], opts)
# decode('utf8') in following needed to make Python 2 and 3 types match.
data = urlopen(opts['server_list']).read().decode('utf8').split('\n')
data = [x for x in data if x] # Remove empty items (if blank lines)
# Display server URLs to console.
log('List of HAPI servers in %s:\n' % opts['server_list'], opts)
for url in data:
log(" %s" % url, opts)
return data
if nin == 1: # hapi(SERVER)
# TODO: Cache
url = SERVER + '/catalog'
log('Reading %s' % url, opts)
res = urlopen(url)
meta = jsonparse(res, url)
return meta
if nin == 2: # hapi(SERVER, DATASET)
# TODO: Cache
url = SERVER + '/info?id=' + DATASET
log('Reading %s' % url, opts)
res = urlopen(url)
meta = jsonparse(res, url)
return meta
if nin == 4:
error('A stop time is required if a start time is given.')
if nin == 3 or nin == 5:
# hapi(SERVER, DATASET, PARAMETERS) or
# hapi(SERVER, DATASET, PARAMETERS, START, STOP)
# Extract all parameters.
if re.search(r', ', PARAMETERS):
warning("Removing spaces after commas in given parameter list of '" \
+ PARAMETERS + "'")
PARAMETERS = re.sub(r',\s+', ',', PARAMETERS)
# urld = url subdirectory of cachedir to store files from SERVER
urld = cachedir(opts["cachedir"], SERVER)
if opts["cachedir"]: log('file directory = %s' % urld, opts)
urljson = SERVER + '/info?id=' + DATASET
# Output from urljson will be saved in a .json file. Parsed json
# will be stored in a .pkl file. Metadata for all parameters is
# requested and response is subsetted so only metadata for PARAMETERS
# is returned.
fname_root = request2path(SERVER, DATASET, '', '', '', opts['cachedir'])
fnamejson = fname_root + '.json'
fnamepkl = fname_root + '.pkl'
if nin == 5: # Data requested
tic_totalTime = time.time()
# URL to get CSV (will be used if binary response is not available)
urlcsv = SERVER + '/data?id=' + DATASET + '¶meters=' + \
PARAMETERS + '&time.min=' + START + '&time.max=' + STOP
# URL for binary request
urlbin = urlcsv + '&format=binary'
# Raw CSV and HAPI Binary (no header) will be stored in .csv and
# .bin files. Parsed response of either CSV or HAPI Binary will
# be stored in a .npy file.
# fnamepklx will contain additional metadata about the request
# including d/l time, parsing time, and the location of files.
fname_root = request2path(SERVER, DATASET, PARAMETERS, START, STOP, opts['cachedir'])
fnamecsv = fname_root + '.csv'
fnamebin = fname_root + '.bin'
fnamenpy = fname_root + '.npy'
fnamepklx = fname_root + ".pkl"
metaFromCache = False
if opts["usecache"]:
if nin == 3 and os.path.isfile(fnamepkl):
# Read cached metadata from .pkl file.
# This returns subsetted metadata with no additional "x_"
# information (which is stored in fnamepklx).
log('Reading %s' % fnamepkl.replace(urld + '/', ''), opts)
f = open(fnamepkl, 'rb')
meta = pickle.load(f)
f.close()
metaFromCache = True
# Remove parameters not requested.
meta = subset(meta, PARAMETERS)
return meta
if os.path.isfile(fnamepklx):
# Read subsetted meta file with x_ information
log('Reading %s' % fnamepklx.replace(urld + '/', ''), opts)
f = open(fnamepklx, 'rb')
meta = pickle.load(f)
metaFromCache = True
f.close()
if not metaFromCache:
# No cached metadata loaded so request it from server.
log('Reading %s' % urljson.replace(urld + '/', ''), opts)
res = urlopen(urljson)
meta = jsonparse(res, urljson)
# Add information to metadata so we can figure out request needed
# to generated it. Will also be used for labeling plots by hapiplot().
meta.update({"x_server": SERVER})
meta.update({"x_dataset": DATASET})
if opts["cache"]:
if not os.path.exists(urld): os.makedirs(urld)
if opts['dt_chunk'] == 'infer':
cadence = meta.get('cadence', None)
# If cadence not given, use 1-day chunks.
if cadence is None:
cadence = 'PT1M'
else:
cadence = isodate.parse_duration(cadence)
if isinstance(cadence, isodate.Duration):
# When a duration does not correspond to an unambiguous
# time duration (e.g., P1M), parse_duration returns an
# isodate.duration.Duration object. Otherwise, it returns
# a datetime.timedelta object.
cadence = cadence.totimedelta(start=datetime.now())
pt1s = isodate.parse_duration('PT1S')
pt1h = isodate.parse_duration('PT1H')
p1d = isodate.parse_duration('P1D')
if cadence < pt1s:
opts['dt_chunk'] = 'PT1H'
elif pt1s <= cadence <= pt1h:
opts['dt_chunk'] = 'P1D'
elif cadence > pt1h:
opts['dt_chunk'] = 'P1M'
elif cadence >= p1d:
opts['dt_chunk'] = 'P1Y'
if opts['n_chunks'] is not None or opts['dt_chunk'] is not None:
padz = lambda x: x if 'Z' in x else x + 'Z'
pSTART = hapitime2datetime(padz(START))[0]
pSTOP = hapitime2datetime(padz(STOP))[0]
if opts['dt_chunk']:
pDELTA = isodate.parse_duration(opts['dt_chunk'])
if opts['dt_chunk'] == 'P1Y':
half = isodate.parse_duration('P365D') / 2
elif opts['dt_chunk'] == 'P1M':
half = isodate.parse_duration('P30D') / 2
else:
half = pDELTA / 2
if (pSTOP - pSTART) < half:
opts['n_chunks'] = None
opts['dt_chunk'] = None
return hapi(SERVER, DATASET, PARAMETERS, START, STOP, **opts)
if opts['dt_chunk'] == 'P1Y':
pSTART = datetime(pSTART.year, 1, 1)
pSTOP = datetime(pSTOP.year + 1, 1, 1)
opts['n_chunks'] = pSTOP.year - pSTART.year
elif opts['dt_chunk'] == 'P1M':
pSTART = datetime(pSTART.year, pSTART.month, 1)
pSTOP = datetime(pSTOP.year, pSTOP.month + 1, 1)
opts['n_chunks'] = (pSTOP.year - pSTART.year) * 12 + (pSTOP.month - pSTART.month)
elif opts['dt_chunk'] == 'P1D':
pSTART = datetime.combine(pSTART.date(), datetime.min.time())
pSTOP = datetime.combine(pSTOP.date(), datetime.min.time()) + timedelta(days=1)
opts['n_chunks'] = (pSTOP - pSTART).days
elif opts['dt_chunk'] == 'PT1H':
pSTART = datetime.combine(pSTART.date(), datetime.min.time()) + timedelta(hours=pSTART.hour)
pSTOP = datetime.combine(pSTOP.date(), datetime.min.time()) + timedelta(hours=pSTOP.hour + 1)
opts['n_chunks'] = int(((pSTOP - pSTART).total_seconds() / 60) / 60)
else:
pDIFF = pSTOP - pSTART
pDELTA = pDIFF / opts['n_chunks']
n_chunks = opts['n_chunks']
opts['n_chunks'] = None
opts['dt_chunk'] = None
backend = 'sequential'
if opts['parallel']:
backend = 'threading'
# multiprocessing was not tested. It may work, but will
# need a speed comparison with threading.
# backend = 'multiprocessing'
log('backend = {}'.format(backend), opts)
verbose = 0
if opts.get('logging'):
verbose = 100
def nhapi(SERVER, DATASET, PARAMETERS, pSTART, pDELTA, i, **opts):
START = pSTART + (i * pDELTA)
START = str(START.date())+'T'+str(START.time())
STOP = pSTART + ((i + 1) * pDELTA)
STOP = str(STOP.date()) + 'T' + str(STOP.time())
data, meta = hapi(
SERVER,
DATASET,
PARAMETERS,
START,
STOP,
**opts
)
return data, meta
resD, resM = zip(
*Parallel(n_jobs=opts['n_parallel'], verbose=verbose, backend=backend)(
delayed(nhapi)(
SERVER,
DATASET,
PARAMETERS,
pSTART,
pDELTA,
i,
**opts
) for i in range(n_chunks)
)
)
resD = list(resD)
tic_trimTime = time.time()
if sys.version_info < (3, ):
START = hapitime_reformat(str(resD[0]['Time'][0]), START)
resD[0] = resD[0][resD[0]['Time'] >= START]
STOP = hapitime_reformat(str(resD[-1]['Time'][0]), STOP)
resD[-1] = resD[-1][resD[-1]['Time'] < STOP]
else:
START = hapitime_reformat(resD[0]['Time'][0].decode('UTF-8'), START)
resD[0] = resD[0][resD[0]['Time'] >= bytes(START, 'UTF-8')]
STOP = hapitime_reformat(resD[-1]['Time'][0].decode('UTF-8'), STOP)
resD[-1] = resD[-1][resD[-1]['Time'] < bytes(STOP, 'UTF-8')]
trimTime = time.time() - tic_trimTime
tic_catTime = time.time()
data = np.concatenate(resD)
catTime = time.time() - tic_catTime
meta = resM[0].copy()
meta['x_time.max'] = resM[-1]['x_time.max']
meta['x_dataFile'] = None
meta['x_dataFiles'] = [resM[i]['x_dataFile'] for i in range(len(resM))]
meta['x_downloadTime'] = sum([resM[i]['x_downloadTime'] for i in range(len(resM))])
meta['x_downloadTimes'] = [resM[i]['x_downloadTime'] for i in range(len(resM))]
meta['x_readTime'] = sum([resM[i]['x_readTime'] for i in range(len(resM))])
meta['x_readTimes'] = [resM[i]['x_readTime'] for i in range(len(resM))]
meta['x_trimTime'] = trimTime
meta['x_catTime'] = catTime
meta['x_totalTime'] = time.time() - tic_totalTime
meta['x_dataFileParsed'] = None
meta['x_dataFilesParsed'] = [resM[i]['x_dataFileParsed'] for i in range(len(resM))]
return data, meta
if opts["cache"] and not metaFromCache:
# Cache metadata for all parameters if it was not already loaded
# from cache. Note that fnamepklx is written after data downloaded
# and parsed.
log('Writing %s ' % fnamejson.replace(urld + '/', ''), opts)
f = open(fnamejson, 'w')
json.dump(meta, f, indent=4)
f.close()
log('Writing %s ' % fnamepkl.replace(urld + '/', ''), opts)
f = open(fnamepkl, 'wb')
# protocol=2 used for Python 2.7 compatability.
pickle.dump(meta, f, protocol=2)
f.close()
# Remove unrequested parameters if they have not have already been
# removed (b/c loaded from cache).
if not metaFromCache:
meta = subset(meta, PARAMETERS)
if nin == 3:
return meta
if opts["usecache"] and os.path.isfile(fnamenpy):
# Read cached data file.
log('Reading %s ' % fnamenpy.replace(urld + '/', ''), opts)
f = open(fnamenpy, 'rb')
data = np.load(f)
f.close()
# There is a possibility that the fnamenpy file existed but
# fnamepklx was not found (b/c removed). In this case, the meta
# returned will not have all of the "x_" information inserted below.
# Code that uses this information needs to account for this.
meta['x_totalTime'] = time.time() - tic_totalTime
return data, meta
cformats = ['csv', 'binary'] # client formats
if not opts['format'] in cformats:
# Check if requested format is implemented by this client.
error('This client does not handle transport '
'format "%s". Available options: %s'
% (opts['format'], ', '.join(cformats)))
# See if server supports binary
if opts['format'] != 'csv':
log('Reading %s' % (SERVER + '/capabilities'), opts)
res = urlopen(SERVER + '/capabilities')
caps = jsonparse(res, SERVER + '/capabilities')
sformats = caps["outputFormats"] # Server formats
if 'format' in kwargs and not kwargs['format'] in sformats:
warning("hapi", 'Requested transport format "%s" not avaiable '
'from %s. Will use "csv". Available options: %s'
% (opts['format'], SERVER, ', '.join(sformats)))
opts['format'] = 'csv'
if not 'binary' in sformats:
opts['format'] = 'csv'
dt, cols, psizes, pnames, missing_length = compute_dt(meta, opts)
# length attribute required for all parameters when serving binary but
# is only required for time parameter when serving CSV. This catches
# case where server provides binary but is missing a length attribute
# in one or more string parameters that were requested. In this case,
# there is not enough information to parse binary.
if opts['format'] == 'binary' and missing_length:
warnings.warn('Requesting CSV instead of binary because of problem with server metadata.')
opts['format'] == 'csv'
# Read the data. toc0 is time to download to file or into buffer;
# toc is time to parse.
if opts['format'] == 'binary':
# HAPI Binary
if opts["cache"]:
log('Writing %s to %s' % (urlbin, fnamebin.replace(urld + '/', '')), opts)
tic0 = time.time()
urlretrieve(urlbin, fnamebin)
toc0 = time.time() - tic0
log('Reading and parsing %s' % fnamebin.replace(urld + '/', ''), opts)
tic = time.time()
data = np.fromfile(fnamebin, dtype=dt)
else:
from io import BytesIO
log('Writing %s to buffer' % urlbin.replace(urld + '/', ''), opts)
tic0 = time.time()
buff = BytesIO(urlopen(urlbin).read())
toc0 = time.time() - tic0
log('Parsing BytesIO buffer.', opts)
tic = time.time()
data = np.frombuffer(buff.read(), dtype=dt)
else:
# HAPI CSV
if opts["cache"]:
log('Writing %s to %s' % (urlcsv, fnamecsv.replace(urld + '/', '')), opts)
tic0 = time.time()
urlretrieve(urlcsv, fnamecsv)
toc0 = time.time() - tic0
log('Reading and parsing %s' % fnamecsv.replace(urld + '/', ''), opts)
tic = time.time()
else:
from io import StringIO
log('Writing %s to buffer' % urlcsv.replace(urld + '/', ''), opts)
tic0 = time.time()
fnamecsv = StringIO(urlopen(urlcsv).read().decode())
toc0 = time.time() - tic0
log('Parsing StringIO buffer.', opts)
tic = time.time()
if not missing_length:
# All string and isotime parameters have a length in metadata.
if opts['method'] == 'numpy':
data = np.genfromtxt(fnamecsv, dtype=dt, delimiter=',')
if opts['method'] == 'pandas':
# Read file into Pandas DataFrame
df = pandas.read_csv(fnamecsv, sep=',', header=None)
# Allocate output N-D array (It is not possible to pass dtype=dt
# as computed to pandas.read_csv; pandas dtype is different
# from numpy's dtype.)
data = np.ndarray(shape=(len(df)), dtype=dt)
# Insert data from dataframe 'df' columns into N-D array 'data'
for i in range(0, len(pnames)):
shape = np.append(len(data), psizes[i])
# In numpy 1.8.2 and Python 2.7, this throws an error
# for no apparent reason. Works as expected in numpy 1.10.4
data[pnames[i]] = np.squeeze(
np.reshape(df.values[:, np.arange(cols[i][0], cols[i][1] + 1)], shape))
else:
data = parse_missing_length(fnamecsv, dt, cols, psizes, pnames, opts)
toc = time.time() - tic
# Extra metadata associated with request will be saved in
# a pkl file with same base name as npy data file.
meta.update({"x_server": SERVER})
meta.update({"x_dataset": DATASET})
meta.update({"x_parameters": PARAMETERS})
meta.update({"x_time.min": START})
meta.update({"x_time.max": STOP})
meta.update({"x_requestDate": datetime.now().isoformat()[0:19]})
meta.update({"x_cacheDir": urld})
meta.update({"x_downloadTime": toc0})
meta.update({"x_readTime": toc})
meta.update({"x_metaFileParsed": fnamepkl})
meta.update({"x_dataFileParsed": fnamenpy})
meta.update({"x_metaFile": fnamejson})
if opts['format'] == 'binary':
meta.update({"x_dataFile": fnamebin})
else:
meta.update({"x_dataFile": fnamecsv})
# Create cache directory
# Note that this should only technically be
# written if cache=True.
if not os.path.exists(opts["cachedir"]):
os.makedirs(opts["cachedir"])
if not os.path.exists(urld):
os.makedirs(urld)
# Write metadata to cache
# Note that this should only technically be
# written if cache=True.
log('Writing %s' % fnamepklx, opts)
f = open(fnamepklx, 'wb')
pickle.dump(meta, f, protocol=2)
f.close()
if opts["cache"]:
log('Writing %s' % fnamenpy, opts)
np.save(fnamenpy, data)
meta['x_totalTime'] = time.time() - tic_totalTime
return data, meta
def compute_dt(meta, opts):
# Compute data type variable dt used to read HAPI response into
# a data structure.
pnames, psizes, dt = [], [], []
# Each element of cols is an array with start/end column number of
# parameter.
cols = np.zeros([len(meta["parameters"]), 2], dtype=np.int32)
ss = 0 # running sum of prod(size)
# missing_length = True will be set if HAPI String or ISOTime
# parameter has no length attribute in metadata (length attribute is
# required for both in binary but only for primary time column in CSV).
# When missing_length=True the CSV read gets more complicated.
missing_length = False
# Extract sizes and types of parameters.
for i in range(0, len(meta["parameters"])):
ptype = str(meta["parameters"][i]["type"])
pnames.append(str(meta["parameters"][i]["name"]))
if 'size' in meta["parameters"][i]:
psizes.append(meta["parameters"][i]['size'])
else:
psizes.append(1)
# For size = [N] case, readers want
# dtype = ('name', type, N)
# not
# dtype = ('name', type, [N])
if type(psizes[i]) is list and len(psizes[i]) == 1:
psizes[i] = psizes[i][0]
if type(psizes[i]) is list and len(psizes[i]) > 1:
# psizes[i] = list(reversed(psizes[i]))
psizes[i] = list(psizes[i])
# First column of ith parameter.
cols[i][0] = ss
# Last column of ith parameter.
cols[i][1] = ss + np.prod(psizes[i]) - 1
# Running sum of columns.
ss = cols[i][1] + 1
# HAPI numerical formats are 64-bit LE floating point and 32-bit LE
# signed integers.
if ptype == 'double':
dtype = (pnames[i], '<d', psizes[i])
if ptype == 'integer':
dtype = (pnames[i], np.dtype('<i4'), psizes[i])
if ptype == 'string' or ptype == 'isotime':
if 'length' in meta["parameters"][i]:
# length is specified for parameter in metadata. Use it.
if ptype == 'string' or 'isotime':
dtype = (pnames[i], 'S' + str(meta["parameters"][i]["length"]), psizes[i])
else:
# A string or isotime parameter did not have a length.
# Will need to use slower CSV read method.
missing_length = True
if ptype == 'string' or ptype == 'isotime':
dtype = (pnames[i], object, psizes[i])
# For testing reader. Force use of slow read method.
if opts['format'] == 'csv':
if opts['method'] == 'numpynolength' or opts['method'] == 'pandasnolength':
missing_length = True
if ptype == 'string' or ptype == 'isotime':
dtype = (pnames[i], object, psizes[i])
# https://numpy.org/doc/stable/release/1.17.0-notes.html#shape-1-fields-in-dtypes-won-t-be-collapsed-to-scalars-in-a-future-version
if dtype[2] == 1:
dtype = dtype[0:2]
dt.append(dtype)
return dt, cols, psizes, pnames, missing_length
def parse_missing_length(fnamecsv, dt, cols, psizes, pnames, opts):
# At least one requested string or isotime parameter does not
# have a length in metadata. More work to do to read.
if opts['method'] == 'numpy' or opts['method'] == 'numpynolength':
# If requested method was numpy, use numpynolength method.
# With dtype='None', the data type is determined automatically
table = np.genfromtxt(fnamecsv, dtype=None, delimiter=',',
encoding='utf-8')
# table is a 1-D array. Each element is a row in the file.
# - If the data types are not the same for each column,
# the elements are tuples with length equal to the number
# of columns.
# - If the data types are the same for each column, which
# will happen if only Time is requested or Time and
# a string or isotime parameter is requested, then table
# has rows that are 1-D numpy arrays.
# Contents of 'table' will be placed into N-D array 'data'.
data = np.ndarray(shape=(len(table)), dtype=dt)
# Insert data from 'table' into N-D array 'data'
if table.dtype.names is None:
if len(pnames) == 1:
# Only time parameter requested.
data[pnames[0]] = table[:]
else:
# All columns in 'table' have the same data type
# so table is a 2-D numpy matrix
for i in range(0, len(pnames)):
shape = np.append(len(data), psizes[i])
data[pnames[i]] = np.squeeze(
np.reshape(table[:, np.arange(cols[i][0], cols[i][1] + 1)], shape))
else:
# Table is not a 2-D numpy matrix.
# Extract each column (don't know how to do this with slicing
# notation, e.g., data['varname'] = table[:][1:3]). Instead,
# loop over each parameter (pn) and aggregate columns.
# Then insert aggregated columns into N-D array 'data'.
for pn in range(0, len(cols)):
shape = np.append(len(data), psizes[pn])
for c in range(cols[pn][0], cols[pn][1] + 1):
if c == cols[pn][0]: # New parameter
tmp = table[table.dtype.names[c]]
else: # Aggregate
tmp = np.vstack((tmp, table[table.dtype.names[c]]))
tmp = np.squeeze(np.reshape(np.transpose(tmp), shape))
data[pnames[pn]] = tmp
if opts['method'] == 'pandas' or opts['method'] == 'pandasnolength':
# If requested method was pandas, use pandasnolength method.
# Read file into Pandas DataFrame
df = pandas.read_csv(fnamecsv, sep=',', header=None)
# Allocate output N-D array (It is not possible to pass dtype=dt
# as computed to pandas.read_csv, so need to create new ND array.)
data = np.ndarray(shape=(len(df)), dtype=dt)
# Insert data from dataframe into N-D array
for i in range(0, len(pnames)):
shape = np.append(len(data), psizes[i])
# In numpy 1.8.2 and Python 2.7, this throws an error for no apparent reason.
# Works as expected in numpy 1.10.4
data[pnames[i]] = np.squeeze(
np.reshape(df.values[:, np.arange(cols[i][0], cols[i][1] + 1)], shape))
# Any of the string parameters that do not have an associated
# length in the metadata will have dtype='O' (object).
# These parameters must be converted to have a dtype='SN', where
# N is the maximum string length. N is determined automatically
# when using astype('<S') (astype uses largest N needed).
dt2 = [] # Will have dtypes with strings lengths calculated.
for i in range(0, len(pnames)):
if data[pnames[i]].dtype == 'O':
dtype = (pnames[i], str(data[pnames[i]].astype('<S').dtype), psizes[i])
else:
dtype = dt[i]
# https://numpy.org/doc/stable/release/1.17.0-notes.html#shape-1-fields-in-dtypes-won-t-be-collapsed-to-scalars-in-a-future-version
if len(dtype) > 2 and dtype[2] == 1:
dtype = dtype[0:2]
dt2.append(dtype)
# Create new N-D array that won't have any parameters with
# type = 'O'.
data2 = np.ndarray(data.shape, dt2)
for i in range(0, len(pnames)):
if data[pnames[i]].dtype == 'O':
data2[pnames[i]] = data[pnames[i]].astype(dt2[i][1])
else:
data2[pnames[i]] = data[pnames[i]]
# Save memory by not copying (does this help?)
# data2[pnames[i]] = np.array(data[pnames[i]],copy=False)
return data2 | 41.043991 | 139 | 0.54814 |
127ce0580644358b077d82cee5c49c5760fd5871 | 383 | py | Python | tally/conf/settings/development.py | Mapkin/tally | 731940362c4c6003eed7f576620a89206fda312d | [
"MIT"
] | 1 | 2022-02-14T05:52:20.000Z | 2022-02-14T05:52:20.000Z | tally/conf/settings/development.py | Mapkin/tally | 731940362c4c6003eed7f576620a89206fda312d | [
"MIT"
] | null | null | null | tally/conf/settings/development.py | Mapkin/tally | 731940362c4c6003eed7f576620a89206fda312d | [
"MIT"
] | null | null | null | #!/usr/bin/env python
#
# Created by John Watson on 2012-10-10.
# Copyright (c) 2012 Eightyone Labs, Inc. All rights reserved.
#
from tally.conf.settings.default import *
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'tally',
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
}
| 18.238095 | 62 | 0.550914 |
16600c67414e5f3529292e5894d733215a892c81 | 1,879 | py | Python | apps/books/models.py | vuonghv/brs | 9cdf9431ac69fd7a33d8bf4240a7d49a49ae4a80 | [
"MIT"
] | 1 | 2021-01-13T23:42:54.000Z | 2021-01-13T23:42:54.000Z | apps/books/models.py | vuonghv/brs | 9cdf9431ac69fd7a33d8bf4240a7d49a49ae4a80 | [
"MIT"
] | 1 | 2015-10-09T06:19:29.000Z | 2015-10-09T06:19:29.000Z | apps/books/models.py | vuonghv/brs | 9cdf9431ac69fd7a33d8bf4240a7d49a49ae4a80 | [
"MIT"
] | 8 | 2015-10-09T02:00:34.000Z | 2016-07-08T15:00:37.000Z | from django.db import models
from django.conf import settings
from apps.categories.models import Category
from apps.users.models import UserProfile
from apps.reviews.models import Review
class Book(models.Model):
title = models.CharField(max_length=255)
slug = models.SlugField(max_length=500)
author = models.CharField(max_length=255)
pages = models.IntegerField()
publish_date = models.DateTimeField()
description = models.TextField(blank=True, default='')
categories = models.ManyToManyField(Category, db_table='category_book', related_name='books')
favourites = models.ManyToManyField(UserProfile, db_table='favourites', related_name='liked_books')
user_profile = models.ManyToManyField(UserProfile, through='UserProfileBook', related_name='book')
cover = models.ImageField(upload_to=settings.BOOK_DIR, max_length=255, default='', blank=False)
price = models.FloatField(null=False, blank=False, default=0.0)
class Meta:
db_table = 'book'
def delete(self, using=None):
super().delete(using)
if self.cover:
self.cover.delete()
def get_rating(self):
reviews = Review.objects.filter(book=self)
total = reviews.count()
if total == 0:
return 0
rating = 0
for review in reviews:
rating += review.rating
return round(rating / total)
def get_cover_url(self):
if self.cover:
return self.cover.url
return ''
class UserProfileBook(models.Model):
READING = 1
READ = 2
READING_STATUS = (
(READING, 'Reading'),
(READ, 'Read'),
)
user_profile = models.ForeignKey(UserProfile)
book = models.ForeignKey(Book)
status = models.IntegerField(choices=READING_STATUS, default=READING)
class Meta:
db_table = 'user_book'
| 31.316667 | 103 | 0.668973 |
440a75cb7ec0c51d8e45e66ff5c7fc940ba9ed63 | 3,119 | py | Python | last few python scripts/p_risk_varying_isotropy.py | pm2111/Heart-Defibrillation-Project | 48ea3570c360aac7c3ff46354891998f4f364fab | [
"MIT"
] | null | null | null | last few python scripts/p_risk_varying_isotropy.py | pm2111/Heart-Defibrillation-Project | 48ea3570c360aac7c3ff46354891998f4f364fab | [
"MIT"
] | null | null | null | last few python scripts/p_risk_varying_isotropy.py | pm2111/Heart-Defibrillation-Project | 48ea3570c360aac7c3ff46354891998f4f364fab | [
"MIT"
] | null | null | null | import matplotlib.pylab as plt
import numpy as np
import os
#os.chdir("/Users/petermarinov/msci project/intermittent /50 hearts 10^5 nr excited 10^3 restitution 0.333 ")
path = []
path.append( "/Users/petermarinov/msci project/all code/50 hearts preferential/50 hearts anis 0.5 corr 0.2/50 hearts 0.333 restitution")
path.append( "/Users/petermarinov/msci project/all code/50 hearts preferential/50 hearts anis 0.5 corr 0.5/50 hearts 0.333 restitution")
path.append( "/Users/petermarinov/msci project/all code/50 hearts preferential/50 hearts anis -0.5 corr 0.99/50 hearts 0.333 restitution")
path.append( "/Users/petermarinov/msci project/all code/50 hearts preferential/50 hearts anis 0.2 corr 0.99/50 hearts 0.333 restitution")
path.append( "/Users/petermarinov/msci project/all code/50 hearts preferential/50 hearts anis 0.5 corr 0.99/50 hearts 0.333 restitution")
path.append( "/Users/petermarinov/msci project/all code/50 hearts preferential/50 hearts anis 0.99 corr 0.99/50 hearts 0.333 restitution")
previous_fib = np.genfromtxt("/Users/petermarinov/msci project/all code/intermittent /paroxysmal.txt") #1 for christensen, 2 for 1d corr
lab = ["anis = 0.5 corr = 0.2","anis = 0.5 corr = 0.5","anis = -0.5 corr = 0.99","anis = 0.2 corr = 0.99","anis = 0.5 corr = 0.99","anis = 0.99 corr = 0.99"]
k=0
paroxysmal = np.zeros((6,8))
for z in path:
filenames = []
for f in os.listdir(z):
if f.endswith(".txt"):
filenames.append('/' +f )
L = 200 #system size
j=0
for x in filenames:
data = np.genfromtxt(z + x)
size = np.shape(data)
paroxysmal_count=0
counter=False
for i in range (0,size[0]):
if counter and (data[i]>1.5*L)==False:
paroxysmal[k][j] +=1
if (data[i]>1.5*L):
counter=True
else:
counter=False
j+=1
if j==8: #iterate through 8 nus
j=0
k+=1
nus = []
nus.append(np.linspace(0.10,0.38,8))
nus.append(np.linspace(0.20,0.48,8))
nus.append(np.linspace(0.40,0.68,8))
nus.append(np.linspace(0.40,0.68,8))
nus.append(np.linspace(0.40,0.68,8))
nus.append(np.linspace(0.60,0.88,8))
previous_fib = np.genfromtxt("/Users/petermarinov/msci project/all code/intermittent /paroxysmal.txt")
preferential = [196,214,250,564,734,149,31,0,0,0,0,0]
nu_pref = np.linspace(0.15,0.7,12)
plt.figure()
for i in range (0,6):
plt.plot(nus[i],paroxysmal[i], label = lab[i], linewidth =2)
#plt.plot(previous_fib[:,0],previous_fib[:,1], label = "Christensen et al.'s Original Model")
#plt.plot(nu_pref,preferential, label = "preferential attachment structure F=10", linewidth = 2 )
#plt.plot(previous_fib[:,0],previous_fib[:,1], label = "Christensen et al.'s orignal model", linewidth = 2 )
#plt.plot(previous_fib[:,2],previous_fib[:,3], label = "Moderate APD", linewidth = 2 )
plt.xlabel(r"$\nu$", fontsize=18)
plt.ylabel("intermittent fibrillation count", fontsize=18)
plt.title( "Intermittent AF comparison between models for 50 randomly seeded hearts" ,fontsize=12)
plt.legend()
plt.grid()
plt.show()
| 44.557143 | 157 | 0.67201 |
644e046954dc07ab51726b3dd54062445d8767a0 | 3,405 | py | Python | huaweicloud-sdk-iotda/huaweicloudsdkiotda/v5/model/show_routing_rule_request.py | githubmilesma/huaweicloud-sdk-python-v3 | 9d9449ed68a609ca65f0aa50b5b2a1c28445bf03 | [
"Apache-2.0"
] | 1 | 2021-04-16T07:59:28.000Z | 2021-04-16T07:59:28.000Z | huaweicloud-sdk-iotda/huaweicloudsdkiotda/v5/model/show_routing_rule_request.py | Lencof/huaweicloud-sdk-python-v3 | d13dc4e2830a83e295be6e4de021999b3376e34e | [
"Apache-2.0"
] | null | null | null | huaweicloud-sdk-iotda/huaweicloudsdkiotda/v5/model/show_routing_rule_request.py | Lencof/huaweicloud-sdk-python-v3 | d13dc4e2830a83e295be6e4de021999b3376e34e | [
"Apache-2.0"
] | 1 | 2022-01-17T02:24:18.000Z | 2022-01-17T02:24:18.000Z | # coding: utf-8
import pprint
import re
import six
class ShowRoutingRuleRequest:
"""
Attributes:
openapi_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.
"""
sensitive_list = []
openapi_types = {
'instance_id': 'str',
'rule_id': 'str'
}
attribute_map = {
'instance_id': 'Instance-Id',
'rule_id': 'rule_id'
}
def __init__(self, instance_id=None, rule_id=None):
"""ShowRoutingRuleRequest - a model defined in huaweicloud sdk"""
self._instance_id = None
self._rule_id = None
self.discriminator = None
if instance_id is not None:
self.instance_id = instance_id
self.rule_id = rule_id
@property
def instance_id(self):
"""Gets the instance_id of this ShowRoutingRuleRequest.
:return: The instance_id of this ShowRoutingRuleRequest.
:rtype: str
"""
return self._instance_id
@instance_id.setter
def instance_id(self, instance_id):
"""Sets the instance_id of this ShowRoutingRuleRequest.
:param instance_id: The instance_id of this ShowRoutingRuleRequest.
:type: str
"""
self._instance_id = instance_id
@property
def rule_id(self):
"""Gets the rule_id of this ShowRoutingRuleRequest.
:return: The rule_id of this ShowRoutingRuleRequest.
:rtype: str
"""
return self._rule_id
@rule_id.setter
def rule_id(self, rule_id):
"""Sets the rule_id of this ShowRoutingRuleRequest.
:param rule_id: The rule_id of this ShowRoutingRuleRequest.
:type: str
"""
self._rule_id = rule_id
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.openapi_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:
if attr in self.sensitive_list:
result[attr] = "****"
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, ShowRoutingRuleRequest):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""Returns true if both objects are not equal"""
return not self == other
| 25.601504 | 75 | 0.555947 |
2e9efe20edb5014b3d4520cccda14bfa1208061a | 12,414 | py | Python | tl.py | theWAM/timelib | 4aa96f39a292d5b219d9953823ffb00f85701627 | [
"MIT"
] | 1 | 2019-09-17T22:20:43.000Z | 2019-09-17T22:20:43.000Z | tl.py | theWAM/timelib | 4aa96f39a292d5b219d9953823ffb00f85701627 | [
"MIT"
] | null | null | null | tl.py | theWAM/timelib | 4aa96f39a292d5b219d9953823ffb00f85701627 | [
"MIT"
] | null | null | null | # timelibWAM Functions 12.26.18 =
# © Woody Allen Montilus 2018 =
# =
# ========================================================================
import sys
import email
import smtplib
import imaplib
import time as t
import tkinter as tk
from timelibWAM import tx
from tkinter import ttk
from pathlib import Path
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
# = Best Setup ======================
# Copy and paste this bad boy:
#
# from timelibWAM import *
#
# try:
# s = tl.start()
#
# *your code*
#
# tl.send_frame_end()
#
# except Exception as e:
# tl.error_alert()
#
# ===================================
# = start() =========================
# ===================================
# Begins run timer
#
# After importing timelibWAM, use this function to start the timer
# save the time returned in a variable, like s:
#
# s = tl.start()
#
# You'll use that variable later!
# ===================================
def start():
start = t.time()
return start
# = print_end() =====================
# ===================================
# Ends run timer
#
# If you don't want any pop ups or texts, you can print
# the run time using this function:
#
# tl.print_end(s)
# ^
# |
# the variable from start()
# ===================================
def print_end(start):
# Logs end time
end = t.time()
# Calculates difference aka run time
diff = end - start
print()
print("Execution Time: "+ str(diff))
# Returns value calculated
return diff
# = frame_end(start) ================
# ===================================
# Ends run timer
#
# Use if you just want a popup to let you know the run time
#
# tl.frame_end(s)
# ^
# |
# the variable from start()
# ===================================
def frame_end(start):
# Runs print_end and extracts run time difference
diff = print_end(start)
# Draws frame detailing run time
popup = tk.Tk()
popup.title("Program Completed")
ttk.Label(popup, text = "Hey! " + str(Path(sys.argv[0]).name) + " is done.\n\n Execution Time: " + str(diff), font = "System 16 bold").grid()
# Draws buttons OK and Destroy Everything
btn_frame = ttk.Frame(popup)
btn_frame.grid()
# OK destroys popup frame
ttk.Button(btn_frame, text = "OK", command = popup.destroy).grid(row=0, column=0)
#Destroy Everything shuts down entire program
ttk.Button(btn_frame, text = "Destroy Everything", command = quit).grid(row=0, column=1)
# = send_end(start) =================
# ===================================
# Ends run timer
#
# Use if you just want a text
#
# tl.send_end(s)
# ^
# |
# the variable from start()
# ===================================
def send_end(start):
# Logs into gmail using provided email/password
addy = "runtimeemail@gmail.com"
pwd = "f=yq9rp}t$`47T@2YPv5tTj;`8H/'$:#eRTvrbK,syWL8RzfH@r=w<"
s = smtplib.SMTP(host = "smtp.gmail.com", port = 587)
s.starttls()
s.login(addy, pwd)
# Logs end time and returns run time
diff = print_end(start)
# Reads document created by mail_ready and sends message to contact given
f = open("timelibContactDoc.txt","r")
contact = f.read()
message = "............................\n Hey! \n"
message = message + str(Path(sys.argv[0]).name)
message = message + " is done.\n\n Execution Time: " + str(diff) + " seconds"
msg = MIMEMultipart()
msg['From'] = addy
msg['To'] = contact
msg.attach(MIMEText(message, 'plain'))
s.send_message(msg)
return diff
# = send_frame_end(start) ===========
# ===================================
# Ends run timer
#
# Use if you want a popup and a text
#
# tl.send_frame_end(s)
# ^
# |
# the variable from start() ---
#
# ===================================
def send_frame_end(start):
diff = send_end(start)
# Draws frame detailing run time
popup = tk.Tk()
popup.title("Program Completed")
ttk.Label(popup, text = "Hey! " + str(Path(sys.argv[0]).name) + " is done!\n\n Execution Time: " + str(diff), font = "System 16 bold").grid()
# Draws buttons OK and Destroy Everything
btn_frame = ttk.Frame(popup)
btn_frame.grid()
# OK destroys popup frame
ttk.Button(btn_frame, text = "OK", command = popup.destroy).grid(row=0, column=0)
#Destroy Everything shuts down entire program
ttk.Button(btn_frame, text = "Destroy Everything", command = quit).grid(row=0, column=1)
# = frame_alert() ===================
# ===================================
# Alerts user
#
# Use if you just want a popup error message
#
# try:
# s = tl.start()
#
# your code
#
# tl.one_of_our_ending_functions()
#
# except Exception as e: <--------
# tl.frame_alert() |
# |
# Screens for any errors types ---
#
# ===================================
def frame_alert():
# Draws frame detailing run time
popup = tk.Tk()
popup.title("Program Completed")
ttk.Label(popup, text = "Hey! \n One or more errors were found in " + str(Path(sys.argv[0]).name), font = "System 16 bold").grid()
# Draws buttons OK and Destroy Everything
btn_frame = ttk.Frame(popup)
btn_frame.grid()
# OK destroys popup frame
ttk.Button(btn_frame, text = "I'll check it out", command = popup.destroy).grid(row=0, column=0)
#Destroy Everything shuts down entire program
ttk.Button(btn_frame, text = "Destroy Everything", command = quit).grid(row=0, column=1)
# = error_alert() ===================
# ===================================
# Alerts user
#
# Use if you want a popup and text for errors
#
# try:
# s = tl.start()
#
# your code
#
# tl.one_of_our_ending_functions()
#
# except Exception as e: <--------
# tl.error_alert() |
# |
# Screens for any errors types ---
#
# ===================================
def error_alert():
# Logs into gmail using provided email/password
addy = "runtimeemail@gmail.com"
pwd = "f=yq9rp}t$`47T@2YPv5tTj;`8H/'$:#eRTvrbK,syWL8RzfH@r=w<"
s = smtplib.SMTP(host = "smtp.gmail.com", port = 587)
s.starttls()
s.login(addy, pwd)
# Reads document created by mail_ready and sends message to contact given
f = open("timelibContactDoc.txt","r")
contact = f.read()
message = "............................\n Hey! \n"
message = message + "One or more errors were found in " + str(Path(sys.argv[0]).name)
msg = MIMEMultipart()
msg['From'] = addy
msg['To'] = contact
msg.attach(MIMEText(message, 'plain'))
s.send_message(msg)
frame_alert()
# Module specific functions ==============================
# ========================================================
# Draws Provider List popup
def pvd_lst():
ATT = "@txt.att.net"
TMOBILE = "@tmomail.net"
VERIZON ="@vtext.com"
SPRINT = "@messaging.sprintpcs.com"
VGMOBILE = "@vmobl.com"
METROPCS = "@mymetropcs.com"
pop = tk.Tk()
pop.title("Provider List")
ttk.Label(pop, text = "Provider List", font = "System 14 bold").grid(padx = 10, pady = 10)
ttk.Label(pop, text = "Copy recipient provider and paste after their #").grid(padx = 10, pady = 10)
labels_frame = ttk.Frame(pop)
labels_frame.grid(padx = 10, pady = 10)
ttk.Label(labels_frame, text = "AT&T:").grid(row = 0, column = 0, padx= 10)
ttk.Label(labels_frame, text = "T-Mobile:").grid(row = 1, column = 0, padx= 10)
ttk.Label(labels_frame, text = "Verizon:").grid(row = 2, column = 0, padx= 10)
ttk.Label(labels_frame, text = "Sprint:").grid(row = 3, column = 0, padx= 10)
ttk.Label(labels_frame, text = "Virgin Mobile:").grid(row = 4, column = 0, padx= 10)
ttk.Label(labels_frame, text = "MetroPCS:").grid(row = 5, column = 0, padx= 10)
ttk.Label(labels_frame, text = ATT).grid(row = 0, column = 1)
ttk.Label(labels_frame, text = TMOBILE).grid(row = 1, column = 1)
ttk.Label(labels_frame, text = VERIZON).grid(row = 2, column = 1)
ttk.Label(labels_frame, text = SPRINT).grid(row = 3, column = 1)
ttk.Label(labels_frame, text = VGMOBILE).grid(row = 4, column = 1)
ttk.Label(labels_frame, text = METROPCS).grid(row = 5, column = 1)
ttk.Button(pop, text = "OK", command = pop.destroy).grid()
pop.mainloop()
# Draws Error popup
def error():
error = tk.Tk()
error.title("ERROR")
er_frame = ttk.Frame(error)
er_frame.grid(padx=20, pady=10)
popup.geometry("+450+250")
label = ttk.Label(pop_frame, text = "Uh oh! Something went wrong! Try again!")
label.grid()
b1_frame = ttk.Frame(pop_frame)
b1_frame.grid(pady = 10)
b1 = ttk.Button(pop_frame, text = "OK", default = "active", command = popup.destroy)
b1.grid()
def doc_bool():
try:
f = open("timelibContactDoc.txt","r")
return True
except FileNotFoundError:
return False
# Destroy's frame
def click_cancel():
print("User pressed cancel")
self.destroy()
quit()
# When enter is pressed, mail_ready from timelibex is run
def send_request(event):
print("Making send request...")
try:
# Signs into email using mail_ready function from timelibex
tx.mail_ready(e_to.get())
except Exception as e:
error()
print("...Request completed")
# Closes window after info is gathered
self.destroy()
# ========================================================
# ========================================================
# If the contact document has yet to be created,
# draw entry frame to accept it
if doc_bool() == False:
# Draws info gathering frame =====================================================================
self = tk.Tk()
self.grid()
self.geometry("+250+150")
self.title("TextEm!")
spacer_frame = ttk.Frame(self)
spacer_frame.grid(pady=10)
# Space for the entirety of the frame
body_frame = ttk.Frame(self)
body_frame.grid(padx=20, pady=10)
# Space for header material
header_div = ttk.Frame(body_frame)
header_div.grid()
# Draws labels in header
ttk.Label(header_div, text = "RunTimeText (Gmail supported only)", font = "System 16 bold").grid()
ttk.Label(header_div, text = "Enter phone#@provideraddress (i.e. 1234567890@txt.att.net)").grid()
ttk.Label(header_div, text = "Click Provider List for provider specific addresses").grid()
# Space for upcoming label and entry slot
to_div = ttk.Frame(body_frame)
to_div.grid()
# Draws label
ttk.Label(to_div, text = "Your # address:").grid(row = 3, column = 0, padx = 10, pady = 15)
#Entry space - pressing enter runs mail_ready from timelibex
e_to = ttk.Entry(to_div)
e_to.grid(row = 3, column = 1, padx = 10, pady = 15)
e_to.bind("<Return>", send_request)
# Space for upcoming button
btns = ttk.Frame(body_frame)
btns.grid(padx=10, pady=10)
# Draws Provider List button
ttk.Button(btns, text = "Provider List", command = pvd_lst).grid()
# Cancel button and Exit button run click_cancel function
self.protocol("WM_DELETE_WINDOW", click_cancel)
ttk.Button(btns, text = "Cancel", command = click_cancel).grid()
#==================================================================================================
# Else, if contact document exists, just run user program
else:
print("Information needed is already in system") | 30.727723 | 146 | 0.527308 |
c4b046890b376744de58e9310878bfd2e08618fb | 1,760 | py | Python | tests/test_bot_support.py | lukasz00500/instabot | 542a35d5ef510183999e5aa825d2f1a0b113a0f1 | [
"Apache-2.0"
] | 4 | 2019-08-17T01:27:20.000Z | 2020-01-08T12:01:34.000Z | tests/test_bot_support.py | lukasz00500/instabot | 542a35d5ef510183999e5aa825d2f1a0b113a0f1 | [
"Apache-2.0"
] | 4 | 2019-02-25T08:48:07.000Z | 2019-03-07T17:06:15.000Z | tests/test_bot_support.py | lukasz00500/instabot | 542a35d5ef510183999e5aa825d2f1a0b113a0f1 | [
"Apache-2.0"
] | 5 | 2019-04-10T04:53:14.000Z | 2020-05-17T09:10:06.000Z | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
import os
import sys
import pytest
from .test_bot import TestBot
class TestBotSupport(TestBot):
@pytest.mark.parametrize('url,result', [
('https://google.com', ['https://google.com']),
('google.com', ['google.com']),
('google.com/search?q=instabot', ['google.com/search?q=instabot']),
('https://google.com/search?q=instabot', ['https://google.com/search?q=instabot']),
('мвд.рф', ['мвд.рф']),
('https://мвд.рф', ['https://мвд.рф']),
('http://мвд.рф/news/', ['http://мвд.рф/news/']),
('hello, google.com/search?q=test and bing.com', ['google.com/search?q=test', 'bing.com']),
])
def test_extract_urls(self, url, result):
assert self.bot.extract_urls(url) == result
def test_check_if_file_exist(self):
test_file = open('test', 'w')
assert self.bot.check_if_file_exists('test')
test_file.close()
os.remove('test')
def test_check_if_file_exist_fail(self):
assert not self.bot.check_if_file_exists('test')
@pytest.mark.parametrize('verbosity,text,result', [
(True, 'test', 'test'),
(False, 'test', '')
])
def test_console_print(self, verbosity, text, result):
self.bot.verbosity = verbosity
try:
if sys.version_info > (3,):
from io import StringIO
else:
from StringIO import StringIO
saved_stdout = sys.stdout
out = StringIO()
sys.stdout = out
self.bot.console_print(text)
output = out.getvalue().strip()
assert output == result
finally:
sys.stdout = saved_stdout
| 29.830508 | 99 | 0.578409 |
b3ad8a149e22778f22bb9baea5230323d6de948f | 12,254 | py | Python | flexget/plugins/input/discover.py | metaMMA/Flexget | a38986422461d7935ead1e2b4ed4c88bcd0a90f5 | [
"MIT"
] | null | null | null | flexget/plugins/input/discover.py | metaMMA/Flexget | a38986422461d7935ead1e2b4ed4c88bcd0a90f5 | [
"MIT"
] | 1 | 2017-10-09T23:06:44.000Z | 2017-10-09T23:06:44.000Z | flexget/plugins/input/discover.py | metaMMA/Flexget | a38986422461d7935ead1e2b4ed4c88bcd0a90f5 | [
"MIT"
] | null | null | null | from __future__ import unicode_literals, division, absolute_import
from builtins import * # noqa pylint: disable=unused-import, redefined-builtin
import datetime
import logging
import random
from sqlalchemy import Column, Integer, DateTime, Unicode, Index
from flexget import options, plugin
from flexget import db_schema
from flexget.event import event
from flexget.manager import Session
from flexget.utils.tools import parse_timedelta, multiply_timedelta, aggregate_inputs
log = logging.getLogger('discover')
Base = db_schema.versioned_base('discover', 0)
class DiscoverEntry(Base):
__tablename__ = 'discover_entry'
id = Column(Integer, primary_key=True)
title = Column(Unicode, index=True)
task = Column(Unicode, index=True)
last_execution = Column(DateTime)
def __init__(self, title, task):
self.title = title
self.task = task
self.last_execution = None
def __str__(self):
return '<DiscoverEntry(title=%s,task=%s,added=%s)>' % (
self.title,
self.task,
self.last_execution,
)
Index('ix_discover_entry_title_task', DiscoverEntry.title, DiscoverEntry.task)
@event('manager.db_cleanup')
def db_cleanup(manager, session):
value = datetime.datetime.now() - parse_timedelta('7 days')
for discover_entry in (
session.query(DiscoverEntry).filter(DiscoverEntry.last_execution <= value).all()
):
log.debug('deleting %s', discover_entry)
session.delete(discover_entry)
class Discover(object):
"""
Discover content based on other inputs material.
Example::
discover:
what:
- next_series_episodes: yes
from:
- piratebay
interval: [1 hours|days|weeks]
release_estimations: [strict|loose|ignore]
"""
schema = {
'type': 'object',
'properties': {
'what': {
'type': 'array',
'items': {
'allOf': [
{'$ref': '/schema/plugins?phase=input'},
{'maxProperties': 1, 'minProperties': 1},
]
},
},
'from': {
'type': 'array',
'items': {
'allOf': [
{'$ref': '/schema/plugins?interface=search'},
{'maxProperties': 1, 'minProperties': 1},
]
},
},
'interval': {'type': 'string', 'format': 'interval', 'default': '5 hours'},
'release_estimations': {
'oneOf': [
{'type': 'string', 'default': 'strict', 'enum': ['loose', 'strict', 'ignore']},
{
'type': 'object',
'properties': {'optimistic': {'type': 'string', 'format': 'interval'}},
'required': ['optimistic'],
},
]
},
'limit': {'type': 'integer', 'minimum': 1},
},
'required': ['what', 'from'],
'additionalProperties': False,
}
def execute_searches(self, config, entries, task):
"""
:param config: Discover plugin config
:param entries: List of pseudo entries to search
:param task: Task being run
:return: List of entries found from search engines listed under `from` configuration
"""
result = []
for index, entry in enumerate(entries):
entry_results = []
for item in config['from']:
if isinstance(item, dict):
plugin_name, plugin_config = list(item.items())[0]
else:
plugin_name, plugin_config = item, None
search = plugin.get(plugin_name, self)
if not callable(getattr(search, 'search')):
log.critical('Search plugin %s does not implement search method', plugin_name)
continue
log.verbose(
'Searching for `%s` with plugin `%s` (%i of %i)',
entry['title'],
plugin_name,
index + 1,
len(entries),
)
try:
search_results = search.search(task=task, entry=entry, config=plugin_config)
if not search_results:
log.debug('No results from %s', plugin_name)
continue
log.debug('Discovered %s entries from %s', len(search_results), plugin_name)
if config.get('limit'):
search_results = search_results[: config['limit']]
for e in search_results:
e['discovered_from'] = entry['title']
e['discovered_with'] = plugin_name
# 'search_results' can be any iterable, make sure it's a list.
e.on_complete(
self.entry_complete, query=entry, search_results=list(search_results)
)
entry_results.extend(search_results)
except plugin.PluginWarning as e:
log.verbose('No results from %s: %s', plugin_name, e)
except plugin.PluginError as e:
log.error('Error searching with %s: %s', plugin_name, e)
if not entry_results:
log.verbose('No search results for `%s`', entry['title'])
entry.complete()
continue
result.extend(entry_results)
return result
def entry_complete(self, entry, query=None, search_results=None, **kwargs):
"""Callback for Entry"""
if entry.accepted:
# One of the search results was accepted, transfer the acceptance back to the query entry which generated it
query.accept()
# Remove this entry from the list of search results yet to complete
search_results.remove(entry)
# When all the search results generated by a query entry are complete, complete the query which generated them
if not search_results:
query.complete()
def estimated(self, entries, estimation_mode):
"""
:param dict estimation_mode: mode -> loose, strict, ignore
:return: Entries that we have estimated to be available
"""
estimator = plugin.get('estimate_release', self)
result = []
for entry in entries:
est_date = estimator.estimate(entry)
if est_date is None:
log.debug('No release date could be determined for %s', entry['title'])
if estimation_mode['mode'] == 'strict':
entry.reject('has no release date')
entry.complete()
else:
result.append(entry)
continue
if isinstance(est_date, datetime.date):
# If we just got a date, add a time so we can compare it to now()
est_date = datetime.datetime.combine(est_date, datetime.time())
if datetime.datetime.now() >= est_date:
log.debug('%s has been released at %s', entry['title'], est_date)
result.append(entry)
elif datetime.datetime.now() >= est_date - parse_timedelta(
estimation_mode['optimistic']
):
log.debug(
'%s will be released at %s. Ignoring release estimation because estimated release date is '
'in less than %s',
entry['title'],
est_date,
estimation_mode['optimistic'],
)
result.append(entry)
else:
entry.reject('has not been released')
entry.complete()
log.verbose("%s hasn't been released yet (Expected: %s)", entry['title'], est_date)
return result
def interval_expired(self, config, task, entries):
"""
Maintain some limit levels so that we don't hammer search
sites with unreasonable amount of queries.
:return: Entries that are up for ``config['interval']``
"""
config.setdefault('interval', '5 hour')
interval = parse_timedelta(config['interval'])
if task.options.discover_now:
log.info('Ignoring interval because of --discover-now')
result = []
interval_count = 0
with Session() as session:
for entry in entries:
discover_entry = (
session.query(DiscoverEntry)
.filter(DiscoverEntry.title == entry['title'])
.filter(DiscoverEntry.task == task.name)
.first()
)
if not discover_entry:
log.debug('%s -> No previous run recorded', entry['title'])
discover_entry = DiscoverEntry(entry['title'], task.name)
session.add(discover_entry)
if (
not task.is_rerun and task.options.discover_now
) or not discover_entry.last_execution:
# First time we execute (and on --discover-now) we randomize time to avoid clumping
delta = multiply_timedelta(interval, random.random())
discover_entry.last_execution = datetime.datetime.now() - delta
else:
next_time = discover_entry.last_execution + interval
log.debug(
'last_time: %r, interval: %s, next_time: %r, ',
discover_entry.last_execution,
config['interval'],
next_time,
)
if datetime.datetime.now() < next_time:
log.debug('interval not met')
interval_count += 1
entry.reject('discover interval not met')
entry.complete()
continue
discover_entry.last_execution = datetime.datetime.now()
log.trace('interval passed for %s', entry['title'])
result.append(entry)
if interval_count and not task.is_rerun:
log.verbose(
'Discover interval of %s not met for %s entries. Use --discover-now to override.',
config['interval'],
interval_count,
)
return result
def on_task_input(self, task, config):
config.setdefault('release_estimations', {})
if not isinstance(config['release_estimations'], dict):
config['release_estimations'] = {'mode': config['release_estimations']}
config['release_estimations'].setdefault('mode', 'strict')
config['release_estimations'].setdefault('optimistic', '0 days')
task.no_entries_ok = True
entries = aggregate_inputs(task, config['what'])
log.verbose('Discovering %i titles ...', len(entries))
if len(entries) > 500:
log.critical(
'Looks like your inputs in discover configuration produced '
'over 500 entries, please reduce the amount!'
)
# TODO: the entries that are estimated should be given priority over expiration
entries = self.interval_expired(config, task, entries)
estimation_mode = config['release_estimations']
if estimation_mode['mode'] != 'ignore':
entries = self.estimated(entries, estimation_mode)
return self.execute_searches(config, entries, task)
@event('plugin.register')
def register_plugin():
plugin.register(Discover, 'discover', api_ver=2)
@event('options.register')
def register_parser_arguments():
options.get_parser('execute').add_argument(
'--discover-now',
action='store_true',
dest='discover_now',
default=False,
help='Immediately try to discover everything',
)
| 39.529032 | 120 | 0.539742 |
020ff8c7d77756766d03dfeca299ecc57f6c0699 | 483 | py | Python | env/lib/python3.8/site-packages/plotly/validators/scatter3d/error_x/_value.py | acrucetta/Chicago_COVI_WebApp | a37c9f492a20dcd625f8647067394617988de913 | [
"MIT",
"Unlicense"
] | 76 | 2020-07-06T14:44:05.000Z | 2022-02-14T15:30:21.000Z | env/lib/python3.8/site-packages/plotly/validators/scatter3d/error_x/_value.py | acrucetta/Chicago_COVI_WebApp | a37c9f492a20dcd625f8647067394617988de913 | [
"MIT",
"Unlicense"
] | 11 | 2020-08-09T02:30:14.000Z | 2022-03-12T00:50:14.000Z | env/lib/python3.8/site-packages/plotly/validators/scatter3d/error_x/_value.py | acrucetta/Chicago_COVI_WebApp | a37c9f492a20dcd625f8647067394617988de913 | [
"MIT",
"Unlicense"
] | 11 | 2020-07-12T16:18:07.000Z | 2022-02-05T16:48:35.000Z | import _plotly_utils.basevalidators
class ValueValidator(_plotly_utils.basevalidators.NumberValidator):
def __init__(self, plotly_name="value", parent_name="scatter3d.error_x", **kwargs):
super(ValueValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "calc"),
min=kwargs.pop("min", 0),
role=kwargs.pop("role", "info"),
**kwargs
)
| 34.5 | 87 | 0.635611 |
6903c80bb31f6dde1f2b183c4e535efd35d734a2 | 118,428 | py | Python | scripts/timos.py | hoxnox/eve-ng | 5b11c20b07fd560b553b871092e3d497f7df413c | [
"BSD-3-Clause"
] | 7 | 2019-10-19T23:15:55.000Z | 2021-11-29T07:01:52.000Z | scripts/timos.py | hoxnox/eve-ng | 5b11c20b07fd560b553b871092e3d497f7df413c | [
"BSD-3-Clause"
] | null | null | null | scripts/timos.py | hoxnox/eve-ng | 5b11c20b07fd560b553b871092e3d497f7df413c | [
"BSD-3-Clause"
] | 9 | 2019-05-01T06:46:28.000Z | 2022-02-14T20:37:33.000Z |
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<link crossorigin="anonymous" href="https://assets-cdn.github.com/assets/frameworks-2ee047e3d7ac61fb4cad5ffb2578eb535d9de741a820b81b04277f6319538d39.css" integrity="sha256-LuBH49esYftMrV/7JXjrU12d50GoILgbBCd/YxlTjTk=" media="all" rel="stylesheet" />
<link crossorigin="anonymous" href="https://assets-cdn.github.com/assets/github-9c5dd67de439961f089da0ec4192c65e38b09b00d77f5160369524b1020a113e.css" integrity="sha256-nF3WfeQ5lh8InaDsQZLGXjiwmwDXf1FgNpUksQIKET4=" media="all" rel="stylesheet" />
<link crossorigin="anonymous" href="https://assets-cdn.github.com/assets/site-02834d091a5403e555c9dc23bc2db89678797487b3349bd3ab7da768a979d976.css" integrity="sha256-AoNNCRpUA+VVydwjvC24lnh5dIezNJvTq32naKl52XY=" media="all" rel="stylesheet" />
<meta name="viewport" content="width=device-width">
<title>unetlab/timos.py at master · kivancimer/unetlab · GitHub</title>
<link rel="search" type="application/opensearchdescription+xml" href="/opensearch.xml" title="GitHub">
<link rel="fluid-icon" href="https://github.com/fluidicon.png" title="GitHub">
<meta property="fb:app_id" content="1401488693436528">
<meta content="https://avatars1.githubusercontent.com/u/12981951?v=3&s=400" property="og:image" /><meta content="GitHub" property="og:site_name" /><meta content="object" property="og:type" /><meta content="kivancimer/unetlab" property="og:title" /><meta content="https://github.com/kivancimer/unetlab" property="og:url" /><meta content="Contribute to unetlab development by creating an account on GitHub." property="og:description" />
<link rel="assets" href="https://assets-cdn.github.com/">
<meta name="pjax-timeout" content="1000">
<meta name="request-id" content="7EFF:0ABB:7721D6:BC6EE3:58B96429" data-pjax-transient>
<meta name="selected-link" value="repo_source" data-pjax-transient>
<meta name="google-site-verification" content="KT5gs8h0wvaagLKAVWq8bbeNwnZZK1r1XQysX3xurLU">
<meta name="google-site-verification" content="ZzhVyEFwb7w3e0-uOTltm8Jsck2F5StVihD0exw2fsA">
<meta name="google-analytics" content="UA-3769691-2">
<meta content="collector.githubapp.com" name="octolytics-host" /><meta content="github" name="octolytics-app-id" /><meta content="https://collector.githubapp.com/github-external/browser_event" name="octolytics-event-url" /><meta content="7EFF:0ABB:7721D6:BC6EE3:58B96429" name="octolytics-dimension-request_id" />
<meta content="/<user-name>/<repo-name>/blob/show" data-pjax-transient="true" name="analytics-location" />
<meta class="js-ga-set" name="dimension1" content="Logged Out">
<meta name="hostname" content="github.com">
<meta name="user-login" content="">
<meta name="expected-hostname" content="github.com">
<meta name="js-proxy-site-detection-payload" content="NmQwYzU0Mjk5MDJjMmM2YWZmZGE5MTM3YWU5MTBjYzMwMjkzMjg2N2Y3OGJmNDBlZmZmZTAyNDQ1ZWE1YjA4Ynx7InJlbW90ZV9hZGRyZXNzIjoiMTM1LjI0NS4yNDguNzMiLCJyZXF1ZXN0X2lkIjoiN0VGRjowQUJCOjc3MjFENjpCQzZFRTM6NThCOTY0MjkiLCJ0aW1lc3RhbXAiOjE0ODg1NDQ4MDksImhvc3QiOiJnaXRodWIuY29tIn0=">
<meta name="html-safe-nonce" content="bb72218f46da437a9da4118a26627ad7561ba85c">
<meta http-equiv="x-pjax-version" content="9e8197a94dea8409322e61a1b454f32a">
<meta name="description" content="Contribute to unetlab development by creating an account on GitHub.">
<meta name="go-import" content="github.com/kivancimer/unetlab git https://github.com/kivancimer/unetlab.git">
<meta content="12981951" name="octolytics-dimension-user_id" /><meta content="kivancimer" name="octolytics-dimension-user_login" /><meta content="76596020" name="octolytics-dimension-repository_id" /><meta content="kivancimer/unetlab" name="octolytics-dimension-repository_nwo" /><meta content="true" name="octolytics-dimension-repository_public" /><meta content="true" name="octolytics-dimension-repository_is_fork" /><meta content="25199111" name="octolytics-dimension-repository_parent_id" /><meta content="dainok/unetlab" name="octolytics-dimension-repository_parent_nwo" /><meta content="25199111" name="octolytics-dimension-repository_network_root_id" /><meta content="dainok/unetlab" name="octolytics-dimension-repository_network_root_nwo" />
<link href="https://github.com/kivancimer/unetlab/commits/master.atom" rel="alternate" title="Recent Commits to unetlab:master" type="application/atom+xml">
<link rel="canonical" href="https://github.com/kivancimer/unetlab/blob/master/scripts/timos.py" data-pjax-transient>
<meta name="browser-stats-url" content="https://api.github.com/_private/browser/stats">
<meta name="browser-errors-url" content="https://api.github.com/_private/browser/errors">
<link rel="mask-icon" href="https://assets-cdn.github.com/pinned-octocat.svg" color="#000000">
<link rel="icon" type="image/x-icon" href="https://assets-cdn.github.com/favicon.ico">
<meta name="theme-color" content="#1e2327">
<meta name="u2f-support" content="true">
</head>
<body class="logged-out env-production windows vis-public fork page-blob">
<div class="position-relative js-header-wrapper ">
<a href="#start-of-content" tabindex="1" class="accessibility-aid js-skip-to-content">Skip to content</a>
<div id="js-pjax-loader-bar" class="pjax-loader-bar"><div class="progress"></div></div>
<header class="site-header js-details-container Details" role="banner">
<div class="container-responsive">
<a class="header-logo-invertocat" href="https://github.com/" aria-label="Homepage" data-ga-click="(Logged out) Header, go to homepage, icon:logo-wordmark">
<svg aria-hidden="true" class="octicon octicon-mark-github" height="32" version="1.1" viewBox="0 0 16 16" width="32"><path fill-rule="evenodd" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0 0 16 8c0-4.42-3.58-8-8-8z"/></svg>
</a>
<button class="btn-link float-right site-header-toggle js-details-target" type="button" aria-label="Toggle navigation">
<svg aria-hidden="true" class="octicon octicon-three-bars" height="24" version="1.1" viewBox="0 0 12 16" width="18"><path fill-rule="evenodd" d="M11.41 9H.59C0 9 0 8.59 0 8c0-.59 0-1 .59-1H11.4c.59 0 .59.41.59 1 0 .59 0 1-.59 1h.01zm0-4H.59C0 5 0 4.59 0 4c0-.59 0-1 .59-1H11.4c.59 0 .59.41.59 1 0 .59 0 1-.59 1h.01zM.59 11H11.4c.59 0 .59.41.59 1 0 .59 0 1-.59 1H.59C0 13 0 12.59 0 12c0-.59 0-1 .59-1z"/></svg>
</button>
<div class="site-header-menu">
<nav class="site-header-nav">
<a href="/features" class="js-selected-navigation-item nav-item" data-ga-click="Header, click, Nav menu - item:features" data-selected-links="/features /features">
Features
</a> <a href="/explore" class="js-selected-navigation-item nav-item" data-ga-click="Header, click, Nav menu - item:explore" data-selected-links="/explore /trending /trending/developers /integrations /integrations/feature/code /integrations/feature/collaborate /integrations/feature/ship /showcases /explore">
Explore
</a> <a href="/pricing" class="js-selected-navigation-item nav-item" data-ga-click="Header, click, Nav menu - item:pricing" data-selected-links="/pricing /pricing">
Pricing
</a> </nav>
<div class="site-header-actions">
<div class="header-search scoped-search site-scoped-search js-site-search" role="search">
<!-- '"` --><!-- </textarea></xmp> --></option></form><form accept-charset="UTF-8" action="/kivancimer/unetlab/search" class="js-site-search-form" data-scoped-search-url="/kivancimer/unetlab/search" data-unscoped-search-url="/search" method="get"><div style="margin:0;padding:0;display:inline"><input name="utf8" type="hidden" value="✓" /></div>
<label class="form-control header-search-wrapper js-chromeless-input-container">
<div class="header-search-scope">This repository</div>
<input type="text"
class="form-control header-search-input js-site-search-focus js-site-search-field is-clearable"
data-hotkey="s"
name="q"
placeholder="Search"
aria-label="Search this repository"
data-unscoped-placeholder="Search GitHub"
data-scoped-placeholder="Search"
autocapitalize="off">
</label>
</form></div>
<a class="text-bold site-header-link" href="/login?return_to=%2Fkivancimer%2Funetlab%2Fblob%2Fmaster%2Fscripts%2Ftimos.py" data-ga-click="(Logged out) Header, clicked Sign in, text:sign-in">Sign in</a>
<span class="text-gray">or</span>
<a class="text-bold site-header-link" href="/join?source=header-repo" data-ga-click="(Logged out) Header, clicked Sign up, text:sign-up">Sign up</a>
</div>
</div>
</div>
</header>
</div>
<div id="start-of-content" class="accessibility-aid"></div>
<div id="js-flash-container">
</div>
<div role="main">
<div itemscope itemtype="http://schema.org/SoftwareSourceCode">
<div id="js-repo-pjax-container" data-pjax-container>
<div class="pagehead repohead instapaper_ignore readability-menu experiment-repo-nav">
<div class="container repohead-details-container">
<ul class="pagehead-actions">
<li>
<a href="/login?return_to=%2Fkivancimer%2Funetlab"
class="btn btn-sm btn-with-count tooltipped tooltipped-n"
aria-label="You must be signed in to watch a repository" rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-eye" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M8.06 2C3 2 0 8 0 8s3 6 8.06 6C13 14 16 8 16 8s-3-6-7.94-6zM8 12c-2.2 0-4-1.78-4-4 0-2.2 1.8-4 4-4 2.22 0 4 1.8 4 4 0 2.22-1.78 4-4 4zm2-4c0 1.11-.89 2-2 2-1.11 0-2-.89-2-2 0-1.11.89-2 2-2 1.11 0 2 .89 2 2z"/></svg>
Watch
</a>
<a class="social-count" href="/kivancimer/unetlab/watchers"
aria-label="1 user is watching this repository">
1
</a>
</li>
<li>
<a href="/login?return_to=%2Fkivancimer%2Funetlab"
class="btn btn-sm btn-with-count tooltipped tooltipped-n"
aria-label="You must be signed in to star a repository" rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-star" height="16" version="1.1" viewBox="0 0 14 16" width="14"><path fill-rule="evenodd" d="M14 6l-4.9-.64L7 1 4.9 5.36 0 6l3.6 3.26L2.67 14 7 11.67 11.33 14l-.93-4.74z"/></svg>
Star
</a>
<a class="social-count js-social-count" href="/kivancimer/unetlab/stargazers"
aria-label="0 users starred this repository">
0
</a>
</li>
<li>
<a href="/login?return_to=%2Fkivancimer%2Funetlab"
class="btn btn-sm btn-with-count tooltipped tooltipped-n"
aria-label="You must be signed in to fork a repository" rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-repo-forked" height="16" version="1.1" viewBox="0 0 10 16" width="10"><path fill-rule="evenodd" d="M8 1a1.993 1.993 0 0 0-1 3.72V6L5 8 3 6V4.72A1.993 1.993 0 0 0 2 1a1.993 1.993 0 0 0-1 3.72V6.5l3 3v1.78A1.993 1.993 0 0 0 5 15a1.993 1.993 0 0 0 1-3.72V9.5l3-3V4.72A1.993 1.993 0 0 0 8 1zM2 4.2C1.34 4.2.8 3.65.8 3c0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zm3 10c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zm3-10c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2z"/></svg>
Fork
</a>
<a href="/kivancimer/unetlab/network" class="social-count"
aria-label="45 users forked this repository">
45
</a>
</li>
</ul>
<h1 class="public ">
<svg aria-hidden="true" class="octicon octicon-repo-forked" height="16" version="1.1" viewBox="0 0 10 16" width="10"><path fill-rule="evenodd" d="M8 1a1.993 1.993 0 0 0-1 3.72V6L5 8 3 6V4.72A1.993 1.993 0 0 0 2 1a1.993 1.993 0 0 0-1 3.72V6.5l3 3v1.78A1.993 1.993 0 0 0 5 15a1.993 1.993 0 0 0 1-3.72V9.5l3-3V4.72A1.993 1.993 0 0 0 8 1zM2 4.2C1.34 4.2.8 3.65.8 3c0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zm3 10c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zm3-10c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2z"/></svg>
<span class="author" itemprop="author"><a href="/kivancimer" class="url fn" rel="author">kivancimer</a></span><!--
--><span class="path-divider">/</span><!--
--><strong itemprop="name"><a href="/kivancimer/unetlab" data-pjax="#js-repo-pjax-container">unetlab</a></strong>
<span class="fork-flag">
<span class="text">forked from <a href="/dainok/unetlab">dainok/unetlab</a></span>
</span>
</h1>
</div>
<div class="container">
<nav class="reponav js-repo-nav js-sidenav-container-pjax"
itemscope
itemtype="http://schema.org/BreadcrumbList"
role="navigation"
data-pjax="#js-repo-pjax-container">
<span itemscope itemtype="http://schema.org/ListItem" itemprop="itemListElement">
<a href="/kivancimer/unetlab" class="js-selected-navigation-item selected reponav-item" data-hotkey="g c" data-selected-links="repo_source repo_downloads repo_commits repo_releases repo_tags repo_branches /kivancimer/unetlab" itemprop="url">
<svg aria-hidden="true" class="octicon octicon-code" height="16" version="1.1" viewBox="0 0 14 16" width="14"><path fill-rule="evenodd" d="M9.5 3L8 4.5 11.5 8 8 11.5 9.5 13 14 8 9.5 3zm-5 0L0 8l4.5 5L6 11.5 2.5 8 6 4.5 4.5 3z"/></svg>
<span itemprop="name">Code</span>
<meta itemprop="position" content="1">
</a> </span>
<span itemscope itemtype="http://schema.org/ListItem" itemprop="itemListElement">
<a href="/kivancimer/unetlab/pulls" class="js-selected-navigation-item reponav-item" data-hotkey="g p" data-selected-links="repo_pulls /kivancimer/unetlab/pulls" itemprop="url">
<svg aria-hidden="true" class="octicon octicon-git-pull-request" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M11 11.28V5c-.03-.78-.34-1.47-.94-2.06C9.46 2.35 8.78 2.03 8 2H7V0L4 3l3 3V4h1c.27.02.48.11.69.31.21.2.3.42.31.69v6.28A1.993 1.993 0 0 0 10 15a1.993 1.993 0 0 0 1-3.72zm-1 2.92c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zM4 3c0-1.11-.89-2-2-2a1.993 1.993 0 0 0-1 3.72v6.56A1.993 1.993 0 0 0 2 15a1.993 1.993 0 0 0 1-3.72V4.72c.59-.34 1-.98 1-1.72zm-.8 10c0 .66-.55 1.2-1.2 1.2-.65 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2zM2 4.2C1.34 4.2.8 3.65.8 3c0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2z"/></svg>
<span itemprop="name">Pull requests</span>
<span class="counter">0</span>
<meta itemprop="position" content="3">
</a> </span>
<a href="/kivancimer/unetlab/projects" class="js-selected-navigation-item reponav-item" data-selected-links="repo_projects new_repo_project repo_project /kivancimer/unetlab/projects">
<svg aria-hidden="true" class="octicon octicon-project" height="16" version="1.1" viewBox="0 0 15 16" width="15"><path fill-rule="evenodd" d="M10 12h3V2h-3v10zm-4-2h3V2H6v8zm-4 4h3V2H2v12zm-1 1h13V1H1v14zM14 0H1a1 1 0 0 0-1 1v14a1 1 0 0 0 1 1h13a1 1 0 0 0 1-1V1a1 1 0 0 0-1-1z"/></svg>
Projects
<span class="counter">0</span>
</a>
<a href="/kivancimer/unetlab/pulse" class="js-selected-navigation-item reponav-item" data-selected-links="pulse /kivancimer/unetlab/pulse">
<svg aria-hidden="true" class="octicon octicon-pulse" height="16" version="1.1" viewBox="0 0 14 16" width="14"><path fill-rule="evenodd" d="M11.5 8L8.8 5.4 6.6 8.5 5.5 1.6 2.38 8H0v2h3.6l.9-1.8.9 5.4L9 8.5l1.6 1.5H14V8z"/></svg>
Pulse
</a>
<a href="/kivancimer/unetlab/graphs" class="js-selected-navigation-item reponav-item" data-selected-links="repo_graphs repo_contributors /kivancimer/unetlab/graphs">
<svg aria-hidden="true" class="octicon octicon-graph" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M16 14v1H0V0h1v14h15zM5 13H3V8h2v5zm4 0H7V3h2v10zm4 0h-2V6h2v7z"/></svg>
Graphs
</a>
</nav>
</div>
</div>
<div class="container new-discussion-timeline experiment-repo-nav">
<div class="repository-content">
<a href="/kivancimer/unetlab/blob/613206a574551bb31629e509ff7d6309afe85bf5/scripts/timos.py" class="d-none js-permalink-shortcut" data-hotkey="y">Permalink</a>
<!-- blob contrib key: blob_contributors:v21:7ed7b19a37a69b920af788cb0cc9ebc0 -->
<div class="file-navigation js-zeroclipboard-container">
<div class="select-menu branch-select-menu js-menu-container js-select-menu float-left">
<button class="btn btn-sm select-menu-button js-menu-target css-truncate" data-hotkey="w"
type="button" aria-label="Switch branches or tags" tabindex="0" aria-haspopup="true">
<i>Branch:</i>
<span class="js-select-button css-truncate-target">master</span>
</button>
<div class="select-menu-modal-holder js-menu-content js-navigation-container" data-pjax aria-hidden="true">
<div class="select-menu-modal">
<div class="select-menu-header">
<svg aria-label="Close" class="octicon octicon-x js-menu-close" height="16" role="img" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M7.48 8l3.75 3.75-1.48 1.48L6 9.48l-3.75 3.75-1.48-1.48L4.52 8 .77 4.25l1.48-1.48L6 6.52l3.75-3.75 1.48 1.48z"/></svg>
<span class="select-menu-title">Switch branches/tags</span>
</div>
<div class="select-menu-filters">
<div class="select-menu-text-filter">
<input type="text" aria-label="Filter branches/tags" id="context-commitish-filter-field" class="form-control js-filterable-field js-navigation-enable" placeholder="Filter branches/tags">
</div>
<div class="select-menu-tabs">
<ul>
<li class="select-menu-tab">
<a href="#" data-tab-filter="branches" data-filter-placeholder="Filter branches/tags" class="js-select-menu-tab" role="tab">Branches</a>
</li>
<li class="select-menu-tab">
<a href="#" data-tab-filter="tags" data-filter-placeholder="Find a tag…" class="js-select-menu-tab" role="tab">Tags</a>
</li>
</ul>
</div>
</div>
<div class="select-menu-list select-menu-tab-bucket js-select-menu-tab-bucket" data-tab-filter="branches" role="menu">
<div data-filterable-for="context-commitish-filter-field" data-filterable-type="substring">
<a class="select-menu-item js-navigation-item js-navigation-open "
href="/kivancimer/unetlab/blob/0.9.0-68/scripts/timos.py"
data-name="0.9.0-68"
data-skip-pjax="true"
rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"/></svg>
<span class="select-menu-item-text css-truncate-target js-select-menu-filter-text">
0.9.0-68
</span>
</a>
<a class="select-menu-item js-navigation-item js-navigation-open "
href="/kivancimer/unetlab/blob/0.9.0-70/scripts/timos.py"
data-name="0.9.0-70"
data-skip-pjax="true"
rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"/></svg>
<span class="select-menu-item-text css-truncate-target js-select-menu-filter-text">
0.9.0-70
</span>
</a>
<a class="select-menu-item js-navigation-item js-navigation-open "
href="/kivancimer/unetlab/blob/0.9.0-76/scripts/timos.py"
data-name="0.9.0-76"
data-skip-pjax="true"
rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"/></svg>
<span class="select-menu-item-text css-truncate-target js-select-menu-filter-text">
0.9.0-76
</span>
</a>
<a class="select-menu-item js-navigation-item js-navigation-open "
href="/kivancimer/unetlab/blob/0.9.0-88/scripts/timos.py"
data-name="0.9.0-88"
data-skip-pjax="true"
rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"/></svg>
<span class="select-menu-item-text css-truncate-target js-select-menu-filter-text">
0.9.0-88
</span>
</a>
<a class="select-menu-item js-navigation-item js-navigation-open selected"
href="/kivancimer/unetlab/blob/master/scripts/timos.py"
data-name="master"
data-skip-pjax="true"
rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"/></svg>
<span class="select-menu-item-text css-truncate-target js-select-menu-filter-text">
master
</span>
</a>
<a class="select-menu-item js-navigation-item js-navigation-open "
href="/kivancimer/unetlab/blob/revert-71-master/scripts/timos.py"
data-name="revert-71-master"
data-skip-pjax="true"
rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"/></svg>
<span class="select-menu-item-text css-truncate-target js-select-menu-filter-text">
revert-71-master
</span>
</a>
<a class="select-menu-item js-navigation-item js-navigation-open "
href="/kivancimer/unetlab/blob/revert-72-revert-71-master/scripts/timos.py"
data-name="revert-72-revert-71-master"
data-skip-pjax="true"
rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"/></svg>
<span class="select-menu-item-text css-truncate-target js-select-menu-filter-text">
revert-72-revert-71-master
</span>
</a>
<a class="select-menu-item js-navigation-item js-navigation-open "
href="/kivancimer/unetlab/blob/revert-160-patch-1/scripts/timos.py"
data-name="revert-160-patch-1"
data-skip-pjax="true"
rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"/></svg>
<span class="select-menu-item-text css-truncate-target js-select-menu-filter-text">
revert-160-patch-1
</span>
</a>
</div>
<div class="select-menu-no-results">Nothing to show</div>
</div>
<div class="select-menu-list select-menu-tab-bucket js-select-menu-tab-bucket" data-tab-filter="tags">
<div data-filterable-for="context-commitish-filter-field" data-filterable-type="substring">
<a class="select-menu-item js-navigation-item js-navigation-open "
href="/kivancimer/unetlab/tree/0.9.0-88/scripts/timos.py"
data-name="0.9.0-88"
data-skip-pjax="true"
rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"/></svg>
<span class="select-menu-item-text css-truncate-target" title="0.9.0-88">
0.9.0-88
</span>
</a>
<a class="select-menu-item js-navigation-item js-navigation-open "
href="/kivancimer/unetlab/tree/0.9.0-76/scripts/timos.py"
data-name="0.9.0-76"
data-skip-pjax="true"
rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"/></svg>
<span class="select-menu-item-text css-truncate-target" title="0.9.0-76">
0.9.0-76
</span>
</a>
<a class="select-menu-item js-navigation-item js-navigation-open "
href="/kivancimer/unetlab/tree/0.9.0-70/scripts/timos.py"
data-name="0.9.0-70"
data-skip-pjax="true"
rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"/></svg>
<span class="select-menu-item-text css-truncate-target" title="0.9.0-70">
0.9.0-70
</span>
</a>
<a class="select-menu-item js-navigation-item js-navigation-open "
href="/kivancimer/unetlab/tree/0.9.0-68/scripts/timos.py"
data-name="0.9.0-68"
data-skip-pjax="true"
rel="nofollow">
<svg aria-hidden="true" class="octicon octicon-check select-menu-item-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M12 5l-8 8-4-4 1.5-1.5L4 10l6.5-6.5z"/></svg>
<span class="select-menu-item-text css-truncate-target" title="0.9.0-68">
0.9.0-68
</span>
</a>
</div>
<div class="select-menu-no-results">Nothing to show</div>
</div>
</div>
</div>
</div>
<div class="BtnGroup float-right">
<a href="/kivancimer/unetlab/find/master"
class="js-pjax-capture-input btn btn-sm BtnGroup-item"
data-pjax
data-hotkey="t">
Find file
</a>
<button aria-label="Copy file path to clipboard" class="js-zeroclipboard btn btn-sm BtnGroup-item tooltipped tooltipped-s" data-copied-hint="Copied!" type="button">Copy path</button>
</div>
<div class="breadcrumb js-zeroclipboard-target">
<span class="repo-root js-repo-root"><span class="js-path-segment"><a href="/kivancimer/unetlab"><span>unetlab</span></a></span></span><span class="separator">/</span><span class="js-path-segment"><a href="/kivancimer/unetlab/tree/master/scripts"><span>scripts</span></a></span><span class="separator">/</span><strong class="final-path">timos.py</strong>
</div>
</div>
<div class="commit-tease">
<span class="float-right">
<a class="commit-tease-sha" href="/kivancimer/unetlab/commit/b5ba998b1a5b5394f0b6250fe611348fefb3d1a1" data-pjax>
b5ba998
</a>
<relative-time datetime="2016-12-15T21:12:48Z">Dec 15, 2016</relative-time>
</span>
<div>
<img alt="@kivancimer" class="avatar" height="20" src="https://avatars3.githubusercontent.com/u/12981951?v=3&s=40" width="20" />
<a href="/kivancimer" class="user-mention" rel="author">kivancimer</a>
<a href="/kivancimer/unetlab/commit/b5ba998b1a5b5394f0b6250fe611348fefb3d1a1" class="message" data-pjax="true" title="15122016 Nokia VSR Update 3">15122016 Nokia VSR Update 3</a>
</div>
<div class="commit-tease-contributors">
<button type="button" class="btn-link muted-link contributors-toggle" data-facebox="#blob_contributors_box">
<strong>1</strong>
contributor
</button>
</div>
<div id="blob_contributors_box" style="display:none">
<h2 class="facebox-header" data-facebox-id="facebox-header">Users who have contributed to this file</h2>
<ul class="facebox-user-list" data-facebox-id="facebox-description">
<li class="facebox-user-list-item">
<img alt="@kivancimer" height="24" src="https://avatars1.githubusercontent.com/u/12981951?v=3&s=48" width="24" />
<a href="/kivancimer">kivancimer</a>
</li>
</ul>
</div>
</div>
<div class="file">
<div class="file-header">
<div class="file-actions">
<div class="BtnGroup">
<a href="/kivancimer/unetlab/raw/master/scripts/timos.py" class="btn btn-sm BtnGroup-item" id="raw-url">Raw</a>
<a href="/kivancimer/unetlab/blame/master/scripts/timos.py" class="btn btn-sm js-update-url-with-hash BtnGroup-item" data-hotkey="b">Blame</a>
<a href="/kivancimer/unetlab/commits/master/scripts/timos.py" class="btn btn-sm BtnGroup-item" rel="nofollow">History</a>
</div>
<a class="btn-octicon tooltipped tooltipped-nw"
href="https://windows.github.com"
aria-label="Open this file in GitHub Desktop"
data-ga-click="Repository, open with desktop, type:windows">
<svg aria-hidden="true" class="octicon octicon-device-desktop" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M15 2H1c-.55 0-1 .45-1 1v9c0 .55.45 1 1 1h5.34c-.25.61-.86 1.39-2.34 2h8c-1.48-.61-2.09-1.39-2.34-2H15c.55 0 1-.45 1-1V3c0-.55-.45-1-1-1zm0 9H1V3h14v8z"/></svg>
</a>
<button type="button" class="btn-octicon disabled tooltipped tooltipped-nw"
aria-label="You must be signed in to make or propose changes">
<svg aria-hidden="true" class="octicon octicon-pencil" height="16" version="1.1" viewBox="0 0 14 16" width="14"><path fill-rule="evenodd" d="M0 12v3h3l8-8-3-3-8 8zm3 2H1v-2h1v1h1v1zm10.3-9.3L12 6 9 3l1.3-1.3a.996.996 0 0 1 1.41 0l1.59 1.59c.39.39.39 1.02 0 1.41z"/></svg>
</button>
<button type="button" class="btn-octicon btn-octicon-danger disabled tooltipped tooltipped-nw"
aria-label="You must be signed in to make or propose changes">
<svg aria-hidden="true" class="octicon octicon-trashcan" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M11 2H9c0-.55-.45-1-1-1H5c-.55 0-1 .45-1 1H2c-.55 0-1 .45-1 1v1c0 .55.45 1 1 1v9c0 .55.45 1 1 1h7c.55 0 1-.45 1-1V5c.55 0 1-.45 1-1V3c0-.55-.45-1-1-1zm-1 12H3V5h1v8h1V5h1v8h1V5h1v8h1V5h1v9zm1-10H2V3h9v1z"/></svg>
</button>
</div>
<div class="file-info">
296 lines (264 sloc)
<span class="file-info-divider"></span>
8.74 KB
</div>
</div>
<div itemprop="text" class="blob-wrapper data type-python">
<table class="highlight tab-size js-file-line-container" data-tab-size="8">
<tr>
<td id="L1" class="blob-num js-line-number" data-line-number="1"></td>
<td id="LC1" class="blob-code blob-code-inner js-file-line"><span class="pl-c"><span class="pl-c">#</span>!/usr/bin/env python3</span></td>
</tr>
<tr>
<td id="L2" class="blob-num js-line-number" data-line-number="2"></td>
<td id="LC2" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L3" class="blob-num js-line-number" data-line-number="3"></td>
<td id="LC3" class="blob-code blob-code-inner js-file-line"><span class="pl-c"><span class="pl-c">#</span> scripts/timos.py</span></td>
</tr>
<tr>
<td id="L4" class="blob-num js-line-number" data-line-number="4"></td>
<td id="LC4" class="blob-code blob-code-inner js-file-line"><span class="pl-c"><span class="pl-c">#</span></span></td>
</tr>
<tr>
<td id="L5" class="blob-num js-line-number" data-line-number="5"></td>
<td id="LC5" class="blob-code blob-code-inner js-file-line"><span class="pl-c"><span class="pl-c">#</span> Import/Export script for SROS.</span></td>
</tr>
<tr>
<td id="L6" class="blob-num js-line-number" data-line-number="6"></td>
<td id="LC6" class="blob-code blob-code-inner js-file-line"><span class="pl-c"><span class="pl-c">#</span></span></td>
</tr>
<tr>
<td id="L7" class="blob-num js-line-number" data-line-number="7"></td>
<td id="LC7" class="blob-code blob-code-inner js-file-line"><span class="pl-c"><span class="pl-c">#</span> @author Andrea Dainese <andrea.dainese@gmail.com></span></td>
</tr>
<tr>
<td id="L8" class="blob-num js-line-number" data-line-number="8"></td>
<td id="LC8" class="blob-code blob-code-inner js-file-line"><span class="pl-c"><span class="pl-c">#</span> @copyright 2014-2016 Andrea Dainese</span></td>
</tr>
<tr>
<td id="L9" class="blob-num js-line-number" data-line-number="9"></td>
<td id="LC9" class="blob-code blob-code-inner js-file-line"><span class="pl-c"><span class="pl-c">#</span> @license BSD-3-Clause https://github.com/dainok/unetlab/blob/master/LICENSE</span></td>
</tr>
<tr>
<td id="L10" class="blob-num js-line-number" data-line-number="10"></td>
<td id="LC10" class="blob-code blob-code-inner js-file-line"><span class="pl-c"><span class="pl-c">#</span> @link http://www.unetlab.com/</span></td>
</tr>
<tr>
<td id="L11" class="blob-num js-line-number" data-line-number="11"></td>
<td id="LC11" class="blob-code blob-code-inner js-file-line"><span class="pl-c"><span class="pl-c">#</span> @version 20160719</span></td>
</tr>
<tr>
<td id="L12" class="blob-num js-line-number" data-line-number="12"></td>
<td id="LC12" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L13" class="blob-num js-line-number" data-line-number="13"></td>
<td id="LC13" class="blob-code blob-code-inner js-file-line"><span class="pl-k">import</span> getopt, multiprocessing, os, pexpect, re, sys, time</td>
</tr>
<tr>
<td id="L14" class="blob-num js-line-number" data-line-number="14"></td>
<td id="LC14" class="blob-code blob-code-inner js-file-line"><span class="pl-k">from</span> datetime <span class="pl-k">import</span> datetime</td>
</tr>
<tr>
<td id="L15" class="blob-num js-line-number" data-line-number="15"></td>
<td id="LC15" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L16" class="blob-num js-line-number" data-line-number="16"></td>
<td id="LC16" class="blob-code blob-code-inner js-file-line">username <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>admin<span class="pl-pds">'</span></span></td>
</tr>
<tr>
<td id="L17" class="blob-num js-line-number" data-line-number="17"></td>
<td id="LC17" class="blob-code blob-code-inner js-file-line">password <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span>admin<span class="pl-pds">'</span></span></td>
</tr>
<tr>
<td id="L18" class="blob-num js-line-number" data-line-number="18"></td>
<td id="LC18" class="blob-code blob-code-inner js-file-line">conntimeout <span class="pl-k">=</span> <span class="pl-c1">3</span> <span class="pl-c"><span class="pl-c">#</span> Maximum time for console connection</span></td>
</tr>
<tr>
<td id="L19" class="blob-num js-line-number" data-line-number="19"></td>
<td id="LC19" class="blob-code blob-code-inner js-file-line">expctimeout <span class="pl-k">=</span> <span class="pl-c1">3</span> <span class="pl-c"><span class="pl-c">#</span> Maximum time for each short expect</span></td>
</tr>
<tr>
<td id="L20" class="blob-num js-line-number" data-line-number="20"></td>
<td id="LC20" class="blob-code blob-code-inner js-file-line">longtimeout <span class="pl-k">=</span> <span class="pl-c1">115</span> <span class="pl-c"><span class="pl-c">#</span> Maximum time for each long expect</span></td>
</tr>
<tr>
<td id="L21" class="blob-num js-line-number" data-line-number="21"></td>
<td id="LC21" class="blob-code blob-code-inner js-file-line">timeout <span class="pl-k">=</span> <span class="pl-c1">150</span> <span class="pl-c"><span class="pl-c">#</span> Maximum run time (conntimeout is included)</span></td>
</tr>
<tr>
<td id="L22" class="blob-num js-line-number" data-line-number="22"></td>
<td id="LC22" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L23" class="blob-num js-line-number" data-line-number="23"></td>
<td id="LC23" class="blob-code blob-code-inner js-file-line"><span class="pl-k">def</span> <span class="pl-en">node_login</span>(<span class="pl-smi">handler</span>):</td>
</tr>
<tr>
<td id="L24" class="blob-num js-line-number" data-line-number="24"></td>
<td id="LC24" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Send an empty line, and wait for the login prompt</span></td>
</tr>
<tr>
<td id="L25" class="blob-num js-line-number" data-line-number="25"></td>
<td id="LC25" class="blob-code blob-code-inner js-file-line"> i <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span></td>
</tr>
<tr>
<td id="L26" class="blob-num js-line-number" data-line-number="26"></td>
<td id="LC26" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> i <span class="pl-k">==</span> <span class="pl-k">-</span><span class="pl-c1">1</span>:</td>
</tr>
<tr>
<td id="L27" class="blob-num js-line-number" data-line-number="27"></td>
<td id="LC27" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L28" class="blob-num js-line-number" data-line-number="28"></td>
<td id="LC28" class="blob-code blob-code-inner js-file-line"> handler.sendline(<span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\r\n</span><span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L29" class="blob-num js-line-number" data-line-number="29"></td>
<td id="LC29" class="blob-code blob-code-inner js-file-line"> i <span class="pl-k">=</span> handler.expect([</td>
</tr>
<tr>
<td id="L30" class="blob-num js-line-number" data-line-number="30"></td>
<td id="LC30" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>Login:<span class="pl-pds">'</span></span>,</td>
</tr>
<tr>
<td id="L31" class="blob-num js-line-number" data-line-number="31"></td>
<td id="LC31" class="blob-code blob-code-inner js-file-line"> <span class="pl-s"><span class="pl-pds">'</span>#<span class="pl-pds">'</span></span>],</td>
</tr>
<tr>
<td id="L32" class="blob-num js-line-number" data-line-number="32"></td>
<td id="LC32" class="blob-code blob-code-inner js-file-line"> <span class="pl-v">timeout</span> <span class="pl-k">=</span> <span class="pl-c1">5</span>)</td>
</tr>
<tr>
<td id="L33" class="blob-num js-line-number" data-line-number="33"></td>
<td id="LC33" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span>:</td>
</tr>
<tr>
<td id="L34" class="blob-num js-line-number" data-line-number="34"></td>
<td id="LC34" class="blob-code blob-code-inner js-file-line"> i <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span></td>
</tr>
<tr>
<td id="L35" class="blob-num js-line-number" data-line-number="35"></td>
<td id="LC35" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L36" class="blob-num js-line-number" data-line-number="36"></td>
<td id="LC36" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> i <span class="pl-k">==</span> <span class="pl-c1">0</span>:</td>
</tr>
<tr>
<td id="L37" class="blob-num js-line-number" data-line-number="37"></td>
<td id="LC37" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Need to send username and password</span></td>
</tr>
<tr>
<td id="L38" class="blob-num js-line-number" data-line-number="38"></td>
<td id="LC38" class="blob-code blob-code-inner js-file-line"> handler.sendline(username)</td>
</tr>
<tr>
<td id="L39" class="blob-num js-line-number" data-line-number="39"></td>
<td id="LC39" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L40" class="blob-num js-line-number" data-line-number="40"></td>
<td id="LC40" class="blob-code blob-code-inner js-file-line"> handler.expect(<span class="pl-s"><span class="pl-pds">'</span>Password:<span class="pl-pds">'</span></span>, <span class="pl-v">timeout</span> <span class="pl-k">=</span> expctimeout)</td>
</tr>
<tr>
<td id="L41" class="blob-num js-line-number" data-line-number="41"></td>
<td id="LC41" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span>:</td>
</tr>
<tr>
<td id="L42" class="blob-num js-line-number" data-line-number="42"></td>
<td id="LC42" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: error waiting for "Password:" prompt.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L43" class="blob-num js-line-number" data-line-number="43"></td>
<td id="LC43" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L44" class="blob-num js-line-number" data-line-number="44"></td>
<td id="LC44" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">False</span></td>
</tr>
<tr>
<td id="L45" class="blob-num js-line-number" data-line-number="45"></td>
<td id="LC45" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L46" class="blob-num js-line-number" data-line-number="46"></td>
<td id="LC46" class="blob-code blob-code-inner js-file-line"> handler.sendline(password)</td>
</tr>
<tr>
<td id="L47" class="blob-num js-line-number" data-line-number="47"></td>
<td id="LC47" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L48" class="blob-num js-line-number" data-line-number="48"></td>
<td id="LC48" class="blob-code blob-code-inner js-file-line"> j <span class="pl-k">=</span> handler.expect([<span class="pl-s"><span class="pl-pds">'</span>#<span class="pl-pds">'</span></span>], <span class="pl-v">timeout</span> <span class="pl-k">=</span> expctimeout)</td>
</tr>
<tr>
<td id="L49" class="blob-num js-line-number" data-line-number="49"></td>
<td id="LC49" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span>:</td>
</tr>
<tr>
<td id="L50" class="blob-num js-line-number" data-line-number="50"></td>
<td id="LC50" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: error waiting for ["#"] prompt.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L51" class="blob-num js-line-number" data-line-number="51"></td>
<td id="LC51" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L52" class="blob-num js-line-number" data-line-number="52"></td>
<td id="LC52" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">False</span></td>
</tr>
<tr>
<td id="L53" class="blob-num js-line-number" data-line-number="53"></td>
<td id="LC53" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L54" class="blob-num js-line-number" data-line-number="54"></td>
<td id="LC54" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> j <span class="pl-k">==</span> <span class="pl-c1">0</span>:</td>
</tr>
<tr>
<td id="L55" class="blob-num js-line-number" data-line-number="55"></td>
<td id="LC55" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Nothing to do</span></td>
</tr>
<tr>
<td id="L56" class="blob-num js-line-number" data-line-number="56"></td>
<td id="LC56" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">True</span></td>
</tr>
<tr>
<td id="L57" class="blob-num js-line-number" data-line-number="57"></td>
<td id="LC57" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">else</span>:</td>
</tr>
<tr>
<td id="L58" class="blob-num js-line-number" data-line-number="58"></td>
<td id="LC58" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Unexpected output</span></td>
</tr>
<tr>
<td id="L59" class="blob-num js-line-number" data-line-number="59"></td>
<td id="LC59" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L60" class="blob-num js-line-number" data-line-number="60"></td>
<td id="LC60" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">False</span></td>
</tr>
<tr>
<td id="L61" class="blob-num js-line-number" data-line-number="61"></td>
<td id="LC61" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">elif</span> i <span class="pl-k">==</span> <span class="pl-c1">1</span>:</td>
</tr>
<tr>
<td id="L62" class="blob-num js-line-number" data-line-number="62"></td>
<td id="LC62" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Config mode detected, need to exit</span></td>
</tr>
<tr>
<td id="L63" class="blob-num js-line-number" data-line-number="63"></td>
<td id="LC63" class="blob-code blob-code-inner js-file-line"> handler.sendline(<span class="pl-s"><span class="pl-pds">'</span>exit all<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L64" class="blob-num js-line-number" data-line-number="64"></td>
<td id="LC64" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L65" class="blob-num js-line-number" data-line-number="65"></td>
<td id="LC65" class="blob-code blob-code-inner js-file-line"> handler.expect(<span class="pl-s"><span class="pl-pds">'</span>#<span class="pl-pds">'</span></span>, <span class="pl-v">timeout</span> <span class="pl-k">=</span> expctimeout)</td>
</tr>
<tr>
<td id="L66" class="blob-num js-line-number" data-line-number="66"></td>
<td id="LC66" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span>:</td>
</tr>
<tr>
<td id="L67" class="blob-num js-line-number" data-line-number="67"></td>
<td id="LC67" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: error waiting for "#" prompt.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L68" class="blob-num js-line-number" data-line-number="68"></td>
<td id="LC68" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L69" class="blob-num js-line-number" data-line-number="69"></td>
<td id="LC69" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">False</span></td>
</tr>
<tr>
<td id="L70" class="blob-num js-line-number" data-line-number="70"></td>
<td id="LC70" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">True</span></td>
</tr>
<tr>
<td id="L71" class="blob-num js-line-number" data-line-number="71"></td>
<td id="LC71" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">else</span>:</td>
</tr>
<tr>
<td id="L72" class="blob-num js-line-number" data-line-number="72"></td>
<td id="LC72" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Unexpected output</span></td>
</tr>
<tr>
<td id="L73" class="blob-num js-line-number" data-line-number="73"></td>
<td id="LC73" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L74" class="blob-num js-line-number" data-line-number="74"></td>
<td id="LC74" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">False</span></td>
</tr>
<tr>
<td id="L75" class="blob-num js-line-number" data-line-number="75"></td>
<td id="LC75" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L76" class="blob-num js-line-number" data-line-number="76"></td>
<td id="LC76" class="blob-code blob-code-inner js-file-line"><span class="pl-k">def</span> <span class="pl-en">node_quit</span>(<span class="pl-smi">handler</span>):</td>
</tr>
<tr>
<td id="L77" class="blob-num js-line-number" data-line-number="77"></td>
<td id="LC77" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> handler.isalive() <span class="pl-k">==</span> <span class="pl-c1">True</span>:</td>
</tr>
<tr>
<td id="L78" class="blob-num js-line-number" data-line-number="78"></td>
<td id="LC78" class="blob-code blob-code-inner js-file-line"> handler.sendline(<span class="pl-s"><span class="pl-pds">'</span>logout<span class="pl-cce">\n</span><span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L79" class="blob-num js-line-number" data-line-number="79"></td>
<td id="LC79" class="blob-code blob-code-inner js-file-line"> handler.close()</td>
</tr>
<tr>
<td id="L80" class="blob-num js-line-number" data-line-number="80"></td>
<td id="LC80" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L81" class="blob-num js-line-number" data-line-number="81"></td>
<td id="LC81" class="blob-code blob-code-inner js-file-line"><span class="pl-k">def</span> <span class="pl-en">config_get</span>(<span class="pl-smi">handler</span>):</td>
</tr>
<tr>
<td id="L82" class="blob-num js-line-number" data-line-number="82"></td>
<td id="LC82" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Clearing all "expect" buffer</span></td>
</tr>
<tr>
<td id="L83" class="blob-num js-line-number" data-line-number="83"></td>
<td id="LC83" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> <span class="pl-c1">True</span>:</td>
</tr>
<tr>
<td id="L84" class="blob-num js-line-number" data-line-number="84"></td>
<td id="LC84" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L85" class="blob-num js-line-number" data-line-number="85"></td>
<td id="LC85" class="blob-code blob-code-inner js-file-line"> handler.expect(<span class="pl-s"><span class="pl-pds">'</span>#<span class="pl-pds">'</span></span>, <span class="pl-v">timeout</span> <span class="pl-k">=</span> <span class="pl-c1">0.1</span>)</td>
</tr>
<tr>
<td id="L86" class="blob-num js-line-number" data-line-number="86"></td>
<td id="LC86" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span>:</td>
</tr>
<tr>
<td id="L87" class="blob-num js-line-number" data-line-number="87"></td>
<td id="LC87" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span></td>
</tr>
<tr>
<td id="L88" class="blob-num js-line-number" data-line-number="88"></td>
<td id="LC88" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L89" class="blob-num js-line-number" data-line-number="89"></td>
<td id="LC89" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Disable paging</span></td>
</tr>
<tr>
<td id="L90" class="blob-num js-line-number" data-line-number="90"></td>
<td id="LC90" class="blob-code blob-code-inner js-file-line"> handler.sendline(<span class="pl-s"><span class="pl-pds">'</span>environment no more<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L91" class="blob-num js-line-number" data-line-number="91"></td>
<td id="LC91" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L92" class="blob-num js-line-number" data-line-number="92"></td>
<td id="LC92" class="blob-code blob-code-inner js-file-line"> handler.expect(<span class="pl-s"><span class="pl-pds">'</span>#<span class="pl-pds">'</span></span>, <span class="pl-v">timeout</span> <span class="pl-k">=</span> expctimeout)</td>
</tr>
<tr>
<td id="L93" class="blob-num js-line-number" data-line-number="93"></td>
<td id="LC93" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span>:</td>
</tr>
<tr>
<td id="L94" class="blob-num js-line-number" data-line-number="94"></td>
<td id="LC94" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: error waiting for "#" prompt.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L95" class="blob-num js-line-number" data-line-number="95"></td>
<td id="LC95" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L96" class="blob-num js-line-number" data-line-number="96"></td>
<td id="LC96" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">False</span></td>
</tr>
<tr>
<td id="L97" class="blob-num js-line-number" data-line-number="97"></td>
<td id="LC97" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L98" class="blob-num js-line-number" data-line-number="98"></td>
<td id="LC98" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Getting the config</span></td>
</tr>
<tr>
<td id="L99" class="blob-num js-line-number" data-line-number="99"></td>
<td id="LC99" class="blob-code blob-code-inner js-file-line"> handler.sendline(<span class="pl-s"><span class="pl-pds">'</span>admin display-config<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L100" class="blob-num js-line-number" data-line-number="100"></td>
<td id="LC100" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L101" class="blob-num js-line-number" data-line-number="101"></td>
<td id="LC101" class="blob-code blob-code-inner js-file-line"> handler.expect(<span class="pl-s"><span class="pl-pds">'</span># Finished<span class="pl-pds">'</span></span>, <span class="pl-v">timeout</span> <span class="pl-k">=</span> longtimeout)</td>
</tr>
<tr>
<td id="L102" class="blob-num js-line-number" data-line-number="102"></td>
<td id="LC102" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span>:</td>
</tr>
<tr>
<td id="L103" class="blob-num js-line-number" data-line-number="103"></td>
<td id="LC103" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: error waiting for "#" prompt.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L104" class="blob-num js-line-number" data-line-number="104"></td>
<td id="LC104" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L105" class="blob-num js-line-number" data-line-number="105"></td>
<td id="LC105" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">False</span></td>
</tr>
<tr>
<td id="L106" class="blob-num js-line-number" data-line-number="106"></td>
<td id="LC106" class="blob-code blob-code-inner js-file-line"> config <span class="pl-k">=</span> handler.before.decode()</td>
</tr>
<tr>
<td id="L107" class="blob-num js-line-number" data-line-number="107"></td>
<td id="LC107" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Enable paging</span></td>
</tr>
<tr>
<td id="L108" class="blob-num js-line-number" data-line-number="108"></td>
<td id="LC108" class="blob-code blob-code-inner js-file-line"> handler.sendline(<span class="pl-s"><span class="pl-pds">'</span>environment more<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L109" class="blob-num js-line-number" data-line-number="109"></td>
<td id="LC109" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-c1">str</span>(datetime.now()))</td>
</tr>
<tr>
<td id="L110" class="blob-num js-line-number" data-line-number="110"></td>
<td id="LC110" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Manipulating the config</span></td>
</tr>
<tr>
<td id="L111" class="blob-num js-line-number" data-line-number="111"></td>
<td id="LC111" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span>config = re.sub('\r', '', config, flags=re.DOTALL) # Unix style</span></td>
</tr>
<tr>
<td id="L112" class="blob-num js-line-number" data-line-number="112"></td>
<td id="LC112" class="blob-code blob-code-inner js-file-line"> config <span class="pl-k">=</span> config.replace(<span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\r</span><span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L113" class="blob-num js-line-number" data-line-number="113"></td>
<td id="LC113" class="blob-code blob-code-inner js-file-line"> config <span class="pl-k">=</span> config.replace(<span class="pl-s"><span class="pl-pds">'</span>admin display-config<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L114" class="blob-num js-line-number" data-line-number="114"></td>
<td id="LC114" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span>config = re.sub('.*Using [0-9]+ out of [0-9]+ bytes\n', '', config, flags=re.DOTALL) # Header</span></td>
</tr>
<tr>
<td id="L115" class="blob-num js-line-number" data-line-number="115"></td>
<td id="LC115" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span>config = re.sub('.*admin display-config', '', config, flags=re.DOTALL) # Header</span></td>
</tr>
<tr>
<td id="L116" class="blob-num js-line-number" data-line-number="116"></td>
<td id="LC116" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span>config = re.sub('.*environment more\n', '', config, flags=re.DOTALL) # Footer</span></td>
</tr>
<tr>
<td id="L117" class="blob-num js-line-number" data-line-number="117"></td>
<td id="LC117" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span>config = re.sub('.*logout.*', '', config, flags=re.DOTALL) # Footer</span></td>
</tr>
<tr>
<td id="L118" class="blob-num js-line-number" data-line-number="118"></td>
<td id="LC118" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span>config = re.sub('!\nend.*', '!\nend\n', config, flags=re.DOTALL) # Footer</span></td>
</tr>
<tr>
<td id="L119" class="blob-num js-line-number" data-line-number="119"></td>
<td id="LC119" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-c1">str</span>(datetime.now()))</td>
</tr>
<tr>
<td id="L120" class="blob-num js-line-number" data-line-number="120"></td>
<td id="LC120" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> config</td>
</tr>
<tr>
<td id="L121" class="blob-num js-line-number" data-line-number="121"></td>
<td id="LC121" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L122" class="blob-num js-line-number" data-line-number="122"></td>
<td id="LC122" class="blob-code blob-code-inner js-file-line"><span class="pl-k">def</span> <span class="pl-en">config_put</span>(<span class="pl-smi">handler</span>):</td>
</tr>
<tr>
<td id="L123" class="blob-num js-line-number" data-line-number="123"></td>
<td id="LC123" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> <span class="pl-c1">True</span>:</td>
</tr>
<tr>
<td id="L124" class="blob-num js-line-number" data-line-number="124"></td>
<td id="LC124" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L125" class="blob-num js-line-number" data-line-number="125"></td>
<td id="LC125" class="blob-code blob-code-inner js-file-line"> i <span class="pl-k">=</span> handler.expect(<span class="pl-s"><span class="pl-pds">'</span>CVAC-4-CONFIG_DONE<span class="pl-pds">'</span></span>, timeout)</td>
</tr>
<tr>
<td id="L126" class="blob-num js-line-number" data-line-number="126"></td>
<td id="LC126" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span>:</td>
</tr>
<tr>
<td id="L127" class="blob-num js-line-number" data-line-number="127"></td>
<td id="LC127" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">False</span></td>
</tr>
<tr>
<td id="L128" class="blob-num js-line-number" data-line-number="128"></td>
<td id="LC128" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">True</span></td>
</tr>
<tr>
<td id="L129" class="blob-num js-line-number" data-line-number="129"></td>
<td id="LC129" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L130" class="blob-num js-line-number" data-line-number="130"></td>
<td id="LC130" class="blob-code blob-code-inner js-file-line"><span class="pl-k">def</span> <span class="pl-en">usage</span>():</td>
</tr>
<tr>
<td id="L131" class="blob-num js-line-number" data-line-number="131"></td>
<td id="LC131" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>Usage: <span class="pl-c1">%s</span> <standard options><span class="pl-pds">'</span></span> <span class="pl-k">%</span>(sys.argv[<span class="pl-c1">0</span>]))<span class="pl-bu">;</span></td>
</tr>
<tr>
<td id="L132" class="blob-num js-line-number" data-line-number="132"></td>
<td id="LC132" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>Standard Options:<span class="pl-pds">'</span></span>)<span class="pl-bu">;</span></td>
</tr>
<tr>
<td id="L133" class="blob-num js-line-number" data-line-number="133"></td>
<td id="LC133" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>-a <s> *Action can be:<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L134" class="blob-num js-line-number" data-line-number="134"></td>
<td id="LC134" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span> - get: get the startup-configuration and push it to a file<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L135" class="blob-num js-line-number" data-line-number="135"></td>
<td id="LC135" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span> - put: put the file as startup-configuration<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L136" class="blob-num js-line-number" data-line-number="136"></td>
<td id="LC136" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>-f <s> *File<span class="pl-pds">'</span></span>)<span class="pl-bu">;</span></td>
</tr>
<tr>
<td id="L137" class="blob-num js-line-number" data-line-number="137"></td>
<td id="LC137" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>-p <n> *Console port<span class="pl-pds">'</span></span>)<span class="pl-bu">;</span></td>
</tr>
<tr>
<td id="L138" class="blob-num js-line-number" data-line-number="138"></td>
<td id="LC138" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>-t <n> Timeout (default = <span class="pl-c1">%i</span>)<span class="pl-pds">'</span></span> <span class="pl-k">%</span>(timeout))<span class="pl-bu">;</span></td>
</tr>
<tr>
<td id="L139" class="blob-num js-line-number" data-line-number="139"></td>
<td id="LC139" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>* Mandatory option<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L140" class="blob-num js-line-number" data-line-number="140"></td>
<td id="LC140" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L141" class="blob-num js-line-number" data-line-number="141"></td>
<td id="LC141" class="blob-code blob-code-inner js-file-line"><span class="pl-k">def</span> <span class="pl-en">now</span>():</td>
</tr>
<tr>
<td id="L142" class="blob-num js-line-number" data-line-number="142"></td>
<td id="LC142" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Return current UNIX time in milliseconds</span></td>
</tr>
<tr>
<td id="L143" class="blob-num js-line-number" data-line-number="143"></td>
<td id="LC143" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">int</span>(<span class="pl-c1">round</span>(time.time() <span class="pl-k">*</span> <span class="pl-c1">1000</span>))</td>
</tr>
<tr>
<td id="L144" class="blob-num js-line-number" data-line-number="144"></td>
<td id="LC144" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L145" class="blob-num js-line-number" data-line-number="145"></td>
<td id="LC145" class="blob-code blob-code-inner js-file-line"><span class="pl-k">def</span> <span class="pl-en">main</span>(<span class="pl-smi">action</span>, <span class="pl-smi">fiename</span>, <span class="pl-smi">port</span>):</td>
</tr>
<tr>
<td id="L146" class="blob-num js-line-number" data-line-number="146"></td>
<td id="LC146" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L147" class="blob-num js-line-number" data-line-number="147"></td>
<td id="LC147" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Connect to the device</span></td>
</tr>
<tr>
<td id="L148" class="blob-num js-line-number" data-line-number="148"></td>
<td id="LC148" class="blob-code blob-code-inner js-file-line"> tmp <span class="pl-k">=</span> conntimeout</td>
</tr>
<tr>
<td id="L149" class="blob-num js-line-number" data-line-number="149"></td>
<td id="LC149" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (tmp <span class="pl-k">></span> <span class="pl-c1">0</span>):</td>
</tr>
<tr>
<td id="L150" class="blob-num js-line-number" data-line-number="150"></td>
<td id="LC150" class="blob-code blob-code-inner js-file-line"> handler <span class="pl-k">=</span> pexpect.spawn(<span class="pl-s"><span class="pl-pds">'</span>telnet 127.0.0.1 <span class="pl-c1">%i</span><span class="pl-pds">'</span></span> <span class="pl-k">%</span>(port))</td>
</tr>
<tr>
<td id="L151" class="blob-num js-line-number" data-line-number="151"></td>
<td id="LC151" class="blob-code blob-code-inner js-file-line"> time.sleep(<span class="pl-c1">0.1</span>)</td>
</tr>
<tr>
<td id="L152" class="blob-num js-line-number" data-line-number="152"></td>
<td id="LC152" class="blob-code blob-code-inner js-file-line"> tmp <span class="pl-k">=</span> tmp <span class="pl-k">-</span> <span class="pl-c1">0.1</span></td>
</tr>
<tr>
<td id="L153" class="blob-num js-line-number" data-line-number="153"></td>
<td id="LC153" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> handler.isalive() <span class="pl-k">==</span> <span class="pl-c1">True</span>:</td>
</tr>
<tr>
<td id="L154" class="blob-num js-line-number" data-line-number="154"></td>
<td id="LC154" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">break</span></td>
</tr>
<tr>
<td id="L155" class="blob-num js-line-number" data-line-number="155"></td>
<td id="LC155" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L156" class="blob-num js-line-number" data-line-number="156"></td>
<td id="LC156" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> (handler.isalive() <span class="pl-k">!=</span> <span class="pl-c1">True</span>):</td>
</tr>
<tr>
<td id="L157" class="blob-num js-line-number" data-line-number="157"></td>
<td id="LC157" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: cannot connect to port "<span class="pl-c1">%i</span>".<span class="pl-pds">'</span></span> <span class="pl-k">%</span>(port))</td>
</tr>
<tr>
<td id="L158" class="blob-num js-line-number" data-line-number="158"></td>
<td id="LC158" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L159" class="blob-num js-line-number" data-line-number="159"></td>
<td id="LC159" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L160" class="blob-num js-line-number" data-line-number="160"></td>
<td id="LC160" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L161" class="blob-num js-line-number" data-line-number="161"></td>
<td id="LC161" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> action <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>get<span class="pl-pds">'</span></span>:</td>
</tr>
<tr>
<td id="L162" class="blob-num js-line-number" data-line-number="162"></td>
<td id="LC162" class="blob-code blob-code-inner js-file-line"> rc <span class="pl-k">=</span> node_login(handler)</td>
</tr>
<tr>
<td id="L163" class="blob-num js-line-number" data-line-number="163"></td>
<td id="LC163" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> rc <span class="pl-k">!=</span> <span class="pl-c1">True</span>:</td>
</tr>
<tr>
<td id="L164" class="blob-num js-line-number" data-line-number="164"></td>
<td id="LC164" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: failed to login.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L165" class="blob-num js-line-number" data-line-number="165"></td>
<td id="LC165" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L166" class="blob-num js-line-number" data-line-number="166"></td>
<td id="LC166" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L167" class="blob-num js-line-number" data-line-number="167"></td>
<td id="LC167" class="blob-code blob-code-inner js-file-line"> config <span class="pl-k">=</span> config_get(handler)</td>
</tr>
<tr>
<td id="L168" class="blob-num js-line-number" data-line-number="168"></td>
<td id="LC168" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> config <span class="pl-k">in</span> [<span class="pl-c1">False</span>, <span class="pl-c1">None</span>]:</td>
</tr>
<tr>
<td id="L169" class="blob-num js-line-number" data-line-number="169"></td>
<td id="LC169" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: failed to retrieve config.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L170" class="blob-num js-line-number" data-line-number="170"></td>
<td id="LC170" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L171" class="blob-num js-line-number" data-line-number="171"></td>
<td id="LC171" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L172" class="blob-num js-line-number" data-line-number="172"></td>
<td id="LC172" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L173" class="blob-num js-line-number" data-line-number="173"></td>
<td id="LC173" class="blob-code blob-code-inner js-file-line"> fd <span class="pl-k">=</span> <span class="pl-c1">open</span>(filename, <span class="pl-s"><span class="pl-pds">'</span>a<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L174" class="blob-num js-line-number" data-line-number="174"></td>
<td id="LC174" class="blob-code blob-code-inner js-file-line"> fd.write(config)</td>
</tr>
<tr>
<td id="L175" class="blob-num js-line-number" data-line-number="175"></td>
<td id="LC175" class="blob-code blob-code-inner js-file-line"> fd.close()</td>
</tr>
<tr>
<td id="L176" class="blob-num js-line-number" data-line-number="176"></td>
<td id="LC176" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span>:</td>
</tr>
<tr>
<td id="L177" class="blob-num js-line-number" data-line-number="177"></td>
<td id="LC177" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: cannot write config to file.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L178" class="blob-num js-line-number" data-line-number="178"></td>
<td id="LC178" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L179" class="blob-num js-line-number" data-line-number="179"></td>
<td id="LC179" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L180" class="blob-num js-line-number" data-line-number="180"></td>
<td id="LC180" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">elif</span> action <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>put<span class="pl-pds">'</span></span>:</td>
</tr>
<tr>
<td id="L181" class="blob-num js-line-number" data-line-number="181"></td>
<td id="LC181" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Import Config is disabled here</span></td>
</tr>
<tr>
<td id="L182" class="blob-num js-line-number" data-line-number="182"></td>
<td id="LC182" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L183" class="blob-num js-line-number" data-line-number="183"></td>
<td id="LC183" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L184" class="blob-num js-line-number" data-line-number="184"></td>
<td id="LC184" class="blob-code blob-code-inner js-file-line"> rc <span class="pl-k">=</span> config_put(handler)</td>
</tr>
<tr>
<td id="L185" class="blob-num js-line-number" data-line-number="185"></td>
<td id="LC185" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> rc <span class="pl-k">!=</span> <span class="pl-c1">True</span>:</td>
</tr>
<tr>
<td id="L186" class="blob-num js-line-number" data-line-number="186"></td>
<td id="LC186" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: failed to push config.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L187" class="blob-num js-line-number" data-line-number="187"></td>
<td id="LC187" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L188" class="blob-num js-line-number" data-line-number="188"></td>
<td id="LC188" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L189" class="blob-num js-line-number" data-line-number="189"></td>
<td id="LC189" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L190" class="blob-num js-line-number" data-line-number="190"></td>
<td id="LC190" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Remove lock file</span></td>
</tr>
<tr>
<td id="L191" class="blob-num js-line-number" data-line-number="191"></td>
<td id="LC191" class="blob-code blob-code-inner js-file-line"> lock <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-c1">%s</span>/.lock<span class="pl-pds">'</span></span> <span class="pl-k">%</span>(os.path.dirname(filename))</td>
</tr>
<tr>
<td id="L192" class="blob-num js-line-number" data-line-number="192"></td>
<td id="LC192" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L193" class="blob-num js-line-number" data-line-number="193"></td>
<td id="LC193" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> os.path.exists(lock):</td>
</tr>
<tr>
<td id="L194" class="blob-num js-line-number" data-line-number="194"></td>
<td id="LC194" class="blob-code blob-code-inner js-file-line"> os.remove(lock)</td>
</tr>
<tr>
<td id="L195" class="blob-num js-line-number" data-line-number="195"></td>
<td id="LC195" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L196" class="blob-num js-line-number" data-line-number="196"></td>
<td id="LC196" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Mark as configured</span></td>
</tr>
<tr>
<td id="L197" class="blob-num js-line-number" data-line-number="197"></td>
<td id="LC197" class="blob-code blob-code-inner js-file-line"> configured <span class="pl-k">=</span> <span class="pl-s"><span class="pl-pds">'</span><span class="pl-c1">%s</span>/.configured<span class="pl-pds">'</span></span> <span class="pl-k">%</span>(os.path.dirname(filename))</td>
</tr>
<tr>
<td id="L198" class="blob-num js-line-number" data-line-number="198"></td>
<td id="LC198" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> <span class="pl-k">not</span> os.path.exists(configured):</td>
</tr>
<tr>
<td id="L199" class="blob-num js-line-number" data-line-number="199"></td>
<td id="LC199" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">open</span>(configured, <span class="pl-s"><span class="pl-pds">'</span>a<span class="pl-pds">'</span></span>).close()</td>
</tr>
<tr>
<td id="L200" class="blob-num js-line-number" data-line-number="200"></td>
<td id="LC200" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L201" class="blob-num js-line-number" data-line-number="201"></td>
<td id="LC201" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L202" class="blob-num js-line-number" data-line-number="202"></td>
<td id="LC202" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">0</span>)</td>
</tr>
<tr>
<td id="L203" class="blob-num js-line-number" data-line-number="203"></td>
<td id="LC203" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L204" class="blob-num js-line-number" data-line-number="204"></td>
<td id="LC204" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span> <span class="pl-c1">Exception</span> <span class="pl-k">as</span> e:</td>
</tr>
<tr>
<td id="L205" class="blob-num js-line-number" data-line-number="205"></td>
<td id="LC205" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: got an exception<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L206" class="blob-num js-line-number" data-line-number="206"></td>
<td id="LC206" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-c1">type</span>(e)) <span class="pl-c"><span class="pl-c">#</span> the exception instance</span></td>
</tr>
<tr>
<td id="L207" class="blob-num js-line-number" data-line-number="207"></td>
<td id="LC207" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(e.args) <span class="pl-c"><span class="pl-c">#</span> arguments stored in .args</span></td>
</tr>
<tr>
<td id="L208" class="blob-num js-line-number" data-line-number="208"></td>
<td id="LC208" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(e) <span class="pl-c"><span class="pl-c">#</span> __str__ allows args to be printed directly,</span></td>
</tr>
<tr>
<td id="L209" class="blob-num js-line-number" data-line-number="209"></td>
<td id="LC209" class="blob-code blob-code-inner js-file-line"> node_quit(handler)</td>
</tr>
<tr>
<td id="L210" class="blob-num js-line-number" data-line-number="210"></td>
<td id="LC210" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">return</span> <span class="pl-c1">False</span></td>
</tr>
<tr>
<td id="L211" class="blob-num js-line-number" data-line-number="211"></td>
<td id="LC211" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L212" class="blob-num js-line-number" data-line-number="212"></td>
<td id="LC212" class="blob-code blob-code-inner js-file-line"><span class="pl-k">if</span> <span class="pl-c1">__name__</span> <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">"</span>__main__<span class="pl-pds">"</span></span>:</td>
</tr>
<tr>
<td id="L213" class="blob-num js-line-number" data-line-number="213"></td>
<td id="LC213" class="blob-code blob-code-inner js-file-line"> action <span class="pl-k">=</span> <span class="pl-c1">None</span></td>
</tr>
<tr>
<td id="L214" class="blob-num js-line-number" data-line-number="214"></td>
<td id="LC214" class="blob-code blob-code-inner js-file-line"> filename <span class="pl-k">=</span> <span class="pl-c1">None</span></td>
</tr>
<tr>
<td id="L215" class="blob-num js-line-number" data-line-number="215"></td>
<td id="LC215" class="blob-code blob-code-inner js-file-line"> port <span class="pl-k">=</span> <span class="pl-c1">None</span></td>
</tr>
<tr>
<td id="L216" class="blob-num js-line-number" data-line-number="216"></td>
<td id="LC216" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L217" class="blob-num js-line-number" data-line-number="217"></td>
<td id="LC217" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Getting parameters from command line</span></td>
</tr>
<tr>
<td id="L218" class="blob-num js-line-number" data-line-number="218"></td>
<td id="LC218" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L219" class="blob-num js-line-number" data-line-number="219"></td>
<td id="LC219" class="blob-code blob-code-inner js-file-line"> opts, args <span class="pl-k">=</span> getopt.getopt(sys.argv[<span class="pl-c1">1</span>:], <span class="pl-s"><span class="pl-pds">'</span>a:p:t:f:<span class="pl-pds">'</span></span>, [<span class="pl-s"><span class="pl-pds">'</span>action=<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>port=<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>timeout=<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>file=<span class="pl-pds">'</span></span>])</td>
</tr>
<tr>
<td id="L220" class="blob-num js-line-number" data-line-number="220"></td>
<td id="LC220" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span> getopt.GetoptError <span class="pl-k">as</span> e:</td>
</tr>
<tr>
<td id="L221" class="blob-num js-line-number" data-line-number="221"></td>
<td id="LC221" class="blob-code blob-code-inner js-file-line"> usage()</td>
</tr>
<tr>
<td id="L222" class="blob-num js-line-number" data-line-number="222"></td>
<td id="LC222" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">3</span>)</td>
</tr>
<tr>
<td id="L223" class="blob-num js-line-number" data-line-number="223"></td>
<td id="LC223" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L224" class="blob-num js-line-number" data-line-number="224"></td>
<td id="LC224" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">for</span> o, a <span class="pl-k">in</span> opts:</td>
</tr>
<tr>
<td id="L225" class="blob-num js-line-number" data-line-number="225"></td>
<td id="LC225" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> o <span class="pl-k">in</span> (<span class="pl-s"><span class="pl-pds">'</span>-a<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>--action<span class="pl-pds">'</span></span>):</td>
</tr>
<tr>
<td id="L226" class="blob-num js-line-number" data-line-number="226"></td>
<td id="LC226" class="blob-code blob-code-inner js-file-line"> action <span class="pl-k">=</span> a</td>
</tr>
<tr>
<td id="L227" class="blob-num js-line-number" data-line-number="227"></td>
<td id="LC227" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">elif</span> o <span class="pl-k">in</span> (<span class="pl-s"><span class="pl-pds">'</span>-f<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>--file<span class="pl-pds">'</span></span>):</td>
</tr>
<tr>
<td id="L228" class="blob-num js-line-number" data-line-number="228"></td>
<td id="LC228" class="blob-code blob-code-inner js-file-line"> filename <span class="pl-k">=</span> a</td>
</tr>
<tr>
<td id="L229" class="blob-num js-line-number" data-line-number="229"></td>
<td id="LC229" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">elif</span> o <span class="pl-k">in</span> (<span class="pl-s"><span class="pl-pds">'</span>-p<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>--port<span class="pl-pds">'</span></span>):</td>
</tr>
<tr>
<td id="L230" class="blob-num js-line-number" data-line-number="230"></td>
<td id="LC230" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L231" class="blob-num js-line-number" data-line-number="231"></td>
<td id="LC231" class="blob-code blob-code-inner js-file-line"> port <span class="pl-k">=</span> <span class="pl-c1">int</span>(a)</td>
</tr>
<tr>
<td id="L232" class="blob-num js-line-number" data-line-number="232"></td>
<td id="LC232" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span>:</td>
</tr>
<tr>
<td id="L233" class="blob-num js-line-number" data-line-number="233"></td>
<td id="LC233" class="blob-code blob-code-inner js-file-line"> port <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span></td>
</tr>
<tr>
<td id="L234" class="blob-num js-line-number" data-line-number="234"></td>
<td id="LC234" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">elif</span> o <span class="pl-k">in</span> (<span class="pl-s"><span class="pl-pds">'</span>-t<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>--timeout<span class="pl-pds">'</span></span>):</td>
</tr>
<tr>
<td id="L235" class="blob-num js-line-number" data-line-number="235"></td>
<td id="LC235" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L236" class="blob-num js-line-number" data-line-number="236"></td>
<td id="LC236" class="blob-code blob-code-inner js-file-line"> timeout <span class="pl-k">=</span> <span class="pl-c1">int</span>(a) <span class="pl-k">*</span> <span class="pl-c1">1000</span></td>
</tr>
<tr>
<td id="L237" class="blob-num js-line-number" data-line-number="237"></td>
<td id="LC237" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span>:</td>
</tr>
<tr>
<td id="L238" class="blob-num js-line-number" data-line-number="238"></td>
<td id="LC238" class="blob-code blob-code-inner js-file-line"> timeout <span class="pl-k">=</span> <span class="pl-k">-</span><span class="pl-c1">1</span></td>
</tr>
<tr>
<td id="L239" class="blob-num js-line-number" data-line-number="239"></td>
<td id="LC239" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">else</span>:</td>
</tr>
<tr>
<td id="L240" class="blob-num js-line-number" data-line-number="240"></td>
<td id="LC240" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: invalid parameter.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L241" class="blob-num js-line-number" data-line-number="241"></td>
<td id="LC241" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L242" class="blob-num js-line-number" data-line-number="242"></td>
<td id="LC242" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Checking mandatory parameters</span></td>
</tr>
<tr>
<td id="L243" class="blob-num js-line-number" data-line-number="243"></td>
<td id="LC243" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> action <span class="pl-k">==</span> <span class="pl-c1">None</span> <span class="pl-k">or</span> port <span class="pl-k">==</span> <span class="pl-c1">None</span> <span class="pl-k">or</span> filename <span class="pl-k">==</span> <span class="pl-c1">None</span>:</td>
</tr>
<tr>
<td id="L244" class="blob-num js-line-number" data-line-number="244"></td>
<td id="LC244" class="blob-code blob-code-inner js-file-line"> usage()</td>
</tr>
<tr>
<td id="L245" class="blob-num js-line-number" data-line-number="245"></td>
<td id="LC245" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: missing mandatory parameters.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L246" class="blob-num js-line-number" data-line-number="246"></td>
<td id="LC246" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L247" class="blob-num js-line-number" data-line-number="247"></td>
<td id="LC247" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> action <span class="pl-k">not</span> <span class="pl-k">in</span> [<span class="pl-s"><span class="pl-pds">'</span>get<span class="pl-pds">'</span></span>, <span class="pl-s"><span class="pl-pds">'</span>put<span class="pl-pds">'</span></span>]:</td>
</tr>
<tr>
<td id="L248" class="blob-num js-line-number" data-line-number="248"></td>
<td id="LC248" class="blob-code blob-code-inner js-file-line"> usage()</td>
</tr>
<tr>
<td id="L249" class="blob-num js-line-number" data-line-number="249"></td>
<td id="LC249" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: invalid action.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L250" class="blob-num js-line-number" data-line-number="250"></td>
<td id="LC250" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L251" class="blob-num js-line-number" data-line-number="251"></td>
<td id="LC251" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> timeout <span class="pl-k"><</span> <span class="pl-c1">0</span>:</td>
</tr>
<tr>
<td id="L252" class="blob-num js-line-number" data-line-number="252"></td>
<td id="LC252" class="blob-code blob-code-inner js-file-line"> usage()</td>
</tr>
<tr>
<td id="L253" class="blob-num js-line-number" data-line-number="253"></td>
<td id="LC253" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: timeout must be 0 or higher.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L254" class="blob-num js-line-number" data-line-number="254"></td>
<td id="LC254" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L255" class="blob-num js-line-number" data-line-number="255"></td>
<td id="LC255" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> port <span class="pl-k"><</span> <span class="pl-c1">0</span>:</td>
</tr>
<tr>
<td id="L256" class="blob-num js-line-number" data-line-number="256"></td>
<td id="LC256" class="blob-code blob-code-inner js-file-line"> usage()</td>
</tr>
<tr>
<td id="L257" class="blob-num js-line-number" data-line-number="257"></td>
<td id="LC257" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: port must be 32768 or higher.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L258" class="blob-num js-line-number" data-line-number="258"></td>
<td id="LC258" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L259" class="blob-num js-line-number" data-line-number="259"></td>
<td id="LC259" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> action <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>get<span class="pl-pds">'</span></span> <span class="pl-k">and</span> os.path.exists(filename):</td>
</tr>
<tr>
<td id="L260" class="blob-num js-line-number" data-line-number="260"></td>
<td id="LC260" class="blob-code blob-code-inner js-file-line"> usage()</td>
</tr>
<tr>
<td id="L261" class="blob-num js-line-number" data-line-number="261"></td>
<td id="LC261" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: destination file already exists.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L262" class="blob-num js-line-number" data-line-number="262"></td>
<td id="LC262" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L263" class="blob-num js-line-number" data-line-number="263"></td>
<td id="LC263" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> action <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>put<span class="pl-pds">'</span></span> <span class="pl-k">and</span> <span class="pl-k">not</span> os.path.exists(filename):</td>
</tr>
<tr>
<td id="L264" class="blob-num js-line-number" data-line-number="264"></td>
<td id="LC264" class="blob-code blob-code-inner js-file-line"> usage()</td>
</tr>
<tr>
<td id="L265" class="blob-num js-line-number" data-line-number="265"></td>
<td id="LC265" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: source file does not already exist.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L266" class="blob-num js-line-number" data-line-number="266"></td>
<td id="LC266" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L267" class="blob-num js-line-number" data-line-number="267"></td>
<td id="LC267" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> action <span class="pl-k">==</span> <span class="pl-s"><span class="pl-pds">'</span>put<span class="pl-pds">'</span></span>:</td>
</tr>
<tr>
<td id="L268" class="blob-num js-line-number" data-line-number="268"></td>
<td id="LC268" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">try</span>:</td>
</tr>
<tr>
<td id="L269" class="blob-num js-line-number" data-line-number="269"></td>
<td id="LC269" class="blob-code blob-code-inner js-file-line"> fd <span class="pl-k">=</span> <span class="pl-c1">open</span>(filename, <span class="pl-s"><span class="pl-pds">'</span>r<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L270" class="blob-num js-line-number" data-line-number="270"></td>
<td id="LC270" class="blob-code blob-code-inner js-file-line"> config <span class="pl-k">=</span> fd.read()</td>
</tr>
<tr>
<td id="L271" class="blob-num js-line-number" data-line-number="271"></td>
<td id="LC271" class="blob-code blob-code-inner js-file-line"> fd.close()</td>
</tr>
<tr>
<td id="L272" class="blob-num js-line-number" data-line-number="272"></td>
<td id="LC272" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">except</span>:</td>
</tr>
<tr>
<td id="L273" class="blob-num js-line-number" data-line-number="273"></td>
<td id="LC273" class="blob-code blob-code-inner js-file-line"> usage()</td>
</tr>
<tr>
<td id="L274" class="blob-num js-line-number" data-line-number="274"></td>
<td id="LC274" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: cannot read from file.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L275" class="blob-num js-line-number" data-line-number="275"></td>
<td id="LC275" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L276" class="blob-num js-line-number" data-line-number="276"></td>
<td id="LC276" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L277" class="blob-num js-line-number" data-line-number="277"></td>
<td id="LC277" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Backgrounding the script</span></td>
</tr>
<tr>
<td id="L278" class="blob-num js-line-number" data-line-number="278"></td>
<td id="LC278" class="blob-code blob-code-inner js-file-line"> end_before <span class="pl-k">=</span> now() <span class="pl-k">+</span> timeout</td>
</tr>
<tr>
<td id="L279" class="blob-num js-line-number" data-line-number="279"></td>
<td id="LC279" class="blob-code blob-code-inner js-file-line"> p <span class="pl-k">=</span> multiprocessing.Process(<span class="pl-v">target</span><span class="pl-k">=</span>main, <span class="pl-v">name</span><span class="pl-k">=</span><span class="pl-s"><span class="pl-pds">"</span>Main<span class="pl-pds">"</span></span>, <span class="pl-v">args</span><span class="pl-k">=</span>(action, filename, port))</td>
</tr>
<tr>
<td id="L280" class="blob-num js-line-number" data-line-number="280"></td>
<td id="LC280" class="blob-code blob-code-inner js-file-line"> p.start()</td>
</tr>
<tr>
<td id="L281" class="blob-num js-line-number" data-line-number="281"></td>
<td id="LC281" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L282" class="blob-num js-line-number" data-line-number="282"></td>
<td id="LC282" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">while</span> (p.is_alive() <span class="pl-k">and</span> now() <span class="pl-k"><</span> end_before):</td>
</tr>
<tr>
<td id="L283" class="blob-num js-line-number" data-line-number="283"></td>
<td id="LC283" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Waiting for the child process to end</span></td>
</tr>
<tr>
<td id="L284" class="blob-num js-line-number" data-line-number="284"></td>
<td id="LC284" class="blob-code blob-code-inner js-file-line"> time.sleep(<span class="pl-c1">1</span>)</td>
</tr>
<tr>
<td id="L285" class="blob-num js-line-number" data-line-number="285"></td>
<td id="LC285" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L286" class="blob-num js-line-number" data-line-number="286"></td>
<td id="LC286" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> p.is_alive():</td>
</tr>
<tr>
<td id="L287" class="blob-num js-line-number" data-line-number="287"></td>
<td id="LC287" class="blob-code blob-code-inner js-file-line"> <span class="pl-c"><span class="pl-c">#</span> Timeout occurred</span></td>
</tr>
<tr>
<td id="L288" class="blob-num js-line-number" data-line-number="288"></td>
<td id="LC288" class="blob-code blob-code-inner js-file-line"> <span class="pl-c1">print</span>(<span class="pl-s"><span class="pl-pds">'</span>ERROR: timeout occurred.<span class="pl-pds">'</span></span>)</td>
</tr>
<tr>
<td id="L289" class="blob-num js-line-number" data-line-number="289"></td>
<td id="LC289" class="blob-code blob-code-inner js-file-line"> p.terminate()</td>
</tr>
<tr>
<td id="L290" class="blob-num js-line-number" data-line-number="290"></td>
<td id="LC290" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">127</span>)</td>
</tr>
<tr>
<td id="L291" class="blob-num js-line-number" data-line-number="291"></td>
<td id="LC291" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L292" class="blob-num js-line-number" data-line-number="292"></td>
<td id="LC292" class="blob-code blob-code-inner js-file-line"> <span class="pl-k">if</span> p.exitcode <span class="pl-k">!=</span> <span class="pl-c1">0</span>:</td>
</tr>
<tr>
<td id="L293" class="blob-num js-line-number" data-line-number="293"></td>
<td id="LC293" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">127</span>)</td>
</tr>
<tr>
<td id="L294" class="blob-num js-line-number" data-line-number="294"></td>
<td id="LC294" class="blob-code blob-code-inner js-file-line">
</td>
</tr>
<tr>
<td id="L295" class="blob-num js-line-number" data-line-number="295"></td>
<td id="LC295" class="blob-code blob-code-inner js-file-line"> sys.exit(<span class="pl-c1">0</span>)</td>
</tr>
</table>
</div>
</div>
<button type="button" data-facebox="#jump-to-line" data-facebox-class="linejump" data-hotkey="l" class="d-none">Jump to Line</button>
<div id="jump-to-line" style="display:none">
<!-- '"` --><!-- </textarea></xmp> --></option></form><form accept-charset="UTF-8" action="" class="js-jump-to-line-form" method="get"><div style="margin:0;padding:0;display:inline"><input name="utf8" type="hidden" value="✓" /></div>
<input class="form-control linejump-input js-jump-to-line-field" type="text" placeholder="Jump to line…" aria-label="Jump to line" autofocus>
<button type="submit" class="btn">Go</button>
</form></div>
</div>
<div class="modal-backdrop js-touch-events"></div>
</div>
</div>
</div>
</div>
<div class="container site-footer-container">
<div class="site-footer" role="contentinfo">
<ul class="site-footer-links float-right">
<li><a href="https://github.com/contact" data-ga-click="Footer, go to contact, text:contact">Contact GitHub</a></li>
<li><a href="https://developer.github.com" data-ga-click="Footer, go to api, text:api">API</a></li>
<li><a href="https://training.github.com" data-ga-click="Footer, go to training, text:training">Training</a></li>
<li><a href="https://shop.github.com" data-ga-click="Footer, go to shop, text:shop">Shop</a></li>
<li><a href="https://github.com/blog" data-ga-click="Footer, go to blog, text:blog">Blog</a></li>
<li><a href="https://github.com/about" data-ga-click="Footer, go to about, text:about">About</a></li>
</ul>
<a href="https://github.com" aria-label="Homepage" class="site-footer-mark" title="GitHub">
<svg aria-hidden="true" class="octicon octicon-mark-github" height="24" version="1.1" viewBox="0 0 16 16" width="24"><path fill-rule="evenodd" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0 0 16 8c0-4.42-3.58-8-8-8z"/></svg>
</a>
<ul class="site-footer-links">
<li>© 2017 <span title="0.05596s from github-fe-e627a19.cp1-iad.github.net">GitHub</span>, Inc.</li>
<li><a href="https://github.com/site/terms" data-ga-click="Footer, go to terms, text:terms">Terms</a></li>
<li><a href="https://github.com/site/privacy" data-ga-click="Footer, go to privacy, text:privacy">Privacy</a></li>
<li><a href="https://github.com/security" data-ga-click="Footer, go to security, text:security">Security</a></li>
<li><a href="https://status.github.com/" data-ga-click="Footer, go to status, text:status">Status</a></li>
<li><a href="https://help.github.com" data-ga-click="Footer, go to help, text:help">Help</a></li>
</ul>
</div>
</div>
<div id="ajax-error-message" class="ajax-error-message flash flash-error">
<svg aria-hidden="true" class="octicon octicon-alert" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M8.865 1.52c-.18-.31-.51-.5-.87-.5s-.69.19-.87.5L.275 13.5c-.18.31-.18.69 0 1 .19.31.52.5.87.5h13.7c.36 0 .69-.19.86-.5.17-.31.18-.69.01-1L8.865 1.52zM8.995 13h-2v-2h2v2zm0-3h-2V6h2v4z"/></svg>
<button type="button" class="flash-close js-flash-close js-ajax-error-dismiss" aria-label="Dismiss error">
<svg aria-hidden="true" class="octicon octicon-x" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M7.48 8l3.75 3.75-1.48 1.48L6 9.48l-3.75 3.75-1.48-1.48L4.52 8 .77 4.25l1.48-1.48L6 6.52l3.75-3.75 1.48 1.48z"/></svg>
</button>
You can't perform that action at this time.
</div>
<script crossorigin="anonymous" integrity="sha256-UGFpyy/nYlS5IejJRN1AblyrLXGeZX6s6K2phIYjFHI=" src="https://assets-cdn.github.com/assets/frameworks-506169cb2fe76254b921e8c944dd406e5cab2d719e657eace8ada98486231472.js"></script>
<script async="async" crossorigin="anonymous" integrity="sha256-JoKHHq/cp2qoENrGskMxUOT5pYEP0pMGxRSbKe+BzDE=" src="https://assets-cdn.github.com/assets/github-2682871eafdca76aa810dac6b2433150e4f9a5810fd29306c5149b29ef81cc31.js"></script>
<div class="js-stale-session-flash stale-session-flash flash flash-warn flash-banner d-none">
<svg aria-hidden="true" class="octicon octicon-alert" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M8.865 1.52c-.18-.31-.51-.5-.87-.5s-.69.19-.87.5L.275 13.5c-.18.31-.18.69 0 1 .19.31.52.5.87.5h13.7c.36 0 .69-.19.86-.5.17-.31.18-.69.01-1L8.865 1.52zM8.995 13h-2v-2h2v2zm0-3h-2V6h2v4z"/></svg>
<span class="signed-in-tab-flash">You signed in with another tab or window. <a href="">Reload</a> to refresh your session.</span>
<span class="signed-out-tab-flash">You signed out in another tab or window. <a href="">Reload</a> to refresh your session.</span>
</div>
<div class="facebox" id="facebox" style="display:none;">
<div class="facebox-popup">
<div class="facebox-content" role="dialog" aria-labelledby="facebox-header" aria-describedby="facebox-description">
</div>
<button type="button" class="facebox-close js-facebox-close" aria-label="Close modal">
<svg aria-hidden="true" class="octicon octicon-x" height="16" version="1.1" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M7.48 8l3.75 3.75-1.48 1.48L6 9.48l-3.75 3.75-1.48-1.48L4.52 8 .77 4.25l1.48-1.48L6 6.52l3.75-3.75 1.48 1.48z"/></svg>
</button>
</div>
</div>
</body>
</html>
| 64.223427 | 751 | 0.596953 |
628f7bc0f0f09241776a5b7eac5d9d28ebc47377 | 18,649 | py | Python | research/object_detection/predictors/convolutional_box_predictor.py | slomrafgrav/models | daa6c0415e47bdc52ad6434dc2bdb5d8aeb4f7ce | [
"Apache-2.0"
] | 79 | 2019-03-02T17:40:25.000Z | 2021-08-17T13:22:03.000Z | research/object_detection/predictors/convolutional_box_predictor.py | ywy0318/models | 91a59c78e8c48e8a1b2fec37143e52dae3f066c1 | [
"Apache-2.0"
] | 8 | 2019-05-14T10:10:50.000Z | 2020-12-20T14:05:29.000Z | research/object_detection/predictors/convolutional_box_predictor.py | ywy0318/models | 91a59c78e8c48e8a1b2fec37143e52dae3f066c1 | [
"Apache-2.0"
] | 27 | 2019-02-04T01:45:48.000Z | 2021-03-18T02:39:28.000Z | # Copyright 2017 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.
# ==============================================================================
"""Convolutional Box Predictors with and without weight sharing."""
import functools
import tensorflow as tf
from object_detection.core import box_predictor
from object_detection.utils import static_shape
slim = tf.contrib.slim
BOX_ENCODINGS = box_predictor.BOX_ENCODINGS
CLASS_PREDICTIONS_WITH_BACKGROUND = (
box_predictor.CLASS_PREDICTIONS_WITH_BACKGROUND)
MASK_PREDICTIONS = box_predictor.MASK_PREDICTIONS
class _NoopVariableScope(object):
"""A dummy class that does not push any scope."""
def __enter__(self):
return None
def __exit__(self, exc_type, exc_value, traceback):
return False
class ConvolutionalBoxPredictor(box_predictor.BoxPredictor):
"""Convolutional Box Predictor.
Optionally add an intermediate 1x1 convolutional layer after features and
predict in parallel branches box_encodings and
class_predictions_with_background.
Currently this box predictor assumes that predictions are "shared" across
classes --- that is each anchor makes box predictions which do not depend
on class.
"""
def __init__(self,
is_training,
num_classes,
box_prediction_head,
class_prediction_head,
other_heads,
conv_hyperparams_fn,
num_layers_before_predictor,
min_depth,
max_depth):
"""Constructor.
Args:
is_training: Indicates whether the BoxPredictor is in training mode.
num_classes: number of classes. Note that num_classes *does not*
include the background category, so if groundtruth labels take values
in {0, 1, .., K-1}, num_classes=K (and not K+1, even though the
assigned classification targets can range from {0,... K}).
box_prediction_head: The head that predicts the boxes.
class_prediction_head: The head that predicts the classes.
other_heads: A dictionary mapping head names to convolutional
head classes.
conv_hyperparams_fn: A function to generate tf-slim arg_scope with
hyperparameters for convolution ops.
num_layers_before_predictor: Number of the additional conv layers before
the predictor.
min_depth: Minimum feature depth prior to predicting box encodings
and class predictions.
max_depth: Maximum feature depth prior to predicting box encodings
and class predictions. If max_depth is set to 0, no additional
feature map will be inserted before location and class predictions.
Raises:
ValueError: if min_depth > max_depth.
"""
super(ConvolutionalBoxPredictor, self).__init__(is_training, num_classes)
self._box_prediction_head = box_prediction_head
self._class_prediction_head = class_prediction_head
self._other_heads = other_heads
self._conv_hyperparams_fn = conv_hyperparams_fn
self._min_depth = min_depth
self._max_depth = max_depth
self._num_layers_before_predictor = num_layers_before_predictor
@property
def num_classes(self):
return self._num_classes
def _predict(self, image_features, num_predictions_per_location_list):
"""Computes encoded object locations and corresponding confidences.
Args:
image_features: A list of float tensors of shape [batch_size, height_i,
width_i, channels_i] containing features for a batch of images.
num_predictions_per_location_list: A list of integers representing the
number of box predictions to be made per spatial location for each
feature map.
Returns:
box_encodings: A list of float tensors of shape
[batch_size, num_anchors_i, q, code_size] representing the location of
the objects, where q is 1 or the number of classes. Each entry in the
list corresponds to a feature map in the input `image_features` list.
class_predictions_with_background: A list of float tensors of shape
[batch_size, num_anchors_i, num_classes + 1] representing the class
predictions for the proposals. Each entry in the list corresponds to a
feature map in the input `image_features` list.
"""
predictions = {
BOX_ENCODINGS: [],
CLASS_PREDICTIONS_WITH_BACKGROUND: [],
}
for head_name in self._other_heads.keys():
predictions[head_name] = []
# TODO(rathodv): Come up with a better way to generate scope names
# in box predictor once we have time to retrain all models in the zoo.
# The following lines create scope names to be backwards compatible with the
# existing checkpoints.
box_predictor_scopes = [_NoopVariableScope()]
if len(image_features) > 1:
box_predictor_scopes = [
tf.variable_scope('BoxPredictor_{}'.format(i))
for i in range(len(image_features))
]
for (image_feature,
num_predictions_per_location, box_predictor_scope) in zip(
image_features, num_predictions_per_location_list,
box_predictor_scopes):
net = image_feature
with box_predictor_scope:
with slim.arg_scope(self._conv_hyperparams_fn()):
with slim.arg_scope([slim.dropout], is_training=self._is_training):
# Add additional conv layers before the class predictor.
features_depth = static_shape.get_depth(image_feature.get_shape())
depth = max(min(features_depth, self._max_depth), self._min_depth)
tf.logging.info('depth of additional conv before box predictor: {}'.
format(depth))
if depth > 0 and self._num_layers_before_predictor > 0:
for i in range(self._num_layers_before_predictor):
net = slim.conv2d(
net,
depth, [1, 1],
reuse=tf.AUTO_REUSE,
scope='Conv2d_%d_1x1_%d' % (i, depth))
sorted_keys = sorted(self._other_heads.keys())
sorted_keys.append(BOX_ENCODINGS)
sorted_keys.append(CLASS_PREDICTIONS_WITH_BACKGROUND)
for head_name in sorted_keys:
if head_name == BOX_ENCODINGS:
head_obj = self._box_prediction_head
elif head_name == CLASS_PREDICTIONS_WITH_BACKGROUND:
head_obj = self._class_prediction_head
else:
head_obj = self._other_heads[head_name]
prediction = head_obj.predict(
features=net,
num_predictions_per_location=num_predictions_per_location)
predictions[head_name].append(prediction)
return predictions
# TODO(rathodv): Replace with slim.arg_scope_func_key once its available
# externally.
def _arg_scope_func_key(op):
"""Returns a key that can be used to index arg_scope dictionary."""
return getattr(op, '_key_op', str(op))
# TODO(rathodv): Merge the implementation with ConvolutionalBoxPredictor above
# since they are very similar.
class WeightSharedConvolutionalBoxPredictor(box_predictor.BoxPredictor):
"""Convolutional Box Predictor with weight sharing.
Defines the box predictor as defined in
https://arxiv.org/abs/1708.02002. This class differs from
ConvolutionalBoxPredictor in that it shares weights and biases while
predicting from different feature maps. However, batch_norm parameters are not
shared because the statistics of the activations vary among the different
feature maps.
Also note that separate multi-layer towers are constructed for the box
encoding and class predictors respectively.
"""
def __init__(self,
is_training,
num_classes,
box_prediction_head,
class_prediction_head,
other_heads,
conv_hyperparams_fn,
depth,
num_layers_before_predictor,
kernel_size=3,
apply_batch_norm=False,
share_prediction_tower=False,
use_depthwise=False):
"""Constructor.
Args:
is_training: Indicates whether the BoxPredictor is in training mode.
num_classes: number of classes. Note that num_classes *does not*
include the background category, so if groundtruth labels take values
in {0, 1, .., K-1}, num_classes=K (and not K+1, even though the
assigned classification targets can range from {0,... K}).
box_prediction_head: The head that predicts the boxes.
class_prediction_head: The head that predicts the classes.
other_heads: A dictionary mapping head names to convolutional
head classes.
conv_hyperparams_fn: A function to generate tf-slim arg_scope with
hyperparameters for convolution ops.
depth: depth of conv layers.
num_layers_before_predictor: Number of the additional conv layers before
the predictor.
kernel_size: Size of final convolution kernel.
apply_batch_norm: Whether to apply batch normalization to conv layers in
this predictor.
share_prediction_tower: Whether to share the multi-layer tower between box
prediction and class prediction heads.
use_depthwise: Whether to use depthwise separable conv2d instead of
regular conv2d.
"""
super(WeightSharedConvolutionalBoxPredictor, self).__init__(is_training,
num_classes)
self._box_prediction_head = box_prediction_head
self._class_prediction_head = class_prediction_head
self._other_heads = other_heads
self._conv_hyperparams_fn = conv_hyperparams_fn
self._depth = depth
self._num_layers_before_predictor = num_layers_before_predictor
self._kernel_size = kernel_size
self._apply_batch_norm = apply_batch_norm
self._share_prediction_tower = share_prediction_tower
self._use_depthwise = use_depthwise
@property
def num_classes(self):
return self._num_classes
def _insert_additional_projection_layer(self, image_feature,
inserted_layer_counter,
target_channel):
if inserted_layer_counter < 0:
return image_feature, inserted_layer_counter
image_feature = slim.conv2d(
image_feature,
target_channel, [1, 1],
stride=1,
padding='SAME',
activation_fn=None,
normalizer_fn=(tf.identity if self._apply_batch_norm else None),
scope='ProjectionLayer/conv2d_{}'.format(
inserted_layer_counter))
if self._apply_batch_norm:
image_feature = slim.batch_norm(
image_feature,
scope='ProjectionLayer/conv2d_{}/BatchNorm'.format(
inserted_layer_counter))
inserted_layer_counter += 1
return image_feature, inserted_layer_counter
def _compute_base_tower(self, tower_name_scope, image_feature, feature_index,
has_different_feature_channels, target_channel,
inserted_layer_counter):
net = image_feature
for i in range(self._num_layers_before_predictor):
if self._use_depthwise:
conv_op = functools.partial(slim.separable_conv2d, depth_multiplier=1)
else:
conv_op = slim.conv2d
net = conv_op(
net,
self._depth, [self._kernel_size, self._kernel_size],
stride=1,
padding='SAME',
activation_fn=None,
normalizer_fn=(tf.identity if self._apply_batch_norm else None),
scope='{}/conv2d_{}'.format(tower_name_scope, i))
if self._apply_batch_norm:
net = slim.batch_norm(
net,
scope='{}/conv2d_{}/BatchNorm/feature_{}'.
format(tower_name_scope, i, feature_index))
net = tf.nn.relu6(net)
return net
def _predict_head(self, head_name, head_obj, image_feature, box_tower_feature,
feature_index, has_different_feature_channels,
target_channel, inserted_layer_counter,
num_predictions_per_location):
if head_name == CLASS_PREDICTIONS_WITH_BACKGROUND:
tower_name_scope = 'ClassPredictionTower'
else:
raise ValueError('Unknown head')
if self._share_prediction_tower:
head_tower_feature = box_tower_feature
else:
head_tower_feature = self._compute_base_tower(
tower_name_scope=tower_name_scope,
image_feature=image_feature,
feature_index=feature_index,
has_different_feature_channels=has_different_feature_channels,
target_channel=target_channel,
inserted_layer_counter=inserted_layer_counter)
return head_obj.predict(
features=head_tower_feature,
num_predictions_per_location=num_predictions_per_location)
def _predict(self, image_features, num_predictions_per_location_list):
"""Computes encoded object locations and corresponding confidences.
Args:
image_features: A list of float tensors of shape [batch_size, height_i,
width_i, channels] containing features for a batch of images. Note that
when not all tensors in the list have the same number of channels, an
additional projection layer will be added on top the tensor to generate
feature map with number of channels consitent with the majority.
num_predictions_per_location_list: A list of integers representing the
number of box predictions to be made per spatial location for each
feature map. Note that all values must be the same since the weights are
shared.
Returns:
A dictionary containing:
box_encodings: A list of float tensors of shape
[batch_size, num_anchors_i, code_size] representing the location of
the objects. Each entry in the list corresponds to a feature map in
the input `image_features` list.
class_predictions_with_background: A list of float tensors of shape
[batch_size, num_anchors_i, num_classes + 1] representing the class
predictions for the proposals. Each entry in the list corresponds to a
feature map in the input `image_features` list.
(optional) mask_predictions: A list of float tensors of shape
[batch_size, num_anchord_i, num_classes, mask_height, mask_width].
Raises:
ValueError: If the image feature maps do not have the same number of
channels or if the num predictions per locations is differs between the
feature maps.
"""
if len(set(num_predictions_per_location_list)) > 1:
raise ValueError('num predictions per location must be same for all'
'feature maps, found: {}'.format(
num_predictions_per_location_list))
feature_channels = [
image_feature.shape[3].value for image_feature in image_features
]
has_different_feature_channels = len(set(feature_channels)) > 1
if has_different_feature_channels:
inserted_layer_counter = 0
target_channel = max(set(feature_channels), key=feature_channels.count)
tf.logging.info('Not all feature maps have the same number of '
'channels, found: {}, addition project layers '
'to bring all feature maps to uniform channels '
'of {}'.format(feature_channels, target_channel))
else:
# Place holder variables if has_different_feature_channels is False.
target_channel = -1
inserted_layer_counter = -1
predictions = {
BOX_ENCODINGS: [],
CLASS_PREDICTIONS_WITH_BACKGROUND: [],
}
for head_name in self._other_heads.keys():
predictions[head_name] = []
for feature_index, (image_feature,
num_predictions_per_location) in enumerate(
zip(image_features,
num_predictions_per_location_list)):
with tf.variable_scope('WeightSharedConvolutionalBoxPredictor',
reuse=tf.AUTO_REUSE):
with slim.arg_scope(self._conv_hyperparams_fn()):
(image_feature,
inserted_layer_counter) = self._insert_additional_projection_layer(
image_feature, inserted_layer_counter, target_channel)
if self._share_prediction_tower:
box_tower_scope = 'PredictionTower'
else:
box_tower_scope = 'BoxPredictionTower'
box_tower_feature = self._compute_base_tower(
tower_name_scope=box_tower_scope,
image_feature=image_feature,
feature_index=feature_index,
has_different_feature_channels=has_different_feature_channels,
target_channel=target_channel,
inserted_layer_counter=inserted_layer_counter)
box_encodings = self._box_prediction_head.predict(
features=box_tower_feature,
num_predictions_per_location=num_predictions_per_location)
predictions[BOX_ENCODINGS].append(box_encodings)
sorted_keys = sorted(self._other_heads.keys())
sorted_keys.append(CLASS_PREDICTIONS_WITH_BACKGROUND)
for head_name in sorted_keys:
if head_name == CLASS_PREDICTIONS_WITH_BACKGROUND:
head_obj = self._class_prediction_head
else:
head_obj = self._other_heads[head_name]
prediction = self._predict_head(
head_name=head_name,
head_obj=head_obj,
image_feature=image_feature,
box_tower_feature=box_tower_feature,
feature_index=feature_index,
has_different_feature_channels=has_different_feature_channels,
target_channel=target_channel,
inserted_layer_counter=inserted_layer_counter,
num_predictions_per_location=num_predictions_per_location)
predictions[head_name].append(prediction)
return predictions
| 44.191943 | 80 | 0.683307 |
ed5595668309ee3b483734136db3df1982fa1b4e | 19,915 | py | Python | numpy_demo/ma/tests/test_mrecords.py | mpmkp2020/numpy_demo | 796262e06c84b7e9aa446b244a3faf3891d9ece1 | [
"BSD-3-Clause"
] | null | null | null | numpy_demo/ma/tests/test_mrecords.py | mpmkp2020/numpy_demo | 796262e06c84b7e9aa446b244a3faf3891d9ece1 | [
"BSD-3-Clause"
] | null | null | null | numpy_demo/ma/tests/test_mrecords.py | mpmkp2020/numpy_demo | 796262e06c84b7e9aa446b244a3faf3891d9ece1 | [
"BSD-3-Clause"
] | null | null | null | # pylint: disable-msg=W0611, W0612, W0511,R0201
"""Tests suite for mrecords.
:author: Pierre Gerard-Marchant
:contact: pierregm_at_uga_dot_edu
"""
import numpy_demo as np
import numpy_demo.ma as ma
from numpy_demo import recarray
from numpy_demo.ma import masked, nomask
from numpy_demo.testing import temppath
from numpy_demo.core.records import (
fromrecords as recfromrecords, fromarrays as recfromarrays
)
from numpy_demo.ma.mrecords import (
MaskedRecords, mrecarray, fromarrays, fromtextfile, fromrecords,
addfield
)
from numpy_demo.ma.testutils import (
assert_, assert_equal,
assert_equal_records,
)
from numpy_demo.compat import pickle
class TestMRecords:
ilist = [1, 2, 3, 4, 5]
flist = [1.1, 2.2, 3.3, 4.4, 5.5]
slist = [b'one', b'two', b'three', b'four', b'five']
ddtype = [('a', int), ('b', float), ('c', '|S8')]
mask = [0, 1, 0, 0, 1]
base = ma.array(list(zip(ilist, flist, slist)), mask=mask, dtype=ddtype)
def test_byview(self):
# Test creation by view
base = self.base
mbase = base.view(mrecarray)
assert_equal(mbase.recordmask, base.recordmask)
assert_equal_records(mbase._mask, base._mask)
assert_(isinstance(mbase._data, recarray))
assert_equal_records(mbase._data, base._data.view(recarray))
for field in ('a', 'b', 'c'):
assert_equal(base[field], mbase[field])
assert_equal_records(mbase.view(mrecarray), mbase)
def test_get(self):
# Tests fields retrieval
base = self.base.copy()
mbase = base.view(mrecarray)
# As fields..........
for field in ('a', 'b', 'c'):
assert_equal(getattr(mbase, field), mbase[field])
assert_equal(base[field], mbase[field])
# as elements .......
mbase_first = mbase[0]
assert_(isinstance(mbase_first, mrecarray))
assert_equal(mbase_first.dtype, mbase.dtype)
assert_equal(mbase_first.tolist(), (1, 1.1, b'one'))
# Used to be mask, now it's recordmask
assert_equal(mbase_first.recordmask, nomask)
assert_equal(mbase_first._mask.item(), (False, False, False))
assert_equal(mbase_first['a'], mbase['a'][0])
mbase_last = mbase[-1]
assert_(isinstance(mbase_last, mrecarray))
assert_equal(mbase_last.dtype, mbase.dtype)
assert_equal(mbase_last.tolist(), (None, None, None))
# Used to be mask, now it's recordmask
assert_equal(mbase_last.recordmask, True)
assert_equal(mbase_last._mask.item(), (True, True, True))
assert_equal(mbase_last['a'], mbase['a'][-1])
assert_((mbase_last['a'] is masked))
# as slice ..........
mbase_sl = mbase[:2]
assert_(isinstance(mbase_sl, mrecarray))
assert_equal(mbase_sl.dtype, mbase.dtype)
# Used to be mask, now it's recordmask
assert_equal(mbase_sl.recordmask, [0, 1])
assert_equal_records(mbase_sl.mask,
np.array([(False, False, False),
(True, True, True)],
dtype=mbase._mask.dtype))
assert_equal_records(mbase_sl, base[:2].view(mrecarray))
for field in ('a', 'b', 'c'):
assert_equal(getattr(mbase_sl, field), base[:2][field])
def test_set_fields(self):
# Tests setting fields.
base = self.base.copy()
mbase = base.view(mrecarray)
mbase = mbase.copy()
mbase.fill_value = (999999, 1e20, 'N/A')
# Change the data, the mask should be conserved
mbase.a._data[:] = 5
assert_equal(mbase['a']._data, [5, 5, 5, 5, 5])
assert_equal(mbase['a']._mask, [0, 1, 0, 0, 1])
# Change the elements, and the mask will follow
mbase.a = 1
assert_equal(mbase['a']._data, [1]*5)
assert_equal(ma.getmaskarray(mbase['a']), [0]*5)
# Use to be _mask, now it's recordmask
assert_equal(mbase.recordmask, [False]*5)
assert_equal(mbase._mask.tolist(),
np.array([(0, 0, 0),
(0, 1, 1),
(0, 0, 0),
(0, 0, 0),
(0, 1, 1)],
dtype=bool))
# Set a field to mask ........................
mbase.c = masked
# Use to be mask, and now it's still mask !
assert_equal(mbase.c.mask, [1]*5)
assert_equal(mbase.c.recordmask, [1]*5)
assert_equal(ma.getmaskarray(mbase['c']), [1]*5)
assert_equal(ma.getdata(mbase['c']), [b'N/A']*5)
assert_equal(mbase._mask.tolist(),
np.array([(0, 0, 1),
(0, 1, 1),
(0, 0, 1),
(0, 0, 1),
(0, 1, 1)],
dtype=bool))
# Set fields by slices .......................
mbase = base.view(mrecarray).copy()
mbase.a[3:] = 5
assert_equal(mbase.a, [1, 2, 3, 5, 5])
assert_equal(mbase.a._mask, [0, 1, 0, 0, 0])
mbase.b[3:] = masked
assert_equal(mbase.b, base['b'])
assert_equal(mbase.b._mask, [0, 1, 0, 1, 1])
# Set fields globally..........................
ndtype = [('alpha', '|S1'), ('num', int)]
data = ma.array([('a', 1), ('b', 2), ('c', 3)], dtype=ndtype)
rdata = data.view(MaskedRecords)
val = ma.array([10, 20, 30], mask=[1, 0, 0])
rdata['num'] = val
assert_equal(rdata.num, val)
assert_equal(rdata.num.mask, [1, 0, 0])
def test_set_fields_mask(self):
# Tests setting the mask of a field.
base = self.base.copy()
# This one has already a mask....
mbase = base.view(mrecarray)
mbase['a'][-2] = masked
assert_equal(mbase.a, [1, 2, 3, 4, 5])
assert_equal(mbase.a._mask, [0, 1, 0, 1, 1])
# This one has not yet
mbase = fromarrays([np.arange(5), np.random.rand(5)],
dtype=[('a', int), ('b', float)])
mbase['a'][-2] = masked
assert_equal(mbase.a, [0, 1, 2, 3, 4])
assert_equal(mbase.a._mask, [0, 0, 0, 1, 0])
def test_set_mask(self):
base = self.base.copy()
mbase = base.view(mrecarray)
# Set the mask to True .......................
mbase.mask = masked
assert_equal(ma.getmaskarray(mbase['b']), [1]*5)
assert_equal(mbase['a']._mask, mbase['b']._mask)
assert_equal(mbase['a']._mask, mbase['c']._mask)
assert_equal(mbase._mask.tolist(),
np.array([(1, 1, 1)]*5, dtype=bool))
# Delete the mask ............................
mbase.mask = nomask
assert_equal(ma.getmaskarray(mbase['c']), [0]*5)
assert_equal(mbase._mask.tolist(),
np.array([(0, 0, 0)]*5, dtype=bool))
def test_set_mask_fromarray(self):
base = self.base.copy()
mbase = base.view(mrecarray)
# Sets the mask w/ an array
mbase.mask = [1, 0, 0, 0, 1]
assert_equal(mbase.a.mask, [1, 0, 0, 0, 1])
assert_equal(mbase.b.mask, [1, 0, 0, 0, 1])
assert_equal(mbase.c.mask, [1, 0, 0, 0, 1])
# Yay, once more !
mbase.mask = [0, 0, 0, 0, 1]
assert_equal(mbase.a.mask, [0, 0, 0, 0, 1])
assert_equal(mbase.b.mask, [0, 0, 0, 0, 1])
assert_equal(mbase.c.mask, [0, 0, 0, 0, 1])
def test_set_mask_fromfields(self):
mbase = self.base.copy().view(mrecarray)
nmask = np.array(
[(0, 1, 0), (0, 1, 0), (1, 0, 1), (1, 0, 1), (0, 0, 0)],
dtype=[('a', bool), ('b', bool), ('c', bool)])
mbase.mask = nmask
assert_equal(mbase.a.mask, [0, 0, 1, 1, 0])
assert_equal(mbase.b.mask, [1, 1, 0, 0, 0])
assert_equal(mbase.c.mask, [0, 0, 1, 1, 0])
# Reinitialize and redo
mbase.mask = False
mbase.fieldmask = nmask
assert_equal(mbase.a.mask, [0, 0, 1, 1, 0])
assert_equal(mbase.b.mask, [1, 1, 0, 0, 0])
assert_equal(mbase.c.mask, [0, 0, 1, 1, 0])
def test_set_elements(self):
base = self.base.copy()
# Set an element to mask .....................
mbase = base.view(mrecarray).copy()
mbase[-2] = masked
assert_equal(
mbase._mask.tolist(),
np.array([(0, 0, 0), (1, 1, 1), (0, 0, 0), (1, 1, 1), (1, 1, 1)],
dtype=bool))
# Used to be mask, now it's recordmask!
assert_equal(mbase.recordmask, [0, 1, 0, 1, 1])
# Set slices .................................
mbase = base.view(mrecarray).copy()
mbase[:2] = (5, 5, 5)
assert_equal(mbase.a._data, [5, 5, 3, 4, 5])
assert_equal(mbase.a._mask, [0, 0, 0, 0, 1])
assert_equal(mbase.b._data, [5., 5., 3.3, 4.4, 5.5])
assert_equal(mbase.b._mask, [0, 0, 0, 0, 1])
assert_equal(mbase.c._data,
[b'5', b'5', b'three', b'four', b'five'])
assert_equal(mbase.b._mask, [0, 0, 0, 0, 1])
mbase = base.view(mrecarray).copy()
mbase[:2] = masked
assert_equal(mbase.a._data, [1, 2, 3, 4, 5])
assert_equal(mbase.a._mask, [1, 1, 0, 0, 1])
assert_equal(mbase.b._data, [1.1, 2.2, 3.3, 4.4, 5.5])
assert_equal(mbase.b._mask, [1, 1, 0, 0, 1])
assert_equal(mbase.c._data,
[b'one', b'two', b'three', b'four', b'five'])
assert_equal(mbase.b._mask, [1, 1, 0, 0, 1])
def test_setslices_hardmask(self):
# Tests setting slices w/ hardmask.
base = self.base.copy()
mbase = base.view(mrecarray)
mbase.harden_mask()
try:
mbase[-2:] = (5, 5, 5)
assert_equal(mbase.a._data, [1, 2, 3, 5, 5])
assert_equal(mbase.b._data, [1.1, 2.2, 3.3, 5, 5.5])
assert_equal(mbase.c._data,
[b'one', b'two', b'three', b'5', b'five'])
assert_equal(mbase.a._mask, [0, 1, 0, 0, 1])
assert_equal(mbase.b._mask, mbase.a._mask)
assert_equal(mbase.b._mask, mbase.c._mask)
except NotImplementedError:
# OK, not implemented yet...
pass
except AssertionError:
raise
else:
raise Exception("Flexible hard masks should be supported !")
# Not using a tuple should crash
try:
mbase[-2:] = 3
except (NotImplementedError, TypeError):
pass
else:
raise TypeError("Should have expected a readable buffer object!")
def test_hardmask(self):
# Test hardmask
base = self.base.copy()
mbase = base.view(mrecarray)
mbase.harden_mask()
assert_(mbase._hardmask)
mbase.mask = nomask
assert_equal_records(mbase._mask, base._mask)
mbase.soften_mask()
assert_(not mbase._hardmask)
mbase.mask = nomask
# So, the mask of a field is no longer set to nomask...
assert_equal_records(mbase._mask,
ma.make_mask_none(base.shape, base.dtype))
assert_(ma.make_mask(mbase['b']._mask) is nomask)
assert_equal(mbase['a']._mask, mbase['b']._mask)
def test_pickling(self):
# Test pickling
base = self.base.copy()
mrec = base.view(mrecarray)
for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
_ = pickle.dumps(mrec, protocol=proto)
mrec_ = pickle.loads(_)
assert_equal(mrec_.dtype, mrec.dtype)
assert_equal_records(mrec_._data, mrec._data)
assert_equal(mrec_._mask, mrec._mask)
assert_equal_records(mrec_._mask, mrec._mask)
def test_filled(self):
# Test filling the array
_a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
_b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
_c = ma.array(['one', 'two', 'three'], mask=[0, 0, 1], dtype='|S8')
ddtype = [('a', int), ('b', float), ('c', '|S8')]
mrec = fromarrays([_a, _b, _c], dtype=ddtype,
fill_value=(99999, 99999., 'N/A'))
mrecfilled = mrec.filled()
assert_equal(mrecfilled['a'], np.array((1, 2, 99999), dtype=int))
assert_equal(mrecfilled['b'], np.array((1.1, 2.2, 99999.),
dtype=float))
assert_equal(mrecfilled['c'], np.array(('one', 'two', 'N/A'),
dtype='|S8'))
def test_tolist(self):
# Test tolist.
_a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
_b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
_c = ma.array(['one', 'two', 'three'], mask=[1, 0, 0], dtype='|S8')
ddtype = [('a', int), ('b', float), ('c', '|S8')]
mrec = fromarrays([_a, _b, _c], dtype=ddtype,
fill_value=(99999, 99999., 'N/A'))
assert_equal(mrec.tolist(),
[(1, 1.1, None), (2, 2.2, b'two'),
(None, None, b'three')])
def test_withnames(self):
# Test the creation w/ format and names
x = mrecarray(1, formats=float, names='base')
x[0]['base'] = 10
assert_equal(x['base'][0], 10)
def test_exotic_formats(self):
# Test that 'exotic' formats are processed properly
easy = mrecarray(1, dtype=[('i', int), ('s', '|S8'), ('f', float)])
easy[0] = masked
assert_equal(easy.filled(1).item(), (1, b'1', 1.))
solo = mrecarray(1, dtype=[('f0', '<f8', (2, 2))])
solo[0] = masked
assert_equal(solo.filled(1).item(),
np.array((1,), dtype=solo.dtype).item())
mult = mrecarray(2, dtype="i4, (2,3)float, float")
mult[0] = masked
mult[1] = (1, 1, 1)
mult.filled(0)
assert_equal_records(mult.filled(0),
np.array([(0, 0, 0), (1, 1, 1)],
dtype=mult.dtype))
class TestView:
def setup(self):
(a, b) = (np.arange(10), np.random.rand(10))
ndtype = [('a', float), ('b', float)]
arr = np.array(list(zip(a, b)), dtype=ndtype)
mrec = fromarrays([a, b], dtype=ndtype, fill_value=(-9., -99.))
mrec.mask[3] = (False, True)
self.data = (mrec, a, b, arr)
def test_view_by_itself(self):
(mrec, a, b, arr) = self.data
test = mrec.view()
assert_(isinstance(test, MaskedRecords))
assert_equal_records(test, mrec)
assert_equal_records(test._mask, mrec._mask)
def test_view_simple_dtype(self):
(mrec, a, b, arr) = self.data
ntype = (float, 2)
test = mrec.view(ntype)
assert_(isinstance(test, ma.MaskedArray))
assert_equal(test, np.array(list(zip(a, b)), dtype=float))
assert_(test[3, 1] is ma.masked)
def test_view_flexible_type(self):
(mrec, a, b, arr) = self.data
alttype = [('A', float), ('B', float)]
test = mrec.view(alttype)
assert_(isinstance(test, MaskedRecords))
assert_equal_records(test, arr.view(alttype))
assert_(test['B'][3] is masked)
assert_equal(test.dtype, np.dtype(alttype))
assert_(test._fill_value is None)
##############################################################################
class TestMRecordsImport:
_a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
_b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
_c = ma.array([b'one', b'two', b'three'],
mask=[0, 0, 1], dtype='|S8')
ddtype = [('a', int), ('b', float), ('c', '|S8')]
mrec = fromarrays([_a, _b, _c], dtype=ddtype,
fill_value=(b'99999', b'99999.',
b'N/A'))
nrec = recfromarrays((_a._data, _b._data, _c._data), dtype=ddtype)
data = (mrec, nrec, ddtype)
def test_fromarrays(self):
_a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
_b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
_c = ma.array(['one', 'two', 'three'], mask=[0, 0, 1], dtype='|S8')
(mrec, nrec, _) = self.data
for (f, l) in zip(('a', 'b', 'c'), (_a, _b, _c)):
assert_equal(getattr(mrec, f)._mask, l._mask)
# One record only
_x = ma.array([1, 1.1, 'one'], mask=[1, 0, 0],)
assert_equal_records(fromarrays(_x, dtype=mrec.dtype), mrec[0])
def test_fromrecords(self):
# Test construction from records.
(mrec, nrec, ddtype) = self.data
#......
palist = [(1, 'abc', 3.7000002861022949, 0),
(2, 'xy', 6.6999998092651367, 1),
(0, ' ', 0.40000000596046448, 0)]
pa = recfromrecords(palist, names='c1, c2, c3, c4')
mpa = fromrecords(palist, names='c1, c2, c3, c4')
assert_equal_records(pa, mpa)
#.....
_mrec = fromrecords(nrec)
assert_equal(_mrec.dtype, mrec.dtype)
for field in _mrec.dtype.names:
assert_equal(getattr(_mrec, field), getattr(mrec._data, field))
_mrec = fromrecords(nrec.tolist(), names='c1,c2,c3')
assert_equal(_mrec.dtype, [('c1', int), ('c2', float), ('c3', '|S5')])
for (f, n) in zip(('c1', 'c2', 'c3'), ('a', 'b', 'c')):
assert_equal(getattr(_mrec, f), getattr(mrec._data, n))
_mrec = fromrecords(mrec)
assert_equal(_mrec.dtype, mrec.dtype)
assert_equal_records(_mrec._data, mrec.filled())
assert_equal_records(_mrec._mask, mrec._mask)
def test_fromrecords_wmask(self):
# Tests construction from records w/ mask.
(mrec, nrec, ddtype) = self.data
_mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=[0, 1, 0,])
assert_equal_records(_mrec._data, mrec._data)
assert_equal(_mrec._mask.tolist(), [(0, 0, 0), (1, 1, 1), (0, 0, 0)])
_mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=True)
assert_equal_records(_mrec._data, mrec._data)
assert_equal(_mrec._mask.tolist(), [(1, 1, 1), (1, 1, 1), (1, 1, 1)])
_mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=mrec._mask)
assert_equal_records(_mrec._data, mrec._data)
assert_equal(_mrec._mask.tolist(), mrec._mask.tolist())
_mrec = fromrecords(nrec.tolist(), dtype=ddtype,
mask=mrec._mask.tolist())
assert_equal_records(_mrec._data, mrec._data)
assert_equal(_mrec._mask.tolist(), mrec._mask.tolist())
def test_fromtextfile(self):
# Tests reading from a text file.
fcontent = (
"""#
'One (S)','Two (I)','Three (F)','Four (M)','Five (-)','Six (C)'
'strings',1,1.0,'mixed column',,1
'with embedded "double quotes"',2,2.0,1.0,,1
'strings',3,3.0E5,3,,1
'strings',4,-1e-10,,,1
""")
with temppath() as path:
with open(path, 'w') as f:
f.write(fcontent)
mrectxt = fromtextfile(path, delimitor=',', varnames='ABCDEFG')
assert_(isinstance(mrectxt, MaskedRecords))
assert_equal(mrectxt.F, [1, 1, 1, 1])
assert_equal(mrectxt.E._mask, [1, 1, 1, 1])
assert_equal(mrectxt.C, [1, 2, 3.e+5, -1e-10])
def test_addfield(self):
# Tests addfield
(mrec, nrec, ddtype) = self.data
(d, m) = ([100, 200, 300], [1, 0, 0])
mrec = addfield(mrec, ma.array(d, mask=m))
assert_equal(mrec.f3, d)
assert_equal(mrec.f3._mask, m)
def test_record_array_with_object_field():
# Trac #1839
y = ma.masked_array(
[(1, '2'), (3, '4')],
mask=[(0, 0), (0, 1)],
dtype=[('a', int), ('b', object)])
# getting an item used to fail
y[1]
| 40.313765 | 78 | 0.527994 |
5d892be1bcdb1f55b8f4e7fbe1b8071405e9fc38 | 2,132 | py | Python | tehbot/plugins/hs.py | tehron/tehbot | 4c097366c9afbbe2da8f629b86f84af9cb300644 | [
"MIT"
] | 6 | 2015-08-25T18:24:23.000Z | 2022-03-03T17:49:43.000Z | tehbot/plugins/hs.py | tehron/tehbot | 4c097366c9afbbe2da8f629b86f84af9cb300644 | [
"MIT"
] | 3 | 2018-09-10T13:46:51.000Z | 2019-11-10T18:23:41.000Z | tehbot/plugins/hs.py | tehron/tehbot | 4c097366c9afbbe2da8f629b86f84af9cb300644 | [
"MIT"
] | 3 | 2015-08-27T21:00:10.000Z | 2022-01-31T17:39:58.000Z | # -*- coding: utf-8 -*-
from tehbot.plugins import *
import urllib.request, urllib.parse, urllib.error
import urllib.request, urllib.error, urllib.parse
import ssl
import lxml.html
import re
from pony.orm import *
from datetime import datetime, timedelta
class HsPoller(Poller):
@db_session
def create_entities(self):
class HsPollerLastSolves(self.db.Entity):
ts = Required(datetime)
user = Required(str)
challenge = Required(str)
class HsPollerForum(self.db.Entity):
ts = Required(datetime)
title = Required(str)
url = Required(str)
who = Required(str)
def execute(self, connection, event, extra):
url = "https://www.happy-security.de/index.php?modul=hacking-zone"
try:
reply = urllib.request.urlopen(url, timeout=5)
except (urllib.error.URLError, ssl.SSLError):
# ignore stupid SSL errors
return
tree = lxml.html.parse(reply)
last_solves = []
for si in tree.xpath("//table[@class='mtable']/tr/td[2]"):
match = re.search(r'(.*?) eingesendet von .* zuletzt gelöst von (.*?) am (\d+\.\d+\.\d+ \d+:\d+) Uhr', " ".join(si.text_content().split()))
if match is not None:
ts = datetime.strptime(match.group(3).strip(), "%d.%m.%Y %H:%M")
who = match.group(2).strip()
chall = match.group(1).strip()
last_solves.append((ts, who, chall))
msgs = []
with db_session:
for ts, who, chall in last_solves:
if not select(s for s in self.db.HsPollerLastSolves if s.ts == ts and s.user == who and s.challenge == chall):
self.db.HsPollerLastSolves(ts=ts, user=who, challenge=chall)
if datetime.now() - ts < timedelta(days=2):
msgs.append(Plugin.green("[Happy-Security Solutions]") + " %s has just solved %s." % (Plugin.bold(who), Plugin.bold(chall)))
msg = "\n".join(msgs)
if msg:
return [("announce", (self.where(), msg))]
| 38.071429 | 151 | 0.568949 |
5ad61d2e001a0065a68dc70ec1b7cf0d77da6617 | 5,139 | py | Python | gpMgmt/bin/gppylib/operations/test/unit/test_unit_utils.py | kmacoskey/gpdb | fdf8b611576d89d52f4c64e4e68ab826cac81d5d | [
"PostgreSQL",
"Apache-2.0"
] | 1 | 2022-03-07T02:51:44.000Z | 2022-03-07T02:51:44.000Z | gpMgmt/bin/gppylib/operations/test/unit/test_unit_utils.py | kmacoskey/gpdb | fdf8b611576d89d52f4c64e4e68ab826cac81d5d | [
"PostgreSQL",
"Apache-2.0"
] | 2 | 2019-03-02T16:16:00.000Z | 2019-03-20T05:52:31.000Z | gpMgmt/bin/gppylib/operations/test/unit/test_unit_utils.py | kmacoskey/gpdb | fdf8b611576d89d52f4c64e4e68ab826cac81d5d | [
"PostgreSQL",
"Apache-2.0"
] | null | null | null | #!/usr/bin/env python
#
# Copyright (c) Greenplum Inc 2008. All Rights Reserved.
#
import sys
from gppylib.commands.base import ExecutionError
from gppylib.operations.utils import RemoteOperation, ParallelOperation
from gppylib.operations.test_utils_helper import TestOperation, RaiseOperation, RaiseOperation_Nested, \
RaiseOperation_Unsafe, RaiseOperation_Unpicklable, RaiseOperation_Safe, MyException, ExceptionWithArgs
from operations.unix import ListFiles
from test.unit.gp_unittest import GpTestCase, run_tests
from mock import patch, MagicMock
class UtilsTestCase(GpTestCase):
"""
Requires GPHOME set. Does actual ssh to localhost.
"""
def setUp(self):
self.old_sys_argv = sys.argv
sys.argv = ['utils.py']
def tearDown(self):
sys.argv = self.old_sys_argv
def test_Remote_basic(self):
""" Basic RemoteOperation test """
self.assertTrue(TestOperation().run() == RemoteOperation(TestOperation(), "localhost").run())
def test_Remote_exceptions(self):
""" Test that an Exception returned remotely will be raised locally. """
with self.assertRaises(Exception):
RemoteOperation(RaiseOperation(), "localhost").run()
def test_inner_exceptions(self):
""" Verify that an object not at the global level of this file cannot be pickled properly. """
try:
RemoteOperation(RaiseOperation_Nested(), "localhost").run()
except ExecutionError, e:
self.assertTrue(e.cmd.get_results().stderr.strip().endswith("raise RaiseOperation_Nested.MyException2()"))
else:
self.fail(
"A PicklingError should have been caused remotely, because RaiseOperation_Nested is not at the global-level.")
def test_unsafe_exceptions_with_args(self):
try:
RemoteOperation(RaiseOperation_Unsafe(), "localhost").run()
except TypeError, e: # Because Exceptions don't retain init args, they are not pickle-able normally
pass
else:
self.fail(
"RaiseOperation_Unsafe should have caused a TypeError, due to an improper Exception idiom. See test_utils.ExceptionWithArgsUnsafe")
def test_proper_exceptions_sanity(self):
try:
RemoteOperation(RaiseOperation_Safe(), "localhost").run()
except ExceptionWithArgs, e:
pass
else:
self.fail("ExceptionWithArgs should have been successfully raised + caught, because proper idiom is used.")
def test_proper_exceptions_with_args(self):
try:
RemoteOperation(RaiseOperation_Safe(), "localhost").run()
except ExceptionWithArgs, e:
self.assertTrue(e.x == 1 and e.y == 2)
else:
self.fail("RaiseOperation_Safe should have thrown ExceptionWithArgs(1, 2)")
# It is crucial that the RMI is debuggable!
def test_Remote_harden(self):
""" Ensure that some logging occurs in event of error. """
# One case encountered thus far is the raising of a pygresql DatabaseError,
# which due to the import from a shared object (I think), does not behave
# nicely in terms of imports and namespacing. """
try:
RemoteOperation(RaiseOperation_Unpicklable(), "localhost").run()
except ExecutionError, e:
self.assertTrue(e.cmd.get_results().stderr.strip().endswith("raise pg.DatabaseError()"))
else:
self.fail("""A pg.DatabaseError should have been raised remotely, and because it cannot
be pickled cleanly (due to a strange import in pickle.py),
an ExecutionError should have ultimately been caused.""")
# TODO: Check logs on disk. With gplogfilter?
def test_ParallelOperation_succeeds(self):
ops = ParallelOperation([ListFiles("/tmp")], 1)
ops.run()
self.assertTrue(len(ops.operations[0].get_ret()) > 0)
def test_ParallelOperation_handles_empty_operations_successfully(self):
ParallelOperation([]).run()
ParallelOperation([], 0).run()
ops = ParallelOperation([], 1)
ops.run()
self.assertTrue(len(ops.operations) == 0)
self.assertTrue(ops.parallelism == 0)
def test_ParallelOperation_with_operation_but_no_threads_raises(self):
with self.assertRaises(Exception):
ParallelOperation([ListFiles("/tmp")], 0).run()
@patch('gppylib.commands.base.logger.debug')
@patch('pickle.loads')
@patch('gppylib.operations.utils.Command')
@patch('os.path.split', return_value = '/')
def test_RemoteOperation_logger_debug(self, mock_split, mock_cmd, mock_lods, mock_debug):
mock_cmd.run = MagicMock()
mockRemoteOperation = RemoteOperation(operation=TestOperation(), host="sdw1", msg_ctx="dbid 2")
mockRemoteOperation.execute()
mock_debug.assert_called()
first_call_args, fist_call_kwargs = mock_debug.call_args_list[0]
self.assertTrue(first_call_args[0].startswith("Output for dbid 2 on host sdw1:"))
if __name__ == '__main__':
run_tests()
| 43.550847 | 147 | 0.675812 |
c386cf9cc08164c91fcb47581603d43333f7ebae | 268,286 | py | Python | sdk/python/pulumi_azure_nextgen/compute/v20191201/_inputs.py | pulumi/pulumi-azure-nextgen | 452736b0a1cf584c2d4c04666e017af6e9b2c15c | [
"Apache-2.0"
] | 31 | 2020-09-21T09:41:01.000Z | 2021-02-26T13:21:59.000Z | sdk/python/pulumi_azure_nextgen/compute/v20191201/_inputs.py | pulumi/pulumi-azure-nextgen | 452736b0a1cf584c2d4c04666e017af6e9b2c15c | [
"Apache-2.0"
] | 231 | 2020-09-21T09:38:45.000Z | 2021-03-01T11:16:03.000Z | sdk/python/pulumi_azure_nextgen/compute/v20191201/_inputs.py | pulumi/pulumi-azure-nextgen | 452736b0a1cf584c2d4c04666e017af6e9b2c15c | [
"Apache-2.0"
] | 4 | 2020-09-29T14:14:59.000Z | 2021-02-10T20:38:16.000Z | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union
from ... import _utilities, _tables
from ._enums import *
__all__ = [
'AdditionalCapabilitiesArgs',
'AdditionalUnattendContentArgs',
'ApiEntityReferenceArgs',
'AutomaticOSUpgradePolicyArgs',
'AutomaticRepairsPolicyArgs',
'BillingProfileArgs',
'BootDiagnosticsArgs',
'DataDiskArgs',
'DataDiskImageEncryptionArgs',
'DiagnosticsProfileArgs',
'DiffDiskSettingsArgs',
'DisallowedArgs',
'DiskEncryptionSetParametersArgs',
'DiskEncryptionSettingsArgs',
'EncryptionImagesArgs',
'GalleryApplicationVersionPublishingProfileArgs',
'GalleryArtifactVersionSourceArgs',
'GalleryDataDiskImageArgs',
'GalleryImageIdentifierArgs',
'GalleryImageVersionPublishingProfileArgs',
'GalleryImageVersionStorageProfileArgs',
'GalleryOSDiskImageArgs',
'HardwareProfileArgs',
'ImageDataDiskArgs',
'ImageOSDiskArgs',
'ImagePurchasePlanArgs',
'ImageReferenceArgs',
'ImageStorageProfileArgs',
'InstanceViewStatusArgs',
'KeyVaultKeyReferenceArgs',
'KeyVaultSecretReferenceArgs',
'LinuxConfigurationArgs',
'ManagedDiskParametersArgs',
'NetworkInterfaceReferenceArgs',
'NetworkProfileArgs',
'OSDiskArgs',
'OSDiskImageEncryptionArgs',
'OSProfileArgs',
'PlanArgs',
'RecommendedMachineConfigurationArgs',
'ResourceRangeArgs',
'RollingUpgradePolicyArgs',
'ScaleInPolicyArgs',
'ScheduledEventsProfileArgs',
'SkuArgs',
'SshConfigurationArgs',
'SshPublicKeyArgs',
'StorageProfileArgs',
'SubResourceArgs',
'TargetRegionArgs',
'TerminateNotificationProfileArgs',
'UpgradePolicyArgs',
'UserArtifactManageArgs',
'UserArtifactSourceArgs',
'VaultCertificateArgs',
'VaultSecretGroupArgs',
'VirtualHardDiskArgs',
'VirtualMachineExtensionInstanceViewArgs',
'VirtualMachineIdentityArgs',
'VirtualMachineScaleSetDataDiskArgs',
'VirtualMachineScaleSetExtensionArgs',
'VirtualMachineScaleSetExtensionProfileArgs',
'VirtualMachineScaleSetIPConfigurationArgs',
'VirtualMachineScaleSetIdentityArgs',
'VirtualMachineScaleSetIpTagArgs',
'VirtualMachineScaleSetManagedDiskParametersArgs',
'VirtualMachineScaleSetNetworkConfigurationArgs',
'VirtualMachineScaleSetNetworkConfigurationDnsSettingsArgs',
'VirtualMachineScaleSetNetworkProfileArgs',
'VirtualMachineScaleSetOSDiskArgs',
'VirtualMachineScaleSetOSProfileArgs',
'VirtualMachineScaleSetPublicIPAddressConfigurationArgs',
'VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsArgs',
'VirtualMachineScaleSetStorageProfileArgs',
'VirtualMachineScaleSetVMNetworkProfileConfigurationArgs',
'VirtualMachineScaleSetVMProfileArgs',
'VirtualMachineScaleSetVMProtectionPolicyArgs',
'WinRMConfigurationArgs',
'WinRMListenerArgs',
'WindowsConfigurationArgs',
]
@pulumi.input_type
class AdditionalCapabilitiesArgs:
def __init__(__self__, *,
ultra_ssd_enabled: Optional[pulumi.Input[bool]] = None):
"""
Enables or disables a capability on the virtual machine or virtual machine scale set.
:param pulumi.Input[bool] ultra_ssd_enabled: The flag that enables or disables a capability to have one or more managed data disks with UltraSSD_LRS storage account type on the VM or VMSS. Managed disks with storage account type UltraSSD_LRS can be added to a virtual machine or virtual machine scale set only if this property is enabled.
"""
if ultra_ssd_enabled is not None:
pulumi.set(__self__, "ultra_ssd_enabled", ultra_ssd_enabled)
@property
@pulumi.getter(name="ultraSSDEnabled")
def ultra_ssd_enabled(self) -> Optional[pulumi.Input[bool]]:
"""
The flag that enables or disables a capability to have one or more managed data disks with UltraSSD_LRS storage account type on the VM or VMSS. Managed disks with storage account type UltraSSD_LRS can be added to a virtual machine or virtual machine scale set only if this property is enabled.
"""
return pulumi.get(self, "ultra_ssd_enabled")
@ultra_ssd_enabled.setter
def ultra_ssd_enabled(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "ultra_ssd_enabled", value)
@pulumi.input_type
class AdditionalUnattendContentArgs:
def __init__(__self__, *,
component_name: Optional[pulumi.Input['ComponentNames']] = None,
content: Optional[pulumi.Input[str]] = None,
pass_name: Optional[pulumi.Input['PassNames']] = None,
setting_name: Optional[pulumi.Input['SettingNames']] = None):
"""
Specifies additional XML formatted information that can be included in the Unattend.xml file, which is used by Windows Setup. Contents are defined by setting name, component name, and the pass in which the content is applied.
:param pulumi.Input['ComponentNames'] component_name: The component name. Currently, the only allowable value is Microsoft-Windows-Shell-Setup.
:param pulumi.Input[str] content: Specifies the XML formatted content that is added to the unattend.xml file for the specified path and component. The XML must be less than 4KB and must include the root element for the setting or feature that is being inserted.
:param pulumi.Input['PassNames'] pass_name: The pass name. Currently, the only allowable value is OobeSystem.
:param pulumi.Input['SettingNames'] setting_name: Specifies the name of the setting to which the content applies. Possible values are: FirstLogonCommands and AutoLogon.
"""
if component_name is not None:
pulumi.set(__self__, "component_name", component_name)
if content is not None:
pulumi.set(__self__, "content", content)
if pass_name is not None:
pulumi.set(__self__, "pass_name", pass_name)
if setting_name is not None:
pulumi.set(__self__, "setting_name", setting_name)
@property
@pulumi.getter(name="componentName")
def component_name(self) -> Optional[pulumi.Input['ComponentNames']]:
"""
The component name. Currently, the only allowable value is Microsoft-Windows-Shell-Setup.
"""
return pulumi.get(self, "component_name")
@component_name.setter
def component_name(self, value: Optional[pulumi.Input['ComponentNames']]):
pulumi.set(self, "component_name", value)
@property
@pulumi.getter
def content(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the XML formatted content that is added to the unattend.xml file for the specified path and component. The XML must be less than 4KB and must include the root element for the setting or feature that is being inserted.
"""
return pulumi.get(self, "content")
@content.setter
def content(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "content", value)
@property
@pulumi.getter(name="passName")
def pass_name(self) -> Optional[pulumi.Input['PassNames']]:
"""
The pass name. Currently, the only allowable value is OobeSystem.
"""
return pulumi.get(self, "pass_name")
@pass_name.setter
def pass_name(self, value: Optional[pulumi.Input['PassNames']]):
pulumi.set(self, "pass_name", value)
@property
@pulumi.getter(name="settingName")
def setting_name(self) -> Optional[pulumi.Input['SettingNames']]:
"""
Specifies the name of the setting to which the content applies. Possible values are: FirstLogonCommands and AutoLogon.
"""
return pulumi.get(self, "setting_name")
@setting_name.setter
def setting_name(self, value: Optional[pulumi.Input['SettingNames']]):
pulumi.set(self, "setting_name", value)
@pulumi.input_type
class ApiEntityReferenceArgs:
def __init__(__self__, *,
id: Optional[pulumi.Input[str]] = None):
"""
The API entity reference.
:param pulumi.Input[str] id: The ARM resource id in the form of /subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/...
"""
if id is not None:
pulumi.set(__self__, "id", id)
@property
@pulumi.getter
def id(self) -> Optional[pulumi.Input[str]]:
"""
The ARM resource id in the form of /subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/...
"""
return pulumi.get(self, "id")
@id.setter
def id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "id", value)
@pulumi.input_type
class AutomaticOSUpgradePolicyArgs:
def __init__(__self__, *,
disable_automatic_rollback: Optional[pulumi.Input[bool]] = None,
enable_automatic_os_upgrade: Optional[pulumi.Input[bool]] = None):
"""
The configuration parameters used for performing automatic OS upgrade.
:param pulumi.Input[bool] disable_automatic_rollback: Whether OS image rollback feature should be disabled. Default value is false.
:param pulumi.Input[bool] enable_automatic_os_upgrade: Indicates whether OS upgrades should automatically be applied to scale set instances in a rolling fashion when a newer version of the OS image becomes available. Default value is false. <br><br> If this is set to true for Windows based scale sets, [enableAutomaticUpdates](https://docs.microsoft.com/dotnet/api/microsoft.azure.management.compute.models.windowsconfiguration.enableautomaticupdates?view=azure-dotnet) is automatically set to false and cannot be set to true.
"""
if disable_automatic_rollback is not None:
pulumi.set(__self__, "disable_automatic_rollback", disable_automatic_rollback)
if enable_automatic_os_upgrade is not None:
pulumi.set(__self__, "enable_automatic_os_upgrade", enable_automatic_os_upgrade)
@property
@pulumi.getter(name="disableAutomaticRollback")
def disable_automatic_rollback(self) -> Optional[pulumi.Input[bool]]:
"""
Whether OS image rollback feature should be disabled. Default value is false.
"""
return pulumi.get(self, "disable_automatic_rollback")
@disable_automatic_rollback.setter
def disable_automatic_rollback(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "disable_automatic_rollback", value)
@property
@pulumi.getter(name="enableAutomaticOSUpgrade")
def enable_automatic_os_upgrade(self) -> Optional[pulumi.Input[bool]]:
"""
Indicates whether OS upgrades should automatically be applied to scale set instances in a rolling fashion when a newer version of the OS image becomes available. Default value is false. <br><br> If this is set to true for Windows based scale sets, [enableAutomaticUpdates](https://docs.microsoft.com/dotnet/api/microsoft.azure.management.compute.models.windowsconfiguration.enableautomaticupdates?view=azure-dotnet) is automatically set to false and cannot be set to true.
"""
return pulumi.get(self, "enable_automatic_os_upgrade")
@enable_automatic_os_upgrade.setter
def enable_automatic_os_upgrade(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "enable_automatic_os_upgrade", value)
@pulumi.input_type
class AutomaticRepairsPolicyArgs:
def __init__(__self__, *,
enabled: Optional[pulumi.Input[bool]] = None,
grace_period: Optional[pulumi.Input[str]] = None):
"""
Specifies the configuration parameters for automatic repairs on the virtual machine scale set.
:param pulumi.Input[bool] enabled: Specifies whether automatic repairs should be enabled on the virtual machine scale set. The default value is false.
:param pulumi.Input[str] grace_period: The amount of time for which automatic repairs are suspended due to a state change on VM. The grace time starts after the state change has completed. This helps avoid premature or accidental repairs. The time duration should be specified in ISO 8601 format. The minimum allowed grace period is 30 minutes (PT30M), which is also the default value. The maximum allowed grace period is 90 minutes (PT90M).
"""
if enabled is not None:
pulumi.set(__self__, "enabled", enabled)
if grace_period is not None:
pulumi.set(__self__, "grace_period", grace_period)
@property
@pulumi.getter
def enabled(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether automatic repairs should be enabled on the virtual machine scale set. The default value is false.
"""
return pulumi.get(self, "enabled")
@enabled.setter
def enabled(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "enabled", value)
@property
@pulumi.getter(name="gracePeriod")
def grace_period(self) -> Optional[pulumi.Input[str]]:
"""
The amount of time for which automatic repairs are suspended due to a state change on VM. The grace time starts after the state change has completed. This helps avoid premature or accidental repairs. The time duration should be specified in ISO 8601 format. The minimum allowed grace period is 30 minutes (PT30M), which is also the default value. The maximum allowed grace period is 90 minutes (PT90M).
"""
return pulumi.get(self, "grace_period")
@grace_period.setter
def grace_period(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "grace_period", value)
@pulumi.input_type
class BillingProfileArgs:
def __init__(__self__, *,
max_price: Optional[pulumi.Input[float]] = None):
"""
Specifies the billing related details of a Azure Spot VM or VMSS. <br><br>Minimum api-version: 2019-03-01.
:param pulumi.Input[float] max_price: Specifies the maximum price you are willing to pay for a Azure Spot VM/VMSS. This price is in US Dollars. <br><br> This price will be compared with the current Azure Spot price for the VM size. Also, the prices are compared at the time of create/update of Azure Spot VM/VMSS and the operation will only succeed if the maxPrice is greater than the current Azure Spot price. <br><br> The maxPrice will also be used for evicting a Azure Spot VM/VMSS if the current Azure Spot price goes beyond the maxPrice after creation of VM/VMSS. <br><br> Possible values are: <br><br> - Any decimal value greater than zero. Example: 0.01538 <br><br> -1 – indicates default price to be up-to on-demand. <br><br> You can set the maxPrice to -1 to indicate that the Azure Spot VM/VMSS should not be evicted for price reasons. Also, the default max price is -1 if it is not provided by you. <br><br>Minimum api-version: 2019-03-01.
"""
if max_price is not None:
pulumi.set(__self__, "max_price", max_price)
@property
@pulumi.getter(name="maxPrice")
def max_price(self) -> Optional[pulumi.Input[float]]:
"""
Specifies the maximum price you are willing to pay for a Azure Spot VM/VMSS. This price is in US Dollars. <br><br> This price will be compared with the current Azure Spot price for the VM size. Also, the prices are compared at the time of create/update of Azure Spot VM/VMSS and the operation will only succeed if the maxPrice is greater than the current Azure Spot price. <br><br> The maxPrice will also be used for evicting a Azure Spot VM/VMSS if the current Azure Spot price goes beyond the maxPrice after creation of VM/VMSS. <br><br> Possible values are: <br><br> - Any decimal value greater than zero. Example: 0.01538 <br><br> -1 – indicates default price to be up-to on-demand. <br><br> You can set the maxPrice to -1 to indicate that the Azure Spot VM/VMSS should not be evicted for price reasons. Also, the default max price is -1 if it is not provided by you. <br><br>Minimum api-version: 2019-03-01.
"""
return pulumi.get(self, "max_price")
@max_price.setter
def max_price(self, value: Optional[pulumi.Input[float]]):
pulumi.set(self, "max_price", value)
@pulumi.input_type
class BootDiagnosticsArgs:
def __init__(__self__, *,
enabled: Optional[pulumi.Input[bool]] = None,
storage_uri: Optional[pulumi.Input[str]] = None):
"""
Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status. <br><br> You can easily view the output of your console log. <br><br> Azure also enables you to see a screenshot of the VM from the hypervisor.
:param pulumi.Input[bool] enabled: Whether boot diagnostics should be enabled on the Virtual Machine.
:param pulumi.Input[str] storage_uri: Uri of the storage account to use for placing the console output and screenshot.
"""
if enabled is not None:
pulumi.set(__self__, "enabled", enabled)
if storage_uri is not None:
pulumi.set(__self__, "storage_uri", storage_uri)
@property
@pulumi.getter
def enabled(self) -> Optional[pulumi.Input[bool]]:
"""
Whether boot diagnostics should be enabled on the Virtual Machine.
"""
return pulumi.get(self, "enabled")
@enabled.setter
def enabled(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "enabled", value)
@property
@pulumi.getter(name="storageUri")
def storage_uri(self) -> Optional[pulumi.Input[str]]:
"""
Uri of the storage account to use for placing the console output and screenshot.
"""
return pulumi.get(self, "storage_uri")
@storage_uri.setter
def storage_uri(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "storage_uri", value)
@pulumi.input_type
class DataDiskArgs:
def __init__(__self__, *,
create_option: pulumi.Input[Union[str, 'DiskCreateOptionTypes']],
lun: pulumi.Input[int],
caching: Optional[pulumi.Input['CachingTypes']] = None,
disk_size_gb: Optional[pulumi.Input[int]] = None,
image: Optional[pulumi.Input['VirtualHardDiskArgs']] = None,
managed_disk: Optional[pulumi.Input['ManagedDiskParametersArgs']] = None,
name: Optional[pulumi.Input[str]] = None,
to_be_detached: Optional[pulumi.Input[bool]] = None,
vhd: Optional[pulumi.Input['VirtualHardDiskArgs']] = None,
write_accelerator_enabled: Optional[pulumi.Input[bool]] = None):
"""
Describes a data disk.
:param pulumi.Input[Union[str, 'DiskCreateOptionTypes']] create_option: Specifies how the virtual machine should be created.<br><br> Possible values are:<br><br> **Attach** \u2013 This value is used when you are using a specialized disk to create the virtual machine.<br><br> **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you also use the plan element previously described.
:param pulumi.Input[int] lun: Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
:param pulumi.Input['CachingTypes'] caching: Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
:param pulumi.Input[int] disk_size_gb: Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
:param pulumi.Input['VirtualHardDiskArgs'] image: The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist.
:param pulumi.Input['ManagedDiskParametersArgs'] managed_disk: The managed disk parameters.
:param pulumi.Input[str] name: The disk name.
:param pulumi.Input[bool] to_be_detached: Specifies whether the data disk is in process of detachment from the VirtualMachine/VirtualMachineScaleset
:param pulumi.Input['VirtualHardDiskArgs'] vhd: The virtual hard disk.
:param pulumi.Input[bool] write_accelerator_enabled: Specifies whether writeAccelerator should be enabled or disabled on the disk.
"""
pulumi.set(__self__, "create_option", create_option)
pulumi.set(__self__, "lun", lun)
if caching is not None:
pulumi.set(__self__, "caching", caching)
if disk_size_gb is not None:
pulumi.set(__self__, "disk_size_gb", disk_size_gb)
if image is not None:
pulumi.set(__self__, "image", image)
if managed_disk is not None:
pulumi.set(__self__, "managed_disk", managed_disk)
if name is not None:
pulumi.set(__self__, "name", name)
if to_be_detached is not None:
pulumi.set(__self__, "to_be_detached", to_be_detached)
if vhd is not None:
pulumi.set(__self__, "vhd", vhd)
if write_accelerator_enabled is not None:
pulumi.set(__self__, "write_accelerator_enabled", write_accelerator_enabled)
@property
@pulumi.getter(name="createOption")
def create_option(self) -> pulumi.Input[Union[str, 'DiskCreateOptionTypes']]:
"""
Specifies how the virtual machine should be created.<br><br> Possible values are:<br><br> **Attach** \u2013 This value is used when you are using a specialized disk to create the virtual machine.<br><br> **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you also use the plan element previously described.
"""
return pulumi.get(self, "create_option")
@create_option.setter
def create_option(self, value: pulumi.Input[Union[str, 'DiskCreateOptionTypes']]):
pulumi.set(self, "create_option", value)
@property
@pulumi.getter
def lun(self) -> pulumi.Input[int]:
"""
Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
"""
return pulumi.get(self, "lun")
@lun.setter
def lun(self, value: pulumi.Input[int]):
pulumi.set(self, "lun", value)
@property
@pulumi.getter
def caching(self) -> Optional[pulumi.Input['CachingTypes']]:
"""
Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
"""
return pulumi.get(self, "caching")
@caching.setter
def caching(self, value: Optional[pulumi.Input['CachingTypes']]):
pulumi.set(self, "caching", value)
@property
@pulumi.getter(name="diskSizeGB")
def disk_size_gb(self) -> Optional[pulumi.Input[int]]:
"""
Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
"""
return pulumi.get(self, "disk_size_gb")
@disk_size_gb.setter
def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "disk_size_gb", value)
@property
@pulumi.getter
def image(self) -> Optional[pulumi.Input['VirtualHardDiskArgs']]:
"""
The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist.
"""
return pulumi.get(self, "image")
@image.setter
def image(self, value: Optional[pulumi.Input['VirtualHardDiskArgs']]):
pulumi.set(self, "image", value)
@property
@pulumi.getter(name="managedDisk")
def managed_disk(self) -> Optional[pulumi.Input['ManagedDiskParametersArgs']]:
"""
The managed disk parameters.
"""
return pulumi.get(self, "managed_disk")
@managed_disk.setter
def managed_disk(self, value: Optional[pulumi.Input['ManagedDiskParametersArgs']]):
pulumi.set(self, "managed_disk", value)
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
"""
The disk name.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
@property
@pulumi.getter(name="toBeDetached")
def to_be_detached(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether the data disk is in process of detachment from the VirtualMachine/VirtualMachineScaleset
"""
return pulumi.get(self, "to_be_detached")
@to_be_detached.setter
def to_be_detached(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "to_be_detached", value)
@property
@pulumi.getter
def vhd(self) -> Optional[pulumi.Input['VirtualHardDiskArgs']]:
"""
The virtual hard disk.
"""
return pulumi.get(self, "vhd")
@vhd.setter
def vhd(self, value: Optional[pulumi.Input['VirtualHardDiskArgs']]):
pulumi.set(self, "vhd", value)
@property
@pulumi.getter(name="writeAcceleratorEnabled")
def write_accelerator_enabled(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether writeAccelerator should be enabled or disabled on the disk.
"""
return pulumi.get(self, "write_accelerator_enabled")
@write_accelerator_enabled.setter
def write_accelerator_enabled(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "write_accelerator_enabled", value)
@pulumi.input_type
class DataDiskImageEncryptionArgs:
def __init__(__self__, *,
lun: pulumi.Input[int],
disk_encryption_set_id: Optional[pulumi.Input[str]] = None):
"""
Contains encryption settings for a data disk image.
:param pulumi.Input[int] lun: This property specifies the logical unit number of the data disk. This value is used to identify data disks within the Virtual Machine and therefore must be unique for each data disk attached to the Virtual Machine.
:param pulumi.Input[str] disk_encryption_set_id: A relative URI containing the resource ID of the disk encryption set.
"""
pulumi.set(__self__, "lun", lun)
if disk_encryption_set_id is not None:
pulumi.set(__self__, "disk_encryption_set_id", disk_encryption_set_id)
@property
@pulumi.getter
def lun(self) -> pulumi.Input[int]:
"""
This property specifies the logical unit number of the data disk. This value is used to identify data disks within the Virtual Machine and therefore must be unique for each data disk attached to the Virtual Machine.
"""
return pulumi.get(self, "lun")
@lun.setter
def lun(self, value: pulumi.Input[int]):
pulumi.set(self, "lun", value)
@property
@pulumi.getter(name="diskEncryptionSetId")
def disk_encryption_set_id(self) -> Optional[pulumi.Input[str]]:
"""
A relative URI containing the resource ID of the disk encryption set.
"""
return pulumi.get(self, "disk_encryption_set_id")
@disk_encryption_set_id.setter
def disk_encryption_set_id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "disk_encryption_set_id", value)
@pulumi.input_type
class DiagnosticsProfileArgs:
def __init__(__self__, *,
boot_diagnostics: Optional[pulumi.Input['BootDiagnosticsArgs']] = None):
"""
Specifies the boot diagnostic settings state. <br><br>Minimum api-version: 2015-06-15.
:param pulumi.Input['BootDiagnosticsArgs'] boot_diagnostics: Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status. <br><br> You can easily view the output of your console log. <br><br> Azure also enables you to see a screenshot of the VM from the hypervisor.
"""
if boot_diagnostics is not None:
pulumi.set(__self__, "boot_diagnostics", boot_diagnostics)
@property
@pulumi.getter(name="bootDiagnostics")
def boot_diagnostics(self) -> Optional[pulumi.Input['BootDiagnosticsArgs']]:
"""
Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status. <br><br> You can easily view the output of your console log. <br><br> Azure also enables you to see a screenshot of the VM from the hypervisor.
"""
return pulumi.get(self, "boot_diagnostics")
@boot_diagnostics.setter
def boot_diagnostics(self, value: Optional[pulumi.Input['BootDiagnosticsArgs']]):
pulumi.set(self, "boot_diagnostics", value)
@pulumi.input_type
class DiffDiskSettingsArgs:
def __init__(__self__, *,
option: Optional[pulumi.Input[Union[str, 'DiffDiskOptions']]] = None,
placement: Optional[pulumi.Input[Union[str, 'DiffDiskPlacement']]] = None):
"""
Describes the parameters of ephemeral disk settings that can be specified for operating system disk. <br><br> NOTE: The ephemeral disk settings can only be specified for managed disk.
:param pulumi.Input[Union[str, 'DiffDiskOptions']] option: Specifies the ephemeral disk settings for operating system disk.
:param pulumi.Input[Union[str, 'DiffDiskPlacement']] placement: Specifies the ephemeral disk placement for operating system disk.<br><br> Possible values are: <br><br> **CacheDisk** <br><br> **ResourceDisk** <br><br> Default: **CacheDisk** if one is configured for the VM size otherwise **ResourceDisk** is used.<br><br> Refer to VM size documentation for Windows VM at https://docs.microsoft.com/en-us/azure/virtual-machines/windows/sizes and Linux VM at https://docs.microsoft.com/en-us/azure/virtual-machines/linux/sizes to check which VM sizes exposes a cache disk.
"""
if option is not None:
pulumi.set(__self__, "option", option)
if placement is not None:
pulumi.set(__self__, "placement", placement)
@property
@pulumi.getter
def option(self) -> Optional[pulumi.Input[Union[str, 'DiffDiskOptions']]]:
"""
Specifies the ephemeral disk settings for operating system disk.
"""
return pulumi.get(self, "option")
@option.setter
def option(self, value: Optional[pulumi.Input[Union[str, 'DiffDiskOptions']]]):
pulumi.set(self, "option", value)
@property
@pulumi.getter
def placement(self) -> Optional[pulumi.Input[Union[str, 'DiffDiskPlacement']]]:
"""
Specifies the ephemeral disk placement for operating system disk.<br><br> Possible values are: <br><br> **CacheDisk** <br><br> **ResourceDisk** <br><br> Default: **CacheDisk** if one is configured for the VM size otherwise **ResourceDisk** is used.<br><br> Refer to VM size documentation for Windows VM at https://docs.microsoft.com/en-us/azure/virtual-machines/windows/sizes and Linux VM at https://docs.microsoft.com/en-us/azure/virtual-machines/linux/sizes to check which VM sizes exposes a cache disk.
"""
return pulumi.get(self, "placement")
@placement.setter
def placement(self, value: Optional[pulumi.Input[Union[str, 'DiffDiskPlacement']]]):
pulumi.set(self, "placement", value)
@pulumi.input_type
class DisallowedArgs:
def __init__(__self__, *,
disk_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
"""
Describes the disallowed disk types.
:param pulumi.Input[Sequence[pulumi.Input[str]]] disk_types: A list of disk types.
"""
if disk_types is not None:
pulumi.set(__self__, "disk_types", disk_types)
@property
@pulumi.getter(name="diskTypes")
def disk_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
"""
A list of disk types.
"""
return pulumi.get(self, "disk_types")
@disk_types.setter
def disk_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
pulumi.set(self, "disk_types", value)
@pulumi.input_type
class DiskEncryptionSetParametersArgs:
def __init__(__self__, *,
id: Optional[pulumi.Input[str]] = None):
"""
Describes the parameter of customer managed disk encryption set resource id that can be specified for disk. <br><br> NOTE: The disk encryption set resource id can only be specified for managed disk. Please refer https://aka.ms/mdssewithcmkoverview for more details.
:param pulumi.Input[str] id: Resource Id
"""
if id is not None:
pulumi.set(__self__, "id", id)
@property
@pulumi.getter
def id(self) -> Optional[pulumi.Input[str]]:
"""
Resource Id
"""
return pulumi.get(self, "id")
@id.setter
def id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "id", value)
@pulumi.input_type
class DiskEncryptionSettingsArgs:
def __init__(__self__, *,
disk_encryption_key: Optional[pulumi.Input['KeyVaultSecretReferenceArgs']] = None,
enabled: Optional[pulumi.Input[bool]] = None,
key_encryption_key: Optional[pulumi.Input['KeyVaultKeyReferenceArgs']] = None):
"""
Describes a Encryption Settings for a Disk
:param pulumi.Input['KeyVaultSecretReferenceArgs'] disk_encryption_key: Specifies the location of the disk encryption key, which is a Key Vault Secret.
:param pulumi.Input[bool] enabled: Specifies whether disk encryption should be enabled on the virtual machine.
:param pulumi.Input['KeyVaultKeyReferenceArgs'] key_encryption_key: Specifies the location of the key encryption key in Key Vault.
"""
if disk_encryption_key is not None:
pulumi.set(__self__, "disk_encryption_key", disk_encryption_key)
if enabled is not None:
pulumi.set(__self__, "enabled", enabled)
if key_encryption_key is not None:
pulumi.set(__self__, "key_encryption_key", key_encryption_key)
@property
@pulumi.getter(name="diskEncryptionKey")
def disk_encryption_key(self) -> Optional[pulumi.Input['KeyVaultSecretReferenceArgs']]:
"""
Specifies the location of the disk encryption key, which is a Key Vault Secret.
"""
return pulumi.get(self, "disk_encryption_key")
@disk_encryption_key.setter
def disk_encryption_key(self, value: Optional[pulumi.Input['KeyVaultSecretReferenceArgs']]):
pulumi.set(self, "disk_encryption_key", value)
@property
@pulumi.getter
def enabled(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether disk encryption should be enabled on the virtual machine.
"""
return pulumi.get(self, "enabled")
@enabled.setter
def enabled(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "enabled", value)
@property
@pulumi.getter(name="keyEncryptionKey")
def key_encryption_key(self) -> Optional[pulumi.Input['KeyVaultKeyReferenceArgs']]:
"""
Specifies the location of the key encryption key in Key Vault.
"""
return pulumi.get(self, "key_encryption_key")
@key_encryption_key.setter
def key_encryption_key(self, value: Optional[pulumi.Input['KeyVaultKeyReferenceArgs']]):
pulumi.set(self, "key_encryption_key", value)
@pulumi.input_type
class EncryptionImagesArgs:
def __init__(__self__, *,
data_disk_images: Optional[pulumi.Input[Sequence[pulumi.Input['DataDiskImageEncryptionArgs']]]] = None,
os_disk_image: Optional[pulumi.Input['OSDiskImageEncryptionArgs']] = None):
"""
Optional. Allows users to provide customer managed keys for encrypting the OS and data disks in the gallery artifact.
:param pulumi.Input[Sequence[pulumi.Input['DataDiskImageEncryptionArgs']]] data_disk_images: A list of encryption specifications for data disk images.
:param pulumi.Input['OSDiskImageEncryptionArgs'] os_disk_image: Contains encryption settings for an OS disk image.
"""
if data_disk_images is not None:
pulumi.set(__self__, "data_disk_images", data_disk_images)
if os_disk_image is not None:
pulumi.set(__self__, "os_disk_image", os_disk_image)
@property
@pulumi.getter(name="dataDiskImages")
def data_disk_images(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataDiskImageEncryptionArgs']]]]:
"""
A list of encryption specifications for data disk images.
"""
return pulumi.get(self, "data_disk_images")
@data_disk_images.setter
def data_disk_images(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataDiskImageEncryptionArgs']]]]):
pulumi.set(self, "data_disk_images", value)
@property
@pulumi.getter(name="osDiskImage")
def os_disk_image(self) -> Optional[pulumi.Input['OSDiskImageEncryptionArgs']]:
"""
Contains encryption settings for an OS disk image.
"""
return pulumi.get(self, "os_disk_image")
@os_disk_image.setter
def os_disk_image(self, value: Optional[pulumi.Input['OSDiskImageEncryptionArgs']]):
pulumi.set(self, "os_disk_image", value)
@pulumi.input_type
class GalleryApplicationVersionPublishingProfileArgs:
def __init__(__self__, *,
source: pulumi.Input['UserArtifactSourceArgs'],
enable_health_check: Optional[pulumi.Input[bool]] = None,
end_of_life_date: Optional[pulumi.Input[str]] = None,
exclude_from_latest: Optional[pulumi.Input[bool]] = None,
manage_actions: Optional[pulumi.Input['UserArtifactManageArgs']] = None,
replica_count: Optional[pulumi.Input[int]] = None,
storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountType']]] = None,
target_regions: Optional[pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]]] = None):
"""
The publishing profile of a gallery image version.
:param pulumi.Input['UserArtifactSourceArgs'] source: The source image from which the Image Version is going to be created.
:param pulumi.Input[bool] enable_health_check: Optional. Whether or not this application reports health.
:param pulumi.Input[str] end_of_life_date: The end of life date of the gallery Image Version. This property can be used for decommissioning purposes. This property is updatable.
:param pulumi.Input[bool] exclude_from_latest: If set to true, Virtual Machines deployed from the latest version of the Image Definition won't use this Image Version.
:param pulumi.Input[int] replica_count: The number of replicas of the Image Version to be created per region. This property would take effect for a region when regionalReplicaCount is not specified. This property is updatable.
:param pulumi.Input[Union[str, 'StorageAccountType']] storage_account_type: Specifies the storage account type to be used to store the image. This property is not updatable.
:param pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]] target_regions: The target regions where the Image Version is going to be replicated to. This property is updatable.
"""
pulumi.set(__self__, "source", source)
if enable_health_check is not None:
pulumi.set(__self__, "enable_health_check", enable_health_check)
if end_of_life_date is not None:
pulumi.set(__self__, "end_of_life_date", end_of_life_date)
if exclude_from_latest is not None:
pulumi.set(__self__, "exclude_from_latest", exclude_from_latest)
if manage_actions is not None:
pulumi.set(__self__, "manage_actions", manage_actions)
if replica_count is not None:
pulumi.set(__self__, "replica_count", replica_count)
if storage_account_type is not None:
pulumi.set(__self__, "storage_account_type", storage_account_type)
if target_regions is not None:
pulumi.set(__self__, "target_regions", target_regions)
@property
@pulumi.getter
def source(self) -> pulumi.Input['UserArtifactSourceArgs']:
"""
The source image from which the Image Version is going to be created.
"""
return pulumi.get(self, "source")
@source.setter
def source(self, value: pulumi.Input['UserArtifactSourceArgs']):
pulumi.set(self, "source", value)
@property
@pulumi.getter(name="enableHealthCheck")
def enable_health_check(self) -> Optional[pulumi.Input[bool]]:
"""
Optional. Whether or not this application reports health.
"""
return pulumi.get(self, "enable_health_check")
@enable_health_check.setter
def enable_health_check(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "enable_health_check", value)
@property
@pulumi.getter(name="endOfLifeDate")
def end_of_life_date(self) -> Optional[pulumi.Input[str]]:
"""
The end of life date of the gallery Image Version. This property can be used for decommissioning purposes. This property is updatable.
"""
return pulumi.get(self, "end_of_life_date")
@end_of_life_date.setter
def end_of_life_date(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "end_of_life_date", value)
@property
@pulumi.getter(name="excludeFromLatest")
def exclude_from_latest(self) -> Optional[pulumi.Input[bool]]:
"""
If set to true, Virtual Machines deployed from the latest version of the Image Definition won't use this Image Version.
"""
return pulumi.get(self, "exclude_from_latest")
@exclude_from_latest.setter
def exclude_from_latest(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "exclude_from_latest", value)
@property
@pulumi.getter(name="manageActions")
def manage_actions(self) -> Optional[pulumi.Input['UserArtifactManageArgs']]:
return pulumi.get(self, "manage_actions")
@manage_actions.setter
def manage_actions(self, value: Optional[pulumi.Input['UserArtifactManageArgs']]):
pulumi.set(self, "manage_actions", value)
@property
@pulumi.getter(name="replicaCount")
def replica_count(self) -> Optional[pulumi.Input[int]]:
"""
The number of replicas of the Image Version to be created per region. This property would take effect for a region when regionalReplicaCount is not specified. This property is updatable.
"""
return pulumi.get(self, "replica_count")
@replica_count.setter
def replica_count(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "replica_count", value)
@property
@pulumi.getter(name="storageAccountType")
def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountType']]]:
"""
Specifies the storage account type to be used to store the image. This property is not updatable.
"""
return pulumi.get(self, "storage_account_type")
@storage_account_type.setter
def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountType']]]):
pulumi.set(self, "storage_account_type", value)
@property
@pulumi.getter(name="targetRegions")
def target_regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]]]:
"""
The target regions where the Image Version is going to be replicated to. This property is updatable.
"""
return pulumi.get(self, "target_regions")
@target_regions.setter
def target_regions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]]]):
pulumi.set(self, "target_regions", value)
@pulumi.input_type
class GalleryArtifactVersionSourceArgs:
def __init__(__self__, *,
id: Optional[pulumi.Input[str]] = None):
"""
The gallery artifact version source.
:param pulumi.Input[str] id: The id of the gallery artifact version source. Can specify a disk uri, snapshot uri, or user image.
"""
if id is not None:
pulumi.set(__self__, "id", id)
@property
@pulumi.getter
def id(self) -> Optional[pulumi.Input[str]]:
"""
The id of the gallery artifact version source. Can specify a disk uri, snapshot uri, or user image.
"""
return pulumi.get(self, "id")
@id.setter
def id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "id", value)
@pulumi.input_type
class GalleryDataDiskImageArgs:
def __init__(__self__, *,
lun: pulumi.Input[int],
host_caching: Optional[pulumi.Input['HostCaching']] = None,
source: Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']] = None):
"""
This is the data disk image.
:param pulumi.Input[int] lun: This property specifies the logical unit number of the data disk. This value is used to identify data disks within the Virtual Machine and therefore must be unique for each data disk attached to the Virtual Machine.
:param pulumi.Input['HostCaching'] host_caching: The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
:param pulumi.Input['GalleryArtifactVersionSourceArgs'] source: The gallery artifact version source.
"""
pulumi.set(__self__, "lun", lun)
if host_caching is not None:
pulumi.set(__self__, "host_caching", host_caching)
if source is not None:
pulumi.set(__self__, "source", source)
@property
@pulumi.getter
def lun(self) -> pulumi.Input[int]:
"""
This property specifies the logical unit number of the data disk. This value is used to identify data disks within the Virtual Machine and therefore must be unique for each data disk attached to the Virtual Machine.
"""
return pulumi.get(self, "lun")
@lun.setter
def lun(self, value: pulumi.Input[int]):
pulumi.set(self, "lun", value)
@property
@pulumi.getter(name="hostCaching")
def host_caching(self) -> Optional[pulumi.Input['HostCaching']]:
"""
The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
"""
return pulumi.get(self, "host_caching")
@host_caching.setter
def host_caching(self, value: Optional[pulumi.Input['HostCaching']]):
pulumi.set(self, "host_caching", value)
@property
@pulumi.getter
def source(self) -> Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']]:
"""
The gallery artifact version source.
"""
return pulumi.get(self, "source")
@source.setter
def source(self, value: Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']]):
pulumi.set(self, "source", value)
@pulumi.input_type
class GalleryImageIdentifierArgs:
def __init__(__self__, *,
offer: pulumi.Input[str],
publisher: pulumi.Input[str],
sku: pulumi.Input[str]):
"""
This is the gallery Image Definition identifier.
:param pulumi.Input[str] offer: The name of the gallery Image Definition offer.
:param pulumi.Input[str] publisher: The name of the gallery Image Definition publisher.
:param pulumi.Input[str] sku: The name of the gallery Image Definition SKU.
"""
pulumi.set(__self__, "offer", offer)
pulumi.set(__self__, "publisher", publisher)
pulumi.set(__self__, "sku", sku)
@property
@pulumi.getter
def offer(self) -> pulumi.Input[str]:
"""
The name of the gallery Image Definition offer.
"""
return pulumi.get(self, "offer")
@offer.setter
def offer(self, value: pulumi.Input[str]):
pulumi.set(self, "offer", value)
@property
@pulumi.getter
def publisher(self) -> pulumi.Input[str]:
"""
The name of the gallery Image Definition publisher.
"""
return pulumi.get(self, "publisher")
@publisher.setter
def publisher(self, value: pulumi.Input[str]):
pulumi.set(self, "publisher", value)
@property
@pulumi.getter
def sku(self) -> pulumi.Input[str]:
"""
The name of the gallery Image Definition SKU.
"""
return pulumi.get(self, "sku")
@sku.setter
def sku(self, value: pulumi.Input[str]):
pulumi.set(self, "sku", value)
@pulumi.input_type
class GalleryImageVersionPublishingProfileArgs:
def __init__(__self__, *,
end_of_life_date: Optional[pulumi.Input[str]] = None,
exclude_from_latest: Optional[pulumi.Input[bool]] = None,
replica_count: Optional[pulumi.Input[int]] = None,
storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountType']]] = None,
target_regions: Optional[pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]]] = None):
"""
The publishing profile of a gallery Image Version.
:param pulumi.Input[str] end_of_life_date: The end of life date of the gallery Image Version. This property can be used for decommissioning purposes. This property is updatable.
:param pulumi.Input[bool] exclude_from_latest: If set to true, Virtual Machines deployed from the latest version of the Image Definition won't use this Image Version.
:param pulumi.Input[int] replica_count: The number of replicas of the Image Version to be created per region. This property would take effect for a region when regionalReplicaCount is not specified. This property is updatable.
:param pulumi.Input[Union[str, 'StorageAccountType']] storage_account_type: Specifies the storage account type to be used to store the image. This property is not updatable.
:param pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]] target_regions: The target regions where the Image Version is going to be replicated to. This property is updatable.
"""
if end_of_life_date is not None:
pulumi.set(__self__, "end_of_life_date", end_of_life_date)
if exclude_from_latest is not None:
pulumi.set(__self__, "exclude_from_latest", exclude_from_latest)
if replica_count is not None:
pulumi.set(__self__, "replica_count", replica_count)
if storage_account_type is not None:
pulumi.set(__self__, "storage_account_type", storage_account_type)
if target_regions is not None:
pulumi.set(__self__, "target_regions", target_regions)
@property
@pulumi.getter(name="endOfLifeDate")
def end_of_life_date(self) -> Optional[pulumi.Input[str]]:
"""
The end of life date of the gallery Image Version. This property can be used for decommissioning purposes. This property is updatable.
"""
return pulumi.get(self, "end_of_life_date")
@end_of_life_date.setter
def end_of_life_date(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "end_of_life_date", value)
@property
@pulumi.getter(name="excludeFromLatest")
def exclude_from_latest(self) -> Optional[pulumi.Input[bool]]:
"""
If set to true, Virtual Machines deployed from the latest version of the Image Definition won't use this Image Version.
"""
return pulumi.get(self, "exclude_from_latest")
@exclude_from_latest.setter
def exclude_from_latest(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "exclude_from_latest", value)
@property
@pulumi.getter(name="replicaCount")
def replica_count(self) -> Optional[pulumi.Input[int]]:
"""
The number of replicas of the Image Version to be created per region. This property would take effect for a region when regionalReplicaCount is not specified. This property is updatable.
"""
return pulumi.get(self, "replica_count")
@replica_count.setter
def replica_count(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "replica_count", value)
@property
@pulumi.getter(name="storageAccountType")
def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountType']]]:
"""
Specifies the storage account type to be used to store the image. This property is not updatable.
"""
return pulumi.get(self, "storage_account_type")
@storage_account_type.setter
def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountType']]]):
pulumi.set(self, "storage_account_type", value)
@property
@pulumi.getter(name="targetRegions")
def target_regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]]]:
"""
The target regions where the Image Version is going to be replicated to. This property is updatable.
"""
return pulumi.get(self, "target_regions")
@target_regions.setter
def target_regions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]]]):
pulumi.set(self, "target_regions", value)
@pulumi.input_type
class GalleryImageVersionStorageProfileArgs:
def __init__(__self__, *,
data_disk_images: Optional[pulumi.Input[Sequence[pulumi.Input['GalleryDataDiskImageArgs']]]] = None,
os_disk_image: Optional[pulumi.Input['GalleryOSDiskImageArgs']] = None,
source: Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']] = None):
"""
This is the storage profile of a Gallery Image Version.
:param pulumi.Input[Sequence[pulumi.Input['GalleryDataDiskImageArgs']]] data_disk_images: A list of data disk images.
:param pulumi.Input['GalleryOSDiskImageArgs'] os_disk_image: This is the OS disk image.
:param pulumi.Input['GalleryArtifactVersionSourceArgs'] source: The gallery artifact version source.
"""
if data_disk_images is not None:
pulumi.set(__self__, "data_disk_images", data_disk_images)
if os_disk_image is not None:
pulumi.set(__self__, "os_disk_image", os_disk_image)
if source is not None:
pulumi.set(__self__, "source", source)
@property
@pulumi.getter(name="dataDiskImages")
def data_disk_images(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['GalleryDataDiskImageArgs']]]]:
"""
A list of data disk images.
"""
return pulumi.get(self, "data_disk_images")
@data_disk_images.setter
def data_disk_images(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GalleryDataDiskImageArgs']]]]):
pulumi.set(self, "data_disk_images", value)
@property
@pulumi.getter(name="osDiskImage")
def os_disk_image(self) -> Optional[pulumi.Input['GalleryOSDiskImageArgs']]:
"""
This is the OS disk image.
"""
return pulumi.get(self, "os_disk_image")
@os_disk_image.setter
def os_disk_image(self, value: Optional[pulumi.Input['GalleryOSDiskImageArgs']]):
pulumi.set(self, "os_disk_image", value)
@property
@pulumi.getter
def source(self) -> Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']]:
"""
The gallery artifact version source.
"""
return pulumi.get(self, "source")
@source.setter
def source(self, value: Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']]):
pulumi.set(self, "source", value)
@pulumi.input_type
class GalleryOSDiskImageArgs:
def __init__(__self__, *,
host_caching: Optional[pulumi.Input['HostCaching']] = None,
source: Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']] = None):
"""
This is the OS disk image.
:param pulumi.Input['HostCaching'] host_caching: The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
:param pulumi.Input['GalleryArtifactVersionSourceArgs'] source: The gallery artifact version source.
"""
if host_caching is not None:
pulumi.set(__self__, "host_caching", host_caching)
if source is not None:
pulumi.set(__self__, "source", source)
@property
@pulumi.getter(name="hostCaching")
def host_caching(self) -> Optional[pulumi.Input['HostCaching']]:
"""
The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
"""
return pulumi.get(self, "host_caching")
@host_caching.setter
def host_caching(self, value: Optional[pulumi.Input['HostCaching']]):
pulumi.set(self, "host_caching", value)
@property
@pulumi.getter
def source(self) -> Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']]:
"""
The gallery artifact version source.
"""
return pulumi.get(self, "source")
@source.setter
def source(self, value: Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']]):
pulumi.set(self, "source", value)
@pulumi.input_type
class HardwareProfileArgs:
def __init__(__self__, *,
vm_size: Optional[pulumi.Input[Union[str, 'VirtualMachineSizeTypes']]] = None):
"""
Specifies the hardware settings for the virtual machine.
:param pulumi.Input[Union[str, 'VirtualMachineSizeTypes']] vm_size: Specifies the size of the virtual machine. For more information about virtual machine sizes, see [Sizes for virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-sizes?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json). <br><br> The available VM sizes depend on region and availability set. For a list of available sizes use these APIs: <br><br> [List all available virtual machine sizes in an availability set](https://docs.microsoft.com/rest/api/compute/availabilitysets/listavailablesizes) <br><br> [List all available virtual machine sizes in a region](https://docs.microsoft.com/rest/api/compute/virtualmachinesizes/list) <br><br> [List all available virtual machine sizes for resizing](https://docs.microsoft.com/rest/api/compute/virtualmachines/listavailablesizes)
"""
if vm_size is not None:
pulumi.set(__self__, "vm_size", vm_size)
@property
@pulumi.getter(name="vmSize")
def vm_size(self) -> Optional[pulumi.Input[Union[str, 'VirtualMachineSizeTypes']]]:
"""
Specifies the size of the virtual machine. For more information about virtual machine sizes, see [Sizes for virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-sizes?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json). <br><br> The available VM sizes depend on region and availability set. For a list of available sizes use these APIs: <br><br> [List all available virtual machine sizes in an availability set](https://docs.microsoft.com/rest/api/compute/availabilitysets/listavailablesizes) <br><br> [List all available virtual machine sizes in a region](https://docs.microsoft.com/rest/api/compute/virtualmachinesizes/list) <br><br> [List all available virtual machine sizes for resizing](https://docs.microsoft.com/rest/api/compute/virtualmachines/listavailablesizes)
"""
return pulumi.get(self, "vm_size")
@vm_size.setter
def vm_size(self, value: Optional[pulumi.Input[Union[str, 'VirtualMachineSizeTypes']]]):
pulumi.set(self, "vm_size", value)
@pulumi.input_type
class ImageDataDiskArgs:
def __init__(__self__, *,
lun: pulumi.Input[int],
blob_uri: Optional[pulumi.Input[str]] = None,
caching: Optional[pulumi.Input['CachingTypes']] = None,
disk_encryption_set: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']] = None,
disk_size_gb: Optional[pulumi.Input[int]] = None,
managed_disk: Optional[pulumi.Input['SubResourceArgs']] = None,
snapshot: Optional[pulumi.Input['SubResourceArgs']] = None,
storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]] = None):
"""
Describes a data disk.
:param pulumi.Input[int] lun: Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
:param pulumi.Input[str] blob_uri: The Virtual Hard Disk.
:param pulumi.Input['CachingTypes'] caching: Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
:param pulumi.Input['DiskEncryptionSetParametersArgs'] disk_encryption_set: Specifies the customer managed disk encryption set resource id for the managed image disk.
:param pulumi.Input[int] disk_size_gb: Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
:param pulumi.Input['SubResourceArgs'] managed_disk: The managedDisk.
:param pulumi.Input['SubResourceArgs'] snapshot: The snapshot.
:param pulumi.Input[Union[str, 'StorageAccountTypes']] storage_account_type: Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
"""
pulumi.set(__self__, "lun", lun)
if blob_uri is not None:
pulumi.set(__self__, "blob_uri", blob_uri)
if caching is not None:
pulumi.set(__self__, "caching", caching)
if disk_encryption_set is not None:
pulumi.set(__self__, "disk_encryption_set", disk_encryption_set)
if disk_size_gb is not None:
pulumi.set(__self__, "disk_size_gb", disk_size_gb)
if managed_disk is not None:
pulumi.set(__self__, "managed_disk", managed_disk)
if snapshot is not None:
pulumi.set(__self__, "snapshot", snapshot)
if storage_account_type is not None:
pulumi.set(__self__, "storage_account_type", storage_account_type)
@property
@pulumi.getter
def lun(self) -> pulumi.Input[int]:
"""
Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
"""
return pulumi.get(self, "lun")
@lun.setter
def lun(self, value: pulumi.Input[int]):
pulumi.set(self, "lun", value)
@property
@pulumi.getter(name="blobUri")
def blob_uri(self) -> Optional[pulumi.Input[str]]:
"""
The Virtual Hard Disk.
"""
return pulumi.get(self, "blob_uri")
@blob_uri.setter
def blob_uri(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "blob_uri", value)
@property
@pulumi.getter
def caching(self) -> Optional[pulumi.Input['CachingTypes']]:
"""
Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
"""
return pulumi.get(self, "caching")
@caching.setter
def caching(self, value: Optional[pulumi.Input['CachingTypes']]):
pulumi.set(self, "caching", value)
@property
@pulumi.getter(name="diskEncryptionSet")
def disk_encryption_set(self) -> Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]:
"""
Specifies the customer managed disk encryption set resource id for the managed image disk.
"""
return pulumi.get(self, "disk_encryption_set")
@disk_encryption_set.setter
def disk_encryption_set(self, value: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]):
pulumi.set(self, "disk_encryption_set", value)
@property
@pulumi.getter(name="diskSizeGB")
def disk_size_gb(self) -> Optional[pulumi.Input[int]]:
"""
Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
"""
return pulumi.get(self, "disk_size_gb")
@disk_size_gb.setter
def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "disk_size_gb", value)
@property
@pulumi.getter(name="managedDisk")
def managed_disk(self) -> Optional[pulumi.Input['SubResourceArgs']]:
"""
The managedDisk.
"""
return pulumi.get(self, "managed_disk")
@managed_disk.setter
def managed_disk(self, value: Optional[pulumi.Input['SubResourceArgs']]):
pulumi.set(self, "managed_disk", value)
@property
@pulumi.getter
def snapshot(self) -> Optional[pulumi.Input['SubResourceArgs']]:
"""
The snapshot.
"""
return pulumi.get(self, "snapshot")
@snapshot.setter
def snapshot(self, value: Optional[pulumi.Input['SubResourceArgs']]):
pulumi.set(self, "snapshot", value)
@property
@pulumi.getter(name="storageAccountType")
def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]:
"""
Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
"""
return pulumi.get(self, "storage_account_type")
@storage_account_type.setter
def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]):
pulumi.set(self, "storage_account_type", value)
@pulumi.input_type
class ImageOSDiskArgs:
def __init__(__self__, *,
os_state: pulumi.Input['OperatingSystemStateTypes'],
os_type: pulumi.Input['OperatingSystemTypes'],
blob_uri: Optional[pulumi.Input[str]] = None,
caching: Optional[pulumi.Input['CachingTypes']] = None,
disk_encryption_set: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']] = None,
disk_size_gb: Optional[pulumi.Input[int]] = None,
managed_disk: Optional[pulumi.Input['SubResourceArgs']] = None,
snapshot: Optional[pulumi.Input['SubResourceArgs']] = None,
storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]] = None):
"""
Describes an Operating System disk.
:param pulumi.Input['OperatingSystemStateTypes'] os_state: The OS State.
:param pulumi.Input['OperatingSystemTypes'] os_type: This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. <br><br> Possible values are: <br><br> **Windows** <br><br> **Linux**
:param pulumi.Input[str] blob_uri: The Virtual Hard Disk.
:param pulumi.Input['CachingTypes'] caching: Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
:param pulumi.Input['DiskEncryptionSetParametersArgs'] disk_encryption_set: Specifies the customer managed disk encryption set resource id for the managed image disk.
:param pulumi.Input[int] disk_size_gb: Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
:param pulumi.Input['SubResourceArgs'] managed_disk: The managedDisk.
:param pulumi.Input['SubResourceArgs'] snapshot: The snapshot.
:param pulumi.Input[Union[str, 'StorageAccountTypes']] storage_account_type: Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
"""
pulumi.set(__self__, "os_state", os_state)
pulumi.set(__self__, "os_type", os_type)
if blob_uri is not None:
pulumi.set(__self__, "blob_uri", blob_uri)
if caching is not None:
pulumi.set(__self__, "caching", caching)
if disk_encryption_set is not None:
pulumi.set(__self__, "disk_encryption_set", disk_encryption_set)
if disk_size_gb is not None:
pulumi.set(__self__, "disk_size_gb", disk_size_gb)
if managed_disk is not None:
pulumi.set(__self__, "managed_disk", managed_disk)
if snapshot is not None:
pulumi.set(__self__, "snapshot", snapshot)
if storage_account_type is not None:
pulumi.set(__self__, "storage_account_type", storage_account_type)
@property
@pulumi.getter(name="osState")
def os_state(self) -> pulumi.Input['OperatingSystemStateTypes']:
"""
The OS State.
"""
return pulumi.get(self, "os_state")
@os_state.setter
def os_state(self, value: pulumi.Input['OperatingSystemStateTypes']):
pulumi.set(self, "os_state", value)
@property
@pulumi.getter(name="osType")
def os_type(self) -> pulumi.Input['OperatingSystemTypes']:
"""
This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. <br><br> Possible values are: <br><br> **Windows** <br><br> **Linux**
"""
return pulumi.get(self, "os_type")
@os_type.setter
def os_type(self, value: pulumi.Input['OperatingSystemTypes']):
pulumi.set(self, "os_type", value)
@property
@pulumi.getter(name="blobUri")
def blob_uri(self) -> Optional[pulumi.Input[str]]:
"""
The Virtual Hard Disk.
"""
return pulumi.get(self, "blob_uri")
@blob_uri.setter
def blob_uri(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "blob_uri", value)
@property
@pulumi.getter
def caching(self) -> Optional[pulumi.Input['CachingTypes']]:
"""
Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
"""
return pulumi.get(self, "caching")
@caching.setter
def caching(self, value: Optional[pulumi.Input['CachingTypes']]):
pulumi.set(self, "caching", value)
@property
@pulumi.getter(name="diskEncryptionSet")
def disk_encryption_set(self) -> Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]:
"""
Specifies the customer managed disk encryption set resource id for the managed image disk.
"""
return pulumi.get(self, "disk_encryption_set")
@disk_encryption_set.setter
def disk_encryption_set(self, value: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]):
pulumi.set(self, "disk_encryption_set", value)
@property
@pulumi.getter(name="diskSizeGB")
def disk_size_gb(self) -> Optional[pulumi.Input[int]]:
"""
Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
"""
return pulumi.get(self, "disk_size_gb")
@disk_size_gb.setter
def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "disk_size_gb", value)
@property
@pulumi.getter(name="managedDisk")
def managed_disk(self) -> Optional[pulumi.Input['SubResourceArgs']]:
"""
The managedDisk.
"""
return pulumi.get(self, "managed_disk")
@managed_disk.setter
def managed_disk(self, value: Optional[pulumi.Input['SubResourceArgs']]):
pulumi.set(self, "managed_disk", value)
@property
@pulumi.getter
def snapshot(self) -> Optional[pulumi.Input['SubResourceArgs']]:
"""
The snapshot.
"""
return pulumi.get(self, "snapshot")
@snapshot.setter
def snapshot(self, value: Optional[pulumi.Input['SubResourceArgs']]):
pulumi.set(self, "snapshot", value)
@property
@pulumi.getter(name="storageAccountType")
def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]:
"""
Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
"""
return pulumi.get(self, "storage_account_type")
@storage_account_type.setter
def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]):
pulumi.set(self, "storage_account_type", value)
@pulumi.input_type
class ImagePurchasePlanArgs:
def __init__(__self__, *,
name: Optional[pulumi.Input[str]] = None,
product: Optional[pulumi.Input[str]] = None,
publisher: Optional[pulumi.Input[str]] = None):
"""
Describes the gallery Image Definition purchase plan. This is used by marketplace images.
:param pulumi.Input[str] name: The plan ID.
:param pulumi.Input[str] product: The product ID.
:param pulumi.Input[str] publisher: The publisher ID.
"""
if name is not None:
pulumi.set(__self__, "name", name)
if product is not None:
pulumi.set(__self__, "product", product)
if publisher is not None:
pulumi.set(__self__, "publisher", publisher)
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
"""
The plan ID.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
@property
@pulumi.getter
def product(self) -> Optional[pulumi.Input[str]]:
"""
The product ID.
"""
return pulumi.get(self, "product")
@product.setter
def product(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "product", value)
@property
@pulumi.getter
def publisher(self) -> Optional[pulumi.Input[str]]:
"""
The publisher ID.
"""
return pulumi.get(self, "publisher")
@publisher.setter
def publisher(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "publisher", value)
@pulumi.input_type
class ImageReferenceArgs:
def __init__(__self__, *,
id: Optional[pulumi.Input[str]] = None,
offer: Optional[pulumi.Input[str]] = None,
publisher: Optional[pulumi.Input[str]] = None,
sku: Optional[pulumi.Input[str]] = None,
version: Optional[pulumi.Input[str]] = None):
"""
Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations. NOTE: Image reference publisher and offer can only be set when you create the scale set.
:param pulumi.Input[str] id: Resource Id
:param pulumi.Input[str] offer: Specifies the offer of the platform image or marketplace image used to create the virtual machine.
:param pulumi.Input[str] publisher: The image publisher.
:param pulumi.Input[str] sku: The image SKU.
:param pulumi.Input[str] version: Specifies the version of the platform image or marketplace image used to create the virtual machine. The allowed formats are Major.Minor.Build or 'latest'. Major, Minor, and Build are decimal numbers. Specify 'latest' to use the latest version of an image available at deploy time. Even if you use 'latest', the VM image will not automatically update after deploy time even if a new version becomes available.
"""
if id is not None:
pulumi.set(__self__, "id", id)
if offer is not None:
pulumi.set(__self__, "offer", offer)
if publisher is not None:
pulumi.set(__self__, "publisher", publisher)
if sku is not None:
pulumi.set(__self__, "sku", sku)
if version is not None:
pulumi.set(__self__, "version", version)
@property
@pulumi.getter
def id(self) -> Optional[pulumi.Input[str]]:
"""
Resource Id
"""
return pulumi.get(self, "id")
@id.setter
def id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "id", value)
@property
@pulumi.getter
def offer(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the offer of the platform image or marketplace image used to create the virtual machine.
"""
return pulumi.get(self, "offer")
@offer.setter
def offer(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "offer", value)
@property
@pulumi.getter
def publisher(self) -> Optional[pulumi.Input[str]]:
"""
The image publisher.
"""
return pulumi.get(self, "publisher")
@publisher.setter
def publisher(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "publisher", value)
@property
@pulumi.getter
def sku(self) -> Optional[pulumi.Input[str]]:
"""
The image SKU.
"""
return pulumi.get(self, "sku")
@sku.setter
def sku(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "sku", value)
@property
@pulumi.getter
def version(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the version of the platform image or marketplace image used to create the virtual machine. The allowed formats are Major.Minor.Build or 'latest'. Major, Minor, and Build are decimal numbers. Specify 'latest' to use the latest version of an image available at deploy time. Even if you use 'latest', the VM image will not automatically update after deploy time even if a new version becomes available.
"""
return pulumi.get(self, "version")
@version.setter
def version(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "version", value)
@pulumi.input_type
class ImageStorageProfileArgs:
def __init__(__self__, *,
data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['ImageDataDiskArgs']]]] = None,
os_disk: Optional[pulumi.Input['ImageOSDiskArgs']] = None,
zone_resilient: Optional[pulumi.Input[bool]] = None):
"""
Describes a storage profile.
:param pulumi.Input[Sequence[pulumi.Input['ImageDataDiskArgs']]] data_disks: Specifies the parameters that are used to add a data disk to a virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
:param pulumi.Input['ImageOSDiskArgs'] os_disk: Specifies information about the operating system disk used by the virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
:param pulumi.Input[bool] zone_resilient: Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
"""
if data_disks is not None:
pulumi.set(__self__, "data_disks", data_disks)
if os_disk is not None:
pulumi.set(__self__, "os_disk", os_disk)
if zone_resilient is not None:
pulumi.set(__self__, "zone_resilient", zone_resilient)
@property
@pulumi.getter(name="dataDisks")
def data_disks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ImageDataDiskArgs']]]]:
"""
Specifies the parameters that are used to add a data disk to a virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
"""
return pulumi.get(self, "data_disks")
@data_disks.setter
def data_disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ImageDataDiskArgs']]]]):
pulumi.set(self, "data_disks", value)
@property
@pulumi.getter(name="osDisk")
def os_disk(self) -> Optional[pulumi.Input['ImageOSDiskArgs']]:
"""
Specifies information about the operating system disk used by the virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
"""
return pulumi.get(self, "os_disk")
@os_disk.setter
def os_disk(self, value: Optional[pulumi.Input['ImageOSDiskArgs']]):
pulumi.set(self, "os_disk", value)
@property
@pulumi.getter(name="zoneResilient")
def zone_resilient(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
"""
return pulumi.get(self, "zone_resilient")
@zone_resilient.setter
def zone_resilient(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "zone_resilient", value)
@pulumi.input_type
class InstanceViewStatusArgs:
def __init__(__self__, *,
code: Optional[pulumi.Input[str]] = None,
display_status: Optional[pulumi.Input[str]] = None,
level: Optional[pulumi.Input['StatusLevelTypes']] = None,
message: Optional[pulumi.Input[str]] = None,
time: Optional[pulumi.Input[str]] = None):
"""
Instance view status.
:param pulumi.Input[str] code: The status code.
:param pulumi.Input[str] display_status: The short localizable label for the status.
:param pulumi.Input['StatusLevelTypes'] level: The level code.
:param pulumi.Input[str] message: The detailed status message, including for alerts and error messages.
:param pulumi.Input[str] time: The time of the status.
"""
if code is not None:
pulumi.set(__self__, "code", code)
if display_status is not None:
pulumi.set(__self__, "display_status", display_status)
if level is not None:
pulumi.set(__self__, "level", level)
if message is not None:
pulumi.set(__self__, "message", message)
if time is not None:
pulumi.set(__self__, "time", time)
@property
@pulumi.getter
def code(self) -> Optional[pulumi.Input[str]]:
"""
The status code.
"""
return pulumi.get(self, "code")
@code.setter
def code(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "code", value)
@property
@pulumi.getter(name="displayStatus")
def display_status(self) -> Optional[pulumi.Input[str]]:
"""
The short localizable label for the status.
"""
return pulumi.get(self, "display_status")
@display_status.setter
def display_status(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "display_status", value)
@property
@pulumi.getter
def level(self) -> Optional[pulumi.Input['StatusLevelTypes']]:
"""
The level code.
"""
return pulumi.get(self, "level")
@level.setter
def level(self, value: Optional[pulumi.Input['StatusLevelTypes']]):
pulumi.set(self, "level", value)
@property
@pulumi.getter
def message(self) -> Optional[pulumi.Input[str]]:
"""
The detailed status message, including for alerts and error messages.
"""
return pulumi.get(self, "message")
@message.setter
def message(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "message", value)
@property
@pulumi.getter
def time(self) -> Optional[pulumi.Input[str]]:
"""
The time of the status.
"""
return pulumi.get(self, "time")
@time.setter
def time(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "time", value)
@pulumi.input_type
class KeyVaultKeyReferenceArgs:
def __init__(__self__, *,
key_url: pulumi.Input[str],
source_vault: pulumi.Input['SubResourceArgs']):
"""
Describes a reference to Key Vault Key
:param pulumi.Input[str] key_url: The URL referencing a key encryption key in Key Vault.
:param pulumi.Input['SubResourceArgs'] source_vault: The relative URL of the Key Vault containing the key.
"""
pulumi.set(__self__, "key_url", key_url)
pulumi.set(__self__, "source_vault", source_vault)
@property
@pulumi.getter(name="keyUrl")
def key_url(self) -> pulumi.Input[str]:
"""
The URL referencing a key encryption key in Key Vault.
"""
return pulumi.get(self, "key_url")
@key_url.setter
def key_url(self, value: pulumi.Input[str]):
pulumi.set(self, "key_url", value)
@property
@pulumi.getter(name="sourceVault")
def source_vault(self) -> pulumi.Input['SubResourceArgs']:
"""
The relative URL of the Key Vault containing the key.
"""
return pulumi.get(self, "source_vault")
@source_vault.setter
def source_vault(self, value: pulumi.Input['SubResourceArgs']):
pulumi.set(self, "source_vault", value)
@pulumi.input_type
class KeyVaultSecretReferenceArgs:
def __init__(__self__, *,
secret_url: pulumi.Input[str],
source_vault: pulumi.Input['SubResourceArgs']):
"""
Describes a reference to Key Vault Secret
:param pulumi.Input[str] secret_url: The URL referencing a secret in a Key Vault.
:param pulumi.Input['SubResourceArgs'] source_vault: The relative URL of the Key Vault containing the secret.
"""
pulumi.set(__self__, "secret_url", secret_url)
pulumi.set(__self__, "source_vault", source_vault)
@property
@pulumi.getter(name="secretUrl")
def secret_url(self) -> pulumi.Input[str]:
"""
The URL referencing a secret in a Key Vault.
"""
return pulumi.get(self, "secret_url")
@secret_url.setter
def secret_url(self, value: pulumi.Input[str]):
pulumi.set(self, "secret_url", value)
@property
@pulumi.getter(name="sourceVault")
def source_vault(self) -> pulumi.Input['SubResourceArgs']:
"""
The relative URL of the Key Vault containing the secret.
"""
return pulumi.get(self, "source_vault")
@source_vault.setter
def source_vault(self, value: pulumi.Input['SubResourceArgs']):
pulumi.set(self, "source_vault", value)
@pulumi.input_type
class LinuxConfigurationArgs:
def __init__(__self__, *,
disable_password_authentication: Optional[pulumi.Input[bool]] = None,
provision_vm_agent: Optional[pulumi.Input[bool]] = None,
ssh: Optional[pulumi.Input['SshConfigurationArgs']] = None):
"""
Specifies the Linux operating system settings on the virtual machine. <br><br>For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json) <br><br> For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
:param pulumi.Input[bool] disable_password_authentication: Specifies whether password authentication should be disabled.
:param pulumi.Input[bool] provision_vm_agent: Indicates whether virtual machine agent should be provisioned on the virtual machine. <br><br> When this property is not specified in the request body, default behavior is to set it to true. This will ensure that VM Agent is installed on the VM so that extensions can be added to the VM later.
:param pulumi.Input['SshConfigurationArgs'] ssh: Specifies the ssh key configuration for a Linux OS.
"""
if disable_password_authentication is not None:
pulumi.set(__self__, "disable_password_authentication", disable_password_authentication)
if provision_vm_agent is not None:
pulumi.set(__self__, "provision_vm_agent", provision_vm_agent)
if ssh is not None:
pulumi.set(__self__, "ssh", ssh)
@property
@pulumi.getter(name="disablePasswordAuthentication")
def disable_password_authentication(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether password authentication should be disabled.
"""
return pulumi.get(self, "disable_password_authentication")
@disable_password_authentication.setter
def disable_password_authentication(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "disable_password_authentication", value)
@property
@pulumi.getter(name="provisionVMAgent")
def provision_vm_agent(self) -> Optional[pulumi.Input[bool]]:
"""
Indicates whether virtual machine agent should be provisioned on the virtual machine. <br><br> When this property is not specified in the request body, default behavior is to set it to true. This will ensure that VM Agent is installed on the VM so that extensions can be added to the VM later.
"""
return pulumi.get(self, "provision_vm_agent")
@provision_vm_agent.setter
def provision_vm_agent(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "provision_vm_agent", value)
@property
@pulumi.getter
def ssh(self) -> Optional[pulumi.Input['SshConfigurationArgs']]:
"""
Specifies the ssh key configuration for a Linux OS.
"""
return pulumi.get(self, "ssh")
@ssh.setter
def ssh(self, value: Optional[pulumi.Input['SshConfigurationArgs']]):
pulumi.set(self, "ssh", value)
@pulumi.input_type
class ManagedDiskParametersArgs:
def __init__(__self__, *,
disk_encryption_set: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']] = None,
id: Optional[pulumi.Input[str]] = None,
storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]] = None):
"""
The parameters of a managed disk.
:param pulumi.Input['DiskEncryptionSetParametersArgs'] disk_encryption_set: Specifies the customer managed disk encryption set resource id for the managed disk.
:param pulumi.Input[str] id: Resource Id
:param pulumi.Input[Union[str, 'StorageAccountTypes']] storage_account_type: Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
"""
if disk_encryption_set is not None:
pulumi.set(__self__, "disk_encryption_set", disk_encryption_set)
if id is not None:
pulumi.set(__self__, "id", id)
if storage_account_type is not None:
pulumi.set(__self__, "storage_account_type", storage_account_type)
@property
@pulumi.getter(name="diskEncryptionSet")
def disk_encryption_set(self) -> Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]:
"""
Specifies the customer managed disk encryption set resource id for the managed disk.
"""
return pulumi.get(self, "disk_encryption_set")
@disk_encryption_set.setter
def disk_encryption_set(self, value: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]):
pulumi.set(self, "disk_encryption_set", value)
@property
@pulumi.getter
def id(self) -> Optional[pulumi.Input[str]]:
"""
Resource Id
"""
return pulumi.get(self, "id")
@id.setter
def id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "id", value)
@property
@pulumi.getter(name="storageAccountType")
def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]:
"""
Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
"""
return pulumi.get(self, "storage_account_type")
@storage_account_type.setter
def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]):
pulumi.set(self, "storage_account_type", value)
@pulumi.input_type
class NetworkInterfaceReferenceArgs:
def __init__(__self__, *,
id: Optional[pulumi.Input[str]] = None,
primary: Optional[pulumi.Input[bool]] = None):
"""
Describes a network interface reference.
:param pulumi.Input[str] id: Resource Id
:param pulumi.Input[bool] primary: Specifies the primary network interface in case the virtual machine has more than 1 network interface.
"""
if id is not None:
pulumi.set(__self__, "id", id)
if primary is not None:
pulumi.set(__self__, "primary", primary)
@property
@pulumi.getter
def id(self) -> Optional[pulumi.Input[str]]:
"""
Resource Id
"""
return pulumi.get(self, "id")
@id.setter
def id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "id", value)
@property
@pulumi.getter
def primary(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies the primary network interface in case the virtual machine has more than 1 network interface.
"""
return pulumi.get(self, "primary")
@primary.setter
def primary(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "primary", value)
@pulumi.input_type
class NetworkProfileArgs:
def __init__(__self__, *,
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkInterfaceReferenceArgs']]]] = None):
"""
Specifies the network interfaces of the virtual machine.
:param pulumi.Input[Sequence[pulumi.Input['NetworkInterfaceReferenceArgs']]] network_interfaces: Specifies the list of resource Ids for the network interfaces associated with the virtual machine.
"""
if network_interfaces is not None:
pulumi.set(__self__, "network_interfaces", network_interfaces)
@property
@pulumi.getter(name="networkInterfaces")
def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NetworkInterfaceReferenceArgs']]]]:
"""
Specifies the list of resource Ids for the network interfaces associated with the virtual machine.
"""
return pulumi.get(self, "network_interfaces")
@network_interfaces.setter
def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkInterfaceReferenceArgs']]]]):
pulumi.set(self, "network_interfaces", value)
@pulumi.input_type
class OSDiskArgs:
def __init__(__self__, *,
create_option: pulumi.Input[Union[str, 'DiskCreateOptionTypes']],
caching: Optional[pulumi.Input['CachingTypes']] = None,
diff_disk_settings: Optional[pulumi.Input['DiffDiskSettingsArgs']] = None,
disk_size_gb: Optional[pulumi.Input[int]] = None,
encryption_settings: Optional[pulumi.Input['DiskEncryptionSettingsArgs']] = None,
image: Optional[pulumi.Input['VirtualHardDiskArgs']] = None,
managed_disk: Optional[pulumi.Input['ManagedDiskParametersArgs']] = None,
name: Optional[pulumi.Input[str]] = None,
os_type: Optional[pulumi.Input['OperatingSystemTypes']] = None,
vhd: Optional[pulumi.Input['VirtualHardDiskArgs']] = None,
write_accelerator_enabled: Optional[pulumi.Input[bool]] = None):
"""
Specifies information about the operating system disk used by the virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
:param pulumi.Input[Union[str, 'DiskCreateOptionTypes']] create_option: Specifies how the virtual machine should be created.<br><br> Possible values are:<br><br> **Attach** \u2013 This value is used when you are using a specialized disk to create the virtual machine.<br><br> **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you also use the plan element previously described.
:param pulumi.Input['CachingTypes'] caching: Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None** for Standard storage. **ReadOnly** for Premium storage.
:param pulumi.Input['DiffDiskSettingsArgs'] diff_disk_settings: Specifies the ephemeral Disk Settings for the operating system disk used by the virtual machine.
:param pulumi.Input[int] disk_size_gb: Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
:param pulumi.Input['DiskEncryptionSettingsArgs'] encryption_settings: Specifies the encryption settings for the OS Disk. <br><br> Minimum api-version: 2015-06-15
:param pulumi.Input['VirtualHardDiskArgs'] image: The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist.
:param pulumi.Input['ManagedDiskParametersArgs'] managed_disk: The managed disk parameters.
:param pulumi.Input[str] name: The disk name.
:param pulumi.Input['OperatingSystemTypes'] os_type: This property allows you to specify the type of the OS that is included in the disk if creating a VM from user-image or a specialized VHD. <br><br> Possible values are: <br><br> **Windows** <br><br> **Linux**
:param pulumi.Input['VirtualHardDiskArgs'] vhd: The virtual hard disk.
:param pulumi.Input[bool] write_accelerator_enabled: Specifies whether writeAccelerator should be enabled or disabled on the disk.
"""
pulumi.set(__self__, "create_option", create_option)
if caching is not None:
pulumi.set(__self__, "caching", caching)
if diff_disk_settings is not None:
pulumi.set(__self__, "diff_disk_settings", diff_disk_settings)
if disk_size_gb is not None:
pulumi.set(__self__, "disk_size_gb", disk_size_gb)
if encryption_settings is not None:
pulumi.set(__self__, "encryption_settings", encryption_settings)
if image is not None:
pulumi.set(__self__, "image", image)
if managed_disk is not None:
pulumi.set(__self__, "managed_disk", managed_disk)
if name is not None:
pulumi.set(__self__, "name", name)
if os_type is not None:
pulumi.set(__self__, "os_type", os_type)
if vhd is not None:
pulumi.set(__self__, "vhd", vhd)
if write_accelerator_enabled is not None:
pulumi.set(__self__, "write_accelerator_enabled", write_accelerator_enabled)
@property
@pulumi.getter(name="createOption")
def create_option(self) -> pulumi.Input[Union[str, 'DiskCreateOptionTypes']]:
"""
Specifies how the virtual machine should be created.<br><br> Possible values are:<br><br> **Attach** \u2013 This value is used when you are using a specialized disk to create the virtual machine.<br><br> **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you also use the plan element previously described.
"""
return pulumi.get(self, "create_option")
@create_option.setter
def create_option(self, value: pulumi.Input[Union[str, 'DiskCreateOptionTypes']]):
pulumi.set(self, "create_option", value)
@property
@pulumi.getter
def caching(self) -> Optional[pulumi.Input['CachingTypes']]:
"""
Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None** for Standard storage. **ReadOnly** for Premium storage.
"""
return pulumi.get(self, "caching")
@caching.setter
def caching(self, value: Optional[pulumi.Input['CachingTypes']]):
pulumi.set(self, "caching", value)
@property
@pulumi.getter(name="diffDiskSettings")
def diff_disk_settings(self) -> Optional[pulumi.Input['DiffDiskSettingsArgs']]:
"""
Specifies the ephemeral Disk Settings for the operating system disk used by the virtual machine.
"""
return pulumi.get(self, "diff_disk_settings")
@diff_disk_settings.setter
def diff_disk_settings(self, value: Optional[pulumi.Input['DiffDiskSettingsArgs']]):
pulumi.set(self, "diff_disk_settings", value)
@property
@pulumi.getter(name="diskSizeGB")
def disk_size_gb(self) -> Optional[pulumi.Input[int]]:
"""
Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
"""
return pulumi.get(self, "disk_size_gb")
@disk_size_gb.setter
def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "disk_size_gb", value)
@property
@pulumi.getter(name="encryptionSettings")
def encryption_settings(self) -> Optional[pulumi.Input['DiskEncryptionSettingsArgs']]:
"""
Specifies the encryption settings for the OS Disk. <br><br> Minimum api-version: 2015-06-15
"""
return pulumi.get(self, "encryption_settings")
@encryption_settings.setter
def encryption_settings(self, value: Optional[pulumi.Input['DiskEncryptionSettingsArgs']]):
pulumi.set(self, "encryption_settings", value)
@property
@pulumi.getter
def image(self) -> Optional[pulumi.Input['VirtualHardDiskArgs']]:
"""
The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist.
"""
return pulumi.get(self, "image")
@image.setter
def image(self, value: Optional[pulumi.Input['VirtualHardDiskArgs']]):
pulumi.set(self, "image", value)
@property
@pulumi.getter(name="managedDisk")
def managed_disk(self) -> Optional[pulumi.Input['ManagedDiskParametersArgs']]:
"""
The managed disk parameters.
"""
return pulumi.get(self, "managed_disk")
@managed_disk.setter
def managed_disk(self, value: Optional[pulumi.Input['ManagedDiskParametersArgs']]):
pulumi.set(self, "managed_disk", value)
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
"""
The disk name.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
@property
@pulumi.getter(name="osType")
def os_type(self) -> Optional[pulumi.Input['OperatingSystemTypes']]:
"""
This property allows you to specify the type of the OS that is included in the disk if creating a VM from user-image or a specialized VHD. <br><br> Possible values are: <br><br> **Windows** <br><br> **Linux**
"""
return pulumi.get(self, "os_type")
@os_type.setter
def os_type(self, value: Optional[pulumi.Input['OperatingSystemTypes']]):
pulumi.set(self, "os_type", value)
@property
@pulumi.getter
def vhd(self) -> Optional[pulumi.Input['VirtualHardDiskArgs']]:
"""
The virtual hard disk.
"""
return pulumi.get(self, "vhd")
@vhd.setter
def vhd(self, value: Optional[pulumi.Input['VirtualHardDiskArgs']]):
pulumi.set(self, "vhd", value)
@property
@pulumi.getter(name="writeAcceleratorEnabled")
def write_accelerator_enabled(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether writeAccelerator should be enabled or disabled on the disk.
"""
return pulumi.get(self, "write_accelerator_enabled")
@write_accelerator_enabled.setter
def write_accelerator_enabled(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "write_accelerator_enabled", value)
@pulumi.input_type
class OSDiskImageEncryptionArgs:
def __init__(__self__, *,
disk_encryption_set_id: Optional[pulumi.Input[str]] = None):
"""
Contains encryption settings for an OS disk image.
:param pulumi.Input[str] disk_encryption_set_id: A relative URI containing the resource ID of the disk encryption set.
"""
if disk_encryption_set_id is not None:
pulumi.set(__self__, "disk_encryption_set_id", disk_encryption_set_id)
@property
@pulumi.getter(name="diskEncryptionSetId")
def disk_encryption_set_id(self) -> Optional[pulumi.Input[str]]:
"""
A relative URI containing the resource ID of the disk encryption set.
"""
return pulumi.get(self, "disk_encryption_set_id")
@disk_encryption_set_id.setter
def disk_encryption_set_id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "disk_encryption_set_id", value)
@pulumi.input_type
class OSProfileArgs:
def __init__(__self__, *,
admin_password: Optional[pulumi.Input[str]] = None,
admin_username: Optional[pulumi.Input[str]] = None,
allow_extension_operations: Optional[pulumi.Input[bool]] = None,
computer_name: Optional[pulumi.Input[str]] = None,
custom_data: Optional[pulumi.Input[str]] = None,
linux_configuration: Optional[pulumi.Input['LinuxConfigurationArgs']] = None,
require_guest_provision_signal: Optional[pulumi.Input[bool]] = None,
secrets: Optional[pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]]] = None,
windows_configuration: Optional[pulumi.Input['WindowsConfigurationArgs']] = None):
"""
Specifies the operating system settings for the virtual machine. Some of the settings cannot be changed once VM is provisioned.
:param pulumi.Input[str] admin_password: Specifies the password of the administrator account. <br><br> **Minimum-length (Windows):** 8 characters <br><br> **Minimum-length (Linux):** 6 characters <br><br> **Max-length (Windows):** 123 characters <br><br> **Max-length (Linux):** 72 characters <br><br> **Complexity requirements:** 3 out of 4 conditions below need to be fulfilled <br> Has lower characters <br>Has upper characters <br> Has a digit <br> Has a special character (Regex match [\W_]) <br><br> **Disallowed values:** "abc@123", "P@$$w0rd", "P@ssw0rd", "P@ssword123", "Pa$$word", "pass@word1", "Password!", "Password1", "Password22", "iloveyou!" <br><br> For resetting the password, see [How to reset the Remote Desktop service or its login password in a Windows VM](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-reset-rdp?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json) <br><br> For resetting root password, see [Manage users, SSH, and check or repair disks on Azure Linux VMs using the VMAccess Extension](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-vmaccess-extension?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#reset-root-password)
:param pulumi.Input[str] admin_username: Specifies the name of the administrator account. <br><br> This property cannot be updated after the VM is created. <br><br> **Windows-only restriction:** Cannot end in "." <br><br> **Disallowed values:** "administrator", "admin", "user", "user1", "test", "user2", "test1", "user3", "admin1", "1", "123", "a", "actuser", "adm", "admin2", "aspnet", "backup", "console", "david", "guest", "john", "owner", "root", "server", "sql", "support", "support_388945a0", "sys", "test2", "test3", "user4", "user5". <br><br> **Minimum-length (Linux):** 1 character <br><br> **Max-length (Linux):** 64 characters <br><br> **Max-length (Windows):** 20 characters <br><br><li> For root access to the Linux VM, see [Using root privileges on Linux virtual machines in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-use-root-privileges?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)<br><li> For a list of built-in system users on Linux that should not be used in this field, see [Selecting User Names for Linux on Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-usernames?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
:param pulumi.Input[bool] allow_extension_operations: Specifies whether extension operations should be allowed on the virtual machine. <br><br>This may only be set to False when no extensions are present on the virtual machine.
:param pulumi.Input[str] computer_name: Specifies the host OS name of the virtual machine. <br><br> This name cannot be updated after the VM is created. <br><br> **Max-length (Windows):** 15 characters <br><br> **Max-length (Linux):** 64 characters. <br><br> For naming conventions and restrictions see [Azure infrastructure services implementation guidelines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-infrastructure-subscription-accounts-guidelines?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#1-naming-conventions).
:param pulumi.Input[str] custom_data: Specifies a base-64 encoded string of custom data. The base-64 encoded string is decoded to a binary array that is saved as a file on the Virtual Machine. The maximum length of the binary array is 65535 bytes. <br><br> **Note: Do not pass any secrets or passwords in customData property** <br><br> This property cannot be updated after the VM is created. <br><br> customData is passed to the VM to be saved as a file, for more information see [Custom Data on Azure VMs](https://azure.microsoft.com/en-us/blog/custom-data-and-cloud-init-on-windows-azure/) <br><br> For using cloud-init for your Linux VM, see [Using cloud-init to customize a Linux VM during creation](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-cloud-init?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
:param pulumi.Input['LinuxConfigurationArgs'] linux_configuration: Specifies the Linux operating system settings on the virtual machine. <br><br>For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json) <br><br> For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
:param pulumi.Input[bool] require_guest_provision_signal: Specifies whether the guest provision signal is required to infer provision success of the virtual machine.
:param pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]] secrets: Specifies set of certificates that should be installed onto the virtual machine.
:param pulumi.Input['WindowsConfigurationArgs'] windows_configuration: Specifies Windows operating system settings on the virtual machine.
"""
if admin_password is not None:
pulumi.set(__self__, "admin_password", admin_password)
if admin_username is not None:
pulumi.set(__self__, "admin_username", admin_username)
if allow_extension_operations is not None:
pulumi.set(__self__, "allow_extension_operations", allow_extension_operations)
if computer_name is not None:
pulumi.set(__self__, "computer_name", computer_name)
if custom_data is not None:
pulumi.set(__self__, "custom_data", custom_data)
if linux_configuration is not None:
pulumi.set(__self__, "linux_configuration", linux_configuration)
if require_guest_provision_signal is not None:
pulumi.set(__self__, "require_guest_provision_signal", require_guest_provision_signal)
if secrets is not None:
pulumi.set(__self__, "secrets", secrets)
if windows_configuration is not None:
pulumi.set(__self__, "windows_configuration", windows_configuration)
@property
@pulumi.getter(name="adminPassword")
def admin_password(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the password of the administrator account. <br><br> **Minimum-length (Windows):** 8 characters <br><br> **Minimum-length (Linux):** 6 characters <br><br> **Max-length (Windows):** 123 characters <br><br> **Max-length (Linux):** 72 characters <br><br> **Complexity requirements:** 3 out of 4 conditions below need to be fulfilled <br> Has lower characters <br>Has upper characters <br> Has a digit <br> Has a special character (Regex match [\W_]) <br><br> **Disallowed values:** "abc@123", "P@$$w0rd", "P@ssw0rd", "P@ssword123", "Pa$$word", "pass@word1", "Password!", "Password1", "Password22", "iloveyou!" <br><br> For resetting the password, see [How to reset the Remote Desktop service or its login password in a Windows VM](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-reset-rdp?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json) <br><br> For resetting root password, see [Manage users, SSH, and check or repair disks on Azure Linux VMs using the VMAccess Extension](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-vmaccess-extension?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#reset-root-password)
"""
return pulumi.get(self, "admin_password")
@admin_password.setter
def admin_password(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "admin_password", value)
@property
@pulumi.getter(name="adminUsername")
def admin_username(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the name of the administrator account. <br><br> This property cannot be updated after the VM is created. <br><br> **Windows-only restriction:** Cannot end in "." <br><br> **Disallowed values:** "administrator", "admin", "user", "user1", "test", "user2", "test1", "user3", "admin1", "1", "123", "a", "actuser", "adm", "admin2", "aspnet", "backup", "console", "david", "guest", "john", "owner", "root", "server", "sql", "support", "support_388945a0", "sys", "test2", "test3", "user4", "user5". <br><br> **Minimum-length (Linux):** 1 character <br><br> **Max-length (Linux):** 64 characters <br><br> **Max-length (Windows):** 20 characters <br><br><li> For root access to the Linux VM, see [Using root privileges on Linux virtual machines in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-use-root-privileges?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)<br><li> For a list of built-in system users on Linux that should not be used in this field, see [Selecting User Names for Linux on Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-usernames?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
"""
return pulumi.get(self, "admin_username")
@admin_username.setter
def admin_username(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "admin_username", value)
@property
@pulumi.getter(name="allowExtensionOperations")
def allow_extension_operations(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether extension operations should be allowed on the virtual machine. <br><br>This may only be set to False when no extensions are present on the virtual machine.
"""
return pulumi.get(self, "allow_extension_operations")
@allow_extension_operations.setter
def allow_extension_operations(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "allow_extension_operations", value)
@property
@pulumi.getter(name="computerName")
def computer_name(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the host OS name of the virtual machine. <br><br> This name cannot be updated after the VM is created. <br><br> **Max-length (Windows):** 15 characters <br><br> **Max-length (Linux):** 64 characters. <br><br> For naming conventions and restrictions see [Azure infrastructure services implementation guidelines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-infrastructure-subscription-accounts-guidelines?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#1-naming-conventions).
"""
return pulumi.get(self, "computer_name")
@computer_name.setter
def computer_name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "computer_name", value)
@property
@pulumi.getter(name="customData")
def custom_data(self) -> Optional[pulumi.Input[str]]:
"""
Specifies a base-64 encoded string of custom data. The base-64 encoded string is decoded to a binary array that is saved as a file on the Virtual Machine. The maximum length of the binary array is 65535 bytes. <br><br> **Note: Do not pass any secrets or passwords in customData property** <br><br> This property cannot be updated after the VM is created. <br><br> customData is passed to the VM to be saved as a file, for more information see [Custom Data on Azure VMs](https://azure.microsoft.com/en-us/blog/custom-data-and-cloud-init-on-windows-azure/) <br><br> For using cloud-init for your Linux VM, see [Using cloud-init to customize a Linux VM during creation](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-cloud-init?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
"""
return pulumi.get(self, "custom_data")
@custom_data.setter
def custom_data(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "custom_data", value)
@property
@pulumi.getter(name="linuxConfiguration")
def linux_configuration(self) -> Optional[pulumi.Input['LinuxConfigurationArgs']]:
"""
Specifies the Linux operating system settings on the virtual machine. <br><br>For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json) <br><br> For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
"""
return pulumi.get(self, "linux_configuration")
@linux_configuration.setter
def linux_configuration(self, value: Optional[pulumi.Input['LinuxConfigurationArgs']]):
pulumi.set(self, "linux_configuration", value)
@property
@pulumi.getter(name="requireGuestProvisionSignal")
def require_guest_provision_signal(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether the guest provision signal is required to infer provision success of the virtual machine.
"""
return pulumi.get(self, "require_guest_provision_signal")
@require_guest_provision_signal.setter
def require_guest_provision_signal(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "require_guest_provision_signal", value)
@property
@pulumi.getter
def secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]]]:
"""
Specifies set of certificates that should be installed onto the virtual machine.
"""
return pulumi.get(self, "secrets")
@secrets.setter
def secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]]]):
pulumi.set(self, "secrets", value)
@property
@pulumi.getter(name="windowsConfiguration")
def windows_configuration(self) -> Optional[pulumi.Input['WindowsConfigurationArgs']]:
"""
Specifies Windows operating system settings on the virtual machine.
"""
return pulumi.get(self, "windows_configuration")
@windows_configuration.setter
def windows_configuration(self, value: Optional[pulumi.Input['WindowsConfigurationArgs']]):
pulumi.set(self, "windows_configuration", value)
@pulumi.input_type
class PlanArgs:
def __init__(__self__, *,
name: Optional[pulumi.Input[str]] = None,
product: Optional[pulumi.Input[str]] = None,
promotion_code: Optional[pulumi.Input[str]] = None,
publisher: Optional[pulumi.Input[str]] = None):
"""
Specifies information about the marketplace image used to create the virtual machine. This element is only used for marketplace images. Before you can use a marketplace image from an API, you must enable the image for programmatic use. In the Azure portal, find the marketplace image that you want to use and then click **Want to deploy programmatically, Get Started ->**. Enter any required information and then click **Save**.
:param pulumi.Input[str] name: The plan ID.
:param pulumi.Input[str] product: Specifies the product of the image from the marketplace. This is the same value as Offer under the imageReference element.
:param pulumi.Input[str] promotion_code: The promotion code.
:param pulumi.Input[str] publisher: The publisher ID.
"""
if name is not None:
pulumi.set(__self__, "name", name)
if product is not None:
pulumi.set(__self__, "product", product)
if promotion_code is not None:
pulumi.set(__self__, "promotion_code", promotion_code)
if publisher is not None:
pulumi.set(__self__, "publisher", publisher)
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
"""
The plan ID.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
@property
@pulumi.getter
def product(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the product of the image from the marketplace. This is the same value as Offer under the imageReference element.
"""
return pulumi.get(self, "product")
@product.setter
def product(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "product", value)
@property
@pulumi.getter(name="promotionCode")
def promotion_code(self) -> Optional[pulumi.Input[str]]:
"""
The promotion code.
"""
return pulumi.get(self, "promotion_code")
@promotion_code.setter
def promotion_code(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "promotion_code", value)
@property
@pulumi.getter
def publisher(self) -> Optional[pulumi.Input[str]]:
"""
The publisher ID.
"""
return pulumi.get(self, "publisher")
@publisher.setter
def publisher(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "publisher", value)
@pulumi.input_type
class RecommendedMachineConfigurationArgs:
def __init__(__self__, *,
memory: Optional[pulumi.Input['ResourceRangeArgs']] = None,
v_cpus: Optional[pulumi.Input['ResourceRangeArgs']] = None):
"""
The properties describe the recommended machine configuration for this Image Definition. These properties are updatable.
:param pulumi.Input['ResourceRangeArgs'] memory: Describes the resource range.
:param pulumi.Input['ResourceRangeArgs'] v_cpus: Describes the resource range.
"""
if memory is not None:
pulumi.set(__self__, "memory", memory)
if v_cpus is not None:
pulumi.set(__self__, "v_cpus", v_cpus)
@property
@pulumi.getter
def memory(self) -> Optional[pulumi.Input['ResourceRangeArgs']]:
"""
Describes the resource range.
"""
return pulumi.get(self, "memory")
@memory.setter
def memory(self, value: Optional[pulumi.Input['ResourceRangeArgs']]):
pulumi.set(self, "memory", value)
@property
@pulumi.getter(name="vCPUs")
def v_cpus(self) -> Optional[pulumi.Input['ResourceRangeArgs']]:
"""
Describes the resource range.
"""
return pulumi.get(self, "v_cpus")
@v_cpus.setter
def v_cpus(self, value: Optional[pulumi.Input['ResourceRangeArgs']]):
pulumi.set(self, "v_cpus", value)
@pulumi.input_type
class ResourceRangeArgs:
def __init__(__self__, *,
max: Optional[pulumi.Input[int]] = None,
min: Optional[pulumi.Input[int]] = None):
"""
Describes the resource range.
:param pulumi.Input[int] max: The maximum number of the resource.
:param pulumi.Input[int] min: The minimum number of the resource.
"""
if max is not None:
pulumi.set(__self__, "max", max)
if min is not None:
pulumi.set(__self__, "min", min)
@property
@pulumi.getter
def max(self) -> Optional[pulumi.Input[int]]:
"""
The maximum number of the resource.
"""
return pulumi.get(self, "max")
@max.setter
def max(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "max", value)
@property
@pulumi.getter
def min(self) -> Optional[pulumi.Input[int]]:
"""
The minimum number of the resource.
"""
return pulumi.get(self, "min")
@min.setter
def min(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "min", value)
@pulumi.input_type
class RollingUpgradePolicyArgs:
def __init__(__self__, *,
max_batch_instance_percent: Optional[pulumi.Input[int]] = None,
max_unhealthy_instance_percent: Optional[pulumi.Input[int]] = None,
max_unhealthy_upgraded_instance_percent: Optional[pulumi.Input[int]] = None,
pause_time_between_batches: Optional[pulumi.Input[str]] = None):
"""
The configuration parameters used while performing a rolling upgrade.
:param pulumi.Input[int] max_batch_instance_percent: The maximum percent of total virtual machine instances that will be upgraded simultaneously by the rolling upgrade in one batch. As this is a maximum, unhealthy instances in previous or future batches can cause the percentage of instances in a batch to decrease to ensure higher reliability. The default value for this parameter is 20%.
:param pulumi.Input[int] max_unhealthy_instance_percent: The maximum percentage of the total virtual machine instances in the scale set that can be simultaneously unhealthy, either as a result of being upgraded, or by being found in an unhealthy state by the virtual machine health checks before the rolling upgrade aborts. This constraint will be checked prior to starting any batch. The default value for this parameter is 20%.
:param pulumi.Input[int] max_unhealthy_upgraded_instance_percent: The maximum percentage of upgraded virtual machine instances that can be found to be in an unhealthy state. This check will happen after each batch is upgraded. If this percentage is ever exceeded, the rolling update aborts. The default value for this parameter is 20%.
:param pulumi.Input[str] pause_time_between_batches: The wait time between completing the update for all virtual machines in one batch and starting the next batch. The time duration should be specified in ISO 8601 format. The default value is 0 seconds (PT0S).
"""
if max_batch_instance_percent is not None:
pulumi.set(__self__, "max_batch_instance_percent", max_batch_instance_percent)
if max_unhealthy_instance_percent is not None:
pulumi.set(__self__, "max_unhealthy_instance_percent", max_unhealthy_instance_percent)
if max_unhealthy_upgraded_instance_percent is not None:
pulumi.set(__self__, "max_unhealthy_upgraded_instance_percent", max_unhealthy_upgraded_instance_percent)
if pause_time_between_batches is not None:
pulumi.set(__self__, "pause_time_between_batches", pause_time_between_batches)
@property
@pulumi.getter(name="maxBatchInstancePercent")
def max_batch_instance_percent(self) -> Optional[pulumi.Input[int]]:
"""
The maximum percent of total virtual machine instances that will be upgraded simultaneously by the rolling upgrade in one batch. As this is a maximum, unhealthy instances in previous or future batches can cause the percentage of instances in a batch to decrease to ensure higher reliability. The default value for this parameter is 20%.
"""
return pulumi.get(self, "max_batch_instance_percent")
@max_batch_instance_percent.setter
def max_batch_instance_percent(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "max_batch_instance_percent", value)
@property
@pulumi.getter(name="maxUnhealthyInstancePercent")
def max_unhealthy_instance_percent(self) -> Optional[pulumi.Input[int]]:
"""
The maximum percentage of the total virtual machine instances in the scale set that can be simultaneously unhealthy, either as a result of being upgraded, or by being found in an unhealthy state by the virtual machine health checks before the rolling upgrade aborts. This constraint will be checked prior to starting any batch. The default value for this parameter is 20%.
"""
return pulumi.get(self, "max_unhealthy_instance_percent")
@max_unhealthy_instance_percent.setter
def max_unhealthy_instance_percent(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "max_unhealthy_instance_percent", value)
@property
@pulumi.getter(name="maxUnhealthyUpgradedInstancePercent")
def max_unhealthy_upgraded_instance_percent(self) -> Optional[pulumi.Input[int]]:
"""
The maximum percentage of upgraded virtual machine instances that can be found to be in an unhealthy state. This check will happen after each batch is upgraded. If this percentage is ever exceeded, the rolling update aborts. The default value for this parameter is 20%.
"""
return pulumi.get(self, "max_unhealthy_upgraded_instance_percent")
@max_unhealthy_upgraded_instance_percent.setter
def max_unhealthy_upgraded_instance_percent(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "max_unhealthy_upgraded_instance_percent", value)
@property
@pulumi.getter(name="pauseTimeBetweenBatches")
def pause_time_between_batches(self) -> Optional[pulumi.Input[str]]:
"""
The wait time between completing the update for all virtual machines in one batch and starting the next batch. The time duration should be specified in ISO 8601 format. The default value is 0 seconds (PT0S).
"""
return pulumi.get(self, "pause_time_between_batches")
@pause_time_between_batches.setter
def pause_time_between_batches(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "pause_time_between_batches", value)
@pulumi.input_type
class ScaleInPolicyArgs:
def __init__(__self__, *,
rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'VirtualMachineScaleSetScaleInRules']]]]] = None):
"""
Describes a scale-in policy for a virtual machine scale set.
:param pulumi.Input[Sequence[pulumi.Input[Union[str, 'VirtualMachineScaleSetScaleInRules']]]] rules: The rules to be followed when scaling-in a virtual machine scale set. <br><br> Possible values are: <br><br> **Default** When a virtual machine scale set is scaled in, the scale set will first be balanced across zones if it is a zonal scale set. Then, it will be balanced across Fault Domains as far as possible. Within each Fault Domain, the virtual machines chosen for removal will be the newest ones that are not protected from scale-in. <br><br> **OldestVM** When a virtual machine scale set is being scaled-in, the oldest virtual machines that are not protected from scale-in will be chosen for removal. For zonal virtual machine scale sets, the scale set will first be balanced across zones. Within each zone, the oldest virtual machines that are not protected will be chosen for removal. <br><br> **NewestVM** When a virtual machine scale set is being scaled-in, the newest virtual machines that are not protected from scale-in will be chosen for removal. For zonal virtual machine scale sets, the scale set will first be balanced across zones. Within each zone, the newest virtual machines that are not protected will be chosen for removal. <br><br>
"""
if rules is not None:
pulumi.set(__self__, "rules", rules)
@property
@pulumi.getter
def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'VirtualMachineScaleSetScaleInRules']]]]]:
"""
The rules to be followed when scaling-in a virtual machine scale set. <br><br> Possible values are: <br><br> **Default** When a virtual machine scale set is scaled in, the scale set will first be balanced across zones if it is a zonal scale set. Then, it will be balanced across Fault Domains as far as possible. Within each Fault Domain, the virtual machines chosen for removal will be the newest ones that are not protected from scale-in. <br><br> **OldestVM** When a virtual machine scale set is being scaled-in, the oldest virtual machines that are not protected from scale-in will be chosen for removal. For zonal virtual machine scale sets, the scale set will first be balanced across zones. Within each zone, the oldest virtual machines that are not protected will be chosen for removal. <br><br> **NewestVM** When a virtual machine scale set is being scaled-in, the newest virtual machines that are not protected from scale-in will be chosen for removal. For zonal virtual machine scale sets, the scale set will first be balanced across zones. Within each zone, the newest virtual machines that are not protected will be chosen for removal. <br><br>
"""
return pulumi.get(self, "rules")
@rules.setter
def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'VirtualMachineScaleSetScaleInRules']]]]]):
pulumi.set(self, "rules", value)
@pulumi.input_type
class ScheduledEventsProfileArgs:
def __init__(__self__, *,
terminate_notification_profile: Optional[pulumi.Input['TerminateNotificationProfileArgs']] = None):
"""
:param pulumi.Input['TerminateNotificationProfileArgs'] terminate_notification_profile: Specifies Terminate Scheduled Event related configurations.
"""
if terminate_notification_profile is not None:
pulumi.set(__self__, "terminate_notification_profile", terminate_notification_profile)
@property
@pulumi.getter(name="terminateNotificationProfile")
def terminate_notification_profile(self) -> Optional[pulumi.Input['TerminateNotificationProfileArgs']]:
"""
Specifies Terminate Scheduled Event related configurations.
"""
return pulumi.get(self, "terminate_notification_profile")
@terminate_notification_profile.setter
def terminate_notification_profile(self, value: Optional[pulumi.Input['TerminateNotificationProfileArgs']]):
pulumi.set(self, "terminate_notification_profile", value)
@pulumi.input_type
class SkuArgs:
def __init__(__self__, *,
capacity: Optional[pulumi.Input[float]] = None,
name: Optional[pulumi.Input[str]] = None,
tier: Optional[pulumi.Input[str]] = None):
"""
Describes a virtual machine scale set sku. NOTE: If the new VM SKU is not supported on the hardware the scale set is currently on, you need to deallocate the VMs in the scale set before you modify the SKU name.
:param pulumi.Input[float] capacity: Specifies the number of virtual machines in the scale set.
:param pulumi.Input[str] name: The sku name.
:param pulumi.Input[str] tier: Specifies the tier of virtual machines in a scale set.<br /><br /> Possible Values:<br /><br /> **Standard**<br /><br /> **Basic**
"""
if capacity is not None:
pulumi.set(__self__, "capacity", capacity)
if name is not None:
pulumi.set(__self__, "name", name)
if tier is not None:
pulumi.set(__self__, "tier", tier)
@property
@pulumi.getter
def capacity(self) -> Optional[pulumi.Input[float]]:
"""
Specifies the number of virtual machines in the scale set.
"""
return pulumi.get(self, "capacity")
@capacity.setter
def capacity(self, value: Optional[pulumi.Input[float]]):
pulumi.set(self, "capacity", value)
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
"""
The sku name.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
@property
@pulumi.getter
def tier(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the tier of virtual machines in a scale set.<br /><br /> Possible Values:<br /><br /> **Standard**<br /><br /> **Basic**
"""
return pulumi.get(self, "tier")
@tier.setter
def tier(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "tier", value)
@pulumi.input_type
class SshConfigurationArgs:
def __init__(__self__, *,
public_keys: Optional[pulumi.Input[Sequence[pulumi.Input['SshPublicKeyArgs']]]] = None):
"""
SSH configuration for Linux based VMs running on Azure
:param pulumi.Input[Sequence[pulumi.Input['SshPublicKeyArgs']]] public_keys: The list of SSH public keys used to authenticate with linux based VMs.
"""
if public_keys is not None:
pulumi.set(__self__, "public_keys", public_keys)
@property
@pulumi.getter(name="publicKeys")
def public_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SshPublicKeyArgs']]]]:
"""
The list of SSH public keys used to authenticate with linux based VMs.
"""
return pulumi.get(self, "public_keys")
@public_keys.setter
def public_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SshPublicKeyArgs']]]]):
pulumi.set(self, "public_keys", value)
@pulumi.input_type
class SshPublicKeyArgs:
def __init__(__self__, *,
key_data: Optional[pulumi.Input[str]] = None,
path: Optional[pulumi.Input[str]] = None):
"""
Contains information about SSH certificate public key and the path on the Linux VM where the public key is placed.
:param pulumi.Input[str] key_data: SSH public key certificate used to authenticate with the VM through ssh. The key needs to be at least 2048-bit and in ssh-rsa format. <br><br> For creating ssh keys, see [Create SSH keys on Linux and Mac for Linux VMs in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-mac-create-ssh-keys?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
:param pulumi.Input[str] path: Specifies the full path on the created VM where ssh public key is stored. If the file already exists, the specified key is appended to the file. Example: /home/user/.ssh/authorized_keys
"""
if key_data is not None:
pulumi.set(__self__, "key_data", key_data)
if path is not None:
pulumi.set(__self__, "path", path)
@property
@pulumi.getter(name="keyData")
def key_data(self) -> Optional[pulumi.Input[str]]:
"""
SSH public key certificate used to authenticate with the VM through ssh. The key needs to be at least 2048-bit and in ssh-rsa format. <br><br> For creating ssh keys, see [Create SSH keys on Linux and Mac for Linux VMs in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-mac-create-ssh-keys?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
"""
return pulumi.get(self, "key_data")
@key_data.setter
def key_data(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "key_data", value)
@property
@pulumi.getter
def path(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the full path on the created VM where ssh public key is stored. If the file already exists, the specified key is appended to the file. Example: /home/user/.ssh/authorized_keys
"""
return pulumi.get(self, "path")
@path.setter
def path(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "path", value)
@pulumi.input_type
class StorageProfileArgs:
def __init__(__self__, *,
data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['DataDiskArgs']]]] = None,
image_reference: Optional[pulumi.Input['ImageReferenceArgs']] = None,
os_disk: Optional[pulumi.Input['OSDiskArgs']] = None):
"""
Specifies the storage settings for the virtual machine disks.
:param pulumi.Input[Sequence[pulumi.Input['DataDiskArgs']]] data_disks: Specifies the parameters that are used to add a data disk to a virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
:param pulumi.Input['ImageReferenceArgs'] image_reference: Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations.
:param pulumi.Input['OSDiskArgs'] os_disk: Specifies information about the operating system disk used by the virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
"""
if data_disks is not None:
pulumi.set(__self__, "data_disks", data_disks)
if image_reference is not None:
pulumi.set(__self__, "image_reference", image_reference)
if os_disk is not None:
pulumi.set(__self__, "os_disk", os_disk)
@property
@pulumi.getter(name="dataDisks")
def data_disks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataDiskArgs']]]]:
"""
Specifies the parameters that are used to add a data disk to a virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
"""
return pulumi.get(self, "data_disks")
@data_disks.setter
def data_disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataDiskArgs']]]]):
pulumi.set(self, "data_disks", value)
@property
@pulumi.getter(name="imageReference")
def image_reference(self) -> Optional[pulumi.Input['ImageReferenceArgs']]:
"""
Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations.
"""
return pulumi.get(self, "image_reference")
@image_reference.setter
def image_reference(self, value: Optional[pulumi.Input['ImageReferenceArgs']]):
pulumi.set(self, "image_reference", value)
@property
@pulumi.getter(name="osDisk")
def os_disk(self) -> Optional[pulumi.Input['OSDiskArgs']]:
"""
Specifies information about the operating system disk used by the virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
"""
return pulumi.get(self, "os_disk")
@os_disk.setter
def os_disk(self, value: Optional[pulumi.Input['OSDiskArgs']]):
pulumi.set(self, "os_disk", value)
@pulumi.input_type
class SubResourceArgs:
def __init__(__self__, *,
id: Optional[pulumi.Input[str]] = None):
"""
:param pulumi.Input[str] id: Resource Id
"""
if id is not None:
pulumi.set(__self__, "id", id)
@property
@pulumi.getter
def id(self) -> Optional[pulumi.Input[str]]:
"""
Resource Id
"""
return pulumi.get(self, "id")
@id.setter
def id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "id", value)
@pulumi.input_type
class TargetRegionArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
encryption: Optional[pulumi.Input['EncryptionImagesArgs']] = None,
regional_replica_count: Optional[pulumi.Input[int]] = None,
storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountType']]] = None):
"""
Describes the target region information.
:param pulumi.Input[str] name: The name of the region.
:param pulumi.Input['EncryptionImagesArgs'] encryption: Optional. Allows users to provide customer managed keys for encrypting the OS and data disks in the gallery artifact.
:param pulumi.Input[int] regional_replica_count: The number of replicas of the Image Version to be created per region. This property is updatable.
:param pulumi.Input[Union[str, 'StorageAccountType']] storage_account_type: Specifies the storage account type to be used to store the image. This property is not updatable.
"""
pulumi.set(__self__, "name", name)
if encryption is not None:
pulumi.set(__self__, "encryption", encryption)
if regional_replica_count is not None:
pulumi.set(__self__, "regional_replica_count", regional_replica_count)
if storage_account_type is not None:
pulumi.set(__self__, "storage_account_type", storage_account_type)
@property
@pulumi.getter
def name(self) -> pulumi.Input[str]:
"""
The name of the region.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: pulumi.Input[str]):
pulumi.set(self, "name", value)
@property
@pulumi.getter
def encryption(self) -> Optional[pulumi.Input['EncryptionImagesArgs']]:
"""
Optional. Allows users to provide customer managed keys for encrypting the OS and data disks in the gallery artifact.
"""
return pulumi.get(self, "encryption")
@encryption.setter
def encryption(self, value: Optional[pulumi.Input['EncryptionImagesArgs']]):
pulumi.set(self, "encryption", value)
@property
@pulumi.getter(name="regionalReplicaCount")
def regional_replica_count(self) -> Optional[pulumi.Input[int]]:
"""
The number of replicas of the Image Version to be created per region. This property is updatable.
"""
return pulumi.get(self, "regional_replica_count")
@regional_replica_count.setter
def regional_replica_count(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "regional_replica_count", value)
@property
@pulumi.getter(name="storageAccountType")
def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountType']]]:
"""
Specifies the storage account type to be used to store the image. This property is not updatable.
"""
return pulumi.get(self, "storage_account_type")
@storage_account_type.setter
def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountType']]]):
pulumi.set(self, "storage_account_type", value)
@pulumi.input_type
class TerminateNotificationProfileArgs:
def __init__(__self__, *,
enable: Optional[pulumi.Input[bool]] = None,
not_before_timeout: Optional[pulumi.Input[str]] = None):
"""
:param pulumi.Input[bool] enable: Specifies whether the Terminate Scheduled event is enabled or disabled.
:param pulumi.Input[str] not_before_timeout: Configurable length of time a Virtual Machine being deleted will have to potentially approve the Terminate Scheduled Event before the event is auto approved (timed out). The configuration must be specified in ISO 8601 format, the default value is 5 minutes (PT5M)
"""
if enable is not None:
pulumi.set(__self__, "enable", enable)
if not_before_timeout is not None:
pulumi.set(__self__, "not_before_timeout", not_before_timeout)
@property
@pulumi.getter
def enable(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether the Terminate Scheduled event is enabled or disabled.
"""
return pulumi.get(self, "enable")
@enable.setter
def enable(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "enable", value)
@property
@pulumi.getter(name="notBeforeTimeout")
def not_before_timeout(self) -> Optional[pulumi.Input[str]]:
"""
Configurable length of time a Virtual Machine being deleted will have to potentially approve the Terminate Scheduled Event before the event is auto approved (timed out). The configuration must be specified in ISO 8601 format, the default value is 5 minutes (PT5M)
"""
return pulumi.get(self, "not_before_timeout")
@not_before_timeout.setter
def not_before_timeout(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "not_before_timeout", value)
@pulumi.input_type
class UpgradePolicyArgs:
def __init__(__self__, *,
automatic_os_upgrade_policy: Optional[pulumi.Input['AutomaticOSUpgradePolicyArgs']] = None,
mode: Optional[pulumi.Input['UpgradeMode']] = None,
rolling_upgrade_policy: Optional[pulumi.Input['RollingUpgradePolicyArgs']] = None):
"""
Describes an upgrade policy - automatic, manual, or rolling.
:param pulumi.Input['AutomaticOSUpgradePolicyArgs'] automatic_os_upgrade_policy: Configuration parameters used for performing automatic OS Upgrade.
:param pulumi.Input['UpgradeMode'] mode: Specifies the mode of an upgrade to virtual machines in the scale set.<br /><br /> Possible values are:<br /><br /> **Manual** - You control the application of updates to virtual machines in the scale set. You do this by using the manualUpgrade action.<br /><br /> **Automatic** - All virtual machines in the scale set are automatically updated at the same time.
:param pulumi.Input['RollingUpgradePolicyArgs'] rolling_upgrade_policy: The configuration parameters used while performing a rolling upgrade.
"""
if automatic_os_upgrade_policy is not None:
pulumi.set(__self__, "automatic_os_upgrade_policy", automatic_os_upgrade_policy)
if mode is not None:
pulumi.set(__self__, "mode", mode)
if rolling_upgrade_policy is not None:
pulumi.set(__self__, "rolling_upgrade_policy", rolling_upgrade_policy)
@property
@pulumi.getter(name="automaticOSUpgradePolicy")
def automatic_os_upgrade_policy(self) -> Optional[pulumi.Input['AutomaticOSUpgradePolicyArgs']]:
"""
Configuration parameters used for performing automatic OS Upgrade.
"""
return pulumi.get(self, "automatic_os_upgrade_policy")
@automatic_os_upgrade_policy.setter
def automatic_os_upgrade_policy(self, value: Optional[pulumi.Input['AutomaticOSUpgradePolicyArgs']]):
pulumi.set(self, "automatic_os_upgrade_policy", value)
@property
@pulumi.getter
def mode(self) -> Optional[pulumi.Input['UpgradeMode']]:
"""
Specifies the mode of an upgrade to virtual machines in the scale set.<br /><br /> Possible values are:<br /><br /> **Manual** - You control the application of updates to virtual machines in the scale set. You do this by using the manualUpgrade action.<br /><br /> **Automatic** - All virtual machines in the scale set are automatically updated at the same time.
"""
return pulumi.get(self, "mode")
@mode.setter
def mode(self, value: Optional[pulumi.Input['UpgradeMode']]):
pulumi.set(self, "mode", value)
@property
@pulumi.getter(name="rollingUpgradePolicy")
def rolling_upgrade_policy(self) -> Optional[pulumi.Input['RollingUpgradePolicyArgs']]:
"""
The configuration parameters used while performing a rolling upgrade.
"""
return pulumi.get(self, "rolling_upgrade_policy")
@rolling_upgrade_policy.setter
def rolling_upgrade_policy(self, value: Optional[pulumi.Input['RollingUpgradePolicyArgs']]):
pulumi.set(self, "rolling_upgrade_policy", value)
@pulumi.input_type
class UserArtifactManageArgs:
def __init__(__self__, *,
install: pulumi.Input[str],
remove: pulumi.Input[str],
update: Optional[pulumi.Input[str]] = None):
"""
:param pulumi.Input[str] install: Required. The path and arguments to install the gallery application. This is limited to 4096 characters.
:param pulumi.Input[str] remove: Required. The path and arguments to remove the gallery application. This is limited to 4096 characters.
:param pulumi.Input[str] update: Optional. The path and arguments to update the gallery application. If not present, then update operation will invoke remove command on the previous version and install command on the current version of the gallery application. This is limited to 4096 characters.
"""
pulumi.set(__self__, "install", install)
pulumi.set(__self__, "remove", remove)
if update is not None:
pulumi.set(__self__, "update", update)
@property
@pulumi.getter
def install(self) -> pulumi.Input[str]:
"""
Required. The path and arguments to install the gallery application. This is limited to 4096 characters.
"""
return pulumi.get(self, "install")
@install.setter
def install(self, value: pulumi.Input[str]):
pulumi.set(self, "install", value)
@property
@pulumi.getter
def remove(self) -> pulumi.Input[str]:
"""
Required. The path and arguments to remove the gallery application. This is limited to 4096 characters.
"""
return pulumi.get(self, "remove")
@remove.setter
def remove(self, value: pulumi.Input[str]):
pulumi.set(self, "remove", value)
@property
@pulumi.getter
def update(self) -> Optional[pulumi.Input[str]]:
"""
Optional. The path and arguments to update the gallery application. If not present, then update operation will invoke remove command on the previous version and install command on the current version of the gallery application. This is limited to 4096 characters.
"""
return pulumi.get(self, "update")
@update.setter
def update(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "update", value)
@pulumi.input_type
class UserArtifactSourceArgs:
def __init__(__self__, *,
media_link: pulumi.Input[str],
default_configuration_link: Optional[pulumi.Input[str]] = None):
"""
The source image from which the Image Version is going to be created.
:param pulumi.Input[str] media_link: Required. The mediaLink of the artifact, must be a readable storage page blob.
:param pulumi.Input[str] default_configuration_link: Optional. The defaultConfigurationLink of the artifact, must be a readable storage page blob.
"""
pulumi.set(__self__, "media_link", media_link)
if default_configuration_link is not None:
pulumi.set(__self__, "default_configuration_link", default_configuration_link)
@property
@pulumi.getter(name="mediaLink")
def media_link(self) -> pulumi.Input[str]:
"""
Required. The mediaLink of the artifact, must be a readable storage page blob.
"""
return pulumi.get(self, "media_link")
@media_link.setter
def media_link(self, value: pulumi.Input[str]):
pulumi.set(self, "media_link", value)
@property
@pulumi.getter(name="defaultConfigurationLink")
def default_configuration_link(self) -> Optional[pulumi.Input[str]]:
"""
Optional. The defaultConfigurationLink of the artifact, must be a readable storage page blob.
"""
return pulumi.get(self, "default_configuration_link")
@default_configuration_link.setter
def default_configuration_link(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "default_configuration_link", value)
@pulumi.input_type
class VaultCertificateArgs:
def __init__(__self__, *,
certificate_store: Optional[pulumi.Input[str]] = None,
certificate_url: Optional[pulumi.Input[str]] = None):
"""
Describes a single certificate reference in a Key Vault, and where the certificate should reside on the VM.
:param pulumi.Input[str] certificate_store: For Windows VMs, specifies the certificate store on the Virtual Machine to which the certificate should be added. The specified certificate store is implicitly in the LocalMachine account. <br><br>For Linux VMs, the certificate file is placed under the /var/lib/waagent directory, with the file name <UppercaseThumbprint>.crt for the X509 certificate file and <UppercaseThumbprint>.prv for private key. Both of these files are .pem formatted.
:param pulumi.Input[str] certificate_url: This is the URL of a certificate that has been uploaded to Key Vault as a secret. For adding a secret to the Key Vault, see [Add a key or secret to the key vault](https://docs.microsoft.com/azure/key-vault/key-vault-get-started/#add). In this case, your certificate needs to be It is the Base64 encoding of the following JSON Object which is encoded in UTF-8: <br><br> {<br> "data":"<Base64-encoded-certificate>",<br> "dataType":"pfx",<br> "password":"<pfx-file-password>"<br>}
"""
if certificate_store is not None:
pulumi.set(__self__, "certificate_store", certificate_store)
if certificate_url is not None:
pulumi.set(__self__, "certificate_url", certificate_url)
@property
@pulumi.getter(name="certificateStore")
def certificate_store(self) -> Optional[pulumi.Input[str]]:
"""
For Windows VMs, specifies the certificate store on the Virtual Machine to which the certificate should be added. The specified certificate store is implicitly in the LocalMachine account. <br><br>For Linux VMs, the certificate file is placed under the /var/lib/waagent directory, with the file name <UppercaseThumbprint>.crt for the X509 certificate file and <UppercaseThumbprint>.prv for private key. Both of these files are .pem formatted.
"""
return pulumi.get(self, "certificate_store")
@certificate_store.setter
def certificate_store(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "certificate_store", value)
@property
@pulumi.getter(name="certificateUrl")
def certificate_url(self) -> Optional[pulumi.Input[str]]:
"""
This is the URL of a certificate that has been uploaded to Key Vault as a secret. For adding a secret to the Key Vault, see [Add a key or secret to the key vault](https://docs.microsoft.com/azure/key-vault/key-vault-get-started/#add). In this case, your certificate needs to be It is the Base64 encoding of the following JSON Object which is encoded in UTF-8: <br><br> {<br> "data":"<Base64-encoded-certificate>",<br> "dataType":"pfx",<br> "password":"<pfx-file-password>"<br>}
"""
return pulumi.get(self, "certificate_url")
@certificate_url.setter
def certificate_url(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "certificate_url", value)
@pulumi.input_type
class VaultSecretGroupArgs:
def __init__(__self__, *,
source_vault: Optional[pulumi.Input['SubResourceArgs']] = None,
vault_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['VaultCertificateArgs']]]] = None):
"""
Describes a set of certificates which are all in the same Key Vault.
:param pulumi.Input['SubResourceArgs'] source_vault: The relative URL of the Key Vault containing all of the certificates in VaultCertificates.
:param pulumi.Input[Sequence[pulumi.Input['VaultCertificateArgs']]] vault_certificates: The list of key vault references in SourceVault which contain certificates.
"""
if source_vault is not None:
pulumi.set(__self__, "source_vault", source_vault)
if vault_certificates is not None:
pulumi.set(__self__, "vault_certificates", vault_certificates)
@property
@pulumi.getter(name="sourceVault")
def source_vault(self) -> Optional[pulumi.Input['SubResourceArgs']]:
"""
The relative URL of the Key Vault containing all of the certificates in VaultCertificates.
"""
return pulumi.get(self, "source_vault")
@source_vault.setter
def source_vault(self, value: Optional[pulumi.Input['SubResourceArgs']]):
pulumi.set(self, "source_vault", value)
@property
@pulumi.getter(name="vaultCertificates")
def vault_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VaultCertificateArgs']]]]:
"""
The list of key vault references in SourceVault which contain certificates.
"""
return pulumi.get(self, "vault_certificates")
@vault_certificates.setter
def vault_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VaultCertificateArgs']]]]):
pulumi.set(self, "vault_certificates", value)
@pulumi.input_type
class VirtualHardDiskArgs:
def __init__(__self__, *,
uri: Optional[pulumi.Input[str]] = None):
"""
Describes the uri of a disk.
:param pulumi.Input[str] uri: Specifies the virtual hard disk's uri.
"""
if uri is not None:
pulumi.set(__self__, "uri", uri)
@property
@pulumi.getter
def uri(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the virtual hard disk's uri.
"""
return pulumi.get(self, "uri")
@uri.setter
def uri(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "uri", value)
@pulumi.input_type
class VirtualMachineExtensionInstanceViewArgs:
def __init__(__self__, *,
name: Optional[pulumi.Input[str]] = None,
statuses: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]]] = None,
substatuses: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]]] = None,
type: Optional[pulumi.Input[str]] = None,
type_handler_version: Optional[pulumi.Input[str]] = None):
"""
The instance view of a virtual machine extension.
:param pulumi.Input[str] name: The virtual machine extension name.
:param pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]] statuses: The resource status information.
:param pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]] substatuses: The resource status information.
:param pulumi.Input[str] type: Specifies the type of the extension; an example is "CustomScriptExtension".
:param pulumi.Input[str] type_handler_version: Specifies the version of the script handler.
"""
if name is not None:
pulumi.set(__self__, "name", name)
if statuses is not None:
pulumi.set(__self__, "statuses", statuses)
if substatuses is not None:
pulumi.set(__self__, "substatuses", substatuses)
if type is not None:
pulumi.set(__self__, "type", type)
if type_handler_version is not None:
pulumi.set(__self__, "type_handler_version", type_handler_version)
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
"""
The virtual machine extension name.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
@property
@pulumi.getter
def statuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]]]:
"""
The resource status information.
"""
return pulumi.get(self, "statuses")
@statuses.setter
def statuses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]]]):
pulumi.set(self, "statuses", value)
@property
@pulumi.getter
def substatuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]]]:
"""
The resource status information.
"""
return pulumi.get(self, "substatuses")
@substatuses.setter
def substatuses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]]]):
pulumi.set(self, "substatuses", value)
@property
@pulumi.getter
def type(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the type of the extension; an example is "CustomScriptExtension".
"""
return pulumi.get(self, "type")
@type.setter
def type(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "type", value)
@property
@pulumi.getter(name="typeHandlerVersion")
def type_handler_version(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the version of the script handler.
"""
return pulumi.get(self, "type_handler_version")
@type_handler_version.setter
def type_handler_version(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "type_handler_version", value)
@pulumi.input_type
class VirtualMachineIdentityArgs:
def __init__(__self__, *,
type: Optional[pulumi.Input['ResourceIdentityType']] = None,
user_assigned_identities: Optional[pulumi.Input[Mapping[str, Any]]] = None):
"""
Identity for the virtual machine.
:param pulumi.Input['ResourceIdentityType'] type: The type of identity used for the virtual machine. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the virtual machine.
:param pulumi.Input[Mapping[str, Any]] user_assigned_identities: The list of user identities associated with the Virtual Machine. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
"""
if type is not None:
pulumi.set(__self__, "type", type)
if user_assigned_identities is not None:
pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
@property
@pulumi.getter
def type(self) -> Optional[pulumi.Input['ResourceIdentityType']]:
"""
The type of identity used for the virtual machine. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the virtual machine.
"""
return pulumi.get(self, "type")
@type.setter
def type(self, value: Optional[pulumi.Input['ResourceIdentityType']]):
pulumi.set(self, "type", value)
@property
@pulumi.getter(name="userAssignedIdentities")
def user_assigned_identities(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
"""
The list of user identities associated with the Virtual Machine. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
"""
return pulumi.get(self, "user_assigned_identities")
@user_assigned_identities.setter
def user_assigned_identities(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
pulumi.set(self, "user_assigned_identities", value)
@pulumi.input_type
class VirtualMachineScaleSetDataDiskArgs:
def __init__(__self__, *,
create_option: pulumi.Input[Union[str, 'DiskCreateOptionTypes']],
lun: pulumi.Input[int],
caching: Optional[pulumi.Input['CachingTypes']] = None,
disk_iops_read_write: Optional[pulumi.Input[float]] = None,
disk_m_bps_read_write: Optional[pulumi.Input[float]] = None,
disk_size_gb: Optional[pulumi.Input[int]] = None,
managed_disk: Optional[pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs']] = None,
name: Optional[pulumi.Input[str]] = None,
write_accelerator_enabled: Optional[pulumi.Input[bool]] = None):
"""
Describes a virtual machine scale set data disk.
:param pulumi.Input[Union[str, 'DiskCreateOptionTypes']] create_option: The create option.
:param pulumi.Input[int] lun: Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
:param pulumi.Input['CachingTypes'] caching: Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
:param pulumi.Input[float] disk_iops_read_write: Specifies the Read-Write IOPS for the managed disk. Should be used only when StorageAccountType is UltraSSD_LRS. If not specified, a default value would be assigned based on diskSizeGB.
:param pulumi.Input[float] disk_m_bps_read_write: Specifies the bandwidth in MB per second for the managed disk. Should be used only when StorageAccountType is UltraSSD_LRS. If not specified, a default value would be assigned based on diskSizeGB.
:param pulumi.Input[int] disk_size_gb: Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
:param pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs'] managed_disk: The managed disk parameters.
:param pulumi.Input[str] name: The disk name.
:param pulumi.Input[bool] write_accelerator_enabled: Specifies whether writeAccelerator should be enabled or disabled on the disk.
"""
pulumi.set(__self__, "create_option", create_option)
pulumi.set(__self__, "lun", lun)
if caching is not None:
pulumi.set(__self__, "caching", caching)
if disk_iops_read_write is not None:
pulumi.set(__self__, "disk_iops_read_write", disk_iops_read_write)
if disk_m_bps_read_write is not None:
pulumi.set(__self__, "disk_m_bps_read_write", disk_m_bps_read_write)
if disk_size_gb is not None:
pulumi.set(__self__, "disk_size_gb", disk_size_gb)
if managed_disk is not None:
pulumi.set(__self__, "managed_disk", managed_disk)
if name is not None:
pulumi.set(__self__, "name", name)
if write_accelerator_enabled is not None:
pulumi.set(__self__, "write_accelerator_enabled", write_accelerator_enabled)
@property
@pulumi.getter(name="createOption")
def create_option(self) -> pulumi.Input[Union[str, 'DiskCreateOptionTypes']]:
"""
The create option.
"""
return pulumi.get(self, "create_option")
@create_option.setter
def create_option(self, value: pulumi.Input[Union[str, 'DiskCreateOptionTypes']]):
pulumi.set(self, "create_option", value)
@property
@pulumi.getter
def lun(self) -> pulumi.Input[int]:
"""
Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
"""
return pulumi.get(self, "lun")
@lun.setter
def lun(self, value: pulumi.Input[int]):
pulumi.set(self, "lun", value)
@property
@pulumi.getter
def caching(self) -> Optional[pulumi.Input['CachingTypes']]:
"""
Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
"""
return pulumi.get(self, "caching")
@caching.setter
def caching(self, value: Optional[pulumi.Input['CachingTypes']]):
pulumi.set(self, "caching", value)
@property
@pulumi.getter(name="diskIOPSReadWrite")
def disk_iops_read_write(self) -> Optional[pulumi.Input[float]]:
"""
Specifies the Read-Write IOPS for the managed disk. Should be used only when StorageAccountType is UltraSSD_LRS. If not specified, a default value would be assigned based on diskSizeGB.
"""
return pulumi.get(self, "disk_iops_read_write")
@disk_iops_read_write.setter
def disk_iops_read_write(self, value: Optional[pulumi.Input[float]]):
pulumi.set(self, "disk_iops_read_write", value)
@property
@pulumi.getter(name="diskMBpsReadWrite")
def disk_m_bps_read_write(self) -> Optional[pulumi.Input[float]]:
"""
Specifies the bandwidth in MB per second for the managed disk. Should be used only when StorageAccountType is UltraSSD_LRS. If not specified, a default value would be assigned based on diskSizeGB.
"""
return pulumi.get(self, "disk_m_bps_read_write")
@disk_m_bps_read_write.setter
def disk_m_bps_read_write(self, value: Optional[pulumi.Input[float]]):
pulumi.set(self, "disk_m_bps_read_write", value)
@property
@pulumi.getter(name="diskSizeGB")
def disk_size_gb(self) -> Optional[pulumi.Input[int]]:
"""
Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
"""
return pulumi.get(self, "disk_size_gb")
@disk_size_gb.setter
def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "disk_size_gb", value)
@property
@pulumi.getter(name="managedDisk")
def managed_disk(self) -> Optional[pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs']]:
"""
The managed disk parameters.
"""
return pulumi.get(self, "managed_disk")
@managed_disk.setter
def managed_disk(self, value: Optional[pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs']]):
pulumi.set(self, "managed_disk", value)
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
"""
The disk name.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
@property
@pulumi.getter(name="writeAcceleratorEnabled")
def write_accelerator_enabled(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether writeAccelerator should be enabled or disabled on the disk.
"""
return pulumi.get(self, "write_accelerator_enabled")
@write_accelerator_enabled.setter
def write_accelerator_enabled(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "write_accelerator_enabled", value)
@pulumi.input_type
class VirtualMachineScaleSetExtensionArgs:
def __init__(__self__, *,
auto_upgrade_minor_version: Optional[pulumi.Input[bool]] = None,
force_update_tag: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
protected_settings: Optional[Any] = None,
provision_after_extensions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
publisher: Optional[pulumi.Input[str]] = None,
settings: Optional[Any] = None,
type: Optional[pulumi.Input[str]] = None,
type_handler_version: Optional[pulumi.Input[str]] = None):
"""
Describes a Virtual Machine Scale Set Extension.
:param pulumi.Input[bool] auto_upgrade_minor_version: Indicates whether the extension should use a newer minor version if one is available at deployment time. Once deployed, however, the extension will not upgrade minor versions unless redeployed, even with this property set to true.
:param pulumi.Input[str] force_update_tag: If a value is provided and is different from the previous value, the extension handler will be forced to update even if the extension configuration has not changed.
:param pulumi.Input[str] name: The name of the extension.
:param Any protected_settings: The extension can contain either protectedSettings or protectedSettingsFromKeyVault or no protected settings at all.
:param pulumi.Input[Sequence[pulumi.Input[str]]] provision_after_extensions: Collection of extension names after which this extension needs to be provisioned.
:param pulumi.Input[str] publisher: The name of the extension handler publisher.
:param Any settings: Json formatted public settings for the extension.
:param pulumi.Input[str] type: Specifies the type of the extension; an example is "CustomScriptExtension".
:param pulumi.Input[str] type_handler_version: Specifies the version of the script handler.
"""
if auto_upgrade_minor_version is not None:
pulumi.set(__self__, "auto_upgrade_minor_version", auto_upgrade_minor_version)
if force_update_tag is not None:
pulumi.set(__self__, "force_update_tag", force_update_tag)
if name is not None:
pulumi.set(__self__, "name", name)
if protected_settings is not None:
pulumi.set(__self__, "protected_settings", protected_settings)
if provision_after_extensions is not None:
pulumi.set(__self__, "provision_after_extensions", provision_after_extensions)
if publisher is not None:
pulumi.set(__self__, "publisher", publisher)
if settings is not None:
pulumi.set(__self__, "settings", settings)
if type is not None:
pulumi.set(__self__, "type", type)
if type_handler_version is not None:
pulumi.set(__self__, "type_handler_version", type_handler_version)
@property
@pulumi.getter(name="autoUpgradeMinorVersion")
def auto_upgrade_minor_version(self) -> Optional[pulumi.Input[bool]]:
"""
Indicates whether the extension should use a newer minor version if one is available at deployment time. Once deployed, however, the extension will not upgrade minor versions unless redeployed, even with this property set to true.
"""
return pulumi.get(self, "auto_upgrade_minor_version")
@auto_upgrade_minor_version.setter
def auto_upgrade_minor_version(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "auto_upgrade_minor_version", value)
@property
@pulumi.getter(name="forceUpdateTag")
def force_update_tag(self) -> Optional[pulumi.Input[str]]:
"""
If a value is provided and is different from the previous value, the extension handler will be forced to update even if the extension configuration has not changed.
"""
return pulumi.get(self, "force_update_tag")
@force_update_tag.setter
def force_update_tag(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "force_update_tag", value)
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
"""
The name of the extension.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
@property
@pulumi.getter(name="protectedSettings")
def protected_settings(self) -> Optional[Any]:
"""
The extension can contain either protectedSettings or protectedSettingsFromKeyVault or no protected settings at all.
"""
return pulumi.get(self, "protected_settings")
@protected_settings.setter
def protected_settings(self, value: Optional[Any]):
pulumi.set(self, "protected_settings", value)
@property
@pulumi.getter(name="provisionAfterExtensions")
def provision_after_extensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
"""
Collection of extension names after which this extension needs to be provisioned.
"""
return pulumi.get(self, "provision_after_extensions")
@provision_after_extensions.setter
def provision_after_extensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
pulumi.set(self, "provision_after_extensions", value)
@property
@pulumi.getter
def publisher(self) -> Optional[pulumi.Input[str]]:
"""
The name of the extension handler publisher.
"""
return pulumi.get(self, "publisher")
@publisher.setter
def publisher(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "publisher", value)
@property
@pulumi.getter
def settings(self) -> Optional[Any]:
"""
Json formatted public settings for the extension.
"""
return pulumi.get(self, "settings")
@settings.setter
def settings(self, value: Optional[Any]):
pulumi.set(self, "settings", value)
@property
@pulumi.getter
def type(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the type of the extension; an example is "CustomScriptExtension".
"""
return pulumi.get(self, "type")
@type.setter
def type(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "type", value)
@property
@pulumi.getter(name="typeHandlerVersion")
def type_handler_version(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the version of the script handler.
"""
return pulumi.get(self, "type_handler_version")
@type_handler_version.setter
def type_handler_version(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "type_handler_version", value)
@pulumi.input_type
class VirtualMachineScaleSetExtensionProfileArgs:
def __init__(__self__, *,
extensions: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetExtensionArgs']]]] = None):
"""
Describes a virtual machine scale set extension profile.
:param pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetExtensionArgs']]] extensions: The virtual machine scale set child extension resources.
"""
if extensions is not None:
pulumi.set(__self__, "extensions", extensions)
@property
@pulumi.getter
def extensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetExtensionArgs']]]]:
"""
The virtual machine scale set child extension resources.
"""
return pulumi.get(self, "extensions")
@extensions.setter
def extensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetExtensionArgs']]]]):
pulumi.set(self, "extensions", value)
@pulumi.input_type
class VirtualMachineScaleSetIPConfigurationArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
application_gateway_backend_address_pools: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
application_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
id: Optional[pulumi.Input[str]] = None,
load_balancer_backend_address_pools: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
load_balancer_inbound_nat_pools: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
primary: Optional[pulumi.Input[bool]] = None,
private_ip_address_version: Optional[pulumi.Input[Union[str, 'IPVersion']]] = None,
public_ip_address_configuration: Optional[pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationArgs']] = None,
subnet: Optional[pulumi.Input['ApiEntityReferenceArgs']] = None):
"""
Describes a virtual machine scale set network profile's IP configuration.
:param pulumi.Input[str] name: The IP configuration name.
:param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] application_gateway_backend_address_pools: Specifies an array of references to backend address pools of application gateways. A scale set can reference backend address pools of multiple application gateways. Multiple scale sets cannot use the same application gateway.
:param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] application_security_groups: Specifies an array of references to application security group.
:param pulumi.Input[str] id: Resource Id
:param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] load_balancer_backend_address_pools: Specifies an array of references to backend address pools of load balancers. A scale set can reference backend address pools of one public and one internal load balancer. Multiple scale sets cannot use the same basic sku load balancer.
:param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] load_balancer_inbound_nat_pools: Specifies an array of references to inbound Nat pools of the load balancers. A scale set can reference inbound nat pools of one public and one internal load balancer. Multiple scale sets cannot use the same basic sku load balancer.
:param pulumi.Input[bool] primary: Specifies the primary network interface in case the virtual machine has more than 1 network interface.
:param pulumi.Input[Union[str, 'IPVersion']] private_ip_address_version: Available from Api-Version 2017-03-30 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible values are: 'IPv4' and 'IPv6'.
:param pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationArgs'] public_ip_address_configuration: The publicIPAddressConfiguration.
:param pulumi.Input['ApiEntityReferenceArgs'] subnet: Specifies the identifier of the subnet.
"""
pulumi.set(__self__, "name", name)
if application_gateway_backend_address_pools is not None:
pulumi.set(__self__, "application_gateway_backend_address_pools", application_gateway_backend_address_pools)
if application_security_groups is not None:
pulumi.set(__self__, "application_security_groups", application_security_groups)
if id is not None:
pulumi.set(__self__, "id", id)
if load_balancer_backend_address_pools is not None:
pulumi.set(__self__, "load_balancer_backend_address_pools", load_balancer_backend_address_pools)
if load_balancer_inbound_nat_pools is not None:
pulumi.set(__self__, "load_balancer_inbound_nat_pools", load_balancer_inbound_nat_pools)
if primary is not None:
pulumi.set(__self__, "primary", primary)
if private_ip_address_version is not None:
pulumi.set(__self__, "private_ip_address_version", private_ip_address_version)
if public_ip_address_configuration is not None:
pulumi.set(__self__, "public_ip_address_configuration", public_ip_address_configuration)
if subnet is not None:
pulumi.set(__self__, "subnet", subnet)
@property
@pulumi.getter
def name(self) -> pulumi.Input[str]:
"""
The IP configuration name.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: pulumi.Input[str]):
pulumi.set(self, "name", value)
@property
@pulumi.getter(name="applicationGatewayBackendAddressPools")
def application_gateway_backend_address_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
"""
Specifies an array of references to backend address pools of application gateways. A scale set can reference backend address pools of multiple application gateways. Multiple scale sets cannot use the same application gateway.
"""
return pulumi.get(self, "application_gateway_backend_address_pools")
@application_gateway_backend_address_pools.setter
def application_gateway_backend_address_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
pulumi.set(self, "application_gateway_backend_address_pools", value)
@property
@pulumi.getter(name="applicationSecurityGroups")
def application_security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
"""
Specifies an array of references to application security group.
"""
return pulumi.get(self, "application_security_groups")
@application_security_groups.setter
def application_security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
pulumi.set(self, "application_security_groups", value)
@property
@pulumi.getter
def id(self) -> Optional[pulumi.Input[str]]:
"""
Resource Id
"""
return pulumi.get(self, "id")
@id.setter
def id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "id", value)
@property
@pulumi.getter(name="loadBalancerBackendAddressPools")
def load_balancer_backend_address_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
"""
Specifies an array of references to backend address pools of load balancers. A scale set can reference backend address pools of one public and one internal load balancer. Multiple scale sets cannot use the same basic sku load balancer.
"""
return pulumi.get(self, "load_balancer_backend_address_pools")
@load_balancer_backend_address_pools.setter
def load_balancer_backend_address_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
pulumi.set(self, "load_balancer_backend_address_pools", value)
@property
@pulumi.getter(name="loadBalancerInboundNatPools")
def load_balancer_inbound_nat_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
"""
Specifies an array of references to inbound Nat pools of the load balancers. A scale set can reference inbound nat pools of one public and one internal load balancer. Multiple scale sets cannot use the same basic sku load balancer.
"""
return pulumi.get(self, "load_balancer_inbound_nat_pools")
@load_balancer_inbound_nat_pools.setter
def load_balancer_inbound_nat_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
pulumi.set(self, "load_balancer_inbound_nat_pools", value)
@property
@pulumi.getter
def primary(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies the primary network interface in case the virtual machine has more than 1 network interface.
"""
return pulumi.get(self, "primary")
@primary.setter
def primary(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "primary", value)
@property
@pulumi.getter(name="privateIPAddressVersion")
def private_ip_address_version(self) -> Optional[pulumi.Input[Union[str, 'IPVersion']]]:
"""
Available from Api-Version 2017-03-30 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible values are: 'IPv4' and 'IPv6'.
"""
return pulumi.get(self, "private_ip_address_version")
@private_ip_address_version.setter
def private_ip_address_version(self, value: Optional[pulumi.Input[Union[str, 'IPVersion']]]):
pulumi.set(self, "private_ip_address_version", value)
@property
@pulumi.getter(name="publicIPAddressConfiguration")
def public_ip_address_configuration(self) -> Optional[pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationArgs']]:
"""
The publicIPAddressConfiguration.
"""
return pulumi.get(self, "public_ip_address_configuration")
@public_ip_address_configuration.setter
def public_ip_address_configuration(self, value: Optional[pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationArgs']]):
pulumi.set(self, "public_ip_address_configuration", value)
@property
@pulumi.getter
def subnet(self) -> Optional[pulumi.Input['ApiEntityReferenceArgs']]:
"""
Specifies the identifier of the subnet.
"""
return pulumi.get(self, "subnet")
@subnet.setter
def subnet(self, value: Optional[pulumi.Input['ApiEntityReferenceArgs']]):
pulumi.set(self, "subnet", value)
@pulumi.input_type
class VirtualMachineScaleSetIdentityArgs:
def __init__(__self__, *,
type: Optional[pulumi.Input['ResourceIdentityType']] = None,
user_assigned_identities: Optional[pulumi.Input[Mapping[str, Any]]] = None):
"""
Identity for the virtual machine scale set.
:param pulumi.Input['ResourceIdentityType'] type: The type of identity used for the virtual machine scale set. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the virtual machine scale set.
:param pulumi.Input[Mapping[str, Any]] user_assigned_identities: The list of user identities associated with the virtual machine scale set. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
"""
if type is not None:
pulumi.set(__self__, "type", type)
if user_assigned_identities is not None:
pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
@property
@pulumi.getter
def type(self) -> Optional[pulumi.Input['ResourceIdentityType']]:
"""
The type of identity used for the virtual machine scale set. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the virtual machine scale set.
"""
return pulumi.get(self, "type")
@type.setter
def type(self, value: Optional[pulumi.Input['ResourceIdentityType']]):
pulumi.set(self, "type", value)
@property
@pulumi.getter(name="userAssignedIdentities")
def user_assigned_identities(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
"""
The list of user identities associated with the virtual machine scale set. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
"""
return pulumi.get(self, "user_assigned_identities")
@user_assigned_identities.setter
def user_assigned_identities(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
pulumi.set(self, "user_assigned_identities", value)
@pulumi.input_type
class VirtualMachineScaleSetIpTagArgs:
def __init__(__self__, *,
ip_tag_type: Optional[pulumi.Input[str]] = None,
tag: Optional[pulumi.Input[str]] = None):
"""
Contains the IP tag associated with the public IP address.
:param pulumi.Input[str] ip_tag_type: IP tag type. Example: FirstPartyUsage.
:param pulumi.Input[str] tag: IP tag associated with the public IP. Example: SQL, Storage etc.
"""
if ip_tag_type is not None:
pulumi.set(__self__, "ip_tag_type", ip_tag_type)
if tag is not None:
pulumi.set(__self__, "tag", tag)
@property
@pulumi.getter(name="ipTagType")
def ip_tag_type(self) -> Optional[pulumi.Input[str]]:
"""
IP tag type. Example: FirstPartyUsage.
"""
return pulumi.get(self, "ip_tag_type")
@ip_tag_type.setter
def ip_tag_type(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "ip_tag_type", value)
@property
@pulumi.getter
def tag(self) -> Optional[pulumi.Input[str]]:
"""
IP tag associated with the public IP. Example: SQL, Storage etc.
"""
return pulumi.get(self, "tag")
@tag.setter
def tag(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "tag", value)
@pulumi.input_type
class VirtualMachineScaleSetManagedDiskParametersArgs:
def __init__(__self__, *,
disk_encryption_set: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']] = None,
storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]] = None):
"""
Describes the parameters of a ScaleSet managed disk.
:param pulumi.Input['DiskEncryptionSetParametersArgs'] disk_encryption_set: Specifies the customer managed disk encryption set resource id for the managed disk.
:param pulumi.Input[Union[str, 'StorageAccountTypes']] storage_account_type: Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
"""
if disk_encryption_set is not None:
pulumi.set(__self__, "disk_encryption_set", disk_encryption_set)
if storage_account_type is not None:
pulumi.set(__self__, "storage_account_type", storage_account_type)
@property
@pulumi.getter(name="diskEncryptionSet")
def disk_encryption_set(self) -> Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]:
"""
Specifies the customer managed disk encryption set resource id for the managed disk.
"""
return pulumi.get(self, "disk_encryption_set")
@disk_encryption_set.setter
def disk_encryption_set(self, value: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]):
pulumi.set(self, "disk_encryption_set", value)
@property
@pulumi.getter(name="storageAccountType")
def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]:
"""
Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
"""
return pulumi.get(self, "storage_account_type")
@storage_account_type.setter
def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]):
pulumi.set(self, "storage_account_type", value)
@pulumi.input_type
class VirtualMachineScaleSetNetworkConfigurationArgs:
def __init__(__self__, *,
ip_configurations: pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIPConfigurationArgs']]],
name: pulumi.Input[str],
dns_settings: Optional[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationDnsSettingsArgs']] = None,
enable_accelerated_networking: Optional[pulumi.Input[bool]] = None,
enable_ip_forwarding: Optional[pulumi.Input[bool]] = None,
id: Optional[pulumi.Input[str]] = None,
network_security_group: Optional[pulumi.Input['SubResourceArgs']] = None,
primary: Optional[pulumi.Input[bool]] = None):
"""
Describes a virtual machine scale set network profile's network configurations.
:param pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIPConfigurationArgs']]] ip_configurations: Specifies the IP configurations of the network interface.
:param pulumi.Input[str] name: The network configuration name.
:param pulumi.Input['VirtualMachineScaleSetNetworkConfigurationDnsSettingsArgs'] dns_settings: The dns settings to be applied on the network interfaces.
:param pulumi.Input[bool] enable_accelerated_networking: Specifies whether the network interface is accelerated networking-enabled.
:param pulumi.Input[bool] enable_ip_forwarding: Whether IP forwarding enabled on this NIC.
:param pulumi.Input[str] id: Resource Id
:param pulumi.Input['SubResourceArgs'] network_security_group: The network security group.
:param pulumi.Input[bool] primary: Specifies the primary network interface in case the virtual machine has more than 1 network interface.
"""
pulumi.set(__self__, "ip_configurations", ip_configurations)
pulumi.set(__self__, "name", name)
if dns_settings is not None:
pulumi.set(__self__, "dns_settings", dns_settings)
if enable_accelerated_networking is not None:
pulumi.set(__self__, "enable_accelerated_networking", enable_accelerated_networking)
if enable_ip_forwarding is not None:
pulumi.set(__self__, "enable_ip_forwarding", enable_ip_forwarding)
if id is not None:
pulumi.set(__self__, "id", id)
if network_security_group is not None:
pulumi.set(__self__, "network_security_group", network_security_group)
if primary is not None:
pulumi.set(__self__, "primary", primary)
@property
@pulumi.getter(name="ipConfigurations")
def ip_configurations(self) -> pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIPConfigurationArgs']]]:
"""
Specifies the IP configurations of the network interface.
"""
return pulumi.get(self, "ip_configurations")
@ip_configurations.setter
def ip_configurations(self, value: pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIPConfigurationArgs']]]):
pulumi.set(self, "ip_configurations", value)
@property
@pulumi.getter
def name(self) -> pulumi.Input[str]:
"""
The network configuration name.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: pulumi.Input[str]):
pulumi.set(self, "name", value)
@property
@pulumi.getter(name="dnsSettings")
def dns_settings(self) -> Optional[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationDnsSettingsArgs']]:
"""
The dns settings to be applied on the network interfaces.
"""
return pulumi.get(self, "dns_settings")
@dns_settings.setter
def dns_settings(self, value: Optional[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationDnsSettingsArgs']]):
pulumi.set(self, "dns_settings", value)
@property
@pulumi.getter(name="enableAcceleratedNetworking")
def enable_accelerated_networking(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether the network interface is accelerated networking-enabled.
"""
return pulumi.get(self, "enable_accelerated_networking")
@enable_accelerated_networking.setter
def enable_accelerated_networking(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "enable_accelerated_networking", value)
@property
@pulumi.getter(name="enableIPForwarding")
def enable_ip_forwarding(self) -> Optional[pulumi.Input[bool]]:
"""
Whether IP forwarding enabled on this NIC.
"""
return pulumi.get(self, "enable_ip_forwarding")
@enable_ip_forwarding.setter
def enable_ip_forwarding(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "enable_ip_forwarding", value)
@property
@pulumi.getter
def id(self) -> Optional[pulumi.Input[str]]:
"""
Resource Id
"""
return pulumi.get(self, "id")
@id.setter
def id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "id", value)
@property
@pulumi.getter(name="networkSecurityGroup")
def network_security_group(self) -> Optional[pulumi.Input['SubResourceArgs']]:
"""
The network security group.
"""
return pulumi.get(self, "network_security_group")
@network_security_group.setter
def network_security_group(self, value: Optional[pulumi.Input['SubResourceArgs']]):
pulumi.set(self, "network_security_group", value)
@property
@pulumi.getter
def primary(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies the primary network interface in case the virtual machine has more than 1 network interface.
"""
return pulumi.get(self, "primary")
@primary.setter
def primary(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "primary", value)
@pulumi.input_type
class VirtualMachineScaleSetNetworkConfigurationDnsSettingsArgs:
def __init__(__self__, *,
dns_servers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
"""
Describes a virtual machines scale sets network configuration's DNS settings.
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns_servers: List of DNS servers IP addresses
"""
if dns_servers is not None:
pulumi.set(__self__, "dns_servers", dns_servers)
@property
@pulumi.getter(name="dnsServers")
def dns_servers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
"""
List of DNS servers IP addresses
"""
return pulumi.get(self, "dns_servers")
@dns_servers.setter
def dns_servers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
pulumi.set(self, "dns_servers", value)
@pulumi.input_type
class VirtualMachineScaleSetNetworkProfileArgs:
def __init__(__self__, *,
health_probe: Optional[pulumi.Input['ApiEntityReferenceArgs']] = None,
network_interface_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]]] = None):
"""
Describes a virtual machine scale set network profile.
:param pulumi.Input['ApiEntityReferenceArgs'] health_probe: A reference to a load balancer probe used to determine the health of an instance in the virtual machine scale set. The reference will be in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}'.
:param pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]] network_interface_configurations: The list of network configurations.
"""
if health_probe is not None:
pulumi.set(__self__, "health_probe", health_probe)
if network_interface_configurations is not None:
pulumi.set(__self__, "network_interface_configurations", network_interface_configurations)
@property
@pulumi.getter(name="healthProbe")
def health_probe(self) -> Optional[pulumi.Input['ApiEntityReferenceArgs']]:
"""
A reference to a load balancer probe used to determine the health of an instance in the virtual machine scale set. The reference will be in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}'.
"""
return pulumi.get(self, "health_probe")
@health_probe.setter
def health_probe(self, value: Optional[pulumi.Input['ApiEntityReferenceArgs']]):
pulumi.set(self, "health_probe", value)
@property
@pulumi.getter(name="networkInterfaceConfigurations")
def network_interface_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]]]:
"""
The list of network configurations.
"""
return pulumi.get(self, "network_interface_configurations")
@network_interface_configurations.setter
def network_interface_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]]]):
pulumi.set(self, "network_interface_configurations", value)
@pulumi.input_type
class VirtualMachineScaleSetOSDiskArgs:
def __init__(__self__, *,
create_option: pulumi.Input[Union[str, 'DiskCreateOptionTypes']],
caching: Optional[pulumi.Input['CachingTypes']] = None,
diff_disk_settings: Optional[pulumi.Input['DiffDiskSettingsArgs']] = None,
disk_size_gb: Optional[pulumi.Input[int]] = None,
image: Optional[pulumi.Input['VirtualHardDiskArgs']] = None,
managed_disk: Optional[pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs']] = None,
name: Optional[pulumi.Input[str]] = None,
os_type: Optional[pulumi.Input['OperatingSystemTypes']] = None,
vhd_containers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
write_accelerator_enabled: Optional[pulumi.Input[bool]] = None):
"""
Describes a virtual machine scale set operating system disk.
:param pulumi.Input[Union[str, 'DiskCreateOptionTypes']] create_option: Specifies how the virtual machines in the scale set should be created.<br><br> The only allowed value is: **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you also use the plan element previously described.
:param pulumi.Input['CachingTypes'] caching: Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
:param pulumi.Input['DiffDiskSettingsArgs'] diff_disk_settings: Specifies the ephemeral disk Settings for the operating system disk used by the virtual machine scale set.
:param pulumi.Input[int] disk_size_gb: Specifies the size of the operating system disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
:param pulumi.Input['VirtualHardDiskArgs'] image: Specifies information about the unmanaged user image to base the scale set on.
:param pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs'] managed_disk: The managed disk parameters.
:param pulumi.Input[str] name: The disk name.
:param pulumi.Input['OperatingSystemTypes'] os_type: This property allows you to specify the type of the OS that is included in the disk if creating a VM from user-image or a specialized VHD. <br><br> Possible values are: <br><br> **Windows** <br><br> **Linux**
:param pulumi.Input[Sequence[pulumi.Input[str]]] vhd_containers: Specifies the container urls that are used to store operating system disks for the scale set.
:param pulumi.Input[bool] write_accelerator_enabled: Specifies whether writeAccelerator should be enabled or disabled on the disk.
"""
pulumi.set(__self__, "create_option", create_option)
if caching is not None:
pulumi.set(__self__, "caching", caching)
if diff_disk_settings is not None:
pulumi.set(__self__, "diff_disk_settings", diff_disk_settings)
if disk_size_gb is not None:
pulumi.set(__self__, "disk_size_gb", disk_size_gb)
if image is not None:
pulumi.set(__self__, "image", image)
if managed_disk is not None:
pulumi.set(__self__, "managed_disk", managed_disk)
if name is not None:
pulumi.set(__self__, "name", name)
if os_type is not None:
pulumi.set(__self__, "os_type", os_type)
if vhd_containers is not None:
pulumi.set(__self__, "vhd_containers", vhd_containers)
if write_accelerator_enabled is not None:
pulumi.set(__self__, "write_accelerator_enabled", write_accelerator_enabled)
@property
@pulumi.getter(name="createOption")
def create_option(self) -> pulumi.Input[Union[str, 'DiskCreateOptionTypes']]:
"""
Specifies how the virtual machines in the scale set should be created.<br><br> The only allowed value is: **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you also use the plan element previously described.
"""
return pulumi.get(self, "create_option")
@create_option.setter
def create_option(self, value: pulumi.Input[Union[str, 'DiskCreateOptionTypes']]):
pulumi.set(self, "create_option", value)
@property
@pulumi.getter
def caching(self) -> Optional[pulumi.Input['CachingTypes']]:
"""
Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
"""
return pulumi.get(self, "caching")
@caching.setter
def caching(self, value: Optional[pulumi.Input['CachingTypes']]):
pulumi.set(self, "caching", value)
@property
@pulumi.getter(name="diffDiskSettings")
def diff_disk_settings(self) -> Optional[pulumi.Input['DiffDiskSettingsArgs']]:
"""
Specifies the ephemeral disk Settings for the operating system disk used by the virtual machine scale set.
"""
return pulumi.get(self, "diff_disk_settings")
@diff_disk_settings.setter
def diff_disk_settings(self, value: Optional[pulumi.Input['DiffDiskSettingsArgs']]):
pulumi.set(self, "diff_disk_settings", value)
@property
@pulumi.getter(name="diskSizeGB")
def disk_size_gb(self) -> Optional[pulumi.Input[int]]:
"""
Specifies the size of the operating system disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
"""
return pulumi.get(self, "disk_size_gb")
@disk_size_gb.setter
def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "disk_size_gb", value)
@property
@pulumi.getter
def image(self) -> Optional[pulumi.Input['VirtualHardDiskArgs']]:
"""
Specifies information about the unmanaged user image to base the scale set on.
"""
return pulumi.get(self, "image")
@image.setter
def image(self, value: Optional[pulumi.Input['VirtualHardDiskArgs']]):
pulumi.set(self, "image", value)
@property
@pulumi.getter(name="managedDisk")
def managed_disk(self) -> Optional[pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs']]:
"""
The managed disk parameters.
"""
return pulumi.get(self, "managed_disk")
@managed_disk.setter
def managed_disk(self, value: Optional[pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs']]):
pulumi.set(self, "managed_disk", value)
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
"""
The disk name.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
@property
@pulumi.getter(name="osType")
def os_type(self) -> Optional[pulumi.Input['OperatingSystemTypes']]:
"""
This property allows you to specify the type of the OS that is included in the disk if creating a VM from user-image or a specialized VHD. <br><br> Possible values are: <br><br> **Windows** <br><br> **Linux**
"""
return pulumi.get(self, "os_type")
@os_type.setter
def os_type(self, value: Optional[pulumi.Input['OperatingSystemTypes']]):
pulumi.set(self, "os_type", value)
@property
@pulumi.getter(name="vhdContainers")
def vhd_containers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
"""
Specifies the container urls that are used to store operating system disks for the scale set.
"""
return pulumi.get(self, "vhd_containers")
@vhd_containers.setter
def vhd_containers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
pulumi.set(self, "vhd_containers", value)
@property
@pulumi.getter(name="writeAcceleratorEnabled")
def write_accelerator_enabled(self) -> Optional[pulumi.Input[bool]]:
"""
Specifies whether writeAccelerator should be enabled or disabled on the disk.
"""
return pulumi.get(self, "write_accelerator_enabled")
@write_accelerator_enabled.setter
def write_accelerator_enabled(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "write_accelerator_enabled", value)
@pulumi.input_type
class VirtualMachineScaleSetOSProfileArgs:
def __init__(__self__, *,
admin_password: Optional[pulumi.Input[str]] = None,
admin_username: Optional[pulumi.Input[str]] = None,
computer_name_prefix: Optional[pulumi.Input[str]] = None,
custom_data: Optional[pulumi.Input[str]] = None,
linux_configuration: Optional[pulumi.Input['LinuxConfigurationArgs']] = None,
secrets: Optional[pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]]] = None,
windows_configuration: Optional[pulumi.Input['WindowsConfigurationArgs']] = None):
"""
Describes a virtual machine scale set OS profile.
:param pulumi.Input[str] admin_password: Specifies the password of the administrator account. <br><br> **Minimum-length (Windows):** 8 characters <br><br> **Minimum-length (Linux):** 6 characters <br><br> **Max-length (Windows):** 123 characters <br><br> **Max-length (Linux):** 72 characters <br><br> **Complexity requirements:** 3 out of 4 conditions below need to be fulfilled <br> Has lower characters <br>Has upper characters <br> Has a digit <br> Has a special character (Regex match [\W_]) <br><br> **Disallowed values:** "abc@123", "P@$$w0rd", "P@ssw0rd", "P@ssword123", "Pa$$word", "pass@word1", "Password!", "Password1", "Password22", "iloveyou!" <br><br> For resetting the password, see [How to reset the Remote Desktop service or its login password in a Windows VM](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-reset-rdp?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json) <br><br> For resetting root password, see [Manage users, SSH, and check or repair disks on Azure Linux VMs using the VMAccess Extension](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-vmaccess-extension?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#reset-root-password)
:param pulumi.Input[str] admin_username: Specifies the name of the administrator account. <br><br> **Windows-only restriction:** Cannot end in "." <br><br> **Disallowed values:** "administrator", "admin", "user", "user1", "test", "user2", "test1", "user3", "admin1", "1", "123", "a", "actuser", "adm", "admin2", "aspnet", "backup", "console", "david", "guest", "john", "owner", "root", "server", "sql", "support", "support_388945a0", "sys", "test2", "test3", "user4", "user5". <br><br> **Minimum-length (Linux):** 1 character <br><br> **Max-length (Linux):** 64 characters <br><br> **Max-length (Windows):** 20 characters <br><br><li> For root access to the Linux VM, see [Using root privileges on Linux virtual machines in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-use-root-privileges?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)<br><li> For a list of built-in system users on Linux that should not be used in this field, see [Selecting User Names for Linux on Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-usernames?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
:param pulumi.Input[str] computer_name_prefix: Specifies the computer name prefix for all of the virtual machines in the scale set. Computer name prefixes must be 1 to 15 characters long.
:param pulumi.Input[str] custom_data: Specifies a base-64 encoded string of custom data. The base-64 encoded string is decoded to a binary array that is saved as a file on the Virtual Machine. The maximum length of the binary array is 65535 bytes. <br><br> For using cloud-init for your VM, see [Using cloud-init to customize a Linux VM during creation](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-cloud-init?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
:param pulumi.Input['LinuxConfigurationArgs'] linux_configuration: Specifies the Linux operating system settings on the virtual machine. <br><br>For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json) <br><br> For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
:param pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]] secrets: Specifies set of certificates that should be installed onto the virtual machines in the scale set.
:param pulumi.Input['WindowsConfigurationArgs'] windows_configuration: Specifies Windows operating system settings on the virtual machine.
"""
if admin_password is not None:
pulumi.set(__self__, "admin_password", admin_password)
if admin_username is not None:
pulumi.set(__self__, "admin_username", admin_username)
if computer_name_prefix is not None:
pulumi.set(__self__, "computer_name_prefix", computer_name_prefix)
if custom_data is not None:
pulumi.set(__self__, "custom_data", custom_data)
if linux_configuration is not None:
pulumi.set(__self__, "linux_configuration", linux_configuration)
if secrets is not None:
pulumi.set(__self__, "secrets", secrets)
if windows_configuration is not None:
pulumi.set(__self__, "windows_configuration", windows_configuration)
@property
@pulumi.getter(name="adminPassword")
def admin_password(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the password of the administrator account. <br><br> **Minimum-length (Windows):** 8 characters <br><br> **Minimum-length (Linux):** 6 characters <br><br> **Max-length (Windows):** 123 characters <br><br> **Max-length (Linux):** 72 characters <br><br> **Complexity requirements:** 3 out of 4 conditions below need to be fulfilled <br> Has lower characters <br>Has upper characters <br> Has a digit <br> Has a special character (Regex match [\W_]) <br><br> **Disallowed values:** "abc@123", "P@$$w0rd", "P@ssw0rd", "P@ssword123", "Pa$$word", "pass@word1", "Password!", "Password1", "Password22", "iloveyou!" <br><br> For resetting the password, see [How to reset the Remote Desktop service or its login password in a Windows VM](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-reset-rdp?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json) <br><br> For resetting root password, see [Manage users, SSH, and check or repair disks on Azure Linux VMs using the VMAccess Extension](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-vmaccess-extension?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#reset-root-password)
"""
return pulumi.get(self, "admin_password")
@admin_password.setter
def admin_password(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "admin_password", value)
@property
@pulumi.getter(name="adminUsername")
def admin_username(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the name of the administrator account. <br><br> **Windows-only restriction:** Cannot end in "." <br><br> **Disallowed values:** "administrator", "admin", "user", "user1", "test", "user2", "test1", "user3", "admin1", "1", "123", "a", "actuser", "adm", "admin2", "aspnet", "backup", "console", "david", "guest", "john", "owner", "root", "server", "sql", "support", "support_388945a0", "sys", "test2", "test3", "user4", "user5". <br><br> **Minimum-length (Linux):** 1 character <br><br> **Max-length (Linux):** 64 characters <br><br> **Max-length (Windows):** 20 characters <br><br><li> For root access to the Linux VM, see [Using root privileges on Linux virtual machines in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-use-root-privileges?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)<br><li> For a list of built-in system users on Linux that should not be used in this field, see [Selecting User Names for Linux on Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-usernames?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
"""
return pulumi.get(self, "admin_username")
@admin_username.setter
def admin_username(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "admin_username", value)
@property
@pulumi.getter(name="computerNamePrefix")
def computer_name_prefix(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the computer name prefix for all of the virtual machines in the scale set. Computer name prefixes must be 1 to 15 characters long.
"""
return pulumi.get(self, "computer_name_prefix")
@computer_name_prefix.setter
def computer_name_prefix(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "computer_name_prefix", value)
@property
@pulumi.getter(name="customData")
def custom_data(self) -> Optional[pulumi.Input[str]]:
"""
Specifies a base-64 encoded string of custom data. The base-64 encoded string is decoded to a binary array that is saved as a file on the Virtual Machine. The maximum length of the binary array is 65535 bytes. <br><br> For using cloud-init for your VM, see [Using cloud-init to customize a Linux VM during creation](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-cloud-init?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
"""
return pulumi.get(self, "custom_data")
@custom_data.setter
def custom_data(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "custom_data", value)
@property
@pulumi.getter(name="linuxConfiguration")
def linux_configuration(self) -> Optional[pulumi.Input['LinuxConfigurationArgs']]:
"""
Specifies the Linux operating system settings on the virtual machine. <br><br>For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json) <br><br> For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
"""
return pulumi.get(self, "linux_configuration")
@linux_configuration.setter
def linux_configuration(self, value: Optional[pulumi.Input['LinuxConfigurationArgs']]):
pulumi.set(self, "linux_configuration", value)
@property
@pulumi.getter
def secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]]]:
"""
Specifies set of certificates that should be installed onto the virtual machines in the scale set.
"""
return pulumi.get(self, "secrets")
@secrets.setter
def secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]]]):
pulumi.set(self, "secrets", value)
@property
@pulumi.getter(name="windowsConfiguration")
def windows_configuration(self) -> Optional[pulumi.Input['WindowsConfigurationArgs']]:
"""
Specifies Windows operating system settings on the virtual machine.
"""
return pulumi.get(self, "windows_configuration")
@windows_configuration.setter
def windows_configuration(self, value: Optional[pulumi.Input['WindowsConfigurationArgs']]):
pulumi.set(self, "windows_configuration", value)
@pulumi.input_type
class VirtualMachineScaleSetPublicIPAddressConfigurationArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
dns_settings: Optional[pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsArgs']] = None,
idle_timeout_in_minutes: Optional[pulumi.Input[int]] = None,
ip_tags: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIpTagArgs']]]] = None,
public_ip_address_version: Optional[pulumi.Input[Union[str, 'IPVersion']]] = None,
public_ip_prefix: Optional[pulumi.Input['SubResourceArgs']] = None):
"""
Describes a virtual machines scale set IP Configuration's PublicIPAddress configuration
:param pulumi.Input[str] name: The publicIP address configuration name.
:param pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsArgs'] dns_settings: The dns settings to be applied on the publicIP addresses .
:param pulumi.Input[int] idle_timeout_in_minutes: The idle timeout of the public IP address.
:param pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIpTagArgs']]] ip_tags: The list of IP tags associated with the public IP address.
:param pulumi.Input[Union[str, 'IPVersion']] public_ip_address_version: Available from Api-Version 2019-07-01 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible values are: 'IPv4' and 'IPv6'.
:param pulumi.Input['SubResourceArgs'] public_ip_prefix: The PublicIPPrefix from which to allocate publicIP addresses.
"""
pulumi.set(__self__, "name", name)
if dns_settings is not None:
pulumi.set(__self__, "dns_settings", dns_settings)
if idle_timeout_in_minutes is not None:
pulumi.set(__self__, "idle_timeout_in_minutes", idle_timeout_in_minutes)
if ip_tags is not None:
pulumi.set(__self__, "ip_tags", ip_tags)
if public_ip_address_version is not None:
pulumi.set(__self__, "public_ip_address_version", public_ip_address_version)
if public_ip_prefix is not None:
pulumi.set(__self__, "public_ip_prefix", public_ip_prefix)
@property
@pulumi.getter
def name(self) -> pulumi.Input[str]:
"""
The publicIP address configuration name.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: pulumi.Input[str]):
pulumi.set(self, "name", value)
@property
@pulumi.getter(name="dnsSettings")
def dns_settings(self) -> Optional[pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsArgs']]:
"""
The dns settings to be applied on the publicIP addresses .
"""
return pulumi.get(self, "dns_settings")
@dns_settings.setter
def dns_settings(self, value: Optional[pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsArgs']]):
pulumi.set(self, "dns_settings", value)
@property
@pulumi.getter(name="idleTimeoutInMinutes")
def idle_timeout_in_minutes(self) -> Optional[pulumi.Input[int]]:
"""
The idle timeout of the public IP address.
"""
return pulumi.get(self, "idle_timeout_in_minutes")
@idle_timeout_in_minutes.setter
def idle_timeout_in_minutes(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "idle_timeout_in_minutes", value)
@property
@pulumi.getter(name="ipTags")
def ip_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIpTagArgs']]]]:
"""
The list of IP tags associated with the public IP address.
"""
return pulumi.get(self, "ip_tags")
@ip_tags.setter
def ip_tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIpTagArgs']]]]):
pulumi.set(self, "ip_tags", value)
@property
@pulumi.getter(name="publicIPAddressVersion")
def public_ip_address_version(self) -> Optional[pulumi.Input[Union[str, 'IPVersion']]]:
"""
Available from Api-Version 2019-07-01 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible values are: 'IPv4' and 'IPv6'.
"""
return pulumi.get(self, "public_ip_address_version")
@public_ip_address_version.setter
def public_ip_address_version(self, value: Optional[pulumi.Input[Union[str, 'IPVersion']]]):
pulumi.set(self, "public_ip_address_version", value)
@property
@pulumi.getter(name="publicIPPrefix")
def public_ip_prefix(self) -> Optional[pulumi.Input['SubResourceArgs']]:
"""
The PublicIPPrefix from which to allocate publicIP addresses.
"""
return pulumi.get(self, "public_ip_prefix")
@public_ip_prefix.setter
def public_ip_prefix(self, value: Optional[pulumi.Input['SubResourceArgs']]):
pulumi.set(self, "public_ip_prefix", value)
@pulumi.input_type
class VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsArgs:
def __init__(__self__, *,
domain_name_label: pulumi.Input[str]):
"""
Describes a virtual machines scale sets network configuration's DNS settings.
:param pulumi.Input[str] domain_name_label: The Domain name label.The concatenation of the domain name label and vm index will be the domain name labels of the PublicIPAddress resources that will be created
"""
pulumi.set(__self__, "domain_name_label", domain_name_label)
@property
@pulumi.getter(name="domainNameLabel")
def domain_name_label(self) -> pulumi.Input[str]:
"""
The Domain name label.The concatenation of the domain name label and vm index will be the domain name labels of the PublicIPAddress resources that will be created
"""
return pulumi.get(self, "domain_name_label")
@domain_name_label.setter
def domain_name_label(self, value: pulumi.Input[str]):
pulumi.set(self, "domain_name_label", value)
@pulumi.input_type
class VirtualMachineScaleSetStorageProfileArgs:
def __init__(__self__, *,
data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetDataDiskArgs']]]] = None,
image_reference: Optional[pulumi.Input['ImageReferenceArgs']] = None,
os_disk: Optional[pulumi.Input['VirtualMachineScaleSetOSDiskArgs']] = None):
"""
Describes a virtual machine scale set storage profile.
:param pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetDataDiskArgs']]] data_disks: Specifies the parameters that are used to add data disks to the virtual machines in the scale set. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
:param pulumi.Input['ImageReferenceArgs'] image_reference: Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations.
:param pulumi.Input['VirtualMachineScaleSetOSDiskArgs'] os_disk: Specifies information about the operating system disk used by the virtual machines in the scale set. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
"""
if data_disks is not None:
pulumi.set(__self__, "data_disks", data_disks)
if image_reference is not None:
pulumi.set(__self__, "image_reference", image_reference)
if os_disk is not None:
pulumi.set(__self__, "os_disk", os_disk)
@property
@pulumi.getter(name="dataDisks")
def data_disks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetDataDiskArgs']]]]:
"""
Specifies the parameters that are used to add data disks to the virtual machines in the scale set. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
"""
return pulumi.get(self, "data_disks")
@data_disks.setter
def data_disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetDataDiskArgs']]]]):
pulumi.set(self, "data_disks", value)
@property
@pulumi.getter(name="imageReference")
def image_reference(self) -> Optional[pulumi.Input['ImageReferenceArgs']]:
"""
Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations.
"""
return pulumi.get(self, "image_reference")
@image_reference.setter
def image_reference(self, value: Optional[pulumi.Input['ImageReferenceArgs']]):
pulumi.set(self, "image_reference", value)
@property
@pulumi.getter(name="osDisk")
def os_disk(self) -> Optional[pulumi.Input['VirtualMachineScaleSetOSDiskArgs']]:
"""
Specifies information about the operating system disk used by the virtual machines in the scale set. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
"""
return pulumi.get(self, "os_disk")
@os_disk.setter
def os_disk(self, value: Optional[pulumi.Input['VirtualMachineScaleSetOSDiskArgs']]):
pulumi.set(self, "os_disk", value)
@pulumi.input_type
class VirtualMachineScaleSetVMNetworkProfileConfigurationArgs:
def __init__(__self__, *,
network_interface_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]]] = None):
"""
Describes a virtual machine scale set VM network profile.
:param pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]] network_interface_configurations: The list of network configurations.
"""
if network_interface_configurations is not None:
pulumi.set(__self__, "network_interface_configurations", network_interface_configurations)
@property
@pulumi.getter(name="networkInterfaceConfigurations")
def network_interface_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]]]:
"""
The list of network configurations.
"""
return pulumi.get(self, "network_interface_configurations")
@network_interface_configurations.setter
def network_interface_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]]]):
pulumi.set(self, "network_interface_configurations", value)
@pulumi.input_type
class VirtualMachineScaleSetVMProfileArgs:
def __init__(__self__, *,
billing_profile: Optional[pulumi.Input['BillingProfileArgs']] = None,
diagnostics_profile: Optional[pulumi.Input['DiagnosticsProfileArgs']] = None,
eviction_policy: Optional[pulumi.Input[Union[str, 'VirtualMachineEvictionPolicyTypes']]] = None,
extension_profile: Optional[pulumi.Input['VirtualMachineScaleSetExtensionProfileArgs']] = None,
license_type: Optional[pulumi.Input[str]] = None,
network_profile: Optional[pulumi.Input['VirtualMachineScaleSetNetworkProfileArgs']] = None,
os_profile: Optional[pulumi.Input['VirtualMachineScaleSetOSProfileArgs']] = None,
priority: Optional[pulumi.Input[Union[str, 'VirtualMachinePriorityTypes']]] = None,
scheduled_events_profile: Optional[pulumi.Input['ScheduledEventsProfileArgs']] = None,
storage_profile: Optional[pulumi.Input['VirtualMachineScaleSetStorageProfileArgs']] = None):
"""
Describes a virtual machine scale set virtual machine profile.
:param pulumi.Input['BillingProfileArgs'] billing_profile: Specifies the billing related details of a Azure Spot VMSS. <br><br>Minimum api-version: 2019-03-01.
:param pulumi.Input['DiagnosticsProfileArgs'] diagnostics_profile: Specifies the boot diagnostic settings state. <br><br>Minimum api-version: 2015-06-15.
:param pulumi.Input[Union[str, 'VirtualMachineEvictionPolicyTypes']] eviction_policy: Specifies the eviction policy for the Azure Spot virtual machine and Azure Spot scale set. <br><br>For Azure Spot virtual machines, both 'Deallocate' and 'Delete' are supported and the minimum api-version is 2019-03-01. <br><br>For Azure Spot scale sets, both 'Deallocate' and 'Delete' are supported and the minimum api-version is 2017-10-30-preview.
:param pulumi.Input['VirtualMachineScaleSetExtensionProfileArgs'] extension_profile: Specifies a collection of settings for extensions installed on virtual machines in the scale set.
:param pulumi.Input[str] license_type: Specifies that the image or disk that is being used was licensed on-premises. This element is only used for images that contain the Windows Server operating system. <br><br> Possible values are: <br><br> Windows_Client <br><br> Windows_Server <br><br> If this element is included in a request for an update, the value must match the initial value. This value cannot be updated. <br><br> For more information, see [Azure Hybrid Use Benefit for Windows Server](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-hybrid-use-benefit-licensing?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json) <br><br> Minimum api-version: 2015-06-15
:param pulumi.Input['VirtualMachineScaleSetNetworkProfileArgs'] network_profile: Specifies properties of the network interfaces of the virtual machines in the scale set.
:param pulumi.Input['VirtualMachineScaleSetOSProfileArgs'] os_profile: Specifies the operating system settings for the virtual machines in the scale set.
:param pulumi.Input[Union[str, 'VirtualMachinePriorityTypes']] priority: Specifies the priority for the virtual machines in the scale set. <br><br>Minimum api-version: 2017-10-30-preview
:param pulumi.Input['ScheduledEventsProfileArgs'] scheduled_events_profile: Specifies Scheduled Event related configurations.
:param pulumi.Input['VirtualMachineScaleSetStorageProfileArgs'] storage_profile: Specifies the storage settings for the virtual machine disks.
"""
if billing_profile is not None:
pulumi.set(__self__, "billing_profile", billing_profile)
if diagnostics_profile is not None:
pulumi.set(__self__, "diagnostics_profile", diagnostics_profile)
if eviction_policy is not None:
pulumi.set(__self__, "eviction_policy", eviction_policy)
if extension_profile is not None:
pulumi.set(__self__, "extension_profile", extension_profile)
if license_type is not None:
pulumi.set(__self__, "license_type", license_type)
if network_profile is not None:
pulumi.set(__self__, "network_profile", network_profile)
if os_profile is not None:
pulumi.set(__self__, "os_profile", os_profile)
if priority is not None:
pulumi.set(__self__, "priority", priority)
if scheduled_events_profile is not None:
pulumi.set(__self__, "scheduled_events_profile", scheduled_events_profile)
if storage_profile is not None:
pulumi.set(__self__, "storage_profile", storage_profile)
@property
@pulumi.getter(name="billingProfile")
def billing_profile(self) -> Optional[pulumi.Input['BillingProfileArgs']]:
"""
Specifies the billing related details of a Azure Spot VMSS. <br><br>Minimum api-version: 2019-03-01.
"""
return pulumi.get(self, "billing_profile")
@billing_profile.setter
def billing_profile(self, value: Optional[pulumi.Input['BillingProfileArgs']]):
pulumi.set(self, "billing_profile", value)
@property
@pulumi.getter(name="diagnosticsProfile")
def diagnostics_profile(self) -> Optional[pulumi.Input['DiagnosticsProfileArgs']]:
"""
Specifies the boot diagnostic settings state. <br><br>Minimum api-version: 2015-06-15.
"""
return pulumi.get(self, "diagnostics_profile")
@diagnostics_profile.setter
def diagnostics_profile(self, value: Optional[pulumi.Input['DiagnosticsProfileArgs']]):
pulumi.set(self, "diagnostics_profile", value)
@property
@pulumi.getter(name="evictionPolicy")
def eviction_policy(self) -> Optional[pulumi.Input[Union[str, 'VirtualMachineEvictionPolicyTypes']]]:
"""
Specifies the eviction policy for the Azure Spot virtual machine and Azure Spot scale set. <br><br>For Azure Spot virtual machines, both 'Deallocate' and 'Delete' are supported and the minimum api-version is 2019-03-01. <br><br>For Azure Spot scale sets, both 'Deallocate' and 'Delete' are supported and the minimum api-version is 2017-10-30-preview.
"""
return pulumi.get(self, "eviction_policy")
@eviction_policy.setter
def eviction_policy(self, value: Optional[pulumi.Input[Union[str, 'VirtualMachineEvictionPolicyTypes']]]):
pulumi.set(self, "eviction_policy", value)
@property
@pulumi.getter(name="extensionProfile")
def extension_profile(self) -> Optional[pulumi.Input['VirtualMachineScaleSetExtensionProfileArgs']]:
"""
Specifies a collection of settings for extensions installed on virtual machines in the scale set.
"""
return pulumi.get(self, "extension_profile")
@extension_profile.setter
def extension_profile(self, value: Optional[pulumi.Input['VirtualMachineScaleSetExtensionProfileArgs']]):
pulumi.set(self, "extension_profile", value)
@property
@pulumi.getter(name="licenseType")
def license_type(self) -> Optional[pulumi.Input[str]]:
"""
Specifies that the image or disk that is being used was licensed on-premises. This element is only used for images that contain the Windows Server operating system. <br><br> Possible values are: <br><br> Windows_Client <br><br> Windows_Server <br><br> If this element is included in a request for an update, the value must match the initial value. This value cannot be updated. <br><br> For more information, see [Azure Hybrid Use Benefit for Windows Server](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-hybrid-use-benefit-licensing?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json) <br><br> Minimum api-version: 2015-06-15
"""
return pulumi.get(self, "license_type")
@license_type.setter
def license_type(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "license_type", value)
@property
@pulumi.getter(name="networkProfile")
def network_profile(self) -> Optional[pulumi.Input['VirtualMachineScaleSetNetworkProfileArgs']]:
"""
Specifies properties of the network interfaces of the virtual machines in the scale set.
"""
return pulumi.get(self, "network_profile")
@network_profile.setter
def network_profile(self, value: Optional[pulumi.Input['VirtualMachineScaleSetNetworkProfileArgs']]):
pulumi.set(self, "network_profile", value)
@property
@pulumi.getter(name="osProfile")
def os_profile(self) -> Optional[pulumi.Input['VirtualMachineScaleSetOSProfileArgs']]:
"""
Specifies the operating system settings for the virtual machines in the scale set.
"""
return pulumi.get(self, "os_profile")
@os_profile.setter
def os_profile(self, value: Optional[pulumi.Input['VirtualMachineScaleSetOSProfileArgs']]):
pulumi.set(self, "os_profile", value)
@property
@pulumi.getter
def priority(self) -> Optional[pulumi.Input[Union[str, 'VirtualMachinePriorityTypes']]]:
"""
Specifies the priority for the virtual machines in the scale set. <br><br>Minimum api-version: 2017-10-30-preview
"""
return pulumi.get(self, "priority")
@priority.setter
def priority(self, value: Optional[pulumi.Input[Union[str, 'VirtualMachinePriorityTypes']]]):
pulumi.set(self, "priority", value)
@property
@pulumi.getter(name="scheduledEventsProfile")
def scheduled_events_profile(self) -> Optional[pulumi.Input['ScheduledEventsProfileArgs']]:
"""
Specifies Scheduled Event related configurations.
"""
return pulumi.get(self, "scheduled_events_profile")
@scheduled_events_profile.setter
def scheduled_events_profile(self, value: Optional[pulumi.Input['ScheduledEventsProfileArgs']]):
pulumi.set(self, "scheduled_events_profile", value)
@property
@pulumi.getter(name="storageProfile")
def storage_profile(self) -> Optional[pulumi.Input['VirtualMachineScaleSetStorageProfileArgs']]:
"""
Specifies the storage settings for the virtual machine disks.
"""
return pulumi.get(self, "storage_profile")
@storage_profile.setter
def storage_profile(self, value: Optional[pulumi.Input['VirtualMachineScaleSetStorageProfileArgs']]):
pulumi.set(self, "storage_profile", value)
@pulumi.input_type
class VirtualMachineScaleSetVMProtectionPolicyArgs:
def __init__(__self__, *,
protect_from_scale_in: Optional[pulumi.Input[bool]] = None,
protect_from_scale_set_actions: Optional[pulumi.Input[bool]] = None):
"""
The protection policy of a virtual machine scale set VM.
:param pulumi.Input[bool] protect_from_scale_in: Indicates that the virtual machine scale set VM shouldn't be considered for deletion during a scale-in operation.
:param pulumi.Input[bool] protect_from_scale_set_actions: Indicates that model updates or actions (including scale-in) initiated on the virtual machine scale set should not be applied to the virtual machine scale set VM.
"""
if protect_from_scale_in is not None:
pulumi.set(__self__, "protect_from_scale_in", protect_from_scale_in)
if protect_from_scale_set_actions is not None:
pulumi.set(__self__, "protect_from_scale_set_actions", protect_from_scale_set_actions)
@property
@pulumi.getter(name="protectFromScaleIn")
def protect_from_scale_in(self) -> Optional[pulumi.Input[bool]]:
"""
Indicates that the virtual machine scale set VM shouldn't be considered for deletion during a scale-in operation.
"""
return pulumi.get(self, "protect_from_scale_in")
@protect_from_scale_in.setter
def protect_from_scale_in(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "protect_from_scale_in", value)
@property
@pulumi.getter(name="protectFromScaleSetActions")
def protect_from_scale_set_actions(self) -> Optional[pulumi.Input[bool]]:
"""
Indicates that model updates or actions (including scale-in) initiated on the virtual machine scale set should not be applied to the virtual machine scale set VM.
"""
return pulumi.get(self, "protect_from_scale_set_actions")
@protect_from_scale_set_actions.setter
def protect_from_scale_set_actions(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "protect_from_scale_set_actions", value)
@pulumi.input_type
class WinRMConfigurationArgs:
def __init__(__self__, *,
listeners: Optional[pulumi.Input[Sequence[pulumi.Input['WinRMListenerArgs']]]] = None):
"""
Describes Windows Remote Management configuration of the VM
:param pulumi.Input[Sequence[pulumi.Input['WinRMListenerArgs']]] listeners: The list of Windows Remote Management listeners
"""
if listeners is not None:
pulumi.set(__self__, "listeners", listeners)
@property
@pulumi.getter
def listeners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WinRMListenerArgs']]]]:
"""
The list of Windows Remote Management listeners
"""
return pulumi.get(self, "listeners")
@listeners.setter
def listeners(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WinRMListenerArgs']]]]):
pulumi.set(self, "listeners", value)
@pulumi.input_type
class WinRMListenerArgs:
def __init__(__self__, *,
certificate_url: Optional[pulumi.Input[str]] = None,
protocol: Optional[pulumi.Input['ProtocolTypes']] = None):
"""
Describes Protocol and thumbprint of Windows Remote Management listener
:param pulumi.Input[str] certificate_url: This is the URL of a certificate that has been uploaded to Key Vault as a secret. For adding a secret to the Key Vault, see [Add a key or secret to the key vault](https://docs.microsoft.com/azure/key-vault/key-vault-get-started/#add). In this case, your certificate needs to be It is the Base64 encoding of the following JSON Object which is encoded in UTF-8: <br><br> {<br> "data":"<Base64-encoded-certificate>",<br> "dataType":"pfx",<br> "password":"<pfx-file-password>"<br>}
:param pulumi.Input['ProtocolTypes'] protocol: Specifies the protocol of WinRM listener. <br><br> Possible values are: <br>**http** <br><br> **https**
"""
if certificate_url is not None:
pulumi.set(__self__, "certificate_url", certificate_url)
if protocol is not None:
pulumi.set(__self__, "protocol", protocol)
@property
@pulumi.getter(name="certificateUrl")
def certificate_url(self) -> Optional[pulumi.Input[str]]:
"""
This is the URL of a certificate that has been uploaded to Key Vault as a secret. For adding a secret to the Key Vault, see [Add a key or secret to the key vault](https://docs.microsoft.com/azure/key-vault/key-vault-get-started/#add). In this case, your certificate needs to be It is the Base64 encoding of the following JSON Object which is encoded in UTF-8: <br><br> {<br> "data":"<Base64-encoded-certificate>",<br> "dataType":"pfx",<br> "password":"<pfx-file-password>"<br>}
"""
return pulumi.get(self, "certificate_url")
@certificate_url.setter
def certificate_url(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "certificate_url", value)
@property
@pulumi.getter
def protocol(self) -> Optional[pulumi.Input['ProtocolTypes']]:
"""
Specifies the protocol of WinRM listener. <br><br> Possible values are: <br>**http** <br><br> **https**
"""
return pulumi.get(self, "protocol")
@protocol.setter
def protocol(self, value: Optional[pulumi.Input['ProtocolTypes']]):
pulumi.set(self, "protocol", value)
@pulumi.input_type
class WindowsConfigurationArgs:
def __init__(__self__, *,
additional_unattend_content: Optional[pulumi.Input[Sequence[pulumi.Input['AdditionalUnattendContentArgs']]]] = None,
enable_automatic_updates: Optional[pulumi.Input[bool]] = None,
provision_vm_agent: Optional[pulumi.Input[bool]] = None,
time_zone: Optional[pulumi.Input[str]] = None,
win_rm: Optional[pulumi.Input['WinRMConfigurationArgs']] = None):
"""
Specifies Windows operating system settings on the virtual machine.
:param pulumi.Input[Sequence[pulumi.Input['AdditionalUnattendContentArgs']]] additional_unattend_content: Specifies additional base-64 encoded XML formatted information that can be included in the Unattend.xml file, which is used by Windows Setup.
:param pulumi.Input[bool] enable_automatic_updates: Indicates whether Automatic Updates is enabled for the Windows virtual machine. Default value is true. <br><br> For virtual machine scale sets, this property can be updated and updates will take effect on OS reprovisioning.
:param pulumi.Input[bool] provision_vm_agent: Indicates whether virtual machine agent should be provisioned on the virtual machine. <br><br> When this property is not specified in the request body, default behavior is to set it to true. This will ensure that VM Agent is installed on the VM so that extensions can be added to the VM later.
:param pulumi.Input[str] time_zone: Specifies the time zone of the virtual machine. e.g. "Pacific Standard Time". <br><br> Possible values can be [TimeZoneInfo.Id](https://docs.microsoft.com/en-us/dotnet/api/system.timezoneinfo.id?#System_TimeZoneInfo_Id) value from time zones returned by [TimeZoneInfo.GetSystemTimeZones](https://docs.microsoft.com/en-us/dotnet/api/system.timezoneinfo.getsystemtimezones).
:param pulumi.Input['WinRMConfigurationArgs'] win_rm: Specifies the Windows Remote Management listeners. This enables remote Windows PowerShell.
"""
if additional_unattend_content is not None:
pulumi.set(__self__, "additional_unattend_content", additional_unattend_content)
if enable_automatic_updates is not None:
pulumi.set(__self__, "enable_automatic_updates", enable_automatic_updates)
if provision_vm_agent is not None:
pulumi.set(__self__, "provision_vm_agent", provision_vm_agent)
if time_zone is not None:
pulumi.set(__self__, "time_zone", time_zone)
if win_rm is not None:
pulumi.set(__self__, "win_rm", win_rm)
@property
@pulumi.getter(name="additionalUnattendContent")
def additional_unattend_content(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AdditionalUnattendContentArgs']]]]:
"""
Specifies additional base-64 encoded XML formatted information that can be included in the Unattend.xml file, which is used by Windows Setup.
"""
return pulumi.get(self, "additional_unattend_content")
@additional_unattend_content.setter
def additional_unattend_content(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AdditionalUnattendContentArgs']]]]):
pulumi.set(self, "additional_unattend_content", value)
@property
@pulumi.getter(name="enableAutomaticUpdates")
def enable_automatic_updates(self) -> Optional[pulumi.Input[bool]]:
"""
Indicates whether Automatic Updates is enabled for the Windows virtual machine. Default value is true. <br><br> For virtual machine scale sets, this property can be updated and updates will take effect on OS reprovisioning.
"""
return pulumi.get(self, "enable_automatic_updates")
@enable_automatic_updates.setter
def enable_automatic_updates(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "enable_automatic_updates", value)
@property
@pulumi.getter(name="provisionVMAgent")
def provision_vm_agent(self) -> Optional[pulumi.Input[bool]]:
"""
Indicates whether virtual machine agent should be provisioned on the virtual machine. <br><br> When this property is not specified in the request body, default behavior is to set it to true. This will ensure that VM Agent is installed on the VM so that extensions can be added to the VM later.
"""
return pulumi.get(self, "provision_vm_agent")
@provision_vm_agent.setter
def provision_vm_agent(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "provision_vm_agent", value)
@property
@pulumi.getter(name="timeZone")
def time_zone(self) -> Optional[pulumi.Input[str]]:
"""
Specifies the time zone of the virtual machine. e.g. "Pacific Standard Time". <br><br> Possible values can be [TimeZoneInfo.Id](https://docs.microsoft.com/en-us/dotnet/api/system.timezoneinfo.id?#System_TimeZoneInfo_Id) value from time zones returned by [TimeZoneInfo.GetSystemTimeZones](https://docs.microsoft.com/en-us/dotnet/api/system.timezoneinfo.getsystemtimezones).
"""
return pulumi.get(self, "time_zone")
@time_zone.setter
def time_zone(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "time_zone", value)
@property
@pulumi.getter(name="winRM")
def win_rm(self) -> Optional[pulumi.Input['WinRMConfigurationArgs']]:
"""
Specifies the Windows Remote Management listeners. This enables remote Windows PowerShell.
"""
return pulumi.get(self, "win_rm")
@win_rm.setter
def win_rm(self, value: Optional[pulumi.Input['WinRMConfigurationArgs']]):
pulumi.set(self, "win_rm", value)
| 53.115423 | 1,266 | 0.693693 |
b126500b61cac328ca9046126829b5e5fd0e3024 | 1,484 | py | Python | plotly/tests/test_optional/test_matplotlylib/test_annotations.py | piyush1301/plotly.py | 50cd5c4cd4732042422751c7760acbab8dd8a50d | [
"MIT"
] | 6 | 2019-05-03T02:12:04.000Z | 2020-03-01T06:33:21.000Z | plotly/tests/test_optional/test_matplotlylib/test_annotations.py | Vesauza/plotly.py | e53e626d59495d440341751f60aeff73ff365c28 | [
"MIT"
] | null | null | null | plotly/tests/test_optional/test_matplotlylib/test_annotations.py | Vesauza/plotly.py | e53e626d59495d440341751f60aeff73ff365c28 | [
"MIT"
] | 5 | 2019-05-18T16:50:11.000Z | 2021-07-06T21:14:36.000Z | from __future__ import absolute_import
from nose.plugins.attrib import attr
from plotly import optional_imports
matplotlylib = optional_imports.get_module('plotly.matplotlylib')
if matplotlylib:
import matplotlib.pyplot as plt
from plotly.tests.utils import compare_dict, strip_dict_params
from plotly.tests.test_optional.optional_utils import run_fig
from plotly.tests.test_optional.test_matplotlylib.data.annotations import *
@attr('matplotlib')
def test_annotations():
fig, ax = plt.subplots()
ax.plot([1, 2, 3], 'b-')
ax.plot([3, 2, 1], 'b-')
ax.text(0.001, 0.999,
'top-left', transform=ax.transAxes, va='top', ha='left')
ax.text(0.001, 0.001,
'bottom-left', transform=ax.transAxes, va='baseline', ha='left')
ax.text(0.999, 0.999,
'top-right', transform=ax.transAxes, va='top', ha='right')
ax.text(0.999, 0.001,
'bottom-right', transform=ax.transAxes, va='baseline', ha='right')
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
d1, d2 = strip_dict_params(data_dict, ANNOTATIONS['data'][data_no], ignore=['uid'])
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
for no, note in enumerate(renderer.plotly_fig['layout']['annotations']):
equivalent, msg = compare_dict(note,
ANNOTATIONS['layout']['annotations'][no])
assert equivalent, msg
| 38.051282 | 91 | 0.660377 |
201c7a85a56073efd32b9e7af9fb2915e49255e4 | 6,931 | py | Python | fsspec/mapping.py | dish59742/filesystem_spec | 87e5ca57fd8be7b636451d4237fe47f6e764fa79 | [
"BSD-3-Clause"
] | null | null | null | fsspec/mapping.py | dish59742/filesystem_spec | 87e5ca57fd8be7b636451d4237fe47f6e764fa79 | [
"BSD-3-Clause"
] | null | null | null | fsspec/mapping.py | dish59742/filesystem_spec | 87e5ca57fd8be7b636451d4237fe47f6e764fa79 | [
"BSD-3-Clause"
] | null | null | null | import array
from collections.abc import MutableMapping
from .core import url_to_fs
class FSMap(MutableMapping):
"""Wrap a FileSystem instance as a mutable wrapping.
The keys of the mapping become files under the given root, and the
values (which must be bytes) the contents of those files.
Parameters
----------
root: string
prefix for all the files
fs: FileSystem instance
check: bool (=True)
performs a touch at the location, to check for write access.
Examples
--------
>>> fs = FileSystem(**parameters) # doctest: +SKIP
>>> d = FSMap('my-data/path/', fs) # doctest: +SKIP
or, more likely
>>> d = fs.get_mapper('my-data/path/')
>>> d['loc1'] = b'Hello World' # doctest: +SKIP
>>> list(d.keys()) # doctest: +SKIP
['loc1']
>>> d['loc1'] # doctest: +SKIP
b'Hello World'
"""
def __init__(self, root, fs, check=False, create=False, missing_exceptions=None):
self.fs = fs
self.root = fs._strip_protocol(root).rstrip(
"/"
) # we join on '/' in _key_to_str
if missing_exceptions is None:
missing_exceptions = (
FileNotFoundError,
IsADirectoryError,
NotADirectoryError,
)
self.missing_exceptions = missing_exceptions
if create:
if not self.fs.exists(root):
self.fs.mkdir(root)
if check:
if not self.fs.exists(root):
raise ValueError(
"Path %s does not exist. Create "
" with the ``create=True`` keyword" % root
)
self.fs.touch(root + "/a")
self.fs.rm(root + "/a")
def clear(self):
"""Remove all keys below root - empties out mapping"""
try:
self.fs.rm(self.root, True)
self.fs.mkdir(self.root)
except: # noqa: E722
pass
def getitems(self, keys, on_error="raise"):
"""Fetch multiple items from the store
If the backend is async-able, this might proceed concurrently
Parameters
----------
keys: list(str)
They keys to be fetched
on_error : "raise", "omit", "return"
If raise, an underlying exception will be raised (converted to KeyError
if the type is in self.missing_exceptions); if omit, keys with exception
will simply not be included in the output; if "return", all keys are
included in the output, but the value will be bytes or an exception
instance.
Returns
-------
dict(key, bytes|exception)
"""
keys2 = [self._key_to_str(k) for k in keys]
oe = on_error if on_error == "raise" else "return"
try:
out = self.fs.cat(keys2, on_error=oe)
except self.missing_exceptions as e:
raise KeyError from e
out = {
k: (KeyError() if isinstance(v, self.missing_exceptions) else v)
for k, v in out.items()
}
return {
key: out[k2]
for key, k2 in zip(keys, keys2)
if on_error == "return" or not isinstance(out[k2], BaseException)
}
def setitems(self, values_dict):
"""Set the values of multiple items in the store
Parameters
----------
values_dict: dict(str, bytes)
"""
values = {self._key_to_str(k): maybe_convert(v) for k, v in values_dict.items()}
self.fs.pipe(values)
def delitems(self, keys):
"""Remove multiple keys from the store"""
self.fs.rm([self._key_to_str(k) for k in keys])
def _key_to_str(self, key):
"""Generate full path for the key"""
if isinstance(key, (tuple, list)):
key = str(tuple(key))
else:
key = str(key)
return "/".join([self.root, key]) if self.root else key
def _str_to_key(self, s):
"""Strip path of to leave key name"""
return s[len(self.root) :].lstrip("/")
def __getitem__(self, key, default=None):
"""Retrieve data"""
k = self._key_to_str(key)
try:
result = self.fs.cat(k)
except self.missing_exceptions:
if default is not None:
return default
raise KeyError(key)
return result
def pop(self, key, default=None):
result = self.__getitem__(key, default)
try:
del self[key]
except KeyError:
pass
return result
def __setitem__(self, key, value):
"""Store value in key"""
key = self._key_to_str(key)
self.fs.mkdirs(self.fs._parent(key), exist_ok=True)
self.fs.pipe_file(key, maybe_convert(value))
def __iter__(self):
return (self._str_to_key(x) for x in self.fs.find(self.root))
def __len__(self):
return len(self.fs.find(self.root))
def __delitem__(self, key):
"""Remove key"""
try:
self.fs.rm(self._key_to_str(key))
except: # noqa: E722
raise KeyError
def __contains__(self, key):
"""Does key exist in mapping?"""
path = self._key_to_str(key)
return self.fs.exists(path) and self.fs.isfile(path)
def __reduce__(self):
return FSMap, (self.root, self.fs, False, False, self.missing_exceptions)
def maybe_convert(value):
if isinstance(value, array.array) or hasattr(value, "__array__"):
# bytes-like things
value = bytearray(memoryview(value))
return value
def get_mapper(url, check=False, create=False, missing_exceptions=None, **kwargs):
"""Create key-value interface for given URL and options
The URL will be of the form "protocol://location" and point to the root
of the mapper required. All keys will be file-names below this location,
and their values the contents of each key.
Also accepts compound URLs like zip::s3://bucket/file.zip , see ``fsspec.open``.
Parameters
----------
url: str
Root URL of mapping
check: bool
Whether to attempt to read from the location before instantiation, to
check that the mapping does exist
create: bool
Whether to make the directory corresponding to the root before
instantiating
missing_exceptions: None or tuple
If given, these excpetion types will be regarded as missing keys and
return KeyError when trying to read data. By default, you get
(FileNotFoundError, IsADirectoryError, NotADirectoryError)
Returns
-------
``FSMap`` instance, the dict-like key-value store.
"""
# Removing protocol here - could defer to each open() on the backend
fs, urlpath = url_to_fs(url, **kwargs)
return FSMap(urlpath, fs, check, create, missing_exceptions=missing_exceptions)
| 32.38785 | 88 | 0.585918 |
ca572be730a66c69bdc5de1c91f06db112478c19 | 454 | py | Python | server/src/common/utils/db.py | TaitoUnited/data-pipeline-template | dc002482c24388b9d49ced9ea47be6068ff69fe0 | [
"MIT"
] | null | null | null | server/src/common/utils/db.py | TaitoUnited/data-pipeline-template | dc002482c24388b9d49ced9ea47be6068ff69fe0 | [
"MIT"
] | null | null | null | server/src/common/utils/db.py | TaitoUnited/data-pipeline-template | dc002482c24388b9d49ced9ea47be6068ff69fe0 | [
"MIT"
] | null | null | null | import re
from .misc import propertyExists
def add_paging(query, params):
q = query
if propertyExists(params, "offset"):
q += "OFFSET %(offset)s "
if propertyExists(params, "limit"):
q += "LIMIT %(limit)s "
return q
def generate_count_query(query):
return (
re.sub(r"SELECT.*FROM", "SELECT count(*) FROM", query)
.replace("OFFSET %(offset)s ", "")
.replace("LIMIT %(limit)s ", "")
)
| 19.73913 | 62 | 0.577093 |
ebb098633adcb6d2e79d6f7c17484faa07ab013e | 7,484 | py | Python | gui/qt/utxo_list.py | rc125/electrum-smart | f1afe5ced0ec458db2e5bcd45e2a771cd5f2682b | [
"MIT"
] | null | null | null | gui/qt/utxo_list.py | rc125/electrum-smart | f1afe5ced0ec458db2e5bcd45e2a771cd5f2682b | [
"MIT"
] | null | null | null | gui/qt/utxo_list.py | rc125/electrum-smart | f1afe5ced0ec458db2e5bcd45e2a771cd5f2682b | [
"MIT"
] | 3 | 2017-12-15T04:51:06.000Z | 2019-06-19T23:48:29.000Z | #!/usr/bin/env python
#
# Electrum - Lightweight SmartCash Client
# Copyright (C) 2015 Thomas Voegtlin
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from .util import *
from electrum_smart.i18n import _
class UTXOList(MyTreeWidget):
filter_columns = [0, 2] # Address, Label
def __init__(self, parent=None):
MyTreeWidget.__init__(self, parent, self.create_menu, [ _('Address'), _('Label'), _('Amount'), _('Height'), _('Output point')], 1)
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.setSortingEnabled(True)
self.wallet = self.parent.wallet if hasattr(self.parent, 'wallet') else None
self.utxos = list()
def get_name(self, x):
return x.get('prevout_hash') + ":%d"%x.get('prevout_n')
def on_update(self):
prev_selection = self.get_selected() # cache previous selection, if any
self.clear()
self.wallet = self.parent.wallet
self.utxos = self.wallet.get_utxos()
item = self.currentItem()
for x in self.utxos:
address = x.get('address')
height = x.get('height')
name = self.get_name(x)
label = self.wallet.get_label(x.get('prevout_hash'))
amount = self.parent.format_amount(x['value'], whitespaces=True)
utxo_item = SortableTreeWidgetItem([address, label, amount, '%d'%height, name[0:10] + '...' + name[-2:]])
utxo_item.DataRole = Qt.UserRole + 100
utxo_item.setFont(0, QFont(MONOSPACE_FONT))
utxo_item.setFont(2, QFont(MONOSPACE_FONT))
utxo_item.setFont(4, QFont(MONOSPACE_FONT))
utxo_item.setData(0, Qt.UserRole, name)
a_frozen = self.wallet.is_frozen(address)
c_frozen = x['is_frozen_coin']
if a_frozen and not c_frozen:
utxo_item.setBackground(0, QColor('lightblue'))
elif c_frozen and not a_frozen:
utxo_item.setBackground(0, ColorScheme.BLUE.as_color(True))
elif c_frozen and a_frozen:
utxo_item.setBackground(0, ColorScheme.BLUE.as_color(True))
utxo_item.setBackground(0, QColor('lightblue'))
utxo_item.setForeground(0, QColor('#3399ff'))
utxo_item.setData(0, Qt.UserRole + 1, "{}{}".format(("a" if a_frozen else ""), ("c" if c_frozen else "")))
self.addChild(utxo_item)
utxo_item.setSelected(name in prev_selection)
def get_selected(self):
return {x.data(0, Qt.UserRole): x.data(0, Qt.UserRole + 1) # dict of "name" -> frozen flags string (eg: "ac")
for x in self.selectedItems()}
def create_menu(self, position):
selected = self.get_selected()
if not selected:
return
menu = QMenu()
coins = filter(lambda x: self.get_name(x) in selected, self.utxos)
spendable_coins = list(filter(lambda x: not selected.get(self.get_name(x), ''), coins))
# Unconditionally add the "Spend" option but leave it disabled if there are no spendable_coins
menu.addAction(_("Spend"), lambda: self.parent.spend_coins(spendable_coins)).setEnabled(bool(spendable_coins))
if len(selected) == 1:
# single selection, offer them the "Details" option and also coin/address "freeze" status, if any
txid = list(selected.keys())[0].split(':')[0]
frozen_flags = list(selected.values())[0]
tx = self.wallet.transactions.get(txid)
menu.addAction(_("Details"), lambda: self.parent.show_transaction(tx))
act = None
needsep = True
if 'c' in frozen_flags:
menu.addSeparator()
menu.addAction(_("Coin is frozen"), lambda: None).setEnabled(False)
menu.addAction(_("Unfreeze Coin"), lambda: self.set_frozen_coins(list(selected.keys()), False))
menu.addSeparator()
needsep = False
else:
menu.addAction(_("Freeze Coin"), lambda: self.set_frozen_coins(list(selected.keys()), True))
if 'a' in frozen_flags:
if needsep: menu.addSeparator()
menu.addAction(_("Address is frozen"), lambda: None).setEnabled(False)
menu.addAction(_("Unfreeze Address"), lambda: self.set_frozen_addresses_for_coins(list(selected.keys()), False))
else:
menu.addAction(_("Freeze Address"), lambda: self.set_frozen_addresses_for_coins(list(selected.keys()), True))
else:
# multi-selection
menu.addSeparator()
if any(['c' not in flags for flags in selected.values()]):
# they have some coin-level non-frozen in the selection, so add the menu action "Freeze coins"
menu.addAction(_("Freeze Coins"), lambda: self.set_frozen_coins(list(selected.keys()), True))
if any(['c' in flags for flags in selected.values()]):
# they have some coin-level frozen in the selection, so add the menu action "Unfreeze coins"
menu.addAction(_("Unfreeze Coins"), lambda: self.set_frozen_coins(list(selected.keys()), False))
if any(['a' not in flags for flags in selected.values()]):
# they have some address-level non-frozen in the selection, so add the menu action "Freeze addresses"
menu.addAction(_("Freeze Addresses"), lambda: self.set_frozen_addresses_for_coins(list(selected.keys()), True))
if any(['a' in flags for flags in selected.values()]):
# they have some address-level frozen in the selection, so add the menu action "Unfreeze addresses"
menu.addAction(_("Unfreeze Addresses"), lambda: self.set_frozen_addresses_for_coins(list(selected.keys()), False))
menu.exec_(self.viewport().mapToGlobal(position))
def on_permit_edit(self, item, column):
# disable editing fields in this tab (labels)
return False
def set_frozen_coins(self, coins, b):
if self.parent:
self.parent.set_frozen_coin_state(coins, b)
def set_frozen_addresses_for_coins(self, coins, b):
if not self.parent: return
addrs = set()
for utxo in self.utxos:
name = self.get_name(utxo)
if name in coins:
addrs.add(utxo['address'])
if addrs:
self.parent.set_frozen_state(list(addrs), b) | 50.911565 | 138 | 0.639097 |
e7b7c70c25651e71823fb8e6317cd4d202eaa031 | 3,632 | py | Python | RDRPOSTagger_python_3/pSCRDRtagger/ExtRDRPOSTagger.py | jirian/text_summarizer_czech | 45be8ca8cd62b467a46e63421fd92a02f896e056 | [
"MIT"
] | 2 | 2019-06-29T02:13:35.000Z | 2019-08-22T08:00:17.000Z | RDRPOSTagger_python_3/pSCRDRtagger/ExtRDRPOSTagger.py | jirian/text_summarizer_czech | 45be8ca8cd62b467a46e63421fd92a02f896e056 | [
"MIT"
] | null | null | null | RDRPOSTagger_python_3/pSCRDRtagger/ExtRDRPOSTagger.py | jirian/text_summarizer_czech | 45be8ca8cd62b467a46e63421fd92a02f896e056 | [
"MIT"
] | 2 | 2020-02-23T18:22:25.000Z | 2022-02-11T19:00:10.000Z | # -*- coding: utf-8 -*-
import os
import sys
os.chdir("../")
sys.setrecursionlimit(100000)
sys.path.append(os.path.abspath(""))
os.chdir("./pSCRDRtagger")
from multiprocessing import Pool
from SCRDRlearner.Object import FWObject, getWordTag
from SCRDRlearner.SCRDRTree import SCRDRTree
from SCRDRlearner.SCRDRTreeLearner import SCRDRTreeLearner
from Utility.Config import NUMBER_OF_PROCESSES, THRESHOLD
def unwrap_self_ExtRDRPOSTagger(arg, **kwarg):
return ExtRDRPOSTagger.tagInitializedSentence(*arg, **kwarg)
class ExtRDRPOSTagger(SCRDRTree):
def __init__(self):
self.root = None
def tagInitializedSentence(self, initSen):
wordTags = initSen.replace("“", "''").replace("”", "''").replace("\"", "''").split()
sen = []
for i in range(len(wordTags)):
fwObject = FWObject.getFWObject(wordTags, i)
word, tag = getWordTag(wordTags[i])
node = self.findFiredNode(fwObject)
if node.depth > 0:
sen.append(word + "/" + node.conclusion)
else:# Fired at root, return initialized tag
sen.append(word + "/" + tag)
return " ".join(sen)
def tagInitializedCorpus(self, inputFile):
lines = open(inputFile, "r").readlines()
#Change the value of NUMBER_OF_PROCESSES to obtain faster tagging process!
pool = Pool(processes = NUMBER_OF_PROCESSES)
taggedLines = pool.map(unwrap_self_ExtRDRPOSTagger, zip([self] * len(lines), lines))
out = open(inputFile + ".TAGGED", "w")
for line in taggedLines:
out.write(line + "\n")
out.close()
print "\nOutput file:", inputFile + ".TAGGED"
def printHelp():
print "\n===== Usage ====="
print '\n#1: To train RDRPOSTagger in case of using output from an external initial POS tagger:'
print '\npython ExtRDRPOSTagger.py train PATH-TO-GOLD-STANDARD-TRAINING-CORPUS PATH-TO-TRAINING-CORPUS-INITIALIZED-BY-EXTERNAL-TAGGER'
print '\nExample: python ExtRDRPOSTagger.py train ../data/goldTrain ../data/initTrain'
print '\n#2: To use the trained model for POS tagging on a test corpus where words already are initially tagged by the external initial tagger:'
print '\npython ExtRDRPOSTagger.py tag PATH-TO-TRAINED-MODEL PATH-TO-TEST-CORPUS-INITIALIZED-BY-EXTERNAL-TAGGER'
print '\nExample: python ExtRDRPOSTagger.py tag ../data/initTrain.RDR ../data/initTest'
print '\n#3: Find the full usage at http://rdrpostagger.sourceforge.net !'
def run(args = sys.argv[1:]):
if (len(args) == 0):
printHelp()
elif args[0].lower() == "train":
try:
print "\n===== Start ====="
print '\nLearn a tree model of rules for POS tagging from %s and %s ' % (args[1], args[2])
rdrTree = SCRDRTreeLearner(THRESHOLD[0], THRESHOLD[1])
rdrTree.learnRDRTree(args[2], args[1])
print "\nWrite the learned tree model to file ", args[2] + ".RDR"
rdrTree.writeToFile(args[2] + ".RDR")
print '\nDone!'
except Exception, e:
print "\nERROR ==> ", e
printHelp()
raise e
elif args[0].lower() == "tag":
try:
r = ExtRDRPOSTagger()
print "\n=> Read a POS tagging model from", args[1]
r.constructSCRDRtreeFromRDRfile(args[1])
print "\n=> Perform POS tagging on", args[2]
r.tagInitializedCorpus(args[2])
except Exception, e:
print "\nERROR ==> ", e
printHelp()
raise e
else:
printHelp()
if __name__ == "__main__":
run()
| 41.272727 | 148 | 0.622247 |
b1b18b0d32362bbc1d0c1126fbe7d3d526df6d7c | 423 | py | Python | tests/utils/pytest_wrapper.py | Bukkster/fiftyone | c061216de5094131c8ce8718d8a6ac58056b003e | [
"Apache-2.0"
] | 3 | 2022-01-18T06:13:33.000Z | 2022-02-14T13:28:23.000Z | tests/utils/pytest_wrapper.py | Bukkster/fiftyone | c061216de5094131c8ce8718d8a6ac58056b003e | [
"Apache-2.0"
] | null | null | null | tests/utils/pytest_wrapper.py | Bukkster/fiftyone | c061216de5094131c8ce8718d8a6ac58056b003e | [
"Apache-2.0"
] | null | null | null | """
Wrapper around pytest that cleans up subprocesses.
| Copyright 2017-2022, Voxel51, Inc.
| `voxel51.com <https://voxel51.com/>`_
|
"""
import sys
import psutil
import pytest
try:
code = pytest.main(sys.argv[1:])
finally:
for child in reversed(psutil.Process().children(recursive=True)):
try:
child.kill()
child.wait()
except psutil.Error:
pass
exit(code)
| 16.92 | 69 | 0.621749 |
4299f7dad5cdc60f34ef7e2535f6f0429718908e | 263 | py | Python | bookbug/bookbug/items.py | Hegelim/Web-Crawler | 37ffe6ffe8c713cc1d51517a60f19f8d1584f68d | [
"MIT"
] | null | null | null | bookbug/bookbug/items.py | Hegelim/Web-Crawler | 37ffe6ffe8c713cc1d51517a60f19f8d1584f68d | [
"MIT"
] | null | null | null | bookbug/bookbug/items.py | Hegelim/Web-Crawler | 37ffe6ffe8c713cc1d51517a60f19f8d1584f68d | [
"MIT"
] | null | null | null | # Define here the models for your scraped items
#
# See documentation in:
# https://docs.scrapy.org/en/latest/topics/items.html
import scrapy
class BookbugItem(scrapy.Item):
# define the fields for your item here like:
# name = scrapy.Field()
pass
| 20.230769 | 53 | 0.714829 |
4e07edef1d6b0cc1b982c73229ed7fafcd4d11df | 714 | py | Python | tests/preprocessing/test_act.py | d-e-h-i-o/bachelor_thesis | 64bc5fb2c65621f7a8265bade0328d3f8c950ff3 | [
"MIT"
] | 1 | 2021-12-20T12:56:32.000Z | 2021-12-20T12:56:32.000Z | tests/preprocessing/test_act.py | DFKI-NLP/covid19-law-matching | c704a926977ef5f7fd4867125a2e79f352efd163 | [
"MIT"
] | null | null | null | tests/preprocessing/test_act.py | DFKI-NLP/covid19-law-matching | c704a926977ef5f7fd4867125a2e79f352efd163 | [
"MIT"
] | 1 | 2021-11-24T11:21:33.000Z | 2021-11-24T11:21:33.000Z | from datetime import date
from training.preprocessing.datasets_.models import Act
def test_act_from_file_constructor():
file_path = "tests/fixtures/InfSchMV_fixture.json"
act = Act.from_file(file_path)
assert act
def test_act_should_return_valid_sections():
file_path = "tests/fixtures/InfSchMV_fixture.json"
act = Act.from_file(file_path)
valid_date = date(2021, 2, 13)
assert len(act.all_sections_for(valid_date)) == 32
assert act.has_sections_for(valid_date)
def test_act_has_sections_for():
file_path = "tests/fixtures/InfSchMV_fixture.json"
act = Act.from_file(file_path)
invalid_date = date(2022, 2, 13)
assert not act.has_sections_for(invalid_date)
| 25.5 | 55 | 0.753501 |
d9f981402e8de91212ebce6b98bc25a64941315b | 4,135 | py | Python | httprunner/cli.py | hewei198711/httprunner2.5.7 | fb4ca1abd9c50b3cef288adf29cce3217c7d8e91 | [
"Apache-2.0"
] | null | null | null | httprunner/cli.py | hewei198711/httprunner2.5.7 | fb4ca1abd9c50b3cef288adf29cce3217c7d8e91 | [
"Apache-2.0"
] | null | null | null | httprunner/cli.py | hewei198711/httprunner2.5.7 | fb4ca1abd9c50b3cef288adf29cce3217c7d8e91 | [
"Apache-2.0"
] | null | null | null | import argparse
import os
import sys
import sentry_sdk
from httprunner import __description__, __version__, exceptions
from httprunner.api import HttpRunner
from httprunner.compat import is_py2
from httprunner.loader import load_cases
from httprunner.logger import color_print, log_error
from httprunner.report import gen_html_report
from httprunner.utils import (create_scaffold, get_python2_retire_msg,
prettify_json_file, init_sentry_sdk)
init_sentry_sdk()
def main():
""" API test: parse command line options and run commands.
解析命令行选项和运行命令
"""
if is_py2:
color_print(get_python2_retire_msg(), "YELLOW")
parser = argparse.ArgumentParser(description=__description__)
parser.add_argument(
'-V', '--version', dest='version', action='store_true',
help="show version")
parser.add_argument(
'testfile_paths', nargs='*',
help="Specify api/testcase/testsuite file paths to run.")
parser.add_argument(
'--log-level', default='INFO',
help="Specify logging level, default is INFO.")
parser.add_argument(
'--log-file',
help="Write logs to specified file path.")
parser.add_argument(
'--dot-env-path',
help="Specify .env file path, which is useful for keeping sensitive data.")
parser.add_argument(
'--report-template',
help="Specify report template path.")
parser.add_argument(
'--report-dir',
help="Specify report save directory.")
parser.add_argument(
'--report-file',
help="Specify report file path, this has higher priority than specifying report dir.")
parser.add_argument(
'--save-tests', action='store_true', default=False,
help="Save loaded/parsed/vars_out/summary json data to JSON files.")
parser.add_argument(
'--failfast', action='store_true', default=False,
help="Stop the test run on the first error or failure.")
parser.add_argument(
'--startproject',
help="Specify new project name.")
parser.add_argument(
'--validate', nargs='*',
help="Validate YAML/JSON api/testcase/testsuite format.") #检验json是否正确
parser.add_argument(
'--prettify', nargs='*',
help="Prettify JSON testcase format.") #美化
args = parser.parse_args()
if len(sys.argv) == 1:
# no argument passed
parser.print_help()
sys.exit(0)
if args.version:
color_print("{}".format(__version__), "GREEN")
sys.exit(0)
if args.validate:
for validate_path in args.validate:
try:
color_print("validate test file: {}".format(validate_path), "GREEN")
load_cases(validate_path, args.dot_env_path)
except exceptions.MyBaseError as ex:
log_error(str(ex))
continue
color_print("done!", "BLUE")
sys.exit(0)
if args.prettify:
prettify_json_file(args.prettify)
sys.exit(0)
project_name = args.startproject
if project_name:
create_scaffold(project_name)
sys.exit(0)
runner = HttpRunner(
failfast=args.failfast,
save_tests=args.save_tests,
log_level=args.log_level,
log_file=args.log_file
)
err_code = 0
try:
for path in args.testfile_paths:
summary = runner.run(path, dot_env_path=args.dot_env_path)
report_dir = args.report_dir or os.path.join(runner.project_working_directory, "reports")
gen_html_report(
summary,
report_template=args.report_template,
report_dir=report_dir,
report_file=args.report_file
)
err_code |= (0 if summary and summary["success"] else 1)
except Exception as ex:
color_print("!!!!!!!!!! exception stage: {} !!!!!!!!!!".format(runner.exception_stage), "YELLOW")
color_print(str(ex), "RED")
sentry_sdk.capture_exception(ex)
err_code = 1
sys.exit(err_code)
if __name__ == '__main__':
main()
| 32.054264 | 105 | 0.629988 |
cb701c42c57d30ed4f95db7aab3c9b22364fc8bf | 18,489 | py | Python | tensorflow/contrib/slim/python/slim/nets/resnet_v1_test.py | zhaojunz/tensorflow | d1415bdc03fcdb090752ab0c91ee529dc09eb4ee | [
"Apache-2.0"
] | 44 | 2017-01-26T11:39:36.000Z | 2019-06-28T10:03:19.000Z | tensorflow/contrib/slim/python/slim/nets/resnet_v1_test.py | zhaojunz/tensorflow | d1415bdc03fcdb090752ab0c91ee529dc09eb4ee | [
"Apache-2.0"
] | 5 | 2017-05-22T08:07:52.000Z | 2019-02-25T12:09:16.000Z | tensorflow/contrib/slim/python/slim/nets/resnet_v1_test.py | zhaojunz/tensorflow | d1415bdc03fcdb090752ab0c91ee529dc09eb4ee | [
"Apache-2.0"
] | 10 | 2017-03-27T04:15:07.000Z | 2018-07-09T15:03:03.000Z | # Copyright 2016 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 slim.nets.resnet_v1."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
from tensorflow.contrib import layers
from tensorflow.contrib.framework.python.ops import arg_scope
from tensorflow.contrib.layers.python.layers import utils
from tensorflow.contrib.slim.python.slim.nets import resnet_utils
from tensorflow.contrib.slim.python.slim.nets import resnet_v1
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.framework import random_seed
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import variable_scope
from tensorflow.python.ops import variables
from tensorflow.python.platform import test
def create_test_input(batch_size, height, width, channels):
"""Create test input tensor.
Args:
batch_size: The number of images per batch or `None` if unknown.
height: The height of each image or `None` if unknown.
width: The width of each image or `None` if unknown.
channels: The number of channels per image or `None` if unknown.
Returns:
Either a placeholder `Tensor` of dimension
[batch_size, height, width, channels] if any of the inputs are `None` or a
constant `Tensor` with the mesh grid values along the spatial dimensions.
"""
if None in [batch_size, height, width, channels]:
return array_ops.placeholder(dtypes.float32,
(batch_size, height, width, channels))
else:
return math_ops.to_float(
np.tile(
np.reshape(
np.reshape(np.arange(height), [height, 1]) + np.reshape(
np.arange(width), [1, width]), [1, height, width, 1]),
[batch_size, 1, 1, channels]))
class ResnetUtilsTest(test.TestCase):
def testSubsampleThreeByThree(self):
x = array_ops.reshape(math_ops.to_float(math_ops.range(9)), [1, 3, 3, 1])
x = resnet_utils.subsample(x, 2)
expected = array_ops.reshape(
constant_op.constant([0, 2, 6, 8]), [1, 2, 2, 1])
with self.test_session():
self.assertAllClose(x.eval(), expected.eval())
def testSubsampleFourByFour(self):
x = array_ops.reshape(math_ops.to_float(math_ops.range(16)), [1, 4, 4, 1])
x = resnet_utils.subsample(x, 2)
expected = array_ops.reshape(
constant_op.constant([0, 2, 8, 10]), [1, 2, 2, 1])
with self.test_session():
self.assertAllClose(x.eval(), expected.eval())
def testConv2DSameEven(self):
n, n2 = 4, 2
# Input image.
x = create_test_input(1, n, n, 1)
# Convolution kernel.
w = create_test_input(1, 3, 3, 1)
w = array_ops.reshape(w, [3, 3, 1, 1])
variable_scope.get_variable('Conv/weights', initializer=w)
variable_scope.get_variable('Conv/biases', initializer=array_ops.zeros([1]))
variable_scope.get_variable_scope().reuse_variables()
y1 = layers.conv2d(x, 1, [3, 3], stride=1, scope='Conv')
y1_expected = math_ops.to_float([[14, 28, 43, 26], [28, 48, 66, 37],
[43, 66, 84, 46], [26, 37, 46, 22]])
y1_expected = array_ops.reshape(y1_expected, [1, n, n, 1])
y2 = resnet_utils.subsample(y1, 2)
y2_expected = math_ops.to_float([[14, 43], [43, 84]])
y2_expected = array_ops.reshape(y2_expected, [1, n2, n2, 1])
y3 = resnet_utils.conv2d_same(x, 1, 3, stride=2, scope='Conv')
y3_expected = y2_expected
y4 = layers.conv2d(x, 1, [3, 3], stride=2, scope='Conv')
y4_expected = math_ops.to_float([[48, 37], [37, 22]])
y4_expected = array_ops.reshape(y4_expected, [1, n2, n2, 1])
with self.test_session() as sess:
sess.run(variables.global_variables_initializer())
self.assertAllClose(y1.eval(), y1_expected.eval())
self.assertAllClose(y2.eval(), y2_expected.eval())
self.assertAllClose(y3.eval(), y3_expected.eval())
self.assertAllClose(y4.eval(), y4_expected.eval())
def testConv2DSameOdd(self):
n, n2 = 5, 3
# Input image.
x = create_test_input(1, n, n, 1)
# Convolution kernel.
w = create_test_input(1, 3, 3, 1)
w = array_ops.reshape(w, [3, 3, 1, 1])
variable_scope.get_variable('Conv/weights', initializer=w)
variable_scope.get_variable('Conv/biases', initializer=array_ops.zeros([1]))
variable_scope.get_variable_scope().reuse_variables()
y1 = layers.conv2d(x, 1, [3, 3], stride=1, scope='Conv')
y1_expected = math_ops.to_float([[14, 28, 43, 58, 34], [28, 48, 66, 84, 46],
[43, 66, 84, 102, 55],
[58, 84, 102, 120, 64],
[34, 46, 55, 64, 30]])
y1_expected = array_ops.reshape(y1_expected, [1, n, n, 1])
y2 = resnet_utils.subsample(y1, 2)
y2_expected = math_ops.to_float([[14, 43, 34], [43, 84, 55], [34, 55, 30]])
y2_expected = array_ops.reshape(y2_expected, [1, n2, n2, 1])
y3 = resnet_utils.conv2d_same(x, 1, 3, stride=2, scope='Conv')
y3_expected = y2_expected
y4 = layers.conv2d(x, 1, [3, 3], stride=2, scope='Conv')
y4_expected = y2_expected
with self.test_session() as sess:
sess.run(variables.global_variables_initializer())
self.assertAllClose(y1.eval(), y1_expected.eval())
self.assertAllClose(y2.eval(), y2_expected.eval())
self.assertAllClose(y3.eval(), y3_expected.eval())
self.assertAllClose(y4.eval(), y4_expected.eval())
def _resnet_plain(self, inputs, blocks, output_stride=None, scope=None):
"""A plain ResNet without extra layers before or after the ResNet blocks."""
with variable_scope.variable_scope(scope, values=[inputs]):
with arg_scope([layers.conv2d], outputs_collections='end_points'):
net = resnet_utils.stack_blocks_dense(inputs, blocks, output_stride)
end_points = utils.convert_collection_to_dict('end_points')
return net, end_points
def testEndPointsV1(self):
"""Test the end points of a tiny v1 bottleneck network."""
bottleneck = resnet_v1.bottleneck
blocks = [
resnet_utils.Block('block1', bottleneck, [(4, 1, 1), (4, 1, 2)]),
resnet_utils.Block('block2', bottleneck, [(8, 2, 1), (8, 2, 1)])
]
inputs = create_test_input(2, 32, 16, 3)
with arg_scope(resnet_utils.resnet_arg_scope()):
_, end_points = self._resnet_plain(inputs, blocks, scope='tiny')
expected = [
'tiny/block1/unit_1/bottleneck_v1/shortcut',
'tiny/block1/unit_1/bottleneck_v1/conv1',
'tiny/block1/unit_1/bottleneck_v1/conv2',
'tiny/block1/unit_1/bottleneck_v1/conv3',
'tiny/block1/unit_2/bottleneck_v1/conv1',
'tiny/block1/unit_2/bottleneck_v1/conv2',
'tiny/block1/unit_2/bottleneck_v1/conv3',
'tiny/block2/unit_1/bottleneck_v1/shortcut',
'tiny/block2/unit_1/bottleneck_v1/conv1',
'tiny/block2/unit_1/bottleneck_v1/conv2',
'tiny/block2/unit_1/bottleneck_v1/conv3',
'tiny/block2/unit_2/bottleneck_v1/conv1',
'tiny/block2/unit_2/bottleneck_v1/conv2',
'tiny/block2/unit_2/bottleneck_v1/conv3']
self.assertItemsEqual(expected, end_points)
def _stack_blocks_nondense(self, net, blocks):
"""A simplified ResNet Block stacker without output stride control."""
for block in blocks:
with variable_scope.variable_scope(block.scope, 'block', [net]):
for i, unit in enumerate(block.args):
depth, depth_bottleneck, stride = unit
with variable_scope.variable_scope('unit_%d' % (i + 1), values=[net]):
net = block.unit_fn(
net,
depth=depth,
depth_bottleneck=depth_bottleneck,
stride=stride,
rate=1)
return net
def _atrousValues(self, bottleneck):
"""Verify the values of dense feature extraction by atrous convolution.
Make sure that dense feature extraction by stack_blocks_dense() followed by
subsampling gives identical results to feature extraction at the nominal
network output stride using the simple self._stack_blocks_nondense() above.
Args:
bottleneck: The bottleneck function.
"""
blocks = [
resnet_utils.Block('block1', bottleneck, [(4, 1, 1), (4, 1, 2)]),
resnet_utils.Block('block2', bottleneck, [(8, 2, 1), (8, 2, 2)]),
resnet_utils.Block('block3', bottleneck, [(16, 4, 1), (16, 4, 2)]),
resnet_utils.Block('block4', bottleneck, [(32, 8, 1), (32, 8, 1)])
]
nominal_stride = 8
# Test both odd and even input dimensions.
height = 30
width = 31
with arg_scope(resnet_utils.resnet_arg_scope(is_training=False)):
for output_stride in [1, 2, 4, 8, None]:
with ops.Graph().as_default():
with self.test_session() as sess:
random_seed.set_random_seed(0)
inputs = create_test_input(1, height, width, 3)
# Dense feature extraction followed by subsampling.
output = resnet_utils.stack_blocks_dense(inputs, blocks,
output_stride)
if output_stride is None:
factor = 1
else:
factor = nominal_stride // output_stride
output = resnet_utils.subsample(output, factor)
# Make the two networks use the same weights.
variable_scope.get_variable_scope().reuse_variables()
# Feature extraction at the nominal network rate.
expected = self._stack_blocks_nondense(inputs, blocks)
sess.run(variables.global_variables_initializer())
output, expected = sess.run([output, expected])
self.assertAllClose(output, expected, atol=1e-4, rtol=1e-4)
def testAtrousValuesBottleneck(self):
self._atrousValues(resnet_v1.bottleneck)
class ResnetCompleteNetworkTest(test.TestCase):
"""Tests with complete small ResNet v1 networks."""
def _resnet_small(self,
inputs,
num_classes=None,
global_pool=True,
output_stride=None,
include_root_block=True,
reuse=None,
scope='resnet_v1_small'):
"""A shallow and thin ResNet v1 for faster tests."""
bottleneck = resnet_v1.bottleneck
blocks = [
resnet_utils.Block('block1', bottleneck, [(4, 1, 1)] * 2 + [(4, 1, 2)]),
resnet_utils.Block('block2', bottleneck, [(8, 2, 1)] * 2 + [(8, 2, 2)]),
resnet_utils.Block('block3', bottleneck,
[(16, 4, 1)] * 2 + [(16, 4, 2)]),
resnet_utils.Block('block4', bottleneck, [(32, 8, 1)] * 2)
]
return resnet_v1.resnet_v1(inputs, blocks, num_classes, global_pool,
output_stride, include_root_block, reuse, scope)
def testClassificationEndPoints(self):
global_pool = True
num_classes = 10
inputs = create_test_input(2, 224, 224, 3)
with arg_scope(resnet_utils.resnet_arg_scope()):
logits, end_points = self._resnet_small(
inputs, num_classes, global_pool, scope='resnet')
self.assertTrue(logits.op.name.startswith('resnet/logits'))
self.assertListEqual(logits.get_shape().as_list(), [2, 1, 1, num_classes])
self.assertTrue('predictions' in end_points)
self.assertListEqual(end_points['predictions'].get_shape().as_list(),
[2, 1, 1, num_classes])
def testClassificationShapes(self):
global_pool = True
num_classes = 10
inputs = create_test_input(2, 224, 224, 3)
with arg_scope(resnet_utils.resnet_arg_scope()):
_, end_points = self._resnet_small(
inputs, num_classes, global_pool, scope='resnet')
endpoint_to_shape = {
'resnet/block1': [2, 28, 28, 4],
'resnet/block2': [2, 14, 14, 8],
'resnet/block3': [2, 7, 7, 16],
'resnet/block4': [2, 7, 7, 32]
}
for endpoint in endpoint_to_shape:
shape = endpoint_to_shape[endpoint]
self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
def testFullyConvolutionalEndpointShapes(self):
global_pool = False
num_classes = 10
inputs = create_test_input(2, 321, 321, 3)
with arg_scope(resnet_utils.resnet_arg_scope()):
_, end_points = self._resnet_small(
inputs, num_classes, global_pool, scope='resnet')
endpoint_to_shape = {
'resnet/block1': [2, 41, 41, 4],
'resnet/block2': [2, 21, 21, 8],
'resnet/block3': [2, 11, 11, 16],
'resnet/block4': [2, 11, 11, 32]
}
for endpoint in endpoint_to_shape:
shape = endpoint_to_shape[endpoint]
self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
def testRootlessFullyConvolutionalEndpointShapes(self):
global_pool = False
num_classes = 10
inputs = create_test_input(2, 128, 128, 3)
with arg_scope(resnet_utils.resnet_arg_scope()):
_, end_points = self._resnet_small(
inputs,
num_classes,
global_pool,
include_root_block=False,
scope='resnet')
endpoint_to_shape = {
'resnet/block1': [2, 64, 64, 4],
'resnet/block2': [2, 32, 32, 8],
'resnet/block3': [2, 16, 16, 16],
'resnet/block4': [2, 16, 16, 32]
}
for endpoint in endpoint_to_shape:
shape = endpoint_to_shape[endpoint]
self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
def testAtrousFullyConvolutionalEndpointShapes(self):
global_pool = False
num_classes = 10
output_stride = 8
inputs = create_test_input(2, 321, 321, 3)
with arg_scope(resnet_utils.resnet_arg_scope()):
_, end_points = self._resnet_small(
inputs,
num_classes,
global_pool,
output_stride=output_stride,
scope='resnet')
endpoint_to_shape = {
'resnet/block1': [2, 41, 41, 4],
'resnet/block2': [2, 41, 41, 8],
'resnet/block3': [2, 41, 41, 16],
'resnet/block4': [2, 41, 41, 32]
}
for endpoint in endpoint_to_shape:
shape = endpoint_to_shape[endpoint]
self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
def testAtrousFullyConvolutionalValues(self):
"""Verify dense feature extraction with atrous convolution."""
nominal_stride = 32
for output_stride in [4, 8, 16, 32, None]:
with arg_scope(resnet_utils.resnet_arg_scope(is_training=False)):
with ops.Graph().as_default():
with self.test_session() as sess:
random_seed.set_random_seed(0)
inputs = create_test_input(2, 81, 81, 3)
# Dense feature extraction followed by subsampling.
output, _ = self._resnet_small(
inputs, None, global_pool=False, output_stride=output_stride)
if output_stride is None:
factor = 1
else:
factor = nominal_stride // output_stride
output = resnet_utils.subsample(output, factor)
# Make the two networks use the same weights.
variable_scope.get_variable_scope().reuse_variables()
# Feature extraction at the nominal network rate.
expected, _ = self._resnet_small(inputs, None, global_pool=False)
sess.run(variables.global_variables_initializer())
self.assertAllClose(
output.eval(), expected.eval(), atol=1e-4, rtol=1e-4)
def testUnknownBatchSize(self):
batch = 2
height, width = 65, 65
global_pool = True
num_classes = 10
inputs = create_test_input(None, height, width, 3)
with arg_scope(resnet_utils.resnet_arg_scope()):
logits, _ = self._resnet_small(
inputs, num_classes, global_pool, scope='resnet')
self.assertTrue(logits.op.name.startswith('resnet/logits'))
self.assertListEqual(logits.get_shape().as_list(),
[None, 1, 1, num_classes])
images = create_test_input(batch, height, width, 3)
with self.test_session() as sess:
sess.run(variables.global_variables_initializer())
output = sess.run(logits, {inputs: images.eval()})
self.assertEqual(output.shape, (batch, 1, 1, num_classes))
def testFullyConvolutionalUnknownHeightWidth(self):
batch = 2
height, width = 65, 65
global_pool = False
inputs = create_test_input(batch, None, None, 3)
with arg_scope(resnet_utils.resnet_arg_scope()):
output, _ = self._resnet_small(inputs, None, global_pool)
self.assertListEqual(output.get_shape().as_list(), [batch, None, None, 32])
images = create_test_input(batch, height, width, 3)
with self.test_session() as sess:
sess.run(variables.global_variables_initializer())
output = sess.run(output, {inputs: images.eval()})
self.assertEqual(output.shape, (batch, 3, 3, 32))
def testAtrousFullyConvolutionalUnknownHeightWidth(self):
batch = 2
height, width = 65, 65
global_pool = False
output_stride = 8
inputs = create_test_input(batch, None, None, 3)
with arg_scope(resnet_utils.resnet_arg_scope()):
output, _ = self._resnet_small(
inputs, None, global_pool, output_stride=output_stride)
self.assertListEqual(output.get_shape().as_list(), [batch, None, None, 32])
images = create_test_input(batch, height, width, 3)
with self.test_session() as sess:
sess.run(variables.global_variables_initializer())
output = sess.run(output, {inputs: images.eval()})
self.assertEqual(output.shape, (batch, 9, 9, 32))
if __name__ == '__main__':
test.main()
| 41.548315 | 80 | 0.645303 |
00cceee81b0c1adf85d9d683a0823717e6e8bfa1 | 3,717 | py | Python | tests/TestSettings.py | tinfins/CMSC495-Group-3 | 0b7ea3c885322631d6dd3ef7ee96b6a98ba2392e | [
"MIT"
] | 1 | 2021-02-11T01:18:08.000Z | 2021-02-11T01:18:08.000Z | tests/TestSettings.py | tinfins/CMSC495-Group-3 | 0b7ea3c885322631d6dd3ef7ee96b6a98ba2392e | [
"MIT"
] | 1 | 2021-01-28T00:03:15.000Z | 2021-01-28T00:03:15.000Z | tests/TestSettings.py | tinfins/CMSC495-Group-3 | 0b7ea3c885322631d6dd3ef7ee96b6a98ba2392e | [
"MIT"
] | 3 | 2021-02-13T22:45:14.000Z | 2021-02-16T02:57:11.000Z | import logging.config
import unittest
import os
from functools import partial
# Modules to Test
from src.utils.Settings import Settings
class TestSettings(unittest.TestCase):
@classmethod
def tag(cls, *tags):
'''
Decorator to add tags to a test class or method.
'''
def decorator(obj):
setattr(obj, 'tags', set(tags))
return obj
return decorator
@classmethod
def setUpClass(cls):
'''
Set up for class to instantiate constructor of class under test
'''
super(TestSettings, cls).setUpClass()
logging.disable(logging.CRITICAL)
cls.config_write_dict = None
# Settings class instantiate
cls.config = Settings('testConfig.ini')
# Create testLogs directory and testConfig.ini
cls.dir = os.mkdir('testLogs')
cls.file = open('testConfig.ini', 'w')
cls.section = 'sqldb'
# Initial values
cls.host = 'aws'
cls.username = 'user'
cls.password = 'pass'
cls.db_name = 'testDB'
# Test Dictionary
cls.testDict = {'host': cls.host, 'username': cls.username, 'password': cls.password, 'db_name': cls.db_name}
def test_create_log_settings(self):
'''
Test:
'''
dir_true = True
TestSettings.config.create_log_settings('testConfig.ini', 'testLogs', dir_true)
self.assertTrue(os.path.isdir('testLogs'), 'Should be True')
self.assertTrue(os.path.isfile('testConfig.ini'), 'Should be True')
def test_db_config_write(self):
'''
Test Settings.db_config_write() vs testDict
'''
TestSettings.config_write_dict = TestSettings.config.db_config_write(section=TestSettings.section,
host=TestSettings.host,
username=TestSettings.username,
password=TestSettings.password,
db_name=TestSettings.db_name)
config_dict = dict(TestSettings.config_write_dict.items(TestSettings.section))
self.assertEqual(config_dict, TestSettings.testDict, 'Should be equal Dicts')
def test_db_config_read(self):
'''
Test Settings.dbConfigWrite() vs testDict
'''
# Value must be written to file fiest
self.test_db_config_write()
config_read_dict = TestSettings.config.db_config_read(TestSettings.section)
self.assertEqual(config_read_dict, self.testDict, "Dicts should be equal values")
def test_check_log_dir(self):
'''
Test Settings.check_log_dir(file)
'''
log_dir = TestSettings.config.check_log_dir(directory='testLogs')
self.assertTrue(log_dir)
def test_check_log_config(self):
'''
Test Settings.check_log_config(file)
'''
log_config = TestSettings.config.check_log_config(file='testConfig.ini')
self.assertTrue(log_config)
@classmethod
def tearDownClass(cls):
super(TestSettings, cls).tearDownClass()
logging.disable(logging.NOTSET)
if os.path.exists('testConfig.ini'):
os.remove('testConfig.ini')
else:
print("File testConfig.ini does not exist")
if os.path.isdir('testLogs'):
os.rmdir('testLogs')
cls.host = ''
cls.username = ''
cls.password = ''
cls.db_name = ''
cls.testDict = {}
if __name__ == "__main__":
unittest.main()
| 34.100917 | 117 | 0.580038 |
10baf258033e616ca38d79e581b96c4a10a6279f | 1,792 | py | Python | openpype/hosts/hiero/plugins/publish_old_workflow/collect_assetbuilds.py | Tilix4/OpenPype | 8909bd890170880aa7ec8b673abaa25a9bdf40f2 | [
"MIT"
] | 1 | 2022-02-08T15:40:41.000Z | 2022-02-08T15:40:41.000Z | openpype/hosts/hiero/plugins/publish_old_workflow/collect_assetbuilds.py | zafrs/OpenPype | 4b8e7e1ed002fc55b31307efdea70b0feaed474f | [
"MIT"
] | 2 | 2022-03-18T01:46:03.000Z | 2022-03-18T01:46:16.000Z | openpype/hosts/hiero/plugins/publish_old_workflow/collect_assetbuilds.py | zafrs/OpenPype | 4b8e7e1ed002fc55b31307efdea70b0feaed474f | [
"MIT"
] | null | null | null | from pyblish import api
from openpype.pipeline import legacy_io
class CollectAssetBuilds(api.ContextPlugin):
"""Collect asset from tags.
Tag is expected to have name of the asset and metadata:
{
"family": "assetbuild"
}
"""
# Run just after CollectClip
order = api.CollectorOrder + 0.02
label = "Collect AssetBuilds"
hosts = ["hiero"]
def process(self, context):
asset_builds = {}
for asset in legacy_io.find({"type": "asset"}):
if asset["data"]["entityType"] == "AssetBuild":
self.log.debug("Found \"{}\" in database.".format(asset))
asset_builds[asset["name"]] = asset
for instance in context:
if instance.data["family"] != "clip":
continue
# Exclude non-tagged instances.
tagged = False
asset_names = []
for tag in instance.data["tags"]:
t_metadata = dict(tag.metadata())
t_family = t_metadata.get("tag.family", "")
if t_family.lower() == "assetbuild":
asset_names.append(tag["name"])
tagged = True
if not tagged:
self.log.debug(
"Skipping \"{}\" because its not tagged with "
"\"assetbuild\"".format(instance)
)
continue
# Collect asset builds.
data = {"assetbuilds": []}
for name in asset_names:
data["assetbuilds"].append(
asset_builds[name]
)
self.log.debug(
"Found asset builds: {}".format(data["assetbuilds"])
)
instance.data.update(data)
| 29.866667 | 73 | 0.501674 |
5daf773439d112d29adc5c4e0da4e2a756e40e3e | 712 | py | Python | qa/rpc-tests/create_cache.py | fransengelmann/luckyblockcoin | 3244ec21fe8dc6045adbfa2c51aa2455d5e3d066 | [
"MIT"
] | null | null | null | qa/rpc-tests/create_cache.py | fransengelmann/luckyblockcoin | 3244ec21fe8dc6045adbfa2c51aa2455d5e3d066 | [
"MIT"
] | null | null | null | qa/rpc-tests/create_cache.py | fransengelmann/luckyblockcoin | 3244ec21fe8dc6045adbfa2c51aa2455d5e3d066 | [
"MIT"
] | null | null | null | #!/usr/bin/env python3
# Copyright (c) 2016 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
#
# Helper script to create the cache
# (see LuckyblockcoinTestFramework.setup_chain)
#
from test_framework.test_framework import LuckyblockcoinTestFramework
class CreateCache(LuckyblockcoinTestFramework):
def __init__(self):
super().__init__()
# Test network and test nodes are not required:
self.num_nodes = 0
self.nodes = []
def setup_network(self):
pass
def run_test(self):
pass
if __name__ == '__main__':
CreateCache().main()
| 23.733333 | 69 | 0.707865 |
d19ceaf757131bc1116a8beddc4979e81538d839 | 22,950 | py | Python | google/cloud/sql/connector/instance_connection_manager.py | anukaal/cloud-sql-python-connector | e8799c7de46dbe11a91a9a29173a5cfd279a561d | [
"Apache-2.0"
] | 77 | 2019-06-25T15:40:43.000Z | 2022-03-25T09:45:41.000Z | google/cloud/sql/connector/instance_connection_manager.py | anukaal/cloud-sql-python-connector | e8799c7de46dbe11a91a9a29173a5cfd279a561d | [
"Apache-2.0"
] | 93 | 2019-06-27T20:24:21.000Z | 2022-03-30T14:16:17.000Z | google/cloud/sql/connector/instance_connection_manager.py | anukaal/cloud-sql-python-connector | e8799c7de46dbe11a91a9a29173a5cfd279a561d | [
"Apache-2.0"
] | 26 | 2019-07-18T15:18:51.000Z | 2022-01-27T11:39:01.000Z | """
Copyright 2019 Google LLC
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
https://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.
"""
# Custom utils import
from google.cloud.sql.connector.rate_limiter import AsyncRateLimiter
from google.cloud.sql.connector.refresh_utils import _get_ephemeral, _get_metadata
from google.cloud.sql.connector.utils import write_to_file
from google.cloud.sql.connector.version import __version__ as version
# Importing libraries
import asyncio
import aiohttp
import concurrent
import datetime
from enum import Enum
import google.auth
from google.auth.credentials import Credentials
import google.auth.transport.requests
import OpenSSL
import platform
import ssl
import socket
from tempfile import TemporaryDirectory
from typing import (
Any,
Awaitable,
Dict,
Optional,
TYPE_CHECKING,
)
from functools import partial
import logging
if TYPE_CHECKING:
import pymysql
import pg8000
import pytds
logger = logging.getLogger(name=__name__)
APPLICATION_NAME = "cloud-sql-python-connector"
SERVER_PROXY_PORT = 3307
# default_refresh_buffer is the amount of time before a refresh's result expires
# that a new refresh operation begins.
_default_refresh_buffer: int = 5 * 60 # 5 minutes
# _iam_auth_refresh_buffer is the amount of time before a refresh's result expires
# that a new refresh operation begins when IAM DB AuthN is enabled. Because token
# sources may be cached until ~60 seconds before expiration, this value must be smaller
# than default_refresh_buffer.
_iam_auth_refresh_buffer: int = 55 # seconds
class IPTypes(Enum):
PUBLIC: str = "PRIMARY"
PRIVATE: str = "PRIVATE"
class ConnectionSSLContext(ssl.SSLContext):
"""Subclass of ssl.SSLContext with added request_ssl attribute. This is
required for compatibility with pg8000 driver.
"""
def __init__(self, *args: Any, **kwargs: Any) -> None:
self.request_ssl = False
super(ConnectionSSLContext, self).__init__(*args, **kwargs)
class TLSVersionError(Exception):
"""
Raised when the required TLS protocol version is not supported.
"""
def __init__(self, *args: Any) -> None:
super(TLSVersionError, self).__init__(self, *args)
class CloudSQLConnectionError(Exception):
"""
Raised when the provided connection string is not formatted
correctly.
"""
def __init__(self, *args: Any) -> None:
super(CloudSQLConnectionError, self).__init__(self, *args)
class CloudSQLIPTypeError(Exception):
"""
Raised when IP address for the preferred IP type is not found.
"""
def __init__(self, *args: Any) -> None:
super(CloudSQLIPTypeError, self).__init__(self, *args)
class PlatformNotSupportedError(Exception):
"""
Raised when a feature is not supported on the current platform.
"""
def __init__(self, *args: Any) -> None:
super(PlatformNotSupportedError, self).__init__(self, *args)
class InstanceMetadata:
ip_addrs: Dict[str, Any]
context: ssl.SSLContext
expiration: datetime.datetime
def __init__(
self,
ephemeral_cert: str,
ip_addrs: Dict[str, Any],
private_key: bytes,
server_ca_cert: str,
expiration: datetime.datetime,
enable_iam_auth: bool,
) -> None:
self.ip_addrs = ip_addrs
if enable_iam_auth and not ssl.HAS_TLSv1_3: # type: ignore
raise TLSVersionError(
"Your current version of OpenSSL does not support TLSv1.3, "
"which is required to use IAM Authentication."
)
self.context = ConnectionSSLContext()
self.expiration = expiration
# tmpdir and its contents are automatically deleted after the CA cert
# and ephemeral cert are loaded into the SSLcontext. The values
# need to be written to files in order to be loaded by the SSLContext
with TemporaryDirectory() as tmpdir:
ca_filename, cert_filename, key_filename = write_to_file(
tmpdir, server_ca_cert, ephemeral_cert, private_key
)
self.context.load_cert_chain(cert_filename, keyfile=key_filename)
self.context.load_verify_locations(cafile=ca_filename)
def get_preferred_ip(self, ip_type: IPTypes) -> str:
"""Returns the first IP address for the instance, according to the preference
supplied by ip_type. If no IP addressess with the given preference are found,
an error is raised."""
if ip_type.value in self.ip_addrs:
return self.ip_addrs[ip_type.value]
raise CloudSQLIPTypeError(
"Cloud SQL instance does not have any IP addresses matching "
f"preference: {ip_type.value})"
)
class InstanceConnectionManager:
"""A class to manage the details of the connection, including refreshing the
credentials.
:param instance_connection_string:
The Google Cloud SQL Instance's connection
string.
:type instance_connection_string: str
:param user_agent_string:
The user agent string to append to SQLAdmin API requests
:type user_agent_string: str
:param enable_iam_auth
Enables IAM based authentication for Postgres instances.
:type enable_iam_auth: bool
:param loop:
A new event loop for the refresh function to run in.
:type loop: asyncio.AbstractEventLoop
"""
# asyncio.AbstractEventLoop is used because the default loop,
# SelectorEventLoop, is usable on both Unix and Windows but has limited
# functionality on Windows. It is recommended to use ProactorEventLoop
# while developing on Windows.
# Link to Github issue:
# https://github.com/GoogleCloudPlatform/cloud-sql-python-connector/issues/22
_loop: asyncio.AbstractEventLoop
_enable_iam_auth: bool
__client_session: Optional[aiohttp.ClientSession] = None
@property
def _client_session(self) -> aiohttp.ClientSession:
if self.__client_session is None:
self.__client_session = aiohttp.ClientSession(
headers={
"x-goog-api-client": self._user_agent_string,
"User-Agent": self._user_agent_string,
"Content-Type": "application/json",
}
)
return self.__client_session
_credentials: Optional[Credentials] = None
_keys: Awaitable
_instance_connection_string: str
_user_agent_string: str
_instance: str
_project: str
_region: str
_refresh_in_progress: asyncio.locks.Event
_current: asyncio.Task # task wraps coroutine that returns InstanceMetadata
_next: asyncio.Task # task wraps coroutine that returns another task
def __init__(
self,
instance_connection_string: str,
driver_name: str,
keys: concurrent.futures.Future,
loop: asyncio.AbstractEventLoop,
enable_iam_auth: bool = False,
) -> None:
# Validate connection string
connection_string_split = instance_connection_string.split(":")
if len(connection_string_split) == 3:
self._instance_connection_string = instance_connection_string
self._project = connection_string_split[0]
self._region = connection_string_split[1]
self._instance = connection_string_split[2]
else:
raise CloudSQLConnectionError(
"Arg instance_connection_string must be in "
+ "format: project:region:instance."
)
self._enable_iam_auth = enable_iam_auth
self._user_agent_string = f"{APPLICATION_NAME}/{version}+{driver_name}"
self._loop = loop
self._keys = asyncio.wrap_future(keys, loop=self._loop)
self._auth_init()
self._refresh_rate_limiter = AsyncRateLimiter(
max_capacity=2, rate=1 / 30, loop=self._loop
)
async def _set_instance_data() -> None:
logger.debug("Updating instance data")
self._refresh_in_progress = asyncio.locks.Event(loop=self._loop)
self._current = self._loop.create_task(self._get_instance_data())
self._next = self._loop.create_task(self._schedule_refresh())
init_future = asyncio.run_coroutine_threadsafe(_set_instance_data(), self._loop)
init_future.result()
def __del__(self) -> None:
"""Deconstructor to make sure ClientSession is closed and tasks have
finished to have a graceful exit.
"""
logger.debug("Entering deconstructor")
async def _deconstruct() -> None:
if isinstance(self._current, asyncio.Task):
logger.debug("Waiting for _current to be cancelled")
self._current.cancel()
if isinstance(self._next, asyncio.Task):
logger.debug("Waiting for _next to be cancelled")
self._next.cancel()
if not self._client_session.closed:
logger.debug("Waiting for _client_session to close")
await self._client_session.close()
deconstruct_future = asyncio.run_coroutine_threadsafe(
_deconstruct(), loop=self._loop
)
# Will attempt to safely shut down tasks for 5s
deconstruct_future.result(timeout=5)
logger.debug("Finished deconstructing")
async def _get_instance_data(self) -> InstanceMetadata:
"""Asynchronous function that takes in the futures for the ephemeral certificate
and the instance metadata and generates an OpenSSL context object.
:rtype: InstanceMetadata
:returns: A dataclass containing a string representing the ephemeral certificate, a dict
containing the instances IP adresses, a string representing a PEM-encoded private key
and a string representing a PEM-encoded certificate authority.
"""
priv_key, pub_key = await self._keys
logger.debug("Creating context")
metadata_task = self._loop.create_task(
_get_metadata(
self._client_session, self._credentials, self._project, self._instance
)
)
ephemeral_task = self._loop.create_task(
_get_ephemeral(
self._client_session,
self._credentials,
self._project,
self._instance,
pub_key,
self._enable_iam_auth,
)
)
metadata, ephemeral_cert = await asyncio.gather(metadata_task, ephemeral_task)
x509 = OpenSSL.crypto.load_certificate(
OpenSSL.crypto.FILETYPE_PEM, ephemeral_cert
)
expiration = datetime.datetime.strptime(
x509.get_notAfter().decode("ascii"), "%Y%m%d%H%M%SZ"
)
if self._enable_iam_auth:
if self._credentials is not None:
token_expiration: datetime.datetime = self._credentials.expiry
if expiration > token_expiration:
expiration = token_expiration
return InstanceMetadata(
ephemeral_cert,
metadata["ip_addresses"],
priv_key,
metadata["server_ca_cert"],
expiration,
self._enable_iam_auth,
)
def _auth_init(self) -> None:
"""Creates and assigns a Google Python API service object for
Google Cloud SQL Admin API.
"""
credentials, project = google.auth.default(
scopes=[
"https://www.googleapis.com/auth/sqlservice.admin",
"https://www.googleapis.com/auth/cloud-platform",
]
)
self._credentials = credentials
async def _force_refresh(self) -> bool:
if self._refresh_in_progress.is_set():
# if a new refresh is already in progress, then block on the result
self._current = await self._next
return True
try:
self._next.cancel()
# schedule a refresh immediately with no delay
self._next = self._loop.create_task(self._schedule_refresh(0))
self._current = await self._next
return True
except Exception as e:
# if anything else goes wrong, log the error and return false
logger.exception("Error occurred during force refresh attempt", exc_info=e)
return False
def force_refresh(self, timeout: Optional[int] = None) -> bool:
"""
Forces a new refresh attempt and returns a boolean value that indicates
whether the attempt was successful.
:type timeout: Optional[int]
:param timeout: Amount of time to wait for the attempted force refresh
to complete before throwing a timeout error.
"""
return asyncio.run_coroutine_threadsafe(
self._force_refresh(), self._loop
).result(timeout=timeout)
async def seconds_until_refresh(self) -> int:
expiration = (await self._current).expiration
if self._enable_iam_auth:
refresh_buffer = _iam_auth_refresh_buffer
else:
refresh_buffer = _default_refresh_buffer
delay = (expiration - datetime.datetime.now()) - datetime.timedelta(
seconds=refresh_buffer
)
if delay.total_seconds() < 0:
# If the time until the certificate expires is less than the buffer,
# schedule the refresh closer to the expiration time
delay = (expiration - datetime.datetime.now()) - datetime.timedelta(
seconds=5
)
return int(delay.total_seconds())
async def _perform_refresh(self) -> asyncio.Task:
"""Retrieves instance metadata and ephemeral certificate from the
Cloud SQL Instance.
:rtype: concurrent.future.Futures
:returns: A future representing the creation of an SSLcontext.
"""
self._refresh_in_progress.set()
await self._refresh_rate_limiter.acquire()
logger.debug("Entered _perform_refresh")
refresh_task = self._loop.create_task(self._get_instance_data())
try:
await refresh_task
except Exception as e:
logger.exception(
"An error occurred while performing refresh."
"Scheduling another refresh attempt immediately",
exc_info=e,
)
instance_data = None
try:
instance_data = await self._current
except Exception:
# Current result is invalid, no-op
logger.debug("Current instance data is invalid.")
if (
instance_data is None
or instance_data.expiration < datetime.datetime.now()
):
self._current = refresh_task
self._next = self._loop.create_task(self._perform_refresh())
else:
self._current = refresh_task
# Ephemeral certificate expires in 1 hour, so we schedule a refresh to happen in 55 minutes.
self._next = self._loop.create_task(self._schedule_refresh())
finally:
self._refresh_in_progress.clear()
return refresh_task
async def _schedule_refresh(self, delay: Optional[int] = None) -> asyncio.Task:
"""A coroutine that sleeps for the specified amount of time before
running _perform_refresh.
:rtype: asyncio.Task
:returns: A Task representing _get_instance_data.
"""
if delay is None:
delay = await self.seconds_until_refresh()
try:
logger.debug("Entering sleep")
await asyncio.sleep(delay)
except asyncio.CancelledError as e:
logger.debug("Schedule refresh task cancelled.")
raise e
return await self._perform_refresh()
def connect(
self,
driver: str,
ip_type: IPTypes,
timeout: int,
**kwargs: Any,
) -> Any:
"""A method that returns a DB-API connection to the database.
:type driver: str
:param driver: A string representing the driver. e.g. "pymysql"
:type timeout: int
:param timeout: The time limit for the connection before raising
a TimeoutError
:returns: A DB-API connection to the primary IP of the database.
"""
connect_future: concurrent.futures.Future = asyncio.run_coroutine_threadsafe(
self._connect(driver, ip_type, **kwargs), self._loop
)
try:
connection = connect_future.result(timeout)
except concurrent.futures.TimeoutError:
connect_future.cancel()
raise TimeoutError(f"Connection timed out after {timeout}s")
else:
return connection
async def _connect(
self,
driver: str,
ip_type: IPTypes,
**kwargs: Any,
) -> Any:
"""A method that returns a DB-API connection to the database.
:type driver: str
:param driver: A string representing the driver. e.g. "pymysql"
:returns: A DB-API connection to the primary IP of the database.
"""
logger.debug("Entered connect method")
# Host and ssl options come from the certificates and metadata, so we don't
# want the user to specify them.
kwargs.pop("host", None)
kwargs.pop("ssl", None)
kwargs.pop("port", None)
connect_func = {
"pymysql": self._connect_with_pymysql,
"pg8000": self._connect_with_pg8000,
"pytds": self._connect_with_pytds,
}
instance_data: InstanceMetadata
instance_data = await self._current
ip_address: str = instance_data.get_preferred_ip(ip_type)
try:
connector = connect_func[driver]
except KeyError:
raise KeyError("Driver {} is not supported.".format(driver))
connect_partial = partial(
connector, ip_address, instance_data.context, **kwargs
)
return await self._loop.run_in_executor(None, connect_partial)
def _connect_with_pymysql(
self, ip_address: str, ctx: ssl.SSLContext, **kwargs: Any
) -> "pymysql.connections.Connection":
"""Helper function to create a pymysql DB-API connection object.
:type ip_address: str
:param ip_address: A string containing an IP address for the Cloud SQL
instance.
:type ctx: ssl.SSLContext
:param ctx: An SSLContext object created from the Cloud SQL server CA
cert and ephemeral cert.
:rtype: pymysql.Connection
:returns: A PyMySQL Connection object for the Cloud SQL instance.
"""
try:
import pymysql
except ImportError:
raise ImportError(
'Unable to import module "pymysql." Please install and try again.'
)
# Create socket and wrap with context.
sock = ctx.wrap_socket(
socket.create_connection((ip_address, SERVER_PROXY_PORT)),
server_hostname=ip_address,
)
# Create pymysql connection object and hand in pre-made connection
conn = pymysql.Connection(host=ip_address, defer_connect=True, **kwargs)
conn.connect(sock)
return conn
def _connect_with_pg8000(
self, ip_address: str, ctx: ssl.SSLContext, **kwargs: Any
) -> "pg8000.dbapi.Connection":
"""Helper function to create a pg8000 DB-API connection object.
:type ip_address: str
:param ip_address: A string containing an IP address for the Cloud SQL
instance.
:type ctx: ssl.SSLContext
:param ctx: An SSLContext object created from the Cloud SQL server CA
cert and ephemeral cert.
:rtype: pg8000.dbapi.Connection
:returns: A pg8000 Connection object for the Cloud SQL instance.
"""
try:
import pg8000
except ImportError:
raise ImportError(
'Unable to import module "pg8000." Please install and try again.'
)
user = kwargs.pop("user")
db = kwargs.pop("db")
passwd = kwargs.pop("password", None)
setattr(ctx, "request_ssl", False)
return pg8000.dbapi.connect(
user,
database=db,
password=passwd,
host=ip_address,
port=SERVER_PROXY_PORT,
ssl_context=ctx,
**kwargs,
)
def _connect_with_pytds(
self, ip_address: str, ctx: ssl.SSLContext, **kwargs: Any
) -> "pytds.Connection":
"""Helper function to create a pg8000 DB-API connection object.
:type ip_address: str
:param ip_address: A string containing an IP address for the Cloud SQL
instance.
:type ctx: ssl.SSLContext
:param ctx: An SSLContext object created from the Cloud SQL server CA
cert and ephemeral cert.
:rtype: pytds.Connection
:returns: A pytds Connection object for the Cloud SQL instance.
"""
try:
import pytds
except ImportError:
raise ImportError(
'Unable to import module "pytds." Please install and try again.'
)
db = kwargs.pop("db", None)
# Create socket and wrap with context.
sock = ctx.wrap_socket(
socket.create_connection((ip_address, SERVER_PROXY_PORT)),
server_hostname=ip_address,
)
if kwargs.pop("active_directory_auth", False):
if platform.system() == "Windows":
# Ignore username and password if using active directory auth
server_name = kwargs.pop("server_name")
return pytds.connect(
database=db,
auth=pytds.login.SspiAuth(port=1433, server_name=server_name),
sock=sock,
**kwargs,
)
else:
raise PlatformNotSupportedError(
"Active Directory authentication is currently only supported on Windows."
)
user = kwargs.pop("user")
passwd = kwargs.pop("password")
return pytds.connect(
ip_address, database=db, user=user, password=passwd, sock=sock, **kwargs
)
| 34.407796 | 104 | 0.635512 |
8e34466781b839c43bac2ddfd3d3351f249e0102 | 2,469 | py | Python | sample_data_utils/money.py | movermeyer/sample-data-utils | 769f1b46e60def2675a14bd5872047af6d1ea398 | [
"BSD-3-Clause"
] | null | null | null | sample_data_utils/money.py | movermeyer/sample-data-utils | 769f1b46e60def2675a14bd5872047af6d1ea398 | [
"BSD-3-Clause"
] | null | null | null | sample_data_utils/money.py | movermeyer/sample-data-utils | 769f1b46e60def2675a14bd5872047af6d1ea398 | [
"BSD-3-Clause"
] | 1 | 2018-03-04T21:50:08.000Z | 2018-03-04T21:50:08.000Z | # -*- coding: utf-8 -*-
import decimal
from random import choice, uniform
import sys
def amount(min=1, max=sys.maxsize, decimal_places=2):
"""
return a random floating number
:param min: minimum value
:param max: maximum value
:param decimal_places: decimal places
:return:
"""
q = '.%s1' % '0' * (decimal_places - 1)
return decimal.Decimal(uniform(min, max)).quantize(decimal.Decimal(q))
def currency():
"""
returns a random ISO 4217 currency code
"""
codes = ['AFN', 'ALL', 'DZD', 'USD', 'EUR', 'AOA', 'XCD', 'XCD', 'XCD', 'ARS', 'AMD', 'AWG', 'AUD', 'EUR', 'AZN',
'BSD', 'BHD', 'BDT', 'BBD', 'BYR', 'EUR', 'BZD', 'XOF', 'BMD', 'BTN', 'BOB', 'BAM', 'BWP', 'NOK', 'BRL',
'USD', 'BND', 'BGN', 'XOF', 'BIF', 'KHR', 'XAF', 'CAD', 'CVE', 'KYD', 'XAF', 'XAF', 'CLP', 'CNY', 'AUD',
'AUD', 'COP', 'KMF', 'XAF', 'CDF', 'NZD', 'CRC', 'HRK', 'CUP', 'EUR', 'CZK', 'DKK', 'DJF', 'XCD', 'DOP',
'ECS', 'EGP', 'SVC', 'XAF', 'ERN', 'EUR', 'ETB', 'EUR', 'FKP', 'DKK', 'FJD', 'EUR', 'EUR', 'EUR', 'EUR',
'XAF', 'GMD', 'GEL', 'EUR', 'GHS', 'GIP', 'GBP', 'EUR', 'DKK', 'XCD', 'EUR', 'USD', 'QTQ', 'GGP', 'GNF',
'GWP', 'GYD', 'HTG', 'AUD', 'HNL', 'HKD', 'HUF', 'ISK', 'INR', 'IDR', 'IRR', 'IQD', 'EUR', 'GBP', 'ILS',
'EUR', 'XOF', 'JMD', 'JPY', 'GBP', 'JOD', 'KZT', 'KES', 'AUD', 'KPW', 'KRW', 'KWD', 'KGS', 'LAK', 'LVL',
'LBP', 'LSL', 'LRD', 'LYD', 'CHF', 'LTL', 'EUR', 'MOP', 'MKD', 'MGF', 'MWK', 'MYR', 'MVR', 'XOF', 'EUR',
'USD', 'EUR', 'MRO', 'MUR', 'EUR', 'MXN', 'USD', 'MDL', 'EUR', 'MNT', 'EUR', 'XCD', 'MAD', 'MZN', 'MMK',
'NAD', 'AUD', 'NPR', 'EUR', 'ANG', 'XPF', 'NZD', 'NIO', 'XOF', 'NGN', 'NZD', 'AUD', 'USD', 'NOK', 'OMR',
'PKR', 'USD', 'PAB', 'PGK', 'PYG', 'PEN', 'PHP', 'NZD', 'PLN', 'XPF', 'EUR', 'USD', 'QAR', 'EUR', 'RON',
'RUB', 'RWF', 'SHP', 'XCD', 'XCD', 'EUR', 'XCD', 'WST', 'EUR', 'STD', 'SAR', 'XOF', 'RSD', 'SCR', 'SLL',
'SGD', 'EUR', 'EUR', 'SBD', 'SOS', 'ZAR', 'GBP', 'SSP', 'EUR', 'LKR', 'SDG', 'SRD', 'NOK', 'SZL', 'SEK',
'CHF', 'SYP', 'TWD', 'TJS', 'TZS', 'THB', 'XOF', 'NZD', 'TOP', 'TTD', 'TND', 'TRY', 'TMT', 'USD', 'AUD',
'GBP', 'UGX', 'UAH', 'AED', 'UYU', 'USD', 'USD', 'UZS', 'VUV', 'EUR', 'VEF', 'VND', 'USD', 'USD', 'XPF',
'MAD', 'YER', 'ZMW', 'ZWD']
return choice(codes)
| 57.418605 | 117 | 0.437424 |
4ea755566f4de07b196ae22c0207920676c72f35 | 6,498 | py | Python | 130_html_to_csv/300_mkcsv_x_race_t.py | takobouzu/BOAT_RACE_DB | f16ed8f55aef567c0ecc6ebd3ad0e917f5c600d8 | [
"MIT"
] | 6 | 2020-12-23T01:06:04.000Z | 2022-01-12T10:18:36.000Z | 130_html_to_csv/300_mkcsv_x_race_t.py | takobouzu/BOAT_RACE_DB | f16ed8f55aef567c0ecc6ebd3ad0e917f5c600d8 | [
"MIT"
] | 15 | 2021-03-02T05:59:24.000Z | 2021-09-12T08:12:38.000Z | 130_html_to_csv/300_mkcsv_x_race_t.py | takobouzu/BOAT_RACE_DB | f16ed8f55aef567c0ecc6ebd3ad0e917f5c600d8 | [
"MIT"
] | 1 | 2021-05-09T10:47:21.000Z | 2021-05-09T10:47:21.000Z | '''
【システム】BOAT_RACE_DB2
【ファイル】200_mkcsv_x_race_t.py
【機能仕様】本日レース一覧HTMLファイルから出走表タイトルテーブル「x_race_t」のインポートCSVファイルを作成する
【動作環境】macOS 11.1/Raspbian OS 10.4/python 3.9.1/sqlite3 3.32.3
【来 歴】2021.02.01 ver 1.00
'''
import os
import datetime
from bs4 import BeautifulSoup
#インストールディレクトの定義
BASE_DIR = '/home/pi/BOAT_RACE_DB'
'''
【関 数】mkcsv_t_race_t
【機 能】本日レース一覧HTMLファイルから出走表タイトルテーブル「x_race_t」のインポートCSVファイルを作成
【引 数】なし
【戻り値】なし
'''
def mkcsv_x_race_t():
print('出走表タイトルテーブル「x_race_t」のインポートCSVファイル 開始')
grade_class_arry = ['is-ippan is-rookie__3rdadd', 'is-ippan is-venus', 'is-ippan', 'is-G1a is-lady', 'is-G1b is-lady', 'is-G2a is-lady', 'is-G2b is-lady', 'is-G3a is-lady', 'is-G3b is-lady','is-SGa ', 'is-SGb', 'is-G1a', 'is-G1b', 'is-G2a', 'is-G2b', 'is-G3a', 'is-G3b']
grade_name_arry = ['一般・若手', '一般・女子', '一般', 'Ｇ１・女子', 'Ｇ１・女子', 'Ｇ２・女子', 'Ｇ２・女子', 'Ｇ３・女子', 'Ｇ３・女子','ＳＧ', 'ＳＧ', 'Ｇ１', 'Ｇ１', 'Ｇ２', 'Ｇ２', 'Ｇ３', 'Ｇ３']
holding_class_arry = ['is-nighter', 'is-morning', 'is-summer']
holding_name_arry = ['ナイター', 'モーニング', 'サマータイム']
event_date_name_arry = ['初日','１日目','２日目','３日目','４日目','５日目','６日目','７日目','最終日']
in_path = BASE_DIR + '/200_html/today'
out_file = BASE_DIR + '/210_csv/x_race_t.csv'
fw = open(out_file, 'w')
for item in os.listdir(path=in_path):
if item != '.html' and item != '.DS_Store':
in_file = in_path + '/' + item
print("==> 処理中[%s]" % (in_file))
fb = open(in_file, 'r')
html = fb.read()
fb.close()
#データ存在チェック
flg = 0
if 'データがありません。' in html:
flg = 1
if flg == 0:
soup = BeautifulSoup(html, 'html.parser')
for tag1 in soup.find_all('tbody'):
#CSVレコードフィールドの初期化
t_race_t_yyyymmdd = '' #開催日付
t_race_t_pool_code = '' #場コード
t_race_t_pool_name = '' #場名
t_race_t_grade = '' #グレード
t_race_t_holding = '' #開催時間帯区分
t_race_t_title = '' #レースタイトル
t_race_t_event_date = '' #開催日
t_race_t_situation = '' #進行状況
#HTMLファイルからcsvレコード項目を抽出
#開催日付の抽出
t_race_t_yyyymmdd = item.replace('.html', '')
#場コードの抽出
for tag2 in str(tag1).splitlines():
if 'is-arrow1 is-fBold is-fs15' in str(tag2):
for tag3 in str(tag2).split('<'):
if '/static_extra/pc/images/text_place1' in str(tag3):
wk_arry = str(tag3).split(' ')
t_race_t_pool_code = str(wk_arry[3])
t_race_t_pool_code = t_race_t_pool_code.replace('src="/static_extra/pc/images/text_place1_', '')
t_race_t_pool_code = t_race_t_pool_code.replace('.png"', '')
#場名の抽出
for tag2 in str(tag1).splitlines():
if 'is-arrow1 is-fBold is-fs15' in str(tag2):
for tag3 in str(tag2).split('<'):
if '/static_extra/pc/images/text_place1' in str(tag3):
wk_arry = str(tag3).split(' ')
t_race_t_pool_name = str(wk_arry[1])
t_race_t_pool_name = t_race_t_pool_name.replace('alt="', '')
t_race_t_pool_name = t_race_t_pool_name.replace('>"', '')
#グレードの抽出
n = 0
t_race_t_grade = '不明'
for wk_grade_class in grade_class_arry:
if str(wk_grade_class) in str(tag1):
t_race_t_grade = grade_name_arry[n]
n = n + 1
#開催時間帯区分の抽出
n = 0
t_race_t_holding = '通常'
for wk_holding_class in holding_class_arry:
if str(wk_holding_class) in tag1:
t_race_t_holding = holding_name_arry[n]
n = n + 1
#レースタイトルの抽出
for tag2 in str(tag1).splitlines():
if '/owpc/pc/race/raceindex' in str(tag2):
wk_arry = str(tag2).split('<')
wk_arry = str(wk_arry[2]).split('>')
t_race_t_title = wk_arry[1]
#開催日の抽出
for wk_event_date_name in event_date_name_arry:
if str(wk_event_date_name) in str(tag1):
t_race_t_event_date = wk_event_date_name
#進行状況の抽出
t_race_t_situation = "-"
#print(tag1)
if '<td class="is-p10-10 is-attentionColor1" colspan="3">' in str(tag1):
for tag2 in str(tag1).splitlines():
if '<td class="is-p10-10 is-attentionColor1" colspan="3">' in str(tag2):
wk_arry = str(tag2).split('>')
wk_arry = str(wk_arry[1]).split('<')
t_race_t_situation = str(wk_arry[0])
#CSVレコードの生成
t_race_t_outrec = ''
t_race_t_outrec = t_race_t_outrec + '"' + t_race_t_yyyymmdd + '"' #開催日付
t_race_t_outrec = t_race_t_outrec + ',"' + t_race_t_pool_code + '"' #場コード
t_race_t_outrec = t_race_t_outrec + ',"' + t_race_t_pool_name + '"' #場名
t_race_t_outrec = t_race_t_outrec + ',"' + t_race_t_grade + '"' #グレード
t_race_t_outrec = t_race_t_outrec + ',"' + t_race_t_holding + '"' #開催時間帯区分
t_race_t_outrec = t_race_t_outrec + ',"' + t_race_t_title + '"' #レースタイトル
t_race_t_outrec = t_race_t_outrec + ',"' + t_race_t_event_date + '"' #開催日
t_race_t_outrec = t_race_t_outrec + ',"' + t_race_t_situation + '"' #進行状況
#CSVレコードファイル出力
fw.write(t_race_t_outrec + '\n')
fw.close()
print('出走表タイトルテーブル「x_race_t」のインポートCSVファイル 完了')
#主処理
mkcsv_x_race_t() #出走表タイトルテーブル「t_race_t」のインポートCSVファイルを作成
| 51.571429 | 274 | 0.48338 |
6d58700c2be3f57535016d7cf591721294c60fb1 | 6,988 | py | Python | clients/kratos/python/ory_kratos_client/model/plugin_config_user.py | simoneromano96/sdk | a6113d0daefbbb803790297e4b242d4c7cbbcb22 | [
"Apache-2.0"
] | null | null | null | clients/kratos/python/ory_kratos_client/model/plugin_config_user.py | simoneromano96/sdk | a6113d0daefbbb803790297e4b242d4c7cbbcb22 | [
"Apache-2.0"
] | null | null | null | clients/kratos/python/ory_kratos_client/model/plugin_config_user.py | simoneromano96/sdk | a6113d0daefbbb803790297e4b242d4c7cbbcb22 | [
"Apache-2.0"
] | null | null | null | """
Ory Kratos API
Documentation for all public and administrative Ory Kratos APIs. Public and administrative APIs are exposed on different ports. Public APIs can face the public internet without any protection while administrative APIs should never be exposed without prior authorization. To protect the administative API port you should use something like Nginx, Ory Oathkeeper, or any other technology capable of authorizing incoming requests. # noqa: E501
The version of the OpenAPI document: v0.6.3-alpha.1
Contact: hi@ory.sh
Generated by: https://openapi-generator.tech
"""
import re # noqa: F401
import sys # noqa: F401
from ory_kratos_client.model_utils import ( # noqa: F401
ApiTypeError,
ModelComposed,
ModelNormal,
ModelSimple,
cached_property,
change_keys_js_to_python,
convert_js_args_to_python_args,
date,
datetime,
file_type,
none_type,
validate_get_composed_info,
)
class PluginConfigUser(ModelNormal):
"""NOTE: This class is auto generated by OpenAPI Generator.
Ref: https://openapi-generator.tech
Do not edit the class manually.
Attributes:
allowed_values (dict): The key is the tuple path to the attribute
and the for var_name this is (var_name,). The value is a dict
with a capitalized key describing the allowed value and an allowed
value. These dicts store the allowed enum values.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
discriminator_value_class_map (dict): A dict to go from the discriminator
variable value to the discriminator class name.
validations (dict): The key is the tuple path to the attribute
and the for var_name this is (var_name,). The value is a dict
that stores validations for max_length, min_length, max_items,
min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum,
inclusive_minimum, and regex.
additional_properties_type (tuple): A tuple of classes accepted
as additional properties values.
"""
allowed_values = {
}
validations = {
}
additional_properties_type = None
_nullable = False
@cached_property
def openapi_types():
"""
This must be a method because a model may have properties that are
of type self, this must run after the class is loaded
Returns
openapi_types (dict): The key is attribute name
and the value is attribute type.
"""
return {
'gid': (int,), # noqa: E501
'uid': (int,), # noqa: E501
}
@cached_property
def discriminator():
return None
attribute_map = {
'gid': 'GID', # noqa: E501
'uid': 'UID', # noqa: E501
}
_composed_schemas = {}
required_properties = set([
'_data_store',
'_check_type',
'_spec_property_naming',
'_path_to_item',
'_configuration',
'_visited_composed_classes',
])
@convert_js_args_to_python_args
def __init__(self, *args, **kwargs): # noqa: E501
"""PluginConfigUser - a model defined in OpenAPI
Keyword Args:
_check_type (bool): if True, values for parameters in openapi_types
will be type checked and a TypeError will be
raised if the wrong type is input.
Defaults to True
_path_to_item (tuple/list): This is a list of keys or values to
drill down to the model in received_data
when deserializing a response
_spec_property_naming (bool): True if the variable names in the input data
are serialized names, as specified in the OpenAPI document.
False if the variable names in the input data
are pythonic names, e.g. snake case (default)
_configuration (Configuration): the instance to use when
deserializing a file_type parameter.
If passed, type conversion is attempted
If omitted no type conversion is done.
_visited_composed_classes (tuple): This stores a tuple of
classes that we have traveled through so that
if we see that class again we will not use its
discriminator again.
When traveling through a discriminator, the
composed schema that is
is traveled through is added to this set.
For example if Animal has a discriminator
petType and we pass in "Dog", and the class Dog
allOf includes Animal, we move through Animal
once using the discriminator, and pick Dog.
Then in Dog, we will make an instance of the
Animal class but this time we won't travel
through its discriminator because we passed in
_visited_composed_classes = (Animal,)
gid (int): g ID. [optional] # noqa: E501
uid (int): UID. [optional] # noqa: E501
"""
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
if args:
raise ApiTypeError(
"Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % (
args,
self.__class__.__name__,
),
path_to_item=_path_to_item,
valid_classes=(self.__class__,),
)
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = _visited_composed_classes + (self.__class__,)
for var_name, var_value in kwargs.items():
if var_name not in self.attribute_map and \
self._configuration is not None and \
self._configuration.discard_unknown_keys and \
self.additional_properties_type is None:
# discard variable.
continue
setattr(self, var_name, var_value)
| 40.865497 | 446 | 0.592444 |
2cf7b13ce2f872670f0b4985feb3781cbe24e421 | 762 | py | Python | tests/urls.py | bartonip/django-cached-fields | ffe1b15a4e12592dfabdc05611c64ab14cbf938d | [
"MIT"
] | null | null | null | tests/urls.py | bartonip/django-cached-fields | ffe1b15a4e12592dfabdc05611c64ab14cbf938d | [
"MIT"
] | null | null | null | tests/urls.py | bartonip/django-cached-fields | ffe1b15a4e12592dfabdc05611c64ab14cbf938d | [
"MIT"
] | null | null | null | """jests URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.11/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.conf.urls import url, include
2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.contrib import admin
urlpatterns = [
url(r'^admin/', admin.site.urls),
]
| 34.636364 | 79 | 0.703412 |
a98c4cd25aeb4340cb09b22a68e484669c39c57b | 2,321 | py | Python | gis_csdt/migrations/0003_auto_20180806_1629.py | kathleentully/gis_csdt | 0ce5295cff73a4b438dbadfd4ceb3d7e75ffd0a4 | [
"BSD-3-Clause"
] | 1 | 2019-09-18T04:03:55.000Z | 2019-09-18T04:03:55.000Z | gis_csdt/migrations/0003_auto_20180806_1629.py | kathleentully/gis_csdt | 0ce5295cff73a4b438dbadfd4ceb3d7e75ffd0a4 | [
"BSD-3-Clause"
] | 162 | 2018-02-02T21:22:38.000Z | 2022-03-23T20:51:26.000Z | gis_csdt/migrations/0003_auto_20180806_1629.py | kathleentully/gis_csdt | 0ce5295cff73a4b438dbadfd4ceb3d7e75ffd0a4 | [
"BSD-3-Clause"
] | 6 | 2016-07-25T14:17:50.000Z | 2017-08-14T05:05:44.000Z | # -*- coding: utf-8 -*-
# Generated by Django 1.11.13 on 2018-08-06 20:29
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('gis_csdt', '0002_phonenumber'),
]
operations = [
migrations.CreateModel(
name='DataPoint',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('value', models.DecimalField(decimal_places=15, max_digits=30)),
('point', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='points', to='gis_csdt.MapPoint')),
],
),
migrations.RemoveField(
model_name='sensor',
name='sensor_type',
),
migrations.AddField(
model_name='sensor',
name='accuracy',
field=models.CharField(default=b'accuracy', max_length=100),
),
migrations.AddField(
model_name='sensor',
name='metric',
field=models.CharField(default=b'metric', max_length=100),
),
migrations.AddField(
model_name='sensor',
name='model_number',
field=models.CharField(default=b'model_number', max_length=100),
),
migrations.AddField(
model_name='sensor',
name='supplier',
field=models.CharField(default=b'supplier', max_length=100),
),
migrations.AlterField(
model_name='sensor',
name='name',
field=models.CharField(default=b'name', max_length=100, unique=True),
),
migrations.AddField(
model_name='datapoint',
name='sensor',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='sensors', to='gis_csdt.Sensor'),
),
migrations.AddField(
model_name='datapoint',
name='user',
field=models.ForeignKey(default=None, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL),
),
]
| 35.166667 | 137 | 0.595433 |
0fa894e1b520a483e9832cbdcce2f3cd2c0b7812 | 1,802 | py | Python | data/p4VQE/R4/benchmark/startCirq412.py | UCLA-SEAL/QDiff | d968cbc47fe926b7f88b4adf10490f1edd6f8819 | [
"BSD-3-Clause"
] | null | null | null | data/p4VQE/R4/benchmark/startCirq412.py | UCLA-SEAL/QDiff | d968cbc47fe926b7f88b4adf10490f1edd6f8819 | [
"BSD-3-Clause"
] | null | null | null | data/p4VQE/R4/benchmark/startCirq412.py | UCLA-SEAL/QDiff | d968cbc47fe926b7f88b4adf10490f1edd6f8819 | [
"BSD-3-Clause"
] | null | null | null | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 5/15/20 4:49 PM
# @File : grover.py
# qubit number=4
# total number=12
import cirq
import cirq.google as cg
from typing import Optional
import sys
from math import log2
import numpy as np
#thatsNoCode
from cirq.contrib.svg import SVGCircuit
# Symbols for the rotation angles in the QAOA circuit.
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.H.on(input_qubit[2])) # number=3
c.append(cirq.CNOT.on(input_qubit[0],input_qubit[1])) # number=9
c.append(cirq.X.on(input_qubit[1])) # number=10
c.append(cirq.CNOT.on(input_qubit[0],input_qubit[1])) # number=11
c.append(cirq.H.on(input_qubit[3])) # number=4
c.append(cirq.Y.on(input_qubit[3])) # number=5
c.append(cirq.X.on(input_qubit[3])) # number=7
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def bitstring(bits):
return ''.join(str(int(b)) for b in bits)
if __name__ == '__main__':
qubit_count = 4
input_qubits = [cirq.GridQubit(i, 0) for i in range(qubit_count)]
circuit = make_circuit(qubit_count,input_qubits)
circuit = cg.optimized_for_sycamore(circuit, optimizer_type='sqrt_iswap')
circuit_sample_count =2000
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=circuit_sample_count)
frequencies = result.histogram(key='result', fold_func=bitstring)
writefile = open("../data/startCirq412.csv","w+")
print(format(frequencies),file=writefile)
print("results end", file=writefile)
print(circuit.__len__(), file=writefile)
print(circuit,file=writefile)
writefile.close() | 28.15625 | 77 | 0.691454 |
dd3863043f2e468da09b07287632819bc96c0a85 | 16,112 | py | Python | cogs/economy.py | tukib/snakebot | 5620a34d3faed1da7d5c5fe2698faa56923b0f44 | [
"MIT"
] | null | null | null | cogs/economy.py | tukib/snakebot | 5620a34d3faed1da7d5c5fe2698faa56923b0f44 | [
"MIT"
] | null | null | null | cogs/economy.py | tukib/snakebot | 5620a34d3faed1da7d5c5fe2698faa56923b0f44 | [
"MIT"
] | null | null | null | import discord
from discord.ext import commands
import orjson
import random
import cogs.utils.database as DB
class Card:
def __init__(self, suit, name, value):
self.suit = suit
self.name = name
self.value = value
class Deck:
def __init__(self):
suits = {
"Spades": "\u2664",
"Hearts": "\u2661",
"Clubs": "\u2667",
"Diamonds": "\u2662",
}
cards = {
"A": 11,
"2": 2,
"3": 3,
"4": 4,
"5": 5,
"6": 6,
"7": 7,
"8": 8,
"9": 9,
"10": 10,
"J": 10,
"Q": 10,
"K": 10,
}
self.card_deck = []
for suit in suits:
for card, value in cards.items():
self.card_deck.append(Card(suits[suit], card, value))
self.member_cards = [self.get_card(), self.get_card()]
self.dealer_cards = [self.get_card(), self.get_card()]
@staticmethod
def get_score(cards):
score = sum(card.value for card in cards)
if score > 21:
for card in cards:
if card.name == "A":
score -= 10
if score < 21:
return score
return score
def get_card(self):
return self.card_deck.pop(random.randrange(len(self.card_deck)))
def get_embed(self, bet, hidden=True):
embed = discord.Embed(color=discord.Color.blurple())
embed.title = f"Blackjack game (${bet})"
embed.description = """
**Your Hand: {}**
{}
**Dealers Hand: {}**
{}
""".format(
self.get_score(self.member_cards),
" ".join([f"`{c.name}{c.suit}`" for c in self.member_cards]),
self.get_score(self.dealer_cards) if not hidden else "",
" ".join([f"`{c.name}{c.suit}`" for c in self.dealer_cards])
if not hidden
else f"`{self.dealer_cards[0].name}{self.dealer_cards[0].suit}` `##`",
)
return embed
class economy(commands.Cog):
"""Commands related to the economy."""
def __init__(self, bot: commands.Bot) -> None:
self.bot = bot
@commands.command()
async def blackjack(self, ctx, bet: float):
"""Starts a game of blackjack.
bet: float
"""
embed = discord.Embed(color=discord.Color.blurple())
if bet < 0:
embed.title = "Bet must be positive"
return await ctx.send(embed=embed)
member = str(ctx.author.id).encode()
bal = await DB.get_bal(member)
if bal < bet:
embed.title = "You don't have enough cash"
return await ctx.send(embed=embed)
deck = Deck()
m_cards = deck.member_cards
d_cards = deck.dealer_cards
message = await ctx.send(embed=deck.get_embed(bet))
if deck.get_score(m_cards) == 21:
await message.edit(embed=deck.get_embed(bet, False))
await DB.put_bal(member, bal + bet)
return await message.add_reaction("✅")
if deck.get_score(d_cards) == 21:
await message.edit(embed=deck.get_embed(bet, False))
await DB.put_bal(member, bal - bet)
return await message.add_reaction("❎")
reactions = ["🇭", "🇸"]
def check(reaction: discord.Reaction, user: discord.User) -> bool:
return (
user.id == ctx.author.id
and reaction.message.channel == ctx.channel
and reaction.emoji in reactions
)
for reaction in reactions:
await message.add_reaction(reaction)
while deck.get_score(m_cards) < 21:
reaction, user = await ctx.bot.wait_for(
"reaction_add", timeout=60.0, check=check
)
if reaction.emoji == "🇭":
m_cards.append(deck.get_card())
else:
break
await reaction.remove(user)
await message.edit(embed=deck.get_embed(bet))
if (m_score := deck.get_score(m_cards)) > 21:
bal -= bet
await message.add_reaction("❎")
else:
while (score := deck.get_score(d_cards)) < 16 or score < m_score:
d_cards.append(deck.get_card())
if score > 21 or m_score > score:
bal += bet
await message.add_reaction("✅")
elif score == m_score:
await message.add_reaction("➖")
else:
bal -= bet
await message.add_reaction("❎")
await message.edit(embed=deck.get_embed(bet, False))
await DB.put_bal(member, bal)
@commands.command(aliases=["flip", "fcoin", "coinf"])
async def coinflip(self, ctx, choice, bet: float):
"""Flips a coin.
choice: str
bet: int
"""
embed = discord.Embed(color=discord.Color.red())
choice = choice[0].lower()
if choice not in ("h", "t"):
embed.title = "Must be [h]eads or [t]ails"
return await ctx.send(embed=embed)
if bet < 0:
embed.title = "Bet must be positive"
return await ctx.send(embed=embed)
member = str(ctx.author.id).encode()
bal = await DB.get_bal(member)
if bal <= 1:
bal += 1
if bal < bet:
embed.title = "You don't have enough cash"
return await ctx.send(embed=embed)
images = {
"heads": "https://i.imgur.com/168G0Cr.jpg",
"tails": "https://i.imgur.com/EdBBcsz.jpg",
}
result = random.choice(["heads", "tails"])
embed.set_author(name=result.capitalize(), icon_url=images[result])
if choice == result[0]:
embed.color = discord.Color.blurple()
embed.description = f"You won ${bet}"
bal += bet
else:
embed.description = f"You lost ${bet}"
bal -= bet
await DB.put_bal(member, bal)
embed.set_footer(text=f"Balance: ${bal:,}")
await ctx.send(embed=embed)
@commands.command(name="baltop")
async def top_balances(self, ctx, amount: int = 10):
"""Gets members with the highest balances.
amount: int
The amount of balances to get defaulting to 3.
"""
topbal = await DB.get_baltop(amount)
embed = discord.Embed(color=discord.Color.blurple())
embed.title = f"Top {len(topbal)} Balances"
embed.description = "\n".join(
[
f"**{self.bot.get_user(member).display_name}:** ${bal:,.2f}"
for bal, member in topbal
]
)
await ctx.send(embed=embed)
@commands.command()
async def lottery(self, ctx, bet: float):
"""Lottery with a 1/99 chance of winning 99 times the bet.
bet: float
The amount of money you are betting.
"""
embed = discord.Embed(color=discord.Color.blurple())
if bet <= 0:
embed.title = "Bet must be positive"
return await ctx.send(embed=embed)
member = str(ctx.author.id).encode()
bal = await DB.get_bal(member)
if bal < bet:
embed.title = "You don't have enough cash"
return await ctx.send(embed=embed)
if random.randint(1, 100) == 50:
bal += bet * 99
await DB.put_bal(member, bal)
embed.title = f"You won ${bet * 99}"
embed.set_footer(text=f"Balance: ${bal:,}")
return await ctx.send(embed=embed)
await DB.put_bal(member, bal - bet)
embed.title = f"You lost ${bet}"
embed.set_footer(text=f"Balance: ${bal - bet:,}")
embed.color = discord.Color.red()
await ctx.send(embed=embed)
async def streak_update(self, member, result):
data = DB.wins.get(member)
if not data:
data = {
"currentwin": 0,
"currentlose": 0,
"highestwin": 0,
"highestlose": 0,
"totallose": 0,
"totalwin": 0,
}
else:
data = orjson.loads(data.decode())
if result == "won":
data["highestlose"] = max(data["highestlose"], data["currentlose"])
data["totalwin"] += 1
data["currentwin"] += 1
data["currentlose"] = 0
else:
data["highestwin"] = max(data["highestwin"], data["currentwin"])
data["totallose"] += 1
data["currentlose"] += 1
data["currentwin"] = 0
DB.wins.put(member, orjson.dumps(data))
@commands.command(aliases=["slots"])
async def slot(self, ctx, bet):
"""Rolls the slot machine.
bet: str
The amount of money you are betting.
"""
embed = discord.Embed(color=discord.Color.red())
try:
bet = float(bet.replace(",", ""))
except ValueError:
embed.description = f"```Invalid bet. e.g {ctx.prefix}slot 1000```"
return await ctx.send(embed=embed)
if bet < 0:
embed.title = "Bet must be positive"
return await ctx.send(embed=embed)
member = str(ctx.author.id).encode()
bal = await DB.get_bal(member)
if bal <= 1:
bal += 1
if bal < bet:
embed.title = "You don't have enough cash"
return await ctx.send(embed=embed)
emojis = (
":apple:",
":tangerine:",
":pear:",
":lemon:",
":watermelon:",
":grapes:",
":strawberry:",
":cherries:",
":kiwi:",
":pineapple:",
":coconut:",
":peach:",
":mango:",
)
a, b, c, d = random.choices(emojis, k=4)
result = "won"
embed.color = discord.Color.blurple()
if a == b == c == d:
winnings = 100
elif (a == b == c) or (a == c == d) or (a == b == d) or (b == c == d):
winnings = 10
elif (a == b) and (d == c) or (b == c) and (d == a) or (d == b) and (a == c):
winnings = 10
elif (a == b) or (a == c) or (b == c) or (d == c) or (d == b) or (d == a):
winnings = 1
else:
winnings = -1
result = "lost"
embed.color = discord.Color.red()
bal += bet * winnings
await DB.put_bal(member, bal)
embed.title = f"[ {a} {b} {c} {d} ]"
embed.description = f"You {result} ${bet*(abs(winnings)):,.2f}"
embed.set_footer(text=f"Balance: ${bal:,}")
await ctx.send(embed=embed)
await self.streak_update(member, result)
@commands.command(aliases=["streaks"])
async def streak(self, ctx, user: discord.User = None):
"""Gets a users streaks on the slot machine.
user: discord.User
The user to get streaks of defaults to the command author."""
if user:
user = str(user.id).encode()
else:
user = str(ctx.author.id).encode()
wins = DB.wins.get(user)
if not wins:
return
wins = orjson.loads(wins.decode())
embed = discord.Embed(color=discord.Color.blurple())
embed.add_field(
name="**Wins/Loses**",
value=f"""
**Total Wins:** {wins["totalwin"]}
**Total Losses:** {wins["totallose"]}
**Current Wins:** {wins["currentwin"]}
**Current Loses:** {wins["currentlose"]}
**Highest Win Streak:** {wins["highestwin"]}
**Highest Loss Streak:** {wins["highestlose"]}
""",
)
await ctx.send(embed=embed)
@commands.command()
async def chances(self, ctx):
"""Sends simulated chances of the slot machine from 1000000000 runs."""
embed = discord.Embed(
title="Chances from 1000000000 runs", color=discord.Color.blurple()
)
embed.add_field(name="Quad:", value="455431, 0.04554%")
embed.add_field(name="Triple:", value="21855314, 2.18553%")
embed.add_field(name="Double double:", value="16378846, 1.63788%")
embed.add_field(name="Double:", value="360525049, 36.05250%")
embed.add_field(name="None:", value="600785361, 60.07854%")
embed.add_field(name="Percentage gain/loss:", value="18.7624388%")
embed.add_field(name="Highest win streak:", value=22)
embed.add_field(name="Highest lose streak:", value=38)
embed.add_field(name="Time taken:", value="2104.39373s")
await ctx.send(embed=embed)
@commands.command(aliases=["bal"])
async def balance(self, ctx, user: discord.User = None):
"""Gets a members balance.
user: discord.User
The user whos balance will be returned.
"""
user = user or ctx.author
user_id = str(user.id).encode()
bal = await DB.get_bal(user_id)
embed = discord.Embed(color=discord.Color.blurple())
embed.add_field(name=f"{user.display_name}'s balance", value=f"${bal:,}")
await ctx.send(embed=embed)
@commands.command(aliases=["give", "donate"])
async def pay(self, ctx, user: discord.User, amount: float):
"""Pays a user from your balance.
user: discord.User
The member you are paying.
amount: float
The amount you are paying.
"""
embed = discord.Embed(color=discord.Color.blurple())
if ctx.author == user:
embed.description = "```You can't pay yourself.```"
return await ctx.send(embed=embed)
_from = str(ctx.author.id).encode()
to = str(user.id).encode()
bal = await DB.transfer(_from, to, amount)
embed = discord.Embed(
title=f"Sent ${amount} to {user.display_name}",
color=discord.Color.blurple(),
)
embed.set_footer(text=f"New Balance: ${bal:,}")
await ctx.send(embed=embed)
@commands.command()
@commands.cooldown(1, 21600, commands.BucketType.user)
async def salary(self, ctx):
"""Gives you a salary of 1000 on a 6 hour cooldown."""
member = str(ctx.author.id).encode()
bal = await DB.add_bal(member, 1000)
embed = discord.Embed(
title=f"Paid {ctx.author.display_name} $1000", color=discord.Color.blurple()
)
embed.set_footer(text=f"Balance: ${bal:,}")
await ctx.send(embed=embed)
@commands.command(name="streaktop")
async def top_streaks(self, ctx):
"""Shows the top slot streaks."""
streak_top = []
for member, data in DB.wins:
user = self.bot.get_user(int(member))
if user is not None:
json = orjson.loads(data)
data = ((json["highestwin"], json["highestlose"]), user.display_name)
streak_top.append(data)
streak_top.sort(reverse=True)
embed = discord.Embed(color=discord.Color.blurple())
embed.description = "```Highest Streaks [win/lose]:\n\n{}```".format(
"\n".join([f"{member}: {hw[0]}/{hw[1]}" for hw, member in streak_top[:10]])
)
await ctx.send(embed=embed)
def setup(bot: commands.Bot) -> None:
"""Starts economy cog."""
bot.add_cog(economy(bot))
| 32.353414 | 89 | 0.506827 |
48c22cbe22834c95de402ed76eb8205fcf6b319b | 95,946 | py | Python | llvmlite/tests/test_ir.py | jhuapl-saralab/llvmlite | 00320f6fdf35bfb080717c2977edf2c38e6341fe | [
"BSD-2-Clause"
] | 4 | 2022-02-26T04:31:16.000Z | 2022-03-03T21:26:54.000Z | lo-fi-machine/processing/package/llvmlite/tests/test_ir.py | rochelletham/lo-tify | 910c62d0ec14bc5a7aaa4f7dca80c0ca14c4c060 | [
"MIT"
] | 1 | 2021-05-06T18:25:20.000Z | 2021-05-09T10:28:14.000Z | lo-fi-machine/processing/package/llvmlite/tests/test_ir.py | rochelletham/lo-tify | 910c62d0ec14bc5a7aaa4f7dca80c0ca14c4c060 | [
"MIT"
] | 1 | 2022-02-03T09:38:16.000Z | 2022-02-03T09:38:16.000Z | """
IR Construction Tests
"""
import copy
import itertools
import pickle
import re
import textwrap
import unittest
from . import TestCase
from llvmlite import ir
from llvmlite import binding as llvm
int1 = ir.IntType(1)
int8 = ir.IntType(8)
int16 = ir.IntType(16)
int32 = ir.IntType(32)
int64 = ir.IntType(64)
hlf = ir.HalfType()
flt = ir.FloatType()
dbl = ir.DoubleType()
class TestBase(TestCase):
"""
Utilities for IR tests.
"""
def assertInText(self, pattern, text):
"""
Assert *pattern* is in *text*, ignoring any whitespace differences
(including newlines).
"""
def escape(c):
if not c.isalnum() and not c.isspace():
return '\\' + c
return c
pattern = ''.join(map(escape, pattern))
regex = re.sub(r'\s+', r'\\s*', pattern)
self.assertRegex(text, regex)
def assert_ir_line(self, line, mod):
lines = [line.strip() for line in str(mod).splitlines()]
self.assertIn(line, lines)
def assert_valid_ir(self, mod):
llvm.parse_assembly(str(mod))
def assert_pickle_correctly(self, irobject):
"""Assert that the IR object pickles and unpickles correctly.
The IR string is equal and that their type is equal
"""
newobject = pickle.loads(pickle.dumps(irobject, protocol=-1))
self.assertIs(irobject.__class__, newobject.__class__)
self.assertEqual(str(irobject), str(newobject))
return newobject
def module(self):
return ir.Module()
def function(self, module=None, name='my_func'):
module = module or self.module()
fnty = ir.FunctionType(int32, (int32, int32, dbl,
ir.PointerType(int32)))
return ir.Function(module, fnty, name)
def block(self, func=None, name=''):
func = func or self.function()
return func.append_basic_block(name)
def descr(self, thing):
buf = []
thing.descr(buf)
return "".join(buf)
def _normalize_asm(self, asm):
asm = textwrap.dedent(asm)
# Normalize indent
asm = asm.replace("\n ", "\n ")
return asm
def check_descr(self, descr, asm):
expected = self._normalize_asm(asm)
self.assertEqual(descr, expected)
def check_block(self, block, asm):
self.check_descr(self.descr(block), asm)
def check_module_body(self, module, asm):
expected = self._normalize_asm(asm)
actual = module._stringify_body()
self.assertEqual(actual.strip(), expected.strip())
def check_metadata(self, module, asm):
"""
Check module metadata against *asm*.
"""
expected = self._normalize_asm(asm)
actual = module._stringify_metadata()
self.assertEqual(actual.strip(), expected.strip())
def check_func_body(self, func, asm):
expected = self._normalize_asm(asm)
actual = self.descr(func)
actual = actual.partition('{')[2].rpartition('}')[0]
self.assertEqual(actual.strip(), expected.strip())
class TestFunction(TestBase):
proto = """i32 @"my_func"(i32 %".1", i32 %".2", double %".3", i32* %".4")"""
def test_declare(self):
# A simple declaration
func = self.function()
asm = self.descr(func).strip()
self.assertEqual(asm.strip(), "declare %s" % self.proto)
def test_declare_attributes(self):
# Now with function attributes
func = self.function()
func.attributes.add("optsize")
func.attributes.add("alwaysinline")
func.attributes.alignstack = 16
tp_pers = ir.FunctionType(int8, (), var_arg=True)
pers = ir.Function(self.module(), tp_pers, '__gxx_personality_v0')
func.attributes.personality = pers
asm = self.descr(func).strip()
self.assertEqual(asm,
("declare %s alwaysinline optsize alignstack(16) "
"personality i8 (...)* @\"__gxx_personality_v0\"") %
self.proto)
# Check pickling
self.assert_pickle_correctly(func)
def test_function_attributes(self):
# Now with parameter attributes
func = self.function()
func.args[0].add_attribute("zeroext")
func.args[1].attributes.dereferenceable = 5
func.args[1].attributes.dereferenceable_or_null = 10
func.args[3].attributes.align = 4
func.args[3].add_attribute("nonnull")
func.return_value.add_attribute("noalias")
asm = self.descr(func).strip()
self.assertEqual(asm,
"""declare noalias i32 @"my_func"(i32 zeroext %".1", i32 dereferenceable(5) dereferenceable_or_null(10) %".2", double %".3", i32* nonnull align 4 %".4")""" # noqa E501
)
# Check pickling
self.assert_pickle_correctly(func)
def test_function_metadata(self):
# Now with function metadata
module = self.module()
func = self.function(module)
func.set_metadata('dbg', module.add_metadata([]))
asm = self.descr(func).strip()
self.assertEqual(asm,
"""declare i32 @"my_func"(i32 %".1", i32 %".2", double %".3", i32* %".4") !dbg !0""" # noqa E501
)
# Check pickling
self.assert_pickle_correctly(func)
def test_define(self):
# A simple definition
func = self.function()
func.attributes.add("alwaysinline")
block = func.append_basic_block('my_block')
builder = ir.IRBuilder(block)
builder.ret_void()
asm = self.descr(func)
self.check_descr(asm, """\
define {proto} alwaysinline
{{
my_block:
ret void
}}
""".format(proto=self.proto))
def test_declare_intrinsics(self):
module = self.module()
pint8 = int8.as_pointer()
powi = module.declare_intrinsic('llvm.powi', [dbl])
memset = module.declare_intrinsic('llvm.memset', [pint8, int32])
memcpy = module.declare_intrinsic('llvm.memcpy', [pint8, pint8, int32])
assume = module.declare_intrinsic('llvm.assume')
self.check_descr(self.descr(powi).strip(), """\
declare double @"llvm.powi.f64"(double %".1", i32 %".2")""")
self.check_descr(self.descr(memset).strip(), """\
declare void @"llvm.memset.p0i8.i32"(i8* %".1", i8 %".2", i32 %".3", i1 %".4")""") # noqa E501
self.check_descr(self.descr(memcpy).strip(), """\
declare void @"llvm.memcpy.p0i8.p0i8.i32"(i8* %".1", i8* %".2", i32 %".3", i1 %".4")""") # noqa E501
self.check_descr(self.descr(assume).strip(), """\
declare void @"llvm.assume"(i1 %".1")""")
def test_redeclare_intrinsic(self):
module = self.module()
powi = module.declare_intrinsic('llvm.powi', [dbl])
powi2 = module.declare_intrinsic('llvm.powi', [dbl])
self.assertIs(powi, powi2)
def test_pickling(self):
fn = self.function()
self.assert_pickle_correctly(fn)
def test_alwaysinline_noinline_disallowed(self):
module = self.module()
func = self.function(module)
func.attributes.add('alwaysinline')
msg = "Can't have alwaysinline and noinline"
with self.assertRaisesRegex(ValueError, msg):
func.attributes.add('noinline')
def test_noinline_alwaysinline_disallowed(self):
module = self.module()
func = self.function(module)
func.attributes.add('noinline')
msg = "Can't have alwaysinline and noinline"
with self.assertRaisesRegex(ValueError, msg):
func.attributes.add('alwaysinline')
class TestIR(TestBase):
def test_unnamed_metadata(self):
# An unnamed metadata node
mod = self.module()
mod.add_metadata([int32(123), int8(42)])
self.assert_ir_line("!0 = !{ i32 123, i8 42 }", mod)
self.assert_valid_ir(mod)
def test_unnamed_metadata_2(self):
# Several unnamed metadata nodes
mod = self.module()
# First node has a literal metadata string
m0 = mod.add_metadata([int32(123), "kernel"])
# Second node refers to the first one
m1 = mod.add_metadata([int64(456), m0])
# Third node is the same as the second one
m2 = mod.add_metadata([int64(456), m0])
self.assertIs(m2, m1)
# Fourth node refers to the first three
mod.add_metadata([m0, m1, m2])
self.assert_ir_line('!0 = !{ i32 123, !"kernel" }', mod)
self.assert_ir_line('!1 = !{ i64 456, !0 }', mod)
self.assert_ir_line('!2 = !{ !0, !1, !1 }', mod)
def test_unnamed_metadata_3(self):
# Passing nested metadata as a sequence
mod = self.module()
mod.add_metadata([int32(123), [int32(456)], [int32(789)], [int32(456)]])
self.assert_ir_line('!0 = !{ i32 456 }', mod)
self.assert_ir_line('!1 = !{ i32 789 }', mod)
self.assert_ir_line('!2 = !{ i32 123, !0, !1, !0 }', mod)
def test_metadata_string(self):
# Escaping contents of a metadata string
mod = self.module()
mod.add_metadata(["\"\\$"])
self.assert_ir_line('!0 = !{ !"\\22\\5c$" }', mod)
def test_named_metadata(self):
# Add a named metadata node and add metadata values to it
mod = self.module()
m0 = mod.add_metadata([int32(123)])
m1 = mod.add_metadata([int64(456)])
nmd = mod.add_named_metadata("foo")
nmd.add(m0)
nmd.add(m1)
nmd.add(m0)
self.assert_ir_line("!foo = !{ !0, !1, !0 }", mod)
self.assert_valid_ir(mod)
# Check get_named_metadata()
self.assertIs(nmd, mod.get_named_metadata("foo"))
with self.assertRaises(KeyError):
mod.get_named_metadata("bar")
def test_named_metadata_2(self):
# Add and set named metadata through a single add_named_metadata() call
mod = self.module()
m0 = mod.add_metadata([int32(123)])
mod.add_named_metadata("foo", m0)
mod.add_named_metadata("foo", [int64(456)])
mod.add_named_metadata("foo", ["kernel"])
mod.add_named_metadata("bar", [])
self.assert_ir_line("!foo = !{ !0, !1, !2 }", mod)
self.assert_ir_line("!0 = !{ i32 123 }", mod)
self.assert_ir_line("!1 = !{ i64 456 }", mod)
self.assert_ir_line('!2 = !{ !"kernel" }', mod)
self.assert_ir_line("!bar = !{ !3 }", mod)
self.assert_ir_line('!3 = !{ }', mod)
self.assert_valid_ir(mod)
def test_metadata_null(self):
# A null metadata (typed) value
mod = self.module()
mod.add_metadata([int32.as_pointer()(None)])
self.assert_ir_line("!0 = !{ i32* null }", mod)
self.assert_valid_ir(mod)
# A null metadata (untyped) value
mod = self.module()
mod.add_metadata([None, int32(123)])
self.assert_ir_line("!0 = !{ null, i32 123 }", mod)
self.assert_valid_ir(mod)
def test_debug_info(self):
# Add real world-looking debug information to a module
# (with various value types)
mod = self.module()
di_file = mod.add_debug_info("DIFile", {
"filename": "foo",
"directory": "bar",
})
di_func_type = mod.add_debug_info("DISubroutineType", {
# None as `null`
"types": mod.add_metadata([None]),
})
di_compileunit = mod.add_debug_info("DICompileUnit", {
"language": ir.DIToken("DW_LANG_Python"),
"file": di_file,
"producer": "ARTIQ",
"runtimeVersion": 0,
"isOptimized": True,
}, is_distinct=True)
mod.add_debug_info("DISubprogram", {
"name": "my_func",
"file": di_file,
"line": 11,
"type": di_func_type,
"isLocal": False,
"unit": di_compileunit,
}, is_distinct=True)
# Check output
strmod = str(mod)
self.assert_ir_line('!0 = !DIFile(directory: "bar", filename: "foo")',
strmod)
self.assert_ir_line('!1 = !{ null }', strmod)
self.assert_ir_line('!2 = !DISubroutineType(types: !1)', strmod)
# self.assert_ir_line('!4 = !{ !3 }', strmod)
self.assert_ir_line('!3 = distinct !DICompileUnit(file: !0, '
'isOptimized: true, language: DW_LANG_Python, '
'producer: "ARTIQ", runtimeVersion: 0)',
strmod)
self.assert_ir_line('!4 = distinct !DISubprogram(file: !0, isLocal: '
'false, line: 11, name: "my_func", type: !2, unit: '
'!3)',
strmod)
self.assert_valid_ir(mod)
def test_debug_info_2(self):
# Identical debug info nodes should be merged
mod = self.module()
di1 = mod.add_debug_info("DIFile",
{"filename": "foo",
"directory": "bar",
})
di2 = mod.add_debug_info("DIFile",
{"filename": "foo",
"directory": "bar",
})
di3 = mod.add_debug_info("DIFile",
{"filename": "bar",
"directory": "foo",
})
di4 = mod.add_debug_info("DIFile",
{"filename": "foo",
"directory": "bar",
}, is_distinct=True)
self.assertIs(di1, di2)
self.assertEqual(len({di1, di2, di3, di4}), 3)
# Check output
strmod = str(mod)
self.assert_ir_line('!0 = !DIFile(directory: "bar", filename: "foo")',
strmod)
self.assert_ir_line('!1 = !DIFile(directory: "foo", filename: "bar")',
strmod)
self.assert_ir_line('!2 = distinct !DIFile(directory: "bar", filename: '
'"foo")', strmod)
self.assert_valid_ir(mod)
def test_debug_info_unicode_string(self):
mod = self.module()
mod.add_debug_info("DILocalVariable", {"name": "a∆"})
# Check output
strmod = str(mod)
# The unicode character is utf8 encoded with \XX format, where XX is hex
name = ''.join(map(lambda x: f"\\{x:02x}", "∆".encode()))
self.assert_ir_line(f'!0 = !DILocalVariable(name: "a{name}")', strmod)
def test_inline_assembly(self):
mod = self.module()
foo = ir.Function(mod, ir.FunctionType(ir.VoidType(), []), 'foo')
builder = ir.IRBuilder(foo.append_basic_block(''))
asmty = ir.FunctionType(int32, [int32])
asm = ir.InlineAsm(asmty, "mov $1, $2", "=r,r", side_effect=True)
builder.call(asm, [int32(123)])
builder.ret_void()
pat = 'call i32 asm sideeffect "mov $1, $2", "=r,r" ( i32 123 )'
self.assertInText(pat, str(mod))
self.assert_valid_ir(mod)
def test_builder_asm(self):
mod = self.module()
foo = ir.Function(mod, ir.FunctionType(ir.VoidType(), []), 'foo')
builder = ir.IRBuilder(foo.append_basic_block(''))
asmty = ir.FunctionType(int32, [int32])
builder.asm(asmty, "mov $1, $2", "=r,r", [int32(123)], side_effect=True)
builder.ret_void()
pat = 'call i32 asm sideeffect "mov $1, $2", "=r,r" ( i32 123 )'
self.assertInText(pat, str(mod))
self.assert_valid_ir(mod)
def test_builder_load_reg(self):
mod = self.module()
foo = ir.Function(mod, ir.FunctionType(ir.VoidType(), []), 'foo')
builder = ir.IRBuilder(foo.append_basic_block(''))
builder.load_reg(ir.IntType(64), "rax")
builder.ret_void()
pat = 'call i64 asm "", "={rax}"'
self.assertInText(pat, str(mod))
self.assert_valid_ir(mod)
def test_builder_store_reg(self):
mod = self.module()
foo = ir.Function(mod, ir.FunctionType(ir.VoidType(), []), 'foo')
builder = ir.IRBuilder(foo.append_basic_block(''))
builder.store_reg(int64(123), ir.IntType(64), "rax")
builder.ret_void()
pat = 'call void asm sideeffect "", "{rax}" ( i64 123 )'
self.assertInText(pat, str(mod))
self.assert_valid_ir(mod)
class TestGlobalValues(TestBase):
def test_globals_access(self):
mod = self.module()
foo = ir.Function(mod, ir.FunctionType(ir.VoidType(), []), 'foo')
ir.Function(mod, ir.FunctionType(ir.VoidType(), []), 'bar')
globdouble = ir.GlobalVariable(mod, ir.DoubleType(), 'globdouble')
self.assertEqual(mod.get_global('foo'), foo)
self.assertEqual(mod.get_global('globdouble'), globdouble)
with self.assertRaises(KeyError):
mod.get_global('kkk')
# Globals should have a useful repr()
self.assertEqual(repr(globdouble),
"<ir.GlobalVariable 'globdouble' of type 'double*'>")
def test_functions_global_values_access(self):
"""
Accessing functions and global values through Module.functions
and Module.global_values.
"""
mod = self.module()
fty = ir.FunctionType(ir.VoidType(), [])
foo = ir.Function(mod, fty, 'foo')
bar = ir.Function(mod, fty, 'bar')
globdouble = ir.GlobalVariable(mod, ir.DoubleType(), 'globdouble')
self.assertEqual(set(mod.functions), set((foo, bar)))
self.assertEqual(set(mod.global_values), set((foo, bar, globdouble)))
def test_global_variables_ir(self):
"""
IR serialization of global variables.
"""
mod = self.module()
# the following have side effects and write to self.module()
a = ir.GlobalVariable(mod, int8, 'a') # noqa F841
b = ir.GlobalVariable(mod, int8, 'b', addrspace=42) # noqa F841
# Initialized global variable doesn't default to "external"
c = ir.GlobalVariable(mod, int32, 'c')
c.initializer = int32(123)
d = ir.GlobalVariable(mod, int32, 'd')
d.global_constant = True
# Non-external linkage implies default "undef" initializer
e = ir.GlobalVariable(mod, int32, 'e')
e.linkage = "internal"
f = ir.GlobalVariable(mod, int32, 'f', addrspace=456)
f.unnamed_addr = True
g = ir.GlobalVariable(mod, int32, 'g')
g.linkage = "internal"
g.initializer = int32(123)
g.align = 16
self.check_module_body(mod, """\
@"a" = external global i8
@"b" = external addrspace(42) global i8
@"c" = global i32 123
@"d" = external constant i32
@"e" = internal global i32 undef
@"f" = external unnamed_addr addrspace(456) global i32
@"g" = internal global i32 123, align 16
""")
def test_pickle(self):
mod = self.module()
self.assert_pickle_correctly(mod)
class TestBlock(TestBase):
def test_attributes(self):
func = self.function()
block = ir.Block(parent=func, name='start')
self.assertIs(block.parent, func)
self.assertFalse(block.is_terminated)
def test_descr(self):
block = self.block(name='my_block')
self.assertEqual(self.descr(block), "my_block:\n")
block.instructions.extend(['a', 'b'])
self.assertEqual(self.descr(block), "my_block:\n a\n b\n")
def test_replace(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
c = builder.add(a, b, 'c')
d = builder.sub(a, b, 'd')
builder.mul(d, b, 'e')
f = ir.Instruction(block, a.type, 'sdiv', (c, b), 'f')
self.check_block(block, """\
my_block:
%"c" = add i32 %".1", %".2"
%"d" = sub i32 %".1", %".2"
%"e" = mul i32 %"d", %".2"
""")
block.replace(d, f)
self.check_block(block, """\
my_block:
%"c" = add i32 %".1", %".2"
%"f" = sdiv i32 %"c", %".2"
%"e" = mul i32 %"f", %".2"
""")
def test_repr(self):
"""
Blocks should have a useful repr()
"""
func = self.function()
block = ir.Block(parent=func, name='start')
self.assertEqual(repr(block), "<ir.Block 'start' of type 'label'>")
class TestBuildInstructions(TestBase):
"""
Test IR generation of LLVM instructions through the IRBuilder class.
"""
maxDiff = 4000
def test_simple(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
inst = builder.add(a, b, 'res')
self.check_block(block, """\
my_block:
%"res" = add i32 %".1", %".2"
""")
# Instructions should have a useful repr()
self.assertEqual(repr(inst),
"<ir.Instruction 'res' of type 'i32', opname 'add', "
"operands (<ir.Argument '.1' of type i32>, "
"<ir.Argument '.2' of type i32>)>")
def test_binops(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b, ff = builder.function.args[:3]
builder.add(a, b, 'c')
builder.fadd(a, b, 'd')
builder.sub(a, b, 'e')
builder.fsub(a, b, 'f')
builder.mul(a, b, 'g')
builder.fmul(a, b, 'h')
builder.udiv(a, b, 'i')
builder.sdiv(a, b, 'j')
builder.fdiv(a, b, 'k')
builder.urem(a, b, 'l')
builder.srem(a, b, 'm')
builder.frem(a, b, 'n')
builder.or_(a, b, 'o')
builder.and_(a, b, 'p')
builder.xor(a, b, 'q')
builder.shl(a, b, 'r')
builder.ashr(a, b, 's')
builder.lshr(a, b, 't')
with self.assertRaises(ValueError) as cm:
builder.add(a, ff)
self.assertEqual(str(cm.exception),
"Operands must be the same type, got (i32, double)")
self.assertFalse(block.is_terminated)
self.check_block(block, """\
my_block:
%"c" = add i32 %".1", %".2"
%"d" = fadd i32 %".1", %".2"
%"e" = sub i32 %".1", %".2"
%"f" = fsub i32 %".1", %".2"
%"g" = mul i32 %".1", %".2"
%"h" = fmul i32 %".1", %".2"
%"i" = udiv i32 %".1", %".2"
%"j" = sdiv i32 %".1", %".2"
%"k" = fdiv i32 %".1", %".2"
%"l" = urem i32 %".1", %".2"
%"m" = srem i32 %".1", %".2"
%"n" = frem i32 %".1", %".2"
%"o" = or i32 %".1", %".2"
%"p" = and i32 %".1", %".2"
%"q" = xor i32 %".1", %".2"
%"r" = shl i32 %".1", %".2"
%"s" = ashr i32 %".1", %".2"
%"t" = lshr i32 %".1", %".2"
""")
def test_binop_flags(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
# As tuple
builder.add(a, b, 'c', flags=('nuw',))
# and as list
builder.sub(a, b, 'd', flags=['nuw', 'nsw'])
self.check_block(block, """\
my_block:
%"c" = add nuw i32 %".1", %".2"
%"d" = sub nuw nsw i32 %".1", %".2"
""")
def test_binop_fastmath_flags(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
# As tuple
builder.fadd(a, b, 'c', flags=('fast',))
# and as list
builder.fsub(a, b, 'd', flags=['ninf', 'nsz'])
self.check_block(block, """\
my_block:
%"c" = fadd fast i32 %".1", %".2"
%"d" = fsub ninf nsz i32 %".1", %".2"
""")
def test_binops_with_overflow(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
builder.sadd_with_overflow(a, b, 'c')
builder.smul_with_overflow(a, b, 'd')
builder.ssub_with_overflow(a, b, 'e')
builder.uadd_with_overflow(a, b, 'f')
builder.umul_with_overflow(a, b, 'g')
builder.usub_with_overflow(a, b, 'h')
self.check_block(block, """\
my_block:
%"c" = call {i32, i1} @"llvm.sadd.with.overflow.i32"(i32 %".1", i32 %".2")
%"d" = call {i32, i1} @"llvm.smul.with.overflow.i32"(i32 %".1", i32 %".2")
%"e" = call {i32, i1} @"llvm.ssub.with.overflow.i32"(i32 %".1", i32 %".2")
%"f" = call {i32, i1} @"llvm.uadd.with.overflow.i32"(i32 %".1", i32 %".2")
%"g" = call {i32, i1} @"llvm.umul.with.overflow.i32"(i32 %".1", i32 %".2")
%"h" = call {i32, i1} @"llvm.usub.with.overflow.i32"(i32 %".1", i32 %".2")
""")
def test_unary_ops(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b, c = builder.function.args[:3]
builder.neg(a, 'd')
builder.not_(b, 'e')
builder.fneg(c, 'f')
self.assertFalse(block.is_terminated)
self.check_block(block, """\
my_block:
%"d" = sub i32 0, %".1"
%"e" = xor i32 %".2", -1
%"f" = fneg double %".3"
""")
def test_replace_operand(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
undef1 = ir.Constant(ir.IntType(32), ir.Undefined)
undef2 = ir.Constant(ir.IntType(32), ir.Undefined)
c = builder.add(undef1, undef2, 'c')
self.check_block(block, """\
my_block:
%"c" = add i32 undef, undef
""")
c.replace_usage(undef1, a)
c.replace_usage(undef2, b)
self.check_block(block, """\
my_block:
%"c" = add i32 %".1", %".2"
""")
def test_integer_comparisons(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
builder.icmp_unsigned('==', a, b, 'c')
builder.icmp_unsigned('!=', a, b, 'd')
builder.icmp_unsigned('<', a, b, 'e')
builder.icmp_unsigned('<=', a, b, 'f')
builder.icmp_unsigned('>', a, b, 'g')
builder.icmp_unsigned('>=', a, b, 'h')
builder.icmp_signed('==', a, b, 'i')
builder.icmp_signed('!=', a, b, 'j')
builder.icmp_signed('<', a, b, 'k')
builder.icmp_signed('<=', a, b, 'l')
builder.icmp_signed('>', a, b, 'm')
builder.icmp_signed('>=', a, b, 'n')
with self.assertRaises(ValueError):
builder.icmp_signed('uno', a, b, 'zz')
with self.assertRaises(ValueError):
builder.icmp_signed('foo', a, b, 'zz')
self.assertFalse(block.is_terminated)
self.check_block(block, """\
my_block:
%"c" = icmp eq i32 %".1", %".2"
%"d" = icmp ne i32 %".1", %".2"
%"e" = icmp ult i32 %".1", %".2"
%"f" = icmp ule i32 %".1", %".2"
%"g" = icmp ugt i32 %".1", %".2"
%"h" = icmp uge i32 %".1", %".2"
%"i" = icmp eq i32 %".1", %".2"
%"j" = icmp ne i32 %".1", %".2"
%"k" = icmp slt i32 %".1", %".2"
%"l" = icmp sle i32 %".1", %".2"
%"m" = icmp sgt i32 %".1", %".2"
%"n" = icmp sge i32 %".1", %".2"
""")
def test_float_comparisons(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
builder.fcmp_ordered('==', a, b, 'c')
builder.fcmp_ordered('!=', a, b, 'd')
builder.fcmp_ordered('<', a, b, 'e')
builder.fcmp_ordered('<=', a, b, 'f')
builder.fcmp_ordered('>', a, b, 'g')
builder.fcmp_ordered('>=', a, b, 'h')
builder.fcmp_unordered('==', a, b, 'i')
builder.fcmp_unordered('!=', a, b, 'j')
builder.fcmp_unordered('<', a, b, 'k')
builder.fcmp_unordered('<=', a, b, 'l')
builder.fcmp_unordered('>', a, b, 'm')
builder.fcmp_unordered('>=', a, b, 'n')
# fcmp_ordered and fcmp_unordered are the same for these cases
builder.fcmp_ordered('ord', a, b, 'u')
builder.fcmp_ordered('uno', a, b, 'v')
builder.fcmp_unordered('ord', a, b, 'w')
builder.fcmp_unordered('uno', a, b, 'x')
builder.fcmp_unordered('olt', a, b, 'y',
flags=['nnan', 'ninf', 'nsz', 'arcp', 'fast'])
self.assertFalse(block.is_terminated)
self.check_block(block, """\
my_block:
%"c" = fcmp oeq i32 %".1", %".2"
%"d" = fcmp one i32 %".1", %".2"
%"e" = fcmp olt i32 %".1", %".2"
%"f" = fcmp ole i32 %".1", %".2"
%"g" = fcmp ogt i32 %".1", %".2"
%"h" = fcmp oge i32 %".1", %".2"
%"i" = fcmp ueq i32 %".1", %".2"
%"j" = fcmp une i32 %".1", %".2"
%"k" = fcmp ult i32 %".1", %".2"
%"l" = fcmp ule i32 %".1", %".2"
%"m" = fcmp ugt i32 %".1", %".2"
%"n" = fcmp uge i32 %".1", %".2"
%"u" = fcmp ord i32 %".1", %".2"
%"v" = fcmp uno i32 %".1", %".2"
%"w" = fcmp ord i32 %".1", %".2"
%"x" = fcmp uno i32 %".1", %".2"
%"y" = fcmp nnan ninf nsz arcp fast olt i32 %".1", %".2"
""")
def test_misc_ops(self):
block = self.block(name='my_block')
t = ir.Constant(int1, True)
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
builder.select(t, a, b, 'c')
self.assertFalse(block.is_terminated)
builder.unreachable()
self.assertTrue(block.is_terminated)
self.check_block(block, """\
my_block:
%"c" = select i1 true, i32 %".1", i32 %".2"
unreachable
""")
def test_phi(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
bb2 = builder.function.append_basic_block('b2')
bb3 = builder.function.append_basic_block('b3')
phi = builder.phi(int32, 'my_phi')
phi.add_incoming(a, bb2)
phi.add_incoming(b, bb3)
self.assertFalse(block.is_terminated)
self.check_block(block, """\
my_block:
%"my_phi" = phi i32 [%".1", %"b2"], [%".2", %"b3"]
""")
def test_mem_ops(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b, z = builder.function.args[:3]
c = builder.alloca(int32, name='c')
d = builder.alloca(int32, size=42, name='d') # noqa F841
e = builder.alloca(dbl, size=a, name='e')
e.align = 8
self.assertEqual(e.type, ir.PointerType(dbl))
ee = builder.store(z, e)
self.assertEqual(ee.type, ir.VoidType())
f = builder.store(b, c)
self.assertEqual(f.type, ir.VoidType())
g = builder.load(c, 'g')
self.assertEqual(g.type, int32)
# With alignment
h = builder.store(b, c, align=1)
self.assertEqual(h.type, ir.VoidType())
i = builder.load(c, 'i', align=1)
self.assertEqual(i.type, int32)
# Atomics
j = builder.store_atomic(b, c, ordering="seq_cst", align=4)
self.assertEqual(j.type, ir.VoidType())
k = builder.load_atomic(c, ordering="seq_cst", align=4, name='k')
self.assertEqual(k.type, int32)
# Not pointer types
with self.assertRaises(TypeError):
builder.store(b, a)
with self.assertRaises(TypeError):
builder.load(b)
# Mismatching pointer type
with self.assertRaises(TypeError) as cm:
builder.store(b, e)
self.assertEqual(str(cm.exception),
"cannot store i32 to double*: mismatching types")
self.check_block(block, """\
my_block:
%"c" = alloca i32
%"d" = alloca i32, i32 42
%"e" = alloca double, i32 %".1", align 8
store double %".3", double* %"e"
store i32 %".2", i32* %"c"
%"g" = load i32, i32* %"c"
store i32 %".2", i32* %"c", align 1
%"i" = load i32, i32* %"c", align 1
store atomic i32 %".2", i32* %"c" seq_cst, align 4
%"k" = load atomic i32, i32* %"c" seq_cst, align 4
""")
def test_gep(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
c = builder.alloca(ir.PointerType(int32), name='c')
d = builder.gep(c, [ir.Constant(int32, 5), a], name='d')
self.assertEqual(d.type, ir.PointerType(int32))
self.check_block(block, """\
my_block:
%"c" = alloca i32*
%"d" = getelementptr i32*, i32** %"c", i32 5, i32 %".1"
""")
# XXX test with more complex types
def test_gep_castinstr(self):
# similar to:
# numba::runtime::nrtdynmod.py_define_nrt_meminfo_data()
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
int8ptr = int8.as_pointer()
ls = ir.LiteralStructType([int64, int8ptr, int8ptr, int8ptr, int64])
d = builder.bitcast(a, ls.as_pointer(), name='d')
e = builder.gep(d, [ir.Constant(int32, x) for x in [0, 3]], name='e')
self.assertEqual(e.type, ir.PointerType(int8ptr))
self.check_block(block, """\
my_block:
%"d" = bitcast i32 %".1" to {i64, i8*, i8*, i8*, i64}*
%"e" = getelementptr {i64, i8*, i8*, i8*, i64}, {i64, i8*, i8*, i8*, i64}* %"d", i32 0, i32 3
""") # noqa E501
def test_gep_castinstr_addrspace(self):
# similar to:
# numba::runtime::nrtdynmod.py_define_nrt_meminfo_data()
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
addrspace = 4
int8ptr = int8.as_pointer()
ls = ir.LiteralStructType([int64, int8ptr, int8ptr, int8ptr, int64])
d = builder.bitcast(a, ls.as_pointer(addrspace=addrspace), name='d')
e = builder.gep(d, [ir.Constant(int32, x) for x in [0, 3]], name='e')
self.assertEqual(e.type.addrspace, addrspace)
self.assertEqual(e.type, ir.PointerType(int8ptr, addrspace=addrspace))
self.check_block(block, """\
my_block:
%"d" = bitcast i32 %".1" to {i64, i8*, i8*, i8*, i64} addrspace(4)*
%"e" = getelementptr {i64, i8*, i8*, i8*, i64}, {i64, i8*, i8*, i8*, i64} addrspace(4)* %"d", i32 0, i32 3
""") # noqa E501
def test_gep_addrspace(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
addrspace = 4
c = builder.alloca(ir.PointerType(int32, addrspace=addrspace), name='c')
self.assertEqual(str(c.type), 'i32 addrspace(4)**')
self.assertEqual(c.type.pointee.addrspace, addrspace)
d = builder.gep(c, [ir.Constant(int32, 5), a], name='d')
self.assertEqual(d.type.addrspace, addrspace)
e = builder.gep(d, [ir.Constant(int32, 10)], name='e')
self.assertEqual(e.type.addrspace, addrspace)
self.check_block(block, """\
my_block:
%"c" = alloca i32 addrspace(4)*
%"d" = getelementptr i32 addrspace(4)*, i32 addrspace(4)** %"c", i32 5, i32 %".1"
%"e" = getelementptr i32, i32 addrspace(4)* %"d", i32 10
""") # noqa E501
def test_extract_insert_value(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
tp_inner = ir.LiteralStructType([int32, int1])
tp_outer = ir.LiteralStructType([int8, tp_inner])
c_inner = ir.Constant(tp_inner, (ir.Constant(int32, 4),
ir.Constant(int1, True)))
# Flat structure
c = builder.extract_value(c_inner, 0, name='c') # noqa F841
d = builder.insert_value(c_inner, a, 0, name='d') # noqa F841
e = builder.insert_value(d, ir.Constant(int1, False), 1, name='e') # noqa F841 E501
self.assertEqual(d.type, tp_inner)
self.assertEqual(e.type, tp_inner)
# Nested structure
p_outer = builder.alloca(tp_outer, name='ptr')
j = builder.load(p_outer, name='j')
k = builder.extract_value(j, 0, name='k')
l = builder.extract_value(j, 1, name='l')
m = builder.extract_value(j, (1, 0), name='m')
n = builder.extract_value(j, (1, 1), name='n')
o = builder.insert_value(j, l, 1, name='o')
p = builder.insert_value(j, a, (1, 0), name='p')
self.assertEqual(k.type, int8)
self.assertEqual(l.type, tp_inner)
self.assertEqual(m.type, int32)
self.assertEqual(n.type, int1)
self.assertEqual(o.type, tp_outer)
self.assertEqual(p.type, tp_outer)
with self.assertRaises(TypeError):
# Not an aggregate
builder.extract_value(p_outer, 0)
with self.assertRaises(TypeError):
# Indexing too deep
builder.extract_value(c_inner, (0, 0))
with self.assertRaises(TypeError):
# Index out of structure bounds
builder.extract_value(c_inner, 5)
with self.assertRaises(TypeError):
# Not an aggregate
builder.insert_value(a, b, 0)
with self.assertRaises(TypeError):
# Replacement value has the wrong type
builder.insert_value(c_inner, a, 1)
self.check_block(block, """\
my_block:
%"c" = extractvalue {i32, i1} {i32 4, i1 true}, 0
%"d" = insertvalue {i32, i1} {i32 4, i1 true}, i32 %".1", 0
%"e" = insertvalue {i32, i1} %"d", i1 false, 1
%"ptr" = alloca {i8, {i32, i1}}
%"j" = load {i8, {i32, i1}}, {i8, {i32, i1}}* %"ptr"
%"k" = extractvalue {i8, {i32, i1}} %"j", 0
%"l" = extractvalue {i8, {i32, i1}} %"j", 1
%"m" = extractvalue {i8, {i32, i1}} %"j", 1, 0
%"n" = extractvalue {i8, {i32, i1}} %"j", 1, 1
%"o" = insertvalue {i8, {i32, i1}} %"j", {i32, i1} %"l", 1
%"p" = insertvalue {i8, {i32, i1}} %"j", i32 %".1", 1, 0
""")
def test_cast_ops(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b, fa, ptr = builder.function.args[:4]
c = builder.trunc(a, int8, name='c')
d = builder.zext(c, int32, name='d') # noqa F841
e = builder.sext(c, int32, name='e') # noqa F841
fb = builder.fptrunc(fa, flt, 'fb')
fc = builder.fpext(fb, dbl, 'fc') # noqa F841
g = builder.fptoui(fa, int32, 'g')
h = builder.fptosi(fa, int8, 'h')
fd = builder.uitofp(g, flt, 'fd') # noqa F841
fe = builder.sitofp(h, dbl, 'fe') # noqa F841
i = builder.ptrtoint(ptr, int32, 'i')
j = builder.inttoptr(i, ir.PointerType(int8), 'j') # noqa F841
k = builder.bitcast(a, flt, "k") # noqa F841
self.assertFalse(block.is_terminated)
self.check_block(block, """\
my_block:
%"c" = trunc i32 %".1" to i8
%"d" = zext i8 %"c" to i32
%"e" = sext i8 %"c" to i32
%"fb" = fptrunc double %".3" to float
%"fc" = fpext float %"fb" to double
%"g" = fptoui double %".3" to i32
%"h" = fptosi double %".3" to i8
%"fd" = uitofp i32 %"g" to float
%"fe" = sitofp i8 %"h" to double
%"i" = ptrtoint i32* %".4" to i32
%"j" = inttoptr i32 %"i" to i8*
%"k" = bitcast i32 %".1" to float
""")
def test_atomicrmw(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
c = builder.alloca(int32, name='c')
d = builder.atomic_rmw('add', c, a, 'monotonic', 'd')
self.assertEqual(d.type, int32)
self.check_block(block, """\
my_block:
%"c" = alloca i32
%"d" = atomicrmw add i32* %"c", i32 %".1" monotonic
""")
def test_branch(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
bb_target = builder.function.append_basic_block(name='target')
builder.branch(bb_target)
self.assertTrue(block.is_terminated)
self.check_block(block, """\
my_block:
br label %"target"
""")
def test_cbranch(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
bb_true = builder.function.append_basic_block(name='b_true')
bb_false = builder.function.append_basic_block(name='b_false')
builder.cbranch(ir.Constant(int1, False), bb_true, bb_false)
self.assertTrue(block.is_terminated)
self.check_block(block, """\
my_block:
br i1 false, label %"b_true", label %"b_false"
""")
def test_cbranch_weights(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
bb_true = builder.function.append_basic_block(name='b_true')
bb_false = builder.function.append_basic_block(name='b_false')
br = builder.cbranch(ir.Constant(int1, False), bb_true, bb_false)
br.set_weights([5, 42])
self.assertTrue(block.is_terminated)
self.check_block(block, """\
my_block:
br i1 false, label %"b_true", label %"b_false", !prof !0
""")
self.check_metadata(builder.module, """\
!0 = !{ !"branch_weights", i32 5, i32 42 }
""")
def test_branch_indirect(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
bb_1 = builder.function.append_basic_block(name='b_1')
bb_2 = builder.function.append_basic_block(name='b_2')
indirectbr = builder.branch_indirect(
ir.BlockAddress(builder.function, bb_1))
indirectbr.add_destination(bb_1)
indirectbr.add_destination(bb_2)
self.assertTrue(block.is_terminated)
self.check_block(block, """\
my_block:
indirectbr i8* blockaddress(@"my_func", %"b_1"), [label %"b_1", label %"b_2"]
""") # noqa E501
def test_returns(self):
def check(block, expected_ir):
self.assertTrue(block.is_terminated)
self.check_block(block, expected_ir)
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
builder.ret_void()
check(block, """\
my_block:
ret void
""")
block = self.block(name='other_block')
builder = ir.IRBuilder(block)
builder.ret(int32(5))
check(block, """\
other_block:
ret i32 5
""")
# With metadata
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
inst = builder.ret_void()
inst.set_metadata("dbg", block.module.add_metadata(()))
check(block, """\
my_block:
ret void, !dbg !0
""")
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
inst = builder.ret(int32(6))
inst.set_metadata("dbg", block.module.add_metadata(()))
check(block, """\
my_block:
ret i32 6, !dbg !0
""")
def test_switch(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
bb_onzero = builder.function.append_basic_block(name='onzero')
bb_onone = builder.function.append_basic_block(name='onone')
bb_ontwo = builder.function.append_basic_block(name='ontwo')
bb_else = builder.function.append_basic_block(name='otherwise')
sw = builder.switch(a, bb_else)
sw.add_case(ir.Constant(int32, 0), bb_onzero)
sw.add_case(ir.Constant(int32, 1), bb_onone)
# A plain Python value gets converted into the right IR constant
sw.add_case(2, bb_ontwo)
self.assertTrue(block.is_terminated)
self.check_block(block, """\
my_block:
switch i32 %".1", label %"otherwise" [i32 0, label %"onzero" i32 1, label %"onone" i32 2, label %"ontwo"]
""") # noqa E501
def test_call(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
tp_f = ir.FunctionType(flt, (int32, int32))
tp_g = ir.FunctionType(dbl, (int32,), var_arg=True)
tp_h = ir.FunctionType(hlf, (int32, int32))
f = ir.Function(builder.function.module, tp_f, 'f')
g = ir.Function(builder.function.module, tp_g, 'g')
h = ir.Function(builder.function.module, tp_h, 'h')
builder.call(f, (a, b), 'res_f')
builder.call(g, (b, a), 'res_g')
builder.call(h, (a, b), 'res_h')
builder.call(f, (a, b), 'res_f_fast', cconv='fastcc')
res_f_readonly = builder.call(f, (a, b), 'res_f_readonly')
res_f_readonly.attributes.add('readonly')
builder.call(f, (a, b), 'res_fast', fastmath='fast')
builder.call(f, (a, b), 'res_nnan_ninf', fastmath=('nnan', 'ninf'))
builder.call(f, (a, b), 'res_noinline', attrs='noinline')
builder.call(f, (a, b), 'res_alwaysinline', attrs='alwaysinline')
builder.call(f, (a, b), 'res_noinline_ro', attrs=('noinline',
'readonly'))
self.check_block(block, """\
my_block:
%"res_f" = call float @"f"(i32 %".1", i32 %".2")
%"res_g" = call double (i32, ...) @"g"(i32 %".2", i32 %".1")
%"res_h" = call half @"h"(i32 %".1", i32 %".2")
%"res_f_fast" = call fastcc float @"f"(i32 %".1", i32 %".2")
%"res_f_readonly" = call float @"f"(i32 %".1", i32 %".2") readonly
%"res_fast" = call fast float @"f"(i32 %".1", i32 %".2")
%"res_nnan_ninf" = call ninf nnan float @"f"(i32 %".1", i32 %".2")
%"res_noinline" = call float @"f"(i32 %".1", i32 %".2") noinline
%"res_alwaysinline" = call float @"f"(i32 %".1", i32 %".2") alwaysinline
%"res_noinline_ro" = call float @"f"(i32 %".1", i32 %".2") noinline readonly
""") # noqa E501
def test_call_metadata(self):
"""
Function calls with metadata arguments.
"""
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
dbg_declare_ty = ir.FunctionType(ir.VoidType(), [ir.MetaDataType()] * 3)
dbg_declare = ir.Function(
builder.module,
dbg_declare_ty,
'llvm.dbg.declare')
a = builder.alloca(int32, name="a")
b = builder.module.add_metadata(())
builder.call(dbg_declare, (a, b, b))
self.check_block(block, """\
my_block:
%"a" = alloca i32
call void @"llvm.dbg.declare"(metadata i32* %"a", metadata !0, metadata !0)
""") # noqa E501
def test_call_attributes(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
fun_ty = ir.FunctionType(
ir.VoidType(), (int32.as_pointer(), int32, int32.as_pointer()))
fun = ir.Function(builder.function.module, fun_ty, 'fun')
fun.args[0].add_attribute('sret')
retval = builder.alloca(int32, name='retval')
other = builder.alloca(int32, name='other')
builder.call(
fun,
(retval, ir.Constant(int32, 42), other),
arg_attrs={
0: ('sret', 'noalias'),
2: 'noalias'
}
)
self.check_block(block, """\
my_block:
%"retval" = alloca i32
%"other" = alloca i32
call void @"fun"(i32* noalias sret %"retval", i32 42, i32* noalias %"other")
""") # noqa E501
def test_invalid_call_attributes(self):
block = self.block()
builder = ir.IRBuilder(block)
fun_ty = ir.FunctionType(ir.VoidType(), ())
fun = ir.Function(builder.function.module, fun_ty, 'fun')
with self.assertRaises(ValueError):
# The function has no arguments, so this should fail.
builder.call(fun, (), arg_attrs={0: 'sret'})
def test_invoke(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
tp_f = ir.FunctionType(flt, (int32, int32))
f = ir.Function(builder.function.module, tp_f, 'f')
bb_normal = builder.function.append_basic_block(name='normal')
bb_unwind = builder.function.append_basic_block(name='unwind')
builder.invoke(f, (a, b), bb_normal, bb_unwind, 'res_f')
self.check_block(block, """\
my_block:
%"res_f" = invoke float @"f"(i32 %".1", i32 %".2")
to label %"normal" unwind label %"unwind"
""")
def test_invoke_attributes(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
fun_ty = ir.FunctionType(
ir.VoidType(), (int32.as_pointer(), int32, int32.as_pointer()))
fun = ir.Function(builder.function.module, fun_ty, 'fun')
fun.calling_convention = "fastcc"
fun.args[0].add_attribute('sret')
retval = builder.alloca(int32, name='retval')
other = builder.alloca(int32, name='other')
bb_normal = builder.function.append_basic_block(name='normal')
bb_unwind = builder.function.append_basic_block(name='unwind')
builder.invoke(
fun,
(retval, ir.Constant(int32, 42), other),
bb_normal,
bb_unwind,
cconv='fastcc',
fastmath='fast',
attrs='noinline',
arg_attrs={
0: ('sret', 'noalias'),
2: 'noalias'
}
)
self.check_block(block, """\
my_block:
%"retval" = alloca i32
%"other" = alloca i32
invoke fast fastcc void @"fun"(i32* noalias sret %"retval", i32 42, i32* noalias %"other") noinline
to label %"normal" unwind label %"unwind"
""") # noqa E501
def test_landingpad(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
lp = builder.landingpad(ir.LiteralStructType([int32,
int8.as_pointer()]), 'lp')
int_typeinfo = ir.GlobalVariable(builder.function.module,
int8.as_pointer(), "_ZTIi")
int_typeinfo.global_constant = True
lp.add_clause(ir.CatchClause(int_typeinfo))
lp.add_clause(ir.FilterClause(ir.Constant(ir.ArrayType(
int_typeinfo.type, 1), [int_typeinfo])))
builder.resume(lp)
self.check_block(block, """\
my_block:
%"lp" = landingpad {i32, i8*}
catch i8** @"_ZTIi"
filter [1 x i8**] [i8** @"_ZTIi"]
resume {i32, i8*} %"lp"
""")
def test_assume(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
c = builder.icmp_signed('>', a, b, name='c')
builder.assume(c)
self.check_block(block, """\
my_block:
%"c" = icmp sgt i32 %".1", %".2"
call void @"llvm.assume"(i1 %"c")
""")
def test_vector_ops(self):
block = self.block(name='insert_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
a.name = 'a'
b.name = 'b'
vecty = ir.VectorType(a.type, 2)
vec = ir.Constant(vecty, ir.Undefined)
idxty = ir.IntType(32)
vec = builder.insert_element(vec, a, idxty(0), name='vec1')
vec = builder.insert_element(vec, b, idxty(1), name='vec2')
self.check_block(block, """\
insert_block:
%"vec1" = insertelement <2 x i32> <i32 undef, i32 undef>, i32 %"a", i32 0
%"vec2" = insertelement <2 x i32> %"vec1", i32 %"b", i32 1
""")
block = builder.append_basic_block("shuffle_block")
builder.branch(block)
builder.position_at_end(block)
mask = ir.Constant(vecty, [1, 0])
builder.shuffle_vector(vec, vec, mask, name='shuf')
self.check_block(block, """\
shuffle_block:
%"shuf" = shufflevector <2 x i32> %"vec2", <2 x i32> %"vec2", <2 x i32> <i32 1, i32 0>
""") # noqa E501
block = builder.append_basic_block("add_block")
builder.branch(block)
builder.position_at_end(block)
builder.add(vec, vec, name='sum')
self.check_block(block, """\
add_block:
%"sum" = add <2 x i32> %"vec2", %"vec2"
""")
block = builder.append_basic_block("extract_block")
builder.branch(block)
builder.position_at_end(block)
c = builder.extract_element(vec, idxty(0), name='ex1')
d = builder.extract_element(vec, idxty(1), name='ex2')
self.check_block(block, """\
extract_block:
%"ex1" = extractelement <2 x i32> %"vec2", i32 0
%"ex2" = extractelement <2 x i32> %"vec2", i32 1
""")
builder.ret(builder.add(c, d))
self.assert_valid_ir(builder.module)
def test_bitreverse(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(int64, 5)
c = builder.bitreverse(a, name='c')
builder.ret(c)
self.check_block(block, """\
my_block:
%"c" = call i64 @"llvm.bitreverse.i64"(i64 5)
ret i64 %"c"
""")
def test_bitreverse_wrongtype(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(flt, 5)
with self.assertRaises(TypeError) as raises:
builder.bitreverse(a, name='c')
self.assertIn(
"expected an integer type, got float",
str(raises.exception))
def test_fence(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
with self.assertRaises(ValueError) as raises:
builder.fence("monotonic", None)
self.assertIn(
"Invalid fence ordering \"monotonic\"!",
str(raises.exception))
with self.assertRaises(ValueError) as raises:
builder.fence(None, "monotonic")
self.assertIn(
"Invalid fence ordering \"None\"!",
str(raises.exception))
builder.fence("acquire", None)
builder.fence("release", "singlethread")
builder.fence("acq_rel", "singlethread")
builder.fence("seq_cst")
builder.ret_void()
self.check_block(block, """\
my_block:
fence acquire
fence syncscope("singlethread") release
fence syncscope("singlethread") acq_rel
fence seq_cst
ret void
""")
def test_bswap(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(int32, 5)
c = builder.bswap(a, name='c')
builder.ret(c)
self.check_block(block, """\
my_block:
%"c" = call i32 @"llvm.bswap.i32"(i32 5)
ret i32 %"c"
""")
def test_ctpop(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(int16, 5)
c = builder.ctpop(a, name='c')
builder.ret(c)
self.check_block(block, """\
my_block:
%"c" = call i16 @"llvm.ctpop.i16"(i16 5)
ret i16 %"c"
""")
def test_ctlz(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(int16, 5)
b = ir.Constant(int1, 1)
c = builder.ctlz(a, b, name='c')
builder.ret(c)
self.check_block(block, """\
my_block:
%"c" = call i16 @"llvm.ctlz.i16"(i16 5, i1 1)
ret i16 %"c"
""")
def test_convert_to_fp16_f32(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(flt, 5.0)
b = builder.convert_to_fp16(a, name='b')
builder.ret(b)
self.check_block(block, """\
my_block:
%"b" = call i16 @"llvm.convert.to.fp16.f32"(float 0x4014000000000000)
ret i16 %"b"
""") # noqa E501
def test_convert_to_fp16_f32_wrongtype(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(int16, 5)
with self.assertRaises(TypeError) as raises:
builder.convert_to_fp16(a, name='b')
self.assertIn(
"expected a float type, got i16",
str(raises.exception))
def test_convert_from_fp16_f32(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(int16, 5)
b = builder.convert_from_fp16(a, name='b', to=flt)
builder.ret(b)
self.check_block(block, """\
my_block:
%"b" = call float @"llvm.convert.from.fp16.f32"(i16 5)
ret float %"b"
""")
def test_convert_from_fp16_f32_notype(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(flt, 5.5)
with self.assertRaises(TypeError) as raises:
builder.convert_from_fp16(a, name='b')
self.assertIn(
"expected a float return type",
str(raises.exception))
def test_convert_from_fp16_f32_wrongtype(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(flt, 5.5)
with self.assertRaises(TypeError) as raises:
builder.convert_from_fp16(a, name='b', to=flt)
self.assertIn(
"expected an i16 type, got float",
str(raises.exception))
def test_convert_from_fp16_f32_wrongtype2(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(flt, 5.5)
with self.assertRaises(TypeError) as raises:
builder.convert_from_fp16(a, name='b', to=int16)
self.assertIn(
"expected a float type, got i16",
str(raises.exception))
def test_cttz(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(int64, 5)
b = ir.Constant(int1, 1)
c = builder.cttz(a, b, name='c')
builder.ret(c)
self.check_block(block, """\
my_block:
%"c" = call i64 @"llvm.cttz.i64"(i64 5, i1 1)
ret i64 %"c"
""")
def test_cttz_wrongflag(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(int64, 5)
b = ir.Constant(int32, 3)
with self.assertRaises(TypeError) as raises:
builder.cttz(a, b, name='c')
self.assertIn(
"expected an i1 type, got i32",
str(raises.exception))
def test_cttz_wrongtype(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(flt, 5)
b = ir.Constant(int1, 1)
with self.assertRaises(TypeError) as raises:
builder.cttz(a, b, name='c')
self.assertIn(
"expected an integer type, got float",
str(raises.exception))
def test_fma(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(flt, 5)
b = ir.Constant(flt, 1)
c = ir.Constant(flt, 2)
fma = builder.fma(a, b, c, name='fma')
builder.ret(fma)
self.check_block(block, """\
my_block:
%"fma" = call float @"llvm.fma.f32"(float 0x4014000000000000, float 0x3ff0000000000000, float 0x4000000000000000)
ret float %"fma"
""") # noqa E501
def test_fma_wrongtype(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(int32, 5)
b = ir.Constant(int32, 1)
c = ir.Constant(int32, 2)
with self.assertRaises(TypeError) as raises:
builder.fma(a, b, c, name='fma')
self.assertIn(
"expected an floating point type, got i32",
str(raises.exception))
def test_fma_mixedtypes(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a = ir.Constant(flt, 5)
b = ir.Constant(dbl, 1)
c = ir.Constant(flt, 2)
with self.assertRaises(TypeError) as raises:
builder.fma(a, b, c, name='fma')
self.assertIn(
"expected types to be the same, got float, double, float",
str(raises.exception))
class TestBuilderMisc(TestBase):
"""
Test various other features of the IRBuilder class.
"""
def test_attributes(self):
block = self.block(name='start')
builder = ir.IRBuilder(block)
self.assertIs(builder.function, block.parent)
self.assertIsInstance(builder.function, ir.Function)
self.assertIs(builder.module, block.parent.module)
self.assertIsInstance(builder.module, ir.Module)
def test_goto_block(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
a, b = builder.function.args[:2]
builder.add(a, b, 'c')
bb_new = builder.append_basic_block(name='foo')
with builder.goto_block(bb_new):
builder.fadd(a, b, 'd')
with builder.goto_entry_block():
builder.sub(a, b, 'e')
builder.fsub(a, b, 'f')
builder.branch(bb_new)
builder.mul(a, b, 'g')
with builder.goto_block(bb_new):
builder.fmul(a, b, 'h')
self.check_block(block, """\
my_block:
%"c" = add i32 %".1", %".2"
%"e" = sub i32 %".1", %".2"
%"g" = mul i32 %".1", %".2"
""")
self.check_block(bb_new, """\
foo:
%"d" = fadd i32 %".1", %".2"
%"f" = fsub i32 %".1", %".2"
%"h" = fmul i32 %".1", %".2"
br label %"foo"
""")
def test_if_then(self):
block = self.block(name='one')
builder = ir.IRBuilder(block)
z = ir.Constant(int1, 0)
a = builder.add(z, z, 'a')
with builder.if_then(a) as bbend:
builder.add(z, z, 'b')
# Block will be terminated implicitly
self.assertIs(builder.block, bbend)
c = builder.add(z, z, 'c')
with builder.if_then(c):
builder.add(z, z, 'd')
builder.branch(block)
# No implicit termination
self.check_func_body(builder.function, """\
one:
%"a" = add i1 0, 0
br i1 %"a", label %"one.if", label %"one.endif"
one.if:
%"b" = add i1 0, 0
br label %"one.endif"
one.endif:
%"c" = add i1 0, 0
br i1 %"c", label %"one.endif.if", label %"one.endif.endif"
one.endif.if:
%"d" = add i1 0, 0
br label %"one"
one.endif.endif:
""")
def test_if_then_nested(self):
# Implicit termination in a nested if/then
block = self.block(name='one')
builder = ir.IRBuilder(block)
z = ir.Constant(int1, 0)
a = builder.add(z, z, 'a')
with builder.if_then(a):
b = builder.add(z, z, 'b')
with builder.if_then(b):
builder.add(z, z, 'c')
builder.ret_void()
self.check_func_body(builder.function, """\
one:
%"a" = add i1 0, 0
br i1 %"a", label %"one.if", label %"one.endif"
one.if:
%"b" = add i1 0, 0
br i1 %"b", label %"one.if.if", label %"one.if.endif"
one.endif:
ret void
one.if.if:
%"c" = add i1 0, 0
br label %"one.if.endif"
one.if.endif:
br label %"one.endif"
""")
def test_if_then_long_label(self):
full_label = 'Long' * 20
block = self.block(name=full_label)
builder = ir.IRBuilder(block)
z = ir.Constant(int1, 0)
a = builder.add(z, z, 'a')
with builder.if_then(a):
b = builder.add(z, z, 'b')
with builder.if_then(b):
builder.add(z, z, 'c')
builder.ret_void()
self.check_func_body(builder.function, """\
{full_label}:
%"a" = add i1 0, 0
br i1 %"a", label %"{label}.if", label %"{label}.endif"
{label}.if:
%"b" = add i1 0, 0
br i1 %"b", label %"{label}.if.if", label %"{label}.if.endif"
{label}.endif:
ret void
{label}.if.if:
%"c" = add i1 0, 0
br label %"{label}.if.endif"
{label}.if.endif:
br label %"{label}.endif"
""".format(full_label=full_label, label=full_label[:25] + '..'))
def test_if_then_likely(self):
def check(likely):
block = self.block(name='one')
builder = ir.IRBuilder(block)
z = ir.Constant(int1, 0)
with builder.if_then(z, likely=likely):
pass
self.check_block(block, """\
one:
br i1 0, label %"one.if", label %"one.endif", !prof !0
""")
return builder
builder = check(True)
self.check_metadata(builder.module, """\
!0 = !{ !"branch_weights", i32 99, i32 1 }
""")
builder = check(False)
self.check_metadata(builder.module, """\
!0 = !{ !"branch_weights", i32 1, i32 99 }
""")
def test_if_else(self):
block = self.block(name='one')
builder = ir.IRBuilder(block)
z = ir.Constant(int1, 0)
a = builder.add(z, z, 'a')
with builder.if_else(a) as (then, otherwise):
with then:
builder.add(z, z, 'b')
with otherwise:
builder.add(z, z, 'c')
# Each block will be terminated implicitly
with builder.if_else(a) as (then, otherwise):
with then:
builder.branch(block)
with otherwise:
builder.ret_void()
# No implicit termination
self.check_func_body(builder.function, """\
one:
%"a" = add i1 0, 0
br i1 %"a", label %"one.if", label %"one.else"
one.if:
%"b" = add i1 0, 0
br label %"one.endif"
one.else:
%"c" = add i1 0, 0
br label %"one.endif"
one.endif:
br i1 %"a", label %"one.endif.if", label %"one.endif.else"
one.endif.if:
br label %"one"
one.endif.else:
ret void
one.endif.endif:
""")
def test_if_else_likely(self):
def check(likely):
block = self.block(name='one')
builder = ir.IRBuilder(block)
z = ir.Constant(int1, 0)
with builder.if_else(z, likely=likely) as (then, otherwise):
with then:
builder.branch(block)
with otherwise:
builder.ret_void()
self.check_func_body(builder.function, """\
one:
br i1 0, label %"one.if", label %"one.else", !prof !0
one.if:
br label %"one"
one.else:
ret void
one.endif:
""")
return builder
builder = check(True)
self.check_metadata(builder.module, """\
!0 = !{ !"branch_weights", i32 99, i32 1 }
""")
builder = check(False)
self.check_metadata(builder.module, """\
!0 = !{ !"branch_weights", i32 1, i32 99 }
""")
def test_positioning(self):
"""
Test IRBuilder.position_{before,after,at_start,at_end}.
"""
func = self.function()
builder = ir.IRBuilder()
z = ir.Constant(int32, 0)
bb_one = func.append_basic_block(name='one')
bb_two = func.append_basic_block(name='two')
bb_three = func.append_basic_block(name='three')
# .at_start(empty block)
builder.position_at_start(bb_one)
builder.add(z, z, 'a')
# .at_end(empty block)
builder.position_at_end(bb_two)
builder.add(z, z, 'm')
builder.add(z, z, 'n')
# .at_start(block)
builder.position_at_start(bb_two)
o = builder.add(z, z, 'o')
builder.add(z, z, 'p')
# .at_end(block)
builder.position_at_end(bb_one)
b = builder.add(z, z, 'b')
# .after(instr)
builder.position_after(o)
builder.add(z, z, 'q')
# .before(instr)
builder.position_before(b)
builder.add(z, z, 'c')
self.check_block(bb_one, """\
one:
%"a" = add i32 0, 0
%"c" = add i32 0, 0
%"b" = add i32 0, 0
""")
self.check_block(bb_two, """\
two:
%"o" = add i32 0, 0
%"q" = add i32 0, 0
%"p" = add i32 0, 0
%"m" = add i32 0, 0
%"n" = add i32 0, 0
""")
self.check_block(bb_three, """\
three:
""")
def test_instruction_removal(self):
func = self.function()
builder = ir.IRBuilder()
blk = func.append_basic_block(name='entry')
builder.position_at_end(blk)
k = ir.Constant(int32, 1234)
a = builder.add(k, k, 'a')
retvoid = builder.ret_void()
self.assertTrue(blk.is_terminated)
builder.remove(retvoid)
self.assertFalse(blk.is_terminated)
b = builder.mul(a, a, 'b')
c = builder.add(b, b, 'c')
builder.remove(c)
builder.ret_void()
self.assertTrue(blk.is_terminated)
self.check_block(blk, """\
entry:
%"a" = add i32 1234, 1234
%"b" = mul i32 %"a", %"a"
ret void
""")
def test_metadata(self):
block = self.block(name='my_block')
builder = ir.IRBuilder(block)
builder.debug_metadata = builder.module.add_metadata([])
builder.alloca(ir.PointerType(int32), name='c')
self.check_block(block, """\
my_block:
%"c" = alloca i32*, !dbg !0
""")
class TestTypes(TestBase):
def has_logical_equality(self, ty):
while isinstance(ty, ir.PointerType):
ty = ty.pointee
return not isinstance(ty, ir.LabelType)
def assorted_types(self):
"""
A bunch of mutually unequal types
"""
# Avoid polluting the namespace
context = ir.Context()
types = [
ir.LabelType(), ir.VoidType(),
ir.FunctionType(int1, (int8, int8)), ir.FunctionType(int1, (int8,)),
ir.FunctionType(int1, (int8,), var_arg=True),
ir.FunctionType(int8, (int8,)),
int1, int8, int32, flt, dbl,
ir.ArrayType(flt, 5), ir.ArrayType(dbl, 5), ir.ArrayType(dbl, 4),
ir.LiteralStructType((int1, int8)), ir.LiteralStructType((int8,
int1)),
context.get_identified_type("MyType1"),
context.get_identified_type("MyType2"),
]
types += [ir.PointerType(tp) for tp in types
if not isinstance(tp, (ir.VoidType, ir.LabelType))]
return types
def test_pickling(self):
types = self.assorted_types()
for ty in types:
newty = self.assert_pickle_correctly(ty)
if self.has_logical_equality(ty):
self.assertEqual(newty, ty)
def test_comparisons(self):
types = self.assorted_types()
for a, b in itertools.product(types, types):
if a is not b:
self.assertFalse(a == b, (a, b))
self.assertTrue(a != b, (a, b))
# We assume copy.copy() works fine here...
for tp in types:
other = copy.copy(tp)
if self.has_logical_equality(tp):
self.assertTrue(tp == other, (tp, other))
self.assertFalse(tp != other, (tp, other))
else:
self.assertFalse(tp == other, (tp, other))
self.assertTrue(tp != other, (tp, other))
def test_str(self):
"""
Test the string representation of types.
"""
self.assertEqual(str(int1), 'i1')
self.assertEqual(str(ir.IntType(29)), 'i29')
self.assertEqual(str(flt), 'float')
self.assertEqual(str(dbl), 'double')
self.assertEqual(str(ir.VoidType()), 'void')
self.assertEqual(str(ir.FunctionType(int1, ())), 'i1 ()')
self.assertEqual(str(ir.FunctionType(int1, (flt,))), 'i1 (float)')
self.assertEqual(str(ir.FunctionType(int1, (flt, dbl))),
'i1 (float, double)')
self.assertEqual(str(ir.FunctionType(int1, (), var_arg=True)),
'i1 (...)')
self.assertEqual(str(ir.FunctionType(int1, (flt,), var_arg=True)),
'i1 (float, ...)')
self.assertEqual(str(ir.FunctionType(int1, (flt, dbl), var_arg=True)),
'i1 (float, double, ...)')
self.assertEqual(str(ir.PointerType(int32)), 'i32*')
self.assertEqual(str(ir.PointerType(ir.PointerType(int32))), 'i32**')
self.assertEqual(str(ir.ArrayType(int1, 5)), '[5 x i1]')
self.assertEqual(str(ir.ArrayType(ir.PointerType(int1), 5)),
'[5 x i1*]')
self.assertEqual(str(ir.PointerType(ir.ArrayType(int1, 5))),
'[5 x i1]*')
self.assertEqual(str(ir.LiteralStructType((int1,))), '{i1}')
self.assertEqual(str(ir.LiteralStructType((int1, flt))), '{i1, float}')
self.assertEqual(str(ir.LiteralStructType((
ir.PointerType(int1), ir.LiteralStructType((int32, int8))))),
'{i1*, {i32, i8}}')
self.assertEqual(str(ir.LiteralStructType((int1,), packed=True)),
'<{i1}>')
self.assertEqual(str(ir.LiteralStructType((int1, flt), packed=True)),
'<{i1, float}>')
# Avoid polluting the namespace
context = ir.Context()
mytype = context.get_identified_type("MyType")
self.assertEqual(str(mytype), "%\"MyType\"")
mytype1 = context.get_identified_type("MyType\\")
self.assertEqual(str(mytype1), "%\"MyType\\5c\"")
mytype2 = context.get_identified_type("MyType\"")
self.assertEqual(str(mytype2), "%\"MyType\\22\"")
def test_hash(self):
for typ in filter(self.has_logical_equality, self.assorted_types()):
self.assertEqual(hash(typ), hash(copy.copy(typ)))
def test_gep(self):
def check_constant(tp, i, expected):
actual = tp.gep(ir.Constant(int32, i))
self.assertEqual(actual, expected)
def check_index_type(tp):
index = ir.Constant(dbl, 1.0)
with self.assertRaises(TypeError):
tp.gep(index)
tp = ir.PointerType(dbl)
for i in range(5):
check_constant(tp, i, dbl)
check_index_type(tp)
tp = ir.ArrayType(int1, 3)
for i in range(3):
check_constant(tp, i, int1)
check_index_type(tp)
tp = ir.LiteralStructType((dbl, ir.LiteralStructType((int1, int8))))
check_constant(tp, 0, dbl)
check_constant(tp, 1, ir.LiteralStructType((int1, int8)))
with self.assertRaises(IndexError):
tp.gep(ir.Constant(int32, 2))
check_index_type(tp)
context = ir.Context()
tp = ir.IdentifiedStructType(context, "MyType")
tp.set_body(dbl, ir.LiteralStructType((int1, int8)))
check_constant(tp, 0, dbl)
check_constant(tp, 1, ir.LiteralStructType((int1, int8)))
with self.assertRaises(IndexError):
tp.gep(ir.Constant(int32, 2))
check_index_type(tp)
def test_abi_size(self):
td = llvm.create_target_data("e-m:e-i64:64-f80:128-n8:16:32:64-S128")
def check(tp, expected):
self.assertEqual(tp.get_abi_size(td), expected)
check(int8, 1)
check(int32, 4)
check(int64, 8)
check(ir.ArrayType(int8, 5), 5)
check(ir.ArrayType(int32, 5), 20)
check(ir.LiteralStructType((dbl, flt, flt)), 16)
def test_abi_alignment(self):
td = llvm.create_target_data("e-m:e-i64:64-f80:128-n8:16:32:64-S128")
def check(tp, expected):
self.assertIn(tp.get_abi_alignment(td), expected)
check(int8, (1, 2, 4))
check(int32, (4,))
check(int64, (8,))
check(ir.ArrayType(int8, 5), (1, 2, 4))
check(ir.ArrayType(int32, 5), (4,))
check(ir.LiteralStructType((dbl, flt, flt)), (8,))
def test_identified_struct(self):
context = ir.Context()
mytype = context.get_identified_type("MyType")
module = ir.Module(context=context)
self.assertTrue(mytype.is_opaque)
self.assert_valid_ir(module)
oldstr = str(module)
mytype.set_body(ir.IntType(32), ir.IntType(64), ir.FloatType())
self.assertFalse(mytype.is_opaque)
self.assert_valid_ir(module)
self.assertNotEqual(oldstr, str(module))
def test_target_data_non_default_context(self):
context = ir.Context()
mytype = context.get_identified_type("MyType")
mytype.elements = [ir.IntType(32)]
td = llvm.create_target_data("e-m:e-i64:64-f80:128-n8:16:32:64-S128")
self.assertEqual(mytype.get_abi_size(td, context=context), 4)
def test_vector(self):
vecty = ir.VectorType(ir.IntType(32), 8)
self.assertEqual(str(vecty), "<8 x i32>")
def c32(i):
return ir.Constant(int32, i)
class TestConstant(TestBase):
def test_integers(self):
c = ir.Constant(int32, 42)
self.assertEqual(str(c), 'i32 42')
c = ir.Constant(int1, 1)
self.assertEqual(str(c), 'i1 1')
c = ir.Constant(int1, 0)
self.assertEqual(str(c), 'i1 0')
c = ir.Constant(int1, True)
self.assertEqual(str(c), 'i1 true')
c = ir.Constant(int1, False)
self.assertEqual(str(c), 'i1 false')
c = ir.Constant(int1, ir.Undefined)
self.assertEqual(str(c), 'i1 undef')
c = ir.Constant(int1, None)
self.assertEqual(str(c), 'i1 0')
def test_reals(self):
# XXX Test NaNs and infs
c = ir.Constant(flt, 1.5)
self.assertEqual(str(c), 'float 0x3ff8000000000000')
c = ir.Constant(flt, -1.5)
self.assertEqual(str(c), 'float 0xbff8000000000000')
c = ir.Constant(dbl, 1.5)
self.assertEqual(str(c), 'double 0x3ff8000000000000')
c = ir.Constant(dbl, -1.5)
self.assertEqual(str(c), 'double 0xbff8000000000000')
c = ir.Constant(dbl, ir.Undefined)
self.assertEqual(str(c), 'double undef')
c = ir.Constant(dbl, None)
self.assertEqual(str(c), 'double 0.0')
def test_arrays(self):
c = ir.Constant(ir.ArrayType(int32, 3), (c32(5), c32(6), c32(4)))
self.assertEqual(str(c), '[3 x i32] [i32 5, i32 6, i32 4]')
c = ir.Constant(ir.ArrayType(int32, 2), (c32(5), c32(ir.Undefined)))
self.assertEqual(str(c), '[2 x i32] [i32 5, i32 undef]')
c = ir.Constant.literal_array((c32(5), c32(6), c32(ir.Undefined)))
self.assertEqual(str(c), '[3 x i32] [i32 5, i32 6, i32 undef]')
with self.assertRaises(TypeError) as raises:
ir.Constant.literal_array((c32(5), ir.Constant(flt, 1.5)))
self.assertEqual(str(raises.exception),
"all elements must have the same type")
c = ir.Constant(ir.ArrayType(int32, 2), ir.Undefined)
self.assertEqual(str(c), '[2 x i32] undef')
c = ir.Constant(ir.ArrayType(int32, 2), None)
self.assertEqual(str(c), '[2 x i32] zeroinitializer')
# Raw array syntax
c = ir.Constant(ir.ArrayType(int8, 11), bytearray(b"foobar_123\x80"))
self.assertEqual(str(c), r'[11 x i8] c"foobar_123\80"')
c = ir.Constant(ir.ArrayType(int8, 4), bytearray(b"\x00\x01\x04\xff"))
self.assertEqual(str(c), r'[4 x i8] c"\00\01\04\ff"')
# Recursive instantiation of inner constants
c = ir.Constant(ir.ArrayType(int32, 3), (5, ir.Undefined, 6))
self.assertEqual(str(c), '[3 x i32] [i32 5, i32 undef, i32 6]')
# Invalid number of args
with self.assertRaises(ValueError):
ir.Constant(ir.ArrayType(int32, 3), (5, 6))
def test_vector(self):
vecty = ir.VectorType(ir.IntType(32), 8)
vals = [1, 2, 4, 3, 8, 6, 9, 7]
vec = ir.Constant(vecty, vals)
vec_repr = "<8 x i32> <{}>".format(
', '.join(map('i32 {}'.format, vals)))
self.assertEqual(str(vec), vec_repr)
def test_non_nullable_int(self):
constant = ir.Constant(ir.IntType(32), None).constant
self.assertEqual(constant, 0)
def test_structs(self):
st1 = ir.LiteralStructType((flt, int1))
st2 = ir.LiteralStructType((int32, st1))
c = ir.Constant(st1, (ir.Constant(ir.FloatType(), 1.5),
ir.Constant(int1, True)))
self.assertEqual(str(c),
'{float, i1} {float 0x3ff8000000000000, i1 true}')
c = ir.Constant.literal_struct((ir.Constant(ir.FloatType(), 1.5),
ir.Constant(int1, True)))
self.assertEqual(c.type, st1)
self.assertEqual(str(c),
'{float, i1} {float 0x3ff8000000000000, i1 true}')
c = ir.Constant.literal_struct((ir.Constant(ir.FloatType(), 1.5),
ir.Constant(int1, ir.Undefined)))
self.assertEqual(c.type, st1)
self.assertEqual(str(c),
'{float, i1} {float 0x3ff8000000000000, i1 undef}')
c = ir.Constant(st1, ir.Undefined)
self.assertEqual(str(c), '{float, i1} undef')
c = ir.Constant(st1, None)
self.assertEqual(str(c), '{float, i1} zeroinitializer')
# Recursive instantiation of inner constants
c1 = ir.Constant(st1, (1.5, True))
self.assertEqual(str(c1),
'{float, i1} {float 0x3ff8000000000000, i1 true}')
c2 = ir.Constant(st2, (42, c1))
self.assertEqual(str(c2), ('{i32, {float, i1}} {i32 42, {float, i1} '
'{float 0x3ff8000000000000, i1 true}}'))
c3 = ir.Constant(st2, (42, (1.5, True)))
self.assertEqual(str(c3), str(c2))
# Invalid number of args
with self.assertRaises(ValueError):
ir.Constant(st2, (4, 5, 6))
def test_undefined_literal_struct_pickling(self):
i8 = ir.IntType(8)
st = ir.Constant(ir.LiteralStructType([i8, i8]), ir.Undefined)
self.assert_pickle_correctly(st)
def test_type_instantiaton(self):
"""
Instantiating a type should create a constant.
"""
c = int8(42)
self.assertIsInstance(c, ir.Constant)
self.assertEqual(str(c), 'i8 42')
c = int1(True)
self.assertIsInstance(c, ir.Constant)
self.assertEqual(str(c), 'i1 true')
# Arrays
at = ir.ArrayType(int32, 3)
c = at([c32(4), c32(5), c32(6)])
self.assertEqual(str(c), '[3 x i32] [i32 4, i32 5, i32 6]')
c = at([4, 5, 6])
self.assertEqual(str(c), '[3 x i32] [i32 4, i32 5, i32 6]')
c = at(None)
self.assertEqual(str(c), '[3 x i32] zeroinitializer')
with self.assertRaises(ValueError):
at([4, 5, 6, 7])
# Structs
st1 = ir.LiteralStructType((flt, int1))
st2 = ir.LiteralStructType((int32, st1))
c = st1((1.5, True))
self.assertEqual(str(c), ('{float, i1} {float 0x3ff8000000000000, i1 '
'true}'))
c = st2((42, (1.5, True)))
self.assertEqual(str(c), ('{i32, {float, i1}} {i32 42, {float, i1} '
'{float 0x3ff8000000000000, i1 true}}'))
def test_repr(self):
"""
Constants should have a useful repr().
"""
c = int32(42)
self.assertEqual(repr(c), "<ir.Constant type='i32' value=42>")
def test_encoding_problem(self):
c = ir.Constant(ir.ArrayType(ir.IntType(8), 256),
bytearray(range(256)))
m = self.module()
gv = ir.GlobalVariable(m, c.type, "myconstant")
gv.global_constant = True
gv.initializer = c
# With utf-8, the following will cause:
# UnicodeDecodeError: 'utf-8' codec can't decode byte 0xe0 in position
# 136: invalid continuation byte
parsed = llvm.parse_assembly(str(m))
# Make sure the encoding does not modify the IR
reparsed = llvm.parse_assembly(str(parsed))
self.assertEqual(str(parsed), str(reparsed))
def test_gep(self):
m = self.module()
tp = ir.LiteralStructType((flt, int1))
gv = ir.GlobalVariable(m, tp, "myconstant")
c = gv.gep([ir.Constant(int32, x) for x in (0, 1)])
self.assertEqual(str(c),
'getelementptr ({float, i1}, {float, i1}* @"myconstant", i32 0, i32 1)') # noqa E501
self.assertEqual(c.type, ir.PointerType(int1))
const = ir.Constant(tp, None)
with self.assertRaises(TypeError):
const.gep([ir.Constant(int32, 0)])
const_ptr = ir.Constant(tp.as_pointer(), None)
c2 = const_ptr.gep([ir.Constant(int32, 0)])
self.assertEqual(str(c2),
'getelementptr ({float, i1}, {float, i1}* null, i32 0)') # noqa E501
self.assertEqual(c.type, ir.PointerType(int1))
def test_gep_addrspace_globalvar(self):
m = self.module()
tp = ir.LiteralStructType((flt, int1))
addrspace = 4
gv = ir.GlobalVariable(m, tp, "myconstant", addrspace=addrspace)
self.assertEqual(gv.addrspace, addrspace)
c = gv.gep([ir.Constant(int32, x) for x in (0, 1)])
self.assertEqual(c.type.addrspace, addrspace)
self.assertEqual(str(c),
('getelementptr ({float, i1}, {float, i1} '
'addrspace(4)* @"myconstant", i32 0, i32 1)'))
self.assertEqual(c.type, ir.PointerType(int1, addrspace=addrspace))
def test_trunc(self):
c = ir.Constant(int64, 1).trunc(int32)
self.assertEqual(str(c), 'trunc (i64 1 to i32)')
def test_zext(self):
c = ir.Constant(int32, 1).zext(int64)
self.assertEqual(str(c), 'zext (i32 1 to i64)')
def test_sext(self):
c = ir.Constant(int32, -1).sext(int64)
self.assertEqual(str(c), 'sext (i32 -1 to i64)')
def test_fptrunc(self):
c = ir.Constant(flt, 1).fptrunc(hlf)
self.assertEqual(str(c), 'fptrunc (float 0x3ff0000000000000 to half)')
def test_fpext(self):
c = ir.Constant(flt, 1).fpext(dbl)
self.assertEqual(str(c), 'fpext (float 0x3ff0000000000000 to double)')
def test_bitcast(self):
m = self.module()
gv = ir.GlobalVariable(m, int32, "myconstant")
c = gv.bitcast(int64.as_pointer())
self.assertEqual(str(c), 'bitcast (i32* @"myconstant" to i64*)')
def test_fptoui(self):
c = ir.Constant(flt, 1).fptoui(int32)
self.assertEqual(str(c), 'fptoui (float 0x3ff0000000000000 to i32)')
def test_uitofp(self):
c = ir.Constant(int32, 1).uitofp(flt)
self.assertEqual(str(c), 'uitofp (i32 1 to float)')
def test_fptosi(self):
c = ir.Constant(flt, 1).fptosi(int32)
self.assertEqual(str(c), 'fptosi (float 0x3ff0000000000000 to i32)')
def test_sitofp(self):
c = ir.Constant(int32, 1).sitofp(flt)
self.assertEqual(str(c), 'sitofp (i32 1 to float)')
def test_ptrtoint_1(self):
ptr = ir.Constant(int64.as_pointer(), None)
one = ir.Constant(int32, 1)
c = ptr.ptrtoint(int32)
self.assertRaises(TypeError, one.ptrtoint, int64)
self.assertRaises(TypeError, ptr.ptrtoint, flt)
self.assertEqual(str(c), 'ptrtoint (i64* null to i32)')
def test_ptrtoint_2(self):
m = self.module()
gv = ir.GlobalVariable(m, int32, "myconstant")
c = gv.ptrtoint(int64)
self.assertEqual(str(c), 'ptrtoint (i32* @"myconstant" to i64)')
self.assertRaisesRegex(
TypeError,
r"can only ptrtoint\(\) to integer type, not 'i64\*'",
gv.ptrtoint,
int64.as_pointer())
c2 = ir.Constant(int32, 0)
self.assertRaisesRegex(
TypeError,
r"can only call ptrtoint\(\) on pointer type, not 'i32'",
c2.ptrtoint,
int64)
def test_inttoptr(self):
one = ir.Constant(int32, 1)
pi = ir.Constant(flt, 3.14)
c = one.inttoptr(int64.as_pointer())
self.assertRaises(TypeError, one.inttoptr, int64)
self.assertRaises(TypeError, pi.inttoptr, int64.as_pointer())
self.assertEqual(str(c), 'inttoptr (i32 1 to i64*)')
def test_neg(self):
one = ir.Constant(int32, 1)
self.assertEqual(str(one.neg()), 'sub (i32 0, i32 1)')
def test_not(self):
one = ir.Constant(int32, 1)
self.assertEqual(str(one.not_()), 'xor (i32 1, i32 -1)')
def test_fneg(self):
one = ir.Constant(flt, 1)
self.assertEqual(str(one.fneg()), 'fneg (float 0x3ff0000000000000)')
def test_int_binops(self):
one = ir.Constant(int32, 1)
two = ir.Constant(int32, 2)
oracle = {one.shl: 'shl', one.lshr: 'lshr', one.ashr: 'ashr',
one.add: 'add', one.sub: 'sub', one.mul: 'mul',
one.udiv: 'udiv', one.sdiv: 'sdiv', one.urem: 'urem',
one.srem: 'srem', one.or_: 'or', one.and_: 'and',
one.xor: 'xor'}
for fn, irop in oracle.items():
self.assertEqual(str(fn(two)), irop + ' (i32 1, i32 2)')
# unsigned integer compare
oracle = {'==': 'eq', '!=': 'ne', '>':
'ugt', '>=': 'uge', '<': 'ult', '<=': 'ule'}
for cop, cond in oracle.items():
actual = str(one.icmp_unsigned(cop, two))
expected = 'icmp ' + cond + ' (i32 1, i32 2)'
self.assertEqual(actual, expected)
# signed integer compare
oracle = {'==': 'eq', '!=': 'ne',
'>': 'sgt', '>=': 'sge', '<': 'slt', '<=': 'sle'}
for cop, cond in oracle.items():
actual = str(one.icmp_signed(cop, two))
expected = 'icmp ' + cond + ' (i32 1, i32 2)'
self.assertEqual(actual, expected)
def test_flt_binops(self):
one = ir.Constant(flt, 1)
two = ir.Constant(flt, 2)
oracle = {one.fadd: 'fadd', one.fsub: 'fsub', one.fmul: 'fmul',
one.fdiv: 'fdiv', one.frem: 'frem'}
for fn, irop in oracle.items():
actual = str(fn(two))
expected = irop + (' (float 0x3ff0000000000000,'
' float 0x4000000000000000)')
self.assertEqual(actual, expected)
# ordered float compare
oracle = {'==': 'oeq', '!=': 'one', '>': 'ogt', '>=': 'oge',
'<': 'olt', '<=': 'ole'}
for cop, cond in oracle.items():
actual = str(one.fcmp_ordered(cop, two))
expected = 'fcmp ' + cond + (' (float 0x3ff0000000000000,'
' float 0x4000000000000000)')
self.assertEqual(actual, expected)
# unordered float compare
oracle = {'==': 'ueq', '!=': 'une', '>': 'ugt', '>=': 'uge',
'<': 'ult', '<=': 'ule'}
for cop, cond in oracle.items():
actual = str(one.fcmp_unordered(cop, two))
expected = 'fcmp ' + cond + (' (float 0x3ff0000000000000,'
' float 0x4000000000000000)')
self.assertEqual(actual, expected)
class TestTransforms(TestBase):
def test_call_transform(self):
mod = ir.Module()
foo = ir.Function(mod, ir.FunctionType(ir.VoidType(), ()), "foo")
bar = ir.Function(mod, ir.FunctionType(ir.VoidType(), ()), "bar")
builder = ir.IRBuilder()
builder.position_at_end(foo.append_basic_block())
call = builder.call(foo, ())
self.assertEqual(call.callee, foo)
modified = ir.replace_all_calls(mod, foo, bar)
self.assertIn(call, modified)
self.assertNotEqual(call.callee, foo)
self.assertEqual(call.callee, bar)
class TestSingleton(TestBase):
def test_undefined(self):
self.assertIs(ir.Undefined, ir.values._Undefined())
self.assertIs(ir.Undefined, copy.copy(ir.Undefined))
self.assertIs(ir.Undefined, copy.deepcopy(ir.Undefined))
self.assert_pickle_correctly(ir.Undefined)
if __name__ == '__main__':
unittest.main()
| 38.813107 | 193 | 0.532497 |
fdf5888549d2ca6199e243b2913bf9f33bf8d970 | 1,721 | py | Python | lte/gateway/python/magma/policydb/rule_store.py | Aitend/magma | 74fe7b437335728219dfbe54733955bdd652eb60 | [
"BSD-3-Clause"
] | 849 | 2020-07-17T09:15:03.000Z | 2022-03-31T17:11:52.000Z | lte/gateway/python/magma/policydb/rule_store.py | Aitend/magma | 74fe7b437335728219dfbe54733955bdd652eb60 | [
"BSD-3-Clause"
] | 8,386 | 2020-06-23T23:35:30.000Z | 2022-03-31T23:31:28.000Z | lte/gateway/python/magma/policydb/rule_store.py | Aitend/magma | 74fe7b437335728219dfbe54733955bdd652eb60 | [
"BSD-3-Clause"
] | 406 | 2020-06-28T17:02:35.000Z | 2022-03-31T22:03:55.000Z | """
Copyright 2020 The Magma Authors.
This source code is licensed under the BSD-style license found in the
LICENSE file in the root directory of this source tree.
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 lte.protos.policydb_pb2 import PolicyRule
from magma.common.redis.client import get_default_client
from magma.common.redis.containers import RedisHashDict
from magma.common.redis.serializers import (
get_proto_deserializer,
get_proto_serializer,
)
class PolicyRuleDict(RedisHashDict):
"""
PolicyRuleDict uses the RedisHashDict collection to store a mapping of policy
rule ids to PolicyRules. Setting and deleting items in the dictionary syncs
with Redis automatically
"""
_DICT_HASH = "policydb:rules"
_NOTIFY_CHANNEL = "policydb:rules:stream_update"
def __init__(self):
client = get_default_client()
super().__init__(
client,
self._DICT_HASH,
get_proto_serializer(),
get_proto_deserializer(PolicyRule),
)
def send_update_notification(self):
"""
Use Redis pub/sub channels to send notifications. Subscribers can listen
to this channel to know when an update is done to the policy store
"""
self.redis.publish(self._NOTIFY_CHANNEL, "Stream Update")
def __missing__(self, key):
"""Instead of throwing a key error, return None when key not found"""
return None
| 33.745098 | 81 | 0.724579 |
a32cbbc4cb0847db1cabebb2f4b3fa3940a4c65c | 1,122 | py | Python | alipay/aop/api/response/AlipaySocialAntforestPlantConsultResponse.py | antopen/alipay-sdk-python-all | 8e51c54409b9452f8d46c7bb10eea7c8f7e8d30c | [
"Apache-2.0"
] | 213 | 2018-08-27T16:49:32.000Z | 2021-12-29T04:34:12.000Z | alipay/aop/api/response/AlipaySocialAntforestPlantConsultResponse.py | antopen/alipay-sdk-python-all | 8e51c54409b9452f8d46c7bb10eea7c8f7e8d30c | [
"Apache-2.0"
] | 29 | 2018-09-29T06:43:00.000Z | 2021-09-02T03:27:32.000Z | alipay/aop/api/response/AlipaySocialAntforestPlantConsultResponse.py | antopen/alipay-sdk-python-all | 8e51c54409b9452f8d46c7bb10eea7c8f7e8d30c | [
"Apache-2.0"
] | 59 | 2018-08-27T16:59:26.000Z | 2022-03-25T10:08:15.000Z | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import json
from alipay.aop.api.response.AlipayResponse import AlipayResponse
class AlipaySocialAntforestPlantConsultResponse(AlipayResponse):
def __init__(self):
super(AlipaySocialAntforestPlantConsultResponse, self).__init__()
self._current_energy = None
self._project_alliable = None
@property
def current_energy(self):
return self._current_energy
@current_energy.setter
def current_energy(self, value):
self._current_energy = value
@property
def project_alliable(self):
return self._project_alliable
@project_alliable.setter
def project_alliable(self, value):
self._project_alliable = value
def parse_response_content(self, response_content):
response = super(AlipaySocialAntforestPlantConsultResponse, self).parse_response_content(response_content)
if 'current_energy' in response:
self.current_energy = response['current_energy']
if 'project_alliable' in response:
self.project_alliable = response['project_alliable']
| 31.166667 | 114 | 0.722816 |
bcb5a6cf1edade1e6847f156ea4a5a8d407e0154 | 39,766 | py | Python | python/dgl/convert.py | qibinc/dgl | 4aafe2d9368a55705ccd6a960aa5f581e486b225 | [
"Apache-2.0"
] | null | null | null | python/dgl/convert.py | qibinc/dgl | 4aafe2d9368a55705ccd6a960aa5f581e486b225 | [
"Apache-2.0"
] | null | null | null | python/dgl/convert.py | qibinc/dgl | 4aafe2d9368a55705ccd6a960aa5f581e486b225 | [
"Apache-2.0"
] | 2 | 2019-12-13T13:45:16.000Z | 2019-12-20T03:30:08.000Z | """Module for converting graph from/to other object."""
from collections import defaultdict
import numpy as np
import scipy as sp
import networkx as nx
from . import backend as F
from . import heterograph_index
from .heterograph import DGLHeteroGraph, combine_frames
from . import graph_index
from . import utils
from .base import NTYPE, ETYPE, NID, EID, DGLError
__all__ = [
'graph',
'bipartite',
'hetero_from_relations',
'heterograph',
'to_hetero',
'to_homo',
'to_networkx',
]
def graph(data, ntype='_N', etype='_E', card=None, validate=False, **kwargs):
"""Create a graph with one type of nodes and edges.
In the sparse matrix perspective, :func:`dgl.graph` creates a graph
whose adjacency matrix must be square while :func:`dgl.bipartite`
creates a graph that does not necessarily have square adjacency matrix.
Parameters
----------
data : graph data
Data to initialize graph structure. Supported data formats are
(1) list of edge pairs (e.g. [(0, 2), (3, 1), ...])
(2) pair of vertex IDs representing end nodes (e.g. ([0, 3, ...], [2, 1, ...]))
(3) scipy sparse matrix
(4) networkx graph
ntype : str, optional
Node type name. (Default: _N)
etype : str, optional
Edge type name. (Default: _E)
card : int, optional
Cardinality (number of nodes in the graph). If None, infer from input data, i.e.
the largest node ID plus 1. (Default: None)
validate : bool, optional
If True, check if node ids are within cardinality, the check process may take
some time.
If False and card is not None, user would receive a warning. (Default: False)
kwargs : key-word arguments, optional
Other key word arguments. Only comes into effect when we are using a NetworkX
graph. It can consist of:
* edge_id_attr_name
``Str``, key name for edge ids in the NetworkX graph. If not found, we
will consider the graph not to have pre-specified edge ids.
* node_attrs
``List of str``, names for node features to retrieve from the NetworkX graph
* edge_attrs
``List of str``, names for edge features to retrieve from the NetworkX graph
Returns
-------
DGLHeteroGraph
Examples
--------
Create from pairs of edges with form (src, dst)
>>> g = dgl.graph([(0, 2), (0, 3), (1, 2)])
Create from source and destination vertex ID lists
>>> u = [0, 0, 1]
>>> v = [2, 3, 2]
>>> g = dgl.graph((u, v))
The IDs can also be stored in framework-specific tensors
>>> import torch
>>> u = torch.tensor([0, 0, 1])
>>> v = torch.tensor([2, 3, 2])
>>> g = dgl.graph((u, v))
Create from scipy sparse matrix
>>> from scipy.sparse import coo_matrix
>>> spmat = coo_matrix(([1,1,1], ([0, 0, 1], [2, 3, 2])), shape=(4, 4))
>>> g = dgl.graph(spmat)
Create from networkx graph
>>> import networkx as nx
>>> nxg = nx.path_graph(3)
>>> g = dgl.graph(nxg)
Specify node and edge type names
>>> g = dgl.graph(..., 'user', 'follows')
>>> g.ntypes
['user']
>>> g.etypes
['follows']
>>> g.canonical_etypes
[('user', 'follows', 'user')]
Check if node ids are within cardinality
>>> g = dgl.graph(([0, 1, 2], [1, 2, 0]), card=2, validate=True)
...
dgl._ffi.base.DGLError: Invalid node id 2 (should be less than cardinality 2).
>>> g = dgl.graph(([0, 1, 2], [1, 2, 0]), card=3, validate=True)
Graph(num_nodes=3, num_edges=3,
ndata_schemes={}
edata_schemes={})
"""
if card is not None:
urange, vrange = card, card
else:
urange, vrange = None, None
if isinstance(data, tuple):
u, v = data
return create_from_edges(u, v, ntype, etype, ntype, urange, vrange, validate)
elif isinstance(data, list):
return create_from_edge_list(data, ntype, etype, ntype, urange, vrange, validate)
elif isinstance(data, sp.sparse.spmatrix):
return create_from_scipy(data, ntype, etype, ntype)
elif isinstance(data, nx.Graph):
return create_from_networkx(data, ntype, etype, **kwargs)
else:
raise DGLError('Unsupported graph data type:', type(data))
def bipartite(data, utype='_U', etype='_E', vtype='_V', card=None, validate=False, **kwargs):
"""Create a bipartite graph.
The result graph is directed and edges must be from ``utype`` nodes
to ``vtype`` nodes. Nodes of each type have their own ID counts.
In the sparse matrix perspective, :func:`dgl.graph` creates a graph
whose adjacency matrix must be square while :func:`dgl.bipartite`
creates a graph that does not necessarily have square adjacency matrix.
Parameters
----------
data : graph data
Data to initialize graph structure. Supported data formats are
(1) list of edge pairs (e.g. [(0, 2), (3, 1), ...])
(2) pair of vertex IDs representing end nodes (e.g. ([0, 3, ...], [2, 1, ...]))
(3) scipy sparse matrix
(4) networkx graph
utype : str, optional
Source node type name. (Default: _U)
etype : str, optional
Edge type name. (Default: _E)
vtype : str, optional
Destination node type name. (Default: _V)
card : pair of int, optional
Cardinality (number of nodes in the source and destination group). If None,
infer from input data, i.e. the largest node ID plus 1 for each type. (Default: None)
validate : bool, optional
If True, check if node ids are within cardinality, the check process may take
some time.
If False and card is not None, user would receive a warning. (Default: False)
kwargs : key-word arguments, optional
Other key word arguments. Only comes into effect when we are using a NetworkX
graph. It can consist of:
* edge_id_attr_name
``Str``, key name for edge ids in the NetworkX graph. If not found, we
will consider the graph not to have pre-specified edge ids.
Returns
-------
DGLHeteroGraph
Examples
--------
Create from pairs of edges
>>> g = dgl.bipartite([(0, 2), (0, 3), (1, 2)], 'user', 'plays', 'game')
>>> g.ntypes
['user', 'game']
>>> g.etypes
['plays']
>>> g.canonical_etypes
[('user', 'plays', 'game')]
>>> g.number_of_nodes('user')
2
>>> g.number_of_nodes('game')
4
>>> g.number_of_edges('plays') # 'plays' could be omitted here
3
Create from source and destination vertex ID lists
>>> u = [0, 0, 1]
>>> v = [2, 3, 2]
>>> g = dgl.bipartite((u, v))
The IDs can also be stored in framework-specific tensors
>>> import torch
>>> u = torch.tensor([0, 0, 1])
>>> v = torch.tensor([2, 3, 2])
>>> g = dgl.bipartite((u, v))
Create from scipy sparse matrix. Since scipy sparse matrix has explicit
shape, the cardinality of the result graph is derived from that.
>>> from scipy.sparse import coo_matrix
>>> spmat = coo_matrix(([1,1,1], ([0, 0, 1], [2, 3, 2])), shape=(4, 4))
>>> g = dgl.bipartite(spmat, 'user', 'plays', 'game')
>>> g.number_of_nodes('user')
4
>>> g.number_of_nodes('game')
4
Create from networkx graph. The given graph must follow the bipartite
graph convention in networkx. Each node has a ``bipartite`` attribute
with values 0 or 1. The result graph has two types of nodes and only
edges from ``bipartite=0`` to ``bipartite=1`` will be included.
>>> import networkx as nx
>>> nxg = nx.complete_bipartite_graph(3, 4)
>>> g = dgl.bipartite(nxg, 'user', 'plays', 'game')
>>> g.number_of_nodes('user')
3
>>> g.number_of_nodes('game')
4
>>> g.edges()
(tensor([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2]), tensor([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]))
Check if node ids are within cardinality
>>> g = dgl.bipartite(([0, 1, 2], [1, 2, 3]), card=(2, 4), validate=True)
...
dgl._ffi.base.DGLError: Invalid node id 2 (should be less than cardinality 2).
>>> g = dgl.bipartite(([0, 1, 2], [1, 2, 3]), card=(3, 4), validate=True)
>>> g
Graph(num_nodes={'_U': 3, '_V': 4},
num_edges={('_U', '_E', '_V'): 3},
metagraph=[('_U', '_V')])
"""
if utype == vtype:
raise DGLError('utype should not be equal to vtype. Use ``dgl.graph`` instead.')
if card is not None:
urange, vrange = card
else:
urange, vrange = None, None
if isinstance(data, tuple):
u, v = data
return create_from_edges(u, v, utype, etype, vtype, urange, vrange, validate)
elif isinstance(data, list):
return create_from_edge_list(data, utype, etype, vtype, urange, vrange, validate)
elif isinstance(data, sp.sparse.spmatrix):
return create_from_scipy(data, utype, etype, vtype)
elif isinstance(data, nx.Graph):
return create_from_networkx_bipartite(data, utype, etype, vtype, **kwargs)
else:
raise DGLError('Unsupported graph data type:', type(data))
def hetero_from_relations(rel_graphs):
"""Create a heterograph from graphs representing connections of each relation.
The input is a list of heterographs where the ``i``th graph contains edges of type
:math:`(s_i, e_i, d_i)`.
If two graphs share a same node type, the number of nodes for the corresponding type
should be the same. See **Examples** for details.
Parameters
----------
rel_graphs : list of DGLHeteroGraph
Each element corresponds to a heterograph for one (src, edge, dst) relation.
Returns
-------
DGLHeteroGraph
A heterograph consisting of all relations.
Examples
--------
>>> import dgl
>>> follows_g = dgl.graph([(0, 1), (1, 2)], 'user', 'follows')
>>> plays_g = dgl.bipartite([(0, 0), (3, 1)], 'user', 'plays', 'game')
>>> devs_g = dgl.bipartite([(0, 0), (1, 1)], 'developer', 'develops', 'game')
>>> g = dgl.hetero_from_relations([follows_g, plays_g, devs_g])
will raise an error as we have 3 nodes of type 'user' in follows_g and 4 nodes of type
'user' in plays_g.
We have two possible methods to avoid the construction.
**Method 1**: Manually specify the number of nodes for all types when constructing
the relation graphs.
>>> # A graph with 4 nodes of type 'user'
>>> follows_g = dgl.graph([(0, 1), (1, 2)], 'user', 'follows', card=4)
>>> # A bipartite graph with 4 nodes of src type ('user') and 2 nodes of dst type ('game')
>>> plays_g = dgl.bipartite([(0, 0), (3, 1)], 'user', 'plays', 'game', card=(4, 2))
>>> devs_g = dgl.bipartite([(0, 0), (1, 1)], 'developer', 'develops', 'game')
>>> g = dgl.hetero_from_relations([follows_g, plays_g, devs_g])
>>> print(g)
Graph(num_nodes={'user': 4, 'game': 2, 'developer': 2},
num_edges={('user', 'follows', 'user'): 2, ('user', 'plays', 'game'): 2,
('developer', 'develops', 'game'): 2},
metagraph=[('user', 'user'), ('user', 'game'), ('developer', 'game')])
``devs_g`` does not have nodes of type ``'user'`` so no error will be raised.
**Method 2**: Construct a heterograph at once without intermediate relation graphs,
in which case we will infer the number of nodes for each type.
>>> g = dgl.heterograph({
>>> ('user', 'follows', 'user'): [(0, 1), (1, 2)],
>>> ('user', 'plays', 'game'): [(0, 0), (3, 1)],
>>> ('developer', 'develops', 'game'): [(0, 0), (1, 1)]
>>> })
>>> print(g)
Graph(num_nodes={'user': 4, 'game': 2, 'developer': 2},
num_edges={('user', 'follows', 'user'): 2,
('user', 'plays', 'game'): 2,
('developer', 'develops', 'game'): 2},
metagraph=[('user', 'user'), ('user', 'game'), ('developer', 'game')])
"""
# TODO(minjie): this API can be generalized as a union operation of the input graphs
# TODO(minjie): handle node/edge data
# infer meta graph
ntype_dict = {} # ntype -> ntid
meta_edges = []
ntypes = []
etypes = []
for rgrh in rel_graphs:
assert len(rgrh.etypes) == 1
stype, etype, dtype = rgrh.canonical_etypes[0]
if stype not in ntype_dict:
ntype_dict[stype] = len(ntypes)
ntypes.append(stype)
stid = ntype_dict[stype]
if dtype not in ntype_dict:
ntype_dict[dtype] = len(ntypes)
ntypes.append(dtype)
dtid = ntype_dict[dtype]
meta_edges.append((stid, dtid))
etypes.append(etype)
metagraph = graph_index.from_edge_list(meta_edges, True, True)
# create graph index
hgidx = heterograph_index.create_heterograph_from_relations(
metagraph, [rgrh._graph for rgrh in rel_graphs])
retg = DGLHeteroGraph(hgidx, ntypes, etypes)
for i, rgrh in enumerate(rel_graphs):
for ntype in rgrh.ntypes:
retg.nodes[ntype].data.update(rgrh.nodes[ntype].data)
retg._edge_frames[i].update(rgrh._edge_frames[0])
return retg
def heterograph(data_dict, num_nodes_dict=None):
"""Create a heterogeneous graph from a dictionary between edge types and edge lists.
Parameters
----------
data_dict : dict
The dictionary between edge types and edge list data.
The edge types are specified as a triplet of (source node type name, edge type
name, destination node type name).
The edge list data can be anything acceptable by :func:`dgl.graph` or
:func:`dgl.bipartite`, or objects returned by the two functions themselves.
num_nodes_dict : dict[str, int]
The number of nodes for each node type.
By default DGL infers the number of nodes for each node type from ``data_dict``
by taking the maximum node ID plus one for each node type.
Returns
-------
DGLHeteroGraph
Examples
--------
>>> g = dgl.heterograph({
... ('user', 'follows', 'user'): [(0, 1), (1, 2)],
... ('user', 'plays', 'game'): [(0, 0), (1, 0), (1, 1), (2, 1)],
... ('developer', 'develops', 'game'): [(0, 0), (1, 1)],
... })
"""
rel_graphs = []
# infer number of nodes for each node type
if num_nodes_dict is None:
num_nodes_dict = defaultdict(int)
for (srctype, etype, dsttype), data in data_dict.items():
if isinstance(data, tuple):
nsrc = max(data[0]) + 1
ndst = max(data[1]) + 1
elif isinstance(data, list):
src, dst = zip(*data)
nsrc = max(src) + 1
ndst = max(dst) + 1
elif isinstance(data, sp.sparse.spmatrix):
nsrc = data.shape[0]
ndst = data.shape[1]
elif isinstance(data, nx.Graph):
if srctype == dsttype:
nsrc = ndst = data.number_of_nodes()
else:
nsrc = len({n for n, d in data.nodes(data=True) if d['bipartite'] == 0})
ndst = data.number_of_nodes() - nsrc
elif isinstance(data, DGLHeteroGraph):
# Do nothing; handled in the next loop
continue
else:
raise DGLError('Unsupported graph data type %s for %s' % (
type(data), (srctype, etype, dsttype)))
if srctype == dsttype:
ndst = nsrc = max(nsrc, ndst)
num_nodes_dict[srctype] = max(num_nodes_dict[srctype], nsrc)
num_nodes_dict[dsttype] = max(num_nodes_dict[dsttype], ndst)
for (srctype, etype, dsttype), data in data_dict.items():
if isinstance(data, DGLHeteroGraph):
rel_graphs.append(data)
elif srctype == dsttype:
rel_graphs.append(graph(data, srctype, etype, card=num_nodes_dict[srctype]))
else:
rel_graphs.append(bipartite(
data, srctype, etype, dsttype,
card=(num_nodes_dict[srctype], num_nodes_dict[dsttype])))
return hetero_from_relations(rel_graphs)
def to_hetero(G, ntypes, etypes, ntype_field=NTYPE, etype_field=ETYPE, metagraph=None):
"""Convert the given homogeneous graph to a heterogeneous graph.
The input graph should have only one type of nodes and edges. Each node and edge
stores an integer feature (under ``ntype_field`` and ``etype_field``), representing
the type id, which can be used to retrieve the type names stored
in the given ``ntypes`` and ``etypes`` arguments.
The function will automatically distinguish edge types that have the same given
type IDs but different src and dst type IDs. For example, we allow both edges A and B
to have the same type ID 0, but one has (0, 1) and the other as (2, 3) as the
(src, dst) type IDs. In this case, the function will "split" edge type 0 into two types:
(0, ty_A, 1) and (2, ty_B, 3). In another word, these two edges share the same edge
type name, but can be distinguished by a canonical edge type tuple.
Parameters
----------
G : DGLHeteroGraph
Input homogeneous graph.
ntypes : list of str
The node type names.
etypes : list of str
The edge type names.
ntype_field : str, optional
The feature field used to store node type. (Default: ``dgl.NTYPE``)
etype_field : str, optional
The feature field used to store edge type. (Default: ``dgl.ETYPE``)
metagraph : networkx MultiDiGraph, optional
Metagraph of the returned heterograph.
If provided, DGL assumes that G can indeed be described with the given metagraph.
If None, DGL will infer the metagraph from the given inputs, which would be
potentially slower for large graphs.
Returns
-------
DGLHeteroGraph
A heterograph. The parent node and edge ID are stored in the column
``dgl.NID`` and ``dgl.EID`` respectively for all node/edge types.
Notes
-----
The returned node and edge types may not necessarily be in the same order as
``ntypes`` and ``etypes``. And edge types may be duplicated if the source
and destination types differ.
The node IDs of a single type in the returned heterogeneous graph is ordered
the same as the nodes with the same ``ntype_field`` feature. Edge IDs of
a single type is similar.
Examples
--------
>>> g1 = dgl.bipartite([(0, 1), (1, 2)], 'user', 'develops', 'activity')
>>> g2 = dgl.bipartite([(0, 0), (1, 1)], 'developer', 'develops', 'game')
>>> hetero_g = dgl.hetero_from_relations([g1, g2])
>>> print(hetero_g)
Graph(num_nodes={'user': 2, 'activity': 3, 'developer': 2, 'game': 2},
num_edges={('user', 'develops', 'activity'): 2, ('developer', 'develops', 'game'): 2},
metagraph=[('user', 'activity'), ('developer', 'game')])
We first convert the heterogeneous graph to a homogeneous graph.
>>> homo_g = dgl.to_homo(hetero_g)
>>> print(homo_g)
Graph(num_nodes=9, num_edges=4,
ndata_schemes={'_TYPE': Scheme(shape=(), dtype=torch.int64),
'_ID': Scheme(shape=(), dtype=torch.int64)}
edata_schemes={'_TYPE': Scheme(shape=(), dtype=torch.int64),
'_ID': Scheme(shape=(), dtype=torch.int64)})
>>> homo_g.ndata
{'_TYPE': tensor([0, 0, 1, 1, 1, 2, 2, 3, 3]), '_ID': tensor([0, 1, 0, 1, 2, 0, 1, 0, 1])}
Nodes 0, 1 for 'user', 2, 3, 4 for 'activity', 5, 6 for 'developer', 7, 8 for 'game'
>>> homo_g.edata
{'_TYPE': tensor([0, 0, 1, 1]), '_ID': tensor([0, 1, 0, 1])}
Edges 0, 1 for ('user', 'develops', 'activity'), 2, 3 for ('developer', 'develops', 'game')
Now convert the homogeneous graph back to a heterogeneous graph.
>>> hetero_g_2 = dgl.to_hetero(homo_g, hetero_g.ntypes, hetero_g.etypes)
>>> print(hetero_g_2)
Graph(num_nodes={'user': 2, 'activity': 3, 'developer': 2, 'game': 2},
num_edges={('user', 'develops', 'activity'): 2, ('developer', 'develops', 'game'): 2},
metagraph=[('user', 'activity'), ('developer', 'game')])
See Also
--------
dgl.to_homo
"""
# TODO(minjie): use hasattr to support DGLGraph input; should be fixed once
# DGLGraph is merged with DGLHeteroGraph
if (hasattr(G, 'ntypes') and len(G.ntypes) > 1
or hasattr(G, 'etypes') and len(G.etypes) > 1):
raise DGLError('The input graph should be homogenous and have only one '
' type of nodes and edges.')
num_ntypes = len(ntypes)
ntype_ids = F.asnumpy(G.ndata[ntype_field])
etype_ids = F.asnumpy(G.edata[etype_field])
# relabel nodes to per-type local IDs
ntype_count = np.bincount(ntype_ids, minlength=num_ntypes)
ntype_offset = np.insert(np.cumsum(ntype_count), 0, 0)
ntype_ids_sortidx = np.argsort(ntype_ids)
ntype_local_ids = np.zeros_like(ntype_ids)
node_groups = []
for i in range(num_ntypes):
node_group = ntype_ids_sortidx[ntype_offset[i]:ntype_offset[i+1]]
node_groups.append(node_group)
ntype_local_ids[node_group] = np.arange(ntype_count[i])
src, dst = G.all_edges(order='eid')
src = F.asnumpy(src)
dst = F.asnumpy(dst)
src_local = ntype_local_ids[src]
dst_local = ntype_local_ids[dst]
# a 2D tensor of shape (E, 3). Each row represents the (stid, etid, dtid) tuple.
edge_ctids = np.stack([ntype_ids[src], etype_ids, ntype_ids[dst]], 1)
# infer metagraph and canonical edge types
# No matter which branch it takes, the code will generate a 2D tensor of shape (E_m, 3),
# E_m is the set of all possible canonical edge tuples. Each row represents the
# (stid, dtid, dtid) tuple. We then compute a 2D tensor of shape (E, E_m) using the
# above ``edge_ctids`` matrix. Each element i,j indicates whether the edge i is of the
# canonical edge type j. We can then group the edges of the same type together.
if metagraph is None:
canonical_etids, _, etype_remapped = \
utils.make_invmap(list(tuple(_) for _ in edge_ctids), False)
etype_mask = (etype_remapped[None, :] == np.arange(len(canonical_etids))[:, None])
else:
ntypes_invmap = {nt: i for i, nt in enumerate(ntypes)}
etypes_invmap = {et: i for i, et in enumerate(etypes)}
canonical_etids = []
for i, (srctype, dsttype, etype) in enumerate(metagraph.edges(keys=True)):
srctype_id = ntypes_invmap[srctype]
etype_id = etypes_invmap[etype]
dsttype_id = ntypes_invmap[dsttype]
canonical_etids.append((srctype_id, etype_id, dsttype_id))
canonical_etids = np.array(canonical_etids)
etype_mask = (edge_ctids[None, :] == canonical_etids[:, None]).all(2)
edge_groups = [etype_mask[i].nonzero()[0] for i in range(len(canonical_etids))]
rel_graphs = []
for i, (stid, etid, dtid) in enumerate(canonical_etids):
src_of_etype = src_local[edge_groups[i]]
dst_of_etype = dst_local[edge_groups[i]]
if stid == dtid:
rel_graph = graph(
(src_of_etype, dst_of_etype), ntypes[stid], etypes[etid],
card=ntype_count[stid])
else:
rel_graph = bipartite(
(src_of_etype, dst_of_etype), ntypes[stid], etypes[etid], ntypes[dtid],
card=(ntype_count[stid], ntype_count[dtid]))
rel_graphs.append(rel_graph)
hg = hetero_from_relations(rel_graphs)
ntype2ngrp = {ntype : node_groups[ntid] for ntid, ntype in enumerate(ntypes)}
for ntid, ntype in enumerate(hg.ntypes):
hg._node_frames[ntid][NID] = F.tensor(ntype2ngrp[ntype])
for etid in range(len(hg.canonical_etypes)):
hg._edge_frames[etid][EID] = F.tensor(edge_groups[etid])
# features
for key, data in G.ndata.items():
for ntid, ntype in enumerate(hg.ntypes):
rows = F.copy_to(F.tensor(ntype2ngrp[ntype]), F.context(data))
hg._node_frames[ntid][key] = F.gather_row(data, rows)
for key, data in G.edata.items():
for etid in range(len(hg.canonical_etypes)):
rows = F.copy_to(F.tensor(edge_groups[etid]), F.context(data))
hg._edge_frames[etid][key] = F.gather_row(data, rows)
return hg
def to_homo(G):
"""Convert the given heterogeneous graph to a homogeneous graph.
The returned graph has only one type of nodes and edges.
Node and edge types are stored as features in the returned graph. Each feature
is an integer representing the type id, which can be used to retrieve the type
names stored in ``G.ntypes`` and ``G.etypes`` arguments.
Parameters
----------
G : DGLHeteroGraph
Input heterogeneous graph.
Returns
-------
DGLHeteroGraph
A homogeneous graph. The parent node and edge type/ID are stored in
columns ``dgl.NTYPE/dgl.NID`` and ``dgl.ETYPE/dgl.EID`` respectively.
Examples
--------
>>> follows_g = dgl.graph([(0, 1), (1, 2)], 'user', 'follows')
>>> devs_g = dgl.bipartite([(0, 0), (1, 1)], 'developer', 'develops', 'game')
>>> hetero_g = dgl.hetero_from_relations([follows_g, devs_g])
>>> homo_g = dgl.to_homo(hetero_g)
>>> homo_g.ndata
{'_TYPE': tensor([0, 0, 0, 1, 1, 2, 2]), '_ID': tensor([0, 1, 2, 0, 1, 0, 1])}
First three nodes for 'user', next two for 'developer' and the last two for 'game'
>>> homo_g.edata
{'_TYPE': tensor([0, 0, 1, 1]), '_ID': tensor([0, 1, 0, 1])}
First two edges for 'follows', next two for 'develops'
See Also
--------
dgl.to_hetero
"""
num_nodes_per_ntype = [G.number_of_nodes(ntype) for ntype in G.ntypes]
offset_per_ntype = np.insert(np.cumsum(num_nodes_per_ntype), 0, 0)
srcs = []
dsts = []
etype_ids = []
eids = []
ntype_ids = []
nids = []
total_num_nodes = 0
for ntype_id, ntype in enumerate(G.ntypes):
num_nodes = G.number_of_nodes(ntype)
total_num_nodes += num_nodes
ntype_ids.append(F.full_1d(num_nodes, ntype_id, F.int64, F.cpu()))
nids.append(F.arange(0, num_nodes))
for etype_id, etype in enumerate(G.canonical_etypes):
srctype, _, dsttype = etype
src, dst = G.all_edges(etype=etype, order='eid')
num_edges = len(src)
srcs.append(src + int(offset_per_ntype[G.get_ntype_id(srctype)]))
dsts.append(dst + int(offset_per_ntype[G.get_ntype_id(dsttype)]))
etype_ids.append(F.full_1d(num_edges, etype_id, F.int64, F.cpu()))
eids.append(F.arange(0, num_edges))
retg = graph((F.cat(srcs, 0), F.cat(dsts, 0)), card=total_num_nodes)
retg.ndata[NTYPE] = F.cat(ntype_ids, 0)
retg.ndata[NID] = F.cat(nids, 0)
retg.edata[ETYPE] = F.cat(etype_ids, 0)
retg.edata[EID] = F.cat(eids, 0)
# features
comb_nf = combine_frames(G._node_frames, range(len(G.ntypes)))
comb_ef = combine_frames(G._edge_frames, range(len(G.etypes)))
if comb_nf is not None:
retg.ndata.update(comb_nf)
if comb_ef is not None:
retg.edata.update(comb_ef)
return retg
############################################################
# Internal APIs
############################################################
def create_from_edges(u, v, utype, etype, vtype, urange=None, vrange=None, validate=False):
"""Internal function to create a graph from incident nodes with types.
utype could be equal to vtype
Parameters
----------
u : iterable of int
List of source node IDs.
v : iterable of int
List of destination node IDs.
utype : str
Source node type name.
etype : str
Edge type name.
vtype : str
Destination node type name.
urange : int, optional
The source node ID range. If None, the value is the maximum
of the source node IDs in the edge list plus 1. (Default: None)
vrange : int, optional
The destination node ID range. If None, the value is the
maximum of the destination node IDs in the edge list plus 1. (Default: None)
validate : bool, optional
If True, checks if node IDs are within range.
Returns
-------
DGLHeteroGraph
"""
u = utils.toindex(u)
v = utils.toindex(v)
if validate:
if urange is not None and urange <= int(F.asnumpy(F.max(u.tousertensor(), dim=0))):
raise DGLError('Invalid node id {} (should be less than cardinality {}).'.format(
urange, int(F.asnumpy(F.max(u.tousertensor(), dim=0)))))
if vrange is not None and vrange <= int(F.asnumpy(F.max(v.tousertensor(), dim=0))):
raise DGLError('Invalid node id {} (should be less than cardinality {}).'.format(
vrange, int(F.asnumpy(F.max(v.tousertensor(), dim=0)))))
urange = urange or (int(F.asnumpy(F.max(u.tousertensor(), dim=0))) + 1)
vrange = vrange or (int(F.asnumpy(F.max(v.tousertensor(), dim=0))) + 1)
if utype == vtype:
urange = vrange = max(urange, vrange)
num_ntypes = 1
else:
num_ntypes = 2
hgidx = heterograph_index.create_unitgraph_from_coo(num_ntypes, urange, vrange, u, v)
if utype == vtype:
return DGLHeteroGraph(hgidx, [utype], [etype])
else:
return DGLHeteroGraph(hgidx, [utype, vtype], [etype])
def create_from_edge_list(elist, utype, etype, vtype, urange=None, vrange=None, validate=False):
"""Internal function to create a heterograph from a list of edge tuples with types.
utype could be equal to vtype
Parameters
----------
elist : iterable of int pairs
List of (src, dst) node ID pairs.
utype : str
Source node type name.
etype : str
Edge type name.
vtype : str
Destination node type name.
urange : int, optional
The source node ID range. If None, the value is the maximum
of the source node IDs in the edge list plus 1. (Default: None)
vrange : int, optional
The destination node ID range. If None, the value is the
maximum of the destination node IDs in the edge list plus 1. (Default: None)
validate : bool, optional
If True, checks if node IDs are within range.
Returns
-------
DGLHeteroGraph
"""
if len(elist) == 0:
u, v = [], []
else:
u, v = zip(*elist)
u = list(u)
v = list(v)
return create_from_edges(u, v, utype, etype, vtype, urange, vrange, validate)
def create_from_scipy(spmat, utype, etype, vtype, with_edge_id=False):
"""Internal function to create a heterograph from a scipy sparse matrix with types.
Parameters
----------
spmat : scipy.sparse.spmatrix
The adjacency matrix whose rows represent sources and columns
represent destinations.
utype : str
Source node type name.
etype : str
Edge type name.
vtype : str
Destination node type name.
with_edge_id : bool
If True, the entries in the sparse matrix are treated as edge IDs.
Otherwise, the entries are ignored and edges will be added in
(source, destination) order.
validate : bool, optional
If True, checks if node IDs are within range.
Returns
-------
DGLHeteroGraph
"""
num_src, num_dst = spmat.shape
num_ntypes = 1 if utype == vtype else 2
if spmat.getformat() == 'coo':
row = utils.toindex(spmat.row)
col = utils.toindex(spmat.col)
hgidx = heterograph_index.create_unitgraph_from_coo(
num_ntypes, num_src, num_dst, row, col)
else:
spmat = spmat.tocsr()
indptr = utils.toindex(spmat.indptr)
indices = utils.toindex(spmat.indices)
# TODO(minjie): with_edge_id is only reasonable for csr matrix. How to fix?
data = utils.toindex(spmat.data if with_edge_id else list(range(len(indices))))
hgidx = heterograph_index.create_unitgraph_from_csr(
num_ntypes, num_src, num_dst, indptr, indices, data)
if num_ntypes == 1:
return DGLHeteroGraph(hgidx, [utype], [etype])
else:
return DGLHeteroGraph(hgidx, [utype, vtype], [etype])
def create_from_networkx(nx_graph,
ntype, etype,
edge_id_attr_name='id',
node_attrs=None,
edge_attrs=None):
"""Create a heterograph that has only one set of nodes and edges.
Parameters
----------
nx_graph : NetworkX graph
ntype : str
Type name for both source and destination nodes
etype : str
Type name for edges
edge_id_attr_name : str, optional
Key name for edge ids in the NetworkX graph. If not found, we
will consider the graph not to have pre-specified edge ids. (Default: 'id')
node_attrs : list of str
Names for node features to retrieve from the NetworkX graph (Default: None)
edge_attrs : list of str
Names for edge features to retrieve from the NetworkX graph (Default: None)
Returns
-------
g : DGLHeteroGraph
"""
if not nx_graph.is_directed():
nx_graph = nx_graph.to_directed()
# Relabel nodes using consecutive integers
nx_graph = nx.convert_node_labels_to_integers(nx_graph, ordering='sorted')
# nx_graph.edges(data=True) returns src, dst, attr_dict
if nx_graph.number_of_edges() > 0:
has_edge_id = edge_id_attr_name in next(iter(nx_graph.edges(data=True)))[-1]
else:
has_edge_id = False
if has_edge_id:
num_edges = nx_graph.number_of_edges()
src = np.zeros((num_edges,), dtype=np.int64)
dst = np.zeros((num_edges,), dtype=np.int64)
for u, v, attr in nx_graph.edges(data=True):
eid = attr[edge_id_attr_name]
src[eid] = u
dst[eid] = v
else:
src = []
dst = []
for e in nx_graph.edges:
src.append(e[0])
dst.append(e[1])
src = utils.toindex(src)
dst = utils.toindex(dst)
num_nodes = nx_graph.number_of_nodes()
g = create_from_edges(src, dst, ntype, etype, ntype, num_nodes, num_nodes)
# handle features
# copy attributes
def _batcher(lst):
if F.is_tensor(lst[0]):
return F.cat([F.unsqueeze(x, 0) for x in lst], dim=0)
else:
return F.tensor(lst)
if node_attrs is not None:
# mapping from feature name to a list of tensors to be concatenated
attr_dict = defaultdict(list)
for nid in range(g.number_of_nodes()):
for attr in node_attrs:
attr_dict[attr].append(nx_graph.nodes[nid][attr])
for attr in node_attrs:
g.ndata[attr] = _batcher(attr_dict[attr])
if edge_attrs is not None:
# mapping from feature name to a list of tensors to be concatenated
attr_dict = defaultdict(lambda: [None] * g.number_of_edges())
# each defaultdict value is initialized to be a list of None
# None here serves as placeholder to be replaced by feature with
# corresponding edge id
if has_edge_id:
num_edges = g.number_of_edges()
for _, _, attrs in nx_graph.edges(data=True):
if attrs[edge_id_attr_name] >= num_edges:
raise DGLError('Expect the pre-specified edge ids to be'
' smaller than the number of edges --'
' {}, got {}.'.format(num_edges, attrs['id']))
for key in edge_attrs:
attr_dict[key][attrs['id']] = attrs[key]
else:
# XXX: assuming networkx iteration order is deterministic
# so the order is the same as graph_index.from_networkx
for eid, (_, _, attrs) in enumerate(nx_graph.edges(data=True)):
for key in edge_attrs:
attr_dict[key][eid] = attrs[key]
for attr in edge_attrs:
for val in attr_dict[attr]:
if val is None:
raise DGLError('Not all edges have attribute {}.'.format(attr))
g.edata[attr] = _batcher(attr_dict[attr])
return g
def create_from_networkx_bipartite(nx_graph,
utype, etype, vtype,
edge_id_attr_name='id',
node_attrs=None,
edge_attrs=None):
"""Create a heterograph that has one set of source nodes, one set of
destination nodes and one set of edges.
Parameters
----------
nx_graph : NetworkX graph
The input graph must follow the bipartite graph convention of networkx.
Each node has an attribute ``bipartite`` with values 0 and 1 indicating
which set it belongs to. Only edges from node set 0 to node set 1 are
added to the returned graph.
utype : str
Source node type name.
etype : str
Edge type name.
vtype : str
Destination node type name.
edge_id_attr_name : str, optional
Key name for edge ids in the NetworkX graph. If not found, we
will consider the graph not to have pre-specified edge ids. (Default: 'id')
node_attrs : list of str
Names for node features to retrieve from the NetworkX graph (Default: None)
edge_attrs : list of str
Names for edge features to retrieve from the NetworkX graph (Default: None)
Returns
-------
g : DGLHeteroGraph
"""
if not nx_graph.is_directed():
nx_graph = nx_graph.to_directed()
top_nodes = {n for n, d in nx_graph.nodes(data=True) if d['bipartite'] == 0}
bottom_nodes = set(nx_graph) - top_nodes
top_nodes = sorted(top_nodes)
bottom_nodes = sorted(bottom_nodes)
top_map = {n : i for i, n in enumerate(top_nodes)}
bottom_map = {n : i for i, n in enumerate(bottom_nodes)}
if nx_graph.number_of_edges() > 0:
has_edge_id = edge_id_attr_name in next(iter(nx_graph.edges(data=True)))[-1]
else:
has_edge_id = False
if has_edge_id:
num_edges = nx_graph.number_of_edges()
src = np.zeros((num_edges,), dtype=np.int64)
dst = np.zeros((num_edges,), dtype=np.int64)
for u, v, attr in nx_graph.edges(data=True):
eid = attr[edge_id_attr_name]
src[eid] = top_map[u]
dst[eid] = bottom_map[v]
else:
src = []
dst = []
for e in nx_graph.edges:
if e[0] in top_map:
src.append(top_map[e[0]])
dst.append(bottom_map[e[1]])
src = utils.toindex(src)
dst = utils.toindex(dst)
g = create_from_edges(src, dst, utype, etype, vtype, len(top_nodes), len(bottom_nodes))
# TODO attributes
assert node_attrs is None, 'Retrieval of node attributes are not supported yet.'
assert edge_attrs is None, 'Retrieval of edge attributes are not supported yet.'
return g
def to_networkx(g, node_attrs=None, edge_attrs=None):
"""Convert to networkx graph.
The edge id will be saved as the 'id' edge attribute.
Parameters
----------
g : DGLGraph or DGLHeteroGraph
For DGLHeteroGraphs, we currently only support the
case of one node type and one edge type.
node_attrs : iterable of str, optional
The node attributes to be copied. (Default: None)
edge_attrs : iterable of str, optional
The edge attributes to be copied. (Default: None)
Returns
-------
networkx.DiGraph
The nx graph
"""
return g.to_networkx(node_attrs, edge_attrs)
| 38.682879 | 96 | 0.608786 |
10b529de97d39871333ed0603d47ed77d1aa9876 | 3,207 | py | Python | generated-libraries/python/netapp/clock/__init__.py | radekg/netapp-ontap-lib-get | 6445ebb071ec147ea82a486fbe9f094c56c5c40d | [
"MIT"
] | 2 | 2017-03-28T15:31:26.000Z | 2018-08-16T22:15:18.000Z | generated-libraries/python/netapp/clock/__init__.py | radekg/netapp-ontap-lib-get | 6445ebb071ec147ea82a486fbe9f094c56c5c40d | [
"MIT"
] | null | null | null | generated-libraries/python/netapp/clock/__init__.py | radekg/netapp-ontap-lib-get | 6445ebb071ec147ea82a486fbe9f094c56c5c40d | [
"MIT"
] | null | null | null | from netapp.connection import NaConnection
from o_timezone import OTimezone # 0 properties
class ClockConnection(NaConnection):
def clock_set_timezone(self, timezone):
"""
Set current timezone to the specified timezone.
:param timezone: Name of the timezone value which has to be set as current
timezone value. A timezone can have one of the two formats:
<ol>
<li>"Using a location string specified in Arthur David
Olsen's public domain time zone database. For example,
"Americas/New_York" represents most of the Eastern
Time Zone.";
<li>"A traditional time zone abbreviation incorporating
default rules for daylight savings time. For example,
"EST5EDT" for the US Eastern Time Zone.";
</ol>
"""
return self.request( "clock-set-timezone", {
'timezone': [ timezone, 'timezone', [ basestring, 'None' ], False ],
}, {
} )
def clock_get_timezone(self):
"""
Gets current timezone and timezone file version.
"""
return self.request( "clock-get-timezone", {
}, {
'timezone': [ basestring, False ],
'timezone-version': [ basestring, False ],
'timezone-UTC': [ basestring, False ],
} )
def clock_get_clock(self, is_compliance_clock=None):
"""
gets current date and time from filer.
:param is_compliance_clock: If true, then local-time and utc-time are values for the
compliance clock, otherwise they are values for the local clock.
Default is false.
Note: This field is deprecated in Data ONTAP 8.1 and later.
If true, the operation will fail with error EOPNOTSUPPORTED.
Clients should use the API snaplock-get-system-compliance-clock or
snaplock-get-volume-compliance-clock as applicable to get the
compliance clock time.
"""
return self.request( "clock-get-clock", {
'is_compliance_clock': [ is_compliance_clock, 'is-compliance-clock', [ bool, 'None' ], False ],
}, {
'utc-time': [ int, False ],
'local-time': [ int, False ],
} )
def clock_set_clock(self, is_utc_clock, time):
"""
Set current date and time to the specified date and time.
:param is_utc_clock: If this is true, then clock is given in UTC (universal time)
instead of local time.
:param time: Actual value of the date and time which has to be set as the
current date and time on filer. Value will be seconds since
Midnight, 1/1/1970. Depending on the time zone and
clock settings, this might be negative by up to 12 hours.
"""
return self.request( "clock-set-clock", {
'is_utc_clock': [ is_utc_clock, 'is-utc-clock', [ bool, 'None' ], False ],
'time': [ time, 'time', [ int, 'None' ], False ],
}, {
} )
| 42.76 | 107 | 0.568756 |
57ced62a12dc27102896518c4c69b5b7296bf9b9 | 17,766 | py | Python | code/insert/insert_views.py | GGGGFan/CS564-Course-Project-A-Database-Management-System-for-Electronic-Health-Records-in-ICU | 11ae6c67e761a87c0584c6ef7278cb93ec708748 | [
"Apache-2.0"
] | null | null | null | code/insert/insert_views.py | GGGGFan/CS564-Course-Project-A-Database-Management-System-for-Electronic-Health-Records-in-ICU | 11ae6c67e761a87c0584c6ef7278cb93ec708748 | [
"Apache-2.0"
] | null | null | null | code/insert/insert_views.py | GGGGFan/CS564-Course-Project-A-Database-Management-System-for-Electronic-Health-Records-in-ICU | 11ae6c67e761a87c0584c6ef7278cb93ec708748 | [
"Apache-2.0"
] | null | null | null | import random
from django.shortcuts import render
from django.db import connection
from django.contrib import messages
from django.http import HttpResponseRedirect
import json
import sys
sys.path.append('../query')
from query.models import Stay, Patients
# This the function django use to guide the page to insert.html
def insert(request):
return render(request, 'insert/insert.html')
# This is the functon to generate a new patient
def new_patient(request):
# Generate a new id
with connection.cursor() as cursor:
cursor.execute("SELECT DISTINCT uniquepid FROM patients WHERE uniquepid LIKE '%999-'")
ptids = cursor.fetchall()
# because uniquepid is in the format of 123-12345
ptids = [i[4:] for i in ptids]
new_ptid = str(random.randint(10000,99999))
while new_ptid in ptids:
new_ptid = random.randint(10000,99999)
new_ptid = '999-' + new_ptid # we assign new id to 999- area
new_patient = Patients.objects.create(uniquepid=new_ptid)
messages.success(request, 'Patient ' + str(new_ptid) + ' has been added!')
next = request.META.get('HTTP_REFERER', '/')
return HttpResponseRedirect(next)
# This is the function to generate a new stay for the specific patient
def new_stay(request):
ptid = request.GET['ptid']
try:
pt_obj = Patients.objects.get(uniquepid=ptid)
except:
messages.success(request, 'Please offer a valid uniquepid')
next = request.META.get('HTTP_REFERER', '/')
return HttpResponseRedirect(next)
# Retrive existing data
with connection.cursor() as cursor:
cursor.execute("SELECT * FROM stay WHERE uniquepid= %s", [ptid])
stay = cursor.fetchone()
new_age = request.GET['new_age']
# if an attribute is leaving blank, display the previously recored data
if not new_age and stay:
new_age = stay[2]
new_admisionweight = request.GET['new_admisionweight']
if not new_admisionweight and stay:
new_admisionweight = stay[6]
new_admisionheight = request.GET['new_admisionheight']
if not new_admisionheight and stay:
new_admisionheight = stay[4]
new_unittype = request.GET['new_unittype']
if not new_unittype and stay:
new_unittype = stay[5]
new_dischargestatus = request.GET['new_dischargestatus']
if not new_dischargestatus and stay:
new_dischargestatus = stay[8]
new_gender = request.GET['new_gender']
if not new_gender and stay:
new_gender = stay[1]
new_ethnicity = request.GET['new_ethnicity']
if not new_ethnicity and stay:
new_ethnicity = stay[3]
# Create new stay
# Generate a new id
with connection.cursor() as cursor:
cursor.execute("SELECT DISTINCT patientunitstayid FROM stay WHERE patientunitstayid IS NOT NULL")
ptids = cursor.fetchall()
ptids = [i[0] for i in ptids]
new_stayid = random.randint(100000,999999)
while new_stayid in ptids:
new_stayid = random.randint(100000,999999)
del ptids
new_stay = Stay.objects.create(patientunitstayid=new_stayid, uniquepid=ptid, gender=new_gender, age=new_age, ethnicity=new_ethnicity, admissionweight=new_admisionweight,
admissionheight=new_admisionheight, unittype=new_unittype, unitdischargestatus=new_dischargestatus)
return render(request, 'insert/new_stay.html', {'stayid': new_stayid,
'ptid': ptid,
'new_age': new_age,
'new_gender': new_gender,
'new_ethnicity': new_ethnicity,
'new_admisionweight':new_admisionweight,
'new_admisionheight': new_admisionheight,
'new_unittype': new_unittype,
'new_dischargestatus': new_dischargestatus})
# This is the function for search the data filed id, like labid, medicationid and etc. under a specific stay.
def modify_data(request):
stayid = request.GET['stayid']
datafield = request.GET['datafield']
try:
Stay_obj = Stay.objects.get(patientunitstayid=stayid)
except:
messages.success(request, 'Please provide valid stayid!')
next = request.META.get('HTTP_REFERER', '/')
return HttpResponseRedirect(next)
# Get the ID List
datafield = request.GET['datafield']
if datafield == 'diagnosis':
with connection.cursor() as cursor:
cursor.execute("SELECT DISTINCT diagnosisid FROM diagnosis WHERE diagnosisid IS NOT NULL AND patientunitstayid = %s", (stayid,))
dgids = cursor.fetchall()
elif datafield == 'lab':
with connection.cursor() as cursor:
cursor.execute("SELECT DISTINCT labid FROM lab WHERE labid IS NOT NULL AND patientunitstayid = %s", (stayid,))
dgids = cursor.fetchall()
elif datafield == 'microlab':
with connection.cursor() as cursor:
cursor.execute("SELECT DISTINCT microlabid FROM microlab WHERE microlabid IS NOT NULL AND patientunitstayid = %s", (stayid,))
dgids = cursor.fetchall()
elif datafield == 'medication':
with connection.cursor() as cursor:
cursor.execute("SELECT DISTINCT medicationid FROM medication WHERE medicationid IS NOT NULL AND patientunitstayid = %s", (stayid,))
dgids = cursor.fetchall()
elif datafield == 'allergy':
with connection.cursor() as cursor:
cursor.execute("SELECT DISTINCT allergyid FROM allergy WHERE allergyid IS NOT NULL AND patientunitstayid = %s", (stayid,))
dgids = cursor.fetchall()
else:
pass
print(dgids)
listA = []
for i in dgids:
listA.append(i[0])
print(listA)
typelist = json.dumps(listA)
print(typelist)
return render(request, 'insert/new_modified_id_selection.html', {'typeid': typelist, 'stayid':stayid, 'datafield': datafield})
# This is the function to find the data under the specific data field ID.
def modify_data_select(request):
datafield = request.GET['datafield']
idname = request.GET['typeID']
if datafield == "diagnosis":
idtype = "diagnosisid"
with connection.cursor() as cursor:
cursor.execute("SELECT * FROM diagnosis WHERE diagnosisid = %s", (idname,))
dic = dictfetchall(cursor)
elif datafield == "lab":
idtype = "labid"
with connection.cursor() as cursor:
cursor.execute("SELECT * FROM lab WHERE labid = %s", (idname,))
dic = dictfetchall(cursor)
elif datafield == "microlab":
idtype = "microlabid"
with connection.cursor() as cursor:
cursor.execute("SELECT * FROM microlab WHERE microlabid = %s", (idname,))
dic = dictfetchall(cursor)
elif datafield == "medication":
idtype = "medicationid"
with connection.cursor() as cursor:
cursor.execute("SELECT * FROM medication WHERE medicationid = %s", (idname,))
dic = dictfetchall(cursor)
elif datafield == "allergy":
idtype = "allergyid"
with connection.cursor() as cursor:
cursor.execute("SELECT * FROM allergy WHERE allergyid = %s", (idname,))
dic = dictfetchall(cursor)
return render(request, 'insert/new_modified_data.html', {'datafield': datafield, 'typeID': idname, 'dictAttri': json.dumps(dic[0])})
# This the function to modify the data based on provided data.
def modify_data_modified(request):
datafield = request.GET['datafield']
typeID = request.GET['typeID']
print(datafield)
print(typeID)
if request.GET['datafield'] == 'diagnosis':
icd9code = request.GET['icd9code']
diagnosisoffset = request.GET['diagnosisoffset']
print("icd9code is: " + str(icd9code))
print(diagnosisoffset)
# Update
with connection.cursor() as cursor:
cursor.execute("""
UPDATE diagnosis SET
icd9code = %s,
diagnosisOffset = %s
WHERE diagnosisid = %s;
""",(icd9code, diagnosisoffset,typeID,))
elif request.GET['datafield'] == 'lab':
labType = request.GET['labType']
labName = request.GET['labName']
labResult = request.GET['labResult']
labMeasureNameSystem = request.GET['labMeasureNameSystem']
labResultOffset = request.GET['labResultOffset']
# Update
with connection.cursor() as cursor:
cursor.execute("""
UPDATE lab SET
labresultoffset = %s,
labtypeid = %s,
labname = %s,
labresult = %s,
labmeasurenamesystem = %s
WHERE
labid = %s;
""", (labResultOffset, labType, labName, labResult, labMeasureNameSystem, typeID, ))
elif request.GET['datafield'] == 'microlab':
organism = request.GET['organism']
cultureSite = request.GET['cultureSite']
sensitivityLevel = request.GET['sensitivityLevel']
antibiotic = request.GET['antibiotic']
cultureTakenOffset = request.GET['cultureTakenOffset']
# Insert
with connection.cursor() as cursor:
cursor.execute("""
UPDATE microlab SET
organism = %s,
cultureSite = %s,
sensitivityLevel = %s,
antibiotic = %s,
cultureTakenOffset = %s
WHERE
microlabid = %s
""", (organism, cultureSite, sensitivityLevel, antibiotic, cultureTakenOffset,typeID, ))
elif request.GET['datafield'] == 'medication':
routeAdmin = request.GET['routeAdmin']
drugName = request.GET['drugName']
dosage = request.GET['dosage']
drugoffset = request.GET['drugOffset']
# Insert
with connection.cursor() as cursor:
cursor.execute("""
UPDATE medication SET
routeAdmin = %s,
drugName = %s,
dosage = %s,
drugoffset = %s
WHERE
medicationid = %s
""", (routeAdmin, drugName, dosage, drugoffset,typeID,))
elif request.GET['datafield'] == 'allergy':
allergyName = request.GET['allergyName']
allergyType = int(request.GET['allergyType'])
allergyOffset = int(request.GET['allergyOffset'])
# Insert
with connection.cursor() as cursor:
cursor.execute("""
UPDATE allergy SET
allergyname = %s,
allergytype = %s,
allergyoffset = %s
WHERE
allergyid = %s
""", (allergyName, allergyType, allergyOffset,typeID,))
else:
pass
messages.success(request, 'Record has been modified!')
next = request.META.get('HTTP_REFERER', '/')
return HttpResponseRedirect(next)
# This is the function for guide the page to new_data.html page with stayid and datafield.
def new_data(request):
stayid = request.GET['stayid']
try:
Stay_obj = Stay.objects.get(patientunitstayid=stayid)
except:
return render(request, 'insert/insert.html', {'no_stay':1})
datafield = request.GET['datafield']
return render(request, 'insert/new_data.html', {'datafield':datafield, 'stayid':stayid})
# This is the function for add new data.
def data_added(request):
stayid = request.GET['stayid']
if request.GET['datafield'] == 'diagnosis':
icd9code = request.GET['icd9code']
diagnosisoffset = request.GET['diagnosisoffset']
# Generate a new id
with connection.cursor() as cursor:
cursor.execute("SELECT DISTINCT diagnosisid FROM diagnosis WHERE diagnosisid IS NOT NULL")
dgids = cursor.fetchall()
dgids = [i[0] for i in dgids]
new_dgid = random.randint(100000,999999)
while new_dgid in dgids:
new_dgid = random.randint(1000000,9999999)
del dgids
# Insert
with connection.cursor() as cursor:
cursor.execute("""
INSERT INTO diagnosis (
diagnosisid,
patientunitstayid,
icd9code,
diagnosisOffset)
VALUES
(%s,%s,%s,%s)
""",(new_dgid, stayid, icd9code, diagnosisoffset,))
elif request.GET['datafield'] == 'lab':
labType = request.GET['labType']
labName = request.GET['labName']
labResult = request.GET['labResult']
labMeasureNameSystem = request.GET['labMeasureNameSystem']
labResultOffset = request.GET['labResultOffset']
# Generate a new id
with connection.cursor() as cursor:
cursor.execute("SELECT DISTINCT labid FROM lab WHERE labid IS NOT NULL")
dgids = cursor.fetchall()
dgids = [i[0] for i in dgids]
new_dgid = random.randint(100000,999999)
while new_dgid in dgids:
new_dgid = random.randint(1000000,9999999)
del dgids
# Insert
with connection.cursor() as cursor:
cursor.execute("""
INSERT INTO lab (
labid,
patientunitstayid,
labresultoffset,
labtypeid,
labname,
labresult,
labmeasurenamesystem)
VALUES
(%s,%s,%s,%s,%s,%s,%s)
""", (new_dgid, stayid, labResultOffset, labType, labName, labResult, labMeasureNameSystem,))
elif request.GET['datafield'] == 'microlab':
organism = request.GET['organism']
cultureSite = request.GET['cultureSite']
sensitivityLevel = request.GET['sensitivityLevel']
antibiotic = request.GET['antibiotic']
cultureTakenOffset = request.GET['cultureTakenOffset']
# Generate a new id
with connection.cursor() as cursor:
cursor.execute("SELECT DISTINCT microlabid FROM microlab WHERE microlabid IS NOT NULL")
dgids = cursor.fetchall()
dgids = [i[0] for i in dgids]
new_dgid = random.randint(100000,999999)
while new_dgid in dgids:
new_dgid = random.randint(1000000,9999999)
del dgids
# Insert
with connection.cursor() as cursor:
cursor.execute("""
INSERT INTO microlab (
microlabid,
patientunitstayid,
organism,
cultureSite,
sensitivityLevel,
antibiotic,
cultureTakenOffset
)
VALUES
(%s,%s,%s,%s,%s,%s,%s)
""", (new_dgid, stayid, organism, cultureSite, sensitivityLevel, antibiotic, cultureTakenOffset,))
elif request.GET['datafield'] == 'medication':
routeAdmin = request.GET['routeAdmin']
drugName = request.GET['drugName']
dosage = request.GET['dosage']
drugoffset = request.GET['drugOffset']
# Generate a new id
with connection.cursor() as cursor:
cursor.execute("SELECT DISTINCT medicationid FROM medication WHERE medicationid IS NOT NULL")
dgids = cursor.fetchall()
dgids = [i[0] for i in dgids]
new_dgid = random.randint(100000,999999)
while new_dgid in dgids:
new_dgid = random.randint(1000000,9999999)
del dgids
# Insert
with connection.cursor() as cursor:
cursor.execute("""
INSERT INTO medication (
medicationid,
patientunitstayid,
routeAdmin,
drugName,
dosage,
drugoffset
)
VALUES
(%s,%s,%s,%s,%s,%s)
""", (new_dgid, stayid, routeAdmin, drugName, dosage, drugoffset,))
elif request.GET['datafield'] == 'allergy':
allergyName = request.GET['allergyName']
allergyType = int(request.GET['allergyType'])
allergyOffset = int(request.GET['allergyOffset'])
# Generate a new id
with connection.cursor() as cursor:
cursor.execute("SELECT DISTINCT allergyid FROM allergy WHERE allergyid IS NOT NULL")
dgids = cursor.fetchall()
dgids = [i[0] for i in dgids]
new_dgid = random.randint(100000,999999)
while new_dgid in dgids:
new_dgid = random.randint(1000000,9999999)
del dgids
# Insert
with connection.cursor() as cursor:
cursor.execute("""
INSERT INTO allergy
(
allergyid,
patientunitstayid,
allergyname,
allergytype,
allergyoffset
)
VALUES
(%s,%s,%s,%s,%s);
""", (new_dgid, stayid, allergyName, allergyType, allergyOffset,))
else:
pass
messages.success(request, 'New Record has been added!')
next = request.META.get('HTTP_REFERER', '/')
return HttpResponseRedirect(next)
# Function for selecting dictionary from SQL
def dictfetchall(cursor):
"Return all rows from a cursor as a dict"
columns = [col[0] for col in cursor.description]
return [
dict(zip(columns, row))
for row in cursor.fetchall()
]
| 39.744966 | 173 | 0.591861 |
d4a2758b58b260ec4a18b8c5fcd45760dd7b1bd9 | 13,931 | py | Python | exopy/measurement/plugin.py | rassouly/exopy | fa5497208b99f7a3474f0e14824a6cf6ab825dea | [
"BSD-3-Clause"
] | 16 | 2018-03-20T09:06:23.000Z | 2021-09-08T18:46:15.000Z | exopy/measurement/plugin.py | rassouly/exopy | fa5497208b99f7a3474f0e14824a6cf6ab825dea | [
"BSD-3-Clause"
] | 118 | 2015-05-13T07:50:04.000Z | 2018-02-14T17:37:20.000Z | exopy/measurement/plugin.py | rassouly/exopy | fa5497208b99f7a3474f0e14824a6cf6ab825dea | [
"BSD-3-Clause"
] | 11 | 2018-03-02T11:17:26.000Z | 2021-06-23T22:25:40.000Z | # -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright 2015-2018 by Exopy Authors, see AUTHORS for more details.
#
# Distributed under the terms of the BSD license.
#
# The full license is in the file LICENCE, distributed with this software.
# -----------------------------------------------------------------------------
"""Plugin handling all measurement related functions.
"""
import logging
import os
from functools import partial
from atom.api import Typed, Str, List, ForwardTyped, Enum, Bool, Dict
from ..utils.plugin_tools import (HasPreferencesPlugin, ExtensionsCollector,
make_extension_validator)
from .engines.api import Engine
from .monitors.api import Monitor
from .hooks.api import PreExecutionHook, PostExecutionHook
from .editors.api import Editor
from .processor import MeasurementProcessor
from .container import MeasurementContainer
logger = logging.getLogger(__name__)
ENGINES_POINT = 'exopy.measurement.engines'
MONITORS_POINT = 'exopy.measurement.monitors'
PRE_HOOK_POINT = 'exopy.measurement.pre-execution'
POST_HOOK_POINT = 'exopy.measurement.post-execution'
EDITORS_POINT = 'exopy.measurement.editors'
def _workspace():
from .workspace.workspace import MeasurementSpace
return MeasurementSpace
class TaskRuntimeContext():
"""A context manager used to give temporary access to a task runtime
(e.g. driver) to a task.
"""
def __init__(self, dependencies, task):
self.dependencies = dependencies
self.task = task
def __enter__(self):
res, msg, errors = self.dependencies.collect_task_runtimes(self.task)
if res:
self.task.root.run_time = self.dependencies.get_runtime_dependencies('main')
else:
logger.error(msg)
logger.error(errors)
return res, msg, errors
def __exit__(self, type, value, traceback):
self.task.root.run_time = {}
self.dependencies.release_runtimes()
self.dependencies.reset()
class MeasurementPlugin(HasPreferencesPlugin):
"""The measurement plugin is reponsible for managing all measurement
related extensions and handling measurement execution.
"""
#: Reference to the workspace if any.
workspace = ForwardTyped(_workspace)
#: Reference to the last directory from/in which a measurement was
#: loaded/saved
path = Str().tag(pref=True)
#: Currently edited measurements.
edited_measurements = Typed(MeasurementContainer, ())
#: Currently enqueued measurements.
enqueued_measurements = Typed(MeasurementContainer, ())
#: Measurement processor responsible for measurement execution.
processor = Typed(MeasurementProcessor)
#: List of currently available engines.
engines = List()
#: Currently selected engine represented by its id.
selected_engine = Str().tag(pref=True)
#: What to do of the engine when there is no more measurement to perform.
engine_policy = Enum('stop', 'sleep').tag(pref=True)
#: List of currently available pre-execution hooks.
pre_hooks = List()
#: Default pre-execution hooks to use for new measurements.
default_pre_hooks = List().tag(pref=True)
#: List of currently available monitors.
monitors = List()
#: Default monitors to use for new measurements.
default_monitors = List(default=['exopy.text_monitor']).tag(pref=True)
#: Always show monitors on measurement startup.
auto_show_monitors = Bool(True).tag(pref=True)
#: List of currently available post-execution hooks.
post_hooks = List()
#: Default post-execution hooks to use for new measurements.
default_post_hooks = List().tag(pref=True)
#: List of currently available editors.
editors = List()
# TODO add the possibility to deactivate some editors.
def start(self):
"""Start the plugin lifecycle by collecting all contributions.
"""
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('exopy.app.errors.enter_error_gathering')
checker = make_extension_validator(Engine, ('new',))
self._engines = ExtensionsCollector(workbench=self.workbench,
point=ENGINES_POINT,
ext_class=Engine,
validate_ext=checker)
self._engines.start()
checker = make_extension_validator(Editor, ('new', 'is_meant_for'))
self._editors = ExtensionsCollector(workbench=self.workbench,
point=EDITORS_POINT,
ext_class=Editor,
validate_ext=checker)
self._editors.start()
checker = make_extension_validator(PreExecutionHook, ('new',))
self._pre_hooks = ExtensionsCollector(workbench=self.workbench,
point=PRE_HOOK_POINT,
ext_class=PreExecutionHook,
validate_ext=checker)
self._pre_hooks.start()
checker = make_extension_validator(Monitor, ('new',))
self._monitors = ExtensionsCollector(workbench=self.workbench,
point=MONITORS_POINT,
ext_class=Monitor,
validate_ext=checker)
self._monitors.start()
checker = make_extension_validator(PostExecutionHook, ('new',))
self._post_hooks = ExtensionsCollector(workbench=self.workbench,
point=POST_HOOK_POINT,
ext_class=PostExecutionHook,
validate_ext=checker)
self._post_hooks.start()
for contrib in ('engines', 'editors', 'pre_hooks', 'monitors',
'post_hooks'):
self._update_contribs(contrib, None)
# This call is delayed till there to avoid loading the preferences
# before discovering the contributions (would be an issue for engine).
super(MeasurementPlugin, self).start()
state = core.invoke_command('exopy.app.states.get',
{'state_id': 'exopy.app.directory'})
m_dir = os.path.join(state.app_directory, 'measurement')
# Create measurement subfolder if it does not exist.
if not os.path.isdir(m_dir):
os.mkdir(m_dir)
s_dir = os.path.join(m_dir, 'saved_measurements')
# Create saved_measurements subfolder if it does not exist.
if not os.path.isdir(s_dir):
os.mkdir(s_dir)
if not os.path.isdir(self.path):
self.path = s_dir
cmd = 'exopy.app.errors.signal'
for contrib in ('pre_hooks', 'monitors', 'post_hooks'):
default = getattr(self, 'default_'+contrib)
avai_default = [d for d in default
if d in getattr(self, contrib)]
if default != avai_default:
msg = 'The following {} have not been found : {}'
missing = set(default) - set(avai_default)
core.invoke_command(cmd, dict(kind='error',
message=msg.format(contrib,
missing)))
setattr(self, 'default_'+contrib, avai_default)
for contrib in ('engines', 'editors', 'pre_hooks', 'monitors',
'post_hooks'):
getattr(self, '_'+contrib).observe('contributions',
partial(self._update_contribs,
contrib))
core.invoke_command('exopy.app.errors.exit_error_gathering')
def stop(self):
"""Stop the plugin and remove all observers.
"""
# Close the monitors window.
if self.processor.monitors_window:
self.processor.monitors_window.hide()
self.processor.monitors_window.close()
self.processor.monitors_window = None
for contrib in ('engines', 'editors', 'pre_hooks', 'monitors',
'post_hooks'):
getattr(self, '_'+contrib).stop()
def get_declarations(self, kind, ids):
"""Get the declarations of engines/editors/tools.
If an id does not correspond to a known declarations it will be omitted
from the return value, but no error will be raised. This is because the
user can easily know which declarations exist by looking at the
appropriate member of the plugin.
Parameters
----------
kind : {'engine', 'editor', 'pre-hook', 'monitor', 'post-hook'}
Kind of object to create.
ids : list
Ids of the declarations to return.
Returns
-------
declarations : dict
Declarations stored in a dict by id.
"""
kinds = ('engine', 'editor', 'pre-hook', 'monitor', 'post-hook')
if kind not in kinds:
msg = 'Expected kind must be one of {}, not {}.'
raise ValueError(msg.format(kinds, kind))
decls = getattr(self, '_'+kind.replace('-', '_')+'s').contributions
return {k: v for k, v in decls.items() if k in ids}
def create(self, kind, id, default=True):
"""Create a new instance of an engine/editor/tool.
Parameters
----------
kind : {'engine', 'editor', 'pre-hook', 'monitor', 'post-hook'}
Kind of object to create.
id : unicode
Id of the object to create.
default : bool, optional
Whether to use default parameters or not when creating the object.
Returns
-------
obj : BaseEngine|BaseMeasurementTool|BaseEditor
New instance of the requested object.
Raises
------
ValueError :
Raised if the provided kind or id in incorrect.
"""
kinds = ('engine', 'editor', 'pre-hook', 'monitor', 'post-hook')
if kind not in kinds:
msg = 'Expected kind must be one of {}, not {}.'
raise ValueError(msg.format(kinds, kind))
decls = getattr(self, '_'+kind.replace('-', '_')+'s').contributions
if id not in decls:
raise ValueError('Unknown {} : {}'.format(kind, id))
return decls[id].new(self.workbench, default)
def find_next_measurement(self):
"""Find the next runnable measurement in the queue.
Returns
-------
measurement : Measurement|None
First valid measurement in the queue or None if there is no
available measurement.
"""
enqueued_measurements = self.enqueued_measurements.measurements
i = 0
measurement = None
# Look for a measurement not being currently edited. (Can happen if the
# user is editing the second measurement when the first measurement
# ends).
while i < len(enqueued_measurements):
measurement = enqueued_measurements[i]
if measurement.status != 'READY':
i += 1
measurement = None
else:
break
return measurement
def get_task_runtime(self, measurement, task):
"""Give temporary access to a task runtime
Parameters
----------
measurement: Measurement
Measurement used to analyse and collect runtime
task: Task:
Task whose dependencies are going to be analysed
and collected. Must be part of the measurement.
Returns
-------
runtime: TaskRuntimeContext
A context manager that acquires and releases the task
dependencies.
"""
return TaskRuntimeContext(measurement.dependencies, task)
# =========================================================================
# --- Private API ---------------------------------------------------------
# =========================================================================
#: Collector of engines.
_engines = Typed(ExtensionsCollector)
#: Collector of editors.
_editors = Typed(ExtensionsCollector)
#: Collector of pre-execution hooks.
_pre_hooks = Typed(ExtensionsCollector)
#: Collectorsof monitors.
_monitors = Typed(ExtensionsCollector)
#: Collector of post-execution hooks.
_post_hooks = Typed(ExtensionsCollector)
#: Workspace state infos kept to preserve layout.
_workspace_state = Dict()
def _post_setattr_selected_engine(self, old, new):
"""Ensures that the selected engine is informed when it is selected and
deselected.
This is always called before notifying the workspace of the change.
"""
# Destroy old instance if any.
self.processor.engine = None
if old in self.engines:
engine = self._engines.contributions[old]
engine.react_to_unselection(self.workbench)
if new and new in self.engines:
engine = self._engines.contributions[new]
engine.react_to_selection(self.workbench)
def _update_contribs(self, name, change):
"""Update the list of available contributions (editors, engines, tools)
when they change.
"""
setattr(self, name, list(getattr(self, '_'+name).contributions))
def _default_processor(self):
"""Create a MeasurementProcessor with a reference to the plugin.
"""
return MeasurementProcessor(plugin=self)
| 35.812339 | 88 | 0.585529 |
919aa3b1b41c0b06cf93f36c92d22e17f84015e4 | 584 | py | Python | setup.py | thomasdotred/lusid-jam | af35ff20617444e17a9f36529a38cb8ec75c40f3 | [
"MIT"
] | null | null | null | setup.py | thomasdotred/lusid-jam | af35ff20617444e17a9f36529a38cb8ec75c40f3 | [
"MIT"
] | 2 | 2019-12-05T09:17:54.000Z | 2021-03-01T02:29:09.000Z | setup.py | thomasdotred/lusid-jam | af35ff20617444e17a9f36529a38cb8ec75c40f3 | [
"MIT"
] | 2 | 2020-01-16T09:50:18.000Z | 2021-03-01T02:27:02.000Z | from setuptools import setup, find_packages # noqa: H301
version = {}
with open("./__version__.py") as fp:
exec(fp.read(), version)
setup(
name="lusid-jam",
version=version["__version__"],
description="Jupyter Access Token Management for LUSID",
url="https://github.com/finbourne/lusid-jam",
author="FINBOURNE Technology",
author_email="engineering@finbourne.com",
license="MIT",
keywords=["FINBOURNE", "LUSID", "LUSID API", "python"],
packages=find_packages(exclude=["tests*"]),
include_package_data=True,
python_requires=">=3.6",
) | 30.736842 | 60 | 0.681507 |
1beda86082811c0d40a507106820f8e3523da6ed | 7,325 | py | Python | pwnlib/util/proc.py | Ngugisenior/pwntools | c15afc592a94a5fd4c1255d2ce0137be38164a66 | [
"MIT"
] | null | null | null | pwnlib/util/proc.py | Ngugisenior/pwntools | c15afc592a94a5fd4c1255d2ce0137be38164a66 | [
"MIT"
] | null | null | null | pwnlib/util/proc.py | Ngugisenior/pwntools | c15afc592a94a5fd4c1255d2ce0137be38164a66 | [
"MIT"
] | null | null | null | from __future__ import absolute_import
from __future__ import division
import errno
import socket
import time
import psutil
from pwnlib import tubes
from pwnlib.log import getLogger
log = getLogger(__name__)
all_pids = psutil.pids
def pidof(target):
"""pidof(target) -> int list
Get PID(s) of `target`. The returned PID(s) depends on the type of `target`:
- :class:`str`: PIDs of all processes with a name matching `target`.
- :class:`pwnlib.tubes.process.process`: singleton list of the PID of `target`.
- :class:`pwnlib.tubes.sock.sock`: singleton list of the PID at the
remote end of `target` if it is running on the host. Otherwise an
empty list.
Arguments:
target(object): The target whose PID(s) to find.
Returns:
A list of found PIDs.
"""
if isinstance(target, tubes.ssh.ssh_channel):
return [target.pid]
elif isinstance(target, tubes.sock.sock):
local = target.sock.getsockname()
remote = target.sock.getpeername()
def match(c):
return (c.raddr, c.laddr, c.status) == (local, remote, 'ESTABLISHED')
return [c.pid for c in psutil.net_connections() if match(c)]
elif isinstance(target, tuple):
host, port = target
host = socket.gethostbyname(host)
def match(c):
return c.raddr == (host, port)
return [c.pid for c in psutil.net_connections() if match(c)]
elif isinstance(target, tubes.process.process):
return [target.proc.pid]
else:
return pid_by_name(target)
def pid_by_name(name):
"""pid_by_name(name) -> int list
Arguments:
name (str): Name of program.
Returns:
List of PIDs matching `name` sorted by lifetime, youngest to oldest.
Example:
>>> os.getpid() in pid_by_name(name(os.getpid()))
True
"""
def match(p):
if p.status() == 'zombie':
return False
if p.name() == name:
return True
try:
if p.exe() == name:
return True
except Exception:
pass
return False
processes = (p for p in psutil.process_iter() if match(p))
processes = sorted(processes, key=lambda p: p.create_time())
return list(reversed([p.pid for p in processes]))
def name(pid):
"""name(pid) -> str
Arguments:
pid (int): PID of the process.
Returns:
Name of process as listed in ``/proc/<pid>/status``.
Example:
>>> p = process('cat')
>>> name(p.pid)
'cat'
"""
return psutil.Process(pid).name()
def parent(pid):
"""parent(pid) -> int
Arguments:
pid (int): PID of the process.
Returns:
Parent PID as listed in ``/proc/<pid>/status`` under ``PPid``,
or 0 if there is not parent.
"""
try:
return psutil.Process(pid).parent().pid
except Exception:
return 0
def children(ppid):
"""children(ppid) -> int list
Arguments:
pid (int): PID of the process.
Returns:
List of PIDs of whose parent process is `pid`.
"""
return [p.pid for p in psutil.Process(ppid).children()]
def ancestors(pid):
"""ancestors(pid) -> int list
Arguments:
pid (int): PID of the process.
Returns:
List of PIDs of whose parent process is `pid` or an ancestor of `pid`.
"""
pids = []
while pid != 0:
pids.append(pid)
pid = parent(pid)
return pids
def descendants(pid):
"""descendants(pid) -> dict
Arguments:
pid (int): PID of the process.
Returns:
Dictionary mapping the PID of each child of `pid` to it's descendants.
"""
this_pid = pid
allpids = all_pids()
ppids = {}
def _parent(pid):
if pid not in ppids:
ppids[pid] = parent(pid)
return ppids[pid]
def _children(ppid):
return [pid for pid in allpids if _parent(pid) == ppid]
def _loop(ppid):
return {pid: _loop(pid) for pid in _children(ppid)}
return _loop(pid)
def exe(pid):
"""exe(pid) -> str
Arguments:
pid (int): PID of the process.
Returns:
The path of the binary of the process. I.e. what ``/proc/<pid>/exe`` points to.
"""
return psutil.Process(pid).exe()
def cwd(pid):
"""cwd(pid) -> str
Arguments:
pid (int): PID of the process.
Returns:
The path of the process's current working directory. I.e. what
``/proc/<pid>/cwd`` points to.
"""
return psutil.Process(pid).cwd()
def cmdline(pid):
"""cmdline(pid) -> str list
Arguments:
pid (int): PID of the process.
Returns:
A list of the fields in ``/proc/<pid>/cmdline``.
"""
return psutil.Process(pid).cmdline()
def stat(pid):
"""stat(pid) -> str list
Arguments:
pid (int): PID of the process.
Returns:
A list of the values in ``/proc/<pid>/stat``, with the exception that ``(`` and ``)`` has been removed from around the process name.
"""
with open('/proc/%d/stat' % pid) as fd:
s = fd.read()
# filenames can have ( and ) in them, dammit
i = s.find('(')
j = s.rfind(')')
name = s[i+1:j]
return s[:i].split() + [name] + s[j+1:].split()
def starttime(pid):
"""starttime(pid) -> float
Arguments:
pid (int): PID of the process.
Returns:
The time (in seconds) the process started after system boot
"""
return psutil.Process(pid).create_time() - psutil.boot_time()
def status(pid):
"""status(pid) -> dict
Get the status of a process.
Arguments:
pid (int): PID of the process.
Returns:
The contents of ``/proc/<pid>/status`` as a dictionary.
"""
out = {}
try:
with open('/proc/%d/status' % pid) as fd:
for line in fd:
if ':' not in line:
continue
i = line.index(':')
key = line[:i]
val = line[i + 2:-1] # initial :\t and trailing \n
out[key] = val
except OSError as e:
if e.errno == errno.ENOENT:
raise ValueError('No process with PID %d' % pid)
else:
raise
return out
def tracer(pid):
"""tracer(pid) -> int
Arguments:
pid (int): PID of the process.
Returns:
PID of the process tracing `pid`, or None if no `pid` is not being traced.
Example:
>>> tracer(os.getpid()) is None
True
"""
tpid = int(status(pid)['TracerPid'])
return tpid if tpid > 0 else None
def state(pid):
"""state(pid) -> str
Arguments:
pid (int): PID of the process.
Returns:
State of the process as listed in ``/proc/<pid>/status``. See `proc(5)` for details.
Example:
>>> state(os.getpid())
'R (running)'
"""
return status(pid)['State']
def wait_for_debugger(pid):
"""wait_for_debugger(pid) -> None
Sleeps until the process with PID `pid` is being traced.
Arguments:
pid (int): PID of the process.
Returns:
None
"""
with log.waitfor('Waiting for debugger') as l:
while tracer(pid) is None:
time.sleep(0.01)
l.success()
| 23.782468 | 140 | 0.566689 |
e56764642920341d732a20aa668f60ee624965be | 782 | py | Python | graphgallery/transforms/edge_transform/add_selfloops_edge.py | Sharpiless/GraphGallery | 5e8895cc2ca2fc06a31bfc58bc3b7a52e1ceddd0 | [
"MIT"
] | 1 | 2020-11-22T10:14:58.000Z | 2020-11-22T10:14:58.000Z | graphgallery/transforms/edge_transform/add_selfloops_edge.py | mengliu1998/GraphGallery | 025ac09e883f3e1e1b02000e086830c935884a6e | [
"MIT"
] | null | null | null | graphgallery/transforms/edge_transform/add_selfloops_edge.py | mengliu1998/GraphGallery | 025ac09e883f3e1e1b02000e086830c935884a6e | [
"MIT"
] | 1 | 2020-11-22T10:14:59.000Z | 2020-11-22T10:14:59.000Z | import numpy as np
from graphgallery import floatx
from graphgallery.transforms import edge_transpose
def add_selfloops_edge(edge_index, edge_weight, n_nodes=None, fill_weight=1.0):
edge_index = edge_transpose(edge_index)
if n_nodes is None:
n_nodes = edge_index.max() + 1
if edge_weight is None:
edge_weight = np.ones(edge_index.shape[1], dtype=floatx())
diagnal_edge_index = np.asarray(np.diag_indices(n_nodes)).astype(edge_index.dtype, copy=False)
updated_edge_index = np.hstack([edge_index, diagnal_edge_index])
diagnal_edge_weight = np.zeros(n_nodes, dtype=floatx()) + fill_weight
updated_edge_weight = np.hstack([edge_weight, diagnal_edge_weight])
return updated_edge_index, updated_edge_weight
| 32.583333 | 98 | 0.735294 |
dc72f845ed3ceb9066086fd8a1e63790612886a8 | 52,825 | py | Python | mintapi/api.py | wsmoak/mintapi | ac56323bbb124fcc7dbd923b024f2e7ecf9ffa11 | [
"MIT"
] | 1 | 2020-06-30T01:15:55.000Z | 2020-06-30T01:15:55.000Z | mintapi/api.py | wsmoak/mintapi | ac56323bbb124fcc7dbd923b024f2e7ecf9ffa11 | [
"MIT"
] | null | null | null | mintapi/api.py | wsmoak/mintapi | ac56323bbb124fcc7dbd923b024f2e7ecf9ffa11 | [
"MIT"
] | null | null | null | import atexit
from datetime import date, datetime, timedelta
import io
import json
import logging
import os
import os.path
import random
import re
import requests
import subprocess
from sys import platform as _platform
import time
import zipfile
import imaplib
import email
import email.header
import sys # DEBUG
import warnings
try:
from StringIO import StringIO # Python 2
except ImportError:
from io import BytesIO as StringIO # Python 3
from selenium.common.exceptions import ElementNotVisibleException, NoSuchElementException, StaleElementReferenceException, TimeoutException
from selenium.webdriver import ChromeOptions
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.remote.webelement import WebElement
from seleniumrequests import Chrome
import xmltodict
try:
import pandas as pd
except ImportError:
pd = None
logger = logging.getLogger('mintapi')
logger.setLevel(logging.INFO)
def assert_pd():
# Common function to check if pd is installed
if not pd:
raise ImportError(
'transactions data requires pandas; '
'please pip install pandas'
)
def json_date_to_datetime(dateraw):
cy = datetime.isocalendar(date.today())[0]
try:
newdate = datetime.strptime(dateraw + str(cy), '%b %d%Y')
except ValueError:
newdate = datetime.strptime(dateraw, '%m/%d/%y')
return newdate
def reverse_credit_amount(row):
amount = float(row['amount'][1:].replace(',', ''))
return amount if row['isDebit'] else -amount
def get_email_code(imap_account, imap_password, imap_server, imap_folder, debug=False, delete=True):
if debug:
warnings.warn(
"debug param to get_email_code() is deprecated and will be "
"removed soon; use: logging.getLogger('mintapi')"
".setLevel(logging.DEBUG) to show DEBUG log messages.",
DeprecationWarning)
code = None
imap_client = imaplib.IMAP4_SSL(imap_server)
try:
rv, data = imap_client.login(imap_account, imap_password)
except imaplib.IMAP4.error:
logger.error("ERROR: email login failed")
return ''
code = ''
for c in range(20):
time.sleep(10)
rv, data = imap_client.select(imap_folder)
if rv != 'OK':
logger.error("ERROR: Unable to open mailbox ", rv)
return ''
rv, data = imap_client.search(None, "ALL")
if rv != 'OK':
logger.error("ERROR: Email search failed")
return ''
count = 0
for num in data[0].split()[::-1]:
count = count + 1
if count > 3:
break
rv, data = imap_client.fetch(num, '(RFC822)')
if rv != 'OK':
logger.error("ERROR: ERROR getting message", num)
sys.exit(1)
msg = email.message_from_bytes(data[0][1])
x = email.header.make_header(email.header.decode_header(msg['Subject']))
subject = str(x)
logger.debug("DEBUG: SUBJECT:", subject)
x = email.header.make_header(email.header.decode_header(msg['From']))
frm = str(x)
logger.debug("DEBUG: FROM:", frm)
if not re.search('do_not_reply@intuit.com', frm, re.IGNORECASE):
continue
if not re.search('Your Mint Account', subject, re.IGNORECASE):
continue
date_tuple = email.utils.parsedate_tz(msg['Date'])
if date_tuple:
local_date = datetime.fromtimestamp(email.utils.mktime_tz(date_tuple))
else:
logger.error("ERROR: FAIL0")
diff = datetime.now() - local_date
logger.debug("DEBUG: AGE:", diff.seconds)
if diff.seconds > 180:
continue
logger.debug("DEBUG: EMAIL HEADER OK")
body = str(msg)
p = re.search(r'Verification code:<.*?(\d\d\d\d\d\d)$', body,
re.S | re.M)
if p:
code = p.group(1)
else:
logger.error("FAIL1")
logger.debug("DEBUG: CODE FROM EMAIL:", code)
if code != '':
break
logger.debug("DEBUG: CODE FROM EMAIL 2:", code)
if code != '':
logger.debug("DEBUG: CODE FROM EMAIL 3:", code)
if delete and count > 0:
imap_client.store(num, '+FLAGS', '\\Deleted')
if delete:
imap_client.expunge()
break
imap_client.logout()
return code
CHROME_DRIVER_BASE_URL = 'https://chromedriver.storage.googleapis.com/'
CHROME_DRIVER_DOWNLOAD_PATH = '{version}/chromedriver_{arch}.zip'
CHROME_DRIVER_LATEST_RELEASE = 'LATEST_RELEASE'
CHROME_ZIP_TYPES = {
'linux': 'linux64',
'linux2': 'linux64',
'darwin': 'mac64',
'win32': 'win32',
'win64': 'win32'
}
version_pattern = re.compile(
".*(?P<version>(?P<major>\\d+)\\.(?P<minor>\\d+)\\."
"(?P<build>\\d+)\\.(?P<patch>\\d+)).*")
def get_chrome_driver_url(version, arch):
return CHROME_DRIVER_BASE_URL + CHROME_DRIVER_DOWNLOAD_PATH.format(
version=version, arch=CHROME_ZIP_TYPES.get(arch))
def get_chrome_driver_major_version_from_executable(local_executable_path):
# Note; --version works on windows as well.
version = subprocess.check_output([local_executable_path, '--version'])
version_match = version_pattern.match(version.decode())
if not version_match:
return None
return version_match.groupdict()['major']
def get_latest_chrome_driver_version():
"""Returns the version of the latest stable chromedriver release."""
latest_url = CHROME_DRIVER_BASE_URL + CHROME_DRIVER_LATEST_RELEASE
latest_request = requests.get(latest_url)
if latest_request.status_code != 200:
raise RuntimeError(
'Error finding the latest chromedriver at {}, status = {}'.format(
latest_url, latest_request.status_code))
return latest_request.text
def get_stable_chrome_driver(download_directory=os.getcwd()):
chromedriver_name = 'chromedriver'
if _platform in ['win32', 'win64']:
chromedriver_name += '.exe'
local_executable_path = os.path.join(download_directory, chromedriver_name)
latest_chrome_driver_version = get_latest_chrome_driver_version()
version_match = version_pattern.match(latest_chrome_driver_version)
latest_major_version = None
if not version_match:
logger.error("Cannot parse latest chrome driver string: {}".format(
latest_chrome_driver_version))
else:
latest_major_version = version_match.groupdict()['major']
if os.path.exists(local_executable_path):
major_version = get_chrome_driver_major_version_from_executable(
local_executable_path)
if major_version == latest_major_version or not latest_major_version:
# Use the existing chrome driver, as it's already the latest
# version or the latest version cannot be determined at the moment.
return local_executable_path
logger.info('Removing old version {} of Chromedriver'.format(
major_version))
os.remove(local_executable_path)
if not latest_chrome_driver_version:
logger.critical(
'No local chrome driver found and cannot parse the latest chrome '
'driver on the internet. Please double check your internet '
'connection, then ask for assistance on the github project.')
return None
logger.info('Downloading version {} of Chromedriver'.format(
latest_chrome_driver_version))
zip_file_url = get_chrome_driver_url(
latest_chrome_driver_version, _platform)
request = requests.get(zip_file_url)
if request.status_code != 200:
raise RuntimeError(
'Error finding chromedriver at {}, status = {}'.format(
zip_file_url, request.status_code))
zip_file = zipfile.ZipFile(io.BytesIO(request.content))
zip_file.extractall(path=download_directory)
os.chmod(local_executable_path, 0o755)
return local_executable_path
def get_web_driver(email, password, headless=False, mfa_method=None,
mfa_input_callback=None, wait_for_sync=True,
wait_for_sync_timeout=5 * 60,
session_path=None, imap_account=None, imap_password=None,
imap_server=None, imap_folder="INBOX",
use_chromedriver_on_path=False,
chromedriver_download_path=os.getcwd()):
if headless and mfa_method is None:
logger.warning("Using headless mode without specifying an MFA method"
"is unlikely to lead to a successful login. Defaulting "
"--mfa-method=sms")
mfa_method = "sms"
chrome_options = ChromeOptions()
if headless:
chrome_options.add_argument('headless')
chrome_options.add_argument('no-sandbox')
chrome_options.add_argument('disable-dev-shm-usage')
chrome_options.add_argument('disable-gpu')
# chrome_options.add_argument("--window-size=1920x1080")
if session_path is not None:
chrome_options.add_argument("user-data-dir=%s" % session_path)
if use_chromedriver_on_path:
driver = Chrome(options=chrome_options)
else:
driver = Chrome(
options=chrome_options,
executable_path=get_stable_chrome_driver(
chromedriver_download_path))
driver.get("https://www.mint.com")
driver.implicitly_wait(20) # seconds
try:
element = driver.find_element_by_link_text("Sign in")
except NoSuchElementException:
# when user has cookies, a slightly different front page appears
driver.implicitly_wait(0) # seconds
element = driver.find_element_by_link_text("Sign in")
driver.implicitly_wait(20) # seconds
element.click()
time.sleep(1)
email_input = driver.find_element_by_id("ius-userid")
# It's possible that the user clicked "remember me" at some point, causing
# the email to already be present. If anything is in the input, clear it
# and use the provided email, just to be safe.
# email_input.setAttribute("value", "")
email_input.clear()
email_input.send_keys(email)
driver.find_element_by_id("ius-password").send_keys(password)
driver.find_element_by_id("ius-sign-in-submit-btn").submit()
# Wait until logged in, just in case we need to deal with MFA.
while not driver.current_url.startswith(
'https://mint.intuit.com/overview.event'):
# An implicitly_wait is also necessary here to avoid getting stuck on
# find_element_by_id while the page is still in transition.
driver.implicitly_wait(1)
time.sleep(1)
# bypass "Let's add your current mobile number" interstitial page
try:
skip_for_now = driver.find_element_by_id('ius-verified-user-update-btn-skip')
skip_for_now.click()
except (NoSuchElementException, StaleElementReferenceException, ElementNotVisibleException):
pass
driver.implicitly_wait(1) # seconds
try:
if mfa_method == 'soft-token':
mfa_token_input = driver.find_element_by_id('ius-mfa-soft-token')
mfa_code = (mfa_input_callback or input)("Please enter your 6-digit MFA code: ")
mfa_token_input.send_keys(mfa_code)
mfa_token_submit = driver.find_element_by_id('ius-mfa-soft-token-submit-btn')
mfa_token_submit.click()
else:
driver.find_element_by_id('ius-mfa-options-form')
try:
mfa_method_option = driver.find_element_by_id('ius-mfa-option-{}'.format(mfa_method))
mfa_method_option.click()
mfa_method_submit = driver.find_element_by_id("ius-mfa-options-submit-btn")
mfa_method_submit.click()
if mfa_method == 'email' and imap_account:
mfa_code = get_email_code(imap_account, imap_password, imap_server, imap_folder=imap_folder)
else:
mfa_code = (mfa_input_callback or input)("Please enter your 6-digit MFA code: ")
mfa_code_input = driver.find_element_by_id("ius-mfa-confirm-code")
mfa_code_input.send_keys(mfa_code)
mfa_code_submit = driver.find_element_by_id("ius-mfa-otp-submit-btn")
mfa_code_submit.click()
except Exception: # if anything goes wrong for any reason, give up on MFA
mfa_method = None
logger.warning("Giving up on handling MFA. Please "
"complete the MFA process manually in the "
"browser.")
except NoSuchElementException:
pass
finally:
driver.implicitly_wait(20) # seconds
# Wait until the overview page has actually loaded, and if wait_for_sync==True, sync has completed.
status_message = None
if wait_for_sync:
try:
# Status message might not be present straight away. Seems to be due
# to dynamic content (client side rendering).
status_message = WebDriverWait(driver, 30).until(
expected_conditions.visibility_of_element_located(
(By.CSS_SELECTOR, ".SummaryView .message")))
WebDriverWait(driver, wait_for_sync_timeout).until(
lambda x: "Account refresh complete" in status_message.get_attribute('innerHTML')
)
except (TimeoutException, StaleElementReferenceException):
logger.warning("Mint sync apparently incomplete after timeout. "
"Data retrieved may not be current.")
else:
driver.find_element_by_id("transaction")
if status_message is not None and isinstance(status_message, WebElement):
status_message = status_message.text
return driver, status_message
IGNORE_FLOAT_REGEX = re.compile(r"[$,%]")
def parse_float(str_number):
try:
return float(IGNORE_FLOAT_REGEX.sub('', str_number))
except ValueError:
return None
DATE_FIELDS = [
'addAccountDate',
'closeDate',
'fiLastUpdated',
'lastUpdated',
]
def convert_account_dates_to_datetime(account):
for df in DATE_FIELDS:
if df in account:
# Convert from javascript timestamp to unix timestamp
# http://stackoverflow.com/a/9744811/5026
try:
ts = account[df] / 1e3
except TypeError:
# returned data is not a number, don't parse
continue
account[df + 'InDate'] = datetime.fromtimestamp(ts)
MINT_ROOT_URL = 'https://mint.intuit.com'
MINT_ACCOUNTS_URL = 'https://accounts.intuit.com'
MINT_CREDIT_URL = 'https://credit.finance.intuit.com'
JSON_HEADER = {'accept': 'application/json'}
class MintException(Exception):
pass
class Mint(object):
request_id = 42 # magic number? random number?
token = None
driver = None
status_message = None
def __init__(self, email=None, password=None, mfa_method=None,
mfa_input_callback=None, headless=False, session_path=None,
imap_account=None, imap_password=None, imap_server=None,
imap_folder="INBOX", wait_for_sync=True, wait_for_sync_timeout=5 * 60,
use_chromedriver_on_path=False,
chromedriver_download_path=os.getcwd()):
if email and password:
self.login_and_get_token(email, password,
mfa_method=mfa_method,
mfa_input_callback=mfa_input_callback,
headless=headless,
session_path=session_path,
imap_account=imap_account,
imap_password=imap_password,
imap_server=imap_server,
imap_folder=imap_folder,
wait_for_sync=wait_for_sync,
wait_for_sync_timeout=wait_for_sync_timeout,
use_chromedriver_on_path=use_chromedriver_on_path,
chromedriver_download_path=chromedriver_download_path)
@classmethod
def create(cls, email, password, **opts):
return Mint(email, password, **opts)
@classmethod
def get_rnd(cls): # {{{
return (str(int(time.mktime(datetime.now().timetuple()))) + str(
random.randrange(999)).zfill(3))
def _get_api_key_header(self):
key_var = 'window.MintConfig.browserAuthAPIKey'
api_key = self.driver.execute_script('return ' + key_var)
auth = 'Intuit_APIKey intuit_apikey=' + api_key
auth += ', intuit_apikey_version=1.0'
header = {'authorization': auth}
header.update(JSON_HEADER)
return header
def close(self):
"""Logs out and quits the current web driver/selenium session."""
if not self.driver:
return
try:
self.driver.implicitly_wait(1)
self.driver.find_element_by_id('link-logout').click()
except NoSuchElementException:
pass
self.driver.quit()
self.driver = None
def request_and_check(self, url, method='get',
expected_content_type=None, **kwargs):
"""Performs a request, and checks that the status is OK, and that the
content-type matches expectations.
Args:
url: URL to request
method: either 'get' or 'post'
expected_content_type: prefix to match response content-type against
**kwargs: passed to the request method directly.
Raises:
RuntimeError if status_code does not match.
"""
assert method in ['get', 'post']
result = self.driver.request(method, url, **kwargs)
if result.status_code != requests.codes.ok:
raise RuntimeError('Error requesting %r, status = %d' %
(url, result.status_code))
if expected_content_type is not None:
content_type = result.headers.get('content-type', '')
if not re.match(expected_content_type, content_type):
raise RuntimeError(
'Error requesting %r, content type %r does not match %r' %
(url, content_type, expected_content_type))
return result
def get(self, url, **kwargs):
return self.driver.request('GET', url, **kwargs)
def post(self, url, **kwargs):
return self.driver.request('POST', url, **kwargs)
def login_and_get_token(self, email, password, mfa_method=None,
mfa_input_callback=None, headless=False,
session_path=None, imap_account=None,
imap_password=None,
imap_server=None,
imap_folder=None,
wait_for_sync=True,
wait_for_sync_timeout=5 * 60,
use_chromedriver_on_path=False,
chromedriver_download_path=os.getcwd()):
if self.token and self.driver:
return
self.driver, self.status_message = get_web_driver(
email, password,
mfa_method=mfa_method,
mfa_input_callback=mfa_input_callback,
headless=headless,
session_path=session_path,
imap_account=imap_account,
imap_password=imap_password,
imap_server=imap_server,
imap_folder=imap_folder,
wait_for_sync=wait_for_sync,
wait_for_sync_timeout=wait_for_sync_timeout,
use_chromedriver_on_path=use_chromedriver_on_path,
chromedriver_download_path=chromedriver_download_path)
self.token = self.get_token()
def get_token(self):
value_json = self.driver.find_element_by_name(
'javascript-user').get_attribute('value')
return json.loads(value_json)['token']
def get_request_id_str(self):
req_id = self.request_id
self.request_id += 1
return str(req_id)
def get_attention(self):
attention = None
# noinspection PyBroadException
try:
if "complete" in self.status_message:
attention = self.status_message.split(".")[1].strip()
else:
attention = self.status_message
except Exception:
pass
return attention
def get_bills(self):
return self.get(
'{}/bps/v2/payer/bills'.format(MINT_ROOT_URL),
headers=self._get_api_key_header()
).json()['bills']
def get_invests_json(self):
body = self.get(
'{}/investment.event'.format(MINT_ROOT_URL),
).text
p = re.search(r'<input name="json-import-node" type="hidden" value="json = ([^"]*);"', body)
if p:
return p.group(1).replace('"', '"')
else:
logger.error("FAIL2")
def get_accounts(self, get_detail=False): # {{{
# Issue service request.
req_id = self.get_request_id_str()
input = {
'args': {
'types': [
'BANK',
'CREDIT',
'INVESTMENT',
'LOAN',
'MORTGAGE',
'OTHER_PROPERTY',
'REAL_ESTATE',
'VEHICLE',
'UNCLASSIFIED'
]
},
'id': req_id,
'service': 'MintAccountService',
'task': 'getAccountsSorted'
# 'task': 'getAccountsSortedByBalanceDescending'
}
data = {'input': json.dumps([input])}
account_data_url = (
'{}/bundledServiceController.xevent?legacy=false&token={}'.format(
MINT_ROOT_URL, self.token))
response = self.post(
account_data_url,
data=data,
headers=JSON_HEADER
).text
if req_id not in response:
raise MintException('Could not parse account data: ' + response)
# Parse the request
response = json.loads(response)
accounts = response['response'][req_id]['response']
for account in accounts:
convert_account_dates_to_datetime(account)
if get_detail:
accounts = self.populate_extended_account_detail(accounts)
return accounts
def set_user_property(self, name, value):
url = (
'{}/bundledServiceController.xevent?legacy=false&token={}'.format(
MINT_ROOT_URL, self.token))
req_id = self.get_request_id_str()
result = self.post(
url,
data={'input': json.dumps([{'args': {'propertyName': name,
'propertyValue': value},
'service': 'MintUserService',
'task': 'setUserProperty',
'id': req_id}])},
headers=JSON_HEADER)
if result.status_code != 200:
raise MintException('Received HTTP error %d' % result.status_code)
response = result.text
if req_id not in response:
raise MintException(
'Could not parse response to set_user_property')
def get_transactions_json(self, include_investment=False,
skip_duplicates=False, start_date=None, id=0):
"""Returns the raw JSON transaction data as downloaded from Mint. The JSON
transaction data includes some additional information missing from the
CSV data, such as whether the transaction is pending or completed, but
leaves off the year for current year transactions.
Warning: In order to reliably include or exclude duplicates, it is
necessary to change the user account property 'hide_duplicates' to the
appropriate value. This affects what is displayed in the web
interface. Note that the CSV transactions never exclude duplicates.
"""
# Warning: This is a global property for the user that we are changing.
self.set_user_property(
'hide_duplicates', 'T' if skip_duplicates else 'F')
# Converts the start date into datetime format - must be mm/dd/yy
try:
start_date = datetime.strptime(start_date, '%m/%d/%y')
except (TypeError, ValueError):
start_date = None
all_txns = []
offset = 0
# Mint only returns some of the transactions at once. To get all of
# them, we have to keep asking for more until we reach the end.
while 1:
url = MINT_ROOT_URL + '/getJsonData.xevent'
params = {
'queryNew': '',
'offset': offset,
'comparableType': '8',
'rnd': Mint.get_rnd(),
}
# Specifying accountId=0 causes Mint to return investment
# transactions as well. Otherwise they are skipped by
# default.
if id > 0 or include_investment:
params['accountId'] = id
if include_investment:
params['task'] = 'transactions'
else:
params['task'] = 'transactions,txnfilters'
params['filterType'] = 'cash'
result = self.request_and_check(
url, headers=JSON_HEADER, params=params,
expected_content_type='text/json|application/json')
data = json.loads(result.text)
txns = data['set'][0].get('data', [])
if not txns:
break
if start_date:
last_dt = json_date_to_datetime(txns[-1]['odate'])
if last_dt < start_date:
keep_txns = [
t for t in txns
if json_date_to_datetime(t['odate']) >= start_date]
all_txns.extend(keep_txns)
break
all_txns.extend(txns)
offset += len(txns)
return all_txns
def get_detailed_transactions(self, include_investment=False,
skip_duplicates=False,
remove_pending=True,
start_date=None):
"""Returns the JSON transaction data as a DataFrame, and converts
current year dates and prior year dates into consistent datetime
format, and reverses credit activity.
Note: start_date must be in format mm/dd/yy. If pulls take too long,
use a more recent start date. See json explanations of
include_investment and skip_duplicates.
Also note: Mint includes pending transactions, however these sometimes
change dates/amounts after the transactions post. They have been
removed by default in this pull, but can be included by changing
remove_pending to False
"""
assert_pd()
result = self.get_transactions_json(include_investment,
skip_duplicates, start_date)
df = pd.DataFrame(result)
df['odate'] = df['odate'].apply(json_date_to_datetime)
if remove_pending:
df = df[~df.isPending]
df.reset_index(drop=True, inplace=True)
df.amount = df.apply(reverse_credit_amount, axis=1)
return df
def get_transactions_csv(self, include_investment=False, acct=0):
"""Returns the raw CSV transaction data as downloaded from Mint.
If include_investment == True, also includes transactions that Mint
classifies as investment-related. You may find that the investment
transaction data is not sufficiently detailed to actually be useful,
however.
"""
# Specifying accountId=0 causes Mint to return investment
# transactions as well. Otherwise they are skipped by
# default.
params = None
if include_investment or acct > 0:
params = {'accountId': acct}
result = self.request_and_check(
'{}/transactionDownload.event'.format(MINT_ROOT_URL),
params=params,
expected_content_type='text/csv')
return result.content
def get_net_worth(self, account_data=None):
if account_data is None:
account_data = self.get_accounts()
# account types in this list will be subtracted
invert = set(['loan', 'loans', 'credit'])
return sum([
-a['currentBalance']
if a['accountType'] in invert else a['currentBalance']
for a in account_data if a['isActive']
])
def get_transactions(self, include_investment=False):
"""Returns the transaction data as a Pandas DataFrame."""
assert_pd()
s = StringIO(self.get_transactions_csv(
include_investment=include_investment))
s.seek(0)
df = pd.read_csv(s, parse_dates=['Date'])
df.columns = [c.lower().replace(' ', '_') for c in df.columns]
df.category = (df.category.str.lower()
.replace('uncategorized', pd.NA))
return df
def populate_extended_account_detail(self, accounts): # {{{
# I can't find any way to retrieve this information other than by
# doing this stupid one-call-per-account to listTransactions.xevent
# and parsing the HTML snippet :(
for account in accounts:
headers = dict(JSON_HEADER)
headers['Referer'] = '{}/transaction.event?accountId={}'.format(
MINT_ROOT_URL, account['id'])
list_txn_url = '{}/listTransaction.xevent'.format(MINT_ROOT_URL)
params = {
'accountId': str(account['id']),
'queryNew': '',
'offset': 0,
'comparableType': 8,
'acctChanged': 'T',
'rnd': Mint.get_rnd(),
}
response = json.loads(self.get(
list_txn_url, params=params, headers=headers).text)
xml = '<div>' + response['accountHeader'] + '</div>'
xml = xml.replace('–', '-')
xml = xmltodict.parse(xml)
account['availableMoney'] = None
account['totalFees'] = None
account['totalCredit'] = None
account['nextPaymentAmount'] = None
account['nextPaymentDate'] = None
xml = xml['div']['div'][1]['table']
if 'tbody' not in xml:
continue
xml = xml['tbody']
table_type = xml['@id']
xml = xml['tr'][1]['td']
if table_type == 'account-table-bank':
account['availableMoney'] = parse_float(xml[1]['#text'])
account['totalFees'] = parse_float(xml[3]['a']['#text'])
if (account['interestRate'] is None):
account['interestRate'] = (
parse_float(xml[2]['#text']) / 100.0
)
elif table_type == 'account-table-credit':
account['availableMoney'] = parse_float(xml[1]['#text'])
account['totalCredit'] = parse_float(xml[2]['#text'])
account['totalFees'] = parse_float(xml[4]['a']['#text'])
if account['interestRate'] is None:
account['interestRate'] = (
parse_float(xml[3]['#text']) / 100.0
)
elif table_type == 'account-table-loan':
account['nextPaymentAmount'] = (
parse_float(xml[1]['#text'])
)
account['nextPaymentDate'] = xml[2].get('#text', None)
elif table_type == 'account-type-investment':
account['totalFees'] = parse_float(xml[2]['a']['#text'])
return accounts
def get_categories(self): # {{{
# Get category metadata.
req_id = self.get_request_id_str()
data = {
'input': json.dumps([{
'args': {
'excludedCategories': [],
'sortByPrecedence': False,
'categoryTypeFilter': 'FREE'
},
'id': req_id,
'service': 'MintCategoryService',
'task': 'getCategoryTreeDto2'
}])
}
cat_url = (
'{}/bundledServiceController.xevent?legacy=false&token={}'.format(
MINT_ROOT_URL, self.token))
response = self.post(cat_url, data=data, headers=JSON_HEADER).text
if req_id not in response:
raise MintException(
'Could not parse category data: "{}"'.format(response))
response = json.loads(response)
response = response['response'][req_id]['response']
# Build category list
categories = {}
for category in response['allCategories']:
categories[category['id']] = category
return categories
def get_budgets(self, hist=None): # {{{
# Get categories
categories = self.get_categories()
# Issue request for budget utilization
first_of_this_month = date.today().replace(day=1)
eleven_months_ago = (first_of_this_month - timedelta(days=330)).replace(day=1)
url = "{}/getBudget.xevent".format(MINT_ROOT_URL)
params = {
'startDate': eleven_months_ago.strftime('%m/%d/%Y'),
'endDate': first_of_this_month.strftime('%m/%d/%Y'),
'rnd': Mint.get_rnd(),
}
response = json.loads(self.get(url, params=params, headers=JSON_HEADER).text)
if hist is not None: # version proofing api
def mos_to_yrmo(mos_frm_zero):
return datetime(year=int(mos_frm_zero / 12),
month=mos_frm_zero % 12 + 1,
day=1).strftime("%Y%m")
# Error checking 'hist' argument
if isinstance(hist, str) or hist > 12:
hist = 12 # MINT_ROOT_URL only calls last 12 months of budget data
elif hist < 1:
hist = 1
bgt_cur_mo = max(map(int, response['data']['income'].keys()))
min_mo_hist = bgt_cur_mo - hist
# Initialize and populate dictionary for return
# Output 'budgets' dictionary with structure
# { "YYYYMM": {"spending": [{"key": value, ...}, ...],
# "income": [{"key": value, ...}, ...] } }
budgets = {}
for months in range(bgt_cur_mo, min_mo_hist, -1):
budgets[mos_to_yrmo(months)] = {}
budgets[mos_to_yrmo(months)][
"income"] = response["data"]["income"][str(months)]['bu']
budgets[mos_to_yrmo(months)][
"spending"] = response["data"]["spending"][str(months)]['bu']
# Fill in the return structure
for month in budgets.keys():
for direction in budgets[month]:
for budget in budgets[month][direction]:
budget['cat'] = self.get_category_from_id(
budget['cat'],
categories
)
else:
# Make the skeleton return structure
budgets = {
'income': response['data']['income'][
str(max(map(int, response['data']['income'].keys())))
]['bu'],
'spend': response['data']['spending'][
str(max(map(int, response['data']['income'].keys())))
]['bu']
}
# Fill in the return structure
for direction in budgets.keys():
for budget in budgets[direction]:
budget['cat'] = self.get_category_from_id(
budget['cat'],
categories
)
return budgets
def get_category_from_id(self, cid, categories):
if cid == 0:
return 'Uncategorized'
for i in categories:
if categories[i]['id'] == cid:
return categories[i]['name']
if 'children' in categories[i]:
for j in categories[i]['children']:
if categories[i][j]['id'] == cid:
return categories[i][j]['name']
return 'Unknown'
def initiate_account_refresh(self):
self.post(
'{}/refreshFILogins.xevent'.format(MINT_ROOT_URL),
data={'token': self.token},
headers=JSON_HEADER)
def get_credit_score(self):
# Request a single credit report, and extract the score
report = self.get_credit_report(limit=1, details=False)
try:
vendor = report['reports']['vendorReports'][0]
return vendor['creditReportList'][0]['creditScore']
except (KeyError, IndexError):
raise Exception('No Credit Score Found')
def get_credit_report(self, limit=2, details=True):
# Get the browser API key, build auth header
credit_header = self._get_api_key_header()
# Get credit reports. The UI shows 2 by default, but more are available!
# At least 8, but could be all the TransUnion reports Mint has
# How the "bands" are defined, and other metadata, is available at a
# /v1/creditscoreproviders/3 endpoint (3 = TransUnion)
credit_report = dict()
response = self.get(
'{}/v1/creditreports?limit={}'.format(MINT_CREDIT_URL, limit),
headers=credit_header)
credit_report['reports'] = response.json()
# If we want details, request the detailed sub-reports
if details:
# Get full list of credit inquiries
response = self.get(
'{}/v1/creditreports/0/inquiries'.format(MINT_CREDIT_URL),
headers=credit_header)
credit_report['inquiries'] = response.json()
# Get full list of credit accounts
response = self.get(
'{}/v1/creditreports/0/tradelines'.format(MINT_CREDIT_URL),
headers=credit_header)
credit_report['accounts'] = response.json()
# Get credit utilization history (~3 months, by account)
response = self.get(
'{}/v1/creditreports/creditutilizationhistory'.format(MINT_CREDIT_URL),
headers=credit_header)
clean_data = self.process_utilization(response.json())
credit_report['utilization'] = clean_data
return credit_report
def process_utilization(self, data):
# Function to clean up the credit utilization history data
utilization = []
utilization.extend(self.flatten_utilization(data['cumulative']))
for trade in data['tradelines']:
utilization.extend(self.flatten_utilization(trade))
return utilization
def flatten_utilization(self, data):
# The utilization history data has a nested format, grouped by year
# and then by month. Let's flatten that into a list of dates.
utilization = []
name = data.get('creditorName', 'Total')
for cu in data['creditUtilization']:
year = cu['year']
for cu_month in cu['months']:
date = datetime.strptime(cu_month['name'], '%B').replace(
day=1, year=int(year))
utilization.append({
'name': name,
'date': date.strftime('%Y-%m-%d'),
'utilization': cu_month['creditUtilization']
})
return utilization
def get_accounts(email, password, get_detail=False):
mint = Mint.create(email, password)
return mint.get_accounts(get_detail=get_detail)
def get_net_worth(email, password):
mint = Mint.create(email, password)
account_data = mint.get_accounts()
return mint.get_net_worth(account_data)
def make_accounts_presentable(accounts, presentable_format='EXCEL'):
formatter = {
'DATE': '%Y-%m-%d',
'ISO8601': '%Y-%m-%dT%H:%M:%SZ',
'EXCEL': '%Y-%m-%d %H:%M:%S',
}[presentable_format]
for account in accounts:
for k, v in account.items():
if isinstance(v, datetime):
account[k] = v.strftime(formatter)
return accounts
def print_accounts(accounts):
print(json.dumps(make_accounts_presentable(accounts), indent=2))
def get_budgets(email, password):
mint = Mint.create(email, password)
return mint.get_budgets()
def get_credit_score(email, password):
mint = Mint.create(email, password)
return mint.get_credit_score()
def get_credit_report(email, password):
mint = Mint.create(email, password)
return mint.get_credit_report()
def initiate_account_refresh(email, password):
mint = Mint.create(email, password)
return mint.initiate_account_refresh()
def main():
import getpass
import argparse
try:
import keyring
except ImportError:
keyring = None
# Parse command-line arguments {{{
cmdline = argparse.ArgumentParser()
cmdline.add_argument(
'email',
nargs='?',
default=None,
help='The e-mail address for your Mint.com account')
cmdline.add_argument(
'password',
nargs='?',
default=None,
help='The password for your Mint.com account')
home = os.path.expanduser("~")
default_session_path = os.path.join(home, '.mintapi', 'session')
cmdline.add_argument(
'--session-path',
nargs='?',
default=default_session_path,
help='Directory to save browser session, including cookies. '
'Used to prevent repeated MFA prompts. Defaults to '
'$HOME/.mintapi/session. Set to None to use '
'a temporary profile.')
cmdline.add_argument(
'--accounts',
action='store_true',
dest='accounts',
default=False,
help='Retrieve account information'
'(default if nothing else is specified)')
cmdline.add_argument(
'--budgets',
action='store_true',
dest='budgets',
default=False,
help='Retrieve budget information')
cmdline.add_argument(
'--budget_hist',
action='store_true',
dest='budget_hist',
default=None,
help='Retrieve 12-month budget history information')
cmdline.add_argument(
'--net-worth',
action='store_true',
dest='net_worth',
default=False,
help='Retrieve net worth information')
cmdline.add_argument(
'--credit-score',
action='store_true',
dest='credit_score',
default=False,
help='Retrieve current credit score')
cmdline.add_argument(
'--credit-report',
action='store_true',
dest='credit_report',
default=False,
help='Retrieve full credit report')
cmdline.add_argument(
'--extended-accounts',
action='store_true',
dest='accounts_ext',
default=False,
help='Retrieve extended account information (slower, '
'implies --accounts)')
cmdline.add_argument(
'--transactions',
'-t',
action='store_true',
default=False,
help='Retrieve transactions')
cmdline.add_argument(
'--extended-transactions',
action='store_true',
default=False,
help='Retrieve transactions with extra information and arguments')
cmdline.add_argument(
'--start-date',
nargs='?',
default=None,
help='Earliest date for transactions to be retrieved from. '
'Used with --extended-transactions. Format: mm/dd/yy')
cmdline.add_argument(
'--include-investment',
action='store_true',
default=False,
help='Used with --extended-transactions')
cmdline.add_argument(
'--skip-duplicates',
action='store_true',
default=False,
help='Used with --extended-transactions')
# Displayed to the user as a postive switch, but processed back
# here as a negative
cmdline.add_argument(
'--show-pending',
action='store_false',
default=True,
help='Exclude pending transactions from being retrieved. '
'Used with --extended-transactions')
cmdline.add_argument(
'--filename', '-f',
help='write results to file. can '
'be {csv,json} format. default is to write to '
'stdout.')
cmdline.add_argument(
'--keyring',
action='store_true',
help='Use OS keyring for storing password '
'information')
cmdline.add_argument(
'--headless',
action='store_true',
help='Whether to execute chromedriver with no visible window.')
cmdline.add_argument(
'--use-chromedriver-on-path',
action='store_true',
help=('Whether to use the chromedriver on PATH, instead of '
'downloading a local copy.'))
cmdline.add_argument(
'--chromedriver-download-path',
default=os.getcwd(),
help=('The directory to download chromedrive to.'))
cmdline.add_argument(
'--mfa-method',
default='sms',
choices=['sms', 'email'],
help='The MFA method to automate.')
cmdline.add_argument(
'--imap-account',
default=None,
help='IMAP login account')
cmdline.add_argument(
'--imap-password',
default=None,
help='IMAP login password')
cmdline.add_argument(
'--imap-server',
default=None,
help='IMAP server')
cmdline.add_argument(
'--imap-folder',
default="INBOX",
help='IMAP folder')
cmdline.add_argument(
'--imap-test',
action='store_true',
help='Test imap login and retrieval.')
cmdline.add_argument(
'--no_wait_for_sync',
action='store_true',
default=False,
help=('By default, mint api will wait for accounts to sync with the '
'backing financial institutions. If this flag is present, do '
'not wait for them to sync.'))
cmdline.add_argument(
'--wait_for_sync_timeout',
type=int,
default=5 * 60,
help=('Number of seconds to wait for sync. Default is 5 minutes'))
cmdline.add_argument(
'--attention',
action='store_true',
help='Display accounts that need attention (None if none).')
options = cmdline.parse_args()
if options.keyring and not keyring:
cmdline.error('--keyring can only be used if the `keyring` '
'library is installed.')
try: # python 2.x
from __builtin__ import raw_input as input
except ImportError: # python 3
from builtins import input
except NameError:
pass
# Try to get the e-mail and password from the arguments
email = options.email
password = options.password
if not email:
# If the user did not provide an e-mail, prompt for it
email = input("Mint e-mail: ")
if keyring and not password:
# If the keyring module is installed and we don't yet have
# a password, try prompting for it
password = keyring.get_password('mintapi', email)
if not password:
# If we still don't have a password, prompt for it
password = getpass.getpass("Mint password: ")
if options.keyring:
# If keyring option is specified, save the password in the keyring
keyring.set_password('mintapi', email, password)
if options.accounts_ext:
options.accounts = True
if not any([options.accounts, options.budgets, options.transactions,
options.extended_transactions, options.net_worth, options.credit_score,
options.credit_report, options.attention]):
options.accounts = True
if options.session_path == 'None':
session_path = None
else:
session_path = options.session_path
mint = Mint.create(
email, password,
mfa_method=options.mfa_method,
session_path=session_path,
headless=options.headless,
imap_account=options.imap_account,
imap_password=options.imap_password,
imap_server=options.imap_server,
imap_folder=options.imap_folder,
wait_for_sync=not options.no_wait_for_sync,
wait_for_sync_timeout=options.wait_for_sync_timeout,
use_chromedriver_on_path=options.use_chromedriver_on_path,
chromedriver_download_path=options.chromedriver_download_path
)
atexit.register(mint.close) # Ensure everything is torn down.
if options.imap_test:
mfa_code = get_email_code(
options.imap_account, options.imap_password, options.imap_server,
imap_folder=options.imap_folder, delete=False)
print("MFA CODE:", mfa_code)
sys.exit()
data = None
if options.accounts and options.budgets:
try:
accounts = make_accounts_presentable(
mint.get_accounts(get_detail=options.accounts_ext)
)
except Exception:
accounts = None
try:
budgets = mint.get_budgets()
except Exception:
budgets = None
data = {'accounts': accounts, 'budgets': budgets}
elif options.budgets:
try:
data = mint.get_budgets()
except Exception:
data = None
elif options.budget_hist:
try:
data = mint.get_budgets(hist=12)
except Exception:
data = None
elif options.accounts:
try:
data = make_accounts_presentable(mint.get_accounts(
get_detail=options.accounts_ext)
)
except Exception:
data = None
elif options.transactions:
data = mint.get_transactions(
include_investment=options.include_investment)
elif options.extended_transactions:
data = mint.get_detailed_transactions(
start_date=options.start_date,
include_investment=options.include_investment,
remove_pending=options.show_pending,
skip_duplicates=options.skip_duplicates)
elif options.net_worth:
data = mint.get_net_worth()
elif options.credit_score:
data = mint.get_credit_score()
elif options.credit_report:
data = mint.get_credit_report(details=True)
# output the data
if options.transactions or options.extended_transactions:
if options.filename is None:
print(data.to_json(orient='records'))
elif options.filename.endswith('.csv'):
data.to_csv(options.filename, index=False)
elif options.filename.endswith('.json'):
data.to_json(options.filename, orient='records')
else:
raise ValueError('file extension must be either .csv or .json')
else:
if options.filename is None:
print(json.dumps(data, indent=2))
elif options.filename.endswith('.json'):
with open(options.filename, 'w+') as f:
json.dump(data, f, indent=2)
else:
raise ValueError('file type must be json for non-transaction data')
if options.attention:
attention_msg = mint.get_attention()
if attention_msg is None or attention_msg == "":
attention_msg = "no messages"
if options.filename is None:
print(attention_msg)
else:
with open(options.filename, 'w+') as f:
f.write(attention_msg)
if __name__ == '__main__':
main()
| 36.992297 | 139 | 0.590043 |
9ffe657bc54fe89b67bf4325f249b5b02d613629 | 11,343 | py | Python | njunmt/tests/rnn_encoder_test.py | whr94621/NJUNMT-tf | 29e0b0c577ea7c81acdc80e7a94a1c4dfb85c118 | [
"Apache-2.0"
] | 111 | 2017-12-29T12:48:02.000Z | 2022-03-15T00:47:13.000Z | njunmt/tests/rnn_encoder_test.py | whr94621/NJUNMT-tf | 29e0b0c577ea7c81acdc80e7a94a1c4dfb85c118 | [
"Apache-2.0"
] | 3 | 2018-01-27T13:54:42.000Z | 2020-03-02T03:07:19.000Z | njunmt/tests/rnn_encoder_test.py | whr94621/NJUNMT-tf | 29e0b0c577ea7c81acdc80e7a94a1c4dfb85c118 | [
"Apache-2.0"
] | 44 | 2017-12-29T12:49:57.000Z | 2022-02-02T13:25:28.000Z | import numpy
import tensorflow as tf
from njunmt.encoders import rnn_encoder
from tensorflow.python.util import nest
def build_inputs(batch_size, max_len, dim):
x = numpy.random.random(size=(batch_size, max_len, dim))
x_len = numpy.random.randint(low=1, high=max_len, size=(batch_size,))
return tf.convert_to_tensor(x, dtype=tf.float32), \
tf.convert_to_tensor(x_len, dtype=tf.int32)
def flatten_final_states(final_states):
if isinstance(final_states, dict):
return nest.flatten(list(final_states.values()))
return nest.flatten(final_states)
def build_state(shape, is_lstm, batch_to_none=True):
state = tf.convert_to_tensor(numpy.zeros(shape=shape))
if batch_to_none:
state.set_shape((None,) + tuple(shape)[1:])
if is_lstm:
return tf.contrib.rnn.LSTMStateTuple(state, state)
return state
class RNNEncoderTest(tf.test.TestCase):
batch_size = 7
max_len = 11
dim = 17
hidden_dim = 5
input_shape = (batch_size, max_len, dim)
hidden_state_shape = (batch_size, hidden_dim)
uni_context_shape = (batch_size, max_len, hidden_dim)
bi_context_shape = (batch_size, max_len, hidden_dim * 2)
little_params1 = {"rnn_cell": {
"cell_class": "LSTMCell",
"cell_params": {
"num_units": hidden_dim,
"layer_norm": False,
"dropout_input_keep_prob": 0.9,
"dropout_state_keep_prob": 1.0
},
"residual_connections": False,
"num_layers": 1
}}
little_params2 = {"rnn_cell": {
"cell_class": "LSTMCell",
"cell_params": {
"num_units": hidden_dim,
"layer_norm": True,
"dropout_input_keep_prob": 1.0,
"dropout_state_keep_prob": 1.0
},
"residual_connections": False,
"num_layers": 3
}}
little_params3 = {"rnn_cell": {
"cell_class": "GRUCell",
"cell_params": {
"num_units": hidden_dim,
"layer_norm": True,
"dropout_input_keep_prob": 1.0,
"dropout_state_keep_prob": 1.0
},
"residual_connections": False,
"num_layers": 3
}}
def testStackUnidirectionalRNNEncoder1(self):
encoder = rnn_encoder.UnidirectionalRNNEncoder(RNNEncoderTest.little_params1,
tf.contrib.learn.ModeKeys.TRAIN)
encoder_output = encoder.encode(*build_inputs(*RNNEncoderTest.input_shape))
self.assertAllEqual(encoder_output.outputs.shape,
tf.TensorShape(RNNEncoderTest.uni_context_shape))
final_states = flatten_final_states(encoder_output.final_states)
true_final_states = flatten_final_states(build_state(RNNEncoderTest.hidden_state_shape, True))
with self.test_session() as sess:
sess.run(tf.global_variables_initializer())
final_states = sess.run(final_states)
true_final_states = sess.run(true_final_states)
self.assertAllEqual([x.shape for x in final_states],
[x.shape for x in true_final_states])
def testStackUnidirectionalRNNEncoder2(self):
encoder = rnn_encoder.UnidirectionalRNNEncoder(RNNEncoderTest.little_params2,
tf.contrib.learn.ModeKeys.TRAIN)
encoder_output = encoder.encode(*build_inputs(*RNNEncoderTest.input_shape))
self.assertAllEqual(encoder_output.outputs.shape,
tf.TensorShape(RNNEncoderTest.uni_context_shape))
final_states = flatten_final_states(encoder_output.final_states)
true_final_states = flatten_final_states(build_state(RNNEncoderTest.hidden_state_shape, True))
with self.test_session() as sess:
sess.run(tf.global_variables_initializer())
final_states = sess.run(final_states)
true_final_states = sess.run(true_final_states)
self.assertAllEqual([x.shape for x in final_states],
[x.shape for x in true_final_states])
def testStackUnidirectionalRNNEncoder3(self):
encoder = rnn_encoder.UnidirectionalRNNEncoder(RNNEncoderTest.little_params3,
tf.contrib.learn.ModeKeys.TRAIN)
encoder_output = encoder.encode(*build_inputs(*RNNEncoderTest.input_shape))
self.assertAllEqual(encoder_output.outputs.shape,
tf.TensorShape(RNNEncoderTest.uni_context_shape))
final_states = flatten_final_states(encoder_output.final_states)
true_final_states = flatten_final_states(build_state(RNNEncoderTest.hidden_state_shape, False))
with self.test_session() as sess:
sess.run(tf.global_variables_initializer())
final_states = sess.run(final_states)
true_final_states = sess.run(true_final_states)
self.assertAllEqual([x.shape for x in final_states],
[x.shape for x in true_final_states])
def testStackBiUnidirectionalRNNEncoder1(self):
encoder = rnn_encoder.BiUnidirectionalRNNEncoder(RNNEncoderTest.little_params1,
tf.contrib.learn.ModeKeys.TRAIN)
encoder_output = encoder.encode(*build_inputs(*RNNEncoderTest.input_shape))
self.assertAllEqual(encoder_output.outputs.shape,
tf.TensorShape(RNNEncoderTest.bi_context_shape))
final_states = flatten_final_states(encoder_output.final_states)
true_final_states = flatten_final_states({
"forward": build_state(RNNEncoderTest.hidden_state_shape, True),
"backward": build_state(RNNEncoderTest.hidden_state_shape, True)})
with self.test_session() as sess:
sess.run(tf.global_variables_initializer())
final_states = sess.run(final_states)
true_final_states = sess.run(true_final_states)
self.assertAllEqual([x.shape for x in final_states],
[x.shape for x in true_final_states])
def testStackBiUnidirectionalRNNEncoder2(self):
encoder = rnn_encoder.BiUnidirectionalRNNEncoder(RNNEncoderTest.little_params2,
tf.contrib.learn.ModeKeys.TRAIN)
encoder_output = encoder.encode(*build_inputs(*RNNEncoderTest.input_shape))
self.assertAllEqual(encoder_output.outputs.shape,
tf.TensorShape(RNNEncoderTest.uni_context_shape))
final_states = flatten_final_states(encoder_output.final_states)
true_final_states = build_state(RNNEncoderTest.hidden_state_shape, True)
with self.test_session() as sess:
sess.run(tf.global_variables_initializer())
final_states = sess.run(final_states)
true_final_states = sess.run(true_final_states)
self.assertAllEqual([x.shape for x in final_states],
[x.shape for x in true_final_states])
def testStackBiUnidirectionalRNNEncoder3(self):
encoder = rnn_encoder.BiUnidirectionalRNNEncoder(RNNEncoderTest.little_params3,
tf.contrib.learn.ModeKeys.TRAIN)
encoder_output = encoder.encode(*build_inputs(*RNNEncoderTest.input_shape))
self.assertAllEqual(encoder_output.outputs.shape,
tf.TensorShape(RNNEncoderTest.uni_context_shape))
final_states = flatten_final_states(encoder_output.final_states)
true_final_states = flatten_final_states(build_state(RNNEncoderTest.hidden_state_shape, False))
with self.test_session() as sess:
sess.run(tf.global_variables_initializer())
final_states = sess.run(final_states)
true_final_states = sess.run(true_final_states)
self.assertAllEqual([x.shape for x in final_states],
[x.shape for x in true_final_states])
def testStackBidirectionalRNNEncoder1(self):
encoder = rnn_encoder.StackBidirectionalRNNEncoder(RNNEncoderTest.little_params1,
tf.contrib.learn.ModeKeys.TRAIN)
encoder_output = encoder.encode(*build_inputs(*RNNEncoderTest.input_shape))
self.assertAllEqual(encoder_output.outputs.shape,
tf.TensorShape(RNNEncoderTest.bi_context_shape))
final_states = flatten_final_states(encoder_output.final_states)
true_final_states = flatten_final_states({
"forward": build_state(RNNEncoderTest.hidden_state_shape, True),
"backward": build_state(RNNEncoderTest.hidden_state_shape, True)})
with self.test_session() as sess:
sess.run(tf.global_variables_initializer())
final_state = sess.run(final_states)
true_final_state = sess.run(true_final_states)
self.assertAllEqual([x.shape for x in final_state],
[x.shape for x in true_final_state])
def testStackBidirectionalRNNEncoder2(self):
encoder = rnn_encoder.StackBidirectionalRNNEncoder(RNNEncoderTest.little_params2,
tf.contrib.learn.ModeKeys.TRAIN)
encoder_output = encoder.encode(*build_inputs(*RNNEncoderTest.input_shape))
self.assertAllEqual(encoder_output.outputs.shape,
tf.TensorShape(RNNEncoderTest.bi_context_shape))
final_states = flatten_final_states(encoder_output.final_states)
true_final_states = flatten_final_states({
"forward": build_state(RNNEncoderTest.hidden_state_shape, True),
"backward": build_state(RNNEncoderTest.hidden_state_shape, True)})
with self.test_session() as sess:
sess.run(tf.global_variables_initializer())
final_state = sess.run(final_states)
true_final_state = sess.run(true_final_states)
self.assertAllEqual([x.shape for x in final_state],
[x.shape for x in true_final_state])
def testStackBidirectionalRNNEncoder3(self):
encoder = rnn_encoder.StackBidirectionalRNNEncoder(RNNEncoderTest.little_params3,
tf.contrib.learn.ModeKeys.TRAIN)
encoder_output = encoder.encode(*build_inputs(*RNNEncoderTest.input_shape))
self.assertAllEqual(encoder_output.outputs.shape,
tf.TensorShape(RNNEncoderTest.bi_context_shape))
final_states = flatten_final_states(encoder_output.final_states)
true_final_states = flatten_final_states({
"forward": build_state(RNNEncoderTest.hidden_state_shape, False),
"backward": build_state(RNNEncoderTest.hidden_state_shape, False)})
with self.test_session() as sess:
sess.run(tf.global_variables_initializer())
final_state = sess.run(final_states)
true_final_state = sess.run(true_final_states)
self.assertAllEqual([x.shape for x in final_state],
[x.shape for x in true_final_state])
if __name__ == "__main__":
tf.test.main()
| 49.103896 | 103 | 0.649916 |
20fe8fcbaa0032916461e767258654c9622b4152 | 210 | py | Python | aio_nacos/__init__.py | zqsc/aio-nacos | c1bb8fda5adb498eb509a3d66f9a39c4dc69e58b | [
"MIT"
] | 2 | 2022-01-10T06:35:48.000Z | 2022-02-26T11:03:27.000Z | aio_nacos/__init__.py | zqsc/aio-nacos | c1bb8fda5adb498eb509a3d66f9a39c4dc69e58b | [
"MIT"
] | null | null | null | aio_nacos/__init__.py | zqsc/aio-nacos | c1bb8fda5adb498eb509a3d66f9a39c4dc69e58b | [
"MIT"
] | null | null | null | #!/usr/bin/env python3
# -*- encoding: utf-8 -*-
"""
@File : __init__.py.py
@Author : zqsc
@Time : 2021/12/14
@Contact : zhao_zqsc@sina.com
@Python Version : 3.8.5
"""
from .aio_nacos import *
| 16.153846 | 32 | 0.590476 |
65d0ccff8198792ebe6a7106bf713e7fce8c1a83 | 7,631 | py | Python | Mandalorion.py | rvolden/Mandalorion | 1100967616e6ccf39703c69ab4d2f0458df1e6a3 | [
"MIT"
] | 7 | 2018-09-19T01:55:13.000Z | 2022-02-14T12:06:27.000Z | Mandalorion.py | rvolden/Mandalorion | 1100967616e6ccf39703c69ab4d2f0458df1e6a3 | [
"MIT"
] | 5 | 2021-01-15T17:15:59.000Z | 2021-06-30T10:39:59.000Z | Mandalorion.py | rvolden/Mandalorion | 1100967616e6ccf39703c69ab4d2f0458df1e6a3 | [
"MIT"
] | 1 | 2021-05-21T02:11:13.000Z | 2021-05-21T02:11:13.000Z | #!/usr/bin/env python3
# Christopher Vollmers
# Roger Volden
import sys
import os
import argparse
VERSION = 'v3.5.0'
parser = argparse.ArgumentParser()
parser.add_argument(
'-c', '--config_file', type=str,
help='''Tab delimited file that specifies where minimap,
blat, emtrey, and racon executables are'''
)
parser.add_argument(
'-p', '--path', type=str, help='Directory to put output files into'
)
parser.add_argument(
'-u', '--upstream_buffer', type=str, default='10',
help='''Defines upstream leniency window for
polyA and TSS determination (default 10)'''
)
parser.add_argument(
'-d', '--downstream_buffer', type=str, default='50',
help='''Defines downstream leniency window for polyA
and TSS determination (default 50)'''
)
parser.add_argument(
'-s', '--subsample_consensus', type=str, default='500',
help='''Defines how many random subreads are used to polish
isoform consensus sequences (default 500)'''
)
parser.add_argument(
'-g', '--genome_annotation', type=str, help='Genome annotation file (gtf)'
)
parser.add_argument(
'-G', '--genome_sequence', type=str, help='Genome file (fasta)'
)
parser.add_argument(
'-r', '--minimum_ratio', type=str, default='0.01',
help='''Proportion of reads that align to a locus
required for an isoform (default 0.01)'''
)
parser.add_argument('-i', '--minimum_internal_ratio', type=str, default='1')
parser.add_argument(
'-R', '--minimum_reads', type=str, default='5',
help='Minimum number of reads to make an isoform (default 5)'
)
parser.add_argument(
'-a', '--adapter_file', type=str,
help='Fasta file with 5prime and 3prime adapters'
)
parser.add_argument(
'-f', '--R2C2_Consensus_reads', type=str,
help='Fasta file with R2C2 consensus reads, can be entered as a comma separated list'
)
parser.add_argument(
'-b', '--R2C2_subreads', type=str,
help='Fastq file with R2C2 subreads, can be entered as a comma separated list'
)
parser.add_argument(
'-O', '--overhangs', type=str, default='0,40,0,40',
help='''Defines bounds for unaligned bases on ends. Format:
min5prime,max5prime,min3prime,max3prime (default 0,40,0,40)'''
)
parser.add_argument(
'-t', '--minimap2_threads', type=str, default='4',
help='Number of threads to use when running minimap (default 4)'
)
parser.add_argument(
'-e', '--ends', type=str, default='ATGGG,AAAAA',
help='''Ends of your sequences. Defaults to Smartseq ends.
Format: 5prime,3prime'''
)
parser.add_argument(
'-I', '--minimum_isoform_length', type=str, default='500',
help='Minimum length in nt of isoforms that will be considered (default 500)'
)
parser.add_argument(
'-n', '--minimum_feature_count', type=str, default='2',
help='''Features (starts,ends, new splice sites) will be considered
if they are present in this number of reads (default 2)'''
)
parser.add_argument(
'-w', '--splice_site_window', type=str, default='1',
help='''reads spliced within this number of nucleotides on each side
of a splice site will be considered spliced at this site (default 1)'''
)
parser.add_argument(
'-A', '--Acutoff', type=str, default='0.5',
help='''Isoforms with A content of more than this cutoff in a 30nt
window surrounding their polyA site will be discarded (default 0.5)'''
)
parser.add_argument(
'-v', '--version', action='version', version=VERSION,
help='Prints Mandalorion version'
)
if len(sys.argv) == 1:
parser.print_help()
sys.exit(0)
args = parser.parse_args()
config_file = args.config_file
path = args.path + '/' # path where you want your output files to go
upstream_buffer = args.upstream_buffer
downstream_buffer = args.downstream_buffer
subsample_consensus = args.subsample_consensus
genome_annotation = args.genome_annotation
genome_sequence = args.genome_sequence
adapter = args.adapter_file
minimum_ratio = args.minimum_ratio
minimum_internal_ratio = args.minimum_internal_ratio
minimum_reads = args.minimum_reads
fasta_files = args.R2C2_Consensus_reads
subreads = args.R2C2_subreads
overhangs = args.overhangs
minimap2_threads = args.minimap2_threads
ends = args.ends
minimum_isoform_length = args.minimum_isoform_length
window = args.splice_site_window
feature_count = args.minimum_feature_count
Acutoff = args.Acutoff
if not os.path.isdir(path):
os.system('mkdir %s' % path)
def configReader(configIn):
'''Parses the config file.'''
progs = {}
for line in open(configIn):
if line.startswith('#') or not line.rstrip().split():
continue
line = line.rstrip().split('\t')
progs[line[0]] = line[1]
# should have minimap, racon, consensus, blat, and emtrey
possible = set(['minimap2', 'consensus', 'racon', 'blat', 'emtrey'])
inConfig = set()
for key in progs.keys():
inConfig.add(key)
# check for missing programs
# if missing, default to path
for missing in possible - inConfig:
if missing == 'consensus':
path = 'consensus.py'
else:
path = missing
progs[missing] = path
sys.stderr.write(
'Using ' + str(missing) + ' from your path, not the config file.\n'
)
return progs
progs = configReader(config_file)
minimap2 = progs['minimap2']
racon = progs['racon']
consensus = progs['consensus']
emtrey = progs['emtrey']
consensus = 'python3 ' + consensus
print('Aligning reads')
fasta_string = (' ').join(fasta_files.split(','))
sam_file = path + '/mm2Alignments.sam'
psl_file = path + '/mm2Alignments.psl'
clean_psl_file = path + '/mm2Alignments.clean.psl'
print(
'%s -G 400k --secondary=no -ax splice:hq -t %s %s %s > %s '
% (minimap2, minimap2_threads, genome_sequence, fasta_string, sam_file)
)
os.system(
'%s -G 400k --secondary=no -ax splice:hq -t %s %s %s > %s '
% (minimap2, minimap2_threads, genome_sequence, fasta_string, sam_file)
)
print('Converting sam output to psl format')
os.system('%s -i %s > %s ' % (emtrey, sam_file, psl_file))
print('Cleaning psl file of small Indels')
os.system('%s %s %s ' % ('python3 clean_psl.py', psl_file, clean_psl_file))
print('Finding Splice sites')
os.system(
'python3 spliceSites.py %s %s %s %s %s %s %s %s'
% (
clean_psl_file,
path,
'0.05',
genome_annotation,
'g',
sam_file,
window,
feature_count,
)
)
print('Identifying Isoforms')
# This script sort raw reads into isoform bins.
# The two number variables determine the window around TSS and TES
# in which read ends can fall and still be matched to the site.
os.system(
'python3 defineAndQuantifyIsoforms.py %s %s %s %s %s %s %s'
% (
clean_psl_file,
path,
downstream_buffer,
upstream_buffer,
subreads,
fasta_files,
feature_count,
)
)
os.system(
'python3 createConsensi.py -p %s -s %s -c %s -n %s'
% (path, subsample_consensus, config_file, minimap2_threads)
)
os.system(
'python3 filterIsoforms.py \
-p %s -i %s -r %s -R %s -n %s -a %s -G %s -c %s \
-O %s -t %s -e %s -A %s -s %s -d %s -I %s 2> %s'
% (
path,
path + '/Isoform_Consensi.fasta',
minimum_ratio,
minimum_reads,
minimum_internal_ratio,
adapter,
genome_sequence,
config_file,
overhangs,
minimap2_threads,
ends,
Acutoff,
window,
downstream_buffer,
minimum_isoform_length,
path + '/filter_reasons.txt',
)
)
| 31.92887 | 89 | 0.65627 |
2122cf607412033e39a90b1b0be6e52cad9b173f | 249 | py | Python | cogs/error/quiet_warning.py | DenverCoder1/dev-pro-tips-bot | 1d36a6514f7573800c687759ca63bb5a0d786816 | [
"MIT"
] | 13 | 2021-09-14T20:37:36.000Z | 2022-02-12T11:41:37.000Z | modules/error/quiet_warning.py | DenverCoder1/jct-discord-bot | e4b1df71d96a4127be27e40c9aa41dbb50c3379c | [
"MIT"
] | 124 | 2021-01-06T13:29:55.000Z | 2022-03-25T14:18:59.000Z | cogs/error/quiet_warning.py | DenverCoder1/dev-pro-tips-bot | 1d36a6514f7573800c687759ca63bb5a0d786816 | [
"MIT"
] | 6 | 2021-11-21T19:39:12.000Z | 2022-03-13T02:02:41.000Z | from typing import Optional
class QuietWarning(Exception):
"""
An error type that will be logged quietly in the log file.
"""
def __init__(
self, msg: str, inner: Optional[Exception] = None,
):
self.inner = inner
super().__init__(msg)
| 17.785714 | 59 | 0.694779 |
551d6ae242f75afa9ac89a9f75632d1caf2e0741 | 818,542 | py | Python | fn_aws_iam/fn_aws_iam/util/customize.py | nickpartner-goahead/resilient-community-apps | 097c0dbefddbd221b31149d82af9809420498134 | [
"MIT"
] | 65 | 2017-12-04T13:58:32.000Z | 2022-03-24T18:33:17.000Z | fn_aws_iam/fn_aws_iam/util/customize.py | nickpartner-goahead/resilient-community-apps | 097c0dbefddbd221b31149d82af9809420498134 | [
"MIT"
] | 48 | 2018-03-02T19:17:14.000Z | 2022-03-09T22:00:38.000Z | fn_aws_iam/fn_aws_iam/util/customize.py | nickpartner-goahead/resilient-community-apps | 097c0dbefddbd221b31149d82af9809420498134 | [
"MIT"
] | 95 | 2018-01-11T16:23:39.000Z | 2022-03-21T11:34:29.000Z | # -*- coding: utf-8 -*-
"""Generate the Resilient customizations required for fn_aws_iam"""
from __future__ import print_function
from resilient_circuits.util import *
def codegen_reload_data():
"""Parameters to codegen used to generate the fn_aws_iam package"""
reload_params = {"package": u"fn_aws_iam",
"incident_fields": [],
"action_fields": [u"aws_iam_access_key_filter", u"aws_iam_group", u"aws_iam_group_filter", u"aws_iam_password", u"aws_iam_password_reset_required", u"aws_iam_policy_filter", u"aws_iam_policy_name", u"aws_iam_user_filter"],
"function_params": [u"aws_iam_access_key_filter", u"aws_iam_access_key_id", u"aws_iam_access_keys", u"aws_iam_arns", u"aws_iam_group_filter", u"aws_iam_group_names", u"aws_iam_mfa_serial_nums", u"aws_iam_password", u"aws_iam_password_reset_required", u"aws_iam_policy_filter", u"aws_iam_policy_names", u"aws_iam_query_type", u"aws_iam_sign_cert_ids", u"aws_iam_ssc_ids", u"aws_iam_ssh_key_ids", u"aws_iam_status", u"aws_iam_user_filter", u"aws_iam_user_name"],
"datatables": [u"aws_iam_access_keys", u"aws_iam_users"],
"message_destinations": [u"fn_aws_iam"],
"functions": [u"fn_aws_iam_add_user_to_groups", u"fn_aws_iam_attach_user_policies", u"fn_aws_iam_deactivate_mfa_devices", u"fn_aws_iam_delete_access_keys", u"fn_aws_iam_delete_login_profile", u"fn_aws_iam_delete_mfa_devices", u"fn_aws_iam_delete_signing_certs", u"fn_aws_iam_delete_ss_creds", u"fn_aws_iam_delete_ssh_keys", u"fn_aws_iam_delete_user", u"fn_aws_iam_detach_user_policies", u"fn_aws_iam_list_mfa_devices", u"fn_aws_iam_list_signing_certs", u"fn_aws_iam_list_ss_creds", u"fn_aws_iam_list_ssh_keys", u"fn_aws_iam_list_user_access_key_ids", u"fn_aws_iam_list_user_groups", u"fn_aws_iam_list_user_policies", u"fn_aws_iam_list_users", u"fn_aws_iam_remove_user_from_groups", u"fn_aws_iam_update_access_key", u"fn_aws_iam_update_login_profile"],
"phases": [],
"automatic_tasks": [],
"scripts": [u"scr_aws_iam_add_access_key_as_artifact", u"scr_aws_iam_add_user_as_artifact"],
"workflows": [u"wf_aws_iam_add_user_to_group", u"wf_aws_iam_attach_user_policy", u"wf_aws_iam_change_profile_password", u"wf_aws_iam_deactivate_access_key", u"wf_aws_iam_delete_access_key", u"wf_aws_iam_delete_access_key_for_artifact", u"wf_aws_iam_delete_access_keys", u"wf_aws_iam_delete_login_profile", u"wf_aws_iam_delete_user", u"wf_aws_iam_delete_user_for_artifact", u"wf_aws_iam_detach_all_user_policies", u"wf_aws_iam_get_access_key_for_artifact", u"wf_aws_iam_get_access_keys", u"wf_aws_iam_get_user", u"wf_aws_iam_get_user_for_artifact", u"wf_aws_iam_list_access_keys", u"wf_aws_iam_list_users", u"wf_aws_iam_refresh_access_key", u"wf_aws_iam_refresh_user", u"wf_aws_iam_remove_user_from_all_groups"],
"actions": [u"Example: AWS IAM: Add Access Key As Artifact", u"Example: AWS IAM: Add User As Artifact", u"Example: AWS IAM: Add User To Group", u"Example: AWS IAM: Attach User Policy", u"Example: AWS IAM: Change Profile Password", u"Example: AWS IAM: Deactivate Access Key", u"Example: AWS IAM: Delete Access Key", u"Example: AWS IAM: Delete Access Key For Artifact", u"Example: AWS IAM: Delete Access Keys", u"Example: AWS IAM: Delete Login Profile", u"Example: AWS IAM: Delete User", u"Example: AWS IAM: Delete User For Artifact", u"Example: AWS IAM: Detach All User Policies", u"Example: AWS IAM: Get access Key For Artifact", u"Example: AWS IAM: Get Access Keys", u"Example: AWS IAM: Get User", u"Example: AWS IAM: Get User For Artifact", u"Example: AWS IAM: List Access Keys", u"Example: AWS IAM: List Users", u"Example: AWS IAM: Refresh Access Key", u"Example: AWS IAM: Refresh User", u"Example: AWS IAM: Remove User From All Groups"],
"incident_artifact_types": [u"aws_iam_access_key_id", u"aws_iam_user_name"]
}
return reload_params
def customization_data(client=None):
"""Produce any customization definitions (types, fields, message destinations, etc)
that should be installed by `resilient-circuits customize`
"""
# This import data contains:
# Action fields:
# aws_iam_access_key_filter
# aws_iam_group
# aws_iam_group_filter
# aws_iam_password
# aws_iam_password_reset_required
# aws_iam_policy_filter
# aws_iam_policy_name
# aws_iam_user_filter
# Function inputs:
# aws_iam_access_key_filter
# aws_iam_access_key_id
# aws_iam_access_keys
# aws_iam_arns
# aws_iam_group_filter
# aws_iam_group_names
# aws_iam_mfa_serial_nums
# aws_iam_password
# aws_iam_password_reset_required
# aws_iam_policy_filter
# aws_iam_policy_names
# aws_iam_query_type
# aws_iam_sign_cert_ids
# aws_iam_ssc_ids
# aws_iam_ssh_key_ids
# aws_iam_status
# aws_iam_user_filter
# aws_iam_user_name
# DataTables:
# aws_iam_access_keys
# aws_iam_users
# Message Destinations:
# fn_aws_iam
# Functions:
# fn_aws_iam_add_user_to_groups
# fn_aws_iam_attach_user_policies
# fn_aws_iam_deactivate_mfa_devices
# fn_aws_iam_delete_access_keys
# fn_aws_iam_delete_login_profile
# fn_aws_iam_delete_mfa_devices
# fn_aws_iam_delete_signing_certs
# fn_aws_iam_delete_ss_creds
# fn_aws_iam_delete_ssh_keys
# fn_aws_iam_delete_user
# fn_aws_iam_detach_user_policies
# fn_aws_iam_list_mfa_devices
# fn_aws_iam_list_signing_certs
# fn_aws_iam_list_ss_creds
# fn_aws_iam_list_ssh_keys
# fn_aws_iam_list_user_access_key_ids
# fn_aws_iam_list_user_groups
# fn_aws_iam_list_user_policies
# fn_aws_iam_list_users
# fn_aws_iam_remove_user_from_groups
# fn_aws_iam_update_access_key
# fn_aws_iam_update_login_profile
# Scripts:
# scr_aws_iam_add_access_key_as_artifact
# scr_aws_iam_add_user_as_artifact
# Workflows:
# wf_aws_iam_add_user_to_group
# wf_aws_iam_attach_user_policy
# wf_aws_iam_change_profile_password
# wf_aws_iam_deactivate_access_key
# wf_aws_iam_delete_access_key
# wf_aws_iam_delete_access_key_for_artifact
# wf_aws_iam_delete_access_keys
# wf_aws_iam_delete_login_profile
# wf_aws_iam_delete_user
# wf_aws_iam_delete_user_for_artifact
# wf_aws_iam_detach_all_user_policies
# wf_aws_iam_get_access_key_for_artifact
# wf_aws_iam_get_access_keys
# wf_aws_iam_get_user
# wf_aws_iam_get_user_for_artifact
# wf_aws_iam_list_access_keys
# wf_aws_iam_list_users
# wf_aws_iam_refresh_access_key
# wf_aws_iam_refresh_user
# wf_aws_iam_remove_user_from_all_groups
# Rules:
# Example: AWS IAM: Add Access Key As Artifact
# Example: AWS IAM: Add User As Artifact
# Example: AWS IAM: Add User To Group
# Example: AWS IAM: Attach User Policy
# Example: AWS IAM: Change Profile Password
# Example: AWS IAM: Deactivate Access Key
# Example: AWS IAM: Delete Access Key
# Example: AWS IAM: Delete Access Key For Artifact
# Example: AWS IAM: Delete Access Keys
# Example: AWS IAM: Delete Login Profile
# Example: AWS IAM: Delete User
# Example: AWS IAM: Delete User For Artifact
# Example: AWS IAM: Detach All User Policies
# Example: AWS IAM: Get access Key For Artifact
# Example: AWS IAM: Get Access Keys
# Example: AWS IAM: Get User
# Example: AWS IAM: Get User For Artifact
# Example: AWS IAM: List Access Keys
# Example: AWS IAM: List Users
# Example: AWS IAM: Refresh Access Key
# Example: AWS IAM: Refresh User
# Example: AWS IAM: Remove User From All Groups
# Incident artifact types:
# aws_iam_access_key_id
# aws_iam_user_name
yield ImportDefinition(u"""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"""
) | 76.743109 | 962 | 0.98229 |
8ae499146fce8d87bceaacf86dbf9c0b8b127590 | 5,988 | py | Python | sopel/logger.py | xnaas/sopel | 005a53452fdd96dde1dd266b1587d67170665317 | [
"EFL-2.0"
] | null | null | null | sopel/logger.py | xnaas/sopel | 005a53452fdd96dde1dd266b1587d67170665317 | [
"EFL-2.0"
] | null | null | null | sopel/logger.py | xnaas/sopel | 005a53452fdd96dde1dd266b1587d67170665317 | [
"EFL-2.0"
] | null | null | null | # coding=utf-8
from __future__ import absolute_import, division, print_function, unicode_literals
import logging
from logging.config import dictConfig
import os
from sopel import tools
class IrcLoggingHandler(logging.Handler):
"""Logging handler for output to an IRC channel.
:param bot: a Sopel instance
:type bot: :class:`sopel.bot.Sopel`
:param level: minimum level of log messages to report through this handler
:type level: :ref:`logging level <levels>`
Implementation of a :class:`logging.Handler`.
"""
def __init__(self, bot, level):
super(IrcLoggingHandler, self).__init__(level)
self._bot = bot
self._channel = bot.settings.core.logging_channel
def emit(self, record):
"""Emit a log ``record`` to the IRC channel.
:param record: the log record to output
:type record: :class:`logging.LogRecord`
"""
if not self._bot.backend.is_connected():
# Don't emit logs when the bot is not connected.
return
try:
msg = self.format(record)
self._bot.say(msg, self._channel)
except (KeyboardInterrupt, SystemExit):
raise
except Exception: # TODO: Be specific
self.handleError(record)
class ChannelOutputFormatter(logging.Formatter):
"""Output formatter for log messages destined for an IRC channel.
:param fmt: log line format
:type fmt: :ref:`format string <formatstrings>`
:param datefmt: date format
:type datefmt: :ref:`format string <formatstrings>`
Implementation of a :class:`logging.Formatter`.
"""
def __init__(self, fmt='[%(filename)s] %(message)s', datefmt=None):
super(ChannelOutputFormatter, self).__init__(fmt=fmt, datefmt=datefmt)
def formatException(self, exc_info):
"""Format the exception info as a string for output.
:param tuple exc_info: standard exception information returned by
:func:`~sys.exc_info`
"""
# logging will throw a newline between the message and this, but
# that's fine because Sopel will strip it back out anyway
return ' - ' + repr(exc_info[1])
def setup_logging(settings):
"""Set up logging based on the bot's configuration ``settings``.
:param settings: configuration settings object
:type settings: :class:`sopel.config.Config`
"""
log_directory = settings.core.logdir
base_level = settings.core.logging_level or 'WARNING'
base_format = settings.core.logging_format
base_datefmt = settings.core.logging_datefmt
logging_config = {
'version': 1,
'formatters': {
'sopel': {
'format': base_format,
'datefmt': base_datefmt,
},
'raw': {
'format': '%(asctime)s %(message)s',
'datefmt': base_datefmt,
},
},
'loggers': {
# all purpose, sopel root logger
'sopel': {
'level': base_level,
'handlers': ['console', 'logfile', 'errorfile'],
},
# raw IRC log
'sopel.raw': {
'level': 'DEBUG',
'propagate': False,
'handlers': ['raw'],
},
# asynchat exception logger
'sopel.exceptions': {
'level': 'INFO',
'propagate': False,
'handlers': ['exceptionfile'],
},
},
'handlers': {
# output on stderr
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
'formatter': 'sopel',
},
# generic purpose log file
'logfile': {
'level': 'DEBUG',
'class': 'logging.handlers.TimedRotatingFileHandler',
'filename': os.path.join(
log_directory, settings.basename + '.sopel.log'),
'when': 'midnight',
'formatter': 'sopel',
},
# caught error log file
'errorfile': {
'level': 'ERROR',
'class': 'logging.handlers.TimedRotatingFileHandler',
'filename': os.path.join(
log_directory, settings.basename + '.error.log'),
'when': 'midnight',
'formatter': 'sopel',
},
# uncaught error file
'exceptionfile': {
'level': 'ERROR',
'class': 'logging.handlers.TimedRotatingFileHandler',
'filename': os.path.join(
log_directory, settings.basename + '.exceptions.log'),
'when': 'midnight',
'formatter': 'sopel',
},
# raw IRC log file
'raw': {
'level': 'DEBUG',
'class': 'logging.handlers.TimedRotatingFileHandler',
'filename': os.path.join(
log_directory, settings.basename + '.raw.log'),
'when': 'midnight',
'formatter': 'raw',
},
},
}
dictConfig(logging_config)
def get_logger(name=None):
"""Return a logger for a module, if the name is given.
.. deprecated:: 7.0
Sopel's own code should use :func:`logging.getLogger(__name__)
<logging.getLogger>` instead, and external plugins should use
:func:`sopel.tools.get_logger`.
This will emit a deprecation warning in Sopel 8.0, and it will be
removed in Sopel 9.0.
"""
if not name:
return logging.getLogger('sopel')
parts = name.strip().split('.')
if len(parts) > 1 or parts[0] in ['sopel', 'sopel_modules']:
return logging.getLogger(name)
# assume it's a plugin name, as intended by the original get_logger
return tools.get_logger(name)
| 33.082873 | 82 | 0.548263 |
1dc30d05c88823129edad05d013821f23b432069 | 22,222 | py | Python | src/test/regress/maketestschedule.py | Oliver-Luo/incubator-hawq | 195909207313d802a110666c76187cefab96d09c | [
"Apache-2.0"
] | null | null | null | src/test/regress/maketestschedule.py | Oliver-Luo/incubator-hawq | 195909207313d802a110666c76187cefab96d09c | [
"Apache-2.0"
] | null | null | null | src/test/regress/maketestschedule.py | Oliver-Luo/incubator-hawq | 195909207313d802a110666c76187cefab96d09c | [
"Apache-2.0"
] | null | null | null | #!/usr/bin/env python
#
# Given a set of tests on the command line (comma separated), builds a schedule and emits it to stdout
#
# Special tokens:
#
#
# Note: if you add a new test with dependencies, update with a new call to add_edge
#
# Note: we could force drop.sql to be run after all others? But I think using known_good_schedule as input for doAll
# is enough -- unless the user specifically requests it.
#
# todo: test more cases where things are run in parallel and talk about the same tables and whatnot
# (get more of these dtm crashes i've seen).
# (partition.sql locktest needs a filter on mppsessionid to work in parallel??)
# also: is my problem running in parallel because of
# todo: write up documentation for tt_ options (on wiki)
# todo: write up documentation for adding a new unit test, etc.
#
# Future improvements to make (to this, and pg_regress calling in general)
# * reduce the overhead of some other things (like only run upg-transform if needed, only transform input
# .source files if not done already)
# * use this for regular running (need to incorporate architecture mapping from the perl version
# * when doing in parallel, we could be even smarter about grouping by time by improving how we manage dependences
# (that is, right now a test always runs in a group based on how many dependencies it has -- but
# we could move it further down in order to get more parallelism as long as it doesn't conflict
# with one of its dependents!)
# The better solution would be to have pg_regress.c take max level
# of parallelism and have start the next test from the same line when done a test from the same
# line). Unfortunately, this doesn't seem like how --max-connections option to pg_regress works.
# * make pg_regress do the diffing of results in parallel as well
# * support tt_last_failed and tt_last_failed_partial to load the last failed test and rerun them
# (failed vs failed_partial depends on whether you use failures written at the end
# or those written as we go (affects if you hit ctrl-c))
#
import collections
import os.path
import re
import subprocess
import sys
SQL_DIR = "sql"
SOURCE_DIR = "input"
EXPECTED_DIR = "expected"
ARCHITECTURE_UNKNOWN = "unknown"
#
# This function ships with the product in utils.py
#
def readAllLinesFromFile(fileName, stripLines=False, skipEmptyLines=False):
"""
@param stripLines if true then line.strip() is called on each line read
@param skipEmptyLines if true then empty lines are not returned. Beware! This will throw off your line counts
if you are relying on line counts
"""
res = []
f = open(fileName)
try:
for line in f:
if stripLines:
line = line.strip()
if skipEmptyLines and len(line) == 0:
# skip it!
pass
else:
res.append(line)
finally:
f.close()
return res
class EstimatedDurations:
"""
Simple map of test to estimated duration for tests. The actual numbers don't matter, just
the relative values (used for test ordering). So, when updating this
you should replace all of the data values, if possible.
"""
def __init__(self):
self.__estimatedDurationPerTest = {}
def addEstimatedDurations(*nameDurationTuples):
for nd in nameDurationTuples:
self.__estimatedDurationPerTest[nd[0]] = nd[1]
addEstimatedDurations(
("boolean", 0.24), ("char", 0.25), ("name", 0.16), ("varchar", 0.24),
("text", 0.13), ("int2", 0.96), ("int4", 1.73), ("int8", 0.51), ("oid", 0.19),
("float4", 0.44), ("float8", 2.23), ("bit", 0.53), ("numeric", 4.28),
("strings", 1.64), ("numerology", 0.88), ("point", 0.16), ("lseg", 0.12),
("box", 0.15), ("path", 0.22), ("polygon", 0.20), ("circle", 0.14),
("date", 0.29), ("time", 0.18), ("timetz", 0.18), ("timestamp", 0.96),
("timestamptz", 0.98), ("interval", 0.28), ("abstime", 0.19), ("reltime", 0.17),
("tinterval", 0.15), ("inet", 0.32), ("comments", 0.02), ("oidjoins", 3.21),
("type_sanity", 0.61), ("opr_sanity", 3.84), ("geometry", 1.04), ("horology", 1.09),
("insert", 0.94), ("create_function_1", 0.11), ("create_type", 1.85), ("create_table", 1.68),
("create_function_2", 0.12), ("copy", 11.63), ("copyselect", 0.64), ("constraints", 2.24),
("create_misc", 7.33), ("create_aggregate", 0.37), ("create_operator", 0.07), ("create_index", 40.89),
("drop_if_exists", 0.28), ("vacuum", 3.61), ("create_view", 1.04), ("errors", 0.43),
("select", 1.71), ("select_into", 1.13), ("select_distinct", 0.20), ("select_distinct_on", 0.06),
("select_having", 0.40), ("subselect", 1.67), ("union", 0.21), ("case", 0.41),
("join", 8.86), ("indexjoin", 2.95), ("aggregates", 0.98), ("direct_dispatch", 2.29), ("partition_pruning_with_fn", 0.19),
("distributed_transactions", 7.57), ("random", 0.24), ("btree_index", 0.13), ("hash_index", 0.27),
("update", 0.68), ("delete", 0.25), ("namespace", 0.29), ("select_views", 0.02),
("portals", 1.32), ("portals_p2", 0.22), ("cluster", 2.04), ("dependency", 0.58),
("guc", 0.09), ("limit", 0.13), ("temp", 1.20), ("rangefuncs_cdb", 17.33),
("prepare", 0.98), ("without_oid", 1.53), ("conversion", 0.22), ("truncate", 1.25),
("sequence", 0.58), ("rowtypes", 1.87), ("gpdiffcheck", 0.39), ("exttab1", 12.88),
("resource_queue", 0.77), ("gptokencheck", 0.01), ("gpcopy", 5.64), ("sreh", 11.69),
("olap_setup", 1.49), ("olap_group", 6.79), ("olap_window", 4.17), ("olap_window_seq", 3.36),
("tpch500GB", 0.72), ("partition", 75.95), ("appendonly", 47.16), ("aocs", 42.76),
("gp_hashagg", 0.50), ("gp_dqa", 1.29), ("gpic", 28.78), ("gpic_bigtup", 7.08),
("filter", 0.47), ("gpctas", 2.18), ("gpdist", 6.81), ("matrix", 0.35),
("gpdtm_plpgsql", 52.83), ("notin", 1.21), ("toast", 0.95),
("gpparams", 1.10), ("upg2", 6.71), ("alter_distribution_policy", 44.76), ("ereport", 4.82),
("gp_numeric_agg", 2.81), ("foreign_data", 1.51), ("gp_toolkit", 0.06),
("column_compression", 5.5))
def getEstimatedDuration(self, testName, defaultIfNotThere=1):
if testName in self.__estimatedDurationPerTest:
return self.__estimatedDurationPerTest[testName]
return defaultIfNotThere
class DependencyEntry:
"""
An entry in the SimpleDependencyGraph
"""
def __init__(self, testName, isOrderingDependencyOnly):
"""
@param isOrderingDependencyOnly see SimpleDependencyGraph.addDependency
"""
self.__testName = testName
self.__isOrderingDependencyOnly = isOrderingDependencyOnly
def getTestName(self):
return self.__testName
def isOrderingDependencyOnly(self):
return self.__isOrderingDependencyOnly
class SimpleDependencyGraph:
"""
Simple dependency graph. Use of this will probably lead to O(N^2) or worse behavior but
I tried using pygraph and I couldn't get the output order that I wanted...
if it gets slow then we'll have to address it then.
Note that because we don't have a complex dependency graph (usually a large number of tests depend on
a small number of tests) this is probably not an issue.
"""
def __init__(self):
# maps from test name to DependencyEntry objects
self.__testToListOfDependencies = {}
self.__testToMaxDependencyLength = {}
def areDependentsSatisfied(self, test, doneTests, allTestsBeingRun):
"""
@param test the name of the test to check
@param doneTests a map of [doneTest->True] for completed tests
@param allTestsBeingRun a map of [test->True] for all tests that will be run in this test run
"""
for dependency in self.__testToListOfDependencies.get(test, []):
if dependency.getTestName() not in doneTests:
if dependency.isOrderingDependencyOnly():
if dependency.getTestName() in allTestsBeingRun:
# ordering-only dependency is being run but not done yet
return False
else:
return False
return True
def getDependencyTestNames(self, test, testsBeingRunMap):
return [d.getTestName() for d in self.__testToListOfDependencies.get(test, [])
if not d.isOrderingDependencyOnly() or d.getTestName() in testsBeingRunMap]
def addDependency(self, thisTest, dependsOnThisOne, isOrderingDependencyOnly=False):
"""
@param isOrderingDependencyOnly if true then this dependency is only an ordering dependency -- that is,
thistest must be run after dependsOnThisOne, but thisTest can also run in a test run
where dependsOnThisOne is not involved!
"""
# clear stats
self.__testToMaxDependencyLength = None
# do the add of dependency
if thisTest not in self.__testToListOfDependencies:
self.__testToListOfDependencies[thisTest] = []
for tEntry in self.__testToListOfDependencies[thisTest]:
# yes, this assertion does not check isOrderingDependencyOnly -- caller should
# pick which they want (the stricter, False for isOrderingDependencyOnly)
assert tEntry.getTestName() != dependsOnThisOne, \
"Duplicate entry for %s->%s dependency" % (thisTest, dependsOnThisOne)
self.__testToListOfDependencies[thisTest].append( DependencyEntry(dependsOnThisOne, isOrderingDependencyOnly))
# make sure the graph knows about the dependency as well
if dependsOnThisOne not in self.__testToListOfDependencies:
self.__testToListOfDependencies[dependsOnThisOne] = []
def updateStats(self, testsBeingRunMap):
"""
Update some stats info used by getStatXXX calls
"""
self.__testToMaxDependencyLength = {}
toProcess = collections.deque(self.__testToListOfDependencies.keys())
safetyCheck = 0
sentinel = 10000000
while toProcess:
test = toProcess.pop()
maxCount = -1 # -1 to get one with no dependents to have value 0 after the increment
for d in self.getDependencyTestNames(test, testsBeingRunMap):
maxCount = max(maxCount, self.__testToMaxDependencyLength.get(d, sentinel))
if maxCount == sentinel:
toProcess.appendleft(test)
else: self.__testToMaxDependencyLength[test] = maxCount + 1
safetyCheck += 1
if safetyCheck >= 10000000:
raise Exception("Failed to update stats")
def getStatMaxDependencyLength(self, test):
assert self.__testToMaxDependencyLength is not None, "updateStats has not been called since last changes"
return self.__testToMaxDependencyLength.get(test, 0)
class ArchitectureSpecificTemplateManager:
"""
Deals with architecture-specific templates for tests (files in sql/input/expected directories that
end with .tpl) that are used according to the current machine architecture
"""
def __init__(self):
self.__architecture = self.__readArchitecture()
def ensureTemplateWritten(self, testName):
"""
Call to ensure that the template file(s) have been copied to the sql/output/etc. directories
as needed.
@return True if the sql/source file are there after this function runs
"""
sqlFile = SQL_DIR + "/" + testName + ".sql"
sourceFile = SOURCE_DIR + "/" + testName + ".source"
if os.path.exists(sqlFile) or os.path.exists(sourceFile):
#
# note: this will create a problem if architecture changes (because you copied
# directories between machines, for example)
# We could just relink in all cases when there is an input template file...
#
return True
return self.__linkFile(SQL_DIR, testName, "sql") and \
self.__linkFile(EXPECTED_DIR, testName, "out")
def __linkFile(self, dir, testName, suffix):
templateFileName = testName + "." + self.__architecture + ".tpl"
templateFile = os.path.join(dir, templateFileName)
targetFileName = testName + "." + suffix
targetFile = os.path.join(dir, targetFileName)
if os.path.exists(templateFile) and self.__architecture != ARCHITECTURE_UNKNOWN:
if os.path.exists(targetFile):
os.remove(targetFile)
os.symlink(templateFileName, targetFile)
return True
else:
return False
def __readArchitecture(self):
#
# determine architecture by using configuration entries in arch_config and
# checking for entries provided by this file command
#
#
process = subprocess.Popen(["file", os.getenv("GPHOME", ".") + "/bin/postgres"], stdout=subprocess.PIPE)
process.wait()
archString = process.communicate()[0].strip()
index = archString.find(":")
if index == -1:
return ARCHITECTURE_UNKNOWN
archLabel = archString[index+1:].strip()
confLineMatcher = re.compile("([^ ]+)\s*:\s*'(.*)'\s*")
for archLine in readAllLinesFromFile("arch_config", stripLines=True, skipEmptyLines=True):
match = confLineMatcher.match(archLine)
if match is not None:
(arch, regExString) = match.group(1,2)
if ( re.compile(regExString).match(archLabel) != -1):
return arch
return ARCHITECTURE_UNKNOWN;
class TestScheduler:
def __init__(self):
pass
def printSchedule(self,sourceSchedule, testsToRun, doAll, enableTimeBasedSorting, parallelTestLimit ):
orderedTests = self.__orderTests(sourceSchedule, testsToRun, doAll)
templateManager = ArchitectureSpecificTemplateManager()
for i, testList in enumerate(orderedTests):
newTestList = []
for test in testList:
if not templateManager.ensureTemplateWritten(test):
print >> sys.stderr, "WARNING: test %s will be skipped because the input files " \
"(sql, source, or architecture-specific template) does not exist" % test
else: newTestList.append(test)
orderedTests[i] = newTestList
for testList in orderedTests:
startIndex = 0
if enableTimeBasedSorting:
testList = self.__sortTestsByEstimatedTimeDesc(testList)
while startIndex < len(testList):
print "test: " + " ".join(testList[startIndex:startIndex+parallelTestLimit])
startIndex += parallelTestLimit
def __sortTestsByEstimatedTimeDesc(self, testNames):
durations = EstimatedDurations()
toSort = []
for i, name in enumerate(testNames):
toSort.append((name, durations.getEstimatedDuration(name), i))
def compareByTime(left, right):
res = cmp(left[1], right[1])
if res == 0:
res = cmp(left[2], right[2])
assert res != 0
return res
toSort.sort(compareByTime, reverse=True)
return [tuple[0] for tuple in toSort]
def __buildDependencyGraph(self):
graph = SimpleDependencyGraph()
def addEdges(src, *dest):
for d in dest:
graph.addDependency(src, d )
#
# Add dependencies between tests
#
# edges are (test, prequisites)
#
addEdges("create_type", "create_function_1")
addEdges("create_table", "create_type")
addEdges("create_function_2", "create_table")
addEdges("copy", "create_function_2")
addEdges("create_misc", "copy")
addEdges("create_index", "create_misc", "polygon", "circle")
addEdges("alter_table","create_index")
addEdges("create_view", "create_misc", "create_operator")
addEdges("errors", "create_table")
addEdges("select", "create_misc", "int8")
addEdges("select_into", "create_misc")
addEdges("select_distinct", "copy", "create_view", "select")
addEdges("select_distinct_on", "copy", "create_view", "select")
addEdges("subselect", "copy", "int4", "int8")
addEdges("union", "char", "float8", "int4", "int8", "text", "varchar")
addEdges("join", "copy", "float8", "int4")
addEdges("aggregates", "copy", "create_aggregate", "int8", "int4")
addEdges("random", "copy")
addEdges("btree_index", "copy")
addEdges("hash_index", "copy")
addEdges("select_views", "create_view")
addEdges("portals", "copy", "create_misc")
addEdges("portals_p2", "copy", "create_misc")
addEdges("limit", "copy")
addEdges("rangefuncs_cdb", "int4")
addEdges("prepare", "copy")
addEdges("rowtypes", "copy")
addEdges("resource_queue", "copy")
addEdges("olap_group", "olap_setup")
addEdges("olap_window", "olap_setup")
addEdges("olap_window_seq", "olap_setup")
addEdges("arrays", "create_table", "copy")
addEdges("transactions", "create_misc")
# these both use (and pkill) gpdist, so keep them separate.
graph.addDependency("sreh", "exttab1", isOrderingDependencyOnly=True)
# upg2 changes some tables in ways opr_sanity does not like; todo: fix the test instead?
graph.addDependency("upg2", "opr_sanity", isOrderingDependencyOnly=True)
return graph
def __orderTests(self, knownGoodScheduleFile, testsToRun, doAll):
"""
Produce an ordering of the given testsToRun, also including any needed prerequisite tests
"""
testsToRun = [t for t in testsToRun] # copy so we can modify later
# parse test lines listed
testLines = [line for line in readAllLinesFromFile(knownGoodScheduleFile, True, True) if line[0] != '#']
testNameToCurrentAction = {}
for line in testLines:
if len(line.split(":")) != 2:
raise Exception("Invalid line in %s: %s " % (knownGoodScheduleFile, line))
(action, name) = line.split(":")
name = name.strip()
action = action.strip()
testNameToCurrentAction[name] = action
if doAll and action == "test":
testsToRun.append(name)
for test in testsToRun:
testNameToCurrentAction[name] = "test"
# build graph and add known dependencies
graph = self.__buildDependencyGraph()
#
# enable testsToRun to include all dependencies
#
addedTests = {}
for test in testsToRun:
addedTests[test] = True
doLoop = True # we must loop multiple times because testsBeingRunMap may change and so more ordering dependencies may appear
while(doLoop):
testsBeingRunMap = dict.fromkeys(testsToRun, True)
doLoop = False
testIndex = 0
while testIndex < len(testsToRun): # we modify testsToRun so do it this way
for d in graph.getDependencyTestNames(testsToRun[testIndex], testsBeingRunMap):
if d not in addedTests:
addedTests[d] = True
testsToRun.append(d)
doLoop = True
testIndex += 1
assert(len(testsBeingRunMap) == len(testsToRun))
#
# now determine the final schedule, kind of N^2 but okay in practice, I think :)
#
graph.updateStats(testsBeingRunMap)
addedTests = {}
result = []
while len(addedTests) != len(testsToRun):
startLen = len(addedTests)
haveUnaddedTest = False
for test in testsToRun:
if test in addedTests:
continue
if graph.areDependentsSatisfied(test, addedTests, testsBeingRunMap):
index = graph.getStatMaxDependencyLength(test)
while index >= len(result):
result.append([])
result[index].append(test)
addedTests[test] = True
if startLen == len(addedTests):
raise Exception("Cannot resolve test order: %s" % (testsToRun))
return result
def makeSpecifiedScheduleMain(argv=None):
if argv is None:
argv = sys.argv
enableTimeBasedSorting = False # note: if enabled, this causes errors in the product for me
parallelTestLimit = 1
doAll = True
testsToRun = []
for arg in argv[1:]:
for test in arg.split(","):
test = test.strip()
if test == "":
pass
elif test == "tt_parallel":
parallelTestLimit = 4 # default parallel limit
elif test.startswith("tt_parallel="):
(dummy, parallelTestLimit) = test.split("=")
parallelTestLimit = int(parallelTestLimit)
assert parallelTestLimit >= 1
elif test == "tt_sort_duration_desc":
enableTimeBasedSorting = True
else:
doAll = False
testsToRun.append(test)
TestScheduler().printSchedule("known_good_schedule", testsToRun, doAll, enableTimeBasedSorting, parallelTestLimit)
if __name__ == '__main__':
makeSpecifiedScheduleMain()
| 43.744094 | 138 | 0.606021 |
859c1d5ebe81ac425cc790fcb0729ccab084b96e | 37 | py | Python | WEEKS/CD_Sata-Structures/_RESOURCES/python-prac/mini-scripts/Python_Variables_case-sensitive.txt.py | webdevhub42/Lambda | b04b84fb5b82fe7c8b12680149e25ae0d27a0960 | [
"MIT"
] | 5 | 2021-06-02T23:44:25.000Z | 2021-12-27T16:21:57.000Z | WEEKS/CD_Sata-Structures/_RESOURCES/python-prac/mini-scripts/Python_Variables_case-sensitive.txt.py | webdevhub42/Lambda | b04b84fb5b82fe7c8b12680149e25ae0d27a0960 | [
"MIT"
] | 22 | 2021-05-31T01:33:25.000Z | 2021-10-18T18:32:39.000Z | WEEKS/CD_Sata-Structures/_RESOURCES/python-prac/mini-scripts/Python_Variables_case-sensitive.txt.py | webdevhub42/Lambda | b04b84fb5b82fe7c8b12680149e25ae0d27a0960 | [
"MIT"
] | 3 | 2021-06-19T03:37:47.000Z | 2021-08-31T00:49:51.000Z | a = 4
A = "Sally"
print(a)
print(A)
| 6.166667 | 11 | 0.540541 |
ee271e4de8642eed6ee3c4428de640aa0caeb589 | 2,446 | py | Python | swain_edward_project3.py | dreadnaught-ETES/school | 9faa2b6379db8f819872b8597896f5291812c5d6 | [
"CC0-1.0"
] | null | null | null | swain_edward_project3.py | dreadnaught-ETES/school | 9faa2b6379db8f819872b8597896f5291812c5d6 | [
"CC0-1.0"
] | null | null | null | swain_edward_project3.py | dreadnaught-ETES/school | 9faa2b6379db8f819872b8597896f5291812c5d6 | [
"CC0-1.0"
] | null | null | null | import random
wordlist='aquarius','aquatic','amused','acerbic','alien','alienate','bemused','mischief','holistic','manual','malnourished','misdemeanor','felony','discharge','disembowel','echelon','epilepsy','pestilent','vestibule','dazed','contrary'
word=random.choice(wordlist)
name=input("Please tell me your name, player: ")
print(f"Hello, {name}, let's play a game.")
print(" ****The Hanged Man****")
print("You have 10 tries to guess my word before the man is hung.")
wrong_list=[]
print(f" My word has {len(word)} letters. Good Luck, {name}.")
guess_list=[]
for i in range (len(word)):
guess_list.append("_")
print(*([i for i in guess_list]))
tries=10
success=[]
for i in range (len(guess_list)):
success.append("_")
while (tries>0):
guess=input("Please guess a letter: ")
if not guess.isalpha():
print("Please make sure your guesses are only letters of the alphabet. Do try to not overcomplicate this...")
tries+=-1
elif (len(guess)>1):
print("I would thank you to keep your guess to just one letter...")
tries+=-1
elif (guess in wrong_list):
print("Deja vu? You have guessed that letter before...")
tries+=-1
if guess in word:
for i in range(len(word)):
if word[i]==guess:
guess_list[i]=word[i]
success[i]=guess_list[i]
if [i for i in success]==[i for i in word]:
print(*([i for i in success]))
print("You guessed my word and the man was saved. Congratulations.")
exit(0)
else:
print("That letter is not in my word. I'm sorry...")
wrong_list.append(guess)
tries+=-1
print("You have already guessed",*([i for i in wrong_list]))
print(*([i for i in guess_list]))
print(f"You have {tries} tries left.")
if tries==-1:
print("You have failed and the man has been hanged...")
print("It's your own fault for giving the same letter every time...")
print(f"My word was {word}...")
while tries==0:
if [i for i in success]==[i for i in word]:
print("You guessed my word and the man was saved. Congratulations.")
exit(0)
if [i for i in success]!=[i for i in word]:
print(f"You have lost and the man was hanged! My word was {word}")
exit(0) | 44.472727 | 236 | 0.582584 |
c0a4dbe712703e4e6258533c4d99175a691d3cab | 5,381 | py | Python | h1/models/quota.py | hyperonecom/h1-client-python | 4ce355852ba3120ec1b8f509ab5894a5c08da730 | [
"MIT"
] | null | null | null | h1/models/quota.py | hyperonecom/h1-client-python | 4ce355852ba3120ec1b8f509ab5894a5c08da730 | [
"MIT"
] | null | null | null | h1/models/quota.py | hyperonecom/h1-client-python | 4ce355852ba3120ec1b8f509ab5894a5c08da730 | [
"MIT"
] | null | null | null | # coding: utf-8
"""
HyperOne
HyperOne API # noqa: E501
The version of the OpenAPI document: 0.1.0
Generated by: https://openapi-generator.tech
"""
import pprint
import re # noqa: F401
import six
from h1.configuration import Configuration
class Quota(object):
"""NOTE: This class is auto generated by OpenAPI Generator.
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
"""
Attributes:
openapi_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.
"""
openapi_types = {
'id': 'str',
'name': 'str',
'metric': 'QuotaMetric',
'usage': 'float',
'limit': 'QuotaLimit'
}
attribute_map = {
'id': 'id',
'name': 'name',
'metric': 'metric',
'usage': 'usage',
'limit': 'limit'
}
def __init__(self, id=None, name=None, metric=None, usage=None, limit=None, local_vars_configuration=None): # noqa: E501
"""Quota - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._id = None
self._name = None
self._metric = None
self._usage = None
self._limit = None
self.discriminator = None
if id is not None:
self.id = id
if name is not None:
self.name = name
if metric is not None:
self.metric = metric
if usage is not None:
self.usage = usage
if limit is not None:
self.limit = limit
@property
def id(self):
"""Gets the id of this Quota. # noqa: E501
:return: The id of this Quota. # noqa: E501
:rtype: str
"""
return self._id
@id.setter
def id(self, id):
"""Sets the id of this Quota.
:param id: The id of this Quota. # noqa: E501
:type: str
"""
self._id = id
@property
def name(self):
"""Gets the name of this Quota. # noqa: E501
:return: The name of this Quota. # noqa: E501
:rtype: str
"""
return self._name
@name.setter
def name(self, name):
"""Sets the name of this Quota.
:param name: The name of this Quota. # noqa: E501
:type: str
"""
self._name = name
@property
def metric(self):
"""Gets the metric of this Quota. # noqa: E501
:return: The metric of this Quota. # noqa: E501
:rtype: QuotaMetric
"""
return self._metric
@metric.setter
def metric(self, metric):
"""Sets the metric of this Quota.
:param metric: The metric of this Quota. # noqa: E501
:type: QuotaMetric
"""
self._metric = metric
@property
def usage(self):
"""Gets the usage of this Quota. # noqa: E501
:return: The usage of this Quota. # noqa: E501
:rtype: float
"""
return self._usage
@usage.setter
def usage(self, usage):
"""Sets the usage of this Quota.
:param usage: The usage of this Quota. # noqa: E501
:type: float
"""
self._usage = usage
@property
def limit(self):
"""Gets the limit of this Quota. # noqa: E501
:return: The limit of this Quota. # noqa: E501
:rtype: QuotaLimit
"""
return self._limit
@limit.setter
def limit(self, limit):
"""Sets the limit of this Quota.
:param limit: The limit of this Quota. # noqa: E501
:type: QuotaLimit
"""
self._limit = limit
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.openapi_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, Quota):
return False
return self.to_dict() == other.to_dict()
def __ne__(self, other):
"""Returns true if both objects are not equal"""
if not isinstance(other, Quota):
return True
return self.to_dict() != other.to_dict()
| 23.915556 | 125 | 0.532615 |
277562a8e12075033a13855aeff72bb3427d0d5b | 666 | py | Python | tests/raylab/policy/modules/test_ddpg.py | angelolovatto/raylab | ebaea8df1a391fb844e75df62ccf1e2e07311d88 | [
"MIT"
] | 29 | 2020-05-05T13:25:33.000Z | 2022-01-03T14:12:29.000Z | tests/raylab/policy/modules/test_ddpg.py | angelolovatto/raylab | ebaea8df1a391fb844e75df62ccf1e2e07311d88 | [
"MIT"
] | 215 | 2019-11-26T12:59:39.000Z | 2022-02-01T12:38:31.000Z | tests/raylab/policy/modules/test_ddpg.py | angelolovatto/raylab | ebaea8df1a391fb844e75df62ccf1e2e07311d88 | [
"MIT"
] | 7 | 2020-06-12T01:42:02.000Z | 2021-05-27T03:40:42.000Z | import pytest
import torch
from torch import nn
from raylab.policy.modules.ddpg import DDPG
@pytest.fixture
def spec_cls():
return DDPG.spec_cls
@pytest.fixture
def module(obs_space, action_space, spec_cls):
return DDPG(obs_space, action_space, spec_cls())
def test_spec(spec_cls):
default_config = spec_cls().to_dict()
for key in ["actor", "critic", "initializer"]:
assert key in default_config
def test_init(module):
assert isinstance(module, nn.Module)
for attr in "actor behavior target_actor critics target_critics".split():
assert hasattr(module, attr)
def test_script(module):
torch.jit.script(module)
| 19.588235 | 77 | 0.726727 |
e43de4663f79a811dd8a6c5a7e032ac0b1760493 | 6,070 | py | Python | kubernetes/client/models/v1alpha1_rule.py | anemerovsky-essextec/python | 6e40b9169b27c3f1f9422c0f6dd1cd9caef8d57c | [
"Apache-2.0"
] | null | null | null | kubernetes/client/models/v1alpha1_rule.py | anemerovsky-essextec/python | 6e40b9169b27c3f1f9422c0f6dd1cd9caef8d57c | [
"Apache-2.0"
] | null | null | null | kubernetes/client/models/v1alpha1_rule.py | anemerovsky-essextec/python | 6e40b9169b27c3f1f9422c0f6dd1cd9caef8d57c | [
"Apache-2.0"
] | null | null | null | # coding: utf-8
"""
Kubernetes
No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
OpenAPI spec version: v1.12.1
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
from pprint import pformat
from six import iteritems
import re
class V1alpha1Rule(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 = {
'api_groups': 'list[str]',
'api_versions': 'list[str]',
'resources': 'list[str]'
}
attribute_map = {
'api_groups': 'apiGroups',
'api_versions': 'apiVersions',
'resources': 'resources'
}
def __init__(self, api_groups=None, api_versions=None, resources=None):
"""
V1alpha1Rule - a model defined in Swagger
"""
self._api_groups = None
self._api_versions = None
self._resources = None
self.discriminator = None
if api_groups is not None:
self.api_groups = api_groups
if api_versions is not None:
self.api_versions = api_versions
if resources is not None:
self.resources = resources
@property
def api_groups(self):
"""
Gets the api_groups of this V1alpha1Rule.
APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required.
:return: The api_groups of this V1alpha1Rule.
:rtype: list[str]
"""
return self._api_groups
@api_groups.setter
def api_groups(self, api_groups):
"""
Sets the api_groups of this V1alpha1Rule.
APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required.
:param api_groups: The api_groups of this V1alpha1Rule.
:type: list[str]
"""
self._api_groups = api_groups
@property
def api_versions(self):
"""
Gets the api_versions of this V1alpha1Rule.
APIVersions is the API versions the resources belong to. '*' is all versions. If '*' is present, the length of the slice must be one. Required.
:return: The api_versions of this V1alpha1Rule.
:rtype: list[str]
"""
return self._api_versions
@api_versions.setter
def api_versions(self, api_versions):
"""
Sets the api_versions of this V1alpha1Rule.
APIVersions is the API versions the resources belong to. '*' is all versions. If '*' is present, the length of the slice must be one. Required.
:param api_versions: The api_versions of this V1alpha1Rule.
:type: list[str]
"""
self._api_versions = api_versions
@property
def resources(self):
"""
Gets the resources of this V1alpha1Rule.
Resources is a list of resources this rule applies to. For example: 'pods' means pods. 'pods/log' means the log subresource of pods. '*' means all resources, but not subresources. 'pods/*' means all subresources of pods. '*/scale' means all scale subresources. '*/*' means all resources and their subresources. If wildcard is present, the validation rule will ensure resources do not overlap with each other. Depending on the enclosing object, subresources might not be allowed. Required.
:return: The resources of this V1alpha1Rule.
:rtype: list[str]
"""
return self._resources
@resources.setter
def resources(self, resources):
"""
Sets the resources of this V1alpha1Rule.
Resources is a list of resources this rule applies to. For example: 'pods' means pods. 'pods/log' means the log subresource of pods. '*' means all resources, but not subresources. 'pods/*' means all subresources of pods. '*/scale' means all scale subresources. '*/*' means all resources and their subresources. If wildcard is present, the validation rule will ensure resources do not overlap with each other. Depending on the enclosing object, subresources might not be allowed. Required.
:param resources: The resources of this V1alpha1Rule.
:type: list[str]
"""
self._resources = resources
def to_dict(self):
"""
Returns the model properties as a dict
"""
result = {}
for attr, _ in iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
return result
def to_str(self):
"""
Returns the string representation of the model
"""
return pformat(self.to_dict())
def __repr__(self):
"""
For `print` and `pprint`
"""
return self.to_str()
def __eq__(self, other):
"""
Returns true if both objects are equal
"""
if not isinstance(other, V1alpha1Rule):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""
Returns true if both objects are not equal
"""
return not self == other
| 33.169399 | 499 | 0.606096 |
1b42bd85c612bdea9bd7bfa637d041c6dbfdbcec | 1,615 | py | Python | data/imgs/figures/first_level_atc_distribution.py | LucaMenestrina/SARS-CoV-2_Networker | 733eb8e4cf4fcfad06b7776067e5a87e9ee92ddb | [
"MIT"
] | 1 | 2022-03-17T11:57:49.000Z | 2022-03-17T11:57:49.000Z | data/imgs/figures/first_level_atc_distribution.py | LucaMenestrina/COVIDrugNet | 6d9ec09dd362c584fccec10adfd37780300eb8ae | [
"MIT"
] | null | null | null | data/imgs/figures/first_level_atc_distribution.py | LucaMenestrina/COVIDrugNet | 6d9ec09dd362c584fccec10adfd37780300eb8ae | [
"MIT"
] | null | null | null | import networkx as nx
import matplotlib.pyplot as plt
from matplotlib.colors import rgb2hex
import numpy as np
import pickle
def draw_ATC_barchart(file):
graph=nx.read_gpickle("../../graphs/drug_projection/drug_projection.gpickle")
ATC_dict=dict(nx.get_node_attributes(graph,"ATC Code Level 1"))
all_atc=["A","B","C","D","G","H","J","L","M","N","P","R","S","V"]
cmap=dict(zip(all_atc,[rgb2hex(plt.cm.Spectral(n)) for n in np.arange(0,1.1,1/14)])) # not necessary but uses the same colors of the Drug Projection (webtool and other figures)
cmap.update({"Not Available":"#708090"})
with open("../../others/atc_description.pickle", "rb") as bkp:
atc_description=pickle.load(bkp)
tmp_atc_values=[l for ll in ATC_dict.values() for l in ll]
ATC_count={atc:tmp_atc_values.count(atc) for atc in cmap.keys()}
ATC_count={k: v for k, v in sorted(ATC_count.items(), key=lambda item: item[1], reverse=True)}#sort by value
for code,value in ATC_count.items():
plt.bar(x=code,height=value, color=cmap[code], label=code, alpha=0.9, align="center")
plt.text(x=code, y=value+0.5, s=str(value), horizontalalignment="center", fontsize="small")
title="First Level ATC Code Distribution"#file.replace("_"," ").title()
plt.ylabel("Number of Nodes")
# plt.xlabel("First Level ATC Code")
plt.xticks(rotation=-45)
plt.tick_params(axis="x", length=0)
plt.title(title)
# plt.legend(bbox_to_anchor=(1.05,1.025))
plt.savefig(file+".svg", bbox_inches="tight")
# plt.show()
plt.close()
draw_ATC_barchart("first_level_ATC_code_distribution")
| 48.939394 | 180 | 0.685449 |
d32f9652554d00340d4fa3dfe08b3db8ad639000 | 2,696 | py | Python | qiime2/core/type/collection.py | misialq/qiime2 | 6d8932eda130d4a9356f977fece2e252c135d0b9 | [
"BSD-3-Clause"
] | 334 | 2016-04-30T16:29:29.000Z | 2022-03-17T19:44:13.000Z | qiime2/core/type/collection.py | misialq/qiime2 | 6d8932eda130d4a9356f977fece2e252c135d0b9 | [
"BSD-3-Clause"
] | 454 | 2016-04-29T22:40:14.000Z | 2022-03-30T17:18:16.000Z | qiime2/core/type/collection.py | misialq/qiime2 | 6d8932eda130d4a9356f977fece2e252c135d0b9 | [
"BSD-3-Clause"
] | 203 | 2016-05-11T22:25:08.000Z | 2022-03-30T17:27:39.000Z | # ----------------------------------------------------------------------------
# Copyright (c) 2016-2021, QIIME 2 development team.
#
# Distributed under the terms of the Modified BSD License.
#
# The full license is in the file LICENSE, distributed with this software.
# ----------------------------------------------------------------------------
import json
from qiime2.core.type.template import TypeTemplate
class _CollectionBase(TypeTemplate):
public_proxy = 'encode', 'decode'
def __init__(self):
# For semantic types
self.variant_of = frozenset()
def __eq__(self, other):
return type(self) is type(other)
def get_name(self):
return self.__class__.__name__[1:] # drop `_`
def get_kind_expr(self, self_expr):
if self_expr.fields:
return self_expr.fields[0].kind
return ""
def get_kind(self):
raise NotImplementedError
def is_variant(self, self_expr, varfield):
return False
def validate_predicate(self, predicate):
raise TypeError("Predicates cannot be applied to %r" % self.get_name())
def is_element_expr(self, self_expr, value):
contained_expr = self_expr.fields[0]
if isinstance(value, self._view) and len(value) > 0:
return all(v in contained_expr for v in value)
return False
def is_element(self, value):
raise NotImplementedError
def get_union_membership_expr(self, self_expr):
return self.get_name() + '-' + self.get_kind_expr(self_expr)
# For primitive types
def encode(self, value):
return json.dumps(list(value))
def decode(self, string):
return self._view(json.loads(string))
class _1DCollectionBase(_CollectionBase):
def validate_field(self, name, field):
if isinstance(field, _1DCollectionBase):
raise TypeError("Cannot nest collection types.")
if field.get_name() in {'MetadataColumn', 'Metadata'}:
raise TypeError("Cannot use %r with metadata." % self.get_name())
def get_field_names(self):
return ['type']
class _Set(_1DCollectionBase):
_view = set
class _List(_1DCollectionBase):
_view = list
class _Tuple(_CollectionBase):
_view = tuple
def get_kind_expr(self, self_expr):
return ""
def get_field_names(self):
return ['*types']
def validate_field_count(self, count):
if not count:
raise TypeError("Tuple type must contain at least one element.")
def validate_field(self, name, field):
# Tuples may contain anything, and as many fields as desired
pass
Set = _Set()
List = _List()
Tuple = _Tuple()
| 26.693069 | 79 | 0.621662 |
e5fbc471a30199099b72c07659df7bd1b4d79345 | 6,917 | py | Python | tests/simulation_tests/test_wake_table_and_monitors.py | fsoubelet/PyHEADTAIL | 51cae8845cceb61cc3f140db4ab0eeb68469110f | [
"BSD-3-Clause"
] | null | null | null | tests/simulation_tests/test_wake_table_and_monitors.py | fsoubelet/PyHEADTAIL | 51cae8845cceb61cc3f140db4ab0eeb68469110f | [
"BSD-3-Clause"
] | null | null | null | tests/simulation_tests/test_wake_table_and_monitors.py | fsoubelet/PyHEADTAIL | 51cae8845cceb61cc3f140db4ab0eeb68469110f | [
"BSD-3-Clause"
] | null | null | null | import os
import pathlib
import h5py
import numpy as np
from scipy.constants import c, e
from scipy.stats import linregress
from scipy.signal import hilbert
from LHC import LHC
from PyHEADTAIL.particles.slicing import UniformBinSlicer
from PyHEADTAIL.impedances.wakes import WakeTable, WakeField
from PyHEADTAIL.feedback.transverse_damper import TransverseDamper
from PyHEADTAIL.monitors.monitors import BunchMonitor, SliceMonitor
def test_monitors():
n_attempts = 5
outputpath = './' # outputpath relative to this file
n_macroparticles = 10000
n_turns = 3000
# Beam and machine parameters
intensity = 1.8e11
epsn_x = 1.8e-6 # normalised horizontal emittance
epsn_y = 1.8e-6 # normalised vertical emittance
Qp_x = -10.0
Qp_y = -10.0
i_oct = 5
dampingrate = 0
wake_folder = pathlib.Path(__file__).parent.joinpath(
'../../examples/impedances').absolute()
# Injection
machine_configuration = 'Injection'
p0 = 450e9*e/c
wakefile = wake_folder.joinpath(
'wakes/wakeforhdtl_PyZbase_Allthemachine_450GeV'
'_B1_LHC_inj_450GeV_B1.dat')
# Detuners
app_x = 2 * p0 * 27380.10941 * i_oct / 100.
app_y = 2 * p0 * 28875.03442 * i_oct / 100.
app_xy = 2 * p0 * -21766.48714 * i_oct / 100.
Qpp_x = 4889.00298 * i_oct / 100.
Qpp_y = -2323.147896 * i_oct / 100.
# Create machine
machine = LHC(n_segments=1,
machine_configuration=machine_configuration,
**{'app_x': app_x, 'app_y': app_y, 'app_xy': app_xy,
'Qp_x': [Qp_x, Qpp_x], 'Qp_y': [Qp_y, Qpp_y]})
sigma_z = 1.2e-9 * machine.beta*c/4. # RMS bunch length in meters
# Wakes
slicer_for_wakefields = UniformBinSlicer(
n_slices=500, z_cuts=(-3*sigma_z, 3*sigma_z))
wake_table1 = WakeTable(wakefile,
['time', 'dipole_x', 'dipole_y',
'noquadrupole_x', 'noquadrupole_y',
'dipole_xy', 'dipole_yx',
])
wake_field = WakeField(slicer_for_wakefields, wake_table1)
# Damper
damper = TransverseDamper(dampingrate, dampingrate)
machine.one_turn_map.append(wake_field)
machine.one_turn_map.append(damper)
# Loop over attempts
i_attempt = 0
while i_attempt < n_attempts:
print(f"Attempt {i_attempt+1}:")
# Create beam
bunch = machine.generate_6D_Gaussian_bunch_matched(
n_macroparticles, intensity, epsn_x, epsn_y, sigma_z=sigma_z)
print("\n--> Bunch length and emittance: {:g} m, {:g} eVs.".format(
bunch.sigma_z(), bunch.epsn_z()))
# Monitors
try:
bucket = machine.longitudinal_map.get_bucket(bunch)
except AttributeError:
bucket = machine.rfbucket
simulation_parameters_dict = {
'gamma': machine.gamma,
'beta': machine.beta,
'intensity': intensity,
'Qx': machine.Q_x,
'Qy': machine.Q_y,
'Qs': bucket.Q_s,
'beta_x': bunch.beta_Twiss_x(),
'beta_y': bunch.beta_Twiss_y(),
'beta_z': bucket.beta_z,
'epsn_x': bunch.epsn_x(),
'epsn_y': bunch.epsn_y(),
'sigma_z': bunch.sigma_z(),
}
bunchmonitor = BunchMonitor(
filename=outputpath+'/bunchmonitor', n_steps=n_turns,
parameters_dict=simulation_parameters_dict,
write_buffer_to_file_every=512, buffer_size=4096)
slicer_for_slicemonitor = UniformBinSlicer(
n_slices=50, z_cuts=(-3*sigma_z, 3*sigma_z))
bunch_stats_to_store = [
'mean_x', 'mean_xp', 'mean_y', 'mean_yp', 'mean_z', 'mean_dp']
slicemonitor = SliceMonitor(
filename=outputpath+'/slicemonitor', n_steps=n_turns,
slicer=slicer_for_slicemonitor,
parameters_dict=simulation_parameters_dict,
write_buffer_every=64, buffer_size=256,
**{'bunch_stats_to_store': bunch_stats_to_store},
)
# Save for plotting
x = np.zeros(n_turns, dtype=float)
# Tracking loop
for i in range(n_turns):
# track the beam around the machine for one turn:
machine.track(bunch)
x[i] = bunch.mean_x()
# monitor the bunch and slice statistics (once per turn):
bunchmonitor.dump(bunch)
slicemonitor.dump(bunch)
# Get data from monitor files
bunch_file = h5py.File(outputpath+'/bunchmonitor.h5')
slice_file = h5py.File(outputpath+'/slicemonitor.h5')
x_from_bunch_file = bunch_file['Bunch']['mean_x'][:]
x_from_slice_file = slice_file['Bunch']['mean_x'][:]
n_per_slice = slice_file['Slices']['n_macroparticles_per_slice'][:]
x_per_slice = slice_file['Slices']['mean_x'][:]
x_from_slices = np.average(x_per_slice, axis=0, weights=n_per_slice)
sx = np.sqrt(epsn_x * bunch_file.attrs['beta_x']
/ bunch_file.attrs['gamma'] / bunch_file.attrs['beta'])
# Check results
turns = np.arange(n_turns)
iMin = 500
iMax = n_turns - 500
ampl = np.abs(hilbert(x))
b, a, r, p, stderr = linregress(turns[iMin:iMax], np.log(ampl[iMin:iMax]))
print(f"Growth rate {b*1e4:.2f} [10^-4/turn]")
ampl = np.abs(hilbert(x_from_slices))
b_from_slices, a, r, p, stderr = linregress(turns[iMin:iMax], np.log(ampl[iMin:iMax]))
print(f"Growth rate from slices {b_from_slices*1e4:.2f} [10^-4/turn]")
h5py.File.close(bunch_file)
h5py.File.close(slice_file)
check_bunch = np.allclose(x_from_bunch_file/sx, x/sx)
check_slice = np.allclose(x_from_slice_file/sx, x/sx)
check_growth_rate = np.allclose(b_from_slices, b, rtol=3e-2)
# assert np.allclose(x_from_bunch_file/sx, x/sx), \
# "x from bunch file doesn't match"
# assert np.allclose(x_from_slice_file/sx, x/sx), \
# "x from slice file doesn't match"
# assert np.allclose(b_from_slices, b, rtol=3e-2), \
# "Growth rate from slices doesn't match"
assert check_bunch or i_attempt < n_attempts-1, \
f"After {n_attempts} attempts x from bunch file doesn't match"
assert check_slice or i_attempt < n_attempts-1, \
f"After {n_attempts} attempts x from slice file doesn't match"
assert check_growth_rate or i_attempt < n_attempts-1, \
f"After {n_attempts} attempts Growth rate from slices doesn't match"
os.remove(outputpath+'/bunchmonitor.h5')
os.remove(outputpath+'/slicemonitor.h5')
if check_bunch and check_slice and check_growth_rate:
print(f"Passed on {i_attempt + 1}. attempt.")
break
i_attempt += 1
| 34.758794 | 94 | 0.616019 |
f14b615471ccc57f947f68a1a8f45e3229f35531 | 33,725 | py | Python | pandas/io/json/json.py | ivary43/pandas | 46adc5b1c2aacb312d72729af72bc0ad600917c0 | [
"BSD-3-Clause"
] | null | null | null | pandas/io/json/json.py | ivary43/pandas | 46adc5b1c2aacb312d72729af72bc0ad600917c0 | [
"BSD-3-Clause"
] | null | null | null | pandas/io/json/json.py | ivary43/pandas | 46adc5b1c2aacb312d72729af72bc0ad600917c0 | [
"BSD-3-Clause"
] | 1 | 2020-11-05T13:46:01.000Z | 2020-11-05T13:46:01.000Z | from io import StringIO
from itertools import islice
import os
import numpy as np
import pandas._libs.json as json
from pandas._libs.tslibs import iNaT
from pandas.errors import AbstractMethodError
from pandas.core.dtypes.common import ensure_str, is_period_dtype
from pandas import DataFrame, MultiIndex, Series, isna, to_datetime
from pandas.core.reshape.concat import concat
from pandas.io.common import (
BaseIterator, _get_handle, _infer_compression, _stringify_path,
get_filepath_or_buffer)
from pandas.io.formats.printing import pprint_thing
from pandas.io.parsers import _validate_integer
from .normalize import _convert_to_line_delimits
from .table_schema import build_table_schema, parse_table_schema
loads = json.loads
dumps = json.dumps
TABLE_SCHEMA_VERSION = '0.20.0'
# interface to/from
def to_json(path_or_buf, obj, orient=None, date_format='epoch',
double_precision=10, force_ascii=True, date_unit='ms',
default_handler=None, lines=False, compression='infer',
index=True):
if not index and orient not in ['split', 'table']:
raise ValueError("'index=False' is only valid when 'orient' is "
"'split' or 'table'")
path_or_buf = _stringify_path(path_or_buf)
if lines and orient != 'records':
raise ValueError(
"'lines' keyword only valid when 'orient' is records")
if orient == 'table' and isinstance(obj, Series):
obj = obj.to_frame(name=obj.name or 'values')
if orient == 'table' and isinstance(obj, DataFrame):
writer = JSONTableWriter
elif isinstance(obj, Series):
writer = SeriesWriter
elif isinstance(obj, DataFrame):
writer = FrameWriter
else:
raise NotImplementedError("'obj' should be a Series or a DataFrame")
s = writer(
obj, orient=orient, date_format=date_format,
double_precision=double_precision, ensure_ascii=force_ascii,
date_unit=date_unit, default_handler=default_handler,
index=index).write()
if lines:
s = _convert_to_line_delimits(s)
if isinstance(path_or_buf, str):
fh, handles = _get_handle(path_or_buf, 'w', compression=compression)
try:
fh.write(s)
finally:
fh.close()
elif path_or_buf is None:
return s
else:
path_or_buf.write(s)
class Writer:
def __init__(self, obj, orient, date_format, double_precision,
ensure_ascii, date_unit, index, default_handler=None):
self.obj = obj
if orient is None:
orient = self._default_orient
self.orient = orient
self.date_format = date_format
self.double_precision = double_precision
self.ensure_ascii = ensure_ascii
self.date_unit = date_unit
self.default_handler = default_handler
self.index = index
self.is_copy = None
self._format_axes()
def _format_axes(self):
raise AbstractMethodError(self)
def write(self):
return self._write(self.obj, self.orient, self.double_precision,
self.ensure_ascii, self.date_unit,
self.date_format == 'iso', self.default_handler)
def _write(self, obj, orient, double_precision, ensure_ascii,
date_unit, iso_dates, default_handler):
return dumps(
obj,
orient=orient,
double_precision=double_precision,
ensure_ascii=ensure_ascii,
date_unit=date_unit,
iso_dates=iso_dates,
default_handler=default_handler
)
class SeriesWriter(Writer):
_default_orient = 'index'
def _format_axes(self):
if not self.obj.index.is_unique and self.orient == 'index':
raise ValueError("Series index must be unique for orient="
"'{orient}'".format(orient=self.orient))
def _write(self, obj, orient, double_precision, ensure_ascii,
date_unit, iso_dates, default_handler):
if not self.index and orient == 'split':
obj = {"name": obj.name, "data": obj.values}
return super()._write(obj, orient, double_precision, ensure_ascii,
date_unit, iso_dates, default_handler)
class FrameWriter(Writer):
_default_orient = 'columns'
def _format_axes(self):
"""
Try to format axes if they are datelike.
"""
if not self.obj.index.is_unique and self.orient in (
'index', 'columns'):
raise ValueError("DataFrame index must be unique for orient="
"'{orient}'.".format(orient=self.orient))
if not self.obj.columns.is_unique and self.orient in (
'index', 'columns', 'records'):
raise ValueError("DataFrame columns must be unique for orient="
"'{orient}'.".format(orient=self.orient))
def _write(self, obj, orient, double_precision, ensure_ascii,
date_unit, iso_dates, default_handler):
if not self.index and orient == 'split':
obj = obj.to_dict(orient='split')
del obj["index"]
return super()._write(obj, orient, double_precision, ensure_ascii,
date_unit, iso_dates, default_handler)
class JSONTableWriter(FrameWriter):
_default_orient = 'records'
def __init__(self, obj, orient, date_format, double_precision,
ensure_ascii, date_unit, index, default_handler=None):
"""
Adds a `schema` attribute with the Table Schema, resets
the index (can't do in caller, because the schema inference needs
to know what the index is, forces orient to records, and forces
date_format to 'iso'.
"""
super().__init__(obj, orient, date_format, double_precision,
ensure_ascii, date_unit, index,
default_handler=default_handler)
if date_format != 'iso':
msg = ("Trying to write with `orient='table'` and "
"`date_format='{fmt}'`. Table Schema requires dates "
"to be formatted with `date_format='iso'`"
.format(fmt=date_format))
raise ValueError(msg)
self.schema = build_table_schema(obj, index=self.index)
# NotImplemented on a column MultiIndex
if obj.ndim == 2 and isinstance(obj.columns, MultiIndex):
raise NotImplementedError(
"orient='table' is not supported for MultiIndex")
# TODO: Do this timedelta properly in objToJSON.c See GH #15137
if ((obj.ndim == 1) and (obj.name in set(obj.index.names)) or
len(obj.columns & obj.index.names)):
msg = "Overlapping names between the index and columns"
raise ValueError(msg)
obj = obj.copy()
timedeltas = obj.select_dtypes(include=['timedelta']).columns
if len(timedeltas):
obj[timedeltas] = obj[timedeltas].applymap(
lambda x: x.isoformat())
# Convert PeriodIndex to datetimes before serialzing
if is_period_dtype(obj.index):
obj.index = obj.index.to_timestamp()
# exclude index from obj if index=False
if not self.index:
self.obj = obj.reset_index(drop=True)
else:
self.obj = obj.reset_index(drop=False)
self.date_format = 'iso'
self.orient = 'records'
self.index = index
def _write(self, obj, orient, double_precision, ensure_ascii,
date_unit, iso_dates, default_handler):
data = super()._write(obj, orient, double_precision, ensure_ascii,
date_unit, iso_dates, default_handler)
serialized = '{{"schema": {schema}, "data": {data}}}'.format(
schema=dumps(self.schema), data=data)
return serialized
def read_json(path_or_buf=None, orient=None, typ='frame', dtype=None,
convert_axes=None, convert_dates=True, keep_default_dates=True,
numpy=False, precise_float=False, date_unit=None, encoding=None,
lines=False, chunksize=None, compression='infer'):
"""
Convert a JSON string to pandas object.
Parameters
----------
path_or_buf : a valid JSON string or file-like, default: None
The string could be a URL. Valid URL schemes include http, ftp, s3,
gcs, and file. For file URLs, a host is expected. For instance, a local
file could be ``file://localhost/path/to/table.json``
orient : string,
Indication of expected JSON string format.
Compatible JSON strings can be produced by ``to_json()`` with a
corresponding orient value.
The set of possible orients is:
- ``'split'`` : dict like
``{index -> [index], columns -> [columns], data -> [values]}``
- ``'records'`` : list like
``[{column -> value}, ... , {column -> value}]``
- ``'index'`` : dict like ``{index -> {column -> value}}``
- ``'columns'`` : dict like ``{column -> {index -> value}}``
- ``'values'`` : just the values array
The allowed and default values depend on the value
of the `typ` parameter.
* when ``typ == 'series'``,
- allowed orients are ``{'split','records','index'}``
- default is ``'index'``
- The Series index must be unique for orient ``'index'``.
* when ``typ == 'frame'``,
- allowed orients are ``{'split','records','index',
'columns','values', 'table'}``
- default is ``'columns'``
- The DataFrame index must be unique for orients ``'index'`` and
``'columns'``.
- The DataFrame columns must be unique for orients ``'index'``,
``'columns'``, and ``'records'``.
.. versionadded:: 0.23.0
'table' as an allowed value for the ``orient`` argument
typ : type of object to recover (series or frame), default 'frame'
dtype : boolean or dict, default None
If True, infer dtypes; if a dict of column to dtype, then use those;
if False, then don't infer dtypes at all, applies only to the data.
For all ``orient`` values except ``'table'``, default is True.
.. versionchanged:: 0.25.0
Not applicable for ``orient='table'``.
convert_axes : boolean, default None
Try to convert the axes to the proper dtypes.
For all ``orient`` values except ``'table'``, default is True.
.. versionchanged:: 0.25.0
Not applicable for ``orient='table'``.
convert_dates : boolean, default True
List of columns to parse for dates; If True, then try to parse
datelike columns default is True; a column label is datelike if
* it ends with ``'_at'``,
* it ends with ``'_time'``,
* it begins with ``'timestamp'``,
* it is ``'modified'``, or
* it is ``'date'``
keep_default_dates : boolean, default True
If parsing dates, then parse the default datelike columns
numpy : boolean, default False
Direct decoding to numpy arrays. Supports numeric data only, but
non-numeric column and index labels are supported. Note also that the
JSON ordering MUST be the same for each term if numpy=True.
precise_float : boolean, default False
Set to enable usage of higher precision (strtod) function when
decoding string to double values. Default (False) is to use fast but
less precise builtin functionality
date_unit : string, default None
The timestamp unit to detect if converting dates. The default behaviour
is to try and detect the correct precision, but if this is not desired
then pass one of 's', 'ms', 'us' or 'ns' to force parsing only seconds,
milliseconds, microseconds or nanoseconds respectively.
encoding : str, default is 'utf-8'
The encoding to use to decode py3 bytes.
.. versionadded:: 0.19.0
lines : boolean, default False
Read the file as a json object per line.
.. versionadded:: 0.19.0
chunksize : integer, default None
Return JsonReader object for iteration.
See the `line-delimited json docs
<http://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#line-delimited-json>`_
for more information on ``chunksize``.
This can only be passed if `lines=True`.
If this is None, the file will be read into memory all at once.
.. versionadded:: 0.21.0
compression : {'infer', 'gzip', 'bz2', 'zip', 'xz', None}, default 'infer'
For on-the-fly decompression of on-disk data. If 'infer', then use
gzip, bz2, zip or xz if path_or_buf is a string ending in
'.gz', '.bz2', '.zip', or 'xz', respectively, and no decompression
otherwise. If using 'zip', the ZIP file must contain only one data
file to be read in. Set to None for no decompression.
.. versionadded:: 0.21.0
Returns
-------
result : Series or DataFrame, depending on the value of `typ`.
See Also
--------
DataFrame.to_json
Notes
-----
Specific to ``orient='table'``, if a :class:`DataFrame` with a literal
:class:`Index` name of `index` gets written with :func:`to_json`, the
subsequent read operation will incorrectly set the :class:`Index` name to
``None``. This is because `index` is also used by :func:`DataFrame.to_json`
to denote a missing :class:`Index` name, and the subsequent
:func:`read_json` operation cannot distinguish between the two. The same
limitation is encountered with a :class:`MultiIndex` and any names
beginning with ``'level_'``.
Examples
--------
>>> df = pd.DataFrame([['a', 'b'], ['c', 'd']],
... index=['row 1', 'row 2'],
... columns=['col 1', 'col 2'])
Encoding/decoding a Dataframe using ``'split'`` formatted JSON:
>>> df.to_json(orient='split')
'{"columns":["col 1","col 2"],
"index":["row 1","row 2"],
"data":[["a","b"],["c","d"]]}'
>>> pd.read_json(_, orient='split')
col 1 col 2
row 1 a b
row 2 c d
Encoding/decoding a Dataframe using ``'index'`` formatted JSON:
>>> df.to_json(orient='index')
'{"row 1":{"col 1":"a","col 2":"b"},"row 2":{"col 1":"c","col 2":"d"}}'
>>> pd.read_json(_, orient='index')
col 1 col 2
row 1 a b
row 2 c d
Encoding/decoding a Dataframe using ``'records'`` formatted JSON.
Note that index labels are not preserved with this encoding.
>>> df.to_json(orient='records')
'[{"col 1":"a","col 2":"b"},{"col 1":"c","col 2":"d"}]'
>>> pd.read_json(_, orient='records')
col 1 col 2
0 a b
1 c d
Encoding with Table Schema
>>> df.to_json(orient='table')
'{"schema": {"fields": [{"name": "index", "type": "string"},
{"name": "col 1", "type": "string"},
{"name": "col 2", "type": "string"}],
"primaryKey": "index",
"pandas_version": "0.20.0"},
"data": [{"index": "row 1", "col 1": "a", "col 2": "b"},
{"index": "row 2", "col 1": "c", "col 2": "d"}]}'
"""
if orient == 'table' and dtype:
raise ValueError("cannot pass both dtype and orient='table'")
if orient == 'table' and convert_axes:
raise ValueError("cannot pass both convert_axes and orient='table'")
if dtype is None and orient != 'table':
dtype = True
if convert_axes is None and orient != 'table':
convert_axes = True
compression = _infer_compression(path_or_buf, compression)
filepath_or_buffer, _, compression, should_close = get_filepath_or_buffer(
path_or_buf, encoding=encoding, compression=compression,
)
json_reader = JsonReader(
filepath_or_buffer, orient=orient, typ=typ, dtype=dtype,
convert_axes=convert_axes, convert_dates=convert_dates,
keep_default_dates=keep_default_dates, numpy=numpy,
precise_float=precise_float, date_unit=date_unit, encoding=encoding,
lines=lines, chunksize=chunksize, compression=compression,
)
if chunksize:
return json_reader
result = json_reader.read()
if should_close:
try:
filepath_or_buffer.close()
except: # noqa: flake8
pass
return result
class JsonReader(BaseIterator):
"""
JsonReader provides an interface for reading in a JSON file.
If initialized with ``lines=True`` and ``chunksize``, can be iterated over
``chunksize`` lines at a time. Otherwise, calling ``read`` reads in the
whole document.
"""
def __init__(self, filepath_or_buffer, orient, typ, dtype, convert_axes,
convert_dates, keep_default_dates, numpy, precise_float,
date_unit, encoding, lines, chunksize, compression):
self.path_or_buf = filepath_or_buffer
self.orient = orient
self.typ = typ
self.dtype = dtype
self.convert_axes = convert_axes
self.convert_dates = convert_dates
self.keep_default_dates = keep_default_dates
self.numpy = numpy
self.precise_float = precise_float
self.date_unit = date_unit
self.encoding = encoding
self.compression = compression
self.lines = lines
self.chunksize = chunksize
self.nrows_seen = 0
self.should_close = False
if self.chunksize is not None:
self.chunksize = _validate_integer("chunksize", self.chunksize, 1)
if not self.lines:
raise ValueError("chunksize can only be passed if lines=True")
data = self._get_data_from_filepath(filepath_or_buffer)
self.data = self._preprocess_data(data)
def _preprocess_data(self, data):
"""
At this point, the data either has a `read` attribute (e.g. a file
object or a StringIO) or is a string that is a JSON document.
If self.chunksize, we prepare the data for the `__next__` method.
Otherwise, we read it into memory for the `read` method.
"""
if hasattr(data, 'read') and not self.chunksize:
data = data.read()
if not hasattr(data, 'read') and self.chunksize:
data = StringIO(data)
return data
def _get_data_from_filepath(self, filepath_or_buffer):
"""
The function read_json accepts three input types:
1. filepath (string-like)
2. file-like object (e.g. open file object, StringIO)
3. JSON string
This method turns (1) into (2) to simplify the rest of the processing.
It returns input types (2) and (3) unchanged.
"""
data = filepath_or_buffer
exists = False
if isinstance(data, str):
try:
exists = os.path.exists(filepath_or_buffer)
# gh-5874: if the filepath is too long will raise here
except (TypeError, ValueError):
pass
if exists or self.compression is not None:
data, _ = _get_handle(filepath_or_buffer, 'r',
encoding=self.encoding,
compression=self.compression)
self.should_close = True
self.open_stream = data
return data
def _combine_lines(self, lines):
"""
Combines a list of JSON objects into one JSON object.
"""
lines = filter(None, map(lambda x: x.strip(), lines))
return '[' + ','.join(lines) + ']'
def read(self):
"""
Read the whole JSON input into a pandas object.
"""
if self.lines and self.chunksize:
obj = concat(self)
elif self.lines:
data = ensure_str(self.data)
obj = self._get_object_parser(
self._combine_lines(data.split('\n'))
)
else:
obj = self._get_object_parser(self.data)
self.close()
return obj
def _get_object_parser(self, json):
"""
Parses a json document into a pandas object.
"""
typ = self.typ
dtype = self.dtype
kwargs = {
"orient": self.orient, "dtype": self.dtype,
"convert_axes": self.convert_axes,
"convert_dates": self.convert_dates,
"keep_default_dates": self.keep_default_dates, "numpy": self.numpy,
"precise_float": self.precise_float, "date_unit": self.date_unit
}
obj = None
if typ == 'frame':
obj = FrameParser(json, **kwargs).parse()
if typ == 'series' or obj is None:
if not isinstance(dtype, bool):
kwargs['dtype'] = dtype
obj = SeriesParser(json, **kwargs).parse()
return obj
def close(self):
"""
If we opened a stream earlier, in _get_data_from_filepath, we should
close it.
If an open stream or file was passed, we leave it open.
"""
if self.should_close:
try:
self.open_stream.close()
except (IOError, AttributeError):
pass
def __next__(self):
lines = list(islice(self.data, self.chunksize))
if lines:
lines_json = self._combine_lines(lines)
obj = self._get_object_parser(lines_json)
# Make sure that the returned objects have the right index.
obj.index = range(self.nrows_seen, self.nrows_seen + len(obj))
self.nrows_seen += len(obj)
return obj
self.close()
raise StopIteration
class Parser:
_STAMP_UNITS = ('s', 'ms', 'us', 'ns')
_MIN_STAMPS = {
's': 31536000,
'ms': 31536000000,
'us': 31536000000000,
'ns': 31536000000000000}
def __init__(self, json, orient, dtype=None, convert_axes=True,
convert_dates=True, keep_default_dates=False, numpy=False,
precise_float=False, date_unit=None):
self.json = json
if orient is None:
orient = self._default_orient
self.orient = orient
self.dtype = dtype
if orient == "split":
numpy = False
if date_unit is not None:
date_unit = date_unit.lower()
if date_unit not in self._STAMP_UNITS:
raise ValueError('date_unit must be one of {units}'
.format(units=self._STAMP_UNITS))
self.min_stamp = self._MIN_STAMPS[date_unit]
else:
self.min_stamp = self._MIN_STAMPS['s']
self.numpy = numpy
self.precise_float = precise_float
self.convert_axes = convert_axes
self.convert_dates = convert_dates
self.date_unit = date_unit
self.keep_default_dates = keep_default_dates
self.obj = None
def check_keys_split(self, decoded):
"""
Checks that dict has only the appropriate keys for orient='split'.
"""
bad_keys = set(decoded.keys()).difference(set(self._split_keys))
if bad_keys:
bad_keys = ", ".join(bad_keys)
raise ValueError("JSON data had unexpected key(s): {bad_keys}"
.format(bad_keys=pprint_thing(bad_keys)))
def parse(self):
# try numpy
numpy = self.numpy
if numpy:
self._parse_numpy()
else:
self._parse_no_numpy()
if self.obj is None:
return None
if self.convert_axes:
self._convert_axes()
self._try_convert_types()
return self.obj
def _convert_axes(self):
"""
Try to convert axes.
"""
for axis in self.obj._AXIS_NUMBERS.keys():
new_axis, result = self._try_convert_data(
axis, self.obj._get_axis(axis), use_dtypes=False,
convert_dates=True)
if result:
setattr(self.obj, axis, new_axis)
def _try_convert_types(self):
raise AbstractMethodError(self)
def _try_convert_data(self, name, data, use_dtypes=True,
convert_dates=True):
"""
Try to parse a ndarray like into a column by inferring dtype.
"""
# don't try to coerce, unless a force conversion
if use_dtypes:
if not self.dtype:
return data, False
elif self.dtype is True:
pass
else:
# dtype to force
dtype = (self.dtype.get(name)
if isinstance(self.dtype, dict) else self.dtype)
if dtype is not None:
try:
dtype = np.dtype(dtype)
return data.astype(dtype), True
except (TypeError, ValueError):
return data, False
if convert_dates:
new_data, result = self._try_convert_to_date(data)
if result:
return new_data, True
result = False
if data.dtype == 'object':
# try float
try:
data = data.astype('float64')
result = True
except (TypeError, ValueError):
pass
if data.dtype.kind == 'f':
if data.dtype != 'float64':
# coerce floats to 64
try:
data = data.astype('float64')
result = True
except (TypeError, ValueError):
pass
# don't coerce 0-len data
if len(data) and (data.dtype == 'float' or data.dtype == 'object'):
# coerce ints if we can
try:
new_data = data.astype('int64')
if (new_data == data).all():
data = new_data
result = True
except (TypeError, ValueError):
pass
# coerce ints to 64
if data.dtype == 'int':
# coerce floats to 64
try:
data = data.astype('int64')
result = True
except (TypeError, ValueError):
pass
return data, result
def _try_convert_to_date(self, data):
"""
Try to parse a ndarray like into a date column.
Try to coerce object in epoch/iso formats and integer/float in epoch
formats. Return a boolean if parsing was successful.
"""
# no conversion on empty
if not len(data):
return data, False
new_data = data
if new_data.dtype == 'object':
try:
new_data = data.astype('int64')
except (TypeError, ValueError, OverflowError):
pass
# ignore numbers that are out of range
if issubclass(new_data.dtype.type, np.number):
in_range = (isna(new_data.values) | (new_data > self.min_stamp) |
(new_data.values == iNaT))
if not in_range.all():
return data, False
date_units = (self.date_unit,) if self.date_unit else self._STAMP_UNITS
for date_unit in date_units:
try:
new_data = to_datetime(new_data, errors='raise',
unit=date_unit)
except ValueError:
continue
except Exception:
break
return new_data, True
return data, False
def _try_convert_dates(self):
raise AbstractMethodError(self)
class SeriesParser(Parser):
_default_orient = 'index'
_split_keys = ('name', 'index', 'data')
def _parse_no_numpy(self):
json = self.json
orient = self.orient
if orient == "split":
decoded = {str(k): v for k, v in loads(
json, precise_float=self.precise_float).items()}
self.check_keys_split(decoded)
self.obj = Series(dtype=None, **decoded)
else:
self.obj = Series(
loads(json, precise_float=self.precise_float), dtype=None)
def _parse_numpy(self):
json = self.json
orient = self.orient
if orient == "split":
decoded = loads(json, dtype=None, numpy=True,
precise_float=self.precise_float)
decoded = {str(k): v for k, v in decoded.items()}
self.check_keys_split(decoded)
self.obj = Series(**decoded)
elif orient == "columns" or orient == "index":
self.obj = Series(*loads(json, dtype=None, numpy=True,
labelled=True,
precise_float=self.precise_float))
else:
self.obj = Series(loads(json, dtype=None, numpy=True,
precise_float=self.precise_float))
def _try_convert_types(self):
if self.obj is None:
return
obj, result = self._try_convert_data(
'data', self.obj, convert_dates=self.convert_dates)
if result:
self.obj = obj
class FrameParser(Parser):
_default_orient = 'columns'
_split_keys = ('columns', 'index', 'data')
def _parse_numpy(self):
json = self.json
orient = self.orient
if orient == "columns":
args = loads(json, dtype=None, numpy=True, labelled=True,
precise_float=self.precise_float)
if len(args):
args = (args[0].T, args[2], args[1])
self.obj = DataFrame(*args)
elif orient == "split":
decoded = loads(json, dtype=None, numpy=True,
precise_float=self.precise_float)
decoded = {str(k): v for k, v in decoded.items()}
self.check_keys_split(decoded)
self.obj = DataFrame(**decoded)
elif orient == "values":
self.obj = DataFrame(loads(json, dtype=None, numpy=True,
precise_float=self.precise_float))
else:
self.obj = DataFrame(*loads(json, dtype=None, numpy=True,
labelled=True,
precise_float=self.precise_float))
def _parse_no_numpy(self):
json = self.json
orient = self.orient
if orient == "columns":
self.obj = DataFrame(
loads(json, precise_float=self.precise_float), dtype=None)
elif orient == "split":
decoded = {str(k): v for k, v in loads(
json, precise_float=self.precise_float).items()}
self.check_keys_split(decoded)
self.obj = DataFrame(dtype=None, **decoded)
elif orient == "index":
self.obj = DataFrame(
loads(json, precise_float=self.precise_float), dtype=None).T
elif orient == 'table':
self.obj = parse_table_schema(json,
precise_float=self.precise_float)
else:
self.obj = DataFrame(
loads(json, precise_float=self.precise_float), dtype=None)
def _process_converter(self, f, filt=None):
"""
Take a conversion function and possibly recreate the frame.
"""
if filt is None:
filt = lambda col, c: True
needs_new_obj = False
new_obj = dict()
for i, (col, c) in enumerate(self.obj.iteritems()):
if filt(col, c):
new_data, result = f(col, c)
if result:
c = new_data
needs_new_obj = True
new_obj[i] = c
if needs_new_obj:
# possibly handle dup columns
new_obj = DataFrame(new_obj, index=self.obj.index)
new_obj.columns = self.obj.columns
self.obj = new_obj
def _try_convert_types(self):
if self.obj is None:
return
if self.convert_dates:
self._try_convert_dates()
self._process_converter(
lambda col, c: self._try_convert_data(col, c, convert_dates=False))
def _try_convert_dates(self):
if self.obj is None:
return
# our columns to parse
convert_dates = self.convert_dates
if convert_dates is True:
convert_dates = []
convert_dates = set(convert_dates)
def is_ok(col):
"""
Return if this col is ok to try for a date parse.
"""
if not isinstance(col, str):
return False
col_lower = col.lower()
if (col_lower.endswith('_at') or
col_lower.endswith('_time') or
col_lower == 'modified' or
col_lower == 'date' or
col_lower == 'datetime' or
col_lower.startswith('timestamp')):
return True
return False
self._process_converter(
lambda col, c: self._try_convert_to_date(c),
lambda col, c: ((self.keep_default_dates and is_ok(col)) or
col in convert_dates))
| 34.875905 | 94 | 0.572009 |
e60a4fe3bd3095e49bd4927a0fdabae3ee8d1a3f | 974 | py | Python | sdk/python/pulumi_azure_native/elastic/__init__.py | polivbr/pulumi-azure-native | 09571f3bf6bdc4f3621aabefd1ba6c0d4ecfb0e7 | [
"Apache-2.0"
] | null | null | null | sdk/python/pulumi_azure_native/elastic/__init__.py | polivbr/pulumi-azure-native | 09571f3bf6bdc4f3621aabefd1ba6c0d4ecfb0e7 | [
"Apache-2.0"
] | null | null | null | sdk/python/pulumi_azure_native/elastic/__init__.py | polivbr/pulumi-azure-native | 09571f3bf6bdc4f3621aabefd1ba6c0d4ecfb0e7 | [
"Apache-2.0"
] | null | null | null | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
from .. import _utilities
import typing
# Export this package's modules as members:
from ._enums import *
from .get_monitor import *
from .get_tag_rule import *
from .list_deployment_info import *
from .list_monitored_resource import *
from .list_vm_host import *
from .monitor import *
from .tag_rule import *
from ._inputs import *
from . import outputs
# Make subpackages available:
if typing.TYPE_CHECKING:
import pulumi_azure_native.elastic.v20200701 as __v20200701
v20200701 = __v20200701
import pulumi_azure_native.elastic.v20200701preview as __v20200701preview
v20200701preview = __v20200701preview
else:
v20200701 = _utilities.lazy_import('pulumi_azure_native.elastic.v20200701')
v20200701preview = _utilities.lazy_import('pulumi_azure_native.elastic.v20200701preview')
| 33.586207 | 93 | 0.783368 |
4374bcc8f510774bc67075e7fcd6c701dfb6236c | 6,302 | py | Python | truck.py | therealr5/TruckSimulatorBot | c14c640401d4b45f7218ab9a460867e33f223ab4 | [
"MIT"
] | 2 | 2021-09-01T22:22:21.000Z | 2021-09-03T09:53:08.000Z | truck.py | therealr5/TruckSimulatorBot | c14c640401d4b45f7218ab9a460867e33f223ab4 | [
"MIT"
] | 1 | 2022-02-14T16:59:57.000Z | 2022-02-14T16:59:57.000Z | truck.py | therealr5/TruckSimulatorBot | c14c640401d4b45f7218ab9a460867e33f223ab4 | [
"MIT"
] | 4 | 2021-06-22T20:39:03.000Z | 2022-02-11T15:24:58.000Z | """
This module contains the Cog for all truck-related commands
"""
from math import log
import discord
from discord.ext import commands
from discord_slash import cog_ext
from discord_slash.utils.manage_commands import create_choice, create_option
import resources.players as players
import resources.trucks as trucks
import resources.symbols as symbols
def get_truck_embed(truck: trucks.Truck) -> discord.Embed:
"""
Returns an embed with details about the given Truck
"""
truck_embed = discord.Embed(title=truck.name, description=truck.description, colour=discord.Colour.lighter_grey())
truck_embed.add_field(name="Gas consumption", value=f"{truck.gas_consumption} litres per mile")
truck_embed.add_field(name="Gas capacity", value=str(truck.gas_capacity) + " l")
truck_embed.add_field(name="Price", value="$" + str(truck.price))
truck_embed.add_field(name="Loading capacity", value=f"{truck.loading_capacity} items")
truck_embed.set_image(url=truck.image_url)
return truck_embed
def get_truck_choices() -> list:
choices = []
for truck in trucks.get_all():
choices.append(create_choice(name=truck.name, value=truck.truck_id))
return choices
class Trucks(commands.Cog):
"""
Check up your truck and its current load
"""
def __init__(self, bot) -> None:
self.bot = bot
super().__init__()
@cog_ext.cog_subcommand(base="truck")
async def show(self, ctx, user: discord.User = None) -> None:
"""
Get details about your truck and the trucks of your friends
"""
if isinstance(user, str):
user = await self.bot.fetch_user(int(user))
if user is not None:
player = await players.get(user.id)
avatar_url = user.avatar_url
else:
player = await players.get(ctx.author.id)
avatar_url = ctx.author.avatar_url
# Detect, when the player is renamed
if player.name != ctx.author.name:
await players.update(player, name=ctx.author.name)
truck = trucks.get(player.truck_id)
truck_embed = get_truck_embed(truck)
truck_embed.set_author(name="{}'s truck".format(player.name), icon_url=avatar_url)
truck_embed.set_footer(
icon_url=self.bot.user.avatar_url,
text="See all trucks with `/truck list` and change your truck with `/truck buy`",
)
await ctx.send(embed=truck_embed)
@cog_ext.cog_subcommand(
base="truck",
options=[
create_option(
name="truck",
description="The truck you want to buy",
option_type=4,
required=True,
choices=get_truck_choices(),
)
],
)
async def buy(self, ctx, truck) -> None:
"""
Buy a new truck, your old one will be sold and your miles will be reset
"""
if await players.is_driving(ctx.author.id):
await ctx.send(f"{ctx.author.mention} You can't buy a new truck while you are driving in the old one")
return
player = await players.get(ctx.author.id)
old_truck = trucks.get(player.truck_id)
new_truck = trucks.get(truck)
selling_price = round(old_truck.price - (old_truck.price / 10) * log(player.truck_miles + 1))
end_price = new_truck.price - selling_price
# this also adds money if the end price is negative
await player.debit_money(end_price)
await players.update(player, truck_miles=0, gas=new_truck.gas_capacity, truck_id=new_truck.truck_id)
answer_embed = discord.Embed(
description=f"You sold your old {old_truck.name} for ${selling_price} and bought a brand new {new_truck.name} for ${new_truck.price}",
colour=discord.Colour.lighter_grey(),
)
answer_embed.set_author(name="You got a new truck", icon_url=self.bot.user.avatar_url)
answer_embed.set_footer(text="Check out your new baby with `/truck show`")
await ctx.send(embed=answer_embed)
@cog_ext.cog_subcommand(
base="truck",
options=[
create_option(
name="truck",
description="The truck you want to view",
option_type=4,
required=True,
choices=get_truck_choices(),
)
],
)
async def view(self, ctx, truck) -> None:
"""
View details about a specific truck
"""
truck_embed = get_truck_embed(trucks.get(truck))
truck_embed.set_footer(
icon_url=self.bot.user.avatar_url,
text="See all trucks with `/truck list` and change your truck with `/truck buy`",
)
await ctx.send(embed=truck_embed)
@cog_ext.cog_subcommand(base="truck")
async def list(self, ctx) -> None:
"""
Lists all available Trucks
"""
list_embed = discord.Embed(title="All available trucks", colour=discord.Colour.lighter_grey())
for truck in trucks.get_all():
list_embed.add_field(
name=truck.name, value="Id: {} \n Price: ${:,}".format(truck.truck_id, truck.price), inline=False
)
list_embed.set_footer(
icon_url=self.bot.user.avatar_url, text="Get more information about a truck with `/truck view <id>`"
)
await ctx.send(embed=list_embed)
@cog_ext.cog_slash()
async def load(self, ctx) -> None:
"""
Shows what your Truck currently has loaded
"""
player = await players.get(ctx.author.id)
item_list = ""
if len(player.loaded_items) == 0:
item_list = "Your truck is empty"
else:
for item in player.loaded_items:
item_list += f"{symbols.LIST_ITEM} {self.bot.get_emoji(item.emoji)} {item.name}\n"
load_embed = discord.Embed(
title="Your currently loaded items", description=item_list, colour=discord.Colour.lighter_grey()
)
load_embed.set_footer(
text=f"Loaded items: {len(player.loaded_items)}/{trucks.get(player.truck_id).loading_capacity}"
)
await ctx.send(embed=load_embed)
def setup(bot):
bot.add_cog(Trucks(bot))
| 38.193939 | 146 | 0.625992 |
7c798b155d7c1ca996056fca271ae048182a91e2 | 5,663 | py | Python | filebeat/tests/system/test_ml.py | IzekChen/beats | 0e52267c104181eb4c4422a4d939f68c9e994ced | [
"ECL-2.0",
"Apache-2.0"
] | 26 | 2017-11-08T09:13:21.000Z | 2020-12-14T06:08:53.000Z | filebeat/tests/system/test_ml.py | IzekChen/beats | 0e52267c104181eb4c4422a4d939f68c9e994ced | [
"ECL-2.0",
"Apache-2.0"
] | 5 | 2017-09-05T03:49:06.000Z | 2020-01-02T13:07:10.000Z | filebeat/tests/system/test_ml.py | IzekChen/beats | 0e52267c104181eb4c4422a4d939f68c9e994ced | [
"ECL-2.0",
"Apache-2.0"
] | 12 | 2018-03-26T07:56:47.000Z | 2021-02-06T19:21:24.000Z | from filebeat import BaseTest
from beat.beat import INTEGRATION_TESTS
import os
import unittest
import shutil
import subprocess
from elasticsearch import Elasticsearch
import logging
from parameterized import parameterized
class Test(BaseTest):
def init(self):
self.elasticsearch_url = self.get_elasticsearch_url()
self.kibana_url = self.get_kibana_url()
print("Using elasticsearch: {}".format(self.elasticsearch_url))
self.es = Elasticsearch([self.elasticsearch_url])
logging.getLogger("urllib3").setLevel(logging.WARNING)
logging.getLogger("elasticsearch").setLevel(logging.ERROR)
self.modules_path = os.path.abspath(self.working_dir +
"/../../../../module")
self.kibana_path = os.path.abspath(self.working_dir +
"/../../../../_meta/kibana.generated")
self.filebeat = os.path.abspath(self.working_dir +
"/../../../../filebeat.test")
self.index_name = "test-filebeat-ml"
@parameterized.expand([
(True, False),
(True, True),
(False, False),
(False, True),
])
@unittest.skipIf(not INTEGRATION_TESTS,
"integration tests are disabled, run with INTEGRATION_TESTS=1 to enable them.")
@unittest.skipIf(os.getenv("TESTING_ENVIRONMENT") == "2x",
"integration test not available on 2.x")
@unittest.skipIf(os.name == "nt", "skipped on Windows")
def test_ml_setup(self, setup_flag, modules_flag):
""" Test ML are installed in all possible ways """
self._run_ml_test(setup_flag, modules_flag)
def _run_ml_test(self, setup_flag, modules_flag):
self.init()
from elasticsearch import AuthorizationException
try:
output = self.es.transport.perform_request("POST", "/_xpack/license/start_trial?acknowledge=true")
except AuthorizationException:
print("License already enabled")
print("Test setup_flag: {}, modules_flag: {}".format(setup_flag, modules_flag))
# Clean any previous state
for df in self.es.transport.perform_request("GET", "/_xpack/ml/datafeeds/")["datafeeds"]:
if df["datafeed_id"] == 'filebeat-nginx-access-response_code':
self.es.transport.perform_request(
"DELETE", "/_xpack/ml/datafeeds/" + df["datafeed_id"])
for df in self.es.transport.perform_request("GET", "/_xpack/ml/anomaly_detectors/")["jobs"]:
if df["job_id"] == 'datafeed-filebeat-nginx-access-response_code':
self.es.transport.perform_request(
"DELETE", "/_xpack/ml/anomaly_detectors/" + df["job_id"])
shutil.rmtree(os.path.join(self.working_dir,
"modules.d"), ignore_errors=True)
# generate a minimal configuration
cfgfile = os.path.join(self.working_dir, "filebeat.yml")
self.render_config_template(
template_name="filebeat_modules",
output=cfgfile,
index_name=self.index_name,
elasticsearch_url=self.elasticsearch_url,
kibana_url=self.kibana_url,
kibana_path=self.kibana_path)
if not modules_flag:
# Enable nginx
os.mkdir(os.path.join(self.working_dir, "modules.d"))
with open(os.path.join(self.working_dir, "modules.d/nginx.yml"), "wb") as nginx:
nginx.write("- module: nginx")
cmd = [
self.filebeat, "-systemTest",
"-e", "-d", "*",
"-c", cfgfile
]
# Skipping dashboard loading to speed up tests, unfortunately only works for setup and not --setup
cmd += ["-E", "setup.dashboards.enabled=false"]
if setup_flag:
cmd += ["--setup"]
else:
cmd += ["setup", "--machine-learning"]
if modules_flag:
cmd += ["--modules=nginx"]
output_path = os.path.join(self.working_dir, "output.log")
output = open(output_path, "ab")
output.write(" ".join(cmd) + "\n")
beat = subprocess.Popen(cmd,
stdin=None,
stdout=output,
stderr=output,
bufsize=0)
# Check result
self.wait_until(lambda: "filebeat-nginx-access-response_code" in
(df["job_id"] for df in self.es.transport.perform_request(
"GET", "/_xpack/ml/anomaly_detectors/")["jobs"]),
max_timeout=60)
self.wait_until(lambda: "datafeed-filebeat-nginx-access-response_code" in
(df["datafeed_id"] for df in self.es.transport.perform_request("GET", "/_xpack/ml/datafeeds/")["datafeeds"]))
beat.kill()
# check if fails during trying to setting it up again
output = open(output_path, "ab")
output.write(" ".join(cmd) + "\n")
beat = subprocess.Popen(cmd,
stdin=None,
stdout=output,
stderr=output,
bufsize=0)
output = open(output_path, "r")
for obj in ["Datafeed", "Job", "Dashboard", "Search", "Visualization"]:
self.wait_log_contains("{obj} already exists".format(obj=obj),
logfile=output_path,
max_timeout=60)
beat.kill()
| 39.880282 | 141 | 0.560833 |
eccc3e243e9efdb42c0e03960585ed4c4bbe389f | 4,471 | py | Python | desktop/core/ext-py/dnspython-1.15.0/tests/test_wiredata.py | kokosing/hue | 2307f5379a35aae9be871e836432e6f45138b3d9 | [
"Apache-2.0"
] | 5,079 | 2015-01-01T03:39:46.000Z | 2022-03-31T07:38:22.000Z | desktop/core/ext-py/dnspython-1.15.0/tests/test_wiredata.py | zks888/hue | 93a8c370713e70b216c428caa2f75185ef809deb | [
"Apache-2.0"
] | 1,623 | 2015-01-01T08:06:24.000Z | 2022-03-30T19:48:52.000Z | desktop/core/ext-py/dnspython-1.15.0/tests/test_wiredata.py | zks888/hue | 93a8c370713e70b216c428caa2f75185ef809deb | [
"Apache-2.0"
] | 2,033 | 2015-01-04T07:18:02.000Z | 2022-03-28T19:55:47.000Z | # Copyright (C) 2016
# Author: Martin Basti <martin.basti@gmail.com>
#
# Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose with or without fee is hereby granted,
# provided that the above copyright notice and this permission notice
# appear in all copies.
try:
import unittest2 as unittest
except ImportError:
import unittest
from dns.exception import FormError
from dns.wiredata import WireData
class WireDataSlicingTestCase(unittest.TestCase):
def testSliceAll(self):
"""Get all data"""
inst = WireData(b'0123456789')
self.assertEqual(inst[:], WireData(b'0123456789'))
def testSliceAllExplicitlyDefined(self):
"""Get all data"""
inst = WireData(b'0123456789')
self.assertEqual(inst[0:10], WireData(b'0123456789'))
def testSliceLowerHalf(self):
"""Get lower half of data"""
inst = WireData(b'0123456789')
self.assertEqual(inst[:5], WireData(b'01234'))
def testSliceLowerHalfWithNegativeIndex(self):
"""Get lower half of data"""
inst = WireData(b'0123456789')
self.assertEqual(inst[:-5], WireData(b'01234'))
def testSliceUpperHalf(self):
"""Get upper half of data"""
inst = WireData(b'0123456789')
self.assertEqual(inst[5:], WireData(b'56789'))
def testSliceMiddle(self):
"""Get data from middle"""
inst = WireData(b'0123456789')
self.assertEqual(inst[3:6], WireData(b'345'))
def testSliceMiddleWithNegativeIndex(self):
"""Get data from middle"""
inst = WireData(b'0123456789')
self.assertEqual(inst[-6:-3], WireData(b'456'))
def testSliceMiddleWithMixedIndex(self):
"""Get data from middle"""
inst = WireData(b'0123456789')
self.assertEqual(inst[-8:3], WireData(b'2'))
self.assertEqual(inst[5:-3], WireData(b'56'))
def testGetOne(self):
"""Get data one by one item"""
data = b'0123456789'
inst = WireData(data)
for i, byte in enumerate(bytearray(data)):
self.assertEqual(inst[i], byte)
for i in range(-1, len(data) * -1, -1):
self.assertEqual(inst[i], bytearray(data)[i])
def testEmptySlice(self):
"""Test empty slice"""
data = b'0123456789'
inst = WireData(data)
for i, byte in enumerate(data):
self.assertEqual(inst[i:i], b'')
for i in range(-1, len(data) * -1, -1):
self.assertEqual(inst[i:i], b'')
self.assertEqual(inst[-3:-6], b'')
def testSliceStartOutOfLowerBorder(self):
"""Get data from out of lower border"""
inst = WireData(b'0123456789')
with self.assertRaises(FormError):
inst[-11:] # pylint: disable=pointless-statement
def testSliceStopOutOfLowerBorder(self):
"""Get data from out of lower border"""
inst = WireData(b'0123456789')
with self.assertRaises(FormError):
inst[:-11] # pylint: disable=pointless-statement
def testSliceBothOutOfLowerBorder(self):
"""Get data from out of lower border"""
inst = WireData(b'0123456789')
with self.assertRaises(FormError):
inst[-12:-11] # pylint: disable=pointless-statement
def testSliceStartOutOfUpperBorder(self):
"""Get data from out of upper border"""
inst = WireData(b'0123456789')
with self.assertRaises(FormError):
inst[11:] # pylint: disable=pointless-statement
def testSliceStopOutOfUpperBorder(self):
"""Get data from out of upper border"""
inst = WireData(b'0123456789')
with self.assertRaises(FormError):
inst[:11] # pylint: disable=pointless-statement
def testSliceBothOutOfUpperBorder(self):
"""Get data from out of lower border"""
inst = WireData(b'0123456789')
with self.assertRaises(FormError):
inst[10:20] # pylint: disable=pointless-statement
def testGetOneOutOfLowerBorder(self):
"""Get item outside of range"""
inst = WireData(b'0123456789')
with self.assertRaises(FormError):
inst[-11] # pylint: disable=pointless-statement
def testGetOneOutOfUpperBorder(self):
"""Get item outside of range"""
inst = WireData(b'0123456789')
with self.assertRaises(FormError):
inst[10] # pylint: disable=pointless-statement
| 35.204724 | 71 | 0.631179 |
26f265c76287c360ad13ee3f744daeab745e3e19 | 1,275 | py | Python | tests/test_visitors/test_ast/test_complexity/test_counts/test_module_counts.py | AlwxSin/wemake-python-styleguide | 467f5a8804bcce67aa8ce1ee5c7e2494b530eea7 | [
"MIT"
] | null | null | null | tests/test_visitors/test_ast/test_complexity/test_counts/test_module_counts.py | AlwxSin/wemake-python-styleguide | 467f5a8804bcce67aa8ce1ee5c7e2494b530eea7 | [
"MIT"
] | null | null | null | tests/test_visitors/test_ast/test_complexity/test_counts/test_module_counts.py | AlwxSin/wemake-python-styleguide | 467f5a8804bcce67aa8ce1ee5c7e2494b530eea7 | [
"MIT"
] | null | null | null | # -*- coding: utf-8 -*-
import pytest
from wemake_python_styleguide.visitors.ast.complexity.counts import (
ModuleMembersVisitor,
TooManyModuleMembersViolation,
)
module_with_function_and_class = """
def first(): ...
class Second(object): ...
"""
module_with_methods = """
class First(object):
def method(self): ...
class Second(object):
def method2(self): ...
"""
@pytest.mark.parametrize('code', [
module_with_function_and_class,
module_with_methods,
])
def test_module_counts_normal(
assert_errors, parse_ast_tree, code, default_options,
):
"""Testing that classes and functions in a module work well."""
tree = parse_ast_tree(code)
visitor = ModuleMembersVisitor(default_options, tree=tree)
visitor.run()
assert_errors(visitor, [])
@pytest.mark.parametrize('code', [
module_with_function_and_class,
module_with_methods,
])
def test_module_counts_violation(
assert_errors, parse_ast_tree, code, options,
):
"""Testing that violations are raised when reaching max value."""
tree = parse_ast_tree(code)
option_values = options(max_module_members=1)
visitor = ModuleMembersVisitor(option_values, tree=tree)
visitor.run()
assert_errors(visitor, [TooManyModuleMembersViolation])
| 22.767857 | 69 | 0.724706 |
980fe17adb6a7147c35c77ff04f465abece6c2fa | 695 | py | Python | aiogram/types/shipping_query.py | muhammedfurkan/aiogram | 692c1340b4dda556da640e5f9ea2200848c06840 | [
"MIT"
] | null | null | null | aiogram/types/shipping_query.py | muhammedfurkan/aiogram | 692c1340b4dda556da640e5f9ea2200848c06840 | [
"MIT"
] | 4 | 2020-11-04T15:55:55.000Z | 2020-11-08T21:36:02.000Z | aiogram/types/shipping_query.py | muhammedfurkan/aiogram | 692c1340b4dda556da640e5f9ea2200848c06840 | [
"MIT"
] | null | null | null | from . import base, fields
from .shipping_address import ShippingAddress
from .user import User
class ShippingQuery(base.TelegramObject):
"""
This object contains information about an incoming shipping query.
https://core.telegram.org/bots/api#shippingquery
"""
id: base.String = fields.Field()
from_user: User = fields.Field(alias="from", base=User)
invoice_payload: base.String = fields.Field()
shipping_address: ShippingAddress = fields.Field(base=ShippingAddress)
def __hash__(self):
return self.id
def __eq__(self, other):
if isinstance(other, type(self)):
return other.id == self.id
return self.id == other
| 27.8 | 74 | 0.689209 |
c94b47fa71b403e0ea12fd1af78288a8c9aa94bc | 845 | py | Python | git/client.py | laincloud/Console | 9d4fb68ad5378279697803ca45a4eda58d72d9a3 | [
"MIT"
] | 11 | 2016-05-04T11:55:01.000Z | 2018-09-29T01:00:05.000Z | git/client.py | laincloud/Console | 9d4fb68ad5378279697803ca45a4eda58d72d9a3 | [
"MIT"
] | 21 | 2016-05-25T06:54:44.000Z | 2019-06-06T00:38:38.000Z | git/client.py | laincloud/Console | 9d4fb68ad5378279697803ca45a4eda58d72d9a3 | [
"MIT"
] | 16 | 2016-05-13T08:20:43.000Z | 2021-12-31T09:23:14.000Z | # coding:utf-8
import time
import requests
from commons.settings import GITLAB_TOKEN
from gitlab import GitLabApi
from util import parse_giturl
SUPPORT_GIT_TYPE = {'gitlab': GitLabApi(GITLAB_TOKEN)}
TIMEFORMAT_ISO8601 = '%Y-%m-%dT%H:%M:%S%z'
def fetch_project_commits(giturl, from_timestamp, until_timestamp=None):
scheme, host, namespace, project = parse_giturl(giturl)
if scheme is None:
return
git_type = host.split('.')[0]
git_api = SUPPORT_GIT_TYPE.get(git_type, None)
if git_api is None:
return
since = time.strftime(TIMEFORMAT_ISO8601, time.gmtime(from_timestamp + 1))
until = None
if until_timestamp is not None:
until = time.strftime(TIMEFORMAT_ISO8601, time.gmtime(until_timestamp))
return git_api.fetch_project_commits(scheme, host, namespace, project, since, until)
| 29.137931 | 88 | 0.733728 |
176b0df46711b9a79ec6667e3b32f1932c64d574 | 18,675 | py | Python | firefly_cli/_version.py | darnir/firefly-cli | 2c6e5a917135efd3b3f6e7cf6bae989457d9b0c1 | [
"Apache-2.0"
] | null | null | null | firefly_cli/_version.py | darnir/firefly-cli | 2c6e5a917135efd3b3f6e7cf6bae989457d9b0c1 | [
"Apache-2.0"
] | null | null | null | firefly_cli/_version.py | darnir/firefly-cli | 2c6e5a917135efd3b3f6e7cf6bae989457d9b0c1 | [
"Apache-2.0"
] | null | null | null |
# This file helps to compute a version number in source trees obtained from
# git-archive tarball (such as those provided by githubs download-from-tag
# feature). Distribution tarballs (built by setup.py sdist) and build
# directories (produced by setup.py build) will contain a much shorter file
# that just contains the computed version number.
# This file is released into the public domain. Generated by
# versioneer-0.19 (https://github.com/python-versioneer/python-versioneer)
"""Git implementation of _version.py."""
import errno
import os
import re
import subprocess
import sys
def get_keywords():
"""Get the keywords needed to look up the version information."""
# these strings will be replaced by git during git-archive.
# setup.py/versioneer.py will grep for the variable names, so they must
# each be defined on a line of their own. _version.py will just call
# get_keywords().
git_refnames = "$Format:%d$"
git_full = "$Format:%H$"
git_date = "$Format:%ci$"
keywords = {"refnames": git_refnames, "full": git_full, "date": git_date}
return keywords
class VersioneerConfig:
"""Container for Versioneer configuration parameters."""
def get_config():
"""Create, populate and return the VersioneerConfig() object."""
# these strings are filled in when 'setup.py versioneer' creates
# _version.py
cfg = VersioneerConfig()
cfg.VCS = "git"
cfg.style = "pep440"
cfg.tag_prefix = "v"
cfg.parentdir_prefix = "firefly-cli-v"
cfg.versionfile_source = "firefly_cli/_version.py"
cfg.verbose = False
return cfg
class NotThisMethod(Exception):
"""Exception raised if a method is not valid for the current scenario."""
LONG_VERSION_PY = {}
HANDLERS = {}
def register_vcs_handler(vcs, method): # decorator
"""Create decorator to mark a method as the handler of a VCS."""
def decorate(f):
"""Store f in HANDLERS[vcs][method]."""
if vcs not in HANDLERS:
HANDLERS[vcs] = {}
HANDLERS[vcs][method] = f
return f
return decorate
def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
env=None):
"""Call the given command(s)."""
assert isinstance(commands, list)
p = None
for c in commands:
try:
dispcmd = str([c] + args)
# remember shell=False, so use git.cmd on windows, not just git
p = subprocess.Popen([c] + args, cwd=cwd, env=env,
stdout=subprocess.PIPE,
stderr=(subprocess.PIPE if hide_stderr
else None))
break
except EnvironmentError:
e = sys.exc_info()[1]
if e.errno == errno.ENOENT:
continue
if verbose:
print("unable to run %s" % dispcmd)
print(e)
return None, None
else:
if verbose:
print("unable to find command, tried %s" % (commands,))
return None, None
stdout = p.communicate()[0].strip().decode()
if p.returncode != 0:
if verbose:
print("unable to run %s (error)" % dispcmd)
print("stdout was %s" % stdout)
return None, p.returncode
return stdout, p.returncode
def versions_from_parentdir(parentdir_prefix, root, verbose):
"""Try to determine the version from the parent directory name.
Source tarballs conventionally unpack into a directory that includes both
the project name and a version string. We will also support searching up
two directory levels for an appropriately named parent directory
"""
rootdirs = []
for i in range(3):
dirname = os.path.basename(root)
if dirname.startswith(parentdir_prefix):
return {"version": dirname[len(parentdir_prefix):],
"full-revisionid": None,
"dirty": False, "error": None, "date": None}
else:
rootdirs.append(root)
root = os.path.dirname(root) # up a level
if verbose:
print("Tried directories %s but none started with prefix %s" %
(str(rootdirs), parentdir_prefix))
raise NotThisMethod("rootdir doesn't start with parentdir_prefix")
@register_vcs_handler("git", "get_keywords")
def git_get_keywords(versionfile_abs):
"""Extract version information from the given file."""
# the code embedded in _version.py can just fetch the value of these
# keywords. When used from setup.py, we don't want to import _version.py,
# so we do it with a regexp instead. This function is not used from
# _version.py.
keywords = {}
try:
f = open(versionfile_abs, "r")
for line in f.readlines():
if line.strip().startswith("git_refnames ="):
mo = re.search(r'=\s*"(.*)"', line)
if mo:
keywords["refnames"] = mo.group(1)
if line.strip().startswith("git_full ="):
mo = re.search(r'=\s*"(.*)"', line)
if mo:
keywords["full"] = mo.group(1)
if line.strip().startswith("git_date ="):
mo = re.search(r'=\s*"(.*)"', line)
if mo:
keywords["date"] = mo.group(1)
f.close()
except EnvironmentError:
pass
return keywords
@register_vcs_handler("git", "keywords")
def git_versions_from_keywords(keywords, tag_prefix, verbose):
"""Get version information from git keywords."""
if not keywords:
raise NotThisMethod("no keywords at all, weird")
date = keywords.get("date")
if date is not None:
# Use only the last line. Previous lines may contain GPG signature
# information.
date = date.splitlines()[-1]
# git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant
# datestamp. However we prefer "%ci" (which expands to an "ISO-8601
# -like" string, which we must then edit to make compliant), because
# it's been around since git-1.5.3, and it's too difficult to
# discover which version we're using, or to work around using an
# older one.
date = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
refnames = keywords["refnames"].strip()
if refnames.startswith("$Format"):
if verbose:
print("keywords are unexpanded, not using")
raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
refs = set([r.strip() for r in refnames.strip("()").split(",")])
# starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
# just "foo-1.0". If we see a "tag: " prefix, prefer those.
TAG = "tag: "
tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
if not tags:
# Either we're using git < 1.8.3, or there really are no tags. We use
# a heuristic: assume all version tags have a digit. The old git %d
# expansion behaves like git log --decorate=short and strips out the
# refs/heads/ and refs/tags/ prefixes that would let us distinguish
# between branches and tags. By ignoring refnames without digits, we
# filter out many common branch names like "release" and
# "stabilization", as well as "HEAD" and "master".
tags = set([r for r in refs if re.search(r'\d', r)])
if verbose:
print("discarding '%s', no digits" % ",".join(refs - tags))
if verbose:
print("likely tags: %s" % ",".join(sorted(tags)))
for ref in sorted(tags):
# sorting will prefer e.g. "2.0" over "2.0rc1"
if ref.startswith(tag_prefix):
r = ref[len(tag_prefix):]
if verbose:
print("picking %s" % r)
return {"version": r,
"full-revisionid": keywords["full"].strip(),
"dirty": False, "error": None,
"date": date}
# no suitable tags, so version is "0+unknown", but full hex is still there
if verbose:
print("no suitable tags, using unknown + full revision id")
return {"version": "0+unknown",
"full-revisionid": keywords["full"].strip(),
"dirty": False, "error": "no suitable tags", "date": None}
@register_vcs_handler("git", "pieces_from_vcs")
def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
"""Get version from 'git describe' in the root of the source tree.
This only gets called if the git-archive 'subst' keywords were *not*
expanded, and _version.py hasn't already been rewritten with a short
version string, meaning we're inside a checked out source tree.
"""
GITS = ["git"]
if sys.platform == "win32":
GITS = ["git.cmd", "git.exe"]
out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
hide_stderr=True)
if rc != 0:
if verbose:
print("Directory %s not under git control" % root)
raise NotThisMethod("'git rev-parse --git-dir' returned error")
# if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
# if there isn't one, this yields HEX[-dirty] (no NUM)
describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty",
"--always", "--long",
"--match", "%s*" % tag_prefix],
cwd=root)
# --long was added in git-1.5.5
if describe_out is None:
raise NotThisMethod("'git describe' failed")
describe_out = describe_out.strip()
full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
if full_out is None:
raise NotThisMethod("'git rev-parse' failed")
full_out = full_out.strip()
pieces = {}
pieces["long"] = full_out
pieces["short"] = full_out[:7] # maybe improved later
pieces["error"] = None
# parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
# TAG might have hyphens.
git_describe = describe_out
# look for -dirty suffix
dirty = git_describe.endswith("-dirty")
pieces["dirty"] = dirty
if dirty:
git_describe = git_describe[:git_describe.rindex("-dirty")]
# now we have TAG-NUM-gHEX or HEX
if "-" in git_describe:
# TAG-NUM-gHEX
mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
if not mo:
# unparseable. Maybe git-describe is misbehaving?
pieces["error"] = ("unable to parse git-describe output: '%s'"
% describe_out)
return pieces
# tag
full_tag = mo.group(1)
if not full_tag.startswith(tag_prefix):
if verbose:
fmt = "tag '%s' doesn't start with prefix '%s'"
print(fmt % (full_tag, tag_prefix))
pieces["error"] = ("tag '%s' doesn't start with prefix '%s'"
% (full_tag, tag_prefix))
return pieces
pieces["closest-tag"] = full_tag[len(tag_prefix):]
# distance: number of commits since tag
pieces["distance"] = int(mo.group(2))
# commit: short hex revision ID
pieces["short"] = mo.group(3)
else:
# HEX: no tags
pieces["closest-tag"] = None
count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
cwd=root)
pieces["distance"] = int(count_out) # total number of commits
# commit date: see ISO-8601 comment in git_versions_from_keywords()
date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"],
cwd=root)[0].strip()
# Use only the last line. Previous lines may contain GPG signature
# information.
date = date.splitlines()[-1]
pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
return pieces
def plus_or_dot(pieces):
"""Return a + if we don't already have one, else return a ."""
if "+" in pieces.get("closest-tag", ""):
return "."
return "+"
def render_pep440(pieces):
"""Build up version string, with post-release "local version identifier".
Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty
Exceptions:
1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"] or pieces["dirty"]:
rendered += plus_or_dot(pieces)
rendered += "%d.g%s" % (pieces["distance"], pieces["short"])
if pieces["dirty"]:
rendered += ".dirty"
else:
# exception #1
rendered = "0+untagged.%d.g%s" % (pieces["distance"],
pieces["short"])
if pieces["dirty"]:
rendered += ".dirty"
return rendered
def render_pep440_pre(pieces):
"""TAG[.post0.devDISTANCE] -- No -dirty.
Exceptions:
1: no tags. 0.post0.devDISTANCE
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"]:
rendered += ".post0.dev%d" % pieces["distance"]
else:
# exception #1
rendered = "0.post0.dev%d" % pieces["distance"]
return rendered
def render_pep440_post(pieces):
"""TAG[.postDISTANCE[.dev0]+gHEX] .
The ".dev0" means dirty. Note that .dev0 sorts backwards
(a dirty tree will appear "older" than the corresponding clean one),
but you shouldn't be releasing software with -dirty anyways.
Exceptions:
1: no tags. 0.postDISTANCE[.dev0]
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"] or pieces["dirty"]:
rendered += ".post%d" % pieces["distance"]
if pieces["dirty"]:
rendered += ".dev0"
rendered += plus_or_dot(pieces)
rendered += "g%s" % pieces["short"]
else:
# exception #1
rendered = "0.post%d" % pieces["distance"]
if pieces["dirty"]:
rendered += ".dev0"
rendered += "+g%s" % pieces["short"]
return rendered
def render_pep440_old(pieces):
"""TAG[.postDISTANCE[.dev0]] .
The ".dev0" means dirty.
Exceptions:
1: no tags. 0.postDISTANCE[.dev0]
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"] or pieces["dirty"]:
rendered += ".post%d" % pieces["distance"]
if pieces["dirty"]:
rendered += ".dev0"
else:
# exception #1
rendered = "0.post%d" % pieces["distance"]
if pieces["dirty"]:
rendered += ".dev0"
return rendered
def render_git_describe(pieces):
"""TAG[-DISTANCE-gHEX][-dirty].
Like 'git describe --tags --dirty --always'.
Exceptions:
1: no tags. HEX[-dirty] (note: no 'g' prefix)
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"]:
rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
else:
# exception #1
rendered = pieces["short"]
if pieces["dirty"]:
rendered += "-dirty"
return rendered
def render_git_describe_long(pieces):
"""TAG-DISTANCE-gHEX[-dirty].
Like 'git describe --tags --dirty --always -long'.
The distance/hash is unconditional.
Exceptions:
1: no tags. HEX[-dirty] (note: no 'g' prefix)
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
else:
# exception #1
rendered = pieces["short"]
if pieces["dirty"]:
rendered += "-dirty"
return rendered
def render(pieces, style):
"""Render the given version pieces into the requested style."""
if pieces["error"]:
return {"version": "unknown",
"full-revisionid": pieces.get("long"),
"dirty": None,
"error": pieces["error"],
"date": None}
if not style or style == "default":
style = "pep440" # the default
if style == "pep440":
rendered = render_pep440(pieces)
elif style == "pep440-pre":
rendered = render_pep440_pre(pieces)
elif style == "pep440-post":
rendered = render_pep440_post(pieces)
elif style == "pep440-old":
rendered = render_pep440_old(pieces)
elif style == "git-describe":
rendered = render_git_describe(pieces)
elif style == "git-describe-long":
rendered = render_git_describe_long(pieces)
else:
raise ValueError("unknown style '%s'" % style)
return {"version": rendered, "full-revisionid": pieces["long"],
"dirty": pieces["dirty"], "error": None,
"date": pieces.get("date")}
def get_versions():
"""Get version information or return default if unable to do so."""
# I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
# __file__, we can work backwards from there to the root. Some
# py2exe/bbfreeze/non-CPython implementations don't do __file__, in which
# case we can only use expanded keywords.
cfg = get_config()
verbose = cfg.verbose
try:
return git_versions_from_keywords(get_keywords(), cfg.tag_prefix,
verbose)
except NotThisMethod:
pass
try:
root = os.path.realpath(__file__)
# versionfile_source is the relative path from the top of the source
# tree (where the .git directory might live) to this file. Invert
# this to find the root from __file__.
for i in cfg.versionfile_source.split('/'):
root = os.path.dirname(root)
except NameError:
return {"version": "0+unknown", "full-revisionid": None,
"dirty": None,
"error": "unable to find root of source tree",
"date": None}
try:
pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose)
return render(pieces, cfg.style)
except NotThisMethod:
pass
try:
if cfg.parentdir_prefix:
return versions_from_parentdir(cfg.parentdir_prefix, root, verbose)
except NotThisMethod:
pass
return {"version": "0+unknown", "full-revisionid": None,
"dirty": None,
"error": "unable to compute version", "date": None}
| 35.503802 | 79 | 0.585703 |
a91a5c412d545e14a2400bae93c664b791cb6ad7 | 2,617 | py | Python | src/compas_blender/__init__.py | 9and3/compas | 02c5a76adeb55696206d2194a8167e4085415891 | [
"MIT"
] | null | null | null | src/compas_blender/__init__.py | 9and3/compas | 02c5a76adeb55696206d2194a8167e4085415891 | [
"MIT"
] | null | null | null | src/compas_blender/__init__.py | 9and3/compas | 02c5a76adeb55696206d2194a8167e4085415891 | [
"MIT"
] | null | null | null | """
********************************************************************************
compas_blender
********************************************************************************
.. currentmodule:: compas_blender
.. toctree::
:maxdepth: 1
compas_blender.artists
compas_blender.conversions
compas_blender.geometry
compas_blender.ui
compas_blender.utilities
"""
import os
import compas
try:
import bpy # noqa: F401
except ImportError:
pass
else:
from .utilities import * # noqa: F401 F403
def clear():
"""Clear all scene objects."""
# delete all objects
bpy.ops.object.select_all(action='SELECT')
bpy.ops.object.delete(use_global=True, confirm=False)
# delete data
delete_unused_data() # noqa: F405
# delete collections
for collection in bpy.context.scene.collection.children:
bpy.context.scene.collection.children.unlink(collection)
for block in bpy.data.collections:
objects = [o for o in block.objects if o.users]
while objects:
bpy.data.objects.remove(objects.pop())
for collection in block.children:
block.children.unlink(collection)
if block.users == 0:
bpy.data.collections.remove(block)
def redraw():
"""Trigger a redraw."""
bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1)
__version__ = '1.15.0'
def _check_blender_version(version):
supported_versions = ['2.83', '2.93', '3.1']
if not version:
return '2.93'
if version not in supported_versions:
raise Exception('Unsupported Blender version: {}'.format(version))
return version
def _get_default_blender_installation_path(version):
version = _check_blender_version(version)
if compas.OSX:
path = _get_default_blender_installation_path_mac(version)
elif compas.WINDOWS:
path = _get_default_blender_installation_path_windows(version)
else:
raise Exception('Unsupported platform.')
if not os.path.exists(path):
raise Exception("The default installation folder for Blender {} doesn't exist.".format(version))
return path
def _get_default_blender_installation_path_mac(version):
return '/Applications/Blender.app/Contents/Resources/{}'.format(version)
def _get_default_blender_installation_path_windows(version):
return os.path.expandvars('%PROGRAMFILES%/Blender Foundation/Blender {}/{}'.format(version, version))
__all__ = [name for name in dir() if not name.startswith('_')]
__all_plugins__ = [
'compas_blender.geometry.booleans',
'compas_blender.artists',
]
| 26.434343 | 105 | 0.655713 |
36dc94b478b69c557002bf0d5cf67387ece1b73a | 7,192 | py | Python | data_preprocessing.py | PatriceC/MLProjectISDP2020 | 64e83824690ccde2714d915c70fb00b20aa66a42 | [
"MIT"
] | 1 | 2021-01-23T01:04:00.000Z | 2021-01-23T01:04:00.000Z | data_preprocessing.py | cor3ntino/Time-Series-Prediction-with-Deep-Learning-for-Road-Trafic-Data | e8eefdf2e630a53e09f88550357b67732f2bccd0 | [
"MIT"
] | null | null | null | data_preprocessing.py | cor3ntino/Time-Series-Prediction-with-Deep-Learning-for-Road-Trafic-Data | e8eefdf2e630a53e09f88550357b67732f2bccd0 | [
"MIT"
] | 1 | 2021-01-19T16:57:27.000Z | 2021-01-19T16:57:27.000Z | # -*- coding: utf-8 -*-
"""
Created on Fri Nov 27 19:01:58 2020
@author: Patrice CHANOL & Corentin MORVAN--CHAUMEIL
"""
import pandas as pd
import numpy as np
import torch
import random
def series(date, latitude, longitude, direction, input_window, output_window, data):
"""
Series selection.
Parameters
----------
date : TYPE datetime
DESCRIPTION. Date des séries à prédire
latitude : TYPE float
DESCRIPTION. Latitude des séries
longitude : TYPE float
DESCRIPTION. Longitude des séries
direction : TYPE int
DESCRIPTION. Direction des séries
input_window : TYPE int
DESCRIPTION. Nombre de jours de la série d'input de la prédiction
output_window: TYPE int
DESCRIPTION. Nombre d'heures de la série d'output de la prédiction
data : TYPE DataFrame
DESCRIPTION. Donnée
"""
# Récupération des données aux jours nécessaires pour le lieu et direction souhaités
dict_J = {}
for j in range(input_window, 0, -1):
dict_J['row_J_moins_' + str(j)] = data[(data['location_latitude'] == latitude) & (data['location_longitude'] == longitude) & (data['Date'] == date - pd.to_timedelta(j, unit='d')) & (data['Direction'] == direction)]
dict_J['row_J'] = data[(data['location_latitude'] == latitude) & (data['location_longitude'] == longitude) & (data['Date'] == date) & (data['Direction'] == direction)]
for j in range(1, 2 + (output_window - 2) // 24):
dict_J['row_J_plus_' + str(j)] = data[(data['location_latitude'] == latitude) & (data['location_longitude'] == longitude) & (data['Date'] == date + pd.to_timedelta(j, unit='d')) & (data['Direction'] == direction)]
# Si on a pas de donnée pour un des jours, on ne fait rien
for element in dict_J:
if dict_J[element].empty:
return(None)
# Sinon on dispose de toutes les données et on peut générer les séries
serie_totale = []
for element in dict_J:
serie_totale += dict_J[element].values.tolist()[0][8:]
nb_series = 24
target, serie = np.zeros((nb_series, output_window)), np.zeros((nb_series, input_window * nb_series))
for h in range(nb_series):
target[h] = serie_totale[h + input_window * nb_series : h + input_window * nb_series + output_window]
serie[h] = serie_totale[h : h + input_window * nb_series]
return(target, serie)
def process_data(input_window=7, output_window=24, file='./Radar_Traffic_Counts.csv'):
"""
Génération du Dataset désiré.
Parameters
----------
input_window : int, optional, default=7
Représente le nombre de jours de la séquence d'entrée qui servira d'input pour l'entraînement.
output_window : int, optional, default=24
Représente le nombre d'heures de la séquence de sortie qui servira de target.
file : String, optional, default='./Radar_Traffic_Counts.csv'
Fichier de données.
"""
data = pd.read_csv(file)
# Préparation du Dataset
data = data.drop(columns=['location_name', 'Time Bin'])
data['Direction'] = data['Direction'].astype('category').cat.codes
data['Date'] = pd.to_datetime(data[['Year', 'Month', 'Day']], errors='coerce')
data['location_latitude'] = data['location_latitude']
data['location_longitude'] = data['location_longitude']
col = ['location_latitude', 'location_longitude', 'Year', 'Month', 'Day', 'Date', 'Day of Week', 'Hour', 'Direction']
col_no_hour = ['location_latitude', 'location_longitude', 'Year', 'Month', 'Day', 'Date', 'Day of Week', 'Direction']
data = data.groupby(col)['Volume'].sum().reset_index()
# On normalise les données de Volume avec la méthode min-max
volume_max, volume_min = data['Volume'].max(), data['Volume'].min()
data = data.pivot_table(index=col_no_hour, columns='Hour', values='Volume').reset_index()
# Suppression des jours contenant des données manquantes
data = data.dropna()
data_train, data_test = [], []
# Pour chaque donnée: jour précis, lieu précis, direction précise
for _, row in data.iterrows():
# On récuprère les informations de cette donnée
latitude, longitude = row['location_latitude'], row['location_longitude']
date, day_of_week = row['Date'], row['Day of Week']
direction = row['Direction']
# On génère les séries
result = series(date=date, latitude=latitude, longitude=longitude, direction=direction, input_window=input_window, output_window=output_window, data=data)
if result is not None:
# On transforme le jour de la semaine en one-hot vector
day_of_week_one_hot = list(np.eye(7)[day_of_week])
target, serie = result
for t, s in zip(target, serie):
# On normalise les valeurs
s_norm = list((s - volume_min)/(volume_max - volume_min))
t_norm = list((t - volume_min)/(volume_max - volume_min))
# On sépare le dataset en 90% training et 10% test
if random.random() < 0.9:
data_train.append(day_of_week_one_hot + s_norm + t_norm)
else:
data_test.append(day_of_week_one_hot + s_norm + t_norm)
# Mélange des données
random.shuffle(data_train)
random.shuffle(data_test)
data_train = np.array(data_train)
data_test = np.array(data_test)
# Enregistrement des données
torch.save(data_train, './data/data_train_' + str(input_window) + '_days_to_' + str(output_window) + '_hours.txt')
torch.save(data_test, './data/data_test_' + str(input_window) + '_days_to_' + str(output_window) + '_hours.txt')
return(data_train, data_test)
def data_loader(data_train, data_test, input_window, output_window, batch_size=128):
"""
On construit nos DataLoaders de train/test que nous utiliserons pour itérer sur les données pour l'apprentissage de modèles.
Parameters
----------
data_train : TYPE array
DESCRIPTION. Matrix of train data
data_test : TYPE array
DESCRIPTION. MAtrix of test data
input_window : TYPE int
DESCRIPTION. Nombre de jours de la série d'input de la prédiction
output_window: TYPE int
DESCRIPTION. Nombre d'heures de la série d'output de la prédiction
batch_size : TYPE int, optional
DESCRIPTION. The default is 128.
Returns
-------
data_loader_train : TYPE DataLoader
DESCRIPTION. Train DataLoader
data_loader_test : TYPE DataLoader
DESCRIPTION. Test DataLoader
"""
day_of_week_train = data_train[:, :7]
day_of_week_test = data_test[:, :7]
serie_train = data_train[:, 7:-output_window]
serie_test = data_test[:, 7:-output_window]
target_train = data_train[:, -output_window:]
target_test = data_test[:, -output_window:]
data_loader_train = torch.utils.data.DataLoader(list(zip(zip(day_of_week_train, serie_train), target_train)), batch_size=batch_size, shuffle=True)
data_loader_test = torch.utils.data.DataLoader(list(zip(zip(day_of_week_test, serie_test), target_test)), batch_size=batch_size, shuffle=True)
return(data_loader_train, data_loader_test)
| 43.065868 | 222 | 0.665879 |
f34c6600883586788ba6f33f8afe72d852ee9893 | 2,212 | py | Python | src/radio.py | uSasha/spotify_radio | d01ec9b5dbc37329ebe1c63dcb085a326f8285e1 | [
"MIT"
] | null | null | null | src/radio.py | uSasha/spotify_radio | d01ec9b5dbc37329ebe1c63dcb085a326f8285e1 | [
"MIT"
] | null | null | null | src/radio.py | uSasha/spotify_radio | d01ec9b5dbc37329ebe1c63dcb085a326f8285e1 | [
"MIT"
] | 1 | 2021-08-03T11:49:27.000Z | 2021-08-03T11:49:27.000Z | import random
from typing import List, Dict, Union
from src import config
from src.spotify_client import SpotifyClient
from vectorizer import Vectorizer
class Radio:
"""
Radio which can find available stations and provide next tracks according to listening history.
"""
def __init__(self) -> None:
self.spoty = SpotifyClient(config.SPOTIFY_SETTINGS)
self.vectorizer = Vectorizer()
def available_stations(self, user_id: str) -> List[Dict[str, str]]:
"""
Get user radio stations.
Stations are generated from Spotify playlists with prefix 'radio: '. Playlists should be public.
:param user_id:
:return:
"""
return self.spoty.get_user_playlists(user_id)
def next(self, radio_id: str, listening_history: List[Dict[str, Union[str, int]]] = None, n: int = 10) -> List[str]:
"""
Find N items within radio station style and with respect to provided listening history.
:param radio_id: ID if Spotify playlist which describes station style
:param listening_history: listening stats for previous tracks
:param n: number of items to return
:return: Spotify track IDs
"""
seed = self.spoty.get_playlist_artist_names(radio_id)
likes = []
dislikes = []
for track in listening_history or []:
track = dict(track) # TODO: remove this
artist = self.spoty.track_to_artist_name(track['track_id'])
if artist is None:
continue
if track['play_seconds'] / track['length_seconds'] > config.DISLIKE_THRESHOLD:
likes.append(artist)
else:
dislikes.append(artist)
seen = set(likes + dislikes)
artist_names = self.vectorizer.recommend(seed, likes, dislikes, n + len(seen))
tracks = []
for artist_name in artist_names:
artist_id, spotify_name = self.spoty.name_to_spotify_id(artist_name)
if spotify_name in seen:
continue
artist_tracks = self.spoty.artist_to_tracks(artist_id)
tracks.append(random.choice(artist_tracks))
return tracks[:n]
| 36.866667 | 120 | 0.63698 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.