func_timeout (version 4.2.0)
index

Copyright (c) 2016, 2017 Tim Savannah All Rights Reserved.
 
Licensed under the Lesser GNU Public License Version 3, LGPLv3. You should have recieved a copy of this with the source distribution as
LICENSE, otherwise it is available at https://github.com/kata198/func_timeout/LICENSE

 
Package Contents
       
StoppableThread
dafunc
exceptions
py2_raise
py3_raise

 
Classes
       
builtins.BaseException(builtins.object)
func_timeout.exceptions.FunctionTimedOut

 
class FunctionTimedOut(builtins.BaseException)
    FunctionTimedOut - Exception raised when a function times out
 
@property timedOutAfter - Number of seconds before timeout was triggered
 
@property timedOutFunction - Function called which timed out
@property timedOutArgs - Ordered args to function
@property timedOutKwargs - Keyword args to function
 
@method retry - Retries the function with same arguments, with option to run with original timeout, no timeout, or a different
  explicit timeout. @see FunctionTimedOut.retry
 
 
Method resolution order:
FunctionTimedOut
builtins.BaseException
builtins.object

Methods defined here:
__init__(self, msg='', timedOutAfter=None, timedOutFunction=None, timedOutArgs=None, timedOutKwargs=None)
Initialize self.  See help(type(self)) for accurate signature.
getMsg(self)
getMsg - Generate a default message based on parameters to FunctionTimedOut exception'
 
@return <str> - Message
retry(self, timeout='RETRY_SAME_TIMEOUT')
retry - Retry the timed-out function with same arguments.
 
@param timeout <float/RETRY_SAME_TIMEOUT/None> Default RETRY_SAME_TIMEOUT
    
    If RETRY_SAME_TIMEOUT : Will retry the function same args, same timeout
    If a float/int : Will retry the function same args with provided timeout
    If None : Will retry function same args no timeout
 
@return - Returnval from function

Data descriptors defined here:
__weakref__
list of weak references to the object (if defined)

Methods inherited from builtins.BaseException:
__delattr__(self, name, /)
Implement delattr(self, name).
__getattribute__(self, name, /)
Return getattr(self, name).
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__reduce__(...)
helper for pickle
__repr__(self, /)
Return repr(self).
__setattr__(self, name, value, /)
Implement setattr(self, name, value).
__setstate__(...)
__str__(self, /)
Return str(self).
with_traceback(...)
Exception.with_traceback(tb) --
set self.__traceback__ to tb and return self.

Data descriptors inherited from builtins.BaseException:
__cause__
exception cause
__context__
exception context
__dict__
__suppress_context__
__traceback__
args

 
Functions
       
func_set_timeout(timeout, allowOverride=False)
func_set_timeout - Decorator to run a function with a given/calculated timeout (max execution time).
    Optionally (if #allowOverride is True), adds a paramater, "forceTimeout", to the
    function which, if provided, will override the default timeout for that invocation.
 
    If #timeout is provided as a lambda/function, it will be called
      prior to each invocation of the decorated function to calculate the timeout to be used
      for that call, based on the arguments passed to the decorated function.
      
      For example, you may have a "processData" function whose execution time
      depends on the number of "data" elements, so you may want a million elements to have a 
      much higher timeout than seven elements.)
 
    If #allowOverride is True AND a kwarg of "forceTimeout" is passed to the wrapped function, that timeout
     will be used for that single call.
 
@param timeout <float OR lambda/function> - 
 
    **If float:**
        Default number of seconds max to allow function to execute
          before throwing FunctionTimedOut
    
    **If lambda/function:
 
         If a function/lambda is provided, it will be called for every
          invocation of the decorated function (unless #allowOverride=True and "forceTimeout" was passed) 
          to determine the timeout to use based on the arguments to the decorated function.
 
            The arguments as passed into the decorated function will be passed to this function.
             They either must match exactly to what the decorated function has, OR
              if you prefer to get the *args (list of ordered args) and **kwargs ( key : value  keyword args form),
              define your calculate function like:
                
                def calculateTimeout(*args, **kwargs):
                    ...
            
              or lambda like:
 
                calculateTimeout = lambda *args, **kwargs : ...
 
            otherwise the args to your calculate function should match exactly the decorated function.
 
 
@param allowOverride <bool> Default False, if True adds a keyword argument to the decorated function,
    "forceTimeout" which, if provided, will override the #timeout. If #timeout was provided as a lambda / function, it
     will not be called.
 
@throws FunctionTimedOut If time alloted passes without function returning naturally
 
@see func_timeout
func_timeout(timeout, func, args=(), kwargs=None)
func_timeout - Runs the given function for up to #timeout# seconds.
 
Raises any exceptions #func# would raise, returns what #func# would return (unless timeout is exceeded), in which case it raises FunctionTimedOut
 
@param timeout <float> - Maximum number of seconds to run #func# before terminating
 
@param func <function> - The function to call
 
@param args    <tuple> - Any ordered arguments to pass to the function
 
@param kwargs  <dict/None> - Keyword arguments to pass to the function.
 
 
@raises - FunctionTimedOut if #timeout# is exceeded, otherwise anything #func# could raise will be raised
 
If the timeout is exceeded, FunctionTimedOut will be raised within the context of the called function every two seconds until it terminates,
but will not block the calling thread (a new thread will be created to perform the join). If possible, you should try/except FunctionTimedOut
to return cleanly, but in most cases it will 'just work'.
 
@return - The return value that #func# gives

 
Data
        __all__ = ('func_timeout', 'func_set_timeout', 'FunctionTimedOut')
__version_tuple__ = (4, 2, 0)