Lines Matching refs:self
183 def getallmatchingheaders(self, name):
197 for line in self.keys():
228 But a TextIOWrapper around self.rfile would buffer too many bytes
248 def __init__(self, sock, debuglevel=0, method=None, url=None):
253 # happen if a self.fp.read() is done (without a size) whether
254 # self.fp is buffered or not. So, no self.fp.read() by
256 self.fp = sock.makefile("rb")
257 self.debuglevel = debuglevel
258 self._method = method
266 self.headers = self.msg = None
269 self.version = _UNKNOWN # HTTP-Version
270 self.status = _UNKNOWN # Status-Code
271 self.reason = _UNKNOWN # Reason-Phrase
273 self.chunked = _UNKNOWN # is "chunked" being used?
274 self.chunk_left = _UNKNOWN # bytes left to read in current chunk
275 self.length = _UNKNOWN # number of bytes left in response
276 self.will_close = _UNKNOWN # conn will close at end of response
278 def _read_status(self):
279 line = str(self.fp.readline(_MAXLINE + 1), "iso-8859-1")
282 if self.debuglevel > 0:
299 self._close_conn()
311 def begin(self):
312 if self.headers is not None:
318 version, status, reason = self._read_status()
322 skipped_headers = _read_headers(self.fp)
323 if self.debuglevel > 0:
327 self.code = self.status = status
328 self.reason = reason.strip()
331 self.version = 10
333 self.version = 11 # use HTTP/1.1 code for HTTP/1.x where x>=1
337 self.headers = self.msg = parse_headers(self.fp)
339 if self.debuglevel > 0:
340 for hdr, val in self.headers.items():
344 tr_enc = self.headers.get("transfer-encoding")
346 self.chunked = True
347 self.chunk_left = None
349 self.chunked = False
352 self.will_close = self._check_close()
356 self.length = None
357 length = self.headers.get("content-length")
358 if length and not self.chunked:
360 self.length = int(length)
362 self.length = None
364 if self.length < 0: # ignore nonsensical negative lengths
365 self.length = None
367 self.length = None
372 self._method == "HEAD"):
373 self.length = 0
378 if (not self.will_close and
379 not self.chunked and
380 self.length is None):
381 self.will_close = True
383 def _check_close(self):
384 conn = self.headers.get("connection")
385 if self.version == 11:
396 if self.headers.get("keep-alive"):
405 pconn = self.headers.get("proxy-connection")
412 def _close_conn(self):
413 fp = self.fp
414 self.fp = None
417 def close(self):
421 if self.fp:
422 self._close_conn()
429 def flush(self):
431 if self.fp:
432 self.fp.flush()
434 def readable(self):
440 def isclosed(self):
442 # NOTE: it is possible that we will not ever call self.close(). This
446 # IMPLIES: if will_close is FALSE, then self.close() will ALWAYS be
447 # called, meaning self.isclosed() is meaningful.
448 return self.fp is None
450 def read(self, amt=None):
452 if self.fp is None:
455 if self._method == "HEAD":
456 self._close_conn()
459 if self.chunked:
460 return self._read_chunked(amt)
463 if self.length is not None and amt > self.length:
465 amt = self.length
466 s = self.fp.read(amt)
470 self._close_conn()
471 elif self.length is not None:
472 self.length -= len(s)
473 if not self.length:
474 self._close_conn()
477 # Amount is not given (unbounded read) so we must check self.length
478 if self.length is None:
479 s = self.fp.read()
482 s = self._safe_read(self.length)
484 self._close_conn()
486 self.length = 0
487 self._close_conn() # we read everything
490 def readinto(self, b):
495 if self.fp is None:
498 if self._method == "HEAD":
499 self._close_conn()
502 if self.chunked:
503 return self._readinto_chunked(b)
505 if self.length is not None:
506 if len(b) > self.length:
508 b = memoryview(b)[0:self.length]
513 n = self.fp.readinto(b)
517 self._close_conn()
518 elif self.length is not None:
519 self.length -= n
520 if not self.length:
521 self._close_conn()
524 def _read_next_chunk_size(self):
526 line = self.fp.readline(_MAXLINE + 1)
537 self._close_conn()
540 def _read_and_discard_trailer(self):
544 line = self.fp.readline(_MAXLINE + 1)
554 def _get_chunk_left(self):
555 # return self.chunk_left, reading a new chunk if necessary.
560 chunk_left = self.chunk_left
564 self._safe_read(2) # toss the CRLF at the end of the chunk
566 chunk_left = self._read_next_chunk_size()
571 self._read_and_discard_trailer()
573 self._close_conn()
575 self.chunk_left = chunk_left
578 def _read_chunked(self, amt=None):
579 assert self.chunked != _UNKNOWN
583 chunk_left = self._get_chunk_left()
588 value.append(self._safe_read(amt))
589 self.chunk_left = chunk_left - amt
592 value.append(self._safe_read(chunk_left))
595 self.chunk_left = 0
600 def _readinto_chunked(self, b):
601 assert self.chunked != _UNKNOWN
606 chunk_left = self._get_chunk_left()
611 n = self._safe_readinto(mvb)
612 self.chunk_left = chunk_left - n
616 n = self._safe_readinto(temp_mvb)
619 self.chunk_left = 0
624 def _safe_read(self, amt):
631 data = self.fp.read(amt)
636 def _safe_readinto(self, b):
639 n = self.fp.readinto(b)
644 def read1(self, n=-1):
648 if self.fp is None or self._method == "HEAD":
650 if self.chunked:
651 return self._read1_chunked(n)
652 if self.length is not None and (n < 0 or n > self.length):
653 n = self.length
654 result = self.fp.read1(n)
656 self._close_conn()
657 elif self.length is not None:
658 self.length -= len(result)
661 def peek(self, n=-1):
664 if self.fp is None or self._method == "HEAD":
666 if self.chunked:
667 return self._peek_chunked(n)
668 return self.fp.peek(n)
670 def readline(self, limit=-1):
671 if self.fp is None or self._method == "HEAD":
673 if self.chunked:
676 if self.length is not None and (limit < 0 or limit > self.length):
677 limit = self.length
678 result = self.fp.readline(limit)
680 self._close_conn()
681 elif self.length is not None:
682 self.length -= len(result)
685 def _read1_chunked(self, n):
688 chunk_left = self._get_chunk_left()
693 read = self.fp.read1(n)
694 self.chunk_left -= len(read)
699 def _peek_chunked(self, n):
703 chunk_left = self._get_chunk_left()
710 return self.fp.peek(chunk_left)[:chunk_left]
712 def fileno(self):
713 return self.fp.fileno()
715 def getheader(self, name, default=None):
727 if self.headers is None:
729 headers = self.headers.get_all(name) or default
735 def getheaders(self):
737 if self.headers is None:
739 return list(self.headers.items())
743 def __iter__(self):
744 return self
748 def info(self):
769 return self.headers
771 def geturl(self):
781 return self.url
783 def getcode(self):
788 return self.status
838 def __init__(self, host, port=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
840 self.timeout = timeout
841 self.source_address = source_address
842 self.blocksize = blocksize
843 self.sock = None
844 self._buffer = []
845 self.__response = None
846 self.__state = _CS_IDLE
847 self._method = None
848 self._tunnel_host = None
849 self._tunnel_port = None
850 self._tunnel_headers = {}
852 (self.host, self.port) = self._get_hostport(host, port)
854 self._validate_host(self.host)
858 self._create_connection = socket.create_connection
860 def set_tunnel(self, host, port=None, headers=None):
875 if self.sock:
878 self._tunnel_host, self._tunnel_port = self._get_hostport(host, port)
880 self._tunnel_headers = headers
882 self._tunnel_headers.clear()
884 def _get_hostport(self, host, port):
893 port = self.default_port
898 port = self.default_port
904 def set_debuglevel(self, level):
905 self.debuglevel = level
907 def _tunnel(self):
909 self._tunnel_host.encode("ascii"), self._tunnel_port)
911 for header, value in self._tunnel_headers.items():
917 self.send(b"".join(headers))
920 response = self.response_class(self.sock, method=self._method)
925 self.close()
937 if self.debuglevel > 0:
942 def connect(self):
944 sys.audit("http.client.connect", self, self.host, self.port)
945 self.sock = self._create_connection(
946 (self.host,self.port), self.timeout, self.source_address)
949 self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
954 if self._tunnel_host:
955 self._tunnel()
957 def close(self):
959 self.__state = _CS_IDLE
961 sock = self.sock
963 self.sock = None
966 response = self.__response
968 self.__response = None
971 def send(self, data):
977 if self.sock is None:
978 if self.auto_open:
979 self.connect()
983 if self.debuglevel > 0:
986 if self.debuglevel > 0:
988 encode = self._is_textIO(data)
989 if encode and self.debuglevel > 0:
992 datablock = data.read(self.blocksize)
997 sys.audit("http.client.send", self, datablock)
998 self.sock.sendall(datablock)
1000 sys.audit("http.client.send", self, data)
1002 self.sock.sendall(data)
1006 self.sock.sendall(d)
1011 def _output(self, s):
1016 self._buffer.append(s)
1018 def _read_readable(self, readable):
1019 if self.debuglevel > 0:
1021 encode = self._is_textIO(readable)
1022 if encode and self.debuglevel > 0:
1025 datablock = readable.read(self.blocksize)
1032 def _send_output(self, message_body=None, encode_chunked=False):
1038 self._buffer.extend((b"", b""))
1039 msg = b"\r\n".join(self._buffer)
1040 del self._buffer[:]
1041 self.send(msg)
1050 chunks = self._read_readable(message_body)
1072 if self.debuglevel > 0:
1076 if encode_chunked and self._http_vsn == 11:
1080 self.send(chunk)
1082 if encode_chunked and self._http_vsn == 11:
1084 self.send(b'0\r\n\r\n')
1086 def putrequest(self, method, url, skip_host=False,
1098 if self.__response and self.__response.isclosed():
1099 self.__response = None
1120 if self.__state == _CS_IDLE:
1121 self.__state = _CS_REQ_STARTED
1123 raise CannotSendRequest(self.__state)
1125 self._validate_method(method)
1128 self._method = method
1131 self._validate_path(url)
1133 request = '%s %s %s' % (method, url, self._http_vsn_str)
1135 self._output(self._encode_request(request))
1137 if self._http_vsn == 11:
1164 self.putheader('Host', netloc_enc)
1166 if self._tunnel_host:
1167 host = self._tunnel_host
1168 port = self._tunnel_port
1170 host = self.host
1171 port = self.port
1184 if port == self.default_port:
1185 self.putheader('Host', host_enc)
1188 self.putheader('Host', "%s:%s" % (host_enc, port))
1199 self.putheader('Accept-Encoding', 'identity')
1203 #self.putheader('TE', 'chunked')
1207 #self.putheader('Connection', 'TE')
1213 def _encode_request(self, request):
1217 def _validate_method(self, method):
1226 def _validate_path(self, url):
1234 def _validate_host(self, host):
1242 def putheader(self, header, *values):
1247 if self.__state != _CS_REQ_STARTED:
1268 self._output(header)
1270 def endheaders(self, message_body=None, *, encode_chunked=False):
1277 if self.__state == _CS_REQ_STARTED:
1278 self.__state = _CS_REQ_SENT
1281 self._send_output(message_body, encode_chunked=encode_chunked)
1283 def request(self, method, url, body=None, headers={}, *,
1286 self._send_request(method, url, body, headers, encode_chunked)
1288 def _send_request(self, method, url, body, headers, encode_chunked):
1297 self.putrequest(method, url, **skips)
1314 content_length = self._get_content_length(body, method)
1317 if self.debuglevel > 0:
1320 self.putheader('Transfer-Encoding', 'chunked')
1322 self.putheader('Content-Length', str(content_length))
1327 self.putheader(hdr, value)
1332 self.endheaders(body, encode_chunked=encode_chunked)
1334 def getresponse(self):
1349 if self.__response and self.__response.isclosed():
1350 self.__response = None
1367 if self.__state != _CS_REQ_SENT or self.__response:
1368 raise ResponseNotReady(self.__state)
1370 if self.debuglevel > 0:
1371 response = self.response_class(self.sock, self.debuglevel,
1372 method=self._method)
1374 response = self.response_class(self.sock, method=self._method)
1380 self.close()
1383 self.__state = _CS_IDLE
1387 self.close()
1390 self.__response = response
1409 def __init__(self, host, port=None, key_file=None, cert_file=None,
1413 super(HTTPSConnection, self).__init__(host, port, timeout,
1422 self.key_file = key_file
1423 self.cert_file = cert_file
1427 if self._http_vsn == 11:
1444 self._context = context
1446 self._context.check_hostname = check_hostname
1448 def connect(self):
1453 if self._tunnel_host:
1454 server_hostname = self._tunnel_host
1456 server_hostname = self.host
1458 self.sock = self._context.wrap_socket(self.sock,
1465 # or define self.args. Otherwise, str() will fail.
1475 def __init__(self, version):
1476 self.args = version,
1477 self.version = version
1486 def __init__(self, partial, expected=None):
1487 self.args = partial,
1488 self.partial = partial
1489 self.expected = expected
1490 def __repr__(self):
1491 if self.expected is not None:
1492 e = ', %i more expected' % self.expected
1495 return '%s(%i bytes read%s)' % (self.__class__.__name__,
1496 len(self.partial), e)
1512 def __init__(self, line):
1515 self.args = line,
1516 self.line = line
1519 def __init__(self, line_type):
1520 HTTPException.__init__(self, "got more than %d bytes when reading %s"
1524 def __init__(self, *pos, **kw):
1525 BadStatusLine.__init__(self, "")
1526 ConnectionResetError.__init__(self, *pos, **kw)