yatmesh
548 lines
20 KiB
Python
548 lines
20 KiB
Python
"""
|
|
|
|
AUTHOR:
|
|
|
|
Khushal P Soonderji
|
|
|
|
DATE:
|
|
|
|
Tuesday, 26th Nov., 2024
|
|
|
|
OBJECTIVE:
|
|
|
|
To provide a base class for common behaviour of Google's APIs.
|
|
|
|
REFERENCES:
|
|
|
|
1. Quickstart: https://developers.google.com/gmail/api/quickstart/python
|
|
|
|
DOWNLOADS:
|
|
|
|
N/A
|
|
|
|
"""
|
|
|
|
|
|
# *****************************************************************************************************************
|
|
# ***** ****
|
|
# *** IMPORT ***
|
|
# ***** ****
|
|
# *****************************************************************************************************************
|
|
|
|
|
|
# To make sibling directories accessible for imports:
|
|
import sys
|
|
sys.path.append(".")
|
|
sys.path.append("..")
|
|
|
|
# System-level activities:
|
|
import io
|
|
|
|
# My utils:
|
|
from utils_v2.date_time import date_time
|
|
from utils_v2.goog.models.api_call import GoogleApiResponse
|
|
from utils_v2.goog.models.auth_tokens import GoogleAuthTokens
|
|
|
|
# Related to Google:
|
|
from google_auth_oauthlib.flow import InstalledAppFlow
|
|
|
|
# To make API calls:
|
|
import httpx
|
|
|
|
# To work with date and time:
|
|
import datetime
|
|
|
|
# For working with datatypes:
|
|
from typing import Literal, List
|
|
|
|
# For debugging:
|
|
from icecream import IceCreamDebugger
|
|
import inspect
|
|
|
|
|
|
# *****************************************************************************************************************
|
|
# ***** ****
|
|
# *** MACROS / ONE-TIME INIT ***
|
|
# ***** ****
|
|
# *****************************************************************************************************************
|
|
|
|
|
|
# --- Nothing Yet
|
|
|
|
|
|
# *****************************************************************************************************************
|
|
# ***** ****
|
|
# *** VARIABLES ***
|
|
# ***** ****
|
|
# *****************************************************************************************************************
|
|
|
|
|
|
# --- Nothing Yet
|
|
|
|
|
|
# *****************************************************************************************************************
|
|
# ***** ****
|
|
# *** FUNCTIONS ***
|
|
# ***** ****
|
|
# *****************************************************************************************************************
|
|
|
|
|
|
# --- Nothing Yet
|
|
|
|
|
|
# *****************************************************************************************************************
|
|
# ***** ****
|
|
# *** CLASSES ***
|
|
# ***** ****
|
|
# *****************************************************************************************************************
|
|
|
|
|
|
class AsyncGoogleBase:
|
|
|
|
def __init__(
|
|
self,
|
|
service_name: str,
|
|
oauth_json: dict,
|
|
http_client: httpx.AsyncClient,
|
|
redirect_url: str = None,
|
|
debug = True,
|
|
debug_prefix = "Google | ",
|
|
debug_only_errors = True
|
|
):
|
|
|
|
"""
|
|
To initialize any Google API from one base class. The client's id and secret are available in the file
|
|
downloaded form https://console.cloud.google.com/apis/credentials (do not forget to select your app).
|
|
:param service_name: A string to identify this service.
|
|
:param oauth_json: The OAuth credentials downloaded from https://console.cloud.google.com/apis/credentials
|
|
:param http_client: An asynchronous HTTP client to make API calls.
|
|
:param redirect_url: Where you would like to receive the confirmation of the user authorization.
|
|
:param debug: Whether, or not, you would like to show debugging messages on the terminal.
|
|
:param debug_prefix: The prefix string to identify the debugging messages.
|
|
:param debug_only_errors: Whether you would like to show all debugging messages or just error messages.
|
|
"""
|
|
|
|
# Prepare the debugging utility:
|
|
self._debug_prefix = debug_prefix
|
|
self._printer = IceCreamDebugger(prefix = debug_prefix, includeContext = True)
|
|
if not debug: self._printer.disable()
|
|
self._debug_only_errors = debug_only_errors
|
|
|
|
# Accept the input configuration:
|
|
self._service_name = service_name
|
|
self._http_client = http_client
|
|
self._oauth_json = oauth_json
|
|
self._client_id = self._oauth_json["web"]["client_id"]
|
|
self._client_secret = self._oauth_json["web"]["client_secret"]
|
|
self._redirect_url = redirect_url
|
|
|
|
def enable_debug(self):
|
|
self._printer.enable()
|
|
|
|
def disable_debug(self):
|
|
self._printer.disable()
|
|
|
|
def debug_only_errors(self):
|
|
self._debug_only_errors = True
|
|
|
|
def debug_everything(self):
|
|
self._debug_only_errors = False
|
|
|
|
# ┏┓ •
|
|
# ┃┃┏┓┏┓┏┓┏┓┏┓╋┓┏┓┏
|
|
# ┣┛┛ ┗┛┣┛┗ ┛ ┗┗┗ ┛
|
|
# ┛
|
|
|
|
@property
|
|
def client_id(self):
|
|
return self._client_id
|
|
|
|
@property
|
|
def client_secret(self):
|
|
return self._client_secret
|
|
|
|
@property
|
|
def http_client(self):
|
|
return self._http_client
|
|
|
|
# ┏┓┏┓ ┓ ┏┓ ┏┓
|
|
# ┃┃┣┫┓┏╋┣┓ ┏┛ ┃┫
|
|
# ┗┛┛┗┗┻┗┛┗ ┗━•┗┛
|
|
|
|
async def get_authorization_url(
|
|
self,
|
|
scopes: List[str],
|
|
state: str = None,
|
|
access_type: Literal["online", "offline"] = "offline",
|
|
approval_prompt: Literal["auto", "force", "consent"] = "auto",
|
|
include_granted_scopes: Literal["true", "false"] = "true",
|
|
user_email: str = None
|
|
) -> str:
|
|
|
|
"""
|
|
TO get the OAuth2.0 authorization URL for one user.
|
|
DOCUMENTATION:
|
|
1. https://developers.google.com/identity/protocols/oauth2/web-server
|
|
:param scopes: The set of permission you want the user to give.
|
|
:param state: A unique identifier for your user. If not supplied, a random string will be generated.
|
|
:param access_type: Set the value to offline if your application needs to refresh access tokens when the user is
|
|
not present at the browser.
|
|
:param approval_prompt: "force" ensures that the consent screen is always shown to the user, regardless of
|
|
whether the user has previously granted consent for the requested scopes. It forces the user to re-approve
|
|
the app's access, which can be useful if the app is requesting new permissions or if the consent needs to be
|
|
explicitly confirmed. "consent" ensures the user's consent is required if they haven't approved the app's
|
|
requested permissions yet. "auto" allows Google to automatically determine whether the consent screen should
|
|
be shown.
|
|
:param include_granted_scopes: Enables applications to use incremental authorization to request access to
|
|
additional scopes in context. If you set this parameter's value to true and the authorization request is
|
|
granted, then the new access token will also cover any scopes to which the user previously granted the
|
|
application access.
|
|
:param user_email:
|
|
:return:
|
|
"""
|
|
|
|
# Create a flow:
|
|
flow = InstalledAppFlow.from_client_config(
|
|
self._oauth_json,
|
|
scopes = scopes,
|
|
redirect_uri = self._redirect_url
|
|
)
|
|
|
|
# Get an authorization URL:
|
|
auth_url, state = flow.authorization_url(
|
|
access_type = access_type,
|
|
approval_prompt = approval_prompt,
|
|
include_granted_scopes = include_granted_scopes,
|
|
login_hint = user_email,
|
|
state = state
|
|
)
|
|
|
|
# Done here:
|
|
return auth_url
|
|
|
|
async def get_authorization_tokens(
|
|
self,
|
|
scopes: List[str] | None,
|
|
redirect_url: str
|
|
) -> GoogleAuthTokens:
|
|
|
|
"""
|
|
When the user accepts or declines an authorization request, Google sends you an alert on your redirect URL. Pass
|
|
the URL as it is to this method to generate the authorization tokens that you can store in the database and
|
|
reuse for this user's activities.
|
|
:param scopes: The set of permissions the user granted.
|
|
:param redirect_url: The exact URL that was hit (with the query params) that Google hit when the user did
|
|
something on your authorization URL. Fortunately, this URL is readily available in Quart and Flask by
|
|
calling 'request.url'.
|
|
:return: The authorization tokens.
|
|
"""
|
|
|
|
# Create a flow:
|
|
flow = InstalledAppFlow.from_client_config(
|
|
self._oauth_json,
|
|
scopes = scopes,
|
|
redirect_uri = self._redirect_url
|
|
)
|
|
|
|
# Get the credentials:
|
|
credentials = flow.fetch_token(authorization_response = redirect_url)
|
|
ttl = credentials["expires_in"] - 60
|
|
tokens = GoogleAuthTokens(
|
|
accessToken = credentials["access_token"],
|
|
refreshToken = credentials["refresh_token"],
|
|
expiresAt = date_time.get_current_utc_date_time() + datetime.timedelta(seconds = ttl),
|
|
scopes = credentials["scope"]
|
|
)
|
|
|
|
# Fetch the user's info:
|
|
if not self._debug_only_errors: self._printer("Getting User Profile.")
|
|
api_response = await self.get(
|
|
url = f"https://openidconnect.googleapis.com/v1/userinfo",
|
|
headers = {"Authorization": f"Bearer {tokens.accessToken}"}
|
|
)
|
|
if api_response.httpCode in [200]:
|
|
api_response_json = await api_response.get_json()
|
|
tokens.displayName = api_response_json.get("name")
|
|
tokens.displayPictureUrl = api_response_json.get("picture")
|
|
|
|
# Done here:
|
|
return tokens
|
|
|
|
# ┏┓ ┳┓ ┓•
|
|
# ┣ ┏┓┏┓┏┓┏┓ ┃┃┏┓┏┏┓┏┫┓┏┓┏┓
|
|
# ┗┛┛ ┛ ┗┛┛ ┻┛┗ ┗┗┛┗┻┗┛┗┗┫
|
|
# ┛
|
|
|
|
@staticmethod
|
|
async def __get_error_message(api_response: GoogleApiResponse) -> str:
|
|
|
|
"""
|
|
To extract various kinds of error messages from Google's responses.
|
|
:param api_response: The formatted response from the API call.
|
|
:return: The message string.
|
|
"""
|
|
|
|
try: return (await api_response.get_json())["error"]["message"]
|
|
except: return api_response.response.reason_phrase
|
|
|
|
# ┏┓┏┓┳ ┏┓ ┓┓•
|
|
# ┣┫┃┃┃ ┃ ┏┓┃┃┓┏┓┏┓
|
|
# ┛┗┣┛┻ ┗┛┗┻┗┗┗┛┗┗┫
|
|
# ┛
|
|
|
|
async def get(
|
|
self,
|
|
url: str,
|
|
headers: dict = None,
|
|
params: dict = None
|
|
) -> GoogleApiResponse:
|
|
|
|
"""
|
|
To call an API using the GET method.
|
|
:param url: The URL to call.
|
|
:param headers: The headers to pass.
|
|
:param params: The params to send in the query string itself.
|
|
:return: A structured response that includes the raw response, the exception (if any), and so on.
|
|
"""
|
|
|
|
# Prepare the structure of the response:
|
|
api_response = GoogleApiResponse(
|
|
serviceName = self._service_name,
|
|
action = inspect.stack()[1].function,
|
|
url = url,
|
|
method = "GET"
|
|
)
|
|
|
|
try:
|
|
|
|
# Make the API call:
|
|
response = await self._http_client.get(
|
|
url = url,
|
|
headers = headers,
|
|
params = params
|
|
)
|
|
|
|
# Note down the results:
|
|
api_response.response = response
|
|
api_response.httpCode = response.status_code
|
|
api_response.message = await self.__get_error_message(api_response)
|
|
|
|
# If something goes wrong:
|
|
except Exception as exception:
|
|
api_response.exception = exception
|
|
api_response.message = str(exception)
|
|
self._printer(exception, api_response.url, api_response.method, headers, params)
|
|
|
|
# Done here:
|
|
return api_response
|
|
|
|
async def post(
|
|
self,
|
|
url: str,
|
|
headers: dict = None,
|
|
json: dict = None,
|
|
data: dict = None,
|
|
content: str | bytes = None
|
|
) -> GoogleApiResponse:
|
|
|
|
"""
|
|
To call an API using the POST method.
|
|
:param url: The URL to call.
|
|
:param headers: The headers to pass.
|
|
:param json: The params to send in the JSON body.
|
|
:param data: The params to send in the form-data in the body.
|
|
:param content: The raw content to be sent in the body (typically as an octet-stream).
|
|
:return: A structured response that includes the raw response, the exception (if any), and so on.
|
|
"""
|
|
|
|
# Prepare the structure of the response:
|
|
api_response = GoogleApiResponse(
|
|
serviceName = self._service_name,
|
|
action = inspect.stack()[1].function,
|
|
url = url,
|
|
method = "POST"
|
|
)
|
|
|
|
try:
|
|
|
|
# Make the API call:
|
|
response = await self._http_client.post(
|
|
url = url,
|
|
headers = headers,
|
|
json = json,
|
|
data = data,
|
|
content = content
|
|
)
|
|
|
|
# Note down the results:
|
|
api_response.response = response
|
|
api_response.httpCode = response.status_code
|
|
api_response.message = await self.__get_error_message(api_response)
|
|
|
|
# If something goes wrong:
|
|
except Exception as exception:
|
|
api_response.exception = exception
|
|
api_response.message = str(exception)
|
|
self._printer(exception, api_response.url, api_response.method, headers, json, data)
|
|
|
|
# Done here:
|
|
return api_response
|
|
|
|
async def put(
|
|
self,
|
|
url: str,
|
|
headers: dict = None,
|
|
json: dict = None,
|
|
data: dict = None
|
|
) -> GoogleApiResponse:
|
|
|
|
"""
|
|
To call an API using the PUT method.
|
|
:param url: The URL to call.
|
|
:param headers: The headers to pass.
|
|
:param json: The params to send in the JSON body.
|
|
:param data: The params to send in the form-data in the body.
|
|
:return: A structured response that includes the raw response, the exception (if any), and so on.
|
|
"""
|
|
|
|
# Prepare the structure of the response:
|
|
api_response = GoogleApiResponse(
|
|
serviceName = self._service_name,
|
|
action = inspect.stack()[1].function,
|
|
url = url,
|
|
method = "PUT"
|
|
)
|
|
|
|
try:
|
|
|
|
# Make the API call:
|
|
response = await self._http_client.put(
|
|
url = url,
|
|
headers = headers,
|
|
json = json,
|
|
data = data
|
|
)
|
|
|
|
# Note down the results:
|
|
api_response.response = response
|
|
api_response.httpCode = response.status_code
|
|
api_response.message = await self.__get_error_message(api_response)
|
|
|
|
# If something goes wrong:
|
|
except Exception as exception:
|
|
api_response.exception = exception
|
|
api_response.message = str(exception)
|
|
self._printer(exception, api_response.url, api_response.method, headers, json, data)
|
|
|
|
# Done here:
|
|
return api_response
|
|
|
|
async def delete(
|
|
self,
|
|
url: str,
|
|
headers: dict = None
|
|
) -> GoogleApiResponse:
|
|
|
|
"""
|
|
To call an API using the DELETE method.
|
|
:param url: The URL to call.
|
|
:param headers: The headers to pass.
|
|
:return: A structured response that includes the raw response, the exception (if any), and so on.
|
|
"""
|
|
|
|
# Prepare the structure of the response:
|
|
api_response = GoogleApiResponse(
|
|
serviceName = self._service_name,
|
|
action = inspect.stack()[1].function,
|
|
url = url,
|
|
method = "DELETE"
|
|
)
|
|
|
|
try:
|
|
|
|
# Make the API call:
|
|
response = await self._http_client.delete(
|
|
url = url,
|
|
headers = headers
|
|
)
|
|
|
|
# Note down the results:
|
|
api_response.response = response
|
|
api_response.httpCode = response.status_code
|
|
api_response.message = await self.__get_error_message(api_response)
|
|
|
|
# If something goes wrong:
|
|
except Exception as exception:
|
|
api_response.exception = exception
|
|
api_response.message = str(exception)
|
|
self._printer(exception, api_response.url, api_response.method, headers)
|
|
|
|
# Done here:
|
|
return api_response
|
|
|
|
|
|
# *****************************************************************************************************************
|
|
# ***** ****
|
|
# *** MAIN PROGRAM ***
|
|
# ***** ****
|
|
# *****************************************************************************************************************
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
from utils_v2.string import json
|
|
import asyncio
|
|
|
|
# Create an HTTP client:
|
|
test_client = httpx.AsyncClient(
|
|
limits = httpx.Limits(
|
|
max_connections = 100, # ............ Maximum number of connections allowed in the pool.
|
|
max_keepalive_connections = 50, # ... Maximum number of connections that can be kept alive.
|
|
),
|
|
timeout = httpx.Timeout(
|
|
connect = 2.5, # ... Shorter connection timeout.
|
|
read = 2.5, # ...... Like what EasyEcom gives.
|
|
write = 10.0, # .... Time to wait for sending data.
|
|
pool = 120.0 # ..... Time to wait for a free connection from the pool.
|
|
)
|
|
)
|
|
|
|
# Define some scopes that the app will use:
|
|
TEST_SCOPES = [
|
|
"https://www.googleapis.com/auth/cloud-platform",
|
|
"https://www.googleapis.com/auth/userinfo.profile"
|
|
]
|
|
|
|
# Read the secrets that give you access to the app:
|
|
secrets_file = r"C:\Users\Khushal P Soonderji\Downloads\google_places_test_secret.json"
|
|
secrets_dict = json.from_file(secrets_file)
|
|
|
|
async def main():
|
|
|
|
# Create an instance of the client:
|
|
my_google = AsyncGoogleBase(
|
|
service_name = "Goog",
|
|
oauth_json = secrets_dict,
|
|
http_client = test_client,
|
|
redirect_url = r"https://wtt.ditscentre.in/shopify/test/1",
|
|
debug = True,
|
|
debug_prefix = "Goog (C) | ",
|
|
debug_only_errors = False
|
|
)
|
|
|
|
# Request Auth:
|
|
print("AUTH URL:", await my_google.get_authorization_url(
|
|
scopes = TEST_SCOPES,
|
|
state = "Bhopli",
|
|
approval_prompt = "force"
|
|
))
|
|
|
|
# Get tokens from callback:
|
|
test_tokens = await my_google.get_authorization_tokens(
|
|
scopes = TEST_SCOPES,
|
|
redirect_url = input("Paste the redirect URL here: ")
|
|
)
|
|
print("TOKENS:", json.to_string(test_tokens.model_dump(), default = str))
|
|
|
|
asyncio.run(main())
|