docs: def transmit(self, what=None, to_whom=None):
          """Transmit one or more infos from one node to another.
  
          "what" dictates which infos are sent, it can be:
              (1) None (in which case the node's _what method is called).
              (2) an Info (in which case the node transmits the info)
              (3) a subclass of Info (in which case the node transmits all
                  its infos of that type)
              (4) a list of any combination of the above
          "to_whom" dictates which node(s) the infos are sent to, it can be:
              (1) None (in which case the node's _to_whom method is called)
              (2) a Node (in which case the node transmits to that node)
              (3) a subclass of Node (in which case the node transmits to all
                  nodes of that type it is connected to)
              (4) a list of any combination of the above
          Will additionally raise an error if:
              (1) _what() or _to_whom() returns None or a list containing None.
              (2) what is/contains an info that does not originate from the
                  transmitting node
              (3) to_whom is/contains a node that the transmitting node does not
                  have a not-failed connection with.
          """
          # make the list of what
          what = self.flatten([what])
          for i in range(len(what)):
              if what[i] is None:
                  what[i] = self._what()
              elif inspect.isclass(what[i]) and issubclass(what[i], Info):
                  what[i] = self.infos(type=what[i])
          what = self.flatten(what)
          for i in range(len(what)):
              if inspect.isclass(what[i]) and issubclass(what[i], Info):
                  what[i] = self.infos(type=what[i])
          what = list(set(self.flatten(what)))
  
          # make the list of to_whom
          to_whom = self.flatten([to_whom])
          for i in range(len(to_whom)):
              if to_whom[i] is None:
                  to_whom[i] = self._to_whom()
              elif inspect.isclass(to_whom[i]) and issubclass(to_whom[i], Node):
                  to_whom[i] = self.neighbors(direction="to", type=to_whom[i])
          to_whom = self.flatten(to_whom)
          for i in range(len(to_whom)):
              if inspect.isclass(to_whom[i]) and issubclass(to_whom[i], Node):
                  to_whom[i] = self.neighbors(direction="to", type=to_whom[i])
          to_whom = list(set(self.flatten(to_whom)))
  
          transmissions = []
          vectors = self.vectors(direction="outgoing")
          for w in what:
              for tw in to_whom:
                  try:
                      vector = [v for v in vectors
                                if v.destination_id == tw.id][0]
                  except:
                      raise ValueError(
                          "{} cannot transmit to {} as it does not have "
                          "a connection to them".format(self, tw))
                  t = Transmission(info=w, vector=vector)
                  transmissions.append(t)
          if len(transmissions) == 1:
              return transmissions[0]
          else:
              return transmissions