code: def subscribe(self,
                    exchange_name: str,
                    routing: str,
                    exchange_type: ExchangeType_ = 'topic',
                    on_message: EVENT_CALLBACK_ = None
                    ) -> EventSubscription:
          
          sub = EventSubscription(
              exchange_name,
              routing,
              exchange_type,
              on_message=on_message
          )
  
          if self._pending is not None:
              self._pending.put_nowait(sub)
          else:
              self._pending_pre_async.append(sub)
              LOGGER.info(f'Deferred event bus subscription: [{sub}]')
  
          self._lazy_listen()
          return sub
docs: Adds a new event subscription to the listener.
  
          Actual queue declaration to the remote message server is done when connected.
          If the listener is not currently connected, it defers declaration.
  
          All existing subscriptions are redeclared on the remote if `EventListener`
          loses and recreates the connection.
  
          Args:
              exchange_name (str):
                  Name of the AMQP exchange. Messages are always published to a specific exchange.
  
              routing (str):
                  Filter messages passing through the exchange.
                  A routing key is a '.'-separated string, and accepts '#' and '*' wildcards.
  
              exchange_type (ExchangeType_, optional):
                  If the exchange does not yet exist, it will be created with this type.
                  Default is `topic`, acceptable values are `topic`, `fanout`, or `direct`.
  
              on_message (EVENT_CALLBACK_, optional):
                  The function to be called when a new message is received.
                  If `on_message` is none, it will default to logging the message.
  
          Returns:
              EventSubscription:
                  The newly created subscription.
                  This value can safely be discarded: EventListener keeps its own reference.