def import_vdn_dataset_url(server, url, user, cached_response):
response = None
try:
r = requests.get(url)
response = r.json()
except:
pass
if not response:
response = cached_response
video = Video()
video.description = "import from {} : {} ".format(server.url,
response['description'])
if user:
video.uploader = user
video.name = response['name']
video.save()
if response['download_url']:
p = processing.DVAPQLProcess()
query = {
'process_type':
DVAPQL.PROCESS,
'tasks': [{
'arguments': {
'source': 'VDN_URL',
'url': response['download_url']
},
'video_id': video.pk,
'operation': 'perform_import',
}]
}
p.create_from_json(j=query, user=user)
p.launch()
elif response['aws_key'] and response['aws_bucket']:
p = processing.DVAPQLProcess()
query = {
'process_type':
DVAPQL.PROCESS,
'tasks': [{
'arguments': {
'source': 'VDN_S3',
'key': response['aws_key'],
'bucket': response['aws_bucket']
},
'video_id': video.pk,
'operation': 'perform_import',
}]
}
p.create_from_json(j=query, user=user)
p.launch()
else:
raise NotImplementedError
def import_vdn_detector_url(server, url, user, cached_response):
response = None
try:
r = requests.get(url)
response = r.json()
except:
pass
if not response:
response = cached_response
detector = Detector()
detector.name = response['name']
detector.detector_type = response.get('detector_type', detector.YOLO)
detector.save()
if response.get('download_url', False):
p = processing.DVAPQLProcess()
query = {
'process_type':
DVAPQL.PROCESS,
'tasks': [{
'arguments': {
'detector_pk': detector.pk,
'download_url': response['download_url']
},
'operation': 'perform_detector_import',
}]
}
p.create_from_json(j=query, user=user)
p.launch()
elif response.get('aws_key', False) and response.get('aws_bucket', False):
raise NotImplementedError
else:
raise NotImplementedError
def import_vdn_detector_url(server, url, user):
r = requests.get(url)
response = r.json()
vdn_detector = create_vdn_detector(response, server)
detector = CustomDetector()
detector.name = vdn_detector.name
detector.vdn_detector = vdn_detector
detector.save()
if vdn_detector.download_url:
p = processing.DVAPQLProcess()
query = {
'process_type':
DVAPQL.PROCESS,
'tasks': [{
'arguments': {
'detector_pk': detector.pk
},
'operation': 'perform_detector_import',
}]
}
p.create_from_json(j=query, user=user)
p.launch()
elif vdn_detector.aws_key and vdn_detector.aws_bucket:
raise NotImplementedError
else:
raise NotImplementedError
def handle_youtube_video(name, url, extract=True, user=None, rate=30, rescale=0):
video = Video()
if user:
video.uploader = user
video.name = name
video.url = url
video.youtube_video = True
video.save()
if extract:
p = processing.DVAPQLProcess()
query = {
'process_type': DVAPQL.PROCESS,
'tasks': [
{
'arguments': {'next_tasks': [
{'operation': 'decode_video',
'arguments': {
'rate': rate,
'rescale': rescale,
'next_tasks': settings.DEFAULT_PROCESSING_PLAN
}
}
]},
'video_id': video.pk,
'operation': 'segment_video',
}
]
}
p.create_from_json(j=query, user=user)
p.launch()
return video
def delete_video_object(video_pk, deleter, garbage_collection=True):
video = Video.objects.get(pk=video_pk)
deleted = DeletedVideo()
deleted.name = video.name
deleted.deleter = deleter
deleted.uploader = video.uploader
deleted.url = video.url
deleted.description = video.description
deleted.original_pk = video_pk
deleted.save()
video.delete()
if garbage_collection:
p = processing.DVAPQLProcess()
query = {
'process_type':
DVAPQL.PROCESS,
'tasks': [{
'arguments': {
'video_pk': video.pk
},
'operation': 'delete_video_by_id',
}]
}
p.create_from_json(j=query, user=deleter)
p.launch()
def handle_downloaded_file(downloaded, video, name, extract=True, user=None, rate=30, rescale=0):
video.name = name
video.save()
filename = downloaded.split('/')[-1]
if filename.endswith('.dva_export.zip'):
create_video_folders(video, create_subdirs=False)
os.rename(downloaded, '{}/{}/{}.{}'.format(settings.MEDIA_ROOT, video.pk, video.pk, filename.split('.')[-1]))
video.uploaded = True
video.save()
operation = 'import_video_by_id'
import_video_task = TEvent()
import_video_task.video = video
import_video_task.save()
app.send_task(name=operation, args=[import_video_task.pk, ], queue=settings.TASK_NAMES_TO_QUEUE[operation])
elif filename.endswith('.mp4') or filename.endswith('.flv') or filename.endswith('.zip'):
create_video_folders(video, create_subdirs=True)
os.rename(downloaded,
'{}/{}/video/{}.{}'.format(settings.MEDIA_ROOT, video.pk, video.pk, filename.split('.')[-1]))
video.uploaded = True
if filename.endswith('.zip'):
video.dataset = True
video.save()
if extract:
p = processing.DVAPQLProcess()
if video.dataset:
query = {
'process_type':DVAPQL.PROCESS,
'tasks':[
{
'arguments':{'rate': rate, 'rescale': rescale,'next_tasks':settings.DEFAULT_PROCESSING_PLAN},
'video_id':video.pk,
'operation': 'extract_frames',
}
]
}
else:
query = {
'process_type':DVAPQL.PROCESS,
'tasks':[
{
'arguments':{'next_tasks':[
{'operation':'decode_video',
'arguments':{
'rate': rate,
'rescale': rescale,
'next_tasks':settings.DEFAULT_PROCESSING_PLAN
}
}
]},
'video_id':video.pk,
'operation': 'segment_video',
}
]
}
p.create_from_json(j=query,user=user)
p.launch()
else:
raise ValueError, "Extension {} not allowed".format(filename.split('.')[-1])
return video
def import_vdn_dataset_url(server, url, user):
r = requests.get(url)
response = r.json()
vdn_dataset = create_dataset(response, server)
vdn_dataset.save()
video = Video()
if user:
video.uploader = user
video.name = vdn_dataset.name
video.vdn_dataset = vdn_dataset
video.save()
if vdn_dataset.download_url:
p = processing.DVAPQLProcess()
query = {
'process_type':
DVAPQL.PROCESS,
'tasks': [{
'arguments': {
'source': 'VDN_URL'
},
'video_id': video.pk,
'operation': 'perform_import',
}]
}
p.create_from_json(j=query, user=user)
p.launch()
elif vdn_dataset.aws_key and vdn_dataset.aws_bucket:
p = processing.DVAPQLProcess()
query = {
'process_type':
DVAPQL.PROCESS,
'tasks': [{
'arguments': {
'source': 'VDN_S3'
},
'video_id': video.pk,
'operation': 'perform_import',
}]
}
p.create_from_json(j=query, user=user)
p.launch()
else:
raise NotImplementedError
def handle_uploaded_file(f, name, extract=True, user=None, rate=30, rescale=0):
video = Video()
if user:
video.uploader = user
video.name = name
video.save()
primary_key = video.pk
filename = f.name
filename = filename.lower()
if filename.endswith('.dva_export.zip'):
create_video_folders(video, create_subdirs=False)
with open('{}/{}/{}.{}'.format(settings.MEDIA_ROOT, video.pk, video.pk, filename.split('.')[-1]),
'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
video.uploaded = True
video.save()
task_name = 'import_video_by_id'
import_video_task = TEvent()
import_video_task.video = video
import_video_task.save()
app.send_task(name=task_name, args=[import_video_task.pk, ], queue=settings.TASK_NAMES_TO_QUEUE[task_name])
elif filename.endswith('.mp4') or filename.endswith('.flv') or filename.endswith('.zip'):
create_video_folders(video, create_subdirs=True)
with open('{}/{}/video/{}.{}'.format(settings.MEDIA_ROOT, video.pk, video.pk, filename.split('.')[-1]),
'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
video.uploaded = True
if filename.endswith('.zip'):
video.dataset = True
video.save()
if extract:
p = processing.DVAPQLProcess()
query = {
'process_type':DVAPQL.PROCESS,
'tasks':[
{
'arguments_json':{'rate': rate, 'rescale': rescale},
'video_id':video.pk,
'operation': 'extract_frames' if video.dataset else 'segment_video',
}
]
}
p.create_from_json(j=query,user=user)
p.launch()
else:
raise ValueError, "Extension {} not allowed".format(filename.split('.')[-1])
return video
def delete_video_object(video_pk, deleter):
p = processing.DVAPQLProcess()
query = {
'process_type':
DVAPQL.PROCESS,
'tasks': [{
'arguments': {
'video_pk': video_pk,
'deleter_pk': deleter.pk
},
'operation': 'perform_deletion',
}]
}
p.create_from_json(j=query, user=deleter)
p.launch()
def handle_uploaded_file(f,
name,
extract=True,
user=None,
rate=None,
rescale=None):
if rate is None:
rate = defaults.DEFAULT_RATE
if rescale is None:
rescale = defaults.DEFAULT_RESCALE
video = Video()
if user:
video.uploader = user
video.name = name
video.save()
filename = f.name
filename = filename.lower()
if filename.endswith('.dva_export.zip'):
video.create_directory(create_subdirs=False)
with open(
'{}/{}/{}.{}'.format(settings.MEDIA_ROOT, video.pk, video.pk,
filename.split('.')[-1]),
'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
video.uploaded = True
video.save()
p = processing.DVAPQLProcess()
query = {
'process_type':
DVAPQL.PROCESS,
'tasks': [{
'arguments': {
'source': 'LOCAL'
},
'video_id': video.pk,
'operation': 'perform_import',
}]
}
p.create_from_json(j=query, user=user)
p.launch()
elif filename.endswith('.mp4') or filename.endswith(
'.flv') or filename.endswith('.zip'):
video.create_directory(create_subdirs=True)
with open(
'{}/{}/video/{}.{}'.format(settings.MEDIA_ROOT, video.pk,
video.pk,
filename.split('.')[-1]),
'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
video.uploaded = True
if filename.endswith('.zip'):
video.dataset = True
video.save()
if extract:
p = processing.DVAPQLProcess()
if video.dataset:
query = {
'process_type':
DVAPQL.PROCESS,
'tasks': [{
'arguments': {
'rescale': rescale,
'next_tasks':
defaults.DEFAULT_PROCESSING_PLAN_DATASET
},
'video_id': video.pk,
'operation': 'perform_dataset_extraction',
}]
}
else:
query = {
'process_type':
DVAPQL.PROCESS,
'tasks': [{
'arguments': {
'next_tasks': [{
'operation': 'perform_video_decode',
'arguments': {
'segments_batch_size':
defaults.DEFAULT_SEGMENTS_BATCH_SIZE,
'rate':
rate,
'rescale':
rescale,
'next_tasks':
defaults.DEFAULT_PROCESSING_PLAN_VIDEO
}
}]
},
'video_id': video.pk,
'operation': 'perform_video_segmentation',
}]
}
p.create_from_json(j=query, user=user)
p.launch()
else:
raise ValueError, "Extension {} not allowed".format(
filename.split('.')[-1])
return video
