def initServer(self):
"""Initialize the server after connecting to LabRAD."""
self.knownDevices = {} # maps (server, channel) to (name, idn)
self.deviceServers = {} # maps device name to list of interested servers.
# each interested server is {'target':<>,'context':<>,'messageID':<>}
self.identFunctions = {} # maps server to (setting, ctx) for ident
self.identLock = DeferredLock()
# named messages are sent with source ID first, which we ignore
connect_func = lambda c, (s, payload): self.gpib_device_connect(*payload)
disconnect_func = lambda c, (s, payload): self.gpib_device_disconnect(*payload)
mgr = self.client.manager
self._cxn.addListener(connect_func, source=mgr.ID, ID=10)
self._cxn.addListener(disconnect_func, source=mgr.ID, ID=11)
yield mgr.subscribe_to_named_message('GPIB Device Connect', 10, True)
yield mgr.subscribe_to_named_message('GPIB Device Disconnect', 11, True)
# do an initial scan of the available GPIB devices
yield self.refreshDeviceLists()
python类DeferredLock()的实例源码
def __init__(self, *args, **kwargs):
AMQClient.__init__(self, *args, **kwargs)
if self.check_0_8():
self.replyToField = "reply to"
else:
self.replyToField = "reply-to"
self.thriftBasicReturnQueueLock = defer.DeferredLock()
self.thriftBasicReturnQueues = {}
def cleanup_deferred_locks():
"""
Need to use this from within trial to cleanup the reactor before
each run.
"""
SoledadDocumentWrapper._k_locks = defaultdict(defer.DeferredLock)
def _get_klass_lock(cls):
"""
Get a DeferredLock that is unique for this subclass name.
Used to lock the access to indexes in the `get_or_create` call
for a particular DocumentWrapper.
"""
return cls._k_locks[cls.__name__]
def __init__(self, doc_id=None, future_doc_id=None, **kwargs):
self._doc_id = doc_id
self._future_doc_id = future_doc_id
self._lock = defer.DeferredLock()
super(SoledadDocumentWrapper, self).__init__(**kwargs)
def __init__(self, maxPerSecond=0):
self.maxPerSecond = maxPerSecond
defer.DeferredLock.__init__(self)
def release(self):
delay = self._nextDelay()
self.reactor.callLater(delay, defer.DeferredLock.release, self)
def initServer(self):
self.listeners = set()
self.camera = AndorCamera()
self.lock = DeferredLock()
self.gui = AndorVideo(self)
def __init__(self, token, on_update, proxy=None, debug=False):
self._lock = defer.DeferredLock()
self._token = token
self._proxy = proxy
self._debug = debug
assert callable(on_update)
self._on_update = on_update
def test_cancelLockAfterAcquired(self):
"""
When canceling a L{Deferred} from a L{DeferredLock} that already
has the lock, the cancel should have no effect.
"""
def _failOnErrback(_):
self.fail("Unexpected errback call!")
lock = defer.DeferredLock()
d = lock.acquire()
d.addErrback(_failOnErrback)
d.cancel()
def test_cancelLockBeforeAcquired(self):
"""
When canceling a L{Deferred} from a L{DeferredLock} that does not
yet have the lock (i.e., the L{Deferred} has not fired), the cancel
should cause a L{defer.CancelledError} failure.
"""
lock = defer.DeferredLock()
lock.acquire()
d = lock.acquire()
d.cancel()
self.assertImmediateFailure(d, defer.CancelledError)
def __init__(self):
self._tasks = iter(())
self._active_tasks = []
self.failures = 0
self.task_lock = defer.DeferredLock()
def __init__(self, timeout, _reactor=reactor):
self.lock = defer.DeferredLock()
self.deferred_subscribers = []
self._reactor = _reactor
self._timeout = timeout
self.timer = task.LoopingCall(
self.notify,
DirectorEvent("null", "No updates"),
)
self.timer.clock = self._reactor
def __init__(self, file_path):
"""
Args:
file_path: is the location of where the filesystem based lockfile should be written to.
"""
self._fs_lock = defer.DeferredFilesystemLock(file_path)
self._mutex = defer.DeferredLock()
def testLock(self):
lock = defer.DeferredLock()
lock.acquire().addCallback(self._incr)
self.failUnless(lock.locked)
self.assertEquals(self.counter, 1)
lock.acquire().addCallback(self._incr)
self.failUnless(lock.locked)
self.assertEquals(self.counter, 1)
lock.release()
self.failUnless(lock.locked)
self.assertEquals(self.counter, 2)
lock.release()
self.failIf(lock.locked)
self.assertEquals(self.counter, 2)
self.assertRaises(TypeError, lock.run)
firstUnique = object()
secondUnique = object()
controlDeferred = defer.Deferred()
def helper(self, b):
self.b = b
return controlDeferred
resultDeferred = lock.run(helper, self=self, b=firstUnique)
self.failUnless(lock.locked)
self.assertEquals(self.b, firstUnique)
resultDeferred.addCallback(lambda x: setattr(self, 'result', x))
lock.acquire().addCallback(self._incr)
self.failUnless(lock.locked)
self.assertEquals(self.counter, 2)
controlDeferred.callback(secondUnique)
self.assertEquals(self.result, secondUnique)
self.failUnless(lock.locked)
self.assertEquals(self.counter, 3)
lock.release()
self.failIf(lock.locked)
def __init__(self, delegate, vhost, spec, heartbeat=0, clock=None, insist=False):
FrameReceiver.__init__(self, spec)
self.delegate = delegate
# XXX Cyclic dependency
self.delegate.client = self
self.vhost = vhost
self.channelFactory = type("Channel%s" % self.spec.klass.__name__,
(self.channelClass, self.spec.klass), {})
self.channels = {}
self.channelLock = defer.DeferredLock()
self.outgoing = defer.DeferredQueue()
self.work = defer.DeferredQueue()
self.started = TwistedEvent()
self.disconnected = TwistedEvent() # Fired upon connection shutdown
self.closed = False
self.queueLock = defer.DeferredLock()
self.basic_return_queue = TimeoutDeferredQueue()
self.queues = {}
self.outgoing.get().addCallback(self.writer)
self.work.get().addCallback(self.worker)
self.heartbeatInterval = heartbeat
self.insist = insist
if clock is None:
from twisted.internet import reactor
clock = reactor
self.clock = clock
if self.heartbeatInterval > 0:
self.checkHB = self.clock.callLater(self.heartbeatInterval *
self.MAX_UNSEEN_HEARTBEAT, self.check_heartbeat)
self.sendHB = LoopingCall(self.send_heartbeat)
self.sendHB.clock = self.clock
d = self.started.wait()
d.addCallback(lambda _: self.reschedule_send_heartbeat())
d.addCallback(lambda _: self.reschedule_check_heartbeat())
# If self.started fails, don't start the heartbeat.
d.addErrback(lambda _: None)
def __init__(self,
list_path,
state_space_parameters,
hyper_parameters,
epsilon=None,
number_models=None):
self.protocol = QConnection
self.new_net_lock = DeferredLock()
self.clients = {} # name of connection is key, each value is dict with {'connection', 'net', 'iters_sampled'}
self.replay_columns = ['net', #Net String
'accuracy_best_val',
'iter_best_val',
'accuracy_last_val',
'iter_last_val',
'accuracy_best_test',
'accuracy_last_test',
'ix_q_value_update', #Iteration for q value update
'epsilon', # For epsilon greedy
'time_finished', # UNIX time
'machine_run_on']
self.list_path = list_path
self.replay_dictionary_path = os.path.join(list_path, 'replay_database.csv')
self.replay_dictionary, self.q_training_step = self.load_replay()
self.schedule_or_single = False if epsilon else True
if self.schedule_or_single:
self.epsilon = state_space_parameters.epsilon_schedule[0][0]
self.number_models = state_space_parameters.epsilon_schedule[0][1]
else:
self.epsilon = epsilon
self.number_models = number_models if number_models else 10000000000
self.state_space_parameters = state_space_parameters
self.hyper_parameters = hyper_parameters
self.number_q_updates_per_train = 100
self.list_path = list_path
self.qlearner = self.load_qlearner()
self.check_reached_limit()
def testLock(self):
lock = defer.DeferredLock()
lock.acquire().addCallback(self._incr)
self.failUnless(lock.locked)
self.assertEquals(self.counter, 1)
lock.acquire().addCallback(self._incr)
self.failUnless(lock.locked)
self.assertEquals(self.counter, 1)
lock.release()
self.failUnless(lock.locked)
self.assertEquals(self.counter, 2)
lock.release()
self.failIf(lock.locked)
self.assertEquals(self.counter, 2)
self.assertRaises(TypeError, lock.run)
firstUnique = object()
secondUnique = object()
controlDeferred = defer.Deferred()
def helper(self, b):
self.b = b
return controlDeferred
resultDeferred = lock.run(helper, self=self, b=firstUnique)
self.failUnless(lock.locked)
self.assertEquals(self.b, firstUnique)
resultDeferred.addCallback(lambda x: setattr(self, 'result', x))
lock.acquire().addCallback(self._incr)
self.failUnless(lock.locked)
self.assertEquals(self.counter, 2)
controlDeferred.callback(secondUnique)
self.assertEquals(self.result, secondUnique)
self.failUnless(lock.locked)
self.assertEquals(self.counter, 3)
lock.release()
self.failIf(lock.locked)
def testLock(self):
lock = defer.DeferredLock()
lock.acquire().addCallback(self._incr)
self.assertTrue(lock.locked)
self.assertEqual(self.counter, 1)
lock.acquire().addCallback(self._incr)
self.assertTrue(lock.locked)
self.assertEqual(self.counter, 1)
lock.release()
self.assertTrue(lock.locked)
self.assertEqual(self.counter, 2)
lock.release()
self.assertFalse(lock.locked)
self.assertEqual(self.counter, 2)
self.assertRaises(TypeError, lock.run)
firstUnique = object()
secondUnique = object()
controlDeferred = defer.Deferred()
def helper(self, b):
self.b = b
return controlDeferred
resultDeferred = lock.run(helper, self=self, b=firstUnique)
self.assertTrue(lock.locked)
self.assertEqual(self.b, firstUnique)
resultDeferred.addCallback(lambda x: setattr(self, 'result', x))
lock.acquire().addCallback(self._incr)
self.assertTrue(lock.locked)
self.assertEqual(self.counter, 2)
controlDeferred.callback(secondUnique)
self.assertEqual(self.result, secondUnique)
self.assertTrue(lock.locked)
self.assertEqual(self.counter, 3)
d = lock.acquire().addBoth(lambda x: setattr(self, 'result', x))
d.cancel()
self.assertEqual(self.result.type, defer.CancelledError)
lock.release()
self.assertFalse(lock.locked)
