code: def stream(self, transaction=None):
          
          parent_path, expected_prefix = self._parent._parent_info()
          response_iterator = self._client._firestore_api.run_query(
              parent_path,
              self._to_protobuf(),
              transaction=_helpers.get_transaction_id(transaction),
              metadata=self._client._rpc_metadata,
          )
  
          for response in response_iterator:
              snapshot = _query_response_to_snapshot(
                  response, self._parent, expected_prefix
              )
              if snapshot is not None:
                  yield snapshot
docs: Read the documents in the collection that match this query.
  
          This sends a ``RunQuery`` RPC and then returns an iterator which
          consumes each document returned in the stream of ``RunQueryResponse``
          messages.
  
          .. note::
  
             The underlying stream of responses will time out after
             the ``max_rpc_timeout_millis`` value set in the GAPIC
             client configuration for the ``RunQuery`` API.  Snapshots
             not consumed from the iterator before that point will be lost.
  
          If a ``transaction`` is used and it already has write operations
          added, this method cannot be used (i.e. read-after-write is not
          allowed).
  
          Args:
              transaction (Optional[~.firestore_v1beta1.transaction.\
                  Transaction]): An existing transaction that this query will
                  run in.
  
          Yields:
              ~.firestore_v1beta1.document.DocumentSnapshot: The next
              document that fulfills the query.