docs: def bulk_modify(self, *filters_or_records, **kwargs):
          """Shortcut to bulk modify records
          
          .. versionadded:: 2.17.0
          
          Args:
              *filters_or_records (tuple) or (Record): Either a list of Records, or a list of filters.
  
          Keyword Args:
              values (dict): Dictionary of one or more 'field_name': 'new_value' pairs to update
  
          Notes:
              Requires Swimlane 2.17+
  
          Examples:
  
              ::
  
                  # Bulk update records by filter
  
                  app.records.bulk_modify(
                      # Query filters
                      ('Field_1', 'equals', value1),
                      ('Field_2', 'equals', value2),
                      ...
                      # New values for records
                      values={
                          "Field_3": value3,
                          "Field_4": value4,
                          ...
                      }
                  )
  
                  # Bulk update records
  
                  record1 = app.records.get(tracking_id='APP-1')
                  record2 = app.records.get(tracking_id='APP-2')
                  record3 = app.records.get(tracking_id='APP-3')
  
                  app.records.bulk_modify(record1, record2, record3, values={"Field_Name": 'new value'})
  
          Returns:
              :class:`string`: Bulk Modify Job ID
          """
          values = kwargs.pop('values', None)
  
          if kwargs:
              raise ValueError('Unexpected arguments: {}'.format(kwargs))
  
          if not values:
              raise ValueError('Must provide "values" as keyword argument')
  
          if not isinstance(values, dict):
              raise ValueError("values parameter must be dict of {'field_name': 'update_value'} pairs")
  
          _type = validate_filters_or_records(filters_or_records)
  
          request_payload = {}
          record_stub = record_factory(self._app)
  
          # build record_id list
          if _type is Record:
              request_payload['recordIds'] = [record.id for record in filters_or_records]
  
          # build filters
          else:
              filters = []
              for filter_tuples in filters_or_records:
                  field_name = record_stub.get_field(filter_tuples[0])
                  filters.append({
                      "fieldId": field_name.id,
                      "filterType": filter_tuples[1],
                      "value": field_name.get_report(filter_tuples[2])
                  })
              request_payload['filters'] = filters
  
          # Ensure all values are wrapped in a bulk modification operation, defaulting to Replace if not provided for
          # backwards compatibility
          for field_name in list(values.keys()):
              modification_operation = values[field_name]
              if not isinstance(modification_operation, _BulkModificationOperation):
                  values[field_name] = Replace(modification_operation)
  
          # build modifications
          modifications = []
          for field_name, modification_operation in values.items():
              # Lookup target field
              modification_field = record_stub.get_field(field_name)
              if not modification_field.bulk_modify_support:
                  raise ValueError("Field '{}' of Type '{}', is not supported for bulk modify".format(
                      field_name,
                      modification_field.__class__.__name__
                  ))
  
              modifications.append({
                  "fieldId": {
                      "value": modification_field.id,
                      "type": "id"
                  },
                  "value": modification_field.get_bulk_modify(modification_operation.value),
                  "type": modification_operation.type
              })
          request_payload['modifications'] = modifications
          response = self._swimlane.request('put', "app/{0}/record/batch".format(self._app.id), json=request_payload)
  
          # Update records if instances were used to submit bulk modify request after request was successful
          if _type is Record:
              for record in filters_or_records:
                  for field_name, modification_operation in six.iteritems(values):
                      record[field_name] = modification_operation.value
  
          return response.text