xoscar 0.9.0__cp312-cp312-macosx_10_13_x86_64.whl

xoscar/aio/__init__.py

@@ -0,0 +1,16 @@
+# Copyright 2022-2023 XProbe Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from .file import AioFileObject
+from .lru import alru_cache
+from .parallelism import AioEvent

xoscar/aio/base.py

@@ -0,0 +1,86 @@
+# Copyright 2022-2023 XProbe Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import asyncio
+import functools
+from concurrent.futures import Executor
+from typing import Any, Type
+
+
+def _make_delegate_method(attr):
+    async def method(self, *args, **kwargs):
+        func = functools.partial(getattr(self._file, attr), *args, **kwargs)
+        return await self._loop.run_in_executor(self._executor, func)
+
+    return method
+
+
+def _make_proxy_method(attr):
+    def method(self, *args, **kwargs):
+        return getattr(self._file, attr)(*args, **kwargs)
+
+    return method
+
+
+def _make_proxy_property(attr):
+    def proxy_property(self):
+        return getattr(self._file, attr)
+
+    return property(proxy_property)
+
+
+def delegate_to_executor(*attrs):
+    def wrap_cls(cls: Type):
+        for attr in attrs:
+            setattr(cls, attr, _make_delegate_method(attr))
+        return cls
+
+    return wrap_cls
+
+
+def proxy_method_directly(*attrs):
+    def wrap_cls(cls: Type):
+        for attr in attrs:
+            setattr(cls, attr, _make_proxy_method(attr))
+        return cls
+
+    return wrap_cls
+
+
+def proxy_property_directly(*attrs):
+    def wrap_cls(cls):
+        for attr in attrs:
+            setattr(cls, attr, _make_proxy_property(attr))
+        return cls
+
+    return wrap_cls
+
+
+class AioBase:
+    def __init__(
+        self,
+        file: Any,
+        loop: asyncio.BaseEventLoop | None = None,
+        executor: Executor | None = None,
+    ):
+        if loop is None:
+            loop = asyncio.get_event_loop()  # type: ignore
+        if isinstance(file, AioBase):
+            file = file._file  # type: ignore
+
+        self._file = file
+        self._loop = loop
+        self._executor = executor

xoscar/aio/file.py

@@ -0,0 +1,59 @@
+# Copyright 2022-2023 XProbe Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .base import (
+    AioBase,
+    delegate_to_executor,
+    proxy_method_directly,
+    proxy_property_directly,
+)
+
+
+@delegate_to_executor(
+    "close",
+    "flush",
+    "isatty",
+    "read",
+    "read1",
+    "readinto",
+    "readline",
+    "readlines",
+    "seek",
+    "seekable",
+    "tell",
+    "truncate",
+    "writable",
+    "write",
+    "writelines",
+)
+@proxy_method_directly("fileno", "readable")
+@proxy_property_directly("closed", "name", "mode")
+class AioFileObject(AioBase):
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        """Simulate normal file iteration."""
+        line = await self.readline()
+        if line:
+            return line
+        else:
+            raise StopAsyncIteration
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+        self._file = None

xoscar/aio/lru.py

@@ -0,0 +1,228 @@
+# The MIT License
+#
+# Copyright (c) 2018 aio-libs team https://github.com/aio-libs/
+# Copyright (c) 2017 Ocean S. A. https://ocean.io/
+# Copyright (c) 2016-2017 WikiBusiness Corporation http://wikibusiness.org/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import asyncio
+import os
+import weakref
+from collections import OrderedDict
+from functools import _CacheInfo, _make_key, partial, wraps
+
+__version__ = "1.0.2"
+
+__all__ = ("alru_cache", "clear_all_alru_caches")
+
+_is_ci = (os.environ.get("CI") or "0").lower() in ("1", "true")
+_all_wrapped: weakref.WeakSet = weakref.WeakSet()
+
+
+def clear_all_alru_caches():
+    for wrapped in _all_wrapped:
+        wrapped.cache_clear()
+
+
+def unpartial(fn):
+    while hasattr(fn, "func"):
+        fn = fn.func
+
+    return fn
+
+
+def _done_callback(fut, task):
+    if task.cancelled():
+        fut.cancel()
+        return
+
+    exc = task.exception()
+    if exc is not None:
+        fut.set_exception(exc)
+        return
+
+    fut.set_result(task.result())
+
+
+def _cache_invalidate(wrapped, typed, *args, **kwargs):
+    key = _make_key(args, kwargs, typed)
+
+    exists = key in wrapped._cache
+
+    if exists:
+        wrapped._cache.pop(key)
+
+    return exists
+
+
+def _cache_clear(wrapped):
+    wrapped.hits = wrapped.misses = 0
+    wrapped._cache = OrderedDict()
+    wrapped.tasks = set()
+
+
+def _open(wrapped):
+    if not wrapped.closed:
+        raise RuntimeError("alru_cache is not closed")
+
+    was_closed = (
+        wrapped.hits == wrapped.misses == len(wrapped.tasks) == len(wrapped._cache) == 0
+    )
+
+    if not was_closed:
+        raise RuntimeError("alru_cache was not closed correctly")
+
+    wrapped.closed = False
+
+
+def _close(wrapped, *, cancel=False, return_exceptions=True):
+    if wrapped.closed:
+        raise RuntimeError("alru_cache is closed")
+
+    wrapped.closed = True
+
+    if cancel:
+        for task in wrapped.tasks:
+            if not task.done():  # not sure is it possible
+                task.cancel()
+
+    return _wait_closed(wrapped, return_exceptions=return_exceptions)
+
+
+async def _wait_closed(wrapped, *, return_exceptions):
+    wait_closed = asyncio.gather(*wrapped.tasks, return_exceptions=return_exceptions)
+
+    wait_closed.add_done_callback(partial(_close_waited, wrapped))
+
+    ret = await wait_closed
+
+    # hack to get _close_waited callback to be executed
+    await asyncio.sleep(0)
+
+    return ret
+
+
+def _close_waited(wrapped, _):
+    wrapped.cache_clear()
+
+
+def _cache_info(wrapped, maxsize):
+    return _CacheInfo(
+        wrapped.hits,
+        wrapped.misses,
+        maxsize,
+        len(wrapped._cache),
+    )
+
+
+def __cache_touch(wrapped, key):
+    try:
+        wrapped._cache.move_to_end(key)
+    except KeyError:  # not sure is it possible
+        pass
+
+
+def _cache_hit(wrapped, key):
+    wrapped.hits += 1
+    __cache_touch(wrapped, key)
+
+
+def _cache_miss(wrapped, key):
+    wrapped.misses += 1
+    __cache_touch(wrapped, key)
+
+
+def alru_cache(
+    fn=None,
+    maxsize=128,
+    typed=False,
+    *,
+    cache_exceptions=True,
+):
+    def wrapper(fn):
+        _origin = unpartial(fn)
+
+        if not asyncio.iscoroutinefunction(_origin):
+            raise RuntimeError("Coroutine function is required, got {}".format(fn))
+
+        # functools.partialmethod support
+        if hasattr(fn, "_make_unbound_method"):
+            fn = fn._make_unbound_method()
+
+        @wraps(fn)
+        async def wrapped(*fn_args, **fn_kwargs):
+            if wrapped.closed:
+                raise RuntimeError("alru_cache is closed for {}".format(wrapped))
+
+            loop = asyncio.get_event_loop()
+
+            key = _make_key(fn_args, fn_kwargs, typed)
+
+            fut = wrapped._cache.get(key)
+
+            if fut is not None:
+                if not fut.done():
+                    _cache_hit(wrapped, key)
+                    return await asyncio.shield(fut)
+
+                exc = fut._exception
+
+                if exc is None or cache_exceptions:
+                    _cache_hit(wrapped, key)
+                    return fut.result()
+
+                # exception here and cache_exceptions == False
+                wrapped._cache.pop(key)
+
+            fut = loop.create_future()
+            task = loop.create_task(fn(*fn_args, **fn_kwargs))
+            task.add_done_callback(partial(_done_callback, fut))
+
+            wrapped.tasks.add(task)
+            task.add_done_callback(wrapped.tasks.remove)
+
+            wrapped._cache[key] = fut
+
+            if maxsize is not None and len(wrapped._cache) > maxsize:
+                wrapped._cache.popitem(last=False)
+
+            _cache_miss(wrapped, key)
+            return await asyncio.shield(fut)
+
+        _cache_clear(wrapped)
+        wrapped._origin = _origin
+        wrapped.closed = False
+        wrapped.cache_info = partial(_cache_info, wrapped, maxsize)
+        wrapped.cache_clear = partial(_cache_clear, wrapped)
+        wrapped.invalidate = partial(_cache_invalidate, wrapped, typed)
+        wrapped.close = partial(_close, wrapped)
+        wrapped.open = partial(_open, wrapped)
+
+        if _is_ci:
+            _all_wrapped.add(wrapped)
+        return wrapped
+
+    if fn is None:
+        return wrapper
+
+    if callable(fn) or hasattr(fn, "_make_unbound_method"):
+        return wrapper(fn)
+
+    raise NotImplementedError("{} decorating is not supported".format(fn))

xoscar/aio/parallelism.py

@@ -0,0 +1,39 @@
+# Copyright 2022-2023 XProbe Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import asyncio
+import multiprocessing
+import threading
+from concurrent.futures import Executor
+from typing import Union
+
+from .base import AioBase, delegate_to_executor, proxy_method_directly
+
+event_types = Union[threading.Event, multiprocessing.Event]  # type: ignore
+
+
+@delegate_to_executor("wait")
+@proxy_method_directly("set", "is_set", "clear")
+class AioEvent(AioBase):
+    def __init__(
+        self,
+        event: event_types | None = None,
+        loop: asyncio.BaseEventLoop | None = None,
+        executor: Executor | None = None,
+    ):
+        if event is None:
+            event = threading.Event()
+        super().__init__(event, loop=loop, executor=executor)