libentry 1.19__py3-none-any.whl → 1.20__py3-none-any.whl

libentry/api.py

@@ -15,7 +15,8 @@ from time import sleep
 from typing import Any, Callable, Iterable, List, Literal, Mapping, Optional, Tuple
 from urllib.parse import urljoin
 
-import requests
+from urllib3 import PoolManager
+from urllib3.exceptions import HTTPError, TimeoutError
 
 from libentry import json
 
@@ -193,32 +194,49 @@ class APIClient:
         if api_key is not None:
             self.headers["Authorization"] = f"Bearer {api_key}"
         self.verify = verify
+        self.charset = "UTF-8"
+
+    DEFAULT_CONN_POOL_SIZE = 10
+    CONN_POOL = (
+        PoolManager(DEFAULT_CONN_POOL_SIZE),
+        PoolManager(DEFAULT_CONN_POOL_SIZE, cert_reqs='CERT_NONE')
+    )
 
     def _request(
             self,
-            method: str,
+            method: Literal["GET", "POST"],
             url: str,
-            num_trials: int,
-            timeout: float,
-            interval: float,
-            retry_factor: float,
+            body: Optional[str] = None,
+            headers: Optional[Mapping[str, str]] = None,
+            stream: bool = False,
+            num_trials: int = 5,
+            timeout: float = 15,
+            interval: float = 1,
+            retry_factor: float = 0.5,
             on_error: Optional[ErrorCallback] = None,
-            **kwargs
+            verify: Optional[bool] = None,
     ):
+        headers = self.headers if headers is None else headers
+        verify = self.verify if verify is None else verify
+        preload_content = not stream
+
+        pool = self.CONN_POOL[int(not verify)]
         err = None
         for i in range(num_trials):
             try:
-                return requests.request(
+                return pool.request(
                     method=method,
                     url=url,
+                    body=body,
+                    headers=headers,
                     timeout=timeout * (1 + i * retry_factor),
-                    **kwargs
+                    preload_content=preload_content
                 )
-            except requests.Timeout as e:
+            except TimeoutError as e:
                 err = e
                 if callable(on_error):
                     on_error(e)
-            except requests.ConnectionError as e:
+            except HTTPError as e:
                 err = e
                 if callable(on_error):
                     on_error(e)
@@ -236,10 +254,8 @@ class APIClient:
     ):
         full_url = urljoin(self.base_url, path)
         response = self._request(
-            "get",
+            method="GET",
             url=full_url,
-            headers=self.headers,
-            verify=self.verify,
             num_trials=num_trials,
             timeout=timeout,
             interval=interval,
@@ -247,15 +263,15 @@ class APIClient:
             on_error=on_error
         )
 
-        if response.status_code != 200:
-            text = response.text
-            response.close()
+        if response.status != 200:
+            text = response.data.decode(self.charset)
+            response.release_conn()
             raise ServiceError(text)
 
         try:
-            return _load_json_or_str(response.text)
+            return _load_json_or_str(response.data.decode(self.charset))
         finally:
-            response.close()
+            response.release_conn()
 
     def post(
             self,
@@ -271,19 +287,19 @@ class APIClient:
             chunk_delimiter: str = "\n\n",
             chunk_prefix: str = None,
             chunk_suffix: str = None,
-            error_prefix: str = "ERROR: "
+            error_prefix: str = "ERROR: ",
+            stream_read_size: int = 512
     ):
         full_url = urljoin(self.base_url, path)
 
         headers = {**self.headers}
         headers["Accept"] = headers["Accept"] + f"; stream={int(stream)}"
-        data = json.dumps(json_data) if json_data is not None else None
+        body = json.dumps(json_data) if json_data is not None else None
         response = self._request(
-            "post",
+            "POST",
             url=full_url,
+            body=body,
             headers=headers,
-            data=data,
-            verify=self.verify,
             stream=stream,
             num_trials=num_trials,
             timeout=timeout,
@@ -291,70 +307,81 @@ class APIClient:
             retry_factor=retry_factor,
             on_error=on_error
         )
-        if response.status_code != 200:
-            text = response.text
-            response.close()
+        if response.status != 200:
+            text = response.data.decode(self.charset)
+            response.release_conn()
             raise ServiceError(text)
 
-        if stream:
-            if chunk_delimiter is None:
-                # TODO: this branch is not tested yet!
-                return response.iter_content(decode_unicode=True)
-            else:
-                gen = self._iter_chunks(
-                    response=response,
-                    chunk_delimiter=chunk_delimiter.encode() if chunk_delimiter else None,
-                    chunk_prefix=chunk_prefix.encode() if chunk_prefix else None,
-                    chunk_suffix=chunk_suffix.encode() if chunk_suffix else None,
-                    error_prefix=error_prefix.encode() if error_prefix else None,
-                )
-                return gen if not exhaust_stream else [*gen]
-        else:
+        if not stream:
             try:
-                return _load_json_or_str(response.text)
+                return _load_json_or_str(response.data.decode(self.charset))
             finally:
-                response.close()
+                response.release_conn()
+        else:
+            def iter_content():
+                try:
+                    if hasattr(response, "stream"):
+                        yield from response.stream(stream_read_size, decode_content=True)
+                    else:
+                        while True:
+                            data = response.read(stream_read_size)
+                            if not data:
+                                break
+                            yield data
+                finally:
+                    response.release_conn()
+
+            def iter_lines(contents: Iterable[bytes]) -> Iterable[str]:
+                delimiter = chunk_delimiter.encode(self.charset) if chunk_delimiter is not None else None
+                pending = None
+                for data in contents:
+                    if pending is not None:
+                        data = pending + data
+
+                    lines = data.split(delimiter) if delimiter else data.splitlines()
+                    pending = lines.pop() if lines and lines[-1] and lines[-1][-1] == data[-1] else None
+
+                    for line in lines:
+                        yield line.decode(self.charset)
+
+                if pending is not None:
+                    yield pending.decode(self.charset)
+
+            def iter_chunks(lines: Iterable[str]):
+                error = None
+                for chunk in lines:
+                    if error is not None:
+                        # error is not None means there is a fatal exception raised from the server side.
+                        # The client should just complete the stream and then raise the error to the upper.
+                        continue
 
-    def _iter_chunks(
-            self,
-            response: requests.Response,
-            chunk_delimiter: bytes,
-            chunk_prefix: bytes,
-            chunk_suffix: bytes,
-            error_prefix: bytes
-    ) -> Iterable:
-        try:
-            error = None
-            for chunk in response.iter_lines(decode_unicode=False, delimiter=chunk_delimiter):
-                if error is not None:
-                    # error is not None means there is a fatal exception raised from the server side.
-                    # The client should just complete the stream and then raise the error to the upper.
-                    continue
+                    if not chunk:
+                        continue
 
-                if not chunk:
-                    continue
+                    if error_prefix is not None:
+                        if chunk.startswith(error_prefix):
+                            chunk = chunk[len(error_prefix):]
+                            error = ServiceError(chunk)
+                            continue
 
-                if error_prefix is not None:
-                    if chunk.startswith(error_prefix):
-                        chunk = chunk[len(error_prefix):]
-                        error = ServiceError(chunk)
-                        continue
+                    if chunk_prefix is not None:
+                        if chunk.startswith(chunk_prefix):
+                            chunk = chunk[len(chunk_prefix):]
+                        else:
+                            continue
 
-                if chunk_prefix is not None:
-                    if chunk.startswith(chunk_prefix):
-                        chunk = chunk[len(chunk_prefix):]
-                    else:
-                        continue
+                    if chunk_suffix is not None:
+                        if chunk.endswith(chunk_suffix):
+                            chunk = chunk[:-len(chunk_suffix)]
+                        else:
+                            continue
 
-                if chunk_suffix is not None:
-                    if chunk.endswith(chunk_suffix):
-                        chunk = chunk[:-len(chunk_suffix)]
-                    else:
-                        continue
+                    yield _load_json_or_str(chunk)
 
-                yield _load_json_or_str(chunk)
+                if error is not None:
+                    raise error
 
-            if error is not None:
-                raise error
-        finally:
-            response.close()
+            gen = iter_content()
+            gen = iter_lines(gen)
+            gen = iter_chunks(gen)
+            return gen if not exhaust_stream else [*gen]

libentry/test_api.py

@@ -21,6 +21,7 @@ class TestRequest(BaseModel):
     timeout: float = 15
     num_threads: int = 1
     num_calls: int = 1
+    stream: bool = False
     quiet: bool = False
     max_resp_len: int = 100
 
@@ -42,7 +43,8 @@ def test(request: TestRequest):
             try:
                 kwargs = dict(
                     on_error=lambda err: print(f"[{tid}:{cid}:RETRY] {err}"),
-                    timeout=request.timeout
+                    timeout=request.timeout,
+                    stream=request.stream
                 )
                 t = time()
                 if request.method == "GET":
@@ -56,12 +58,26 @@ def test(request: TestRequest):
                         request.data,
                         **kwargs
                     )
-                t = time() - t
+                if not request.stream:
+                    t = time() - t
+                    if not request.quiet:
+                        content = str(response).replace("\n", "\\n")
+                        print(f"[{tid}:{cid}:SUCCESS] Response={content:.{request.max_resp_len}} Time={t:.04f}")
+                else:
+                    if not request.quiet and request.num_threads == 1:
+                        print(f"[{tid}:{cid}:SUCCESS] Response=[", end="", flush=True)
+                        for chunk in response:
+                            print(f"'{chunk}', ", end="", flush=True)
+                        t = time() - t
+                        print(f"] Time={t:.04f}", flush=True)
+                    else:
+                        content = [*response]
+                        t = time() - t
+                        if not request.quiet:
+                            content = str(content).replace("\n", "\\n")
+                            print(f"[{tid}:{cid}:SUCCESS] Response={content:.{request.max_resp_len}} Time={t:.04f}")
                 with lock:
                     time_list.append(t)
-                if not request.quiet:
-                    content = str(response).replace("\n", " ")
-                    print(f"[{tid}:{cid}:SUCCESS] Time={t:.04f} Response={content:.{request.max_resp_len}}")
             except Exception as e:
                 print(f"[{tid}:{cid}:FAILED] {e}")
 
@@ -93,6 +109,7 @@ def main():
     parser.add_argument("--timeout", type=float, default=15)
     parser.add_argument("--num_threads", "-t", type=int, default=1)
     parser.add_argument("--num_calls", "-c", type=int, default=1)
+    parser.add_argument("--stream", "-s", action="store_true")
     parser.add_argument("--quiet", "-q", action="store_true")
     args = parser.parse_args()
 
@@ -110,6 +127,7 @@ def main():
         timeout=args.timeout,
         num_threads=args.num_threads,
         num_calls=args.num_calls,
+        stream=args.stream,
         quiet=args.quiet
     ))
     print(response.model_dump_json(indent=4))

{libentry-1.19.dist-info → libentry-1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libentry
-Version: 1.19
+Version: 1.20
 Summary: Entries for experimental utilities.
 Home-page: https://github.com/XoriieInpottn/libentry
 Author: xi
@@ -12,10 +12,10 @@ Description-Content-Type: text/markdown
 Requires-Dist: Flask
 Requires-Dist: PyYAML
 Requires-Dist: gunicorn
-Requires-Dist: json5
 Requires-Dist: numpy
+Requires-Dist: psutil
 Requires-Dist: pydantic
-Requires-Dist: requests
+Requires-Dist: urllib3
 
 # libentry
 

{libentry-1.19.dist-info → libentry-1.20.dist-info}/RECORD

@@ -1,5 +1,5 @@
 libentry/__init__.py,sha256=rDBip9M1Xb1N4wMKE1ni_DldrQbkRjp8DxPkTp3K2qo,170
-libentry/api.py,sha256=LqTa8T8Oh8z5BybzrgtdC0HhMXWL2-DZPdOdBHb6Vl0,10753
+libentry/api.py,sha256=bs4mpOLRA6i9gAWPGzeNarpKssZs2UlaP2xuQbAi9NQ,12063
 libentry/argparse.py,sha256=NxzXV-jBN51ReZsNs5aeyOfzwYQ5A5nJ95rWoa-FYCs,10415
 libentry/dataclasses.py,sha256=AQV2PuxplJCwGZ5HKX72U-z-POUhTdy3XtpEK9KNIGQ,4541
 libentry/executor.py,sha256=cTV0WxJi0nU1TP-cOwmeodN8DD6L1691M2HIQsJtGrU,6582
@@ -8,7 +8,7 @@ libentry/json.py,sha256=1-Kv5ZRb5dBrOTU84n6sZtYZV3xE-O6wEt_--ynbSaU,1209
 libentry/logging.py,sha256=IiYoCUzm8XTK1fduA-NA0FI2Qz_m81NEPV3d3tEfgdI,1349
 libentry/schema.py,sha256=BO7EE7i43Cb4xn_OLsBM-HDwWOT6V5fPs91Am3QqnNQ,8178
 libentry/server.py,sha256=gYPoZXd0umlDYZf-6ZV0_vJadg3YQvnLDc6JFDJh9jc,1503
-libentry/test_api.py,sha256=uiHo9rVli9ENkzIyyFDDK6PdteBdetFTA8ikCDNykRQ,3488
+libentry/test_api.py,sha256=GFmirvxfCAQ-nhh6QXyB5EpF4WaENCc3Eoymuk5JxBQ,4448
 libentry/service/__init__.py,sha256=1oLL20yLB1GL9IbFiZD8OReDqiCpFr-yetIR6x1cNkI,23
 libentry/service/common.py,sha256=OVaW2afgKA6YqstJmtnprBCqQEUZEWotZ6tHavmJJeU,42
 libentry/service/flask.py,sha256=Alpsix01ROqI28k-dabD8wJlWAWs-ObNc1nJ-LxOXn4,13349
@@ -16,10 +16,10 @@ libentry/service/list.py,sha256=ElHWhTgShGOhaxMUEwVbMXos0NQKjHsODboiQ-3AMwE,1397
 libentry/service/running.py,sha256=FrPJoJX6wYxcHIysoatAxhW3LajCCm0Gx6l7__6sULQ,5105
 libentry/service/start.py,sha256=mZT7b9rVULvzy9GTZwxWnciCHgv9dbGN2JbxM60OMn4,1270
 libentry/service/stop.py,sha256=wOpwZgrEJ7QirntfvibGq-XsTC6b3ELhzRW2zezh-0s,1187
-libentry-1.19.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-libentry-1.19.dist-info/METADATA,sha256=L3cYIpAJrvAMvlHXoqrDqlKe3HeBf2_6BI8EfvqCGuo,812
-libentry-1.19.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-libentry-1.19.dist-info/entry_points.txt,sha256=vgHmJZhM-kqM7U9S179UwDD3pM232tpzJ5NntncXi_8,62
-libentry-1.19.dist-info/top_level.txt,sha256=u2uF6-X5fn2Erf9PYXOg_6tntPqTpyT-yzUZrltEd6I,9
-libentry-1.19.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-libentry-1.19.dist-info/RECORD,,
+libentry-1.20.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+libentry-1.20.dist-info/METADATA,sha256=lW-aRHt0LPfumZXzccvJazTcOXkTCFhNMUrzGiU90-w,812
+libentry-1.20.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+libentry-1.20.dist-info/entry_points.txt,sha256=vgHmJZhM-kqM7U9S179UwDD3pM232tpzJ5NntncXi_8,62
+libentry-1.20.dist-info/top_level.txt,sha256=u2uF6-X5fn2Erf9PYXOg_6tntPqTpyT-yzUZrltEd6I,9
+libentry-1.20.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+libentry-1.20.dist-info/RECORD,,