backports.interpreters 0.3.0__py3-none-any.whl

backports/interpreters/__init__.py

@@ -0,0 +1,209 @@
+"""Backport of the concurrent.interpreters module (PEP 734).
+
+On Python 3.14+ this re-exports the standard library module. On 3.8 through
+3.13 it builds the same API on the primitives in :mod:`._backend`.
+"""
+
+import sys
+
+__all__ = [
+    "get_current", "get_main", "create", "list_all", "is_shareable",
+    "Interpreter",
+    "InterpreterError", "InterpreterNotFoundError", "ExecutionFailed",
+    "NotShareableError",
+    "create_queue", "Queue", "QueueEmpty", "QueueFull",
+]
+
+
+if sys.version_info >= (3, 14):
+    # The real thing exists in the standard library.
+    from concurrent.interpreters import (  # noqa: F401
+        get_current, get_main, create, list_all, is_shareable,
+        Interpreter,
+        InterpreterError, InterpreterNotFoundError, ExecutionFailed,
+        NotShareableError,
+        create_queue, Queue, QueueEmpty, QueueFull,
+    )
+
+else:
+    import threading
+    import weakref
+
+    from . import _backend as _interpreters
+
+    InterpreterError = _interpreters.InterpreterError
+    InterpreterNotFoundError = _interpreters.InterpreterNotFoundError
+    NotShareableError = _interpreters.NotShareableError
+    is_shareable = _interpreters.is_shareable
+
+    from ._queues import (
+        create as create_queue,
+        Queue, QueueEmpty, QueueFull,
+    )
+
+    _EXEC_FAILURE_STR = """
+{superstr}
+
+Uncaught in the interpreter:
+
+{formatted}
+""".strip()
+
+    class ExecutionFailed(InterpreterError):
+        """An unhandled exception happened during execution."""
+
+        def __init__(self, excinfo):
+            msg = excinfo.formatted
+            if not msg:
+                if excinfo.type and excinfo.msg:
+                    msg = f'{excinfo.type.__name__}: {excinfo.msg}'
+                else:
+                    msg = excinfo.type.__name__ or excinfo.msg
+            super().__init__(msg)
+            self.excinfo = excinfo
+
+        def __str__(self):
+            try:
+                formatted = self.excinfo.errdisplay
+            except Exception:
+                return super().__str__()
+            else:
+                return _EXEC_FAILURE_STR.format(
+                    superstr=super().__str__(),
+                    formatted=formatted,
+                )
+
+    def create():
+        """Return a new (idle) Python interpreter."""
+        id = _interpreters.create(reqrefs=True)
+        return Interpreter(id, _ownsref=True)
+
+    def list_all():
+        """Return all existing interpreters."""
+        return [Interpreter(id, _whence=whence)
+                for id, whence in _interpreters.list_all(require_ready=True)]
+
+    def get_current():
+        """Return the currently running interpreter."""
+        id, whence = _interpreters.get_current()
+        return Interpreter(id, _whence=whence)
+
+    def get_main():
+        """Return the main interpreter."""
+        id, whence = _interpreters.get_main()
+        assert whence == _interpreters.WHENCE_RUNTIME, repr(whence)
+        return Interpreter(id, _whence=whence)
+
+    _known = weakref.WeakValueDictionary()
+
+    class Interpreter:
+        """A single Python interpreter.
+
+        Interpreters not created by this module cannot be modified, so
+        close(), prepare_main(), exec() and call() will fail on them.
+        """
+
+        _WHENCE_TO_STR = {
+            _interpreters.WHENCE_UNKNOWN: 'unknown',
+            _interpreters.WHENCE_RUNTIME: 'runtime init',
+            _interpreters.WHENCE_LEGACY_CAPI: 'legacy C-API',
+            _interpreters.WHENCE_CAPI: 'C-API',
+            _interpreters.WHENCE_XI: 'cross-interpreter C-API',
+            _interpreters.WHENCE_STDLIB: '_interpreters module',
+        }
+
+        def __new__(cls, id, /, _whence=None, _ownsref=None):
+            # There is only one instance for any given ID.
+            if not isinstance(id, int):
+                raise TypeError(f'id must be an int, got {id!r}')
+            id = int(id)
+            if _whence is None:
+                if _ownsref:
+                    _whence = _interpreters.WHENCE_STDLIB
+                else:
+                    _whence = _interpreters.whence(id)
+            assert _whence in cls._WHENCE_TO_STR, repr(_whence)
+            if _ownsref is None:
+                _ownsref = (_whence == _interpreters.WHENCE_STDLIB)
+            try:
+                self = _known[id]
+                assert hasattr(self, '_ownsref')
+            except KeyError:
+                self = super().__new__(cls)
+                _known[id] = self
+                self._id = id
+                self._whence = _whence
+                self._ownsref = _ownsref
+                if _ownsref:
+                    # May raise InterpreterNotFoundError.
+                    _interpreters.incref(id)
+            return self
+
+        def __repr__(self):
+            return f'{type(self).__name__}({self.id})'
+
+        def __hash__(self):
+            return hash(self._id)
+
+        def __del__(self):
+            self._decref()
+
+        def _decref(self):
+            if not self._ownsref:
+                return
+            self._ownsref = False
+            try:
+                _interpreters.decref(self._id)
+            except InterpreterNotFoundError:
+                pass
+
+        @property
+        def id(self):
+            return self._id
+
+        @property
+        def whence(self):
+            return self._WHENCE_TO_STR[self._whence]
+
+        def is_running(self):
+            """Return whether the interpreter is running."""
+            return _interpreters.is_running(self._id)
+
+        def close(self):
+            """Finalize and destroy the interpreter."""
+            return _interpreters.destroy(self._id, restrict=True)
+
+        def prepare_main(self, ns=None, /, **kwargs):
+            """Bind the given values into the interpreter's __main__."""
+            ns = dict(ns, **kwargs) if ns is not None else kwargs
+            _interpreters.set___main___attrs(self._id, ns, restrict=True)
+
+        def exec(self, code, /):
+            """Run source code in the interpreter, blocking until it finishes.
+
+            Raises ExecutionFailed if the code raises something uncaught.
+            """
+            excinfo = _interpreters.exec(self._id, code, restrict=True)
+            if excinfo is not None:
+                raise ExecutionFailed(excinfo)
+
+        def _call(self, callable, args, kwargs):
+            res, excinfo = _interpreters.call(
+                self._id, callable, args, kwargs, restrict=True)
+            if excinfo is not None:
+                raise ExecutionFailed(excinfo)
+            return res
+
+        def call(self, callable, /, *args, **kwargs):
+            """Call the function in the interpreter and return its result.
+
+            Raises ExecutionFailed if the call raises something uncaught.
+            """
+            return self._call(callable, args, kwargs)
+
+        def call_in_thread(self, callable, /, *args, **kwargs):
+            """Like call(), but run it in a new thread and return the thread."""
+            t = threading.Thread(
+                target=self._call, args=(callable, args, kwargs))
+            t.start()
+            return t

backports/interpreters/_backend.py

@@ -0,0 +1,273 @@
+"""Low level interpreter primitives, normalised across Python versions.
+
+On 3.13 the native ``_interpreters`` module is used directly, apart from
+``call()`` which gains its 3.14 arguments and return value here. On 3.8 through
+3.12 everything is emulated over ``_xxsubinterpreters`` by running a small
+pickle/marshal bootstrap and shipping the result back over a channel.
+"""
+
+import os
+import sys
+import time
+import types
+import pickle
+import marshal
+
+from . import _qbackend
+
+_PY = sys.version_info
+
+WHENCE_UNKNOWN = 0
+WHENCE_RUNTIME = 1
+WHENCE_LEGACY_CAPI = 2
+WHENCE_CAPI = 3
+WHENCE_XI = 4
+WHENCE_STDLIB = 5
+
+
+class _ExcInfo:
+    """Stands in for what _interpreters.capture_exception returns."""
+
+    def __init__(self, formatted, typename, msg):
+        self.formatted = formatted
+        self.errdisplay = formatted
+        self.type = types.SimpleNamespace(__name__=typename)
+        self.msg = msg
+
+
+# Runs in the target interpreter and ships a pickled (ok, ...) tuple back home.
+_RUNNER = """
+import pickle as __xi_pk, traceback as __xi_tb, marshal as __xi_ma, types as __xi_ty
+try:
+    if __xi_mode == 0:
+        exec(compile(__xi_code.decode('utf-8'), '<string>', 'exec'), globals())
+        __xi_res = None
+    else:
+        __xi_fn = __xi_ty.FunctionType(__xi_ma.loads(__xi_code), globals())
+        __xi_a, __xi_k = __xi_pk.loads(__xi_callargs)
+        __xi_res = __xi_fn(*__xi_a, **__xi_k)
+    __xi_ok = True
+except BaseException as __xi_e:
+    __xi_ok = False
+    __xi_err = (__xi_tb.format_exc(), type(__xi_e).__name__, str(__xi_e))
+if __xi_ok:
+    try:
+        __xi_payload = __xi_pk.dumps((True, __xi_res))
+    except BaseException as __xi_e:
+        __xi_payload = __xi_pk.dumps(
+            (False, __xi_tb.format_exc(), type(__xi_e).__name__, str(__xi_e)))
+else:
+    __xi_payload = __xi_pk.dumps((False,) + __xi_err)
+""" + _qbackend.SUBINTERP_SEND
+
+
+def _recv_oneshot(tid, timeout=30.0):
+    deadline = time.time() + timeout
+    while True:
+        try:
+            return _qbackend.get(tid)
+        except _qbackend._Empty:
+            if time.time() >= deadline:
+                raise InterpreterError("timed out waiting for interpreter result")
+            time.sleep(0.0005)
+
+
+def _run_captured(id, *, mode, code, callargs):
+    tid = _qbackend.create()
+    _qbackend.bind(tid)
+    shared = {"__xi_tid": int(tid), "__xi_mode": mode, "__xi_code": code}
+    if callargs is not None:
+        shared["__xi_callargs"] = callargs
+    try:
+        err = _run_string(id, _RUNNER, shared)
+        if err is not None:
+            raise InterpreterError(getattr(err, "formatted", str(err)))
+        payload = _recv_oneshot(tid)
+    finally:
+        _qbackend.destroy(tid)
+    data = pickle.loads(payload)
+    if data[0]:
+        return data[1], None
+    return None, _ExcInfo(data[1], data[2], data[3])
+
+
+def _code_payload(code):
+    if isinstance(code, str):
+        return 0, code.encode("utf-8")
+    if isinstance(code, types.FunctionType):
+        code = code.__code__
+    if isinstance(code, types.CodeType):
+        return 1, marshal.dumps(code)
+    raise TypeError("exec() arg must be a string, function, or code object")
+
+
+_PKG_PARENT = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+
+
+def _bind_main(id, ns):
+    if not ns:
+        return
+    # Put our package on the worker's path so it can unpickle a Queue etc.
+    shared = {"__xi_path": _PKG_PARENT}
+    boot = [
+        "import sys as __xi_sys, pickle as __xi_pk",
+        "__xi_path in __xi_sys.path or __xi_sys.path.insert(0, __xi_path)",
+    ]
+    for i, (key, value) in enumerate(ns.items()):
+        slot = "__xi_b%d" % i
+        try:
+            shared[slot] = pickle.dumps(value)
+        except Exception as exc:
+            raise NotShareableError(key) from exc
+        boot.append("globals()[%r] = __xi_pk.loads(%s); del %s" % (key, slot, slot))
+    boot.append("del __xi_pk, __xi_sys, __xi_path")
+    err = _run_string(id, "\n".join(boot), shared)
+    if err is not None:
+        raise InterpreterError(getattr(err, "formatted", str(err)))
+
+
+if _PY >= (3, 13):
+    import _interpreters as _impl
+
+    InterpreterError = _impl.InterpreterError
+    InterpreterNotFoundError = _impl.InterpreterNotFoundError
+    NotShareableError = _impl.NotShareableError
+    is_shareable = _impl.is_shareable
+
+    create = _impl.create
+    destroy = _impl.destroy
+    list_all = _impl.list_all
+    get_current = _impl.get_current
+    get_main = _impl.get_main
+    is_running = _impl.is_running
+    whence = _impl.whence
+    incref = _impl.incref
+    decref = _impl.decref
+    exec = _impl.exec
+
+    def _run_string(id, src, shared):
+        return _impl.exec(id, src, shared, restrict=False)
+
+    def set___main___attrs(id, ns, *, restrict=False):
+        # Native set___main___attrs only takes shareables, so go through pickle
+        # to also accept plain picklable objects like our Queue.
+        _bind_main(id, dict(ns))
+
+    def call(id, callable, args=None, kwargs=None, *, restrict=False):
+        # Native call() here takes no args and returns nothing, so emulate it.
+        if not isinstance(callable, types.FunctionType):
+            raise TypeError("call() only supports plain functions")
+        payload = marshal.dumps(callable.__code__)
+        callargs = pickle.dumps((tuple(args or ()), dict(kwargs or {})))
+        return _run_captured(id, mode=1, code=payload, callargs=callargs)
+
+
+else:
+    import _xxsubinterpreters as _impl
+
+    class InterpreterError(Exception):
+        """A cross-interpreter operation failed."""
+
+    class InterpreterNotFoundError(InterpreterError):
+        """An interpreter was not found."""
+
+    class NotShareableError(ValueError):
+        """An object cannot be shared between interpreters."""
+
+    is_shareable = _impl.is_shareable
+
+    _refcounts = {}
+    # The id object owns the interpreter, so dropping it destroys the
+    # interpreter. Hold onto it until we are done.
+    _objs = {}
+
+    def _cid(id):
+        return int(id)
+
+    def incref(id, *, implieslink=False):
+        id = _cid(id)
+        _refcounts[id] = _refcounts.get(id, 0) + 1
+
+    def decref(id):
+        id = _cid(id)
+        count = _refcounts.get(id, 0) - 1
+        if count <= 0:
+            _refcounts.pop(id, None)
+            if id in _objs:
+                try:
+                    _impl.destroy(id)
+                except Exception:
+                    pass
+                _objs.pop(id, None)
+        else:
+            _refcounts[id] = count
+
+    def whence(id):
+        id = _cid(id)
+        try:
+            if id == int(_impl.get_main()):
+                return WHENCE_RUNTIME
+        except Exception:
+            pass
+        return WHENCE_STDLIB if id in _objs else WHENCE_UNKNOWN
+
+    def create(config="isolated", *, reqrefs=False):
+        if _PY >= (3, 9):
+            try:
+                obj = _impl.create(isolated=(config != "legacy"))
+            except TypeError:
+                obj = _impl.create()
+        else:
+            obj = _impl.create()
+        id = _cid(obj)
+        _objs[id] = obj
+        return id
+
+    def destroy(id, *, restrict=False):
+        id = _cid(id)
+        try:
+            _impl.destroy(id)
+        except Exception as exc:
+            raise InterpreterNotFoundError(id) from exc
+        _objs.pop(id, None)
+        _refcounts.pop(id, None)
+
+    def list_all(*, require_ready=False):
+        return [(_cid(i), whence(i)) for i in _impl.list_all()]
+
+    def get_current():
+        id = _cid(_impl.get_current())
+        return (id, whence(id))
+
+    def get_main():
+        id = _cid(_impl.get_main())
+        return (id, WHENCE_RUNTIME)
+
+    def is_running(id, *, restrict=False):
+        return _impl.is_running(_cid(id))
+
+    def _run_string(id, src, shared):
+        try:
+            _impl.run_string(_cid(id), src, shared=shared)
+        except _impl.RunFailedError as exc:
+            return _ExcInfo(str(exc), "RunFailedError", str(exc))
+        return None
+
+    def set___main___attrs(id, ns, *, restrict=False):
+        _bind_main(_cid(id), dict(ns))
+
+    def exec(id, code, shared=None, *, restrict=False):
+        if shared:
+            _bind_main(_cid(id), dict(shared))
+        mode, payload = _code_payload(code)
+        callargs = pickle.dumps(((), {})) if mode == 1 else None
+        _res, excinfo = _run_captured(_cid(id), mode=mode, code=payload,
+                                      callargs=callargs)
+        return excinfo
+
+    def call(id, callable, args=None, kwargs=None, *, restrict=False):
+        if not isinstance(callable, types.FunctionType):
+            raise TypeError("call() only supports plain functions")
+        payload = marshal.dumps(callable.__code__)
+        callargs = pickle.dumps((tuple(args or ()), dict(kwargs or {})))
+        return _run_captured(_cid(id), mode=1, code=payload, callargs=callargs)

backports/interpreters/_qbackend.py

@@ -0,0 +1,161 @@
+"""Moves pickled bytes between interpreters.
+
+Backed by the native ``_interpqueues`` on 3.13 and by interpreter channels on
+3.8 through 3.12. Channels cannot report their size, so ``SUPPORTS_COUNT`` is
+False there and the queue size methods are unavailable.
+"""
+
+import sys
+
+_PY = sys.version_info
+
+
+class _Empty(Exception):
+    pass
+
+
+class _NotFound(Exception):
+    pass
+
+
+if _PY >= (3, 13):
+    import _interpqueues as _q
+
+    SUPPORTS_COUNT = True
+
+    # fmt 0 stores our bytes as-is, unboundop 3 replaces unbound items.
+    _FMT = 0
+    _UNBOUNDOP = 3
+
+    QueueError = _q.QueueError
+    QueueNotFoundError = _q.QueueNotFoundError
+
+    # Runs in a target interpreter to send a bytes payload back. Wants
+    # __xi_tid and __xi_payload already in scope.
+    SUBINTERP_SEND = (
+        "import _interpqueues as __xi_t\n"
+        "__xi_t.put(__xi_tid, __xi_payload, 0, 3)\n"
+    )
+
+    def create(maxsize=0):
+        return _q.create(maxsize, _FMT, _UNBOUNDOP)
+
+    def destroy(qid):
+        try:
+            _q.destroy(qid)
+        except QueueNotFoundError:
+            pass
+
+    def bind(qid):
+        _q.bind(qid)
+
+    def release(qid):
+        try:
+            _q.release(qid)
+        except QueueNotFoundError:
+            pass
+
+    def put(qid, data):
+        _q.put(qid, data, _FMT, _UNBOUNDOP)
+
+    def get(qid):
+        if _q.get_count(qid) == 0:
+            raise _Empty
+        obj = _q.get(qid)[0]
+        return obj
+
+    def count(qid):
+        return _q.get_count(qid)
+
+    def is_full(qid):
+        return _q.is_full(qid)
+
+    def maxsize(qid):
+        return _q.get_maxsize(qid)
+
+else:
+    if _PY >= (3, 12):
+        import _xxinterpchannels as _c
+
+        _create = _c.create
+        _send = _c.send
+        _recv = _c.recv
+        _destroy = _c.destroy
+        _Empty_native = _c.ChannelEmptyError
+        _NotFound_native = _c.ChannelNotFoundError
+
+        SUBINTERP_SEND = (
+            "import _xxinterpchannels as __xi_t\n"
+            "__xi_t.send(__xi_tid, __xi_payload)\n"
+        )
+    else:
+        import _xxsubinterpreters as _c
+
+        _create = _c.channel_create
+        _send = _c.channel_send
+        _recv = _c.channel_recv
+        _destroy = _c.channel_destroy
+        _Empty_native = _c.ChannelEmptyError
+        _NotFound_native = _c.ChannelNotFoundError
+
+        SUBINTERP_SEND = (
+            "import _xxsubinterpreters as __xi_t\n"
+            "__xi_t.channel_send(__xi_tid, __xi_payload)\n"
+        )
+
+    SUPPORTS_COUNT = False
+
+    class QueueError(Exception):
+        pass
+
+    class QueueNotFoundError(QueueError):
+        pass
+
+    # The ChannelID owns the channel, so keep it alive like an interpreter id.
+    _chan_objs = {}
+
+    def create(maxsize=0):
+        # Channels are unbounded, so maxsize is ignored here.
+        obj = _create()
+        cid = int(obj)
+        _chan_objs[cid] = obj
+        return cid
+
+    def destroy(qid):
+        try:
+            _destroy(qid)
+        except Exception:
+            pass
+        _chan_objs.pop(int(qid), None)
+
+    def bind(qid):
+        pass
+
+    def release(qid):
+        try:
+            _destroy(qid)
+        except Exception:
+            pass
+        _chan_objs.pop(int(qid), None)
+
+    def put(qid, data):
+        _send(qid, data)
+
+    def get(qid):
+        try:
+            return _recv(qid)
+        except _Empty_native:
+            raise _Empty
+        except _NotFound_native as exc:
+            raise _NotFound from exc
+
+    def count(qid):
+        raise NotImplementedError(
+            "queue size is not available before Python 3.13"
+        )
+
+    def is_full(qid):
+        return False
+
+    def maxsize(qid):
+        return 0

backports/interpreters/_queues.py

@@ -0,0 +1,149 @@
+"""The high level Queue, version-independent.
+
+Objects are pickled to bytes and handed to :mod:`._qbackend` to cross the
+interpreter boundary.
+"""
+
+import time
+import queue
+import pickle
+import weakref
+
+from . import _qbackend
+
+__all__ = [
+    "create", "list_all", "Queue",
+    "QueueError", "QueueNotFoundError", "QueueEmpty", "QueueFull",
+]
+
+
+class QueueError(Exception):
+    pass
+
+
+class QueueNotFoundError(QueueError):
+    pass
+
+
+class QueueEmpty(QueueError, queue.Empty):
+    pass
+
+
+class QueueFull(QueueError, queue.Full):
+    pass
+
+
+def create(maxsize=0):
+    """Return a new cross-interpreter queue."""
+    qid = _qbackend.create(maxsize)
+    return Queue(qid, _maxsize=maxsize)
+
+
+def list_all():
+    listing = getattr(_qbackend, "list_all", None)
+    if listing is None:
+        raise NotImplementedError(
+            "listing queues is not available before Python 3.13"
+        )
+    return [Queue(qid) for qid in listing()]
+
+
+_known_queues = weakref.WeakValueDictionary()
+
+
+class Queue:
+    """A cross-interpreter FIFO queue."""
+
+    def __new__(cls, id, /, _maxsize=0):
+        if not isinstance(id, int):
+            raise TypeError(f"id must be an int, got {id!r}")
+        id = int(id)
+        try:
+            self = _known_queues[id]
+        except KeyError:
+            self = super().__new__(cls)
+            self._id = id
+            self._maxsize = _maxsize
+            _known_queues[id] = self
+            _qbackend.bind(id)
+        return self
+
+    def __del__(self):
+        try:
+            _qbackend.release(self._id)
+        except Exception:
+            pass
+
+    def __repr__(self):
+        return f"{type(self).__name__}({self._id})"
+
+    def __hash__(self):
+        return hash(self._id)
+
+    def __reduce__(self):
+        return (type(self), (self._id,))
+
+    @property
+    def id(self):
+        return self._id
+
+    @property
+    def maxsize(self):
+        return self._maxsize
+
+    def qsize(self):
+        return _qbackend.count(self._id)
+
+    def empty(self):
+        return self.qsize() == 0
+
+    def full(self):
+        if self._maxsize <= 0:
+            return _qbackend.is_full(self._id)
+        return self.qsize() >= self._maxsize
+
+    def put(self, obj, block=True, timeout=None, *, _delay=10 / 1000):
+        data = pickle.dumps(obj)
+        if not block:
+            return self.put_nowait(obj)
+        deadline = None if timeout is None else time.time() + timeout
+        while True:
+            if self._maxsize > 0 and _qbackend.SUPPORTS_COUNT:
+                if _qbackend.count(self._id) >= self._maxsize:
+                    if deadline is not None and time.time() >= deadline:
+                        raise QueueFull
+                    time.sleep(_delay)
+                    continue
+            _qbackend.put(self._id, data)
+            return
+
+    def put_nowait(self, obj):
+        if self._maxsize > 0 and _qbackend.SUPPORTS_COUNT:
+            if _qbackend.count(self._id) >= self._maxsize:
+                raise QueueFull
+        _qbackend.put(self._id, pickle.dumps(obj))
+
+    def get(self, block=True, timeout=None, *, _delay=10 / 1000):
+        if not block:
+            return self.get_nowait()
+        deadline = None if timeout is None else time.time() + timeout
+        while True:
+            try:
+                data = _qbackend.get(self._id)
+            except _qbackend._Empty:
+                if deadline is not None and time.time() >= deadline:
+                    raise QueueEmpty
+                time.sleep(_delay)
+                continue
+            except _qbackend._NotFound as exc:
+                raise QueueNotFoundError(self._id) from exc
+            return pickle.loads(data)
+
+    def get_nowait(self):
+        try:
+            data = _qbackend.get(self._id)
+        except _qbackend._Empty:
+            raise QueueEmpty
+        except _qbackend._NotFound as exc:
+            raise QueueNotFoundError(self._id) from exc
+        return pickle.loads(data)

backports_interpreters-0.3.0.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: backports.interpreters
+Version: 0.3.0
+Summary: Backport of the concurrent.interpreters module described in PEP 734
+Home-page: https://github.com/aisk/backports.interpreters
+Author: An Long
+License: PSF-2.0
+Classifier: License :: OSI Approved :: Python Software Foundation License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.8
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: author
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary

backports_interpreters-0.3.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+backports/interpreters/__init__.py,sha256=FowiJSH4RiFfxScZHV0PCqoO6Idbtaxqy-rueu0365g,7067
+backports/interpreters/_backend.py,sha256=xsDS63Iy6Bn3pl7sDoISO1ALfY41BOnpfUtD7b4q69g,8800
+backports/interpreters/_qbackend.py,sha256=qKoF5Nexf29kzPNnuVYPCAF87TPfhAcLd_k--m0UnnA,3639
+backports/interpreters/_queues.py,sha256=0TmOjAKFa2yUe6v8upQpe_QeTZ8efiO28eQpcE3Bz4o,3938
+backports_interpreters-0.3.0.dist-info/licenses/LICENSE,sha256=UhvnS3nxkXCqd2IJaxOFI43mAD0D4GEeeD46TNF7pE4,3012
+backports_interpreters-0.3.0.dist-info/METADATA,sha256=iDaVP12o2hNGX6UMgu3UA5ywVjMm3RJRmEM1UPhzZhs,926
+backports_interpreters-0.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+backports_interpreters-0.3.0.dist-info/top_level.txt,sha256=cGjaLMOoBR1FK0ApojtzWVmViTtJ7JGIK_HwXiEsvtU,10
+backports_interpreters-0.3.0.dist-info/RECORD,,

backports_interpreters-0.3.0.dist-info/WHEEL

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

backports_interpreters-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,55 @@
+This package is a backport of the CPython standard library module
+concurrent.interpreters and is distributed under the same license as Python
+itself, the Python Software Foundation License Version 2.
+
+Copyright (c) 2020-2026 An Long.
+Copyright © 2001 Python Software Foundation; All Rights Reserved.
+
+Summary of changes from the original Python source: the high level API is
+adapted to run on Python 3.8 through 3.13 by emulating the interpreter
+primitives those versions lack. On 3.14+ the standard library module is used
+directly. See the README and git history for details.
+
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and
+   the Individual or Organization ("Licensee") accessing and otherwise using this
+   software ("Python") in source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+   grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+   analyze, test, perform and/or display publicly, prepare derivative works,
+   distribute, and otherwise use Python alone or in any derivative version,
+   provided, however, that PSF's License Agreement and PSF's notice of copyright,
+   i.e., "Copyright © 2001 Python Software Foundation; All Rights Reserved" are
+   retained in Python alone or in any derivative version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or
+   incorporates Python or any part thereof, and wants to make the derivative work
+   available to others as provided herein, then Licensee hereby agrees to include
+   in any such work a brief summary of the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS" basis. PSF MAKES NO
+   REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT
+   LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF
+   MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON
+   WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY
+   INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING,
+   DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+   ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material breach of
+   its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any relationship
+   of agency, partnership, or joint venture between PSF and Licensee. This License
+   Agreement does not grant permission to use PSF trademarks or trade name in a
+   trademark sense to endorse or promote products or services of Licensee, or any
+   third party.
+
+8. By copying, installing or otherwise using Python, Licensee agrees to be bound
+   by the terms and conditions of this License Agreement.

backports_interpreters-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+backports