def Upload(img_path, img_name):
cred = credentials.Certificate(certificate_path)
firebase_admin.initialize_app(
cred, {'storageBucket': 'facerecognizationdata.appspot.com'})
bucket = storage.bucket()
with open(img_path, "rb") as image_file:
image_data = base64.b64encode(image_file.read())
bucket = storage.bucket()
blob = bucket.blob(img_name + '.jpg')
blob.upload_from_filename(img_path, content_type='image/jpg')
print(blob.public_url)
## blob = bucket.blob(img_name + '.jpg')
## blob.upload_from_filename(
## image_data,
## content_type='image/jpg'
## )
## print(blob.public_url)
##if __name__ == '__main__':
##
##
## img_path = '/'.join(os.path.realpath(__file__).replace('\\', '/').split('/')[:-1]) + '/2018_student.jpg'
##
##
## img_name = '2018_student'
##
## ImageUploading.Upload(img_path, img_name)
def deleteVideo():
data = request.get_json()
video_id = data['video_id']
token = data['idToken']
decoded_token = auth.verify_id_token(token)
user_uid = decoded_token['uid']
print(video_id, user_uid)
doc_ref = db.collection("users").document(user_uid).collection(
"videos").document(video_id).get()
print(doc_ref.to_dict())
if doc_ref.exists:
doc_ref = doc_ref.to_dict()
imageExtension = doc_ref["thumbnail_type"]
videoExtension = doc_ref['type']
bucket = storage.bucket()
blob = bucket.blob('images/' + video_id + imageExtension)
blob.delete()
bucket2 = storage.bucket()
blob2 = bucket2.blob('videos/' + video_id + videoExtension)
blob2.delete()
db.collection("users").document(user_uid).collection(
"videos").document(video_id).delete()
return Response("OK", status=200, mimetype='application/json')
else:
print(doc_ref.id)
print("!exists")
def downloadFile(filename):
print 'Downloading Video to temp file...'
tempName = 'temporaryVideo.mp4'
storage.bucket('mta-bus-view-originals').blob(
filename).download_to_filename(tempName,
client=None,
start=None,
end=None)
print 'Download complete!'
return tempName
def route_upload_user_image(user_id: str, index: int):
"""Endpoint for uploading profile images."""
user = User.objects.get_or_404(id=user_id)
user.identify(request)
image_file = request.files["user_image"]
if not re.match(IMAGE_MIMETYPE_REGEX, image_file.mimetype):
raise ValueError("The file is not an image type.")
bucket = storage.bucket()
file_name_to_save = "{0}_{1}_{2}".format(user.uid, index, uuid.uuid1())
blob = bucket.blob("{0}/{1}/{2}".format(USER_IMAGE_FOLDER, user.uid, file_name_to_save))
blob.upload_from_file(image_file)
user_images_temp = user.user_images_temp
current_image_at_index = next((x for x in user_images_temp if x.index == index), None)
if not current_image_at_index: # create new one
user.user_images_temp.append(UserImage(index=index, url=blob.public_url))
else: # update existing one
current_image_at_index.url = blob.public_url
user.user_images_temp = sorted(user_images_temp, key=lambda x: x.index)
user.status = User.Status.OPENED
user.save()
updated_image = next((x for x in user_images_temp if x.index == index), None)
response = encode(updated_image.to_mongo())
return Response(response, mimetype="application/json")
def download_blob(download=False):
bucket = storage.bucket()
blob = bucket.get_blob('surgery1.mp4')
if download:
with open("blob.mp4", "wb") as file_obj:
blob.download_to_file(file_obj)
return blob
def create_blob(file_path):
# Connect to bucket
bucket = storage.bucket()
# Create blob
blob = bucket.blob(file_path)
return blob
def _remove_image(self, filename):
bucket = storage.bucket(app=self.app)
blob = bucket.get_blob(filename)
if blob is None:
raise NotFoundError("Photo")
blob.delete()
def downloadFileFromRepository(self, filename):
bucket = storage.bucket("hyperledger-jte.appspot.com")
blob = bucket.get_blob(filename)
local_filename = filename.split(".")[0] + f"_{self.analyst_name}.txt"
blob.download_to_filename(local_filename)
os.rename(os.path.join(os.getcwd(), local_filename), os.path.join(self.analyst_path, filename))
def extract_features(args):
model = load_model(args)
model = model.cuda() if torch.cuda.is_available() else model
model.eval()
if not firebase_admin._apps:
print('Initializing firebase app')
cred = credentials.Certificate('firebase_key.json')
firebase_admin.initialize_app(cred)
bucket = storage.bucket('ssnap-411f1.appspot.com')
blobs = []
for i, blob in enumerate(bucket.list_blobs()):
if 'Grade' in blob.path or '%EC%9D%BC%EB%B0%98' in blob.path:
blobs.append(blob)
wf = open(args.csv_path, 'w')
with torch.no_grad():
for i, blob in tqdm(enumerate(blobs), total=len(blobs)):
try:
blob.download_to_filename('./fb_extract_temp.jpg')
image = read_image('./fb_extract_temp.jpg')
image = image.cuda(non_blocking=True) if torch.cuda.is_available() else image
_, features = model(image)
wf.write('{},{}\n'.format(blob.id, ','.join([str(x) for x in features[0].cpu().data.numpy()])))
except:
print('Error [{}] {}'.format(i, blob))
continue
os.remove('./fb_extract_temp.jpg')
wf.close()
def homepage():
if not checkLoggedIn():
return redirect(url_for('login'))
try:
bucket = storage.bucket()
blob = bucket.blob('hello.txt')
outfile='./hello.txt'
blob.upload_from_filename(outfile)
except:
print("ok")
def displayAllData():
user_refs = db.collection("available options")
docs = user_refs.stream()
options = [doc.to_dict() for doc in docs]
ret_dict = {}
for option in options:
product = option['item']
price = option['cash_price']
place = option["\ufeffname"]
popularity = option["popularity"]
if place in ret_dict:
ret_dict[place].append({product: [price, popularity]})
else:
ret_dict[place] = [{product: [price, popularity]}]
return ret_dict
display_dict = displayAllData()
return render_template("buyer.html", options=display_dict)
def verify(job: dict):
'''
Get the job, from the app id, download the user image and passport
compare this information and make sure that they match for facial rec.
Then, we need to check mrz and get info off of it. date of birth,
the expiry and stuff...............
'''
# Convert the byte strings to images
bucket = storage.bucket(app=app)
default_bucket = "userinf/{}/".format(job['AppID'])
passport_image_blob = default_bucket + "passport"
user_image_blob = default_bucket + "profile_picture"
passport_image_blob = bucket.blob(passport_image_blob)
user_image_blob = bucket.blob(user_image_blob)
passport_bytes = passport_image_blob.download_as_string()
profile_picture_bytes = user_image_blob.download_as_string()
passport_image = Image.open(io.BytesIO(passport_bytes))
user_image = Image.open(io.BytesIO(profile_picture_bytes))
check_face_result = __check_face(passport_image, user_image)
if(check_face_result[0]):
# Passed the first check, verify the user's face matches their
# passport now to verify date of biheaders = {'content-type': 'application/json'}rth and driving license number.
return __verify_age(io.BytesIO(passport_bytes), job)
else:
return check_face_result
def deleteFile(blob_path):
bucket = storage.bucket()
fileDeleteBlob = bucket.blob(blob_path)
try:
fileDeleteBlob.delete()
except Exception as e:
print(e)
def fetch_channels(self):
config = Config.get()
bucket = storage.bucket("yada-comp451.appspot.com")
channel_path = Path(channel_module_directory)
if not channel_path.exists():
channel_path.mkdir()
for key in filter(lambda section: section.startswith("channel/"),
config.sections()):
config.remove_section(key)
for root, dirs, files in os.walk(channel_module_directory):
for file in files:
os.remove(os.path.join(root, file))
template = self.template_snapshot.to_dict()
for channel_name, filename in template["channels"].items():
blob = bucket.blob(f"{PREFIX}{filename['script']}")
blob.download_to_filename(
f"{channel_module_directory}{channel_name}.py")
config[f"channel/{channel_name}"] = {
"module": filename['script'].replace(".py", "")
}
config["config"]["template_modified_date"] = template["modified"]
def __init__(self, private_key: str = "./certs/admin-key.json",
firebase_url: str = "https://spirobot-d9387.firebaseio.com/",
storage_bucket_url: str = "spirobot-d9387.appspot.com"):
"""
Constructor for Firebase communications
:param private_key: Private Key JSON file for Firebase
:param firebase_url: URL of Firebase Instance
:param storage_bucket_url: URL of Google Cloud Storage Instance.
"""
firebase_admin.initialize_app(credentials.Certificate(private_key), {
"databaseURL": firebase_url,
"storageBucket": storage_bucket_url
})
self.root = db.reference("/")
self.__verify_control_details()
sleep(1) # Allows Live DB to be refreshed and stops old commands from being loaded.
self.__controls = db.reference("controls")
self.__events = db.reference("events")
self.__status = db.reference("status")
self.__images = db.reference("images")
self.__custom_moves = db.reference("custom_moves")
self.__motion_data = db.reference("motion_data")
self.__proximity_data = db.reference("proximity_data")
self.__message_token = db.reference("token")
self.__video_state = None
self.communication_controls = {}
self.__storage_bucket = storage.bucket()
def __init__(self):
try:
self.app = firebase_admin.initialize_app(Firebase_module.cred)
except:
pass
self.db = firestore.client()
self.bucket = storage.bucket('homefood-b7713.appspot.com')
def __init__(self):
try:
cred_json = json.loads(os.getenv('FIREBASE_CREDENTIALS', None))
cred_json['private_key'] = cred_json['private_key'].replace(
'\\n', '\n')
credential = credentials.Certificate(cred_json)
app = firebase_admin.initialize_app(
credential, {
'projectId': 'colorfightai-firebase',
'storageBucket': 'colorfightai-firebase.appspot.com',
'databaseURL':
'https://colorfightai-firebase.firebaseio.com'
})
self.executor = concurrent.futures.ThreadPoolExecutor(
max_workers=15)
self.bucket = storage.bucket()
self.firestore = firestore.client()
self.db = db
self.leaderboard_duration = 7 * 24 * 3600
self.valid = True
self.timezone = datetime.timezone(datetime.timedelta(-1, 61200))
schedule.every().hour.at(":00").do(
self.sync_backup_leaderboard,
tag="leaderboard_" + datetime.datetime.now(
tz=self.timezone).strftime("%y%m%d_%H%M"))
except Exception as e:
self.valid = False
print(e)
print(
"Could not connect to firebase, other stuff should work fine")
def upload():
#initialize files
outfile = None
blob = None
bucket = storage.bucket()
#Name file by current time
name = str(dt.datetime.now())
#Picture to be sent to Firebase
outfile = '/home/pi/Desktop/CameraSoftware/WhoDat.jpg'
print("Sending Image to Firestore...")
#Upload image blob
blob = bucket.blob(settings.userID + '/images/' + name + '.jpg')
blob.upload_from_filename(outfile)
print("Image was uploaded to firestore!")
#Video to be Sent to Firebase
outfile = '/home/pi/Desktop/CameraSoftware/video.mp4'
print("Sending Video to Firestore...")
#Upload video blob
blob = bucket.blob(settings.userID + '/videos/' + name + '.mp4')
blob.upload_from_filename(outfile)
print("Video was uploaded to firestore!")
#Signal Database
fireapp = firebase.FirebaseApplication('https://mspi-a4b75.firebaseio.com',
None)
fireapp.post('/signal', {'signal': 'Charrrrrlie'})
print('DB has been signaled...')
def generate_song():
song_length = 100
pitches, velocities = _get_sequence(song_length)
_song_to_txt([pitches, velocities], song_length)
_txt_to_mid()
# Init firebase with your credentials
file_name = newMidi_dir + song_id + '.mid'
bucket = storage.bucket()
blob = bucket.blob(file_name)
blob.upload_from_filename(file_name)
blob.make_public()
song_obj = {
'name': "Temporary name",
'duration': str(song_length * .07),
'song_id': song_id,
'genres': "Classical"
}
url = 'Library/' + song_id
res = fb.patch(url, song_obj)
print(res)
return song_id
def uploadima(self):
from connection_status import connect
if connect():
from firebase_admin import credentials, initialize_app, storage
import firebase_admin
import pathlib
if not firebase_admin._apps:
cred = credentials.Certificate(
"farmzon-abdcb-c4c57249e43b.json")
initialize_app(cred,
{'storageBucket': 'farmzon-abdcb.appspot.com'})
# print(uploadima_app.name)
list_food = [
"avocado.png", "pea.png", "carrot.png", "cucumber.png",
"capsicum.png", "onion.png", "clove.png"
]
for i in range(list_food.__len__()):
fileName = "farmzon database/herbs/herbs/" + list_food[i]
bucket = storage.bucket()
suf = pathlib.Path(list_food[i]).suffix
name = self.rchop(list_food[i], ".png")
blob = bucket.blob("Categories_url/herbs/" + name.lower())
blob.upload_from_filename(fileName)
blob.make_public()
self.url = blob.public_url
print("your file url", self.url)
self.product_image = self.url
self.put_in_database(self.url, name.lower())
def addPictureToStorage(self, image):
bucket = storage.bucket()
blob = bucket.blob("Repairs/Test.png")
blob.upload_from_string(image, content_type='image/png')
blob.make_public()
print(blob.public_url)
def get_url(imagePath):
bucket = storage.bucket()
blob = bucket.blob(imagePath)
blob.upload_from_filename(imagePath)
blob.make_public()
return blob.public_url
def db_storage(ringsData, imgDirPath):
cred = firebase_admin.credentials.Certificate("./firebase_key.json")
firebase_admin.initialize_app(
cred, {
"databaseURL": "https://engagementringwebapp.firebaseio.com/",
"storageBucket": "engagementringwebapp.appspot.com"
})
# to access the root level of the collection node
root = db.reference()
# delete "shops" node to wipe all previous data
# shops might sell different rings already so better to wipe all old data
root.child("shops").delete()
# push new data obtained after recently web scrapping
root.child("shops").push(ringsData)
# upload all images to firebase storage
bucket = storage.bucket()
# delete all images in the firebase storage
# shops might sell different rings already so better to wipe all old data
bucket.delete_blobs(bucket.list_blobs())
# get each image and upload it
for file in os.listdir(imgDirPath):
# set the destination name
blob = bucket.blob(file)
# set the source path
blob.upload_from_filename(imgDirPath + "/" + file)
# to make it available to annoymous users so our website can access without authentication
blob.make_public()
# e.g. https://storage.googleapis.com/engagementringwebapp.appspot.com/86.jpg
# print(blob.public_url)
print("Finished uploadeding to database...")
def upload(self, caminho, arquivo):
try:
'''
screenshot = 'minha-colecao-a01d5.appspot.com'
banco='minha-colecao-a01d5.appspot.com/Y2hyaXN0aWFuLmNvbGl2ZWlyYUBnbWFpbC5jb20=/bancodados'
'''
# Init firebase with your credentials
try:
cred = credentials.Certificate(
"minha-colecao-a01d5-firebase-adminsdk-ehm8b-b1a0aed377.json"
)
initialize_app(cred, {'storageBucket': caminho})
except:
pass
# upload image
fileName = arquivo
bucket = storage.bucket()
blob = bucket.blob(fileName)
blob.upload_from_filename(fileName)
# Opt : if you want to make public access from the URL
blob.make_public()
print("your file url", blob.public_url)
# /Y2hyaXN0aWFuLmNvbGl2ZWlyYUBnbWFpbC5jb20=/bancodados
except Exception as e:
print(e)
def upload_image(self, image, image_cat):
assert image_cat in ["profile_picture", "floor_plan"]
if not allowed_file(image.filename, image_cat):
return ("danger", "Error!", "file must have one of the following extensions: {}".format(", ".join(
config.Config.ALLOWED_EXTENSIONS[image_cat])))
if not allowed_image_filesize(request.cookies[image_cat + "_filesize"]):
return ("danger", "Error!", "file size has exceeded maximum limit of 1Mb")
filename = secure_filename(image.filename)
bucket = storage.bucket("clamber-7fb70.appspot.com")
firestore_file_name = f"{self.uid}_{image_cat}.{filename.rsplit('.')[-1].upper()}"
blob = bucket.blob(firestore_file_name)
temp = tempfile.NamedTemporaryFile(delete=False)
image.save(temp.name)
t = threading.Thread(target=lambda blob, r: blob.upload_from_file(r), name=firestore_file_name, args=(blob, temp))
t.start()
t.join()
self.update_user({image_cat: firestore_file_name})
# Clean-up temp images
temp.close()
os.remove(temp.name)
return ("success", "Success!", "Profile picture has been successfully uploaded")
def pictureFunc():
GPIO.output(36, GPIO.LOW)
time.sleep(0.3)
GPIO.output(36, GPIO.HIGH)
value = randint(0, 10000)
vs.camera.capture('/home/pi/Desktop/randomCaptures_001/picture%s.jpg' %
value)
#os.system("aplay /home/pi/Desktop/test.wav")
# Put your local file path
fileName = ('/home/pi/Desktop/randomCaptures_001/picture%s.jpg' % value)
bucket = storage.bucket()
blob = bucket.blob(fileName)
blob.upload_from_filename(fileName)
# Opt : if you want to make public access from the URL
blob.make_public()
#Adding data to firebase
doc_ref = db.collection('testEntry').document('testDocument')
doc_ref.set({'Datetime': today, 'ImageUrl1': blob.public_url})
print("your file url", blob.public_url)
print("Datetime: ", today)
def success():
path = "images/original/"
if request.method == 'POST':
f = request.files['file']
ps = path+f.filename
f.save(ps)
fileName = f.filename
bucket = storage.bucket()
blob1 = bucket.blob(fileName)
blob1.upload_from_filename(ps)
blob1.make_public()
l1 = blob1.public_url
img = Image.open(ps)
# Compressing the image
compname = "/compressed_"+f.filename
blob2 = bucket.blob(compname)
if(request.form['comp']==''):
img.save('images/compressed'+compname,optimize=True,quality=30)
blob2.upload_from_filename('images/compressed'+compname)
blob2.make_public()
else:
img.save('images/compressed'+compname,optimize=True,quality=int(request.form['comp']))
blob2.upload_from_filename('images/compressed'+compname)
blob2.make_public()
# Setting the links in firebase
ref.set({"out_link":blob2.public_url,
"out_file_size":os.path.getsize('images/compressed'+compname),
"original_link":blob1.public_url,
"original_file_size":os.path.getsize(ps)})
return redirect(blob2.public_url)
def upload(self, model):
bucket = storage.bucket()
blob = bucket.blob('bus/' + str(model['timestamp']) + '.jpg')
blob.upload_from_string(model['image'])
blob.make_public()
print(blob.public_url)
return blob.public_url
def read_from_storage(self):
print('pulling from store')
bucket = storage.bucket()
for blob in bucket.list_blobs():
blob.download_to_filename(blob.name)
def upload():
if request.method == 'POST':
db = MySQLdb.connect("伺服器", "帳號", "密碼", "schema", charset='utf8')
cursor = db.cursor()
psort = request.form.get('psort')
pname = request.form.get('pname')
pmoney = request.form.get('pmoney')
file = request.files['pimg']
filename = file.filename # 圖片檔名
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
# 圖片上傳到 firebase Storage：先去firebase建立anysell資料夾
bucket = storage.bucket(app=app01)
blob = bucket.blob('anysell/'+filename)
blob.upload_from_filename(os.path.join(app.config['UPLOAD_FOLDER'], filename))
blob.make_public()
fbimg = blob.public_url
pstorage = fbimg
sql = 'INSERT INTO product(psort, pname, pmoney, pimg, pstorage) VALUES ("%s", "%s", "%s", "%s", "%s")' % (psort, pname, pmoney, filename, pstorage)
try:
cursor.execute(sql)
db.commit()
except:
db.rollback()
db.close()
return render_template('upload.html', okk='thanks')
else:
return render_template('upload.html')
def send_json_to_database(filename):
cred = credentials.Certificate(
'/root/mycovidtracker/mycovidtracker/service.json')
initialized = firebase_admin._apps
if not initialized:
initialize_app(cred,
{'storageBucket': 'mycovidtracker-5e186.appspot.com'})
bucket = storage.bucket('mycovidtracker-5e186.appspot.com'
) if initialized else storage.bucket()
blob = bucket.blob(filename)
blob.upload_from_filename(filename)
blob.make_public()
return
