k3http 0.1.4__tar.gz → 0.1.6__tar.gz

{k3http-0.1.4/k3http.egg-info → k3http-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: k3http
-Version: 0.1.4
+Version: 0.1.6
 Summary: HTTP/1.1 client with timeout support
 Author-email: Zhang Yanpo <drdr.xp@gmail.com>
 License: MIT
@@ -38,7 +38,6 @@ Dynamic: license-file
 # k3http
 
 [![Action-CI](https://github.com/pykit3/k3http/actions/workflows/python-package.yml/badge.svg)](https://github.com/pykit3/k3http/actions/workflows/python-package.yml)
-[![Build Status](https://travis-ci.com/pykit3/k3http.svg?branch=master)](https://travis-ci.com/pykit3/k3http)
 [![Documentation Status](https://readthedocs.org/projects/k3http/badge/?version=stable)](https://k3http.readthedocs.io/en/stable/?badge=stable)
 [![Package](https://img.shields.io/pypi/pyversions/k3http)](https://pypi.org/project/k3http)
 
@@ -62,23 +61,22 @@ pip install k3http
 # Synopsis
 
 ```python
+import urllib
 
 import k3http
-import urllib
-import socket
 
 headers = {
-    'Host': '127.0.0.1',
-    'Accept-Language': 'en, mi',
+    "Host": "127.0.0.1",
+    "Accept-Language": "en, mi",
 }
 
 try:
-    h = k3http.Client('127.0.0.1', 80)
+    h = k3http.Client("127.0.0.1", 80)
 
     # send http reqeust without body
     # read response status line
     # read response headers
-    h.request('/test.txt', method='GET', headers=headers)
+    h.request("/test.txt", method="GET", headers=headers)
 
     status = h.status
     # response code return from http server, type is int
@@ -97,23 +95,22 @@ try:
 
     # get response body
     print(h.read_body(None))
-except (socket.error, k3http.HttpError) as e:
+except (OSError, k3http.HttpError) as e:
     print(repr(e))
 
 
-
-content = urllib.urlencode({'f': 'foo', 'b': 'bar'})
+content = urllib.urlencode({"f": "foo", "b": "bar"})
 headers = {
-    'Host': 'www.example.com',
-    'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8',
-    'Content-Length': len(content),
+    "Host": "www.example.com",
+    "Content-Type": "application/x-www-form-urlencoded;charset=utf-8",
+    "Content-Length": len(content),
 }
 
 try:
-    h = k3http.Client('127.0.0.1', 80)
+    h = k3http.Client("127.0.0.1", 80)
 
     # send http reqeust
-    h.send_request('http://www.example.com', method='POST', headers=headers)
+    h.send_request("http://www.example.com", method="POST", headers=headers)
 
     # send http request body
     h.send_body(content)
@@ -123,9 +120,8 @@ try:
 
     # read response body
     print(h.read_body(None))
-except (socket.error, k3http.HttpError) as e:
+except (OSError, k3http.HttpError) as e:
     print(repr(e))
-
 ```
 
 #   Author

{k3http-0.1.4 → k3http-0.1.6}/README.md

@@ -1,7 +1,6 @@
 # k3http
 
 [![Action-CI](https://github.com/pykit3/k3http/actions/workflows/python-package.yml/badge.svg)](https://github.com/pykit3/k3http/actions/workflows/python-package.yml)
-[![Build Status](https://travis-ci.com/pykit3/k3http.svg?branch=master)](https://travis-ci.com/pykit3/k3http)
 [![Documentation Status](https://readthedocs.org/projects/k3http/badge/?version=stable)](https://k3http.readthedocs.io/en/stable/?badge=stable)
 [![Package](https://img.shields.io/pypi/pyversions/k3http)](https://pypi.org/project/k3http)
 
@@ -25,23 +24,22 @@ pip install k3http
 # Synopsis
 
 ```python
+import urllib
 
 import k3http
-import urllib
-import socket
 
 headers = {
-    'Host': '127.0.0.1',
-    'Accept-Language': 'en, mi',
+    "Host": "127.0.0.1",
+    "Accept-Language": "en, mi",
 }
 
 try:
-    h = k3http.Client('127.0.0.1', 80)
+    h = k3http.Client("127.0.0.1", 80)
 
     # send http reqeust without body
     # read response status line
     # read response headers
-    h.request('/test.txt', method='GET', headers=headers)
+    h.request("/test.txt", method="GET", headers=headers)
 
     status = h.status
     # response code return from http server, type is int
@@ -60,23 +58,22 @@ try:
 
     # get response body
     print(h.read_body(None))
-except (socket.error, k3http.HttpError) as e:
+except (OSError, k3http.HttpError) as e:
     print(repr(e))
 
 
-
-content = urllib.urlencode({'f': 'foo', 'b': 'bar'})
+content = urllib.urlencode({"f": "foo", "b": "bar"})
 headers = {
-    'Host': 'www.example.com',
-    'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8',
-    'Content-Length': len(content),
+    "Host": "www.example.com",
+    "Content-Type": "application/x-www-form-urlencoded;charset=utf-8",
+    "Content-Length": len(content),
 }
 
 try:
-    h = k3http.Client('127.0.0.1', 80)
+    h = k3http.Client("127.0.0.1", 80)
 
     # send http reqeust
-    h.send_request('http://www.example.com', method='POST', headers=headers)
+    h.send_request("http://www.example.com", method="POST", headers=headers)
 
     # send http request body
     h.send_body(content)
@@ -86,9 +83,8 @@ try:
 
     # read response body
     print(h.read_body(None))
-except (socket.error, k3http.HttpError) as e:
+except (OSError, k3http.HttpError) as e:
     print(repr(e))
-
 ```
 
 #   Author

{k3http-0.1.4 → k3http-0.1.6}/__init__.py

@@ -9,30 +9,29 @@ from importlib.metadata import version
 __version__ = version("k3http")
 
 from .client import (
+    BadStatusLineError,
+    ChunkedSizeError,
+    Client,
+    HeadersError,
     HttpError,
     LineTooLongError,
-    ChunkedSizeError,
     NotConnectedError,
     ResponseNotReadyError,
-    HeadersError,
-    BadStatusLineError,
-    Client,
 )
-
 from .util import (
     headers_add_host,
     request_add_host,
 )
 
 __all__ = [
+    "BadStatusLineError",
+    "ChunkedSizeError",
+    "Client",
+    "HeadersError",
     "HttpError",
     "LineTooLongError",
-    "ChunkedSizeError",
     "NotConnectedError",
     "ResponseNotReadyError",
-    "HeadersError",
-    "BadStatusLineError",
-    "Client",
     "headers_add_host",
     "request_add_host",
 ]

{k3http-0.1.4 → k3http-0.1.6}/client.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# coding: utf-8
 
 import errno
 import logging
@@ -50,7 +49,7 @@ MAX_LINE_LENGTH = 65536
 LINE_RECV_LENGTH = 1024 * 4
 
 
-class Client(object):
+class Client:
     """
     HTTP client class
 
@@ -125,11 +124,11 @@ class Client(object):
         sw = self.get_and_end_stopwatch()
         rst = []
         for t in sw.get_last_trace_report():
-            ent = dict(
-                name=t.name,
-                time=t.end_time - t.start_time,
-                annotation=[self._human_annotation(an) for an in t.trace_annotations],
-            )
+            ent = {
+                "name": t.name,
+                "time": t.end_time - t.start_time,
+                "annotation": [self._human_annotation(an) for an in t.trace_annotations],
+            }
 
             rst.append(ent)
 
@@ -137,7 +136,7 @@ class Client(object):
 
     def _human_annotation(self, annotation):
         an = annotation
-        return "{key}:{value}".format(key=an.key, value=an.value)
+        return f"{an.key}:{an.value}"
 
     def get_and_end_stopwatch(self):
         """stopwatch must be stopped before it can be read"""
@@ -198,7 +197,7 @@ class Client(object):
                 self.sock = self.https_context.wrap_socket(self.sock, server_hostname=self.host)
 
         bufs = [
-            "{method} {uri} HTTP/1.1".format(method=method, uri=uri),
+            f"{method} {uri} HTTP/1.1",
         ]
 
         headers = headers or {}
@@ -209,7 +208,7 @@ class Client(object):
             self.request_chunked_encoded = True
 
         for k, v in headers.items():
-            bufs.append("%s: %s" % (k, v))
+            bufs.append(f"{k}: {v}")
 
         bufs.extend(["", ""])
 
@@ -218,20 +217,24 @@ class Client(object):
 
     def send_body(self, body):
         """
-        Send http request body. It should be a 'str' of data to send after the headers are finished
+        Send http request body. It should be a 'bytes' of data to send after the headers are finished.
+        A 'str' body is encoded as UTF-8.
 
-        :param body: a 'str' of http request body.
+        :param body: a 'bytes' or 'str' of http request body.
         :return: nothing
         """
 
         if self.sock is None:
             raise NotConnectedError("socket object is None")
 
+        if isinstance(body, str):
+            body = body.encode("utf-8")
+
         with self.stopwatch.timer("send_body"):
             if self.request_chunked_encoded:
-                body = "{0:x}\r\n{1}\r\n".format(len(body), body)
+                body = b"%x\r\n%s\r\n" % (len(body), body)
 
-            self.sock.sendall(body.encode("utf-8"))
+            self.sock.sendall(body)
 
     def read_status(self, skip_100=True):
         """
@@ -276,7 +279,7 @@ class Client(object):
 
                 kv = line.strip().split(":", 1)
                 if len(kv) < 2:
-                    raise HeadersError("invalid headers param line:%s" % (line))
+                    raise HeadersError(f"invalid headers param line:{line}")
                 self.headers[kv[0].lower()] = kv[1].strip()
 
         if self.status in (204, 304) or self.method == "HEAD":
@@ -293,7 +296,7 @@ class Client(object):
         try:
             self.content_length = int(length)
         except ValueError as e:
-            logger.error(repr(e) + " while get content-length length:{l}".format(l=length))
+            logger.error(repr(e) + f" while get content-length length:{length}")
             raise HeadersError("invalid content-length")
 
         return self.headers
@@ -320,7 +323,7 @@ class Client(object):
         Read and return the response body.
 
         :param size: need read size, if greater than left size use the min one, if 'None' read left unread body.
-        :return: the response body.
+        :return: the response body as 'bytes'.
         """
 
         with self.stopwatch.timer("recv_body"):
@@ -330,19 +333,19 @@ class Client(object):
         """
         Read and yield one line in response body each time.
 
-        :param delimiter: specify the delimiter between each line, defalut supporting '\n'.
-        :return: a generator yileding one line including delimiter in response body each time.
+        :param delimiter: specify the 'bytes' delimiter between each line, defalut supporting b'\n'.
+        :return: a generator yileding one 'bytes' line including delimiter in response body each time.
         """
 
         if delimiter is None:
-            delimiter = "\n"
+            delimiter = b"\n"
 
-        buf = ""
+        buf = b""
         while True:
             tmp = self._read_body(MAX_LINE_LENGTH)
 
-            if tmp == "":
-                if buf != "":
+            if tmp == b"":
+                if buf != b"":
                     yield buf
                 break
 
@@ -356,7 +359,7 @@ class Client(object):
 
     def _read_body(self, size):
         if size is not None and size <= 0:
-            return ""
+            return b""
 
         if self.chunked:
             buf = self._read_chunked(size)
@@ -369,7 +372,7 @@ class Client(object):
             size = min(size, self.content_length - self.has_read)
 
         if size <= 0:
-            return ""
+            return b""
 
         buf = self._read(size)
         self.has_read += size
@@ -380,16 +383,16 @@ class Client(object):
         if self.recv_iter is not None:
             try:
                 self.recv_iter.close()
-            except Exception as e:
-                logger.exception(repr(e) + " while close recv_iter")
+            except Exception:
+                logger.exception("while close recv_iter")
 
         self.recv_iter = None
 
         if self.sock is not None:
             try:
                 self.sock.close()
-            except Exception as e:
-                logger.exception(repr(e) + " while close sock")
+            except Exception:
+                logger.exception("while close sock")
 
         self.sock = None
 
@@ -407,7 +410,8 @@ class Client(object):
         return self.recv_iter.send(("block", size))
 
     def _readline(self):
-        return self.recv_iter.send(("line", None))
+        line = self.recv_iter.send(("line", None))
+        return line.decode("utf-8")
 
     def _get_response_status(self):
         with self.stopwatch.timer("recv_status"):
@@ -415,7 +419,7 @@ class Client(object):
 
         vals = line.split(None, 2)
         if len(vals) < 2:
-            raise BadStatusLineError("invalid status line:{l}".format(l=line))
+            raise BadStatusLineError(f"invalid status line:{line}")
 
         ver, status = vals[0], vals[1]
 
@@ -423,10 +427,10 @@ class Client(object):
             status = int(status)
         except ValueError as e:
             logger.error(repr(e) + " while get response status")
-            raise BadStatusLineError("status is not int:{l}".format(l=line))
+            raise BadStatusLineError(f"status is not int:{line}")
 
         if not ver.startswith("HTTP/") or status < 100 or status > 999:
-            raise BadStatusLineError("invalid status line:{l}".format(l=line))
+            raise BadStatusLineError(f"invalid status line:{line}")
 
         return status
 
@@ -441,7 +445,7 @@ class Client(object):
         try:
             chunk_size = int(line, 16)
         except ValueError as e:
-            logger.error(repr(e) + " while get chunk size line:{l}".format(l=line))
+            logger.error(repr(e) + f" while get chunk size line:{line}")
             raise ChunkedSizeError("invalid chunk size")
 
         return chunk_size
@@ -450,7 +454,7 @@ class Client(object):
         buf = []
 
         if self.chunk_left == 0:
-            return ""
+            return b""
 
         while size is None or size > 0:
             if self.chunk_left is None:
@@ -478,7 +482,7 @@ class Client(object):
                 if line == "":
                     break
 
-        return "".join(buf)
+        return b"".join(buf)
 
     def set_timeout(self, timeout):
         self.timeout = timeout
@@ -488,20 +492,20 @@ class Client(object):
 
 
 def _recv_loop(sock, timeout):
-    bufs = [""]
+    bufs = [b""]
     mode, size = yield
 
     while True:
         if mode == "line":
             buf = bufs[0]
-            if "\r\n" in buf:
-                rst, buf = buf.split("\r\n", 1)
+            if b"\r\n" in buf:
+                rst, buf = buf.split(b"\r\n", 1)
                 bufs[0] = buf
                 mode, size = yield rst
                 continue
             else:
                 if len(buf) >= MAX_LINE_LENGTH:
-                    raise LineTooLongError("line length greater than max_len:{l}".format(l=len(buf)))
+                    raise LineTooLongError(f"line length greater than max_len:{len(buf)}")
                 else:
                     buf += _recv(sock, timeout, LINE_RECV_LENGTH)
                     bufs[0] = buf
@@ -512,31 +516,31 @@ def _recv_loop(sock, timeout):
                 bufs.append(_recv(sock, timeout, size - total))
                 total += len(bufs[-1])
 
-            rst = "".join(bufs)
+            rst = b"".join(bufs)
             if size < len(rst):
                 bufs = [rst[size:]]
                 rst = rst[:size]
             else:
-                bufs = [""]
+                bufs = [b""]
             mode, size = yield rst
 
 
 def _recv(sock, timeout, size):
-    buf = ""
+    buf = b""
     for _ in range(2):
         try:
-            buf = (sock.recv(size)).decode("utf-8")
+            buf = sock.recv(size)
             break
-        except socket.error as e:
+        except OSError as e:
             if len(e.args) <= 0 or e.args[0] != errno.EAGAIN:
                 raise
 
-            evin, evout, everr = select.select([sock.fileno()], [], [], timeout)
+            evin, _evout, _everr = select.select([sock.fileno()], [], [], timeout)
 
             if len(evin) <= 0:
-                raise socket.timeout("{second}s timeout while recv".format(second=timeout))
+                raise socket.timeout(f"{timeout}s timeout while recv")
 
     if len(buf) <= 0:
-        raise socket.error("got empty when recv {l} bytes".format(l=size))
+        raise OSError(f"got empty when recv {size} bytes")
 
     return buf

{k3http-0.1.4 → k3http-0.1.6/k3http.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: k3http
-Version: 0.1.4
+Version: 0.1.6
 Summary: HTTP/1.1 client with timeout support
 Author-email: Zhang Yanpo <drdr.xp@gmail.com>
 License: MIT
@@ -38,7 +38,6 @@ Dynamic: license-file
 # k3http
 
 [![Action-CI](https://github.com/pykit3/k3http/actions/workflows/python-package.yml/badge.svg)](https://github.com/pykit3/k3http/actions/workflows/python-package.yml)
-[![Build Status](https://travis-ci.com/pykit3/k3http.svg?branch=master)](https://travis-ci.com/pykit3/k3http)
 [![Documentation Status](https://readthedocs.org/projects/k3http/badge/?version=stable)](https://k3http.readthedocs.io/en/stable/?badge=stable)
 [![Package](https://img.shields.io/pypi/pyversions/k3http)](https://pypi.org/project/k3http)
 
@@ -62,23 +61,22 @@ pip install k3http
 # Synopsis
 
 ```python
+import urllib
 
 import k3http
-import urllib
-import socket
 
 headers = {
-    'Host': '127.0.0.1',
-    'Accept-Language': 'en, mi',
+    "Host": "127.0.0.1",
+    "Accept-Language": "en, mi",
 }
 
 try:
-    h = k3http.Client('127.0.0.1', 80)
+    h = k3http.Client("127.0.0.1", 80)
 
     # send http reqeust without body
     # read response status line
     # read response headers
-    h.request('/test.txt', method='GET', headers=headers)
+    h.request("/test.txt", method="GET", headers=headers)
 
     status = h.status
     # response code return from http server, type is int
@@ -97,23 +95,22 @@ try:
 
     # get response body
     print(h.read_body(None))
-except (socket.error, k3http.HttpError) as e:
+except (OSError, k3http.HttpError) as e:
     print(repr(e))
 
 
-
-content = urllib.urlencode({'f': 'foo', 'b': 'bar'})
+content = urllib.urlencode({"f": "foo", "b": "bar"})
 headers = {
-    'Host': 'www.example.com',
-    'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8',
-    'Content-Length': len(content),
+    "Host": "www.example.com",
+    "Content-Type": "application/x-www-form-urlencoded;charset=utf-8",
+    "Content-Length": len(content),
 }
 
 try:
-    h = k3http.Client('127.0.0.1', 80)
+    h = k3http.Client("127.0.0.1", 80)
 
     # send http reqeust
-    h.send_request('http://www.example.com', method='POST', headers=headers)
+    h.send_request("http://www.example.com", method="POST", headers=headers)
 
     # send http request body
     h.send_body(content)
@@ -123,9 +120,8 @@ try:
 
     # read response body
     print(h.read_body(None))
-except (socket.error, k3http.HttpError) as e:
+except (OSError, k3http.HttpError) as e:
     print(repr(e))
-
 ```
 
 #   Author

{k3http-0.1.4 → k3http-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "k3http"
-version = "0.1.4"
+version = "0.1.6"
 description = "HTTP/1.1 client with timeout support"
 readme = "README.md"
 license = {text = "MIT"}

{k3http-0.1.4 → k3http-0.1.6}/synopsis.py

@@ -1,6 +1,6 @@
-import k3http
 import urllib
-import socket
+
+import k3http
 
 headers = {
     "Host": "127.0.0.1",
@@ -32,7 +32,7 @@ try:
 
     # get response body
     print(h.read_body(None))
-except (socket.error, k3http.HttpError) as e:
+except (OSError, k3http.HttpError) as e:
     print(repr(e))
 
 
@@ -57,5 +57,5 @@ try:
 
     # read response body
     print(h.read_body(None))
-except (socket.error, k3http.HttpError) as e:
+except (OSError, k3http.HttpError) as e:
     print(repr(e))

{k3http-0.1.4 → k3http-0.1.6}/test/test_httpclient.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python3
-# coding: utf-8
-
 import gc
 import os
 import socket
@@ -8,12 +5,12 @@ import ssl
 import threading
 import time
 import unittest
-from http.server import BaseHTTPRequestHandler
-from http.server import HTTPServer
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import ClassVar
 
-import k3http
 import k3ut
 
+import k3http
 
 dd = k3ut.dd
 
@@ -26,22 +23,34 @@ HOME_PATH = os.path.dirname(os.path.abspath(__file__))
 
 
 class TestHttpClient(unittest.TestCase):
-    special_cases = {
-        "test_recving_server_close": (0, 1, "HTTP/1.1 200 OK\r\nContent-Length: 10\r\n\r\n"),
-        "test_server_delay_response": (0.5, 1, "HTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\nabcd"),
-        "test_raise_chunked_size_error": (0, 10, "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\nfoo\r\n"),
-        "test_raise_socket_timeout": (3, 1, "H"),
-        "test_raise_line_too_long_error": (0, KB, "a" * 65536),
+    special_cases: ClassVar[dict] = {
+        "test_recving_server_close": (0, 1, b"HTTP/1.1 200 OK\r\nContent-Length: 10\r\n\r\n"),
+        "test_server_delay_response": (0.5, 1, b"HTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\nabcd"),
+        "test_raise_chunked_size_error": (0, 10, b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\nfoo\r\n"),
+        "test_raise_socket_timeout": (3, 1, b"H"),
+        "test_raise_line_too_long_error": (0, KB, b"a" * 65536),
         "test_request_chunked": (),
+        "test_send_body_chunked_utf8": (),
         "test_readlines": (
             0,
             10,
-            "HTTP/1.1 200 OK\r\nContent-Length: 131086\r\n\r\n" + "a" * 65540 + "\r\nbb\r\n" + "c" * 65540,
+            b"HTTP/1.1 200 OK\r\nContent-Length: 131086\r\n\r\n" + b"a" * 65540 + b"\r\nbb\r\n" + b"c" * 65540,
+        ),
+        "test_readlines_delimiter": (0, 10, b"HTTP/1.1 200 OK\r\nContent-Length: 15\r\n\r\nabcd\rbcde\rcdef\r"),
+        # The first send ends inside the 3-byte "中", the second send completes it.
+        "test_read_body_utf8_split_across_recv": (
+            0.1,
+            39,
+            b"HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\n" + "中".encode(),
+        ),
+        "test_read_body_chunked_binary": (
+            0,
+            KB,
+            b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n8\r\n\x89PNG\r\n\x1a\n\r\n0\r\n\r\n",
         ),
-        "test_readlines_delimiter": (0, 10, "HTTP/1.1 200 OK\r\nContent-Length: 15\r\n\r\nabcd\rbcde\rcdef\r"),
     }
-    request_headers = {}
-    request_body = {}
+    request_headers: ClassVar[dict] = {}
+    request_body = b""
 
     def test_raise_connnect_error(self):
         h = k3http.Client(HOST, PORT)
@@ -125,7 +134,7 @@ class TestHttpClient(unittest.TestCase):
         for uri, each_read_size, expected_res, content_range, chunked in cases:
             h.request(uri)
 
-            bufs = ""
+            bufs = b""
             if each_read_size is None:
                 bufs = h.read_body(None)
                 self.assertEqual(h.has_read, len(bufs))
@@ -141,7 +150,8 @@ class TestHttpClient(unittest.TestCase):
             if len(content_range) >= 2:
                 start, end = content_range[0], content_range[1] + 1
 
-            self.assertEqual(expected_res[start:end], bufs)
+            expected = expected_res[start:end].encode("utf-8")
+            self.assertEqual(expected, bufs)
             self.assertEqual(None if chunked else len(bufs), h.content_length)
             self.assertEqual(chunked, h.chunked)
 
@@ -169,6 +179,17 @@ class TestHttpClient(unittest.TestCase):
             h.send_body(body)
             self.assertEqual(h.read_status(False), status)
 
+    def test_send_body_chunked_utf8(self):
+        # The chunk size must count the 3 UTF-8 bytes of "中", not 1 char.
+        h = k3http.Client(HOST, PORT)
+        h.send_request("", "PUT", {"Transfer-Encoding": "chunked"})
+        h.send_body("中")
+        h.send_body("")
+        h.read_response()
+
+        chunks = self.request_body.split(b"\r\n\r\n", 1)[1]
+        self.assertEqual(b"3\r\n\xe4\xb8\xad\r\n0\r\n\r\n", chunks)
+
     def test_request_headers(self):
         cases = (
             ("/header_1", {"host": "example.com"}),
@@ -198,9 +219,10 @@ class TestHttpClient(unittest.TestCase):
 
     def test_send_body(self):
         cases = (
-            ("/put_1b", "a", {"Content-Length": 1}),
-            ("/put_10k", "bc" * 5 * KB, {"Content-Length": 10 * KB}),
-            ("/put_30m", "cde" * 10 * MB, {"Content-Length": 30 * MB}),
+            ("/put_1b", b"a", {"Content-Length": 1}),
+            ("/put_10k", b"bc" * 5 * KB, {"Content-Length": 10 * KB}),
+            ("/put_30m", b"cde" * 10 * MB, {"Content-Length": 30 * MB}),
+            ("/put_binary", b"\x89PNG\r\n\x1a\n", {"Content-Length": 8}),
         )
 
         h = k3http.Client(HOST, PORT)
@@ -216,7 +238,7 @@ class TestHttpClient(unittest.TestCase):
         h = k3http.Client(HOST, PORT)
         h.request("")
 
-        expected_body = ("a" * 65540 + "\r\n", "bb\r\n", "c" * 65540)
+        expected_body = (b"a" * 65540 + b"\r\n", b"bb\r\n", b"c" * 65540)
         for idx, line in enumerate(h.readlines()):
             self.assertEqual(expected_body[idx], line)
 
@@ -224,10 +246,24 @@ class TestHttpClient(unittest.TestCase):
         h = k3http.Client(HOST, PORT)
         h.request("")
 
-        expected_body = ("abcd\r", "bcde\r", "cdef\r")
-        for idx, line in enumerate(h.readlines("\r")):
+        expected_body = (b"abcd\r", b"bcde\r", b"cdef\r")
+        for idx, line in enumerate(h.readlines(b"\r")):
             self.assertEqual(expected_body[idx], line)
 
+    def test_read_body_utf8_split_across_recv(self):
+        h = k3http.Client(HOST, PORT)
+        h.request("")
+
+        body = h.read_body(None)
+        self.assertEqual("中".encode(), body)
+
+    def test_read_body_chunked_binary(self):
+        h = k3http.Client(HOST, PORT)
+        h.request("")
+
+        body = h.read_body(None)
+        self.assertEqual(b"\x89PNG\r\n\x1a\n", body)
+
     def test_recving_server_close(self):
         h = k3http.Client(HOST, PORT, 3)
         succ = False
@@ -235,16 +271,14 @@ class TestHttpClient(unittest.TestCase):
         try:
             h.request("")
             h.read_body(1024)
-        except socket.error as e:
+        except OSError as e:
             dd(repr(e) + " while recv server close")
             succ = True
-        except Exception as e:
-            dd(repr(e) + " unexpected exception")
 
         self.assertTrue(succ)
 
     def test_server_delay_response(self):
-        case = ({"content-length": "4"}, "abcd")
+        case = ({"content-length": "4"}, b"abcd")
         expected_headers, expected_body = case
 
         h = k3http.Client(HOST, PORT, 1)
@@ -255,7 +289,7 @@ class TestHttpClient(unittest.TestCase):
         self.assertEqual(expected_body, body)
 
     def test_client_delay_send_data(self):
-        case = ("/client_delay", {"Content-Length": 10}, "abcde" * 2)
+        case = ("/client_delay", {"Content-Length": 10}, b"abcde" * 2)
         uri, headers, body = case
 
         h = k3http.Client(HOST, PORT, 3)
@@ -290,7 +324,7 @@ class TestHttpClient(unittest.TestCase):
         try:
             with h.stopwatch.timer("exception"):
                 raise FakeErrorDuringHTTP(3)
-        except Exception:
+        except FakeErrorDuringHTTP:
             pass
 
         trace = h.get_trace()
@@ -306,7 +340,7 @@ class TestHttpClient(unittest.TestCase):
 
         for i, k in enumerate(ks):
             self.assertEqual(k, trace[i]["name"])
-            self.assertEqual(type(0.1), type(trace[i]["time"]))
+            self.assertEqual(float, type(trace[i]["time"]))
 
         names = [x["name"] for x in trace]
         self.assertEqual(
@@ -340,9 +374,9 @@ class TestHttpClient(unittest.TestCase):
 
     def test_https(self):
         cases = (
-            ("/get_1b", "a"),
-            ("/get_10k", "bc" * 5 * KB),
-            ("/get_30m", "cde" * 10 * MB),
+            ("/get_1b", b"a"),
+            ("/get_10k", b"bc" * 5 * KB),
+            ("/get_30m", b"cde" * 10 * MB),
         )
 
         context = ssl._create_unverified_context()
@@ -355,7 +389,7 @@ class TestHttpClient(unittest.TestCase):
             self.assertEqual(expected_res, body)
 
     def __init__(self, *args, **kwargs):
-        super(TestHttpClient, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.server_thread = None
         self.http_server = None
 
@@ -406,6 +440,18 @@ class TestHttpClient(unittest.TestCase):
             res = "HTTP/1.1 200 OK\r\n\r\n"
             conn.sendall(res.encode("utf-8"))
 
+        elif self._testMethodName == "test_send_body_chunked_utf8":
+            conn, _ = sock.accept()
+            data = b""
+            while not data.endswith(b"\r\n0\r\n\r\n"):
+                buf = conn.recv(1024)
+                if buf == b"":
+                    break
+                data += buf
+
+            TestHttpClient.request_body = data
+            conn.sendall(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")
+
         else:
             conn, _ = sock.accept()
             data = (conn.recv(1024)).decode("utf-8")
@@ -417,10 +463,10 @@ class TestHttpClient(unittest.TestCase):
             sleep_time, each_send_size, content = res
             try:
                 while len(content) > 0:
-                    conn.sendall((content[:each_send_size]).encode("utf-8"))
+                    conn.sendall(content[:each_send_size])
                     content = content[each_send_size:]
                     time.sleep(sleep_time)
-            except socket.error as e:
+            except OSError as e:
                 dd(repr(e) + " while response")
 
         time.sleep(1)
@@ -429,7 +475,7 @@ class TestHttpClient(unittest.TestCase):
 
 
 class Handle(BaseHTTPRequestHandler):
-    all_responses = {
+    all_responses: ClassVar[dict] = {
         "/invalid_content_len": (200, {"content-length": "abc"}, (0, "")),
         "/invalid_header": (200, {}, (0, "")),
         "/get_1b": (200, {"content-length": 1}, (1, "a")),
@@ -438,15 +484,15 @@ class Handle(BaseHTTPRequestHandler):
         "/get_10b_chunked": (200, {"Transfer-Encoding": "chunked"}, (5, "f" * 10)),
         "/get_10k_chunked": (200, {"Transfer-Encoding": "chunked"}, (KB, "gh" * 5 * KB)),
         "/get_30m_chunked": (200, {"Transfer-Encoding": "chunked"}, (10 * MB, "ijk" * 10 * MB)),
-        "/get_10b_range": (206, {"Content-Range": "bytes %d-%d/%d" % (2, 8, 10), "Content-Length": 7}, (5, "l" * 10)),
+        "/get_10b_range": (206, {"Content-Range": "bytes 2-8/10", "Content-Length": 7}, (5, "l" * 10)),
         "/get_10k_range": (
             206,
-            {"Content-Range": "bytes %d-%d/%d" % (KB, 8 * KB, 10 * KB), "Content-Length": 7 * KB + 1},
+            {"Content-Range": f"bytes {KB}-{8 * KB}/{10 * KB}", "Content-Length": 7 * KB + 1},
             (KB, "mn" * 5 * KB),
         ),
         "/get_30m_range": (
             206,
-            {"Content-Range": "bytes %d-%d/%d" % (2 * MB, 25 * MB, 30 * MB), "Content-Length": 23 * MB + 1},
+            {"Content-Range": f"bytes {2 * MB}-{25 * MB}/{30 * MB}", "Content-Length": 23 * MB + 1},
             (10 * MB, "opq" * 10 * MB),
         ),
         "/get_200": (200, {"content-length": 1}, (0, "")),
@@ -481,9 +527,9 @@ class Handle(BaseHTTPRequestHandler):
                 return
             else:
                 protocol = self.protocol_version
-            self.wfile.write(("%s %d %s\r\n" % (protocol, code, message)).encode("utf-8"))
+            self.wfile.write(f"{protocol} {code} {message}\r\n".encode())
             if self.path == "/invalid_header":
-                self.wfile.write(("foo\r\n").encode("utf-8"))
+                self.wfile.write(b"foo\r\n")
 
     def do_PUT(self):
         try:
@@ -493,18 +539,18 @@ class Handle(BaseHTTPRequestHandler):
             return
 
         read_bytes = 0
-        bufs = ""
+        bufs = b""
 
         try:
             while read_bytes < length:
-                bufs += (self.rfile.read(length - read_bytes)).decode("utf-8")
+                bufs += self.rfile.read(length - read_bytes)
                 read_bytes = len(bufs)
 
             TestHttpClient.request_body = bufs
             self.send_response(200)
             self.send_header("Content-Length", 0)
             self.end_headers()
-        except Exception as e:
+        except OSError as e:
             dd(repr(e) + " while parse put request")
 
     def do_GET(self):
@@ -525,7 +571,9 @@ class Handle(BaseHTTPRequestHandler):
             self.end_headers()
 
             self._send_body(headers, body)
-        except Exception as e:
+        except (OSError, AttributeError) as e:
+            # The malformed responses, such as /invalid_line, send no header,
+            # so end_headers() raises AttributeError.
             dd(repr(e) + " while parse get request")
 
     def _send_body(self, headers, body):
@@ -538,13 +586,13 @@ class Handle(BaseHTTPRequestHandler):
                     ext = ""
                 else:
                     ext = ";extname"
-                send_buf = "%x%s\r\n%s\r\n" % (len(send_buf), ext, send_buf)
+                send_buf = f"{len(send_buf):x}{ext}\r\n{send_buf}\r\n"
 
             self.wfile.write(send_buf.encode("utf-8"))
             data = data[each_send_size:]
 
         if "Transfer-Encoding" in headers:
-            self.wfile.write(("0\r\n\r\n").encode("utf-8"))
+            self.wfile.write(b"0\r\n\r\n")
 
     def _get_body(self, headers, body):
         each_send_size, data = body

{k3http-0.1.4 → k3http-0.1.6}/test/test_util.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python3
-# coding: utf-8
-
 import unittest
 
 import k3http

{k3http-0.1.4 → k3http-0.1.6}/util.py

@@ -1,7 +1,3 @@
-#!/usr/bin/env python3
-# coding: utf-8
-
-
 def headers_add_host(headers, address):
     """
     If there is no Host field in the headers, insert the address as a Host into the headers.