1 import datetime, zipfile, tarfile, logging, os, string, random, ipaddress, uuid, pytz, py7zr
2 import io, socket
3 from email.mime.text import MIMEText
4 from email.mime.multipart import MIMEMultipart
5 from email.mime.application import MIMEApplication
6 from email.utils import formatdate, make_msgid
7 from email.mime.image import MIMEImage
8 import email.generator, email.message, threading, multiprocessing, pdb, logging.handlers, linecache
9 import openpyxl
10 import tqdm
11 from faker import Faker
12 from multiprocessing import Pool
13
14 # email domain dict
15 email_domain = {
16 0: 'gmail.com', 1: 'yahoo.com', 2: 'msn.com', 3: 'hotmail.com', 4: 'aol.com', 5: '163.com', 6: 'live.com',
17 7: 'qq.com', 8: 'ask.com', 9: '0355.com', 10: 'googlemail.com', 11: 'sina.com', 12: 'sougou.com', 13: 'foxmail.com',
18 14: 'live.com', 15: '163.net', 16: '263.net', 17: 'yeah.net', 18: 'mail.com', 19: 'aim.com', 20: 'walla.com',
19 21: 'inbox.com', 22: 'hongkong.com', 23: 'ctimail.com', 24: 'hknet.com', 25: 'SEED.NET.TW',
20 26: 'TOPMARKEPLG.COM.TW', 27: 'PCHOME.COM.TW', 28: 'netzero.net', 29: 'vsnl.com', 30: 'yandex.ru'
21 }
22 # link dict
23 link_dict = {
24 1: 'https://www.baidu.com',
25 2: 'https://www.gitee.cn',
26 3: 'https://www.ccc.net',
27 4: rf'{random.choice(["www", "https://www"])}.{"".join(random.choices((string.ascii_letters + string.digits + chr(random.randint(0x4E00, 0X9FBF))), k=random.randint(5, 30)))}.{random.choice(["com", "cn", "net"])}',
28 }
29 eml_format = {
30 1: 'eml',
31 2: 'msg',
32 3: 'pst',
33 4: 'fox'
34 }
35 type_list = ['rar', 'tgz', 'zip', '7z']
36
37 # txt file path
38 PATH_TXT = rf'{os.getcwd()}\article_pic'
39 PATH_SAVE = rf'{os.getcwd()}\eml\eml_file'
40 PATH_ATTACHMENT = rf'{os.getcwd()}\attachment'
41 PATH_COMPRESS = rf'{os.getcwd()}\compressfiles'
42 PATH_LOG = rf'{os.getcwd()}\eml_log'
43 PATH_MSG = rf'{os.getcwd()}\eml\msg_file'
44 PATH_TOOL = rf'{os.getcwd()}\tool_msg\MailConverter.exe'
45
46 recip_dict = {}
47 sender_dict = {}
48
49
50 class Domain:
51
52 def __init__(self):
53 """
54 define msg structure
55 """
56 self.msg = MIMEMultipart()
57 self.path = ''
58 logging.basicConfig(level=logging.DEBUG)
59 handler = logging.handlers.RotatingFileHandler(filename=os.path.join(PATH_LOG, 'eml_log.log'),
60 maxBytes=20971520, backupCount=20)
61 self.logger = logging.getLogger()
62 formatter = logging.Formatter('[%(levelname)s] : [%(asctime)s] : [%(lineno)d]%(message)s')
63 handler.setFormatter(formatter)
64 self.logger.setLevel(logging.INFO)
65 self.logger.addHandler(handler)
66 self.fake = Faker()
67
68 # read/write file operation
69 def files_operation(self, name, method, msg_save_flag=False, encoding=None):
70 """
71 file read/write operation
72 :param name: the file name that need operation, full name
73 :param method: type of operation , read/write
74 :param msg_save_flag: email save flag
75 :param encoding: change encoding way , UTF-8 or auto
76 :return: read return only
77 """
78 if 'eml' in name or 'fox' in name or 'msg' in name or 'pst' in name:
79 self.path = os.path.join(PATH_SAVE, name)
80 elif 'log' in name:
81 self.path = os.path.join(PATH_LOG, name)
82 else:
83 self.path = os.path.join(PATH_TXT, name)
84
85 if 'rb' in method:
86 if 'PNG' in name:
87 self.path = os.path.join(PATH_TXT, name)
88 else:
89 self.path = os.path.join(PATH_ATTACHMENT, name)
90
91 with open(self.path, method, encoding=encoding) as file:
92 if 'r' in method:
93 if '.log' in name:
94 length = len(file.readlines())
95 return length
96 else:
97 print(self.path)
98 message = file.read()
99 return message
100 elif method == 'w':
101 if msg_save_flag:
102 file.write(self.msg.as_string())
103 elif method == 'wb':
104 if msg_save_flag:
105 file.write(self.msg.as_bytes())
106 if 'fox' in name:
107 gen = email.generator.BytesGenerator(file, mangle_from_=False, maxheaderlen=0)
108 gen.flatten(self.msg)
109
110 # create email local
111 def create_emails(self, recip_name, sender_name, create_num, attachment, debug_flag, att_num=1, picture_flag=1, link_flag=1,
112 flag='close'):
113 """
114
115 :param recip_name: name list for recipe
116 :param sender_name: name list for sender
117 :param create_num: just for file name
118 :param attachment: whether email need add attachment, 0 true / 1 false
119 :param att_num: attachment number, int
120 :param picture_flag: add picture in eml
121 :param link_flag: add link in article, random location in article or table in the end
122 :param flag: post flag
123 """
124
125 def cc_list_collect(recip_info):
126 """
127 dispose cc list information
128 :param recip_info:
129 :return:cc_list
130 """
131 choose_cc_set = set(recip_dict.values()) - set(recip_info)
132 return random.sample(list(choose_cc_set), random.randint(1, 10))
133
134 def add_link(body_of_html):
135 """
136 :param body_of_html:
137 :return: str
138 """
139 # link location in article
140 article_link_flag = random.randint(0, 3)
141 if article_link_flag == 0:
142 add_num = random.randint(1, 3)
143 local_random = [random.randint(28, len(body_html) - 7) for _ in range(add_num)]
144 # link just url not text
145 for local in local_random:
146 body_of_html = body_of_html[:int(local)] + f'<a href="{link_dict[random.randint(1, 3)]}">' \
147 f'{link_dict[random.randint(1, 3)]}</a>' + body_of_html[
148 int(local):]
149 log_info = f'add href in article flag [TRUE], num[{add_num}], url[{link_dict[random.randint(1, 3)]}] '
150 else:
151 log_info = 'add href in article flag [FALSE]'
152 # link location in the end of article
153 table_flag = random.randint(0, 0)
154 # link in table
155 if table_flag == 0:
156 body_of_html += '<style>td {height: 50px;width: 200px;text-align: center;vertical-align: middle;} ' \
157 'table {margin: auto;}</style>' \
158 '<table border="1"><tr><th>index</th><th>link</th><th>end</th></tr>'
159 num_link = random.randint(1, 5)
160 link_choose = [link_dict[random.randint(1, 3)] for _ in range(num_link)]
161 # random num of link
162 for link_add in link_choose:
163 if table_flag == 0:
164 body_of_html += f'<tr data_id="{num_link - 1}"><td>click link</td><td><a href="{link_add}">' \
165 f'here is a link</a></td><td>jump</td></tr>'
166 else:
167 body_of_html += f'<p><a href="{link_add}">here is a href</a></p>'
168 if table_flag == 0:
169 body_of_html += '</table>'
170 log_info += 'table flag [TRUE]'
171 if not debug_flag:
172 self.logger.info(log_info + f' end href num {num_link}, list:{link_choose}')
173 return body_of_html
174
175 def ip_info_active(num, name, data_real):
176 """
177
178 :param num: random ip number
179 :param name: recip name
180 :return:list
181 """
182 for _ in range(num):
183 none_del = []
184 for ele in [linecache.getline(os.path.join(PATH_LOG, 'ip_info.log'),
185 random.randint(1, self.files_operation('ip_info.log', 'r') - 1)
186 ).rstrip("\n").split(':') for _ in range(4)]:
187 if ele != ['']:
188 none_del.append(ele)
189 if len(none_del) < 2:
190 ip_info_active(1, name)
191 else:
192 if not debug_flag:
193 self.logger.info(f'info:{none_del}')
194 self.msg[
195 'Received'] = f'from {none_del[0][1]}({random.choice([f"{none_del[0][1]}", "unknown"])} [{none_del[0][0]}]) ' \
196 f'by {none_del[1][1]} with {random.choice(["SMTP", "ESMTP"])} ' \
197 f'id {uuid.uuid4().hex} for <{name}>; {data_real}'
198 name = random.choice(list(sender_dict.values()))
199 return num
200
201 def time_map():
202 start_time = datetime.date(2020, 1, 1)
203 end_time = datetime.date(2020, 12, 31)
204 random_date = start_time + datetime.timedelta(days=random.randint(0, (end_time - start_time).days))
205 start_min = datetime.time(0, 0, 0)
206 end_min = datetime.time(23, 59, 59)
207
208 random_min = datetime.time(
209 random.randint(start_min.hour, end_min.hour),
210 random.randint(start_min.minute, end_min.minute),
211 random.randint(start_min.second, end_min.second)
212 )
213 random_datetime = datetime.datetime.combine(random_date, random_min)
214 timestamp = random_datetime.timestamp()
215 dt = datetime.datetime.fromtimestamp(timestamp)
216 format_time = dt.strftime('%a, %d %b %Y %H:%M:%S +0800')
217 return format_time
218
219 # email info
220 save_name = f'2020_{create_num - 1}.{eml_format[random.randint(1, 1)]}'
221 self.msg['Message-ID'] = make_msgid(domain=sender_name.split('@')[-1])
222 eml_data = time_map()
223 # random read ip\domain form file
224 received_num = ip_info_active(random.randint(1, 1), name=sender_name, data_real=eml_data)
225 self.msg['From'] = sender_name
226 self.msg['To'] = ','.join(recip_name)
227 # main email
228 read_message = random.choice([file for file in os.listdir(PATH_TXT) if file.endswith('.txt')])
229 self.msg['Subject'] = read_message.split('.')[0] if not read_message.split('.')[0].isdigit() \
230 else self.fake.sentence(nb_words=10, variable_nb_words=True)
231 info_of_recip = str(recip_name).split('[')[-1].split(']')[0].split(',')
232 body_info = self.files_operation(read_message, 'r', encoding='utf-8')
233 body_html = f'<html><body><div id="info">"{body_info}"</div>'
234
235 cc_flag = random.randint(0, 2)
236 cc_name = ','.join(cc_list_collect(recip_name))
237 if cc_flag == 0:
238 self.msg['Cc'] = cc_name
239 if not debug_flag:
240 self.logger.info(f'cc list:{cc_list_collect(recip_name)}')
241
242 if "p" in flag:
243 self.post_info(sender_name, recip_name, cc_name, attachment, body_info, debug_flag=debug_flag)
244 else:
245 if link_flag == 0:
246 body_html = add_link(body_html)
247 if picture_flag == 0:
248 pic_link_flag = random.randint(0, 5)
249 if pic_link_flag == 0:
250 # picture only
251 flag_info = True
252 body_html += f'<div><p>Here is a img:</p><a href="{link_dict[random.randint(1, 3)]}">' \
253 f'<img src="cid:image1"></a></div>'
254 else:
255 # picture have a link to jump web
256 flag_info = False
257 body_html += f'<div><p>Here is a img:</p><img src="cid:image1"></div>'
258
259 picture_add = self.files_operation(
260 random.choice([file for file in os.listdir(PATH_TXT) if file.endswith('.PNG')]),
261 'rb')
262 img = MIMEImage(picture_add)
263 img.add_header('Content-ID', '<image1>')
264 self.msg.attach(img)
265 self.logger.info(f'picture_status:[TRUE] picture link flag: {flag_info}')
266 else:
267 self.logger.info('picture_status:[FALSE]')
268 body_html += '</body></html>'
269 body = MIMEText(body_html.encode('utf-8'), 'html', 'utf-8')
270
271 if 'fox' in save_name:
272 body.add_header('Content-Disposition', 'inline')
273 body.add_header('Content-Type', 'text/html; charset=utf-8')
274 self.msg.attach(body)
275
276 self.logger.info(f'Received number[{received_num}], sender list:{sender_name}')
277 self.logger.info(f'recipe list:{info_of_recip}')
278
279 # set email time
280 # send_time = formatdate(localtime=True)
281 self.msg['Date'] = eml_data
282 self.logger.info(f'email body from file:{read_message} '
283 f' the number of recip:{len(info_of_recip)} send time:{eml_data}')
284
285 # add attachment
286 if attachment == 0:
287 # num = 1 and any other
288 if att_num == 1:
289 file_name = [random.choice([file for file in os.listdir(PATH_ATTACHMENT)])]
290 else:
291 file_name = random.sample([file for file in os.listdir(PATH_ATTACHMENT)], att_num)
292
293 for att_ele in file_name:
294 att = self.files_operation(att_ele, 'rb')
295 attachment = MIMEApplication(att, name=att_ele)
296 attachment['Content-Disposition'] = f'attachment; filename="{att_ele}"'
297 # attachment.add_header('connect-disposition', 'attachment', filename=att_filename)
298 self.msg.attach(attachment)
299 self.logger.info(f"attachment_flag:[TRUE] push attachment num {att_num} Success!")
300 self.logger.info(f'attachments list:{file_name}')
301 else:
302 self.logger.info(f"push attachment not this time! attachment_flag:[FALSE]")
303
304 # save email
305 self.files_operation(save_name, 'wb', msg_save_flag=True)
306 self.logger.info(f'eml file save as {save_name} in {PATH_SAVE}')
307 os.chmod(os.path.join(PATH_SAVE, save_name), 0o600)
308
309 # random create msg/pst
310 flag_change_type = random.randint(1, 1)
311 if flag_change_type == 0:
312 os.system(PATH_TOOL + ' ' + 'to-msg' + ' ' + os.path.join(PATH_SAVE, save_name) + ' ' + PATH_MSG)
313 self.logger.info('change eml -> msg')
314
315 # IO data to fill the files specify the size
316 def io_size(self, file_name, file_size):
317 """
318 :param file_name: file name which want change size
319 :param file_size: file size you need, 'int' best
320 :return:
321 """
322 while os.path.getsize(file_name) < int(file_size):
323 read_eml_info = self.files_operation(file_name, 'r')
324 eml_size_before = len(read_eml_info)
325 if eml_size_before >= file_size:
326 break
327 else:
328 # additional_size = file_size - eml_size_before
329 # additional_content = ''.join(self.files_operation(
330 # random.choice([file for file in os.listdir(PATH_TXT)]), 'r', encoding='utf-8'))
331 additional_content = ''.join(
332 self.files_operation(os.path.join(PATH_TXT, '999.txt'), 'r', encoding='utf-8'))
333 read_eml_info += additional_content
334 self.files_operation(file_name, 'wb', msg_save_flag=True)
335 # print(len(read_eml_info))
336
337 @staticmethod
338 def random_name():
339 """
340 random name with string, length 5 - 12
341 :return: str
342 """
343 name_length = random.randint(5, 12)
344 return ''.join(random.choices((string.ascii_letters + string.digits), k=name_length))
345
346 # compress files
347 def compress_files(self, file_formats, com_time=1, passwd=''):
348 """
349 handles file compression
350 :param file_formats: file format , support .rar/.zip/.msg/.pst/.fox/.7z/tgz
351 :param com_time: the number of times that the file was compressed
352 :param passwd: whether encryption is required, True/False
353 """
354
355 def file_active(obj, file_name, type_files):
356 """
357 dispose compress files save method
358 :param obj: compress objective
359 :param file_name: filename list
360 :param type_files: compress type
361 """
362 for name in file_name:
363 if 'tgz' in name or 'zip' in name or 'rar' in name or '7z' in name:
364 path = os.path.join(PATH_COMPRESS, name)
365 elif '.eml' in name:
366 path = os.path.join(PATH_SAVE, name)
367 elif '.msg' in name:
368 path = os.path.join(PATH_MSG, name)
369 else:
370 path = os.path.join(PATH_ATTACHMENT, name)
371
372 if type_files == 'tgz':
373 obj.add(path, arcname=name)
374 elif type_files == 'rar' or type_files == '7z':
375 self.logger.info(f'{path}')
376 obj.writeall(path, arcname=name)
377 elif type_files == 'zip':
378 obj.write(path, arcname=name)
379
380 for file_format in file_formats:
381 for _ in range(com_time):
382 file_names = []
383 # file_list = [file for file in os.listdir(PATH_MSG)] + [file for file in os.listdir(PATH_SAVE)
384 # + [file for file in os.listdir(PATH_ATTACHMENT)]]
385 file_list = [file for file in os.listdir(PATH_SAVE)]
386 if _ >= 1:
387 file_names.append([f'test_{_ - 1}.{file_format}'])
388 file_names[0].append(random.choice(file_list))
389 else:
390 # file_names.append(random.sample(file_list, random.randint(1, len(file_list))))
391 file_names.append(random.sample(file_list, random.randint(1, 10)))
392 operate = 'w'
393 if file_format == 'zip':
394 method = zipfile.ZipFile
395 elif file_format == 'rar' or file_format == '7z':
396 method = py7zr.SevenZipFile
397 # pass
398 elif file_format == 'tgz':
399 method = tarfile.open
400 operate += ':gz'
401 else:
402 raise TypeError('file format error!')
403
404 with method(os.path.join(PATH_COMPRESS, f'test_{_}.{file_format}'), operate) as active_com:
405 file_active(active_com, file_names[0], file_format)
406 if _ < 1:
407 self.logger.info(f"Success create {file_format} file. File number in doc: {len(file_names[0])}"
408 + "\t" + f"File in compress:{file_names[0]}")
409 # if passwd:
410 # active_com.setpassword(passwd)
411
412 def create_user_sender(self, num):
413 """
414 create user for send and recipe
415 :param num: the number of user you need
416 :return: user dict
417 """
418
419 def init_name(number, dict_name):
420 for num_user in range(1, int(number / 3)):
421 name = self.random_name()
422 full_email = name + '@' + email_domain[random.randint(0, len(email_domain) - 1)]
423 dict_name[name] = full_email
424
425 # create user_dict
426 init_name(num, recip_dict)
427 # create sender_dict, half past of user_dict
428 for index, (key, value) in enumerate(recip_dict.items()):
429 if index < len(recip_dict) / 2:
430 sender_dict[key] = value
431 else:
432 break
433 init_name(num / 2, sender_dict)
434 self.logger.info(f'number of sender dict: {len(sender_dict)} number of recipe dict: {len(recip_dict)}')
435
436 def post_data(self, sender_name, recip_name, cc_name, attachment, body_info):
437 """
438 send json data to ES
439 :param attachment: attachment num
440 :param sender_name: sender list
441 :param recip_name: recip list
442 :param cc_name: cc list
443 :param body_info: html body
444 :return:
445 """
446
447 import json
448 import hashlib
449
450 def encrypted_random(num=1):
451 string_enc = "".join(random.choices((string.ascii_letters + string.digits), k=random.randint(0, 10)))
452 if num == 1:
453 encrypted = hashlib.md5()
454 encrypted.update(string_enc.encode('utf8'))
455 elif num == 2:
456 encrypted = hashlib.sha1(string_enc.encode('utf8'))
457 elif num == 3:
458 encrypted = hashlib.sha256(string_enc.encode('utf8'))
459 else:
460 raise TypeError('Type error!')
461 return encrypted.hexdigest()
462
463 def random_num(num):
464 a = 999999999999999999
465 return random.randint(1, int(str(a)[:num]))
466
467 def str_random(num=22):
468 return "".join(random.choices((string.ascii_letters + string.digits), k=random.randint(0, num)))
469
470 def choice_list(tp):
471 if tp == 1:
472 info_list = ["中文"]
473 elif tp == 2:
474 info_list = ['rar', 'tgz', 'zip', '7z', "pdf_f", "doc_f", "xlsx_f"]
475 else:
476 raise
477 return random.choice(info_list)
478
479 def time_map():
480 start_time = datetime.date(2017, 1, 1)
481 end_time = datetime.date(2023, 6, 1)
482 random_date = start_time + datetime.timedelta(days=random.randint(0, (end_time - start_time).days))
483 start_min = datetime.time(0, 0, 0)
484 end_min = datetime.time(23, 59, 59)
485 random_min = datetime.time(
486 random.randint(start_min.hour, end_min.hour),
487 random.randint(start_min.minute, end_min.minute),
488 random.randint(start_min.second, end_min.second)
489 )
490 random_datetime = datetime.datetime.combine(random_date, random_min)
491 timestamp = random_datetime.timestamp()
492 return int(timestamp)
493
494 random_id = random_num(16)
495 task_id = random_num(16)
496 attachment_id = random_num(16)
497 attachment_md5 = encrypted_random()
498 att_info = attachment_info_num(random.randint(1, 5))
499 url_info = link_dict[random.randint(1, 4)]
500 end_with = random.choice(type_list)
501 eml_domain = email_domain[random.randint(0, 30)]
502
503 json_info = {}
504
505 json_data = json.dumps(json_info)
506 return json_data
507
508 def post_info(self, sender_name, recip_name, cc_name, attachment, body_info, save_xlsx=True, read_from_xlsx=True,
509 debug_flag=False):
510 import requests
511
512 def xlsx_file(num_c):
513 excel_work = openpyxl.Workbook()
514 wk_sheet = excel_work.active
515 tqdm_time = 1
516 for _ in range(int(num_c)):
517 wk_sheet[f'A{_ + 1}'] = str(json_data)
518 with tqdm.tqdm(total=num_c, desc='progress', unit='num', colour='blue') as pbar:
519 pbar.update(tqdm_time)
520 tqdm_time += 1
521 wk_sheet.title = 'json'
522 excel_work.save(os.path.join(r'PATH_SAVE', 'json.xlsx'))
523
524 def txt_info(num_w, info):
525 for _ in range(num_w):
526 f = open('E:\data\json.txt', 'w')
527 f.writelines(info)
528 f.close()
529
530 def post_info_active(data_info):
531 for _ in range(10):
532 res = requests.post('http:url', data=data_info, headers=headers,
533 timeout=50)
534 ela_time = res.elapsed.total_seconds()
535 print(str(res) + str(ela_time))
536 if '200' not in str(res):
537 raise
538
539 headers = {'Content-Type': 'application/json'}
540 json_data = self.post_data(sender_name, recip_name, cc_name, attachment, body_info)
541
542 if not read_from_xlsx:
543 post_info_active(json_data)
544 if not save_xlsx:
545 open_time = datetime.datetime.now()
546 workbook = openpyxl.load_workbook(r'D:\pycharm\project\py\xlsx_file\json.xlsx')
547 sheet = workbook.active
548 end_time_read = datetime.datetime.now()
549 line = sheet.max_row
550 print(str(line) + ' ' + str(end_time_read - open_time))
551 for info_json in range(line):
552 cell = sheet[f'A{info_json + 500000}'].value
553 print(cell)
554 post_info_active(cell)
555 else:
556 xlsx_file(1000000)
557 # txt_info(100, str(json_data))
558
559 # processing logic
560 def generate_process(self, num_eml, debug_create_flag, post_request=False):
561 """
562 main process
563 """
564 logging.info(f'create email number : {num_eml}')
565 # create user/sender dict
566 create_start_time = datetime.datetime.now()
567 self.create_user_sender(500000)
568 print('create user dict SUCCESS!')
569 success_create_dict_time = datetime.datetime.now()
570 if not debug_create_flag:
571 self.logger.info(f'start create user time {create_start_time}, finish time {success_create_dict_time}, '
572 f'spend {success_create_dict_time - create_start_time}')
573
574 def create_active(min_trunk_num, max_trunk_num, num_progress, debug_flag):
575 """
576 email create active for threading
577 :return: None
578 """
579 tqdm_time = 1
580 # for trunk_times in range(1, len(num_eml/num_process)+1):
581 while min_trunk_num <= max_trunk_num:
582 # current progress
583 if not debug_flag:
584 with tqdm.tqdm(total=num_progress, desc='progress', unit='num', colour='blue') as pbar:
585 pbar.update(tqdm_time)
586 tqdm_time += 1
587 self.logger.info('-----------------------------------------------')
588 self.logger.info(f'The current number of cycles : {min_trunk_num}')
589 # self.logger.info(f'add data in log, exegesis when running')
590 self.msg = MIMEMultipart()
591 # random sender
592 sender_info = sender_dict[random.choice(list(sender_dict.keys()))]
593 recip_info = [recip_dict[info] for info in
594 random.choices(list(recip_dict.keys()), k=random.randint(1, 20))]
595 # reset body if sender = user
596 if sender_info == recip_info:
597 min_trunk_num -= 1
598 continue
599 min_trunk_num += 1
600 # create email, random attachment
601 if not post_request:
602 post_flag = 'close'
603 else:
604 post_flag = 'open'
605 self.create_emails(recip_info, sender_info, min_trunk_num, attachment=random.randint(0, 0),
606 att_num=random.randint(14, 14), picture_flag=random.randint(0, 3),
607 link_flag=random.randint(0, 3), debug_flag=debug_flag, flag=post_flag)
608 return None
609
610 start_time = datetime.datetime.now()
611
612 create_active(1, num_eml, num_eml, debug_flag=debug_create_flag)
613 end_time = datetime.datetime.now()
614 if not debug_create_flag:
615 self.logger.info(f'process start time {start_time}, '
616 f'process stop time {end_time}, spend {end_time - start_time}')
617
618 def mod_choose(self, debug_create_flag=False, is_post=False):
619 """
620 mod choose (delete no effect, just change main objective)
621 :param debug_create_flag: open it that you can debug the demo
622 :param is_post: the way of running, post or save eml
623 """
624 if debug_create_flag:
625 operate_for_user = '0'
626 else:
627 operate_for_user = input(
628 "choose the sys type(0--create email 1--create compress 2--change file size[coding...]):")
629
630 if operate_for_user == '0':
631 if debug_create_flag:
632 num_eml = 1
633 else:
634 num_eml = int(input("input the number that you want create: "))
635 self.generate_process(num_eml, debug_create_flag=debug_create_flag, post_request=is_post)
636
637 elif operate_for_user == '1':
638 type_choose = input('choose type(0--all 1--rar 2--tgz 3--zip 4--7z):')
639 com_time = int(input("Warning: compress files must have at least one file!" + "\n"
640 + "enter the number of time you want to compress the file (int): "))
641 if type_choose == '0':
642 type_active = type_list
643 else:
644 type_active = [type_list[int(type_choose) - 1]]
645 # create compress files after email create
646 compress_start_time = datetime.datetime.now()
647 self.compress_files(type_active, com_time=com_time)
648
649 compress_complete_time = datetime.datetime.now()
650 self.logger.info(f'compress time {compress_start_time}, complete time {compress_complete_time}, '
651 f'spend {compress_complete_time - compress_start_time}')
652
653 elif operate_for_user == '2':
654 file_size = input('input size to change(MB):')
655 self.io_size(os.path.join(PATH_SAVE, random.choice([file for file in os.listdir(PATH_SAVE)])),
656 int(file_size) * 1024 * 1024)
657
658
659 Domain().mod_choose(debug_create_flag=False, is_post=False)
标签：info,name,python,eml,self,random,压缩文件,num,file From： https://www.cnblogs.com/TOvOT/p/17464077.html