def __init__(self, event_id=None):
global pygame
import pygame
self.timer = None
self.event_id = event_id or pygame.USEREVENT
self.queue = PriorityQueue()
def __init__(self):
super().__init__()
global pygame
import pygame
self._lock = threading.Lock()
self._queue: PriorityQueue[ScheduledItem[
typing.TState]] = PriorityQueue()
def __init__(self):
"""Gets a scheduler that schedules work as soon as possible on the
current thread."""
super().__init__()
self._idle = True
self.queue = PriorityQueue()
self.lock = threading.RLock()
def test_priorityqueue_enqueue_dequeue(self):
"""Enqueue followed by dequeue should give the same result"""
p = PriorityQueue()
self.assertRaises(IndexError, p.dequeue)
p.enqueue(42)
p.enqueue(41)
p.enqueue(43)
assert([p.dequeue(), p.dequeue(), p.dequeue()] == [41, 42, 43])
def test_priorityqueue_empty(self):
"""Must be empty on construction"""
p = PriorityQueue()
assert len(p) == 0
assert p.items == []
# Still empty after enqueue/dequeue
p.enqueue(42)
p.dequeue()
assert len(p) == 0
def test_priorityqueue_peek(self):
"""Peek at first element in queue"""
p = PriorityQueue()
self.assertRaises(InvalidOperationException, p.peek)
p.enqueue(42)
assert p.peek() == 42
p.enqueue(41)
assert p.peek() == 41
p.enqueue(43)
assert p.peek() == 41
def __init__(self, pygame: Any):
"""Create a new PyGameScheduler.
Args:
pygame: The PyGame module to use; typically, you would get this by
import pygame
"""
super().__init__()
self._pygame = pygame # TODO not used, refactor to actually use pygame?
self._lock = threading.Lock()
self._queue: PriorityQueue[ScheduledItem[typing.TState]] = PriorityQueue()
def test_priorityqueue_peek(self):
"""Peek at first element in queue"""
p = PriorityQueue()
self.assertRaises(IndexError, p.peek)
p.enqueue(42)
assert p.peek() == 42
p.enqueue(41)
assert p.peek() == 41
p.enqueue(43)
assert p.peek() == 41
def __init__(self, initial_clock=0, comparer=None):
"""Creates a new virtual time scheduler with the specified initial
clock value and absolute time comparer.
Keyword arguments:
initial_clock -- Initial value for the clock.
comparer -- Comparer to determine causality of events based on absolute time.
"""
self.clock = initial_clock
self.comparer = comparer
self.is_enabled = False
self.queue = PriorityQueue(1024)
def __init__(self, initial_clock=0) -> None:
"""Creates a new virtual time scheduler with the specified
initial clock value.
Args:
initial_clock: Initial value for the clock.
"""
super().__init__()
self._clock = initial_clock
self._is_enabled = False
self._lock: threading.Lock = threading.Lock()
self._queue: PriorityQueue[ScheduledItem] = PriorityQueue()
def test_priorityqueue_remove_at(self):
"""Remove item at index"""
p = PriorityQueue()
self.assertRaises(IndexError, p.remove_at, 42)
p.enqueue(42)
p.enqueue(41)
p.enqueue(43)
assert (p.remove_at(2) == 43)
assert (p.remove_at(1) == 42)
assert (p.remove_at(0) == 41)
self.assertRaises(IndexError, p.remove_at, 0)
def __init__(self, initial_clock=0.0) -> None:
"""Creates a new virtual time scheduler with the specified
initial clock value and absolute time comparer.
Args:
initial_clock: Initial value for the clock.
comparer: Comparer to determine causality of events based
on absolute time.
"""
self.clock = initial_clock
self.is_enabled = False
self.queue = PriorityQueue(1024)
super().__init__()
def test_priorityqueue_length(self):
"""Test that length is n after n invocations"""
p = PriorityQueue()
assert len(p) == 0
for n in range(42):
p.enqueue(n)
assert len(p) == 42
p.dequeue()
assert len(p) == 41
p.remove(10)
assert len(p) == 40
for n in range(len(p)):
p.dequeue()
assert len(p) == 0
def test_priorityqueue_sort_stability(self):
"""Items with same value should be returned in the order they were
added"""
p = PriorityQueue()
p.enqueue(TestItem(43, "high"))
p.enqueue(TestItem(42, "first"))
p.enqueue(TestItem(42, "second"))
p.enqueue(TestItem(42, "last"))
p.enqueue(TestItem(41, "low"))
assert len(p) == 5
assert p.dequeue() == TestItem(41, "low")
assert p.dequeue() == TestItem(42, "first")
assert p.dequeue() == TestItem(42, "second")
assert p.dequeue() == TestItem(42, "last")
assert p.dequeue() == TestItem(43, "high")
def schedule_relative(self, duetime, action, state=None):
"""Schedules an action to be executed after duetime."""
duetime = self.to_timedelta(duetime)
dt = self.now + SchedulerBase.normalize(duetime)
si = ScheduledItem(self, state, action, dt)
queue = self.queue
if queue is None:
queue = PriorityQueue(4)
queue.enqueue(si)
self.queue = queue
try:
Trampoline.run(queue)
finally:
self.queue = None
else:
queue.enqueue(si)
return si.disposable
def test_priorityqueue_remove(self):
"""Remove item from queue"""
p = PriorityQueue()
assert(p.remove(42) == False)
p.enqueue(42)
p.enqueue(41)
p.enqueue(43)
assert p.remove(42) == True
assert [p.dequeue(), p.dequeue()] == [41, 43]
p.enqueue(42)
p.enqueue(41)
p.enqueue(43)
assert p.remove(41) == True
assert [p.dequeue(), p.dequeue()] == [42, 43]
p.enqueue(42)
p.enqueue(41)
p.enqueue(43)
assert p.remove(43) == True
assert [p.dequeue(), p.dequeue()] == [41, 42]
def __init__(self) -> None:
super().__init__()
self.idle: bool = True
self.queue: PriorityQueue[ScheduledItem[
typing.TState]] = PriorityQueue()
def __init__(self):
self.queue = PriorityQueue(4)
def __init__(self):
self.idle: bool = True
self.queue: PriorityQueue[ScheduledItem[
typing.TState]] = PriorityQueue()
def __init__(self, scheduler):
self.queue = PriorityQueue(4)
self.scheduler = scheduler
