API Reference¶

def get(self,get_event):
    """
    Retrieve an item from the store after a successful reservation.

    This method attempts to retrieve an item associated with a `reserve_get`
    event. If the reservation exists, it triggers `_trigger_get` to retrieve
    the item. If successful, `_trigger_reserve_put` is called to process any
    pending `reserve_put` requests. If the item retrieval fails, an error
    message is raised.

    Args:
        get_event (simpy.Event): The reservation event associated with the request.

    Returns:
        item (Object): The retrieved item if successful, otherwise raises an error

    Raises:
        RuntimeError: If no reservations are available in the reservations_get
        RuntimeError: If item returned is None
    """

    item = None
    #if there are reservations, then call _trigger_get
    if self.reservations_get:
      item= self._trigger_get(get_event)
    #else raise an error
    else:
      raise RuntimeError("No matching reservation found for process: reservations_get is empty")
    #if an item is returned then call _trigger_reserve_put to process pending requests
    if item is not None:
      self._trigger_reserve_put(None)

    if item is None:
      raise RuntimeError(f"No item found in the store for {get_event.requesting_process} and get request failed")
    else:
      #self._update_time_averaged_level()
      return item

def handle_new_item_during_interruption(self, item):
    """
    Handle new item added during STALLED_ACCUMULATING_STATE with accumulation=1.

    Computes delay using same logic as for existing items.
    """


    # Build the updated belt pattern with new item
    current_pattern = self._get_belt_pattern()
    print(f"T={self.env.now:.2f} Current belt pattern after adding new item: {current_pattern[0]} and items {current_pattern[1]}")
    updated_pattern = list(current_pattern[0])




    # Recompute item positions
    item_positions = [i for i, c in enumerate(updated_pattern) if c == '*']
    print("item_positions with new item", item_positions)
    # Get interruption plan
    interruption_plan = self._calculate_gap_based_interruptions(''.join(updated_pattern), item_positions, current_pattern[1])
    print(f"T={self.env.now:.2f} Interruption plan with new item: {interruption_plan}")
    # The new item is the last one added in pattern
    delay_for_new_item = interruption_plan[0]['delay']

    item_id = item[0].id if hasattr(item[0], 'id') else str(id(item))
    item_id = item[0].id if hasattr(item[0], 'id') else str(id(item))
    item_length = item[0].length if hasattr(item[0], 'length') else 1.0
    delay_for_new_item = delay_for_new_item * (item_length / self.speed)
    if delay_for_new_item > 0:
        print(f"T={self.env.now:.2f} New item {item_id} will be interrupted after {delay_for_new_item} time units")
        interrupt_process= self.env.process(self._delayed_interrupt(item_id, delay_for_new_item, "New item during interruption"))
        item_id = item[0].id if hasattr(item[0], 'id') else str(id(item))
        self.active_delayed_interrupt_processes[item_id] = interrupt_process
    else:
        print(f"T={self.env.now:.2f} New item {item_id} {interruption_plan[0]['item_index']} {interruption_plan[-1]['delay']} interrupted immediately")
        self._interrupt_specific_item(item_id, "New item during interruption")

def interrupt_all_move_processes(self, reason="External interrupt"):
    """
    Interrupt all active move_to_ready_items processes.

    Args:
        reason (str): Reason for the interrupt
    """
    print(f"T={self.env.now:.2f} Belt_Store interrupting {len(self.active_move_processes)} move processes - {reason}")

    for item_id, process_info in self.active_move_processes.items():
        process = process_info['process']
        if process and not process.processed:
            try:
                process.interrupt(reason)
                print(f"T={self.env.now:.2f} Interrupted move process for item {item_id}")
            except RuntimeError:
                # Process might already be finished
                pass

def interrupt_and_resume_all_delayed_interrupt_processes(self, reason="State change interrupt"):
    """
    Interrupt all active delayed interrupt processes and clear them.

    Args:
        reason (str): Reason for the interrupt
    """
    print(f"T={self.env.now:.2f} Belt_Store interrupting {len(self.active_delayed_interrupt_processes)} delayed interrupt processes - {reason}")

    for item_id, process in list(self.active_delayed_interrupt_processes.items()):
        if process and not process.processed:
            try:
                process.interrupt(reason)
                print(f"T={self.env.now:.2f} Interrupted delayed interrupt process for item {item_id}")
            except RuntimeError:
                # Process might already be finished
                pass
        # Remove from tracking regardless
        self.active_delayed_interrupt_processes.pop(item_id, None)

def move_to_ready_items(self, item):
    """
    Move items from the store to the ready_items list after a put operation.
    This method is called as a process to ensure that items are moved asynchronously.
    Handles interrupts when state changes to stalled and resumes when state changes back.
    Movement is split into two phases:
    1. First phase: item[0].length/self.speed time (time for item to fully enter belt)
    2. Second phase: remaining time (time for item to reach exit)
    """
    item_id = item[0].id if hasattr(item[0], 'id') else str(id(item))
    event=self.env.event()
    total_interruption_time=0
    #self.delay=item[0].length/self.speed
    #print(f"created Added event suceeded{self.delay}")
    event.callbacks.append(self._trigger_reserve_put)# after putting an item, an event is created and will be triggered ater delay amount of time to allow waiting get calls to succeed in a stalled belt
    #event.callbacks.append(self._trigger_put)# this may not be needed

    #print(f"{self.env.now}Added event suceed        ed")

    # Calculate the two phases of movement
    phase1_time = item[0].length / self.speed  # Time for item to fully enter belt
    phase2_time = item[1] - phase1_time        # Remaining time to reach exit
    item[0].total_interruption_time= total_interruption_time
    item[0].interruption_start_time=None
    try:
        # Move items to the ready_items list
        if self.items:
            print(f"T={self.env.now:.2f} beltstore received an item {item[0].id, item[1]} . Item started moving in belt")

            # Phase 1: Item entering the belt (length/speed time)
            remaining_phase1_time = phase1_time
            print(f"T={self.env.now:.2f} Item {item_id} starting Phase 1 (entering belt): {phase1_time:.2f} time")

            while remaining_phase1_time > 0:
                try:
                    start_time = self.env.now
                    yield self.env.timeout(remaining_phase1_time)
                    # If we reach here, phase 1 completed without interruption
                    event.succeed()
                    remaining_phase1_time = 0
                    break
                except simpy.Interrupt as interrupt:
                    # Calculate how much time has passed
                    interruption_start_time_phase1 = self.env.now
                    item[0].interruption_start_time= interruption_start_time_phase1
                    print(f"{self.env.now} for item {item_id} Phase 1 started interruption at {interruption_start_time_phase1}")
                    elapsed_time = self.env.now - start_time
                    remaining_phase1_time -= elapsed_time

                    print(f"T={self.env.now:.2f} Move process Phase 1 for item {item_id} interrupted: {interrupt.cause}")
                    print(f"T={self.env.now:.2f} Remaining Phase 1 time for item {item_id}: {remaining_phase1_time:.2f}")

                    # Wait for resume signal
                    print(f"T={self.env.now:.2f} Item {item_id} waiting for resume signal with {remaining_phase1_time:.2f} time left to complete(Phase 1)...")
                    yield self.resume_event
                    total_interruption_time += self.env.now - interruption_start_time_phase1
                    item[0].interruption_start_time=None
                    item[0].total_interruption_time= total_interruption_time
                    print(f"T={self.env.now:.2f} Item {item_id} resuming Phase 1 movement with {remaining_phase1_time:.2f} time remaining")

            print(f"T={self.env.now:.2f} Item {item_id} completed Phase 1 (fully entered belt)")

            # Phase 2: Item moving through the belt to exit
            remaining_phase2_time = phase2_time
            print(f"T={self.env.now:.2f} Item {item_id} starting Phase 2 (moving to exit): {phase2_time:.2f} time")

            while remaining_phase2_time > 0:
                try:
                    start_time = self.env.now
                    yield self.env.timeout(remaining_phase2_time)
                    # If we reach here, phase 2 completed without interruption
                    remaining_phase2_time = 0
                    break
                except simpy.Interrupt as interrupt:
                    # Calculate how much time has passed
                    interruption_start_time_phase2 = self.env.now
                    item[0].interruption_start_time= interruption_start_time_phase2
                    print(f"{self.env.now} for item {item_id} Phase 2 started interruption at {interruption_start_time_phase2}")
                    elapsed_time = self.env.now - start_time
                    remaining_phase2_time -= elapsed_time

                    print(f"T={self.env.now:.2f} Move process Phase 2 for item {item_id} interrupted: {interrupt.cause}")
                    print(f"T={self.env.now:.2f} Remaining Phase 2 time for item {item_id}: {remaining_phase2_time:.2f}")

                    # Wait for resume signal
                    print(f"T={self.env.now:.2f} Item {item_id} waiting for resume signal (Phase 2) time left- {remaining_phase2_time:.2f}...")
                    yield self.resume_event
                    item[0].interruption_start_time = None
                    total_interruption_time += self.env.now - interruption_start_time_phase2
                    item[0].total_interruption_time= total_interruption_time
                    print(f"T={self.env.now:.2f} Item {item_id} resuming Phase 2 movement with {remaining_phase2_time:.2f} time remaining")

            print(f"T={self.env.now:.2f} Item {item_id} completed Phase 2 (reached exit)")
            #print(f"T={self.env.now:.2f} bufferstore finished moving item {item[0].id, item[1]} going to ready_items")

            item_index = self.items.index(item)
            item_to_put = self.items.pop(item_index)  # Remove the item

            if len(self.ready_items) + len(self.items) < self.capacity:
                self.ready_items.append(item_to_put[0])
                item_to_put[0].conveyor_ready_item_entry_time = self.env.now
                print("Total items on belt",len(self.ready_items)+len(self.items))

                if not self.ready_item_event.triggered:
                    self.ready_item_event.succeed()

                print(f"T={self.env.now:.2f} bufferstore finished moving item {item[0].id, item[1]} moved to ready_items")
                self._trigger_reserve_get(None)
                self._trigger_reserve_put(None)
            else:
                raise RuntimeError("Total number of items in the store exceeds capacity. Cannot move item to ready_items.")


    except simpy.Interrupt as interrupt:
        # Handle any uncaught interrupts
        print(f"T={self.env.now:.2f} Item {item_id} move process was interrupted: {interrupt.cause}")   

    finally:
        # Clean up the process tracking when done
        if item_id in self.active_move_processes:
            del self.active_move_processes[item_id]
            print(f"T={self.env.now:.2f} Removed tracking for completed move process of item {item_id}")

def put(self,put_event,item):
    """
    Perform a `put` operation on the store and trigger any pending `reserve_get` requests.

    Ensures that only processes with a valid reservation can put items into the store.
    If the put operation succeeds, it triggers `_trigger_reserve_get` to process pending get requests.

    Args:
        put_event (simpy.Event): The event corresponding to the reservation.
        item (object): The item to be added to the store.

    Returns:
        proceed (bool): True if the put operation succeeded, False otherwise.

    Raises:
        RuntimeError: If no reservations are available in the reservations_put
        RuntimeError: If proceed is False after put operation
    """
    proceed = False

    if self.reservations_put:
      proceed = self._trigger_put(put_event,item)
    else:
      raise RuntimeError("No matching reservation found for process: reservations_put is empty")

    if proceed:
      #print(f"{self.env.now} proceed")
      #self._trigger_get(None)
      self._trigger_reserve_get(None)



    if not proceed:

      raise RuntimeError(f"No matching put_event found in the reservations and put failed for{item}")
    else:
      #self._update_time_averaged_level()
      return proceed

def reserve_get(self):
    """
    Create a reservation request to retrieve an item from the store.

    This method generates a SimPy event representing a request to reserve an item
    for retrieval (`get`). The event is assigned attributes such as
    the resource it belongs to, and the process making the request.

    The event is then added to `reserve_get_queue`, which is maintained in
    the order in which the requests are made, and `_trigger_reserve_get()` is called to process pending
    reservations if items are available.



    Returns:
       event (simpy.Event): A reservation event that will succeed when an item becomes available.
    """
    #adding attributes to the newly created event for reserve_get
    event = self.env.event()
    event.resourcename=self
    event.requesting_process = self.env.active_process  # Associate event with the current process




    self.reserve_get_queue.append(event)


    self._trigger_reserve_get(event)
    return event

def reserve_get_cancel(self, get_event_to_cancel):
    """
    Cancel a previously made `reserve_get` request.
    """
    # Case 1: still waiting
    if get_event_to_cancel in self.reserve_get_queue:
        self.reserve_get_queue.remove(get_event_to_cancel)
        self._trigger_reserve_get(None)
        return True

    # Case 2: already yielded reservation
    if get_event_to_cancel in self.reservations_get:
        # 1) Remove from active reservations
        self.reservations_get.remove(get_event_to_cancel)

        # 2) Find its index in the parallel lists
        ev_idx = self.reserved_events.index(get_event_to_cancel)

        # 3) Pop out the exact item reference
        item = self.reserved_items.pop(ev_idx)
        # 4) Drop the event token
        self.reserved_events.pop(ev_idx)

        # 5) Remove it from ready_items wherever it currently is
        try:
            self.ready_items.remove(item)
        except ValueError:
            raise RuntimeError(f"Item {item!r} not found in ready_items during cancel.")

        # 6) Compute new insertion index

        insert_idx = len(self.ready_items) - len(self.reserved_events) - 1

        # 7) Re‑insert it
        self.ready_items.insert(insert_idx, item)

        # 8) Trigger any other pending reservations
        self._trigger_reserve_get(None)
        return True

    # No such reservation
    raise RuntimeError(
        "No matching event in reserve_get_queue or reservations_get"
    )

def reserve_put(self):
    """
    Create a reservation request to put an item into the store.

    This function generates a SimPy event representing a reservation request. The event is
    assigned attributes such as resource name, and the process making the request.
    The event is then added to `reserve_put_queue`, which is maintained in the order in which the 
    request is made.

    After adding the event to the queue, `_trigger_reserve_put` is called to process
    any pending reservations.


    Returns:
        event (simpy.Event): A reservation event that will succeed when space is available.

    """
    event = self.env.event()
    event.resourcename = self  # Store reference
    event.requesting_process = self.env.active_process  # Process making the reservation

    self.reserve_put_queue.append(event)


    # Attempt to process reservations
    self._trigger_reserve_put(event)

    return event

def reserve_put_cancel(self, put_event_to_cancel):
  """
    Cancel a previously made `reserve_put` request.

    This method allows a process to cancel its reservation for putting an item
    into the store. If the reservation exists in the `reserve_put_queue`, it is
    removed before triggering `_trigger_reserve_put` to process any pending reservations.
    If the reservation is already in `reservations_put`, it is also removed and
    `_trigger_reserve_put` is triggered.

    Args:
        put_event_to_cancel (simpy.Event): The reservation event that needs to be canceled.

    Returns:
       proceed (bool): True if the reservation was successfully canceled.

    Raises:
        RuntimeError: If the specified event does not exist in `reserve_put_queue`
                      or `reservations_put`.
    """

  #checking and removing the event if it is not yielded and is present in the reserve_put_queue
  proceed = False
  if put_event_to_cancel in self.reserve_put_queue:
    self.reserve_put_queue.remove(put_event_to_cancel)
    self._trigger_reserve_put(None)#if t is removed, then a waiting event can be succeeded, if any
    proceed = True
  #checking and removing the event if it is already yielded and is present in the reservations_put
  elif put_event_to_cancel in self.reservations_put:
    self.reservations_put.remove(put_event_to_cancel)
    self._trigger_reserve_put(None)#if t is removed, then a waiting event can be succeeded, if any
    proceed = True

  else:
    raise RuntimeError("No matching event in reserve_put_queue or reservations_put for this process")
  return proceed

def resume_all_move_processes(self):
    """
    Resume all interrupted move_to_ready_items processes.
    """
    print(f"T={self.env.now:.2f} Belt_Store resuming move processes")

    # Create a new resume event and trigger it
    old_resume_event = self.resume_event
    self.resume_event = self.env.event()
    old_resume_event.succeed()

def selective_interrupt(self, reason="Selective interrupt"):
    """
    Perform selective interruption based on belt occupancy patterns and mode.

    When noaccumulation_mode_on=True (STALLED_NONACCUMULATING_STATE):
    - Interrupt all items immediately

    When noaccumulation_mode_on=False (STALLED_ACCUMULATING_STATE):
    - Use pattern-based interruption with delays based on item positions

    Pattern-based rules for accumulating mode:
    - For patterns like '_****', interrupt all items.
    - For patterns like '_*_*_', interrupt item in second last position after 1 delay,
      and second item after 2 delays.
    - For patterns like '*___*', interrupt first item and second item after 3 delays.
    - For patterns like '**__*', interrupt first item, second after 2 delays,
      and third after 2 delays.

    Args:
        reason (str): Reason for the interrupt
    """
    if not self.items:
        print(f"T={self.env.now:.2f} No items on belt to interrupt")
        return

    # If noaccumulation_mode_on is True (STALLED_NONACCUMULATING_STATE), interrupt all items immediately
    if self.noaccumulation_mode_on == True:
        print(f"T={self.env.now:.2f} Noaccumulation_mode_on: interrupting all items immediately")
        for i, item in enumerate(self.items):
            item_id = item[0].id if hasattr(item[0], 'id') else str(id(item))
            self._interrupt_specific_item(item_id, f"{reason} - immediate (no accumulation)")
        return

    # For accumulating mode (STALLED_ACCUMULATING_STATE), use pattern-based interruption
    if self.accumulation_mode_indicator == True:
    #if self.noaccumulation_mode_on == False:
        print(f"T={self.env.now:.2f} Accumulating mode: using pattern-based interruption")

        # Get current belt pattern
        all_patterns = self._get_belt_pattern()
        pattern = all_patterns[0]
        beltitems = all_patterns[1]
        print(f"T={self.env.now:.2f} Current belt pattern: {pattern} and items {beltitems}")

        # Analyze pattern and determine interruption strategy
        interruption_plan = self._analyze_pattern_for_interruption(all_patterns)

        if not interruption_plan:
            print(f"T={self.env.now:.2f} No interruption needed for current pattern")
            return

        print(f"T={self.env.now:.2f} Executing selective interruption plan: {interruption_plan}")

        # Execute the interruption plan
        self._execute_interruption_plan(interruption_plan, reason)

def get(self,get_event):
    """
    Retrieve an item from the store after a successful reservation.

    This method attempts to retrieve an item associated with a `reserve_get`
    event. If the reservation exists, it triggers `_trigger_get` to retrieve
    the item. If successful, `_trigger_reserve_put` is called to process any
    pending `reserve_put` requests. If the item retrieval fails, an error
    message is raised.

    Args:
        get_event (simpy.Event): The reservation event associated with the request.

    Returns:
        item (Object): The retrieved item if successful, otherwise raises an error

    Raises:
        RuntimeError: If no reservations are available in the reservations_get
        RuntimeError: If item returned is None
    """

    item = None
    #if there are reservations, then call _trigger_get
    if self.reservations_get:
      item= self._trigger_get(get_event)
    #else raise an error
    else:
      raise RuntimeError("No matching reservation found for process: reservations_get is empty")
    #if an item is returned then call _trigger_reserve_put to process pending requests
    if item is not None:
      self._trigger_reserve_put(None)

    if item is None:
      raise RuntimeError(f"No item found in the store for {get_event.requesting_process} and get request failed")
    else:
      #self._update_time_averaged_level()
      return item

def move_to_ready_items(self,item):
    """
    Move items from the store to the ready_items list after a put operation.
    This method is called as a process to ensure that items are moved asynchronously.
    """

    # Move items to the ready_items list
    if self.items:
        #print(f"T={self.env.now:.2f} beltstore received an item {item[0].id, item[1]} . Item started moving in belt")
        yield self.env.timeout(item[1])
        #print(f"T={self.env.now:.2f} bufferstore finished moving item {item[0].id, item[1]} going to ready_items")

        item_index = self.items.index(item)
        item_to_put = self.items.pop(item_index)  # Remove the first item
        #print(item_to_put, item)
        if len(self.ready_items)+ len(self.items) < self.capacity:
            self.ready_items.append(item_to_put[0])
            #print(f"T={self.env.now:.2f} bufferstore finished moving item {item[0].id, item[1]} moved to ready_items")
            self._trigger_reserve_get(None)
            self._trigger_reserve_put(None)
            #print(f"T={self.env.now:.2f} bufferstore is moving item {item[0].id, item[1]} to ready_items. Total items in buffer is {len(self.items)+len(self.ready_items)}"   )
        else:
            raise RuntimeError("Total number of items in the store exceeds capacity. Cannot move item to ready_items.")

def put(self,put_event,item):
    """
    Perform a `put` operation on the store and trigger any pending `reserve_get` requests.

    Ensures that only processes with a valid reservation can put items into the store.
    If the put operation succeeds, it triggers `_trigger_reserve_get` to process pending get requests.

    Args:
        put_event (simpy.Event): The event corresponding to the reservation.
        item (object): The item to be added to the store.

    Returns:
        proceed (bool): True if the put operation succeeded, False otherwise.

    Raises:
        RuntimeError: If no reservations are available in the reservations_put
        RuntimeError: If proceed is False after put operation
    """
    proceed = False

    if self.reservations_put:
      proceed = self._trigger_put(put_event,item)
    else:
      raise RuntimeError("No matching reservation found for process: reservations_put is empty")

    if proceed:
      #print(f"{self.env.now} proceed")
      #self._trigger_get(None)
      self._trigger_reserve_get(None)



    if not proceed:

      raise RuntimeError(f"No matching put_event found in the reservations and put failed for{item}")
    else:
      #self._update_time_averaged_level()
      return proceed

def reserve_get(self):
    """
    Create a reservation request to retrieve an item from the store.

    This method generates a SimPy event representing a request to reserve an item
    for retrieval (`get`). The event is assigned attributes such as the resource 
    it belongs to, and the process making the request.

    The event is then added to `reserve_get_queue`, which is maintained in
    the order in which the requests are made, and `_trigger_reserve_get()` is called to process pending
    reservations if items are available.


    Returns:
       event (simpy.Event): A reservation event that will succeed when an item becomes available.
    """
    #adding attributes to the newly created event for reserve_get
    event = self.env.event()
    event.resourcename=self
    event.requesting_process = self.env.active_process  # Associate event with the current process


    self.reserve_get_queue.append(event)


    self._trigger_reserve_get(event)
    return event

def reserve_get_cancel(self, get_event_to_cancel):
    """
    Cancel a previously made `reserve_get` request.
    """
    # Case 1: still waiting
    if get_event_to_cancel in self.reserve_get_queue:
        self.reserve_get_queue.remove(get_event_to_cancel)
        self._trigger_reserve_get(None)
        return True

    # Case 2: already yielded reservation
    if get_event_to_cancel in self.reservations_get:
        # 1) Remove from active reservations
        self.reservations_get.remove(get_event_to_cancel)

        # 2) Find its index in the parallel lists
        ev_idx = self.reserved_events.index(get_event_to_cancel)

        # 3) Pop out the exact item reference
        item = self.reserved_items.pop(ev_idx)
        # 4) Drop the event token
        self.reserved_events.pop(ev_idx)

        # 5) Remove it from ready_items wherever it currently is
        try:
            self.ready_items.remove(item)
        except ValueError:
            raise RuntimeError(f"Item {item} not found in ready_items during cancel.")

        # 6) Compute new insertion index as a get call is cancelled and item that is reserved and associated to an event is now freely available to be assigned to a new incoming event
        if self.mode == "FIFO":
            # one slot before the remaining reserved block
            insert_idx = len(self.ready_items) - len(self.reserved_events) - 1
        else:  # LIFO
            # top of stack
            insert_idx = len(self.ready_items)

        # 7) Re‑insert it
        self.ready_items.insert(insert_idx, item)

        # 8) Trigger any other pending reservations
        self._trigger_reserve_get(None)
        return True

    # No such reservation
    raise RuntimeError(
        "No matching event in reserve_get_queue or reservations_get"
    )

def reserve_put(self):
    """
    Create a reservation request to put an item into the store.

    This function generates a SimPy event representing a reservation request. The event is
    assigned attributes such as resource name, and the process making the request.
    The event is then added to `reserve_put_queue`, which is maintained in the order in which the requests are made.

    After adding the event to the queue, `_trigger_reserve_put` is called to process
    any pending reservations.



    Returns:
        event (simpy.Event): A reservation event that will succeed when space is available.

    """
    event = self.env.event()
    event.resourcename = self  # Store reference
    event.requesting_process = self.env.active_process  # Process making the reservation

    self.reserve_put_queue.append(event)


    # Attempt to process reservations
    self._trigger_reserve_put(event)

    return event

def reserve_put_cancel(self, put_event_to_cancel):
  """
    Cancel a previously made `reserve_put` request.

    This method allows a process to cancel its reservation for putting an item
    into the store. If the reservation exists in the `reserve_put_queue`, it is
    removed before triggering `_trigger_reserve_put` to process any pending reservations.
    If the reservation is already in `reservations_put`, it is also removed and
    `_trigger_reserve_put` is triggered.

    Args:
        put_event_to_cancel (simpy.Event): The reservation event that needs to be canceled.

    Returns:
       proceed (bool): True if the reservation was successfully canceled.

    Raises:
        RuntimeError: If the specified event does not exist in `reserve_put_queue`
                      or `reservations_put`.
    """

  #checking and removing the event if it is not yielded and is present in the reserve_put_queue
  proceed = False
  if put_event_to_cancel in self.reserve_put_queue:
    self.reserve_put_queue.remove(put_event_to_cancel)
    self._trigger_reserve_put(None)#if t is removed, then a waiting event can be succeeded, if any
    proceed = True
  #checking and removing the event if it is already yielded and is present in the reservations_put
  elif put_event_to_cancel in self.reservations_put:
    self.reservations_put.remove(put_event_to_cancel)
    self._trigger_reserve_put(None)#if t is removed, then a waiting event can be succeeded, if any
    proceed = True

  else:
    raise RuntimeError("No matching event in reserve_put_queue or reservations_put for this process")
  return proceed

def fleet_activation_process(self,):
    """
    Process to activate the fleet when items are available but not equivalent to self.capacity(level not achieved).
    This process waits for the activate_fleet event to be triggered.
    """
    while True:
        timeout_event = self.env.timeout(self.delay)
        event_list= [timeout_event, self.activate_fleet]
        yield self.env.any_of(event_list)

        print(f"T={self.env.now:.2f}: Fleet activation process triggered.")

        if self.items:
            print(f"T={self.env.now:.2f}: Fleet activated with {len(self.items)} items ready.")
            self.env.process(self.move_to_ready_items(self.items))
            #self.env.process(self.move_to_ready_items(self.items))
            if self.activate_fleet.triggered:
                #print("yes")
                self.activate_fleet = self.env.event()  # Reset the event for next activation

def get(self,get_event):
    """
    Retrieve an item from the store after a successful reservation.

    This method attempts to retrieve an item associated with a `reserve_get`
    event. If the reservation exists, it triggers `_trigger_get` to retrieve
    the item. If successful, `_trigger_reserve_put` is called to process any
    pending `reserve_put` requests. If the item retrieval fails, an error
    message is raised.

    Args:
        get_event (simpy.Event): The reservation event associated with the request.

    Returns:
        item (Object): The retrieved item if successful, otherwise raises an error

    Raises:
        RuntimeError: If no reservations are available in the reservations_get
        RuntimeError: If item returned is None
    """

    item = None
    #if there are reservations, then call _trigger_get
    if self.reservations_get:
      item= self._trigger_get(get_event)
    #else raise an error
    else:
      raise RuntimeError("No matching reservation found for process: reservations_get is empty")
    #if an item is returned then call _trigger_reserve_put to process pending requests
    if item is not None:
      self._trigger_reserve_put(None)

    if item is None:
      raise RuntimeError(f"No item found in the store for {get_event.requesting_process} and get request failed")
    else:
      #self._update_time_averaged_level()
      return item

def move_to_ready_items(self, items):
    """
    Move items from the store to the ready_items list after a put operation.
    This method is called as a process to ensure that items are moved asynchronously.
    """

    # Move items to the ready_items list
    if items:

        print(f"T={self.env.now:.2f}: Moving items to ready_items.")
        #START=self.env.now
        yield self.env.timeout(self.transit_delay)
        #print("WAITED FOR TRANSIT_DELAY BEFORE MOVING", self.env.now-START)
        yield self.env.timeout(self.transit_delay)

        for item in items:

            item_index = self.items.index(item)
            item_to_put = self.items.pop(item_index)  # Remove the first item

            if len(self.ready_items) < self.capacity:
                self.ready_items.append(item_to_put)
                #print(f"T={self.env.now:.2f}: {self.id} moved item {item_to_put.id} to ready_items.")
                self._trigger_reserve_get(None)
                self._trigger_reserve_put(None)
                #print(f"T={self.env.now:.2f} bufferstore is moving item {item[0].id, item[1]} to ready_items. Total items in buffer is {len(self.items)+len(self.ready_items)}"   )
            else:
                raise RuntimeError("Total number of items in the store exceeds capacity. Cannot move item to ready_items.")

        print(f"T={self.env.now:.2f}: Fleetstore moved items to ready_items.")

def put(self,put_event,item):
    """
    Perform a `put` operation on the store and trigger any pending `reserve_get` requests.

    Ensures that only processes with a valid reservation can put items into the store.
    If the put operation succeeds, it triggers `_trigger_reserve_get` to process pending get requests.

    Args:
        put_event (simpy.Event): The event corresponding to the reservation.
        item (object): The item to be added to the store.

    Returns:
        proceed (bool): True if the put operation succeeded, False otherwise.

    Raises:
        RuntimeError: If no reservations are available in the reservations_put
        RuntimeError: If proceed is False after put operation
    """

    proceed = False

    if self.reservations_put:
      proceed = self._trigger_put(put_event,item)
    else:
      raise RuntimeError("No matching reservation found for process: reservations_put is empty")

    if proceed:
      #print(f"{self.env.now} proceed")
      #self._trigger_get(None)
      self._trigger_reserve_get(None)



    if not proceed:

      raise RuntimeError(f"No matching put_event found in the reservations and put failed for{item}")
    else:
      #self._update_time_averaged_level()
      return proceed

def reserve_get(self,priority=0):
    """
    Create a reservation request to retrieve an item from the store.

    This method generates a SimPy event representing a request to reserve an item
    for retrieval (`get`). The event is assigned attributes such as priority,
    the resource it belongs to, and the process making the request.

    The event is then added to `reserve_get_queue`, which is maintained in
    priority order, and `_trigger_reserve_get()` is called to process pending
    reservations if items are available.

    Args:
        priority (int, optional): The priority level of the reservation request.
                                  Lower values indicate higher priority. Defaults to 0.

    Returns:
       event (simpy.Event): A reservation event that will succeed when an item becomes available.
    """
    #adding attributes to the newly created event for reserve_get
    event = self.env.event()
    event.resourcename=self
    event.requesting_process = self.env.active_process  # Associate event with the current process

    #event.priority_to_get = (priority, self._env.now)
    event.priority_to_get = priority

    #sorting the list based on priority after appending the new event
    self.reserve_get_queue.append(event)
    self.reserve_get_queue.sort(key=lambda e: e.priority_to_get)

    self._trigger_reserve_get(event)
    return event

def reserve_get_cancel(self, get_event_to_cancel):
    """
    Cancel a previously made `reserve_get` request.
    """
    # Case 1: still waiting
    if get_event_to_cancel in self.reserve_get_queue:
        self.reserve_get_queue.remove(get_event_to_cancel)
        self._trigger_reserve_get(None)
        return True

    # Case 2: already yielded reservation
    if get_event_to_cancel in self.reservations_get:
        # 1) Remove from active reservations
        self.reservations_get.remove(get_event_to_cancel)

        # 2) Find its index in the parallel lists
        ev_idx = self.reserved_events.index(get_event_to_cancel)

        # 3) Pop out the exact item reference
        item = self.reserved_items.pop(ev_idx)
        # 4) Drop the event token
        self.reserved_events.pop(ev_idx)

        # 5) Remove it from ready_items wherever it currently is
        try:
            self.ready_items.remove(item)
        except ValueError:
            raise RuntimeError(f"Item {item!r} not found in ready_items during cancel.")

        # 6) Compute new insertion index
        # "FIFO":
            # one slot before the remaining reserved block
        insert_idx = len(self.ready_items) - len(self.reserved_events) - 1


        # 7) Re‑insert it
        self.ready_items.insert(insert_idx, item)

        # 8) Trigger any other pending reservations
        self._trigger_reserve_get(None)
        return True

    # No such reservation
    raise RuntimeError(
        "No matching event in reserve_get_queue or reservations_get"
    )

def reserve_get_cancel1(self, get_event_to_cancel):

  """
    Cancel a previously made `reserve_get` request.

    This method allows a process to cancel its reservation for retrieving an item
    from the store. If the reservation exists in the `reserve_get_queue`, it is removed,
    and `_trigger_reserve_get()` is called to process any remaining reservations.

    If the reservation is already in `reservations_get`, it is removed, and the corresponding
    item is repositioned in the store to maintain order. `_trigger_reserve_get()` is then
    triggered to handle pending reservations.

    Args:
        get_event_to_cancel (simpy.Event): The reservation event that needs to be canceled.

    Returns:
        proceed (bool): True if the reservation was successfully canceled.

    Raises:
        RuntimeError: If the specified event does not exist in `reserve_get_queue`
                      or `reservations_get`.
    """

  proceed = False
  #checking and removing the event if it is not yielded and is present in the reserve_get_queue
  if get_event_to_cancel in self.reserve_get_queue:
    self.reserve_get_queue.remove(get_event_to_cancel)
    self._trigger_reserve_get(None)#if t is removed, then a waiting event can be succeeded, if any
    proceed = True

  #checking and removing the event if it is already yielded and is present in the reservations_queue.
  # 1-to-1 association with items done to preserve item order should also be removed.
  elif get_event_to_cancel in self.reservations_get:
    self.reservations_get.remove(get_event_to_cancel)

    #deleting the associated event in the reserved_events list to preserve the order of the items
    #finding index of the item
    event_in_index = self.reserved_events.index(get_event_to_cancel)
    delta_position = len(self.reserved_events)
    #shifting the item
    item_to_shift = self.items.pop(event_in_index)
    self.items.insert(delta_position-1, item_to_shift)
    #deleting the event
    self.reserved_events.pop(event_in_index)#if t is removed, then a waiting event can be succeeded, if any

    self._trigger_reserve_get(None)
    proceed = True

  else:
    raise RuntimeError("No matching event in reserve_get_queue or reservations_get for this process")

  return proceed

def reserve_put(self, priority=0):
    """
    Create a reservation request to put an item into the store.

    This function generates a SimPy event representing a reservation request. The event is
    assigned attributes such as priority, resource name, and the process making the request.
    The event is then added to `reserve_put_queue`, which is maintained in priority order.

    After adding the event to the queue, `_trigger_reserve_put` is called to process
    any pending reservations.

    Args:
        priority (int, optional): The priority level of the reservation request.
                                  Lower values indicate higher priority. Defaults to 0.

    Returns:
        event (simpy.Event): A reservation event that will succeed when space is available.

    """
    event = self.env.event()
    event.resourcename = self  # Store reference
    event.requesting_process = self.env.active_process  # Process making the reservation
    event.priority_to_put = priority  # Priority for sorting reservations

    # Add the event to the reservation queue and sort by priority
    self.reserve_put_queue.append(event)
    self.reserve_put_queue.sort(key=lambda e: e.priority_to_put)

    # Attempt to process reservations
    self._trigger_reserve_put(event)

    return event

def reserve_put_cancel(self, put_event_to_cancel):
  """
    Cancel a previously made `reserve_put` request.

    This method allows a process to cancel its reservation for putting an item
    into the store. If the reservation exists in the `reserve_put_queue`, it is
    removed before triggering `_trigger_reserve_put` to process any pending reservations.
    If the reservation is already in `reservations_put`, it is also removed and
    `_trigger_reserve_put` is triggered.

    Args:
        put_event_to_cancel (simpy.Event): The reservation event that needs to be canceled.

    Returns:
       proceed (bool): True if the reservation was successfully canceled.

    Raises:
        RuntimeError: If the specified event does not exist in `reserve_put_queue`
                      or `reservations_put`.
    """

  #checking and removing the event if it is not yielded and is present in the reserve_put_queue
  proceed = False
  if put_event_to_cancel in self.reserve_put_queue:
    self.reserve_put_queue.remove(put_event_to_cancel)
    self._trigger_reserve_put(None)#if t is removed, then a waiting event can be succeeded, if any
    proceed = True
  #checking and removing the event if it is already yielded and is present in the reservations_put
  elif put_event_to_cancel in self.reservations_put:
    self.reservations_put.remove(put_event_to_cancel)
    self._trigger_reserve_put(None)#if t is removed, then a waiting event can be succeeded, if any
    proceed = True

  else:
    raise RuntimeError("No matching event in reserve_put_queue or reservations_put for this process")
  return proceed

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

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

    """
    if self.maxlen is not None and len(self) >= self.maxlen:
        raise RuntimeError('Cannot append event. Queue is full.')

    super().append(item)
    super().sort(key=lambda e: e.key)