darts.util.events é uma biblioteca Python que fornece um despachador de eventos simples, similar ao construto evento proporcionada pela linguagem C #. & Nbsp; A biblioteca não tem dependências externas.
Foi destinado para casos de uso, onde os componentes emissores de eventos e os componentes de escuta para eventos de acordo sobre o tipo de evento ea semântica associados. Isso é verdade, por exemplo, para manipuladores de eventos, que escuta nas "clique" eventos sinalizadas por objetos de botão GUI, ou notificações sinalizadas por objetos, sempre que o valor de algumas alterações de propriedade. Isso difere da abordagem adotada pela, digamos, o PyDispatcher, que é mais genérico, e favorece a comunicação entre os componentes fracamente acoplados.
Compatibilidade
O código foi escrito para e testado com o Python 2.6. Deve ser compatível com 2.5, bem como, mas você pode ter que inserir algumas linhas de __future__ with_statement importação aqui e ali. Ele deve funcionar (isto não foi testado) com implementações alternativas de como Python Jython ou IronPython. Observe, porém, que alguns dos casos de teste definidos nesse arquivo pode falhar devido a diferentes implementações de coleta de lixo; este arquivo foi gravado com CPython em mente.
Documentação
Uso Básico
& Nbsp; >>> from darts.lib.utils.event importação Publisher, ReferenceRetention como RR
& Nbsp; >>> some_event = Publisher ()
O Publisher é o componente principal. Ele atua como registro de chamadas de retorno / ouvintes. Vamos definir um ouvinte
& Nbsp; >>> def impressora (* event_args, event_keys **):
& Nbsp; ... event_args impressão, event_keys
Para receber notificações, os clientes devem assinar um editor. Isto pode ser tão simples quanto
& Nbsp; >>> some_event.subscribe (impressora) #doctest: + ELLIPSIS
& Nbsp;
O resultado da chamada para se inscrever é uma instância de (alguns subclasse de) classe Subscription. Este valor pode ser usado mais tarde, a fim de cancelar a assinatura, quando as notificações não são mais desejado. A subclasse real é um detalhe de implementação que você normalmente não deve se preocupar. Tudo que você precisa saber (e estão autorizados a confiar em nós, na verdade) é que será uma instância da classe de subscrição, e que irá fornecer tudo o que tem sido documentada como API pública dessa classe (agora: único método cancelar) .
Agora, vamos sinalizar um evento e ver o que acontece:
& Nbsp; >>> some_event.publish ('an-evento')
& Nbsp; ('an-evento',) {}
Como você pode ver, a impressora foi notificado do evento, e duefully impresso os seus argumentos para o console.
assinaturas Cancelling
Como mencionado, o resultado da chamada inscrever é um objeto especial de subscrição, que representa o registro do ouvinte com a editora.
& Nbsp; >>> s1 = some_event.subscribe (impressora)
& Nbsp; >>> some_event.publish ('outro evento')
& Nbsp; ('outro evento',) {}
& Nbsp; ('outro evento',) {}
& Nbsp; >>> s1.cancel ()
& Nbsp; Verdadeira
& Nbsp; >>> some_event.publish ('ainda-mais-um ")
& Nbsp; ('ainda-mais-um',) {}
A editora é totalmente re-entrantes. Isso significa, que você pode se inscrever para eventos de dentro de um ouvinte, e você pode cancelar assinaturas, neste contexto, bem como:
& Nbsp; >>> def make_canceller (subs):
& Nbsp; ... def ouvinte (* unused_1, unused_2 **):
& Nbsp; ... print "Cancelar", subs, subs.cancel ()
& Nbsp; ... retorno ouvinte
& Nbsp; >>> s1 = some_event.subscribe (impressora)
& Nbsp; >>> s2 = some_event.subscribe (make_canceller (S1))
& Nbsp; >>> some_event.publish ('gotta-go') #doctest: + ELLIPSIS
& Nbsp; ('gotta-go',) {}
& Nbsp; ('gotta-go',) {}
& Nbsp; Anular
& Nbsp; >>> some_event.publish ('Gone') #doctest: + ELLIPSIS
& Nbsp; ('Gone',) {}
& Nbsp; Anular
& Nbsp; >>> s1.cancel ()
& Nbsp; False
O resultado da chamada para cancelar nos diz, que a subscrição já havia sido desfeita antes da chamada (por nosso ouvinte cancelamento mágica). Geralmente, chamando cancelar várias vezes é inofensivo; todos, mas a primeira chamada são ignorados.
Vamos agora remover a magia que eu puder cancelar a-stuff ouvinte e seguir em frente:
& Nbsp; >>> s2.cancel ()
& Nbsp; Verdadeira
Usando Non-Callables como chamadas de retorno
Sempre fizemos assinaturas acima, nós realmente simplied as coisas um pouco. A assinatura completa do método é:
& Nbsp; def subscrever (ouvinte [, método [, reference_retention]])
Vamos explorar o argumento método primeiro. Até agora, nós só usamos objetos de função como ouvintes. Basicamente, na verdade, poderíamos ter usado qualquer objeto que pode ser chamado. Lembre-se que qualquer objeto é "exigível" em Python, se ele fornece um método __call__, por isso acho que, o que é o valor padrão do argumento de método?
& Nbsp; >>> s1 = some_event.subscribe (impressora, method = "__ call__ ')
& Nbsp; >>> some_event.publish ('foo')
& Nbsp; ('foo',) {}
& Nbsp; ('foo',) {}
& Nbsp; >>> s1.cancel ()
& Nbsp; Verdadeira
Nada de novo. Então, agora você pode perguntar: quando eu uso um nome de método diferente?
& Nbsp; >>> Alvo classe (objeto):
& Nbsp; ... def __init __ (self, nome):
& Nbsp; ... self.name = nome
& Nbsp; ... def _callback (self, * args, ** chaves):
& Nbsp; ... impressão self.name, args, chaves
& Nbsp; >>> s1 = some_event.subscribe (Target ('foo'))
& Nbsp; >>> some_event.publish ('! Bumm') #doctest: + ELLIPSIS
& Nbsp; Traceback (most recent call last):
& Nbsp; ...
& Nbsp; TypeError: objeto 'Target' não é resgatável
Oops. Vamos remover o infractor, antes que alguém perceba o nosso erro:
& Nbsp; >>> s1.cancel ()
& Nbsp; Verdadeira
& Nbsp; >>> s1 = some_event.subscribe (Target ('foo'), method = '_ callback')
& Nbsp; >>> some_event.publish ('obras')
& Nbsp; ('! Obras',) {}
& Nbsp; foo ('obras',) {}
Referência de retenção
Então, é isso. Há ainda um argumento inexplorado para inscrever-se para a esquerda, no entanto: reference_retention. O nome soa perigoso, mas o que ele faz?
& Nbsp; >>> ouvinte = Destino ('gostoso')
& Nbsp; >>> s2 = some_event.subscribe (ouvinte, method = '_ retorno de chamada', reference_retention = RR.WEAK)
& Nbsp; >>> some_event.publish ('yow')
& Nbsp; ('yow',) {}
& Nbsp; foo ('yow',) {}
& Nbsp; gostoso ('yow',) {}
Hm. Até agora, não há diferenças. Vamos fazer uma mudança simples:
& Nbsp; >>> ouvinte = None
& Nbsp; >>> some_event.publish ('yow')
& Nbsp; ('yow',) {}
& Nbsp; foo ('yow',) {}
Ah. Ok. Nossa gostoso ouvinte está desaparecido. O que aconteceu? Bem, especificando uma política de retenção de referência fraca, que se disse o editor, que ele deve usar uma referência fraca para o ouvinte acabou de instalar, em vez de a forte referência padrão. E depois de termos lançado o único outro conhecido referência forte para o ouvinte, definindo ouvinte para Nenhum, o ouvinte foi realmente removido da editora. Nota, BTW., Que o exemplo acima pode falhar com outras implementações CPython do que python, devido a políticas diferentes com relação à coleta de lixo. O princípio deve permanecer válida, porém, em Jython, bem como IronPython, mas naqueles implementações, não há nenhuma garantia de que o ouvinte é removido assim que a última referência a ele é descartado.
Claro, isso tudo funciona também, se o método a ser chamado é o padrão: __call__:
& Nbsp; >>> def make_listener (nome):
& Nbsp; ... def ouvinte (* args, ** chaves):
& Nbsp; ... Nome impressão, args, chaves
& Nbsp; ... retorno ouvinte
& Nbsp; >>> ouvinte = make_listener ("fraco")
& Nbsp; >>> s2 = some_event.subscribe (ouvinte, reference_retention = RR.WEAK)
& Nbsp; >>> some_event.publish ("evento")
& Nbsp; ('evento',) {}
& Nbsp; foo ("evento",) {}
& Nbsp; fraco ("evento",) {}
& Nbsp; >>> ouvinte = None
& Nbsp; >>> some_event.publish ("evento")
& Nbsp; ('evento',) {}
& Nbsp; foo ("evento",) {}
Isso é tudo que há para saber sobre a biblioteca. Como eu disse acima: é simples, e pode não ser útil para todos os scenarioes e casos de uso, mas ele faz o que foi escrito para.
Tratamento de erros
A classe Publisher não se destina a ser uma subclasse. Se você precisar ajustar o comportamento, você usa objetos de política / chamadas de retorno, que são passados para o construtor. Neste momento, não é uma política ajustável único, ou seja, o comportamento do editor no caso, os ouvintes levantar exceções:
& Nbsp; >>> def toobad (evento):
& Nbsp; ... se o evento == 'raise':
& Nbsp; ... levantar ValueError
& Nbsp; >>> s1 = some_event.subscribe (toobad)
& Nbsp; >>> some_event.publish («inofensivo»)
& Nbsp; («inofensivo»,) {}
& Nbsp; foo («inofensivo»,) {}
& Nbsp; >>> some_event.publish ('raise')
& Nbsp; Traceback (most recent call last):
& Nbsp; ...
& Nbsp; ValueError
Como você pode ver, o comportamento padrão é a re-raise a exceção de dentro de publicar. Isto pode não ser adequada, dependendo do caso de uso. Em particular, ele irá impedir ouvintes registrados mais tarde a ser executado. Então, vamos definir nossa própria manipulação de erro:
& Nbsp; >>> def log_error (excepção, valor, traceback, subscrição, args), chaves:
& Nbsp; ... print "apanhado", exceção
& Nbsp; >>> publisher = Publisher (exception_handler = log_error)
& Nbsp; >>> publisher.subscribe (toobad) #doctest: + ELLIPSIS
& Nbsp;
& Nbsp; >>> publisher.subscribe (impressora) #doctest: + ELLIPSIS
& Nbsp;
& Nbsp; >>> publisher.publish («inofensivo»)
& Nbsp; («inofensivo»,) {}
& Nbsp; >>> publisher.publish ('raise')
& Nbsp; apanhado
& Nbsp; ('raise',) {}
Como uma alternativa para fornecer o manipulador de erro em tempo de construção, você também pode fornecer um manipulador de erro ao publicar um evento, assim:
& Nbsp; >>> def log_error_2 (excepção, valor, traceback, subscrição, args), chaves:
& Nbsp; ... print "apanhado", exceção ", durante a publicação"
& Nbsp; >>> publisher.publish_safely (log_error_2, 'raise')
& Nbsp; apanhado
& Nbsp; ('raise',) {}
Como você pode ver, o manipulador de erro por chamada tem precedência sobre manipulador de erro padrão do editor. Note-se, que não há encadeamento, ou seja, se o manipulador de erro por chamada gera uma exceção, manipulador padrão do editor não é chamado, mas a exceção é simplesmente propagado para fora, para o chamador de publish_safely: o editor não tem como distinguir entre exceções levantadas porque o manipulador quer abortar a expedição e exceções levantadas por acidente, por isso todas as exceções levantadas pelo manipulador são simplesmente encaminhadas para a aplicação cliente.
Segurança de Segmentos
A biblioteca está totalmente consciente e enfiar o segmento de seguros. Assim, a subscrição de um ouvinte compartilhado entre vários tópicos é seguro, e assim está cancelando assinaturas
O que é novo nesta versão:.
- Subscrição lida agora fornecer acesso aos seus objetos de ouvinte e nomes de método. Este foi adicionado por uma questão de código de manipulação de erro, que quer fazer login exceções e fornecer uma maneira melhor de identificar o ouvinte real, que foi desonesto.
O que é novo na versão 0.2:
- A manipulação de erro foi alterado. Em vez de uma subclasse da editora, o manipulador de exceção padrão agora é passado como callback para o editor durante a construção. A classe Publisher agora está documentado como & quot; não destinado a ser uma subclasse & quot;.
Requisitos :
- Python
Comentários não encontrado