brinmax

Изобретение мела для бильярда | Лига любителей бильярда

Джон Карр работал маркером в бильярдной Upper Rooms, которая принадлежала господину Бартли. Когда в зале было мало посетителей, хозяин и его работник часто развлекались тем, что отрабатывали новые удары. Например, они ставили на центральную точку красного шара и пробовали по центральной линии закатить в среднюю лузу другого шара, не затронув помеху. Первым стал исполнять этот удар Бартли. Но вскоре, Джон Карр превзошел своего учителя. И если хозяин бильярдной Бартли так и не смог обратить свое умение себе в прибыль, то Карру предприимчивости было не занимать. По вечерам в бильярдной он умело исполнял этот и другие крученые удары. Игроки были готовы пойти на все, чтобы научиться бить не хуже. Особенно, нужно полагать, усердствовали игроки, которых Карр, благодаря своему умению, оставлял с пустыми карманами. Искусно подогрев интерес публики, ловкий маркер заявлял, что секрет его мастерства вовсе не в тренировках, а в удивительном «крученом меле», который он изобрел и который находится вот в этих коробочках. И он, Джон Карр, готов поделиться этими чудесными коробочками за умеренную плату. Мел шел нарасхват. Учитывая, что коробочки Карр набивал обыкновенным копеечным «рассыпным» мелом, который владелец бильярдной господин Бартли совершенно бесплатно выдавал своим клиентам, прибыли маркера были астрономическими. За короткое время он стал настолько богатым, что мог бы купить всю бильярдную, если бы….

Если бы Джон Карр не был настоящим Homo Ludens — человеком играющим! То, что он зарабатывал на слоновой кости в виде бильярдных шаров, маркер благополучно спускал, благодаря другой слоновой кости — кубикам, с нанесенными на гранях черными точками. Карру было не занимать мастерства и предприимчивости, но вот с удачей у него явно были не лады. Через некоторое время он остался ни с чем: игроки в кости и карты искали его, чтобы выбить долги, а игроки на бильярде не рисковали сводиться с ним. Бывший маркер решил уехать в Испанию. Горячие доны чуть что- хватались за ножи, но мастерство Карра было таково, что даже проигравшиеся гранды в восхищении платили. Однако игорных домов в Испании было не меньше, чем в Англии, и через некоторое время пришлось возвращаться на родину. Он обосновался в Портсмуте и закончил свои дни на грани нищеты. Благодаря Джону Карру мел стали использовать по обе стороны океана.

До 1893-го года в бильярдных пользовались обычным мелом. Он не удовлетворял игроков, был вреден для сукна: не только обесцвечивал его, но и приводил к гниению. Никто в течение почти 100 лет не догадался, что обычный мел — материал с некристаллической структурой — не совсем соответствует тем задачам, которые на него возлагаются. В 1892 году профессиональный бильярдист Уильям А. Спинкс побывал во Франции и вернулся оттуда в Чикаго с маленьким жестким кусочком мела. Спинкс отнес этот кусочек на экспертизу к знакомому химику, который через некоторое время создал материал, отвечающий всем требованиям заказчика. В 1897 году Уильям Спинкс и Уильям Хоскинс (а именно так звали того химика) получили патент на новый мел. «Мел Спинкса» произвел революцию в бильярде из-за того, что он был полностью сделан из абразива высокого качества, обеспечивая максимально высокое сцепление с шаром в момент удара, что было невозможно при использовании обычного мела.
В современном бильярдном «меле» не содержится собственно мела, которым пишут в школе на доске или белят потолки. При производстве качественного бильярдного мела используется кварц и алоксит, каждый из которых играет важную роль при контакте кия с шаром. Только при правильном сочетании этих компонентов (к белому кварцу, растолченному в порошок, добавляется более твердый алоксит в незначительном количестве) и красителя для придания цвета получается высококачественный бильярдный мел. Форму мелу придает гидравлический пресс, которым обеспечивается давление в 15 тонн на одну форму, квадратную или круглую. После прессовки формы просушиваются так, что образуется очень твердая оболочка по краям мела. Чем плотнее и тверже кусочек мела сделан, тем более тонкий слой от него отделяется при натирании наклейки, и тем лучше для сукна.

Бильярдный зал

ЗА БИЛЬЯРДНЫМ СТОЛОМ И ЛЕЙТЕНАНТЫ, И ГЕНЕРАЛЫ

    20 февраля 2017 года, в Москве прошел традиционный, 11-й Турнир по бильярду на Кубок Министерства обороны Российской Федерации, посвященный Дню защитника Отечества. Организаторами соревнований, как и прежде, выступили военное ведомство в лице Центрального Дома Российской Армии имени М.В.Фрунзе и Московский Союз бильярдного спорта.

  
В турнире, который прошел в известном бильярдном клубе «Кино» (клуб регулярно посещают популярные деятели театра и кино) в ОАО «Спортивный комплекс «Олимпийский», приняли участие офицеры Сухопутных войск, Военно-Морского Флота, Воздушно-космических сил, РВСН, ВДВ, а также 12-го Главного управления Минобороны России, Военной академии Генерального штаба Вооруженных Сил Российской Федерации и Национального центра управления обороной Российской Федерации. 

   Участников турнира на церемонии открытия, которую вел начальник группы культурного обслуживания войск отдела военно-шефской работы ЦДРА заслуженный работник культуры Российской Федерации Николай Дрыга, тепло приветствовали прославленные военачальники – генерал-полковник Валерий Петрович Баранов, генерал-полковник авиации Борис Федорович Корольков (позднее они также взяли в руки кии), член президиума Московского Союза бильярдного спорта Николай Васильевич Рагозин, начальник Центрального Дома Российской Армии имени М. В.Фрунзе заслуженный работник культуры Российской Федерации Василий Иванович Мазуренко и главный судья Московского Союза бильярдного спорта судья международной категории Сергей Александрович Агеенко.

   Примечательно, что в захватывающих поединках мастеров кия в погонах свое мастерство смогли показать и молодые офицеры – лейтенанты и капитаны, и зрелые полковники и генералы. Причем спор молодости и опыта за бильярдным столом продолжался вплоть до финала, где в противоборстве за первое место встретились капитан Кирилл Прохин, представляющий Национальный центр управления обороной Российской Федерации, и капитан первого ранга Виктор Филимонов из 12-го Главного управления Минобороны России. Убедительную победу в двух партиях одержал капитан Прохин. 

   Матч за третье место было решено не проводить. Таким образом, бронзовыми призерами стали – полковник Андрей Ломакин (Военно-морской флот) и капитан Василий Лосев (Воздушно-космические силы).

    На церемонии награждения, которое провели генерал-полковник авиации Борис Федорович Корольков и заместитель начальника ЦДРА заслуженный работник культуры Российской Федерации Анатолий Анатольевич Пуклич, победитель удостоился Кубка Министерства обороны Российской Федерации, золотой медали и денежной премии. Медалями соответствующего достоинства и денежными премиями были награждены все призеры турнира. Кроме того, всем лучшим игрокам начальник отдела военно-шефской работы ЦДРА заслуженный работник культуры Российской Федерации Галина Александровна Карасева вручила билеты для посещения 23 февраля концерта в Государственном академическом Большом театре России.

billiard.pool — документация Celery 5.0.5

# - * - кодировка: utf-8 - * -
#
# Модуль, предоставляющий класс Pool для управления пулом процессов
#
# multiprocessing / pool.py
#
# Copyright (c) 2006-2008, R Oudkerk
# Лицензия предоставлена ​​PSF по Соглашению с спонсором.
#
from __future__ import absolute_import

#
# Импорт
#
импортная копия
import errno
импорт itertools
импорт ОС
платформа для импорта
импортный сигнал
import sys
импорт потоковой передачи
время импорта
предупреждения об импорте

из коллекций import deque
from functools import partial

из .импортировать cpu_count, get_context
из . импорт утилит
из . common import (
    TERM_SIGNAL, human_status, pickle_loads, reset_signals, restart_state,
)
из .compat import get_errno, mem_rss, send_offset
из .einfo импорт ExceptionInfo
из .dummy import DummyProcess
из .exceptions import (
    CoroStop,
    RestartFreqExceeded,
    SoftTimeLimitExceeded,
    Прекращено,
    TimeLimitExceeded,
    TimeoutError,
    WorkerLostError,
)
из .five import Empty, Queue, range, values, reraise, monotonic
из .util import Finalize, debug, warning

MAXMEM_USED_FMT = "" "\
дочерний процесс завершается после превышения лимита памяти ({0} КиБ / {1} КиБ)
"" "

PY3 = sys.version_info [0] == 3

if platform.system () == 'Windows': # pragma: no cover
    # В Windows os.kill вызывает TerminateProcess, который не может быть
    # обрабатывается # любым процессом, поэтому это необходимо для завершения задачи
    # * и его дочерние элементы * (если есть).
    из ._win импортировать kill_processtree как _kill # noqa
    SIGKILL = TERM_SIGNAL
еще:
    из os import kill as _kill # noqa
    SIGKILL = сигнал. СИГКИЛЛ


пытаться:
    TIMEOUT_MAX = поток.TIMEOUT_MAX
кроме AttributeError: # pragma: no cover
    TIMEOUT_MAX = 1e10 # noqa


если sys.version_info> = (3, 3):
    _Semaphore = threading.Semaphore
еще:
    # Semaphore - это заводская функция, указывающая на _Semaphore
    _Semaphore = threading._Semaphore # noqa

#
# Константы, представляющие состояние пула
#

RUN = 0
ЗАКРЫТЬ = 1
TERMINATE = 2

#
# Константы, представляющие состояние задания
#

ACK = 0
ГОТОВ = 1
ЗАДАЧА = 2
NACK = 3
СМЕРТЬ = 4

#
# Константы кода выхода
#
EX_OK = 0
EX_FAILURE = 1
EX_RECYCLE = 0x9B


# Сигнал, используемый для мягких временных ограничений.SIG_SOFT_TIMEOUT = getattr (сигнал, "SIGUSR1", Нет)

#
# Разное
#

LOST_WORKER_TIMEOUT = 10,0
EX_OK = getattr (os, "EX_OK", 0)
GUARANTEE_MESSAGE_CONSUMPTION_RETRY_LIMIT = 300
GUARANTEE_MESSAGE_CONSUMPTION_RETRY_INTERVAL = 0,1

job_counter = itertools.count ()

Lock = резьба.


def _get_send_offset (соединение):
    пытаться:
        native = connection.send_offset
    кроме AttributeError:
        native = Нет
    если native - None:
        возврат частичного (send_offset, connection. fileno ())
    вернуть родной


def mapstar (аргументы):
    список возврата (map (* args))


def starmapstar (аргументы):
    список возврата (itertools.звездная карта (аргументы [0], аргументы [1]))


def error (msg, * args, ** kwargs):
    util.get_logger (). error (msg, * args, ** kwargs)


def stop_if_not_current (поток, тайм-аут = None):
    если поток не является threading.current_thread ():
        thread.stop (тайм-аут)


класс LaxBoundedSemaphore (_Semaphore):
    "" "Семафор, который проверяет, что # выпуск <= # получает,
    но игнорирует, если # релизов> = value. "" "

    def shrink (self):
        self._initial_value - = 1
        self.acquire ()

    если PY3:

        def __init __ (self, value = 1, verbose = None):
            _Semaphore.__init __ (себя, значение)
            self._initial_value = значение

        def расти (сам):
            с self._cond:
                self._initial_value + = 1
                self._value + = 1
                self._cond.notify ()

        def release (self):
            cond = self. _cond
            с конд:
                если self._value  release (сам)

#
# Исключения
#


класс MaybeEncodingError (Исключение):
    "" "Обертывает возможные непоправимые ошибки, чтобы их можно было
    благополучно отправлено через сокет. "" "

    def __init __ (self, exc, value):
        self.exc = repr (exc)
        себя.значение = repr (значение)
        super (MaybeEncodingError, self) .__ init __ (self.exc, self.value)

    def __repr __ (сам):
        return "<% s:% s>"% (self .__ class __.__ name__, str (self))

    def __str __ (сам):
        return "Ошибка отправки результата: '% r'. Причина: '% r'." % (
            self.value, self.exc)


класс WorkersJoined (исключение):
    "" "Все рабочие уволены." ""


def soft_timeout_sighandler (знак, кадр):
    поднять SoftTimeLimitExceeded ()

#
# Код, выполняемый рабочими процессами
#


класс Worker (объект):

    def __init __ (self, inq, outq, synq = None, initializer = None, initargs = (),
                 maxtasks = None, sentinel = None, on_exit = None,
                 sigprotection = True, wrap_exception = True,
                 max_memory_per_child = Нет, on_ready_counter = Нет):
        assert maxtasks - None или (type (maxtasks) == int и maxtasks> 0)
        себя. инициализатор = инициализатор
        self.initargs = initargs
        self.maxtasks = maxtasks
        self.max_memory_per_child = max_memory_per_child
        self._shutdown = дозорный
        self.on_exit = on_exit
        self.sigprotection = sigprotection
        self.inq, self.outq, self.synq = inq, outq, synq
        self.wrap_exception = wrap_exception # XXX пока не может отключить
        self.on_ready_counter = on_ready_counter
        self.contribute_to_object (сам)

    def deposit_to_object (self, obj):
        объектinq, obj.outq, obj.synq = self.inq, self.outq, self.synq
        obj.inqW_fd = self.inq._writer.fileno () # поставить в очередь запись fd
        obj.outqR_fd = self.outq._reader.fileno () # outqueue read fd
        если self.synq:
            obj.synqR_fd = self.synq._reader.fileno () # синхронизация чтения fd
            obj.synqW_fd = self.synq._writer.fileno () # synqueue write fd
            obj.send_syn_offset = _get_send_offset (self.synq._writer)
        еще:
            obj. synqR_fd = obj.synqW_fd = obj._send_syn_offset = Нет
        объект_quick_put = self.inq._writer.send
        obj._quick_get = self.outq._reader.recv
        obj.send_job_offset = _get_send_offset (self.inq._writer)
        вернуть объект

    def __reduce __ (сам):
        вернуть self .__ class__, (
            self.inq, self.outq, self.synq, self.initializer,
            self.initargs, self.maxtasks, self._shutdown, self.on_exit,
            self.sigprotection, self.wrap_exception, self.max_memory_per_child,
        )

    def __call __ (сам):
        _exit = sys.exit
        _exitcode = [Нет]

        def exit (статус = Нет):
            _exitcode [0] = статус
            return _exit (статус)
        sys.exit = выход

        pid = os.getpid ()

        self._make_child_methods ()
        self.after_fork ()
        self.on_loop_start (pid = pid) # обратный вызов при запуске цикла
        пытаться:
            sys.exit (self.workloop (pid = pid))
        кроме исключения как exc:
            error ('Ошибка процесса пула% r:% r', self, exc, exc_info = 1)
            self. _do_exit (pid, _exitcode [0], exc)
        наконец-то:
            self._do_exit (pid, _exitcode [0], Нет)

    def _do_exit (self, pid, exitcode, exc = None):
        если код выхода None:
            exitcode = EX_FAILURE если exc иначе EX_OK

        если сам.on_exit не равно None:
            self.on_exit (идентификатор, код выхода)

        если sys.platform! = 'win32':
            пытаться:
                self.outq.put ((СМЕРТЬ, (pid, exitcode)))
                время сна (1)
            наконец-то:
                os._exit (код выхода)
        еще:
            os._exit (код выхода)

    def on_loop_start (self, pid):
        проходить

    def prepare_result (self, результат):
        вернуть результат

    def workloop (self, debug = debug, now = monotonic, pid = None):
        pid = pid или os.getpid ()
        положите = self.выход
        inqW_fd = self.inqW_fd
        synqW_fd = self.synqW_fd
        maxtasks = self.maxtasks
        max_memory_per_child = self.max_memory_per_child или 0
        prepare_result = self. prepare_result

        wait_for_job = self.wait_for_job
        _wait_for_syn = self.wait_for_syn

        def wait_for_syn (jid):
            я = 0
            а 1:
                если i> 60:
                    error ('!!! WAIT FOR ACK TIMEOUT: job:% r fd:% r !!!',
                          джид, сам.synq._reader.fileno (), exc_info = 1)
                req = _wait_for_syn ()
                если требуется:
                    type_, args = req
                    если type_ == NACK:
                        return False
                    assert type_ == ACK
                    вернуть True
                я + = 1

        завершено = 0
        пытаться:
            в то время как maxtasks - None или (maxtasks и завершено  exc_info ()
                        пытаться:
                            wrapped = MaybeEncodingError (exc, результат [1])
                            einfo = ExceptionInfo ((
                                MaybeEncodingError, завернутый, tb,
                            ))
                            положить ((ГОТОВ, (задание, я, (Ложь, einfo), inqW_fd)))
                        наконец-то:
                            дель (tb)
                    завершено + = 1
                    если max_memory_per_child> 0:
                        used_kb = mem_rss ()
                        если used_kb <= 0:
                            ошибка («работник не может определить использование памяти»)
                        если used_kb> 0 и used_kb> max_memory_per_child:
                            предупреждение (MAXMEM_USED_FMT.формат(
                                used_kb, max_memory_per_child))
                            вернуть EX_RECYCLE

            отладка ('работник завершает работу после% d задач', выполнено)
            если maxtasks:
                вернуть EX_RECYCLE, если завершено == maxtasks else EX_FAILURE
            вернуть EX_OK
        наконец-то:
            # Перед выходом из воркера мы хотим убедиться, что все
            # сообщение, созданное работником, было использовано основным
            # процесс.  Это предотвращает преждевременное завершение работника.
            # и сообщения теряются.self._ensure_messages_consumed (завершено = выполнено)

    def _ensure_messages_consumed (самостоятельно, выполнено):
        "" "Возвращает истину, если все отправленные сообщения были получены и
        потребляется в разумные сроки "" "

        если не self.on_ready_counter:
            return False

        для повтора в диапазоне (GUARANTEE_MESSAGE_CONSUMPTION_RETRY_LIMIT):
            если self.on_ready_counter.value> = завершено:
                отладка ('гарантированные сообщения потребляются после% d повторных попыток', повторить попытку)
                вернуть True
            время.спать (GUARANTEE_MESSAGE_CONSUMPTION_RETRY_INTERVAL)
        предупреждение ('не удалось гарантировать, что все сообщения были использованы до'
                'выход')
        return False

    def after_fork (сам):
        если hasattr (self.inq, '_writer'):
            self.inq._writer.close ()
        если hasattr (self. outq, '_reader'):
            self.outq._reader.close ()

        если self.initializer не равен None:
            self.initializer (* self.initargs)

        # Убедитесь, что все исходящие сигналы вызывают finally: blocks.# Это важно для освобождения семафора.
        reset_signals (полный = self.sigprotection)

        # установить обработчик сигналов для мягких таймаутов.
        если SIG_SOFT_TIMEOUT не равно None:
            signal.signal (SIG_SOFT_TIMEOUT, soft_timeout_sighandler)

        пытаться:
            signal.signal (сигнал.SIGINT, сигнал.SIG_IGN)
        кроме AttributeError:
            проходить

    def _make_recv_method (self, conn):
        get = conn.get

        если hasattr (conn, '_reader'):
            _poll = conn._reader.poll
            если hasattr (conn, 'get_payload') и conn.get_payload:
                get_payload = conn.get_payload

                def _recv (тайм-аут, загрузка = pickle_loads):
                    return True, загружает (get_payload ())
            еще:
                def _recv (тайм-аут): # noqa
                    если _poll (тайм-аут):
                        вернуть True, получить ()
                    return False, None
        еще:
            def _recv (тайм-аут): # noqa
                пытаться:
                    вернуть True, получить (тайм-аут = тайм-аут)
                кроме очереди. Пустой:
                    return False, None
        возврат _recv

    def _make_child_methods (self, load = pickle_loads):
        self.wait_for_job = self._make_protected_receive (self.inq)
        self.wait_for_syn = (self._make_protected_receive (self.synq)
                             if self.synq else None)

    def _make_protected_receive (self, conn):
        _receive = self._make_recv_method (conn)
        should_shutdown = self._shutdown.is_set if self._shutdown else Нет

        def получить (отладка = отладка):
            если should_shutdown и should_shutdown ():
                отладка ('рабочий получил дозорный - выход')
                поднять SystemExit (EX_OK)
            пытаться:
                готово, req = _receive (1.0)
                если не готов:
                    return None
            кроме (EOFError, IOError) как exc:
                если get_errno (exc) == errno.EINTR:
                    return None # прервано, возможно, GDB
                отладка ('рабочий получил% s - завершается', введите (exc) . __ name__)
                поднять SystemExit (EX_FAILURE)
            если req равно None:
                отладка ('рабочий получил дозорный - выход')
                поднять SystemExit (EX_FAILURE)
            запрос на возврат

        возврат получить


#
# Класс, представляющий пул процессов
#


класс PoolThread (DummyProcess):

    def __init __ (self, * args, ** kwargs):
        DummyProcess.__в себе)
        self._state = ВЫПОЛНИТЬ
        self._was_started = Ложь
        self.daemon = Верно

    def run (self):
        пытаться:
            вернуть self.body ()
        кроме RestartFreqExceeded как exc:
            error («Поток% r разбился:% r», тип (self) .__ name__, exc,
                  exc_info = 1)
            _kill (os.getpid (), TERM_SIGNAL)
            sys.exit ()
        кроме исключения как exc:
            error («Поток% r разбился:% r», тип (self) .__ name__, exc,
                  exc_info = 1)
            Операционные системы._exit (1)

    def start (self, * args, ** kwargs):
        self. _was_started = Верно
        super (PoolThread, self) .start (* аргументы, ** kwargs)

    def on_stop_not_started (самостоятельно):
        проходить

    def stop (self, timeout = None):
        если self._was_started:
            self.join (тайм-аут)
            возвращаться
        self.on_stop_not_started ()

    def terminate (self):
        self._state = ПРЕКРАТИТЬ

    def close (self):
        self._state = ЗАКРЫТЬ


класс Supervisor (PoolThread):

    def __init __ (я, пул):
        себя.pool = бассейн
        super (руководитель, сам) .__ init __ ()

    def body (self):
        отладка ('запуск обработчика рабочего')

        time.sleep (0,8)

        бассейн = self.pool

        пытаться:
            # делаем серию при запуске, чтобы убедиться, что мы можем начать
            # наш пул обрабатывает, и за это время мы понижаем
            # максимальная частота перезапуска.
            prev_state = pool.restart_state
            pool.restart_state = restart_state (10 * pool. _processes, 1)
            для _ в диапазоне (10):
                если сам._state == RUN и pool._state == RUN:
                    pool._maintain_pool ()
                    time.sleep (0,1)

            # Поддерживать рабочие процессы до тех пор, пока кеш не будет опустошен, если только
            # бассейн завершен
            pool.restart_state = предыдущее_состояние
            а self._state == RUN и pool._state == RUN:
                pool._maintain_pool ()
                time.sleep (0,8)
        кроме RestartFreqExceeded:
            pool.close ()
            pool.join ()
            поднимать
        отладка ('рабочий обработчик завершается')


класс TaskHandler (PoolThread):

    def __init __ (self, taskqueue, put, outqueue, pool, cache):
        себя.taskqueue = очередь задач
        self.put = положить
        self.outqueue = outqueue
        self.pool = бассейн
        self.cache = кеш
        super (TaskHandler, сам) .__ init __ ()

    def body (self):
        cache = self. cache
        taskqueue = self.taskqueue
        put = self.put

        для taskseq, set_length в iter (taskqueue.get, None):
            task = Нет
            я = -1
            пытаться:
                для i задача в перечислении (taskseq):
                    если self._state:
                        debug ('обработчик задачи обнаружил поток._state! = RUN ')
                        перемена
                    пытаться:
                        поставить (задача)
                    кроме IOError:
                        отладка ('не удалось поставить задачу в очередь')
                        перемена
                    кроме исключения:
                        работа, ind = задача [: 2]
                        пытаться:
                            кеш [задание] ._ set (ind, (False, ExceptionInfo ()))
                        кроме KeyError:
                            проходить
                еще:
                    если set_length:
                        отладка ('выполнение set_length ()')
                        set_length (я + 1)
                    Продолжить
                перемена
            кроме исключения:
                job, ind = task [: 2] if task else (0, 0)
                если задание в кеше:
                    кеш [задание]. _set (ind + 1, (Ложь, ExceptionInfo ()))
                если set_length:
                    util.debug ('выполнение set_length ()')
                    set_length (я + 1)
        еще:
            отладка ('обработчик задачи получил дозор')

        self.tell_others ()

    def tell_others (сам):
        outqueue = self.outqueue
        put = self.put
        бассейн = self.pool

        пытаться:
            # сообщаем обработчику результата завершить работу, когда кеш пуст
            отладка ('обработчик задачи отправляет дозор обработчику результата')
            вне очереди.положить (Нет)

            # сообщить работникам, что работы больше нет
            отладка ('обработчик задачи отправляет дозор работникам')
            для p в бассейне:
                положить (Нет)
        кроме IOError:
            debug ('обработчик задачи получил ошибку IOError при отправке часовых')

        отладка ('выход из обработчика задачи')

    def on_stop_not_started (самостоятельно):
        self. tell_others ()


класс TimeoutHandler (PoolThread):

    def __init __ (сам, процессы, кеш, t_soft, t_hard):
        self.processes = процессы
        себя.cache = кеш
        self.t_soft = t_soft
        self.t_hard = t_hard
        self._it = Нет
        super (TimeoutHandler, сам) .__ init __ ()

    def _process_by_pid (self, pid):
        вернуться далее ((
            (proc, i) для i, proc in enumerate (self.processes)
            если proc.pid == pid
        ), (Нет, Нет))

    def on_soft_timeout (сам, задание):
        отладка ('мягкий предел времени превышен для% r', задание)
        процесс, _index = self._process_by_pid (job._worker_pid)
        если не процесс:
            возвращаться

        # Выполнить обратный вызов таймаута
        работа.handle_timeout (soft = True)

        пытаться:
            _kill (job._worker_pid, SIG_SOFT_TIMEOUT)
        кроме OSError как exc:
            если get_errno (exc)! = errno.ESRCH:
                поднимать

    def on_hard_timeout (сам, задание):
        если job. ready ():
            возвращаться
        отладка ('жесткий предел времени превышен для% r', задание)
        # Удалить из кеша и установить возвращаемое значение для исключения
        пытаться:
            поднять TimeLimitExceeded (job._timeout)
        кроме TimeLimitExceeded:
            работа._set (job._job, (False, ExceptionInfo ()))
        else: # pragma: без обложки
            проходить

        # Удалить из _pool
        процесс, _index = self._process_by_pid (job._worker_pid)

        # Выполнить обратный вызов таймаута
        job.handle_timeout (soft = False)

        если процесс:
            self._trywaitkill (процесс)

    def _trywaitkill (сам, рабочий):
        debug ('тайм-аут: отправка TERM% s', worker._name)
        пытаться:
            если os.getpgid (worker.pid) == worker.pid:
                debug ("работник% s - лидер группы.Можно безопасно убить (SIGTERM) всю группу ", worker.pid)
                os.killpg (os.getpgid (worker.pid), signal.SIGTERM)
            еще:
                worker. terminate ()
        кроме OSError:
            проходить
        еще:
            если worker._popen.wait (timeout = 0.1):
                возвращаться
        debug ('timeout: TERM timed-out, теперь отправка KILL% s', worker._name)
        пытаться:
            если os.getpgid (worker.pid) == worker.pid:
                debug ("работник% s - лидер группы.Можно безопасно убить (SIGKILL) всю группу ", worker.pid)
                os.killpg (os.getpgid (worker.pid), сигнал.SIGKILL)
            еще:
                _kill (worker.pid, SIGKILL)
        кроме OSError:
            проходить

    def handle_timeouts (сам):
        t_hard, t_soft = self.t_hard, self.t_soft
        грязный = набор ()
        on_soft_timeout = self.on_soft_timeout
        on_hard_timeout = self.on_hard_timeout

        def _timed_out (начало, тайм-аут):
            если не запускается или нет тайм-аута:
                return False
            если monotonic ()> = start + timeout:
                вернуть True

        # Внутренний цикл
        пока сам. _state == RUN:
            # Выполните неглубокую копию перед итерацией, потому что ключи могут измениться.
            # Глубокая копия не выполняется (при завершении работы) из-за объектов thread.lock.
            # https://github.com/celery/billiard/issues/260
            cache = copy.copy (self.cache)

            # Удаляем грязные элементы, которых больше нет в кеше
            если грязный:
                dirty = set (k вместо k в dirty, если k в кеше)

            для i задание в cache.items ():
                ack_time = job._time_accepted
                soft_timeout = работа._soft_timeout
                если soft_timeout равен None:
                    soft_timeout = t_soft
                hard_timeout = job._timeout
                если hard_timeout равен None:
                    hard_timeout = t_hard
                если _timed_out (ack_time, hard_timeout):
                    on_hard_timeout (задание)
                elif i not in dirty and _timed_out (ack_time, soft_timeout):
                    on_soft_timeout (задание)
                    dirty. add (я)
            урожай

    def body (self):
        пока сам._state == RUN:
            пытаться:
                для _ в self.handle_timeouts ():
                    time.sleep (1.0) # не крутить
            кроме CoroStop:
                перемена
        отладка ('завершение работы обработчика тайм-аута')

    def handle_event (self, * args):
        если self._it - None:
            self._it = self.handle_timeouts ()
        пытаться:
            следующий (self._it)
        кроме StopIteration:
            self._it = Нет


класс ResultHandler (PoolThread):

    def __init __ (self, outqueue, get, cache, poll,
                 join_exited_workers, putlock, restart_state,
                 check_timeouts, on_job_ready, on_ready_counters = None):
        себя.outqueue = outqueue
        self.get = получить
        self.cache = кеш
        self.poll = опрос
        self.join_exited_workers = join_exited_workers
        self.putlock = putlock
        self.restart_state = restart_state
        self. _it = Нет
        self._shutdown_complete = Ложь
        self.check_timeouts = check_timeouts
        self.on_job_ready = on_job_ready
        self.on_ready_counters = on_ready_counters
        self._make_methods ()
        super (ResultHandler, сам) .__ init __ ()

    def on_stop_not_started (самостоятельно):
        # используется при запуске пула без потока обработчика результатов.self.finish_at_shutdown (handle_timeouts = True)

    def _make_methods (самостоятельно):
        cache = self.cache
        putlock = self.putlock
        restart_state = self.restart_state
        on_job_ready = self.on_job_ready

        def on_ack (job, i, time_accepted, pid, synqW_fd):
            restart_state.R = 0
            пытаться:
                кэш [задание] ._ ack (i, time_accepted, pid, synqW_fd)
            кроме (KeyError, AttributeError):
                # Объект пропал или не поддерживает _ack (e.грамм. IMAPIterator).
                проходить

        def on_ready (задание, i, obj, inqW_fd):
            если on_job_ready не равно None:
                on_job_ready (задание, я, объект, inqW_fd)
            пытаться:
                item = кеш [задание]
            кроме KeyError:
                возвращаться

            если self. on_ready_counters:
                worker_pid = следующий (iter (item.worker_pids ()), Нет)
                если worker_pid и worker_pid в self.on_ready_counters:
                    on_ready_counter = сам.on_ready_counters [worker_pid]
                    с on_ready_counter.get_lock ():
                        on_ready_counter.value + = 1

            если не item.ready ():
                если putlock не равен None:
                    putlock.release ()
            пытаться:
                item._set (я, объект)
            кроме KeyError:
                проходить

        def on_death (pid, код выхода):
            пытаться:
                os.kill (pid, TERM_SIGNAL)
            кроме OSError как exc:
                если get_errno (exc)! = errno.ESRCH:
                    поднимать

        state_handlers = self.state_handlers = {
            ACK: on_ack, READY: on_ready, DEATH: on_death
        }

        def on_state_change (задача):
            состояние, args = задача
            пытаться:
                state_handlers [состояние] (* аргументы)
            кроме KeyError:
                отладка ("Неизвестное состояние задания:% s (args =% s)", состояние, аргументы)
        self. on_state_change = on_state_change

    def _process_result (self, timeout = 1.0):
        опрос = self.poll
        on_state_change = сам.on_state_change

        а 1:
            пытаться:
                готово, задача = опрос (тайм-аут)
            except (IOError, EOFError) как exc:
                debug ('обработчик результата получил% r - выход', exc)
                поднять CoroStop ()

            если self._state:
                assert self._state == TERMINATE
                debug ('найден обработчик результата thread._state = TERMINATE')
                поднять CoroStop ()

            если готов:
                если задача Нет:
                    отладка ('обработчик результатов получил дозор')
                    поднять CoroStop ()
                on_state_change (задача)
                if timeout! = 0: # блокировка
                    перемена
            еще:
                перемена
            урожай

    def handle_event (self, fileno = None, events = None):
        если сам. _state == RUN:
            если self._it - None:
                self._it = self._process_result (0) # неблокирующий
            пытаться:
                следующий (self._it)
            кроме (StopIteration, CoroStop):
                self._it = Нет

    def body (self):
        отладка ('запуск обработчика результатов')
        пытаться:
            пока self._state == RUN:
                пытаться:
                    for _ в self._process_result (1.0): # блокировка
                        проходить
                кроме CoroStop:
                    перемена
        наконец-то:
            себя.finish_at_shutdown ()

    def finish_at_shutdown (self, handle_timeouts = False):
        self._shutdown_complete = Верно
        get = self.get
        outqueue = self.outqueue
        cache = self.cache
        опрос = self.poll
        join_exited_workers = self.join_exited_workers
        check_timeouts = self.check_timeouts
        on_state_change = self.on_state_change

        time_terminate = Нет
        в то время как cache и self. _state! = TERMINATE:
            если check_timeouts не равно None:
                check_timeouts ()
            пытаться:
                готово, task = poll (1.0)
            except (IOError, EOFError) как exc:
                debug ('обработчик результата получил% r - выход', exc)
                возвращаться

            если готов:
                если задача Нет:
                    отладка ('обработчик результата игнорирует лишних дозорных')
                    Продолжить

                on_state_change (задача)
            пытаться:
                join_exited_workers (выключение = True)
            кроме WorkersJoined:
                сейчас = монотонный ()
                если не time_terminate:
                    time_terminate = сейчас
                еще:
                    если сейчас - time_terminate> 5.0:
                        отладка ('завершение работы обработчика: истекло время ожидания')
                        перемена
                    debug ('обработчик результата: все рабочие завершены,'
                          'тайм-аут в% ss',
                          абс (мин (сейчас - time_terminate - 5. 0, 0)))

        если hasattr (outqueue, '_reader'):
            отладка ('обеспечение того, что очередь не заполнена')
            # Если мы не освободим место в очереди, тогда
            # попыток добавить дозорного (Нет) в очередь может
            # блокировать.Гарантированно будет не более двух часовых.
            пытаться:
                для i в диапазоне (10):
                    если не outqueue._reader.poll ():
                        перемена
                    получать()
            кроме (IOError, EOFError):
                проходить

        debug ('выход обработчика результата: len (cache) =% s, thread._state =% s',
              len (кеш), self._state)


класс Пул (объект):
    '' '
    Класс, который поддерживает асинхронную версию применения функций к аргументам.
    '' '
    _wrap_exception = Истина
    Worker = Рабочий
    Супервайзер = Супервайзер
    TaskHandler = TaskHandler
    TimeoutHandler = TimeoutHandler
    ResultHandler = ResultHandler
    SoftTimeLimitExceeded = SoftTimeLimitExceeded

    def __init __ (self, process = None, initializer = None, initargs = (),
                 maxtasksperchild = Нет, тайм-аут = Нет, soft_timeout = Нет,
                 lost_worker_timeout = Нет,
                 max_restarts = Нет, max_restart_freq = 1,
                 on_process_up = Нет,
                 on_process_down = Нет,
                 on_timeout_set = Нет,
                 on_timeout_cancel = Нет,
                 thread = True,
                 семафор = Нет,
                 putlocks = False,
                 allow_restart = Ложь,
                 synack = False,
                 on_process_exit = Нет,
                 context = None,
                 max_memory_per_child = Нет,
                 enable_timeouts = Ложь,
                 ** kwargs):
        себя. _ctx = context или get_context ()
        self.synack = synack
        self._setup_queues ()
        self._taskqueue = Очередь ()
        self._cache = {}
        self._state = ВЫПОЛНИТЬ
        self.timeout = тайм-аут
        self.soft_timeout = soft_timeout
        self._maxtasksperchild = maxtasksperchild
        self._max_memory_per_child = max_memory_per_child
        self._initializer = инициализатор
        self._initargs = initargs
        self._on_process_exit = on_process_exit
        self.lost_worker_timeout = lost_worker_timeout или LOST_WORKER_TIMEOUT
        себя.on_process_up = on_process_up
        self.on_process_down = on_process_down
        self.on_timeout_set = on_timeout_set
        self.on_timeout_cancel = on_timeout_cancel
        self.threads = потоки
        self.readers = {}
        self.allow_restart = allow_restart

        self.enable_timeouts = bool (
            enable_timeouts или
            self.timeout не равен None или
            self.soft_timeout не равно None
        )

        если soft_timeout и SIG_SOFT_TIMEOUT равно None:
            предупреждения. предупреждать (UserWarning (
                «Мягкие таймауты не поддерживаются:»
                "на этой платформе: нет сигнала SIGUSR1.",
            ))
            soft_timeout = Нет

        self._processes = self.cpu_count (), если процессов нет, другие процессы
        self.max_restarts = max_restarts или раунд (self._processes * 100)
        self.restart_state = restart_state (max_restarts, max_restart_freq или 1)

        если инициализатор не равен None и не вызывается (инициализатор):
            поднять TypeError ('инициализатор должен быть вызываемым')

        если on_process_exit не None и не вызывается (on_process_exit):
            поднять TypeError ('on_process_exit должен быть вызываемым')

        себя._Process = self._ctx.Process

        self._pool = []
        self._poolctrl = {}
        self._on_ready_counters = {}
        self.putlocks = блокировки
        self._putlock = семафор или LaxBoundedSemaphore (self._processes)
        для i в диапазоне (self._processes):
            self. _create_worker_process (i)

        self._worker_handler = self.Supervisor (сам)
        если потоки:
            self._worker_handler.start ()

        self._task_handler = self.TaskHandler (self._taskqueue,
                                              себя._quick_put,
                                              self._outqueue,
                                              self._pool,
                                              self._cache)
        если потоки:
            self._task_handler.start ()

        self.check_timeouts = Нет

        # Поток убивает задания с тайм-аутом.
        если self.enable_timeouts:
            self._timeout_handler = self.TimeoutHandler (
                self._pool, self._cache,
                self.soft_timeout, self.timeout,
            )
            себя._timeout_handler_mutex = Блокировка ()
            self._timeout_handler_started = Ложь
            self._start_timeout_handler ()
            # При работе без потоков нам нужно проверить таймауты
            # ожидая незавершенной работы при выключении. 
            если не потоки:
                self.check_timeouts = self._timeout_handler.handle_event
        еще:
            self._timeout_handler = Нет
            self._timeout_handler_started = Ложь
            self._timeout_handler_mutex = Нет

        # Обработка потока приводит к выходу в очередь.self._result_handler = self.create_result_handler ()
        self.handle_result_event = self._result_handler.handle_event

        если потоки:
            self._result_handler.start ()

        self._terminate = Завершить (
            self, self._terminate_pool,
            args = (self._taskqueue, self._inqueue, self._outqueue,
                  self._pool, self._worker_handler, self._task_handler,
                  self._result_handler, self._cache,
                  self._timeout_handler,
                  себя._help_stuff_finish_args ()),
            exitpriority = 15,
        )

    def Process (self, * args, ** kwds):
        вернуть self._Process (* args, ** kwds)

    def WorkerProcess (сам, рабочий):
        вернуть worker. contribute_to_object (self.Process (target = worker))

    def create_result_handler (self, ** extra_kwargs):
        вернуть self.ResultHandler (
            self._outqueue, self._quick_get, self._cache,
            self._poll_result, self._join_exited_workers,
            self._putlock, self.restart_state, self.check_timeouts,
            self.on_job_ready, on_ready_counters = self._on_ready_counters,
            ** extra_kwargs
        )

    def on_job_ready (self, job, i, obj, inqW_fd):
        проходить

    def _help_stuff_finish_args (самостоятельно):
        вернуть self._inqueue, self._task_handler, self._pool

    def cpu_count (сам):
        пытаться:
            вернуть cpu_count ()
        кроме NotImplementedError:
            возврат 1

    def handle_result_event (self, * args):
        вернуть self._result_handler.handle_event (* args)

    def _process_register_queues (self, worker, queues):
        проходить

    def _process_by_pid (self, pid):
        вернуться далее ((
            (proc, i) для i, proc in enumerate (self. _бассейн)
            если proc.pid == pid
        ), (Нет, Нет))

    def get_process_queues (сам):
        вернуть self._inqueue, self._outqueue, None

    def _create_worker_process (self, i):
        sentinel = self._ctx.Event () if self.allow_restart else Нет
        inq, outq, synq = self.get_process_queues ()
        on_ready_counter = self._ctx.Value ('i')
        w = self.WorkerProcess (self.Worker (
            inq, outq, synq, self._initializer, self._initargs,
            self._maxtasksperchild, дозорный, сам._on_process_exit,
            # При использовании семафора ipc необходимо обрабатывать все сигналы,
            # чтобы убедиться, что семафор освобожден.
            sigprotection = self.threads,
            wrap_exception = self._wrap_exception,
            max_memory_per_child = self._max_memory_per_child,
            on_ready_counter = on_ready_counter,
        ))
        self._pool.append (ш)
        self._process_register_queues (ш, (вход, выход, синхронизация))
        w. name = w.name.replace ('Процесс', 'PoolWorker')
        ш.daemon = Истина
        w.index = i
        w.start ()
        self._poolctrl [w.pid] = дозорный
        self._on_ready_counters [w.pid] = on_ready_counter
        если self.on_process_up:
            self.on_process_up (ш)
        вернуть w

    def process_flush_queues (сам, рабочий):
        проходить

    def _join_exited_workers (self, shutdown = False):
        "" "Очистка после любых рабочих процессов, которые завершились из-за
        достигнув указанного срока службы. Возвращает True, если какие-либо рабочие были
        очищен."" "
        now = нет
        # Работник мог опубликовать результат до того, как был уволен,
        # но мы не можем точно сказать, было ли это. Итак, мы ждем
        # _lost_worker_timeout секунд до того, как мы помечаем задание с помощью
        # WorkerLostError.
        для задания в [задание для задания в списке (self._cache.values ​​())
                    если не job.ready () и job._worker_lost]:
            now = now или монотонный ()
            lost_time, lost_ret = job. _worker_lost
            если сейчас - lost_time> job._lost_worker_timeout:
                self.mark_as_worker_lost (работа, lost_ret)

        если выключение, а не len (self._pool):
            поднять WorkersJoined ()

        очищено, коды выхода = {}, {}
        для i в обратном порядке (диапазон (len (self._pool))):
            worker = self._pool [i]
            exitcode = worker.exitcode
            popen = worker._popen
            если popen равно None или код выхода не None:
                # работник вышел
                debug ('Супервизор: очистка работника% d', i)
                если popen не None:
                    рабочий.присоединиться()
                debug ('Супервизор: работал% d присоединился', i)
                очищено [worker.pid] = worker
                коды выхода [worker.pid] = код выхода
                если код выхода отсутствует в (EX_OK, EX_RECYCLE) и \
                        not getattr (worker, '_controlled_termination', False):
                    ошибка(
                        'Процесс% r pid:% r завершился с% r',
                        worker. name, worker.pid, human_status (код выхода),
                        exc_info = 0,
                    )
                себя.process_flush_queues (рабочий)
                del self._pool [i]
                del self._poolctrl [worker.pid]
                del self._on_ready_counters [worker.pid]
        если очищено:
            all_pids = [w.pid для w в self._pool]
            для работы в списке (self._cache.values ​​()):
                acked_by_gone = следующий (
                    (pid для pid в job.worker_pids ()
                     если pid в очищенном или pid не во all_pids),
                    Никто
                )
                # уже принято процессом
                если acked_by_gone:
                    себя.on_job_process_down (задание, acked_by_gone)
                    если не job.ready ():
                        exitcode = exitcodes.get (acked_by_gone) или 0
                        proc = cleaned.get (acked_by_gone)
                        если proc и getattr (proc, '_job_terminated', False):
                            job. _set_terminated (код выхода)
                        еще:
                            self.on_job_process_lost (
                                задание, acked_by_gone, код выхода,
                            )
                еще:
                    # начал писать в
                    write_to = работа._написать в
                    # было запланировано написать
                    sched_for = job._scheduled_for

                    если write_to, а не write_to._is_alive ():
                        self.on_job_process_down (задание, write_to.pid)
                    elif sched_for, а не sched_for._is_alive ():
                        self.on_job_process_down (задание, sched_for.pid)

            для рабочего в значениях (убран):
                если self.on_process_down:
                    если не выключить:
                        себя._process_cleanup_queues (рабочий)
                    self.on_process_down (рабочий)
            список возврата (exitcodes.values ​​())
        возвращаться []

    def on_partial_read (я, работа, работник):
        проходить

    def _process_cleanup_queues (сам, рабочий):
        проходить

    def on_job_process_down (self, job, pid_gone):
        проходить

    def on_job_process_lost (self, job, pid, exitcode):
        job. _worker_lost = (монотонный (), код выхода)

    def mark_as_worker_lost (self, job, exitcode):
        пытаться:
            поднять WorkerLostError (
                'Работник преждевременно завершил работу: {0}.'.формат(
                    human_status (код выхода)),
            )
        кроме WorkerLostError:
            job._set (Нет, (False, ExceptionInfo ()))
        else: # pragma: без обложки
            проходить

    def __enter __ (сам):
        вернуть себя

    def __exit __ (self, * exc_info):
        вернуть self.terminate ()

    def on_grow (себя, n):
        проходить

    def on_shrink (self, n):
        проходить

    def shrink (self, n = 1):
        для i, рабочий в enumerate (self._iterinactive ()):
            себя._processes - = 1
            если self._putlock:
                self._putlock.shrink ()
            worker.terminate_controlled ()
            self.on_shrink (1)
            если i> = n - 1:
                перемена
        еще:
            Raise ValueError ("Не удается сжать пул.  Все процессы заняты!")

    def grow (self, n = 1):
        для i в диапазоне (n):
            self._processes + = 1
            если self._putlock:
                self._putlock.grow ()
        self.on_grow (сущ.)

    def _iterinactive (сам):
        для работника в себе._бассейн:
            если не self._worker_active (worker):
                урожайный работник

    def _worker_active (сам, рабочий):
        для работы в значениях (self._cache):
            если worker.pid в job.worker_pids ():
                вернуть True
        return False

    def _repopulate_pool (self, exitcodes):
        "" "Довести количество процессов пула до указанного числа,
        для использования после жатвы вышедших рабочих.
        "" "
        для i в диапазоне (self._processes - len (self._pool)):
            если сам._state! = ЗАПУСК:
                возвращаться
            пытаться:
                если коды выхода и коды выхода [i] отсутствуют в (EX_OK, EX_RECYCLE):
                    self. restart_state.step ()
            кроме IndexError:
                self.restart_state.step ()
            self._create_worker_process (self._avail_index ())
            отладка ('добавленный работник')

    def _avail_index (сам):
        assert len ​​(self._pool)  close ()
                self.join ()
                поднимать
            кроме OSError как exc:
                если get_errno (exc) == errno.ENOMEM:
                    ререйз (MemoryError,
                            MemoryError (str (exc)),
                            sys.exc_info () [2])
                поднимать

    def _setup_queues (сам):
        self._inqueue = self._ctx.SimpleQueue ()
        себя._outqueue = self._ctx.SimpleQueue ()
        self._quick_put = self._inqueue._writer.send
        self._quick_get = self._outqueue._reader.recv

        def _poll_result (тайм-аут):
            если self._outqueue._reader.poll (тайм-аут):
                return True, self._quick_get ()
            return False, None
        self._poll_result = _poll_result

    def _start_timeout_handler (сам):
        # убедитесь, что более одного потока не запускают обработчик тайм-аута
        # поток сразу.
        если сам.потоков и self._timeout_handler не равно None:
            с self._timeout_handler_mutex:
                если не self. _timeout_handler_started:
                    self._timeout_handler_started = Верно
                    self._timeout_handler.start ()

    def apply (self, func, args = (), kwds = {}):
        '' '
        Эквивалент `func (* args, ** kwargs)`.
        '' '
        если self._state == RUN:
            вернуть self.apply_async (func, args, kwds) .get ()

    def starmap (self, func, iterable, chunksize = None):
        '' '
        Подобно методу `map ()`, но ожидается, что элементы `iterable`
        быть итерируемыми, и они будут распакованы как аргументы.Следовательно
        `func` и (a, b) становится func (a, b).
        '' '
        если self._state == RUN:
            вернуть self._map_async (func, итерабельность,
                                   starmapstar, chunksize) .get ()

    def starmap_async (self, func, iterable, chunksize = None,
                      callback = None, error_callback = None):
        '' '
        Асинхронная версия метода starmap ().
        '' '
        если self. _state == RUN:
            вернуть self._map_async (func, iterable, starmapstar, chunksize,
                                   callback, error_callback)

    def map (self, func, iterable, chunksize = None):
        '' '
        Примените func к каждому элементу в iterable, собирая результаты
        в возвращаемом списке.'' '
        если self._state == RUN:
            вернуть self.map_async (func, iterable, chunksize) .get ()

    def imap (self, func, iterable, chunksize = 1, lost_worker_timeout = None):
        '' '
        Эквивалент `map ()` - может быть НАМНОГО медленнее, чем `Pool.map ()`.
        '' '
        если self._state! = RUN:
            возвращаться
        lost_worker_timeout = lost_worker_timeout или self.lost_worker_timeout
        если chunksize == 1:
            результат = IMapIterator (self._cache,
                                  lost_worker_timeout = lost_worker_timeout)
            себя._taskqueue.put ((
                ((ЗАДАЧА, (результат._задание, i, func, (x,), {}))
                 для i, x in enumerate (итерация)),
                result. _set_length,
            ))
            вернуть результат
        еще:
            assert chunksize> 1
            task_batches = Pool._get_tasks (функция, итерабельность, размер фрагмента)
            результат = IMapIterator (self._cache,
                                  lost_worker_timeout = lost_worker_timeout)
            self._taskqueue.put ((
                ((ЗАДАЧА, (результат._job, i, mapstar, (x,), {}))
                 для i, x в enumerate (task_batches)),
                result._set_length,
            ))
            return (элемент для чанка в результате для элемента в чанке)

    def imap_unordered (self, func, iterable, chunksize = 1,
                       lost_worker_timeout = Нет):
        '' '
        Подобен методу `imap ()`, но порядок результатов произвольный.
        '' '
        если self._state! = RUN:
            возвращаться
        lost_worker_timeout = lost_worker_timeout или себя.lost_worker_timeout
        если chunksize == 1:
            результат = IMapUnorderedIterator (
                self. _cache, lost_worker_timeout = lost_worker_timeout,
            )
            self._taskqueue.put ((
                ((ЗАДАЧА, (результат._задание, i, func, (x,), {}))
                 для i, x in enumerate (итерация)),
                result._set_length,
            ))
            вернуть результат
        еще:
            assert chunksize> 1
            task_batches = Pool._get_tasks (функция, итерабельность, размер фрагмента)
            результат = IMapUnorderedIterator (
                себя._cache, lost_worker_timeout = lost_worker_timeout,
            )
            self._taskqueue.put ((
                ((ЗАДАЧА, (результат._задание, i, mapstar, (x,), {}))
                 для i, x в enumerate (task_batches)),
                result._set_length,
            ))
            return (элемент для чанка в результате для элемента в чанке)

    def apply_async (self, func, args = (), kwds = {},
                    callback = None, error_callback = None, accept_callback = None,
                    timeout_callback = Нет, waitforslot = Нет,
                    soft_timeout = Нет, тайм-аут = Нет, lost_worker_timeout = Нет,
                    callbacks_propagate = (),
                    correlation_id = None):
        '' '
        Асинхронный эквивалент метода apply (). Обратный вызов вызывается, когда возвращается значение функции.
        Обратный вызов accept вызывается, когда задание принимается к выполнению.

        Упрощенный поток выглядит так:

            >>> def apply_async (func, args, kwds, callback, accept_callback):
            ... если accept_callback:
            ... accept_callback ()
            ... retval = func (* аргументы, ** kwds)
            ... если обратный вызов:
            ... обратный вызов (retval)

        '' '
        если сам._state! = ЗАПУСК:
            возвращаться
        soft_timeout = soft_timeout или self.soft_timeout
        timeout = тайм-аут или self.timeout
        lost_worker_timeout = lost_worker_timeout или self.lost_worker_timeout
        если soft_timeout и SIG_SOFT_TIMEOUT равно None:
            warnings.warn (UserWarning (
                «Мягкие таймауты не поддерживаются:»
                "на этой платформе: нет сигнала SIGUSR1.",
            ))
            soft_timeout = Нет
        если self._state == RUN:
            waitforslot = self. блокирует, если waitforslot равен None else waitforslot
            если waitforslot и self._putlock не равно None:
                self._putlock.acquire ()
            результат = ApplyResult (
                self._cache, callback, accept_callback, timeout_callback,
                error_callback, soft_timeout, timeout, lost_worker_timeout,
                on_timeout_set = self.on_timeout_set,
                on_timeout_cancel = self.on_timeout_cancel,
                callbacks_propagate = callbacks_propagate,
                send_ack = сам.send_ack, если self.synack еще Нет,
                correlation_id = correlation_id,
            )
            если таймаут или soft_timeout:
                # запускаем поток обработчика тайм-аута, когда это необходимо.
                self._start_timeout_handler ()
            если self.threads:
                self._taskqueue.put (([(ЗАДАЧА, (result._job, None,
                                    func, args, kwds))], None))
            еще:
                self. _quick_put ((ЗАДАЧА, (result._job, None, func, args, kwds)))
            вернуть результат

    def send_ack (self, response, job, i, fd):
        проходить

    def terminate_job (self, pid, sig = None):
        proc, _ = self._process_by_pid (pid)
        если proc не равен None:
            пытаться:
                _kill (pid, sig или TERM_SIGNAL)
            кроме OSError как exc:
                если get_errno (exc)! = errno.ESRCH:
                    поднимать
            еще:
                proc._controlled_termination = Верно
                proc._job_terminated = Верно

    def map_async (self, func, iterable, chunksize = None,
                  callback = None, error_callback = None):
        '' '
        Асинхронный эквивалент метода map ().'' '
        вернуть self._map_async (
            func, iterable, mapstar, chunksize, callback, error_callback,
        )

    def _map_async (self, func, iterable, mapper, chunksize = None,
                   callback = None, error_callback = None):
        '' '
        Вспомогательная функция для реализации map, starmap и их асинхронных аналогов. 
        '' '
        если self._state! = RUN:
            возвращаться
        если не hasattr (iterable, '__len__'):
            iterable = список (повторяемый)

        если размер блока - None:
            chunksize, extra = divmod (len (итерабельность), len (self._pool) * 4)
            если дополнительно:
                chunksize + = 1
        если len (итерабельность) == 0:
            chunksize = 0

        task_batches = Pool._get_tasks (функция, итерабельность, размер фрагмента)
        результат = MapResult (self._cache, chunksize, len (итерация), обратный вызов,
                           error_callback = error_callback)
        self._taskqueue.put ((((ЗАДАЧА, (result._job, i, mapper, (x,), {}))
                              для i, x в enumerate (task_batches)), None))
        вернуть результат

    @staticmethod
    def _get_tasks (func, it, size):
        it = iter (оно)
        а 1:
            x = кортеж (itertools.islice (он, размер))
            если не x:
                возвращаться
            выход (функция, х)

    def __reduce __ (сам):
        поднять NotImplementedError (
            'объекты пула нельзя передавать между процессами или мариновать',
        )

    def close (self):
        отладка («закрывающийся пул»)
        если self. _state == RUN:
            self._state = ЗАКРЫТЬ
            если self._putlock:
                self._putlock.clear ()
            self._worker_handler.close ()
            self._taskqueue.put (Нет)
            stop_if_not_current (сам._worker_handler)

    def terminate (self):
        отладка ('конечный пул')
        self._state = ПРЕКРАТИТЬ
        self._worker_handler.terminate ()
        self._terminate ()

    @staticmethod
    def _stop_task_handler (task_handler):
        stop_if_not_current (task_handler)

    def join (self):
        утверждать self._state в (ЗАКРЫТЬ, ПРЕКРАТИТЬ)
        отладка ('присоединение к обработчику рабочего')
        stop_if_not_current (self._worker_handler)
        отладка ('присоединение к обработчику задачи')
        self._stop_task_handler (сам._task_handler)
        отладка ('присоединение обработчика результата')
        stop_if_not_current (self._result_handler)
        отладка ('обработчик результатов присоединился')
        для i, p в enumerate (self. _pool):
            debug ('присоединяющийся к рабочему% s /% s (% r)', i + 1, len (self._pool), p)
            если p._popen не None: # процесс запущен?
                p.join ()
        отладка ('объединение в пул завершено')

    def перезапуск (сам):
        для e в значениях (self._poolctrl):
            e.set ()

    @staticmethod
    def _help_stuff_finish (inqueue, task_handler, _pool):
        # task_handler может быть заблокирован при попытке поместить элементы в очередь
        отладка ('удаление задач из очереди до завершения обработчика задач')
        в очереди._rlock.acquire ()
        пока task_handler.is_alive () и inqueue._reader.poll ():
            inqueue._reader.recv ()
            время сна (0)

    @classmethod
    def _set_result_sentinel (cls, outqueue, pool):
        outqueue.put (Нет)

    @classmethod
    def _terminate_pool (cls, taskqueue, inqueue, outqueue, pool,
                        worker_handler, task_handler,
                        result_handler, cache, timeout_handler,
                        help_stuff_finish_args):

        # гарантированно вызывается только один раз
        отладка ('финализирующий пул')

        worker_handler. terminate ()

        task_handler.terminate ()
        taskqueue.put (Нет) # sentinel

        отладка ('помощь обработчику задачи / работникам в завершении')
        cls._help_stuff_finish (* help_stuff_finish_args)

        result_handler.terminate ()
        cls._set_result_sentinel (очередь, пул)

        если timeout_handler не равен None:
            timeout_handler.terminate ()

        # Завершить рабочие процессы, которые еще не завершились
        если пул и hasattr (пул [0], 'завершить'):
            отладка («завершающие рабочие»)
            для p в бассейне:
                если п._жив():
                    p.terminate ()

        отладка ('присоединение к обработчику задачи')
        cls._stop_task_handler (task_handler)

        отладка ('присоединение обработчика результата')
        result_handler.stop ()

        если timeout_handler не равен None:
            отладка ('обработчик тайм-аута присоединения')
            timeout_handler.stop (TIMEOUT_MAX)

        если пул и hasattr (пул [0], 'завершить'):
            отладка ('присоединение к работникам пула')
            для p в бассейне:
                если p. is_alive ():
                    # работник еще не завершил работу
                    debug ('очистка рабочего% d', стр.pid)
                    если p._popen не равно None:
                        p.join ()
            отладка ('работники пула присоединились')

        если в очереди:
            inqueue.close ()
        если вне очереди:
            outqueue.close ()

    @свойство
    def process_sentinels (сам):
        вернуть [w._popen.sentinel for w в self._pool]

#
# Класс, экземпляры которого возвращаются `Pool.apply_async ()`
#


класс ApplyResult (объект):
    _worker_lost = Нет
    _write_to = Нет
    _scheduled_for = Нет

    def __init __ (self, cache, callback, accept_callback = None,
                 timeout_callback = Нет, error_callback = Нет, soft_timeout = Нет,
                 timeout = Нет, lost_worker_timeout = LOST_WORKER_TIMEOUT,
                 on_timeout_set = Нет, on_timeout_cancel = Нет,
                 callbacks_propagate = (), send_ack = Нет,
                 correlation_id = None):
        себя. correlation_id = correlation_id
        self._mutex = Блокировка ()
        self._event = threading.Event ()
        self._job = next (job_counter)
        self._cache = кеш
        self._callback = обратный вызов
        self._accept_callback = accept_callback
        self._error_callback = error_callback
        self._timeout_callback = timeout_callback
        self._timeout = тайм-аут
        self._soft_timeout = soft_timeout
        self._lost_worker_timeout = lost_worker_timeout
        self._on_timeout_set = on_timeout_set
        себя._on_timeout_cancel = on_timeout_cancel
        self._callbacks_propagate = callbacks_propagate или ()
        self._send_ack = send_ack

        self._accepted = Ложь
        self._cancelled = Ложь
        self._worker_pid = Нет
        self._time_accepted = Нет
        self._terminated = Нет
        кеш [self._job] = себя

    def __repr __ (сам):
        return '<% s: {id} ack: {ack} ready: {ready}>'. format (
            self .__ class __.__ name__,
            id = self. _job, ack = self._accepted, ready = self.готовы(),
        )

    def готов (сам):
        вернуть self._event.isSet ()

    def принято (самостоятельно):
        вернуть self._accepted

    def успешно (сам):
        утверждать self.ready ()
        вернуть self._success

    def _cancel (сам):
        "" "Работает только при использовании synack." ""
        self._cancelled = Верно

    def discard (self):
        self._cache.pop (self._job, Нет)

    def terminate (self, signum):
        self._terminated = signum

    def _set_terminated (self, signum = None):
        пытаться:
            Raise прекращено (- (signum или 0))
        кроме прекращенного:
            себя._set (Нет, (Ложь, ExceptionInfo ()))

    def worker_pids (сам):
        вернуть [self._worker_pid], если self._worker_pid else []

    def wait (self, timeout = None):
        self._event.wait (тайм-аут)

    def get (self, timeout = None):
        self.wait (тайм-аут)
        если не self.ready ():
            поднять TimeoutError
        если self. _success:
            вернуть self._value
        еще:
            поднять self._value.exception

    def safe_apply_callback (self, fun, * args, ** kwargs):
        если весело:
            пытаться:
                веселье (* аргументы, ** kwargs)
            кроме себя._callbacks_propagate:
                поднимать
            кроме исключения как exc:
                error ('Возникла исключительная ситуация обратного вызова пула:% r', exc,
                      exc_info = 1)

    def handle_timeout (self, soft = False):
        если self._timeout_callback не равен None:
            self.safe_apply_callback (
                self._timeout_callback, soft = soft,
                timeout = self._soft_timeout если soft else self._timeout,
            )

    def _set (self, i, obj):
        с self._mutex:
            если сам._on_timeout_cancel:
                self._on_timeout_cancel (сам)
            self._success, self._value = obj
            self._event.set ()
            если self. _accepted:
                # если еще не принято, то установленное сообщение
                # был получен до подтверждения, что означает
                # подтверждение удалит запись.
                self._cache.pop (self._job, Нет)

            # применить обратные вызовы последними
            если self._callback и self._success:
                self.safe_apply_callback (
                    себя._callback, self._value)
            if (self._value не равно None и
                    self._error_callback, а не self._success):
                self.safe_apply_callback (
                    self._error_callback, self._value)

    def _ack (self, i, time_accepted, pid, synqW_fd):
        с self._mutex:
            если self._cancelled и self._send_ack:
                self._accepted = Верно
                если synqW_fd:
                    вернуть self._send_ack (NACK, pid, self._job, synqW_fd)
                возвращаться
            себя._accepted = Верно
            self._time_accepted = время_принято
            self. _worker_pid = pid
            если self.ready ():
                # подтверждение получено после set ()
                self._cache.pop (self._job, Нет)
            если self._on_timeout_set:
                self._on_timeout_set (self, self._soft_timeout, self._timeout)
            response = ACK
            если self._accept_callback:
                пытаться:
                    self._accept_callback (pid, time_accepted)
                кроме себя._propagate_errors:
                    response = NACK
                    поднимать
                кроме исключения:
                    response = NACK
                    # игнорировать другие ошибки
                наконец-то:
                    если self._send_ack и synqW_fd:
                        вернуть self._send_ack (
                            ответ, pid, self._job, synqW_fd
                        )
            если self._send_ack и synqW_fd:
                self._send_ack (ответ, pid, self._job, synqW_fd)

#
# Класс, экземпляры которого возвращаются `Pool. map_async ()`
#


класс MapResult (ApplyResult):

    def __init __ (self, cache, chunksize, length, callback, error_callback):
        ApplyResult .__ init __ (
            сам, кеш, обратный вызов, error_callback = error_callback,
        )
        self._success = Верно
        self._length = длина
        self._value = [Нет] * длина
        self._accepted = [False] * длина
        self._worker_pid = [None] * длина
        self._time_accepted = [Нет] * длина
        себя._chunksize = размер фрагмента
        если chunksize <= 0:
            self._number_left = 0
            self._event.set ()
            del cache [self._job]
        еще:
            self._number_left = length // chunksize + bool (длина% chunksize)

    def _set (self, i, success_result):
        успех, результат = success_result
        в случае успеха:
            self._value [i * self._chunksize: (i + 1) * self._chunksize] = результат
            self._number_left - = 1
            если self._number_left == 0:
                если сам. _Перезвоните:
                    self._callback (self._value)
                если self._accepted:
                    self._cache.pop (self._job, Нет)
                self._event.set ()
        еще:
            self._success = Ложь
            self._value = результат
            если self._error_callback:
                self._error_callback (self._value)
            если self._accepted:
                self._cache.pop (self._job, Нет)
            self._event.set ()

    def _ack (self, i, time_accepted, pid, * args):
        начало = я * сам._chunksize
        stop = min ((i + 1) * self._chunksize, self._length)
        для j в диапазоне (старт, стоп):
            self._accepted [j] = Верно
            self._worker_pid [j] = pid
            self._time_accepted [j] = time_accepted
        если self.ready ():
            self._cache.pop (self._job, Нет)

    def принято (самостоятельно):
        вернуть все (self._accepted)

    def worker_pids (сам):
        return [pid для pid в self. _worker_pid if pid]

#
# Класс, экземпляры которого возвращаются `Pool.imap ()`
#


класс IMapIterator (объект):
    _worker_lost = Нет

    def __init __ (self, cache, lost_worker_timeout = LOST_WORKER_TIMEOUT):
        себя._cond = threading.Condition (threading.Lock ())
        self._job = next (job_counter)
        self._cache = кеш
        self._items = deque ()
        self._index = 0
        self._length = Нет
        self._ready = Ложь
        self._unsorted = {}
        self._worker_pids = []
        self._lost_worker_timeout = lost_worker_timeout
        кеш [self._job] = себя

    def __iter __ (сам):
        вернуть себя

    def next (self, timeout = None):
        с self._cond:
            пытаться:
                item = self._items.popleft ()
            кроме IndexError:
                если self._index == self._length:
                    self._ready = Верно
                    поднять StopIteration
                self._cond.wait (тайм-аут)
                пытаться:
                    item = self. _items.popleft ()
                кроме IndexError:
                    если self._index == self._length:
                        self._ready = Верно
                        поднять StopIteration
                    поднять TimeoutError

        успех, значение = элемент
        в случае успеха:
            возвращаемое значение
        поднять исключение (значение)

    __next__ = следующий # XXX

    def _set (self, i, obj):
        с собой._ second:
            если self._index == i:
                self._items.append (объект)
                self._index + = 1
                а self._index в self._unsorted:
                    obj = self._unsorted.pop (self._index)
                    self._items.append (объект)
                    self._index + = 1
                self._cond.notify ()
            еще:
                self._unsorted [i] = obj

            если self._index == self._length:
                self._ready = Верно
                дель себя._cache [self._job]

    def _set_length (self, длина):
        с self. _cond:
            self._length = длина
            если self._index == self._length:
                self._ready = Верно
                self._cond.notify ()
                del self._cache [self._job]

    def _ack (self, i, time_accepted, pid, * args):
        self._worker_pids.append (pid)

    def готов (сам):
        вернуть self._ready

    def worker_pids (сам):
        вернуть self._worker_pids

#
# Класс, экземпляры которого возвращаются `Pool.imap_unordered () `
#


класс IMapUnorderedIterator (IMapIterator):

    def _set (self, i, obj):
        с self._cond:
            self._items.append (объект)
            self._index + = 1
            self._cond.notify ()
            если self._index == self._length:
                self._ready = Верно
                del self._cache [self._job]

#
#
#


класс ThreadPool (Пул):

    из .dummy import Process как DummyProcess
    Процесс = DummyProcess

    def __init __ (self ,cesses = None, initializer = None, initargs = ()):
        Бассейн. __init __ (сам, процессы, инициализатор, параметры инициализации)

    def _setup_queues (сам):
        self._inqueue = Очередь ()
        self._outqueue = Очередь ()
        self._quick_put = self._inqueue.put
        self._quick_get = self._outqueue.get

        def _poll_result (тайм-аут):
            пытаться:
                вернуть True, self._quick_get (timeout = timeout)
            кроме пустого:
                return False, None
        self._poll_result = _poll_result

    @staticmethod
    def _help_stuff_finish (inqueue, task_handler, pool):
        # поставить часовых во главе очереди, чтобы рабочие закончили
        с постановкой в ​​очередь.не пустой:
            inqueue.queue.clear ()
            inqueue.queue.extend ([Нет] * len (пул))
            inqueue.not_empty.notify_all ()
 

django — Celery: WorkerLostError: Worker завершился преждевременно: сигнал 9 (SIGKILL)

Я использую Celery с RabbitMQ в моем приложении Django (на Elastic Beanstalk) для управления фоновыми задачами и демонизировал его с помощью Supervisor. Теперь проблема в том, что одна из задач периода, которые я определил, не работает (после недели, в которой она работала правильно), у меня есть ошибка:

  [01 / Apr / 2014 23:04:03] [ОШИБКА] [сельдерей.worker.job: 272] Task clean-dead-sessions [1bfb5a0a-7914-4623-8b5b-35fc68443d2e] неожиданно вызвал: WorkerLostError ('Рабочий завершил работу преждевременно: сигнал 9 (SIGKILL).',)
Отслеживание (последний вызов последний):
  Файл "/opt/python/run/venv/lib/python2.7/site-packages/billiard/pool.py", строка 1168, в mark_as_worker_lost
    human_status (код выхода)),
WorkerLostError: работник преждевременно завершил работу: сигнал 9 (SIGKILL).
  

Все процессы, которыми управляет супервизор, запущены и работают должным образом ( supervisorctl status говорит: RUNNING ).

Я попытался прочитать несколько журналов на моем экземпляре ec2, но, похоже, никто не помог мне выяснить, в чем причина SIGKILL . Что я должен делать? Как я могу расследовать?

Это мои настройки сельдерея :

  CELERY_TIMEZONE = 'UTC'
CELERY_TASK_SERIALIZER = 'json'
CELERY_ACCEPT_CONTENT = ['json']
BROKER_URL = os. environ ['RABBITMQ_URL']
CELERY_IGNORE_RESULT = Верно
CELERY_DISABLE_RATE_LIMITS = Ложь
CELERYD_HIJACK_ROOT_LOGGER = Ложь
  

А это мой супервайзер .конф :

  [программа: celery_worker]
среда = $ env_variables
каталог = / opt / python / current / app
команда = / opt / python / run / venv / bin / celery worker -A com.cygora -l info --pidfile = / opt / python / run / celery_worker.pid
startsecs = 10
stopwaitsecs = 60
stopasgroup = true
killasgroup = правда
autostart = true
autorestart = true
stdout_logfile = / opt / python / log / celery_worker.stdout.log
stdout_logfile_maxbytes = 5 МБ
stdout_logfile_backups = 10
stderr_logfile = / opt / python / log / celery_worker.stderr.log
stderr_logfile_maxbytes = 5 МБ
stderr_logfile_backups = 10
numprocs = 1

[программа: celery_beat]
среда = $ env_variables
каталог = / opt / python / current / app
команда = / opt / python / run / venv / bin / celery beat -A com.cygora -l info --pidfile = / opt / python / run / celery_beat. pid --schedule = / opt / python / run / celery_beat_schedule
startsecs = 10
stopwaitsecs = 300
stopasgroup = true
killasgroup = правда
autostart = false
autorestart = true
stdout_logfile = / opt / python / log / celery_beat.stdout.log
stdout_logfile_maxbytes = 5 МБ
stdout_logfile_backups = 10
stderr_logfile = / opt / python / log / celery_beat.stderr.log
stderr_logfile_maxbytes = 5 МБ
stderr_logfile_backups = 10
numprocs = 1
  

Редактировать 1

После перезапуска celery beat проблема осталась.

Редактировать 2

Изменено killasgroup = true на killasgroup = false , и проблема остается.

python — Celery WorkerLostError Worker завершился преждевременно: сигнал 6 (SIGABRT)

Я хочу, чтобы асинхронная работа выполнялась синхронно. Я использую идентификатор данных в couchbase как ключ Redis. Я снова добавляю couchbase со значением redis. Он отлично работает, когда он работает синхронно, но не работает, когда он выполняется асинхронно.

  из couchbase.cluster import Cluster
из couchbase.cluster импортировать PasswordAuthenticator
из couchbase.n1ql импорт N1QLQuery
из couchbase.n1ql импорт N1QLRequest
из elasticsearch импорт Elasticsearch
от времени импортный сон
из запроса на импорт urllib
из клиента импорта wikidata.client
из openpyxl import Workbook
импорт base64
импортировать json
импорт osmapi
импорт ре
импортировать Redis
импортировать urllib
импортировать хэш-библиотеку
время импорта
запросы на импорт
импорт csv
от импорта functools уменьшить

wikid_client = Клиент ()
es_client = Elasticsearch ("-")
cluster = Cluster ('couchbase: // -')
аутентификатор = PasswordAuthenticator ('ATLAS-DEV', 'ATLAS-DEV')
кластер.аутентифицировать (аутентификатор)
bucket_test = cluster.open_bucket ('ATLAS-DEV')
redis_db = redis.StrictRedis (host = '-', port = 6379, db = 10, decode_responses = True)
map_api = osmapi.OsmApi ()
N1QLQuery.timeout = 3600


def deep_get (словарь, ключи, по умолчанию = Нет):
    return reduce (lambda d, key: d. get (key, default) if isinstance (d, dict) else default, keys.split ("."), dictionary)

query = N1QLQuery ("ВЫБРАТЬ meta (). id, * FROM` ATLAS-DEV` WHERE class_type = 'REGION' AND (code.osm IS NOT NULL OR code.osm! = '') LIMIT 20 ")
для k в bucket_test.n1ql_query (запрос):
    # print ("k:")
    # print (k)
    document_id = k.get ("идентификатор")
    # print ("document_id:" + document_id)
    osm_id = deep_get (k, "ATLAS-DEV.codes.osm")
    polygon = redis_db.hget (name = "osm: polygons", key = osm_id)
    если многоугольник не равен None:
        k ['ATLAS-DEV']. update ({'limits': polygon})
        bucket_test.upsert (идентификатор_документа, k ['ATLAS-DEV'])
  

это моя синхронная работа. это работает хорошо. это может перевернуть кушетку.

, но вот мой код работы с сельдереем.

  из app.jobs.task import each_k
query = N1QLQuery ("ВЫБРАТЬ meta (). id, * FROM` ATLAS-DEV` WHERE class_type = 'REGION' AND (code.osm IS NOT NULL OR code.osm! = '') LIMIT 5 ")
для k в bucket_test. n1ql_query (запрос):
    # print ("k:")
    # print (k)
    each_k.delay (k)




# /app/jobs/task.py

def deep_get (словарь, ключи, по умолчанию = Нет):
    return reduce (lambda d, key: d.get (key, default) if isinstance (d, dict) else default, keys.split ("."), dictionary)

@ app.task
@provide_redis
def each_k (redis_db, k):
    print ("레디 스 디비:")
    печать (redis_db)
    document_id = k.получить ("идентификатор")
    print ("document_id:" + document_id)
    osm_id = deep_get (k, "ATLAS-DEV.codes.osm")
    polygon = redis_db.hget (name = "osm: polygons", key = osm_id)
    печать ("폴리곤:")
    печать (многоугольник)
    если многоугольник не равен None:
        k ['ATLAS-DEV']. update ({'limits': polygon})
        bucket_test.upsert (идентификатор_документа, k ['ATLAS-DEV'])

  

возвращает

  [предупредить] kevent: неверный дескриптор файла
python-couchbase: self-> nremaining == 0 в src / oputil.c: 67. Прервать [2019-06-26 15: 13: 03,675: ERROR / MainProcess] Обработчик задачи вызвал ошибку: WorkerLostError ('Рабочий завершил работу преждевременно: сигнал 6 (SIGABRT). ')
Отслеживание (последний вызов последний):
  Файл "/Users/n18016/Library/Python/3.7/lib/python/site-packages/billiard/pool.py", строка 1226, в mark_as_worker_lost
    human_status (код выхода)),
billiard.exceptions.WorkerLostError: Рабочий завершил работу преждевременно: сигнал 6 (SIGABRT).
[2019-06-26 15: 13: 03,701: ERROR / MainProcess] Процесс 'ForkPoolWorker-11' pid: 7697 завершился с 'сигналом 6 (SIGABRT)'
[2019-06-26 15: 13: 03,702: ERROR / MainProcess] Процесс 'ForkPoolWorker-10' pid: 7696 завершился с 'сигналом 6 (SIGABRT)'
[2019-06-26 15: 13: 03,703: ERROR / MainProcess] Обработчик задачи вызвал ошибку: WorkerLostError ('Worker завершил работу преждевременно: сигнал 6 (SIGABRT).')
Отслеживание (последний вызов последний):
  Файл "/Users/n18016/Library/Python/3.7/lib/python/site-packages/billiard/pool.py", строка 1226, в mark_as_worker_lost
    human_status (код выхода)),
billiard.exceptions.WorkerLostError: Рабочий завершил работу преждевременно: сигнал 6 (SIGABRT).
[2019-06-26 15: 13: 03,704: ERROR / MainProcess] Обработчик задачи вызвал ошибку: WorkerLostError ('Рабочий завершил работу преждевременно: сигнал 6 (SIGABRT). ')
Отслеживание (последний вызов последний):
  Файл "/Users/n18016/Library/Python/3.7/lib/python/site-packages/billiard/pool.py ", строка 1226, в mark_as_worker_lost
    human_status (код выхода)),
billiard.exceptions.WorkerLostError: Рабочий завершил работу преждевременно: сигнал 6 (SIGABRT).

  

Работница, пораженная бильярдным шаром во время обеда в RAA, отменяет постановление о компенсации

Работница одной из крупнейших страховых компаний Южной Австралии, раненная бильярдным шаром по голове, говорит, что она больше не может работать и заслуживает компенсации.

Ключевые моменты:

• Сьюзан Стоддард была ранена по голове во время еды в кафе RAA
• Офицеру по автострахованию выплачивались промежуточные выплаты, пока врач не сказал, что она может вернуться к работе
• Она проиграла дело организации продолжать платить ей

Однако Королевская автомобильная ассоциация Южной Австралии (RAA) перестала платить ей, заявив, что ей разрешено вернуться к работе в качестве инспектора по автострахованию.

Он выиграл приказ, чтобы больше не платить ей.

Трибунал по трудовым спорам Южной Австралии услышал, что Сьюзан Стоддард ударилась мячом в левый висок, когда она обедала в кафе для персонала в штаб-квартире RAA Mile End South 23 сентября 2019 года.

«Г-жа Стоддард получила травму, когда ее ударил бильярдный шар из бильярдного стола в кафе на территории RAA », — говорится в решении трибунала.

Она немедленно подала иск, и RAA выплатило ей «промежуточные платежи», пока она не работала в период с 24 сентября по 7 декабря.

После осмотра неврологом Тимом Кляйнигом 6 декабря RAA сообщило г-же Стоддард, что в его отчете говорится, что она «полностью трудоспособна».

Он сообщил г-же Стоддард, что примет ее иск в качестве пострадавшего с 23 сентября по 21 ноября, но не с 22 ноября по 7 декабря.

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

Г-жа Стоддард подала апелляцию на это решение, и комиссар трибунала сказал RAA продолжить выплаты ей.

Женщина, «непригодная для работы»

Врач г-жи Стоддард из реабилитационного центра SA Health в Хэмпстеде сказал, что г-жа Стоддард «непригодна для работы» и у нее «постконтузионный синдром».

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

Трибунал согласился с г-жой Стоддард на слушании 23 января, что она должна продолжать получать выплаты до тех пор, пока дело не будет решено, но RAA подало апелляцию и выиграло решение, вынесенное в пятницу.

Президент Трибунала Стивен Долфин заявил, что решение RAA о прекращении выплат официально не было решением в соответствии с Законом о возвращении на работу, поэтому суд не имел юрисдикции, чтобы заставить ассоциацию продолжать выплаты.

Что касается промежуточных платежей, это не означает, что RAA признало ответственность по делу.

Когда ABC связались с RAA, они заявили, что не будут комментировать, поскольку «вопрос в настоящее время находится на рассмотрении трибунала».

NoCookies | Австралийский

У вас отключены файлы cookie

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

Приложение Facebook: открывать ссылки во внешнем браузере

Существует конкретная проблема с браузером в приложении Facebook, который периодически отправляет запросы на веб-сайты без файлов cookie, которые были установлены ранее. Похоже, это дефект в браузере, который необходимо исправить в ближайшее время. Самый простой способ избежать этой проблемы — продолжать использовать приложение Facebook, но не использовать встроенный в приложение браузер. Это можно сделать, выполнив следующие шаги:

1. Откройте меню настроек, щелкнув меню гамбургера в правом верхнем углу.
2. Выберите «Настройки приложения» в меню.
3. Включите параметр «Ссылки открываются извне» (при этом будет использоваться браузер устройства по умолчанию).

Окна

Включение файлов cookie в Internet Explorer 9

1. Откройте Интернет-браузер
2. Щелкните Инструменты (или значок шестеренки в правом верхнем углу)> Свойства обозревателя> Конфиденциальность> Дополнительно.
3. Проверка отмены автоматической обработки файлов cookie
4. Для основных и сторонних файлов cookie нажмите Принять
5. Нажмите ОК и ОК

Включение файлов cookie в Internet Explorer 10, 11

1. Откройте Интернет-браузер
2. Нажмите кнопку «Инструменты», а затем нажмите «Свойства обозревателя».
3. Щелкните вкладку «Конфиденциальность», затем в разделе «Параметры» переместите ползунок вниз, чтобы разрешить использование всех файлов cookie, и нажмите кнопку «ОК».
4. Нажмите ОК

Включение файлов cookie в Firefox

1. Откройте браузер Firefox
2. Щелкните Инструменты> Параметры> Конфиденциальность <Использовать пользовательские настройки для журнала
3. Проверить Принимать куки с сайтов
4. Проверить Принять сторонние файлы cookie
5. Выберите «Хранить до истечения срока действия»
6. Нажмите ОК

Включение файлов cookie в Google Chrome

1. Откройте браузер Google Chrome
2. Щелкните значок «Инструменты» или введите «Перейти к chrome: // settings /» в окне URL-адреса, нажмите «Enter»
3. Нажмите «Дополнительные настройки»> Выберите «Конфиденциальность»> «Настройки содержания».
4. Установите флажок «Разрешить установку локальных данных (рекомендуется)»
5. Нажмите «Готово»

Mac

Включение файлов cookie в Firefox

1. Откройте браузер Firefox
2. Firefox> Настройки
3. Перейдите на вкладку «Конфиденциальность»
4. В разделе «История» выберите Firefox: «Использовать пользовательские настройки для истории»
5. Установите флажок «Принимать файлы cookie с сайтов», а затем установите флажок «Принимать сторонние файлы cookie».
6. Нажмите ОК

Включение файлов cookie в Google Chrome

1. Откройте браузер Google Chrome
2. Chrome> Настройки
3. Щелкните «Показать дополнительные настройки…» внизу.
4. В разделе «Конфиденциальность» выберите «Настройки содержания…»
5. В разделе «Файлы cookie» выберите «Разрешить установку локальных данных (рекомендуется)».
6. Нажмите «ОК»

Включение файлов cookie в Safari

1. В Safari
2. Safari> Настройки
3. Перейдите на вкладку «Конфиденциальность»
4. В разделе «Блокировать файлы cookie» отметьте «Никогда»

Включение файлов cookie в мобильном Safari (iPhone, iPad)

1. Перейдите на главный экран, нажав кнопку «Домой» или разблокировав свой телефон / iPad
2. Выберите значок «Настройки».
3. Выберите Safari в меню настроек.
4. Выберите «принять файлы cookie» в меню сафари.
5. Выберите «из посещенных» в меню принятия файлов cookie.
6. Нажмите кнопку «Домой», чтобы вернуться на главный экран iPhone.
7. Выберите значок Safari, чтобы вернуться в Safari.
8. Прежде чем изменение настроек cookie вступит в силу, необходимо перезапустить Safari. Чтобы перезапустить Safari, нажмите и удерживайте кнопку «Домой» (около пяти секунд), пока дисплей iPhone / iPad не погаснет и не появится главный экран.
9. Выберите значок Safari, чтобы вернуться в Safari.

бильярдных залов и сотрудников, Кентукки · Известная база данных афроамериканцев Кентукки

Эта запись — первый шаг к истории афроамериканцев в Кентукки и из Кентукки, которые зарабатывали на жизнь как владельцы и служащие заведений бильярдных залов. В Кентукки между концом 1800-х и концом 1950-х годов афроамериканские мужчины работали в бильярдных, и было несколько владельцев. В первые десятилетия 20-го века в городе Луисвилл было больше всего афроамериканцев, владеющих бассейнами в Кентукки, за ним следовали город Падука и некоторые из небольших городов и сельских общин по всему штату.

Некоторые предприятия существовали десять или более лет, переходя от одного владельца к другому. Бизнес бильярдного зала был в значительной степени мужским делом, и его клиентура была мужчиной. Бильярдные также были разделены, хотя независимо от расы все они в значительной степени рассматривались как тенистые места для игр, азартных игр и выпивки.

Другие названия заведений были «бильярдные» и «бильярдные». В статьях и книгах, в которых упоминаются ранние бильярдные, они, как правило, помещаются в менее богатые районы города или города с атмосферой преступности, и не всегда ясно, что отличает бильярдный зал от салуна с бильярдными столами.Более тонкая сторона термина «бильярдный зал» — это «бильярдная», которую часто представляли как более гражданское пространство в отелях и джентльменских клубах [источник: Энциклопедия уличной преступности в Америке , автор: Дж. И. Росс].

В бильярдных иногда нанимали афроамериканцев в качестве носильщиков. Их также наняли носильщиками в бильярдных. Исследование не было полностью изучено, рассматривая афроамериканцев и бильярдные как жизнеспособные варианты трудоустройства, а также привлекающую силу бильярдных залов как мужских пространств.Ниже перечислены местоположения некоторых из самых первых известных бассейновых залов в Кентукки, которые принадлежали афроамериканцам. Также включены имена афроамериканцев в Кентукки и из Кентукки, которые зарабатывали себе на жизнь работниками бильярдного зала.

Кентукки

1. Эшленд, штат Кентукки (округ Бойд) — зал бассейна на Бродвее, 113, принадлежащий Эдварду Франклину — Справочник компании Marion Directory по газетирам округа Эшленд и Бойд за 1908–1909 годы , стр.231. [Эдвард Франклин также был сапожником и ремонтником в Ашленде.]
2. Bowling Green, KY (округ Уоррен) — бильярдный зал по адресу 129 E. Main Street, принадлежащий Томасу Харрису — Bowling Green, Kentucky City Directory, 1922 , стр. 313
3. Синтиана, Кентукки (округ Харрисон) — служащий бильярдного зала Харрисона Ишем Миллер Аллен — Драфт-карта времен Второй мировой войны 1940 года
4. Данвилл, Кентукки (округ Бойл) — Elite Pool Hall на 2-й улице, 130 S. , принадлежащий братьям Леону и Оресту Ричардсонам — Polk’s Danville (округ Бойл, Кентукки).) Городской справочник 1958 г. , стр.98
5. Эрлингтон, Кентукки (округ Хопкинс) — Пул-холл, принадлежащий Генри Кингу — 1930 переписи населения США
6. Франкфорт, Кентукки (округ Франклин) — хранитель бильярда Чарльз Эллис — перепись населения США 1870 года
7. Франкфорт, Кентукки (округ Франклин) — хранитель бильярда Нельсон Паттерсон — перепись США 1870 года
8. Франкфорт, Кентукки (округ Франклин) — Владелец пула и бильярда Чарльз Тейлор — 1910 Перепись США
9. Франкфорт, Кентукки (округ Франклин) — владелец пула и бильярда Джон Шелтон — 1910 г.С. Перепись
10. Франкфорт, Кентукки (округ Франклин) — Pool Hall на 412 W. Clinton Street, принадлежащий Гранту Оуэнсу — Caron’s Frankfort Directory for the Years 1914-1915-1916 , p.316
11. Франкфорт, Кентукки (округ Франклин) — Pool Hall на 511 Washington Street, принадлежащий Уиллу С. Кастлману — Caron’s Directory of the City of Frankfort, Ky за 1917-1918-1919 гг. , стр. 322
12. Харлан, Кентукки (округ Харлан) — Тендер в бильярдной Elmes Tunes — 1940 перепись США
13. Харлан, Кентукки (округ Харлан) — Тендер в бильярдной John Tunes — 1940 U.С. Перепись
14. Hopkinsville (Christian County) — Pool Room на 104 East 6 ^th Street, принадлежащая Кларенсу Дж. Бэббиджу — Caron’s Directory of the City of Hopkinsville, Ky.1916-1917-1918 , p.393
15. Hopkinsville (Christian County) — Pool Room на 20 ½ East 6 ^th Street, принадлежащая Питеру Постеллу-младшему — Caron’s Hopkinsville Directory за 1912-13-14 годы , стр. 392
16. Лексингтон, Кентукки (округ Фейет) — Бильярдный зал на Дьюиз-стрит, 186, принадлежащий Хейдону Янгу — R.Справочник L. Polk & Co. в Лексингтоне (Кентукки), 1925 г., , стр. 860
17. Лексингтон, Кентукки (округ Фейет) — Crystal Pool Room на Дьюиз-стрит, 186, принадлежащий Томасу Резерфорду и Клем Б. Льюису — Polk’s Lexington (Kentucky) City Directory, 1931-1932 гг. , p.170
18. Lexington, KY (Fayette County) — Lougard Pool Hall на 238 Vertner Avenue, управляемый Сэмом Тилфордом — Lexington City Directory, 1923 , стр. 543
19. Луисвилл, Кентукки (округ Джефферсон) — служащий бильярдного магазина Джордж Уорден — 1880 г.С. Перепись
20. Луисвилл, Кентукки (округ Джефферсон) — сотрудник бильярдной Генри Хаглем — перепись населения США 1880 г.
21. Луисвилл, Кентукки (округ Джефферсон) — носильщик бильярдной Томас Монтгомери — перепись США 1880 года
22. Луисвилл, Кентукки (округ Джефферсон) — владелец бильярдной комнаты Лерой Джонсон — перепись населения США 1920 года
23. Луисвилл, Кентукки (округ Джефферсон) — Бильярдный зал на 548 E. Джейкоб-авеню, принадлежащий Роберту Эллиотту — Справочник Кэрона города Луисвилля за 1913 г. , стр.1859
24. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на улице У. Уолнат, 906, принадлежащий Роберту Клэкстону — Справочник Кэрона города Луисвилля за 1913 год , p.1859
25. Луисвилл, штат Кентукки (округ Джефферсон) — Pool Hall на 629 W. Magnolia Avenue, принадлежащий Джону Филдсу — Справочник Кэрона города Луисвилля за 1913 год , p.1859
26. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на 416 South 9th Street, принадлежащий Джону Холлу — Caron’s Directory of the City of Louisville for 1913 , p.1859
27. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на 446 South 10th Street, принадлежащий Уильяму Уокеру — Справочник Кэрона города Луисвилля за 1913 год , стр.1860
28. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на 425 South 12th Street, принадлежащий Генри Уоллесу — Caron’s Directory of the City of Louisville for 1913 , p.1860
29. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на 1032 W. Chestnut, принадлежащий Б. Ф. Боллу — Справочник Кэрона по городу Луисвиллю за 1921 год , стр. 2112
30. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на 1026 South 15th Street, принадлежащий Фрэнку Барретту — Caron’s Directory of the City of Louisville for 1921 , p.2112
31. Луисвилл, штат Кентукки (округ Джефферсон) — Bowman & Smith Pool Hall, 1101 W. Chestnut Street — Справочник Кэрона города Луисвилля на 1921 год , стр. 2112
32. Луисвилл, Кентукки (округ Джефферсон) — Бильярдный зал на 320 Кассин-стрит, принадлежащий Джейкобу Бруксу — Справочник Кэрона города Луисвилля за 1921 г.2112
33. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на 449 South 7th Street, принадлежащий Томасу Бруксу — Caron’s Directory of the City of Louisville for 1921 , p.2112
34. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на 442 South 7th Street, принадлежащий Джозефу Бьюфорду — Caron’s Directory of the City of Louisville for 1921 , p.2112
35. Луисвилль, Кентукки (округ Джефферсон) — Бильярдный зал на 629 W. Magnolia Avenue, принадлежащий Рою Карру — Справочник Кэрона города Луисвилля за 1921 год , стр.2112
36. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на У. Либерти-стрит, 124, принадлежащий Даду Эвансу — Справочник Кэрона города Луисвилля за 1921 год , стр. 2112
37. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на улице E. Liberty, 102, принадлежащей Джеймсу Гранди — Справочник Кэрона города Луисвилля на 1921 год , стр. 2112
38. Луисвилл, штат Кентукки (округ Джефферсон) — Pool Hall на 1014 Cedar Street, принадлежащий Бенджамину МакЛемору — Справочник Кэрона города Луисвилля на 1921 год , p.2113
39. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на 932 South 12th Street, принадлежащий Ральфу Нилу — Caron’s Directory of the City of Louisville for 1921 , p.2113
40. Луисвилл, Кентукки (округ Джефферсон) — Пифийская гостиная по адресу 611 South 10t Street — Справочник Карона города Луисвилля на 1921 год , стр. 2113
41. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на 323 Pocahontas Street, принадлежащий Эдварду Шафферу — Caron’s Directory of the City of Louisville for 1921 , p.2113
42. Луисвилл, Кентукки (округ Джефферсон) — Pool Hall на У. Уолнат-стрит, 900, принадлежащий Джону Стюарду — Справочник Кэрона города Луисвилля на 1921 год , стр.2113
43. Луисвилл, Кентукки (округ Джефферсон) — менеджер бильярдного салона Уильям С. Томпсон — 1930 г., перепись США
44. Луисвилл, Кентукки (округ Джефферсон) — менеджер бильярдного зала Джордж МакГенри — перепись населения США 1920 года
45. Луисвилл, Кентукки (округ Джефферсон) — обивка бильярдного зала Уилла Поузи — 1920 U.С. Перепись
46. Луисвилл, Кентукки (округ Джефферсон) — работник бильярдного зала Джеймс Франклин — перепись населения США 1920 года
47. Луисвилл, Кентукки (Округ Джефферсон) — носильщик бильярдной Дик Дуган — Перепись населения США 1930 года
48. Луисвилл, Кентукки (округ Джефферсон) — рабочий в бильярдной Уильям Грэйм — 1930 переписи населения США
49. Луисвилл, Кентукки (округ Джефферсон) — носильщик бильярдного зала Джон Ливисон — Перепись США 1930 года
50. Луисвилл, штат Кентукки (округ Джефферсон) — носильщик бильярдного зала Чарльз Белл — 1930 г. С. Перепись
51. Мэдисонвилл, Кентукки (округ Хопкинс) — Pool Hall на 213 W. Center Street, принадлежащий Чарльзу Вулдриджу — Waltrip’s City Directory of Madisonville, Kentucky, 1932-1933 , p.197
52. Мидлсборо, Кентукки (округ Белл) — Бассейн на Девятнадцатой улице по адресу 326 North 19, ^{-я улица,} , принадлежащая Т. Дж. Доруму — Мидлсборо, Кентукки-Сити Директория, 1912-13 гг. , стр.178
53. Мидлсборо, Кентукки (Белл Каунти) — Комната отдыха с бассейном по адресу 401 North 19, ^th, Street — Baldwin Brothers ‘Middlesboro Kentucky City Directory, 1926 , стр.125
54. Mt. Стерлинг, штат Кентукки (округ Монтгомери) — игрок в пул Хикс Уокер — перепись населения США 1920 года
55. Ньюпорт, Кентукки (округ Кэмпбелл) — сотрудник бильярдного зала Джеймса Ингулла Хуберт Ли Дадли — Драфт-карта Второй мировой войны 1940 года
56. Owensboro, KY (Daviess County) — Pool Hall на 109 Frederica Street, принадлежащий Эду Томасу — Owensboro City Directory на 1911-1912 гг. , стр. 313
57. Оуэнсборо, Кентукки (округ Дэвис) — Тендер на объединение Джозеф Белл — Справочник города Оуэнсборо на 1899-1900 годы , стр.38
58. Оуэнсборо, Кентукки (округ Дэвис) — Бильярдная на улице Фредерика 109, принадлежащая Отелло Солсбери — Оуэнсборо, Kentucky City Directory, 1922-1923 , p.266
59. Paducah, KY (McCracken County) — Pool Hall на Кентукки авеню 124, принадлежащий Томасу Гиллиаму — Caron’s Paducah Directory за 1914-1915 годы , p.710
60. Paducah, KY (McCracken County) — Pool Hall на 741 Harris Street, принадлежащий W. P. Grogan — Caron’s Paducah Directory за 1914-1915 годы , p.710
61. Падука, Кентукки (округ Маккракен) — Пул-холл Hughes & Gauses на 7-й улице, 505 — Справочник Керона по Падуке за 1914-1915 годы , p.710
62. Падука, Кентукки (округ Маккракен) — братья Лоу, 827 Вашингтон-стрит — Справочник Падуки Кэрон за 1914-1915 годы , стр.710
63. Падука, Кентукки (округ Маккракен) — бильярдный зал на Кентукки авеню, 124, принадлежащий Джону Армстронгу — Справочник Кэрона города Падука, штат Кентукки. за 1918-1919 гг. , с.576
64. Paducah, KY (McCracken County) — Pool Hall на 116-118 Kentucky Avenue, принадлежащий A. G. Strauss — Caron’s Directory of the City of Paducah, Ky. За 1918-1919 гг. , стр. 576
65. Paducah, KY (McCracken County) — Pool Hall на 900 Washington Street, принадлежащий Артуру Блейкли — Caron’s Directory of the City of Paducah, Ky. За 1920-1921 гг. , p.643
66. Падука, Кентукки (округ Маккракен) — Pool Hall на 1006 South 9th Street, принадлежащий Уильяму Холлу — Caron’s Directory of the City of Paducah, Ky.для 1920-1921 гг. , с.643
67. Paducah, KY (McCracken County) — Pool Hall на 705 Jackson Street, принадлежащий Фрэнку Майнору — Caron’s Directory of the City of Paducah, Ky., За 1920-1921 гг. , p.643
68. Paducah, KY (McCracken County) — Pool Hall на 621 Adams Street, принадлежащий Генри Майнору — Caron’s Directory of the City of Paducah, Ky., За 1920-1921 годы , p.6 43
69. Падука, штат Кентукки (округ Маккракен) — носильщик бильярдного зала Джоди Ториан — 1930 г. С. Перепись
70. Париж, Кентукки (Округ Бурбон) — Pool Hall на 727 Main Street, принадлежащий Альберту Бэкону — Городской справочник В. Х. Хоффмана в Париже, Кентукки, 1917 , стр.209
71. Париж, Кентукки (Округ Бурбон) — Pool Hall на 102 Turner Street, принадлежащий Томасу Б. Келли — Городской справочник В. Х. Хоффмана в Париже, Кентукки, 1917 , стр.20 9
72. Париж, Кентукки (Округ Бурбон) — владелец бильярдного зала Джеймс Ф. Мейсон — 1930 г. по переписи населения США
73. Расселвилл, Кентукки (округ Логан) — менеджер бильярдного зала Бен Эллисон — 1910 г.С. Перепись
74. Шелбивилль, Кентукки (округ Шелби) — носильщик бильярдного зала Скотт Шилдс — Перепись населения США 1910 года
75. Шелбивилль, Кентукки (округ Шелби) — уборщик бильярдного зала Ричард Уомак — Перепись населения США 1910 года
76. Уилрайт, Кентукки (округ Флойд) — оператор бильярдного зала Томас Фолкнер — перепись США 1940 года
77. Винчестер, штат Кентукки (округ Кларк) — бильярдный зал по адресу 117 W. Washington Street, принадлежащий Теодору Бренту — Справочник Кэрона города Винчестера, штат Кентукки.для 1911-12-13 , с.241
78. Винчестер, Кентукки (округ Кларк) — Pool Hall на У. Вашингтон-стрит, 35, принадлежащий И. Б. Драммеру — Winchester, Kentucky City Directory, 1924-1925 , p.232
79. Винчестер, штат Кентукки (округ Кларк) — Pool Hall на У. Вашингтон-стрит, 119, принадлежащий Джеймсу Скиннеру — Winchester, Kentucky City Directory, 1924-1925 , p.232
80. Винчестер, штат Кентукки (округ Кларк) — владелец бильярдной комнаты Уолтер Белл — перепись населения США 1930 года

За пределами Кентукки

1. Анн-Арбор, Мичиган — носильщик бильярдного зала Джон Карр (р.1887 Кентукки) — 1910 Перепись США
2. Bannock, ID — носильщик бильярдного зала Сэмюэл Гранди (род. 1881, Кентукки) — перепись населения США, 1920 г.,
3. Буффало, Нью-Йорк — носильщик бильярдного зала Джеймс Уоттс (род. 1905, Кентукки) — 1930 г., перепись США
4. Шампейн, Иллинойс — носильщик бильярдного зала Джеймс Робинсон (род. 1884, Кентукки) — 1910 г. по переписи населения США
5. Чикаго, Иллинойс — носильщик бильярдного зала Браунло Шено (1885-1921) из Кентукки — округ Кук, штат Иллинойс, индекс смертей
6. Чикаго, Иллинойс — Рабочий в бильярдном зале Эдди Скотт (р.1892 Кентукки) — 1910 Перепись США
7. Чикаго, Иллинойс — носильщик бильярдного зала Льюис Оуэнс (р. 1872 г. Кентукки) — 1910 г. по переписи населения США
8. Чикаго, Иллинойс — Носильщик бильярдного зала Уильям Л. Смит (род. 1885 Кентукки) — 1910 Перепись США
9. Чикаго, Иллинойс — Носильщик бильярдного зала Уильям Х. Джонсон (р. 1877 Кентукки) — 1910 Перепись США
10. Чикаго, Иллинойс — Носильщик бильярдного зала Чарльз Вагнер (р. 1878 Кентукки) — 1910 Перепись США
11. Чикаго, Иллинойс — носильщик бильярдного зала Гарри Фриман (р.1871 Кентукки) — 1920 Перепись США
12. Чикаго, Иллинойс — носильщик бильярдного зала Джек Джонсон (р. 1893, Кентукки) — 1920 г., перепись США
13. Чикаго, Иллинойс — Владелец бильярдного зала Джон П. Малвин (р. 1880 Кентукки) — 1920 Перепись США
14. Чикаго, Иллинойс — носильщик бильярдного зала Джеймс Мерривезер (род. 1884 Кентукки) — 1920 Перепись США
15. Чикаго, Иллинойс — Носильщик бильярдного зала Аллен Оуэнс (род. 1886 Кентукки) — 1920 Перепись населения США
16. Чикаго, Иллинойс — носильщик бильярдного зала Карл Л.Брэдшоу (род. 1886 Кентукки) — 1920 Перепись США
17. Чикаго, Иллинойс — носильщик бильярдного зала Джозеф Роум (р. 1894 Кентукки) — 1920 г. по переписи населения США
18. Чикаго, Иллинойс — Владелец бильярдного салона Уильям Дж. Тейлор (р. 1863 Кентукки) — 1920 Перепись США
19. Чикаго, Иллинойс — Носильщик бильярдного зала Абрахам Джонс (р. 1899 Кентукки) — 1920 Перепись США
20. Чикаго, Иллинойс — ремонтник бильярдного зала Джордж Хью (р. 1893, Кентукки) — 1920 г. по переписи населения США
21. Чикаго, Иллинойс — носильщик бильярдного зала Оливер Джексон (р. 1900 Кентукки) — 1930 перепись США
22. Чикаго, Иллинойс — Владелец бильярдной и обеденной комнаты Уильям Уокер (р. 1890 Кентукки) — 1930 Перепись США
23. Чикаго, Иллинойс — носильщик бильярдного зала Монро Стиггер (род. 1885 Кентукки) — 1930 Перепись США
24. Цинциннати, Огайо — Стойка бильярдного зала Джеймс Каннингем (род. 1911 Кентукки) — 1930 Перепись США
25. Цинциннати, Огайо — Носильщик бильярдного зала Герберт Макалистер (род. 1893 Кентукки) — 1930 Перепись США
26. Кливленд, Огайо — Владелец Billiard Place Артур П.Мэддокс (род. 1884, Кентукки) — 1930, перепись США
27. Колумбус, Огайо — Менеджер бильярдной комнаты Джон Карр (р. 1867 Кентукки) — 1930 Перепись США
28. Денвер, Колорадо — Бильярдный зал, принадлежащий Эдварду Р. Пейджу (р. 1869 Кентукки) — 1920 Перепись США
29. Де-Мойн, Айова — носильщик бильярдного зала Роберт Джексон (р. 1899 Кентукки) — 1920 г., перепись США
30. Детройт, штат Мичиган — владелец бильярдного зала Томас Джефферсон (?) (Р. 1869 Кентукки) — 1900 Перепись США
31. Детройт, Мичиган — менеджер бильярдного зала Перри Белл (р.1885 Кентукки) — 1920 Перепись США
32. Детройт, Мичиган — менеджер бильярдного зала Тайри Т. Флорной (род. 1899 Кентукки) — 1930 Перепись США
33. Дайерсбург, Теннесси — Оператор бильярдной Генри Курд (1870-1920, родился в Кентукки) — Индекс смерти и захоронения Теннесси
34. Ист-Сент-Луис, Иллинойс — Пул-холл, принадлежащий Уильяму Добсону (1886-1923) из Кентукки — Иллинойс, Индекс смертей и мертворождений
35. Эль-Пасо, Техас — Оператор бильярдного зала Генри Картер (род. 1876, Кентукки) — 1940 г.С. Перепись
36. French Lick, IN — менеджер бильярдного зала Джеймс Х. Дорси (род. 1873 г., Кентукки) — перепись населения США 1930 г.
37. Индианаполис, Индиана — Менеджер бассейновой комнаты Телмонд Хинтон (р. 1904 Кентукки) — 1930 Перепись США
38. Индианаполис, Индиана — Оператор бильярдного зала Раймонд Хорн (род. 1902, Кентукки) — перепись населения США 1930 года,
39. Индианаполис, Индиана — носильщик бильярдного зала Фрэнк Мэтьюз (род. 1879, Кентукки) — 1930 Перепись США
40. Канзас-Сити, Миссури — носильщик бильярдного зала Бен Ингрэм (р.1875 Кентукки) — 1920 Перепись США
41. Ла-Хунта, Колорадо — уборщик бильярдного зала Руфус Р. Мур (род. 1875 Кентукки) — Перепись населения США 1920 г.
42. Ламар, Колорадо — Работник бильярдного зала Торнтон Грин (р. 1877 Кентукки) — перепись населения США 1920 г.,
43. Локленд, Огайо — Владелец бильярдной Уильям Когар (р. 1895 Кентукки) — 1930 Перепись США
44. Мейсон, Айова — Помощник бильярдного зала Эдвард Калхун (род. 1886, Кентукки) — 1920 г., перепись США
45. Mt. Вернон, Иллинойс — Оператор бильярдной Даниэль Яегер (род.1878 Кентукки) — 1940 перепись США
46. Ниагара-Фолс, Нью-Йорк — менеджер бильярдного зала Сэмюэл Гриффин (род. 1881, Кентукки) — 1930 Перепись США
47. Окленд, Калифорния — Торговец бильярдом К. Х. Смит (р. 1860 Кентукки) — 1900 г., перепись США
48. Оклахома-Сити, Оклахома — носильщик в бильярдном зале Абрахам Х. Бейкер (р. 1873, Кентукки) — Перепись населения США 1920 г.
49. Омаха, NE — Владелец бильярдного зала Томас Хатчинсон (род. 1878 Кентукки) — 1920 Перепись США
50. Питтсбург, Пенсильвания — клерк бильярдного зала Джордж Картер (р.1905 Кентукки) — 1930 Перепись США
51. Сан-Франциско, Калифорния — уборщик бильярдного зала Далтимм Нельсон (род. 1892, Кентукки) — перепись населения США 1930 года
52. Сиэтл, Вашингтон — Владелец бильярдного зала Эверетт Дэниел (род. 1881, Кентукки) — Перепись населения США 1920 г.
53. Саут-Фултон, Теннесси — уборщик бильярдного зала Рэймонд Стилли (род. В 1912 году в Кентаке) — перепись США 1930 года
54. Спрингфилд, Огайо — Владелец бильярдной комнаты Джеймс Спиллман (род. 1870, Кентукки) — Перепись населения США 1920 г.
55. Спрингфилд, Огайо — Оператор бильярдной Джон Джонсон (р.1866 Кентукки) — 1920 Перепись США
56. Спрингфилд, Огайо — Владелец бильярдного зала Генри Янг (р. 1875 Кентукки) — 1920 г. по переписи населения США
57. Сент-Луис, Миссури — носильщик бильярдного зала Ральф Ньюман (р. 1894 Кентукки) — 1930 Перепись США
58. Сент-Луис, Миссури — Горничная Бильярдного зала Кэтрин Кеммер (род. 1901, Кентукки) — 1930 Перепись США
59. Texarkana, AR — Хранитель бильярдного салона Джордж Картер (р. 1822 Кентукки) — 1880 г., перепись США
60. Урбана, Огайо — Владелец бильярдной Уильям Сублет (р.1891 Кентукки) — 1940 перепись США
61. Вашингтон, округ Колумбия — Хранитель бильярдной Джошуа Барклай (р. 1860 Кентукки) — 1900 Перепись США
62. Washington Court House, Огайо — партнер по бильярдному залу Ли Тейлор (род. 1863 Кентукки) — перепись населения США 1920 г.
63. Вест-Баден, Индиана — менеджер бильярдной Стивен Г. Вашингтон (род. 1870, Кентукки) — перепись населения США 1930 года,

Для получения дополнительной информации см. Пул: исторические стратегии и легенды М.Я Шамос; и см. «Rack ’em up» в Black Enterprise , декабрь 1989 г. , стр.115-118.

% PDF-1.4 % 4 0 obj > endobj xref 4 75 0000000016 00000 н. 0000002070 00000 н. 0000002166 00000 н. 0000002649 00000 н. 0000002776 00000 н. 0000003290 00000 н. 0000003558 00000 н. 0000003932 00000 н. 0000004304 00000 н. 0000004739 00000 н. 0000005177 00000 н. 0000005560 00000 н. 0000006047 00000 н. 0000006242 00000 н. 0000008399 00000 н. 0000010095 00000 п. 0000011146 00000 п. 0000011279 00000 п. 0000011419 00000 п. 0000012480 00000 п. 0000013860 00000 п. 0000014906 00000 п. 0000016950 00000 п. 0000018355 00000 п. 0000018468 00000 п. 0000018579 00000 п. 0000018648 00000 п. 0000018728 00000 п. 0000038826 00000 п. 0000039086 00000 н. 0000039518 00000 п. 0000039543 00000 п. 0000040144 00000 п. 0000040213 00000 п. 0000040293 00000 п. 0000051628 00000 п. 0000051894 00000 п. 0000052231 00000 п. 0000052256 00000 п. 0000052704 00000 п. 0000052773 00000 п. 0000052853 00000 п. 0000061317 00000 п. 0000061596 00000 п.