@vercel/python 4.3.1 → 4.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "4.3.1",
+  "version": "4.4.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -19,7 +19,8 @@
     "@types/jest": "27.4.1",
     "@types/node": "14.18.33",
     "@types/which": "3.0.0",
-    "@vercel/build-utils": "8.3.5",
+    "@vercel/build-utils": "8.4.12",
+    "cross-env": "7.0.3",
     "execa": "^1.0.0",
     "fs-extra": "11.1.1",
     "jest-junit": "16.0.0",
@@ -27,7 +28,7 @@
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",
-    "test": "jest --reporters=default --reporters=jest-junit --env node --verbose --runInBand --bail",
+    "test": "cross-env VERCEL_FORCE_PYTHON_STREAMING=1 jest --reporters=default --reporters=jest-junit --env node --verbose --runInBand --bail",
     "test-unit": "pnpm test test/unit.test.ts",
     "test-e2e": "pnpm test test/integration-*",
     "type-check": "tsc --noEmit"

package/vc_init.py

@@ -5,6 +5,7 @@ import inspect
 from importlib import util
 from http.server import BaseHTTPRequestHandler
 import socket
+import os
 
 # Import relative path https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
 __vc_spec = util.spec_from_file_location("__VC_HANDLER_MODULE_NAME", "./__VC_HANDLER_ENTRYPOINT")
@@ -26,6 +27,304 @@ def format_headers(headers, decode=False):
         keyToList[key].append(value)
     return keyToList
 
+if 'VERCEL_IPC_FD' in os.environ:
+    from http.server import HTTPServer
+    import http
+    import time
+    import contextvars
+    import functools
+    import builtins
+    import logging
+
+    ipc_fd = int(os.getenv("VERCEL_IPC_FD", ""))
+    sock = socket.socket(fileno=ipc_fd)
+    start_time = time.time()
+
+    send_message = lambda message: sock.sendall((json.dumps(message) + '\0').encode())
+    storage = contextvars.ContextVar('storage', default=None)
+
+    # Override sys.stdout and sys.stderr to map logs to the correct request
+    class StreamWrapper:
+        def __init__(self, stream, stream_name):
+            self.stream = stream
+            self.stream_name = stream_name
+
+        def write(self, message):
+            context = storage.get()
+            if context is not None:
+                send_message({
+                    "type": "log",
+                    "payload": {
+                        "context": {
+                            "invocationId": context['invocationId'],
+                            "requestId": context['requestId'],
+                        },
+                        "message": base64.b64encode(message.encode()).decode(),
+                        "stream": self.stream_name,
+                    }
+                })
+            else:
+                self.stream.write(message)
+
+        def __getattr__(self, name):
+            return getattr(self.stream, name)
+
+    sys.stdout = StreamWrapper(sys.stdout, "stdout")
+    sys.stderr = StreamWrapper(sys.stderr, "stderr")
+
+    # Override the global print to log to stdout
+    def print_wrapper(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            sys.stdout.write(' '.join(map(str, args)) + '\n')
+        return wrapper
+    builtins.print = print_wrapper(builtins.print)
+
+    # Override logging to maps logs to the correct request
+    def logging_wrapper(func, level="info"):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            context = storage.get()
+            if context is not None:
+                send_message({
+                    "type": "log",
+                    "payload": {
+                        "context": {
+                            "invocationId": context['invocationId'],
+                            "requestId": context['requestId'],
+                        },
+                        "message": base64.b64encode(f"{args[0]}".encode()).decode(),
+                        "level": level,
+                    }
+                })
+            else:
+                func(*args, **kwargs)
+        return wrapper
+
+    logging.basicConfig(level=logging.INFO)
+    logging.debug = logging_wrapper(logging.debug)
+    logging.info = logging_wrapper(logging.info)
+    logging.warning = logging_wrapper(logging.warning, "warn")
+    logging.error = logging_wrapper(logging.error, "error")
+    logging.critical = logging_wrapper(logging.critical, "error")
+
+    class BaseHandler(BaseHTTPRequestHandler):
+        # Re-implementation of BaseHTTPRequestHandler's log_message method to
+        # log to stdout instead of stderr.
+        def log_message(self, format, *args):
+            message = format % args
+            sys.stdout.write("%s - - [%s] %s\n" %
+                             (self.address_string(),
+                              self.log_date_time_string(),
+                              message.translate(self._control_char_table)))
+
+        # Re-implementation of BaseHTTPRequestHandler's handle_one_request method
+        # to send the end message after the response is fully sent.
+        def handle_one_request(self):
+            self.raw_requestline = self.rfile.readline(65537)
+            if not self.raw_requestline:
+                self.close_connection = True
+                return
+            if not self.parse_request():
+                return
+
+            invocationId = self.headers.get('x-vercel-internal-invocation-id')
+            requestId = int(self.headers.get('x-vercel-internal-request-id'))
+            del self.headers['x-vercel-internal-invocation-id']
+            del self.headers['x-vercel-internal-request-id']
+            del self.headers['x-vercel-internal-span-id']
+            del self.headers['x-vercel-internal-trace-id']
+
+            token = storage.set({
+                "invocationId": invocationId,
+                "requestId": requestId,
+            })
+
+            try:
+                self.handle_request()
+            finally:
+                storage.reset(token)
+                send_message({
+                    "type": "end",
+                    "payload": {
+                        "context": {
+                            "invocationId": invocationId,
+                            "requestId": requestId,
+                        }
+                    }
+                })
+
+    if 'handler' in __vc_variables or 'Handler' in __vc_variables:
+        base = __vc_module.handler if ('handler' in __vc_variables) else  __vc_module.Handler
+        if not issubclass(base, BaseHTTPRequestHandler):
+            print('Handler must inherit from BaseHTTPRequestHandler')
+            print('See the docs: https://vercel.com/docs/functions/serverless-functions/runtimes/python')
+            exit(1)
+
+        class Handler(BaseHandler, base):
+            def handle_request(self):
+                mname = 'do_' + self.command
+                if not hasattr(self, mname):
+                    self.send_error(
+                        http.HTTPStatus.NOT_IMPLEMENTED,
+                        "Unsupported method (%r)" % self.command)
+                    return
+                method = getattr(self, mname)
+                method()
+                self.wfile.flush()
+    elif 'app' in __vc_variables:
+        if (
+            not inspect.iscoroutinefunction(__vc_module.app) and
+            not inspect.iscoroutinefunction(__vc_module.app.__call__)
+        ):
+            from io import BytesIO
+
+            string_types = (str,)
+            app = __vc_module.app
+
+            def wsgi_encoding_dance(s, charset="utf-8", errors="replace"):
+                if isinstance(s, str):
+                    s = s.encode(charset)
+                return s.decode("latin1", errors)
+
+            class Handler(BaseHandler):
+                def handle_request(self):
+                    # Prepare WSGI environment
+                    if '?' in self.path:
+                        path, query = self.path.split('?', 1)
+                    else:
+                        path, query = self.path, ''
+                    content_length = int(self.headers.get('Content-Length', 0))
+                    env = {
+                        'CONTENT_LENGTH': str(content_length),
+                        'CONTENT_TYPE': self.headers.get('content-type', ''),
+                        'PATH_INFO': path,
+                        'QUERY_STRING': query,
+                        'REMOTE_ADDR': self.headers.get(
+                            'x-forwarded-for', self.headers.get(
+                                'x-real-ip')),
+                        'REQUEST_METHOD': self.command,
+                        'SERVER_NAME': self.headers.get('host', 'lambda'),
+                        'SERVER_PORT': self.headers.get('x-forwarded-port', '80'),
+                        'SERVER_PROTOCOL': 'HTTP/1.1',
+                        'wsgi.errors': sys.stderr,
+                        'wsgi.input': BytesIO(self.rfile.read(content_length)),
+                        'wsgi.multiprocess': False,
+                        'wsgi.multithread': False,
+                        'wsgi.run_once': False,
+                        'wsgi.url_scheme': self.headers.get('x-forwarded-proto', 'http'),
+                        'wsgi.version': (1, 0),
+                    }
+                    for key, value in env.items():
+                        if isinstance(value, string_types):
+                            env[key] = wsgi_encoding_dance(value)
+                    for k, v in self.headers.items():
+                        env['HTTP_' + k.replace('-', '_').upper()] = v
+                    # Response body
+                    body = BytesIO()
+
+                    def start_response(status, headers, exc_info=None):
+                        self.send_response(int(status.split(' ')[0]))
+                        for name, value in headers:
+                            self.send_header(name, value)
+                        self.end_headers()
+                        return body.write
+
+                    # Call the application
+                    response = app(env, start_response)
+                    try:
+                        for data in response:
+                            if data:
+                                body.write(data)
+                    finally:
+                        if hasattr(response, 'close'):
+                            response.close()
+                    body = body.getvalue()
+                    self.wfile.write(body)
+                    self.wfile.flush()
+        else:
+            from urllib.parse import urlparse
+            from io import BytesIO
+            import asyncio
+
+            app = __vc_module.app
+
+            class Handler(BaseHandler):
+                def handle_request(self):
+                    # Prepare ASGI scope
+                    url = urlparse(self.path)
+                    headers_encoded = []
+                    for k, v in self.headers.items():
+                        # Cope with repeated headers in the encoding.
+                        if isinstance(v, list):
+                            headers_encoded.append([k.lower().encode(), [i.encode() for i in v]])
+                        else:
+                            headers_encoded.append([k.lower().encode(), v.encode()])
+                    scope = {
+                        'server': (self.headers.get('host', 'lambda'), self.headers.get('x-forwarded-port', 80)),
+                        'client': (self.headers.get(
+                            'x-forwarded-for', self.headers.get(
+                                'x-real-ip')), 0),
+                        'scheme': self.headers.get('x-forwarded-proto', 'http'),
+                        'root_path': '',
+                        'query_string': url.query.encode(),
+                        'headers': headers_encoded,
+                        'type': 'http',
+                        'http_version': '1.1',
+                        'method': self.command,
+                        'path': url.path,
+                        'raw_path': url.path.encode(),
+                    }
+
+                    # Prepare ASGI receive function
+                    async def receive():
+                        if 'content-length' in self.headers:
+                            content_length = int(self.headers['content-length'])
+                            body = self.rfile.read(content_length)
+                            return {
+                                'type': 'http.request',
+                                'body': body,
+                                'more_body': False,
+                            }
+                        return {
+                            'type': 'http.request',
+                            'body': b'',
+                            'more_body': False,
+                        }
+
+                    # Prepare ASGI send function
+                    response_started = False
+                    async def send(event):
+                        nonlocal response_started
+                        if event['type'] == 'http.response.start':
+                            self.send_response(event['status'])
+                            if 'headers' in event:
+                                for name, value in event['headers']:
+                                    self.send_header(name.decode(), value.decode())
+                            self.end_headers()
+                            response_started = True
+                        elif event['type'] == 'http.response.body':
+                            self.wfile.write(event['body'])
+                            if not event.get('more_body', False):
+                                self.wfile.flush()
+
+                    # Run the ASGI application
+                    asyncio.run(app(scope, receive, send))
+
+    if 'Handler' in locals():
+        server = HTTPServer(('127.0.0.1', 0), Handler)
+        send_message({
+            "type": "server-started",
+            "payload": {
+                "initDuration": int((time.time() - start_time) * 1000),
+                "httpPort": server.server_address[1],
+            }
+        })
+        server.serve_forever()
+
+    print('Missing variable `handler` or `app` in file "__VC_HANDLER_ENTRYPOINT".')
+    print('See the docs: https://vercel.com/docs/functions/serverless-functions/runtimes/python')
+    exit(1)
 
 if 'handler' in __vc_variables or 'Handler' in __vc_variables:
     base = __vc_module.handler if ('handler' in __vc_variables) else  __vc_module.Handler