def resizeimageandputinazure (strkey, url):
maxwidthandheight = 150
resize = False
bytes = urllib2.urlopen(url).read()
img = Image.open( io.BytesIO (bytes))
newwidth = img.width
newheight = img.height
if (newheight > newwidth and newheight > maxwidthandheight):
heightpercent = maxwidthandheight/float(newheight)
newheight = maxwidthandheight
newwidth = int((float(img.width)*float(heightpercent)))
resize = True
elif (newwidth > newheight and newwidth > maxwidthandheight):
widthpercent = maxwidthandheight/float(newwidth)
newwidth = maxwidthandheight
newheight = int((float(img.height)*float(widthpercent)))
resize = True
if resize:
newimg = img.resize((newwidth, newheight), Image.ANTIALIAS)
newimg.format = img.format
newio = io.BytesIO()
newimg.save (newio, 'JPEG')
bytes = newio.getvalue()
blob_service = BlobService(account_name='wanderight', account_key='gdmZeJOCx3HYlFPZZukUhHAfeGAu4cfHWGQZc3+HIpkBHjlznUDjhXMl5HWh5MgbjpJF09ZxRaET1JVF9S2MWQ==')
blob_service.put_block_blob_from_bytes(config['container'], 'images/' + strkey, bytes,
x_ms_blob_content_type='image/jpg', x_ms_meta_name_values={'url':url})
def upload_documents():
data = request.json.get('data', None)
if not data:
return jsonify(status=400, message='No file content passed')
data = data.decode("base64")
upload_handler = get_upload_handler()
# force is a flag that signals to upload the current file even if it was uploaded before
force = request.json.get('force', None)
if force is None or force.lower() != "true":
if upload_handler.is_file_already_uploaded(data, current_user.get_id()):
return jsonify(status=400, message='File content was already uploaded. Force upload by adding the force boolean')
blob_service = BlobService(account_name=BLOB_ACCOUNT_NAME, account_key=BLOB_ACCOUNT_KEY)
filename = uuid.uuid4().hex
# put the data in the container using a random filename
blob_service.put_block_blob_from_bytes(BLOB_CONTAINER_NAME, filename, data)
task_collection = get_db().task_collection
# update the task db with the new task (which is parsing the new data file)
task_id = upload_handler.update_uploaded_file(filename, data, current_user.get_id())
return jsonify(status=200, message='Task created successfully', task_id=task_id)
class AzureTransfer(BaseTransfer):
def __init__(self, account_name, account_key, container_name):
BaseTransfer.__init__(self)
self.account_name = account_name
self.account_key = account_key
self.container_name = container_name
self.conn = BlobService(account_name=self.account_name, account_key=self.account_key)
self.container = self.get_or_create_container(self.container_name)
self.log.debug("AzureTransfer initialized")
def get_metadata_for_key(self, key):
key = fix_path(key)
return self.list_path(key)[0]['metadata']
def list_path(self, path):
return_list = []
path = fix_path(path)
self.log.info("Asking for listing of: %r", path)
for r in self.conn.list_blobs(self.container_name, prefix=path, delimiter="/",
include="metadata"):
entry = {"name": r.name, "size": r.properties.content_length,
"last_modified": dateutil.parser.parse(r.properties.last_modified),
"metadata": r.metadata}
return_list.append(entry)
return return_list
def delete_key(self, key_name):
key_name = fix_path(key_name)
self.log.debug("Deleting key: %r", key_name)
return self.conn.delete_blob(self.container_name, key_name)
def get_contents_to_file(self, obj_key, filepath_to_store_to):
obj_key = fix_path(obj_key)
self.log.debug("Starting to fetch the contents of: %r to: %r", obj_key, filepath_to_store_to)
return self.conn.get_blob_to_path(self.container_name, obj_key, filepath_to_store_to)
def get_contents_to_string(self, obj_key):
obj_key = fix_path(obj_key)
self.log.debug("Starting to fetch the contents of: %r", obj_key)
return self.conn.get_blob_to_bytes(self.container_name, obj_key), self.get_metadata_for_key(obj_key)
def store_file_from_memory(self, key, memstring, metadata=None):
# For whatever reason Azure requires all values to be strings at the point of sending
metadata_to_send = dict((str(k), str(v)) for k, v in metadata.items())
self.conn.put_block_blob_from_bytes(self.container_name, key, memstring,
x_ms_meta_name_values=metadata_to_send)
def store_file_from_disk(self, key, filepath, metadata=None):
# For whatever reason Azure requires all values to be strings at the point of sending
metadata_to_send = dict((str(k), str(v)) for k, v in metadata.items())
self.conn.put_block_blob_from_path(self.container_name, key, filepath,
x_ms_meta_name_values=metadata_to_send)
def get_or_create_container(self, container_name):
start_time = time.time()
self.conn.create_container(container_name)
self.log.debug("Got/Created container: %r successfully, took: %.3fs", container_name, time.time() - start_time)
return container_name
def upload_chunck(buf, path, storagename, container, key):
blob_service = BlobService(account_name=storagename, account_key=key)
loop = 0;
while True:
try:
blob_service.put_block_blob_from_bytes(container,path,buf)
break
except (azure.http.HTTPError, TimeoutError) as e:
loop = loop + 1
if loop >= 3:
raise e
def rest_modify_image(album_name, username):
gallery_db = connect_to_db()
albums = gallery_db.albums
requested_album = albums.find_one({"name": album_name})
if not requested_album:
return jsonify({'error': "album does not exist"})
if not username in requested_album["write"]:
return jsonify({'error': "no permission to post images"})
if request.method == 'POST':
req_file = request.json.get('data', '')
if not req_file:
return jsonify({'error': "no images"})
file_name = uuid.uuid4().hex
blob_service = BlobService(account_name=ACCOUNT_NAME, account_key=ACCOUNT_KEY)
blob_service.put_block_blob_from_bytes(CONTAINER_NAME, file_name, req_file.decode("base64"))
gallery_db.albums.update({'name': album_name}, {'$push': {'images': file_name}})
return jsonify({'success': "file uploaded", 'file_name': file_name})
else:
# DELETE
image = request.json.get('image', '')
if not image:
return jsonify({'error': 'no image name'})
blob_service = BlobService(account_name=ACCOUNT_NAME, account_key=ACCOUNT_KEY)
try:
blob_service.delete_blob(CONTAINER_NAME, image)
except WindowsAzureMissingResourceError:
# Even if the file is not in the blob storage, we want to remove it from the album
pass
gallery_db.albums.update({'name': album_name}, {'$pull': {'images': image}})
return jsonify({'success': "file deleted"})
def motion_detect():
try:
while True:
if gpio.input(37) == 1:
print "Motion Detected"
hubClient = EventHubClient()
hostname = socket.gethostname()
host = socket.gethostname()
body = ""
first = True
sensorType = "Motion"
sensorValue = "1"
sensorId = 'Motion@1stfloor'
tablename = 'sensordata'
motiontime = time.strftime('%m/%d/%Y %H:%M:%S');
add_info = host + "_PiCam@1stfloor_" + motiontime.replace("/","-").replace(" ","-").replace(":","-") + ".jpg"
print motiontime
if first == True:
first = False
else:
body += ","
#deviceid_sensorid_motiondatetime (- replace with).png
body += "{ \"DeviceId\" : \"" + host + "\", \"SensorId\" : \"" + sensorId + "\", \"SensorType\" : \"" + sensorType + "\", \"SensorValue\" : \"" + sensorValue + "\", \"Datetime\" : \"" + motiontime + "\", \"AdditionalInfo\" : \"" + add_info + "\", \"table_name\" : \"" + tablename + "\" }"
my_stream = io.BytesIO()
with picamera.PiCamera() as camera:
camera.resolution = (640, 480)
camera.capture(my_stream, 'jpeg')
img_stream = base64.b64encode(my_stream.getvalue())
img_type = "jpeg"
sensorType = "PiCam"
sensorValue = img_stream
sensorId = 'PiCam@1stfloor'
#add_info = host + "_" + sensorId + "_" + motiontime.replace("/","-").replace(" ","-").replace(":","-") + ".jpg"
print add_info
print time.strftime('%m/%d/%Y %H:%M:%S')
cbody = "{ \"DeviceId\" : \"" + host + "\", \"SensorId\" : \"" + sensorId + "\", \"SensorType\" : \"" + sensorType + "\", \"SensorValue\" : \"" + sensorValue + "\", \"Datetime\" : \"" + time.strftime('%m/%d/%Y %H:%M:%S') + "\", \"AdditionalInfo\" : \"" + add_info + "\", \"table_name\" : \"" + tablename + "\" }"
hubStatus = hubClient.sendMessage(body, hostname)
print hubStatus
hubStatus = hubClient.sendMessage(cbody, hostname)
print hubStatus
print time.strftime('%m/%d/%Y %H:%M:%S')
#print cbody
upload = my_stream.getvalue();
container = "motioncaptureimages-direct";
blob = add_info;
blob_service = BlobService(account_name='commoniotstorage', account_key='PX4BC7LHPFWYtayYDtHAC/CV/+VHWOudqXBB9En2dGYHg3yGnXwbXIOHyvdq0gEU0P4FTV0A5AlRBHFe5DL5Kg==')
blobstatus = blob_service.put_block_blob_from_bytes(
container,
blob,
upload,
x_ms_blob_content_type='image/jpg'
)
print blobstatus
print time.strftime('%m/%d/%Y %H:%M:%S')
except KeyboardInterrupt:
gpio.cleanup()
print "\n Terminated by User"
sys.exit()
# ADDED ####################################################################
## Decrease main image size
# we need to keep in mind aspect ratio
if image.shape[1] >= image.shape[0]:
width = 800
r = (width * 1.0) / image.shape[1]
dim = ( width, int(image.shape[0] * r) )
else:
height = 800
r = (height * 1.0) / image.shape[0]
dim = ( int(image.shape[1] * r), height )
# perform the actual resizing of the image
image = cv2.resize(image, dim, interpolation = cv2.INTER_AREA)
# put to blob smaller version
lol ,image_tn = cv2.imencode( '.jpg', image )
blob_service.put_block_blob_from_bytes( blob_container, imgBlobName, str(bytearray(image_tn.flatten().tolist())) )
############################################################################
# process image
colourStructure = getCharacteristics( image, region, results )
blob_service.put_block_blob_from_bytes( blob_analysis, imgBlobName, dumps(colourStructure) )
# {'PartitionKey': 'allPhotos', 'RowKey': 'imageName', 'thumbnail' : 'thumbnailName',
# 'userId' : ?, 'local' : ?, 'hue' : 200, 'saturation' : 200, 'value' : 200}
## query for image in table to ensure existence
currentTask = table_service.get_entity( tableName, tablePartitionKey, tableRowKey)
class AzureTransfer(BaseTransfer):
def __init__(self, account_name, account_key, container_name, prefix=None):
# NOTE: Azure wants all paths to start with a slash
prefix = "/{}".format(prefix.lstrip("/") if prefix else "")
super().__init__(prefix=prefix)
self.account_name = account_name
self.account_key = account_key
self.container_name = container_name
self.conn = BlobService(account_name=self.account_name, account_key=self.account_key)
self.container = self.get_or_create_container(self.container_name)
self.log.debug("AzureTransfer initialized")
# XXX: AzureTransfer isn't actively tested and hasn't its error handling is probably lacking
self.log.warning("AzureTransfer is experimental and has not been thoroughly tested")
def get_metadata_for_key(self, key):
key = self.format_key_for_backend(key)
return self._list_blobs(key)[0]["metadata"]
def _metadata_for_key(self, key):
return self._list_blobs(key)[0]["metadata"]
def list_path(self, key):
path = self.format_key_for_backend(key, trailing_slash=True)
return self._list_blobs(path)
def _list_blobs(self, path):
self.log.debug("Listing path %r", path)
items = self.conn.list_blobs(self.container_name, prefix=path, delimiter="/", include="metadata")
result = []
for item in items:
result.append({
"last_modified": dateutil.parser.parse(item.properties.last_modified),
"metadata": item.metadata,
"name": self.format_key_from_backend(item.name),
"size": item.properties.content_length,
})
return result
def delete_key(self, key):
key = self.format_key_for_backend(key)
self.log.debug("Deleting key: %r", key)
return self.conn.delete_blob(self.container_name, key)
def get_contents_to_file(self, key, filepath_to_store_to):
key = self.format_key_for_backend(key)
self.log.debug("Starting to fetch the contents of: %r to: %r", key, filepath_to_store_to)
return self.conn.get_blob_to_path(self.container_name, key, filepath_to_store_to)
def get_contents_to_fileobj(self, key, fileobj_to_store_to):
key = self.format_key_for_backend(key)
self.log.debug("Starting to fetch the contents of: %r", key)
return self.conn.get_blob_to_file(self.container_name, key, fileobj_to_store_to)
def get_contents_to_string(self, key):
key = self.format_key_for_backend(key)
self.log.debug("Starting to fetch the contents of: %r", key)
return self.conn.get_blob_to_bytes(self.container_name, key), self._metadata_for_key(key)
def store_file_from_memory(self, key, memstring, metadata=None):
key = self.format_key_for_backend(key)
# Azure requires all metadata keys and values to be strings
metadata_to_send = {str(k): str(v) for k, v in metadata.items()}
self.conn.put_block_blob_from_bytes(self.container_name, key, memstring,
x_ms_meta_name_values=metadata_to_send)
def store_file_from_disk(self, key, filepath, metadata=None, multipart=None):
key = self.format_key_for_backend(key)
# Azure requires all metadata keys and values to be strings
metadata_to_send = {str(k): str(v) for k, v in metadata.items()}
self.conn.put_block_blob_from_path(self.container_name, key, filepath,
x_ms_meta_name_values=metadata_to_send)
def get_or_create_container(self, container_name):
start_time = time.time()
self.conn.create_container(container_name)
self.log.debug("Got/Created container: %r successfully, took: %.3fs", container_name, time.time() - start_time)
return container_name
def upload():
file = request.files['fileInput']
print "File is" + file.filename
if file:
data = file.read()
blob_service = BlobService(account_name='squadshots', account_key='UgxaWKAKv2ZvhHrPt0IHi4EQedPpZw35r+RXkAYB2eICPrG3TjSwk2G8gUzG/PNDDTV+4CVCYWCvZSiad5xMQQ==')
blob_service.create_container('album')
blob_service.put_block_blob_from_bytes(
'album',
file.filename + "_blob",
data,
x_ms_blob_content_type='image/png'
)
if 'username' in session:
un = session['username']
else:
print "not in session"
blob_service.set_blob_metadata(container_name="album",
blob_name=file.filename + "_blob",
x_ms_meta_name_values={'metaun': un})
blob_service.get_blob_to_path('album',file.filename + "_blob",'static/output.png')
f = open('input_person.png','w+')
f.write(data)
f.close()
[X,y] = read_images(OUTPUT_DIRECTORY, (256,256))
# Convert labels to 32bit integers. This is a workaround for 64bit machines,
y = np.asarray(y, dtype=np.int32)
# Create the Eigenfaces model.
model = cv2.createEigenFaceRecognizer()
# Learn the model. Remember our function returns Python lists,
# so we use np.asarray to turn them into NumPy lists to make
# the OpenCV wrapper happy:
model.train(np.asarray(X), np.asarray(y))
# Save the model for later use
model.save("eigenModel.xml")
# Create an Eign Face recogniser
t = float(100000)
model = cv2.createEigenFaceRecognizer(threshold=t)
# Load the model
model.load("eigenModel.xml")
# Read the image we're looking for
try:
sampleImage = cv2.imread('static/output.png', cv2.IMREAD_GRAYSCALE)
if sampleImage != None:
sampleImage = cv2.resize(sampleImage, (256,256))
else:
print "sample image is null"
except IOError:
print "IO error"
# Look through the model and find the face it matches
[p_label, p_confidence] = model.predict(sampleImage)
# Print the confidence levels
print "Predicted label = %d (confidence=%.2f)" % (p_label, p_confidence)
# If the model found something, print the file path
if (p_label > -1):
count = 0
for dirname, dirnames, filenames in os.walk(OUTPUT_DIRECTORY):
for subdirname in dirnames:
subject_path = os.path.join(dirname, subdirname)
if (count == p_label):
for filename in os.listdir(subject_path):
print "subject path = " + subject_path
count = count+1
return "uploaded"
class BlobServiceAdapter(Component):
"""The :class:`BlobServiceAdapter` class is a thin wrapper over azure.storage.BlobService.
All the attributes of the wrapper stream are proxied by the adapter so
it's possible to do ``adapter.create_container()`` instead of the long form
``adapter.blob_service.adapter()``.
"""
def __init__(self):
self.blob_service = BlobService(
account_name=self.util.get_config("storage.azure.account_name"),
account_key=self.util.get_config("storage.azure.account_key"),
host_base=self.util.get_config("storage.azure.blob_service_host_base"),
)
def __getattr__(self, name):
return getattr(self.blob_service, name)
def create_container_in_storage(self, container_name, access="container"):
"""create a container if doesn't exist
:type container_name: str|unicode
:param container_name: Name of container to create.
:type access: str|unicode
:param access: Optional. Possible values include: container, blob
:return:
"""
try:
names = [x.name for x in self.blob_service.list_containers()]
if container_name not in names:
return self.blob_service.create_container(container_name, x_ms_blob_public_access=access)
else:
self.log.debug("container already exists in storage")
return True
except Exception as e:
self.log.error(e)
return False
def upload_file_to_azure(self, container_name, blob_name, stream):
"""
Creates a new block blob from a file/stream, or updates the content of
an existing block blob, with automatic chunking and progress
notifications.
:type container_name: str|unicode
:param container_name: Name of existing container.
:type blob_name: str | unicode
:param blob_name: Name of blob to create or update.
:type stream: file
:param stream: Opened file/stream to upload as the blob content.
"""
try:
if self.create_container_in_storage(container_name, "container"):
self.blob_service.put_block_blob_from_file(container_name, blob_name, stream)
return self.blob_service.make_blob_url(container_name, blob_name)
else:
return None
except Exception as e:
self.log.error(e)
return None
def upload_file_to_azure_from_bytes(self, container_name, blob_name, blob):
"""
Creates a new block blob from an array of bytes, or updates the content
of an existing block blob, with automatic chunking and progress
notifications.
:type container_name: str|unicode
:param container_name: Name of existing container.
:type blob_name: str|unicode
:param blob_name: Name of blob to create or update.
:type blob: bytes
:param blob: Content of blob as an array of bytes.
"""
try:
if self.create_container_in_storage(container_name, "container"):
self.blob_service.put_block_blob_from_bytes(container_name, blob_name, blob)
return self.blob_service.make_blob_url(container_name, blob_name)
else:
return None
except Exception as e:
self.log.error(e)
return None
def upload_file_to_azure_from_text(self, container_name, blob_name, text):
"""
Creates a new block blob from str/unicode, or updates the content of an
existing block blob, with automatic chunking and progress notifications.
:type container_name: str|unicode
:param container_name: Name of existing container.
:type blob_name: str|unicode
:param blob_name: Name of blob to create or update.
:type text: str|unicode
:param text: Text to upload to the blob.
"""
try:
if self.create_container_in_storage(container_name, "container"):
self.blob_service.put_block_blob_from_text(container_name, blob_name, text)
return self.blob_service.make_blob_url(container_name, blob_name)
else:
return None
except Exception as e:
self.log.error(e)
return None
def upload_file_to_azure_from_path(self, container_name, blob_name, path):
"""
Creates a new page blob from a file path, or updates the content of an
existing page blob, with automatic chunking and progress notifications.
:type container_name: str|unicode
:param container_name: Name of existing container.
:type blob_name: str|unicode
:param blob_name: Name of blob to create or update.
:type path: str|unicode
:param path: Path of the file to upload as the blob content.
"""
try:
if self.create_container_in_storage(container_name, "container"):
self.blob_service.put_block_blob_from_path(container_name, blob_name, path)
return self.blob_service.make_blob_url(container_name, blob_name)
else:
return None
except Exception as e:
self.log.error(e)
return None
def delete_file_from_azure(self, container_name, blob_name):
try:
if self.create_container_in_storage(container_name, "container"):
self.blob_service.delete_blob(container_name, blob_name)
except Exception as e:
self.log.error(e)
return None
class BlobServiceAdapter(Component):
"""The :class:`BlobServiceAdapter` class is a thin wrapper over azure.storage.BlobService.
All the attributes of the wrapper stream are proxied by the adapter so
it's possible to do ``adapter.create_container()`` instead of the long form
``adapter.blob_service.adapter()``.
"""
def __init__(self):
self.blob_service = BlobService(account_name=self.util.get_config("storage.azure.account_name"),
account_key=self.util.get_config("storage.azure.account_key"),
host_base=self.util.get_config("storage.azure.blob_service_host_base"))
def __getattr__(self, name):
return getattr(self.blob_service, name)
def create_container_in_storage(self, container_name, access="container"):
"""create a container if doesn't exist
:type container_name: str|unicode
:param container_name: Name of container to create.
:type access: str|unicode
:param access: Optional. Possible values include: container, blob
:return:
"""
try:
names = [x.name for x in self.blob_service.list_containers()]
if container_name not in names:
return self.blob_service.create_container(container_name, x_ms_blob_public_access=access)
else:
self.log.debug("container already exists in storage")
return True
except Exception as e:
self.log.error(e)
return False
def upload_file_to_azure(self, container_name, blob_name, stream):
"""
Creates a new block blob from a file/stream, or updates the content of
an existing block blob, with automatic chunking and progress
notifications.
:type container_name: str|unicode
:param container_name: Name of existing container.
:type blob_name: str | unicode
:param blob_name: Name of blob to create or update.
:type stream: file
:param stream: Opened file/stream to upload as the blob content.
"""
try:
if self.create_container_in_storage(container_name, 'container'):
self.blob_service.put_block_blob_from_file(container_name, blob_name, stream)
return self.blob_service.make_blob_url(container_name, blob_name)
else:
return None
except Exception as e:
self.log.error(e)
return None
def upload_file_to_azure_from_bytes(self, container_name, blob_name, blob):
"""
Creates a new block blob from an array of bytes, or updates the content
of an existing block blob, with automatic chunking and progress
notifications.
:type container_name: str|unicode
:param container_name: Name of existing container.
:type blob_name: str|unicode
:param blob_name: Name of blob to create or update.
:type blob: bytes
:param blob: Content of blob as an array of bytes.
"""
try:
if self.create_container_in_storage(container_name, 'container'):
self.blob_service.put_block_blob_from_bytes(container_name, blob_name, blob)
return self.blob_service.make_blob_url(container_name, blob_name)
else:
return None
except Exception as e:
self.log.error(e)
return None
def upload_file_to_azure_from_text(self, container_name, blob_name, text):
"""
Creates a new block blob from str/unicode, or updates the content of an
existing block blob, with automatic chunking and progress notifications.
:type container_name: str|unicode
:param container_name: Name of existing container.
:type blob_name: str|unicode
:param blob_name: Name of blob to create or update.
:type text: str|unicode
:param text: Text to upload to the blob.
"""
try:
if self.create_container_in_storage(container_name, 'container'):
self.blob_service.put_block_blob_from_text(container_name, blob_name, text)
return self.blob_service.make_blob_url(container_name, blob_name)
else:
return None
except Exception as e:
self.log.error(e)
return None
def upload_file_to_azure_from_path(self, container_name, blob_name, path):
"""
Creates a new page blob from a file path, or updates the content of an
existing page blob, with automatic chunking and progress notifications.
:type container_name: str|unicode
:param container_name: Name of existing container.
:type blob_name: str|unicode
:param blob_name: Name of blob to create or update.
:type path: str|unicode
:param path: Path of the file to upload as the blob content.
"""
try:
if self.create_container_in_storage(container_name, 'container'):
self.blob_service.put_block_blob_from_path(container_name, blob_name, path)
return self.blob_service.make_blob_url(container_name, blob_name)
else:
return None
except Exception as e:
self.log.error(e)
return None
def delete_file_from_azure(self, container_name, blob_name):
try:
if self.create_container_in_storage(container_name, 'container'):
self.blob_service.delete_blob(container_name, blob_name)
except Exception as e:
self.log.error(e)
return None
class AzureTransfer(BaseTransfer):
def __init__(self, account_name, account_key, container_name, prefix=None):
# NOTE: Azure wants all paths to start with a slash
prefix = "/{}".format(prefix.lstrip("/") if prefix else "")
super().__init__(prefix=prefix)
self.account_name = account_name
self.account_key = account_key
self.container_name = container_name
self.conn = BlobService(account_name=self.account_name,
account_key=self.account_key)
self.container = self.get_or_create_container(self.container_name)
self.log.debug("AzureTransfer initialized")
# XXX: AzureTransfer isn't actively tested and hasn't its error handling is probably lacking
self.log.warning(
"AzureTransfer is experimental and has not been thoroughly tested")
def get_metadata_for_key(self, key):
key = self.format_key_for_backend(key)
return self._list_blobs(key)[0]["metadata"]
def _metadata_for_key(self, key):
return self._list_blobs(key)[0]["metadata"]
def list_path(self, key):
path = self.format_key_for_backend(key, trailing_slash=True)
return self._list_blobs(path)
def _list_blobs(self, path):
self.log.debug("Listing path %r", path)
items = self.conn.list_blobs(self.container_name,
prefix=path,
delimiter="/",
include="metadata")
result = []
for item in items:
result.append({
"last_modified":
dateutil.parser.parse(item.properties.last_modified),
"metadata":
item.metadata,
"name":
self.format_key_from_backend(item.name),
"size":
item.properties.content_length,
})
return result
def delete_key(self, key):
key = self.format_key_for_backend(key)
self.log.debug("Deleting key: %r", key)
return self.conn.delete_blob(self.container_name, key)
def get_contents_to_file(self, key, filepath_to_store_to):
key = self.format_key_for_backend(key)
self.log.debug("Starting to fetch the contents of: %r to: %r", key,
filepath_to_store_to)
return self.conn.get_blob_to_path(self.container_name, key,
filepath_to_store_to)
def get_contents_to_fileobj(self, key, fileobj_to_store_to):
key = self.format_key_for_backend(key)
self.log.debug("Starting to fetch the contents of: %r", key)
return self.conn.get_blob_to_file(self.container_name, key,
fileobj_to_store_to)
def get_contents_to_string(self, key):
key = self.format_key_for_backend(key)
self.log.debug("Starting to fetch the contents of: %r", key)
return self.conn.get_blob_to_bytes(self.container_name,
key), self._metadata_for_key(key)
def store_file_from_memory(self, key, memstring, metadata=None):
key = self.format_key_for_backend(key)
# Azure requires all metadata keys and values to be strings
metadata_to_send = {str(k): str(v) for k, v in metadata.items()}
self.conn.put_block_blob_from_bytes(
self.container_name,
key,
memstring,
x_ms_meta_name_values=metadata_to_send)
def store_file_from_disk(self,
key,
filepath,
metadata=None,
multipart=None):
key = self.format_key_for_backend(key)
# Azure requires all metadata keys and values to be strings
metadata_to_send = {str(k): str(v) for k, v in metadata.items()}
self.conn.put_block_blob_from_path(
self.container_name,
key,
filepath,
x_ms_meta_name_values=metadata_to_send)
def get_or_create_container(self, container_name):
start_time = time.time()
self.conn.create_container(container_name)
self.log.debug("Got/Created container: %r successfully, took: %.3fs",
container_name,
time.time() - start_time)
return container_name
compiledImage = cv2.resize(compiledImage, (w / 5, h / 5),
interpolation=cv2.INTER_AREA)
# Overlay
try:
saveImage = cv2.addWeighted(compiledImage, 0.4, bigImageBigger,
0.6, 1)
except cv2.error as ex:
queue_service.delete_message(imagesQueue, message.message_id,
message.pop_receipt)
sys.stderr.write(ex)
continue
# Put to blob
if imgBlobName[-4] == '.':
mosID = imgBlobName[:-4] + "_mos" + imgBlobName[-4:]
else:
mosID = imgBlobName[:-5] + "_mos" + imgBlobName[-5:]
ignore, blobImage = cv2.imencode('.jpg', saveImage)
blob_service.put_block_blob_from_bytes(
blob_big, mosID, str(bytearray(blobImage.flatten().tolist())))
# Find big image entity
currentTableTask.mosaicId = mosID
table_service.update_entity(tableName, tablePartitionKey, tableRowKey,
currentTableTask)
# dequeue image
queue_service.delete_message(imagesQueue, message.message_id,
message.pop_receipt)
# process image
image_tn = makeThumbnail( image, imageWidth )
(hw, sw, vw) = getCharacteristics( image )
# put thumbnail to bloob: add suffix _tn
result ,blob_tn = cv2.imencode( '.jpg', image_tn )
# Override
tnID = imgBlobName
# if imgBlobName[-4] == '.' :
# tnID = imgBlobName[:-4] + "_tn" + imgBlobName[-4:]
# else :
# tnID = imgBlobName[:-5] + "_tn" + imgBlobName[-5:]
blob_service.put_block_blob_from_bytes( blob_container, tnID, str(bytearray(blob_tn.flatten().tolist())) )
# {'PartitionKey': 'allPhotos', 'RowKey': 'imageName', 'thumbnail' : 'thumbnailName',
# 'userId' : ?, 'local' : ?, 'hue' : 200, 'saturation' : 200, 'value' : 200}
## query for image in table to ensure existence
currentTask = table_service.get_entity( tableName, tablePartitionKey, tableRowKey)
## send the quantities to table: save thumbnail ID & save image characteristics
# currentTask.thumbnail = tnID
currentTask.hue = hw
currentTask.saturation = sw
currentTask.value = vw
table_service.update_entity( tableName, tablePartitionKey, tableRowKey, currentTask)
# dequeue image
## Decrease main image size
# we need to keep in mind aspect ratio
if image.shape[1] >= image.shape[0]:
width = 800
r = (width * 1.0) / image.shape[1]
dim = (width, int(image.shape[0] * r))
else:
height = 800
r = (height * 1.0) / image.shape[0]
dim = (int(image.shape[1] * r), height)
# perform the actual resizing of the image
image = cv2.resize(image, dim, interpolation=cv2.INTER_AREA)
# put to blob smaller version
lol, image_tn = cv2.imencode('.jpg', image)
blob_service.put_block_blob_from_bytes(
blob_container, imgBlobName,
str(bytearray(image_tn.flatten().tolist())))
############################################################################
# process image
colourStructure = getCharacteristics(image, region, results)
blob_service.put_block_blob_from_bytes(blob_analysis, imgBlobName,
dumps(colourStructure))
# {'PartitionKey': 'allPhotos', 'RowKey': 'imageName', 'thumbnail' : 'thumbnailName',
# 'userId' : ?, 'local' : ?, 'hue' : 200, 'saturation' : 200, 'value' : 200}
## query for image in table to ensure existence
currentTask = table_service.get_entity(tableName, tablePartitionKey,
tableRowKey)
