Call the find function
163554
def find(self, changed=True, forward=True,
             rehighlight=True, start_highlight_timer=False, multiline_replace_check=True):
        """"""
        # When several lines are selected in the editor and replace box is activated, 
        # dynamic search is deactivated to prevent changing the selection. Otherwise
        # we show matching items.
        if multiline_replace_check and self.replace_widgets[0].isVisible() and \
           len(to_text_string(self.editor.get_selected_text()).splitlines())>1:
            return None
        text = self.search_text.currentText()
        if len(text) == 0:
            self.search_text.lineEdit().setStyleSheet("")
            if not self.is_code_editor:
                # Clears the selection for WebEngine
                self.editor.find_text('')
            self.change_number_matches()
            return None
        else:
            case = self.case_button.isChecked()
            words = self.words_button.isChecked()
            regexp = self.re_button.isChecked()
            found = self.editor.find_text(text, changed, forward, case=case,
                                          words=words, regexp=regexp)

            stylesheet = self.STYLE[found]
            tooltip = self.TOOLTIP[found]
            if not found and regexp:
                error_msg = regexp_error_msg(text)
                if error_msg:  # special styling for regexp errors
                    stylesheet = self.STYLE['regexp_error']
                    tooltip = self.TOOLTIP['regexp_error'] + ': ' + error_msg
            self.search_text.lineEdit().setStyleSheet(stylesheet)
            self.search_text.setToolTip(tooltip)

            if self.is_code_editor and found:
                block = self.editor.textCursor().block()
                TextHelper(self.editor).unfold_if_colapsed(block)

                if rehighlight or not self.editor.found_results:
                    self.highlight_timer.stop()
                    if start_highlight_timer:
                        self.highlight_timer.start()
                    else:
                        self.highlight_matches()
            else:
                self.clear_matches()

            number_matches = self.editor.get_number_matches(text, case=case,
                                                            regexp=regexp)
            if hasattr(self.editor, 'get_match_number'):
                match_number = self.editor.get_match_number(text, case=case,
                                                            regexp=regexp)
            else:
                match_number = 0
            self.change_number_matches(current_match=match_number,
                                       total_matches=number_matches)
            return found
1365100
function find(test, paths, callback, one) {
  var state = {
    broken: false,
    checked: [],
    test: augment(test)
  }

  if (!callback) {
    callback = paths
    paths = [process.cwd()]
  } else if (typeof paths === 'string') {
    paths = [paths]
  }

  return visitAll(state, paths, null, one, done)

  function done(result) {
    callback(null, one ? result[0] || null : result)
  }
}
557023
function find(selector) {
  var arr = [], $ = this.air, slice = this.slice;
  this.each(function(el) {
    arr = arr.concat(slice.call($(selector, el).dom));
  });
  return $(arr);
}
136242
def find(self, func: Callable[[K, T], bool]) -> TOption[T]:
        
        for k, v in self.items():
            if func(k, v):
                return TOption(v)
        return TOption(None)
655204
function find(requestObj, callback) {
            var i, found, storedData, property, storage;

            storage = this;
            callback = callback || function(){};

            if (typeof requestObj === 'undefined' || requestObj === null) {
                callback(null);
                return this;
            }

			for (i = 0; i < storage.preprocessors.length; i++) {
                requestObj.data = storage.preprocessors[i](requestObj.data, requestObj);
            }

            requestObj.config = {};
            requestObj.config.url = requestObj.config.url || this.url.find;
            requestObj.config.type = requestObj.config.type || this.constructor.REQUEST_TYPE_GET;

            this.constructor._sendRequest(requestObj, function(data){
                for (i = 0; i < storage.processors.length; i++) {
                    data = storage.processors[i](data, requestObj);
                }
                callback(data);
            });

            return this;
        }
906140
function find(obj, node, parent) {
  if (!obj) return;
  var result;

  var types = Object.keys(obj);
  for (var i = 0; i < types.length; i++) {
    var type = types[i];

    if (t.is(type, node)) {
      var fn = obj[type];
      result = fn(node, parent);
      if (result != null) break;
    }
  }

  return result;
}
1235189
function find(arr, check) {
  // use native find if supported
  if (Array.prototype.find) {
    return arr.find(check);
  }

  // use `filter` to obtain the same behavior of `find`
  return arr.filter(check)[0];
}
538690
function find(param) {
  var fn
    , asInt = Number(param);

  fn = isNaN(asInt) ? findBySlug : findById;
  fn.apply(null, arguments);
}
1131766
function _find( items, id ) {
        for ( var i=0; i < items.length; i++ ) {
            if (items[i].id == id) return i;
        }
    }
630983
function indexer ( str, find ) {
    return ( str.indexOf( find ) > 0 ) ? str.indexOf( find ) : false;
  }
1138399
def seekset_ng(func):
    """"""
    @functools.wraps(func)
    def seekcur(file, *args, seekset=os.SEEK_SET, **kw):
        # seek_cur = file.tell()
        file.seek(seekset, os.SEEK_SET)
        return_ = func(file, *args, seekset=seekset, **kw)
        # file.seek(seek_cur, os.SEEK_SET)
        return return_
    return seekcur
983255
function find(requestObj, callback) {
            var found, storedData, property;

            var storage = this;
            
            callback = callback || function defaultGetCallback() {
                //nothing here maybe put error notification
            };
            
			for (i = 0; i < storage.preprocessors.length; i++) {
                requestObj.data = storage.preprocessors[i](requestObj.data, requestObj);
            }

            if ((typeof requestObj) === 'undefined' || requestObj === null) {
               callback(null);
               return this;
            }
            
            found      = [];
            storedData = this.storage;

            Object.keys(storedData).forEach(function (property) {
                found.push(storedData[property]);
            });

            var data = found; 
            
            for (i = 0; i < storage.processors.length; i++) {
                data = storage.processors[i](data, requestObj);
            }
            callback(data);
            
            return this;
        }
1260952
def do_find(lookup, term):
    """"""

    space = defaultdict(list)

    for name in lookup.keys():
        space[name].append(name)

    try:
        iter_lookup = lookup.iteritems()  # Python 2
    except AttributeError:
        iter_lookup = lookup.items()  # Python 3

    for name, definition in iter_lookup:
        for keyword in definition['keywords']:
            space[keyword].append(name)
        space[definition['category']].append(name)

    matches = fnmatch.filter(space.keys(), term)

    results = set()
    for match in matches:
        results.update(space[match])

    return [(r, translate(lookup, r)) for r in results]
827173
function(arr, property, value) {
      return _.find(arr, function(item) {
        return (item[property] === value);
      });
    }
1047269
def find(self, *args, **kwargs):
        
        # print(f"database.collection: '{self.database.name}.{self.collection.name}'")
        self.print_cursor(self.collection.find(*args, **kwargs))
1228647
def do_search(self, string):
        """"""
        results = self.n.doSearch(string, full_path = self.current_path)

        if results:
            for r in results:
                self.stdout.write("%s\n" % r['path'])
754871
function createFind(findIndexFunc) {
      return function(collection, predicate, fromIndex) {
        var iterable = Object(collection);
        if (!isArrayLike(collection)) {
          var iteratee = getIteratee(predicate, 3);
          collection = keys(collection);
          predicate = function(key) { return iteratee(iterable[key], key, iterable); };
        }
        var index = findIndexFunc(collection, predicate, fromIndex);
        return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined$1;
      };
    }