b60439152b
- harness/es.py: append-only event store + проекции (образец — кооп-портал) - harness/levels.py: уровни 1с/1м/1ч/1д, контекст ∝ масштабу - harness/scheduler.py: уровневые потоки, идемпотентные тики, absorbed-стабы - harness/isolated_runner.py + _llm_worker.py: LLM-тик в сабпроцессе (глобальный asyncio-рантайм Strands не переживает 2+ create_harness) - cli.py: init/task/tasks/status/events + requeue (написан самим минутным агентом) - 9router: отдельный ключ sk-simbiot, модель auto (glm-5.3 первым)
165 lines
7.3 KiB
Python
165 lines
7.3 KiB
Python
"""Weak reference proxy for functions and bound methods."""
|
|
|
|
import functools
|
|
import weakref
|
|
|
|
from .__wrapt__ import BaseObjectProxy, _FunctionWrapperBase
|
|
|
|
# A weak function proxy. This will work on instance methods, class
|
|
# methods, static methods and regular functions. Special treatment is
|
|
# needed for the method types because the bound method is effectively a
|
|
# transient object and applying a weak reference to one will immediately
|
|
# result in it being destroyed and the weakref callback called. The weak
|
|
# reference is therefore applied to the instance the method is bound to
|
|
# and the original function. The function is then rebound at the point
|
|
# of a call via the weak function proxy.
|
|
#
|
|
# Where the function is a wrapt function wrapper, such as results from
|
|
# applying a decorator, the same applies but there may be no instance,
|
|
# either because the wrapper was never bound, as for a decorated free
|
|
# function, or because the method was accessed via the class rather
|
|
# than an instance. In that case a weak reference to the class the
|
|
# wrapper was accessed through, the owner, is retained as well so that
|
|
# the function can still be rebound correctly at the point of a call.
|
|
|
|
|
|
def _weak_function_proxy_callback(ref, proxy, callback):
|
|
if proxy._self_expired:
|
|
return
|
|
|
|
proxy._self_expired = True
|
|
|
|
# This could raise an exception. We let it propagate back and let
|
|
# the weakref.proxy() deal with it, at which point it generally
|
|
# prints out a short error message direct to stderr and keeps going.
|
|
|
|
if callback is not None:
|
|
callback(proxy)
|
|
|
|
|
|
class WeakFunctionProxy(BaseObjectProxy):
|
|
"""A weak function proxy."""
|
|
|
|
def __init__(self, wrapped, callback=None):
|
|
"""Create a proxy to object which uses a weak reference. This is
|
|
similar to the `weakref.proxy` but is designed to work with functions
|
|
and methods. It will automatically rebind the function to the instance
|
|
when called if the function was originally a bound method. This is
|
|
necessary because bound methods are transient objects and applying a
|
|
weak reference to one will immediately result in it being destroyed
|
|
and the weakref callback called. The weak reference is therefore
|
|
applied to the instance the method is bound to and the original
|
|
function. The function is then rebound at the point of a call via the
|
|
weak function proxy.
|
|
"""
|
|
|
|
# We need to determine if the wrapped function is actually a
|
|
# bound method. In the case of a bound method, we need to keep a
|
|
# reference to the original unbound function and the instance.
|
|
# This is necessary because if we hold a reference to the bound
|
|
# function, it will be the only reference and given it is a
|
|
# temporary object, it will almost immediately expire and
|
|
# the weakref callback triggered. So what is done is that we
|
|
# hold a reference to the instance and unbound function and
|
|
# when called bind the function to the instance once again and
|
|
# then call it. Note that we avoid using a nested function for
|
|
# the callback here so as not to cause any odd reference cycles.
|
|
|
|
_callback = callback and functools.partial(
|
|
_weak_function_proxy_callback, proxy=self, callback=callback
|
|
)
|
|
|
|
self._self_expired = False
|
|
self._self_owner = None
|
|
|
|
if isinstance(wrapped, _FunctionWrapperBase):
|
|
# A function wrapper may have no instance, either because it
|
|
# was never bound, as for a decorated free function, or
|
|
# because the method was accessed via the class rather than
|
|
# an instance. Only take a weak reference to the instance
|
|
# where there is one. The owner is the class the wrapper was
|
|
# accessed through, and is retained so the function can be
|
|
# rebound with it when called. Without it a classmethod
|
|
# accessed via the class could not be rebound at all, and an
|
|
# instance method accessed via the class would not be able
|
|
# to identify an instance passed as the first argument.
|
|
|
|
instance = wrapped._self_instance
|
|
self._self_instance = (
|
|
weakref.ref(instance, _callback) if instance is not None else None
|
|
)
|
|
owner = wrapped._self_owner
|
|
if owner is not None:
|
|
self._self_owner = weakref.ref(owner, _callback)
|
|
|
|
if wrapped._self_parent is not None:
|
|
# Explicit class in super() is used because the proxy
|
|
# overrides __class__ and MRO-related methods to delegate
|
|
# to the wrapped object, which can interfere with bare
|
|
# super().
|
|
super(WeakFunctionProxy, self).__init__(
|
|
weakref.proxy(wrapped._self_parent, _callback)
|
|
)
|
|
|
|
else:
|
|
super(WeakFunctionProxy, self).__init__(
|
|
weakref.proxy(wrapped, _callback)
|
|
)
|
|
|
|
return
|
|
|
|
try:
|
|
self._self_instance = weakref.ref(wrapped.__self__, _callback)
|
|
|
|
super(WeakFunctionProxy, self).__init__(
|
|
weakref.proxy(wrapped.__func__, _callback)
|
|
)
|
|
|
|
except AttributeError:
|
|
self._self_instance = None
|
|
|
|
super(WeakFunctionProxy, self).__init__(weakref.proxy(wrapped, _callback))
|
|
|
|
def __call__(*args, **kwargs):
|
|
def _unpack_self(self, *args):
|
|
return self, args
|
|
|
|
self, args = _unpack_self(*args)
|
|
|
|
# We perform a boolean check here on the instance and wrapped
|
|
# function as that will trigger the reference error prior to
|
|
# calling if the reference had expired.
|
|
|
|
instance = self._self_instance and self._self_instance()
|
|
function = self.__wrapped__ and self.__wrapped__
|
|
|
|
# If the wrapped function was originally a bound method but the
|
|
# instance it was bound to has been garbage collected, raise a
|
|
# ReferenceError rather than silently calling it as unbound.
|
|
|
|
if self._self_instance is not None and instance is None:
|
|
raise ReferenceError("weakly-referenced object no longer exists")
|
|
|
|
# If the wrapped function was a function wrapper for which the
|
|
# owner was retained, rebind the function against the instance,
|
|
# which may be None, and that owner. This is what a classmethod
|
|
# accessed via the class needs to be rebound at all, and what an
|
|
# instance method accessed via the class needs to recognise an
|
|
# instance passed as the first argument. If the owner has been
|
|
# garbage collected, raise a ReferenceError as for the instance.
|
|
|
|
if self._self_owner is not None:
|
|
owner = self._self_owner()
|
|
if owner is None:
|
|
raise ReferenceError("weakly-referenced object no longer exists")
|
|
return function.__get__(instance, owner)(*args, **kwargs)
|
|
|
|
# Otherwise, if the wrapped function was originally a bound
|
|
# function, for which we retained a reference to the instance and
|
|
# the unbound function, we need to rebind the function and then
|
|
# call it. If not just call the wrapped function.
|
|
|
|
if instance is None:
|
|
return self.__wrapped__(*args, **kwargs)
|
|
|
|
return function.__get__(instance, type(instance))(*args, **kwargs)
|