@vercel/python 3.0.5 → 3.1.0

package/dist/index.js

@@ -3819,7 +3819,6 @@ const allOptions = [
         discontinueDate: new Date('2022-07-18'),
     },
 ];
-const upstreamProvider = 'This change is the result of a decision made by an upstream infrastructure provider (AWS)';
 function getDevPythonVersion() {
     // Use the system-installed version of `python3` when running `vercel dev`
     return {
@@ -3854,12 +3853,12 @@ function getSupportedPythonVersion({ isDev, pipLockPythonVersion, }) {
         throw new build_utils_1.NowBuildError({
             code: 'BUILD_UTILS_PYTHON_VERSION_DISCONTINUED',
             link: 'http://vercel.link/python-version',
-            message: `Python version "${selection.version}" detected in Pipfile.lock is discontinued and must be upgraded. ${upstreamProvider}.`,
+            message: `Python version "${selection.version}" detected in Pipfile.lock is discontinued and must be upgraded.`,
         });
     }
     if (selection.discontinueDate) {
         const d = selection.discontinueDate.toISOString().split('T')[0];
-        console.warn(`Error: Python version "${selection.version}" detected in Pipfile.lock is deprecated. Deployments created on or after ${d} will fail to build. ${upstreamProvider}. http://vercel.link/python-version`);
+        console.warn(`Error: Python version "${selection.version}" detected in Pipfile.lock has reached End-of-Life. Deployments created on or after ${d} will fail to build. http://vercel.link/python-version`);
     }
     return selection;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "3.0.5",
+  "version": "3.1.0",
   "main": "./dist/index.js",
   "license": "MIT",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -23,10 +23,10 @@
   "devDependencies": {
     "@types/execa": "^0.9.0",
     "@types/jest": "27.4.1",
-    "@vercel/build-utils": "5.0.1",
+    "@vercel/build-utils": "5.0.4",
     "@vercel/ncc": "0.24.0",
     "execa": "^1.0.0",
     "typescript": "4.3.4"
   },
-  "gitHead": "0a2af4fb94d71a7a23ffc72fb68748be1177f345"
+  "gitHead": "3d3774ee7e3d344b3292d2166d485bdf41a68d4c"
 }

package/vc_init.py

@@ -167,13 +167,23 @@ elif 'app' in __vc_variables:
     else:
         print('using Asynchronous Server Gateway Interface (ASGI)')
         # Originally authored by Jordan Eremieff and included under MIT license:
-        # https://github.com/erm/mangum/blob/b4d21c8f5e304a3e17b88bc9fa345106acc50ad7/mangum/__init__.py
-        # https://github.com/erm/mangum/blob/b4d21c8f5e304a3e17b88bc9fa345106acc50ad7/LICENSE
+        # https://github.com/erm/mangum/blob/07ce20a0e2f67c5c2593258a92c03fdc66d9edda/mangum/__init__.py
+        # https://github.com/erm/mangum/blob/07ce20a0e2f67c5c2593258a92c03fdc66d9edda/LICENSE
         import asyncio
         import enum
+        import logging
+        from contextlib import ExitStack
         from urllib.parse import urlparse
         from werkzeug.datastructures import Headers
 
+        def get_event_loop():
+            try:
+                return asyncio.get_running_loop()
+            except:
+                if sys.version_info < (3, 10):
+                    return asyncio.get_event_loop()
+                else:
+                    return asyncio.get_event_loop_policy().get_event_loop()
 
         class ASGICycleState(enum.Enum):
             REQUEST = enum.auto()
@@ -194,8 +204,8 @@ elif 'app' in __vc_variables:
                 ASGI instance using the connection scope.
                 Runs until the response is completely read from the application.
                 """
-                loop = asyncio.new_event_loop()
-                self.app_queue = asyncio.Queue(loop=loop)
+                loop = get_event_loop()
+                self.app_queue = asyncio.Queue()
                 self.put_message({'type': 'http.request', 'body': body, 'more_body': False})
 
                 asgi_instance = app(self.scope, self.receive, self.send)
@@ -257,6 +267,156 @@ elif 'app' in __vc_variables:
                     self.response['body'] = base64.b64encode(self.body).decode('utf-8')
                     self.response['encoding'] = 'base64'
 
+        class LifespanFailure(Exception):
+            """Raise when a lifespan failure event is sent by an application."""
+
+        class LifespanUnsupported(Exception):
+            """Raise when lifespan events are not supported by an application."""
+
+        class UnexpectedMessage(Exception):
+            """Raise when an unexpected message type is received during an ASGI cycle."""
+
+        class LifespanCycleState(enum.Enum):
+            """
+            The state of the ASGI `lifespan` connection.
+            * **CONNECTING** - Initial state. The ASGI application instance will be run with
+            the connection scope containing the `lifespan` type.
+            * **STARTUP** - The lifespan startup event has been pushed to the queue to be
+            received by the application.
+            * **SHUTDOWN** - The lifespan shutdown event has been pushed to the queue to be
+            received by the application.
+            * **FAILED** - A lifespan failure has been detected, and the connection will be
+            closed with an error.
+            * **UNSUPPORTED** - An application attempted to send a message before receiving
+            the lifepan startup event. If the lifespan argument is "on", then the connection
+            will be closed with an error.
+            """
+
+            CONNECTING = enum.auto()
+            STARTUP = enum.auto()
+            SHUTDOWN = enum.auto()
+            FAILED = enum.auto()
+            UNSUPPORTED = enum.auto()
+        
+        class Lifespan:
+
+            def __init__(self, app):
+                self.app = app
+                self.state = LifespanCycleState.CONNECTING
+                self.exception = None
+                self.logger = logging.getLogger('lifespan')
+                self.loop = get_event_loop()
+                self.app_queue = asyncio.Queue()
+                self.startup_event = asyncio.Event()
+                self.shutdown_event = asyncio.Event()
+
+            
+            def __enter__(self) -> None:
+                """Runs the event loop for application startup."""
+                self.loop.create_task(self.run())
+                self.loop.run_until_complete(self.startup())
+
+            def __exit__(
+                self,
+                exc_type,
+                exc_value,
+                traceback,
+            ) -> None:
+                """Runs the event loop for application shutdown."""
+                self.loop.run_until_complete(self.shutdown())
+                
+            async def run(self):
+                """Calls the application with the `lifespan` connection scope."""
+                try:
+                    await self.app(
+                        {"type": "lifespan", "asgi": {"spec_version": "2.0", "version": "3.0"}},
+                        self.receive,
+                        self.send,
+                    )
+                except LifespanUnsupported:
+                    self.logger.info("ASGI 'lifespan' protocol appears unsupported.")
+                except (LifespanFailure, UnexpectedMessage) as exc:
+                    self.exception = exc
+                except BaseException as exc:
+                    self.logger.error("Exception in 'lifespan' protocol.", exc_info=exc)
+                finally:
+                    self.startup_event.set()
+                    self.shutdown_event.set()
+
+            async def send(self, message):
+                """Awaited by the application to send ASGI `lifespan` events."""
+                message_type = message["type"]
+
+                if self.state is LifespanCycleState.CONNECTING:
+                    # If a message is sent before the startup event is received by the
+                    # application, then assume that lifespan is unsupported.
+                    self.state = LifespanCycleState.UNSUPPORTED
+                    raise LifespanUnsupported("Lifespan protocol appears unsupported.")
+
+                if message_type not in (
+                    "lifespan.startup.complete",
+                    "lifespan.shutdown.complete",
+                    "lifespan.startup.failed",
+                    "lifespan.shutdown.failed",
+                ):
+                    self.state = LifespanCycleState.FAILED
+                    raise UnexpectedMessage(f"Unexpected '{message_type}' event received.")
+
+                if self.state is LifespanCycleState.STARTUP:
+                    if message_type == "lifespan.startup.complete":
+                        self.startup_event.set()
+                    elif message_type == "lifespan.startup.failed":
+                        self.state = LifespanCycleState.FAILED
+                        self.startup_event.set()
+                        message_value = message.get("message", "")
+                        raise LifespanFailure(f"Lifespan startup failure. {message_value}")
+
+                elif self.state is LifespanCycleState.SHUTDOWN:
+                    if message_type == "lifespan.shutdown.complete":
+                        self.shutdown_event.set()
+                    elif message_type == "lifespan.shutdown.failed":
+                        self.state = LifespanCycleState.FAILED
+                        self.shutdown_event.set()
+                        message_value = message.get("message", "")
+                        raise LifespanFailure(f"Lifespan shutdown failure. {message_value}")
+
+            async def receive(self):
+                """Awaited by the application to receive ASGI `lifespan` events."""
+                if self.state is LifespanCycleState.CONNECTING:
+
+                    # Connection established. The next event returned by the queue will be
+                    # `lifespan.startup` to inform the application that the connection is
+                    # ready to receive lfiespan messages.
+                    self.state = LifespanCycleState.STARTUP
+
+                elif self.state is LifespanCycleState.STARTUP:
+
+                    # Connection shutting down. The next event returned by the queue will be
+                    # `lifespan.shutdown` to inform the application that the connection is now
+                    # closing so that it may perform cleanup.
+                    self.state = LifespanCycleState.SHUTDOWN
+
+                return await self.app_queue.get()
+
+            async def startup(self) -> None:
+                """Pushes the `lifespan` startup event to the queue and handles errors."""
+                await self.app_queue.put({"type": "lifespan.startup"})
+                await self.startup_event.wait()
+                if self.state is LifespanCycleState.FAILED:
+                    raise LifespanFailure(self.exception)
+
+                if not self.exception:
+                    self.logger.info("Application startup complete.")
+                else:
+                    self.logger.info("Application startup failed.")
+
+            async def shutdown(self) -> None:
+                """Pushes the `lifespan` shutdown event to the queue and handles errors."""
+                await self.app_queue.put({"type": "lifespan.shutdown"})
+                await self.shutdown_event.wait()
+                if self.state is LifespanCycleState.FAILED:
+                    raise LifespanFailure(self.exception)
+       
         def vc_handler(event, context):
             payload = json.loads(event['body'])
 
@@ -289,9 +449,13 @@ elif 'app' in __vc_variables:
                 'raw_path': path.encode(),
             }
 
-            asgi_cycle = ASGICycle(scope)
-            response = asgi_cycle(__vc_module.app, body)
-            return response
+            with ExitStack() as stack:
+                lifespan = Lifespan(__vc_module.app)
+                stack.enter_context(lifespan)
+
+                asgi_cycle = ASGICycle(scope)
+                response = asgi_cycle(__vc_module.app, body)
+                return response
 
 else:
     print('Missing variable `handler` or `app` in file "__VC_HANDLER_ENTRYPOINT".')