Table Of Contents

• Clock object
  • Schedule before frame
  • Triggered Events
  • Unscheduling
  • Clock Lifecycle
  • Exception Handling
  • Scheduling from __del__
  • Threading and Callback Order
  • Advanced Clock Details
    • Default Clock
    • Interruptible Clock
    • Free Clock
    • Free Only Clock
    • Summary
  • Async clock support

Объект Clock

Объект Clock позволяет вам планировать вызов функции в будущем; однократно или повторно через указанные интервалы. Вы можете получить время, прошедшее между планированием и вызовом обратного вызова с помощью аргумента dt:

# dt означает дельту времени
def my_callback(dt):
    pass
# вызывать my_callback каждые 0.5 секунды
Clock.schedule_interval(my_callback, 0.5)

# вызвать my_callback через 5 секунд
Clock.schedule_once(my_callback, 5)

# вызвать my_callback как можно скорее (обычно на следующем кадре.)
Clock.schedule_once(my_callback)

Примечание

Если обратный вызов возвращает False, планирование будет отменено и не будет повторяться.

Если вы хотите запланировать вызов функции с использованием аргументов по умолчанию, вы можете использовать модуль Python functools.partial:

from functools import partial

def my_callback(value, key, *largs):
    pass

Clock.schedule_interval(partial(my_callback, 'my value', 'my key'), 0.5)

Наоборот, если вы хотите запланировать вызов функции, которая не принимает аргумент dt, вы можете использовать выражение lambda, чтобы написать короткую функцию, которая принимает dt. Например:

def no_args_func():
    print("Я не принимаю аргументы, поэтому не планируйте мой вызов в часах")

Clock.schedule_once(lambda dt: no_args_func(), 0.5)

Примечание

Вы не можете отменить запланированный анонимный вызов функции, если не сохраните ссылку на него. Лучше всего добавить *args в определение вашей функции, чтобы ее можно было вызывать с произвольным количеством параметров.

Важно

Метод класса callback не сохраняется в слабой ссылке: вы несете ответственность за сохранение ссылки на ваш объект/функцию обратного вызова. Если вы не сохраните ссылку, ClockBase никогда не выполнит ваш обратный вызов. Например:

class Foo(object):
    def start(self):
        Clock.schedule_interval(self.callback, 0.5)

    def callback(self, dt):
        print('В обратном вызове')

# Создается объект Foo, и вызывается метод start.
# Поскольку ссылка на экземпляр, возвращенный из Foo(), не сохраняется,
# объект будет собран сборщиком мусора Python, и
# ваш обратный вызов никогда не будет выполнен.
Foo().start()

# Поэтому вам следует сделать следующее и сохранить ссылку на экземпляр
# foo до тех пор, пока вам он не понадобится!
foo = Foo()
foo.start()

Планирование перед кадром

Добавлено в версии 1.0.5.

Иногда вам нужно запланировать обратный вызов ПЕРЕД следующим кадром. Начиная с версии 1.0.5, вы можете использовать таймаут -1:

Clock.schedule_once(my_callback, 0) # вызвать после следующего кадра
Clock.schedule_once(my_callback, -1) # вызвать перед следующим кадром

Часы выполнит все обратные вызовы с таймаутом -1 перед следующим кадром, даже если вы добавите новый обратный вызов с -1 из выполняющегося обратного вызова. Однако у Clock есть ограничение на количество итераций для этих обратных вызовов: по умолчанию оно равно 10.

Если вы запланировали обратный вызов, который запланировал обратный вызов, который запланировал ... и так далее более 10 раз, он выйдет из цикла и отправит предупреждение на консоль, а затем продолжит после следующего кадра. Это сделано для предотвращения ошибок, которые могут привести к зависанию или аварийному завершению приложения.

Если вам нужно увеличить это ограничение, установите свойство max_iteration:

from kivy.clock import Clock
Clock.max_iteration = 20

События по триггеру

Добавлено в версии 1.0.5.

CyClockBase.create_trigger() - это продвинутый метод отложенного вызова обратного вызова. Он работает точно так же, как и методы CyClockBase.schedule_once() и CyClockBase.schedule_interval(), за исключением того, что он не назначает обратный вызов немедленно. Вместо этого обратный вызов планируется с использованием ClockEvent, возвращенного этим методом. Это гарантирует, что вы можете вызвать событие несколько раз, но оно не будет запланировано более одного раза. Это не относится к методу CyClockBase.schedule_once():

# будет запущен обратный вызов дважды перед следующим кадром
Clock.schedule_once(my_callback)
Clock.schedule_once(my_callback)

# будет запущен обратный вызов один раз перед следующим кадром
event = Clock.create_trigger(my_callback)
event()
event()

# также будет запущен обратный вызов только один раз перед следующим кадром
event = Clock.schedule_once(my_callback)  # теперь он уже запланирован
event()  # не будет запланирован снова
event()

Кроме того, более удобно создавать и связывать с триггером события, чем использовать CyClockBase.schedule_once() в функции:

from kivy.clock import Clock
from kivy.uix.widget import Widget

class Sample(Widget):
    def __init__(self, **kwargs):
        self._trigger = Clock.create_trigger(self.cb)
        super(Sample, self).__init__(**kwargs)
        self.bind(x=self._trigger, y=self._trigger)

    def cb(self, *largs):
        pass

Даже если x и y изменяются в одном кадре, обратный вызов выполняется только один раз.

Отмена планирования

Событие, запланированное с помощью CyClockBase.schedule_once(), CyClockBase.schedule_interval() или с использованием CyClockBase.create_trigger(), а затем вызванное, можно отменить несколькими способами. Например:

def my_callback(dt):
    pass

# вызывать my_callback каждые 0.5 секунды
event = Clock.schedule_interval(my_callback, 0.5)

# вызывать my_callback через 5 секунд
event2 = Clock.schedule_once(my_callback, 5)

event_trig = Clock.create_trigger(my_callback, 5)
event_trig()

# отменить с использованием cancel
event.cancel()

# отменить с использованием Clock.unschedule
Clock.unschedule(event2)

# отменить с использованием Clock.unschedule с обратным вызовом
# НЕ РЕКОМЕНДУЕТСЯ
Clock.unschedule(my_callback)

Самый лучший способ отмены планирования обратного вызова - это использование ClockEvent.cancel(). CyClockBase.unschedule() в основном является псевдонимом для этой функции. Однако, если сам обратный вызов передается в CyClockBase.unschedule(), он будет отменен везде, где используется этот обратный вызов (при условии, что all равно True, что является значением по умолчанию, в противном случае будет удален только первый совпадающий обратный вызов).

Вызывать CyClockBase.unschedule() на исходном обратном вызове крайне не рекомендуется, так как это существенно замедляет выполнение по сравнению с использованием события.

Жизненный цикл Clock

Часы Kivy имеют свой собственный жизненный цикл. По умолчанию планирование обратного вызова после завершения Clock не вызовет ошибку, даже если обратный вызов может так и не быть вызван. Это происходит потому, что большинство обратных вызовов похожи на службы, например, обработка нажатия кнопки пользователем - если приложение работает, то обратные вызовы должны обслуживать приложение и реагировать на ввод, но как только приложение остановлено или завершается, мы можем безопасно игнорировать эти события.

Другие события всегда должны быть обработаны. Например, другой поток может запросить обратный вызов в потоке Kivy и затем обработать некоторый результат. Если событие не обрабатывается в потоке Kivy из-за остановки приложения, второй поток может заблокироваться навсегда, повесив приложение при его завершении.

Следовательно, мы предоставляем API (CyClockBase.create_lifecycle_aware_trigger()) для планирования обратных вызовов, которые вызывают ClockNotRunningError, если часы остановлены. Если планирование выполнено успешно, это гарантирует вызов одного из его обратных вызовов. То есть новый CyClockBase.create_lifecycle_aware_trigger() принимает дополнительный параметр clock_ended_callback. Обычно callback будет вызван, когда событие будет обработано. Но если часы останавливаются до того, как оно будет обработано, если приложение завершено нормально (и приложение было запущено) и событие не было отменено, а также обратные вызовы не подлежат сборке мусора, то вместо этого будет вызван clock_ended_callback, когда часы останавливаются.

То есть, при соблюдении этих условий, если ClockNotRunningError не был вызван при планировании события, то один из этих обратных вызовов будет вызван - либо callback, если событие выполнилось нормально, либо clock_ended_callback, если часы останавливаются во время выполнения события.

По умолчанию события могут быть запланированы до запуска часов, потому что предполагается, что часы будут запущены, когда приложение начнется. То есть вызов CyClockBase.create_lifecycle_aware_trigger() перед запуском часов и приложения будет успешным. Но если приложение никогда на самом деле не запускается, то ни один из обратных вызовов может не быть выполнен.

Добавлено в версии 2.0.0: Жизненный цикл был добавлен в версии 2.0.0

Обработка исключений

Kivy предоставляет менеджер обработки исключений, ExceptionManager, для обработки внутренних исключений, включая исключения, возникающие в обратных вызовах часов, без сбоя приложения. По умолчанию, если возникает исключение, приложение завершится. Однако , если обработчик зарегистрирован в менеджере исключений и обработчик обрабатывает исключение, приложение не завершится и продолжит работу как обычно.

from kivy.base import ExceptionHandler, ExceptionManager
class MyHandler(ExceptionHandler):
    def handle_exception(self, inst):
        if isinstance(inst, ValueError):
            Logger.exception('Ошибка ValueError перехвачена MyHandler')
            return ExceptionManager.PASS
        return ExceptionManager.RAISE

ExceptionManager.add_handler(MyHandler())

Затем все исключения ValueError будут зарегистрированы в консоли и проигнорированы. Аналогично, если запланированный обратный вызов часов вызывает исключение ValueError, другие события часов будут обрабатываться как обычно.

Если обратный вызов события вызывает исключение, до выполнения обработчика исключений, обратный вызов сразу отменяется.

При этом приложение все равно может быть повреждено, если исключение происходит изнутри самого Kivy. То есть даже при наличии обработчика, который игнорирует исключения и не вызывает сбой, приложение может находиться в поврежденном состоянии, если ошибка происходит внутри Kivy. Тем не менее, обработчик исключений может помочь предотвратить аварийное завершение приложения и защитить его от сбоя, вызванного исключениями пользовательских обратных вызовов.

Изменено в версии 2.0.0: До Kivy 2.0.0, исключение, вызванное в обратном вызове события, вызывало аварийное завершение часов, и последующие события могли быть выполнены или не выполнены. Даже если исключение обрабатывалось обработчиком исключений, не было никаких гарантий, что некоторые запланированные события не будут пропущены.

С версии 2.0.0, если исключение события обрабатывается обработчиком исключений, другие события будут защищены от исключения и будут выполняться нормально.

Планирование из метода __del__

Небезопасно планировать события часов из метода __del__ или __dealloc__ объекта. Если необходимо запланировать вызов часов из этого метода, используйте CyClockBase.schedule_del_safe() или CyClockBase.schedule_lifecycle_aware_del_safe() вместо этого.

Потоки и порядок обратных вызовов

Начиная с версии 1.10.0, все события, запланированные на одном и том же кадре, например, все события, запланированные на том же кадре с timeout равным 0, будут выполнены в порядке их запланирования.

Кроме того, все методы планирования и отмены полностью защищены от потоков и могут быть безопасно использованы из внешних потоков.

Как следствие, вызов CyClockBase.unschedule() с исходным обратным вызовом теперь существенно медленнее и крайне не рекомендуется. Вместо этого возвращенные события должны быть использованы для отмены. В обмен на это, все остальные методы теперь выполняются значительно быстрее, чем раньше.

Детали продвинутых часов

Следующий раздел предоставляет внутренние детали часов Kivy, а также различные параметры часов. Этот раздел предназначен только для опытных пользователей.

Фундаментально, часы Kivy пытаются выполнять запланированный обратный вызов ритмично, как определено указанной частотой кадров (frame per second, см. maxfps в config). Идеально, при заданной частоте кадров, например, 30 кадров в секунду, часы будут выполнять обратные вызовы через интервалы 1 / 30 секунды, или каждые 33,33 миллисекунды. Все обратные вызовы в одном кадре имеют одинаковый временной штамп, т.е. переданный обратному вызову параметр dt одинаков для всех и разница во времени между началом текущего и предыдущего кадра.

Из-за внутренней недетерминированности, кадры фактически не происходят точно с интервалами частоты кадров, и dt может быть меньше или больше заданной частоты кадров. Кроме того, когда время ожидания "достаточно близко" к желаемому времени ожидания, как определено внутренне, Kivy выполнит обратный вызов в текущем кадре, даже если "фактическое время" еще не прошло величины timeout.

Начиная с версии 1.10.0, Kivy предлагает несколько типов часов с разным поведением.

Часы по умолчанию

Часы по умолчанию (default) ведут себя как описано выше. Когда запланирован обратный вызов с таймаутом ноль или ненулевым, они выполняются в кадре, который близок к времени ожидания, которое зависит от частоты кадров. Так что таймаут ноль по-прежнему приведет к задержке на один кадр или около 1 / частоты кадров, обычно чуть меньше, но иногда больше, в зависимости от использования CPU других событий, запланированных на этом кадре.

В тесте с частотой кадров 30, обратный вызов с таймаутом 0, 0.001 и 0.05 привел к средней задержке обратного вызова соответственно 0,02487, 0,02488 и 0,05011 секунд, соответственно. При тестировании с частотой кадров 600 задержка для 0,05 была аналогичной, за исключением уменьшения стандартного отклонения, что привело к улучшению общей точности.

Часы с возможностью прерывания

Часы по умолчанию страдают от проблемы квантования, так как кадры происходят только на интервалах, и запланированные тайм-ауты не могут происходить во время интервала. Например, с тайм-аутом 0,05, в то время как среднее значение было 0,05011, его значения варьировались от 0,02548 до 0,07348, а стандартное отклонение составляло 0,002. Кроме того, существует минимальное значение тайм-аута около 0,02487.

Часы с возможностью прерывания (interrupt) будут выполнять тайм-ауты даже во время кадра. Так что тайм-аут ноль будет выполняться как можно быстрее, и так же ненулевой тайм-аут будет выполняться даже во время интервала.

У этого часов, и всех часов, описанных ниже, есть параметр ClockBaseInterruptBehavior.interupt_next_only. Когда он равен True, новое поведение будет применяться только к обратным вызовам с таймаутом ноль. Ненулевые тайм-ауты будут вести себя так же, как в часах по умолчанию. Например, для этих часов, когда True, только тайм-ауты ноль будут выполняться во время интервала.

В тесте с частотой кадров 30, обратный вызов с таймаутом 0, 0.001 и 0.05 привел к средней задержке обратного вызова соответственно 0,00013, 0,00013 и 0,04120 секунд, когда параметр ClockBaseInterruptBehavior.interupt_next_only был равен False. Кроме того, по сравнению с часами по умолчанию, стандартное отклонение было уменьшено. Когда параметр ClockBaseInterruptBehavior.interupt_next_only был равен True, значения были 0,00010, 0,02414 и 0,05034, соответственно.

Свободные часы

Часы с возможностью прерывания могут быть не идеальными для всех случаев, потому что все события выполняются во время интервалов, и события больше не выполняются ритмично в кратные частоте кадров. Например, нет никакой пользы в том, чтобы обновлять графику в суб-интервале, поэтому дополнительная точность теряется на CPU.

Свободные часы (free_all) решают эту проблему, предоставляя версии методов планирования событий Clock.xxx_free для всех методов планирования Clock. Под свободными событиями мы понимаем события, которые не ограничены частотой кадров, потому что они не ограничены частотой кадров. Например, CyClockBaseFree.create_trigger_free() соответствует CyClockBase.create_trigger(). Только когда событие, запланированное с использованием методов Clock.xxx_free, присутствует, часы будут прерывать и выполнять события во время интервала. Итак, если события free отсутствуют, часы ведут себя как часы по умолчанию, в противном случае они ведут себя как часы с возможностью прерывания.

В тесте с частотой кадров 30, обратный вызов с таймаутом 0с, 0,001с и 0,05с привел к средней задержке обратного вызова соответственно 0,00012с, 0,00017с и 0,04121с секунд, когда это было свободное событие, и 0,02403с, 0,02405с и 0,04829с соответственно, когда его не было.

Только свободные часы

Свободные часы выполняют все события, когда было запланировано свободное событие. Это приводит к тому, что обычные события также выполняются в середине интервала, когда запланировано свободное событие. Например, вышеуказанный тест, когда свободное событие отсутствовало, обычное событие с таймаутом 0,001с было задержано на 0,02405с. Однако, если случайно было запланировано свободное событие, обычное событие было задержано всего на 0,00014с, что может быть нежелательным.

Только свободные часы (free_only) решают эту проблему, выполняя только свободные события во время интервала, и обычные события всегда выполняются, как и в случае часов по умолчанию. Например, при наличии свободного события, обычное событие с таймаутом 0,001с по-прежнему имело задержку 0,02406. Так что эти часы обрабатывают свободные и обычные события независимо друг от друга, при этом обычные события всегда ограничены частотой кадров, но никогда не ограничивают свободные события.

Резюме

Тип часов Kivy можно установить с помощью параметра kivy_clock в config. Если KIVY_CLOCK присутствует в среде, он переопределит выбор параметра конфигурации. Его возможные значения следующие:

• Когда kivy_clock равен default, используются обычные часы, ClockBase, которые ограничивают обратные вызовы квантованием до maxfps.

• Когда kivy_clock равен interrupt, используются часы с возможностью прерывания, ClockBaseInterrupt, которые не ограничивают обратные вызовы квантованием до maxfps. Обратные вызовы будут выполняться в любое время.

• Когда kivy_clock равен free_all, используются часы с возможностью прерывания, ClockBaseFreeInterruptAll, которые не ограничивают обратные вызовы квантованием до maxfps в присутствии свободных событий, но в их отсутствие они ограничивают события интервалом квантования fps.

• Когда kivy_clock равен free_only, используются часы с возможностью прерывания, ClockBaseFreeInterruptAll, которые обрабатывают свободные и обычные события независимо друг от друга; обычные события всегда ограничены частотой кадров, но свободные события — нет.

Поддержка асинхронных часов

Добавлено в версии 2.0.0.

Экспериментальная поддержка асинхронных операций была добавлена в версии 2.0.0. Теперь в часах есть ClockBaseBehavior.async_tick() и ClockBaseBehavior.async_idle() методы корутины, которые используются EventLoop в Kivy, когда EventLoop выполняется асинхронно. При использовании их, часы Kivy не блокируются во время простоя.

Библиотека асинхронных операций выбирается с помощью переменной окружения KIVY_EVENTLOOP или путем вызова init_async_lib() напрямую. В качестве библиотеки может быть указано значение “asyncio”, если следует использовать стандартную библиотеку asyncio, или “trio”, если следует использовать библиотеку Trio. Если не установлено, по умолчанию используется “asyncio”.

См. app для примера использования.

kivy.clock.Clock: kivy.clock.ClockBase = None

Экземпляр часов Kivy. См. документацию модуля для получения подробной информации.

class kivy.clock.ClockBase(**kwargs)

Основа стандартных часов Kivy. См. документацию модуля для получения подробной информации.

usleep(микросекунды)

Приостанавливает выполнение на указанное количество микросекунд.

class kivy.clock.ClockBaseBehavior(async_lib='asyncio', **kwargs)

Базовый класс: builtins.object

Основа часов Kivy.

Parameters

async_lib: string

Библиотека асинхронных операций, которую следует использовать при асинхронном выполнении часов. Может быть одним из значений: “asyncio”, если следует использовать стандартную библиотеку asyncio, или “trio”, если следует использовать библиотеку Trio.

По умолчанию используется ‘asyncio’ или значение из переменной окружения KIVY_EVENTLOOP, если она установлена. Можно также вызвать init_async_lib() напрямую для установки библиотеки.

MIN_SLEEP = 0.005

Минимальное время ожидания. Если оставшееся время меньше этого значения, цикл событий продолжает выполнение.

async async_idle()

(внутренний) асинхронная версия метода idle().

async async_tick()

Асинхронная версия метода tick().

property frames

Количество внутренних кадров (не обязательно отрисованных) с начала работы часов.

Добавлено в версии 1.8.0.

property frames_displayed

Количество отображенных кадров с начала работы часов.

property frametime

Время, затраченное между последним и текущим кадром (в секундах).

Добавлено в версии 1.8.0.

get_boottime()

Получить время в секундах с момента запуска приложения.

get_fps()

Получить текущее среднее значение FPS, рассчитанное часами.

get_rfps()

Получить текущий "реальный" FPS, рассчитанный часами. Этот счетчик отражает реальную частоту кадров, отображаемую на экране.

В отличие от функции get_fps(), эта функция возвращает счетчик количества кадров, а не среднее значение кадров в секунду.

get_time()

Получить последний тик, сделанный часами.

idle()

(внутренний) ждет здесь до следующего кадра.

init_async_lib(lib)

Вручную устанавливает внутреннюю асинхронную библиотеку для использования при выполнении асинхронным образом.

Это можно вызывать в любое время до запуска событийного цикла Kivy, но не после запуска приложения Kivy.

Parameters

lib: string

Асинхронная библиотека, которую следует использовать при асинхронном выполнении часов. Может быть одной из следующих: “asyncio”, когда следует использовать стандартную библиотеку asyncio, или “trio”, если следует использовать библиотеку trio.

post_idle(ts, current)

Вызывается после idle() с помощью tick().

pre_idle()

Вызывается перед idle() с помощью tick().

tick()

Продвигает часы до следующего шага. Должно вызываться на каждом кадре. Встроенные часы имеют функцию tick(), вызываемую ядром Kivy по умолчанию.

tick_draw()

Увеличивает счетчик рисования.

static time()

Метод-прокси для clock().

usleep(microseconds)

Засыпает на указанное количество микросекунд.

class kivy.clock.ClockBaseFreeInterruptAll(**kwargs)

Базовый класс: kivy.clock.ClockBaseInterruptFreeBehavior, kivy._clock.CyClockBaseFree

Часы Kivy с отключенной поддержкой прерываний. См. модуль для деталей.

class kivy.clock.ClockBaseFreeInterruptOnly(**kwargs)

Базовый класс: kivy.clock.ClockBaseInterruptFreeBehavior, kivy._clock.CyClockBaseFree

Часы Kivy с отключенными прерываниями. См. модуль для деталей.

async async_idle()

(внутренний) Асинхронная версия метода idle().

idle()

(внутренний) Ожидание до следующего кадра.

class kivy.clock.ClockBaseInterrupt(interupt_next_only=False, **kwargs)

Базовый класс: kivy.clock.ClockBaseInterruptBehavior, kivy._clock.CyClockBase

Часы Kivy с прерываниями. См. модуль для деталей.

class kivy.clock.ClockBaseInterruptBehavior(interupt_next_only=False, **kwargs)

Базовый класс: kivy.clock.ClockBaseBehavior

Часы Kivy, которые могут быть прерваны во время кадра для выполнения событий.

async async_idle()

(внутренний) Асинхронная версия метода idle().

idle()

(внутренний) Ожидание до следующего кадра.

init_async_lib(lib)

Вручную устанавливает библиотеку асинхронного выполнения, которую следует использовать внутренне при выполнении асинхронно.

Это можно вызвать в любое время до запуска цикла событий Kivy, но не после запуска приложения Kivy.

Parameters

lib: string

Библиотека асинхронного выполнения, которую следует использовать, когда часы работают в асинхронном режиме. Может быть одним из: “asyncio”, когда следует использовать стандартную библиотеку asyncio или “trio”, если следует использовать библиотеку trio.

usleep(microseconds)

Спит указанное количество микросекунд.

class kivy.clock.ClockBaseInterruptFreeBehavior(**kwargs)

Базовый класс: kivy.clock.ClockBaseInterruptBehavior

Базовый класс для часов, прерывающих интервал сна для свободных событий.

class kivy.clock.ClockEvent(CyClockBase clock, int loop, callback, double timeout, double starttime, cid=None, int trigger=False, clock_ended_callback=None, release_ref=True, **kwargs)

Базовый класс: builtins.object

Этот класс никогда не создается пользователем; вместо этого Kivy создает и возвращает экземпляр этого класса при планировании обратного вызова.

Событие можно запланировать (вызвать) путем его вызова. Если оно уже запланировано, ничего не произойдет, в противном случае оно будет запланировано. Например:

event = Clock.schedule_once(my_callback, .5)
event()  # ничего не произойдет, так как оно уже запланировано.
event.cancel()  # отменить его
event()  # теперь оно снова запланировано.

callback

callback: объект

cancel()

Отменяет обратный вызов, если он был запланирован для вызова. Если не запланировано, ничего не происходит.

cid

cid: объект

clock

clock: kivy._clock.CyClockBase Экземпляр CyClockBase, связанный с событием.

clock_ended_callback

clock_ended_callback: объект Дополнительный обратный вызов для этого события, который будет вызван часами

когда часы остановлены, и событие не было вызвано.

get_callback()

Возвращает обратный вызов, связанный с событием. Обратные вызовы сохраняются с опосредованной ссылкой, чтобы они не удерживали объекты в живых. Если обратный вызов "мертв", возвращается None.

get_clock_ended_callback()

Возвращает связанный с событием обратный вызов clock_ended_callback. Обратные вызовы хранятся с опосредованной ссылкой, чтобы они не удерживали объекты в живых. Если обратный вызов "мертв" или не был предоставлен, возвращается None.

is_triggered()

Возвращает, запланировано ли событие для выполнения обратного вызова потоком Kivy.

loop

loop: ‘int’ Определяет, повторяется ли это событие через интервалы timeout.

next

next: kivy._clock.ClockEvent Следующее ClockEvent в порядке их запланированного выполнения.

prev

prev: kivy._clock.ClockEvent Предыдущее ClockEvent в порядке их запланированного выполнения.

release()

(внутренний метод) Преобразует обратный вызов в опосредованную ссылку.

release_ref

release_ref: ‘int’ Если True, событие никогда не должно освобождать ссылку на обратные вызовы.

Если False, вместо этого может быть создана слабая ссылка.

tick(double curtime)

(внутренний метод) Обрабатывает событие для потока Kivy.

timeout

timeout: ‘double’ Продолжительность после запланирования, когда должен быть выполнен обратный вызов.

weak_callback

weak_callback: объект

weak_clock_ended_callback

weak_clock_ended_callback: объект

exception kivy.clock.ClockNotRunningError

Базовый класс: RuntimeError

Возникает при использовании таймера Kivy, если таймер уже завершился (был вызван метод stop_clock).

class kivy.clock.CyClockBase(**kwargs)

Базовый класс: builtins.object

clock_resolution

clock_resolution: ‘double’ Если оставшееся время до завершения события меньше clock_resolution,

часы выполнения выполнит обратный вызов, даже если истекло точное время. Если -1, по умолчанию, разрешение будет вычислено из maxfps в конфигурации. В противном случае будет использовано предоставленное значение. По умолчанию -1.

create_lifecycle_aware_trigger(callback, clock_ended_callback, timeout=0, interval=False, release_ref=True) → ClockEvent

Создать событие триггера аналогично create_trigger(), но событие чувствительно к состоянию часов.

Если это событие вызывается после остановки часов (stop_clock()), то будет поднято исключение ClockNotRunningError. Если исключение не поднимается, то будет вызвано либо callback, либо clock_ended_callback. callback будет вызван, когда событие обычно выполняется. Если часы остановлены до его выполнения, при условии, что приложение вышло нормально без сбоев и событие не было вручную отменено, и обратные вызовы не были удалены сборщиком мусора, то вместо этого будет вызван clock_ended_callback, когда часы останавливаются.

Parameters

callback: callable

Обратный вызов для выполнения в Kivy. Он принимает один параметр - текущее прошедшее время Kivy.

clock_ended_callback: callable

Обратный вызов, который будет вызван, если часы остановлены, когда событие все еще запланировано для вызова. Обратный вызов принимает один параметр - объект события. Когда событие успешно запланировано, если приложение вышло нормально, и событие не было отменено, и обратные вызовы не были удалены сборщиком мусора - гарантируется, что либо callback, либо clock_ended_callback будет вызван.

timeout: float

Сколько времени ждать перед вызовом обратного вызова.

interval: bool

Должен ли обратный вызов быть вызван один раз (False) или повторно с интервалом timeout (True), как schedule_interval().

release_ref: bool

Если True, по умолчанию, то если callback или clock_ended_callback является методом класса и объект не имеет на него ссылок, то объект может быть собран сборщиком мусора и обратные вызовы не будут вызваны. Если False, часы сохраняют ссылку на объект, предотвращая его сборка мусора - поэтому он будет вызван.

Returns

Экземпляр ClockEvent. Чтобы запланировать обратный вызов этого экземпляра, вы можете его вызвать.

Добавлено в версии 2.0.0.

create_trigger(callback, timeout=0, interval=False, release_ref=True) → ClockEvent

Создать событие триггера. Оно потокобезопасно, но не __del__ или безопасно для __dealloc__ (см. schedule_del_safe()). Для получения дополнительной информации см. документацию к модулю.

Чтобы отменить событие до его выполнения, вызовите ClockEvent.cancel() на возвращенном событии. Для повторного запуска его просто вызовите (с помощью event()) и оно будет безопасно перепланировано, если оно еще не запланировано.

Parameters

callback: callable

Обратный вызов для выполнения из Kivy. Принимает один параметр - текущее прошедшее время Kivy.

timeout: float

Сколько времени ждать перед вызовом обратного вызова.

interval: bool

Должен ли обратный вызов быть вызван один раз (False) или повторно с интервалом timeout (True), как schedule_interval().

release_ref: bool

Если True, по умолчанию, то если callback является методом класса и объект не имеет на него ссылок, то объект может быть собран сборщиком мусора и обратные вызовы не будут вызваны. Если False, часы сохраняют ссылку на объект, предотвращая его сборка мусора - поэтому он будет вызван.

Returns

Экземпляр ClockEvent. Чтобы запланировать обратный вызов этого экземпляра, вы можете его вызвать.

Добавлено в версии 1.0.5.

Изменено в версии 1.10.0: добавлена опция interval.

Изменено в версии 2.0.0: добавлена опция release_ref.

get_before_frame_events()

Возвращает список экземпляров ClockEvent, запланированных для вызова перед следующим кадром (с таймаутом -1).

Добавлено в версии 2.1.0.

get_events()

Возвращает список экземпляров ClockEvent, в настоящее время запланированных.

get_min_timeout()

Возвращает оставшееся время с начала текущего кадра для события с самым коротким таймаутом.

get_resolution()

Returns the minimum resolution the clock has. It’s a function of clock_resolution and maxfps provided at the config.

handle_exception(e)

Предоставляет возможность обработать исключение события.

По желанию исключение обрабатывается, в противном случае оно должно быть возбуждено снова. По умолчанию оно снова возбуждается.

Parameters

e – Исключение, которое должно быть обработано.

Добавлено в версии 2.0.0.

has_ended

has_ended: ‘int’

has_started

has_started: ‘int’

max_iteration

max_iteration: ‘int’ Максимальное количество итераций обратного вызова в конце кадра, перед следующим

кадром. Если произойдет больше итераций, будет выдано предупреждение.

on_schedule(event)

Функция, которая вызывается внутренне каждый раз, когда событие запускается для этого часов. Она принимает событие в качестве параметра.

Порядок вызовов on_schedule не гарантируется быть в том же порядке, в котором события запланированы. Также возможно, что событие, которое запланировано, было отменено до того, как оно было вызвано для события. Это потому, что on_schedule() может вызываться из разных потоков.

schedule_del_safe(callback)

Запланировать обратный вызов, который является потокобезопасным и безопасным для __del__ или __dealloc__.

Небезопасно вызывать различные виды кода из методов __del__ или __dealloc__, поскольку они могут выполняться в любое время. Большинство методов Kivy Clock небезопасно вызывать из этих методов. Вместо этого используйте этот метод, который является потокобезопасным и безопасным для __del__ или __dealloc__, для планирования обратного вызова в потоке Kivy. Он будет выполнен после обработки нормальных событий.

Parameters

callback: func

Обратный вызов для выполнения из Kivy. Он не принимает параметров и не может быть отменен.

Добавлено в версии 1.11.0.

schedule_interval(callback, timeout) → ClockEvent

Запланировать событие для вызова каждые <timeout> секунд. См. create_trigger() для более продвинутого планирования и дополнительных подробностей.

Чтобы отменить событие перед его выполнением, вызовите ClockEvent.cancel() на возвращенном событии. Если обратный вызов является методом класса, создается слабая ссылка на объект и он может быть собран сборщиком мусора, если нет других ссылок на объект.

Returns

Экземпляр ClockEvent. В отличие от create_trigger(), который только создает событие-триггер, этот метод также планирует его выполнение.

schedule_lifecycle_aware_del_safe(callback, clock_ended_callback)

Запланировать обратный вызов, который является потокобезопасным и безопасным для __del__ или __dealloc__ аналогично методу schedule_del_safe(), но обратный вызов чувствителен к состоянию часов.

Если это событие срабатывает после остановки часов (stop_clock()), то будет вызвано исключение ClockNotRunningError. Если исключение не вызывается, то будет вызван либо callback, либо clock_ended_callback. callback будет вызван, когда обратный вызов нормально выполняется. Если часы остановлены до его выполнения, при условии, что приложение завершено нормально и не вышло из строя, вместо этого будет вызван clock_ended_callback, когда часы останавливаются.

Parameters

callback: func

Обратный вызов для выполнения из Kivy. Он не принимает параметров и не может быть отменен.

clock_ended_callback: callable

Обратный вызов, который будет вызван, если часы остановлены, когда обратный вызов все еще запланирован для вызова. Обратный вызов принимает один параметр - обратный вызов. Если приложение завершено нормально, гарантируется, что будет вызван либо callback, либо clock_ended_callback.

Добавлено в версии 2.0.0.

schedule_once(callback, timeout=0) → ClockEvent

Запланировать событие через <timeout> секунд. Если <timeout> не указан или равен 0, обратный вызов будет вызван после следующего кадра. См. create_trigger() для продвинутого планирования и дополнительных подробностей.

Чтобы отменить событие перед его выполнением, вызовите ClockEvent.cancel() на возвращенном событии. Если обратный вызов является методом класса, создается слабая ссылка на объект и он может быть собран сборщиком мусора, если нет других ссылок на объект.

Returns

Экземпляр ClockEvent. В отличие от create_trigger(), который только создает событие-триггер, этот метод также планирует его выполнение.

Изменено в версии 1.0.5: Если timeout равен -1, обратный вызов будет вызван до следующего кадра (в tick_draw()).

start_clock()

Должен быть вызван для запуска часов.

После вызова stop_clock() его нельзя снова запустить.

stop_clock()

Останавливает часы и выполняет очистку.

Этот метод должен быть вызван для обработки колбеков, связанных с жизненным циклом и т. д.

unschedule(callback, all=True)

Удаляет ранее запланированное событие.

Событие ClockEvent также можно отменить напрямую, вызвав ClockEvent.cancel().

Parameters

callback: ClockEvent или func.

Если это экземпляр ClockEvent, то связанный с ним колбек будет отменен, если он был запланирован.

Если это вызываемая функция, то она будет отменена, если была запланирована.

Предупреждение

Передача функции обратного вызова, а не возвращенного ClockEvent, приведет к значительно медленному отменению.

all: bool

Если True и если callback является вызываемой функцией, то все экземпляры этой вызываемой функции будут отменены (т. е. если эта функция была запланирована несколько раз). Значение по умолчанию - True.

Изменено в версии 1.9.0: Добавлен параметр all. Ранее он вел себя так, как если бы all было True.

class kivy.clock.CyClockBaseFree

Базовый класс: kivy._clock.CyClockBase

Класс часов, поддерживающий планирование свободных событий, в дополнение к обычным событиям.

Для каждого из методов create_trigger(), schedule_once() и schedule_interval(), которые создают обычное событие, существует соответствующий метод для создания свободного события.

create_lifecycle_aware_trigger(callback, clock_ended_callback, timeout=0, interval=False, release_ref=True) → FreeClockEvent

create_lifecycle_aware_trigger_free(callback, clock_ended_callback, timeout=0, interval=False, release_ref=True) → FreeClockEvent

Аналогично методу create_lifecycle_aware_trigger(), но создает свободное событие.

create_trigger(callback, timeout=0, interval=False, release_ref=True) → FreeClockEvent

create_trigger_free(callback, timeout=0, interval=False, release_ref=True) → FreeClockEvent

Аналогично методу create_trigger(), но создает свободное событие.

get_min_free_timeout()

Возвращает оставшееся время с начала текущего кадра для свободного события с наименьшим временем ожидания.

schedule_interval(callback, timeout) → FreeClockEvent

schedule_interval_free(callback, timeout) → FreeClockEvent

Аналогично методу schedule_interval(), но создает свободное событие.

schedule_once(callback, timeout=0) → FreeClockEvent

schedule_once_free(callback, timeout=0) → FreeClockEvent

Аналогично методу schedule_once(), но создает свободное событие.

class kivy.clock.FreeClockEvent(free, *largs, **kwargs)

Базовый класс: kivy._clock.ClockEvent

CyClockBaseFree. Хранит информацию о том, было ли событие запланировано как свободное событие.

free

free: ‘int’ Показывает, было ли это событие запланировано как свободное событие.

kivy.clock.mainthread(func)

Декоратор, который запланирует вызов функции на следующем доступном кадре в главном потоке. Это может быть полезно, когда вы используете UrlRequest или при выполнении программы в потоке. Обратите внимание, что эта функция будет возвращать управление немедленно, и результат не будет возвращен:

@mainthread
def callback(self, *args):
    print('The request succeeded!',
          'This callback is called in the main thread.')


self.req = UrlRequest(url='http://...', on_success=обработка)

Добавлено в версии 1.8.0.

kivy.clock.triggered(timeout=0, interval=False)

Декоратор, который запланирует вызов функции через указанный таймаут с использованием метода CyClockBase.create_trigger(). Последующие вызовы функции с декоратором (пока таймаут активен) игнорируются.

Это может быть полезно, когда дорогостоящая функция (например, вызов сервера) может быть запланирована разными методами. Установка соответствующего таймаута отсрочит вызов и выполнится только один раз.

@triggered(timeout, interval=False) def callback(id):

print(‘The callback has been called with id=%d’ % id)

>> callback(id=1) >> callback(id=2) The callback has been called with id=2

Вызванную функцию можно также отменить:

>> callback.cancel()

Добавлено в версии 1.10.1.

« Cache manager

Compatibility module for Python 2.7 and >= 3.4 »