GET /api/entries/{entry}.{_format}

        Retrieve a single entry

        :param entry: \w+ an integer The Entry ID
        :return data related to the ext
190268
async def get_entry(self, entry):
        
        params = {'access_token': self.token}
        url = '/api/entries/{entry}.{ext}'.format(entry=entry,
                                                  ext=self.format)
        return await self.query(url, "get", **params)
164335
def get(self, entry):
        """"""
        try:
            list = self.cache[entry.key]
            return list[list.index(entry)]
        except:
            return None
1300430
def get(self, id):
        """"""
        params = {'q': 'id:%s' % str(id), 'wt': 'python'}
        request = urllib.parse.urlencode(params, doseq=True)
        data = None
        try:
            rsp = self.doPost(self.solrBase + '', request, self.formheaders)
            data = eval(rsp.read())
        except Exception:
            pass
        if data['response']['numFound'] > 0:
            return data['response']['docs'][0]
        return None
329284
def __get_value(self, bundleId, languageId, resourceKey, fallback=False):
        
        resourceEntryData = self.__get_resource_entry_data(bundleId=bundleId,
            languageId=languageId, resourceKey=resourceKey, fallback=fallback)

        if not resourceEntryData:
            return None

        value = resourceEntryData.get(self.__RESPONSE_TRANSLATION_KEY)

        return value
126650
def get_entry(self, key, column=None, table=None):
        """"""
        if table is None:  table  = self.main_table
        if column is None: column = "id"
        if isinstance(key, basestring): key = key.replace("'","''")
        query = 'SELECT * from "%s" where "%s"=="%s" LIMIT 1;'
        query = query % (table, column, key)
        self.own_cursor.execute(query)
        return self.own_cursor.fetchone()
970194
def _cache_get_entry(self, entry_name, key=ENTIRE_ENTRY_KEY, default=False):
        
        if key is self.ENTIRE_ENTRY_KEY:
            return self._cache[entry_name]
        return self._cache[entry_name].get(key, default)
471020
def get(content, keep_order=False):
        """"""
        if keep_order:
            from collections import OrderedDict
            dataentry = OrderedDict()
        else:
            dataentry = {}

        found = False
        for line in content.split('\n'):
            if line.strip().startswith('---- dataentry'):
                found = True
                continue
            elif line == '----':
                break
            elif not found:
                continue

            line_split = line.split(':')
            key = line_split[0].strip()
            value = re.sub('#.*$', '', ':'.join(line_split[1:])).strip()
            dataentry.setdefault(key, value)

        if not found:
            raise DokuWikiError('no dataentry found')
        return dataentry
21972
public static Entry getEntry(byte[] source, byte[] destination) {
        CaseInsensitiveBytesHash<Entry> sHash = transcoders.get(source);
        return sHash == null ? null : sHash.get(destination);
    }
1052527
def get_entry(self, entry_id):
        

        if entry_id in self._entries:
            return self._entries[entry_id]
        else:
            entry_offset = entry_id * self.entry_size

            # load entry
            entry = MftEntry(
                filename=self.filename,
                offset=self.offset + entry_offset,
                length=self.entry_size,
                index=entry_id
            )

            # cache entry
            self._entries[entry_id] = entry

            return entry
845353
public FormEntry getFormEntry(final String entryKey, final int index) {
		return getFormEntry(entryKey + JFunkConstants.INDEXED_KEY_SEPARATOR + index);
	}
497765
def encode(cls, entry):
        
        (data, info) = entry
        if info['mime_type'] in cls.utf8_mime_types:
            return data.encode('utf-8')
        else:
            return data
1128148
def get_client_entry(self, client_entry_name):
        """"""
        request_url = self._build_url(['ClientEntry', client_entry_name])
        return self._do_request('GET', request_url)
174978
def get_entry(journal_location, date):
    
    if not isinstance(date, datetime.date):
        return None
    try:
        with open(build_journal_path(journal_location, date), "r") as entry_file:
            return entry_file.read()
    except IOError:
        return None
442282
def get_entries(self, acc: Account, cls=AccountEntry) -> QuerySet:
        
        return cls.objects.filter(Q(account=acc) & (Q(source_invoice=self) | Q(settled_invoice=self))) if acc else cls.objects.none()
386817
Entry get(String uuid)
   {
      LRUMap cacheSegment = docNumbers[getSegmentIndex(uuid.charAt(0))];
      // uuid may be invalid
      //        if (uuid.length() != UUID.UUID_FORMATTED_LENGTH) {
      //            return null;
      //        }
      String key = uuid;
      Entry entry;
      synchronized (cacheSegment)
      {
         entry = (Entry)cacheSegment.get(key);
      }
      if (log.isDebugEnabled())
      {
         accesses++;
         if (entry == null)
         {
            misses++;
         }
         // log at most after 1000 accesses and every 10 seconds
         if (accesses > 1000 && System.currentTimeMillis() - lastLog > LOG_INTERVAL)
         {
            long ratio = 100;
            if (misses != 0)
            {
               ratio -= misses * 100L / accesses;
            }
            StringBuilder statistics = new StringBuilder();
            int inUse = 0;
            for (int i = 0; i < docNumbers.length; i++)
            {
               inUse += docNumbers[i].size();
            }
            statistics.append("size=").append(inUse);
            statistics.append("/").append(docNumbers[0].maxSize() * CACHE_SEGMENTS);
            statistics.append(", #accesses=").append(accesses);
            statistics.append(", #hits=").append((accesses - misses));
            statistics.append(", #misses=").append(misses);
            statistics.append(", cacheRatio=").append(ratio).append("%");
            log.debug(statistics.toString());
            accesses = 0;
            misses = 0;
            lastLog = System.currentTimeMillis();
         }
      }
      return entry;
   }
594696
def __retrieve(self, key):
        ''' 
        '''
        with self.get_conn() as conn:
            try:
                c = conn.cursor()
                if key is None:
                    c.execute("SELECT value FROM cache_entries WHERE key IS NULL")
                else:
                    c.execute("SELECT value FROM cache_entries WHERE key = ?", (key,))
                result = c.fetchone()
                if result is None or len(result) != 1:
                    getLogger().info("There's no entry with key={key}".format(key=key))
                    return None
                else:
                    return result[0]
            except:
                getLogger().exception("Cannot retrieve")
                return None
1028170
def get_entry(key):
    
    if type(key) != str:
        raise TypeError("key must be str")
    if key not in _config:
        raise KeyError("Nonexistent entry '{key}'".format(key=key))
    return _config[key]