snowflake.core.PollingOperation¶

class snowflake.core.PollingOperation(delegate: Future[T], transformer: Callable[[T], U])¶

Bases: Future[U]

Encapsulates the asynchronous execution of a callable.

Supports all methods provided by the concurrent.futures.Future class. PollingOperation instances are not intended to be created directly.

Param:

transformer - a callable that is executed with the result of the delegated future as an argument. The result of the callable is accessible via the result() method.

Examples

>>> operation = root.databases.iter_async()
Copy

Getting a value returned by the call, waiting indefinitely if the call hasn’t completed yet:

>>> result = operation.result()
Copy

Getting a value returned by the call, waiting up to 60 seconds if the call hasn’t completed yet:

>>> result = operation.result(timeout=60)
Copy

Getting whether the call is currently being executed:

>>> is_running = operation.running()
Copy

Cancelling the call if it has not started yet:

>>> cancelled = operation.cancel()
Copy

Getting an exception raised by the call, waiting indefinitely if the call hasn’t completed yet:

>>> exception = operation.exception()
Copy

Getting an exception raised by the call, waiting up to 60 seconds if the call hasn’t completed yet:

>>> exception = operation.exception(timeout=60)
Copy

Scheduling 100 task creation jobs and waiting for all of them to complete:

>>> operations = [task_collection.create_async(Task(name=f"task_{n}", definition="select 1")) for n in range(100)]
>>> concurrent.futures.wait(operations)
Copy

Initializes the future. Should not be called by clients.

Methods

add_done_callback(fn)¶

Attaches a callable that will be called when the future finishes.

Parameters:

fn – A callable that will be called with this future as its only argument when the future completes or is cancelled. The callable will always be called by a thread in the same process in which it was added. If the future has already completed or been cancelled then the callable will be called immediately. These callables are called in the order that they were added.

cancel() → bool¶

Cancel the future if possible.

Returns True if the future was cancelled, False otherwise. A future cannot be cancelled if it is running or has already completed.

cancelled()¶

Return True if the future was cancelled.

done()¶

Return True if the future was cancelled or finished executing.

exception(timeout=None)¶

Return the exception raised by the call that the future represents.

Parameters:

timeout – The number of seconds to wait for the exception if the future isn’t done. If None, then there is no limit on the wait time.

Returns:

The exception raised by the call that the future represents or None if the call completed without raising.

Raises:

  • CancelledError – If the future was cancelled.

  • TimeoutError – If the future didn’t finish executing before the given timeout.

result(timeout=None)¶

Return the result of the call that the future represents.

Parameters:

timeout – The number of seconds to wait for the result if the future isn’t done. If None, then there is no limit on the wait time.

Returns:

The result of the call that the future represents.

Raises:

  • CancelledError – If the future was cancelled.

  • TimeoutError – If the future didn’t finish executing before the given timeout.

  • Exception – If the call raised then that exception will be raised.

running()¶

Return True if the future is currently executing.

set_exception(exception)¶

Sets the result of the future as being the given exception.

Should only be used by Executor implementations and unit tests.

set_result(result)¶

Sets the return value of work associated with the future.

Should only be used by Executor implementations and unit tests.

set_running_or_notify_cancel()¶

Mark the future as running or process any cancel notifications.

Should only be used by Executor implementations and unit tests.

If the future has been cancelled (cancel() was called and returned True) then any threads waiting on the future completing (though calls to as_completed() or wait()) are notified and False is returned.

If the future was not cancelled then it is put in the running state (future calls to running() will return True) and True is returned.

This method should be called by Executor implementations before executing the work associated with this future. If this method returns False then the work should not be executed.

Returns:

False if the Future was cancelled, True otherwise.

Raises:

RuntimeError – if this method was already called or if set_result() or set_exception() was called.

Language: English