def test_split_read_stream(self): # Setup Expected Response expected_response = {} expected_response = storage_pb2.SplitReadStreamResponse(**expected_response) # Mock the API response channel = ChannelStub(responses=[expected_response]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = big_query_storage_client.BigQueryStorageClient() # Setup Request original_stream = {} response = client.split_read_stream(original_stream) assert expected_response == response assert len(channel.requests) == 1 expected_request = storage_pb2.SplitReadStreamRequest( original_stream=original_stream ) actual_request = channel.requests[0][1] assert expected_request == actual_request
def split_read_stream( self, original_stream, fraction=None, retry=google.api_core.gapic_v1.method.DEFAULT, timeout=google.api_core.gapic_v1.method.DEFAULT, metadata=None, ): """ Splits a given read stream into two Streams. These streams are referred to as the primary and the residual of the split. The original stream can still be read from in the same manner as before. Both of the returned streams can also be read from, and the total rows return by both child streams will be the same as the rows read from the original stream. Moreover, the two child streams will be allocated back to back in the original Stream. Concretely, it is guaranteed that for streams Original, Primary, and Residual, that Original[0-j] = Primary[0-j] and Original[j-n] = Residual[0-m] once the streams have been read to completion. This method is guaranteed to be idempotent. Example: >>> from google.cloud import bigquery_storage_v1beta1 >>> >>> client = bigquery_storage_v1beta1.BigQueryStorageClient() >>> >>> # TODO: Initialize `original_stream`: >>> original_stream = {} >>> >>> response = client.split_read_stream(original_stream) Args: original_stream (Union[dict, ~google.cloud.bigquery_storage_v1beta1.types.Stream]): Stream to split. If a dict is provided, it must be of the same form as the protobuf message :class:`~google.cloud.bigquery_storage_v1beta1.types.Stream` fraction (float): A value in the range (0.0, 1.0) that specifies the fractional point at which the original stream should be split. The actual split point is evaluated on pre-filtered rows, so if a filter is provided, then there is no guarantee that the division of the rows between the new child streams will be proportional to this fractional value. Additionally, because the server-side unit for assigning data is collections of rows, this fraction will always map to to a data storage boundary on the server side. retry (Optional[google.api_core.retry.Retry]): A retry object used to retry requests. If ``None`` is specified, requests will be retried using a default configuration. timeout (Optional[float]): The amount of time, in seconds, to wait for the request to complete. Note that if ``retry`` is specified, the timeout applies to each individual attempt. metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata that is provided to the method. Returns: A :class:`~google.cloud.bigquery_storage_v1beta1.types.SplitReadStreamResponse` instance. Raises: google.api_core.exceptions.GoogleAPICallError: If the request failed for any reason. google.api_core.exceptions.RetryError: If the request failed due to a retryable error and retry attempts failed. ValueError: If the parameters are invalid. """ # Wrap the transport method to add retry and timeout logic. if "split_read_stream" not in self._inner_api_calls: self._inner_api_calls[ "split_read_stream" ] = google.api_core.gapic_v1.method.wrap_method( self.transport.split_read_stream, default_retry=self._method_configs["SplitReadStream"].retry, default_timeout=self._method_configs["SplitReadStream"].timeout, client_info=self._client_info, ) request = storage_pb2.SplitReadStreamRequest( original_stream=original_stream, fraction=fraction ) if metadata is None: metadata = [] metadata = list(metadata) try: routing_header = [("original_stream.name", original_stream.name)] except AttributeError: pass else: routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( routing_header ) metadata.append(routing_metadata) # pragma: no cover return self._inner_api_calls["split_read_stream"]( request, retry=retry, timeout=timeout, metadata=metadata )