Datasets:

ytzi

/

the-stack-dedup-python-scored

like 0

6a7ef877f9a75af565239a4f498da3558863fc35

py

Python

tensorflow/contrib/data/python/kernel_tests/optimization/map_and_filter_fusion_test.py

Smokrow/tensorflow

debd66dae1c9a49d36ea006c97facf06b4ac25cb

2018-09-08T08:26:31.000Z

2018-09-08T08:26:31.000Z

tensorflow/contrib/data/python/kernel_tests/optimization/map_and_filter_fusion_test.py

Smokrow/tensorflow

debd66dae1c9a49d36ea006c97facf06b4ac25cb

tensorflow/contrib/data/python/kernel_tests/optimization/map_and_filter_fusion_test.py

Smokrow/tensorflow

debd66dae1c9a49d36ea006c97facf06b4ac25cb

2020-02-15T14:34:36.000Z

2020-02-15T14:34:36.000Z

# Copyright 2018 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 the MapAndFilterFusion optimization.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function from absl.testing import parameterized from tensorflow.contrib.data.python.ops import optimization from tensorflow.python.data.ops import dataset_ops from tensorflow.python.framework import constant_op from tensorflow.python.framework import dtypes from tensorflow.python.framework import errors from tensorflow.python.ops import math_ops from tensorflow.python.platform import test class MapAndFilterFusionTest(test.TestCase, parameterized.TestCase): @staticmethod def map_functions(): identity = lambda x: x increment = lambda x: x + 1 def increment_and_square(x): y = x + 1 return y * y functions = [identity, increment, increment_and_square] tests = [] for i, fun1 in enumerate(functions): for j, fun2 in enumerate(functions): tests.append(( "Test{}{}".format(i, j), [fun1, fun2], )) for k, fun3 in enumerate(functions): tests.append(( "Test{}{}{}".format(i, j, k), [fun1, fun2, fun3], )) swap = lambda x, n: (n, x) tests.append(( "Swap1", [lambda x: (x, 42), swap], )) tests.append(( "Swap2", [lambda x: (x, 42), swap, swap], )) return tuple(tests) @parameterized.named_parameters(*map_functions.__func__()) def testMapFusion(self, functions): dataset = dataset_ops.Dataset.range(5).apply( optimization.assert_next(["Map", "Prefetch"])) for function in functions: dataset = dataset.map(function) dataset = dataset.prefetch(0).apply(optimization.optimize(["map_fusion"])) iterator = dataset.make_one_shot_iterator() get_next = iterator.get_next() with self.test_session() as sess: for x in range(5): result = sess.run(get_next) r = x for function in functions: if isinstance(r, tuple): r = function(*r) # Pass tuple as multiple arguments. else: r = function(r) self.assertAllEqual(r, result) with self.assertRaises(errors.OutOfRangeError): sess.run(get_next) @staticmethod def map_and_filter_functions(): identity = lambda x: x increment = lambda x: x + 1 minus_five = lambda x: x - 5 def increment_and_square(x): y = x + 1 return y * y take_all = lambda x: constant_op.constant(True) is_zero = lambda x: math_ops.equal(x, 0) is_odd = lambda x: math_ops.equal(x % 2, 0) greater = lambda x: math_ops.greater(x + 5, 0) functions = [identity, increment, minus_five, increment_and_square] filters = [take_all, is_zero, is_odd, greater] tests = [] for x, fun in enumerate(functions): for y, predicate in enumerate(filters): tests.append(("Mixed{}{}".format(x, y), fun, predicate)) # Multi output tests.append(("Multi1", lambda x: (x, x), lambda x, y: constant_op.constant(True))) tests.append( ("Multi2", lambda x: (x, 2), lambda x, y: math_ops.equal(x * math_ops.cast(y, dtypes.int64), 0))) return tuple(tests) @parameterized.named_parameters(*map_and_filter_functions.__func__()) def testMapFilterFusion(self, function, predicate): dataset = dataset_ops.Dataset.range(10).apply( optimization.assert_next( ["Map", "FilterByLastComponent"])).map(function).filter(predicate).apply( optimization.optimize(["map_and_filter_fusion"])) self._testMapAndFilter(dataset, function, predicate) def _testMapAndFilter(self, dataset, function, predicate): iterator = dataset.make_one_shot_iterator() get_next = iterator.get_next() with self.test_session() as sess: for x in range(10): r = function(x) if isinstance(r, tuple): b = predicate(*r) # Pass tuple as multiple arguments. else: b = predicate(r) if sess.run(b): result = sess.run(get_next) self.assertAllEqual(r, result) with self.assertRaises(errors.OutOfRangeError): sess.run(get_next) def testAdditionalInputs(self): a = constant_op.constant(3, dtype=dtypes.int64) b = constant_op.constant(4, dtype=dtypes.int64) some_tensor = math_ops.mul(a, b) function = lambda x: x * x def predicate(y): return math_ops.less(math_ops.cast(y, dtypes.int64), some_tensor) # We are currently not supporting functions with additional inputs. dataset = dataset_ops.Dataset.range(10).apply( optimization.assert_next( ["Map", "Filter"])).map(function).filter(predicate).apply( optimization.optimize(["map_and_filter_fusion"])) self._testMapAndFilter(dataset, function, predicate) @staticmethod def filter_functions(): take_all = lambda x: constant_op.constant(True) is_zero = lambda x: math_ops.equal(x, 0) greater = lambda x: math_ops.greater(x + 5, 0) tests = [] filters = [take_all, is_zero, greater] identity = lambda x: x for x, predicate_1 in enumerate(filters): for y, predicate_2 in enumerate(filters): tests.append(("Mixed{}{}".format(x, y), identity, [predicate_1, predicate_2])) for z, predicate_3 in enumerate(filters): tests.append(("Mixed{}{}{}".format(x, y, z), identity, [predicate_1, predicate_2, predicate_3])) take_all_multiple = lambda x, y: constant_op.constant(True) # Multi output tests.append(("Multi1", lambda x: (x, x), [take_all_multiple, take_all_multiple])) tests.append(("Multi2", lambda x: (x, 2), [ take_all_multiple, lambda x, y: math_ops.equal(x * math_ops.cast(y, dtypes.int64), 0) ])) return tuple(tests) @parameterized.named_parameters(*filter_functions.__func__()) def testFilterFusion(self, map_function, predicates): dataset = dataset_ops.Dataset.range(5).apply( optimization.assert_next(["Map", "Filter", "Prefetch"])).map(map_function) for predicate in predicates: dataset = dataset.filter(predicate) dataset = dataset.prefetch(0).apply( optimization.optimize(["filter_fusion"])) iterator = dataset.make_one_shot_iterator() get_next = iterator.get_next() with self.test_session() as sess: for x in range(5): r = map_function(x) filtered = False for predicate in predicates: if isinstance(r, tuple): b = predicate(*r) # Pass tuple as multiple arguments. else: b = predicate(r) if not sess.run(b): filtered = True break if not filtered: result = sess.run(get_next) self.assertAllEqual(r, result) with self.assertRaises(errors.OutOfRangeError): sess.run(get_next) if __name__ == "__main__": test.main()

6a7f52df743becc0516c5282308cd0c5db04737d

py

Python

meerk40t/lihuiyu/lihuiyuemulator.py

jpirnay/meerk40t

10d4e41a8c5e2bb95a504904273699e115822b9b

meerk40t/lihuiyu/lihuiyuemulator.py

jpirnay/meerk40t

10d4e41a8c5e2bb95a504904273699e115822b9b

meerk40t/lihuiyu/lihuiyuemulator.py

jpirnay/meerk40t

10d4e41a8c5e2bb95a504904273699e115822b9b

from meerk40t.core.cutcode import CutCode, RawCut from meerk40t.core.parameters import Parameters from meerk40t.core.units import UNITS_PER_MIL from meerk40t.kernel import Module from meerk40t.numpath import Numpath from meerk40t.svgelements import Color class LihuiyuEmulator(Module): def __init__(self, context, path): Module.__init__(self, context, path) self.context.setting(bool, "fix_speeds", False) self.parser = LihuiyuParser() self.parser.fix_speeds = self.context.fix_speeds self.parser.channel = self.context.channel("lhy") def pos(p): if p is None: return x0, y0, x1, y1 = p self.context.signal("emulator;position", (x0, y0, x1, y1)) self.parser.position = pos def __repr__(self): return "LihuiyuEmulator(%s)" % self.name def initialize(self, *args, **kwargs): context = self.context active = self.context.root.active send = context.channel("%s/usb_send" % active) send.watch(self.parser.write_packet) def finalize(self, *args, **kwargs): context = self.context active = self.context.root.active send = context.channel("%s/usb_send" % active) send.unwatch(self.parser.write_packet) class LihuiyuParser: """ LihuiyuParser parses LHYMicro-GL code with a state diagram. This should accurately reconstruct the values. When the position is changed it calls a self.position() function if one exists. """ def __init__(self): self.channel = None self.position = None self.board = "M2" self.header_skipped = False self.count_lines = 0 self.count_flag = 0 self.settings = Parameters({"speed": 20.0, "power": 1000.0}) self.speed_code = None self.x = 0.0 self.y = 0.0 self.number_value = "" self.distance_x = 0 self.distance_y = 0 self.filename = "" self.laser = 0 self.left = False self.top = False self.x_on = False self.y_on = False self.small_jump = False self.returning_compact = True self.returning_finished = False self.mode = None self.raster_step = 0 self.paused_state = False self.compact_state = False self.finish_state = False self.horizontal_major = False self.fix_speeds = False self.number_consumer = {} def parse(self, data, elements): self.path = Numpath() def position(p): if p is None: return from_x, from_y, to_x, to_y = p if self.program_mode: if self.laser: self.path.line(complex(from_x, from_y), complex(to_x, to_y)) self.position = position self.write(data) self.path.uscale(UNITS_PER_MIL) elements.elem_branch.add( type="elem numpath", path=self.path, stroke=Color("black"), **self.settings.settings, ) elements.signal("refresh_scene", 0) @property def program_mode(self): return self.compact_state @property def default_mode(self): return not self.compact_state @property def raster_mode(self): return self.settings.get("raster_step", 0) != 0 def new_file(self): self.header_skipped = False self.count_flag = 0 self.count_lines = 0 @staticmethod def remove_header(data): count_lines = 0 count_flag = 0 for i in range(len(data)): b = data[i] c = chr(b) if c == "\n": count_lines += 1 elif c == "%": count_flag += 1 if count_lines >= 3 and count_flag >= 5: return data[i:] def header_write(self, data): """ Write data to the emulator including the header. This is intended for saved .egv files which include a default header. """ if self.header_skipped: self.write(data) else: data = LihuiyuParser.remove_header(data) self.write(data) def write_packet(self, packet): self.write(packet[1:31]) def write(self, data): for b in data: self.process(b, chr(b)) def distance_consumer(self, c): self.number_value += c if len(self.number_value) >= 3: self.append_distance(int(self.number_value)) self.number_value = "" def speedcode_b1_consumer(self, c): self.number_value += c if len(self.number_value) >= 3: if self.channel: self.channel("Speedcode B1 = %s" % self.number_value) self.number_value = "" self.number_consumer = self.speedcode_b2_consumer def speedcode_b2_consumer(self, c): self.number_value += c if len(self.number_value) >= 3: if self.channel: self.channel("Speedcode B2 = %s" % self.number_value) self.number_value = "" self.number_consumer = self.speedcode_accel_consumer def speedcode_accel_consumer(self, c): self.number_value += c if len(self.number_value) >= 1: if self.channel: self.channel("Speedcode Accel = %s" % self.number_value) self.number_value = "" self.number_consumer = self.speedcode_mult_consumer def speedcode_mult_consumer(self, c): self.number_value += c if len(self.number_value) >= 3: if self.channel: self.channel("Speedcode Accel = %s" % self.number_value) self.number_value = "" self.number_consumer = self.speedcode_dratio_b1_consumer def speedcode_dratio_b1_consumer(self, c): self.number_value += c if len(self.number_value) >= 3: if self.channel: self.channel("Speedcode Dratio b1 = %s" % self.number_value) self.number_value = "" self.number_consumer = self.speedcode_dratio_b2_consumer def speedcode_dratio_b2_consumer(self, c): self.number_value += c if len(self.number_value) >= 3: if self.channel: self.channel("Speedcode Dratio b2 = %s" % self.number_value) self.number_value = "" self.number_consumer = self.distance_consumer def raster_step_consumer(self, c): self.number_value += c if len(self.number_value) >= 3: if self.channel: self.channel("Raster Step = %s" % self.number_value) self.raster_step = int(self.number_value) self.number_value = "" self.number_consumer = self.distance_consumer def mode_consumer(self, c): self.number_value += c if len(self.number_value) >= 1: if self.channel: self.channel("Set Mode = %s" % self.number_value) self.mode = int(self.number_value) self.number_value = "" self.number_consumer = self.speedcode_mult_consumer def append_distance(self, amount): if self.x_on: self.distance_x += amount if self.y_on: self.distance_y += amount def execute_distance(self): if self.distance_x != 0 or self.distance_y != 0: dx = self.distance_x dy = self.distance_y if self.left: dx = -dx if self.top: dy = -dy self.distance_x = 0 self.distance_y = 0 ox = self.x oy = self.y self.x += dx self.y += dy if self.position: self.position((ox, oy, self.x, self.y)) if self.channel: self.channel("Moving (%d %d) now at %d %d" % (dx, dy, self.x, self.y)) def process(self, b, c): if c == "I": self.finish_state = False self.compact_state = False self.paused_state = False self.distance_x = 0 self.distance_y = 0 if self.finish_state: # In finished all commands are black holed return if ord("0") <= b <= ord("9"): self.number_consumer(c) return else: self.number_consumer = self.distance_consumer self.number_value = "" if self.compact_state: # Every command in compact state executes distances. self.execute_distance() if c == "|": self.append_distance(25) self.small_jump = True elif ord("a") <= b <= ord("y"): self.append_distance(b + 1 - ord("a")) self.small_jump = False elif c == "z": self.append_distance(26 if self.small_jump else 255) self.small_jump = False elif c == "B": # Move to Right. if self.left and self.horizontal_major: # Was T switched to B with horizontal rastering. if self.raster_step: self.distance_y += self.raster_step self.left = False self.x_on = True self.y_on = False if self.channel: self.channel("Right") elif c == "T": # Move to Left if not self.left and self.horizontal_major: # Was T switched to B with horizontal rastering. if self.raster_step: self.distance_y += self.raster_step self.left = True self.x_on = True self.y_on = False if self.channel: self.channel("Left") elif c == "R": # Move to Bottom if self.top and not self.horizontal_major: # Was L switched to R with vertical rastering. if self.raster_step: self.distance_x += self.raster_step self.top = False self.x_on = False self.y_on = True if self.channel: self.channel("Bottom") elif c == "L": # Move to Top if not self.top and not self.horizontal_major: # Was R switched to L with vertical rastering. if self.raster_step: self.distance_x += self.raster_step self.top = True self.x_on = False self.y_on = True if self.channel: self.channel("Top") elif c == "U": self.laser = 0 if self.channel: self.channel("Laser Off") elif c == "D": self.laser = 1 if self.channel: self.channel("Laser On") elif c == "F": if self.channel: self.channel("Finish") self.returning_compact = False self.returning_finished = True elif c == "@": if self.channel: self.channel("Reset") self.returning_finished = False self.returning_compact = False elif c in "C": if self.channel: self.channel("Speedcode") self.speed_code = "" elif c in "V": self.raster_step = None if self.channel: self.channel("Velocity") self.number_consumer = self.speedcode_b1_consumer elif c in "G": if self.channel: self.channel("Step Value") self.number_consumer = self.raster_step_consumer elif c == "S": if self.channel: self.channel("Mode Set") self.laser = 0 self.execute_distance() self.mode = None self.number_consumer = self.mode_consumer elif c == "E": if self.channel: self.channel("Execute State") if self.mode is None: if self.returning_compact: self.compact_state = True if self.returning_finished: self.finish_state = True if self.horizontal_major: self.left = not self.left self.x_on = True self.y_on = False if self.raster_step: self.distance_y += self.raster_step else: # vertical major self.top = not self.top self.x_on = False self.y_on = True if self.raster_step: self.distance_x += self.raster_step elif self.mode == 0: # Homes then moves position. pass elif self.mode == 1: self.compact_state = True self.horizontal_major = self.x_on if self.channel: self.channel("Setting Axis: h=" + str(self.x_on)) elif self.mode == 2: # Rail unlocked. self.compact_state = True self.returning_finished = False self.returning_compact = True self.laser = 0 elif c == "P": if self.channel: self.channel("Pause") self.laser = 0 if self.paused_state: # Home sequence triggered by 2 P commands in the same packet. # This should resume if not located within the same packet. if self.position: self.position((self.x, self.y, 0, 0)) self.x = 0 self.y = 0 self.distance_y = 0 self.distance_x = 0 self.finish_state = True self.paused_state = False else: self.execute_distance() # distance is executed by a P command self.paused_state = True elif c == "N": if self.channel: self.channel("N") self.execute_distance() # distance is executed by an N command. self.laser = 0 self.compact_state = False if self.position: self.position(None) elif c == "M": self.x_on = True self.y_on = True if self.channel: a = "Top" if self.top else "Bottom" b = "Left" if self.left else "Right" self.channel("Diagonal %s %s" % (a, b)) class EGVBlob: def __init__(self, data: bytearray, name=None): self.name = name self.data = data self.operation = "blob" self._cutcode = None self._cut = None def __repr__(self): return "EGV(%s, %d bytes)" % (self.name, len(self.data)) def as_cutobjects(self): parser = LihuiyuParser() self._cutcode = CutCode() self._cut = RawCut() def new_cut(): if self._cut is not None and len(self._cut): self._cutcode.append(self._cut) self._cut = RawCut() self._cut.settings = dict(parser.settings) def position(p): if p is None or self._cut is None: new_cut() return from_x, from_y, to_x, to_y = p if parser.program_mode: if len(self._cut.plot) == 0: self._cut.plot_append(int(from_x), int(from_y), parser.laser) self._cut.plot_append(int(to_x), int(to_y), parser.laser) else: new_cut() parser.position = position parser.header_write(self.data) cutcode = self._cutcode self._cut = None self._cutcode = None return cutcode def generate(self): yield "blob", "egv", LihuiyuParser.remove_header(self.data) class EgvLoader: @staticmethod def remove_header(data): count_lines = 0 count_flag = 0 for i in range(len(data)): b = data[i] c = chr(b) if c == "\n": count_lines += 1 elif c == "%": count_flag += 1 if count_lines >= 3 and count_flag >= 5: return data[i:] @staticmethod def load_types(): yield "Engrave Files", ("egv",), "application/x-egv" @staticmethod def load(kernel, elements_modifier, pathname, **kwargs): import os basename = os.path.basename(pathname) with open(pathname, "rb") as f: op_branch = elements_modifier.get(type="branch ops") op_branch.add( data=bytearray(EgvLoader.remove_header(f.read())), data_type="egv", type="blob", name=basename, ) return True

6a7f701b1440f625bfec8817f0a39a899231c69f

py

Python

tencentcloud/dbbrain/v20210527/models.py

lleiyyang/tencentcloud-sdk-python

e6e6a4ce89286673b2322ae92d3c2fbf8665aa0b

2018-04-27T09:54:59.000Z

2022-03-29T02:18:01.000Z

tencentcloud/dbbrain/v20210527/models.py

lleiyyang/tencentcloud-sdk-python

e6e6a4ce89286673b2322ae92d3c2fbf8665aa0b

2018-04-27T09:48:11.000Z

2022-03-12T08:04:04.000Z

tencentcloud/dbbrain/v20210527/models.py

lleiyyang/tencentcloud-sdk-python

e6e6a4ce89286673b2322ae92d3c2fbf8665aa0b

2018-05-02T08:02:46.000Z

2022-03-30T08:02:48.000Z

# -*- coding: utf8 -*- # Copyright (c) 2017-2021 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. import warnings from tencentcloud.common.abstract_model import AbstractModel class AddUserContactRequest(AbstractModel): """AddUserContact请求参数结构体 """ def __init__(self): r""" :param Name: 联系人姓名，由中英文、数字、空格、!@#$%^&*()_+-=（）组成，不能以下划线开头，长度在20以内。 :type Name: str :param ContactInfo: 邮箱地址，支持大小写字母、数字、下划线及@字符， 不能以下划线开头，邮箱地址不可重复。 :type ContactInfo: str :param Product: 服务产品类型，固定值："mysql"。 :type Product: str """ self.Name = None self.ContactInfo = None self.Product = None def _deserialize(self, params): self.Name = params.get("Name") self.ContactInfo = params.get("ContactInfo") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class AddUserContactResponse(AbstractModel): """AddUserContact返回参数结构体 """ def __init__(self): r""" :param Id: 添加成功的联系人id。 :type Id: int :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.Id = None self.RequestId = None def _deserialize(self, params): self.Id = params.get("Id") self.RequestId = params.get("RequestId") class ContactItem(AbstractModel): """联系人contact描述。 """ def __init__(self): r""" :param Id: 联系人id。 :type Id: int :param Name: 联系人姓名。 :type Name: str :param Mail: 联系人绑定的邮箱。 :type Mail: str """ self.Id = None self.Name = None self.Mail = None def _deserialize(self, params): self.Id = params.get("Id") self.Name = params.get("Name") self.Mail = params.get("Mail") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class CreateDBDiagReportTaskRequest(AbstractModel): """CreateDBDiagReportTask请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例ID。 :type InstanceId: str :param StartTime: 开始时间，如“2020-11-08T14:00:00+08:00”。 :type StartTime: str :param EndTime: 结束时间，如“2020-11-09T14:00:00+08:00”。 :type EndTime: str :param SendMailFlag: 是否发送邮件: 0 - 否，1 - 是。 :type SendMailFlag: int :param ContactPerson: 接收邮件的联系人ID数组。 :type ContactPerson: list of int :param ContactGroup: 接收邮件的联系组ID数组。 :type ContactGroup: list of int :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL，默认值为"mysql"。 :type Product: str """ self.InstanceId = None self.StartTime = None self.EndTime = None self.SendMailFlag = None self.ContactPerson = None self.ContactGroup = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.StartTime = params.get("StartTime") self.EndTime = params.get("EndTime") self.SendMailFlag = params.get("SendMailFlag") self.ContactPerson = params.get("ContactPerson") self.ContactGroup = params.get("ContactGroup") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class CreateDBDiagReportTaskResponse(AbstractModel): """CreateDBDiagReportTask返回参数结构体 """ def __init__(self): r""" :param AsyncRequestId: 异步任务的请求 ID，可使用此 ID 查询异步任务的执行结果。 注意：此字段可能返回 null，表示取不到有效值。 :type AsyncRequestId: int :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.AsyncRequestId = None self.RequestId = None def _deserialize(self, params): self.AsyncRequestId = params.get("AsyncRequestId") self.RequestId = params.get("RequestId") class CreateDBDiagReportUrlRequest(AbstractModel): """CreateDBDiagReportUrl请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例ID。 :type InstanceId: str :param AsyncRequestId: 健康报告相应的任务ID，可通过DescribeDBDiagReportTasks查询。 :type AsyncRequestId: int :param Product: 服务产品类型，支持值："mysql" - 云数据库 MySQL；"cynosdb" - 云数据库 TDSQL-C for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.AsyncRequestId = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.AsyncRequestId = params.get("AsyncRequestId") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class CreateDBDiagReportUrlResponse(AbstractModel): """CreateDBDiagReportUrl返回参数结构体 """ def __init__(self): r""" :param ReportUrl: 健康报告浏览地址。 :type ReportUrl: str :param ExpireTime: 健康报告浏览地址到期时间戳（秒）。 :type ExpireTime: int :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.ReportUrl = None self.ExpireTime = None self.RequestId = None def _deserialize(self, params): self.ReportUrl = params.get("ReportUrl") self.ExpireTime = params.get("ExpireTime") self.RequestId = params.get("RequestId") class CreateMailProfileRequest(AbstractModel): """CreateMailProfile请求参数结构体 """ def __init__(self): r""" :param ProfileInfo: 邮件配置内容。 :type ProfileInfo: :class:`tencentcloud.dbbrain.v20210527.models.ProfileInfo` :param ProfileLevel: 配置级别，支持值包括："User" - 用户级别，"Instance" - 实例级别，其中数据库巡检邮件配置为用户级别，定期生成邮件配置为实例级别。 :type ProfileLevel: str :param ProfileName: 配置名称，需要保持唯一性，数据库巡检邮件配置名称自拟；定期生成邮件配置命名格式："scheduler_" + {instanceId}，如"schduler_cdb-test"。 :type ProfileName: str :param ProfileType: 配置类型，支持值包括："dbScan_mail_configuration" - 数据库巡检邮件配置，"scheduler_mail_configuration" - 定期生成邮件配置。 :type ProfileType: str :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL。 :type Product: str :param BindInstanceIds: 配置绑定的实例ID，当配置级别为"Instance"时需要传入且只能为一个实例；当配置级别为“User”时，此参数不填。 :type BindInstanceIds: list of str """ self.ProfileInfo = None self.ProfileLevel = None self.ProfileName = None self.ProfileType = None self.Product = None self.BindInstanceIds = None def _deserialize(self, params): if params.get("ProfileInfo") is not None: self.ProfileInfo = ProfileInfo() self.ProfileInfo._deserialize(params.get("ProfileInfo")) self.ProfileLevel = params.get("ProfileLevel") self.ProfileName = params.get("ProfileName") self.ProfileType = params.get("ProfileType") self.Product = params.get("Product") self.BindInstanceIds = params.get("BindInstanceIds") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class CreateMailProfileResponse(AbstractModel): """CreateMailProfile返回参数结构体 """ def __init__(self): r""" :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.RequestId = None def _deserialize(self, params): self.RequestId = params.get("RequestId") class CreateSchedulerMailProfileRequest(AbstractModel): """CreateSchedulerMailProfile请求参数结构体 """ def __init__(self): r""" :param WeekConfiguration: 取值范围1-7，分别代表周一至周日。 :type WeekConfiguration: list of int :param ProfileInfo: 邮件配置内容。 :type ProfileInfo: :class:`tencentcloud.dbbrain.v20210527.models.ProfileInfo` :param ProfileName: 配置名称，需要保持唯一性，定期生成邮件配置命名格式："scheduler_" + {instanceId}，如"schduler_cdb-test"。 :type ProfileName: str :param BindInstanceId: 配置订阅的实例ID。 :type BindInstanceId: str :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 TDSQL-C for MySQL，默认为"mysql"。 :type Product: str """ self.WeekConfiguration = None self.ProfileInfo = None self.ProfileName = None self.BindInstanceId = None self.Product = None def _deserialize(self, params): self.WeekConfiguration = params.get("WeekConfiguration") if params.get("ProfileInfo") is not None: self.ProfileInfo = ProfileInfo() self.ProfileInfo._deserialize(params.get("ProfileInfo")) self.ProfileName = params.get("ProfileName") self.BindInstanceId = params.get("BindInstanceId") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class CreateSchedulerMailProfileResponse(AbstractModel): """CreateSchedulerMailProfile返回参数结构体 """ def __init__(self): r""" :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.RequestId = None def _deserialize(self, params): self.RequestId = params.get("RequestId") class CreateSecurityAuditLogExportTaskRequest(AbstractModel): """CreateSecurityAuditLogExportTask请求参数结构体 """ def __init__(self): r""" :param SecAuditGroupId: 安全审计组Id。 :type SecAuditGroupId: str :param StartTime: 导出日志开始时间，例如2020-12-28 00:00:00。 :type StartTime: str :param EndTime: 导出日志结束时间，例如2020-12-28 01:00:00。 :type EndTime: str :param Product: 服务产品类型，支持值："mysql" - 云数据库 MySQL。 :type Product: str :param DangerLevels: 日志风险等级列表，支持值包括：0 无风险；1 低风险；2 中风险；3 高风险。 :type DangerLevels: list of int """ self.SecAuditGroupId = None self.StartTime = None self.EndTime = None self.Product = None self.DangerLevels = None def _deserialize(self, params): self.SecAuditGroupId = params.get("SecAuditGroupId") self.StartTime = params.get("StartTime") self.EndTime = params.get("EndTime") self.Product = params.get("Product") self.DangerLevels = params.get("DangerLevels") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class CreateSecurityAuditLogExportTaskResponse(AbstractModel): """CreateSecurityAuditLogExportTask返回参数结构体 """ def __init__(self): r""" :param AsyncRequestId: 日志导出任务Id。 :type AsyncRequestId: int :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.AsyncRequestId = None self.RequestId = None def _deserialize(self, params): self.AsyncRequestId = params.get("AsyncRequestId") self.RequestId = params.get("RequestId") class DeleteSecurityAuditLogExportTasksRequest(AbstractModel): """DeleteSecurityAuditLogExportTasks请求参数结构体 """ def __init__(self): r""" :param SecAuditGroupId: 安全审计组Id。 :type SecAuditGroupId: str :param AsyncRequestIds: 日志导出任务Id列表，接口会忽略不存在或已删除的任务Id。 :type AsyncRequestIds: list of int non-negative :param Product: 服务产品类型，支持值： "mysql" - 云数据库 MySQL。 :type Product: str """ self.SecAuditGroupId = None self.AsyncRequestIds = None self.Product = None def _deserialize(self, params): self.SecAuditGroupId = params.get("SecAuditGroupId") self.AsyncRequestIds = params.get("AsyncRequestIds") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DeleteSecurityAuditLogExportTasksResponse(AbstractModel): """DeleteSecurityAuditLogExportTasks返回参数结构体 """ def __init__(self): r""" :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.RequestId = None def _deserialize(self, params): self.RequestId = params.get("RequestId") class DescribeAllUserContactRequest(AbstractModel): """DescribeAllUserContact请求参数结构体 """ def __init__(self): r""" :param Product: 服务产品类型，固定值：mysql。 :type Product: str :param Names: 联系人名数组，支持模糊搜索。 :type Names: list of str """ self.Product = None self.Names = None def _deserialize(self, params): self.Product = params.get("Product") self.Names = params.get("Names") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeAllUserContactResponse(AbstractModel): """DescribeAllUserContact返回参数结构体 """ def __init__(self): r""" :param TotalCount: 联系人的总数量。 :type TotalCount: int :param Contacts: 联系人的信息。 注意：此字段可能返回 null，表示取不到有效值。 :type Contacts: list of ContactItem :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.TotalCount = None self.Contacts = None self.RequestId = None def _deserialize(self, params): self.TotalCount = params.get("TotalCount") if params.get("Contacts") is not None: self.Contacts = [] for item in params.get("Contacts"): obj = ContactItem() obj._deserialize(item) self.Contacts.append(obj) self.RequestId = params.get("RequestId") class DescribeAllUserGroupRequest(AbstractModel): """DescribeAllUserGroup请求参数结构体 """ def __init__(self): r""" :param Product: 服务产品类型，固定值：mysql。 :type Product: str :param Names: 联系组名称数组，支持模糊搜索。 :type Names: list of str """ self.Product = None self.Names = None def _deserialize(self, params): self.Product = params.get("Product") self.Names = params.get("Names") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeAllUserGroupResponse(AbstractModel): """DescribeAllUserGroup返回参数结构体 """ def __init__(self): r""" :param TotalCount: 组总数。 :type TotalCount: int :param Groups: 组信息。 注意：此字段可能返回 null，表示取不到有效值。 :type Groups: list of GroupItem :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.TotalCount = None self.Groups = None self.RequestId = None def _deserialize(self, params): self.TotalCount = params.get("TotalCount") if params.get("Groups") is not None: self.Groups = [] for item in params.get("Groups"): obj = GroupItem() obj._deserialize(item) self.Groups.append(obj) self.RequestId = params.get("RequestId") class DescribeDBDiagEventRequest(AbstractModel): """DescribeDBDiagEvent请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例 ID 。 :type InstanceId: str :param EventId: 事件 ID 。通过“获取实例诊断历史DescribeDBDiagHistory”获取。 :type EventId: int :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.EventId = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.EventId = params.get("EventId") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeDBDiagEventResponse(AbstractModel): """DescribeDBDiagEvent返回参数结构体 """ def __init__(self): r""" :param DiagItem: 诊断项。 :type DiagItem: str :param DiagType: 诊断类型。 :type DiagType: str :param EventId: 事件 ID 。 :type EventId: int :param Explanation: 诊断事件详情，若无附加解释信息则输出为空。 :type Explanation: str :param Outline: 诊断概要。 :type Outline: str :param Problem: 诊断出的问题。 :type Problem: str :param Severity: 严重程度。严重程度分为5级，按影响程度从高至低分别为：1：致命，2：严重，3：告警，4：提示，5：健康。 :type Severity: int :param StartTime: 开始时间 :type StartTime: str :param Suggestions: 诊断建议，若无建议则输出为空。 :type Suggestions: str :param Metric: 保留字段。 注意：此字段可能返回 null，表示取不到有效值。 :type Metric: str :param EndTime: 结束时间。 :type EndTime: str :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.DiagItem = None self.DiagType = None self.EventId = None self.Explanation = None self.Outline = None self.Problem = None self.Severity = None self.StartTime = None self.Suggestions = None self.Metric = None self.EndTime = None self.RequestId = None def _deserialize(self, params): self.DiagItem = params.get("DiagItem") self.DiagType = params.get("DiagType") self.EventId = params.get("EventId") self.Explanation = params.get("Explanation") self.Outline = params.get("Outline") self.Problem = params.get("Problem") self.Severity = params.get("Severity") self.StartTime = params.get("StartTime") self.Suggestions = params.get("Suggestions") self.Metric = params.get("Metric") self.EndTime = params.get("EndTime") self.RequestId = params.get("RequestId") class DescribeDBDiagHistoryRequest(AbstractModel): """DescribeDBDiagHistory请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例 ID 。 :type InstanceId: str :param StartTime: 开始时间，如“2019-09-10 12:13:14”。 :type StartTime: str :param EndTime: 结束时间，如“2019-09-11 12:13:14”，结束时间与开始时间的间隔最大可为2天。 :type EndTime: str :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.StartTime = None self.EndTime = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.StartTime = params.get("StartTime") self.EndTime = params.get("EndTime") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeDBDiagHistoryResponse(AbstractModel): """DescribeDBDiagHistory返回参数结构体 """ def __init__(self): r""" :param Events: 事件描述。 :type Events: list of DiagHistoryEventItem :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.Events = None self.RequestId = None def _deserialize(self, params): if params.get("Events") is not None: self.Events = [] for item in params.get("Events"): obj = DiagHistoryEventItem() obj._deserialize(item) self.Events.append(obj) self.RequestId = params.get("RequestId") class DescribeDBDiagReportTasksRequest(AbstractModel): """DescribeDBDiagReportTasks请求参数结构体 """ def __init__(self): r""" :param StartTime: 第一个任务的开始时间，用于范围查询，时间格式如：2019-09-10 12:13:14。 :type StartTime: str :param EndTime: 最后一个任务的开始时间，用于范围查询，时间格式如：2019-09-10 12:13:14。 :type EndTime: str :param InstanceIds: 实例ID数组，用于筛选指定实例的任务列表。 :type InstanceIds: list of str :param Sources: 任务的触发来源，支持的取值包括："DAILY_INSPECTION" - 实例巡检；"SCHEDULED" - 定时生成；"MANUAL" - 手动触发。 :type Sources: list of str :param HealthLevels: 报告的健康等级，支持的取值包括："HEALTH" - 健康；"SUB_HEALTH" - 亚健康；"RISK" - 危险；"HIGH_RISK" - 高危。 :type HealthLevels: str :param TaskStatuses: 任务的状态，支持的取值包括："created" - 新建；"chosen" - 待执行； "running" - 执行中；"failed" - 失败；"finished" - 已完成。 :type TaskStatuses: str :param Offset: 偏移量，默认0。 :type Offset: int :param Limit: 返回数量，默认20，最大值为100。 :type Limit: int :param Product: 服务产品类型，支持值："mysql" - 云数据库 MySQL；"cynosdb" - 云数据库 TDSQL-C for MySQL，默认为"mysql"。 :type Product: str """ self.StartTime = None self.EndTime = None self.InstanceIds = None self.Sources = None self.HealthLevels = None self.TaskStatuses = None self.Offset = None self.Limit = None self.Product = None def _deserialize(self, params): self.StartTime = params.get("StartTime") self.EndTime = params.get("EndTime") self.InstanceIds = params.get("InstanceIds") self.Sources = params.get("Sources") self.HealthLevels = params.get("HealthLevels") self.TaskStatuses = params.get("TaskStatuses") self.Offset = params.get("Offset") self.Limit = params.get("Limit") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeDBDiagReportTasksResponse(AbstractModel): """DescribeDBDiagReportTasks返回参数结构体 """ def __init__(self): r""" :param TotalCount: 任务总数目。 :type TotalCount: int :param Tasks: 任务列表。 :type Tasks: list of HealthReportTask :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.TotalCount = None self.Tasks = None self.RequestId = None def _deserialize(self, params): self.TotalCount = params.get("TotalCount") if params.get("Tasks") is not None: self.Tasks = [] for item in params.get("Tasks"): obj = HealthReportTask() obj._deserialize(item) self.Tasks.append(obj) self.RequestId = params.get("RequestId") class DescribeDBSpaceStatusRequest(AbstractModel): """DescribeDBSpaceStatus请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例 ID 。 :type InstanceId: str :param RangeDays: 时间段天数，截止日期为当日，默认为7天。 :type RangeDays: int :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.RangeDays = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.RangeDays = params.get("RangeDays") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeDBSpaceStatusResponse(AbstractModel): """DescribeDBSpaceStatus返回参数结构体 """ def __init__(self): r""" :param Growth: 磁盘增长量(MB)。 :type Growth: int :param Remain: 磁盘剩余(MB)。 :type Remain: int :param Total: 磁盘总量(MB)。 :type Total: int :param AvailableDays: 预计可用天数。 :type AvailableDays: int :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.Growth = None self.Remain = None self.Total = None self.AvailableDays = None self.RequestId = None def _deserialize(self, params): self.Growth = params.get("Growth") self.Remain = params.get("Remain") self.Total = params.get("Total") self.AvailableDays = params.get("AvailableDays") self.RequestId = params.get("RequestId") class DescribeDiagDBInstancesRequest(AbstractModel): """DescribeDiagDBInstances请求参数结构体 """ def __init__(self): r""" :param IsSupported: 是否是DBbrain支持的实例，固定传 true。 :type IsSupported: bool :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 TDSQL-C for MySQL，默认为"mysql"。 :type Product: str :param Offset: 分页参数，偏移量。 :type Offset: int :param Limit: 分页参数，分页值，最大值为100。 :type Limit: int :param InstanceNames: 根据实例名称条件查询。 :type InstanceNames: list of str :param InstanceIds: 根据实例ID条件查询。 :type InstanceIds: list of str :param Regions: 根据地域条件查询。 :type Regions: list of str """ self.IsSupported = None self.Product = None self.Offset = None self.Limit = None self.InstanceNames = None self.InstanceIds = None self.Regions = None def _deserialize(self, params): self.IsSupported = params.get("IsSupported") self.Product = params.get("Product") self.Offset = params.get("Offset") self.Limit = params.get("Limit") self.InstanceNames = params.get("InstanceNames") self.InstanceIds = params.get("InstanceIds") self.Regions = params.get("Regions") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeDiagDBInstancesResponse(AbstractModel): """DescribeDiagDBInstances返回参数结构体 """ def __init__(self): r""" :param TotalCount: 实例总数。 :type TotalCount: int :param DbScanStatus: 全实例巡检状态：0：开启全实例巡检；1：未开启全实例巡检。 :type DbScanStatus: int :param Items: 实例相关信息。 :type Items: list of InstanceInfo :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.TotalCount = None self.DbScanStatus = None self.Items = None self.RequestId = None def _deserialize(self, params): self.TotalCount = params.get("TotalCount") self.DbScanStatus = params.get("DbScanStatus") if params.get("Items") is not None: self.Items = [] for item in params.get("Items"): obj = InstanceInfo() obj._deserialize(item) self.Items.append(obj) self.RequestId = params.get("RequestId") class DescribeHealthScoreRequest(AbstractModel): """DescribeHealthScore请求参数结构体 """ def __init__(self): r""" :param InstanceId: 需要获取健康得分的实例ID。 :type InstanceId: str :param Time: 获取健康得分的时间，时间格式如：2019-09-10 12:13:14。 :type Time: str :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 TDSQL-C for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.Time = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.Time = params.get("Time") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeHealthScoreResponse(AbstractModel): """DescribeHealthScore返回参数结构体 """ def __init__(self): r""" :param Data: 健康得分以及异常扣分项。 :type Data: :class:`tencentcloud.dbbrain.v20210527.models.HealthScoreInfo` :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.Data = None self.RequestId = None def _deserialize(self, params): if params.get("Data") is not None: self.Data = HealthScoreInfo() self.Data._deserialize(params.get("Data")) self.RequestId = params.get("RequestId") class DescribeMailProfileRequest(AbstractModel): """DescribeMailProfile请求参数结构体 """ def __init__(self): r""" :param ProfileType: 配置类型，支持值包括："dbScan_mail_configuration" - 数据库巡检邮件配置，"scheduler_mail_configuration" - 定期生成邮件配置。 :type ProfileType: str :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 TDSQL-C for MySQL，默认为"mysql"。 :type Product: str :param Offset: 分页偏移量。 :type Offset: int :param Limit: 分页单位，最大支持50。 :type Limit: int :param ProfileName: 根据邮件配置名称查询，定期发送的邮件配置名称遵循："scheduler_"+{instanceId}的规则。 :type ProfileName: str """ self.ProfileType = None self.Product = None self.Offset = None self.Limit = None self.ProfileName = None def _deserialize(self, params): self.ProfileType = params.get("ProfileType") self.Product = params.get("Product") self.Offset = params.get("Offset") self.Limit = params.get("Limit") self.ProfileName = params.get("ProfileName") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeMailProfileResponse(AbstractModel): """DescribeMailProfile返回参数结构体 """ def __init__(self): r""" :param ProfileList: 邮件配置详情。 注意：此字段可能返回 null，表示取不到有效值。 :type ProfileList: list of UserProfile :param TotalCount: 邮件模版总数。 注意：此字段可能返回 null，表示取不到有效值。 :type TotalCount: int :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.ProfileList = None self.TotalCount = None self.RequestId = None def _deserialize(self, params): if params.get("ProfileList") is not None: self.ProfileList = [] for item in params.get("ProfileList"): obj = UserProfile() obj._deserialize(item) self.ProfileList.append(obj) self.TotalCount = params.get("TotalCount") self.RequestId = params.get("RequestId") class DescribeMySqlProcessListRequest(AbstractModel): """DescribeMySqlProcessList请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例ID。 :type InstanceId: str :param ID: 线程的ID，用于筛选线程列表。 :type ID: int :param User: 线程的操作账号名，用于筛选线程列表。 :type User: str :param Host: 线程的操作主机地址，用于筛选线程列表。 :type Host: str :param DB: 线程的操作数据库，用于筛选线程列表。 :type DB: str :param State: 线程的操作状态，用于筛选线程列表。 :type State: str :param Command: 线程的执行类型，用于筛选线程列表。 :type Command: str :param Time: 线程的操作时长最小值，单位秒，用于筛选操作时长大于该值的线程列表。 :type Time: int :param Info: 线程的操作语句，用于筛选线程列表。 :type Info: str :param Limit: 返回数量，默认20。 :type Limit: int :param Product: 服务产品类型，支持值："mysql" - 云数据库 MySQL；"cynosdb" - 云数据库 TDSQL-C for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.ID = None self.User = None self.Host = None self.DB = None self.State = None self.Command = None self.Time = None self.Info = None self.Limit = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.ID = params.get("ID") self.User = params.get("User") self.Host = params.get("Host") self.DB = params.get("DB") self.State = params.get("State") self.Command = params.get("Command") self.Time = params.get("Time") self.Info = params.get("Info") self.Limit = params.get("Limit") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeMySqlProcessListResponse(AbstractModel): """DescribeMySqlProcessList返回参数结构体 """ def __init__(self): r""" :param ProcessList: 实时线程列表。 :type ProcessList: list of MySqlProcess :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.ProcessList = None self.RequestId = None def _deserialize(self, params): if params.get("ProcessList") is not None: self.ProcessList = [] for item in params.get("ProcessList"): obj = MySqlProcess() obj._deserialize(item) self.ProcessList.append(obj) self.RequestId = params.get("RequestId") class DescribeSecurityAuditLogDownloadUrlsRequest(AbstractModel): """DescribeSecurityAuditLogDownloadUrls请求参数结构体 """ def __init__(self): r""" :param SecAuditGroupId: 安全审计组Id。 :type SecAuditGroupId: str :param AsyncRequestId: 异步任务Id。 :type AsyncRequestId: int :param Product: 服务产品类型，支持值："mysql" - 云数据库 MySQL。 :type Product: str """ self.SecAuditGroupId = None self.AsyncRequestId = None self.Product = None def _deserialize(self, params): self.SecAuditGroupId = params.get("SecAuditGroupId") self.AsyncRequestId = params.get("AsyncRequestId") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeSecurityAuditLogDownloadUrlsResponse(AbstractModel): """DescribeSecurityAuditLogDownloadUrls返回参数结构体 """ def __init__(self): r""" :param Urls: 导出结果的COS链接列表。当结果集很大时，可能会切分为多个url下载。 :type Urls: list of str :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.Urls = None self.RequestId = None def _deserialize(self, params): self.Urls = params.get("Urls") self.RequestId = params.get("RequestId") class DescribeSecurityAuditLogExportTasksRequest(AbstractModel): """DescribeSecurityAuditLogExportTasks请求参数结构体 """ def __init__(self): r""" :param SecAuditGroupId: 安全审计组Id。 :type SecAuditGroupId: str :param Product: 服务产品类型，支持值："mysql" - 云数据库 MySQL。 :type Product: str :param AsyncRequestIds: 日志导出任务Id列表。 :type AsyncRequestIds: list of int non-negative :param Offset: 偏移量，默认0。 :type Offset: int :param Limit: 返回数量，默认20，最大值为100。 :type Limit: int """ self.SecAuditGroupId = None self.Product = None self.AsyncRequestIds = None self.Offset = None self.Limit = None def _deserialize(self, params): self.SecAuditGroupId = params.get("SecAuditGroupId") self.Product = params.get("Product") self.AsyncRequestIds = params.get("AsyncRequestIds") self.Offset = params.get("Offset") self.Limit = params.get("Limit") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeSecurityAuditLogExportTasksResponse(AbstractModel): """DescribeSecurityAuditLogExportTasks返回参数结构体 """ def __init__(self): r""" :param Tasks: 安全审计日志导出任务列表。 :type Tasks: list of SecLogExportTaskInfo :param TotalCount: 安全审计日志导出任务总数。 :type TotalCount: int :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.Tasks = None self.TotalCount = None self.RequestId = None def _deserialize(self, params): if params.get("Tasks") is not None: self.Tasks = [] for item in params.get("Tasks"): obj = SecLogExportTaskInfo() obj._deserialize(item) self.Tasks.append(obj) self.TotalCount = params.get("TotalCount") self.RequestId = params.get("RequestId") class DescribeSlowLogTimeSeriesStatsRequest(AbstractModel): """DescribeSlowLogTimeSeriesStats请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例 ID 。 :type InstanceId: str :param StartTime: 开始时间，如“2019-09-10 12:13:14”。 :type StartTime: str :param EndTime: 结束时间，如“2019-09-10 12:13:14”，结束时间与开始时间的间隔最大可为7天。 :type EndTime: str :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.StartTime = None self.EndTime = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.StartTime = params.get("StartTime") self.EndTime = params.get("EndTime") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeSlowLogTimeSeriesStatsResponse(AbstractModel): """DescribeSlowLogTimeSeriesStats返回参数结构体 """ def __init__(self): r""" :param Period: 柱间单位时间间隔，单位为秒。 :type Period: int :param TimeSeries: 单位时间间隔内慢日志数量统计。 :type TimeSeries: list of TimeSlice :param SeriesData: 单位时间间隔内的实例 cpu 利用率监控数据。 :type SeriesData: :class:`tencentcloud.dbbrain.v20210527.models.MonitorMetricSeriesData` :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.Period = None self.TimeSeries = None self.SeriesData = None self.RequestId = None def _deserialize(self, params): self.Period = params.get("Period") if params.get("TimeSeries") is not None: self.TimeSeries = [] for item in params.get("TimeSeries"): obj = TimeSlice() obj._deserialize(item) self.TimeSeries.append(obj) if params.get("SeriesData") is not None: self.SeriesData = MonitorMetricSeriesData() self.SeriesData._deserialize(params.get("SeriesData")) self.RequestId = params.get("RequestId") class DescribeSlowLogTopSqlsRequest(AbstractModel): """DescribeSlowLogTopSqls请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例 ID 。 :type InstanceId: str :param StartTime: 开始时间，如“2019-09-10 12:13:14”。 :type StartTime: str :param EndTime: 截止时间，如“2019-09-11 10:13:14”，截止时间与开始时间的间隔小于7天。 :type EndTime: str :param SortBy: 排序键，目前支持 QueryTime,ExecTimes,RowsSent,LockTime以及RowsExamined 等排序键，默认为QueryTime。 :type SortBy: str :param OrderBy: 排序方式，支持ASC（升序）以及DESC（降序），默认为DESC。 :type OrderBy: str :param Limit: 返回数量，默认为20，最大值为100。 :type Limit: int :param Offset: 偏移量，默认为0。 :type Offset: int :param SchemaList: 数据库名称数组。 :type SchemaList: list of SchemaItem :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.StartTime = None self.EndTime = None self.SortBy = None self.OrderBy = None self.Limit = None self.Offset = None self.SchemaList = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.StartTime = params.get("StartTime") self.EndTime = params.get("EndTime") self.SortBy = params.get("SortBy") self.OrderBy = params.get("OrderBy") self.Limit = params.get("Limit") self.Offset = params.get("Offset") if params.get("SchemaList") is not None: self.SchemaList = [] for item in params.get("SchemaList"): obj = SchemaItem() obj._deserialize(item) self.SchemaList.append(obj) self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeSlowLogTopSqlsResponse(AbstractModel): """DescribeSlowLogTopSqls返回参数结构体 """ def __init__(self): r""" :param TotalCount: 符合条件的记录总数。 :type TotalCount: int :param Rows: 慢日志 top sql 列表 :type Rows: list of SlowLogTopSqlItem :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.TotalCount = None self.Rows = None self.RequestId = None def _deserialize(self, params): self.TotalCount = params.get("TotalCount") if params.get("Rows") is not None: self.Rows = [] for item in params.get("Rows"): obj = SlowLogTopSqlItem() obj._deserialize(item) self.Rows.append(obj) self.RequestId = params.get("RequestId") class DescribeSlowLogUserHostStatsRequest(AbstractModel): """DescribeSlowLogUserHostStats请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例ID。 :type InstanceId: str :param StartTime: 查询范围的开始时间，时间格式如：2019-09-10 12:13:14。 :type StartTime: str :param EndTime: 查询范围的结束时间，时间格式如：2019-09-10 12:13:14。 :type EndTime: str :param Product: 服务产品类型，支持值："mysql" - 云数据库 MySQL；"cynosdb" - 云数据库 TDSQL-C for MySQL，默认为"mysql"。 :type Product: str :param Md5: SOL模板的MD5值 :type Md5: str """ self.InstanceId = None self.StartTime = None self.EndTime = None self.Product = None self.Md5 = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.StartTime = params.get("StartTime") self.EndTime = params.get("EndTime") self.Product = params.get("Product") self.Md5 = params.get("Md5") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeSlowLogUserHostStatsResponse(AbstractModel): """DescribeSlowLogUserHostStats返回参数结构体 """ def __init__(self): r""" :param TotalCount: 来源地址数目。 :type TotalCount: int :param Items: 各来源地址的慢日志占比详情列表。 :type Items: list of SlowLogHost :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.TotalCount = None self.Items = None self.RequestId = None def _deserialize(self, params): self.TotalCount = params.get("TotalCount") if params.get("Items") is not None: self.Items = [] for item in params.get("Items"): obj = SlowLogHost() obj._deserialize(item) self.Items.append(obj) self.RequestId = params.get("RequestId") class DescribeTopSpaceSchemaTimeSeriesRequest(AbstractModel): """DescribeTopSpaceSchemaTimeSeries请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例ID。 :type InstanceId: str :param Limit: 返回的Top库数量，最大值为100，默认为20。 :type Limit: int :param SortBy: 筛选Top库所用的排序字段，可选字段包含DataLength、IndexLength、TotalLength、DataFree、FragRatio、TableRows、PhysicalFileSize（仅云数据库 MySQL实例支持），云数据库 MySQL实例默认为 PhysicalFileSize，其他产品实例默认为TotalLength。 :type SortBy: str :param StartDate: 开始日期，如“2021-01-01”，最早为当日的前第29天，默认为截止日期的前第6天。 :type StartDate: str :param EndDate: 截止日期，如“2021-01-01”，最早为当日的前第29天，默认为当日。 :type EndDate: str :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.Limit = None self.SortBy = None self.StartDate = None self.EndDate = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.Limit = params.get("Limit") self.SortBy = params.get("SortBy") self.StartDate = params.get("StartDate") self.EndDate = params.get("EndDate") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeTopSpaceSchemaTimeSeriesResponse(AbstractModel): """DescribeTopSpaceSchemaTimeSeries返回参数结构体 """ def __init__(self): r""" :param TopSpaceSchemaTimeSeries: 返回的Top库空间统计信息的时序数据列表。 :type TopSpaceSchemaTimeSeries: list of SchemaSpaceTimeSeries :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.TopSpaceSchemaTimeSeries = None self.RequestId = None def _deserialize(self, params): if params.get("TopSpaceSchemaTimeSeries") is not None: self.TopSpaceSchemaTimeSeries = [] for item in params.get("TopSpaceSchemaTimeSeries"): obj = SchemaSpaceTimeSeries() obj._deserialize(item) self.TopSpaceSchemaTimeSeries.append(obj) self.RequestId = params.get("RequestId") class DescribeTopSpaceSchemasRequest(AbstractModel): """DescribeTopSpaceSchemas请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例 ID 。 :type InstanceId: str :param Limit: 返回的Top库数量，最大值为100，默认为20。 :type Limit: int :param SortBy: 筛选Top库所用的排序字段，可选字段包含DataLength、IndexLength、TotalLength、DataFree、FragRatio、TableRows、PhysicalFileSize（仅云数据库 MySQL实例支持），云数据库 MySQL实例默认为 PhysicalFileSize，其他产品实例默认为TotalLength。 :type SortBy: str :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.Limit = None self.SortBy = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.Limit = params.get("Limit") self.SortBy = params.get("SortBy") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeTopSpaceSchemasResponse(AbstractModel): """DescribeTopSpaceSchemas返回参数结构体 """ def __init__(self): r""" :param TopSpaceSchemas: 返回的Top库空间统计信息列表。 :type TopSpaceSchemas: list of SchemaSpaceData :param Timestamp: 采集库空间数据的时间戳（秒）。 :type Timestamp: int :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.TopSpaceSchemas = None self.Timestamp = None self.RequestId = None def _deserialize(self, params): if params.get("TopSpaceSchemas") is not None: self.TopSpaceSchemas = [] for item in params.get("TopSpaceSchemas"): obj = SchemaSpaceData() obj._deserialize(item) self.TopSpaceSchemas.append(obj) self.Timestamp = params.get("Timestamp") self.RequestId = params.get("RequestId") class DescribeTopSpaceTableTimeSeriesRequest(AbstractModel): """DescribeTopSpaceTableTimeSeries请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例 ID 。 :type InstanceId: str :param Limit: 返回的Top表数量，最大值为100，默认为20。 :type Limit: int :param SortBy: 筛选Top表所用的排序字段，可选字段包含DataLength、IndexLength、TotalLength、DataFree、FragRatio、TableRows、PhysicalFileSize，默认为 PhysicalFileSize。 :type SortBy: str :param StartDate: 开始日期，如“2021-01-01”，最早为当日的前第29天，默认为截止日期的前第6天。 :type StartDate: str :param EndDate: 截止日期，如“2021-01-01”，最早为当日的前第29天，默认为当日。 :type EndDate: str :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.Limit = None self.SortBy = None self.StartDate = None self.EndDate = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.Limit = params.get("Limit") self.SortBy = params.get("SortBy") self.StartDate = params.get("StartDate") self.EndDate = params.get("EndDate") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeTopSpaceTableTimeSeriesResponse(AbstractModel): """DescribeTopSpaceTableTimeSeries返回参数结构体 """ def __init__(self): r""" :param TopSpaceTableTimeSeries: 返回的Top表空间统计信息的时序数据列表。 :type TopSpaceTableTimeSeries: list of TableSpaceTimeSeries :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.TopSpaceTableTimeSeries = None self.RequestId = None def _deserialize(self, params): if params.get("TopSpaceTableTimeSeries") is not None: self.TopSpaceTableTimeSeries = [] for item in params.get("TopSpaceTableTimeSeries"): obj = TableSpaceTimeSeries() obj._deserialize(item) self.TopSpaceTableTimeSeries.append(obj) self.RequestId = params.get("RequestId") class DescribeTopSpaceTablesRequest(AbstractModel): """DescribeTopSpaceTables请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例 ID 。 :type InstanceId: str :param Limit: 返回的Top表数量，最大值为100，默认为20。 :type Limit: int :param SortBy: 筛选Top表所用的排序字段，可选字段包含DataLength、IndexLength、TotalLength、DataFree、FragRatio、TableRows、PhysicalFileSize（仅云数据库 MySQL实例支持），云数据库 MySQL实例默认为 PhysicalFileSize，其他产品实例默认为TotalLength。 :type SortBy: str :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.Limit = None self.SortBy = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.Limit = params.get("Limit") self.SortBy = params.get("SortBy") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeTopSpaceTablesResponse(AbstractModel): """DescribeTopSpaceTables返回参数结构体 """ def __init__(self): r""" :param TopSpaceTables: 返回的Top表空间统计信息列表。 :type TopSpaceTables: list of TableSpaceData :param Timestamp: 采集表空间数据的时间戳（秒）。 :type Timestamp: int :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.TopSpaceTables = None self.Timestamp = None self.RequestId = None def _deserialize(self, params): if params.get("TopSpaceTables") is not None: self.TopSpaceTables = [] for item in params.get("TopSpaceTables"): obj = TableSpaceData() obj._deserialize(item) self.TopSpaceTables.append(obj) self.Timestamp = params.get("Timestamp") self.RequestId = params.get("RequestId") class DescribeUserSqlAdviceRequest(AbstractModel): """DescribeUserSqlAdvice请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例ID。 :type InstanceId: str :param SqlText: SQL语句。 :type SqlText: str :param Schema: 库名。 :type Schema: str """ self.InstanceId = None self.SqlText = None self.Schema = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.SqlText = params.get("SqlText") self.Schema = params.get("Schema") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class DescribeUserSqlAdviceResponse(AbstractModel): """DescribeUserSqlAdvice返回参数结构体 """ def __init__(self): r""" :param Advices: SQL优化建议，可解析为JSON数组，无需优化时输出为空。 :type Advices: str :param Comments: SQL优化建议备注，可解析为String数组，无需优化时输出为空。 :type Comments: str :param SqlText: SQL语句。 :type SqlText: str :param Schema: 库名。 :type Schema: str :param Tables: 相关表的DDL信息，可解析为JSON数组。 :type Tables: str :param SqlPlan: SQL执行计划，可解析为JSON，无需优化时输出为空。 :type SqlPlan: str :param Cost: SQL优化后的成本节约详情，可解析为JSON，无需优化时输出为空。 :type Cost: str :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.Advices = None self.Comments = None self.SqlText = None self.Schema = None self.Tables = None self.SqlPlan = None self.Cost = None self.RequestId = None def _deserialize(self, params): self.Advices = params.get("Advices") self.Comments = params.get("Comments") self.SqlText = params.get("SqlText") self.Schema = params.get("Schema") self.Tables = params.get("Tables") self.SqlPlan = params.get("SqlPlan") self.Cost = params.get("Cost") self.RequestId = params.get("RequestId") class DiagHistoryEventItem(AbstractModel): """实例诊断历史事件 """ def __init__(self): r""" :param DiagType: 诊断类型。 :type DiagType: str :param EndTime: 结束时间。 :type EndTime: str :param StartTime: 开始时间。 :type StartTime: str :param EventId: 事件唯一ID 。 :type EventId: int :param Severity: 严重程度。严重程度分为5级，按影响程度从高至低分别为：1：致命，2：严重，3：告警，4：提示，5：健康。 :type Severity: int :param Outline: 诊断概要。 :type Outline: str :param DiagItem: 诊断项说明。 :type DiagItem: str :param InstanceId: 实例 ID 。 :type InstanceId: str :param Metric: 保留字段。 注意：此字段可能返回 null，表示取不到有效值。 :type Metric: str :param Region: 地域。 :type Region: str """ self.DiagType = None self.EndTime = None self.StartTime = None self.EventId = None self.Severity = None self.Outline = None self.DiagItem = None self.InstanceId = None self.Metric = None self.Region = None def _deserialize(self, params): self.DiagType = params.get("DiagType") self.EndTime = params.get("EndTime") self.StartTime = params.get("StartTime") self.EventId = params.get("EventId") self.Severity = params.get("Severity") self.Outline = params.get("Outline") self.DiagItem = params.get("DiagItem") self.InstanceId = params.get("InstanceId") self.Metric = params.get("Metric") self.Region = params.get("Region") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class EventInfo(AbstractModel): """异常事件信息。 """ def __init__(self): r""" :param EventId: 事件 ID 。 :type EventId: int :param DiagType: 诊断类型。 :type DiagType: str :param StartTime: 开始时间。 :type StartTime: str :param EndTime: 结束时间。 :type EndTime: str :param Outline: 概要。 :type Outline: str :param Severity: 严重程度。严重程度分为5级，按影响程度从高至低分别为：1：致命，2：严重，3：告警，4：提示，5：健康。 :type Severity: int :param ScoreLost: 扣分。 :type ScoreLost: int :param Metric: 保留字段。 :type Metric: str :param Count: 告警数目。 :type Count: int """ self.EventId = None self.DiagType = None self.StartTime = None self.EndTime = None self.Outline = None self.Severity = None self.ScoreLost = None self.Metric = None self.Count = None def _deserialize(self, params): self.EventId = params.get("EventId") self.DiagType = params.get("DiagType") self.StartTime = params.get("StartTime") self.EndTime = params.get("EndTime") self.Outline = params.get("Outline") self.Severity = params.get("Severity") self.ScoreLost = params.get("ScoreLost") self.Metric = params.get("Metric") self.Count = params.get("Count") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class GroupItem(AbstractModel): """描述组信息。 """ def __init__(self): r""" :param Id: 组id。 :type Id: int :param Name: 组名称。 :type Name: str :param MemberCount: 组成员数量。 :type MemberCount: int """ self.Id = None self.Name = None self.MemberCount = None def _deserialize(self, params): self.Id = params.get("Id") self.Name = params.get("Name") self.MemberCount = params.get("MemberCount") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class HealthReportTask(AbstractModel): """健康报告任务详情。 """ def __init__(self): r""" :param AsyncRequestId: 异步任务请求 ID。 :type AsyncRequestId: int :param Source: 任务的触发来源，支持的取值包括："DAILY_INSPECTION" - 实例巡检；"SCHEDULED" - 定时生成；"MANUAL" - 手动触发。 :type Source: str :param Progress: 任务完成进度，单位%。 :type Progress: int :param CreateTime: 任务创建时间。 :type CreateTime: str :param StartTime: 任务开始执行时间。 :type StartTime: str :param EndTime: 任务完成执行时间。 :type EndTime: str :param InstanceInfo: 任务所属实例的基础信息。 :type InstanceInfo: :class:`tencentcloud.dbbrain.v20210527.models.InstanceBasicInfo` :param HealthStatus: 健康报告中的健康信息。 :type HealthStatus: :class:`tencentcloud.dbbrain.v20210527.models.HealthStatus` """ self.AsyncRequestId = None self.Source = None self.Progress = None self.CreateTime = None self.StartTime = None self.EndTime = None self.InstanceInfo = None self.HealthStatus = None def _deserialize(self, params): self.AsyncRequestId = params.get("AsyncRequestId") self.Source = params.get("Source") self.Progress = params.get("Progress") self.CreateTime = params.get("CreateTime") self.StartTime = params.get("StartTime") self.EndTime = params.get("EndTime") if params.get("InstanceInfo") is not None: self.InstanceInfo = InstanceBasicInfo() self.InstanceInfo._deserialize(params.get("InstanceInfo")) if params.get("HealthStatus") is not None: self.HealthStatus = HealthStatus() self.HealthStatus._deserialize(params.get("HealthStatus")) memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class HealthScoreInfo(AbstractModel): """获取健康得分返回的详情。 """ def __init__(self): r""" :param IssueTypes: 异常详情。 :type IssueTypes: list of IssueTypeInfo :param EventsTotalCount: 异常事件总数。 :type EventsTotalCount: int :param HealthScore: 健康得分。 :type HealthScore: int :param HealthLevel: 健康等级, 如："HEALTH", "SUB_HEALTH", "RISK", "HIGH_RISK"。 :type HealthLevel: str """ self.IssueTypes = None self.EventsTotalCount = None self.HealthScore = None self.HealthLevel = None def _deserialize(self, params): if params.get("IssueTypes") is not None: self.IssueTypes = [] for item in params.get("IssueTypes"): obj = IssueTypeInfo() obj._deserialize(item) self.IssueTypes.append(obj) self.EventsTotalCount = params.get("EventsTotalCount") self.HealthScore = params.get("HealthScore") self.HealthLevel = params.get("HealthLevel") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class HealthStatus(AbstractModel): """实例健康详情。 """ def __init__(self): r""" :param HealthScore: 健康分数，满分100。 :type HealthScore: int :param HealthLevel: 健康等级，取值包括："HEALTH" - 健康；"SUB_HEALTH" - 亚健康；"RISK"- 危险；"HIGH_RISK" - 高危。 :type HealthLevel: str :param ScoreLost: 总扣分分数。 :type ScoreLost: int :param ScoreDetails: 扣分详情。 注意：此字段可能返回 null，表示取不到有效值。 :type ScoreDetails: list of ScoreDetail """ self.HealthScore = None self.HealthLevel = None self.ScoreLost = None self.ScoreDetails = None def _deserialize(self, params): self.HealthScore = params.get("HealthScore") self.HealthLevel = params.get("HealthLevel") self.ScoreLost = params.get("ScoreLost") if params.get("ScoreDetails") is not None: self.ScoreDetails = [] for item in params.get("ScoreDetails"): obj = ScoreDetail() obj._deserialize(item) self.ScoreDetails.append(obj) memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class InstanceBasicInfo(AbstractModel): """实例基础信息。 """ def __init__(self): r""" :param InstanceId: 实例ID。 :type InstanceId: str :param InstanceName: 实例名称。 :type InstanceName: str :param Vip: 实例内网IP。 :type Vip: str :param Vport: 实例内网Port。 :type Vport: int :param Product: 实例产品。 :type Product: str :param EngineVersion: 实例引擎版本。 :type EngineVersion: str """ self.InstanceId = None self.InstanceName = None self.Vip = None self.Vport = None self.Product = None self.EngineVersion = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.InstanceName = params.get("InstanceName") self.Vip = params.get("Vip") self.Vport = params.get("Vport") self.Product = params.get("Product") self.EngineVersion = params.get("EngineVersion") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class InstanceConfs(AbstractModel): """实例配置。 """ def __init__(self): r""" :param DailyInspection: 数据库巡检开关, Yes/No。 :type DailyInspection: str :param OverviewDisplay: 实例概览开关，Yes/No。 :type OverviewDisplay: str """ self.DailyInspection = None self.OverviewDisplay = None def _deserialize(self, params): self.DailyInspection = params.get("DailyInspection") self.OverviewDisplay = params.get("OverviewDisplay") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class InstanceInfo(AbstractModel): """查询实例列表，返回实例的相关信息的对象。 """ def __init__(self): r""" :param InstanceId: 实例ID。 :type InstanceId: str :param InstanceName: 实例名称。 :type InstanceName: str :param Region: 实例所属地域。 :type Region: str :param HealthScore: 健康得分。 :type HealthScore: int :param Product: 所属产品。 :type Product: str :param EventCount: 异常事件数量。 :type EventCount: int :param InstanceType: 实例类型：1:MASTER；2:DR，3：RO，4:SDR。 :type InstanceType: int :param Cpu: 核心数。 :type Cpu: int :param Memory: 内存，单位MB。 :type Memory: int :param Volume: 硬盘存储，单位GB。 :type Volume: int :param EngineVersion: 数据库版本。 :type EngineVersion: str :param Vip: 内网地址。 :type Vip: str :param Vport: 内网端口。 :type Vport: int :param Source: 接入来源。 :type Source: str :param GroupId: 分组ID。 :type GroupId: str :param GroupName: 分组组名。 :type GroupName: str :param Status: 实例状态：0：发货中；1：运行正常；4：销毁中；5：隔离中。 :type Status: int :param UniqSubnetId: 子网统一ID。 :type UniqSubnetId: str :param DeployMode: cdb类型。 :type DeployMode: str :param InitFlag: cdb实例初始化标志：0：未初始化；1：已初始化。 :type InitFlag: int :param TaskStatus: 任务状态。 :type TaskStatus: int :param UniqVpcId: 私有网络统一ID。 :type UniqVpcId: str :param InstanceConf: 实例巡检/概览的状态。 :type InstanceConf: :class:`tencentcloud.dbbrain.v20210527.models.InstanceConfs` :param DeadlineTime: 资源到期时间。 :type DeadlineTime: str :param IsSupported: 是否是DBbrain支持的实例。 :type IsSupported: bool :param SecAuditStatus: 实例安全审计日志开启状态：ON： 安全审计开启；OFF： 未开启安全审计。 :type SecAuditStatus: str :param AuditPolicyStatus: 实例审计日志开启状态，ALL_AUDIT： 开启全审计；RULE_AUDIT： 开启规则审计；UNBOUND： 未开启审计。 :type AuditPolicyStatus: str :param AuditRunningStatus: 实例审计日志运行状态：normal： 运行中； paused： 欠费暂停。 :type AuditRunningStatus: str """ self.InstanceId = None self.InstanceName = None self.Region = None self.HealthScore = None self.Product = None self.EventCount = None self.InstanceType = None self.Cpu = None self.Memory = None self.Volume = None self.EngineVersion = None self.Vip = None self.Vport = None self.Source = None self.GroupId = None self.GroupName = None self.Status = None self.UniqSubnetId = None self.DeployMode = None self.InitFlag = None self.TaskStatus = None self.UniqVpcId = None self.InstanceConf = None self.DeadlineTime = None self.IsSupported = None self.SecAuditStatus = None self.AuditPolicyStatus = None self.AuditRunningStatus = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.InstanceName = params.get("InstanceName") self.Region = params.get("Region") self.HealthScore = params.get("HealthScore") self.Product = params.get("Product") self.EventCount = params.get("EventCount") self.InstanceType = params.get("InstanceType") self.Cpu = params.get("Cpu") self.Memory = params.get("Memory") self.Volume = params.get("Volume") self.EngineVersion = params.get("EngineVersion") self.Vip = params.get("Vip") self.Vport = params.get("Vport") self.Source = params.get("Source") self.GroupId = params.get("GroupId") self.GroupName = params.get("GroupName") self.Status = params.get("Status") self.UniqSubnetId = params.get("UniqSubnetId") self.DeployMode = params.get("DeployMode") self.InitFlag = params.get("InitFlag") self.TaskStatus = params.get("TaskStatus") self.UniqVpcId = params.get("UniqVpcId") if params.get("InstanceConf") is not None: self.InstanceConf = InstanceConfs() self.InstanceConf._deserialize(params.get("InstanceConf")) self.DeadlineTime = params.get("DeadlineTime") self.IsSupported = params.get("IsSupported") self.SecAuditStatus = params.get("SecAuditStatus") self.AuditPolicyStatus = params.get("AuditPolicyStatus") self.AuditRunningStatus = params.get("AuditRunningStatus") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class IssueTypeInfo(AbstractModel): """指标信息。 """ def __init__(self): r""" :param IssueType: 指标分类：AVAILABILITY：可用性，MAINTAINABILITY：可维护性，PERFORMANCE，性能，RELIABILITY可靠性。 :type IssueType: str :param Events: 异常事件。 :type Events: list of EventInfo :param TotalCount: 异常事件总数。 :type TotalCount: int """ self.IssueType = None self.Events = None self.TotalCount = None def _deserialize(self, params): self.IssueType = params.get("IssueType") if params.get("Events") is not None: self.Events = [] for item in params.get("Events"): obj = EventInfo() obj._deserialize(item) self.Events.append(obj) self.TotalCount = params.get("TotalCount") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class KillMySqlThreadsRequest(AbstractModel): """KillMySqlThreads请求参数结构体 """ def __init__(self): r""" :param InstanceId: 实例ID。 :type InstanceId: str :param Stage: kill会话任务的阶段，取值包括："Prepare"-准备阶段，"Commit"-提交阶段。 :type Stage: str :param Threads: 需要kill的sql会话ID列表，此参数用于Prepare阶段。 :type Threads: list of int :param SqlExecId: 执行ID，此参数用于Commit阶段。 :type SqlExecId: str :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL，默认为"mysql"。 :type Product: str """ self.InstanceId = None self.Stage = None self.Threads = None self.SqlExecId = None self.Product = None def _deserialize(self, params): self.InstanceId = params.get("InstanceId") self.Stage = params.get("Stage") self.Threads = params.get("Threads") self.SqlExecId = params.get("SqlExecId") self.Product = params.get("Product") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class KillMySqlThreadsResponse(AbstractModel): """KillMySqlThreads返回参数结构体 """ def __init__(self): r""" :param Threads: kill完成的sql会话ID列表。 :type Threads: list of int :param SqlExecId: 执行ID， Prepare阶段的任务输出，用于Commit阶段中指定执行kill操作的会话ID。 注意：此字段可能返回 null，表示取不到有效值。 :type SqlExecId: str :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.Threads = None self.SqlExecId = None self.RequestId = None def _deserialize(self, params): self.Threads = params.get("Threads") self.SqlExecId = params.get("SqlExecId") self.RequestId = params.get("RequestId") class MailConfiguration(AbstractModel): """邮件发送配置 """ def __init__(self): r""" :param SendMail: 是否开启邮件发送: 0, 否; 1, 是。 :type SendMail: int :param Region: 地域配置, 如["ap-guangzhou", "ap-shanghai"]。巡检的邮件发送模版，配置需要发送巡检邮件的地域；订阅的邮件发送模版，配置当前订阅实例的所属地域。 :type Region: list of str :param HealthStatus: 发送指定的健康等级的报告, 如["HEALTH", "SUB_HEALTH", "RISK", "HIGH_RISK"]。 :type HealthStatus: list of str :param ContactPerson: 联系人id, 联系人/联系组不能都为空。 :type ContactPerson: list of int :param ContactGroup: 联系组id, 联系人/联系组不能都为空。 :type ContactGroup: list of int """ self.SendMail = None self.Region = None self.HealthStatus = None self.ContactPerson = None self.ContactGroup = None def _deserialize(self, params): self.SendMail = params.get("SendMail") self.Region = params.get("Region") self.HealthStatus = params.get("HealthStatus") self.ContactPerson = params.get("ContactPerson") self.ContactGroup = params.get("ContactGroup") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class ModifyDiagDBInstanceConfRequest(AbstractModel): """ModifyDiagDBInstanceConf请求参数结构体 """ def __init__(self): r""" :param InstanceConfs: 实例配置，包括巡检、概览开关等。 :type InstanceConfs: :class:`tencentcloud.dbbrain.v20210527.models.InstanceConfs` :param Regions: 生效实例地域，取值为"All"，代表全地域。 :type Regions: str :param Product: 服务产品类型，支持值包括： "mysql" - 云数据库 MySQL， "cynosdb" - 云数据库 CynosDB for MySQL。 :type Product: str :param InstanceIds: 指定更改巡检状态的实例ID。 :type InstanceIds: list of str """ self.InstanceConfs = None self.Regions = None self.Product = None self.InstanceIds = None def _deserialize(self, params): if params.get("InstanceConfs") is not None: self.InstanceConfs = InstanceConfs() self.InstanceConfs._deserialize(params.get("InstanceConfs")) self.Regions = params.get("Regions") self.Product = params.get("Product") self.InstanceIds = params.get("InstanceIds") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class ModifyDiagDBInstanceConfResponse(AbstractModel): """ModifyDiagDBInstanceConf返回参数结构体 """ def __init__(self): r""" :param RequestId: 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。 :type RequestId: str """ self.RequestId = None def _deserialize(self, params): self.RequestId = params.get("RequestId") class MonitorFloatMetric(AbstractModel): """监控数据（浮点型） """ def __init__(self): r""" :param Metric: 指标名称。 :type Metric: str :param Unit: 指标单位。 :type Unit: str :param Values: 指标值。 注意：此字段可能返回 null，表示取不到有效值。 :type Values: list of float """ self.Metric = None self.Unit = None self.Values = None def _deserialize(self, params): self.Metric = params.get("Metric") self.Unit = params.get("Unit") self.Values = params.get("Values") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class MonitorFloatMetricSeriesData(AbstractModel): """单位时间间隔内的监控指标数据（浮点型） """ def __init__(self): r""" :param Series: 监控指标。 :type Series: list of MonitorFloatMetric :param Timestamp: 监控指标对应的时间戳。 :type Timestamp: list of int """ self.Series = None self.Timestamp = None def _deserialize(self, params): if params.get("Series") is not None: self.Series = [] for item in params.get("Series"): obj = MonitorFloatMetric() obj._deserialize(item) self.Series.append(obj) self.Timestamp = params.get("Timestamp") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class MonitorMetric(AbstractModel): """监控数据 """ def __init__(self): r""" :param Metric: 指标名称。 :type Metric: str :param Unit: 指标单位。 :type Unit: str :param Values: 指标值。 注意：此字段可能返回 null，表示取不到有效值。 :type Values: list of float """ self.Metric = None self.Unit = None self.Values = None def _deserialize(self, params): self.Metric = params.get("Metric") self.Unit = params.get("Unit") self.Values = params.get("Values") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class MonitorMetricSeriesData(AbstractModel): """单位时间间隔内的监控指标数据 """ def __init__(self): r""" :param Series: 监控指标。 :type Series: list of MonitorMetric :param Timestamp: 监控指标对应的时间戳。 :type Timestamp: list of int """ self.Series = None self.Timestamp = None def _deserialize(self, params): if params.get("Series") is not None: self.Series = [] for item in params.get("Series"): obj = MonitorMetric() obj._deserialize(item) self.Series.append(obj) self.Timestamp = params.get("Timestamp") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class MySqlProcess(AbstractModel): """关系型数据库线程 """ def __init__(self): r""" :param ID: 线程ID。 :type ID: str :param User: 线程的操作账号名。 :type User: str :param Host: 线程的操作主机地址。 :type Host: str :param DB: 线程的操作数据库。 :type DB: str :param State: 线程的操作状态。 :type State: str :param Command: 线程的执行类型。 :type Command: str :param Time: 线程的操作时长，单位秒。 :type Time: str :param Info: 线程的操作语句。 :type Info: str """ self.ID = None self.User = None self.Host = None self.DB = None self.State = None self.Command = None self.Time = None self.Info = None def _deserialize(self, params): self.ID = params.get("ID") self.User = params.get("User") self.Host = params.get("Host") self.DB = params.get("DB") self.State = params.get("State") self.Command = params.get("Command") self.Time = params.get("Time") self.Info = params.get("Info") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class ProfileInfo(AbstractModel): """用户配置的信息 """ def __init__(self): r""" :param Language: 语言, 如"zh"。 :type Language: str :param MailConfiguration: 邮件模板的内容。 :type MailConfiguration: :class:`tencentcloud.dbbrain.v20210527.models.MailConfiguration` """ self.Language = None self.MailConfiguration = None def _deserialize(self, params): self.Language = params.get("Language") if params.get("MailConfiguration") is not None: self.MailConfiguration = MailConfiguration() self.MailConfiguration._deserialize(params.get("MailConfiguration")) memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class SchemaItem(AbstractModel): """SchemaItem数组 """ def __init__(self): r""" :param Schema: 数据库名称 :type Schema: str """ self.Schema = None def _deserialize(self, params): self.Schema = params.get("Schema") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class SchemaSpaceData(AbstractModel): """库空间统计数据。 """ def __init__(self): r""" :param TableSchema: 库名。 :type TableSchema: str :param DataLength: 数据空间（MB）。 :type DataLength: float :param IndexLength: 索引空间（MB）。 :type IndexLength: float :param DataFree: 碎片空间（MB）。 :type DataFree: float :param TotalLength: 总使用空间（MB）。 :type TotalLength: float :param FragRatio: 碎片率（%）。 :type FragRatio: float :param TableRows: 行数。 :type TableRows: int :param PhysicalFileSize: 库中所有表对应的独立物理文件大小加和（MB）。 注意：此字段可能返回 null，表示取不到有效值。 :type PhysicalFileSize: float """ self.TableSchema = None self.DataLength = None self.IndexLength = None self.DataFree = None self.TotalLength = None self.FragRatio = None self.TableRows = None self.PhysicalFileSize = None def _deserialize(self, params): self.TableSchema = params.get("TableSchema") self.DataLength = params.get("DataLength") self.IndexLength = params.get("IndexLength") self.DataFree = params.get("DataFree") self.TotalLength = params.get("TotalLength") self.FragRatio = params.get("FragRatio") self.TableRows = params.get("TableRows") self.PhysicalFileSize = params.get("PhysicalFileSize") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class SchemaSpaceTimeSeries(AbstractModel): """库空间时序数据 """ def __init__(self): r""" :param TableSchema: 库名 :type TableSchema: str :param SeriesData: 单位时间间隔内的空间指标数据。 :type SeriesData: :class:`tencentcloud.dbbrain.v20210527.models.MonitorMetricSeriesData` """ self.TableSchema = None self.SeriesData = None def _deserialize(self, params): self.TableSchema = params.get("TableSchema") if params.get("SeriesData") is not None: self.SeriesData = MonitorMetricSeriesData() self.SeriesData._deserialize(params.get("SeriesData")) memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class ScoreDetail(AbstractModel): """扣分详情。 """ def __init__(self): r""" :param IssueType: 扣分项分类，取值包括：可用性、可维护性、性能及可靠性。 :type IssueType: str :param ScoreLost: 扣分总分。 :type ScoreLost: int :param ScoreLostMax: 扣分总分上限。 :type ScoreLostMax: int :param Items: 扣分项列表。 注意：此字段可能返回 null，表示取不到有效值。 :type Items: list of ScoreItem """ self.IssueType = None self.ScoreLost = None self.ScoreLostMax = None self.Items = None def _deserialize(self, params): self.IssueType = params.get("IssueType") self.ScoreLost = params.get("ScoreLost") self.ScoreLostMax = params.get("ScoreLostMax") if params.get("Items") is not None: self.Items = [] for item in params.get("Items"): obj = ScoreItem() obj._deserialize(item) self.Items.append(obj) memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class ScoreItem(AbstractModel): """诊断扣分项。 """ def __init__(self): r""" :param DiagItem: 异常诊断项名称。 :type DiagItem: str :param IssueType: 诊断项分类，取值包括：可用性、可维护性、性能及可靠性。 :type IssueType: str :param TopSeverity: 健康等级，取值包括：信息、提示、告警、严重、致命。 :type TopSeverity: str :param Count: 该异常诊断项出现次数。 :type Count: int :param ScoreLost: 扣分分数。 :type ScoreLost: int """ self.DiagItem = None self.IssueType = None self.TopSeverity = None self.Count = None self.ScoreLost = None def _deserialize(self, params): self.DiagItem = params.get("DiagItem") self.IssueType = params.get("IssueType") self.TopSeverity = params.get("TopSeverity") self.Count = params.get("Count") self.ScoreLost = params.get("ScoreLost") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class SecLogExportTaskInfo(AbstractModel): """安全审计日志导出任务信息 """ def __init__(self): r""" :param AsyncRequestId: 异步任务Id。 :type AsyncRequestId: int :param StartTime: 任务开始时间。 注意：此字段可能返回 null，表示取不到有效值。 :type StartTime: str :param EndTime: 任务结束时间。 注意：此字段可能返回 null，表示取不到有效值。 :type EndTime: str :param CreateTime: 任务创建时间。 :type CreateTime: str :param Status: 任务状态。 :type Status: str :param Progress: 任务执行进度。 :type Progress: int :param LogStartTime: 导出日志开始时间。 注意：此字段可能返回 null，表示取不到有效值。 :type LogStartTime: str :param LogEndTime: 导出日志结束时间。 注意：此字段可能返回 null，表示取不到有效值。 :type LogEndTime: str :param TotalSize: 日志文件总大小，单位KB。 注意：此字段可能返回 null，表示取不到有效值。 :type TotalSize: int :param DangerLevels: 风险等级列表。0 无风险；1 低风险；2 中风险；3 高风险。 注意：此字段可能返回 null，表示取不到有效值。 :type DangerLevels: list of int non-negative """ self.AsyncRequestId = None self.StartTime = None self.EndTime = None self.CreateTime = None self.Status = None self.Progress = None self.LogStartTime = None self.LogEndTime = None self.TotalSize = None self.DangerLevels = None def _deserialize(self, params): self.AsyncRequestId = params.get("AsyncRequestId") self.StartTime = params.get("StartTime") self.EndTime = params.get("EndTime") self.CreateTime = params.get("CreateTime") self.Status = params.get("Status") self.Progress = params.get("Progress") self.LogStartTime = params.get("LogStartTime") self.LogEndTime = params.get("LogEndTime") self.TotalSize = params.get("TotalSize") self.DangerLevels = params.get("DangerLevels") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class SlowLogHost(AbstractModel): """慢日志来源地址详情。 """ def __init__(self): r""" :param UserHost: 来源地址。 :type UserHost: str :param Ratio: 该来源地址的慢日志数目占总数目的比例，单位%。 :type Ratio: float :param Count: 该来源地址的慢日志数目。 :type Count: int """ self.UserHost = None self.Ratio = None self.Count = None def _deserialize(self, params): self.UserHost = params.get("UserHost") self.Ratio = params.get("Ratio") self.Count = params.get("Count") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class SlowLogTopSqlItem(AbstractModel): """慢日志TopSql """ def __init__(self): r""" :param LockTime: sql总锁等待时间，单位秒 :type LockTime: float :param LockTimeMax: 最大锁等待时间，单位秒 :type LockTimeMax: float :param LockTimeMin: 最小锁等待时间，单位秒 :type LockTimeMin: float :param RowsExamined: 总扫描行数 :type RowsExamined: int :param RowsExaminedMax: 最大扫描行数 :type RowsExaminedMax: int :param RowsExaminedMin: 最小扫描行数 :type RowsExaminedMin: int :param QueryTime: 总耗时，单位秒 :type QueryTime: float :param QueryTimeMax: 最大执行时间，单位秒 :type QueryTimeMax: float :param QueryTimeMin: 最小执行时间，单位秒 :type QueryTimeMin: float :param RowsSent: 总返回行数 :type RowsSent: int :param RowsSentMax: 最大返回行数 :type RowsSentMax: int :param RowsSentMin: 最小返回行数 :type RowsSentMin: int :param ExecTimes: 执行次数 :type ExecTimes: int :param SqlTemplate: sql模板 :type SqlTemplate: str :param SqlText: 带参数SQL（随机） :type SqlText: str :param Schema: 数据库名 :type Schema: str :param QueryTimeRatio: 总耗时占比，单位% :type QueryTimeRatio: float :param LockTimeRatio: sql总锁等待时间占比，单位% :type LockTimeRatio: float :param RowsExaminedRatio: 总扫描行数占比，单位% :type RowsExaminedRatio: float :param RowsSentRatio: 总返回行数占比，单位% :type RowsSentRatio: float :param QueryTimeAvg: 平均执行时间，单位秒 :type QueryTimeAvg: float :param RowsSentAvg: 平均返回行数 :type RowsSentAvg: float :param LockTimeAvg: 平均锁等待时间，单位秒 :type LockTimeAvg: float :param RowsExaminedAvg: 平均扫描行数 :type RowsExaminedAvg: float :param Md5: SOL模板的MD5值 :type Md5: str """ self.LockTime = None self.LockTimeMax = None self.LockTimeMin = None self.RowsExamined = None self.RowsExaminedMax = None self.RowsExaminedMin = None self.QueryTime = None self.QueryTimeMax = None self.QueryTimeMin = None self.RowsSent = None self.RowsSentMax = None self.RowsSentMin = None self.ExecTimes = None self.SqlTemplate = None self.SqlText = None self.Schema = None self.QueryTimeRatio = None self.LockTimeRatio = None self.RowsExaminedRatio = None self.RowsSentRatio = None self.QueryTimeAvg = None self.RowsSentAvg = None self.LockTimeAvg = None self.RowsExaminedAvg = None self.Md5 = None def _deserialize(self, params): self.LockTime = params.get("LockTime") self.LockTimeMax = params.get("LockTimeMax") self.LockTimeMin = params.get("LockTimeMin") self.RowsExamined = params.get("RowsExamined") self.RowsExaminedMax = params.get("RowsExaminedMax") self.RowsExaminedMin = params.get("RowsExaminedMin") self.QueryTime = params.get("QueryTime") self.QueryTimeMax = params.get("QueryTimeMax") self.QueryTimeMin = params.get("QueryTimeMin") self.RowsSent = params.get("RowsSent") self.RowsSentMax = params.get("RowsSentMax") self.RowsSentMin = params.get("RowsSentMin") self.ExecTimes = params.get("ExecTimes") self.SqlTemplate = params.get("SqlTemplate") self.SqlText = params.get("SqlText") self.Schema = params.get("Schema") self.QueryTimeRatio = params.get("QueryTimeRatio") self.LockTimeRatio = params.get("LockTimeRatio") self.RowsExaminedRatio = params.get("RowsExaminedRatio") self.RowsSentRatio = params.get("RowsSentRatio") self.QueryTimeAvg = params.get("QueryTimeAvg") self.RowsSentAvg = params.get("RowsSentAvg") self.LockTimeAvg = params.get("LockTimeAvg") self.RowsExaminedAvg = params.get("RowsExaminedAvg") self.Md5 = params.get("Md5") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class TableSpaceData(AbstractModel): """库表空间统计数据。 """ def __init__(self): r""" :param TableName: 表名。 :type TableName: str :param TableSchema: 库名。 :type TableSchema: str :param Engine: 库表的存储引擎。 :type Engine: str :param DataLength: 数据空间（MB）。 :type DataLength: float :param IndexLength: 索引空间（MB）。 :type IndexLength: float :param DataFree: 碎片空间（MB）。 :type DataFree: float :param TotalLength: 总使用空间（MB）。 :type TotalLength: float :param FragRatio: 碎片率（%）。 :type FragRatio: float :param TableRows: 行数。 :type TableRows: int :param PhysicalFileSize: 表对应的独立物理文件大小（MB）。 :type PhysicalFileSize: float """ self.TableName = None self.TableSchema = None self.Engine = None self.DataLength = None self.IndexLength = None self.DataFree = None self.TotalLength = None self.FragRatio = None self.TableRows = None self.PhysicalFileSize = None def _deserialize(self, params): self.TableName = params.get("TableName") self.TableSchema = params.get("TableSchema") self.Engine = params.get("Engine") self.DataLength = params.get("DataLength") self.IndexLength = params.get("IndexLength") self.DataFree = params.get("DataFree") self.TotalLength = params.get("TotalLength") self.FragRatio = params.get("FragRatio") self.TableRows = params.get("TableRows") self.PhysicalFileSize = params.get("PhysicalFileSize") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class TableSpaceTimeSeries(AbstractModel): """库表空间时序数据 """ def __init__(self): r""" :param TableName: 表名。 :type TableName: str :param TableSchema: 库名。 :type TableSchema: str :param Engine: 库表的存储引擎。 :type Engine: str :param SeriesData: 单位时间间隔内的空间指标数据。 :type SeriesData: :class:`tencentcloud.dbbrain.v20210527.models.MonitorFloatMetricSeriesData` """ self.TableName = None self.TableSchema = None self.Engine = None self.SeriesData = None def _deserialize(self, params): self.TableName = params.get("TableName") self.TableSchema = params.get("TableSchema") self.Engine = params.get("Engine") if params.get("SeriesData") is not None: self.SeriesData = MonitorFloatMetricSeriesData() self.SeriesData._deserialize(params.get("SeriesData")) memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class TimeSlice(AbstractModel): """单位时间间隔内的慢日志统计 """ def __init__(self): r""" :param Count: 总数 :type Count: int :param Timestamp: 统计开始时间 :type Timestamp: int """ self.Count = None self.Timestamp = None def _deserialize(self, params): self.Count = params.get("Count") self.Timestamp = params.get("Timestamp") memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set)) class UserProfile(AbstractModel): """用户配置的相关信息，包括邮件配置。 """ def __init__(self): r""" :param ProfileId: 配置的id。 注意：此字段可能返回 null，表示取不到有效值。 :type ProfileId: str :param ProfileType: 配置类型，支持值包括："dbScan_mail_configuration" - 数据库巡检邮件配置，"scheduler_mail_configuration" - 定期生成邮件配置。 注意：此字段可能返回 null，表示取不到有效值。 :type ProfileType: str :param ProfileLevel: 配置级别，支持值包括："User" - 用户级别，"Instance" - 实例级别，其中数据库巡检邮件配置为用户级别，定期生成邮件配置为实例级别。 注意：此字段可能返回 null，表示取不到有效值。 :type ProfileLevel: str :param ProfileName: 配置名称。 注意：此字段可能返回 null，表示取不到有效值。 :type ProfileName: str :param ProfileInfo: 配置详情。 :type ProfileInfo: :class:`tencentcloud.dbbrain.v20210527.models.ProfileInfo` """ self.ProfileId = None self.ProfileType = None self.ProfileLevel = None self.ProfileName = None self.ProfileInfo = None def _deserialize(self, params): self.ProfileId = params.get("ProfileId") self.ProfileType = params.get("ProfileType") self.ProfileLevel = params.get("ProfileLevel") self.ProfileName = params.get("ProfileName") if params.get("ProfileInfo") is not None: self.ProfileInfo = ProfileInfo() self.ProfileInfo._deserialize(params.get("ProfileInfo")) memeber_set = set(params.keys()) for name, value in vars(self).items(): if name in memeber_set: memeber_set.remove(name) if len(memeber_set) > 0: warnings.warn("%s fileds are useless." % ",".join(memeber_set))

6a7fd9c2a4520acac2ad0d4b073014e3ffeaa218

py

Python

oauth/provider.py

giuseppe/quay

a1b7e4b51974edfe86f66788621011eef2667e6a

2019-11-12T18:05:48.000Z

2022-03-31T22:25:04.000Z

oauth/provider.py

giuseppe/quay

a1b7e4b51974edfe86f66788621011eef2667e6a

2019-11-12T18:13:37.000Z

2022-03-31T10:43:45.000Z

oauth/provider.py

giuseppe/quay

a1b7e4b51974edfe86f66788621011eef2667e6a

2019-11-12T18:02:27.000Z

2022-03-22T12:19:19.000Z

# Ported to Python 3 # Originally from https://github.com/DeprecatedCode/oauth2lib/blob/d161b010f8a596826050a09e5e94d59443cc12d9/oauth2lib/provider.py import json import logging from requests import Response from io import StringIO try: from werkzeug.exceptions import Unauthorized except ImportError: Unauthorized = Exception from oauth import utils class Provider(object): """Base provider class for different types of OAuth 2.0 providers.""" def _handle_exception(self, exc): """Handle an internal exception that was caught and suppressed. :param exc: Exception to process. :type exc: Exception """ logger = logging.getLogger(__name__) logger.exception(exc) def _make_response(self, body="", headers=None, status_code=200): """Return a response object from the given parameters. :param body: Buffer/string containing the response body. :type body: str :param headers: Dict of headers to include in the requests. :type headers: dict :param status_code: HTTP status code. :type status_code: int :rtype: requests.Response """ res = Response() res.status_code = status_code if headers is not None: res.headers.update(headers) res.raw = StringIO(body) return res def _make_redirect_error_response(self, redirect_uri, err): """Return a HTTP 302 redirect response object containing the error. :param redirect_uri: Client redirect URI. :type redirect_uri: str :param err: OAuth error message. :type err: str :rtype: requests.Response """ params = {"error": err, "response_type": None, "client_id": None, "redirect_uri": None} redirect = utils.build_url(redirect_uri, params) return self._make_response(headers={"Location": redirect}, status_code=302) def _make_json_response(self, data, headers=None, status_code=200): """Return a response object from the given JSON data. :param data: Data to JSON-encode. :type data: mixed :param headers: Dict of headers to include in the requests. :type headers: dict :param status_code: HTTP status code. :type status_code: int :rtype: requests.Response """ response_headers = {} if headers is not None: response_headers.update(headers) response_headers["Content-Type"] = "application/json;charset=UTF-8" response_headers["Cache-Control"] = "no-store" response_headers["Pragma"] = "no-cache" return self._make_response(json.dumps(data), response_headers, status_code) def _make_json_error_response(self, err): """Return a JSON-encoded response object representing the error. :param err: OAuth error message. :type err: str :rtype: requests.Response """ return self._make_json_response({"error": err}, status_code=400) def _invalid_redirect_uri_response(self): """What to return when the redirect_uri parameter is missing. :rtype: requests.Response """ return self._make_json_error_response("invalid_request") class AuthorizationProvider(Provider): """OAuth 2.0 authorization provider. This class manages authorization codes and access tokens. Certain methods MUST be overridden in a subclass, thus this class cannot be directly used as a provider. These are the methods that must be implemented in a subclass: validate_client_id(self, client_id) # Return True or False validate_client_secret(self, client_id, client_secret) # Return True or False validate_scope(self, client_id, scope) # Return True or False validate_redirect_uri(self, client_id, redirect_uri) # Return True or False validate_access(self) # Use this to validate your app session user # Return True or False from_authorization_code(self, client_id, code, scope) # Return mixed data or None on invalid from_refresh_token(self, client_id, refresh_token, scope) # Return mixed data or None on invalid persist_authorization_code(self, client_id, code, scope) # Return value ignored persist_token_information(self, client_id, scope, access_token, token_type, expires_in, refresh_token, data) # Return value ignored discard_authorization_code(self, client_id, code) # Return value ignored discard_refresh_token(self, client_id, refresh_token) # Return value ignored Optionally, the following may be overridden to acheive desired behavior: @property token_length(self) @property token_type(self) @property token_expires_in(self) generate_authorization_code(self) generate_access_token(self) generate_refresh_token(self) """ @property def token_length(self): """Property method to get the length used to generate tokens. :rtype: int """ return 40 @property def token_type(self): """Property method to get the access token type. :rtype: str """ return "Bearer" @property def token_expires_in(self): """Property method to get the token expiration time in seconds. :rtype: int """ return 3600 def generate_authorization_code(self): """Generate a random authorization code. :rtype: str """ return utils.random_ascii_string(self.token_length) def generate_access_token(self): """Generate a random access token. :rtype: str """ return utils.random_ascii_string(self.token_length) def generate_refresh_token(self): """Generate a random refresh token. :rtype: str """ return utils.random_ascii_string(self.token_length) def get_authorization_code(self, response_type, client_id, redirect_uri, **params): """Generate authorization code HTTP response. :param response_type: Desired response type. Must be exactly "code". :type response_type: str :param client_id: Client ID. :type client_id: str :param redirect_uri: Client redirect URI. :type redirect_uri: str :rtype: requests.Response """ # Ensure proper response_type if response_type != "code": err = "unsupported_response_type" return self._make_redirect_error_response(redirect_uri, err) # Check redirect URI is_valid_redirect_uri = self.validate_redirect_uri(client_id, redirect_uri) if not is_valid_redirect_uri: return self._invalid_redirect_uri_response() # Check conditions is_valid_client_id = self.validate_client_id(client_id) is_valid_access = self.validate_access() scope = params.get("scope", "") is_valid_scope = self.validate_scope(client_id, scope) # Return proper error responses on invalid conditions if not is_valid_client_id: err = "unauthorized_client" return self._make_redirect_error_response(redirect_uri, err) if not is_valid_access: err = "access_denied" return self._make_redirect_error_response(redirect_uri, err) if not is_valid_scope: err = "invalid_scope" return self._make_redirect_error_response(redirect_uri, err) # Generate authorization code code = self.generate_authorization_code() # Save information to be used to validate later requests self.persist_authorization_code(client_id=client_id, code=code, scope=scope) # Return redirection response params.update( {"code": code, "response_type": None, "client_id": None, "redirect_uri": None} ) redirect = utils.build_url(redirect_uri, params) return self._make_response(headers={"Location": redirect}, status_code=302) def refresh_token(self, grant_type, client_id, client_secret, refresh_token, **params): """Generate access token HTTP response from a refresh token. :param grant_type: Desired grant type. Must be "refresh_token". :type grant_type: str :param client_id: Client ID. :type client_id: str :param client_secret: Client secret. :type client_secret: str :param refresh_token: Refresh token. :type refresh_token: str :rtype: requests.Response """ # Ensure proper grant_type if grant_type != "refresh_token": return self._make_json_error_response("unsupported_grant_type") # Check conditions is_valid_client_id = self.validate_client_id(client_id) is_valid_client_secret = self.validate_client_secret(client_id, client_secret) scope = params.get("scope", "") is_valid_scope = self.validate_scope(client_id, scope) data = self.from_refresh_token(client_id, refresh_token, scope) is_valid_refresh_token = data is not None # Return proper error responses on invalid conditions if not (is_valid_client_id and is_valid_client_secret): return self._make_json_error_response("invalid_client") if not is_valid_scope: return self._make_json_error_response("invalid_scope") if not is_valid_refresh_token: return self._make_json_error_response("invalid_grant") # Discard original refresh token self.discard_refresh_token(client_id, refresh_token) # Generate access tokens once all conditions have been met access_token = self.generate_access_token() token_type = self.token_type expires_in = self.token_expires_in refresh_token = self.generate_refresh_token() # Save information to be used to validate later requests self.persist_token_information( client_id=client_id, scope=scope, access_token=access_token, token_type=token_type, expires_in=expires_in, refresh_token=refresh_token, data=data, ) # Return json response return self._make_json_response( { "access_token": access_token, "token_type": token_type, "expires_in": expires_in, "refresh_token": refresh_token, } ) def get_token(self, grant_type, client_id, client_secret, redirect_uri, code, **params): """Generate access token HTTP response. :param grant_type: Desired grant type. Must be "authorization_code". :type grant_type: str :param client_id: Client ID. :type client_id: str :param client_secret: Client secret. :type client_secret: str :param redirect_uri: Client redirect URI. :type redirect_uri: str :param code: Authorization code. :type code: str :rtype: requests.Response """ # Ensure proper grant_type if grant_type != "authorization_code": return self._make_json_error_response("unsupported_grant_type") # Check conditions is_valid_client_id = self.validate_client_id(client_id) is_valid_client_secret = self.validate_client_secret(client_id, client_secret) is_valid_redirect_uri = self.validate_redirect_uri(client_id, redirect_uri) scope = params.get("scope", "") is_valid_scope = self.validate_scope(client_id, scope) data = self.from_authorization_code(client_id, code, scope) is_valid_grant = data is not None # Return proper error responses on invalid conditions if not (is_valid_client_id and is_valid_client_secret): return self._make_json_error_response("invalid_client") if not is_valid_grant or not is_valid_redirect_uri: return self._make_json_error_response("invalid_grant") if not is_valid_scope: return self._make_json_error_response("invalid_scope") # Discard original authorization code self.discard_authorization_code(client_id, code) # Generate access tokens once all conditions have been met access_token = self.generate_access_token() token_type = self.token_type expires_in = self.token_expires_in refresh_token = self.generate_refresh_token() # Save information to be used to validate later requests self.persist_token_information( client_id=client_id, scope=scope, access_token=access_token, token_type=token_type, expires_in=expires_in, refresh_token=refresh_token, data=data, ) # Return json response return self._make_json_response( { "access_token": access_token, "token_type": token_type, "expires_in": expires_in, "refresh_token": refresh_token, } ) def get_authorization_code_from_uri(self, uri): """Get authorization code response from a URI. This method will ignore the domain and path of the request, instead automatically parsing the query string parameters. :param uri: URI to parse for authorization information. :type uri: str :rtype: requests.Response """ params = utils.url_query_params(uri) try: if "response_type" not in params: raise TypeError("Missing parameter response_type in URL query") if "client_id" not in params: raise TypeError("Missing parameter client_id in URL query") if "redirect_uri" not in params: raise TypeError("Missing parameter redirect_uri in URL query") return self.get_authorization_code(**params) except TypeError as exc: self._handle_exception(exc) # Catch missing parameters in request err = "invalid_request" if "redirect_uri" in params: u = params["redirect_uri"] return self._make_redirect_error_response(u, err) else: return self._invalid_redirect_uri_response() except StandardError as exc: self._handle_exception(exc) # Catch all other server errors err = "server_error" u = params["redirect_uri"] return self._make_redirect_error_response(u, err) def get_token_from_post_data(self, data): """Get a token response from POST data. :param data: POST data containing authorization information. :type data: dict :rtype: requests.Response """ try: # Verify OAuth 2.0 Parameters for x in ["grant_type", "client_id", "client_secret"]: if not data.get(x): raise TypeError("Missing required OAuth 2.0 POST param: {0}".format(x)) # Handle get token from refresh_token if "refresh_token" in data: return self.refresh_token(**data) # Handle get token from authorization code for x in ["redirect_uri", "code"]: if not data.get(x): raise TypeError("Missing required OAuth 2.0 POST param: {0}".format(x)) return self.get_token(**data) except TypeError as exc: self._handle_exception(exc) # Catch missing parameters in request return self._make_json_error_response("invalid_request") except StandardError as exc: self._handle_exception(exc) # Catch all other server errors return self._make_json_error_response("server_error") def validate_client_id(self, client_id): raise NotImplementedError("Subclasses must implement " "validate_client_id.") def validate_client_secret(self, client_id, client_secret): raise NotImplementedError("Subclasses must implement " "validate_client_secret.") def validate_redirect_uri(self, client_id, redirect_uri): raise NotImplementedError("Subclasses must implement " "validate_redirect_uri.") def validate_scope(self, client_id, scope): raise NotImplementedError("Subclasses must implement " "validate_scope.") def validate_access(self): raise NotImplementedError("Subclasses must implement " "validate_access.") def from_authorization_code(self, client_id, code, scope): raise NotImplementedError("Subclasses must implement " "from_authorization_code.") def from_refresh_token(self, client_id, refresh_token, scope): raise NotImplementedError("Subclasses must implement " "from_refresh_token.") def persist_authorization_code(self, client_id, code, scope): raise NotImplementedError("Subclasses must implement " "persist_authorization_code.") def persist_token_information( self, client_id, scope, access_token, token_type, expires_in, refresh_token, data ): raise NotImplementedError("Subclasses must implement " "persist_token_information.") def discard_authorization_code(self, client_id, code): raise NotImplementedError("Subclasses must implement " "discard_authorization_code.") def discard_refresh_token(self, client_id, refresh_token): raise NotImplementedError("Subclasses must implement " "discard_refresh_token.") class OAuthError(Unauthorized): """OAuth error, including the OAuth error reason.""" def __init__(self, reason, *args, **kwargs): self.reason = reason super(OAuthError, self).__init__(*args, **kwargs) class ResourceAuthorization(object): """A class containing an OAuth 2.0 authorization.""" is_oauth = False is_valid = None token = None client_id = None expires_in = None error = None def raise_error_if_invalid(self): if not self.is_valid: raise OAuthError(self.error, "OAuth authorization error") class ResourceProvider(Provider): """OAuth 2.0 resource provider. This class provides an interface to validate an incoming request and authenticate resource access. Certain methods MUST be overridden in a subclass, thus this class cannot be directly used as a resource provider. These are the methods that must be implemented in a subclass: get_authorization_header(self) # Return header string for key "Authorization" or None validate_access_token(self, access_token, authorization) # Set is_valid=True, client_id, and expires_in attributes # on authorization if authorization was successful. # Return value is ignored """ @property def authorization_class(self): return ResourceAuthorization def get_authorization(self): """Get authorization object representing status of authentication.""" auth = self.authorization_class() header = self.get_authorization_header() if not header or not header.split: return auth header = header.split() if len(header) > 1 and header[0] == "Bearer": auth.is_oauth = True access_token = header[1] self.validate_access_token(access_token, auth) if not auth.is_valid: auth.error = "access_denied" return auth def get_authorization_header(self): raise NotImplementedError("Subclasses must implement " "get_authorization_header.") def validate_access_token(self, access_token, authorization): raise NotImplementedError("Subclasses must implement " "validate_token.")

6a811562ddff805b40048018c138048e412a8c98

py

Python

main.py

TomHacker/ImageCluster

c4262e08a61c50b6d850ba29bc4d56d21c789aa9

2019-04-08T06:46:35.000Z

2019-10-31T11:10:32.000Z

main.py

HandsomeBrotherShuaiLi/ImageCluster

c4262e08a61c50b6d850ba29bc4d56d21c789aa9

2020-06-02T01:24:18.000Z

2021-05-20T04:53:26.000Z

main.py

HandsomeBrotherShuaiLi/ImageCluster

c4262e08a61c50b6d850ba29bc4d56d21c789aa9

2019-05-23T11:08:04.000Z

2019-05-23T11:08:04.000Z

from model import ImageCluster m=ImageCluster( base_model='vgg16',#your feature map extractor model resorted_img_folder='resorted_data',#the folder for clustered images cluster_algo='kmeans',#cluster algorithm base_img_folder='data', maxK=150,#the max k num is 30, which means ImageCluster calculates every k in range(2,30+1) ) # calculate the feature maps # m.get_feature_map( # resize_shape=(224,224) # (w,h) a tuple for resizing the input images to the same shape # ) # #clustering for feature maps # m.imagecluster() #As we can see, 21 may be the best cluster number for this dataset. #So,we can call the resorted_img function to label the images under different folders m.resorted_img( selected_k_num=100# a int number in range[2,maxK] )

6a8199a221f44d9fef4df3ccc6d623b0243a377c

py

Python

tests/dummies.py

arvindmuralie77/gradsflow

d6ec5bc517dcf714cd4ecb91a7f702dce6bded3f

2021-08-17T17:42:25.000Z

2022-03-25T07:59:41.000Z

tests/dummies.py

arvindmuralie77/gradsflow

d6ec5bc517dcf714cd4ecb91a7f702dce6bded3f

2021-08-17T16:28:08.000Z

2022-03-27T02:36:45.000Z

tests/dummies.py

arvindmuralie77/gradsflow

d6ec5bc517dcf714cd4ecb91a7f702dce6bded3f

2021-08-23T16:26:15.000Z

2022-03-26T17:08:15.000Z

# Copyright (c) 2021 GradsFlow. 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. import torch from gradsflow.models import Model class DummyModel(Model): def __init__(self): learner = torch.nn.Linear(1, 4) super().__init__(learner) def backward(self, loss: torch.Tensor): return None def train_step(self, batch): return {"loss": torch.as_tensor(1), "metrics": {"accuracy": 1}} def val_step(self, batch): return {"loss": torch.as_tensor(1), "metrics": {"accuracy": 1}}

6a82018dc0f7662911572e4ff805c96d468e9254

py

Python

JumpscaleCore/tools/executor/ExecutorSerial.py

gneumann333/jumpscaleX_core

777d249fa3668c6e802c2f765f4b82fb39c3e5fa

2020-06-21T11:18:52.000Z

2020-06-21T11:18:52.000Z

JumpscaleCore/tools/executor/ExecutorSerial.py

gneumann333/jumpscaleX_core

777d249fa3668c6e802c2f765f4b82fb39c3e5fa

2019-08-25T10:19:56.000Z

2020-12-23T09:41:04.000Z

JumpscaleCore/tools/executor/ExecutorSerial.py

gneumann333/jumpscaleX_core

777d249fa3668c6e802c2f765f4b82fb39c3e5fa

2019-08-29T21:38:50.000Z

2020-06-21T11:18:55.000Z

from Jumpscale import j JSBASE = j.baseclasses.object from .ExecutorBase import * import serial class ExecutorSerial(ExecutorBase): """ This executor is primary made to communicate with devices (routers, switch, ...) over console cable but you can use underlaying method to communicate with any serial device. Please note that default mode attempt to recognize a device with cisco like commands. """ def __init__(self, device, baudrate=9600, type="serial", parity="N", stopbits=1, bytesize=8, timeout=1): ExecutorBase.__init__(self, checkok=False) self.device = device self.baudrate = baudrate self.type = type self.parity = parity self.stopbits = stopbits self.bytesize = bytesize self.timeout = timeout self._id = None self._log_info("Initialized") self.reconnect() self.fetch() def reconnect(self): self.console = serial.Serial( port=self.device, baudrate=self.baudrate, parity=self.parity, stopbits=self.stopbits, bytesize=self.bytesize, timeout=self.timeout, ) return True @property def id(self): if self._id is None: self._id = "serial.%s" % (self.device) return self._id def execute(self, cmds, die=True, checkok=None, showout=True, timeout=0, env={}): self._log_debug("Serial command: %s" % cmds) if not cmds.endswith("\n"): cmds += "\n" self.send(cmds) return 0, "", "" def send(self, data): self.console.write(data.encode("utf-8")) def fetch(self): input = self.console.read_all() return input.decode("utf-8") def enter(self, command): self.send(command) self.send("\n") def _execute_script(self, content="", die=True, showout=True, checkok=None): raise j.exceptions.NotImplemented() def upload(self, source, dest, dest_prefix="", recursive=True, createdir=True): raise j.exceptions.NotImplemented() def download(self, source, dest, source_prefix="", recursive=True): raise j.exceptions.NotImplemented() def __repr__(self): return "Executor serial: %s" % (self.device) __str__ = __repr__

6a836399736ccfbfdcec602215566bd6e9ae598c

py

Python

melisa/utils/snowflake.py

MelisaDev/melisa

53fee10d8c1bf4dd716bc90096c16f096e11bfbf

2022-03-11T19:51:28.000Z

2022-03-13T16:28:58.000Z

melisa/utils/snowflake.py

jungledev1/melisa

835e4b644e50b5038599ecbd1bfa510a0d3200e9

2022-03-19T18:09:39.000Z

2022-03-23T12:18:49.000Z

melisa/utils/snowflake.py

jungledev1/melisa

835e4b644e50b5038599ecbd1bfa510a0d3200e9

2022-03-23T07:30:04.000Z

2022-03-23T07:30:04.000Z

# Copyright MelisaDev 2022 - Present # Full MIT License can be found in `LICENSE.txt` at the project root. from __future__ import annotations class Snowflake(int): """ Discord utilizes Twitter's snowflake format for uniquely identifiable descriptors (IDs). These IDs are guaranteed to be unique across all of Discord, except in some unique scenarios in which child objects share their parent's ID. Because Snowflake IDs are up to 64 bits in size (e.g. a uint64), they are always returned as strings in the HTTP API to prevent integer overflows in some languages. See Gateway ETF/JSON for more information regarding Gateway encoding. Read more here: https://discord.com/developers/docs/reference#snowflakes """ _MAX_VALUE: int = 9223372036854775807 _MIN_VALUE: int = 0 def __init__(self, _): super().__init__() if self < self._MIN_VALUE: raise ValueError("snowflake value should be greater than or equal to 0.") if self > self._MAX_VALUE: raise ValueError( "snowflake value should be less than or equal to 9223372036854775807." ) @classmethod def __factory__(cls, string: str) -> Snowflake: return cls.from_string(string) @classmethod def from_string(cls, string: str): """Initialize a new Snowflake from a string. Parameters ---------- string: :class:`str` The snowflake as a string. """ return Snowflake(int(string)) @property def timestamp(self) -> int: """ Milliseconds since Discord Epoch, the first second of 2015 or 1420070400000. """ return self >> 22 @property def worker_id(self) -> int: """Internal worker ID""" return (self >> 17) % 16 @property def process_id(self) -> int: """Internal process ID""" return (self >> 12) % 16 @property def increment(self) -> int: """For every ID that is generated on that process, this number is incremented""" return self % 2048 @property def unix(self) -> int: return self.timestamp + 1420070400000

6a83ea727e6668f4f022e77a641fbd9d212a22e3

py

Python

feed/serializers/extensions.py

cul-it/arxiv-rss

40c0e859528119cc8ba3700312cb8df095d95cdd

2020-06-29T15:05:37.000Z

2022-02-02T10:28:28.000Z

feed/serializers/extensions.py

arXiv/arxiv-feed

82923d062e2524df94c22490cf936a988559ce66

2020-03-06T16:45:00.000Z

2022-03-02T15:36:14.000Z

feed/serializers/extensions.py

cul-it/arxiv-rss

40c0e859528119cc8ba3700312cb8df095d95cdd

2020-12-06T16:30:06.000Z

2021-11-05T12:29:08.000Z

"""Classes derived from the Feedgen extension classes.""" from typing import Dict, List, Optional from lxml import etree from lxml.etree import Element from flask import current_app from feedgen.ext.base import BaseEntryExtension, BaseExtension from feed.domain import Author, Media class ArxivExtension(BaseExtension): """Extension of the Feedgen class to allow us to change its behavior.""" def extend_atom(self: BaseExtension, atom_feed: Element) -> Element: """Allow the extension to modify the initial feed tree for Atom. Parameters ---------- atom_feed : Element The feed's root element. Returns ------- atom_feed : Element The feed's root element. """ return atom_feed def extend_rss(self: BaseExtension, rss_feed: Element) -> Element: """Allow the extension to modify the initial feed tree for RSS. Parameters ---------- rss_feed : Element The feed's root element. Returns ------- rss_feed : Element The feed's root element. """ return rss_feed def extend_ns(self: BaseExtension) -> Dict[str, str]: """ Define the feed's namespaces. Returns ------- namespaces : Dict[str, str] Definitions of the "arxiv" namespaces. """ return { "arxiv": "http://arxiv.org/schemas/atom", "content": "http://purl.org/rss/1.0/modules/content/", "taxo": "http://purl.org/rss/1.0/modules/taxonomy/", "syn": "http://purl.org/rss/1.0/modules/syndication/", "admin": "http://webns.net/mvcb/", "media": "http://search.yahoo.com/mrss", } class ArxivAtomExtension(BaseEntryExtension): """Atom only extension.""" def extend_ns(self: BaseExtension) -> Dict[str, str]: """ Define the feed's namespaces. Returns ------- namespaces : Dict[str, str] Definitions of the "arxiv" namespaces. """ return { "arxiv": "http://arxiv.org/schemas/atom", } class ArxivEntryExtension(BaseEntryExtension): """Extension of the Entry class to allow us to change its behavior.""" def __init__(self: BaseEntryExtension): """Initialize the member values to all be empty.""" self.__arxiv_authors: List[Author] = [] self.__arxiv_media: List[Media] = [] self.__arxiv_comment: Optional[str] = None self.__arxiv_primary_category: Optional[str] = None self.__arxiv_doi: Optional[dict] = None self.__arxiv_affiliation: Optional[str] = None self.__arxiv_journal_ref: Optional[str] = None self.__arxiv_affiliations: Dict = {} def __add_media(self, entry: Element) -> None: for media in self.__arxiv_media: group = etree.SubElement( entry, "{http://search.yahoo.com/mrss}group" ) title = etree.SubElement( group, "{http://search.yahoo.com/mrss}title" ) title.text = media.title etree.SubElement( group, "{http://search.yahoo.com/mrss}content", attrib={"url": media.url, "type": media.type}, ) def extend_atom(self, entry: Element) -> Element: """ Allow the extension to modify the entry element for Atom serialization. Parameters ---------- entry : Element The FeedEntry to modify. Returns ------- entry : Element The modified entry. """ if self.__arxiv_comment: comment_element = etree.SubElement( entry, "{http://arxiv.org/schemas/atom}comment" ) comment_element.text = self.__arxiv_comment if self.__arxiv_primary_category: etree.SubElement( entry, "{http://arxiv.org/schemas/atom}primary_category", attrib=self.__arxiv_primary_category, ) if self.__arxiv_journal_ref: journal_ref_element = etree.SubElement( entry, "{http://arxiv.org/schemas/atom}journal_ref" ) journal_ref_element.text = self.__arxiv_journal_ref if self.__arxiv_doi: for doi in self.__arxiv_doi: doi_element = etree.SubElement( entry, "{http://arxiv.org/schemas/atom}doi" ) doi_element.text = doi # Check each of the entry's author nodes for entry_child in entry: if entry_child.tag == "author": author = entry_child for author_child in author: # If the author's name is in the affiliation dictionary, # add Elements for all of its affiliations. if author_child.tag == "name": name = author_child.text affiliations = self.__arxiv_affiliations.get(name, []) for affiliation in affiliations: element = etree.SubElement( author, "{http://arxiv.org/schemas/atom}affiliation", ) element.text = affiliation self.__add_media(entry=entry) return entry def extend_rss(self, entry: Element) -> Element: """Allow the extension to modify the entry element for RSS. Parameters ---------- entry : Element The FeedEntry to modify. Returns ------- entry : Element The modified entry. """ base_server: str = current_app.config["BASE_SERVER"] for entry_child in entry: if entry_child.tag == "description": description = "<p>Authors: " first = True for author in self.__arxiv_authors: if first: first = False else: description += ", " name = ( f"{author.last_name}," f"+{author.initials.replace(' ', '+')}" ) description += ( f'<a href="http://{base_server}/search/?query={name}&' f'searchtype=author">{author.full_name}</a>' ) description += f"</p><p>{entry_child.text}</p>" entry_child.text = description self.__add_media(entry=entry) return entry def author(self, author: Author) -> None: """Add an author value to this entry. Parameters ---------- author : Author Paper author. """ self.__arxiv_authors.append(author) def media(self, media: Media) -> None: """Add a media item. Parameters ---------- media: Dict[str, str] Dictionary with url and type attributes. """ self.__arxiv_media.append(media) def comment(self, text: str) -> None: """Assign the comment value to this entry. Parameters ---------- text : str The new comment text. """ self.__arxiv_comment = text def primary_category(self, text: str) -> None: """Assign the primary_category value to this entry. Parameters ---------- text : str The new primary_category name. """ self.__arxiv_primary_category = text def journal_ref(self, text: str) -> None: """Assign the journal_ref value to this entry. Parameters ---------- text : str The new journal_ref value. """ self.__arxiv_journal_ref = text def doi(self, doi_list: Dict[str, str]) -> None: """Assign the set of DOI definitions for this entry. Parameters ---------- doi_list : Dict[str, str] A dictionary of DOI assignments. """ self.__arxiv_doi = doi_list def affiliation(self, full_name: str, affiliations: List[str]) -> None: """Assign an affiliation for one author of this entry. Parameters ---------- full_name : str An author's full name. affiliations : List[str] The code for the author's affiliated institution. """ self.__arxiv_affiliations[full_name] = affiliations

6a849b7bcd124ad715f2ce345cebb1f79d3397f0

py

Python

discovery-infra/test_infra/helper_classes/config/controller_config.py

lranjbar/assisted-test-infra

89cd4e16744afa646af88975f8038ca1774bcfa4

discovery-infra/test_infra/helper_classes/config/controller_config.py

lranjbar/assisted-test-infra

89cd4e16744afa646af88975f8038ca1774bcfa4

2021-11-15T07:10:49.000Z

2022-03-28T07:10:26.000Z

discovery-infra/test_infra/helper_classes/config/controller_config.py

lranjbar/assisted-test-infra

89cd4e16744afa646af88975f8038ca1774bcfa4

from abc import ABC from pathlib import Path from typing import Any from dataclasses import dataclass from test_infra import consts from test_infra.utils.global_variables import GlobalVariables from .base_config import _BaseConfig global_variables = GlobalVariables() @dataclass class BaseNodeConfig(_BaseConfig, ABC): platform: str = None is_ipv6: bool = None bootstrap_in_place: bool = None private_ssh_key_path: Path = None working_dir: str = consts.WORKING_DIR master_memory: int = None master_vcpu: int = None masters_count: int = None nodes_count: int = None master_cpu_mode: str = None master_disk: int = None # disk size in MB. master_disk_size_gib: str = None # disk size in GB. master_disk_count: int = None # number of disks to create worker_memory: int = None worker_vcpu: int = None workers_count: int = None worker_cpu_mode: str = None worker_disk: int = None worker_disk_count: int = None network_mtu: int = None @staticmethod def get_default(key, default=None) -> Any: return getattr(global_variables, key)

6a84b5159878bc48cef9594078edc989fb798f13

py

Python

bitcoinpy/mempool.py

obulpathi/bitcoinpy

8f41e0221f2ff2d35697b6d4e5397deb7de09c3d

2016-01-03T14:52:07.000Z

2021-08-09T18:05:08.000Z

bitcoinpy/mempool.py

obulpathi/bitcoinpy

8f41e0221f2ff2d35697b6d4e5397deb7de09c3d

bitcoinpy/mempool.py

obulpathi/bitcoinpy

8f41e0221f2ff2d35697b6d4e5397deb7de09c3d

2015-02-07T20:08:11.000Z

2019-10-03T04:45:45.000Z

# MemPool.py # # Distributed under the MIT/X11 software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. import logging from lib.serialize import uint256_to_shortstr class MemPool(object): def __init__(self): self.pool = {} # setup logging logging.basicConfig(level=logging.DEBUG) self.logger = logging.getLogger(__name__) def add(self, tx): tx.calc_sha256() hash = tx.sha256 hashstr = uint256_to_shortstr(hash) if hash in self.pool: self.log.write("MemPool.add(%s): already known" % (hashstr,)) return False if not tx.is_valid(): self.log.write("MemPool.add(%s): invalid TX" % (hashstr, )) return False self.pool[hash] = tx self.log.write("MemPool.add(%s), poolsz %d" % (hashstr, len(self.pool))) return True def remove(self, hash): if hash not in self.pool: return False del self.pool[hash] return True def size(self): return len(self.pool)

6a84b6d6b4154a68e4e0a9485928b636bf10d1b0

py

Python

bashspy/parser.py

sarvi/bashspy

088f2cdfd00d29b4c7a98ec311f6e6c382ba4749

bashspy/parser.py

sarvi/bashspy

088f2cdfd00d29b4c7a98ec311f6e6c382ba4749

2021-06-12T12:47:44.000Z

2021-06-12T12:47:44.000Z

bashspy/parser.py

sarvi/bashspy

088f2cdfd00d29b4c7a98ec311f6e6c382ba4749

2020-05-18T08:55:14.000Z

2020-05-18T08:55:14.000Z

''' Created on Jun 13, 2019 @author: sarvi ''' from sly import Parser from .lexer import BashLexer class ASTCommands(list): __slots__ = ('grouping') def __init__(self, command, grouping=None): self.append(command) self.grouping = grouping def __repr__(self): x=[str(i) for i in self] if self.grouping: x.insert(0, self.grouping[0]) x.append(self.grouping[1]) return '\n'.join(x) class ASTCommand: __slots__ = ('assignments', 'executable', 'arguments', 'redirections', 'pipetocmd') def __init__(self, executable=None, assignments=None, arguments=None, redirections=None, pipetocmd=None): self.executable = executable self.assignments = assignments or list() self.arguments = arguments or list() self.redirections = redirections or list() self.pipetocmd = pipetocmd def __repr__(self): if self.executable: return ('%s %s %s %s %s' % (' '.join([str(i) for i in self.assignments]), self.executable, ' '.join([str(i) for i in self.arguments]), ' '.join([str(i) for i in self.redirections]), '| %s'%self.pipetocmd if self.pipetocmd else '')).strip() else: return ' '.join([str(i) for i in self.assignments]) class ASTAssignment: __slots__ = ('variable', 'assignop', 'value') def __init__(self, variable, assignop, value=None): self.variable = variable self.assignop = assignop self.value = value def __repr__(self): return '%s%s%s'%(self.variable, self.assignop, self.value or '') class ASTArgument: __slots__ = ('option', 'value') def __init__(self, option=None, value=None): self.option = option self.value = value def __repr__(self): return '%s=%s'%(self.option, self.value) if self.option and self.value else (self.option or self.value) class ASTRedirection: __slots__ = ('redirect', 'file') def __init__(self, redirect, file): self.redirect = redirect self.file = file def __repr__(self): return '%s%s'%(self.redirect, self.file) if self.file else '%s'%(self.redirect) class ASTTestCombination: __slots__ = ('leftexpr', 'combination', 'rightexpr', 'test_command', 'group') def __init__(self, combination, rightexpr, leftexpr=None, test_command=False, group=False): self.combination = combination self.rightexpr = rightexpr self.leftexpr = leftexpr self.test_command = test_command self.group = group def __repr__(self): if self.leftexpr: return '%s %s %s'%(self.leftexpr, self.combination, self.rightexpr) elif self.combination: return '%s %s'%(self.combination, self.rightexpr) elif self.test_command: return '[ %s ]'%(self.rightexpr) elif self.group: return '( %s )'%(self.rightexpr) else: return '%s'%(self.rightexpr) class ASTTestCondition: __slots__ = ('leftvalue', 'test', 'rightvalue') def __init__(self, test, rightvalue, leftvalue=None): self.test = test self.leftvalue = leftvalue self.rightvalue = rightvalue def __repr__(self): if self.test: return '%s %s %s'%(self.leftvalue, self.test, self.rightvalue) if self.leftvalue else '%s %s'%(self.test, self.rightvalue) else: return '%s' % (self.rightvalue) class ASTIfCommand: __slots__ = ('test_commands', 'then_commands', 'else_commands') def __init__(self, test_commands, then_commands, else_commands=None): self.test_commands = test_commands self.then_commands = then_commands self.else_commands = else_commands def __repr__(self): if self.else_commands: return 'if %s; then\n%s\nelse\n%s\nfi' % (self.test_commands, self.then_commands, self.else_commands) else: return 'if %s; then\n%s\nfi' % (self.test_commands, self.then_commands) class BashParser(Parser): # Get the token list from the lexer (required) debugfile = 'parser.out' tokens = BashLexer.tokens precedence = ( # ('nonassoc', BOOL_NOT), # ('nonassoc', BOOL_LESS, BOOL_GREATER, BOOL_EQ, BOOL_NEQ), # Nonassociative operators ('left', LIST_COMMANDS), ('left', AMPERSAND, CMDSEP, NEWLINE), ('left', BOOL_COMBINATION), ('left', BOOL_COMPARISON), ('right', BOOL_NOT), # ('right', END_LINE) ) # Grammar rules and actions @_('compound_commands') def program(self, p): print('program(%s)' % (p.compound_commands)) return p.compound_commands @_('compound_command', 'compound_command end_command', 'compound_command end_command compound_commands' ) def compound_commands(self, p): # print('simple_command(%s)' % (list(p))) if getattr(p, 'compound_commands', None): p.compound_commands.insert(0, p.compound_command) return p.compound_commands else: return ASTCommands(p.compound_command) @_( 'group_command', 'list_commands', 'if_command', ) def compound_command(self, p): return p[0] @_( 'LBRACE NEWLINE compound_commands RBRACE', 'LBRACE compound_commands RBRACE', 'LPAREN compound_commands RPAREN', ) def group_command(self, p): if getattr(p, 'LBRACE', None): p.compound_commands.grouping = '{}' elif getattr(p, 'LPAREN', None): p.compound_commands.grouping = '()' return getattr(p, 'compound_commands', None) @_('pipe_command %prec LIST_COMMANDS', 'pipe_command end_pipe', 'pipe_command end_pipe list_commands', 'pipe_command boolean_combination list_commands') def list_commands(self, p): if getattr(p, 'boolean_combination', None): return ASTTestCombination(p.boolean_combination, p.list_commands, p.pipe_command) elif getattr(p, 'list_commands', None): p.list_commands.insert(0, p.pipe_command) return p.list_commands else: return ASTCommands(p.pipe_command) @_('NEWLINE', 'CMDSEP', 'AMPERSAND') def end_pipe(self, p): return None @_('NEWLINE', 'CMDSEP') def end_command(self, p): return None @_('IF list_commands THEN compound_commands FI', 'IF list_commands THEN NEWLINE compound_commands FI', 'IF list_commands THEN compound_commands ELSE compound_commands FI', 'IF list_commands THEN NEWLINE compound_commands ELSE NEWLINE compound_commands FI') def if_command(self, p): if getattr(p, 'ELSE', None): return ASTIfCommand(p.list_commands, p.compound_commands0, p.compound_commands1) else: return ASTIfCommand(p.list_commands, p.compound_commands) # @_( #'test_command', # 'command_pipe', # # 'test_command boolean_combination compound_command', # # 'command_pipe boolean_combination compound_command' # ) # def compound_command(self, p): # if getattr(p, 'boolean_combination', None): # return ASTTestCombination(p.boolean_combination, p.test_commands, p.test_command) # else: # return p.test_command @_('time_command pipe_commands', 'time_command BOOL_NOT pipe_commands', 'pipe_commands', 'BOOL_NOT pipe_commands') def pipe_command(self, p): # print('simple_command(%s)' % (list(p))) cmd = p.pipe_commands if getattr(p, 'BOOL_NOT', None): cmd = ASTTestCombination(p.BOOL_NOT, p.pipe_commands) return cmd @_('TIME', 'TIME TIME_OPTP') def time_command(self, p): cmd = ASTCommand(p.TIME) if getattr(p, 'TIME_OPTP', None): cmd.arguments = [p.TIME_OPTP] return cmd @_('simple_command', 'simple_command PIPE pipe_commands') def pipe_commands(self, p): # print('simple_command(%s)' % (list(p))) if getattr(p, 'PIPE', None): p.simple_command.pipetocmd = p.pipe_commands return p.simple_command @_('assignments', 'base_command', 'assignments base_command', 'base_command redirects', 'assignments base_command redirects') def simple_command(self, p): # print('simple_command(%s)' % (list(p))) cmd = p.base_command if getattr(p, 'base_command', None) else ASTCommand() if getattr(p, 'redirects', None): cmd.redirections = p.redirects if getattr(p, 'assignments', None): cmd.assignments = p.assignments return cmd @_('redirect', 'redirect redirects') def redirects(self, p): return [p.redirect] if len(p)==1 else [p.redirect] + p.redirects @_('REDIRECT', 'REDIRECT WORD') def redirect(self, p): # print('assignment(%s)' % (list(p))) return ASTRedirection(p.REDIRECT, getattr(p, 'WORD', None)) @_('echo_command', 'exec_command', 'test_command') def base_command(self, p): if len(p)==2: p[1].assignments = p.assignments.assignments return p[1] else: return p[0] @_('LBRACK test_expressions RBRACK', 'LDBRACK test_expressions RDBRACK') def test_command(self, p): if getattr(p, 'BOOL_NOT', None): return ASTTestCombination(p.BOOL_NOT, p.command_pipe) elif getattr(p, 'command_pipe', None): return ASTTestCombination(None, p.command_pipe) else: return ASTTestCombination(None, p.test_expressions, test_command=True) @_('test_expression', 'LPAREN test_expressions RPAREN', 'BOOL_NOT test_expressions %prec BOOL_NOT', 'test_expressions boolean_combination test_expressions %prec BOOL_COMBINATION' ) def test_expressions(self, p): if getattr(p, 'BOOL_NOT', None): return ASTTestCombination(p.BOOL_NOT, p.test_expressions) elif getattr(p, 'boolean_combination', None): return ASTTestCombination(p.boolean_combination, p.test_expressions1, p.test_expressions0) elif getattr(p, 'LPAREN', None): return ASTTestCombination(None, p.test_expressions, group=True) else: return p.test_expression @_('BOOL_OR', 'BOOL_AND') def boolean_combination(self, p): return p[0] @_('value boolean_comparison value %prec BOOL_COMPARISON', 'OPTION value') def test_expression(self, p): if getattr(p, 'BOOL_NOT', None): return ASTTestCombination(p.BOOL_NOT, p.test_expression) elif getattr(p, 'LPAREN', None): return ASTTestCombination(None, p.test_expressions, group=True) elif getattr(p, 'OPTION', None): return ASTTestCondition(p.boolean_comparison, p.value) else: return ASTTestCondition(p.boolean_comparison, p.value1, p.value0) @_('OPTION', 'BOOL_EQ', 'BOOL_NEQ', 'BOOL_LESS', 'BOOL_GREATER', 'ASSIGN') def boolean_comparison(self, p): return p[0] # @_( # 'for_command', # 'case_command', # 'WHILE compound_list DO compound_list DONE', # 'UNTIL compound_list DO compound_list DONE', # 'select_command', # 'if_command', # 'subshell', # 'group_command', # 'arith_command' # 'cond_command', # 'arith_for_command' # ) # def shell_command(self, p): # print('assignments(%s)' % (list(p))) # return list(p) @_('ECHO ECHO_STRING') def echo_command(self, p): return ASTCommand(p[0], None, [p[1]]) @_('WORD', 'WORD arguments') def exec_command(self, p): return ASTCommand(p[0], None, getattr(p, 'arguments', None), getattr(p, 'redirects', None)) @_('argument', 'argument arguments') def arguments(self, p): return [p.argument] if len(p)==1 else [p.argument] + p.arguments @_('OPTION ASSIGN', 'OPTION', 'arg_value') def argument(self, p): # print('assignment(%s)' % (list(p))) return ASTArgument(getattr(p, 'OPTION', None), getattr(p, 'arg_value', None)) @_('value', 'WORD') def arg_value(self, p): # print('value(%s)' % (list(p))) return p[0] @_('assignment', 'assignment assignments') def assignments(self, p): return [p.assignment] if len(p) == 1 else [p.assignment] + p.assignments @_('LET ID assignop value', 'ID assignop value', 'ID assignop') def assignment(self, p): # print('assignment(%s)' % (list(p))) return ASTAssignment(p.ID, p.assignop, getattr(p, 'value', None)) @_('ASSIGN', 'ARITH_ASSIGN') def assignop(self, p): return p[0] @_('QSTRING', 'DQSTRING', 'BTQUOTED', 'CMD_EXP', 'VAL_STRING', 'VAR_SUBST', 'VARIABLE') def value(self, p): # print('value(%s)' % (list(p))) return p[0] if __name__ == '__main__': lexer = BashLexer() parser = BashParser() while True: try: text = input('Command:>') result = parser.parse(lexer.tokenize(text)) print(result) except EOFError: break

6a84df704829c829063b750bd4cbc4f7f7261e8a

py

Python

Module03/pregnancy_wheel.py

biomed-bioinformatics-bootcamp/bmes-t580-2019-coursework-charrison620

4f53e9290b456f582464c86d114c794c1448b995

Module03/pregnancy_wheel.py

biomed-bioinformatics-bootcamp/bmes-t580-2019-coursework-charrison620

4f53e9290b456f582464c86d114c794c1448b995

Module03/pregnancy_wheel.py

biomed-bioinformatics-bootcamp/bmes-t580-2019-coursework-charrison620

4f53e9290b456f582464c86d114c794c1448b995

import datetime def print_header(): print('----------------------------') print(' Due Date APP ') print('----------------------------') print() def get_lmp_from_patient(): print("When was the patient's last normal menstrual cycle? ") date_str = input('Format: [dd/mm/yyyy}') #'05/06/2018' parts = date_str.split('/') if len(parts)!= 3: print('Bad date found', date_str) return get_lmp_from_patient() year = int(parts[2]) month = int(parts[1]) day = int(parts[0]) lmp = datetime.date(year, month, day) #print(lmp) return lmp #avg pregnancy length is 281 days def compute_days_between_dates(original_date, target_date): this_year = datetime.date(target_date.year, original_date.month, original_date.day) dt = this_year - target_date return dt.days def print_due_date_information(min_due_date, max_due_date, expected_due_date): print('Your expected due date is ', expected_due_date.strftime('%a %b %d %Y')) print('But it may be as early as ', min_due_date.strftime('%m/%d/%Y')) print('But as late as ', max_due_date.strftime('%m/%d/%Y')) def main(): print_header() lmp_day = get_lmp_from_patient() gest_length = datetime.timedelta(days = 281) gest_std = datetime.timedelta(days = 13) expected_due_date = lmp_day + gest_length min_due_date = expected_due_date - gest_std max_due_date = expected_due_date + gest_std print_due_date_information(min_due_date, max_due_date, expected_due_date) main()

6a863c2235ddfde035ee8193728b86e170dd1480

py

Python

costcalculator/forms.py

connor-c/Trip-Gas-Cost-Calculator

6101093ffd48b6cb6c4f847b8c1f40351617750b

costcalculator/forms.py

connor-c/Trip-Gas-Cost-Calculator

6101093ffd48b6cb6c4f847b8c1f40351617750b

2020-02-11T23:59:35.000Z

2022-02-10T07:16:43.000Z

costcalculator/forms.py

connor-c/Trip-Gas-Cost-Calculator

6101093ffd48b6cb6c4f847b8c1f40351617750b

from django import forms from django.core.validators import MinValueValidator, MinLengthValidator class OriginForm(forms.Form): origin_address = forms.CharField(validators=[MinLengthValidator(1)], widget=forms.TextInput(attrs={'class': 'form-control', 'id': 'inlineFormInputGroup', 'placeholder': '123 Tech St, Silicon Valley, CA 00000'})) class DestinationForm(forms.Form): destination_address = forms.CharField(validators=[MinLengthValidator(1)], widget=forms.TextInput(attrs={'class': 'form-control', 'id': 'inlineFormInputGroup', 'placeholder': '123 Tech St, Silicon Valley, CA 00000'})) class GasPriceForm(forms.Form): gas_price = forms.FloatField(validators=[MinValueValidator(0.01)], widget=forms.TextInput(attrs={'class': 'form-control', 'id': 'inlineFormInputGroup', 'placeholder': '1.23'})) class MpgForm(forms.Form): mpg = forms.FloatField(validators=[MinValueValidator(0.01)], widget=forms.TextInput(attrs={'class': 'form-control', 'id': 'inlineFormInputGroup', 'placeholder': '12'})) class NumPeopleForm(forms.Form): num_people = forms.IntegerField(validators=[MinValueValidator(1)], widget=forms.TextInput(attrs={'class': 'form-control', 'id': 'inlineFormInputGroup', 'placeholder': '1 (default is 1 if left blank)'})) class DistanceForm(forms.Form): distance = forms.FloatField(validators=[MinValueValidator(0.01)], widget=forms.TextInput(attrs={'class': 'form-control', 'id': 'inlineFormInputGroup', 'placeholder': '15.2'}))

6a86a5adbb68bba6dc2b067c07b59de722a8d5ca

py

Python

tasks/storm_raffle_handler.py

Ayouuuu/bili2.0

1108e39208e56f129fb5eb6605a5b3f1aadc0d8f

2020-01-03T09:27:53.000Z

2020-04-07T05:06:36.000Z

tasks/storm_raffle_handler.py

Ayouuuu/bili2.0

1108e39208e56f129fb5eb6605a5b3f1aadc0d8f

tasks/storm_raffle_handler.py

Ayouuuu/bili2.0

1108e39208e56f129fb5eb6605a5b3f1aadc0d8f

2019-08-23T07:43:21.000Z

2019-08-23T07:43:21.000Z

import bili_statistics from reqs.storm_raffle_handler import StormRaffleHandlerReq from tasks.utils import UtilsTask from .base_class import Forced, DontWait, Multi class StormRaffleJoinTask(Forced, DontWait, Multi): TASK_NAME = 'join_storm_raffle' # 为了速度，有时不用等room_id验证就参加,置room_id为0，is_normal_room自然会返回固定值true @staticmethod async def check(user, room_id, raffle_id=None): if not await UtilsTask.is_normal_room(user, room_id): return if raffle_id is not None: json_rsp = {'data': {'id': raffle_id}} else: json_rsp = await user.req_s(StormRaffleHandlerReq.check, user, room_id) next_step_settings = [] data = json_rsp['data'] if data: raffle_id = int(data['id']) if not bili_statistics.is_raffleid_duplicate(raffle_id/1000000): user.info(f'确认获取到飓风暴抽奖 {raffle_id}', with_userid=False) next_step_setting = (-2, (1, 3), room_id, raffle_id) next_step_settings.append(next_step_setting) next_step_setting = (-2, (2, 4), room_id, raffle_id) next_step_settings.append(next_step_setting) bili_statistics.add2raffle_ids(raffle_id/1000000, 'STORM') return next_step_settings @staticmethod async def work(user, room_id, raffle_id): # await UtilsTask.enter_room(user, room_id) json_rsp = await user.req_s(StormRaffleHandlerReq.join, user, raffle_id) bili_statistics.add2joined_raffles('节奏风暴(合计)', user.id) if not json_rsp['code']: data = json_rsp['data'] gift_name = data["gift_name"] gift_num = data["gift_num"] user.info(f'飓风暴({raffle_id})的参与结果: {gift_name}X{gift_num}') bili_statistics.add2results(gift_name, user.id, gift_num) return print(json_rsp)

6a86acff1cb947e60b02c94c6dbdcc5c7b79e9bf

py

Python

u24_lymphocyte/third_party/treeano/sandbox/nodes/gradnet.py

ALSM-PhD/quip_classification

7347bfaa5cf11ae2d7a528fbcc43322a12c795d3

2015-04-26T04:45:51.000Z

2022-01-24T15:03:55.000Z

u24_lymphocyte/third_party/treeano/sandbox/nodes/gradnet.py

ALSM-PhD/quip_classification

7347bfaa5cf11ae2d7a528fbcc43322a12c795d3

2018-07-20T20:54:51.000Z

2020-06-12T05:36:04.000Z

u24_lymphocyte/third_party/treeano/sandbox/nodes/gradnet.py

ALSM-PhD/quip_classification

7347bfaa5cf11ae2d7a528fbcc43322a12c795d3

2018-05-21T23:57:20.000Z

2022-02-21T00:48:32.000Z

import theano import theano.tensor as T import treeano import treeano.nodes as tn fX = theano.config.floatX @treeano.register_node("grad_net_interpolation") class GradNetInterpolationNode(treeano.NodeImpl): """ interpolates outputs between 2 nodes """ hyperparameter_names = ("late_gate",) children_container = treeano.core.DictChildrenContainerSchema( early=treeano.core.ChildContainer, late=treeano.core.ChildContainer, ) input_keys = ("early", "late") def init_state(self, network): children = self.raw_children() early = children["early"] late = children["late"] network.forward_input_to(early.name) network.forward_input_to(late.name) network.take_output_from(early.name, to_key="early") network.take_output_from(late.name, to_key="late") def compute_output(self, network, early_vw, late_vw): late_gate = network.find_hyperparameter(["late_gate"], 1) out_var = (early_vw.variable * (1 - late_gate) + late_vw.variable * late_gate) out_shape = [] assert early_vw.ndim == late_vw.ndim for e, l in zip(early_vw.shape, late_vw.shape): if e is None and l is None: out_shape.append(None) elif e is None: out_shape.append(l) elif l is None: out_shape.append(e) else: assert e == l out_shape.append(e) network.create_vw( "default", variable=out_var, shape=tuple(out_shape), tags={"output"}, ) @treeano.register_node("grad_net_optimizer_interpolation") class _GradNetOptimizerInterpolationNode(treeano.Wrapper1NodeImpl): hyperparameter_names = ("late_gate", "gradnet_epsilon", "epsilon", "multiplicative_inverse_for_early_gate") def init_state(self, network): super(_GradNetOptimizerInterpolationNode, self).init_state(network) epsilon = network.find_hyperparameter(["gradnet_epsilon", "epsilon"], 1e-3) late_gate = network.find_hyperparameter(["late_gate"], 1) late_gate = treeano.utils.as_fX(late_gate) # NOTE: late gate cannot be 0 because the early gate is divide by it # AND multiplied by it. Clipping only for the early gate will cause # no updates to occur. late_gate = T.clip(late_gate, epsilon, 1) use_multiplicative_inverse = network.find_hyperparameter( ["multiplicative_inverse_for_early_gate"], False) if use_multiplicative_inverse: early_gate = epsilon / late_gate else: early_gate = 1 - late_gate network.set_hyperparameter(self.name + "_late_update_scale", "update_scale_factor", late_gate) network.set_hyperparameter(self.name + "_early_update_scale", "update_scale_factor", # these updates are also multiplied by # late_gate later on, so rescale them early_gate / late_gate) def GradNetOptimizerInterpolationNode(name, children, early, late, **kwargs): """ interpolates updates from 2 optimizers nodes NOTE: this is a hack to take in node constructors as arguments """ assert set(children.keys()) == {"subtree", "cost"} subtree = children["subtree"] cost = children["cost"] cost_ref = tn.ReferenceNode(name + "_costref", reference=cost.name) late_subtree = tn.UpdateScaleNode(name + "_late_update_scale", subtree) late_node = late(name + "_late", {"subtree": late_subtree, "cost": cost}) early_subtree = tn.UpdateScaleNode(name + "_early_update_scale", late_node) early_node = early(name + "_early", {"subtree": early_subtree, "cost": cost_ref}) # NOTE: need separate node to forward hyperparameter return _GradNetOptimizerInterpolationNode(name, early_node, **kwargs) def GradualSimpleBatchNormalizationNode(name): from treeano.sandbox.nodes import batch_normalization as bn return GradNetInterpolationNode( name, {"early": bn.SimpleBatchNormalizationNode(name + "_bn"), "late": tn.IdentityNode(name + "_identity")}) GradualBNNode = GradualSimpleBatchNormalizationNode

6a88dea060f9ea00f0bb7c465137c71904b3c14f

py

Python

minus80/RawFile.py

brohammer/Minus80

3cd5b61a7349b9fa6d35ed192d8a4f38523f92bb

minus80/RawFile.py

brohammer/Minus80

3cd5b61a7349b9fa6d35ed192d8a4f38523f92bb

minus80/RawFile.py

brohammer/Minus80

3cd5b61a7349b9fa6d35ed192d8a4f38523f92bb

import gzip #pragma: no cover import bz2 #pragma: no cover import lzma #pragma: no cover class RawFile(object):#pragma: no cover def __init__(self,filename): self.filename = filename if filename.endswith('.gz'): self.handle = gzip.open(filename,'rt') elif filename.endswith('bz2'): self.handle = bz2.open(filename,'rt') elif filename.endswith('xz'): self.handle = lzma.open(filenaem,'rt') else: self.handle = open(filename,'r') def __enter__(self): return self.handle def __exit__(self,dtype,value,traceback): self.handle.close()

6a89b2893b587e6d66f6aa207ca89999bce84710

py

Python

utils/config.py

jtr109/Alpha2kindle

a411d05cafa9036a732eeb75fa13f68963f254e3

utils/config.py

jtr109/Alpha2kindle

a411d05cafa9036a732eeb75fa13f68963f254e3

utils/config.py

jtr109/Alpha2kindle

a411d05cafa9036a732eeb75fa13f68963f254e3

# -*- coding: utf-8 -*- import os class BaseConf(object): HEADERS = { "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) " "AppleWebKit/537.36 (KHTML, like Gecko) " "Chrome/55.0.2883.95 " "Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;" "q=0.9,image/webp,*/*;" "q=0.8", "Accept-Encoding": "gzip, deflate, sdch, br", "Accept-Language": "zh-CN,zh;q=0.8,en;q=0.6,zh-TW;q=0.4", "Cache-Control": "max-age=0", } class TestConf(BaseConf): REDIS_URL = "redis://:{password}@{hostname}:{port}/{db_number}".format( password=os.environ.get("REDIS_PWD"), hostname='127.0.0.1', port=6379, db_number=0 ) CURCONF = TestConf

6a89d65e11282b8c81495e2795c8364f65d2114c

py

Python

framework/database/__init__.py

fabmiz/osf.io

8d86af3f0a6e5388bd5b18383e68e27b65a66247

framework/database/__init__.py

fabmiz/osf.io

8d86af3f0a6e5388bd5b18383e68e27b65a66247

framework/database/__init__.py

fabmiz/osf.io

8d86af3f0a6e5388bd5b18383e68e27b65a66247

# -*- coding: utf-8 -*- import functools import httplib as http import markupsafe from django.core.paginator import Paginator from django.db.models import Q, QuerySet from framework.exceptions import HTTPError def get_or_http_error(Model, pk_or_query, allow_deleted=False, display_name=None): """Load an instance of Model by primary key or modularodm.Q query. Raise an appropriate HTTPError if no record is found or if the query fails to find a unique record :param type Model: StoredObject subclass to query :param pk_or_query: :type pk_or_query: either - a <basestring> representation of the record's primary key, e.g. 'abcdef' - a <QueryBase> subclass query to uniquely select a record, e.g. Q('title', 'eq', 'Entitled') & Q('version', 'eq', 1) :param bool allow_deleted: allow deleleted records? :param basestring display_name: :raises: HTTPError(404) if the record does not exist :raises: HTTPError(400) if no unique record is found :raises: HTTPError(410) if the resource is deleted and allow_deleted = False :return: Model instance """ display_name = display_name or '' # FIXME: Not everything that uses this decorator needs to be markupsafe, but OsfWebRenderer error.mako does... safe_name = markupsafe.escape(display_name) if isinstance(pk_or_query, Q): try: instance = Model.objects.get(pk_or_query) except Model.DoesNotExist: raise HTTPError(http.NOT_FOUND, data=dict( message_long='No {name} record matching that query could be found'.format(name=safe_name) )) except Model.MultipleObjectsReturned: raise HTTPError(http.BAD_REQUEST, data=dict( message_long='The query must match exactly one {name} record'.format(name=safe_name) )) else: instance = Model.load(pk_or_query) if not instance: raise HTTPError(http.NOT_FOUND, data=dict( message_long='No {name} record with that primary key could be found'.format(name=safe_name) )) if getattr(instance, 'is_deleted', False) and getattr(instance, 'suspended', False): raise HTTPError(451, data=dict( # 451 - Unavailable For Legal Reasons message_short='Content removed', message_long='This content has been removed' )) if not allow_deleted and getattr(instance, 'is_deleted', False): raise HTTPError(http.GONE) return instance def autoload(Model, extract_key, inject_key, func): """Decorator to autoload a StoredObject instance by primary key and inject into kwargs. Raises an appropriate HTTPError (see #get_or_http_error) :param type Model: database collection model to query (should be a subclass of StoredObject) :param basestring extract_key: named URL field containing the desired primary key to be fetched from the database :param basestring inject_key: name the instance will be accessible as when it's injected as an argument to the function Example usage: :: def get_node(node_id): node = Node.load(node_id) ... becomes import functools autoload_node = functools.partial(autoload, Node, 'node_id', 'node') @autoload_node def get_node(node): ... """ @functools.wraps(func) def wrapper(*args, **kwargs): primary_key = kwargs.get(extract_key) instance = get_or_http_error(Model, primary_key) kwargs[inject_key] = instance return func(*args, **kwargs) return wrapper def paginated(model, query=None, increment=200, each=True, include=None): """Paginate a MODM query. :param StoredObject model: Model to query. :param Q query: Optional query object. :param int increment: Page size :param bool each: If True, each record is yielded. If False, pages are yielded. """ if include and query: queryset = model.objects.filter(query).include(*include) elif query: queryset = model.objects.filter(query) else: queryset = model.objects.all() # Pagination requires an order by clause, especially when using Postgres. # see: https://docs.djangoproject.com/en/1.10/topics/pagination/#required-arguments if isinstance(queryset, QuerySet) and not queryset.ordered: queryset = queryset.order_by(queryset.model._meta.pk.name) paginator = Paginator(queryset.all(), increment) for page_num in paginator.page_range: page = paginator.page(page_num) if each: for item in page.object_list: yield item else: yield page.object_list

6a8b93de9ef615a88be0dad5abda769599f3cf01

py

Python

neptune/internal/client_library/job_development_api/image.py

jiji-online/neptune-cli

50cf680a80d141497f9331ab7cdaee49fcb90b0c

neptune/internal/client_library/job_development_api/image.py

jiji-online/neptune-cli

50cf680a80d141497f9331ab7cdaee49fcb90b0c

neptune/internal/client_library/job_development_api/image.py

jiji-online/neptune-cli

50cf680a80d141497f9331ab7cdaee49fcb90b0c

# -*- coding: utf-8 -*- # # Copyright (c) 2016, deepsense.io # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from future import standard_library standard_library.install_aliases() # pylint: disable=wrong-import-position from future.builtins import object import base64 import io import PIL.Image from neptune.generated.swagger_client import InputImage from neptune.internal.common.models.parameters_validation import ( of_type_validator, text_conv, validate ) class Image(object): """ Represents information about images sent to image channels. """ @validate(name=text_conv, description=text_conv, data=of_type_validator(PIL.Image.Image)) def __init__(self, name, description, data): """ Creates a new Image. :param name: Name of the image, displayed in the Channels tab on job's dashboard. :param description: Description of the image displayed in the Channels tab on job's dashboard. :param data: Image data. :type name: unicode :type description: unicode :type data: PIL.Image """ self._name = name self._description = description self._data = data def to_input_image(self): """ Creates InputImage that can be sent to Neptune. :return: input image in format appropriate to be sent to Neptune. :rtype: InputImage """ image_buffer = io.BytesIO() self.data.save(image_buffer, format='PNG') contents = image_buffer.getvalue() image_buffer.close() input_image = InputImage() input_image.name = self.name input_image.description = self.description input_image.data = base64.b64encode(contents).decode('utf-8') return input_image @property def name(self): """ Gets name of this Image. :return: The name of this Image. :rtype: str """ return self._name @property def description(self): """ Gets description of this Image. :return: The description of this Image. :rtype: str """ return self._description @property def data(self): """ Gets data of this Image. :return: The data of this Image. :rtype: PIL.Image """ return self._data

6a8bca56c22e3267d252604b1793381dda94c58e

py

Python

src/picome/hukeyboard.py

guibohnert91/picome

9b91c28f7e83a2b730cafbda1a97205672f3e676

src/picome/hukeyboard.py

guibohnert91/picome

9b91c28f7e83a2b730cafbda1a97205672f3e676

src/picome/hukeyboard.py

guibohnert91/picome

9b91c28f7e83a2b730cafbda1a97205672f3e676

from adafruit_hid.keyboard import Keyboard from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS from adafruit_hid.keycode import Keycode import usb_hid import time class HumanKeyboard(object): def __init__(self): self.keyboard = Keyboard(usb_hid.devices) self.keyboardLayout = KeyboardLayoutUS(self.keyboard) def keyPress(self, keyCode): """Send a human like keypress. Keyword arguments: keyCode -- the real key to be pressed (example Keycode.SEVEN) """ self.keyboard.press(keyCode) time.sleep(0.1) self.keyboard.release(keyCode)

6a8c272cd22c6193695ebfa5fa34ff4d88d4565d

py

Python

src/solutions/part2/q104_max_bi_tree_depth.py

hychrisli/PyAlgorithms

71e537180f3b371d0d2cc47b11cb68ec13a8ac68

src/solutions/part2/q104_max_bi_tree_depth.py

hychrisli/PyAlgorithms

71e537180f3b371d0d2cc47b11cb68ec13a8ac68

src/solutions/part2/q104_max_bi_tree_depth.py

hychrisli/PyAlgorithms

71e537180f3b371d0d2cc47b11cb68ec13a8ac68

from src.base.solution import Solution from src.tests.part2.q104_test_max_bi_tree_depth import MaxBiTreeDepthTestCases class MaxBiTreeDepth(Solution): def gen_test_cases(self): return MaxBiTreeDepthTestCases() def run_test(self, input): return self.maxDepth(input) def maxDepth(self, root): """ :type root: TreeNode :rtype: int """ if not root: return 0 return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1 if __name__ == '__main__': sol = MaxBiTreeDepth() sol.run_tests()

6a8c916961dcdf5b4bdd11f085941afc268401f1

py

Python

inventory/admin.py

shakyasaijal/businessAnalytics

9312bae79709387c6eadd50f87f6be85bd52c396

inventory/admin.py

shakyasaijal/businessAnalytics

9312bae79709387c6eadd50f87f6be85bd52c396

2021-03-30T13:03:11.000Z

2022-03-12T00:20:13.000Z

inventory/admin.py

shakyasaijal/businessAnalytics

9312bae79709387c6eadd50f87f6be85bd52c396

from django.contrib import admin from . import models class SupplierAdmin(admin.ModelAdmin): list_display = ('supplier_name', 'contact', ) search_fields = ['supplier_name', 'contact', ] admin.site.register(models.Suppliers, SupplierAdmin) class InventoryUserAdmin(admin.ModelAdmin): list_display = ('employee_name', 'user_type') search_fields = ['employee_name', 'user_type'] list_filter = ("user_type",) admin.site.register(models.InventoryUser, InventoryUserAdmin) class ProductsAdmin(admin.ModelAdmin): list_display = ('name', 'quantity', 'cost_price', 'selling_price',) search_fields = ['name', 'quantity', 'cost_price', 'selling_price',] list_filter = ("branch", "supplier",) admin.site.register(models.Product, ProductsAdmin)

6a8e0d766c7cdfdc409946fd3a6196d6981baf1d

py

Python

python/testData/resolve/TryExceptElse.py

jnthn/intellij-community

8fa7c8a3ace62400c838e0d5926a7be106aa8557

2019-04-28T07:48:50.000Z

2020-12-11T14:18:08.000Z

python/testData/resolve/TryExceptElse.py

Cyril-lamirand/intellij-community

60ab6c61b82fc761dd68363eca7d9d69663cfa39

2018-07-05T13:59:39.000Z

2018-08-09T01:12:03.000Z

python/testData/resolve/TryExceptElse.py

Cyril-lamirand/intellij-community

60ab6c61b82fc761dd68363eca7d9d69663cfa39

2020-03-15T08:57:37.000Z

2020-04-07T04:48:14.000Z

try: name = "" except: pass else: print na<ref>me

6a8e67d20152ca7acb56c8c6199b1999e7f99406

py

Python

pybyte/session.py

ms7m/py-byte

c5872ff5b8536160d8cbd7f88406ed593113e77d

2020-01-26T17:22:05.000Z

2020-08-15T12:23:31.000Z

pybyte/session.py

ms7m/py-byte

c5872ff5b8536160d8cbd7f88406ed593113e77d

2020-01-27T18:10:06.000Z

2020-03-31T10:56:03.000Z

pybyte/session.py

ms7m/py-byte

c5872ff5b8536160d8cbd7f88406ed593113e77d

2020-01-27T17:59:45.000Z

2020-02-01T16:43:53.000Z

import requests class ByteSession(object): def __init__(self, token, providedSession=False): self._userToken = token if providedSession == False: self._session = requests.session() else: self._session = providedSession self._session.headers = { "Authorization": token, "User-Agent": "byte/0.2 (co.byte.video; build:145; iOS 13.3.0) Alamofire/4.9.1" } def session(self): return self._session

6a8e7fcaf4ca3d67de4aab013987d7db788188b5

py

Python

pyqtgraph/examples/template.py

secantsquared/pyqtgraph

3ef7f5b91639543e43bcd66a84290fb9bc18fc5c

pyqtgraph/examples/template.py

secantsquared/pyqtgraph

3ef7f5b91639543e43bcd66a84290fb9bc18fc5c

pyqtgraph/examples/template.py

secantsquared/pyqtgraph

3ef7f5b91639543e43bcd66a84290fb9bc18fc5c

# -*- coding: utf-8 -*- """ Description of example """ import pyqtgraph as pg from pyqtgraph.Qt import QtCore, QtGui, mkQApp import numpy as np app = mkQApp() # win.setWindowTitle('pyqtgraph example: ____') if __name__ == '__main__': pg.exec()

6a8f3e25920be24fb569cc55eff90ae879efa647

py

Python

ambari-server/src/test/python/stacks/2.0.6/common/test_stack_advisor.py

cas-packone/ambari-chs

68033fbd4b810b6642853f2ad9128cbbd4e0cb7b

2019-06-20T11:49:36.000Z

2020-12-11T10:44:29.000Z

ambari-server/src/test/python/stacks/2.0.6/common/test_stack_advisor.py

cas-packone/ambari-chs

68033fbd4b810b6642853f2ad9128cbbd4e0cb7b

ambari-server/src/test/python/stacks/2.0.6/common/test_stack_advisor.py

cas-packone/ambari-chs

68033fbd4b810b6642853f2ad9128cbbd4e0cb7b

2019-03-20T08:36:17.000Z

2019-03-20T08:36:17.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. ''' import socket from unittest import TestCase from mock.mock import patch, MagicMock class TestHDP206StackAdvisor(TestCase): def setUp(self): import imp import os testDirectory = os.path.dirname(os.path.abspath(__file__)) stackAdvisorPath = os.path.join(testDirectory, '../../../../../main/resources/stacks/stack_advisor.py') hdp206StackAdvisorPath = os.path.join(testDirectory, '../../../../../main/resources/stacks/HDP/2.0.6/services/stack_advisor.py') hdp206StackAdvisorClassName = 'HDP206StackAdvisor' with open(stackAdvisorPath, 'rb') as fp: stack_advisor = imp.load_module( 'stack_advisor', fp, stackAdvisorPath, ('.py', 'rb', imp.PY_SOURCE) ) with open(hdp206StackAdvisorPath, 'rb') as fp: self.stack_advisor_impl = imp.load_module('stack_advisor_impl', fp, hdp206StackAdvisorPath, ('.py', 'rb', imp.PY_SOURCE)) clazz = getattr(self.stack_advisor_impl, hdp206StackAdvisorClassName) self.stackAdvisor = clazz() self.maxDiff = None # substitute method in the instance self.get_system_min_uid_real = self.stackAdvisor.get_system_min_uid self.stackAdvisor.get_system_min_uid = self.get_system_min_uid_magic @patch('__builtin__.open') @patch('os.path.exists') def get_system_min_uid_magic(self, exists_mock, open_mock): class MagicFile(object): def read(self): return """ #test line UID_MIN 200 UID_MIN 500 """ def __exit__(self, exc_type, exc_val, exc_tb): pass def __enter__(self): return self exists_mock.return_value = True open_mock.return_value = MagicFile() return self.get_system_min_uid_real() def test_recommendationCardinalityALL(self): servicesInfo = [ { "name": "GANGLIA", "components": [{"name": "GANGLIA_MONITOR", "cardinality": "ALL", "category": "SLAVE", "is_master": False}] } ] services = self.prepareServices(servicesInfo) hosts = self.prepareHosts(["host1", "host2"]) result = self.stackAdvisor.recommendComponentLayout(services, hosts) expectedComponentsHostsMap = { "GANGLIA_MONITOR": ["host1", "host2"] } self.assertHostLayout(expectedComponentsHostsMap, result) def test_recommendOnAllHosts(self): """ Recommend on all hosts for cardinality ALL even if the component has been installed in the cluster before """ servicesInfo = [ { "name": "GANGLIA", "components": [{"name": "GANGLIA_MONITOR", "cardinality": "ALL", "category": "SLAVE", "is_master": False, "hostnames": ["host1"]}] } ] services = self.prepareServices(servicesInfo) hosts = self.prepareHosts(["host1", "host2"]) result = self.stackAdvisor.recommendComponentLayout(services, hosts) expectedComponentsHostsMap = { "GANGLIA_MONITOR": ["host1", "host2"] } self.assertHostLayout(expectedComponentsHostsMap, result) def test_recommendationIsNotPreferableOnAmbariServer(self): servicesInfo = [ { "name": "GANGLIA", "components": [{"name": "GANGLIA_SERVER", "cardinality": "ALL", "category": "MASTER", "is_master": True}] } ] services = self.prepareServices(servicesInfo) localhost = socket.getfqdn() hosts = self.prepareHosts([localhost, "host2"]) result = self.stackAdvisor.recommendComponentLayout(services, hosts) expectedComponentsHostsMap = { "GANGLIA_SERVER": ["host2"] } self.assertHostLayout(expectedComponentsHostsMap, result) def test_validationNamenodeAndSecondaryNamenode2Hosts_noMessagesForSameHost(self): servicesInfo = [ { "name": "HDFS", "components": [ {"name": "NAMENODE", "cardinality": "1-2", "category": "MASTER", "is_master": True, "hostnames": ["host1"]}, {"name": "SECONDARY_NAMENODE", "cardinality": "1", "category": "MASTER", "is_master": True, "hostnames": ["host1"]}] } ] services = self.prepareServices(servicesInfo) hosts = self.prepareHosts(["host1", "host2"]) result = self.stackAdvisor.validateComponentLayout(services, hosts) expectedItems = [ {"message": "Host is not used", "level": "ERROR", "host": "host2"} ] self.assertValidationResult(expectedItems, result) def test_validationCardinalityALL(self): servicesInfo = [ { "name": "GANGLIA", "components": [ {"name": "GANGLIA_MONITOR", "display_name": "Ganglia Monitor", "cardinality": "ALL", "category": "SLAVE", "is_master": False, "hostnames": ["host1"]}, {"name": "GANGLIA_SERVER", "display_name": "Ganglia Server", "cardinality": "1-2", "category": "MASTER", "is_master": True, "hostnames": ["host2", "host1"]} ] } ] services = self.prepareServices(servicesInfo) hosts = self.prepareHosts(["host1", "host2"]) result = self.stackAdvisor.validateComponentLayout(services, hosts) expectedItems = [ {"message": "Ganglia Monitor component should be installed on all hosts in cluster.", "level": "ERROR"} ] self.assertValidationResult(expectedItems, result) def test_validationCardinalityExactAmount(self): servicesInfo = [ { "name": "GANGLIA", "components": [ {"name": "GANGLIA_MONITOR", "display_name": "Ganglia Monitor", "cardinality": "2", "category": "SLAVE", "is_master": False, "hostnames": ["host1"]}, {"name": "GANGLIA_SERVER", "display_name": "Ganglia Server", "cardinality": "2", "category": "MASTER", "is_master": True, "hostnames": ["host2", "host1"]} ] } ] services = self.prepareServices(servicesInfo) hosts = self.prepareHosts(["host1", "host2"]) result = self.stackAdvisor.validateComponentLayout(services, hosts) expectedItems = [ {"message": "Exactly 2 Ganglia Monitor components should be installed in cluster.", "level": "ERROR"} ] self.assertValidationResult(expectedItems, result) def test_validationCardinalityAtLeast(self): servicesInfo = [ { "name": "GANGLIA", "components": [ {"name": "GANGLIA_MONITOR", "display_name": "Ganglia Monitor", "cardinality": "1+", "category": "SLAVE", "is_master": False, "hostnames": ["host1"]}, {"name": "GANGLIA_SERVER", "display_name": "Ganglia Server", "cardinality": "3+", "category": "MASTER", "is_master": True, "hostnames": ["host2", "host1"]} ] } ] services = self.prepareServices(servicesInfo) hosts = self.prepareHosts(["host1", "host2"]) result = self.stackAdvisor.validateComponentLayout(services, hosts) expectedItems = [ {"message": "At least 3 Ganglia Server components should be installed in cluster.", "level": "ERROR"} ] self.assertValidationResult(expectedItems, result) def test_validationWarnMessagesIfLessThanDefault(self): servicesInfo = [ { "name": "YARN", "components": [] } ] services = self.prepareServices(servicesInfo) services["configurations"] = {"yarn-site":{"properties":{"yarn.nodemanager.resource.memory-mb": "0", "yarn.scheduler.minimum-allocation-mb": "str"}}} hosts = self.prepareHosts([]) result = self.stackAdvisor.validateConfigurations(services, hosts) expectedItems = [ {"message": "Value is less than the recommended default of 512", "level": "WARN"}, {'message': 'Value should be set for yarn.nodemanager.linux-container-executor.group', 'level': 'ERROR'}, {"message": "Value should be integer", "level": "ERROR"}, {"message": "Value should be set", "level": "ERROR"} ] self.assertValidationResult(expectedItems, result) def test_validationYARNServicecheckQueueName(self): servicesInfo = [ { "name": "YARN", "components": [] } ] services = self.prepareServices(servicesInfo) services["configurations"] = {"yarn-env":{"properties":{"service_check.queue.name": "default"}}, "capacity-scheduler":{"properties":{"capacity-scheduler": "yarn.scheduler.capacity.root.queues=ndfqueue\n"}}} hosts = self.prepareHosts([]) result = self.stackAdvisor.validateConfigurations(services, hosts) expectedItems = [ {'message': 'Queue is not exist, or not corresponds to existing YARN leaf queue', 'level': 'ERROR'} ] self.assertValidationResult(expectedItems, result) services["configurations"]["yarn-env"]["properties"]["service_check.queue.name"] = "ndfqueue" expectedItems = [] result = self.stackAdvisor.validateConfigurations(services, hosts) self.assertValidationResult(expectedItems, result) def test_validationMinMax(self): configurations = { "mapred-site": { "properties": { "mapreduce.task.io.sort.mb": "4096", "some_float_value": "0.5", "no_min_or_max_attribute_property": "STRING_VALUE" } } } recommendedDefaults = { "mapred-site": { "properties": { "mapreduce.task.io.sort.mb": "2047", "some_float_value": "0.8", "no_min_or_max_attribute_property": "STRING_VALUE" }, "property_attributes": { 'mapreduce.task.io.sort.mb': {'maximum': '2047'}, 'some_float_value': {'minimum': '0.8'} } } } items = [] self.stackAdvisor.validateMinMax(items, recommendedDefaults, configurations) expectedItems = [ { 'message': 'Value is greater than the recommended maximum of 2047 ', 'level': 'WARN', 'config-type': 'mapred-site', 'config-name': 'mapreduce.task.io.sort.mb', 'type': 'configuration' }, { 'message': 'Value is less than the recommended minimum of 0.8 ', 'level': 'WARN', 'config-type': 'mapred-site', 'config-name': 'some_float_value', 'type': 'configuration' } ] self.assertEquals(expectedItems, items) def test_validationHostIsNotUsedForNonValuableComponent(self): servicesInfo = [ { "name": "GANGLIA", "components": [ {"name": "GANGLIA_MONITOR", "cardinality": "ALL", "category": "SLAVE", "is_master": False, "hostnames": ["host1", "host2"]}, {"name": "GANGLIA_SERVER", "cardinality": "1", "category": "MASTER", "is_master": True, "hostnames": ["host2"]} ] } ] services = self.prepareServices(servicesInfo) hosts = self.prepareHosts(["host1", "host2"]) result = self.stackAdvisor.validateComponentLayout(services, hosts) expectedItems = [ {"message": "Host is not used", "host": "host1", "level": "ERROR"} ] self.assertValidationResult(expectedItems, result) def test_validationCardinality01TwoHostsAssigned(self): servicesInfo = [ { "name": "GANGLIA", "components": [ {"name": "GANGLIA_SERVER", "display_name": "Ganglia Server", "cardinality": "0-1", "category": "MASTER", "is_master": True, "hostnames": ["host1", "host2"]} ] } ] services = self.prepareServices(servicesInfo) hosts = self.prepareHosts(["host1", "host2"]) result = self.stackAdvisor.validateComponentLayout(services, hosts) expectedItems = [ {"message": "Between 0 and 1 Ganglia Server components should be installed in cluster.", "level": "ERROR"} ] self.assertValidationResult(expectedItems, result) def test_validationHostIsNotUsed(self): servicesInfo = [ { "name": "GANGLIA", "components": [ {"name": "GANGLIA_SERVER", "cardinality": "1", "category": "MASTER", "is_master": True, "hostnames": ["host1"]} ] } ] services = self.prepareServices(servicesInfo) hosts = self.prepareHosts(["host1", "host2"]) result = self.stackAdvisor.validateComponentLayout(services, hosts) expectedItems = [ {"message": "Host is not used", "host": "host2", "level": "ERROR"} ] self.assertValidationResult(expectedItems, result) def test_getConfigurationClusterSummary_withHBaseAnd6gbRam(self): servicesList = ["HBASE"] components = [] hosts = { "items" : [ { "Hosts" : { "cpu_count" : 8, "total_mem" : 6291456, "disk_info" : [ {"mountpoint" : "/"}, {"mountpoint" : "/dev/shm"}, {"mountpoint" : "/vagrant"}, {"mountpoint" : "/"}, {"mountpoint" : "/dev/shm"}, {"mountpoint" : "/"}, {"mountpoint" : "/dev/shm"}, {"mountpoint" : "/vagrant"} ] } } ] } expected = { "hBaseInstalled": True, "components": components, "cpu": 8, "disk": 8, "ram": 6, "reservedRam": 2, "hbaseRam": 1, "minContainerSize": 512, "totalAvailableRam": 3072, "containers": 6, "ramPerContainer": 512, "mapMemory": 512, "reduceMemory": 512, "amMemory": 512, "referenceHost": hosts["items"][0]["Hosts"] } # Test - Cluster data with 1 host result = self.stackAdvisor.getConfigurationClusterSummary(servicesList, hosts, components, None) self.assertEquals(result, expected) # Test - Cluster data with 2 hosts - pick minimum memory servicesList.append("YARN") services = services = {"services": [{"StackServices": {"service_name" : "YARN", "service_version" : "2.6.0.2.2" }, "components":[ { "StackServiceComponents":{ "advertise_version":"true", "cardinality":"1+", "component_category":"SLAVE", "component_name":"NODEMANAGER", "custom_commands":[ ], "display_name":"NodeManager", "is_client":"false", "is_master":"false", "service_name":"YARN", "stack_name":"HDP", "stack_version":"2.2", "hostnames":[ "host1", "host2" ] }, "dependencies":[ ] } ], }], "configurations": {} } hosts["items"][0]["Hosts"]["host_name"] = "host1" hosts["items"].append({ "Hosts": { "cpu_count" : 4, "total_mem" : 500000, "host_name" : "host2", "disk_info" : [ {"mountpoint" : "/"}, {"mountpoint" : "/dev/shm"}, {"mountpoint" : "/vagrant"}, {"mountpoint" : "/"}, {"mountpoint" : "/dev/shm"}, {"mountpoint" : "/"}, {"mountpoint" : "/dev/shm"}, {"mountpoint" : "/vagrant"} ] } }) expected["referenceHost"] = hosts["items"][1]["Hosts"] expected["referenceNodeManagerHost"] = hosts["items"][1]["Hosts"] expected["amMemory"] = 170.66666666666666 expected["containers"] = 3.0 expected["cpu"] = 4 expected["totalAvailableRam"] = 512 expected["mapMemory"] = 170 expected["minContainerSize"] = 256 expected["reduceMemory"] = 170.66666666666666 expected["ram"] = 0 expected["ramPerContainer"] = 170.66666666666666 expected["reservedRam"] = 1 result = self.stackAdvisor.getConfigurationClusterSummary(servicesList, hosts, components, services) self.assertEquals(result, expected) def test_getConfigurationClusterSummary_withHBaseAnd48gbRam(self): servicesList = ["HBASE"] components = [] hosts = { "items" : [ { "Hosts" : { "cpu_count" : 6, "total_mem" : 50331648, "disk_info" : [ {"mountpoint" : "/"}, {"mountpoint" : "/dev/shm"}, {"mountpoint" : "/vagrant"}, {"mountpoint" : "/"}, {"mountpoint" : "/dev/shm"}, {"mountpoint" : "/vagrant"} ] } } ] } expected = { "hBaseInstalled": True, "components": components, "cpu": 6, "disk": 6, "ram": 48, "reservedRam": 6, "hbaseRam": 8, "minContainerSize": 2048, "totalAvailableRam": 34816, "containers": 11, "ramPerContainer": 3072, "mapMemory": 3072, "reduceMemory": 3072, "amMemory": 3072, "referenceHost": hosts["items"][0]["Hosts"] } result = self.stackAdvisor.getConfigurationClusterSummary(servicesList, hosts, components, None) self.assertEquals(result, expected) def test_recommendStormConfigurations(self): # no AMS configurations = {} services = { "services": [ ], "configurations": configurations } expected = { "storm-site": { "properties": { } }, } self.stackAdvisor.recommendStormConfigurations(configurations, None, services, None) self.assertEquals(configurations, expected) # with AMS configurations = {} services = { "services": [ { "StackServices": { "service_name": "AMBARI_METRICS" } } ], "configurations": configurations } expected = { "storm-site": { "properties": { "metrics.reporter.register": "org.apache.hadoop.metrics2.sink.storm.StormTimelineMetricsReporter" } }, } self.stackAdvisor.recommendStormConfigurations(configurations, None, services, None) self.assertEquals(configurations, expected) def test_recommendYARNConfigurations(self): configurations = {} services = {"configurations": configurations, "services": []} clusterData = { "containers" : 5, "ramPerContainer": 256 } expected = { "yarn-env": { "properties": { "min_user_id": "500", 'service_check.queue.name': 'default' } }, "yarn-site": { "properties": { "yarn.nodemanager.linux-container-executor.group": "hadoop", "yarn.nodemanager.resource.memory-mb": "1280", "yarn.scheduler.minimum-allocation-mb": "256", "yarn.scheduler.maximum-allocation-mb": "1280" } } } self.stackAdvisor.recommendYARNConfigurations(configurations, clusterData, services, None) self.assertEquals(configurations, expected) def test_recommendMapReduce2Configurations_mapMemoryLessThan2560(self): configurations = {} clusterData = { "mapMemory": 567, "reduceMemory": 345.6666666666666, "amMemory": 123.54 } expected = { "mapred-site": { "properties": { 'mapreduce.job.queuename': 'default', "yarn.app.mapreduce.am.resource.mb": "123", "yarn.app.mapreduce.am.command-opts": "-Xmx99m", "mapreduce.map.memory.mb": "567", "mapreduce.reduce.memory.mb": "345", "mapreduce.map.java.opts": "-Xmx454m", "mapreduce.reduce.java.opts": "-Xmx277m", "mapreduce.task.io.sort.mb": "227" } } } self.stackAdvisor.recommendMapReduce2Configurations(configurations, clusterData, None, None) self.assertEquals(configurations, expected) def test_getConfigurationClusterSummary_noHostsWithoutHBase(self): servicesList = [] components = [] hosts = { "items" : [] } result = self.stackAdvisor.getConfigurationClusterSummary(servicesList, hosts, components, None) expected = { "hBaseInstalled": False, "components": components, "cpu": 0, "disk": 0, "ram": 0, "reservedRam": 1, "hbaseRam": 1, "minContainerSize": 256, "totalAvailableRam": 512, "containers": 3, "ramPerContainer": 170.66666666666666, "mapMemory": 170, "reduceMemory": 170.66666666666666, "amMemory": 170.66666666666666 } self.assertEquals(result, expected) def prepareHosts(self, hostsNames): hosts = { "items": [] } for hostName in hostsNames: nextHost = {"Hosts":{"host_name" : hostName}} hosts["items"].append(nextHost) return hosts def prepareServices(self, servicesInfo): services = { "Versions" : { "stack_name" : "HDP", "stack_version" : "2.0.6" } } services["services"] = [] for serviceInfo in servicesInfo: nextService = {"StackServices":{"service_name" : serviceInfo["name"]}} nextService["components"] = [] for component in serviceInfo["components"]: nextComponent = { "StackServiceComponents": { "component_name": component["name"], "cardinality": component["cardinality"], "component_category": component["category"], "is_master": component["is_master"] } } try: nextComponent["StackServiceComponents"]["hostnames"] = component["hostnames"] except KeyError: nextComponent["StackServiceComponents"]["hostnames"] = [] try: nextComponent["StackServiceComponents"]["display_name"] = component["display_name"] except KeyError: nextComponent["StackServiceComponents"]["display_name"] = component["name"] nextService["components"].append(nextComponent) services["services"].append(nextService) return services def assertHostLayout(self, componentsHostsMap, recommendation): blueprintMapping = recommendation["recommendations"]["blueprint"]["host_groups"] bindings = recommendation["recommendations"]["blueprint_cluster_binding"]["host_groups"] actualComponentHostsMap = {} for hostGroup in blueprintMapping: hostGroupName = hostGroup["name"] hostsInfos = [binding["hosts"] for binding in bindings if binding["name"] == hostGroupName][0] hosts = [info["fqdn"] for info in hostsInfos] for component in hostGroup["components"]: componentName = component["name"] try: actualComponentHostsMap[componentName] except KeyError, err: actualComponentHostsMap[componentName] = [] for host in hosts: if host not in actualComponentHostsMap[componentName]: actualComponentHostsMap[componentName].append(host) for componentName in componentsHostsMap.keys(): expectedHosts = componentsHostsMap[componentName] actualHosts = actualComponentHostsMap[componentName] self.checkEqual(expectedHosts, actualHosts) def checkEqual(self, l1, l2): if not len(l1) == len(l2) or not sorted(l1) == sorted(l2): raise AssertionError("list1={0}, list2={1}".format(l1, l2)) def assertValidationResult(self, expectedItems, result): actualItems = [] for item in result["items"]: next = {"message": item["message"], "level": item["level"]} try: next["host"] = item["host"] except KeyError, err: pass actualItems.append(next) self.checkEqual(expectedItems, actualItems) def test_recommendHbaseConfigurations(self): servicesList = ["HBASE"] configurations = {} components = [] host_item = { "Hosts" : { "cpu_count" : 6, "total_mem" : 50331648, "disk_info" : [ {"mountpoint" : "/"}, {"mountpoint" : "/dev/shm"}, {"mountpoint" : "/vagrant"}, {"mountpoint" : "/"}, {"mountpoint" : "/dev/shm"}, {"mountpoint" : "/vagrant"} ] } } hosts = { "items" : [host_item for i in range(1, 300)] } services = { "services" : [ ], "configurations": { "hbase-site": { "properties": { "hbase.superuser": "hbase" } }, "hbase-env": { "properties": { "hbase_user": "hbase123" } } } } expected = { 'hbase-site': { 'properties': { 'hbase.superuser': 'hbase123' } }, "hbase-env": { "properties": { "hbase_master_heapsize": "4096", "hbase_regionserver_heapsize": "8192", } } } clusterData = self.stackAdvisor.getConfigurationClusterSummary(servicesList, hosts, components, None) self.assertEquals(clusterData['hbaseRam'], 8) self.stackAdvisor.recommendHbaseConfigurations(configurations, clusterData, services, hosts) self.assertEquals(configurations, expected) def test_recommendRangerConfigurations(self): clusterData = {} # Recommend for not existing DB_FLAVOR and http enabled, HDP-2.3 services = { "Versions" : { "stack_version" : "2.3", }, "services": [ { "StackServices": { "service_name": "RANGER", "service_version": "0.5.0" }, "components": [ { "StackServiceComponents": { "component_name": "RANGER_ADMIN", "hostnames": ["host1"] } } ] }, { "StackServices": { "service_name": "HDFS" }, "components": [ { "StackServiceComponents": { "component_name": "NAMENODE", "hostnames": ["host1"] } } ] } ], "configurations": { "admin-properties": { "properties": { "DB_FLAVOR": "NOT_EXISTING", } }, "ranger-admin-site": { "properties": { "ranger.service.http.port": "7777", "ranger.service.http.enabled": "true", } } } } expected = { "admin-properties": { "properties": { "policymgr_external_url": "http://host1:7777" } } } recommendedConfigurations = {} self.stackAdvisor.recommendRangerConfigurations(recommendedConfigurations, clusterData, services, None) self.assertEquals(recommendedConfigurations, expected, "Test for not existing DB_FLAVOR and http enabled, HDP-2.3") # Recommend for DB_FLAVOR POSTGRES and https enabled, HDP-2.3 configurations = { "admin-properties": { "properties": { "DB_FLAVOR": "POSTGRES", } }, "ranger-admin-site": { "properties": { "ranger.service.https.port": "7777", "ranger.service.http.enabled": "false", } } } services['configurations'] = configurations expected = { "admin-properties": { "properties": { "policymgr_external_url": "https://host1:7777" } } } recommendedConfigurations = {} self.stackAdvisor.recommendRangerConfigurations(recommendedConfigurations, clusterData, services, None) self.assertEquals(recommendedConfigurations, expected, "Test for DB_FLAVOR POSTGRES and https enabled, HDP-2.3") # Recommend for DB_FLAVOR ORACLE and https enabled, HDP-2.2 configurations = { "admin-properties": { "properties": { "DB_FLAVOR": "ORACLE", } }, "ranger-site": { "properties": { "http.enabled": "false", "https.service.port": "8888", } } } services['configurations'] = configurations expected = { "admin-properties": { "properties": { "policymgr_external_url": "https://host1:8888" } }, "ranger-env": {"properties": {}} } recommendedConfigurations = {} services['services'][0]['StackServices']['service_version'] = "0.4.0" self.stackAdvisor.recommendRangerConfigurations(recommendedConfigurations, clusterData, services, None) self.assertEquals(recommendedConfigurations, expected, "Test for DB_FLAVOR ORACLE and https enabled, HDP-2.2") # Test Recommend LDAP values services["ambari-server-properties"] = { "ambari.ldap.isConfigured" : "true", "authentication.ldap.bindAnonymously" : "false", "authentication.ldap.baseDn" : "dc=apache,dc=org", "authentication.ldap.groupNamingAttr" : "cn", "authentication.ldap.primaryUrl" : "c6403.ambari.apache.org:636", "authentication.ldap.userObjectClass" : "posixAccount", "authentication.ldap.secondaryUrl" : "c6403.ambari.apache.org:636", "authentication.ldap.usernameAttribute" : "uid", "authentication.ldap.dnAttribute" : "dn", "authentication.ldap.useSSL" : "true", "authentication.ldap.managerPassword" : "/etc/ambari-server/conf/ldap-password.dat", "authentication.ldap.groupMembershipAttr" : "memberUid", "authentication.ldap.groupObjectClass" : "posixGroup", "authentication.ldap.managerDn" : "uid=hdfs,ou=people,ou=dev,dc=apache,dc=org" } services["configurations"] = {} expected = { 'admin-properties': { 'properties': { 'policymgr_external_url': 'http://host1:6080', } }, 'ranger-env': {'properties': {}}, 'usersync-properties': { 'properties': { 'SYNC_LDAP_URL': 'ldaps://c6403.ambari.apache.org:636', 'SYNC_LDAP_BIND_DN': 'uid=hdfs,ou=people,ou=dev,dc=apache,dc=org', 'SYNC_LDAP_USER_OBJECT_CLASS': 'posixAccount', 'SYNC_LDAP_USER_NAME_ATTRIBUTE': 'uid' } } } recommendedConfigurations = {} self.stackAdvisor.recommendRangerConfigurations(recommendedConfigurations, clusterData, services, None) self.assertEquals(recommendedConfigurations, expected, "Test Recommend LDAP values") # Test Ranger Audit properties del services["ambari-server-properties"] services["configurations"] = { "core-site": { "properties": { "fs.defaultFS": "hdfs://host1:8080", } }, "ranger-env": { "properties": { "xasecure.audit.destination.db": "true", "xasecure.audit.destination.hdfs":"false", "xasecure.audit.destination.hdfs.dir":"hdfs://localhost:8020/ranger/audit/%app-type%/%time:yyyyMMdd%" } }, "ranger-hdfs-plugin-properties": { "properties": {} } } expected = { 'admin-properties': { 'properties': { 'policymgr_external_url': 'http://host1:6080' } }, 'ranger-hdfs-plugin-properties': { 'properties': { 'XAAUDIT.HDFS.IS_ENABLED': 'false', 'XAAUDIT.HDFS.DESTINATION_DIRECTORY': 'hdfs://host1:8080/ranger/audit/%app-type%/%time:yyyyMMdd%', 'XAAUDIT.DB.IS_ENABLED': 'true' } }, 'ranger-env': { 'properties': { 'xasecure.audit.destination.hdfs.dir': 'hdfs://host1:8080/ranger/audit/%app-type%/%time:yyyyMMdd%' } } } recommendedConfigurations = {} self.stackAdvisor.recommendRangerConfigurations(recommendedConfigurations, clusterData, services, None) self.assertEquals(recommendedConfigurations, expected, "Test Ranger Audit properties") def test_recommendHDFSConfigurations(self): configurations = { "hadoop-env": { "properties": { "hdfs_user": "hdfs", "proxyuser_group": "users" } }, "hive-env": { "properties": { "webhcat_user": "webhcat", "hive_user": "hive" } }, "oozie-env": { "properties": { "oozie_user": "oozie" } }, "falcon-env": { "properties": { "falcon_user": "falcon" } } } hosts = { "items": [ { "href": "/api/v1/hosts/host1", "Hosts": { "cpu_count": 1, "host_name": "c6401.ambari.apache.org", "os_arch": "x86_64", "os_type": "centos6", "ph_cpu_count": 1, "public_host_name": "c6401.ambari.apache.org", "rack_info": "/default-rack", "total_mem": 2097152, "disk_info": [{ "size": '8', "mountpoint": "/" }] } }, { "href": "/api/v1/hosts/host2", "Hosts": { "cpu_count": 1, "host_name": "c6402.ambari.apache.org", "os_arch": "x86_64", "os_type": "centos6", "ph_cpu_count": 1, "public_host_name": "c6402.ambari.apache.org", "rack_info": "/default-rack", "total_mem": 1048576, "disk_info": [{ "size": '8', "mountpoint": "/" }] } }, ]} services = { "services": [ { "StackServices": { "service_name": "HDFS" }, "components": [] }, { "StackServices": { "service_name": "FALCON" }, "components": [] }, { "StackServices": { "service_name": "HIVE" }, "components": [{ "href": "/api/v1/stacks/HDP/versions/2.0.6/services/HIVE/components/HIVE_SERVER", "StackServiceComponents": { "advertise_version": "true", "cardinality": "1", "component_category": "MASTER", "component_name": "HIVE_SERVER", "custom_commands": [], "display_name": "Hive Server", "is_client": "false", "is_master": "true", "service_name": "HIVE", "stack_name": "HDP", "stack_version": "2.0.6", "hostnames": ["c6401.ambari.apache.org","c6402.ambari.apache.org"] }}, { "href": "/api/v1/stacks/HDP/versions/2.0.6/services/HIVE/components/WEBHCAT_SERVER", "StackServiceComponents": { "advertise_version": "true", "cardinality": "1", "component_category": "MASTER", "component_name": "WEBHCAT_SERVER", "custom_commands": [], "display_name": "WebHCat Server", "is_client": "false", "is_master": "true", "service_name": "HIVE", "stack_name": "HDP", "stack_version": "2.0.6", "hostnames": ["c6401.ambari.apache.org", "c6402.ambari.apache.org"] }}] }, { "StackServices": { "service_name": "OOZIE" }, "components": [{ "href": "/api/v1/stacks/HDP/versions/2.0.6/services/HIVE/components/OOZIE_SERVER", "StackServiceComponents": { "advertise_version": "true", "cardinality": "1", "component_category": "MASTER", "component_name": "OOZIE_SERVER", "custom_commands": [], "display_name": "Oozie Server", "is_client": "false", "is_master": "true", "service_name": "HIVE", "stack_name": "HDP", "stack_version": "2.0.6", "hostnames": ["c6401.ambari.apache.org", "c6402.ambari.apache.org"] }, }] }], "configurations": configurations, "ambari-server-properties": {"ambari-server.user":"ambari_user"} } clusterData = { "totalAvailableRam": 2048 } ambariHostName = socket.getfqdn() expected = {'oozie-env': {'properties': {'oozie_user': 'oozie'}}, 'core-site': {'properties': {'hadoop.proxyuser.ambari_user.groups': '*', 'hadoop.proxyuser.ambari_user.hosts': ambariHostName, 'hadoop.proxyuser.oozie.groups': '*', 'hadoop.proxyuser.hive.groups': '*', 'hadoop.proxyuser.webhcat.hosts': 'c6401.ambari.apache.org,c6402.ambari.apache.org', 'hadoop.proxyuser.falcon.hosts': '*', 'hadoop.proxyuser.webhcat.groups': '*', 'hadoop.proxyuser.hdfs.groups': '*', 'hadoop.proxyuser.hdfs.hosts': '*', 'hadoop.proxyuser.hive.hosts': 'c6401.ambari.apache.org,c6402.ambari.apache.org', 'hadoop.proxyuser.oozie.hosts': 'c6401.ambari.apache.org,c6402.ambari.apache.org', 'hadoop.proxyuser.falcon.groups': '*'}}, 'falcon-env': {'properties': {'falcon_user': 'falcon'}}, 'hdfs-site': {'properties': {'dfs.datanode.data.dir': '/hadoop/hdfs/data', 'dfs.datanode.du.reserved': '1024'}}, 'hive-env': {'properties': {'hive_user': 'hive', 'webhcat_user': 'webhcat'}}, 'hadoop-env': {'properties': {'hdfs_user': 'hdfs', 'namenode_heapsize': '1024', 'proxyuser_group': 'users', 'namenode_opt_maxnewsize': '256', 'namenode_opt_newsize': '256'}}} self.stackAdvisor.recommendHDFSConfigurations(configurations, clusterData, services, hosts) self.assertEquals(configurations, expected) configurations["hadoop-env"]["properties"]['hdfs_user'] = "hdfs1" changedConfigurations = [{"type":"hadoop-env", "name":"hdfs_user", "old_value":"hdfs"}] services["changed-configurations"] = changedConfigurations services['configurations'] = configurations expected = {'oozie-env': {'properties': {'oozie_user': 'oozie'}}, 'core-site': {'properties': {'hadoop.proxyuser.ambari_user.groups': '*', 'hadoop.proxyuser.ambari_user.hosts': ambariHostName, 'hadoop.proxyuser.oozie.groups': '*', 'hadoop.proxyuser.hive.groups': '*', 'hadoop.proxyuser.hdfs1.groups': '*', 'hadoop.proxyuser.hdfs1.hosts': '*', 'hadoop.proxyuser.webhcat.hosts': 'c6401.ambari.apache.org,c6402.ambari.apache.org', 'hadoop.proxyuser.falcon.hosts': '*', 'hadoop.proxyuser.webhcat.groups': '*', 'hadoop.proxyuser.hdfs.groups': '*', 'hadoop.proxyuser.hdfs.hosts': '*', 'hadoop.proxyuser.hive.hosts': 'c6401.ambari.apache.org,c6402.ambari.apache.org', 'hadoop.proxyuser.oozie.hosts': 'c6401.ambari.apache.org,c6402.ambari.apache.org', 'hadoop.proxyuser.falcon.groups': '*'}, 'property_attributes': {'hadoop.proxyuser.hdfs.groups': {'delete': 'true'}, 'hadoop.proxyuser.hdfs.hosts': {'delete': 'true'}}}, 'falcon-env': {'properties': {'falcon_user': 'falcon'}}, 'hive-env': {'properties': {'hive_user': 'hive', 'webhcat_user': 'webhcat'}}, 'hdfs-site': {'properties': {'dfs.datanode.data.dir': '/hadoop/hdfs/data', 'dfs.datanode.du.reserved': '1024'}}, 'hadoop-env': {'properties': {'hdfs_user': 'hdfs1', 'namenode_heapsize': '1024', 'proxyuser_group': 'users', 'namenode_opt_maxnewsize': '256', 'namenode_opt_newsize': '256'}}} self.stackAdvisor.recommendHDFSConfigurations(configurations, clusterData, services, hosts) self.assertEquals(configurations, expected) # Verify dfs.namenode.rpc-address is recommended to be deleted when NN HA configurations["hdfs-site"]["properties"]['dfs.internal.nameservices'] = "mycluster" configurations["hdfs-site"]["properties"]['dfs.ha.namenodes.mycluster'] = "nn1,nn2" services['configurations'] = configurations expected["hdfs-site"] = { 'properties': { 'dfs.datanode.data.dir': '/hadoop/hdfs/data', 'dfs.datanode.du.reserved': '1024', 'dfs.internal.nameservices': 'mycluster', 'dfs.ha.namenodes.mycluster': 'nn1,nn2' }, 'property_attributes': { 'dfs.namenode.rpc-address': { 'delete': 'true' } } } self.stackAdvisor.recommendHDFSConfigurations(configurations, clusterData, services, hosts) self.assertEquals(configurations, expected) def test_getHostNamesWithComponent(self): services = { "services": [ { "StackServices": { "service_name": "SERVICE" }, "components": [ { "StackServiceComponents": { "component_name": "COMPONENT", "hostnames": ["host1","host2","host3"] } } ] } ], "configurations": {} } result = self.stackAdvisor.getHostNamesWithComponent("SERVICE","COMPONENT", services) expected = ["host1","host2","host3"] self.assertEquals(result, expected) def test_getZKHostPortString(self): configurations = { "zoo.cfg": { "properties": { 'clientPort': "2183" } } } services = { "services": [ { "StackServices": { "service_name": "ZOOKEEPER" }, "components": [ { "StackServiceComponents": { "component_name": "ZOOKEEPER_SERVER", "hostnames": ["zk.host1","zk.host2","zk.host3"] } }, { "StackServiceComponents": { "component_name": "ZOOKEEPER_CLIENT", "hostnames": ["host1"] } } ] } ], "configurations": configurations } result = self.stackAdvisor.getZKHostPortString(services) expected = "zk.host1:2183,zk.host2:2183,zk.host3:2183" self.assertEquals(result, expected) def test_validateHDFSConfigurations(self): configurations = {} services = '' hosts = '' #Default configuration recommendedDefaults = {'dfs.datanode.du.reserved': '1024'} properties = {'dfs.datanode.du.reserved': '1024'} res = self.stackAdvisor.validateHDFSConfigurations(properties, recommendedDefaults, configurations, services, hosts) self.assertFalse(res) #Value is less then expected recommendedDefaults = {'dfs.datanode.du.reserved': '1024'} properties = {'dfs.datanode.du.reserved': '512'} res = self.stackAdvisor.validateHDFSConfigurations(properties, recommendedDefaults, configurations, services, hosts) self.assertTrue(res) #Value is begger then expected recommendedDefaults = {'dfs.datanode.du.reserved': '1024'} properties = {'dfs.datanode.du.reserved': '2048'} res = self.stackAdvisor.validateHDFSConfigurations(properties, recommendedDefaults, configurations, services, hosts) self.assertFalse(res) def test_validateHDFSConfigurationsEnv(self): configurations = {} # 1) ok: namenode_heapsize > recommended recommendedDefaults = {'namenode_heapsize': '1024', 'namenode_opt_newsize' : '256', 'namenode_opt_maxnewsize' : '256'} properties = {'namenode_heapsize': '2048', 'namenode_opt_newsize' : '300', 'namenode_opt_maxnewsize' : '300'} res_expected = [] res = self.stackAdvisor.validateHDFSConfigurationsEnv(properties, recommendedDefaults, configurations, '', '') self.assertEquals(res, res_expected) # 2) fail: namenode_heapsize, namenode_opt_maxnewsize < recommended properties['namenode_heapsize'] = '1022' properties['namenode_opt_maxnewsize'] = '255' res_expected = [{'config-type': 'hadoop-env', 'message': 'Value is less than the recommended default of 1024', 'type': 'configuration', 'config-name': 'namenode_heapsize', 'level': 'WARN'}, {'config-name': 'namenode_opt_maxnewsize', 'config-type': 'hadoop-env', 'level': 'WARN', 'message': 'Value is less than the recommended default of 256', 'type': 'configuration'}] res = self.stackAdvisor.validateHDFSConfigurationsEnv(properties, recommendedDefaults, configurations, '', '') self.assertEquals(res, res_expected) def test_validateAmsHbaseSiteConfigurations(self): configurations = { "hdfs-site": { "properties": { 'dfs.datanode.data.dir': "/hadoop/data" } }, "core-site": { "properties": { "fs.defaultFS": "hdfs://c6401.ambari.apache.org:8020" } }, "ams-site": { "properties": { "timeline.metrics.service.operation.mode": "embedded" } } } recommendedDefaults = { 'hbase.rootdir': 'file:///var/lib/ambari-metrics-collector/hbase', 'hbase.tmp.dir': '/var/lib/ambari-metrics-collector/hbase', 'hbase.cluster.distributed': 'false' } properties = { 'hbase.rootdir': 'file:///var/lib/ambari-metrics-collector/hbase', 'hbase.tmp.dir' : '/var/lib/ambari-metrics-collector/hbase', 'hbase.cluster.distributed': 'false' } host = { "href" : "/api/v1/hosts/host1", "Hosts" : { "cpu_count" : 1, "host_name" : "host1", "os_arch" : "x86_64", "os_type" : "centos6", "ph_cpu_count" : 1, "public_host_name" : "host1", "rack_info" : "/default-rack", "total_mem" : 2097152, "disk_info": [ { "available": str(15<<30), # 15 GB "type": "ext4", "mountpoint": "/" } ] } } hosts = { "items" : [ host ] } services = { "services": [ { "StackServices": { "service_name": "AMBARI_METRICS" }, "components": [ { "StackServiceComponents": { "component_name": "METRICS_COLLECTOR", "hostnames": ["host1"] } }, { "StackServiceComponents": { "component_name": "METRICS_MONITOR", "hostnames": ["host1"] } } ] }, { "StackServices": { "service_name": "HDFS" }, "components": [ { "StackServiceComponents": { "component_name": "DATANODE", "hostnames": ["host1"] } } ] } ], "configurations": configurations } # only 1 partition, enough disk space, no warnings res = self.stackAdvisor.validateAmsHbaseSiteConfigurations(properties, recommendedDefaults, configurations, services, hosts) expected = [] self.assertEquals(res, expected) # 1 partition, no enough disk space host['Hosts']['disk_info'] = [ { "available" : '1', "type" : "ext4", "mountpoint" : "/" } ] res = self.stackAdvisor.validateAmsHbaseSiteConfigurations(properties, recommendedDefaults, configurations, services, hosts) expected = [ {'config-name': 'hbase.rootdir', 'config-type': 'ams-hbase-site', 'level': 'WARN', 'message': 'Ambari Metrics disk space requirements not met. ' '\nRecommended disk space for partition / is 10G', 'type': 'configuration' } ] self.assertEquals(res, expected) # 2 partitions host['Hosts']['disk_info'] = [ { "available": str(15<<30), # 15 GB "type" : "ext4", "mountpoint" : "/grid/0" }, { "available" : str(15<<30), # 15 GB "type" : "ext4", "mountpoint" : "/" } ] recommendedDefaults = { 'hbase.rootdir': 'file:///grid/0/var/lib/ambari-metrics-collector/hbase', 'hbase.tmp.dir': '/var/lib/ambari-metrics-collector/hbase', 'hbase.cluster.distributed': 'false' } properties = { 'hbase.rootdir': 'file:///grid/0/var/lib/ambari-metrics-collector/hbase', 'hbase.tmp.dir' : '/var/lib/ambari-metrics-collector/hbase', 'hbase.cluster.distributed': 'false' } res = self.stackAdvisor.validateAmsHbaseSiteConfigurations(properties, recommendedDefaults, configurations, services, hosts) expected = [] self.assertEquals(res, expected) # dfs.dir & hbase.rootdir crosscheck + root partition + hbase.rootdir == hbase.tmp.dir warnings properties = { 'hbase.rootdir': 'file:///var/lib/ambari-metrics-collector/hbase', 'hbase.tmp.dir' : '/var/lib/ambari-metrics-collector/hbase', 'hbase.cluster.distributed': 'false' } res = self.stackAdvisor.validateAmsHbaseSiteConfigurations(properties, recommendedDefaults, configurations, services, hosts) expected = [ { 'config-name': 'hbase.rootdir', 'config-type': 'ams-hbase-site', 'level': 'WARN', 'message': 'It is not recommended to use root partition for hbase.rootdir', 'type': 'configuration' }, { 'config-name': 'hbase.tmp.dir', 'config-type': 'ams-hbase-site', 'level': 'WARN', 'message': 'Consider not using / partition for storing metrics temporary data. ' '/ partition is already used as hbase.rootdir to store metrics data', 'type': 'configuration' }, { 'config-name': 'hbase.rootdir', 'config-type': 'ams-hbase-site', 'level': 'WARN', 'message': 'Consider not using / partition for storing metrics data. ' '/ is already used by datanode to store HDFS data', 'type': 'configuration' } ] self.assertEquals(res, expected) # incorrect hbase.rootdir in distributed mode properties = { 'hbase.rootdir': 'file:///grid/0/var/lib/ambari-metrics-collector/hbase', 'hbase.tmp.dir' : '/var/lib/ambari-metrics-collector/hbase', 'hbase.cluster.distributed': 'false' } configurations['ams-site']['properties']['timeline.metrics.service.operation.mode'] = 'distributed' res = self.stackAdvisor.validateAmsHbaseSiteConfigurations(properties, recommendedDefaults, configurations, services, hosts) expected = [ { 'config-name': 'hbase.rootdir', 'config-type': 'ams-hbase-site', 'level': 'WARN', 'message': 'In distributed mode hbase.rootdir should point to HDFS.', 'type': 'configuration' }, { 'config-name': 'hbase.cluster.distributed', 'config-type': 'ams-hbase-site', 'level': 'ERROR', 'message': 'hbase.cluster.distributed property should be set to true for distributed mode', 'type': 'configuration' } ] self.assertEquals(res, expected) def test_validateStormSiteConfigurations(self): configurations = { "storm-site": { "properties": { 'metrics.reporter.register': "org.apache.hadoop.metrics2.sink.storm.StormTimelineMetricsReporter" } } } recommendedDefaults = { 'metrics.reporter.register': 'org.apache.hadoop.metrics2.sink.storm.StormTimelineMetricsReporter', } properties = { 'metrics.reporter.register': 'org.apache.hadoop.metrics2.sink.storm.StormTimelineMetricsReporter', } services = { "services": [ { "StackServices": { "service_name": "AMBARI_METRICS" } } ], "configurations": configurations } # positive res = self.stackAdvisor.validateStormConfigurations(properties, recommendedDefaults, configurations, services, None) expected = [] self.assertEquals(res, expected) properties['metrics.reporter.register'] = '' res = self.stackAdvisor.validateStormConfigurations(properties, recommendedDefaults, configurations, services, None) expected = [ {'config-name': 'metrics.reporter.register', 'config-type': 'storm-site', 'level': 'WARN', 'message': 'Should be set to org.apache.hadoop.metrics2.sink.storm.StormTimelineMetricsReporter ' 'to report the metrics to Ambari Metrics service.', 'type': 'configuration' } ] self.assertEquals(res, expected) def test_getHostsWithComponent(self): services = {"services": [{"StackServices": {"service_name" : "HDFS", "service_version" : "2.6.0.2.2" }, "components":[ { "href":"/api/v1/stacks/HDP/versions/2.2/services/HDFS/components/DATANODE", "StackServiceComponents":{ "advertise_version":"true", "cardinality":"1+", "component_category":"SLAVE", "component_name":"DATANODE", "custom_commands":[ ], "display_name":"DataNode", "is_client":"false", "is_master":"false", "service_name":"HDFS", "stack_name":"HDP", "stack_version":"2.2", "hostnames":[ "host1", "host2" ] }, "dependencies":[ ] }, { "href":"/api/v1/stacks/HDP/versions/2.2/services/HDFS/components/JOURNALNODE", "StackServiceComponents":{ "advertise_version":"true", "cardinality":"0+", "component_category":"SLAVE", "component_name":"JOURNALNODE", "custom_commands":[ ], "display_name":"JournalNode", "is_client":"false", "is_master":"false", "service_name":"HDFS", "stack_name":"HDP", "stack_version":"2.2", "hostnames":[ "host1" ] }, "dependencies":[ { "href":"/api/v1/stacks/HDP/versions/2.2/services/HDFS/components/JOURNALNODE/dependencies/HDFS_CLIENT", "Dependencies":{ "component_name":"HDFS_CLIENT", "dependent_component_name":"JOURNALNODE", "dependent_service_name":"HDFS", "stack_name":"HDP", "stack_version":"2.2" } } ] }, { "href":"/api/v1/stacks/HDP/versions/2.2/services/HDFS/components/NAMENODE", "StackServiceComponents":{ "advertise_version":"true", "cardinality":"1-2", "component_category":"MASTER", "component_name":"NAMENODE", "custom_commands":[ "DECOMMISSION", "REBALANCEHDFS" ], "display_name":"NameNode", "is_client":"false", "is_master":"true", "service_name":"HDFS", "stack_name":"HDP", "stack_version":"2.2", "hostnames":[ "host2" ] }, "dependencies":[ ] }, ], }], "configurations": {} } hosts = { "items" : [ { "href" : "/api/v1/hosts/host1", "Hosts" : { "cpu_count" : 1, "host_name" : "host1", "os_arch" : "x86_64", "os_type" : "centos6", "ph_cpu_count" : 1, "public_host_name" : "host1", "rack_info" : "/default-rack", "total_mem" : 2097152 } }, { "href" : "/api/v1/hosts/host2", "Hosts" : { "cpu_count" : 1, "host_name" : "host2", "os_arch" : "x86_64", "os_type" : "centos6", "ph_cpu_count" : 1, "public_host_name" : "host2", "rack_info" : "/default-rack", "total_mem" : 1048576 } }, ] } datanodes = self.stackAdvisor.getHostsWithComponent("HDFS", "DATANODE", services, hosts) self.assertEquals(len(datanodes), 2) self.assertEquals(datanodes, hosts["items"]) datanode = self.stackAdvisor.getHostWithComponent("HDFS", "DATANODE", services, hosts) self.assertEquals(datanode, hosts["items"][0]) namenodes = self.stackAdvisor.getHostsWithComponent("HDFS", "NAMENODE", services, hosts) self.assertEquals(len(namenodes), 1) # [host2] self.assertEquals(namenodes, [hosts["items"][1]]) namenode = self.stackAdvisor.getHostWithComponent("HDFS", "NAMENODE", services, hosts) # host2 self.assertEquals(namenode, hosts["items"][1]) # not installed nodemanager = self.stackAdvisor.getHostWithComponent("YARN", "NODEMANAGER", services, hosts) self.assertEquals(nodemanager, None) # unknown component unknown_component = self.stackAdvisor.getHostWithComponent("YARN", "UNKNOWN", services, hosts) self.assertEquals(nodemanager, None) # unknown service unknown_component = self.stackAdvisor.getHostWithComponent("UNKNOWN", "NODEMANAGER", services, hosts) self.assertEquals(nodemanager, None) def test_mergeValidators(self): childValidators = { "HDFS": {"hdfs-site": "validateHDFSConfigurations2.3"}, "HIVE": {"hiveserver2-site": "validateHiveServer2Configurations2.3"}, "HBASE": {"hbase-site": "validateHBASEConfigurations2.3", "newconf": "new2.3"}, "NEWSERVICE" : {"newserviceconf": "abc2.3"} } parentValidators = { "HDFS": {"hdfs-site": "validateHDFSConfigurations2.2", "hadoop-env": "validateHDFSConfigurationsEnv2.2"}, "YARN": {"yarn-env": "validateYARNEnvConfigurations2.2"}, "HIVE": {"hiveserver2-site": "validateHiveServer2Configurations2.2", "hive-site": "validateHiveConfigurations2.2", "hive-env": "validateHiveConfigurationsEnv2.2"}, "HBASE": {"hbase-site": "validateHBASEConfigurations2.2", "hbase-env": "validateHBASEEnvConfigurations2.2"}, "MAPREDUCE2": {"mapred-site": "validateMapReduce2Configurations2.2"}, "TEZ": {"tez-site": "validateTezConfigurations2.2"} } expected = { "HDFS": {"hdfs-site": "validateHDFSConfigurations2.3", "hadoop-env": "validateHDFSConfigurationsEnv2.2"}, "YARN": {"yarn-env": "validateYARNEnvConfigurations2.2"}, "HIVE": {"hiveserver2-site": "validateHiveServer2Configurations2.3", "hive-site": "validateHiveConfigurations2.2", "hive-env": "validateHiveConfigurationsEnv2.2"}, "HBASE": {"hbase-site": "validateHBASEConfigurations2.3", "hbase-env": "validateHBASEEnvConfigurations2.2", "newconf": "new2.3"}, "MAPREDUCE2": {"mapred-site": "validateMapReduce2Configurations2.2"}, "TEZ": {"tez-site": "validateTezConfigurations2.2"}, "NEWSERVICE" : {"newserviceconf": "abc2.3"} } self.stackAdvisor.mergeValidators(parentValidators, childValidators) self.assertEquals(expected, parentValidators) def test_getProperMountPoint(self): hostInfo = None self.assertEquals(["/"], self.stackAdvisor.getPreferredMountPoints(hostInfo)) hostInfo = {"some_key": []} self.assertEquals(["/"], self.stackAdvisor.getPreferredMountPoints(hostInfo)) hostInfo["disk_info"] = [] self.assertEquals(["/"], self.stackAdvisor.getPreferredMountPoints(hostInfo)) # root mountpoint with low space available hostInfo["disk_info"].append( { "available" : "1", "type" : "ext4", "mountpoint" : "/" } ) self.assertEquals(["/"], self.stackAdvisor.getPreferredMountPoints(hostInfo)) # tmpfs with more space available hostInfo["disk_info"].append( { "available" : "2", "type" : "tmpfs", "mountpoint" : "/dev/shm" } ) self.assertEquals(["/"], self.stackAdvisor.getPreferredMountPoints(hostInfo)) # /boot with more space available hostInfo["disk_info"].append( { "available" : "3", "type" : "tmpfs", "mountpoint" : "/boot/grub" } ) self.assertEquals(["/"], self.stackAdvisor.getPreferredMountPoints(hostInfo)) # /boot with more space available hostInfo["disk_info"].append( { "available" : "4", "type" : "tmpfs", "mountpoint" : "/mnt/external_hdd" } ) self.assertEquals(["/"], self.stackAdvisor.getPreferredMountPoints(hostInfo)) # virtualbox fs with more space available hostInfo["disk_info"].append( { "available" : "5", "type" : "vboxsf", "mountpoint" : "/vagrant" } ) self.assertEquals(["/"], self.stackAdvisor.getPreferredMountPoints(hostInfo)) # proper mountpoint with more space available hostInfo["disk_info"].append( { "available" : "6", "type" : "ext4", "mountpoint" : "/grid/0" } ) self.assertEquals(["/grid/0", "/"], self.stackAdvisor.getPreferredMountPoints(hostInfo)) # proper mountpoint with more space available hostInfo["disk_info"].append( { "available" : "7", "type" : "ext4", "mountpoint" : "/grid/1" } ) self.assertEquals(["/grid/1", "/grid/0", "/"], self.stackAdvisor.getPreferredMountPoints(hostInfo)) def test_validateNonRootFs(self): hostInfo = {"disk_info": [ { "available" : "2", "type" : "ext4", "mountpoint" : "/" } ]} properties = {"property1": "file:///var/dir"} recommendedDefaults = {"property1": "file:///var/dir"} # only / mountpoint - no warning self.assertTrue(self.stackAdvisor.validatorNotRootFs(properties, recommendedDefaults, 'property1', hostInfo) == None) # More preferable /grid/0 mountpoint - warning hostInfo["disk_info"].append( { "available" : "3", "type" : "ext4", "mountpoint" : "/grid/0" } ) recommendedDefaults = {"property1": "file:///grid/0/var/dir"} warn = self.stackAdvisor.validatorNotRootFs(properties, recommendedDefaults, 'property1', hostInfo) self.assertTrue(warn != None) self.assertEquals({'message': 'It is not recommended to use root partition for property1', 'level': 'WARN'}, warn) # Set by user /var mountpoint, which is non-root , but not preferable - no warning hostInfo["disk_info"].append( { "available" : "1", "type" : "ext4", "mountpoint" : "/var" } ) self.assertTrue(self.stackAdvisor.validatorNotRootFs(properties, recommendedDefaults, 'property1', hostInfo) == None) def test_validatorEnoughDiskSpace(self): reqiuredDiskSpace = 1048576 errorMsg = "Ambari Metrics disk space requirements not met. \n" \ "Recommended disk space for partition / is 1G" # local FS, enough space hostInfo = {"disk_info": [ { "available" : "1048578", "type" : "ext4", "mountpoint" : "/" } ]} properties = {"property1": "file:///var/dir"} self.assertTrue(self.stackAdvisor.validatorEnoughDiskSpace(properties, 'property1', hostInfo, reqiuredDiskSpace) == None) # local FS, no enough space hostInfo = {"disk_info": [ { "available" : "1", "type" : "ext4", "mountpoint" : "/" } ]} warn = self.stackAdvisor.validatorEnoughDiskSpace(properties, 'property1', hostInfo, reqiuredDiskSpace) self.assertTrue(warn != None) self.assertEquals({'message': errorMsg, 'level': 'WARN'}, warn) # non-local FS, HDFS properties = {"property1": "hdfs://h1"} self.assertTrue(self.stackAdvisor.validatorEnoughDiskSpace(properties, 'property1', hostInfo, reqiuredDiskSpace) == None) # non-local FS, WASB properties = {"property1": "wasb://h1"} self.assertTrue(self.stackAdvisor.validatorEnoughDiskSpace(properties, 'property1', hostInfo, reqiuredDiskSpace) == None) def test_round_to_n(self): self.assertEquals(self.stack_advisor_impl.round_to_n(0), 0) self.assertEquals(self.stack_advisor_impl.round_to_n(1000), 1024) self.assertEquals(self.stack_advisor_impl.round_to_n(2000), 2048) self.assertEquals(self.stack_advisor_impl.round_to_n(4097), 4096) def test_getMountPointForDir(self): self.assertEquals(self.stack_advisor_impl.getMountPointForDir("/var/log", ["/"]), "/") self.assertEquals(self.stack_advisor_impl.getMountPointForDir("/var/log", ["/var", "/"]), "/var") self.assertEquals(self.stack_advisor_impl.getMountPointForDir("file:///var/log", ["/var", "/"]), "/var") self.assertEquals(self.stack_advisor_impl.getMountPointForDir("hdfs:///hdfs_path", ["/var", "/"]), None) self.assertEquals(self.stack_advisor_impl.getMountPointForDir("relative/path", ["/var", "/"]), None) def test_getValidatorEqualsToRecommendedItem(self): properties = {"property1": "value1"} recommendedDefaults = {"property1": "value1"} self.assertEquals(self.stackAdvisor.validatorEqualsToRecommendedItem(properties, recommendedDefaults, "property1"), None) properties = {"property1": "value1"} recommendedDefaults = {"property1": "value2"} expected = {'message': 'It is recommended to set value value2 for property property1', 'level': 'WARN'} self.assertEquals(self.stackAdvisor.validatorEqualsToRecommendedItem(properties, recommendedDefaults, "property1"), expected) properties = {} recommendedDefaults = {"property1": "value2"} expected = {'level': 'ERROR', 'message': 'Value should be set for property1'} self.assertEquals(self.stackAdvisor.validatorEqualsToRecommendedItem(properties, recommendedDefaults, "property1"), expected) properties = {"property1": "value1"} recommendedDefaults = {} expected = {'level': 'ERROR', 'message': 'Value should be recommended for property1'} self.assertEquals(self.stackAdvisor.validatorEqualsToRecommendedItem(properties, recommendedDefaults, "property1"), expected) def test_getServicesSiteProperties(self): import imp, os testDirectory = os.path.dirname(os.path.abspath(__file__)) hdp206StackAdvisorPath = os.path.join(testDirectory, '../../../../../main/resources/stacks/HDP/2.0.6/services/stack_advisor.py') stack_advisor = imp.load_source('stack_advisor', hdp206StackAdvisorPath) services = { "services": [ { "StackServices": { "service_name": "RANGER" }, "components": [ { "StackServiceComponents": { "component_name": "RANGER_ADMIN", "hostnames": ["host1"] } } ] }, ], "configurations": { "admin-properties": { "properties": { "DB_FLAVOR": "NOT_EXISTING", } }, "ranger-admin-site": { "properties": { "ranger.service.http.port": "7777", "ranger.service.http.enabled": "true", } } } } expected = { "ranger.service.http.port": "7777", "ranger.service.http.enabled": "true", } siteProperties = stack_advisor.getServicesSiteProperties(services, "ranger-admin-site") self.assertEquals(siteProperties, expected) def test_createComponentLayoutRecommendations_addService_1freeHost(self): """ Test that already installed slaves are not added to any free hosts (not having any component installed) as part of recommendation received during Add service operation. For already installed services, recommendation for installed components should match the existing layout """ services = { "services" : [ { "StackServices" : { "service_name" : "HDFS" }, "components" : [ { "StackServiceComponents" : { "cardinality" : "1+", "component_category" : "SLAVE", "component_name" : "DATANODE", "hostnames" : [ "c6401.ambari.apache.org" ] } } ] } ] } hosts = self.prepareHosts(["c6401.ambari.apache.org", "c6402.ambari.apache.org"]) recommendations = self.stackAdvisor.createComponentLayoutRecommendations(services, hosts) """ Recommendation received should be as below: { 'blueprint': { 'host_groups': [{ 'name': 'host-group-1', 'components': [] }, { 'name': 'host-group-2', 'components': [{ 'name': 'DATANODE' }] }] }, 'blueprint_cluster_binding': { 'host_groups': [{ 'hosts': [{ 'fqdn': 'c6402.ambari.apache.org' }], 'name': 'host-group-1' }, { 'hosts': [{ 'fqdn': 'c6401.ambari.apache.org' }], 'name': 'host-group-2' }] } } """ # Assert that the list is empty for host-group-1 self.assertFalse(recommendations['blueprint']['host_groups'][0]['components']) # Assert that DATANODE is placed on host-group-2 self.assertEquals(recommendations['blueprint']['host_groups'][1]['components'][0]['name'], 'DATANODE')

6a8f6efd4560f4b302cef1f8c07a3c86f509c35d

py

Python

debugging/code/multiprocess_main.py

awesome-archive/python-debugging-skills

69af455302a805d6f198a06ea934f79d5913cb3e

debugging/code/multiprocess_main.py

awesome-archive/python-debugging-skills

69af455302a805d6f198a06ea934f79d5913cb3e

debugging/code/multiprocess_main.py

awesome-archive/python-debugging-skills

69af455302a805d6f198a06ea934f79d5913cb3e

# -*- encoding: utf-8 -*- import multiprocessing as mp import time from pudb.remote import set_trace def worker(worker_id): """ Simple worker process""" i = 0 while i < 10: if worker_id == 1: # debug process with id 1 set_trace(term_size=(80, 24)) time.sleep(1) # represents some work print('In Process {}, i:{}'.format(worker_id, i)) i = i + 1 if __name__ == '__main__': processes = [] for p_id in range(2): # 2 worker processes p = mp.Process(target=worker, args=(p_id,)) p.start() processes.append(p) for p in processes: p.join()

6a8fb5db5439c528b72c62e081f71f595115b9ad

py

Python

lldb/packages/Python/lldbsuite/test/expression_command/anonymous-struct/TestCallUserAnonTypedef.py

bytesnake/Enzyme

247606c279920d476645d2e319e574bf8be10fc9

lldb/packages/Python/lldbsuite/test/expression_command/anonymous-struct/TestCallUserAnonTypedef.py

bytesnake/Enzyme

247606c279920d476645d2e319e574bf8be10fc9

lldb/packages/Python/lldbsuite/test/expression_command/anonymous-struct/TestCallUserAnonTypedef.py

bytesnake/Enzyme

247606c279920d476645d2e319e574bf8be10fc9

""" Test calling user defined functions using expression evaluation. This test checks that typesystem lookup works correctly for typedefs of untagged structures. Ticket: https://llvm.org/bugs/show_bug.cgi?id=26790 """ from __future__ import print_function import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil class TestExprLookupAnonStructTypedef(TestBase): mydir = TestBase.compute_mydir(__file__) def setUp(self): TestBase.setUp(self) # Find the breakpoint self.line = line_number('main.cpp', '// lldb testsuite break') @expectedFailureAll(oslist=["windows"]) @expectedFailureAll( oslist=['linux'], archs=['arm'], bugnumber="llvm.org/pr27868") def test(self): """Test typedeffed untagged struct arguments for function call expressions""" self.build() self.runCmd("file "+self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) lldbutil.run_break_set_by_file_and_line( self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True ) self.runCmd("run", RUN_SUCCEEDED) self.expect("expr multiply(&s)", substrs=['$0 = 1'])

6a8fddf8511ca7d429d8644119f475536d5dae17

py

Python

main.py

ThomasDLi/simple-photo-editor

f8b3f1025155e2542b93b94c12d607b9b5e45731

2021-05-21T19:21:26.000Z

2021-05-21T19:21:26.000Z

main.py

ThomasDLi/simple-photo-editor

f8b3f1025155e2542b93b94c12d607b9b5e45731

main.py

ThomasDLi/simple-photo-editor

f8b3f1025155e2542b93b94c12d607b9b5e45731

from PIL import Image, ImageEnhance user_account_name = "Thomas.Li26" def main(): mode = input("Specify image editing mode. Type DEEPFRY, STRETCH, BRIGHTNESS, SHARPEN, or INVERT: ") if mode == "DEEPFRY": DEEPFRY() if mode == "STRETCH": STRETCH() if mode == "INVERT": INVERT() if mode == "BRIGHTNESS": BRIGHTNESS() if mode == "SHARPEN": SHARPEN() def DEEPFRY(): img = input("Insert the name of an image found in the Downloads folder (for example: Image.png): ") im = Image.open(r"C:\Users\{}\Downloads\{}".format(user_account_name, img)) enhancer = ImageEnhance.Contrast(im) factor = float(input("Specify deepfry amount (0-100): ")) im_output = enhancer.enhance(factor) im_output.save('more-contrast-image.png') im_output.show() def STRETCH(): img = input("Insert the name of an image found in the Downloads folder (for example: Image.png): ") im = Image.open(r"C:\Users\{}\Downloads\{}".format(user_account_name, img)) factor = int(input("Specify width: ")) factor2 = int(input("Specify height: ")) im_output = im.resize((factor,factor2)) im_output.save('more-contrast-image.png') im_output.show() def INVERT(): img = input("Insert the name of an image found in the Downloads folder (for example: Image.png): ") im = Image.open(r"C:\Users\{}\Downloads\{}".format(user_account_name, img)) enhancer = ImageEnhance.Contrast(im) im_output = enhancer.enhance(-1) im_output.save('more-contrast-image.png') im_output.show() def BRIGHTNESS(): img = input("Insert the name of an image found in the Downloads folder (for example: Image.png): ") im = Image.open(r"C:\Users\{}\Downloads\{}".format(user_account_name, img)) enhancer = ImageEnhance.Brightness(im) factor = float(input("Specify brightness amount: ")) im_output = enhancer.enhance(factor) im_output.save('more-contrast-image.png') im_output.show() def SHARPEN(): img = input("Insert the name of an image found in the Downloads folder (for example: Image.png): ") im = Image.open(r"C:\Users\{}\Downloads\{}".format(user_account_name, img)) enhancer = ImageEnhance.Sharpness(im) factor = float(input("Specify sharpening amount: ")) im_output = enhancer.enhance(factor) im_output.save('more-contrast-image.png') im_output.show() if __name__ == "__main__": main()

6a90540c04aa6d7b6d0419ad6f3c05ff1c4aa797

py

Python

scripts/field/Curbrock_Summon1.py

G00dBye/YYMS

1de816fc842b6598d5b4b7896b6ab0ee8f7cdcfb

2019-04-16T23:24:48.000Z

2021-12-18T11:41:50.000Z

scripts/field/Curbrock_Summon1.py

G00dBye/YYMS

1de816fc842b6598d5b4b7896b6ab0ee8f7cdcfb

2019-05-19T15:19:41.000Z

2020-04-27T16:29:16.000Z

scripts/field/Curbrock_Summon1.py

G00dBye/YYMS

1de816fc842b6598d5b4b7896b6ab0ee8f7cdcfb

2020-11-25T23:29:16.000Z

2022-03-26T16:20:24.000Z

# Curbrock Summon 2 CURBROCK2 = 9400930 # MOD ID CURBROCKS_ESCAPE_ROUTE_VER2 = 600050040 # MAP ID CURBROCKS_ESCAPE_ROUTE_VER3 = 600050050 # MAP ID 2 sm.spawnMob(CURBROCK2, 190, -208, False) sm.createClock(1800) sm.addEvent(sm.invokeAfterDelay(1800000, "warp", CURBROCKS_ESCAPE_ROUTE_VER3, 0)) sm.waitForMobDeath(CURBROCK2) sm.warp(CURBROCKS_ESCAPE_ROUTE_VER2) sm.stopEvents()

6a9096da46f0e3f90b72b1a819bf62ce11ddc6bd

py

Python

trainloops/listeners/cluster_killswitch.py

Gerryflap/master_thesis

5dc16e21b23837fee8a4532679bb5cb961af0b7c

trainloops/listeners/cluster_killswitch.py

Gerryflap/master_thesis

5dc16e21b23837fee8a4532679bb5cb961af0b7c

trainloops/listeners/cluster_killswitch.py

Gerryflap/master_thesis

5dc16e21b23837fee8a4532679bb5cb961af0b7c

""" Cancelling jobs on the University cluster forces programs to instantly quit, which sometimes crashes cluster nodes. As a remedy, this killswitch listener will stop the experiment in a nicer way to prevent this from happening. The experiment will be stopped if a file named "stop" is encountered in the results folder of the experiment. The existence of this file is checked after each epoch. """ import os from trainloops.listeners.listener import Listener class KillSwitchListener(Listener): def __init__(self, experiment_path): super().__init__() self.path = os.path.join(experiment_path, "stop") def initialize(self): pass def report(self, state_dict): if os.path.exists(self.path): exit()

6a920dacf31156e85a0fcebb52765a1d1ca683fe

py

Python

authors/apps/notifications/views.py

andela/ah-backend-spaces-

58e031a96a6b9555f1a4133cf8cb688c236d3f3b

2018-08-17T15:47:36.000Z

2018-09-13T13:58:34.000Z

authors/apps/notifications/views.py

andela/ah-backend-spaces-

58e031a96a6b9555f1a4133cf8cb688c236d3f3b

2018-07-24T11:42:53.000Z

2021-06-10T20:34:41.000Z

authors/apps/notifications/views.py

andela/ah-backend-spaces-

58e031a96a6b9555f1a4133cf8cb688c236d3f3b

2018-07-17T13:05:35.000Z

2018-09-06T16:03:52.000Z

from rest_framework import status from rest_framework.generics import ( RetrieveUpdateAPIView, CreateAPIView, RetrieveUpdateDestroyAPIView ) from rest_framework.permissions import AllowAny, IsAuthenticated from rest_framework.response import Response from rest_framework.views import APIView from ..authentication.backends import JWTAuthentication from ..authentication.models import User from .models import Notifications from .renderers import ( NotificationsJSONRenderer ) from .serializers import ( NotificationsAPIViewSerializer, GetNotificationsAPIViewSerializer ) class NotificationsAPIView(RetrieveUpdateAPIView): permission_classes = (IsAuthenticated,) renderer_classes = (NotificationsJSONRenderer,) def put(self, request): """ This class method is used to update a users article """ serializer_class = NotificationsAPIViewSerializer notification = request.data.get('notification', {}) user_data = JWTAuthentication().authenticate(request) # append user_id from token to article variable for later validations in serializers notification["user_id"] = user_data[1] serializer = serializer_class(data=notification) serializer.is_valid(raise_exception=True) # update the notification statue to True serializer.update_read_status(serializer.data["notifications"]) return Response(serializer.data, status=status.HTTP_201_CREATED) def get(self, request): """ retrieve all notifications of a user """ # decode users authentication token user_data = JWTAuthentication().authenticate(request) # get user notifications details from the Notifications table in the database notifications = Notifications.objects.filter(notification_owner=user_data[1]).values( "id", "article_id", "notification_title", "notification_body", "notification_owner", "read_status" ) # create a list of notifications # the action below is done by use of list comprehension list_of_notifications = [i for i in notifications] return Response({"notifications": list_of_notifications}, status=status.HTTP_200_OK)

6a921ec9df90e9d0bc4821cbf3d19c03f4f29792

py

Python

scripts/common/frozendict.py

bopopescu/build

4e95fd33456e552bfaf7d94f7d04b19273d1c534

scripts/common/frozendict.py

bopopescu/build

4e95fd33456e552bfaf7d94f7d04b19273d1c534

scripts/common/frozendict.py

bopopescu/build

4e95fd33456e552bfaf7d94f7d04b19273d1c534

2020-07-23T11:05:06.000Z

2020-07-23T11:05:06.000Z

# Copyright 2014 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Implements a frozen dictionary-like object""" import collections import copy import common.memo as memo class frozendict(collections.Mapping): """A frozen dictionary class""" def __init__(self, *args, **kwargs): self._data = dict(*args, **kwargs) def __iter__(self): return iter(self._data) def __len__(self): return len(self._data) def __getitem__(self, key): return self._data[key] @memo.memo_i() def __hash__(self): return hash(self.itemtuple()) def __str__(self): return str(self._data) def __repr__(self): return '%s(%s)' % (type(self).__name__, str(self)) def __eq__(self, other): return self._data == other def __ne__(self, other): return not self == other def __deepcopy__(self, _memo): return copy.deepcopy(self._data) @memo.memo_i() def itemtuple(self): return tuple(sorted(self.iteritems())) def mutableDict(self): """ Returns a mutable dictionary copy, replacing 'frozendict' with 'dict's. This function uses the 'copy.deepcopy' method to create a mutable deep copy of the dictionary. Note that due to the one-size-fits-all behavior of 'deepcopy', the result can be anything from heavyhanded to incorrect depending on the contents of the dictionary. The caller should make sure they understand the operation and its behavior on all of the dictionary's subtypes before using it. Returns: (dict) A mutable clone of the dictionary and its members. """ return copy.deepcopy(self) def extend(self, **kwargs): """Returns a copy of this object with the 'kwargs' fields updated.""" ndata = self.mutableDict() ndata.update(kwargs) return type(self)(**ndata)

6a92b244776a352d3c8cb2387f8e203d0ce669c3

py

Python

avatar/__init__.py

yogeshkheri/geonode-avatar

293474f814117ae680278223c8cdf8d59c67862d

2021-10-17T20:37:40.000Z

2022-03-17T10:29:14.000Z

avatar/__init__.py

yogeshkheri/geonode-avatar

293474f814117ae680278223c8cdf8d59c67862d

2021-09-02T13:26:11.000Z

2022-03-16T12:26:36.000Z

avatar/__init__.py

yogeshkheri/geonode-avatar

293474f814117ae680278223c8cdf8d59c67862d

__version__ = '5.0.2'

6a9450d0c04cca0024a14e15346193d320a70e58

py

Python

__init__.py

mmanganel/neurecon

5e86324675985f1fedfc4d5d3ac2e750f480538f

__init__.py

mmanganel/neurecon

5e86324675985f1fedfc4d5d3ac2e750f480538f

__init__.py

mmanganel/neurecon

5e86324675985f1fedfc4d5d3ac2e750f480538f

from neurecon.reconstruction import reconstruct

6a94a7cd3e89c26bee4c47c7741e5a37358da6ff

py

Python

Fundamentals/Reversed Strings.py

gnvidal/Codewars

117a83bd949a1503f31f1f915641e96e7bf7a04c

2018-04-30T06:42:45.000Z

2021-07-22T16:39:02.000Z

Fundamentals/Reversed Strings.py

gnvidal/Codewars

117a83bd949a1503f31f1f915641e96e7bf7a04c

2020-08-31T02:36:53.000Z

2020-08-31T10:14:00.000Z

Fundamentals/Reversed Strings.py

gnvidal/Codewars

117a83bd949a1503f31f1f915641e96e7bf7a04c

2016-11-07T19:59:58.000Z

2022-03-31T11:18:27.000Z

def solution(string): return string[::-1]

6a95707999c6dd8d718ea3549fc898fb5e496ed8

py

Python

python/flexflow/keras/datasets/cifar.py

zmxdream/FlexFlow

7ea50d71a02e853af7ae573d88c911511b3e82e0

2018-12-09T01:57:46.000Z

2022-03-22T01:56:47.000Z

python/flexflow/keras/datasets/cifar.py

zmxdream/FlexFlow

7ea50d71a02e853af7ae573d88c911511b3e82e0

2019-04-19T08:24:27.000Z

2022-03-28T01:39:19.000Z

python/flexflow/keras/datasets/cifar.py

zmxdream/FlexFlow

7ea50d71a02e853af7ae573d88c911511b3e82e0

2018-12-22T07:38:05.000Z

2022-03-30T06:04:39.000Z

# -*- coding: utf-8 -*- """Utilities common to CIFAR10 and CIFAR100 datasets. """ from __future__ import absolute_import from __future__ import division from __future__ import print_function import sys from six.moves import cPickle def load_batch(fpath, label_key='labels'): """Internal utility for parsing CIFAR data. # Arguments fpath: path the file to parse. label_key: key for label data in the retrieve dictionary. # Returns A tuple `(data, labels)`. """ with open(fpath, 'rb') as f: if sys.version_info < (3,): d = cPickle.load(f) else: d = cPickle.load(f, encoding='bytes') # decode utf8 d_decoded = {} for k, v in d.items(): d_decoded[k.decode('utf8')] = v d = d_decoded data = d['data'] labels = d[label_key] data = data.reshape(data.shape[0], 3, 32, 32) return data, labels

6a96000d55f22510def511958af1f99b01dba806

py

Python

day7/p2.py

Seralpa/Advent-of-code

9633624e4ff48c50d8be3deac54c83059e9c3b04

2020-12-18T16:06:25.000Z

2020-12-18T16:06:25.000Z

day7/p2.py

Seralpa/Advent-of-code

9633624e4ff48c50d8be3deac54c83059e9c3b04

day7/p2.py

Seralpa/Advent-of-code

9633624e4ff48c50d8be3deac54c83059e9c3b04

def getNumBags(color): if color=='': return 0 numBags=1 for bag in rules[color]: numBags+=bag[1]*getNumBags(bag[0]) return numBags with open('day7/input.txt') as f: rules=dict([l.split(' contain') for l in f.read().replace(' bags', '').replace(' bag', '').replace('.', '').replace(' no other', '0 ').splitlines()]) for key in rules: rules[key]=[(d[2:].strip(), int(d[:2].strip())) for d in rules[key].split(', ')] print(getNumBags('shiny gold')-1) #-1 cause shiny bag not included

6a9611abd97c536f926ca250cbefadb44ebcbbc2

py

Python

adv/luther.py

6tennis/dl

69eb7e71da9fabe9e7ec40c461b525b4f967f345

adv/luther.py

6tennis/dl

69eb7e71da9fabe9e7ec40c461b525b4f967f345

adv/luther.py

6tennis/dl

69eb7e71da9fabe9e7ec40c461b525b4f967f345

from core.advbase import * from slot.d import * def module(): return Luther class Luther(Adv): a1 = ('cc',0.10,'hit15') conf = {} conf ['slots.d'] = Leviathan() conf['acl'] = """ `dragon `s1 `s2, seq=5 and cancel `s3, seq=5 and cancel or fsc `fs, seq=5 """ coab = ['Blade', 'Xander', 'Tiki'] if __name__ == '__main__': from core.simulate import test_with_argv test_with_argv(None, *sys.argv)

6a9615693970b5561756763d7533ebc0f325ce0c

py

Python

wandb/sdk/data_types/image.py

macio232/client

295380c99b1a0946470672d40348b17a674ad17f

wandb/sdk/data_types/image.py

macio232/client

295380c99b1a0946470672d40348b17a674ad17f

wandb/sdk/data_types/image.py

macio232/client

295380c99b1a0946470672d40348b17a674ad17f

import hashlib from io import BytesIO import logging import os from typing import Any, cast, Dict, List, Optional, Sequence, Type, TYPE_CHECKING, Union from pkg_resources import parse_version import wandb from wandb import util from ._private import MEDIA_TMP from .base_types.media import BatchableMedia, Media from .helper_types.bounding_boxes_2d import BoundingBoxes2D from .helper_types.classes import Classes from .helper_types.image_mask import ImageMask if TYPE_CHECKING: # pragma: no cover import matplotlib # type: ignore import numpy as np # type: ignore import PIL # type: ignore import torch # type: ignore from wandb.apis.public import Artifact as PublicArtifact from ..wandb_artifacts import Artifact as LocalArtifact from ..wandb_run import Run as LocalRun ImageDataType = Union[ "matplotlib.artist.Artist", "PIL.Image", "TorchTensorType", "np.ndarray" ] ImageDataOrPathType = Union[str, "Image", ImageDataType] TorchTensorType = Union["torch.Tensor", "torch.Variable"] def _server_accepts_image_filenames() -> bool: # Newer versions of wandb accept large image filenames arrays # but older versions would have issues with this. max_cli_version = util._get_max_cli_version() if max_cli_version is None: return False return parse_version("0.12.10") <= parse_version(max_cli_version) class Image(BatchableMedia): """Format images for logging to W&B. Arguments: data_or_path: (numpy array, string, io) Accepts numpy array of image data, or a PIL image. The class attempts to infer the data format and converts it. mode: (string) The PIL mode for an image. Most common are "L", "RGB", "RGBA". Full explanation at https://pillow.readthedocs.io/en/4.2.x/handbook/concepts.html#concept-modes. caption: (string) Label for display of image. Examples: ### Create a wandb.Image from a numpy array <!--yeadoc-test:log-image-numpy-> ```python import numpy as np import wandb wandb.init() examples = [] for i in range(3): pixels = np.random.randint(low=0, high=256, size=(100, 100, 3)) image = wandb.Image(pixels, caption=f"random field {i}") examples.append(image) wandb.log({"examples": examples}) ``` ### Create a wandb.Image from a PILImage <!--yeadoc-test:log-image-pil-> ```python import numpy as np from PIL import Image as PILImage import wandb wandb.init() examples = [] for i in range(3): pixels = np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8) pil_image = PILImage.fromarray(pixels, mode="RGB") image = wandb.Image(pil_image, caption=f"random field {i}") examples.append(image) wandb.log({"examples": examples}) ``` """ MAX_ITEMS = 108 # PIL limit MAX_DIMENSION = 65500 _log_type = "image-file" format: Optional[str] _grouping: Optional[int] _caption: Optional[str] _width: Optional[int] _height: Optional[int] _image: Optional["PIL.Image"] _classes: Optional["Classes"] _boxes: Optional[Dict[str, "BoundingBoxes2D"]] _masks: Optional[Dict[str, "ImageMask"]] def __init__( self, data_or_path: "ImageDataOrPathType", mode: Optional[str] = None, caption: Optional[str] = None, grouping: Optional[int] = None, classes: Optional[Union["Classes", Sequence[dict]]] = None, boxes: Optional[Union[Dict[str, "BoundingBoxes2D"], Dict[str, dict]]] = None, masks: Optional[Union[Dict[str, "ImageMask"], Dict[str, dict]]] = None, ) -> None: super(Image, self).__init__() # TODO: We should remove grouping, it's a terrible name and I don't # think anyone uses it. self._grouping = None self._caption = None self._width = None self._height = None self._image = None self._classes = None self._boxes = None self._masks = None # Allows the user to pass an Image object as the first parameter and have a perfect copy, # only overriding additional metdata passed in. If this pattern is compelling, we can generalize. if isinstance(data_or_path, Image): self._initialize_from_wbimage(data_or_path) elif isinstance(data_or_path, str): self._initialize_from_path(data_or_path) else: self._initialize_from_data(data_or_path, mode) self._set_initialization_meta(grouping, caption, classes, boxes, masks) def _set_initialization_meta( self, grouping: Optional[int] = None, caption: Optional[str] = None, classes: Optional[Union["Classes", Sequence[dict]]] = None, boxes: Optional[Union[Dict[str, "BoundingBoxes2D"], Dict[str, dict]]] = None, masks: Optional[Union[Dict[str, "ImageMask"], Dict[str, dict]]] = None, ) -> None: if grouping is not None: self._grouping = grouping if caption is not None: self._caption = caption total_classes = {} if boxes: if not isinstance(boxes, dict): raise ValueError('Images "boxes" argument must be a dictionary') boxes_final: Dict[str, BoundingBoxes2D] = {} for key in boxes: box_item = boxes[key] if isinstance(box_item, BoundingBoxes2D): boxes_final[key] = box_item elif isinstance(box_item, dict): # TODO: Consider injecting top-level classes if user-provided is empty boxes_final[key] = BoundingBoxes2D(box_item, key) total_classes.update(boxes_final[key]._class_labels) self._boxes = boxes_final if masks: if not isinstance(masks, dict): raise ValueError('Images "masks" argument must be a dictionary') masks_final: Dict[str, ImageMask] = {} for key in masks: mask_item = masks[key] if isinstance(mask_item, ImageMask): masks_final[key] = mask_item elif isinstance(mask_item, dict): # TODO: Consider injecting top-level classes if user-provided is empty masks_final[key] = ImageMask(mask_item, key) if hasattr(masks_final[key], "_val"): total_classes.update(masks_final[key]._val["class_labels"]) self._masks = masks_final if classes is not None: if isinstance(classes, Classes): total_classes.update( {val["id"]: val["name"] for val in classes._class_set} ) else: total_classes.update({val["id"]: val["name"] for val in classes}) if len(total_classes.keys()) > 0: self._classes = Classes( [ {"id": key, "name": total_classes[key]} for key in total_classes.keys() ] ) self._width, self._height = self.image.size # type: ignore self._free_ram() def _initialize_from_wbimage(self, wbimage: "Image") -> None: self._grouping = wbimage._grouping self._caption = wbimage._caption self._width = wbimage._width self._height = wbimage._height self._image = wbimage._image self._classes = wbimage._classes self._path = wbimage._path self._is_tmp = wbimage._is_tmp self._extension = wbimage._extension self._sha256 = wbimage._sha256 self._size = wbimage._size self.format = wbimage.format self._artifact_source = wbimage._artifact_source self._artifact_target = wbimage._artifact_target # We do not want to implicitly copy boxes or masks, just the image-related data. # self._boxes = wbimage._boxes # self._masks = wbimage._masks def _initialize_from_path(self, path: str) -> None: pil_image = util.get_module( "PIL.Image", required='wandb.Image needs the PIL package. To get it, run "pip install pillow".', ) self._set_file(path, is_tmp=False) self._image = pil_image.open(path) self._image.load() ext = os.path.splitext(path)[1][1:] self.format = ext def _initialize_from_data(self, data: "ImageDataType", mode: str = None,) -> None: pil_image = util.get_module( "PIL.Image", required='wandb.Image needs the PIL package. To get it, run "pip install pillow".', ) if util.is_matplotlib_typename(util.get_full_typename(data)): buf = BytesIO() util.ensure_matplotlib_figure(data).savefig(buf) self._image = pil_image.open(buf) elif isinstance(data, pil_image.Image): self._image = data elif util.is_pytorch_tensor_typename(util.get_full_typename(data)): vis_util = util.get_module( "torchvision.utils", "torchvision is required to render images" ) if hasattr(data, "requires_grad") and data.requires_grad: data = data.detach() data = vis_util.make_grid(data, normalize=True) self._image = pil_image.fromarray( data.mul(255).clamp(0, 255).byte().permute(1, 2, 0).cpu().numpy() ) else: if hasattr(data, "numpy"): # TF data eager tensors data = data.numpy() if data.ndim > 2: data = data.squeeze() # get rid of trivial dimensions as a convenience self._image = pil_image.fromarray( self.to_uint8(data), mode=mode or self.guess_mode(data) ) tmp_path = os.path.join(MEDIA_TMP.name, str(util.generate_id()) + ".png") self.format = "png" self._image.save(tmp_path, transparency=None) self._set_file(tmp_path, is_tmp=True) @classmethod def from_json( cls: Type["Image"], json_obj: dict, source_artifact: "PublicArtifact" ) -> "Image": classes = None if json_obj.get("classes") is not None: classes = source_artifact.get(json_obj["classes"]["path"]) masks = json_obj.get("masks") _masks: Optional[Dict[str, ImageMask]] = None if masks: _masks = {} for key in masks: _masks[key] = ImageMask.from_json(masks[key], source_artifact) _masks[key]._set_artifact_source(source_artifact) _masks[key]._key = key boxes = json_obj.get("boxes") _boxes: Optional[Dict[str, BoundingBoxes2D]] = None if boxes: _boxes = {} for key in boxes: _boxes[key] = BoundingBoxes2D.from_json(boxes[key], source_artifact) _boxes[key]._key = key return cls( source_artifact.get_path(json_obj["path"]).download(), caption=json_obj.get("caption"), grouping=json_obj.get("grouping"), classes=classes, boxes=_boxes, masks=_masks, ) @classmethod def get_media_subdir(cls: Type["Image"]) -> str: return os.path.join("media", "images") def bind_to_run( self, run: "LocalRun", key: Union[int, str], step: Union[int, str], id_: Optional[Union[int, str]] = None, ignore_copy_err: Optional[bool] = None, ) -> None: super().bind_to_run(run, key, step, id_, ignore_copy_err=ignore_copy_err) if self._boxes is not None: for i, k in enumerate(self._boxes): id_ = "{}{}".format(id_, i) if id_ is not None else None self._boxes[k].bind_to_run( run, key, step, id_, ignore_copy_err=ignore_copy_err ) if self._masks is not None: for i, k in enumerate(self._masks): id_ = "{}{}".format(id_, i) if id_ is not None else None self._masks[k].bind_to_run( run, key, step, id_, ignore_copy_err=ignore_copy_err ) def to_json(self, run_or_artifact: Union["LocalRun", "LocalArtifact"]) -> dict: json_dict = super(Image, self).to_json(run_or_artifact) json_dict["_type"] = Image._log_type json_dict["format"] = self.format if self._width is not None: json_dict["width"] = self._width if self._height is not None: json_dict["height"] = self._height if self._grouping: json_dict["grouping"] = self._grouping if self._caption: json_dict["caption"] = self._caption if isinstance(run_or_artifact, wandb.wandb_sdk.wandb_artifacts.Artifact): artifact = run_or_artifact if ( self._masks is not None or self._boxes is not None ) and self._classes is None: raise ValueError( "classes must be passed to wandb.Image which have masks or bounding boxes when adding to artifacts" ) if self._classes is not None: class_id = hashlib.md5( str(self._classes._class_set).encode("utf-8") ).hexdigest() class_name = os.path.join("media", "classes", class_id + "_cls",) classes_entry = artifact.add(self._classes, class_name) json_dict["classes"] = { "type": "classes-file", "path": classes_entry.path, "digest": classes_entry.digest, } elif not isinstance(run_or_artifact, wandb.wandb_sdk.wandb_run.Run): raise ValueError("to_json accepts wandb_run.Run or wandb_artifact.Artifact") if self._boxes: json_dict["boxes"] = { k: box.to_json(run_or_artifact) for (k, box) in self._boxes.items() } if self._masks: json_dict["masks"] = { k: mask.to_json(run_or_artifact) for (k, mask) in self._masks.items() } return json_dict def guess_mode(self, data: "np.ndarray") -> str: """ Guess what type of image the np.array is representing """ # TODO: do we want to support dimensions being at the beginning of the array? if data.ndim == 2: return "L" elif data.shape[-1] == 3: return "RGB" elif data.shape[-1] == 4: return "RGBA" else: raise ValueError( "Un-supported shape for image conversion %s" % list(data.shape) ) @classmethod def to_uint8(cls, data: "np.ndarray") -> "np.ndarray": """ Converts floating point image on the range [0,1] and integer images on the range [0,255] to uint8, clipping if necessary. """ np = util.get_module( "numpy", required="wandb.Image requires numpy if not supplying PIL Images: pip install numpy", ) # I think it's better to check the image range vs the data type, since many # image libraries will return floats between 0 and 255 # some images have range -1...1 or 0-1 dmin = np.min(data) if dmin < 0: data = (data - np.min(data)) / np.ptp(data) if np.max(data) <= 1.0: data = (data * 255).astype(np.int32) # assert issubclass(data.dtype.type, np.integer), 'Illegal image format.' return data.clip(0, 255).astype(np.uint8) @classmethod def seq_to_json( cls: Type["Image"], seq: Sequence["BatchableMedia"], run: "LocalRun", key: str, step: Union[int, str], ) -> dict: """ Combines a list of images into a meta dictionary object describing the child images. """ if TYPE_CHECKING: seq = cast(Sequence["Image"], seq) jsons = [obj.to_json(run) for obj in seq] media_dir = cls.get_media_subdir() for obj in jsons: expected = util.to_forward_slash_path(media_dir) if not obj["path"].startswith(expected): raise ValueError( "Files in an array of Image's must be in the {} directory, not {}".format( cls.get_media_subdir(), obj["path"] ) ) num_images_to_log = len(seq) width, height = seq[0].image.size # type: ignore format = jsons[0]["format"] def size_equals_image(image: "Image") -> bool: img_width, img_height = image.image.size # type: ignore return img_width == width and img_height == height # type: ignore sizes_match = all(size_equals_image(img) for img in seq) if not sizes_match: logging.warning( "Images sizes do not match. This will causes images to be display incorrectly in the UI." ) meta = { "_type": "images/separated", "width": width, "height": height, "format": format, "count": num_images_to_log, } if _server_accepts_image_filenames(): meta["filenames"] = [obj["path"] for obj in jsons] else: wandb.termwarn( "Unable to log image array filenames. In some cases, this can prevent images from being" "viewed in the UI. Please upgrade your wandb server", repeat=False, ) captions = Image.all_captions(seq) if captions: meta["captions"] = captions all_masks = Image.all_masks(seq, run, key, step) if all_masks: meta["all_masks"] = all_masks all_boxes = Image.all_boxes(seq, run, key, step) if all_boxes: meta["all_boxes"] = all_boxes return meta @classmethod def all_masks( cls: Type["Image"], images: Sequence["Image"], run: "LocalRun", run_key: str, step: Union[int, str], ) -> Union[List[Optional[dict]], bool]: all_mask_groups: List[Optional[dict]] = [] for image in images: if image._masks: mask_group = {} for k in image._masks: mask = image._masks[k] mask_group[k] = mask.to_json(run) all_mask_groups.append(mask_group) else: all_mask_groups.append(None) if all_mask_groups and not all(x is None for x in all_mask_groups): return all_mask_groups else: return False @classmethod def all_boxes( cls: Type["Image"], images: Sequence["Image"], run: "LocalRun", run_key: str, step: Union[int, str], ) -> Union[List[Optional[dict]], bool]: all_box_groups: List[Optional[dict]] = [] for image in images: if image._boxes: box_group = {} for k in image._boxes: box = image._boxes[k] box_group[k] = box.to_json(run) all_box_groups.append(box_group) else: all_box_groups.append(None) if all_box_groups and not all(x is None for x in all_box_groups): return all_box_groups else: return False @classmethod def all_captions( cls: Type["Image"], images: Sequence["Media"] ) -> Union[bool, Sequence[Optional[str]]]: return cls.captions(images) def __ne__(self, other: object) -> bool: return not self.__eq__(other) def __eq__(self, other: object) -> bool: if not isinstance(other, Image): return False else: self_image = self.image other_image = other.image if self_image is not None: self_image = list(self_image.getdata()) if other_image is not None: other_image = list(other_image.getdata()) return ( self._grouping == other._grouping and self._caption == other._caption and self._width == other._width and self._height == other._height and self_image == other_image and self._classes == other._classes ) def to_data_array(self) -> List[Any]: res = [] if self.image is not None: data = list(self.image.getdata()) for i in range(self.image.height): res.append(data[i * self.image.width : (i + 1) * self.image.width]) self._free_ram() return res def _free_ram(self) -> None: if self._path is not None: self._image = None @property def image(self) -> Optional["PIL.Image"]: if self._image is None: if self._path is not None: pil_image = util.get_module( "PIL.Image", required='wandb.Image needs the PIL package. To get it, run "pip install pillow".', ) self._image = pil_image.open(self._path) self._image.load() return self._image

6a961a7708b268c3d81ea73ab8b93515bd578d6c

py

Python

src/ACC_Backend_Utils.py

skostic14/isda-racing-backend

41b5f9760dc17a29aa8ab5e4cc1894a27496a72c

2021-07-29T05:29:06.000Z

2021-07-29T05:29:06.000Z

src/ACC_Backend_Utils.py

skostic14/isda-racing-backend

41b5f9760dc17a29aa8ab5e4cc1894a27496a72c

src/ACC_Backend_Utils.py

skostic14/isda-racing-backend

41b5f9760dc17a29aa8ab5e4cc1894a27496a72c

import datetime # Gets time from milliseconds # Returns string formatted as HH:MM:SS:mmm, MM:SS:mmm or S:mmm, depending on the time. def get_time_from_milliseconds(milli): milliseconds = milli % 1000 seconds= (milli//1000)%60 minutes= (milli//(1000*60))%60 hours= (milli//(1000*60*60))%24 if hours == 0: if minutes == 0: return '%d.%03d' % (seconds, milliseconds) return '%02d:%02d.%03d' % (minutes, seconds, milliseconds) return '%02d:%02d:%02d.%03d' % (hours, minutes, seconds, milliseconds) # Returns a string formatted as YYYY-MM-DD def get_date_today(): return datetime.date.today().strftime("%Y-%m-%d")

6a961b6b72524b941aa7777c8c1e4c9ea87f76f0

py

Python

examples/advanced/pidigits.py

ovolve/sympy

0a15782f20505673466b940454b33b8014a25c13

2015-01-17T23:15:04.000Z

2015-05-26T14:11:44.000Z

examples/advanced/pidigits.py

ovolve/sympy

0a15782f20505673466b940454b33b8014a25c13

2015-03-23T23:33:02.000Z

2019-02-09T00:19:41.000Z

examples/advanced/pidigits.py

ovolve/sympy

0a15782f20505673466b940454b33b8014a25c13

2019-10-18T12:39:41.000Z

2019-10-18T12:39:41.000Z

#!/usr/bin/env python """Pi digits example Example shows arbitrary precision using mpmath with the computation of the digits of pi. """ from mpmath import libmp, pi from mpmath import functions as mpf_funs import math from time import clock import sys def display_fraction(digits, skip=0, colwidth=10, columns=5): """Pretty printer for first n digits of a fraction""" perline = colwidth * columns printed = 0 for linecount in range((len(digits) - skip) // (colwidth * columns)): line = digits[skip + linecount*perline:skip + (linecount + 1)*perline] for i in range(columns): print(line[i*colwidth: (i + 1)*colwidth],) print(":", (linecount + 1)*perline) if (linecount + 1) % 10 == 0: print printed += colwidth*columns rem = (len(digits) - skip) % (colwidth * columns) if rem: buf = digits[-rem:] s = "" for i in range(columns): s += buf[:colwidth].ljust(colwidth + 1, " ") buf = buf[colwidth:] print(s + ":", printed + colwidth*columns) def calculateit(func, base, n, tofile): """Writes first n base-digits of a mpmath function to file""" prec = 100 intpart = libmp.numeral(3, base) if intpart == 0: skip = 0 else: skip = len(intpart) print("Step 1 of 2: calculating binary value...") prec = int(n*math.log(base, 2)) + 10 t = clock() a = func(prec) step1_time = clock() - t print("Step 2 of 2: converting to specified base...") t = clock() d = libmp.bin_to_radix(a.man, -a.exp, base, n) d = libmp.numeral(d, base, n) step2_time = clock() - t print("\nWriting output...\n") if tofile: out_ = sys.stdout sys.stdout = tofile print("%i base-%i digits of pi:\n" % (n, base)) print(intpart, ".\n") display_fraction(d, skip, colwidth=10, columns=5) if tofile: sys.stdout = out_ print("\nFinished in %f seconds (%f calc, %f convert)" % \ ((step1_time + step2_time), step1_time, step2_time)) def interactive(): """Simple function to interact with user""" print("Compute digits of pi with SymPy\n") base = input("Which base? (2-36, 10 for decimal) \n> ") digits = input("How many digits? (enter a big number, say, 10000)\n> ") tofile = raw_input("Output to file? (enter a filename, or just press enter\nto print directly to the screen) \n> ") if tofile: tofile = open(tofile, "w") calculateit(pi, base, digits, tofile) def main(): """A non-interactive runner""" base = 16 digits = 500 tofile = None calculateit(pi, base, digits, tofile) if __name__ == "__main__": interactive()

6a975a412e5d4fce44f6c3c23326742e66d78cbe

py

Python

authserver/mailauth/migrations/0011_mnserviceuser.py

yopiti/authserver

0a1f7f5a83d03963d1ecfb5199be8e05d3068dfd

2017-07-04T10:07:32.000Z

2022-01-02T10:31:43.000Z

authserver/mailauth/migrations/0011_mnserviceuser.py

yopiti/authserver

0a1f7f5a83d03963d1ecfb5199be8e05d3068dfd

2020-02-11T21:42:38.000Z

2022-03-28T16:00:55.000Z

authserver/mailauth/migrations/0011_mnserviceuser.py

yopiti/authserver

0a1f7f5a83d03963d1ecfb5199be8e05d3068dfd

2020-03-01T10:39:28.000Z

2020-03-01T10:39:28.000Z

# -*- coding: utf-8 -*- # Generated by Django 1.11.11 on 2018-03-13 00:16 from __future__ import unicode_literals from django.conf import settings from django.db import migrations, models import django.db.models.deletion import mailauth.models import uuid class Migration(migrations.Migration): dependencies = [ ('mailauth', '0010_domain_redirect_to'), ] operations = [ migrations.CreateModel( name='MNServiceUser', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('username', models.CharField(default=uuid.uuid4, max_length=64, verbose_name='Username')), ('password', mailauth.models.PretendHasherPasswordField(max_length=128, verbose_name='Password')), ('description', models.CharField(blank=True, default='', max_length=255)), ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)), ], options={ 'verbose_name': 'Service User', 'verbose_name_plural': 'Service Users', }, bases=(mailauth.models.PasswordMaskMixin, models.Model), ), ]

6a97a004a7c418b0d32aaf5764a1c6b24a50f26a

py

Python

tempest/hacking/checks.py

rishabh20111990/tempest

df15531cd4231000b0da016f5cd8641523ce984e

2015-08-13T00:07:49.000Z

2020-08-07T06:38:44.000Z

tempest/hacking/checks.py

rishabh20111990/tempest

df15531cd4231000b0da016f5cd8641523ce984e

tempest/hacking/checks.py

rishabh20111990/tempest

df15531cd4231000b0da016f5cd8641523ce984e

2016-08-30T06:53:54.000Z

2021-03-22T16:54:39.000Z

# Copyright 2013 IBM Corp. # # 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 os import re from hacking import core import pycodestyle PYTHON_CLIENTS = ['cinder', 'glance', 'keystone', 'nova', 'swift', 'neutron', 'ironic', 'heat', 'sahara'] PYTHON_CLIENT_RE = re.compile('import (%s)client' % '|'.join(PYTHON_CLIENTS)) TEST_DEFINITION = re.compile(r'^\s*def test.*') SETUP_TEARDOWN_CLASS_DEFINITION = re.compile(r'^\s+def (setUp|tearDown)Class') SCENARIO_DECORATOR = re.compile(r'\s*@.*services\((.*)\)') RAND_NAME_HYPHEN_RE = re.compile(r".*rand_name\(.+[\-\_][\"\']\)") mutable_default_args = re.compile(r"^\s*def .+\((.+=\{\}|.+=\[\])") TESTTOOLS_SKIP_DECORATOR = re.compile(r'\s*@testtools\.skip\((.*)\)') METHOD = re.compile(r"^ def .+") METHOD_GET_RESOURCE = re.compile(r"^\s*def (list|show)\_.+") METHOD_DELETE_RESOURCE = re.compile(r"^\s*def delete_.+") CLASS = re.compile(r"^class .+") EX_ATTRIBUTE = re.compile(r'(\s+|\()(e|ex|exc|exception).message(\s+|\))') NEGATIVE_TEST_DECORATOR = re.compile( r'\s*@decorators\.attr\(type=.*negative.*\)') _HAVE_NEGATIVE_DECORATOR = False @core.flake8ext def import_no_clients_in_api_and_scenario_tests(physical_line, filename): """Check for client imports from tempest/api & tempest/scenario tests T102: Cannot import OpenStack python clients """ if "tempest/api" in filename or "tempest/scenario" in filename: res = PYTHON_CLIENT_RE.match(physical_line) if res: return (physical_line.find(res.group(1)), ("T102: python clients import not allowed" " in tempest/api/* or tempest/scenario/* tests")) @core.flake8ext def scenario_tests_need_service_tags(physical_line, filename, previous_logical): """Check that scenario tests have service tags T104: Scenario tests require a services decorator """ if 'tempest/scenario/' in filename and '/test_' in filename: if TEST_DEFINITION.match(physical_line): if not SCENARIO_DECORATOR.match(previous_logical): return (physical_line.find('def'), "T104: Scenario tests require a service decorator") @core.flake8ext def no_setup_teardown_class_for_tests(physical_line, filename): if pycodestyle.noqa(physical_line): return if 'tempest/test.py' in filename or 'tempest/lib/' in filename: return if SETUP_TEARDOWN_CLASS_DEFINITION.match(physical_line): return (physical_line.find('def'), "T105: (setUp|tearDown)Class can not be used in tests") @core.flake8ext def service_tags_not_in_module_path(physical_line, filename): """Check that a service tag isn't in the module path A service tag should only be added if the service name isn't already in the module path. T107 """ # NOTE(mtreinish) Scenario tests always need service tags, but subdirs are # created for services like heat which would cause false negatives for # those tests, so just exclude the scenario tests. if 'tempest/scenario' not in filename: matches = SCENARIO_DECORATOR.match(physical_line) if matches: services = matches.group(1).split(',') for service in services: service_name = service.strip().strip("'") modulepath = os.path.split(filename)[0] if service_name in modulepath: return (physical_line.find(service_name), "T107: service tag should not be in path") @core.flake8ext def no_hyphen_at_end_of_rand_name(logical_line, filename): """Check no hyphen at the end of rand_name() argument T108 """ msg = "T108: hyphen should not be specified at the end of rand_name()" if RAND_NAME_HYPHEN_RE.match(logical_line): return 0, msg @core.flake8ext def no_mutable_default_args(logical_line): """Check that mutable object isn't used as default argument N322: Method's default argument shouldn't be mutable """ msg = "N322: Method's default argument shouldn't be mutable!" if mutable_default_args.match(logical_line): yield (0, msg) @core.flake8ext def no_testtools_skip_decorator(logical_line): """Check that methods do not have the testtools.skip decorator T109 """ if TESTTOOLS_SKIP_DECORATOR.match(logical_line): yield (0, "T109: Cannot use testtools.skip decorator; instead use " "decorators.skip_because from tempest.lib") def _common_service_clients_check(logical_line, physical_line, filename, ignored_list_file=None): if not re.match('tempest/(lib/)?services/.*', filename): return False if ignored_list_file is not None: ignored_list = [] with open('tempest/hacking/' + ignored_list_file) as f: for line in f: ignored_list.append(line.strip()) if filename in ignored_list: return False if not METHOD.match(physical_line): return False if pycodestyle.noqa(physical_line): return False return True @core.flake8ext def get_resources_on_service_clients(physical_line, logical_line, filename, line_number, lines): """Check that service client names of GET should be consistent T110 """ if not _common_service_clients_check(logical_line, physical_line, filename, 'ignored_list_T110.txt'): return for line in lines[line_number:]: if METHOD.match(line) or CLASS.match(line): # the end of a method return if 'self.get(' not in line and ('self.show_resource(' not in line and 'self.list_resources(' not in line): continue if METHOD_GET_RESOURCE.match(logical_line): return msg = ("T110: [GET /resources] methods should be list_<resource name>s" " or show_<resource name>") yield (0, msg) @core.flake8ext def delete_resources_on_service_clients(physical_line, logical_line, filename, line_number, lines): """Check that service client names of DELETE should be consistent T111 """ if not _common_service_clients_check(logical_line, physical_line, filename, 'ignored_list_T111.txt'): return for line in lines[line_number:]: if METHOD.match(line) or CLASS.match(line): # the end of a method return if 'self.delete(' not in line and 'self.delete_resource(' not in line: continue if METHOD_DELETE_RESOURCE.match(logical_line): return msg = ("T111: [DELETE /resources/<id>] methods should be " "delete_<resource name>") yield (0, msg) @core.flake8ext def dont_import_local_tempest_into_lib(logical_line, filename): """Check that tempest.lib should not import local tempest code T112 """ if 'tempest/lib/' not in filename: return if not ('from tempest' in logical_line or 'import tempest' in logical_line): return if ('from tempest.lib' in logical_line or 'import tempest.lib' in logical_line): return msg = ("T112: tempest.lib should not import local tempest code to avoid " "circular dependency") yield (0, msg) @core.flake8ext def use_rand_uuid_instead_of_uuid4(logical_line, filename): """Check that tests use data_utils.rand_uuid() instead of uuid.uuid4() T113 """ if 'tempest/lib/' in filename: return if 'uuid.uuid4()' not in logical_line: return msg = ("T113: Tests should use data_utils.rand_uuid()/rand_uuid_hex() " "instead of uuid.uuid4()/uuid.uuid4().hex") yield (0, msg) @core.flake8ext def dont_use_config_in_tempest_lib(logical_line, filename): """Check that tempest.lib doesn't use tempest config T114 """ if 'tempest/lib/' not in filename: return if ('tempest.config' in logical_line or 'from tempest import config' in logical_line or 'oslo_config' in logical_line): msg = ('T114: tempest.lib can not have any dependency on tempest ' 'config.') yield(0, msg) @core.flake8ext def dont_put_admin_tests_on_nonadmin_path(logical_line, filename): """Check admin tests should exist under admin path T115 """ if 'tempest/api/' not in filename: return if not re.match(r'class .*Test.*\(.*Admin.*\):', logical_line): return if not re.match(r'.\/tempest\/api\/.*\/admin\/.*', filename): msg = 'T115: All admin tests should exist under admin path.' yield(0, msg) @core.flake8ext def unsupported_exception_attribute_PY3(logical_line): """Check Unsupported 'message' exception attribute in PY3 T116 """ result = EX_ATTRIBUTE.search(logical_line) msg = ("[T116] Unsupported 'message' Exception attribute in PY3") if result: yield(0, msg) @core.flake8ext def negative_test_attribute_always_applied_to_negative_tests(physical_line, filename): """Check ``@decorators.attr(type=['negative'])`` applied to negative tests. T117 """ global _HAVE_NEGATIVE_DECORATOR if re.match(r'.\/tempest\/api\/.*_negative.*', filename): if NEGATIVE_TEST_DECORATOR.match(physical_line): _HAVE_NEGATIVE_DECORATOR = True return if TEST_DEFINITION.match(physical_line): if not _HAVE_NEGATIVE_DECORATOR: return ( 0, "T117: Must apply `@decorators.attr(type=['negative'])`" " to all negative API tests" ) _HAVE_NEGATIVE_DECORATOR = False

6a98547230e4cc83fa248137ca0fde09ebb67dcf

py

Python

data/train/python/6a98547230e4cc83fa248137ca0fde09ebb67dcfController.py

harshp8l/deep-learning-lang-detection

2a54293181c1c2b1a2b840ddee4d4d80177efb33

2017-10-25T15:49:21.000Z

2021-11-28T21:25:54.000Z

data/train/python/6a98547230e4cc83fa248137ca0fde09ebb67dcfController.py

vassalos/deep-learning-lang-detection

cbb00b3e81bed3a64553f9c6aa6138b2511e544e

2018-03-29T11:50:46.000Z

2021-04-26T13:33:18.000Z

data/train/python/6a98547230e4cc83fa248137ca0fde09ebb67dcfController.py

vassalos/deep-learning-lang-detection

cbb00b3e81bed3a64553f9c6aa6138b2511e544e

2017-11-22T08:31:00.000Z

2022-03-27T01:22:31.000Z

import SimpleXMLRPCServer import sys import logging from K8055Controller import K8055Controller logging.basicConfig() controller_log = logging.getLogger("Controller") class Controller: def __init__(self): self.k8055 = K8055Controller() controller_log.debug("initialized") def reset(self): self.k8055.reset() controller_log.debug("reset") return 0 def turn_on(self, i): self.k8055.turn_on(i) controller_log.debug('turned on %i' % (i)) return 0 def turn_off(self, i): self.k8055.turn_off(i) controller_log.debug('turned off %i' % (i)) return 0 def set_analog(self, i, level): if (i == 1): self.k8055.set_analog1(level) else: self.k8055.set_analog2(level) return 0 controller = Controller() server = SimpleXMLRPCServer.SimpleXMLRPCServer(("d6349.mysql.zone.ee", 7000)) server.register_instance(controller) server.serve_forever()

6a98f5590ec68008681144a3cad2ee8a6d9f0359

py

Python

model/__init__.py

sun1638650145/CRNN

485157e5803b9be861a63ebb04f04fccb16ef5f1

2020-09-18T02:35:48.000Z

2022-02-26T21:31:55.000Z

model/__init__.py

sun1638650145/CRNN

485157e5803b9be861a63ebb04f04fccb16ef5f1

model/__init__.py

sun1638650145/CRNN

485157e5803b9be861a63ebb04f04fccb16ef5f1

from .crnn import CRNN from .crnn import CRNN_Attention

6a9907c6e19624e9a00da0b3cff99ba87e746680

py

Python

models2.py

Lydia-Tan/MindLife

644f1a3834f337d51c99650c3924df99c5200d06

2020-01-20T19:49:07.000Z

2020-01-20T19:49:07.000Z

models2.py

lindaweng/Mindlife

30be070b39728fb3fe149d4c95e5bce280a3b6a7

models2.py

lindaweng/Mindlife

30be070b39728fb3fe149d4c95e5bce280a3b6a7

import nltk import re import sys from sys import argv from nltk.sentiment.vader import SentimentIntensityAnalyzer def ajay(ans): ajay = SentimentIntensityAnalyzer() completeScore = 0 questionWeights = [0.05, 0.20, 0.05, 0.05, 0.05, 0.20, 0.05, 0.05, 0.20, 0.10] print ans ansList = ans.split("$") for j in range(10): print ansList[j] for i in range(10): results = [] score = 0 count = 0 # print (count) for paragraph in ansList: for line in paragraph: #Split Paragraph on basis of '.' or ? or !. for l in re.split(r"\.|\?|\!",paragraph): # print(l) ss = ajay.polarity_scores(l) results.append(ss); # print(ss['compound']) score += ss['compound'] count += 1 completeScore += (score/count)*questionWeights[i] #print(completeScore) if (completeScore >= 0.1): return "False Alarm! You don't have Depression." elif (completeScore >= -0.1): return ("Seasonal affective disorder (SAD). This type of depression " + "emerges as days get shorter in the fall and winter. The mood " + "change may result from alterations in the body's natural daily " + "rhythms, in the eyes' sensitivity to light, or in how chemical " + "messengers like serotonin and melatonin function. The leading " + "treatment is light therapy, which involves daily sessions sitting " + "close to an especially intense light source. The usual treatments " + "for depression, such as psychotherapy and medication, may also be " + "effective."); elif (completeScore >= -0.4): return ("Persistent depressive disorder. Formerly called dysthymia, this " + "type of depression refers to low mood that has lasted for at least " + "two years but may not reach the intensity of major depression. Many " + "people with this type of depression type are able to function day to " + "but feel low or joyless much of the time. Some depressive symptoms, " + "such as appetite and sleep changes, low energy, low self-esteem, or " + "hopelessness, are usually part of the picture.") else: return ("The classic depression type, major depression is a state where a dark " + "mood is all-consuming and one loses interest in activities, even ones " + "that are usually pleasurable. Symptoms of this type of depression " + "include trouble sleeping, changes in appetite or weight, loss of energy, " + "and feeling worthless. Thoughts of death or suicide may occur. It is " + "usually treated with psychotherapy and medication. For some people with " + "severe depression that isn't alleviated with psychotherapy or antidepressant " + "medications, electroconvulsive therapy may be effective.")

6a9a4141ccd8a77a2a296371f9b8eb6510494db4

py

Python

tokendito/tool.py

pcmxgti/tokendito

c1672917b1b95e463c5bdf8e9c3c039189da8e42

2019-07-31T03:21:03.000Z

2022-03-29T23:57:19.000Z

tokendito/tool.py

pcmxgti/tokendito

c1672917b1b95e463c5bdf8e9c3c039189da8e42

2019-08-07T06:40:15.000Z

2022-03-21T18:46:49.000Z

tokendito/tool.py

pcmxgti/tokendito

c1672917b1b95e463c5bdf8e9c3c039189da8e42

2019-07-31T14:22:04.000Z

2022-02-16T12:55:27.000Z

# vim: set filetype=python ts=4 sw=4 # -*- coding: utf-8 -*- """This module retrieves AWS credentials after authenticating with Okta.""" from __future__ import absolute_import, division, print_function, unicode_literals import logging from future import standard_library from tokendito import aws_helpers from tokendito import helpers from tokendito import okta_helpers from tokendito import settings standard_library.install_aliases() def cli(args): """Tokendito retrieves AWS credentials after authenticating with Okta.""" # Set some required initial values args = helpers.setup(args) logging.debug("tokendito retrieves AWS credentials after authenticating with Okta.") # Collect and organize user specific information helpers.process_options(args) # Authenticate okta and AWS also use assumerole to assign the role logging.debug("Authenticate user with Okta and AWS.") secret_session_token = okta_helpers.authenticate_user( settings.okta_org, settings.okta_username, settings.okta_password ) saml_response_string, saml_xml = aws_helpers.authenticate_to_roles( secret_session_token, settings.okta_aws_app_url ) assume_role_response, role_name = aws_helpers.select_assumeable_role( saml_response_string, saml_xml ) aws_helpers.ensure_keys_work(assume_role_response) helpers.set_local_credentials( assume_role_response, role_name, settings.aws_region, settings.aws_output )

6a9b47904f23c1124cf4fbc27654a8fe5f3b7493

py

Python

resources/__init__.py

Boryslavq/UHMI_Chalenge

4b7df902c0a0901c727a6fb26347dabca1067494

resources/__init__.py

Boryslavq/UHMI_Chalenge

4b7df902c0a0901c727a6fb26347dabca1067494

resources/__init__.py

Boryslavq/UHMI_Chalenge

4b7df902c0a0901c727a6fb26347dabca1067494

from . import rest from . import helpers

6a9c07074d315021100d6322a18c6bc3087be1db

py

Python

ir_datasets/formats/trec.py

cakiki/ir_datasets

7f9f8e9ff62e49d40383220ecc2daa250695d267

ir_datasets/formats/trec.py

cakiki/ir_datasets

7f9f8e9ff62e49d40383220ecc2daa250695d267

ir_datasets/formats/trec.py

cakiki/ir_datasets

7f9f8e9ff62e49d40383220ecc2daa250695d267

import io import codecs import tarfile import re import gzip import xml.etree.ElementTree as ET from fnmatch import fnmatch from pathlib import Path from typing import NamedTuple import ir_datasets from ir_datasets.indices import PickleLz4FullStore from .base import GenericDoc, GenericQuery, GenericScoredDoc, BaseDocs, BaseQueries, BaseScoredDocs, BaseQrels class TrecDoc(NamedTuple): doc_id: str text: str marked_up_doc: str class TitleUrlTextDoc(NamedTuple): doc_id: str title: str url: str text: str class TrecQuery(NamedTuple): query_id: str title: str description: str narrative: str class TrecSubtopic(NamedTuple): number: str text: str type: str class TrecQrel(NamedTuple): query_id: str doc_id: str relevance: int iteration: str class TrecPrel(NamedTuple): query_id: str doc_id: str relevance: int method: int iprob: float # Default content tags from Anserini's TrecCollection CONTENT_TAGS = 'TEXT HEADLINE TITLE HL HEAD TTL DD DATE LP LEADPARA'.split() class TrecDocs(BaseDocs): def __init__(self, docs_dlc, encoding=None, path_globs=None, content_tags=CONTENT_TAGS, parser='BS4', namespace=None, lang=None, expected_file_count=None, docstore_size_hint=None, count_hint=None): self._docs_dlc = docs_dlc self._encoding = encoding self._path_globs = path_globs self._content_tags = content_tags self._parser = { 'BS4': self._parser_bs, 'text': self._parser_text, 'tut': self._parser_tut, }[parser] self._doc = { 'BS4': TrecDoc, 'text': GenericDoc, 'tut': TitleUrlTextDoc, }[parser] self._docs_namespace = namespace self._docs_lang = lang self._expected_file_count = expected_file_count self._docstore_size_hint = docstore_size_hint self._count_hint = count_hint if expected_file_count is not None: assert self._path_globs is not None, "expected_file_count only supported with path_globs" def docs_path(self, force=True): return self._docs_dlc.path(force) @ir_datasets.util.use_docstore def docs_iter(self): if Path(self._docs_dlc.path()).is_dir(): if self._path_globs: file_count = 0 for glob in sorted(self._path_globs): for path in sorted(Path(self._docs_dlc.path()).glob(glob)): file_count += 1 yield from self._docs_iter(path) if self._expected_file_count is not None: if file_count != self._expected_file_count: raise RuntimeError(f'found {file_count} files of the expected {self._expected_file_count} matching the following: {self._path_globs} under {self._docs_dlc.path()}. Make sure that directories are linked such that these globs match the correct number of files.') else: yield from self._docs_iter(self._docs_dlc.path()) else: if self._path_globs: file_count = 0 # tarfile, find globs, open in streaming mode (r|) with self._docs_dlc.stream() as stream: with tarfile.open(fileobj=stream, mode='r|gz') as tarf: for block in tarf: if any(fnmatch(block.name, g) for g in self._path_globs): file = tarf.extractfile(block) if block.name.endswith('.gz'): file = gzip.GzipFile(fileobj=file) yield from self._parser(file) file_count += 1 if self._expected_file_count is not None: if file_count != self._expected_file_count: raise RuntimeError(f'found {file_count} files of the expected {self._expected_file_count} matching the following: {self._path_globs} under {self._docs_dlc.path()}. Make sure that directories are linked such that these globs match the correct number of files.') else: with self._docs_dlc.stream() as f: yield from self._parser(f) def _docs_iter(self, path): if Path(path).is_file(): if str(path).endswith('.gz'): with gzip.open(path, 'rb') as f: yield from self._parser(f) else: with path.open('rb') as f: yield from self._parser(f) elif Path(path).is_dir(): for child in path.iterdir(): yield from self._docs_iter(child) def _parser_bs(self, stream): BeautifulSoup = ir_datasets.lazy_libs.bs4().BeautifulSoup f = codecs.getreader(self._encoding or 'utf8')(stream, errors='replace') doc_id, doc_markup = None, '' in_tag = False for line in f: if line.startswith('<DOCNO>'): doc_id = line.replace('<DOCNO>', '').replace('</DOCNO>\n', '').strip() elif line == '</DOC>\n': soup = BeautifulSoup(f'<OUTER>\n{doc_markup}\n</OUTER>', 'lxml') text = soup.get_text() yield TrecDoc(doc_id, text, doc_markup) doc_id, doc_markup = None, '' else: if in_tag: doc_markup += line if line.startswith('</'): if any(line.startswith(f'</{tag}>') for tag in self._content_tags): in_tag -= 1 if line.startswith('<'): if any(line.startswith(f'<{tag}>') for tag in self._content_tags): in_tag += 1 if in_tag == 1: doc_markup += line def _parser_text(self, stream): f = codecs.getreader(self._encoding or 'utf8')(stream, errors='replace') doc_id, doc_text = None, '' in_tag = False for line in f: if line.startswith('<DOCNO>'): doc_id = line.replace('<DOCNO>', '').replace('</DOCNO>\n', '').strip() elif line == '</DOC>\n': yield GenericDoc(doc_id, doc_text) doc_id, doc_text = None, '' else: if line.startswith('</'): if any(line.startswith(f'</{tag}>') for tag in self._content_tags): in_tag = False if in_tag: doc_text += line if line.startswith('<'): if any(line.startswith(f'<{tag}>') for tag in self._content_tags): in_tag = True def _parser_tut(self, stream): f = codecs.getreader(self._encoding or 'utf8')(stream, errors='replace') doc_id, doc_title, doc_url, doc_text = None, None, None, '' in_tag = False for line in f: if line.startswith('<DOCNO>'): doc_id = line.replace('<DOCNO>', '').replace('</DOCNO>\n', '').strip() if line.startswith('<TITLE>'): doc_title = line.replace('<TITLE>', '').replace('</TITLE>\n', '').strip() if line.startswith('<URL>'): doc_url = line.replace('<URL>', '').replace('</URL>\n', '').strip() elif line == '</DOC>\n': yield TitleUrlTextDoc(doc_id, doc_title, doc_url, doc_text) doc_id, doc_title, doc_url, doc_text = None, None, None, '' else: if line.startswith('</TEXT>'): in_tag = False if in_tag: doc_text += line if line.startswith('<TEXT>'): in_tag = True def docs_cls(self): return self._doc def docs_store(self, field='doc_id'): return PickleLz4FullStore( path=f'{self.docs_path(force=False)}.pklz4', init_iter_fn=self.docs_iter, data_cls=self.docs_cls(), lookup_field=field, index_fields=['doc_id'], size_hint=self._docstore_size_hint, count_hint=self._count_hint, ) def docs_count(self): if self.docs_store().built(): return self.docs_store().count() def docs_namespace(self): return self._docs_namespace def docs_lang(self): return self._docs_lang DEFAULT_QTYPE_MAP = { '<num> *(Number:)?': 'query_id', '<title> *(Topic:)?': 'title', '<desc> *(Description:)?': 'description', '<narr> *(Narrative:)?': 'narrative' } class TrecQueries(BaseQueries): def __init__(self, queries_dlc, qtype=TrecQuery, qtype_map=None, encoding=None, namespace=None, lang=None, remove_tags=('</title>',)): self._queries_dlc = queries_dlc self._qtype = qtype self._qtype_map = qtype_map or DEFAULT_QTYPE_MAP self._encoding = encoding self._queries_namespace = namespace self._queries_lang = lang self._remove_tags = remove_tags def queries_path(self): return self._queries_dlc.path() def queries_iter(self): fields, reading = {}, None with self._queries_dlc.stream() as f: f = codecs.getreader(self._encoding or 'utf8')(f) for line in f: if line.startswith('</top>'): assert len(fields) == len(self._qtype._fields), fields for tag in self._remove_tags: fields = {k: v.replace(tag, '') for k, v in fields.items()} yield self._qtype(*(fields[f].strip() for f in self._qtype._fields)) fields, reading = {}, None match_any = False for tag, target in self._qtype_map.items(): match = re.match(tag, line) if match: fields[target] = line[match.end():] reading = target match_any = True break if not match_any and reading and not line.startswith('<'): fields[reading] += line def queries_cls(self): return self._qtype def queries_namespace(self): return self._queries_namespace def queries_lang(self): return self._queries_lang class TrecXmlQueries(BaseQueries): def __init__(self, queries_dlc, qtype=TrecQuery, qtype_map=None, encoding=None, subtopics_key='subtopics', namespace=None, lang=None): self._queries_dlc = queries_dlc self._qtype = qtype self._qtype_map = qtype_map or {f: f for f in qtype._fields} self._encoding = encoding self._subtopics_key = subtopics_key self._queries_namespace = namespace self._queries_lang = lang def queries_path(self): return self._queries_dlc.path() def queries_iter(self): with self._queries_dlc.stream() as f: f = codecs.getreader(self._encoding or 'utf8')(f) for topic_el in ET.fromstring(f.read()): item = [None for _ in self._qtype._fields] if 'number' in topic_el.attrib: item[self._qtype._fields.index('query_id')] = topic_el.attrib['number'] subtopics = [] for attr in topic_el.attrib: if attr in self._qtype_map: text = topic_el.attrib[attr] field = self._qtype_map[attr] item[self._qtype._fields.index(field)] = text if topic_el.tag in self._qtype_map: text = ''.join(topic_el.itertext()) field = self._qtype_map[topic_el.tag] item[self._qtype._fields.index(field)] = text for field_el in topic_el: if field_el.tag in self._qtype_map: text = ''.join(field_el.itertext()) field = self._qtype_map[field_el.tag] item[self._qtype._fields.index(field)] = text if field_el.tag == 'subtopic': text = ''.join(field_el.itertext()) subtopics.append(TrecSubtopic(field_el.attrib['number'], text, field_el.attrib['type'])) if self._subtopics_key in self._qtype._fields: item[self._qtype._fields.index('subtopics')] = tuple(subtopics) qid_field = self._qtype._fields.index('query_id') item[qid_field] = item[qid_field].strip() # remove whitespace from query_ids yield self._qtype(*item) def queries_cls(self): return self._qtype def queries_namespace(self): return self._queries_namespace def queries_lang(self): return self._queries_lang class TrecColonQueries(BaseQueries): def __init__(self, queries_dlc, encoding=None, namespace=None, lang=None): self._queries_dlc = queries_dlc self._encoding = encoding self._queries_namespace = namespace self._queries_lang = lang def queries_iter(self): with self._queries_dlc.stream() as f: f = codecs.getreader(self._encoding or 'utf8')(f) for line in f: query_id, text = line.split(':', 1) text = text.rstrip('\n') yield GenericQuery(query_id, text) def queries_path(self): return self._queries_dlc.path() def queries_cls(self): return GenericQuery def queries_namespace(self): return self._queries_namespace def queries_lang(self): return self._queries_lang class TrecQrels(BaseQrels): def __init__(self, qrels_dlc, qrels_defs): self._qrels_dlc = qrels_dlc self._qrels_defs = qrels_defs def qrels_path(self): return self._qrels_dlc.path() def qrels_iter(self): with self._qrels_dlc.stream() as f: f = codecs.getreader('utf8')(f) for line in f: if line == '\n': continue # ignore blank lines cols = line.rstrip().split() if len(cols) != 4: raise RuntimeError(f'expected 4 columns, got {len(cols)}') qid, it, did, score = cols yield TrecQrel(qid, did, int(score), it) def qrels_cls(self): return TrecQrel def qrels_defs(self): return self._qrels_defs class TrecPrels(TrecQrels): def qrels_iter(self): with self._qrels_dlc.stream() as f: f = codecs.getreader('utf8')(f) for line in f: if line == '\n': continue # ignore blank lines cols = line.rstrip().split() if len(cols) != 5: raise RuntimeError(f'expected 5 columns, got {len(cols)}') qid, did, rel, method, iprob = cols yield TrecPrel(qid, did, int(rel), int(method), float(iprob)) def qrels_cls(self): return TrecPrel class TrecScoredDocs(BaseScoredDocs): def __init__(self, scoreddocs_dlc): self._scoreddocs_dlc = scoreddocs_dlc def scoreddocs_path(self): return self._scoreddocs_dlc.path() def scoreddocs_iter(self): with self._scoreddocs_dlc.stream() as f: f = codecs.getreader('utf8')(f) for line in f: cols = line.rstrip().split() if len(cols) == 6: qid, _, did, _, score, _ = cols elif len(cols) == 2: qid, did, score = *cols, '0' yield GenericScoredDoc(qid, did, float(score))

6a9c552700ad0a75cac33278ee8dc5a5139c2432

py

Python

textpand/download.py

caufieldjh/textpand-for-kgs

42853c53c5a4cc06fbd745c147d02fe7916690fa

2021-12-10T21:13:47.000Z

2021-12-10T23:36:18.000Z

textpand/download.py

caufieldjh/textpand-for-kgs

42853c53c5a4cc06fbd745c147d02fe7916690fa

2022-01-06T20:59:07.000Z

2022-01-06T20:59:07.000Z

textpand/download.py

caufieldjh/textpand-for-kgs

42853c53c5a4cc06fbd745c147d02fe7916690fa