Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use is_int method in pandera

Best Python code snippet using pandera_python

two_arguments.py

Source:two_arguments.py

1from check_type import *2import math3import itertools4def get_list_or_string_item_or_concatenate_yield(a, b, arg):5	if is_int(a) and is_int(b):6		yield int(str(a)+str(b))7	elif is_int(a) and is_list(b):8		yield b[a % len(b)]9	elif is_list(a) and is_int(b):10		yield a[b % len(a)]11	elif is_int(a) and is_str(b):12		yield b[a % len(b)]13	elif is_str(a) and is_int(b):14		yield a[b % len(a)]15	elif is_list(a) and is_list(b):16		yield [a[n % len(a)] for n in b]17	else:18		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))19def is_equal(a, b, arg):20	if is_num(a) and is_num(b):21		yield int(a == b)22	elif type(a) == type(b) and type(a) != str:23		yield int(a == b)24	elif is_list(a):25		yield a.index(b) if b in a else -126	elif is_list(b):27		yield b.index(a) if a in b else -128	elif is_str(a) and is_str(b):29		if (len(a) == 1 or len(b) == 1) and len(a) != len(b):30			if len(a) < len(b):31				yield b.find(a)32			else:33				yield a.find(b)34		else:35			yield int(a == b)36	else:37		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))38def is_less(a, b, arg):39	if is_num(a) and is_num(b):40		yield int(a < b)41	elif is_int(a) and is_list(b):42		yield [b[i%len(b)] for i in range(a)]43	elif is_list(a) and is_int(b):44		yield [a[i%len(a)] for i in range(b)]45	elif is_int(a) and is_str(b):46		yield ''.join([b[i%len(b)] for i in range(a)])47	elif is_str(a) and is_int(b):48		yield ''.join([a[i%len(a)] for i in range(b)])49	else:50		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))51def is_greater(a, b, arg):52	if is_num(a) and is_num(b):53		yield int(a > b)54	elif is_int(a) and is_list(b):55		yield [b[i] for i in range((a+1)%len(b), len(b))]56	elif is_list(a) and is_int(b):57		yield [a[i] for i in range((b+1)%len(a), len(a))]58	elif is_int(a) and is_str(b):59		yield ''.join([b[i] for i in range((a+1)%len(b), len(b))])60	elif is_str(a) and is_int(b):61		yield ''.join([a[i] for i in range((b+1)%len(a), len(a))])62	else:63		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))64def is_leq(a, b, arg):65	if is_num(a) and is_num(b):66		yield int(a <= b)67	elif is_int(a) and is_list(b):68		yield [b[i%len(b)] for i in range(a+1)]69	elif is_list(a) and is_int(b):70		yield [a[i%len(a)] for i in range(b+1)]71	elif is_int(a) and is_str(b):72		yield ''.join([b[i%len(b)] for i in range(a+1)])73	elif is_str(a) and is_int(b):74		yield ''.join([a[i%len(a)] for i in range(b+1)])75	else:76		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))77def is_geq(a, b, arg):78	if is_num(a) and is_num(b):79		yield int(a >= b)80	elif is_int(a) and is_list(b):81		yield [b[i] for i in range(a%len(b), len(b))]82	elif is_list(a) and is_int(b):83		yield [a[i] for i in range(b%len(a), len(a))]84	elif is_int(a) and is_str(b):85		yield ''.join([b[i] for i in range(a%len(b), len(b))])86	elif is_str(a) and is_int(b):87		yield ''.join([a[i] for i in range(b%len(a), len(a))])88	else:89		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))90def is_not(a, b, arg):91	if type(a) == type(b):92		yield int(a != b)93	else:94		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))95def zip_yield(a, b, arg):96	if is_list(a) and is_list(b):97		max_len = max(len(a), len(b))98		yield [([a[i]] if i<len(a) else []) + ([b[i]] if i<len(b) else []) \99		for i in range(max_len)]100	elif is_str(a) and is_str(b):101		max_len = max(len(a), len(b))102		yield "".join([(a[i] if i<len(a) else "") + (b[i] if i<len(b) else "") \103		for i in range(max_len)])104	else:105		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))106def add_yield(a, b, arg):107	if is_num(a) and is_num(b):108		yield a+b109	elif is_num(a) and is_list(b):110		yield [n+a for n in b]111	elif is_list(a) and is_num(b):112		yield [n+b for n in a]113	elif is_list(a) and is_list(b):114		yield a+b115	elif is_str(a) and is_num(b):116		yield a+str(b)117	elif is_num(a) and is_str(b):118		yield str(a)+b119	elif is_list(a):120		yield [c for n in a for c in add_yield(n, b, arg)]121	elif is_list(b):122		yield [c for n in b for c in add_yield(a, n, arg)]123	elif is_str(a) and is_str(b):124		yield a+b125	else:126		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))127def subtract_yield(a, b, arg):128	if is_num(a) and is_num(b):129		yield a-b130	elif is_num(a) and is_list(b):131		yield [a-n for n in b]132	elif is_list(a) and is_num(b):133		yield [n-b for n in a]134	elif is_list(a) and is_list(b):135		yield [n for n in a if n not in set(b)]136	elif is_list(a) and is_str(b):137		yield [n for n in a if n not in set(b)]138	elif is_str(a) and is_list(b):139		yield ''.join([n for n in a if n not in set(b)])140	elif is_str(a) and is_str(b):141		yield ''.join([n for n in a if n not in set(b)])142	else:143		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))144def reverse_subtract_yield(a, b, arg):145	for res in subtract_yield(b, a, arg):146		yield res147def mult_yield(a, b, arg):148	if is_num(a) and is_num(b):149		yield a*b150	elif is_str(a) and is_num(b):151		yield a*int(b)152	elif is_num(a) and is_str(b):153		yield int(a)*b154	elif is_num(a) and is_list(b):155		yield a*b156	elif is_list(a) and is_num(b):157		yield [n2 for n in a for n2 in mult_yield(n, b, arg)]158	elif is_list(a) and is_str(b):159		yield [n2 for n in a for n2 in mult_yield(n, b, arg)]160	elif is_list(a) and is_list(b):161		yield [list(n) for n in itertools.product(a, b)]162	elif is_str(a) and is_list(b):163		if all(isinstance(item, str) for item in b):164			yield ''.join([''.join(n) for n in itertools.product(a, b)])165		else:166			yield [list(n) for n in itertools.product(a, b)]167	elif is_str(a) and is_str(b):168		yield ''.join([''.join(n) for n in itertools.product(a, b)])169	else:170		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))171def reverse_multiply_yield(a, b, arg):172	for res in mult_yield(b, a, arg):173		yield res174def divide_yield(a, b, arg):175	if is_int(a) and is_int(b):176		yield a//b177	elif is_num(a) and is_num(b):178		yield a/b179	elif is_num(a) and is_list(b):180		yield [a//n if is_int(a) and is_int(n) else a/n for n in b]181	elif is_list(a) and is_num(b):182		yield [n//b if is_int(b) and is_int(n) else n/b for n in a]183	elif is_list(a) and is_list(b):184		yield [n for n in a if n  in set(b)]185	elif is_str(a) and is_int(b):186		yield [a[i*b:(i+1)*b] for i in range(math.ceil(len(a)/b))]187	elif is_str(a) and is_str(b):188		yield a.split(b)189	elif is_list(a) and is_str(b):190		yield [n for n in a if n != b]191	elif is_str(a) and is_list(b):192		if all(isinstance(item, str) for item in b):193			for n in b:194				a = a.replace(n, "")195			yield a196		elif all(isinstance(item, int) for item in b):197			yield [a[b[i]:b[i+1]] for i in range(len(b)-1)]198		else:199			raise ValueError("[%s][%s]%s is only supported for single type string or int arrays" % (type(a), type(b), arg.char))200	else:201		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))202def reverse_divide_yield(a, b, arg):203	for res in divide_yield(b, a, arg):204		yield res205def power_yield(a, b, arg):206	if is_num(a) and is_num(b):207		yield a**b208	elif is_num(a) and is_list(b):209		yield [a**n for n in b]210	elif is_list(a) and is_num(b):211		yield [n**b for n in a]212	else:213		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))214def reverse_power_yield(a, b, arg):215	for res in power_yield(b, a, arg):216		yield res217def modulo_yield(a, b, arg):218	if is_num(a) and is_num(b):219		yield a%b220	elif is_int(a) and is_list(b):221		yield [n for n in b[::a]]222	elif is_list(a) and is_num(b):223		yield [n%b for n in a]224	elif is_num(a) and is_str(b):225		yield ''.join([n for n in b[::n]])226	else:227		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))228def join_yield(a, b, arg):229	if is_list(a) and is_str(b):230		yield b.join([str(n) for n in a])231	elif is_str(a) and is_list(b):232		yield a.join([str(n) for n in b])233	elif(is_str(a) and is_str(b)):234		yield b.join(list(a))235	elif is_list(a) and is_list(b):236		yield [n.join(a) for n in b]237	else:238		raise ValueError("[%s]%s is not supported" % (type(a),arg.char))239def prepend_list_or_string_yield(a, b, arg):240	if is_num(a) and is_list(b):241		yield [a] + b242	elif is_list(a) and is_num(b):243		yield [b] + a244	elif is_str(a) and is_list(b):245		yield [a] + b246	elif is_list(a) and is_str(b):247		yield [b] + a248	elif is_str(a) and is_num(b):249		yield str(b) + a250	elif is_num(a) and is_str(b):251		yield str(a) + b252	elif is_str(a) and is_str(b):253		yield b + a254	elif is_int(a) and is_int(b):255		yield int(str(b)+str(a))256	elif is_list(a) and is_list(b):257		yield b + a258	else:259		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))260def append_list_or_string_yield(a, b, arg):261	if is_num(a) and is_list(b):262		yield b + [a]263	elif is_list(a) and is_num(b):264		yield a + [b]265	elif is_str(a) and is_list(b):266		yield b + [a]267	elif is_list(a) and is_str(b):268		yield a + [b]269	elif is_str(a) and is_num(b):270		yield a + str(b)271	elif is_num(a) and is_str(b):272		yield b + str(a)273	elif is_str(a) and is_str(b):274		yield a + b275	elif is_int(a) and is_int(b):276		yield int(str(a)+str(b))277	elif is_list(a) and is_list(b):278		yield a + b279	else:280		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))281def increase_array_element_yield(a, b, arg):282	if is_int(a) and is_list(b):283		b[a % len(b)] += 1284		yield b285	elif is_list(a) and is_int(b):286		a[b % len(a)] += 1287		yield a288	else:289		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))290def decrease_array_element_yield(a, b, arg):291	if is_int(a) and is_list(b):292		b[a % len(b)] -= 1293		yield b294	elif is_list(a) and is_int(b):295		a[b % len(a)] -= 1296		yield a297	else:298		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))299def is_divisible_yield(a, b, arg):300	if is_int(a) and is_int(b):301		yield int(a%b == 0)302	elif is_int(a) and is_list(b):303		yield [int(a%n == 0) for n in b]304	elif is_list(a) and is_int(b):305		yield [int(n%b == 0) for n in a]306	else:307		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))308def add(a, b):309	return a+b310def mult(a, b, arg):311	return a*b312def center_string_or_int_yield(a, b, arg):313	if is_int(a) and is_int(b):314		yield str(a).center(b)315	elif is_int(a) and is_str(b):316		yield b.center(a)317	elif is_str(a) and is_int(b):318		yield a.center(b)319	elif is_int(a) and is_list(b):320		yield [str(n).center(a) for n in b]321	elif is_list(a) and is_int(b):322		yield [str(n).center(b) for n in a]323	else:324		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))325def pad_to_equal_length(a, b, arg):326	if is_list(a) and (is_int(b) or is_str(b)):327		max_len = 0328		for n in a:329			max_len = max(max_len, len(str(n)))330		res = []331		for n in a:332			pad = max_len - len(str(n))333			res.append(pad*str(b)+str(n))334		yield res335	elif is_list(b) and (is_int(a) or is_str(a)):336		max_len = 0337		for n in b:338			max_len = max(max_len, len(str(n)))339		res = []340		for n in b:341			pad = max_len - len(str(n))342			res.append(pad*str(a)+str(n))343		yield res344	else:345		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))346def contains_yield(a, b, arg):347	if is_list(a):348		yield 1 if b in a else 0349	elif is_list(b):350		yield 1 if a in b else 0351	elif is_str(a) and is_str(b):352		if len(a) < len(b):353			yield 1 if a in b else 0354		else:355			yield 1 if b in a else 0356	elif is_str(a):357		yield 1 if str(b) in a else 0358	elif is_str(b):359		yield 1 if str(a) in b else 0360	elif is_int(a) and is_int(b):361		yield 1 if str(b) in str(a) else 0362	else:363		raise ValueError("[%s][%s]%s is not supported" % (type(a), type(b), arg.char))364def inclusive_range_yield(a, b, arg):365	if is_int(a) and is_int(b):366		if b < a:367			yield list(range(b, a+1))368		else:369			yield list(range(b, a-1, -1))370	else:...

expr.py

Source:expr.py

...41class Expression(object):42    """43    Base class for all expressions.44    """45    def is_int(self, val = None):46        return False47class Terminal(Expression):48    """49    A terminal object.50    """51    def __init__(self, val, pretty = None):52        """53        Construct a Terminal.54        The val variable is usually a string or an integer. Integers may also55        be passed as strings. The pretty-printer will use the string when56        formatting the expression.57        """58        self.val = val59        self.pretty = pretty60    def __str__(self):61        """62        Return the string expression of this object.63        """64        if self.pretty is None:65            return str(self.val)66        return self.pretty67    def simplify(self):68        """69        Return a simplified version of this sub-expression.70        """71        return self72    def is_int(self, val = None):73        """74        Return True if the value of this Terminal is an integer.75        """76        if type(self.val) is int:77            return val is None or self.val == val78        return False79class FunctionCall(Expression):80    """81    Represent a function call82    """83    def __init__(self, name, args):84        """85        Construct a function call object.86        """87        self.name = _classify(name)88        self.args = [_classify(arg) for arg in args]89    def __str__(self):90        """91        Return the string expression of this object.92        """93        return str(self.name) + '(' + ', '.join([str(arg) for arg in self.args]) + ')'94    def simplify(self):95        """96        Return a simplified version of this sub-expression.97        """98        args = [arg.simplify() for arg in self.args]99        return FunctionCall(self.name, args)100class Parenthesis(Expression):101    """102    Represent a pair of round brackets.103    """104    def __init__(self, val):105        """106        Construct a parenthesis object.107        """108        self.val = _classify(val)109    def simplify(self):110        """111        Return a simplified version of this sub-expression.112        """113        val = self.val.simplify()114        if type(val) is Terminal:115            return val116        return Parenthesis(val)117    def __str__(self):118        """119        Return the string expression of this object.120        """121        return '(' + str(self.val) + ')'122class Add(Expression):123    """124    Represent an addition of operands.125    """126    def __init__(self, lhs, rhs):127        """128        Construct an addition object.129        """130        self.lhs = _classify(lhs)131        self.rhs = _classify(rhs)132    def simplify(self):133        """134        Return a simplified version of this sub-expression.135        """136        lhs = self.lhs.simplify()137        rhs = self.rhs.simplify()138        if lhs.is_int() and rhs.is_int():139            return Terminal(lhs.val + rhs.val)140        if lhs.is_int(0):141            return rhs142        if rhs.is_int(0):143            return lhs144        return Add(lhs, rhs)145    def __str__(self):146        """147        Return the string expression of this object.148        """149        return str(self.lhs) + ' + ' + str(self.rhs)150class Sub(Expression):151    """152    Represent a subtraction of operands.153    """154    def __init__(self, lhs, rhs):155        """156        Construct subtraction object.157        """158        self.lhs = _classify(lhs)159        self.rhs = _classify(rhs)160    def simplify(self):161        """162        Return a simplified version of this sub-expression.163        """164        lhs = self.lhs.simplify()165        rhs = self.rhs.simplify()166        if lhs.is_int() and rhs.is_int():167            return Terminal(lhs.val - rhs.val)168        if lhs.is_int(0):169            return rhs170        if rhs.is_int(0):171            return lhs172        return Sub(lhs, rhs)173    def __str__(self):174        """175        Return the string expression of this object.176        """177        return str(self.lhs) + ' - ' + str(self.rhs)178class Mul(Expression):179    """180    Represent the multiplication of operands.181    """182    def __init__(self, lhs, rhs):183        """184        Construct a multiplication object.185        """186        self.lhs = _classify(lhs)187        self.rhs = _classify(rhs)188    def simplify(self):189        """190        Return a simplified version of this sub-expression.191        """192        lhs = self.lhs.simplify()193        rhs = self.rhs.simplify()194        if lhs.is_int() and rhs.is_int():195            return Terminal(lhs.val * rhs.val)196        if lhs.is_int(0) or rhs.is_int(0):197            return Terminal(0)198        if lhs.is_int(1):199            return rhs200        if rhs.is_int(1):201            return lhs202        return Mul(lhs, rhs)203    def __str__(self):204        """205        Return the string expression of this object.206        """207        return str(self.lhs) + ' * ' + str(self.rhs)208class Shl(Expression):209    """210    Shift left operation.211    """212    def __init__(self, lhs, rhs):213        """214        Construct a shift left object.215        """216        self.lhs = _classify(lhs)217        self.rhs = _classify(rhs)218    def simplify(self):219        """220        Return a simplified version of this sub-expression.221        """222        lhs = self.lhs.simplify()223        rhs = self.rhs.simplify()224        if lhs.is_int() and rhs.is_int():225            return Terminal(lhs.val << rhs.val)226        if lhs.is_int(0):227            return Terminal(0)228        if rhs.is_int(0):229            return lhs230        return Shl(lhs, rhs)231    def __str__(self):232        """233        Return the string expression of this object.234        """235        return str(self.lhs) + ' << ' + str(self.rhs)236class Shr(Expression):237    """238    Shift right operation.239    """240    def __init__(self, lhs, rhs):241        """242        Construct a shift right object.243        """244        self.lhs = _classify(lhs)245        self.rhs = _classify(rhs)246    def simplify(self):247        """248        Return a simplified version of this sub-expression.249        """250        lhs = self.lhs.simplify()251        rhs = self.rhs.simplify()252        if lhs.is_int() and rhs.is_int():253            return Terminal(lhs.val >> rhs.val)254        if lhs.is_int(0):255            return Terminal(0)256        if rhs.is_int(0):257            return lhs258        return Shr(lhs, rhs)259    def __str__(self):260        """261        Return the string expression of this object.262        """263        return str(self.lhs) + ' >> ' + str(self.rhs)264class Or(Expression):265    """266    Logical or operation.267    """268    def __init__(self, lhs, rhs):269        """270        Construct a logical and object.271        """272        self.lhs = _classify(lhs)273        self.rhs = _classify(rhs)274    def simplify(self):275        """276        Return a simplified version of this sub-expression.277        """278        lhs = self.lhs.simplify()279        rhs = self.rhs.simplify()280        if lhs.is_int() and rhs.is_int():281            return Terminal(lhs.val | rhs.val)282        if lhs.is_int(0):283            return rhs284        if rhs.is_int(0):285            return lhs286        return Or(lhs, rhs)287    def __str__(self):288        """289        Return the string expression of this object.290        """291        return str(self.lhs) + ' | ' + str(self.rhs)292class And(Expression):293    """294    Logical and operation.295    """296    def __init__(self, lhs, rhs):297        """298        Construct a logical and object.299        """300        self.lhs = _classify(lhs)301        self.rhs = _classify(rhs)302    def simplify(self):303        """304        Return a simplified version of this sub-expression.305        """306        lhs = self.lhs.simplify()307        rhs = self.rhs.simplify()308        if lhs.is_int() and rhs.is_int():309            return Terminal(lhs.val & rhs.val)310        if lhs.is_int(0) or rhs.is_int(0):311            return Terminal(0)312        return And(lhs, rhs)313    def __str__(self):314        """315        Return the string expression of this object.316        """317        return str(self.lhs) + ' & ' + str(self.rhs)318class Xor(Expression):319    """320    Logical xor operation.321    """322    def __init__(self, lhs, rhs):323        """324        Construct a logical xor object.325        """326        self.lhs = _classify(lhs)327        self.rhs = _classify(rhs)328    def simplify(self):329        """330        Return a simplified version of this sub-expression.331        """332        lhs = self.lhs.simplify()333        rhs = self.rhs.simplify()334        if lhs.is_int() and rhs.is_int():335            return Terminal(lhs.val ^ rhs.val)336        if lhs.is_int(0):337            return rhs338        if rhs.is_int(0):339            return lhs340        return Xor(lhs, rhs)341    def __str__(self):342        """343        Return the string expression of this object.344        """...

test_variable.py

Source:test_variable.py

...15    """16    def get_variable(self,cls):17        v = cls(host=mysql_host,port=mysql_port,user=mysql_user,password=mysql_password)18        return v.value19    def is_int(self,cls,msg=''):20        v = self.get_variable(cls)21        print("{cls.variable_name:32} = {v}".format(cls=cls,v=v))22        self.assertEqual(type(v),int,msg)23    def is_str(self,cls,msg=''):24        v = self.get_variable(cls)25        print("{cls.variable_name:<32} = {v}".format(cls=cls,v=v))26        self.assertEqual(type(v),str,msg)27    def test_ServerID(self):28        self.is_int(variable.ServerID)29    def test_BaseDir(self):30        self.is_str(variable.BaseDir)31    def test_DataDir(self):32        self.is_str(variable.DataDir)33    def test_Port(self):34        self.is_int(variable.Port)35    def test_CharacterSetServer(self):36        self.is_str(variable.CharacterSetServer)37    def test_Socket(self):38        self.is_str(variable.Socket)39    def test_ReadOnly(self):40        self.is_int(variable.ReadOnly)41    def test_SkipNameResolve(self):42        self.is_int(variable.SkipNameResolve)43    def test_LowerCaseTableNames(self):44        self.is_int(variable.LowerCaseTableNames)45    def test_ThreadCacheSize(self):46        self.is_int(variable.ThreadCacheSize)47    def test_TableOpenCache(self):48        self.is_int(variable.TableOpenCache)49    def test_TableDefinitionCache(self):50        self.is_int(variable.TableDefinitionCache)51    def test_TableOpenCacheInstances(self):52        self.is_int(variable.TableOpenCacheInstances)53    def test_MaxConnections(self):54        self.is_int(variable.MaxConnections)55    def test_BinlogFormat(self):56        self.is_str(variable.BinlogFormat)57    def test_LogBin(self):58        self.is_int(variable.LogBin)59    def test_BinlogRowsQueryLogEvents(self):60        self.is_int(variable.BinlogRowsQueryLogEvents)61    def test_LogSlaveUpdates(self):62        self.is_int(variable.LogSlaveUpdates)63    def test_ExpireLogsDays(self):64        self.is_int(variable.ExpireLogsDays)65    def test_BinlogCacheSize(self):66        self.is_int(variable.BinlogCacheSize)67    def test_SyncBinlog(self):68        self.is_int(variable.SyncBinlog)69    def test_ErrorLog(self):70        self.is_str(variable.ErrorLog)71    def test_GtidMode(self):72        self.is_str(variable.GtidMode)73    def test_EnforceGtidConsistency(self):74        self.is_str(variable.EnforceGtidConsistency)75    def test_MasterInfoRepository(self):76        self.is_str(variable.MasterInfoRepository)77    def test_RelayLogInfoRepository(self):78        self.is_str(variable.RelayLogInfoRepository)79    def test_SlaveParallelType(self):80        self.is_str(variable.SlaveParallelType)81    def test_SlaveParallelWorkers(self):82        self.is_int(variable.SlaveParallelWorkers)83    def test_InnodbDataFilePath(self):84        self.is_str(variable.InnodbDataFilePath)85    def test_InnodbTempDataFilePath(self):86        self.is_str(variable.InnodbTempDataFilePath)87    def test_InnodbBufferPoolFilename(self):88        self.is_str(variable.InnodbBufferPoolFilename)89    def test_InnodbLogGroupHomeDir(self):90        self.is_str(variable.InnodbLogGroupHomeDir)91    def test_InnodbLogFilesInGroup(self):92        self.is_int(variable.InnodbLogFilesInGroup)93    def test_InnodbLogFileSize(self):94        self.is_int(variable.InnodbLogFileSize)95    def test_InnodbFileformat(self):96        v = self.get_variable(variable.Version)97        if v.startswith('8'):98            #8.0.x ä»¥ä¸çæ¬å·²ç»ä¸åæinnodb_file_formatåæ°99            pass100        else:101            self.is_str(variable.InnodbFileformat)102    def test_InnodbFilePerTable(self):103        self.is_int(variable.InnodbFilePerTable)104    def test_InnodbOnlineAlterLogMaxSize(self):105        self.is_int(variable.InnodbOnlineAlterLogMaxSize)106    def test_InnodbOpenFiles(self):107        self.is_int(variable.InnodbOpenFiles)108    def test_InnodbPageSize(self):109        self.is_int(variable.InnodbPageSize)110    def test_InnodbThreadConcurrency(self):111        self.is_int(variable.InnodbThreadConcurrency)112    def test_InnodbReadIoThreads(self):113        self.is_int(variable.InnodbReadIoThreads)114    def test_InnodbWriteIoThreads(self):115        self.is_int(variable.InnodbWriteIoThreads)116    def test_InnodbPurgeThreads(self):117        self.is_int(variable.InnodbPurgeThreads)118    def test_InnodbLockWaitTimeout(self):119        self.is_int(variable.InnodbLockWaitTimeout)120    def test_InnodbSpinWaitDelay(self):121        self.is_int(variable.InnodbSpinWaitDelay)122    def test_InnodbAutoincLockMode(self):123        self.is_int(variable.InnodbAutoincLockMode)124    def test_InnodbStatsAutoRecalc(self):125        self.is_int(variable.InnodbStatsAutoRecalc)126    def test_InnodbStatsPersistent(self):127        self.is_int(variable.InnodbStatsPersistent)128    def test_InnodbStatsPersistentSamplePages(self):129        self.is_int(variable.InnodbStatsPersistentSamplePages)130    def test_InnodbBufferPoolInstances(self):131        self.is_int(variable.InnodbBufferPoolInstances)132    def test_InnodbAdaptiveHashIndex(self):133        self.is_int(variable.InnodbAdaptiveHashIndex)134    def test_InnodbChangeBuffering(self):135        self.is_str(variable.InnodbChangeBuffering)136    def test_InnodbChangeBufferMaxSize(self):137        self.is_int(variable.InnodbChangeBufferMaxSize)138    def test_InnodbFlushNeighbors(self):139        self.is_int(variable.InnodbFlushNeighbors)140    def test_InnodbFlushMethod(self):141        self.is_str(variable.InnodbFlushMethod)142    def test_InnodbDoublewrite(self):143        self.is_int(variable.InnodbDoublewrite)144    def test_InnodbLogBufferSize(self):145        self.is_int(variable.InnodbLogBufferSize)146    def test_InnodbFlushLogAtTimeout(self):147        self.is_int(variable.InnodbFlushLogAtTimeout)148    def test_InnodbFlushLogAtTrxCommit(self):149        self.is_int(variable.InnodbFlushLogAtTrxCommit)150    def test_InnodbBufferPoolSize(self):151        self.is_int(variable.InnodbBufferPoolSize)152    def test_Autocommit(self):153        self.is_str(variable.Autocommit)154    def test_InnodbOldBlocksPct(self):155        self.is_int(variable.InnodbOldBlocksPct)156    def test_InnodbOldBlocksTime(self):157        self.is_int(variable.InnodbOldBlocksTime)158    def test_InnodbReadAheadThreshold(self):159        self.is_int(variable.InnodbReadAheadThreshold)160    def test_InnodbRandomReadAhead(self):161        self.is_int(variable.InnodbRandomReadAhead)162    def test_InnodbBufferPoolDumpPct(self):163        self.is_int(variable.InnodbBufferPoolDumpPct)164    def test_InnodbBufferPoolDumpAtShutdown(self):165        self.is_int(variable.InnodbBufferPoolDumpAtShutdown)166    def test_InnodbBufferPoolLoadAtStartup(self):167        self.is_int(variable.InnodbBufferPoolLoadAtStartup)168    def test_QueryCacheLimit(self):169        if not self.get_variable(variable.Version).startswith('8'):170            self.is_int(variable.QueryCacheLimit)171    def test_QueryCacheMinResUnit(self):172        if not self.get_variable(variable.Version).startswith('8'):173            self.is_int(variable.QueryCacheMinResUnit)174    def test_QueryCacheSize(self):175        if not self.get_variable(variable.Version).startswith('8'):176            self.is_int(variable.QueryCacheSize)177    def test_QueryCacheType(self):178        if not self.get_variable(variable.Version).startswith('8'):179            self.is_int(variable.QueryCacheType)180    def test_Version(self):181        self.is_str(variable.Version)182if __name__=="__main__":...

day18.py

Source:day18.py

...6        self.left = ch17        self.right = ch28        self.parent = None9    def is_simple_node(self):10        return is_int(self.left) and is_int(self.right)11    def __repr__(self):12        return f'[{self.left},{self.right}]'13    def magnitude(self):14        mag = 015        if is_int(self.left):16            mag += 3 * self.left17        else:18            mag += 3 * self.left.magnitude()19        if is_int(self.right):20            mag += 2 * self.right21        else:22            mag += 2 * self.right.magnitude()23        return mag24def is_node(v): return isinstance(v, Node)25def is_int(v): return isinstance(v, int)26def parse_snail(d):27    stack = []28    current_level = 029    for c in filter(lambda s: s not in list(', '), d):30        if c == '[':31            current_level += 132        elif c == ']':33            v1 = stack.pop()34            v2 = stack.pop()35            n = Node(current_level, v2, v1)36            if is_node(v1): v1.parent = n37            if is_node(v2): v2.parent = n38            stack.append(n)39            current_level -= 140        else:41            stack.append(int(c))42    return stack[0]43def inc_level(p):44    if not is_node(p): return45    p.level += 146    inc_level(p.left)47    inc_level(p.right)48def add_snails(s1, s2):49    s = Node(0, s1, s2)50    s1.parent = s51    s2.parent = s52    inc_level(s)53    return s54def explode_left(p, v):55    t = p.parent56    if is_int(t.left):57        t.left += v58        return59    prev = p60    while t and prev == t.left:61        prev = t62        t = t.parent63    if t is None: return64    if is_int(t.left):65        t.left += v66        return67    t = t.left68    while is_node(t.right):69        t = t.right70    t.right += v71def explode_right(p, v):72    t = p.parent73    if is_int(t.right):74        t.right += v75        return76    prev = p77    while t and prev == t.right:78        prev = t79        t = t.parent80    if t is None: return81    if is_int(t.right):82        t.right += v83        return84    t = t.right85    while is_node(t.left):86        t = t.left87    t.left += v88def explode_node(n: Node):89    if n is None: return90    p = n.parent91    explode_right(n, n.right)92    explode_left(n, n.left)93    if p.left == n:94        p.left = 095    else:96        p.right = 097def split_node(n: Node):98    if n is None: return99    if is_int(n.left) and n.left > 9:100        v = n.left101        n.left = Node(n.level + 1, floor(v / 2), ceil(v / 2))102        n.left.parent = n103        return104    if is_int(n.right) and n.right > 9:105        v = n.right106        n.right = Node(n.level + 1, floor(v / 2), ceil(v / 2))107        n.right.parent = n108        return109def check_for_explode(p):110    if is_int(p): return None111    if is_node(p) and p.level == 5: return p112    for_explode = check_for_explode(p.left)113    if for_explode: return for_explode114    return check_for_explode(p.right)115def check_for_split(p):116    if is_int(p.left) and is_int(p.right):117        if p.left > 9 or p.right > 9: return p118        return None119    elif is_int(p.left):120        if p.left > 9: return p121        return check_for_split(p.right)122    elif is_int(p.right):123        found = check_for_split(p.left)124        if found: return found125        if p.right > 9: return p126        return None127    else:128        found = check_for_split(p.left)129        if found: return found130        found = check_for_split(p.right)131        if found: return found132    return None133def reduce_snail(snail):134    while True:135        found = check_for_explode(snail)136        if found:...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.