def delete(id):
db = firestore.Client()
venusdoc_ref = db.collection(u'venusdoc').document(id)
venusdoc_ref.delete()
def __init__(self):
self.db_client = firestore.Client()
from google.cloud import firestore
datanase = firestore.Client()
doc = datanase.collection("Batting_History").document("111")
print(doc.get().to_dict())
def collector(event, context):
# This function doesnt need to know what to do at the moment.
# in future I may try and extend is to do different things, but for now it has 1 simple role
# kraken = "https://api.kraken.com/0/public/Ticker?pair=xbteur"
# luno = "https://api.mybitx.com/api/1/ticker?pair=XBTZAR"
kraken = "https://api.cryptowat.ch/markets/kraken/btceur/summary"
luno = "https://api.cryptowat.ch/markets/luno/btczar/summary"
exch = "https://api.exchangeratesapi.io/latest?base=ZAR"
timestamp = dt.datetime.now(pytz.utc)
resp_exch = requests.get(exch)
resp_luno = requests.get(luno)
resp_kraken = requests.get(kraken)
ex_rate = json.loads(resp_exch.content)["rates"]
ex_rate["timestamp"] = timestamp
json_luno = formatter(resp_luno, timestamp)
json_kraken = formatter(resp_kraken, timestamp)
db = firestore.Client()
db.collection(u'kraken').document(str(int(timestamp.timestamp()))).set(
json_kraken, merge=True)
db.collection(u'luno').document(str(int(timestamp.timestamp()))).set(
json_luno, merge=True)
db.collection(u'rates').document(str(int(timestamp.timestamp()))).set(
ex_rate, merge=True)
# If you start using luno api: to match kraken
# stemp = json.loads(resp_luno.content)
# dat = {}
# dat["ask_price"] = float(stemp["ask"])
# dat["ask_whole_lot_vol"] = None
# dat["ask_lot_vol"] = None
# dat["bid_price"] = float(stemp["bid"])
# dat["bid_whole_lot_vol"] = None
# dat["bid_lot_vol"] = None
# dat["close_price"] = float(stemp["last_trade"])
# dat["close_lot_vol"] = None
# dat["vol_today"] = None
# dat["vol_last24"] = float(stemp["rolling_24_hour_volume"])
# dat["vol_weighted_ave_price_today"] = None
# dat["vol_weighted_ave_price_last24"] = None
# dat["n_trades_today"] = None
# dat["n_trades_last24"] = None
# dat["l_today"] = None
# dat["l_last24"] = None
# dat["h_today"] = None
# dat["h_last24"] = None
# dat["opening_price_today"] = None
# # kraken
# stemp = json.loads(resp_kraken.content)["result"]["XXBTZEUR"]
# dat = {}
# dat["ask_price"] = float(stemp["a"][0])
# dat["ask_whole_lot_vol"] = float(stemp["a"][1])
# dat["ask_lot_vol"] = float(stemp["a"][2])
# dat["bid_price"] = float(stemp["b"][0])
# dat["bid_whole_lot_vol"] = float(stemp["b"][1])
# dat["bid_lot_vol"] = float(stemp["b"][2])
# dat["close_price"] = float(stemp["c"][0])
# dat["close_lot_vol"] = float(stemp["c"][1])
# dat["vol_today"] = float(stemp["v"][0])
# dat["vol_last24"] = float(stemp["v"][0])
# dat["vol_weighted_ave_price_today"] = float(stemp["p"][0])
# dat["vol_weighted_ave_price_last24"] = float(stemp["p"][0])
# dat["n_trades_today"] = float(stemp["t"][0])
# dat["n_trades_last24"] = float(stemp["t"][0])
# dat["l_today"] = float(stemp["l"][0])
# dat["l_last24"] = float(stemp["l"][0])
# dat["h_today"] = float(stemp["h"][0])
# dat["h_last24"] = float(stemp["h"][0])
# dat["opening_price_today"] = float(stemp["o"][0])
# push to BQ
# if pdf is not None:
# client = bigquery.Client()
# dataset_ref = client.dataset("exchange_data")
# table_ref = dataset_ref.table("exchange_data")
# job = client.load_table_from_dataframe(pdf, table_ref, location="US")
# job.result() # Waits for table load to complete.
# assert job.state == "DONE"
return ("success")
def __init__(self, config_file_path=None):
self.parse_config_file(config_file_path)
self.populate_config_parameters()
self.first_request = True
# Init client credentials
self.client_credentials = CloudPasswordLogin(self.login_email, self.login_password, self.api_key)
self.init_opencv()
self.ret = None
self.frame = None
self.frame_gray = None
self.prev_frame = np.zeros((self.camera_height, self.camera_width), np.uint8)
self.prev_frame_gray = np.zeros((self.camera_height, self.camera_width), np.uint8)
self.movement_detected = False
for i in range(self.times_to_rotate_by_90_degrees):
self.prev_frame = np.rot90(self.prev_frame)
self.prev_frame_gray = np.rot90(self.prev_frame_gray)
self.latest_image = np.zeros((self.camera_height, self.camera_width), np.uint8)
# Init URLs
self.url_base = 'https://firebasestorage.googleapis.com/v0/b/'
# inference_image_api_url: REST API endpoint for inference image
# inference_image_url: Binary image content for inference image
self.inference_image_api_url = (self.url_base
+ self.database_id
+ ".appspot.com/o/"
+ str(self.client_credentials.uid)
+ "%2Finference_"
+ self.device_id
+ ".jpg")
self.inference_image_url = self.inference_image_api_url + "?alt=media"
# recorded_image_api_url: REST API for recorded latest image
# recorded_image_url: Binary image content for recorded latest image
self.recorded_image_api_url = (self.url_base
+ self.database_id
+ ".appspot.com/o/"
+ str(self.client_credentials.uid)
+ "%2Frecorded_"
+ self.device_id
+ ".jpg")
self.recorded_image_url = self.recorded_image_api_url + "?alt=media"
# Init database and storage clients
# For Cloud Firestore
self.db = firestore.Client(project=self.database_id, credentials=self.client_credentials)
self.device_doc = self.db.collection('DEVICES').document(self.device_id)
# For Cloud Storage
self.authed_session = AuthorizedSession(self.client_credentials)
# Get Request Queue IDs
self.request_queues = None
self.request_queues_list = []
self.fetch_request_queues()
# Initialise the device on Firestore
try: # Tries to update the device
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
ip = s.getsockname()[0]
except:
ip = None
self.device_doc.update({'device_name': self.device_name,
'recorded_image_url': self.recorded_image_url,
'inference_image_url': self.inference_image_url,
'client_name': self.client_name,
'device_ip': ip})
s.close()
except: # If the device document does not exist then create the device document
try:
self.device_doc.set({'device_name': self.device_name,
'last_count_date': None,
'last_count_utc_time': None,
'last_count_unix_time': None,
'people_count': None,
'recorded_image_url': self.recorded_image_url,
'inference_image_url': self.inference_image_url,
'client_name': self.client_name})
except:
print("UNABLE TO INITIALISE DEVICE ON DATABASE")
def __init__(self, credentials, project):
self._client = firestore.Client(credentials=credentials, project=project)
def get_all(cls):
db = firestore.Client()
return [
cls().populate(**item.to_dict())
for item in db.collection(cls.collection_name).stream()
]
def check_snapshot(request):
from googleapiclient import discovery
from google.oauth2 import service_account
from google.cloud import firestore
from datetime import datetime
import pytz
if request.method == 'POST':
if request.is_json:
body = request.get_json(silent=True)
else:
return 'json not found', 400
if 'user' not in body or 'project_id' not in body:
return 'Wrong parameters', 409
if 'snapshot_id' not in body or 'debuggee_id' not in body or 'breakpoint_id' not in body:
return 'Wrong parameters', 409
project_id = body['project_id']
user = body['user']
snap_id = body['snapshot_id']
debuggee_id = body['debuggee_id']
breakpoint_id = body['breakpoint_id']
db = firestore.Client()
p_ref = db.collection(u'users').document(user).collection(
u'projects').document(project_id)
if p_ref.get().exists:
service_account_info = p_ref.get().to_dict()
else:
return 'Service account info not found', 411
credentials = service_account.Credentials.from_service_account_info(
service_account_info,
scopes=['https://www.googleapis.com/auth/cloud-platform'])
service = discovery.build('clouddebugger',
'v2',
credentials=credentials)
request = service.debugger().debuggees().breakpoints().get(
debuggeeId=debuggee_id, breakpointId=snap_id)
response = request.execute()['breakpoint']
try:
if response['isFinalState']:
# store snapshot info
snap_ref = p_ref.collection('captured_snapshots').document(
snap_id)
raw_ip = response['stackFrames'][3]['arguments'][1]['members'][
15]['value']
ip_address = raw_ip.split(', ')[0][1:]
if not snap_ref.get().exists:
snap_ref.set({
'create_final':
response['createTime'] + '/' + response['finalTime'],
'breakpoint':
breakpoint_id,
'ip_address':
ip_address
})
# delete snapshot from running_snapshots
p_ref.collection(u'running_snapshots').document(
snap_id).delete()
# create a new snapshot
b_info = db.collection(u'users').document(user).collection(u'projects').\
document(project_id).collection(u'breakpoints').document(breakpoint_id).get().to_dict()
body = {
"action": "CAPTURE",
"location": {
"path": b_info['file'],
"line": b_info['line']
}
}
request = service.debugger().debuggees().breakpoints().set(
debuggeeId=debuggee_id, body=body)
snap_id = request.execute()['breakpoint']['id']
print(snap_id, " created")
tz = pytz.timezone("Zulu")
snap_ref = p_ref.collection('running_snapshots').document(
snap_id)
snap_ref.set({
u'id': snap_id,
u'breakpoint_id': breakpoint_id,
u'create_time': str(datetime.now(tz))
})
return 'All good bro', 201
except Exception as e:
print(e)
return 'Probably Snapshot not captured yet', 202
return 'Nothing done', 200
def delete_data():
db = firestore.Client()
all_titles = db.collection(TITLES_COLLECTION).list_documents()
for title in all_titles:
title.delete()
break
def get_new_urls(self, domain_name):
db = firestore.Client()
new_urls_doc = db.collection(u'domains').document(domain_name)
new_urls_doc_results = new_urls_doc.get()
return new_urls_doc_results.to_dict()
def delegate_ML(user):
csv_str = storege_client.get_bucket("manerun-motions").blob(
user.csv_id).download_as_string()
score = Score_generate(csv_str)
firestore.Client().collection("users").document(user.id).update(
{"score": score})
def get_active_feed_urls(self, domain_name, is_active=False):
db = firestore.Client()
topic_doc_ref = db.collection(u'feeds').document(domain_name)
topics = topic_doc_ref.get().to_dict()
return [topic for topic in topics['topics'] if topic['is_active'] == is_active]
def build_firestore_client() -> firestore.Client:
return firestore.Client()
def client():
credentials = service_account.Credentials.from_service_account_file(FIRESTORE_CREDS)
project = FIRESTORE_PROJECT or credentials.project_id
yield firestore.Client(project=project, credentials=credentials)
def get_firestore_client(credentials):
credentials_info = ServiceAccount.auth(credentials)
return (firestore.Client(credentials=credentials_info,
project=credentials_info.project_id)
if credentials_info else firestore.Client())
def __init__(self):
json_config = json.loads(app.config['FIRESTORE_JSON'])
credentials = service_account.Credentials.from_service_account_info(json_config)
self.db = firestore.Client(project="uva-covid19-testing-kiosk",
credentials= credentials)
from google.cloud import firestore
urls_collection = firestore.Client().collection(u"urls")
def get_yes_or_no(text):
answer = input(text)
if not answer:
return False
answer = answer.lower()
if answer == "y":
return True
elif answer == "n":
return False
else:
print("yes or no only")
return get_yes_or_no(text)
def ask_to_approve(title, url, top_image, text):
print("title: {}".format(title))
print("URL: {}".format(url))
print("top_image url: {}".format(top_image))
print("################# SUMMARY ###############")
print(text)
print("################### END #################")
return get_yes_or_no("Approve? (y/N)")
def ratings(request):
"""Responds to any HTTP request.
Args:
request (flask.Request): HTTP request object.
Returns:
The response text or any set of values that can be turned into a
Response object using
`make_response <http://flask.pocoo.org/docs/1.0/api/#flask.Flask.make_response>`.
"""
if request.method == 'OPTIONS':
# Allows GET requests from any origin with the Content-Type
# header and caches preflight response for an 3600s
headers = {
'Access-Control-Allow-Origin': '*',
'Access-Control-Allow-Methods': 'GET',
'Access-Control-Allow-Headers': 'Content-Type',
'Access-Control-Max-Age': '3600'
}
return ('', 204, headers)
request_json = request.get_json()
headers = {
'Access-Control-Allow-Origin': '*',
}
try:
address = request_json.get("address", "")
product = request_json.get("product", "")
rating = request_json.get("rating", "")
if address == "" or product == "" or rating == "":
return ('invalid-request', 400, headers)
db = firestore.Client()
collection_name = "shops"
doc = db.collection(collection_name).document(address).get()
if not doc.exists:
return ("shop-doesn't-exist", 400, headers)
dic = doc.to_dict()
print(dic["products"])
print(len(dic["products"]))
for prod in dic["products"]:
print(prod["name"])
print(product)
if prod["name"] == product:
current_rating = prod["rating"]
print(type(current_rating))
if rating == "up":
current_rating += 1
elif rating == "down":
current_rating -= 1
else:
return ("invalid rating passed", 400, headers)
prod["rating"] = current_rating
db.collection(collection_name).document(address).set(dic)
return ("success", 200, headers)
return ("item-doesn't-exist", 400, headers)
except Exception as e:
return (str(e), 500)
def db():
yield firestore.Client()
import pytz
from google.cloud import firestore
import google.cloud.exceptions
from flask import Flask, jsonify, abort, Response
import flask
app = Flask(__name__)
app.config["JSONIFY_PRETTYPRINT_REGULAR"] = True
ZEIT_JSON_URL = os.environ["ZEIT_JSON_URL"]
BE_MOPO_CSV_URL = os.environ["BE_MOPO_CSV_URL"]
RL_TS_CSV_URL = os.environ["RL_TS_CSV_URL"]
FIRESTORE = firestore.Client().collection("cache")
FS_NOW_DOC = FIRESTORE.document("gernow-2")
FS_TIMESERIES_DOC = FIRESTORE.document("gerhistory-2")
log = logging.getLogger()
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s.%(msecs)03d %(levelname)s: %(message)s",
datefmt="%y%m%d-%H:%M:%S",
)
@app.route("/_tasks/update_now")
def task_update_now():
if flask.request.headers.get("X-Appengine-Cron") or app.debug:
import utils
import publish_utils
from google.cloud import firestore
from google.cloud import pubsub_v1
from datetime import datetime
publisher = pubsub_v1.PublisherClient()
twitter_topic_path = publisher.topic_path(constants.PROJECT_ID, constants.TWITTER_PUBLISH_QUEUE_TOPIC_NAME)
mailsender_topic_path = publisher.topic_path(constants.MAILSENDER_PROJECT_ID,
constants.PUBLISH_NEWSLETTER_QUEUE_TOPIC_NAME)
old_prod_chat_id = "@techtldr"
prod_chat_id = "@overnews"
urls_collection = firestore.Client().collection(u"urls")
newsletter_collection = firestore.Client(
project=constants.MAILSENDER_PROJECT_ID).collection(u"newsletters")
def publish_to_twitter_topic(title, telegram_url):
msg_dict = {
"title": title,
"url": telegram_url,
"test": False
}
msg_str = json.dumps(msg_dict)
msg_data = msg_str.encode("utf-8")
publisher.publish(
twitter_topic_path, msg_data
)
def __init__(self, bot: Bot):
super(Utility, self).__init__()
self.bot = bot
self.fire = firestore.Client()
def fmpfeedback_comment(request: Request) -> Any:
"""Cloud Function HTTP Entrypoint
Args:
request (Request): Framework request data
Returns:
"OK" if feedback was accepted or an error message with HTTP 4xx status code.
(Technically, client ignores response content.)
Anything other than status 2xx will cause client to notify user of failure.
"""
def _abort_return(client_error: str, internal_error: str = None) -> tuple:
if internal_error:
print(f"ERROR! Feedback submit failed: {internal_error}")
else:
print(f"ERROR! Feedback submit failed: {client_error}")
return client_error, 400
if request.method == "GET":
# Feedback must be submitted via POST but as a convenience we can at least
# sanity check the authtoken to help get started.
if not FEEDBACK_SENDER_AUTHTOKEN:
err, _ = _abort_return(
"You must define FEEDBACK_SENDER_AUTHTOKEN as a Runtime Environment Variable. See README for details."
)
return err
abort(405) # method not allowed
auth_username = request.authorization.username # [email protected]/token
auth_token = request.authorization.password # FEEDBACK_SENDER_AUTHTOKEN
x_forwarded_for = next(
iter(request.headers.get("X-Forwarded-For", "").split(
',', 1))).strip() # IP1 in "IP1, IP2,..., IPN"
if request.content_type != "application/json":
return _abort_return("BAD CONTENT")
if not auth_token:
return _abort_return("BAD TOKEN")
if auth_token != FEEDBACK_SENDER_AUTHTOKEN:
return _abort_return("BAD TOKEN")
try:
feedback_json = request.json["request"]
feedback_email = feedback_json["requester"]["email"]
feedback_subject = feedback_json["subject"]
feedback_body = feedback_json["comment"]["body"]
except KeyError:
return _abort_return("BAD DATA")
if not feedback_email:
return _abort_return("BAD DATA")
if not feedback_subject:
return _abort_return("BAD DATA")
if not feedback_body:
return _abort_return("BAD DATA")
if not auth_username:
return _abort_return("BAD AUTH")
if auth_username != f"{feedback_email}/token":
return _abort_return("BAD AUTH")
feedback_doc = {
FEEDBACKDOC_FIELD_SUBJECT: feedback_subject,
FEEDBACKDOC_FIELD_MESSAGE: feedback_body,
}
feedback_name = feedback_json["requester"].get("name") # optional
if feedback_name:
feedback_doc[FEEDBACKDOC_FIELD_NAME] = feedback_name
# An "uploads token" will be included if any files were attached to the feedback submission,
# in which case it will reference a stub document we need to update with feedback details.
fs_feedback_doc_id = feedback_json["comment"].get("uploads")
if fs_feedback_doc_id:
fs_feedback_doc_id = next(iter(fs_feedback_doc_id))
if fs_feedback_doc_id:
print(
f"Received feedback from: {feedback_email}; uploads stored with feedback {fs_feedback_doc_id}"
)
else:
print(f"Received feedback from: {feedback_email}; no uploads")
# 1. Store feedback document in Firestore collection
try:
fs_client = firestore.Client()
fs_feedback_coll = fs_client.collection(FEEDBACK_FIRESTORE_COLLECTION)
if fs_feedback_doc_id:
# Update details for existing feedback document with attachments
fs_feedback_doc = fs_feedback_coll.document(fs_feedback_doc_id)
fs_feedback_doc.update(feedback_doc)
else:
fs_feedback_docs = fs_feedback_coll.where(
FEEDBACKDOC_FIELD_EMAIL, "==",
feedback_email).where(FEEDBACKDOC_FIELD_ARCHIVEDTIMESTAMP,
"==", "").get()
# Prevent submitting too much feedback
if len(fs_feedback_docs) >= FEEDBACK_MAX_PENDING_SUBMITS:
return _abort_return(
"TOO MUCH FEEDBACK",
f"TOO MUCH FEEDBACK FROM {feedback_email}")
feedback_doc.update({
FEEDBACKDOC_FIELD_EMAIL:
feedback_email,
FEEDBACKDOC_FIELD_CREATETIMESTAMP:
datetime.now(timezone.utc).isoformat(timespec="seconds"),
FEEDBACKDOC_FIELD_CLIENTIP:
x_forwarded_for or request.remote_addr,
})
# Store feedback document
_, fs_feedback_doc = fs_feedback_coll.add(FEEDBACK_EMPTY_DOC
| feedback_doc)
fs_feedback_doc_id = fs_feedback_doc.id
except google.auth.exceptions.GoogleAuthError as e: # GoogleAuthError(Exception)
return _abort_return(
"FIRESTORE FAIL",
f"Feedback Firestore operation failed: Firestore auth exception: {e}"
)
except google.api_core.exceptions.ClientError as e: # ClientError(GoogleAPICallError)
return _abort_return(
"FIRESTORE FAIL",
f"Feedback Firestore operation failed: Firestore client exception: {e}"
)
except google.api_core.exceptions.GoogleAPIError as e: # GoogleAPIError(Exception)
return _abort_return(
"FIRESTORE FAIL",
f"Feedback Firestore operation failed: Firestore API exception: {e}"
)
except Exception as e:
return _abort_return(
"FIRESTORE FAIL",
f"Feedback Firestore operation failed: Unexpected exception: {e}")
# 2. Publish Pub/Sub message to notify subscribers a feedback document was submitted
try:
ps_client = pubsub.PublisherClient()
topic_path = ps_client.topic_path(fs_client.project,
FEEDBACK_PUBSUB_TOPIC)
try:
# Topic should have been created before Cloud Functions execute
topic = ps_client.get_topic(topic=topic_path)
except google.api_core.exceptions.NotFound:
return _abort_return(
"PUBSUB FAIL",
f"Feedback Pub/Sub {FEEDBACK_PUBSUB_FIELD_ACTION} failed: Topic does not exist: {topic_path}"
)
ps_message = json.dumps(
{
FEEDBACK_PUBSUB_FIELD_ACTION:
FEEDBACK_PUBSUB_ACTION_NEWFEEDBACK,
FEEDBACK_PUBSUB_FIELD_DOCID: fs_feedback_doc_id,
},
separators=(',', ':'))
# Block until publish is complete, raise exception on error
ps_future = ps_client.publish(topic.name, ps_message.encode())
ps_event_id = ps_future.result()
except google.auth.exceptions.GoogleAuthError as e: # GoogleAuthError(Exception)
return _abort_return(
"PUBSUB FAIL",
f"Feedback Pub/Sub {FEEDBACK_PUBSUB_FIELD_ACTION} publish failed: Pub/Sub auth exception: {e}"
)
except google.api_core.exceptions.ClientError as e: # ClientError(GoogleAPICallError)
return _abort_return(
"PUBSUB FAIL",
f"Feedback Pub/Sub {FEEDBACK_PUBSUB_FIELD_ACTION} publish failed: Pub/Sub client exception: {e}"
)
except google.api_core.exceptions.GoogleAPIError as e: # GoogleAPIError(Exception)
return _abort_return(
"PUBSUB FAIL",
f"Feedback Pub/Sub {FEEDBACK_PUBSUB_FIELD_ACTION} publish failed: Pub/Sub API exception: {e}"
)
except Exception as e:
return _abort_return(
"PUBSUB FAIL",
f"Feedback Pub/Sub {FEEDBACK_PUBSUB_FIELD_ACTION} publish failed: Unexpected exception: {e}"
)
else:
print(
f"Published {FEEDBACK_PUBSUB_FIELD_ACTION} '{FEEDBACK_PUBSUB_ACTION_NEWFEEDBACK}' to Pub/Sub topic: {ps_event_id}"
)
return "OK"
import google.auth.credentials
try:
import googleclouddebugger
googleclouddebugger.enable(breakpoint_enable_canary=True)
except ImportError:
pass
app = Flask(__name__)
#create a key
app.secret_key = ''.join(
secrets.choice(string.ascii_uppercase + string.digits) for i in range(8))
if os.getenv('GAE_ENV', '').startswith('standard'):
# production
db = firestore.Client()
else:
# localhost
os.environ["FIRESTORE_DATASET"] = "test"
os.environ["FIRESTORE_EMULATOR_HOST"] = "localhost:8001"
os.environ["FIRESTORE_EMULATOR_HOST_PATH"] = "localhost:8001/firestore"
os.environ["FIRESTORE_HOST"] = "http://localhost:8001"
os.environ["FIRESTORE_PROJECT_ID"] = "test"
credentials = mock.Mock(spec=google.auth.credentials.Credentials)
db = firestore.Client(project="test2", credentials=credentials)
def clear_db(db, search_str):
#Get a new write batch
batch = db.batch()
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# [START run_pubsub_server_setup]
import base64
import os
import sys
import json
import subprocess
from flask import Flask, request
from google.cloud import storage, firestore
app = Flask(__name__)
# [END run_pubsub_server_setup]
firestore_client = firestore.Client()
def download_blob(bucket_name, source_blob_name, destination_file_name):
"""Downloads a blob from the bucket."""
# bucket_name = "your-bucket-name"
# source_blob_name = "storage-object-name"
# destination_file_name = "local/path/to/file"
storage_client = storage.Client()
bucket = storage_client.bucket(bucket_name)
blob = bucket.blob(source_blob_name)
blob.download_to_filename(destination_file_name)
print(
json.dumps(dict(
def setup_db(app):
db = firestore.Client()
app.config['DB'] = db
def get_client():
setup_credentials()
return firestore.Client()
# because Heroku uses an ephemeral file system (https://devcenter.heroku.com/articles/active-storage-on-heroku)
# we need to write the key that is stored in FIREBASE_SERVICE_ACCOUNT_JSON to a file
# before we can pass it to firebase admin
# the below will error if you haven't set FIREBASE_SERVICE_ACCOUNT_JSON
raw_account = os.environ["FIREBASE_SERVICE_ACCOUNT_JSON"]
ACCOUNT_JSON_FILENAME = "firebase_account_cred.json"
with open(ACCOUNT_JSON_FILENAME, 'w') as account_file:
account_file.write(raw_account)
# Initialising this on Travis breaks the test suite
if os.environ.get("CI", None) != "true":
db = firestore.Client("assistive-chess-robot")
# can't do this in a CI environment
cred = credentials.Certificate(ACCOUNT_JSON_FILENAME)
default_app = firebase_admin.initialize_app(cred)
else:
# reassigned by a mock object
db = None
GAMES_COLLECTION = "games"
CONTROLLER_COLLECTION = "controllers"
COUNTS_COLLECTION = "counts"
BAD_REQUEST = 400
REQUEST_OK = 'OK'
app = Flask(__name__)
import time
############Explicit Credential environment
path = "/home/pi/Desktop/Parking.json"
os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = path
#GPIO starts
s1 = 2
s2 = 21
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(s1, GPIO.IN)
GPIO.setup(s2, GPIO.IN)
#firestore initialization
db = firestore.Client()
doc_ref_s1 = db.collection(u'sensors').document(u'sensor1')
doc_ref_s2 = db.collection(u'sensors').document(u'sensor2')
#here starts main
data1 = 0
data2 = 0
counter = 0
while 1:
if (GPIO.input(s1) == False): #car found in slot 1
data1 = 1
counter += 1
else:
data1 = 0
print("Received from 1: %s" % data1)
def update(data, venusdoc_id=None):
db = firestore.Client()
venusdoc_ref = db.collection(u'venusdoc').document(venusdoc_id)
venusdoc_ref.set(data)
return document_to_dict(venusdoc_ref.get())
