docs: def update_stage(self, stage, executable=None, force=False,
                       name=None, unset_name=False, folder=None, unset_folder=False, stage_input=None,
                       instance_type=None, edit_version=None, **kwargs):
          '''
          :param stage: A number for the stage index (for the nth stage, starting from 0), or a string stage index, name, or ID
          :type stage: int or string
          :param executable: string or a handler for an app or applet
          :type executable: string, DXApplet, or DXApp
          :param force: whether to use *executable* even if it is incompatible with the previous executable's spec
          :type force: boolean
          :param name: new name for the stage; cannot be provided with *unset_name* set to True
          :type name: string
          :param unset_name: whether to unset the stage name; cannot be True with string value for *name*
          :type unset_name: boolean
          :param folder: new default output folder for the stage; either a relative or absolute path (optional)
          :type folder: string
          :param unset_folder: whether to unset the stage folder; cannot be True with string value for *folder*
          :type unset_folder: boolean
          :param stage_input: input fields to bind as default inputs for the executable (optional)
          :type stage_input: dict
          :param instance_type: Default instance type on which all jobs will be run for this stage, or a dict mapping function names to instance type requests
          :type instance_type: string or dict
          :param edit_version: if provided, the edit version of the workflow that should be modified; if not provided, the current edit version will be used (optional)
          :type edit_version: int
  
          Removes the specified stage from the workflow
          '''
          stage_id = self._get_stage_id(stage)
  
          if name is not None and unset_name:
              raise DXError('dxpy.DXWorkflow.update_stage: cannot provide both "name" and set "unset_name"')
          if folder is not None and unset_folder:
              raise DXError('dxpy.DXWorkflow.update_stage: cannot provide both "folder" and set "unset_folder"')
  
          if executable is not None:
              if isinstance(executable, basestring):
                  exec_id = executable
              elif isinstance(executable, DXExecutable):
                  exec_id = executable.get_id()
              else:
                  raise DXError("dxpy.DXWorkflow.update_stage: executable (if provided) must be a string or an instance of DXApplet or DXApp")
              update_stage_exec_input = {"stage": stage_id,
                                         "executable": exec_id,
                                         "force": force}
              self._add_edit_version_to_request(update_stage_exec_input, edit_version)
              try:
                  dxpy.api.workflow_update_stage_executable(self._dxid, update_stage_exec_input, **kwargs)
              finally:
                  self.describe() # update cached describe
  
          # Construct hash and update the workflow's stage if necessary
          update_stage_input = {}
          if name is not None:
              update_stage_input["name"] = name
          elif unset_name:
              update_stage_input["name"] = None
          if folder:
              update_stage_input["folder"] = folder
          elif unset_folder:
              update_stage_input["folder"] = None
          if stage_input:
              update_stage_input["input"] = stage_input
          if instance_type is not None:
              update_stage_input["systemRequirements"] = SystemRequirementsDict.from_instance_type(instance_type).as_dict()
          if update_stage_input:
              update_input = {"stages": {stage_id: update_stage_input}}
              self._add_edit_version_to_request(update_input, edit_version)
              try:
                  dxpy.api.workflow_update(self._dxid, update_input, **kwargs)
              finally:
                  self.describe()