`.
+ """
+
+ def __init__(self, db, user_model, role_model, webauthn_model=None):
+ PonyDatastore.__init__(self, db)
+ UserDatastore.__init__(self, user_model, role_model, webauthn_model)
+
+ @with_pony_session
+ def find_user(self, case_insensitive=False, **kwargs):
+ if case_insensitive:
+ # While it is of course possible to pass in multiple keys to filter on
+ # that isn't the normal use case. If caller asks for case_insensitive
+ # AND gives multiple keys - throw an error.
+ if len(kwargs) > 1:
+ raise ValueError("Case insensitive option only supports single key")
+ # TODO - implement case insensitive look ups.
+
+ return self.user_model.get(**kwargs)
+
+ @with_pony_session
+ def find_role(self, role):
+ return self.role_model.get(name=role)
+
+ @with_pony_session
+ def add_role_to_user(self, *args, **kwargs):
+ return super().add_role_to_user(*args, **kwargs)
+
+ @with_pony_session
+ def create_user(self, **kwargs):
+ return super().create_user(**kwargs)
+
+ @with_pony_session
+ def create_role(self, **kwargs):
+ return super().create_role(**kwargs)
+
+
+if t.TYPE_CHECKING: # pragma: no cover
+ # Normally - the application creates the Models and glues them together
+ # For typing we do that here since we don't know which DB interface they
+ # will pick.
+ from .core import UserMixin, RoleMixin, WebAuthnMixin
+
+ class CanonicalUserDatastore(Datastore, UserDatastore):
+ pass
+
+ class User(UserMixin):
+ id: int
+ email: str
+ username: str | None
+ password: str | None
+ active: bool
+ fs_uniquifier: str
+ fs_token_uniquifier: str
+ fs_webauthn_user_handle: str
+ confirmed_at: datetime | None
+ last_login_at: datetime
+ current_login_at: datetime
+ last_login_ip: str | None
+ current_login_ip: str | None
+ login_count: int
+ tf_primary_method: str | None
+ tf_totp_secret: str | None
+ tf_phone_number: str | None
+ mf_recovery_codes: list[str] | None
+ us_phone_number: str | None
+ us_totp_secrets: str | bytes | None
+ create_datetime: datetime
+ update_datetime: datetime
+ roles: list[Role]
+ webauthn: list[WebAuthn]
+
+ def __init__(self, **kwargs): ...
+
+ class Role(RoleMixin):
+ id: int
+ name: str
+ description: str | None
+ permissions: list[str] | None
+ update_datetime: datetime
+
+ def __init__(self, **kwargs): ...
+
+ class WebAuthn(WebAuthnMixin):
+ id: int
+ name: str
+ credential_id: bytes
+ public_key: bytes
+ sign_count: int
+ transports: list[str] | None
+ backup_state: bool
+ device_type: str
+ extensions: str | None
+ lastuse_datetime: datetime
+ user_id: int
+ usage: str
+
+ def __init__(self, **kwargs): ...
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/decorators.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/decorators.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8dd0298638973292e574cd7c45dafc6ca00c42a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/decorators.py
@@ -0,0 +1,647 @@
+"""
+ flask_security.decorators
+ ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security decorators module
+
+ :copyright: (c) 2012-2019 by Matt Wright.
+ :copyright: (c) 2019-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+from collections import namedtuple
+import datetime
+from functools import wraps
+import typing as t
+
+from flask import Response, abort, current_app, g, redirect, request
+from flask_login import current_user, login_required # noqa: F401
+from flask_principal import Identity, Permission, RoleNeed, identity_changed
+from flask_wtf.csrf import CSRFError
+from werkzeug.local import LocalProxy
+
+from .proxies import _security, DecoratedView
+from .signals import user_unauthenticated
+from .utils import (
+ FsPermNeed,
+ config_value as cv,
+ do_flash,
+ get_message,
+ get_url,
+ is_user_authenticated,
+ lookup_identity,
+ check_and_update_authn_fresh,
+ json_error_response,
+ set_request_attr,
+ simplify_url,
+ get_request_attr,
+ url_for_security,
+)
+
+if t.TYPE_CHECKING: # pragma: no cover
+ from flask.typing import ResponseValue
+
+# Convenient references
+_csrf = LocalProxy(lambda: current_app.extensions["csrf"])
+
+BasicAuth = namedtuple("BasicAuth", "username, password")
+
+# NOTE: this is here for backwards compatibility, it is deprecated and
+# could be removed any time!
+_default_unauthenticated_html = """
+ Unauthorized
+ The server could not verify that you are authorized to access the URL
+ requested. You either supplied the wrong credentials (e.g. a bad password),
+ or your browser doesn't understand how to supply the credentials required.
+
+ """
+
+
+def _get_unauthenticated_response(text=None, headers=None):
+ text = text or _default_unauthenticated_html
+ headers = headers or {}
+ return Response(text, 401, headers)
+
+
+def default_unauthn_handler(mechanisms=None, headers=None):
+ """Default callback for failures to authenticate
+
+ If caller wants JSON - return 401.
+ If caller wants BasicAuth - return 401 (the WWW-Authenticate header is set).
+ Otherwise - assume caller is html and redirect if possible to a login view.
+ """
+ user_unauthenticated.send(
+ current_app._get_current_object(), # type: ignore[attr-defined]
+ _async_wrapper=current_app.ensure_sync,
+ )
+ headers = headers or {}
+ m, c = get_message("UNAUTHENTICATED")
+
+ if cv("BACKWARDS_COMPAT_UNAUTHN"):
+ return _get_unauthenticated_response(headers=headers)
+ if _security._want_json(request):
+ payload = json_error_response(errors=m)
+ return _security._render_json(payload, 401, headers, None)
+
+ # Basic-Auth is often used to provide a browser based login form and then the
+ # browser will always add the BasicAuth credentials. For that to work we need to
+ # return 401 and not redirect to our login view.
+ if "WWW-Authenticate" in headers:
+ return Response(m, 401, headers)
+
+ do_flash(m, c)
+ # Simplify the original URL to be relative (if possible) and set as 'next' parameter
+ login_url = url_for_security("login", _external=True)
+ next_url = simplify_url(login_url, request.url)
+ redirect_url = url_for_security("login", next=next_url)
+ return redirect(redirect_url)
+
+
+def default_reauthn_handler(within, grace):
+ """Default callback for 'freshness' related authn failures.
+
+ If caller wants JSON - return 401
+ Otherwise - assume caller is html and redirect if possible to configured view.
+
+ """
+ m, c = get_message("REAUTHENTICATION_REQUIRED")
+
+ if _security._want_json(request):
+ from .webauthn import has_webauthn
+
+ is_us = cv("UNIFIED_SIGNIN")
+ payload = json_error_response(errors=m)
+ payload["reauth_required"] = True
+ payload["unified_signin_enabled"] = is_us
+ payload["has_webauthn_verify_credential"] = has_webauthn(
+ current_user, cv("WAN_ALLOW_AS_VERIFY")
+ )
+ return _security._render_json(payload, 401, None, None)
+
+ view = "us_verify" if cv("UNIFIED_SIGNIN") else "verify"
+ do_flash(m, c)
+ # Simplify the original URL to be relative (if possible) and set as 'next' parameter
+ view_url = url_for_security(view, _external=True)
+ next_url = simplify_url(view_url, request.url)
+ redirect_url = url_for_security(view, next=next_url)
+ return redirect(redirect_url)
+
+
+def default_unauthz_handler(func_name, params):
+ unauthz_message, unauthz_message_type = get_message("UNAUTHORIZED")
+ if _security._want_json(request):
+ payload = json_error_response(errors=unauthz_message)
+ return _security._render_json(payload, 403, None, None)
+ if view := cv("UNAUTHORIZED_VIEW"):
+ if callable(view):
+ if not (redirect_to := view()):
+ abort(403)
+ else:
+ redirect_to = get_url(view)
+ do_flash(unauthz_message, unauthz_message_type)
+ return redirect(redirect_to)
+ abort(403)
+
+
+def _check_token():
+ user = _security.login_manager.request_callback(request)
+ if is_user_authenticated(user):
+ identity_changed.send(
+ current_app._get_current_object(),
+ _async_wrapper=current_app.ensure_sync,
+ identity=Identity(user.fs_uniquifier),
+ )
+ return True
+
+ return False
+
+
+def _check_session():
+ """
+ Note that flask_login will have already run _load_user (due to someone referencing
+ current_user proxy). This will have called our _user_loader or _request_loader
+ already.
+ This method needs to determine whether the authenticated user was authenticated
+ due to _user_loader or _request_loader and return True for the former.
+ This routine makes sure that if an endpoint is decorated with just allowing
+ 'session' that token authentication won't return True (even though the user
+ is in fact correctly authenticated). There are certainly endpoints that need to
+ be web browser/session only (often those that in fact return tokens!).
+ """
+ if not is_user_authenticated(current_user):
+ return False
+ if get_request_attr("fs_authn_via") != "session":
+ return False
+ return True
+
+
+def _check_http_auth():
+ auth = request.authorization or BasicAuth(username=None, password=None)
+ if not auth.username:
+ return False
+ user = lookup_identity(auth.username)
+ if user and not user.active:
+ return False
+
+ if user and user.verify_and_update_password(auth.password):
+ _security.datastore.commit()
+ _security.login_manager._update_request_context_with_user(user)
+ identity_changed.send(
+ current_app._get_current_object(),
+ _async_wrapper=current_app.ensure_sync,
+ identity=Identity(user.fs_uniquifier),
+ )
+ return True
+
+ return False
+
+
+def handle_csrf(method: str, json_response: bool = False) -> ResponseValue | None:
+ """Invoke CSRF protection based on authentication method.
+
+ Usually this is called as part of a decorator, but if that isn't
+ appropriate, endpoint code can call this directly.
+
+ If CSRF protection is appropriate, this will call flask_wtf::protect() which
+ will raise a CSRFError(BadRequest) on CSRF failure.
+
+ This routine does nothing if any of these are true:
+
+ #) *WTF_CSRF_ENABLED* is set to False
+
+ #) the Flask-WTF CSRF module hasn't been initialized
+
+ #) csrfProtect already checked and accepted the token
+
+ This means in the default config - CSRF is done as part of form validation
+ not here. Only if the application calls CSRFProtect(app) will this method
+ do anything. Furthermore - since this is called PRIOR to form instantiation
+ if the request is JSON - it MUST send the csrf_token as a header.
+
+ If the passed in method is not in
+ :py:data:`SECURITY_CSRF_PROTECT_MECHANISMS` then in addition to
+ no CSRF code being run, the flask_wtf request global 'csrf_valid' will be set
+ so that downstream code knows to ignore any CSRF checks.
+
+ Returns None if all ok, returns a Response with JSON error if request
+ wanted JSON - else re-raises the CSRFError exception.
+
+ .. versionadded:: 3.3.0
+
+ .. versionchanged:: 5.4.3
+ Use flask_wtf request global 'csrf_valid' instead of our own to handle
+ application forms that aren't derived from our forms.
+ """
+ if (
+ not current_app.config.get("WTF_CSRF_ENABLED", False)
+ or not current_app.extensions.get("csrf", None)
+ or g.get("csrf_valid", False)
+ ):
+ return None
+
+ if cv("CSRF_PROTECT_MECHANISMS"):
+ if method in cv("CSRF_PROTECT_MECHANISMS"):
+ try:
+ _csrf.protect() # type: ignore
+ except CSRFError as e:
+ if json_response:
+ payload = json_error_response(errors=e.description)
+ return _security._render_json(payload, 400, None, None)
+ raise
+ return None
+ set_request_attr("csrf_valid", True) # flask_wtf global
+ return None
+
+
+def http_auth_required(realm: t.Any) -> DecoratedView:
+ """Decorator that protects endpoints using Basic HTTP authentication.
+
+ :param realm: optional realm name
+
+ If authentication fails, then a 401 with the 'WWW-Authenticate' header set will be
+ returned.
+
+ Once authenticated, if so configured, CSRF protection will be tested.
+ """
+
+ def decorator(fn):
+ @wraps(fn)
+ def wrapper(*args, **kwargs):
+ if _check_http_auth():
+ eresponse = handle_csrf("basic", _security._want_json(request))
+ if eresponse:
+ return eresponse
+ set_request_attr("fs_authn_via", "basic")
+ return current_app.ensure_sync(fn)(*args, **kwargs)
+ r = cv("DEFAULT_HTTP_AUTH_REALM") if callable(realm) else realm
+ h = {"WWW-Authenticate": f'Basic realm="{r}"'}
+ return _security._unauthn_handler(["basic"], headers=h)
+
+ return wrapper
+
+ if callable(realm):
+ return decorator(realm)
+ return decorator
+
+
+def auth_token_required(fn: DecoratedView) -> DecoratedView:
+ """Decorator that protects endpoints using token authentication. The token
+ should be added to the request by the client by using a query string
+ variable with a name equal to the configuration value of
+ :py:data:`SECURITY_TOKEN_AUTHENTICATION_KEY` or in a request header named that of
+ the configuration value of :py:data:`SECURITY_TOKEN_AUTHENTICATION_HEADER`
+
+ Once authenticated, if so configured, CSRF protection will be tested.
+ """
+
+ @wraps(fn)
+ def decorated(*args, **kwargs):
+ if _check_token():
+ eresponse = handle_csrf("token", _security._want_json(request))
+ if eresponse:
+ return eresponse
+ set_request_attr("fs_authn_via", "token")
+ return current_app.ensure_sync(fn)(*args, **kwargs)
+ return _security._unauthn_handler(["token"])
+
+ return t.cast(DecoratedView, decorated)
+
+
+def auth_required(
+ *auth_methods: str | t.Callable[[], list[str]] | None,
+ within: int | float | t.Callable[[], datetime.timedelta] = -1,
+ grace: int | float | t.Callable[[], datetime.timedelta] | None = None,
+) -> DecoratedView:
+ """
+ Decorator that protects endpoints through multiple mechanisms.
+ Example::
+
+ @app.route('/dashboard')
+ @auth_required('token', 'session')
+ def dashboard():
+ return 'Dashboard'
+
+ :param auth_methods: Specified mechanisms (token, basic, session). If not specified
+ then all current available mechanisms (except "basic") will be tried. A callable
+ can also be passed (useful if you need app/request context). The callable
+ must return a list.
+ :param within: Add 'freshness' check to authentication. Is either an int
+ specifying # of minutes, or a callable that returns a timedelta. For timedeltas,
+ timedelta.total_seconds() is used for the calculations:
+
+ - If > 0, then the caller must have authenticated within the time specified
+ (as measured using the session cookie).
+ - If 0 and not within the grace period (see below) the caller will
+ always be redirected to re-authenticate.
+ - If < 0 (the default) no freshness check is performed.
+
+ Note that Basic Auth, by definition, is always 'fresh' and will never result in
+ a redirect/error.
+ :param grace: Add a grace period for freshness checks. As above, either an int
+ or a callable returning a timedelta. If not specified then
+ :py:data:`SECURITY_FRESHNESS_GRACE_PERIOD` is used. The grace period allows
+ callers to complete the required operations w/o being prompted again.
+ See :meth:`flask_security.check_and_update_authn_fresh` for details.
+
+ Note that regardless of order specified - they will be tried in the following
+ order: token, session, basic.
+
+ The first mechanism that succeeds is used, following that, depending on
+ configuration, CSRF protection will be tested.
+
+ On authentication failure :meth:`.Security.unauthn_handler` will be called.
+
+ As a side effect, upon successful authentication, the request global
+ ``fs_authn_via`` will be set to the method ("basic", "token", "session")
+
+ .. note::
+ If "basic" is specified in addition to other methods, then if authentication
+ fails, a 401 with the "WWW-Authenticate" header will be returned - rather than
+ being redirected to the login view.
+
+ .. versionchanged:: 3.3.0
+ If ``auth_methods`` isn't specified, then all will be tried. Authentication
+ mechanisms will always be tried in order of ``token``, ``session``, ``basic``
+ regardless of how they are specified in the ``auth_methods`` parameter.
+
+ .. versionchanged:: 3.4.0
+ Added ``within`` and ``grace`` parameters to enforce a freshness check.
+
+ .. versionchanged:: 3.4.4
+ If ``auth_methods`` isn't specified try all mechanisms EXCEPT ``basic``.
+
+ .. versionchanged:: 4.0.0
+ auth_methods can be passed as a callable.
+
+ """
+
+ login_mechanisms = {
+ "token": lambda: _check_token(),
+ "session": lambda: _check_session(),
+ "basic": lambda: _check_http_auth(),
+ }
+ mechanisms_order = ["token", "session", "basic"]
+
+ def wrapper(fn):
+ @wraps(fn)
+ def decorated_view(
+ *args, auth_methods=auth_methods, within=within, grace=grace, **kwargs
+ ):
+ if callable(within):
+ within = within()
+ else:
+ within = datetime.timedelta(minutes=within)
+ if grace is None:
+ grace = cv("FRESHNESS_GRACE_PERIOD")
+ elif callable(grace):
+ grace = grace()
+ else:
+ grace = datetime.timedelta(minutes=grace)
+
+ if not auth_methods:
+ ams = {"session", "token"}
+ else:
+ ams = []
+ for am in auth_methods:
+ if callable(am):
+ ams.extend(am())
+ else:
+ ams.append(am)
+
+ h = {}
+ if "basic" in ams:
+ r = cv("DEFAULT_HTTP_AUTH_REALM")
+ h["WWW-Authenticate"] = f'Basic realm="{r}"'
+ mechanisms = [
+ (method, login_mechanisms.get(method))
+ for method in mechanisms_order
+ if method in ams
+ ]
+ for method, mechanism in mechanisms:
+ if mechanism and mechanism():
+ # successfully authenticated. Basic auth is by definition 'fresh'.
+ # Note that using token auth is ok - but caller still has to pass
+ # in a session cookie if freshness checking is required.
+ if not check_and_update_authn_fresh(within, grace, method):
+ return _security._reauthn_handler(within, grace)
+ if eresponse := handle_csrf(method, _security._want_json(request)):
+ return eresponse
+ set_request_attr("fs_authn_via", method)
+ return current_app.ensure_sync(fn)(*args, **kwargs)
+ return _security._unauthn_handler(ams, headers=h)
+
+ return decorated_view
+
+ return wrapper
+
+
+def unauth_csrf(
+ fall_through: bool = False,
+) -> DecoratedView:
+ """Decorator for endpoints that don't need authentication
+ but do want CSRF checks (available via Header rather than just form).
+ This is required when setting *WTF_CSRF_CHECK_DEFAULT* = **False** since in that
+ case, without this decorator, the form validation will attempt to do the CSRF
+ check, and that will fail since the csrf-token is in the header (for pure JSON
+ requests).
+
+ This decorator does nothing unless Flask-WTF::CSRFProtect has been initialized.
+
+ This decorator does nothing if *WTF_CSRF_ENABLED* == **False**.
+
+ This decorator does nothing if the caller is authenticated.
+
+ This decorator will suppress CSRF if caller isn't authenticated and has set the
+ :py:data:`SECURITY_CSRF_IGNORE_UNAUTH_ENDPOINTS` config variable to **True**.
+
+ .. versionadded:: 3.3.0
+
+ .. versionchanged:: 5.4.3
+ The fall_through parameter is now ignored.
+ Add code to properly handle JSON errors.
+ """
+
+ def wrapper(fn):
+ @wraps(fn)
+ def decorated(*args, **kwargs):
+ if (
+ not current_app.config.get("WTF_CSRF_ENABLED", False)
+ or not current_app.extensions.get("csrf", None)
+ or g.get("csrf_valid", False)
+ ):
+ return current_app.ensure_sync(fn)(*args, **kwargs)
+
+ if cv("CSRF_IGNORE_UNAUTH_ENDPOINTS") and not is_user_authenticated(
+ current_user
+ ):
+ set_request_attr("csrf_valid", True)
+ else:
+ try:
+ _csrf.protect()
+ except CSRFError as e:
+ if _security._want_json(request):
+ payload = json_error_response(errors=e.description)
+ return _security._render_json(payload, 400, None, None)
+ raise
+
+ return current_app.ensure_sync(fn)(*args, **kwargs)
+
+ return decorated
+
+ return wrapper
+
+
+def roles_required(*roles: str) -> DecoratedView:
+ """Decorator which specifies that a user must have all the specified roles.
+ Example::
+
+ @app.route('/dashboard')
+ @roles_required('admin', 'editor')
+ def dashboard():
+ return 'Dashboard'
+
+ The current user must have both the `admin` role and `editor` role in order
+ to view the page.
+
+ :param roles: The required roles.
+ """
+
+ def wrapper(fn):
+ @wraps(fn)
+ def decorated_view(*args, **kwargs):
+ perms = [Permission(RoleNeed(role)) for role in roles]
+ for perm in perms:
+ if not perm.can():
+ return _security._unauthz_handler(
+ roles_required.__name__, list(roles)
+ )
+ return current_app.ensure_sync(fn)(*args, **kwargs)
+
+ return decorated_view
+
+ return wrapper
+
+
+def roles_accepted(*roles: str) -> DecoratedView:
+ """Decorator which specifies that a user must have at least one of the
+ specified roles. Example::
+
+ @app.route('/create_post')
+ @roles_accepted('editor', 'author')
+ def create_post():
+ return 'Create Post'
+
+ The current user must have either the `editor` role or `author` role in
+ order to view the page.
+
+ :param roles: The possible roles.
+ """
+
+ def wrapper(fn):
+ @wraps(fn)
+ def decorated_view(*args, **kwargs):
+ perm = Permission(*(RoleNeed(role) for role in roles))
+ if perm.can():
+ return current_app.ensure_sync(fn)(*args, **kwargs)
+ return _security._unauthz_handler(roles_accepted.__name__, list(roles))
+
+ return decorated_view
+
+ return wrapper
+
+
+def permissions_required(*fsperms: str) -> DecoratedView:
+ """Decorator which specifies that a user must have all the specified permissions.
+ Example::
+
+ @app.route('/dashboard')
+ @permissions_required('admin-write', 'editor-write')
+ def dashboard():
+ return 'Dashboard'
+
+ The current user must have BOTH permissions (via the roles it has)
+ to view the page.
+
+ N.B. Don't confuse these permissions with flask-principle Permission()!
+
+ :param fsperms: The required permissions.
+
+ .. versionadded:: 3.3.0
+ """
+
+ def wrapper(fn):
+ @wraps(fn)
+ def decorated_view(*args, **kwargs):
+ perms = [Permission(FsPermNeed(fsperm)) for fsperm in fsperms]
+ for perm in perms:
+ if not perm.can():
+ return _security._unauthz_handler(
+ permissions_required.__name__, list(fsperms)
+ )
+
+ return current_app.ensure_sync(fn)(*args, **kwargs)
+
+ return decorated_view
+
+ return wrapper
+
+
+def permissions_accepted(*fsperms: str) -> DecoratedView:
+ """Decorator which specifies that a user must have at least one of the
+ specified permissions. Example::
+
+ @app.route('/create_post')
+ @permissions_accepted('editor-write', 'author-wrote')
+ def create_post():
+ return 'Create Post'
+
+ The current user must have one of the permissions (via the roles it has)
+ to view the page.
+
+ N.B. Don't confuse these permissions with flask-principle Permission()!
+
+ :param fsperms: The possible permissions.
+
+ .. versionadded:: 3.3.0
+ """
+
+ def wrapper(fn):
+ @wraps(fn)
+ def decorated_view(*args, **kwargs):
+ perm = Permission(*(FsPermNeed(fsperm) for fsperm in fsperms))
+ if perm.can():
+ return current_app.ensure_sync(fn)(*args, **kwargs)
+ return _security._unauthz_handler(
+ permissions_accepted.__name__, list(fsperms)
+ )
+
+ return decorated_view
+
+ return wrapper
+
+
+def anonymous_user_required(f: DecoratedView) -> DecoratedView:
+ """Decorator which requires that caller NOT be logged in.
+ If a logged in user accesses an endpoint protected with this decorator
+ they will be redirected to the :py:data:`SECURITY_POST_LOGIN_VIEW`.
+ If the caller requests a JSON response, a 400 will be returned.
+
+ .. versionchanged:: 3.3.0
+ Support for JSON response was added.
+ """
+
+ @wraps(f)
+ def wrapper(*args, **kwargs):
+ if is_user_authenticated(current_user):
+ if _security._want_json(request):
+ payload = json_error_response(
+ errors=get_message("ANONYMOUS_USER_REQUIRED")[0]
+ )
+ return _security._render_json(payload, 400, None, None)
+ else:
+ return redirect(get_url(cv("POST_LOGIN_VIEW")))
+ return current_app.ensure_sync(f)(*args, **kwargs)
+
+ return t.cast(DecoratedView, wrapper)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/forms.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/forms.py
new file mode 100644
index 0000000000000000000000000000000000000000..d837dfc22447fc6bfb4ce94402c80525c8fd2c99
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/forms.py
@@ -0,0 +1,899 @@
+"""
+ flask_security.forms
+ ~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security forms module
+
+ :copyright: (c) 2012 by Matt Wright.
+ :copyright: (c) 2017 by CERN.
+ :copyright: (c) 2019-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import inspect
+import typing as t
+
+from flask import current_app, request
+from flask_login import current_user
+from flask_wtf import FlaskForm as BaseForm
+from markupsafe import Markup
+from wtforms import (
+ BooleanField,
+ EmailField,
+ Field,
+ HiddenField,
+ PasswordField,
+ RadioField,
+ StringField,
+ SubmitField,
+ TelField,
+ ValidationError,
+ validators,
+)
+
+from werkzeug.datastructures import MultiDict
+from wtforms.validators import Optional, StopValidation
+
+from .babel import is_lazy_string, make_lazy_string
+from .confirmable import requires_confirmation
+from .mail_util import EmailValidateException
+from .proxies import _security
+from .utils import (
+ _,
+ _datastore,
+ config_value as cv,
+ do_flash,
+ get_identity_attribute,
+ get_message,
+ hash_password,
+ localize_callback,
+ suppress_form_csrf,
+ url_for_security,
+ validate_redirect_url,
+ verify_password,
+)
+
+if t.TYPE_CHECKING: # pragma: no cover
+ from .datastore import User
+
+_default_field_labels = {
+ "email": _("Email Address"),
+ "password": _("Password"),
+ "remember_me": _("Remember Me"),
+ "login": _("Login"),
+ "signin": _("Sign In"),
+ "register": _("Register"),
+ "send_confirmation": _("Resend Confirmation Instructions"),
+ "recover_password": _("Recover Password"),
+ "reset_password": _("Reset Password"),
+ "retype_password": _("Retype Password"),
+ "new_password": _("New Password"),
+ "change_password": _("Change Password"),
+ "send_login_link": _("Send Login Link"),
+ "verify_password": _("Verify Password"),
+ "change_method": _("Change Method"),
+ "phone": _("Phone Number"),
+ "code": _("Authentication Code"),
+ "submit": _("Submit"),
+ "submitcode": _("Submit Code"),
+ "error": _("Error(s)"),
+ "identity": _("Identity"),
+ "sendcode": _("Send Code"),
+ "passcode": _("Passcode"),
+ "username": _("Username"),
+ "delete": _("Delete"),
+ "email_method": _("Set up using email"),
+ "authapp_method": _(
+ "Set up using an authenticator app (e.g. google, lastpass, authy)"
+ ),
+ "sms_method": _("Set up using SMS"),
+}
+
+# translated methods for two-factor and us-signin. keyed by form 'choices'
+_setup_methods_xlate = {
+ "google_authenticator": _("Google Authenticator"),
+ "authenticator": _("authenticator"),
+ "email": _("email"),
+ "mail": _("email"),
+ "sms": _("SMS"),
+ "password": _("password"),
+ None: _("none"),
+}
+
+
+class ValidatorMixin:
+ """
+ This is called at import time - so there is no app context.
+ Validators have state - namely self.message - but we need that
+ xlated on a per-request basis. So we want a lazy_string - but we can't create
+ that until we are in an app context.
+ """
+
+ def __init__(self, *args, **kwargs):
+ # If the message is available from config[MSG_xx] then it can be xlated.
+ # Otherwise it will be used as is.
+ if "message" in kwargs:
+ self._original_message = kwargs["message"]
+ del kwargs["message"]
+ else:
+ self._original_message = None
+ super().__init__(*args, **kwargs)
+
+ def __call__(self, form, field):
+ if self._original_message and (
+ not is_lazy_string(self.message) and not self.message
+ ):
+ # Creat on first usage within app context.
+ msg = cv("MSG_" + self._original_message, strict=False)
+ if msg:
+ self.message = make_lazy_string(_local_xlate, msg[0])
+ else:
+ self.message = self._original_message
+ return super().__call__(form, field)
+
+
+class EqualTo(ValidatorMixin, validators.EqualTo):
+ pass
+
+
+class Required(ValidatorMixin, validators.DataRequired):
+ pass
+
+
+class Length(ValidatorMixin, validators.Length):
+ pass
+
+
+class EmailValidation:
+ """Simple interface to email_validator.
+ N.B. Side-effect - if valid email, the field.data is set to the normalized value.
+
+ The 'verify' keyword informs the validator to perform checks to be more sure
+ that the email can actually receive an email (as well as normalize).
+ Set to False - just normalize (for use with identity purposes).
+ """
+
+ def __init__(self, *args, **kwargs):
+ self.verify = kwargs.get("verify", False)
+
+ def __call__(self, form, field):
+ if field.data is None: # pragma: no cover
+ raise ValidationError(get_message("EMAIL_NOT_PROVIDED")[0])
+
+ try:
+ if self.verify:
+ field.data = _security._mail_util.validate(field.data)
+ else:
+ field.data = _security._mail_util.normalize(field.data)
+ except EmailValidateException as e:
+ # we stop further validators if email isn't valid.
+ # TODO: email_validator provides some really nice error messages - however
+ # they aren't localized. And there isn't an easy way to add multiple
+ # errors at once.
+ raise StopValidation(e.msg)
+ except ValueError:
+ # Backwards compat - mail_util no longer raises this - but app subclasses
+ # might (and we're making this change in 5.4.3).
+ msg = get_message("INVALID_EMAIL_ADDRESS")[0]
+ raise StopValidation(msg)
+
+
+email_required = Required(message="EMAIL_NOT_PROVIDED")
+password_required = Required(message="PASSWORD_NOT_PROVIDED")
+
+
+def _local_xlate(text):
+ """LazyStrings need to be evaluated in the context of a request
+ where _security.i18_domain is available.
+ """
+ return localize_callback(text)
+
+
+def get_form_field_label(key):
+ """This is called during import since form fields are declared as part of
+ class. Thus can't call 'localize_callback' until we need to actually
+ translate/render form.
+ """
+ return make_lazy_string(_local_xlate, _default_field_labels.get(key, ""))
+
+
+def get_form_field_xlate(txt):
+ return make_lazy_string(_local_xlate, txt)
+
+
+def valid_user_email(form, field):
+ # Verify email exists in DB - be sure to normalize first.
+ # Side-effect - set form.user if field is valid
+ uia_email = get_identity_attribute("email")
+ form.user = _datastore.find_user(
+ case_insensitive=uia_email.get("case_insensitive", False), email=field.data
+ )
+ if form.user is None:
+ raise ValidationError(get_message("USER_DOES_NOT_EXIST")[0])
+
+
+def unique_user_email(form, field):
+ # Verify email not already in DB
+ # Assumes field value already normalized - email_validator does this.
+ uia_email = get_identity_attribute("email")
+ form.existing_email_user = _datastore.find_user(
+ case_insensitive=uia_email.get("case_insensitive", False), email=field.data
+ )
+ if form.existing_email_user is not None:
+ msg = get_message("EMAIL_ALREADY_ASSOCIATED", email=field.data)[0]
+ raise ValidationError(msg)
+
+
+def username_validator(form, field):
+ # Side-effect - field.data is updated to normalized value.
+ msg, field.data = _security._username_util.validate(field.data)
+ if msg:
+ raise ValidationError(msg)
+
+
+def unique_username(form, field):
+ # Verify username not already in DB
+ # Assumes field value already normalized - username_validator does this.
+ uia_username = get_identity_attribute("username")
+ form.existing_username_user = _datastore.find_user(
+ case_insensitive=uia_username.get("case_insensitive", False),
+ username=field.data,
+ )
+ if form.existing_username_user is not None:
+ msg = get_message("USERNAME_ALREADY_ASSOCIATED", username=field.data)[0]
+ raise ValidationError(msg)
+
+
+def unique_identity_attribute(form, field):
+ """A validator that checks the field data against all configured
+ :py:data:`SECURITY_USER_IDENTITY_ATTRIBUTES`.
+ This can be used as part of registration.
+
+ Be aware that the "mapper" function likely also normalizes the input in addition
+ to validating it.
+
+ :param form:
+ :param field:
+ :return: Nothing; if field data corresponds to an existing User, ValidationError
+ is raised.
+ """
+ for mapping in cv("USER_IDENTITY_ATTRIBUTES"):
+ attr = list(mapping.keys())[0]
+ details = mapping[attr]
+ idata = details["mapper"](field.data)
+ if idata:
+ if _datastore.find_user(
+ case_insensitive=details.get("case_insensitive", False), **{attr: idata}
+ ):
+ msg = get_message(
+ "IDENTITY_ALREADY_ASSOCIATED", attr=attr, value=idata
+ )[0]
+ raise ValidationError(msg)
+
+
+class Form(BaseForm):
+ def __init__(self, *args, **kwargs):
+ if current_app and current_app.testing:
+ self.TIME_LIMIT = None
+ super().__init__(*args, **kwargs)
+
+
+def generic_message(
+ detailed_msg: str, generic_msg: str, **kwargs: t.Any
+) -> tuple[str, str]:
+ if cv("RETURN_GENERIC_RESPONSES"):
+ m, c = get_message(generic_msg, **kwargs)
+ else:
+ m, c = get_message(detailed_msg, **kwargs)
+ return m, c
+
+
+def form_errors_munge(form: Form, fields: dict[str, dict[str, str]]) -> None:
+ """
+ To support OWASP best practice on unauthenticated endpoints to avoid
+ disclosing whether a user exists or not we need to return generic error messages.
+ Furthermore, WTForms really likes to place errors on the field itself - which is
+ a dead giveaway. We need to move errors from fields to the form.form_errors, and
+ (optionally) replace then with generic msgs.
+ """
+ if not cv("RETURN_GENERIC_RESPONSES"): # pragma: no cover
+ return
+
+ for fname, rinfo in fields.items():
+ field = getattr(form, fname)
+ if field.errors:
+ field.errors = []
+ # If they want to replace that message with a generic message and place
+ # it in the generic/form level errors - do that.
+ if replace_msg := rinfo.get("replace_msg"):
+ form.form_errors.append(get_message(replace_msg)[0])
+
+
+class UserEmailFormMixin:
+ email = EmailField(
+ get_form_field_label("email"),
+ render_kw={"autocomplete": "email"},
+ validators=[email_required, EmailValidation(verify=True), valid_user_email],
+ )
+
+
+class UniqueEmailFormMixin:
+ email = EmailField(
+ get_form_field_label("email"),
+ render_kw={"autocomplete": "email"},
+ validators=[email_required, EmailValidation(verify=True), unique_user_email],
+ )
+
+
+class PasswordFormMixin:
+ password = PasswordField(
+ get_form_field_label("password"),
+ render_kw={"autocomplete": "current-password"},
+ validators=[password_required],
+ )
+
+
+class NewPasswordFormMixin:
+ password = PasswordField(
+ get_form_field_label("password"),
+ render_kw={"autocomplete": "new-password"},
+ validators=[password_required],
+ )
+
+
+class PasswordConfirmFormMixin:
+ password_confirm = PasswordField(
+ get_form_field_label("retype_password"),
+ render_kw={"autocomplete": "new-password"},
+ validators=[
+ EqualTo("password", message="RETYPE_PASSWORD_MISMATCH"),
+ password_required,
+ ],
+ )
+
+
+class NextFormMixin:
+ next = HiddenField()
+
+ def validate_next(self, field):
+ if field.data and not validate_redirect_url(field.data):
+ field.data = ""
+ do_flash(*get_message("INVALID_REDIRECT"))
+ raise ValidationError(get_message("INVALID_REDIRECT")[0])
+
+
+class CodeFormMixin:
+ code = StringField(
+ get_form_field_label("code"),
+ render_kw={
+ "autocomplete": "one-time-code",
+ "inputtype": "numeric",
+ "pattern": "[0-9]*",
+ },
+ validators=[Required()],
+ )
+
+
+def get_register_username_field(app):
+ if cv("USERNAME_REQUIRED", app=app):
+ validators = [
+ Required(message="USERNAME_NOT_PROVIDED"),
+ username_validator,
+ unique_username,
+ ]
+ else:
+ validators = [username_validator, unique_username]
+ return StringField(
+ get_form_field_label("username"),
+ render_kw={"autocomplete": "username"},
+ validators=validators,
+ )
+
+
+login_username_field = StringField(
+ get_form_field_label("username"),
+ render_kw={"autocomplete": "username"},
+ validators=[username_validator],
+)
+
+
+class RegisterFormMixin:
+ submit = SubmitField(get_form_field_label("register"))
+
+ # The "username" field is added in init_app if USERNAME_ENABLE is set.
+ # This is just a type hint.
+ username: t.ClassVar[Field]
+
+ def to_dict(self, only_user):
+ """
+ Return form data as dictionary
+ :param only_user: bool, if True then only fields that have
+ corresponding members in UserModel are returned
+ :return: dict
+ """
+
+ def is_field_and_user_attr(member):
+ if not isinstance(member, Field):
+ return False
+
+ # If only fields recorded on UserModel should be returned,
+ # perform check on user model, else return True
+ if only_user is True:
+ return hasattr(_datastore.user_model, member.name)
+ else:
+ return True
+
+ fields = inspect.getmembers(self, is_field_and_user_attr)
+ return {key: value.data for key, value in fields}
+
+
+class SendConfirmationForm(Form, UserEmailFormMixin):
+ """The default send confirmation form"""
+
+ submit = SubmitField(get_form_field_label("send_confirmation"))
+
+ def __init__(self, *args: t.Any, **kwargs: t.Any):
+ super().__init__(*args, **kwargs)
+ self.user: User | None = None # set by valid_user_email
+ if request and request.method == "GET":
+ self.email.data = request.args.get("email", None)
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+ assert self.user is not None
+ if self.user.confirmed_at is not None:
+ self.email.errors.append(get_message("ALREADY_CONFIRMED")[0])
+ return False
+ return True
+
+
+class ForgotPasswordForm(Form, UserEmailFormMixin):
+ """The default forgot password form"""
+
+ submit = SubmitField(get_form_field_label("recover_password"))
+
+ def __init__(self, *args: t.Any, **kwargs: t.Any):
+ super().__init__(*args, **kwargs)
+ self.requires_confirmation: bool = False
+ self.user: User | None = None # set by valid_user_email
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+ assert self.user is not None
+ if not self.user.is_active:
+ self.email.errors.append(get_message("DISABLED_ACCOUNT")[0])
+ return False
+ self.requires_confirmation = requires_confirmation(self.user)
+ if self.requires_confirmation:
+ self.email.errors.append(get_message("CONFIRMATION_REQUIRED")[0])
+ return False
+ return True
+
+
+class PasswordlessLoginForm(Form):
+ """The passwordless login form"""
+
+ email = EmailField(
+ get_form_field_label("email"),
+ render_kw={"autocomplete": "email"},
+ validators=[email_required, EmailValidation(verify=False), valid_user_email],
+ )
+
+ submit = SubmitField(get_form_field_label("send_login_link"))
+
+ def __init__(self, *args: t.Any, **kwargs: t.Any):
+ super().__init__(*args, **kwargs)
+ self.user: User | None = None # set by valid_user_email
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+ assert self.user is not None
+ if not self.user.is_active:
+ self.email.errors.append(get_message("DISABLED_ACCOUNT")[0])
+ return False
+ return True
+
+
+class LoginForm(Form, PasswordFormMixin, NextFormMixin):
+ """The default login form"""
+
+ # email field - we don't use valid_user_email since for login
+ # with username feature it is potentially optional.
+ email = EmailField(
+ get_form_field_label("email"),
+ render_kw={"autocomplete": "email"},
+ validators=[Optional(), EmailValidation(verify=False)],
+ )
+
+ # username is added dynamically based on USERNAME_ENABLED.
+ username: t.ClassVar[Field]
+ remember = BooleanField(get_form_field_label("remember_me"))
+ submit = SubmitField(get_form_field_label("login"))
+
+ def __init__(self, *args: t.Any, **kwargs: t.Any):
+ super().__init__(*args, **kwargs)
+ if request and not self.next.data:
+ self.next.data = request.args.get("next", "")
+ self.remember.default = cv("DEFAULT_REMEMBER_ME")
+ if _security.recoverable and not self.password.description:
+ html = Markup(
+ f''
+ f'{get_message("FORGOT_PASSWORD")[0]}'
+ )
+ self.password.description = html
+ self.requires_confirmation: bool = False
+ self.user: User | None = None
+ # ifield can be set by subclasses to skip identity checks.
+ self.ifield: Field | None = None
+ # If True then user has authenticated so we can show detailed errors
+ self.user_authenticated = False
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+
+ # Stay clear of accessing 'username' unless we added that field.
+ # Lots of applications have added their own.
+ # To make subclassing easier - if self.ifield has been set we assume
+ # subclass has validated and attempted to look up user. It is also
+ # responsible to deal with USER_IDENTITY_ATTRIBUTES if it cares.
+ if not self.ifield:
+ uia_email = get_identity_attribute("email")
+ if uia_email and self.email.data:
+ self.ifield = self.email
+ self.user = _datastore.find_user(
+ case_insensitive=uia_email.get("case_insensitive", False),
+ email=self.email.data,
+ )
+ elif cv("USERNAME_ENABLE"):
+ uia_username = get_identity_attribute("username")
+ if uia_username and self.username.data:
+ self.user = _datastore.find_user(
+ case_insensitive=uia_username.get("case_insensitive", False),
+ username=self.username.data,
+ )
+ self.ifield = self.username
+ else:
+ # A bit of backwards compat - the old LoginForm just had email and
+ # any errors would be set on that field.
+ if uia_email:
+ self.ifield = self.email
+
+ if self.user is None:
+ msg = get_message("USER_DOES_NOT_EXIST")[0]
+ if self.ifield:
+ self.ifield.errors.append(msg)
+ else:
+ self.form_errors.append(msg)
+ # Reduce timing variation between existing and non-existing users
+ hash_password(self.password.data)
+ return False
+ if not self.user.password:
+ # This is result of PASSWORD_REQUIRED=False and UNIFIED_SIGNIN
+ self.password.errors.append(get_message("INVALID_PASSWORD")[0])
+ # Reduce timing variation between existing and non-existing users
+ hash_password(self.password.data)
+ return False
+ self.password.data = _security._password_util.normalize(self.password.data)
+ if not self.user.verify_and_update_password(self.password.data):
+ self.password.errors.append(get_message("INVALID_PASSWORD")[0])
+ return False
+
+ # At this point the user has successfully authenticated - so it is fine
+ # to return detailed errors.
+ self.user_authenticated = True
+ self.requires_confirmation = requires_confirmation(self.user)
+ if self.requires_confirmation:
+ self.ifield.errors.append(get_message("CONFIRMATION_REQUIRED")[0])
+ return False
+ if not self.user.is_active:
+ self.ifield.errors.append(get_message("DISABLED_ACCOUNT")[0])
+ return False
+ return True
+
+
+class VerifyForm(Form, PasswordFormMixin):
+ """The verify authentication form"""
+
+ submit = SubmitField(get_form_field_label("verify_password"))
+
+ def __init__(self, *args: t.Any, user: User, **kwargs: t.Any):
+ super().__init__(*args, **kwargs)
+ self.user: User = user
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs): # pragma: no cover
+ return False
+
+ self.password.data = _security._password_util.normalize(self.password.data)
+ if not self.user.verify_and_update_password(self.password.data):
+ self.password.errors.append(get_message("INVALID_PASSWORD")[0])
+ return False
+ return True
+
+
+class ConfirmRegisterForm(Form, RegisterFormMixin, UniqueEmailFormMixin):
+ """This form is used for registering when 'confirmable' is set.
+ The only difference between this and the other RegisterForm is that
+ this one doesn't require re-typing in the password...
+
+ We want to support OWASP best-practice around mitigating user enumeration.
+ To that end we run through the entire validation regardless - this allows us
+ to still return important bad-password messages.
+ In the case of an existing email or username - we set form.existing_xx so that
+ the view can decide how to match responses (e.g. json responses always return 200).
+ """
+
+ # Password optional when Unified Signin enabled.
+ password = PasswordField(
+ get_form_field_label("password"),
+ render_kw={"autocomplete": "new-password"},
+ )
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.existing_username_user = None
+ self.existing_email_user = None
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ failed = False
+ if not super().validate(**kwargs):
+ failed = True
+
+ # whether a password is required is a config variable (PASSWORD_REQUIRED).
+ # For unified signin there are many other ways to authenticate
+ if cv("PASSWORD_REQUIRED") or not cv("UNIFIED_SIGNIN"):
+ if not self.password.data or not self.password.data.strip():
+ self.password.errors.append(get_message("PASSWORD_NOT_PROVIDED")[0])
+ failed = True
+
+ if self.password.data:
+ # We do explicit validation here for passwords
+ # (rather than write a validator class) for 2 reasons:
+ # 1) We want to control which fields are passed -
+ # sometimes that's current_user
+ # other times it's the registration fields.
+ # 2) We want to be able to return multiple error messages.
+ rfields = {}
+ for k, v in self.data.items():
+ if hasattr(_datastore.user_model, k):
+ rfields[k] = v
+ del rfields["password"]
+ pbad, self.password.data = _security._password_util.validate(
+ self.password.data, True, **rfields
+ )
+ if pbad:
+ self.password.errors.extend(pbad)
+ failed = True
+ return not failed
+
+
+class RegisterForm(ConfirmRegisterForm, NextFormMixin):
+ # Password optional when Unified Signin enabled.
+ password_confirm = PasswordField(
+ get_form_field_label("retype_password"),
+ validators=[
+ EqualTo("password", message="RETYPE_PASSWORD_MISMATCH"),
+ validators.Optional(),
+ ],
+ )
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+ if not cv("UNIFIED_SIGNIN"):
+ # password_confirm required
+ if not self.password_confirm.data or not self.password_confirm.data.strip():
+ self.password_confirm.errors.append(
+ get_message("PASSWORD_NOT_PROVIDED")[0]
+ )
+ return False
+ return True
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ if not self.next.data:
+ self.next.data = request.args.get("next", "")
+
+
+class ResetPasswordForm(Form, NewPasswordFormMixin, PasswordConfirmFormMixin):
+ """The default reset password form"""
+
+ # filled in by caller
+ user: User
+
+ submit = SubmitField(get_form_field_label("reset_password"))
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+
+ pbad, self.password.data = _security._password_util.validate(
+ self.password.data, False, user=self.user
+ )
+ if pbad:
+ self.password.errors.extend(pbad)
+ return False
+ return True
+
+
+class ChangePasswordForm(Form):
+ """The default change password form"""
+
+ password = PasswordField(
+ get_form_field_label("password"), render_kw={"autocomplete": "current-password"}
+ )
+ new_password = PasswordField(
+ get_form_field_label("new_password"),
+ render_kw={"autocomplete": "new-password"},
+ validators=[password_required],
+ )
+
+ new_password_confirm = PasswordField(
+ get_form_field_label("retype_password"),
+ render_kw={"autocomplete": "new-password"},
+ validators=[
+ EqualTo("new_password", message="RETYPE_PASSWORD_MISMATCH"),
+ password_required,
+ ],
+ )
+
+ submit = SubmitField(get_form_field_label("change_password"))
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+
+ # If user doesn't have a password then the caller (view) has already
+ # verified a current fresh session.
+ if current_user.password:
+ if not self.password.data or not self.password.data.strip():
+ self.password.errors.append(get_message("PASSWORD_NOT_PROVIDED")[0])
+ return False
+
+ self.password.data = _security._password_util.normalize(self.password.data)
+ if not verify_password(self.password.data, current_user.password):
+ self.password.errors.append(get_message("INVALID_PASSWORD")[0])
+ return False
+ if self.password.data == self.new_password.data:
+ self.password.errors.append(get_message("PASSWORD_IS_THE_SAME")[0])
+ return False
+
+ pbad, self.new_password.data = _security._password_util.validate(
+ self.new_password.data, False, user=current_user
+ )
+ if pbad:
+ self.new_password.errors.extend(pbad)
+ return False
+ return True
+
+
+class TwoFactorSetupForm(Form):
+ """The Two-factor token validation form"""
+
+ setup = RadioField(
+ get_form_field_xlate(_("Available Methods")),
+ choices=[
+ ("disable", get_form_field_xlate(_("Disable two factor authentication"))),
+ ("email", get_form_field_label("email_method")),
+ (
+ "authenticator",
+ get_form_field_label("authapp_method"),
+ ),
+ ("sms", get_form_field_label("sms_method")),
+ ],
+ validate_choice=False,
+ )
+ phone = TelField(get_form_field_label("phone"))
+ submit = SubmitField(get_form_field_label("submit"))
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs): # pragma: no cover
+ return False
+ choices = list(cv("TWO_FACTOR_ENABLED_METHODS"))
+ if "email" in choices:
+ # backwards compat
+ choices.append("mail")
+ if not cv("TWO_FACTOR_REQUIRED"):
+ choices.append("disable")
+ if "setup" not in self.data or self.data["setup"] not in choices:
+ self.setup.errors.append(get_message("TWO_FACTOR_METHOD_NOT_AVAILABLE")[0])
+ return False
+ if self.setup.data == "sms":
+ msg = _security._phone_util.validate_phone_number(self.phone.data)
+ if msg:
+ self.phone.errors.append(msg)
+ return False
+
+ return True
+
+
+class TwoFactorVerifyCodeForm(Form, CodeFormMixin):
+ """The Two-factor token validation form"""
+
+ submit = SubmitField(get_form_field_label("submitcode"))
+
+ def __init__(self, *args: t.Any, **kwargs: t.Any):
+ super().__init__(*args, **kwargs)
+ # These are set by view.
+ self.window: int = 0
+ self.primary_method: str = ""
+ self.tf_totp_secret: str = ""
+ self.user: User | None = None # set by view
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs): # pragma: no cover
+ return False
+ if (
+ self.primary_method == "google_authenticator"
+ or self.primary_method == "authenticator"
+ ):
+ self.window = cv("TWO_FACTOR_AUTHENTICATOR_VALIDITY")
+ elif self.primary_method == "email" or self.primary_method == "mail":
+ self.window = cv("TWO_FACTOR_MAIL_VALIDITY")
+ elif self.primary_method == "sms":
+ self.window = cv("TWO_FACTOR_SMS_VALIDITY")
+ else:
+ return False
+
+ # verify entered code with user's totp secret
+ assert self.user is not None
+ if not _security._totp_factory.verify_totp(
+ token=self.code.data,
+ totp_secret=self.tf_totp_secret,
+ user=self.user,
+ window=self.window,
+ ):
+ self.code.errors.append(get_message("TWO_FACTOR_INVALID_TOKEN")[0])
+ return False
+
+ return True
+
+
+class TwoFactorRescueForm(Form):
+ """The Two-factor Rescue validation form"""
+
+ # rescue options - additional options are generated in set_rescue_options()
+ help_setup = RadioField(
+ get_form_field_xlate(_("Trouble Accessing Your Account?/Lost Mobile Device?")),
+ choices=[
+ ("help", get_form_field_xlate(_("Contact Administrator"))),
+ ],
+ )
+ submit = SubmitField(get_form_field_label("submit"))
+
+
+class DummyForm(Form):
+ """A dummy form for json responses"""
+
+ def __init__(self, *args: t.Any, **kwargs: t.Any):
+ super().__init__(*args, **kwargs)
+ self.user: User | None = kwargs.get("user", None)
+
+
+def build_form_from_request(form_name: str, **kwargs: dict[str, t.Any]) -> Form:
+ # helper function for views
+ form_data = None
+ if request.content_length:
+ form_data = MultiDict(request.get_json()) if request.is_json else request.form
+ return build_form(
+ form_name, formdata=form_data, meta=suppress_form_csrf(), **kwargs
+ )
+
+
+def build_form(form_name, **kwargs):
+ # helper function for views
+ kwargs.setdefault("formdata", None)
+ return _security.forms[form_name].instantiator(
+ form_name,
+ _security.forms[form_name].cls,
+ **kwargs,
+ )
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/json.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/json.py
new file mode 100644
index 0000000000000000000000000000000000000000..f44a611471f5078a175121ccb24d3afe6cc25125
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/json.py
@@ -0,0 +1,30 @@
+"""
+ Flask-Security JSON extensions.
+
+ :copyright: (c) 2022-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+
+ Pieces of this code liberally copied from flask-mongoengine.
+"""
+
+
+def _use_provider(superclass):
+ """Flask 2.2 onwards - customize JSONProvider"""
+
+ class FSJsonProvider(superclass):
+ @staticmethod
+ def default(obj):
+ from .babel import is_lazy_string
+
+ if is_lazy_string(obj):
+ return str(obj)
+ return super(FSJsonProvider, FSJsonProvider).default(obj)
+
+ return FSJsonProvider
+
+
+def setup_json(app, bp=None):
+ # Called at init_app time.
+ # Flask >= 2.2
+ app.json_provider_class = _use_provider(app.json_provider_class)
+ app.json = app.json_provider_class(app)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/mail_util.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/mail_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4514f604fe52805bdc6ab0aa51594852dc34fb4
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/mail_util.py
@@ -0,0 +1,165 @@
+"""
+ flask_security.mail_util
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Utility class providing methods for validating, normalizing and sending emails.
+
+ :copyright: (c) 2020-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+
+ While this default implementation uses Flask-Mailman - we want to make sure that
+ Flask-Mailman isn't REQUIRED (if this implementation isn't used).
+"""
+
+from __future__ import annotations
+
+import typing as t
+
+import email_validator
+from flask import current_app
+
+from .utils import config_value, get_message
+
+if t.TYPE_CHECKING: # pragma: no cover
+ import flask
+
+
+class EmailValidateException(ValueError):
+ """This is raised for any email validation errors.
+ This can be used by custom MailUtil implementations to provide
+ custom error messages.
+ """
+
+ def __init__(self, message: str) -> None:
+ self.msg = message
+
+
+class MailUtil:
+ """
+ Utility class providing methods for validating, normalizing and sending emails.
+
+ This default class uses the email_validator package to handle validation and
+ normalization, and the flask_mailman package (if initialized) to send emails.
+
+ To provide your own implementation, pass in the class as ``mail_util_cls``
+ at init time. Your class will be instantiated once as part of app initialization.
+
+ .. versionadded:: 4.0.0
+ """
+
+ def __init__(self, app: flask.Flask):
+ """Instantiate class.
+
+ :param app: The Flask application being initialized.
+ """
+ pass
+
+ def send_mail(
+ self,
+ template: str,
+ subject: str,
+ recipient: str,
+ sender: str | tuple,
+ body: str,
+ html: str | None,
+ **kwargs: t.Any,
+ ) -> None:
+ """Send an email via the Flask-Mailman or Flask-Mail or other mail extension.
+
+ :param template: the Template name. The message has already been rendered
+ however this might be useful to differentiate why the email is being sent.
+ :param subject: Email subject
+ :param recipient: Email recipient
+ :param sender: who to send email as (see :py:data:`SECURITY_EMAIL_SENDER`)
+ :param body: the rendered body (text)
+ :param html: the rendered body (html)
+ :param kwargs: the entire context
+
+ It is possible that sender is a lazy_string for localization (unlikely but..)
+ so we cast to str() here to force localization.
+ """
+
+ if current_app.extensions.get("mailman", None):
+ from flask_mailman import EmailMultiAlternatives, Mail
+
+ # Flask-Mailman doesn't appear to take a tuple - a bug has been filed
+ # but not sure they will fix it (parts of Flask-Mailman work - but not
+ # the actual email headers).
+ if isinstance(sender, tuple) and len(sender) == 2:
+ # sender = (str(sender[0]), str(sender[1]))
+ sender = f"{str(sender[0])} <{str(sender[1])}>"
+ else:
+ sender = str(sender)
+
+ mail: Mail = current_app.extensions.get("mailman")
+ with mail.get_connection() as connection:
+ msg = EmailMultiAlternatives(
+ subject,
+ body=body,
+ from_email=sender,
+ to=[recipient],
+ connection=connection,
+ )
+ if html:
+ msg.attach_alternative(html, "text/html")
+ msg.send()
+
+ elif current_app.extensions.get("mail", None): # pragma: no cover
+ from flask_mail import Message
+
+ # In Flask-Mail, sender can be a two element tuple -- (name, address)
+ if isinstance(sender, tuple) and len(sender) == 2:
+ sender = (str(sender[0]), str(sender[1]))
+ else:
+ sender = str(sender)
+ msg = Message(subject, sender=sender, recipients=[recipient])
+ msg.body = body
+ msg.html = html
+
+ mail = current_app.extensions.get("mail")
+ mail.send(msg) # type: ignore
+
+ else: # pragma: no cover
+ raise ValueError("No email extension configured")
+
+ def normalize(self, email: str) -> str:
+ """
+ Given an input email - return a normalized version or
+ raise EmailValidateException if field value isn't syntactically valid.
+
+ This is called by forms that use email as an identity to be looked up.
+
+ Must be called in app context and uses :py:data:`SECURITY_EMAIL_VALIDATOR_ARGS`
+ config variable to pass any relevant arguments to
+ email_validator.validate_email() method.
+
+ This defaults to NOT checking for deliverability (i.e. DNS checks).
+ """
+ validator_args = config_value("EMAIL_VALIDATOR_ARGS") or {}
+ validator_args["check_deliverability"] = False
+ try:
+ valid = email_validator.validate_email(email, **validator_args)
+ return valid.normalized
+ except ValueError:
+ raise EmailValidateException(get_message("INVALID_EMAIL_ADDRESS")[0])
+
+ def validate(self, email: str) -> str:
+ """
+ Validate the given email.
+ If valid, the normalized version is returned.
+ This is used by forms/views that require an email that likely can have an
+ actual email sent to it.
+
+ Must be called in app context and uses :py:data:`SECURITY_EMAIL_VALIDATOR_ARGS`
+ config variable to pass any relevant arguments to
+ email_validator.validate_email() method.
+
+ EmailValidationException is thrown on invalid email.
+ """
+
+ validator_args = config_value("EMAIL_VALIDATOR_ARGS") or {}
+ try:
+ valid = email_validator.validate_email(email, **validator_args)
+ return valid.normalized
+ except ValueError:
+ raise EmailValidateException(get_message("INVALID_EMAIL_ADDRESS")[0])
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/oauth_glue.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/oauth_glue.py
new file mode 100644
index 0000000000000000000000000000000000000000..20ec2298dbe2edff000fc72345096c7bad47b250
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/oauth_glue.py
@@ -0,0 +1,254 @@
+"""
+ flask_security.oauth_glue
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Class and methods to glue our login path with authlib for to support 'social' auth.
+
+ :copyright: (c) 2022-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+
+"""
+
+from __future__ import annotations
+
+import typing as t
+
+try:
+ # noinspection PyUnresolvedReferences
+ from authlib.integrations.flask_client import OAuth
+
+ # noinspection PyUnresolvedReferences
+ from authlib.integrations.base_client.errors import (
+ OAuthError,
+ )
+except ImportError: # pragma: no cover
+ pass
+
+from flask import abort, after_this_request, redirect, request, session
+from flask_login import current_user
+
+from .decorators import unauth_csrf
+from .oauth_provider import (
+ OauthCbType,
+ FsOAuthProvider,
+ GoogleFsOauthProvider,
+ GitHubFsOauthProvider,
+)
+from .proxies import _security
+from .utils import (
+ config_value as cv,
+ do_flash,
+ login_user,
+ get_message,
+ get_post_action_redirect,
+ get_url,
+ is_user_authenticated,
+ json_error_response,
+ slash_url_suffix,
+ url_for_security,
+ view_commit,
+)
+
+if t.TYPE_CHECKING: # pragma: no cover
+ import flask
+ from flask.typing import ResponseValue
+
+
+@unauth_csrf()
+def oauthstart(name: str) -> ResponseValue:
+ """View to start an oauth authentication.
+ Name is a pre-registered oauth provider.
+ TODO: remember me?
+ """
+ assert _security.oauthglue
+ if is_user_authenticated(current_user):
+ # Just redirect current_user to POST_LOGIN_VIEW.
+ # For json - return an error.
+ # This endpoint is POST only.
+ # This does NOT use get_post_login_redirect() so that it doesn't look at
+ # 'next' - which can cause infinite redirect loops
+ # (see test_common::test_authenticated_loop)
+ if _security._want_json(request):
+ payload = json_error_response(
+ errors=get_message("ANONYMOUS_USER_REQUIRED")[0]
+ )
+ return _security._render_json(payload, 400, None, None)
+ else:
+ return redirect(get_url(cv("POST_LOGIN_VIEW")))
+ # we never want to return here or to the redirect location.
+ # Some providers match on entire redirect url - so we don't want to
+ # store next there. Use session.
+ session.pop("fs_oauth_next", None)
+ if request.args.get("next"):
+ session["fs_oauth_next"] = request.args.get("next")
+ return _security.oauthglue.get_redirect(name)
+
+
+def oauthresponse(name: str) -> ResponseValue:
+ """
+ Callback from oauth provider - response is provider specific
+ Since this is a callback from oauth provider - there is no form,
+ We may have stored the original 'next' in the session
+ N.B. all responses MUST be redirects.
+ """
+ assert _security.oauthglue
+ authlib_provider = _security.oauthglue.authlib_provider(name)
+ oauth_provider = _security.oauthglue.providers.get(name)
+ if not authlib_provider or not oauth_provider:
+ # this should only happen with purposeful bad API call
+ abort(404) # TODO - redirect... to where?
+ # This parses the Flask Request
+ try:
+ token = authlib_provider.authorize_access_token()
+ except OAuthError as e:
+ """One known way this can happen is if the session cookie 'samesite'
+ is set to 'strict' and e.g. the first time the user goes to github
+ and has to authorize this app and then redirect - the session
+ cookie isn't sent - and by default that is where the state is kept.
+ """
+ return oauth_provider.oauth_response_failure(e)
+
+ field_name, value = oauth_provider.fetch_identity_cb(
+ _security.oauthglue.oauth_app, token
+ )
+ user = _security.datastore.find_user(**{field_name: value})
+ if user:
+ after_this_request(view_commit)
+ next_loc = session.pop("fs_oauth_next", None)
+ response = _security.two_factor_plugins.tf_enter(
+ user, False, "oauth", next_loc=next_loc
+ )
+ if response:
+ return response
+ # two factor not required - login user
+ login_user(user)
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(
+ get_url(
+ cv("POST_OAUTH_LOGIN_VIEW"), qparams=user.get_redirect_qparams()
+ )
+ )
+ redirect_url = get_post_action_redirect(
+ "SECURITY_POST_LOGIN_VIEW", dict(next=next_loc)
+ )
+ return redirect(redirect_url)
+ # Seems ok to show identity - the only identity it could be is the callers
+ # so seems no way this can be used to enumerate registered users.
+ m, c = get_message("IDENTITY_NOT_REGISTERED", id=value)
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(get_url(cv("LOGIN_ERROR_VIEW"), qparams={c: m}))
+ do_flash(m, c)
+ # TODO: should redirect to where we came from?
+ return redirect(url_for_security("login"))
+
+
+class OAuthGlue:
+ """
+ Provide the necessary glue between the Flask-Security login process and
+ authlib oauth client code.
+
+ There are some builtin providers which can be used or not - configured via
+ :py:data:`SECURITY_OAUTH_BUILTIN_PROVIDERS`. Any other provider can be registered
+ using :py:meth:`register_provider_ext`.
+
+ See `Flask OAuth Client `_
+
+ .. versionadded:: 5.1.0
+
+ .. versionchanged:: 5.4.0
+ Added register_provider_ext which allows applications more control to
+ manage new providers (such as extended error handling).
+ """
+
+ def __init__(self, app: flask.Flask, oauthapp: OAuth | None = None):
+ if not oauthapp:
+ oauthapp = OAuth(app)
+ self.oauth = oauthapp
+ self.providers: dict[str, FsOAuthProvider] = dict()
+ if cv("OAUTH_BUILTIN_PROVIDERS", app=app):
+ for provider in cv("OAUTH_BUILTIN_PROVIDERS", app=app):
+ if provider == "github":
+ self.register_provider_ext(GitHubFsOauthProvider("github"))
+ elif provider == "google":
+ self.register_provider_ext(GoogleFsOauthProvider("google"))
+
+ def _create_blueprint(self, app: flask.Flask, bp: flask.Blueprint) -> None:
+ # Routes for each type of oauth provider
+ start_url = cv("OAUTH_START_URL", app=app)
+ response_url = cv("OAUTH_RESPONSE_URL", app=app)
+ bp.route(
+ start_url + slash_url_suffix(start_url, ""),
+ methods=["POST"],
+ endpoint="oauthstart",
+ )(oauthstart)
+ bp.route(
+ response_url + slash_url_suffix(response_url, ""),
+ methods=["GET"],
+ endpoint="oauthresponse",
+ )(oauthresponse)
+
+ def get_redirect(self, name: str, **values: t.Any) -> ResponseValue:
+ authlib_provider = self.authlib_provider(name)
+ if not authlib_provider:
+ return abort(404)
+ start_uri = url_for_security(
+ "oauthresponse", name=name, _external=True, **values
+ )
+ redirect_url = authlib_provider.authorize_redirect(start_uri)
+ return redirect_url
+
+ @property
+ def provider_names(self):
+ return self.providers.keys()
+
+ @property
+ def oauth_app(self):
+ return self.oauth
+
+ def authlib_provider(self, name):
+ return getattr(self.oauth, name, None)
+
+ def register_provider(
+ self,
+ name: str,
+ registration_info: dict[str, t.Any] | None,
+ fetch_identity_cb: OauthCbType,
+ ) -> None:
+ """Add a provider to the list.
+
+ :param name: Name of provider. This is used as part of the
+ :py:data:`SECURITY_OAUTH_START_URL`.
+ :param registration_info: Sent directly to authlib. Set this to None
+ if you already have registered the provider directly with OAuth.
+ :param fetch_identity_cb: This callback is called when the oauth
+ redirect happens. It must take the response from the provider and return
+ a tuple of - which will be used
+ to look up the user in the datastore.
+
+ The provider can be registered with OAuth here or already be done by the
+ application. If you register directly with OAuth make sure to use
+ the same `name`.
+
+ .. deprecated:: 5.4.0
+ Use :py:meth:`register_provider_ext` instead.
+
+ """
+ pcls = FsOAuthProvider(
+ name,
+ registration_info=registration_info,
+ fetch_identity_cb=fetch_identity_cb,
+ )
+ self.register_provider_ext(pcls)
+
+ def register_provider_ext(self, provider: FsOAuthProvider) -> None:
+ """Register a provider via an instance of subclass.
+ This is the new way - to provide more control for applications
+
+ The authlib provider can be registered here (by calling Oauth)
+ or already be done by the application.
+ If you register directly with OAuth make sure to use
+ the same `name` when instantiating the class.
+ """
+ self.providers[provider.name] = provider
+ if not self.authlib_provider(provider.name):
+ self.oauth.register(provider.name, **provider.authlib_config())
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/oauth_provider.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/oauth_provider.py
new file mode 100644
index 0000000000000000000000000000000000000000..42ba4a622ecf29c9c8d4e55c116aac6bf18313bc
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/oauth_provider.py
@@ -0,0 +1,130 @@
+"""
+ flask_security.oauth_provider
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Class and methods to create providers for oauth_glue.
+ Example providers for github and google.
+
+ :copyright: (c) 2024-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+
+"""
+
+from __future__ import annotations
+import collections.abc as cabc
+import sys
+
+try:
+ from authlib.integrations.flask_client import OAuth
+ from authlib.integrations.base_client.errors import (
+ OAuthError,
+ )
+except ImportError: # pragma: no cover
+ pass
+
+import typing as t
+
+from flask import redirect
+
+from .utils import (
+ config_value as cv,
+ do_flash,
+ get_message,
+ get_url,
+ url_for_security,
+)
+
+if t.TYPE_CHECKING: # pragma: no cover
+ from flask.typing import ResponseValue
+
+if sys.version_info >= (3, 9):
+ OauthCbType = cabc.Callable[["OAuth", t.Any], tuple[str, t.Any]]
+else:
+ OauthCbType = t.Callable[["OAuth", t.Any], t.Tuple[str, t.Any]] # pragma: no cover
+
+
+class FsOAuthProvider:
+ """
+ Subclass this or instantiate to add new oauth providers.
+
+ Subclassing allows for customizing additional aspects of the oauth flow
+ in particular - a custom error path for oauth flow state mismatches and
+ other errors thrown by authlib.
+
+ Call security.oauthglue.register_provider_ext(myproviderclass("myprovider"))
+
+ :param name: a name for provider - must match what was passed if this
+ is already registered with Oauth.
+ :param registration_info: This dict is passed directly to Oauth as
+ part of registration - not needed if provider already registered with
+ Oauth
+ :param fetch_identity_cb: Call back from response to oauth flow.
+ """
+
+ def __init__(
+ self,
+ name: str,
+ registration_info: dict[str, t.Any] | None = None,
+ fetch_identity_cb: OauthCbType | None = None,
+ ):
+ self.name = name
+ self._registration_info = registration_info or {}
+ self._fetch_identity_cb = fetch_identity_cb
+
+ def authlib_config(self) -> dict[str, t.Any]:
+ """Return dict with authlib configuration.
+ This is called as part of provider registration."""
+ return self._registration_info
+
+ def fetch_identity_cb(self, oauth: OAuth, token: t.Any) -> tuple[str, t.Any]:
+ """This callback is called when the oauth
+ redirect happens. It must take the response from the provider and return
+ a tuple of - which will be used
+ to look up the user in the datastore."""
+ if not self._fetch_identity_cb: # pragma no cover
+ raise NotImplementedError
+ return self._fetch_identity_cb(oauth, token)
+
+ def oauth_response_failure(self, e: OAuthError) -> ResponseValue:
+ """Called if authlib authorize_access_token throws an error.
+
+ N.B. flashing doesn't seem to work in some cases - if the session
+ cookie has samesite='strict' and it is the first registration.
+ """
+ m, c = get_message(
+ "OAUTH_HANDSHAKE_ERROR", exerror=e.error, exdesc=e.description
+ )
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(get_url(cv("LOGIN_ERROR_VIEW"), qparams={c: m}))
+ do_flash(m, c)
+ return redirect(url_for_security("login"))
+
+
+class GitHubFsOauthProvider(FsOAuthProvider):
+ def authlib_config(self):
+ return dict(
+ access_token_url="https://github.com/login/oauth/access_token",
+ access_token_params=None,
+ authorize_url="https://github.com/login/oauth/authorize",
+ authorize_params=None,
+ api_base_url="https://api.github.com/",
+ client_kwargs={"scope": "user:email"},
+ )
+
+ def fetch_identity_cb(self, oauth, token):
+ resp = oauth.github.get("user", token=token)
+ profile = resp.json()
+ return "email", profile["email"]
+
+
+class GoogleFsOauthProvider(FsOAuthProvider):
+ def authlib_config(self):
+ return dict(
+ server_metadata_url="https://accounts.google.com/"
+ ".well-known/openid-configuration",
+ client_kwargs={"scope": "openid email profile"},
+ )
+
+ def fetch_identity_cb(self, oauth, token): # pragma no cover
+ profile = token["userinfo"]
+ return "email", profile["email"]
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/password_util.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/password_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..c4b36934d890cdf57ff6fd51617cc25f22cd648c
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/password_util.py
@@ -0,0 +1,81 @@
+"""
+ flask_security.password_util
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Utility class providing methods for validating and normalizing passwords.
+
+ :copyright: (c) 2020-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+
+"""
+
+from __future__ import annotations
+
+import typing as t
+import unicodedata
+
+from .utils import (
+ config_value,
+ password_length_validator,
+ password_breached_validator,
+ password_complexity_validator,
+)
+
+if t.TYPE_CHECKING: # pragma: no cover
+ import flask
+
+
+class PasswordUtil:
+ """
+ Utility class providing methods for validating and normalizing passwords.
+
+ To provide your own implementation, pass in the class as ``password_util_cls``
+ at init time. Your class will be instantiated once as part of app initialization.
+
+ .. versionadded:: 4.0.0
+ """
+
+ def __init__(self, app: flask.Flask):
+ """Instantiate class.
+
+ :param app: The Flask application being initialized.
+ """
+ pass
+
+ def normalize(self, password: str) -> str:
+ """
+ Given an input password - return a normalized version (using Python's
+ unicodedata.normalize()).
+ Must be called in app context and uses
+ :py:data:`SECURITY_PASSWORD_NORMALIZE_FORM` config variable.
+ """
+ cf = config_value("PASSWORD_NORMALIZE_FORM")
+ if cf:
+ return unicodedata.normalize(cf, password)
+ return password
+
+ def validate(
+ self, password: str, is_register: bool, **kwargs: t.Any
+ ) -> tuple[list | None, str]:
+ """
+ Password validation.
+ Called in app/request context.
+
+ If is_register is True then kwargs will be the contents of the register form.
+ If is_register is False, then there is a single kwarg "user" which has the
+ current user data model.
+
+ The password is first normalized then validated.
+ Return value is a tuple ([msgs], normalized_password)
+ """
+
+ pnorm = self.normalize(password)
+ notok = password_length_validator(pnorm)
+ if notok:
+ return notok, pnorm
+
+ notok = password_breached_validator(pnorm)
+ if notok:
+ return notok, pnorm
+
+ return password_complexity_validator(pnorm, is_register, **kwargs), pnorm
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/passwordless.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/passwordless.py
new file mode 100644
index 0000000000000000000000000000000000000000..447c4494c0146f2707cfe3d37680b2912b3b37ee
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/passwordless.py
@@ -0,0 +1,60 @@
+"""
+ flask_security.passwordless
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security passwordless module
+
+ :copyright: (c) 2012 by Matt Wright.
+ :copyright: (c) 2021 by Chris Wagner.
+ :license: MIT, see LICENSE for more details.
+"""
+
+from flask import current_app as app
+
+from .proxies import _security
+from .signals import login_instructions_sent
+from .utils import config_value, get_token_status, send_mail, url_for_security
+
+
+def send_login_instructions(user):
+ """Sends the login instructions email for the specified user.
+
+ :param user: The user to send the instructions to
+ """
+ token = generate_login_token(user)
+ login_link = url_for_security("token_login", token=token, _external=True)
+
+ send_mail(
+ config_value("EMAIL_SUBJECT_PASSWORDLESS"),
+ user.email,
+ "login_instructions",
+ user=user,
+ login_link=login_link,
+ login_token=token,
+ )
+
+ login_instructions_sent.send(
+ app._get_current_object(),
+ _async_wrapper=app.ensure_sync,
+ user=user,
+ login_token=token,
+ )
+
+
+def generate_login_token(user):
+ """Generates a unique login token for the specified user.
+
+ :param user: The user the token belongs to
+ """
+ return _security.login_serializer.dumps([str(user.fs_uniquifier)])
+
+
+def login_token_status(token):
+ """Returns the expired status, invalid status, and user of a login token.
+ For example::
+
+ expired, invalid, user = login_token_status('...')
+
+ :param token: The login token
+ """
+ return get_token_status(token, "login", "LOGIN")
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/phone_util.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/phone_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec9aec1343a0573dc5f32f4ae28dfc00ef5fa2ab
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/phone_util.py
@@ -0,0 +1,78 @@
+"""
+ flask_security.phone_util
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Utility class for managing phone numbers
+
+ :copyright: (c) 2020-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+
+ Avoid making 'phonenumbers' a required package unless needed.
+"""
+
+from __future__ import annotations
+
+import typing as t
+
+from .utils import config_value, get_message
+
+if t.TYPE_CHECKING: # pragma: no cover
+ import flask
+
+
+class PhoneUtil:
+ """
+ Provide parsing and validation for user inputted phone numbers.
+ Subclass this to use a different underlying phone number parsing library.
+
+ To provide your own implementation, pass in the class as ``phone_util_cls``
+ at init time. Your class will be instantiated once as part of
+ Flask-Security initialization.
+
+ .. versionadded:: 3.4.0
+
+ .. versionchanged:: 4.0.0
+ __init__ takes app argument, and is instantiated at Flask-Security
+ initialization time rather than at first request.
+ """
+
+ def __init__(self, app: flask.Flask):
+ """Instantiate class.
+
+ :param app: The Flask application being initialized.
+ """
+ pass
+
+ def validate_phone_number(self, input_data: str) -> str | None:
+ """Return ``None`` if a valid phone number else
+ the ``PHONE_INVALID`` error message."""
+ import phonenumbers
+
+ try:
+ z = phonenumbers.parse(
+ input_data, region=config_value("PHONE_REGION_DEFAULT")
+ )
+ if phonenumbers.is_valid_number(z):
+ return None
+ except phonenumbers.phonenumberutil.NumberParseException:
+ pass
+ return get_message("PHONE_INVALID")[0]
+
+ def get_canonical_form(self, input_data: str) -> str | None:
+ """Validate and return a canonical form to be stored in DB
+ and compared against.
+ Returns ``None`` if input isn't a valid phone number.
+ """
+ import phonenumbers
+
+ try:
+ z = phonenumbers.parse(
+ input_data, region=config_value("PHONE_REGION_DEFAULT")
+ )
+ if phonenumbers.is_valid_number(z):
+ return phonenumbers.format_number(
+ z, phonenumbers.PhoneNumberFormat.E164
+ )
+ return None
+ except phonenumbers.phonenumberutil.NumberParseException:
+ return None
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/proxies.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/proxies.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1a761af67a43674c2a06aa18ea048eaafccbb39
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/proxies.py
@@ -0,0 +1,28 @@
+# Copyright 2021 by J. Christopher Wagner (jwag). All rights reserved.
+
+import typing as t
+
+from flask import current_app
+from werkzeug.local import LocalProxy
+
+if t.TYPE_CHECKING: # pragma: no cover
+ from passlib.context import CryptContext
+ from .core import Security
+ from .datastore import CanonicalUserDatastore
+
+# Convenient references
+_security: "Security" = LocalProxy( # type: ignore
+ lambda: current_app.extensions["security"]
+)
+
+_datastore: "CanonicalUserDatastore" = LocalProxy( # type:ignore
+ lambda: _security.datastore
+)
+
+_pwd_context: "CryptContext" = LocalProxy(lambda: _security.pwd_context) # type: ignore
+
+_hashing_context: "CryptContext" = LocalProxy( # type: ignore
+ lambda: _security.hashing_context
+)
+
+DecoratedView = t.Callable[..., t.Any]
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/py.typed b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/quart_compat.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/quart_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f90c3718691867ea3a53fdddb76522510974233
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/quart_compat.py
@@ -0,0 +1,37 @@
+"""
+ flask_security.quart_compat
+ ~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security quart compatibility modiles
+
+ :copyright: (c) 2019 by Shinon.
+ :license: MIT, see LICENSE for more details.
+
+ This modules tests whether we are using quart or not
+ we can test if the name of the imported flask is: quart.flask_patch
+"""
+
+import flask
+
+if "quart." in flask.__name__ or hasattr(flask, "_quart_patched"): # pragma: no cover
+ is_quart = True
+else:
+ is_quart = False
+
+
+@property # type: ignore
+def best(self): # pragma: no cover
+ options = sorted(
+ self.options,
+ key=lambda option: (option.value != "*", option.quality, option.value),
+ reverse=True,
+ )
+ return options[0].value
+
+
+def get_quart_status():
+ """
+ Tests if we are using Quart Patched Flask or Vanilla Flask.
+ :return: boolean value determining if it is quart patched flask or not
+ """
+ return is_quart
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/recoverable.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/recoverable.py
new file mode 100644
index 0000000000000000000000000000000000000000..682220ad252c257ac9e4439c080721cef234f748
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/recoverable.py
@@ -0,0 +1,116 @@
+"""
+ flask_security.recoverable
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security recoverable module
+
+ :copyright: (c) 2012 by Matt Wright.
+ :copyright: (c) 2019-2023 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+"""
+
+from flask import current_app
+from .proxies import _security, _datastore
+from .signals import password_reset, reset_password_instructions_sent
+from .utils import (
+ config_value,
+ get_token_status,
+ hash_data,
+ hash_password,
+ send_mail,
+ url_for_security,
+ verify_hash,
+)
+
+
+def send_reset_password_instructions(user):
+ """Sends the reset password instructions email for the specified user.
+
+ :param user: The user to send the instructions to
+ """
+ token = generate_reset_password_token(user)
+ reset_link = url_for_security("reset_password", token=token, _external=True)
+
+ if config_value("SEND_PASSWORD_RESET_EMAIL"):
+ send_mail(
+ config_value("EMAIL_SUBJECT_PASSWORD_RESET"),
+ user.email,
+ "reset_instructions",
+ user=user,
+ reset_link=reset_link,
+ reset_token=token,
+ )
+
+ reset_password_instructions_sent.send(
+ current_app._get_current_object(),
+ _async_wrapper=current_app.ensure_sync,
+ user=user,
+ token=token,
+ reset_token=token,
+ )
+
+
+def send_password_reset_notice(user):
+ """Sends the password reset notice email for the specified user.
+
+ :param user: The user to send the notice to
+ """
+ if config_value("SEND_PASSWORD_RESET_NOTICE_EMAIL"):
+ send_mail(
+ config_value("EMAIL_SUBJECT_PASSWORD_NOTICE"),
+ user.email,
+ "reset_notice",
+ user=user,
+ )
+
+
+def generate_reset_password_token(user):
+ """Generates a unique reset password token for the specified user.
+
+ :param user: The user to work with
+ """
+ password_hash = hash_data(user.password) if user.password else None
+ data = [str(user.fs_uniquifier), password_hash]
+ return _security.reset_serializer.dumps(data)
+
+
+def reset_password_token_status(token):
+ """Returns the expired status, invalid status, and user of a password reset
+ token. For example::
+
+ expired, invalid, user, data = reset_password_token_status('...')
+
+ :param token: The password reset token
+ """
+ expired, invalid, user, data = get_token_status(
+ token, "reset", "RESET_PASSWORD", return_data=True
+ )
+ # This check looks to see if the password has been changed since the reset token
+ # was created. As of #338 - we reset the fs_uniquifier on each password change
+ # so the token would have been marked invalid above.
+ # This made sure that the token couldn't be used twice.
+ # TODO - look at removing this entire check.
+ if not invalid and user:
+ if user.password:
+ if not verify_hash(data[1], user.password):
+ invalid = True
+
+ return expired, invalid, user
+
+
+def update_password(user, password):
+ """Update the specified user's password
+
+ :param user: The user to update_password
+ :param password: The unhashed new password
+ """
+ user.password = hash_password(password)
+ # Change uniquifier - this will cause ALL sessions to be invalidated.
+ _datastore.set_uniquifier(user)
+ _datastore.put(user)
+ send_password_reset_notice(user)
+ password_reset.send(
+ current_app._get_current_object(),
+ _async_wrapper=current_app.ensure_sync,
+ user=user,
+ )
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/recovery_codes.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/recovery_codes.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ac689a5709b6209cbec913ab540f073cba12545
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/recovery_codes.py
@@ -0,0 +1,249 @@
+"""
+ flask_security.recovery_codes
+ ~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security Recovery Codes Module
+
+ :copyright: (c) 2022-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import typing as t
+
+from flask import after_this_request, request, redirect
+from flask_login import current_user
+
+
+from .decorators import anonymous_user_required, auth_required, unauth_csrf
+from .forms import (
+ build_form_from_request,
+ get_form_field_label,
+ get_form_field_xlate,
+ Form,
+ Required,
+ StringField,
+ SubmitField,
+)
+from .proxies import _datastore, _security
+from .tf_plugin import tf_check_state, tf_illegal_state
+from .utils import (
+ _,
+ base_render_json,
+ config_value as cv,
+ get_message,
+ get_post_login_redirect,
+ view_commit,
+)
+
+if t.TYPE_CHECKING: # pragma: no cover
+ from cryptography.fernet import MultiFernet
+ import flask
+ from flask.typing import ResponseValue
+ from .datastore import User
+
+
+class MfRecoveryCodesUtil:
+ """Handle creation, checking, encrypting and decrypting recovery codes.
+ Since these are rarely used - keep them encrypted until needed - yes
+ if someone gets access to memory they can find the key...
+ """
+
+ def __init__(self, app: flask.Flask):
+ self.cryptor: MultiFernet | None = None
+ keys = cv("MULTI_FACTOR_RECOVERY_CODES_KEYS", app)
+ # N.B. order is important - first key is 'primary'.
+ if keys:
+ self.setup_cryptor(keys)
+
+ def setup_cryptor(self, keys: list[bytes]) -> None:
+ from cryptography.fernet import Fernet, MultiFernet
+
+ cryptors: list[Fernet] = []
+ for key in keys:
+ cryptors.append(Fernet(key))
+ self.cryptor = MultiFernet(cryptors)
+
+ def create_recovery_codes(self, user: User) -> list[str]:
+ # Create new recovery codes and store in user record.
+ # If configured codes are stored encrypted - but plainttext
+ # versions are returned.
+ new_codes = _security._totp_factory.generate_recovery_codes(
+ cv("MULTI_FACTOR_RECOVERY_CODES_N")
+ )
+ _datastore.mf_set_recovery_codes(user, self.encrypt_codes(new_codes))
+ return new_codes
+
+ def get_recovery_codes(self, user: User) -> list[str]:
+ ecodes = _datastore.mf_get_recovery_codes(user)
+ return self.decrypt_codes(ecodes)
+
+ def check_recovery_code(self, user: User, code: str) -> bool:
+ # Verify code is valid
+ codes = _datastore.mf_get_recovery_codes(user)
+ dcodes = self.decrypt_codes(codes)
+ return code in dcodes
+
+ def delete_recovery_code(self, user: User, code: str) -> bool:
+ # codes are single use - so delete after use.
+ # encrypting code gives different answer due to time stamp.
+ # we don't want to re-encrypt other codes.
+ codes = _datastore.mf_get_recovery_codes(user)
+ if self.cryptor:
+ codes = self.decrypt_codes(codes)
+ idx = codes.index(code)
+ return _datastore.mf_delete_recovery_code(user, idx)
+
+ def encrypt_codes(self, codes: list[str]) -> list[str]:
+ if not self.cryptor:
+ return codes
+ ecodes = []
+ for code in codes:
+ ecodes.append(self.cryptor.encrypt(code.encode()).decode())
+ return ecodes
+
+ def decrypt_codes(self, codes: list[str]) -> list[str]:
+ from cryptography.fernet import InvalidToken
+
+ if not self.cryptor:
+ return codes
+ dcodes = []
+ for code in codes:
+ try:
+ dcode = self.cryptor.decrypt(
+ code.encode(), cv("MULTI_FACTOR_RECOVERY_CODE_TTL")
+ )
+ dcodes.append(dcode.decode())
+ except InvalidToken:
+ # should we delete this?
+ pass
+ return dcodes
+
+
+class MfRecoveryCodesForm(Form):
+ """Generate and fetch recovery codes"""
+
+ # show_codes is a GET option., generate_new_codes is a POST option
+ show_codes = SubmitField(get_form_field_xlate(_("Show Recovery Codes")))
+ generate_new_codes = SubmitField(
+ get_form_field_xlate(_("Generate New Recovery Codes"))
+ )
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs): # pragma: no cover
+ return False
+ return True
+
+
+class MfRecoveryForm(Form):
+ """Accept recovery code for second factor authentication"""
+
+ code = StringField(
+ get_form_field_xlate(_("Recovery Code")),
+ validators=[Required()],
+ )
+ submit = SubmitField(get_form_field_label("submitcode"))
+
+ def __init__(self, *args: t.Any, **kwargs: t.Any):
+ super().__init__(*args, **kwargs)
+ # filled by view
+ self.user: User | None = None
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs): # pragma: no cover
+ return False
+ assert self.user is not None
+ if not _security._mf_recovery_codes_util.check_recovery_code(
+ self.user, self.code.data
+ ):
+ self.code.errors.append(get_message("INVALID_RECOVERY_CODE")[0])
+ return False
+ return True
+
+
+@auth_required(
+ lambda: cv("API_ENABLED_METHODS"),
+ within=lambda: cv("FRESHNESS"),
+ grace=lambda: cv("FRESHNESS_GRACE_PERIOD"),
+)
+def mf_recovery_codes() -> ResponseValue:
+ """
+ Create and download multi-factor recovery codes.
+ For forms, we want the user to explicitly request to see the codes - so
+ the form has a show_codes submit button.
+ """
+ form = t.cast(
+ MfRecoveryCodesForm, build_form_from_request("mf_recovery_codes_form")
+ )
+
+ if form.validate_on_submit():
+ # generate new codes
+ codes = _security._mf_recovery_codes_util.create_recovery_codes(current_user)
+ after_this_request(view_commit)
+ if _security._want_json(request):
+ payload = dict(recovery_codes=codes)
+ return base_render_json(form, include_user=False, additional=payload)
+ return _security.render_template(
+ cv("MULTI_FACTOR_RECOVERY_CODES_TEMPLATE"),
+ mf_recovery_codes_form=form,
+ recovery_codes=codes,
+ **_security._run_ctx_processor("mf_recovery_codes"),
+ )
+
+ codes = _security._mf_recovery_codes_util.get_recovery_codes(current_user)
+ if _security._want_json(request):
+ return base_render_json(
+ form, include_user=False, additional=dict(recovery_codes=codes)
+ )
+ show_codes = request.args.get("show_codes", False)
+ if show_codes and not codes:
+ form.show_codes.errors = []
+ form.show_codes.errors.append(get_message("NO_RECOVERY_CODES_SETUP")[0])
+ return _security.render_template(
+ cv("MULTI_FACTOR_RECOVERY_CODES_TEMPLATE"),
+ mf_recovery_codes_form=form,
+ recovery_codes=codes if show_codes else [],
+ **_security._run_ctx_processor("mf_recovery_codes"),
+ )
+
+
+@anonymous_user_required
+@unauth_csrf()
+def mf_recovery():
+ """View for entering a recovery code.
+
+ User must have already provided valid username/password.
+ User must have already established 2FA
+
+ """
+ form = t.cast(MfRecoveryForm, build_form_from_request("mf_recovery_form"))
+ form.user = tf_check_state(["ready"])
+ if not form.user:
+ return tf_illegal_state(form, cv("TWO_FACTOR_ERROR_VIEW"))
+
+ if form.validate_on_submit():
+ # Valid code - we want these to be one time - so remove it from list
+ _security._mf_recovery_codes_util.delete_recovery_code(
+ form.user, form.code.data
+ )
+ after_this_request(view_commit)
+
+ # In the recovery case - don't set/offer validity token.
+ _security.two_factor_plugins.tf_complete(form.user, True)
+
+ if not _security._want_json(request):
+ return redirect(get_post_login_redirect())
+ else:
+ return base_render_json(form)
+
+ if _security._want_json(request):
+ return base_render_json(form, include_user=False)
+ return _security.render_template(
+ cv("MULTI_FACTOR_RECOVERY_TEMPLATE"),
+ mf_recovery_form=form,
+ **_security._run_ctx_processor("mf_recovery"),
+ )
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/registerable.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/registerable.py
new file mode 100644
index 0000000000000000000000000000000000000000..db9d22a51b71284be060e4cd6a603def2defa0a9
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/registerable.py
@@ -0,0 +1,176 @@
+"""
+ flask_security.registerable
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security registerable module
+
+ :copyright: (c) 2012 by Matt Wright.
+ :copyright: (c) 2019-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import typing as t
+
+from flask import current_app
+
+from .confirmable import generate_confirmation_link
+from .forms import form_errors_munge
+from .proxies import _security, _datastore
+from .signals import user_registered, user_not_registered
+from .utils import (
+ config_value as cv,
+ do_flash,
+ get_message,
+ hash_password,
+ send_mail,
+ url_for_security,
+)
+
+if t.TYPE_CHECKING:
+ from .forms import ConfirmRegisterForm
+
+
+def register_user(registration_form):
+ """
+ Calls datastore to create user, triggers post-registration logic
+ (e.g. sending confirmation link, sending registration mail)
+ :param registration_form: form with user registration data
+ :return: user instance
+ """
+
+ user_model_kwargs = registration_form.to_dict(only_user=True)
+
+ # passwords are not always required -
+ # with UNIFIED_SIGNIN and PASSWORD_REQUIRED=False
+ if user_model_kwargs["password"]:
+ user_model_kwargs["password"] = hash_password(user_model_kwargs["password"])
+ user = _datastore.create_user(**user_model_kwargs)
+
+ # if they didn't give a password - auto-setup email magic links (if UNIFIED SIGNIN)
+ if not user_model_kwargs["password"] and cv("UNIFIED_SIGNIN"):
+ _datastore.us_setup_email(user)
+
+ confirmation_link, token = None, None
+ if _security.confirmable:
+ confirmation_link, token = generate_confirmation_link(user)
+ do_flash(*get_message("CONFIRM_REGISTRATION", email=user.email))
+
+ user_registered.send(
+ current_app._get_current_object(),
+ _async_wrapper=current_app.ensure_sync,
+ user=user,
+ confirm_token=token,
+ confirmation_token=token,
+ form_data=registration_form.to_dict(only_user=False),
+ )
+
+ if cv("SEND_REGISTER_EMAIL"):
+ send_mail(
+ cv("EMAIL_SUBJECT_REGISTER"),
+ user.email,
+ "welcome",
+ user=user,
+ confirmation_link=confirmation_link,
+ confirmation_token=token,
+ )
+
+ return user
+
+
+def register_existing(form: ConfirmRegisterForm) -> bool:
+ """
+ In the case of generic responses we want to mitigate any possible
+ email/username enumeration.
+ For an existing email we send an email to that address and tell them they
+ are already registered (and provide their username if any).
+
+ N.B. This (and forgot and confirm) could be used to DDOS an email by constantly
+ issuing requests. One way to mitigate that is to use signals and add specific
+ application code.
+
+ Returning False means to return normal error messages.
+ Returns True if the only 'error' is an existing email/user. In this case we
+ simulate a normal registration and email the existing account to inform.
+
+ """
+
+ if not (
+ cv("RETURN_GENERIC_RESPONSES")
+ or form.existing_username_user
+ or form.existing_email_user
+ ): # pragma: no cover
+ return False
+
+ # There are 2 classes of error - an existing email/username and non-compliant
+ # email/username/password. We want to give the user feedback on a non-compliant
+ # input - but not give away whether the email/username is already taken.
+ # Since in this case we have an 'existing' entry - we simply Null out those
+ # errors.
+ # This also means for JSON there is no way to tell if things worked or not.
+ fields_to_squash: dict[str, dict[str, str]] = dict()
+ if form.existing_email_user:
+ fields_to_squash["email"] = dict()
+ if hasattr(form, "username") and form.existing_username_user:
+ fields_to_squash["username"] = dict()
+ form_errors_munge(form, fields_to_squash)
+ if form.errors:
+ # some other illegal password/username - return an error
+ return False
+
+ # only errors were existing email/username
+ hash_password("not-a-password") # reduce timing between successful and not.
+
+ # Same as is done in register_user()
+ if _security.confirmable:
+ do_flash(*get_message("CONFIRM_REGISTRATION", email=form.email.data))
+
+ # 2 cases:
+ # 1) existing email (an already registered account) empty or same username
+ # 2) new email with existing username (which corresponds to some OTHER account)
+
+ if form.existing_email_user:
+ user_not_registered.send(
+ current_app._get_current_object(), # type: ignore
+ _async_wrapper=current_app.ensure_sync,
+ user=form.existing_email_user,
+ existing_email=True,
+ existing_username=form.existing_username_user is not None,
+ form_data=form.to_dict(only_user=False),
+ )
+ # Send a nice email saying they are already registered - tell them their
+ # existing username if they have one, and suggest how to reset password.
+ recovery_link = None
+ if _security.recoverable:
+ recovery_link = url_for_security("forgot_password", _external=True)
+ if cv("SEND_REGISTER_EMAIL"):
+ send_mail(
+ cv("EMAIL_SUBJECT_REGISTER"),
+ form.existing_email_user.email,
+ "welcome_existing",
+ user=form.existing_email_user,
+ recovery_link=recovery_link,
+ )
+ elif form.existing_username_user:
+ # New email, already taken username.
+ # Note that we send email to NEW email - so it is possible for a bad-actor
+ # to enumerate usernames (slowly).
+ user_not_registered.send(
+ current_app._get_current_object(), # type: ignore[attr-defined]
+ _async_wrapper=current_app.ensure_sync,
+ user=None,
+ existing_email=False,
+ existing_username=True,
+ form_data=form.to_dict(only_user=False),
+ )
+ if cv("SEND_REGISTER_EMAIL"):
+ send_mail(
+ cv("EMAIL_SUBJECT_REGISTER"),
+ form.email.data,
+ "welcome_existing_username",
+ email=form.email.data,
+ username=form.username.data if hasattr(form, "username") else None,
+ )
+
+ return True
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/signals.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/signals.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb0bc5dd43b2cbbe6155a4f510e29beb9ae1a14a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/signals.py
@@ -0,0 +1,51 @@
+"""
+ flask_security.signals
+ ~~~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security signals module
+
+ :copyright: (c) 2012 by Matt Wright.
+ :copyright: (c) 2019-2022 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+"""
+
+import blinker
+
+signals = blinker.Namespace()
+
+user_authenticated = signals.signal("user-authenticated")
+
+user_unauthenticated = signals.signal("user-unauthenticated")
+
+user_registered = signals.signal("user-registered")
+
+# For cases of RETURN_GENERIC_RESPONSES with existing email/username
+user_not_registered = signals.signal("user-not-registered")
+
+user_confirmed = signals.signal("user-confirmed")
+
+confirm_instructions_sent = signals.signal("confirm-instructions-sent")
+
+login_instructions_sent = signals.signal("login-instructions-sent")
+
+password_reset = signals.signal("password-reset")
+
+password_changed = signals.signal("password-changed")
+
+reset_password_instructions_sent = signals.signal("password-reset-instructions-sent")
+
+tf_code_confirmed = signals.signal("tf-code-confirmed")
+
+tf_profile_changed = signals.signal("tf-profile-changed")
+
+tf_security_token_sent = signals.signal("tf-security-token-sent")
+
+tf_disabled = signals.signal("tf-disabled")
+
+us_security_token_sent = signals.signal("us-security-token-sent")
+
+us_profile_changed = signals.signal("us-profile-changed")
+
+wan_registered = signals.signal("wan-registered")
+
+wan_deleted = signals.signal("wan-deleted")
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/tf_plugin.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/tf_plugin.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed500f1b43a831c7052a068279db464d42443f31
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/tf_plugin.py
@@ -0,0 +1,354 @@
+"""
+ flask_security.tf_plugin
+ ~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security Two-Factor Plugin Module
+
+ :copyright: (c) 2022-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+
+ TODO:
+ - add localized callback for select choices.
+"""
+
+from __future__ import annotations
+
+import typing as t
+
+from flask import request, redirect, session
+
+from .decorators import unauth_csrf
+from .forms import (
+ build_form_from_request,
+ get_form_field_xlate,
+ Form,
+ RadioField,
+ SubmitField,
+)
+from .proxies import _datastore, _security
+from .utils import (
+ _,
+ base_render_json,
+ check_and_get_token_status,
+ config_value as cv,
+ do_flash,
+ get_message,
+ get_within_delta,
+ get_url,
+ login_user,
+ propagate_next,
+ simple_render_json,
+ url_for_security,
+)
+
+if t.TYPE_CHECKING: # pragma: no cover
+ import flask
+ from flask.typing import ResponseValue
+ from flask import Response
+ from .core import Security
+ from .datastore import User
+
+
+class TwoFactorSelectForm(Form):
+ which = RadioField(get_form_field_xlate(_("Available Second Factor Methods:")))
+ submit = SubmitField(get_form_field_xlate(_("Select")))
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+
+
+@unauth_csrf()
+def tf_select() -> ResponseValue:
+ # Ask user which MFA method they want to use.
+ # This is used when a user has setup more than one type of 2FA.
+ form = t.cast(
+ TwoFactorSelectForm, build_form_from_request("two_factor_select_form")
+ )
+
+ # This endpoint is unauthenticated - make sure we're in a valid state
+ if not all(k in session for k in ["tf_user_id", "tf_select"]):
+ # illegal call on this endpoint
+ tf_clean_session()
+ return tf_illegal_state(form, cv("TWO_FACTOR_ERROR_VIEW"))
+
+ user = _datastore.find_user(fs_uniquifier=session["tf_user_id"])
+ if not user: # pragma no cover
+ # hard to imagine - someone deletes the user while they are logging in.
+ tf_clean_session()
+ return tf_illegal_state(form, cv("TWO_FACTOR_ERROR_VIEW"))
+
+ setup_methods = _security.two_factor_plugins.get_setup_tf_methods(user)
+ form.which.choices = setup_methods
+
+ if form.validate_on_submit():
+ response = None
+ tf_impl = _security.two_factor_plugins.method_to_impl(user, form.which.data)
+ if tf_impl:
+ json_payload = {"tf_required": True}
+ response = tf_impl.tf_login(
+ user, json_payload, next_loc=propagate_next(request.url, None)
+ )
+ if not response: # pragma no cover
+ # This really can't happen unless between the time the started logging in
+ # and now, they deleted a second factor (which they would have to do
+ # in another window).
+ tf_clean_session()
+ return tf_illegal_state(form, cv("TWO_FACTOR_ERROR_VIEW"))
+ return response
+
+ if _security._want_json(request):
+ payload = {"tf_select": True, "tf_setup_methods": setup_methods}
+ return base_render_json(form, include_user=False, additional=payload)
+
+ return _security.render_template(
+ cv("TWO_FACTOR_SELECT_TEMPLATE"),
+ two_factor_select_form=form,
+ **_security._run_ctx_processor("tf_select"),
+ )
+
+
+class TfPluginBase: # pragma no cover
+ def __init__(self, app: flask.Flask):
+ pass
+
+ def create_blueprint(
+ self, app: flask.Flask, bp: flask.Blueprint, state: Security
+ ) -> None:
+ raise NotImplementedError
+
+ def get_setup_methods(self, user: User) -> list[str]:
+ """
+ Return a list of methods that ``user`` has setup for this second factor
+ """
+ raise NotImplementedError
+
+ def tf_login(
+ self, user: User, json_payload: dict[str, t.Any], next_loc: str | None
+ ) -> ResponseValue:
+ """
+ Called from first/primary authenticated views if the user successfully
+ authenticated, and required a second method of authentication.
+ This method returns the necessary information for the user UI to continue.
+ For forms, this is usually a redirect to a secondary sign in form. For JSON
+ it is just a payload that describes what the user has to do next.
+ """
+ raise NotImplementedError
+
+
+class TfPlugin:
+ """
+ Two-Factor plugin support.
+
+ Enables multiple independent two-factor implementations to be configured for a given
+ app. See TfPluginBase for what a new implementation must provide.
+ """
+
+ def __init__(self) -> None:
+ self._tf_impls: dict[str, TfPluginBase] = {}
+
+ def register_tf_impl(
+ # N.B. all methods must be unique across all implementations.
+ self,
+ app: flask.Flask,
+ name: str,
+ impl: t.Type[TfPluginBase],
+ ) -> None:
+ self._tf_impls[name] = impl(app)
+
+ def create_blueprint(
+ self, app: flask.Flask, bp: flask.Blueprint, state: Security
+ ) -> None:
+ if state.support_mfa:
+ for impl in self._tf_impls.values():
+ impl.create_blueprint(app, bp, state)
+ # Add our route for selecting between multiple active two-factor
+ # mechanisms.
+ bp.route(
+ cv("TWO_FACTOR_SELECT_URL", app),
+ methods=["GET", "POST"],
+ endpoint="tf_select",
+ )(tf_select)
+
+ def method_to_impl(self, user: User, method: str) -> TfPluginBase | None:
+ # reverse map a method to the implementation.
+ # N.B. again - requires that methods be unique across all implementations.
+ # There is a small window that a previously setup method was removed.
+ for impl in self._tf_impls.values():
+ setup_methods = impl.get_setup_methods(user)
+ if method in setup_methods:
+ return impl
+ return None # pragma no cover
+
+ def get_setup_tf_methods(self, user: User) -> list[str]:
+ # Return list of methods that user has setup
+ methods = []
+ for impl in self._tf_impls.values():
+ methods.extend(impl.get_setup_methods(user))
+ return methods
+
+ def tf_enter(
+ self,
+ user: User,
+ remember_me: bool,
+ primary_authn_via: str,
+ next_loc: str | None,
+ ) -> ResponseValue | None:
+ """Check if two-factor is required and if so, start the process.
+ Must be called in a request context.
+ remember_me controls 2 cookies - the remember_me cookie and the tf_validity
+ cookie. We use the session to hold the fact that the user requested 'remember'
+ across the second factor.
+ """
+ json_payload: dict[str, t.Any]
+ if _security.support_mfa:
+ tf_setup_methods = self.get_setup_tf_methods(user)
+ if cv("TWO_FACTOR_REQUIRED") or len(tf_setup_methods) > 0:
+ tf_fresh = tf_verify_validity_token(user.fs_uniquifier)
+ if cv("TWO_FACTOR_ALWAYS_VALIDATE") or not tf_fresh:
+ # Clean out any potential old session info - in case of previous
+ # aborted 2FA attempt.
+ tf_clean_session()
+
+ json_payload = {"tf_required": True}
+ if remember_me:
+ session["tf_remember_login"] = remember_me
+
+ session["tf_user_id"] = user.fs_uniquifier
+ # A backwards compat hack - the original twofactor could be setup
+ # as part of initial login.
+ if len(tf_setup_methods) == 0:
+ # only initial two-factor implementation supports this
+ return self._tf_impls["code"].tf_login(
+ user, json_payload, next_loc
+ )
+ elif len(tf_setup_methods) == 1:
+ # method_to_impl can't return None here since we just
+ # got the methods up above.
+ impl = t.cast(
+ TfPluginBase,
+ self.method_to_impl(user, tf_setup_methods[0]),
+ )
+ return impl.tf_login(user, json_payload, next_loc)
+ else:
+ session["tf_select"] = True
+ if not _security._want_json(request):
+ values = dict(next=next_loc) if next_loc else dict()
+ return redirect(url_for_security("tf_select", **values))
+ # Let's force app to go through tf-select just in case we want
+ # to do further validation... However, provide the choices
+ # so they can just do a POST
+ json_payload.update(
+ {
+ "tf_select": True,
+ "tf_setup_methods": tf_setup_methods,
+ }
+ )
+ return simple_render_json(json_payload)
+ return None
+
+ def tf_complete(self, user: User, dologin: bool) -> str | None:
+ remember = session.pop("tf_remember_login", None)
+
+ if dologin:
+ login_user(user, remember=remember)
+ tf_clean_session()
+ token = None
+ # return a token to avoid future two-factor prompts (for a period of time)
+ if not cv("TWO_FACTOR_ALWAYS_VALIDATE") and remember:
+ token = generate_tf_validity_token(user.fs_uniquifier)
+ return token
+
+
+def generate_tf_validity_token(fs_uniquifier):
+ """Generates a unique token for the specified user.
+
+ :param fs_uniquifier: The fs_uniquifier of a user to whom the token belongs to
+ """
+ return _security.tf_validity_serializer.dumps(fs_uniquifier)
+
+
+def tf_validity_token_status(token):
+ """Returns the expired status, invalid status, and user of a
+ Two-Factor Validity token.
+ For example::
+
+ expired, invalid, user = tf_validity_token_status('...')
+
+ :param token: The Two-Factor Validity token
+ """
+ return check_and_get_token_status(
+ token, "tf_validity", get_within_delta("TWO_FACTOR_LOGIN_VALIDITY")
+ )
+
+
+def tf_verify_validity_token(fs_uniquifier: str) -> bool:
+ """Returns the status of the Two-Factor Validity token based on the current
+ request.
+
+ :param fs_uniquifier: The ``fs_uniquifier`` of the submitting user.
+ """
+ token = request.cookies.get("tf_validity", default=None)
+ if token is None:
+ return False
+
+ expired, invalid, uniquifier = tf_validity_token_status(token)
+ if expired or invalid or (fs_uniquifier != uniquifier):
+ return False
+
+ return True
+
+
+def tf_set_validity_token_cookie(response: Response, token: str) -> Response:
+ """Sets the Two-Factor validity token for a specific user given that is
+ configured and the user selects remember me
+
+ :param response: The response with which to set the set_cookie
+ :param token: validity token
+ """
+ cookie_kwargs = cv("TWO_FACTOR_VALIDITY_COOKIE")
+ max_age = int(get_within_delta("TWO_FACTOR_LOGIN_VALIDITY").total_seconds())
+ response.set_cookie("tf_validity", value=token, max_age=max_age, **cookie_kwargs)
+ # This is likely overkill since so far we only return this on a POST which is
+ # unlikely to be cached.
+ response.vary.add("Cookie")
+ return response
+
+
+def tf_check_state(allowed_states: list[str]) -> User | None:
+ if (
+ not all(k in session for k in ["tf_user_id", "tf_state"])
+ or session["tf_state"] not in allowed_states
+ ):
+ tf_clean_session()
+ return None
+
+ user = _datastore.find_user(fs_uniquifier=session["tf_user_id"])
+ if not user:
+ tf_clean_session()
+ return user
+
+
+def tf_illegal_state(form, redirect_to):
+ m, c = get_message("TWO_FACTOR_PERMISSION_DENIED")
+ if not _security._want_json(request):
+ do_flash(m, c)
+ return redirect(get_url(redirect_to))
+ else:
+ form.form_errors.append(m)
+ return base_render_json(form, include_user=False)
+
+
+def tf_clean_session():
+ """
+ Clean out ALL stuff stored in session (e.g. on logout or restart of a session)
+ """
+ if cv("TWO_FACTOR"):
+ for k in [
+ "tf_state",
+ "tf_user_id",
+ "tf_primary_method",
+ "tf_remember_login",
+ "tf_totp_secret",
+ "tf_select",
+ ]:
+ session.pop(k, None)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/totp.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/totp.py
new file mode 100644
index 0000000000000000000000000000000000000000..c9af7761a805d0f6031d589c49f83a7ff366a9fa
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/totp.py
@@ -0,0 +1,193 @@
+"""
+ flask_security.totp
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security TOTP (Timed-One-Time-Passwords) module
+
+ :copyright: (c) 2019-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import base64
+import io
+import typing as t
+
+from passlib.totp import TOTP, TokenError, TotpMatch
+from passlib.pwd import genword
+
+if t.TYPE_CHECKING: # pragma: no cover
+ from .datastore import User
+
+
+class Totp:
+ """Encapsulate usage of Passlib TOTP functionality.
+
+ Flask-Security doesn't implement any replay-attack protection out of the box
+ as suggested by:
+ https://passlib.readthedocs.io/en/stable/narr/totp-tutorial.html#match-verify
+
+ Subclass this and implement the get/set last_counter methods. Your subclass can
+ be registered at Flask-Security creation/initialization time.
+
+ .. versionadded:: 3.4.0
+
+ """
+
+ def __init__(self, secrets: dict[str | int, str], issuer: str):
+ """Initialize a totp factory.
+ secrets are used to encrypt the per-user totp_secret on disk.
+ """
+ # This should be a dict with at least one entry
+ if not isinstance(secrets, dict) or len(secrets) < 1:
+ raise ValueError("secrets needs to be a dict with at least one entry")
+ self._totp = TOTP.using(issuer=issuer, secrets=secrets)
+
+ def generate_totp_password(self, totp_secret: str) -> str:
+ """Get time-based one-time password on the basis of given secret and time
+ :param totp_secret: the unique shared secret of the user
+ """
+ return self._totp.from_source(totp_secret).generate().token
+
+ def generate_totp_secret(self) -> str:
+ """Create new user-unique totp_secret.
+
+ We return an encrypted json string so that when sent in a cookie or
+ sent to DB - it is encrypted.
+
+ """
+ return self._totp.new().to_json(encrypt=True)
+
+ def verify_totp(
+ self, token: str, totp_secret: str, user: User, window: int = 0
+ ) -> bool:
+ """Verifies token for specific user.
+
+ :param token: token to be check against user's secret
+ :param totp_secret: the unique shared secret of the user
+ :param user: User model
+ :param window: optional. How far backward and forward in time to search
+ for a match. Measured in seconds.
+ :return: True if match
+ """
+
+ # TODO - in old implementation using onetimepass window was described
+ # as 'compensate for clock skew) and 'interval_length' would say how long
+ # the token is good for.
+ # In passlib - 'window' means how far back and forward to look and 'clock_skew'
+ # is specifically for well, clock slew.
+ try:
+ tmatch = self._totp.verify(
+ token,
+ totp_secret,
+ window=window,
+ last_counter=self.get_last_counter(user),
+ )
+ self.set_last_counter(user, tmatch)
+ return True
+
+ except TokenError:
+ return False
+
+ def get_totp_uri(self, username: str, totp_secret: str) -> str:
+ """Generate provisioning url for use with the qrcode
+ scanner built into the app
+
+ :param username: username/email of the current user
+ :param totp_secret: a unique shared secret of the user
+ """
+ tp = self._totp.from_source(totp_secret)
+ return tp.to_uri(username)
+
+ def get_totp_pretty_key(self, totp_secret: str) -> str:
+ """Generate pretty key for manual input
+
+ :param totp_secret: a unique shared secret of the user
+
+ .. versionadded:: 4.0.0
+ """
+ tp = self._totp.from_source(totp_secret)
+ return tp.pretty_key()
+
+ def fetch_setup_values(self, totp: str, user: User) -> dict[str, str]:
+ """Generate various values user needs to setup authenticator app.
+ Returns dict with keys:
+ 'key': totp key
+ 'image': image as string (useful for 
)
+ 'username: qrcode best practice
+ 'issuer': qrcode best practice
+
+ .. versionadded:: 4.0.0
+ """
+
+ r = dict()
+
+ # By convention, the URI should have the username that the user
+ # logs in with.
+ username = user.calc_username() or "Unknown"
+ r["username"] = username
+ r["key"] = self.get_totp_pretty_key(totp)
+ r["issuer"] = self._totp.issuer
+ r["image"] = self.generate_qrcode(username, totp)
+ return r
+
+ def generate_qrcode(self, username: str, totp: str) -> str:
+ """Generate QRcode
+ Using username, totp, generate the actual QRcode image.
+ This method can be overridden to fine-tune how the image is created -
+ such as size, color etc.
+
+ It must return a string suitable for use in an tag.
+
+ .. versionadded:: 4.0.0
+ """
+ try:
+ import qrcode
+ import qrcode.image.svg
+
+ image = qrcode.make(
+ self.get_totp_uri(username, totp),
+ image_factory=qrcode.image.svg.SvgImage,
+ )
+ with io.BytesIO() as virtual_file:
+ image.save(virtual_file)
+ image_as_str = base64.b64encode(virtual_file.getvalue()).decode("ascii")
+
+ return f"data:image/svg+xml;base64,{image_as_str}"
+ except ImportError: # pragma: no cover
+ # This should have been checked at app init.
+ raise
+
+ def generate_recovery_codes(self, number: int) -> list[str]:
+ """Generate a set of secure passwords - used for 2FA recovery codes.
+ # this is nice for english - but not for others
+ return genphrase(entropy="fair", wordset="eff_short", sep="-",
+ returns=number)
+
+ .. versionadded:: 5.0.0
+ """
+ pwds = genword(length=12, charset="hex", returns=number)
+ # make this a bit easier to type - 3 sets of 4 characters
+ spwds = []
+ for pwd in pwds:
+ spwds.append(
+ "-".join([pwd[i : i + 4] for i in range(0, len(pwd), 4)]) # noqa: E203
+ )
+ return spwds
+
+ def get_last_counter(self, user: User) -> TotpMatch | None:
+ """Implement this to fetch stored last_counter from cache.
+
+ :param user: User model
+ :return: last_counter as stored in set_last_counter()
+ """
+ return None
+
+ def set_last_counter(self, user: User, tmatch: TotpMatch) -> None:
+ """Implement this to cache last_counter.
+
+ :param user: User model
+ :param tmatch: a TotpMatch as returned from totp.verify()
+ """
+ pass
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/twofactor.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/twofactor.py
new file mode 100644
index 0000000000000000000000000000000000000000..921acc545de7192f1689b881570f1e65231ae9db
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/twofactor.py
@@ -0,0 +1,237 @@
+"""
+ flask_security.two_factor
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security two_factor module
+
+ :copyright: (c) 2016 by Gal Stainfeld, at Emedgene
+ :copyright: (c) 2019-2024 by J. Christopher Wagner (jwag).
+"""
+
+from __future__ import annotations
+
+import typing as t
+
+from flask import current_app, redirect, request, session
+
+from .forms import (
+ get_form_field_xlate,
+ DummyForm,
+ TwoFactorRescueForm,
+)
+from .proxies import _security, _datastore
+from .tf_plugin import TfPluginBase, tf_clean_session
+from .utils import (
+ _,
+ SmsSenderFactory,
+ base_render_json,
+ config_value as cv,
+ do_flash,
+ json_error_response,
+ send_mail,
+ url_for_security,
+)
+from .signals import (
+ tf_code_confirmed,
+ tf_disabled,
+ tf_security_token_sent,
+ tf_profile_changed,
+)
+
+if t.TYPE_CHECKING: # pragma: no cover
+ import flask
+ from .core import Security
+ from .datastore import User
+ from flask.typing import ResponseValue
+
+
+def tf_send_security_token(user, method, totp_secret, phone_number):
+ """Sends the security token via email/sms for the specified user.
+
+ :param user: The user to send the code to
+ :param method: The method in which the code will be sent
+ ('email' or 'sms', or 'authenticator') at the moment
+ :param totp_secret: a unique shared secret of the user
+ :param phone_number: If 'sms' phone number to send to
+
+ There is no return value - it is assumed that exceptions are thrown by underlying
+ methods that callers can catch.
+
+ Flask-Security code should NOT call this directly -
+ call :meth:`.UserMixin.tf_send_security_token`
+ """
+ token_to_be_sent = _security._totp_factory.generate_totp_password(totp_secret)
+ if method == "email" or method == "mail":
+ send_mail(
+ cv("EMAIL_SUBJECT_TWO_FACTOR"),
+ user.email,
+ "two_factor_instructions",
+ user=user,
+ token=token_to_be_sent,
+ username=user.calc_username(),
+ )
+ elif method == "sms":
+ msg = f"Use this code to log in: {token_to_be_sent}"
+ from_number = cv("SMS_SERVICE_CONFIG")["PHONE_NUMBER"]
+ to_number = phone_number
+ sms_sender = SmsSenderFactory.createSender(cv("SMS_SERVICE"))
+ sms_sender.send_sms(from_number=from_number, to_number=to_number, msg=msg)
+
+ else:
+ # password are generated automatically in the authenticator apps or not needed
+ token_to_be_sent = None
+
+ tf_security_token_sent.send(
+ current_app._get_current_object(),
+ _async_wrapper=current_app.ensure_sync,
+ user=user,
+ method=method,
+ token=token_to_be_sent,
+ login_token=token_to_be_sent,
+ phone_number=phone_number,
+ )
+
+
+def complete_two_factor_process(user, primary_method, totp_secret, is_changing):
+ """clean session according to process (login or changing two-factor method)
+ and perform action accordingly
+ """
+
+ _datastore.tf_set(user, primary_method, totp_secret=totp_secret)
+
+ # if we are changing two-factor method
+ dologin = False
+ if is_changing:
+ completion_message = "TWO_FACTOR_CHANGE_METHOD_SUCCESSFUL"
+ tf_profile_changed.send(
+ current_app._get_current_object(),
+ _async_wrapper=current_app.ensure_sync,
+ user=user,
+ method=primary_method,
+ )
+ # if we are logging in for the first time
+ else:
+ completion_message = "TWO_FACTOR_LOGIN_SUCCESSFUL"
+ tf_code_confirmed.send(
+ current_app._get_current_object(),
+ _async_wrapper=current_app.ensure_sync,
+ user=user,
+ method=primary_method,
+ )
+ dologin = True
+ token = _security.two_factor_plugins.tf_complete(user, dologin)
+ return completion_message, token
+
+
+def set_rescue_options(form: TwoFactorRescueForm, user: User) -> dict[str, str]:
+ # Based on config - set up options for rescue.
+ # Note that this modifies the passed in Form as well as returns
+ # a dict that can be returned as part of a JSON response.
+ recovery_options = dict(help=url_for_security("two_factor_rescue"))
+
+ if cv("TWO_FACTOR_RESCUE_EMAIL"):
+ recovery_options["email"] = url_for_security("two_factor_rescue")
+ form.help_setup.choices.append(
+ ("email", get_form_field_xlate(_("Send code via email")))
+ )
+
+ if (
+ _security.support_mfa
+ and cv("MULTI_FACTOR_RECOVERY_CODES")
+ and _datastore.mf_get_recovery_codes(user)
+ ):
+ recovery_options["recovery_code"] = url_for_security("mf_recovery")
+ form.help_setup.choices.append(
+ (
+ "recovery_code",
+ get_form_field_xlate(_("Use previously downloaded recovery code")),
+ )
+ )
+ return recovery_options
+
+
+def tf_disable(user):
+ """Disable two factor for user"""
+ tf_clean_session()
+ _datastore.tf_reset(user)
+ tf_disabled.send(
+ current_app._get_current_object(),
+ _async_wrapper=current_app.ensure_sync,
+ user=user,
+ )
+
+
+def is_tf_setup(user):
+ """Return True is user account is setup for 2FA."""
+ return user.tf_totp_secret and user.tf_primary_method
+
+
+class CodeTfPlugin(TfPluginBase):
+ def __init__(self, app: flask.Flask):
+ super().__init__(app)
+
+ def create_blueprint(
+ self, app: flask.Flask, bp: flask.Blueprint, state: Security
+ ) -> None:
+ pass
+
+ def get_setup_methods(self, user: User) -> list[str]:
+ if is_tf_setup(user):
+ assert user.tf_primary_method is not None
+ return [user.tf_primary_method]
+ return []
+
+ def tf_login(
+ self, user: User, json_payload: dict[str, t.Any], next_loc: str | None
+ ) -> ResponseValue:
+ """Helper for two-factor authentication login
+
+ This is called only when login/password have already been validated.
+ This can be from login, register, confirm, unified sign in, unified magic link.
+
+ If two-factor is already setup then this sends a code if the method requires it.
+ If not, then user is redirected to two-factor-setup.
+ In either case we do NOT log in user, so we must store some info in session to
+ track our state (including what user).
+ """
+
+ # if user's two-factor properties are not configured
+ if not is_tf_setup(user):
+ session["tf_state"] = "setup_from_login"
+ json_payload["tf_state"] = "setup_from_login"
+ if not _security._want_json(request):
+ return redirect(url_for_security("two_factor_setup"))
+
+ # if user's two-factor properties are configured
+ else:
+ session["tf_state"] = "ready"
+ json_payload["tf_state"] = "ready"
+ json_payload["tf_primary_method"] = user.tf_primary_method
+ json_payload["tf_method"] = user.tf_primary_method
+
+ if user.tf_primary_method in ["mail", "email", "sms"]:
+ msg = user.tf_send_security_token(
+ method=user.tf_primary_method,
+ totp_secret=user.tf_totp_secret,
+ phone_number=getattr(user, "tf_phone_number", None),
+ )
+ if msg:
+ # send code didn't work
+ if not _security._want_json(request):
+ # This is a mess -
+ # we are deep down in the login/unified sign in flow.
+ do_flash(msg, "error")
+ return redirect(url_for_security("login"))
+ else:
+ payload = json_error_response(errors=msg)
+ return _security._render_json(payload, 500, None, None)
+
+ if not _security._want_json(request):
+ values = dict(next=next_loc) if next_loc else dict()
+ return redirect(
+ url_for_security("two_factor_token_validation", **values)
+ )
+
+ # JSON response - Fake up a form - doesn't really matter which.
+ form = DummyForm(formdata=None)
+ return base_render_json(form, include_user=False, additional=json_payload)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/unified_signin.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/unified_signin.py
new file mode 100644
index 0000000000000000000000000000000000000000..f77585ea93113d310e4fe91fa150c2e85bbc80b2
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/unified_signin.py
@@ -0,0 +1,1069 @@
+"""
+ flask_security.unified_signin
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security Unified Signin module
+
+ :copyright: (c) 2019-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+
+ This implements a unified sign in endpoint - allowing
+ authentication via identity and passcode - where identity is configured
+ via SECURITY_USER_IDENTITY_ATTRIBUTES, and allowable passcodes are
+ one of US_ENABLED_METHODS.
+
+ Finish up:
+ - we should be able to add a phone number as part of setup even w/o any METHODS -
+ i.e. to allow login with any identity (phone) and a password.
+
+ Consider/Questions:
+ - Allow registering/confirming with just a phone number - this likely would require
+ a new register/confirm endpoint in order to implement verification.
+ - Right now ChangePassword won't work - it requires an existing password - so
+ if the user doesn't have one - can't change it. However ForgotPassword will in
+ fact allow the user to add a password. Is that sufficient?
+ - This also means that there is no way to REMOVE your password once it is setup,
+ although user can register without one.
+ - separate code validation times for SMS, email, authenticator?
+ - token versus code versus passcode? Confusing terminology.
+
+"""
+
+from __future__ import annotations
+
+import time
+import typing as t
+
+from flask import current_app
+from flask import after_this_request, request, session
+from flask_login import current_user
+from wtforms import (
+ BooleanField,
+ PasswordField,
+ RadioField,
+ SelectMultipleField,
+ StringField,
+ SubmitField,
+ TelField,
+ validators,
+)
+from wtforms.widgets import CheckboxInput
+
+from .confirmable import requires_confirmation
+from .decorators import anonymous_user_required, auth_required, unauth_csrf
+from .forms import (
+ _setup_methods_xlate,
+ Form,
+ NextFormMixin,
+ Required,
+ build_form_from_request,
+ build_form,
+ form_errors_munge,
+ generic_message,
+ get_form_field_label,
+ get_form_field_xlate,
+)
+from .proxies import _security, _datastore
+from .quart_compat import get_quart_status
+from .signals import us_profile_changed, us_security_token_sent
+from .utils import (
+ _,
+ SmsSenderFactory,
+ base_render_json,
+ check_and_get_token_status,
+ config_value as cv,
+ do_flash,
+ get_identity_attributes,
+ get_post_login_redirect,
+ get_post_verify_redirect,
+ get_message,
+ get_url,
+ get_within_delta,
+ is_user_authenticated,
+ localize_callback,
+ json_error_response,
+ login_user,
+ lookup_identity,
+ propagate_next,
+ send_mail,
+ url_for_security,
+ view_commit,
+)
+from .twofactor import tf_clean_session
+from .webauthn import has_webauthn
+
+if t.TYPE_CHECKING: # pragma: no cover
+ from flask.typing import ResponseValue
+ from .datastore import User
+
+if get_quart_status(): # pragma: no cover
+ from quart import redirect
+else:
+ from flask import redirect
+
+
+def _compute_code_methods():
+ # Return list of methods that actually send codes
+ return list(set(cv("US_ENABLED_METHODS")) - {"password", "authenticator"})
+
+
+def _compute_setup_methods():
+ # Return list of methods that require setup
+ return list(set(cv("US_ENABLED_METHODS")) - {"password"})
+
+
+def _compute_active_methods(user):
+ # Compute methods already setup.
+ active_methods = set(cv("US_ENABLED_METHODS")) & set(
+ _datastore.us_get_totp_secrets(user).keys()
+ )
+ if user.password:
+ active_methods = active_methods.union({"password"})
+ return list(active_methods)
+
+
+def _compute_active_code_methods(user):
+ return list(set(_compute_active_methods(user)) & set(_compute_code_methods()))
+
+
+def _us_common_validate(form):
+ # Be aware - this has side effect on the form - it will fill in
+ # the form.user
+
+ # Validate identity - we go in order to figure out which user attribute the
+ # request gave us. Note that we give up on the first 'match' even if that
+ # doesn't yield a user. Why?
+ form.user = lookup_identity(form.identity.data)
+ if not form.user:
+ form.identity.errors.append(get_message("US_SPECIFY_IDENTITY")[0])
+ return False
+ if not form.user.is_active:
+ form.identity.errors.append(get_message("DISABLED_ACCOUNT")[0])
+ return False
+ return True
+
+
+class _UnifiedPassCodeForm(Form):
+ """Common form for signin and verify/reauthenticate."""
+
+ # filled in by caller
+ user: User
+
+ # Filled in here
+ authn_via: str
+
+ # PasswordField so it doesn't show, no autocomplete since it might be a password
+ # but it might be a passcode.
+ passcode = PasswordField(
+ get_form_field_label("passcode"),
+ render_kw={
+ "placeholder": get_form_field_xlate(_("Code or Password")),
+ "autocomplete": "off",
+ },
+ )
+ submit = SubmitField(get_form_field_label("submit"))
+
+ chosen_method = RadioField(
+ _("Available Methods"),
+ choices=[
+ ("email", get_form_field_xlate(_("Via email"))),
+ ("sms", get_form_field_xlate(_("Via SMS"))),
+ ],
+ validators=[validators.Optional()],
+ )
+ submit_send_code = SubmitField(get_form_field_label("sendcode"))
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+ return True
+
+ def validate2(self) -> bool:
+ totp_secrets = _datastore.us_get_totp_secrets(self.user)
+ if self.submit.data:
+ # This is authn - verify passcode/password
+ # Since we have a unique totp_secret for each method - we
+ # can figure out which mechanism was used.
+ # Note that password check requires a string (not int or None)
+ passcode = self.passcode.data
+ if not passcode:
+ self.passcode.errors.append(get_message("INVALID_PASSWORD_CODE")[0])
+ return False
+ passcode = str(passcode)
+
+ ok = False
+ for method in cv("US_ENABLED_METHODS"):
+ if method == "password" and self.user.password:
+ passcode = _security._password_util.normalize(passcode)
+ if self.user.verify_and_update_password(passcode):
+ ok = True
+ break
+ else:
+ if method in totp_secrets and _security._totp_factory.verify_totp(
+ token=passcode,
+ totp_secret=totp_secrets[method],
+ user=self.user,
+ window=cv("US_TOKEN_VALIDITY"),
+ ):
+ ok = True
+ break
+ if not ok:
+ self.passcode.errors.append(get_message("INVALID_PASSWORD_CODE")[0])
+ return False
+
+ self.authn_via = method
+ return True
+ elif self.submit_send_code.data:
+ # Send a code - chosen_method must be valid
+ cm = self.chosen_method.data
+ if cm not in cv("US_ENABLED_METHODS"):
+ self.chosen_method.errors.append(
+ get_message("US_METHOD_NOT_AVAILABLE")[0]
+ )
+ return False
+ if cm not in totp_secrets:
+ self.chosen_method.errors.append(
+ get_message("US_METHOD_NOT_AVAILABLE")[0]
+ )
+ return False
+ if cm == "sms" and not self.user.us_phone_number:
+ # They need to us-setup!
+ self.chosen_method.errors.append(get_message("PHONE_INVALID")[0])
+ return False
+ return True
+ return False # pragma: no cover
+
+
+class UnifiedSigninForm(_UnifiedPassCodeForm, NextFormMixin):
+ """A unified login form
+ For either identity/password or request and enter code.
+ """
+
+ identity = StringField(
+ get_form_field_label("identity"),
+ validators=[Required()],
+ )
+ remember = BooleanField(get_form_field_label("remember_me"))
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.remember.default = cv("DEFAULT_REMEMBER_ME")
+ self.requires_confirmation = False
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+ if not _us_common_validate(self):
+ return False
+ if not super().validate2():
+ return False
+
+ # Can't authenticate nor get a code if still required confirmation.
+ self.requires_confirmation = requires_confirmation(self.user)
+ if self.requires_confirmation:
+ self.identity.errors.append(get_message("CONFIRMATION_REQUIRED")[0])
+ return False
+ return True
+
+
+class UnifiedVerifyForm(_UnifiedPassCodeForm):
+ """Verify authentication.
+ This is for freshness 'reauthentication' required.
+ """
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ self.user = current_user
+ if not super().validate(**kwargs):
+ return False
+ if not super().validate2():
+ return False
+ return True
+
+
+class UnifiedSigninSetupForm(Form):
+ """Setup form"""
+
+ setup_choices = [
+ ("email", get_form_field_label("email_method")),
+ (
+ "authenticator",
+ get_form_field_label("authapp_method"),
+ ),
+ ("sms", get_form_field_label("sms_method")),
+ ]
+ chosen_method = RadioField(
+ get_form_field_xlate(_("Setup additional sign in option")),
+ validate_choice=False,
+ )
+ delete_choices = [
+ ("email", get_form_field_xlate("Delete email option")),
+ (
+ "authenticator",
+ get_form_field_xlate("Delete authenticator option"),
+ ),
+ ("sms", get_form_field_xlate("Delete SMS option")),
+ ]
+
+ delete_method = SelectMultipleField(
+ get_form_field_xlate(_("Delete active sign in option")),
+ option_widget=CheckboxInput(),
+ validate_choice=False,
+ )
+ phone = TelField(get_form_field_label("phone"))
+ submit = SubmitField(get_form_field_label("submit"))
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+
+ if not self.chosen_method.data and not self.delete_method.data:
+ self.form_errors.append(get_message("API_ERROR")[0])
+ return False
+ if self.chosen_method.data:
+ if self.chosen_method.data not in cv("US_ENABLED_METHODS"):
+ self.chosen_method.errors.append(
+ get_message("US_METHOD_NOT_AVAILABLE")[0]
+ )
+ return False
+
+ if self.chosen_method.data == "sms":
+ msg = _security._phone_util.validate_phone_number(self.phone.data)
+ if msg:
+ self.phone.errors.append(msg)
+ return False
+ # As an identity attribute - it MUST be unique!
+ cphone = _security._phone_util.get_canonical_form(self.phone.data)
+ if _datastore.find_user(us_phone_number=cphone):
+ msg = get_message(
+ "IDENTITY_ALREADY_ASSOCIATED",
+ attr="us_phone_number",
+ value=cphone,
+ )[0]
+ self.phone.errors.append(msg)
+ return False
+ if self.delete_method.data:
+ if not all(
+ m in _compute_active_methods(current_user)
+ for m in self.delete_method.data
+ ):
+ self.delete_method.errors.append(
+ get_message("US_METHOD_NOT_AVAILABLE")[0]
+ )
+ return False
+
+ return True
+
+
+class UnifiedSigninSetupValidateForm(Form):
+ """The unified sign in setup validation form"""
+
+ # These 2 filled in by view
+ user: User
+ totp_secret: str
+
+ passcode = StringField(
+ get_form_field_label("passcode"),
+ render_kw={
+ "autocomplete": "one-time-code",
+ "inputtype": "numeric",
+ "pattern": "[0-9]*",
+ },
+ validators=[Required()],
+ )
+ submit = SubmitField(get_form_field_label("submitcode"))
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+
+ if not _security._totp_factory.verify_totp(
+ token=self.passcode.data,
+ totp_secret=self.totp_secret,
+ user=self.user,
+ window=cv("US_TOKEN_VALIDITY"),
+ ):
+ self.passcode.errors.append(get_message("INVALID_PASSWORD_CODE")[0])
+ return False
+
+ return True
+
+
+def _send_code_helper(form, send_magic_link):
+ # send code
+ user = form.user
+ method = form.chosen_method.data
+ totp_secrets = _datastore.us_get_totp_secrets(user)
+
+ msg = user.us_send_security_token(
+ method,
+ totp_secret=totp_secrets[method],
+ phone_number=getattr(user, "us_phone_number", None),
+ send_magic_link=send_magic_link,
+ )
+ return msg
+
+
+@anonymous_user_required
+@unauth_csrf()
+def us_signin_send_code() -> ResponseValue:
+ """
+ Send code view. POST only.
+ This takes an identity (as configured in USER_IDENTITY_ATTRIBUTES)
+ and a method request to send a code.
+ """
+ form = t.cast(UnifiedSigninForm, build_form_from_request("us_signin_form"))
+ form.submit_send_code.data = True
+ form.submit.data = False
+
+ code_methods = _compute_code_methods()
+
+ if form.validate_on_submit():
+ msg = _send_code_helper(form, True)
+ if msg:
+ form.chosen_method.errors.append(msg)
+
+ if _security._want_json(request):
+ # Not authenticated yet - so don't send any user info.
+ return base_render_json(
+ form, include_user=False, error_status_code=500 if msg else 200
+ )
+
+ # Make sure same response as non-setup method below
+ do_flash(*generic_message("CODE_HAS_BEEN_SENT", "GENERIC_US_SIGNIN"))
+
+ return _security.render_template(
+ cv("US_SIGNIN_TEMPLATE"),
+ us_signin_form=form,
+ available_methods=cv("US_ENABLED_METHODS"),
+ code_methods=code_methods,
+ chosen_method=form.chosen_method.data,
+ skip_loginmenu=True,
+ **_security._run_ctx_processor("us_signin"),
+ )
+ elif request.method == "POST" and cv("RETURN_GENERIC_RESPONSES"):
+ # TODO - this suppresses the error if they don't select ANY send code option.
+ rinfo: dict[str, dict[str, str]] = dict(
+ identity=dict(), passcode=dict(), chosen_method=dict()
+ )
+ form_errors_munge(form, rinfo)
+ if not _security._want_json(request):
+ # Make sure same response as successful code above.
+ do_flash(*get_message("GENERIC_US_SIGNIN"))
+
+ # Here on failed validation
+ if _security._want_json(request):
+ payload = {
+ "available_methods": cv("US_ENABLED_METHODS"),
+ "code_methods": code_methods,
+ "identity_attributes": get_identity_attributes(),
+ }
+ return base_render_json(form, include_user=False, additional=payload)
+
+ if (
+ form.requires_confirmation
+ and cv("REQUIRES_CONFIRMATION_ERROR_VIEW")
+ and not cv("RETURN_GENERIC_RESPONSES")
+ ):
+ do_flash(*get_message("CONFIRMATION_REQUIRED"))
+ return redirect(get_url(cv("REQUIRES_CONFIRMATION_ERROR_VIEW")))
+
+ return _security.render_template(
+ cv("US_SIGNIN_TEMPLATE"),
+ us_signin_form=form,
+ available_methods=cv("US_ENABLED_METHODS"),
+ code_methods=code_methods,
+ skip_loginmenu=True,
+ **_security._run_ctx_processor("us_signin"),
+ )
+
+
+@auth_required(lambda: cv("API_ENABLED_METHODS"))
+def us_verify_send_code() -> ResponseValue:
+ """
+ Send code during verify. POST only.
+ """
+ form = t.cast(UnifiedVerifyForm, build_form_from_request("us_verify_form"))
+ form.submit_send_code.data = True
+ form.submit.data = False
+
+ code_methods = _compute_active_code_methods(current_user)
+
+ if form.validate_on_submit():
+ msg = _send_code_helper(form, False)
+ if msg:
+ form.chosen_method.errors.append(msg)
+
+ if _security._want_json(request):
+ # no real reason to send user info?
+ return base_render_json(
+ form, include_user=False, error_status_code=500 if msg else 200
+ )
+ if not msg:
+ do_flash(*get_message("CODE_HAS_BEEN_SENT"))
+ return _security.render_template(
+ cv("US_VERIFY_TEMPLATE"),
+ us_verify_form=form,
+ available_methods=cv("US_ENABLED_METHODS"),
+ code_methods=code_methods,
+ chosen_method=form.chosen_method.data,
+ skip_login_menu=True,
+ **_security._run_ctx_processor("us_verify"),
+ )
+
+ # Here on failed validation
+ if _security._want_json(request):
+ return base_render_json(form)
+
+ return _security.render_template(
+ cv("US_VERIFY_TEMPLATE"),
+ us_verify_form=form,
+ available_methods=cv("US_ENABLED_METHODS"),
+ code_methods=code_methods,
+ skip_login_menu=True,
+ **_security._run_ctx_processor("us_verify"),
+ )
+
+
+@unauth_csrf()
+def us_signin() -> ResponseValue:
+ """
+ Unified sign in view.
+ This takes an identity (as configured in USER_IDENTITY_ATTRIBUTES)
+ and a passcode (password or OTP).
+
+ Allow already authenticated users. For GET this is useful for
+ single-page-applications on refresh - session still active but need to
+ access user info and csrf-token.
+ For POST - redirects to POST_LOGIN_VIEW (forms) or returns 400 (json).
+ """
+
+ if is_user_authenticated(current_user) and request.method == "POST":
+ # Just redirect current_user to POST_LOGIN_VIEW (or next).
+ # While its tempting to try to logout the current user and login the
+ # new requested user - that simply doesn't work with CSRF.
+
+ # While this is close to anonymous_user_required - it differs in that
+ # it uses get_post_login_redirect which correctly handles 'next'.
+ # TODO: consider changing anonymous_user_required to also call
+ # get_post_login_redirect - not sure why it never has?
+ if _security._want_json(request):
+ payload = json_error_response(
+ errors=get_message("ANONYMOUS_USER_REQUIRED")[0]
+ )
+ return _security._render_json(payload, 400, None, None)
+ else:
+ return redirect(get_post_login_redirect())
+
+ form = t.cast(UnifiedSigninForm, build_form_from_request("us_signin_form"))
+ form.submit.data = True
+ form.submit_send_code.data = False
+ # Clean out any potential old session info - in case of previous
+ # aborted 2FA attempt.
+ tf_clean_session()
+
+ if form.validate_on_submit():
+ # Check if multi-factor is required. Some (this is configurable) don't
+ # need 2FA since they ARE multi-factor (such as SMS and authenticator).
+ remember_me = form.remember.data if "remember" in form else None
+ if form.authn_via in cv("US_MFA_REQUIRED"):
+ response = _security.two_factor_plugins.tf_enter(
+ form.user,
+ remember_me,
+ form.authn_via,
+ next_loc=propagate_next(request.url, form),
+ )
+ if response:
+ return response
+ after_this_request(view_commit)
+ login_user(form.user, remember=remember_me, authn_via=[form.authn_via])
+
+ if _security._want_json(request):
+ return base_render_json(form, include_auth_token=True)
+
+ return redirect(get_post_login_redirect())
+ elif request.method == "POST" and cv("RETURN_GENERIC_RESPONSES"):
+ rinfo = dict(
+ identity=dict(replace_msg="GENERIC_AUTHN_FAILED"),
+ passcode=dict(replace_msg="GENERIC_AUTHN_FAILED"),
+ )
+ form_errors_munge(form, rinfo)
+
+ # Here on GET or failed POST validate
+ code_methods = _compute_code_methods()
+ if _security._want_json(request):
+ payload = {
+ "available_methods": cv("US_ENABLED_METHODS"),
+ "code_methods": code_methods,
+ "identity_attributes": get_identity_attributes(),
+ }
+ return base_render_json(form, include_user=False, additional=payload)
+
+ if is_user_authenticated(current_user):
+ # Basically a no-op if authenticated - just perform the same
+ # post-login redirect as if user just logged in.
+ return redirect(get_post_login_redirect())
+
+ # On error - wipe code
+ form.passcode.data = None
+
+ if (
+ form.requires_confirmation
+ and cv("REQUIRES_CONFIRMATION_ERROR_VIEW")
+ and not cv("RETURN_GENERIC_RESPONSES")
+ ):
+ do_flash(*get_message("CONFIRMATION_REQUIRED"))
+ return redirect(get_url(cv("REQUIRES_CONFIRMATION_ERROR_VIEW")))
+
+ return _security.render_template(
+ cv("US_SIGNIN_TEMPLATE"),
+ us_signin_form=form,
+ available_methods=cv("US_ENABLED_METHODS"),
+ code_methods=code_methods,
+ skip_login_menu=True,
+ **_security._run_ctx_processor("us_signin"),
+ )
+
+
+@auth_required(lambda: cv("API_ENABLED_METHODS"))
+def us_verify() -> ResponseValue:
+ """
+ Re-authenticate to reset freshness time.
+ This is likely the result of a reauthn_handler redirect, which
+ will have filled in ?next=xxx - which we want to carefully not lose as we
+ go through these steps.
+ """
+ form = t.cast(UnifiedVerifyForm, build_form_from_request("us_verify_form"))
+ form.submit.data = True
+ form.submit_send_code.data = False
+
+ code_methods = _compute_active_code_methods(current_user)
+
+ if form.validate_on_submit():
+ # verified - so set freshness time.
+ session["fs_paa"] = time.time()
+
+ if _security._want_json(request):
+ return base_render_json(form, include_auth_token=True)
+
+ do_flash(*get_message("REAUTHENTICATION_SUCCESSFUL"))
+ return redirect(get_post_verify_redirect())
+
+ # Here on GET or failed POST validate
+ webauthn_available = has_webauthn(current_user, cv("WAN_ALLOW_AS_VERIFY"))
+ if _security._want_json(request):
+ payload = {
+ "available_methods": cv("US_ENABLED_METHODS"),
+ "code_methods": code_methods,
+ "has_webauthn_verify_credential": webauthn_available,
+ }
+ return base_render_json(form, additional=payload)
+
+ # On error - wipe code
+ form.passcode.data = None
+ return _security.render_template(
+ cv("US_VERIFY_TEMPLATE"),
+ us_verify_form=form,
+ code_methods=code_methods,
+ skip_login_menu=True,
+ has_webauthn_verify_credential=webauthn_available,
+ wan_verify_form=build_form("wan_verify_form"),
+ **_security._run_ctx_processor("us_verify"),
+ )
+
+
+@anonymous_user_required
+def us_verify_link() -> ResponseValue:
+ """
+ Used to verify a magic email link. GET only
+ Since this is just a URL - be careful not to disclose info like
+ whether email exists or not.
+ """
+ fs_uniquifier = request.args.get("id", None)
+ code = request.args.get("code", None)
+ if not fs_uniquifier or not code:
+ m, c = get_message("API_ERROR")
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(get_url(cv("LOGIN_ERROR_VIEW"), qparams={c: m}))
+ do_flash(m, c)
+ return redirect(url_for_security("us_signin"))
+
+ user = _datastore.find_user(fs_uniquifier=fs_uniquifier)
+ if not user or not user.active:
+ if not user:
+ m, c = generic_message("USER_DOES_NOT_EXIST", "GENERIC_AUTHN_FAILED")
+ else:
+ m, c = generic_message("DISABLED_ACCOUNT", "GENERIC_AUTHN_FAILED")
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(get_url(cv("LOGIN_ERROR_VIEW"), qparams={c: m}))
+ do_flash(m, c)
+ return redirect(url_for_security("us_signin"))
+
+ totp_secrets = _datastore.us_get_totp_secrets(user)
+ if "email" not in totp_secrets or not _security._totp_factory.verify_totp(
+ token=code,
+ totp_secret=totp_secrets["email"],
+ user=user,
+ window=cv("US_TOKEN_VALIDITY"),
+ ):
+ m, c = generic_message("INVALID_CODE", "GENERIC_AUTHN_FAILED")
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(
+ get_url(
+ cv("LOGIN_ERROR_VIEW"),
+ qparams=user.get_redirect_qparams({c: m}),
+ )
+ )
+ do_flash(m, c)
+ return redirect(url_for_security("us_signin"))
+
+ tf_setup_methods = []
+ if cv("TWO_FACTOR"):
+ tf_setup_methods = _security.two_factor_plugins.get_setup_tf_methods(user)
+ if (
+ cv("TWO_FACTOR")
+ and "email" in cv("US_MFA_REQUIRED")
+ and (cv("TWO_FACTOR_REQUIRED") or len(tf_setup_methods) > 0)
+ ):
+ # tf_login doesn't know anything about "spa" etc. In general two-factor
+ # isn't quite ready for SPA. So we return an error via a redirect rather
+ # than mess up SPA applications. To be clear - this simply doesn't
+ # work - using a magic link w/ 2FA - need to use code.
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(
+ get_url(
+ cv("LOGIN_ERROR_VIEW"),
+ qparams=user.get_redirect_qparams({"tf_required": 1}),
+ )
+ )
+ response = _security.two_factor_plugins.tf_enter(
+ user, False, "email", next_loc=propagate_next(request.url, None)
+ )
+ if response:
+ return response
+
+ login_user(user, authn_via=["email"])
+ after_this_request(view_commit)
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ # We do NOT send the authentication token here since the only way to
+ # send it would be via a query param and that isn't secure. (logging and
+ # possibly HTTP Referer header).
+ # This means that this can only work if sessions are active which sort of
+ # makes sense - otherwise you need to use /us-signin with a code.
+ return redirect(
+ get_url(cv("POST_LOGIN_VIEW"), qparams=user.get_redirect_qparams())
+ )
+
+ do_flash(*get_message("PASSWORDLESS_LOGIN_SUCCESSFUL"))
+ return redirect(get_post_login_redirect())
+
+
+@auth_required(
+ lambda: cv("API_ENABLED_METHODS"),
+ within=lambda: cv("FRESHNESS"),
+ grace=lambda: cv("FRESHNESS_GRACE_PERIOD"),
+)
+def us_setup() -> ResponseValue:
+ """
+ Change unified sign in methods.
+ We want to verify the new method - so don't store anything yet in DB
+ use a timed signed token to pass along state.
+ GET - retrieve current info (json) or form.
+ """
+ form = t.cast(UnifiedSigninSetupForm, build_form_from_request("us_setup_form"))
+
+ setup_methods = _compute_setup_methods()
+ active_methods = _compute_active_methods(current_user)
+ form.chosen_method.choices = [
+ c for c in form.setup_choices if c[0] not in active_methods
+ ]
+ form.delete_method.choices = [
+ c for c in form.delete_choices if c[0] in active_methods
+ ]
+
+ # translate active methods
+ if not active_methods:
+ active_methods = [None]
+ current_methods = _security.i18n_domain.format_list(
+ [localize_callback(_setup_methods_xlate[m]) for m in active_methods]
+ )
+ current_methods_msg = get_message(
+ "US_CURRENT_METHODS", method_list=current_methods
+ )[0]
+
+ if form.validate_on_submit():
+ qrcode_values = dict()
+ json_response = dict()
+ state_token = None
+ delete_method = form.delete_method.data
+ add_method = form.chosen_method.data
+
+ if delete_method:
+ after_this_request(view_commit)
+ for m in delete_method:
+ _datastore.us_reset(current_user, m)
+ active_methods = _compute_active_methods(current_user)
+ if not active_methods:
+ active_methods = [None]
+ current_methods = _security.i18n_domain.format_list(
+ [localize_callback(_setup_methods_xlate[m]) for m in active_methods]
+ )
+
+ current_methods_msg = get_message(
+ "US_CURRENT_METHODS", method_list=current_methods
+ )[0]
+ form.chosen_method.choices = [
+ c for c in form.setup_choices if c[0] not in active_methods
+ ]
+ form.delete_method.choices = [
+ c for c in form.delete_choices if c[0] in active_methods
+ ]
+ form.delete_method.data = None
+ us_profile_changed.send(
+ current_app._get_current_object(), # type: ignore
+ _async_wrapper=current_app.ensure_sync,
+ user=current_user,
+ methods=delete_method,
+ delete=True,
+ )
+
+ if add_method:
+ # Always generate a totp_secret. We don't set it in the DB until
+ # user has successfully validated.
+ totp = _security._totp_factory.generate_totp_secret()
+
+ # N.B. totp (totp_secret) is actually encrypted - so it seems safe enough
+ # to send it to the user.
+ # Only check phone number if SMS (see form validate)
+ phone_number = (
+ _security._phone_util.get_canonical_form(form.phone.data)
+ if add_method == "sms"
+ else None
+ )
+ state = {
+ "totp_secret": totp,
+ "chosen_method": add_method,
+ "phone_number": phone_number,
+ }
+ msg = current_user.us_send_security_token(
+ method=add_method,
+ totp_secret=totp,
+ phone_number=phone_number,
+ )
+ if msg:
+ # sending didn't work.
+ form.chosen_method.errors.append(msg)
+ if _security._want_json(request):
+ # Not authenticated yet - so don't send any user info.
+ return base_render_json(
+ form, include_user=False, error_status_code=500 if msg else 400
+ )
+ return _security.render_template(
+ cv("US_SETUP_TEMPLATE"),
+ available_methods=cv("US_ENABLED_METHODS"),
+ active_methods=active_methods,
+ current_methods_msg=current_methods_msg,
+ setup_methods=setup_methods,
+ us_setup_form=form,
+ **_security._run_ctx_processor("us_setup"),
+ )
+
+ state_token = _security.us_setup_serializer.dumps(state)
+ json_response = dict(
+ chosen_method=form.chosen_method.data,
+ phone=phone_number,
+ state=state_token,
+ )
+
+ if form.chosen_method.data == "authenticator":
+ authr_setup_values = _security._totp_factory.fetch_setup_values(
+ totp, current_user
+ )
+
+ # Add all the values used in qrcode to json response
+ json_response["authr_key"] = authr_setup_values["key"]
+ json_response["authr_username"] = authr_setup_values["username"]
+ json_response["authr_issuer"] = authr_setup_values["issuer"]
+
+ qrcode_values = dict(
+ authr_qrcode=authr_setup_values["image"],
+ authr_key=authr_setup_values["key"],
+ authr_username=authr_setup_values["username"],
+ authr_issuer=authr_setup_values["issuer"],
+ )
+
+ if _security._want_json(request):
+ return base_render_json(form, include_user=False, additional=json_response)
+ form.delete_method.data = None
+ return _security.render_template(
+ cv("US_SETUP_TEMPLATE"),
+ available_methods=cv("US_ENABLED_METHODS"),
+ active_methods=active_methods,
+ current_methods_msg=current_methods_msg,
+ setup_methods=setup_methods,
+ code_sent=form.chosen_method.data in _compute_code_methods(),
+ chosen_method=form.chosen_method.data,
+ us_setup_form=form,
+ us_setup_validate_form=build_form("us_setup_validate_form"),
+ **qrcode_values,
+ state=state_token,
+ **_security._run_ctx_processor("us_setup"),
+ )
+
+ # Get here on initial new setup (GET)
+ # Or failure of POST
+ if _security._want_json(request):
+ payload = {
+ "identity_attributes": get_identity_attributes(),
+ "available_methods": cv("US_ENABLED_METHODS"),
+ "active_methods": active_methods,
+ "setup_methods": setup_methods,
+ "phone": current_user.us_phone_number,
+ }
+ return base_render_json(form, include_user=False, additional=payload)
+
+ # Show user existing phone number
+ form.phone.data = current_user.us_phone_number
+ form.chosen_method.data = None
+ form.delete_method.data = None
+ return _security.render_template(
+ cv("US_SETUP_TEMPLATE"),
+ available_methods=cv("US_ENABLED_METHODS"),
+ active_methods=active_methods,
+ current_methods_msg=current_methods_msg,
+ setup_methods=setup_methods,
+ us_setup_form=form,
+ **_security._run_ctx_processor("us_setup"),
+ )
+
+
+@auth_required(lambda: cv("API_ENABLED_METHODS"))
+def us_setup_validate(token: str) -> ResponseValue:
+ """
+ Validate new setup.
+ The token is the state variable which is signed and timed
+ and contains all the state that once confirmed will be stored in the user record.
+ """
+ form = t.cast(
+ UnifiedSigninSetupValidateForm,
+ build_form_from_request("us_setup_validate_form"),
+ )
+
+ expired, invalid, state = check_and_get_token_status(
+ token, "us_setup", get_within_delta("US_SETUP_WITHIN")
+ )
+ if invalid:
+ m, c = get_message("API_ERROR")
+ if expired:
+ m, c = get_message("US_SETUP_EXPIRED", within=cv("US_SETUP_WITHIN"))
+ if invalid or expired:
+ if _security._want_json(request):
+ form.form_errors.append(m)
+ return base_render_json(form, include_user=False)
+ do_flash(m, c)
+ return redirect(url_for_security("us_setup"))
+
+ form.totp_secret = state["totp_secret"]
+ form.user = current_user
+
+ if form.validate_on_submit():
+ after_this_request(view_commit)
+ method = state["chosen_method"]
+ phone = state["phone_number"] if method == "sms" else None
+ _datastore.us_set(current_user, method, state["totp_secret"], phone)
+
+ us_profile_changed.send(
+ current_app._get_current_object(), # type: ignore
+ _async_wrapper=current_app.ensure_sync,
+ user=current_user,
+ methods=[method],
+ delete=False,
+ )
+ if _security._want_json(request):
+ return base_render_json(
+ form,
+ include_user=False,
+ additional=dict(
+ chosen_method=method, phone=current_user.us_phone_number
+ ),
+ )
+ else:
+ do_flash(*get_message("US_SETUP_SUCCESSFUL"))
+ return redirect(get_url(cv("US_POST_SETUP_VIEW")))
+
+ # Code not correct/outdated.
+ if _security._want_json(request):
+ return base_render_json(form, include_user=False)
+ m, c = get_message("INVALID_PASSWORD_CODE")
+ do_flash(m, c)
+ return redirect(url_for_security("us_setup"))
+
+
+def us_send_security_token(
+ user, method, totp_secret, phone_number, send_magic_link=False
+):
+ """Generate and send the security code.
+
+ :param user: The user to send the code to
+ :param method: The method in which the code will be sent
+ :param totp_secret: the unique shared secret of the user
+ :param phone_number: If 'sms' phone number to send to
+ :param send_magic_link: If true a magic link that can be clicked on will be sent.
+ This shouldn't be sent during a setup.
+
+ There is no return value - it is assumed that exceptions are thrown by underlying
+ methods that callers can catch.
+
+ Flask-Security code should NOT call this directly -
+ call :meth:`.UserMixin.us_send_security_token`
+
+ .. versionadded:: 3.4.0
+ """
+ code = _security._totp_factory.generate_totp_password(totp_secret)
+
+ if method == "email":
+ login_link = None
+ if send_magic_link:
+ login_link = url_for_security(
+ "us_verify_link", id=str(user.fs_uniquifier), code=code, _external=True
+ )
+ send_mail(
+ cv("US_EMAIL_SUBJECT"),
+ user.email,
+ "us_instructions",
+ user=user,
+ username=user.calc_username(),
+ token=code, # deprecated
+ login_token=code,
+ login_link=login_link,
+ )
+ elif method == "sms":
+ m, c = get_message("USE_CODE", code=code)
+ from_number = cv("SMS_SERVICE_CONFIG")["PHONE_NUMBER"]
+ to_number = phone_number
+ sms_sender = SmsSenderFactory.createSender(cv("SMS_SERVICE"))
+ sms_sender.send_sms(from_number=from_number, to_number=to_number, msg=m)
+
+ elif method == "authenticator" or method == "password":
+ # tokens are generated automatically with authenticator apps
+ # and passwords are well passwords
+ # Still go ahead and notify signal receivers that they requested it.
+ code = None
+ us_security_token_sent.send(
+ current_app._get_current_object(),
+ _async_wrapper=current_app.ensure_sync,
+ user=user,
+ method=method,
+ token=code,
+ login_token=code,
+ phone_number=phone_number,
+ send_magic_link=send_magic_link,
+ )
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/username_util.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/username_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..473f5529763020ff1e02986b93c7bbb51a751944
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/username_util.py
@@ -0,0 +1,107 @@
+"""
+ flask_security.username_util
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Utility class providing methods for validating and normalizing usernames.
+
+ :copyright: (c) 2020-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+
+"""
+
+from __future__ import annotations
+
+import typing as t
+import unicodedata
+
+from .utils import (
+ config_value as cv,
+ get_message,
+)
+
+if t.TYPE_CHECKING: # pragma: no cover
+ import flask
+
+
+class UsernameUtil:
+ """
+ Utility class providing methods for validating and normalizing usernames.
+
+ To provide your own implementation, pass in the class as ``username_util_cls``
+ at init time. Your class will be instantiated once as part of app initialization.
+
+ .. versionadded:: 4.1.0
+ """
+
+ def __init__(self, app: flask.Flask):
+ """Instantiate class.
+
+ :param app: The Flask application being initialized.
+ """
+ pass
+
+ def check_username(self, username: str) -> str | None:
+ """
+ Given a username - check for allowable character categories.
+ This is broken out so applications can easily override this method only.
+
+ By default allow letters and numbers (using unicodedata.category).
+
+ Returns None if allowed, error message if not allowed.
+ """
+ cats = [unicodedata.category(c)[0] for c in username]
+ if any([cat not in ["L", "N"] for cat in cats]):
+ return get_message("USERNAME_DISALLOWED_CHARACTERS")[0]
+ return None
+
+ def normalize(self, username: str) -> str:
+ """
+ Given an input username - return a clean (using bleach) and normalized
+ (using Python's unicodedata.normalize()) version.
+ Must be called in app context and uses
+ :py:data:`SECURITY_USERNAME_NORMALIZE_FORM` config variable.
+ """
+ import bleach
+
+ if not username:
+ return ""
+
+ username = bleach.clean(username.strip(), strip=True)
+ if not username:
+ return ""
+ cf = cv("USERNAME_NORMALIZE_FORM")
+ if cf:
+ return unicodedata.normalize(cf, username)
+ return username
+
+ def validate(self, username: str) -> tuple[str | None, str | None]:
+ """
+ Username validation.
+ Called in app/request context.
+
+ The username is first validated then normalized.
+ Input is restricted/validated via a call to check_username.
+ Return value is a tuple (msg, normalized_username). msg will be None if
+ properly validated.
+
+ It is important that None be returned if data is an empty string since
+ otherwise DBs will complain since the field is unique/nullable.
+ """
+ import bleach
+
+ if not username:
+ return None, None
+ uclean = bleach.clean(username.strip(), strip=True)
+ if uclean != username:
+ return get_message("USERNAME_ILLEGAL_CHARACTERS")[0], None
+
+ msg = self.check_username(uclean)
+ if msg:
+ return msg, None
+
+ unorm = self.normalize(username)
+ umin = cv("USERNAME_MIN_LENGTH")
+ umax = cv("USERNAME_MAX_LENGTH")
+ if len(unorm) < umin or len(unorm) > umax:
+ return get_message("USERNAME_INVALID_LENGTH", min=umin, max=umax)[0], unorm
+ return None, unorm
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/utils.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..d764d25cc14dbd92ddd39543f29421f3fd38d8d4
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/utils.py
@@ -0,0 +1,1344 @@
+"""
+ flask_security.utils
+ ~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security utils module
+
+ :copyright: (c) 2012-2019 by Matt Wright.
+ :copyright: (c) 2019-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import abc
+import base64
+from datetime import datetime, timedelta, timezone
+from functools import partial
+import hashlib
+import hmac
+import time
+import typing as t
+from urllib.parse import parse_qsl, quote, urlsplit, urlunsplit, urlencode
+import urllib.request
+import urllib.error
+import warnings
+
+from flask import (
+ after_this_request,
+ current_app,
+ flash,
+ g,
+ request,
+ render_template,
+ session,
+ url_for,
+)
+from flask_login import login_user as _login_user
+from flask_login import logout_user as _logout_user
+from flask_login import current_user
+from flask_login import COOKIE_NAME as REMEMBER_COOKIE_NAME
+from flask_principal import AnonymousIdentity, Identity, identity_changed, Need
+from flask_wtf import csrf, FlaskForm
+from wtforms import ValidationError
+from itsdangerous import BadSignature, SignatureExpired
+from werkzeug.local import LocalProxy
+from werkzeug.datastructures import MultiDict
+
+from .quart_compat import best, get_quart_status
+from .proxies import _security, _datastore, _pwd_context, _hashing_context
+from .signals import user_authenticated
+
+if t.TYPE_CHECKING: # pragma: no cover
+ from flask import Flask, Response
+ from flask.typing import ResponseValue
+ from .datastore import User
+
+localize_callback = LocalProxy(lambda: _security.i18n_domain.gettext)
+
+FsPermNeed = partial(Need, "fsperm")
+FsPermNeed.__doc__ = """A need with the method preset to `"fsperm"`."""
+
+
+def _(translate):
+ """Identity function to mark strings for translation."""
+ return translate
+
+
+def get_request_attr(name: str) -> t.Any:
+ """Retrieve a request local attribute.
+
+ Current public attributes are:
+
+ **fs_authn_via**
+ will be set to the authentication mechanism (session, token, basic)
+ that the current request was authenticated with.
+
+ Returns None if attribute doesn't exist.
+
+ .. versionadded:: 4.0.0
+ .. versionchanged:: 4.1.5
+ Use 'g' rather than request_ctx stack which is going away post Flask 2.2
+ """
+ return getattr(g, name, None)
+
+
+def set_request_attr(name, value):
+ return setattr(g, name, value)
+
+
+"""
+Most view functions that modify the DB will call ``after_this_request(view_commit)``
+Quart compatibility needs an async version
+"""
+if get_quart_status(): # pragma: no cover
+
+ async def view_commit(response=None):
+ _datastore.commit()
+ return response
+
+else:
+
+ def view_commit(response=None):
+ _datastore.commit()
+ return response
+
+
+# From a miguel grinberg blog around dealing with 3.12.
+# Our default SQLAlchemy Datetime is naive.
+# Note that most code should call _security.datetime_factory()
+def aware_utcnow():
+ return datetime.now(timezone.utc)
+
+
+def aware_utcfromtimestamp(timestamp):
+ return datetime.fromtimestamp(timestamp, timezone.utc)
+
+
+def naive_utcnow():
+ return aware_utcnow().replace(tzinfo=None)
+
+
+def naive_utcfromtimestamp(timestamp):
+ return aware_utcfromtimestamp(timestamp).replace(tzinfo=None)
+
+
+def find_csrf_field_name():
+ """
+ We need to clear it on logout (since that isn't being done by Flask-WTF).
+ The field name is configurable withing Flask-WTF as well as being
+ overridable.
+ We take the field name from the login_form as set by the configuration.
+ """
+ from .forms import DummyForm
+
+ form = DummyForm(formdata=None)
+ if hasattr(form.meta, "csrf_field_name"):
+ return form.meta.csrf_field_name
+ return None
+
+
+def is_user_authenticated(user: User | None) -> bool:
+ """
+ return True if user is authenticated.
+
+ With Flask-Login <=0.6.x and Flask-Security <5.4 current_user was always
+ set - for non-authenticated users it pointed to an AnonymousUser
+ Flask-Login is experimenting (11/5/23) with a LOGIN_NO_ANONYMOUS which will set
+ current_user to None and deprecate is_authenticated (current_user non None implies
+ authenticated).
+ We have a configuration variable ANONYMOUS_USER_DISABLED which if true will force
+ current_user to None on unauthenticated as well
+ """
+ if config_value("ANONYMOUS_USER_DISABLED"):
+ # Note that user often is current_user which is a proxy and isn't ever actually
+ # 'None'
+ return bool(user)
+ return bool(user and user.is_authenticated)
+
+
+def login_user(
+ user: User,
+ remember: bool | None = None,
+ authn_via: list[str] | None = None,
+) -> bool:
+ """Perform the login routine.
+
+ If :py:data:`SECURITY_TRACKABLE` is used, make sure you commit changes after this
+ request (i.e. ``app.security.datastore.commit()``).
+
+ :param user: The user to login
+ :param remember: Flag specifying if the remember cookie should be set.
+ If ``None`` use value of :py:data:`SECURITY_DEFAULT_REMEMBER_ME`
+ :param authn_via: A list of strings denoting which mechanism(s) the user
+ authenticated with.
+ These should be one or more of ["password", "sms", "authenticator", "email"] or
+ other 'auto-login' mechanisms.
+ :return: True if user successfully logged in.
+ """
+
+ if remember is None:
+ remember = config_value("DEFAULT_REMEMBER_ME")
+
+ if not _login_user(user, remember): # pragma: no cover
+ return False
+
+ if _security.trackable:
+ remote_addr = request.remote_addr or None # make sure it is None
+
+ old_current_login, new_current_login = (
+ user.current_login_at,
+ _security.datetime_factory(),
+ )
+ old_current_ip, new_current_ip = user.current_login_ip, remote_addr
+
+ user.last_login_at = old_current_login or new_current_login
+ user.current_login_at = new_current_login
+ user.last_login_ip = old_current_ip
+ user.current_login_ip = new_current_ip
+ user.login_count = user.login_count + 1 if user.login_count else 1
+
+ _datastore.put(user)
+
+ session["fs_cc"] = "set" # CSRF cookie
+ session["fs_paa"] = time.time() # Primary authentication at - timestamp
+
+ identity_changed.send(
+ current_app._get_current_object(), # type: ignore[attr-defined]
+ _async_wrapper=current_app.ensure_sync,
+ identity=Identity(user.fs_uniquifier),
+ )
+
+ user_authenticated.send(
+ current_app._get_current_object(), # type: ignore[attr-defined]
+ _async_wrapper=current_app.ensure_sync,
+ user=user,
+ authn_via=authn_via,
+ )
+ return True
+
+
+def logout_user() -> None:
+ """Logs out the current user.
+
+ This will also clean up the remember me cookie if it exists.
+
+ This sends an ``identity_changed`` signal to note that the current
+ identity is now the `AnonymousIdentity`
+ """
+
+ for key in (
+ "identity.name",
+ "identity.auth_type",
+ "fs_paa",
+ "fs_gexp",
+ "fs_oauth_next",
+ ):
+ session.pop(key, None)
+
+ # Clear csrf token between sessions.
+ # Ideally this would be handled by Flask-WTF but...
+ # We don't clear entire session since Flask-Login seems to like having it.
+ csrf_field_name = find_csrf_field_name()
+ if csrf_field_name:
+ session.pop(csrf_field_name, None)
+ # Flask-WTF 'caches' csrf_token - and only set the session if not already
+ # in 'g'. Be sure to clear both. This affects at least /confirm
+ g.pop(csrf_field_name, None)
+ session["fs_cc"] = "clear"
+ identity_changed.send(
+ current_app._get_current_object(), # type: ignore
+ _async_wrapper=current_app.ensure_sync,
+ identity=AnonymousIdentity(),
+ )
+ _logout_user()
+
+
+def check_and_update_authn_fresh(
+ within: timedelta,
+ grace: timedelta,
+ method: str | None = None,
+) -> bool:
+ """Check if user authenticated within specified time and update grace period.
+
+ :param within: A timedelta specifying the maximum time in the past that the caller
+ authenticated that is still considered 'fresh'.
+ :param grace: A timedelta that, if the current session is considered 'fresh'
+ will set a grace period for which freshness won't be checked.
+ The intent here is that the caller shouldn't get part-way though
+ a set of operations and suddenly be required to authenticate again.
+ :param method: Optional - if set and == "basic" then will always return True.
+ (since basic-auth sends username/password on every request)
+
+ If within.total_seconds() is negative, will always return True (always 'fresh').
+ This effectively just disables this entire mechanism.
+
+ If "fs_gexp" is in the session and the current timestamp is less than that,
+ return True and extend grace time (i.e. set fs_gexp to current time + grace).
+
+ If not within the grace period, and within.total_seconds() is 0,
+ return False (not fresh).
+
+ Be aware that for this to work, sessions and therefore session cookies
+ must be functioning and being sent as part of the request. If the required
+ state isn't in the session cookie then return False (not 'fresh').
+
+ .. warning::
+ Be sure the caller is already authenticated PRIOR to calling this method.
+
+ .. versionadded:: 3.4.0
+
+ .. versionchanged:: 4.0.0
+ Added `method` parameter.
+ """
+
+ if method == "basic":
+ return True
+
+ if within.total_seconds() < 0:
+ # this means 'always fresh'
+ return True
+
+ if "fs_paa" not in session:
+ # No session, you can't play.
+ return False
+
+ now = naive_utcnow()
+ new_exp = now + grace
+ grace_ts = int(new_exp.timestamp())
+
+ if fs_gexp := session.get("fs_gexp", None):
+ if now.timestamp() < fs_gexp:
+ # Within grace period - extend it, and we're good.
+ session["fs_gexp"] = grace_ts
+ return True
+
+ # Special case 0 - return False always, but set grace period.
+ if within.total_seconds() == 0:
+ session["fs_gexp"] = grace_ts
+ return False
+
+ authn_time = naive_utcfromtimestamp(session["fs_paa"])
+ # allow for some time drift where it's possible authn_time is in the future
+ # but let's be cautious and not allow arbitrary future times
+ delta = now - authn_time
+ if within > delta > -within:
+ session["fs_gexp"] = grace_ts
+ return True
+ return False
+
+
+def get_hmac(password: str | bytes) -> bytes:
+ """Returns a Base64 encoded HMAC+SHA512 of the password signed with
+ the salt specified by :py:data:`SECURITY_PASSWORD_SALT`.
+
+ :param password: The password to sign
+ """
+ if not (salt := config_value("PASSWORD_SALT")):
+ raise RuntimeError(
+ "The configuration value `SECURITY_PASSWORD_SALT` must "
+ "not be None when the value of `SECURITY_PASSWORD_HASH` is "
+ 'set to "%s"' % config_value("PASSWORD_HASH")
+ )
+
+ h = hmac.new(encode_string(salt), encode_string(password), hashlib.sha512)
+ return base64.b64encode(h.digest())
+
+
+def verify_password(password: str | bytes, password_hash: str | bytes) -> bool:
+ """Returns ``True`` if the password matches the supplied hash.
+
+ :param password: A plaintext password to verify
+ :param password_hash: The expected hash value of the password
+ (usually from your database)
+
+ .. note::
+ Make sure that the password passed in has already been normalized.
+ """
+ if use_double_hash(password_hash):
+ password = get_hmac(password)
+
+ return _pwd_context.verify(password, password_hash)
+
+
+def verify_and_update_password(password: str | bytes, user: User) -> bool:
+ """Returns ``True`` if the password is valid for the specified user.
+
+ Additionally, the hashed password in the database is updated if the
+ hashing algorithm happens to have changed.
+
+ N.B. you MUST call DB commit if you are using a session-based datastore
+ (such as SqlAlchemy) since the user instance might have been altered
+ (i.e. ``app.security.datastore.commit()``).
+ This is usually handled in the view.
+
+ :param password: A plaintext password to verify
+ :param user: The user to verify against
+
+ .. tip::
+ This should not be called directly - rather use
+ :meth:`.UserMixin.verify_and_update_password`
+
+ """
+ if use_double_hash(user.password):
+ verified = _pwd_context.verify(get_hmac(password), user.password)
+ else:
+ # Try with original password.
+ verified = _pwd_context.verify(password, user.password)
+
+ if verified and _pwd_context.needs_update(user.password):
+ user.password = hash_password(password)
+ _datastore.put(user)
+ return verified
+
+
+def hash_password(password: str | bytes) -> str:
+ """Hash the specified plaintext password.
+
+ Unless the hash algorithm (as specified by
+ :py:data:`SECURITY_PASSWORD_HASH`) is listed in
+ the configuration variable :py:data:`SECURITY_PASSWORD_SINGLE_HASH`,
+ perform a double hash - first create an HMAC from the plaintext password
+ and the value of :py:data:`SECURITY_PASSWORD_SALT`,
+ then use the configured hashing algorithm.
+ This satisfies OWASP/ASVS section 2.4.5: 'provide additional
+ iteration of a key derivation'.
+
+ .. versionadded:: 2.0.2
+
+ :param password: The plaintext password to hash
+ """
+ if use_double_hash():
+ password = get_hmac(password).decode("ascii")
+
+ # Passing in options as part of hash is deprecated in passlib 1.7
+ # and new algorithms like argon2 don't even support it.
+ return _pwd_context.hash(
+ password,
+ **config_value("PASSWORD_HASH_OPTIONS", default={}).get(
+ config_value("PASSWORD_HASH"), {}
+ ),
+ )
+
+
+def encode_string(string):
+ """Encodes a string to bytes, if it isn't already.
+
+ :param string: The string to encode"""
+
+ if isinstance(string, str):
+ string = string.encode("utf-8")
+ return string
+
+
+def hash_data(data):
+ return _hashing_context.hash(encode_string(data))
+
+
+def verify_hash(hashed_data, compare_data):
+ return _hashing_context.verify(encode_string(compare_data), hashed_data)
+
+
+def suppress_form_csrf():
+ """
+ Return meta contents if we should suppress form from attempting to validate CSRF.
+
+ If app doesn't want CSRF for unauth endpoints then check if caller is authenticated
+ or not (many endpoints can be called either way).
+ """
+ if config_value("CSRF_IGNORE_UNAUTH_ENDPOINTS") and not is_user_authenticated(
+ current_user
+ ):
+ return {"csrf": False}
+ return {}
+
+
+def do_flash(message: str, category: str) -> None:
+ """Flash a message depending on if the `FLASH_MESSAGES` configuration
+ value is set.
+
+ :param message: The flash message
+ :param category: The flash message category
+ """
+ if config_value("FLASH_MESSAGES"):
+ flash(message, category)
+
+
+def parse_auth_token(auth_token: str) -> dict[str, t.Any]:
+ """Parse an authentication token.
+ This will raise an exception if not properly signed or expired
+ """
+ tdata = dict()
+
+ # This can raise BadSignature or SignatureExpired exceptions from itsdangerous
+ raw_data = _security.remember_token_serializer.loads(
+ auth_token, max_age=config_value("TOKEN_MAX_AGE")
+ )
+
+ # Version 3.x generated tokens that map to data with 3 elements,
+ # and fs_uniquifier was on last element.
+ # Version 4.0.0 generates tokens that map to data with only 1 element,
+ # which maps to fs_uniquifier.
+ # Version 5 and up are already a dict (with a version #)
+ if isinstance(raw_data, dict):
+ # new format - starting at ver=5
+ if not all(k in raw_data for k in ["ver", "uid", "exp", "sid"]):
+ raise ValueError("Token missing keys")
+ tdata = raw_data
+ if ts := tdata.get("exp"):
+ if ts < int(time.time()):
+ raise SignatureExpired("token[exp] value expired")
+ else:
+ # old tokens that were lists
+ if len(raw_data) == 1:
+ # version 4
+ tdata["ver"] = "4"
+ tdata["uid"] = raw_data[0]
+ else:
+ # version 3
+ tdata["ver"] = "3"
+ tdata["uid"] = raw_data[2]
+
+ return tdata
+
+
+def get_url(endpoint_or_url: str, qparams: dict[str, str] | None = None) -> str:
+ """Returns a URL if a valid endpoint is found. Otherwise, returns the
+ provided value.
+
+ .. warning::
+ If an endpoint ISN'T provided, then it is assumed that the URL
+ is external to Flask and if the spa configuration REDIRECT_HOST
+ is set will redirect to that host. This could be an issue in
+ development.
+
+ :param endpoint_or_url: The endpoint name or URL to default to
+ :param qparams: additional query params to add to end of url
+ :return: URL
+ """
+ try:
+ return transform_url(url_for(endpoint_or_url), qparams)
+ except Exception:
+ # This is an external URL (no endpoint defined in app)
+ # For (mostly) testing - allow changing/adding the url - for example
+ # add a different host:port for cases where the UI is running
+ # separately.
+ if config_value("REDIRECT_HOST"):
+ url = transform_url(
+ endpoint_or_url, qparams, netloc=config_value("REDIRECT_HOST")
+ )
+ else:
+ url = transform_url(endpoint_or_url, qparams)
+
+ return url
+
+
+def slash_url_suffix(url, suffix):
+ """Adds a slash either to the beginning or the end of a suffix
+ (which is to be appended to a URL), depending on whether or not
+ the URL ends with a slash."""
+ return url.endswith("/") and f"{suffix}/" or f"/{suffix}"
+
+
+def transform_url(
+ url: str, qparams: dict[str, str] | None = None, **kwargs: str
+) -> str:
+ """Modify url
+
+ :param url: url to transform (can be relative)
+ :param qparams: additional query params to add to end of url
+ :param kwargs: pieces of URL to modify - e.g. netloc=localhost:8000
+ :return: Modified URL
+
+ .. versionadded:: 3.2.0
+ """
+ link_parse = urlsplit(url)
+ if qparams:
+ current_query = dict(parse_qsl(link_parse.query))
+ current_query.update(qparams)
+ link_parse = link_parse._replace(query=urlencode(current_query))
+ return urlunsplit(link_parse._replace(**kwargs))
+
+
+def get_security_endpoint_name(endpoint):
+ return f"{config_value('BLUEPRINT_NAME')}.{endpoint}"
+
+
+def url_for_security(endpoint: str, **values: t.Any) -> str:
+ """Return a URL for the security blueprint
+
+ :param endpoint: the endpoint of the URL (name of the function)
+ :param values: the variable arguments of the URL rule
+ :param _external: if set to `True`, an absolute URL is generated. Server
+ address can be changed via `SERVER_NAME` configuration variable which
+ defaults to `localhost`.
+ :param _anchor: if provided this is added as anchor to the URL.
+ :param _method: if provided this explicitly specifies an HTTP method.
+ """
+ endpoint = get_security_endpoint_name(endpoint)
+ # mypy is complaining about this - but I think it's wrong?
+ return url_for(endpoint, **values) # type: ignore
+
+
+def validate_redirect_url(url: str) -> bool:
+ """Validate that the URL for redirect is relative.
+ Allowing an absolute redirect is a security issue - a so-called open-redirect.
+ Note that by default Werkzeug will always take this URL and make it relative
+ when setting the Location header - but that behavior can be overridden.
+
+ The complexity here is that urlsplit() does pretty well, but browsers even today
+ May 2021 are very lenient in what they accept as URLs - for example:
+ next=\\\\github.com
+ next=%5C%5C%5Cgithub.com
+ next=/////github.com
+ next=%20\\\\github.com
+ next=%20///github.com
+ next=%20//github.com
+ next=%19////github.com - i.e. browser will strip control chars
+ next=%E2%80%8A///github.com - doesn't redirect! That is a unicode thin space.
+
+ All will result in a null netloc and scheme from urlsplit - however many browsers
+ will gladly strip off uninteresting characters and convert backslashes to forward
+ slashes - and the cases above will actually cause a redirect to github.com
+ Sigh.
+
+ Some articles claim that a relative url has to start with a '/' - but that isn't
+ strictly true. From: https://datatracker.ietf.org/doc/html/rfc3986#section-5
+ a relative path can start with a "//", "/", a non-colon, or be empty. So it seems
+ that all the above URLs are valid.
+ By the time we get the URL, it has been unencoded - so we can't really determine
+ if it is 'valid' since it appears that '/'s can appear in the URL if escaped.
+ """
+ if url is None or url.strip() == "":
+ return False
+ url_next = urlsplit(url)
+ url_base = urlsplit(request.host_url)
+ if (url_next.netloc or url_next.scheme) and url_next.netloc != url_base.netloc:
+ base_domain = current_app.config.get("SERVER_NAME")
+ if (
+ config_value("REDIRECT_ALLOW_SUBDOMAINS")
+ and base_domain
+ and (
+ url_next.netloc == base_domain
+ or url_next.netloc.endswith(f".{base_domain}")
+ )
+ ):
+ return True
+ else:
+ return False
+ return True
+
+
+def get_post_action_redirect(
+ config_key: str, next_loc: FlaskForm | MultiDict | dict | None
+) -> str:
+ """
+ There is a security angle here - the result of this method is
+ sent to Flask::redirect() - and we need to be sure that it can't be
+ interpreted as a user-input external URL - that would mean we would
+ have an 'open-redirect' vulnerability.
+ """
+ rurl = propagate_next(find_redirect(config_key), next_loc)
+ (scheme, netloc, path, query, fragment) = urlsplit(rurl)
+ safe_url = urlunsplit((scheme, netloc, quote(path), query, fragment))
+ return safe_url
+
+
+def get_post_login_redirect() -> str:
+ return get_post_action_redirect("SECURITY_POST_LOGIN_VIEW", request.form)
+
+
+def get_post_register_redirect() -> str:
+ return get_post_action_redirect("SECURITY_POST_REGISTER_VIEW", request.form)
+
+
+def get_post_logout_redirect() -> str:
+ return get_post_action_redirect("SECURITY_POST_LOGOUT_VIEW", request.form)
+
+
+def get_post_verify_redirect() -> str:
+ return get_post_action_redirect("SECURITY_POST_VERIFY_VIEW", request.form)
+
+
+def find_redirect(key: str) -> str:
+ """Returns the URL to redirect to.
+
+ :param key: The application configuration key to search for
+ """
+ app_url = None
+ if app_value := current_app.config[key.upper()]:
+ app_url = get_url(app_value)
+ rv = app_url or str(current_app.config.get("APPLICATION_ROOT", "/"))
+ return rv
+
+
+def propagate_next(fallback_url: str, form: FlaskForm | MultiDict | dict | None) -> str:
+ """Compute appropriate redirect URL
+ The application can add a 'next' query parameter or have 'next' as a form field.
+ If either exist, make sure they are valid (not pointing to external location)
+ If neither, return the fallback_url
+
+ Can be passed either request.form
+ (which is really a MultiDict OR a real form OR a dict with a 'next' key).
+ """
+ form_next = None
+ if form and isinstance(form, FlaskForm):
+ if hasattr(form, "next") and form.next.data:
+ form_next = form.next.data
+ elif form and form.get("next", None):
+ form_next = str(form.get("next"))
+ arg_next = request.args.get("next")
+
+ urls = [
+ get_url(form_next) if form_next else None,
+ get_url(arg_next) if arg_next else None,
+ fallback_url,
+ ]
+ for url in urls:
+ if url and validate_redirect_url(url):
+ return url
+ raise ValueError("No valid redirect URL found - configuration error")
+
+
+def simplify_url(base_url: str, redirect_url: str) -> str:
+ """
+ Reduces the scheme and host from the redirect_url so it can be passed
+ as a relative URL in a query (e.g. next) param.
+ For this method we aren't worrying about a valid url (e.g. if it points
+ externally) - that will be handled by later requests.
+
+ :param base_url: The URL to simplify 'against'.
+ :param redirect_url: The URL to reduce.
+ """
+ b_url = urlsplit(base_url)
+ r_url = urlsplit(redirect_url)
+
+ if (not r_url.scheme or r_url.scheme == b_url.scheme) and (
+ not r_url.netloc or r_url.netloc == b_url.netloc
+ ):
+ return urlunsplit(("", "", r_url.path, r_url.query, r_url.fragment))
+ return redirect_url
+
+
+def get_message(key: str, **kwargs: t.Any) -> tuple[str, str]:
+ rv = config_value("MSG_" + key)
+ return localize_callback(rv[0], **kwargs), rv[1]
+
+
+def config_value(key, app=None, default=None, strict=True):
+ """Get a Flask-Security configuration value.
+
+ :param key: The configuration key without the prefix `SECURITY_`
+ :param app: An optional specific application to inspect. Defaults to
+ Flask's `current_app`
+ :param default: An optional default value if the value is not set
+ :param strict: if True, will raise ValueError if key doesn't exist
+ """
+ app = app or current_app
+ key = f"SECURITY_{key.upper()}"
+ # protect against spelling mistakes
+ if strict and key not in app.config:
+ raise ValueError(f"Key {key} doesn't exist")
+ return app.config.get(key, default)
+
+
+def get_max_age(key, app=None):
+ td = get_within_delta(key + "_WITHIN", app)
+ return td.seconds + td.days * 24 * 3600
+
+
+def get_within_delta(key, app=None):
+ """Get a timedelta object from the application configuration following
+ the internal convention of::
+
+
+
+ Examples of valid config values::
+
+ 5 days
+ 10 minutes
+
+ :param key: The config value key without the `SECURITY_` prefix
+ :param app: Optional application to inspect. Defaults to Flask's
+ `current_app`
+ """
+ txt = config_value(key, app=app)
+ values = txt.split()
+ return timedelta(**{values[1]: int(values[0])})
+
+
+def send_mail(subject, recipient, template, **context):
+ """Send an email.
+
+ :param subject: Email subject
+ :param recipient: Email recipient
+ :param template: The name of the email template
+ :param context: The context to render the template with
+
+ This formats the email and passes it off to :class:`.MailUtil` to actually send the
+ message.
+ """
+
+ context.setdefault("security", _security)
+ context.update(_security._run_ctx_processor("mail"))
+
+ body = None
+ html = None
+ template_path = f"security/email/{template}"
+ if config_value("EMAIL_PLAINTEXT"):
+ body = _security.render_template(f"{template_path}.txt", **context)
+ if config_value("EMAIL_HTML"):
+ html = _security.render_template(f"{template_path}.html", **context)
+
+ subject = localize_callback(subject)
+
+ sender = config_value("EMAIL_SENDER")
+ if isinstance(sender, LocalProxy):
+ sender = sender._get_current_object()
+
+ _security._mail_util.send_mail(
+ template,
+ subject,
+ recipient,
+ sender,
+ body,
+ html,
+ **context,
+ )
+
+
+def get_token_status(token, serializer, max_age=None, return_data=False):
+ """Get the status of a token.
+
+ :param token: The token to check
+ :param serializer: The name of the serializer. Can be one of the
+ following: ``confirm``, ``login``, ``reset``
+ :param max_age: The name of the max age config option. Can be one of
+ the following: ``CONFIRM_EMAIL``, ``LOGIN``,
+ ``RESET_PASSWORD``
+
+ .. deprecated:: 5.0.0
+ """
+ warnings.warn(
+ "'get_token_status' is deprecated - use check_and_get_token_status instead",
+ DeprecationWarning,
+ stacklevel=2,
+ )
+ serializer = getattr(_security, serializer + "_serializer")
+ max_age = get_max_age(max_age)
+ user, data = None, None
+ expired, invalid = False, False
+
+ try:
+ data = serializer.loads(token, max_age=max_age)
+ except SignatureExpired:
+ d, data = serializer.loads_unsafe(token)
+ expired = True
+ except (BadSignature, TypeError, ValueError):
+ invalid = True
+
+ if data:
+ user = _datastore.find_user(fs_uniquifier=data[0])
+
+ expired = expired and (user is not None)
+
+ if return_data:
+ return expired, invalid, user, data
+ else:
+ return expired, invalid, user
+
+
+def check_and_get_token_status(
+ token: str, serializer_name: str, within: timedelta
+) -> tuple[bool, bool, t.Any]:
+ """Get the status of a token and return data.
+
+ :param token: The token to check
+ :param serializer_name: The name of the serializer. Can be one of the
+ following: ``confirm``, ``login``, ``reset``, ``us_setup``
+ ``remember``, ``two_factor_validity``, ``wan``
+ :param within: max age - passed as a timedelta
+
+ :return: a tuple of (expired, invalid, data)
+
+ .. versionadded:: 3.4.0
+ """
+ serializer = getattr(_security, serializer_name + "_serializer")
+ max_age = within.total_seconds()
+ data = None
+ expired, invalid = False, False
+
+ try:
+ data = serializer.loads(token, max_age=max_age)
+ except SignatureExpired:
+ d, data = serializer.loads_unsafe(token)
+ expired = True
+ except (BadSignature, TypeError, ValueError):
+ invalid = True
+
+ return expired, invalid, data
+
+
+def get_identity_attributes(app: Flask | None = None) -> list[str]:
+ # Return list of keys of identity attributes
+ # Is it possible to not have any?
+ app = app or current_app
+ iattrs = app.config["SECURITY_USER_IDENTITY_ATTRIBUTES"]
+ if iattrs:
+ return [[*f][0] for f in iattrs]
+ return []
+
+
+def get_identity_attribute(attr: str, app: Flask | None = None) -> dict[str, t.Any]:
+ """Given an user_identity_attribute, return the defining dict.
+ A bit annoying since USER_IDENTITY_ATTRIBUTES is a list of dict
+ where each dict has just one key.
+ """
+ app = app or current_app
+ iattrs = app.config["SECURITY_USER_IDENTITY_ATTRIBUTES"]
+ if iattrs:
+ details = [
+ mapping[attr] for mapping in iattrs if list(mapping.keys())[0] == attr
+ ]
+ if details:
+ return details[0]
+ return {}
+
+
+def lookup_identity(identity):
+ """
+ Lookup identity in DB.
+ This loops through, in order, :py:data:`SECURITY_USER_IDENTITY_ATTRIBUTES`,
+ and first calls the mapper function to validate/normalize.
+ Then the db.find_user is called on the specified user model attribute.
+ """
+ for mapping in config_value("USER_IDENTITY_ATTRIBUTES"):
+ attr = list(mapping.keys())[0]
+ details = mapping[attr]
+ idata = details["mapper"](identity)
+ if idata:
+ user = _datastore.find_user(
+ case_insensitive=details.get("case_insensitive", False), **{attr: idata}
+ )
+ return user
+ return None
+
+
+def uia_phone_mapper(identity: str) -> str | None:
+ """Used to match identity as a phone number. This is a simple proxy
+ to :py:class:`PhoneUtil`
+
+ See :py:data:`SECURITY_USER_IDENTITY_ATTRIBUTES`.
+
+ .. versionadded:: 3.4.0
+ """
+ ph = _security._phone_util.get_canonical_form(identity)
+ return ph
+
+
+def uia_email_mapper(identity: str) -> str | None:
+ """Used to match identity as an email.
+
+ :return: Normalized email or None if not valid email.
+
+ See :py:data:`SECURITY_USER_IDENTITY_ATTRIBUTES`.
+
+ .. versionadded:: 3.4.0
+ """
+
+ try:
+ return _security._mail_util.normalize(identity)
+ except ValueError:
+ return None
+
+
+def uia_username_mapper(identity: str) -> str | None:
+ """Used to match identity as a username. This is a simple proxy
+ to :py:class:`UsernameUtil`
+
+ See :py:data:`SECURITY_USER_IDENTITY_ATTRIBUTES`.
+
+ .. versionadded:: 4.1.0
+ """
+ return _security._username_util.normalize(identity)
+
+
+def use_double_hash(password_hash=None):
+ """Return a bool indicating whether a password should be hashed twice."""
+ # Default to plaintext for backward compatibility with
+ # :py:data:`SECURITY_PASSWORD_SINGLE_HASH` = False
+ single_hash = config_value("PASSWORD_SINGLE_HASH") or {"plaintext"}
+
+ if password_hash is None:
+ scheme = config_value("PASSWORD_HASH")
+ else:
+ scheme = _pwd_context.identify(password_hash)
+
+ return not (single_hash is True or scheme in single_hash)
+
+
+def csrf_cookie_handler(response: Response) -> Response:
+ """Called at end of every request.
+ Uses session to track state (set/clear)
+
+ Ideally we just need to set this once - however by default
+ Flask-WTF has a time-out on these tokens governed by *WTF_CSRF_TIME_LIMIT*.
+ While we could set that to None - and OWASP implies this is fine - that might
+ not be agreeable to everyone.
+ So as a basic usability hack - we check if it is expired and re-generate so at least
+ the user doesn't have to log out and back in (just refresh).
+ We also support a *CSRF_COOKIE_REFRESH_EACH_REQUEST* analogous to Flask's
+ *SESSION_REFRESH_EACH_REQUEST*
+
+ It is of course removed on logout/session end.
+ Other info on web suggests replacing on every POST and accepting up to 'age' ago.
+ """
+ csrf_cookie = config_value("CSRF_COOKIE")
+ csrf_cookie_name = config_value("CSRF_COOKIE_NAME")
+ if not csrf_cookie_name:
+ return response
+
+ op = session.get("fs_cc", None)
+ if not op:
+ remember_cookie_name = current_app.config.get(
+ "REMEMBER_COOKIE_NAME", REMEMBER_COOKIE_NAME
+ )
+ has_remember_cookie = (
+ remember_cookie_name in request.cookies
+ and session.get("remember") != "clear"
+ )
+ # Set cookie if successfully logged in with flask_login's remember cookie
+ if has_remember_cookie and is_user_authenticated(current_user):
+ op = "set"
+ else:
+ return response
+
+ if op == "clear":
+ # Alas delete_cookie only accepts some of the keywords set_cookie does
+ allowed = ["path", "domain", "secure", "httponly", "samesite"]
+ args = {k: csrf_cookie.get(k) for k in allowed if k in csrf_cookie}
+ response.delete_cookie(csrf_cookie_name, **args)
+ session.pop("fs_cc")
+ return response
+
+ # Send a cookie if any of:
+ # 1) CSRF_COOKIE_REFRESH_EACH_REQUEST is true
+ # 2) fs_cc == "set" - this is on first login
+ # 3) existing cookie has expired
+ send = False
+ if op == "set":
+ send = True
+ session["fs_cc"] = "sent"
+ elif config_value("CSRF_COOKIE_REFRESH_EACH_REQUEST"):
+ send = True
+ elif current_app.config["WTF_CSRF_TIME_LIMIT"]:
+ current_cookie = request.cookies.get(csrf_cookie_name, None)
+ if current_cookie:
+ # Lets make sure it isn't expired if app doesn't set TIME_LIMIT to None.
+ try:
+ csrf.validate_csrf(current_cookie)
+ except ValidationError:
+ send = True
+
+ if send:
+ response.set_cookie(csrf_cookie_name, value=csrf.generate_csrf(), **csrf_cookie)
+ return response
+
+
+def base_render_json(
+ form: FlaskForm,
+ include_user: bool = True,
+ include_auth_token: bool = False,
+ additional: dict[str, t.Any] | None = None,
+ error_status_code: int = 400,
+) -> ResponseValue:
+ """
+ This method is called by all views that return JSON responses.
+ This fills in the response and then calls :meth:`.Security.render_json`
+ which can be overridden by the app.
+ """
+ user = getattr(form, "user", None)
+ if form.errors:
+ code = error_status_code
+ # wtforms 3.0 introduces form-level errors - these show up as part of the
+ # errors dict with a key of 'None'
+ payload = json_error_response(field_errors=form.errors)
+ else:
+ code = 200
+ payload = dict()
+ if user:
+ # This allows anonymous GETs via JSON
+ if include_user:
+ payload["user"] = user.get_security_payload()
+
+ if include_auth_token:
+ # view willing to return auth_token - check behavior config
+ if (
+ config_value("BACKWARDS_COMPAT_AUTH_TOKEN")
+ or "include_auth_token" in request.args
+ ):
+ try:
+ token = user.get_auth_token()
+ except ValueError:
+ # application has fs_token_uniquifier attribute but it
+ # hasn't been initialized. Since we are in a request context
+ # we can do that here.
+ _datastore.set_token_uniquifier(user)
+ after_this_request(view_commit)
+ token = user.get_auth_token()
+ payload["user"]["authentication_token"] = token
+
+ # Return csrf_token on each JSON response - just as every form
+ # has it rendered.
+ payload["csrf_token"] = csrf.generate_csrf()
+ if additional:
+ payload.update(additional)
+
+ return _security._render_json(payload, code, None, user)
+
+
+def simple_render_json(
+ additional: dict[str, t.Any] | None = None,
+) -> ResponseValue:
+ payload = dict(csrf_token=csrf.generate_csrf())
+ if additional:
+ payload.update(additional)
+ return _security._render_json(payload, 200, None, None)
+
+
+def default_want_json(req):
+ """Return True if response should be in json
+ N.B. do not call this directly - use security._want_json()
+
+ :param req: Flask/Werkzeug Request
+ """
+ if req.is_json:
+ return True
+ # TODO should this handle json sub-types?
+ accept_mimetypes = req.accept_mimetypes
+ if not hasattr(req.accept_mimetypes, "best"): # pragma: no cover
+ # Alright. we don't have the best property, lets add it ourselves.
+ # This is for quart compatibility
+ accept_mimetypes.best = best
+ if accept_mimetypes.best == "application/json":
+ return True
+ return False
+
+
+def json_error_response(
+ errors: str | list | None = None,
+ field_errors: dict[str | None, list] | None = None,
+) -> dict[str, t.Any]:
+ """Helper to create an error response.
+
+ The "errors" key holds a simple list of errors - which is made up of any passed
+ errors (either a string or list) as well as the (localized) error msgs from the
+ passed in field_errors.
+
+ The "field_errors" key which is exactly what is returned from WTForms - namely
+ a dict of field-name: msg. For form-level errors (WTForms 3.0) the 'field-name' is
+ None - which alas means it isn't sortable and Flask's default JSONProvider
+ sorts keys - so we change that to '__all__' which is what django uses
+ apparently and was suggested as part of WTForms 3.0.
+ """
+ response_json: dict[str, list | dict[str, list]] = dict()
+ plain_errors = []
+ if errors:
+ if isinstance(errors, str):
+ plain_errors = [errors]
+ elif isinstance(errors, list):
+ plain_errors = errors
+ else:
+ raise TypeError("The errors argument should be either a str or list.")
+ if field_errors:
+ # This is default from WTForms - a dictionary of field name and list of errors
+ # we return that, as well as create a simple list of errors.
+ for e in field_errors.values():
+ plain_errors.extend(e)
+ if None in field_errors.keys():
+ # Ugh - wtforms decided to use None as a key - which json
+ # a) can't sort
+ # b) converts to "null"
+ # Issue filed - maybe they will change it
+ field_errors[""] = field_errors[None]
+ del field_errors[None]
+ response_json["field_errors"] = field_errors # type: ignore
+ response_json["errors"] = plain_errors
+
+ return response_json
+
+
+def default_render_template(*args, **kwargs):
+ return render_template(*args, **kwargs)
+
+
+class SmsSenderBaseClass(metaclass=abc.ABCMeta):
+ @abc.abstractmethod
+ def send_sms(
+ self, from_number: str, to_number: str, msg: str
+ ) -> None: # pragma: no cover
+ """Abstract method for sending sms messages
+
+ .. versionadded:: 3.2.0
+ """
+ return
+
+
+class DummySmsSender(SmsSenderBaseClass):
+ def send_sms(self, from_number, to_number, msg): # pragma: no cover
+ """Do nothing."""
+ return
+
+
+class SmsSenderFactory:
+ senders: dict[str, t.Type[SmsSenderBaseClass]] = {"Dummy": DummySmsSender}
+
+ @classmethod
+ def createSender(cls, name, *args, **kwargs):
+ """Initialize an SMS sender.
+
+ :param name: Name as registered in SmsSenderFactory:senders (e.g. 'Twilio')
+
+ .. versionadded:: 3.2.0
+ """
+ return cls.senders[name](*args, **kwargs)
+
+
+try: # pragma: no cover
+ from twilio.rest import Client
+
+ class TwilioSmsSender(SmsSenderBaseClass):
+ def __init__(self):
+ super().__init__()
+ self.account_sid = config_value("SMS_SERVICE_CONFIG")["ACCOUNT_SID"]
+ self.auth_token = config_value("SMS_SERVICE_CONFIG")["AUTH_TOKEN"]
+
+ def send_sms(self, from_number, to_number, msg):
+ """Send message via twilio account."""
+ client = Client(self.account_sid, self.auth_token)
+ client.messages.create(to=to_number, from_=from_number, body=msg)
+
+ SmsSenderFactory.senders["Twilio"] = TwilioSmsSender
+except Exception:
+ pass
+
+
+def password_length_validator(password: str) -> list[str] | None:
+ """Test password for length.
+
+ :param password: Plain text password to check
+
+ :return: ``None`` if password conforms to length requirements,
+ a list of error/suggestions if not.
+
+ .. versionadded:: 3.4.0
+
+ """
+ if len(password) < config_value("PASSWORD_LENGTH_MIN") or len(password) > 128:
+ return [
+ get_message(
+ "PASSWORD_INVALID_LENGTH", length=config_value("PASSWORD_LENGTH_MIN")
+ )[0]
+ ]
+ return None
+
+
+def password_complexity_validator(
+ password: str, is_register: bool, **kwargs: t.Any
+) -> list[str] | None:
+ """Test password for complexity.
+
+ Currently just supports 'zxcvbn'.
+
+ :param password: Plain text password to check
+ :param is_register: if True then kwargs are arbitrary additional info. (e.g.
+ info from a registration form). If False, must be a SINGLE key "user" that
+ corresponds to the current_user. All string values will be extracted and
+ sent to the complexity checker.
+ :param kwargs:
+
+ :return: ``None`` if password is complex enough, a list of error/suggestions if not.
+ Be aware that zxcvbn does not (easily) provide a way to localize messages.
+
+ .. versionadded:: 3.4.0
+ """
+
+ if config_value("PASSWORD_COMPLEXITY_CHECKER") == "zxcvbn":
+ import zxcvbn
+
+ user_info: list[t.Any] = []
+ if not is_register:
+ for v in kwargs["user"].__dict__.values():
+ if v and isinstance(v, str):
+ user_info.append(v)
+ else:
+ # This is usually all register form values that are in the user_model
+ if kwargs:
+ user_info = list(kwargs.values())
+ results = zxcvbn.zxcvbn(password, user_inputs=user_info)
+ if results["score"] >= config_value("ZXCVBN_MINIMUM_SCORE"):
+ return None
+ # Should we return suggestions? Default forms don't really know what to do.
+ if results["feedback"]["warning"]:
+ # Note that these come from zxcvbn and
+ # aren't localizable via Flask-Security
+ return [results["feedback"]["warning"]]
+ return [get_message("PASSWORD_TOO_SIMPLE")[0]]
+ else:
+ return None
+
+
+def password_breached_validator(password: str) -> list[str] | None:
+ """Check if password on breached list.
+ Does nothing unless :py:data:`SECURITY_PASSWORD_CHECK_BREACHED` is set.
+ If password is found on the breached list, return an error if the count is
+ greater than or equal to :py:data:`SECURITY_PASSWORD_BREACHED_COUNT`.
+ Uses :meth:`pwned`.
+
+ :param password: Plain text password to check
+
+ :return: ``None`` if password passes breached tests, else a list of error messages.
+
+ .. versionadded:: 3.4.0
+ """
+ if pwn := config_value("PASSWORD_CHECK_BREACHED"):
+ try:
+ cnt = pwned(password)
+ if cnt >= config_value("PASSWORD_BREACHED_COUNT"):
+ return [get_message("PASSWORD_BREACHED")[0]]
+ except Exception:
+ if pwn == "strict":
+ return [get_message("PASSWORD_BREACHED_SITE_ERROR")[0]]
+ return None
+
+
+def pwned(password: str) -> int:
+ """
+ Check password against pwnedpasswords API using k-Anonymity.
+ https://haveibeenpwned.com/API/v3
+
+ :return: Count of password in DB (0 means hasn't been compromised)
+
+ Can raise HTTPError
+
+ .. versionadded:: 3.4.0
+ """
+
+ def convert_password_tuple(value):
+ hash_suffix, count = value.split(":")
+ return hash_suffix, int(count)
+
+ sha1 = hashlib.sha1(password.encode("utf8")).hexdigest()
+
+ req = urllib.request.Request(
+ url=f"https://api.pwnedpasswords.com/range/{sha1[:5].upper()}",
+ headers={"User-Agent": "Flask-Security (Python)"},
+ )
+ # Might raise HTTPError
+ with urllib.request.urlopen(req) as f:
+ response = f.read()
+
+ raw = response.decode("utf-8-sig")
+
+ entries = dict(map(convert_password_tuple, raw.upper().split("\r\n")))
+ return entries.get(sha1[5:].upper(), 0)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/views.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/views.py
new file mode 100644
index 0000000000000000000000000000000000000000..5748450f7eda5713bc7a68e75588c7918753e0b4
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/views.py
@@ -0,0 +1,1254 @@
+"""
+ flask_security.views
+ ~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security views module
+
+ :copyright: (c) 2012 by Matt Wright.
+ :copyright: (c) 2019-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+
+ CSRF is tricky. By default all our forms have CSRF protection built in via
+ Flask-WTF. This is regardless of authentication method or whether the request
+ is Form or JSON based. Form-based 'just works' since when rendering the form
+ (on GET), the CSRF token is automatically populated.
+ We want to handle:
+ - JSON requests where CSRF token is in a header (e.g. X-CSRF-Token)
+ - Option to skip CSRF when using a token to authenticate (rather than session)
+ (CSRF_PROTECT_MECHANISMS)
+ - Option to skip CSRF for 'login'/unauthenticated requests
+ (CSRF_IGNORE_UNAUTH_ENDPOINTS)
+ This is complicated by the fact that the only way to disable form CSRF is to
+ pass in meta={csrf: false} at form instantiation time.
+
+ Be aware that for CSRF to work, caller MUST pass in session cookie. So
+ for pure API, and no session cookie - there is no way to support CSRF-Login
+ so app must set CSRF_IGNORE_UNAUTH_ENDPOINTS (or use CSRF/session cookie for logging
+ in then once they have a token, no need for cookie).
+
+"""
+
+from functools import partial
+import time
+import typing as t
+
+from flask import (
+ Blueprint,
+ after_this_request,
+ jsonify,
+ request,
+ session,
+)
+from flask_login import current_user
+
+from .changeable import change_user_password
+from .confirmable import (
+ confirm_email_token_status,
+ confirm_user,
+ send_confirmation_instructions,
+)
+from .decorators import anonymous_user_required, auth_required, unauth_csrf
+from .forms import (
+ _setup_methods_xlate,
+ ChangePasswordForm,
+ DummyForm,
+ ForgotPasswordForm,
+ LoginForm,
+ build_form_from_request,
+ build_form,
+ form_errors_munge,
+ ResetPasswordForm,
+ SendConfirmationForm,
+ TwoFactorVerifyCodeForm,
+ TwoFactorSetupForm,
+ TwoFactorRescueForm,
+)
+from .passwordless import login_token_status, send_login_instructions
+from .proxies import _security, _datastore
+from .quart_compat import get_quart_status
+from .unified_signin import (
+ us_signin,
+ us_signin_send_code,
+ us_setup,
+ us_setup_validate,
+ us_verify,
+ us_verify_link,
+ us_verify_send_code,
+)
+from .recoverable import (
+ reset_password_token_status,
+ send_reset_password_instructions,
+ update_password,
+)
+from .registerable import register_user, register_existing
+from .recovery_codes import mf_recovery, mf_recovery_codes
+from .tf_plugin import (
+ tf_check_state,
+ tf_illegal_state,
+ tf_set_validity_token_cookie,
+)
+from .twofactor import (
+ complete_two_factor_process,
+ set_rescue_options,
+ tf_clean_session,
+ tf_disable,
+)
+from .utils import (
+ base_render_json,
+ check_and_update_authn_fresh,
+ config_value as cv,
+ do_flash,
+ get_identity_attributes,
+ get_message,
+ get_post_login_redirect,
+ get_post_logout_redirect,
+ get_post_register_redirect,
+ get_post_verify_redirect,
+ get_request_attr,
+ get_url,
+ hash_password,
+ is_user_authenticated,
+ json_error_response,
+ localize_callback,
+ login_user,
+ logout_user,
+ propagate_next,
+ send_mail,
+ slash_url_suffix,
+ url_for_security,
+ view_commit,
+)
+from .webauthn import (
+ has_webauthn,
+ webauthn_delete,
+ webauthn_register,
+ webauthn_register_response,
+ webauthn_signin,
+ webauthn_signin_response,
+ webauthn_verify,
+ webauthn_verify_response,
+)
+
+if get_quart_status(): # pragma: no cover
+ from quart import make_response, redirect
+else:
+ from flask import make_response, redirect
+
+if t.TYPE_CHECKING: # pragma: no cover
+ from flask.typing import ResponseValue
+
+
+def default_render_json(payload, code, headers, user):
+ """Default JSON response handler."""
+ # Force Content-Type header to json.
+ if headers is None:
+ headers = dict()
+ headers["Content-Type"] = "application/json"
+ payload = dict(meta=dict(code=code), response=payload)
+ return make_response(jsonify(payload), code, headers)
+
+
+def _ctx(endpoint):
+ return _security._run_ctx_processor(endpoint)
+
+
+@unauth_csrf()
+def login() -> "ResponseValue":
+ """View function for login view
+
+ Allow already authenticated users. For GET this is useful for
+ single-page-applications on refresh - session still active but need to
+ access user info and csrf-token.
+ For POST - redirects to POST_LOGIN_VIEW (forms) or returns 400 (json).
+ """
+ form = t.cast(LoginForm, build_form_from_request("login_form"))
+
+ if is_user_authenticated(current_user):
+ # Just redirect current_user to POST_LOGIN_VIEW.
+ # While its tempting to try to logout the current user and login the
+ # new requested user - that simply doesn't work with CSRF.
+
+ # This does NOT use get_post_login_redirect() so that it doesn't look at
+ # 'next' - which can cause infinite redirect loops
+ # (see test_common::test_authenticated_loop)
+ if _security._want_json(request):
+ if request.method == "POST":
+ payload = json_error_response(
+ errors=get_message("ANONYMOUS_USER_REQUIRED")[0]
+ )
+ return _security._render_json(payload, 400, None, None)
+ else:
+ form.user = current_user
+ return base_render_json(form)
+ else:
+ return redirect(get_url(cv("POST_LOGIN_VIEW")))
+
+ # Clean out any potential old session info - in case of previous
+ # aborted 2FA attempt.
+ tf_clean_session()
+
+ if form.validate_on_submit():
+ assert form.user is not None
+ remember_me = form.remember.data if "remember" in form else None
+ response = _security.two_factor_plugins.tf_enter(
+ form.user,
+ remember_me,
+ "password",
+ next_loc=propagate_next(request.url, form),
+ )
+ if response:
+ return response
+ # two factor not required - login user
+ after_this_request(view_commit)
+ login_user(form.user, remember=remember_me, authn_via=["password"])
+
+ if _security._want_json(request):
+ return base_render_json(form, include_auth_token=True)
+ return redirect(get_post_login_redirect())
+
+ if request.method == "POST" and cv("RETURN_GENERIC_RESPONSES"):
+ # Validation failed - make sure PII error messages are generic
+ fields_to_squash = dict(
+ email=dict(replace_msg="GENERIC_AUTHN_FAILED"),
+ password=dict(replace_msg="GENERIC_AUTHN_FAILED"),
+ )
+ if hasattr(form, "username"):
+ fields_to_squash["username"] = dict(replace_msg="GENERIC_AUTHN_FAILED")
+ form_errors_munge(form, fields_to_squash)
+
+ if _security._want_json(request):
+ payload = {
+ "identity_attributes": get_identity_attributes(),
+ }
+ return base_render_json(form, additional=payload)
+
+ if (
+ form.requires_confirmation
+ and cv("REQUIRES_CONFIRMATION_ERROR_VIEW")
+ and not cv("RETURN_GENERIC_RESPONSES")
+ ):
+ assert form.user_authenticated
+ do_flash(*get_message("CONFIRMATION_REQUIRED"))
+ return redirect(
+ get_url(
+ cv("REQUIRES_CONFIRMATION_ERROR_VIEW"),
+ qparams={"email": form.email.data},
+ )
+ )
+ return _security.render_template(
+ cv("LOGIN_USER_TEMPLATE"),
+ login_user_form=form,
+ identity_attributes=get_identity_attributes(),
+ **_ctx("login"),
+ )
+
+
+@auth_required(lambda: cv("API_ENABLED_METHODS"))
+def verify():
+ """View function which handles a reauthentication request."""
+ form = build_form_from_request("verify_form", user=current_user)
+
+ if form.validate_on_submit():
+ # form may have called verify_and_update_password()
+ after_this_request(view_commit)
+
+ # verified - so set freshness time.
+ session["fs_paa"] = time.time()
+
+ if _security._want_json(request):
+ return base_render_json(form, include_auth_token=True)
+ do_flash(*get_message("REAUTHENTICATION_SUCCESSFUL"))
+ return redirect(get_post_verify_redirect())
+
+ webauthn_available = has_webauthn(current_user, cv("WAN_ALLOW_AS_VERIFY"))
+ if _security._want_json(request):
+ payload = {
+ "has_webauthn_verify_credential": webauthn_available,
+ }
+ return base_render_json(form, additional=payload)
+
+ return _security.render_template(
+ cv("VERIFY_TEMPLATE"),
+ verify_form=form,
+ has_webauthn_verify_credential=webauthn_available,
+ wan_verify_form=build_form("wan_verify_form"),
+ **_ctx("verify"),
+ )
+
+
+def logout():
+ """View function which handles a logout request."""
+ tf_clean_session()
+
+ if is_user_authenticated(current_user):
+ logout_user()
+
+ # No body is required - so if a POST and json - return OK
+ if request.method == "POST" and _security._want_json(request):
+ return _security._render_json({}, 200, None, None)
+
+ return redirect(get_post_logout_redirect())
+
+
+@anonymous_user_required
+@unauth_csrf()
+def register() -> "ResponseValue":
+ """View function which handles a registration request."""
+
+ # For some unknown historic reason - if you don't require confirmation
+ # (via email) then you need to type in your password twice. That might
+ # make sense if you can't reset your password but in modern (2020) UX models
+ # don't ask twice.
+ if _security.confirmable or request.is_json:
+ form_name = "confirm_register_form"
+ else:
+ form_name = "register_form"
+ form = build_form_from_request(form_name)
+
+ if form.validate_on_submit():
+ after_this_request(view_commit)
+ did_login = False
+ user = register_user(form)
+ form.user = user
+
+ # The 'auto-login' feature probably should be removed - I can't imagine
+ # an application that would want random email accounts. It has been like this
+ # since the beginning. Note that we still enforce 2FA - however for unified
+ # signin - we adhere to historic behavior.
+ if not _security.confirmable or cv("LOGIN_WITHOUT_CONFIRMATION"):
+ response = _security.two_factor_plugins.tf_enter(
+ form.user, False, "register", next_loc=propagate_next(request.url, form)
+ )
+ if response:
+ return response
+ # two factor not required - login user.
+ login_user(user, authn_via=["register"])
+ did_login = True
+
+ if not _security._want_json(request):
+ return redirect(get_post_register_redirect())
+
+ # Only include auth token if in fact user is permitted to login
+ return base_render_json(form, include_auth_token=did_login)
+
+ # Here on GET or failed validate
+ if request.method == "POST" and cv("RETURN_GENERIC_RESPONSES"):
+ gr = register_existing(form)
+ if gr:
+ if _security._want_json(request):
+ return base_render_json(form)
+
+ return redirect(get_post_register_redirect())
+
+ if _security._want_json(request):
+ return base_render_json(form)
+
+ return _security.render_template(
+ cv("REGISTER_USER_TEMPLATE"),
+ register_user_form=form,
+ **_ctx("register"),
+ )
+
+
+@unauth_csrf()
+def send_login():
+ """View function that sends login instructions for passwordless login"""
+ form = build_form_from_request("passwordless_login_form")
+
+ if form.validate_on_submit():
+ send_login_instructions(form.user)
+ if not _security._want_json(request):
+ do_flash(*get_message("LOGIN_EMAIL_SENT", email=form.user.email))
+
+ if _security._want_json(request):
+ return base_render_json(form)
+
+ return _security.render_template(
+ cv("SEND_LOGIN_TEMPLATE"), send_login_form=form, **_ctx("send_login")
+ )
+
+
+@anonymous_user_required
+def token_login(token):
+ """View function that handles passwordless login via a token
+ Like reset-password and confirm - this is usually a GET via an email
+ so from the request we can't differentiate form-based apps from non.
+ """
+
+ expired, invalid, user = login_token_status(token)
+
+ if not user or invalid:
+ m, c = get_message("INVALID_LOGIN_TOKEN")
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(get_url(cv("LOGIN_ERROR_VIEW"), qparams={c: m}))
+ do_flash(m, c)
+ return redirect(url_for_security("login"))
+ if expired:
+ send_login_instructions(user)
+ m, c = get_message("LOGIN_EXPIRED", email=user.email, within=cv("LOGIN_WITHIN"))
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(
+ get_url(
+ cv("LOGIN_ERROR_VIEW"),
+ qparams=user.get_redirect_qparams({c: m}),
+ )
+ )
+ do_flash(m, c)
+ return redirect(url_for_security("login"))
+
+ login_user(user, authn_via=["token"])
+ after_this_request(view_commit)
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(
+ get_url(cv("POST_LOGIN_VIEW"), qparams=user.get_redirect_qparams())
+ )
+
+ do_flash(*get_message("PASSWORDLESS_LOGIN_SUCCESSFUL"))
+
+ return redirect(get_post_login_redirect())
+
+
+@unauth_csrf()
+def send_confirmation():
+ """View function which sends confirmation instructions (/confirm)."""
+ form = t.cast(
+ SendConfirmationForm, build_form_from_request("send_confirmation_form")
+ )
+
+ if form.validate_on_submit():
+ send_confirmation_instructions(form.user)
+ if not _security._want_json(request):
+ do_flash(*get_message("CONFIRMATION_REQUEST", email=form.email.data))
+
+ elif request.method == "POST" and cv("RETURN_GENERIC_RESPONSES"):
+ # Here on GET or failed validate
+ rinfo = dict(email=dict())
+ form_errors_munge(form, rinfo) # by suppressing errors JSON should return 200
+ # Check for other errors - for default form - there aren't additional fields
+ # but applications might add some (e.g. recaptcha)
+ if not form.errors:
+ # Make look exactly like successful (e.g. real user) request
+ if not _security._want_json(request):
+ do_flash(*get_message("CONFIRMATION_REQUEST", email=form.email.data))
+
+ if _security._want_json(request):
+ # Never include user info since this is an anonymous endpoint.
+ return base_render_json(form, include_user=False)
+
+ return _security.render_template(
+ cv("SEND_CONFIRMATION_TEMPLATE"),
+ send_confirmation_form=form,
+ **_ctx("send_confirmation"),
+ )
+
+
+def confirm_email(token):
+ """
+ View function which handles an email confirmation request.
+ This is always a GET from an email - so for 'spa' must always redirect.
+ """
+
+ expired, invalid, user = confirm_email_token_status(token)
+
+ if not user or invalid or expired:
+ if expired:
+ m, c = get_message(
+ "CONFIRMATION_EXPIRED",
+ within=cv("CONFIRM_EMAIL_WITHIN"),
+ )
+ else:
+ m, c = get_message("INVALID_CONFIRMATION_TOKEN")
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(get_url(cv("CONFIRM_ERROR_VIEW"), qparams={c: m}))
+ do_flash(m, c)
+ return redirect(
+ get_url(cv("CONFIRM_ERROR_VIEW")) or url_for_security("send_confirmation")
+ )
+
+ already_confirmed = user.confirmed_at is not None
+ if already_confirmed:
+ m, c = get_message("ALREADY_CONFIRMED")
+
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ # No reason to expose identity info to anyone who has the link
+ return redirect(
+ get_url(
+ cv("CONFIRM_ERROR_VIEW"),
+ qparams={c: m},
+ )
+ )
+
+ do_flash(m, c)
+ return redirect(
+ get_url(cv("CONFIRM_ERROR_VIEW")) or url_for_security("send_confirmation")
+ )
+
+ confirm_user(user)
+ after_this_request(view_commit)
+ m, c = get_message("EMAIL_CONFIRMED")
+
+ # ? The only case where user is logged in already would be if
+ # LOGIN_WITHOUT_CONFIRMATION
+ if user != current_user:
+ logout_user()
+ if cv("AUTO_LOGIN_AFTER_CONFIRM"):
+ # N.B. this is a (small) security risk if email went to wrong place.
+ # and you have the LOGIN_WITHOUT_CONFIRMATION flag since in that case
+ # you can be logged in and doing stuff - but another person could
+ # get the email.
+ # Note also this goes against OWASP recommendations.
+ response = _security.two_factor_plugins.tf_enter(
+ user, False, "confirm", next_loc=propagate_next(request.url, None)
+ )
+ if response:
+ do_flash(m, c)
+ return response
+ login_user(user, authn_via=["confirm"])
+
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(
+ get_url(
+ cv("POST_CONFIRM_VIEW"),
+ qparams=user.get_redirect_qparams({c: m}),
+ )
+ )
+ do_flash(m, c)
+ return redirect(
+ get_url(cv("POST_CONFIRM_VIEW"))
+ or get_url(
+ cv("POST_LOGIN_VIEW") if cv("AUTO_LOGIN_AFTER_CONFIRM") else ".login"
+ )
+ )
+
+
+@anonymous_user_required
+@unauth_csrf()
+def forgot_password():
+ """View function that handles a forgotten password request (/reset)."""
+ form = t.cast(ForgotPasswordForm, build_form_from_request("forgot_password_form"))
+
+ if form.validate_on_submit():
+ send_reset_password_instructions(form.user)
+ if not _security._want_json(request):
+ do_flash(*get_message("PASSWORD_RESET_REQUEST", email=form.email.data))
+
+ elif request.method == "POST" and cv("RETURN_GENERIC_RESPONSES"):
+ # Here on failed validate (POST) and want generic responses
+ rinfo = dict(email=dict())
+ form_errors_munge(form, rinfo) # by suppressing errors JSON should return 200
+ # Check for other errors - for default form - there aren't additional fields
+ # but applications might add some (e.g. recaptcha)
+ if not form.errors:
+ # No OTHER errors on form.
+ # Make look exactly like successful (e.g. real user) request
+ hash_password("not-a-password") # reduce timing between successful and not.
+ if not _security._want_json(request):
+ do_flash(*get_message("PASSWORD_RESET_REQUEST", email=form.email.data))
+
+ if _security._want_json(request):
+ # Never include user info since this is an anonymous endpoint.
+ return base_render_json(form, include_user=False)
+
+ if (
+ form.requires_confirmation
+ and cv("REQUIRES_CONFIRMATION_ERROR_VIEW")
+ and not cv("RETURN_GENERIC_RESPONSES")
+ ):
+ do_flash(*get_message("CONFIRMATION_REQUIRED"))
+ return redirect(
+ get_url(
+ cv("REQUIRES_CONFIRMATION_ERROR_VIEW"),
+ qparams={"email": form.email.data},
+ )
+ )
+
+ return _security.render_template(
+ cv("FORGOT_PASSWORD_TEMPLATE"),
+ forgot_password_form=form,
+ **_ctx("forgot_password"),
+ )
+
+
+@anonymous_user_required
+@unauth_csrf()
+def reset_password(token):
+ """View function that handles a reset password request (/reset/).
+
+ This is usually called via GET as part of an email link and redirects to
+ a reset-password form
+ It is called via POST to actually update the password (and then redirects to
+ a post reset/login view)
+ If in either case the token is either invalid or expired it redirects to
+ the 'forgot-password' form.
+
+ In the case of non-form based configuration:
+ For GET normal case - redirect to RESET_VIEW?token={token}
+ For GET invalid case - redirect to RESET_ERROR_VIEW?error={error}
+ For POST normal/successful case - return 200 with new authentication token
+ For POST error case return 400
+ """
+
+ expired, invalid, user = reset_password_token_status(token)
+ form = t.cast(ResetPasswordForm, build_form_from_request("reset_password_form"))
+ form.user = user
+
+ if request.method == "GET":
+ if not user or invalid or expired:
+ if expired:
+ m, c = get_message(
+ "PASSWORD_RESET_EXPIRED",
+ within=cv("RESET_PASSWORD_WITHIN"),
+ )
+ else:
+ m, c = get_message("INVALID_RESET_PASSWORD_TOKEN")
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(get_url(cv("RESET_ERROR_VIEW"), qparams={c: m}))
+ do_flash(m, c)
+ return redirect(url_for_security("forgot_password"))
+
+ # All good - for SPA - redirect to the ``reset_view``
+ # Still - don't include PII such as identity and email if someone
+ # intercepts link they still won't necessarily know the login identity
+ # (even though they can change the password!).
+ if cv("REDIRECT_BEHAVIOR") == "spa":
+ return redirect(
+ get_url(
+ cv("RESET_VIEW"),
+ qparams={"token": token},
+ )
+ )
+ # for forms - render the reset password form
+ return _security.render_template(
+ cv("RESET_PASSWORD_TEMPLATE"),
+ reset_password_form=form,
+ reset_password_token=token,
+ **_ctx("reset_password"),
+ )
+
+ # This is the POST case.
+ if not user or invalid or expired:
+ if expired:
+ m, c = get_message(
+ "PASSWORD_RESET_EXPIRED", within=cv("RESET_PASSWORD_WITHIN")
+ )
+ else:
+ m, c = get_message("INVALID_RESET_PASSWORD_TOKEN")
+
+ if _security._want_json(request):
+ form.form_errors.append(m)
+ return base_render_json(form, include_user=False)
+ else:
+ do_flash(m, c)
+ return redirect(url_for_security("forgot_password"))
+
+ if form.validate_on_submit():
+ after_this_request(view_commit)
+ update_password(user, form.password.data)
+ if cv("AUTO_LOGIN_AFTER_RESET"):
+ # backwards compat - really shouldn't do this according to OWASP
+ response = _security.two_factor_plugins.tf_enter(
+ form.user, False, "reset", next_loc=propagate_next(request.url, None)
+ )
+ if response:
+ return response
+ # two factor not required - just login
+ login_user(user, authn_via=["reset"])
+ if _security._want_json(request):
+ dummy_form = DummyForm(formdata=None)
+ dummy_form.user = user
+ return base_render_json(dummy_form, include_auth_token=True)
+ else:
+ do_flash(*get_message("PASSWORD_RESET"))
+ return redirect(
+ get_url(cv("POST_RESET_VIEW")) or get_url(cv("POST_LOGIN_VIEW"))
+ )
+ else:
+ if _security._want_json(request):
+ return _security._render_json({}, 200, None, None)
+ else:
+ do_flash(*get_message("PASSWORD_RESET_NO_LOGIN"))
+ return redirect(get_url(cv("POST_RESET_VIEW")) or get_url(".login"))
+
+ # validation failure case - for forms - we try again including the token
+ # for non-forms - we just return errors and assume caller remembers token.
+ if _security._want_json(request):
+ return base_render_json(form)
+ return _security.render_template(
+ cv("RESET_PASSWORD_TEMPLATE"),
+ reset_password_form=form,
+ reset_password_token=token,
+ **_ctx("reset_password"),
+ )
+
+
+@auth_required(lambda: cv("API_ENABLED_METHODS"))
+def change_password():
+ """View function which handles a change password request."""
+ form = t.cast(ChangePasswordForm, build_form_from_request("change_password_form"))
+
+ if not current_user.password:
+ # This is case where user registered w/o a password - since we can't
+ # confirm with existing password - make sure fresh using whatever authentication
+ # method they have set up.
+ if not check_and_update_authn_fresh(
+ cv("FRESHNESS"),
+ cv("FRESHNESS_GRACE_PERIOD"),
+ get_request_attr("fs_authn_via"),
+ ):
+ return _security._reauthn_handler(
+ cv("FRESHNESS"), cv("FRESHNESS_GRACE_PERIOD")
+ )
+
+ if form.validate_on_submit():
+ after_this_request(view_commit)
+ change_user_password(current_user._get_current_object(), form.new_password.data)
+ if _security._want_json(request):
+ form.user = current_user
+ return base_render_json(form, include_auth_token=True)
+
+ do_flash(*get_message("PASSWORD_CHANGE"))
+ return redirect(
+ get_url(cv("POST_CHANGE_VIEW")) or get_url(cv("POST_LOGIN_VIEW"))
+ )
+
+ active_password = True if current_user.password else False
+ if _security._want_json(request):
+ form.user = current_user
+ payload = dict(active_password=active_password)
+ return base_render_json(form, additional=payload)
+
+ return _security.render_template(
+ cv("CHANGE_PASSWORD_TEMPLATE"),
+ change_password_form=form,
+ active_password=active_password,
+ **_ctx("change_password"),
+ )
+
+
+@unauth_csrf()
+def two_factor_setup():
+ """View function for two-factor setup.
+
+ This is used both for GET to fetch forms and POST to actually set configuration
+ (and send token).
+
+ There are 3 cases for setting up:
+ 1) initial login and application requires 2FA
+ 2) changing existing 2FA information
+ 3) user wanting to enable or disable 2FA (assuming application doesn't require it)
+
+ In order to CHANGE/ENABLE/DISABLE a 2FA information, user must be properly logged in
+ AND have a 'fresh' authentication.
+
+ For initial login when 2FA required of course user can't be logged in - in this
+ case we need to have been sent some
+ state via the session as part of login to show a) who and b) that they successfully
+ authenticated.
+ """
+ form = t.cast(TwoFactorSetupForm, build_form_from_request("two_factor_setup_form"))
+
+ if not is_user_authenticated(current_user):
+ # This is the initial login case
+ # We can also get here from setup if they want to change TODO: how?
+ if not all(k in session for k in ["tf_user_id", "tf_state"]) or session[
+ "tf_state"
+ ] not in ["setup_from_login", "validating_profile"]:
+ # illegal call on this endpoint
+ tf_clean_session()
+ return tf_illegal_state(form, cv("TWO_FACTOR_ERROR_VIEW"))
+
+ user = _datastore.find_user(fs_uniquifier=session["tf_user_id"])
+ if not user:
+ tf_clean_session()
+ return tf_illegal_state(form, cv("TWO_FACTOR_ERROR_VIEW"))
+
+ else:
+ # Caller is changing their TFA profile. This requires a 'fresh' authentication
+ # N.B unauth_csrf has done the CSRF check already.
+ if not check_and_update_authn_fresh(
+ cv("FRESHNESS"),
+ cv("FRESHNESS_GRACE_PERIOD"),
+ get_request_attr("fs_authn_via"),
+ ):
+ return _security._reauthn_handler(
+ cv("FRESHNESS"), cv("FRESHNESS_GRACE_PERIOD")
+ )
+ user = current_user
+
+ if form.validate_on_submit():
+ # Before storing in DB and therefore requiring 2FA we need to
+ # make sure it actually works.
+ # Requiring 2FA is triggered by having BOTH tf_totp_secret and
+ # tf_primary_method in the user record (or having the application
+ # global config TWO_FACTOR_REQUIRED)
+ # Until we correctly validate the 2FA - we don't set primary_method in
+ # user model but use the session to store it.
+ pm = form.setup.data
+ if pm == "disable":
+ tf_disable(user)
+ after_this_request(view_commit)
+ if not _security._want_json(request):
+ do_flash(*get_message("TWO_FACTOR_DISABLED"))
+ return redirect(get_url(cv("TWO_FACTOR_POST_SETUP_VIEW")))
+ else:
+ return base_render_json(form)
+
+ # Regenerate the TOTP secret on every call of 2FA setup
+ totp = _security._totp_factory.generate_totp_secret()
+ phone = form.phone.data if pm == "sms" else None
+ session["tf_totp_secret"] = totp
+ session["tf_primary_method"] = pm
+ session["tf_state"] = "validating_profile"
+ json_response = {
+ "tf_state": "validating_profile",
+ "tf_primary_method": pm, # old
+ "tf_method": pm,
+ }
+ if phone:
+ # TODO dont save here - wait until complete
+ user.tf_phone_number = phone
+ _datastore.put(user)
+ after_this_request(view_commit)
+
+ if (
+ pm == "email" or pm == "sms"
+ ): # TODO not sure this is needed - send checks this
+ msg = user.tf_send_security_token(
+ method=pm,
+ totp_secret=totp,
+ phone_number=phone,
+ )
+ if msg:
+ # send code didn't work
+ form.setup.errors = list()
+ form.setup.errors.append(msg)
+ if _security._want_json(request):
+ return base_render_json(
+ form, include_user=False, error_status_code=500
+ )
+
+ qrcode_values = dict()
+ if pm == "authenticator":
+ authr_setup_values = _security._totp_factory.fetch_setup_values(totp, user)
+ # Add all the values used in qrcode to json response
+ json_response["tf_authr_key"] = authr_setup_values["key"]
+ json_response["tf_authr_username"] = authr_setup_values["username"]
+ json_response["tf_authr_issuer"] = authr_setup_values["issuer"]
+
+ qrcode_values = dict(
+ authr_qrcode=authr_setup_values["image"],
+ authr_key=authr_setup_values["key"],
+ authr_username=authr_setup_values["username"],
+ authr_issuer=authr_setup_values["issuer"],
+ )
+ if _security._want_json(request):
+ return base_render_json(form, include_user=False, additional=json_response)
+ code_form = build_form("two_factor_verify_code_form")
+ return _security.render_template(
+ cv("TWO_FACTOR_SETUP_TEMPLATE"),
+ two_factor_setup_form=form,
+ two_factor_verify_code_form=code_form,
+ choices=cv("TWO_FACTOR_ENABLED_METHODS"),
+ chosen_method=pm, # do not translate
+ primary_method=localize_callback(
+ _setup_methods_xlate[getattr(user, "tf_primary_method", None)]
+ ),
+ **qrcode_values,
+ **_ctx("tf_setup"),
+ )
+
+ # We get here on GET and POST with failed validation.
+ # For things like phone number - we've already done one POST
+ # that succeeded and now it failed - so retain the initial info
+ choices = cv("TWO_FACTOR_ENABLED_METHODS")
+ if (not cv("TWO_FACTOR_REQUIRED")) and user.tf_primary_method is not None:
+ choices.insert(0, "disable")
+
+ if _security._want_json(request):
+ # Provide information application/UI might need to render their own form/input
+ json_response = {
+ "tf_required": cv("TWO_FACTOR_REQUIRED"),
+ "tf_primary_method": getattr(user, "tf_primary_method", None), # old
+ "tf_method": getattr(user, "tf_primary_method", None),
+ "tf_phone_number": getattr(user, "tf_phone_number", None),
+ "tf_available_methods": choices,
+ }
+ return base_render_json(form, include_user=False, additional=json_response)
+
+ code_form = build_form("two_factor_verify_code_form")
+ return _security.render_template(
+ cv("TWO_FACTOR_SETUP_TEMPLATE"),
+ two_factor_setup_form=form,
+ two_factor_verify_code_form=code_form,
+ choices=choices,
+ chosen_method=form.setup.data,
+ primary_method=localize_callback(
+ _setup_methods_xlate[getattr(user, "tf_primary_method", None)]
+ ),
+ two_factor_required=cv("TWO_FACTOR_REQUIRED"),
+ **_ctx("tf_setup"),
+ )
+
+
+@unauth_csrf()
+def two_factor_token_validation():
+ """View function for two-factor token validation
+
+ Two cases:
+ 1) normal login case - everything setup correctly; normal 2FA validation
+ In this case - user not logged in -
+ but 'tf_state' == 'ready' or 'validating_profile'
+ 2) validating after CHANGE/ENABLE 2FA. In this case user logged in/authenticated
+ In this case we allow a GET to get the specific enter-code form.
+
+ """
+ form = t.cast(
+ TwoFactorVerifyCodeForm, build_form_from_request("two_factor_verify_code_form")
+ )
+
+ # state info in session
+ pm = session.get("tf_primary_method", None)
+ totp_secret = session.get("tf_totp_secret", None)
+ tf_state = session.get("tf_state", None)
+ tf_user_id = session.get("tf_user_id", None)
+
+ changing = is_user_authenticated(current_user)
+ if not changing:
+ # This is the normal login case OR initial setup (two factor required)
+ if (
+ tf_state not in ["ready", "validating_profile"]
+ or (tf_state == "validating_profile" and not all([pm, totp_secret]))
+ or not tf_user_id
+ ):
+ # illegal call on this endpoint
+ tf_clean_session()
+ return tf_illegal_state(form, cv("TWO_FACTOR_ERROR_VIEW"))
+
+ user = _datastore.find_user(fs_uniquifier=tf_user_id)
+ form.user = user
+ if not user:
+ tf_clean_session()
+ return tf_illegal_state(form, cv("TWO_FACTOR_ERROR_VIEW"))
+
+ if tf_state == "ready":
+ # normal login case - use saved values
+ pm = user.tf_primary_method
+ totp_secret = user.tf_totp_secret
+ else:
+ # Changing TFA profile - user is already authenticated.
+ if tf_state != "validating_profile" or not all([pm, totp_secret]):
+ tf_clean_session()
+ # logout since this seems like attack-ish/logic error
+ logout_user()
+ return tf_illegal_state(form, cv("TWO_FACTOR_ERROR_VIEW"))
+ form.user = current_user
+
+ form.primary_method = pm
+ form.tf_totp_secret = totp_secret
+ if form.validate_on_submit():
+ # Success - finish process based on 'changing' and clear all session variables
+ completion_message, token = complete_two_factor_process(
+ form.user, pm, totp_secret, changing
+ )
+
+ after_this_request(view_commit)
+ if token:
+ after_this_request(partial(tf_set_validity_token_cookie, token=token))
+
+ if not _security._want_json(request):
+ do_flash(*get_message(completion_message))
+ if changing:
+ return redirect(get_url(cv("TWO_FACTOR_POST_SETUP_VIEW")))
+ else:
+ return redirect(get_post_login_redirect())
+
+ else:
+ return base_render_json(form, include_auth_token=True)
+
+ # GET or not successful POST
+
+ # if we were trying to validate a new method
+ if changing:
+ if _security._want_json(request):
+ return base_render_json(form)
+ # allow app to fetch just this form (independent of /tf_setup)
+ return _security.render_template(
+ cv("TWO_FACTOR_VERIFY_CODE_TEMPLATE"),
+ two_factor_verify_code_form=form,
+ chosen_method=localize_callback(_setup_methods_xlate[pm]),
+ **_ctx("tf_token_validation"),
+ )
+
+ # if we were trying to validate an existing method
+ else:
+ rescue_form = build_form("two_factor_rescue_form")
+ recovery_options = set_rescue_options(rescue_form, form.user)
+ if _security._want_json(request):
+ return base_render_json(
+ form, additional=dict(recovery_options=recovery_options)
+ )
+ return _security.render_template(
+ cv("TWO_FACTOR_VERIFY_CODE_TEMPLATE"),
+ two_factor_rescue_form=rescue_form,
+ two_factor_verify_code_form=form,
+ chosen_method=localize_callback(_setup_methods_xlate[pm]),
+ problem=None,
+ **_ctx("tf_token_validation"),
+ )
+
+
+@anonymous_user_required
+@unauth_csrf()
+def two_factor_rescue():
+ """Function that handles a situation where user can't
+ enter his two-factor validation code
+
+ User must have already provided valid username/password.
+ User must have already established 2FA
+
+ """
+ form = t.cast(
+ TwoFactorRescueForm, build_form_from_request("two_factor_rescue_form")
+ )
+
+ form.user = tf_check_state(["ready"])
+ if not form.user:
+ return tf_illegal_state(form, cv("TWO_FACTOR_ERROR_VIEW"))
+
+ recovery_options = set_rescue_options(form, form.user)
+ rproblem = ""
+ if form.validate_on_submit():
+ raction = form.help_setup.data
+ rproblem = raction
+ if raction == "email":
+ msg = form.user.tf_send_security_token(
+ method="email",
+ totp_secret=form.user.tf_totp_secret,
+ phone_number=getattr(form.user, "tf_phone_number", None),
+ )
+ if msg:
+ rproblem = ""
+ form.help_setup.errors.append(msg)
+ if _security._want_json(request):
+ return base_render_json(
+ form, include_user=False, error_status_code=500
+ )
+ # drop through to GET path
+ elif raction == "recovery_code":
+ return redirect(url_for_security("mf_recovery"))
+
+ # send app provider a mail message regarding trouble
+ elif raction == "help":
+ send_mail(
+ cv("EMAIL_SUBJECT_TWO_FACTOR_RESCUE"),
+ cv("TWO_FACTOR_RESCUE_MAIL"),
+ "two_factor_rescue",
+ user=form.user,
+ )
+ # drop through to GET path
+ else:
+ return "", 404
+
+ if _security._want_json(request):
+ return base_render_json(
+ form, include_user=False, additional=dict(recovery_options=recovery_options)
+ )
+
+ code_form = build_form("two_factor_verify_code_form")
+ return _security.render_template(
+ cv("TWO_FACTOR_VERIFY_CODE_TEMPLATE"),
+ two_factor_verify_code_form=code_form,
+ two_factor_rescue_form=form,
+ chosen_method=localize_callback(
+ _setup_methods_xlate[form.user.tf_primary_method]
+ ),
+ rescue_mail=cv("TWO_FACTOR_RESCUE_MAIL"),
+ problem=rproblem,
+ **_ctx("tf_token_validation"),
+ )
+
+
+def create_blueprint(app, state, import_name):
+ """Creates the security extension blueprint"""
+
+ bp = Blueprint(
+ cv("BLUEPRINT_NAME", app=app),
+ import_name,
+ url_prefix=cv("URL_PREFIX", app=app),
+ subdomain=cv("SUBDOMAIN", app=app),
+ template_folder="templates",
+ static_folder=cv("STATIC_FOLDER", app),
+ static_url_path=cv("STATIC_FOLDER_URL", app),
+ )
+
+ if cv("LOGOUT_METHODS", app=app) is not None:
+ bp.route(
+ cv("LOGOUT_URL", app=app),
+ methods=cv("LOGOUT_METHODS", app=app),
+ endpoint="logout",
+ )(logout)
+
+ login_url = cv("LOGIN_URL", app=app)
+ if state.passwordless:
+ bp.route(login_url, methods=["GET", "POST"], endpoint="login")(send_login)
+ bp.route(
+ login_url + slash_url_suffix(login_url, ""),
+ endpoint="token_login",
+ )(token_login)
+ elif cv("US_SIGNIN_REPLACES_LOGIN", app=app):
+ bp.route(login_url, methods=["GET", "POST"], endpoint="login")(us_signin)
+
+ else:
+ bp.route(login_url, methods=["GET", "POST"], endpoint="login")(login)
+
+ if cv("FRESHNESS", app=app).total_seconds() >= 0:
+ bp.route(cv("VERIFY_URL", app=app), methods=["GET", "POST"], endpoint="verify")(
+ verify
+ )
+
+ if state.unified_signin:
+ us_signin_url = cv("US_SIGNIN_URL", app=app)
+ us_signin_send_code_url = cv("US_SIGNIN_SEND_CODE_URL", app=app)
+ us_setup_url = cv("US_SETUP_URL", app=app)
+ us_verify_url = cv("US_VERIFY_URL", app=app)
+ us_verify_send_code_url = cv("US_VERIFY_SEND_CODE_URL", app=app)
+ us_verify_link_url = cv("US_VERIFY_LINK_URL", app=app)
+ bp.route(us_signin_url, methods=["GET", "POST"], endpoint="us_signin")(
+ us_signin
+ )
+ bp.route(
+ us_signin_send_code_url,
+ methods=["POST"],
+ endpoint="us_signin_send_code",
+ )(us_signin_send_code)
+
+ bp.route(us_setup_url, methods=["GET", "POST"], endpoint="us_setup")(us_setup)
+ bp.route(
+ us_setup_url + slash_url_suffix(us_setup_url, ""),
+ methods=["POST"],
+ endpoint="us_setup_validate",
+ )(us_setup_validate)
+
+ # Freshness verification
+ if cv("FRESHNESS", app=app).total_seconds() >= 0:
+ bp.route(us_verify_url, methods=["GET", "POST"], endpoint="us_verify")(
+ us_verify
+ )
+ bp.route(
+ us_verify_send_code_url,
+ methods=["POST"],
+ endpoint="us_verify_send_code",
+ )(us_verify_send_code)
+
+ bp.route(us_verify_link_url, methods=["GET"], endpoint="us_verify_link")(
+ us_verify_link
+ )
+
+ if state.two_factor:
+ two_factor_setup_url = cv("TWO_FACTOR_SETUP_URL", app=app)
+ two_factor_token_validation_url = cv("TWO_FACTOR_TOKEN_VALIDATION_URL", app=app)
+ two_factor_rescue_url = cv("TWO_FACTOR_RESCUE_URL", app=app)
+ bp.route(
+ two_factor_setup_url,
+ methods=["GET", "POST"],
+ endpoint="two_factor_setup",
+ )(two_factor_setup)
+ bp.route(
+ two_factor_token_validation_url,
+ methods=["GET", "POST"],
+ endpoint="two_factor_token_validation",
+ )(two_factor_token_validation)
+ bp.route(
+ two_factor_rescue_url,
+ methods=["GET", "POST"],
+ endpoint="two_factor_rescue",
+ )(two_factor_rescue)
+
+ if state.registerable:
+ bp.route(
+ cv("REGISTER_URL", app=app), methods=["GET", "POST"], endpoint="register"
+ )(register)
+
+ if state.recoverable:
+ reset_url = cv("RESET_URL", app=app)
+ bp.route(reset_url, methods=["GET", "POST"], endpoint="forgot_password")(
+ forgot_password
+ )
+ bp.route(
+ reset_url + slash_url_suffix(reset_url, ""),
+ methods=["GET", "POST"],
+ endpoint="reset_password",
+ )(reset_password)
+
+ if state.changeable:
+ bp.route(
+ cv("CHANGE_URL", app=app),
+ methods=["GET", "POST"],
+ endpoint="change_password",
+ )(change_password)
+
+ if state.confirmable:
+ confirm_url = cv("CONFIRM_URL", app=app)
+ bp.route(confirm_url, methods=["GET", "POST"], endpoint="send_confirmation")(
+ send_confirmation
+ )
+ bp.route(
+ confirm_url + slash_url_suffix(confirm_url, ""),
+ methods=["GET", "POST"],
+ endpoint="confirm_email",
+ )(confirm_email)
+
+ if cv("MULTI_FACTOR_RECOVERY_CODES", app) and state.support_mfa:
+ multi_factor_recovery_codes_url = cv("MULTI_FACTOR_RECOVERY_CODES_URL", app=app)
+ multi_factor_recovery_url = cv("MULTI_FACTOR_RECOVERY_URL", app=app)
+ bp.route(
+ multi_factor_recovery_codes_url,
+ methods=["GET", "POST"],
+ endpoint="mf_recovery_codes",
+ )(mf_recovery_codes)
+ bp.route(
+ multi_factor_recovery_url,
+ methods=["GET", "POST"],
+ endpoint="mf_recovery",
+ )(mf_recovery)
+
+ if state.webauthn:
+ wan_register_url = cv("WAN_REGISTER_URL", app=app)
+ wan_signin_url = cv("WAN_SIGNIN_URL", app=app)
+ wan_delete_url = cv("WAN_DELETE_URL", app=app)
+ wan_verify_url = cv("WAN_VERIFY_URL", app=app)
+ bp.route(
+ wan_register_url,
+ methods=["GET", "POST"],
+ endpoint="wan_register",
+ )(webauthn_register)
+ bp.route(
+ wan_register_url + slash_url_suffix(wan_register_url, ""),
+ methods=["POST"],
+ endpoint="wan_register_response",
+ )(webauthn_register_response)
+
+ bp.route(wan_signin_url, methods=["GET", "POST"], endpoint="wan_signin")(
+ webauthn_signin
+ )
+ bp.route(
+ wan_signin_url + slash_url_suffix(wan_signin_url, ""),
+ methods=["POST"],
+ endpoint="wan_signin_response",
+ )(webauthn_signin_response)
+ bp.route(wan_delete_url, methods=["GET", "POST"], endpoint="wan_delete")(
+ webauthn_delete
+ )
+ if cv("FRESHNESS", app=app).total_seconds() >= 0 and cv(
+ "WAN_ALLOW_AS_VERIFY", app=app
+ ):
+ bp.route(wan_verify_url, methods=["GET", "POST"], endpoint="wan_verify")(
+ webauthn_verify
+ )
+ bp.route(
+ wan_verify_url + slash_url_suffix(wan_verify_url, ""),
+ methods=["POST"],
+ endpoint="wan_verify_response",
+ )(webauthn_verify_response)
+
+ return bp
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/webauthn.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/webauthn.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4fa915529f1bc3e67a7cb60e4b1b3e204428a23
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/webauthn.py
@@ -0,0 +1,948 @@
+"""
+ flask_security.webauthn
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Flask-Security WebAuthn module
+
+ :copyright: (c) 2021-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+
+ This implements support for webauthn/FIDO2 Level 2 using the py_webauthn package.
+
+ Check out: https://golb.hplar.ch/2019/08/webauthn.html
+ for some ideas on recovery and adding additional authenticators.
+
+ For testing - you can see your YubiKey (or other) resident keys in chrome!
+ chrome://settings/securityKeys
+
+ Observation: if key isn't resident than Chrome for example won't let you use
+ it if it isn't part of allowedCredentials - throw error: referencing:
+ https://www.w3.org/TR/webauthn-2/#sctn-privacy-considerations-client
+
+ TODO:
+ - update/add examples to support webauthn
+ - should we universally add endpoint urls to JSON responses?
+ - Add a way to order registered credentials so we can return an ordered list
+ in allowCredentials.
+ - #sctn-usecase-new-device-registration - allow more than one "first" key
+ and have them not necessarily be cross-platform.. add form option?
+
+ Research:
+ - should we store things like user verified in 'last use'...
+ - By insisting on 2FA if user has registered a webauthn - things
+ get interesting if they try to log in on a different device....
+ How would they register a security key for a new device? They would need
+ some OTHER 2FA? Force them to register a NEW webauthn key?
+
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import typing as t
+from functools import partial
+
+from flask import abort, after_this_request, request, session
+from flask import current_app
+from flask_login import current_user
+from wtforms import BooleanField, HiddenField, RadioField, StringField, SubmitField
+from .forms import NextFormMixin
+
+try:
+ import webauthn
+ from webauthn.authentication.verify_authentication_response import (
+ VerifiedAuthentication,
+ )
+ from webauthn.registration.verify_registration_response import VerifiedRegistration
+ from webauthn.helpers import (
+ parse_registration_credential_json,
+ parse_authentication_credential_json,
+ )
+ from webauthn.helpers.exceptions import (
+ InvalidAuthenticationResponse,
+ InvalidJSONStructure,
+ InvalidRegistrationResponse,
+ )
+ from webauthn.helpers.structs import (
+ AuthenticatorTransport,
+ PublicKeyCredentialDescriptor,
+ PublicKeyCredentialType,
+ UserVerificationRequirement,
+ )
+ from webauthn.helpers import bytes_to_base64url
+except ImportError: # pragma: no cover
+ pass
+
+from .decorators import anonymous_user_required, auth_required, unauth_csrf
+from .forms import (
+ Form,
+ Required,
+ build_form_from_request,
+ build_form,
+ get_form_field_label,
+ get_form_field_xlate,
+)
+from .proxies import _security, _datastore
+from .quart_compat import get_quart_status
+from .signals import wan_registered, wan_deleted
+from .tf_plugin import TfPluginBase, tf_set_validity_token_cookie
+from .utils import (
+ _,
+ base_render_json,
+ check_and_get_token_status,
+ config_value as cv,
+ do_flash,
+ get_message,
+ get_post_login_redirect,
+ get_post_verify_redirect,
+ get_url,
+ get_within_delta,
+ login_user,
+ lookup_identity,
+ propagate_next,
+ simple_render_json,
+ url_for_security,
+ view_commit,
+)
+
+if t.TYPE_CHECKING: # pragma: no cover
+ import flask
+ from flask.typing import ResponseValue
+ from .core import Security
+ from .datastore import User, WebAuthn
+
+if get_quart_status(): # pragma: no cover
+ from quart import redirect
+else:
+ from flask import redirect
+
+
+class WebAuthnRegisterForm(Form):
+ name = StringField(
+ get_form_field_xlate(_("Nickname")),
+ validators=[Required(message="WEBAUTHN_NAME_REQUIRED")],
+ )
+ usage = RadioField(
+ get_form_field_xlate(_("Usage")),
+ choices=[
+ ("first", get_form_field_xlate(_("Use as a first authentication factor"))),
+ (
+ "secondary",
+ get_form_field_xlate(_("Use as a secondary authentication factor")),
+ ),
+ ],
+ default="secondary",
+ validate_choice=True,
+ )
+ submit = SubmitField(label=get_form_field_label("submit"), id="wan_register")
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+ inuse = any([self.name.data == cred.name for cred in current_user.webauthn])
+ if inuse:
+ msg = get_message("WEBAUTHN_NAME_INUSE", name=self.name.data)[0]
+ self.name.errors.append(msg)
+ return False
+ if not cv("WAN_ALLOW_AS_FIRST_FACTOR"):
+ self.usage.data = "secondary"
+ return True
+
+
+class WebAuthnRegisterResponseForm(Form):
+ credential = HiddenField()
+ submit = SubmitField(label=get_form_field_label("submit"))
+
+ # from state
+ challenge: str
+ name: str
+ usage: str
+ user_verification: bool
+ # this is returned to caller (not part of the client form)
+ registration_verification: VerifiedRegistration
+ transports: list[AuthenticatorTransport] = []
+ extensions: str
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False # pragma: no cover
+ inuse = any([self.name == cred.name for cred in current_user.webauthn])
+ if inuse:
+ msg = get_message("WEBAUTHN_NAME_INUSE", name=self.name)[0]
+ self.credential.errors.append(msg)
+ return False
+ try:
+ reg_cred = parse_registration_credential_json(self.credential.data)
+ except (
+ ValueError,
+ KeyError,
+ InvalidJSONStructure,
+ InvalidRegistrationResponse,
+ ):
+ self.credential.errors.append(get_message("API_ERROR")[0])
+ return False
+ try:
+ self.registration_verification = webauthn.verify_registration_response(
+ credential=reg_cred,
+ expected_challenge=self.challenge.encode(),
+ expected_origin=_security._webauthn_util.origin(),
+ expected_rp_id=request.host.split(":")[0],
+ require_user_verification=self.user_verification,
+ )
+ if _datastore.find_webauthn(credential_id=reg_cred.raw_id):
+ msg = get_message("WEBAUTHN_CREDENTIAL_ID_INUSE")[0]
+ self.credential.errors.append(msg)
+ return False
+ except KeyError:
+ self.credential.errors.append(get_message("API_ERROR")[0])
+ return False
+ except InvalidRegistrationResponse as exc:
+ self.credential.errors.append(
+ get_message("WEBAUTHN_NO_VERIFY", cause=str(exc))[0]
+ )
+ return False
+
+ self.transports = (
+ reg_cred.response.transports if reg_cred.response.transports else []
+ )
+ # Alas py_webauthn doesn't support extensions
+ response_full = json.loads(self.credential.data)
+ # TODO - verify this is JSON (created with JSON.stringify)
+ self.extensions = response_full.get("extensions", None)
+ return True
+
+
+class WebAuthnSigninForm(Form, NextFormMixin):
+ identity = StringField(get_form_field_label("identity"))
+ remember = BooleanField(get_form_field_label("remember_me"))
+ submit = SubmitField(label=get_form_field_xlate(_("Start")), id="wan_signin")
+
+ user: User | None = None
+ # set by caller - is this a second factor authentication?
+ is_secondary: bool
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.remember.default = cv("DEFAULT_REMEMBER_ME")
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False # pragma: no cover
+ user = None
+ if self.is_secondary:
+ if "tf_user_id" in session:
+ user = _datastore.find_user(fs_uniquifier=session["tf_user_id"])
+ elif cv("WAN_ALLOW_USER_HINTS"):
+ # If we allow HINTS - provide them - but don't error
+ # out if an unknown or disabled account - that would provide too
+ # much 'discovery' capability of un-authenticated users.
+ if self.identity.data:
+ user = lookup_identity(self.identity.data)
+ if user and user.is_active:
+ self.user = user
+ return True
+
+
+class WebAuthnSigninResponseForm(Form, NextFormMixin):
+ """
+ This form is used both for signin (primary/first or secondary) and verify.
+ """
+
+ remember = HiddenField()
+ submit = SubmitField(label=get_form_field_label("submit"))
+ credential = HiddenField()
+
+ # set by caller
+ challenge: str
+ user_verification: bool
+ is_secondary: bool
+ is_verify: bool
+ # returned to caller
+ authentication_verification: VerifiedAuthentication
+ user: User | None = None
+ cred: WebAuthn | None = None
+ # Set to True if this authentication qualifies as 'multi-factor'
+ mf_check: bool = False
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False # pragma: no cover
+ try:
+ auth_cred = parse_authentication_credential_json(self.credential.data)
+ except (
+ ValueError,
+ KeyError,
+ InvalidJSONStructure,
+ InvalidAuthenticationResponse,
+ ):
+ self.credential.errors.append(get_message("API_ERROR")[0])
+ return False
+
+ # Look up credential Id (raw_id) and user. 7.2.6/7
+ self.cred = _datastore.find_webauthn(credential_id=auth_cred.raw_id)
+ if not self.cred:
+ self.credential.errors.append(
+ get_message("WEBAUTHN_UNKNOWN_CREDENTIAL_ID")[0]
+ )
+ return False
+ # This shouldn't be able to happen if datastore properly cascades
+ # delete
+ self.user = _datastore.find_user_from_webauthn(self.cred)
+ if not self.user: # pragma: no cover
+ self.credential.errors.append(
+ get_message("WEBAUTHN_ORPHAN_CREDENTIAL_ID")[0]
+ )
+ return False
+
+ # Verify user Handle. 7.2.6
+ if auth_cred.response.user_handle:
+ if (
+ auth_cred.response.user_handle
+ != self.user.fs_webauthn_user_handle.encode()
+ ):
+ self.credential.errors.append(
+ get_message("WEBAUTHN_MISMATCH_USER_HANDLE")[0]
+ )
+ return False
+
+ # Make sure the usage of credential matches configured
+ if self.is_verify:
+ usage = cv("WAN_ALLOW_AS_VERIFY")
+ elif self.is_secondary:
+ usage = "secondary"
+ else:
+ usage = "first"
+ if not is_cred_usable(self.cred, usage):
+ self.credential.errors.append(
+ get_message("WEBAUTHN_CREDENTIAL_WRONG_USAGE")[0]
+ )
+ return False
+
+ if not self.user.is_active:
+ self.credential.errors.append(get_message("DISABLED_ACCOUNT")[0])
+ return False
+
+ verify = partial(
+ webauthn.verify_authentication_response,
+ credential=auth_cred,
+ expected_challenge=self.challenge.encode(),
+ expected_origin=_security._webauthn_util.origin(),
+ expected_rp_id=request.host.split(":")[0],
+ credential_public_key=self.cred.public_key,
+ credential_current_sign_count=self.cred.sign_count,
+ )
+ # Start by verifying requiring user_verification - if that succeeds then
+ # this authn could be used for both primary and secondary.
+ # If it fails, then try to verify with user_verification == False - unless
+ # as part of signin the app required user_verification (as stored in the state)
+ try:
+ self.authentication_verification = verify(require_user_verification=True)
+ self.mf_check = True
+ except InvalidAuthenticationResponse:
+ try:
+ self.authentication_verification = verify(
+ require_user_verification=self.user_verification
+ )
+ except InvalidAuthenticationResponse as exc:
+ self.credential.errors.append(
+ get_message("WEBAUTHN_NO_VERIFY", cause=str(exc))[0]
+ )
+ return False
+ return True
+
+
+class WebAuthnDeleteForm(Form):
+ name = StringField(
+ get_form_field_xlate(_("Nickname")),
+ validators=[Required(message="WEBAUTHN_NAME_REQUIRED")],
+ )
+ submit = SubmitField(label=get_form_field_label("delete"))
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False
+ if not any([self.name.data == cred.name for cred in current_user.webauthn]):
+ self.name.errors.append(
+ get_message("WEBAUTHN_NAME_NOT_FOUND", name=self.name.data)[0]
+ )
+ return False
+ return True
+
+
+class WebAuthnVerifyForm(Form):
+ submit = SubmitField(label=get_form_field_label("submit"), id="wan_verify")
+
+ user: User
+
+ def validate(self, **kwargs: t.Any) -> bool:
+ if not super().validate(**kwargs):
+ return False # pragma: no cover
+ # We are always authenticated - so return possible credentials.
+ self.user = current_user
+ return True
+
+
+@auth_required(
+ lambda: cv("API_ENABLED_METHODS"),
+ within=lambda: cv("FRESHNESS"),
+ grace=lambda: cv("FRESHNESS_GRACE_PERIOD"),
+)
+def webauthn_register() -> ResponseValue:
+ """Start Registration for an existing authenticated user
+
+ Note that it requires a POST to start the registration and must send 'name'
+ in. We check here that user hasn't already registered an authenticator with that
+ name.
+ Also - this requires that the user already be logged in - so we can provide info
+ as part of the GET that could otherwise be considered leaking user info.
+ """
+ payload: dict[str, t.Any]
+
+ form: WebAuthnRegisterForm = t.cast(
+ WebAuthnRegisterForm, build_form_from_request("wan_register_form")
+ )
+
+ if form.validate_on_submit():
+ challenge = _security._webauthn_util.generate_challenge(
+ cv("WAN_CHALLENGE_BYTES")
+ )
+ if not current_user.fs_webauthn_user_handle:
+ # set a user handle. This allows an easy migration when adding this
+ # column (and not requiring as part of schema change to update all existing
+ # records. New users will have this set as part of user creation.
+ after_this_request(view_commit)
+ _datastore.set_webauthn_user_handle(current_user)
+
+ ro = dict(
+ challenge=challenge.encode(),
+ rp_name=cv("WAN_RP_NAME"),
+ rp_id=request.host.split(":")[0],
+ user_id=current_user.fs_webauthn_user_handle.encode(),
+ user_name=current_user.calc_username(),
+ timeout=cv("WAN_REGISTER_TIMEOUT"),
+ exclude_credentials=create_credential_list(
+ current_user, ["first", "secondary"]
+ ),
+ )
+ ro = _security._webauthn_util.registration_options(
+ current_user, form.usage.data, ro
+ )
+ credential_options = webauthn.generate_registration_options(**ro)
+ co_json = json.loads(webauthn.options_to_json(credential_options))
+ co_json["extensions"] = {"credProps": True}
+
+ # If we ask for UserVerification then we need to check that in the response.
+ uv = False
+ if credential_options.authenticator_selection:
+ uv = (
+ credential_options.authenticator_selection.user_verification
+ == UserVerificationRequirement.REQUIRED
+ )
+ state = {
+ "challenge": challenge,
+ "name": form.name.data,
+ "usage": form.usage.data,
+ "user_verification": uv,
+ }
+ state_token = _security.wan_serializer.dumps(state)
+
+ if _security._want_json(request):
+ payload = {
+ "credential_options": co_json,
+ "wan_state": state_token,
+ }
+ return base_render_json(form, include_user=False, additional=payload)
+
+ return _security.render_template(
+ cv("WAN_REGISTER_TEMPLATE"),
+ wan_register_form=form,
+ wan_register_response_form=build_form("wan_register_response_form"),
+ wan_state=state_token,
+ credential_options=json.dumps(co_json),
+ **_security._run_ctx_processor("wan_register"),
+ )
+
+ current_creds = []
+ cred: WebAuthn
+ for cred in current_user.webauthn:
+ cl = {
+ "name": cred.name,
+ "credential_id": bytes_to_base64url(cred.credential_id),
+ "transports": cred.transports,
+ "lastuse": cred.lastuse_datetime.isoformat(),
+ "usage": cred.usage,
+ "backup_state": (
+ cred.backup_state if hasattr(cred, "backup_state") else False
+ ),
+ "device_type": (
+ cred.device_type if hasattr(cred, "device_type") else "Unknown"
+ ),
+ }
+ # TODO: i18n
+ discoverable = "Unknown"
+ if cred.extensions:
+ extensions = json.loads(cred.extensions)
+ if "credProps" in extensions:
+ discoverable = extensions["credProps"].get("rk", "Unknown")
+ cl["discoverable"] = discoverable
+ current_creds.append(cl)
+
+ payload = {"registered_credentials": current_creds}
+ if _security._want_json(request):
+ return base_render_json(form, additional=payload)
+ return _security.render_template(
+ cv("WAN_REGISTER_TEMPLATE"),
+ wan_register_form=form,
+ wan_delete_form=build_form("wan_delete_form"),
+ registered_credentials=current_creds,
+ **_security._run_ctx_processor("wan_register"),
+ )
+
+
+@auth_required(lambda: cv("API_ENABLED_METHODS"))
+def webauthn_register_response(token: str) -> ResponseValue:
+ """Response from browser."""
+ form: WebAuthnRegisterResponseForm = t.cast(
+ WebAuthnRegisterResponseForm,
+ build_form_from_request("wan_register_response_form"),
+ )
+
+ expired, invalid, state = check_and_get_token_status(
+ token, "wan", get_within_delta("WAN_REGISTER_WITHIN")
+ )
+ if invalid:
+ m, c = get_message("API_ERROR")
+ if expired:
+ m, c = get_message("WEBAUTHN_EXPIRED", within=cv("WAN_REGISTER_WITHIN"))
+ if invalid or expired:
+ if _security._want_json(request):
+ form.form_errors.append(m)
+ return base_render_json(form, include_user=False)
+ do_flash(m, c)
+ return redirect(url_for_security("wan_register"))
+
+ form.challenge = state["challenge"]
+ form.name = state["name"]
+ form.usage = state["usage"]
+ form.user_verification = state["user_verification"]
+ if form.validate_on_submit():
+ # store away successful registration
+ after_this_request(view_commit)
+ _datastore.create_webauthn(
+ current_user._get_current_object(), # Not needed with Werkzeug >2.0.0
+ name=state["name"],
+ credential_id=form.registration_verification.credential_id,
+ public_key=form.registration_verification.credential_public_key,
+ sign_count=form.registration_verification.sign_count,
+ backup_state=getattr(
+ form.registration_verification, "credential_backed_up", False
+ ),
+ device_type=getattr(
+ form.registration_verification,
+ "credential_device_type",
+ "single_device",
+ ),
+ transports=list(form.transports),
+ extensions=form.extensions,
+ usage=form.usage,
+ )
+ wan_registered.send(
+ current_app._get_current_object(), # type: ignore
+ _async_wrapper=current_app.ensure_sync,
+ user=current_user,
+ name=state["name"],
+ )
+
+ if _security._want_json(request):
+ return base_render_json(form)
+ msg, c = get_message("WEBAUTHN_REGISTER_SUCCESSFUL", name=state["name"])
+ do_flash(msg, c)
+ return redirect(get_url(cv("WAN_POST_REGISTER_VIEW")))
+
+ if _security._want_json(request):
+ return base_render_json(form)
+ if form.errors:
+ for v in form.errors.values():
+ do_flash(v[0], "error")
+ return redirect(url_for_security("wan_register"))
+
+
+def _signin_common(user: User | None, usage: list[str]) -> tuple[t.Any, str]:
+ """
+ Common code between signin and verify - once form has been verified.
+ """
+ challenge = _security._webauthn_util.generate_challenge(cv("WAN_CHALLENGE_BYTES"))
+
+ # Populate allowedCredentials if identity passed and allowed
+ allow_credentials = None
+ if user:
+ allow_credentials = create_credential_list(user, usage)
+
+ ao = dict(
+ rp_id=request.host.split(":")[0],
+ challenge=challenge.encode(),
+ timeout=cv("WAN_SIGNIN_TIMEOUT"),
+ allow_credentials=allow_credentials,
+ )
+ ao = _security._webauthn_util.authentication_options(user, usage, ao)
+ options = webauthn.generate_authentication_options(**ao)
+
+ # If we ask for UserVerification then we need to check that in the response.
+ uv = False
+ if options.user_verification == UserVerificationRequirement.REQUIRED:
+ uv = True
+ state = {
+ "challenge": challenge,
+ "user_verification": uv,
+ }
+
+ o_json = json.loads(webauthn.options_to_json(options))
+ state_token = t.cast(str, _security.wan_serializer.dumps(state))
+ return o_json, state_token
+
+
+@anonymous_user_required
+@unauth_csrf()
+def webauthn_signin() -> ResponseValue:
+ # This view can be called either as a 'first' authentication or as part of
+ # 2FA.
+ is_secondary = all(k in session for k in ["tf_user_id", "tf_state"]) and session[
+ "tf_state"
+ ] in ["ready"]
+ if is_secondary or cv("WAN_ALLOW_AS_FIRST_FACTOR"):
+ pass
+ else:
+ abort(404)
+
+ form = t.cast(WebAuthnSigninForm, build_form_from_request("wan_signin_form"))
+ form.is_secondary = is_secondary
+ if form.validate_on_submit():
+ o_json, state_token = _signin_common(
+ form.user, ["secondary"] if is_secondary else ["first"]
+ )
+ if _security._want_json(request):
+ payload = {
+ "credential_options": o_json,
+ "wan_state": state_token,
+ "remember": form.remember.data,
+ "is_secondary": is_secondary,
+ }
+ return base_render_json(form, include_user=False, additional=payload)
+
+ # Copy the user's remember field into the next form - since that is
+ # auto-submitted.
+ return _security.render_template(
+ cv("WAN_SIGNIN_TEMPLATE"),
+ wan_signin_form=form,
+ wan_signin_response_form=build_form(
+ "wan_signin_response_form",
+ remember=form.remember.data,
+ next=form.next.data,
+ ),
+ wan_state=state_token,
+ credential_options=json.dumps(o_json),
+ is_secondary=is_secondary,
+ **_security._run_ctx_processor("wan_signin"),
+ )
+
+ if _security._want_json(request):
+ return base_render_json(form, additional={"is_secondary": is_secondary})
+ return _security.render_template(
+ cv("WAN_SIGNIN_TEMPLATE"),
+ wan_signin_form=form,
+ wan_signin_response_form=build_form("wan_signin_response_form"),
+ is_secondary=is_secondary,
+ **_security._run_ctx_processor("wan_signin"),
+ )
+
+
+@unauth_csrf()
+def webauthn_signin_response(token: str) -> ResponseValue:
+ is_secondary = all(k in session for k in ["tf_user_id", "tf_state"]) and session[
+ "tf_state"
+ ] in ["ready"]
+
+ form = t.cast(
+ WebAuthnSigninResponseForm, build_form_from_request("wan_signin_response_form")
+ )
+
+ expired, invalid, state = check_and_get_token_status(
+ token, "wan", get_within_delta("WAN_SIGNIN_WITHIN")
+ )
+ if invalid:
+ m, c = get_message("API_ERROR")
+ if expired:
+ m, c = get_message("WEBAUTHN_EXPIRED", within=cv("WAN_SIGNIN_WITHIN"))
+ if invalid or expired:
+ if _security._want_json(request):
+ form.form_errors.append(m)
+ return base_render_json(form, include_user=False)
+ do_flash(m, c)
+ return redirect(url_for_security("wan_signin"))
+
+ form.challenge = state["challenge"]
+ form.user_verification = state["user_verification"]
+ form.is_secondary = is_secondary
+ form.is_verify = False
+
+ if form.validate_on_submit():
+ # update last use and sign count
+ after_this_request(view_commit)
+ assert form.cred
+ assert form.user
+ form.cred.lastuse_datetime = _security.datetime_factory()
+ form.cred.sign_count = form.authentication_verification.new_sign_count
+ form.cred.backup_state = getattr(
+ form.authentication_verification, "credential_backed_up", False
+ )
+ form.cred.device_type = getattr(
+ form.authentication_verification, "credential_device_type", "single_device"
+ )
+ _datastore.put(form.cred)
+
+ json_payload = {}
+ if is_secondary:
+ tf_token = _security.two_factor_plugins.tf_complete(form.user, True)
+ if tf_token:
+ after_this_request(
+ partial(tf_set_validity_token_cookie, token=tf_token)
+ )
+ else:
+ # Need Two-factor?:
+ # - Is it required?
+ # - Did this credential provide 2-factor and
+ # is WAN_ALLOW_AS_MULTI_FACTOR set
+ # - Is another 2FA setup?
+ remember_me = form.remember.data if "remember" in form else None
+ if form.mf_check and cv("WAN_ALLOW_AS_MULTI_FACTOR"):
+ pass
+ else:
+ response = _security.two_factor_plugins.tf_enter(
+ form.user,
+ remember_me,
+ "webauthn",
+ next_loc=propagate_next(request.url, form),
+ )
+ if response:
+ return response
+ # login user
+ login_user(form.user, remember=remember_me, authn_via=["webauthn"])
+
+ goto_url = get_post_login_redirect()
+ if _security._want_json(request):
+ # Tell caller where we would go if forms based - they can use it or
+ # not.
+ json_payload["post_login_url"] = goto_url
+ return base_render_json(
+ form, include_auth_token=True, additional=json_payload
+ )
+ return redirect(goto_url)
+
+ # Here on validate error
+ if _security._want_json(request):
+ return base_render_json(form)
+
+ # Since the response is auto submitted - we go back to
+ # signin form - for now use flash.
+ if form.errors:
+ for v in form.errors.values():
+ do_flash(v[0], "error")
+ return redirect(url_for_security("wan_signin"))
+
+
+@auth_required(
+ lambda: cv("API_ENABLED_METHODS"),
+ within=lambda: cv("FRESHNESS"),
+ grace=lambda: cv("FRESHNESS_GRACE_PERIOD"),
+)
+def webauthn_delete() -> ResponseValue:
+ """Deletes an existing registered credential."""
+ form = t.cast(WebAuthnDeleteForm, build_form_from_request("wan_delete_form"))
+
+ if form.validate_on_submit():
+ # validate made sure form.name.data exists.
+ cred = [c for c in current_user.webauthn if c.name == form.name.data][0]
+ after_this_request(view_commit)
+
+ wan_deleted.send(
+ current_app._get_current_object(), # type: ignore
+ _async_wrapper=current_app.ensure_sync,
+ user=current_user,
+ name=cred.name,
+ )
+ _datastore.delete_webauthn(cred)
+ if _security._want_json(request):
+ return base_render_json(form)
+ msg, c = get_message("WEBAUTHN_CREDENTIAL_DELETED", name=form.name.data)
+ do_flash(msg, c)
+
+ if _security._want_json(request):
+ return base_render_json(form)
+ if form.name.errors:
+ do_flash(form.name.errors[0], "error")
+ return redirect(url_for_security("wan_register"))
+
+
+@auth_required(lambda: cv("API_ENABLED_METHODS"))
+def webauthn_verify() -> ResponseValue:
+ """
+ Re-authenticate to reset freshness time.
+ This is likely the result of a reauthn_handler redirect, which
+ will have filled in ?next=xxx - which we want to carefully not lose as we
+ go through these steps.
+ """
+ form = t.cast(WebAuthnVerifyForm, build_form_from_request("wan_verify_form"))
+
+ if form.validate_on_submit():
+ o_json, state_token = _signin_common(form.user, cv("WAN_ALLOW_AS_VERIFY"))
+ if _security._want_json(request):
+ payload = {"credential_options": o_json, "wan_state": state_token}
+ return base_render_json(form, include_user=False, additional=payload)
+
+ return _security.render_template(
+ cv("WAN_VERIFY_TEMPLATE"),
+ wan_verify_form=form,
+ wan_signin_response_form=build_form("wan_signin_response_form"),
+ wan_state=state_token,
+ credential_options=json.dumps(o_json),
+ **_security._run_ctx_processor("wan_verify"),
+ )
+
+ if _security._want_json(request):
+ return base_render_json(form)
+ return _security.render_template(
+ cv("WAN_VERIFY_TEMPLATE"),
+ wan_verify_form=form,
+ wan_signin_response_form=build_form("wan_signin_response_form"),
+ skip_login_menu=True,
+ **_security._run_ctx_processor("wan_verify"),
+ )
+
+
+@auth_required(lambda: cv("API_ENABLED_METHODS"))
+def webauthn_verify_response(token: str) -> ResponseValue:
+ form = t.cast(
+ WebAuthnSigninResponseForm, build_form_from_request("wan_signin_response_form")
+ )
+
+ expired, invalid, state = check_and_get_token_status(
+ token, "wan", get_within_delta("WAN_SIGNIN_WITHIN")
+ )
+ if invalid:
+ m, c = get_message("API_ERROR")
+ if expired:
+ m, c = get_message("WEBAUTHN_EXPIRED", within=cv("WAN_SIGNIN_WITHIN"))
+ if invalid or expired:
+ if _security._want_json(request):
+ form.form_errors.append(m)
+ return base_render_json(form, include_user=False)
+ do_flash(m, c)
+ return redirect(url_for_security("wan_verify"))
+
+ form.challenge = state["challenge"]
+ form.user_verification = state["user_verification"]
+ form.is_secondary = False
+ form.is_verify = True
+
+ if form.validate_on_submit():
+ # update last use and sign count
+ after_this_request(view_commit)
+ assert form.cred
+ form.cred.lastuse_datetime = _security.datetime_factory()
+ form.cred.sign_count = form.authentication_verification.new_sign_count
+ _datastore.put(form.cred)
+
+ # verified - so set freshness time.
+ session["fs_paa"] = time.time()
+
+ if _security._want_json(request):
+ return base_render_json(form, include_auth_token=True)
+
+ do_flash(*get_message("REAUTHENTICATION_SUCCESSFUL"))
+ return redirect(get_post_verify_redirect())
+
+ # Here on validate error (only POST is allowed on this endpoint)
+ if _security._want_json(request):
+ return base_render_json(form)
+
+ # Since the response is auto submitted - we go back to
+ # verify form - for now use flash.
+ if form.credential.errors:
+ do_flash(form.credential.errors[0], "error")
+ return redirect(url_for_security("wan_verify"))
+
+
+def is_cred_usable(cred: WebAuthn, usage: str | list[str]) -> bool:
+ # Return True is cred can be used for the requested usage/verify
+ if not isinstance(usage, list):
+ usage = [usage]
+ assert "verify" not in usage
+ return cred.usage in usage
+
+
+def has_webauthn(user: User, usage: str | list[str]) -> bool:
+ # Return True if ``user`` has one or more keys with requested usage.
+ # Usage: either "first" or "secondary"
+ if not isinstance(usage, list):
+ usage = [usage]
+ wan_keys = getattr(user, "webauthn", [])
+ for cred in wan_keys:
+ if is_cred_usable(cred, usage):
+ return True
+ return False
+
+
+def create_credential_list(
+ user: User, usage: list[str]
+) -> list[PublicKeyCredentialDescriptor]:
+ # Return a list of registered credentials - filtered by whether they apply to our
+ # authentication state (first or secondary)
+ cl = []
+
+ for cred in user.webauthn:
+ if not is_cred_usable(cred, usage):
+ continue
+ descriptor = PublicKeyCredentialDescriptor(
+ type=PublicKeyCredentialType.PUBLIC_KEY, id=cred.credential_id
+ )
+ if cred.transports:
+ tlist = cred.transports
+ transports = [AuthenticatorTransport(transport) for transport in tlist]
+ descriptor.transports = transports
+ # TODO order is important - figure out a way to add 'weight'
+ cl.append(descriptor)
+
+ return cl
+
+
+class WebAuthnTfPlugin(TfPluginBase):
+ def __init__(self, app: flask.Flask):
+ super().__init__(app)
+
+ def create_blueprint(
+ self, app: flask.Flask, bp: flask.Blueprint, state: Security
+ ) -> None:
+ """Our endpoints are already registered since webauthn can be both
+ a 'first' or 'secondary' authentication mechanism.
+ """
+ pass
+
+ def get_setup_methods(self, user: User) -> list[str]:
+ if has_webauthn(user, "secondary"):
+ return [_("webauthn")]
+ return []
+
+ def tf_login(
+ self, user: User, json_payload: dict[str, t.Any], next_loc: str | None
+ ) -> ResponseValue:
+ session["tf_state"] = "ready"
+ if not _security._want_json(request):
+ values = dict(next=next_loc) if next_loc else dict()
+ return redirect(url_for_security("wan_signin", **values))
+
+ # JSON response
+ json_payload["tf_signin_url"] = url_for_security("wan_signin")
+ json_payload["tf_state"] = "ready"
+ json_payload["tf_method"] = "webauthn"
+ return simple_render_json(additional=json_payload)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/webauthn_util.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/webauthn_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..120ed3b2fff5b3e11894d9adfe609bbf887d5b66
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_security/webauthn_util.py
@@ -0,0 +1,158 @@
+"""
+ flask_security.webauthn_util
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Utility class providing methods controlling various aspects of webauthn.
+
+ :copyright: (c) 2020-2024 by J. Christopher Wagner (jwag).
+ :license: MIT, see LICENSE for more details.
+
+"""
+
+from __future__ import annotations
+
+import secrets
+import typing as t
+
+from flask import current_app, request
+
+try:
+ # noinspection PyUnresolvedReferences
+ from webauthn.helpers.structs import (
+ AuthenticatorAttachment,
+ AuthenticatorSelectionCriteria,
+ ResidentKeyRequirement,
+ UserVerificationRequirement,
+ )
+except ImportError: # pragma: no cover
+ pass
+
+
+if t.TYPE_CHECKING: # pragma: no cover
+ import flask
+ from .datastore import User
+
+
+class WebauthnUtil:
+ """
+ Utility class allowing an application to fine-tune various Relying Party
+ attributes.
+
+ To provide your own implementation, pass in the class as ``webauthn_util_cls``
+ at init time. Your class will be instantiated once as part of app initialization.
+
+ .. versionadded:: 5.0.0
+ """
+
+ def __init__(self, app: flask.Flask):
+ """Instantiate class.
+
+ :param app: The Flask application being initialized.
+ """
+ pass
+
+ def generate_challenge(self, nbytes: int | None = None) -> str:
+ # Mostly override this for testing, so we can have a 'constant' challenge.
+ return secrets.token_urlsafe(nbytes)
+
+ def origin(self) -> str:
+ # Return the RP origin - normally this is just the URL of the application.
+ return request.host_url.rstrip("/")
+
+ def registration_options(
+ self, user: User, usage: str, existing_options: dict[str, t.Any]
+ ) -> dict[str, t.Any]:
+ """
+ :param user: User object - could be used to configure on a per-user basis.
+ :param usage: Either "first" or "secondary" (webauthn is being used as a second
+ factor for authentication)
+ :param existing_options: Currently filled in registration options.
+
+ Return a dict that will be sent in to py-webauthn generate_registration_options
+ """
+ existing_options["authenticator_selection"] = self.authenticator_selection(
+ user, usage
+ )
+ return existing_options
+
+ def authenticator_selection(
+ self, user: User, usage: str
+ ) -> AuthenticatorSelectionCriteria:
+ """
+ :param user: User object - could be used to configure on a per-user basis.
+ :param usage: Either "first" or "secondary" (webauthn is being used as a second
+ factor for authentication
+
+ Part of the registration ceremony is providing information about what kind
+ of authenticators the app is interested in.
+ See: https://www.w3.org/TR/2021/REC-webauthn-2-20210408/#dictionary-authenticatorSelection
+
+ The main options are:
+ - whether you want a ResidentKey (discoverable)
+ - Attachment - platform or cross-platform
+ - Does the key have to provide user-verification
+
+ :note::
+ If the key isn't resident then it isn't discoverable which means that
+ the user won't be able to use that key unless they identify themselves
+ (use the key as a second factor OR type in their identity). If they are forced
+ to type in their identity PRIOR to being authenticated, then there is the
+ possibility that the app will leak username information.
+ """ # noqa: E501
+
+ select_criteria = AuthenticatorSelectionCriteria()
+ # TODO: look at #sctn-usecase-new-device-registration to see a reason
+ # to allow multiple keys as "first" - only one would need to be cross-platform
+ if usage == "first":
+ select_criteria.authenticator_attachment = (
+ AuthenticatorAttachment.CROSS_PLATFORM
+ )
+ select_criteria.user_verification = UserVerificationRequirement.PREFERRED
+ else:
+ # For second factor minimize user-interaction by not asking for UV
+ select_criteria.user_verification = UserVerificationRequirement.DISCOURAGED
+
+ if not current_app.config.get("SECURITY_WAN_ALLOW_USER_HINTS"):
+ select_criteria.resident_key = ResidentKeyRequirement.REQUIRED
+ else:
+ select_criteria.resident_key = ResidentKeyRequirement.PREFERRED
+ return select_criteria
+
+ def authentication_options(
+ self,
+ user: User | None,
+ usage: list[str],
+ existing_options: dict[str, t.Any],
+ ) -> dict[str, t.Any]:
+ """
+ :param user: User object - could be used to configure on a per-user basis.
+ However, this can be null.
+ :param usage: Either "first" or "secondary" (webauthn is being used as a second
+ factor for authentication)
+ :param existing_options: Currently filled in authentication options.
+
+ Return a dict that will be sent in to
+ py-webauthn generate_authentication_options
+ """
+ existing_options["user_verification"] = self.user_verification(user, usage)
+ return existing_options
+
+ def user_verification(
+ self, user: User | None, usage: list[str]
+ ) -> UserVerificationRequirement:
+ """
+ As part of signin - do we want/need user verification.
+ This is called from /wan-signin and /wan-verify
+
+ :param user: User object - could be used to configure on a per-user basis.
+ Note that this may not be set on initial wan-signin.
+ :param usage: List of "first", "secondary" (webauthn is being used as a second
+ factor for authentication). Note that in the ``verify``/``reauthentication``
+ case this list is derived from :py:data:`SECURITY_WAN_ALLOW_AS_VERIFY`
+
+ """
+ if "secondary" in usage:
+ return UserVerificationRequirement.DISCOURAGED
+ if current_app.config.get("SECURITY_WAN_ALLOW_AS_MULTI_FACTOR"):
+ return UserVerificationRequirement.PREFERRED
+ return UserVerificationRequirement.PREFERRED
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_socketio/__init__.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_socketio/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c065ae372edcbcb1d4b6f026e27e3d7a0cf464b8
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_socketio/__init__.py
@@ -0,0 +1,1117 @@
+from functools import wraps
+import os
+import sys
+
+# make sure gevent-socketio is not installed, as it conflicts with
+# python-socketio
+gevent_socketio_found = True
+try:
+ from socketio import socketio_manage # noqa: F401
+except ImportError:
+ gevent_socketio_found = False
+if gevent_socketio_found:
+ print('The gevent-socketio package is incompatible with this version of '
+ 'the Flask-SocketIO extension. Please uninstall it, and then '
+ 'install the latest version of python-socketio in its place.')
+ sys.exit(1)
+
+import flask
+from flask import has_request_context, json as flask_json
+from flask.sessions import SessionMixin
+import socketio
+from socketio.exceptions import ConnectionRefusedError # noqa: F401
+from werkzeug.debug import DebuggedApplication
+from werkzeug._reloader import run_with_reloader
+
+from .namespace import Namespace
+from .test_client import SocketIOTestClient
+
+
+class _SocketIOMiddleware(socketio.WSGIApp):
+ """This WSGI middleware simply exposes the Flask application in the WSGI
+ environment before executing the request.
+ """
+ def __init__(self, socketio_app, flask_app, socketio_path='socket.io'):
+ self.flask_app = flask_app
+ super(_SocketIOMiddleware, self).__init__(socketio_app,
+ flask_app.wsgi_app,
+ socketio_path=socketio_path)
+
+ def __call__(self, environ, start_response):
+ environ = environ.copy()
+ environ['flask.app'] = self.flask_app
+ return super(_SocketIOMiddleware, self).__call__(environ,
+ start_response)
+
+
+class _ManagedSession(dict, SessionMixin):
+ """This class is used for user sessions that are managed by
+ Flask-SocketIO. It is simple dict, expanded with the Flask session
+ attributes."""
+ pass
+
+
+class SocketIO(object):
+ """Create a Flask-SocketIO server.
+
+ :param app: The flask application instance. If the application instance
+ isn't known at the time this class is instantiated, then call
+ ``socketio.init_app(app)`` once the application instance is
+ available.
+ :param manage_session: If set to ``True``, this extension manages the user
+ session for Socket.IO events. If set to ``False``,
+ Flask's own session management is used. When using
+ Flask's cookie based sessions it is recommended that
+ you leave this set to the default of ``True``. When
+ using server-side sessions, a ``False`` setting
+ enables sharing the user session between HTTP routes
+ and Socket.IO events.
+ :param message_queue: A connection URL for a message queue service the
+ server can use for multi-process communication. A
+ message queue is not required when using a single
+ server process.
+ :param channel: The channel name, when using a message queue. If a channel
+ isn't specified, a default channel will be used. If
+ multiple clusters of SocketIO processes need to use the
+ same message queue without interfering with each other,
+ then each cluster should use a different channel.
+ :param path: The path where the Socket.IO server is exposed. Defaults to
+ ``'socket.io'``. Leave this as is unless you know what you are
+ doing.
+ :param resource: Alias to ``path``.
+ :param kwargs: Socket.IO and Engine.IO server options.
+
+ The Socket.IO server options are detailed below:
+
+ :param client_manager: The client manager instance that will manage the
+ client list. When this is omitted, the client list
+ is stored in an in-memory structure, so the use of
+ multiple connected servers is not possible. In most
+ cases, this argument does not need to be set
+ explicitly.
+ :param logger: To enable logging set to ``True`` or pass a logger object to
+ use. To disable logging set to ``False``. The default is
+ ``False``. Note that fatal errors will be logged even when
+ ``logger`` is ``False``.
+ :param json: An alternative json module to use for encoding and decoding
+ packets. Custom json modules must have ``dumps`` and ``loads``
+ functions that are compatible with the standard library
+ versions. To use the same json encoder and decoder as a Flask
+ application, use ``flask.json``.
+ :param async_handlers: If set to ``True``, event handlers for a client are
+ executed in separate threads. To run handlers for a
+ client synchronously, set to ``False``. The default
+ is ``True``.
+ :param always_connect: When set to ``False``, new connections are
+ provisory until the connect handler returns
+ something other than ``False``, at which point they
+ are accepted. When set to ``True``, connections are
+ immediately accepted, and then if the connect
+ handler returns ``False`` a disconnect is issued.
+ Set to ``True`` if you need to emit events from the
+ connect handler and your client is confused when it
+ receives events before the connection acceptance.
+ In any other case use the default of ``False``.
+
+ The Engine.IO server configuration supports the following settings:
+
+ :param async_mode: The asynchronous model to use. See the Deployment
+ section in the documentation for a description of the
+ available options. Valid async modes are ``threading``,
+ ``eventlet``, ``gevent`` and ``gevent_uwsgi``. If this
+ argument is not given, ``eventlet`` is tried first, then
+ ``gevent_uwsgi``, then ``gevent``, and finally
+ ``threading``. The first async mode that has all its
+ dependencies installed is then one that is chosen.
+ :param ping_interval: The interval in seconds at which the server pings
+ the client. The default is 25 seconds. For advanced
+ control, a two element tuple can be given, where
+ the first number is the ping interval and the second
+ is a grace period added by the server.
+ :param ping_timeout: The time in seconds that the client waits for the
+ server to respond before disconnecting. The default
+ is 5 seconds.
+ :param max_http_buffer_size: The maximum size of a message when using the
+ polling transport. The default is 1,000,000
+ bytes.
+ :param allow_upgrades: Whether to allow transport upgrades or not. The
+ default is ``True``.
+ :param http_compression: Whether to compress packages when using the
+ polling transport. The default is ``True``.
+ :param compression_threshold: Only compress messages when their byte size
+ is greater than this value. The default is
+ 1024 bytes.
+ :param cookie: If set to a string, it is the name of the HTTP cookie the
+ server sends back to the client containing the client
+ session id. If set to a dictionary, the ``'name'`` key
+ contains the cookie name and other keys define cookie
+ attributes, where the value of each attribute can be a
+ string, a callable with no arguments, or a boolean. If set
+ to ``None`` (the default), a cookie is not sent to the
+ client.
+ :param cors_allowed_origins: Origin or list of origins that are allowed to
+ connect to this server. Only the same origin
+ is allowed by default. Set this argument to
+ ``'*'`` to allow all origins, or to ``[]`` to
+ disable CORS handling.
+ :param cors_credentials: Whether credentials (cookies, authentication) are
+ allowed in requests to this server. The default is
+ ``True``.
+ :param monitor_clients: If set to ``True``, a background task will ensure
+ inactive clients are closed. Set to ``False`` to
+ disable the monitoring task (not recommended). The
+ default is ``True``.
+ :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass
+ a logger object to use. To disable logging set to
+ ``False``. The default is ``False``. Note that
+ fatal errors are logged even when
+ ``engineio_logger`` is ``False``.
+ """
+
+ def __init__(self, app=None, **kwargs):
+ self.server = None
+ self.server_options = {}
+ self.wsgi_server = None
+ self.handlers = []
+ self.namespace_handlers = []
+ self.exception_handlers = {}
+ self.default_exception_handler = None
+ self.manage_session = True
+ # We can call init_app when:
+ # - we were given the Flask app instance (standard initialization)
+ # - we were not given the app, but we were given a message_queue
+ # (standard initialization for auxiliary process)
+ # In all other cases we collect the arguments and assume the client
+ # will call init_app from an app factory function.
+ if app is not None or 'message_queue' in kwargs:
+ self.init_app(app, **kwargs)
+ else:
+ self.server_options.update(kwargs)
+
+ def init_app(self, app, **kwargs):
+ if app is not None:
+ if not hasattr(app, 'extensions'):
+ app.extensions = {} # pragma: no cover
+ app.extensions['socketio'] = self
+ self.server_options.update(kwargs)
+ self.manage_session = self.server_options.pop('manage_session',
+ self.manage_session)
+
+ if 'client_manager' not in kwargs:
+ url = self.server_options.get('message_queue', None)
+ channel = self.server_options.pop('channel', 'flask-socketio')
+ write_only = app is None
+ if url:
+ if url.startswith(('redis://', "rediss://")):
+ queue_class = socketio.RedisManager
+ elif url.startswith(('kafka://')):
+ queue_class = socketio.KafkaManager
+ elif url.startswith('zmq'):
+ queue_class = socketio.ZmqManager
+ else:
+ queue_class = socketio.KombuManager
+ queue = queue_class(url, channel=channel,
+ write_only=write_only)
+ self.server_options['client_manager'] = queue
+
+ if 'json' in self.server_options and \
+ self.server_options['json'] == flask_json:
+ # flask's json module is tricky to use because its output
+ # changes when it is invoked inside or outside the app context
+ # so here to prevent any ambiguities we replace it with wrappers
+ # that ensure that the app context is always present
+ class FlaskSafeJSON(object):
+ @staticmethod
+ def dumps(*args, **kwargs):
+ with app.app_context():
+ return flask_json.dumps(*args, **kwargs)
+
+ @staticmethod
+ def loads(*args, **kwargs):
+ with app.app_context():
+ return flask_json.loads(*args, **kwargs)
+
+ self.server_options['json'] = FlaskSafeJSON
+
+ resource = self.server_options.pop('path', None) or \
+ self.server_options.pop('resource', None) or 'socket.io'
+ if resource.startswith('/'):
+ resource = resource[1:]
+ if os.environ.get('FLASK_RUN_FROM_CLI'):
+ if self.server_options.get('async_mode') is None:
+ self.server_options['async_mode'] = 'threading'
+ self.server = socketio.Server(**self.server_options)
+ self.async_mode = self.server.async_mode
+ for handler in self.handlers:
+ self.server.on(handler[0], handler[1], namespace=handler[2])
+ for namespace_handler in self.namespace_handlers:
+ self.server.register_namespace(namespace_handler)
+
+ if app is not None:
+ # here we attach the SocketIO middleware to the SocketIO object so
+ # it can be referenced later if debug middleware needs to be
+ # inserted
+ self.sockio_mw = _SocketIOMiddleware(self.server, app,
+ socketio_path=resource)
+ app.wsgi_app = self.sockio_mw
+
+ def on(self, message, namespace=None):
+ """Decorator to register a SocketIO event handler.
+
+ This decorator must be applied to SocketIO event handlers. Example::
+
+ @socketio.on('my event', namespace='/chat')
+ def handle_my_custom_event(json):
+ print('received json: ' + str(json))
+
+ :param message: The name of the event. This is normally a user defined
+ string, but a few event names are already defined. Use
+ ``'message'`` to define a handler that takes a string
+ payload, ``'json'`` to define a handler that takes a
+ JSON blob payload, ``'connect'`` or ``'disconnect'``
+ to create handlers for connection and disconnection
+ events.
+ :param namespace: The namespace on which the handler is to be
+ registered. Defaults to the global namespace.
+ """
+ namespace = namespace or '/'
+
+ def decorator(handler):
+ @wraps(handler)
+ def _handler(sid, *args):
+ return self._handle_event(handler, message, namespace, sid,
+ *args)
+
+ if self.server:
+ self.server.on(message, _handler, namespace=namespace)
+ else:
+ self.handlers.append((message, _handler, namespace))
+ return handler
+ return decorator
+
+ def on_error(self, namespace=None):
+ """Decorator to define a custom error handler for SocketIO events.
+
+ This decorator can be applied to a function that acts as an error
+ handler for a namespace. This handler will be invoked when a SocketIO
+ event handler raises an exception. The handler function must accept one
+ argument, which is the exception raised. Example::
+
+ @socketio.on_error(namespace='/chat')
+ def chat_error_handler(e):
+ print('An error has occurred: ' + str(e))
+
+ :param namespace: The namespace for which to register the error
+ handler. Defaults to the global namespace.
+ """
+ namespace = namespace or '/'
+
+ def decorator(exception_handler):
+ if not callable(exception_handler):
+ raise ValueError('exception_handler must be callable')
+ self.exception_handlers[namespace] = exception_handler
+ return exception_handler
+ return decorator
+
+ def on_error_default(self, exception_handler):
+ """Decorator to define a default error handler for SocketIO events.
+
+ This decorator can be applied to a function that acts as a default
+ error handler for any namespaces that do not have a specific handler.
+ Example::
+
+ @socketio.on_error_default
+ def error_handler(e):
+ print('An error has occurred: ' + str(e))
+ """
+ if not callable(exception_handler):
+ raise ValueError('exception_handler must be callable')
+ self.default_exception_handler = exception_handler
+ return exception_handler
+
+ def on_event(self, message, handler, namespace=None):
+ """Register a SocketIO event handler.
+
+ ``on_event`` is the non-decorator version of ``'on'``.
+
+ Example::
+
+ def on_foo_event(json):
+ print('received json: ' + str(json))
+
+ socketio.on_event('my event', on_foo_event, namespace='/chat')
+
+ :param message: The name of the event. This is normally a user defined
+ string, but a few event names are already defined. Use
+ ``'message'`` to define a handler that takes a string
+ payload, ``'json'`` to define a handler that takes a
+ JSON blob payload, ``'connect'`` or ``'disconnect'``
+ to create handlers for connection and disconnection
+ events.
+ :param handler: The function that handles the event.
+ :param namespace: The namespace on which the handler is to be
+ registered. Defaults to the global namespace.
+ """
+ self.on(message, namespace=namespace)(handler)
+
+ def event(self, *args, **kwargs):
+ """Decorator to register an event handler.
+
+ This is a simplified version of the ``on()`` method that takes the
+ event name from the decorated function.
+
+ Example usage::
+
+ @socketio.event
+ def my_event(data):
+ print('Received data: ', data)
+
+ The above example is equivalent to::
+
+ @socketio.on('my_event')
+ def my_event(data):
+ print('Received data: ', data)
+
+ A custom namespace can be given as an argument to the decorator::
+
+ @socketio.event(namespace='/test')
+ def my_event(data):
+ print('Received data: ', data)
+ """
+ if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+ # the decorator was invoked without arguments
+ # args[0] is the decorated function
+ return self.on(args[0].__name__)(args[0])
+ else:
+ # the decorator was invoked with arguments
+ def set_handler(handler):
+ return self.on(handler.__name__, *args, **kwargs)(handler)
+
+ return set_handler
+
+ def on_namespace(self, namespace_handler):
+ if not isinstance(namespace_handler, Namespace):
+ raise ValueError('Not a namespace instance.')
+ namespace_handler._set_socketio(self)
+ if self.server:
+ self.server.register_namespace(namespace_handler)
+ else:
+ self.namespace_handlers.append(namespace_handler)
+
+ def emit(self, event, *args, **kwargs):
+ """Emit a server generated SocketIO event.
+
+ This function emits a SocketIO event to one or more connected clients.
+ A JSON blob can be attached to the event as payload. This function can
+ be used outside of a SocketIO event context, so it is appropriate to
+ use when the server is the originator of an event, outside of any
+ client context, such as in a regular HTTP request handler or a
+ background task. Example::
+
+ @app.route('/ping')
+ def ping():
+ socketio.emit('ping event', {'data': 42}, namespace='/chat')
+
+ :param event: The name of the user event to emit.
+ :param args: A dictionary with the JSON data to send as payload.
+ :param namespace: The namespace under which the message is to be sent.
+ Defaults to the global namespace.
+ :param to: Send the message to all the users in the given room, or to
+ the user with the given session ID. If this parameter is not
+ included, the event is sent to all connected users.
+ :param include_self: ``True`` to include the sender when broadcasting
+ or addressing a room, or ``False`` to send to
+ everyone but the sender.
+ :param skip_sid: The session id of a client to ignore when broadcasting
+ or addressing a room. This is typically set to the
+ originator of the message, so that everyone except
+ that client receive the message. To skip multiple sids
+ pass a list.
+ :param callback: If given, this function will be called to acknowledge
+ that the client has received the message. The
+ arguments that will be passed to the function are
+ those provided by the client. Callback functions can
+ only be used when addressing an individual client.
+ """
+ namespace = kwargs.pop('namespace', '/')
+ to = kwargs.pop('to', None) or kwargs.pop('room', None)
+ include_self = kwargs.pop('include_self', True)
+ skip_sid = kwargs.pop('skip_sid', None)
+ if not include_self and not skip_sid:
+ skip_sid = flask.request.sid
+ callback = kwargs.pop('callback', None)
+ if callback:
+ # wrap the callback so that it sets app app and request contexts
+ sid = None
+ original_callback = callback
+ original_namespace = namespace
+ if has_request_context():
+ sid = getattr(flask.request, 'sid', None)
+ original_namespace = getattr(flask.request, 'namespace', None)
+
+ def _callback_wrapper(*args):
+ return self._handle_event(original_callback, None,
+ original_namespace, sid, *args)
+
+ if sid:
+ # the callback wrapper above will install a request context
+ # before invoking the original callback
+ # we only use it if the emit was issued from a Socket.IO
+ # populated request context (i.e. request.sid is defined)
+ callback = _callback_wrapper
+ self.server.emit(event, *args, namespace=namespace, to=to,
+ skip_sid=skip_sid, callback=callback, **kwargs)
+
+ def call(self, event, *args, **kwargs): # pragma: no cover
+ """Emit a SocketIO event and wait for the response.
+
+ This method issues an emit with a callback and waits for the callback
+ to be invoked by the client before returning. If the callback isn’t
+ invoked before the timeout, then a TimeoutError exception is raised. If
+ the Socket.IO connection drops during the wait, this method still waits
+ until the specified timeout. Example::
+
+ def get_status(client, data):
+ status = call('status', {'data': data}, to=client)
+
+ :param event: The name of the user event to emit.
+ :param args: A dictionary with the JSON data to send as payload.
+ :param namespace: The namespace under which the message is to be sent.
+ Defaults to the global namespace.
+ :param to: The session ID of the recipient client.
+ :param timeout: The waiting timeout. If the timeout is reached before
+ the client acknowledges the event, then a
+ ``TimeoutError`` exception is raised. The default is 60
+ seconds.
+ :param ignore_queue: Only used when a message queue is configured. If
+ set to ``True``, the event is emitted to the
+ client directly, without going through the queue.
+ This is more efficient, but only works when a
+ single server process is used, or when there is a
+ single addressee. It is recommended to always
+ leave this parameter with its default value of
+ ``False``.
+ """
+ namespace = kwargs.pop('namespace', '/')
+ to = kwargs.pop('to', None) or kwargs.pop('room', None)
+ return self.server.call(event, *args, namespace=namespace, to=to,
+ **kwargs)
+
+ def send(self, data, json=False, namespace=None, to=None,
+ callback=None, include_self=True, skip_sid=None, **kwargs):
+ """Send a server-generated SocketIO message.
+
+ This function sends a simple SocketIO message to one or more connected
+ clients. The message can be a string or a JSON blob. This is a simpler
+ version of ``emit()``, which should be preferred. This function can be
+ used outside of a SocketIO event context, so it is appropriate to use
+ when the server is the originator of an event.
+
+ :param data: The message to send, either a string or a JSON blob.
+ :param json: ``True`` if ``message`` is a JSON blob, ``False``
+ otherwise.
+ :param namespace: The namespace under which the message is to be sent.
+ Defaults to the global namespace.
+ :param to: Send the message to all the users in the given room, or to
+ the user with the given session ID. If this parameter is not
+ included, the event is sent to all connected users.
+ :param include_self: ``True`` to include the sender when broadcasting
+ or addressing a room, or ``False`` to send to
+ everyone but the sender.
+ :param skip_sid: The session id of a client to ignore when broadcasting
+ or addressing a room. This is typically set to the
+ originator of the message, so that everyone except
+ that client receive the message. To skip multiple sids
+ pass a list.
+ :param callback: If given, this function will be called to acknowledge
+ that the client has received the message. The
+ arguments that will be passed to the function are
+ those provided by the client. Callback functions can
+ only be used when addressing an individual client.
+ """
+ skip_sid = flask.request.sid if not include_self else skip_sid
+ if json:
+ self.emit('json', data, namespace=namespace, to=to,
+ skip_sid=skip_sid, callback=callback, **kwargs)
+ else:
+ self.emit('message', data, namespace=namespace, to=to,
+ skip_sid=skip_sid, callback=callback, **kwargs)
+
+ def close_room(self, room, namespace=None):
+ """Close a room.
+
+ This function removes any users that are in the given room and then
+ deletes the room from the server. This function can be used outside
+ of a SocketIO event context.
+
+ :param room: The name of the room to close.
+ :param namespace: The namespace under which the room exists. Defaults
+ to the global namespace.
+ """
+ self.server.close_room(room, namespace)
+
+ def run(self, app, host=None, port=None, **kwargs): # pragma: no cover
+ """Run the SocketIO web server.
+
+ :param app: The Flask application instance.
+ :param host: The hostname or IP address for the server to listen on.
+ Defaults to 127.0.0.1.
+ :param port: The port number for the server to listen on. Defaults to
+ 5000.
+ :param debug: ``True`` to start the server in debug mode, ``False`` to
+ start in normal mode.
+ :param use_reloader: ``True`` to enable the Flask reloader, ``False``
+ to disable it.
+ :param reloader_options: A dictionary with options that are passed to
+ the Flask reloader, such as ``extra_files``,
+ ``reloader_type``, etc.
+ :param extra_files: A list of additional files that the Flask
+ reloader should watch. Defaults to ``None``.
+ Deprecated, use ``reloader_options`` instead.
+ :param log_output: If ``True``, the server logs all incoming
+ connections. If ``False`` logging is disabled.
+ Defaults to ``True`` in debug mode, ``False``
+ in normal mode. Unused when the threading async
+ mode is used.
+ :param allow_unsafe_werkzeug: Set to ``True`` to allow the use of the
+ Werkzeug web server in a production
+ setting. Default is ``False``. Set to
+ ``True`` at your own risk.
+ :param kwargs: Additional web server options. The web server options
+ are specific to the server used in each of the supported
+ async modes. Note that options provided here will
+ not be seen when using an external web server such
+ as gunicorn, since this method is not called in that
+ case.
+ """
+ if host is None:
+ host = '127.0.0.1'
+ if port is None:
+ server_name = app.config['SERVER_NAME']
+ if server_name and ':' in server_name:
+ port = int(server_name.rsplit(':', 1)[1])
+ else:
+ port = 5000
+
+ debug = kwargs.pop('debug', app.debug)
+ log_output = kwargs.pop('log_output', debug)
+ use_reloader = kwargs.pop('use_reloader', debug)
+ extra_files = kwargs.pop('extra_files', None)
+ reloader_options = kwargs.pop('reloader_options', {})
+ if extra_files:
+ reloader_options['extra_files'] = extra_files
+
+ app.debug = debug
+ if app.debug and self.server.eio.async_mode != 'threading':
+ # put the debug middleware between the SocketIO middleware
+ # and the Flask application instance
+ #
+ # mw1 mw2 mw3 Flask app
+ # o ---- o ---- o ---- o
+ # /
+ # o Flask-SocketIO
+ # \ middleware
+ # o
+ # Flask-SocketIO WebSocket handler
+ #
+ # BECOMES
+ #
+ # dbg-mw mw1 mw2 mw3 Flask app
+ # o ---- o ---- o ---- o ---- o
+ # /
+ # o Flask-SocketIO
+ # \ middleware
+ # o
+ # Flask-SocketIO WebSocket handler
+ #
+ self.sockio_mw.wsgi_app = DebuggedApplication(
+ self.sockio_mw.wsgi_app, evalex=True)
+
+ allow_unsafe_werkzeug = kwargs.pop('allow_unsafe_werkzeug', False)
+ if self.server.eio.async_mode == 'threading':
+ try:
+ import simple_websocket # noqa: F401
+ except ImportError:
+ from werkzeug._internal import _log
+ _log('warning', 'WebSocket transport not available. Install '
+ 'simple-websocket for improved performance.')
+ if not sys.stdin or not sys.stdin.isatty(): # pragma: no cover
+ if not allow_unsafe_werkzeug:
+ raise RuntimeError('The Werkzeug web server is not '
+ 'designed to run in production. Pass '
+ 'allow_unsafe_werkzeug=True to the '
+ 'run() method to disable this error.')
+ else:
+ from werkzeug._internal import _log
+ _log('warning', ('Werkzeug appears to be used in a '
+ 'production deployment. Consider '
+ 'switching to a production web server '
+ 'instead.'))
+ app.run(host=host, port=port, threaded=True,
+ use_reloader=use_reloader, **reloader_options, **kwargs)
+ elif self.server.eio.async_mode == 'eventlet':
+ def run_server():
+ import eventlet
+ import eventlet.wsgi
+ import eventlet.green
+ addresses = eventlet.green.socket.getaddrinfo(host, port)
+ if not addresses:
+ raise RuntimeError(
+ 'Could not resolve host to a valid address')
+ eventlet_socket = eventlet.listen(addresses[0][4],
+ addresses[0][0])
+
+ # If provided an SSL argument, use an SSL socket
+ ssl_args = ['keyfile', 'certfile', 'server_side', 'cert_reqs',
+ 'ssl_version', 'ca_certs',
+ 'do_handshake_on_connect', 'suppress_ragged_eofs',
+ 'ciphers']
+ ssl_params = {k: kwargs[k] for k in kwargs
+ if k in ssl_args and kwargs[k] is not None}
+ for k in ssl_args:
+ kwargs.pop(k, None)
+ if len(ssl_params) > 0:
+ ssl_params['server_side'] = True # Listening requires true
+ eventlet_socket = eventlet.wrap_ssl(eventlet_socket,
+ **ssl_params)
+
+ eventlet.wsgi.server(eventlet_socket, app,
+ log_output=log_output, **kwargs)
+
+ if use_reloader:
+ run_with_reloader(run_server, **reloader_options)
+ else:
+ run_server()
+ elif self.server.eio.async_mode == 'gevent':
+ from gevent import pywsgi
+ try:
+ from geventwebsocket.handler import WebSocketHandler
+ websocket = True
+ except ImportError:
+ app.logger.warning(
+ 'WebSocket transport not available. Install '
+ 'gevent-websocket for improved performance.')
+ websocket = False
+
+ log = 'default'
+ if not log_output:
+ log = None
+ if websocket:
+ self.wsgi_server = pywsgi.WSGIServer(
+ (host, port), app, handler_class=WebSocketHandler,
+ log=log, **kwargs)
+ else:
+ self.wsgi_server = pywsgi.WSGIServer((host, port), app,
+ log=log, **kwargs)
+
+ if use_reloader:
+ # monkey patching is required by the reloader
+ from gevent import monkey
+ monkey.patch_thread()
+ monkey.patch_time()
+
+ def run_server():
+ self.wsgi_server.serve_forever()
+
+ run_with_reloader(run_server, **reloader_options)
+ else:
+ self.wsgi_server.serve_forever()
+
+ def stop(self):
+ """Stop a running SocketIO web server.
+
+ This method must be called from a HTTP or SocketIO handler function.
+ """
+ if self.server.eio.async_mode == 'threading':
+ func = flask.request.environ.get('werkzeug.server.shutdown')
+ if func:
+ func()
+ else:
+ raise RuntimeError('Cannot stop unknown web server')
+ elif self.server.eio.async_mode == 'eventlet':
+ raise SystemExit
+ elif self.server.eio.async_mode == 'gevent':
+ self.wsgi_server.stop()
+
+ def start_background_task(self, target, *args, **kwargs):
+ """Start a background task using the appropriate async model.
+
+ This is a utility function that applications can use to start a
+ background task using the method that is compatible with the
+ selected async mode.
+
+ :param target: the target function to execute.
+ :param args: arguments to pass to the function.
+ :param kwargs: keyword arguments to pass to the function.
+
+ This function returns an object that represents the background task,
+ on which the ``join()`` method can be invoked to wait for the task to
+ complete.
+ """
+ return self.server.start_background_task(target, *args, **kwargs)
+
+ def sleep(self, seconds=0):
+ """Sleep for the requested amount of time using the appropriate async
+ model.
+
+ This is a utility function that applications can use to put a task to
+ sleep without having to worry about using the correct call for the
+ selected async mode.
+ """
+ return self.server.sleep(seconds)
+
+ def test_client(self, app, namespace=None, query_string=None,
+ headers=None, auth=None, flask_test_client=None):
+ """The Socket.IO test client is useful for testing a Flask-SocketIO
+ server. It works in a similar way to the Flask Test Client, but
+ adapted to the Socket.IO server.
+
+ :param app: The Flask application instance.
+ :param namespace: The namespace for the client. If not provided, the
+ client connects to the server on the global
+ namespace.
+ :param query_string: A string with custom query string arguments.
+ :param headers: A dictionary with custom HTTP headers.
+ :param auth: Optional authentication data, given as a dictionary.
+ :param flask_test_client: The instance of the Flask test client
+ currently in use. Passing the Flask test
+ client is optional, but is necessary if you
+ want the Flask user session and any other
+ cookies set in HTTP routes accessible from
+ Socket.IO events.
+ """
+ return SocketIOTestClient(app, self, namespace=namespace,
+ query_string=query_string, headers=headers,
+ auth=auth,
+ flask_test_client=flask_test_client)
+
+ def _handle_event(self, handler, message, namespace, sid, *args):
+ environ = self.server.get_environ(sid, namespace=namespace)
+ if not environ:
+ # we don't have record of this client, ignore this event
+ return '', 400
+ app = environ['flask.app']
+ with app.request_context(environ):
+ if self.manage_session:
+ # manage a separate session for this client's Socket.IO events
+ # created as a copy of the regular user session
+ if 'saved_session' not in environ:
+ environ['saved_session'] = _ManagedSession(flask.session)
+ session_obj = environ['saved_session']
+ if hasattr(flask, 'globals') and \
+ hasattr(flask.globals, 'request_ctx'):
+ # update session for Flask >= 2.2
+ ctx = flask.globals.request_ctx._get_current_object()
+ else: # pragma: no cover
+ # update session for Flask < 2.2
+ ctx = flask._request_ctx_stack.top
+ ctx.session = session_obj
+ else:
+ # let Flask handle the user session
+ # for cookie based sessions, this effectively freezes the
+ # session to its state at connection time
+ # for server-side sessions, this allows HTTP and Socket.IO to
+ # share the session, with both having read/write access to it
+ session_obj = flask.session._get_current_object()
+ flask.request.sid = sid
+ flask.request.namespace = namespace
+ flask.request.event = {'message': message, 'args': args}
+ try:
+ if message == 'connect':
+ auth = args[1] if len(args) > 1 else None
+ try:
+ ret = handler(auth)
+ except TypeError:
+ ret = handler()
+ else:
+ ret = handler(*args)
+ except ConnectionRefusedError:
+ raise # let this error bubble up to python-socketio
+ except:
+ err_handler = self.exception_handlers.get(
+ namespace, self.default_exception_handler)
+ if err_handler is None:
+ raise
+ type, value, traceback = sys.exc_info()
+ return err_handler(value)
+ if not self.manage_session:
+ # when Flask is managing the user session, it needs to save it
+ if not hasattr(session_obj, 'modified') or \
+ session_obj.modified:
+ resp = app.response_class()
+ app.session_interface.save_session(app, session_obj, resp)
+ return ret
+
+
+def emit(event, *args, **kwargs):
+ """Emit a SocketIO event.
+
+ This function emits a SocketIO event to one or more connected clients. A
+ JSON blob can be attached to the event as payload. This is a function that
+ can only be called from a SocketIO event handler, as in obtains some
+ information from the current client context. Example::
+
+ @socketio.on('my event')
+ def handle_my_custom_event(json):
+ emit('my response', {'data': 42})
+
+ :param event: The name of the user event to emit.
+ :param args: A dictionary with the JSON data to send as payload.
+ :param namespace: The namespace under which the message is to be sent.
+ Defaults to the namespace used by the originating event.
+ A ``'/'`` can be used to explicitly specify the global
+ namespace.
+ :param callback: Callback function to invoke with the client's
+ acknowledgement.
+ :param broadcast: ``True`` to send the message to all clients, or ``False``
+ to only reply to the sender of the originating event.
+ :param to: Send the message to all the users in the given room, or to the
+ user with the given session ID. If this argument is not set and
+ ``broadcast`` is ``False``, then the message is sent only to the
+ originating user.
+ :param include_self: ``True`` to include the sender when broadcasting or
+ addressing a room, or ``False`` to send to everyone
+ but the sender.
+ :param skip_sid: The session id of a client to ignore when broadcasting
+ or addressing a room. This is typically set to the
+ originator of the message, so that everyone except
+ that client receive the message. To skip multiple sids
+ pass a list.
+ :param ignore_queue: Only used when a message queue is configured. If
+ set to ``True``, the event is emitted to the
+ clients directly, without going through the queue.
+ This is more efficient, but only works when a
+ single server process is used, or when there is a
+ single addressee. It is recommended to always leave
+ this parameter with its default value of ``False``.
+ """
+ if 'namespace' in kwargs:
+ namespace = kwargs['namespace']
+ else:
+ namespace = flask.request.namespace
+ callback = kwargs.get('callback')
+ broadcast = kwargs.get('broadcast')
+ to = kwargs.pop('to', None) or kwargs.pop('room', None)
+ if to is None and not broadcast:
+ to = flask.request.sid
+ include_self = kwargs.get('include_self', True)
+ skip_sid = kwargs.get('skip_sid')
+ ignore_queue = kwargs.get('ignore_queue', False)
+
+ socketio = flask.current_app.extensions['socketio']
+ return socketio.emit(event, *args, namespace=namespace, to=to,
+ include_self=include_self, skip_sid=skip_sid,
+ callback=callback, ignore_queue=ignore_queue)
+
+
+def call(event, *args, **kwargs): # pragma: no cover
+ """Emit a SocketIO event and wait for the response.
+
+ This function issues an emit with a callback and waits for the callback to
+ be invoked by the client before returning. If the callback isn’t invoked
+ before the timeout, then a TimeoutError exception is raised. If the
+ Socket.IO connection drops during the wait, this method still waits until
+ the specified timeout. Example::
+
+ def get_status(client, data):
+ status = call('status', {'data': data}, to=client)
+
+ :param event: The name of the user event to emit.
+ :param args: A dictionary with the JSON data to send as payload.
+ :param namespace: The namespace under which the message is to be sent.
+ Defaults to the namespace used by the originating event.
+ A ``'/'`` can be used to explicitly specify the global
+ namespace.
+ :param to: The session ID of the recipient client. If this argument is not
+ given, the event is sent to the originating client.
+ :param timeout: The waiting timeout. If the timeout is reached before the
+ client acknowledges the event, then a ``TimeoutError``
+ exception is raised. The default is 60 seconds.
+ :param ignore_queue: Only used when a message queue is configured. If
+ set to ``True``, the event is emitted to the
+ client directly, without going through the queue.
+ This is more efficient, but only works when a
+ single server process is used, or when there is a
+ single addressee. It is recommended to always leave
+ this parameter with its default value of ``False``.
+ """
+ if 'namespace' in kwargs:
+ namespace = kwargs['namespace']
+ else:
+ namespace = flask.request.namespace
+ to = kwargs.pop('to', None) or kwargs.pop('room', None)
+ if to is None:
+ to = flask.request.sid
+ timeout = kwargs.get('timeout', 60)
+ ignore_queue = kwargs.get('ignore_queue', False)
+
+ socketio = flask.current_app.extensions['socketio']
+ return socketio.call(event, *args, namespace=namespace, to=to,
+ ignore_queue=ignore_queue, timeout=timeout)
+
+
+def send(message, **kwargs):
+ """Send a SocketIO message.
+
+ This function sends a simple SocketIO message to one or more connected
+ clients. The message can be a string or a JSON blob. This is a simpler
+ version of ``emit()``, which should be preferred. This is a function that
+ can only be called from a SocketIO event handler.
+
+ :param message: The message to send, either a string or a JSON blob.
+ :param json: ``True`` if ``message`` is a JSON blob, ``False``
+ otherwise.
+ :param namespace: The namespace under which the message is to be sent.
+ Defaults to the namespace used by the originating event.
+ An empty string can be used to use the global namespace.
+ :param callback: Callback function to invoke with the client's
+ acknowledgement.
+ :param broadcast: ``True`` to send the message to all connected clients, or
+ ``False`` to only reply to the sender of the originating
+ event.
+ :param to: Send the message to all the users in the given room, or to the
+ user with the given session ID. If this argument is not set and
+ ``broadcast`` is ``False``, then the message is sent only to the
+ originating user.
+ :param include_self: ``True`` to include the sender when broadcasting or
+ addressing a room, or ``False`` to send to everyone
+ but the sender.
+ :param skip_sid: The session id of a client to ignore when broadcasting
+ or addressing a room. This is typically set to the
+ originator of the message, so that everyone except
+ that client receive the message. To skip multiple sids
+ pass a list.
+ :param ignore_queue: Only used when a message queue is configured. If
+ set to ``True``, the event is emitted to the
+ clients directly, without going through the queue.
+ This is more efficient, but only works when a
+ single server process is used, or when there is a
+ single addressee. It is recommended to always leave
+ this parameter with its default value of ``False``.
+ """
+ json = kwargs.get('json', False)
+ if 'namespace' in kwargs:
+ namespace = kwargs['namespace']
+ else:
+ namespace = flask.request.namespace
+ callback = kwargs.get('callback')
+ broadcast = kwargs.get('broadcast')
+ to = kwargs.pop('to', None) or kwargs.pop('room', None)
+ if to is None and not broadcast:
+ to = flask.request.sid
+ include_self = kwargs.get('include_self', True)
+ skip_sid = kwargs.get('skip_sid')
+ ignore_queue = kwargs.get('ignore_queue', False)
+
+ socketio = flask.current_app.extensions['socketio']
+ return socketio.send(message, json=json, namespace=namespace, to=to,
+ include_self=include_self, skip_sid=skip_sid,
+ callback=callback, ignore_queue=ignore_queue)
+
+
+def join_room(room, sid=None, namespace=None):
+ """Join a room.
+
+ This function puts the user in a room, under the current namespace. The
+ user and the namespace are obtained from the event context. This is a
+ function that can only be called from a SocketIO event handler. Example::
+
+ @socketio.on('join')
+ def on_join(data):
+ username = session['username']
+ room = data['room']
+ join_room(room)
+ send(username + ' has entered the room.', to=room)
+
+ :param room: The name of the room to join.
+ :param sid: The session id of the client. If not provided, the client is
+ obtained from the request context.
+ :param namespace: The namespace for the room. If not provided, the
+ namespace is obtained from the request context.
+ """
+ socketio = flask.current_app.extensions['socketio']
+ sid = sid or flask.request.sid
+ namespace = namespace or flask.request.namespace
+ socketio.server.enter_room(sid, room, namespace=namespace)
+
+
+def leave_room(room, sid=None, namespace=None):
+ """Leave a room.
+
+ This function removes the user from a room, under the current namespace.
+ The user and the namespace are obtained from the event context. Example::
+
+ @socketio.on('leave')
+ def on_leave(data):
+ username = session['username']
+ room = data['room']
+ leave_room(room)
+ send(username + ' has left the room.', to=room)
+
+ :param room: The name of the room to leave.
+ :param sid: The session id of the client. If not provided, the client is
+ obtained from the request context.
+ :param namespace: The namespace for the room. If not provided, the
+ namespace is obtained from the request context.
+ """
+ socketio = flask.current_app.extensions['socketio']
+ sid = sid or flask.request.sid
+ namespace = namespace or flask.request.namespace
+ socketio.server.leave_room(sid, room, namespace=namespace)
+
+
+def close_room(room, namespace=None):
+ """Close a room.
+
+ This function removes any users that are in the given room and then deletes
+ the room from the server.
+
+ :param room: The name of the room to close.
+ :param namespace: The namespace for the room. If not provided, the
+ namespace is obtained from the request context.
+ """
+ socketio = flask.current_app.extensions['socketio']
+ namespace = namespace or flask.request.namespace
+ socketio.server.close_room(room, namespace=namespace)
+
+
+def rooms(sid=None, namespace=None):
+ """Return a list of the rooms the client is in.
+
+ This function returns all the rooms the client has entered, including its
+ own room, assigned by the Socket.IO server.
+
+ :param sid: The session id of the client. If not provided, the client is
+ obtained from the request context.
+ :param namespace: The namespace for the room. If not provided, the
+ namespace is obtained from the request context.
+ """
+ socketio = flask.current_app.extensions['socketio']
+ sid = sid or flask.request.sid
+ namespace = namespace or flask.request.namespace
+ return socketio.server.rooms(sid, namespace=namespace)
+
+
+def disconnect(sid=None, namespace=None, silent=False):
+ """Disconnect the client.
+
+ This function terminates the connection with the client. As a result of
+ this call the client will receive a disconnect event. Example::
+
+ @socketio.on('message')
+ def receive_message(msg):
+ if is_banned(session['username']):
+ disconnect()
+ else:
+ # ...
+
+ :param sid: The session id of the client. If not provided, the client is
+ obtained from the request context.
+ :param namespace: The namespace for the room. If not provided, the
+ namespace is obtained from the request context.
+ :param silent: this option is deprecated.
+ """
+ socketio = flask.current_app.extensions['socketio']
+ sid = sid or flask.request.sid
+ namespace = namespace or flask.request.namespace
+ return socketio.server.disconnect(sid, namespace=namespace)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_socketio/namespace.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_socketio/namespace.py
new file mode 100644
index 0000000000000000000000000000000000000000..43833a9bdeaf87e8499db0f004544804a3f44870
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_socketio/namespace.py
@@ -0,0 +1,46 @@
+from socketio import Namespace as _Namespace
+
+
+class Namespace(_Namespace):
+ def __init__(self, namespace=None):
+ super(Namespace, self).__init__(namespace)
+ self.socketio = None
+
+ def _set_socketio(self, socketio):
+ self.socketio = socketio
+
+ def trigger_event(self, event, *args):
+ """Dispatch an event to the proper handler method.
+
+ In the most common usage, this method is not overloaded by subclasses,
+ as it performs the routing of events to methods. However, this
+ method can be overridden if special dispatching rules are needed, or if
+ having a single method that catches all events is desired.
+ """
+ handler_name = 'on_' + event
+ if not hasattr(self, handler_name):
+ # there is no handler for this event, so we ignore it
+ return
+ handler = getattr(self, handler_name)
+ return self.socketio._handle_event(handler, event, self.namespace,
+ *args)
+
+ def emit(self, event, data=None, room=None, include_self=True,
+ namespace=None, callback=None):
+ """Emit a custom event to one or more connected clients."""
+ return self.socketio.emit(event, data, room=room,
+ include_self=include_self,
+ namespace=namespace or self.namespace,
+ callback=callback)
+
+ def send(self, data, room=None, include_self=True, namespace=None,
+ callback=None):
+ """Send a message to one or more connected clients."""
+ return self.socketio.send(data, room=room, include_self=include_self,
+ namespace=namespace or self.namespace,
+ callback=callback)
+
+ def close_room(self, room, namespace=None):
+ """Close a room."""
+ return self.socketio.close_room(room=room,
+ namespace=namespace or self.namespace)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_socketio/test_client.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_socketio/test_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..0603d77c733de90cc93a30fb688c5e293c74342c
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_socketio/test_client.py
@@ -0,0 +1,236 @@
+import uuid
+
+from socketio import packet
+from socketio.pubsub_manager import PubSubManager
+from werkzeug.test import EnvironBuilder
+
+
+class SocketIOTestClient(object):
+ """
+ This class is useful for testing a Flask-SocketIO server. It works in a
+ similar way to the Flask Test Client, but adapted to the Socket.IO server.
+
+ :param app: The Flask application instance.
+ :param socketio: The application's ``SocketIO`` instance.
+ :param namespace: The namespace for the client. If not provided, the client
+ connects to the server on the global namespace.
+ :param query_string: A string with custom query string arguments.
+ :param headers: A dictionary with custom HTTP headers.
+ :param auth: Optional authentication data, given as a dictionary.
+ :param flask_test_client: The instance of the Flask test client
+ currently in use. Passing the Flask test
+ client is optional, but is necessary if you
+ want the Flask user session and any other
+ cookies set in HTTP routes accessible from
+ Socket.IO events.
+ """
+ clients = {}
+
+ def __init__(self, app, socketio, namespace=None, query_string=None,
+ headers=None, auth=None, flask_test_client=None):
+ def _mock_send_packet(eio_sid, pkt):
+ # make sure the packet can be encoded and decoded
+ epkt = pkt.encode()
+ if not isinstance(epkt, list):
+ pkt = packet.Packet(encoded_packet=epkt)
+ else:
+ pkt = packet.Packet(encoded_packet=epkt[0])
+ for att in epkt[1:]:
+ pkt.add_attachment(att)
+ client = self.clients.get(eio_sid)
+ if not client:
+ return
+ if pkt.packet_type == packet.EVENT or \
+ pkt.packet_type == packet.BINARY_EVENT:
+ if pkt.data[0] == 'message' or pkt.data[0] == 'json':
+ client.queue.append({
+ 'name': pkt.data[0],
+ 'args': pkt.data[1],
+ 'namespace': pkt.namespace or '/'})
+ else:
+ client.queue.append({
+ 'name': pkt.data[0],
+ 'args': pkt.data[1:],
+ 'namespace': pkt.namespace or '/'})
+ elif pkt.packet_type == packet.ACK or \
+ pkt.packet_type == packet.BINARY_ACK:
+ client.acks = {'args': pkt.data,
+ 'namespace': pkt.namespace or '/'}
+ elif pkt.packet_type in [packet.DISCONNECT, packet.CONNECT_ERROR]:
+ client.connected[pkt.namespace or '/'] = False
+
+ _current_packet = None
+
+ def _mock_send_eio_packet(eio_sid, eio_pkt):
+ nonlocal _current_packet
+ if _current_packet is not None:
+ _current_packet.add_attachment(eio_pkt.data)
+ if _current_packet.attachment_count == \
+ len(_current_packet.attachments):
+ _mock_send_packet(eio_sid, _current_packet)
+ _current_packet = None
+ else:
+ pkt = packet.Packet(encoded_packet=eio_pkt.data)
+ if pkt.attachment_count == 0:
+ _mock_send_packet(eio_sid, pkt)
+ else:
+ _current_packet = pkt
+
+ self.app = app
+ self.flask_test_client = flask_test_client
+ self.eio_sid = uuid.uuid4().hex
+ self.clients[self.eio_sid] = self
+ self.callback_counter = 0
+ self.socketio = socketio
+ self.connected = {}
+ self.queue = []
+ self.acks = None
+ socketio.server._send_packet = _mock_send_packet
+ socketio.server._send_eio_packet = _mock_send_eio_packet
+ socketio.server.environ[self.eio_sid] = {}
+ socketio.server.async_handlers = False # easier to test when
+ socketio.server.eio.async_handlers = False # events are sync
+ if isinstance(socketio.server.manager, PubSubManager):
+ raise RuntimeError('Test client cannot be used with a message '
+ 'queue. Disable the queue on your test '
+ 'configuration.')
+ socketio.server.manager.initialize()
+ self.connect(namespace=namespace, query_string=query_string,
+ headers=headers, auth=auth)
+
+ def is_connected(self, namespace=None):
+ """Check if a namespace is connected.
+
+ :param namespace: The namespace to check. The global namespace is
+ assumed if this argument is not provided.
+ """
+ return self.connected.get(namespace or '/', False)
+
+ def connect(self, namespace=None, query_string=None, headers=None,
+ auth=None):
+ """Connect the client.
+
+ :param namespace: The namespace for the client. If not provided, the
+ client connects to the server on the global
+ namespace.
+ :param query_string: A string with custom query string arguments.
+ :param headers: A dictionary with custom HTTP headers.
+ :param auth: Optional authentication data, given as a dictionary.
+
+ Note that it is usually not necessary to explicitly call this method,
+ since a connection is automatically established when an instance of
+ this class is created. An example where it this method would be useful
+ is when the application accepts multiple namespace connections.
+ """
+ url = '/socket.io'
+ namespace = namespace or '/'
+ if query_string:
+ if query_string[0] != '?':
+ query_string = '?' + query_string
+ url += query_string
+ environ = EnvironBuilder(url, headers=headers).get_environ()
+ environ['flask.app'] = self.app
+ if self.flask_test_client:
+ # inject cookies from Flask
+ if hasattr(self.flask_test_client, '_add_cookies_to_wsgi'):
+ # flask >= 2.3
+ self.flask_test_client._add_cookies_to_wsgi(environ)
+ else: # pragma: no cover
+ # flask < 2.3
+ self.flask_test_client.cookie_jar.inject_wsgi(environ)
+ self.socketio.server._handle_eio_connect(self.eio_sid, environ)
+ pkt = packet.Packet(packet.CONNECT, auth, namespace=namespace)
+ self.socketio.server._handle_eio_message(self.eio_sid, pkt.encode())
+ sid = self.socketio.server.manager.sid_from_eio_sid(self.eio_sid,
+ namespace)
+ if sid:
+ self.connected[namespace] = True
+
+ def disconnect(self, namespace=None):
+ """Disconnect the client.
+
+ :param namespace: The namespace to disconnect. The global namespace is
+ assumed if this argument is not provided.
+ """
+ if not self.is_connected(namespace):
+ raise RuntimeError('not connected')
+ pkt = packet.Packet(packet.DISCONNECT, namespace=namespace)
+ self.socketio.server._handle_eio_message(self.eio_sid, pkt.encode())
+ del self.connected[namespace or '/']
+
+ def emit(self, event, *args, **kwargs):
+ """Emit an event to the server.
+
+ :param event: The event name.
+ :param *args: The event arguments.
+ :param callback: ``True`` if the client requests a callback, ``False``
+ if not. Note that client-side callbacks are not
+ implemented, a callback request will just tell the
+ server to provide the arguments to invoke the
+ callback, but no callback is invoked. Instead, the
+ arguments that the server provided for the callback
+ are returned by this function.
+ :param namespace: The namespace of the event. The global namespace is
+ assumed if this argument is not provided.
+ """
+ namespace = kwargs.pop('namespace', None)
+ if not self.is_connected(namespace):
+ raise RuntimeError('not connected')
+ callback = kwargs.pop('callback', False)
+ id = None
+ if callback:
+ self.callback_counter += 1
+ id = self.callback_counter
+ pkt = packet.Packet(packet.EVENT, data=[event] + list(args),
+ namespace=namespace, id=id)
+ encoded_pkt = pkt.encode()
+ if isinstance(encoded_pkt, list):
+ for epkt in encoded_pkt:
+ self.socketio.server._handle_eio_message(self.eio_sid, epkt)
+ else:
+ self.socketio.server._handle_eio_message(self.eio_sid, encoded_pkt)
+ if self.acks is not None:
+ ack = self.acks
+ self.acks = None
+ return ack['args'][0] if len(ack['args']) == 1 \
+ else ack['args']
+
+ def send(self, data, json=False, callback=False, namespace=None):
+ """Send a text or JSON message to the server.
+
+ :param data: A string, dictionary or list to send to the server.
+ :param json: ``True`` to send a JSON message, ``False`` to send a text
+ message.
+ :param callback: ``True`` if the client requests a callback, ``False``
+ if not. Note that client-side callbacks are not
+ implemented, a callback request will just tell the
+ server to provide the arguments to invoke the
+ callback, but no callback is invoked. Instead, the
+ arguments that the server provided for the callback
+ are returned by this function.
+ :param namespace: The namespace of the event. The global namespace is
+ assumed if this argument is not provided.
+ """
+ if json:
+ msg = 'json'
+ else:
+ msg = 'message'
+ return self.emit(msg, data, callback=callback, namespace=namespace)
+
+ def get_received(self, namespace=None):
+ """Return the list of messages received from the server.
+
+ Since this is not a real client, any time the server emits an event,
+ the event is simply stored. The test code can invoke this method to
+ obtain the list of events that were received since the last call.
+
+ :param namespace: The namespace to get events from. The global
+ namespace is assumed if this argument is not
+ provided.
+ """
+ if not self.is_connected(namespace):
+ raise RuntimeError('not connected')
+ namespace = namespace or '/'
+ r = [pkt for pkt in self.queue if pkt['namespace'] == namespace]
+ self.queue = [pkt for pkt in self.queue if pkt not in r]
+ return r
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/INSTALLER b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/LICENSE.rst b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/LICENSE.rst
new file mode 100644
index 0000000000000000000000000000000000000000..9d227a0cc43c3268d15722b763bd94ad298645a1
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/LICENSE.rst
@@ -0,0 +1,28 @@
+Copyright 2010 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/METADATA b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..92f239cd94799c4295987ca96e73e5c49c872efa
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/METADATA
@@ -0,0 +1,109 @@
+Metadata-Version: 2.1
+Name: Flask-SQLAlchemy
+Version: 3.1.1
+Summary: Add SQLAlchemy support to your Flask application.
+Maintainer-email: Pallets
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Dist: flask>=2.2.5
+Requires-Dist: sqlalchemy>=2.0.16
+Project-URL: Changes, https://flask-sqlalchemy.palletsprojects.com/changes/
+Project-URL: Chat, https://discord.gg/pallets
+Project-URL: Documentation, https://flask-sqlalchemy.palletsprojects.com
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Issue Tracker, https://github.com/pallets-eco/flask-sqlalchemy/issues/
+Project-URL: Source Code, https://github.com/pallets-eco/flask-sqlalchemy/
+
+Flask-SQLAlchemy
+================
+
+Flask-SQLAlchemy is an extension for `Flask`_ that adds support for
+`SQLAlchemy`_ to your application. It aims to simplify using SQLAlchemy
+with Flask by providing useful defaults and extra helpers that make it
+easier to accomplish common tasks.
+
+.. _Flask: https://palletsprojects.com/p/flask/
+.. _SQLAlchemy: https://www.sqlalchemy.org
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+ $ pip install -U Flask-SQLAlchemy
+
+.. _pip: https://pip.pypa.io/en/stable/getting-started/
+
+
+A Simple Example
+----------------
+
+.. code-block:: python
+
+ from flask import Flask
+ from flask_sqlalchemy import SQLAlchemy
+ from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+ app = Flask(__name__)
+ app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///example.sqlite"
+
+ class Base(DeclarativeBase):
+ pass
+
+ db = SQLAlchemy(app, model_class=Base)
+
+ class User(db.Model):
+ id: Mapped[int] = mapped_column(db.Integer, primary_key=True)
+ username: Mapped[str] = mapped_column(db.String, unique=True, nullable=False)
+
+ with app.app_context():
+ db.create_all()
+
+ db.session.add(User(username="example"))
+ db.session.commit()
+
+ users = db.session.execute(db.select(User)).scalars()
+
+
+Contributing
+------------
+
+For guidance on setting up a development environment and how to make a
+contribution to Flask-SQLAlchemy, see the `contributing guidelines`_.
+
+.. _contributing guidelines: https://github.com/pallets-eco/flask-sqlalchemy/blob/main/CONTRIBUTING.rst
+
+
+Donate
+------
+
+The Pallets organization develops and supports Flask-SQLAlchemy and
+other popular packages. In order to grow the community of contributors
+and users, and allow the maintainers to devote more time to the
+projects, `please donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+- Documentation: https://flask-sqlalchemy.palletsprojects.com/
+- Changes: https://flask-sqlalchemy.palletsprojects.com/changes/
+- PyPI Releases: https://pypi.org/project/Flask-SQLAlchemy/
+- Source Code: https://github.com/pallets-eco/flask-sqlalchemy/
+- Issue Tracker: https://github.com/pallets-eco/flask-sqlalchemy/issues/
+- Website: https://palletsprojects.com/
+- Twitter: https://twitter.com/PalletsTeam
+- Chat: https://discord.gg/pallets
+
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/RECORD b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..4df6c836e9e2d91dccd43b70b2c40e7affbff763
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/RECORD
@@ -0,0 +1,27 @@
+flask_sqlalchemy-3.1.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+flask_sqlalchemy-3.1.1.dist-info/LICENSE.rst,sha256=SJqOEQhQntmKN7uYPhHg9-HTHwvY-Zp5yESOf_N9B-o,1475
+flask_sqlalchemy-3.1.1.dist-info/METADATA,sha256=lBxR1akBt7n9XBjIVTL2OV52OhCfFrb-Mqtoe0DCbR8,3432
+flask_sqlalchemy-3.1.1.dist-info/RECORD,,
+flask_sqlalchemy-3.1.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flask_sqlalchemy-3.1.1.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+flask_sqlalchemy/__init__.py,sha256=he_w4qQQVS2Z1ms5GCTptDTXNOXBXw0n8zSuWCp8n6Y,653
+flask_sqlalchemy/__pycache__/__init__.cpython-311.pyc,,
+flask_sqlalchemy/__pycache__/cli.cpython-311.pyc,,
+flask_sqlalchemy/__pycache__/extension.cpython-311.pyc,,
+flask_sqlalchemy/__pycache__/model.cpython-311.pyc,,
+flask_sqlalchemy/__pycache__/pagination.cpython-311.pyc,,
+flask_sqlalchemy/__pycache__/query.cpython-311.pyc,,
+flask_sqlalchemy/__pycache__/record_queries.cpython-311.pyc,,
+flask_sqlalchemy/__pycache__/session.cpython-311.pyc,,
+flask_sqlalchemy/__pycache__/table.cpython-311.pyc,,
+flask_sqlalchemy/__pycache__/track_modifications.cpython-311.pyc,,
+flask_sqlalchemy/cli.py,sha256=pg3QDxP36GW2qnwe_CpPtkRhPchyVSGM6zlBNWuNCFE,484
+flask_sqlalchemy/extension.py,sha256=71tP_kNtb5VgZdafy_OH1sWdZOA6PaT7cJqX7tKgZ-k,38261
+flask_sqlalchemy/model.py,sha256=_mSisC2Eni0TgTyFWeN_O4LIexTeP_sVTdxh03yMK50,11461
+flask_sqlalchemy/pagination.py,sha256=JFpllrqkRkwacb8DAmQWaz9wsvQa0dypfSkhUDSC2ws,11119
+flask_sqlalchemy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flask_sqlalchemy/query.py,sha256=Uls9qbmnpb9Vba43EDfsRP17eHJ0X4VG7SE22tH5R3g,3748
+flask_sqlalchemy/record_queries.py,sha256=ouS1ayj16h76LJprx13iYdoFZbm6m8OncrOgAVbG1Sk,3520
+flask_sqlalchemy/session.py,sha256=pBbtN8iDc8yuGVt0k18BvZHh2uEI7QPzZXO7eXrRi1g,3426
+flask_sqlalchemy/table.py,sha256=wAPOy8qwyAxpMwOIUJY4iMOultzz2W0D6xvBkQ7U2CE,859
+flask_sqlalchemy/track_modifications.py,sha256=yieyozj7IiVzwnAGZ-ZrgqrzjrUfG0kPrXBfW_hStSU,2755
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/REQUESTED b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/WHEEL b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..3b5e64b5e6c4a210201d1676a891fd57b15cda99
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy-3.1.1.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/__init__.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2fa0591c0243c91face8b5e42c11a8441d0a58a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/__init__.py
@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import typing as t
+
+from .extension import SQLAlchemy
+
+__all__ = [
+ "SQLAlchemy",
+]
+
+
+def __getattr__(name: str) -> t.Any:
+ if name == "__version__":
+ import importlib.metadata
+ import warnings
+
+ warnings.warn(
+ "The '__version__' attribute is deprecated and will be removed in"
+ " Flask-SQLAlchemy 3.2. Use feature detection or"
+ " 'importlib.metadata.version(\"flask-sqlalchemy\")' instead.",
+ DeprecationWarning,
+ stacklevel=2,
+ )
+ return importlib.metadata.version("flask-sqlalchemy")
+
+ raise AttributeError(name)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/cli.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/cli.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7d7e4bef6ebbcf2a1480198b49ddac7a8bd0850
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/cli.py
@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import typing as t
+
+from flask import current_app
+
+
+def add_models_to_shell() -> dict[str, t.Any]:
+ """Registered with :meth:`~flask.Flask.shell_context_processor` if
+ ``add_models_to_shell`` is enabled. Adds the ``db`` instance and all model classes
+ to ``flask shell``.
+ """
+ db = current_app.extensions["sqlalchemy"]
+ out = {m.class_.__name__: m.class_ for m in db.Model._sa_registry.mappers}
+ out["db"] = db
+ return out
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/extension.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/extension.py
new file mode 100644
index 0000000000000000000000000000000000000000..43e1b9a445608a7a27d234f6878e3ced3281116d
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/extension.py
@@ -0,0 +1,1008 @@
+from __future__ import annotations
+
+import os
+import types
+import typing as t
+import warnings
+from weakref import WeakKeyDictionary
+
+import sqlalchemy as sa
+import sqlalchemy.event as sa_event
+import sqlalchemy.exc as sa_exc
+import sqlalchemy.orm as sa_orm
+from flask import abort
+from flask import current_app
+from flask import Flask
+from flask import has_app_context
+
+from .model import _QueryProperty
+from .model import BindMixin
+from .model import DefaultMeta
+from .model import DefaultMetaNoName
+from .model import Model
+from .model import NameMixin
+from .pagination import Pagination
+from .pagination import SelectPagination
+from .query import Query
+from .session import _app_ctx_id
+from .session import Session
+from .table import _Table
+
+_O = t.TypeVar("_O", bound=object) # Based on sqlalchemy.orm._typing.py
+
+
+# Type accepted for model_class argument
+_FSA_MCT = t.TypeVar(
+ "_FSA_MCT",
+ bound=t.Union[
+ t.Type[Model],
+ sa_orm.DeclarativeMeta,
+ t.Type[sa_orm.DeclarativeBase],
+ t.Type[sa_orm.DeclarativeBaseNoMeta],
+ ],
+)
+
+
+# Type returned by make_declarative_base
+class _FSAModel(Model):
+ metadata: sa.MetaData
+
+
+def _get_2x_declarative_bases(
+ model_class: _FSA_MCT,
+) -> list[t.Type[t.Union[sa_orm.DeclarativeBase, sa_orm.DeclarativeBaseNoMeta]]]:
+ return [
+ b
+ for b in model_class.__bases__
+ if issubclass(b, (sa_orm.DeclarativeBase, sa_orm.DeclarativeBaseNoMeta))
+ ]
+
+
+class SQLAlchemy:
+ """Integrates SQLAlchemy with Flask. This handles setting up one or more engines,
+ associating tables and models with specific engines, and cleaning up connections and
+ sessions after each request.
+
+ Only the engine configuration is specific to each application, other things like
+ the model, table, metadata, and session are shared for all applications using that
+ extension instance. Call :meth:`init_app` to configure the extension on an
+ application.
+
+ After creating the extension, create model classes by subclassing :attr:`Model`, and
+ table classes with :attr:`Table`. These can be accessed before :meth:`init_app` is
+ called, making it possible to define the models separately from the application.
+
+ Accessing :attr:`session` and :attr:`engine` requires an active Flask application
+ context. This includes methods like :meth:`create_all` which use the engine.
+
+ This class also provides access to names in SQLAlchemy's ``sqlalchemy`` and
+ ``sqlalchemy.orm`` modules. For example, you can use ``db.Column`` and
+ ``db.relationship`` instead of importing ``sqlalchemy.Column`` and
+ ``sqlalchemy.orm.relationship``. This can be convenient when defining models.
+
+ :param app: Call :meth:`init_app` on this Flask application now.
+ :param metadata: Use this as the default :class:`sqlalchemy.schema.MetaData`. Useful
+ for setting a naming convention.
+ :param session_options: Arguments used by :attr:`session` to create each session
+ instance. A ``scopefunc`` key will be passed to the scoped session, not the
+ session instance. See :class:`sqlalchemy.orm.sessionmaker` for a list of
+ arguments.
+ :param query_class: Use this as the default query class for models and dynamic
+ relationships. The query interface is considered legacy in SQLAlchemy.
+ :param model_class: Use this as the model base class when creating the declarative
+ model class :attr:`Model`. Can also be a fully created declarative model class
+ for further customization.
+ :param engine_options: Default arguments used when creating every engine. These are
+ lower precedence than application config. See :func:`sqlalchemy.create_engine`
+ for a list of arguments.
+ :param add_models_to_shell: Add the ``db`` instance and all model classes to
+ ``flask shell``.
+
+ .. versionchanged:: 3.1.0
+ The ``metadata`` parameter can still be used with SQLAlchemy 1.x classes,
+ but is ignored when using SQLAlchemy 2.x style of declarative classes.
+ Instead, specify metadata on your Base class.
+
+ .. versionchanged:: 3.1.0
+ Added the ``disable_autonaming`` parameter.
+
+ .. versionchanged:: 3.1.0
+ Changed ``model_class`` parameter to accepta SQLAlchemy 2.x
+ declarative base subclass.
+
+ .. versionchanged:: 3.0
+ An active Flask application context is always required to access ``session`` and
+ ``engine``.
+
+ .. versionchanged:: 3.0
+ Separate ``metadata`` are used for each bind key.
+
+ .. versionchanged:: 3.0
+ The ``engine_options`` parameter is applied as defaults before per-engine
+ configuration.
+
+ .. versionchanged:: 3.0
+ The session class can be customized in ``session_options``.
+
+ .. versionchanged:: 3.0
+ Added the ``add_models_to_shell`` parameter.
+
+ .. versionchanged:: 3.0
+ Engines are created when calling ``init_app`` rather than the first time they
+ are accessed.
+
+ .. versionchanged:: 3.0
+ All parameters except ``app`` are keyword-only.
+
+ .. versionchanged:: 3.0
+ The extension instance is stored directly as ``app.extensions["sqlalchemy"]``.
+
+ .. versionchanged:: 3.0
+ Setup methods are renamed with a leading underscore. They are considered
+ internal interfaces which may change at any time.
+
+ .. versionchanged:: 3.0
+ Removed the ``use_native_unicode`` parameter and config.
+
+ .. versionchanged:: 2.4
+ Added the ``engine_options`` parameter.
+
+ .. versionchanged:: 2.1
+ Added the ``metadata``, ``query_class``, and ``model_class`` parameters.
+
+ .. versionchanged:: 2.1
+ Use the same query class across ``session``, ``Model.query`` and
+ ``Query``.
+
+ .. versionchanged:: 0.16
+ ``scopefunc`` is accepted in ``session_options``.
+
+ .. versionchanged:: 0.10
+ Added the ``session_options`` parameter.
+ """
+
+ def __init__(
+ self,
+ app: Flask | None = None,
+ *,
+ metadata: sa.MetaData | None = None,
+ session_options: dict[str, t.Any] | None = None,
+ query_class: type[Query] = Query,
+ model_class: _FSA_MCT = Model, # type: ignore[assignment]
+ engine_options: dict[str, t.Any] | None = None,
+ add_models_to_shell: bool = True,
+ disable_autonaming: bool = False,
+ ):
+ if session_options is None:
+ session_options = {}
+
+ self.Query = query_class
+ """The default query class used by ``Model.query`` and ``lazy="dynamic"``
+ relationships.
+
+ .. warning::
+ The query interface is considered legacy in SQLAlchemy.
+
+ Customize this by passing the ``query_class`` parameter to the extension.
+ """
+
+ self.session = self._make_scoped_session(session_options)
+ """A :class:`sqlalchemy.orm.scoping.scoped_session` that creates instances of
+ :class:`.Session` scoped to the current Flask application context. The session
+ will be removed, returning the engine connection to the pool, when the
+ application context exits.
+
+ Customize this by passing ``session_options`` to the extension.
+
+ This requires that a Flask application context is active.
+
+ .. versionchanged:: 3.0
+ The session is scoped to the current app context.
+ """
+
+ self.metadatas: dict[str | None, sa.MetaData] = {}
+ """Map of bind keys to :class:`sqlalchemy.schema.MetaData` instances. The
+ ``None`` key refers to the default metadata, and is available as
+ :attr:`metadata`.
+
+ Customize the default metadata by passing the ``metadata`` parameter to the
+ extension. This can be used to set a naming convention. When metadata for
+ another bind key is created, it copies the default's naming convention.
+
+ .. versionadded:: 3.0
+ """
+
+ if metadata is not None:
+ if len(_get_2x_declarative_bases(model_class)) > 0:
+ warnings.warn(
+ "When using SQLAlchemy 2.x style of declarative classes,"
+ " the `metadata` should be an attribute of the base class."
+ "The metadata passed into SQLAlchemy() is ignored.",
+ DeprecationWarning,
+ stacklevel=2,
+ )
+ else:
+ metadata.info["bind_key"] = None
+ self.metadatas[None] = metadata
+
+ self.Table = self._make_table_class()
+ """A :class:`sqlalchemy.schema.Table` class that chooses a metadata
+ automatically.
+
+ Unlike the base ``Table``, the ``metadata`` argument is not required. If it is
+ not given, it is selected based on the ``bind_key`` argument.
+
+ :param bind_key: Used to select a different metadata.
+ :param args: Arguments passed to the base class. These are typically the table's
+ name, columns, and constraints.
+ :param kwargs: Arguments passed to the base class.
+
+ .. versionchanged:: 3.0
+ This is a subclass of SQLAlchemy's ``Table`` rather than a function.
+ """
+
+ self.Model = self._make_declarative_base(
+ model_class, disable_autonaming=disable_autonaming
+ )
+ """A SQLAlchemy declarative model class. Subclass this to define database
+ models.
+
+ If a model does not set ``__tablename__``, it will be generated by converting
+ the class name from ``CamelCase`` to ``snake_case``. It will not be generated
+ if the model looks like it uses single-table inheritance.
+
+ If a model or parent class sets ``__bind_key__``, it will use that metadata and
+ database engine. Otherwise, it will use the default :attr:`metadata` and
+ :attr:`engine`. This is ignored if the model sets ``metadata`` or ``__table__``.
+
+ For code using the SQLAlchemy 1.x API, customize this model by subclassing
+ :class:`.Model` and passing the ``model_class`` parameter to the extension.
+ A fully created declarative model class can be
+ passed as well, to use a custom metaclass.
+
+ For code using the SQLAlchemy 2.x API, customize this model by subclassing
+ :class:`sqlalchemy.orm.DeclarativeBase` or
+ :class:`sqlalchemy.orm.DeclarativeBaseNoMeta`
+ and passing the ``model_class`` parameter to the extension.
+ """
+
+ if engine_options is None:
+ engine_options = {}
+
+ self._engine_options = engine_options
+ self._app_engines: WeakKeyDictionary[Flask, dict[str | None, sa.engine.Engine]]
+ self._app_engines = WeakKeyDictionary()
+ self._add_models_to_shell = add_models_to_shell
+
+ if app is not None:
+ self.init_app(app)
+
+ def __repr__(self) -> str:
+ if not has_app_context():
+ return f"<{type(self).__name__}>"
+
+ message = f"{type(self).__name__} {self.engine.url}"
+
+ if len(self.engines) > 1:
+ message = f"{message} +{len(self.engines) - 1}"
+
+ return f"<{message}>"
+
+ def init_app(self, app: Flask) -> None:
+ """Initialize a Flask application for use with this extension instance. This
+ must be called before accessing the database engine or session with the app.
+
+ This sets default configuration values, then configures the extension on the
+ application and creates the engines for each bind key. Therefore, this must be
+ called after the application has been configured. Changes to application config
+ after this call will not be reflected.
+
+ The following keys from ``app.config`` are used:
+
+ - :data:`.SQLALCHEMY_DATABASE_URI`
+ - :data:`.SQLALCHEMY_ENGINE_OPTIONS`
+ - :data:`.SQLALCHEMY_ECHO`
+ - :data:`.SQLALCHEMY_BINDS`
+ - :data:`.SQLALCHEMY_RECORD_QUERIES`
+ - :data:`.SQLALCHEMY_TRACK_MODIFICATIONS`
+
+ :param app: The Flask application to initialize.
+ """
+ if "sqlalchemy" in app.extensions:
+ raise RuntimeError(
+ "A 'SQLAlchemy' instance has already been registered on this Flask app."
+ " Import and use that instance instead."
+ )
+
+ app.extensions["sqlalchemy"] = self
+ app.teardown_appcontext(self._teardown_session)
+
+ if self._add_models_to_shell:
+ from .cli import add_models_to_shell
+
+ app.shell_context_processor(add_models_to_shell)
+
+ basic_uri: str | sa.engine.URL | None = app.config.setdefault(
+ "SQLALCHEMY_DATABASE_URI", None
+ )
+ basic_engine_options = self._engine_options.copy()
+ basic_engine_options.update(
+ app.config.setdefault("SQLALCHEMY_ENGINE_OPTIONS", {})
+ )
+ echo: bool = app.config.setdefault("SQLALCHEMY_ECHO", False)
+ config_binds: dict[
+ str | None, str | sa.engine.URL | dict[str, t.Any]
+ ] = app.config.setdefault("SQLALCHEMY_BINDS", {})
+ engine_options: dict[str | None, dict[str, t.Any]] = {}
+
+ # Build the engine config for each bind key.
+ for key, value in config_binds.items():
+ engine_options[key] = self._engine_options.copy()
+
+ if isinstance(value, (str, sa.engine.URL)):
+ engine_options[key]["url"] = value
+ else:
+ engine_options[key].update(value)
+
+ # Build the engine config for the default bind key.
+ if basic_uri is not None:
+ basic_engine_options["url"] = basic_uri
+
+ if "url" in basic_engine_options:
+ engine_options.setdefault(None, {}).update(basic_engine_options)
+
+ if not engine_options:
+ raise RuntimeError(
+ "Either 'SQLALCHEMY_DATABASE_URI' or 'SQLALCHEMY_BINDS' must be set."
+ )
+
+ engines = self._app_engines.setdefault(app, {})
+
+ # Dispose existing engines in case init_app is called again.
+ if engines:
+ for engine in engines.values():
+ engine.dispose()
+
+ engines.clear()
+
+ # Create the metadata and engine for each bind key.
+ for key, options in engine_options.items():
+ self._make_metadata(key)
+ options.setdefault("echo", echo)
+ options.setdefault("echo_pool", echo)
+ self._apply_driver_defaults(options, app)
+ engines[key] = self._make_engine(key, options, app)
+
+ if app.config.setdefault("SQLALCHEMY_RECORD_QUERIES", False):
+ from . import record_queries
+
+ for engine in engines.values():
+ record_queries._listen(engine)
+
+ if app.config.setdefault("SQLALCHEMY_TRACK_MODIFICATIONS", False):
+ from . import track_modifications
+
+ track_modifications._listen(self.session)
+
+ def _make_scoped_session(
+ self, options: dict[str, t.Any]
+ ) -> sa_orm.scoped_session[Session]:
+ """Create a :class:`sqlalchemy.orm.scoping.scoped_session` around the factory
+ from :meth:`_make_session_factory`. The result is available as :attr:`session`.
+
+ The scope function can be customized using the ``scopefunc`` key in the
+ ``session_options`` parameter to the extension. By default it uses the current
+ thread or greenlet id.
+
+ This method is used for internal setup. Its signature may change at any time.
+
+ :meta private:
+
+ :param options: The ``session_options`` parameter from ``__init__``. Keyword
+ arguments passed to the session factory. A ``scopefunc`` key is popped.
+
+ .. versionchanged:: 3.0
+ The session is scoped to the current app context.
+
+ .. versionchanged:: 3.0
+ Renamed from ``create_scoped_session``, this method is internal.
+ """
+ scope = options.pop("scopefunc", _app_ctx_id)
+ factory = self._make_session_factory(options)
+ return sa_orm.scoped_session(factory, scope)
+
+ def _make_session_factory(
+ self, options: dict[str, t.Any]
+ ) -> sa_orm.sessionmaker[Session]:
+ """Create the SQLAlchemy :class:`sqlalchemy.orm.sessionmaker` used by
+ :meth:`_make_scoped_session`.
+
+ To customize, pass the ``session_options`` parameter to :class:`SQLAlchemy`. To
+ customize the session class, subclass :class:`.Session` and pass it as the
+ ``class_`` key.
+
+ This method is used for internal setup. Its signature may change at any time.
+
+ :meta private:
+
+ :param options: The ``session_options`` parameter from ``__init__``. Keyword
+ arguments passed to the session factory.
+
+ .. versionchanged:: 3.0
+ The session class can be customized.
+
+ .. versionchanged:: 3.0
+ Renamed from ``create_session``, this method is internal.
+ """
+ options.setdefault("class_", Session)
+ options.setdefault("query_cls", self.Query)
+ return sa_orm.sessionmaker(db=self, **options)
+
+ def _teardown_session(self, exc: BaseException | None) -> None:
+ """Remove the current session at the end of the request.
+
+ :meta private:
+
+ .. versionadded:: 3.0
+ """
+ self.session.remove()
+
+ def _make_metadata(self, bind_key: str | None) -> sa.MetaData:
+ """Get or create a :class:`sqlalchemy.schema.MetaData` for the given bind key.
+
+ This method is used for internal setup. Its signature may change at any time.
+
+ :meta private:
+
+ :param bind_key: The name of the metadata being created.
+
+ .. versionadded:: 3.0
+ """
+ if bind_key in self.metadatas:
+ return self.metadatas[bind_key]
+
+ if bind_key is not None:
+ # Copy the naming convention from the default metadata.
+ naming_convention = self._make_metadata(None).naming_convention
+ else:
+ naming_convention = None
+
+ # Set the bind key in info to be used by session.get_bind.
+ metadata = sa.MetaData(
+ naming_convention=naming_convention, info={"bind_key": bind_key}
+ )
+ self.metadatas[bind_key] = metadata
+ return metadata
+
+ def _make_table_class(self) -> type[_Table]:
+ """Create a SQLAlchemy :class:`sqlalchemy.schema.Table` class that chooses a
+ metadata automatically based on the ``bind_key``. The result is available as
+ :attr:`Table`.
+
+ This method is used for internal setup. Its signature may change at any time.
+
+ :meta private:
+
+ .. versionadded:: 3.0
+ """
+
+ class Table(_Table):
+ def __new__(
+ cls, *args: t.Any, bind_key: str | None = None, **kwargs: t.Any
+ ) -> Table:
+ # If a metadata arg is passed, go directly to the base Table. Also do
+ # this for no args so the correct error is shown.
+ if not args or (len(args) >= 2 and isinstance(args[1], sa.MetaData)):
+ return super().__new__(cls, *args, **kwargs)
+
+ metadata = self._make_metadata(bind_key)
+ return super().__new__(cls, *[args[0], metadata, *args[1:]], **kwargs)
+
+ return Table
+
+ def _make_declarative_base(
+ self,
+ model_class: _FSA_MCT,
+ disable_autonaming: bool = False,
+ ) -> t.Type[_FSAModel]:
+ """Create a SQLAlchemy declarative model class. The result is available as
+ :attr:`Model`.
+
+ To customize, subclass :class:`.Model` and pass it as ``model_class`` to
+ :class:`SQLAlchemy`. To customize at the metaclass level, pass an already
+ created declarative model class as ``model_class``.
+
+ This method is used for internal setup. Its signature may change at any time.
+
+ :meta private:
+
+ :param model_class: A model base class, or an already created declarative model
+ class.
+
+ :param disable_autonaming: Turns off automatic tablename generation in models.
+
+ .. versionchanged:: 3.1.0
+ Added support for passing SQLAlchemy 2.x base class as model class.
+ Added optional ``disable_autonaming`` parameter.
+
+ .. versionchanged:: 3.0
+ Renamed with a leading underscore, this method is internal.
+
+ .. versionchanged:: 2.3
+ ``model`` can be an already created declarative model class.
+ """
+ model: t.Type[_FSAModel]
+ declarative_bases = _get_2x_declarative_bases(model_class)
+ if len(declarative_bases) > 1:
+ # raise error if more than one declarative base is found
+ raise ValueError(
+ "Only one declarative base can be passed to SQLAlchemy."
+ " Got: {}".format(model_class.__bases__)
+ )
+ elif len(declarative_bases) == 1:
+ body = dict(model_class.__dict__)
+ body["__fsa__"] = self
+ mixin_classes = [BindMixin, NameMixin, Model]
+ if disable_autonaming:
+ mixin_classes.remove(NameMixin)
+ model = types.new_class(
+ "FlaskSQLAlchemyBase",
+ (*mixin_classes, *model_class.__bases__),
+ {"metaclass": type(declarative_bases[0])},
+ lambda ns: ns.update(body),
+ )
+ elif not isinstance(model_class, sa_orm.DeclarativeMeta):
+ metadata = self._make_metadata(None)
+ metaclass = DefaultMetaNoName if disable_autonaming else DefaultMeta
+ model = sa_orm.declarative_base(
+ metadata=metadata, cls=model_class, name="Model", metaclass=metaclass
+ )
+ else:
+ model = model_class # type: ignore[assignment]
+
+ if None not in self.metadatas:
+ # Use the model's metadata as the default metadata.
+ model.metadata.info["bind_key"] = None
+ self.metadatas[None] = model.metadata
+ else:
+ # Use the passed in default metadata as the model's metadata.
+ model.metadata = self.metadatas[None]
+
+ model.query_class = self.Query
+ model.query = _QueryProperty() # type: ignore[assignment]
+ model.__fsa__ = self
+ return model
+
+ def _apply_driver_defaults(self, options: dict[str, t.Any], app: Flask) -> None:
+ """Apply driver-specific configuration to an engine.
+
+ SQLite in-memory databases use ``StaticPool`` and disable ``check_same_thread``.
+ File paths are relative to the app's :attr:`~flask.Flask.instance_path`,
+ which is created if it doesn't exist.
+
+ MySQL sets ``charset="utf8mb4"``, and ``pool_timeout`` defaults to 2 hours.
+
+ This method is used for internal setup. Its signature may change at any time.
+
+ :meta private:
+
+ :param options: Arguments passed to the engine.
+ :param app: The application that the engine configuration belongs to.
+
+ .. versionchanged:: 3.0
+ SQLite paths are relative to ``app.instance_path``. It does not use
+ ``NullPool`` if ``pool_size`` is 0. Driver-level URIs are supported.
+
+ .. versionchanged:: 3.0
+ MySQL sets ``charset="utf8mb4". It does not set ``pool_size`` to 10. It
+ does not set ``pool_recycle`` if not using a queue pool.
+
+ .. versionchanged:: 3.0
+ Renamed from ``apply_driver_hacks``, this method is internal. It does not
+ return anything.
+
+ .. versionchanged:: 2.5
+ Returns ``(sa_url, options)``.
+ """
+ url = sa.engine.make_url(options["url"])
+
+ if url.drivername in {"sqlite", "sqlite+pysqlite"}:
+ if url.database is None or url.database in {"", ":memory:"}:
+ options["poolclass"] = sa.pool.StaticPool
+
+ if "connect_args" not in options:
+ options["connect_args"] = {}
+
+ options["connect_args"]["check_same_thread"] = False
+ else:
+ # the url might look like sqlite:///file:path?uri=true
+ is_uri = url.query.get("uri", False)
+
+ if is_uri:
+ db_str = url.database[5:]
+ else:
+ db_str = url.database
+
+ if not os.path.isabs(db_str):
+ os.makedirs(app.instance_path, exist_ok=True)
+ db_str = os.path.join(app.instance_path, db_str)
+
+ if is_uri:
+ db_str = f"file:{db_str}"
+
+ options["url"] = url.set(database=db_str)
+ elif url.drivername.startswith("mysql"):
+ # set queue defaults only when using queue pool
+ if (
+ "pool_class" not in options
+ or options["pool_class"] is sa.pool.QueuePool
+ ):
+ options.setdefault("pool_recycle", 7200)
+
+ if "charset" not in url.query:
+ options["url"] = url.update_query_dict({"charset": "utf8mb4"})
+
+ def _make_engine(
+ self, bind_key: str | None, options: dict[str, t.Any], app: Flask
+ ) -> sa.engine.Engine:
+ """Create the :class:`sqlalchemy.engine.Engine` for the given bind key and app.
+
+ To customize, use :data:`.SQLALCHEMY_ENGINE_OPTIONS` or
+ :data:`.SQLALCHEMY_BINDS` config. Pass ``engine_options`` to :class:`SQLAlchemy`
+ to set defaults for all engines.
+
+ This method is used for internal setup. Its signature may change at any time.
+
+ :meta private:
+
+ :param bind_key: The name of the engine being created.
+ :param options: Arguments passed to the engine.
+ :param app: The application that the engine configuration belongs to.
+
+ .. versionchanged:: 3.0
+ Renamed from ``create_engine``, this method is internal.
+ """
+ return sa.engine_from_config(options, prefix="")
+
+ @property
+ def metadata(self) -> sa.MetaData:
+ """The default metadata used by :attr:`Model` and :attr:`Table` if no bind key
+ is set.
+ """
+ return self.metadatas[None]
+
+ @property
+ def engines(self) -> t.Mapping[str | None, sa.engine.Engine]:
+ """Map of bind keys to :class:`sqlalchemy.engine.Engine` instances for current
+ application. The ``None`` key refers to the default engine, and is available as
+ :attr:`engine`.
+
+ To customize, set the :data:`.SQLALCHEMY_BINDS` config, and set defaults by
+ passing the ``engine_options`` parameter to the extension.
+
+ This requires that a Flask application context is active.
+
+ .. versionadded:: 3.0
+ """
+ app = current_app._get_current_object() # type: ignore[attr-defined]
+
+ if app not in self._app_engines:
+ raise RuntimeError(
+ "The current Flask app is not registered with this 'SQLAlchemy'"
+ " instance. Did you forget to call 'init_app', or did you create"
+ " multiple 'SQLAlchemy' instances?"
+ )
+
+ return self._app_engines[app]
+
+ @property
+ def engine(self) -> sa.engine.Engine:
+ """The default :class:`~sqlalchemy.engine.Engine` for the current application,
+ used by :attr:`session` if the :attr:`Model` or :attr:`Table` being queried does
+ not set a bind key.
+
+ To customize, set the :data:`.SQLALCHEMY_ENGINE_OPTIONS` config, and set
+ defaults by passing the ``engine_options`` parameter to the extension.
+
+ This requires that a Flask application context is active.
+ """
+ return self.engines[None]
+
+ def get_engine(
+ self, bind_key: str | None = None, **kwargs: t.Any
+ ) -> sa.engine.Engine:
+ """Get the engine for the given bind key for the current application.
+ This requires that a Flask application context is active.
+
+ :param bind_key: The name of the engine.
+
+ .. deprecated:: 3.0
+ Will be removed in Flask-SQLAlchemy 3.2. Use ``engines[key]`` instead.
+
+ .. versionchanged:: 3.0
+ Renamed the ``bind`` parameter to ``bind_key``. Removed the ``app``
+ parameter.
+ """
+ warnings.warn(
+ "'get_engine' is deprecated and will be removed in Flask-SQLAlchemy"
+ " 3.2. Use 'engine' or 'engines[key]' instead. If you're using"
+ " Flask-Migrate or Alembic, you'll need to update your 'env.py' file.",
+ DeprecationWarning,
+ stacklevel=2,
+ )
+
+ if "bind" in kwargs:
+ bind_key = kwargs.pop("bind")
+
+ return self.engines[bind_key]
+
+ def get_or_404(
+ self,
+ entity: type[_O],
+ ident: t.Any,
+ *,
+ description: str | None = None,
+ **kwargs: t.Any,
+ ) -> _O:
+ """Like :meth:`session.get() ` but aborts with a
+ ``404 Not Found`` error instead of returning ``None``.
+
+ :param entity: The model class to query.
+ :param ident: The primary key to query.
+ :param description: A custom message to show on the error page.
+ :param kwargs: Extra arguments passed to ``session.get()``.
+
+ .. versionchanged:: 3.1
+ Pass extra keyword arguments to ``session.get()``.
+
+ .. versionadded:: 3.0
+ """
+ value = self.session.get(entity, ident, **kwargs)
+
+ if value is None:
+ abort(404, description=description)
+
+ return value
+
+ def first_or_404(
+ self, statement: sa.sql.Select[t.Any], *, description: str | None = None
+ ) -> t.Any:
+ """Like :meth:`Result.scalar() `, but aborts
+ with a ``404 Not Found`` error instead of returning ``None``.
+
+ :param statement: The ``select`` statement to execute.
+ :param description: A custom message to show on the error page.
+
+ .. versionadded:: 3.0
+ """
+ value = self.session.execute(statement).scalar()
+
+ if value is None:
+ abort(404, description=description)
+
+ return value
+
+ def one_or_404(
+ self, statement: sa.sql.Select[t.Any], *, description: str | None = None
+ ) -> t.Any:
+ """Like :meth:`Result.scalar_one() `,
+ but aborts with a ``404 Not Found`` error instead of raising ``NoResultFound``
+ or ``MultipleResultsFound``.
+
+ :param statement: The ``select`` statement to execute.
+ :param description: A custom message to show on the error page.
+
+ .. versionadded:: 3.0
+ """
+ try:
+ return self.session.execute(statement).scalar_one()
+ except (sa_exc.NoResultFound, sa_exc.MultipleResultsFound):
+ abort(404, description=description)
+
+ def paginate(
+ self,
+ select: sa.sql.Select[t.Any],
+ *,
+ page: int | None = None,
+ per_page: int | None = None,
+ max_per_page: int | None = None,
+ error_out: bool = True,
+ count: bool = True,
+ ) -> Pagination:
+ """Apply an offset and limit to a select statment based on the current page and
+ number of items per page, returning a :class:`.Pagination` object.
+
+ The statement should select a model class, like ``select(User)``. This applies
+ ``unique()`` and ``scalars()`` modifiers to the result, so compound selects will
+ not return the expected results.
+
+ :param select: The ``select`` statement to paginate.
+ :param page: The current page, used to calculate the offset. Defaults to the
+ ``page`` query arg during a request, or 1 otherwise.
+ :param per_page: The maximum number of items on a page, used to calculate the
+ offset and limit. Defaults to the ``per_page`` query arg during a request,
+ or 20 otherwise.
+ :param max_per_page: The maximum allowed value for ``per_page``, to limit a
+ user-provided value. Use ``None`` for no limit. Defaults to 100.
+ :param error_out: Abort with a ``404 Not Found`` error if no items are returned
+ and ``page`` is not 1, or if ``page`` or ``per_page`` is less than 1, or if
+ either are not ints.
+ :param count: Calculate the total number of values by issuing an extra count
+ query. For very complex queries this may be inaccurate or slow, so it can be
+ disabled and set manually if necessary.
+
+ .. versionchanged:: 3.0
+ The ``count`` query is more efficient.
+
+ .. versionadded:: 3.0
+ """
+ return SelectPagination(
+ select=select,
+ session=self.session(),
+ page=page,
+ per_page=per_page,
+ max_per_page=max_per_page,
+ error_out=error_out,
+ count=count,
+ )
+
+ def _call_for_binds(
+ self, bind_key: str | None | list[str | None], op_name: str
+ ) -> None:
+ """Call a method on each metadata.
+
+ :meta private:
+
+ :param bind_key: A bind key or list of keys. Defaults to all binds.
+ :param op_name: The name of the method to call.
+
+ .. versionchanged:: 3.0
+ Renamed from ``_execute_for_all_tables``.
+ """
+ if bind_key == "__all__":
+ keys: list[str | None] = list(self.metadatas)
+ elif bind_key is None or isinstance(bind_key, str):
+ keys = [bind_key]
+ else:
+ keys = bind_key
+
+ for key in keys:
+ try:
+ engine = self.engines[key]
+ except KeyError:
+ message = f"Bind key '{key}' is not in 'SQLALCHEMY_BINDS' config."
+
+ if key is None:
+ message = f"'SQLALCHEMY_DATABASE_URI' config is not set. {message}"
+
+ raise sa_exc.UnboundExecutionError(message) from None
+
+ metadata = self.metadatas[key]
+ getattr(metadata, op_name)(bind=engine)
+
+ def create_all(self, bind_key: str | None | list[str | None] = "__all__") -> None:
+ """Create tables that do not exist in the database by calling
+ ``metadata.create_all()`` for all or some bind keys. This does not
+ update existing tables, use a migration library for that.
+
+ This requires that a Flask application context is active.
+
+ :param bind_key: A bind key or list of keys to create the tables for. Defaults
+ to all binds.
+
+ .. versionchanged:: 3.0
+ Renamed the ``bind`` parameter to ``bind_key``. Removed the ``app``
+ parameter.
+
+ .. versionchanged:: 0.12
+ Added the ``bind`` and ``app`` parameters.
+ """
+ self._call_for_binds(bind_key, "create_all")
+
+ def drop_all(self, bind_key: str | None | list[str | None] = "__all__") -> None:
+ """Drop tables by calling ``metadata.drop_all()`` for all or some bind keys.
+
+ This requires that a Flask application context is active.
+
+ :param bind_key: A bind key or list of keys to drop the tables from. Defaults to
+ all binds.
+
+ .. versionchanged:: 3.0
+ Renamed the ``bind`` parameter to ``bind_key``. Removed the ``app``
+ parameter.
+
+ .. versionchanged:: 0.12
+ Added the ``bind`` and ``app`` parameters.
+ """
+ self._call_for_binds(bind_key, "drop_all")
+
+ def reflect(self, bind_key: str | None | list[str | None] = "__all__") -> None:
+ """Load table definitions from the database by calling ``metadata.reflect()``
+ for all or some bind keys.
+
+ This requires that a Flask application context is active.
+
+ :param bind_key: A bind key or list of keys to reflect the tables from. Defaults
+ to all binds.
+
+ .. versionchanged:: 3.0
+ Renamed the ``bind`` parameter to ``bind_key``. Removed the ``app``
+ parameter.
+
+ .. versionchanged:: 0.12
+ Added the ``bind`` and ``app`` parameters.
+ """
+ self._call_for_binds(bind_key, "reflect")
+
+ def _set_rel_query(self, kwargs: dict[str, t.Any]) -> None:
+ """Apply the extension's :attr:`Query` class as the default for relationships
+ and backrefs.
+
+ :meta private:
+ """
+ kwargs.setdefault("query_class", self.Query)
+
+ if "backref" in kwargs:
+ backref = kwargs["backref"]
+
+ if isinstance(backref, str):
+ backref = (backref, {})
+
+ backref[1].setdefault("query_class", self.Query)
+
+ def relationship(
+ self, *args: t.Any, **kwargs: t.Any
+ ) -> sa_orm.RelationshipProperty[t.Any]:
+ """A :func:`sqlalchemy.orm.relationship` that applies this extension's
+ :attr:`Query` class for dynamic relationships and backrefs.
+
+ .. versionchanged:: 3.0
+ The :attr:`Query` class is set on ``backref``.
+ """
+ self._set_rel_query(kwargs)
+ return sa_orm.relationship(*args, **kwargs)
+
+ def dynamic_loader(
+ self, argument: t.Any, **kwargs: t.Any
+ ) -> sa_orm.RelationshipProperty[t.Any]:
+ """A :func:`sqlalchemy.orm.dynamic_loader` that applies this extension's
+ :attr:`Query` class for relationships and backrefs.
+
+ .. versionchanged:: 3.0
+ The :attr:`Query` class is set on ``backref``.
+ """
+ self._set_rel_query(kwargs)
+ return sa_orm.dynamic_loader(argument, **kwargs)
+
+ def _relation(
+ self, *args: t.Any, **kwargs: t.Any
+ ) -> sa_orm.RelationshipProperty[t.Any]:
+ """A :func:`sqlalchemy.orm.relationship` that applies this extension's
+ :attr:`Query` class for dynamic relationships and backrefs.
+
+ SQLAlchemy 2.0 removes this name, use ``relationship`` instead.
+
+ :meta private:
+
+ .. versionchanged:: 3.0
+ The :attr:`Query` class is set on ``backref``.
+ """
+ self._set_rel_query(kwargs)
+ f = sa_orm.relationship
+ return f(*args, **kwargs)
+
+ def __getattr__(self, name: str) -> t.Any:
+ if name == "relation":
+ return self._relation
+
+ if name == "event":
+ return sa_event
+
+ if name.startswith("_"):
+ raise AttributeError(name)
+
+ for mod in (sa, sa_orm):
+ if hasattr(mod, name):
+ return getattr(mod, name)
+
+ raise AttributeError(name)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/model.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/model.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6f9e5a92b44f905c730502e149652ad1f1b3222
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/model.py
@@ -0,0 +1,330 @@
+from __future__ import annotations
+
+import re
+import typing as t
+
+import sqlalchemy as sa
+import sqlalchemy.orm as sa_orm
+
+from .query import Query
+
+if t.TYPE_CHECKING:
+ from .extension import SQLAlchemy
+
+
+class _QueryProperty:
+ """A class property that creates a query object for a model.
+
+ :meta private:
+ """
+
+ def __get__(self, obj: Model | None, cls: type[Model]) -> Query:
+ return cls.query_class(
+ cls, session=cls.__fsa__.session() # type: ignore[arg-type]
+ )
+
+
+class Model:
+ """The base class of the :attr:`.SQLAlchemy.Model` declarative model class.
+
+ To define models, subclass :attr:`db.Model <.SQLAlchemy.Model>`, not this. To
+ customize ``db.Model``, subclass this and pass it as ``model_class`` to
+ :class:`.SQLAlchemy`. To customize ``db.Model`` at the metaclass level, pass an
+ already created declarative model class as ``model_class``.
+ """
+
+ __fsa__: t.ClassVar[SQLAlchemy]
+ """Internal reference to the extension object.
+
+ :meta private:
+ """
+
+ query_class: t.ClassVar[type[Query]] = Query
+ """Query class used by :attr:`query`. Defaults to :attr:`.SQLAlchemy.Query`, which
+ defaults to :class:`.Query`.
+ """
+
+ query: t.ClassVar[Query] = _QueryProperty() # type: ignore[assignment]
+ """A SQLAlchemy query for a model. Equivalent to ``db.session.query(Model)``. Can be
+ customized per-model by overriding :attr:`query_class`.
+
+ .. warning::
+ The query interface is considered legacy in SQLAlchemy. Prefer using
+ ``session.execute(select())`` instead.
+ """
+
+ def __repr__(self) -> str:
+ state = sa.inspect(self)
+ assert state is not None
+
+ if state.transient:
+ pk = f"(transient {id(self)})"
+ elif state.pending:
+ pk = f"(pending {id(self)})"
+ else:
+ pk = ", ".join(map(str, state.identity))
+
+ return f"<{type(self).__name__} {pk}>"
+
+
+class BindMetaMixin(type):
+ """Metaclass mixin that sets a model's ``metadata`` based on its ``__bind_key__``.
+
+ If the model sets ``metadata`` or ``__table__`` directly, ``__bind_key__`` is
+ ignored. If the ``metadata`` is the same as the parent model, it will not be set
+ directly on the child model.
+ """
+
+ __fsa__: SQLAlchemy
+ metadata: sa.MetaData
+
+ def __init__(
+ cls, name: str, bases: tuple[type, ...], d: dict[str, t.Any], **kwargs: t.Any
+ ) -> None:
+ if not ("metadata" in cls.__dict__ or "__table__" in cls.__dict__):
+ bind_key = getattr(cls, "__bind_key__", None)
+ parent_metadata = getattr(cls, "metadata", None)
+ metadata = cls.__fsa__._make_metadata(bind_key)
+
+ if metadata is not parent_metadata:
+ cls.metadata = metadata
+
+ super().__init__(name, bases, d, **kwargs)
+
+
+class BindMixin:
+ """DeclarativeBase mixin to set a model's ``metadata`` based on ``__bind_key__``.
+
+ If no ``__bind_key__`` is specified, the model will use the default metadata
+ provided by ``DeclarativeBase`` or ``DeclarativeBaseNoMeta``.
+ If the model doesn't set ``metadata`` or ``__table__`` directly
+ and does set ``__bind_key__``, the model will use the metadata
+ for the specified bind key.
+ If the ``metadata`` is the same as the parent model, it will not be set
+ directly on the child model.
+
+ .. versionchanged:: 3.1.0
+ """
+
+ __fsa__: SQLAlchemy
+ metadata: sa.MetaData
+
+ @classmethod
+ def __init_subclass__(cls: t.Type[BindMixin], **kwargs: t.Dict[str, t.Any]) -> None:
+ if not ("metadata" in cls.__dict__ or "__table__" in cls.__dict__) and hasattr(
+ cls, "__bind_key__"
+ ):
+ bind_key = getattr(cls, "__bind_key__", None)
+ parent_metadata = getattr(cls, "metadata", None)
+ metadata = cls.__fsa__._make_metadata(bind_key)
+
+ if metadata is not parent_metadata:
+ cls.metadata = metadata
+
+ super().__init_subclass__(**kwargs)
+
+
+class NameMetaMixin(type):
+ """Metaclass mixin that sets a model's ``__tablename__`` by converting the
+ ``CamelCase`` class name to ``snake_case``. A name is set for non-abstract models
+ that do not otherwise define ``__tablename__``. If a model does not define a primary
+ key, it will not generate a name or ``__table__``, for single-table inheritance.
+ """
+
+ metadata: sa.MetaData
+ __tablename__: str
+ __table__: sa.Table
+
+ def __init__(
+ cls, name: str, bases: tuple[type, ...], d: dict[str, t.Any], **kwargs: t.Any
+ ) -> None:
+ if should_set_tablename(cls):
+ cls.__tablename__ = camel_to_snake_case(cls.__name__)
+
+ super().__init__(name, bases, d, **kwargs)
+
+ # __table_cls__ has run. If no table was created, use the parent table.
+ if (
+ "__tablename__" not in cls.__dict__
+ and "__table__" in cls.__dict__
+ and cls.__dict__["__table__"] is None
+ ):
+ del cls.__table__
+
+ def __table_cls__(cls, *args: t.Any, **kwargs: t.Any) -> sa.Table | None:
+ """This is called by SQLAlchemy during mapper setup. It determines the final
+ table object that the model will use.
+
+ If no primary key is found, that indicates single-table inheritance, so no table
+ will be created and ``__tablename__`` will be unset.
+ """
+ schema = kwargs.get("schema")
+
+ if schema is None:
+ key = args[0]
+ else:
+ key = f"{schema}.{args[0]}"
+
+ # Check if a table with this name already exists. Allows reflected tables to be
+ # applied to models by name.
+ if key in cls.metadata.tables:
+ return sa.Table(*args, **kwargs)
+
+ # If a primary key is found, create a table for joined-table inheritance.
+ for arg in args:
+ if (isinstance(arg, sa.Column) and arg.primary_key) or isinstance(
+ arg, sa.PrimaryKeyConstraint
+ ):
+ return sa.Table(*args, **kwargs)
+
+ # If no base classes define a table, return one that's missing a primary key
+ # so SQLAlchemy shows the correct error.
+ for base in cls.__mro__[1:-1]:
+ if "__table__" in base.__dict__:
+ break
+ else:
+ return sa.Table(*args, **kwargs)
+
+ # Single-table inheritance, use the parent table name. __init__ will unset
+ # __table__ based on this.
+ if "__tablename__" in cls.__dict__:
+ del cls.__tablename__
+
+ return None
+
+
+class NameMixin:
+ """DeclarativeBase mixin that sets a model's ``__tablename__`` by converting the
+ ``CamelCase`` class name to ``snake_case``. A name is set for non-abstract models
+ that do not otherwise define ``__tablename__``. If a model does not define a primary
+ key, it will not generate a name or ``__table__``, for single-table inheritance.
+
+ .. versionchanged:: 3.1.0
+ """
+
+ metadata: sa.MetaData
+ __tablename__: str
+ __table__: sa.Table
+
+ @classmethod
+ def __init_subclass__(cls: t.Type[NameMixin], **kwargs: t.Dict[str, t.Any]) -> None:
+ if should_set_tablename(cls):
+ cls.__tablename__ = camel_to_snake_case(cls.__name__)
+
+ super().__init_subclass__(**kwargs)
+
+ # __table_cls__ has run. If no table was created, use the parent table.
+ if (
+ "__tablename__" not in cls.__dict__
+ and "__table__" in cls.__dict__
+ and cls.__dict__["__table__"] is None
+ ):
+ del cls.__table__
+
+ @classmethod
+ def __table_cls__(cls, *args: t.Any, **kwargs: t.Any) -> sa.Table | None:
+ """This is called by SQLAlchemy during mapper setup. It determines the final
+ table object that the model will use.
+
+ If no primary key is found, that indicates single-table inheritance, so no table
+ will be created and ``__tablename__`` will be unset.
+ """
+ schema = kwargs.get("schema")
+
+ if schema is None:
+ key = args[0]
+ else:
+ key = f"{schema}.{args[0]}"
+
+ # Check if a table with this name already exists. Allows reflected tables to be
+ # applied to models by name.
+ if key in cls.metadata.tables:
+ return sa.Table(*args, **kwargs)
+
+ # If a primary key is found, create a table for joined-table inheritance.
+ for arg in args:
+ if (isinstance(arg, sa.Column) and arg.primary_key) or isinstance(
+ arg, sa.PrimaryKeyConstraint
+ ):
+ return sa.Table(*args, **kwargs)
+
+ # If no base classes define a table, return one that's missing a primary key
+ # so SQLAlchemy shows the correct error.
+ for base in cls.__mro__[1:-1]:
+ if "__table__" in base.__dict__:
+ break
+ else:
+ return sa.Table(*args, **kwargs)
+
+ # Single-table inheritance, use the parent table name. __init__ will unset
+ # __table__ based on this.
+ if "__tablename__" in cls.__dict__:
+ del cls.__tablename__
+
+ return None
+
+
+def should_set_tablename(cls: type) -> bool:
+ """Determine whether ``__tablename__`` should be generated for a model.
+
+ - If no class in the MRO sets a name, one should be generated.
+ - If a declared attr is found, it should be used instead.
+ - If a name is found, it should be used if the class is a mixin, otherwise one
+ should be generated.
+ - Abstract models should not have one generated.
+
+ Later, ``__table_cls__`` will determine if the model looks like single or
+ joined-table inheritance. If no primary key is found, the name will be unset.
+ """
+ if (
+ cls.__dict__.get("__abstract__", False)
+ or (
+ not issubclass(cls, (sa_orm.DeclarativeBase, sa_orm.DeclarativeBaseNoMeta))
+ and not any(isinstance(b, sa_orm.DeclarativeMeta) for b in cls.__mro__[1:])
+ )
+ or any(
+ (b is sa_orm.DeclarativeBase or b is sa_orm.DeclarativeBaseNoMeta)
+ for b in cls.__bases__
+ )
+ ):
+ return False
+
+ for base in cls.__mro__:
+ if "__tablename__" not in base.__dict__:
+ continue
+
+ if isinstance(base.__dict__["__tablename__"], sa_orm.declared_attr):
+ return False
+
+ return not (
+ base is cls
+ or base.__dict__.get("__abstract__", False)
+ or not (
+ # SQLAlchemy 1.x
+ isinstance(base, sa_orm.DeclarativeMeta)
+ # 2.x: DeclarativeBas uses this as metaclass
+ or isinstance(base, sa_orm.decl_api.DeclarativeAttributeIntercept)
+ # 2.x: DeclarativeBaseNoMeta doesn't use a metaclass
+ or issubclass(base, sa_orm.DeclarativeBaseNoMeta)
+ )
+ )
+
+ return True
+
+
+def camel_to_snake_case(name: str) -> str:
+ """Convert a ``CamelCase`` name to ``snake_case``."""
+ name = re.sub(r"((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))", r"_\1", name)
+ return name.lower().lstrip("_")
+
+
+class DefaultMeta(BindMetaMixin, NameMetaMixin, sa_orm.DeclarativeMeta):
+ """SQLAlchemy declarative metaclass that provides ``__bind_key__`` and
+ ``__tablename__`` support.
+ """
+
+
+class DefaultMetaNoName(BindMetaMixin, sa_orm.DeclarativeMeta):
+ """SQLAlchemy declarative metaclass that provides ``__bind_key__`` and
+ ``__tablename__`` support.
+ """
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/pagination.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/pagination.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d49d6e04447e2111b7647fd59db6aaf3a3094ad
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/pagination.py
@@ -0,0 +1,364 @@
+from __future__ import annotations
+
+import typing as t
+from math import ceil
+
+import sqlalchemy as sa
+import sqlalchemy.orm as sa_orm
+from flask import abort
+from flask import request
+
+
+class Pagination:
+ """Apply an offset and limit to the query based on the current page and number of
+ items per page.
+
+ Don't create pagination objects manually. They are created by
+ :meth:`.SQLAlchemy.paginate` and :meth:`.Query.paginate`.
+
+ This is a base class, a subclass must implement :meth:`_query_items` and
+ :meth:`_query_count`. Those methods will use arguments passed as ``kwargs`` to
+ perform the queries.
+
+ :param page: The current page, used to calculate the offset. Defaults to the
+ ``page`` query arg during a request, or 1 otherwise.
+ :param per_page: The maximum number of items on a page, used to calculate the
+ offset and limit. Defaults to the ``per_page`` query arg during a request,
+ or 20 otherwise.
+ :param max_per_page: The maximum allowed value for ``per_page``, to limit a
+ user-provided value. Use ``None`` for no limit. Defaults to 100.
+ :param error_out: Abort with a ``404 Not Found`` error if no items are returned
+ and ``page`` is not 1, or if ``page`` or ``per_page`` is less than 1, or if
+ either are not ints.
+ :param count: Calculate the total number of values by issuing an extra count
+ query. For very complex queries this may be inaccurate or slow, so it can be
+ disabled and set manually if necessary.
+ :param kwargs: Information about the query to paginate. Different subclasses will
+ require different arguments.
+
+ .. versionchanged:: 3.0
+ Iterating over a pagination object iterates over its items.
+
+ .. versionchanged:: 3.0
+ Creating instances manually is not a public API.
+ """
+
+ def __init__(
+ self,
+ page: int | None = None,
+ per_page: int | None = None,
+ max_per_page: int | None = 100,
+ error_out: bool = True,
+ count: bool = True,
+ **kwargs: t.Any,
+ ) -> None:
+ self._query_args = kwargs
+ page, per_page = self._prepare_page_args(
+ page=page,
+ per_page=per_page,
+ max_per_page=max_per_page,
+ error_out=error_out,
+ )
+
+ self.page: int = page
+ """The current page."""
+
+ self.per_page: int = per_page
+ """The maximum number of items on a page."""
+
+ self.max_per_page: int | None = max_per_page
+ """The maximum allowed value for ``per_page``."""
+
+ items = self._query_items()
+
+ if not items and page != 1 and error_out:
+ abort(404)
+
+ self.items: list[t.Any] = items
+ """The items on the current page. Iterating over the pagination object is
+ equivalent to iterating over the items.
+ """
+
+ if count:
+ total = self._query_count()
+ else:
+ total = None
+
+ self.total: int | None = total
+ """The total number of items across all pages."""
+
+ @staticmethod
+ def _prepare_page_args(
+ *,
+ page: int | None = None,
+ per_page: int | None = None,
+ max_per_page: int | None = None,
+ error_out: bool = True,
+ ) -> tuple[int, int]:
+ if request:
+ if page is None:
+ try:
+ page = int(request.args.get("page", 1))
+ except (TypeError, ValueError):
+ if error_out:
+ abort(404)
+
+ page = 1
+
+ if per_page is None:
+ try:
+ per_page = int(request.args.get("per_page", 20))
+ except (TypeError, ValueError):
+ if error_out:
+ abort(404)
+
+ per_page = 20
+ else:
+ if page is None:
+ page = 1
+
+ if per_page is None:
+ per_page = 20
+
+ if max_per_page is not None:
+ per_page = min(per_page, max_per_page)
+
+ if page < 1:
+ if error_out:
+ abort(404)
+ else:
+ page = 1
+
+ if per_page < 1:
+ if error_out:
+ abort(404)
+ else:
+ per_page = 20
+
+ return page, per_page
+
+ @property
+ def _query_offset(self) -> int:
+ """The index of the first item to query, passed to ``offset()``.
+
+ :meta private:
+
+ .. versionadded:: 3.0
+ """
+ return (self.page - 1) * self.per_page
+
+ def _query_items(self) -> list[t.Any]:
+ """Execute the query to get the items on the current page.
+
+ Uses init arguments stored in :attr:`_query_args`.
+
+ :meta private:
+
+ .. versionadded:: 3.0
+ """
+ raise NotImplementedError
+
+ def _query_count(self) -> int:
+ """Execute the query to get the total number of items.
+
+ Uses init arguments stored in :attr:`_query_args`.
+
+ :meta private:
+
+ .. versionadded:: 3.0
+ """
+ raise NotImplementedError
+
+ @property
+ def first(self) -> int:
+ """The number of the first item on the page, starting from 1, or 0 if there are
+ no items.
+
+ .. versionadded:: 3.0
+ """
+ if len(self.items) == 0:
+ return 0
+
+ return (self.page - 1) * self.per_page + 1
+
+ @property
+ def last(self) -> int:
+ """The number of the last item on the page, starting from 1, inclusive, or 0 if
+ there are no items.
+
+ .. versionadded:: 3.0
+ """
+ first = self.first
+ return max(first, first + len(self.items) - 1)
+
+ @property
+ def pages(self) -> int:
+ """The total number of pages."""
+ if self.total == 0 or self.total is None:
+ return 0
+
+ return ceil(self.total / self.per_page)
+
+ @property
+ def has_prev(self) -> bool:
+ """``True`` if this is not the first page."""
+ return self.page > 1
+
+ @property
+ def prev_num(self) -> int | None:
+ """The previous page number, or ``None`` if this is the first page."""
+ if not self.has_prev:
+ return None
+
+ return self.page - 1
+
+ def prev(self, *, error_out: bool = False) -> Pagination:
+ """Query the :class:`Pagination` object for the previous page.
+
+ :param error_out: Abort with a ``404 Not Found`` error if no items are returned
+ and ``page`` is not 1, or if ``page`` or ``per_page`` is less than 1, or if
+ either are not ints.
+ """
+ p = type(self)(
+ page=self.page - 1,
+ per_page=self.per_page,
+ error_out=error_out,
+ count=False,
+ **self._query_args,
+ )
+ p.total = self.total
+ return p
+
+ @property
+ def has_next(self) -> bool:
+ """``True`` if this is not the last page."""
+ return self.page < self.pages
+
+ @property
+ def next_num(self) -> int | None:
+ """The next page number, or ``None`` if this is the last page."""
+ if not self.has_next:
+ return None
+
+ return self.page + 1
+
+ def next(self, *, error_out: bool = False) -> Pagination:
+ """Query the :class:`Pagination` object for the next page.
+
+ :param error_out: Abort with a ``404 Not Found`` error if no items are returned
+ and ``page`` is not 1, or if ``page`` or ``per_page`` is less than 1, or if
+ either are not ints.
+ """
+ p = type(self)(
+ page=self.page + 1,
+ per_page=self.per_page,
+ max_per_page=self.max_per_page,
+ error_out=error_out,
+ count=False,
+ **self._query_args,
+ )
+ p.total = self.total
+ return p
+
+ def iter_pages(
+ self,
+ *,
+ left_edge: int = 2,
+ left_current: int = 2,
+ right_current: int = 4,
+ right_edge: int = 2,
+ ) -> t.Iterator[int | None]:
+ """Yield page numbers for a pagination widget. Skipped pages between the edges
+ and middle are represented by a ``None``.
+
+ For example, if there are 20 pages and the current page is 7, the following
+ values are yielded.
+
+ .. code-block:: python
+
+ 1, 2, None, 5, 6, 7, 8, 9, 10, 11, None, 19, 20
+
+ :param left_edge: How many pages to show from the first page.
+ :param left_current: How many pages to show left of the current page.
+ :param right_current: How many pages to show right of the current page.
+ :param right_edge: How many pages to show from the last page.
+
+ .. versionchanged:: 3.0
+ Improved efficiency of calculating what to yield.
+
+ .. versionchanged:: 3.0
+ ``right_current`` boundary is inclusive.
+
+ .. versionchanged:: 3.0
+ All parameters are keyword-only.
+ """
+ pages_end = self.pages + 1
+
+ if pages_end == 1:
+ return
+
+ left_end = min(1 + left_edge, pages_end)
+ yield from range(1, left_end)
+
+ if left_end == pages_end:
+ return
+
+ mid_start = max(left_end, self.page - left_current)
+ mid_end = min(self.page + right_current + 1, pages_end)
+
+ if mid_start - left_end > 0:
+ yield None
+
+ yield from range(mid_start, mid_end)
+
+ if mid_end == pages_end:
+ return
+
+ right_start = max(mid_end, pages_end - right_edge)
+
+ if right_start - mid_end > 0:
+ yield None
+
+ yield from range(right_start, pages_end)
+
+ def __iter__(self) -> t.Iterator[t.Any]:
+ yield from self.items
+
+
+class SelectPagination(Pagination):
+ """Returned by :meth:`.SQLAlchemy.paginate`. Takes ``select`` and ``session``
+ arguments in addition to the :class:`Pagination` arguments.
+
+ .. versionadded:: 3.0
+ """
+
+ def _query_items(self) -> list[t.Any]:
+ select = self._query_args["select"]
+ select = select.limit(self.per_page).offset(self._query_offset)
+ session = self._query_args["session"]
+ return list(session.execute(select).unique().scalars())
+
+ def _query_count(self) -> int:
+ select = self._query_args["select"]
+ sub = select.options(sa_orm.lazyload("*")).order_by(None).subquery()
+ session = self._query_args["session"]
+ out = session.execute(sa.select(sa.func.count()).select_from(sub)).scalar()
+ return out # type: ignore[no-any-return]
+
+
+class QueryPagination(Pagination):
+ """Returned by :meth:`.Query.paginate`. Takes a ``query`` argument in addition to
+ the :class:`Pagination` arguments.
+
+ .. versionadded:: 3.0
+ """
+
+ def _query_items(self) -> list[t.Any]:
+ query = self._query_args["query"]
+ out = query.limit(self.per_page).offset(self._query_offset).all()
+ return out # type: ignore[no-any-return]
+
+ def _query_count(self) -> int:
+ # Query.count automatically disables eager loads
+ out = self._query_args["query"].order_by(None).count()
+ return out # type: ignore[no-any-return]
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/py.typed b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/query.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/query.py
new file mode 100644
index 0000000000000000000000000000000000000000..35f927d2852d0e6ba54480e55d1c76ad46d72c58
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/query.py
@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import typing as t
+
+import sqlalchemy.exc as sa_exc
+import sqlalchemy.orm as sa_orm
+from flask import abort
+
+from .pagination import Pagination
+from .pagination import QueryPagination
+
+
+class Query(sa_orm.Query): # type: ignore[type-arg]
+ """SQLAlchemy :class:`~sqlalchemy.orm.query.Query` subclass with some extra methods
+ useful for querying in a web application.
+
+ This is the default query class for :attr:`.Model.query`.
+
+ .. versionchanged:: 3.0
+ Renamed to ``Query`` from ``BaseQuery``.
+ """
+
+ def get_or_404(self, ident: t.Any, description: str | None = None) -> t.Any:
+ """Like :meth:`~sqlalchemy.orm.Query.get` but aborts with a ``404 Not Found``
+ error instead of returning ``None``.
+
+ :param ident: The primary key to query.
+ :param description: A custom message to show on the error page.
+ """
+ rv = self.get(ident)
+
+ if rv is None:
+ abort(404, description=description)
+
+ return rv
+
+ def first_or_404(self, description: str | None = None) -> t.Any:
+ """Like :meth:`~sqlalchemy.orm.Query.first` but aborts with a ``404 Not Found``
+ error instead of returning ``None``.
+
+ :param description: A custom message to show on the error page.
+ """
+ rv = self.first()
+
+ if rv is None:
+ abort(404, description=description)
+
+ return rv
+
+ def one_or_404(self, description: str | None = None) -> t.Any:
+ """Like :meth:`~sqlalchemy.orm.Query.one` but aborts with a ``404 Not Found``
+ error instead of raising ``NoResultFound`` or ``MultipleResultsFound``.
+
+ :param description: A custom message to show on the error page.
+
+ .. versionadded:: 3.0
+ """
+ try:
+ return self.one()
+ except (sa_exc.NoResultFound, sa_exc.MultipleResultsFound):
+ abort(404, description=description)
+
+ def paginate(
+ self,
+ *,
+ page: int | None = None,
+ per_page: int | None = None,
+ max_per_page: int | None = None,
+ error_out: bool = True,
+ count: bool = True,
+ ) -> Pagination:
+ """Apply an offset and limit to the query based on the current page and number
+ of items per page, returning a :class:`.Pagination` object.
+
+ :param page: The current page, used to calculate the offset. Defaults to the
+ ``page`` query arg during a request, or 1 otherwise.
+ :param per_page: The maximum number of items on a page, used to calculate the
+ offset and limit. Defaults to the ``per_page`` query arg during a request,
+ or 20 otherwise.
+ :param max_per_page: The maximum allowed value for ``per_page``, to limit a
+ user-provided value. Use ``None`` for no limit. Defaults to 100.
+ :param error_out: Abort with a ``404 Not Found`` error if no items are returned
+ and ``page`` is not 1, or if ``page`` or ``per_page`` is less than 1, or if
+ either are not ints.
+ :param count: Calculate the total number of values by issuing an extra count
+ query. For very complex queries this may be inaccurate or slow, so it can be
+ disabled and set manually if necessary.
+
+ .. versionchanged:: 3.0
+ All parameters are keyword-only.
+
+ .. versionchanged:: 3.0
+ The ``count`` query is more efficient.
+
+ .. versionchanged:: 3.0
+ ``max_per_page`` defaults to 100.
+ """
+ return QueryPagination(
+ query=self,
+ page=page,
+ per_page=per_page,
+ max_per_page=max_per_page,
+ error_out=error_out,
+ count=count,
+ )
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/record_queries.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/record_queries.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8273be951c52357ab8248e29e6b04d86327697c
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/record_queries.py
@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import dataclasses
+import inspect
+import typing as t
+from time import perf_counter
+
+import sqlalchemy as sa
+import sqlalchemy.event as sa_event
+from flask import current_app
+from flask import g
+from flask import has_app_context
+
+
+def get_recorded_queries() -> list[_QueryInfo]:
+ """Get the list of recorded query information for the current session. Queries are
+ recorded if the config :data:`.SQLALCHEMY_RECORD_QUERIES` is enabled.
+
+ Each query info object has the following attributes:
+
+ ``statement``
+ The string of SQL generated by SQLAlchemy with parameter placeholders.
+ ``parameters``
+ The parameters sent with the SQL statement.
+ ``start_time`` / ``end_time``
+ Timing info about when the query started execution and when the results where
+ returned. Accuracy and value depends on the operating system.
+ ``duration``
+ The time the query took in seconds.
+ ``location``
+ A string description of where in your application code the query was executed.
+ This may not be possible to calculate, and the format is not stable.
+
+ .. versionchanged:: 3.0
+ Renamed from ``get_debug_queries``.
+
+ .. versionchanged:: 3.0
+ The info object is a dataclass instead of a tuple.
+
+ .. versionchanged:: 3.0
+ The info object attribute ``context`` is renamed to ``location``.
+
+ .. versionchanged:: 3.0
+ Not enabled automatically in debug or testing mode.
+ """
+ return g.get("_sqlalchemy_queries", []) # type: ignore[no-any-return]
+
+
+@dataclasses.dataclass
+class _QueryInfo:
+ """Information about an executed query. Returned by :func:`get_recorded_queries`.
+
+ .. versionchanged:: 3.0
+ Renamed from ``_DebugQueryTuple``.
+
+ .. versionchanged:: 3.0
+ Changed to a dataclass instead of a tuple.
+
+ .. versionchanged:: 3.0
+ ``context`` is renamed to ``location``.
+ """
+
+ statement: str | None
+ parameters: t.Any
+ start_time: float
+ end_time: float
+ location: str
+
+ @property
+ def duration(self) -> float:
+ return self.end_time - self.start_time
+
+
+def _listen(engine: sa.engine.Engine) -> None:
+ sa_event.listen(engine, "before_cursor_execute", _record_start, named=True)
+ sa_event.listen(engine, "after_cursor_execute", _record_end, named=True)
+
+
+def _record_start(context: sa.engine.ExecutionContext, **kwargs: t.Any) -> None:
+ if not has_app_context():
+ return
+
+ context._fsa_start_time = perf_counter() # type: ignore[attr-defined]
+
+
+def _record_end(context: sa.engine.ExecutionContext, **kwargs: t.Any) -> None:
+ if not has_app_context():
+ return
+
+ if "_sqlalchemy_queries" not in g:
+ g._sqlalchemy_queries = []
+
+ import_top = current_app.import_name.partition(".")[0]
+ import_dot = f"{import_top}."
+ frame = inspect.currentframe()
+
+ while frame:
+ name = frame.f_globals.get("__name__")
+
+ if name and (name == import_top or name.startswith(import_dot)):
+ code = frame.f_code
+ location = f"{code.co_filename}:{frame.f_lineno} ({code.co_name})"
+ break
+
+ frame = frame.f_back
+ else:
+ location = ""
+
+ g._sqlalchemy_queries.append(
+ _QueryInfo(
+ statement=context.statement,
+ parameters=context.parameters,
+ start_time=context._fsa_start_time, # type: ignore[attr-defined]
+ end_time=perf_counter(),
+ location=location,
+ )
+ )
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/session.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/session.py
new file mode 100644
index 0000000000000000000000000000000000000000..631fffa82c449827f9c5c102fa190801478484bc
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/session.py
@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import typing as t
+
+import sqlalchemy as sa
+import sqlalchemy.exc as sa_exc
+import sqlalchemy.orm as sa_orm
+from flask.globals import app_ctx
+
+if t.TYPE_CHECKING:
+ from .extension import SQLAlchemy
+
+
+class Session(sa_orm.Session):
+ """A SQLAlchemy :class:`~sqlalchemy.orm.Session` class that chooses what engine to
+ use based on the bind key associated with the metadata associated with the thing
+ being queried.
+
+ To customize ``db.session``, subclass this and pass it as the ``class_`` key in the
+ ``session_options`` to :class:`.SQLAlchemy`.
+
+ .. versionchanged:: 3.0
+ Renamed from ``SignallingSession``.
+ """
+
+ def __init__(self, db: SQLAlchemy, **kwargs: t.Any) -> None:
+ super().__init__(**kwargs)
+ self._db = db
+ self._model_changes: dict[object, tuple[t.Any, str]] = {}
+
+ def get_bind(
+ self,
+ mapper: t.Any | None = None,
+ clause: t.Any | None = None,
+ bind: sa.engine.Engine | sa.engine.Connection | None = None,
+ **kwargs: t.Any,
+ ) -> sa.engine.Engine | sa.engine.Connection:
+ """Select an engine based on the ``bind_key`` of the metadata associated with
+ the model or table being queried. If no bind key is set, uses the default bind.
+
+ .. versionchanged:: 3.0.3
+ Fix finding the bind for a joined inheritance model.
+
+ .. versionchanged:: 3.0
+ The implementation more closely matches the base SQLAlchemy implementation.
+
+ .. versionchanged:: 2.1
+ Support joining an external transaction.
+ """
+ if bind is not None:
+ return bind
+
+ engines = self._db.engines
+
+ if mapper is not None:
+ try:
+ mapper = sa.inspect(mapper)
+ except sa_exc.NoInspectionAvailable as e:
+ if isinstance(mapper, type):
+ raise sa_orm.exc.UnmappedClassError(mapper) from e
+
+ raise
+
+ engine = _clause_to_engine(mapper.local_table, engines)
+
+ if engine is not None:
+ return engine
+
+ if clause is not None:
+ engine = _clause_to_engine(clause, engines)
+
+ if engine is not None:
+ return engine
+
+ if None in engines:
+ return engines[None]
+
+ return super().get_bind(mapper=mapper, clause=clause, bind=bind, **kwargs)
+
+
+def _clause_to_engine(
+ clause: sa.ClauseElement | None,
+ engines: t.Mapping[str | None, sa.engine.Engine],
+) -> sa.engine.Engine | None:
+ """If the clause is a table, return the engine associated with the table's
+ metadata's bind key.
+ """
+ table = None
+
+ if clause is not None:
+ if isinstance(clause, sa.Table):
+ table = clause
+ elif isinstance(clause, sa.UpdateBase) and isinstance(clause.table, sa.Table):
+ table = clause.table
+
+ if table is not None and "bind_key" in table.metadata.info:
+ key = table.metadata.info["bind_key"]
+
+ if key not in engines:
+ raise sa_exc.UnboundExecutionError(
+ f"Bind key '{key}' is not in 'SQLALCHEMY_BINDS' config."
+ )
+
+ return engines[key]
+
+ return None
+
+
+def _app_ctx_id() -> int:
+ """Get the id of the current Flask application context for the session scope."""
+ return id(app_ctx._get_current_object()) # type: ignore[attr-defined]
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/table.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/table.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab08a692af92e090d23b9a642463d901c28f1c65
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/table.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import typing as t
+
+import sqlalchemy as sa
+import sqlalchemy.sql.schema as sa_sql_schema
+
+
+class _Table(sa.Table):
+ @t.overload
+ def __init__(
+ self,
+ name: str,
+ *args: sa_sql_schema.SchemaItem,
+ bind_key: str | None = None,
+ **kwargs: t.Any,
+ ) -> None:
+ ...
+
+ @t.overload
+ def __init__(
+ self,
+ name: str,
+ metadata: sa.MetaData,
+ *args: sa_sql_schema.SchemaItem,
+ **kwargs: t.Any,
+ ) -> None:
+ ...
+
+ @t.overload
+ def __init__(
+ self, name: str, *args: sa_sql_schema.SchemaItem, **kwargs: t.Any
+ ) -> None:
+ ...
+
+ def __init__(
+ self, name: str, *args: sa_sql_schema.SchemaItem, **kwargs: t.Any
+ ) -> None:
+ super().__init__(name, *args, **kwargs) # type: ignore[arg-type]
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/track_modifications.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/track_modifications.py
new file mode 100644
index 0000000000000000000000000000000000000000..7028b65381146f82fadb9b102c432f8b05341af6
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_sqlalchemy/track_modifications.py
@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import typing as t
+
+import sqlalchemy as sa
+import sqlalchemy.event as sa_event
+import sqlalchemy.orm as sa_orm
+from flask import current_app
+from flask import has_app_context
+from flask.signals import Namespace # type: ignore[attr-defined]
+
+if t.TYPE_CHECKING:
+ from .session import Session
+
+_signals = Namespace()
+
+models_committed = _signals.signal("models-committed")
+"""This Blinker signal is sent after the session is committed if there were changed
+models in the session.
+
+The sender is the application that emitted the changes. The receiver is passed the
+``changes`` argument with a list of tuples in the form ``(instance, operation)``.
+The operations are ``"insert"``, ``"update"``, and ``"delete"``.
+"""
+
+before_models_committed = _signals.signal("before-models-committed")
+"""This signal works exactly like :data:`models_committed` but is emitted before the
+commit takes place.
+"""
+
+
+def _listen(session: sa_orm.scoped_session[Session]) -> None:
+ sa_event.listen(session, "before_flush", _record_ops, named=True)
+ sa_event.listen(session, "before_commit", _record_ops, named=True)
+ sa_event.listen(session, "before_commit", _before_commit)
+ sa_event.listen(session, "after_commit", _after_commit)
+ sa_event.listen(session, "after_rollback", _after_rollback)
+
+
+def _record_ops(session: Session, **kwargs: t.Any) -> None:
+ if not has_app_context():
+ return
+
+ if not current_app.config["SQLALCHEMY_TRACK_MODIFICATIONS"]:
+ return
+
+ for targets, operation in (
+ (session.new, "insert"),
+ (session.dirty, "update"),
+ (session.deleted, "delete"),
+ ):
+ for target in targets:
+ state = sa.inspect(target)
+ key = state.identity_key if state.has_identity else id(target)
+ session._model_changes[key] = (target, operation)
+
+
+def _before_commit(session: Session) -> None:
+ if not has_app_context():
+ return
+
+ app = current_app._get_current_object() # type: ignore[attr-defined]
+
+ if not app.config["SQLALCHEMY_TRACK_MODIFICATIONS"]:
+ return
+
+ if session._model_changes:
+ changes = list(session._model_changes.values())
+ before_models_committed.send(app, changes=changes)
+
+
+def _after_commit(session: Session) -> None:
+ if not has_app_context():
+ return
+
+ app = current_app._get_current_object() # type: ignore[attr-defined]
+
+ if not app.config["SQLALCHEMY_TRACK_MODIFICATIONS"]:
+ return
+
+ if session._model_changes:
+ changes = list(session._model_changes.values())
+ models_committed.send(app, changes=changes)
+ session._model_changes.clear()
+
+
+def _after_rollback(session: Session) -> None:
+ session._model_changes.clear()
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/INSTALLER b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/METADATA b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..92f1ff25658838ae9639052003770899dc3851cb
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/METADATA
@@ -0,0 +1,72 @@
+Metadata-Version: 2.1
+Name: Flask-WTF
+Version: 1.2.1
+Summary: Form rendering, validation, and CSRF protection for Flask with WTForms.
+Project-URL: Documentation, https://flask-wtf.readthedocs.io/
+Project-URL: Changes, https://flask-wtf.readthedocs.io/changes/
+Project-URL: Source Code, https://github.com/wtforms/flask-wtf/
+Project-URL: Issue Tracker, https://github.com/wtforms/flask-wtf/issues/
+Project-URL: Chat, https://discord.gg/pallets
+Maintainer: WTForms
+License: Copyright 2010 WTForms
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ 3. Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+ TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+License-File: LICENSE.rst
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.8
+Requires-Dist: flask
+Requires-Dist: itsdangerous
+Requires-Dist: wtforms
+Provides-Extra: email
+Requires-Dist: email-validator; extra == 'email'
+Description-Content-Type: text/x-rst
+
+Flask-WTF
+=========
+
+Simple integration of Flask and WTForms, including CSRF, file upload,
+and reCAPTCHA.
+
+Links
+-----
+
+- Documentation: https://flask-wtf.readthedocs.io/
+- Changes: https://flask-wtf.readthedocs.io/changes/
+- PyPI Releases: https://pypi.org/project/Flask-WTF/
+- Source Code: https://github.com/wtforms/flask-wtf/
+- Issue Tracker: https://github.com/wtforms/flask-wtf/issues/
+- Chat: https://discord.gg/pallets
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/RECORD b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..44cf4fe85b82eb1659eccf510842e39a69572fd8
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/RECORD
@@ -0,0 +1,26 @@
+flask_wtf-1.2.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+flask_wtf-1.2.1.dist-info/METADATA,sha256=9Y5upDJ7WU2m2l4erWImF3HcVSWIZKH3TdX6klYpq4M,3373
+flask_wtf-1.2.1.dist-info/RECORD,,
+flask_wtf-1.2.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flask_wtf-1.2.1.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87
+flask_wtf-1.2.1.dist-info/licenses/LICENSE.rst,sha256=1fGQNkUVeMs27u8EyZ6_fXyi5w3PBDY2UZvEIOFafGI,1475
+flask_wtf/__init__.py,sha256=x6ydw5SJzsXZgz-Y6IM_95Sy8VufRepvZH1DUIlFoTo,214
+flask_wtf/__pycache__/__init__.cpython-311.pyc,,
+flask_wtf/__pycache__/_compat.cpython-311.pyc,,
+flask_wtf/__pycache__/csrf.cpython-311.pyc,,
+flask_wtf/__pycache__/file.cpython-311.pyc,,
+flask_wtf/__pycache__/form.cpython-311.pyc,,
+flask_wtf/__pycache__/i18n.cpython-311.pyc,,
+flask_wtf/_compat.py,sha256=N3sqC9yzFWY-3MZ7QazX1sidvkO3d5yy4NR6lkp0s94,248
+flask_wtf/csrf.py,sha256=O-fjnWygxxi_FsIU2koua97ZpIhiOJVDHA57dXLpvTA,10171
+flask_wtf/file.py,sha256=AsfkYTCgtqGWySimc_NjeAxg-DtpdcthhqMLrXIDAhU,4706
+flask_wtf/form.py,sha256=TmR7xCrxin2LHp6thn7fq1OeU8aLB7xsZzvv52nH7Ss,4049
+flask_wtf/i18n.py,sha256=TyO8gqt9DocHMSaNhj0KKgxoUrPYs-G1nVW-jns0SOw,1166
+flask_wtf/recaptcha/__init__.py,sha256=m4eNGoU3Q0Wnt_wP8VvOlA0mwWuoMtAcK9pYT7sPFp8,106
+flask_wtf/recaptcha/__pycache__/__init__.cpython-311.pyc,,
+flask_wtf/recaptcha/__pycache__/fields.cpython-311.pyc,,
+flask_wtf/recaptcha/__pycache__/validators.cpython-311.pyc,,
+flask_wtf/recaptcha/__pycache__/widgets.cpython-311.pyc,,
+flask_wtf/recaptcha/fields.py,sha256=M1-RFuUKOsJAzsLm3xaaxuhX2bB9oRqS-HVSN-NpkmI,433
+flask_wtf/recaptcha/validators.py,sha256=3sd1mUQT3Y3D_WJeKwecxUGstnhh_QD-A_dEBJfkf6s,2434
+flask_wtf/recaptcha/widgets.py,sha256=J_XyxAZt3uB15diIMnkXXGII2dmsWCsVsKV3KQYn4Ns,1512
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/REQUESTED b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/WHEEL b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..ba1a8af28bcccdacebb8c22dfda1537447a1a58a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf-1.2.1.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.18.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/__init__.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..be2649e26d8dfa2cde5457f13b72715135d12b5a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/__init__.py
@@ -0,0 +1,8 @@
+from .csrf import CSRFProtect
+from .form import FlaskForm
+from .form import Form
+from .recaptcha import Recaptcha
+from .recaptcha import RecaptchaField
+from .recaptcha import RecaptchaWidget
+
+__version__ = "1.2.1"
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/_compat.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..50973e063bbdbd6982fc9501221603efbc2e88f9
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/_compat.py
@@ -0,0 +1,11 @@
+import warnings
+
+
+class FlaskWTFDeprecationWarning(DeprecationWarning):
+ pass
+
+
+warnings.simplefilter("always", FlaskWTFDeprecationWarning)
+warnings.filterwarnings(
+ "ignore", category=FlaskWTFDeprecationWarning, module="wtforms|flask_wtf"
+)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/csrf.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/csrf.py
new file mode 100644
index 0000000000000000000000000000000000000000..06afa0cd4ef3670ca3357d47bbecc2baa7e18fe0
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/csrf.py
@@ -0,0 +1,329 @@
+import hashlib
+import hmac
+import logging
+import os
+from urllib.parse import urlparse
+
+from flask import Blueprint
+from flask import current_app
+from flask import g
+from flask import request
+from flask import session
+from itsdangerous import BadData
+from itsdangerous import SignatureExpired
+from itsdangerous import URLSafeTimedSerializer
+from werkzeug.exceptions import BadRequest
+from wtforms import ValidationError
+from wtforms.csrf.core import CSRF
+
+__all__ = ("generate_csrf", "validate_csrf", "CSRFProtect")
+logger = logging.getLogger(__name__)
+
+
+def generate_csrf(secret_key=None, token_key=None):
+ """Generate a CSRF token. The token is cached for a request, so multiple
+ calls to this function will generate the same token.
+
+ During testing, it might be useful to access the signed token in
+ ``g.csrf_token`` and the raw token in ``session['csrf_token']``.
+
+ :param secret_key: Used to securely sign the token. Default is
+ ``WTF_CSRF_SECRET_KEY`` or ``SECRET_KEY``.
+ :param token_key: Key where token is stored in session for comparison.
+ Default is ``WTF_CSRF_FIELD_NAME`` or ``'csrf_token'``.
+ """
+
+ secret_key = _get_config(
+ secret_key,
+ "WTF_CSRF_SECRET_KEY",
+ current_app.secret_key,
+ message="A secret key is required to use CSRF.",
+ )
+ field_name = _get_config(
+ token_key,
+ "WTF_CSRF_FIELD_NAME",
+ "csrf_token",
+ message="A field name is required to use CSRF.",
+ )
+
+ if field_name not in g:
+ s = URLSafeTimedSerializer(secret_key, salt="wtf-csrf-token")
+
+ if field_name not in session:
+ session[field_name] = hashlib.sha1(os.urandom(64)).hexdigest()
+
+ try:
+ token = s.dumps(session[field_name])
+ except TypeError:
+ session[field_name] = hashlib.sha1(os.urandom(64)).hexdigest()
+ token = s.dumps(session[field_name])
+
+ setattr(g, field_name, token)
+
+ return g.get(field_name)
+
+
+def validate_csrf(data, secret_key=None, time_limit=None, token_key=None):
+ """Check if the given data is a valid CSRF token. This compares the given
+ signed token to the one stored in the session.
+
+ :param data: The signed CSRF token to be checked.
+ :param secret_key: Used to securely sign the token. Default is
+ ``WTF_CSRF_SECRET_KEY`` or ``SECRET_KEY``.
+ :param time_limit: Number of seconds that the token is valid. Default is
+ ``WTF_CSRF_TIME_LIMIT`` or 3600 seconds (60 minutes).
+ :param token_key: Key where token is stored in session for comparison.
+ Default is ``WTF_CSRF_FIELD_NAME`` or ``'csrf_token'``.
+
+ :raises ValidationError: Contains the reason that validation failed.
+
+ .. versionchanged:: 0.14
+ Raises ``ValidationError`` with a specific error message rather than
+ returning ``True`` or ``False``.
+ """
+
+ secret_key = _get_config(
+ secret_key,
+ "WTF_CSRF_SECRET_KEY",
+ current_app.secret_key,
+ message="A secret key is required to use CSRF.",
+ )
+ field_name = _get_config(
+ token_key,
+ "WTF_CSRF_FIELD_NAME",
+ "csrf_token",
+ message="A field name is required to use CSRF.",
+ )
+ time_limit = _get_config(time_limit, "WTF_CSRF_TIME_LIMIT", 3600, required=False)
+
+ if not data:
+ raise ValidationError("The CSRF token is missing.")
+
+ if field_name not in session:
+ raise ValidationError("The CSRF session token is missing.")
+
+ s = URLSafeTimedSerializer(secret_key, salt="wtf-csrf-token")
+
+ try:
+ token = s.loads(data, max_age=time_limit)
+ except SignatureExpired as e:
+ raise ValidationError("The CSRF token has expired.") from e
+ except BadData as e:
+ raise ValidationError("The CSRF token is invalid.") from e
+
+ if not hmac.compare_digest(session[field_name], token):
+ raise ValidationError("The CSRF tokens do not match.")
+
+
+def _get_config(
+ value, config_name, default=None, required=True, message="CSRF is not configured."
+):
+ """Find config value based on provided value, Flask config, and default
+ value.
+
+ :param value: already provided config value
+ :param config_name: Flask ``config`` key
+ :param default: default value if not provided or configured
+ :param required: whether the value must not be ``None``
+ :param message: error message if required config is not found
+ :raises KeyError: if required config is not found
+ """
+
+ if value is None:
+ value = current_app.config.get(config_name, default)
+
+ if required and value is None:
+ raise RuntimeError(message)
+
+ return value
+
+
+class _FlaskFormCSRF(CSRF):
+ def setup_form(self, form):
+ self.meta = form.meta
+ return super().setup_form(form)
+
+ def generate_csrf_token(self, csrf_token_field):
+ return generate_csrf(
+ secret_key=self.meta.csrf_secret, token_key=self.meta.csrf_field_name
+ )
+
+ def validate_csrf_token(self, form, field):
+ if g.get("csrf_valid", False):
+ # already validated by CSRFProtect
+ return
+
+ try:
+ validate_csrf(
+ field.data,
+ self.meta.csrf_secret,
+ self.meta.csrf_time_limit,
+ self.meta.csrf_field_name,
+ )
+ except ValidationError as e:
+ logger.info(e.args[0])
+ raise
+
+
+class CSRFProtect:
+ """Enable CSRF protection globally for a Flask app.
+
+ ::
+
+ app = Flask(__name__)
+ csrf = CSRFProtect(app)
+
+ Checks the ``csrf_token`` field sent with forms, or the ``X-CSRFToken``
+ header sent with JavaScript requests. Render the token in templates using
+ ``{{ csrf_token() }}``.
+
+ See the :ref:`csrf` documentation.
+ """
+
+ def __init__(self, app=None):
+ self._exempt_views = set()
+ self._exempt_blueprints = set()
+
+ if app:
+ self.init_app(app)
+
+ def init_app(self, app):
+ app.extensions["csrf"] = self
+
+ app.config.setdefault("WTF_CSRF_ENABLED", True)
+ app.config.setdefault("WTF_CSRF_CHECK_DEFAULT", True)
+ app.config["WTF_CSRF_METHODS"] = set(
+ app.config.get("WTF_CSRF_METHODS", ["POST", "PUT", "PATCH", "DELETE"])
+ )
+ app.config.setdefault("WTF_CSRF_FIELD_NAME", "csrf_token")
+ app.config.setdefault("WTF_CSRF_HEADERS", ["X-CSRFToken", "X-CSRF-Token"])
+ app.config.setdefault("WTF_CSRF_TIME_LIMIT", 3600)
+ app.config.setdefault("WTF_CSRF_SSL_STRICT", True)
+
+ app.jinja_env.globals["csrf_token"] = generate_csrf
+ app.context_processor(lambda: {"csrf_token": generate_csrf})
+
+ @app.before_request
+ def csrf_protect():
+ if not app.config["WTF_CSRF_ENABLED"]:
+ return
+
+ if not app.config["WTF_CSRF_CHECK_DEFAULT"]:
+ return
+
+ if request.method not in app.config["WTF_CSRF_METHODS"]:
+ return
+
+ if not request.endpoint:
+ return
+
+ if app.blueprints.get(request.blueprint) in self._exempt_blueprints:
+ return
+
+ view = app.view_functions.get(request.endpoint)
+ dest = f"{view.__module__}.{view.__name__}"
+
+ if dest in self._exempt_views:
+ return
+
+ self.protect()
+
+ def _get_csrf_token(self):
+ # find the token in the form data
+ field_name = current_app.config["WTF_CSRF_FIELD_NAME"]
+ base_token = request.form.get(field_name)
+
+ if base_token:
+ return base_token
+
+ # if the form has a prefix, the name will be {prefix}-csrf_token
+ for key in request.form:
+ if key.endswith(field_name):
+ csrf_token = request.form[key]
+
+ if csrf_token:
+ return csrf_token
+
+ # find the token in the headers
+ for header_name in current_app.config["WTF_CSRF_HEADERS"]:
+ csrf_token = request.headers.get(header_name)
+
+ if csrf_token:
+ return csrf_token
+
+ return None
+
+ def protect(self):
+ if request.method not in current_app.config["WTF_CSRF_METHODS"]:
+ return
+
+ try:
+ validate_csrf(self._get_csrf_token())
+ except ValidationError as e:
+ logger.info(e.args[0])
+ self._error_response(e.args[0])
+
+ if request.is_secure and current_app.config["WTF_CSRF_SSL_STRICT"]:
+ if not request.referrer:
+ self._error_response("The referrer header is missing.")
+
+ good_referrer = f"https://{request.host}/"
+
+ if not same_origin(request.referrer, good_referrer):
+ self._error_response("The referrer does not match the host.")
+
+ g.csrf_valid = True # mark this request as CSRF valid
+
+ def exempt(self, view):
+ """Mark a view or blueprint to be excluded from CSRF protection.
+
+ ::
+
+ @app.route('/some-view', methods=['POST'])
+ @csrf.exempt
+ def some_view():
+ ...
+
+ ::
+
+ bp = Blueprint(...)
+ csrf.exempt(bp)
+
+ """
+
+ if isinstance(view, Blueprint):
+ self._exempt_blueprints.add(view)
+ return view
+
+ if isinstance(view, str):
+ view_location = view
+ else:
+ view_location = ".".join((view.__module__, view.__name__))
+
+ self._exempt_views.add(view_location)
+ return view
+
+ def _error_response(self, reason):
+ raise CSRFError(reason)
+
+
+class CSRFError(BadRequest):
+ """Raise if the client sends invalid CSRF data with the request.
+
+ Generates a 400 Bad Request response with the failure reason by default.
+ Customize the response by registering a handler with
+ :meth:`flask.Flask.errorhandler`.
+ """
+
+ description = "CSRF validation failed."
+
+
+def same_origin(current_uri, compare_uri):
+ current = urlparse(current_uri)
+ compare = urlparse(compare_uri)
+
+ return (
+ current.scheme == compare.scheme
+ and current.hostname == compare.hostname
+ and current.port == compare.port
+ )
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/file.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/file.py
new file mode 100644
index 0000000000000000000000000000000000000000..a720dff8d81911df179e80512caa0056a47be410
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/file.py
@@ -0,0 +1,147 @@
+from collections import abc
+
+from werkzeug.datastructures import FileStorage
+from wtforms import FileField as _FileField
+from wtforms import MultipleFileField as _MultipleFileField
+from wtforms.validators import DataRequired
+from wtforms.validators import StopValidation
+from wtforms.validators import ValidationError
+
+
+class FileField(_FileField):
+ """Werkzeug-aware subclass of :class:`wtforms.fields.FileField`."""
+
+ def process_formdata(self, valuelist):
+ valuelist = (x for x in valuelist if isinstance(x, FileStorage) and x)
+ data = next(valuelist, None)
+
+ if data is not None:
+ self.data = data
+ else:
+ self.raw_data = ()
+
+
+class MultipleFileField(_MultipleFileField):
+ """Werkzeug-aware subclass of :class:`wtforms.fields.MultipleFileField`.
+
+ .. versionadded:: 1.2.0
+ """
+
+ def process_formdata(self, valuelist):
+ valuelist = (x for x in valuelist if isinstance(x, FileStorage) and x)
+ data = list(valuelist) or None
+
+ if data is not None:
+ self.data = data
+ else:
+ self.raw_data = ()
+
+
+class FileRequired(DataRequired):
+ """Validates that the uploaded files(s) is a Werkzeug
+ :class:`~werkzeug.datastructures.FileStorage` object.
+
+ :param message: error message
+
+ You can also use the synonym ``file_required``.
+ """
+
+ def __call__(self, form, field):
+ field_data = [field.data] if not isinstance(field.data, list) else field.data
+ if not (
+ all(isinstance(x, FileStorage) and x for x in field_data) and field_data
+ ):
+ raise StopValidation(
+ self.message or field.gettext("This field is required.")
+ )
+
+
+file_required = FileRequired
+
+
+class FileAllowed:
+ """Validates that the uploaded file(s) is allowed by a given list of
+ extensions or a Flask-Uploads :class:`~flaskext.uploads.UploadSet`.
+
+ :param upload_set: A list of extensions or an
+ :class:`~flaskext.uploads.UploadSet`
+ :param message: error message
+
+ You can also use the synonym ``file_allowed``.
+ """
+
+ def __init__(self, upload_set, message=None):
+ self.upload_set = upload_set
+ self.message = message
+
+ def __call__(self, form, field):
+ field_data = [field.data] if not isinstance(field.data, list) else field.data
+ if not (
+ all(isinstance(x, FileStorage) and x for x in field_data) and field_data
+ ):
+ return
+
+ filenames = [f.filename.lower() for f in field_data]
+
+ for filename in filenames:
+ if isinstance(self.upload_set, abc.Iterable):
+ if any(filename.endswith("." + x) for x in self.upload_set):
+ continue
+
+ raise StopValidation(
+ self.message
+ or field.gettext(
+ "File does not have an approved extension: {extensions}"
+ ).format(extensions=", ".join(self.upload_set))
+ )
+
+ if not self.upload_set.file_allowed(field_data, filename):
+ raise StopValidation(
+ self.message
+ or field.gettext("File does not have an approved extension.")
+ )
+
+
+file_allowed = FileAllowed
+
+
+class FileSize:
+ """Validates that the uploaded file(s) is within a minimum and maximum
+ file size (set in bytes).
+
+ :param min_size: minimum allowed file size (in bytes). Defaults to 0 bytes.
+ :param max_size: maximum allowed file size (in bytes).
+ :param message: error message
+
+ You can also use the synonym ``file_size``.
+ """
+
+ def __init__(self, max_size, min_size=0, message=None):
+ self.min_size = min_size
+ self.max_size = max_size
+ self.message = message
+
+ def __call__(self, form, field):
+ field_data = [field.data] if not isinstance(field.data, list) else field.data
+ if not (
+ all(isinstance(x, FileStorage) and x for x in field_data) and field_data
+ ):
+ return
+
+ for f in field_data:
+ file_size = len(f.read())
+ f.seek(0) # reset cursor position to beginning of file
+
+ if (file_size < self.min_size) or (file_size > self.max_size):
+ # the file is too small or too big => validation failure
+ raise ValidationError(
+ self.message
+ or field.gettext(
+ "File must be between {min_size} and {max_size} bytes.".format(
+ min_size=self.min_size, max_size=self.max_size
+ )
+ )
+ )
+
+
+file_size = FileSize
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/form.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/form.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7f52e022c82fe43d6674377e5df040c82d10d79
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/form.py
@@ -0,0 +1,127 @@
+from flask import current_app
+from flask import request
+from flask import session
+from markupsafe import Markup
+from werkzeug.datastructures import CombinedMultiDict
+from werkzeug.datastructures import ImmutableMultiDict
+from werkzeug.utils import cached_property
+from wtforms import Form
+from wtforms.meta import DefaultMeta
+from wtforms.widgets import HiddenInput
+
+from .csrf import _FlaskFormCSRF
+
+try:
+ from .i18n import translations
+except ImportError:
+ translations = None # babel not installed
+
+
+SUBMIT_METHODS = {"POST", "PUT", "PATCH", "DELETE"}
+_Auto = object()
+
+
+class FlaskForm(Form):
+ """Flask-specific subclass of WTForms :class:`~wtforms.form.Form`.
+
+ If ``formdata`` is not specified, this will use :attr:`flask.request.form`
+ and :attr:`flask.request.files`. Explicitly pass ``formdata=None`` to
+ prevent this.
+ """
+
+ class Meta(DefaultMeta):
+ csrf_class = _FlaskFormCSRF
+ csrf_context = session # not used, provided for custom csrf_class
+
+ @cached_property
+ def csrf(self):
+ return current_app.config.get("WTF_CSRF_ENABLED", True)
+
+ @cached_property
+ def csrf_secret(self):
+ return current_app.config.get("WTF_CSRF_SECRET_KEY", current_app.secret_key)
+
+ @cached_property
+ def csrf_field_name(self):
+ return current_app.config.get("WTF_CSRF_FIELD_NAME", "csrf_token")
+
+ @cached_property
+ def csrf_time_limit(self):
+ return current_app.config.get("WTF_CSRF_TIME_LIMIT", 3600)
+
+ def wrap_formdata(self, form, formdata):
+ if formdata is _Auto:
+ if _is_submitted():
+ if request.files:
+ return CombinedMultiDict((request.files, request.form))
+ elif request.form:
+ return request.form
+ elif request.is_json:
+ return ImmutableMultiDict(request.get_json())
+
+ return None
+
+ return formdata
+
+ def get_translations(self, form):
+ if not current_app.config.get("WTF_I18N_ENABLED", True):
+ return super().get_translations(form)
+
+ return translations
+
+ def __init__(self, formdata=_Auto, **kwargs):
+ super().__init__(formdata=formdata, **kwargs)
+
+ def is_submitted(self):
+ """Consider the form submitted if there is an active request and
+ the method is ``POST``, ``PUT``, ``PATCH``, or ``DELETE``.
+ """
+
+ return _is_submitted()
+
+ def validate_on_submit(self, extra_validators=None):
+ """Call :meth:`validate` only if the form is submitted.
+ This is a shortcut for ``form.is_submitted() and form.validate()``.
+ """
+ return self.is_submitted() and self.validate(extra_validators=extra_validators)
+
+ def hidden_tag(self, *fields):
+ """Render the form's hidden fields in one call.
+
+ A field is considered hidden if it uses the
+ :class:`~wtforms.widgets.HiddenInput` widget.
+
+ If ``fields`` are given, only render the given fields that
+ are hidden. If a string is passed, render the field with that
+ name if it exists.
+
+ .. versionchanged:: 0.13
+
+ No longer wraps inputs in hidden div.
+ This is valid HTML 5.
+
+ .. versionchanged:: 0.13
+
+ Skip passed fields that aren't hidden.
+ Skip passed names that don't exist.
+ """
+
+ def hidden_fields(fields):
+ for f in fields:
+ if isinstance(f, str):
+ f = getattr(self, f, None)
+
+ if f is None or not isinstance(f.widget, HiddenInput):
+ continue
+
+ yield f
+
+ return Markup("\n".join(str(f) for f in hidden_fields(fields or self)))
+
+
+def _is_submitted():
+ """Consider the form submitted if there is an active request and
+ the method is ``POST``, ``PUT``, ``PATCH``, or ``DELETE``.
+ """
+
+ return bool(request) and request.method in SUBMIT_METHODS
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/i18n.py b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/i18n.py
new file mode 100644
index 0000000000000000000000000000000000000000..1cc0e9c5a6d2fee8d18c4f46a79ed82f93d132a7
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/flask_wtf/i18n.py
@@ -0,0 +1,47 @@
+from babel import support
+from flask import current_app
+from flask import request
+from flask_babel import get_locale
+from wtforms.i18n import messages_path
+
+__all__ = ("Translations", "translations")
+
+
+def _get_translations():
+ """Returns the correct gettext translations.
+ Copy from flask-babel with some modifications.
+ """
+
+ if not request:
+ return None
+
+ # babel should be in extensions for get_locale
+ if "babel" not in current_app.extensions:
+ return None
+
+ translations = getattr(request, "wtforms_translations", None)
+
+ if translations is None:
+ translations = support.Translations.load(
+ messages_path(), [get_locale()], domain="wtforms"
+ )
+ request.wtforms_translations = translations
+
+ return translations
+
+
+class Translations:
+ def gettext(self, string):
+ t = _get_translations()
+ return string if t is None else t.ugettext(string)
+
+ def ngettext(self, singular, plural, n):
+ t = _get_translations()
+
+ if t is None:
+ return singular if n == 1 else plural
+
+ return t.ungettext(singular, plural, n)
+
+
+translations = Translations()
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/INSTALLER b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/LICENSE b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..d645695673349e3947e8e5ae42332d0ac3164cd7
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ 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.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/METADATA b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..c36ce2da1890bdc93b449a0d985a0f917e4dabed
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/METADATA
@@ -0,0 +1,70 @@
+Metadata-Version: 2.1
+Name: google-api-core
+Version: 2.19.0
+Summary: Google API client core library
+Home-page: https://github.com/googleapis/python-api-core
+Author: Google LLC
+Author-email: googleapis-packages@google.com
+License: Apache 2.0
+Platform: Posix; MacOS X; Windows
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: googleapis-common-protos <2.0.dev0,>=1.56.2
+Requires-Dist: protobuf !=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0.dev0,>=3.19.5
+Requires-Dist: proto-plus <2.0.0dev,>=1.22.3
+Requires-Dist: google-auth <3.0.dev0,>=2.14.1
+Requires-Dist: requests <3.0.0.dev0,>=2.18.0
+Provides-Extra: grpc
+Requires-Dist: grpcio <2.0dev,>=1.33.2 ; extra == 'grpc'
+Requires-Dist: grpcio-status <2.0.dev0,>=1.33.2 ; extra == 'grpc'
+Requires-Dist: grpcio <2.0dev,>=1.49.1 ; (python_version >= "3.11") and extra == 'grpc'
+Requires-Dist: grpcio-status <2.0.dev0,>=1.49.1 ; (python_version >= "3.11") and extra == 'grpc'
+Provides-Extra: grpcgcp
+Requires-Dist: grpcio-gcp <1.0.dev0,>=0.2.2 ; extra == 'grpcgcp'
+Provides-Extra: grpcio-gcp
+Requires-Dist: grpcio-gcp <1.0.dev0,>=0.2.2 ; extra == 'grpcio-gcp'
+
+Core Library for Google Client Libraries
+========================================
+
+|pypi| |versions|
+
+This library is not meant to stand-alone. Instead it defines
+common helpers used by all Google API clients. For more information, see the
+`documentation`_.
+
+.. |pypi| image:: https://img.shields.io/pypi/v/google-api_core.svg
+ :target: https://pypi.org/project/google-api_core/
+.. |versions| image:: https://img.shields.io/pypi/pyversions/google-api_core.svg
+ :target: https://pypi.org/project/google-api_core/
+.. _documentation: https://googleapis.dev/python/google-api-core/latest
+
+
+Supported Python Versions
+-------------------------
+Python >= 3.7
+
+
+Unsupported Python Versions
+---------------------------
+
+Python == 2.7, Python == 3.5, Python == 3.6.
+
+The last version of this library compatible with Python 2.7 and 3.5 is
+`google-api-core==1.31.1`.
+
+The last version of this library compatible with Python 3.6 is
+`google-api-core==2.8.2`.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/RECORD b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..7e99b41596cf7b4a39e0b567e1ea81cfa11663c0
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/RECORD
@@ -0,0 +1,109 @@
+google/api_core/__init__.py,sha256=bCgLRZtOkaVlSxTPG_o1x4V0w5FJAWREIlnq3kCfqeY,782
+google/api_core/__pycache__/__init__.cpython-311.pyc,,
+google/api_core/__pycache__/bidi.cpython-311.pyc,,
+google/api_core/__pycache__/client_info.cpython-311.pyc,,
+google/api_core/__pycache__/client_options.cpython-311.pyc,,
+google/api_core/__pycache__/datetime_helpers.cpython-311.pyc,,
+google/api_core/__pycache__/exceptions.cpython-311.pyc,,
+google/api_core/__pycache__/extended_operation.cpython-311.pyc,,
+google/api_core/__pycache__/general_helpers.cpython-311.pyc,,
+google/api_core/__pycache__/grpc_helpers.cpython-311.pyc,,
+google/api_core/__pycache__/grpc_helpers_async.cpython-311.pyc,,
+google/api_core/__pycache__/iam.cpython-311.pyc,,
+google/api_core/__pycache__/operation.cpython-311.pyc,,
+google/api_core/__pycache__/operation_async.cpython-311.pyc,,
+google/api_core/__pycache__/page_iterator.cpython-311.pyc,,
+google/api_core/__pycache__/page_iterator_async.cpython-311.pyc,,
+google/api_core/__pycache__/path_template.cpython-311.pyc,,
+google/api_core/__pycache__/protobuf_helpers.cpython-311.pyc,,
+google/api_core/__pycache__/rest_helpers.cpython-311.pyc,,
+google/api_core/__pycache__/rest_streaming.cpython-311.pyc,,
+google/api_core/__pycache__/retry_async.cpython-311.pyc,,
+google/api_core/__pycache__/timeout.cpython-311.pyc,,
+google/api_core/__pycache__/universe.cpython-311.pyc,,
+google/api_core/__pycache__/version.cpython-311.pyc,,
+google/api_core/__pycache__/version_header.cpython-311.pyc,,
+google/api_core/bidi.py,sha256=wpC9Lthrh62Jxp9WzRas1W78UiHO5OPuHEvx3SHcvgg,27940
+google/api_core/client_info.py,sha256=MQse7unHD1nxqvEQPEMZyr4BH8oRHb9p2DE5dPXfKY0,3744
+google/api_core/client_options.py,sha256=g6PmyvmDOpnOHdQi7ZUjf1Pxq4ikUchvZrd31jYf2x4,5449
+google/api_core/datetime_helpers.py,sha256=5gFi7n0r-xVImQdj6rQKNwk58m2LcMF9WliXGHbBsDA,9034
+google/api_core/exceptions.py,sha256=9OPxGWIA9dsU4Ba2lkQ16sOmvja7Y_sCxt7Tlagr0k0,19326
+google/api_core/extended_operation.py,sha256=r9xSOblNF35lwn2hrrjUQ-f3JDoo0a4Z8xwOy_VkvL0,8632
+google/api_core/future/__init__.py,sha256=7sToxNNu9c_xqcpmO8dbrcSLOOxplnYOOSXjOX9QIXw,702
+google/api_core/future/__pycache__/__init__.cpython-311.pyc,,
+google/api_core/future/__pycache__/_helpers.cpython-311.pyc,,
+google/api_core/future/__pycache__/async_future.cpython-311.pyc,,
+google/api_core/future/__pycache__/base.cpython-311.pyc,,
+google/api_core/future/__pycache__/polling.cpython-311.pyc,,
+google/api_core/future/_helpers.py,sha256=jA6m2L1aqlOJA-9NdC1BDosPksZQ7FmLLYWDOrsQOPc,1248
+google/api_core/future/async_future.py,sha256=7rOK0tzud8MCoUwO9AjF-3OQDtELwhtp2ONltSB3GEI,5355
+google/api_core/future/base.py,sha256=SHyudamSWR7EyUsYaQ-XrGGkLeYClSfXfsHIHSqDIYI,1763
+google/api_core/future/polling.py,sha256=0HUw1bp7ZLgEqMtwsvxIXNMHQbHgsP6TpmpVrMbjJ2I,14349
+google/api_core/gapic_v1/__init__.py,sha256=r6kCwKznSXPTYRdz4C384fscefaw_rXP2bzJdnzEVnw,988
+google/api_core/gapic_v1/__pycache__/__init__.cpython-311.pyc,,
+google/api_core/gapic_v1/__pycache__/client_info.cpython-311.pyc,,
+google/api_core/gapic_v1/__pycache__/config.cpython-311.pyc,,
+google/api_core/gapic_v1/__pycache__/config_async.cpython-311.pyc,,
+google/api_core/gapic_v1/__pycache__/method.cpython-311.pyc,,
+google/api_core/gapic_v1/__pycache__/method_async.cpython-311.pyc,,
+google/api_core/gapic_v1/__pycache__/routing_header.cpython-311.pyc,,
+google/api_core/gapic_v1/client_info.py,sha256=98rwKt-s_jk7ez0KUKEJoARR1RWHClP6NLOAAGon7M4,2215
+google/api_core/gapic_v1/config.py,sha256=5isOOYPSZCXpDcJDJiwmTxGTUo0RjxJJvW2yjqBR4BI,6300
+google/api_core/gapic_v1/config_async.py,sha256=_jrB5Yv6rxxSU6KwzOxWQ-G_x5mXilpSFAgnQ_6ktrU,1728
+google/api_core/gapic_v1/method.py,sha256=SnMqRoKKCRph9xpnQvQ29SGjCd9WVpHEPK60X-uPyWM,9494
+google/api_core/gapic_v1/method_async.py,sha256=f307YYgYYvjQBF5So9S1rP8E7DubCbmhJw5EbkHwMA4,1952
+google/api_core/gapic_v1/routing_header.py,sha256=kJKOYpNS2mgSZa4Qt8Ib2Q5ONfNwpJwbNloVJ8e2wMs,3093
+google/api_core/general_helpers.py,sha256=ZrYwDg7VTgtaQlFk_fCeFTKYZD62JMQdZRhbQhbQL_c,681
+google/api_core/grpc_helpers.py,sha256=r262_0OWGqkECOlydA2dp40KG9Qqhnw72qJ7Pj9hpUU,23291
+google/api_core/grpc_helpers_async.py,sha256=1ewS441H6o0tvgdgfanL8y9STOseV3evnvstk7kDy-4,12344
+google/api_core/iam.py,sha256=BGz63HtOP5_5oH9Zs93RP0Y6Qshty2eOhFEYj_CoE64,13213
+google/api_core/operation.py,sha256=mHWay2vrNbEliv5YWFzyXBywbQdy_VPW98BALh514PA,13198
+google/api_core/operation_async.py,sha256=XdunwVY6aKA-K0OK-5_dYbqjbvF1DLTYUUL4IOztld4,8046
+google/api_core/operations_v1/__init__.py,sha256=lC3JHtOPlhKWHIPXOEqJH2QrJmMjC3vWQjMuuA5VxfQ,1126
+google/api_core/operations_v1/__pycache__/__init__.cpython-311.pyc,,
+google/api_core/operations_v1/__pycache__/abstract_operations_client.cpython-311.pyc,,
+google/api_core/operations_v1/__pycache__/operations_async_client.cpython-311.pyc,,
+google/api_core/operations_v1/__pycache__/operations_client.cpython-311.pyc,,
+google/api_core/operations_v1/__pycache__/operations_client_config.cpython-311.pyc,,
+google/api_core/operations_v1/__pycache__/pagers.cpython-311.pyc,,
+google/api_core/operations_v1/abstract_operations_client.py,sha256=SWIgFbnAQhcLkUCV1hPAPXAzP4CvbICe5sLDpxXak_s,24551
+google/api_core/operations_v1/operations_async_client.py,sha256=1BENex2y2ovlCHlXR4v5Cfiqk2o36DBWEzPyCCCudbU,14794
+google/api_core/operations_v1/operations_client.py,sha256=-fmbRv_2L_5cJv70WfybRw9EUyLlHB-wTbC-n0Iq4Fg,15274
+google/api_core/operations_v1/operations_client_config.py,sha256=v7B0FiVc5p9HhnpPY1_3FIomFdA-J-4lilomeoC9SkQ,2285
+google/api_core/operations_v1/pagers.py,sha256=BxwldJRuw3HRRjUzCdGI5OUjL7Z-p0iRPKXkjrh7V5A,3143
+google/api_core/operations_v1/transports/__init__.py,sha256=bIzQO8Dy86kAz1OZYu2qDOvdto6vkHcLXiUrGEHot6g,918
+google/api_core/operations_v1/transports/__pycache__/__init__.cpython-311.pyc,,
+google/api_core/operations_v1/transports/__pycache__/base.cpython-311.pyc,,
+google/api_core/operations_v1/transports/__pycache__/rest.cpython-311.pyc,,
+google/api_core/operations_v1/transports/base.py,sha256=0JbrFJCRiAK0333p937vkUJB5J61jN6Q8A04Vrty2Ws,8594
+google/api_core/operations_v1/transports/rest.py,sha256=1Ce15zqU3dKRvRVEw84bpjcMiFEW3bW-G_fCTcN6AAY,19584
+google/api_core/page_iterator.py,sha256=FXMfqbhlVYAEVjpojytYAiUluVNYAVSC41MdfAhHAX4,20330
+google/api_core/page_iterator_async.py,sha256=TbuXorRhP1wcQTD3raBJhWgSJP1JwJO_nCKJphCbVdw,10294
+google/api_core/path_template.py,sha256=Lyqqw8OECuw5O7y9x1BJvfNbYEbmx4lnTGqc6opSyHk,11685
+google/api_core/protobuf_helpers.py,sha256=uGl-E4EuDgw5ahHCZ_UiadxOLz5xGBcLMU_ECvdq5f4,12430
+google/api_core/py.typed,sha256=q8dgH9l1moUXiufHBVjqI0MuJy4Be9a3rNH8Zl_sICA,78
+google/api_core/rest_helpers.py,sha256=2DsInZiHv0sLd9dfLIbEL2vDJQIybWgxlkxnNFahPnI,3529
+google/api_core/rest_streaming.py,sha256=E-5Dyk2Yg0Hk4zpPPpbjJNx0b1Nh7YYIGOJxQL3k_WI,4890
+google/api_core/retry/__init__.py,sha256=WhgtLBQO2oK-AehH_AHbGbfWo1IdG5ahUGrs3aFGw0o,2088
+google/api_core/retry/__pycache__/__init__.cpython-311.pyc,,
+google/api_core/retry/__pycache__/retry_base.cpython-311.pyc,,
+google/api_core/retry/__pycache__/retry_streaming.cpython-311.pyc,,
+google/api_core/retry/__pycache__/retry_streaming_async.cpython-311.pyc,,
+google/api_core/retry/__pycache__/retry_unary.cpython-311.pyc,,
+google/api_core/retry/__pycache__/retry_unary_async.cpython-311.pyc,,
+google/api_core/retry/retry_base.py,sha256=WJtEMphRNm1c3ldnuTjCzVu3Xzm-NwjmZhnULpHGVBM,12433
+google/api_core/retry/retry_streaming.py,sha256=kt5ucutVWGYzIsBugqag2DKBwucBmRtkKUvvlKHQ5ew,10860
+google/api_core/retry/retry_streaming_async.py,sha256=7liXfL9o9X9BvDxwFoHdgcClQJq8A9l_Ir5Z_gN4ZvA,14343
+google/api_core/retry/retry_unary.py,sha256=k_0PGsmFwRe4EPUMRHfzrZatDTFwEp9ucPRZDtKKGm4,13338
+google/api_core/retry/retry_unary_async.py,sha256=9mQgLnDqRNBb0enszfE7suqy-5R_C0PQlV3y-s2q_Hw,9415
+google/api_core/retry_async.py,sha256=_r0ROYeQqdATtRMx-q_6o4bPmqFzPyjr_oV3lfloDSM,1514
+google/api_core/timeout.py,sha256=LnElJPn1XJuU8dNZl0YKxw8wqQbGGV94t5K1NiXOGk0,9685
+google/api_core/universe.py,sha256=k_K5J0I3kKQiM2yEHvxeqAWxXEQZKJ2SfDlMAH-rQ08,2952
+google/api_core/version.py,sha256=z21NSbk7z3Fn2m4V3DAA0fztKH8Xm9MBMS2MEV-vUJg,598
+google/api_core/version_header.py,sha256=uEFXosCp8UH7XhznG5GQseTYtWNoJHXRPA557DWsUxA,1046
+google_api_core-2.19.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+google_api_core-2.19.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+google_api_core-2.19.0.dist-info/METADATA,sha256=rBjRdKragnKQz66qILCu6IBxNAAgKuU9UIZzRfSeujg,2729
+google_api_core-2.19.0.dist-info/RECORD,,
+google_api_core-2.19.0.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+google_api_core-2.19.0.dist-info/top_level.txt,sha256=_1QvSJIhFAGfxb79D6DhB7SUw2X6T4rwnz_LLrbcD3c,7
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/WHEEL b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..ba48cbcf9275ac6d88fe25821695e14d0a822e79
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.3)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/top_level.txt b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cb429113e0f9a73019fd799e8052093fea7f0c8b
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_core-2.19.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+google
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/INSTALLER b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/LICENSE b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ 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.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/METADATA b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..b8d798dfcc0b5a2e83de52c7d5aaa9a0bb28766e
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/METADATA
@@ -0,0 +1,150 @@
+Metadata-Version: 2.1
+Name: google-api-python-client
+Version: 2.127.0
+Summary: Google API Client Library for Python
+Home-page: https://github.com/googleapis/google-api-python-client/
+Author: Google LLC
+Author-email: googleapis-packages@google.com
+License: Apache 2.0
+Keywords: google api client
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httplib2 <1.dev0,>=0.19.0
+Requires-Dist: google-auth !=2.24.0,!=2.25.0,<3.0.0.dev0,>=1.32.0
+Requires-Dist: google-auth-httplib2 <1.0.0,>=0.2.0
+Requires-Dist: google-api-core !=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0,<3.0.0.dev0,>=1.31.5
+Requires-Dist: uritemplate <5,>=3.0.1
+
+# Google API Client
+
+[](https://badge.fury.io/py/google-api-python-client)
+
+This is the [Google API Python client library](https://cloud.google.com/apis/docs/client-libraries-explained#google_api_client_libraries)
+for Google's discovery based APIs. To get started, please see the
+[docs folder](https://github.com/googleapis/google-api-python-client/blob/main/docs/README.md).
+
+This library is considered complete and is in maintenance mode. This means
+that we will address critical bugs and security issues but will not add any
+new features.
+
+This library is officially supported by Google. However, the maintainers of
+this repository recommend using [Cloud Client Libraries for Python](https://github.com/googleapis/google-cloud-python),
+where possible, for new code development. For more information, please visit
+[Client Libraries Explained](https://cloud.google.com/apis/docs/client-libraries-explained).
+
+## Version 2.0 Release
+The 2.0 release of `google-api-python-client` includes a substantial reliability
+improvement, compared with 1.x, as discovery documents are now cached in the library
+rather than fetched dynamically. It is highly recommended to upgrade from v1.x to v2.x.
+
+Only python 3.7 and newer is supported. If you are not able to upgrade python, then
+please continue to use version 1.x as we will continue supporting python 2.7+ in
+[v1](https://github.com/googleapis/google-api-python-client/tree/v1).
+
+Discovery documents will no longer be retrieved dynamically when
+you call `discovery.build()`. The discovery documents will instead be retrieved
+from the client library directly. New versions of this library are released weekly.
+As a result of caching the discovery documents, the size of this package is at least
+50 MB larger compared to the previous version.
+
+Please see the [Migration Guide](https://github.com/googleapis/google-api-python-client/blob/main/UPGRADING.md)
+for more information.
+
+## Documentation
+
+See the [docs folder](https://github.com/googleapis/google-api-python-client/blob/main/docs/README.md) for more detailed instructions and additional documentation.
+
+## Other Google API libraries
+
+The maintainers of this repository recommend using
+[Cloud Client Libraries for Python](https://github.com/googleapis/google-cloud-python),
+where possible, for new code development due to the following reasons:
+
+With [Cloud Client Libraries for Python](https://github.com/googleapis/google-cloud-python):
+- There is a separate client library for each API, so you can choose
+which client libraries to download. Whereas, `google-api-python-client` is a
+single client library for all APIs. As a result, the total package size for
+`google-api-python-client` exceeds 50MB.
+- There are stricter controls for breaking changes to the underlying APIs
+as each client library is focused on a specific API.
+- There are more features in these Cloud Client Libraries as each library is
+focused on a specific API, and in some cases, the libraries are owned by team
+who specialized in that API.
+- Developers will benefit from intellisense.
+
+For more information, please visit
+[Client Libraries Explained](https://cloud.google.com/apis/docs/client-libraries-explained).
+
+Although there are many benefits to moving to
+[Cloud Client Libraries for Python](https://github.com/googleapis/google-cloud-python),
+the maintainers want to emphasize that `google-api-python-client` will continue
+to be supported.
+
+For Google Ads API, we recommend using [Google Ads API Client Library for Python](https://github.com/googleads/google-ads-python/).
+
+For Google Firebase Admin API, we recommend using [Firebase Admin Python SDK](https://github.com/firebase/firebase-admin-python).
+
+## Installation
+
+Install this library in a [virtualenv](https://virtualenv.pypa.io/en/latest/) using pip. virtualenv is a tool to
+create isolated Python environments. The basic problem it addresses is one of
+dependencies and versions, and indirectly permissions.
+
+With virtualenv, it's possible to install this library without needing system
+install permissions, and without clashing with the installed system
+dependencies.
+
+### Mac/Linux
+
+```bash
+pip3 install virtualenv
+virtualenv
+source /bin/activate
+/bin/pip install google-api-python-client
+```
+
+### Windows
+
+```batch
+pip install virtualenv
+virtualenv
+\Scripts\activate
+\Scripts\pip.exe install google-api-python-client
+```
+
+## Supported Python Versions
+
+Python 3.7, 3.8, 3.9, 3.10, 3.11 and 3.12 are fully supported and tested. This library may work on later versions of 3, but we do not currently run tests against those versions.
+
+## Unsupported Python Versions
+
+Python < 3.7
+
+## Third Party Libraries and Dependencies
+
+The following libraries will be installed when you install the client library:
+* [httplib2](https://github.com/httplib2/httplib2)
+* [uritemplate](https://github.com/sigmavirus24/uritemplate)
+
+For development you will also need the following libraries:
+* [WebTest](https://pypi.org/project/WebTest/)
+* [pyopenssl](https://pypi.python.org/pypi/pyOpenSSL)
+
+## Contributing
+
+Please see our [Contribution Guide](https://github.com/googleapis/google-api-python-client/blob/main/CONTRIBUTING.rst).
+In particular, we love pull requests - but please make sure to sign
+the contributor license agreement.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/RECORD b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..810f05ad855967574c29c7487fad89ec816057d0
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/RECORD
@@ -0,0 +1,541 @@
+apiclient/__init__.py,sha256=U1SOZ1GeeF3uCr0fzO5Od-rpe17R12-Ppyq25NTSbow,746
+apiclient/__pycache__/__init__.cpython-311.pyc,,
+google_api_python_client-2.127.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+google_api_python_client-2.127.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+google_api_python_client-2.127.0.dist-info/METADATA,sha256=k98pjmPYf3U8DesbKBRVyJFmgKLcUD5XEQgaVyzk0Y0,6657
+google_api_python_client-2.127.0.dist-info/RECORD,,
+google_api_python_client-2.127.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google_api_python_client-2.127.0.dist-info/WHEEL,sha256=P2T-6epvtXQ2cBOE_U1K4_noqlJFN3tj15djMgEu4NM,110
+google_api_python_client-2.127.0.dist-info/top_level.txt,sha256=lbWgdDwQ3oww0ub0pmZ3fmIYAOTHf18Two4U9CxRlnw,58
+googleapiclient/__init__.py,sha256=kFWxKShJalbnrCuV0klL7mjZaiXfPpjlqmyKyI8yfTU,904
+googleapiclient/__pycache__/__init__.cpython-311.pyc,,
+googleapiclient/__pycache__/_auth.cpython-311.pyc,,
+googleapiclient/__pycache__/_helpers.cpython-311.pyc,,
+googleapiclient/__pycache__/channel.cpython-311.pyc,,
+googleapiclient/__pycache__/discovery.cpython-311.pyc,,
+googleapiclient/__pycache__/errors.cpython-311.pyc,,
+googleapiclient/__pycache__/http.cpython-311.pyc,,
+googleapiclient/__pycache__/mimeparse.cpython-311.pyc,,
+googleapiclient/__pycache__/model.cpython-311.pyc,,
+googleapiclient/__pycache__/sample_tools.cpython-311.pyc,,
+googleapiclient/__pycache__/schema.cpython-311.pyc,,
+googleapiclient/__pycache__/version.cpython-311.pyc,,
+googleapiclient/_auth.py,sha256=QttUwhmp7BmhW5CReaAOVGH6kEtITYmEHhVCVmsnDPs,5736
+googleapiclient/_helpers.py,sha256=iNxILG6iNNFukr7lhaYfVqX4oFM5SERvcsU3JxeOo6I,6723
+googleapiclient/channel.py,sha256=Fc4nxu-RxGkjY_STp9bwJfZaLan6VdX-DNniH-ANSuE,11054
+googleapiclient/discovery.py,sha256=ZhpydEOl7uxfDUDT0lvqIJ4RPZo4XwSGbbkfmppsq5Q,66270
+googleapiclient/discovery_cache/__init__.py,sha256=ww_vl0vhVLuHSEdRTv3-gq6EDG--Ff7rILYHHFifnzc,2315
+googleapiclient/discovery_cache/__pycache__/__init__.cpython-311.pyc,,
+googleapiclient/discovery_cache/__pycache__/appengine_memcache.cpython-311.pyc,,
+googleapiclient/discovery_cache/__pycache__/base.cpython-311.pyc,,
+googleapiclient/discovery_cache/__pycache__/file_cache.cpython-311.pyc,,
+googleapiclient/discovery_cache/appengine_memcache.py,sha256=6T1pQj-toAhDwfgLuiggFGhxKNGw5y-NnLUzLIF_M4s,1657
+googleapiclient/discovery_cache/base.py,sha256=yCDPtxnbNN-p5_9fzBacC6P3wcUPlaCQIy5v_dXTons,1389
+googleapiclient/discovery_cache/documents/abusiveexperiencereport.v1.json,sha256=37nAqJqOzxY4_iMI-HWNmtK73zZL1-wuQzPKINTECK0,5671
+googleapiclient/discovery_cache/documents/acceleratedmobilepageurl.v1.json,sha256=aKlp_nv0fhmeUSTEJpCagaZcoqcAyM_jJu2Cef067b8,6729
+googleapiclient/discovery_cache/documents/accessapproval.v1.json,sha256=Mu4nKIpnJ405BhzRJkD5IrUQjRUeOf6WRVUwjCl5VDU,48620
+googleapiclient/discovery_cache/documents/accesscontextmanager.v1.json,sha256=qdw245LaEM7ch03H4QEbhT06jAMAm_icFd0CXO2D0xg,109313
+googleapiclient/discovery_cache/documents/accesscontextmanager.v1beta.json,sha256=Vsv_nz7ubkkbGwNgxirN2AWgUuYH0mADUx9LFaqKu_c,51062
+googleapiclient/discovery_cache/documents/acmedns.v1.json,sha256=cJhSgNx2l37Dcldu8kjV1e561Wh5Kg03-hBQtmJkvjs,6858
+googleapiclient/discovery_cache/documents/addressvalidation.v1.json,sha256=inMf1GOU81440A7MwV1i31ObAGuL2a9Dx8-CPRwPCrg,46902
+googleapiclient/discovery_cache/documents/adexchangebuyer.v1.2.json,sha256=0-XVzUa3kcqFiCZYk_W0au5mIV5-w3AgBtQJsSnWL9w,20475
+googleapiclient/discovery_cache/documents/adexchangebuyer.v1.3.json,sha256=6lFs8ULCDsQuo8s48oBpFdDCVbwICk6MNaCvDVrhP9Q,59967
+googleapiclient/discovery_cache/documents/adexchangebuyer.v1.4.json,sha256=pgYvRj3gK2vBxH7Dh4YoCqd7TXTzTDPQqVqOlVRxITk,136987
+googleapiclient/discovery_cache/documents/adexchangebuyer2.v2beta1.json,sha256=WU9P2A-nHlHst92YfnFGea7NX84rXmLeJAMyhDp_Ks8,231555
+googleapiclient/discovery_cache/documents/adexperiencereport.v1.json,sha256=yJK89IC1j2hlb5OwfL9lVlXVVZ-4PkUgdMgCGSTWr0Q,6644
+googleapiclient/discovery_cache/documents/admin.datatransfer_v1.json,sha256=xJP25zW9YEBhByOo3jjR_MJPtAiRpuTjr7rqoT5PytA,12021
+googleapiclient/discovery_cache/documents/admin.datatransferv1.json,sha256=xJP25zW9YEBhByOo3jjR_MJPtAiRpuTjr7rqoT5PytA,12021
+googleapiclient/discovery_cache/documents/admin.directory_v1.json,sha256=CUDZDlDXyH3Oh1y8lzn7HBRWSyaSa108mfPSXEP3Rrk,269790
+googleapiclient/discovery_cache/documents/admin.directoryv1.json,sha256=CUDZDlDXyH3Oh1y8lzn7HBRWSyaSa108mfPSXEP3Rrk,269790
+googleapiclient/discovery_cache/documents/admin.reports_v1.json,sha256=Ao55KksPJdx5bp3VoWV8-xBdrcuGHbOM0iM_l8mA5j8,52363
+googleapiclient/discovery_cache/documents/admin.reportsv1.json,sha256=Ao55KksPJdx5bp3VoWV8-xBdrcuGHbOM0iM_l8mA5j8,52363
+googleapiclient/discovery_cache/documents/admob.v1.json,sha256=fiWD9hB0fc-0IM7em4YSIJmGmSvcTeQRLtBwYacNFNI,52164
+googleapiclient/discovery_cache/documents/admob.v1beta.json,sha256=d4OUW1h67nlXIjCR5od2MqnPvvDvBsqI4BKnEJHZ4T4,91957
+googleapiclient/discovery_cache/documents/adsense.v2.json,sha256=e79sVYKV-j8yXiin3R5BDPlZUtP88hNNrm3CBj1mIFE,103207
+googleapiclient/discovery_cache/documents/adsensehost.v4.1.json,sha256=kKGnNG3aFbYwLFOLJkIGph3m7vC2heaob68rlmV4J28,37965
+googleapiclient/discovery_cache/documents/advisorynotifications.v1.json,sha256=ooOQ9RZ5JIBXLtmvVqKccFAewXoeYDZdLGbusMBEFI4,20673
+googleapiclient/discovery_cache/documents/aiplatform.v1.json,sha256=tb7X3S8pVO7oxZ_FPoMOwNmja5DbYlG8Z4G_GyWoNGE,1593466
+googleapiclient/discovery_cache/documents/aiplatform.v1beta1.json,sha256=7iOxFcaZobRP5svQr_qrcXjZI1hASsIG7pLRJMP8t2A,1778693
+googleapiclient/discovery_cache/documents/alertcenter.v1beta1.json,sha256=puLntH3EeSQmgarGFs9yAXdm5mEHaqZ4dFavmhdQquA,67788
+googleapiclient/discovery_cache/documents/alloydb.v1.json,sha256=2fQy75F6v0c0-YOSgSVPnqc_kxsBmsYzDYKXpNBXLlc,162387
+googleapiclient/discovery_cache/documents/alloydb.v1alpha.json,sha256=6PyHnRujioJCyjIDYCn00JNAGPIaSYynlkem_pnYg_U,168582
+googleapiclient/discovery_cache/documents/alloydb.v1beta.json,sha256=i2e2ojZZhyLCepmj7vKJDtEOkwDzHVh9z3FG9OJYZWY,167954
+googleapiclient/discovery_cache/documents/analytics.v3.json,sha256=pq5nLmdNvFR-k8Sre800U3mI2tU6hVZGdQCNX_VJNiE,195428
+googleapiclient/discovery_cache/documents/analyticsadmin.v1alpha.json,sha256=FL4NVD_QngmFLhhDCKay60ZBhnKf86840zyTPU0Svs0,309040
+googleapiclient/discovery_cache/documents/analyticsadmin.v1beta.json,sha256=XFgsv9JLcnN-6adJwNtpMFDe9Fn2eAhVXGlMk09laAU,121971
+googleapiclient/discovery_cache/documents/analyticsdata.v1alpha.json,sha256=3rdVFqqDjQQ7-0qi_UkAYpRthvRKjoXJ8SJzulNHBn0,80445
+googleapiclient/discovery_cache/documents/analyticsdata.v1beta.json,sha256=fsiYl-WqAZ3AGxif3lApNzRP6L-x9wm9yHHdnRofADg,94704
+googleapiclient/discovery_cache/documents/analyticshub.v1.json,sha256=kdQQtYR0BcMLUGiUuI1HWlkHOnWko65a_DriY1d4hI4,73056
+googleapiclient/discovery_cache/documents/analyticshub.v1beta1.json,sha256=FeW-l-MFTQ81nqRGzsHmisUXBvEClfbQgvSUBYTL7KU,54367
+googleapiclient/discovery_cache/documents/analyticsreporting.v4.json,sha256=8S4FyrAstnlesJ3ss4fYM7V18YvJgMh9S9jIo-vAOY8,61333
+googleapiclient/discovery_cache/documents/androiddeviceprovisioning.v1.json,sha256=d39RtQU_pWcgcGCNJSs7Lvuh7Tx54NBiQqDeCv8gtwQ,60784
+googleapiclient/discovery_cache/documents/androidenterprise.v1.json,sha256=v5Fn4N8bFLoFq-GpW3jLPCg2g12k77FuIndHccQt8Wk,155986
+googleapiclient/discovery_cache/documents/androidmanagement.v1.json,sha256=hG8vR9QsviibCSmFiJiXed8WgXxYH0ghsKkCAtU6poM,249963
+googleapiclient/discovery_cache/documents/androidpublisher.v3.json,sha256=LdSSjRybzAShjEnrBT2ojvmjoi9VY419_A87KdXetsw,305315
+googleapiclient/discovery_cache/documents/apigateway.v1.json,sha256=jNuUVorQ78rdXOpMfTSoigmXpKVuvbCyL5MOtVS5RVQ,67378
+googleapiclient/discovery_cache/documents/apigateway.v1beta.json,sha256=iBuGb7LPfIWue4qHxDvYkvmFFyDn3EPQiGSCPh9fLdg,69091
+googleapiclient/discovery_cache/documents/apigee.v1.json,sha256=uF-sp_h9tQ5Nz4eCrhOTTZyHHtZxsFQuPArsp2Towp8,645631
+googleapiclient/discovery_cache/documents/apigeeregistry.v1.json,sha256=hCu1irwJNFHGEQgiTM5HJtqvF1JUeqpBVA8SGUn9syQ,156027
+googleapiclient/discovery_cache/documents/apikeys.v2.json,sha256=mpeOUdNe-p4C9GlXxvUjljaie8AkAiz2cjiEQT3s3hA,22139
+googleapiclient/discovery_cache/documents/appengine.v1.json,sha256=yAKLpK6yNjnqokwbnYHbfy56SO7ta0PzSS8UzyJ7Q0A,148242
+googleapiclient/discovery_cache/documents/appengine.v1alpha.json,sha256=yTrvpjtrLyr2mod0i6QUoXFXVAwTD8ggzgJx9z8_ByA,60154
+googleapiclient/discovery_cache/documents/appengine.v1beta.json,sha256=OASvMjDuew4zrB9M3py4-thZVLbZkCoi7m8JzTfFejA,155573
+googleapiclient/discovery_cache/documents/appengine.v1beta4.json,sha256=yELseCdExWSunuF7afIqEw_94UU7PvKCXDmWkyAbYWg,110912
+googleapiclient/discovery_cache/documents/appengine.v1beta5.json,sha256=OHCPs6izs9jPAEuG8s9dr76KCn3f5lKdfWE5NaQBhZo,110227
+googleapiclient/discovery_cache/documents/apphub.v1.json,sha256=S9J7Llxk8HYyAAbnoD_7Vf0VulZGS41pXJlcy0uf9jY,92413
+googleapiclient/discovery_cache/documents/apphub.v1alpha.json,sha256=NJjn8KzwiMKLU5qSHL2lNZ_tyoufrSbkNNfTp5XcSpY,97031
+googleapiclient/discovery_cache/documents/area120tables.v1alpha1.json,sha256=Q9NhTi0D__lqaZOfqhUyLkM6qQbIFXsmQ0BjqCrLCDI,26671
+googleapiclient/discovery_cache/documents/artifactregistry.v1.json,sha256=xaoepq9AMCG05976GA5S793WRl0j1NcGF2xN0Mm3FlM,117709
+googleapiclient/discovery_cache/documents/artifactregistry.v1beta1.json,sha256=CsZk-EaYTXCbgnoT01o2rVdsU8z32VK0ntbu8ryA4Ww,53976
+googleapiclient/discovery_cache/documents/artifactregistry.v1beta2.json,sha256=WBxBbK355CerVxbm_FCwYfA26f0yekzfqrsJZA2xaL8,72275
+googleapiclient/discovery_cache/documents/assuredworkloads.v1.json,sha256=wpWdeKq-Vfnap3VlNm6SQu6Sh86iDYnNIJ9VgIUcwDw,57904
+googleapiclient/discovery_cache/documents/assuredworkloads.v1beta1.json,sha256=3ik3uFyaMUach_9rWkxEll0QOq7EAjWY-RF2mHGvBbs,59450
+googleapiclient/discovery_cache/documents/authorizedbuyersmarketplace.v1.json,sha256=r9xZNIUe78xcpYCR4rDvXsKZtEJdAOU5ECoukvyJL6k,108664
+googleapiclient/discovery_cache/documents/backupdr.v1.json,sha256=UfP-6OnNFlObZ9Y7UZIeleg1pX-oR9PwCtzvwGI2I1g,49331
+googleapiclient/discovery_cache/documents/baremetalsolution.v1.json,sha256=DgpA2txkVyJ3FJmckMnRzB1LGtD8K6qo8F2eYT6Bi3c,13574
+googleapiclient/discovery_cache/documents/baremetalsolution.v1alpha1.json,sha256=LWBZqVLJQlt0qgc4yoRJWQfwH0oPL8aS4wHGF8LRfzk,19186
+googleapiclient/discovery_cache/documents/baremetalsolution.v2.json,sha256=j5nwqWad5DX4YvOeWMGoADyOhXgKrAOB6KmxvPEvzqc,101728
+googleapiclient/discovery_cache/documents/batch.v1.json,sha256=qcuHzI4soTNbjjHyd7wdlCFGvUYmQNS2MPuh0Sw5jsA,80993
+googleapiclient/discovery_cache/documents/beyondcorp.v1.json,sha256=Vzr8UAlIM-QEtOZRMedFRDgQUoPhOSQDrJL4ppFnnOs,137815
+googleapiclient/discovery_cache/documents/beyondcorp.v1alpha.json,sha256=iS-SG834i8RB7IXDeUKXJiwEo_hfy0DfBOLUV-lXwcA,266811
+googleapiclient/discovery_cache/documents/biglake.v1.json,sha256=nwbIR_hroE_djAfsXPQrhyNH8YWDYgyjUToK_A0fSaY,26554
+googleapiclient/discovery_cache/documents/bigquery.v2.json,sha256=DHxuDjBjaHBgEUjJUuj6adMB5MOg24Lvd3UwufE7bWE,371531
+googleapiclient/discovery_cache/documents/bigqueryconnection.v1.json,sha256=O1HqFuRht2UDHcYOWvyqcoYaq7x_o0B2m27Xjd93PKQ,42594
+googleapiclient/discovery_cache/documents/bigqueryconnection.v1beta1.json,sha256=7bwOYam7QBHDOg0OaJvJqVO48HOGUgK9OAwvWr4oX60,32721
+googleapiclient/discovery_cache/documents/bigquerydatapolicy.v1.json,sha256=P5xgBU4akMjWE4InudRYsrnIbiqx0HeKRrqRN2N0mRQ,34611
+googleapiclient/discovery_cache/documents/bigquerydatatransfer.v1.json,sha256=Tech6WCZvDJE-Dwrh213hB3N7YOa-6EwSQpSqkTFH7A,80054
+googleapiclient/discovery_cache/documents/bigqueryreservation.v1.json,sha256=psxcep7qXwaLRvzQwnT__jNfM7wydzrZGDgXkr28RBY,53611
+googleapiclient/discovery_cache/documents/bigqueryreservation.v1alpha2.json,sha256=u1WvY6zx7CYg_q9OhtqB5I8Su4b1kEA7p3VwegecO8U,44509
+googleapiclient/discovery_cache/documents/bigqueryreservation.v1beta1.json,sha256=zVtHmOXJTgtYX3JK9YoFUW8uNNHwi-ZPHs4gQN-Y0cY,60957
+googleapiclient/discovery_cache/documents/bigtableadmin.v1.json,sha256=udwAbAWXjShMSJcvAaxRNI-V5QFFQdE6InVOhHT-y7Q,32684
+googleapiclient/discovery_cache/documents/bigtableadmin.v2.json,sha256=aXE9Yqcw46lA8Ps4RbtROMfFIHlrrbYw908_3BpTAGQ,170403
+googleapiclient/discovery_cache/documents/billingbudgets.v1.json,sha256=QXRL987DRIh2EQhokFytLhta2zsrO9DNEHFCJc1lYRc,27319
+googleapiclient/discovery_cache/documents/billingbudgets.v1beta1.json,sha256=uD1QaMiCk4YUIzdzBL-lr8scFgdEoI9ABReVH-enJSU,26850
+googleapiclient/discovery_cache/documents/binaryauthorization.v1.json,sha256=fJ6da6Utvr-UzUIg2rXeNtDzs6SVXQgPgNCFpL7xquM,84346
+googleapiclient/discovery_cache/documents/binaryauthorization.v1beta1.json,sha256=pu3uMj8oUbhvTC10Gv3bcSLwP9yPDgstsruMVPGfsSQ,50577
+googleapiclient/discovery_cache/documents/blockchainnodeengine.v1.json,sha256=x8MAjPHkNkdaOPmwAK4Z0UjFfczCBCEQkw2euchyDUg,33078
+googleapiclient/discovery_cache/documents/blogger.v2.json,sha256=qAxMrtu3IyP-h7gkKD6hjmvgot2a46ap-mlMeyrfWqc,21584
+googleapiclient/discovery_cache/documents/blogger.v3.json,sha256=U-2HJn6EgGmc1XAQKB-5A5D-v_qm37rTgq2u0z5t4Uw,44123
+googleapiclient/discovery_cache/documents/books.v1.json,sha256=DhME0j4J8CHq66eNgY4iHY1aye0ahVWNjZKw2mSJJ8I,110062
+googleapiclient/discovery_cache/documents/businessprofileperformance.v1.json,sha256=lLME8MBJWlb9yopVZz9ItZAFRGxrPezt_bl8NExX5I8,24089
+googleapiclient/discovery_cache/documents/calendar.v3.json,sha256=von3lmqTl5EolfgzIx7XFLoiFqBBgXdRzM3Arz-ehEI,115201
+googleapiclient/discovery_cache/documents/certificatemanager.v1.json,sha256=Gp5kXajbk6_2lkgAZCMnSsRaYYn4Gz3gQwZ0GjqEkow,70692
+googleapiclient/discovery_cache/documents/chat.v1.json,sha256=3YfPGV90aaKgPZecwGenlQ8J1B63sJeUuDHVoVw1veU,212482
+googleapiclient/discovery_cache/documents/checks.v1alpha.json,sha256=ah0uoIorAwDX60dk9VlVJUj_by932QMM5qsj8G5igXA,65998
+googleapiclient/discovery_cache/documents/chromemanagement.v1.json,sha256=lPz_3S4YJQLw3ZXu1Tcsxa7pjGGZD6yzriY-YxNz6ek,143949
+googleapiclient/discovery_cache/documents/chromepolicy.v1.json,sha256=XzXPeD-ZtHTIVr8GhqcUz2sH6Bvfn6rpYLq8O4ICmH8,61896
+googleapiclient/discovery_cache/documents/chromeuxreport.v1.json,sha256=A-TDgD-87UpKY99RCa_EkOUzaakjyOPA9-dnm-0VGq0,22424
+googleapiclient/discovery_cache/documents/civicinfo.v2.json,sha256=olsG60C-NAu3DPqwfHmsHp3jk14XyQE8C2T_yX77HFs,37651
+googleapiclient/discovery_cache/documents/classroom.v1.json,sha256=t3h0RTBX4mgQHXwAYQe1Xn2DQ4XmiXXwWAe2mP0nUuA,160146
+googleapiclient/discovery_cache/documents/cloudasset.v1.json,sha256=MZYSwJGq098R9DoITfYvQexlJNzx-_xUQ2n4up5WT9M,256254
+googleapiclient/discovery_cache/documents/cloudasset.v1beta1.json,sha256=9GQRihaHTzCPI7SuFhXpIYSVXFFuQpgDseJZQRQSYJ0,93726
+googleapiclient/discovery_cache/documents/cloudasset.v1p1beta1.json,sha256=DteNxFatX_miQ-nYMAcmYwMdPbNYTmCtenRAPzKn5IY,81893
+googleapiclient/discovery_cache/documents/cloudasset.v1p4beta1.json,sha256=RT5pGxMQhQ_T9JKt97G6G94znnnweuqgSwEnby7Vkck,110574
+googleapiclient/discovery_cache/documents/cloudasset.v1p5beta1.json,sha256=Df6qU9S-2OFBTb0hNCJmhRKrJRWE0uVf2YqZpeyHOaI,80551
+googleapiclient/discovery_cache/documents/cloudasset.v1p7beta1.json,sha256=xrzStUXpFnMA751Zo2UMANKg9pX3VTxil-HOalfiEXY,86206
+googleapiclient/discovery_cache/documents/cloudbilling.v1.json,sha256=sVdxvcy-Yi_5_4l2sL3qrmvjjagS5ivMf0b5b2O-rAA,60689
+googleapiclient/discovery_cache/documents/cloudbilling.v1beta.json,sha256=Qec6NAxiMsO4Dsz6UPKqdm_lE4B0ul_O3sPJSXHz7eg,97448
+googleapiclient/discovery_cache/documents/cloudbuild.v1.json,sha256=4eQ7_qdoxjGJuw02bHi9A8-27v9yDqngudgkLHGZk4A,181045
+googleapiclient/discovery_cache/documents/cloudbuild.v1alpha1.json,sha256=tN8lxatpJZdx4mhuKWjgzYeBfbN3ZFgZOhdDI8HdMTc,103536
+googleapiclient/discovery_cache/documents/cloudbuild.v1alpha2.json,sha256=FqGePJRUozQZ3MgYXXDeeBwhKb38oRdL3RDyfn5LKOA,102139
+googleapiclient/discovery_cache/documents/cloudbuild.v1beta1.json,sha256=Z9D0XmsAbFI1Ug2BBm8i4hocf4dzGW0MP_3rprbHH2I,105268
+googleapiclient/discovery_cache/documents/cloudbuild.v2.json,sha256=8Wp5ar41Evw-wT7ZCYB_66B-JW5Rkcc-xJNgh9QjIM0,104463
+googleapiclient/discovery_cache/documents/cloudchannel.v1.json,sha256=BzRfZDukvoHmQ_q9FWwPb0b5cLIu4R-C5psLW6JJP_Q,239183
+googleapiclient/discovery_cache/documents/cloudcommerceprocurement.v1.json,sha256=NtXgLDh60lxmnNf3YKeRYfUr2suT9B1KvXUyXvfeXuU,40056
+googleapiclient/discovery_cache/documents/cloudcontrolspartner.v1.json,sha256=lfaFxdp0nD2kU8qhsm25SaaOXLqg5Y_DnfCe3xBioXw,36426
+googleapiclient/discovery_cache/documents/cloudcontrolspartner.v1beta.json,sha256=vqeDM9kE-_6SD_uDijceI0jSZ0tpmoX_8-Y_xzlRtWY,36514
+googleapiclient/discovery_cache/documents/clouddebugger.v2.json,sha256=2IO6Cc_uKUbDzdXhyc02Xr2Y7vd8TIRq_2iWDhwGYPE,53446
+googleapiclient/discovery_cache/documents/clouddeploy.v1.json,sha256=KSe-O3hzX5FfJGcVS2pS9MSd0OOTr5pbZ_o2plQ20as,219202
+googleapiclient/discovery_cache/documents/clouderrorreporting.v1beta1.json,sha256=wJ3gRI825PdMffTOcXF4le3zpfadmFrJj6XjAuzvY3o,31795
+googleapiclient/discovery_cache/documents/cloudfunctions.v1.json,sha256=cJAwBhkjvOyRdzQdJje4cC8V3hyNXsX5dl_MuB7IOYA,78272
+googleapiclient/discovery_cache/documents/cloudfunctions.v2.json,sha256=sXOV9FHhQcQtRHNW-8B9UaQo4ZhPwTiEWjwfRvx-89c,93503
+googleapiclient/discovery_cache/documents/cloudfunctions.v2alpha.json,sha256=crDv8vsB7IVoY64nBCXlhEs7f0JtOsZ9waX7BaXJV6w,93708
+googleapiclient/discovery_cache/documents/cloudfunctions.v2beta.json,sha256=dz9qVJJSI7G76e80u7tlj5BJyao4TgQzw0YCLjHxH5w,93667
+googleapiclient/discovery_cache/documents/cloudidentity.v1.json,sha256=P-fwJ56HozjqZrdFceL1nsA_zvtPBfRelV0ctvVxR_A,154656
+googleapiclient/discovery_cache/documents/cloudidentity.v1beta1.json,sha256=vbdVMRyrYNVcGK8LLTZaQcMPCbjwP7hm5FBNscXI-Po,182370
+googleapiclient/discovery_cache/documents/cloudiot.v1.json,sha256=BLM9X9po2P0rn8osda4MgRc990yAYWFVbRMnoCTjN6w,94703
+googleapiclient/discovery_cache/documents/cloudkms.v1.json,sha256=UthiZstVoNBgfa8ZfQw8zT4_osjp94MVxk3eCQigcZM,176642
+googleapiclient/discovery_cache/documents/cloudprofiler.v2.json,sha256=6UPJdt-EecV4q8DTCo6D9WV2-zxU0kx0kaymaJtRl7Y,14920
+googleapiclient/discovery_cache/documents/cloudresourcemanager.v1.json,sha256=NK3rBqymj8vP5RvzvEgnCQZjLJA-sJJGvqesK1pZ3Z0,101363
+googleapiclient/discovery_cache/documents/cloudresourcemanager.v1beta1.json,sha256=wwAGW3fZ6pBdJsI2DSBGA40HL5m9zbMLqUU1yWZYdSM,58393
+googleapiclient/discovery_cache/documents/cloudresourcemanager.v2.json,sha256=FDnbURNu0tRbioR6Sg1GOQpZbp16sfFeITqElLxZK8A,52001
+googleapiclient/discovery_cache/documents/cloudresourcemanager.v2beta1.json,sha256=INo0-vLizwMhTNWxz5T_S76qMx2gpO6Gv2pRaTAbmFM,52011
+googleapiclient/discovery_cache/documents/cloudresourcemanager.v3.json,sha256=W530n77S2mpl0DQ-lU-9CazQNDxFgyqxnSy5HNO0Xqc,126177
+googleapiclient/discovery_cache/documents/cloudscheduler.v1.json,sha256=hQ8UNYQWv6__3qc-FXJENrc-i0GTZvWe8y3d8nIjUs8,39868
+googleapiclient/discovery_cache/documents/cloudscheduler.v1beta1.json,sha256=qf3DP_2CqRX5Uj0YHzSDcwvHAilEceozcRH09zs1nPI,41606
+googleapiclient/discovery_cache/documents/cloudsearch.v1.json,sha256=csMOy3Y2Wlnb0uyxV896PuL1pKnVCE7tmkZa614ipY8,246061
+googleapiclient/discovery_cache/documents/cloudshell.v1.json,sha256=3fi9eLbdZRNnocEF_oJr-bq1ZrJ2_r8HP-5aFLdJbas,22893
+googleapiclient/discovery_cache/documents/cloudshell.v1alpha1.json,sha256=XoIskUrEjFBy7Saxe7cApOT6ShmcKZlwzRDAiIoxgSI,25615
+googleapiclient/discovery_cache/documents/cloudsupport.v2.json,sha256=qmS2-9pL9BcvtuagPstYmjzeKRnplQ3ZgyxKk325esg,52740
+googleapiclient/discovery_cache/documents/cloudsupport.v2beta.json,sha256=Y3XHoP1XWqztvEAiAMuZLWiJQ_dBfv5x7SPCT5bziII,53502
+googleapiclient/discovery_cache/documents/cloudtasks.v2.json,sha256=uQmKoV0aFLakzUhDz3teNmZb8n2hxhXZJ04IHpx40RE,96085
+googleapiclient/discovery_cache/documents/cloudtasks.v2beta2.json,sha256=EdUuSrI8ho1lXK4vbsf1p29iuuXpKK1maMsQskExPXI,112957
+googleapiclient/discovery_cache/documents/cloudtasks.v2beta3.json,sha256=ao2bh1bdpkamfKHWO8AaZ0nBtX838GvSS7xay_nwpbY,102889
+googleapiclient/discovery_cache/documents/cloudtrace.v1.json,sha256=42W4740LBqNqcstTSxD2sCWy5QBaZXeY2vo_Ta6MiwE,14143
+googleapiclient/discovery_cache/documents/cloudtrace.v2.json,sha256=lp_WQmH-FgaH8NI6MqO5XGbsNIjNy7RmBoSjF9Yt4Fo,21080
+googleapiclient/discovery_cache/documents/cloudtrace.v2beta1.json,sha256=cwCxA1OnGCfQnkAzIt9I-fVbp-juSgCV2szH2S57Kz4,11521
+googleapiclient/discovery_cache/documents/composer.v1.json,sha256=AnKMENl4PHI7DgGZlb6WHcMLlq4bx7HHd61vlKV8eUo,95747
+googleapiclient/discovery_cache/documents/composer.v1beta1.json,sha256=eHAyXJ58mvVHKuBQIsWbETS9hCFg6Exhoy7a5Nor6AI,102123
+googleapiclient/discovery_cache/documents/compute.alpha.json,sha256=ChNufOnaynP-9PhUXFXxmEvqC7tUDSRiTk7ZTbnwAVk,4323429
+googleapiclient/discovery_cache/documents/compute.beta.json,sha256=JYNK-aNgQ0Oj-zmjrYhabVe9O1meMo1gmANhvqM_Ku0,4007207
+googleapiclient/discovery_cache/documents/compute.v1.json,sha256=zxNj-YZbzKPIBJy2uSnjq5JRYzDeoZ7jl01Ef2NUyXs,3708391
+googleapiclient/discovery_cache/documents/config.v1.json,sha256=5VrBYSbONH-F4KMtcr_f6I4kJNyRm_S9Qt86WZMB4Ck,100406
+googleapiclient/discovery_cache/documents/connectors.v1.json,sha256=rP4ZfDnVcIowJ70FhOLEiJrPVC0Kdm3gadwk7zbvDtI,209600
+googleapiclient/discovery_cache/documents/connectors.v2.json,sha256=mTUzzPKJDaGxMTYCjE0aE3-CC5zqI5C69RKslKvuFeM,68676
+googleapiclient/discovery_cache/documents/contactcenteraiplatform.v1alpha1.json,sha256=GFDh-BsOpmSFhMLykAJ3c_MgI16DTNIDB2jaOzJvDXM,32530
+googleapiclient/discovery_cache/documents/contactcenterinsights.v1.json,sha256=Yl7E60o8wPvbD2Mgy18hYeoilUiaVy8dRMW1lBJOZhg,233233
+googleapiclient/discovery_cache/documents/container.v1.json,sha256=vO5WrT28-7r9jx08kJwBMiPQFHu0fjYabEzsQhWaUMo,289371
+googleapiclient/discovery_cache/documents/container.v1beta1.json,sha256=oGPHM1xnRv1LaSyZ5X8FsqPAF-Kste4YhGDwBwgPG2g,315742
+googleapiclient/discovery_cache/documents/containeranalysis.v1.json,sha256=JNtKuHSneaR5-mr-jHq8zh5a9-lZvMY1ATJ_2IpMRTM,202848
+googleapiclient/discovery_cache/documents/containeranalysis.v1alpha1.json,sha256=AHdqdArEAE8Xq07O2JNLcI3pkbXduKAZ9W9rTYu9vBA,238711
+googleapiclient/discovery_cache/documents/containeranalysis.v1beta1.json,sha256=ulx__TbHEItYSxUdedT5FIAa5zFKu6Bgtkio1P9W1N0,218042
+googleapiclient/discovery_cache/documents/content.v2.1.json,sha256=KDnvbs3Zs7KHNrqT_1NpicmrFBw3HWwEO2Q67URRUtg,604912
+googleapiclient/discovery_cache/documents/content.v2.json,sha256=PuV1X8AOtI9T1gaQphOf14GgA06gplme2e31cRNVSlU,389993
+googleapiclient/discovery_cache/documents/contentwarehouse.v1.json,sha256=sh6MJpzhuFg-RmXJsUW-LaHiMdke7V6W9VAUmObYI9k,4579077
+googleapiclient/discovery_cache/documents/customsearch.v1.json,sha256=okqDX4xeHHg_ZVKQn6Bk80xN-0DOaU58pa62ue2tngc,62694
+googleapiclient/discovery_cache/documents/datacatalog.v1.json,sha256=d5IZYdC45s20-2b6vnlzEDDeZ2g6hX5k0jBuEEUCJc0,181835
+googleapiclient/discovery_cache/documents/datacatalog.v1beta1.json,sha256=KQd_kXo_rCOG512kY0qQZrL3jso5YkLQP4C_jMWx54U,180450
+googleapiclient/discovery_cache/documents/dataflow.v1b3.json,sha256=ll-8BdN1e6T47zLsqwgtPaySbs1AUbM2CIOdR4j-9ek,262317
+googleapiclient/discovery_cache/documents/dataform.v1beta1.json,sha256=LZL5i8oavDc6panjKew2cRnsYw-IRO7PP3I60Mdg3nE,132324
+googleapiclient/discovery_cache/documents/datafusion.v1.json,sha256=h13v8xC2PruKHTQwN4tihDJ--eVS7fOWMPw1jpY3pCQ,65693
+googleapiclient/discovery_cache/documents/datafusion.v1beta1.json,sha256=JPsCgy1wp1LFjTydrkt5CcudEMgX36OCCu9oC3bm7WE,74698
+googleapiclient/discovery_cache/documents/datalabeling.v1beta1.json,sha256=VJXeKNDTAWpQ6WtRl1ooWHt6r4Sk_RGXyyPxsDeszAY,202099
+googleapiclient/discovery_cache/documents/datalineage.v1.json,sha256=RYsJZKPDV2MIbz5sZ_cEIciTHeOCJrV3w8iKAzZbWU4,45445
+googleapiclient/discovery_cache/documents/datamigration.v1.json,sha256=TbksgUtY49IlD8CdcYTALior9L7o7FbbO1Su1CrRaoY,213186
+googleapiclient/discovery_cache/documents/datamigration.v1beta1.json,sha256=0QA8nw8IV1J9SR-NYvOI05bHzZCqsixOwGiGPulCV4k,83902
+googleapiclient/discovery_cache/documents/datapipelines.v1.json,sha256=VUiXBysMJ1k_97XHF6LLTC4TpSdMEqUNvTvDfbGFseU,38301
+googleapiclient/discovery_cache/documents/dataplex.v1.json,sha256=furf-Ih-bBoA5zU3qlajerVSZ_vWEmS9ukXwoCHoWUs,390273
+googleapiclient/discovery_cache/documents/dataportability.v1.json,sha256=_OEFAhHnpMerAkyDqGcRCqWNtIhKJgoNzvZudCPPvl0,35993
+googleapiclient/discovery_cache/documents/dataportability.v1beta.json,sha256=0ImhpoZGdmco85HE6BQpSy4inSUU7spOoe3zJM9aZL4,36033
+googleapiclient/discovery_cache/documents/dataproc.v1.json,sha256=hX0lHbpDdhpt_l5VOLSl_y9IJNKpVeRW4Ql_tGQwm7M,293215
+googleapiclient/discovery_cache/documents/dataproc.v1beta2.json,sha256=jfuxbI0IJ3EFmdqwKxUp_DvxU6gLnDToTAicOhZM0qo,256974
+googleapiclient/discovery_cache/documents/datastore.v1.json,sha256=49vsFanKQLZpHmQ7A0Qgn9OLKCrj6lflww8uEKEpAY0,91787
+googleapiclient/discovery_cache/documents/datastore.v1beta1.json,sha256=KlOEINzUvGOe5zDPdn8sQfxj7_9w_NRvfL9EF1HSAlU,28932
+googleapiclient/discovery_cache/documents/datastore.v1beta3.json,sha256=IGOmjeLtlh0aVlefTRzo7DRCbZANWqoBkHC3IWlLIAE,68781
+googleapiclient/discovery_cache/documents/datastream.v1.json,sha256=bNqBJOHsfviD2x5gUrnjGTL7YVv4UsHmMvGpcjUsKXU,96626
+googleapiclient/discovery_cache/documents/datastream.v1alpha1.json,sha256=YpCstMtaGxQoO_9pHKYDFGY0IrowaQXyGE8NGwyJAf4,78725
+googleapiclient/discovery_cache/documents/deploymentmanager.alpha.json,sha256=IeAFy-JCVsNFU699Qj0vKMPx-tgSmphxxH5w9xag6Yk,144399
+googleapiclient/discovery_cache/documents/deploymentmanager.v2.json,sha256=ZAF_tsFrsG0r-96Z5lnKMNQyLlg376CyMF2sbT046TY,99029
+googleapiclient/discovery_cache/documents/deploymentmanager.v2beta.json,sha256=VIcGLcWb8uO-NaDJXDdiVHgeZ76bJq7P4n33O7pRia0,140563
+googleapiclient/discovery_cache/documents/dfareporting.v3.3.json,sha256=AaucsfQ-9Hx6evOCWHX3E6n6llRjAlvVFEqLD2bpYXE,721039
+googleapiclient/discovery_cache/documents/dfareporting.v3.4.json,sha256=0KvRG3-gvfK5CunHotnX5uTGYwl8W_af_vg0LX0q_NU,748283
+googleapiclient/discovery_cache/documents/dfareporting.v3.5.json,sha256=4p9g307jjj0_2ETEh4Ndc4Fk9i7W-Nuz6j7o_AQU05M,24941
+googleapiclient/discovery_cache/documents/dfareporting.v4.json,sha256=yTJuXnIvytP_KgGdEqTQBzxPo_s2QDS2XMDLOoBLWn0,558112
+googleapiclient/discovery_cache/documents/dialogflow.v2.json,sha256=u2U0iqXb-bUQ5BnLtL48q-vM2-cyOl-qp-LLhdzY2n0,833468
+googleapiclient/discovery_cache/documents/dialogflow.v2beta1.json,sha256=OTz-BoOshE8y6wFpVt_S1IgMeKBe8DTcK37tj0vnrV4,843196
+googleapiclient/discovery_cache/documents/dialogflow.v3.json,sha256=Op9569u6nFFOlD1Xn1_bL_CCjwpsHhXr_Gxamce00fM,686063
+googleapiclient/discovery_cache/documents/dialogflow.v3beta1.json,sha256=zt-WmUGHjuBOPD1pVU52Vrno1aa8g2snMPVjQ88my90,690465
+googleapiclient/discovery_cache/documents/digitalassetlinks.v1.json,sha256=jl9iYYYQTk9yczzC2WDAJyvGn964QuCe9nZd2up7-8M,27271
+googleapiclient/discovery_cache/documents/discovery.v1.json,sha256=OQvmfp6aUxzASZk9m__FvI0wuRXNWI_41RykyxtDkzU,18215
+googleapiclient/discovery_cache/documents/discoveryengine.v1.json,sha256=_6Qx_7ipwAQ_iY3Uckr3Q3N6kPK8uDOo82RhJVd3sBs,423662
+googleapiclient/discovery_cache/documents/discoveryengine.v1alpha.json,sha256=DaDsYxSAEicWbreipJdRdPbqPZwS5Lckoof9EVacIMI,578046
+googleapiclient/discovery_cache/documents/discoveryengine.v1beta.json,sha256=OyZaZA4eqmLUo1abMYZbdO5hp_K51igjot71uz8TM9s,523922
+googleapiclient/discovery_cache/documents/displayvideo.v1.json,sha256=RRZQfVKtGzhfs9Kx6Rp2mrBcfaRJ9p5B9I76uIcVf4c,737810
+googleapiclient/discovery_cache/documents/displayvideo.v2.json,sha256=2YzDzcEuVxkCyLb6hvguV0ZnvZv4c1WHtjSUzd1HwGw,863544
+googleapiclient/discovery_cache/documents/displayvideo.v3.json,sha256=SbZanZNeBVmKsDC0hAw1rpugzu8SRs3KXZ_SuN3JAIU,875654
+googleapiclient/discovery_cache/documents/displayvideo.v4.json,sha256=ZawYORuamvnE2jVpVNrXpFwg7zEdTwNcHKxcGREHJ1k,9032
+googleapiclient/discovery_cache/documents/dlp.v2.json,sha256=fpvTI4sJD2bVg7-uYNzaiqNqsxmB17hj7-GL8OCqtW0,443439
+googleapiclient/discovery_cache/documents/dns.v1.json,sha256=-XKyvQ4RaD7eXgitkTCHqqNpwXouZOsipGqVbPlmrjU,120541
+googleapiclient/discovery_cache/documents/dns.v1beta2.json,sha256=jdmTLfbzaSdzi9-oJrhO7X20wnlKS52kRx-er8yCF3k,120925
+googleapiclient/discovery_cache/documents/dns.v2.json,sha256=uMSPBTHSlq6gMc-OC9ap_C9WuE34lwbub8U8wOlwoTY,136579
+googleapiclient/discovery_cache/documents/docs.v1.json,sha256=psbt1vIyoVEfdymwQt2eGAPEMMzCVPwS7Q4eeUJeTwU,164629
+googleapiclient/discovery_cache/documents/documentai.v1.json,sha256=jn8ym-ZuNyEq8jiHF0hw7l4w3r4jMgK12PTPB9OGrtg,295044
+googleapiclient/discovery_cache/documents/documentai.v1beta2.json,sha256=xBPDAhe9bWLJBDjWIWTR5jATUqpXzNQqanLOaF8YFn8,194912
+googleapiclient/discovery_cache/documents/documentai.v1beta3.json,sha256=QLd4kBiyaoP_PBJwB3xgmMd7mllhtNYoW3Vgxjx4DRA,329433
+googleapiclient/discovery_cache/documents/domains.v1.json,sha256=g2PhgiR3FaWZc-LntimqB5DBj6Z2V5ueR1W9NJFjZzo,99468
+googleapiclient/discovery_cache/documents/domains.v1alpha2.json,sha256=uXFSIQRPW7nSl2UJHhl3cf6YKQ6bRzzXy0PjIOyLhHU,100073
+googleapiclient/discovery_cache/documents/domains.v1beta1.json,sha256=Xsw3CBE6Ot_qWtfqBWV6gFwvkkc0dm5WzyfMZP7AxmQ,99718
+googleapiclient/discovery_cache/documents/domainsrdap.v1.json,sha256=qgeyGgTtwS4In3PMSk5ZWCZYBauDeH1JoYY67XlsTr8,11381
+googleapiclient/discovery_cache/documents/doubleclickbidmanager.v1.1.json,sha256=jHYIGcAx7c3WN_5Mvr6LpEFpkB-VYgyz-rpoi41Fl-8,117347
+googleapiclient/discovery_cache/documents/doubleclickbidmanager.v1.json,sha256=c-oeCNUdKAdNJa3Bm3sqAgb6LpgiCn-s6NUUp4rsUt8,3347
+googleapiclient/discovery_cache/documents/doubleclickbidmanager.v2.json,sha256=85dVntmxoNMtqbv9r2hPO0WXcqXWkru0tVR5K0VOUuw,23862
+googleapiclient/discovery_cache/documents/doubleclicksearch.v2.json,sha256=LRKuvBOvGilAm5kgZS3OELVqparFZ5oU_-Zoh6X7j3A,34837
+googleapiclient/discovery_cache/documents/drive.v2.json,sha256=ZCoaJDE9m_JVfTYS8gSMwsFSE02ztPHwqf2vNSjGFLU,199661
+googleapiclient/discovery_cache/documents/drive.v3.json,sha256=Ff1bSdjBn_AdbAk0EQ_WQY3ihdYVOqqRUYGh5Ub8GX4,152964
+googleapiclient/discovery_cache/documents/driveactivity.v2.json,sha256=g6ffIZeqmMiMJ44sqcDASn8Yfowfz8PhqdJn4myuUmc,36906
+googleapiclient/discovery_cache/documents/drivelabels.v2.json,sha256=eQYmE4G9tACCWcGqdbLfmWKvMAVD_ax8sNoIscYiTHQ,105403
+googleapiclient/discovery_cache/documents/drivelabels.v2beta.json,sha256=3UJlfCfI4nDnvEjkwi5vt0w_XjrsFH_iUa4kHcbll5g,106827
+googleapiclient/discovery_cache/documents/essentialcontacts.v1.json,sha256=-ECZoxOB3EkBkqbjz689SEAI__Q5XWNAYQb6OUVRrUQ,34440
+googleapiclient/discovery_cache/documents/eventarc.v1.json,sha256=lJPqpESPqw2-hU0cA6-aHEKAjzILttgFj4cHvqRm6NM,86835
+googleapiclient/discovery_cache/documents/eventarc.v1beta1.json,sha256=U-aHfsX4GDiwOAMc5FO06rTGskX2ujciwv7seR4yFMM,46836
+googleapiclient/discovery_cache/documents/factchecktools.v1alpha1.json,sha256=1mBzn7u0bKOT9clIlkAgjMlFoEqHpwEBsBAn9zEGG7Q,22439
+googleapiclient/discovery_cache/documents/fcm.v1.json,sha256=HhLPAISi49DxjjA-OTZpF13Bun3bkb6xASox1oawmJQ,30270
+googleapiclient/discovery_cache/documents/fcmdata.v1beta1.json,sha256=FARAQ8upLOkPaDT2tGacCrCtiGadFDW2LfsN96VxHlQ,13172
+googleapiclient/discovery_cache/documents/file.v1.json,sha256=RMRlJw8uqCUdslRwcDRYcfazsjuolgJG7yMeCukHFtI,73217
+googleapiclient/discovery_cache/documents/file.v1beta1.json,sha256=9d-j-f6bluz_reVqC250ny6_685CA07HITarbKFmRx0,85332
+googleapiclient/discovery_cache/documents/firebase.v1beta1.json,sha256=lZfEf0xAwysaRIrJkkCYkowkxTufvnVpCQS9TPRsVAU,112124
+googleapiclient/discovery_cache/documents/firebaseappcheck.v1.json,sha256=EpeL713bnbvh_3GHwel7ODplvKBXHDN5nGPzeqkdwYo,79709
+googleapiclient/discovery_cache/documents/firebaseappcheck.v1beta.json,sha256=q7mb_WvBvzQcnJO13V9OeVUPS8eZgWuTYrrKYY2eCAs,119099
+googleapiclient/discovery_cache/documents/firebaseappdistribution.v1.json,sha256=0kKXEEsuVS7FKGIcEAqApSEFHH2MTqYWcu3NPPagSpQ,65361
+googleapiclient/discovery_cache/documents/firebaseappdistribution.v1alpha.json,sha256=0NLMpKf9ZwT9H47_47BbfLyZbM2S7V4_ZnIHMdVgsLw,36058
+googleapiclient/discovery_cache/documents/firebasedatabase.v1beta.json,sha256=reaf6Rn6vjECqqcFGMV-vEnlzhxQicBk2_0sindY54Y,15636
+googleapiclient/discovery_cache/documents/firebasedynamiclinks.v1.json,sha256=chXGUUiWO_pz779vG1afyrOEoufnRUf7OMQdd56dJTk,32930
+googleapiclient/discovery_cache/documents/firebasehosting.v1.json,sha256=RNpRXTvOB7yMdcNaFTzkhcn7n-hr8IWsVtxeXHb95pM,26740
+googleapiclient/discovery_cache/documents/firebasehosting.v1beta1.json,sha256=oVVBppZvKfvzx203kwmOJHgSg68S5mZX2q2DQVrY7Jk,133655
+googleapiclient/discovery_cache/documents/firebaseml.v1.json,sha256=s7iJs1g7NN58zxNUroZg3_eQgkT1nuv7qLRUgSMHCjQ,10354
+googleapiclient/discovery_cache/documents/firebaseml.v1beta2.json,sha256=34_4j0Hy71AOv-ihCqwUPCt-1ihO8VMcq_oY-jbrgUc,16713
+googleapiclient/discovery_cache/documents/firebaseml.v2beta.json,sha256=Fm5LlqnH9CkwSgWyKo_xcBKhFbCAYep5NwONSE3qBL0,35682
+googleapiclient/discovery_cache/documents/firebaserules.v1.json,sha256=f64w_-_9eQRD0WAShRaEmGpAXtNCWTeNH4IKBrpHH5g,34167
+googleapiclient/discovery_cache/documents/firebasestorage.v1beta.json,sha256=D0re3iHVCNS2IOr83xVozoSRtJkyn13qqU4_HTt-lEk,12239
+googleapiclient/discovery_cache/documents/firestore.v1.json,sha256=R2omlhtkoZGpyss3uUgG_pZQeLqJkb4vnnsiT6uvV1U,166427
+googleapiclient/discovery_cache/documents/firestore.v1beta1.json,sha256=aTgejEE2ngYNC3_XzpborUmoZ5I6MDTtZPWoSQDdOdY,111858
+googleapiclient/discovery_cache/documents/firestore.v1beta2.json,sha256=Rh3c7CSx-Z5uKEpoAFQHuvWEnM5N11Yvnj_GX-JB7-g,39889
+googleapiclient/discovery_cache/documents/fitness.v1.json,sha256=WCeuIlOHDG-xSDX0GHRtJTCx0YgTfSxUbC3tmRFnPd8,62402
+googleapiclient/discovery_cache/documents/forms.v1.json,sha256=-PsbRv-KtYiumfkyJizqqIrqPDyfAqIWbzLWetpkwkY,48259
+googleapiclient/discovery_cache/documents/games.v1.json,sha256=Kf87rlGibGEUNo8kPsTA5Gb7r1-dSaOOG8Tl1GKyjJo,95733
+googleapiclient/discovery_cache/documents/gamesConfiguration.v1configuration.json,sha256=CEz4AHKj5bTcboPG5js909L3QC-CNrlDVoIPgkt3xpk,19279
+googleapiclient/discovery_cache/documents/gamesManagement.v1management.json,sha256=eVk4FEyhNp30gHuPbvTzaEf-vY15KANo-oViA_3WsaM,23156
+googleapiclient/discovery_cache/documents/gameservices.v1.json,sha256=E5MFFlyECvsMxSIdo45glqQhAagCDHzeRSo13RPcJ-o,54733
+googleapiclient/discovery_cache/documents/gameservices.v1beta.json,sha256=amIruWItU7wwP_wTWMXY_g2eoY-2FW24EWyPxwQtMvs,54813
+googleapiclient/discovery_cache/documents/genomics.v1.json,sha256=r75lm6eDRH0cxivOOnIQnsm-KkrMY0C8Kp1H6WirqHY,44128
+googleapiclient/discovery_cache/documents/genomics.v1alpha2.json,sha256=OBijBJvThGSucv3G0IILtC8RNGFmdxYrZeLTDFMncsM,66239
+googleapiclient/discovery_cache/documents/genomics.v2alpha1.json,sha256=80yCmc2cqlgSJfPYAxqPMCKFxDWRksFMZzsEkgcsQmI,63816
+googleapiclient/discovery_cache/documents/gkebackup.v1.json,sha256=ItntPL5QtSh_ne3Ve60Ou62ufdR2hEKV_iri6eIRmcY,142632
+googleapiclient/discovery_cache/documents/gkehub.v1.json,sha256=oOZyEHdaRCrGuMl77ZxjXD9wJMkQAAEKqX_s4mYyYfE,211327
+googleapiclient/discovery_cache/documents/gkehub.v1alpha.json,sha256=GMVuwhJebpZk7hWufYX4t2QmzIr4746BLdTl2uk_pzw,240744
+googleapiclient/discovery_cache/documents/gkehub.v1alpha2.json,sha256=jIsXo_cDmHYf0RJNlhYTrM1ELjde46sbGHhrfbOGDc4,65373
+googleapiclient/discovery_cache/documents/gkehub.v1beta.json,sha256=R7sbGEdAjS_peTz4QvROAheYdt23xDJDGy9ZxD1uOwY,223758
+googleapiclient/discovery_cache/documents/gkehub.v1beta1.json,sha256=kfzoYRU9NBZFRc4_MTh_fU_DmLFDs2v5gBcKJpWRYpY,70370
+googleapiclient/discovery_cache/documents/gkehub.v2alpha.json,sha256=BapVekOly-Cwd5KRSybZSA7GIr0AYUIjd1jFendmRwU,13237
+googleapiclient/discovery_cache/documents/gkeonprem.v1.json,sha256=EdDsgV-3TQuR8a4eRCreLDcvfmSkFjXry38qG3ZV0J0,245945
+googleapiclient/discovery_cache/documents/gmail.v1.json,sha256=mxuye32vzhWBBLrvBrENpM0drKTUO4e_EuJS0IZaR6Q,130285
+googleapiclient/discovery_cache/documents/gmailpostmastertools.v1.json,sha256=osBN5dKllNo8yGQGp83TAQPJYdTV0i7Tuu2NCNaN-1Y,19146
+googleapiclient/discovery_cache/documents/gmailpostmastertools.v1beta1.json,sha256=fAbTUNgZ39tHtENa-PuCCWZzr2SnU6Zfupwbmq8o16w,19533
+googleapiclient/discovery_cache/documents/groupsmigration.v1.json,sha256=uqpKSkIv9peUS11JaX0QfmYg4VSI0wfQZ6wjDxZJ7Ek,3947
+googleapiclient/discovery_cache/documents/groupssettings.v1.json,sha256=nIlEpwiGvuICnB4MFl-FeDzDuC2qp-7aDfdh5PnKJ9Q,24702
+googleapiclient/discovery_cache/documents/healthcare.v1.json,sha256=eHtDFZB8lbIkAohAQqnsti1w6AxuYQ0lAJQRxhyBn1g,375158
+googleapiclient/discovery_cache/documents/healthcare.v1beta1.json,sha256=WMGxmsRbDYj-Q5n0HumdU4yb311Rm5qGjDMTLrn1sH0,489961
+googleapiclient/discovery_cache/documents/homegraph.v1.json,sha256=tqcPFNAETAA89YqLH1kBFiSG4gz3U46sw_dcZxoF7sQ,19439
+googleapiclient/discovery_cache/documents/iam.v1.json,sha256=YrJvCkh8xszVE9mUTcjPyOyCGp8yeeuAxDcAktWvvcs,226083
+googleapiclient/discovery_cache/documents/iam.v2.json,sha256=mdtws43aspuYskmIwQmZZOIWdozV6sfdrVrZAfrnt04,30287
+googleapiclient/discovery_cache/documents/iam.v2beta.json,sha256=xwICAbhb1RrpKqQD0QyzhZ5h-OiBt3d7SK9ikDEowIk,30411
+googleapiclient/discovery_cache/documents/iamcredentials.v1.json,sha256=YgMKWyRTtBIXGOIlswOC9EzKY49QcHBLl27I9CYDRpc,14399
+googleapiclient/discovery_cache/documents/iap.v1.json,sha256=E5oM_MScaGwdSpmCA73uuj-iQGxFKSTZyGv__CiLoo0,55028
+googleapiclient/discovery_cache/documents/iap.v1beta1.json,sha256=g3z498lFSeGri0HsDSDIjdYrtjB-hLiPJy9mGpf6Q_E,20190
+googleapiclient/discovery_cache/documents/ideahub.v1alpha.json,sha256=PfWK6J_Vqz1f_-mYWGBlCxLWSc8iwHrn9QRu0fl3GBY,21042
+googleapiclient/discovery_cache/documents/ideahub.v1beta.json,sha256=9N4Jk-jHWcWC-Cd5Hb_ARxh7nB6h2HVqrDNPRtei-GY,18785
+googleapiclient/discovery_cache/documents/identitytoolkit.v1.json,sha256=LnVymC0QgGJVLDjQ4e7dTV84_3b3o5tYAPQGKSdcr0o,142789
+googleapiclient/discovery_cache/documents/identitytoolkit.v2.json,sha256=oRfu0B8WoFamPz61PoaZErI7umfSlC8RSMrjgnuBmhE,131353
+googleapiclient/discovery_cache/documents/identitytoolkit.v3.json,sha256=1RFnGfmY0X0BPw4SowmIbeuhS8tGGm5rFXrEtQpV9Jk,54662
+googleapiclient/discovery_cache/documents/ids.v1.json,sha256=dxkwjVIgqM-fAJ907JdQT-lwDl-QCqRxllpf0xdwCCE,43597
+googleapiclient/discovery_cache/documents/index.json,sha256=aToo8a5LH-shdyLDo4-_QRwB6s1vFYEsF2w-gmO3-eg,213200
+googleapiclient/discovery_cache/documents/indexing.v3.json,sha256=t0_kK2nJynL33tDy3gfmujf-PvuWKhVncRrBxbozfKc,5776
+googleapiclient/discovery_cache/documents/integrations.v1.json,sha256=BGEReBVIXk2gTDetesuUhNxXyUifD9cTjVTUnJdEayA,394640
+googleapiclient/discovery_cache/documents/integrations.v1alpha.json,sha256=-bp1QUgLeateldClVafXg6Z8lbasIk1B9x0Vc5UwSKk,376245
+googleapiclient/discovery_cache/documents/jobs.v2.json,sha256=L-aDKIJ86eq-tEmOrHZfKD2MmQkCP_uTwCCTQHSJcoQ,227088
+googleapiclient/discovery_cache/documents/jobs.v3.json,sha256=gJTt0Wk_JN75soI7C9DUtNyDgwRBIC6nrXb_MQ67l_Y,126810
+googleapiclient/discovery_cache/documents/jobs.v3p1beta1.json,sha256=qvOT8O9-d8hUGxtnfwGEqApHszBvHXZGMOZEnq33Hao,140799
+googleapiclient/discovery_cache/documents/jobs.v4.json,sha256=Zpcq5aRYfaWjYO41ondbHkjDI7HNz4TavjLYS3VsmSU,140315
+googleapiclient/discovery_cache/documents/keep.v1.json,sha256=avjc36CvOcyxoG4r6QcJje64hibYAyiIFucNfE0DOlQ,16988
+googleapiclient/discovery_cache/documents/kgsearch.v1.json,sha256=RTtKW-qCqHcb5yMU13El8JDPynq3njx4KUcB0aCcid4,4886
+googleapiclient/discovery_cache/documents/kmsinventory.v1.json,sha256=hmkXXtRgf1e4aUxEholUzrRGGjzoIoxL3Ihcxckc-8o,33417
+googleapiclient/discovery_cache/documents/language.v1.json,sha256=GWpek8vonR_cMRiSyPUP0WAi9yd9tXjG8vk1LoAHCso,150941
+googleapiclient/discovery_cache/documents/language.v1beta1.json,sha256=-Nwsr0Ls6nKWMZSQ3ZzkW1Zdvu2gEqb6yt4r65Z1xOU,38558
+googleapiclient/discovery_cache/documents/language.v1beta2.json,sha256=i4OT7fpHq1yKRpzYBgklvY1M4DtYp9mpztNWW7PV39o,151762
+googleapiclient/discovery_cache/documents/language.v2.json,sha256=5E8KQCkyiR3_sSls5xoYj9Dsx3sB9CbVf_dNXUpCJ00,136779
+googleapiclient/discovery_cache/documents/libraryagent.v1.json,sha256=r8Ukq-OYLT9KfD5Ka0p4tt9Qld3YIbcVyIC8v7HIq6k,9898
+googleapiclient/discovery_cache/documents/licensing.v1.json,sha256=DXnSHi490f2Yjf8rgSj8rqpIhXZwtcfQroip3laa_6Q,15821
+googleapiclient/discovery_cache/documents/lifesciences.v2beta.json,sha256=fwSW5n_jM_D6Xy9WkvoQkYnRAEVpEawEeQouXVZPB3o,52343
+googleapiclient/discovery_cache/documents/localservices.v1.json,sha256=wFMEyrsNS_zg8NBjgVFvWw6IldhBeLSwITNwxitH5J8,18765
+googleapiclient/discovery_cache/documents/logging.v2.json,sha256=UNe8E3xtdZsuNZEr0nXziPHUliPVpM2Kx5z5vAZHM6w,432363
+googleapiclient/discovery_cache/documents/looker.v1.json,sha256=RVuNi_bsMBa98BCrrKPwtvv0pr1BjNMS1ykDD4hVW8k,59873
+googleapiclient/discovery_cache/documents/managedidentities.v1.json,sha256=Ki_dgmYOjecPamwnj9DPwaKEp5DGjszQkRPnUZ0ogY0,118265
+googleapiclient/discovery_cache/documents/managedidentities.v1alpha1.json,sha256=gfQ7Zoovvtt8kELkoKvnoadCKoehE1SPfutDaXHrsY0,118405
+googleapiclient/discovery_cache/documents/managedidentities.v1beta1.json,sha256=b0GvZCmfJ6hheQDOFn7oz4hK1X1gGg7L9S1ikvDxviU,119358
+googleapiclient/discovery_cache/documents/manufacturers.v1.json,sha256=SI8o88jd5dVuKKr72iOg6WQFZ2vLJkmdiA1dfyzroWU,39749
+googleapiclient/discovery_cache/documents/marketingplatformadmin.v1alpha.json,sha256=9U-A37At71-1QwTPmnexIldY9xNnpuVUrghlAmhglbs,12555
+googleapiclient/discovery_cache/documents/memcache.v1.json,sha256=9_tH5Vz3WAfX5Zi84NgEBsS5AiphjT9-GDP--86fv7k,63637
+googleapiclient/discovery_cache/documents/memcache.v1beta2.json,sha256=Co-QSQoo2sbqnSC5lj_2CkakM5Blt7kcknOEv_6BZds,65563
+googleapiclient/discovery_cache/documents/metastore.v1.json,sha256=ZD4LHoh9Qle2GkWZZB7DEuNPFwzZCTDK-6hume1cjGM,113796
+googleapiclient/discovery_cache/documents/metastore.v1alpha.json,sha256=YLlfXmaTDwuE5kUDWT7_xUtCnLhvNF980AAqMQ7ZcG4,145115
+googleapiclient/discovery_cache/documents/metastore.v1beta.json,sha256=VQCVgUZhZe85iKnsQJh3NsxUHNJVLj7QMGC0ghMJpj0,145009
+googleapiclient/discovery_cache/documents/migrationcenter.v1.json,sha256=SxtXu4-7ZwbcMi40IUgVy8reA3a_WY5wM_5n4FHSfxA,182766
+googleapiclient/discovery_cache/documents/migrationcenter.v1alpha1.json,sha256=8C_j1q_kDb59ibsYAZo0ksRkBJdXngvkq57WLUSxbFQ,228354
+googleapiclient/discovery_cache/documents/ml.v1.json,sha256=Wh9OqEl-bnJI_i9w59k96y9h6kpPrj6BWHgygEsW5EU,175515
+googleapiclient/discovery_cache/documents/monitoring.v1.json,sha256=yFpQ3fEoffghsnmHTcey0GFuRakMu0XDX79nnhuSg2U,104208
+googleapiclient/discovery_cache/documents/monitoring.v3.json,sha256=6LvIAZhiX1lNTCQ7xiX9HxDjGNCwoqdme6Fe7WfsbDY,331177
+googleapiclient/discovery_cache/documents/mybusinessaccountmanagement.v1.json,sha256=h1FtxaEAH-PwJ5Wc_k9eUA34Xvvk0PNAoWY67FZVZU0,31822
+googleapiclient/discovery_cache/documents/mybusinessbusinesscalls.v1.json,sha256=w_OnSvJZU62j-5J8o3Mt3CmA2Rk7_GKu5DuhsIV574Y,16209
+googleapiclient/discovery_cache/documents/mybusinessbusinessinformation.v1.json,sha256=RMYuXyqhw6-eg0DQFRb1I614GR28ql63TuNJF8-hg7I,65869
+googleapiclient/discovery_cache/documents/mybusinesslodging.v1.json,sha256=DY8MqeNbnWUbr3xJ0n9B1eHbDBOsgzMRfLRYjy9C_ZU,222585
+googleapiclient/discovery_cache/documents/mybusinessnotifications.v1.json,sha256=Q95_IaVJoFB4sV-15OW9cMw0HCY_vCcTTYXCHDG5bws,8029
+googleapiclient/discovery_cache/documents/mybusinessplaceactions.v1.json,sha256=iubPg8M1Zb1aEhTfO1mHCOqAWxd5KmoL3TJNeErbZJE,14578
+googleapiclient/discovery_cache/documents/mybusinessqanda.v1.json,sha256=OJ10AVNg5DAeEclWX1ZcQGPa7eZSP8d7PJBLk7BSck4,14263
+googleapiclient/discovery_cache/documents/mybusinessverifications.v1.json,sha256=XjJ7BFAd3JA0hsugsIfvmq0KxTL-5derLR2V-1KaEOg,25381
+googleapiclient/discovery_cache/documents/networkconnectivity.v1.json,sha256=qhB15p6WlOikLD2AFyKETIrZJpeZeAwtbiH_qXT3jaA,185724
+googleapiclient/discovery_cache/documents/networkconnectivity.v1alpha1.json,sha256=EXjWj0T6Kk1FF-TSUtCz0PSoY2AUfQ8OHv3Dlb2mW74,76295
+googleapiclient/discovery_cache/documents/networkmanagement.v1.json,sha256=7eVr8Tbw44kfvjL3Gvw62pzxEZLwxHazlSxmFUa213Q,113560
+googleapiclient/discovery_cache/documents/networkmanagement.v1beta1.json,sha256=XVux1wh88bO-__mDzekHy3TrjSLSXuaCJxBAgcypveA,123589
+googleapiclient/discovery_cache/documents/networksecurity.v1.json,sha256=iF-48MQregWBCoanytR64KAH4iSDPx2foxH3L6BMZVs,184919
+googleapiclient/discovery_cache/documents/networksecurity.v1beta1.json,sha256=cC7jTPGs2F7IfzTZqnJrxx02Zt-AYusLm7rwqLd57cg,185919
+googleapiclient/discovery_cache/documents/networkservices.v1.json,sha256=4nlWCgZ5tnTmbVM9akflqIJmaM766A_W0sBlebPWAYk,202812
+googleapiclient/discovery_cache/documents/networkservices.v1beta1.json,sha256=FZemjGjz3caFNqUDaWZYThp0navHirRX0-Rd-QzZ3aU,191376
+googleapiclient/discovery_cache/documents/notebooks.v1.json,sha256=ShpnK6u2qW331_52_40PTBraOHOdazbB88dJcDXlC38,158357
+googleapiclient/discovery_cache/documents/notebooks.v2.json,sha256=bvTtkinh12aJR_-38cV2za_yodGU1jQG0lJ1FN6XKNo,70455
+googleapiclient/discovery_cache/documents/oauth2.v2.json,sha256=qbqQUKMu6g1IrIHIAfYwTAZZgIDf8j69Lr6i-rzbzLs,6601
+googleapiclient/discovery_cache/documents/ondemandscanning.v1.json,sha256=LwwW3AErAvLhv0OmaDegjecIBUDTyvTgxZ_ky2dj1Ac,88252
+googleapiclient/discovery_cache/documents/ondemandscanning.v1beta1.json,sha256=5hrlenXF4hbTXqZi7luqKBbJIdOxf_pyxRY1kNNrPLk,88103
+googleapiclient/discovery_cache/documents/orgpolicy.v2.json,sha256=nJpMnJi8F-rvSY2mFBjkue3e7Aa0U0cYZBt1H1PO3mg,52064
+googleapiclient/discovery_cache/documents/osconfig.v1.json,sha256=QN9vW_-DVVogXzjcx-TBJCcMDUtiEokGNZaLXzWe5aw,135299
+googleapiclient/discovery_cache/documents/osconfig.v1alpha.json,sha256=HE4lNRktpkoGIcTadYZNtyyISQUZCm2hcpKQjx0faLQ,100049
+googleapiclient/discovery_cache/documents/osconfig.v1beta.json,sha256=CPcvZ2I--e6FJlOhAehQCAjDsXaXAbe3i58O98Zo7aE,82652
+googleapiclient/discovery_cache/documents/oslogin.v1.json,sha256=PhWS0Is39lrw-BLYo_HKpv2CnGHS9DUnGqeicHZoyMU,13069
+googleapiclient/discovery_cache/documents/oslogin.v1alpha.json,sha256=a2tUOAl2kD6t0H_CmmDSoqSEsINxfW3oAXEnTXhITQY,18548
+googleapiclient/discovery_cache/documents/oslogin.v1beta.json,sha256=QNtjUAh8_M3DjA7Y2wRrk7MqcIlJlmeGUIHC28o1ZKo,17672
+googleapiclient/discovery_cache/documents/pagespeedonline.v5.json,sha256=w6p-MXCBQlZSlj5DBAFPmm2CNbJuyy0eqqYQ5qTq630,27329
+googleapiclient/discovery_cache/documents/paymentsresellersubscription.v1.json,sha256=LMLYzsQ5-V751ZhL4ZlybZ_2V7aFMX1OAGuH6v6IopM,57682
+googleapiclient/discovery_cache/documents/people.v1.json,sha256=f7v9zj-wlYeggKzlOICFzEuj3zYVBZm3jdqgEIuIa7Y,112444
+googleapiclient/discovery_cache/documents/places.v1.json,sha256=PGrS0JsjuAI-aRFE5VwqwrIh3cJlqUZPfEE7MavouyE,71998
+googleapiclient/discovery_cache/documents/playablelocations.v3.json,sha256=wbkjdTm2IPCudHBKwwIOaAWwsRxfcinsOiKPR_C5G4M,25906
+googleapiclient/discovery_cache/documents/playcustomapp.v1.json,sha256=ULA2arfFC3Zg7xsct0XoM1nA8zE2jxGBMpW8uH8c5fU,5201
+googleapiclient/discovery_cache/documents/playdeveloperreporting.v1alpha1.json,sha256=NGTtpuISnR5I912qujw7n4RI6uwtlL1MWS1LZKyz4jk,137477
+googleapiclient/discovery_cache/documents/playdeveloperreporting.v1beta1.json,sha256=2brata3G0_PsRMQuVHiLDVMkwx0iTp29X-YoSh-chv4,137283
+googleapiclient/discovery_cache/documents/playgrouping.v1alpha1.json,sha256=GsOLflUeu9Bo0iWu4ZvE_4aEswUVXF0k-SM5Qe7Dw3U,6307
+googleapiclient/discovery_cache/documents/playintegrity.v1.json,sha256=Srng1NjAAAaLlI1jDNb4EWdh0U8zKNc-sJreyODgeZE,14877
+googleapiclient/discovery_cache/documents/policyanalyzer.v1.json,sha256=vy3fYRZY1Y4VzyBDR-RYzRpXKkQTwvX-KhBgZdNSOP4,7177
+googleapiclient/discovery_cache/documents/policyanalyzer.v1beta1.json,sha256=NsndMhEhOkDiTYP0mEG-XM79cA_CNWMZb5nU3dzqA8Y,6796
+googleapiclient/discovery_cache/documents/policysimulator.v1.json,sha256=caLAb_ItssbZBicNCvz1RnGs961snHThWpGt7aLvUXE,109531
+googleapiclient/discovery_cache/documents/policysimulator.v1alpha.json,sha256=cayenRWNSgEyUyv-nrG2QAoVNCrJNiigqNyz6DD7-Kg,114024
+googleapiclient/discovery_cache/documents/policysimulator.v1beta.json,sha256=G-g0f7-_IHBSKwncR8GxixcqrHixhkhE9xmYDGFT3RE,113900
+googleapiclient/discovery_cache/documents/policysimulator.v1beta1.json,sha256=Q1ufGYQSG04J4ufoZ0JH4hgwdeN1QeW1dhREOv-b0Pw,54107
+googleapiclient/discovery_cache/documents/policytroubleshooter.v1.json,sha256=NpA0E8hJD9jaCi1CcaiZkQ49SblOsoGp4E3LrzclBoI,31718
+googleapiclient/discovery_cache/documents/policytroubleshooter.v1beta.json,sha256=vRHb1i9YtSGMHW-qs2cpqLD6uPSMGNmuf2YHbLIWOxw,30156
+googleapiclient/discovery_cache/documents/poly.v1.json,sha256=MI1zdlmWLLalpCwlx22n33nkszug6pksZb9_1x96K90,27091
+googleapiclient/discovery_cache/documents/privateca.v1.json,sha256=OwA4eDhrsog9OhXBgYke_EBsfl9_ZGyw28mP0SVRXyk,147758
+googleapiclient/discovery_cache/documents/privateca.v1beta1.json,sha256=5Ij0dWFrYeAa4IKVRsuZ9a02IrPLXfVrTY0i0WCxsqE,44001
+googleapiclient/discovery_cache/documents/prod_tt_sasportal.v1alpha1.json,sha256=Bi597GZeHBuZ4EUv-1RAl21qmgzaOurvcfi7GEH0ISQ,99944
+googleapiclient/discovery_cache/documents/publicca.v1.json,sha256=WaAwIdQ8V8GO9ES7qVS1hoi3SjUvn5e5IWsCVVL1MwQ,4849
+googleapiclient/discovery_cache/documents/publicca.v1alpha1.json,sha256=uD2JXP3gSuwngrhyXh5UUu_xj6VmHBivV_FkTtdgqoo,4873
+googleapiclient/discovery_cache/documents/publicca.v1beta1.json,sha256=aiprKq74emxgJifHERnxlxvjiBeIlUncuarkpB9G6qo,4869
+googleapiclient/discovery_cache/documents/pubsub.v1.json,sha256=lEUPmpM6dt28lBpLMzZggS8R0lh4yUCS_yQ1tbUcMbs,116460
+googleapiclient/discovery_cache/documents/pubsub.v1beta1a.json,sha256=z6Z8F5VgDgYDVlVHADkVWE61-THOBw9VYuuWFOpQE7k,24620
+googleapiclient/discovery_cache/documents/pubsub.v1beta2.json,sha256=ALw_rBsgAND8R8XTWRIUEjT320qlaT6aZGqJSoJKn6Q,49730
+googleapiclient/discovery_cache/documents/pubsublite.v1.json,sha256=KDurMFb1r12JdwBMC2U_ZI-LJ4yl2y9IqVBtW-ZxeQI,53050
+googleapiclient/discovery_cache/documents/rapidmigrationassessment.v1.json,sha256=nmv-1cxInZgESzodRzd5vSR9yiAoWE2Le4QhvtsfXV8,32479
+googleapiclient/discovery_cache/documents/readerrevenuesubscriptionlinking.v1.json,sha256=jf_ChB3wKJx4STYplH5t7zXtc97zoA3TAtscaNLG-NM,8887
+googleapiclient/discovery_cache/documents/realtimebidding.v1.json,sha256=R28zNja5bfcExSqFsOItdN2Pq1RetbyIvu4aSxWPW9g,117315
+googleapiclient/discovery_cache/documents/realtimebidding.v1alpha.json,sha256=0aZYwk8L6hmk_xVK_rr4BwT4FPEn56oiZWKVqin92rs,18365
+googleapiclient/discovery_cache/documents/recaptchaenterprise.v1.json,sha256=uefaP7lNEKKiE09eafyZwsyCrpKyQUHlSSzb0lsb6m0,85673
+googleapiclient/discovery_cache/documents/recommendationengine.v1beta1.json,sha256=bDNAUHQN_6xevgIFaFHNL7XZe5wzaqL3KdbVRV6UAKU,87898
+googleapiclient/discovery_cache/documents/recommender.v1.json,sha256=RybtWD8yn_TiRBuhjvNl4rhuKV1_LwqOnfKF7Lqmk-s,98475
+googleapiclient/discovery_cache/documents/recommender.v1beta1.json,sha256=0x8DZMNLyNSu0YwRAMkNN4KiVxfEjWyOIjR7uozI3gg,110056
+googleapiclient/discovery_cache/documents/redis.v1.json,sha256=skxcrcbrcpoT52PVmq_InZqIfi37hVUSPn4gNJ0kZrI,112580
+googleapiclient/discovery_cache/documents/redis.v1beta1.json,sha256=V5ylLMk49zFw0Vjg1j74ePJYCiPi2SJdrM2yg1v6ieo,113386
+googleapiclient/discovery_cache/documents/remotebuildexecution.v1.json,sha256=7GFLt5IiI_-OYe68YsVR99EYWAZbRDdQ7MBSu2yU8n4,117609
+googleapiclient/discovery_cache/documents/remotebuildexecution.v1alpha.json,sha256=hSDoD01FhwXYIVbrOwSe7cLI19DoN1AwZm4ylBQzTgU,124864
+googleapiclient/discovery_cache/documents/remotebuildexecution.v2.json,sha256=EII61EfJ8sqYPcx-Ilk5j-XosxGTIfrN48mLKLkGfnQ,148991
+googleapiclient/discovery_cache/documents/reseller.v1.json,sha256=eLgnI56mvKGtsgyzVjiwuCVe8m8HAQTT7TihkC3Bq1k,48941
+googleapiclient/discovery_cache/documents/resourcesettings.v1.json,sha256=44z-FvjlHqVXTJK2pNB36GJz1wnRV_D87dIu8Xo3ZJg,22202
+googleapiclient/discovery_cache/documents/retail.v2.json,sha256=8izbWvRNciFVS5PxtBl2Mqo-5T6XFgZrXOBWx39jCMs,351059
+googleapiclient/discovery_cache/documents/retail.v2alpha.json,sha256=QW_gUYKhAwz7be745ruyrrYNbkpYJzyiR-samITDKgo,392443
+googleapiclient/discovery_cache/documents/retail.v2beta.json,sha256=zo-JfGGssPXzUaclgNv_aB2MDhlMM4i2CgN_0-Q3O28,360230
+googleapiclient/discovery_cache/documents/run.v1.json,sha256=jlvy_juyTN3ATU6ivtZQL3fMbyBcWVragTvpHCHuYS0,233386
+googleapiclient/discovery_cache/documents/run.v1alpha1.json,sha256=Z0H_iXudGt7JDmcS4XZx09xCSBXPBv9MCktQqrAiayA,69965
+googleapiclient/discovery_cache/documents/run.v1beta1.json,sha256=huF9CDeN1HdW5tai_neIoAPtXOqg1t_KxstLag14WiE,40411
+googleapiclient/discovery_cache/documents/run.v2.json,sha256=-J4kcBmv03UaRsnebqUiKaAg4IsDyf9fk0K4bxRC_Y8,209863
+googleapiclient/discovery_cache/documents/runtimeconfig.v1.json,sha256=LNnedcvXM-IHsiOw5FLXE0Hrxsji2lt4Y7SD7fvSvLk,10287
+googleapiclient/discovery_cache/documents/runtimeconfig.v1beta1.json,sha256=eHHOGPu8bKwL5BEE7k2mAsi5gbC_p-3gGySW-WKZm8A,55381
+googleapiclient/discovery_cache/documents/safebrowsing.v4.json,sha256=Z4MCF0QUjpZUy_daSQuJmq5a07L0HBVk53PEaiNG7jg,38346
+googleapiclient/discovery_cache/documents/safebrowsing.v5.json,sha256=-0oFcWhPT-HmAv9wb-u4b2aSKZmtVg7w4bfe2FUOhOs,9390
+googleapiclient/discovery_cache/documents/sasportal.v1alpha1.json,sha256=itVzXCjWsEoUNTUD0z4xhFCeYiJesgVsJ0dK80aXmrw,99199
+googleapiclient/discovery_cache/documents/script.v1.json,sha256=u5y91--SNQad7zvJG9P6hMz-wREwUjbR8_XqCZnS2Kk,52104
+googleapiclient/discovery_cache/documents/searchads360.v0.json,sha256=AY45erCOpR4bkDKTJ8311ZY4rxaQQa1JQqdRSRj7SYg,318175
+googleapiclient/discovery_cache/documents/searchconsole.v1.json,sha256=FdKdNpBCVIIjgwmpgWIMczVglZ123PzicUaD2H3UGZU,40068
+googleapiclient/discovery_cache/documents/secretmanager.v1.json,sha256=Ssy2u_cZb7hAGwGxaZzO6qqGWHfzYCHUbUmiBPNbytk,71535
+googleapiclient/discovery_cache/documents/secretmanager.v1beta1.json,sha256=a9lHPOS0gmz1TqmMZTSlQw3f7kJYiDZA6K8SqHZVwGY,43358
+googleapiclient/discovery_cache/documents/secretmanager.v1beta2.json,sha256=CzW-mt9GW0P1UFwF6O3gq-HwfbpZKBgyIajGsMTQMgQ,71863
+googleapiclient/discovery_cache/documents/securitycenter.v1.json,sha256=Pqu1xT3Y-bklSPLYLzmplgZZqRh7MFsrwRjZm23bV_4,528902
+googleapiclient/discovery_cache/documents/securitycenter.v1beta1.json,sha256=L3aKPB1-H8_4V4qnfZNJDXWFrKO9mUa_eCUWZAkpJ68,291712
+googleapiclient/discovery_cache/documents/securitycenter.v1beta2.json,sha256=AbGxQ-L8SgbxOiyradi2nMmp3DRDW0yZDbqjQbOZoQI,311090
+googleapiclient/discovery_cache/documents/serviceconsumermanagement.v1.json,sha256=1Cmugls7pl8EvIpeUCg6YE3zbmzIMAUW6QI3Akcygjs,157101
+googleapiclient/discovery_cache/documents/serviceconsumermanagement.v1beta1.json,sha256=eS_DXuzRnW8l5dtKiWvDEJOMTKeTy6ePwPTgexinwyo,154289
+googleapiclient/discovery_cache/documents/servicecontrol.v1.json,sha256=AhvjjgaPH7hRBRnqA4qf0leXiU-ljKwFME6iYXWirEQ,96203
+googleapiclient/discovery_cache/documents/servicecontrol.v2.json,sha256=H0O68umvWKS3OxEkiEu-iNOWCNSLwHit2tWfBy__96g,52485
+googleapiclient/discovery_cache/documents/servicedirectory.v1.json,sha256=p7_qrNvZ7UCSuVlAlLC29pSY7-6MA3CfgS60N_bizcg,54213
+googleapiclient/discovery_cache/documents/servicedirectory.v1beta1.json,sha256=XDkv79GmbfcwoHXAeK8Z9Uhvl0APKvxbjSB8vX4ltV8,58637
+googleapiclient/discovery_cache/documents/servicemanagement.v1.json,sha256=U3YYDDdaFHNFIytagGg-Z-B-CRLRLZnXdrImQMDEadM,177891
+googleapiclient/discovery_cache/documents/servicenetworking.v1.json,sha256=l2MTxLtep9gFli3Q-b0u-aDIFM68IQ3AD2ia04uH98M,191187
+googleapiclient/discovery_cache/documents/servicenetworking.v1beta.json,sha256=ZJcxnOSoE1YPd12jGWRw-sh3lVCJBN_EYWpoc52I8u0,144470
+googleapiclient/discovery_cache/documents/serviceusage.v1.json,sha256=EeN-938FrT_2oz47HaHzEJk7L5IsfwB2YTuaadsQKNo,153842
+googleapiclient/discovery_cache/documents/serviceusage.v1beta1.json,sha256=QPFzM8t9utRxuwtyLt6Le1KQvfxwYxekmNvoPnEjK1g,191442
+googleapiclient/discovery_cache/documents/sheets.v4.json,sha256=WtAHoB46FwLH5gptrTpXA3KR-rl9vPd3Q7qNiM0Ipxc,285540
+googleapiclient/discovery_cache/documents/siteVerification.v1.json,sha256=xvq_xsL575_6zsUckW9eo-jWWdxW6Ng13g8ohB2uGLA,8419
+googleapiclient/discovery_cache/documents/slides.v1.json,sha256=dQcdX3sY3h7lYeQlBll9NMhCaCibXynRYkvPyAOV7KY,184797
+googleapiclient/discovery_cache/documents/smartdevicemanagement.v1.json,sha256=x-he8k8QOsMqVSCLPLhX_psGjCtveVrcdBgeIbqUTGs,12914
+googleapiclient/discovery_cache/documents/solar.v1.json,sha256=JvHqM7ey-biOQCw1fEfUUlu88CSxDklcGM7VfLzk7cs,35899
+googleapiclient/discovery_cache/documents/sourcerepo.v1.json,sha256=c_9cZaYPE0nidci1W7MG74gohq7RoV8dMAWYjKxgO6U,38279
+googleapiclient/discovery_cache/documents/spanner.v1.json,sha256=juU_V0xNG21cS5lS_IUvk7GPLD80NUCuzHsGXu123m0,308342
+googleapiclient/discovery_cache/documents/speech.v1.json,sha256=HT3Rl3NB8lEil1VEpNlejmFggTiNqd83_VUZwuwyHqs,62992
+googleapiclient/discovery_cache/documents/speech.v1p1beta1.json,sha256=CcDgepnsKfjJbc8bOB-Nby3_58_NvcaqnitBeXtpCYc,64146
+googleapiclient/discovery_cache/documents/speech.v2beta1.json,sha256=uKUcKcn6zNl_egbyhzSYNTlr_o2tpGelQ0WctfRAU54,18493
+googleapiclient/discovery_cache/documents/sqladmin.v1.json,sha256=mlQNQRMbMGzFA1jfvc13wBreUvRws-qwEHKlryzO3Eo,181426
+googleapiclient/discovery_cache/documents/sqladmin.v1beta4.json,sha256=xweVvmXSn8JRG9nBtGokCuaJSP41BRUBPycOri--rMw,182758
+googleapiclient/discovery_cache/documents/storage.v1.json,sha256=WLgvJT3aXgQAwOWzweiD9QRPIcRVQyGwgpoG8FwKmYE,175223
+googleapiclient/discovery_cache/documents/storagetransfer.v1.json,sha256=Xla6XuMYw_8ygSyntr_leWcpKYk9Wh1cjUUUPuRwB4A,82191
+googleapiclient/discovery_cache/documents/streetviewpublish.v1.json,sha256=R6ixCaZBcZGAS3Jbhb5IEDhiAnGlz0Nq8XJd92rl190,48408
+googleapiclient/discovery_cache/documents/sts.v1.json,sha256=GlzlQc7qedqpW1xGm6j9T258AUl_ZPwJ9sFzgB9zt0A,27586
+googleapiclient/discovery_cache/documents/sts.v1beta.json,sha256=oMH617n3cmmsc8_PSypn5a-7XvGVJ5lOQnJE8696tGM,26725
+googleapiclient/discovery_cache/documents/tagmanager.v1.json,sha256=bk2w7PpTSN6VXdtqJKZg1ff0lpj0beMM7qevjJiG5W4,90841
+googleapiclient/discovery_cache/documents/tagmanager.v2.json,sha256=fKHEp2oTpZRKuS5HMgF1bBALP1zeF2Z7drvVrdXaUvs,181799
+googleapiclient/discovery_cache/documents/tasks.v1.json,sha256=Zem6um7WgSygBMOOaDFiU5n2tfHZ9T80P1xfWP0jaNU,18607
+googleapiclient/discovery_cache/documents/testing.v1.json,sha256=A0t_C-TY9XvVPvt3mJLSBD9N7JwzyhdxM9iJIwOGrtY,95617
+googleapiclient/discovery_cache/documents/texttospeech.v1.json,sha256=uVY2hBVo3JPGtuKCTHPImpaIj6H7QcgFdsGPJcT1D5M,24645
+googleapiclient/discovery_cache/documents/texttospeech.v1beta1.json,sha256=zGmU1w3TaFH4s_NbUP4-vl7nWS5WE4ml30OMQpHvuRc,23486
+googleapiclient/discovery_cache/documents/toolresults.v1beta3.json,sha256=p101nwpXOofvJLRUXXugMKjpUUdTzZlT5M2o_AUag44,129534
+googleapiclient/discovery_cache/documents/tpu.v1.json,sha256=2TzAhsBd6Ix2zutqEJevQaI3i9oblJJmxkesrpnB_10,32111
+googleapiclient/discovery_cache/documents/tpu.v1alpha1.json,sha256=YhRpvjqjazgOLVFC3rFuaaMeZBGCXCpVvCZYxfBmrLI,32526
+googleapiclient/discovery_cache/documents/tpu.v2.json,sha256=BQIK1E21LoPNcsKKA3l2zy25RhHdkU0eN3taiP5ncCg,55158
+googleapiclient/discovery_cache/documents/tpu.v2alpha1.json,sha256=j6T-aAg3lsT18cAlwx2HJQieGTmvePC4yQa_p44OaMI,61101
+googleapiclient/discovery_cache/documents/trafficdirector.v2.json,sha256=7GKYsdmh7wpT3heiauo5y4k6_sgxgVM_tvZTDhaCn5I,32631
+googleapiclient/discovery_cache/documents/trafficdirector.v3.json,sha256=xeQ9ZQv1NivKmRoI4WgzTBp-njmF_h0WMYYjNU53r4Q,49583
+googleapiclient/discovery_cache/documents/transcoder.v1.json,sha256=7zWYZqG1ZW7Vi-gKqYqAcHKM5yLdXcsrW1IBRvLY_sk,68163
+googleapiclient/discovery_cache/documents/transcoder.v1beta1.json,sha256=nj-9u_qqRm_1H3tlaTpWZ2AEkXlgI6uIzwTqj7DZQYg,60514
+googleapiclient/discovery_cache/documents/translate.v2.json,sha256=uIVhWVyniBow5R6_BxTdei59xpeUcu2hPy_fLyX8Jig,11984
+googleapiclient/discovery_cache/documents/translate.v3.json,sha256=IS1nRKcZfKmmTcfFMmdSFd5DGU-zAe_u1rplTHcZ-c4,116367
+googleapiclient/discovery_cache/documents/translate.v3beta1.json,sha256=8AaFbe9mveBZhgPX1dDxLgHen3ggLED-Jca-aXTHq5Y,68419
+googleapiclient/discovery_cache/documents/travelimpactmodel.v1.json,sha256=VlFMqCaSOo99WeN7hm44SVlK80rsyt09hbvTiIGn29g,9908
+googleapiclient/discovery_cache/documents/vault.v1.json,sha256=wonGNWtSgbte4UH18-NUi07O2xPvb6fDgCH4p8tA6no,74281
+googleapiclient/discovery_cache/documents/vectortile.v1.json,sha256=ox05W0ZLG7Yn-6uUQOP3yeXgibQfaQ6tqA6iv865DQg,47652
+googleapiclient/discovery_cache/documents/verifiedaccess.v1.json,sha256=PNqTY_HJrsKlR_wOdkkcn-RQtKdLWvMZ3FNYYpo1KUQ,6762
+googleapiclient/discovery_cache/documents/verifiedaccess.v2.json,sha256=WGRwxgmL3jmMvGP7K1hXUZvOJEkzHAiwTfzN8LCo5Mw,17322
+googleapiclient/discovery_cache/documents/versionhistory.v1.json,sha256=yImVV5wWtg7ihhRHwYfhZeX1LbulG43uxWkejLm_iL0,17093
+googleapiclient/discovery_cache/documents/videointelligence.v1.json,sha256=Tqwd4LocY3eSaTN5quoruLA-_PlVq2hu0wJOKOBTwes,177769
+googleapiclient/discovery_cache/documents/videointelligence.v1beta2.json,sha256=KJuxW7tCTVXurcvOGiJh6_Wc37mh-k7mi9L4LwsZWK8,169935
+googleapiclient/discovery_cache/documents/videointelligence.v1p1beta1.json,sha256=FHOfk53CJT7Gj_1J1qOuK8YVqivls5_5n_caXDhywzQ,170011
+googleapiclient/discovery_cache/documents/videointelligence.v1p2beta1.json,sha256=Y1dLpEYizHEsEbbWPsT26OtXCoPIsPuX-WIhQzeoDa0,170011
+googleapiclient/discovery_cache/documents/videointelligence.v1p3beta1.json,sha256=Hc_6jRFkEurRWWYi0NvOHVeZAV3sX2zw4G_JY-PCZCE,170062
+googleapiclient/discovery_cache/documents/vision.v1.json,sha256=uAweS2gj1A4P4Qk8TVh2H7bRpI5qO2M9S48IS9h5_qE,312498
+googleapiclient/discovery_cache/documents/vision.v1p1beta1.json,sha256=YSh_SzxIAA00BEF0H5Zzqd1L_BLyskt-zjKP27WVF0Q,277224
+googleapiclient/discovery_cache/documents/vision.v1p2beta1.json,sha256=Fk0rQGt-2HtC0sLoCdYBpQdhGI4AQyeTptG6EcBS8ZA,277224
+googleapiclient/discovery_cache/documents/vmmigration.v1.json,sha256=-QBllAJ4WMKBtmhuEfulp-C-ZCXGvL1F2LPwGSBd1Lg,176147
+googleapiclient/discovery_cache/documents/vmmigration.v1alpha1.json,sha256=Ax4KNVET_NbUVtqjLJ7SO5i7cKeHNaVlG_UfaQPIyew,183695
+googleapiclient/discovery_cache/documents/vmwareengine.v1.json,sha256=C6erzUK7m09h-a34UPGOMDpSBh5UQxYR1JTN6MBH8o8,252247
+googleapiclient/discovery_cache/documents/vpcaccess.v1.json,sha256=Sl78iEwycOM3X1ZHMDZSoeQnPZEFRq2wDIW_yJl87pU,21088
+googleapiclient/discovery_cache/documents/vpcaccess.v1beta1.json,sha256=okYxxzBNGVOUDgvujLnxP52Q559T4HKdaPV_V9l3tJw,21487
+googleapiclient/discovery_cache/documents/walletobjects.v1.json,sha256=yaoFmslhm6lsUm0FjzIna7nqQ8zeOjpPa2Mx8C_jEdA,318186
+googleapiclient/discovery_cache/documents/webfonts.v1.json,sha256=yvoGwzwJJeFg_AMSX0rRci4X9yhjOK7BSD4NSog1BEI,6169
+googleapiclient/discovery_cache/documents/webmasters.v3.json,sha256=TOTCcpZyUk-dbmnjFVFoQam0hq2wFQg2UV9x-4fuVLY,20097
+googleapiclient/discovery_cache/documents/webrisk.v1.json,sha256=nTIcFtYnBgE5f78fZueJvNrA5F4gWQJ5bkwtP8_sW9o,26586
+googleapiclient/discovery_cache/documents/websecurityscanner.v1.json,sha256=wn-E_umxen1h1CdlJBVhcKLvidR77ap3Grf8I1xQUXE,44164
+googleapiclient/discovery_cache/documents/websecurityscanner.v1alpha.json,sha256=OoH7QKYju9cBxzy4NT_em3M7mh-INBMSSMukpo4qOyY,36660
+googleapiclient/discovery_cache/documents/websecurityscanner.v1beta.json,sha256=L_PwwvdfIh1CZjlkKv3id9xlpg1scqHZ5aXP-atMZmU,42878
+googleapiclient/discovery_cache/documents/workflowexecutions.v1.json,sha256=rVMpcal8SFd5IgVDRoaxL84MAuyF3uRfT2uhtio7OMw,35338
+googleapiclient/discovery_cache/documents/workflowexecutions.v1beta.json,sha256=BlRUv_7OJvlnVr7ln8KlQgrxwKlZBJ7JaDBLzXNKNxU,14318
+googleapiclient/discovery_cache/documents/workflows.v1.json,sha256=wDn2Mx2VlYjvRtYMMNL2XEW_5Ixz3Aasvope8883NHY,27276
+googleapiclient/discovery_cache/documents/workflows.v1beta.json,sha256=Q8KLpfkXzaesm4HzofVA--oLshk_4I4B9jMqhwpiiio,22461
+googleapiclient/discovery_cache/documents/workloadmanager.v1.json,sha256=T1T-qDNWF5vDqp9a3rbXVlvsO3EeuDUj_7VWeN3InK0,58140
+googleapiclient/discovery_cache/documents/workspaceevents.v1.json,sha256=L1zi20EZbMk17VO8e-i3MDV9q2EFD0-B7e_ZDw9e-8A,28251
+googleapiclient/discovery_cache/documents/workstations.v1.json,sha256=5JTyGNlV05z9_HDYtfg7Iu1wsYQk5QmYlqZP5WitVLA,97032
+googleapiclient/discovery_cache/documents/workstations.v1beta.json,sha256=qa48u6minJ6bkNeLpqTBADNXxSg32DKwt48JsSc3aFU,95804
+googleapiclient/discovery_cache/documents/youtube.v3.json,sha256=70yqNLUtgJtQP2xiSx0fG0it9f1Kx3dbdTzBWcvrhlk,370108
+googleapiclient/discovery_cache/documents/youtubeAnalytics.v1.json,sha256=KLPoKHO_XT4-LyIZjwSGh44f_htMwjePD2PXR8MH-YY,3220
+googleapiclient/discovery_cache/documents/youtubeAnalytics.v2.json,sha256=LYo5YVuKoeE4ObgdgySIIFjuHLGRXTGaaaMv1vZ6K3A,28888
+googleapiclient/discovery_cache/documents/youtubereporting.v1.json,sha256=j8s29o-UE4WoDfot-gUJiZQv3XgSMU82O3A998noKAk,23094
+googleapiclient/discovery_cache/file_cache.py,sha256=sim3Mg4HgRYo3vX75jvcKy_aV568EvIrtBfvfbw-044,4774
+googleapiclient/errors.py,sha256=9h3uimcMcczBHZJFWAX_YDABzJeJugWB0jmj11rp-LI,5460
+googleapiclient/http.py,sha256=ITE51oqDBqN1-AA5D-Tnlj3egGc_5O0V5xSzBw3UTKI,68241
+googleapiclient/mimeparse.py,sha256=wwouQMCjppTocJtiQhkkTa27kocYwlFRALL2z11Xo1Y,6530
+googleapiclient/model.py,sha256=qEsdqL3KuhQNGKIDxFzABxMNrejPIScDfJaScNNnffs,13322
+googleapiclient/sample_tools.py,sha256=hDBLJNwLluN6AGhaBR-3GXWDrOwRNPvXyseLOyz9l30,4315
+googleapiclient/schema.py,sha256=rR3u8WPQ_V8a7GCUsNuvtf6GxzwuMO0HaqsTBp3tnyM,10414
+googleapiclient/version.py,sha256=A2x7sRWqx71__v8NH_Cz5tQrJJKtUPJFqLN1wmVgb3U,599
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/REQUESTED b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/WHEEL b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..f31e450fda2866f274547bb723d784248069898a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.3)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/top_level.txt b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f907e7e175c8bc3cc7226dbe019836a82cefb1ea
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_api_python_client-2.127.0.dist-info/top_level.txt
@@ -0,0 +1,3 @@
+apiclient
+googleapiclient
+googleapiclient/discovery_cache
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/INSTALLER b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/LICENSE b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ 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.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/METADATA b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..e0785656a45ce3e859d5a744669cd34982b381dd
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/METADATA
@@ -0,0 +1,135 @@
+Metadata-Version: 2.1
+Name: google-auth
+Version: 2.29.0
+Summary: Google Authentication Library
+Home-page: https://github.com/googleapis/google-auth-library-python
+Author: Google Cloud Platform
+Author-email: googleapis-packages@google.com
+License: Apache 2.0
+Keywords: google auth oauth client
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: cachetools <6.0,>=2.0.0
+Requires-Dist: pyasn1-modules >=0.2.1
+Requires-Dist: rsa <5,>=3.1.4
+Provides-Extra: aiohttp
+Requires-Dist: aiohttp <4.0.0.dev0,>=3.6.2 ; extra == 'aiohttp'
+Requires-Dist: requests <3.0.0.dev0,>=2.20.0 ; extra == 'aiohttp'
+Provides-Extra: enterprise_cert
+Requires-Dist: cryptography ==36.0.2 ; extra == 'enterprise_cert'
+Requires-Dist: pyopenssl ==22.0.0 ; extra == 'enterprise_cert'
+Provides-Extra: pyopenssl
+Requires-Dist: pyopenssl >=20.0.0 ; extra == 'pyopenssl'
+Requires-Dist: cryptography >=38.0.3 ; extra == 'pyopenssl'
+Provides-Extra: reauth
+Requires-Dist: pyu2f >=0.1.5 ; extra == 'reauth'
+Provides-Extra: requests
+Requires-Dist: requests <3.0.0.dev0,>=2.20.0 ; extra == 'requests'
+
+Google Auth Python Library
+==========================
+
+|pypi|
+
+This library simplifies using Google's various server-to-server authentication
+mechanisms to access Google APIs.
+
+.. |pypi| image:: https://img.shields.io/pypi/v/google-auth.svg
+ :target: https://pypi.python.org/pypi/google-auth
+
+Installing
+----------
+
+You can install using `pip`_::
+
+ $ pip install google-auth
+
+.. _pip: https://pip.pypa.io/en/stable/
+
+For more information on setting up your Python development environment, please refer to `Python Development Environment Setup Guide`_ for Google Cloud Platform.
+
+.. _`Python Development Environment Setup Guide`: https://cloud.google.com/python/docs/setup
+
+Extras
+------
+
+google-auth has few extras that you can install. For example::
+
+ $ pip install google-auth[pyopenssl]
+
+Note that the extras pyopenssl and enterprise_cert should not be used together because they use conflicting versions of `cryptography`_.
+
+.. _`cryptography`: https://cryptography.io/en/latest/
+
+Supported Python Versions
+^^^^^^^^^^^^^^^^^^^^^^^^^
+Python >= 3.7
+
+**NOTE**:
+Python 3.7 was marked as `unsupported`_ by the python community in June 2023.
+We recommend that all developers upgrade to Python 3.8 and newer as soon as
+they can. Support for Python 3.7 will be removed from this library after
+January 1 2024. Previous releases that support Python 3.7 will continue to be available
+for download, but releases after January 1 2024 will only target Python 3.8 and
+newer.
+
+.. _unsupported: https://devguide.python.org/versions/#unsupported-versions
+
+Unsupported Python Versions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- Python == 2.7: The last version of this library with support for Python 2.7
+ was `google.auth == 1.34.0`.
+
+- Python 3.5: The last version of this library with support for Python 3.5
+ was `google.auth == 1.23.0`.
+
+- Python 3.6: The last version of this library with support for Python 3.6
+ was `google.auth == 2.22.0`.
+
+Documentation
+-------------
+
+Google Auth Python Library has usage and reference documentation at https://googleapis.dev/python/google-auth/latest/index.html.
+
+Current Maintainers
+-------------------
+- googleapis-auth@google.com
+
+Authors
+-------
+
+- `@theacodes `_ (Thea Flowers)
+- `@dhermes `_ (Danny Hermes)
+- `@lukesneeringer `_ (Luke Sneeringer)
+- `@busunkim96 `_ (Bu Sun Kim)
+
+Contributing
+------------
+
+Contributions to this library are always welcome and highly encouraged.
+
+See `CONTRIBUTING.rst`_ for more information on how to get started.
+
+.. _CONTRIBUTING.rst: https://github.com/googleapis/google-auth-library-python/blob/main/CONTRIBUTING.rst
+
+License
+-------
+
+Apache 2.0 - See `the LICENSE`_ for more information.
+
+.. _the LICENSE: https://github.com/googleapis/google-auth-library-python/blob/main/LICENSE
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/RECORD b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..9b878ac92aea014382bd027b019b2f6d46afd83a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/RECORD
@@ -0,0 +1,128 @@
+google/auth/__init__.py,sha256=wg5MWwRk8nfJFMmUMU2gLirrPdGe9NMwqLkdSwdFwE8,1639
+google/auth/__pycache__/__init__.cpython-311.pyc,,
+google/auth/__pycache__/_cloud_sdk.cpython-311.pyc,,
+google/auth/__pycache__/_credentials_async.cpython-311.pyc,,
+google/auth/__pycache__/_default.cpython-311.pyc,,
+google/auth/__pycache__/_default_async.cpython-311.pyc,,
+google/auth/__pycache__/_exponential_backoff.cpython-311.pyc,,
+google/auth/__pycache__/_helpers.cpython-311.pyc,,
+google/auth/__pycache__/_jwt_async.cpython-311.pyc,,
+google/auth/__pycache__/_oauth2client.cpython-311.pyc,,
+google/auth/__pycache__/_refresh_worker.cpython-311.pyc,,
+google/auth/__pycache__/_service_account_info.cpython-311.pyc,,
+google/auth/__pycache__/api_key.cpython-311.pyc,,
+google/auth/__pycache__/app_engine.cpython-311.pyc,,
+google/auth/__pycache__/aws.cpython-311.pyc,,
+google/auth/__pycache__/credentials.cpython-311.pyc,,
+google/auth/__pycache__/downscoped.cpython-311.pyc,,
+google/auth/__pycache__/environment_vars.cpython-311.pyc,,
+google/auth/__pycache__/exceptions.cpython-311.pyc,,
+google/auth/__pycache__/external_account.cpython-311.pyc,,
+google/auth/__pycache__/external_account_authorized_user.cpython-311.pyc,,
+google/auth/__pycache__/iam.cpython-311.pyc,,
+google/auth/__pycache__/identity_pool.cpython-311.pyc,,
+google/auth/__pycache__/impersonated_credentials.cpython-311.pyc,,
+google/auth/__pycache__/jwt.cpython-311.pyc,,
+google/auth/__pycache__/metrics.cpython-311.pyc,,
+google/auth/__pycache__/pluggable.cpython-311.pyc,,
+google/auth/__pycache__/version.cpython-311.pyc,,
+google/auth/_cloud_sdk.py,sha256=u7tbE3KdHBCzZK8ka47xG3CHHtF0DhFDjmPSgz8lwXg,5212
+google/auth/_credentials_async.py,sha256=bHB28wMULOIEMmYqKEOU06A4co7uIXPcnfVC_TaA6KY,6802
+google/auth/_default.py,sha256=gULLKwjyw_JP_zgab9YkLww4QATthRjo13newNZ0Zgk,28538
+google/auth/_default_async.py,sha256=r4bFozWfioQa4lIEC-psuRsLiVhnJbuW-uQ0daj7s3Q,11575
+google/auth/_exponential_backoff.py,sha256=YEuEn2SzAvoPoesLnGdAKwLKipsdnQQl-R0Qh7v64T8,3903
+google/auth/_helpers.py,sha256=7Zm-uwaZWyFb3fE2JQA-sJUTSBvltTgZkNkMGc7raRo,8236
+google/auth/_jwt_async.py,sha256=5mGab5CkdnBMkQkS4mtNkwFkktp1jBw6G1sYQk8bYKY,5972
+google/auth/_oauth2client.py,sha256=hPxcl_8q6Oxr0hOHPUWaWObxI85Pv-0q6kZhRUrT5oY,5855
+google/auth/_refresh_worker.py,sha256=7apJkFsD9oL1yz1K7O8v-YN3f3TdNBiJdd7_Wmq6zpE,3375
+google/auth/_service_account_info.py,sha256=KGruc_OxS7O7_EADD4JEIjjz_-5Xa1_rlgk1t0p1nvk,2816
+google/auth/api_key.py,sha256=PeieTYceHJIFCo0zQo1EA9NEDL_Ie6S78qmD-6Ig17s,2583
+google/auth/app_engine.py,sha256=LuEaoWM1UwcIUJ6OrLza0tTpqJBXbtzZ3XjN0C-6Wvk,6121
+google/auth/aws.py,sha256=2V5NLhboorkPLLwnA87VuyH9imruake6qhyHKV_rVYM,34568
+google/auth/compute_engine/__init__.py,sha256=BqeTka-oyHFATkys3SGKRlOyWQ8mVV0vVaP2hOwV4Qw,910
+google/auth/compute_engine/__pycache__/__init__.cpython-311.pyc,,
+google/auth/compute_engine/__pycache__/_metadata.cpython-311.pyc,,
+google/auth/compute_engine/__pycache__/credentials.cpython-311.pyc,,
+google/auth/compute_engine/_metadata.py,sha256=Uy-j_ru8qRU4WmvshXxf1tnHN8D2BVyj-839VgBiydQ,11848
+google/auth/compute_engine/credentials.py,sha256=aGdb_LlDv0iDAuW4InStICvxsPN222x4hc-x6HYTPQk,18760
+google/auth/credentials.py,sha256=QhGHUljYgSlBTqrlo9g_pAxyHV2TlMTxZMsYnOSXEMM,18516
+google/auth/crypt/__init__.py,sha256=xxBMOPuzD-XOxPvzkleLa2oj4u-9FSjnFmUN3PBk00s,3324
+google/auth/crypt/__pycache__/__init__.cpython-311.pyc,,
+google/auth/crypt/__pycache__/_cryptography_rsa.cpython-311.pyc,,
+google/auth/crypt/__pycache__/_helpers.cpython-311.pyc,,
+google/auth/crypt/__pycache__/_python_rsa.cpython-311.pyc,,
+google/auth/crypt/__pycache__/base.cpython-311.pyc,,
+google/auth/crypt/__pycache__/es256.cpython-311.pyc,,
+google/auth/crypt/__pycache__/rsa.cpython-311.pyc,,
+google/auth/crypt/_cryptography_rsa.py,sha256=o2QTRkfDRLtEBiq-fbpbTWypvxaxUDwzlx2NpXG9o0w,5158
+google/auth/crypt/_helpers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google/auth/crypt/_python_rsa.py,sha256=L0kgvPXVdEGhajzxLRIgdk2T9rY0nlThrSlSz8Hc8XY,6123
+google/auth/crypt/base.py,sha256=3CJrnQsppR6h-WnTRqSrt1hPEQVkHcwNIVJ_B5M00hY,4190
+google/auth/crypt/es256.py,sha256=hXyeia3g6_TZf-UYdZVzFKgbPrLlgSuR1mMvYKSYqbg,6251
+google/auth/crypt/rsa.py,sha256=QI17aKQsX3gdbJkBef-zsm-X_YBjBollCaoA65Am-WI,1109
+google/auth/downscoped.py,sha256=KmmC8lbBWUFUsIYt1VpcbTXs3yYJYXteH19qdZQgobA,21793
+google/auth/environment_vars.py,sha256=ML9aFh5gwRStBDjn8BQSQHyWsA-OcMn-RB5FRMM8qOw,3297
+google/auth/exceptions.py,sha256=OeM4KgN0GVHUq8XTfagIwXqPpYXc4zvtK9Eptw8bi50,2962
+google/auth/external_account.py,sha256=PBoJ3hkv58uNpSsFnWI4HfObM7SOz8a9iGyZuULYeTw,24130
+google/auth/external_account_authorized_user.py,sha256=OeoI8FpoG9u1LDyHnZreVmlI_z-uDeWL_CBIEBC2sCI,13562
+google/auth/iam.py,sha256=-Pij0ZsUwU43rn7f9uWsYCss8p_4ER1oJu437mamWUI,3651
+google/auth/identity_pool.py,sha256=zN0xDa2IfPU8_At5uGBFVYwWra8xHpuFZLSOBfz3ZgA,16011
+google/auth/impersonated_credentials.py,sha256=BiSYO_F3UvEIsM9z-J1onX0ubMDW4RKasHktnICuku4,16975
+google/auth/jwt.py,sha256=1m_arp5x-4I5UTDaK9y50PSlKnUhnSKFyJW95k3-7cQ,31096
+google/auth/metrics.py,sha256=wx3m95QQCF885wYvPL4T01CHOdCBN5JvFCtbOakd98Q,5614
+google/auth/pluggable.py,sha256=iCqevwmAs8MJ0OdlxnlFFmHDxthNpqVIQXTKjnTyN8E,17306
+google/auth/transport/__init__.py,sha256=Bc9Tx4qozvP1g1USD8pvk7NEVE6hgXrpO-FH2WQFkkU,3621
+google/auth/transport/__pycache__/__init__.cpython-311.pyc,,
+google/auth/transport/__pycache__/_aiohttp_requests.cpython-311.pyc,,
+google/auth/transport/__pycache__/_custom_tls_signer.cpython-311.pyc,,
+google/auth/transport/__pycache__/_http_client.cpython-311.pyc,,
+google/auth/transport/__pycache__/_mtls_helper.cpython-311.pyc,,
+google/auth/transport/__pycache__/grpc.cpython-311.pyc,,
+google/auth/transport/__pycache__/mtls.cpython-311.pyc,,
+google/auth/transport/__pycache__/requests.cpython-311.pyc,,
+google/auth/transport/__pycache__/urllib3.cpython-311.pyc,,
+google/auth/transport/_aiohttp_requests.py,sha256=OWl0SAygFICdOp33rpauBlcmeo0z4N64p4-GBMyjmOc,14554
+google/auth/transport/_custom_tls_signer.py,sha256=E0bfybQJanDnfq9nfcY8d0k2vxFMOV0s05h1GYlEd9w,9680
+google/auth/transport/_http_client.py,sha256=j7Amhmg-ipWztX3W5zOs2kJUFFuGCs0PhI7ZMAvle50,3706
+google/auth/transport/_mtls_helper.py,sha256=cClydxTEeXZXU8Z36LsmX4VYUjaBKjqZoAqiBrydDhw,9062
+google/auth/transport/grpc.py,sha256=59vVJbmvzpW61z0h1Z5xQa3ZMzCu4G3wLYQrAtHFpAk,13937
+google/auth/transport/mtls.py,sha256=-QZN3xe9Jb7OGQ_4Qv_GtyZuRvbRGPbBZEdRjgdqFWg,3793
+google/auth/transport/requests.py,sha256=L0xLVrPaJvDJqqtGGauLRFCK5jXdBKAv29kM1e80h0M,22707
+google/auth/transport/urllib3.py,sha256=cQITCEXvu375iIP749bG5p96Sf2EVBsq63EbKRYkhTA,16049
+google/auth/version.py,sha256=I02L77ZU1zYFnHO98O72btm0ZMy633_FR2wkKYeiHkQ,598
+google/oauth2/__init__.py,sha256=IdFKxhIzlqNIalPgeB2P5hP6KkoxcpNk61hp7P2B85w,1196
+google/oauth2/__pycache__/__init__.cpython-311.pyc,,
+google/oauth2/__pycache__/_client.cpython-311.pyc,,
+google/oauth2/__pycache__/_client_async.cpython-311.pyc,,
+google/oauth2/__pycache__/_credentials_async.cpython-311.pyc,,
+google/oauth2/__pycache__/_id_token_async.cpython-311.pyc,,
+google/oauth2/__pycache__/_reauth_async.cpython-311.pyc,,
+google/oauth2/__pycache__/_service_account_async.cpython-311.pyc,,
+google/oauth2/__pycache__/challenges.cpython-311.pyc,,
+google/oauth2/__pycache__/credentials.cpython-311.pyc,,
+google/oauth2/__pycache__/gdch_credentials.cpython-311.pyc,,
+google/oauth2/__pycache__/id_token.cpython-311.pyc,,
+google/oauth2/__pycache__/reauth.cpython-311.pyc,,
+google/oauth2/__pycache__/service_account.cpython-311.pyc,,
+google/oauth2/__pycache__/sts.cpython-311.pyc,,
+google/oauth2/__pycache__/utils.cpython-311.pyc,,
+google/oauth2/_client.py,sha256=muJCQR_9FA3RpngNnpaAeaLfIwDFz-9X_udMDj0CrCc,17533
+google/oauth2/_client_async.py,sha256=CscoOhgVni9P6Xxy8a2BPGf_spxz_VAloIKvJqe6xfk,10480
+google/oauth2/_credentials_async.py,sha256=hUrucQkcYuYlyCdHMci8tzaVncnjQlFc2sAfNu5Dt8k,4474
+google/oauth2/_id_token_async.py,sha256=o_DViJoWMGlL3zwTbW2unGDBfY569D_VMB4l7bx-Qpw,10115
+google/oauth2/_reauth_async.py,sha256=C6k3f4T0aoVWItl8shYjOl5ngaoTJw3zKVhqHAeBXU0,11696
+google/oauth2/_service_account_async.py,sha256=5-HBGWoHhbWpCRbd34YiopQepEsEf8gSiuMlSm5hN84,5131
+google/oauth2/challenges.py,sha256=kGzZiSdQbvRFxnZnqHAlSOOcoEKNfatO1euJo40CAmY,7171
+google/oauth2/credentials.py,sha256=hXgCshPfbDMu-3VAbIfMugzFG-ggfhTnJVrTNWem9io,25809
+google/oauth2/gdch_credentials.py,sha256=CY6iPnPuc2OCIe1Zujwg1Mu9QSl1iGJqGOy6TkUleHw,9007
+google/oauth2/id_token.py,sha256=XxUfOR4Pb8QnLizNhwV9QB-JvEU7lFGoC3NWcqTvKgI,12067
+google/oauth2/reauth.py,sha256=neMOsDBYoDwJJuoaG7tKUZEb9NmzLVRQqWrwWwya2DA,12790
+google/oauth2/service_account.py,sha256=AHHyhEueL5Uiy9lqOY_O-RV3mHC1ZZmzEZHWBt16fVQ,31544
+google/oauth2/sts.py,sha256=GjpFEvByl3EzyGt2v1kev6rvP7_uSQ3eTlpBK9vUhSc,6699
+google/oauth2/utils.py,sha256=4crAdpKbDtobpQfXJc3uF6Zm6F3IzffvRSo-9h_515w,6315
+google_auth-2.29.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+google_auth-2.29.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+google_auth-2.29.0.dist-info/METADATA,sha256=tGcKXdXRWDGJx_U7JOIeUCHHHRwTK21XtnGd6JJs7ak,4690
+google_auth-2.29.0.dist-info/RECORD,,
+google_auth-2.29.0.dist-info/WHEEL,sha256=P2T-6epvtXQ2cBOE_U1K4_noqlJFN3tj15djMgEu4NM,110
+google_auth-2.29.0.dist-info/top_level.txt,sha256=BWmDiI8eoKfseZ5-MI2AW66GLJLNH4Lz23AXXTrIlyQ,23
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/WHEEL b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..f31e450fda2866f274547bb723d784248069898a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.3)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/top_level.txt b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..64f26a32e6269f22ba603fede491e460b08a91d8
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth-2.29.0.dist-info/top_level.txt
@@ -0,0 +1,3 @@
+google
+scripts
+testing
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/INSTALLER b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/LICENSE b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ 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.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/METADATA b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..cdf15e5479825f7e03eefd9b8c9d18cf05e3f247
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/METADATA
@@ -0,0 +1,62 @@
+Metadata-Version: 2.1
+Name: google-auth-httplib2
+Version: 0.2.0
+Summary: Google Authentication Library: httplib2 transport
+Home-page: https://github.com/GoogleCloudPlatform/google-auth-library-python-httplib2
+Author: Google Cloud Platform
+Author-email: googleapis-packages@google.com
+License: Apache 2.0
+Keywords: google auth oauth client
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+License-File: LICENSE
+Requires-Dist: google-auth
+Requires-Dist: httplib2 >=0.19.0
+
+``httplib2`` Transport for Google Auth
+======================================
+
+|pypi|
+
+This library provides an `httplib2`_ transport for `google-auth`_.
+
+.. note:: ``httplib`` has lots of problems such as lack of threadsafety
+ and insecure usage of TLS. Using it is highly discouraged. This
+ library is intended to help existing users of ``oauth2client`` migrate to
+ ``google-auth``.
+
+.. |pypi| image:: https://img.shields.io/pypi/v/google-auth-httplib2.svg
+ :target: https://pypi.python.org/pypi/google-auth-httplib2
+
+.. _httplib2: https://github.com/httplib2/httplib2
+.. _google-auth: https://github.com/GoogleCloudPlatform/google-auth-library-python/
+
+Installing
+----------
+
+You can install using `pip`_::
+
+ $ pip install google-auth-httplib2
+
+.. _pip: https://pip.pypa.io/en/stable/
+
+License
+-------
+
+Apache 2.0 - See `the LICENSE`_ for more information.
+
+.. _the LICENSE: https://github.com/GoogleCloudPlatform/google-auth-library-python/blob/main/LICENSE
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/RECORD b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..63b20856f97de371d140b14f02b4e13bbf371f0b
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/RECORD
@@ -0,0 +1,8 @@
+__pycache__/google_auth_httplib2.cpython-311.pyc,,
+google_auth_httplib2-0.2.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+google_auth_httplib2-0.2.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+google_auth_httplib2-0.2.0.dist-info/METADATA,sha256=KbbX6r2o-hWv_6Mr3PkYxa96q59OBXu2mF9WJ8MMlJk,2179
+google_auth_httplib2-0.2.0.dist-info/RECORD,,
+google_auth_httplib2-0.2.0.dist-info/WHEEL,sha256=P2T-6epvtXQ2cBOE_U1K4_noqlJFN3tj15djMgEu4NM,110
+google_auth_httplib2-0.2.0.dist-info/top_level.txt,sha256=xQr4X91CsNWr1mw3rrOH8mKnYLOW_Uhr5U7moYxkq4E,21
+google_auth_httplib2.py,sha256=Z-VdVWlB8Rcrwn4Q2MU9SHHJ5HZkPYHfDu8xHKsBeQI,10211
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/WHEEL b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..f31e450fda2866f274547bb723d784248069898a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.3)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/top_level.txt b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f8b63c266a006ff9f89d5a998d7cb9e836bec45e
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_httplib2-0.2.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+google_auth_httplib2
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/INSTALLER b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/LICENSE b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..d645695673349e3947e8e5ae42332d0ac3164cd7
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ 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.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/METADATA b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..99875cdf4972cbe3e41f5dcc36f11dad83fdb179
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/METADATA
@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: google-auth-oauthlib
+Version: 1.2.0
+Summary: Google Authentication Library
+Home-page: https://github.com/GoogleCloudPlatform/google-auth-library-python-oauthlib
+Author: Google Cloud Platform
+Author-email: googleapis-packages@google.com
+License: Apache 2.0
+Keywords: google auth oauth client oauthlib
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.6
+License-File: LICENSE
+Requires-Dist: google-auth >=2.15.0
+Requires-Dist: requests-oauthlib >=0.7.0
+Provides-Extra: tool
+Requires-Dist: click >=6.0.0 ; extra == 'tool'
+
+oauthlib integration for Google Auth
+====================================
+
+|pypi|
+
+This library provides `oauthlib`_ integration with `google-auth`_.
+
+.. |build| image:: https://travis-ci.org/googleapis/google-auth-library-python-oauthlib.svg?branch=main
+ :target: https://googleapis.dev/python/google-auth-oauthlib/latest/index.html
+.. |pypi| image:: https://img.shields.io/pypi/v/google-auth-oauthlib.svg
+ :target: https://pypi.python.org/pypi/google-auth-oauthlib
+
+.. _oauthlib: https://github.com/idan/oauthlib
+.. _google-auth: https://github.com/googleapis/google-auth-library-python
+
+Installing
+----------
+
+You can install using `pip`_::
+
+ $ pip install google-auth-oauthlib
+
+.. _pip: https://pip.pypa.io/en/stable/
+
+Documentation
+-------------
+
+The latest documentation is available at `google-auth-oauthlib.googleapis.dev`_.
+
+.. _google-auth-oauthlib.googleapis.dev: https://googleapis.dev/python/google-auth-oauthlib/latest/index.html
+
+Supported Python Versions
+-------------------------
+Python >= 3.6
+
+
+Unsupported Python Versions
+---------------------------
+
+Python == 2.7, Python == 3.5.
+
+The last version of this library compatible with Python 2.7 and 3.5 is
+`google-auth-oauthlib==0.4.1`.
+
+License
+-------
+
+Apache 2.0 - See `the LICENSE`_ for more information.
+
+.. _the LICENSE: https://github.com/googleapis/google-auth-library-python-oauthlib/blob/main/LICENSE
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/RECORD b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..1793e9073251a6d87d54f3c4c3a3e61c1a9e04fa
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/RECORD
@@ -0,0 +1,25 @@
+../../Scripts/google-oauthlib-tool.exe,sha256=-NlfJKdCR6-xi3m1ap-ZdUgesA72HgJhd__oWruMbCY,108479
+docs/__pycache__/conf.cpython-311.pyc,,
+docs/conf.py,sha256=yxdRFyXsTmlqMkXGWei6J67-wbndjU0-TpcQQjHTHQg,12421
+google_auth_oauthlib-1.2.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+google_auth_oauthlib-1.2.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+google_auth_oauthlib-1.2.0.dist-info/METADATA,sha256=kbw74oxR4lDtiUGq43tf894VBichxoT9gYb3QyBTSKU,2696
+google_auth_oauthlib-1.2.0.dist-info/RECORD,,
+google_auth_oauthlib-1.2.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google_auth_oauthlib-1.2.0.dist-info/WHEEL,sha256=P2T-6epvtXQ2cBOE_U1K4_noqlJFN3tj15djMgEu4NM,110
+google_auth_oauthlib-1.2.0.dist-info/entry_points.txt,sha256=DL3GRTp3HgwLxdBZCPkz9o8sK9cnENZMmu09EzAovkk,88
+google_auth_oauthlib-1.2.0.dist-info/top_level.txt,sha256=1UIrxRzACA8j-HW3CjjUghyqzTMl5NOXgMwHPpTY-BU,42
+google_auth_oauthlib/__init__.py,sha256=TTUgKl-F0eTBxBmbwDwDbIN-L33LmD4JbNKwXE-HngU,846
+google_auth_oauthlib/__pycache__/__init__.cpython-311.pyc,,
+google_auth_oauthlib/__pycache__/flow.cpython-311.pyc,,
+google_auth_oauthlib/__pycache__/helpers.cpython-311.pyc,,
+google_auth_oauthlib/__pycache__/interactive.cpython-311.pyc,,
+google_auth_oauthlib/flow.py,sha256=dINL-6b0UjC9Vj8icj9JnEtFDs8ym1QQhvs6IV7TDA8,19608
+google_auth_oauthlib/helpers.py,sha256=C6oIR1TZsizfH61SxdhaLI7utttHgI4Ww0tMrLhYnAY,5729
+google_auth_oauthlib/interactive.py,sha256=BW-L8FToU4iXf8Fd85U6kWJvjWSyS5FVvYvAIDe4NVM,6063
+google_auth_oauthlib/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google_auth_oauthlib/tool/__main__.py,sha256=BeX0cYaM50IInJ1c5U3ukxtuI9q1no-KIJhW7ynJBfs,3835
+google_auth_oauthlib/tool/__pycache__/__init__.cpython-311.pyc,,
+google_auth_oauthlib/tool/__pycache__/__main__.cpython-311.pyc,,
+scripts/readme-gen/__pycache__/readme_gen.cpython-311.pyc,,
+scripts/readme-gen/readme_gen.py,sha256=hPFWJnVXqwe6LOGJoWePgI7E97QBBQQTx6WvHW5ucZ0,1750
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/REQUESTED b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/WHEEL b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..f31e450fda2866f274547bb723d784248069898a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.3)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/entry_points.txt b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a33f32fa2ef02405f14d1457af1055e1e2fc44c4
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[console_scripts]
+google-oauthlib-tool = google_auth_oauthlib.tool.__main__:main [tool]
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/top_level.txt b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..14627fc3bdf89b15dc6be3b2fb5ceaa533bd216a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib-1.2.0.dist-info/top_level.txt
@@ -0,0 +1,4 @@
+docs
+google_auth_oauthlib
+scripts
+testing
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib/__init__.py b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1905f9a47070070020aecac07b637784e791f969
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib/__init__.py
@@ -0,0 +1,23 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""oauthlib integration for Google Auth
+
+This library provides `oauthlib `__
+integration with `google-auth `__.
+"""
+
+from .interactive import get_user_credentials
+
+__all__ = ["get_user_credentials"]
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib/flow.py b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib/flow.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5d8bceed9b76eb05e982f951da30a495f48d907
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib/flow.py
@@ -0,0 +1,505 @@
+# Copyright 2016 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""OAuth 2.0 Authorization Flow
+
+This module provides integration with `requests-oauthlib`_ for running the
+`OAuth 2.0 Authorization Flow`_ and acquiring user credentials. See
+`Using OAuth 2.0 to Access Google APIs`_ for an overview of OAuth 2.0
+authorization scenarios Google APIs support.
+
+Here's an example of using :class:`InstalledAppFlow`::
+
+ from google_auth_oauthlib.flow import InstalledAppFlow
+
+ # Create the flow using the client secrets file from the Google API
+ # Console.
+ flow = InstalledAppFlow.from_client_secrets_file(
+ 'client_secrets.json',
+ scopes=['profile', 'email'])
+
+ flow.run_local_server()
+
+ # You can use flow.credentials, or you can just get a requests session
+ # using flow.authorized_session.
+ session = flow.authorized_session()
+
+ profile_info = session.get(
+ 'https://www.googleapis.com/userinfo/v2/me').json()
+
+ print(profile_info)
+ # {'name': '...', 'email': '...', ...}
+
+.. _requests-oauthlib: http://requests-oauthlib.readthedocs.io/en/latest/
+.. _OAuth 2.0 Authorization Flow:
+ https://tools.ietf.org/html/rfc6749#section-1.2
+.. _Using OAuth 2.0 to Access Google APIs:
+ https://developers.google.com/identity/protocols/oauth2
+
+"""
+from base64 import urlsafe_b64encode
+import hashlib
+import json
+import logging
+
+try:
+ from secrets import SystemRandom
+except ImportError: # pragma: NO COVER
+ from random import SystemRandom
+from string import ascii_letters, digits
+import webbrowser
+import wsgiref.simple_server
+import wsgiref.util
+
+import google.auth.transport.requests
+import google.oauth2.credentials
+
+import google_auth_oauthlib.helpers
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Flow(object):
+ """OAuth 2.0 Authorization Flow
+
+ This class uses a :class:`requests_oauthlib.OAuth2Session` instance at
+ :attr:`oauth2session` to perform all of the OAuth 2.0 logic. This class
+ just provides convenience methods and sane defaults for doing Google's
+ particular flavors of OAuth 2.0.
+
+ Typically you'll construct an instance of this flow using
+ :meth:`from_client_secrets_file` and a `client secrets file`_ obtained
+ from the `Google API Console`_.
+
+ .. _client secrets file:
+ https://developers.google.com/identity/protocols/oauth2/web-server
+ #creatingcred
+ .. _Google API Console:
+ https://console.developers.google.com/apis/credentials
+ """
+
+ def __init__(
+ self,
+ oauth2session,
+ client_type,
+ client_config,
+ redirect_uri=None,
+ code_verifier=None,
+ autogenerate_code_verifier=True,
+ ):
+ """
+ Args:
+ oauth2session (requests_oauthlib.OAuth2Session):
+ The OAuth 2.0 session from ``requests-oauthlib``.
+ client_type (str): The client type, either ``web`` or
+ ``installed``.
+ client_config (Mapping[str, Any]): The client
+ configuration in the Google `client secrets`_ format.
+ redirect_uri (str): The OAuth 2.0 redirect URI if known at flow
+ creation time. Otherwise, it will need to be set using
+ :attr:`redirect_uri`.
+ code_verifier (str): random string of 43-128 chars used to verify
+ the key exchange.using PKCE.
+ autogenerate_code_verifier (bool): If true, auto-generate a
+ code_verifier.
+ .. _client secrets:
+ https://github.com/googleapis/google-api-python-client/blob
+ /main/docs/client-secrets.md
+ """
+ self.client_type = client_type
+ """str: The client type, either ``'web'`` or ``'installed'``"""
+ self.client_config = client_config[client_type]
+ """Mapping[str, Any]: The OAuth 2.0 client configuration."""
+ self.oauth2session = oauth2session
+ """requests_oauthlib.OAuth2Session: The OAuth 2.0 session."""
+ self.redirect_uri = redirect_uri
+ self.code_verifier = code_verifier
+ self.autogenerate_code_verifier = autogenerate_code_verifier
+
+ @classmethod
+ def from_client_config(cls, client_config, scopes, **kwargs):
+ """Creates a :class:`requests_oauthlib.OAuth2Session` from client
+ configuration loaded from a Google-format client secrets file.
+
+ Args:
+ client_config (Mapping[str, Any]): The client
+ configuration in the Google `client secrets`_ format.
+ scopes (Sequence[str]): The list of scopes to request during the
+ flow.
+ kwargs: Any additional parameters passed to
+ :class:`requests_oauthlib.OAuth2Session`
+
+ Returns:
+ Flow: The constructed Flow instance.
+
+ Raises:
+ ValueError: If the client configuration is not in the correct
+ format.
+
+ .. _client secrets:
+ https://github.com/googleapis/google-api-python-client/blob/main/docs/client-secrets.md
+ """
+ if "web" in client_config:
+ client_type = "web"
+ elif "installed" in client_config:
+ client_type = "installed"
+ else:
+ raise ValueError("Client secrets must be for a web or installed app.")
+
+ # these args cannot be passed to requests_oauthlib.OAuth2Session
+ code_verifier = kwargs.pop("code_verifier", None)
+ autogenerate_code_verifier = kwargs.pop("autogenerate_code_verifier", None)
+
+ (
+ session,
+ client_config,
+ ) = google_auth_oauthlib.helpers.session_from_client_config(
+ client_config, scopes, **kwargs
+ )
+
+ redirect_uri = kwargs.get("redirect_uri", None)
+
+ return cls(
+ session,
+ client_type,
+ client_config,
+ redirect_uri,
+ code_verifier,
+ autogenerate_code_verifier,
+ )
+
+ @classmethod
+ def from_client_secrets_file(cls, client_secrets_file, scopes, **kwargs):
+ """Creates a :class:`Flow` instance from a Google client secrets file.
+
+ Args:
+ client_secrets_file (str): The path to the client secrets .json
+ file.
+ scopes (Sequence[str]): The list of scopes to request during the
+ flow.
+ kwargs: Any additional parameters passed to
+ :class:`requests_oauthlib.OAuth2Session`
+
+ Returns:
+ Flow: The constructed Flow instance.
+ """
+ with open(client_secrets_file, "r") as json_file:
+ client_config = json.load(json_file)
+
+ return cls.from_client_config(client_config, scopes=scopes, **kwargs)
+
+ @property
+ def redirect_uri(self):
+ """The OAuth 2.0 redirect URI. Pass-through to
+ ``self.oauth2session.redirect_uri``."""
+ return self.oauth2session.redirect_uri
+
+ @redirect_uri.setter
+ def redirect_uri(self, value):
+ """The OAuth 2.0 redirect URI. Pass-through to
+ ``self.oauth2session.redirect_uri``."""
+ self.oauth2session.redirect_uri = value
+
+ def authorization_url(self, **kwargs):
+ """Generates an authorization URL.
+
+ This is the first step in the OAuth 2.0 Authorization Flow. The user's
+ browser should be redirected to the returned URL.
+
+ This method calls
+ :meth:`requests_oauthlib.OAuth2Session.authorization_url`
+ and specifies the client configuration's authorization URI (usually
+ Google's authorization server) and specifies that "offline" access is
+ desired. This is required in order to obtain a refresh token.
+
+ Args:
+ kwargs: Additional arguments passed through to
+ :meth:`requests_oauthlib.OAuth2Session.authorization_url`
+
+ Returns:
+ Tuple[str, str]: The generated authorization URL and state. The
+ user must visit the URL to complete the flow. The state is used
+ when completing the flow to verify that the request originated
+ from your application. If your application is using a different
+ :class:`Flow` instance to obtain the token, you will need to
+ specify the ``state`` when constructing the :class:`Flow`.
+ """
+ kwargs.setdefault("access_type", "offline")
+ if self.autogenerate_code_verifier:
+ chars = ascii_letters + digits + "-._~"
+ rnd = SystemRandom()
+ random_verifier = [rnd.choice(chars) for _ in range(0, 128)]
+ self.code_verifier = "".join(random_verifier)
+
+ if self.code_verifier:
+ code_hash = hashlib.sha256()
+ code_hash.update(str.encode(self.code_verifier))
+ unencoded_challenge = code_hash.digest()
+ b64_challenge = urlsafe_b64encode(unencoded_challenge)
+ code_challenge = b64_challenge.decode().split("=")[0]
+ kwargs.setdefault("code_challenge", code_challenge)
+ kwargs.setdefault("code_challenge_method", "S256")
+ url, state = self.oauth2session.authorization_url(
+ self.client_config["auth_uri"], **kwargs
+ )
+
+ return url, state
+
+ def fetch_token(self, **kwargs):
+ """Completes the Authorization Flow and obtains an access token.
+
+ This is the final step in the OAuth 2.0 Authorization Flow. This is
+ called after the user consents.
+
+ This method calls
+ :meth:`requests_oauthlib.OAuth2Session.fetch_token`
+ and specifies the client configuration's token URI (usually Google's
+ token server).
+
+ Args:
+ kwargs: Arguments passed through to
+ :meth:`requests_oauthlib.OAuth2Session.fetch_token`. At least
+ one of ``code`` or ``authorization_response`` must be
+ specified.
+
+ Returns:
+ Mapping[str, str]: The obtained tokens. Typically, you will not use
+ return value of this function and instead use
+ :meth:`credentials` to obtain a
+ :class:`~google.auth.credentials.Credentials` instance.
+ """
+ kwargs.setdefault("client_secret", self.client_config["client_secret"])
+ kwargs.setdefault("code_verifier", self.code_verifier)
+ return self.oauth2session.fetch_token(self.client_config["token_uri"], **kwargs)
+
+ @property
+ def credentials(self):
+ """Returns credentials from the OAuth 2.0 session.
+
+ :meth:`fetch_token` must be called before accessing this. This method
+ constructs a :class:`google.oauth2.credentials.Credentials` class using
+ the session's token and the client config.
+
+ Returns:
+ google.oauth2.credentials.Credentials: The constructed credentials.
+
+ Raises:
+ ValueError: If there is no access token in the session.
+ """
+ return google_auth_oauthlib.helpers.credentials_from_session(
+ self.oauth2session, self.client_config
+ )
+
+ def authorized_session(self):
+ """Returns a :class:`requests.Session` authorized with credentials.
+
+ :meth:`fetch_token` must be called before this method. This method
+ constructs a :class:`google.auth.transport.requests.AuthorizedSession`
+ class using this flow's :attr:`credentials`.
+
+ Returns:
+ google.auth.transport.requests.AuthorizedSession: The constructed
+ session.
+ """
+ return google.auth.transport.requests.AuthorizedSession(self.credentials)
+
+
+class InstalledAppFlow(Flow):
+ """Authorization flow helper for installed applications.
+
+ This :class:`Flow` subclass makes it easier to perform the
+ `Installed Application Authorization Flow`_. This flow is useful for
+ local development or applications that are installed on a desktop operating
+ system.
+
+ This flow uses a local server strategy provided by :meth:`run_local_server`.
+
+ Example::
+
+ from google_auth_oauthlib.flow import InstalledAppFlow
+
+ flow = InstalledAppFlow.from_client_secrets_file(
+ 'client_secrets.json',
+ scopes=['profile', 'email'])
+
+ flow.run_local_server()
+
+ session = flow.authorized_session()
+
+ profile_info = session.get(
+ 'https://www.googleapis.com/userinfo/v2/me').json()
+
+ print(profile_info)
+ # {'name': '...', 'email': '...', ...}
+
+
+ Note that this isn't the only way to accomplish the installed
+ application flow, just one of the most common. You can use the
+ :class:`Flow` class to perform the same flow with different methods of
+ presenting the authorization URL to the user or obtaining the authorization
+ response, such as using an embedded web view.
+
+ .. _Installed Application Authorization Flow:
+ https://github.com/googleapis/google-api-python-client/blob/main/docs/oauth-installed.md
+ """
+
+ _DEFAULT_AUTH_PROMPT_MESSAGE = (
+ "Please visit this URL to authorize this application: {url}"
+ )
+ """str: The message to display when prompting the user for
+ authorization."""
+ _DEFAULT_AUTH_CODE_MESSAGE = "Enter the authorization code: "
+ """str: The message to display when prompting the user for the
+ authorization code. Used only by the console strategy."""
+
+ _DEFAULT_WEB_SUCCESS_MESSAGE = (
+ "The authentication flow has completed. You may close this window."
+ )
+
+ def run_local_server(
+ self,
+ host="localhost",
+ bind_addr=None,
+ port=8080,
+ authorization_prompt_message=_DEFAULT_AUTH_PROMPT_MESSAGE,
+ success_message=_DEFAULT_WEB_SUCCESS_MESSAGE,
+ open_browser=True,
+ redirect_uri_trailing_slash=True,
+ timeout_seconds=None,
+ token_audience=None,
+ browser=None,
+ **kwargs
+ ):
+ """Run the flow using the server strategy.
+
+ The server strategy instructs the user to open the authorization URL in
+ their browser and will attempt to automatically open the URL for them.
+ It will start a local web server to listen for the authorization
+ response. Once authorization is complete the authorization server will
+ redirect the user's browser to the local web server. The web server
+ will get the authorization code from the response and shutdown. The
+ code is then exchanged for a token.
+
+ Args:
+ host (str): The hostname for the local redirect server. This will
+ be served over http, not https.
+ bind_addr (str): Optionally provide an ip address for the redirect
+ server to listen on when it is not the same as host
+ (e.g. in a container). Default value is None,
+ which means that the redirect server will listen
+ on the ip address specified in the host parameter.
+ port (int): The port for the local redirect server.
+ authorization_prompt_message (str | None): The message to display to tell
+ the user to navigate to the authorization URL. If None or empty,
+ don't display anything.
+ success_message (str): The message to display in the web browser
+ the authorization flow is complete.
+ open_browser (bool): Whether or not to open the authorization URL
+ in the user's browser.
+ redirect_uri_trailing_slash (bool): whether or not to add trailing
+ slash when constructing the redirect_uri. Default value is True.
+ timeout_seconds (int): It will raise an error after the timeout timing
+ if there are no credentials response. The value is in seconds.
+ When set to None there is no timeout.
+ Default value is None.
+ token_audience (str): Passed along with the request for an access
+ token. Determines the endpoints with which the token can be
+ used. Optional.
+ browser (str): specify which browser to open for authentication. If not
+ specified this defaults to default browser.
+ kwargs: Additional keyword arguments passed through to
+ :meth:`authorization_url`.
+
+ Returns:
+ google.oauth2.credentials.Credentials: The OAuth 2.0 credentials
+ for the user.
+ """
+ wsgi_app = _RedirectWSGIApp(success_message)
+ # Fail fast if the address is occupied
+ wsgiref.simple_server.WSGIServer.allow_reuse_address = False
+ local_server = wsgiref.simple_server.make_server(
+ bind_addr or host, port, wsgi_app, handler_class=_WSGIRequestHandler
+ )
+
+ redirect_uri_format = (
+ "http://{}:{}/" if redirect_uri_trailing_slash else "http://{}:{}"
+ )
+ self.redirect_uri = redirect_uri_format.format(host, local_server.server_port)
+ auth_url, _ = self.authorization_url(**kwargs)
+
+ if open_browser:
+ # if browser is None it defaults to default browser
+ webbrowser.get(browser).open(auth_url, new=1, autoraise=True)
+
+ if authorization_prompt_message:
+ print(authorization_prompt_message.format(url=auth_url))
+
+ local_server.timeout = timeout_seconds
+ local_server.handle_request()
+
+ # Note: using https here because oauthlib is very picky that
+ # OAuth 2.0 should only occur over https.
+ authorization_response = wsgi_app.last_request_uri.replace("http", "https")
+ self.fetch_token(
+ authorization_response=authorization_response, audience=token_audience
+ )
+
+ # This closes the socket
+ local_server.server_close()
+
+ return self.credentials
+
+
+class _WSGIRequestHandler(wsgiref.simple_server.WSGIRequestHandler):
+ """Custom WSGIRequestHandler.
+
+ Uses a named logger instead of printing to stderr.
+ """
+
+ def log_message(self, format, *args):
+ # pylint: disable=redefined-builtin
+ # (format is the argument name defined in the superclass.)
+ _LOGGER.info(format, *args)
+
+
+class _RedirectWSGIApp(object):
+ """WSGI app to handle the authorization redirect.
+
+ Stores the request URI and displays the given success message.
+ """
+
+ def __init__(self, success_message):
+ """
+ Args:
+ success_message (str): The message to display in the web browser
+ the authorization flow is complete.
+ """
+ self.last_request_uri = None
+ self._success_message = success_message
+
+ def __call__(self, environ, start_response):
+ """WSGI Callable.
+
+ Args:
+ environ (Mapping[str, Any]): The WSGI environment.
+ start_response (Callable[str, list]): The WSGI start_response
+ callable.
+
+ Returns:
+ Iterable[bytes]: The response body.
+ """
+ start_response("200 OK", [("Content-type", "text/plain; charset=utf-8")])
+ self.last_request_uri = wsgiref.util.request_uri(environ)
+ return [self._success_message.encode("utf-8")]
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib/helpers.py b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib/helpers.py
new file mode 100644
index 0000000000000000000000000000000000000000..25462f4c193c84aad5c935ad55910faa70f760e8
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib/helpers.py
@@ -0,0 +1,151 @@
+# Copyright 2017 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""Integration helpers.
+
+This module provides helpers for integrating with `requests-oauthlib`_.
+Typically, you'll want to use the higher-level helpers in
+:mod:`google_auth_oauthlib.flow`.
+
+.. _requests-oauthlib: http://requests-oauthlib.readthedocs.io/en/latest/
+"""
+
+import datetime
+import json
+
+from google.auth import external_account_authorized_user
+import google.oauth2.credentials
+import requests_oauthlib
+
+_REQUIRED_CONFIG_KEYS = frozenset(("auth_uri", "token_uri", "client_id"))
+
+
+def session_from_client_config(client_config, scopes, **kwargs):
+ """Creates a :class:`requests_oauthlib.OAuth2Session` from client
+ configuration loaded from a Google-format client secrets file.
+
+ Args:
+ client_config (Mapping[str, Any]): The client
+ configuration in the Google `client secrets`_ format.
+ scopes (Sequence[str]): The list of scopes to request during the
+ flow.
+ kwargs: Any additional parameters passed to
+ :class:`requests_oauthlib.OAuth2Session`
+
+ Raises:
+ ValueError: If the client configuration is not in the correct
+ format.
+
+ Returns:
+ Tuple[requests_oauthlib.OAuth2Session, Mapping[str, Any]]: The new
+ oauthlib session and the validated client configuration.
+
+ .. _client secrets:
+ https://github.com/googleapis/google-api-python-client/blob/main/docs/client-secrets.md
+ """
+
+ if "web" in client_config:
+ config = client_config["web"]
+ elif "installed" in client_config:
+ config = client_config["installed"]
+ else:
+ raise ValueError("Client secrets must be for a web or installed app.")
+
+ if not _REQUIRED_CONFIG_KEYS.issubset(config.keys()):
+ raise ValueError("Client secrets is not in the correct format.")
+
+ session = requests_oauthlib.OAuth2Session(
+ client_id=config["client_id"], scope=scopes, **kwargs
+ )
+
+ return session, client_config
+
+
+def session_from_client_secrets_file(client_secrets_file, scopes, **kwargs):
+ """Creates a :class:`requests_oauthlib.OAuth2Session` instance from a
+ Google-format client secrets file.
+
+ Args:
+ client_secrets_file (str): The path to the `client secrets`_ .json
+ file.
+ scopes (Sequence[str]): The list of scopes to request during the
+ flow.
+ kwargs: Any additional parameters passed to
+ :class:`requests_oauthlib.OAuth2Session`
+
+ Returns:
+ Tuple[requests_oauthlib.OAuth2Session, Mapping[str, Any]]: The new
+ oauthlib session and the validated client configuration.
+
+ .. _client secrets:
+ https://github.com/googleapis/google-api-python-client/blob/main/docs/client-secrets.md
+ """
+ with open(client_secrets_file, "r") as json_file:
+ client_config = json.load(json_file)
+
+ return session_from_client_config(client_config, scopes, **kwargs)
+
+
+def credentials_from_session(session, client_config=None):
+ """Creates :class:`google.oauth2.credentials.Credentials` from a
+ :class:`requests_oauthlib.OAuth2Session`.
+
+ :meth:`fetch_token` must be called on the session before before calling
+ this. This uses the session's auth token and the provided client
+ configuration to create :class:`google.oauth2.credentials.Credentials`.
+ This allows you to use the credentials from the session with Google
+ API client libraries.
+
+ Args:
+ session (requests_oauthlib.OAuth2Session): The OAuth 2.0 session.
+ client_config (Mapping[str, Any]): The subset of the client
+ configuration to use. For example, if you have a web client
+ you would pass in `client_config['web']`.
+
+ Returns:
+ google.oauth2.credentials.Credentials: The constructed credentials.
+
+ Raises:
+ ValueError: If there is no access token in the session.
+ """
+ client_config = client_config if client_config is not None else {}
+
+ if not session.token:
+ raise ValueError(
+ "There is no access token for this session, did you call " "fetch_token?"
+ )
+
+ if "3pi" in client_config:
+ credentials = external_account_authorized_user.Credentials(
+ token=session.token["access_token"],
+ refresh_token=session.token.get("refresh_token"),
+ token_url=client_config.get("token_uri"),
+ client_id=client_config.get("client_id"),
+ client_secret=client_config.get("client_secret"),
+ token_info_url=client_config.get("token_info_url"),
+ scopes=session.scope,
+ )
+ else:
+ credentials = google.oauth2.credentials.Credentials(
+ session.token["access_token"],
+ refresh_token=session.token.get("refresh_token"),
+ id_token=session.token.get("id_token"),
+ token_uri=client_config.get("token_uri"),
+ client_id=client_config.get("client_id"),
+ client_secret=client_config.get("client_secret"),
+ scopes=session.scope,
+ granted_scopes=session.token.get("scope"),
+ )
+ credentials.expiry = datetime.datetime.utcfromtimestamp(session.token["expires_at"])
+ return credentials
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib/interactive.py b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib/interactive.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1ed990ef435c9127430a2f4a3c269151463000e
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/google_auth_oauthlib/interactive.py
@@ -0,0 +1,172 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""Get user credentials from interactive code environments.
+
+This module contains helpers for getting user credentials from interactive
+code environments installed on a development machine, such as Jupyter
+notebooks.
+"""
+
+from __future__ import absolute_import
+
+import contextlib
+import socket
+
+import google_auth_oauthlib.flow
+
+
+LOCALHOST = "localhost"
+DEFAULT_PORTS_TO_TRY = 100
+
+
+def is_port_open(port):
+ """Check if a port is open on localhost.
+ Based on StackOverflow answer: https://stackoverflow.com/a/43238489/101923
+ Parameters
+ ----------
+ port : int
+ A port to check on localhost.
+ Returns
+ -------
+ is_open : bool
+ True if a socket can be opened at the requested port.
+ """
+ with contextlib.closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
+ try:
+ sock.bind((LOCALHOST, port))
+ sock.listen(1)
+ except socket.error:
+ is_open = False
+ else:
+ is_open = True
+ return is_open
+
+
+def find_open_port(start=8080, stop=None):
+ """Find an open port between ``start`` and ``stop``.
+ Parameters
+ ----------
+ start : Optional[int]
+ Beginning of range of ports to try. Defaults to 8080.
+ stop : Optional[int]
+ End of range of ports to try (not including exactly equals ``stop``).
+ This function tries 100 possible ports if no ``stop`` is specified.
+ Returns
+ -------
+ Optional[int]
+ ``None`` if no open port is found, otherwise an integer indicating an
+ open port.
+ """
+ if not stop:
+ stop = start + DEFAULT_PORTS_TO_TRY
+
+ for port in range(start, stop):
+ if is_port_open(port):
+ return port
+
+ # No open ports found.
+ return None
+
+
+def get_user_credentials(
+ scopes, client_id, client_secret, minimum_port=8080, maximum_port=None
+):
+ """Gets credentials associated with your Google user account.
+
+ This function authenticates using your user credentials by going through
+ the OAuth 2.0 flow. You'll open a browser window to authenticate to your
+ Google account. The permissions it requests correspond to the scopes
+ you've provided.
+
+ To obtain the ``client_id`` and ``client_secret``, create an **OAuth
+ client ID** with application type **Other** from the `Credentials page on
+ the Google Developer's Console
+ `_. Learn more
+ with the `Authenticating as an end user
+ `_ guide.
+
+ Args:
+ scopes (Sequence[str]):
+ A list of scopes to use when authenticating to Google APIs. See
+ the `list of OAuth 2.0 scopes for Google APIs
+ `_.
+ client_id (str):
+ A string that identifies your application to Google APIs. Find
+ this value in the `Credentials page on the Google Developer's
+ Console
+ `_.
+ client_secret (str):
+ A string that verifies your application to Google APIs. Find this
+ value in the `Credentials page on the Google Developer's Console
+ `_.
+ minimum_port (int):
+ Beginning of range of ports to try for redirect URI HTTP server.
+ Defaults to 8080.
+ maximum_port (Optional[int]):
+ End of range of ports to try (not including exactly equals ``stop``).
+ This function tries 100 possible ports if no ``stop`` is specified.
+
+ Returns:
+ google.oauth2.credentials.Credentials:
+ The OAuth 2.0 credentials for the user.
+
+ Examples:
+ Get credentials for your user account and use them to run a query
+ with BigQuery::
+
+ import google_auth_oauthlib
+
+ # TODO: Create a client ID for your project.
+ client_id = "YOUR-CLIENT-ID.apps.googleusercontent.com"
+ client_secret = "abc_ThIsIsAsEcReT"
+
+ # TODO: Choose the needed scopes for your applications.
+ scopes = ["https://www.googleapis.com/auth/cloud-platform"]
+
+ credentials = google_auth_oauthlib.get_user_credentials(
+ scopes, client_id, client_secret
+ )
+
+ # 1. Open the link.
+ # 2. Authorize the application to have access to your account.
+ # 3. Copy and paste the authorization code to the prompt.
+
+ # Use the credentials to construct a client for Google APIs.
+ from google.cloud import bigquery
+
+ bigquery_client = bigquery.Client(
+ credentials=credentials, project="your-project-id"
+ )
+ print(list(bigquery_client.query("SELECT 1").result()))
+ """
+
+ client_config = {
+ "installed": {
+ "client_id": client_id,
+ "client_secret": client_secret,
+ "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+ "token_uri": "https://oauth2.googleapis.com/token",
+ }
+ }
+
+ app_flow = google_auth_oauthlib.flow.InstalledAppFlow.from_client_config(
+ client_config, scopes=scopes
+ )
+
+ port = find_open_port(start=minimum_port, stop=maximum_port)
+ if not port:
+ raise ConnectionError("Could not find open port.")
+
+ return app_flow.run_local_server(host=LOCALHOST, port=port)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/__init__.py b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c9218dd854063df739f78247c299643f2c6b29f0
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+# Set default logging handler to avoid "No handler found" warnings.
+import logging
+
+try: # Python 2.7+
+ from logging import NullHandler
+except ImportError:
+
+ class NullHandler(logging.Handler):
+ def emit(self, record):
+ pass
+
+
+logging.getLogger(__name__).addHandler(NullHandler())
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/_auth.py b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/_auth.py
new file mode 100644
index 0000000000000000000000000000000000000000..065b2ecd307df1d69a7e6afe1b94086b8b33c838
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/_auth.py
@@ -0,0 +1,167 @@
+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""Helpers for authentication using oauth2client or google-auth."""
+
+import httplib2
+
+try:
+ import google.auth
+ import google.auth.credentials
+
+ HAS_GOOGLE_AUTH = True
+except ImportError: # pragma: NO COVER
+ HAS_GOOGLE_AUTH = False
+
+try:
+ import google_auth_httplib2
+except ImportError: # pragma: NO COVER
+ google_auth_httplib2 = None
+
+try:
+ import oauth2client
+ import oauth2client.client
+
+ HAS_OAUTH2CLIENT = True
+except ImportError: # pragma: NO COVER
+ HAS_OAUTH2CLIENT = False
+
+
+def credentials_from_file(filename, scopes=None, quota_project_id=None):
+ """Returns credentials loaded from a file."""
+ if HAS_GOOGLE_AUTH:
+ credentials, _ = google.auth.load_credentials_from_file(
+ filename, scopes=scopes, quota_project_id=quota_project_id
+ )
+ return credentials
+ else:
+ raise EnvironmentError(
+ "client_options.credentials_file is only supported in google-auth."
+ )
+
+
+def default_credentials(scopes=None, quota_project_id=None):
+ """Returns Application Default Credentials."""
+ if HAS_GOOGLE_AUTH:
+ credentials, _ = google.auth.default(
+ scopes=scopes, quota_project_id=quota_project_id
+ )
+ return credentials
+ elif HAS_OAUTH2CLIENT:
+ if scopes is not None or quota_project_id is not None:
+ raise EnvironmentError(
+ "client_options.scopes and client_options.quota_project_id are not supported in oauth2client."
+ "Please install google-auth."
+ )
+ return oauth2client.client.GoogleCredentials.get_application_default()
+ else:
+ raise EnvironmentError(
+ "No authentication library is available. Please install either "
+ "google-auth or oauth2client."
+ )
+
+
+def with_scopes(credentials, scopes):
+ """Scopes the credentials if necessary.
+
+ Args:
+ credentials (Union[
+ google.auth.credentials.Credentials,
+ oauth2client.client.Credentials]): The credentials to scope.
+ scopes (Sequence[str]): The list of scopes.
+
+ Returns:
+ Union[google.auth.credentials.Credentials,
+ oauth2client.client.Credentials]: The scoped credentials.
+ """
+ if HAS_GOOGLE_AUTH and isinstance(credentials, google.auth.credentials.Credentials):
+ return google.auth.credentials.with_scopes_if_required(credentials, scopes)
+ else:
+ try:
+ if credentials.create_scoped_required():
+ return credentials.create_scoped(scopes)
+ else:
+ return credentials
+ except AttributeError:
+ return credentials
+
+
+def authorized_http(credentials):
+ """Returns an http client that is authorized with the given credentials.
+
+ Args:
+ credentials (Union[
+ google.auth.credentials.Credentials,
+ oauth2client.client.Credentials]): The credentials to use.
+
+ Returns:
+ Union[httplib2.Http, google_auth_httplib2.AuthorizedHttp]: An
+ authorized http client.
+ """
+ from googleapiclient.http import build_http
+
+ if HAS_GOOGLE_AUTH and isinstance(credentials, google.auth.credentials.Credentials):
+ if google_auth_httplib2 is None:
+ raise ValueError(
+ "Credentials from google.auth specified, but "
+ "google-api-python-client is unable to use these credentials "
+ "unless google-auth-httplib2 is installed. Please install "
+ "google-auth-httplib2."
+ )
+ return google_auth_httplib2.AuthorizedHttp(credentials, http=build_http())
+ else:
+ return credentials.authorize(build_http())
+
+
+def refresh_credentials(credentials):
+ # Refresh must use a new http instance, as the one associated with the
+ # credentials could be a AuthorizedHttp or an oauth2client-decorated
+ # Http instance which would cause a weird recursive loop of refreshing
+ # and likely tear a hole in spacetime.
+ refresh_http = httplib2.Http()
+ if HAS_GOOGLE_AUTH and isinstance(credentials, google.auth.credentials.Credentials):
+ request = google_auth_httplib2.Request(refresh_http)
+ return credentials.refresh(request)
+ else:
+ return credentials.refresh(refresh_http)
+
+
+def apply_credentials(credentials, headers):
+ # oauth2client and google-auth have the same interface for this.
+ if not is_valid(credentials):
+ refresh_credentials(credentials)
+ return credentials.apply(headers)
+
+
+def is_valid(credentials):
+ if HAS_GOOGLE_AUTH and isinstance(credentials, google.auth.credentials.Credentials):
+ return credentials.valid
+ else:
+ return (
+ credentials.access_token is not None
+ and not credentials.access_token_expired
+ )
+
+
+def get_credentials_from_http(http):
+ if http is None:
+ return None
+ elif hasattr(http.request, "credentials"):
+ return http.request.credentials
+ elif hasattr(http, "credentials") and not isinstance(
+ http.credentials, httplib2.Credentials
+ ):
+ return http.credentials
+ else:
+ return None
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/_helpers.py b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/_helpers.py
new file mode 100644
index 0000000000000000000000000000000000000000..17b8a171514eb144ba67b75de58f526b36680ea1
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/_helpers.py
@@ -0,0 +1,207 @@
+# Copyright 2015 Google Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""Helper functions for commonly used utilities."""
+
+import functools
+import inspect
+import logging
+import urllib
+
+logger = logging.getLogger(__name__)
+
+POSITIONAL_WARNING = "WARNING"
+POSITIONAL_EXCEPTION = "EXCEPTION"
+POSITIONAL_IGNORE = "IGNORE"
+POSITIONAL_SET = frozenset(
+ [POSITIONAL_WARNING, POSITIONAL_EXCEPTION, POSITIONAL_IGNORE]
+)
+
+positional_parameters_enforcement = POSITIONAL_WARNING
+
+_SYM_LINK_MESSAGE = "File: {0}: Is a symbolic link."
+_IS_DIR_MESSAGE = "{0}: Is a directory"
+_MISSING_FILE_MESSAGE = "Cannot access {0}: No such file or directory"
+
+
+def positional(max_positional_args):
+ """A decorator to declare that only the first N arguments may be positional.
+
+ This decorator makes it easy to support Python 3 style keyword-only
+ parameters. For example, in Python 3 it is possible to write::
+
+ def fn(pos1, *, kwonly1=None, kwonly2=None):
+ ...
+
+ All named parameters after ``*`` must be a keyword::
+
+ fn(10, 'kw1', 'kw2') # Raises exception.
+ fn(10, kwonly1='kw1') # Ok.
+
+ Example
+ ^^^^^^^
+
+ To define a function like above, do::
+
+ @positional(1)
+ def fn(pos1, kwonly1=None, kwonly2=None):
+ ...
+
+ If no default value is provided to a keyword argument, it becomes a
+ required keyword argument::
+
+ @positional(0)
+ def fn(required_kw):
+ ...
+
+ This must be called with the keyword parameter::
+
+ fn() # Raises exception.
+ fn(10) # Raises exception.
+ fn(required_kw=10) # Ok.
+
+ When defining instance or class methods always remember to account for
+ ``self`` and ``cls``::
+
+ class MyClass(object):
+
+ @positional(2)
+ def my_method(self, pos1, kwonly1=None):
+ ...
+
+ @classmethod
+ @positional(2)
+ def my_method(cls, pos1, kwonly1=None):
+ ...
+
+ The positional decorator behavior is controlled by
+ ``_helpers.positional_parameters_enforcement``, which may be set to
+ ``POSITIONAL_EXCEPTION``, ``POSITIONAL_WARNING`` or
+ ``POSITIONAL_IGNORE`` to raise an exception, log a warning, or do
+ nothing, respectively, if a declaration is violated.
+
+ Args:
+ max_positional_arguments: Maximum number of positional arguments. All
+ parameters after this index must be
+ keyword only.
+
+ Returns:
+ A decorator that prevents using arguments after max_positional_args
+ from being used as positional parameters.
+
+ Raises:
+ TypeError: if a keyword-only argument is provided as a positional
+ parameter, but only if
+ _helpers.positional_parameters_enforcement is set to
+ POSITIONAL_EXCEPTION.
+ """
+
+ def positional_decorator(wrapped):
+ @functools.wraps(wrapped)
+ def positional_wrapper(*args, **kwargs):
+ if len(args) > max_positional_args:
+ plural_s = ""
+ if max_positional_args != 1:
+ plural_s = "s"
+ message = (
+ "{function}() takes at most {args_max} positional "
+ "argument{plural} ({args_given} given)".format(
+ function=wrapped.__name__,
+ args_max=max_positional_args,
+ args_given=len(args),
+ plural=plural_s,
+ )
+ )
+ if positional_parameters_enforcement == POSITIONAL_EXCEPTION:
+ raise TypeError(message)
+ elif positional_parameters_enforcement == POSITIONAL_WARNING:
+ logger.warning(message)
+ return wrapped(*args, **kwargs)
+
+ return positional_wrapper
+
+ if isinstance(max_positional_args, int):
+ return positional_decorator
+ else:
+ args, _, _, defaults, _, _, _ = inspect.getfullargspec(max_positional_args)
+ return positional(len(args) - len(defaults))(max_positional_args)
+
+
+def parse_unique_urlencoded(content):
+ """Parses unique key-value parameters from urlencoded content.
+
+ Args:
+ content: string, URL-encoded key-value pairs.
+
+ Returns:
+ dict, The key-value pairs from ``content``.
+
+ Raises:
+ ValueError: if one of the keys is repeated.
+ """
+ urlencoded_params = urllib.parse.parse_qs(content)
+ params = {}
+ for key, value in urlencoded_params.items():
+ if len(value) != 1:
+ msg = "URL-encoded content contains a repeated value:" "%s -> %s" % (
+ key,
+ ", ".join(value),
+ )
+ raise ValueError(msg)
+ params[key] = value[0]
+ return params
+
+
+def update_query_params(uri, params):
+ """Updates a URI with new query parameters.
+
+ If a given key from ``params`` is repeated in the ``uri``, then
+ the URI will be considered invalid and an error will occur.
+
+ If the URI is valid, then each value from ``params`` will
+ replace the corresponding value in the query parameters (if
+ it exists).
+
+ Args:
+ uri: string, A valid URI, with potential existing query parameters.
+ params: dict, A dictionary of query parameters.
+
+ Returns:
+ The same URI but with the new query parameters added.
+ """
+ parts = urllib.parse.urlparse(uri)
+ query_params = parse_unique_urlencoded(parts.query)
+ query_params.update(params)
+ new_query = urllib.parse.urlencode(query_params)
+ new_parts = parts._replace(query=new_query)
+ return urllib.parse.urlunparse(new_parts)
+
+
+def _add_query_parameter(url, name, value):
+ """Adds a query parameter to a url.
+
+ Replaces the current value if it already exists in the URL.
+
+ Args:
+ url: string, url to add the query parameter to.
+ name: string, query parameter name.
+ value: string, query parameter value.
+
+ Returns:
+ Updated query parameter. Does not update the url if value is None.
+ """
+ if value is None:
+ return url
+ else:
+ return update_query_params(url, {name: value})
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/channel.py b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/channel.py
new file mode 100644
index 0000000000000000000000000000000000000000..37bda1ea7e52630d2a775961816ea19d6174a62b
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/channel.py
@@ -0,0 +1,315 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""Channel notifications support.
+
+Classes and functions to support channel subscriptions and notifications
+on those channels.
+
+Notes:
+ - This code is based on experimental APIs and is subject to change.
+ - Notification does not do deduplication of notification ids, that's up to
+ the receiver.
+ - Storing the Channel between calls is up to the caller.
+
+
+Example setting up a channel:
+
+ # Create a new channel that gets notifications via webhook.
+ channel = new_webhook_channel("https://example.com/my_web_hook")
+
+ # Store the channel, keyed by 'channel.id'. Store it before calling the
+ # watch method because notifications may start arriving before the watch
+ # method returns.
+ ...
+
+ resp = service.objects().watchAll(
+ bucket="some_bucket_id", body=channel.body()).execute()
+ channel.update(resp)
+
+ # Store the channel, keyed by 'channel.id'. Store it after being updated
+ # since the resource_id value will now be correct, and that's needed to
+ # stop a subscription.
+ ...
+
+
+An example Webhook implementation using webapp2. Note that webapp2 puts
+headers in a case insensitive dictionary, as headers aren't guaranteed to
+always be upper case.
+
+ id = self.request.headers[X_GOOG_CHANNEL_ID]
+
+ # Retrieve the channel by id.
+ channel = ...
+
+ # Parse notification from the headers, including validating the id.
+ n = notification_from_headers(channel, self.request.headers)
+
+ # Do app specific stuff with the notification here.
+ if n.resource_state == 'sync':
+ # Code to handle sync state.
+ elif n.resource_state == 'exists':
+ # Code to handle the exists state.
+ elif n.resource_state == 'not_exists':
+ # Code to handle the not exists state.
+
+
+Example of unsubscribing.
+
+ service.channels().stop(channel.body()).execute()
+"""
+from __future__ import absolute_import
+
+import datetime
+import uuid
+
+from googleapiclient import _helpers as util
+from googleapiclient import errors
+
+# The unix time epoch starts at midnight 1970.
+EPOCH = datetime.datetime(1970, 1, 1)
+
+# Map the names of the parameters in the JSON channel description to
+# the parameter names we use in the Channel class.
+CHANNEL_PARAMS = {
+ "address": "address",
+ "id": "id",
+ "expiration": "expiration",
+ "params": "params",
+ "resourceId": "resource_id",
+ "resourceUri": "resource_uri",
+ "type": "type",
+ "token": "token",
+}
+
+X_GOOG_CHANNEL_ID = "X-GOOG-CHANNEL-ID"
+X_GOOG_MESSAGE_NUMBER = "X-GOOG-MESSAGE-NUMBER"
+X_GOOG_RESOURCE_STATE = "X-GOOG-RESOURCE-STATE"
+X_GOOG_RESOURCE_URI = "X-GOOG-RESOURCE-URI"
+X_GOOG_RESOURCE_ID = "X-GOOG-RESOURCE-ID"
+
+
+def _upper_header_keys(headers):
+ new_headers = {}
+ for k, v in headers.items():
+ new_headers[k.upper()] = v
+ return new_headers
+
+
+class Notification(object):
+ """A Notification from a Channel.
+
+ Notifications are not usually constructed directly, but are returned
+ from functions like notification_from_headers().
+
+ Attributes:
+ message_number: int, The unique id number of this notification.
+ state: str, The state of the resource being monitored.
+ uri: str, The address of the resource being monitored.
+ resource_id: str, The unique identifier of the version of the resource at
+ this event.
+ """
+
+ @util.positional(5)
+ def __init__(self, message_number, state, resource_uri, resource_id):
+ """Notification constructor.
+
+ Args:
+ message_number: int, The unique id number of this notification.
+ state: str, The state of the resource being monitored. Can be one
+ of "exists", "not_exists", or "sync".
+ resource_uri: str, The address of the resource being monitored.
+ resource_id: str, The identifier of the watched resource.
+ """
+ self.message_number = message_number
+ self.state = state
+ self.resource_uri = resource_uri
+ self.resource_id = resource_id
+
+
+class Channel(object):
+ """A Channel for notifications.
+
+ Usually not constructed directly, instead it is returned from helper
+ functions like new_webhook_channel().
+
+ Attributes:
+ type: str, The type of delivery mechanism used by this channel. For
+ example, 'web_hook'.
+ id: str, A UUID for the channel.
+ token: str, An arbitrary string associated with the channel that
+ is delivered to the target address with each event delivered
+ over this channel.
+ address: str, The address of the receiving entity where events are
+ delivered. Specific to the channel type.
+ expiration: int, The time, in milliseconds from the epoch, when this
+ channel will expire.
+ params: dict, A dictionary of string to string, with additional parameters
+ controlling delivery channel behavior.
+ resource_id: str, An opaque id that identifies the resource that is
+ being watched. Stable across different API versions.
+ resource_uri: str, The canonicalized ID of the watched resource.
+ """
+
+ @util.positional(5)
+ def __init__(
+ self,
+ type,
+ id,
+ token,
+ address,
+ expiration=None,
+ params=None,
+ resource_id="",
+ resource_uri="",
+ ):
+ """Create a new Channel.
+
+ In user code, this Channel constructor will not typically be called
+ manually since there are functions for creating channels for each specific
+ type with a more customized set of arguments to pass.
+
+ Args:
+ type: str, The type of delivery mechanism used by this channel. For
+ example, 'web_hook'.
+ id: str, A UUID for the channel.
+ token: str, An arbitrary string associated with the channel that
+ is delivered to the target address with each event delivered
+ over this channel.
+ address: str, The address of the receiving entity where events are
+ delivered. Specific to the channel type.
+ expiration: int, The time, in milliseconds from the epoch, when this
+ channel will expire.
+ params: dict, A dictionary of string to string, with additional parameters
+ controlling delivery channel behavior.
+ resource_id: str, An opaque id that identifies the resource that is
+ being watched. Stable across different API versions.
+ resource_uri: str, The canonicalized ID of the watched resource.
+ """
+ self.type = type
+ self.id = id
+ self.token = token
+ self.address = address
+ self.expiration = expiration
+ self.params = params
+ self.resource_id = resource_id
+ self.resource_uri = resource_uri
+
+ def body(self):
+ """Build a body from the Channel.
+
+ Constructs a dictionary that's appropriate for passing into watch()
+ methods as the value of body argument.
+
+ Returns:
+ A dictionary representation of the channel.
+ """
+ result = {
+ "id": self.id,
+ "token": self.token,
+ "type": self.type,
+ "address": self.address,
+ }
+ if self.params:
+ result["params"] = self.params
+ if self.resource_id:
+ result["resourceId"] = self.resource_id
+ if self.resource_uri:
+ result["resourceUri"] = self.resource_uri
+ if self.expiration:
+ result["expiration"] = self.expiration
+
+ return result
+
+ def update(self, resp):
+ """Update a channel with information from the response of watch().
+
+ When a request is sent to watch() a resource, the response returned
+ from the watch() request is a dictionary with updated channel information,
+ such as the resource_id, which is needed when stopping a subscription.
+
+ Args:
+ resp: dict, The response from a watch() method.
+ """
+ for json_name, param_name in CHANNEL_PARAMS.items():
+ value = resp.get(json_name)
+ if value is not None:
+ setattr(self, param_name, value)
+
+
+def notification_from_headers(channel, headers):
+ """Parse a notification from the webhook request headers, validate
+ the notification, and return a Notification object.
+
+ Args:
+ channel: Channel, The channel that the notification is associated with.
+ headers: dict, A dictionary like object that contains the request headers
+ from the webhook HTTP request.
+
+ Returns:
+ A Notification object.
+
+ Raises:
+ errors.InvalidNotificationError if the notification is invalid.
+ ValueError if the X-GOOG-MESSAGE-NUMBER can't be converted to an int.
+ """
+ headers = _upper_header_keys(headers)
+ channel_id = headers[X_GOOG_CHANNEL_ID]
+ if channel.id != channel_id:
+ raise errors.InvalidNotificationError(
+ "Channel id mismatch: %s != %s" % (channel.id, channel_id)
+ )
+ else:
+ message_number = int(headers[X_GOOG_MESSAGE_NUMBER])
+ state = headers[X_GOOG_RESOURCE_STATE]
+ resource_uri = headers[X_GOOG_RESOURCE_URI]
+ resource_id = headers[X_GOOG_RESOURCE_ID]
+ return Notification(message_number, state, resource_uri, resource_id)
+
+
+@util.positional(2)
+def new_webhook_channel(url, token=None, expiration=None, params=None):
+ """Create a new webhook Channel.
+
+ Args:
+ url: str, URL to post notifications to.
+ token: str, An arbitrary string associated with the channel that
+ is delivered to the target address with each notification delivered
+ over this channel.
+ expiration: datetime.datetime, A time in the future when the channel
+ should expire. Can also be None if the subscription should use the
+ default expiration. Note that different services may have different
+ limits on how long a subscription lasts. Check the response from the
+ watch() method to see the value the service has set for an expiration
+ time.
+ params: dict, Extra parameters to pass on channel creation. Currently
+ not used for webhook channels.
+ """
+ expiration_ms = 0
+ if expiration:
+ delta = expiration - EPOCH
+ expiration_ms = (
+ delta.microseconds / 1000 + (delta.seconds + delta.days * 24 * 3600) * 1000
+ )
+ if expiration_ms < 0:
+ expiration_ms = 0
+
+ return Channel(
+ "web_hook",
+ str(uuid.uuid4()),
+ token,
+ url,
+ expiration=expiration_ms,
+ params=params,
+ )
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/discovery.py b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/discovery.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8f59bca5ab86dfdb20b286a3806584a4f1ea823
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/discovery.py
@@ -0,0 +1,1660 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""Client for discovery based APIs.
+
+A client library for Google's discovery based APIs.
+"""
+from __future__ import absolute_import
+
+__author__ = "jcgregorio@google.com (Joe Gregorio)"
+__all__ = ["build", "build_from_document", "fix_method_name", "key2param"]
+
+from collections import OrderedDict
+import collections.abc
+
+# Standard library imports
+import copy
+from email.generator import BytesGenerator
+from email.mime.multipart import MIMEMultipart
+from email.mime.nonmultipart import MIMENonMultipart
+import http.client as http_client
+import io
+import json
+import keyword
+import logging
+import mimetypes
+import os
+import re
+import urllib
+
+import google.api_core.client_options
+from google.auth.exceptions import MutualTLSChannelError
+from google.auth.transport import mtls
+from google.oauth2 import service_account
+
+# Third-party imports
+import httplib2
+import uritemplate
+
+try:
+ import google_auth_httplib2
+except ImportError: # pragma: NO COVER
+ google_auth_httplib2 = None
+
+try:
+ from google.api_core import universe
+
+ HAS_UNIVERSE = True
+except ImportError:
+ HAS_UNIVERSE = False
+
+# Local imports
+from googleapiclient import _auth, mimeparse
+from googleapiclient._helpers import _add_query_parameter, positional
+from googleapiclient.errors import (
+ HttpError,
+ InvalidJsonError,
+ MediaUploadSizeError,
+ UnacceptableMimeTypeError,
+ UnknownApiNameOrVersion,
+ UnknownFileType,
+)
+from googleapiclient.http import (
+ BatchHttpRequest,
+ HttpMock,
+ HttpMockSequence,
+ HttpRequest,
+ MediaFileUpload,
+ MediaUpload,
+ build_http,
+)
+from googleapiclient.model import JsonModel, MediaModel, RawModel
+from googleapiclient.schema import Schemas
+
+# The client library requires a version of httplib2 that supports RETRIES.
+httplib2.RETRIES = 1
+
+logger = logging.getLogger(__name__)
+
+URITEMPLATE = re.compile("{[^}]*}")
+VARNAME = re.compile("[a-zA-Z0-9_-]+")
+DISCOVERY_URI = (
+ "https://www.googleapis.com/discovery/v1/apis/" "{api}/{apiVersion}/rest"
+)
+V1_DISCOVERY_URI = DISCOVERY_URI
+V2_DISCOVERY_URI = (
+ "https://{api}.googleapis.com/$discovery/rest?" "version={apiVersion}"
+)
+DEFAULT_METHOD_DOC = "A description of how to use this function"
+HTTP_PAYLOAD_METHODS = frozenset(["PUT", "POST", "PATCH"])
+
+_MEDIA_SIZE_BIT_SHIFTS = {"KB": 10, "MB": 20, "GB": 30, "TB": 40}
+BODY_PARAMETER_DEFAULT_VALUE = {"description": "The request body.", "type": "object"}
+MEDIA_BODY_PARAMETER_DEFAULT_VALUE = {
+ "description": (
+ "The filename of the media request body, or an instance "
+ "of a MediaUpload object."
+ ),
+ "type": "string",
+ "required": False,
+}
+MEDIA_MIME_TYPE_PARAMETER_DEFAULT_VALUE = {
+ "description": (
+ "The MIME type of the media request body, or an instance "
+ "of a MediaUpload object."
+ ),
+ "type": "string",
+ "required": False,
+}
+_PAGE_TOKEN_NAMES = ("pageToken", "nextPageToken")
+
+# Parameters controlling mTLS behavior. See https://google.aip.dev/auth/4114.
+GOOGLE_API_USE_CLIENT_CERTIFICATE = "GOOGLE_API_USE_CLIENT_CERTIFICATE"
+GOOGLE_API_USE_MTLS_ENDPOINT = "GOOGLE_API_USE_MTLS_ENDPOINT"
+GOOGLE_CLOUD_UNIVERSE_DOMAIN = "GOOGLE_CLOUD_UNIVERSE_DOMAIN"
+DEFAULT_UNIVERSE = "googleapis.com"
+# Parameters accepted by the stack, but not visible via discovery.
+# TODO(dhermes): Remove 'userip' in 'v2'.
+STACK_QUERY_PARAMETERS = frozenset(["trace", "pp", "userip", "strict"])
+STACK_QUERY_PARAMETER_DEFAULT_VALUE = {"type": "string", "location": "query"}
+
+
+class APICoreVersionError(ValueError):
+ def __init__(self):
+ message = (
+ "google-api-core >= 2.18.0 is required to use the universe domain feature."
+ )
+ super().__init__(message)
+
+
+# Library-specific reserved words beyond Python keywords.
+RESERVED_WORDS = frozenset(["body"])
+
+# patch _write_lines to avoid munging '\r' into '\n'
+# ( https://bugs.python.org/issue18886 https://bugs.python.org/issue19003 )
+class _BytesGenerator(BytesGenerator):
+ _write_lines = BytesGenerator.write
+
+
+def fix_method_name(name):
+ """Fix method names to avoid '$' characters and reserved word conflicts.
+
+ Args:
+ name: string, method name.
+
+ Returns:
+ The name with '_' appended if the name is a reserved word and '$' and '-'
+ replaced with '_'.
+ """
+ name = name.replace("$", "_").replace("-", "_")
+ if keyword.iskeyword(name) or name in RESERVED_WORDS:
+ return name + "_"
+ else:
+ return name
+
+
+def key2param(key):
+ """Converts key names into parameter names.
+
+ For example, converting "max-results" -> "max_results"
+
+ Args:
+ key: string, the method key name.
+
+ Returns:
+ A safe method name based on the key name.
+ """
+ result = []
+ key = list(key)
+ if not key[0].isalpha():
+ result.append("x")
+ for c in key:
+ if c.isalnum():
+ result.append(c)
+ else:
+ result.append("_")
+
+ return "".join(result)
+
+
+@positional(2)
+def build(
+ serviceName,
+ version,
+ http=None,
+ discoveryServiceUrl=None,
+ developerKey=None,
+ model=None,
+ requestBuilder=HttpRequest,
+ credentials=None,
+ cache_discovery=True,
+ cache=None,
+ client_options=None,
+ adc_cert_path=None,
+ adc_key_path=None,
+ num_retries=1,
+ static_discovery=None,
+ always_use_jwt_access=False,
+):
+ """Construct a Resource for interacting with an API.
+
+ Construct a Resource object for interacting with an API. The serviceName and
+ version are the names from the Discovery service.
+
+ Args:
+ serviceName: string, name of the service.
+ version: string, the version of the service.
+ http: httplib2.Http, An instance of httplib2.Http or something that acts
+ like it that HTTP requests will be made through.
+ discoveryServiceUrl: string, a URI Template that points to the location of
+ the discovery service. It should have two parameters {api} and
+ {apiVersion} that when filled in produce an absolute URI to the discovery
+ document for that service.
+ developerKey: string, key obtained from
+ https://code.google.com/apis/console.
+ model: googleapiclient.Model, converts to and from the wire format.
+ requestBuilder: googleapiclient.http.HttpRequest, encapsulator for an HTTP
+ request.
+ credentials: oauth2client.Credentials or
+ google.auth.credentials.Credentials, credentials to be used for
+ authentication.
+ cache_discovery: Boolean, whether or not to cache the discovery doc.
+ cache: googleapiclient.discovery_cache.base.CacheBase, an optional
+ cache object for the discovery documents.
+ client_options: Mapping object or google.api_core.client_options, client
+ options to set user options on the client.
+ (1) The API endpoint should be set through client_options. If API endpoint
+ is not set, `GOOGLE_API_USE_MTLS_ENDPOINT` environment variable can be used
+ to control which endpoint to use.
+ (2) client_cert_source is not supported, client cert should be provided using
+ client_encrypted_cert_source instead. In order to use the provided client
+ cert, `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable must be
+ set to `true`.
+ More details on the environment variables are here:
+ https://google.aip.dev/auth/4114
+ adc_cert_path: str, client certificate file path to save the application
+ default client certificate for mTLS. This field is required if you want to
+ use the default client certificate. `GOOGLE_API_USE_CLIENT_CERTIFICATE`
+ environment variable must be set to `true` in order to use this field,
+ otherwise this field doesn't nothing.
+ More details on the environment variables are here:
+ https://google.aip.dev/auth/4114
+ adc_key_path: str, client encrypted private key file path to save the
+ application default client encrypted private key for mTLS. This field is
+ required if you want to use the default client certificate.
+ `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable must be set to
+ `true` in order to use this field, otherwise this field doesn't nothing.
+ More details on the environment variables are here:
+ https://google.aip.dev/auth/4114
+ num_retries: Integer, number of times to retry discovery with
+ randomized exponential backoff in case of intermittent/connection issues.
+ static_discovery: Boolean, whether or not to use the static discovery docs
+ included in the library. The default value for `static_discovery` depends
+ on the value of `discoveryServiceUrl`. `static_discovery` will default to
+ `True` when `discoveryServiceUrl` is also not provided, otherwise it will
+ default to `False`.
+ always_use_jwt_access: Boolean, whether always use self signed JWT for service
+ account credentials. This only applies to
+ google.oauth2.service_account.Credentials.
+
+ Returns:
+ A Resource object with methods for interacting with the service.
+
+ Raises:
+ google.auth.exceptions.MutualTLSChannelError: if there are any problems
+ setting up mutual TLS channel.
+ """
+ params = {"api": serviceName, "apiVersion": version}
+
+ # The default value for `static_discovery` depends on the value of
+ # `discoveryServiceUrl`. `static_discovery` will default to `True` when
+ # `discoveryServiceUrl` is also not provided, otherwise it will default to
+ # `False`. This is added for backwards compatability with
+ # google-api-python-client 1.x which does not support the `static_discovery`
+ # parameter.
+ if static_discovery is None:
+ if discoveryServiceUrl is None:
+ static_discovery = True
+ else:
+ static_discovery = False
+
+ if http is None:
+ discovery_http = build_http()
+ else:
+ discovery_http = http
+
+ service = None
+
+ for discovery_url in _discovery_service_uri_options(discoveryServiceUrl, version):
+ requested_url = uritemplate.expand(discovery_url, params)
+
+ try:
+ content = _retrieve_discovery_doc(
+ requested_url,
+ discovery_http,
+ cache_discovery,
+ serviceName,
+ version,
+ cache,
+ developerKey,
+ num_retries=num_retries,
+ static_discovery=static_discovery,
+ )
+ service = build_from_document(
+ content,
+ base=discovery_url,
+ http=http,
+ developerKey=developerKey,
+ model=model,
+ requestBuilder=requestBuilder,
+ credentials=credentials,
+ client_options=client_options,
+ adc_cert_path=adc_cert_path,
+ adc_key_path=adc_key_path,
+ always_use_jwt_access=always_use_jwt_access,
+ )
+ break # exit if a service was created
+ except HttpError as e:
+ if e.resp.status == http_client.NOT_FOUND:
+ continue
+ else:
+ raise e
+
+ # If discovery_http was created by this function, we are done with it
+ # and can safely close it
+ if http is None:
+ discovery_http.close()
+
+ if service is None:
+ raise UnknownApiNameOrVersion("name: %s version: %s" % (serviceName, version))
+ else:
+ return service
+
+
+def _discovery_service_uri_options(discoveryServiceUrl, version):
+ """
+ Returns Discovery URIs to be used for attempting to build the API Resource.
+
+ Args:
+ discoveryServiceUrl:
+ string, the Original Discovery Service URL preferred by the customer.
+ version:
+ string, API Version requested
+
+ Returns:
+ A list of URIs to be tried for the Service Discovery, in order.
+ """
+
+ if discoveryServiceUrl is not None:
+ return [discoveryServiceUrl]
+ if version is None:
+ # V1 Discovery won't work if the requested version is None
+ logger.warning(
+ "Discovery V1 does not support empty versions. Defaulting to V2..."
+ )
+ return [V2_DISCOVERY_URI]
+ else:
+ return [DISCOVERY_URI, V2_DISCOVERY_URI]
+
+
+def _retrieve_discovery_doc(
+ url,
+ http,
+ cache_discovery,
+ serviceName,
+ version,
+ cache=None,
+ developerKey=None,
+ num_retries=1,
+ static_discovery=True,
+):
+ """Retrieves the discovery_doc from cache or the internet.
+
+ Args:
+ url: string, the URL of the discovery document.
+ http: httplib2.Http, An instance of httplib2.Http or something that acts
+ like it through which HTTP requests will be made.
+ cache_discovery: Boolean, whether or not to cache the discovery doc.
+ serviceName: string, name of the service.
+ version: string, the version of the service.
+ cache: googleapiclient.discovery_cache.base.Cache, an optional cache
+ object for the discovery documents.
+ developerKey: string, Key for controlling API usage, generated
+ from the API Console.
+ num_retries: Integer, number of times to retry discovery with
+ randomized exponential backoff in case of intermittent/connection issues.
+ static_discovery: Boolean, whether or not to use the static discovery docs
+ included in the library.
+
+ Returns:
+ A unicode string representation of the discovery document.
+ """
+ from . import discovery_cache
+
+ if cache_discovery:
+ if cache is None:
+ cache = discovery_cache.autodetect()
+ if cache:
+ content = cache.get(url)
+ if content:
+ return content
+
+ # When `static_discovery=True`, use static discovery artifacts included
+ # with the library
+ if static_discovery:
+ content = discovery_cache.get_static_doc(serviceName, version)
+ if content:
+ return content
+ else:
+ raise UnknownApiNameOrVersion(
+ "name: %s version: %s" % (serviceName, version)
+ )
+
+ actual_url = url
+ # REMOTE_ADDR is defined by the CGI spec [RFC3875] as the environment
+ # variable that contains the network address of the client sending the
+ # request. If it exists then add that to the request for the discovery
+ # document to avoid exceeding the quota on discovery requests.
+ if "REMOTE_ADDR" in os.environ:
+ actual_url = _add_query_parameter(url, "userIp", os.environ["REMOTE_ADDR"])
+ if developerKey:
+ actual_url = _add_query_parameter(url, "key", developerKey)
+ logger.debug("URL being requested: GET %s", actual_url)
+
+ # Execute this request with retries build into HttpRequest
+ # Note that it will already raise an error if we don't get a 2xx response
+ req = HttpRequest(http, HttpRequest.null_postproc, actual_url)
+ resp, content = req.execute(num_retries=num_retries)
+
+ try:
+ content = content.decode("utf-8")
+ except AttributeError:
+ pass
+
+ try:
+ service = json.loads(content)
+ except ValueError as e:
+ logger.error("Failed to parse as JSON: " + content)
+ raise InvalidJsonError()
+ if cache_discovery and cache:
+ cache.set(url, content)
+ return content
+
+
+def _check_api_core_compatible_with_credentials_universe(credentials):
+ if not HAS_UNIVERSE:
+ credentials_universe = getattr(credentials, "universe_domain", None)
+ if credentials_universe and credentials_universe != DEFAULT_UNIVERSE:
+ raise APICoreVersionError
+
+
+@positional(1)
+def build_from_document(
+ service,
+ base=None,
+ future=None,
+ http=None,
+ developerKey=None,
+ model=None,
+ requestBuilder=HttpRequest,
+ credentials=None,
+ client_options=None,
+ adc_cert_path=None,
+ adc_key_path=None,
+ always_use_jwt_access=False,
+):
+ """Create a Resource for interacting with an API.
+
+ Same as `build()`, but constructs the Resource object from a discovery
+ document that is it given, as opposed to retrieving one over HTTP.
+
+ Args:
+ service: string or object, the JSON discovery document describing the API.
+ The value passed in may either be the JSON string or the deserialized
+ JSON.
+ base: string, base URI for all HTTP requests, usually the discovery URI.
+ This parameter is no longer used as rootUrl and servicePath are included
+ within the discovery document. (deprecated)
+ future: string, discovery document with future capabilities (deprecated).
+ http: httplib2.Http, An instance of httplib2.Http or something that acts
+ like it that HTTP requests will be made through.
+ developerKey: string, Key for controlling API usage, generated
+ from the API Console.
+ model: Model class instance that serializes and de-serializes requests and
+ responses.
+ requestBuilder: Takes an http request and packages it up to be executed.
+ credentials: oauth2client.Credentials or
+ google.auth.credentials.Credentials, credentials to be used for
+ authentication.
+ client_options: Mapping object or google.api_core.client_options, client
+ options to set user options on the client.
+ (1) The API endpoint should be set through client_options. If API endpoint
+ is not set, `GOOGLE_API_USE_MTLS_ENDPOINT` environment variable can be used
+ to control which endpoint to use.
+ (2) client_cert_source is not supported, client cert should be provided using
+ client_encrypted_cert_source instead. In order to use the provided client
+ cert, `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable must be
+ set to `true`.
+ More details on the environment variables are here:
+ https://google.aip.dev/auth/4114
+ adc_cert_path: str, client certificate file path to save the application
+ default client certificate for mTLS. This field is required if you want to
+ use the default client certificate. `GOOGLE_API_USE_CLIENT_CERTIFICATE`
+ environment variable must be set to `true` in order to use this field,
+ otherwise this field doesn't nothing.
+ More details on the environment variables are here:
+ https://google.aip.dev/auth/4114
+ adc_key_path: str, client encrypted private key file path to save the
+ application default client encrypted private key for mTLS. This field is
+ required if you want to use the default client certificate.
+ `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable must be set to
+ `true` in order to use this field, otherwise this field doesn't nothing.
+ More details on the environment variables are here:
+ https://google.aip.dev/auth/4114
+ always_use_jwt_access: Boolean, whether always use self signed JWT for service
+ account credentials. This only applies to
+ google.oauth2.service_account.Credentials.
+
+ Returns:
+ A Resource object with methods for interacting with the service.
+
+ Raises:
+ google.auth.exceptions.MutualTLSChannelError: if there are any problems
+ setting up mutual TLS channel.
+ """
+
+ if client_options is None:
+ client_options = google.api_core.client_options.ClientOptions()
+ if isinstance(client_options, collections.abc.Mapping):
+ client_options = google.api_core.client_options.from_dict(client_options)
+
+ if http is not None:
+ # if http is passed, the user cannot provide credentials
+ banned_options = [
+ (credentials, "credentials"),
+ (client_options.credentials_file, "client_options.credentials_file"),
+ ]
+ for option, name in banned_options:
+ if option is not None:
+ raise ValueError(
+ "Arguments http and {} are mutually exclusive".format(name)
+ )
+
+ if isinstance(service, str):
+ service = json.loads(service)
+ elif isinstance(service, bytes):
+ service = json.loads(service.decode("utf-8"))
+
+ if "rootUrl" not in service and isinstance(http, (HttpMock, HttpMockSequence)):
+ logger.error(
+ "You are using HttpMock or HttpMockSequence without"
+ + "having the service discovery doc in cache. Try calling "
+ + "build() without mocking once first to populate the "
+ + "cache."
+ )
+ raise InvalidJsonError()
+
+ # If an API Endpoint is provided on client options, use that as the base URL
+ base = urllib.parse.urljoin(service["rootUrl"], service["servicePath"])
+ universe_domain = None
+ if HAS_UNIVERSE:
+ universe_domain_env = os.getenv(GOOGLE_CLOUD_UNIVERSE_DOMAIN, None)
+ universe_domain = universe.determine_domain(
+ client_options.universe_domain, universe_domain_env
+ )
+ base = base.replace(universe.DEFAULT_UNIVERSE, universe_domain)
+ else:
+ client_universe = getattr(client_options, "universe_domain", None)
+ if client_universe:
+ raise APICoreVersionError
+
+ audience_for_self_signed_jwt = base
+ if client_options.api_endpoint:
+ base = client_options.api_endpoint
+
+ schema = Schemas(service)
+
+ # If the http client is not specified, then we must construct an http client
+ # to make requests. If the service has scopes, then we also need to setup
+ # authentication.
+ if http is None:
+ # Does the service require scopes?
+ scopes = list(
+ service.get("auth", {}).get("oauth2", {}).get("scopes", {}).keys()
+ )
+
+ # If so, then the we need to setup authentication if no developerKey is
+ # specified.
+ if scopes and not developerKey:
+ # Make sure the user didn't pass multiple credentials
+ if client_options.credentials_file and credentials:
+ raise google.api_core.exceptions.DuplicateCredentialArgs(
+ "client_options.credentials_file and credentials are mutually exclusive."
+ )
+ # Check for credentials file via client options
+ if client_options.credentials_file:
+ credentials = _auth.credentials_from_file(
+ client_options.credentials_file,
+ scopes=client_options.scopes,
+ quota_project_id=client_options.quota_project_id,
+ )
+ # If the user didn't pass in credentials, attempt to acquire application
+ # default credentials.
+ if credentials is None:
+ credentials = _auth.default_credentials(
+ scopes=client_options.scopes,
+ quota_project_id=client_options.quota_project_id,
+ )
+
+ # Check google-api-core >= 2.18.0 if credentials' universe != "googleapis.com".
+ _check_api_core_compatible_with_credentials_universe(credentials)
+
+ # The credentials need to be scoped.
+ # If the user provided scopes via client_options don't override them
+ if not client_options.scopes:
+ credentials = _auth.with_scopes(credentials, scopes)
+
+ # For google-auth service account credentials, enable self signed JWT if
+ # always_use_jwt_access is true.
+ if (
+ credentials
+ and isinstance(credentials, service_account.Credentials)
+ and always_use_jwt_access
+ and hasattr(service_account.Credentials, "with_always_use_jwt_access")
+ ):
+ credentials = credentials.with_always_use_jwt_access(always_use_jwt_access)
+ credentials._create_self_signed_jwt(audience_for_self_signed_jwt)
+
+ # If credentials are provided, create an authorized http instance;
+ # otherwise, skip authentication.
+ if credentials:
+ http = _auth.authorized_http(credentials)
+
+ # If the service doesn't require scopes then there is no need for
+ # authentication.
+ else:
+ http = build_http()
+
+ # Obtain client cert and create mTLS http channel if cert exists.
+ client_cert_to_use = None
+ use_client_cert = os.getenv(GOOGLE_API_USE_CLIENT_CERTIFICATE, "false")
+ if not use_client_cert in ("true", "false"):
+ raise MutualTLSChannelError(
+ "Unsupported GOOGLE_API_USE_CLIENT_CERTIFICATE value. Accepted values: true, false"
+ )
+ if client_options and client_options.client_cert_source:
+ raise MutualTLSChannelError(
+ "ClientOptions.client_cert_source is not supported, please use ClientOptions.client_encrypted_cert_source."
+ )
+ if use_client_cert == "true":
+ if (
+ client_options
+ and hasattr(client_options, "client_encrypted_cert_source")
+ and client_options.client_encrypted_cert_source
+ ):
+ client_cert_to_use = client_options.client_encrypted_cert_source
+ elif (
+ adc_cert_path and adc_key_path and mtls.has_default_client_cert_source()
+ ):
+ client_cert_to_use = mtls.default_client_encrypted_cert_source(
+ adc_cert_path, adc_key_path
+ )
+ if client_cert_to_use:
+ cert_path, key_path, passphrase = client_cert_to_use()
+
+ # The http object we built could be google_auth_httplib2.AuthorizedHttp
+ # or httplib2.Http. In the first case we need to extract the wrapped
+ # httplib2.Http object from google_auth_httplib2.AuthorizedHttp.
+ http_channel = (
+ http.http
+ if google_auth_httplib2
+ and isinstance(http, google_auth_httplib2.AuthorizedHttp)
+ else http
+ )
+ http_channel.add_certificate(key_path, cert_path, "", passphrase)
+
+ # If user doesn't provide api endpoint via client options, decide which
+ # api endpoint to use.
+ if "mtlsRootUrl" in service and (
+ not client_options or not client_options.api_endpoint
+ ):
+ mtls_endpoint = urllib.parse.urljoin(
+ service["mtlsRootUrl"], service["servicePath"]
+ )
+ use_mtls_endpoint = os.getenv(GOOGLE_API_USE_MTLS_ENDPOINT, "auto")
+
+ if not use_mtls_endpoint in ("never", "auto", "always"):
+ raise MutualTLSChannelError(
+ "Unsupported GOOGLE_API_USE_MTLS_ENDPOINT value. Accepted values: never, auto, always"
+ )
+
+ # Switch to mTLS endpoint, if environment variable is "always", or
+ # environment varibable is "auto" and client cert exists.
+ if use_mtls_endpoint == "always" or (
+ use_mtls_endpoint == "auto" and client_cert_to_use
+ ):
+ if HAS_UNIVERSE and universe_domain != universe.DEFAULT_UNIVERSE:
+ raise MutualTLSChannelError(
+ f"mTLS is not supported in any universe other than {universe.DEFAULT_UNIVERSE}."
+ )
+ base = mtls_endpoint
+ else:
+ # Check google-api-core >= 2.18.0 if credentials' universe != "googleapis.com".
+ http_credentials = getattr(http, "credentials", None)
+ _check_api_core_compatible_with_credentials_universe(http_credentials)
+
+ if model is None:
+ features = service.get("features", [])
+ model = JsonModel("dataWrapper" in features)
+
+ return Resource(
+ http=http,
+ baseUrl=base,
+ model=model,
+ developerKey=developerKey,
+ requestBuilder=requestBuilder,
+ resourceDesc=service,
+ rootDesc=service,
+ schema=schema,
+ universe_domain=universe_domain,
+ )
+
+
+def _cast(value, schema_type):
+ """Convert value to a string based on JSON Schema type.
+
+ See http://tools.ietf.org/html/draft-zyp-json-schema-03 for more details on
+ JSON Schema.
+
+ Args:
+ value: any, the value to convert
+ schema_type: string, the type that value should be interpreted as
+
+ Returns:
+ A string representation of 'value' based on the schema_type.
+ """
+ if schema_type == "string":
+ if type(value) == type("") or type(value) == type(""):
+ return value
+ else:
+ return str(value)
+ elif schema_type == "integer":
+ return str(int(value))
+ elif schema_type == "number":
+ return str(float(value))
+ elif schema_type == "boolean":
+ return str(bool(value)).lower()
+ else:
+ if type(value) == type("") or type(value) == type(""):
+ return value
+ else:
+ return str(value)
+
+
+def _media_size_to_long(maxSize):
+ """Convert a string media size, such as 10GB or 3TB into an integer.
+
+ Args:
+ maxSize: string, size as a string, such as 2MB or 7GB.
+
+ Returns:
+ The size as an integer value.
+ """
+ if len(maxSize) < 2:
+ return 0
+ units = maxSize[-2:].upper()
+ bit_shift = _MEDIA_SIZE_BIT_SHIFTS.get(units)
+ if bit_shift is not None:
+ return int(maxSize[:-2]) << bit_shift
+ else:
+ return int(maxSize)
+
+
+def _media_path_url_from_info(root_desc, path_url):
+ """Creates an absolute media path URL.
+
+ Constructed using the API root URI and service path from the discovery
+ document and the relative path for the API method.
+
+ Args:
+ root_desc: Dictionary; the entire original deserialized discovery document.
+ path_url: String; the relative URL for the API method. Relative to the API
+ root, which is specified in the discovery document.
+
+ Returns:
+ String; the absolute URI for media upload for the API method.
+ """
+ return "%(root)supload/%(service_path)s%(path)s" % {
+ "root": root_desc["rootUrl"],
+ "service_path": root_desc["servicePath"],
+ "path": path_url,
+ }
+
+
+def _fix_up_parameters(method_desc, root_desc, http_method, schema):
+ """Updates parameters of an API method with values specific to this library.
+
+ Specifically, adds whatever global parameters are specified by the API to the
+ parameters for the individual method. Also adds parameters which don't
+ appear in the discovery document, but are available to all discovery based
+ APIs (these are listed in STACK_QUERY_PARAMETERS).
+
+ SIDE EFFECTS: This updates the parameters dictionary object in the method
+ description.
+
+ Args:
+ method_desc: Dictionary with metadata describing an API method. Value comes
+ from the dictionary of methods stored in the 'methods' key in the
+ deserialized discovery document.
+ root_desc: Dictionary; the entire original deserialized discovery document.
+ http_method: String; the HTTP method used to call the API method described
+ in method_desc.
+ schema: Object, mapping of schema names to schema descriptions.
+
+ Returns:
+ The updated Dictionary stored in the 'parameters' key of the method
+ description dictionary.
+ """
+ parameters = method_desc.setdefault("parameters", {})
+
+ # Add in the parameters common to all methods.
+ for name, description in root_desc.get("parameters", {}).items():
+ parameters[name] = description
+
+ # Add in undocumented query parameters.
+ for name in STACK_QUERY_PARAMETERS:
+ parameters[name] = STACK_QUERY_PARAMETER_DEFAULT_VALUE.copy()
+
+ # Add 'body' (our own reserved word) to parameters if the method supports
+ # a request payload.
+ if http_method in HTTP_PAYLOAD_METHODS and "request" in method_desc:
+ body = BODY_PARAMETER_DEFAULT_VALUE.copy()
+ body.update(method_desc["request"])
+ parameters["body"] = body
+
+ return parameters
+
+
+def _fix_up_media_upload(method_desc, root_desc, path_url, parameters):
+ """Adds 'media_body' and 'media_mime_type' parameters if supported by method.
+
+ SIDE EFFECTS: If there is a 'mediaUpload' in the method description, adds
+ 'media_upload' key to parameters.
+
+ Args:
+ method_desc: Dictionary with metadata describing an API method. Value comes
+ from the dictionary of methods stored in the 'methods' key in the
+ deserialized discovery document.
+ root_desc: Dictionary; the entire original deserialized discovery document.
+ path_url: String; the relative URL for the API method. Relative to the API
+ root, which is specified in the discovery document.
+ parameters: A dictionary describing method parameters for method described
+ in method_desc.
+
+ Returns:
+ Triple (accept, max_size, media_path_url) where:
+ - accept is a list of strings representing what content types are
+ accepted for media upload. Defaults to empty list if not in the
+ discovery document.
+ - max_size is a long representing the max size in bytes allowed for a
+ media upload. Defaults to 0L if not in the discovery document.
+ - media_path_url is a String; the absolute URI for media upload for the
+ API method. Constructed using the API root URI and service path from
+ the discovery document and the relative path for the API method. If
+ media upload is not supported, this is None.
+ """
+ media_upload = method_desc.get("mediaUpload", {})
+ accept = media_upload.get("accept", [])
+ max_size = _media_size_to_long(media_upload.get("maxSize", ""))
+ media_path_url = None
+
+ if media_upload:
+ media_path_url = _media_path_url_from_info(root_desc, path_url)
+ parameters["media_body"] = MEDIA_BODY_PARAMETER_DEFAULT_VALUE.copy()
+ parameters["media_mime_type"] = MEDIA_MIME_TYPE_PARAMETER_DEFAULT_VALUE.copy()
+
+ return accept, max_size, media_path_url
+
+
+def _fix_up_method_description(method_desc, root_desc, schema):
+ """Updates a method description in a discovery document.
+
+ SIDE EFFECTS: Changes the parameters dictionary in the method description with
+ extra parameters which are used locally.
+
+ Args:
+ method_desc: Dictionary with metadata describing an API method. Value comes
+ from the dictionary of methods stored in the 'methods' key in the
+ deserialized discovery document.
+ root_desc: Dictionary; the entire original deserialized discovery document.
+ schema: Object, mapping of schema names to schema descriptions.
+
+ Returns:
+ Tuple (path_url, http_method, method_id, accept, max_size, media_path_url)
+ where:
+ - path_url is a String; the relative URL for the API method. Relative to
+ the API root, which is specified in the discovery document.
+ - http_method is a String; the HTTP method used to call the API method
+ described in the method description.
+ - method_id is a String; the name of the RPC method associated with the
+ API method, and is in the method description in the 'id' key.
+ - accept is a list of strings representing what content types are
+ accepted for media upload. Defaults to empty list if not in the
+ discovery document.
+ - max_size is a long representing the max size in bytes allowed for a
+ media upload. Defaults to 0L if not in the discovery document.
+ - media_path_url is a String; the absolute URI for media upload for the
+ API method. Constructed using the API root URI and service path from
+ the discovery document and the relative path for the API method. If
+ media upload is not supported, this is None.
+ """
+ path_url = method_desc["path"]
+ http_method = method_desc["httpMethod"]
+ method_id = method_desc["id"]
+
+ parameters = _fix_up_parameters(method_desc, root_desc, http_method, schema)
+ # Order is important. `_fix_up_media_upload` needs `method_desc` to have a
+ # 'parameters' key and needs to know if there is a 'body' parameter because it
+ # also sets a 'media_body' parameter.
+ accept, max_size, media_path_url = _fix_up_media_upload(
+ method_desc, root_desc, path_url, parameters
+ )
+
+ return path_url, http_method, method_id, accept, max_size, media_path_url
+
+
+def _fix_up_media_path_base_url(media_path_url, base_url):
+ """
+ Update the media upload base url if its netloc doesn't match base url netloc.
+
+ This can happen in case the base url was overridden by
+ client_options.api_endpoint.
+
+ Args:
+ media_path_url: String; the absolute URI for media upload.
+ base_url: string, base URL for the API. All requests are relative to this URI.
+
+ Returns:
+ String; the absolute URI for media upload.
+ """
+ parsed_media_url = urllib.parse.urlparse(media_path_url)
+ parsed_base_url = urllib.parse.urlparse(base_url)
+ if parsed_media_url.netloc == parsed_base_url.netloc:
+ return media_path_url
+ return urllib.parse.urlunparse(
+ parsed_media_url._replace(netloc=parsed_base_url.netloc)
+ )
+
+
+def _urljoin(base, url):
+ """Custom urljoin replacement supporting : before / in url."""
+ # In general, it's unsafe to simply join base and url. However, for
+ # the case of discovery documents, we know:
+ # * base will never contain params, query, or fragment
+ # * url will never contain a scheme or net_loc.
+ # In general, this means we can safely join on /; we just need to
+ # ensure we end up with precisely one / joining base and url. The
+ # exception here is the case of media uploads, where url will be an
+ # absolute url.
+ if url.startswith("http://") or url.startswith("https://"):
+ return urllib.parse.urljoin(base, url)
+ new_base = base if base.endswith("/") else base + "/"
+ new_url = url[1:] if url.startswith("/") else url
+ return new_base + new_url
+
+
+# TODO(dhermes): Convert this class to ResourceMethod and make it callable
+class ResourceMethodParameters(object):
+ """Represents the parameters associated with a method.
+
+ Attributes:
+ argmap: Map from method parameter name (string) to query parameter name
+ (string).
+ required_params: List of required parameters (represented by parameter
+ name as string).
+ repeated_params: List of repeated parameters (represented by parameter
+ name as string).
+ pattern_params: Map from method parameter name (string) to regular
+ expression (as a string). If the pattern is set for a parameter, the
+ value for that parameter must match the regular expression.
+ query_params: List of parameters (represented by parameter name as string)
+ that will be used in the query string.
+ path_params: Set of parameters (represented by parameter name as string)
+ that will be used in the base URL path.
+ param_types: Map from method parameter name (string) to parameter type. Type
+ can be any valid JSON schema type; valid values are 'any', 'array',
+ 'boolean', 'integer', 'number', 'object', or 'string'. Reference:
+ http://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
+ enum_params: Map from method parameter name (string) to list of strings,
+ where each list of strings is the list of acceptable enum values.
+ """
+
+ def __init__(self, method_desc):
+ """Constructor for ResourceMethodParameters.
+
+ Sets default values and defers to set_parameters to populate.
+
+ Args:
+ method_desc: Dictionary with metadata describing an API method. Value
+ comes from the dictionary of methods stored in the 'methods' key in
+ the deserialized discovery document.
+ """
+ self.argmap = {}
+ self.required_params = []
+ self.repeated_params = []
+ self.pattern_params = {}
+ self.query_params = []
+ # TODO(dhermes): Change path_params to a list if the extra URITEMPLATE
+ # parsing is gotten rid of.
+ self.path_params = set()
+ self.param_types = {}
+ self.enum_params = {}
+
+ self.set_parameters(method_desc)
+
+ def set_parameters(self, method_desc):
+ """Populates maps and lists based on method description.
+
+ Iterates through each parameter for the method and parses the values from
+ the parameter dictionary.
+
+ Args:
+ method_desc: Dictionary with metadata describing an API method. Value
+ comes from the dictionary of methods stored in the 'methods' key in
+ the deserialized discovery document.
+ """
+ parameters = method_desc.get("parameters", {})
+ sorted_parameters = OrderedDict(sorted(parameters.items()))
+ for arg, desc in sorted_parameters.items():
+ param = key2param(arg)
+ self.argmap[param] = arg
+
+ if desc.get("pattern"):
+ self.pattern_params[param] = desc["pattern"]
+ if desc.get("enum"):
+ self.enum_params[param] = desc["enum"]
+ if desc.get("required"):
+ self.required_params.append(param)
+ if desc.get("repeated"):
+ self.repeated_params.append(param)
+ if desc.get("location") == "query":
+ self.query_params.append(param)
+ if desc.get("location") == "path":
+ self.path_params.add(param)
+ self.param_types[param] = desc.get("type", "string")
+
+ # TODO(dhermes): Determine if this is still necessary. Discovery based APIs
+ # should have all path parameters already marked with
+ # 'location: path'.
+ for match in URITEMPLATE.finditer(method_desc["path"]):
+ for namematch in VARNAME.finditer(match.group(0)):
+ name = key2param(namematch.group(0))
+ self.path_params.add(name)
+ if name in self.query_params:
+ self.query_params.remove(name)
+
+
+def createMethod(methodName, methodDesc, rootDesc, schema):
+ """Creates a method for attaching to a Resource.
+
+ Args:
+ methodName: string, name of the method to use.
+ methodDesc: object, fragment of deserialized discovery document that
+ describes the method.
+ rootDesc: object, the entire deserialized discovery document.
+ schema: object, mapping of schema names to schema descriptions.
+ """
+ methodName = fix_method_name(methodName)
+ (
+ pathUrl,
+ httpMethod,
+ methodId,
+ accept,
+ maxSize,
+ mediaPathUrl,
+ ) = _fix_up_method_description(methodDesc, rootDesc, schema)
+
+ parameters = ResourceMethodParameters(methodDesc)
+
+ def method(self, **kwargs):
+ # Don't bother with doc string, it will be over-written by createMethod.
+
+ # Validate credentials for the configured universe.
+ self._validate_credentials()
+
+ for name in kwargs:
+ if name not in parameters.argmap:
+ raise TypeError("Got an unexpected keyword argument {}".format(name))
+
+ # Remove args that have a value of None.
+ keys = list(kwargs.keys())
+ for name in keys:
+ if kwargs[name] is None:
+ del kwargs[name]
+
+ for name in parameters.required_params:
+ if name not in kwargs:
+ # temporary workaround for non-paging methods incorrectly requiring
+ # page token parameter (cf. drive.changes.watch vs. drive.changes.list)
+ if name not in _PAGE_TOKEN_NAMES or _findPageTokenName(
+ _methodProperties(methodDesc, schema, "response")
+ ):
+ raise TypeError('Missing required parameter "%s"' % name)
+
+ for name, regex in parameters.pattern_params.items():
+ if name in kwargs:
+ if isinstance(kwargs[name], str):
+ pvalues = [kwargs[name]]
+ else:
+ pvalues = kwargs[name]
+ for pvalue in pvalues:
+ if re.match(regex, pvalue) is None:
+ raise TypeError(
+ 'Parameter "%s" value "%s" does not match the pattern "%s"'
+ % (name, pvalue, regex)
+ )
+
+ for name, enums in parameters.enum_params.items():
+ if name in kwargs:
+ # We need to handle the case of a repeated enum
+ # name differently, since we want to handle both
+ # arg='value' and arg=['value1', 'value2']
+ if name in parameters.repeated_params and not isinstance(
+ kwargs[name], str
+ ):
+ values = kwargs[name]
+ else:
+ values = [kwargs[name]]
+ for value in values:
+ if value not in enums:
+ raise TypeError(
+ 'Parameter "%s" value "%s" is not an allowed value in "%s"'
+ % (name, value, str(enums))
+ )
+
+ actual_query_params = {}
+ actual_path_params = {}
+ for key, value in kwargs.items():
+ to_type = parameters.param_types.get(key, "string")
+ # For repeated parameters we cast each member of the list.
+ if key in parameters.repeated_params and type(value) == type([]):
+ cast_value = [_cast(x, to_type) for x in value]
+ else:
+ cast_value = _cast(value, to_type)
+ if key in parameters.query_params:
+ actual_query_params[parameters.argmap[key]] = cast_value
+ if key in parameters.path_params:
+ actual_path_params[parameters.argmap[key]] = cast_value
+ body_value = kwargs.get("body", None)
+ media_filename = kwargs.get("media_body", None)
+ media_mime_type = kwargs.get("media_mime_type", None)
+
+ if self._developerKey:
+ actual_query_params["key"] = self._developerKey
+
+ model = self._model
+ if methodName.endswith("_media"):
+ model = MediaModel()
+ elif "response" not in methodDesc:
+ model = RawModel()
+
+ headers = {}
+ headers, params, query, body = model.request(
+ headers, actual_path_params, actual_query_params, body_value
+ )
+
+ expanded_url = uritemplate.expand(pathUrl, params)
+ url = _urljoin(self._baseUrl, expanded_url + query)
+
+ resumable = None
+ multipart_boundary = ""
+
+ if media_filename:
+ # Ensure we end up with a valid MediaUpload object.
+ if isinstance(media_filename, str):
+ if media_mime_type is None:
+ logger.warning(
+ "media_mime_type argument not specified: trying to auto-detect for %s",
+ media_filename,
+ )
+ media_mime_type, _ = mimetypes.guess_type(media_filename)
+ if media_mime_type is None:
+ raise UnknownFileType(media_filename)
+ if not mimeparse.best_match([media_mime_type], ",".join(accept)):
+ raise UnacceptableMimeTypeError(media_mime_type)
+ media_upload = MediaFileUpload(media_filename, mimetype=media_mime_type)
+ elif isinstance(media_filename, MediaUpload):
+ media_upload = media_filename
+ else:
+ raise TypeError("media_filename must be str or MediaUpload.")
+
+ # Check the maxSize
+ if media_upload.size() is not None and media_upload.size() > maxSize > 0:
+ raise MediaUploadSizeError("Media larger than: %s" % maxSize)
+
+ # Use the media path uri for media uploads
+ expanded_url = uritemplate.expand(mediaPathUrl, params)
+ url = _urljoin(self._baseUrl, expanded_url + query)
+ url = _fix_up_media_path_base_url(url, self._baseUrl)
+ if media_upload.resumable():
+ url = _add_query_parameter(url, "uploadType", "resumable")
+
+ if media_upload.resumable():
+ # This is all we need to do for resumable, if the body exists it gets
+ # sent in the first request, otherwise an empty body is sent.
+ resumable = media_upload
+ else:
+ # A non-resumable upload
+ if body is None:
+ # This is a simple media upload
+ headers["content-type"] = media_upload.mimetype()
+ body = media_upload.getbytes(0, media_upload.size())
+ url = _add_query_parameter(url, "uploadType", "media")
+ else:
+ # This is a multipart/related upload.
+ msgRoot = MIMEMultipart("related")
+ # msgRoot should not write out it's own headers
+ setattr(msgRoot, "_write_headers", lambda self: None)
+
+ # attach the body as one part
+ msg = MIMENonMultipart(*headers["content-type"].split("/"))
+ msg.set_payload(body)
+ msgRoot.attach(msg)
+
+ # attach the media as the second part
+ msg = MIMENonMultipart(*media_upload.mimetype().split("/"))
+ msg["Content-Transfer-Encoding"] = "binary"
+
+ payload = media_upload.getbytes(0, media_upload.size())
+ msg.set_payload(payload)
+ msgRoot.attach(msg)
+ # encode the body: note that we can't use `as_string`, because
+ # it plays games with `From ` lines.
+ fp = io.BytesIO()
+ g = _BytesGenerator(fp, mangle_from_=False)
+ g.flatten(msgRoot, unixfrom=False)
+ body = fp.getvalue()
+
+ multipart_boundary = msgRoot.get_boundary()
+ headers["content-type"] = (
+ "multipart/related; " 'boundary="%s"'
+ ) % multipart_boundary
+ url = _add_query_parameter(url, "uploadType", "multipart")
+
+ logger.debug("URL being requested: %s %s" % (httpMethod, url))
+ return self._requestBuilder(
+ self._http,
+ model.response,
+ url,
+ method=httpMethod,
+ body=body,
+ headers=headers,
+ methodId=methodId,
+ resumable=resumable,
+ )
+
+ docs = [methodDesc.get("description", DEFAULT_METHOD_DOC), "\n\n"]
+ if len(parameters.argmap) > 0:
+ docs.append("Args:\n")
+
+ # Skip undocumented params and params common to all methods.
+ skip_parameters = list(rootDesc.get("parameters", {}).keys())
+ skip_parameters.extend(STACK_QUERY_PARAMETERS)
+
+ all_args = list(parameters.argmap.keys())
+ args_ordered = [key2param(s) for s in methodDesc.get("parameterOrder", [])]
+
+ # Move body to the front of the line.
+ if "body" in all_args:
+ args_ordered.append("body")
+
+ for name in sorted(all_args):
+ if name not in args_ordered:
+ args_ordered.append(name)
+
+ for arg in args_ordered:
+ if arg in skip_parameters:
+ continue
+
+ repeated = ""
+ if arg in parameters.repeated_params:
+ repeated = " (repeated)"
+ required = ""
+ if arg in parameters.required_params:
+ required = " (required)"
+ paramdesc = methodDesc["parameters"][parameters.argmap[arg]]
+ paramdoc = paramdesc.get("description", "A parameter")
+ if "$ref" in paramdesc:
+ docs.append(
+ (" %s: object, %s%s%s\n The object takes the form of:\n\n%s\n\n")
+ % (
+ arg,
+ paramdoc,
+ required,
+ repeated,
+ schema.prettyPrintByName(paramdesc["$ref"]),
+ )
+ )
+ else:
+ paramtype = paramdesc.get("type", "string")
+ docs.append(
+ " %s: %s, %s%s%s\n" % (arg, paramtype, paramdoc, required, repeated)
+ )
+ enum = paramdesc.get("enum", [])
+ enumDesc = paramdesc.get("enumDescriptions", [])
+ if enum and enumDesc:
+ docs.append(" Allowed values\n")
+ for (name, desc) in zip(enum, enumDesc):
+ docs.append(" %s - %s\n" % (name, desc))
+ if "response" in methodDesc:
+ if methodName.endswith("_media"):
+ docs.append("\nReturns:\n The media object as a string.\n\n ")
+ else:
+ docs.append("\nReturns:\n An object of the form:\n\n ")
+ docs.append(schema.prettyPrintSchema(methodDesc["response"]))
+
+ setattr(method, "__doc__", "".join(docs))
+ return (methodName, method)
+
+
+def createNextMethod(
+ methodName,
+ pageTokenName="pageToken",
+ nextPageTokenName="nextPageToken",
+ isPageTokenParameter=True,
+):
+ """Creates any _next methods for attaching to a Resource.
+
+ The _next methods allow for easy iteration through list() responses.
+
+ Args:
+ methodName: string, name of the method to use.
+ pageTokenName: string, name of request page token field.
+ nextPageTokenName: string, name of response page token field.
+ isPageTokenParameter: Boolean, True if request page token is a query
+ parameter, False if request page token is a field of the request body.
+ """
+ methodName = fix_method_name(methodName)
+
+ def methodNext(self, previous_request, previous_response):
+ """Retrieves the next page of results.
+
+ Args:
+ previous_request: The request for the previous page. (required)
+ previous_response: The response from the request for the previous page. (required)
+
+ Returns:
+ A request object that you can call 'execute()' on to request the next
+ page. Returns None if there are no more items in the collection.
+ """
+ # Retrieve nextPageToken from previous_response
+ # Use as pageToken in previous_request to create new request.
+
+ nextPageToken = previous_response.get(nextPageTokenName, None)
+ if not nextPageToken:
+ return None
+
+ request = copy.copy(previous_request)
+
+ if isPageTokenParameter:
+ # Replace pageToken value in URI
+ request.uri = _add_query_parameter(
+ request.uri, pageTokenName, nextPageToken
+ )
+ logger.debug("Next page request URL: %s %s" % (methodName, request.uri))
+ else:
+ # Replace pageToken value in request body
+ model = self._model
+ body = model.deserialize(request.body)
+ body[pageTokenName] = nextPageToken
+ request.body = model.serialize(body)
+ request.body_size = len(request.body)
+ if "content-length" in request.headers:
+ del request.headers["content-length"]
+ logger.debug("Next page request body: %s %s" % (methodName, body))
+
+ return request
+
+ return (methodName, methodNext)
+
+
+class Resource(object):
+ """A class for interacting with a resource."""
+
+ def __init__(
+ self,
+ http,
+ baseUrl,
+ model,
+ requestBuilder,
+ developerKey,
+ resourceDesc,
+ rootDesc,
+ schema,
+ universe_domain=universe.DEFAULT_UNIVERSE if HAS_UNIVERSE else "",
+ ):
+ """Build a Resource from the API description.
+
+ Args:
+ http: httplib2.Http, Object to make http requests with.
+ baseUrl: string, base URL for the API. All requests are relative to this
+ URI.
+ model: googleapiclient.Model, converts to and from the wire format.
+ requestBuilder: class or callable that instantiates an
+ googleapiclient.HttpRequest object.
+ developerKey: string, key obtained from
+ https://code.google.com/apis/console
+ resourceDesc: object, section of deserialized discovery document that
+ describes a resource. Note that the top level discovery document
+ is considered a resource.
+ rootDesc: object, the entire deserialized discovery document.
+ schema: object, mapping of schema names to schema descriptions.
+ universe_domain: string, the universe for the API. The default universe
+ is "googleapis.com".
+ """
+ self._dynamic_attrs = []
+
+ self._http = http
+ self._baseUrl = baseUrl
+ self._model = model
+ self._developerKey = developerKey
+ self._requestBuilder = requestBuilder
+ self._resourceDesc = resourceDesc
+ self._rootDesc = rootDesc
+ self._schema = schema
+ self._universe_domain = universe_domain
+ self._credentials_validated = False
+
+ self._set_service_methods()
+
+ def _set_dynamic_attr(self, attr_name, value):
+ """Sets an instance attribute and tracks it in a list of dynamic attributes.
+
+ Args:
+ attr_name: string; The name of the attribute to be set
+ value: The value being set on the object and tracked in the dynamic cache.
+ """
+ self._dynamic_attrs.append(attr_name)
+ self.__dict__[attr_name] = value
+
+ def __getstate__(self):
+ """Trim the state down to something that can be pickled.
+
+ Uses the fact that the instance variable _dynamic_attrs holds attrs that
+ will be wiped and restored on pickle serialization.
+ """
+ state_dict = copy.copy(self.__dict__)
+ for dynamic_attr in self._dynamic_attrs:
+ del state_dict[dynamic_attr]
+ del state_dict["_dynamic_attrs"]
+ return state_dict
+
+ def __setstate__(self, state):
+ """Reconstitute the state of the object from being pickled.
+
+ Uses the fact that the instance variable _dynamic_attrs holds attrs that
+ will be wiped and restored on pickle serialization.
+ """
+ self.__dict__.update(state)
+ self._dynamic_attrs = []
+ self._set_service_methods()
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc, exc_tb):
+ self.close()
+
+ def close(self):
+ """Close httplib2 connections."""
+ # httplib2 leaves sockets open by default.
+ # Cleanup using the `close` method.
+ # https://github.com/httplib2/httplib2/issues/148
+ self._http.close()
+
+ def _set_service_methods(self):
+ self._add_basic_methods(self._resourceDesc, self._rootDesc, self._schema)
+ self._add_nested_resources(self._resourceDesc, self._rootDesc, self._schema)
+ self._add_next_methods(self._resourceDesc, self._schema)
+
+ def _add_basic_methods(self, resourceDesc, rootDesc, schema):
+ # If this is the root Resource, add a new_batch_http_request() method.
+ if resourceDesc == rootDesc:
+ batch_uri = "%s%s" % (
+ rootDesc["rootUrl"],
+ rootDesc.get("batchPath", "batch"),
+ )
+
+ def new_batch_http_request(callback=None):
+ """Create a BatchHttpRequest object based on the discovery document.
+
+ Args:
+ callback: callable, A callback to be called for each response, of the
+ form callback(id, response, exception). The first parameter is the
+ request id, and the second is the deserialized response object. The
+ third is an apiclient.errors.HttpError exception object if an HTTP
+ error occurred while processing the request, or None if no error
+ occurred.
+
+ Returns:
+ A BatchHttpRequest object based on the discovery document.
+ """
+ return BatchHttpRequest(callback=callback, batch_uri=batch_uri)
+
+ self._set_dynamic_attr("new_batch_http_request", new_batch_http_request)
+
+ # Add basic methods to Resource
+ if "methods" in resourceDesc:
+ for methodName, methodDesc in resourceDesc["methods"].items():
+ fixedMethodName, method = createMethod(
+ methodName, methodDesc, rootDesc, schema
+ )
+ self._set_dynamic_attr(
+ fixedMethodName, method.__get__(self, self.__class__)
+ )
+ # Add in _media methods. The functionality of the attached method will
+ # change when it sees that the method name ends in _media.
+ if methodDesc.get("supportsMediaDownload", False):
+ fixedMethodName, method = createMethod(
+ methodName + "_media", methodDesc, rootDesc, schema
+ )
+ self._set_dynamic_attr(
+ fixedMethodName, method.__get__(self, self.__class__)
+ )
+
+ def _add_nested_resources(self, resourceDesc, rootDesc, schema):
+ # Add in nested resources
+ if "resources" in resourceDesc:
+
+ def createResourceMethod(methodName, methodDesc):
+ """Create a method on the Resource to access a nested Resource.
+
+ Args:
+ methodName: string, name of the method to use.
+ methodDesc: object, fragment of deserialized discovery document that
+ describes the method.
+ """
+ methodName = fix_method_name(methodName)
+
+ def methodResource(self):
+ return Resource(
+ http=self._http,
+ baseUrl=self._baseUrl,
+ model=self._model,
+ developerKey=self._developerKey,
+ requestBuilder=self._requestBuilder,
+ resourceDesc=methodDesc,
+ rootDesc=rootDesc,
+ schema=schema,
+ universe_domain=self._universe_domain,
+ )
+
+ setattr(methodResource, "__doc__", "A collection resource.")
+ setattr(methodResource, "__is_resource__", True)
+
+ return (methodName, methodResource)
+
+ for methodName, methodDesc in resourceDesc["resources"].items():
+ fixedMethodName, method = createResourceMethod(methodName, methodDesc)
+ self._set_dynamic_attr(
+ fixedMethodName, method.__get__(self, self.__class__)
+ )
+
+ def _add_next_methods(self, resourceDesc, schema):
+ # Add _next() methods if and only if one of the names 'pageToken' or
+ # 'nextPageToken' occurs among the fields of both the method's response
+ # type either the method's request (query parameters) or request body.
+ if "methods" not in resourceDesc:
+ return
+ for methodName, methodDesc in resourceDesc["methods"].items():
+ nextPageTokenName = _findPageTokenName(
+ _methodProperties(methodDesc, schema, "response")
+ )
+ if not nextPageTokenName:
+ continue
+ isPageTokenParameter = True
+ pageTokenName = _findPageTokenName(methodDesc.get("parameters", {}))
+ if not pageTokenName:
+ isPageTokenParameter = False
+ pageTokenName = _findPageTokenName(
+ _methodProperties(methodDesc, schema, "request")
+ )
+ if not pageTokenName:
+ continue
+ fixedMethodName, method = createNextMethod(
+ methodName + "_next",
+ pageTokenName,
+ nextPageTokenName,
+ isPageTokenParameter,
+ )
+ self._set_dynamic_attr(
+ fixedMethodName, method.__get__(self, self.__class__)
+ )
+
+ def _validate_credentials(self):
+ """Validates client's and credentials' universe domains are consistent.
+
+ Returns:
+ bool: True iff the configured universe domain is valid.
+
+ Raises:
+ UniverseMismatchError: If the configured universe domain is not valid.
+ """
+ credentials = getattr(self._http, "credentials", None)
+
+ self._credentials_validated = (
+ (
+ self._credentials_validated
+ or universe.compare_domains(self._universe_domain, credentials)
+ )
+ if HAS_UNIVERSE
+ else True
+ )
+ return self._credentials_validated
+
+
+def _findPageTokenName(fields):
+ """Search field names for one like a page token.
+
+ Args:
+ fields: container of string, names of fields.
+
+ Returns:
+ First name that is either 'pageToken' or 'nextPageToken' if one exists,
+ otherwise None.
+ """
+ return next(
+ (tokenName for tokenName in _PAGE_TOKEN_NAMES if tokenName in fields), None
+ )
+
+
+def _methodProperties(methodDesc, schema, name):
+ """Get properties of a field in a method description.
+
+ Args:
+ methodDesc: object, fragment of deserialized discovery document that
+ describes the method.
+ schema: object, mapping of schema names to schema descriptions.
+ name: string, name of top-level field in method description.
+
+ Returns:
+ Object representing fragment of deserialized discovery document
+ corresponding to 'properties' field of object corresponding to named field
+ in method description, if it exists, otherwise empty dict.
+ """
+ desc = methodDesc.get(name, {})
+ if "$ref" in desc:
+ desc = schema.get(desc["$ref"], {})
+ return desc.get("properties", {})
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/errors.py b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..288594a68a5647ff5179bccc0adcf18a697d4c41
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/errors.py
@@ -0,0 +1,197 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""Errors for the library.
+
+All exceptions defined by the library
+should be defined in this file.
+"""
+from __future__ import absolute_import
+
+__author__ = "jcgregorio@google.com (Joe Gregorio)"
+
+import json
+
+from googleapiclient import _helpers as util
+
+
+class Error(Exception):
+ """Base error for this module."""
+
+ pass
+
+
+class HttpError(Error):
+ """HTTP data was invalid or unexpected."""
+
+ @util.positional(3)
+ def __init__(self, resp, content, uri=None):
+ self.resp = resp
+ if not isinstance(content, bytes):
+ raise TypeError("HTTP content should be bytes")
+ self.content = content
+ self.uri = uri
+ self.error_details = ""
+ self.reason = self._get_reason()
+
+ @property
+ def status_code(self):
+ """Return the HTTP status code from the response content."""
+ return self.resp.status
+
+ def _get_reason(self):
+ """Calculate the reason for the error from the response content."""
+ reason = self.resp.reason
+ try:
+ try:
+ data = json.loads(self.content.decode("utf-8"))
+ except json.JSONDecodeError:
+ # In case it is not json
+ data = self.content.decode("utf-8")
+ if isinstance(data, dict):
+ reason = data["error"]["message"]
+ error_detail_keyword = next(
+ (
+ kw
+ for kw in ["detail", "details", "errors", "message"]
+ if kw in data["error"]
+ ),
+ "",
+ )
+ if error_detail_keyword:
+ self.error_details = data["error"][error_detail_keyword]
+ elif isinstance(data, list) and len(data) > 0:
+ first_error = data[0]
+ reason = first_error["error"]["message"]
+ if "details" in first_error["error"]:
+ self.error_details = first_error["error"]["details"]
+ else:
+ self.error_details = data
+ except (ValueError, KeyError, TypeError):
+ pass
+ if reason is None:
+ reason = ""
+ return reason.strip()
+
+ def __repr__(self):
+ if self.error_details:
+ return '' % (
+ self.resp.status,
+ self.uri,
+ self.reason,
+ self.error_details,
+ )
+ elif self.uri:
+ return '' % (
+ self.resp.status,
+ self.uri,
+ self.reason,
+ )
+ else:
+ return '' % (self.resp.status, self.reason)
+
+ __str__ = __repr__
+
+
+class InvalidJsonError(Error):
+ """The JSON returned could not be parsed."""
+
+ pass
+
+
+class UnknownFileType(Error):
+ """File type unknown or unexpected."""
+
+ pass
+
+
+class UnknownLinkType(Error):
+ """Link type unknown or unexpected."""
+
+ pass
+
+
+class UnknownApiNameOrVersion(Error):
+ """No API with that name and version exists."""
+
+ pass
+
+
+class UnacceptableMimeTypeError(Error):
+ """That is an unacceptable mimetype for this operation."""
+
+ pass
+
+
+class MediaUploadSizeError(Error):
+ """Media is larger than the method can accept."""
+
+ pass
+
+
+class ResumableUploadError(HttpError):
+ """Error occurred during resumable upload."""
+
+ pass
+
+
+class InvalidChunkSizeError(Error):
+ """The given chunksize is not valid."""
+
+ pass
+
+
+class InvalidNotificationError(Error):
+ """The channel Notification is invalid."""
+
+ pass
+
+
+class BatchError(HttpError):
+ """Error occurred during batch operations."""
+
+ @util.positional(2)
+ def __init__(self, reason, resp=None, content=None):
+ self.resp = resp
+ self.content = content
+ self.reason = reason
+
+ def __repr__(self):
+ if getattr(self.resp, "status", None) is None:
+ return '' % (self.reason)
+ else:
+ return '' % (self.resp.status, self.reason)
+
+ __str__ = __repr__
+
+
+class UnexpectedMethodError(Error):
+ """Exception raised by RequestMockBuilder on unexpected calls."""
+
+ @util.positional(1)
+ def __init__(self, methodId=None):
+ """Constructor for an UnexpectedMethodError."""
+ super(UnexpectedMethodError, self).__init__(
+ "Received unexpected call %s" % methodId
+ )
+
+
+class UnexpectedBodyError(Error):
+ """Exception raised by RequestMockBuilder on unexpected bodies."""
+
+ def __init__(self, expected, provided):
+ """Constructor for an UnexpectedMethodError."""
+ super(UnexpectedBodyError, self).__init__(
+ "Expected: [%s] - Provided: [%s]" % (expected, provided)
+ )
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/http.py b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/http.py
new file mode 100644
index 0000000000000000000000000000000000000000..187f6f5dac856e27d583e66ca805d80e26f8f6df
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/http.py
@@ -0,0 +1,1962 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""Classes to encapsulate a single HTTP request.
+
+The classes implement a command pattern, with every
+object supporting an execute() method that does the
+actual HTTP request.
+"""
+from __future__ import absolute_import
+
+__author__ = "jcgregorio@google.com (Joe Gregorio)"
+
+import copy
+import http.client as http_client
+import io
+import json
+import logging
+import mimetypes
+import os
+import random
+import socket
+import time
+import urllib
+import uuid
+
+import httplib2
+
+# TODO(issue 221): Remove this conditional import jibbajabba.
+try:
+ import ssl
+except ImportError:
+ _ssl_SSLError = object()
+else:
+ _ssl_SSLError = ssl.SSLError
+
+from email.generator import Generator
+from email.mime.multipart import MIMEMultipart
+from email.mime.nonmultipart import MIMENonMultipart
+from email.parser import FeedParser
+
+from googleapiclient import _auth
+from googleapiclient import _helpers as util
+from googleapiclient.errors import (
+ BatchError,
+ HttpError,
+ InvalidChunkSizeError,
+ ResumableUploadError,
+ UnexpectedBodyError,
+ UnexpectedMethodError,
+)
+from googleapiclient.model import JsonModel
+
+LOGGER = logging.getLogger(__name__)
+
+DEFAULT_CHUNK_SIZE = 100 * 1024 * 1024
+
+MAX_URI_LENGTH = 2048
+
+MAX_BATCH_LIMIT = 1000
+
+_TOO_MANY_REQUESTS = 429
+
+DEFAULT_HTTP_TIMEOUT_SEC = 60
+
+_LEGACY_BATCH_URI = "https://www.googleapis.com/batch"
+
+
+def _should_retry_response(resp_status, content):
+ """Determines whether a response should be retried.
+
+ Args:
+ resp_status: The response status received.
+ content: The response content body.
+
+ Returns:
+ True if the response should be retried, otherwise False.
+ """
+ reason = None
+
+ # Retry on 5xx errors.
+ if resp_status >= 500:
+ return True
+
+ # Retry on 429 errors.
+ if resp_status == _TOO_MANY_REQUESTS:
+ return True
+
+ # For 403 errors, we have to check for the `reason` in the response to
+ # determine if we should retry.
+ if resp_status == http_client.FORBIDDEN:
+ # If there's no details about the 403 type, don't retry.
+ if not content:
+ return False
+
+ # Content is in JSON format.
+ try:
+ data = json.loads(content.decode("utf-8"))
+ if isinstance(data, dict):
+ # There are many variations of the error json so we need
+ # to determine the keyword which has the error detail. Make sure
+ # that the order of the keywords below isn't changed as it can
+ # break user code. If the "errors" key exists, we must use that
+ # first.
+ # See Issue #1243
+ # https://github.com/googleapis/google-api-python-client/issues/1243
+ error_detail_keyword = next(
+ (
+ kw
+ for kw in ["errors", "status", "message"]
+ if kw in data["error"]
+ ),
+ "",
+ )
+
+ if error_detail_keyword:
+ reason = data["error"][error_detail_keyword]
+
+ if isinstance(reason, list) and len(reason) > 0:
+ reason = reason[0]
+ if "reason" in reason:
+ reason = reason["reason"]
+ else:
+ reason = data[0]["error"]["errors"]["reason"]
+ except (UnicodeDecodeError, ValueError, KeyError):
+ LOGGER.warning("Invalid JSON content from response: %s", content)
+ return False
+
+ LOGGER.warning('Encountered 403 Forbidden with reason "%s"', reason)
+
+ # Only retry on rate limit related failures.
+ if reason in ("userRateLimitExceeded", "rateLimitExceeded"):
+ return True
+
+ # Everything else is a success or non-retriable so break.
+ return False
+
+
+def _retry_request(
+ http, num_retries, req_type, sleep, rand, uri, method, *args, **kwargs
+):
+ """Retries an HTTP request multiple times while handling errors.
+
+ If after all retries the request still fails, last error is either returned as
+ return value (for HTTP 5xx errors) or thrown (for ssl.SSLError).
+
+ Args:
+ http: Http object to be used to execute request.
+ num_retries: Maximum number of retries.
+ req_type: Type of the request (used for logging retries).
+ sleep, rand: Functions to sleep for random time between retries.
+ uri: URI to be requested.
+ method: HTTP method to be used.
+ args, kwargs: Additional arguments passed to http.request.
+
+ Returns:
+ resp, content - Response from the http request (may be HTTP 5xx).
+ """
+ resp = None
+ content = None
+ exception = None
+ for retry_num in range(num_retries + 1):
+ if retry_num > 0:
+ # Sleep before retrying.
+ sleep_time = rand() * 2**retry_num
+ LOGGER.warning(
+ "Sleeping %.2f seconds before retry %d of %d for %s: %s %s, after %s",
+ sleep_time,
+ retry_num,
+ num_retries,
+ req_type,
+ method,
+ uri,
+ resp.status if resp else exception,
+ )
+ sleep(sleep_time)
+
+ try:
+ exception = None
+ resp, content = http.request(uri, method, *args, **kwargs)
+ # Retry on SSL errors and socket timeout errors.
+ except _ssl_SSLError as ssl_error:
+ exception = ssl_error
+ except socket.timeout as socket_timeout:
+ # Needs to be before socket.error as it's a subclass of OSError
+ # socket.timeout has no errorcode
+ exception = socket_timeout
+ except ConnectionError as connection_error:
+ # Needs to be before socket.error as it's a subclass of OSError
+ exception = connection_error
+ except OSError as socket_error:
+ # errno's contents differ by platform, so we have to match by name.
+ # Some of these same errors may have been caught above, e.g. ECONNRESET *should* be
+ # raised as a ConnectionError, but some libraries will raise it as a socket.error
+ # with an errno corresponding to ECONNRESET
+ if socket.errno.errorcode.get(socket_error.errno) not in {
+ "WSAETIMEDOUT",
+ "ETIMEDOUT",
+ "EPIPE",
+ "ECONNABORTED",
+ "ECONNREFUSED",
+ "ECONNRESET",
+ }:
+ raise
+ exception = socket_error
+ except httplib2.ServerNotFoundError as server_not_found_error:
+ exception = server_not_found_error
+
+ if exception:
+ if retry_num == num_retries:
+ raise exception
+ else:
+ continue
+
+ if not _should_retry_response(resp.status, content):
+ break
+
+ return resp, content
+
+
+class MediaUploadProgress(object):
+ """Status of a resumable upload."""
+
+ def __init__(self, resumable_progress, total_size):
+ """Constructor.
+
+ Args:
+ resumable_progress: int, bytes sent so far.
+ total_size: int, total bytes in complete upload, or None if the total
+ upload size isn't known ahead of time.
+ """
+ self.resumable_progress = resumable_progress
+ self.total_size = total_size
+
+ def progress(self):
+ """Percent of upload completed, as a float.
+
+ Returns:
+ the percentage complete as a float, returning 0.0 if the total size of
+ the upload is unknown.
+ """
+ if self.total_size is not None and self.total_size != 0:
+ return float(self.resumable_progress) / float(self.total_size)
+ else:
+ return 0.0
+
+
+class MediaDownloadProgress(object):
+ """Status of a resumable download."""
+
+ def __init__(self, resumable_progress, total_size):
+ """Constructor.
+
+ Args:
+ resumable_progress: int, bytes received so far.
+ total_size: int, total bytes in complete download.
+ """
+ self.resumable_progress = resumable_progress
+ self.total_size = total_size
+
+ def progress(self):
+ """Percent of download completed, as a float.
+
+ Returns:
+ the percentage complete as a float, returning 0.0 if the total size of
+ the download is unknown.
+ """
+ if self.total_size is not None and self.total_size != 0:
+ return float(self.resumable_progress) / float(self.total_size)
+ else:
+ return 0.0
+
+
+class MediaUpload(object):
+ """Describes a media object to upload.
+
+ Base class that defines the interface of MediaUpload subclasses.
+
+ Note that subclasses of MediaUpload may allow you to control the chunksize
+ when uploading a media object. It is important to keep the size of the chunk
+ as large as possible to keep the upload efficient. Other factors may influence
+ the size of the chunk you use, particularly if you are working in an
+ environment where individual HTTP requests may have a hardcoded time limit,
+ such as under certain classes of requests under Google App Engine.
+
+ Streams are io.Base compatible objects that support seek(). Some MediaUpload
+ subclasses support using streams directly to upload data. Support for
+ streaming may be indicated by a MediaUpload sub-class and if appropriate for a
+ platform that stream will be used for uploading the media object. The support
+ for streaming is indicated by has_stream() returning True. The stream() method
+ should return an io.Base object that supports seek(). On platforms where the
+ underlying httplib module supports streaming, for example Python 2.6 and
+ later, the stream will be passed into the http library which will result in
+ less memory being used and possibly faster uploads.
+
+ If you need to upload media that can't be uploaded using any of the existing
+ MediaUpload sub-class then you can sub-class MediaUpload for your particular
+ needs.
+ """
+
+ def chunksize(self):
+ """Chunk size for resumable uploads.
+
+ Returns:
+ Chunk size in bytes.
+ """
+ raise NotImplementedError()
+
+ def mimetype(self):
+ """Mime type of the body.
+
+ Returns:
+ Mime type.
+ """
+ return "application/octet-stream"
+
+ def size(self):
+ """Size of upload.
+
+ Returns:
+ Size of the body, or None of the size is unknown.
+ """
+ return None
+
+ def resumable(self):
+ """Whether this upload is resumable.
+
+ Returns:
+ True if resumable upload or False.
+ """
+ return False
+
+ def getbytes(self, begin, end):
+ """Get bytes from the media.
+
+ Args:
+ begin: int, offset from beginning of file.
+ length: int, number of bytes to read, starting at begin.
+
+ Returns:
+ A string of bytes read. May be shorter than length if EOF was reached
+ first.
+ """
+ raise NotImplementedError()
+
+ def has_stream(self):
+ """Does the underlying upload support a streaming interface.
+
+ Streaming means it is an io.IOBase subclass that supports seek, i.e.
+ seekable() returns True.
+
+ Returns:
+ True if the call to stream() will return an instance of a seekable io.Base
+ subclass.
+ """
+ return False
+
+ def stream(self):
+ """A stream interface to the data being uploaded.
+
+ Returns:
+ The returned value is an io.IOBase subclass that supports seek, i.e.
+ seekable() returns True.
+ """
+ raise NotImplementedError()
+
+ @util.positional(1)
+ def _to_json(self, strip=None):
+ """Utility function for creating a JSON representation of a MediaUpload.
+
+ Args:
+ strip: array, An array of names of members to not include in the JSON.
+
+ Returns:
+ string, a JSON representation of this instance, suitable to pass to
+ from_json().
+ """
+ t = type(self)
+ d = copy.copy(self.__dict__)
+ if strip is not None:
+ for member in strip:
+ del d[member]
+ d["_class"] = t.__name__
+ d["_module"] = t.__module__
+ return json.dumps(d)
+
+ def to_json(self):
+ """Create a JSON representation of an instance of MediaUpload.
+
+ Returns:
+ string, a JSON representation of this instance, suitable to pass to
+ from_json().
+ """
+ return self._to_json()
+
+ @classmethod
+ def new_from_json(cls, s):
+ """Utility class method to instantiate a MediaUpload subclass from a JSON
+ representation produced by to_json().
+
+ Args:
+ s: string, JSON from to_json().
+
+ Returns:
+ An instance of the subclass of MediaUpload that was serialized with
+ to_json().
+ """
+ data = json.loads(s)
+ # Find and call the right classmethod from_json() to restore the object.
+ module = data["_module"]
+ m = __import__(module, fromlist=module.split(".")[:-1])
+ kls = getattr(m, data["_class"])
+ from_json = getattr(kls, "from_json")
+ return from_json(s)
+
+
+class MediaIoBaseUpload(MediaUpload):
+ """A MediaUpload for a io.Base objects.
+
+ Note that the Python file object is compatible with io.Base and can be used
+ with this class also.
+
+ fh = BytesIO('...Some data to upload...')
+ media = MediaIoBaseUpload(fh, mimetype='image/png',
+ chunksize=1024*1024, resumable=True)
+ farm.animals().insert(
+ id='cow',
+ name='cow.png',
+ media_body=media).execute()
+
+ Depending on the platform you are working on, you may pass -1 as the
+ chunksize, which indicates that the entire file should be uploaded in a single
+ request. If the underlying platform supports streams, such as Python 2.6 or
+ later, then this can be very efficient as it avoids multiple connections, and
+ also avoids loading the entire file into memory before sending it. Note that
+ Google App Engine has a 5MB limit on request size, so you should never set
+ your chunksize larger than 5MB, or to -1.
+ """
+
+ @util.positional(3)
+ def __init__(self, fd, mimetype, chunksize=DEFAULT_CHUNK_SIZE, resumable=False):
+ """Constructor.
+
+ Args:
+ fd: io.Base or file object, The source of the bytes to upload. MUST be
+ opened in blocking mode, do not use streams opened in non-blocking mode.
+ The given stream must be seekable, that is, it must be able to call
+ seek() on fd.
+ mimetype: string, Mime-type of the file.
+ chunksize: int, File will be uploaded in chunks of this many bytes. Only
+ used if resumable=True. Pass in a value of -1 if the file is to be
+ uploaded as a single chunk. Note that Google App Engine has a 5MB limit
+ on request size, so you should never set your chunksize larger than 5MB,
+ or to -1.
+ resumable: bool, True if this is a resumable upload. False means upload
+ in a single request.
+ """
+ super(MediaIoBaseUpload, self).__init__()
+ self._fd = fd
+ self._mimetype = mimetype
+ if not (chunksize == -1 or chunksize > 0):
+ raise InvalidChunkSizeError()
+ self._chunksize = chunksize
+ self._resumable = resumable
+
+ self._fd.seek(0, os.SEEK_END)
+ self._size = self._fd.tell()
+
+ def chunksize(self):
+ """Chunk size for resumable uploads.
+
+ Returns:
+ Chunk size in bytes.
+ """
+ return self._chunksize
+
+ def mimetype(self):
+ """Mime type of the body.
+
+ Returns:
+ Mime type.
+ """
+ return self._mimetype
+
+ def size(self):
+ """Size of upload.
+
+ Returns:
+ Size of the body, or None of the size is unknown.
+ """
+ return self._size
+
+ def resumable(self):
+ """Whether this upload is resumable.
+
+ Returns:
+ True if resumable upload or False.
+ """
+ return self._resumable
+
+ def getbytes(self, begin, length):
+ """Get bytes from the media.
+
+ Args:
+ begin: int, offset from beginning of file.
+ length: int, number of bytes to read, starting at begin.
+
+ Returns:
+ A string of bytes read. May be shorted than length if EOF was reached
+ first.
+ """
+ self._fd.seek(begin)
+ return self._fd.read(length)
+
+ def has_stream(self):
+ """Does the underlying upload support a streaming interface.
+
+ Streaming means it is an io.IOBase subclass that supports seek, i.e.
+ seekable() returns True.
+
+ Returns:
+ True if the call to stream() will return an instance of a seekable io.Base
+ subclass.
+ """
+ return True
+
+ def stream(self):
+ """A stream interface to the data being uploaded.
+
+ Returns:
+ The returned value is an io.IOBase subclass that supports seek, i.e.
+ seekable() returns True.
+ """
+ return self._fd
+
+ def to_json(self):
+ """This upload type is not serializable."""
+ raise NotImplementedError("MediaIoBaseUpload is not serializable.")
+
+
+class MediaFileUpload(MediaIoBaseUpload):
+ """A MediaUpload for a file.
+
+ Construct a MediaFileUpload and pass as the media_body parameter of the
+ method. For example, if we had a service that allowed uploading images:
+
+ media = MediaFileUpload('cow.png', mimetype='image/png',
+ chunksize=1024*1024, resumable=True)
+ farm.animals().insert(
+ id='cow',
+ name='cow.png',
+ media_body=media).execute()
+
+ Depending on the platform you are working on, you may pass -1 as the
+ chunksize, which indicates that the entire file should be uploaded in a single
+ request. If the underlying platform supports streams, such as Python 2.6 or
+ later, then this can be very efficient as it avoids multiple connections, and
+ also avoids loading the entire file into memory before sending it. Note that
+ Google App Engine has a 5MB limit on request size, so you should never set
+ your chunksize larger than 5MB, or to -1.
+ """
+
+ @util.positional(2)
+ def __init__(
+ self, filename, mimetype=None, chunksize=DEFAULT_CHUNK_SIZE, resumable=False
+ ):
+ """Constructor.
+
+ Args:
+ filename: string, Name of the file.
+ mimetype: string, Mime-type of the file. If None then a mime-type will be
+ guessed from the file extension.
+ chunksize: int, File will be uploaded in chunks of this many bytes. Only
+ used if resumable=True. Pass in a value of -1 if the file is to be
+ uploaded in a single chunk. Note that Google App Engine has a 5MB limit
+ on request size, so you should never set your chunksize larger than 5MB,
+ or to -1.
+ resumable: bool, True if this is a resumable upload. False means upload
+ in a single request.
+ """
+ self._fd = None
+ self._filename = filename
+ self._fd = open(self._filename, "rb")
+ if mimetype is None:
+ # No mimetype provided, make a guess.
+ mimetype, _ = mimetypes.guess_type(filename)
+ if mimetype is None:
+ # Guess failed, use octet-stream.
+ mimetype = "application/octet-stream"
+ super(MediaFileUpload, self).__init__(
+ self._fd, mimetype, chunksize=chunksize, resumable=resumable
+ )
+
+ def __del__(self):
+ if self._fd:
+ self._fd.close()
+
+ def to_json(self):
+ """Creating a JSON representation of an instance of MediaFileUpload.
+
+ Returns:
+ string, a JSON representation of this instance, suitable to pass to
+ from_json().
+ """
+ return self._to_json(strip=["_fd"])
+
+ @staticmethod
+ def from_json(s):
+ d = json.loads(s)
+ return MediaFileUpload(
+ d["_filename"],
+ mimetype=d["_mimetype"],
+ chunksize=d["_chunksize"],
+ resumable=d["_resumable"],
+ )
+
+
+class MediaInMemoryUpload(MediaIoBaseUpload):
+ """MediaUpload for a chunk of bytes.
+
+ DEPRECATED: Use MediaIoBaseUpload with either io.TextIOBase or io.StringIO for
+ the stream.
+ """
+
+ @util.positional(2)
+ def __init__(
+ self,
+ body,
+ mimetype="application/octet-stream",
+ chunksize=DEFAULT_CHUNK_SIZE,
+ resumable=False,
+ ):
+ """Create a new MediaInMemoryUpload.
+
+ DEPRECATED: Use MediaIoBaseUpload with either io.TextIOBase or io.StringIO for
+ the stream.
+
+ Args:
+ body: string, Bytes of body content.
+ mimetype: string, Mime-type of the file or default of
+ 'application/octet-stream'.
+ chunksize: int, File will be uploaded in chunks of this many bytes. Only
+ used if resumable=True.
+ resumable: bool, True if this is a resumable upload. False means upload
+ in a single request.
+ """
+ fd = io.BytesIO(body)
+ super(MediaInMemoryUpload, self).__init__(
+ fd, mimetype, chunksize=chunksize, resumable=resumable
+ )
+
+
+class MediaIoBaseDownload(object):
+ """ "Download media resources.
+
+ Note that the Python file object is compatible with io.Base and can be used
+ with this class also.
+
+
+ Example:
+ request = farms.animals().get_media(id='cow')
+ fh = io.FileIO('cow.png', mode='wb')
+ downloader = MediaIoBaseDownload(fh, request, chunksize=1024*1024)
+
+ done = False
+ while done is False:
+ status, done = downloader.next_chunk()
+ if status:
+ print "Download %d%%." % int(status.progress() * 100)
+ print "Download Complete!"
+ """
+
+ @util.positional(3)
+ def __init__(self, fd, request, chunksize=DEFAULT_CHUNK_SIZE):
+ """Constructor.
+
+ Args:
+ fd: io.Base or file object, The stream in which to write the downloaded
+ bytes.
+ request: googleapiclient.http.HttpRequest, the media request to perform in
+ chunks.
+ chunksize: int, File will be downloaded in chunks of this many bytes.
+ """
+ self._fd = fd
+ self._request = request
+ self._uri = request.uri
+ self._chunksize = chunksize
+ self._progress = 0
+ self._total_size = None
+ self._done = False
+
+ # Stubs for testing.
+ self._sleep = time.sleep
+ self._rand = random.random
+
+ self._headers = {}
+ for k, v in request.headers.items():
+ # allow users to supply custom headers by setting them on the request
+ # but strip out the ones that are set by default on requests generated by
+ # API methods like Drive's files().get(fileId=...)
+ if not k.lower() in ("accept", "accept-encoding", "user-agent"):
+ self._headers[k] = v
+
+ @util.positional(1)
+ def next_chunk(self, num_retries=0):
+ """Get the next chunk of the download.
+
+ Args:
+ num_retries: Integer, number of times to retry with randomized
+ exponential backoff. If all retries fail, the raised HttpError
+ represents the last request. If zero (default), we attempt the
+ request only once.
+
+ Returns:
+ (status, done): (MediaDownloadProgress, boolean)
+ The value of 'done' will be True when the media has been fully
+ downloaded or the total size of the media is unknown.
+
+ Raises:
+ googleapiclient.errors.HttpError if the response was not a 2xx.
+ httplib2.HttpLib2Error if a transport error has occurred.
+ """
+ headers = self._headers.copy()
+ headers["range"] = "bytes=%d-%d" % (
+ self._progress,
+ self._progress + self._chunksize - 1,
+ )
+ http = self._request.http
+
+ resp, content = _retry_request(
+ http,
+ num_retries,
+ "media download",
+ self._sleep,
+ self._rand,
+ self._uri,
+ "GET",
+ headers=headers,
+ )
+
+ if resp.status in [200, 206]:
+ if "content-location" in resp and resp["content-location"] != self._uri:
+ self._uri = resp["content-location"]
+ self._progress += len(content)
+ self._fd.write(content)
+
+ if "content-range" in resp:
+ content_range = resp["content-range"]
+ length = content_range.rsplit("/", 1)[1]
+ self._total_size = int(length)
+ elif "content-length" in resp:
+ self._total_size = int(resp["content-length"])
+
+ if self._total_size is None or self._progress == self._total_size:
+ self._done = True
+ return MediaDownloadProgress(self._progress, self._total_size), self._done
+ elif resp.status == 416:
+ # 416 is Range Not Satisfiable
+ # This typically occurs with a zero byte file
+ content_range = resp["content-range"]
+ length = content_range.rsplit("/", 1)[1]
+ self._total_size = int(length)
+ if self._total_size == 0:
+ self._done = True
+ return (
+ MediaDownloadProgress(self._progress, self._total_size),
+ self._done,
+ )
+ raise HttpError(resp, content, uri=self._uri)
+
+
+class _StreamSlice(object):
+ """Truncated stream.
+
+ Takes a stream and presents a stream that is a slice of the original stream.
+ This is used when uploading media in chunks. In later versions of Python a
+ stream can be passed to httplib in place of the string of data to send. The
+ problem is that httplib just blindly reads to the end of the stream. This
+ wrapper presents a virtual stream that only reads to the end of the chunk.
+ """
+
+ def __init__(self, stream, begin, chunksize):
+ """Constructor.
+
+ Args:
+ stream: (io.Base, file object), the stream to wrap.
+ begin: int, the seek position the chunk begins at.
+ chunksize: int, the size of the chunk.
+ """
+ self._stream = stream
+ self._begin = begin
+ self._chunksize = chunksize
+ self._stream.seek(begin)
+
+ def read(self, n=-1):
+ """Read n bytes.
+
+ Args:
+ n, int, the number of bytes to read.
+
+ Returns:
+ A string of length 'n', or less if EOF is reached.
+ """
+ # The data left available to read sits in [cur, end)
+ cur = self._stream.tell()
+ end = self._begin + self._chunksize
+ if n == -1 or cur + n > end:
+ n = end - cur
+ return self._stream.read(n)
+
+
+class HttpRequest(object):
+ """Encapsulates a single HTTP request."""
+
+ @util.positional(4)
+ def __init__(
+ self,
+ http,
+ postproc,
+ uri,
+ method="GET",
+ body=None,
+ headers=None,
+ methodId=None,
+ resumable=None,
+ ):
+ """Constructor for an HttpRequest.
+
+ Args:
+ http: httplib2.Http, the transport object to use to make a request
+ postproc: callable, called on the HTTP response and content to transform
+ it into a data object before returning, or raising an exception
+ on an error.
+ uri: string, the absolute URI to send the request to
+ method: string, the HTTP method to use
+ body: string, the request body of the HTTP request,
+ headers: dict, the HTTP request headers
+ methodId: string, a unique identifier for the API method being called.
+ resumable: MediaUpload, None if this is not a resumbale request.
+ """
+ self.uri = uri
+ self.method = method
+ self.body = body
+ self.headers = headers or {}
+ self.methodId = methodId
+ self.http = http
+ self.postproc = postproc
+ self.resumable = resumable
+ self.response_callbacks = []
+ self._in_error_state = False
+
+ # The size of the non-media part of the request.
+ self.body_size = len(self.body or "")
+
+ # The resumable URI to send chunks to.
+ self.resumable_uri = None
+
+ # The bytes that have been uploaded.
+ self.resumable_progress = 0
+
+ # Stubs for testing.
+ self._rand = random.random
+ self._sleep = time.sleep
+
+ @util.positional(1)
+ def execute(self, http=None, num_retries=0):
+ """Execute the request.
+
+ Args:
+ http: httplib2.Http, an http object to be used in place of the
+ one the HttpRequest request object was constructed with.
+ num_retries: Integer, number of times to retry with randomized
+ exponential backoff. If all retries fail, the raised HttpError
+ represents the last request. If zero (default), we attempt the
+ request only once.
+
+ Returns:
+ A deserialized object model of the response body as determined
+ by the postproc.
+
+ Raises:
+ googleapiclient.errors.HttpError if the response was not a 2xx.
+ httplib2.HttpLib2Error if a transport error has occurred.
+ """
+ if http is None:
+ http = self.http
+
+ if self.resumable:
+ body = None
+ while body is None:
+ _, body = self.next_chunk(http=http, num_retries=num_retries)
+ return body
+
+ # Non-resumable case.
+
+ if "content-length" not in self.headers:
+ self.headers["content-length"] = str(self.body_size)
+ # If the request URI is too long then turn it into a POST request.
+ # Assume that a GET request never contains a request body.
+ if len(self.uri) > MAX_URI_LENGTH and self.method == "GET":
+ self.method = "POST"
+ self.headers["x-http-method-override"] = "GET"
+ self.headers["content-type"] = "application/x-www-form-urlencoded"
+ parsed = urllib.parse.urlparse(self.uri)
+ self.uri = urllib.parse.urlunparse(
+ (parsed.scheme, parsed.netloc, parsed.path, parsed.params, None, None)
+ )
+ self.body = parsed.query
+ self.headers["content-length"] = str(len(self.body))
+
+ # Handle retries for server-side errors.
+ resp, content = _retry_request(
+ http,
+ num_retries,
+ "request",
+ self._sleep,
+ self._rand,
+ str(self.uri),
+ method=str(self.method),
+ body=self.body,
+ headers=self.headers,
+ )
+
+ for callback in self.response_callbacks:
+ callback(resp)
+ if resp.status >= 300:
+ raise HttpError(resp, content, uri=self.uri)
+ return self.postproc(resp, content)
+
+ @util.positional(2)
+ def add_response_callback(self, cb):
+ """add_response_headers_callback
+
+ Args:
+ cb: Callback to be called on receiving the response headers, of signature:
+
+ def cb(resp):
+ # Where resp is an instance of httplib2.Response
+ """
+ self.response_callbacks.append(cb)
+
+ @util.positional(1)
+ def next_chunk(self, http=None, num_retries=0):
+ """Execute the next step of a resumable upload.
+
+ Can only be used if the method being executed supports media uploads and
+ the MediaUpload object passed in was flagged as using resumable upload.
+
+ Example:
+
+ media = MediaFileUpload('cow.png', mimetype='image/png',
+ chunksize=1000, resumable=True)
+ request = farm.animals().insert(
+ id='cow',
+ name='cow.png',
+ media_body=media)
+
+ response = None
+ while response is None:
+ status, response = request.next_chunk()
+ if status:
+ print "Upload %d%% complete." % int(status.progress() * 100)
+
+
+ Args:
+ http: httplib2.Http, an http object to be used in place of the
+ one the HttpRequest request object was constructed with.
+ num_retries: Integer, number of times to retry with randomized
+ exponential backoff. If all retries fail, the raised HttpError
+ represents the last request. If zero (default), we attempt the
+ request only once.
+
+ Returns:
+ (status, body): (ResumableMediaStatus, object)
+ The body will be None until the resumable media is fully uploaded.
+
+ Raises:
+ googleapiclient.errors.HttpError if the response was not a 2xx.
+ httplib2.HttpLib2Error if a transport error has occurred.
+ """
+ if http is None:
+ http = self.http
+
+ if self.resumable.size() is None:
+ size = "*"
+ else:
+ size = str(self.resumable.size())
+
+ if self.resumable_uri is None:
+ start_headers = copy.copy(self.headers)
+ start_headers["X-Upload-Content-Type"] = self.resumable.mimetype()
+ if size != "*":
+ start_headers["X-Upload-Content-Length"] = size
+ start_headers["content-length"] = str(self.body_size)
+
+ resp, content = _retry_request(
+ http,
+ num_retries,
+ "resumable URI request",
+ self._sleep,
+ self._rand,
+ self.uri,
+ method=self.method,
+ body=self.body,
+ headers=start_headers,
+ )
+
+ if resp.status == 200 and "location" in resp:
+ self.resumable_uri = resp["location"]
+ else:
+ raise ResumableUploadError(resp, content)
+ elif self._in_error_state:
+ # If we are in an error state then query the server for current state of
+ # the upload by sending an empty PUT and reading the 'range' header in
+ # the response.
+ headers = {"Content-Range": "bytes */%s" % size, "content-length": "0"}
+ resp, content = http.request(self.resumable_uri, "PUT", headers=headers)
+ status, body = self._process_response(resp, content)
+ if body:
+ # The upload was complete.
+ return (status, body)
+
+ if self.resumable.has_stream():
+ data = self.resumable.stream()
+ if self.resumable.chunksize() == -1:
+ data.seek(self.resumable_progress)
+ chunk_end = self.resumable.size() - self.resumable_progress - 1
+ else:
+ # Doing chunking with a stream, so wrap a slice of the stream.
+ data = _StreamSlice(
+ data, self.resumable_progress, self.resumable.chunksize()
+ )
+ chunk_end = min(
+ self.resumable_progress + self.resumable.chunksize() - 1,
+ self.resumable.size() - 1,
+ )
+ else:
+ data = self.resumable.getbytes(
+ self.resumable_progress, self.resumable.chunksize()
+ )
+
+ # A short read implies that we are at EOF, so finish the upload.
+ if len(data) < self.resumable.chunksize():
+ size = str(self.resumable_progress + len(data))
+
+ chunk_end = self.resumable_progress + len(data) - 1
+
+ headers = {
+ # Must set the content-length header here because httplib can't
+ # calculate the size when working with _StreamSlice.
+ "Content-Length": str(chunk_end - self.resumable_progress + 1),
+ }
+
+ # An empty file results in chunk_end = -1 and size = 0
+ # sending "bytes 0--1/0" results in an invalid request
+ # Only add header "Content-Range" if chunk_end != -1
+ if chunk_end != -1:
+ headers["Content-Range"] = "bytes %d-%d/%s" % (
+ self.resumable_progress,
+ chunk_end,
+ size,
+ )
+
+ for retry_num in range(num_retries + 1):
+ if retry_num > 0:
+ self._sleep(self._rand() * 2**retry_num)
+ LOGGER.warning(
+ "Retry #%d for media upload: %s %s, following status: %d"
+ % (retry_num, self.method, self.uri, resp.status)
+ )
+
+ try:
+ resp, content = http.request(
+ self.resumable_uri, method="PUT", body=data, headers=headers
+ )
+ except:
+ self._in_error_state = True
+ raise
+ if not _should_retry_response(resp.status, content):
+ break
+
+ return self._process_response(resp, content)
+
+ def _process_response(self, resp, content):
+ """Process the response from a single chunk upload.
+
+ Args:
+ resp: httplib2.Response, the response object.
+ content: string, the content of the response.
+
+ Returns:
+ (status, body): (ResumableMediaStatus, object)
+ The body will be None until the resumable media is fully uploaded.
+
+ Raises:
+ googleapiclient.errors.HttpError if the response was not a 2xx or a 308.
+ """
+ if resp.status in [200, 201]:
+ self._in_error_state = False
+ return None, self.postproc(resp, content)
+ elif resp.status == 308:
+ self._in_error_state = False
+ # A "308 Resume Incomplete" indicates we are not done.
+ try:
+ self.resumable_progress = int(resp["range"].split("-")[1]) + 1
+ except KeyError:
+ # If resp doesn't contain range header, resumable progress is 0
+ self.resumable_progress = 0
+ if "location" in resp:
+ self.resumable_uri = resp["location"]
+ else:
+ self._in_error_state = True
+ raise HttpError(resp, content, uri=self.uri)
+
+ return (
+ MediaUploadProgress(self.resumable_progress, self.resumable.size()),
+ None,
+ )
+
+ def to_json(self):
+ """Returns a JSON representation of the HttpRequest."""
+ d = copy.copy(self.__dict__)
+ if d["resumable"] is not None:
+ d["resumable"] = self.resumable.to_json()
+ del d["http"]
+ del d["postproc"]
+ del d["_sleep"]
+ del d["_rand"]
+
+ return json.dumps(d)
+
+ @staticmethod
+ def from_json(s, http, postproc):
+ """Returns an HttpRequest populated with info from a JSON object."""
+ d = json.loads(s)
+ if d["resumable"] is not None:
+ d["resumable"] = MediaUpload.new_from_json(d["resumable"])
+ return HttpRequest(
+ http,
+ postproc,
+ uri=d["uri"],
+ method=d["method"],
+ body=d["body"],
+ headers=d["headers"],
+ methodId=d["methodId"],
+ resumable=d["resumable"],
+ )
+
+ @staticmethod
+ def null_postproc(resp, contents):
+ return resp, contents
+
+
+class BatchHttpRequest(object):
+ """Batches multiple HttpRequest objects into a single HTTP request.
+
+ Example:
+ from googleapiclient.http import BatchHttpRequest
+
+ def list_animals(request_id, response, exception):
+ \"\"\"Do something with the animals list response.\"\"\"
+ if exception is not None:
+ # Do something with the exception.
+ pass
+ else:
+ # Do something with the response.
+ pass
+
+ def list_farmers(request_id, response, exception):
+ \"\"\"Do something with the farmers list response.\"\"\"
+ if exception is not None:
+ # Do something with the exception.
+ pass
+ else:
+ # Do something with the response.
+ pass
+
+ service = build('farm', 'v2')
+
+ batch = BatchHttpRequest()
+
+ batch.add(service.animals().list(), list_animals)
+ batch.add(service.farmers().list(), list_farmers)
+ batch.execute(http=http)
+ """
+
+ @util.positional(1)
+ def __init__(self, callback=None, batch_uri=None):
+ """Constructor for a BatchHttpRequest.
+
+ Args:
+ callback: callable, A callback to be called for each response, of the
+ form callback(id, response, exception). The first parameter is the
+ request id, and the second is the deserialized response object. The
+ third is an googleapiclient.errors.HttpError exception object if an HTTP error
+ occurred while processing the request, or None if no error occurred.
+ batch_uri: string, URI to send batch requests to.
+ """
+ if batch_uri is None:
+ batch_uri = _LEGACY_BATCH_URI
+
+ if batch_uri == _LEGACY_BATCH_URI:
+ LOGGER.warning(
+ "You have constructed a BatchHttpRequest using the legacy batch "
+ "endpoint %s. This endpoint will be turned down on August 12, 2020. "
+ "Please provide the API-specific endpoint or use "
+ "service.new_batch_http_request(). For more details see "
+ "https://developers.googleblog.com/2018/03/discontinuing-support-for-json-rpc-and.html"
+ "and https://developers.google.com/api-client-library/python/guide/batch.",
+ _LEGACY_BATCH_URI,
+ )
+ self._batch_uri = batch_uri
+
+ # Global callback to be called for each individual response in the batch.
+ self._callback = callback
+
+ # A map from id to request.
+ self._requests = {}
+
+ # A map from id to callback.
+ self._callbacks = {}
+
+ # List of request ids, in the order in which they were added.
+ self._order = []
+
+ # The last auto generated id.
+ self._last_auto_id = 0
+
+ # Unique ID on which to base the Content-ID headers.
+ self._base_id = None
+
+ # A map from request id to (httplib2.Response, content) response pairs
+ self._responses = {}
+
+ # A map of id(Credentials) that have been refreshed.
+ self._refreshed_credentials = {}
+
+ def _refresh_and_apply_credentials(self, request, http):
+ """Refresh the credentials and apply to the request.
+
+ Args:
+ request: HttpRequest, the request.
+ http: httplib2.Http, the global http object for the batch.
+ """
+ # For the credentials to refresh, but only once per refresh_token
+ # If there is no http per the request then refresh the http passed in
+ # via execute()
+ creds = None
+ request_credentials = False
+
+ if request.http is not None:
+ creds = _auth.get_credentials_from_http(request.http)
+ request_credentials = True
+
+ if creds is None and http is not None:
+ creds = _auth.get_credentials_from_http(http)
+
+ if creds is not None:
+ if id(creds) not in self._refreshed_credentials:
+ _auth.refresh_credentials(creds)
+ self._refreshed_credentials[id(creds)] = 1
+
+ # Only apply the credentials if we are using the http object passed in,
+ # otherwise apply() will get called during _serialize_request().
+ if request.http is None or not request_credentials:
+ _auth.apply_credentials(creds, request.headers)
+
+ def _id_to_header(self, id_):
+ """Convert an id to a Content-ID header value.
+
+ Args:
+ id_: string, identifier of individual request.
+
+ Returns:
+ A Content-ID header with the id_ encoded into it. A UUID is prepended to
+ the value because Content-ID headers are supposed to be universally
+ unique.
+ """
+ if self._base_id is None:
+ self._base_id = uuid.uuid4()
+
+ # NB: we intentionally leave whitespace between base/id and '+', so RFC2822
+ # line folding works properly on Python 3; see
+ # https://github.com/googleapis/google-api-python-client/issues/164
+ return "<%s + %s>" % (self._base_id, urllib.parse.quote(id_))
+
+ def _header_to_id(self, header):
+ """Convert a Content-ID header value to an id.
+
+ Presumes the Content-ID header conforms to the format that _id_to_header()
+ returns.
+
+ Args:
+ header: string, Content-ID header value.
+
+ Returns:
+ The extracted id value.
+
+ Raises:
+ BatchError if the header is not in the expected format.
+ """
+ if header[0] != "<" or header[-1] != ">":
+ raise BatchError("Invalid value for Content-ID: %s" % header)
+ if "+" not in header:
+ raise BatchError("Invalid value for Content-ID: %s" % header)
+ base, id_ = header[1:-1].split(" + ", 1)
+
+ return urllib.parse.unquote(id_)
+
+ def _serialize_request(self, request):
+ """Convert an HttpRequest object into a string.
+
+ Args:
+ request: HttpRequest, the request to serialize.
+
+ Returns:
+ The request as a string in application/http format.
+ """
+ # Construct status line
+ parsed = urllib.parse.urlparse(request.uri)
+ request_line = urllib.parse.urlunparse(
+ ("", "", parsed.path, parsed.params, parsed.query, "")
+ )
+ status_line = request.method + " " + request_line + " HTTP/1.1\n"
+ major, minor = request.headers.get("content-type", "application/json").split(
+ "/"
+ )
+ msg = MIMENonMultipart(major, minor)
+ headers = request.headers.copy()
+
+ if request.http is not None:
+ credentials = _auth.get_credentials_from_http(request.http)
+ if credentials is not None:
+ _auth.apply_credentials(credentials, headers)
+
+ # MIMENonMultipart adds its own Content-Type header.
+ if "content-type" in headers:
+ del headers["content-type"]
+
+ for key, value in headers.items():
+ msg[key] = value
+ msg["Host"] = parsed.netloc
+ msg.set_unixfrom(None)
+
+ if request.body is not None:
+ msg.set_payload(request.body)
+ msg["content-length"] = str(len(request.body))
+
+ # Serialize the mime message.
+ fp = io.StringIO()
+ # maxheaderlen=0 means don't line wrap headers.
+ g = Generator(fp, maxheaderlen=0)
+ g.flatten(msg, unixfrom=False)
+ body = fp.getvalue()
+
+ return status_line + body
+
+ def _deserialize_response(self, payload):
+ """Convert string into httplib2 response and content.
+
+ Args:
+ payload: string, headers and body as a string.
+
+ Returns:
+ A pair (resp, content), such as would be returned from httplib2.request.
+ """
+ # Strip off the status line
+ status_line, payload = payload.split("\n", 1)
+ protocol, status, reason = status_line.split(" ", 2)
+
+ # Parse the rest of the response
+ parser = FeedParser()
+ parser.feed(payload)
+ msg = parser.close()
+ msg["status"] = status
+
+ # Create httplib2.Response from the parsed headers.
+ resp = httplib2.Response(msg)
+ resp.reason = reason
+ resp.version = int(protocol.split("/", 1)[1].replace(".", ""))
+
+ content = payload.split("\r\n\r\n", 1)[1]
+
+ return resp, content
+
+ def _new_id(self):
+ """Create a new id.
+
+ Auto incrementing number that avoids conflicts with ids already used.
+
+ Returns:
+ string, a new unique id.
+ """
+ self._last_auto_id += 1
+ while str(self._last_auto_id) in self._requests:
+ self._last_auto_id += 1
+ return str(self._last_auto_id)
+
+ @util.positional(2)
+ def add(self, request, callback=None, request_id=None):
+ """Add a new request.
+
+ Every callback added will be paired with a unique id, the request_id. That
+ unique id will be passed back to the callback when the response comes back
+ from the server. The default behavior is to have the library generate it's
+ own unique id. If the caller passes in a request_id then they must ensure
+ uniqueness for each request_id, and if they are not an exception is
+ raised. Callers should either supply all request_ids or never supply a
+ request id, to avoid such an error.
+
+ Args:
+ request: HttpRequest, Request to add to the batch.
+ callback: callable, A callback to be called for this response, of the
+ form callback(id, response, exception). The first parameter is the
+ request id, and the second is the deserialized response object. The
+ third is an googleapiclient.errors.HttpError exception object if an HTTP error
+ occurred while processing the request, or None if no errors occurred.
+ request_id: string, A unique id for the request. The id will be passed
+ to the callback with the response.
+
+ Returns:
+ None
+
+ Raises:
+ BatchError if a media request is added to a batch.
+ KeyError is the request_id is not unique.
+ """
+
+ if len(self._order) >= MAX_BATCH_LIMIT:
+ raise BatchError(
+ "Exceeded the maximum calls(%d) in a single batch request."
+ % MAX_BATCH_LIMIT
+ )
+ if request_id is None:
+ request_id = self._new_id()
+ if request.resumable is not None:
+ raise BatchError("Media requests cannot be used in a batch request.")
+ if request_id in self._requests:
+ raise KeyError("A request with this ID already exists: %s" % request_id)
+ self._requests[request_id] = request
+ self._callbacks[request_id] = callback
+ self._order.append(request_id)
+
+ def _execute(self, http, order, requests):
+ """Serialize batch request, send to server, process response.
+
+ Args:
+ http: httplib2.Http, an http object to be used to make the request with.
+ order: list, list of request ids in the order they were added to the
+ batch.
+ requests: list, list of request objects to send.
+
+ Raises:
+ httplib2.HttpLib2Error if a transport error has occurred.
+ googleapiclient.errors.BatchError if the response is the wrong format.
+ """
+ message = MIMEMultipart("mixed")
+ # Message should not write out it's own headers.
+ setattr(message, "_write_headers", lambda self: None)
+
+ # Add all the individual requests.
+ for request_id in order:
+ request = requests[request_id]
+
+ msg = MIMENonMultipart("application", "http")
+ msg["Content-Transfer-Encoding"] = "binary"
+ msg["Content-ID"] = self._id_to_header(request_id)
+
+ body = self._serialize_request(request)
+ msg.set_payload(body)
+ message.attach(msg)
+
+ # encode the body: note that we can't use `as_string`, because
+ # it plays games with `From ` lines.
+ fp = io.StringIO()
+ g = Generator(fp, mangle_from_=False)
+ g.flatten(message, unixfrom=False)
+ body = fp.getvalue()
+
+ headers = {}
+ headers["content-type"] = (
+ "multipart/mixed; " 'boundary="%s"'
+ ) % message.get_boundary()
+
+ resp, content = http.request(
+ self._batch_uri, method="POST", body=body, headers=headers
+ )
+
+ if resp.status >= 300:
+ raise HttpError(resp, content, uri=self._batch_uri)
+
+ # Prepend with a content-type header so FeedParser can handle it.
+ header = "content-type: %s\r\n\r\n" % resp["content-type"]
+ # PY3's FeedParser only accepts unicode. So we should decode content
+ # here, and encode each payload again.
+ content = content.decode("utf-8")
+ for_parser = header + content
+
+ parser = FeedParser()
+ parser.feed(for_parser)
+ mime_response = parser.close()
+
+ if not mime_response.is_multipart():
+ raise BatchError(
+ "Response not in multipart/mixed format.", resp=resp, content=content
+ )
+
+ for part in mime_response.get_payload():
+ request_id = self._header_to_id(part["Content-ID"])
+ response, content = self._deserialize_response(part.get_payload())
+ # We encode content here to emulate normal http response.
+ if isinstance(content, str):
+ content = content.encode("utf-8")
+ self._responses[request_id] = (response, content)
+
+ @util.positional(1)
+ def execute(self, http=None):
+ """Execute all the requests as a single batched HTTP request.
+
+ Args:
+ http: httplib2.Http, an http object to be used in place of the one the
+ HttpRequest request object was constructed with. If one isn't supplied
+ then use a http object from the requests in this batch.
+
+ Returns:
+ None
+
+ Raises:
+ httplib2.HttpLib2Error if a transport error has occurred.
+ googleapiclient.errors.BatchError if the response is the wrong format.
+ """
+ # If we have no requests return
+ if len(self._order) == 0:
+ return None
+
+ # If http is not supplied use the first valid one given in the requests.
+ if http is None:
+ for request_id in self._order:
+ request = self._requests[request_id]
+ if request is not None:
+ http = request.http
+ break
+
+ if http is None:
+ raise ValueError("Missing a valid http object.")
+
+ # Special case for OAuth2Credentials-style objects which have not yet been
+ # refreshed with an initial access_token.
+ creds = _auth.get_credentials_from_http(http)
+ if creds is not None:
+ if not _auth.is_valid(creds):
+ LOGGER.info("Attempting refresh to obtain initial access_token")
+ _auth.refresh_credentials(creds)
+
+ self._execute(http, self._order, self._requests)
+
+ # Loop over all the requests and check for 401s. For each 401 request the
+ # credentials should be refreshed and then sent again in a separate batch.
+ redo_requests = {}
+ redo_order = []
+
+ for request_id in self._order:
+ resp, content = self._responses[request_id]
+ if resp["status"] == "401":
+ redo_order.append(request_id)
+ request = self._requests[request_id]
+ self._refresh_and_apply_credentials(request, http)
+ redo_requests[request_id] = request
+
+ if redo_requests:
+ self._execute(http, redo_order, redo_requests)
+
+ # Now process all callbacks that are erroring, and raise an exception for
+ # ones that return a non-2xx response? Or add extra parameter to callback
+ # that contains an HttpError?
+
+ for request_id in self._order:
+ resp, content = self._responses[request_id]
+
+ request = self._requests[request_id]
+ callback = self._callbacks[request_id]
+
+ response = None
+ exception = None
+ try:
+ if resp.status >= 300:
+ raise HttpError(resp, content, uri=request.uri)
+ response = request.postproc(resp, content)
+ except HttpError as e:
+ exception = e
+
+ if callback is not None:
+ callback(request_id, response, exception)
+ if self._callback is not None:
+ self._callback(request_id, response, exception)
+
+
+class HttpRequestMock(object):
+ """Mock of HttpRequest.
+
+ Do not construct directly, instead use RequestMockBuilder.
+ """
+
+ def __init__(self, resp, content, postproc):
+ """Constructor for HttpRequestMock
+
+ Args:
+ resp: httplib2.Response, the response to emulate coming from the request
+ content: string, the response body
+ postproc: callable, the post processing function usually supplied by
+ the model class. See model.JsonModel.response() as an example.
+ """
+ self.resp = resp
+ self.content = content
+ self.postproc = postproc
+ if resp is None:
+ self.resp = httplib2.Response({"status": 200, "reason": "OK"})
+ if "reason" in self.resp:
+ self.resp.reason = self.resp["reason"]
+
+ def execute(self, http=None):
+ """Execute the request.
+
+ Same behavior as HttpRequest.execute(), but the response is
+ mocked and not really from an HTTP request/response.
+ """
+ return self.postproc(self.resp, self.content)
+
+
+class RequestMockBuilder(object):
+ """A simple mock of HttpRequest
+
+ Pass in a dictionary to the constructor that maps request methodIds to
+ tuples of (httplib2.Response, content, opt_expected_body) that should be
+ returned when that method is called. None may also be passed in for the
+ httplib2.Response, in which case a 200 OK response will be generated.
+ If an opt_expected_body (str or dict) is provided, it will be compared to
+ the body and UnexpectedBodyError will be raised on inequality.
+
+ Example:
+ response = '{"data": {"id": "tag:google.c...'
+ requestBuilder = RequestMockBuilder(
+ {
+ 'plus.activities.get': (None, response),
+ }
+ )
+ googleapiclient.discovery.build("plus", "v1", requestBuilder=requestBuilder)
+
+ Methods that you do not supply a response for will return a
+ 200 OK with an empty string as the response content or raise an excpetion
+ if check_unexpected is set to True. The methodId is taken from the rpcName
+ in the discovery document.
+
+ For more details see the project wiki.
+ """
+
+ def __init__(self, responses, check_unexpected=False):
+ """Constructor for RequestMockBuilder
+
+ The constructed object should be a callable object
+ that can replace the class HttpResponse.
+
+ responses - A dictionary that maps methodIds into tuples
+ of (httplib2.Response, content). The methodId
+ comes from the 'rpcName' field in the discovery
+ document.
+ check_unexpected - A boolean setting whether or not UnexpectedMethodError
+ should be raised on unsupplied method.
+ """
+ self.responses = responses
+ self.check_unexpected = check_unexpected
+
+ def __call__(
+ self,
+ http,
+ postproc,
+ uri,
+ method="GET",
+ body=None,
+ headers=None,
+ methodId=None,
+ resumable=None,
+ ):
+ """Implements the callable interface that discovery.build() expects
+ of requestBuilder, which is to build an object compatible with
+ HttpRequest.execute(). See that method for the description of the
+ parameters and the expected response.
+ """
+ if methodId in self.responses:
+ response = self.responses[methodId]
+ resp, content = response[:2]
+ if len(response) > 2:
+ # Test the body against the supplied expected_body.
+ expected_body = response[2]
+ if bool(expected_body) != bool(body):
+ # Not expecting a body and provided one
+ # or expecting a body and not provided one.
+ raise UnexpectedBodyError(expected_body, body)
+ if isinstance(expected_body, str):
+ expected_body = json.loads(expected_body)
+ body = json.loads(body)
+ if body != expected_body:
+ raise UnexpectedBodyError(expected_body, body)
+ return HttpRequestMock(resp, content, postproc)
+ elif self.check_unexpected:
+ raise UnexpectedMethodError(methodId=methodId)
+ else:
+ model = JsonModel(False)
+ return HttpRequestMock(None, "{}", model.response)
+
+
+class HttpMock(object):
+ """Mock of httplib2.Http"""
+
+ def __init__(self, filename=None, headers=None):
+ """
+ Args:
+ filename: string, absolute filename to read response from
+ headers: dict, header to return with response
+ """
+ if headers is None:
+ headers = {"status": "200"}
+ if filename:
+ with open(filename, "rb") as f:
+ self.data = f.read()
+ else:
+ self.data = None
+ self.response_headers = headers
+ self.headers = None
+ self.uri = None
+ self.method = None
+ self.body = None
+ self.headers = None
+
+ def request(
+ self,
+ uri,
+ method="GET",
+ body=None,
+ headers=None,
+ redirections=1,
+ connection_type=None,
+ ):
+ self.uri = uri
+ self.method = method
+ self.body = body
+ self.headers = headers
+ return httplib2.Response(self.response_headers), self.data
+
+ def close(self):
+ return None
+
+
+class HttpMockSequence(object):
+ """Mock of httplib2.Http
+
+ Mocks a sequence of calls to request returning different responses for each
+ call. Create an instance initialized with the desired response headers
+ and content and then use as if an httplib2.Http instance.
+
+ http = HttpMockSequence([
+ ({'status': '401'}, ''),
+ ({'status': '200'}, '{"access_token":"1/3w","expires_in":3600}'),
+ ({'status': '200'}, 'echo_request_headers'),
+ ])
+ resp, content = http.request("http://examples.com")
+
+ There are special values you can pass in for content to trigger
+ behavours that are helpful in testing.
+
+ 'echo_request_headers' means return the request headers in the response body
+ 'echo_request_headers_as_json' means return the request headers in
+ the response body
+ 'echo_request_body' means return the request body in the response body
+ 'echo_request_uri' means return the request uri in the response body
+ """
+
+ def __init__(self, iterable):
+ """
+ Args:
+ iterable: iterable, a sequence of pairs of (headers, body)
+ """
+ self._iterable = iterable
+ self.follow_redirects = True
+ self.request_sequence = list()
+
+ def request(
+ self,
+ uri,
+ method="GET",
+ body=None,
+ headers=None,
+ redirections=1,
+ connection_type=None,
+ ):
+ # Remember the request so after the fact this mock can be examined
+ self.request_sequence.append((uri, method, body, headers))
+ resp, content = self._iterable.pop(0)
+ if isinstance(content, str):
+ content = content.encode("utf-8")
+
+ if content == b"echo_request_headers":
+ content = headers
+ elif content == b"echo_request_headers_as_json":
+ content = json.dumps(headers)
+ elif content == b"echo_request_body":
+ if hasattr(body, "read"):
+ content = body.read()
+ else:
+ content = body
+ elif content == b"echo_request_uri":
+ content = uri
+ if isinstance(content, str):
+ content = content.encode("utf-8")
+ return httplib2.Response(resp), content
+
+
+def set_user_agent(http, user_agent):
+ """Set the user-agent on every request.
+
+ Args:
+ http - An instance of httplib2.Http
+ or something that acts like it.
+ user_agent: string, the value for the user-agent header.
+
+ Returns:
+ A modified instance of http that was passed in.
+
+ Example:
+
+ h = httplib2.Http()
+ h = set_user_agent(h, "my-app-name/6.0")
+
+ Most of the time the user-agent will be set doing auth, this is for the rare
+ cases where you are accessing an unauthenticated endpoint.
+ """
+ request_orig = http.request
+
+ # The closure that will replace 'httplib2.Http.request'.
+ def new_request(
+ uri,
+ method="GET",
+ body=None,
+ headers=None,
+ redirections=httplib2.DEFAULT_MAX_REDIRECTS,
+ connection_type=None,
+ ):
+ """Modify the request headers to add the user-agent."""
+ if headers is None:
+ headers = {}
+ if "user-agent" in headers:
+ headers["user-agent"] = user_agent + " " + headers["user-agent"]
+ else:
+ headers["user-agent"] = user_agent
+ resp, content = request_orig(
+ uri,
+ method=method,
+ body=body,
+ headers=headers,
+ redirections=redirections,
+ connection_type=connection_type,
+ )
+ return resp, content
+
+ http.request = new_request
+ return http
+
+
+def tunnel_patch(http):
+ """Tunnel PATCH requests over POST.
+ Args:
+ http - An instance of httplib2.Http
+ or something that acts like it.
+
+ Returns:
+ A modified instance of http that was passed in.
+
+ Example:
+
+ h = httplib2.Http()
+ h = tunnel_patch(h, "my-app-name/6.0")
+
+ Useful if you are running on a platform that doesn't support PATCH.
+ Apply this last if you are using OAuth 1.0, as changing the method
+ will result in a different signature.
+ """
+ request_orig = http.request
+
+ # The closure that will replace 'httplib2.Http.request'.
+ def new_request(
+ uri,
+ method="GET",
+ body=None,
+ headers=None,
+ redirections=httplib2.DEFAULT_MAX_REDIRECTS,
+ connection_type=None,
+ ):
+ """Modify the request headers to add the user-agent."""
+ if headers is None:
+ headers = {}
+ if method == "PATCH":
+ if "oauth_token" in headers.get("authorization", ""):
+ LOGGER.warning(
+ "OAuth 1.0 request made with Credentials after tunnel_patch."
+ )
+ headers["x-http-method-override"] = "PATCH"
+ method = "POST"
+ resp, content = request_orig(
+ uri,
+ method=method,
+ body=body,
+ headers=headers,
+ redirections=redirections,
+ connection_type=connection_type,
+ )
+ return resp, content
+
+ http.request = new_request
+ return http
+
+
+def build_http():
+ """Builds httplib2.Http object
+
+ Returns:
+ A httplib2.Http object, which is used to make http requests, and which has timeout set by default.
+ To override default timeout call
+
+ socket.setdefaulttimeout(timeout_in_sec)
+
+ before interacting with this method.
+ """
+ if socket.getdefaulttimeout() is not None:
+ http_timeout = socket.getdefaulttimeout()
+ else:
+ http_timeout = DEFAULT_HTTP_TIMEOUT_SEC
+ http = httplib2.Http(timeout=http_timeout)
+ # 308's are used by several Google APIs (Drive, YouTube)
+ # for Resumable Uploads rather than Permanent Redirects.
+ # This asks httplib2 to exclude 308s from the status codes
+ # it treats as redirects
+ try:
+ http.redirect_codes = http.redirect_codes - {308}
+ except AttributeError:
+ # Apache Beam tests depend on this library and cannot
+ # currently upgrade their httplib2 version
+ # http.redirect_codes does not exist in previous versions
+ # of httplib2, so pass
+ pass
+
+ return http
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/mimeparse.py b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/mimeparse.py
new file mode 100644
index 0000000000000000000000000000000000000000..d3dedee9c53370e9ba67f252d34a7e0cccd2a244
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/mimeparse.py
@@ -0,0 +1,183 @@
+# Copyright 2014 Joe Gregorio
+#
+# Licensed under the MIT License
+
+"""MIME-Type Parser
+
+This module provides basic functions for handling mime-types. It can handle
+matching mime-types against a list of media-ranges. See section 14.1 of the
+HTTP specification [RFC 2616] for a complete explanation.
+
+ http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+
+Contents:
+ - parse_mime_type(): Parses a mime-type into its component parts.
+ - parse_media_range(): Media-ranges are mime-types with wild-cards and a 'q'
+ quality parameter.
+ - quality(): Determines the quality ('q') of a mime-type when
+ compared against a list of media-ranges.
+ - quality_parsed(): Just like quality() except the second parameter must be
+ pre-parsed.
+ - best_match(): Choose the mime-type with the highest quality ('q')
+ from a list of candidates.
+"""
+from __future__ import absolute_import
+
+from functools import reduce
+
+__version__ = "0.1.3"
+__author__ = "Joe Gregorio"
+__email__ = "joe@bitworking.org"
+__license__ = "MIT License"
+__credits__ = ""
+
+
+def parse_mime_type(mime_type):
+ """Parses a mime-type into its component parts.
+
+ Carves up a mime-type and returns a tuple of the (type, subtype, params)
+ where 'params' is a dictionary of all the parameters for the media range.
+ For example, the media range 'application/xhtml;q=0.5' would get parsed
+ into:
+
+ ('application', 'xhtml', {'q', '0.5'})
+ """
+ parts = mime_type.split(";")
+ params = dict(
+ [tuple([s.strip() for s in param.split("=", 1)]) for param in parts[1:]]
+ )
+ full_type = parts[0].strip()
+ # Java URLConnection class sends an Accept header that includes a
+ # single '*'. Turn it into a legal wildcard.
+ if full_type == "*":
+ full_type = "*/*"
+ (type, subtype) = full_type.split("/")
+
+ return (type.strip(), subtype.strip(), params)
+
+
+def parse_media_range(range):
+ """Parse a media-range into its component parts.
+
+ Carves up a media range and returns a tuple of the (type, subtype,
+ params) where 'params' is a dictionary of all the parameters for the media
+ range. For example, the media range 'application/*;q=0.5' would get parsed
+ into:
+
+ ('application', '*', {'q', '0.5'})
+
+ In addition this function also guarantees that there is a value for 'q'
+ in the params dictionary, filling it in with a proper default if
+ necessary.
+ """
+ (type, subtype, params) = parse_mime_type(range)
+ if (
+ "q" not in params
+ or not params["q"]
+ or not float(params["q"])
+ or float(params["q"]) > 1
+ or float(params["q"]) < 0
+ ):
+ params["q"] = "1"
+
+ return (type, subtype, params)
+
+
+def fitness_and_quality_parsed(mime_type, parsed_ranges):
+ """Find the best match for a mime-type amongst parsed media-ranges.
+
+ Find the best match for a given mime-type against a list of media_ranges
+ that have already been parsed by parse_media_range(). Returns a tuple of
+ the fitness value and the value of the 'q' quality parameter of the best
+ match, or (-1, 0) if no match was found. Just as for quality_parsed(),
+ 'parsed_ranges' must be a list of parsed media ranges.
+ """
+ best_fitness = -1
+ best_fit_q = 0
+ (target_type, target_subtype, target_params) = parse_media_range(mime_type)
+ for (type, subtype, params) in parsed_ranges:
+ type_match = type == target_type or type == "*" or target_type == "*"
+ subtype_match = (
+ subtype == target_subtype or subtype == "*" or target_subtype == "*"
+ )
+ if type_match and subtype_match:
+ param_matches = reduce(
+ lambda x, y: x + y,
+ [
+ 1
+ for (key, value) in target_params.items()
+ if key != "q" and key in params and value == params[key]
+ ],
+ 0,
+ )
+ fitness = (type == target_type) and 100 or 0
+ fitness += (subtype == target_subtype) and 10 or 0
+ fitness += param_matches
+ if fitness > best_fitness:
+ best_fitness = fitness
+ best_fit_q = params["q"]
+
+ return best_fitness, float(best_fit_q)
+
+
+def quality_parsed(mime_type, parsed_ranges):
+ """Find the best match for a mime-type amongst parsed media-ranges.
+
+ Find the best match for a given mime-type against a list of media_ranges
+ that have already been parsed by parse_media_range(). Returns the 'q'
+ quality parameter of the best match, 0 if no match was found. This function
+ bahaves the same as quality() except that 'parsed_ranges' must be a list of
+ parsed media ranges.
+ """
+
+ return fitness_and_quality_parsed(mime_type, parsed_ranges)[1]
+
+
+def quality(mime_type, ranges):
+ """Return the quality ('q') of a mime-type against a list of media-ranges.
+
+ Returns the quality 'q' of a mime-type when compared against the
+ media-ranges in ranges. For example:
+
+ >>> quality('text/html','text/*;q=0.3, text/html;q=0.7,
+ text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5')
+ 0.7
+
+ """
+ parsed_ranges = [parse_media_range(r) for r in ranges.split(",")]
+
+ return quality_parsed(mime_type, parsed_ranges)
+
+
+def best_match(supported, header):
+ """Return mime-type with the highest quality ('q') from list of candidates.
+
+ Takes a list of supported mime-types and finds the best match for all the
+ media-ranges listed in header. The value of header must be a string that
+ conforms to the format of the HTTP Accept: header. The value of 'supported'
+ is a list of mime-types. The list of supported mime-types should be sorted
+ in order of increasing desirability, in case of a situation where there is
+ a tie.
+
+ >>> best_match(['application/xbel+xml', 'text/xml'],
+ 'text/*;q=0.5,*/*; q=0.1')
+ 'text/xml'
+ """
+ split_header = _filter_blank(header.split(","))
+ parsed_header = [parse_media_range(r) for r in split_header]
+ weighted_matches = []
+ pos = 0
+ for mime_type in supported:
+ weighted_matches.append(
+ (fitness_and_quality_parsed(mime_type, parsed_header), pos, mime_type)
+ )
+ pos += 1
+ weighted_matches.sort()
+
+ return weighted_matches[-1][0][1] and weighted_matches[-1][2] or ""
+
+
+def _filter_blank(i):
+ for s in i:
+ if s.strip():
+ yield s
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/model.py b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/model.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ba27522357aeba242fa7d119b76d5e64623e3aa
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/model.py
@@ -0,0 +1,409 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""Model objects for requests and responses.
+
+Each API may support one or more serializations, such
+as JSON, Atom, etc. The model classes are responsible
+for converting between the wire format and the Python
+object representation.
+"""
+from __future__ import absolute_import
+
+__author__ = "jcgregorio@google.com (Joe Gregorio)"
+
+import json
+import logging
+import platform
+import urllib
+
+from googleapiclient import version as googleapiclient_version
+from googleapiclient.errors import HttpError
+
+_LIBRARY_VERSION = googleapiclient_version.__version__
+_PY_VERSION = platform.python_version()
+
+LOGGER = logging.getLogger(__name__)
+
+dump_request_response = False
+
+
+def _abstract():
+ raise NotImplementedError("You need to override this function")
+
+
+class Model(object):
+ """Model base class.
+
+ All Model classes should implement this interface.
+ The Model serializes and de-serializes between a wire
+ format such as JSON and a Python object representation.
+ """
+
+ def request(self, headers, path_params, query_params, body_value):
+ """Updates outgoing requests with a serialized body.
+
+ Args:
+ headers: dict, request headers
+ path_params: dict, parameters that appear in the request path
+ query_params: dict, parameters that appear in the query
+ body_value: object, the request body as a Python object, which must be
+ serializable.
+ Returns:
+ A tuple of (headers, path_params, query, body)
+
+ headers: dict, request headers
+ path_params: dict, parameters that appear in the request path
+ query: string, query part of the request URI
+ body: string, the body serialized in the desired wire format.
+ """
+ _abstract()
+
+ def response(self, resp, content):
+ """Convert the response wire format into a Python object.
+
+ Args:
+ resp: httplib2.Response, the HTTP response headers and status
+ content: string, the body of the HTTP response
+
+ Returns:
+ The body de-serialized as a Python object.
+
+ Raises:
+ googleapiclient.errors.HttpError if a non 2xx response is received.
+ """
+ _abstract()
+
+
+class BaseModel(Model):
+ """Base model class.
+
+ Subclasses should provide implementations for the "serialize" and
+ "deserialize" methods, as well as values for the following class attributes.
+
+ Attributes:
+ accept: The value to use for the HTTP Accept header.
+ content_type: The value to use for the HTTP Content-type header.
+ no_content_response: The value to return when deserializing a 204 "No
+ Content" response.
+ alt_param: The value to supply as the "alt" query parameter for requests.
+ """
+
+ accept = None
+ content_type = None
+ no_content_response = None
+ alt_param = None
+
+ def _log_request(self, headers, path_params, query, body):
+ """Logs debugging information about the request if requested."""
+ if dump_request_response:
+ LOGGER.info("--request-start--")
+ LOGGER.info("-headers-start-")
+ for h, v in headers.items():
+ LOGGER.info("%s: %s", h, v)
+ LOGGER.info("-headers-end-")
+ LOGGER.info("-path-parameters-start-")
+ for h, v in path_params.items():
+ LOGGER.info("%s: %s", h, v)
+ LOGGER.info("-path-parameters-end-")
+ LOGGER.info("body: %s", body)
+ LOGGER.info("query: %s", query)
+ LOGGER.info("--request-end--")
+
+ def request(self, headers, path_params, query_params, body_value):
+ """Updates outgoing requests with a serialized body.
+
+ Args:
+ headers: dict, request headers
+ path_params: dict, parameters that appear in the request path
+ query_params: dict, parameters that appear in the query
+ body_value: object, the request body as a Python object, which must be
+ serializable by json.
+ Returns:
+ A tuple of (headers, path_params, query, body)
+
+ headers: dict, request headers
+ path_params: dict, parameters that appear in the request path
+ query: string, query part of the request URI
+ body: string, the body serialized as JSON
+ """
+ query = self._build_query(query_params)
+ headers["accept"] = self.accept
+ headers["accept-encoding"] = "gzip, deflate"
+ if "user-agent" in headers:
+ headers["user-agent"] += " "
+ else:
+ headers["user-agent"] = ""
+ headers["user-agent"] += "(gzip)"
+ if "x-goog-api-client" in headers:
+ headers["x-goog-api-client"] += " "
+ else:
+ headers["x-goog-api-client"] = ""
+ headers["x-goog-api-client"] += "gdcl/%s gl-python/%s" % (
+ _LIBRARY_VERSION,
+ _PY_VERSION,
+ )
+
+ if body_value is not None:
+ headers["content-type"] = self.content_type
+ body_value = self.serialize(body_value)
+ self._log_request(headers, path_params, query, body_value)
+ return (headers, path_params, query, body_value)
+
+ def _build_query(self, params):
+ """Builds a query string.
+
+ Args:
+ params: dict, the query parameters
+
+ Returns:
+ The query parameters properly encoded into an HTTP URI query string.
+ """
+ if self.alt_param is not None:
+ params.update({"alt": self.alt_param})
+ astuples = []
+ for key, value in params.items():
+ if type(value) == type([]):
+ for x in value:
+ x = x.encode("utf-8")
+ astuples.append((key, x))
+ else:
+ if isinstance(value, str) and callable(value.encode):
+ value = value.encode("utf-8")
+ astuples.append((key, value))
+ return "?" + urllib.parse.urlencode(astuples)
+
+ def _log_response(self, resp, content):
+ """Logs debugging information about the response if requested."""
+ if dump_request_response:
+ LOGGER.info("--response-start--")
+ for h, v in resp.items():
+ LOGGER.info("%s: %s", h, v)
+ if content:
+ LOGGER.info(content)
+ LOGGER.info("--response-end--")
+
+ def response(self, resp, content):
+ """Convert the response wire format into a Python object.
+
+ Args:
+ resp: httplib2.Response, the HTTP response headers and status
+ content: string, the body of the HTTP response
+
+ Returns:
+ The body de-serialized as a Python object.
+
+ Raises:
+ googleapiclient.errors.HttpError if a non 2xx response is received.
+ """
+ self._log_response(resp, content)
+ # Error handling is TBD, for example, do we retry
+ # for some operation/error combinations?
+ if resp.status < 300:
+ if resp.status == 204:
+ # A 204: No Content response should be treated differently
+ # to all the other success states
+ return self.no_content_response
+ return self.deserialize(content)
+ else:
+ LOGGER.debug("Content from bad request was: %r" % content)
+ raise HttpError(resp, content)
+
+ def serialize(self, body_value):
+ """Perform the actual Python object serialization.
+
+ Args:
+ body_value: object, the request body as a Python object.
+
+ Returns:
+ string, the body in serialized form.
+ """
+ _abstract()
+
+ def deserialize(self, content):
+ """Perform the actual deserialization from response string to Python
+ object.
+
+ Args:
+ content: string, the body of the HTTP response
+
+ Returns:
+ The body de-serialized as a Python object.
+ """
+ _abstract()
+
+
+class JsonModel(BaseModel):
+ """Model class for JSON.
+
+ Serializes and de-serializes between JSON and the Python
+ object representation of HTTP request and response bodies.
+ """
+
+ accept = "application/json"
+ content_type = "application/json"
+ alt_param = "json"
+
+ def __init__(self, data_wrapper=False):
+ """Construct a JsonModel.
+
+ Args:
+ data_wrapper: boolean, wrap requests and responses in a data wrapper
+ """
+ self._data_wrapper = data_wrapper
+
+ def serialize(self, body_value):
+ if (
+ isinstance(body_value, dict)
+ and "data" not in body_value
+ and self._data_wrapper
+ ):
+ body_value = {"data": body_value}
+ return json.dumps(body_value)
+
+ def deserialize(self, content):
+ try:
+ content = content.decode("utf-8")
+ except AttributeError:
+ pass
+ try:
+ body = json.loads(content)
+ except json.decoder.JSONDecodeError:
+ body = content
+ else:
+ if self._data_wrapper and "data" in body:
+ body = body["data"]
+ return body
+
+ @property
+ def no_content_response(self):
+ return {}
+
+
+class RawModel(JsonModel):
+ """Model class for requests that don't return JSON.
+
+ Serializes and de-serializes between JSON and the Python
+ object representation of HTTP request, and returns the raw bytes
+ of the response body.
+ """
+
+ accept = "*/*"
+ content_type = "application/json"
+ alt_param = None
+
+ def deserialize(self, content):
+ return content
+
+ @property
+ def no_content_response(self):
+ return ""
+
+
+class MediaModel(JsonModel):
+ """Model class for requests that return Media.
+
+ Serializes and de-serializes between JSON and the Python
+ object representation of HTTP request, and returns the raw bytes
+ of the response body.
+ """
+
+ accept = "*/*"
+ content_type = "application/json"
+ alt_param = "media"
+
+ def deserialize(self, content):
+ return content
+
+ @property
+ def no_content_response(self):
+ return ""
+
+
+class ProtocolBufferModel(BaseModel):
+ """Model class for protocol buffers.
+
+ Serializes and de-serializes the binary protocol buffer sent in the HTTP
+ request and response bodies.
+ """
+
+ accept = "application/x-protobuf"
+ content_type = "application/x-protobuf"
+ alt_param = "proto"
+
+ def __init__(self, protocol_buffer):
+ """Constructs a ProtocolBufferModel.
+
+ The serialized protocol buffer returned in an HTTP response will be
+ de-serialized using the given protocol buffer class.
+
+ Args:
+ protocol_buffer: The protocol buffer class used to de-serialize a
+ response from the API.
+ """
+ self._protocol_buffer = protocol_buffer
+
+ def serialize(self, body_value):
+ return body_value.SerializeToString()
+
+ def deserialize(self, content):
+ return self._protocol_buffer.FromString(content)
+
+ @property
+ def no_content_response(self):
+ return self._protocol_buffer()
+
+
+def makepatch(original, modified):
+ """Create a patch object.
+
+ Some methods support PATCH, an efficient way to send updates to a resource.
+ This method allows the easy construction of patch bodies by looking at the
+ differences between a resource before and after it was modified.
+
+ Args:
+ original: object, the original deserialized resource
+ modified: object, the modified deserialized resource
+ Returns:
+ An object that contains only the changes from original to modified, in a
+ form suitable to pass to a PATCH method.
+
+ Example usage:
+ item = service.activities().get(postid=postid, userid=userid).execute()
+ original = copy.deepcopy(item)
+ item['object']['content'] = 'This is updated.'
+ service.activities.patch(postid=postid, userid=userid,
+ body=makepatch(original, item)).execute()
+ """
+ patch = {}
+ for key, original_value in original.items():
+ modified_value = modified.get(key, None)
+ if modified_value is None:
+ # Use None to signal that the element is deleted
+ patch[key] = None
+ elif original_value != modified_value:
+ if type(original_value) == type({}):
+ # Recursively descend objects
+ patch[key] = makepatch(original_value, modified_value)
+ else:
+ # In the case of simple types or arrays we just replace
+ patch[key] = modified_value
+ else:
+ # Don't add anything to patch if there's no change
+ pass
+ for key in modified:
+ if key not in original:
+ patch[key] = modified[key]
+
+ return patch
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/sample_tools.py b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/sample_tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..bdad0a2ae878f43627199c5a7dcdd82cad0a8e8e
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/sample_tools.py
@@ -0,0 +1,108 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""Utilities for making samples.
+
+Consolidates a lot of code commonly repeated in sample applications.
+"""
+from __future__ import absolute_import
+
+__author__ = "jcgregorio@google.com (Joe Gregorio)"
+__all__ = ["init"]
+
+
+import argparse
+import os
+
+from googleapiclient import discovery
+from googleapiclient.http import build_http
+
+
+def init(
+ argv, name, version, doc, filename, scope=None, parents=[], discovery_filename=None
+):
+ """A common initialization routine for samples.
+
+ Many of the sample applications do the same initialization, which has now
+ been consolidated into this function. This function uses common idioms found
+ in almost all the samples, i.e. for an API with name 'apiname', the
+ credentials are stored in a file named apiname.dat, and the
+ client_secrets.json file is stored in the same directory as the application
+ main file.
+
+ Args:
+ argv: list of string, the command-line parameters of the application.
+ name: string, name of the API.
+ version: string, version of the API.
+ doc: string, description of the application. Usually set to __doc__.
+ file: string, filename of the application. Usually set to __file__.
+ parents: list of argparse.ArgumentParser, additional command-line flags.
+ scope: string, The OAuth scope used.
+ discovery_filename: string, name of local discovery file (JSON). Use when discovery doc not available via URL.
+
+ Returns:
+ A tuple of (service, flags), where service is the service object and flags
+ is the parsed command-line flags.
+ """
+ try:
+ from oauth2client import client, file, tools
+ except ImportError:
+ raise ImportError(
+ "googleapiclient.sample_tools requires oauth2client. Please install oauth2client and try again."
+ )
+
+ if scope is None:
+ scope = "https://www.googleapis.com/auth/" + name
+
+ # Parser command-line arguments.
+ parent_parsers = [tools.argparser]
+ parent_parsers.extend(parents)
+ parser = argparse.ArgumentParser(
+ description=doc,
+ formatter_class=argparse.RawDescriptionHelpFormatter,
+ parents=parent_parsers,
+ )
+ flags = parser.parse_args(argv[1:])
+
+ # Name of a file containing the OAuth 2.0 information for this
+ # application, including client_id and client_secret, which are found
+ # on the API Access tab on the Google APIs
+ # Console .
+ client_secrets = os.path.join(os.path.dirname(filename), "client_secrets.json")
+
+ # Set up a Flow object to be used if we need to authenticate.
+ flow = client.flow_from_clientsecrets(
+ client_secrets, scope=scope, message=tools.message_if_missing(client_secrets)
+ )
+
+ # Prepare credentials, and authorize HTTP object with them.
+ # If the credentials don't exist or are invalid run through the native client
+ # flow. The Storage object will ensure that if successful the good
+ # credentials will get written back to a file.
+ storage = file.Storage(name + ".dat")
+ credentials = storage.get()
+ if credentials is None or credentials.invalid:
+ credentials = tools.run_flow(flow, storage, flags)
+ http = credentials.authorize(http=build_http())
+
+ if discovery_filename is None:
+ # Construct a service object via the discovery service.
+ service = discovery.build(name, version, http=http)
+ else:
+ # Construct a service object using a local discovery document file.
+ with open(discovery_filename) as discovery_file:
+ service = discovery.build_from_document(
+ discovery_file.read(), base="https://www.googleapis.com/", http=http
+ )
+ return (service, flags)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/schema.py b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/schema.py
new file mode 100644
index 0000000000000000000000000000000000000000..93b07df44ac6cb3ddf47a23218801de2ecdc6614
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/schema.py
@@ -0,0 +1,317 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+"""Schema processing for discovery based APIs
+
+Schemas holds an APIs discovery schemas. It can return those schema as
+deserialized JSON objects, or pretty print them as prototype objects that
+conform to the schema.
+
+For example, given the schema:
+
+ schema = \"\"\"{
+ "Foo": {
+ "type": "object",
+ "properties": {
+ "etag": {
+ "type": "string",
+ "description": "ETag of the collection."
+ },
+ "kind": {
+ "type": "string",
+ "description": "Type of the collection ('calendar#acl').",
+ "default": "calendar#acl"
+ },
+ "nextPageToken": {
+ "type": "string",
+ "description": "Token used to access the next
+ page of this result. Omitted if no further results are available."
+ }
+ }
+ }
+ }\"\"\"
+
+ s = Schemas(schema)
+ print s.prettyPrintByName('Foo')
+
+ Produces the following output:
+
+ {
+ "nextPageToken": "A String", # Token used to access the
+ # next page of this result. Omitted if no further results are available.
+ "kind": "A String", # Type of the collection ('calendar#acl').
+ "etag": "A String", # ETag of the collection.
+ },
+
+The constructor takes a discovery document in which to look up named schema.
+"""
+from __future__ import absolute_import
+
+# TODO(jcgregorio) support format, enum, minimum, maximum
+
+__author__ = "jcgregorio@google.com (Joe Gregorio)"
+
+
+from collections import OrderedDict
+
+from googleapiclient import _helpers as util
+
+
+class Schemas(object):
+ """Schemas for an API."""
+
+ def __init__(self, discovery):
+ """Constructor.
+
+ Args:
+ discovery: object, Deserialized discovery document from which we pull
+ out the named schema.
+ """
+ self.schemas = discovery.get("schemas", {})
+
+ # Cache of pretty printed schemas.
+ self.pretty = {}
+
+ @util.positional(2)
+ def _prettyPrintByName(self, name, seen=None, dent=0):
+ """Get pretty printed object prototype from the schema name.
+
+ Args:
+ name: string, Name of schema in the discovery document.
+ seen: list of string, Names of schema already seen. Used to handle
+ recursive definitions.
+
+ Returns:
+ string, A string that contains a prototype object with
+ comments that conforms to the given schema.
+ """
+ if seen is None:
+ seen = []
+
+ if name in seen:
+ # Do not fall into an infinite loop over recursive definitions.
+ return "# Object with schema name: %s" % name
+ seen.append(name)
+
+ if name not in self.pretty:
+ self.pretty[name] = _SchemaToStruct(
+ self.schemas[name], seen, dent=dent
+ ).to_str(self._prettyPrintByName)
+
+ seen.pop()
+
+ return self.pretty[name]
+
+ def prettyPrintByName(self, name):
+ """Get pretty printed object prototype from the schema name.
+
+ Args:
+ name: string, Name of schema in the discovery document.
+
+ Returns:
+ string, A string that contains a prototype object with
+ comments that conforms to the given schema.
+ """
+ # Return with trailing comma and newline removed.
+ return self._prettyPrintByName(name, seen=[], dent=0)[:-2]
+
+ @util.positional(2)
+ def _prettyPrintSchema(self, schema, seen=None, dent=0):
+ """Get pretty printed object prototype of schema.
+
+ Args:
+ schema: object, Parsed JSON schema.
+ seen: list of string, Names of schema already seen. Used to handle
+ recursive definitions.
+
+ Returns:
+ string, A string that contains a prototype object with
+ comments that conforms to the given schema.
+ """
+ if seen is None:
+ seen = []
+
+ return _SchemaToStruct(schema, seen, dent=dent).to_str(self._prettyPrintByName)
+
+ def prettyPrintSchema(self, schema):
+ """Get pretty printed object prototype of schema.
+
+ Args:
+ schema: object, Parsed JSON schema.
+
+ Returns:
+ string, A string that contains a prototype object with
+ comments that conforms to the given schema.
+ """
+ # Return with trailing comma and newline removed.
+ return self._prettyPrintSchema(schema, dent=0)[:-2]
+
+ def get(self, name, default=None):
+ """Get deserialized JSON schema from the schema name.
+
+ Args:
+ name: string, Schema name.
+ default: object, return value if name not found.
+ """
+ return self.schemas.get(name, default)
+
+
+class _SchemaToStruct(object):
+ """Convert schema to a prototype object."""
+
+ @util.positional(3)
+ def __init__(self, schema, seen, dent=0):
+ """Constructor.
+
+ Args:
+ schema: object, Parsed JSON schema.
+ seen: list, List of names of schema already seen while parsing. Used to
+ handle recursive definitions.
+ dent: int, Initial indentation depth.
+ """
+ # The result of this parsing kept as list of strings.
+ self.value = []
+
+ # The final value of the parsing.
+ self.string = None
+
+ # The parsed JSON schema.
+ self.schema = schema
+
+ # Indentation level.
+ self.dent = dent
+
+ # Method that when called returns a prototype object for the schema with
+ # the given name.
+ self.from_cache = None
+
+ # List of names of schema already seen while parsing.
+ self.seen = seen
+
+ def emit(self, text):
+ """Add text as a line to the output.
+
+ Args:
+ text: string, Text to output.
+ """
+ self.value.extend([" " * self.dent, text, "\n"])
+
+ def emitBegin(self, text):
+ """Add text to the output, but with no line terminator.
+
+ Args:
+ text: string, Text to output.
+ """
+ self.value.extend([" " * self.dent, text])
+
+ def emitEnd(self, text, comment):
+ """Add text and comment to the output with line terminator.
+
+ Args:
+ text: string, Text to output.
+ comment: string, Python comment.
+ """
+ if comment:
+ divider = "\n" + " " * (self.dent + 2) + "# "
+ lines = comment.splitlines()
+ lines = [x.rstrip() for x in lines]
+ comment = divider.join(lines)
+ self.value.extend([text, " # ", comment, "\n"])
+ else:
+ self.value.extend([text, "\n"])
+
+ def indent(self):
+ """Increase indentation level."""
+ self.dent += 1
+
+ def undent(self):
+ """Decrease indentation level."""
+ self.dent -= 1
+
+ def _to_str_impl(self, schema):
+ """Prototype object based on the schema, in Python code with comments.
+
+ Args:
+ schema: object, Parsed JSON schema file.
+
+ Returns:
+ Prototype object based on the schema, in Python code with comments.
+ """
+ stype = schema.get("type")
+ if stype == "object":
+ self.emitEnd("{", schema.get("description", ""))
+ self.indent()
+ if "properties" in schema:
+ properties = schema.get("properties", {})
+ sorted_properties = OrderedDict(sorted(properties.items()))
+ for pname, pschema in sorted_properties.items():
+ self.emitBegin('"%s": ' % pname)
+ self._to_str_impl(pschema)
+ elif "additionalProperties" in schema:
+ self.emitBegin('"a_key": ')
+ self._to_str_impl(schema["additionalProperties"])
+ self.undent()
+ self.emit("},")
+ elif "$ref" in schema:
+ schemaName = schema["$ref"]
+ description = schema.get("description", "")
+ s = self.from_cache(schemaName, seen=self.seen)
+ parts = s.splitlines()
+ self.emitEnd(parts[0], description)
+ for line in parts[1:]:
+ self.emit(line.rstrip())
+ elif stype == "boolean":
+ value = schema.get("default", "True or False")
+ self.emitEnd("%s," % str(value), schema.get("description", ""))
+ elif stype == "string":
+ value = schema.get("default", "A String")
+ self.emitEnd('"%s",' % str(value), schema.get("description", ""))
+ elif stype == "integer":
+ value = schema.get("default", "42")
+ self.emitEnd("%s," % str(value), schema.get("description", ""))
+ elif stype == "number":
+ value = schema.get("default", "3.14")
+ self.emitEnd("%s," % str(value), schema.get("description", ""))
+ elif stype == "null":
+ self.emitEnd("None,", schema.get("description", ""))
+ elif stype == "any":
+ self.emitEnd('"",', schema.get("description", ""))
+ elif stype == "array":
+ self.emitEnd("[", schema.get("description"))
+ self.indent()
+ self.emitBegin("")
+ self._to_str_impl(schema["items"])
+ self.undent()
+ self.emit("],")
+ else:
+ self.emit("Unknown type! %s" % stype)
+ self.emitEnd("", "")
+
+ self.string = "".join(self.value)
+ return self.string
+
+ def to_str(self, from_cache):
+ """Prototype object based on the schema, in Python code with comments.
+
+ Args:
+ from_cache: callable(name, seen), Callable that retrieves an object
+ prototype for a schema with the given name. Seen is a list of schema
+ names already seen as we recursively descend the schema definition.
+
+ Returns:
+ Prototype object based on the schema, in Python code with comments.
+ The lines of the code will all be properly indented.
+ """
+ self.from_cache = from_cache
+ return self._to_str_impl(self.schema)
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/version.py b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a555a350304352bf1c7c2478f9b19565efc0095
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapiclient/version.py
@@ -0,0 +1,15 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+__version__ = "2.127.0"
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/INSTALLER b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/LICENSE b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..d645695673349e3947e8e5ae42332d0ac3164cd7
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ 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.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/METADATA b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..892416efea51f47a28ecb2cbc0b7415ed5ce62f9
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/METADATA
@@ -0,0 +1,36 @@
+Metadata-Version: 2.1
+Name: googleapis-common-protos
+Version: 1.63.0
+Summary: Common protobufs used in Google APIs
+Home-page: https://github.com/googleapis/python-api-common-protos
+Author: Google LLC
+Author-email: googleapis-packages@google.com
+License: Apache-2.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: protobuf !=3.20.0,!=3.20.1,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0.dev0,>=3.19.5
+Provides-Extra: grpc
+Requires-Dist: grpcio <2.0.0.dev0,>=1.44.0 ; extra == 'grpc'
+
+Google APIs common protos
+-------------------------
+
+.. image:: https://img.shields.io/pypi/v/googleapis-common-protos.svg
+ :target: https://pypi.org/project/googleapis-common-protos/
+
+
+googleapis-common-protos contains the python classes generated from the common
+protos in the `googleapis/googleapis `_ repository.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/RECORD b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..49f386647b3901b749bb7790b8a30a9a3a285248
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/RECORD
@@ -0,0 +1,202 @@
+google/api/__pycache__/annotations_pb2.cpython-311.pyc,,
+google/api/__pycache__/auth_pb2.cpython-311.pyc,,
+google/api/__pycache__/backend_pb2.cpython-311.pyc,,
+google/api/__pycache__/billing_pb2.cpython-311.pyc,,
+google/api/__pycache__/client_pb2.cpython-311.pyc,,
+google/api/__pycache__/config_change_pb2.cpython-311.pyc,,
+google/api/__pycache__/consumer_pb2.cpython-311.pyc,,
+google/api/__pycache__/context_pb2.cpython-311.pyc,,
+google/api/__pycache__/control_pb2.cpython-311.pyc,,
+google/api/__pycache__/distribution_pb2.cpython-311.pyc,,
+google/api/__pycache__/documentation_pb2.cpython-311.pyc,,
+google/api/__pycache__/endpoint_pb2.cpython-311.pyc,,
+google/api/__pycache__/error_reason_pb2.cpython-311.pyc,,
+google/api/__pycache__/field_behavior_pb2.cpython-311.pyc,,
+google/api/__pycache__/field_info_pb2.cpython-311.pyc,,
+google/api/__pycache__/http_pb2.cpython-311.pyc,,
+google/api/__pycache__/httpbody_pb2.cpython-311.pyc,,
+google/api/__pycache__/label_pb2.cpython-311.pyc,,
+google/api/__pycache__/launch_stage_pb2.cpython-311.pyc,,
+google/api/__pycache__/log_pb2.cpython-311.pyc,,
+google/api/__pycache__/logging_pb2.cpython-311.pyc,,
+google/api/__pycache__/metric_pb2.cpython-311.pyc,,
+google/api/__pycache__/monitored_resource_pb2.cpython-311.pyc,,
+google/api/__pycache__/monitoring_pb2.cpython-311.pyc,,
+google/api/__pycache__/policy_pb2.cpython-311.pyc,,
+google/api/__pycache__/quota_pb2.cpython-311.pyc,,
+google/api/__pycache__/resource_pb2.cpython-311.pyc,,
+google/api/__pycache__/routing_pb2.cpython-311.pyc,,
+google/api/__pycache__/service_pb2.cpython-311.pyc,,
+google/api/__pycache__/source_info_pb2.cpython-311.pyc,,
+google/api/__pycache__/system_parameter_pb2.cpython-311.pyc,,
+google/api/__pycache__/usage_pb2.cpython-311.pyc,,
+google/api/__pycache__/visibility_pb2.cpython-311.pyc,,
+google/api/annotations.proto,sha256=09O0u-gMBIHDVQc3b1ZT_P38vcfxaKqwl_Ja5kO36-g,1045
+google/api/annotations_pb2.py,sha256=YF9EPjyDHsuST4Wc-6PKGTU8Me99WEvq4iJqhYxpfkA,2133
+google/api/auth.proto,sha256=u8PdMmE2SGz-KxYJegFwtyjEpuSeVQW-jkWEXJAbQjg,9257
+google/api/auth_pb2.py,sha256=wtl4w33zZZ1CjhsEAJapVolMOdRFP2iOdwLT0L9VfP0,5613
+google/api/backend.proto,sha256=qvxyM1fK4tqaP3uWBCPohZhUnzLmywuwOxdcdDxPTdw,7014
+google/api/backend_pb2.py,sha256=-tzYI1CRFlwbU6VPRaRER5_3cqI0umzmkJA_UUJD4Is,4838
+google/api/billing.proto,sha256=xZ0G1HmUepQukR_Y7ZiUJwb-dFnFOOGiIJb-PbCrd8c,3062
+google/api/billing_pb2.py,sha256=jgYLuA4FLUXJRF-Y0HeRDTsbQrkljz_KarHP9TWCgs0,2933
+google/api/client.proto,sha256=9TwY6nVlJIRJdtX7kcZc2auusupQxsRzoLfzhsFDVQI,14713
+google/api/client_pb2.py,sha256=Xo60EbQr_0gt7yUPIx8wsIFoPwuEFNndnNwq6nxbv8Y,17267
+google/api/config_change.proto,sha256=kuiMcrr5XvH3HFN31V9MhIfdTeChNTnTtETlg-s7N7k,3166
+google/api/config_change_pb2.py,sha256=cUbDOjd9uwousOYM9p7qA4Q7y68aLnKFjF1sSu6bOIM,3374
+google/api/consumer.proto,sha256=nRIVNOKCPv2beOI2AfALSLJfmYlkRe2QriVRBY-lIIQ,2717
+google/api/consumer_pb2.py,sha256=Ov5COY4mlEBH0Hc3Eg6izxrd1iOfBcw78Ue3GG4dZCU,3138
+google/api/context.proto,sha256=BzCCy5wtEl-UTci4sWU0bYTtbp8Dn4zywPHZCZhA70g,3067
+google/api/context_pb2.py,sha256=yP4_kQz8Zm_GnVf8L-DuUvghfnPOKMccabQeB-MWupw,2844
+google/api/control.proto,sha256=ktHfRtYcfxkJ01tkDxHzhCCbFp2pOzhnBAuWFdqwEyg,1436
+google/api/control_pb2.py,sha256=8533F75OpqFwiFn4h_jFWuaB0nIVfYqmI3vrUahX2n4,2300
+google/api/distribution.proto,sha256=60XQt_MNXylP8XZaUVL0pWQ-mNHrwDL20DPX1jqSEDM,8660
+google/api/distribution_pb2.py,sha256=9dKLzQiLjbUyYxfPEAp0NkKSJcgUugfOkcfTo1-SE2Q,7845
+google/api/documentation.proto,sha256=0uInhGiosl0j97XbXy7JisxdM8ZZwkUI_avEwFK73-o,6940
+google/api/documentation_pb2.py,sha256=Mux0olXLDUgMuZ9KBXtrowzwjEO8SjbV_4d9DGSr5AA,3698
+google/api/endpoint.proto,sha256=hpZTTEOcIQKPt4PdsgSN1BXJXTWK5Bbi77RA21Q3G4M,3028
+google/api/endpoint_pb2.py,sha256=lj5ZV1xx8oczPmqFYSOUGUqPYR9jh0ADBkSBoDQswEc,2380
+google/api/error_reason.proto,sha256=CBA3T2eg17dOXscynFIcIhK-mCqTYY3lUrJG82SQcnE,22644
+google/api/error_reason_pb2.py,sha256=anyJ-h-bXZZx1acS1kiELB3lNxN5T0h95-kgtVTB_yw,4267
+google/api/field_behavior.proto,sha256=sr0D9MqnF3kMYRLxZy8D3oJqEnMiHoGcJRuBN5L_9LI,4306
+google/api/field_behavior_pb2.py,sha256=twdNwrHeqq2xXQqihgbTW2HW-hvffT_oV43FWHxpMys,2973
+google/api/field_info.proto,sha256=kvrsv6SkuDyDPEsaTcWDIR6ZdMIvfLAMCGfS7jOwwE8,3156
+google/api/field_info_pb2.py,sha256=rFh5xZxM_zQPob1_MplM_3LO1xrSU5snrF22lD11qlo,2920
+google/api/http.proto,sha256=L_4ZHyCammjjDwSTxm1c4Vvo3qwnbVW81BJ_jMf0U-I,15159
+google/api/http_pb2.py,sha256=koUyg-VEMqSMlv-kJklMyBDN3jxjHjMpJL-VJbm5sGA,3701
+google/api/httpbody.proto,sha256=RPXmE_7DRqAjCzaHAvb_CMCn0y8F1LwsZL9R3xnsQ8k,2693
+google/api/httpbody_pb2.py,sha256=OISoFp1ICdU5VKD0eHiVOqyQEC6XkjcwYpQZLoPYt1c,2344
+google/api/label.proto,sha256=JViuxDB6MwdRL5Gk0O6JDptyXisc43fBItUGf_b4_kE,1389
+google/api/label_pb2.py,sha256=_V5_MSffDWP5ONpU1peWP0H_3N4S7qP54MtJxAfVKp4,2581
+google/api/launch_stage.proto,sha256=zZcQL4rXzkrgSqoFe269y3OyUn6hcw8pIvnYnRsf9GA,3083
+google/api/launch_stage_pb2.py,sha256=dyaJQ0t77VOXH3XO0n_jbyidIFfrFiMzvLkQ7eCEzF8,2277
+google/api/log.proto,sha256=MSWzePwp2r1WUBX9kFRHeKUSBVWlyeJGXEHoDuZFiBI,2043
+google/api/log_pb2.py,sha256=H_YgxiGviHLtv7iqTWICVjjV2Al_Fx7voyRy5JySGL4,2402
+google/api/logging.proto,sha256=yKbh67OdirGJB4B754U5P64CpZhZwgl_dslbKsBE48M,3174
+google/api/logging_pb2.py,sha256=PUtosIJ9S36_E4ZA4czj16mr1rOh_a_7te5LyXWWHoA,3014
+google/api/metric.proto,sha256=emZwaXd7TzFNSd2sXUD_XdpK3tfPA9GzyEeZn6BN-_0,10605
+google/api/metric_pb2.py,sha256=EUk_3BU3a8Fw37apksZ_hlc93ynSUu3XRZV52GgUpVA,6432
+google/api/monitored_resource.proto,sha256=DZiXCbvLH9PW0DSjYfoxZzblgid2N-fAsfS7qk6q2iw,5920
+google/api/monitored_resource_pb2.py,sha256=yKAPdtiTiEfKYSFIeCQwPWZfdo-RxLNSbuz5qVYFlqY,6324
+google/api/monitoring.proto,sha256=9RAWLxXvsiRrPfH7ZJnLxb3uvnoauDMclCON_PciefA,4457
+google/api/monitoring_pb2.py,sha256=sqB9wfL4Ms1jpjThYz0gUbttNu1bMIegV8JnQM1jtpg,3129
+google/api/policy.proto,sha256=jfFD0EcmCDcPSRR4FYXxqJq7ik2jOhcEfCwQnCSLJyI,3254
+google/api/policy_pb2.py,sha256=cmNXJ_IyvwwXftF_NWjwEycYMZvsyB6hSmZ6Jmvix9k,3608
+google/api/quota.proto,sha256=J2XtnPZgFcvNZEUYxKeoOxmZkk9qc0fgw-RaceiIfE4,7138
+google/api/quota_pb2.py,sha256=WUc5bd9VEtegpSdQFjHjW13G93KQSI6g8INdMDg4N3Q,5303
+google/api/resource.proto,sha256=DZKZOJK1tR4LSrTd6dG2hngbOVCVvwdygy10hJtL9Cw,8744
+google/api/resource_pb2.py,sha256=fkpZbj1fa13oQEWlR2mJyEhwVmE0Z2JPtziWx43p6LQ,4870
+google/api/routing.proto,sha256=ckmS9y9-Bjgo9EqDunvX0NxkgXGVLjo5hgK7mmKX2BY,14929
+google/api/routing_pb2.py,sha256=jMlornQKLJA5QWV2Uvg3zkbsYt4MxERuTAGyzAGvi90,3189
+google/api/service.proto,sha256=q6s7MJZIDsOwIGkp526ieNbyG-_hER2ot3F3YuSklWY,6762
+google/api/service_pb2.py,sha256=pjj3yYNuDOwvayJAGHJHdRBie9FKsS_1V5CLEhie0R4,5979
+google/api/source_info.proto,sha256=Wrh5ykV_Xh8LoacqD-cXb8a_zxcpIPR_r0EaUBWD9lg,1091
+google/api/source_info_pb2.py,sha256=PLZrMXESnQSXpxYUHjiUrVFqTiepW3j4sk4wyxEAU2c,2292
+google/api/system_parameter.proto,sha256=vbN1_GdjvsPRiP6MW_fsDzOEHscA7Mzy2i3GqfAZSiQ,3475
+google/api/system_parameter_pb2.py,sha256=PSwnzUUjh2mzEoM5hWKwp0EIU_3wXmxBl9-qNocrJnA,3583
+google/api/usage.proto,sha256=8kJh9mrTKQ7gNxX_VntFH9ShcB4kDJHmzv7S-2SpMsY,3787
+google/api/usage_pb2.py,sha256=sx_aUDinwllJqMW1bTz61583bnAXNHXrYqZ4GSZTrxk,2791
+google/api/visibility.proto,sha256=PITea3Rt7KkZQgSEgMxC234uUlPFTuxcJsLFsjdlYCM,3799
+google/api/visibility_pb2.py,sha256=LqZr2qeBjnzV8IR9tqNRmXI8Bskxt69xMDFD-Fa4u8c,4956
+google/cloud/__pycache__/extended_operations_pb2.cpython-311.pyc,,
+google/cloud/extended_operations.proto,sha256=YJSiUZyj11GQWoC33lbtUkttnz1--TfvVlpk4g9iu60,6308
+google/cloud/extended_operations_pb2.py,sha256=xKWiAi1sLCfEKPYkYnDiwlA7z7rnlBYUMTnWmKsSJDQ,4032
+google/cloud/location/__pycache__/locations_pb2.cpython-311.pyc,,
+google/cloud/location/locations.proto,sha256=7DPpJRIbH8jMe44Isz-8X6vooGE6AnkIFT0sFE84dhs,3604
+google/cloud/location/locations_pb2.py,sha256=ECp0OFSg2o1UiMfy2lWdpqulf4UEish8W20N0eU8PLQ,6899
+google/gapic/metadata/__pycache__/gapic_metadata_pb2.cpython-311.pyc,,
+google/gapic/metadata/gapic_metadata.proto,sha256=QuhLul-63A_1cdrk57GUm3dtbimtpSSCCbjIt6olym8,3393
+google/gapic/metadata/gapic_metadata_pb2.py,sha256=x-EJeba3Btl9E0K3W5SqRGKgmjDsEA1FLa6CFVKXv7I,8346
+google/logging/type/__pycache__/http_request_pb2.cpython-311.pyc,,
+google/logging/type/__pycache__/log_severity_pb2.cpython-311.pyc,,
+google/logging/type/http_request.proto,sha256=uzaKHqH3enOvfAYlKC2iE0Hn2iA827KsR7T-a9_gUOQ,3601
+google/logging/type/http_request_pb2.py,sha256=Nb-XAlILoKbfpfj1tpJVpIyx0NvFf-2fttombdlJhhc,3176
+google/logging/type/log_severity.proto,sha256=WB3qvy_1RdtZz0tlDPlcYzgyoA40K2n54tySkbcTOLE,2555
+google/logging/type/log_severity_pb2.py,sha256=gVb0R8dOvN6fYTLRnWnZyel-YIMRcBsj0GAFVQDXqTA,2622
+google/longrunning/__pycache__/operations_grpc.cpython-311.pyc,,
+google/longrunning/__pycache__/operations_grpc_pb2.cpython-311.pyc,,
+google/longrunning/__pycache__/operations_pb2.cpython-311.pyc,,
+google/longrunning/__pycache__/operations_pb2_grpc.cpython-311.pyc,,
+google/longrunning/__pycache__/operations_proto.cpython-311.pyc,,
+google/longrunning/__pycache__/operations_proto_pb2.cpython-311.pyc,,
+google/longrunning/operations.proto,sha256=a3F1Vl2rsgO481XBr0PKrRghjWu5ZC5IasKeN7v8TEQ,10513
+google/longrunning/operations_grpc.py,sha256=nulj2Z10WF2ggHn3LMJ4IhUbtAmTbISk6zb7RDKJc3c,797
+google/longrunning/operations_grpc_pb2.py,sha256=eUCKbAgcHJRKT1Dq1iud7y9SacGX1B96g4sX-UJiMfk,914
+google/longrunning/operations_pb2.py,sha256=GEezQBLVw5LvEZYwq_V7zptQJLL9gWs3dUNqHDotHK8,2253
+google/longrunning/operations_pb2_grpc.py,sha256=XCmhWtnahuW6TIfekqggTAChF49ZF7TU6kY3j7Wgqk8,14464
+google/longrunning/operations_proto.py,sha256=ZXPIBp7WWZoZ9wn_Dr5UBi7XDYduodBqMlihm30f6NM,222
+google/longrunning/operations_proto_pb2.py,sha256=j6hATmAEzprWY1GR_VzCOUaTH9FA9AJDWbHGEp9R7EA,10443
+google/rpc/__pycache__/code_pb2.cpython-311.pyc,,
+google/rpc/__pycache__/error_details_pb2.cpython-311.pyc,,
+google/rpc/__pycache__/http_pb2.cpython-311.pyc,,
+google/rpc/__pycache__/status_pb2.cpython-311.pyc,,
+google/rpc/code.proto,sha256=hmoQd4S8If7XkY63aNBVSgpzzoKz_k-uvf3BvONgl3M,7138
+google/rpc/code_pb2.py,sha256=vvDGSq77csBfVJRLj0BUfvM5ZFiVozaFe6DKR1996z0,2707
+google/rpc/context/__pycache__/attribute_context_pb2.cpython-311.pyc,,
+google/rpc/context/__pycache__/audit_context_pb2.cpython-311.pyc,,
+google/rpc/context/attribute_context.proto,sha256=5tSRA8ggvbpnOn2jhyCxklUaHqQOeobupD7dUCoGyVo,14852
+google/rpc/context/attribute_context_pb2.py,sha256=e0PIy8ksorphcJR9bGw4ai43KPZxCr-ofa2fODBtPjY,14660
+google/rpc/context/audit_context.proto,sha256=R80PkNeRDMRJ-D9hvgi8SxYA_S0EVoHrbBbaXkYAI90,1861
+google/rpc/context/audit_context_pb2.py,sha256=4vbYr_XFfwNHqpo9c7fzvtHFHiDvq1KihMwKlKz8rvU,2603
+google/rpc/error_details.proto,sha256=j5dPUn_1MBQ_FNTwbpewLDFFKXWGnd6EPjHMJPj50Ns,10869
+google/rpc/error_details_pb2.py,sha256=0kiN6fc94jQvsaeMy3s7S-b3EhsM46yXY2WmN6TA78s,11094
+google/rpc/http.proto,sha256=PKlTG0AmdqGUfGi3shoTlm-DCH2dAl62rSBL2X41uL0,1940
+google/rpc/http_pb2.py,sha256=5bNcOVfY8tlHEp_JFozfQe2xRIaEbDuWc2udr1eqK1g,3404
+google/rpc/status.proto,sha256=0b5oDhU-v4IIDAHEHd9ArG3lreRz_IY5GDu6tbnSR1U,1934
+google/rpc/status_pb2.py,sha256=SGM-WxVgLbnqxCc1JQGmPJKvOpVOVhfiWSg-KrH8Ujs,2302
+google/type/__pycache__/calendar_period_pb2.cpython-311.pyc,,
+google/type/__pycache__/color_pb2.cpython-311.pyc,,
+google/type/__pycache__/date_pb2.cpython-311.pyc,,
+google/type/__pycache__/datetime_pb2.cpython-311.pyc,,
+google/type/__pycache__/dayofweek_pb2.cpython-311.pyc,,
+google/type/__pycache__/decimal_pb2.cpython-311.pyc,,
+google/type/__pycache__/expr_pb2.cpython-311.pyc,,
+google/type/__pycache__/fraction_pb2.cpython-311.pyc,,
+google/type/__pycache__/interval_pb2.cpython-311.pyc,,
+google/type/__pycache__/latlng_pb2.cpython-311.pyc,,
+google/type/__pycache__/localized_text_pb2.cpython-311.pyc,,
+google/type/__pycache__/money_pb2.cpython-311.pyc,,
+google/type/__pycache__/month_pb2.cpython-311.pyc,,
+google/type/__pycache__/phone_number_pb2.cpython-311.pyc,,
+google/type/__pycache__/postal_address_pb2.cpython-311.pyc,,
+google/type/__pycache__/quaternion_pb2.cpython-311.pyc,,
+google/type/__pycache__/timeofday_pb2.cpython-311.pyc,,
+google/type/calendar_period.proto,sha256=Uv20O4lquXuT9Au_bJKJ94UHgD3V9XIZURjtgVIUdUE,1762
+google/type/calendar_period_pb2.py,sha256=hZCpKJsaRPCWGp1vNC5XI2B0IUjiHnoBGeFHI7EwCP4,2343
+google/type/color.proto,sha256=kK9GArFcQ4lj6mkLueoapkOSUprR3lNFpng43YNrUI0,6376
+google/type/color_pb2.py,sha256=IUMmF1mMTBbj6iZtGH0Jocx-duS_T-dSbFIoeUKjiqo,2343
+google/type/date.proto,sha256=BuBfGZRa3GepdFMQ_1cRhpdyio8qJ8BtYkkQdvAOIws,1955
+google/type/date_pb2.py,sha256=hpA97snLnWGhirx7dt7tq3J3MOl4vU909-K0QnfTIVE,2138
+google/type/datetime.proto,sha256=iRLRmPPSRZ5b86o6yjiIsK810RXGysWwSaF08CXtAlU,3905
+google/type/datetime_pb2.py,sha256=PuOi4a1AmmOFWijE417NB1Wh5zJxQKFyz3rLQs5LjrU,3165
+google/type/dayofweek.proto,sha256=56YBXUUcCxXQmPWNg76G3OII-bPLtAjCmvCTkgs6JwY,1204
+google/type/dayofweek_pb2.py,sha256=izQmV3nNwX5BH_1gHTD43hQYZdm1HhqKSFeFevsUH8s,2278
+google/type/decimal.proto,sha256=MHwhtJvxLOmTnmlFr7zjUzUMv-GtKWjt8KjI7h8ocSc,4213
+google/type/decimal_pb2.py,sha256=o3ik8jpNxmHKIQFTt3jQ0yolx7hg6FHhcZBqj9O6bRw,2132
+google/type/expr.proto,sha256=h01oPawn_bZZuE8tazwwU4A2dHd27gDTyp89xO2NbV0,2730
+google/type/expr_pb2.py,sha256=e45VfWwvvEAeJkcZOnLLd-QiuJadyC9isZh4PuL8lDw,2153
+google/type/fraction.proto,sha256=v_UMj40abInG6gzw386a9poFH3R1qs1NL7LZCWHfmIs,1156
+google/type/fraction_pb2.py,sha256=AXyzZFbgOpNsWApJ9gETgtZH6-gbWG7XxIjL-zSBQZU,2166
+google/type/interval.proto,sha256=aL9e8GY36gd30t-e4cDPOVMoGb4t_zXhtx-3vGPa_So,1667
+google/type/interval_pb2.py,sha256=1YWhrG1aII6vPMZO2C9PBLIkbLugFgmXCAAdqiedAvo,2364
+google/type/latlng.proto,sha256=p2KWOD4xxxfxeajCt-yigHRhH0uBmejeAZv_qwFXTV8,1447
+google/type/latlng_pb2.py,sha256=JjEHmRlkz4mtNwjkH2uJ265GHb2zCGn7-P_l1uv-AE0,2144
+google/type/localized_text.proto,sha256=nSlltBLvrTIYY-mF04BFlrqybqtvnUFS6_DqD6SOgbw,1303
+google/type/localized_text_pb2.py,sha256=1PoTaA6FpVLEMdvUnu9Yy2kYpiH3WKP_IW0whK3aWuc,2270
+google/type/money.proto,sha256=c-E8J98shWtC68tlqUWcS_xZ3Z4JzEjhp2W74GufpAY,1603
+google/type/money_pb2.py,sha256=xhpDpw13jLt_pim5l7r6Jx-QHd1TvRQgj1gSyQHTOzA,2151
+google/type/month.proto,sha256=76TvqQEdADPekbSnpQxBJ1P_xBr8o-BI_qG3ByHJIfI,1479
+google/type/month_pb2.py,sha256=nSmTfRZiOGe2NHr5zeUm3bNiGFEW0RAKk-sw1QtIGt8,2398
+google/type/phone_number.proto,sha256=V_GJma9FFGht1pEkCzMG9IL4nd-KQZQWT574PzsGudI,4744
+google/type/phone_number_pb2.py,sha256=phMqj3ouEDRmYoxNZSC9aBzL0M_Ej_-EU9OujIZGm5c,3046
+google/type/postal_address.proto,sha256=_R41zeaO1PcGqfEU4gHlFzUubKJ2SERzxhnvJxTIID0,6235
+google/type/postal_address_pb2.py,sha256=_akaf6XBB_6o8EsS2Lw1BIeJdwEL8rLvvO8_0NMpcrE,2654
+google/type/quaternion.proto,sha256=KfoTNWnwo2LypdBv8rMPHB5pf_kdcI5QPiLXrucdOpw,3791
+google/type/quaternion_pb2.py,sha256=iO651jhNnTaHqcQQkFmIjh0510o3q2RNF5s4Q5Teeps,2261
+google/type/timeofday.proto,sha256=7zMEkJWeYteVVcz3SpM686GFL66hX-aguaqIKZwJv2M,1667
+google/type/timeofday_pb2.py,sha256=mHFQIkY9h2QWrvHFa2AWc6uzco-nF3LoVCcVnjt8XRQ,2266
+googleapis_common_protos-1.63.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+googleapis_common_protos-1.63.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+googleapis_common_protos-1.63.0.dist-info/METADATA,sha256=WfOVf7h9x3whA4t1pcvDun4qvPHNt_OdCF0UbWr46Ig,1532
+googleapis_common_protos-1.63.0.dist-info/RECORD,,
+googleapis_common_protos-1.63.0.dist-info/WHEEL,sha256=P2T-6epvtXQ2cBOE_U1K4_noqlJFN3tj15djMgEu4NM,110
+googleapis_common_protos-1.63.0.dist-info/top_level.txt,sha256=_1QvSJIhFAGfxb79D6DhB7SUw2X6T4rwnz_LLrbcD3c,7
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/WHEEL b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..f31e450fda2866f274547bb723d784248069898a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.3)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/top_level.txt b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cb429113e0f9a73019fd799e8052093fea7f0c8b
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/googleapis_common_protos-1.63.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+google
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/AUTHORS b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/AUTHORS
new file mode 100644
index 0000000000000000000000000000000000000000..42a5c227b4401333cd40db283d06c4471786afd8
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/AUTHORS
@@ -0,0 +1,51 @@
+Original Authors
+----------------
+* Armin Rigo
+* Christian Tismer
+
+Contributors
+------------
+* Al Stone
+* Alexander Schmidt
+* Alexey Borzenkov
+* Andreas Schwab
+* Armin Ronacher
+* Bin Wang
+* Bob Ippolito
+* ChangBo Guo
+* Christoph Gohlke
+* Denis Bilenko
+* Dirk Mueller
+* Donovan Preston
+* Fantix King
+* Floris Bruynooghe
+* Fredrik Fornwall
+* Gerd Woetzel
+* Giel van Schijndel
+* Gökhan Karabulut
+* Gustavo Niemeyer
+* Guy Rozendorn
+* Hye-Shik Chang
+* Jared Kuolt
+* Jason Madden
+* Josh Snyder
+* Kyle Ambroff
+* Laszlo Boszormenyi
+* Mao Han
+* Marc Abramowitz
+* Marc Schlaich
+* Marcin Bachry
+* Matt Madison
+* Matt Turner
+* Michael Ellerman
+* Michael Matz
+* Ralf Schmitt
+* Robie Basak
+* Ronny Pfannschmidt
+* Samual M. Rushing
+* Tony Bowles
+* Tony Breeds
+* Trevor Bowen
+* Tulio Magno Quites Machado Filho
+* Ulrich Weigand
+* Victor Stinner
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/INSTALLER b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/LICENSE b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..b73a4a10c6fa93a3a6fa47deb3796c590a9dee10
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/LICENSE
@@ -0,0 +1,30 @@
+The following files are derived from Stackless Python and are subject to the
+same license as Stackless Python:
+
+ src/greenlet/slp_platformselect.h
+ files in src/greenlet/platform/ directory
+
+See LICENSE.PSF and http://www.stackless.com/ for details.
+
+Unless otherwise noted, the files in greenlet have been released under the
+following MIT license:
+
+Copyright (c) Armin Rigo, Christian Tismer and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/LICENSE.PSF b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/LICENSE.PSF
new file mode 100644
index 0000000000000000000000000000000000000000..d3b509a2b4119c47ad86af9fc1b400ce2eb09cf1
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/LICENSE.PSF
@@ -0,0 +1,47 @@
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011 Python Software Foundation; All Rights Reserved" are retained in Python
+alone or in any derivative version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee. This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/METADATA b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..0298776deb829ab0a9e5ac04650a541f05c8ac04
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/METADATA
@@ -0,0 +1,102 @@
+Metadata-Version: 2.1
+Name: greenlet
+Version: 3.0.3
+Summary: Lightweight in-process concurrent programming
+Home-page: https://greenlet.readthedocs.io/
+Author: Alexey Borzenkov
+Author-email: snaury@gmail.com
+Maintainer: Jason Madden
+Maintainer-email: jason@seecoresoftware.com
+License: MIT License
+Project-URL: Bug Tracker, https://github.com/python-greenlet/greenlet/issues
+Project-URL: Source Code, https://github.com/python-greenlet/greenlet/
+Project-URL: Documentation, https://greenlet.readthedocs.io/
+Keywords: greenlet coroutine concurrency threads cooperative
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: LICENSE.PSF
+License-File: AUTHORS
+Provides-Extra: docs
+Requires-Dist: Sphinx ; extra == 'docs'
+Requires-Dist: furo ; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: objgraph ; extra == 'test'
+Requires-Dist: psutil ; extra == 'test'
+
+.. This file is included into docs/history.rst
+
+
+Greenlets are lightweight coroutines for in-process concurrent
+programming.
+
+The "greenlet" package is a spin-off of `Stackless`_, a version of
+CPython that supports micro-threads called "tasklets". Tasklets run
+pseudo-concurrently (typically in a single or a few OS-level threads)
+and are synchronized with data exchanges on "channels".
+
+A "greenlet", on the other hand, is a still more primitive notion of
+micro-thread with no implicit scheduling; coroutines, in other words.
+This is useful when you want to control exactly when your code runs.
+You can build custom scheduled micro-threads on top of greenlet;
+however, it seems that greenlets are useful on their own as a way to
+make advanced control flow structures. For example, we can recreate
+generators; the difference with Python's own generators is that our
+generators can call nested functions and the nested functions can
+yield values too. (Additionally, you don't need a "yield" keyword. See
+the example in `test_generator.py
+`_).
+
+Greenlets are provided as a C extension module for the regular unmodified
+interpreter.
+
+.. _`Stackless`: http://www.stackless.com
+
+
+Who is using Greenlet?
+======================
+
+There are several libraries that use Greenlet as a more flexible
+alternative to Python's built in coroutine support:
+
+ - `Concurrence`_
+ - `Eventlet`_
+ - `Gevent`_
+
+.. _Concurrence: http://opensource.hyves.org/concurrence/
+.. _Eventlet: http://eventlet.net/
+.. _Gevent: http://www.gevent.org/
+
+Getting Greenlet
+================
+
+The easiest way to get Greenlet is to install it with pip::
+
+ pip install greenlet
+
+
+Source code archives and binary distributions are available on the
+python package index at https://pypi.org/project/greenlet
+
+The source code repository is hosted on github:
+https://github.com/python-greenlet/greenlet
+
+Documentation is available on readthedocs.org:
+https://greenlet.readthedocs.io
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/RECORD b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..d6a23c75139ed70e6bcc5cbd992cd2837f209aee
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/RECORD
@@ -0,0 +1,116 @@
+../../include/site/python3.11/greenlet/greenlet.h,sha256=sz5pYRSQqedgOt2AMgxLZdTjO-qcr_JMvgiEJR9IAJ8,4755
+greenlet-3.0.3.dist-info/AUTHORS,sha256=swW28t2knVRxRkaEQNZtO7MP9Sgnompb7B6cNgJM8Gk,849
+greenlet-3.0.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+greenlet-3.0.3.dist-info/LICENSE,sha256=dpgx1uXfrywggC-sz_H6-0wgJd2PYlPfpH_K1Z1NCXk,1434
+greenlet-3.0.3.dist-info/LICENSE.PSF,sha256=5f88I8EQ5JTNfXNsEP2W1GJFe6_soxCEDbZScpjH1Gs,2424
+greenlet-3.0.3.dist-info/METADATA,sha256=LjLm176aHpnFw1eMigcZGdnc0OgCO7LKPy21O4WhAp0,3881
+greenlet-3.0.3.dist-info/RECORD,,
+greenlet-3.0.3.dist-info/WHEEL,sha256=ircjsfhzblqgSzO8ow7-0pXK-RVqDqNRGQ8F650AUNM,102
+greenlet-3.0.3.dist-info/top_level.txt,sha256=YSnRsCRoO61JGlP57o8iKL6rdLWDWuiyKD8ekpWUsDc,9
+greenlet/TBrokenGreenlet.cpp,sha256=YgKaHkQV6_dKBrgS0HKDSqZroskv0IwSZDo4bsiwz3w,1029
+greenlet/TExceptionState.cpp,sha256=Ctg2YfyEYNjOYbteRB_oIJa9lNGyC7N1F3h4XqqQdg8,1367
+greenlet/TGreenlet.cpp,sha256=1xwAzGNqO68AZ4D5lD5DHmGPBohM6nv4BYnLatgIL68,25637
+greenlet/TGreenletGlobals.cpp,sha256=qLi1icS1UDSbefTkolz9TycEi_GOUblsEznMp0HFywQ,3268
+greenlet/TMainGreenlet.cpp,sha256=FvWtGJDKb64DLy0n-ddcTF6xJDwczPMKSm9mXSsHJKg,3365
+greenlet/TPythonState.cpp,sha256=QUoIQzF0HYmAJO_nwX5gXSSlMNL1mkxlN24KJCXIrIQ,14861
+greenlet/TStackState.cpp,sha256=VclDR-qiMeJjuiJxL9_u24MJiTgdSaYvr8bWQdTEZjY,7389
+greenlet/TThreadStateDestroy.cpp,sha256=EqZ-GjksrWNC20CY_P0yXN43wVRMYEh659SmRRqBaI4,7214
+greenlet/TUserGreenlet.cpp,sha256=b_Bmh4WZdS6I1yM2AfHRtd535WovtpYMkpfu2GQpaDs,23618
+greenlet/__init__.py,sha256=Dw4tovn18bpPaWQ4SK7jDJe24uV4ao264UfaT0uufxU,1723
+greenlet/__pycache__/__init__.cpython-311.pyc,,
+greenlet/_greenlet.cp311-win_amd64.pyd,sha256=x467oRjf1xR9J7Qa4d6TI1yBtNeDNy4hkb2oivDMPBY,220160
+greenlet/greenlet.cpp,sha256=k9RZolayY79WgjPXwcA3Vcv48MuW7TAtogIZPaDD3gM,48815
+greenlet/greenlet.h,sha256=sz5pYRSQqedgOt2AMgxLZdTjO-qcr_JMvgiEJR9IAJ8,4755
+greenlet/greenlet_allocator.hpp,sha256=kxyWW4Qdwlrc7ufgdb5vd6Y7jhauQ699Kod0mqiO1iM,1582
+greenlet/greenlet_compiler_compat.hpp,sha256=m7wvwrZqBoCQpDMTP-Z7whdXIES7e3AuXBgvPHSsfxg,4140
+greenlet/greenlet_cpython_add_pending.hpp,sha256=apAwIhGlgYrnYn03zWL6Sxy68kltDeb1e0QupZfb3DQ,6043
+greenlet/greenlet_cpython_compat.hpp,sha256=ZpN8gewZeOtd6T-mLidA7zteQ_P4vG8T1za_KPvCijg,3621
+greenlet/greenlet_exceptions.hpp,sha256=Dt8YdaQn8AK9nBfwU9rrDoMlR2Lw5aLTQV6ZAsHmfsw,3683
+greenlet/greenlet_greenlet.hpp,sha256=Ct_EAx4OJL6FvF5g3jV1ybSxnqzLVaRdPi2EcYT1iq4,27728
+greenlet/greenlet_internal.hpp,sha256=ZXH5zemWCN8wH8zAqMUGycvz_3IulRL6Gf2hZA6CknE,2703
+greenlet/greenlet_refs.hpp,sha256=ECkHKV1CVamtzmWWGKXXMpw8lXLeIzastXM9tfqlsNI,33864
+greenlet/greenlet_slp_switch.hpp,sha256=kM1QHA2iV-gH4cFyN6lfIagHQxvJZjWOVJdIxRE3TlQ,3198
+greenlet/greenlet_thread_state.hpp,sha256=0UwJCNd86ifwM2yDd3QrNmHAECL-eNADHubwiB_XGA4,20614
+greenlet/greenlet_thread_state_dict_cleanup.hpp,sha256=tEN0rI1pZiEsdtr7Oda24gr52fGiHnYTLyM8Vme3Gns,3831
+greenlet/greenlet_thread_support.hpp,sha256=XUJ6ljWjf9OYyuOILiz8e_yHvT3fbaUiHdhiPNQUV4s,867
+greenlet/platform/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+greenlet/platform/__pycache__/__init__.cpython-311.pyc,,
+greenlet/platform/setup_switch_x64_masm.cmd,sha256=ZpClUJeU0ujEPSTWNSepP0W2f9XiYQKA8QKSoVou8EU,143
+greenlet/platform/switch_aarch64_gcc.h,sha256=GKC0yWNXnbK2X--X6aguRCMj2Tg7hDU1Zkl3RljDvC8,4307
+greenlet/platform/switch_alpha_unix.h,sha256=Z-SvF8JQV3oxWT8JRbL9RFu4gRFxPdJ7cviM8YayMmw,671
+greenlet/platform/switch_amd64_unix.h,sha256=EcSFCBlodEBhqhKjcJqY_5Dn_jn7pKpkJlOvp7gFXLI,2748
+greenlet/platform/switch_arm32_gcc.h,sha256=Z3KkHszdgq6uU4YN3BxvKMG2AdDnovwCCNrqGWZ1Lyo,2479
+greenlet/platform/switch_arm32_ios.h,sha256=mm5_R9aXB92hyxzFRwB71M60H6AlvHjrpTrc72Pz3l8,1892
+greenlet/platform/switch_arm64_masm.asm,sha256=4kpTtfy7rfcr8j1CpJLAK21EtZpGDAJXWRU68HEy5A8,1245
+greenlet/platform/switch_arm64_masm.obj,sha256=DmLnIB_icoEHAz1naue_pJPTZgR9ElM7-Nmztr-o9_U,746
+greenlet/platform/switch_arm64_msvc.h,sha256=RqK5MHLmXI3Q-FQ7tm32KWnbDNZKnkJdq8CR89cz640,398
+greenlet/platform/switch_csky_gcc.h,sha256=kDikyiPpewP71KoBZQO_MukDTXTXBiC7x-hF0_2DL0w,1331
+greenlet/platform/switch_loongarch64_linux.h,sha256=7M-Dhc4Q8tRbJCJhalDLwU6S9Mx8MjmN1RbTDgIvQTM,779
+greenlet/platform/switch_m68k_gcc.h,sha256=VSa6NpZhvyyvF-Q58CTIWSpEDo4FKygOyTz00whctlw,928
+greenlet/platform/switch_mips_unix.h,sha256=E0tYsqc5anDY1BhenU1l8DW-nVHC_BElzLgJw3TGtPk,1426
+greenlet/platform/switch_ppc64_aix.h,sha256=_BL0iyRr3ZA5iPlr3uk9SJ5sNRWGYLrXcZ5z-CE9anE,3860
+greenlet/platform/switch_ppc64_linux.h,sha256=0rriT5XyxPb0GqsSSn_bP9iQsnjsPbBmu0yqo5goSyQ,3815
+greenlet/platform/switch_ppc_aix.h,sha256=pHA4slEjUFP3J3SYm1TAlNPhgb2G_PAtax5cO8BEe1A,2941
+greenlet/platform/switch_ppc_linux.h,sha256=YwrlKUzxlXuiKMQqr6MFAV1bPzWnmvk6X1AqJZEpOWU,2759
+greenlet/platform/switch_ppc_macosx.h,sha256=L8sB0c00V4G2_5cQCG3zX-23DKq3le_Dcj0sUDcACos,2624
+greenlet/platform/switch_ppc_unix.h,sha256=POy4bRBcH74Chfw4viFE9bVlZ-7BaNsFC0NnXr1L2tg,2652
+greenlet/platform/switch_riscv_unix.h,sha256=jX3vC_xZXiUho8tz4J6Ai8BNQB80yLn03fxkoMztVCU,740
+greenlet/platform/switch_s390_unix.h,sha256=RRlGu957ybmq95qNNY4Qw1mcaoT3eBnW5KbVwu48KX8,2763
+greenlet/platform/switch_sparc_sun_gcc.h,sha256=xZish9GsMHBienUbUMsX1-ZZ-as7hs36sVhYIE3ew8Y,2797
+greenlet/platform/switch_x32_unix.h,sha256=nM98PKtzTWc1lcM7TRMUZJzskVdR1C69U1UqZRWX0GE,1509
+greenlet/platform/switch_x64_masm.asm,sha256=nu6n2sWyXuXfpPx40d9YmLfHXUc1sHgeTvX1kUzuvEM,1841
+greenlet/platform/switch_x64_masm.obj,sha256=GNtTNxYdo7idFUYsQv-mrXWgyT5EJ93-9q90lN6svtQ,1078
+greenlet/platform/switch_x64_msvc.h,sha256=LIeasyKo_vHzspdMzMHbosRhrBfKI4BkQOh4qcTHyJw,1805
+greenlet/platform/switch_x86_msvc.h,sha256=TtGOwinbFfnn6clxMNkCz8i6OmgB6kVRrShoF5iT9to,12838
+greenlet/platform/switch_x86_unix.h,sha256=VplW9H0FF0cZHw1DhJdIUs5q6YLS4cwb2nYwjF83R1s,3059
+greenlet/slp_platformselect.h,sha256=JEnia_2HsTwdqvnnEsDxHQqalYvFJqx_CDsqvNUQYe8,3600
+greenlet/tests/__init__.py,sha256=F282jaIavKrhsYgHJEXtIQXKHdHpe9OJOPTK7R40JzI,9022
+greenlet/tests/__pycache__/__init__.cpython-311.pyc,,
+greenlet/tests/__pycache__/fail_clearing_run_switches.cpython-311.pyc,,
+greenlet/tests/__pycache__/fail_cpp_exception.cpython-311.pyc,,
+greenlet/tests/__pycache__/fail_initialstub_already_started.cpython-311.pyc,,
+greenlet/tests/__pycache__/fail_slp_switch.cpython-311.pyc,,
+greenlet/tests/__pycache__/fail_switch_three_greenlets.cpython-311.pyc,,
+greenlet/tests/__pycache__/fail_switch_three_greenlets2.cpython-311.pyc,,
+greenlet/tests/__pycache__/fail_switch_two_greenlets.cpython-311.pyc,,
+greenlet/tests/__pycache__/leakcheck.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_contextvars.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_cpp.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_extension_interface.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_gc.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_generator.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_generator_nested.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_greenlet.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_greenlet_trash.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_leaks.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_stack_saved.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_throw.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_tracing.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_version.cpython-311.pyc,,
+greenlet/tests/__pycache__/test_weakref.cpython-311.pyc,,
+greenlet/tests/_test_extension.c,sha256=vkeGA-6oeJcGILsD7oIrT1qZop2GaTOHXiNT7mcSl-0,5773
+greenlet/tests/_test_extension.cp311-win_amd64.pyd,sha256=DpTTzao8NjCJi7uCB_EKKJ0mNFVu80Y__OG7P_8rFtg,13824
+greenlet/tests/_test_extension_cpp.cp311-win_amd64.pyd,sha256=TXzaiHa7HiEzHpWLHz5PRkZojVfMgFjaH1eTfI1WAis,15872
+greenlet/tests/_test_extension_cpp.cpp,sha256=e0kVnaB8CCaEhE9yHtNyfqTjevsPDKKx-zgxk7PPK48,6565
+greenlet/tests/fail_clearing_run_switches.py,sha256=o433oA_nUCtOPaMEGc8VEhZIKa71imVHXFw7TsXaP8M,1263
+greenlet/tests/fail_cpp_exception.py,sha256=o_ZbipWikok8Bjc-vjiQvcb5FHh2nVW-McGKMLcMzh0,985
+greenlet/tests/fail_initialstub_already_started.py,sha256=txENn5IyzGx2p-XR1XB7qXmC8JX_4mKDEA8kYBXUQKc,1961
+greenlet/tests/fail_slp_switch.py,sha256=rJBZcZfTWR3e2ERQtPAud6YKShiDsP84PmwOJbp4ey0,524
+greenlet/tests/fail_switch_three_greenlets.py,sha256=zSitV7rkNnaoHYVzAGGLnxz-yPtohXJJzaE8ehFDQ0M,956
+greenlet/tests/fail_switch_three_greenlets2.py,sha256=FPJensn2EJxoropl03JSTVP3kgP33k04h6aDWWozrOk,1285
+greenlet/tests/fail_switch_two_greenlets.py,sha256=1CaI8s3504VbbF1vj1uBYuy-zxBHVzHPIAd1LIc8ONg,817
+greenlet/tests/leakcheck.py,sha256=inbfM7_oVzd8jIKGxCgo4JqpFZaDAnWPkSULJ8vIE1s,11964
+greenlet/tests/test_contextvars.py,sha256=0n5pR_lbpAppc5wFfK0e1SwYLM-fsSFp72B5_ArLPGE,10348
+greenlet/tests/test_cpp.py,sha256=hpxhFAdKJTpAVZP8CBGs1ZcrKdscI9BaDZk4btkI5d4,2736
+greenlet/tests/test_extension_interface.py,sha256=eJ3cwLacdK2WbsrC-4DgeyHdwLRcG4zx7rrkRtqSzC4,3829
+greenlet/tests/test_gc.py,sha256=PCOaRpIyjNnNlDogGL3FZU_lrdXuM-pv1rxeE5TP5mc,2923
+greenlet/tests/test_generator.py,sha256=tONXiTf98VGm347o1b-810daPiwdla5cbpFg6QI1R1g,1240
+greenlet/tests/test_generator_nested.py,sha256=7v4HOYrf1XZP39dk5IUMubdZ8yc3ynwZcqj9GUJyMSA,3718
+greenlet/tests/test_greenlet.py,sha256=95qgDR-xtB0jzEFLirNx7HPUdwHikVMvDdyUoCvyjOo,45354
+greenlet/tests/test_greenlet_trash.py,sha256=P6r-3K4fmXX8foW8BVgthuqVKjicHMDvxfK7Al4x028,7508
+greenlet/tests/test_leaks.py,sha256=wskLqCAvqZ3qTZkam_wXzd-E5zelUjlXS5Ss8KshtZY,17465
+greenlet/tests/test_stack_saved.py,sha256=eyzqNY2VCGuGlxhT_In6TvZ6Okb0AXFZVyBEnK1jDwA,446
+greenlet/tests/test_throw.py,sha256=u2TQ_WvvCd6N6JdXWIxVEcXkKu5fepDlz9dktYdmtng,3712
+greenlet/tests/test_tracing.py,sha256=VlwzMU0C1noospZhuUMyB7MHw200emIvGCN_6G2p2ZU,8250
+greenlet/tests/test_version.py,sha256=O9DpAITsOFgiRcjd4odQ7ejmwx_N9Q1zQENVcbtFHIc,1339
+greenlet/tests/test_weakref.py,sha256=F8M23btEF87bIbpptLNBORosbQqNZGiYeKMqYjWrsak,883
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/WHEEL b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..d60b00472b6db035b28a0470c4bc8f72f5db2de0
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/top_level.txt b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..46725be4fd5ff62893d8def5f9e356d4d096328a
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet-3.0.3.dist-info/top_level.txt
@@ -0,0 +1 @@
+greenlet
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TBrokenGreenlet.cpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TBrokenGreenlet.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..11a3beab8b0db3ccbc493505fb41d3180968dd43
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TBrokenGreenlet.cpp
@@ -0,0 +1,45 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+/**
+ * Implementation of greenlet::UserGreenlet.
+ *
+ * Format with:
+ * clang-format -i --style=file src/greenlet/greenlet.c
+ *
+ *
+ * Fix missing braces with:
+ * clang-tidy src/greenlet/greenlet.c -fix -checks="readability-braces-around-statements"
+*/
+
+#include "greenlet_greenlet.hpp"
+
+namespace greenlet {
+
+void* BrokenGreenlet::operator new(size_t UNUSED(count))
+{
+ return allocator.allocate(1);
+}
+
+
+void BrokenGreenlet::operator delete(void* ptr)
+{
+ return allocator.deallocate(static_cast(ptr),
+ 1);
+}
+
+greenlet::PythonAllocator greenlet::BrokenGreenlet::allocator;
+
+bool
+BrokenGreenlet::force_slp_switch_error() const noexcept
+{
+ return this->_force_slp_switch_error;
+}
+
+UserGreenlet::switchstack_result_t BrokenGreenlet::g_switchstack(void)
+{
+ if (this->_force_switch_error) {
+ return switchstack_result_t(-1);
+ }
+ return UserGreenlet::g_switchstack();
+}
+
+}; //namespace greenlet
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TExceptionState.cpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TExceptionState.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ee6b19177ada3e982f1dab8d1ffde9aad1b30e88
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TExceptionState.cpp
@@ -0,0 +1,62 @@
+#ifndef GREENLET_EXCEPTION_STATE_CPP
+#define GREENLET_EXCEPTION_STATE_CPP
+
+#include
+#include "greenlet_greenlet.hpp"
+
+namespace greenlet {
+
+
+ExceptionState::ExceptionState()
+{
+ this->clear();
+}
+
+void ExceptionState::operator<<(const PyThreadState *const tstate) noexcept
+{
+ this->exc_info = tstate->exc_info;
+ this->exc_state = tstate->exc_state;
+}
+
+void ExceptionState::operator>>(PyThreadState *const tstate) noexcept
+{
+ tstate->exc_state = this->exc_state;
+ tstate->exc_info =
+ this->exc_info ? this->exc_info : &tstate->exc_state;
+ this->clear();
+}
+
+void ExceptionState::clear() noexcept
+{
+ this->exc_info = nullptr;
+ this->exc_state.exc_value = nullptr;
+#if !GREENLET_PY311
+ this->exc_state.exc_type = nullptr;
+ this->exc_state.exc_traceback = nullptr;
+#endif
+ this->exc_state.previous_item = nullptr;
+}
+
+int ExceptionState::tp_traverse(visitproc visit, void* arg) noexcept
+{
+ Py_VISIT(this->exc_state.exc_value);
+#if !GREENLET_PY311
+ Py_VISIT(this->exc_state.exc_type);
+ Py_VISIT(this->exc_state.exc_traceback);
+#endif
+ return 0;
+}
+
+void ExceptionState::tp_clear() noexcept
+{
+ Py_CLEAR(this->exc_state.exc_value);
+#if !GREENLET_PY311
+ Py_CLEAR(this->exc_state.exc_type);
+ Py_CLEAR(this->exc_state.exc_traceback);
+#endif
+}
+
+
+}; // namespace greenlet
+
+#endif // GREENLET_EXCEPTION_STATE_CPP
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TGreenlet.cpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TGreenlet.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..51f899505b9bc76733ec4e55ab650134fa6d3b83
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TGreenlet.cpp
@@ -0,0 +1,714 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+/**
+ * Implementation of greenlet::Greenlet.
+ *
+ * Format with:
+ * clang-format -i --style=file src/greenlet/greenlet.c
+ *
+ *
+ * Fix missing braces with:
+ * clang-tidy src/greenlet/greenlet.c -fix -checks="readability-braces-around-statements"
+*/
+
+#include "greenlet_internal.hpp"
+#include "greenlet_greenlet.hpp"
+#include "greenlet_thread_state.hpp"
+
+#include "TGreenletGlobals.cpp"
+#include "TThreadStateDestroy.cpp"
+
+namespace greenlet {
+
+Greenlet::Greenlet(PyGreenlet* p)
+{
+ p ->pimpl = this;
+}
+
+Greenlet::~Greenlet()
+{
+ // XXX: Can't do this. tp_clear is a virtual function, and by the
+ // time we're here, we've sliced off our child classes.
+ //this->tp_clear();
+}
+
+Greenlet::Greenlet(PyGreenlet* p, const StackState& initial_stack)
+ : stack_state(initial_stack)
+{
+ // can't use a delegating constructor because of
+ // MSVC for Python 2.7
+ p->pimpl = this;
+}
+
+bool
+Greenlet::force_slp_switch_error() const noexcept
+{
+ return false;
+}
+
+void
+Greenlet::release_args()
+{
+ this->switch_args.CLEAR();
+}
+
+/**
+ * CAUTION: This will allocate memory and may trigger garbage
+ * collection and arbitrary Python code.
+ */
+OwnedObject
+Greenlet::throw_GreenletExit_during_dealloc(const ThreadState& UNUSED(current_thread_state))
+{
+ // If we're killed because we lost all references in the
+ // middle of a switch, that's ok. Don't reset the args/kwargs,
+ // we still want to pass them to the parent.
+ PyErr_SetString(mod_globs->PyExc_GreenletExit,
+ "Killing the greenlet because all references have vanished.");
+ // To get here it had to have run before
+ return this->g_switch();
+}
+
+inline void
+Greenlet::slp_restore_state() noexcept
+{
+#ifdef SLP_BEFORE_RESTORE_STATE
+ SLP_BEFORE_RESTORE_STATE();
+#endif
+ this->stack_state.copy_heap_to_stack(
+ this->thread_state()->borrow_current()->stack_state);
+}
+
+
+inline int
+Greenlet::slp_save_state(char *const stackref) noexcept
+{
+ // XXX: This used to happen in the middle, before saving, but
+ // after finding the next owner. Does that matter? This is
+ // only defined for Sparc/GCC where it flushes register
+ // windows to the stack (I think)
+#ifdef SLP_BEFORE_SAVE_STATE
+ SLP_BEFORE_SAVE_STATE();
+#endif
+ return this->stack_state.copy_stack_to_heap(stackref,
+ this->thread_state()->borrow_current()->stack_state);
+}
+
+/**
+ * CAUTION: This will allocate memory and may trigger garbage
+ * collection and arbitrary Python code.
+ */
+OwnedObject
+Greenlet::on_switchstack_or_initialstub_failure(
+ Greenlet* target,
+ const Greenlet::switchstack_result_t& err,
+ const bool target_was_me,
+ const bool was_initial_stub)
+{
+ // If we get here, either g_initialstub()
+ // failed, or g_switchstack() failed. Either one of those
+ // cases SHOULD leave us in the original greenlet with a valid stack.
+ if (!PyErr_Occurred()) {
+ PyErr_SetString(
+ PyExc_SystemError,
+ was_initial_stub
+ ? "Failed to switch stacks into a greenlet for the first time."
+ : "Failed to switch stacks into a running greenlet.");
+ }
+ this->release_args();
+
+ if (target && !target_was_me) {
+ target->murder_in_place();
+ }
+
+ assert(!err.the_new_current_greenlet);
+ assert(!err.origin_greenlet);
+ return OwnedObject();
+
+}
+
+OwnedGreenlet
+Greenlet::g_switchstack_success() noexcept
+{
+ PyThreadState* tstate = PyThreadState_GET();
+ // restore the saved state
+ this->python_state >> tstate;
+ this->exception_state >> tstate;
+
+ // The thread state hasn't been changed yet.
+ ThreadState* thread_state = this->thread_state();
+ OwnedGreenlet result(thread_state->get_current());
+ thread_state->set_current(this->self());
+ //assert(thread_state->borrow_current().borrow() == this->_self);
+ return result;
+}
+
+Greenlet::switchstack_result_t
+Greenlet::g_switchstack(void)
+{
+ // if any of these assertions fail, it's likely because we
+ // switched away and tried to switch back to us. Early stages of
+ // switching are not reentrant because we re-use ``this->args()``.
+ // Switching away would happen if we trigger a garbage collection
+ // (by just using some Python APIs that happen to allocate Python
+ // objects) and some garbage had weakref callbacks or __del__ that
+ // switches (people don't write code like that by hand, but with
+ // gevent it's possible without realizing it)
+ assert(this->args() || PyErr_Occurred());
+ { /* save state */
+ if (this->thread_state()->is_current(this->self())) {
+ // Hmm, nothing to do.
+ // TODO: Does this bypass trace events that are
+ // important?
+ return switchstack_result_t(0,
+ this, this->thread_state()->borrow_current());
+ }
+ BorrowedGreenlet current = this->thread_state()->borrow_current();
+ PyThreadState* tstate = PyThreadState_GET();
+
+ current->python_state << tstate;
+ current->exception_state << tstate;
+ this->python_state.will_switch_from(tstate);
+ switching_thread_state = this;
+ current->expose_frames();
+ }
+ assert(this->args() || PyErr_Occurred());
+ // If this is the first switch into a greenlet, this will
+ // return twice, once with 1 in the new greenlet, once with 0
+ // in the origin.
+ int err;
+ if (this->force_slp_switch_error()) {
+ err = -1;
+ }
+ else {
+ err = slp_switch();
+ }
+
+ if (err < 0) { /* error */
+ // Tested by
+ // test_greenlet.TestBrokenGreenlets.test_failed_to_slp_switch_into_running
+ //
+ // It's not clear if it's worth trying to clean up and
+ // continue here. Failing to switch stacks is a big deal which
+ // may not be recoverable (who knows what state the stack is in).
+ // Also, we've stolen references in preparation for calling
+ // ``g_switchstack_success()`` and we don't have a clean
+ // mechanism for backing that all out.
+ Py_FatalError("greenlet: Failed low-level slp_switch(). The stack is probably corrupt.");
+ }
+
+ // No stack-based variables are valid anymore.
+
+ // But the global is volatile so we can reload it without the
+ // compiler caching it from earlier.
+ Greenlet* greenlet_that_switched_in = switching_thread_state; // aka this
+ switching_thread_state = nullptr;
+ // except that no stack variables are valid, we would:
+ // assert(this == greenlet_that_switched_in);
+
+ // switchstack success is where we restore the exception state,
+ // etc. It returns the origin greenlet because its convenient.
+
+ OwnedGreenlet origin = greenlet_that_switched_in->g_switchstack_success();
+ assert(greenlet_that_switched_in->args() || PyErr_Occurred());
+ return switchstack_result_t(err, greenlet_that_switched_in, origin);
+}
+
+
+inline void
+Greenlet::check_switch_allowed() const
+{
+ // TODO: Make this take a parameter of the current greenlet,
+ // or current main greenlet, to make the check for
+ // cross-thread switching cheaper. Surely somewhere up the
+ // call stack we've already accessed the thread local variable.
+
+ // We expect to always have a main greenlet now; accessing the thread state
+ // created it. However, if we get here and cleanup has already
+ // begun because we're a greenlet that was running in a
+ // (now dead) thread, these invariants will not hold true. In
+ // fact, accessing `this->thread_state` may not even be possible.
+
+ // If the thread this greenlet was running in is dead,
+ // we'll still have a reference to a main greenlet, but the
+ // thread state pointer we have is bogus.
+ // TODO: Give the objects an API to determine if they belong
+ // to a dead thread.
+
+ const BorrowedMainGreenlet main_greenlet = this->find_main_greenlet_in_lineage();
+
+ if (!main_greenlet) {
+ throw PyErrOccurred(mod_globs->PyExc_GreenletError,
+ "cannot switch to a garbage collected greenlet");
+ }
+
+ if (!main_greenlet->thread_state()) {
+ throw PyErrOccurred(mod_globs->PyExc_GreenletError,
+ "cannot switch to a different thread (which happens to have exited)");
+ }
+
+ // The main greenlet we found was from the .parent lineage.
+ // That may or may not have any relationship to the main
+ // greenlet of the running thread. We can't actually access
+ // our this->thread_state members to try to check that,
+ // because it could be in the process of getting destroyed,
+ // but setting the main_greenlet->thread_state member to NULL
+ // may not be visible yet. So we need to check against the
+ // current thread state (once the cheaper checks are out of
+ // the way)
+ const BorrowedMainGreenlet current_main_greenlet = GET_THREAD_STATE().state().borrow_main_greenlet();
+ if (
+ // lineage main greenlet is not this thread's greenlet
+ current_main_greenlet != main_greenlet
+ || (
+ // atteched to some thread
+ this->main_greenlet()
+ // XXX: Same condition as above. Was this supposed to be
+ // this->main_greenlet()?
+ && current_main_greenlet != main_greenlet)
+ // switching into a known dead thread (XXX: which, if we get here,
+ // is bad, because we just accessed the thread state, which is
+ // gone!)
+ || (!current_main_greenlet->thread_state())) {
+ // CAUTION: This may trigger memory allocations, gc, and
+ // arbitrary Python code.
+ throw PyErrOccurred(mod_globs->PyExc_GreenletError,
+ "cannot switch to a different thread");
+ }
+}
+
+const OwnedObject
+Greenlet::context() const
+{
+ using greenlet::PythonStateContext;
+ OwnedObject result;
+
+ if (this->is_currently_running_in_some_thread()) {
+ /* Currently running greenlet: context is stored in the thread state,
+ not the greenlet object. */
+ if (GET_THREAD_STATE().state().is_current(this->self())) {
+ result = PythonStateContext::context(PyThreadState_GET());
+ }
+ else {
+ throw ValueError(
+ "cannot get context of a "
+ "greenlet that is running in a different thread");
+ }
+ }
+ else {
+ /* Greenlet is not running: just return context. */
+ result = this->python_state.context();
+ }
+ if (!result) {
+ result = OwnedObject::None();
+ }
+ return result;
+}
+
+
+void
+Greenlet::context(BorrowedObject given)
+{
+ using greenlet::PythonStateContext;
+ if (!given) {
+ throw AttributeError("can't delete context attribute");
+ }
+ if (given.is_None()) {
+ /* "Empty context" is stored as NULL, not None. */
+ given = nullptr;
+ }
+
+ //checks type, incrs refcnt
+ greenlet::refs::OwnedContext context(given);
+ PyThreadState* tstate = PyThreadState_GET();
+
+ if (this->is_currently_running_in_some_thread()) {
+ if (!GET_THREAD_STATE().state().is_current(this->self())) {
+ throw ValueError("cannot set context of a greenlet"
+ " that is running in a different thread");
+ }
+
+ /* Currently running greenlet: context is stored in the thread state,
+ not the greenlet object. */
+ OwnedObject octx = OwnedObject::consuming(PythonStateContext::context(tstate));
+ PythonStateContext::context(tstate, context.relinquish_ownership());
+ }
+ else {
+ /* Greenlet is not running: just set context. Note that the
+ greenlet may be dead.*/
+ this->python_state.context() = context;
+ }
+}
+
+/**
+ * CAUTION: May invoke arbitrary Python code.
+ *
+ * Figure out what the result of ``greenlet.switch(arg, kwargs)``
+ * should be and transfers ownership of it to the left-hand-side.
+ *
+ * If switch() was just passed an arg tuple, then we'll just return that.
+ * If only keyword arguments were passed, then we'll pass the keyword
+ * argument dict. Otherwise, we'll create a tuple of (args, kwargs) and
+ * return both.
+ *
+ * CAUTION: This may allocate a new tuple object, which may
+ * cause the Python garbage collector to run, which in turn may
+ * run arbitrary Python code that switches.
+ */
+OwnedObject& operator<<=(OwnedObject& lhs, greenlet::SwitchingArgs& rhs) noexcept
+{
+ // Because this may invoke arbitrary Python code, which could
+ // result in switching back to us, we need to get the
+ // arguments locally on the stack.
+ assert(rhs);
+ OwnedObject args = rhs.args();
+ OwnedObject kwargs = rhs.kwargs();
+ rhs.CLEAR();
+ // We shouldn't be called twice for the same switch.
+ assert(args || kwargs);
+ assert(!rhs);
+
+ if (!kwargs) {
+ lhs = args;
+ }
+ else if (!PyDict_Size(kwargs.borrow())) {
+ lhs = args;
+ }
+ else if (!PySequence_Length(args.borrow())) {
+ lhs = kwargs;
+ }
+ else {
+ // PyTuple_Pack allocates memory, may GC, may run arbitrary
+ // Python code.
+ lhs = OwnedObject::consuming(PyTuple_Pack(2, args.borrow(), kwargs.borrow()));
+ }
+ return lhs;
+}
+
+static OwnedObject
+g_handle_exit(const OwnedObject& greenlet_result)
+{
+ if (!greenlet_result && mod_globs->PyExc_GreenletExit.PyExceptionMatches()) {
+ /* catch and ignore GreenletExit */
+ PyErrFetchParam val;
+ PyErr_Fetch(PyErrFetchParam(), val, PyErrFetchParam());
+ if (!val) {
+ return OwnedObject::None();
+ }
+ return OwnedObject(val);
+ }
+
+ if (greenlet_result) {
+ // package the result into a 1-tuple
+ // PyTuple_Pack increments the reference of its arguments,
+ // so we always need to decref the greenlet result;
+ // the owner will do that.
+ return OwnedObject::consuming(PyTuple_Pack(1, greenlet_result.borrow()));
+ }
+
+ return OwnedObject();
+}
+
+
+
+/**
+ * May run arbitrary Python code.
+ */
+OwnedObject
+Greenlet::g_switch_finish(const switchstack_result_t& err)
+{
+ assert(err.the_new_current_greenlet == this);
+
+ ThreadState& state = *this->thread_state();
+ // Because calling the trace function could do arbitrary things,
+ // including switching away from this greenlet and then maybe
+ // switching back, we need to capture the arguments now so that
+ // they don't change.
+ OwnedObject result;
+ if (this->args()) {
+ result <<= this->args();
+ }
+ else {
+ assert(PyErr_Occurred());
+ }
+ assert(!this->args());
+ try {
+ // Our only caller handles the bad error case
+ assert(err.status >= 0);
+ assert(state.borrow_current() == this->self());
+ if (OwnedObject tracefunc = state.get_tracefunc()) {
+ assert(result || PyErr_Occurred());
+ g_calltrace(tracefunc,
+ result ? mod_globs->event_switch : mod_globs->event_throw,
+ err.origin_greenlet,
+ this->self());
+ }
+ // The above could have invoked arbitrary Python code, but
+ // it couldn't switch back to this object and *also*
+ // throw an exception, so the args won't have changed.
+
+ if (PyErr_Occurred()) {
+ // We get here if we fell of the end of the run() function
+ // raising an exception. The switch itself was
+ // successful, but the function raised.
+ // valgrind reports that memory allocated here can still
+ // be reached after a test run.
+ throw PyErrOccurred::from_current();
+ }
+ return result;
+ }
+ catch (const PyErrOccurred&) {
+ /* Turn switch errors into switch throws */
+ /* Turn trace errors into switch throws */
+ this->release_args();
+ throw;
+ }
+}
+
+void
+Greenlet::g_calltrace(const OwnedObject& tracefunc,
+ const greenlet::refs::ImmortalEventName& event,
+ const BorrowedGreenlet& origin,
+ const BorrowedGreenlet& target)
+{
+ PyErrPieces saved_exc;
+ try {
+ TracingGuard tracing_guard;
+ // TODO: We have saved the active exception (if any) that's
+ // about to be raised. In the 'throw' case, we could provide
+ // the exception to the tracefunction, which seems very helpful.
+ tracing_guard.CallTraceFunction(tracefunc, event, origin, target);
+ }
+ catch (const PyErrOccurred&) {
+ // In case of exceptions trace function is removed,
+ // and any existing exception is replaced with the tracing
+ // exception.
+ GET_THREAD_STATE().state().set_tracefunc(Py_None);
+ throw;
+ }
+
+ saved_exc.PyErrRestore();
+ assert(
+ (event == mod_globs->event_throw && PyErr_Occurred())
+ || (event == mod_globs->event_switch && !PyErr_Occurred())
+ );
+}
+
+void
+Greenlet::murder_in_place()
+{
+ if (this->active()) {
+ assert(!this->is_currently_running_in_some_thread());
+ this->deactivate_and_free();
+ }
+}
+
+inline void
+Greenlet::deactivate_and_free()
+{
+ if (!this->active()) {
+ return;
+ }
+ // Throw away any saved stack.
+ this->stack_state = StackState();
+ assert(!this->stack_state.active());
+ // Throw away any Python references.
+ // We're holding a borrowed reference to the last
+ // frame we executed. Since we borrowed it, the
+ // normal traversal, clear, and dealloc functions
+ // ignore it, meaning it leaks. (The thread state
+ // object can't find it to clear it when that's
+ // deallocated either, because by definition if we
+ // got an object on this list, it wasn't
+ // running and the thread state doesn't have
+ // this frame.)
+ // So here, we *do* clear it.
+ this->python_state.tp_clear(true);
+}
+
+bool
+Greenlet::belongs_to_thread(const ThreadState* thread_state) const
+{
+ if (!this->thread_state() // not running anywhere, or thread
+ // exited
+ || !thread_state) { // same, or there is no thread state.
+ return false;
+ }
+ return true;
+}
+
+
+void
+Greenlet::deallocing_greenlet_in_thread(const ThreadState* current_thread_state)
+{
+ /* Cannot raise an exception to kill the greenlet if
+ it is not running in the same thread! */
+ if (this->belongs_to_thread(current_thread_state)) {
+ assert(current_thread_state);
+ // To get here it had to have run before
+ /* Send the greenlet a GreenletExit exception. */
+
+ // We don't care about the return value, only whether an
+ // exception happened.
+ this->throw_GreenletExit_during_dealloc(*current_thread_state);
+ return;
+ }
+
+ // Not the same thread! Temporarily save the greenlet
+ // into its thread's deleteme list, *if* it exists.
+ // If that thread has already exited, and processed its pending
+ // cleanup, we'll never be able to clean everything up: we won't
+ // be able to raise an exception.
+ // That's mostly OK! Since we can't add it to a list, our refcount
+ // won't increase, and we'll go ahead with the DECREFs later.
+ ThreadState *const thread_state = this->thread_state();
+ if (thread_state) {
+ thread_state->delete_when_thread_running(this->self());
+ }
+ else {
+ // The thread is dead, we can't raise an exception.
+ // We need to make it look non-active, though, so that dealloc
+ // finishes killing it.
+ this->deactivate_and_free();
+ }
+ return;
+}
+
+
+int
+Greenlet::tp_traverse(visitproc visit, void* arg)
+{
+
+ int result;
+ if ((result = this->exception_state.tp_traverse(visit, arg)) != 0) {
+ return result;
+ }
+ //XXX: This is ugly. But so is handling everything having to do
+ //with the top frame.
+ bool visit_top_frame = this->was_running_in_dead_thread();
+ // When true, the thread is dead. Our implicit weak reference to the
+ // frame is now all that's left; we consider ourselves to
+ // strongly own it now.
+ if ((result = this->python_state.tp_traverse(visit, arg, visit_top_frame)) != 0) {
+ return result;
+ }
+ return 0;
+}
+
+int
+Greenlet::tp_clear()
+{
+ bool own_top_frame = this->was_running_in_dead_thread();
+ this->exception_state.tp_clear();
+ this->python_state.tp_clear(own_top_frame);
+ return 0;
+}
+
+bool Greenlet::is_currently_running_in_some_thread() const
+{
+ return this->stack_state.active() && !this->python_state.top_frame();
+}
+
+#if GREENLET_PY312
+void GREENLET_NOINLINE(Greenlet::expose_frames)()
+{
+ if (!this->python_state.top_frame()) {
+ return;
+ }
+
+ _PyInterpreterFrame* last_complete_iframe = nullptr;
+ _PyInterpreterFrame* iframe = this->python_state.top_frame()->f_frame;
+ while (iframe) {
+ // We must make a copy before looking at the iframe contents,
+ // since iframe might point to a portion of the greenlet's C stack
+ // that was spilled when switching greenlets.
+ _PyInterpreterFrame iframe_copy;
+ this->stack_state.copy_from_stack(&iframe_copy, iframe, sizeof(*iframe));
+ if (!_PyFrame_IsIncomplete(&iframe_copy)) {
+ // If the iframe were OWNED_BY_CSTACK then it would always be
+ // incomplete. Since it's not incomplete, it's not on the C stack
+ // and we can access it through the original `iframe` pointer
+ // directly. This is important since GetFrameObject might
+ // lazily _create_ the frame object and we don't want the
+ // interpreter to lose track of it.
+ assert(iframe_copy.owner != FRAME_OWNED_BY_CSTACK);
+
+ // We really want to just write:
+ // PyFrameObject* frame = _PyFrame_GetFrameObject(iframe);
+ // but _PyFrame_GetFrameObject calls _PyFrame_MakeAndSetFrameObject
+ // which is not a visible symbol in libpython. The easiest
+ // way to get a public function to call it is using
+ // PyFrame_GetBack, which is defined as follows:
+ // assert(frame != NULL);
+ // assert(!_PyFrame_IsIncomplete(frame->f_frame));
+ // PyFrameObject *back = frame->f_back;
+ // if (back == NULL) {
+ // _PyInterpreterFrame *prev = frame->f_frame->previous;
+ // prev = _PyFrame_GetFirstComplete(prev);
+ // if (prev) {
+ // back = _PyFrame_GetFrameObject(prev);
+ // }
+ // }
+ // return (PyFrameObject*)Py_XNewRef(back);
+ if (!iframe->frame_obj) {
+ PyFrameObject dummy_frame;
+ _PyInterpreterFrame dummy_iframe;
+ dummy_frame.f_back = nullptr;
+ dummy_frame.f_frame = &dummy_iframe;
+ // force the iframe to be considered complete without
+ // needing to check its code object:
+ dummy_iframe.owner = FRAME_OWNED_BY_GENERATOR;
+ dummy_iframe.previous = iframe;
+ assert(!_PyFrame_IsIncomplete(&dummy_iframe));
+ // Drop the returned reference immediately; the iframe
+ // continues to hold a strong reference
+ Py_XDECREF(PyFrame_GetBack(&dummy_frame));
+ assert(iframe->frame_obj);
+ }
+
+ // This is a complete frame, so make the last one of those we saw
+ // point at it, bypassing any incomplete frames (which may have
+ // been on the C stack) in between the two. We're overwriting
+ // last_complete_iframe->previous and need that to be reversible,
+ // so we store the original previous ptr in the frame object
+ // (which we must have created on a previous iteration through
+ // this loop). The frame object has a bunch of storage that is
+ // only used when its iframe is OWNED_BY_FRAME_OBJECT, which only
+ // occurs when the frame object outlives the frame's execution,
+ // which can't have happened yet because the frame is currently
+ // executing as far as the interpreter is concerned. So, we can
+ // reuse it for our own purposes.
+ assert(iframe->owner == FRAME_OWNED_BY_THREAD
+ || iframe->owner == FRAME_OWNED_BY_GENERATOR);
+ if (last_complete_iframe) {
+ assert(last_complete_iframe->frame_obj);
+ memcpy(&last_complete_iframe->frame_obj->_f_frame_data[0],
+ &last_complete_iframe->previous, sizeof(void *));
+ last_complete_iframe->previous = iframe;
+ }
+ last_complete_iframe = iframe;
+ }
+ // Frames that are OWNED_BY_FRAME_OBJECT are linked via the
+ // frame's f_back while all others are linked via the iframe's
+ // previous ptr. Since all the frames we traverse are running
+ // as far as the interpreter is concerned, we don't have to
+ // worry about the OWNED_BY_FRAME_OBJECT case.
+ iframe = iframe_copy.previous;
+ }
+
+ // Give the outermost complete iframe a null previous pointer to
+ // account for any potential incomplete/C-stack iframes between it
+ // and the actual top-of-stack
+ if (last_complete_iframe) {
+ assert(last_complete_iframe->frame_obj);
+ memcpy(&last_complete_iframe->frame_obj->_f_frame_data[0],
+ &last_complete_iframe->previous, sizeof(void *));
+ last_complete_iframe->previous = nullptr;
+ }
+}
+#else
+void Greenlet::expose_frames()
+{
+
+}
+#endif
+
+}; // namespace greenlet
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TGreenletGlobals.cpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TGreenletGlobals.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c71c963b32385a8c1661add1728f98752a4a6d17
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TGreenletGlobals.cpp
@@ -0,0 +1,94 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+/**
+ * Implementation of GreenletGlobals.
+ *
+ * Format with:
+ * clang-format -i --style=file src/greenlet/greenlet.c
+ *
+ *
+ * Fix missing braces with:
+ * clang-tidy src/greenlet/greenlet.c -fix -checks="readability-braces-around-statements"
+*/
+#ifndef T_GREENLET_GLOBALS
+#define T_GREENLET_GLOBALS
+
+#include "greenlet_refs.hpp"
+#include "greenlet_exceptions.hpp"
+#include "greenlet_thread_support.hpp"
+#include "greenlet_thread_state.hpp"
+
+namespace greenlet {
+
+// This encapsulates what were previously module global "constants"
+// established at init time.
+// This is a step towards Python3 style module state that allows
+// reloading.
+//
+// In an earlier iteration of this code, we used placement new to be
+// able to allocate this object statically still, so that references
+// to its members don't incur an extra pointer indirection.
+// But under some scenarios, that could result in crashes at
+// shutdown because apparently the destructor was getting run twice?
+class GreenletGlobals
+{
+
+public:
+ const greenlet::refs::ImmortalEventName event_switch;
+ const greenlet::refs::ImmortalEventName event_throw;
+ const greenlet::refs::ImmortalException PyExc_GreenletError;
+ const greenlet::refs::ImmortalException PyExc_GreenletExit;
+ const greenlet::refs::ImmortalObject empty_tuple;
+ const greenlet::refs::ImmortalObject empty_dict;
+ const greenlet::refs::ImmortalString str_run;
+ Mutex* const thread_states_to_destroy_lock;
+ greenlet::cleanup_queue_t thread_states_to_destroy;
+
+ GreenletGlobals() :
+ event_switch("switch"),
+ event_throw("throw"),
+ PyExc_GreenletError("greenlet.error"),
+ PyExc_GreenletExit("greenlet.GreenletExit", PyExc_BaseException),
+ empty_tuple(Require(PyTuple_New(0))),
+ empty_dict(Require(PyDict_New())),
+ str_run("run"),
+ thread_states_to_destroy_lock(new Mutex())
+ {}
+
+ ~GreenletGlobals()
+ {
+ // This object is (currently) effectively immortal, and not
+ // just because of those placement new tricks; if we try to
+ // deallocate the static object we allocated, and overwrote,
+ // we would be doing so at C++ teardown time, which is after
+ // the final Python GIL is released, and we can't use the API
+ // then.
+ // (The members will still be destructed, but they also don't
+ // do any deallocation.)
+ }
+
+ void queue_to_destroy(ThreadState* ts) const
+ {
+ // we're currently accessed through a static const object,
+ // implicitly marking our members as const, so code can't just
+ // call push_back (or pop_back) without casting away the
+ // const.
+ //
+ // Do that for callers.
+ greenlet::cleanup_queue_t& q = const_cast(this->thread_states_to_destroy);
+ q.push_back(ts);
+ }
+
+ ThreadState* take_next_to_destroy() const
+ {
+ greenlet::cleanup_queue_t& q = const_cast(this->thread_states_to_destroy);
+ ThreadState* result = q.back();
+ q.pop_back();
+ return result;
+ }
+};
+
+}; // namespace greenlet
+
+static const greenlet::GreenletGlobals* mod_globs;
+
+#endif // T_GREENLET_GLOBALS
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TMainGreenlet.cpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TMainGreenlet.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c33aadb3a71c5b1e3af4b12b4ed13bc1af3272a0
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TMainGreenlet.cpp
@@ -0,0 +1,155 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+/**
+ * Implementation of greenlet::MainGreenlet.
+ *
+ * Format with:
+ * clang-format -i --style=file src/greenlet/greenlet.c
+ *
+ *
+ * Fix missing braces with:
+ * clang-tidy src/greenlet/greenlet.c -fix -checks="readability-braces-around-statements"
+*/
+
+#include "greenlet_greenlet.hpp"
+#include "greenlet_thread_state.hpp"
+
+
+// Protected by the GIL. Incremented when we create a main greenlet,
+// in a new thread, decremented when it is destroyed.
+static Py_ssize_t G_TOTAL_MAIN_GREENLETS;
+
+namespace greenlet {
+greenlet::PythonAllocator MainGreenlet::allocator;
+
+void* MainGreenlet::operator new(size_t UNUSED(count))
+{
+ return allocator.allocate(1);
+}
+
+
+void MainGreenlet::operator delete(void* ptr)
+{
+ return allocator.deallocate(static_cast(ptr),
+ 1);
+}
+
+
+MainGreenlet::MainGreenlet(PyGreenlet* p, ThreadState* state)
+ : Greenlet(p, StackState::make_main()),
+ _self(p),
+ _thread_state(state)
+{
+ G_TOTAL_MAIN_GREENLETS++;
+}
+
+MainGreenlet::~MainGreenlet()
+{
+ G_TOTAL_MAIN_GREENLETS--;
+ this->tp_clear();
+}
+
+ThreadState*
+MainGreenlet::thread_state() const noexcept
+{
+ return this->_thread_state;
+}
+
+void
+MainGreenlet::thread_state(ThreadState* t) noexcept
+{
+ assert(!t);
+ this->_thread_state = t;
+}
+
+BorrowedGreenlet
+MainGreenlet::self() const noexcept
+{
+ return BorrowedGreenlet(this->_self.borrow());
+}
+
+
+const BorrowedMainGreenlet
+MainGreenlet::main_greenlet() const
+{
+ return this->_self;
+}
+
+BorrowedMainGreenlet
+MainGreenlet::find_main_greenlet_in_lineage() const
+{
+ return BorrowedMainGreenlet(this->_self);
+}
+
+bool
+MainGreenlet::was_running_in_dead_thread() const noexcept
+{
+ return !this->_thread_state;
+}
+
+OwnedObject
+MainGreenlet::g_switch()
+{
+ try {
+ this->check_switch_allowed();
+ }
+ catch (const PyErrOccurred&) {
+ this->release_args();
+ throw;
+ }
+
+ switchstack_result_t err = this->g_switchstack();
+ if (err.status < 0) {
+ // XXX: This code path is untested, but it is shared
+ // with the UserGreenlet path that is tested.
+ return this->on_switchstack_or_initialstub_failure(
+ this,
+ err,
+ true, // target was me
+ false // was initial stub
+ );
+ }
+
+ return err.the_new_current_greenlet->g_switch_finish(err);
+}
+
+int
+MainGreenlet::tp_traverse(visitproc visit, void* arg)
+{
+ if (this->_thread_state) {
+ // we've already traversed main, (self), don't do it again.
+ int result = this->_thread_state->tp_traverse(visit, arg, false);
+ if (result) {
+ return result;
+ }
+ }
+ return Greenlet::tp_traverse(visit, arg);
+}
+
+const OwnedObject&
+MainGreenlet::run() const
+{
+ throw AttributeError("Main greenlets do not have a run attribute.");
+}
+
+void
+MainGreenlet::run(const BorrowedObject UNUSED(nrun))
+{
+ throw AttributeError("Main greenlets do not have a run attribute.");
+}
+
+void
+MainGreenlet::parent(const BorrowedObject raw_new_parent)
+{
+ if (!raw_new_parent) {
+ throw AttributeError("can't delete attribute");
+ }
+ throw AttributeError("cannot set the parent of a main greenlet");
+}
+
+const OwnedGreenlet
+MainGreenlet::parent() const
+{
+ return OwnedGreenlet(); // null becomes None
+}
+
+}; // namespace greenlet
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TPythonState.cpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TPythonState.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..465d41740d71adab2a596fd109bfbbf432cedcab
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TPythonState.cpp
@@ -0,0 +1,375 @@
+#ifndef GREENLET_PYTHON_STATE_CPP
+#define GREENLET_PYTHON_STATE_CPP
+
+#include
+#include "greenlet_greenlet.hpp"
+
+namespace greenlet {
+
+PythonState::PythonState()
+ : _top_frame()
+#if GREENLET_USE_CFRAME
+ ,cframe(nullptr)
+ ,use_tracing(0)
+#endif
+#if GREENLET_PY312
+ ,py_recursion_depth(0)
+ ,c_recursion_depth(0)
+#else
+ ,recursion_depth(0)
+#endif
+ ,trash_delete_nesting(0)
+#if GREENLET_PY311
+ ,current_frame(nullptr)
+ ,datastack_chunk(nullptr)
+ ,datastack_top(nullptr)
+ ,datastack_limit(nullptr)
+#endif
+{
+#if GREENLET_USE_CFRAME
+ /*
+ The PyThreadState->cframe pointer usually points to memory on
+ the stack, alloceted in a call into PyEval_EvalFrameDefault.
+
+ Initially, before any evaluation begins, it points to the
+ initial PyThreadState object's ``root_cframe`` object, which is
+ statically allocated for the lifetime of the thread.
+
+ A greenlet can last for longer than a call to
+ PyEval_EvalFrameDefault, so we can't set its ``cframe`` pointer
+ to be the current ``PyThreadState->cframe``; nor could we use
+ one from the greenlet parent for the same reason. Yet a further
+ no: we can't allocate one scoped to the greenlet and then
+ destroy it when the greenlet is deallocated, because inside the
+ interpreter the _PyCFrame objects form a linked list, and that too
+ can result in accessing memory beyond its dynamic lifetime (if
+ the greenlet doesn't actually finish before it dies, its entry
+ could still be in the list).
+
+ Using the ``root_cframe`` is problematic, though, because its
+ members are never modified by the interpreter and are set to 0,
+ meaning that its ``use_tracing`` flag is never updated. We don't
+ want to modify that value in the ``root_cframe`` ourself: it
+ *shouldn't* matter much because we should probably never get
+ back to the point where that's the only cframe on the stack;
+ even if it did matter, the major consequence of an incorrect
+ value for ``use_tracing`` is that if its true the interpreter
+ does some extra work --- however, it's just good code hygiene.
+
+ Our solution: before a greenlet runs, after its initial
+ creation, it uses the ``root_cframe`` just to have something to
+ put there. However, once the greenlet is actually switched to
+ for the first time, ``g_initialstub`` (which doesn't actually
+ "return" while the greenlet is running) stores a new _PyCFrame on
+ its local stack, and copies the appropriate values from the
+ currently running _PyCFrame; this is then made the _PyCFrame for the
+ newly-minted greenlet. ``g_initialstub`` then proceeds to call
+ ``glet.run()``, which results in ``PyEval_...`` adding the
+ _PyCFrame to the list. Switches continue as normal. Finally, when
+ the greenlet finishes, the call to ``glet.run()`` returns and
+ the _PyCFrame is taken out of the linked list and the stack value
+ is now unused and free to expire.
+
+ XXX: I think we can do better. If we're deallocing in the same
+ thread, can't we traverse the list and unlink our frame?
+ Can we just keep a reference to the thread state in case we
+ dealloc in another thread? (Is that even possible if we're still
+ running and haven't returned from g_initialstub?)
+ */
+ this->cframe = &PyThreadState_GET()->root_cframe;
+#endif
+}
+
+
+inline void PythonState::may_switch_away() noexcept
+{
+#if GREENLET_PY311
+ // PyThreadState_GetFrame is probably going to have to allocate a
+ // new frame object. That may trigger garbage collection. Because
+ // we call this during the early phases of a switch (it doesn't
+ // matter to which greenlet, as this has a global effect), if a GC
+ // triggers a switch away, two things can happen, both bad:
+ // - We might not get switched back to, halting forward progress.
+ // this is pathological, but possible.
+ // - We might get switched back to with a different set of
+ // arguments or a throw instead of a switch. That would corrupt
+ // our state (specifically, PyErr_Occurred() and this->args()
+ // would no longer agree).
+ //
+ // Thus, when we call this API, we need to have GC disabled.
+ // This method serves as a bottleneck we call when maybe beginning
+ // a switch. In this way, it is always safe -- no risk of GC -- to
+ // use ``_GetFrame()`` whenever we need to, just as it was in
+ // <=3.10 (because subsequent calls will be cached and not
+ // allocate memory).
+
+ GCDisabledGuard no_gc;
+ Py_XDECREF(PyThreadState_GetFrame(PyThreadState_GET()));
+#endif
+}
+
+void PythonState::operator<<(const PyThreadState *const tstate) noexcept
+{
+ this->_context.steal(tstate->context);
+#if GREENLET_USE_CFRAME
+ /*
+ IMPORTANT: ``cframe`` is a pointer into the STACK. Thus, because
+ the call to ``slp_switch()`` changes the contents of the stack,
+ you cannot read from ``ts_current->cframe`` after that call and
+ necessarily get the same values you get from reading it here.
+ Anything you need to restore from now to then must be saved in a
+ global/threadlocal variable (because we can't use stack
+ variables here either). For things that need to persist across
+ the switch, use `will_switch_from`.
+ */
+ this->cframe = tstate->cframe;
+ #if !GREENLET_PY312
+ this->use_tracing = tstate->cframe->use_tracing;
+ #endif
+#endif // GREENLET_USE_CFRAME
+#if GREENLET_PY311
+ #if GREENLET_PY312
+ this->py_recursion_depth = tstate->py_recursion_limit - tstate->py_recursion_remaining;
+ this->c_recursion_depth = C_RECURSION_LIMIT - tstate->c_recursion_remaining;
+ #else // not 312
+ this->recursion_depth = tstate->recursion_limit - tstate->recursion_remaining;
+ #endif // GREENLET_PY312
+ this->current_frame = tstate->cframe->current_frame;
+ this->datastack_chunk = tstate->datastack_chunk;
+ this->datastack_top = tstate->datastack_top;
+ this->datastack_limit = tstate->datastack_limit;
+
+ PyFrameObject *frame = PyThreadState_GetFrame((PyThreadState *)tstate);
+ Py_XDECREF(frame); // PyThreadState_GetFrame gives us a new
+ // reference.
+ this->_top_frame.steal(frame);
+ #if GREENLET_PY312
+ this->trash_delete_nesting = tstate->trash.delete_nesting;
+ #else // not 312
+ this->trash_delete_nesting = tstate->trash_delete_nesting;
+ #endif // GREENLET_PY312
+#else // Not 311
+ this->recursion_depth = tstate->recursion_depth;
+ this->_top_frame.steal(tstate->frame);
+ this->trash_delete_nesting = tstate->trash_delete_nesting;
+#endif // GREENLET_PY311
+}
+
+#if GREENLET_PY312
+void GREENLET_NOINLINE(PythonState::unexpose_frames)()
+{
+ if (!this->top_frame()) {
+ return;
+ }
+
+ // See GreenletState::expose_frames() and the comment on frames_were_exposed
+ // for more information about this logic.
+ _PyInterpreterFrame *iframe = this->_top_frame->f_frame;
+ while (iframe != nullptr) {
+ _PyInterpreterFrame *prev_exposed = iframe->previous;
+ assert(iframe->frame_obj);
+ memcpy(&iframe->previous, &iframe->frame_obj->_f_frame_data[0],
+ sizeof(void *));
+ iframe = prev_exposed;
+ }
+}
+#else
+void PythonState::unexpose_frames()
+{}
+#endif
+
+void PythonState::operator>>(PyThreadState *const tstate) noexcept
+{
+ tstate->context = this->_context.relinquish_ownership();
+ /* Incrementing this value invalidates the contextvars cache,
+ which would otherwise remain valid across switches */
+ tstate->context_ver++;
+#if GREENLET_USE_CFRAME
+ tstate->cframe = this->cframe;
+ /*
+ If we were tracing, we need to keep tracing.
+ There should never be the possibility of hitting the
+ root_cframe here. See note above about why we can't
+ just copy this from ``origin->cframe->use_tracing``.
+ */
+ #if !GREENLET_PY312
+ tstate->cframe->use_tracing = this->use_tracing;
+ #endif
+#endif // GREENLET_USE_CFRAME
+#if GREENLET_PY311
+ #if GREENLET_PY312
+ tstate->py_recursion_remaining = tstate->py_recursion_limit - this->py_recursion_depth;
+ tstate->c_recursion_remaining = C_RECURSION_LIMIT - this->c_recursion_depth;
+ this->unexpose_frames();
+ #else // \/ 3.11
+ tstate->recursion_remaining = tstate->recursion_limit - this->recursion_depth;
+ #endif // GREENLET_PY312
+ tstate->cframe->current_frame = this->current_frame;
+ tstate->datastack_chunk = this->datastack_chunk;
+ tstate->datastack_top = this->datastack_top;
+ tstate->datastack_limit = this->datastack_limit;
+ this->_top_frame.relinquish_ownership();
+ #if GREENLET_PY312
+ tstate->trash.delete_nesting = this->trash_delete_nesting;
+ #else // not 3.12
+ tstate->trash_delete_nesting = this->trash_delete_nesting;
+ #endif // GREENLET_PY312
+#else // not 3.11
+ tstate->frame = this->_top_frame.relinquish_ownership();
+ tstate->recursion_depth = this->recursion_depth;
+ tstate->trash_delete_nesting = this->trash_delete_nesting;
+#endif // GREENLET_PY311
+}
+
+inline void PythonState::will_switch_from(PyThreadState *const origin_tstate) noexcept
+{
+#if GREENLET_USE_CFRAME && !GREENLET_PY312
+ // The weird thing is, we don't actually save this for an
+ // effect on the current greenlet, it's saved for an
+ // effect on the target greenlet. That is, we want
+ // continuity of this setting across the greenlet switch.
+ this->use_tracing = origin_tstate->cframe->use_tracing;
+#endif
+}
+
+void PythonState::set_initial_state(const PyThreadState* const tstate) noexcept
+{
+ this->_top_frame = nullptr;
+#if GREENLET_PY312
+ this->py_recursion_depth = tstate->py_recursion_limit - tstate->py_recursion_remaining;
+ // XXX: TODO: Comment from a reviewer:
+ // Should this be ``C_RECURSION_LIMIT - tstate->c_recursion_remaining``?
+ // But to me it looks more like that might not be the right
+ // initialization either?
+ this->c_recursion_depth = tstate->py_recursion_limit - tstate->py_recursion_remaining;
+#elif GREENLET_PY311
+ this->recursion_depth = tstate->recursion_limit - tstate->recursion_remaining;
+#else
+ this->recursion_depth = tstate->recursion_depth;
+#endif
+}
+// TODO: Better state management about when we own the top frame.
+int PythonState::tp_traverse(visitproc visit, void* arg, bool own_top_frame) noexcept
+{
+ Py_VISIT(this->_context.borrow());
+ if (own_top_frame) {
+ Py_VISIT(this->_top_frame.borrow());
+ }
+ return 0;
+}
+
+void PythonState::tp_clear(bool own_top_frame) noexcept
+{
+ PythonStateContext::tp_clear();
+ // If we get here owning a frame,
+ // we got dealloc'd without being finished. We may or may not be
+ // in the same thread.
+ if (own_top_frame) {
+ this->_top_frame.CLEAR();
+ }
+}
+
+#if GREENLET_USE_CFRAME
+void PythonState::set_new_cframe(_PyCFrame& frame) noexcept
+{
+ frame = *PyThreadState_GET()->cframe;
+ /* Make the target greenlet refer to the stack value. */
+ this->cframe = &frame;
+ /*
+ And restore the link to the previous frame so this one gets
+ unliked appropriately.
+ */
+ this->cframe->previous = &PyThreadState_GET()->root_cframe;
+}
+#endif
+
+const PythonState::OwnedFrame& PythonState::top_frame() const noexcept
+{
+ return this->_top_frame;
+}
+
+void PythonState::did_finish(PyThreadState* tstate) noexcept
+{
+#if GREENLET_PY311
+ // See https://github.com/gevent/gevent/issues/1924 and
+ // https://github.com/python-greenlet/greenlet/issues/328. In
+ // short, Python 3.11 allocates memory for frames as a sort of
+ // linked list that's kept as part of PyThreadState in the
+ // ``datastack_chunk`` member and friends. These are saved and
+ // restored as part of switching greenlets.
+ //
+ // When we initially switch to a greenlet, we set those to NULL.
+ // That causes the frame management code to treat this like a
+ // brand new thread and start a fresh list of chunks, beginning
+ // with a new "root" chunk. As we make calls in this greenlet,
+ // those chunks get added, and as calls return, they get popped.
+ // But the frame code (pystate.c) is careful to make sure that the
+ // root chunk never gets popped.
+ //
+ // Thus, when a greenlet exits for the last time, there will be at
+ // least a single root chunk that we must be responsible for
+ // deallocating.
+ //
+ // The complex part is that these chunks are allocated and freed
+ // using ``_PyObject_VirtualAlloc``/``Free``. Those aren't public
+ // functions, and they aren't exported for linking. It so happens
+ // that we know they are just thin wrappers around the Arena
+ // allocator, so we can use that directly to deallocate in a
+ // compatible way.
+ //
+ // CAUTION: Check this implementation detail on every major version.
+ //
+ // It might be nice to be able to do this in our destructor, but
+ // can we be sure that no one else is using that memory? Plus, as
+ // described below, our pointers may not even be valid anymore. As
+ // a special case, there is one time that we know we can do this,
+ // and that's from the destructor of the associated UserGreenlet
+ // (NOT main greenlet)
+ PyObjectArenaAllocator alloc;
+ _PyStackChunk* chunk = nullptr;
+ if (tstate) {
+ // We really did finish, we can never be switched to again.
+ chunk = tstate->datastack_chunk;
+ // Unfortunately, we can't do much sanity checking. Our
+ // this->datastack_chunk pointer is out of date (evaluation may
+ // have popped down through it already) so we can't verify that
+ // we deallocate it. I don't think we can even check datastack_top
+ // for the same reason.
+
+ PyObject_GetArenaAllocator(&alloc);
+ tstate->datastack_chunk = nullptr;
+ tstate->datastack_limit = nullptr;
+ tstate->datastack_top = nullptr;
+
+ }
+ else if (this->datastack_chunk) {
+ // The UserGreenlet (NOT the main greenlet!) is being deallocated. If we're
+ // still holding a stack chunk, it's garbage because we know
+ // we can never switch back to let cPython clean it up.
+ // Because the last time we got switched away from, and we
+ // haven't run since then, we know our chain is valid and can
+ // be dealloced.
+ chunk = this->datastack_chunk;
+ PyObject_GetArenaAllocator(&alloc);
+ }
+
+ if (alloc.free && chunk) {
+ // In case the arena mechanism has been torn down already.
+ while (chunk) {
+ _PyStackChunk *prev = chunk->previous;
+ chunk->previous = nullptr;
+ alloc.free(alloc.ctx, chunk, chunk->size);
+ chunk = prev;
+ }
+ }
+
+ this->datastack_chunk = nullptr;
+ this->datastack_limit = nullptr;
+ this->datastack_top = nullptr;
+#endif
+}
+
+
+}; // namespace greenlet
+
+#endif // GREENLET_PYTHON_STATE_CPP
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TStackState.cpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TStackState.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9aab596fbfa96b5d35e954c91cd3a837edbbfcb4
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TStackState.cpp
@@ -0,0 +1,265 @@
+#ifndef GREENLET_STACK_STATE_CPP
+#define GREENLET_STACK_STATE_CPP
+
+#include "greenlet_greenlet.hpp"
+
+namespace greenlet {
+
+#ifdef GREENLET_USE_STDIO
+#include
+using std::cerr;
+using std::endl;
+
+std::ostream& operator<<(std::ostream& os, const StackState& s)
+{
+ os << "StackState(stack_start=" << (void*)s._stack_start
+ << ", stack_stop=" << (void*)s.stack_stop
+ << ", stack_copy=" << (void*)s.stack_copy
+ << ", stack_saved=" << s._stack_saved
+ << ", stack_prev=" << s.stack_prev
+ << ", addr=" << &s
+ << ")";
+ return os;
+}
+#endif
+
+StackState::StackState(void* mark, StackState& current)
+ : _stack_start(nullptr),
+ stack_stop((char*)mark),
+ stack_copy(nullptr),
+ _stack_saved(0),
+ /* Skip a dying greenlet */
+ stack_prev(current._stack_start
+ ? ¤t
+ : current.stack_prev)
+{
+}
+
+StackState::StackState()
+ : _stack_start(nullptr),
+ stack_stop(nullptr),
+ stack_copy(nullptr),
+ _stack_saved(0),
+ stack_prev(nullptr)
+{
+}
+
+StackState::StackState(const StackState& other)
+// can't use a delegating constructor because of
+// MSVC for Python 2.7
+ : _stack_start(nullptr),
+ stack_stop(nullptr),
+ stack_copy(nullptr),
+ _stack_saved(0),
+ stack_prev(nullptr)
+{
+ this->operator=(other);
+}
+
+StackState& StackState::operator=(const StackState& other)
+{
+ if (&other == this) {
+ return *this;
+ }
+ if (other._stack_saved) {
+ throw std::runtime_error("Refusing to steal memory.");
+ }
+
+ //If we have memory allocated, dispose of it
+ this->free_stack_copy();
+
+ this->_stack_start = other._stack_start;
+ this->stack_stop = other.stack_stop;
+ this->stack_copy = other.stack_copy;
+ this->_stack_saved = other._stack_saved;
+ this->stack_prev = other.stack_prev;
+ return *this;
+}
+
+inline void StackState::free_stack_copy() noexcept
+{
+ PyMem_Free(this->stack_copy);
+ this->stack_copy = nullptr;
+ this->_stack_saved = 0;
+}
+
+inline void StackState::copy_heap_to_stack(const StackState& current) noexcept
+{
+
+ /* Restore the heap copy back into the C stack */
+ if (this->_stack_saved != 0) {
+ memcpy(this->_stack_start, this->stack_copy, this->_stack_saved);
+ this->free_stack_copy();
+ }
+ StackState* owner = const_cast(¤t);
+ if (!owner->_stack_start) {
+ owner = owner->stack_prev; /* greenlet is dying, skip it */
+ }
+ while (owner && owner->stack_stop <= this->stack_stop) {
+ // cerr << "\tOwner: " << owner << endl;
+ owner = owner->stack_prev; /* find greenlet with more stack */
+ }
+ this->stack_prev = owner;
+ // cerr << "\tFinished with: " << *this << endl;
+}
+
+inline int StackState::copy_stack_to_heap_up_to(const char* const stop) noexcept
+{
+ /* Save more of g's stack into the heap -- at least up to 'stop'
+ g->stack_stop |________|
+ | |
+ | __ stop . . . . .
+ | | ==> . .
+ |________| _______
+ | | | |
+ | | | |
+ g->stack_start | | |_______| g->stack_copy
+ */
+ intptr_t sz1 = this->_stack_saved;
+ intptr_t sz2 = stop - this->_stack_start;
+ assert(this->_stack_start);
+ if (sz2 > sz1) {
+ char* c = (char*)PyMem_Realloc(this->stack_copy, sz2);
+ if (!c) {
+ PyErr_NoMemory();
+ return -1;
+ }
+ memcpy(c + sz1, this->_stack_start + sz1, sz2 - sz1);
+ this->stack_copy = c;
+ this->_stack_saved = sz2;
+ }
+ return 0;
+}
+
+inline int StackState::copy_stack_to_heap(char* const stackref,
+ const StackState& current) noexcept
+{
+ /* must free all the C stack up to target_stop */
+ const char* const target_stop = this->stack_stop;
+
+ StackState* owner = const_cast(¤t);
+ assert(owner->_stack_saved == 0); // everything is present on the stack
+ if (!owner->_stack_start) {
+ owner = owner->stack_prev; /* not saved if dying */
+ }
+ else {
+ owner->_stack_start = stackref;
+ }
+
+ while (owner->stack_stop < target_stop) {
+ /* ts_current is entierely within the area to free */
+ if (owner->copy_stack_to_heap_up_to(owner->stack_stop)) {
+ return -1; /* XXX */
+ }
+ owner = owner->stack_prev;
+ }
+ if (owner != this) {
+ if (owner->copy_stack_to_heap_up_to(target_stop)) {
+ return -1; /* XXX */
+ }
+ }
+ return 0;
+}
+
+inline bool StackState::started() const noexcept
+{
+ return this->stack_stop != nullptr;
+}
+
+inline bool StackState::main() const noexcept
+{
+ return this->stack_stop == (char*)-1;
+}
+
+inline bool StackState::active() const noexcept
+{
+ return this->_stack_start != nullptr;
+}
+
+inline void StackState::set_active() noexcept
+{
+ assert(this->_stack_start == nullptr);
+ this->_stack_start = (char*)1;
+}
+
+inline void StackState::set_inactive() noexcept
+{
+ this->_stack_start = nullptr;
+ // XXX: What if we still have memory out there?
+ // That case is actually triggered by
+ // test_issue251_issue252_explicit_reference_not_collectable (greenlet.tests.test_leaks.TestLeaks)
+ // and
+ // test_issue251_issue252_need_to_collect_in_background
+ // (greenlet.tests.test_leaks.TestLeaks)
+ //
+ // Those objects never get deallocated, so the destructor never
+ // runs.
+ // It *seems* safe to clean up the memory here?
+ if (this->_stack_saved) {
+ this->free_stack_copy();
+ }
+}
+
+inline intptr_t StackState::stack_saved() const noexcept
+{
+ return this->_stack_saved;
+}
+
+inline char* StackState::stack_start() const noexcept
+{
+ return this->_stack_start;
+}
+
+
+inline StackState StackState::make_main() noexcept
+{
+ StackState s;
+ s._stack_start = (char*)1;
+ s.stack_stop = (char*)-1;
+ return s;
+}
+
+StackState::~StackState()
+{
+ if (this->_stack_saved != 0) {
+ this->free_stack_copy();
+ }
+}
+
+void StackState::copy_from_stack(void* vdest, const void* vsrc, size_t n) const
+{
+ char* dest = static_cast(vdest);
+ const char* src = static_cast(vsrc);
+ if (src + n <= this->_stack_start
+ || src >= this->_stack_start + this->_stack_saved
+ || this->_stack_saved == 0) {
+ // Nothing we're copying was spilled from the stack
+ memcpy(dest, src, n);
+ return;
+ }
+
+ if (src < this->_stack_start) {
+ // Copy the part before the saved stack.
+ // We know src + n > _stack_start due to the test above.
+ const size_t nbefore = this->_stack_start - src;
+ memcpy(dest, src, nbefore);
+ dest += nbefore;
+ src += nbefore;
+ n -= nbefore;
+ }
+ // We know src >= _stack_start after the before-copy, and
+ // src < _stack_start + _stack_saved due to the first if condition
+ size_t nspilled = std::min(n, this->_stack_start + this->_stack_saved - src);
+ memcpy(dest, this->stack_copy + (src - this->_stack_start), nspilled);
+ dest += nspilled;
+ src += nspilled;
+ n -= nspilled;
+ if (n > 0) {
+ // Copy the part after the saved stack
+ memcpy(dest, src, n);
+ }
+}
+
+}; // namespace greenlet
+
+#endif // GREENLET_STACK_STATE_CPP
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TThreadStateDestroy.cpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TThreadStateDestroy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a149a1a4eec041c3a0d7e080ccf9ab36bd6ba287
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TThreadStateDestroy.cpp
@@ -0,0 +1,195 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+/**
+ * Implementation of the ThreadState destructors.
+ *
+ * Format with:
+ * clang-format -i --style=file src/greenlet/greenlet.c
+ *
+ *
+ * Fix missing braces with:
+ * clang-tidy src/greenlet/greenlet.c -fix -checks="readability-braces-around-statements"
+*/
+#ifndef T_THREADSTATE_DESTROY
+#define T_THREADSTATE_DESTROY
+
+#include "greenlet_greenlet.hpp"
+#include "greenlet_thread_state.hpp"
+#include "greenlet_thread_support.hpp"
+#include "greenlet_cpython_add_pending.hpp"
+#include "TGreenletGlobals.cpp"
+
+namespace greenlet {
+
+struct ThreadState_DestroyWithGIL
+{
+ ThreadState_DestroyWithGIL(ThreadState* state)
+ {
+ if (state && state->has_main_greenlet()) {
+ DestroyWithGIL(state);
+ }
+ }
+
+ static int
+ DestroyWithGIL(ThreadState* state)
+ {
+ // Holding the GIL.
+ // Passed a non-shared pointer to the actual thread state.
+ // state -> main greenlet
+ assert(state->has_main_greenlet());
+ PyGreenlet* main(state->borrow_main_greenlet());
+ // When we need to do cross-thread operations, we check this.
+ // A NULL value means the thread died some time ago.
+ // We do this here, rather than in a Python dealloc function
+ // for the greenlet, in case there's still a reference out
+ // there.
+ static_cast(main->pimpl)->thread_state(nullptr);
+
+ delete state; // Deleting this runs the destructor, DECREFs the main greenlet.
+ return 0;
+ }
+};
+
+
+
+struct ThreadState_DestroyNoGIL
+{
+ // ensure this is actually defined.
+ static_assert(GREENLET_BROKEN_PY_ADD_PENDING == 1 || GREENLET_BROKEN_PY_ADD_PENDING == 0,
+ "GREENLET_BROKEN_PY_ADD_PENDING not defined correctly.");
+
+#if GREENLET_BROKEN_PY_ADD_PENDING
+ static int _push_pending_call(struct _pending_calls *pending,
+ int (*func)(void *), void *arg)
+ {
+ int i = pending->last;
+ int j = (i + 1) % NPENDINGCALLS;
+ if (j == pending->first) {
+ return -1; /* Queue full */
+ }
+ pending->calls[i].func = func;
+ pending->calls[i].arg = arg;
+ pending->last = j;
+ return 0;
+ }
+
+ static int AddPendingCall(int (*func)(void *), void *arg)
+ {
+ _PyRuntimeState *runtime = &_PyRuntime;
+ if (!runtime) {
+ // obviously impossible
+ return 0;
+ }
+ struct _pending_calls *pending = &runtime->ceval.pending;
+ if (!pending->lock) {
+ return 0;
+ }
+ int result = 0;
+ PyThread_acquire_lock(pending->lock, WAIT_LOCK);
+ if (!pending->finishing) {
+ result = _push_pending_call(pending, func, arg);
+ }
+ PyThread_release_lock(pending->lock);
+ SIGNAL_PENDING_CALLS(&runtime->ceval);
+ return result;
+ }
+#else
+ // Python < 3.8 or >= 3.9
+ static int AddPendingCall(int (*func)(void*), void* arg)
+ {
+ return Py_AddPendingCall(func, arg);
+ }
+#endif
+
+ ThreadState_DestroyNoGIL(ThreadState* state)
+ {
+ // We are *NOT* holding the GIL. Our thread is in the middle
+ // of its death throes and the Python thread state is already
+ // gone so we can't use most Python APIs. One that is safe is
+ // ``Py_AddPendingCall``, unless the interpreter itself has
+ // been torn down. There is a limited number of calls that can
+ // be queued: 32 (NPENDINGCALLS) in CPython 3.10, so we
+ // coalesce these calls using our own queue.
+ if (state && state->has_main_greenlet()) {
+ // mark the thread as dead ASAP.
+ // this is racy! If we try to throw or switch to a
+ // greenlet from this thread from some other thread before
+ // we clear the state pointer, it won't realize the state
+ // is dead which can crash the process.
+ PyGreenlet* p = state->borrow_main_greenlet();
+ assert(p->pimpl->thread_state() == state || p->pimpl->thread_state() == nullptr);
+ static_cast(p->pimpl)->thread_state(nullptr);
+ }
+
+ // NOTE: Because we're not holding the GIL here, some other
+ // Python thread could run and call ``os.fork()``, which would
+ // be bad if that happenend while we are holding the cleanup
+ // lock (it wouldn't function in the child process).
+ // Make a best effort to try to keep the duration we hold the
+ // lock short.
+ // TODO: On platforms that support it, use ``pthread_atfork`` to
+ // drop this lock.
+ LockGuard cleanup_lock(*mod_globs->thread_states_to_destroy_lock);
+
+ if (state && state->has_main_greenlet()) {
+ // Because we don't have the GIL, this is a race condition.
+ if (!PyInterpreterState_Head()) {
+ // We have to leak the thread state, if the
+ // interpreter has shut down when we're getting
+ // deallocated, we can't run the cleanup code that
+ // deleting it would imply.
+ return;
+ }
+
+ mod_globs->queue_to_destroy(state);
+ if (mod_globs->thread_states_to_destroy.size() == 1) {
+ // We added the first item to the queue. We need to schedule
+ // the cleanup.
+ int result = ThreadState_DestroyNoGIL::AddPendingCall(
+ ThreadState_DestroyNoGIL::DestroyQueueWithGIL,
+ NULL);
+ if (result < 0) {
+ // Hmm, what can we do here?
+ fprintf(stderr,
+ "greenlet: WARNING: failed in call to Py_AddPendingCall; "
+ "expect a memory leak.\n");
+ }
+ }
+ }
+ }
+
+ static int
+ DestroyQueueWithGIL(void* UNUSED(arg))
+ {
+ // We're holding the GIL here, so no Python code should be able to
+ // run to call ``os.fork()``.
+ while (1) {
+ ThreadState* to_destroy;
+ {
+ LockGuard cleanup_lock(*mod_globs->thread_states_to_destroy_lock);
+ if (mod_globs->thread_states_to_destroy.empty()) {
+ break;
+ }
+ to_destroy = mod_globs->take_next_to_destroy();
+ }
+ // Drop the lock while we do the actual deletion.
+ ThreadState_DestroyWithGIL::DestroyWithGIL(to_destroy);
+ }
+ return 0;
+ }
+
+};
+
+}; // namespace greenlet
+
+// The intent when GET_THREAD_STATE() is needed multiple times in a
+// function is to take a reference to its return value in a local
+// variable, to avoid the thread-local indirection. On some platforms
+// (macOS), accessing a thread-local involves a function call (plus an
+// initial function call in each function that uses a thread local);
+// in contrast, static volatile variables are at some pre-computed
+// offset.
+typedef greenlet::ThreadStateCreator ThreadStateCreator;
+static thread_local ThreadStateCreator g_thread_state_global;
+#define GET_THREAD_STATE() g_thread_state_global
+
+#endif //T_THREADSTATE_DESTROY
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TUserGreenlet.cpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TUserGreenlet.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..495a79405ce51fa39534c41d4d479dc2be1fda0c
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/TUserGreenlet.cpp
@@ -0,0 +1,667 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+/**
+ * Implementation of greenlet::UserGreenlet.
+ *
+ * Format with:
+ * clang-format -i --style=file src/greenlet/greenlet.c
+ *
+ *
+ * Fix missing braces with:
+ * clang-tidy src/greenlet/greenlet.c -fix -checks="readability-braces-around-statements"
+*/
+
+#include "greenlet_internal.hpp"
+#include "greenlet_greenlet.hpp"
+#include "greenlet_thread_state.hpp"
+#include "TThreadStateDestroy.cpp"
+
+
+namespace greenlet {
+using greenlet::refs::BorrowedMainGreenlet;
+greenlet::PythonAllocator UserGreenlet::allocator;
+
+void* UserGreenlet::operator new(size_t UNUSED(count))
+{
+ return allocator.allocate(1);
+}
+
+
+void UserGreenlet::operator delete(void* ptr)
+{
+ return allocator.deallocate(static_cast(ptr),
+ 1);
+}
+
+
+UserGreenlet::UserGreenlet(PyGreenlet* p, BorrowedGreenlet the_parent)
+ : Greenlet(p), _parent(the_parent)
+{
+ this->_self = p;
+}
+
+UserGreenlet::~UserGreenlet()
+{
+ // Python 3.11: If we don't clear out the raw frame datastack
+ // when deleting an unfinished greenlet,
+ // TestLeaks.test_untracked_memory_doesnt_increase_unfinished_thread_dealloc_in_main fails.
+ this->python_state.did_finish(nullptr);
+ this->tp_clear();
+}
+
+BorrowedGreenlet
+UserGreenlet::self() const noexcept
+{
+ return this->_self;
+}
+
+
+
+const BorrowedMainGreenlet
+UserGreenlet::main_greenlet() const
+{
+ return this->_main_greenlet;
+}
+
+
+BorrowedMainGreenlet
+UserGreenlet::find_main_greenlet_in_lineage() const
+{
+ if (this->started()) {
+ assert(this->_main_greenlet);
+ return BorrowedMainGreenlet(this->_main_greenlet);
+ }
+
+ if (!this->_parent) {
+ /* garbage collected greenlet in chain */
+ // XXX: WHAT?
+ return BorrowedMainGreenlet(nullptr);
+ }
+
+ return this->_parent->find_main_greenlet_in_lineage();
+}
+
+
+/**
+ * CAUTION: This will allocate memory and may trigger garbage
+ * collection and arbitrary Python code.
+ */
+OwnedObject
+UserGreenlet::throw_GreenletExit_during_dealloc(const ThreadState& current_thread_state)
+{
+ /* The dying greenlet cannot be a parent of ts_current
+ because the 'parent' field chain would hold a
+ reference */
+ UserGreenlet::ParentIsCurrentGuard with_current_parent(this, current_thread_state);
+
+ // We don't care about the return value, only whether an
+ // exception happened. Whether or not an exception happens,
+ // we need to restore the parent in case the greenlet gets
+ // resurrected.
+ return Greenlet::throw_GreenletExit_during_dealloc(current_thread_state);
+}
+
+ThreadState*
+UserGreenlet::thread_state() const noexcept
+{
+ // TODO: maybe make this throw, if the thread state isn't there?
+ // if (!this->main_greenlet) {
+ // throw std::runtime_error("No thread state"); // TODO: Better exception
+ // }
+ if (!this->_main_greenlet) {
+ return nullptr;
+ }
+ return this->_main_greenlet->thread_state();
+}
+
+
+bool
+UserGreenlet::was_running_in_dead_thread() const noexcept
+{
+ return this->_main_greenlet && !this->thread_state();
+}
+
+OwnedObject
+UserGreenlet::g_switch()
+{
+ assert(this->args() || PyErr_Occurred());
+
+ try {
+ this->check_switch_allowed();
+ }
+ catch (const PyErrOccurred&) {
+ this->release_args();
+ throw;
+ }
+
+ // Switching greenlets used to attempt to clean out ones that need
+ // deleted *if* we detected a thread switch. Should it still do
+ // that?
+ // An issue is that if we delete a greenlet from another thread,
+ // it gets queued to this thread, and ``kill_greenlet()`` switches
+ // back into the greenlet
+
+ /* find the real target by ignoring dead greenlets,
+ and if necessary starting a greenlet. */
+ switchstack_result_t err;
+ Greenlet* target = this;
+ // TODO: probably cleaner to handle the case where we do
+ // switch to ourself separately from the other cases.
+ // This can probably even further be simplified if we keep
+ // track of the switching_state we're going for and just call
+ // into g_switch() if it's not ourself. The main problem with that
+ // is that we would be using more stack space.
+ bool target_was_me = true;
+ bool was_initial_stub = false;
+ while (target) {
+ if (target->active()) {
+ if (!target_was_me) {
+ target->args() <<= this->args();
+ assert(!this->args());
+ }
+ err = target->g_switchstack();
+ break;
+ }
+ if (!target->started()) {
+ // We never encounter a main greenlet that's not started.
+ assert(!target->main());
+ UserGreenlet* real_target = static_cast(target);
+ assert(real_target);
+ void* dummymarker;
+ was_initial_stub = true;
+ if (!target_was_me) {
+ target->args() <<= this->args();
+ assert(!this->args());
+ }
+ try {
+ // This can only throw back to us while we're
+ // still in this greenlet. Once the new greenlet
+ // is bootstrapped, it has its own exception state.
+ err = real_target->g_initialstub(&dummymarker);
+ }
+ catch (const PyErrOccurred&) {
+ this->release_args();
+ throw;
+ }
+ catch (const GreenletStartedWhileInPython&) {
+ // The greenlet was started sometime before this
+ // greenlet actually switched to it, i.e.,
+ // "concurrent" calls to switch() or throw().
+ // We need to retry the switch.
+ // Note that the current greenlet has been reset
+ // to this one (or we wouldn't be running!)
+ continue;
+ }
+ break;
+ }
+
+ target = target->parent();
+ target_was_me = false;
+ }
+ // The ``this`` pointer and all other stack or register based
+ // variables are invalid now, at least where things succeed
+ // above.
+ // But this one, probably not so much? It's not clear if it's
+ // safe to throw an exception at this point.
+
+ if (err.status < 0) {
+ // If we get here, either g_initialstub()
+ // failed, or g_switchstack() failed. Either one of those
+ // cases SHOULD leave us in the original greenlet with a valid
+ // stack.
+ return this->on_switchstack_or_initialstub_failure(target, err, target_was_me, was_initial_stub);
+ }
+
+ // err.the_new_current_greenlet would be the same as ``target``,
+ // if target wasn't probably corrupt.
+ return err.the_new_current_greenlet->g_switch_finish(err);
+}
+
+
+
+Greenlet::switchstack_result_t
+UserGreenlet::g_initialstub(void* mark)
+{
+ OwnedObject run;
+
+ // We need to grab a reference to the current switch arguments
+ // in case we're entered concurrently during the call to
+ // GetAttr() and have to try again.
+ // We'll restore them when we return in that case.
+ // Scope them tightly to avoid ref leaks.
+ {
+ SwitchingArgs args(this->args());
+
+ /* save exception in case getattr clears it */
+ PyErrPieces saved;
+
+ /*
+ self.run is the object to call in the new greenlet.
+ This could run arbitrary python code and switch greenlets!
+ */
+ run = this->_self.PyRequireAttr(mod_globs->str_run);
+ /* restore saved exception */
+ saved.PyErrRestore();
+
+
+ /* recheck that it's safe to switch in case greenlet reparented anywhere above */
+ this->check_switch_allowed();
+
+ /* by the time we got here another start could happen elsewhere,
+ * that means it should now be a regular switch.
+ * This can happen if the Python code is a subclass that implements
+ * __getattribute__ or __getattr__, or makes ``run`` a descriptor;
+ * all of those can run arbitrary code that switches back into
+ * this greenlet.
+ */
+ if (this->stack_state.started()) {
+ // the successful switch cleared these out, we need to
+ // restore our version. They will be copied on up to the
+ // next target.
+ assert(!this->args());
+ this->args() <<= args;
+ throw GreenletStartedWhileInPython();
+ }
+ }
+
+ // Sweet, if we got here, we have the go-ahead and will switch
+ // greenlets.
+ // Nothing we do from here on out should allow for a thread or
+ // greenlet switch: No arbitrary calls to Python, including
+ // decref'ing
+
+#if GREENLET_USE_CFRAME
+ /* OK, we need it, we're about to switch greenlets, save the state. */
+ /*
+ See green_new(). This is a stack-allocated variable used
+ while *self* is in PyObject_Call().
+ We want to defer copying the state info until we're sure
+ we need it and are in a stable place to do so.
+ */
+ _PyCFrame trace_info;
+
+ this->python_state.set_new_cframe(trace_info);
+#endif
+ /* start the greenlet */
+ ThreadState& thread_state = GET_THREAD_STATE().state();
+ this->stack_state = StackState(mark,
+ thread_state.borrow_current()->stack_state);
+ this->python_state.set_initial_state(PyThreadState_GET());
+ this->exception_state.clear();
+ this->_main_greenlet = thread_state.get_main_greenlet();
+
+ /* perform the initial switch */
+ switchstack_result_t err = this->g_switchstack();
+ /* returns twice!
+ The 1st time with ``err == 1``: we are in the new greenlet.
+ This one owns a greenlet that used to be current.
+ The 2nd time with ``err <= 0``: back in the caller's
+ greenlet; this happens if the child finishes or switches
+ explicitly to us. Either way, the ``err`` variable is
+ created twice at the same memory location, but possibly
+ having different ``origin`` values. Note that it's not
+ constructed for the second time until the switch actually happens.
+ */
+ if (err.status == 1) {
+ // In the new greenlet.
+
+ // This never returns! Calling inner_bootstrap steals
+ // the contents of our run object within this stack frame, so
+ // it is not valid to do anything with it.
+ try {
+ this->inner_bootstrap(err.origin_greenlet.relinquish_ownership(),
+ run.relinquish_ownership());
+ }
+ // Getting a C++ exception here isn't good. It's probably a
+ // bug in the underlying greenlet, meaning it's probably a
+ // C++ extension. We're going to abort anyway, but try to
+ // display some nice information *if* possible. Some obscure
+ // platforms don't properly support this (old 32-bit Arm, see see
+ // https://github.com/python-greenlet/greenlet/issues/385); that's not
+ // great, but should usually be OK because, as mentioned above, we're
+ // terminating anyway.
+ //
+ // The catching is tested by
+ // ``test_cpp.CPPTests.test_unhandled_exception_in_greenlet_aborts``.
+ //
+ // PyErrOccurred can theoretically be thrown by
+ // inner_bootstrap() -> g_switch_finish(), but that should
+ // never make it back to here. It is a std::exception and
+ // would be caught if it is.
+ catch (const std::exception& e) {
+ std::string base = "greenlet: Unhandled C++ exception: ";
+ base += e.what();
+ Py_FatalError(base.c_str());
+ }
+ catch (...) {
+ // Some compilers/runtimes use exceptions internally.
+ // It appears that GCC on Linux with libstdc++ throws an
+ // exception internally at process shutdown time to unwind
+ // stacks and clean up resources. Depending on exactly
+ // where we are when the process exits, that could result
+ // in an unknown exception getting here. If we
+ // Py_FatalError() or abort() here, we interfere with
+ // orderly process shutdown. Throwing the exception on up
+ // is the right thing to do.
+ //
+ // gevent's ``examples/dns_mass_resolve.py`` demonstrates this.
+#ifndef NDEBUG
+ fprintf(stderr,
+ "greenlet: inner_bootstrap threw unknown exception; "
+ "is the process terminating?\n");
+#endif
+ throw;
+ }
+ Py_FatalError("greenlet: inner_bootstrap returned with no exception.\n");
+ }
+
+
+ // In contrast, notice that we're keeping the origin greenlet
+ // around as an owned reference; we need it to call the trace
+ // function for the switch back into the parent. It was only
+ // captured at the time the switch actually happened, though,
+ // so we haven't been keeping an extra reference around this
+ // whole time.
+
+ /* back in the parent */
+ if (err.status < 0) {
+ /* start failed badly, restore greenlet state */
+ this->stack_state = StackState();
+ this->_main_greenlet.CLEAR();
+ // CAUTION: This may run arbitrary Python code.
+ run.CLEAR(); // inner_bootstrap didn't run, we own the reference.
+ }
+
+ // In the success case, the spawned code (inner_bootstrap) will
+ // take care of decrefing this, so we relinquish ownership so as
+ // to not double-decref.
+
+ run.relinquish_ownership();
+
+ return err;
+}
+
+
+void
+UserGreenlet::inner_bootstrap(PyGreenlet* origin_greenlet, PyObject* run)
+{
+ // The arguments here would be another great place for move.
+ // As it is, we take them as a reference so that when we clear
+ // them we clear what's on the stack above us. Do that NOW, and
+ // without using a C++ RAII object,
+ // so there's no way that exiting the parent frame can clear it,
+ // or we clear it unexpectedly. This arises in the context of the
+ // interpreter shutting down. See https://github.com/python-greenlet/greenlet/issues/325
+ //PyObject* run = _run.relinquish_ownership();
+
+ /* in the new greenlet */
+ assert(this->thread_state()->borrow_current() == this->_self);
+ // C++ exceptions cannot propagate to the parent greenlet from
+ // here. (TODO: Do we need a catch(...) clause, perhaps on the
+ // function itself? ALl we could do is terminate the program.)
+ // NOTE: On 32-bit Windows, the call chain is extremely
+ // important here in ways that are subtle, having to do with
+ // the depth of the SEH list. The call to restore it MUST NOT
+ // add a new SEH handler to the list, or we'll restore it to
+ // the wrong thing.
+ this->thread_state()->restore_exception_state();
+ /* stack variables from above are no good and also will not unwind! */
+ // EXCEPT: That can't be true, we access run, among others, here.
+
+ this->stack_state.set_active(); /* running */
+
+ // We're about to possibly run Python code again, which
+ // could switch back/away to/from us, so we need to grab the
+ // arguments locally.
+ SwitchingArgs args;
+ args <<= this->args();
+ assert(!this->args());
+
+ // XXX: We could clear this much earlier, right?
+ // Or would that introduce the possibility of running Python
+ // code when we don't want to?
+ // CAUTION: This may run arbitrary Python code.
+ this->_run_callable.CLEAR();
+
+
+ // The first switch we need to manually call the trace
+ // function here instead of in g_switch_finish, because we
+ // never return there.
+ if (OwnedObject tracefunc = this->thread_state()->get_tracefunc()) {
+ OwnedGreenlet trace_origin;
+ trace_origin = origin_greenlet;
+ try {
+ g_calltrace(tracefunc,
+ args ? mod_globs->event_switch : mod_globs->event_throw,
+ trace_origin,
+ this->_self);
+ }
+ catch (const PyErrOccurred&) {
+ /* Turn trace errors into switch throws */
+ args.CLEAR();
+ }
+ }
+
+ // We no longer need the origin, it was only here for
+ // tracing.
+ // We may never actually exit this stack frame so we need
+ // to explicitly clear it.
+ // This could run Python code and switch.
+ Py_CLEAR(origin_greenlet);
+
+ OwnedObject result;
+ if (!args) {
+ /* pending exception */
+ result = NULL;
+ }
+ else {
+ /* call g.run(*args, **kwargs) */
+ // This could result in further switches
+ try {
+ //result = run.PyCall(args.args(), args.kwargs());
+ // CAUTION: Just invoking this, before the function even
+ // runs, may cause memory allocations, which may trigger
+ // GC, which may run arbitrary Python code.
+ result = OwnedObject::consuming(PyObject_Call(run, args.args().borrow(), args.kwargs().borrow()));
+ }
+ catch (...) {
+ // Unhandled C++ exception!
+
+ // If we declare ourselves as noexcept, if we don't catch
+ // this here, most platforms will just abort() the
+ // process. But on 64-bit Windows with older versions of
+ // the C runtime, this can actually corrupt memory and
+ // just return. We see this when compiling with the
+ // Windows 7.0 SDK targeting Windows Server 2008, but not
+ // when using the Appveyor Visual Studio 2019 image. So
+ // this currently only affects Python 2.7 on Windows 64.
+ // That is, the tests pass and the runtime aborts
+ // everywhere else.
+ //
+ // However, if we catch it and try to continue with a
+ // Python error, then all Windows 64 bit platforms corrupt
+ // memory. So all we can do is manually abort, hopefully
+ // with a good error message. (Note that the above was
+ // tested WITHOUT the `/EHr` switch being used at compile
+ // time, so MSVC may have "optimized" out important
+ // checking. Using that switch, we may be in a better
+ // place in terms of memory corruption.) But sometimes it
+ // can't be caught here at all, which is confusing but not
+ // terribly surprising; so again, the G_NOEXCEPT_WIN32
+ // plus "/EHr".
+ //
+ // Hopefully the basic C stdlib is still functional enough
+ // for us to at least print an error.
+ //
+ // It gets more complicated than that, though, on some
+ // platforms, specifically at least Linux/gcc/libstdc++. They use
+ // an exception to unwind the stack when a background
+ // thread exits. (See comments about noexcept.) So this
+ // may not actually represent anything untoward. On those
+ // platforms we allow throws of this to propagate, or
+ // attempt to anyway.
+# if defined(WIN32) || defined(_WIN32)
+ Py_FatalError(
+ "greenlet: Unhandled C++ exception from a greenlet run function. "
+ "Because memory is likely corrupted, terminating process.");
+ std::abort();
+#else
+ throw;
+#endif
+ }
+ }
+ // These lines may run arbitrary code
+ args.CLEAR();
+ Py_CLEAR(run);
+
+ if (!result
+ && mod_globs->PyExc_GreenletExit.PyExceptionMatches()
+ && (this->args())) {
+ // This can happen, for example, if our only reference
+ // goes away after we switch back to the parent.
+ // See test_dealloc_switch_args_not_lost
+ PyErrPieces clear_error;
+ result <<= this->args();
+ result = single_result(result);
+ }
+ this->release_args();
+ this->python_state.did_finish(PyThreadState_GET());
+
+ result = g_handle_exit(result);
+ assert(this->thread_state()->borrow_current() == this->_self);
+
+ /* jump back to parent */
+ this->stack_state.set_inactive(); /* dead */
+
+
+ // TODO: Can we decref some things here? Release our main greenlet
+ // and maybe parent?
+ for (Greenlet* parent = this->_parent;
+ parent;
+ parent = parent->parent()) {
+ // We need to somewhere consume a reference to
+ // the result; in most cases we'll never have control
+ // back in this stack frame again. Calling
+ // green_switch actually adds another reference!
+ // This would probably be clearer with a specific API
+ // to hand results to the parent.
+ parent->args() <<= result;
+ assert(!result);
+ // The parent greenlet now owns the result; in the
+ // typical case we'll never get back here to assign to
+ // result and thus release the reference.
+ try {
+ result = parent->g_switch();
+ }
+ catch (const PyErrOccurred&) {
+ // Ignore, keep passing the error on up.
+ }
+
+ /* Return here means switch to parent failed,
+ * in which case we throw *current* exception
+ * to the next parent in chain.
+ */
+ assert(!result);
+ }
+ /* We ran out of parents, cannot continue */
+ PyErr_WriteUnraisable(this->self().borrow_o());
+ Py_FatalError("greenlet: ran out of parent greenlets while propagating exception; "
+ "cannot continue");
+ std::abort();
+}
+
+void
+UserGreenlet::run(const BorrowedObject nrun)
+{
+ if (this->started()) {
+ throw AttributeError(
+ "run cannot be set "
+ "after the start of the greenlet");
+ }
+ this->_run_callable = nrun;
+}
+
+const OwnedGreenlet
+UserGreenlet::parent() const
+{
+ return this->_parent;
+}
+
+void
+UserGreenlet::parent(const BorrowedObject raw_new_parent)
+{
+ if (!raw_new_parent) {
+ throw AttributeError("can't delete attribute");
+ }
+
+ BorrowedMainGreenlet main_greenlet_of_new_parent;
+ BorrowedGreenlet new_parent(raw_new_parent.borrow()); // could
+ // throw
+ // TypeError!
+ for (BorrowedGreenlet p = new_parent; p; p = p->parent()) {
+ if (p == this->_self) {
+ throw ValueError("cyclic parent chain");
+ }
+ main_greenlet_of_new_parent = p->main_greenlet();
+ }
+
+ if (!main_greenlet_of_new_parent) {
+ throw ValueError("parent must not be garbage collected");
+ }
+
+ if (this->started()
+ && this->_main_greenlet != main_greenlet_of_new_parent) {
+ throw ValueError("parent cannot be on a different thread");
+ }
+
+ this->_parent = new_parent;
+}
+
+void
+UserGreenlet::murder_in_place()
+{
+ this->_main_greenlet.CLEAR();
+ Greenlet::murder_in_place();
+}
+
+bool
+UserGreenlet::belongs_to_thread(const ThreadState* thread_state) const
+{
+ return Greenlet::belongs_to_thread(thread_state) && this->_main_greenlet == thread_state->borrow_main_greenlet();
+}
+
+
+int
+UserGreenlet::tp_traverse(visitproc visit, void* arg)
+{
+ Py_VISIT(this->_parent.borrow_o());
+ Py_VISIT(this->_main_greenlet.borrow_o());
+ Py_VISIT(this->_run_callable.borrow_o());
+
+ return Greenlet::tp_traverse(visit, arg);
+}
+
+int
+UserGreenlet::tp_clear()
+{
+ Greenlet::tp_clear();
+ this->_parent.CLEAR();
+ this->_main_greenlet.CLEAR();
+ this->_run_callable.CLEAR();
+ return 0;
+}
+
+UserGreenlet::ParentIsCurrentGuard::ParentIsCurrentGuard(UserGreenlet* p,
+ const ThreadState& thread_state)
+ : oldparent(p->_parent),
+ greenlet(p)
+{
+ p->_parent = thread_state.get_current();
+}
+
+UserGreenlet::ParentIsCurrentGuard::~ParentIsCurrentGuard()
+{
+ this->greenlet->_parent = oldparent;
+ oldparent.CLEAR();
+}
+
+}; //namespace greenlet
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/__init__.py b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..298a19de02f47540b2be8ae246c761dc2e426ce9
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/__init__.py
@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+"""
+The root of the greenlet package.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+__all__ = [
+ '__version__',
+ '_C_API',
+
+ 'GreenletExit',
+ 'error',
+
+ 'getcurrent',
+ 'greenlet',
+
+ 'gettrace',
+ 'settrace',
+]
+
+# pylint:disable=no-name-in-module
+
+###
+# Metadata
+###
+__version__ = '3.0.3'
+from ._greenlet import _C_API # pylint:disable=no-name-in-module
+
+###
+# Exceptions
+###
+from ._greenlet import GreenletExit
+from ._greenlet import error
+
+###
+# greenlets
+###
+from ._greenlet import getcurrent
+from ._greenlet import greenlet
+
+###
+# tracing
+###
+try:
+ from ._greenlet import gettrace
+ from ._greenlet import settrace
+except ImportError:
+ # Tracing wasn't supported.
+ # XXX: The option to disable it was removed in 1.0,
+ # so this branch should be dead code.
+ pass
+
+###
+# Constants
+# These constants aren't documented and aren't recommended.
+# In 1.0, USE_GC and USE_TRACING are always true, and USE_CONTEXT_VARS
+# is the same as ``sys.version_info[:2] >= 3.7``
+###
+from ._greenlet import GREENLET_USE_CONTEXT_VARS # pylint:disable=unused-import
+from ._greenlet import GREENLET_USE_GC # pylint:disable=unused-import
+from ._greenlet import GREENLET_USE_TRACING # pylint:disable=unused-import
+
+# Controlling the use of the gc module. Provisional API for this greenlet
+# implementation in 2.0.
+from ._greenlet import CLOCKS_PER_SEC # pylint:disable=unused-import
+from ._greenlet import enable_optional_cleanup # pylint:disable=unused-import
+from ._greenlet import get_clocks_used_doing_optional_cleanup # pylint:disable=unused-import
+
+# Other APIS in the _greenlet module are for test support.
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet.cpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5a9818e83f220e918579f79f8600dce4ef0f3aae
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet.cpp
@@ -0,0 +1,1494 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+/* Format with:
+ * clang-format -i --style=file src/greenlet/greenlet.c
+ *
+ *
+ * Fix missing braces with:
+ * clang-tidy src/greenlet/greenlet.c -fix -checks="readability-braces-around-statements"
+*/
+#include
+#include
+#include
+#include
+
+
+#define PY_SSIZE_T_CLEAN
+#include
+#include "structmember.h" // PyMemberDef
+
+#include "greenlet_internal.hpp"
+// Code after this point can assume access to things declared in stdint.h,
+// including the fixed-width types. This goes for the platform-specific switch functions
+// as well.
+#include "greenlet_refs.hpp"
+#include "greenlet_slp_switch.hpp"
+#include "greenlet_thread_state.hpp"
+#include "greenlet_thread_support.hpp"
+#include "greenlet_greenlet.hpp"
+
+#include "TGreenletGlobals.cpp"
+#include "TThreadStateDestroy.cpp"
+#include "TGreenlet.cpp"
+#include "TMainGreenlet.cpp"
+#include "TUserGreenlet.cpp"
+#include "TBrokenGreenlet.cpp"
+#include "TExceptionState.cpp"
+#include "TPythonState.cpp"
+#include "TStackState.cpp"
+
+
+using greenlet::LockGuard;
+using greenlet::LockInitError;
+using greenlet::PyErrOccurred;
+using greenlet::Require;
+
+using greenlet::g_handle_exit;
+using greenlet::single_result;
+
+using greenlet::Greenlet;
+using greenlet::UserGreenlet;
+using greenlet::MainGreenlet;
+using greenlet::BrokenGreenlet;
+using greenlet::ThreadState;
+using greenlet::PythonState;
+
+
+
+// ******* Implementation of things from included files
+template
+greenlet::refs::_BorrowedGreenlet& greenlet::refs::_BorrowedGreenlet::operator=(const greenlet::refs::BorrowedObject& other)
+{
+ this->_set_raw_pointer(static_cast(other));
+ return *this;
+}
+
+template
+inline greenlet::refs::_BorrowedGreenlet::operator Greenlet*() const noexcept
+{
+ if (!this->p) {
+ return nullptr;
+ }
+ return reinterpret_cast(this->p)->pimpl;
+}
+
+template
+greenlet::refs::_BorrowedGreenlet::_BorrowedGreenlet(const BorrowedObject& p)
+ : BorrowedReference(nullptr)
+{
+
+ this->_set_raw_pointer(p.borrow());
+}
+
+template
+inline greenlet::refs::_OwnedGreenlet::operator Greenlet*() const noexcept
+{
+ if (!this->p) {
+ return nullptr;
+ }
+ return reinterpret_cast(this->p)->pimpl;
+}
+
+
+
+#ifdef __clang__
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wmissing-field-initializers"
+# pragma clang diagnostic ignored "-Wwritable-strings"
+#elif defined(__GNUC__)
+# pragma GCC diagnostic push
+// warning: ISO C++ forbids converting a string constant to ‘char*’
+// (The python APIs aren't const correct and accept writable char*)
+# pragma GCC diagnostic ignored "-Wwrite-strings"
+#endif
+
+
+/***********************************************************
+
+A PyGreenlet is a range of C stack addresses that must be
+saved and restored in such a way that the full range of the
+stack contains valid data when we switch to it.
+
+Stack layout for a greenlet:
+
+ | ^^^ |
+ | older data |
+ | |
+ stack_stop . |_______________|
+ . | |
+ . | greenlet data |
+ . | in stack |
+ . * |_______________| . . _____________ stack_copy + stack_saved
+ . | | | |
+ . | data | |greenlet data|
+ . | unrelated | | saved |
+ . | to | | in heap |
+ stack_start . | this | . . |_____________| stack_copy
+ | greenlet |
+ | |
+ | newer data |
+ | vvv |
+
+
+Note that a greenlet's stack data is typically partly at its correct
+place in the stack, and partly saved away in the heap, but always in
+the above configuration: two blocks, the more recent one in the heap
+and the older one still in the stack (either block may be empty).
+
+Greenlets are chained: each points to the previous greenlet, which is
+the one that owns the data currently in the C stack above my
+stack_stop. The currently running greenlet is the first element of
+this chain. The main (initial) greenlet is the last one. Greenlets
+whose stack is entirely in the heap can be skipped from the chain.
+
+The chain is not related to execution order, but only to the order
+in which bits of C stack happen to belong to greenlets at a particular
+point in time.
+
+The main greenlet doesn't have a stack_stop: it is responsible for the
+complete rest of the C stack, and we don't know where it begins. We
+use (char*) -1, the largest possible address.
+
+States:
+ stack_stop == NULL && stack_start == NULL: did not start yet
+ stack_stop != NULL && stack_start == NULL: already finished
+ stack_stop != NULL && stack_start != NULL: active
+
+The running greenlet's stack_start is undefined but not NULL.
+
+ ***********************************************************/
+
+static PyGreenlet*
+green_create_main(ThreadState* state)
+{
+ PyGreenlet* gmain;
+
+ /* create the main greenlet for this thread */
+ gmain = (PyGreenlet*)PyType_GenericAlloc(&PyGreenlet_Type, 0);
+ if (gmain == NULL) {
+ Py_FatalError("green_create_main failed to alloc");
+ return NULL;
+ }
+ new MainGreenlet(gmain, state);
+
+ assert(Py_REFCNT(gmain) == 1);
+ return gmain;
+}
+
+
+
+/***********************************************************/
+
+/* Some functions must not be inlined:
+ * slp_restore_state, when inlined into slp_switch might cause
+ it to restore stack over its own local variables
+ * slp_save_state, when inlined would add its own local
+ variables to the saved stack, wasting space
+ * slp_switch, cannot be inlined for obvious reasons
+ * g_initialstub, when inlined would receive a pointer into its
+ own stack frame, leading to incomplete stack save/restore
+
+g_initialstub is a member function and declared virtual so that the
+compiler always calls it through a vtable.
+
+slp_save_state and slp_restore_state are also member functions. They
+are called from trampoline functions that themselves are declared as
+not eligible for inlining.
+*/
+
+extern "C" {
+static int GREENLET_NOINLINE(slp_save_state_trampoline)(char* stackref)
+{
+ return switching_thread_state->slp_save_state(stackref);
+}
+static void GREENLET_NOINLINE(slp_restore_state_trampoline)()
+{
+ switching_thread_state->slp_restore_state();
+}
+}
+
+
+/***********************************************************/
+
+static PyGreenlet*
+green_new(PyTypeObject* type, PyObject* UNUSED(args), PyObject* UNUSED(kwds))
+{
+ PyGreenlet* o =
+ (PyGreenlet*)PyBaseObject_Type.tp_new(type, mod_globs->empty_tuple, mod_globs->empty_dict);
+ if (o) {
+ new UserGreenlet(o, GET_THREAD_STATE().state().borrow_current());
+ assert(Py_REFCNT(o) == 1);
+ }
+ return o;
+}
+
+static PyGreenlet*
+green_unswitchable_new(PyTypeObject* type, PyObject* UNUSED(args), PyObject* UNUSED(kwds))
+{
+ PyGreenlet* o =
+ (PyGreenlet*)PyBaseObject_Type.tp_new(type, mod_globs->empty_tuple, mod_globs->empty_dict);
+ if (o) {
+ new BrokenGreenlet(o, GET_THREAD_STATE().state().borrow_current());
+ assert(Py_REFCNT(o) == 1);
+ }
+ return o;
+}
+
+static int
+green_setrun(BorrowedGreenlet self, BorrowedObject nrun, void* c);
+static int
+green_setparent(BorrowedGreenlet self, BorrowedObject nparent, void* c);
+
+static int
+green_init(BorrowedGreenlet self, BorrowedObject args, BorrowedObject kwargs)
+{
+ PyArgParseParam run;
+ PyArgParseParam nparent;
+ static const char* const kwlist[] = {
+ "run",
+ "parent",
+ NULL
+ };
+
+ // recall: The O specifier does NOT increase the reference count.
+ if (!PyArg_ParseTupleAndKeywords(
+ args, kwargs, "|OO:green", (char**)kwlist, &run, &nparent)) {
+ return -1;
+ }
+
+ if (run) {
+ if (green_setrun(self, run, NULL)) {
+ return -1;
+ }
+ }
+ if (nparent && !nparent.is_None()) {
+ return green_setparent(self, nparent, NULL);
+ }
+ return 0;
+}
+
+
+
+static int
+green_traverse(PyGreenlet* self, visitproc visit, void* arg)
+{
+ // We must only visit referenced objects, i.e. only objects
+ // Py_INCREF'ed by this greenlet (directly or indirectly):
+ //
+ // - stack_prev is not visited: holds previous stack pointer, but it's not
+ // referenced
+ // - frames are not visited as we don't strongly reference them;
+ // alive greenlets are not garbage collected
+ // anyway. This can be a problem, however, if this greenlet is
+ // never allowed to finish, and is referenced from the frame: we
+ // have an uncollectible cycle in that case. Note that the
+ // frame object itself is also frequently not even tracked by the GC
+ // starting with Python 3.7 (frames are allocated by the
+ // interpreter untracked, and only become tracked when their
+ // evaluation is finished if they have a refcount > 1). All of
+ // this is to say that we should probably strongly reference
+ // the frame object. Doing so, while always allowing GC on a
+ // greenlet, solves several leaks for us.
+
+ Py_VISIT(self->dict);
+ if (!self->pimpl) {
+ // Hmm. I have seen this at interpreter shutdown time,
+ // I think. That's very odd because this doesn't go away until
+ // we're ``green_dealloc()``, at which point we shouldn't be
+ // traversed anymore.
+ return 0;
+ }
+
+ return self->pimpl->tp_traverse(visit, arg);
+}
+
+static int
+green_is_gc(BorrowedGreenlet self)
+{
+ int result = 0;
+ /* Main greenlet can be garbage collected since it can only
+ become unreachable if the underlying thread exited.
+ Active greenlets --- including those that are suspended ---
+ cannot be garbage collected, however.
+ */
+ if (self->main() || !self->active()) {
+ result = 1;
+ }
+ // The main greenlet pointer will eventually go away after the thread dies.
+ if (self->was_running_in_dead_thread()) {
+ // Our thread is dead! We can never run again. Might as well
+ // GC us. Note that if a tuple containing only us and other
+ // immutable objects had been scanned before this, when we
+ // would have returned 0, the tuple will take itself out of GC
+ // tracking and never be investigated again. So that could
+ // result in both us and the tuple leaking due to an
+ // unreachable/uncollectible reference. The same goes for
+ // dictionaries.
+ //
+ // It's not a great idea to be changing our GC state on the
+ // fly.
+ result = 1;
+ }
+ return result;
+}
+
+
+static int
+green_clear(PyGreenlet* self)
+{
+ /* Greenlet is only cleared if it is about to be collected.
+ Since active greenlets are not garbage collectable, we can
+ be sure that, even if they are deallocated during clear,
+ nothing they reference is in unreachable or finalizers,
+ so even if it switches we are relatively safe. */
+ // XXX: Are we responsible for clearing weakrefs here?
+ Py_CLEAR(self->dict);
+ return self->pimpl->tp_clear();
+}
+
+/**
+ * Returns 0 on failure (the object was resurrected) or 1 on success.
+ **/
+static int
+_green_dealloc_kill_started_non_main_greenlet(BorrowedGreenlet self)
+{
+ /* Hacks hacks hacks copied from instance_dealloc() */
+ /* Temporarily resurrect the greenlet. */
+ assert(self.REFCNT() == 0);
+ Py_SET_REFCNT(self.borrow(), 1);
+ /* Save the current exception, if any. */
+ PyErrPieces saved_err;
+ try {
+ // BY THE TIME WE GET HERE, the state may actually be going
+ // away
+ // if we're shutting down the interpreter and freeing thread
+ // entries,
+ // this could result in freeing greenlets that were leaked. So
+ // we can't try to read the state.
+ self->deallocing_greenlet_in_thread(
+ self->thread_state()
+ ? static_cast(GET_THREAD_STATE())
+ : nullptr);
+ }
+ catch (const PyErrOccurred&) {
+ PyErr_WriteUnraisable(self.borrow_o());
+ /* XXX what else should we do? */
+ }
+ /* Check for no resurrection must be done while we keep
+ * our internal reference, otherwise PyFile_WriteObject
+ * causes recursion if using Py_INCREF/Py_DECREF
+ */
+ if (self.REFCNT() == 1 && self->active()) {
+ /* Not resurrected, but still not dead!
+ XXX what else should we do? we complain. */
+ PyObject* f = PySys_GetObject("stderr");
+ Py_INCREF(self.borrow_o()); /* leak! */
+ if (f != NULL) {
+ PyFile_WriteString("GreenletExit did not kill ", f);
+ PyFile_WriteObject(self.borrow_o(), f, 0);
+ PyFile_WriteString("\n", f);
+ }
+ }
+ /* Restore the saved exception. */
+ saved_err.PyErrRestore();
+ /* Undo the temporary resurrection; can't use DECREF here,
+ * it would cause a recursive call.
+ */
+ assert(self.REFCNT() > 0);
+
+ Py_ssize_t refcnt = self.REFCNT() - 1;
+ Py_SET_REFCNT(self.borrow_o(), refcnt);
+ if (refcnt != 0) {
+ /* Resurrected! */
+ _Py_NewReference(self.borrow_o());
+ Py_SET_REFCNT(self.borrow_o(), refcnt);
+ /* Better to use tp_finalizer slot (PEP 442)
+ * and call ``PyObject_CallFinalizerFromDealloc``,
+ * but that's only supported in Python 3.4+; see
+ * Modules/_io/iobase.c for an example.
+ *
+ * The following approach is copied from iobase.c in CPython 2.7.
+ * (along with much of this function in general). Here's their
+ * comment:
+ *
+ * When called from a heap type's dealloc, the type will be
+ * decref'ed on return (see e.g. subtype_dealloc in typeobject.c). */
+ if (PyType_HasFeature(self.TYPE(), Py_TPFLAGS_HEAPTYPE)) {
+ Py_INCREF(self.TYPE());
+ }
+
+ PyObject_GC_Track((PyObject*)self);
+
+ _Py_DEC_REFTOTAL;
+#ifdef COUNT_ALLOCS
+ --Py_TYPE(self)->tp_frees;
+ --Py_TYPE(self)->tp_allocs;
+#endif /* COUNT_ALLOCS */
+ return 0;
+ }
+ return 1;
+}
+
+
+static void
+green_dealloc(PyGreenlet* self)
+{
+ PyObject_GC_UnTrack(self);
+ BorrowedGreenlet me(self);
+ if (me->active()
+ && me->started()
+ && !me->main()) {
+ if (!_green_dealloc_kill_started_non_main_greenlet(me)) {
+ return;
+ }
+ }
+
+ if (self->weakreflist != NULL) {
+ PyObject_ClearWeakRefs((PyObject*)self);
+ }
+ Py_CLEAR(self->dict);
+
+ if (self->pimpl) {
+ // In case deleting this, which frees some memory,
+ // somehow winds up calling back into us. That's usually a
+ //bug in our code.
+ Greenlet* p = self->pimpl;
+ self->pimpl = nullptr;
+ delete p;
+ }
+ // and finally we're done. self is now invalid.
+ Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+
+static OwnedObject
+throw_greenlet(BorrowedGreenlet self, PyErrPieces& err_pieces)
+{
+ PyObject* result = nullptr;
+ err_pieces.PyErrRestore();
+ assert(PyErr_Occurred());
+ if (self->started() && !self->active()) {
+ /* dead greenlet: turn GreenletExit into a regular return */
+ result = g_handle_exit(OwnedObject()).relinquish_ownership();
+ }
+ self->args() <<= result;
+
+ return single_result(self->g_switch());
+}
+
+
+
+PyDoc_STRVAR(
+ green_switch_doc,
+ "switch(*args, **kwargs)\n"
+ "\n"
+ "Switch execution to this greenlet.\n"
+ "\n"
+ "If this greenlet has never been run, then this greenlet\n"
+ "will be switched to using the body of ``self.run(*args, **kwargs)``.\n"
+ "\n"
+ "If the greenlet is active (has been run, but was switch()'ed\n"
+ "out before leaving its run function), then this greenlet will\n"
+ "be resumed and the return value to its switch call will be\n"
+ "None if no arguments are given, the given argument if one\n"
+ "argument is given, or the args tuple and keyword args dict if\n"
+ "multiple arguments are given.\n"
+ "\n"
+ "If the greenlet is dead, or is the current greenlet then this\n"
+ "function will simply return the arguments using the same rules as\n"
+ "above.\n");
+
+static PyObject*
+green_switch(PyGreenlet* self, PyObject* args, PyObject* kwargs)
+{
+ using greenlet::SwitchingArgs;
+ SwitchingArgs switch_args(OwnedObject::owning(args), OwnedObject::owning(kwargs));
+ self->pimpl->may_switch_away();
+ self->pimpl->args() <<= switch_args;
+
+ // If we're switching out of a greenlet, and that switch is the
+ // last thing the greenlet does, the greenlet ought to be able to
+ // go ahead and die at that point. Currently, someone else must
+ // manually switch back to the greenlet so that we "fall off the
+ // end" and can perform cleanup. You'd think we'd be able to
+ // figure out that this is happening using the frame's ``f_lasti``
+ // member, which is supposed to be an index into
+ // ``frame->f_code->co_code``, the bytecode string. However, in
+ // recent interpreters, ``f_lasti`` tends not to be updated thanks
+ // to things like the PREDICT() macros in ceval.c. So it doesn't
+ // really work to do that in many cases. For example, the Python
+ // code:
+ // def run():
+ // greenlet.getcurrent().parent.switch()
+ // produces bytecode of len 16, with the actual call to switch()
+ // being at index 10 (in Python 3.10). However, the reported
+ // ``f_lasti`` we actually see is...5! (Which happens to be the
+ // second byte of the CALL_METHOD op for ``getcurrent()``).
+
+ try {
+ //OwnedObject result = single_result(self->pimpl->g_switch());
+ OwnedObject result(single_result(self->pimpl->g_switch()));
+#ifndef NDEBUG
+ // Note that the current greenlet isn't necessarily self. If self
+ // finished, we went to one of its parents.
+ assert(!self->pimpl->args());
+
+ const BorrowedGreenlet& current = GET_THREAD_STATE().state().borrow_current();
+ // It's possible it's never been switched to.
+ assert(!current->args());
+#endif
+ PyObject* p = result.relinquish_ownership();
+
+ if (!p && !PyErr_Occurred()) {
+ // This shouldn't be happening anymore, so the asserts
+ // are there for debug builds. Non-debug builds
+ // crash "gracefully" in this case, although there is an
+ // argument to be made for killing the process in all
+ // cases --- for this to be the case, our switches
+ // probably nested in an incorrect way, so the state is
+ // suspicious. Nothing should be corrupt though, just
+ // confused at the Python level. Letting this propagate is
+ // probably good enough.
+ assert(p || PyErr_Occurred());
+ throw PyErrOccurred(
+ mod_globs->PyExc_GreenletError,
+ "Greenlet.switch() returned NULL without an exception set."
+ );
+ }
+ return p;
+ }
+ catch(const PyErrOccurred&) {
+ return nullptr;
+ }
+}
+
+PyDoc_STRVAR(
+ green_throw_doc,
+ "Switches execution to this greenlet, but immediately raises the\n"
+ "given exception in this greenlet. If no argument is provided, the "
+ "exception\n"
+ "defaults to `greenlet.GreenletExit`. The normal exception\n"
+ "propagation rules apply, as described for `switch`. Note that calling "
+ "this\n"
+ "method is almost equivalent to the following::\n"
+ "\n"
+ " def raiser():\n"
+ " raise typ, val, tb\n"
+ " g_raiser = greenlet(raiser, parent=g)\n"
+ " g_raiser.switch()\n"
+ "\n"
+ "except that this trick does not work for the\n"
+ "`greenlet.GreenletExit` exception, which would not propagate\n"
+ "from ``g_raiser`` to ``g``.\n");
+
+static PyObject*
+green_throw(PyGreenlet* self, PyObject* args)
+{
+ PyArgParseParam typ(mod_globs->PyExc_GreenletExit);
+ PyArgParseParam val;
+ PyArgParseParam tb;
+
+ if (!PyArg_ParseTuple(args, "|OOO:throw", &typ, &val, &tb)) {
+ return nullptr;
+ }
+
+ assert(typ.borrow() || val.borrow());
+
+ self->pimpl->may_switch_away();
+ try {
+ // Both normalizing the error and the actual throw_greenlet
+ // could throw PyErrOccurred.
+ PyErrPieces err_pieces(typ.borrow(), val.borrow(), tb.borrow());
+
+ return throw_greenlet(self, err_pieces).relinquish_ownership();
+ }
+ catch (const PyErrOccurred&) {
+ return nullptr;
+ }
+}
+
+static int
+green_bool(PyGreenlet* self)
+{
+ return self->pimpl->active();
+}
+
+/**
+ * CAUTION: Allocates memory, may run GC and arbitrary Python code.
+ */
+static PyObject*
+green_getdict(PyGreenlet* self, void* UNUSED(context))
+{
+ if (self->dict == NULL) {
+ self->dict = PyDict_New();
+ if (self->dict == NULL) {
+ return NULL;
+ }
+ }
+ Py_INCREF(self->dict);
+ return self->dict;
+}
+
+static int
+green_setdict(PyGreenlet* self, PyObject* val, void* UNUSED(context))
+{
+ PyObject* tmp;
+
+ if (val == NULL) {
+ PyErr_SetString(PyExc_TypeError, "__dict__ may not be deleted");
+ return -1;
+ }
+ if (!PyDict_Check(val)) {
+ PyErr_SetString(PyExc_TypeError, "__dict__ must be a dictionary");
+ return -1;
+ }
+ tmp = self->dict;
+ Py_INCREF(val);
+ self->dict = val;
+ Py_XDECREF(tmp);
+ return 0;
+}
+
+static bool
+_green_not_dead(BorrowedGreenlet self)
+{
+ // XXX: Where else should we do this?
+ // Probably on entry to most Python-facing functions?
+ if (self->was_running_in_dead_thread()) {
+ self->deactivate_and_free();
+ return false;
+ }
+ return self->active() || !self->started();
+}
+
+
+static PyObject*
+green_getdead(BorrowedGreenlet self, void* UNUSED(context))
+{
+ if (_green_not_dead(self)) {
+ Py_RETURN_FALSE;
+ }
+ else {
+ Py_RETURN_TRUE;
+ }
+}
+
+static PyObject*
+green_get_stack_saved(PyGreenlet* self, void* UNUSED(context))
+{
+ return PyLong_FromSsize_t(self->pimpl->stack_saved());
+}
+
+
+static PyObject*
+green_getrun(BorrowedGreenlet self, void* UNUSED(context))
+{
+ try {
+ OwnedObject result(self->run());
+ return result.relinquish_ownership();
+ }
+ catch(const PyErrOccurred&) {
+ return nullptr;
+ }
+}
+
+
+
+
+
+static int
+green_setrun(BorrowedGreenlet self, BorrowedObject nrun, void* UNUSED(context))
+{
+ try {
+ self->run(nrun);
+ return 0;
+ }
+ catch(const PyErrOccurred&) {
+ return -1;
+ }
+}
+
+static PyObject*
+green_getparent(BorrowedGreenlet self, void* UNUSED(context))
+{
+ return self->parent().acquire_or_None();
+}
+
+
+
+static int
+green_setparent(BorrowedGreenlet self, BorrowedObject nparent, void* UNUSED(context))
+{
+ try {
+ self->parent(nparent);
+ }
+ catch(const PyErrOccurred&) {
+ return -1;
+ }
+ return 0;
+}
+
+
+static PyObject*
+green_getcontext(const PyGreenlet* self, void* UNUSED(context))
+{
+ const Greenlet *const g = self->pimpl;
+ try {
+ OwnedObject result(g->context());
+ return result.relinquish_ownership();
+ }
+ catch(const PyErrOccurred&) {
+ return nullptr;
+ }
+}
+
+static int
+green_setcontext(BorrowedGreenlet self, PyObject* nctx, void* UNUSED(context))
+{
+ try {
+ self->context(nctx);
+ return 0;
+ }
+ catch(const PyErrOccurred&) {
+ return -1;
+ }
+}
+
+
+static PyObject*
+green_getframe(BorrowedGreenlet self, void* UNUSED(context))
+{
+ const PythonState::OwnedFrame& top_frame = self->top_frame();
+ return top_frame.acquire_or_None();
+}
+
+
+static PyObject*
+green_getstate(PyGreenlet* self)
+{
+ PyErr_Format(PyExc_TypeError,
+ "cannot serialize '%s' object",
+ Py_TYPE(self)->tp_name);
+ return nullptr;
+}
+
+static PyObject*
+green_repr(BorrowedGreenlet self)
+{
+ /*
+ Return a string like
+
+
+ The handling of greenlets across threads is not super good.
+ We mostly use the internal definitions of these terms, but they
+ generally should make sense to users as well.
+ */
+ PyObject* result;
+ int never_started = !self->started() && !self->active();
+
+ const char* const tp_name = Py_TYPE(self)->tp_name;
+
+ if (_green_not_dead(self)) {
+ /* XXX: The otid= is almost useless because you can't correlate it to
+ any thread identifier exposed to Python. We could use
+ PyThreadState_GET()->thread_id, but we'd need to save that in the
+ greenlet, or save the whole PyThreadState object itself.
+
+ As it stands, its only useful for identifying greenlets from the same thread.
+ */
+ const char* state_in_thread;
+ if (self->was_running_in_dead_thread()) {
+ // The thread it was running in is dead!
+ // This can happen, especially at interpreter shut down.
+ // It complicates debugging output because it may be
+ // impossible to access the current thread state at that
+ // time. Thus, don't access the current thread state.
+ state_in_thread = " (thread exited)";
+ }
+ else {
+ state_in_thread = GET_THREAD_STATE().state().is_current(self)
+ ? " current"
+ : (self->started() ? " suspended" : "");
+ }
+ result = PyUnicode_FromFormat(
+ "<%s object at %p (otid=%p)%s%s%s%s>",
+ tp_name,
+ self.borrow_o(),
+ self->thread_state(),
+ state_in_thread,
+ self->active() ? " active" : "",
+ never_started ? " pending" : " started",
+ self->main() ? " main" : ""
+ );
+ }
+ else {
+ result = PyUnicode_FromFormat(
+ "<%s object at %p (otid=%p) %sdead>",
+ tp_name,
+ self.borrow_o(),
+ self->thread_state(),
+ self->was_running_in_dead_thread()
+ ? "(thread exited) "
+ : ""
+ );
+ }
+
+ return result;
+}
+
+/*****************************************************************************
+ * C interface
+ *
+ * These are exported using the CObject API
+ */
+extern "C" {
+static PyGreenlet*
+PyGreenlet_GetCurrent(void)
+{
+ return GET_THREAD_STATE().state().get_current().relinquish_ownership();
+}
+
+static int
+PyGreenlet_SetParent(PyGreenlet* g, PyGreenlet* nparent)
+{
+ return green_setparent((PyGreenlet*)g, (PyObject*)nparent, NULL);
+}
+
+static PyGreenlet*
+PyGreenlet_New(PyObject* run, PyGreenlet* parent)
+{
+ using greenlet::refs::NewDictReference;
+ // In the past, we didn't use green_new and green_init, but that
+ // was a maintenance issue because we duplicated code. This way is
+ // much safer, but slightly slower. If that's a problem, we could
+ // refactor green_init to separate argument parsing from initialization.
+ OwnedGreenlet g = OwnedGreenlet::consuming(green_new(&PyGreenlet_Type, nullptr, nullptr));
+ if (!g) {
+ return NULL;
+ }
+
+ try {
+ NewDictReference kwargs;
+ if (run) {
+ kwargs.SetItem(mod_globs->str_run, run);
+ }
+ if (parent) {
+ kwargs.SetItem("parent", (PyObject*)parent);
+ }
+
+ Require(green_init(g, mod_globs->empty_tuple, kwargs));
+ }
+ catch (const PyErrOccurred&) {
+ return nullptr;
+ }
+
+ return g.relinquish_ownership();
+}
+
+static PyObject*
+PyGreenlet_Switch(PyGreenlet* self, PyObject* args, PyObject* kwargs)
+{
+ if (!PyGreenlet_Check(self)) {
+ PyErr_BadArgument();
+ return NULL;
+ }
+
+ if (args == NULL) {
+ args = mod_globs->empty_tuple;
+ }
+
+ if (kwargs == NULL || !PyDict_Check(kwargs)) {
+ kwargs = NULL;
+ }
+
+ return green_switch(self, args, kwargs);
+}
+
+static PyObject*
+PyGreenlet_Throw(PyGreenlet* self, PyObject* typ, PyObject* val, PyObject* tb)
+{
+ if (!PyGreenlet_Check(self)) {
+ PyErr_BadArgument();
+ return nullptr;
+ }
+ try {
+ PyErrPieces err_pieces(typ, val, tb);
+ return throw_greenlet(self, err_pieces).relinquish_ownership();
+ }
+ catch (const PyErrOccurred&) {
+ return nullptr;
+ }
+}
+
+static int
+Extern_PyGreenlet_MAIN(PyGreenlet* self)
+{
+ if (!PyGreenlet_Check(self)) {
+ PyErr_BadArgument();
+ return -1;
+ }
+ return self->pimpl->main();
+}
+
+static int
+Extern_PyGreenlet_ACTIVE(PyGreenlet* self)
+{
+ if (!PyGreenlet_Check(self)) {
+ PyErr_BadArgument();
+ return -1;
+ }
+ return self->pimpl->active();
+}
+
+static int
+Extern_PyGreenlet_STARTED(PyGreenlet* self)
+{
+ if (!PyGreenlet_Check(self)) {
+ PyErr_BadArgument();
+ return -1;
+ }
+ return self->pimpl->started();
+}
+
+static PyGreenlet*
+Extern_PyGreenlet_GET_PARENT(PyGreenlet* self)
+{
+ if (!PyGreenlet_Check(self)) {
+ PyErr_BadArgument();
+ return NULL;
+ }
+ // This can return NULL even if there is no exception
+ return self->pimpl->parent().acquire();
+}
+} // extern C.
+
+/** End C API ****************************************************************/
+
+static PyMethodDef green_methods[] = {
+ {"switch",
+ reinterpret_cast(green_switch),
+ METH_VARARGS | METH_KEYWORDS,
+ green_switch_doc},
+ {"throw", (PyCFunction)green_throw, METH_VARARGS, green_throw_doc},
+ {"__getstate__", (PyCFunction)green_getstate, METH_NOARGS, NULL},
+ {NULL, NULL} /* sentinel */
+};
+
+static PyGetSetDef green_getsets[] = {
+ /* name, getter, setter, doc, context pointer */
+ {"__dict__", (getter)green_getdict, (setter)green_setdict, /*XXX*/ NULL},
+ {"run", (getter)green_getrun, (setter)green_setrun, /*XXX*/ NULL},
+ {"parent", (getter)green_getparent, (setter)green_setparent, /*XXX*/ NULL},
+ {"gr_frame", (getter)green_getframe, NULL, /*XXX*/ NULL},
+ {"gr_context",
+ (getter)green_getcontext,
+ (setter)green_setcontext,
+ /*XXX*/ NULL},
+ {"dead", (getter)green_getdead, NULL, /*XXX*/ NULL},
+ {"_stack_saved", (getter)green_get_stack_saved, NULL, /*XXX*/ NULL},
+ {NULL}
+};
+
+static PyMemberDef green_members[] = {
+ {NULL}
+};
+
+static PyNumberMethods green_as_number = {
+ NULL, /* nb_add */
+ NULL, /* nb_subtract */
+ NULL, /* nb_multiply */
+ NULL, /* nb_remainder */
+ NULL, /* nb_divmod */
+ NULL, /* nb_power */
+ NULL, /* nb_negative */
+ NULL, /* nb_positive */
+ NULL, /* nb_absolute */
+ (inquiry)green_bool, /* nb_bool */
+};
+
+
+PyTypeObject PyGreenlet_Type = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "greenlet.greenlet", /* tp_name */
+ sizeof(PyGreenlet), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ /* methods */
+ (destructor)green_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ (reprfunc)green_repr, /* tp_repr */
+ &green_as_number, /* tp_as _number*/
+ 0, /* tp_as _sequence*/
+ 0, /* tp_as _mapping*/
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer*/
+ G_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+ "greenlet(run=None, parent=None) -> greenlet\n\n"
+ "Creates a new greenlet object (without running it).\n\n"
+ " - *run* -- The callable to invoke.\n"
+ " - *parent* -- The parent greenlet. The default is the current "
+ "greenlet.", /* tp_doc */
+ (traverseproc)green_traverse, /* tp_traverse */
+ (inquiry)green_clear, /* tp_clear */
+ 0, /* tp_richcompare */
+ offsetof(PyGreenlet, weakreflist), /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ green_methods, /* tp_methods */
+ green_members, /* tp_members */
+ green_getsets, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ offsetof(PyGreenlet, dict), /* tp_dictoffset */
+ (initproc)green_init, /* tp_init */
+ PyType_GenericAlloc, /* tp_alloc */
+ (newfunc)green_new, /* tp_new */
+ PyObject_GC_Del, /* tp_free */
+ (inquiry)green_is_gc, /* tp_is_gc */
+};
+
+
+
+static PyObject*
+green_unswitchable_getforce(PyGreenlet* self, void* UNUSED(context))
+{
+ BrokenGreenlet* broken = dynamic_cast(self->pimpl);
+ return PyBool_FromLong(broken->_force_switch_error);
+}
+
+static int
+green_unswitchable_setforce(PyGreenlet* self, BorrowedObject nforce, void* UNUSED(context))
+{
+ if (!nforce) {
+ PyErr_SetString(
+ PyExc_AttributeError,
+ "Cannot delete force_switch_error"
+ );
+ return -1;
+ }
+ BrokenGreenlet* broken = dynamic_cast(self->pimpl);
+ int is_true = PyObject_IsTrue(nforce);
+ if (is_true == -1) {
+ return -1;
+ }
+ broken->_force_switch_error = is_true;
+ return 0;
+}
+
+static PyObject*
+green_unswitchable_getforceslp(PyGreenlet* self, void* UNUSED(context))
+{
+ BrokenGreenlet* broken = dynamic_cast(self->pimpl);
+ return PyBool_FromLong(broken->_force_slp_switch_error);
+}
+
+static int
+green_unswitchable_setforceslp(PyGreenlet* self, BorrowedObject nforce, void* UNUSED(context))
+{
+ if (!nforce) {
+ PyErr_SetString(
+ PyExc_AttributeError,
+ "Cannot delete force_slp_switch_error"
+ );
+ return -1;
+ }
+ BrokenGreenlet* broken = dynamic_cast(self->pimpl);
+ int is_true = PyObject_IsTrue(nforce);
+ if (is_true == -1) {
+ return -1;
+ }
+ broken->_force_slp_switch_error = is_true;
+ return 0;
+}
+
+static PyGetSetDef green_unswitchable_getsets[] = {
+ /* name, getter, setter, doc, context pointer */
+ {"force_switch_error",
+ (getter)green_unswitchable_getforce,
+ (setter)green_unswitchable_setforce,
+ /*XXX*/ NULL},
+ {"force_slp_switch_error",
+ (getter)green_unswitchable_getforceslp,
+ (setter)green_unswitchable_setforceslp,
+ /*XXX*/ NULL},
+
+ {NULL}
+};
+
+PyTypeObject PyGreenletUnswitchable_Type = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "greenlet._greenlet.UnswitchableGreenlet",
+ 0, /* tp_basicsize */
+ 0, /* tp_itemsize */
+ /* methods */
+ (destructor)green_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as _number*/
+ 0, /* tp_as _sequence*/
+ 0, /* tp_as _mapping*/
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer*/
+ G_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+ "Undocumented internal class", /* tp_doc */
+ (traverseproc)green_traverse, /* tp_traverse */
+ (inquiry)green_clear, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ 0, /* tp_methods */
+ 0, /* tp_members */
+ green_unswitchable_getsets, /* tp_getset */
+ &PyGreenlet_Type, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ (initproc)green_init, /* tp_init */
+ PyType_GenericAlloc, /* tp_alloc */
+ (newfunc)green_unswitchable_new, /* tp_new */
+ PyObject_GC_Del, /* tp_free */
+ (inquiry)green_is_gc, /* tp_is_gc */
+};
+
+
+PyDoc_STRVAR(mod_getcurrent_doc,
+ "getcurrent() -> greenlet\n"
+ "\n"
+ "Returns the current greenlet (i.e. the one which called this "
+ "function).\n");
+
+static PyObject*
+mod_getcurrent(PyObject* UNUSED(module))
+{
+ return GET_THREAD_STATE().state().get_current().relinquish_ownership_o();
+}
+
+PyDoc_STRVAR(mod_settrace_doc,
+ "settrace(callback) -> object\n"
+ "\n"
+ "Sets a new tracing function and returns the previous one.\n");
+static PyObject*
+mod_settrace(PyObject* UNUSED(module), PyObject* args)
+{
+ PyArgParseParam tracefunc;
+ if (!PyArg_ParseTuple(args, "O", &tracefunc)) {
+ return NULL;
+ }
+ ThreadState& state = GET_THREAD_STATE();
+ OwnedObject previous = state.get_tracefunc();
+ if (!previous) {
+ previous = Py_None;
+ }
+
+ state.set_tracefunc(tracefunc);
+
+ return previous.relinquish_ownership();
+}
+
+PyDoc_STRVAR(mod_gettrace_doc,
+ "gettrace() -> object\n"
+ "\n"
+ "Returns the currently set tracing function, or None.\n");
+
+static PyObject*
+mod_gettrace(PyObject* UNUSED(module))
+{
+ OwnedObject tracefunc = GET_THREAD_STATE().state().get_tracefunc();
+ if (!tracefunc) {
+ tracefunc = Py_None;
+ }
+ return tracefunc.relinquish_ownership();
+}
+
+PyDoc_STRVAR(mod_set_thread_local_doc,
+ "set_thread_local(key, value) -> None\n"
+ "\n"
+ "Set a value in the current thread-local dictionary. Debbuging only.\n");
+
+static PyObject*
+mod_set_thread_local(PyObject* UNUSED(module), PyObject* args)
+{
+ PyArgParseParam key;
+ PyArgParseParam value;
+ PyObject* result = NULL;
+
+ if (PyArg_UnpackTuple(args, "set_thread_local", 2, 2, &key, &value)) {
+ if(PyDict_SetItem(
+ PyThreadState_GetDict(), // borrow
+ key,
+ value) == 0 ) {
+ // success
+ Py_INCREF(Py_None);
+ result = Py_None;
+ }
+ }
+ return result;
+}
+
+PyDoc_STRVAR(mod_get_pending_cleanup_count_doc,
+ "get_pending_cleanup_count() -> Integer\n"
+ "\n"
+ "Get the number of greenlet cleanup operations pending. Testing only.\n");
+
+
+static PyObject*
+mod_get_pending_cleanup_count(PyObject* UNUSED(module))
+{
+ LockGuard cleanup_lock(*mod_globs->thread_states_to_destroy_lock);
+ return PyLong_FromSize_t(mod_globs->thread_states_to_destroy.size());
+}
+
+PyDoc_STRVAR(mod_get_total_main_greenlets_doc,
+ "get_total_main_greenlets() -> Integer\n"
+ "\n"
+ "Quickly return the number of main greenlets that exist. Testing only.\n");
+
+static PyObject*
+mod_get_total_main_greenlets(PyObject* UNUSED(module))
+{
+ return PyLong_FromSize_t(G_TOTAL_MAIN_GREENLETS);
+}
+
+PyDoc_STRVAR(mod_get_clocks_used_doing_optional_cleanup_doc,
+ "get_clocks_used_doing_optional_cleanup() -> Integer\n"
+ "\n"
+ "Get the number of clock ticks the program has used doing optional "
+ "greenlet cleanup.\n"
+ "Beginning in greenlet 2.0, greenlet tries to find and dispose of greenlets\n"
+ "that leaked after a thread exited. This requires invoking Python's garbage collector,\n"
+ "which may have a performance cost proportional to the number of live objects.\n"
+ "This function returns the amount of processor time\n"
+ "greenlet has used to do this. In programs that run with very large amounts of live\n"
+ "objects, this metric can be used to decide whether the cost of doing this cleanup\n"
+ "is worth the memory leak being corrected. If not, you can disable the cleanup\n"
+ "using ``enable_optional_cleanup(False)``.\n"
+ "The units are arbitrary and can only be compared to themselves (similarly to ``time.clock()``);\n"
+ "for example, to see how it scales with your heap. You can attempt to convert them into seconds\n"
+ "by dividing by the value of CLOCKS_PER_SEC."
+ "If cleanup has been disabled, returns None."
+ "\n"
+ "This is an implementation specific, provisional API. It may be changed or removed\n"
+ "in the future.\n"
+ ".. versionadded:: 2.0"
+ );
+static PyObject*
+mod_get_clocks_used_doing_optional_cleanup(PyObject* UNUSED(module))
+{
+ std::clock_t& clocks = ThreadState::clocks_used_doing_gc();
+
+ if (clocks == std::clock_t(-1)) {
+ Py_RETURN_NONE;
+ }
+ // This might not actually work on some implementations; clock_t
+ // is an opaque type.
+ return PyLong_FromSsize_t(clocks);
+}
+
+PyDoc_STRVAR(mod_enable_optional_cleanup_doc,
+ "mod_enable_optional_cleanup(bool) -> None\n"
+ "\n"
+ "Enable or disable optional cleanup operations.\n"
+ "See ``get_clocks_used_doing_optional_cleanup()`` for details.\n"
+ );
+static PyObject*
+mod_enable_optional_cleanup(PyObject* UNUSED(module), PyObject* flag)
+{
+ int is_true = PyObject_IsTrue(flag);
+ if (is_true == -1) {
+ return nullptr;
+ }
+
+ std::clock_t& clocks = ThreadState::clocks_used_doing_gc();
+ if (is_true) {
+ // If we already have a value, we don't want to lose it.
+ if (clocks == std::clock_t(-1)) {
+ clocks = 0;
+ }
+ }
+ else {
+ clocks = std::clock_t(-1);
+ }
+ Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(mod_get_tstate_trash_delete_nesting_doc,
+ "get_tstate_trash_delete_nesting() -> Integer\n"
+ "\n"
+ "Return the 'trash can' nesting level. Testing only.\n");
+static PyObject*
+mod_get_tstate_trash_delete_nesting(PyObject* UNUSED(module))
+{
+ PyThreadState* tstate = PyThreadState_GET();
+
+#if GREENLET_PY312
+ return PyLong_FromLong(tstate->trash.delete_nesting);
+#else
+ return PyLong_FromLong(tstate->trash_delete_nesting);
+#endif
+}
+
+static PyMethodDef GreenMethods[] = {
+ {"getcurrent",
+ (PyCFunction)mod_getcurrent,
+ METH_NOARGS,
+ mod_getcurrent_doc},
+ {"settrace", (PyCFunction)mod_settrace, METH_VARARGS, mod_settrace_doc},
+ {"gettrace", (PyCFunction)mod_gettrace, METH_NOARGS, mod_gettrace_doc},
+ {"set_thread_local", (PyCFunction)mod_set_thread_local, METH_VARARGS, mod_set_thread_local_doc},
+ {"get_pending_cleanup_count", (PyCFunction)mod_get_pending_cleanup_count, METH_NOARGS, mod_get_pending_cleanup_count_doc},
+ {"get_total_main_greenlets", (PyCFunction)mod_get_total_main_greenlets, METH_NOARGS, mod_get_total_main_greenlets_doc},
+ {"get_clocks_used_doing_optional_cleanup", (PyCFunction)mod_get_clocks_used_doing_optional_cleanup, METH_NOARGS, mod_get_clocks_used_doing_optional_cleanup_doc},
+ {"enable_optional_cleanup", (PyCFunction)mod_enable_optional_cleanup, METH_O, mod_enable_optional_cleanup_doc},
+ {"get_tstate_trash_delete_nesting", (PyCFunction)mod_get_tstate_trash_delete_nesting, METH_NOARGS, mod_get_tstate_trash_delete_nesting_doc},
+ {NULL, NULL} /* Sentinel */
+};
+
+static const char* const copy_on_greentype[] = {
+ "getcurrent",
+ "error",
+ "GreenletExit",
+ "settrace",
+ "gettrace",
+ NULL
+};
+
+static struct PyModuleDef greenlet_module_def = {
+ PyModuleDef_HEAD_INIT,
+ "greenlet._greenlet",
+ NULL,
+ -1,
+ GreenMethods,
+};
+
+
+
+static PyObject*
+greenlet_internal_mod_init() noexcept
+{
+ static void* _PyGreenlet_API[PyGreenlet_API_pointers];
+
+ try {
+ CreatedModule m(greenlet_module_def);
+
+ Require(PyType_Ready(&PyGreenlet_Type));
+ Require(PyType_Ready(&PyGreenletUnswitchable_Type));
+
+ mod_globs = new greenlet::GreenletGlobals;
+ ThreadState::init();
+
+ m.PyAddObject("greenlet", PyGreenlet_Type);
+ m.PyAddObject("UnswitchableGreenlet", PyGreenletUnswitchable_Type);
+ m.PyAddObject("error", mod_globs->PyExc_GreenletError);
+ m.PyAddObject("GreenletExit", mod_globs->PyExc_GreenletExit);
+
+ m.PyAddObject("GREENLET_USE_GC", 1);
+ m.PyAddObject("GREENLET_USE_TRACING", 1);
+ m.PyAddObject("GREENLET_USE_CONTEXT_VARS", 1L);
+ m.PyAddObject("GREENLET_USE_STANDARD_THREADING", 1L);
+
+ OwnedObject clocks_per_sec = OwnedObject::consuming(PyLong_FromSsize_t(CLOCKS_PER_SEC));
+ m.PyAddObject("CLOCKS_PER_SEC", clocks_per_sec);
+
+ /* also publish module-level data as attributes of the greentype. */
+ // XXX: This is weird, and enables a strange pattern of
+ // confusing the class greenlet with the module greenlet; with
+ // the exception of (possibly) ``getcurrent()``, this
+ // shouldn't be encouraged so don't add new items here.
+ for (const char* const* p = copy_on_greentype; *p; p++) {
+ OwnedObject o = m.PyRequireAttr(*p);
+ PyDict_SetItemString(PyGreenlet_Type.tp_dict, *p, o.borrow());
+ }
+
+ /*
+ * Expose C API
+ */
+
+ /* types */
+ _PyGreenlet_API[PyGreenlet_Type_NUM] = (void*)&PyGreenlet_Type;
+
+ /* exceptions */
+ _PyGreenlet_API[PyExc_GreenletError_NUM] = (void*)mod_globs->PyExc_GreenletError;
+ _PyGreenlet_API[PyExc_GreenletExit_NUM] = (void*)mod_globs->PyExc_GreenletExit;
+
+ /* methods */
+ _PyGreenlet_API[PyGreenlet_New_NUM] = (void*)PyGreenlet_New;
+ _PyGreenlet_API[PyGreenlet_GetCurrent_NUM] = (void*)PyGreenlet_GetCurrent;
+ _PyGreenlet_API[PyGreenlet_Throw_NUM] = (void*)PyGreenlet_Throw;
+ _PyGreenlet_API[PyGreenlet_Switch_NUM] = (void*)PyGreenlet_Switch;
+ _PyGreenlet_API[PyGreenlet_SetParent_NUM] = (void*)PyGreenlet_SetParent;
+
+ /* Previously macros, but now need to be functions externally. */
+ _PyGreenlet_API[PyGreenlet_MAIN_NUM] = (void*)Extern_PyGreenlet_MAIN;
+ _PyGreenlet_API[PyGreenlet_STARTED_NUM] = (void*)Extern_PyGreenlet_STARTED;
+ _PyGreenlet_API[PyGreenlet_ACTIVE_NUM] = (void*)Extern_PyGreenlet_ACTIVE;
+ _PyGreenlet_API[PyGreenlet_GET_PARENT_NUM] = (void*)Extern_PyGreenlet_GET_PARENT;
+
+ /* XXX: Note that our module name is ``greenlet._greenlet``, but for
+ backwards compatibility with existing C code, we need the _C_API to
+ be directly in greenlet.
+ */
+ const NewReference c_api_object(Require(
+ PyCapsule_New(
+ (void*)_PyGreenlet_API,
+ "greenlet._C_API",
+ NULL)));
+ m.PyAddObject("_C_API", c_api_object);
+ assert(c_api_object.REFCNT() == 2);
+
+ // cerr << "Sizes:"
+ // << "\n\tGreenlet : " << sizeof(Greenlet)
+ // << "\n\tUserGreenlet : " << sizeof(UserGreenlet)
+ // << "\n\tMainGreenlet : " << sizeof(MainGreenlet)
+ // << "\n\tExceptionState : " << sizeof(greenlet::ExceptionState)
+ // << "\n\tPythonState : " << sizeof(greenlet::PythonState)
+ // << "\n\tStackState : " << sizeof(greenlet::StackState)
+ // << "\n\tSwitchingArgs : " << sizeof(greenlet::SwitchingArgs)
+ // << "\n\tOwnedObject : " << sizeof(greenlet::refs::OwnedObject)
+ // << "\n\tBorrowedObject : " << sizeof(greenlet::refs::BorrowedObject)
+ // << "\n\tPyGreenlet : " << sizeof(PyGreenlet)
+ // << endl;
+
+ return m.borrow(); // But really it's the main reference.
+ }
+ catch (const LockInitError& e) {
+ PyErr_SetString(PyExc_MemoryError, e.what());
+ return NULL;
+ }
+ catch (const PyErrOccurred&) {
+ return NULL;
+ }
+
+}
+
+extern "C" {
+
+PyMODINIT_FUNC
+PyInit__greenlet(void)
+{
+ return greenlet_internal_mod_init();
+}
+
+}; // extern C
+
+#ifdef __clang__
+# pragma clang diagnostic pop
+#elif defined(__GNUC__)
+# pragma GCC diagnostic pop
+#endif
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet.h b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet.h
new file mode 100644
index 0000000000000000000000000000000000000000..d02a16e43426fb1c1bb286f1cda463cb9b1185ad
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet.h
@@ -0,0 +1,164 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+
+/* Greenlet object interface */
+
+#ifndef Py_GREENLETOBJECT_H
+#define Py_GREENLETOBJECT_H
+
+
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This is deprecated and undocumented. It does not change. */
+#define GREENLET_VERSION "1.0.0"
+
+#ifndef GREENLET_MODULE
+#define implementation_ptr_t void*
+#endif
+
+typedef struct _greenlet {
+ PyObject_HEAD
+ PyObject* weakreflist;
+ PyObject* dict;
+ implementation_ptr_t pimpl;
+} PyGreenlet;
+
+#define PyGreenlet_Check(op) (op && PyObject_TypeCheck(op, &PyGreenlet_Type))
+
+
+/* C API functions */
+
+/* Total number of symbols that are exported */
+#define PyGreenlet_API_pointers 12
+
+#define PyGreenlet_Type_NUM 0
+#define PyExc_GreenletError_NUM 1
+#define PyExc_GreenletExit_NUM 2
+
+#define PyGreenlet_New_NUM 3
+#define PyGreenlet_GetCurrent_NUM 4
+#define PyGreenlet_Throw_NUM 5
+#define PyGreenlet_Switch_NUM 6
+#define PyGreenlet_SetParent_NUM 7
+
+#define PyGreenlet_MAIN_NUM 8
+#define PyGreenlet_STARTED_NUM 9
+#define PyGreenlet_ACTIVE_NUM 10
+#define PyGreenlet_GET_PARENT_NUM 11
+
+#ifndef GREENLET_MODULE
+/* This section is used by modules that uses the greenlet C API */
+static void** _PyGreenlet_API = NULL;
+
+# define PyGreenlet_Type \
+ (*(PyTypeObject*)_PyGreenlet_API[PyGreenlet_Type_NUM])
+
+# define PyExc_GreenletError \
+ ((PyObject*)_PyGreenlet_API[PyExc_GreenletError_NUM])
+
+# define PyExc_GreenletExit \
+ ((PyObject*)_PyGreenlet_API[PyExc_GreenletExit_NUM])
+
+/*
+ * PyGreenlet_New(PyObject *args)
+ *
+ * greenlet.greenlet(run, parent=None)
+ */
+# define PyGreenlet_New \
+ (*(PyGreenlet * (*)(PyObject * run, PyGreenlet * parent)) \
+ _PyGreenlet_API[PyGreenlet_New_NUM])
+
+/*
+ * PyGreenlet_GetCurrent(void)
+ *
+ * greenlet.getcurrent()
+ */
+# define PyGreenlet_GetCurrent \
+ (*(PyGreenlet * (*)(void)) _PyGreenlet_API[PyGreenlet_GetCurrent_NUM])
+
+/*
+ * PyGreenlet_Throw(
+ * PyGreenlet *greenlet,
+ * PyObject *typ,
+ * PyObject *val,
+ * PyObject *tb)
+ *
+ * g.throw(...)
+ */
+# define PyGreenlet_Throw \
+ (*(PyObject * (*)(PyGreenlet * self, \
+ PyObject * typ, \
+ PyObject * val, \
+ PyObject * tb)) \
+ _PyGreenlet_API[PyGreenlet_Throw_NUM])
+
+/*
+ * PyGreenlet_Switch(PyGreenlet *greenlet, PyObject *args)
+ *
+ * g.switch(*args, **kwargs)
+ */
+# define PyGreenlet_Switch \
+ (*(PyObject * \
+ (*)(PyGreenlet * greenlet, PyObject * args, PyObject * kwargs)) \
+ _PyGreenlet_API[PyGreenlet_Switch_NUM])
+
+/*
+ * PyGreenlet_SetParent(PyObject *greenlet, PyObject *new_parent)
+ *
+ * g.parent = new_parent
+ */
+# define PyGreenlet_SetParent \
+ (*(int (*)(PyGreenlet * greenlet, PyGreenlet * nparent)) \
+ _PyGreenlet_API[PyGreenlet_SetParent_NUM])
+
+/*
+ * PyGreenlet_GetParent(PyObject* greenlet)
+ *
+ * return greenlet.parent;
+ *
+ * This could return NULL even if there is no exception active.
+ * If it does not return NULL, you are responsible for decrementing the
+ * reference count.
+ */
+# define PyGreenlet_GetParent \
+ (*(PyGreenlet* (*)(PyGreenlet*)) \
+ _PyGreenlet_API[PyGreenlet_GET_PARENT_NUM])
+
+/*
+ * deprecated, undocumented alias.
+ */
+# define PyGreenlet_GET_PARENT PyGreenlet_GetParent
+
+# define PyGreenlet_MAIN \
+ (*(int (*)(PyGreenlet*)) \
+ _PyGreenlet_API[PyGreenlet_MAIN_NUM])
+
+# define PyGreenlet_STARTED \
+ (*(int (*)(PyGreenlet*)) \
+ _PyGreenlet_API[PyGreenlet_STARTED_NUM])
+
+# define PyGreenlet_ACTIVE \
+ (*(int (*)(PyGreenlet*)) \
+ _PyGreenlet_API[PyGreenlet_ACTIVE_NUM])
+
+
+
+
+/* Macro that imports greenlet and initializes C API */
+/* NOTE: This has actually moved to ``greenlet._greenlet._C_API``, but we
+ keep the older definition to be sure older code that might have a copy of
+ the header still works. */
+# define PyGreenlet_Import() \
+ { \
+ _PyGreenlet_API = (void**)PyCapsule_Import("greenlet._C_API", 0); \
+ }
+
+#endif /* GREENLET_MODULE */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_GREENLETOBJECT_H */
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_allocator.hpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_allocator.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b452f5444262fb3553bee15c4692e06d7fac549c
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_allocator.hpp
@@ -0,0 +1,63 @@
+#ifndef GREENLET_ALLOCATOR_HPP
+#define GREENLET_ALLOCATOR_HPP
+
+#define PY_SSIZE_T_CLEAN
+#include
+#include
+#include "greenlet_compiler_compat.hpp"
+
+
+namespace greenlet
+{
+ // This allocator is stateless; all instances are identical.
+ // It can *ONLY* be used when we're sure we're holding the GIL
+ // (Python's allocators require the GIL).
+ template
+ struct PythonAllocator : public std::allocator {
+
+ PythonAllocator(const PythonAllocator& UNUSED(other))
+ : std::allocator()
+ {
+ }
+
+ PythonAllocator(const std::allocator other)
+ : std::allocator(other)
+ {}
+
+ template
+ PythonAllocator(const std::allocator& other)
+ : std::allocator(other)
+ {
+ }
+
+ PythonAllocator() : std::allocator() {}
+
+ T* allocate(size_t number_objects, const void* UNUSED(hint)=0)
+ {
+ void* p;
+ if (number_objects == 1)
+ p = PyObject_Malloc(sizeof(T));
+ else
+ p = PyMem_Malloc(sizeof(T) * number_objects);
+ return static_cast(p);
+ }
+
+ void deallocate(T* t, size_t n)
+ {
+ void* p = t;
+ if (n == 1) {
+ PyObject_Free(p);
+ }
+ else
+ PyMem_Free(p);
+ }
+ // This member is deprecated in C++17 and removed in C++20
+ template< class U >
+ struct rebind {
+ typedef PythonAllocator other;
+ };
+
+ };
+}
+
+#endif
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_compiler_compat.hpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_compiler_compat.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ee5bbdd20541578e94730a88c8bef2c2ca1b4e95
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_compiler_compat.hpp
@@ -0,0 +1,95 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+#ifndef GREENLET_COMPILER_COMPAT_HPP
+#define GREENLET_COMPILER_COMPAT_HPP
+
+/**
+ * Definitions to aid with compatibility with different compilers.
+ *
+ * .. caution:: Use extreme care with noexcept.
+ * Some compilers and runtimes, specifically gcc/libgcc/libstdc++ on
+ * Linux, implement stack unwinding by throwing an uncatchable
+ * exception, one that specifically does not appear to be an active
+ * exception to the rest of the runtime. If this happens while we're in a noexcept function,
+ * we have violated our dynamic exception contract, and so the runtime
+ * will call std::terminate(), which kills the process with the
+ * unhelpful message "terminate called without an active exception".
+ *
+ * This has happened in this scenario: A background thread is running
+ * a greenlet that has made a native call and released the GIL.
+ * Meanwhile, the main thread finishes and starts shutting down the
+ * interpreter. When the background thread is scheduled again and
+ * attempts to obtain the GIL, it notices that the interpreter is
+ * exiting and calls ``pthread_exit()``. This in turn starts to unwind
+ * the stack by throwing that exception. But we had the ``PyCall``
+ * functions annotated as noexcept, so the runtime terminated us.
+ *
+ * #2 0x00007fab26fec2b7 in std::terminate() () from /lib/x86_64-linux-gnu/libstdc++.so.6
+ * #3 0x00007fab26febb3c in __gxx_personality_v0 () from /lib/x86_64-linux-gnu/libstdc++.so.6
+ * #4 0x00007fab26f34de6 in ?? () from /lib/x86_64-linux-gnu/libgcc_s.so.1
+ * #6 0x00007fab276a34c6 in __GI___pthread_unwind at ./nptl/unwind.c:130
+ * #7 0x00007fab2769bd3a in __do_cancel () at ../sysdeps/nptl/pthreadP.h:280
+ * #8 __GI___pthread_exit (value=value@entry=0x0) at ./nptl/pthread_exit.c:36
+ * #9 0x000000000052e567 in PyThread_exit_thread () at ../Python/thread_pthread.h:370
+ * #10 0x00000000004d60b5 in take_gil at ../Python/ceval_gil.h:224
+ * #11 0x00000000004d65f9 in PyEval_RestoreThread at ../Python/ceval.c:467
+ * #12 0x000000000060cce3 in setipaddr at ../Modules/socketmodule.c:1203
+ * #13 0x00000000006101cd in socket_gethostbyname
+ */
+
+#include
+
+# if defined(__clang__)
+# define G_FP_TMPL_STATIC static
+# else
+// GCC has no problem allowing static function pointers, but emits
+// tons of warnings about "whose type uses the anonymous namespace [-Wsubobject-linkage]"
+# define G_FP_TMPL_STATIC
+# endif
+
+# define G_NO_COPIES_OF_CLS(Cls) private: \
+ Cls(const Cls& other) = delete; \
+ Cls& operator=(const Cls& other) = delete
+
+# define G_NO_ASSIGNMENT_OF_CLS(Cls) private: \
+ Cls& operator=(const Cls& other) = delete
+
+# define G_NO_COPY_CONSTRUCTOR_OF_CLS(Cls) private: \
+ Cls(const Cls& other) = delete;
+
+
+// CAUTION: MSVC is stupidly picky:
+//
+// "The compiler ignores, without warning, any __declspec keywords
+// placed after * or & and in front of the variable identifier in a
+// declaration."
+// (https://docs.microsoft.com/en-us/cpp/cpp/declspec?view=msvc-160)
+//
+// So pointer return types must be handled differently (because of the
+// trailing *), or you get inscrutable compiler warnings like "error
+// C2059: syntax error: ''"
+//
+// In C++ 11, there is a standard syntax for attributes, and
+// GCC defines an attribute to use with this: [[gnu:noinline]].
+// In the future, this is expected to become standard.
+
+#if defined(__GNUC__) || defined(__clang__)
+/* We used to check for GCC 4+ or 3.4+, but those compilers are
+ laughably out of date. Just assume they support it. */
+# define GREENLET_NOINLINE(name) __attribute__((noinline)) name
+# define GREENLET_NOINLINE_P(rtype, name) rtype __attribute__((noinline)) name
+# define UNUSED(x) UNUSED_ ## x __attribute__((__unused__))
+#elif defined(_MSC_VER)
+/* We used to check for && (_MSC_VER >= 1300) but that's also out of date. */
+# define GREENLET_NOINLINE(name) __declspec(noinline) name
+# define GREENLET_NOINLINE_P(rtype, name) __declspec(noinline) rtype name
+# define UNUSED(x) UNUSED_ ## x
+#endif
+
+#if defined(_MSC_VER)
+# define G_NOEXCEPT_WIN32 noexcept
+#else
+# define G_NOEXCEPT_WIN32
+#endif
+
+
+#endif
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_cpython_add_pending.hpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_cpython_add_pending.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..0d28efd3d2b045558497f9981d33c94a777f73b7
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_cpython_add_pending.hpp
@@ -0,0 +1,172 @@
+#ifndef GREENLET_CPYTHON_ADD_PENDING_HPP
+#define GREENLET_CPYTHON_ADD_PENDING_HPP
+
+#if (PY_VERSION_HEX >= 0x30800A0 && PY_VERSION_HEX < 0x3090000) && !(defined(_WIN32) || defined(WIN32))
+// XXX: From Python 3.8a3 [1] up until Python 3.9a6 [2][3],
+// ``Py_AddPendingCall`` would try to produce a Python exception if
+// the interpreter was in the beginning of shutting down when this
+// function is called. However, ``Py_AddPendingCall`` doesn't require
+// the GIL, and we are absolutely not holding it when we make that
+// call. That means that trying to create the Python exception is
+// using the C API in an undefined state; here the C API detects this
+// and aborts the process with an error ("Fatal Python error: Python
+// memory allocator called without holding the GIL": Add ->
+// PyErr_SetString -> PyUnicode_New -> PyObject_Malloc). This arises
+// (obviously) in multi-threaded programs and happens if one thread is
+// exiting and cleaning up its thread-local data while the other
+// thread is trying to shut down the interpreter. A crash on shutdown
+// is still a crash and could result in data loss (e.g., daemon
+// threads are still running, pending signal handlers may be present,
+// buffers may not be flushed, there may be __del__ that need run,
+// etc), so we have to work around it.
+//
+// Of course, we can (and do) check for whether the interpreter is
+// shutting down before calling ``Py_AddPendingCall``, but that's a
+// race condition since we don't hold the GIL, and so we may not
+// actually get the right answer. Plus, ``Py_FinalizeEx`` actually
+// calls ``_Py_FinishPendingCalls`` (which sets the pending->finishing
+// flag, which is used to gate creating the exceptioen) *before*
+// publishing any other data that would let us detect the shutdown
+// (such as runtime->finalizing). So that point is moot.
+//
+// Our solution for those versions is to inline the same code, without
+// the problematic bit that sets the exception. Unfortunately, all of
+// the structure definitions are private/opaque, *and* we can't
+// actually count on being able to include their definitions from
+// ``internal/pycore_*``, because on some platforms those header files
+// are incomplete (i.e., on macOS with macports 3.8, the includes are
+// fine, but on Ubuntu jammy with 3.8 from ppa:deadsnakes or GitHub
+// Actions 3.8 (I think it's Ubuntu 18.04), they con't be used; at
+// least, I couldn't get them to work). So we need to define the
+// structures and _PyRuntime data member ourself. Yet more
+// unfortunately, _PyRuntime won't link on Windows, so we can only do
+// this on other platforms.
+//
+// [1] https://github.com/python/cpython/commit/842a2f07f2f08a935ef470bfdaeef40f87490cfc
+// [2] https://github.com/python/cpython/commit/cfc3c2f8b34d3864717ab584c5b6c260014ba55a
+// [3] https://github.com/python/cpython/issues/81308
+# define GREENLET_BROKEN_PY_ADD_PENDING 1
+
+// When defining these structures, the important thing is to get
+// binary compatibility, i.e., structure layout. For that, we only
+// need to define fields up to the ones we use; after that they're
+// irrelevant UNLESS the structure is included in another structure
+// *before* the structure we're interested in --- in that case, it
+// must be complete. Ellipsis indicate elided trailing members.
+// Pointer types are changed to void* to keep from having to define
+// more structures.
+
+// From "internal/pycore_atomic.h"
+
+// There are several different definitions of this, including the
+// plain ``int`` version, a ``volatile int`` and an ``_Atomic int``
+// I don't think any of those change the size/layout.
+typedef struct _Py_atomic_int {
+ volatile int _value;
+} _Py_atomic_int;
+
+// This needs too much infrastructure, so we just do a regular store.
+#define _Py_atomic_store_relaxed(ATOMIC_VAL, NEW_VAL) \
+ (ATOMIC_VAL)->_value = NEW_VAL
+
+
+
+// From "internal/pycore_pymem.h"
+#define NUM_GENERATIONS 3
+
+
+struct gc_generation {
+ PyGC_Head head; // We already have this defined.
+ int threshold;
+ int count;
+};
+struct gc_generation_stats {
+ Py_ssize_t collections;
+ Py_ssize_t collected;
+ Py_ssize_t uncollectable;
+};
+
+struct _gc_runtime_state {
+ void *trash_delete_later;
+ int trash_delete_nesting;
+ int enabled;
+ int debug;
+ struct gc_generation generations[NUM_GENERATIONS];
+ void *generation0;
+ struct gc_generation permanent_generation;
+ struct gc_generation_stats generation_stats[NUM_GENERATIONS];
+ int collecting;
+ void *garbage;
+ void *callbacks;
+ Py_ssize_t long_lived_total;
+ Py_ssize_t long_lived_pending;
+};
+
+// From "internal/pycore_pystate.h"
+struct _pending_calls {
+ int finishing;
+ PyThread_type_lock lock;
+ _Py_atomic_int calls_to_do;
+ int async_exc;
+#define NPENDINGCALLS 32
+ struct {
+ int (*func)(void *);
+ void *arg;
+ } calls[NPENDINGCALLS];
+ int first;
+ int last;
+};
+
+struct _ceval_runtime_state {
+ int recursion_limit;
+ int tracing_possible;
+ _Py_atomic_int eval_breaker;
+ _Py_atomic_int gil_drop_request;
+ struct _pending_calls pending;
+ // ...
+};
+
+typedef struct pyruntimestate {
+ int preinitializing;
+ int preinitialized;
+ int core_initialized;
+ int initialized;
+ void *finalizing;
+
+ struct pyinterpreters {
+ PyThread_type_lock mutex;
+ void *head;
+ void *main;
+ int64_t next_id;
+ } interpreters;
+ // XXX Remove this field once we have a tp_* slot.
+ struct _xidregistry {
+ PyThread_type_lock mutex;
+ void *head;
+ } xidregistry;
+
+ unsigned long main_thread;
+
+#define NEXITFUNCS 32
+ void (*exitfuncs[NEXITFUNCS])(void);
+ int nexitfuncs;
+
+ struct _gc_runtime_state gc;
+ struct _ceval_runtime_state ceval;
+ // ...
+} _PyRuntimeState;
+
+#define SIGNAL_PENDING_CALLS(ceval) \
+ do { \
+ _Py_atomic_store_relaxed(&(ceval)->pending.calls_to_do, 1); \
+ _Py_atomic_store_relaxed(&(ceval)->eval_breaker, 1); \
+ } while (0)
+
+extern _PyRuntimeState _PyRuntime;
+
+#else
+# define GREENLET_BROKEN_PY_ADD_PENDING 0
+#endif
+
+
+#endif
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_cpython_compat.hpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_cpython_compat.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..cdc1617f6788957cc575e852dcdb9a917e07ee54
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_cpython_compat.hpp
@@ -0,0 +1,127 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+#ifndef GREENLET_CPYTHON_COMPAT_H
+#define GREENLET_CPYTHON_COMPAT_H
+
+/**
+ * Helpers for compatibility with multiple versions of CPython.
+ */
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+
+
+#if PY_VERSION_HEX >= 0x30A00B1
+# define GREENLET_PY310 1
+/*
+Python 3.10 beta 1 changed tstate->use_tracing to a nested cframe member.
+See https://github.com/python/cpython/pull/25276
+We have to save and restore this as well.
+*/
+# define GREENLET_USE_CFRAME 1
+#else
+# define GREENLET_USE_CFRAME 0
+# define GREENLET_PY310 0
+#endif
+
+
+
+#if PY_VERSION_HEX >= 0x30B00A4
+/*
+Greenlet won't compile on anything older than Python 3.11 alpha 4 (see
+https://bugs.python.org/issue46090). Summary of breaking internal changes:
+- Python 3.11 alpha 1 changed how frame objects are represented internally.
+ - https://github.com/python/cpython/pull/30122
+- Python 3.11 alpha 3 changed how recursion limits are stored.
+ - https://github.com/python/cpython/pull/29524
+- Python 3.11 alpha 4 changed how exception state is stored. It also includes a
+ change to help greenlet save and restore the interpreter frame "data stack".
+ - https://github.com/python/cpython/pull/30122
+ - https://github.com/python/cpython/pull/30234
+*/
+# define GREENLET_PY311 1
+#else
+# define GREENLET_PY311 0
+#endif
+
+
+#if PY_VERSION_HEX >= 0x30C0000
+# define GREENLET_PY312 1
+#else
+# define GREENLET_PY312 0
+#endif
+
+#ifndef Py_SET_REFCNT
+/* Py_REFCNT and Py_SIZE macros are converted to functions
+https://bugs.python.org/issue39573 */
+# define Py_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
+#endif
+
+#ifndef _Py_DEC_REFTOTAL
+/* _Py_DEC_REFTOTAL macro has been removed from Python 3.9 by:
+ https://github.com/python/cpython/commit/49932fec62c616ec88da52642339d83ae719e924
+
+ The symbol we use to replace it was removed by at least 3.12.
+*/
+# ifdef Py_REF_DEBUG
+# if GREENLET_PY312
+# define _Py_DEC_REFTOTAL
+# else
+# define _Py_DEC_REFTOTAL _Py_RefTotal--
+# endif
+# else
+# define _Py_DEC_REFTOTAL
+# endif
+#endif
+// Define these flags like Cython does if we're on an old version.
+#ifndef Py_TPFLAGS_CHECKTYPES
+ #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+ #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+ #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+
+#ifndef Py_TPFLAGS_HAVE_VERSION_TAG
+ #define Py_TPFLAGS_HAVE_VERSION_TAG 0
+#endif
+
+#define G_TPFLAGS_DEFAULT Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_VERSION_TAG | Py_TPFLAGS_CHECKTYPES | Py_TPFLAGS_HAVE_NEWBUFFER | Py_TPFLAGS_HAVE_GC
+
+
+#if PY_VERSION_HEX < 0x03090000
+// The official version only became available in 3.9
+# define PyObject_GC_IsTracked(o) _PyObject_GC_IS_TRACKED(o)
+#endif
+
+
+// bpo-43760 added PyThreadState_EnterTracing() to Python 3.11.0a2
+#if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION)
+static inline void PyThreadState_EnterTracing(PyThreadState *tstate)
+{
+ tstate->tracing++;
+#if PY_VERSION_HEX >= 0x030A00A1
+ tstate->cframe->use_tracing = 0;
+#else
+ tstate->use_tracing = 0;
+#endif
+}
+#endif
+
+// bpo-43760 added PyThreadState_LeaveTracing() to Python 3.11.0a2
+#if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION)
+static inline void PyThreadState_LeaveTracing(PyThreadState *tstate)
+{
+ tstate->tracing--;
+ int use_tracing = (tstate->c_tracefunc != NULL
+ || tstate->c_profilefunc != NULL);
+#if PY_VERSION_HEX >= 0x030A00A1
+ tstate->cframe->use_tracing = use_tracing;
+#else
+ tstate->use_tracing = use_tracing;
+#endif
+}
+#endif
+
+#endif /* GREENLET_CPYTHON_COMPAT_H */
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_exceptions.hpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_exceptions.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..3807018bdc6dedbd808afc9d197b29ba5733a7fa
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_exceptions.hpp
@@ -0,0 +1,150 @@
+#ifndef GREENLET_EXCEPTIONS_HPP
+#define GREENLET_EXCEPTIONS_HPP
+
+#define PY_SSIZE_T_CLEAN
+#include
+#include
+#include
+
+#ifdef __clang__
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+namespace greenlet {
+
+ class PyErrOccurred : public std::runtime_error
+ {
+ public:
+
+ // CAUTION: In debug builds, may run arbitrary Python code.
+ static const PyErrOccurred
+ from_current()
+ {
+ assert(PyErr_Occurred());
+#ifndef NDEBUG
+ // This is not exception safe, and
+ // not necessarily safe in general (what if it switches?)
+ // But we only do this in debug mode, where we are in
+ // tight control of what exceptions are getting raised and
+ // can prevent those issues.
+
+ // You can't call PyObject_Str with a pending exception.
+ PyObject* typ;
+ PyObject* val;
+ PyObject* tb;
+
+ PyErr_Fetch(&typ, &val, &tb);
+ PyObject* typs = PyObject_Str(typ);
+ PyObject* vals = PyObject_Str(val ? val : typ);
+ const char* typ_msg = PyUnicode_AsUTF8(typs);
+ const char* val_msg = PyUnicode_AsUTF8(vals);
+ PyErr_Restore(typ, val, tb);
+
+ std::string msg(typ_msg);
+ msg += ": ";
+ msg += val_msg;
+ PyErrOccurred ex(msg);
+ Py_XDECREF(typs);
+ Py_XDECREF(vals);
+
+ return ex;
+#else
+ return PyErrOccurred();
+#endif
+ }
+
+ PyErrOccurred() : std::runtime_error("")
+ {
+ assert(PyErr_Occurred());
+ }
+
+ PyErrOccurred(const std::string& msg) : std::runtime_error(msg)
+ {
+ assert(PyErr_Occurred());
+ }
+
+ PyErrOccurred(PyObject* exc_kind, const char* const msg)
+ : std::runtime_error(msg)
+ {
+ PyErr_SetString(exc_kind, msg);
+ }
+
+ PyErrOccurred(PyObject* exc_kind, const std::string msg)
+ : std::runtime_error(msg)
+ {
+ // This copies the c_str, so we don't have any lifetime
+ // issues to worry about.
+ PyErr_SetString(exc_kind, msg.c_str());
+ }
+ };
+
+ class TypeError : public PyErrOccurred
+ {
+ public:
+ TypeError(const char* const what)
+ : PyErrOccurred(PyExc_TypeError, what)
+ {
+ }
+ TypeError(const std::string what)
+ : PyErrOccurred(PyExc_TypeError, what)
+ {
+ }
+ };
+
+ class ValueError : public PyErrOccurred
+ {
+ public:
+ ValueError(const char* const what)
+ : PyErrOccurred(PyExc_ValueError, what)
+ {
+ }
+ };
+
+ class AttributeError : public PyErrOccurred
+ {
+ public:
+ AttributeError(const char* const what)
+ : PyErrOccurred(PyExc_AttributeError, what)
+ {
+ }
+ };
+
+ /**
+ * Calls `Py_FatalError` when constructed, so you can't actually
+ * throw this. It just makes static analysis easier.
+ */
+ class PyFatalError : public std::runtime_error
+ {
+ public:
+ PyFatalError(const char* const msg)
+ : std::runtime_error(msg)
+ {
+ Py_FatalError(msg);
+ }
+ };
+
+ static inline PyObject*
+ Require(PyObject* p, const std::string& msg="")
+ {
+ if (!p) {
+ throw PyErrOccurred(msg);
+ }
+ return p;
+ };
+
+ static inline void
+ Require(const int retval)
+ {
+ if (retval < 0) {
+ throw PyErrOccurred();
+ }
+ };
+
+
+};
+#ifdef __clang__
+# pragma clang diagnostic pop
+#endif
+
+#endif
diff --git a/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_greenlet.hpp b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_greenlet.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..d52ce1fddeab27d1e27e3ce72d771b72f1258515
--- /dev/null
+++ b/pgsql/pgAdmin 4/python/Lib/site-packages/greenlet/greenlet_greenlet.hpp
@@ -0,0 +1,805 @@
+#ifndef GREENLET_GREENLET_HPP
+#define GREENLET_GREENLET_HPP
+/*
+ * Declarations of the core data structures.
+*/
+
+#define PY_SSIZE_T_CLEAN
+#include
+
+#include "greenlet_compiler_compat.hpp"
+#include "greenlet_refs.hpp"
+#include "greenlet_cpython_compat.hpp"
+#include "greenlet_allocator.hpp"
+
+using greenlet::refs::OwnedObject;
+using greenlet::refs::OwnedGreenlet;
+using greenlet::refs::OwnedMainGreenlet;
+using greenlet::refs::BorrowedGreenlet;
+
+#if PY_VERSION_HEX < 0x30B00A6
+# define _PyCFrame CFrame
+# define _PyInterpreterFrame _interpreter_frame
+#endif
+
+#if GREENLET_PY312
+# include "internal/pycore_frame.h"
+#endif
+
+// XXX: TODO: Work to remove all virtual functions
+// for speed of calling and size of objects (no vtable).
+// One pattern is the Curiously Recurring Template
+namespace greenlet
+{
+ class ExceptionState
+ {
+ private:
+ G_NO_COPIES_OF_CLS(ExceptionState);
+
+ // Even though these are borrowed objects, we actually own
+ // them, when they're not null.
+ // XXX: Express that in the API.
+ private:
+ _PyErr_StackItem* exc_info;
+ _PyErr_StackItem exc_state;
+ public:
+ ExceptionState();
+ void operator<<(const PyThreadState *const tstate) noexcept;
+ void operator>>(PyThreadState* tstate) noexcept;
+ void clear() noexcept;
+
+ int tp_traverse(visitproc visit, void* arg) noexcept;
+ void tp_clear() noexcept;
+ };
+
+ template
+ void operator<<(const PyThreadState *const tstate, T& exc);
+
+ class PythonStateContext
+ {
+ protected:
+ greenlet::refs::OwnedContext _context;
+ public:
+ inline const greenlet::refs::OwnedContext& context() const
+ {
+ return this->_context;
+ }
+ inline greenlet::refs::OwnedContext& context()
+ {
+ return this->_context;
+ }
+
+ inline void tp_clear()
+ {
+ this->_context.CLEAR();
+ }
+
+ template
+ inline static PyObject* context(T* tstate)
+ {
+ return tstate->context;
+ }
+
+ template
+ inline static void context(T* tstate, PyObject* new_context)
+ {
+ tstate->context = new_context;
+ tstate->context_ver++;
+ }
+ };
+ class SwitchingArgs;
+ class PythonState : public PythonStateContext
+ {
+ public:
+ typedef greenlet::refs::OwnedReference OwnedFrame;
+ private:
+ G_NO_COPIES_OF_CLS(PythonState);
+ // We own this if we're suspended (although currently we don't
+ // tp_traverse into it; that's a TODO). If we're running, it's
+ // empty. If we get deallocated and *still* have a frame, it
+ // won't be reachable from the place that normally decref's
+ // it, so we need to do it (hence owning it).
+ OwnedFrame _top_frame;
+#if GREENLET_USE_CFRAME
+ _PyCFrame* cframe;
+ int use_tracing;
+#endif
+#if GREENLET_PY312
+ int py_recursion_depth;
+ int c_recursion_depth;
+#else
+ int recursion_depth;
+#endif
+ int trash_delete_nesting;
+#if GREENLET_PY311
+ _PyInterpreterFrame* current_frame;
+ _PyStackChunk* datastack_chunk;
+ PyObject** datastack_top;
+ PyObject** datastack_limit;
+#endif
+ // The PyInterpreterFrame list on 3.12+ contains some entries that are
+ // on the C stack, which can't be directly accessed while a greenlet is
+ // suspended. In order to keep greenlet gr_frame introspection working,
+ // we adjust stack switching to rewrite the interpreter frame list
+ // to skip these C-stack frames; we call this "exposing" the greenlet's
+ // frames because it makes them valid to work with in Python. Then when
+ // the greenlet is resumed we need to remember to reverse the operation
+ // we did. The C-stack frames are "entry frames" which are a low-level
+ // interpreter detail; they're not needed for introspection, but do
+ // need to be present for the eval loop to work.
+ void unexpose_frames();
+
+ public:
+
+ PythonState();
+ // You can use this for testing whether we have a frame
+ // or not. It returns const so they can't modify it.
+ const OwnedFrame& top_frame() const noexcept;
+
+ inline void operator<<(const PyThreadState *const tstate) noexcept;
+ inline void operator>>(PyThreadState* tstate) noexcept;
+ void clear() noexcept;
+
+ int tp_traverse(visitproc visit, void* arg, bool visit_top_frame) noexcept;
+ void tp_clear(bool own_top_frame) noexcept;
+ void set_initial_state(const PyThreadState* const tstate) noexcept;
+#if GREENLET_USE_CFRAME
+ void set_new_cframe(_PyCFrame& frame) noexcept;
+#endif
+
+ inline void may_switch_away() noexcept;
+ inline void will_switch_from(PyThreadState *const origin_tstate) noexcept;
+ void did_finish(PyThreadState* tstate) noexcept;
+ };
+
+ class StackState
+ {
+ // By having only plain C (POD) members, no virtual functions
+ // or bases, we get a trivial assignment operator generated
+ // for us. However, that's not safe since we do manage memory.
+ // So we declare an assignment operator that only works if we
+ // don't have any memory allocated. (We don't use
+ // std::shared_ptr for reference counting just to keep this
+ // object small)
+ private:
+ char* _stack_start;
+ char* stack_stop;
+ char* stack_copy;
+ intptr_t _stack_saved;
+ StackState* stack_prev;
+ inline int copy_stack_to_heap_up_to(const char* const stop) noexcept;
+ inline void free_stack_copy() noexcept;
+
+ public:
+ /**
+ * Creates a started, but inactive, state, using *current*
+ * as the previous.
+ */
+ StackState(void* mark, StackState& current);
+ /**
+ * Creates an inactive, unstarted, state.
+ */
+ StackState();
+ ~StackState();
+ StackState(const StackState& other);
+ StackState& operator=(const StackState& other);
+ inline void copy_heap_to_stack(const StackState& current) noexcept;
+ inline int copy_stack_to_heap(char* const stackref, const StackState& current) noexcept;
+ inline bool started() const noexcept;
+ inline bool main() const noexcept;
+ inline bool active() const noexcept;
+ inline void set_active() noexcept;
+ inline void set_inactive() noexcept;
+ inline intptr_t stack_saved() const noexcept;
+ inline char* stack_start() const noexcept;
+ static inline StackState make_main() noexcept;
+#ifdef GREENLET_USE_STDIO
+ friend std::ostream& operator<<(std::ostream& os, const StackState& s);
+#endif
+
+ // Fill in [dest, dest + n) with the values that would be at
+ // [src, src + n) while this greenlet is running. This is like memcpy
+ // except that if the greenlet is suspended it accounts for the portion
+ // of the greenlet's stack that was spilled to the heap. `src` may
+ // be on this greenlet's stack, or on the heap, but not on a different
+ // greenlet's stack.
+ void copy_from_stack(void* dest, const void* src, size_t n) const;
+ };
+#ifdef GREENLET_USE_STDIO
+ std::ostream& operator<<(std::ostream& os, const StackState& s);
+#endif
+
+ class SwitchingArgs
+ {
+ private:
+ G_NO_ASSIGNMENT_OF_CLS(SwitchingArgs);
+ // If args and kwargs are both false (NULL), this is a *throw*, not a
+ // switch. PyErr_... must have been called already.
+ OwnedObject _args;
+ OwnedObject _kwargs;
+ public:
+
+ SwitchingArgs()
+ {}
+
+ SwitchingArgs(const OwnedObject& args, const OwnedObject& kwargs)
+ : _args(args),
+ _kwargs(kwargs)
+ {}
+
+ SwitchingArgs(const SwitchingArgs& other)
+ : _args(other._args),
+ _kwargs(other._kwargs)
+ {}
+
+ const OwnedObject& args()
+ {
+ return this->_args;
+ }
+
+ const OwnedObject& kwargs()
+ {
+ return this->_kwargs;
+ }
+
+ /**
+ * Moves ownership from the argument to this object.
+ */
+ SwitchingArgs& operator<<=(SwitchingArgs& other)
+ {
+ if (this != &other) {
+ this->_args = other._args;
+ this->_kwargs = other._kwargs;
+ other.CLEAR();
+ }
+ return *this;
+ }
+
+ /**
+ * Acquires ownership of the argument (consumes the reference).
+ */
+ SwitchingArgs& operator<<=(PyObject* args)
+ {
+ this->_args = OwnedObject::consuming(args);
+ this->_kwargs.CLEAR();
+ return *this;
+ }
+
+ /**
+ * Acquires ownership of the argument.
+ *
+ * Sets the args to be the given value; clears the kwargs.
+ */
+ SwitchingArgs& operator<<=(OwnedObject& args)
+ {
+ assert(&args != &this->_args);
+ this->_args = args;
+ this->_kwargs.CLEAR();
+ args.CLEAR();
+
+ return *this;
+ }
+
+ explicit operator bool() const noexcept
+ {
+ return this->_args || this->_kwargs;
+ }
+
+ inline void CLEAR()
+ {
+ this->_args.CLEAR();
+ this->_kwargs.CLEAR();
+ }
+
+ const std::string as_str() const noexcept
+ {
+ return PyUnicode_AsUTF8(
+ OwnedObject::consuming(
+ PyUnicode_FromFormat(
+ "SwitchingArgs(args=%R, kwargs=%R)",
+ this->_args.borrow(),
+ this->_kwargs.borrow()
+ )
+ ).borrow()
+ );
+ }
+ };
+
+ class ThreadState;
+
+ class UserGreenlet;
+ class MainGreenlet;
+
+ class Greenlet
+ {
+ private:
+ G_NO_COPIES_OF_CLS(Greenlet);
+ private:
+ // XXX: Work to remove these.
+ friend class ThreadState;
+ friend class UserGreenlet;
+ friend class MainGreenlet;
+ protected:
+ ExceptionState exception_state;
+ SwitchingArgs switch_args;
+ StackState stack_state;
+ PythonState python_state;
+ Greenlet(PyGreenlet* p, const StackState& initial_state);
+ public:
+ Greenlet(PyGreenlet* p);
+ virtual ~Greenlet();
+
+ const OwnedObject context() const;
+
+ // You MUST call this _very_ early in the switching process to
+ // prepare anything that may need prepared. This might perform
+ // garbage collections or otherwise run arbitrary Python code.
+ //
+ // One specific use of it is for Python 3.11+, preventing
+ // running arbitrary code at unsafe times. See
+ // PythonState::may_switch_away().
+ inline void may_switch_away()
+ {
+ this->python_state.may_switch_away();
+ }
+
+ inline void context(refs::BorrowedObject new_context);
+
+ inline SwitchingArgs& args()
+ {
+ return this->switch_args;
+ }
+
+ virtual const refs::BorrowedMainGreenlet main_greenlet() const = 0;
+
+ inline intptr_t stack_saved() const noexcept
+ {
+ return this->stack_state.stack_saved();
+ }
+
+ // This is used by the macro SLP_SAVE_STATE to compute the
+ // difference in stack sizes. It might be nice to handle the
+ // computation ourself, but the type of the result
+ // varies by platform, so doing it in the macro is the
+ // simplest way.
+ inline const char* stack_start() const noexcept
+ {
+ return this->stack_state.stack_start();
+ }
+
+ virtual OwnedObject throw_GreenletExit_during_dealloc(const ThreadState& current_thread_state);
+ virtual OwnedObject g_switch() = 0;
+ /**
+ * Force the greenlet to appear dead. Used when it's not
+ * possible to throw an exception into a greenlet anymore.
+ *
+ * This losses access to the thread state and the main greenlet.
+ */
+ virtual void murder_in_place();
+
+ /**
+ * Called when somebody notices we were running in a dead
+ * thread to allow cleaning up resources (because we can't
+ * raise GreenletExit into it anymore).
+ * This is very similar to ``murder_in_place()``, except that
+ * it DOES NOT lose the main greenlet or thread state.
+ */
+ inline void deactivate_and_free();
+
+
+ // Called when some thread wants to deallocate a greenlet
+ // object.
+ // The thread may or may not be the same thread the greenlet
+ // was running in.
+ // The thread state will be null if the thread the greenlet
+ // was running in was known to have exited.
+ void deallocing_greenlet_in_thread(const ThreadState* current_state);
+
+ // Must be called on 3.12+ before exposing a suspended greenlet's
+ // frames to user code. This rewrites the linked list of interpreter
+ // frames to skip the ones that are being stored on the C stack (which
+ // can't be safely accessed while the greenlet is suspended because
+ // that stack space might be hosting a different greenlet), and
+ // sets PythonState::frames_were_exposed so we remember to restore
+ // the original list before resuming the greenlet. The C-stack frames
+ // are a low-level interpreter implementation detail; while they're
+ // important to the bytecode eval loop, they're superfluous for
+ // introspection purposes.
+ void expose_frames();
+
+
+ // TODO: Figure out how to make these non-public.
+ inline void slp_restore_state() noexcept;
+ inline int slp_save_state(char *const stackref) noexcept;
+
+ inline bool is_currently_running_in_some_thread() const;
+ virtual bool belongs_to_thread(const ThreadState* state) const;
+
+ inline bool started() const
+ {
+ return this->stack_state.started();
+ }
+ inline bool active() const
+ {
+ return this->stack_state.active();
+ }
+ inline bool main() const
+ {
+ return this->stack_state.main();
+ }
+ virtual refs::BorrowedMainGreenlet find_main_greenlet_in_lineage() const = 0;
+
+ virtual const OwnedGreenlet parent() const = 0;
+ virtual void parent(const refs::BorrowedObject new_parent) = 0;
+
+ inline const PythonState::OwnedFrame& top_frame()
+ {
+ return this->python_state.top_frame();
+ }
+
+ virtual const OwnedObject& run() const = 0;
+ virtual void run(const refs::BorrowedObject nrun) = 0;
+
+
+ virtual int tp_traverse(visitproc visit, void* arg);
+ virtual int tp_clear();
+
+
+ // Return the thread state that the greenlet is running in, or
+ // null if the greenlet is not running or the thread is known
+ // to have exited.
+ virtual ThreadState* thread_state() const noexcept = 0;
+
+ // Return true if the greenlet is known to have been running
+ // (active) in a thread that has now exited.
+ virtual bool was_running_in_dead_thread() const noexcept = 0;
+
+ // Return a borrowed greenlet that is the Python object
+ // this object represents.
+ virtual BorrowedGreenlet self() const noexcept = 0;
+
+ // For testing. If this returns true, we should pretend that
+ // slp_switch() failed.
+ virtual bool force_slp_switch_error() const noexcept;
+
+ protected:
+ inline void release_args();
+
+ // The functions that must not be inlined are declared virtual.
+ // We also mark them as protected, not private, so that the
+ // compiler is forced to call them through a function pointer.
+ // (A sufficiently smart compiler could directly call a private
+ // virtual function since it can never be overridden in a
+ // subclass).
+
+ // Also TODO: Switch away from integer error codes and to enums,
+ // or throw exceptions when possible.
+ struct switchstack_result_t
+ {
+ int status;
+ Greenlet* the_new_current_greenlet;
+ OwnedGreenlet origin_greenlet;
+
+ switchstack_result_t()
+ : status(0),
+ the_new_current_greenlet(nullptr)
+ {}
+
+ switchstack_result_t(int err)
+ : status(err),
+ the_new_current_greenlet(nullptr)
+ {}
+
+ switchstack_result_t(int err, Greenlet* state, OwnedGreenlet& origin)
+ : status(err),
+ the_new_current_greenlet(state),
+ origin_greenlet(origin)
+ {
+ }
+
+ switchstack_result_t(int err, Greenlet* state, const BorrowedGreenlet& origin)
+ : status(err),
+ the_new_current_greenlet(state),
+ origin_greenlet(origin)
+ {
+ }
+
+ switchstack_result_t(const switchstack_result_t& other)
+ : status(other.status),
+ the_new_current_greenlet(other.the_new_current_greenlet),
+ origin_greenlet(other.origin_greenlet)
+ {}
+
+ switchstack_result_t& operator=(const switchstack_result_t& other)
+ {
+ this->status = other.status;
+ this->the_new_current_greenlet = other.the_new_current_greenlet;
+ this->origin_greenlet = other.origin_greenlet;
+ return *this;
+ }
+ };
+
+ OwnedObject on_switchstack_or_initialstub_failure(
+ Greenlet* target,
+ const switchstack_result_t& err,
+ const bool target_was_me=false,
+ const bool was_initial_stub=false);
+
+ // Returns the previous greenlet we just switched away from.
+ virtual OwnedGreenlet g_switchstack_success() noexcept;
+
+
+ // Check the preconditions for switching to this greenlet; if they
+ // aren't met, throws PyErrOccurred. Most callers will want to
+ // catch this and clear the arguments
+ inline void check_switch_allowed() const;
+ class GreenletStartedWhileInPython : public std::runtime_error
+ {
+ public:
+ GreenletStartedWhileInPython() : std::runtime_error("")
+ {}
+ };
+
+ protected:
+
+
+ /**
+ Perform a stack switch into this greenlet.
+
+ This temporarily sets the global variable
+ ``switching_thread_state`` to this greenlet; as soon as the
+ call to ``slp_switch`` completes, this is reset to NULL.
+ Consequently, this depends on the GIL.
+
+ TODO: Adopt the stackman model and pass ``slp_switch`` a
+ callback function and context pointer; this eliminates the
+ need for global variables altogether.
+
+ Because the stack switch happens in this function, this
+ function can't use its own stack (local) variables, set
+ before the switch, and then accessed after the switch.
+
+ Further, you con't even access ``g_thread_state_global``
+ before and after the switch from the global variable.
+ Because it is thread local some compilers cache it in a
+ register/on the stack, notably new versions of MSVC; this
+ breaks with strange crashes sometime later, because writing
+ to anything in ``g_thread_state_global`` after the switch
+ is actually writing to random memory. For this reason, we
+ call a non-inlined function to finish the operation. (XXX:
+ The ``/GT`` MSVC compiler argument probably fixes that.)
+
+ It is very important that stack switch is 'atomic', i.e. no
+ calls into other Python code allowed (except very few that
+ are safe), because global variables are very fragile. (This
+ should no longer be the case with thread-local variables.)
+
+ */
+ // Made virtual to facilitate subclassing UserGreenlet for testing.
+ virtual switchstack_result_t g_switchstack(void);
+
+class TracingGuard
+{
+private:
+ PyThreadState* tstate;
+public:
+ TracingGuard()
+ : tstate(PyThreadState_GET())
+ {
+ PyThreadState_EnterTracing(this->tstate);
+ }
+
+ ~TracingGuard()
+ {
+ PyThreadState_LeaveTracing(this->tstate);
+ this->tstate = nullptr;
+ }
+
+ inline void CallTraceFunction(const OwnedObject& tracefunc,
+ const greenlet::refs::ImmortalEventName& event,
+ const BorrowedGreenlet& origin,
+ const BorrowedGreenlet& target)
+ {
+ // TODO: This calls tracefunc(event, (origin, target)). Add a shortcut
+ // function for that that's specialized to avoid the Py_BuildValue
+ // string parsing, or start with just using "ON" format with PyTuple_Pack(2,
+ // origin, target). That seems like what the N format is meant
+ // for.
+ // XXX: Why does event not automatically cast back to a PyObject?
+ // It tries to call the "deleted constructor ImmortalEventName
+ // const" instead.
+ assert(tracefunc);
+ assert(event);
+ assert(origin);
+ assert(target);
+ greenlet::refs::NewReference retval(
+ PyObject_CallFunction(
+ tracefunc.borrow(),
+ "O(OO)",
+ event.borrow(),
+ origin.borrow(),
+ target.borrow()
+ ));
+ if (!retval) {
+ throw PyErrOccurred::from_current();
+ }
+ }
+};
+
+ static void
+ g_calltrace(const OwnedObject& tracefunc,
+ const greenlet::refs::ImmortalEventName& event,
+ const greenlet::refs::BorrowedGreenlet& origin,
+ const BorrowedGreenlet& target);
+ private:
+ OwnedObject g_switch_finish(const switchstack_result_t& err);
+
+ };
+
+ class UserGreenlet : public Greenlet
+ {
+ private:
+ static greenlet::PythonAllocator