docstr: Returns parsed `word` and `status` (bool: False if word wasn't handled, True otherwise).
          
docstr_tok: ["Returns","parsed","`","word","`","and","`","status","`","(","bool",":","False","if","word","was","n't","handled",",","True","otherwise",")","."]
code: def parse_one_word(self, word: str) -> Tuple[List[str], bool]:
      """Returns parsed `word` and `status` (bool: False if word wasn't handled, True otherwise)."""
      word = set_grapheme_case(word, case=self.grapheme_case)
  
      # Punctuation (assumes other chars have been stripped)
      if self.CHAR_REGEX.search(word) is None:
          return list(word), True
  
      # Keep graphemes of a word with a probability.
      if (
          self.phoneme_probability is not None
          and self._rng.random() > self.phoneme_probability
      ):
          return self._prepend_prefix_for_one_word(word), True
  
      # Heteronyms
      if self.heteronyms and word in self.heteronyms:
          return self._prepend_prefix_for_one_word(word), True
  
      # special cases for en-US when transliterating a word into a list of phonemes.
      # TODO @xueyang: add special cases for any other languages upon new findings.
      if self.locale == "en-US":
          # `'s` suffix (with apostrophe) - not in phoneme dict
          if len(word) > 2 and (
              word.endswith("'s") or word.endswith("'S")
          ):
              word_found = None
              if (word not in self.phoneme_dict) and (
                  word.upper() not in self.phoneme_dict
              ):
                  if word[:-2] in self.phoneme_dict:
                      word_found = word[:-2]
                  elif word[:-2].upper() in self.phoneme_dict:
                      word_found = word[:-2].upper()
  
              if word_found is not None and (
                  not self.ignore_ambiguous_words
                  or self.is_unique_in_phoneme_dict(word_found)
              ):
                  if word_found[-1] in ["T", "t"]:
                      # for example, "airport's" doesn't exist in the dict while "airport" exists. So append a phoneme
                      # /s/ at the end of "airport"'s first pronunciation.
                      return (
                          self.phoneme_dict[word_found][0] + ["s"],
                          True,
                      )
                  elif word_found[-1] in ["S", "s"]:
                      # for example, "jones's" doesn't exist in the dict while "jones" exists. So append two phonemes,
                      # /ɪ/ and /z/ at the end of "jones"'s first pronunciation.
                      return (
                          self.phoneme_dict[word_found][0] + ["ɪ", "z"],
                          True,
                      )
                  else:
                      return (
                          self.phoneme_dict[word_found][0] + ["z"],
                          True,
                      )
  
          # `s` suffix (without apostrophe) - not in phoneme dict
          if len(word) > 1 and (
              word.endswith("s") or word.endswith("S")
          ):
              word_found = None
              if (word not in self.phoneme_dict) and (
                  word.upper() not in self.phoneme_dict
              ):
                  if word[:-1] in self.phoneme_dict:
                      word_found = word[:-1]
                  elif word[:-1].upper() in self.phoneme_dict:
                      word_found = word[:-1].upper()
  
              if word_found is not None and (
                  not self.ignore_ambiguous_words
                  or self.is_unique_in_phoneme_dict(word_found)
              ):
                  if word_found[-1] in ["T", "t"]:
                      # for example, "airports" doesn't exist in the dict while "airport" exists. So append a phoneme
                      # /s/ at the end of "airport"'s first pronunciation.
                      return (
                          self.phoneme_dict[word_found][0] + ["s"],
                          True,
                      )
                  else:
                      return (
                          self.phoneme_dict[word_found][0] + ["z"],
                          True,
                      )
  
      if self.locale == "fr-FR":
          # contracted prefix (with apostrophe) - not in phoneme dict
          contractions_g = [
              "l",
              "c",
              "d",
              "j",
              "m",
              "n",
              "qu",
              "s",
              "t",
              "puisqu",
              "lorsqu",
              "jusqu",
          ]
          contractions_p = [
              "l",
              "s",
              "d",
              "ʒ",
              "m",
              "n",
              "k",
              "s",
              "t",
              "pyisk",
              "loʁsk",
              "ʒysk",
          ]
  
          for cont_g, cont_p in zip(contractions_g, contractions_p):
              starter = cont_g + "'"
              if len(word) > 2 and (
                  word.startswith(starter)
                  or word.startswith(starter.upper())
              ):
                  word_found = None
                  if (word not in self.phoneme_dict) and (
                      word.upper() not in self.phoneme_dict
                  ):
                      start_index = len(starter)
                      if word[start_index:] in self.phoneme_dict:
                          word_found = word[start_index:]
                      elif (
                          word[start_index:].upper()
                          in self.phoneme_dict
                      ):
                          word_found = word[start_index:].upper()
  
                  if word_found is not None and (
                      not self.ignore_ambiguous_words
                      or self.is_unique_in_phoneme_dict(word_found)
                  ):
                      return [c for c in cont_p] + self.phoneme_dict[
                          word_found
                      ][0], True
  
      # For the words that have a single pronunciation, directly look it up in the phoneme_dict; for the
      # words that have multiple pronunciation variants, if we don't want to ignore them, then directly choose their
      # first pronunciation variant as the target phonemes.
      # TODO @xueyang: this is a temporary solution, but it is not optimal if always choosing the first pronunciation
      #  variant as the target if a word has multiple pronunciation variants. We need explore better approach to
      #  select its optimal pronunciation variant aligning with its reference audio.
      if word in self.phoneme_dict and (
          not self.ignore_ambiguous_words
          or self.is_unique_in_phoneme_dict(word)
      ):
          return self.phoneme_dict[word][0], True
  
      if (
          self.grapheme_case == GRAPHEME_CASE_MIXED
          and word not in self.phoneme_dict
          and word.upper() in self.phoneme_dict
      ):
          word = word.upper()
          if (
              not self.ignore_ambiguous_words
              or self.is_unique_in_phoneme_dict(word)
          ):
              return self.phoneme_dict[word][0], True
  
      if self.apply_to_oov_word is not None:
          return self.apply_to_oov_word(word), True
      else:
          return self._prepend_prefix_for_one_word(word), False
  
imports: import pathlib
  import random
  import re
  from collections import defaultdict
  from typing import Callable, Dict, List, Optional, Set, Tuple, Union
  from nemo.collections.common.tokenizers.text_to_speech.ipa_lexicon import validate_locale
  from nemo.collections.common.tokenizers.text_to_speech.tokenizer_utils import LATIN_CHARS_ALL, any_locale_word_tokenize, english_word_tokenize, normalize_unicode_text
  from nemo.collections.tts.g2p.models.base import BaseG2p
  from nemo.collections.tts.g2p.utils import GRAPHEME_CASE_MIXED, GRAPHEME_CASE_UPPER, set_grapheme_case
  from nemo.utils import logging
  from nemo.utils.decorators import experimental
label_desc: Use image node_id 9 for calling the IpaG2p obj's underlying member method code with example usage: obj.parse_one_word(word) and returns: list,  True, self,  True, self,  True, self,  True, self,  True, self,  False, self,  True, unknown,  True, unknown,  True, unknown,  True, unknown,  True, unknown,  True, unknown,  True