code: def dflt_interval(self, cd_id: str) -> (int, int):
          
  
          LOGGER.debug('RevocationCache.dflt_interval >>>')
  
          fro = None
          to = None
  
          for rr_id in self:
              if cd_id != rev_reg_id2cred_def_id(rr_id):
                  continue
              entry = self[rr_id]
              if entry.rr_delta_frames:
                  to = max(entry.rr_delta_frames, key=lambda f: f.to).to
                  fro = min(fro or to, to)
  
          if not (fro and to):
              LOGGER.debug(
                  'RevocationCache.dflt_interval <!< No data for default non-revoc interval on cred def id %s',
                  cd_id)
              raise CacheIndex('No data for default non-revoc interval on cred def id {}'.format(cd_id))
  
          rv = (fro, to)
          LOGGER.debug('RevocationCache.dflt_interval <<< %s', rv)
          return rv
docs: Return default non-revocation interval from latest 'to' times on delta frames
          of revocation cache entries on indices stemming from input cred def id.
  
          Compute the 'from'/'to' values as the earliest/latest 'to' values of all
          cached delta frames on all rev reg ids stemming from the input cred def id.
  
          E.g., on frames for
              rev-reg-0: -[xx]---[xxxx]-[x]---[xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx]--> time
              rev-reg-1: ----------------------[xxxx]----[xxx]---[xxxxxxxxxxxxxxxxxxxx]---------> time
              rev-reg-2: -------------------------------------------[xx]-----[xxxx]-----[xxxxx]-> time
              rev-reg-3: -----------------------------------------------------------[xxxxxxxx]--> time
  
          return the most recent interval covering all matching revocation registries in the cache; i.e.,:
              interval:  -------------------------------------------------------------[*******]-> time
  
          Raise CacheIndex if there are no matching entries.
  
          :param cd_id: cred def identifier to match
          :return: default non-revocation interval as 2-tuple (fro, to)