code: def partition_read(
          self,
          table,
          columns,
          keyset,
          index="",
          partition_size_bytes=None,
          max_partitions=None,
      ):
          
          if not self._multi_use:
              raise ValueError("Cannot use single-use snapshot.")
  
          if self._transaction_id is None:
              raise ValueError("Transaction not started.")
  
          database = self._session._database
          api = database.spanner_api
          metadata = _metadata_with_prefix(database.name)
          transaction = self._make_txn_selector()
          partition_options = PartitionOptions(
              partition_size_bytes=partition_size_bytes, max_partitions=max_partitions
          )
  
          response = api.partition_read(
              session=self._session.name,
              table=table,
              columns=columns,
              key_set=keyset._to_pb(),
              transaction=transaction,
              index=index,
              partition_options=partition_options,
              metadata=metadata,
          )
  
          return [partition.partition_token for partition in response.partitions]
docs: Perform a ``ParitionRead`` API request for rows in a table.
  
          :type table: str
          :param table: name of the table from which to fetch data
  
          :type columns: list of str
          :param columns: names of columns to be retrieved
  
          :type keyset: :class:`~google.cloud.spanner_v1.keyset.KeySet`
          :param keyset: keys / ranges identifying rows to be retrieved
  
          :type index: str
          :param index: (Optional) name of index to use, rather than the
                        table's primary key
  
          :type partition_size_bytes: int
          :param partition_size_bytes:
              (Optional) desired size for each partition generated.  The service
              uses this as a hint, the actual partition size may differ.
  
          :type max_partitions: int
          :param max_partitions:
              (Optional) desired maximum number of partitions generated. The
              service uses this as a hint, the actual number of partitions may
              differ.
  
          :rtype: iterable of bytes
          :returns: a sequence of partition tokens
  
          :raises ValueError:
              for single-use snapshots, or if a transaction ID is
              already associtated with the snapshot.