def test_type_is_all(self): var=[1,2,3,4,5,6,7] test=lzlist(var) # if value have the same type self.assertTrue(test.type_is_all(int)) self.assertFalse(test.type_is_all(str)) # if value have different types var= [1,2,"3",4,5,6,7] test=lzlist(var) self.assertFalse(test.type_is_all(int)) self.assertFalse(test.type_is_all(str))
def test_includetype(self): var= [1,2,3,4,"b","c"] test = lzlist(var) self.assertTrue(test.includes_type(int)) self.assertTrue(test.includes_type(str)) self.assertFalse(test.includes_type(list)) self.assertFalse(test.includes_type(lzdict))
def test_similar_to(self):
var = ["apple","apes","ape","app","application","bape","bang","bong"]
test=lzlist(var)
self.assertEqual(test.similar_to("ap"),["apple","apes","ape","app","application","bape"])
self.assertEqual(test.similar_to("^app"),["apple","app","application"])
self.assertEqual(test.similar_to("b..g"),["bang","bong"])
self.assertEqual(test.similar_to("^c"),[])
def stats(*args):
a = list(args)
dist = gts().columns // 2 - 1
file_types = str(lzlist(['.' + x.extension for x in a[7]]).unique)
STATSPAGE = f'''\
Time Taken:
|{'-'*(gts().columns- 2)}|
|{'Treating args':^{dist}}|{lzfloat(a[1]-a[0]).round_sf(8):^{dist}}|
|{'-'*(gts().columns- 2)}|
|{'Printing args':^{dist}}|{lzfloat(a[2]-a[1]).round_sf(8):^{dist}}|
|{'-'*(gts().columns- 2)}|
|{'Generating links':^{dist}}|{lzfloat(a[3]-a[2]).round_sf(8):^{dist}}|
|{'-'*(gts().columns- 2)}|
|{'Getting file lists':^{dist}}|{lzfloat(a[4]-a[3]).round_sf(8):^{dist}}|
|{'-'*(gts().columns- 2)}|
|{'Downloading image':^{dist}}|{lzfloat(a[5]-a[4]).round_sf(8):^{dist}}|
|{'-'*(gts().columns- 2)}|
|{'Converting files':^{dist}}|{lzfloat(a[6]-a[5]).round_sf(8):^{dist}}|
|{'-'*(gts().columns- 2)}|
Files:
|{'-'*(gts().columns- 2)}|
|{'Amount of files':^{dist}}|{len(a[7]):^{dist-1}}|
|{'-'*(gts().columns- 2)}|
|{'File types':^{dist}}|{file_types:^{dist-1}}|
|{'-'*(gts().columns- 2)}|
'''
return STATSPAGE
def test_type_includes(self):
var= [1,2,3,4,5,6,[1,2,3,{4:5},{7}],"4"]
test=lzlist(var)
# type_includes only checks first layer of lists
self.assertTrue(test.type_includes(int))
self.assertTrue(test.type_includes(str))
self.assertTrue(test.type_includes(list))
self.assertFalse(test.type_includes(set))
self.assertFalse(test.type_includes(dict))
# test for different data types
var = [{1,2},[3,4]]
test=lzlist(var)
self.assertTrue(test.type_includes(set))
self.assertTrue(test.type_includes(list))
self.assertFalse(test.type_includes(str))
self.assertFalse(test.type_includes(int))
def test_split_by(self): var=[1,2,3,4,5,6,7,8,9] test=lzlist(var) self.assertEqual(test.split_by(3),[[1,2,3],[4,5,6],[7,8,9]]) # split_by function replaces original string test.revert() self.assertEqual(test.split_by(4),[[1,2,3,4],[5,6,7,8],[9]])
def test_choice(self): var=[1,2,3,4,5,6,7,8,9,0] test=lzlist(var) random.seed(1234) # self.assertEqual(test.choice(random.randrange(1,10)),_k) self.assertTrue(all([i in var for i in test.choice(10)])) self.assertTrue(len(test.choice(1010)), 1010)
def generalconfigs():
global followingparties
global configs
# Makes the following key unique
for k, v in configs.items():
if k == "GENERAL":
continue
for key, value in v.items():
if type(value) != list:
continue
v[key] = sorted(lzlist(value).unique, key=lambda x: x[0].lower())
# Add a list of total tracking guild.
configs["GENERAL"]["trackingguild"] = sorted(
list(
set(
lzlist(
i["trackingguild"]
for i in [v for k, v in configs.items()
if k != "GENERAL"]).join_all())))
configs["GENERAL"]["trackingplayer"] = sorted(
list(
set(
lzlist(
i["trackingplayer"]
for i in [v for k, v in configs.items()
if k != "GENERAL"]).join_all())))
# get the smallest kill fame in all guilds
try:
configs["GENERAL"]["minimumkillfame"] = min([
i["minimumkillfame"]
for i in [v for k, v in configs.items() if k != "GENERAL"]
])
# No guild has set a minimum fame yet// have not joined any guild
except ValueError:
pass
# Set a list of tracking guilds and players to the kb object
kb.tracking = configs["GENERAL"]["trackingplayer"] + configs["GENERAL"][
"trackingguild"]
# Set the minimum kill fame of the killboard
kb.minkillfame = configs["GENERAL"]["minimumkillfame"]
# update the following parties for the colors!
followingparties = configs["GENERAL"]["trackingguild"] + configs[
"GENERAL"]["trackingplayer"]
#set a latest item
configs["latest_eventid"] = kb.latest
# dump everything into the configs file
return updateconfigs(configs)
def test_tostr(self): var= [97,98,99] test=lzlist(var) self.assertEqual(test.tostr,"abc") var= [102, 101, 105, 109, 97, 111, 109, 105, 97, 111] test=lzlist(var) self.assertEqual(test.tostr,"feimaomiao") var=[77, 97, 116, 116, 104, 101, 119, 32, 76, 97, 109] test=lzlist(var) self.assertEqual(test.tostr,"Matthew Lam") # test for other languages var=[49324, 46993, 54644] test=lzlist(var) self.assertEqual(test.tostr,"사랑해")
def test_all_without_type(self):
var=[1,"2",3,[1,2,3],{1:2},{5},"4",5]
test=lzlist(var)
self.assertEqual(test.all_without_type(int),["2",[1,2,3],{1:2},{5},"4"])
self.assertEqual(test.all_without_type(list),[1,"2",3,{1:2},{5},"4",5])
# test for >1 types
self.assertEqual(test.all_without_type((int,str,list)),[{1:2},{5}])
self.assertEqual(test.all_without_type((int,str,list,dict,set)),[])
def test_run_all(self): # test function that will be called def _t(v=1): return lzint(v).iseven var = [_t, _t, _t, _t, _t, print, _t, _t] test= lzlist(var) self.assertEqual(test.run_all([1,3,6],2), [False, True, False, True,False,None, True,False]) self.assertEqual(test.run_all([0,1,2],v=2),[True,True,True,False,False,None,False,False])
def test_before(self):
var = [1,2,3,1,2,1]
test=lzlist(var)
self.assertEqual(test.before(2),[1,1])
self.assertEqual(test.before(1),[1,3,2])
self.assertEqual(test.before(3),[2])
self.assertEqual(test.before("a"),[])
def test_next(self):
var=[0,1,2,3,4,5,6,7,8,9]
test=lzlist(var)
self.assertEqual(test.next(0),[1])
self.assertEqual(test.next(5),[6])
# Final unit
self.assertEqual(test.next(9),[0])
# Default case
self.assertEqual(test.next() ,[1])
# Non existense case
self.assertEqual(test.next("a"),[])
var = [1,2,1,2]
test=lzlist(var)
self.assertEqual(test.next(1),[2,2])
def test_includes(self):
var= [1,"2",3,[4,5]]
test=lzlist(var)
# test for include
self.assertTrue(test.includes(1))
self.assertTrue(test.includes("2"))
self.assertTrue(test.includes(3))
self.assertTrue(test.includes([4,5]))
# test for not include
self.assertFalse(test.includes("1"))
self.assertFalse(test.includes([4]))
self.assertFalse(test.includes([4,"5"]))
def test_shuffle(self):
var=[1,2,3,4,5,6,7,8,9]
test=lzlist(var)
MSGSTRING=f"""\
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
For test lzlist.shuffle:
Before shuffle: {test}
After shuffle: {test.shuffle(rp=True)}
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"""
with open(OUTPUTFILE,"a") as file:
print(MSGSTRING, file=file)
self.assertTrue(all([i in test for i in var]))
def test_forall(self):
import itertools
var=[1,2,3,4]
test=lzlist(var)
# return type is list for function forall instead of tuple
self.assertEqual(test.forall("pro"),[list(i) for i in itertools.product(var,repeat=2)])
self.assertEqual(test.forall("product"),[list(i) for i in itertools.product(var,repeat=2)])
self.assertEqual(test.forall("per"),[list(i) for i in itertools.permutations(var,2)])
self.assertEqual(test.forall("permuutations"),[list(i) for i in itertools.permutations(var,2)])
self.assertEqual(test.forall("combinations"), [list(i) for i in itertools.combinations(var,2)])
self.assertEqual(test.forall("combinations"), [list(i) for i in itertools.combinations(var,2)])
self.assertEqual(test.forall("combinations_with_replacement"), [list(i) for i in itertools.combinations_with_replacement(var,2)])
self.assertEqual(test.forall("random words that does not make sense"),[list(i) for i in itertools.combinations_with_replacement(var,2)])
del itertools
def test_deepshuffle(self):
var = [1,2,3,4,5,6,[7,8,9,[1,2,3,4]]]
test=lzlist(var)
# All values should be the same
MSGSTRING=f"""\
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
For test lzl.deeppshuffle:
Before shuffle: {test}
After shuffle: {test.deepshuffle()}
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"""
with open(OUTPUTFILE,"a") as file:
print(MSGSTRING,file=file)
self.assertTrue(all([i in var for i in test.deepshuffle()]))
async def inventory(self):
stuff = []
async with aiohttp.ClientSession(
headers={"Connection": "close"}) as session:
for i in [j for j in self.victim["Inventory"] if j is not None]:
itemworth = _getaverage(
await get_iw_json(i["Type"],
session,
sendchannel=self.debugchannel),
i["Quality"])
stuff.append(
(items_get(i["Type"],
i["Quality"]), int(i["Count"]), int(itemworth)))
for i in stuff:
self.gw += i[2] * i[1]
sortedstuff = sorted(stuff, key=lambda x: x[2], reverse=True)
rs = lambda x, y: "\n".join([str(i[int(x)]) for i in tuple(y)])
if any(len(rs(0, sortedstuff)) > 1024 for x in range(0, 3)):
s0, s1 = (lzlist(sortedstuff).split_to(2))
return (rs(0, s0), rs(1, s0), rs(2, s0), rs(0, s1), rs(1, s1),
rs(2, s1), True)
return (rs(0, sortedstuff), rs(1, sortedstuff), rs(2, sortedstuff), "",
"", "", False)
def test_unique(self): var=[1,2,1,1,2,1,3,1,4,15,1,2,13,[1,2,3,9]] test= lzlist(var) self.assertEqual(test.unique,[1,2,3,4,9,13,15])
def test_basic(self):
var = [1,2,3,4,"a","b","c","d",["a","b"],{"a","b"}]
test = lzlist(var)
self.assertEqual(test, var)
def test_split_to(self): var=[1,2,3,4,5,6,7,8] test=lzlist(var) self.assertEqual(test.split_to(2),[[1,2,3,4],[5,6,7,8]]) test.revert() self.assertEqual(test.split_to(3),[[1,2,3],[4,5,6],[7,8]])
def test_split_mod(self): var=[1,4,7,2,5,8,3,6,9] test=lzlist(var) self.assertEqual(test.split_mod(3),[[1,2,3],[4,5,6],[7,8,9]])
def test_listtypes(self): var=[1,2,3,[1,2],"a","b","c"] test=lzlist(var) self.assertEqual(test.list_types, [list,int,str])
def test_join_all(self): var= [1,[2,[3,[4,[5,[6,[7,[8,[9,10],11],12],13],14],15],16],17],18] test=lzlist(var) self.assertEqual(test.join_all(),[i for i in range(1,19)]) # joinall function replaces original string self.assertEqual(test,[i for i in range(1,19)])
def test_all_index(self): var= [1,2,1,2,3,4,3,43,5,4,3,3,2,22,1,3] test = lzlist(var) self.assertEqual(test.all_index(1),[0,2,14])
def test_revert(self): var= [1,2,3,4,"b","c"] test= lzlist(var) test.clear() self.assertEqual(test.revert(), var) self.assertEqual(test, var)
def test_count_type(self):
var = [1,"2",[3],{4:"4"},{5},range(6),7,8,"9",{10}]
test=lzlist(var)
self.assertEqual(test.count_type(int),3)
self.assertEqual(test.count_type(str),2)
self.assertEqual(test.count_type((int,str)),5)
