'.png32', '.tiff', '.tif', '.ptif', '.tiff64', '.psd', '.xcf', '.ico', '.icon', '.svg', '.svgz', '.msvgz', '.eps',

'.eps2', '.eps3', '.epsf', '.ai', '.nef', '.cr2', '.crw', '.dcr', '.kdc', '.k25', '.x3f', '.arw', '.sr2', '.srf',

'.mrw', '.erf', '.raf', '.pct', '.pict', '.dds', '.dng', '.pex', '.3fr', '.ppm', '.orf', '.pef', '.aai', '.exr',

'.hdr', '.dcm', '.dicom', '.psb', '.pbm', '.jpf', '.iff', '.sct', '.tga', '.fit', '.fits', '.fts', '.mng', '.pgm',

exts_types = []

exts_types.append(IMAGE_EXTS)

exts_types.append(CODE_EXTS)

exts_types.append(DOCUMENT_EXTS)

exts_types.append(EBOOKS_EXTS)

exts_types.append(VIDEO_EXTS)

exts_types.append(AUDIO_EXTS)

exts_types.append(PRESENTATION_EXTS)

exts_types.append(SYSTEM_EXTS)

exts_types.append(COMPRESSED_EXTS)

exts_types.append(EXECUTABLE_EXTS)

exts_types.append(DISK_IMAGE_EXTS)

exts_types.append(SPREADSHEETS_EXTS)

exts_types.append(FONT_EXTS)

exts_types.append(DATABASE_EXTS)

exts_types.append(SETTINGS_EXTS)

exts_types.append(BACKUP_EXTS)

exts_types.append(CAD_EXTS)

exts_types.append(PLUGIN_EXTS)

exts_types.append(PARTIALLY_DOWNLOADED_EXTS)

exts_types.append(CALENDAR_EXTS)

exts_types.append(INSTALLER_EXTS)

exts_types.append(TORRENT_EXTS)

ext_to_filetype = {}

for exts_type in exts_types:

ftype = exts_type.pop(0)

for ext in exts_type:

ext_to_filetype[ext] = ftype

ext = os.path.splitext(filepath)[1].lower()

if ext in ext_to_filetype:

return ext_to_filetype[ext]

if ext != '':

unknown_exts.add(ext)

basename = os.path.basename(filepath).lower()

filename = basename

if not basename in filenames_storage:

filenames_storage[basename] = 0

else:

filenames_storage[basename] += 1

filename, ext = os.path.splitext(basename)

filename += '(' + str(filenames_storage[basename]) + ')' + ext

fulldest = os.path.join(not_fulldest, filename)

global progress

new_progress = int('{:.0f}'.format(processed_files_size / float(cleandir_size) * 100))

if progress != new_progress or forced_update:

progress = new_progress

cutted_basename = cutstr(os.path.basename(filepath))

sysprint('{:d}% complete (copying \'{}\')\r'.format(progress, cutted_basename))

elif forced_update:

progress = new_progress

cutted_basename = cutstr(os.path.basename(filepath))

log(msg='{:d}% complete (copying \'{}\')'.format(progress, cutted_basename))

global processed_files_size

copyfrom_size = os.path.getsize(copyfrom)

try:

with open(copyfrom, 'rb') as src:

with open(copyto, 'wb') as dst:

datablock = src.read(copybytes_buffer_size)

while datablock:

dst.write(datablock)

if copyfrom_size > copybytes_buffer_size:

processed_files_size += copybytes_buffer_size

copyfrom_size -= copybytes_buffer_size

else:

processed_files_size += copyfrom_size

copyfrom_size = 0

update_progress(cleandir_size, copyfrom, processed_files_size)

datablock = src.read(copybytes_buffer_size)

shutil.copystat(copyfrom, copyto)

except IOError:

inform('Error when copying file: \'' + copyfrom + '\'.')

log(msg=traceback.format_exc())

if system_name() == 'Windows':

from ctypes.wintypes import MAX_PATH

return MAX_PATH

elif system_name() == 'Linux':

return int(subprocess.check_output(['getconf', 'PATH_MAX', '/']))

global processed_files_size

#TEST info

log(msg='Cleaning file: \'' + filepath + '\'.')

destination = os.path.join(todir, ftype)

ext = os.path.splitext(filepath)[1].lower()

ext = ext.strip('.')

if ext == '':

ext = '[no_extension]'

destination = os.path.join(destination, ext)

try:

if not os.path.exists(destination):

os.makedirs(destination)

except OSError:

inform('Error when creating destination path to file: \'' + filepath + '\'.')

log(msg='The file path before cleaning: \'' + filepath + '\'.')

log(msg='The expected file path after cleaning: \'' + destination + '\'.')

log(msg=traceback.format_exc())

sys_exit(1, error='OSError', send_log=True)

fulldest = full_destination(destination, filepath, filenames_storage)

log(msg='Destination: \'' + fulldest + '\'.')

if os.path.getsize(filepath) >= get_copybytes_min_file_size():

#Under test

log(msg='copybytes function choosed.\n')

copybytes(filepath, fulldest, cleandir_size, copybytes_buffer_size)

else:

#Under test

log(msg='shutil.copy2 function choosed.\n')

shutil.copy2(filepath, fulldest)

processed_files_size += os.path.getsize(filepath)

copybytes_buffer_size):

global processed_files_number

global unknown_files_number

for subpath in os.listdir(path):

fullpath = os.path.join(path, subpath)

if os.path.isdir(fullpath):

plungedir(fullpath, todir, cleandir_files_number, cleandir_size, ext_to_filetype, filenames_storage, unknown_exts,

copybytes_buffer_size)

else:

ftype = filetype(fullpath, ext_to_filetype, unknown_exts)

cleanfile(fullpath, todir, ftype, filenames_storage, cleandir_size, copybytes_buffer_size)

processed_files_number += 1

if ftype == 'unknown':

appname = 'ffcleaner'

appauthor = 'hrrmsn'

logpath = appdirs.user_log_dir(appname, appauthor)

try:

if not os.path.exists(logpath):

os.makedirs(logpath)

except OSError:

inform('Error when creating path to log file: \'' + logpath + '\'.')

log(msg=traceback.format_exc())

sys_exit(1, error='OSError', send_log=True)

timestamp = '[' + datetime.now().strftime('%Y-%d-%m %H:%M:%S') + ']'

if act == 'start':

msg = timestamp + ' Start logging.'

elif act == 'log':

msg = timestamp + ' ' + msg

elif act == 'end':

msg = timestamp + ' End logging.\n'

try:

with open(LOGFILE, 'a') as fopen:

fopen.write(msg + '\n')

except IOError:

print 'Error when writing to log file. \nSending email with error...'

errmsg = 'Error when writing to log file. Full stack trace is below. \n' + traceback.format_exc()

sendmail(DECODED_SENDER_EMAIL, DECODED_SUPPORT_EMAIL, 'IOError (writing to log)', errmsg, [])

try:

print 'Removing ' + file_title + '...'

os.remove(filepath)

except OSError:

print 'Error when removing ' + file_title + '. \nSending email with error...'

errmsg = 'Error when removing' + file_title + '. Full stack trace is below. \n' + traceback.format_exc()

sendmail(DECODED_SENDER_EMAIL, DECODED_SUPPORT_EMAIL, 'OSError (removing file)', errmsg, [])

else:

basename = os.path.basename(filepath)

basename_ext_cutted = os.path.splitext(basename)[0]

archive_name = 'zipped_' + basename_ext_cutted + '.zip'

basedir = os.path.dirname(filepath)

archive_fullname = os.path.join(basedir, archive_name)

try:

with zipfile.ZipFile(archive_fullname, mode='w') as zfile:

zfile.write(filepath, compress_type=zipfile.ZIP_DEFLATED)

except (RuntimeError, IOError) as exception:

print 'Error when processing zip file. \nSending email without attachments...'

errmsg = 'Error when processing zip file. Full stack trace is below. \n' + traceback.format_exc()

sendmail(DECODED_SENDER_EMAIL, DECODED_SUPPORT_EMAIL, type(exception).__name__ + ' (processing zip archive)',

errmsg, [])

sys.exit(1)

if send_log:

inform('Creating archive with the log file...')

log(act='end')

archive_path = archive_file(LOGFILE)

#print 'Ok. \nSending archive via email...'

errmsg = 'Details are inside the log file.'

#if sendmail(DECODED_SENDER_EMAIL, DECODED_SUPPORT_EMAIL, error, errmsg, [archive_path]):

#remove_file(LOGFILE, 'log file')

# remove_file(archive_path, 'archive with log')

else:

log(act='end')

try:

response = requests.post(

ENCODED_API_BASE_URL.decode(ENCODING_SCHEME),

auth=('api', ENCODED_API_KEY.decode(ENCODING_SCHEME)),

files=attachments,

data={'from': mailfrom, 'to': [mailto], 'subject': subject, 'text': message})

if response.status_code != requests.codes.ok:

response.raise_for_status()

except requests.ConnectionError:

print 'Warning: some problems with internet connection. Email wasn\'t sent.'

return False

except requests.code.HTTPError:

print 'Failed to send email. (Status: ' + str(response.status_code) + ' ' + response.reason + '.)'

return False

else:

print 'Ok.'

return True

finally:

for attachment in attachments:

attached_file = attachment[1]

attachments = []

for filepath in attached_files:

try:

fopen = open(filepath, 'rb')

attachments.append(('attachment', fopen))

except IOError:

print 'Error when preparing attachments for sending via email. \nSending email without attachments...'

errmsg = 'Couldn\'t prepare attachments for sending via email. Full stack trace is below. \n'

errmsg += traceback.format_exc()

sendpost(mailfrom, mailto, 'IOError (problems with attachments)', errmsg, [])

sys.exit(1)

if not args:

inform('Usage: [--todir dir] dir.')

inform('Usage: --logpath.')

sys_exit(0)

if len(args) == 1 and args[0].lower() == '--logpath':

inform(LOGFILE)

sys_exit(0)

todir = ''

if args[0].startswith('--'):

if args[0].lower() != '--todir':

inform('Error: unsupported option.')

sys_exit(1)

if len(args) == 1:

inform('Error: must specify target dir.')

sys_exit(1)

todir = args[1]

del args[:2]

if not args:

inform('Error: must specify dir to clean.')

sys_exit(1)

elif len(args) > 1:

if '--todir' in ''.join(args):

inform('Error: todir option must be the first.')

sys_exit(1)

inform('Error: must specify only one dir to clean.')

sys_exit(1)

cleandir = args[0]

answer = raw_input('Dir to output already exists. Do you want to overwrite it? (y/n) ')

answer = answer.lower()

log(msg='Dir to output already exists. Do you want to overwrite it? (y/n) ' + answer)

if answer in ['y', 'yes']:

inform('Removing \'' + path + '\'...')

try:

shutil.rmtree(path, onerror=remove_readonly)

except OSError:

inform('Error when removing directory: \'' + path + '\'.')

log(msg=traceback.format_exc())

sys_exit(1, error='OSError', send_log=True)

else:

inform('Ok.')

elif answer in ['n', 'no']:

path = raw_input('Enter new dir to output: ')

log(msg='Enter new dir to output: \'' + path + '\'.')

else:

inform('Error: incorrect answer was typed.')

sys_exit(1)

platform_order = PLATFORM_DATA_ORDER[system_name()]

for unit_and_symbol in BYTE_UNITS:

unit_symbol = unit_and_symbol[1]

units_by_order = unit_and_symbol[0]

bytes_in_unit = units_by_order[platform_order]

if bytes >= bytes_in_unit:

return '{:.1f}'.format(bytes / float(bytes_in_unit)) + ' ' + unit_symbol

total_size = 0

for root, dirs, filenames in os.walk(dirpath):

for filename in filenames:

total_size += os.path.getsize(os.path.join(root, filename))

if todir == cleandir:

inform('Error: dir to clean and dir to output should be different.')

sys_exit(1)

if not os.path.exists(cleandir):

inform('Error: dir to clean doesn\'t exist.')

sys_exit(1)

inform('Counting files to clean...')

files_numbers_in_subfolders = [len(filenames) for dirpath, dirnames, filenames in os.walk(cleandir)]

cleandir_files_number = sum(files_numbers_in_subfolders)

if cleandir_files_number == 0:

inform('Error: dir to clean is empty or doesn\'t contain any files.')

sys_exit(1)

cleandir_size = dirsize(cleandir)

inform(str(cleandir_files_number) + ' files found. (' + print_bytes(cleandir_size) + ')')

while os.path.exists(todir) and os.listdir(todir) != []:

todir = overwrite(todir)

if os.path.exists(todir) == False:

os.makedirs(todir)

if sys.platform.startswith('linux'):

return 'Linux'

elif sys.platform.startswith('win'):

return 'Windows'

elif sys.platform.startswith('darwin'):

return 'Mac OS'

if unknown_files_number == 0:

inform('Unknown files are not found.')

else:

inform('Unknown files: ' + '{:.2f}%'.format(unknown_files_number / float(processed_files_number) * 100) + '.')

if unknown_exts:

log(msg='List of unknown extensions: [\'' + '\', \''.join(unknown_exts) + '\'].')

else:

if seconds == 0:

return '0 sec'

splitted_seconds = []

for time_unit in TIME_UNITS:

if seconds >= time_unit[1]:

unit_value = seconds / time_unit[1]

seconds %= time_unit[1]

splitted_seconds.append(str(unit_value) + ' ' + time_unit[0])

if system_name() == 'Windows':

free_bytes = ctypes.c_ulonglong(0)

ctypes.windll.kernel32.GetDiskFreeSpaceExW(ctypes.c_wchar_p(path), None, None, ctypes.pointer(free_bytes))

return free_bytes.value

st = os.statvfs(path)

if system_name() == 'Windows':

absolute_path = os.path.abspath(path)

path = os.path.splitdrive(absolute_path)[0]

free_bytes = get_free_space(path)

if get_free_space(path) < required_bytes:

inform('Error: not enough free disk space.')

inform(print_bytes(free_bytes) + ' available, ' + print_bytes(required_bytes) + ' required.')

log(act='start')

log(msg='OS is ' + system_name() + '.')

log(msg='Platform info: ' + platform.platform() + '.')

log(msg='Launch command: ' + ' '.join(sys.argv) + '.')

copybytes_buffer_size = get_copybytes_default_buffer_size()

if len(sys.argv) > 4:

copybytes_buffer_size = int(sys.argv[4])

del sys.argv[4]

todir, cleandir = check_arguments(sys.argv[1:])

inform('Dir to output: \'' + todir + '\'.')

inform('Dir to clean: \'' + cleandir + '\'.')

todir, cleandir_files_number, cleandir_size = check_input(todir, cleandir)

check_free_drive_space(cleandir, cleandir_size)

exts_types = extensions_types()

ext_to_filetype = extension_to_filetype(exts_types)

inform('Started cleaning. (b_size is ' + print_bytes(copybytes_buffer_size) + ')')

unknown_exts = set()

timestart = time.time()

try:

plungedir(cleandir, todir, cleandir_files_number, cleandir_size, ext_to_filetype, {}, unknown_exts,

copybytes_buffer_size)

sysprint()

except (OSError, IOError) as exception:

inform('Error when cleaning directory: \'' + cleandir + '\'.')

log(msg=traceback.format_exc())

sys_exit(1, error=type(exception).__name__, send_log=True)

inform('Cleaning was done successfully.')

inform('Processed files: ' + str(processed_files_number) + '. (' + print_bytes(processed_files_size) + ')')

check_unknown_files(unknown_files_number, processed_files_number, unknown_exts)

timedelta = int('{:.0f}'.format(time.time() - timestart))

inform('Cleaned in ' + print_seconds(timedelta) + '.')