===== src/simpy/events.py lines 1-240 =====
"""
This module contains the basic event types used in SimPy.

The base class for all events is :class:`Event`. Though it can be directly
used, there are several specialized subclasses of it.

.. autosummary::

    ~simpy.events.Event
    ~simpy.events.Timeout
    ~simpy.events.Process
    ~simpy.events.AnyOf
    ~simpy.events.AllOf

"""
from __future__ import annotations
from typing import TYPE_CHECKING, Any, Callable, Dict, Generator, Iterable, Iterator, List, NewType, Optional, Tuple, TypeVar
from simpy.exceptions import Interrupt
if TYPE_CHECKING:
    from types import FrameType
    from simpy.core import Environment, SimTime
PENDING: object = object()
'Unique object to identify pending values of events.'
EventPriority = NewType('EventPriority', int)
URGENT: EventPriority = EventPriority(0)
'Priority of interrupts and process initialization events.'
NORMAL: EventPriority = EventPriority(1)
'Default priority used by events.'

class Event:
    """An event that may happen at some point in time.

    An event

    - may happen (:attr:`triggered` is ``False``),
    - is going to happen (:attr:`triggered` is ``True``) or
    - has happened (:attr:`processed` is ``True``).

    Every event is bound to an environment *env* and is initially not
    triggered. Events are scheduled for processing by the environment after
    they are triggered by either :meth:`succeed`, :meth:`fail` or
    :meth:`trigger`. These methods also set the *ok* flag and the *value* of
    the event.

    An event has a list of :attr:`callbacks`. A callback can be any callable.
    Once an event gets processed, all callbacks will be invoked with the event
    as the single argument. Callbacks can check if the event was successful by
    examining *ok* and do further processing with the *value* it has produced.

    Failed events are never silently ignored and will raise an exception upon
    being processed. If a callback handles an exception, it must set
    :attr:`defused` to ``True`` to prevent this.

    This class also implements ``__and__()`` (``&``) and ``__or__()`` (``|``).
    If you concatenate two events using one of these operators,
    a :class:`Condition` event is generated that lets you wait for both or one
    of them.

    """
    _ok: bool
    _defused: bool
    _value: Any = PENDING

    def __init__(self, env: Environment):
        self.env = env
        'The :class:`~simpy.core.Environment` the event lives in.'
        self.callbacks: EventCallbacks = []
        'List of functions that are called when the event is processed.'

    def __repr__(self) -> str:
        """Return the description of the event (see :meth:`_desc`) with the id
        of the event."""
        return f'<{self._desc()} object at {id(self):#x}>'

    def _desc(self) -> str:
        """Return a string *Event()*."""
        pass

    @property
    def triggered(self) -> bool:
        """Becomes ``True`` if the event has been triggered and its callbacks
        are about to be invoked."""
        pass

    @property
    def processed(self) -> bool:
        """Becomes ``True`` if the event has been processed (e.g., its
        callbacks have been invoked)."""
        pass

    @property
    def ok(self) -> bool:
        """Becomes ``True`` when the event has been triggered successfully.

        A "successful" event is one triggered with :meth:`succeed()`.

        :raises AttributeError: if accessed before the event is triggered.

        """
        pass

    @property
    def defused(self) -> bool:
        """Becomes ``True`` when the failed event's exception is "defused".

        When an event fails (i.e. with :meth:`fail()`), the failed event's
        `value` is an exception that will be re-raised when the
        :class:`~simpy.core.Environment` processes the event (i.e. in
        :meth:`~simpy.core.Environment.step()`).

        It is also possible for the failed event's exception to be defused by
        setting :attr:`defused` to ``True`` from an event callback. Doing so
        prevents the event's exception from being re-raised when the event is
        processed by the :class:`~simpy.core.Environment`.

        """
        pass

    @property
    def value(self) -> Optional[Any]:
        """The value of the event if it is available.

        The value is available when the event has been triggered.

        Raises :exc:`AttributeError` if the value is not yet available.

        """
        pass

    def trigger(self, event: Event) -> None:
        """Trigger the event with the state and value of the provided *event*.
        Return *self* (this event instance).

        This method can be used directly as a callback function to trigger
        chain reactions.

        """
        pass

    def succeed(self, value: Optional[Any]=None) -> Event:
        """Set the event's value, mark it as successful and schedule it for
        processing by the environment. Returns the event instance.

        Raises :exc:`RuntimeError` if this event has already been triggerd.

        """
        pass

    def fail(self, exception: Exception) -> Event:
        """Set *exception* as the events value, mark it as failed and schedule
        it for processing by the environment. Returns the event instance.

        Raises :exc:`TypeError` if *exception* is not an :exc:`Exception`.

        Raises :exc:`RuntimeError` if this event has already been triggered.

        """
        pass

    def __and__(self, other: Event) -> Condition:
        """Return a :class:`~simpy.events.Condition` that will be triggered if
        both, this event and *other*, have been processed."""
        return Condition(self.env, Condition.all_events, [self, other])

    def __or__(self, other: Event) -> Condition:
        """Return a :class:`~simpy.events.Condition` that will be triggered if
        either this event or *other* have been processed (or even both, if they
        happened concurrently)."""
        return Condition(self.env, Condition.any_events, [self, other])
EventType = TypeVar('EventType', bound=Event)
EventCallback = Callable[[EventType], None]
EventCallbacks = List[EventCallback]

class Timeout(Event):
    """A :class:`~simpy.events.Event` that gets processed after a *delay* has
    passed.

    This event is automatically triggered when it is created.


    """

    def __init__(self, env: Environment, delay: SimTime, value: Optional[Any]=None):
        if delay < 0:
            raise ValueError(f'Negative delay {delay}')
        self.env = env
        self.callbacks: EventCallbacks = []
        self._value = value
        self._delay = delay
        self._ok = True
        env.schedule(self, NORMAL, delay)

    def _desc(self) -> str:
        """Return a string *Timeout(delay[, value=value])*."""
        pass

class Initialize(Event):
    """Initializes a process. Only used internally by :class:`Process`.

    This event is automatically triggered when it is created.

    """

    def __init__(self, env: Environment, process: Process):
        self.env = env
        self.callbacks: EventCallbacks = [process._resume]
        self._value: Any = None
        self._ok = True
        env.schedule(self, URGENT)

class Interruption(Event):
    """Immediately schedules an :class:`~simpy.exceptions.Interrupt` exception
    with the given *cause* to be thrown into *process*.

    This event is automatically triggered when it is created.

    """

    def __init__(self, process: Process, cause: Optional[Any]):
        self.env = process.env
        self.callbacks: EventCallbacks = [self._interrupt]
        self._value = Interrupt(cause)
        self._ok = False
        self._defused = True
        if process._value is not PENDING:
            raise RuntimeError(f'{process} has terminated and cannot be interrupted.')
        if process is self.env.active_process:
            raise RuntimeError('A process is not allowed to interrupt itself.')
        self.process = process
        self.env.schedule(self, URGENT)
ProcessGenerator = Generator[Event, Any, Any]

class Process(Event):
    """Process an event yielding generator.

    A generator (also known as a coroutine) can suspend its execution by
    yielding an event. ``Process`` will take care of resuming the generator
    with the value of that event once it has happened. The exception of failed
    events is thrown into the generator.

===== src/simpy/events.py lines 241-520 =====
    ``Process`` itself is an event, too. It is triggered, once the generator
    returns or raises an exception. The value of the process is the return
    value of the generator or the exception, respectively.

    Processes can be interrupted during their execution by :meth:`interrupt`.

    """

    def __init__(self, env: Environment, generator: ProcessGenerator):
        if not hasattr(generator, 'throw'):
            raise ValueError(f'{generator} is not a generator.')
        self.env = env
        self.callbacks: EventCallbacks = []
        self._generator = generator
        self._target: Event = Initialize(env, self)

    def _desc(self) -> str:
        """Return a string *Process(process_func_name)*."""
        pass

    @property
    def target(self) -> Event:
        """The event that the process is currently waiting for.

        Returns ``None`` if the process is dead, or it is currently being
        interrupted.

        """
        pass

    @property
    def name(self) -> str:
        """Name of the function used to start the process."""
        pass

    @property
    def is_alive(self) -> bool:
        """``True`` until the process generator exits."""
        pass

    def interrupt(self, cause: Optional[Any]=None) -> None:
        """Interrupt this process optionally providing a *cause*.

        A process cannot be interrupted if it already terminated. A process can
        also not interrupt itself. Raise a :exc:`RuntimeError` in these
        cases.

        """
        pass

    def _resume(self, event: Event) -> None:
        """Resumes the execution of the process with the value of *event*. If
        the process generator exits, the process itself will get triggered with
        the return value or the exception of the generator."""
        pass

class ConditionValue:
    """Result of a :class:`~simpy.events.Condition`. It supports convenient
    dict-like access to the triggered events and their values. The events are
    ordered by their occurrences in the condition."""

    def __init__(self) -> None:
        self.events: List[Event] = []

    def __getitem__(self, key: Event) -> Any:
        if key not in self.events:
            raise KeyError(str(key))
        return key._value

    def __contains__(self, key: Event) -> bool:
        return key in self.events

    def __eq__(self, other: object) -> bool:
        if isinstance(other, ConditionValue):
            return self.events == other.events
        elif isinstance(other, dict):
            return self.todict() == other
        else:
            return NotImplemented

    def __repr__(self) -> str:
        return f'<ConditionValue {self.todict()}>'

    def __iter__(self) -> Iterator[Event]:
        return self.keys()

class Condition(Event):
    """An event that gets triggered once the condition function *evaluate*
    returns ``True`` on the given list of *events*.

    The value of the condition event is an instance of :class:`ConditionValue`
    which allows convenient access to the input events and their values. The
    :class:`ConditionValue` will only contain entries for those events that
    occurred before the condition is processed.

    If one of the events fails, the condition also fails and forwards the
    exception of the failing event.

    The *evaluate* function receives the list of target events and the number
    of processed events in this list: ``evaluate(events, processed_count)``. If
    it returns ``True``, the condition is triggered. The
    :func:`Condition.all_events()` and :func:`Condition.any_events()` functions
    are used to implement *and* (``&``) and *or* (``|``) for events.

    Condition events can be nested.

    """

    def __init__(self, env: Environment, evaluate: Callable[[Tuple[Event, ...], int], bool], events: Iterable[Event]):
        super().__init__(env)
        self._evaluate = evaluate
        self._events = tuple(events)
        self._count = 0
        if not self._events:
            self.succeed(ConditionValue())
            return
        for event in self._events:
            if self.env != event.env:
                raise ValueError('It is not allowed to mix events from different environments')
        for event in self._events:
            if event.callbacks is None:
                self._check(event)
            else:
                event.callbacks.append(self._check)
        assert isinstance(self.callbacks, list)
        self.callbacks.append(self._build_value)

    def _desc(self) -> str:
        """Return a string *Condition(evaluate, [events])*."""
        pass

    def _populate_value(self, value: ConditionValue) -> None:
        """Populate the *value* by recursively visiting all nested
        conditions."""
        pass

    def _build_value(self, event: Event) -> None:
        """Build the value of this condition."""
        pass

    def _remove_check_callbacks(self) -> None:
        """Remove _check() callbacks from events recursively.

        Once the condition has triggered, the condition's events no longer need
        to have _check() callbacks. Removing the _check() callbacks is
        important to break circular references between the condition and
        untriggered events.

        """
        pass

    def _check(self, event: Event) -> None:
        """Check if the condition was already met and schedule the *event* if
        so."""
        pass

    @staticmethod
    def all_events(events: Tuple[Event, ...], count: int) -> bool:
        """An evaluation function that returns ``True`` if all *events* have
        been triggered."""
        pass

    @staticmethod
    def any_events(events: Tuple[Event, ...], count: int) -> bool:
        """An evaluation function that returns ``True`` if at least one of
        *events* has been triggered."""
        pass

class AllOf(Condition):
    """A :class:`~simpy.events.Condition` event that is triggered if all of
    a list of *events* have been successfully triggered. Fails immediately if
    any of *events* failed.

    """

    def __init__(self, env: Environment, events: Iterable[Event]):
        super().__init__(env, Condition.all_events, events)

class AnyOf(Condition):
    """A :class:`~simpy.events.Condition` event that is triggered if any of
    a list of *events* has been successfully triggered. Fails immediately if
    any of *events* failed.

    """

    def __init__(self, env: Environment, events: Iterable[Event]):
      <response clipped><NOTE>Due to the max output limit, only part of the full response has been shown to you.</NOTE>ource users can be preempted by requests with a higher priority.

"""
from __future__ import annotations
from typing import TYPE_CHECKING, Any, List, Optional, Type
from simpy.core import BoundClass, Environment, SimTime
from simpy.resources import base
if TYPE_CHECKING:
    from types import TracebackType
    from simpy.events import Process

class Preempted:
    """Cause of a preemption :class:`~simpy.exceptions.Interrupt` containing
    information about the preemption.

    """

    def __init__(self, by: Optional[Process], usage_since: Optional[SimTime], resource: Resource):
        self.by = by
        'The preempting :class:`simpy.events.Process`.'
        self.usage_since = usage_since
        'The simulation time at which the preempted process started to use\n        the resource.'
        self.resource = resource
        'The resource which was lost, i.e., caused the preemption.'

class Request(base.Put):
    """Request usage of the *resource*. The event is triggered once access is
    granted. Subclass of :class:`simpy.resources.base.Put`.

    If the maximum capacity of users has not yet been reached, the request is
    triggered immediately. If the maximum capacity has been
    reached, the request is triggered once an earlier usage request on the
    resource is released.

    The request is automatically released when the request was created within
    a :keyword:`with` statement.

    """
    resource: Resource
    usage_since: Optional[SimTime] = None

    def __exit__(self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], traceback: Optional[TracebackType]) -> Optional[bool]:
        super().__exit__(exc_type, exc_value, traceback)
        if exc_type is not GeneratorExit:
            self.resource.release(self)
        return None

class Release(base.Get):
    """Releases the usage of *resource* granted by *request*. This event is
    triggered immediately. Subclass of :class:`simpy.resources.base.Get`.

    """

    def __init__(self, resource: Resource, request: Request):
        self.request = request
        'The request (:class:`Request`) that is to be released.'
        super().__init__(resource)

class PriorityRequest(Request):
    """Request the usage of *resource* with a given *priority*. If the
    *resource* supports preemption and *preempt* is ``True`` other usage
    requests of the *resource* may be preempted (see
    :class:`PreemptiveResource` for details).

    This event type inherits :class:`Request` and adds some additional
    attributes needed by :class:`PriorityResource` and
    :class:`PreemptiveResource`

    """

    def __init__(self, resource: Resource, priority: int=0, preempt: bool=True):
        self.priority = priority
        'The priority of this request. A smaller number means higher\n        priority.'
        self.preempt = preempt
        'Indicates whether the request should preempt a resource user or not\n        (:class:`PriorityResource` ignores this flag).'
        self.time = resource._env.now
        'The time at which the request was made.'
        self.key = (self.priority, self.time, not self.preempt)
        'Key for sorting events. Consists of the priority (lower value is\n        more important), the time at which the request was made (earlier\n        requests are more important) and finally the preemption flag (preempt\n        requests are more important).'
        super().__init__(resource)

class SortedQueue(list):
    """Queue for sorting events by their :attr:`~PriorityRequest.key`
    attribute.

    """

    def __init__(self, maxlen: Optional[int]=None):
        super().__init__()
        self.maxlen = maxlen
        'Maximum length of the queue.'

    def append(self, item: Any) -> None:
        """Sort *item* into the queue.

        Raise a :exc:`RuntimeError` if the queue is full.

        """
        pass

class Resource(base.BaseResource):
    """Resource with *capacity* of usage slots that can be requested by
    processes.

    If all slots are taken, requests are enqueued. Once a usage request is
    released, a pending request will be triggered.

    The *env* parameter is the :class:`~simpy.core.Environment` instance the
    resource is bound to.

    """

    def __init__(self, env: Environment, capacity: int=1):
        if capacity <= 0:
            raise ValueError('"capacity" must be > 0.')
        super().__init__(env, capacity)
        self.users: List[Request] = []
        'List of :class:`Request` events for the processes that are currently\n        using the resource.'
        self.queue = self.put_queue
        'Queue of pending :class:`Request` events. Alias of\n        :attr:`~simpy.resources.base.BaseResource.put_queue`.\n        '

    @property
    def count(self) -> int:
        """Number of users currently using the resource."""
        pass
    if TYPE_CHECKING:

        def request(self) -> Request:
            """Request a usage slot."""
            pass

        def release(self, request: Request) -> Release:
            """Release a usage slot."""
            pass
    else:
        request = BoundClass(Request)
        release = BoundClass(Release)

class PriorityResource(Resource):
    """A :class:`~simpy.resources.resource.Resource` supporting prioritized
    requests.

    Pending requests in the :attr:`~Resource.queue` are sorted in ascending
    order by their *priority* (that means lower values are more important).

    """
    PutQueue = SortedQueue
    'Type of the put queue. See\n    :attr:`~simpy.resources.base.BaseResource.put_queue` for details.'
    GetQueue = list
    'Type of the get queue. See\n    :attr:`~simpy.resources.base.BaseResource.get_queue` for details.'

    def __init__(self, env: Environment, capacity: int=1):
        super().__init__(env, capacity)
    if TYPE_CHECKING:

        def request(self, priority: int=0, preempt: bool=True) -> PriorityRequest:
            """Request a usage slot with the given *priority*."""
            pass

        def release(self, request: PriorityRequest) -> Release:
            """Release a usage slot."""
            pass
    else:
        request = BoundClass(PriorityRequest)
        release = BoundClass(Release)

class PreemptiveResource(PriorityResource):
    """A :class:`~simpy.resources.resource.PriorityResource` with preemption.

    If a request is preempted, the process of that request will receive an
    :class:`~simpy.exceptions.Interrupt` with a :class:`Preempted` instance as
    cause.

    """
    users: List[PriorityRequest]===== src/simpy/resources/resource.py lines 241-520 =====
===== src/simpy/resources/container.py lines 1-240 =====
"""
Resource for sharing homogeneous matter between processes, either continuous
(like water) or discrete (like apples).

A :class:`Container` can be used to model the fuel tank of a gasoline station.
Tankers increase and refuelled cars decrease the amount of gas in the station's
fuel tanks.

"""
from __future__ import annotations
from typing import TYPE_CHECKING, Optional, Union
from simpy.core import BoundClass, Environment
from simpy.resources import base
ContainerAmount = Union[int, float]

class ContainerPut(base.Put):
    """Request to put *amount* of matter into the *container*. The request will
    be triggered once there is enough space in the *container* available.

    Raise a :exc:`ValueError` if ``amount <= 0``.

    """

    def __init__(self, container: Container, amount: ContainerAmount):
        if amount <= 0:
            raise ValueError(f'amount(={amount}) must be > 0.')
        self.amount = amount
        'The amount of matter to be put into the container.'
        super().__init__(container)

class ContainerGet(base.Get):
    """Request to get *amount* of matter from the *container*. The request will
    be triggered once there is enough matter available in the *container*.

    Raise a :exc:`ValueError` if ``amount <= 0``.

    """

    def __init__(self, container: Container, amount: ContainerAmount):
        if amount <= 0:
            raise ValueError(f'amount(={amount}) must be > 0.')
        self.amount = amount
        'The amount of matter to be taken out of the container.'
        super().__init__(container)

class Container(base.BaseResource):
    """Resource containing up to *capacity* of matter which may either be
    continuous (like water) or discrete (like apples). It supports requests to
    put or get matter into/from the container.

    The *env* parameter is the :class:`~simpy.core.Environment` instance the
    container is bound to.

    The *capacity* defines the size of the container. By default, a container
    is of unlimited size. The initial amount of matter is specified by *init*
    and defaults to ``0``.

    Raise a :exc:`ValueError` if ``capacity <= 0``, ``init < 0`` or
    ``init > capacity``.

    """

    def __init__(self, env: Environment, capacity: ContainerAmount=float('inf'), init: ContainerAmount=0):
        if capacity <= 0:
            raise ValueError('"capacity" must be > 0.')
        if init < 0:
            raise ValueError('"init" must be >= 0.')
        if init > capacity:
            raise ValueError('"init" must be <= "capacity".')
        super().__init__(env, capacity)
        self._level = init

    @property
    def level(self) -> ContainerAmount:
        """The current amount of the matter in the container."""
        pass
    if TYPE_CHECKING:

        def put(self, amount: ContainerAmount) -> ContainerPut:
            """Request to put *amount* of matter into the container."""
            pass

        def get(self, amount: ContainerAmount) -> ContainerGet:
            """Request to get *amount* of matter out of the container."""
            pass
    else:
        put = BoundClass(ContainerPut)
        get = BoundClass(ContainerGet)===== src/simpy/resources/container.py lines 241-520 =====
===== src/simpy/resources/store.py lines 1-240 =====
"""
Shared resources for storing a possibly unlimited amount of objects supporting
requests for specific objects.

The :class:`Store` operates in a FIFO (first-in, first-out) order. Objects are
retrieved from the store in the order they were put in. The *get* requests of a
:class:`FilterStore` can be customized by a filter to only retrieve objects
matching a given criterion.

"""
from __future__ import annotations
from heapq import heappop, heappush
from typing import TYPE_CHECKING, Any, Callable, List, NamedTuple, Optional, Union
from simpy.core import BoundClass, Environment
from simpy.resources import base

class StorePut(base.Put):
    """Request to put *item* into the *store*. The request is triggered once
    there is space for the item in the store.

    """

    def __init__(self, store: Store, item: Any):
        self.item = item
        'The item to put into the store.'
        super().__init__(store)

class StoreGet(base.Get):
    """Request to get an *item* from the *store*. The request is triggered
    once there is an item available in the store.

    """

class FilterStoreGet(StoreGet):
    """Request to get an *item* from the *store* matching the *filter*. The
    request is triggered once there is such an item available in the store.

    *filter* is a function receiving one item. It should return ``True`` for
    items matching the filter criterion. The default function returns ``True``
    for all items, which makes the request to behave exactly like
    :class:`StoreGet`.

    """

    def __init__(self, resource: FilterStore, filter: Callable[[Any], bool]=lambda item: True):
        self.filter = filter
        'The filter function to filter items in the store.'
        super().__init__(resource)

class Store(base.BaseResource):
    """Resource with *capacity* slots for storing arbitrary objects. By
    default, the *capacity* is unlimited and objects are put and retrieved from
    the store in a first-in first-out order.

    The *env* parameter is the :class:`~simpy.core.Environment` instance the
    container is bound to.

    """

    def __init__(self, env: Environment, capacity: Union[float, int]=float('inf')):
        if capacity <= 0:
            raise ValueError('"capacity" must be > 0.')
        super().__init__(env, capacity)
        self.items: List[Any] = []
        'List of the items available in the store.'
    if TYPE_CHECKING:

        def put(self, item: Any) -> StorePut:
            """Request to put *item* into the store."""
            pass

        def get(self) -> StoreGet:
            """Request to get an *item* out of the store."""
            pass
    else:
        put = BoundClass(StorePut)
        get = BoundClass(StoreGet)

class PriorityItem(NamedTuple):
    """Wrap an arbitrary *item* with an order-able *priority*.

    Pairs a *priority* with an arbitrary *item*. Comparisons of *PriorityItem*
    instances only consider the *priority* attribute, thus supporting use of
    unorderable items in a :class:`PriorityStore` instance.

    """
    priority: Any
    item: Any

    def __lt__(self, other: PriorityItem) -> bool:
        return self.priority < other.priority

class PriorityStore(Store):
    """Resource with *capacity* slots for storing objects in priority order.

    Unlike :class:`Store` which provides first-in first-out discipline,
    :class:`PriorityStore` maintains items in sorted order such that
    the smallest items value are retrieved first from the store.

    All items in a *PriorityStore* instance must be order-able; which is to say
    that items must implement :meth:`~object.__lt__()`. To use unorderable
    items with *PriorityStore*, use :class:`PriorityItem`.

    """

class FilterStore(Store):
    """Resource with *capacity* slots for storing arbitrary objects supporting
    filtered get requests. Like the :class:`Store`, the *capacity* is unlimited
    by default and objects are put and retrieved from the store in a first-in
    first-out order.

    Get requests can be customized with a filter function to only trigger for
    items for which said filter function returns ``True``.

    .. note::

        In contrast to :class:`Store`, get requests of a :class:`FilterStore`
        won't necessarily be triggered in the same order they were issued.

        *Example:* The store is empty. *Process 1* tries to get an item of type
        *a*, *Process 2* an item of type *b*. Another process puts one item of
        type *b* into the store. Though *Process 2* made his request after
        *Process 1*, it will receive that new item because *Process 1* doesn't
        want it.

    """
    if TYPE_CHECKING:

        def get(self, filter: Callable[[Any], bool]=lambda item: True) -> FilterStoreGet:
            """Request to get an *item*, for which *filter* returns ``True``,
            out of the store."""
            pass
    else:
        get = BoundClass(FilterStoreGet)===== src/simpy/resources/store.py lines 241-520 =====
[The command completed with exit code 0.]
[Current working directory: /workspace/simpy]
[Python interpreter: /usr/bin/python]
[Command finished with exit code 0]