def __init__(self, pipe, width=5):
Deferred.__init__(self)
self.pipe = pipe
self.width = width
self.waiting = None
self.running = 0
self.results = DeferredQueue()
def __init__(self, pipe, width=5):
Deferred.__init__(self)
self.pipe = pipe
self.width = width
self.waiting = None
self.running = 0
self.results = DeferredQueue()
def __init__(self, root, relation, path, parent, depth):
"""
Constructor.
Args:
root:
relation:
path:
parent:
depth: An positive integer value, corresponding to the number of
none 1..1 args traversed from the root Table to the current
"""
assert root != None, "ExploreTask::__init__(): invalid root = %s" % root
# Context
self.root = root
self.relation = relation
self.path = path
self.parent = parent
self.depth = depth
# Result
self.ast = None
self.sq_rename_dict = dict()
self.keep_root_a = set()
self.subqueries = dict()
self.identifier = random.randint(0, 9999)
Deferred.__init__(self)
def __init__(self, timeout=None):
r"""
@param timeout: Timeout object.
@type timeout: Any object, providing L{IDelayedCall<twisted.internet.interfaces.IDelayedCall>}
"""
self._timeout = timeout
Deferred.__init__(self)
def __init__(self, executable, args=[], env=None, termination_signal='KILL', path=None):
assert termination_signal in ALLOWED_TERMINATION_SIGNALS
Deferred.__init__(self, canceller=lambda _: self._kill())
self._termination_signal = termination_signal
self._stdout_output = []
self._stderr_output = []
self._killed = False
reactor.spawnProcess(self, executable, args=[os.path.basename(executable)] + args, env=env, path=path)
def __init__(self,
payloadEnvelope: PayloadEnvelope,
destVortexName: Optional[str] = None,
destVortexUuid: Optional[str] = None,
timeout: Optional[float] = None,
resultCheck=True,
logTimeoutError=True) -> None:
""" Constructor
Tag and optionally send a payload.
The timeout starts as soon as the constructor is called.
:param payloadEnvelope The payloadEnvelope to send to the remote and, and wait for a response for
:param destVortexName The name of the vortex to send to.
:param destVortexUuid The UUID of the vortex to send a payload to.
:param timeout The timeout to wait for a response
:param resultCheck Should the response payload.result be checked, if it fails
it errback will be called.
"""
Deferred.__init__(self)
if not timeout:
timeout = self.TIMEOUT
self._resultCheck = resultCheck
self._logTimeoutError = logTimeoutError
# uuid4 can have collisions
self._messageId = str(uuid4()) + str(PayloadResponse.__SEQ)
PayloadResponse.__SEQ += 1
payloadEnvelope.filt[self.__messageIdKey] = self._messageId
self._filt = copy(payloadEnvelope.filt)
self._destVortexName = destVortexName
self._status = self.PROCESSING
self._date = datetime.now(pytz.utc)
self._endpoint = PayloadEndpoint(self._filt, self._process)
if destVortexName or destVortexUuid:
d: Deferred = payloadEnvelope.toVortexMsgDefer()
d.addCallback(VortexFactory.sendVortexMsg,
destVortexName=destVortexName,
destVortexUuid=destVortexUuid)
d.addErrback(self.errback)
try:
raise Exception()
except:
self._stack = sys.exc_info()[2]
# noinspection PyTypeChecker
self.addTimeout(timeout, reactor)
self.addErrback(self._timedOut)
def __init__(self, protocol, message, timeout=5):
"""data without line eol. timeout -1 means we do not expect an answer."""
self.protocol = protocol
self.createTime = datetime.datetime.now()
self.sendTime = None
assert isinstance(message, Message), message
self.message = message
self.timeout = timeout
self.retries = 0
Deferred.__init__(self)
def __init__(self, verbose=False):
"""
Remember verbosity level for potential logging.
@type verbose: bool
@param verbose: If True, we log the response JSON
"""
Deferred.__init__(self)
self.verbose = verbose
def __init__(self, verbose=False):
"""
Remember verbosity level for potential logging.
@type verbose: bool
@param verbose: If True, we log the response JSON
"""
Deferred.__init__(self)
self.verbose = verbose
def reset(self, canceller=None): cback = self.callbacks canceller = (canceller if canceller is not None else self._canceller if self._canceller != None else None) Deferred.__init__(self, canceller) self.callbacks = cback
def __init__(self, pipe, prev=None):
Deferred.__init__(self)
self.pipe = pipe
self.prev = prev
self.result = None
self.waiting = False
self.unblock = DeferredQueue()
self.stage = 0
if prev:
# we will start when the previous pipe unblocks us
self.waitForPrev()
def __init__(self, pipe, prev=None):
Deferred.__init__(self)
self.pipe = pipe
self.prev = prev
self.result = None
self.waiting = False
self.unblock = DeferredQueue()
self.stage = 0
if prev:
# we will start when the previous pipe unblocks us
self.waitForPrev()
def __init__(self, protocol, message, maxWaitSeconds=None):
"""data without line eol. maxWaitSeconds -1 means we do not expect an answer."""
if maxWaitSeconds is None:
maxWaitSeconds = 5
self.protocol = protocol
self.message = message
self.maxWaitSeconds = maxWaitSeconds
self.createTime = datetime.datetime.now()
self.sendTime = None
self.answerTime = datetime.datetime.now() if maxWaitSeconds == -1 else None
assert isinstance(message, Message), message
Deferred.__init__(self)
def __init__(self, protocol, message, maxWaitSeconds=None):
"""data without line eol. maxWaitSeconds -1 means we do not expect an answer."""
if maxWaitSeconds is None:
maxWaitSeconds = 5
self.protocol = protocol
self.message = message
self.maxWaitSeconds = maxWaitSeconds
self.createTime = datetime.datetime.now()
self.sendTime = None
self.answerTime = datetime.datetime.now(
) if maxWaitSeconds == -1 else None
assert isinstance(message, Message), message
Deferred.__init__(self)
def __init__(self, runtime, field, value=None):
"""Initialize a share.
If an initial value is given, it will be passed to
:meth:`callback` right away.
"""
assert field is not None, "Cannot construct share without a field."
assert callable(field), "The field is not callable, wrong argument?"
Deferred.__init__(self)
self.runtime = runtime
self.field = field
if value is not None:
self.callback(value)
def __init__(self, runtime, field, value=None):
"""Initialize a share.
If an initial value is given, it will be passed to
:meth:`callback` right away.
"""
assert field is not None, "Cannot construct share without a field."
assert callable(field), "The field is not callable, wrong argument?"
Deferred.__init__(self)
self.runtime = runtime
self.field = field
if value is not None:
self.callback(value)
def __init__(self, dlg, modal=True, always=False):
Deferred.__init__(self)
self.dlg = dlg
self.modal = modal
self.always = always
if Options.gui:
if hasattr(self.dlg, 'buttonClicked'):
self.dlg.buttonClicked.connect(self.clicked)
else:
self.dlg.accepted.connect(self.clicked)
self.dlg.rejected.connect(self.cancel)
if Internal.reactor:
Internal.reactor.callLater(0, self.__execute)
else:
# we do not yet have a reactor in initDb()
self.__execute()
def __init__(self, dlg, modal=True, always=False):
Deferred.__init__(self)
self.dlg = dlg
self.defaultResult = dlg.returns()
self.modal = modal
self.always = always
if Options.gui:
if hasattr(self.dlg, 'buttonClicked'):
self.dlg.buttonClicked.connect(self.clicked)
else:
self.dlg.accepted.connect(self.clicked)
self.dlg.rejected.connect(self.cancel)
if Internal.reactor:
Internal.reactor.callLater(0, self.__execute)
else:
# we do not yet have a reactor in initDb()
self.__execute()
def __init__(self, dlg, modal=True, always=False):
Deferred.__init__(self)
self.dlg = dlg
self.modal = modal
self.always = always
if Internal.field:
if hasattr(self.dlg, 'buttonClicked'):
self.dlg.buttonClicked.connect(self.clicked)
else:
self.dlg.accepted.connect(self.clicked)
self.dlg.rejected.connect(self.cancel)
if Internal.reactor:
# pylint: disable=E1101
Internal.reactor.callLater(0, self.__execute)
else:
# we do not yet have a reactor in initDb()
self.__execute()
def __init__(self, server, port, login, password,
ssl_flag, timeout=5,
receive_event=None, no_messages_event=None):
Deferred.__init__(self)
dhnio.Dprint(16, 'transport_email.PopCheckerServer.__init__')
self.server = server
try:
self.port = int(port)
except:
self.port = 110
self.ssl_flag = ssl_flag
self.addCallbacks(self.stop,self.fail)
self.loopcall = None
self.shutdown = False
self.checker = PopChecker(login, password,
timeout, self.run, receive_event,
finish_event=self.finish_callback,
no_messages_event=no_messages_event)
def __init__(self,
executable,
args=[],
env=None,
termination_signal='KILL',
path=None):
assert termination_signal in ALLOWED_TERMINATION_SIGNALS
Deferred.__init__(self, canceller=lambda _: self._kill())
self._termination_signal = termination_signal
self._stdout_output = []
self._stderr_output = []
self._killed = False
reactor.spawnProcess(self,
executable,
args=[os.path.basename(executable)] + args,
env=env,
path=path)
def __init__(self, deferred_factories, max_concurrent):
# type: (Iterable[Callable[[], Deferred]], int) -> None
"""
:param deferred_factories: A list of callables which, when invoked without arguments, return a Deferred.
:param max_concurrent: Run no more than max_concurrent Deferreds at the same time.
"""
Deferred.__init__(self)
# Index the Deferreds so we can order the results when they callback
indexed_factories = enumerate(deferred_factories)
self.deferred_factories = collections.deque(indexed_factories)
self.results = [None] * len(self.deferred_factories)
self.counter = 0
# Start up max_concurrent Deferreds! Later, we start a new Deferred for every one that callbacks. So we don't
# even need to store max_concurrent
for _ in range(max_concurrent):
self.__schedule_deferred()
def __init__(self, wrapped_d):
Deferred.__init__(self)
self.already_fired = False
def callback(*args, **kwargs):
if not self.already_fired:
self.already_fired = True
self.callback(*args, **kwargs)
else:
log.msg("callback called again: %s %s" % (args, kwargs))
def errback(*args, **kwargs):
if not self.already_fired:
self.already_fired = True
self.errback(*args, **kwargs)
else:
log.msg("errback called again: %s %s" % (args, kwargs))
wrapped_d.addCallbacks(callback, errback)
def __init__(self, wrapped_d):
Deferred.__init__(self)
self.already_fired = False
def callback(*args, **kwargs):
if not self.already_fired:
self.already_fired = True
self.callback(*args, **kwargs)
else:
log.msg("callback called again: %s %s" % (args, kwargs))
def errback(*args, **kwargs):
if not self.already_fired:
self.already_fired = True
self.errback(*args, **kwargs)
else:
log.msg("errback called again: %s %s" % (args, kwargs))
wrapped_d.addCallbacks(callback, errback)
def __init__(self, deferredList, fireOnOneCallback=0, fireOnOneErrback=0,
consumeErrors=0):
"""Initialize a DeferredList.
@type deferredList: C{list} of L{Deferred}s
@param deferredList: The list of deferreds to track.
@param fireOnOneCallback: (keyword param) a flag indicating that
only one callback needs to be fired for me to call
my callback
@param fireOnOneErrback: (keyword param) a flag indicating that
only one errback needs to be fired for me to call
my errback
@param consumeErrors: (keyword param) a flag indicating that any errors
raised in the original deferreds should be
consumed by this DeferredList. This is useful to
prevent spurious warnings being logged.
"""
self.resultList = [None] * len(deferredList)
Deferred.__init__(self)
if len(deferredList) == 0 and not fireOnOneCallback:
self.callback(self.resultList)
# These flags need to be set *before* attaching callbacks to the
# deferreds, because the callbacks use these flags, and will run
# synchronously if any of the deferreds are already fired.
self.fireOnOneCallback = fireOnOneCallback
self.fireOnOneErrback = fireOnOneErrback
self.consumeErrors = consumeErrors
self.finishedCount = 0
index = 0
for deferred in deferredList:
deferred.addCallbacks(self._cbDeferred, self._cbDeferred,
callbackArgs=(index,SUCCESS),
errbackArgs=(index,FAILURE))
index = index + 1
def __init__(self):
Deferred.__init__(self)
NotKnown.__init__(self)
self.pause()
def __init__(self):
Deferred.__init__(self)
NotKnown.__init__(self)
self.pause()
def __init__(self, timeout):
Deferred.__init__(self)
reactor.callLater(timeout, self.callback, None)
def __init__(self, result):
Deferred.__init__(self)
self._wait(result)
def __init__(self, result):
Deferred.__init__(self)
self._wait(result)
def __init__(self, data=None):
Deferred.__init__(self)
self.data = data
def __init__(self, timeout=1.0):
Deferred.__init__(self)
self._timeout = timeout
self.timer = reactor.callLater(timeout, self.timed_out)
def __init__(self, threshold=1):
Deferred.__init__(self)
assert threshold >= 1, "threshold should be at least 1"
self.threshold = threshold
self.times_called = 0
def __init__(self):
Deferred.__init__(self)
self.canceled = 0
def __init__(self, data, canceller=None): BasicMessage.__init__(self, data) Deferred.__init__(self)
def __init__(self, pattern, *args, **kwargs):
Deferred.__init__(self, *args, **kwargs)
self.pattern = pattern
def __init__(self):
Deferred.__init__(self)
self.canceled = 0
def __init__(self, timeout=1.0):
Deferred.__init__(self)
self._timeout = timeout
self.timer = reactor.callLater(timeout, self.timed_out)
