def sync_efs_to_s3():
setup_django()
from dvaapp.models import Video,TEvent
from dvaapp.tasks import sync_bucket_video_by_id
for v in Video.objects.all():
e = TEvent()
e.video_id = v.pk
e.operation = 'sync_bucket_video_by_id'
e.save()
sync_bucket_video_by_id(e.pk)
def test_coco():
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
from dvaui.view_shared import handle_uploaded_file
from dvaapp.tasks import perform_import, perform_region_import, perform_dataset_extraction
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaapp.models import TEvent
for fname in glob.glob('tests/ci/coco*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="application/zip")
v = handle_uploaded_file(f, name)
dt = TEvent.objects.get(video=v, operation='perform_import')
perform_import(dt.pk)
dt = TEvent(video=v, operation='perform_dataset_extraction')
dt.save()
perform_dataset_extraction(dt.pk)
shutil.copy("tests/ci/coco_regions/coco_ci_regions.json",
"dva/media/ingest/coco_ci_regions.json")
args = {"path": "/ingest/coco_ci_regions.json"}
dt = TEvent(video=v, operation='perform_region_import', arguments=args)
dt.save()
perform_region_import(dt.pk)
def ci():
"""
Used in conjunction with travis for Continuous Integration testing
:return:
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
import base64
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaapp.views import handle_uploaded_file, handle_youtube_video, create_query
from dvaapp.models import Video, Clusters,IndexEntries,TEvent
from django.conf import settings
from dvaapp.tasks import extract_frames, perform_face_indexing, inception_index_by_id, perform_ssd_detection_by_id,\
perform_yolo_detection_by_id, inception_index_ssd_detection_by_id, export_video_by_id, import_video_by_id,\
inception_query_by_image, perform_clustering, assign_open_images_text_tags_by_id
for fname in glob.glob('tests/ci/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="application/zip")
handle_uploaded_file(f, name)
handle_youtube_video('tomorrow never dies', 'https://www.youtube.com/watch?v=gYtz5sw98Bc')
for i,v in enumerate(Video.objects.all()):
extract_frames(TEvent.objects.create(video=v).pk)
inception_index_by_id(TEvent.objects.create(video=v).pk)
if i ==0: # save travis time by just running detection on first video
perform_ssd_detection_by_id(TEvent.objects.create(video=v).pk)
perform_yolo_detection_by_id(TEvent.objects.create(video=v).pk)
perform_face_indexing(v.pk)
inception_index_ssd_detection_by_id(TEvent.objects.create(video=v).pk)
assign_open_images_text_tags_by_id(TEvent.objects.create(video=v).pk)
fname = export_video_by_id(TEvent.objects.create(video=v,event_type=TEvent.EXPORT).pk)
f = SimpleUploadedFile(fname, file("{}/exports/{}".format(settings.MEDIA_ROOT,fname)).read(), content_type="application/zip")
vimported = handle_uploaded_file(f, fname)
import_video_by_id(TEvent.objects.create(video=vimported).pk)
dc = Clusters()
dc.indexer_algorithm = 'inception'
dc.included_index_entries_pk = [k.pk for k in IndexEntries.objects.all().filter(algorithm=dc.indexer_algorithm)]
dc.components = 32
dc.save()
clustering_task = TEvent()
clustering_task.clustering = dc
clustering_task.event_type = TEvent.CLUSTERING
clustering_task.operation = 'perform_clustering'
clustering_task.save()
perform_clustering(clustering_task.pk)
query,dv = create_query(10,False,['inception',],[],'data:image/png;base64,'+base64.encodestring(file('tests/query.png').read()))
inception_query_by_image(query.pk)
query,dv = create_query(10,True,['inception',],[],'data:image/png;base64,'+base64.encodestring(file('tests/query.png').read()))
inception_query_by_image(query.pk)
test_backup()
def sync_efs_to_s3():
setup_django()
from dvaapp.models import Video, TEvent
from dvaapp.tasks import sync_bucket_video_by_id
for v in Video.objects.all():
e = TEvent()
e.video_id = v.pk
e.operation = 'sync_bucket_video_by_id'
e.save()
sync_bucket_video_by_id(e.pk)
def sync_efs_to_s3():
setup_django()
from dvaapp.models import Video,TEvent
from dvaapp.tasks import perform_sync
for v in Video.objects.all():
e = TEvent()
e.video_id = v.pk
e.operation = 'perform_sync'
e.save()
perform_sync(e.pk)
def qt_lopq():
from dvaapp.models import Retriever, Indexer, TEvent
from dvaapp.tasks import perform_retriever_creation
dc = Retriever()
args = {'components': 32, 'm': 8, 'v': 8, 'sub': 128}
dc.algorithm = Retriever.LOPQ
dc.source_filters = {
'indexer_shasum': Indexer.objects.get(name="inception").shasum
}
dc.arguments = args
dc.save()
clustering_task = TEvent()
clustering_task.arguments = {'retriever_pk': dc.pk}
clustering_task.operation = 'perform_retriever_creation'
clustering_task.save()
perform_retriever_creation(clustering_task.pk)
def ci():
"""
Used in conjunction with travis for Continuous Integration testing
:return:
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
import base64
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaapp.views import handle_uploaded_file, handle_youtube_video, pull_vdn_list\
,import_vdn_dataset_url
from dvaapp.models import Video, Clusters,IndexEntries,TEvent,VDNServer
from django.conf import settings
from dvaapp.operations.query_processing import QueryProcessing
from dvaapp.tasks import extract_frames, inception_index_by_id, perform_ssd_detection_by_id,\
perform_yolo_detection_by_id, inception_index_regions_by_id, export_video_by_id, import_video_by_id,\
execute_index_subquery, perform_clustering, assign_open_images_text_tags_by_id, perform_face_detection,\
perform_face_indexing
for fname in glob.glob('tests/ci/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="application/zip")
handle_uploaded_file(f, name)
# handle_youtube_video('world is not enough', 'https://www.youtube.com/watch?v=P-oNz3Nf50Q') # Temporarily disabled due error in travis
for i,v in enumerate(Video.objects.all()):
extract_frames(TEvent.objects.create(video=v).pk)
inception_index_by_id(TEvent.objects.create(video=v).pk)
if i ==0: # save travis time by just running detection on first video
perform_ssd_detection_by_id(TEvent.objects.create(video=v).pk)
perform_face_detection(TEvent.objects.create(video=v).pk)
inception_index_regions_by_id(TEvent.objects.create(video=v).pk)
assign_open_images_text_tags_by_id(TEvent.objects.create(video=v).pk)
fname = export_video_by_id(TEvent.objects.create(video=v,event_type=TEvent.EXPORT).pk)
f = SimpleUploadedFile(fname, file("{}/exports/{}".format(settings.MEDIA_ROOT,fname)).read(), content_type="application/zip")
vimported = handle_uploaded_file(f, fname)
import_video_by_id(TEvent.objects.create(video=vimported).pk)
dc = Clusters()
dc.indexer_algorithm = 'inception'
dc.included_index_entries_pk = [k.pk for k in IndexEntries.objects.all().filter(algorithm=dc.indexer_algorithm)]
dc.components = 32
dc.save()
clustering_task = TEvent()
clustering_task.clustering = dc
clustering_task.event_type = TEvent.CLUSTERING
clustering_task.operation = 'perform_clustering'
clustering_task.save()
perform_clustering(clustering_task.pk)
query_dict = {
'image_data_b64':base64.encodestring(file('tests/query.png').read()),
'indexers':[
{
'algorithm':'inception',
'count':10,
'approximate':False
}
]
}
qp = QueryProcessing()
qp.create_from_json(query_dict)
execute_index_subquery(qp.indexer_queries[0].pk)
query_dict = {
'image_data_b64':base64.encodestring(file('tests/query.png').read()),
'indexers':[
{
'algorithm':'inception',
'count':10,
'approximate':True
}
]
}
qp = QueryProcessing()
qp.create_from_json(query_dict)
execute_index_subquery(qp.indexer_queries[0].pk)
server, datasets, detectors = pull_vdn_list(1)
for k in datasets:
if k['name'] == 'MSCOCO_Sample_500':
print 'FOUND MSCOCO SAMPLE'
import_vdn_dataset_url(VDNServer.objects.get(pk=1),k['url'],None)
test_backup()
def ci():
"""
Perform Continuous Integration testing using Travis
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
import base64
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaui.view_shared import handle_uploaded_file, pull_vdn_list \
, import_vdn_dataset_url
from dvaapp.models import Video, TEvent, VDNServer, DVAPQL, Retriever, DeepModel
from django.conf import settings
from dvaapp.processing import DVAPQLProcess
from dvaapp.tasks import perform_dataset_extraction, perform_indexing, perform_export, perform_import, \
perform_retriever_creation, perform_detection, \
perform_video_segmentation, perform_transformation
for fname in glob.glob('tests/ci/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="video/mp4")
handle_uploaded_file(f, name, False)
if sys.platform != 'darwin':
for fname in glob.glob('tests/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="application/zip")
handle_uploaded_file(f, name)
for i, v in enumerate(Video.objects.all()):
if v.dataset:
arguments = {'sync': True}
perform_dataset_extraction(
TEvent.objects.create(video=v, arguments=arguments).pk)
else:
arguments = {'sync': True}
perform_video_segmentation(
TEvent.objects.create(video=v, arguments=arguments).pk)
arguments = {'index': 'inception', 'target': 'frames'}
perform_indexing(
TEvent.objects.create(video=v, arguments=arguments).pk)
if i == 0: # save travis time by just running detection on first video
# face_mtcnn
arguments = {'detector': 'face'}
dt = TEvent.objects.create(video=v, arguments=arguments)
perform_detection(dt.pk)
arguments = {
'filters': {
'event_id': dt.pk
},
}
perform_transformation(
TEvent.objects.create(video=v, arguments=arguments).pk)
# coco_mobilenet
arguments = {'detector': 'coco'}
dt = TEvent.objects.create(video=v, arguments=arguments)
perform_detection(dt.pk)
arguments = {
'filters': {
'event_id': dt.pk
},
}
perform_transformation(
TEvent.objects.create(video=v, arguments=arguments).pk)
# inception on crops from detector
arguments = {
'index': 'inception',
'target': 'regions',
'filters': {
'event_id': dt.pk,
'w__gte': 50,
'h__gte': 50
}
}
perform_indexing(
TEvent.objects.create(video=v, arguments=arguments).pk)
# assign_open_images_text_tags_by_id(TEvent.objects.create(video=v).pk)
temp = TEvent.objects.create(video=v,
arguments={'destination': "FILE"})
perform_export(temp.pk)
temp.refresh_from_db()
fname = temp.arguments['file_name']
f = SimpleUploadedFile(fname,
file("{}/exports/{}".format(
settings.MEDIA_ROOT, fname)).read(),
content_type="application/zip")
vimported = handle_uploaded_file(f, fname)
perform_import(
TEvent.objects.create(video=vimported,
arguments={
"source": "LOCAL"
}).pk)
dc = Retriever()
args = {}
args['components'] = 32
args['m'] = 8
args['v'] = 8
args['sub'] = 64
dc.algorithm = Retriever.LOPQ
dc.source_filters = {
'indexer_shasum':
DeepModel.objects.get(name="inception",
model_type=DeepModel.INDEXER).shasum
}
dc.arguments = args
dc.save()
clustering_task = TEvent()
clustering_task.arguments = {'retriever_pk': dc.pk}
clustering_task.operation = 'perform_retriever_creation'
clustering_task.save()
perform_retriever_creation(clustering_task.pk)
query_dict = {
'process_type':
DVAPQL.QUERY,
'image_data_b64':
base64.encodestring(file('tests/query.png').read()),
'tasks': [{
'operation': 'perform_indexing',
'arguments': {
'index':
'inception',
'target':
'query',
'next_tasks': [{
'operation': 'perform_retrieval',
'arguments': {
'count': 20,
'retriever_pk':
Retriever.objects.get(name='inception').pk
}
}]
}
}]
}
launch_workers_and_scheduler_from_environment()
qp = DVAPQLProcess()
qp.create_from_json(query_dict)
qp.launch()
qp.wait()
server, datasets, detectors = pull_vdn_list(1)
for k in datasets:
if k['name'] == 'MSCOCO_Sample_500':
print 'FOUND MSCOCO SAMPLE'
import_vdn_dataset_url(VDNServer.objects.get(pk=1), k['url'], None,
k)
def ci():
"""
Used in conjunction with travis for Continuous Integration testing
:return:
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
import base64
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaapp.views import handle_uploaded_file, handle_youtube_video, pull_vdn_list\
,import_vdn_dataset_url
from dvaapp.models import Video, Clusters,IndexEntries,TEvent,VDNServer, DVAPQL
from django.conf import settings
from dvaapp.operations.processing import DVAPQLProcess
from dvaapp.tasks import extract_frames, perform_indexing, export_video, import_video_by_id,\
perform_clustering, perform_analysis, perform_detection,\
segment_video, crop_regions_by_id
for fname in glob.glob('tests/ci/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="video/mp4")
handle_uploaded_file(f, name, False)
if sys.platform != 'darwin':
for fname in glob.glob('tests/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="application/zip")
handle_uploaded_file(f, name)
# handle_youtube_video('world is not enough', 'https://www.youtube.com/watch?v=P-oNz3Nf50Q') # Temporarily disabled due error in travis
for i,v in enumerate(Video.objects.all()):
if v.dataset:
arguments = {'sync':True}
extract_frames(TEvent.objects.create(video=v,arguments=arguments).pk)
else:
arguments = {'sync':True}
segment_video(TEvent.objects.create(video=v,arguments=arguments).pk)
arguments = {'index': 'inception'}
perform_indexing(TEvent.objects.create(video=v,arguments=arguments).pk)
if i ==0: # save travis time by just running detection on first video
# face_mtcnn
arguments = {'detector': 'face'}
dt = TEvent.objects.create(video=v,arguments=arguments)
perform_detection(dt.pk)
arguments = {'filters':{'event_id':dt.pk},}
crop_regions_by_id(TEvent.objects.create(video=v,arguments=arguments).pk)
# coco_mobilenet
arguments = {'detector': 'coco'}
dt = TEvent.objects.create(video=v, arguments=arguments)
perform_detection(dt.pk)
arguments = {'filters':{'event_id':dt.pk},}
crop_regions_by_id(TEvent.objects.create(video=v,arguments=arguments).pk)
# inception on crops from detector
arguments = {'index':'inception','target': 'regions','filters': {'event_id': dt.pk, 'w__gte': 50, 'h__gte': 50}}
perform_indexing(TEvent.objects.create(video=v,arguments=arguments).pk)
# assign_open_images_text_tags_by_id(TEvent.objects.create(video=v).pk)
fname = export_video(TEvent.objects.create(video=v).pk)
f = SimpleUploadedFile(fname, file("{}/exports/{}".format(settings.MEDIA_ROOT,fname)).read(), content_type="application/zip")
vimported = handle_uploaded_file(f, fname)
import_video_by_id(TEvent.objects.create(video=vimported).pk)
dc = Clusters()
dc.indexer_algorithm = 'inception'
dc.included_index_entries_pk = [k.pk for k in IndexEntries.objects.all().filter(algorithm=dc.indexer_algorithm)]
dc.components = 32
dc.save()
clustering_task = TEvent()
clustering_task.arguments = {'clusters_id':dc.pk}
clustering_task.operation = 'perform_clustering'
clustering_task.save()
perform_clustering(clustering_task.pk)
query_dict = {
'process_type': DVAPQL.QUERY,
'image_data_b64':base64.encodestring(file('tests/query.png').read()),
'indexer_queries':[
{
'algorithm':'inception',
'count':10,
'approximate':False
}
]
}
qp = DVAPQLProcess()
qp.create_from_json(query_dict)
# execute_index_subquery(qp.indexer_queries[0].pk)
query_dict = {
'process_type': DVAPQL.QUERY,
'image_data_b64':base64.encodestring(file('tests/query.png').read()),
'indexer_queries':[
{
'algorithm':'inception',
'count':10,
'approximate':True
}
]
}
qp = DVAPQLProcess()
qp.create_from_json(query_dict)
# execute_index_subquery(qp.indexer_queries[0].pk)
server, datasets, detectors = pull_vdn_list(1)
for k in datasets:
if k['name'] == 'MSCOCO_Sample_500':
print 'FOUND MSCOCO SAMPLE'
import_vdn_dataset_url(VDNServer.objects.get(pk=1),k['url'],None)
test_backup()
#!/usr/bin/env python
import django, os, sys, glob, shutil
sys.path.append('../server/')
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
from dvaui.view_shared import handle_uploaded_file
from dvaapp.tasks import perform_import, perform_region_import, perform_dataset_extraction
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaapp.models import TEvent
from django.conf import settings
if __name__ == '__main__':
for fname in glob.glob('ci/coco*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="application/zip")
v = handle_uploaded_file(f, name)
dt = TEvent.objects.get(video=v, operation='perform_import')
perform_import(dt.pk)
dt = TEvent(video=v, operation='perform_dataset_extraction', arguments={})
dt.save()
perform_dataset_extraction(dt.pk)
shutil.copy("ci/coco_regions/coco_ci_regions.json", "{}/ingest/coco_ci_regions.json".format(settings.MEDIA_ROOT))
args = {"path": "/ingest/coco_ci_regions.json"}
dt = TEvent(video=v, operation='perform_region_import', arguments=args)
dt.save()
perform_region_import(dt.pk)
#!/usr/bin/env python
import django, sys, glob, os, time, logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
datefmt='%m-%d %H:%M',
filename='../logs/tests.log',
filemode='a')
sys.path.append('../server/')
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
from dvaapp.models import TEvent, Video
from dvaapp.tasks import perform_stream_capture
if __name__ == '__main__':
dv = Video(name="test", url=sys.argv[-1])
dv.save()
start = TEvent(video=dv,
operation="perform_stream_capture",
arguments={"max_time": 180})
start.save()
perform_stream_capture(start.pk)
def ci():
"""
Used in conjunction with travis for Continuous Integration testing
:return:
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
import base64
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaapp.views import handle_uploaded_file, handle_youtube_video, pull_vdn_list\
,import_vdn_dataset_url
from dvaapp.models import Video, Clusters,IndexEntries,TEvent,VDNServer
from django.conf import settings
from dvaapp.operations.query_processing import QueryProcessing
from dvaapp.tasks import extract_frames, perform_indexing, export_video_by_id, import_video_by_id,\
perform_clustering, perform_analysis, perform_detection,\
segment_video, crop_regions_by_id
for fname in glob.glob('tests/ci/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="video/mp4")
handle_uploaded_file(f, name, False)
if sys.platform != 'darwin':
for fname in glob.glob('tests/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="application/zip")
handle_uploaded_file(f, name)
# handle_youtube_video('world is not enough', 'https://www.youtube.com/watch?v=P-oNz3Nf50Q') # Temporarily disabled due error in travis
for i,v in enumerate(Video.objects.all()):
if v.dataset:
arguments_json = json.dumps({'sync':True})
extract_frames(TEvent.objects.create(video=v,arguments_json=arguments_json).pk)
else:
arguments_json = json.dumps({'sync':True})
segment_video(TEvent.objects.create(video=v,arguments_json=arguments_json).pk)
arguments_json = json.dumps({'index': 'inception'})
perform_indexing(TEvent.objects.create(video=v,arguments_json=arguments_json).pk)
if i ==0: # save travis time by just running detection on first video
# face_mtcnn
arguments_json = json.dumps({'detector': 'face'})
dt = TEvent.objects.create(video=v,arguments_json=arguments_json)
perform_detection(dt.pk)
arguments_json = json.dumps({'filters':{'event_id':dt.pk},})
crop_regions_by_id(TEvent.objects.create(video=v,arguments_json=arguments_json).pk)
# coco_mobilenet
arguments_json = json.dumps({'detector': 'coco'})
dt = TEvent.objects.create(video=v, arguments_json=arguments_json)
perform_detection(dt.pk)
arguments_json = json.dumps({'filters':{'event_id':dt.pk},})
crop_regions_by_id(TEvent.objects.create(video=v,arguments_json=arguments_json).pk)
# inception on crops from detector
arguments_json = json.dumps({'index':'inception','target': 'regions','filters': {'event_id': dt.pk, 'w__gte': 50, 'h__gte': 50}})
perform_indexing(TEvent.objects.create(video=v,arguments_json=arguments_json).pk)
# assign_open_images_text_tags_by_id(TEvent.objects.create(video=v).pk)
fname = export_video_by_id(TEvent.objects.create(video=v,event_type=TEvent.EXPORT).pk)
f = SimpleUploadedFile(fname, file("{}/exports/{}".format(settings.MEDIA_ROOT,fname)).read(), content_type="application/zip")
vimported = handle_uploaded_file(f, fname)
import_video_by_id(TEvent.objects.create(video=vimported).pk)
dc = Clusters()
dc.indexer_algorithm = 'inception'
dc.included_index_entries_pk = [k.pk for k in IndexEntries.objects.all().filter(algorithm=dc.indexer_algorithm)]
dc.components = 32
dc.save()
clustering_task = TEvent()
clustering_task.clustering = dc
clustering_task.event_type = TEvent.CLUSTERING
clustering_task.operation = 'perform_clustering'
clustering_task.save()
perform_clustering(clustering_task.pk)
query_dict = {
'image_data_b64':base64.encodestring(file('tests/query.png').read()),
'indexers':[
{
'algorithm':'inception',
'count':10,
'approximate':False
}
]
}
qp = QueryProcessing()
qp.create_from_json(query_dict)
# execute_index_subquery(qp.indexer_queries[0].pk)
query_dict = {
'image_data_b64':base64.encodestring(file('tests/query.png').read()),
'indexers':[
{
'algorithm':'inception',
'count':10,
'approximate':True
}
]
}
qp = QueryProcessing()
qp.create_from_json(query_dict)
# execute_index_subquery(qp.indexer_queries[0].pk)
server, datasets, detectors = pull_vdn_list(1)
for k in datasets:
if k['name'] == 'MSCOCO_Sample_500':
print 'FOUND MSCOCO SAMPLE'
import_vdn_dataset_url(VDNServer.objects.get(pk=1),k['url'],None)
test_backup()
