# encoding: utf-8
# module vtkmodules.vtkCommonExecutionModel
# from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkCommonExecutionModel.cp311-win_amd64.pyd
# by generator 1.147
# no doc

# imports
import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore


class vtkAlgorithm(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkAlgorithm - Superclass for all sources, filters, and sinks in VTK.
    
    Superclass: vtkObject
    
    vtkAlgorithm is the superclass for all sources, filters, and sinks in
    VTK.  It defines a generalized interface for executing data
    processing algorithms.  Pipeline connections are associated with
    input and output ports that are independent of the type of data
    passing through the connections.
    
    Instances may be used independently or within pipelines with a
    variety of architectures and update mechanisms.  Pipelines are
    controlled by instances of vtkExecutive.  Every vtkAlgorithm instance
    has an associated vtkExecutive when it is used in a pipeline.  The
    executive is responsible for data flow.
    """
    def AbortExecuteOff(self): # real signature unknown; restored from __doc__
        """
        AbortExecuteOff(self) -> None
        C++: virtual void AbortExecuteOff()
        """
        pass

    def AbortExecuteOn(self): # real signature unknown; restored from __doc__
        """
        AbortExecuteOn(self) -> None
        C++: virtual void AbortExecuteOn()
        """
        pass

    def AddInputConnection(self, port, input): # real signature unknown; restored from __doc__
        """
        AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
            -> None
        C++: virtual void AddInputConnection(int port,
            vtkAlgorithmOutput *input)
        AddInputConnection(self, input:vtkAlgorithmOutput) -> None
        C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
        
        Add a connection to the given input port index.  See
        SetInputConnection() for details on input connections.  This
        method is the complement to RemoveInputConnection() in that it
        adds only the connection specified without affecting other
        connections.  Typical usage is
        
        * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
        """
        pass

    def AddInputDataObject(self, port, data): # real signature unknown; restored from __doc__
        """
        AddInputDataObject(self, port:int, data:vtkDataObject) -> None
        C++: virtual void AddInputDataObject(int port,
            vtkDataObject *data)
        AddInputDataObject(self, data:vtkDataObject) -> None
        C++: virtual void AddInputDataObject(vtkDataObject *data)
        
        Add the data-object as an input to this given port. This will add
        a new input connection on the specified port without affecting
        any existing connections on the same input port.
        """
        pass

    def CAN_HANDLE_PIECE_REQUEST(self): # real signature unknown; restored from __doc__
        """
        CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
        C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
        
        Key that tells the pipeline that a particular algorithm can or
        cannot handle piece request. If a filter cannot handle piece
        requests and is asked for a piece, the executive will flag an
        error. If a structured data source cannot handle piece requests
        but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
        executive will use an extent translator to split the extent into
        pieces. Otherwise, if a source cannot handle piece requests, the
        executive will ask for the whole data for piece 0 and not execute
        the source for other pieces.\ingroup InformationKeys
        """
        pass

    def CAN_PRODUCE_SUB_EXTENT(self): # real signature unknown; restored from __doc__
        """
        CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
        C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
        
        This key tells the executive that a particular output port is
        capable of producing an arbitrary subextent of the whole extent.
        Many image sources and readers fall into this category but some
        such as the legacy structured data readers cannot support this
        feature.\ingroup InformationKeys
        """
        pass

    def ConvertTotalInputToPortConnection(self, ind, port, conn): # real signature unknown; restored from __doc__
        """
        ConvertTotalInputToPortConnection(self, ind:int, port:int,
            conn:int) -> None
        C++: void ConvertTotalInputToPortConnection(int ind, int &port,
            int &conn)
        
        Convenience routine to convert from a linear ordering of input
        connections to a port/connection pair.
        """
        pass

    def GetAbortExecute(self): # real signature unknown; restored from __doc__
        """
        GetAbortExecute(self) -> int
        C++: virtual vtkTypeBool GetAbortExecute()
        """
        return 0

    def GetErrorCode(self): # real signature unknown; restored from __doc__
        """
        GetErrorCode(self) -> int
        C++: virtual unsigned long GetErrorCode()
        
        The error code contains a possible error that occurred while
        reading or writing the file.
        """
        return 0

    def GetExecutive(self): # real signature unknown; restored from __doc__
        """
        GetExecutive(self) -> vtkExecutive
        C++: vtkExecutive *GetExecutive()
        
        Get this algorithm's executive.  If it has none, a default
        executive will be created.
        """
        return vtkExecutive

    def GetInformation(self): # real signature unknown; restored from __doc__
        """
        GetInformation(self) -> vtkInformation
        C++: virtual vtkInformation *GetInformation()
        
        Set/Get the information object associated with this algorithm.
        """
        pass

    def GetInputAlgorithm(self, port, index, algPort): # real signature unknown; restored from __doc__
        """
        GetInputAlgorithm(self, port:int, index:int, algPort:int)
            -> vtkAlgorithm
        C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
            int &algPort)
        GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
        C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
        GetInputAlgorithm(self) -> vtkAlgorithm
        C++: vtkAlgorithm *GetInputAlgorithm()
        
        Returns the algorithm and the output port index of that algorithm
        connected to a port-index pair.
        """
        return vtkAlgorithm

    def GetInputArrayInformation(self, idx): # real signature unknown; restored from __doc__
        """
        GetInputArrayInformation(self, idx:int) -> vtkInformation
        C++: vtkInformation *GetInputArrayInformation(int idx)
        
        Get the info object for the specified input array to this
        algorithm
        """
        pass

    def GetInputConnection(self, port, index): # real signature unknown; restored from __doc__
        """
        GetInputConnection(self, port:int, index:int)
            -> vtkAlgorithmOutput
        C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
        
        Get the algorithm output port connected to an input port.
        """
        return vtkAlgorithmOutput

    def GetInputDataObject(self, port, connection): # real signature unknown; restored from __doc__
        """
        GetInputDataObject(self, port:int, connection:int)
            -> vtkDataObject
        C++: vtkDataObject *GetInputDataObject(int port, int connection)
        
        Get the data object that will contain the algorithm input for the
        given port and given connection.
        """
        pass

    def GetInputExecutive(self, port, index): # real signature unknown; restored from __doc__
        """
        GetInputExecutive(self, port:int, index:int) -> vtkExecutive
        C++: vtkExecutive *GetInputExecutive(int port, int index)
        GetInputExecutive(self) -> vtkExecutive
        C++: vtkExecutive *GetInputExecutive()
        
        Returns the executive associated with a particular input
        connection.
        """
        return vtkExecutive

    def GetInputInformation(self, port, index): # real signature unknown; restored from __doc__
        """
        GetInputInformation(self, port:int, index:int) -> vtkInformation
        C++: vtkInformation *GetInputInformation(int port, int index)
        GetInputInformation(self) -> vtkInformation
        C++: vtkInformation *GetInputInformation()
        
        Return the information object that is associated with a
        particular input connection. This can be used to get meta-data
        coming from the REQUEST_INFORMATION pass and set requests for the
        REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
        pipeline passes. Use the information objects passed as arguments
        instead.
        """
        pass

    def GetInputPortInformation(self, port): # real signature unknown; restored from __doc__
        """
        GetInputPortInformation(self, port:int) -> vtkInformation
        C++: vtkInformation *GetInputPortInformation(int port)
        
        Get the information object associated with an input port.  There
        is one input port per kind of input to the algorithm.  Each input
        port tells executives what kind of data and downstream requests
        this algorithm can handle for that input.
        """
        pass

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        return 0

    def GetNumberOfInputConnections(self, port): # real signature unknown; restored from __doc__
        """
        GetNumberOfInputConnections(self, port:int) -> int
        C++: int GetNumberOfInputConnections(int port)
        
        Get the number of inputs currently connected to a port.
        """
        return 0

    def GetNumberOfInputPorts(self): # real signature unknown; restored from __doc__
        """
        GetNumberOfInputPorts(self) -> int
        C++: int GetNumberOfInputPorts()
        
        Get the number of input ports used by the algorithm.
        """
        return 0

    def GetNumberOfOutputPorts(self): # real signature unknown; restored from __doc__
        """
        GetNumberOfOutputPorts(self) -> int
        C++: int GetNumberOfOutputPorts()
        
        Get the number of output ports provided by the algorithm.
        """
        return 0

    def GetOutputDataObject(self, port): # real signature unknown; restored from __doc__
        """
        GetOutputDataObject(self, port:int) -> vtkDataObject
        C++: vtkDataObject *GetOutputDataObject(int port)
        
        Get the data object that will contain the algorithm output for
        the given port.
        """
        pass

    def GetOutputInformation(self, port): # real signature unknown; restored from __doc__
        """
        GetOutputInformation(self, port:int) -> vtkInformation
        C++: vtkInformation *GetOutputInformation(int port)
        
        Return the information object that is associated with a
        particular output port. This can be used to set meta-data coming
        during the REQUEST_INFORMATION. NOTE: Do not use this in any of
        the pipeline passes. Use the information objects passed as
        arguments instead.
        """
        pass

    def GetOutputPort(self, index): # real signature unknown; restored from __doc__
        """
        GetOutputPort(self, index:int) -> vtkAlgorithmOutput
        C++: vtkAlgorithmOutput *GetOutputPort(int index)
        GetOutputPort(self) -> vtkAlgorithmOutput
        C++: vtkAlgorithmOutput *GetOutputPort()
        
        Get a proxy object corresponding to the given output port of this
        algorithm.  The proxy object can be passed to another algorithm's
        SetInputConnection(), AddInputConnection(), and
        RemoveInputConnection() methods to modify pipeline connectivity.
        """
        return vtkAlgorithmOutput

    def GetOutputPortInformation(self, port): # real signature unknown; restored from __doc__
        """
        GetOutputPortInformation(self, port:int) -> vtkInformation
        C++: vtkInformation *GetOutputPortInformation(int port)
        
        Get the information object associated with an output port.  There
        is one output port per output from the algorithm.  Each output
        port tells executives what kind of upstream requests this
        algorithm can handle for that output.
        """
        pass

    def GetProgress(self): # real signature unknown; restored from __doc__
        """
        GetProgress(self) -> float
        C++: virtual double GetProgress()
        
        Get the execution progress of a process object.
        """
        return 0.0

    def GetProgressObserver(self): # real signature unknown; restored from __doc__
        """
        GetProgressObserver(self) -> vtkProgressObserver
        C++: virtual vtkProgressObserver *GetProgressObserver()
        """
        return vtkProgressObserver

    def GetProgressScale(self): # real signature unknown; restored from __doc__
        """
        GetProgressScale(self) -> float
        C++: virtual double GetProgressScale()
        """
        return 0.0

    def GetProgressShift(self): # real signature unknown; restored from __doc__
        """
        GetProgressShift(self) -> float
        C++: virtual double GetProgressShift()
        """
        return 0.0

    def GetProgressText(self): # real signature unknown; restored from __doc__
        """
        GetProgressText(self) -> str
        C++: virtual char *GetProgressText()
        """
        return ""

    def GetReleaseDataFlag(self): # real signature unknown; restored from __doc__
        """
        GetReleaseDataFlag(self) -> int
        C++: virtual int GetReleaseDataFlag()
        """
        return 0

    def GetTotalNumberOfInputConnections(self): # real signature unknown; restored from __doc__
        """
        GetTotalNumberOfInputConnections(self) -> int
        C++: int GetTotalNumberOfInputConnections()
        
        Get the total number of inputs for this algorithm
        """
        return 0

    def GetUpdateExtent(self): # real signature unknown; restored from __doc__
        """
        GetUpdateExtent(self) -> (int, int, int, int, int, int)
        C++: int *GetUpdateExtent()
        GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
        C++: int *GetUpdateExtent(int port)
        GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
            z1:int) -> None
        C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
            int &z0, int &z1)
        GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
            z0:int, z1:int) -> None
        C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
            int &y1, int &z0, int &z1)
        GetUpdateExtent(self, extent:[int, int, int, int, int, int])
            -> None
        C++: void GetUpdateExtent(int extent[6])
        GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
            int]) -> None
        C++: void GetUpdateExtent(int port, int extent[6])
        
        These functions return the update extent for output ports that
        use 3D extents. Where port is not specified, it is assumed to be
        0.
        """
        pass

    def GetUpdateGhostLevel(self): # real signature unknown; restored from __doc__
        """
        GetUpdateGhostLevel(self) -> int
        C++: int GetUpdateGhostLevel()
        GetUpdateGhostLevel(self, port:int) -> int
        C++: int GetUpdateGhostLevel(int port)
        """
        return 0

    def GetUpdateNumberOfPieces(self): # real signature unknown; restored from __doc__
        """
        GetUpdateNumberOfPieces(self) -> int
        C++: int GetUpdateNumberOfPieces()
        GetUpdateNumberOfPieces(self, port:int) -> int
        C++: int GetUpdateNumberOfPieces(int port)
        """
        return 0

    def GetUpdatePiece(self): # real signature unknown; restored from __doc__
        """
        GetUpdatePiece(self) -> int
        C++: int GetUpdatePiece()
        GetUpdatePiece(self, port:int) -> int
        C++: int GetUpdatePiece(int port)
        
        These functions return the update extent for output ports that
        use piece extents. Where port is not specified, it is assumed to
        be 0.
        """
        return 0

    def HasExecutive(self): # real signature unknown; restored from __doc__
        """
        HasExecutive(self) -> int
        C++: int HasExecutive()
        
        Check whether this algorithm has an assigned executive.  This
        will NOT create a default executive.
        """
        return 0

    def INPUT_ARRAYS_TO_PROCESS(self): # real signature unknown; restored from __doc__
        """
        INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
        C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
            )
        
        \ingroup InformationKeys
        """
        pass

    def INPUT_CONNECTION(self): # real signature unknown; restored from __doc__
        """
        INPUT_CONNECTION() -> vtkInformationIntegerKey
        C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
        
        \ingroup InformationKeys
        """
        pass

    def INPUT_IS_OPTIONAL(self): # real signature unknown; restored from __doc__
        """
        INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
        C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
        
        Keys used to specify input port requirements.\ingroup
        InformationKeys
        """
        pass

    def INPUT_IS_REPEATABLE(self): # real signature unknown; restored from __doc__
        """
        INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
        C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
        
        \ingroup InformationKeys
        """
        pass

    def INPUT_PORT(self): # real signature unknown; restored from __doc__
        """
        INPUT_PORT() -> vtkInformationIntegerKey
        C++: static vtkInformationIntegerKey *INPUT_PORT()
        
        \ingroup InformationKeys
        """
        pass

    def INPUT_REQUIRED_DATA_TYPE(self): # real signature unknown; restored from __doc__
        """
        INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
        C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
            )
        
        \ingroup InformationKeys
        """
        pass

    def INPUT_REQUIRED_FIELDS(self): # real signature unknown; restored from __doc__
        """
        INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
        C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
            )
        
        \ingroup InformationKeys
        """
        pass

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        return 0

    def ModifyRequest(self, request, when): # real signature unknown; restored from __doc__
        """
        ModifyRequest(self, request:vtkInformation, when:int) -> int
        C++: virtual int ModifyRequest(vtkInformation *request, int when)
        
        This method gives the algorithm a chance to modify the contents
        of a request before or after (specified in the when argument) it
        is forwarded. The default implementation is empty. Returns 1 on
        success, 0 on failure. When can be either
        vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
        """
        return 0

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkAlgorithm
        C++: vtkAlgorithm *NewInstance()
        """
        return vtkAlgorithm

    def ProcessRequest(self, request, inInfo, outInfo): # real signature unknown; restored from __doc__
        """
        ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
             outInfo:vtkInformationVector) -> int
        C++: vtkTypeBool ProcessRequest(vtkInformation *request,
            vtkCollection *inInfo, vtkInformationVector *outInfo)
        
        Version of ProcessRequest() that is wrapped. This converts the
        collection to an array and calls the other version.
        """
        return 0

    def PropagateUpdateExtent(self): # real signature unknown; restored from __doc__
        """
        PropagateUpdateExtent(self) -> None
        C++: virtual void PropagateUpdateExtent()
        
        Propagate meta-data upstream.
        """
        pass

    def ReleaseDataFlagOff(self): # real signature unknown; restored from __doc__
        """
        ReleaseDataFlagOff(self) -> None
        C++: void ReleaseDataFlagOff()
        """
        pass

    def ReleaseDataFlagOn(self): # real signature unknown; restored from __doc__
        """
        ReleaseDataFlagOn(self) -> None
        C++: void ReleaseDataFlagOn()
        """
        pass

    def RemoveAllInputConnections(self, port): # real signature unknown; restored from __doc__
        """
        RemoveAllInputConnections(self, port:int) -> None
        C++: virtual void RemoveAllInputConnections(int port)
        
        Removes all input connections.
        """
        pass

    def RemoveAllInputs(self): # real signature unknown; restored from __doc__
        """
        RemoveAllInputs(self) -> None
        C++: void RemoveAllInputs()
        
        Remove all the input data.
        """
        pass

    def RemoveInputConnection(self, port, input): # real signature unknown; restored from __doc__
        """
        RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
            -> None
        C++: virtual void RemoveInputConnection(int port,
            vtkAlgorithmOutput *input)
        RemoveInputConnection(self, port:int, idx:int) -> None
        C++: virtual void RemoveInputConnection(int port, int idx)
        
        Remove a connection from the given input port index.  See
        SetInputConnection() for details on input connection.  This
        method is the complement to AddInputConnection() in that it
        removes only the connection specified without affecting other
        connections.  Typical usage is
        
        * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
        """
        pass

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkAlgorithm
        C++: static vtkAlgorithm *SafeDownCast(vtkObjectBase *o)
        """
        return vtkAlgorithm

    def SetAbortExecute(self, _arg): # real signature unknown; restored from __doc__
        """
        SetAbortExecute(self, _arg:int) -> None
        C++: virtual void SetAbortExecute(vtkTypeBool _arg)
        
        Set/Get the AbortExecute flag for the process object. Process
        objects may handle premature termination of execution in
        different ways.
        """
        pass

    def SetDefaultExecutivePrototype(self, proto): # real signature unknown; restored from __doc__
        """
        SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
        C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
        
        If the DefaultExecutivePrototype is set, a copy of it is created
        in CreateDefaultExecutive() using NewInstance().
        """
        pass

    def SetExecutive(self, executive): # real signature unknown; restored from __doc__
        """
        SetExecutive(self, executive:vtkExecutive) -> None
        C++: virtual void SetExecutive(vtkExecutive *executive)
        
        Set this algorithm's executive.  This algorithm is removed from
        any executive to which it has previously been assigned and then
        assigned to the given executive.
        """
        pass

    def SetInformation(self, __a): # real signature unknown; restored from __doc__
        """
        SetInformation(self, __a:vtkInformation) -> None
        C++: virtual void SetInformation(vtkInformation *)
        """
        pass

    def SetInputArrayToProcess(self, idx, port, connection, fieldAssociation, name): # real signature unknown; restored from __doc__
        """
        SetInputArrayToProcess(self, idx:int, port:int, connection:int,
            fieldAssociation:int, name:str) -> None
        C++: virtual void SetInputArrayToProcess(int idx, int port,
            int connection, int fieldAssociation, const char *name)
        SetInputArrayToProcess(self, idx:int, port:int, connection:int,
            fieldAssociation:int, fieldAttributeType:int) -> None
        C++: virtual void SetInputArrayToProcess(int idx, int port,
            int connection, int fieldAssociation, int fieldAttributeType)
        SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
        C++: virtual void SetInputArrayToProcess(int idx,
            vtkInformation *info)
        SetInputArrayToProcess(self, idx:int, port:int, connection:int,
            fieldAssociation:str, attributeTypeorName:str) -> None
        C++: virtual void SetInputArrayToProcess(int idx, int port,
            int connection, const char *fieldAssociation,
            const char *attributeTypeorName)
        
        Set the input data arrays that this algorithm will process.
        Specifically the idx array that this algorithm will process
        (starting from 0) is the array on port, connection with the
        specified association and name or attribute type (such as
        SCALARS). The fieldAssociation refers to which field in the data
        object the array is stored. See vtkDataObject::FieldAssociations
        for detail.
        """
        pass

    def SetInputConnection(self, port, input): # real signature unknown; restored from __doc__
        """
        SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
            -> None
        C++: virtual void SetInputConnection(int port,
            vtkAlgorithmOutput *input)
        SetInputConnection(self, input:vtkAlgorithmOutput) -> None
        C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
        
        Set the connection for the given input port index.  Each input
        port of a filter has a specific purpose.  A port may have zero or
        more connections and the required number is specified by each
        filter.  Setting the connection with this method removes all
        other connections from the port.  To add more than one connection
        use AddInputConnection().
        
        * The input for the connection is the output port of another
        * filter, which is obtained with GetOutputPort().  Typical usage
          is
        
        * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
        """
        pass

    def SetInputDataObject(self, port, data): # real signature unknown; restored from __doc__
        """
        SetInputDataObject(self, port:int, data:vtkDataObject) -> None
        C++: virtual void SetInputDataObject(int port,
            vtkDataObject *data)
        SetInputDataObject(self, data:vtkDataObject) -> None
        C++: virtual void SetInputDataObject(vtkDataObject *data)
        
        Sets the data-object as an input on the given port index. Setting
        the input with this method removes all other connections from the
        port. Internally, this method creates a vtkTrivialProducer
        instance and sets that as the input-connection for the given
        port. It is safe to call this method repeatedly with the same
        input data object. The MTime of the vtkAlgorithm will not change
        unless the data object changed.
        """
        pass

    def SetProgressObserver(self, __a): # real signature unknown; restored from __doc__
        """
        SetProgressObserver(self, __a:vtkProgressObserver) -> None
        C++: void SetProgressObserver(vtkProgressObserver *)
        
        If an ProgressObserver is set, the algorithm will report progress
        through it rather than directly. This means that it will call
        UpdateProgress() on the ProgressObserver rather than itself
        report it and set progress. This is most useful in situations
        where multiple threads are executing an algorithm at the same
        time and want to handle progress locally.
        """
        pass

    def SetProgressShiftScale(self, shift, scale): # real signature unknown; restored from __doc__
        """
        SetProgressShiftScale(self, shift:float, scale:float) -> None
        C++: void SetProgressShiftScale(double shift, double scale)
        
        Specify the shift and scale values to use to apply to the
        progress amount when `UpdateProgress` is called. By default shift
        is set to 0, and scale is set to 1.0. This is useful when the
        vtkAlgorithm instance is used as an internal algorithm to solve
        only a part of a whole problem.
        
        If calling on a internal vtkAlgorithm, make sure you take into
        consideration that values set of the outer vtkAlgorithm as well
        since the outer vtkAlgorithm itself may be nested in another
        algorithm.
        
        ote SetProgressShiftScale does not modify the MTime of the
        algorithm.
        """
        pass

    def SetProgressText(self, ptext): # real signature unknown; restored from __doc__
        """
        SetProgressText(self, ptext:str) -> None
        C++: void SetProgressText(const char *ptext)
        
        Set the current text message associated with the progress state.
        This may be used by a calling process/GUI. Note: Because
        SetProgressText() is called from inside RequestData() it does not
        modify the algorithm object. Algorithms are not allowed to modify
        themselves from inside RequestData().
        """
        pass

    def SetReleaseDataFlag(self, __a): # real signature unknown; restored from __doc__
        """
        SetReleaseDataFlag(self, __a:int) -> None
        C++: virtual void SetReleaseDataFlag(int)
        
        Turn release data flag on or off for all output ports.
        """
        pass

    def Update(self, port): # real signature unknown; restored from __doc__
        """
        Update(self, port:int) -> None
        C++: virtual void Update(int port)
        Update(self) -> None
        C++: virtual void Update()
        Update(self, port:int, requests:vtkInformationVector) -> int
        C++: virtual vtkTypeBool Update(int port,
            vtkInformationVector *requests)
        Update(self, requests:vtkInformation) -> int
        C++: virtual vtkTypeBool Update(vtkInformation *requests)
        
        Bring this algorithm's outputs up-to-date.
        """
        pass

    def UpdateDataObject(self): # real signature unknown; restored from __doc__
        """
        UpdateDataObject(self) -> None
        C++: virtual void UpdateDataObject()
        
        Create output object(s).
        """
        pass

    def UpdateExtent(self, extents, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
        C++: virtual int UpdateExtent(const int extents[6])
        
        Convenience method to update an algorithm after passing requests
        to its first output port. Supports extent request.
        """
        pass

    def UpdateExtentIsEmpty(self, pinfo, output): # real signature unknown; restored from __doc__
        """
        UpdateExtentIsEmpty(self, pinfo:vtkInformation,
            output:vtkDataObject) -> int
        C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
            vtkDataObject *output)
        UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
            -> int
        C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
            int extentType)
        
        This detects when the UpdateExtent will generate no data This
        condition is satisfied when the UpdateExtent has zero volume
        (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
        call to determine whether to call Execute.
        """
        return 0

    def UpdateInformation(self): # real signature unknown; restored from __doc__
        """
        UpdateInformation(self) -> None
        C++: virtual void UpdateInformation()
        
        Bring the algorithm's information up-to-date.
        """
        pass

    def UpdatePiece(self, piece, numPieces, ghostLevels, extents, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
            extents:(int, int, int, int, int, int)=...) -> int
        C++: virtual int UpdatePiece(int piece, int numPieces,
            int ghostLevels, const int extents[6]=nullptr)
        
        Convenience method to update an algorithm after passing requests
        to its first output port. See documentation for Update(int port,
        vtkInformationVector* requests) for details. Supports piece and
        extent (optional) requests.
        """
        pass

    def UpdateProgress(self, amount): # real signature unknown; restored from __doc__
        """
        UpdateProgress(self, amount:float) -> None
        C++: void UpdateProgress(double amount)
        
        Update the progress of the process object. If a ProgressMethod
        exists, executes it.  Then set the Progress ivar to amount. The
        parameter amount should range between (0,1).
        """
        pass

    def UpdateTimeStep(self, time, piece=-1, numPieces=1, ghostLevels=0, extents, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
            ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
             -> int
        C++: virtual int UpdateTimeStep(double time, int piece=-1,
            int numPieces=1, int ghostLevels=0,
            const int extents[6]=nullptr)
        
        Convenience method to update an algorithm after passing requests
        to its first output port. See documentation for Update(int port,
        vtkInformationVector* requests) for details. Supports time, piece
        (optional) and extent (optional) requests.
        """
        pass

    def UpdateWholeExtent(self): # real signature unknown; restored from __doc__
        """
        UpdateWholeExtent(self) -> None
        C++: virtual void UpdateWholeExtent()
        
        Bring this algorithm's outputs up-to-date.
        """
        pass

    def UsesGarbageCollector(self): # real signature unknown; restored from __doc__
        """
        UsesGarbageCollector(self) -> bool
        C++: bool UsesGarbageCollector() override;
        
        Participate in garbage collection.
        """
        return False

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    DEFAULT_PRECISION = 2
    DesiredOutputPrecision = None # (!) real value is "<class 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm.DesiredOutputPrecision'>"
    DOUBLE_PRECISION = 1
    SINGLE_PRECISION = 0
    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkAlgorithm', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'HasExecutive': <method 'HasExecutive' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetExecutive': <method 'GetExecutive' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'SetExecutive': <method 'SetExecutive' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'ProcessRequest': <method 'ProcessRequest' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'ModifyRequest': <method 'ModifyRequest' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetInputPortInformation': <method 'GetInputPortInformation' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetOutputPortInformation': <method 'GetOutputPortInformation' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetInformation': <method 'GetInformation' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'SetInformation': <method 'SetInformation' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetNumberOfInputPorts': <method 'GetNumberOfInputPorts' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetNumberOfOutputPorts': <method 'GetNumberOfOutputPorts' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'UsesGarbageCollector': <method 'UsesGarbageCollector' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'SetAbortExecute': <method 'SetAbortExecute' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetAbortExecute': <method 'GetAbortExecute' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'AbortExecuteOn': <method 'AbortExecuteOn' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'AbortExecuteOff': <method 'AbortExecuteOff' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetProgress': <method 'GetProgress' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'UpdateProgress': <method 'UpdateProgress' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'SetProgressShiftScale': <method 'SetProgressShiftScale' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetProgressShift': <method 'GetProgressShift' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetProgressScale': <method 'GetProgressScale' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'SetProgressText': <method 'SetProgressText' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetProgressText': <method 'GetProgressText' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetErrorCode': <method 'GetErrorCode' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'INPUT_IS_OPTIONAL': <method 'INPUT_IS_OPTIONAL' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'INPUT_IS_REPEATABLE': <method 'INPUT_IS_REPEATABLE' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'INPUT_REQUIRED_FIELDS': <method 'INPUT_REQUIRED_FIELDS' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'INPUT_REQUIRED_DATA_TYPE': <method 'INPUT_REQUIRED_DATA_TYPE' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'INPUT_ARRAYS_TO_PROCESS': <method 'INPUT_ARRAYS_TO_PROCESS' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'INPUT_PORT': <method 'INPUT_PORT' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'INPUT_CONNECTION': <method 'INPUT_CONNECTION' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'CAN_PRODUCE_SUB_EXTENT': <method 'CAN_PRODUCE_SUB_EXTENT' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'CAN_HANDLE_PIECE_REQUEST': <method 'CAN_HANDLE_PIECE_REQUEST' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'SetInputArrayToProcess': <method 'SetInputArrayToProcess' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetInputArrayInformation': <method 'GetInputArrayInformation' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'RemoveAllInputs': <method 'RemoveAllInputs' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetOutputDataObject': <method 'GetOutputDataObject' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetInputDataObject': <method 'GetInputDataObject' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'SetInputConnection': <method 'SetInputConnection' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'AddInputConnection': <method 'AddInputConnection' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'RemoveInputConnection': <method 'RemoveInputConnection' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'RemoveAllInputConnections': <method 'RemoveAllInputConnections' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'SetInputDataObject': <method 'SetInputDataObject' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'AddInputDataObject': <method 'AddInputDataObject' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetOutputPort': <method 'GetOutputPort' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetNumberOfInputConnections': <method 'GetNumberOfInputConnections' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetTotalNumberOfInputConnections': <method 'GetTotalNumberOfInputConnections' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetInputConnection': <method 'GetInputConnection' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetInputAlgorithm': <method 'GetInputAlgorithm' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetInputExecutive': <method 'GetInputExecutive' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetInputInformation': <method 'GetInputInformation' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetOutputInformation': <method 'GetOutputInformation' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'Update': <method 'Update' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'UpdatePiece': <method 'UpdatePiece' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'UpdateExtent': <method 'UpdateExtent' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'UpdateTimeStep': <method 'UpdateTimeStep' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'UpdateInformation': <method 'UpdateInformation' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'UpdateDataObject': <method 'UpdateDataObject' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'PropagateUpdateExtent': <method 'PropagateUpdateExtent' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'UpdateWholeExtent': <method 'UpdateWholeExtent' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'ConvertTotalInputToPortConnection': <method 'ConvertTotalInputToPortConnection' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'SetReleaseDataFlag': <method 'SetReleaseDataFlag' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetReleaseDataFlag': <method 'GetReleaseDataFlag' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'ReleaseDataFlagOn': <method 'ReleaseDataFlagOn' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'ReleaseDataFlagOff': <method 'ReleaseDataFlagOff' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'UpdateExtentIsEmpty': <method 'UpdateExtentIsEmpty' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'SetDefaultExecutivePrototype': <method 'SetDefaultExecutivePrototype' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetUpdateExtent': <method 'GetUpdateExtent' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetUpdatePiece': <method 'GetUpdatePiece' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetUpdateNumberOfPieces': <method 'GetUpdateNumberOfPieces' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetUpdateGhostLevel': <method 'GetUpdateGhostLevel' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'SetProgressObserver': <method 'SetProgressObserver' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'GetProgressObserver': <method 'GetProgressObserver' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, 'DesiredOutputPrecision': <class 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm.DesiredOutputPrecision'>, 'SINGLE_PRECISION': 0, 'DOUBLE_PRECISION': 1, 'DEFAULT_PRECISION': 2, '__new__': <built-in method __new__ of type object at 0x00007FF82F4DEDB0>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonExecutionModel.vtkAlgorithm' objects>, '__doc__': 'vtkAlgorithm - Superclass for all sources, filters, and sinks in VTK.\\n\\nSuperclass: vtkObject\\n\\nvtkAlgorithm is the superclass for all sources, filters, and sinks in\\nVTK.  It defines a generalized interface for executing data\\nprocessing algorithms.  Pipeline connections are associated with\\ninput and output ports that are independent of the type of data\\npassing through the connections.\\n\\nInstances may be used independently or within pipelines with a\\nvariety of architectures and update mechanisms.  Pipelines are\\ncontrolled by instances of vtkExecutive.  Every vtkAlgorithm instance\\nhas an associated vtkExecutive when it is used in a pipeline.  The\\nexecutive is responsible for data flow.\\n\\n'})"
    __vtkname__ = 'vtkAlgorithm'