from django.http import JsonResponse
from django.shortcuts import render, redirect
from django.utils.datetime_safe import datetime
from func_timeout import func_timeout, FunctionTimedOut
from questions.models import Question, Scores
import json
from firebase_admin import credentials, firestore
from config import *
from django.contrib.auth import logout
cred = credentials.Certificate('./firekey.json')
db = firestore.client()
# Get current timestamp.
def timestamp():
return datetime.now().strftime('%Y%m%d%H%M%S')
# Gets the answers of user, checks with actual answers from Database and
# calculates the score as per the marking scheme defined in config.py file.
def submit_data(request):
ansdict = json.loads(str(request.POST['answers']))
print(str(ansdict))
if request.user.is_authenticated:
for i in ansdict:
if Question.objects.get(
id=i).correct_option.upper() == ansdict[i].upper():
import firebase_admin
from firebase_admin import credentials
from firebase_admin import db
cred = credentials.Certificate("auth.json")
default_app = firebase_admin.initialize_app(
cred, {'databaseURL': '<firebase database url>'})
print(default_app.name)
#update or create json table with below data.
dbref = db.dbreference('/')
dbref.set({
'Home': {
'Hall': {
'light': 'on',
'wallLight': "off",
'fan': 'on',
'ac': 'off',
},
'Room1': {
'light': 'on',
'wallLight': "off",
'fan': 'on',
'ac': 'off',
},
'Room2': {
'light': 'on',
'wallLight': "off",
'fan': 'on',
'ac': 'off',
from serial import SerialException
import pyrebase
import datetime
import serial
import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore
cred = credentials.Certificate(
'beacon-dddae-firebase-adminsdk-2qj4p-4ab2ce47dd.json')
firebase_admin.initialize_app(cred)
fb = firestore.client()
config = {
"apiKey": "AIzaSyD3_MZ_UEnz3G_cwXBAA9Fv1RZlVqxo2s0",
"authDomain": "beacon-dddae.firebaseapp.com",
"databaseURL": "https://beacon-dddae.firebaseio.com",
"projectId": "beacon-dddae",
"storageBucket": "beacon-dddae.appspot.com",
"messagingSenderId": "717730730032",
"appId": "1:717730730032:web:665ff2d3aa744e4c"
}
firebase = pyrebase.initialize_app(config)
auth = firebase.auth()
db = firebase.database()
def connect():
while (True):
try:
arduino = serial.Serial('com9', 9600)
performcode(arduino)
except SerialException:
#program to delete the encoded images of deactivated user as in firebase
import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore
import pickle,argparse
ap = argparse.ArgumentParser()
ap.add_argument("-e", "--encodings", required=True,
help="path to serialized db of facial encodings")
args = vars(ap.parse_args('-e encodings.pickle'.split()))
cred = credentials.Certificate('digitaltravel-6cb10-firebase-adminsdk-l5pld-97a2c4bf6a.json')
firebase_admin.initialize_app(cred)
db = firestore.client()
dict_1 ={}
dict_2={}
d_name={}
d_encod={}
d_id={}
del_count=0
d_ref=db.collection(u'deleteduser')
del_docs=d_ref.stream()
for del_doc in del_docs:
del_count=del_count+1
dict_1=del_doc.to_dict()
dict_2=dict_1["user-id"]
#print(dict_2)
f_emp = open(args["encodings"], "rb+")
e_data=pickle.load(f_emp)
d_encod=e_data["encodings"]
d_name=e_data["names"]
flask_cors.CORS(app)
# Initialize APIs
##
## service_api = googleapiclient.discovery.build('iam', 'v1')
## firebase_admin.initialize_app()
## db = firestore.client()
# Use a service account # Initialize APIs
service_cred = service_account.Credentials.from_service_account_file(
filename='accounts/backendServiceAccount.json',
scopes=['https://www.googleapis.com/auth/cloud-platform'])
service_api = googleapiclient.discovery.build('iam',
'v1',
credentials=service_cred)
cred = credentials.Certificate('accounts/backendServiceAccount.json')
firebase_admin.initialize_app(cred)
db = firestore.client()
def get_hash(str):
m = hashlib.sha256()
m.update(str.encode('utf-8'))
return base58.b58encode(m.digest()).decode('ascii')[0:25].lower()
def create_service_account(project_id, service_name, display_name):
"""Creates a service account."""
service_account = service_api.projects().serviceAccounts().create(
name='projects/' + project_id,
body={
from django.contrib.auth.models import User, auth import pytz from django.utils import timezone from django.db.models import Q from django.views.decorators.csrf import csrf_exempt ####firebase import firebase_admin from firebase_admin import credentials, firestore,db import os, sys import json import ast script_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) rel_path = "covid.json" covid = os.path.join(script_dir, rel_path) cred = credentials.Certificate(covid) firebase_admin.initialize_app(cred) db = firestore.client() """ #####################covid2 script_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) rel_path = "covid2.json" covid2 = os.path.join(script_dir, rel_path) cred2 = credentials.Certificate(covid2) firebase_admin.initialize_app(cred2) db2 = firestore.client() ########################### """ ###pusher
###################################################
from utils.file import create_dir, write_json_to_file
###################################################
import firebase_admin
from firebase_admin import credentials, firestore
###################################################
THEGAMEDATA_PATH = "thegamedata"
###################################################
cred = credentials.Certificate('firebase/sacckey.json')
default_app = firebase_admin.initialize_app(cred)
db = firestore.client()
print("firebase initialized", db)
###################################################
create_dir("backup", verbose=True)
print("retrieving doc")
gamedatacoll = db.collection(THEGAMEDATA_PATH)
thegamepgn_docref = gamedatacoll.document("pgn")
thegamepgn_dict = thegamepgn_docref.get().to_dict()
print("writing json")
write_json_to_file("backup/pgn.json", thegamepgn_dict)
/point_2/windspeed
'''
import paho.mqtt.client as mqtt
import firebase_admin
from firebase_admin import credentials
from firebase_admin import db
# Your Firebase Database URL here:
projectUrl = "your-project.firebaseio.com"
# Your Firebase JSON credentials here:
credFile = "your-credentials.json"
# Import credentials
cred = credentials.Certificate(credFile)
firebase_admin.initialize_app(
cred, {
'databaseURL': projectUrl,
'databaseAuthVariableOverride': {
'uid': 'my-service-worker'
}
})
# Create reference in database
points = ["point_1", "point_2", "point_3"]
params = ["temp", "humd", "wind"]
refer = {}
topics = []
for point in points:
import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore
import json
import os
import sys
# Use a service account
cred = credentials.Certificate('./firebase_credentials.json')
firebase_admin.initialize_app(cred)
db = firestore.client()
def document_name(json_path):
(cam, event_date, frame_id) = sequence_info(json_path)
return f"{cam}.{event_date}.{frame_id}"
def sequence_info(json_path):
(cam, event_date, frame_json) = json_path.split(os.path.sep)[-3:]
(frame_id, _) = os.path.splitext(frame_json)
return (cam, event_date, frame_id)
def create_document(json_path):
with open(json_path) as f:
metadata = json.load(f)
from firebase_admin import credentials, firestore, auth
import firebase_admin
import threading
import uuid
import henpei_crypto
import traceback
import pyotp
import serial
import time
import cv2
import cv2 as cv
import math
import numpy as np
cred = credentials.Certificate("servicekey.json")
firebase_admin.initialize_app(cred)
COLORS = {
"WHITE": [200, 200, 200],
"BLUE": [125, 76, 22],
"YELLOW": [200, 200, 200],
"GREEN": [62, 87, 15],
"ORANGE": [200, 200, 200],
"RED": [53, 53, 140]
}
class pi:
def __init__(self):
self.s = serial.Serial('/dev/ttyACM2')
#self.led = LED(18)
import speech_recognition as sr
import firebase_admin
from firebase_admin import credentials
from firebase_admin import db
json = './service_account.json'
cred = credentials.Certificate(json)
firebase_admin.initialize_app(cred, {
'databaseURL': 'https://your-firebase-application.firebaseio.com'
})
ref = db.reference('/path-to-your-table/')
sample_rate = 48000
chunk_size = 2048
r = sr.Recognizer()
with sr.Microphone(sample_rate=sample_rate, chunk_size=chunk_size) as source:
r.adjust_for_ambient_noise(source)
print("Hello! What's that Query?")
audio = r.listen(source)
data = {}
try:
query = r.recognize_google(audio)
if 'on' in query:
from flask import Flask, render_template, request, redirect, jsonify, session
app = Flask(__name__)
app.secret_key = 'Tarbiyah23'
import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore
cred = credentials.Certificate("key.json")
firebase_admin.initialize_app(cred)
db = firestore.client()
@app.route('/api/mhs')
def api_mahasiswa():
mhs = []
docs = db.collection('mahasiswa').stream()
for doc in docs:
mahasiswa = doc.to_dict()
mahasiswa['id'] = doc.id
mhs.append(mahasiswa)
return jsonify(mhs)
@app.route('/')
def index():
if 'login' not in session:
return redirect('/login')
mhs = []
docs = db.collection('mahasiswa').stream()
for doc in docs:
import firebase_admin
import pyrebase
import os
from django.conf import settings
from firebase_admin import credentials
firebase_config = {
'apiKey': "AIzaSyCs4Yq8i4cBGHxFWfDNYkdybcf0DEjEkK0",
'authDomain': "digirc-scet.firebaseapp.com",
'databaseURL': "https://digirc-scet.firebaseio.com/",
'projectId': "digirc-scet",
'storageBucket': "digirc-scet.appspot.com",
'messagingSenderId': "483564861009",
'appId': "1:483564861009:web:2f9ccdf224e51d1f"
}
firebase = pyrebase.initialize_app(firebase_config)
auth = firebase.auth()
database = firebase.database()
storage = firebase.storage()
filepath = os.path.join(settings.BASE_DIR, 'DigiRC//service_account_key.json')
cred = credentials.Certificate(filepath)
firebase_admin.initialize_app(cred)
#rtsp_domain = "rtsp://*****:*****@192.168.0.102:554/Streaming/Channels/101"
status = {'Status': ''}
try:
cap = cv2.VideoCapture(1)
except IOError:
message = 'Cant connect to camera'
status['Status'] = 'Cant connect to camera'
client.publish('v1/devices/me/telemetry', json.dumps(status), 1)
else:
if cap.isOpened():
ret, frame = cap.read()
tm = time.asctime(time.localtime(time.time()))
filename = 'images/' + str(tm) + '.jpg'
cv2.imwrite(filename, frame)
try:
cred = credentials.Certificate(
'lab411-a9813-firebase-adminsdk-zhpav-469b199d3c.json')
firebase_admin.initialize_app(
cred, {'storageBucket': 'lab411-a9813.appspot.com'})
bucket = storage.bucket()
blob = bucket.blob(filename)
blob.upload_from_filename(filename)
except:
message = 'Cant connect to cloud'
status['Status'] = 'Cant connect to cloud'
client.publish('v1/devices/me/telemetry', json.dumps(status), 1)
else:
message = "Successful"
status['Status'] = 'Send images successful'
client.publish('v1/devices/me/telemetry', json.dumps(status), 1)
def __init__(self):
# Initialize Firestore DB
cred = credentials.Certificate('keys/firebase-key.json')
self.default_app = initialize_app(cred)
self.db = firestore.client()
# coding: utf-8
import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore
import csv
import logging
formatter = "%(asctime)s %(levelname)s %(name)s %(funcName)s %(lineno)d : %(message)s"
logging.basicConfig(level=logging.DEBUG, format=formatter)
logger = logging.getLogger(__name__)
cred = credentials.Certificate("../bot/instance/key.json")
firebase_admin.initialize_app(cred)
db = firestore.client()
pref = {}
with open("./libraries.csv", "r", encoding="utf-8") as f:
reader = csv.DictReader(f)
for row in reader:
p = pref.get(row["pref"])
if p is None:
p = set()
p.add(row["city"])
pref[row["pref"]] = p
for p in pref:
logger.info(p)
db.collection("pref").document(p).set({p: list(pref[p])})
# -*- coding: utf-8 -*-
"""
Created on Mon Apr 13 14:08:29 2020
@author: Brownie
"""
import pandas as pd
import sys
import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore
if not firebase_admin._apps:
# Use a service account
cred = credentials.Certificate(
'./bibviz-firebase-adminsdk-1mj6d-d606f24212.json')
# cred = credentials.Certificate('/content/drive/My Drive/Auth/bibviz-firebase-adminsdk-1mj6d-d606f24212.json')
firebase_admin.initialize_app(cred)
db = firestore.client()
data = pd.read_csv('./AuthorXContentXReserve2.txt', sep='\t')
# data_650 = data[(data['MARC'] == 650) & (data['varfield_view.marc_tag'] == 710)]
no_data = data.shape[0]
start = 0
print('Processing Data ...')
for i, row in data.iloc[start:].iterrows():
book_id, lang_code, country_code, marc_tag, author, content, marc, checkout, renew, copy, internal = row
def initialize():
cred = credentials.Certificate('serviceAccountKey.json')
firebase_admin.initialize_app(
cred, {'databaseURL': 'https://hack-a-toon.firebaseio.com/'})
from sense_hat import SenseHat
import firebase_admin
from firebase_admin import credentials, firestore
import time
# constants
COLLECTION = 'data'
DOCUMENT = 'metrics'
NEIGHBOURS_NEEDED = 3
# firebase
cred = credentials.Certificate("./config.json")
firebase_admin.initialize_app(cred)
# connect firestore
db = firestore.client()
pi_ref = db.collection(COLLECTION).document(DOCUMENT)
# sensehat
sense = SenseHat()
sense.set_imu_config(False, False, False)
sense.clear()
def getData():
return {
# u'date' : datetime.now,
u'temp': sense.get_temperature(),
u'pressure': sense.get_pressure(),
u'humidity': sense.get_humidity(),
}
FIREBASE_ADMIN_SDK_KEY,
PRODUCTION
)
app = Flask(__name__)
app.secret_key = SECRET
firebase = pyrebase.initialize_app(FIREBASE_CONFIG)
auth = firebase.auth()
logging.getLogger().setLevel(logging.INFO)
try:
if PRODUCTION:
firebase_admin.initialize_app()
else:
firebase_admin_cred = credentials.Certificate(FIREBASE_ADMIN_SDK_KEY)
firebase_admin.initialize_app(firebase_admin_cred)
except Exception as err:
logging.info(f'Starting app in prod: {PRODUCTION}')
logging.error(f'ERROR at firebase_admin.initialize_app: {err}')
def login_required(f):
@wraps(f)
def decorated_function(*args, **kwargs):
if not session.get('user'):
return redirect(url_for('view_login', next=request.url))
return f(*args, **kwargs)
return decorated_function
import firebase_admin
from firebase_admin import credentials
from firebase_admin import db
from google.cloud import storage
import os
import pandas as pd
from pprint import pprint
os.environ[
'GOOGLE_APPLICATION_CREDENTIALS'] = "C:/Users/Aniket/Desktop/Aniket/food-grain-app/farmfresh-9c7fd-firebase-adminsdk-dx65j-9533ee02a1.json"
cred = credentials.Certificate(
'farmfresh-9c7fd-firebase-adminsdk-dx65j-9533ee02a1.json')
firebase_admin.initialize_app(
cred, {'databaseURL': 'https://farmfresh-9c7fd.firebaseio.com/'})
def get_reponse(data):
final_list = []
for element in data:
tempDict = {}
tempDict['name'] = element
tempDict['description'] = data[element]['Description']
tempDict['imageUrl'] = data[element]['Image']
tempDict['size'] = data[element]['Size']
tempDict['price'] = data[element]['Price']
tempDict['availableQuantity'] = data[element]['Available Quantity']
tempDict['type'] = data[element]['Type']
final_list.append(tempDict)
return final_list
import os
from firebase_admin import credentials, firestore, initialize_app
import requests
import json
from model import UserModel, UserResponse
userModel = UserModel()
userResponse = UserResponse()
cred = credentials.Certificate('firebaseKey.json')
initialize_app(cred)
db = firestore.client()
users_ref = db.collection('users')
def update(request):
request_json = request.get_json()
id = request_json['phone']
userModel = UserModel(**request_json)
userResponse.userModel = request_json
user = users_ref.document(id).get().to_dict()
if (user != None):
users_ref.document(id).set(userModel.__dict__, merge=True)
userResponse.result = {
"code": "1",
"title": "修改完成",
}
else:
import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore
import argparse
import io
import json
import os
from google.cloud import language
import numpy
import six
# Use a service account
cred = credentials.Certificate(
'/Users/andyliu/develop/pennapps/NLP/pennapps-b49dc-f3f8ef18d574.json')
firebase_admin.initialize_app(cred)
#initialize database
db = firestore.client()
#users_ref = db.collection(u'users')
#docs = users_ref.stream()
def classify(text, verbose):
"""Classify the input text into categories. """
language_client = language.LanguageServiceClient()
document = language.types.Document(
import firebase_admin
from firebase_admin import credentials
from firebase_admin import db
import cv2
import numpy as np
import os
import datetime
import threading
carnumber = 0
carlen = 43
cred = credentials.Certificate('Mykey.json')
# firebase Autentication
firebase_admin.initialize_app(
cred,
{'databaseURL': 'https://contest-6f840.firebaseio.com'
# 자신 DB주소로 접속.
})
ref = db.reference()
# DB의 data 받아오기
def listener(event):
# 주차장의 .차량 변화를 보여주는 함수
if event.data['test3'] == False:
cap = cv2.VideoCapture('./parking.mp4')
# 동영상 실행
if (cap.isOpened() == False):
print("Unable to read camera feed")
class DbBasic:
__cred = credentials.Certificate(
'personal\\firebase\mucha-pizza-firebase-adminsdk-lrard-794e3a2b61.json'
)
__default_app = firebase_admin.initialize_app(
__cred, {'databaseURL': 'https://mucha-pizza.firebaseio.com/'})
def __init__(self):
self.id = random.randint(1, 1000)
def pegarEndereco(self, numeroTelefone):
aux = db.reference('users/' + "".join(numeroTelefone)).get()
# print(aux)
if aux is None:
return None
else:
return aux['endereco']
def pegarNome(self, numeroTelefone):
aux = db.reference('users/' + "".join(numeroTelefone)).get()
# print(aux)
if aux is None:
return None
else:
return aux['nome']
def cadastrarUsuario(self, numero, endereco, nome):
aux = db.reference('users')
if numero in list(aux.get().keys()):
aux.child("".join(numero)).update({
'encereco': endereco,
})
else:
aux.child("".join(numero)).set({
'endereco': endereco,
'nome': nome
})
def gravarPedido(self, ped, num):
# print("passei2")
db.reference('pedidos').child(num).set(ped)
self.id = random.randint(0, 1000)
def getID(self):
return self.id
def getPizzas(self):
return db.reference('pizzas').get()
def getRefri(self):
return db.reference('refrigerante').get()
def getPedidos(self):
return db.reference('pedidos').get()
def getPedido(self, fone):
pedidos = db.reference('pedidos').get()
for chave in pedidos:
if pedidos[chave]['telefone'] == fone:
return pedidos['chave']
return False
import os
import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore
current_file = os.path.abspath(os.path.dirname(__file__))
CRED = credentials.Certificate(
os.path.join(current_file, "tuk-mensa-kl-conv-ai-firebase-adminsdk.json"))
class FirestoreConnector:
def __init__(self):
firebase_admin.initialize_app(CRED)
self.db = firestore.client()
def create_document(self, path, data):
"""
Function for creating documents in Firestore
:param path: The path in Firestore, where the document should be created.
:param data: A Dict, containing one or more Key-Value Pairs
:return:
"""
if self.validate_document_path(path):
doc_ref = self.db.document(path)
doc_ref.set(data)
def delete_document(self, path):
doc_ref = self.db.document(path)
doc_ref.delete()
import firebase_admin
from firebase_admin import credentials
from firebase_admin import db
cred = credentials.Certificate(
"./calmdnd-firebase-adminsdk-5i177-e2b913ce4f.json")
# Initialize the app with a service account, granting admin privileges
firebase_admin.initialize_app(
cred, {'databaseURL': 'https://calmdnd.firebaseio.com'})
monsterList = []
def monsterListener(event):
monster = str(event.data)
if monster in monsterList:
monsterList.remove(monster)
print(monsterList)
else:
monsterList.append(monster)
print(monsterList)
file = "monsters.txt"
with open(file, mode="w") as outfile:
for s in monsterList:
import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore
# Use a service account to connect to database
cred = credentials.Certificate(
'/Users/natejhome/projects/Cloud Database/my-monster-manual-c54dbafe3cb7.json'
)
firebase_admin.initialize_app(cred)
db = firestore.client()
# Write a new document into the database
# Goblin stat block
Goblin_data = {
u'AC': 11,
u'ATK': u'1d6',
u'CR': 1,
u'HP': 15,
u'SPD': 30,
u'TYPE': u'Undead'
}
db.collection(u'monster_stats').document(u'Goblin').set(Goblin_data)
# Zombie stat block
Zombie_data = {
u'AC': 13,
u'ATK': u'1d6',
u'CR': 1,
u'HP': 25,
import firebase_admin
from firebase_admin import credentials
cred = credentials.Certificate("serviceAccountKey.json")
firebase_admin.initialize_app(cred)
from time import sleep
import numpy as np
from PIL import Image
from datetime import datetime
import sys
sys.path.append(r'C:\Users\DeepLearning_3\PycharmProjects\firebase_dump1\service\lib')
from tinydb_manager import TinyDBManager
from tinydb import Query, TinyDB
import cv2
from tqdm import tqdm
cred = credentials.Certificate('keys/i-find-521d7-firebase-adminsdk-wemsi-4fca9d0fb8.json')
firebase_admin.initialize_app(cred)
fm = FBManager(firestore.client())
inst = am.getInstance()
if inst.checkConnected() is False:
inst.connect('ifind', 'IFCollection')
root_path = r'C:\Users\DeepLearning_3\PycharmProjects\ipcgan_clone\preprocess\posts'
db = TinyDBManager(db_file=r'D:\Data\TinyDB\db.json', default_table='ganQueue')
table = db.getTable()
Request = Query()
while True:
# firebase 체크하기
# 5초마다 grabbed=False 인 것을 가져옴.
# gan_list = fm.readCollection(fm.getCollection(u'ganStack'))
