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=[])
