libentry 1.21__py3-none-any.whl → 1.21.2__py3-none-any.whl

libentry/__init__.py

@@ -5,4 +5,3 @@ from .executor import *
 from .dataclasses import *
 from .experiment import *
 from .logging import *
-from .server import *

libentry/api.py

@@ -12,9 +12,10 @@ __all__ = [
 
 from dataclasses import dataclass, field
 from time import sleep
-from typing import Any, Callable, Iterable, List, Literal, Mapping, Optional, Tuple
+from typing import Any, AsyncIterable, Callable, Iterable, List, Literal, Mapping, Optional, Tuple, Union
 from urllib.parse import urljoin
 
+import httpx
 from urllib3 import PoolManager
 from urllib3.exceptions import HTTPError, TimeoutError
 
@@ -170,7 +171,7 @@ class ServiceError(RuntimeError):
 ErrorCallback = Callable[[Exception], None]
 
 
-class APIClient:
+class BaseClient:
 
     def __init__(
             self,
@@ -181,6 +182,8 @@ class APIClient:
             user_agent: str = "API Client",
             connection: str = "close",
             verify=False,
+            stream_read_size: int = 512,
+            charset: str = "UTF-8",
             **extra_headers
     ) -> None:
         self.base_url = base_url
@@ -194,43 +197,89 @@ class APIClient:
         if api_key is not None:
             self.headers["Authorization"] = f"Bearer {api_key}"
         self.verify = verify
-        self.charset = "UTF-8"
+        self.stream_read_size = stream_read_size
+        self.charset = charset
 
     DEFAULT_CONN_POOL_SIZE = 10
-    CONN_POOL = (
-        PoolManager(DEFAULT_CONN_POOL_SIZE),
-        PoolManager(DEFAULT_CONN_POOL_SIZE, cert_reqs='CERT_NONE')
+    URLLIB3_POOL = (
+        PoolManager(DEFAULT_CONN_POOL_SIZE, cert_reqs='CERT_NONE'),
+        PoolManager(DEFAULT_CONN_POOL_SIZE)
     )
 
-    def _request(
+    def _single_request(
+            self,
+            method: str,
+            url: str,
+            body: Optional[Union[bytes, str]],
+            headers: Optional[Mapping[str, str]],
+            timeout: float,
+            stream: bool,
+            verify: bool,
+    ) -> Union[bytes, Iterable[bytes]]:
+        response = self.URLLIB3_POOL[int(verify)].request(
+            method=method,
+            url=url,
+            body=body,
+            headers=headers,
+            timeout=timeout,
+            preload_content=not stream
+        )
+
+        if response.status != 200:
+            try:
+                raise ServiceError(response.data.decode(self.charset))
+            finally:
+                response.release_conn()
+
+        if not stream:
+            try:
+                return response.data
+            finally:
+                response.release_conn()
+        else:
+            def iter_content():
+                try:
+                    if hasattr(response, "stream"):
+                        yield from response.stream(self.stream_read_size, decode_content=True)
+                    else:
+                        while True:
+                            data = response.read(self.stream_read_size)
+                            if not data:
+                                break
+                            yield data
+                finally:
+                    response.release_conn()
+
+            return iter_content()
+
+    def request(
             self,
             method: Literal["GET", "POST"],
             url: str,
-            body: Optional[str] = None,
+            body: Optional[Union[bytes, str]] = None,
             headers: Optional[Mapping[str, str]] = None,
-            stream: bool = False,
-            num_trials: int = 5,
             timeout: float = 15,
+            num_trials: int = 5,
             interval: float = 1,
             retry_factor: float = 0.5,
             on_error: Optional[ErrorCallback] = None,
+            stream: bool = False,
             verify: Optional[bool] = None,
-    ):
+    ) -> Union[bytes, Iterable[bytes]]:
         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 pool.request(
+                return self._single_request(
                     method=method,
                     url=url,
                     body=body,
                     headers=headers,
                     timeout=timeout * (1 + i * retry_factor),
-                    preload_content=preload_content
+                    stream=stream,
+                    verify=verify,
                 )
             except TimeoutError as e:
                 err = e
@@ -243,98 +292,289 @@ class APIClient:
             sleep(interval)
         raise err
 
-    def get(
+    HTTPX_POOL = httpx.Limits(max_keepalive_connections=DEFAULT_CONN_POOL_SIZE)
+
+    async def _single_request_async(
             self,
-            path: Optional[str] = None, *,
+            method: str,
+            url: str,
+            body: Optional[Union[bytes, str]],
+            headers: Optional[Mapping[str, str]],
+            timeout: float,
+            stream: bool,
+            verify: bool,
+    ):
+        if not stream:
+            async with httpx.AsyncClient(headers=headers, verify=verify) as client:
+                response = await client.request(
+                    method=method,
+                    url=url,
+                    content=body,
+                    timeout=timeout
+                )
+                try:
+                    if response.status_code != 200:
+                        raise ServiceError(response.content.decode(self.charset))
+                    return response.content
+                finally:
+                    await response.aclose()
+        else:
+            client = httpx.AsyncClient(headers=headers, verify=verify)
+            response = client.stream(
+                method=method,
+                url=url,
+                content=body,
+                timeout=timeout
+            )
+
+            async def iter_content():
+                try:
+                    async with response as r:
+                        if r.status_code != 200:
+                            content = await r.aread()
+                            raise ServiceError(content.decode(self.charset))
+                        async for data in r.aiter_bytes():
+                            yield data
+                finally:
+                    await client.aclose()
+
+            return iter_content()
+
+    async def request_async(
+            self,
+            method: Literal["GET", "POST"],
+            url: str,
+            body: Optional[Union[bytes, str]] = None,
+            headers: Optional[Mapping[str, str]] = None,
+            timeout: float = 15,
             num_trials: int = 5,
+            interval: float = 1,
+            retry_factor: float = 0.5,
+            on_error: Optional[ErrorCallback] = None,
+            stream: bool = False,
+            verify: Optional[bool] = None,
+    ):
+        headers = self.headers if headers is None else headers
+        verify = self.verify if verify is None else verify
+
+        err = None
+        for i in range(num_trials):
+            try:
+                return await self._single_request_async(
+                    method=method,
+                    url=url,
+                    body=body,
+                    headers=headers,
+                    timeout=timeout * (1 + i * retry_factor),
+                    stream=stream,
+                    verify=verify,
+                )
+            except httpx.TimeoutException as e:
+                err = e
+                if callable(on_error):
+                    on_error(e)
+            except httpx.HTTPError as e:
+                err = e
+                if callable(on_error):
+                    on_error(e)
+            sleep(interval)
+        raise err
+
+
+class APIClient(BaseClient):
+
+    def request(
+            self,
+            method: Literal["GET", "POST"],
+            path: str,
+            json_data: Optional[Mapping] = None,
+            *,
+            headers: Optional[Mapping[str, str]] = None,
             timeout: float = 15,
+            num_trials: int = 5,
             interval: float = 1,
             retry_factor: float = 0.5,
-            on_error: Optional[ErrorCallback] = None
+            on_error: Optional[ErrorCallback] = None,
+            stream: bool = False,
+            chunk_delimiter: str = "\n\n",
+            chunk_prefix: str = None,
+            chunk_suffix: str = None,
+            error_prefix: str = "ERROR: ",
+            exhaust_stream: bool = False,
+            verify: Optional[bool] = None,
     ):
         full_url = urljoin(self.base_url, path)
-        response = self._request(
-            method="GET",
-            url=full_url,
-            num_trials=num_trials,
+        headers = {**self.headers}
+        headers["Accept"] = headers["Accept"] + f"; stream={int(stream)}"
+        body = json.dumps(json_data) if json_data is not None else None
+        content = super().request(
+            method,
+            full_url,
+            body=body,
+            headers=headers,
             timeout=timeout,
+            num_trials=num_trials,
             interval=interval,
             retry_factor=retry_factor,
-            on_error=on_error
+            on_error=on_error,
+            stream=stream,
+            verify=verify,
         )
+        if not stream:
+            return _load_json_or_str(content.decode(self.charset))
+        else:
+            def iter_lines(data_list: Iterable[bytes]) -> Iterable[str]:
+                delimiter = chunk_delimiter.encode(self.charset) if chunk_delimiter is not None else None
+                pending = None
+                for data in data_list:
+                    if pending is not None:
+                        data = pending + data
 
-        if response.status != 200:
-            text = response.data.decode(self.charset)
-            response.release_conn()
-            raise ServiceError(text)
+                    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
+
+                    if not chunk:
+                        continue
 
-        try:
-            return _load_json_or_str(response.data.decode(self.charset))
-        finally:
-            response.release_conn()
+                    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_suffix is not None:
+                        if chunk.endswith(chunk_suffix):
+                            chunk = chunk[:-len(chunk_suffix)]
+                        else:
+                            continue
+
+                    yield _load_json_or_str(chunk)
+
+                if error is not None:
+                    raise error
+
+            gen = iter_lines(content)
+            gen = iter_chunks(gen)
+            return gen if not exhaust_stream else [*gen]
+
+    def get(
+            self,
+            path: Optional[str] = None,
+            *,
+            timeout: float = 15,
+            num_trials: int = 5,
+            interval: float = 1,
+            retry_factor: float = 0.5,
+            on_error: Optional[ErrorCallback] = None
+    ):
+        return self.request(
+            "GET",
+            path,
+            timeout=timeout,
+            num_trials=num_trials,
+            interval=interval,
+            retry_factor=retry_factor,
+            on_error=on_error,
+        )
 
     def post(
             self,
             path: Optional[str] = None,
-            json_data: Optional[Mapping] = None, *,
+            json_data: Optional[Mapping] = None,
+            *,
+            timeout: float = 15,
+            num_trials: int = 5,
+            interval: float = 1,
+            retry_factor: float = 0.5,
+            on_error: Optional[ErrorCallback] = None,
             stream: bool = False,
+            chunk_delimiter: str = "\n\n",
+            chunk_prefix: str = None,
+            chunk_suffix: str = None,
+            error_prefix: str = "ERROR: ",
             exhaust_stream: bool = False,
-            num_trials: int = 5,
+    ):
+        return self.request(
+            "POST",
+            path,
+            json_data=json_data,
+            timeout=timeout,
+            num_trials=num_trials,
+            interval=interval,
+            retry_factor=retry_factor,
+            on_error=on_error,
+            stream=stream,
+            chunk_delimiter=chunk_delimiter,
+            chunk_prefix=chunk_prefix,
+            chunk_suffix=chunk_suffix,
+            error_prefix=error_prefix,
+            exhaust_stream=exhaust_stream,
+        )
+
+    async def request_async(
+            self,
+            method: Literal["GET", "POST"],
+            path: str,
+            json_data: Optional[Mapping] = None,
+            *,
+            headers: Optional[Mapping[str, str]] = None,
             timeout: float = 15,
+            num_trials: int = 5,
             interval: float = 1,
             retry_factor: float = 0.5,
             on_error: Optional[ErrorCallback] = None,
+            stream: bool = False,
             chunk_delimiter: str = "\n\n",
             chunk_prefix: str = None,
             chunk_suffix: str = None,
             error_prefix: str = "ERROR: ",
-            stream_read_size: int = 512
+            exhaust_stream: bool = False,
+            verify: Optional[bool] = None,
     ):
         full_url = urljoin(self.base_url, path)
-
         headers = {**self.headers}
         headers["Accept"] = headers["Accept"] + f"; stream={int(stream)}"
         body = json.dumps(json_data) if json_data is not None else None
-        response = self._request(
-            "POST",
-            url=full_url,
+        content = await super().request_async(
+            method,
+            full_url,
             body=body,
             headers=headers,
-            stream=stream,
-            num_trials=num_trials,
             timeout=timeout,
+            num_trials=num_trials,
             interval=interval,
             retry_factor=retry_factor,
-            on_error=on_error
+            on_error=on_error,
+            stream=stream,
+            verify=verify,
         )
-        if response.status != 200:
-            text = response.data.decode(self.charset)
-            response.release_conn()
-            raise ServiceError(text)
-
         if not stream:
-            try:
-                return _load_json_or_str(response.data.decode(self.charset))
-            finally:
-                response.release_conn()
+            return _load_json_or_str(content.decode(self.charset))
         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]:
+            async def iter_lines(data_list: AsyncIterable[bytes]) -> AsyncIterable[str]:
                 delimiter = chunk_delimiter.encode(self.charset) if chunk_delimiter is not None else None
                 pending = None
-                for data in contents:
+                async for data in data_list:
                     if pending is not None:
                         data = pending + data
 
@@ -347,9 +587,9 @@ class APIClient:
                 if pending is not None:
                     yield pending.decode(self.charset)
 
-            def iter_chunks(lines: Iterable[str]):
+            async def iter_chunks(lines: AsyncIterable[str]) -> AsyncIterable:
                 error = None
-                for chunk in lines:
+                async 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.
@@ -381,7 +621,60 @@ class APIClient:
                 if error is not None:
                     raise error
 
-            gen = iter_content()
-            gen = iter_lines(gen)
+            gen = iter_lines(content)
             gen = iter_chunks(gen)
             return gen if not exhaust_stream else [*gen]
+
+    async def get_async(
+            self,
+            path: Optional[str] = None,
+            *,
+            timeout: float = 15,
+            num_trials: int = 5,
+            interval: float = 1,
+            retry_factor: float = 0.5,
+            on_error: Optional[ErrorCallback] = None
+    ):
+        return await self.request_async(
+            "GET",
+            path,
+            timeout=timeout,
+            num_trials=num_trials,
+            interval=interval,
+            retry_factor=retry_factor,
+            on_error=on_error,
+        )
+
+    async def post_async(
+            self,
+            path: Optional[str] = None,
+            json_data: Optional[Mapping] = None,
+            *,
+            timeout: float = 15,
+            num_trials: int = 5,
+            interval: float = 1,
+            retry_factor: float = 0.5,
+            on_error: Optional[ErrorCallback] = None,
+            stream: bool = False,
+            chunk_delimiter: str = "\n\n",
+            chunk_prefix: str = None,
+            chunk_suffix: str = None,
+            error_prefix: str = "ERROR: ",
+            exhaust_stream: bool = False,
+    ):
+        return await self.request_async(
+            "POST",
+            path,
+            json_data=json_data,
+            timeout=timeout,
+            num_trials=num_trials,
+            interval=interval,
+            retry_factor=retry_factor,
+            on_error=on_error,
+            stream=stream,
+            chunk_delimiter=chunk_delimiter,
+            chunk_prefix=chunk_prefix,
+            chunk_suffix=chunk_suffix,
+            error_prefix=error_prefix,
+            exhaust_stream=exhaust_stream,
+        )

libentry/test_api.py

@@ -43,8 +43,7 @@ def test(request: TestRequest):
             try:
                 kwargs = dict(
                     on_error=lambda err: print(f"[{tid}:{cid}:RETRY] {err}"),
-                    timeout=request.timeout,
-                    stream=request.stream
+                    timeout=request.timeout
                 )
                 t = time()
                 if request.method == "GET":
@@ -56,6 +55,7 @@ def test(request: TestRequest):
                     response = APIClient().post(
                         request.url,
                         request.data,
+                        stream=request.stream,
                         **kwargs
                     )
                 if not request.stream:

{libentry-1.21.dist-info → libentry-1.21.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: libentry
-Version: 1.21
+Version: 1.21.2
 Summary: Entries for experimental utilities.
 Home-page: https://github.com/XoriieInpottn/libentry
 Author: xi
@@ -9,23 +9,13 @@ License: Apache-2.0 license
 Platform: any
 Classifier: Programming Language :: Python :: 3
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pydantic
+Requires-Dist: Flask
 Requires-Dist: PyYAML
+Requires-Dist: gunicorn
+Requires-Dist: httpx
 Requires-Dist: numpy
+Requires-Dist: pydantic
 Requires-Dist: urllib3
-Requires-Dist: Flask
-Requires-Dist: gunicorn
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: platform
-Dynamic: requires-dist
-Dynamic: summary
 
 # libentry
 
@@ -39,3 +29,5 @@ Dynamic: summary
 2. Use its post() or get() method to send the request.
 
 
+
+

{libentry-1.21.dist-info → libentry-1.21.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
-libentry/__init__.py,sha256=rDBip9M1Xb1N4wMKE1ni_DldrQbkRjp8DxPkTp3K2qo,170
-libentry/api.py,sha256=bs4mpOLRA6i9gAWPGzeNarpKssZs2UlaP2xuQbAi9NQ,12063
+libentry/__init__.py,sha256=ko2YBIIx5H3dD0tedBkialzJGEDczFaP_PZmT1cIlak,148
+libentry/api.py,sha256=zlZF0IWyQu8GPEVAM0J6K8BOSgqI06p8JJVoCNaTCBo,22110
 libentry/argparse.py,sha256=NxzXV-jBN51ReZsNs5aeyOfzwYQ5A5nJ95rWoa-FYCs,10415
 libentry/dataclasses.py,sha256=AQV2PuxplJCwGZ5HKX72U-z-POUhTdy3XtpEK9KNIGQ,4541
 libentry/executor.py,sha256=cTV0WxJi0nU1TP-cOwmeodN8DD6L1691M2HIQsJtGrU,6582
@@ -7,8 +7,7 @@ libentry/experiment.py,sha256=ejgAHDXWIe9x4haUzIFuz1WasLY0_aD1z_vyEVGjTu8,4922
 libentry/json.py,sha256=1-Kv5ZRb5dBrOTU84n6sZtYZV3xE-O6wEt_--ynbSaU,1209
 libentry/logging.py,sha256=IiYoCUzm8XTK1fduA-NA0FI2Qz_m81NEPV3d3tEfgdI,1349
 libentry/schema.py,sha256=o6JcdR00Yj4_Qjmlo100OlQpMVnl0PgvvwVVrL9limw,8268
-libentry/server.py,sha256=gYPoZXd0umlDYZf-6ZV0_vJadg3YQvnLDc6JFDJh9jc,1503
-libentry/test_api.py,sha256=GFmirvxfCAQ-nhh6QXyB5EpF4WaENCc3Eoymuk5JxBQ,4448
+libentry/test_api.py,sha256=Xw7B7sH6g1iCTV5sFzyBF3JAJzeOr9xg0AyezTNsnIk,4452
 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 +15,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.21.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-libentry-1.21.dist-info/METADATA,sha256=_WRBE701A14mz9idf8wRi6UnN6ZSo9e8X1KyjNxj1zw,1017
-libentry-1.21.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-libentry-1.21.dist-info/entry_points.txt,sha256=1v_nLVDsjvVJp9SWhl4ef2zZrsLTBtFWgrYFgqvQBgc,61
-libentry-1.21.dist-info/top_level.txt,sha256=u2uF6-X5fn2Erf9PYXOg_6tntPqTpyT-yzUZrltEd6I,9
-libentry-1.21.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-libentry-1.21.dist-info/RECORD,,
+libentry-1.21.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+libentry-1.21.2.dist-info/METADATA,sha256=M2-N8UEjYrgrXC-85vZ2-ts0SeNjOTx9_Vjclgdu8Xg,813
+libentry-1.21.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+libentry-1.21.2.dist-info/entry_points.txt,sha256=vgHmJZhM-kqM7U9S179UwDD3pM232tpzJ5NntncXi_8,62
+libentry-1.21.2.dist-info/top_level.txt,sha256=u2uF6-X5fn2Erf9PYXOg_6tntPqTpyT-yzUZrltEd6I,9
+libentry-1.21.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+libentry-1.21.2.dist-info/RECORD,,

{libentry-1.21.dist-info → libentry-1.21.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{libentry-1.21.dist-info → libentry-1.21.2.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 libentry_test_api = libentry.test_api:main
+

libentry/server.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-
-import os
-from socketserver import ThreadingMixIn
-from threading import Thread
-from xmlrpc.server import SimpleXMLRPCRequestHandler, SimpleXMLRPCServer
-
-from libentry.logging import logger
-
-__all__ = [
-    'XMLRPCServerMixIn',
-]
-
-
-class ThreadXMLRPCServer(ThreadingMixIn, SimpleXMLRPCServer):
-    pass
-
-
-class MultRequestHandler(SimpleXMLRPCRequestHandler):
-    rpc_paths = ('/RPC2', '/RPC3')
-
-    def log_message(self, fmt, *args):
-        logger.info(fmt % args)
-
-
-class XMLRPCServerMixIn:
-
-    def __init__(self, log_request=True):
-        self.log_request = log_request
-
-    def serve_forever(self, addr, daemon=False):
-        if 'RANK' in os.environ:
-            rank = int(os.environ['RANK'])
-            if rank > 0:
-                return
-
-        with ThreadXMLRPCServer(
-                addr,
-                requestHandler=MultRequestHandler,
-                allow_none=True,
-                logRequests=self.log_request
-        ) as server:
-            server.register_introspection_functions()
-            server.register_multicall_functions()
-            server.register_instance(self)
-            if daemon:
-                if hasattr(self, 'serve_thread'):
-                    raise RuntimeError('Server is already running.')
-                serve_thread = Thread(target=server.serve_forever, daemon=daemon)
-                serve_thread.start()
-                setattr(self, 'serve_thread', serve_thread)
-            else:
-                server.serve_forever()