def downloadUnpause(gid):
download_info_file = os.path.join(download_info_folder, gid)
readList(download_info_file)
# this section is sending unpause request to aria2 . see aria2
# documentation for more informations.
try:
answer = server.aria2.unpause(gid)
version_answer = 'ok'
except:
answer = str("None")
return answer
def endTime(end_hour, end_minute, gid):
time.sleep(1)
print("end time is actived " + gid)
logger.sendToLog("End time is activated " + gid, "INFO")
sigma_end = sigmaTime(end_hour, end_minute)
sigma_now = nowTime()
download_info_file = os.path.join(download_info_folder, gid)
while sigma_end != sigma_now:
status_file = 'no'
# waiting for start downloading :
while status_file == 'no':
time.sleep(0.5)
try:
download_info_file_list = readList(download_info_file)
status_file = 'yes'
status = download_info_file_list[1]
except:
status_file = 'no'
# checking download's status
if status == 'downloading' or status == 'paused' or status == 'waiting':
answer = 'continue'
else:
answer = 'end'
print("Download ended before! " + str(gid))
logger.sendToLog("Download has been finished! " + str(gid), "INFO")
break
sigma_now = nowTime()
time.sleep(2.1)
if answer != 'end':
print("Time is Up")
logger.sendToLog("Time is up!", "INFO")
answer = downloadStop(gid)
i = 0
# trying to stop download 10 times
while answer == 'None' and (i <= 9):
time.sleep(1)
answer = downloadStop(gid)
i = i + 1
if (answer == 'None') and (os_type != 'Windows'):
os.system("killall aria2c")
download_info_file_list = readList(download_info_file)
add_link_dictionary = download_info_file_list[9]
add_link_dictionary['end_hour'] = None
add_link_dictionary['end_minute'] = None
download_info_file_list[9] = add_link_dictionary
download_info_file_list[1] = "stopped"
writeList(download_info_file, download_info_file_list)
def downloadPause(gid):
download_info_file = os.path.join(download_info_folder, gid)
readList(download_info_file)
# this section is sending pause request to aira2 . see aria2 documentation
# for more informations
try:
answer = server.aria2.pause(gid)
version_answer = 'ok'
except:
answer = str("None")
print(answer + " paused")
logger.sendToLog(answer + " paused", "INFO")
return answer
def startTime(start_hour, start_minute, gid):
print("Download starts at " + start_hour + ":" + start_minute)
logger.sendToLog("Download starts at " + start_hour + ":" + start_minute,
"INFO")
sigma_start = sigmaTime(start_hour, start_minute) # getting sima time
sigma_now = nowTime() # getting sigma now time
# getting download_info_file path
download_info_file = os.path.join(download_info_folder, gid)
status = 'scheduled' # defining status
while sigma_start != sigma_now: # this loop is countinuing until download time arrival!
time.sleep(2.1)
sigma_now = nowTime()
try: # this part is reading download informations for finding download status , perhaps user canceled download! try command used for avoiding some problems when readList reading files
download_info_file_list = readList(download_info_file)
except:
download_info_file_list = ['some_name', 'scheduled']
# if download_info_file_list[1] = stopped >> it means that user
# canceled download , and loop is breaking!
if download_info_file_list[1] == 'stopped':
status = 'stopped'
break
else:
status = 'scheduled'
return status # if user canceled download , then 'stopped' returns and if download time arrived then 'scheduled' returns!
def downloadStop(gid):
download_info_file = os.path.join(download_info_folder, gid)
download_info_file_list = readList(download_info_file)
# if status is scheduled so download request is not sended to aria2 yet!
status = download_info_file_list[1]
if status != 'scheduled':
try:
# this section is sending request to aria2 to removing download.
# see aria2 documentation for more informations
answer = server.aria2.remove(gid)
if status == 'downloading':
server.aria2.removeDownloadResult(gid)
except:
answer = str("None")
print(answer + " stopped")
logger.sendToLog(answer + " stopped", "INFO")
else:
answer = 'stopped'
if status != 'complete':
add_link_dictionary = download_info_file_list[9]
add_link_dictionary['start_hour'] = None
add_link_dictionary['start_minute'] = None
add_link_dictionary['end_hour'] = None
add_link_dictionary['end_minute'] = None
add_link_dictionary['after_download'] = 'None'
download_info_file_list[1] = "stopped"
download_info_file_list[9] = add_link_dictionary
writeList(download_info_file, download_info_file_list)
return answer
def __init__(self, parent, gid, persepolis_setting):
super().__init__(persepolis_setting)
self.persepolis_setting = persepolis_setting
self.parent = parent
self.gid = gid
self.status = None
self.resume_pushButton.clicked.connect(self.resumePushButtonPressed)
self.stop_pushButton.clicked.connect(self.stopPushButtonPressed)
self.pause_pushButton.clicked.connect(self.pausePushButtonPressed)
self.download_progressBar.setValue(0)
self.limit_pushButton.clicked.connect(self.limitPushButtonPressed)
self.limit_frame.setEnabled(False)
self.limit_checkBox.toggled.connect(self.limitCheckBoxToggled)
self.after_frame.setEnabled(False)
self.after_checkBox.toggled.connect(self.afterCheckBoxToggled)
self.after_pushButton.clicked.connect(self.afterPushButtonPressed)
# check if limit speed actived by user or not
download_info_file_list_len = 1
while download_info_file_list_len != 13:
download_info_file = download_info_folder + "/" + self.gid
download_info_file_list = readList(download_info_file)
download_info_file_list_len = len(download_info_file_list)
add_link_dictionary = download_info_file_list[9]
limit = add_link_dictionary['limit']
if limit != 0:
limit_number = limit[:-1]
limit_unit = limit[-1]
self.limit_spinBox.setValue(int(limit_number))
if limit_unit == 'K':
self.after_comboBox.setCurrentIndex(0)
else:
self.after_comboBox.setCurrentIndex(1)
self.limit_checkBox.setChecked(True)
self.after_comboBox.currentIndexChanged.connect(
self.afterComboBoxChanged)
self.limit_comboBox.currentIndexChanged.connect(
self.limitComboBoxChanged)
self.limit_spinBox.valueChanged.connect(self.limitComboBoxChanged)
# setting window size and position
size = self.persepolis_setting.value(
'ProgressWindow/size', QSize(595, 274))
position = self.persepolis_setting.value(
'ProgressWindow/position', QPoint(300, 300))
self.resize(size)
self.move(position)
def limitCheckBoxToggled(self, checkBoxes):
if self.limit_checkBox.isChecked() == True:
self.limit_frame.setEnabled(True)
self.limit_pushButton.setEnabled(True)
else:
self.limit_frame.setEnabled(False)
if self.status != 'scheduled':
download.limitSpeed(self.gid, "0")
else:
download_info_file = download_info_folder + '/' + self.gid
download_info_file_list = readList(download_info_file)
add_link_dictionary = download_info_file_list[9]
add_link_dictionary['limit'] = '0'
download_info_file_list[9] = add_link_dictionary
writeList(download_info_file, download_info_file_list)
def limitPushButtonPressed(self, button):
self.limit_pushButton.setEnabled(False)
if self.limit_comboBox.currentText() == "KB/S":
limit = str(self.limit_spinBox.value()) + str("K")
else:
limit = str(self.limit_spinBox.value()) + str("M")
# if download was started before , send the limit_speed request to aria2 .
# else save the request in download_information_file
if self.status != 'scheduled':
download.limitSpeed(self.gid, limit)
else:
download_info_file = os.path.join(download_info_folder, self.gid)
download_info_file_list = readList(download_info_file)
add_link_dictionary = download_info_file_list[9]
add_link_dictionary['limit'] = limit
download_info_file_list[9] = add_link_dictionary
writeList(download_info_file, download_info_file_list)
def compatibility():
if os.path.isfile(queues_list_file):
persepolis_db = PersepolisDB()
# add categories to category_db_table in data_base
f = open(queues_list_file)
queues_list = f.readlines()
f.close()
# remove queues_list_file
remove(queues_list_file)
else:
return
category_list = ['All Downloads', 'Single Downloads']
for line in queues_list:
queue_name = line.strip()
category_list.append(queue_name)
for category in category_list:
gid_list = []
if category == 'All Downloads':
category_info_file = download_list_file
else:
category_info_file = os.path.join(category_folder, category)
f = open(category_info_file)
category_info_file_list = f.readlines()
f.close()
for item in category_info_file_list:
gid = item.strip()
gid_list.append(gid)
category_dict = {
'category': category,
'start_time_enable': 'no',
'start_time': '0:0',
'end_time_enable': 'no',
'end_time': '0:0',
'reverse': 'no',
'limit_enable': 'no',
'limit_value': '0K',
'after_download': 'no',
'gid_list': str(gid_list)
}
# add category to data_base
if category == 'All Downloads' or category == 'Single Downloads':
persepolis_db.updateCategoryTable([category_dict])
else:
persepolis_db.insertInCategoryTable(category_dict)
# add items to download_db_table in data base
f_download_list_file = open(download_list_file)
download_list_file_lines = f_download_list_file.readlines()
f_download_list_file.close()
for line in download_list_file_lines:
gid = line.strip()
download_info_file = os.path.join(download_info_folder, gid)
download_info_file_list = readList(download_info_file)
add_link_dictionary = download_info_file_list[9]
dict = {
'file_name': download_info_file_list[0],
'status': download_info_file_list[1],
'size': download_info_file_list[2],
'downloaded_size': download_info_file_list[3],
'percent': download_info_file_list[4],
'connections': download_info_file_list[5],
'rate': download_info_file_list[6],
'estimate_time_left': download_info_file_list[7],
'gid': download_info_file_list[8],
'link': add_link_dictionary['link'],
'first_try_date': download_info_file_list[10],
'last_try_date': download_info_file_list[11],
'category': download_info_file_list[12]
}
add_link_dictionary['gid'] = download_info_file_list[8]
if 'user-agent' in add_link_dictionary.keys():
add_link_dictionary['user_agent'] = add_link_dictionary.pop(
'user-agent')
if 'load-cookies' in add_link_dictionary.keys():
add_link_dictionary['load_cookies'] = add_link_dictionary.pop(
'load-cookies')
add_link_dictionary['limit_value'] = 0
keys_list = [
'gid', 'out', 'start_time', 'end_time', 'link', 'ip', 'port',
'proxy_user', 'proxy_passwd', 'download_user', 'download_passwd',
'connections', 'limit_value', 'download_path', 'referer',
'load_cookies', 'user_agent', 'header', 'after_download'
]
for key in keys_list:
# if a key is missed in dict,
# then add this key to the dict and assign None value for the key.
if key not in add_link_dictionary.keys():
add_link_dictionary[key] = None
# write information in data_base
persepolis_db.insertInDownloadTable([dict])
persepolis_db.insertInAddLinkTable([add_link_dictionary])
# close connections
persepolis_db.closeConnections()
# remove unwanted files and folders
for file in [download_list_file, download_list_file_active]:
remove(file)
for folder in [category_folder, queue_info_folder]:
removeDir(folder)
def compatibility():
if os.path.isfile(queues_list_file):
persepolis_db = PersepolisDB()
# add categories to category_db_table in data_base
f = open(queues_list_file)
queues_list = f.readlines()
f.close()
# remove queues_list_file
remove(queues_list_file)
else:
return
category_list = ['All Downloads', 'Single Downloads']
for line in queues_list:
queue_name = line.strip()
category_list.append(queue_name)
for category in category_list:
gid_list = []
if category == 'All Downloads':
category_info_file = download_list_file
else:
category_info_file = os.path.join(category_folder, category)
f = open(category_info_file)
category_info_file_list = f.readlines()
f.close()
for item in category_info_file_list:
gid = item.strip()
gid_list.append(gid)
category_dict = {'category': category,
'start_time_enable': 'no',
'start_time': '0:0',
'end_time_enable': 'no',
'end_time': '0:0',
'reverse': 'no',
'limit_enable': 'no',
'limit_value': '0K',
'after_download': 'no',
'gid_list': str(gid_list)
}
# add category to data_base
if category == 'All Downloads' or category == 'Single Downloads':
persepolis_db.updateCategoryTable([category_dict])
else:
persepolis_db.insertInCategoryTable(category_dict)
# add items to download_db_table in data base
f_download_list_file = open(download_list_file)
download_list_file_lines = f_download_list_file.readlines()
f_download_list_file.close()
for line in download_list_file_lines:
gid = line.strip()
download_info_file = os.path.join(download_info_folder, gid)
download_info_file_list = readList(download_info_file)
add_link_dictionary = download_info_file_list[9]
dict = {'file_name': download_info_file_list[0],
'status': download_info_file_list[1],
'size': download_info_file_list[2],
'downloaded_size': download_info_file_list[3],
'percent': download_info_file_list[4],
'connections': download_info_file_list[5],
'rate': download_info_file_list[6],
'estimate_time_left': download_info_file_list[7],
'gid': download_info_file_list[8],
'link': add_link_dictionary['link'],
'first_try_date': download_info_file_list[10],
'last_try_date': download_info_file_list[11],
'category': download_info_file_list[12]}
add_link_dictionary['gid'] = download_info_file_list[8]
if 'user-agent' in add_link_dictionary.keys():
add_link_dictionary['user_agent'] = add_link_dictionary.pop('user-agent')
if 'load-cookies' in add_link_dictionary.keys():
add_link_dictionary['load_cookies'] = add_link_dictionary.pop('load-cookies')
add_link_dictionary['limit_value'] = 0
keys_list = ['gid',
'out',
'start_time',
'end_time',
'link',
'ip',
'port',
'proxy_user',
'proxy_passwd',
'download_user',
'download_passwd',
'connections',
'limit_value',
'download_path',
'referer',
'load_cookies',
'user_agent',
'header',
'after_download']
for key in keys_list:
# if a key is missed in dict,
# then add this key to the dict and assign None value for the key.
if key not in add_link_dictionary.keys():
add_link_dictionary[key] = None
# write information in data_base
persepolis_db.insertInDownloadTable([dict])
persepolis_db.insertInAddLinkTable([add_link_dictionary])
# close connections
persepolis_db.closeConnections()
# remove unwanted files and folders
for file in [download_list_file, download_list_file_active]:
remove(file)
for folder in [category_folder, queue_info_folder]:
removeDir(folder)
def downloadStatus(gid):
try:
download_status = server.aria2.tellStatus(gid, [
'status', 'connections', 'errorCode', 'errorMessage',
'downloadSpeed', 'connections', 'dir', 'totalLength',
'completedLength', 'files'
])
except:
download_status = {
'status': None,
'connections': None,
'errorCode': None,
'errorMessage': None,
'downloadSpeed': None,
'connections': None,
'dir': None,
'totalLength': None,
'completedLength': None,
'files': None
}
# file_status contains name of download file
try:
file_status = str(download_status['files'])
file_status = file_status[1:-1]
file_status = ast.literal_eval(file_status)
path = str(file_status['path'])
file_name = urllib.parse.unquote(os.path.basename(path))
if not (file_name):
file_name = None
except:
file_name = None
for i in download_status.keys():
if not (download_status[i]):
download_status[i] = None
try:
file_size = float(download_status['totalLength'])
except:
file_size = None
try:
downloaded = float(download_status['completedLength'])
except:
downloaded = None
if (downloaded != None and file_size != None and file_size != 0):
file_size_back = file_size
if int(file_size / 1073741824) != 0:
file_size = file_size / 1073741824
size_str = str(round(file_size, 2)) + " GB"
elif int(file_size / 1048576) != 0:
size_str = str(int(file_size / 1048576)) + " MB"
elif int(file_size / 1024) != 0:
size_str = str(int(file_size / 1024)) + " KB"
else:
size_str = str(file_size)
downloaded_back = downloaded
if int(downloaded / 1073741824) != 0:
downloaded = downloaded / 1073741824
downloaded_str = str(round(downloaded, 2)) + " GB"
elif int((downloaded / 1048576)) != 0:
downloaded_str = str(int(downloaded / 1048576)) + " MB"
elif int(downloaded / 1024) != 0:
downloaded_str = str(int(downloaded / 1024)) + " KB"
else:
downloaded_str = str(downloaded)
file_size = file_size_back
downloaded = downloaded_back
percent = int(downloaded * 100 / file_size)
percent_str = str(percent) + "%"
else:
percent_str = None
size_str = None
downloaded_str = None
try:
download_speed = int(download_status['downloadSpeed'])
except:
download_speed = 0
if (downloaded != None and download_speed != 0):
estimate_time_left = int((file_size - downloaded) / download_speed)
if int((download_speed / 1073741824)) != 0:
download_speed = download_speed / 1073741824
download_speed_str = str(round(download_speed, 2)) + " GB/S"
elif int((download_speed / 1048576)) != 0:
download_speed_num = download_speed / 1048576
download_speed_str = str(round(download_speed_num, 2)) + " MB/S"
elif int((download_speed / 1024)) != 0:
download_speed_str = str(int(download_speed / 1024)) + " KB/S"
else:
download_speed_str = str(download_speed)
eta = ""
if estimate_time_left >= 3600:
eta = eta + str(int(estimate_time_left / 3600)) + "h"
estimate_time_left = estimate_time_left % 3600
eta = eta + str(int(estimate_time_left / 60)) + "m"
estimate_time_left = estimate_time_left % 60
eta = eta + str(estimate_time_left) + "s"
elif estimate_time_left >= 60:
eta = eta + str(int(estimate_time_left / 60)) + "m"
estimate_time_left = estimate_time_left % 60
eta = eta + str(estimate_time_left) + "s"
else:
eta = eta + str(estimate_time_left) + "s"
estimate_time_left_str = eta
else:
download_speed_str = "0"
estimate_time_left_str = None
try:
connections_str = str(download_status['connections'])
except:
connections_str = None
try:
status_str = str(download_status['status'])
except:
status_str = None
download_info_file = os.path.join(download_info_folder, gid)
download_info_file_list = readList(download_info_file)
add_link_dictionary = download_info_file_list[9]
download_path = add_link_dictionary['download_path']
final_download_path = add_link_dictionary['final_download_path']
# if final_download_path did not defined and download_path equaled to user
# default download folder then this section is finding final_download_path
# according to file extension
if final_download_path == None:
if file_name != None:
# finding default download_path
persepolis_setting.sync()
if persepolis_setting.value(
'settings/download_path') == download_path:
final_download_path = findDownloadPath(
file_name, download_path,
persepolis_setting.value('settings/subfolder'))
add_link_dictionary[
'final_download_path'] = final_download_path
else:
final_download_path = download_path
add_link_dictionary[
'final_download_path'] = final_download_path
# if download has completed , then move file to the download folder
if (status_str == "complete"):
if final_download_path != None:
download_path = final_download_path
file_path = downloadCompleteAction(path, download_path, file_name)
add_link_dictionary['file_path'] = file_path
add_link_dictionary['final_download_path'] = file_path
file_name = urllib.parse.unquote(os.path.basename(file_path))
# rename active status to downloading
if (status_str == "active"):
status_str = "downloading"
# rename removed status to stopped
if (status_str == "removed"):
status_str = "stopped"
if (status_str == "error"):
add_link_dictionary["error"] = str(download_status['errorMessage'])
server.aria2.removeDownloadResult(gid)
if (status_str == "None"):
status_str = None
# setting firs_try_date and last_try_date
date_list = add_link_dictionary['firs_try_date']
firs_try_date = str(date_list[0]) + '/' + str(date_list[1]) + '/' + str(
date_list[2]) + ' , ' + str(date_list[3]) + ':' + str(
date_list[4]) + ':' + str(date_list[5])
date_list = add_link_dictionary['last_try_date']
last_try_date = str(date_list[0]) + '/' + str(date_list[1]) + '/' + str(
date_list[2]) + ' , ' + str(date_list[3]) + ':' + str(
date_list[4]) + ':' + str(date_list[5])
download_info = [
file_name, status_str, size_str, downloaded_str, percent_str,
connections_str, download_speed_str, estimate_time_left_str, None,
add_link_dictionary, firs_try_date, last_try_date
]
for i in range(12):
if download_info[i] != None:
download_info_file_list[i] = download_info[i]
writeList(download_info_file, download_info_file_list)
return ['ready', download_info_file_list[1]]
def downloadAria(gid):
# add_link_dictionary is a dictionary that contains user download request
# information
download_info_file = os.path.join(download_info_folder, gid)
download_info_file_list = readList(download_info_file)
add_link_dictionary = download_info_file_list[9]
link = add_link_dictionary['link']
ip = add_link_dictionary['ip']
port = add_link_dictionary['port']
proxy_user = add_link_dictionary['proxy_user']
proxy_passwd = add_link_dictionary['proxy_passwd']
download_user = add_link_dictionary['download_user']
download_passwd = add_link_dictionary['download_passwd']
connections = add_link_dictionary['connections']
limit = str(add_link_dictionary['limit'])
start_hour = add_link_dictionary['start_hour']
start_minute = add_link_dictionary['start_minute']
end_hour = add_link_dictionary['end_hour']
end_minute = add_link_dictionary['end_minute']
header = add_link_dictionary['header']
out = add_link_dictionary['out']
user_agent = add_link_dictionary['user-agent']
cookies = add_link_dictionary['load-cookies']
referer = add_link_dictionary['referer']
# setting time and date for last_try_date
now_date_list = nowDate()
add_link_dictionary['last_try_date'] = now_date_list
# making header option
header_list = []
header_list.append("Cookie: " + str(cookies))
# converting Mega to Kilo, RPC does not Support floating point numbers.
if limit != '0':
limit_number = limit[:-1]
limit_number = float(limit_number)
limit_unit = limit[-1]
if limit_unit == 'K':
limit_number = round(limit_number)
else:
limit_number = round(1024 * limit_number)
limit_unit = 'K'
limit = str(limit_number) + limit_unit
if header != None:
semicolon_split_header = header.split('; ')
for i in semicolon_split_header:
equal_split_header = i.split('=', 1)
join_header = ':'.join(equal_split_header)
if i != '':
header_list.append(join_header)
if len(header_list) == 0:
header_list = None
if start_hour != None:
download_info_file_list[1] = "scheduled"
# writing new informations on download_info_file
download_info_file_list[9] = add_link_dictionary
writeList(download_info_file, download_info_file_list)
if ip:
ip_port = str(ip) + ":" + str(port)
else:
ip_port = ""
if start_hour != None:
start_time_status = startTime(start_hour, start_minute, gid)
else:
start_time_status = "downloading"
if start_time_status == "scheduled":
# reading new limit option before starting download! perhaps user
# changed this in progress bar window
download_info_file_list = readList(download_info_file)
add_link_dictionary = download_info_file_list[9]
limit = add_link_dictionary['limit']
# eliminating start_hour and start_minute!
add_link_dictionary['start_hour'] = None
add_link_dictionary['start_minute'] = None
download_info_file_list[9] = add_link_dictionary
writeList(download_info_file, download_info_file_list)
# finding download_path_temp from persepolis_setting
persepolis_setting.sync()
download_path_temp = persepolis_setting.value(
'settings/download_path_temp')
if start_time_status != 'stopped':
# sending download request to aria2
aria_dict = {
'gid': gid,
'max-tries': str(persepolis_setting.value('settings/max-tries')),
'retry-wait': int(persepolis_setting.value('settings/retry-wait')),
'timeout': int(persepolis_setting.value('settings/timeout')),
'header': header_list,
'out': out,
'user-agent': user_agent,
'referer': referer,
'all-proxy': ip_port,
'max-download-limit': limit,
'all-proxy-user': str(proxy_user),
'all-proxy-passwd': str(proxy_passwd),
'http-user': str(download_user),
'http-passwd': str(download_passwd),
'split': '16',
'max-connection-per-server': str(connections),
'min-split-size': '1M',
'continue': 'true',
'dir': str(download_path_temp)
}
if not link.startswith("https"):
aria_dict['http-user'] = str(download_user)
aria_dict['http-passwd'] = str(download_passwd)
try:
answer = server.aria2.addUri([link], aria_dict)
print(answer + " Starts")
logger.sendToLog(answer + " Starts", 'INFO')
if end_hour != None:
endTime(end_hour, end_minute, gid)
except:
print("Download did not start")
logger.sendToLog("Download did not start", "ERROR")
error_message = str(traceback.format_exc())
logger.sendToLog(error_message, "ERROR")
print(error_message)
# if request was unsuccessful return None!
return 'None'
else:
# if start_time_status is "stopped" it means download Canceled by user
print("Download Canceled")
logger.sendToLog("Download Canceled", "INFO")
def downloadAria(gid):
# add_link_dictionary is a dictionary that contains user download request
# information
download_info_file = os.path.join(download_info_folder, gid)
download_info_file_list = readList(download_info_file)
add_link_dictionary = download_info_file_list[9]
link = add_link_dictionary['link']
ip = add_link_dictionary['ip']
port = add_link_dictionary['port']
proxy_user = add_link_dictionary['proxy_user']
proxy_passwd = add_link_dictionary['proxy_passwd']
download_user = add_link_dictionary['download_user']
download_passwd = add_link_dictionary['download_passwd']
connections = add_link_dictionary['connections']
limit = add_link_dictionary['limit']
start_hour = add_link_dictionary['start_hour']
start_minute = add_link_dictionary['start_minute']
end_hour = add_link_dictionary['end_hour']
end_minute = add_link_dictionary['end_minute']
header = add_link_dictionary['header']
out = add_link_dictionary['out']
user_agent = add_link_dictionary['user-agent']
cookies = add_link_dictionary['load-cookies']
referer = add_link_dictionary['referer']
# setting time and date for last_try_date
now_date_list = nowDate()
add_link_dictionary['last_try_date'] = now_date_list
# making header option
header_list = []
if cookies != None:
semicolon_split_cookies = cookies.split('; ')
for i in semicolon_split_cookies:
equal_split_cookie = i.split('=')
join_cookie = ':'.join(equal_split_cookie)
if i != '':
header_list.append(join_cookie)
if header != None:
semicolon_split_header = header.split('; ')
for i in semicolon_split_header:
equal_split_header = i.split('=')
join_header = ':'.join(equal_split_header)
if i != '':
header_list.append(join_header)
if len(header_list) == 0:
header_list = None
if start_hour != None:
download_info_file_list[1] = "scheduled"
# writing new informations on download_info_file
download_info_file_list[9] = add_link_dictionary
writeList(download_info_file, download_info_file_list)
if ip:
ip_port = str(ip) + ":" + str(port)
else:
ip_port = ""
if start_hour != None:
start_time_status = startTime(start_hour, start_minute, gid)
else:
start_time_status = "downloading"
if start_time_status == "scheduled":
# reading new limit option before starting download! perhaps user
# changed this in progress bar window
download_info_file_list = readList(download_info_file)
add_link_dictionary = download_info_file_list[9]
limit = add_link_dictionary['limit']
# eliminating start_hour and start_minute!
add_link_dictionary['start_hour'] = None
add_link_dictionary['start_minute'] = None
download_info_file_list[9] = add_link_dictionary
writeList(download_info_file, download_info_file_list)
# finding download_path_temp from persepolis_setting
persepolis_setting.sync()
download_path_temp = persepolis_setting.value(
'settings/download_path_temp')
if start_time_status != 'stopped':
# sending download request to aria2
if link[0:5] != "https":
aria_dict = {'gid': gid, 'max-tries': str(persepolis_setting.value('settings/max-tries')), 'retry-wait': int(persepolis_setting.value('settings/retry-wait')), 'timeout': int(persepolis_setting.value('settings/timeout')), 'header': header_list, 'out': out, 'user-agent': user_agent, 'referer': referer, 'all-proxy': ip_port,
'max-download-limit': limit, 'all-proxy-user': str(proxy_user), 'all-proxy-passwd': str(proxy_passwd), 'http-user': str(download_user), 'http-passwd': str(download_passwd), 'split': '16', 'max-connection-per-server': str(connections), 'min-split-size': '1M', 'continue': 'true', 'dir': str(download_path_temp)}
else:
aria_dict = {'gid': gid, 'max-tries': str(persepolis_setting.value('settings/max-tries')), 'retry-wait': int(persepolis_setting.value('settings/retry-wait')), 'timeout': int(persepolis_setting.value('settings/timeout')), 'header': header_list, 'out': out, 'user-agent': user_agent,
'referer': referer, 'all-proxy': ip_port, 'max-download-limit': limit, 'all-proxy-user': str(proxy_user), 'all-proxy-passwd': str(proxy_passwd), 'split': '16', 'max-connection-per-server': str(connections), 'min-split-size': '1M', 'continue': 'true', 'dir': str(download_path_temp)}
try:
if ("http" in link[0:5]):
answer = server.aria2.addUri([link], aria_dict)
else:
answer = server.aria2.addUri([link], aria_dict)
print(answer + " Starts")
logger.sendToLog(answer + " Starts", 'INFO')
if end_hour != None:
endTime(end_hour, end_minute, gid)
except:
print("None Starts")
logger.sendToLog("None Starts", "INFO")
# if request was unsuccessful return None!
return 'None'
else:
# if start_time_status is "stopped" it means download Canceled by user
print("Download Canceled")
logger.sendToLog("Download Canceled", "INFO")
def spider(add_link_dictionary, gid):
# getting user's download request from add_link_dictionary
link = add_link_dictionary['link']
ip = add_link_dictionary['ip']
port = add_link_dictionary['port']
proxy_user = add_link_dictionary['proxy_user']
proxy_passwd = add_link_dictionary['proxy_passwd']
download_user = add_link_dictionary['download_user']
download_passwd = add_link_dictionary['download_passwd']
header = add_link_dictionary['header']
out = add_link_dictionary['out']
user_agent = add_link_dictionary['user-agent']
raw_cookies = add_link_dictionary['load-cookies']
referer = add_link_dictionary['referer']
if out == '***':
out = None
requests_session = requests.Session() # defining a requests Session
if ip:
ip_port = 'http://' + str(ip) + ":" + str(port)
if proxy_user:
ip_port = 'http://' + proxy_user + ':' + proxy_passwd + '@' + ip_port
# setting proxy to the session
requests_session.proxies = {'http': ip_port}
if download_user:
# setting download user pass to the session
requests_session.auth(download_user, download_passwd)
if raw_cookies != None: # setting cookies
cookie = SimpleCookie()
cookie.load(raw_cookies)
cookies = {key: morsel.value for key, morsel in cookie.items()}
requests_session.cookies = cookiejar_from_dict(cookies)
if referer != None:
requests_session.headers.update({'referer': referer
}) #setting referer to the session
if user_agent != None:
requests_session.headers.update({'user-agent': user_agent
}) #setting user_agent to the session
#finding headers
response = requests_session.head(link)
header = response.headers
filename = '***'
filesize = '***'
if 'Content-Disposition' in header.keys(
): # checking if filename is available
content_disposition = header['Content-Disposition']
if content_disposition.find('filename') != -1:
filename_splited = content_disposition.split('filename=')
filename_splited = filename_splited[-1]
# getting file name in desired format
filename = filename_splited[1:-1]
if filename == '***':
filename = link.split('/')[-1]
if out != None:
filename = out
if 'Content-Length' in header.keys(): # checking if file_size is available
file_size = int(header['Content-Length'])
if int(file_size /
1073741824) != 0: # converting file_size to KB or MB or GB
file_size = file_size / 1073741824
size_str = str(round(file_size, 2)) + " GB"
elif int(file_size / 1048576) != 0:
size_str = str(int(file_size / 1048576)) + " MB"
elif int(file_size / 1024) != 0:
size_str = str(int(file_size / 1024)) + " KB"
else:
size_str = str(file_size)
filesize = size_str
download_info_file = os.path.join(download_info_folder, gid)
download_info_file_list = readList(download_info_file)
download_info = [
filename, None, filesize, None, None, None, None, None, None, None,
None, None, None
]
for i in range(13):
if download_info[i] != None:
download_info_file_list[i] = download_info[i]
writeList(download_info_file, download_info_file_list)
def __init__(self, callback, gid, persepolis_setting):
super().__init__(persepolis_setting)
self.persepolis_setting = persepolis_setting
self.download_later_pushButton.hide(
) # hiding download_later_pushButton
self.change_name_checkBox.hide() # hiding change_name_checkBox
self.change_name_lineEdit.hide() # hiding change_name_lineEdit
self.callback = callback
self.gid = gid
global connections
connections = int(
self.persepolis_setting.value('settings/connections'))
# hiding options_pushButton
self.options_pushButton.hide()
# detect_proxy_pushButton
self.detect_proxy_pushButton.clicked.connect(self.detectProxy)
# connect folder_pushButton
self.folder_pushButton.clicked.connect(self.changeFolder)
self.download_folder_lineEdit.setEnabled(False)
self.ok_pushButton.setEnabled(False)
self.link_lineEdit.textChanged.connect(self.linkLineChanged)
# connect OK and canel button
self.cancel_pushButton.clicked.connect(self.close)
self.ok_pushButton.clicked.connect(self.okButtonPressed)
#frames and checkBoxes
self.proxy_frame.setEnabled(False)
self.proxy_checkBox.toggled.connect(self.proxyFrame)
self.download_frame.setEnabled(False)
self.download_checkBox.toggled.connect(self.downloadFrame)
self.limit_frame.setEnabled(False)
self.limit_checkBox.toggled.connect(self.limitFrame)
self.start_frame.setEnabled(False)
self.start_checkBox.toggled.connect(self.startFrame)
self.end_frame.setEnabled(False)
self.end_checkBox.toggled.connect(self.endFrame)
# initialization
self.connections_spinBox.setValue(connections)
download_info_file = download_info_folder + "/" + self.gid
download_info_file_list = readList(download_info_file)
self.add_link_dictionary = download_info_file_list[9]
# disable folder_frame when download is complete
status = download_info_file_list[1]
if status == 'complete':
self.folder_frame.setEnabled(False)
# link
self.link_lineEdit.setText(self.add_link_dictionary['link'])
# ip_lineEdit initialization
if self.add_link_dictionary['ip'] != None:
self.proxy_checkBox.setChecked(True)
self.ip_lineEdit.setText(self.add_link_dictionary['ip'])
# port_spinBox initialization
try:
self.port_spinBox.setValue(
int(self.add_link_dictionary['port']))
except:
pass
# proxy user lineEdit initialization
try:
self.proxy_user_lineEdit.setText(
self.add_link_dictionary['proxy_user'])
except:
pass
# proxy pass lineEdit initialization
try:
self.proxy_pass_lineEdit.setText(
self.add_link_dictionary['proxy_passwd'])
except:
pass
# download UserName initialization
if self.add_link_dictionary['download_user'] != None:
self.download_checkBox.setChecked(True)
self.download_user_lineEdit.setText(
self.add_link_dictionary['download_user'])
# download PassWord initialization
try:
self.download_pass_lineEdit.setText(
self.add_link_dictionary['download_passwd'])
except:
pass
# folder_path
try:
self.download_folder_lineEdit.setText(
self.add_link_dictionary['download_path'])
except:
pass
# connections
try:
self.connections_spinBox.setValue(
int(self.add_link_dictionary['connections']))
except:
pass
# finding categories name and adding them to add_queue_comboBox
self.add_queue_comboBox.addItem('Single Downloads')
f_queues_list = Open(queues_list_file)
queues_list_file_lines = f_queues_list.readlines()
f_queues_list.close()
for queue in queues_list_file_lines:
queue_strip = queue.strip()
self.add_queue_comboBox.addItem(str(queue_strip))
# finding current queue and setting it!
self.current_category = str(download_info_file_list[12])
current_category_index = self.add_queue_comboBox.findText(
self.current_category)
self.add_queue_comboBox.setCurrentIndex(current_category_index)
# add_queue_comboBox event
self.add_queue_comboBox.currentIndexChanged.connect(self.queueChanged)
# limit speed
limit = str(self.add_link_dictionary['limit'])
if limit != '0':
self.limit_checkBox.setChecked(True)
limit_number = limit[0:-1]
limit_unit = limit[-1]
self.limit_spinBox.setValue(float(limit_number))
if limit_unit == "K":
self.limit_comboBox.setCurrentIndex(0)
else:
self.limit_comboBox.setCurrentIndex(1)
# start_time
if self.add_link_dictionary['start_hour'] != None:
self.start_checkBox.setChecked(True)
self.start_hour_spinBox.setValue(
int(self.add_link_dictionary['start_hour']))
self.start_minute_spinBox.setValue(
int(self.add_link_dictionary['start_minute']))
# end_time
if self.add_link_dictionary['end_hour'] != None:
self.end_checkBox.setChecked(True)
self.end_hour_spinBox.setValue(
int(self.add_link_dictionary['end_hour']))
self.end_minute_spinBox.setValue(
int(self.add_link_dictionary['end_minute']))
# setting window size and position
size = self.persepolis_setting.value('PropertiesWindow/size',
QSize(700, 500))
position = self.persepolis_setting.value('PropertiesWindow/position',
QPoint(300, 300))
self.resize(size)
self.move(position)
