docs: def filterOr(self, **kwargs):
          '''
              filterOr - Performs a filter and returns a QueryableList object of the same type.
  
                  Anythe provided filters can match for the item to be returned.
  
              @params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.
  
              @return - A QueryableList object of the same type, with only the matching objects returned.
          '''
          filters = getFiltersFromArgs(kwargs)
          ret = self.__class__()
  
          if USE_CACHED:
              caches = [dict() for i in range(len(self))]
              get_item_value = self._getItemValueFunction(caches, self._get_item_value)
          else:
              get_item_value = self._get_item_value
  
          # OR filtering - For each item in the collection
          #   Run through each filter type. If anything matches, we add the item to the collection and continue
          #   If we get to the end without a match, we continue to next item
          for item in self:
              keepIt = False
  
              # Do is/isnot (and implicitly isnull) first.
              for fieldName, value in filters['is']:
                  if get_item_value(item, fieldName) is value:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['isnot']:
                  if get_item_value(item, fieldName) is not value:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, matchFunc in filters['customMatch']:
                  val = get_item_value(item, fieldName)
                  if matchFunc(val):
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['in']:
                  if get_item_value(item, fieldName) in value:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['notin']:
                  if get_item_value(item, fieldName) not in value:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['eq']:
                  if get_item_value(item, fieldName) == value:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['ieq']:
                  # If we can't lowercase the item's value, it obviously doesn't match whatever we previously could.
                  # Reminder: the "i" filter's values have already been lowercased
                  itemValue = get_item_value(item, fieldName)
                  try:
                      itemValueLower = itemValue.lower()
                  except:
                      keepIt = False
                      break
  
                  if itemValueLower == value:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['ne']:
                  if get_item_value(item, fieldName) != value:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['ine']:
                  itemValue = get_item_value(item, fieldName)
                  try:
                      itemValueLower = itemValue.lower()
                  except:
                      # If we can't convert the field value to lowercase, it does not equal the other.
                      continue
  
                  if itemValueLower != value:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['lt']:
                  if get_item_value(item, fieldName) < value:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['lte']:
                  if get_item_value(item, fieldName) <= value:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['gt']:
                  if get_item_value(item, fieldName) > value:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
  
              for fieldName, value in filters['gte']:
                  if get_item_value(item, fieldName) >= value:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['contains']:
                  itemValue = get_item_value(item, fieldName)
                  try:
                      if value in itemValue:
                          keepIt = True
                          break
                  except:
                      # If field does not support "in", it does not contain the item.
                      continue
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['icontains']:
                  itemValue = get_item_value(item, fieldName)
                  try:
                      itemValue = itemValue.lower()
  
                      if value in itemValue:
                          keepIt = True
                          break
                  except:
                      continue
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['notcontains']:
                  itemValue = get_item_value(item, fieldName)
                  try:
                      if value not in itemValue:
                          keepIt = True
                          break
                  except:
                      # If field does not support "in", it does not contain the item.
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['noticontains']:
                  itemValue = get_item_value(item, fieldName)
                  try:
                      itemValue = itemValue.lower()
  
                      if value not in itemValue:
                          keepIt = True
                          break
                  except:
                      # If field does not support "in", it does not contain the item.
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
  
              for fieldName, value in filters['containsAny']:
                  itemValue = get_item_value(item, fieldName)
  
                  if itemValue is None:
                      # None contains nothing, no match
                      continue
  
                  didContain = False
                  for maybeContains in value:
                      if maybeContains in itemValue:
                          didContain = True
                          break
                  if didContain is True:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['notcontainsAny']:
                  itemValue = get_item_value(item, fieldName)
  
                  if itemValue is None:
                      # None contains nothing, so this is a match
                      keepIt = True
                      break
  
                  didContain = False
                  for maybeContains in value:
                      if maybeContains in itemValue:
                          didContain = True
                          break
                  if didContain is False:
                      keepIt = True
                      break
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
  
              for fieldName, value in filters['splitcontains']:
                  (splitBy, maybeContains) = value
  
                  itemValue = get_item_value(item, fieldName)
  
                  if itemValue is None:
                      # Cannot split, no match
                      continue
  
                  try:
                      itemValue = itemValue.split(splitBy)
                      if maybeContains in itemValue:
                          keepIt = True
                          break
                  except:
                      # If field does not supprt "in", or cannot be split, it does not contain the item.
                      continue
  
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['splitnotcontains']:
                  (splitBy, maybeContains) = value
  
                  itemValue = get_item_value(item, fieldName)
  
                  if itemValue is None:
                      # Cannot split, so does not contain and is a match.
                      keepIt = True
                      break
  
  
                  try:
                      itemValue = itemValue.split(splitBy)
                      if maybeContains not in itemValue:
                          keepIt = True
                          break
                  except:
                      # If field does not supprt "in", or cannot be split, it does not contain the item and thus matches here.
                      keepIt = True
                      break
  
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
  
              for fieldName, value in filters['splitcontainsAny']:
                  (splitBy, maybeContainsLst) = value
  
                  itemValue = get_item_value(item, fieldName)
  
                  if itemValue is None:
                      # Cannot split, so it does not contain a match
                      continue
  
                  try:
                      itemValue = itemValue.split(splitBy)
                  except:
                      # Cannot split, does not match.
                      continue
  
  
                  didContain = False
                  for maybeContains in maybeContainsLst:
                      if maybeContains in itemValue:
                          didContain = True
                          break
  
                  if didContain is True:
                      keepIt = True
                      break
  
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
              for fieldName, value in filters['splitnotcontainsAny']:
                  (splitBy, maybeContainsLst) = value
  
                  itemValue = get_item_value(item, fieldName)
  
                  if itemValue is None:
                      # Cannot split, so it must not contain any (and is a match)
                      keepIt = True
                      break
  
                  try:
                      itemValue = itemValue.split(splitBy)
                  except:
                      # Cannot split, so must not contain any (and is a match)
                      keepIt = True
                      break
  
                  didContain = False
                  for maybeContains in maybeContainsLst:
                      if maybeContains in itemValue:
                          didContain = True
                          break
                  if didContain is False:
                      keepIt = True
                      break
  
  
              if keepIt is True:
                  ret.append(item)
                  continue
  
  
          return ret