Resource

__init__(ref, acquire) -> None

def __init__(self, ref: ScopedRef[Exit[A, E]], acquire: Effect[A, E]) -> None:
    self._ref = ref
    self._acquire = acquire

manual(acquire) -> Effect[Resource[T, X], Never, Scope | R]

@staticmethod
def manual[T, X = Never, R = Never](
    acquire: Effect[T, X, R],
) -> Effect[Resource[T, X], Never, Scope | R]:
    """A resource acquired now (with the services in scope now) and
    again on each ``refresh``."""
    require_effect(acquire, "acquire")

    def body(fiber: Fiber[Any, Any]) -> Effect[Resource[T, X], Never, Scope]:
        captured = fiber._context
        provided: Effect[T, X] = _Locally(acquire, captured.merge)
        return ScopedRef.from_acquire(provided.exit()).map(lambda ref: Resource(ref, provided))

    return _WithFiber(body)

auto(acquire, policy) -> Effect[Resource[T, X], Never, Scope | RR]

@staticmethod
def auto[T, X = Never, RR = Never](
    acquire: Effect[T, X, RR], policy: Schedule[object, object, object, RR]
) -> Effect[Resource[T, X], Never, Scope | RR]:
    """``manual``, refreshed each time ``policy`` recurs (first after its
    first delay) until the current scope closes. Failed refreshes are
    ignored."""
    require_effect(acquire, "acquire")
    return Resource.manual(acquire).tap(
        lambda resource: resource.refresh().ignore_cause().schedule(policy).fork_scoped()
    )

get() -> Effect[A, E]

def get(self) -> Effect[A, E]:
    """The cached value, or the cached failure."""
    return self._ref.get().flat_map(_FromExit)

refresh() -> Effect[None, E]

def refresh(self) -> Effect[None, E]:
    """Acquire anew and swap the value in. A failure keeps the cached
    value."""
    return self._ref.set(self._acquire.map(Success))