code: def signatures(ambiguous_word: str, pos: str = None, hyperhypo=True, adapted=False,
                 remove_stopwords=True, to_lemmatize=True, remove_numbers=True,
                 lowercase=True, to_stem=False, original_lesk=False, from_cache=True) -> dict:
      
  
      # Ensure that the POS is supported.
      pos = pos if pos in ['a', 'r', 's', 'n', 'v', None] else None
  
      # If the POS specified isn't found but other POS is in wordnet.
      if not wn.synsets(ambiguous_word, pos) and wn.synsets(ambiguous_word):
          pos = None
  
      # Holds the synset->signature dictionary.
      ss_sign = {}
      for ss in wn.synsets(ambiguous_word, pos):
          ss_sign[ss] = synset_signatures(ss, hyperhypo=hyperhypo,
                                          adapted=adapted,
                                          remove_stopwords=remove_stopwords,
                                          to_lemmatize=to_lemmatize,
                                          remove_numbers=remove_numbers,
                                          lowercase=lowercase,
                                          original_lesk=original_lesk,
                                          from_cache=from_cache)
  
      # Matching exact words may cause sparsity, so optional matching for stems.
      # Not advisible to use thus left out of the synsets_signatures()
      if to_stem == True:
          ss_sign = {ss:[porter.stem(s) for s in signature]
                     for ss, signature in ss_sign.items()}
  
      return ss_sign
docs: Takes an ambiguous word and optionally its Part-Of-Speech and returns
      a dictionary where keys are the synsets and values are sets of signatures.
  
      :param ambiguous_word: String, a single word.
      :param pos: String, one of 'a', 'r', 's', 'n', 'v', or None.
      :return: dict(synset:{signatures}).