rupython 1.2.12__py3-none-any.whl → 1.2.14__py3-none-any.whl

rupython//342/225/250/320/254/342/225/250/342/225/233/342/225/250/342/224/244/342/225/244/320/223/342/225/250/342/225/227/342/225/250/342/225/225//342/225/250/320/254/342/225/250/342/226/221/342/225/244/320/222/342/225/250/342/225/241/342/225/250/342/225/235.py

@@ -3,8 +3,8 @@ import math
 Пи = math.pi
 e = math.e
 Тау = math.tau
-Бскн = math.inf
-НеЧ = math.nan
+Бесконечность = math.inf
+Не_число = math.nan
 
 def Сочетаний(n, k): return math.comb(n, k)
 def Перестановок(n, k): return math.perm(n, k)
@@ -12,8 +12,8 @@ def Факториал(n): return math.factorial(n)
 def НОД(*целые): return math.gcd(*целые)
 def НОК(*целые): return math.lcm(*целые)
 def ЦелКвКорень(n): return math.isqrt(n)
-def БольшЦел(x): return math.ceil(x)
-def МеньшЦел(x): return math.floor(x)
+def ЦелВверх(x): return math.ceil(x)
+def ЦелВниз(x): return math.floor(x)
 def Модуль(x): return math.fabs(x)
 def УмножСлож(x, y, z): return math.fma(x, y, z)
 def Остаток(x, y): return math.fmod(x, y)

rupython//342/225/250/320/254/342/225/250/342/225/233/342/225/250/342/224/244/342/225/244/320/223/342/225/250/342/225/227/342/225/250/342/225/225//342/225/250/320/256/342/225/244/320/227/342/225/250/342/225/241/342/225/244/320/220/342/225/250/342/225/241/342/225/250/342/224/244/342/225/244/320/234.py

@@ -18,160 +18,160 @@ from rupython import __Общие_функции__
 }
 
 class Очередь:
-    def __init__(здесь, максимальный_размер = 0):
+    def __init__(экземпляр, максимальный_размер = 0):
         kwargs = {'maxsize': максимальный_размер}
-        здесь._queue = queue.Queue(**kwargs)
+        экземпляр._queue = queue.Queue(**kwargs)
 
-    def Добавить(здесь, элемент, блоковать = True, таймаут = None):
+    def Добавить(экземпляр, элемент, блоковать = True, таймаут = None):
         kwargs = {'item': элемент, 'block': блоковать}
         if таймаут is not None:
             kwargs['timeout'] = таймаут
-        здесь._queue.put(**kwargs)
+        экземпляр._queue.put(**kwargs)
 
-    def Добавить_без_блокования(здесь, элемент):
-        здесь._queue.put_nowait(элемент)
+    def Добавить_без_блокования(экземпляр, элемент):
+        экземпляр._queue.put_nowait(элемент)
 
-    def Получить(здесь, блоковать = True, таймаут = None):
+    def Получить(экземпляр, блоковать = True, таймаут = None):
         kwargs = {'block': блоковать}
         if таймаут is not None:
             kwargs['timeout'] = таймаут
-        return здесь._queue.get(**kwargs)
+        return экземпляр._queue.get(**kwargs)
 
-    def Получить_без_блокования(здесь):
-        return здесь._queue.get_nowait()
+    def Получить_без_блокования(экземпляр):
+        return экземпляр._queue.get_nowait()
 
-    def Задача_выполнена(здесь):
-        здесь._queue.task_done()
+    def Задача_выполнена(экземпляр):
+        экземпляр._queue.task_done()
 
-    def Ждать_завершения(здесь):
-        здесь._queue.join()
+    def Ждать_завершения(экземпляр):
+        экземпляр._queue.join()
 
-    def Пустая(здесь):
-        return здесь._queue.empty()
+    def Пустая(экземпляр):
+        return экземпляр._queue.empty()
 
-    def Полная(здесь):
-        return здесь._queue.full()
+    def Полная(экземпляр):
+        return экземпляр._queue.full()
 
-    def Размер(здесь):
-        return здесь._queue.qsize()
+    def Размер(экземпляр):
+        return экземпляр._queue.qsize()
 
-    def __len__(здесь):
-        return здесь._queue.qsize()
+    def __len__(экземпляр):
+        return экземпляр._queue.qsize()
 
-    def __str__(здесь):
-        размер = здесь.Размер()
+    def __str__(экземпляр):
+        размер = экземпляр.Размер()
         return f"Очередь с {__Общие_функции__.Склонение_после_числительного(размер, Словарь_склонений['элемент'])}"
 
-    def В_строку_с_задачами(здесь):
-        размер = здесь.Размер()
+    def В_строку_с_задачами(экземпляр):
+        размер = экземпляр.Размер()
         return f"Очередь с {__Общие_функции__.Склонение_после_числительного(размер, Словарь_склонений['задача'])}"
 
 class Стековая_очередь:
-    def __init__(здесь, максимальный_размер = 0):
+    def __init__(экземпляр, максимальный_размер = 0):
         kwargs = {'maxsize': максимальный_размер}
-        здесь._queue = queue.LifoQueue(**kwargs)
+        экземпляр._queue = queue.LifoQueue(**kwargs)
 
-    def Добавить(здесь, элемент, блоковать = True, таймаут = None):
+    def Добавить(экземпляр, элемент, блоковать = True, таймаут = None):
         kwargs = {'item': элемент, 'block': блоковать}
         if таймаут is not None:
             kwargs['timeout'] = таймаут
-        здесь._queue.put(**kwargs)
+        экземпляр._queue.put(**kwargs)
 
-    def Добавить_без_блокования(здесь, элемент):
-        здесь._queue.put_nowait(элемент)
+    def Добавить_без_блокования(экземпляр, элемент):
+        экземпляр._queue.put_nowait(элемент)
 
-    def Получить(здесь, блоковать = True, таймаут = None):
+    def Получить(экземпляр, блоковать = True, таймаут = None):
         kwargs = {'block': блоковать}
         if таймаут is not None:
             kwargs['timeout'] = таймаут
-        return здесь._queue.get(**kwargs)
+        return экземпляр._queue.get(**kwargs)
 
-    def Получить_без_блокования(здесь):
-        return здесь._queue.get_nowait()
+    def Получить_без_блокования(экземпляр):
+        return экземпляр._queue.get_nowait()
 
-    def Задача_выполнена(здесь):
-        здесь._queue.task_done()
+    def Задача_выполнена(экземпляр):
+        экземпляр._queue.task_done()
 
-    def Ждать_завершения(здесь):
-        здесь._queue.join()
+    def Ждать_завершения(экземпляр):
+        экземпляр._queue.join()
 
-    def Пустая(здесь):
-        return здесь._queue.empty()
+    def Пустая(экземпляр):
+        return экземпляр._queue.empty()
 
-    def Полная(здесь):
-        return здесь._queue.full()
+    def Полная(экземпляр):
+        return экземпляр._queue.full()
 
-    def Размер(здесь):
-        return здесь._queue.qsize()
+    def Размер(экземпляр):
+        return экземпляр._queue.qsize()
 
-    def __len__(здесь):
-        return здесь._queue.qsize()
+    def __len__(экземпляр):
+        return экземпляр._queue.qsize()
 
-    def __str__(здесь):
-        размер = здесь.Размер()
+    def __str__(экземпляр):
+        размер = экземпляр.Размер()
         return f"Стековая_очередь с {__Общие_функции__.Склонение_после_числительного(размер, Словарь_склонений['элемент'])}"
 
-    def В_строку_с_задачами(здесь):
-        размер = здесь.Размер()
+    def В_строку_с_задачами(экземпляр):
+        размер = экземпляр.Размер()
         return f"Стековая_очередь с {__Общие_функции__.Склонение_после_числительного(размер, Словарь_склонений['задача'])}"
 
 class Приоритетная_очередь:
-    def __init__(здесь, максимальный_размер = 0):
+    def __init__(экземпляр, максимальный_размер = 0):
         kwargs = {'maxsize': максимальный_размер}
-        здесь._queue = queue.PriorityQueue(**kwargs)
+        экземпляр._queue = queue.PriorityQueue(**kwargs)
 
-    def Добавить(здесь, элемент, приоритет, блоковать = True, таймаут = None):
+    def Добавить(экземпляр, элемент, приоритет, блоковать = True, таймаут = None):
         kwargs = {'item': (приоритет, элемент), 'block': блоковать}
         if таймаут is not None:
             kwargs['timeout'] = таймаут
-        здесь._queue.put(**kwargs)
+        экземпляр._queue.put(**kwargs)
 
-    def Добавить_без_блокования(здесь, элемент, приоритет):
-        здесь._queue.put_nowait((приоритет, элемент))
+    def Добавить_без_блокования(экземпляр, элемент, приоритет):
+        экземпляр._queue.put_nowait((приоритет, элемент))
 
-    def Получить(здесь, блоковать = True, таймаут = None):
+    def Получить(экземпляр, блоковать = True, таймаут = None):
         kwargs = {'block': блоковать}
         if таймаут is not None:
             kwargs['timeout'] = таймаут
-        приоритет, элемент = здесь._queue.get(**kwargs)
+        приоритет, элемент = экземпляр._queue.get(**kwargs)
         return элемент
 
-    def Получить_с_приоритетом(здесь, блоковать = True, таймаут = None):
+    def Получить_с_приоритетом(экземпляр, блоковать = True, таймаут = None):
         kwargs = {'block': блоковать}
         if таймаут is not None:
             kwargs['timeout'] = таймаут
-        return здесь._queue.get(**kwargs)
+        return экземпляр._queue.get(**kwargs)
 
-    def Получить_без_блокования(здесь):
-        приоритет, элемент = здесь._queue.get_nowait()
+    def Получить_без_блокования(экземпляр):
+        приоритет, элемент = экземпляр._queue.get_nowait()
         return элемент
 
-    def Получить_без_блокования_с_приоритетом(здесь):
+    def Получить_без_блокования_с_приоритетом(экземпляр):
         """Возвращает кортеж (приоритет, элемент)."""
-        return здесь._queue.get_nowait()
+        return экземпляр._queue.get_nowait()
 
-    def Задача_выполнена(здесь):
-        здесь._queue.task_done()
+    def Задача_выполнена(экземпляр):
+        экземпляр._queue.task_done()
 
-    def Ждать_завершения(здесь):
-        здесь._queue.join()
+    def Ждать_завершения(экземпляр):
+        экземпляр._queue.join()
 
-    def Пустая(здесь):
-        return здесь._queue.empty()
+    def Пустая(экземпляр):
+        return экземпляр._queue.empty()
 
-    def Полная(здесь):
-        return здесь._queue.full()
+    def Полная(экземпляр):
+        return экземпляр._queue.full()
 
-    def Размер(здесь):
-        return здесь._queue.qsize()
+    def Размер(экземпляр):
+        return экземпляр._queue.qsize()
 
-    def __len__(здесь):
-        return здесь._queue.qsize()
+    def __len__(экземпляр):
+        return экземпляр._queue.qsize()
 
-    def __str__(здесь):
-        размер = здесь.Размер()
+    def __str__(экземпляр):
+        размер = экземпляр.Размер()
         return f"Приоритетная_очередь с {__Общие_функции__.Склонение_после_числительного(размер, Словарь_склонений['элемент'])}"
 
-    def В_строку_с_задачами(здесь):
-        размер = здесь.Размер()
+    def В_строку_с_задачами(экземпляр):
+        размер = экземпляр.Размер()
         return f"Приоритетная_очередь с {__Общие_функции__.Склонение_после_числительного(размер, Словарь_склонений['задача'])}"

rupython//342/225/250/320/254/342/225/250/342/225/233/342/225/250/342/224/244/342/225/244/320/223/342/225/250/342/225/227/342/225/250/342/225/225//342/225/250/320/257/342/225/250/342/225/233/342/225/244/320/222/342/225/250/342/225/233/342/225/250/342/225/221/342/225/250/342/225/225.py

@@ -26,7 +26,7 @@ from rupython import __Общие_функции__
 }
 
 class Поток:
-    def __init__(здесь, цель = None, имя = None, аргументы = (), именовАргументы = None, после_окончания = None):
+    def __init__(экземпляр, цель = None, имя = None, аргументы = (), именовАргументы = None, после_окончания = None):
         ИА = {}
         if цель is not None:
             ИА['target'] = цель
@@ -38,227 +38,227 @@ class Поток:
             ИА['kwargs'] = именовАргументы
         if после_окончания is not None:
             ИА['daemon'] = после_окончания
-        здесь._thread = threading.Thread(**ИА)
+        экземпляр._thread = threading.Thread(**ИА)
 
-    def Начать(здесь):
-        здесь._thread.start()
+    def Начать(экземпляр):
+        экземпляр._thread.start()
 
-    def Ждать(здесь, время_ожидания = None):
+    def Ждать(экземпляр, время_ожидания = None):
         ИА = {}
         if время_ожидания is not None:
             ИА['timeout'] = время_ожидания
-        здесь._thread.join(**kwargs)
+        экземпляр._thread.join(**kwargs)
 
-    def Живой(здесь):
-        return здесь._thread.is_alive()
+    def Живой(экземпляр):
+        return экземпляр._thread.is_alive()
 
-    def Получить_имя(здесь):
-        return здесь._thread.getName()
+    def Получить_имя(экземпляр):
+        return экземпляр._thread.getName()
 
-    def Установить_имя(здесь, имя):
-        здесь._thread.setName(имя)
+    def Установить_имя(экземпляр, имя):
+        экземпляр._thread.setName(имя)
 
-    def Получить_идентификатор(здесь):
-        return здесь._thread.ident
+    def Получить_идентификатор(экземпляр):
+        return экземпляр._thread.ident
 
-    def После_окончания(здесь):
-        return здесь._thread.daemon
+    def После_окончания(экземпляр):
+        return экземпляр._thread.daemon
 
-    def Установить_после_окончания(здесь, после_окончания):
-        здесь._thread.daemon = после_окончания
+    def Установить_после_окончания(экземпляр, после_окончания):
+        экземпляр._thread.daemon = после_окончания
 
-    def __str__(здесь):
-        return f"Поток(имя={здесь.Получить_имя()}, живой={здесь.Живой()})"
+    def __str__(экземпляр):
+        return f"Поток(имя={экземпляр.Получить_имя()}, живой={экземпляр.Живой()})"
 
 class Блокование:
-    def __init__(здесь):
-        здесь._lock = threading.Lock()
+    def __init__(экземпляр):
+        экземпляр._lock = threading.Lock()
 
-    def Захватить(здесь, блоковать = True, время_ожидания = None):
+    def Захватить(экземпляр, блоковать = True, время_ожидания = None):
         ИА = {'block': блоковать}
         if время_ожидания is not None:
             ИА['timeout'] = время_ожидания
-        return здесь._lock.acquire(**ИА)
+        return экземпляр._lock.acquire(**ИА)
 
-    def Освободить(здесь):
-        здесь._lock.release()
+    def Освободить(экземпляр):
+        экземпляр._lock.release()
 
-    def Захвачено(здесь):
-        return здесь._lock.locked()
+    def Захвачено(экземпляр):
+        return экземпляр._lock.locked()
 
-    def __enter__(здесь):
-        здесь.Захватить()
-        return здесь
+    def __enter__(экземпляр):
+        экземпляр.Захватить()
+        return экземпляр
 
-    def __exit__(здесь, тип_исключения, значение_исключения, трассировка):
-        здесь.Освободить()
+    def __exit__(экземпляр, тип_исключения, значение_исключения, трассировка):
+        экземпляр.Освободить()
 
-    def __str__(здесь):
-        return f"Блокование(захвачено={здесь.Захвачено()})"
+    def __str__(экземпляр):
+        return f"Блокование(захвачено={экземпляр.Захвачено()})"
 
 class Повторное_блокование:
-    def __init__(здесь):
-        здесь._rlock = threading.RLock()
+    def __init__(экземпляр):
+        экземпляр._rlock = threading.RLock()
 
-    def Захватить(здесь, блоковать = True, время_ожидания = None):
+    def Захватить(экземпляр, блоковать = True, время_ожидания = None):
         ИА = {'block': блоковать}
         if время_ожидания is not None:
             ИА['timeout'] = время_ожидания
-        return здесь._rlock.acquire(**ИА)
+        return экземпляр._rlock.acquire(**ИА)
 
-    def Освободить(здесь):
-        здесь._rlock.release()
+    def Освободить(экземпляр):
+        экземпляр._rlock.release()
 
-    def __enter__(здесь):
-        здесь.Захватить()
-        return здесь
+    def __enter__(экземпляр):
+        экземпляр.Захватить()
+        return экземпляр
 
-    def __exit__(здесь, тип_исключения, значение_исключения, трассировка):
-        здесь.Освободить()
+    def __exit__(экземпляр, тип_исключения, значение_исключения, трассировка):
+        экземпляр.Освободить()
 
-    def __str__(здесь):
-        return f"Повторное_блокование(владелец={здесь._rlock._owner}, счётчик={здесь._rlock._count})"
+    def __str__(экземпляр):
+        return f"Повторное_блокование(владелец={экземпляр._rlock._owner}, счётчик={экземпляр._rlock._count})"
 
 class Семафор:
-    def __init__(здесь, количество = 1):
+    def __init__(экземпляр, количество = 1):
         ИА = {'value': количество}
-        здесь._semaphore = threading.Semaphore(**ИА)
+        экземпляр._semaphore = threading.Semaphore(**ИА)
 
-    def Захватить(здесь, блоковать = True, время_ожидания = None):
+    def Захватить(экземпляр, блоковать = True, время_ожидания = None):
         ИА = {'block': блоковать}
         if время_ожидания is not None:
             ИА['timeout'] = время_ожидания
-        return здесь._semaphore.acquire(**ИА)
+        return экземпляр._semaphore.acquire(**ИА)
 
-    def Освободить(здесь):
-        здесь._semaphore.release()
+    def Освободить(экземпляр):
+        экземпляр._semaphore.release()
 
-    def __enter__(здесь):
-        здесь.Захватить()
-        return здесь
+    def __enter__(экземпляр):
+        экземпляр.Захватить()
+        return экземпляр
 
-    def __exit__(здесь, тип_исключения, значение_исключения, трассировка):
-        здесь.Освободить()
+    def __exit__(экземпляр, тип_исключения, значение_исключения, трассировка):
+        экземпляр.Освободить()
 
-    def __str__(здесь):
-        return f"Семафор(ресурсов={здесь._semaphore._value})"
+    def __str__(экземпляр):
+        return f"Семафор(ресурсов={экземпляр._semaphore._value})"
 
 class Ограниченный_семафор(Семафор):
-    def __init__(здесь, количество = 1):
+    def __init__(экземпляр, количество = 1):
         ИА = {'value': количество}
-        здесь._semaphore = threading.BoundedSemaphore(**ИА)
+        экземпляр._semaphore = threading.BoundedSemaphore(**ИА)
 
 class Событие:
-    def __init__(здесь):
-        здесь._event = threading.Event()
+    def __init__(экземпляр):
+        экземпляр._event = threading.Event()
 
-    def Установить(здесь):
-        здесь._event.set()
+    def Установить(экземпляр):
+        экземпляр._event.set()
 
-    def Сбросить(здесь):
-        здесь._event.clear()
+    def Сбросить(экземпляр):
+        экземпляр._event.clear()
 
-    def Активно(здесь):
-        return здесь._event.is_set()
+    def Активно(экземпляр):
+        return экземпляр._event.is_set()
 
-    def Ждать(здесь, время_ожидания = None):
+    def Ждать(экземпляр, время_ожидания = None):
         ИА = {}
         if время_ожидания is not None:
             ИА['timeout'] = время_ожидания
-        return здесь._event.wait(**ИА)
+        return экземпляр._event.wait(**ИА)
 
-    def __str__(здесь):
-        return f"Событие(активно={здесь.Активно()})"
+    def __str__(экземпляр):
+        return f"Событие(активно={экземпляр.Активно()})"
 
 class Условие:
-    def __init__(здесь, блокование = None):
+    def __init__(экземпляр, блокование = None):
         ИА = {}
         if блокование is not None:
             ИА['lock'] = блокование._lock if isinstance(блокование, (Блокование, Повторное_блокование)) else блокование
-        здесь._condition = threading.Condition(**ИА)
+        экземпляр._condition = threading.Condition(**ИА)
 
-    def Захватить(здесь):
-        return здесь._condition.acquire()
+    def Захватить(экземпляр):
+        return экземпляр._condition.acquire()
 
-    def Освободить(здесь):
-        здесь._condition.release()
+    def Освободить(экземпляр):
+        экземпляр._condition.release()
 
-    def Ждать(здесь, время_ожидания = None):
+    def Ждать(экземпляр, время_ожидания = None):
         ИА = {}
         if время_ожидания is not None:
             ИА['timeout'] = время_ожидания
-        return здесь._condition.wait(**ИА)
+        return экземпляр._condition.wait(**ИА)
 
-    def Уведомить(здесь, количество = 1):
+    def Уведомить(экземпляр, количество = 1):
         ИА = {'n': количество}
-        здесь._condition.notify(**ИА)
+        экземпляр._condition.notify(**ИА)
 
-    def Уведомить_все(здесь):
-        здесь._condition.notify_all()
+    def Уведомить_все(экземпляр):
+        экземпляр._condition.notify_all()
 
-    def __enter__(здесь):
-        здесь.Захватить()
-        return здесь
+    def __enter__(экземпляр):
+        экземпляр.Захватить()
+        return экземпляр
 
-    def __exit__(здесь, тип_исключения, значение_исключения, трассировка):
-        здесь.Освободить()
+    def __exit__(экземпляр, тип_исключения, значение_исключения, трассировка):
+        экземпляр.Освободить()
 
-    def __str__(здесь):
-        return f"Условие(захвачено={здесь._condition._is_owned()})"
+    def __str__(экземпляр):
+        return f"Условие(захвачено={экземпляр._condition._is_owned()})"
 
 class Барьер:
-    def __init__(здесь, количество, действие = None, время_ожидания = None):
+    def __init__(экземпляр, количество, действие = None, время_ожидания = None):
         ИА = {'parties': количество}
         if действие is not None:
             ИА['action'] = действие
         if время_ожидания is not None:
             ИА['timeout'] = время_ожидания
-        здесь._barrier = threading.Barrier(**ИА)
+        экземпляр._barrier = threading.Barrier(**ИА)
 
-    def Ждать(здесь, время_ожидания = None):
+    def Ждать(экземпляр, время_ожидания = None):
         ИА = {}
         if время_ожидания is not None:
             ИА['timeout'] = время_ожидания
-        return здесь._barrier.wait(**ИА)
+        return экземпляр._barrier.wait(**ИА)
 
-    def Сбросить(здесь):
-        здесь._barrier.reset()
+    def Сбросить(экземпляр):
+        экземпляр._barrier.reset()
 
-    def Прервать(здесь):
-        здесь._barrier.abort()
+    def Прервать(экземпляр):
+        экземпляр._barrier.abort()
 
-    def Количество_участников(здесь):
-        return здесь._barrier.parties
+    def Количество_участников(экземпляр):
+        return экземпляр._barrier.parties
 
-    def Количество_ожидающих(здесь):
-        return здесь._barrier.n_waiting
+    def Количество_ожидающих(экземпляр):
+        return экземпляр._barrier.n_waiting
 
-    def Сломан(здесь):
-        return здесь._barrier.broken
+    def Сломан(экземпляр):
+        return экземпляр._barrier.broken
 
-    def __str__(здесь):
-        return f"Барьер({__Общие_функции__.Склонение_после_числительного(здесь.Количество_ожидающих(), Словарь_склонений['участник'])} из {здесь.Количество_участников()})"
+    def __str__(экземпляр):
+        return f"Барьер({__Общие_функции__.Склонение_после_числительного(экземпляр.Количество_ожидающих(), Словарь_склонений['участник'])} из {экземпляр.Количество_участников()})"
 
 class Таймер(Поток):
-    def __init__(здесь, интервал, цель, аргументы = (), именовАргументы = None, обратный_вызов = None, аргументыОбрВыз = (), именовАргументыОбрВыз = None):
+    def __init__(экземпляр, интервал, цель, аргументы = (), именовАргументы = None, обратный_вызов = None, аргументыОбрВыз = (), именовАргументыОбрВыз = None):
         ИА = {'interval': интервал, 'function': цель}
         if аргументы:
             ИА['args'] = аргументы
         if именовАргументы is not None:
             ИА['kwargs'] = именовАргументы
-        здесь._timer = threading.Timer(**ИА)
-        здесь._callback = обратный_вызов
-        здесь._callback_args = аргументыОбрВыз
-        здесь._callback_kwargs = именовАргументыОбрВыз or {}
+        экземпляр._timer = threading.Timer(**ИА)
+        экземпляр._callback = обратный_вызов
+        экземпляр._callback_args = аргументыОбрВыз
+        экземпляр._callback_kwargs = именовАргументыОбрВыз or {}
 
-    def Отменить(здесь):
-        здесь._timer.cancel()
+    def Отменить(экземпляр):
+        экземпляр._timer.cancel()
 
-    def Завершён(здесь):
-        return здесь._timer.finished.is_set()
+    def Завершён(экземпляр):
+        return экземпляр._timer.finished.is_set()
 
-    def __str__(здесь):
-        return f"Таймер(интервал={здесь._timer.interval}, завершён={здесь.Завершён()})"
+    def __str__(экземпляр):
+        return f"Таймер(интервал={экземпляр._timer.interval}, завершён={экземпляр.Завершён()})"
 
 def Текущий_поток():
     return Поток(цель = lambda: None, имя = threading.current_thread().getName())