TODO: all others are 'typed', e.g. get_user, get_record_items ... should this be typed, too ?
5255
def search(request, *args)
      request = request.is_a?(Search::Request) ? request : Search::Request.new(request)
      self.class::Search.new(self).call(request, *args)
    end
1111539
def _load_records(self, record_type_idstrs):
        """"""
        for record_type_idstr in record_type_idstrs:
            try:
                self._init_record(record_type_idstr)
            except (ImportError, KeyError):
                pass
982007
def record_type(self, column=None, value=None, **kwargs):
        
        return self._resolve_call('GIC_RECORD_TYPE', column, value, **kwargs)
675342
def findRecordItem(self, record, parent=None):
        
        try:
            item = self._recordMapping[record]()
        except KeyError:
            return None
        
        if item is None:
            self._recordMapping.pop(record)
        
        return item
481120
def isRecordidField?( fid )
      fields = lookupFieldsByType( "recordid" )
      (fields and fields.last and fields.last.attributes[ "id" ] == fid)
   end
1161378
def _filter_records(self, records, rtype=None, name=None, content=None, identifier=None):  # pylint: disable=too-many-arguments,no-self-use
        
        if not records:
            return []
        if identifier is not None:
            LOGGER.debug('Filtering %d records by id: %s', len(records), identifier)
            records = [record for record in records if record['id'] == identifier]
        if rtype is not None:
            LOGGER.debug('Filtering %d records by type: %s', len(records), rtype)
            records = [record for record in records if record['type'] == rtype]
        if name is not None:
            LOGGER.debug('Filtering %d records by name: %s', len(records), name)
            if name.endswith('.'):
                name = name[:-1]
            records = [record for record in records if name == record['name']]
        if content is not None:
            LOGGER.debug('Filtering %d records by content: %s', len(records), content.lower())
            records = [record for record in records if
                       record['content'].lower() == content.lower()]
        return records
322602
def data_items(self) -> typing.List[DataItem]:
        
        return [DataItem(data_item) for data_item in self.__document_model.data_items]
925362
def _init_records(self, record_types):
        """"""
        for record_type in record_types:
            # This conditional was inserted on 7/11/14. It may prove problematic:
            if str(record_type) not in self._my_map['recordTypeIds']:
                record_initialized = self._init_record(str(record_type))
                if record_initialized:
                    self._my_map['recordTypeIds'].append(str(record_type))
1340764
def _record_key(record: Record) -> List[Tuple[Column, str]]:
    ""
    return sorted(record.items())
78887
function retrieveRecords(rType, source) {
  return function(options, callback) {
    var q = {
      _source : source,
      size : hitSize,
      "query": {
        "filtered": {
          "query": {
            "bool": {
              "must": [
                {
                  query_string: {
                    query: 'member:' + (options.member ? '"' + options.member + '"' : '*')
                  }
                }
              ]
            }
          }
        }
      }
    };

    getEs().search({ _index : GLOBAL.config.ESEARCH._index, _type : rType}, q, function(err, res) {
      callback(err, res);
    });
  };
}
766267
def get_record(self, dns_record_type, host):
        """"""
        record_list = self._entries
        for record in record_list:
            if record._record_type == dns_record_type \
                    and record.host == host:
                return record
        return False
1198837
def LookupWithType(self, user_str):
        
        prefix = 'template '
        ref = None  # fail the lookup by default
        if user_str.startswith(prefix):
            name = user_str[len(prefix):]
            if name == 'SELF':
                # we can resolve this right away
                ref = _TemplateRef(template=self.owner)  # special value
            else:
                ref = _TemplateRef(name)
        
        return ref, (), TEMPLATE_FORMATTER
328411
def _from_list_record(data):
    
    return [Schema._get_field_entry('Column%d' % (i + 1), value) for i, value in enumerate(data)]
1031732
def arecord_user_action_on_item(action, uid, iid, optional = {})
      optional['targetEntityType'] = 'item'
      optional['targetEntityId'] = iid
      acreate_event(action, 'user', uid, optional)
    end
119216
def list(self, domain_id, sub_domain=None):
        '''
        '''
        optional_args = {}
        if sub_domain != None:
            optional_args['sub_domain'] = sub_domain
        r = self._api.do_post('Record.List', domain_id=domain_id,
                              **optional_args)
        record_list = []
        for record in r['records']:
            record['domain_id'] = domain_id
            record_list.append(Record(record))
        return record_list
712719
private boolean isInRecord(String[] strClassNames, int iClassIndex, String strRecordClass)
    {
        boolean bIsInRecord = false;
        for (int i = 0; i <= iClassIndex; i++)
        {
            if (strClassNames[i].equalsIgnoreCase(strRecordClass))
                bIsInRecord = true;   // True, it IS in the record
        }
        return bIsInRecord;    // It is in the record?
    }
1238935
def to_record_per_alt(self):
        ''''''
        record_list = []
        for alt in self.ALT:
            record_list.append(copy.copy(self))
            record_list[-1].ALT = [alt]
        return record_list