def register( name ): if not SIGNALS.get(name,None) is None :raise Exception('SIGNAL duplicated: %s '%name) logging.debug( 'register signal: %s ' % name ) sig = Signal( name=name ) # sig=Signal() # sig.description = description # sig.name=name SIGNALS[name]=sig return sig
def __init__(self, nrCaminhoes=10, tempoSimulacao=sys.maxint, maxViagens=None): Simulation.__init__(self) self.nrCaminhoes_changed = Signal(providing_args=['nrCaminhoes']) self.nrCaminhoes = nrCaminhoes self.tempoSimulacao = tempoSimulacao self.maxViagens = maxViagens self.caminhoes = list() self.fila_carregadores_changed = Signal(providing_args=['tam']) self.carregadores_ativos_changed = Signal(providing_args=['tam']) self.fila_balanca_changed = Signal(providing_args=['tam']) self.balanca_ativo_changed = Signal(providing_args=['tam']) self._carregamento_va = None self._pesagem_va = None self._viagem_va = None self.nrViagensRealizadas_changed = Signal(providing_args=['nrViagensRealizadas']) def default_handler(sender, **kwargs): pass self.caminhao_changed_handler = default_handler self._nrViagensRealizadas = 0 self._inicializado = False
class TextFieldWrapper(object): def __init__(self, node): self.node = node self.detect_signal = Signal() self.node.addEventListener(self._event) @property def text(self): return self.node.getString() @text.setter def text(self, t): self.node.setString(t) def connect_detect(self, receiver, sender=None, weak=True, dispatch_uid=None): self.detect_signal.connect(receiver, sender, weak, dispatch_uid) def _event(self, node, e): if e == const.EVENT_TYPE.TEXTFIELD_EVENT_DETACH_WITH_IME: self.detect_signal.send(sender=self)
class ButtonWrapper(object): def __init__(self, node): self.node = node self.begin_singal = Signal() self.moved_singal = Signal() self.end_singal = Signal() self.node.addTouchEventListener(self._event) def _event(self, node, event): if event == 0: self.begin_singal.send(sender=self) elif event == 1: self.moved_singal.send(sender=self) elif event == 2: self.end_singal.send(sender=self) def connect_end(self, receiver, sender=None, weak=True, dispatch_uid=None): self.end_singal.connect(receiver, sender, weak, dispatch_uid)
def __init__(self, modelo): self.property_changed = Signal(providing_args=['property_name']) self._tam_fila_carregadores = MinMaxMedia(self.property_changed) modelo.fila_carregadores_changed.connect(fila_carregadores_changed) self._tam_fila_balanca = MinMaxMedia(self.property_changed) modelo.fila_balanca_changed.connect(fila_balanca_changed) self._ocupacao_media_car = 0.0 modelo.carregadores_ativos_changed.connect(carregadores_ativos_changed) self._ocupacao_media_bal = 0.0 modelo.balanca_ativo_changed.connect(balanca_ativo_changed) modelo.caminhao_changed_handler = self.caminhao_changed_handler self._tempo_fila_carregador = MinMaxMedia(self.property_changed) self._tempo_fila_balanca = MinMaxMedia(self.property_changed) self._tempo_ciclo = MinMaxMedia(self.property_changed)
class Context(object): def __init__(self, *args, **kwargs): super(Context, self).__init__() self.signal = Signal() def connect(self, receiver, sender=None, weak=True, dispatch_uid=None): self.signal.connect(receiver, sender, weak, dispatch_uid) def disconnect(self, receiver=None, sender=None, weak=True, dispatch_uid=None): self.signal.disconnect(receiver, sender, weak, dispatch_uid) def send(self, sender, **named): self.signal.send(sender, **named)
class Estatisticas: class MinMaxMedia: def __init__(self, property_changed): self._min = 0.0 self._max = 0.0 self._media = 0.0 self._count = 0 self.property_changed = property_changed def verify_and_notify(self, attr_name, value): if getattr(self, attr_name) != value: setattr(self, attr_name, value) self.property_changed.send(sender=self, property_name=attr_name[1:]) def update_properties(self, val, average=None): self.min = min(self.min, val) self.max = max(self.max, val) self._count += 1 if average is None: self.media = (self.media + val) / self._count else: self.media = average @property def min(self): return self._min @min.setter def min(self, value): self.verify_and_notify('_min', value) @property def max(self): return self._max @max.setter def max(self, value): self.verify_and_notify('_max', value) @property def media(self): return self._media @media.setter def media(self, value): self._media = value self.property_changed.send(sender=self, property_name='media') def __init__(self, modelo): self.property_changed = Signal(providing_args=['property_name']) self._tam_fila_carregadores = MinMaxMedia(self.property_changed) modelo.fila_carregadores_changed.connect(fila_carregadores_changed) self._tam_fila_balanca = MinMaxMedia(self.property_changed) modelo.fila_balanca_changed.connect(fila_balanca_changed) self._ocupacao_media_car = 0.0 modelo.carregadores_ativos_changed.connect(carregadores_ativos_changed) self._ocupacao_media_bal = 0.0 modelo.balanca_ativo_changed.connect(balanca_ativo_changed) modelo.caminhao_changed_handler = self.caminhao_changed_handler self._tempo_fila_carregador = MinMaxMedia(self.property_changed) self._tempo_fila_balanca = MinMaxMedia(self.property_changed) self._tempo_ciclo = MinMaxMedia(self.property_changed) @property def ocupacao_media_car(self): return self._ocupacao_media_car @ocupacao_media_car.setter def ocupacao_media_car(self, value): self._ocupacao_media_car = value self.property_changed.send(sender=self, property_changed='ocupacao_media_car') @property def ocupacao_media_bal(self): return self._ocupacao_media_bal @ocupacao_media_bal.setter def ocupacao_media_bal(self, value): self._ocupacao_media_bal = value self.property_changed.send(sender=self, property_changed='ocupacao_media_bal') def caminhao_changed_handler(self, sender, **kwargs): property_changed_name = kwargs['property_name'] property_value = getattr(sender, property_changed_name) if property_changed_name == 't_fila_car': self._tempo_fila_carregador.update_properties(property_value) elif property_changed_name == 't_fila_bal': self._tempo_fila_balanca.update_properties(property_value) elif property_changed_name == 't_ciclo': self._tempo_ciclo.update_properties(property_value) def fila_carregadores_changed(self, sender, **kwargs): tam_atual = kwargs['tam'] average = sender.timeaverage() self._tam_fila_carregadores.update_properties(tam_atual, average) def fila_balanca_changed(self, sender, **kwargs): tam_atual = kwargs['tam'] average = sender.timeaverage() self._tam_fila_balanca.update_properties(tam_atual, average) def carregadores_ativos_changed(self, sender, **kwargs): self.ocupacao_media_car = sender.timeaverage() def balanca_ativo_changed(self, sender, **kwargs): self.ocupacao_media_bal = sender.timeaverage()
#!/usr/bin/env python # -*- coding: utf-8 -*- # ============================================================================== # Copyright (C) 2014 Andreas Kührmann [[email protected]] # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # ============================================================================== from dispatch import Signal line2D_requested = Signal() property_changed = Signal() undo_stack_changed = Signal()
from dispatch import Signal ''' .. note:: *sender* is used by *receiver* to specify which source to accept signal from, usually it's some *class name*. if you want to carry a instance arg, don't use it, instead, you can add one more arg in the signal's `provoding_args` ''' config_ready = Signal(providing_args=["config"]) p2p_address_ready = Signal(providing_args=["ip", "port"]) peer_connection_accepted = Signal(providing_args=["connection", "ip", "port"]) peer_disconnect_requested = Signal(providing_args=["peer", "forget"]) peer_addresses_received = Signal(providing_args=["addresses"]) peer_handshake_success = Signal(providing_args=["peer"]) getpeers_received = Signal(providing_args=["peer"]) gettransactions_received = Signal(providing_args=["peer"]) remote_blocks_received = Signal(providing_args=["block_lst", "peer"]) remote_chain_requested = Signal(providing_args=["parents", "count"]) local_chain_requested = Signal(providing_args=["peer", "blocks", "count"]) send_local_blocks = Signal(providing_args=["blocks"]) local_transaction_received = Signal(providing_args=["transaction"]) remote_transactions_received = Signal(providing_args=["transactions"]) send_local_transactions = Signal(providing_args=["transaction"])
from dispatch import Signal payment_verified = Signal(providing_args=["ref", "amount", "order"]) event_signal = Signal(providing_args=["event", "data"]) successful_payment_signal = Signal(providing_args=["data"]) failed_payment_signal = Signal(providing_args=["transfer_code", "data"])
class Callable(object): def __call__(self, val, **kwargs): return val def a(self, val, **kwargs): return val class Sender(object): signal = Signal(providing_args=["val"]) def send(self): self.signal.send(sender=self, val="test") a_signal = Signal(providing_args=["val"]) class DispatcherTests(unittest.TestCase): """Test suite for dispatcher (barely started)""" def _testIsClean(self, signal): """Assert that everything has been cleaned up automatically""" self.assertEqual(signal.receivers, []) # force cleanup just in case signal.receivers = [] def testExact(self): a_signal.connect(receiver_1_arg, sender=self) expected = [(receiver_1_arg, "test")] result = a_signal.send(sender=self, val="test")
#! /usr/bin/env python # -*- coding: utf-8 -*- from dispatch import Signal calendar_date_changed = Signal(providing_args=['date'])
from dispatch import Signal payment_verified = Signal(providing_args=["ref", "amount", "order"]) event_signal = Signal(providing_args=['event', "data"]) successful_payment_signal = Signal(providing_args=['data']) successful_transfer_signal = Signal(providing_args=['transfer_code', 'data']) failed_transfer_signal = Signal(providing_args=['transfer_code', 'data'])
def __init__(self, node): self.node = node self.begin_singal = Signal() self.moved_singal = Signal() self.end_singal = Signal() self.node.addTouchEventListener(self._event)
"""Simple sample showing basic usage pattern""" import time from dispatch import Signal request_started = Signal(providing_args=["remote_addr"]) request_ended = Signal(providing_args=["time_start", "time_end"]) class Request(object): def __init__(self, remote_addr): self.remote_addr = remote_addr self.time_start = time.time() def enter(self): request_started.send(sender=self, remote_addr=self.remote_addr) def leave(self): time_end = time.time() request_ended.send(sender=self, time_start=self.time_start, time_end=time_end) def mycallback(signal, sender, **kwargs): print("Received signal: %s" % repr(kwargs)) if __name__ == "__main__": request_started.connect(mycallback)
def __init__(self, node): self.node = node self.detect_signal = Signal() self.node.addEventListener(self._event)
class Modelo(SimulationStep): def __init__(self, nrCaminhoes=10, tempoSimulacao=sys.maxint, maxViagens=None): Simulation.__init__(self) self.nrCaminhoes_changed = Signal(providing_args=['nrCaminhoes']) self.nrCaminhoes = nrCaminhoes self.tempoSimulacao = tempoSimulacao self.maxViagens = maxViagens self.caminhoes = list() self.fila_carregadores_changed = Signal(providing_args=['tam']) self.carregadores_ativos_changed = Signal(providing_args=['tam']) self.fila_balanca_changed = Signal(providing_args=['tam']) self.balanca_ativo_changed = Signal(providing_args=['tam']) self._carregamento_va = None self._pesagem_va = None self._viagem_va = None self.nrViagensRealizadas_changed = Signal(providing_args=['nrViagensRealizadas']) def default_handler(sender, **kwargs): pass self.caminhao_changed_handler = default_handler self._nrViagensRealizadas = 0 self._inicializado = False def _nroTotalDeViagensForamRealizadas(self): if self.maxViagens is None: return False return self.nrViagensRealizadas == self.maxViagens @property def nrCaminhoes(self): return self._nrCaminhoes @nrCaminhoes.setter def nrCaminhoes(self, value): self._nrCaminhoes = value self.nrCaminhoes_changed.send(sender=self, nrCaminhoes=self._nrCaminhoes) @property def nrViagensRealizadas(self): return self._nrViagensRealizadas @nrViagensRealizadas.setter def nrViagensRealizadas(self, value): self._nrViagensRealizadas = value self.nrViagensRealizadas_changed.send(sender=self, nrViagensRealizadas=self._nrViagensRealizadas) if self._nroTotalDeViagensForamRealizadas(): self.stopSimulation() @property def carregamento_va(self): return self._carregamento_va @carregamento_va.setter def carregamento_va(self, value): self._carregamento_va = value @property def pesagem_va(self): return self._pesagem_va @pesagem_va.setter def pesagem_va(self, value): self._pesagem_va = value @property def viagem_va(self): return self._viagem_va @viagem_va.setter def viagem_va(self, value): self._viagem_va = value def inicializar(self): if self.maxViagens is None and self.tempoSimulacao is None: raise ModeloError('Número máximo de viagens e o tempo de simulação não foram informados. Ao menos um deles deve ser informado') self.nrViagensRealizadas = 0 self.initialize() car_name = 'Carregadores' self.carregadores = Resource(name=car_name, unitName='carregador', capacity=2, monitored=True, sim=self) carWaitMon = NotifyMonitor(signal= self.fila_carregadores_changed, name = 'Wait Queue Monitor %s'%car_name, ylab = 'nr in queue', tlab = 'time', sim = self) print len(self.carregadores.waitQ) carWaitMon.observe(t=self.now(), y=len(self.carregadores.waitQ)) self.carregadores.waitMon = carWaitMon carActMon = NotifyMonitor(signal=self.carregadores_ativos_changed, name = 'Active Queue Monitor %s'%car_name, ylab = 'nr in queue', tlab = 'time', sim = self) carActMon.observe(t=self.now(), y=len(self.carregadores.activeQ)) self.carregadores.actMon = carActMon bal_name = 'Balança' self.balanca = Resource(name=bal_name, unitName='balança', capacity=1, monitored=True, sim=self) balWaitMon = NotifyMonitor(signal=self.fila_balanca_changed, name = 'Wait Queue Monitor %s'%bal_name, ylab = 'nr in queue', tlab = 'time', sim = self) balWaitMon.observe(t=self.now(), y=len(self.balanca.waitQ)) self.balanca.waitMon = balWaitMon balActMon = NotifyMonitor(signal=self.balanca_ativo_changed, name = 'Active Queue Monitor %s'%bal_name, ylab = 'nr in queue', tlab = 'time', sim = self) balActMon.observe(t=self.now(), y=len(self.balanca.activeQ)) self.balanca.actMon = balActMon for i in range(self._nrCaminhoes): caminhao = Caminhao(name='caminhao_%s'%i, sim=self) caminhao.property_changed.connect(self.caminhao_changed_handler) self.caminhoes.append(caminhao) self.activate(caminhao, caminhao.rodar()) self._inicializado = True def inicializado(self): return self._inicializado def rodar(self, step=False): if not self.inicializado(): self.inicializar() # pdb.set_trace() # TODO: usar variavel self.stop_l setada com um Lock # while not self.stop_l and self.has_events(): while self.has_events(): self.simulateStep(until=self.tempoSimulacao)
#!/usr/bin/env python # -*- coding: utf-8 -*- # # @author [email protected] # @date 2016-1-9 # from dispatch import Signal call_started = Signal(providing_args=["request"]) handler_started = Signal(providing_args=["handler"]) handler_response = Signal(providing_args=["handler", "chunk"]) call_finished = Signal(providing_args=["handler"]) handler_render = Signal(providing_args=["handler", "template_name", "kwargs"])
# -*- coding: utf-8 -*- # Copyright (C) 2011 ~ 2014 Deepin, Inc. # 2011 ~ 2014 Hou ShaoHui # # Author: Hou ShaoHui <*****@*****.**> # Maintainer: Hou ShaoHui <*****@*****.**> # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from dispatch import Signal pre_save = Signal(providing_args=["instance", "created", "update_fields"]) post_save = Signal(providing_args=["instance", "created", "update_fields"]) pre_delete = Signal(providing_args=["instance"]) post_delete = Signal(providing_args=["instance"]) pre_init = Signal(providing_args=["instance"]) post_init = Signal(providing_args=["instance"]) db_init_finished = Signal(providing_args=["created"])
from dispatch import Signal ''' .. note:: *sender* is used by *receiver* to specify which source to accept signal from, usually it's some *class name*. if you want to carry a instance arg, don't use it, instead, you can add one more arg in the signal's `provoding_args` ''' config_ready = Signal(providing_args=["config"]) p2p_address_ready = Signal(providing_args=["ip", "port"]) peer_connection_accepted = Signal(providing_args=["connection", "ip", "port"]) peer_disconnect_requested = Signal(providing_args=["peer", "forget"]) peer_addresses_received = Signal(providing_args=["addresses"]) peer_handshake_success = Signal(providing_args=["peer"]) peer_status_received = Signal(providing_args=["peer"]) getpeers_received = Signal(providing_args=["peer"]) local_transaction_received = Signal(providing_args=["transaction"]) remote_transactions_received = Signal(providing_args=["transactions"]) send_local_transactions = Signal(providing_args=["transaction"]) remote_block_hashes_received = Signal(providing_args=["block_hashes", "peer"]) get_block_hashes_received = Signal(providing_args=["block_hashes", "peer"]) remote_blocks_received = Signal(providing_args=["block_lst", "peer"]) get_blocks_received = Signal(providing_args=["block_hashes", "count", "peer"])
class Sender(object): signal = Signal(providing_args=["val"]) def send(self): self.signal.send(sender=self, val="test")
def __init__(self, *args, **kwargs): super(Context, self).__init__() self.signal = Signal()
from dispatch import Signal, receiver """ Define signals used in Lib2d here """ # signals used in area.py bodyRelMove = Signal(providing_args=["body", "position", "force"]) bodyAbsMove = Signal(providing_args=["body", "position", "force"]) bodyWarp = Signal(providing_args=["body", "area"]) emitSound = Signal(providing_args=["filename", "position"]) emitText = Signal(providing_args=["text", "position"]) # signals relevant for the engine timeSignal = Signal(providing_args=["time"]) drawSignal = Signal(providing_args=["surface"]) inputSignal = Signal(providing_args=["driver", "args"])
class Caminhao(Process): def __init__(self, name, sim): Process.__init__(self, name, sim) self.property_changed = Signal(providing_args=['property_name']) self._t_fila_car = 0.0 self._t_fila_bal = 0.0 self._t_ciclo = 0.0 @property def t_fila_car(self): return self._t_fila_car @t_fila_car.setter def t_fila_car(self, value): self._t_fila_car = value self.property_changed.send(sender=self, property_name='t_fila_car') @property def t_fila_bal(self): return self._t_fila_bal @t_fila_bal.setter def t_fila_bal(self, value): self._t_fila_bal = value self.property_changed.send(sender=self, property_name='t_fila_bal') @property def t_ciclo(self): return self._t_ciclo @t_ciclo.setter def t_ciclo(self, value): self._t_ciclo = value self.property_changed.send(sender=self, property_name='t_ciclo') def rodar(self): while True: # carregando o caminhão espera_inicio = self.sim.now() yield request, self, self.sim.carregadores espera_fim = self.sim.now() self.t_fila_car = espera_fim - espera_inicio t_carregamento = self.sim.carregamento_va() yield hold, self, t_carregamento yield release, self, self.sim.carregadores # pesagem espera_inicio = self.sim.now() yield request, self, self.sim.balanca espera_fim = self.sim.now() self.t_fila_bal = espera_fim - espera_inicio t_pesagem = self.sim.pesagem_va() yield hold, self, t_pesagem yield release, self, self.sim.balanca # delay da viagem t_viagem = self.sim.viagem_va() yield hold, self, t_viagem self.t_ciclo = self.t_fila_car + t_carregamento + self.t_fila_bal + t_pesagem + t_viagem self.sim.nrViagensRealizadas +=1
# Sample of python dispatcher from dispatch import Signal log_it = Signal(providing_args=['level', 'message']) def simple_receiver(**kwargs): message, level = kwargs['message'], kwargs['level'] print 'Receiver # 1' print '\tLevel: %d, Message: %s\n' % (level, message) def picky_receiver(**kwargs): message, level = kwargs['message'], kwargs['level'] print 'Receiver # 2' if level < 2: print "\tSome unimportant message was sent. Ignoring it!\n" log_it.connect(simple_receiver) log_it.connect(picky_receiver) def a_cool_sender(): # Do something cool here # Now send a signal to all receivers log_it.send(sender='a_cool_sender', message='Hello!', level=1) a_cool_sender()
def __init__(self, name, sim): Process.__init__(self, name, sim) self.property_changed = Signal(providing_args=['property_name']) self._t_fila_car = 0.0 self._t_fila_bal = 0.0 self._t_ciclo = 0.0
# -*- coding: utf-8 -*- __author__ = 'Esteban Castro Borsani' from dispatch import Signal # This are globals, you get the same object on import, from anywhere. # do_something = Event('do something') #args: my_arg1, my_arg_list2, my_arg_str3 quit_app = Signal() #args: some_arg
#! /usr/bin/env python # -*- coding: utf-8 -*- from dispatch import Signal error_excepted = Signal(providing_args=['type_', 'info']) passcode_newed = Signal(providing_args=['module', 'url', 'rand_code']) login_successed = Signal(providing_args=['username', 'password']) passcode_checked = Signal(providing_args=['module', 'value']) query_trains_completed = Signal(providing_args=['data']) query_tickets_completed = Signal(providing_args=['data']) passengers_received = Signal(providing_args=['passengers']) grab_tickets_successed = Signal(providing_args=[]) grab_tickets_failed = Signal(providing_args=[]) query_tickets_failed = Signal(providing_args=[])