Example #1
0
def test_heappop():
    n = 1000
    a = [randrange(1000) for _ in range(n)]
    heapify(a)
    previous = heappop(a)
    pop_count = 1
    while a:
        assert previous <= (previous := heappop(a))
        pop_count += 1
    assert pop_count == n
    assert len(a) == 0
Example #2
0
 def unplan_call(self, h):
     # remove a call from the queue
     q = self.q
     rv = 0
     for i in range(len(q)):
         try:
             if q[i][1] is h:
                 q[i] = (0, 0)
         except IndexError:
             break
     heapq.heapify(q)
     while q and q[0] == (0, 0):
         heapq.heappop(q)
         rv += 1
     return rv
Example #3
0
    def run_forever(self):
        while True:
            if self.q:
                t, cnt, cb, args = heapq.heappop(self.q)
                if __debug__:
                    log.debug("Next coroutine to run: %s", (t, cnt, cb, args))
#                __main__.mem_info()
                tnow = self.time()
                delay = t - tnow
                if delay > 0:
                    self.wait(delay)
            else:
                self.wait(-1)
                # Assuming IO completion scheduled some tasks
                continue
            if callable(cb):
                cb(*args)
            else:
                delay = 0
                try:
                    if __debug__:
                        log.debug("Coroutine %s send args: %s", cb, args)
                    if args == ():
                        ret = next(cb)
                    else:
                        ret = cb.send(*args)
                    if __debug__:
                        log.debug("Coroutine %s yield result: %s", cb, ret)
                    if isinstance(ret, SysCall1):
                        arg = ret.arg
                        if isinstance(ret, Sleep):
                            delay = arg
                        elif isinstance(ret, IORead):
#                            self.add_reader(ret.obj.fileno(), lambda self, c, f: self.call_soon(c, f), self, cb, ret.obj)
#                            self.add_reader(ret.obj.fileno(), lambda c, f: self.call_soon(c, f), cb, ret.obj)
#                            self.add_reader(arg.fileno(), lambda cb: self.call_soon(cb), cb)
                            self.add_reader(arg.fileno(), cb)
                            continue
                        elif isinstance(ret, IOWrite):
#                            self.add_writer(arg.fileno(), lambda cb: self.call_soon(cb), cb)
                            self.add_writer(arg.fileno(), cb)
                            continue
                        elif isinstance(ret, IOReadDone):
                            self.remove_reader(arg.fileno())
                        elif isinstance(ret, IOWriteDone):
                            self.remove_writer(arg.fileno())
                        elif isinstance(ret, StopLoop):
                            return arg
                    elif isinstance(ret, type_gen):
                        self.call_soon(ret)
                    elif ret is None:
                        # Just reschedule
                        pass
                    else:
                        assert False, "Unsupported coroutine yield value: %r (of type %r)" % (ret, type(ret))
                except StopIteration as e:
                    if __debug__:
                        log.debug("Coroutine finished: %s", cb)
                    continue
                self.call_later(delay, cb, *args)
Example #4
0
    def play_audio(self):
        if self.queue_data is None:
            return False
        try:
            # dequeue a data
            data = heapq.heappop(self.queue_data)
            print("pop {}".format(len(data)))

            # TODO: play data
        except:
            #print("play_audio exception ")
            return False
        return True
Example #5
0
def process_configuration():
    configuration = uheapq.heappop(heap)

    sensors = []

    for item in configuration["sensors"]:
        # string
        name_type = item["name_type"]
        # integer
        sampling_frequency = int(item["sampling_frequency"])
        # array
        microcontroller_pins = item["microcontroller_pins"]
        # array
        field_name = item["field_name"]
        # array
        data_type = item["data_type"]

        # sensor type
        sensor_type = name_type[name_type.index("(") + 1:name_type.rindex(")")]

        if sensor_type == "BUTTON":
            sensor = Button_LED(name_type, sampling_frequency,
                                microcontroller_pins, field_name, data_type)
            sensors.append(sensor)

        if sensor_type == "DHT11":
            sensor = Temperature_Humidity(name_type, sampling_frequency,
                                          microcontroller_pins, field_name,
                                          data_type)
            sensors.append(sensor)

        if sensor_type == "ACCELEROMETER":
            sensor = Accelerometer(name_type, sampling_frequency,
                                   microcontroller_pins, field_name, data_type)
            sensors.append(sensor)

        if sensor_type == "PH":
            sensor = Ph(name_type, sampling_frequency, microcontroller_pins,
                        field_name, data_type)
            sensors.append(sensor)

    return sensors
Example #6
0
try:
    import uheapq as heapq
except:
    try:
        import heapq
    except ImportError:
        import sys
        print("SKIP")
        sys.exit()

try:
    heapq.heappop([])
except IndexError:
    print("IndexError")

try:
    heapq.heappush((), 1)
except TypeError:
    print("TypeError")


def pop_and_print(h):
    l = []
    while h:
        l.append(str(heapq.heappop(h)))
    print(' '.join(l))


h = []
heapq.heappush(h, 3)
heapq.heappush(h, 1)
Example #7
0
def move_train(t):
    global head, tail
    if head == 0:
        print(f'move = {time.monotonic():.2f}')
    PIXELS[head] = BLUE
    PIXELS[tail] = BLACK
    head = (head + DIRECTION) % 10
    tail = (tail + DIRECTION) % 10
    uheapq.heappush(EVENT_QUEUE, (t + 100 * MILLISECOND, move_train))


def blink_on(t):
    print(f'blink_on: {time.monotonic():.2f}')
    RED_LED.value = True
    uheapq.heappush(EVENT_QUEUE, (t + 100 * MILLISECOND, blink_off))


def blink_off(t):
    RED_LED.value = False
    uheapq.heappush(EVENT_QUEUE, (t + 900 * MILLISECOND, blink_on))


start = time.monotonic_ns()
uheapq.heappush(EVENT_QUEUE, (start + SECOND, move_train))
uheapq.heappush(EVENT_QUEUE, (start + SECOND + 1, blink_on))

while EVENT_QUEUE:
    t, fn = uheapq.heappop(EVENT_QUEUE)
    time.sleep(max((t - time.monotonic_ns()) / SECOND, 0))
    fn(t)
Example #8
0
    def run_forever(self):
        while True:
            if self.q:
                t, cnt, cb, args = heapq.heappop(self.q)
                if __debug__:
                    log.debug("Next coroutine to run: %s", (t, cnt, cb, args))


#                __main__.mem_info()
                tnow = self.time()
                delay = t - tnow
                if delay > 0:
                    self.wait(delay)
            else:
                self.wait(-1)
                # Assuming IO completion scheduled some tasks
                continue
            if callable(cb):
                cb(*args)
            else:
                delay = 0
                try:
                    if args == ():
                        args = (None, )
                    if __debug__:
                        log.debug("Coroutine %s send args: %s", cb, args)
                    ret = cb.send(*args)
                    if __debug__:
                        log.debug("Coroutine %s yield result: %s", cb, ret)
                    if isinstance(ret, SysCall1):
                        arg = ret.arg
                        if isinstance(ret, Sleep):
                            delay = arg
                        elif isinstance(ret, IORead):
                            #                            self.add_reader(ret.obj.fileno(), lambda self, c, f: self.call_soon(c, f), self, cb, ret.obj)
                            #                            self.add_reader(ret.obj.fileno(), lambda c, f: self.call_soon(c, f), cb, ret.obj)
                            #                            self.add_reader(arg.fileno(), lambda cb: self.call_soon(cb), cb)
                            self.add_reader(arg.fileno(), cb)
                            continue
                        elif isinstance(ret, IOWrite):
                            #                            self.add_writer(arg.fileno(), lambda cb: self.call_soon(cb), cb)
                            self.add_writer(arg.fileno(), cb)
                            continue
                        elif isinstance(ret, IOReadDone):
                            self.remove_reader(arg.fileno())
                        elif isinstance(ret, IOWriteDone):
                            self.remove_writer(arg.fileno())
                        elif isinstance(ret, StopLoop):
                            return arg
                    elif isinstance(ret, type_gen):
                        self.call_soon(ret)
                    elif ret is None:
                        # Just reschedule
                        pass
                    else:
                        assert False, "Unsupported coroutine yield value: %r (of type %r)" % (
                            ret, type(ret))
                except StopIteration as e:
                    if __debug__:
                        log.debug("Coroutine finished: %s", cb)
                    continue
                self.call_later(delay, cb, *args)
Example #9
0
    def run_forever(self):
        self.idle_us = 0
        t0_ms = pyb.millis()
        while True:
            if self.q:
                t, cnt, cb, args = heapq.heappop(self.q)
                if __debug__:
                    log.debug("Next coroutine to run: %s", (t, cnt, cb, args))


#                __main__.mem_info()
                tnow = self.time()
                delay = t - tnow
                if delay > 0:
                    self.wait(delay)
            else:
                self.wait(-1)
                # Assuming IO completion scheduled some tasks
                continue
            if callable(cb):
                cb(*args)
            else:
                delay = 0
                try:
                    if args == ():
                        args = (None, )
                    if __debug__:
                        log.debug("Coroutine %s send args: %s", cb, args)
                    ret = cb.send(*args)
                    if __debug__:
                        log.debug("Coroutine %s yield result: %s", cb, ret)
                    if isinstance(ret, SysCall):
                        arg = ret.args[0]
                        if isinstance(ret, Sleep):
                            delay = arg
                        elif isinstance(ret, IORead):
                            #                            self.add_reader(ret.obj.fileno(), lambda self, c, f: self.call_soon(c, f), self, cb, ret.obj)
                            #                            self.add_reader(ret.obj.fileno(), lambda c, f: self.call_soon(c, f), cb, ret.obj)
                            self.add_reader(
                                arg.fileno(),
                                lambda cb, f: self.call_soon(cb, f), cb, arg)
                            continue
                        elif isinstance(ret, IOWrite):
                            self.add_writer(
                                arg.fileno(),
                                lambda cb, f: self.call_soon(cb, f), cb, arg)
                            continue
                        elif isinstance(ret, IOReadDone):
                            self.remove_reader(arg.fileno())
                        elif isinstance(ret, IOWriteDone):
                            self.remove_writer(arg.fileno())

                        # EXPERIMENTAL
                        elif isinstance(ret, GetRunningCoro):
                            args = [cb]
                        elif isinstance(ret, GetRunningLoop):
                            args = [self]
                        elif isinstance(ret, BlockUntilDone):
                            if __debug__:
                                log.debug('BlockUntilDone(%s)', repr(ret.args))
                            #if not hasattr(ret.args[0], 'clear_unblocking_callbacks'):
                            #    raise NotImplementedError("BlockUntilDone only on a future")
                            handle = None
                            # assume a Future instance
                            assert hasattr(ret.args[0],
                                           'clear_unblocking_callback')
                            fut = ret.args[0]
                            tl = None
                            if len(ret.args) > 1:
                                timeout = ret.args[1]
                                #if timeout and timeout > 0:
                                if timeout is not None:
                                    tl = []
                                    fto = self.future_timeout_closure(
                                        cb, fut, tl)
                                    #print("fto", fto, end=' ')
                                    handle = self.call_later(timeout, fto)
                            fcb = self.future_callback_closure(cb, handle)
                            #print("fcb", fcb, end=' ')
                            arg.add_unblocking_callback(fcb)
                            #print("ubcbs", arg.ubcbs)
                            if tl is not None:
                                tl.append(fcb)
                            #print("tl", tl)
                            continue
                        # end EXPERIMENTAL

                        elif isinstance(ret, StopLoop):
                            self.d_ms = pyb.elapsed_millis(t0_ms)
                            return arg
                    elif isinstance(ret, type_gen):
                        self.call_soon(ret)
                    elif ret is None:
                        # Just reschedule
                        pass
                    else:
                        assert False, "Unsupported coroutine yield value: %r (of type %r)" % (
                            ret, type(ret))
                except StopIteration as e:
                    if __debug__:
                        log.debug("Coroutine finished: %s", cb)
                    continue
                self.call_later(delay, cb, *args)
Example #10
0
    def dprint(*v):
        pass


# Try not to crash on invalid data
h = []
heapq.heappush(h, 1)
try:
    heapq.heappush(h, 2, True)
    assert False
except TypeError:
    pass

heapq.heappush(h, 2)
try:
    heapq.heappop(h, True)
    assert False
except TypeError:
    pass


def pop_all(h):
    l = []
    while h:
        l.append(heapq.heappop(h, True))
    dprint(l)
    return l


def add(h, v):
    heapq.heappush(h, (v, None), True)
Example #11
0
try:
    import uheapq as heapq
except:
    try:
        import heapq
    except ImportError:
        print("SKIP")
        raise SystemExit

try:
    heapq.heappop([])
except IndexError:
    print("IndexError")

try:
    heapq.heappush((), 1)
except TypeError:
    print("TypeError")

def pop_and_print(h):
    l = []
    while h:
        l.append(str(heapq.heappop(h)))
    print(' '.join(l))

h = []
heapq.heappush(h, 3)
heapq.heappush(h, 1)
heapq.heappush(h, 2)
print(h)
pop_and_print(h)
Example #12
0
def pop_all(h):
    l = []
    while h:
        l.append(heapq.heappop(h, True))
    dprint(l)
    return l
Example #13
0
else:
    def dprint(*v):
        pass

# Try not to crash on invalid data
h = []
heapq.heappush(h, 1)
try:
    heapq.heappush(h, 2, True)
    assert False
except TypeError:
    pass

heapq.heappush(h, 2)
try:
    heapq.heappop(h, True)
    assert False
except TypeError:
    pass


def pop_all(h):
    l = []
    while h:
        l.append(heapq.heappop(h, True))
    dprint(l)
    return l

def add(h, v):
    heapq.heappush(h, (v, None), True)
Example #14
0
def pop_all(h):
    l = []
    while h:
        l.append(heapq.heappop(h, True))
    dprint(l)
    return l
Example #15
0
def pop_and_print(h):
    l = []
    while h:
        l.append(str(heapq.heappop(h)))
    print(' '.join(l))
Example #16
0
def pop_and_print(h):
    l = []
    while h:
        l.append(str(heapq.heappop(h)))
    print(' '.join(l))
Example #17
0
def kmain(server=SERVER):
    global sub_flag, i_pum, i_snd, i_data
    f_snd = 0
    c = MQTTClient(CLIENT_ID, server)
    try:
        hello_i = ESP_init(DATA_TP)
        c.connect()
        c.publish(TOPIC, hello_i, retain=True, qos=1)
        sleep_ms(10)
        c.disconnect()
        sleep_ms(50)
        c.connect()
        c.set_last_will(DATA_TP, b"<Connect_lost>", retain=True, qos=1)
        sleep_ms(10)
        c.publish(DATA_TP, b"<Data_begin>", retain=True, qos=1)
        sleep_ms(10)
        gc.collect()
        while sub_flag != 404:
            foobar = Foo()
            f_snd = 0
            while button.value() != 0 and sub_flag == 100:
                try:
                    if f_snd == 0 or i_pum - i_snd > 60:
                        str_data = uheapq.heappop(i_data)
                    try:
                        c.publish(DATA_TP, str_data, retain=True, qos=1)
                        sleep_ms(10)
                        f_snd = 0
                        i_snd += 1
                    except:
                        f_snd += 1
                        gc.collect()
                        if f_snd > 30:
                            sub_flag = 104
                        else:
                            try:
                                c.connect()
                                sleep_ms(200)
                            except:
                                try:
                                    import boot
                                except:
                                    pass
                                sleep_ms(200)
                                pass
                        pass
                except:
                    i_snd = i_pum
                    sleep_ms(10)
                    pass
            if sub_flag == 104:
                sub_flag = 404
                raise
            sleep_ms(50)
            if button.value() == 0 and sub_flag == 101:
                sleep_ms(2000)
                if button.value() == 0:
                    sub_flag = 100
                    sleep_ms(2000)
            if button.value() == 0 and sub_flag == 100:
                sleep_ms(2000)
                if button.value() == 0:
                    sub_flag = 101
                    sleep_ms(2000)
    except:
        pass
    finally:
        try:
            del foobar
        except:
            pass
        c.publish(DATA_TP, b"<Data_end>", retain=True, qos=1)
        sleep_ms(50)
        c.disconnect()
        raise
Example #18
0
    def get_command(self):
        if len(self.queue):
            return uheapq.heappop(self.queue)

        return None