appengine-python-standard 1.2.0b0__tar.gz → 1.3.0b0__tar.gz

{appengine_python_standard-1.2.0b0/src/appengine_python_standard.egg-info → appengine_python_standard-1.3.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appengine-python-standard
-Version: 1.2.0b0
+Version: 1.3.0b0
 Summary: Google App Engine services SDK for Python 3
 Home-page: https://github.com/GoogleCloudPlatform/appengine-python-standard
 Author: Google LLC
@@ -22,6 +22,7 @@ Requires-Dist: ruamel.yaml>=0.17.7
 Requires-Dist: six>=1.15.0
 Requires-Dist: urllib3<2,>=1.26.2
 Requires-Dist: legacy-cgi>=2.6.2; python_version >= "3.10"
+Requires-Dist: google-api-python-client
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

{appengine_python_standard-1.2.0b0 → appengine_python_standard-1.3.0b0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="appengine-python-standard",
-    version="1.2.0-beta",
+    version="1.3.0-beta",
     author="Google LLC",
     description="Google App Engine services SDK for Python 3",
     long_description=long_description,
@@ -27,6 +27,7 @@ setuptools.setup(
         "six>=1.15.0",
         "urllib3>=1.26.2,<2",
         "legacy-cgi>=2.6.2; python_version>='3.10'",
+        "google-api-python-client"
     ],
     classifiers=[
         "Programming Language :: Python :: 3",

{appengine_python_standard-1.2.0b0 → appengine_python_standard-1.3.0b0/src/appengine_python_standard.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appengine-python-standard
-Version: 1.2.0b0
+Version: 1.3.0b0
 Summary: Google App Engine services SDK for Python 3
 Home-page: https://github.com/GoogleCloudPlatform/appengine-python-standard
 Author: Google LLC
@@ -22,6 +22,7 @@ Requires-Dist: ruamel.yaml>=0.17.7
 Requires-Dist: six>=1.15.0
 Requires-Dist: urllib3<2,>=1.26.2
 Requires-Dist: legacy-cgi>=2.6.2; python_version >= "3.10"
+Requires-Dist: google-api-python-client
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

{appengine_python_standard-1.2.0b0 → appengine_python_standard-1.3.0b0}/src/appengine_python_standard.egg-info/requires.txt

@@ -9,6 +9,7 @@ requests>=2.25.1
 ruamel.yaml>=0.17.7
 six>=1.15.0
 urllib3<2,>=1.26.2
+google-api-python-client
 
 [:python_version >= "3.10"]
 legacy-cgi>=2.6.2

{appengine_python_standard-1.2.0b0 → appengine_python_standard-1.3.0b0}/src/google/appengine/api/mail.py

@@ -45,8 +45,6 @@ from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 import functools
 import logging
-import os
-import smtplib
 import typing
 
 from google.appengine.api import api_base_pb2
@@ -1199,77 +1197,20 @@ class _EmailMessageBase(object):
     return self.to_mime_message()
 
   def send(self, make_sync_call=apiproxy_stub_map.MakeSyncCall):
-    """Sends an email message via the Mail API or SMTP.
-
-    If the 'USE_SMTP_MAIL_SERVICE' environment variable is set to 'true', this
-    method will send the email via SMTP using credentials from other
-    environment variables. Otherwise, it falls back to the App Engine Mail API.
+    """Sends an email message via the Mail API.
 
     Args:
       make_sync_call: Method that will make a synchronous call to the API proxy.
     """
-    if os.environ.get('APPENGINE_USE_SMTP_MAIL_SERVICE') == 'true':
-        logging.info('Sending email via SMTP.')
-        mime_message = self.to_mime_message()
-
-        # The Bcc header should not be in the final message.
-        if 'Bcc' in mime_message:
-            del mime_message['Bcc']
-
-        recipients = []
-        if isinstance(self, AdminEmailMessage):
-            admin_emails = os.environ.get('APPENGINE_ADMIN_EMAIL_RECIPIENTS')
-            if admin_emails:
-                recipients.extend(admin_emails.split(','))
-        else:
-            if hasattr(self, 'to'):
-                recipients.extend(_email_sequence(self.to))
-            if hasattr(self, 'cc'):
-                recipients.extend(_email_sequence(self.cc))
-            if hasattr(self, 'bcc'):
-                recipients.extend(_email_sequence(self.bcc))
-
-        if not recipients:
-            raise MissingRecipientsError()
-
-        try:
-            host = os.environ['APPENGINE_SMTP_HOST']
-            port = int(os.environ.get('APPENGINE_SMTP_PORT', 587))
-            user = os.environ.get('APPENGINE_SMTP_USER')
-            password = os.environ.get('APPENGINE_SMTP_PASSWORD')
-            use_tls = os.environ.get('APPENGINE_SMTP_USE_TLS', 'true').lower() == 'true'
-
-            with smtplib.SMTP(host, port) as server:
-                if use_tls:
-                    server.starttls()
-                if user and password:
-                    server.login(user, password)
-                server.send_message(mime_message, from_addr=self.sender, to_addrs=recipients)
-            logging.info('Email sent successfully via SMTP.')
-
-        except smtplib.SMTPAuthenticationError as e:
-            logging.error('SMTP authentication failed: %s', e.smtp_error)
-            raise InvalidSenderError(f'SMTP authentication failed: {e.smtp_error}')
-        except (smtplib.SMTPException, OSError) as e:
-            logging.error('Failed to send email via SMTP: %s', e)
-            raise Error(f'Failed to send email via SMTP: {e}')
-        except KeyError as e:
-            logging.error('Missing required SMTP environment variable: %s', e)
-            raise Error(f'Missing required SMTP environment variable: {e}')
+    message = self.ToProto()
+    response = api_base_pb2.VoidProto()
 
-    else:
-        logging.info('Sending email via App Engine Mail API.')
-        message = self.ToProto()
-        response = api_base_pb2.VoidProto()
-
-        try:
-          make_sync_call('mail', self._API_CALL, message, response)
-          logging.info('Email sent successfully via App Engine Mail API.')
-        except apiproxy_errors.ApplicationError as e:
-          logging.error('App Engine Mail API error: %s', e)
-          if e.application_error in ERROR_MAP:
-            raise ERROR_MAP[e.application_error](e.error_detail)
-          raise e
+    try:
+      make_sync_call('mail', self._API_CALL, message, response)
+    except apiproxy_errors.ApplicationError as e:
+      if e.application_error in ERROR_MAP:
+        raise ERROR_MAP[e.application_error](e.error_detail)
+      raise e
 
 
   def Send(self, *args, **kwds):

{appengine_python_standard-1.2.0b0 → appengine_python_standard-1.3.0b0}/src/google/appengine/api/modules/modules.py

@@ -22,6 +22,20 @@ Using the Modules guide:
 https://cloud.google.com/appengine/docs/standard/python/using-the-modules-api.
 """
 
+import logging
+import os
+import threading
+
+from google.appengine.api import apiproxy_stub_map
+from google.appengine.api.modules import modules_service_pb2
+from google.appengine.runtime import apiproxy_errors
+from googleapiclient import discovery, errors, http
+from google_auth_httplib2 import AuthorizedHttp
+import google.auth
+import six
+import httplib2
+
+
 __all__ = [
     'Error',
     'InvalidModuleError',
@@ -46,16 +60,6 @@ __all__ = [
     'get_hostname'
 ]
 
-import logging
-import os
-
-import six
-
-from google.appengine.api import apiproxy_stub_map
-from google.appengine.api.modules import modules_service_pb2
-from google.appengine.runtime import apiproxy_errors
-
-
 class Error(Exception):
   """Base-class for errors in this module."""
 
@@ -79,6 +83,28 @@ class UnexpectedStateError(Error):
 class TransientError(Error):
   """A transient error was encountered, retry the operation."""
 
+def _has_opted_in():
+  return (os.environ.get('APPENGINE_MODULES_USE_ADMIN_API', 'false').lower() == 'true')
+
+def _raise_error(e):
+  # Translate HTTP errors to the exceptions expected by the API
+  if e.resp.status == 400:
+      raise InvalidInstancesError(e) from e
+  elif e.resp.status == 404:
+      raise InvalidVersionError(e) from e
+  elif e.resp.status >= 500:
+      raise TransientError(e) from e
+  else:
+      raise Error(e) from e
+
+def _get_project_id():
+  project_id = os.environ.get('GAE_PROJECT') or os.environ.get(
+      'GOOGLE_CLOUD_PROJECT'
+  )
+  if project_id is None:
+    app_id = os.environ.get('GAE_APPLICATION')
+    project_id = app_id.split('~', 1)[1]
+  return project_id
 
 def get_current_module_name():
   """Returns the module name of the current instance.
@@ -120,16 +146,44 @@ def get_current_instance_id():
   return os.environ.get('GAE_INSTANCE') or os.environ.get('INSTANCE_ID', None)
 
 
+class _ThreadedRpc:
+  """A class to emulate the UserRPC object for threaded operations."""
+
+  def __init__(self, target):
+    self.thread = threading.Thread(target=self._run_target, args=(target,))
+    self.exception = None
+    self.done = threading.Event()
+    self.thread.start()
+
+  def _run_target(self, target):
+    try:
+        target()
+    except Exception as e:
+        self.exception = e
+    finally:
+        self.done.set()
+
+  def wait(self):
+    self.done.wait()
+
+  def check_success(self):
+    if self.exception:
+      raise self.exception
+
+  def get_result(self):
+    self.wait()
+    self.check_success()
+    return None
+
+
 def _GetRpc():
   return apiproxy_stub_map.UserRPC('modules')
 
-
 def _MakeAsyncCall(method, request, response, get_result_hook):
   rpc = _GetRpc()
   rpc.make_call(method, request, response, get_result_hook)
   return rpc
 
-
 _MODULE_SERVICE_ERROR_MAP = {
     modules_service_pb2.ModulesServiceError.INVALID_INSTANCES:
         InvalidInstancesError,
@@ -143,7 +197,6 @@ _MODULE_SERVICE_ERROR_MAP = {
         UnexpectedStateError
 }
 
-
 def _CheckAsyncResult(rpc, expected_application_errors,
                       ignored_application_errors):
   try:
@@ -158,6 +211,14 @@ def _CheckAsyncResult(rpc, expected_application_errors,
         raise mapped_error()
     raise Error(e)
 
+def _get_admin_api_client_with_useragent(methodName):
+  userAgent = 'appengine-modules-api-python-client/' + methodName
+  http_client = httplib2.Http(timeout=60)
+  http_client = http.set_user_agent(http_client, userAgent)
+  credentials,_ = google.auth.default()
+  authorized_http = AuthorizedHttp(credentials, http=http_client)
+  client = discovery.build('appengine', 'v1', http=authorized_http)
+  return client
 
 def get_modules():
   """Returns a list of all modules for the application.
@@ -167,8 +228,29 @@ def get_modules():
       application.  The 'default' module will be included if it exists, as will
       the name of the module that is associated with the instance that calls
       this function.
+
+  Raises:
+    Error: If the configured project ID is invalid.
+    TransientError: If there is an issue fetching the information.
   """
+  if not _has_opted_in():
+    return get_modules_legacy()
+  
+  project_id = _get_project_id()
+  client = _get_admin_api_client_with_useragent('get_modules')
+  request = client.apps().services().list(appsId=project_id)
+
+  try:
+    response = request.execute()
+  except errors.HttpError as e:
+    if e.resp.status == 404:
+      raise Error(f"Project '{project_id}' not found.") from e
+    _raise_error(e)
+
+  return [service['id'] for service in response.get('services', [])]
 
+#Legacy get_modules implementation
+def get_modules_legacy():
   def _ResultHook(rpc):
     _CheckAsyncResult(rpc, [], {})
 
@@ -181,6 +263,7 @@ def get_modules():
                         _ResultHook).get_result()
 
 
+
 def get_versions(module=None):
   """Returns a list of versions for a given module.
 
@@ -196,7 +279,27 @@ def get_versions(module=None):
     `InvalidModuleError` if the given module isn't valid, `TransientError` if
     there is an issue fetching the information.
   """
+  if not _has_opted_in():
+    return get_versions_legacy(module=module)
+
+  if not module:
+    module = os.environ.get('GAE_SERVICE', 'default')
+  
+  project_id = _get_project_id()
+  client = _get_admin_api_client_with_useragent('get_versions')
+  request = client.apps().services().versions().list(
+      appsId=project_id, servicesId=module, view='FULL'
+  )
+  try:
+    response = request.execute()
+  except errors.HttpError as e:
+    if e.resp.status == 404:
+      raise InvalidModuleError(f"") from e
+    _raise_error(e)
 
+  return [version['id'] for version in response.get('versions', [])]
+
+def get_versions_legacy(module=None):
   def _ResultHook(rpc):
     mapped_errors = [
         modules_service_pb2.ModulesServiceError.INVALID_MODULE,
@@ -212,7 +315,8 @@ def get_versions(module=None):
     request.module = module
   response = modules_service_pb2.GetVersionsResponse()
   return _MakeAsyncCall('GetVersions', request, response,
-                        _ResultHook).get_result()
+                        _ResultHook).get_result()  
+
 
 
 def get_default_version(module=None):
@@ -230,6 +334,46 @@ def get_default_version(module=None):
     if no default version could be found.
   """
 
+  if not _has_opted_in():
+    return get_default_version_legacy(module=module)
+
+  if not module:
+    module = os.environ.get('GAE_SERVICE', 'default')
+  project = _get_project_id()
+  client = _get_admin_api_client_with_useragent('get_default_version')
+  request = client.apps().services().get(
+    appsId=project, servicesId=module)
+
+  try:
+    response = request.execute()
+  except errors.HttpError as e:
+    if e.resp.status == 404:
+        raise InvalidModuleError(f"") from e
+    _raise_error(e)
+
+  allocations = response.get('split', {}).get('allocations')
+  maxAlloc = -1
+  retVersion = None
+
+  if allocations:
+    for version, allocation in allocations.items():
+      if allocation == 1.0:
+        retVersion = version
+        break
+
+      if allocation > maxAlloc:
+        retVersion = version
+        maxAlloc = allocation
+      elif allocation == maxAlloc:
+        if version < retVersion:
+          retVersion = version
+
+  if retVersion is None:
+    raise InvalidVersionError(f"Could not determine default version for module '{module}'.")
+
+  return retVersion
+
+def get_default_version_legacy(module):
   def _ResultHook(rpc):
     mapped_errors = [
         modules_service_pb2.ModulesServiceError.INVALID_MODULE,
@@ -269,7 +413,34 @@ def get_num_instances(
   Raises:
     `InvalidVersionError` on invalid input.
   """
+  if not _has_opted_in():
+    return get_num_instances_legacy(module=module, version=version)
+
+  if module is None:
+    module = get_current_module_name()
+
+  if version is None:
+    version = get_current_version_name()
 
+  project_id = _get_project_id()
+  client = _get_admin_api_client_with_useragent('get_num_instances')
+  request = client.apps().services().versions().get(
+        appsId=project_id, servicesId=module, versionsId=version)
+
+  try:
+    response = request.execute()
+  except errors.HttpError as e:
+    if e.resp.status == 404:
+        raise InvalidModuleError(f"") from e
+    _raise_error(e)
+
+  if 'manualScaling' not in response:
+      raise InvalidVersionError(f"")
+  
+  return response['manualScaling'].get('instances')
+
+  
+def get_num_instances_legacy(module, version):
   def _ResultHook(rpc):
     mapped_errors = [modules_service_pb2.ModulesServiceError.INVALID_VERSION]
     _CheckAsyncResult(rpc, mapped_errors, {})
@@ -285,6 +456,23 @@ def get_num_instances(
                         _ResultHook).get_result()
 
 
+def _admin_api_version_patch(project_id, module, version, body, update_mask):
+  methodName = ''
+  if 'manualScaling' in body:
+    methodName = 'set_num_instances'
+  elif 'servingStatus' in body and body['servingStatus'] == 'SERVING':
+    methodName = 'start_version'
+  elif 'servingStatus' in body and body['servingStatus'] == 'STOPPED':
+    methodName = 'stop_version'
+
+  client = _get_admin_api_client_with_useragent(methodName)
+  client.apps().services().versions().patch(
+    appsId=project_id,
+    servicesId=module,
+    versionsId=version,
+    updateMask=update_mask,
+    body=body).execute()
+
 def set_num_instances(
     instances,
     module=None,
@@ -324,6 +512,33 @@ def set_num_instances_async(
     A `UserRPC` to set the number of instances on the module version.
   """
 
+  if not _has_opted_in():
+    return set_num_instances_async_legacy(instances=instances, module=module, version=version)
+
+  if not isinstance(instances, six.integer_types):
+    raise TypeError("'instances' arg must be of type long or int.")
+
+  project_id = _get_project_id()
+  if module is None:
+    module = get_current_module_name()
+  if version is None:
+    version = get_current_version_name()
+
+  def run_request():
+    """This function will be executed in a separate thread."""
+    try:
+      body = {
+        'manualScaling': {
+          'instances': instances
+          }
+        }
+      _admin_api_version_patch(project_id, module, version, body, 'manualScaling.instances')
+    except errors.HttpError as e:
+      _raise_error(e)
+
+  return _ThreadedRpc(target=run_request)
+
+def set_num_instances_async_legacy(instances, module, version):
   def _ResultHook(rpc):
     mapped_errors = [
         modules_service_pb2.ModulesServiceError.INVALID_VERSION,
@@ -370,7 +585,28 @@ def start_version_async(
   Returns:
     A `UserRPC` to start all instances for the given module version.
   """
-
+  if not _has_opted_in():
+    return start_version_async_legacy(module=module, version=version)
+
+  if module is None:
+    module = get_current_module_name()
+
+  if version is None:
+    version = get_current_version_name()
+  project_id = _get_project_id()
+  def run_request():
+    """This function will be executed in a separate thread."""
+    try:
+      body = {
+        'servingStatus': 'SERVING'
+        }
+      _admin_api_version_patch(project_id, module, version, body, 'servingStatus')
+    except errors.HttpError as e:
+      _raise_error(e)
+
+  return _ThreadedRpc(target=run_request)
+
+def start_version_async_legacy(module, version):
   def _ResultHook(rpc):
     mapped_errors = [
         modules_service_pb2.ModulesServiceError.INVALID_VERSION,
@@ -389,7 +625,6 @@ def start_version_async(
   response = modules_service_pb2.StartModuleResponse()
   return _MakeAsyncCall('StartModule', request, response, _ResultHook)
 
-
 def stop_version(
     module=None,
     version=None):
@@ -422,6 +657,28 @@ def stop_version_async(
     A `UserRPC` to stop all instances for the given module version.
   """
 
+  if not _has_opted_in():
+    return stop_version_async_legacy(module=module, version=version)
+
+  if module is None:
+    module = get_current_module_name()
+
+  if version is None:
+    version = get_current_version_name()
+  project_id = _get_project_id()
+  def run_request():
+    """This function will be executed in a separate thread."""
+    try:
+      body = {
+        'servingStatus': 'STOPPED'
+        }
+      _admin_api_version_patch(project_id, module, version, body, 'servingStatus')
+    except errors.HttpError as e:
+      _raise_error(e)
+
+  return _ThreadedRpc(target=run_request)
+
+def stop_version_async_legacy(module, version):
   def _ResultHook(rpc):
     mapped_errors = [
         modules_service_pb2.ModulesServiceError.INVALID_VERSION,
@@ -433,7 +690,7 @@ def stop_version_async(
             (module, version)
     }
     _CheckAsyncResult(rpc, mapped_errors, expected_errors)
-
+    
   request = modules_service_pb2.StopModuleRequest()
   if module:
     request.module = module
@@ -443,6 +700,10 @@ def stop_version_async(
   return _MakeAsyncCall('StopModule', request, response, _ResultHook)
 
 
+def _construct_hostname(*hostname_parts):
+  """Constructs a hostname for the given module, version, and instance."""
+  return ".".join(hostname_parts)
+
 def get_hostname(
     module=None,
     version=None,
@@ -467,7 +728,95 @@ def get_hostname(
     InvalidInstancesError: if the given instance value is invalid.
     TypeError: if the given instance type is invalid.
   """
+  if not _has_opted_in():
+    return get_hostname_legacy(module=module, version=version, instance=instance)
 
+  if instance is not None:
+    try:
+      instance_id = int(instance)
+      if instance_id < 0:
+        raise ValueError
+    except (ValueError, TypeError) as e:
+      raise InvalidInstancesError("Instance must be a non-negative integer.") from e
+
+  project_id = _get_project_id()
+  
+
+  req_module = module or get_current_module_name()
+  req_version = version or get_current_version_name()
+
+  try:
+    services = get_modules()
+    client = _get_admin_api_client_with_useragent('get_hostname')
+    request = client.apps().get(appsId=project_id)
+    
+    response = request.execute()
+    default_hostname = response.get('defaultHostname')
+
+  except errors.HttpError as e:
+    _raise_error(e)
+
+  if req_module not in services:
+    raise InvalidModuleError(f"")
+  # Legacy Applications (Without "Engines")
+  if len(services) == 1 and services[0] == 'default':
+    if req_module != 'default':
+      raise InvalidModuleError(f"Module '{req_module}' not found.")
+    hostname_parts = [req_version, default_hostname]
+    if instance:
+      return _construct_hostname(instance, req_version, default_hostname)
+    return _construct_hostname(req_version, default_hostname)
+
+  if instance is not None:
+    try:
+      # Get version details to check scaling and instance count
+      version_request = discovery.build('appengine', 'v1').apps().services().versions().get(
+          appsId=project_id, servicesId=req_module, versionsId=req_version, view='FULL')
+      version_details = version_request.execute()
+
+      if 'manualScaling' not in version_details:
+        raise InvalidInstancesError(
+            "Instance-specific hostnames are only available for manually scaled services.")
+
+      num_instances = version_details['manualScaling'].get('instances', 0)
+      if int(instance) >= num_instances:
+        raise InvalidInstancesError(
+            "The specified instance does not exist for this module/version.")
+
+      return _construct_hostname(instance, req_version, req_module, default_hostname)
+
+    except errors.HttpError as e:
+      if e.resp.status == 404:
+        raise InvalidModuleError(
+            f"Module '{req_module}' or version '{req_version}' not found.") from e
+      _raise_error(e)
+
+  # Request with no explicit version and no instance.
+  if version is None:
+    try:
+        # Get all versions for the target module.
+        versions_list = get_versions(module=req_module)
+
+        # Create a set of version IDs for efficient lookup.
+        existing_version_ids = set(versions_list)
+
+        # Check if the version from the current context exists in the target module.
+        if req_version in existing_version_ids:
+            return _construct_hostname(req_version, req_module, default_hostname)
+        else:
+            # If the current version does not exist on the target module,
+            # return a hostname without a version.
+            return _construct_hostname(req_module, default_hostname)
+
+    except errors.HttpError as e:
+        if e.resp.status == 404:
+            raise InvalidModuleError(f"Module '{req_module}' not found.") from e
+        _raise_error(e)
+
+  # Request with a version but no instance
+  return _construct_hostname(version, req_module, default_hostname)
+
+def get_hostname_legacy(module, version, instance):
   def _ResultHook(rpc):
     mapped_errors = [
         modules_service_pb2.ModulesServiceError.INVALID_MODULE,