pylons__waitress-249

{
  "status": "ok",
  "stdout": "132:class ReadOnlyFileBasedBuffer(FileBasedBuffer):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "waitress/buffers.py",
  "content": "        return BytesIO()\n\nclass ReadOnlyFileBasedBuffer(FileBasedBuffer):\n    # used as wsgi.file_wrapper\n\n    def __init__(self, file, block_size=32768):\n        self.file = file\n        self.block_size = block_size # for __iter__\n\n    def prepare(self, size=None):\n        if hasattr(self.file, 'seek') and hasattr(self.file, 'tell'):\n            start_pos = self.file.tell()\n            self.file.seek(0, 2)\n            end_pos = self.file.tell()\n            self.file.seek(start_pos)\n            fsize = end_pos - start_pos\n            if size is None:\n                self.remain = fsize\n            else:\n                self.remain = min(fsize, size)\n        return self.remain\n\n    def get(self, numbytes=-1, skip=False):\n        # never read more than self.remain (it can be user-specified)\n        if numbytes == -1 or numbytes > self.remain:\n            numbytes = self.remain\n        file = self.file\n        if not skip:\n            read_pos = file.tell()\n        res = file.read(numbytes)\n        if skip:\n            self.remain -= len(res)\n        else:\n            file.seek(read_pos)\n        return res\n\n    def __iter__(self): # called by task if self.filelike has no seek/tell\n        return self\n\n    def next(self):\n        val = self.file.read(self.block_size)",
  "start_line": 130,
  "end_line": 170,
  "total_lines": 298,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "waitress/buffers.py",
  "content": "class BytesIOBasedBuffer(FileBasedBuffer):\n\n    def __init__(self, from_buffer=None):\n        if from_buffer is not None:\n            FileBasedBuffer.__init__(self, BytesIO(), from_buffer)\n        else:\n            # Shortcut. :-)\n            self.file = BytesIO()\n\n    def newfile(self):\n        return BytesIO()\n",
  "start_line": 120,
  "end_line": 131,
  "total_lines": 298,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "waitress/buffers.py",
  "content": "##############################################################################\n#\n# Copyright (c) 2001-2004 Zope Foundation and Contributors.\n# All Rights Reserved.\n#\n# This software is subject to the provisions of the Zope Public License,\n# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.\n# THIS SOFTWARE IS PROVIDED \"AS IS\" AND ANY AND ALL EXPRESS OR IMPLIED\n# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS\n# FOR A PARTICULAR PURPOSE.\n#\n##############################################################################\n\"\"\"Buffers\n\"\"\"\nfrom io import BytesIO\n\n# copy_bytes controls the size of temp. strings for shuffling data around.\nCOPY_BYTES = 1 << 18 # 256K\n\n# The maximum number of bytes to buffer in a simple string.\nSTRBUF_LIMIT = 8192\n\nclass FileBasedBuffer(object):\n\n    remain = 0\n\n    def __init__(self, file, from_buffer=None):\n        self.file = file\n        if from_buffer is not None:\n            from_file = from_buffer.getfile()\n            read_pos = from_file.tell()\n            from_file.seek(0)\n            while True:\n                data = from_file.read(COPY_BYTES)\n                if not data:\n                    break\n                file.write(data)\n            self.remain = int(file.tell() - read_pos)\n            from_file.seek(read_pos)\n            file.seek(read_pos)\n\n    def __len__(self):\n        return self.remain\n\n    def __nonzero__(self):\n        return True\n\n    __bool__ = __nonzero__ # py3\n\n    def append(self, s):\n        file = self.file\n        read_pos = file.tell()\n        file.seek(0, 2)\n        file.write(s)\n        file.seek(read_pos)\n        self.remain = self.remain + len(s)\n\n    def get(self, numbytes=-1, skip=False):\n        file = self.file\n        if not skip:\n            read_pos = file.tell()\n        if numbytes < 0:\n            # Read all\n            res = file.read()\n        else:\n            res = file.read(numbytes)\n        if skip:\n            self.remain -= len(res)\n        else:\n            file.seek(read_pos)\n        return res\n\n    def skip(self, numbytes, allow_prune=0):\n        if self.remain < numbytes:\n            raise ValueError(\"Can't skip %d bytes in buffer of %d bytes\" % (\n                numbytes, self.remain)\n            )\n        self.file.seek(numbytes, 1)\n        self.remain = self.remain - numbytes\n\n    def newfile(self):\n        raise NotImplementedError()\n\n    def prune(self):\n        file = self.file\n        if self.remain == 0:\n            read_pos = file.tell()\n            file.seek(0, 2)\n            sz = file.tell()\n            file.seek(read_pos)\n            if sz == 0:\n                # Nothing to prune.\n                return\n        nf = self.newfile()\n        while True:\n            data = file.read(COPY_BYTES)\n            if not data:\n                break\n            nf.write(data)\n        self.file = nf\n\n    def getfile(self):\n        return self.file\n\n    def close(self):\n        if hasattr(self.file, 'close'):\n            self.file.close()\n        self.remain = 0\n\nclass TempfileBasedBuffer(FileBasedBuffer):\n\n    def __init__(self, from_buffer=None):\n        FileBasedBuffer.__init__(self, self.newfile(), from_buffer)\n\n    def newfile(self):\n        from tempfile import TemporaryFile\n        return TemporaryFile('w+b')\n\nclass BytesIOBasedBuffer(FileBasedBuffer):",
  "start_line": 1,
  "end_line": 120,
  "total_lines": 298,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "Calling prepare()...\nCaught expected UnsupportedOperation in prepare\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "waitress/buffers.py",
  "content": "        val = self.file.read(self.block_size)\n        if not val:\n            raise StopIteration\n        return val\n\n    __next__ = next # py3\n\n    def append(self, s):\n        raise NotImplementedError\n\nclass OverflowableBuffer(object):",
  "start_line": 170,
  "end_line": 180,
  "total_lines": 298,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "./waitress/buffers.py:132:class ReadOnlyFileBasedBuffer(FileBasedBuffer):\n./waitress/channel.py:21:    ReadOnlyFileBasedBuffer,\n./waitress/channel.py:309:                if data.__class__ is ReadOnlyFileBasedBuffer:\n./waitress/task.py:21:from .buffers import ReadOnlyFileBasedBuffer\n./waitress/task.py:451:            if app_iter.__class__ is ReadOnlyFileBasedBuffer:\n./waitress/task.py:788:            'wsgi.file_wrapper': ReadOnlyFileBasedBuffer,\n./waitress/tests/test_task.py:614:        from waitress.buffers import ReadOnlyFileBasedBuffer\n./waitress/tests/test_task.py:616:        app_iter = ReadOnlyFileBasedBuffer(f, 8192)\n./waitress/tests/test_task.py:627:        from waitress.buffers import ReadOnlyFileBasedBuffer\n./waitress/tests/test_task.py:629:        app_iter = ReadOnlyFileBasedBuffer(f, 8192)\n./waitress/tests/test_task.py:641:        from waitress.buffers import ReadOnlyFileBasedBuffer\n./waitress/tests/test_task.py:643:        app_iter = ReadOnlyFileBasedBuffer(f, 8192)\n./waitress/tests/test_buffers.py:146:class TestReadOnlyFileBasedBuffer(unittest.TestCase):\n./waitress/tests/test_buffers.py:149:        from waitress.buffers import ReadOnlyFileBasedBuffer\n./waitress/tests/test_buffers.py:150:        return ReadOnlyFileBasedBuffer(file, block_size)\n./waitress/tests/test_channel.py:211:        from waitress.buffers import ReadOnlyFileBasedBuffer\n./waitress/tests/test_channel.py:213:        wrapper = ReadOnlyFileBasedBuffer(f, 8192)\n./HISTORY.txt:123:- FileBasedBuffer and more important ReadOnlyFileBasedBuffer no longer report\n./HISTORY.txt:177:  (ReadOnlyFileBasedBuffer) a ``close`` method.  Do not call ``close`` on an\n",
  "stderr": "grep: ./waitress/__pycache__/task.cpython-37.pyc: binary file matches\ngrep: ./waitress/__pycache__/buffers.cpython-37.pyc: binary file matches\ngrep: ./waitress/__pycache__/channel.cpython-37.pyc: binary file matches\n",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "waitress/task.py",
  "content": "\n            self.response_headers.extend(headers)\n\n            # Return a method used to write the response data.\n            return self.write\n\n        # Call the application to handle the request and write a response\n        app_iter = self.channel.server.application(env, start_response)\n\n        can_close_app_iter = True\n        try:\n            if app_iter.__class__ is ReadOnlyFileBasedBuffer:\n                cl = self.content_length\n                size = app_iter.prepare(cl)\n                if size:\n                    if cl != size:\n                        if cl is not None:\n                            self.remove_content_length_header()\n                        self.content_length = size\n                    self.write(b'') # generate headers\n                    # if the write_soon below succeeds then the channel will",
  "start_line": 440,
  "end_line": 460,
  "total_lines": 833,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "waitress/task.py",
  "content": "                    # take over closing the underlying file via the channel's\n                    # _flush_some or handle_close so we intentionally avoid\n                    # calling close in the finally block\n                    self.channel.write_soon(app_iter)\n                    can_close_app_iter = False\n                    return\n\n            first_chunk_len = None\n            for chunk in app_iter:\n                if first_chunk_len is None:\n                    first_chunk_len = len(chunk)\n                    # Set a Content-Length header if one is not supplied.\n                    # start_response may not have been called until first\n                    # iteration as per PEP, so we must reinterrogate\n                    # self.content_length here\n                    if self.content_length is None:\n                        app_iter_len = None\n                        if hasattr(app_iter, '__len__'):\n                            app_iter_len = len(app_iter)\n                        if app_iter_len == 1:",
  "start_line": 461,
  "end_line": 480,
  "total_lines": 833,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "waitress/channel.py",
  "content": "            # can cleanup possibly before the app_iter is exhausted\n            raise ClientDisconnected\n        if data:\n            # the async mainloop might be popping data off outbuf; we can\n            # block here waiting for it because we're in a task thread\n            with self.outbuf_lock:\n                self._flush_outbufs_below_high_watermark()\n                if not self.connected:\n                    raise ClientDisconnected\n                if data.__class__ is ReadOnlyFileBasedBuffer:\n                    # they used wsgi.file_wrapper\n                    self.outbufs.append(data)\n                    nextbuf = OverflowableBuffer(self.adj.outbuf_overflow)\n                    self.outbufs.append(nextbuf)\n                    self.current_outbuf_count = 0\n                else:\n                    if self.current_outbuf_count > self.adj.outbuf_high_watermark:\n                        # rotate to a new buffer if the current buffer has hit\n                        # the watermark to avoid it growing unbounded\n                        nextbuf = OverflowableBuffer(self.adj.outbuf_overflow)\n                        self.outbufs.append(nextbuf)",
  "start_line": 300,
  "end_line": 320,
  "total_lines": 415,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "56:    total_outbufs_len = 0        # total bytes ready to send\n73:        self.outbufs = [OverflowableBuffer(adj.outbuf_overflow)]\n91:        return self.total_outbufs_len or self.will_close\n108:        elif self.total_outbufs_len >= self.adj.send_bytes:\n130:        if self.close_when_flushed and not self.total_outbufs_len:\n143:        return not (self.will_close or self.requests or self.total_outbufs_len)\n180:                    self.outbufs[-1].append(outbuf_payload)\n182:                    self.total_outbufs_len += len(outbuf_payload)\n211:                if self.total_outbufs_len < self.adj.outbuf_high_watermark:\n223:            outbuf = self.outbufs[0]\n234:                    self.total_outbufs_len -= num_sent\n240:                # self.outbufs[-1] must always be a writable outbuf\n241:                if len(self.outbufs) > 1:\n242:                    toclose = self.outbufs.pop(0)\n263:            for outbuf in self.outbufs:\n269:            self.total_outbufs_len = 0\n306:                self._flush_outbufs_below_high_watermark()\n311:                    self.outbufs.append(data)\n313:                    self.outbufs.append(nextbuf)\n320:                        self.outbufs.append(nextbuf)\n322:                    self.outbufs[-1].append(data)\n325:                self.total_outbufs_len += num_bytes\n333:    def _flush_outbufs_below_high_watermark(self):\n335:        if self.total_outbufs_len > self.adj.outbuf_high_watermark:\n339:                    self.total_outbufs_len > self.adj.outbuf_high_watermark\n395:                    # much data in the outbufs waiting to be flushed\n402:                        self._flush_outbufs_below_high_watermark()\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "waitress/channel.py",
  "content": "\n                if self.total_outbufs_len < self.adj.outbuf_high_watermark:\n                    self.outbuf_lock.notify()\n            finally:\n                self.outbuf_lock.release()\n\n    def _flush_some(self):\n        # Send as much data as possible to our client\n\n        sent = 0\n        dobreak = False\n\n        while True:\n            outbuf = self.outbufs[0]\n            # use outbuf.__len__ rather than len(outbuf) FBO of not getting\n            # OverflowError on 32-bit Python\n            outbuflen = outbuf.__len__()\n            while outbuflen > 0:\n                chunk = outbuf.get(self.sendbuf_len)\n                num_sent = self.send(chunk)\n                if num_sent:\n                    outbuf.skip(num_sent, True)\n                    outbuflen -= num_sent\n                    sent += num_sent\n                    self.total_outbufs_len -= num_sent\n                else:\n                    # failed to write anything, break out entirely\n                    dobreak = True\n                    break\n            else:\n                # self.outbufs[-1] must always be a writable outbuf\n                if len(self.outbufs) > 1:\n                    toclose = self.outbufs.pop(0)\n                    try:\n                        toclose.close()\n                    except Exception:\n                        self.logger.exception(\n                            'Unexpected error when closing an outbuf')\n                else:\n                    # caught up, done flushing for now\n                    dobreak = True",
  "start_line": 210,
  "end_line": 250,
  "total_lines": 415,
  "is_truncated": false
}