How to use the osxphotos.utils._debug function in osxphotos

def get_exiftool_path():
    """ return path of exiftool, cache result """
    result = subprocess.run(["which", "exiftool"], stdout=subprocess.PIPE)
    exiftool_path = result.stdout.decode("utf-8")
    if _debug():
        logging.debug("exiftool path = %s" % (exiftool_path))
    if exiftool_path:
        return exiftool_path.rstrip()
    else:
        raise FileNotFoundError(
            "Could not find exiftool. Please download and install from "
            "https://exiftool.org/"

if not (hasattr(self, "_process") and self._process):
            raise ValueError("exiftool process is not running")

        if not commands:
            raise TypeError("must provide one or more command to run")

        filename = os.fsencode(self.file) if not no_file else b""
        command_str = (
            b"\n".join([c.encode("utf-8") for c in commands])
            + b"\n"
            + filename
            + b"\n"
            + b"-execute\n"
        )

        if _debug():
            logging.debug(command_str)

        # send the command
        self._process.stdin.write(command_str)
        self._process.stdin.flush()

        # read the output
        output = b""
        while EXIFTOOL_STAYOPEN_EOF not in str(output):
            output += self._process.stdout.readline().strip()
        return output[:-EXIFTOOL_STAYOPEN_EOF_LEN]

try:
            _db_searchinfo_categories[category].append(record["normalized_string"])
        except KeyError:
            _db_searchinfo_categories[category] = [record["normalized_string"]]

        if category == SEARCH_CATEGORY_LABEL:
            label = record["content_string"]
            label_norm = record["normalized_string"]
            try:
                _db_searchinfo_labels[label].append(uuid)
                _db_searchinfo_labels_normalized[label_norm].append(uuid)
            except KeyError:
                _db_searchinfo_labels[label] = [uuid]
                _db_searchinfo_labels_normalized[label_norm] = [uuid]

    if _debug():
        logging.debug(
            "_db_searchinfo_categories: \n" + pformat(self._db_searchinfo_categories)
        )
        logging.debug("_db_searchinfo_uuid: \n" + pformat(self._db_searchinfo_uuid))
        logging.debug("_db_searchinfo_labels: \n" + pformat(self._db_searchinfo_labels))
        logging.debug(
            "_db_searchinfo_labels_normalized: \n"
            + pformat(self._db_searchinfo_labels_normalized)
        )

# 1     RKVersion.uuid

        for face in c:
            pk = face[0]
            uuid = face[1]
            try:
                self._dbfaces_uuid[uuid].append(pk)
            except KeyError:
                self._dbfaces_uuid[uuid] = [pk]

            try:
                self._dbfaces_pk[pk].append(uuid)
            except KeyError:
                self._dbfaces_pk[pk] = [uuid]

        if _debug():
            logging.debug(f"Finished walking through persons")
            logging.debug(pformat(self._dbpersons_pk))
            logging.debug(pformat(self._dbpersons_fullname))
            logging.debug(pformat(self._dbfaces_pk))
            logging.debug(pformat(self._dbfaces_uuid))

        # Get info on albums
        c.execute(
            """ SELECT 
                RKAlbum.uuid, 
                RKVersion.uuid,
                RKCustomSortOrder.orderNumber
                FROM RKVersion
                JOIN RKCustomSortOrder on RKCustomSortOrder.objectUuid = RKVersion.uuid
                JOIN RKAlbum on RKAlbum.uuid = RKCustomSortOrder.containerUuid
            """

# 1     ZGENERICASSET.ZUUID,

        for face in c:
            pk = face[0]
            uuid = face[1]
            try:
                self._dbfaces_uuid[uuid].append(pk)
            except KeyError:
                self._dbfaces_uuid[uuid] = [pk]

            try:
                self._dbfaces_pk[pk].append(uuid)
            except KeyError:
                self._dbfaces_pk[pk] = [uuid]

        if _debug():
            logging.debug(f"Finished walking through persons")
            logging.debug(pformat(self._dbpersons_pk))
            logging.debug(pformat(self._dbpersons_fullname))
            logging.debug(pformat(self._dbfaces_pk))
            logging.debug(pformat(self._dbfaces_uuid))

        # get details about albums
        c.execute(
            """ SELECT 
                ZGENERICALBUM.ZUUID, 
                ZGENERICASSET.ZUUID,
                Z_26ASSETS.Z_FOK_34ASSETS
                FROM ZGENERICASSET 
                JOIN Z_26ASSETS ON Z_26ASSETS.Z_34ASSETS = ZGENERICASSET.Z_PK 
                JOIN ZGENERICALBUM ON ZGENERICALBUM.Z_PK = Z_26ASSETS.Z_26ALBUMS
            """

# e.g. {'0C514A98-7B77-4E4F-801B-364B7B65EAFA': ['92D68107-B6C7-453B-96D2-97B0F26D5B8B'],}
        self._dbalbum_parent_folders = {}

        # Dict with information about folder hierarchy for each album / folder
        # key is uuid of album / folder, value is dict with uuid of descendant folder / album
        # structure is recursive as a descendant may itself have descendants
        # e.g. {'AA4145F5-098C-496E-9197-B7584958FF9B': {'99D24D3E-59E7-465F-B386-A48A94B00BC1': {'F2246D82-1A12-4994-9654-3DC6FE38A7A8': None}}, }
        self._dbalbum_folders = {}

        # Dict with information about folders
        self._dbfolder_details = {}

        # Will hold the primary key of root folder
        self._folder_root_pk = None

        if _debug():
            logging.debug(f"dbfile = {dbfile}")

        # get the path to photos library database
        if dbfile_:
            # got a library path as argument
            if dbfile:
                # shouldn't pass via both *args and dbfile=
                raise TypeError(
                    f"photos database path must be specified as argument or "
                    f"named parameter dbfile but not both: args: {dbfile_}, dbfile: {dbfile}",
                    dbfile_,
                    dbfile,
                )
            elif len(dbfile_) == 1:
                dbfile = dbfile_[0]
            else: