def __init__(self, api_key=None, proxy_dict=None, env=None, json_encoder=None, adapter=None): if api_key: self._FCM_API_KEY = api_key elif os.getenv('FCM_API_KEY', None): self._FCM_API_KEY = os.getenv('FCM_API_KEY', None) else: raise AuthenticationError("Please provide the api_key in the google-services.json file") self.FCM_REQ_PROXIES = None self.requests_session = requests.Session() retries = Retry(backoff_factor=1, status_forcelist=[502, 503], allowed_methods=(Retry.DEFAULT_ALLOWED_METHODS | frozenset(['POST']))) self.requests_session.mount('http://', adapter or HTTPAdapter(max_retries=retries)) self.requests_session.mount('https://', adapter or HTTPAdapter(max_retries=retries)) self.requests_session.headers.update(self.request_headers()) self.requests_session.mount(self.INFO_END_POINT, HTTPAdapter(max_retries=self.INFO_RETRIES)) if proxy_dict and isinstance(proxy_dict, dict) and (('http' in proxy_dict) or ('https' in proxy_dict)): self.FCM_REQ_PROXIES = proxy_dict self.requests_session.proxies.update(proxy_dict) self.send_request_responses = [] if env == 'app_engine': try: from requests_toolbelt.adapters import appengine appengine.monkeypatch() except ModuleNotFoundError: pass self.json_encoder = json_encoder
def __init__(self, api_key=None, proxy_dict=None, env=None, json_encoder=None): """ :type proxy_dict: dict, api_key: string """ if api_key: self._FCM_API_KEY = api_key elif os.getenv('FCM_API_KEY', None): self._FCM_API_KEY = os.getenv('FCM_API_KEY', None) else: raise AuthenticationError( "Please provide the api_key in the google-services.json file") self.FCM_REQ_PROXIES = None if proxy_dict and isinstance(proxy_dict, dict) and ( ('http' in proxy_dict) or ('https' in proxy_dict)): self.FCM_REQ_PROXIES = proxy_dict self.send_request_responses = list() if env == 'app_engine': try: from requests_toolbelt.adapters import appengine appengine.monkeypatch() except: pass self.json_encoder = json_encoder
def __init__(self, api_key=None, proxy_dict=None, env=None, json_encoder=None): if api_key: self._FCM_API_KEY = api_key elif os.getenv('FCM_API_KEY', None): self._FCM_API_KEY = os.getenv('FCM_API_KEY', None) else: raise AuthenticationError( "Please provide the api_key in the google-services.json file") self.FCM_REQ_PROXIES = None self.requests_session = requests.Session() self.requests_session.headers.update(self.request_headers()) self.requests_session.mount(self.INFO_END_POINT, HTTPAdapter(max_retries=self.INFO_RETRIES)) if proxy_dict and isinstance(proxy_dict, dict) and ( ('http' in proxy_dict) or ('https' in proxy_dict)): self.FCM_REQ_PROXIES = proxy_dict self.requests_session.proxies.update(proxy_dict) self.send_request_responses = list() if env == 'app_engine': try: from requests_toolbelt.adapters import appengine appengine.monkeypatch() except: pass self.json_encoder = json_encoder
def __init__(self, api_key=None, proxy_dict=None, env=None, json_encoder=None): if api_key: self._FCM_API_KEY = api_key elif os.getenv('FCM_API_KEY', None): self._FCM_API_KEY = os.getenv('FCM_API_KEY', None) else: raise AuthenticationError("Please provide the api_key in the google-services.json file") self.FCM_REQ_PROXIES = None self.requests_session = requests.Session() retries = Retry(backoff_factor=1, status_forcelist=[502, 503, 504], method_whitelist=(Retry.DEFAULT_METHOD_WHITELIST | frozenset(['POST']))) self.requests_session.mount('http://', HTTPAdapter(max_retries=retries)) self.requests_session.mount('https://', HTTPAdapter(max_retries=retries)) self.requests_session.headers.update(self.request_headers()) self.requests_session.mount(self.INFO_END_POINT, HTTPAdapter(max_retries=self.INFO_RETRIES)) if proxy_dict and isinstance(proxy_dict, dict) and (('http' in proxy_dict) or ('https' in proxy_dict)): self.FCM_REQ_PROXIES = proxy_dict self.requests_session.proxies.update(proxy_dict) self.send_request_responses = [] if env == 'app_engine': try: from requests_toolbelt.adapters import appengine appengine.monkeypatch() except ModuleNotFoundError: pass self.json_encoder = json_encoder
def __init__(self, api_key=None, proxy_dict=None, env=None, json_encoder=None): """ :type proxy_dict: dict, api_key: string """ if api_key: self._FCM_API_KEY = api_key elif os.getenv("FCM_API_KEY", None): self._FCM_API_KEY = os.getenv("FCM_API_KEY", None) else: raise AuthenticationError( "Please provide the api_key in the google-services.json file") self.FCM_REQ_PROXIES = None self.requests_session = requests.Session() self.requests_session.headers.update(self.request_headers()) if (proxy_dict and isinstance(proxy_dict, dict) and (("http" in proxy_dict) or ("https" in proxy_dict))): self.FCM_REQ_PROXIES = proxy_dict self.requests_session.proxies.update(proxy_dict) self.send_request_responses = list() if env == "app_engine": try: from requests_toolbelt.adapters import appengine appengine.monkeypatch() except: pass self.json_encoder = json_encoder
def get(self): from requests_toolbelt.adapters import appengine appengine.monkeypatch() controller = str(self.request.get('controller_id')) t1 = str(self.request.get('t1')) t2 = str(self.request.get('t2')) client = bigquery.Client() query_job = client.query(asu_constants.QUERY.format( controller, t1, t2)) results = query_job.result() rows = list(results) dict_data = [] for i in range(len(rows)): dict_data.append({ 'timestamp': rows[i][0], 'controller_id': rows[i][1], 'ph': rows[i][2], 'ec': rows[i][3], 'temperature': rows[i][4] }) json_data = json.dumps(dict_data, cls=MyEncoder2) self.response.headers.add_header("Access-Control-Allow-Origin", "*") self.response.headers[ 'Content-Type'] = 'application/json; charset=utf-8' self.response.out.write(json_data)
def get(self): from requests_toolbelt.adapters import appengine appengine.monkeypatch() controller = str(self.request.get('controller_id')) t1 = str(self.request.get('t1')) t2 = str(self.request.get('t2')) #controller = 'controller1' #t1 = '2019-04-29T18:00:04.291333' #t2 = '2019-04-30T18:00:04.291333' client = bigquery.Client() query_job = client.query( asu_constants.QUERY_MIN.format(controller, t1, t2, controller, controller, t1, t2, controller, controller, t1, t2, controller)) results = query_job.result() rows = list(results) dict_data = [] for i in range(len(rows)): dict_data.append({ 'Column': rows[i][0], 'DATE': rows[i][1], 'value': rows[i][2] }) json_data = json.dumps(dict_data, cls=MyEncoder2) self.response.headers.add_header("Access-Control-Allow-Origin", "*") self.response.headers[ 'Content-Type'] = 'application/json; charset=utf-8' self.response.out.write(json_data)
def get(self): #os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1' appengine.monkeypatch() self.session[str(self.request.remote_addr)] = str( self.request.remote_addr) self.session['cstate'] = 0 alog = Behavlog() alog.remoaddr = self.session[str(self.request.remote_addr)] templist = [] for i in range(LIST_LENGTH): templist.append(-1) alog.vector = templist alog.put() self.redirect('/main/welcome')
def __fetch_get_request(): import json import requests from requests_toolbelt.adapters import appengine appengine.monkeypatch() response = requests.get('https://api.openbrewerydb.org/breweries/5494') return json.loads(response.text)
def __init__(self, loop=None, api_key=None, proxy_dict=None, env=None, json_encoder=None, adapter=None): self.loop = loop if api_key: self._FCM_API_KEY = api_key elif os.getenv('FCM_API_KEY', None): self._FCM_API_KEY = os.getenv('FCM_API_KEY', None) else: raise AuthenticationError( "Please provide the api_key in the google-services.json file") self.FCM_REQ_PROXIES = None self.requests_session = requests.Session() self.aiodns = AsyncResolver(loop=self.loop, nameservers=["8.8.8.8", "8.8.4.4"]) self.aiohttp_connector = aiohttp.TCPConnector(loop=self.loop, limit=0, ttl_dns_cache=600, resolver=self.aiodns, family=socket.AF_INET) self.aiohttp_session = ClientSession(loop=self.loop, headers=self.request_headers(), connector=self.aiohttp_connector, connector_owner=False) retries = Retry(backoff_factor=1, status_forcelist=[502, 503, 504], method_whitelist=(Retry.DEFAULT_METHOD_WHITELIST | frozenset(['POST']))) self.requests_session.mount( 'http://', adapter or HTTPAdapter(max_retries=retries)) self.requests_session.mount( 'https://', adapter or HTTPAdapter(max_retries=retries)) self.requests_session.headers.update(self.request_headers()) self.requests_session.mount(self.INFO_END_POINT, HTTPAdapter(max_retries=self.INFO_RETRIES)) if proxy_dict and isinstance(proxy_dict, dict) and ( ('http' in proxy_dict) or ('https' in proxy_dict)): self.FCM_REQ_PROXIES = proxy_dict self.requests_session.proxies.update(proxy_dict) self.send_request_responses = [] if env == 'app_engine': try: from requests_toolbelt.adapters import appengine appengine.monkeypatch() except ModuleNotFoundError: pass self.json_encoder = json_encoder
def setup_appengine(app): r""" App Engine setup procedures for app. """ appengine.monkeypatch() warnings.filterwarnings('ignore', r'urllib3 is using URLFetch', urllib3.contrib.appengine.AppEnginePlatformWarning) app.config.setdefault('DEBUG', os.getenv('SERVER_SOFTWARE', '').startswith('Google App Engine/')) app.debug = app.config['DEBUG']
def __init__(self, to_account, msg_date): #This line fixes the error #AttributeError: 'VerifiedHTTPSConnection' object has no attribute '_tunnel_host' appengine.monkeypatch() configParser = ConfigParser.RawConfigParser() file = r'./config/reception.cfg' configParser.read(file) self.msg_date = msg_date self.bucket = configParser.get('DEFAULT', 'BUCKET') self.dir = configParser.get('DEFAULT', 'DIRECTORY') for account in configParser.sections(): matchObj = re.match('.*%s.*' % (account), to_account, re.I) if matchObj: self.bucket = configParser.get(account, 'BUCKET') self.dir = configParser.get(account, 'DIRECTORY')
def __init__(self, client_id, client_secret, user, application_name): """Initializes an APIHandler. Args: client_id: The client id retrieved from the Cloud Console. client_secret: The client secret retrieved from the Cloud Console. user: The models.AppUser retrieved from the Datastore. application_name: The name of the AppEngine application. """ credentials = GoogleRefreshTokenClient(client_id, client_secret, user.refresh_token) self.user = user self.client = AdManagerClient(credentials, application_name, cache=ZeepServiceProxy.NO_CACHE) self.page_limit = 25 appengine.monkeypatch()
def test_appengine_monkeypatch(): """Tests monkeypatching Requests adapters for AppEngine compatibility. """ adapter = requests.sessions.HTTPAdapter appengine.monkeypatch() assert requests.sessions.HTTPAdapter == appengine.AppEngineAdapter assert requests.adapters.HTTPAdapter == appengine.AppEngineAdapter appengine.monkeypatch(validate_certificate=False) assert requests.sessions.HTTPAdapter == appengine.InsecureAppEngineAdapter assert requests.adapters.HTTPAdapter == appengine.InsecureAppEngineAdapter requests.sessions.HTTPAdapter = adapter requests.adapters.HTTPAdapter = adapter
def test_appengine_monkeypatch(): """Tests monkeypatching Requests adapters for AppEngine compatibility. """ adapter = requests.sessions.HTTPAdapter appengine.monkeypatch() assert requests.sessions.HTTPAdapter == appengine.AppEngineAdapter assert requests.adapters.HTTPAdapter == appengine.AppEngineAdapter appengine.monkeypatch(validate_certificate=False) assert requests.sessions.HTTPAdapter == appengine.InsecureAppEngineAdapter assert requests.adapters.HTTPAdapter == appengine.InsecureAppEngineAdapter requests.sessions.HTTPAdapter = adapter requests.adapters.HTTPAdapter = adapter
def post(self): if asu_constants.SUBSCRIPTION_UNIQUE_TOKEN != self.request.get( 'token'): self.response.status = 404 return try: message = json.loads(urllib.unquote(self.request.body).rstrip('=')) logging.info("MESSAGE") logging.info(message) controller_id = message['message']['attributes']['deviceId'] message_body = base64.b64decode(str(message['message']['data'])) logging.info("MESSAGE BODY") logging.info(message_body) data = json.loads(message_body) logging.info("DATA") logging.info(data) datetime_r = pytz.timezone('America/Phoenix').localize( datetime.datetime.strptime(data['timestamp'].strip(), "%Y-%m-%dT%H:%M:%S.%f")) nonaware_datetime_r = datetime_r.replace( tzinfo=None) - datetime_r.utcoffset() location = data['location'] ph = data['ph'] temperature = data['temperature'] ec = data['ec'] rows_to_insert = [(nonaware_datetime_r, controller_id, location, ph, ec, temperature)] except: self.response.status = 200 logging.info("ERROR") self.response.write('ERROR') from requests_toolbelt.adapters import appengine appengine.monkeypatch() client = bigquery.Client() dummy = client.get_table(asu_constants.TABLE_NAME) client.insert_rows(asu_constants.TABLE_NAME, rows_to_insert, selected_fields=dummy.schema) self.response.status = 200 logging.info('SUCCESS')
def landing(): appengine.monkeypatch() storage_client = storage.Client() bucket = storage_client.get_bucket(BUCKET_NAME) blobs = bucket.list_blobs() photos = [] length_folder_name = len(FOLDER_NAME) for blob in blobs: if blob.name.startswith(FOLDER_NAME): photos.append(blob.name) cached_links = [] for photo in photos[1:]: blob_key = blobstore.create_gs_key("/gs/" + BUCKET_NAME + "/" + FOLDER_NAME + photo[length_folder_name:]) cached_links.append(images.get_serving_url(blob_key, secure_url=True)) return render_template('landing.html', photos=photos, cached_links=cached_links)
def get(self): controller_id = str(self.request.get('controller_id')) from requests_toolbelt.adapters import appengine appengine.monkeypatch() client = bigquery.Client() query_job = client.query( asu_constants.QUERY_EIGHT_WEEKLY.format(controller_id)) results = query_job.result() rows = list(results) dict_data = [] for i in range(len(rows)): dict_data.append({ 'controller_id': rows[i][0], 'hour_number': rows[i][1], 'Average_ph': rows[i][2], 'Average_ec': rows[i][3], 'Average_temp': rows[i][4] }) json_data = json.dumps(dict_data, cls=MyEncoder1) self.response.headers.add_header("Access-Control-Allow-Origin", "*") self.response.headers[ 'Content-Type'] = 'application/json; charset=utf-8' self.response.out.write(json_data)
# -*- coding: utf-8 -*- import bot import requests from datastore import config from requests_toolbelt.adapters import appengine # Use AppEngineAdapter to support GAE with requests appengine.monkeypatch() app = bot.create_app(config) if __name__ == '__main__': app.run()
# Load packages from virtualenv # https://cloud.google.com/appengine/docs/python/tools/libraries27#vendoring from google.appengine.ext import vendor vendor.add('local') from granary.appengine_config import * # Make requests and urllib3 play nice with App Engine. # https://github.com/snarfed/bridgy/issues/396 # http://stackoverflow.com/questions/34574740 from requests_toolbelt.adapters import appengine appengine.monkeypatch()
# Disabled for now fixed_ndb.patch_logging(0) # Fix our runaway mapreduces fixed_ndb.fix_rpc_ordering() # Improve jinja2 stacktraces fixed_jinja2.fix_stacktraces() # Fix mapreduce to not require a certain version fixed_mapreduce_util.patch_function() # Make requests work with AppEngine's URLFetch if appengine_manager.is_local_appengine(): appengine_adapter.monkeypatch() def webapp_add_wsgi_middleware(app): # Disable appstats since it may be resulting in NDB OOM issues # from google.appengine.ext.appstats import recording # app = recording.appstats_wsgi_middleware(app) # Clean up per-thread NDB memory "leaks", though don't try to finish all RPCs calls (which includes runaway iterators) app = fixed_ndb.tasklets_toplevel(app) # Should only use this in cases of serialized execution of requests in a multi-threaded processes. # So setdeploy manually, and test from there. Never a live server, as it would be both broken *and* slow. # from hacks import memory_leaks # app = memory_leaks.leak_middleware(app)
from django.http import HttpResponse import json import AuthInfoStore as AuthInfoStore from shareplay_app.models import User # import requests from urlfetch import post import spotipy from requests_toolbelt.adapters import appengine appengine.monkeypatch() ## needed for appengine and requests to behave __CLIENT_ID = AuthInfoStore.CLIENT_ID __CLIENT_SECRET = AuthInfoStore.CLIENT_SECRET __REDIRECT_URI = AuthInfoStore.REDIRECT_URI def pass_off(request_data): auth_code = request_data['auth_code'] firebase_refresh_token = None if 'firebase_refresh_token' in request_data: firebase_refresh_token = request_data['firebase_refresh_token'] response = post("https://accounts.spotify.com/api/token", headers={'content_type': 'application/x-www-form-urlencoded'}, data={'grant_type': 'authorization_code', 'code': auth_code, 'redirect_uri': __REDIRECT_URI, 'client_id': __CLIENT_ID, 'client_secret': __CLIENT_SECRET}) if response.status_code != 200: return HttpResponse(response.text, content_type='application/json', status=response.status_code)
# Disabled for now fixed_ndb.patch_logging(0) # Fix our runaway mapreduces fixed_ndb.fix_rpc_ordering() # Improve jinja2 stacktraces fixed_jinja2.fix_stacktraces() # Fix mapreduce to not require a certain version fixed_mapreduce_util.patch_function() # Make requests work with AppEngine's URLFetch if appengine_manager.is_local_appengine(): appengine_adapter.monkeypatch() def webapp_add_wsgi_middleware(app): # Disable appstats since it may be resulting in NDB OOM issues # from google.appengine.ext.appstats import recording # app = recording.appstats_wsgi_middleware(app) # Clean up per-thread NDB memory "leaks", though don't try to finish all RPCs calls (which includes runaway iterators) app = fixed_ndb.tasklets_toplevel(app) # Should only use this in cases of serialized execution of requests in a multi-threaded processes. # So setdeploy manually, and test from there. Never a live server, as it would be both broken *and* slow. # from hacks import memory_leaks # app = memory_leaks.leak_middleware(app)
# from flask import Flask, request, redirect, g, render_template import base64 # from bottle import route, run, request import spotipy from spotipy import oauth2 import urllib import spotipy.util as util from math import trunc import unicodedata from requests_toolbelt.adapters import appengine import sys #these 3 lines fix most UnicodeDecodeErrors reload(sys) #and UnicodeEncodeErrors due to names like sys.setdefaultencoding("utf-8") #Beyonce with the accent (#BeyonceError) appengine.monkeypatch( ) #this is a patch that allows the python requests library to be used with Google App Engine # app = Flask(__name__) client_id = spotify.CLIENT_ID client_secret = spotify.CLIENT_SECRET # comment jinja_current_dir = jinja2.Environment( #jinja is used for templating loader=jinja2.FileSystemLoader(os.path.dirname(__file__)), extensions=['jinja2.ext.autoescape'], autoescape=True) global_dict = {}
# appengine_config.py from google.appengine.ext import vendor # Add any libraries install in the "lib" folder. vendor.add('lib') from requests_toolbelt.adapters import appengine as requests_toolbelt_appengine requests_toolbelt_appengine.monkeypatch()
# Unless required by applicable law or agreed to in writing, software # 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 app] import logging from flask import Flask from flask import request from flask_cors import CORS import requests from requests_toolbelt.adapters import appengine appengine.monkeypatch(validate_certificate=False) import json import math from google.cloud import bigquery bigquery_client = bigquery.Client('project-shubin') GEOCODING_API_KEY = 'AIzaSyAdaCsSyIFSoyyvIyOQEobu1twZSiQ5K8o' app = Flask(__name__) CORS(app) stations = [] ##Open and read file with open('ga_stations.json', 'r') as stations_file: content = stations_file.read()