code: def get(self, byte_sig: str, online_timeout: int = 2) -> List[str]:
          
  
          byte_sig = self._normalize_byte_sig(byte_sig)
  
          # check if we have any Solidity signatures to look up
          text_sigs = self.solidity_sigs.get(byte_sig)
          if text_sigs is not None:
              return text_sigs
  
          # try lookup in the local DB
          with SQLiteDB(self.path) as cur:
              cur.execute("SELECT text_sig FROM signatures WHERE byte_sig=?", (byte_sig,))
              text_sigs = cur.fetchall()
  
          if text_sigs:
              return [t[0] for t in text_sigs]
  
          # abort if we're not allowed to check 4byte or we already missed
          # the signature, or we're on a timeout
          if (
              not self.enable_online_lookup
              or byte_sig in self.online_lookup_miss
              or time.time() < self.online_lookup_timeout
          ):
              return []
  
          try:
              text_sigs = self.lookup_online(byte_sig=byte_sig, timeout=online_timeout)
              if not text_sigs:
                  self.online_lookup_miss.add(byte_sig)
                  return []
              else:
                  for resolved in text_sigs:
                      self.add(byte_sig, resolved)
                  return text_sigs
          except FourByteDirectoryOnlineLookupError as fbdole:
              # wait at least 2 mins to try again
              self.online_lookup_timeout = int(time.time()) + 2 * 60
              log.warning("Online lookup failed, not retrying for 2min: %s", fbdole)
              return []
docs: Get a function text signature for a byte signature 1) try local
          cache 2) try online lookup (if enabled; if not flagged as unavailable)
  
          :param byte_sig: function signature hash as hexstr
          :param online_timeout: online lookup timeout
          :return: list of matching function text signatures