code: def whichdb(filename):
      """Guess which db package to use to open a db file.
  
      Return values:
  
      - None if the database file can't be read;
      - empty string if the file can be read but can't be recognized
      - the name of the dbm submodule (e.g. "ndbm" or "gnu") if recognized.
  
      Importing the given module may still fail, and opening the
      database using that module may still fail.
      """
  
      # Check for ndbm first -- this has a .pag and a .dir file
      filename = os.fsencode(filename)
      try:
          f = io.open(filename + b".pag", "rb")
          f.close()
          f = io.open(filename + b".dir", "rb")
          f.close()
          return "dbm.ndbm"
      except OSError:
          # some dbm emulations based on Berkeley DB generate a .db file
          # some do not, but they should be caught by the bsd checks
          try:
              f = io.open(filename + b".db", "rb")
              f.close()
              # guarantee we can actually open the file using dbm
              # kind of overkill, but since we are dealing with emulations
              # it seems like a prudent step
              if ndbm is not None:
                  d = ndbm.open(filename)
                  d.close()
                  return "dbm.ndbm"
          except OSError:
              pass
  
      # Check for dumbdbm next -- this has a .dir and a .dat file
      try:
          # First check for presence of files
          os.stat(filename + b".dat")
          size = os.stat(filename + b".dir").st_size
          # dumbdbm files with no keys are empty
          if size == 0:
              return "dbm.dumb"
          f = io.open(filename + b".dir", "rb")
          try:
              if f.read(1) in (b"'", b'"'):
                  return "dbm.dumb"
          finally:
              f.close()
      except OSError:
          pass
  
      # See if the file exists, return None if not
      try:
          f = io.open(filename, "rb")
      except OSError:
          return None
  
      with f:
          # Read the start of the file -- the magic number
          s16 = f.read(16)
      s = s16[0:4]
  
      # Return "" if not at least 4 bytes
      if len(s) != 4:
          return ""
  
      # Convert to 4-byte int in native byte order -- return "" if impossible
      try:
          (magic,) = struct.unpack("=l", s)
      except struct.error:
          return ""
  
      # Check for GNU dbm
      if magic in (0x13579ACE, 0x13579ACD, 0x13579ACF):
          return "dbm.gnu"
  
      # Later versions of Berkeley db hash file have a 12-byte pad in
      # front of the file type
      try:
          (magic,) = struct.unpack("=l", s16[-4:])
      except struct.error:
          return ""
  
      # Unknown
      return ""
  
file_path: catboost/contrib/tools/python3/src/Lib/dbm/__init__.py
imports: import io
  import os
  import struct
  import sys
label_desc: Use image node_id 2 for calling a global function with example usage: whichdb(filename) and returns: str, str, str, str, str, None, str, str, str, str