1306

pending completion

Build # 1306

Build Type

Pull #253

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/quantmind/pulsar/commit/<a class=hub.com/quantmind/pulsar/commit/552cbb19885f393ba59a3b4f8fc49f808421abf1">552cbb198<a href="https://github.com/quantmind/pulsar/commit/552cbb19885f393ba59a3b4f8fc49f808421abf1">&quot;&gt;Revert &amp;quot;Make MultipartDecoder asynchronous&quot;

This reverts commit </a><a class="double-link" href="https://github.com/quantmind/pulsar/commit/<a class="double-link" href="https://github.com/quantmind/pulsar/commit/2036963c4031a9bb76450c72dbc26f5859cb74b8">2036963c4</a>">2036963c4</a><a href="https://github.com/quantmind/pulsar/commit/552cbb19885f393ba59a3b4f8fc49f808421abf1">.

Pull Request Pull Request #253: Fix: uploading large files

Run Details

9 of 9 new or added lines in 1 file covered. (100.0%)

13840 of 15884 relevant lines covered (87.13%)

0.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.56

/pulsar/apps/wsgi/formdata.py

import email.parser
import asyncio
from http.client import HTTPMessage, _MAXLINE, _MAXHEADERS
from io import BytesIO
from urllib.parse import parse_qs
from base64 import b64encode
from functools import reduce
from cgi import valid_boundary, parse_header

from pulsar import HttpException, BadRequest, isawaitable, ensure_future
from pulsar.utils.system import json
from pulsar.utils.structures import MultiValueDict, mapping_iterator
from pulsar.utils.httpurl import (DEFAULT_CHARSET, ENCODE_BODY_METHODS,
                                  JSON_CONTENT_TYPES, parse_options_header)


ONEMB = 2**20
# Default max size for body when not streaming
DEFAULT_MAXSIZE = 10*ONEMB

FORM_ENCODED_TYPES = ('application/x-www-form-urlencoded',
                      'application/x-url-encoded')
BODY_DATA = 0
BODY_FILES = 1
LARGE_BODY_CODE = 403


def http_protocol(parser):
    version = parser.get_version()
    return "HTTP/%s" % ".".join(('%s' % v for v in version))


class HttpBodyReader:
    _expect_sent = None
    _waiting = None

    def __init__(self, headers, parser, transport, **kw):
        self.headers = headers
        self.parser = parser
        self.reader = asyncio.StreamReader(**kw)
        self.reader.set_transport(transport)
        self.feed_data = self.reader.feed_data
        self.feed_eof = self.reader.feed_eof

    def waiting_expect(self):
        '''``True`` when the client is waiting for 100 Continue.
        '''
        if self._expect_sent is None:
            if (not self.reader.at_eof() and
                    self.headers.has('expect', '100-continue')):
                return True
            self._expect_sent = ''
        return False

    def can_continue(self):
        if self.waiting_expect():
            if self.parser.get_version() < (1, 1):
                raise HttpException(status=417)
            else:
                msg = '%s 100 Continue\r\n\r\n' % http_protocol(self.parser)
                self._expect_sent = msg
                self.reader._transport.write(msg.encode(DEFAULT_CHARSET))

    def fail(self):
        if self.waiting_expect():
            raise HttpException(status=417)

    def read(self, n=-1):
        self.can_continue()
        return self.reader.read(n=n)

    def readline(self):
        self.can_continue()
        return self.reader.readline()

    def readexactly(self, n):
        self.can_continue()
        return self.reader.readexactly(n)

    @property
    def limit(self):
        return self.reader._limit

    def readuntil(self, separator):
        self.can_continue()
        return self.reader.readuntil(separator)


def parse_form_data(environ, stream=None, **kw):
    '''Parse form data from an environ dict and return a (forms, files) tuple.

    Both tuple values are dictionaries with the form-field name as a key
    (unicode) and lists as values (multiple values per key are possible).
    The forms-dictionary contains form-field values as unicode strings.
    The files-dictionary contains :class:`MultipartPart` instances, either
    because the form-field was a file-upload or the value is to big to fit
    into memory limits.

    :parameter environ: A WSGI environment dict.
    :parameter stream: Optional callable accepting one parameter only, the
        instance of :class:`FormDecoder` being parsed. If provided, the
        callable is invoked when data or partial data has been successfully
        parsed.
    '''
    method = environ.get('REQUEST_METHOD', 'GET').upper()
    if method not in ENCODE_BODY_METHODS:
        raise HttpException(status=422)

    content_type = environ.get('CONTENT_TYPE')
    if content_type:
        content_type, options = parse_options_header(content_type)
        options.update(kw)
    else:
        options = kw

    if content_type == 'multipart/form-data':
        decoder = MultipartDecoder(environ, options, stream)
    elif content_type in FORM_ENCODED_TYPES:
        decoder = UrlEncodedDecoder(environ, options, stream)
    elif content_type in JSON_CONTENT_TYPES:
        decoder = JsonDecoder(environ, options, stream)
    else:
        decoder = BytesDecoder(environ, options, stream)

    return decoder.parse()


class FormDecoder:

    def __init__(self, environ, options, stream):
        self.environ = environ
        self.options = options
        self.stream = stream
        self.result = (MultiValueDict(), MultiValueDict())

    @property
    def content_length(self):
        return int(self.environ.get('CONTENT_LENGTH', -1))

    @property
    def charset(self):
        return self.options.get('charset', 'utf-8')

    def parse(self):
        raise NotImplementedError


class MultipartDecoder(FormDecoder):
    boundary = None

    def parse(self):
        boundary = self.options.get('boundary', '')
        if not valid_boundary(boundary):
            raise HttpException("Invalid boundary for multipart/form-data",
                                status=422)
        inp = self.environ.get('wsgi.input') or BytesIO()
        self.buffer = bytearray()

        if isinstance(inp, HttpBodyReader):
            return ensure_future(self._consume(inp, boundary),
                                 loop=inp.reader._loop)
        else:
            producer = BytesProducer(inp)
            return producer(self._consume, boundary)

    async def _consume(self, fp, boundary):
        sep = b'--'
        nextpart = ('--%s' % boundary).encode()
        lastpart = ("--%s--" % boundary).encode()
        terminator = b""

        while terminator != lastpart:
            nbytes = -1
            data = None
            current = None

            if terminator:
                headers = await parse_headers(fp)
                current = MultipartPart(self, headers)

                if nbytes > 0:
                    data = await fp.read(nbytes)
                else:
                    data = b''

                if current.name:
                    current.feed_data(data)
                else:
                    current = None

            while 1:
                try:
                    line = await fp.readuntil(b'\n')
                except asyncio.streams.LimitOverrunError as e:
                    line = await fp.read(fp.limit)
                line = line or lastpart
                if line.startswith(sep):
                    terminator = line.rstrip()
                    if terminator in (nextpart, lastpart):
                        break
                if current:
                    current.feed_data(line)

            # Done with part.
            if current:
                current.done()

        self.environ['wsgi.input'] = BytesIO(self.buffer)
        return self.result


class BytesDecoder(FormDecoder):

    def parse(self, mem_limit=None, **kw):
        mem_limit = mem_limit or DEFAULT_MAXSIZE
        if self.content_length > mem_limit:
            raise HttpException("Request to big. Increase MAXMEM.",
                                status=LARGE_BODY_CODE)
        inp = self.environ.get('wsgi.input') or BytesIO()
        data = inp.read()

        if isawaitable(data):
            return ensure_future(self._async(data))
        else:
            return self._ready(data)

    async def _async(self, chunk):
        chunk = await chunk
        return self._ready(chunk)

    def _ready(self, data):
        self.environ['wsgi.input'] = BytesIO(data)
        self.result = (data, None)
        return self.result


class UrlEncodedDecoder(BytesDecoder):

    def _ready(self, data):
        self.environ['wsgi.input'] = BytesIO(data)
        charset = self.charset
        data = parse_qs(data.decode(charset), keep_blank_values=True)
        forms = self.result[0]
        for key, values in mapping_iterator(data):
            for value in values:
                forms[key] = value
        return self.result


class JsonDecoder(BytesDecoder):

    def _ready(self, data):
        self.environ['wsgi.input'] = BytesIO(data)
        try:
            self.result = (json.loads(data.decode(self.charset)), None)
        except Exception as exc:
            raise BadRequest('Could not decode JSON') from exc
        return self.result


class MultipartPart:
    filename = None
    name = ''

    def __init__(self, parser, headers):
        self.parser = parser
        self.headers = headers
        self._bytes = []
        self._done = False
        length = headers.get('content-length')
        content = headers.get('content-disposition')
        if length:
            try:
                length = int(length)
            except ValueError:
                length = -1
        else:
            length = -1
        self.length = length
        if content:
            key, params = parse_header(content)
            name = params.get('name')
            if key == 'form-data' and name:
                self.name = name
                self.filename = params.get('filename')

    def __repr__(self):
        return self.name

    @property
    def charset(self):
        return self.parser.charset

    @property
    def content_type(self):
        return self.headers.get('Content-Type')

    @property
    def size(self):
        return reduce(lambda x, y: x+len(y), self._bytes, 0)

    def bytes(self):
        '''Bytes'''
        return b''.join(self._bytes)

    def bytesio(self):
        return BytesIO(self.recv())

    def base64(self, charset=None):
        '''Data encoded as base 64'''
        return b64encode(self.bytes()).decode(charset or self.charset)

    def string(self, charset=None):
        '''Data decoded with the specified charset'''
        return self.bytes().decode(charset or self.charset)

    def complete(self):
        return self._done

    def feed_data(self, data):
        if data:
            self._bytes.append(data)
            if self.parser.stream:
                self.parser.stream(self)
            else:
                self.parser.buffer.extend(data)

    def recv(self, size=-1):
        if self._done:
            data = self._bytes
            self._bytes = []
        else:
            data = self._bytes[:-1]
            self._bytes = self._bytes[-1:]
        return b''.join(data)

    def is_file(self):
        return self.filename or self.content_type not in (None, 'text/plain')

    def done(self):
        if not self._done:

            if self._bytes and self.length < 0:
                # Strip final line terminator
                line = self._bytes[-1]
                if line[-2:] == b"\r\n":
                    line = line[:-2]
                elif line[-1:] == b"\n":
                    line = line[:-1]
                self._bytes[-1] = line

            self._done = True
            if self.parser.stream:
                self.parser.stream(self)

            if self.is_file():
                self.parser.result[1][self.name] = self
            else:
                self.parser.result[0][self.name] = self.string()


async def parse_headers(fp, _class=HTTPMessage):
    """Parses only RFC2822 headers from a file pointer.
    email Parser wants to see strings rather than bytes.
    But a TextIOWrapper around self.rfile would buffer too many bytes
    from the stream, bytes which we later need to read as bytes.
    So we read the correct bytes here, as bytes, for email Parser
    to parse.
    """
    headers = []
    while True:
        line = await fp.readline()
        if len(line) > _MAXLINE:
            raise HttpException("header line")
        headers.append(line)
        if len(headers) > _MAXHEADERS:
            raise HttpException("got more than %d headers" % _MAXHEADERS)
        if line in (b'\r\n', b'\n', b''):
            break
    hstring = b''.join(headers).decode('iso-8859-1')
    return email.parser.Parser(_class=_class).parsestr(hstring)


class BytesProducer:

    def __init__(self, bytes):
        self.bytes = bytes

    async def readline(self):
        return self.bytes.readline()

    async def read(self):
        return self.bytes.read()

    def __call__(self, consumer, *args):
        value = None
        coro = consumer(self, *args)
        while True:
            try:
                value = coro.send(value)
            except StopIteration as exc:
                value = exc.value
                break
        return value

1	import email.parser	1✔
2	import asyncio	1✔
3	from http.client import HTTPMessage, _MAXLINE, _MAXHEADERS	1✔
4	from io import BytesIO	1✔
5	from urllib.parse import parse_qs	1✔
6	from base64 import b64encode	1✔
7	from functools import reduce	1✔
8	from cgi import valid_boundary, parse_header	1✔
9
10	from pulsar import HttpException, BadRequest, isawaitable, ensure_future	1✔
11	from pulsar.utils.system import json	1✔
12	from pulsar.utils.structures import MultiValueDict, mapping_iterator	1✔
13	from pulsar.utils.httpurl import (DEFAULT_CHARSET, ENCODE_BODY_METHODS,	1✔
14	JSON_CONTENT_TYPES, parse_options_header)
15
16
17	ONEMB = 2**20	1✔
18	# Default max size for body when not streaming
19	DEFAULT_MAXSIZE = 10*ONEMB	1✔
20
21	FORM_ENCODED_TYPES = ('application/x-www-form-urlencoded',	1✔
22	'application/x-url-encoded')
23	BODY_DATA = 0	1✔
24	BODY_FILES = 1	1✔
25	LARGE_BODY_CODE = 403	1✔
26
27
28	def http_protocol(parser):	1✔
29	version = parser.get_version()	1✔
30	return "HTTP/%s" % ".".join(('%s' % v for v in version))	1✔
31
32
33	class HttpBodyReader:	1✔
34	_expect_sent = None	1✔
35	_waiting = None	1✔
36
37	def __init__(self, headers, parser, transport, **kw):	1✔
38	self.headers = headers	1✔
39	self.parser = parser	1✔
40	self.reader = asyncio.StreamReader(**kw)	1✔
41	self.reader.set_transport(transport)	1✔
42	self.feed_data = self.reader.feed_data	1✔
43	self.feed_eof = self.reader.feed_eof	1✔
44
45	def waiting_expect(self):	1✔
46	'''``True`` when the client is waiting for 100 Continue.
47	'''
48	if self._expect_sent is None:	1✔
49	if (not self.reader.at_eof() and	1✔
50	self.headers.has('expect', '100-continue')):
51	return True	1✔
52	self._expect_sent = ''	1✔
53	return False	1✔
54
55	def can_continue(self):	1✔
56	if self.waiting_expect():	1✔
57	if self.parser.get_version() < (1, 1):	1✔
58	raise HttpException(status=417)	×
59	else:
60	msg = '%s 100 Continue\r\n\r\n' % http_protocol(self.parser)	1✔
61	self._expect_sent = msg	1✔
62	self.reader._transport.write(msg.encode(DEFAULT_CHARSET))	1✔
63
64	def fail(self):	1✔
65	if self.waiting_expect():	1✔
66	raise HttpException(status=417)	1✔
67
68	def read(self, n=-1):	1✔
69	self.can_continue()	1✔
70	return self.reader.read(n=n)	1✔
71
72	def readline(self):	1✔
73	self.can_continue()	1✔
74	return self.reader.readline()	1✔
75
76	def readexactly(self, n):	1✔
77	self.can_continue()	×
78	return self.reader.readexactly(n)	×
79
80	@property	1✔
81	def limit(self):
82	return self.reader._limit	×
83
84	def readuntil(self, separator):	1✔
85	self.can_continue()	1✔
86	return self.reader.readuntil(separator)	1✔
87
88
89	def parse_form_data(environ, stream=None, **kw):	1✔
90	'''Parse form data from an environ dict and return a (forms, files) tuple.
91
92	Both tuple values are dictionaries with the form-field name as a key
93	(unicode) and lists as values (multiple values per key are possible).
94	The forms-dictionary contains form-field values as unicode strings.
95	The files-dictionary contains :class:`MultipartPart` instances, either
96	because the form-field was a file-upload or the value is to big to fit
97	into memory limits.
98
99	:parameter environ: A WSGI environment dict.
100	:parameter stream: Optional callable accepting one parameter only, the
101	instance of :class:`FormDecoder` being parsed. If provided, the
102	callable is invoked when data or partial data has been successfully
103	parsed.
104	'''
105	method = environ.get('REQUEST_METHOD', 'GET').upper()	1✔
106	if method not in ENCODE_BODY_METHODS:	1✔
107	raise HttpException(status=422)	×
108
109	content_type = environ.get('CONTENT_TYPE')	1✔
110	if content_type:	1✔
111	content_type, options = parse_options_header(content_type)	1✔
112	options.update(kw)	1✔
113	else:
114	options = kw	×
115
116	if content_type == 'multipart/form-data':	1✔
117	decoder = MultipartDecoder(environ, options, stream)	1✔
118	elif content_type in FORM_ENCODED_TYPES:	1✔
119	decoder = UrlEncodedDecoder(environ, options, stream)	1✔
120	elif content_type in JSON_CONTENT_TYPES:	1✔
121	decoder = JsonDecoder(environ, options, stream)	1✔
122	else:
123	decoder = BytesDecoder(environ, options, stream)	1✔
124
125	return decoder.parse()	1✔
126
127
128	class FormDecoder:	1✔
129
130	def __init__(self, environ, options, stream):	1✔
131	self.environ = environ	1✔
132	self.options = options	1✔
133	self.stream = stream	1✔
134	self.result = (MultiValueDict(), MultiValueDict())	1✔
135
136	@property	1✔
137	def content_length(self):
138	return int(self.environ.get('CONTENT_LENGTH', -1))	1✔
139
140	@property	1✔
141	def charset(self):
142	return self.options.get('charset', 'utf-8')	1✔
143
144	def parse(self):	1✔
145	raise NotImplementedError
146
147
148	class MultipartDecoder(FormDecoder):	1✔
149	boundary = None	1✔
150
151	def parse(self):	1✔
152	boundary = self.options.get('boundary', '')	1✔
153	if not valid_boundary(boundary):	1✔
154	raise HttpException("Invalid boundary for multipart/form-data",	×
155	status=422)
156	inp = self.environ.get('wsgi.input') or BytesIO()	1✔
157	self.buffer = bytearray()	1✔
158
159	if isinstance(inp, HttpBodyReader):	1✔
160	return ensure_future(self._consume(inp, boundary),	1✔
161	loop=inp.reader._loop)
162	else:
163	producer = BytesProducer(inp)	1✔
164	return producer(self._consume, boundary)	1✔
165
166	async def _consume(self, fp, boundary):	1✔
167	sep = b'--'	1✔
168	nextpart = ('--%s' % boundary).encode()	1✔
169	lastpart = ("--%s--" % boundary).encode()	1✔
170	terminator = b""	1✔
171
172	while terminator != lastpart:	1✔
173	nbytes = -1	1✔
174	data = None	1✔
175	current = None	1✔
176
177	if terminator:	1✔
178	headers = await parse_headers(fp)	1✔
179	current = MultipartPart(self, headers)	1✔
180
181	if nbytes > 0:	1✔
182	data = await fp.read(nbytes)	×
183	else:
184	data = b''	1✔
185
186	if current.name:	1✔
187	current.feed_data(data)	1✔
188	else:
189	current = None	×
190
191	while 1:	1✔
192	try:	1✔
193	line = await fp.readuntil(b'\n')	1✔
194	except asyncio.streams.LimitOverrunError as e:	1✔
195	line = await fp.read(fp.limit)	×
196	line = line or lastpart	1✔
197	if line.startswith(sep):	1✔
198	terminator = line.rstrip()	1✔
199	if terminator in (nextpart, lastpart):	1✔
200	break	1✔
201	if current:	1✔
202	current.feed_data(line)	1✔
203
204	# Done with part.
205	if current:	1✔
206	current.done()	1✔
207
208	self.environ['wsgi.input'] = BytesIO(self.buffer)	1✔
209	return self.result	1✔
210
211
212	class BytesDecoder(FormDecoder):	1✔
213
214	def parse(self, mem_limit=None, **kw):	1✔
215	mem_limit = mem_limit or DEFAULT_MAXSIZE	1✔
216	if self.content_length > mem_limit:	1✔
217	raise HttpException("Request to big. Increase MAXMEM.",	×
218	status=LARGE_BODY_CODE)
219	inp = self.environ.get('wsgi.input') or BytesIO()	1✔
220	data = inp.read()	1✔
221
222	if isawaitable(data):	1✔
223	return ensure_future(self._async(data))	1✔
224	else:
225	return self._ready(data)	1✔
226
227	async def _async(self, chunk):	1✔
228	chunk = await chunk	1✔
229	return self._ready(chunk)	1✔
230
231	def _ready(self, data):	1✔
232	self.environ['wsgi.input'] = BytesIO(data)	1✔
233	self.result = (data, None)	1✔
234	return self.result	1✔
235
236
237	class UrlEncodedDecoder(BytesDecoder):	1✔
238
239	def _ready(self, data):	1✔
240	self.environ['wsgi.input'] = BytesIO(data)	1✔
241	charset = self.charset	1✔
242	data = parse_qs(data.decode(charset), keep_blank_values=True)	1✔
243	forms = self.result[0]	1✔
244	for key, values in mapping_iterator(data):	1✔
245	for value in values:	1✔
246	forms[key] = value	1✔
247	return self.result	1✔
248
249
250	class JsonDecoder(BytesDecoder):	1✔
251
252	def _ready(self, data):	1✔
253	self.environ['wsgi.input'] = BytesIO(data)	1✔
254	try:	1✔
255	self.result = (json.loads(data.decode(self.charset)), None)	1✔
256	except Exception as exc:	×
257	raise BadRequest('Could not decode JSON') from exc	×
258	return self.result	1✔
259
260
261	class MultipartPart:	1✔
262	filename = None	1✔
263	name = ''	1✔
264
265	def __init__(self, parser, headers):	1✔
266	self.parser = parser	1✔
267	self.headers = headers	1✔
268	self._bytes = []	1✔
269	self._done = False	1✔
270	length = headers.get('content-length')	1✔
271	content = headers.get('content-disposition')	1✔
272	if length:	1✔
273	try:	×
274	length = int(length)	×
275	except ValueError:	×
276	length = -1	×
277	else:
278	length = -1	1✔
279	self.length = length	1✔
280	if content:	1✔
281	key, params = parse_header(content)	1✔
282	name = params.get('name')	1✔
283	if key == 'form-data' and name:	1✔
284	self.name = name	1✔
285	self.filename = params.get('filename')	1✔
286
287	def __repr__(self):	1✔
288	return self.name	×
289
290	@property	1✔
291	def charset(self):
292	return self.parser.charset	1✔
293
294	@property	1✔
295	def content_type(self):
296	return self.headers.get('Content-Type')	1✔
297
298	@property	1✔
299	def size(self):
300	return reduce(lambda x, y: x+len(y), self._bytes, 0)	×
301
302	def bytes(self):	1✔
303	'''Bytes'''
304	return b''.join(self._bytes)	1✔
305
306	def bytesio(self):	1✔
307	return BytesIO(self.recv())	×
308
309	def base64(self, charset=None):	1✔
310	'''Data encoded as base 64'''
311	return b64encode(self.bytes()).decode(charset or self.charset)	×
312
313	def string(self, charset=None):	1✔
314	'''Data decoded with the specified charset'''
315	return self.bytes().decode(charset or self.charset)	1✔
316
317	def complete(self):	1✔
318	return self._done	1✔
319
320	def feed_data(self, data):	1✔
321	if data:	1✔
322	self._bytes.append(data)	1✔
323	if self.parser.stream:	1✔
324	self.parser.stream(self)	1✔
325	else:
326	self.parser.buffer.extend(data)	×
327
328	def recv(self, size=-1):	1✔
329	if self._done:	1✔
330	data = self._bytes	1✔
331	self._bytes = []	1✔
332	else:
333	data = self._bytes[:-1]	1✔
334	self._bytes = self._bytes[-1:]	1✔
335	return b''.join(data)	1✔
336
337	def is_file(self):	1✔
338	return self.filename or self.content_type not in (None, 'text/plain')	1✔
339
340	def done(self):	1✔
341	if not self._done:	1✔
342
343	if self._bytes and self.length < 0:	1✔
344	# Strip final line terminator
345	line = self._bytes[-1]	1✔
346	if line[-2:] == b"\r\n":	1✔
347	line = line[:-2]	1✔
348	elif line[-1:] == b"\n":	×
349	line = line[:-1]	×
350	self._bytes[-1] = line	1✔
351
352	self._done = True	1✔
353	if self.parser.stream:	1✔
354	self.parser.stream(self)	1✔
355
356	if self.is_file():	1✔
357	self.parser.result[1][self.name] = self	1✔
358	else:
359	self.parser.result[0][self.name] = self.string()	1✔
360
361
362	async def parse_headers(fp, _class=HTTPMessage):	1✔
363	"""Parses only RFC2822 headers from a file pointer.
364	email Parser wants to see strings rather than bytes.
365	But a TextIOWrapper around self.rfile would buffer too many bytes
366	from the stream, bytes which we later need to read as bytes.
367	So we read the correct bytes here, as bytes, for email Parser
368	to parse.
369	"""
370	headers = []	1✔
371	while True:	1✔
372	line = await fp.readline()	1✔
373	if len(line) > _MAXLINE:	1✔
374	raise HttpException("header line")	×
375	headers.append(line)	1✔
376	if len(headers) > _MAXHEADERS:	1✔
377	raise HttpException("got more than %d headers" % _MAXHEADERS)	×
378	if line in (b'\r\n', b'\n', b''):	1✔
379	break	1✔
380	hstring = b''.join(headers).decode('iso-8859-1')	1✔
381	return email.parser.Parser(_class=_class).parsestr(hstring)	1✔
382
383
384	class BytesProducer:	1✔
385
386	def __init__(self, bytes):	1✔
387	self.bytes = bytes	1✔
388
389	async def readline(self):	1✔
390	return self.bytes.readline()	×
391
392	async def read(self):	1✔
393	return self.bytes.read()	×
394
395	def __call__(self, consumer, *args):	1✔
396	value = None	1✔
397	coro = consumer(self, *args)	1✔
398	while True:	1✔
399	try:	1✔
400	value = coro.send(value)	1✔
401	except StopIteration as exc:	1✔
402	value = exc.value	×
403	break	×
404	return value	×

quantmind / pulsar / 1306

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous