def predict(request):
# Init of the view predict
try:
# Pool call
response, repool = sendPool(request, 'predict')
if response or repool:
if repool:
return HttpResponse(response)
return renderMainPanel(request=request, popup_text=response.text)
else:
try:
# Save file X_img_path
filename_X_img_path, location_X_img_path, X_img_path = saveFileOutput(
request.FILES['X_img_path'], 'objectdetection', 'ai')
except Exception as e:
# If not param X_img_path
if request.POST.get('is_async_predict', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter knn_clf (Optional - Default None)
knn_clf = request.POST.get('knn_clf', None)
if not knn_clf:
knn_clf = None
try:
# Save file model_path (Optional)
filename_model_path, location_model_path, model_path = saveFileOutput(
request.FILES['model_path'], 'objectdetection', 'ai')
except Exception as e:
# If not param model_path
if request.POST.get('is_async_predict', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter distance_threshold (Optional - Default 0.6)
distance_threshold = request.POST.get('distance_threshold', 0.6)
# Execute, get result and show it
result = ht.getModule('ht_objectdetection').predict(
X_img_path=X_img_path,
knn_clf=knn_clf,
model_path=model_path,
distance_threshold=distance_threshold)
if request.POST.get('is_async_predict', False):
return JsonResponse({"data": result})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_predict', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def saveCroppedImage(request):
# Init of the view saveCroppedImage
try:
# Pool call
response, repool = sendPool(request, 'saveCroppedImage')
if response or repool:
if repool:
return HttpResponse(response)
return renderMainPanel(request=request, popup_text=response.text)
else:
try:
# Save file img_path
filename_img_path, location_img_path, img_path = saveFileOutput(
request.FILES['img_path'], 'objectdetection', 'ai')
except Exception as e:
# If not param img_path
if request.POST.get('is_async_saveCroppedImage', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter coords
coords = request.POST.get('coords')
try:
# Save file model_path
filename_model_path, location_model_path, model_path = saveFileOutput(
request.FILES['model_path'], 'objectdetection', 'ai')
except Exception as e:
# If not param model_path
if request.POST.get('is_async_saveCroppedImage', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter name
name = request.POST.get('name')
# Parameter counter (Optional - Default 1)
counter = request.POST.get('counter', 1)
# Execute the function
ht.getModule('ht_objectdetection').saveCroppedImage(
img_path=img_path,
coords=coords,
model_path=model_path,
name=name,
counter=counter)
except Exception as e:
if request.POST.get('is_async_saveCroppedImage', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def show_prediction_labels_on_image(request):
# Init of the view show_prediction_labels_on_image
try:
# Pool call
response, repool = sendPool(request, 'show_prediction_labels_on_image')
if response or repool:
if repool:
return HttpResponse(response)
return renderMainPanel(request=request, popup_text=response.text)
else:
try:
# Save file img_path
filename_img_path, location_img_path, img_path = saveFileOutput(
request.FILES['img_path'], 'objectdetection', 'ai')
except Exception as e:
# If not param img_path
if request.POST.get('is_async_show_prediction_labels_on_image',
False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter predictions
predictions = request.POST.get('predictions')
try:
# Save file model_path
filename_model_path, location_model_path, model_path = saveFileOutput(
request.FILES['model_path'], 'objectdetection', 'ai')
except Exception as e:
# If not param model_path
if request.POST.get('is_async_show_prediction_labels_on_image',
False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Execute, get result and show it
result = ht.getModule(
'ht_objectdetection').show_prediction_labels_on_image(
img_path=img_path,
predictions=predictions,
model_path=model_path)
if request.POST.get('is_async_show_prediction_labels_on_image',
False):
return JsonResponse({"data": result})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_show_prediction_labels_on_image', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def set_pdf_field_value(request):
# Init of the view set_pdf_field_value
try:
# Pool call
response, repool = sendPool(request, 'set_pdf_field_value')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
try:
# Save file pdf_file
filename_pdf_file, location_pdf_file, pdf_file = saveFileOutput(
request.FILES['pdf_file'], 'metadata', 'forensic')
except Exception as e:
# If not param pdf_file
if request.POST.get('is_async_set_pdf_field_value', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter field
field = request.POST.get('field')
# Parameter fieldValue
fieldValue = request.POST.get('fieldValue')
# Execute, get result and show it
result = ht.getModule('ht_metadata').set_pdf_field_value(
pdf_file=pdf_file, field=field, fieldValue=fieldValue)
if request.POST.get('is_async_set_pdf_field_value', False):
return JsonResponse({"data": returnAsModal(result)})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_set_pdf_field_value', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def get_mp3_exif(request):
# Init of the view get_mp3_exif
try:
# Pool call
response, repool = sendPool(request, 'get_mp3_exif')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
try:
# Save file mp3_file
filename_mp3_file, location_mp3_file, mp3_file = saveFileOutput(
request.FILES['mp3_file'], 'metadata', 'forensic')
except Exception as e:
# If not param mp3_file
if request.POST.get('is_async_get_mp3_exif', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Execute, get result and show it
result = ht.getModule('ht_metadata').get_mp3_exif(
mp3_file=mp3_file)
if request.POST.get('is_async_get_mp3_exif', False):
return JsonResponse({"data": returnAsModal(result)})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_get_mp3_exif', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def isBadFileHash(request):
# Init of the view isBadFileHash
try:
# Pool call
response, repool = sendPool(request, 'isBadFileHash')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
try:
# Save file fileHash
filename_fileHash, location_fileHash, fileHash = saveFileOutput(
request.FILES['fileHash'], 'virustotal', 'forensic')
except Exception as e:
# If not param fileHash
if request.POST.get('is_async_isBadFileHash', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Execute, get result and show it
result = ht.getModule('ht_virustotal').isBadFileHash(
fileHash=fileHash)
if request.POST.get('is_async_isBadFileHash', False):
return JsonResponse({"data": returnAsModal(result)})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_isBadFileHash', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def extractFile(request):
# Init of the view extractFile
try:
# Pool call
response, repool = sendPool(request, 'extractFile')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
try:
# Save file zipPathName
filename_zipPathName, location_zipPathName, zipPathName = saveFileOutput(
request.FILES['zipPathName'], 'unzip', 'crackers')
except Exception as e:
# If not param zipPathName
if request.POST.get('is_async_extractFile', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter password (Optional - Default None)
password = request.POST.get('password', None)
if not password:
password = None
# Execute, get result and show it
result = ht.getModule('ht_unzip').extractFile(
zipPathName=zipPathName, password=password)
if request.POST.get('is_async_extractFile', False):
return JsonResponse({"data": returnAsModal(result)})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_extractFile', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def upload_files(request):
# Init of the view upload_files
try:
# Pool call
response, repool = sendPool(request, 'upload_files')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
try:
# Save file files
filename_files, location_files, files = saveFileOutput(
request.FILES['files'], 'ssh', 'connector')
except Exception as e:
# If not param files
if request.POST.get('is_async_upload_files', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Execute the function
ht.getModule('ht_ssh').upload_files(files=files)
except Exception as e:
if request.POST.get('is_async_upload_files', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def getImports(request):
# Init of the view getImports
try:
# Pool call
response, repool = sendPool(request, 'getImports')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
try:
# Save file filemon
filename_filemon, location_filemon, filemon = saveFileOutput(
request.FILES['filemon'], 'radare2', 'reversing')
except Exception as e:
# If not param filemon
if request.POST.get('is_async_getImports', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Execute, get result and show it
result = ht.getModule('ht_radare2').getImports(filemon=filemon)
if request.POST.get('is_async_getImports', False):
return JsonResponse({"data": returnAsModal(result)})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_getImports', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def set_mp3_metadata(request):
# Init of the view set_mp3_metadata
try:
# Pool call
response, repool = sendPool(request, 'set_mp3_metadata')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
try:
# Save file mp3_file
filename_mp3_file, location_mp3_file, mp3_file = saveFileOutput(
request.FILES['mp3_file'], 'metadata', 'forensic')
except Exception as e:
# If not param mp3_file
if request.POST.get('is_async_set_mp3_metadata', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter title (Optional - Default None)
title = request.POST.get('title', None)
if not title:
title = None
# Parameter artist (Optional - Default None)
artist = request.POST.get('artist', None)
if not artist:
artist = None
# Parameter album (Optional - Default None)
album = request.POST.get('album', None)
if not album:
album = None
# Parameter album_artist (Optional - Default None)
album_artist = request.POST.get('album_artist', None)
if not album_artist:
album_artist = None
# Parameter track_num (Optional - Default None)
track_num = request.POST.get('track_num', None)
if not track_num:
track_num = None
# Execute, get result and show it
result = ht.getModule('ht_metadata').set_mp3_metadata(
mp3_file=mp3_file,
title=title,
artist=artist,
album=album,
album_artist=album_artist,
track_num=track_num)
if request.POST.get('is_async_set_mp3_metadata', False):
return JsonResponse({"data": returnAsModal(result)})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_set_mp3_metadata', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def createStub(request):
# Init of the view createStub
try:
# Pool call
response, repool = sendPool(request, 'createStub')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
# Parameter crypto_data_hex
crypto_data_hex = request.POST.get('crypto_data_hex')
# Parameter public_key
public_key = request.POST.get('public_key')
try:
# Save file drop_file_name
filename_drop_file_name, location_drop_file_name, drop_file_name = saveFileOutput(
request.FILES['drop_file_name'], 'crypter', 'av_evasion')
except Exception as e:
# If not param drop_file_name
if request.POST.get('is_async_createStub', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter save_name
save_name = request.POST.get('save_name')
# Parameter is_iterating (Optional - Default False)
is_iterating = request.POST.get('is_iterating', False)
if not is_iterating:
is_iterating = None
# Parameter is_last (Optional - Default False)
is_last = request.POST.get('is_last', False)
if not is_last:
is_last = None
# Parameter convert (Optional - Default False)
convert = request.POST.get('convert', False)
if not convert:
convert = None
# Execute, get result and show it
result = ht.getModule('ht_crypter').createStub(
crypto_data_hex=crypto_data_hex,
public_key=public_key,
drop_file_name=drop_file_name,
save_name=save_name,
is_iterating=is_iterating,
is_last=is_last,
convert=convert)
if request.POST.get('is_async_createStub', False):
return JsonResponse({"data": result})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_createStub', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def crackZip(request):
# Init of the view crackZip
try:
# Pool call
response, repool = sendPool(request, 'crackZip')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
try:
# Save file zipPathName
filename_zipPathName, location_zipPathName, zipPathName = saveFileOutput(
request.FILES['zipPathName'], 'bruteforce', 'crackers')
except Exception as e:
# If not param zipPathName
if request.POST.get('is_async_crackZip', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter unzipper (Optional - Default None)
unzipper = request.POST.get('unzipper', None)
if not unzipper:
unzipper = None
# Parameter alphabet (Optional - Default lalpha)
alphabet = request.POST.get('alphabet', 'lalpha')
# Parameter password_length (Optional - Default 4)
password_length = request.POST.get('password_length', 4)
# Parameter password_pattern (Optional - Default None)
password_pattern = request.POST.get('password_pattern', None)
if not password_pattern:
password_pattern = None
# Parameter log (Optional - Default False)
log = request.POST.get('log', False)
if not log:
log = None
# Execute, get result and show it
result = ht.getModule('ht_bruteforce').crackZip(
zipPathName=zipPathName,
unzipper=unzipper,
alphabet=alphabet,
password_length=password_length,
password_pattern=password_pattern,
log=log)
if request.POST.get('is_async_crackZip', False):
return JsonResponse({"data": result})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_crackZip', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def set_pdf_metadata_to_another(request):
# Init of the view set_pdf_metadata_to_another
try:
# Pool call
response, repool = sendPool(request, 'set_pdf_metadata_to_another')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
try:
# Save file pdf_file_original
filename_pdf_file_original, location_pdf_file_original, pdf_file_original = saveFileOutput(
request.FILES['pdf_file_original'], 'metadata', 'forensic')
except Exception as e:
# If not param pdf_file_original
if request.POST.get('is_async_set_pdf_metadata_to_another',
False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
try:
# Save file pdf_file_fake
filename_pdf_file_fake, location_pdf_file_fake, pdf_file_fake = saveFileOutput(
request.FILES['pdf_file_fake'], 'metadata', 'forensic')
except Exception as e:
# If not param pdf_file_fake
if request.POST.get('is_async_set_pdf_metadata_to_another',
False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Execute, get result and show it
result = ht.getModule('ht_metadata').set_pdf_metadata_to_another(
pdf_file_original=pdf_file_original,
pdf_file_fake=pdf_file_fake)
if result:
if os.path.isfile(result):
with open(result, 'rb') as fh:
response = HttpResponse(
fh.read(),
content_type="application/{type}".format(
type=os.path.split(result)[1].split('.')[1]))
response[
'Content-Disposition'] = 'inline; filename=' + os.path.basename(
result)
return response
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_set_pdf_metadata_to_another', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def readFileToType(request):
# Init of the view readFileToType
try:
# Pool call
response, repool = sendPool(request, 'readFileToType')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
try:
# Save file filename
filename_filename, location_filename, filename = saveFileOutput(
request.FILES['filename'], 'parser', 'files')
except Exception as e:
# If not param filename
if request.POST.get('is_async_readFileToType', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter typeToExport
typeToExport = request.POST.get('typeToExport')
# Parameter typeOf (Optional - Default None)
typeOf = request.POST.get('typeOf', None)
if not typeOf:
typeOf = None
# Parameter csv_headers (Optional - Default False)
csv_headers = request.POST.get('csv_headers', False)
# Execute, get result and show it
result = ht.getModule('ht_parser').readFileToType(
filename=filename,
typeToExport=typeToExport,
typeOf=typeOf,
csv_headers=csv_headers)
if request.POST.get('is_async_readFileToType', False):
return JsonResponse({"data": returnAsModal(result)})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_readFileToType', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def injectPayloadToWindowsTerminalProfile(request):
# Init of the view injectPayloadToWindowsTerminalProfile
try:
# Pool call
response, repool = sendPool(request,
'injectPayloadToWindowsTerminalProfile')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
# Parameter payload
payload = request.POST.get('payload')
try:
# Save file filename
filename_filename, location_filename, filename = saveFileOutput(
request.FILES['filename'], 'infector', 'malware')
except Exception as e:
# If not param filename
if request.POST.get(
'is_async_injectPayloadToWindowsTerminalProfile',
False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter update (Optional - Default False)
update = request.POST.get('update', False)
if not update:
update = None
# Execute, get result and show it
result = ht.getModule(
'ht_infector').injectPayloadToWindowsTerminalProfile(
payload=payload, filename=filename, update=update)
if request.POST.get(
'is_async_injectPayloadToWindowsTerminalProfile', False):
return JsonResponse({"data": result})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_injectPayloadToWindowsTerminalProfile',
False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def trainFromZip(request):
try:
if len(request.FILES) != 0:
objectdetection = ht.getModule('ht_objectdetection')
first_folder_name = None
filenameZip = None
uploaded_file_urlZip = 'trained.clf'
if 'image_models_zip' in request.FILES:
zip_to_train = request.FILES['image_models_zip']
first_folder_name = request.POST.get('first_folder_name', None)
if not first_folder_name:
first_folder_name = zip_to_train.name.split('.')[0]
filenameZip, location, uploaded_file_urlZip = saveFileOutput(
zip_to_train, "objectdetection", "ai")
n_neighbors = int(request.POST.get('neighbors', 1))
if filenameZip:
image_final = objectdetection.trainFromZip(
uploaded_file_urlZip,
model_path='{f}.clf'.format(f=filenameZip.split('.')[0]),
trainZipFile=uploaded_file_urlZip,
first_folder_name=first_folder_name,
n_neighbors=n_neighbors)
if request.POST.get('is_async_trainFromZip', False):
data = {'data': image_final}
return JsonResponse(data)
return renderMainPanel(request=request, popup_text=image_final)
return renderMainPanel(request=request)
except Exception as e:
Logger.printMessage(message='trainFromZip',
description=str(e),
is_error=True)
return renderMainPanel(request=request, popup_text=str(e))
def crypt_file(request):
this_conf = config['ht_crypter_crypt_file']
if len(request.FILES) != 0:
if request.FILES['filename']:
# Get file
myfile = request.FILES['filename']
# Get Crypter Module
crypter = ht.getModule('ht_crypter')
# Save the file
filename, location, uploaded_file_url = saveFileOutput(
myfile, "crypter", "av_evasion")
# Compile Exe
compile_exe = False
if request.POST.get('compile_exe', '') == 'on':
compile_exe = True
tmp_new_file_name = filename.split('.')[0]
if not '.' in tmp_new_file_name:
tmp_new_file_name = '{name}.py'.format(name=tmp_new_file_name)
new_file_name = os.path.join(location, tmp_new_file_name)
drop_file_name = filename
if not '.' in drop_file_name:
drop_file_name = '{name}.{ext}'.format(
name=drop_file_name, ext=filename.split('.')[1])
iterate_count = 1
if request.POST.get('iteratecount'):
try:
iterate_count = int(request.POST.get('iteratecount'))
if iterate_count < 1:
iterate_count = 1
except:
pass
prime_length = 2
if request.POST.get('prime_length'):
try:
prime_length = int(request.POST.get('prime_length'))
if prime_length < 1:
prime_length = 2
except:
pass
is_last = False
if iterate_count == 1:
is_last = True
crypted_file = crypter.crypt_file(filename=uploaded_file_url,
new_file_name=new_file_name,
drop_file_name=drop_file_name,
prime_length=prime_length,
iterate_count=iterate_count,
is_last=is_last,
compile_exe=compile_exe)
if crypted_file:
if os.path.isfile(crypted_file):
with open(crypted_file, 'rb') as fh:
if compile_exe:
new_file_name = '{name}.exe'.format(
name=new_file_name.split('.')[0])
response = HttpResponse(
fh.read(),
content_type="application/{type}".format(
type=new_file_name.split('.')[1]))
response[
'Content-Disposition'] = 'inline; filename=' + os.path.basename(
crypted_file)
return response
os.remove(uploaded_file_url)
os.remove(crypted_file)
else:
Logger.printMessage(message='crypt_file',
description=this_conf['bad_saved'],
is_error=True)
return renderMainPanel(request=request)
return renderMainPanel(request=request)
def connect(request):
# Init of the view connect
try:
# Pool call
response, repool = sendPool(request, 'connect')
if response or repool:
if repool:
return HttpResponse(response)
return JsonResponse({"data": str(response)})
else:
# Parameter host
host = request.POST.get('host')
# Parameter user
user = request.POST.get('user')
try:
# Save file ssh_key_filepath
filename_ssh_key_filepath, location_ssh_key_filepath, ssh_key_filepath = saveFileOutput(
request.FILES['ssh_key_filepath'], 'ssh', 'connector')
except Exception as e:
# If not param ssh_key_filepath
if request.POST.get('is_async_connect', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter remote_upload_dir
remote_upload_dir = request.POST.get('remote_upload_dir')
# Execute the function
ht.getModule('ht_ssh').connect(host=host,
user=user,
ssh_key_filepath=ssh_key_filepath,
remote_upload_dir=remote_upload_dir)
except Exception as e:
if request.POST.get('is_async_connect', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
def predictFromZip(request):
this_conf = config['ht_objectdetection_predictFromZip']
try:
if len(request.FILES) != 0:
if 'image_file_test_zip' in request.FILES:
objectdetection = ht.getModule('ht_objectdetection')
image_to_test_zip = request.FILES['image_file_test_zip']
first_folder_name = request.POST.get('first_folder_name', None)
filename, location, uploaded_file_url = saveFileOutput(
image_to_test_zip, "objectdetection", "ai")
if not first_folder_name:
first_folder_name = image_to_test_zip.split('.')[0]
filenameZip = None
uploaded_file_urlZip = this_conf['default_model']
modelfile = request.POST.get('dropdown_modelfile_pred')
if 'image_models_zip_pred' in request.FILES:
zip_to_train = request.FILES['image_models_zip_pred']
first_folder_name_zip = request.POST.get(
'first_folder_name_zip', None)
if not first_folder_name_zip:
first_folder_name_zip = zip_to_train.name.split('.')[0]
filenameZip, location, uploaded_file_urlZip = saveFileOutput(
zip_to_train, "objectdetection", "ai")
n_neighbors = int(request.POST.get('neighbors_pred', 1))
if filenameZip:
image_final = objectdetection.predictFromZip(
uploaded_file_url,
model_path='{f}.clf'.format(
f=filenameZip.split('.')[0]),
first_folder_name=first_folder_name,
trainZipFile=uploaded_file_urlZip,
first_folder_name_training_zip=first_folder_name_zip,
n_neighbors=n_neighbors)
else:
image_final = objectdetection.predictFromZip(
uploaded_file_url,
model_path=modelfile,
first_folder_name=first_folder_name)
with open(image_final, 'rb') as fh:
response = HttpResponse(
fh.read(),
content_type="application/{type}".format(
type=filename.split('.')[1]))
response[
'Content-Disposition'] = 'inline; filename=' + os.path.basename(
image_final)
return response
if request.POST.get('is_async_predictFromZip', False):
data = {'data': this_conf['need_params']}
return JsonResponse(data)
return renderMainPanel(request=request,
popup_text=this_conf['need_params'])
except Exception as e:
Logger.printMessage(message='predictFromZip',
description=str(e),
is_error=True)
return renderMainPanel(request=request, popup_text=str(e))
def train(request):
# Init of the view train
try:
# Pool call
response, repool = sendPool(request, 'train')
if response or repool:
if repool:
return HttpResponse(response)
return renderMainPanel(request=request, popup_text=response.text)
else:
# Parameter train_dir
train_dir = request.POST.get('train_dir')
try:
# Save file model_save_path (Optional)
filename_model_save_path, location_model_save_path, model_save_path = saveFileOutput(
request.FILES['model_save_path'], 'objectdetection', 'ai')
except Exception as e:
# If not param model_save_path
if request.POST.get('is_async_train', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
# Parameter n_neighbors (Optional - Default None)
n_neighbors = request.POST.get('n_neighbors', None)
if not n_neighbors:
n_neighbors = None
# Parameter knn_algo (Optional - Default ball_tree)
knn_algo = request.POST.get('knn_algo', 'ball_tree')
# Parameter verbose (Optional - Default False)
verbose = request.POST.get('verbose', False)
if not verbose:
verbose = None
# Execute, get result and show it
result = ht.getModule('ht_objectdetection').train(
train_dir=train_dir,
model_save_path=model_save_path,
n_neighbors=n_neighbors,
knn_algo=knn_algo,
verbose=verbose)
if request.POST.get('is_async_train', False):
return JsonResponse({"data": result})
return renderMainPanel(request=request, popup_text=result)
except Exception as e:
if request.POST.get('is_async_train', False):
return JsonResponse({"data": str(e)})
return renderMainPanel(request=request, popup_text=str(e))
