Python blinker.Signal方法代码示例

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def __init__(self, url, secret=None, cxn_cls=Connection, **kwargs):
				self.url = url
				self.secret = secret
				self.state = self.DISCONNECTED
				self.cxn_cls = cxn_cls
				self.cxn = None
				self.cxn_kwargs = kwargs
				self.cxns = 0
				self.created = threading.Event()
				self.plugins = []
				self.plugin_idx = {}
				self.txns = {}
				self.txn_q = []
				self._connected = None
				self._disconnected = None
				self._created = None

		# Signal fired when `Session` has been connected. 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def add(self, signal_name, receiver, sender=ANY):
        """
        增加订阅者

        e.g.::

            def callback_function_for_app(sender, **kwargs):
                pass
            def callback_function_for_all(sender, **kwargs):
                pass
            my_signal = signal('test')
            observer.add(my_signal, callback_function_for_app, 'APP')
            observer.add(my_signal, callback_function_for_all)

        :param signal_name: 订阅的主题, 信号
        :param receiver: 订阅者回调方法
        :param sender: ANY, 'ANY' 面向所有发布者(默认), 'APP', current_app._get_current_object() 当前 APP
        :return:
        """
        if isinstance(signal_name, Signal) and hasattr(receiver, '__call__'):
            self._observers.append({
                'signal_name': signal_name,
                'receiver': receiver,
                'sender': sender,
            }) 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def __init__(self, host='localhost', port=9091, *, tls=False, user='',
                 password='', path='/transmission/rpc', enabled=True):
        self.host = host
        self.port = port
        self.path = path
        self.tls = tls
        self.user = user
        self.password = password
        self._headers = {'content-type': 'application/json'}
        self._session = None
        self._enabled_event = asyncio.Event()
        self.enabled = enabled
        self._request_lock = asyncio.Lock()
        self._connecting_lock = asyncio.Lock()
        self._connection_tested = False
        self._connection_exception = None
        self._timeout = TIMEOUT
        self._version = None
        self._rpcversion = None
        self._rpcversionmin = None
        self._on_connecting = Signal()
        self._on_connected = Signal()
        self._on_disconnected = Signal()
        self._on_error = Signal() 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def on(self, signal, callback, autoremove=True):
        """
        Register `callback` for `signal`

        signal: 'connecting', 'connected', 'disconnected' or 'error'
        callback: a callable that receives this instance as a positional
                  argument and, in case of the 'error' signal, the exception as
                  a keyword argument with the name 'error'

        Callbacks are automatically unsubscribed when they are
        garbage-collected.
        """
        try:
            sig = getattr(self, '_on_' + signal)
        except AttributeError:
            raise ValueError('Unknown signal: {!r}'.format(signal))
        else:
            if not isinstance(sig, Signal):
                raise ValueError('Unknown signal: {!r}'.format(signal))
            else:
                log.debug('Registering %r for %r event', callback, signal)
                sig.connect(callback, weak=autoremove) 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def __init__(self, srvapi, interval=1):
        self._session_stats_updated = False
        self._tcounts_updated = False
        self._reset_session_stats()
        self._reset_tcounts()
        self._on_update = blinker.Signal()

        self._poller_stats = RequestPoller(srvapi.rpc.session_stats,
                                           interval=interval)
        self._poller_stats.on_response(self._handle_session_stats)
        self._poller_stats.on_error(lambda e: log.debug('Ignoring exception: %r', e),
                                    autoremove=False)

        # 'session-stats' provides some counters, but not enough, so we
        # request a minimalistic torrent list.
        self._poller_tcount = RequestPoller(srvapi.torrent.torrents,
                                            keys=('rate-down', 'rate-up', 'status'),
                                            interval=interval)
        self._poller_tcount.on_response(self._handle_torrent_list) 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def __init__(self, name, owningNode, direction, **kwargs):
        """
        :param name: Pin name
        :type name: string
        :param owningNode: Owning Node
        :type owningNode: :py:class:`PyFlow.Core.NodeBase.NodeBase`
        :param direction: PinDirection , can be input or output
        :type direction: :py:class:`PyFlow.Core.Common.PinDirection`
        """
        super(AnyPin, self).__init__(name, owningNode, direction, **kwargs)
        self.typeChanged = Signal(str)
        self.dataTypeBeenSet = Signal()
        self.setDefaultValue(None)
        self._isAny = True
        # if True, setType and setDefault will work only once
        self.singleInit = False
        self.checkForErrors = True
        self.enableOptions(PinOptions.ChangeTypeOnConnection)
        self._defaultSupportedDataTypes = self._supportedDataTypes = tuple([pin.__name__ for pin in getAllPinClasses() if pin.IsValuePin()])
        self.canChange = True
        self._super = None
        self.prevDataType = None
        self._lastError2 = None 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def __init__(self, name, manager, parentGraph=None, category='', uid=None, *args, **kwargs):
        super(GraphBase, self).__init__(*args, **kwargs)
        self.graphManager = manager
        self._isRoot = False

        self.nameChanged = Signal(str)
        self.categoryChanged = Signal(str)

        self.__name = name
        self.__category = category

        self._parentGraph = None
        self.childGraphs = set()

        self.parentGraph = parentGraph

        self._nodes = {}
        self._vars = {}
        self.uid = uuid.uuid4() if uid is None else uid

        manager.add(self) 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def on_message(self):
        """Emitted when a message frame is received.

        The signal sender is the connection and the ``message`` is sent as an
        argument.
        """
        return blinker.Signal(doc='Emitted when a message frame is received.') 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def on_response(self):
        """Emitted when a response frame is received.

        The signal sender is the connection and the ``response`` is sent as an
        argument.
        """
        return blinker.Signal(doc='Emitted when a response frame is received.') 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def on_error(self):
        """Emitted when an error frame is received.

        The signal sender is the connection and the ``error`` is sent as an
        argument.
        """
        return blinker.Signal(doc='Emitted when a error frame is received.') 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def on_finish(self):
        """Emitted after :meth:`finish`.

        Sent after a message owned by this connection is successfully finished.
        The signal sender is the connection and the ``message_id`` is sent as an
        argument.
        """
        return blinker.Signal(doc='Emitted after the a message is finished.') 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def on_requeue(self):
        """Emitted after :meth:`requeue`.

        Sent after a message owned by this connection is requeued. The signal
        sender is the connection and the ``message_id``, ``timeout`` and
        ``backoff`` flag are sent as arguments.
        """
        return blinker.Signal(doc='Emitted after the a message is requeued.') 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def on_close(self):
        """Emitted after :meth:`close_stream`.

        Sent after the connection socket has closed. The signal sender is the
        connection.
        """
        return blinker.Signal(doc='Emitted after the connection is closed.') 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def on_response(self):
        """Emitted when a response is received.

        The signal sender is the consumer and the ` ` is sent as an
        argument.
        """
        return blinker.Signal(doc='Emitted when a response is received.') 

# 需要导入模块: import blinker [as 别名]
# 或者: from blinker import Signal [as 别名]
def on_error(self):
        """Emitted when an error is received.

        The signal sender is the consumer and the ``error`` is sent as an
        argument.
        """
        return blinker.Signal(doc='Emitted when a error is received.')