def _get_encryption_headers(key, source=False):
"""Builds customer encryption key headers
:type key: bytes
:param key: 32 byte key to build request key and hash.
:type source: bool
:param source: If true, return headers for the "source" blob; otherwise,
return headers for the "destination" blob.
:rtype: dict
:returns: dict of HTTP headers being sent in request.
"""
if key is None:
return {}
key = _to_bytes(key)
key_hash = hashlib.sha256(key).digest()
key_hash = base64.b64encode(key_hash).rstrip()
key = base64.b64encode(key).rstrip()
if source:
prefix = 'X-Goog-Copy-Source-Encryption-'
else:
prefix = 'X-Goog-Encryption-'
return {
prefix + 'Algorithm': 'AES256',
prefix + 'Key': _bytes_to_unicode(key),
prefix + 'Key-Sha256': _bytes_to_unicode(key_hash),
}
def _get_encryption_headers(key, source=False):
"""Builds customer encryption key headers
:type key: bytes
:param key: 32 byte key to build request key and hash.
:type source: bool
:param source: If true, return headers for the "source" blob; otherwise,
return headers for the "destination" blob.
:rtype: dict
:returns: dict of HTTP headers being sent in request.
"""
if key is None:
return {}
key = _to_bytes(key)
key_hash = hashlib.sha256(key).digest()
key_hash = base64.b64encode(key_hash).rstrip()
key = base64.b64encode(key).rstrip()
if source:
prefix = 'X-Goog-Copy-Source-Encryption-'
else:
prefix = 'X-Goog-Encryption-'
return {
prefix + 'Algorithm': 'AES256',
prefix + 'Key': _bytes_to_unicode(key),
prefix + 'Key-Sha256': _bytes_to_unicode(key_hash),
}
def _from_service_account_json_helper(self, project=None):
from google.cloud import _helpers
klass = self._get_target_class()
default_project = "eye-d-of-project"
info = {"dummy": "value", "valid": "json", "project_id": default_project}
if project is None:
expected_project = "eye-d-of-project"
else:
expected_project = project
# Mock both the file opening and the credentials constructor.
json_fi = io.StringIO(_helpers._bytes_to_unicode(json.dumps(info)))
file_open_patch = mock.patch("io.open", return_value=json_fi)
constructor_patch = mock.patch(
"google.oauth2.service_account.Credentials." "from_service_account_info",
return_value=_make_credentials(),
)
with file_open_patch as file_open:
with constructor_patch as constructor:
kwargs = {}
if project is not None:
kwargs["project"] = project
client_obj = klass.from_service_account_json(
mock.sentinel.filename, **kwargs
)
self.assertIs(client_obj._credentials, constructor.return_value)
self.assertIsNone(client_obj._http_internal)
self.assertEqual(client_obj.project, expected_project)
# Check that mocks were called as expected.
file_open.assert_called_once_with(mock.sentinel.filename, "r", encoding="utf-8")
constructor.assert_called_once_with(info)
def _from_service_account_json_helper(self, project=None):
from google.cloud import _helpers
klass = self._get_target_class()
info = {"dummy": "value", "valid": "json"}
if project is None:
expected_project = "eye-d-of-project"
else:
expected_project = project
info["project_id"] = expected_project
# Mock both the file opening and the credentials constructor.
json_fi = io.StringIO(_helpers._bytes_to_unicode(json.dumps(info)))
file_open_patch = mock.patch("io.open", return_value=json_fi)
constructor_patch = mock.patch(
"google.oauth2.service_account.Credentials." "from_service_account_info",
return_value=_make_credentials(),
)
with file_open_patch as file_open:
with constructor_patch as constructor:
kwargs = {}
if project is not None:
kwargs["project"] = project
client_obj = klass.from_service_account_json(
mock.sentinel.filename, **kwargs
)
self.assertIs(client_obj._credentials, constructor.return_value)
self.assertIsNone(client_obj._http_internal)
self.assertEqual(client_obj.project, expected_project)
# Check that mocks were called as expected.
file_open.assert_called_once_with(mock.sentinel.filename, "r", encoding="utf-8")
constructor.assert_called_once_with(info)
def test_from_service_account_json(self):
from google.cloud import _helpers
klass = self._get_target_class()
# Mock both the file opening and the credentials constructor.
info = {'dummy': 'value', 'valid': 'json'}
json_fi = io.StringIO(_helpers._bytes_to_unicode(json.dumps(info)))
file_open_patch = mock.patch('io.open', return_value=json_fi)
constructor_patch = mock.patch(
'google.oauth2.service_account.Credentials.'
'from_service_account_info',
return_value=_make_credentials())
with file_open_patch as file_open:
with constructor_patch as constructor:
client_obj = klass.from_service_account_json(
mock.sentinel.filename)
self.assertIs(client_obj._credentials, constructor.return_value)
self.assertIsNone(client_obj._http_internal)
# Check that mocks were called as expected.
file_open.assert_called_once_with(mock.sentinel.filename,
'r',
encoding='utf-8')
constructor.assert_called_once_with(info)
def _set_encryption_headers(key, headers):
"""Builds customer encryption key headers
:type key: str or bytes
:param key: 32 byte key to build request key and hash.
:type headers: dict
:param headers: dict of HTTP headers being sent in request.
"""
key = _to_bytes(key)
sha256_key = hashlib.sha256(key).digest()
key_hash = base64.b64encode(sha256_key).rstrip()
encoded_key = base64.b64encode(key).rstrip()
headers['X-Goog-Encryption-Algorithm'] = 'AES256'
headers['X-Goog-Encryption-Key'] = _bytes_to_unicode(encoded_key)
headers['X-Goog-Encryption-Key-Sha256'] = _bytes_to_unicode(key_hash)
def __init__(
self,
name,
bucket,
chunk_size=None,
encryption_key=None,
kms_key_name=None,
generation=None,
):
name = _bytes_to_unicode(name)
self.chunk_size = chunk_size # Check that setter accepts value.
self._bucket = bucket
# self._acl = ObjectACL(self)
if encryption_key is not None and kms_key_name is not None:
raise ValueError("Pass at most one of 'encryption_key' "
"and 'kms_key_name'")
self._encryption_key = encryption_key
if kms_key_name is not None:
self._properties["kmsKeyName"] = kms_key_name
if generation is not None:
self._properties["generation"] = generation
def _set_encryption_headers(key, headers):
"""Builds customer encryption key headers
:type key: str or bytes
:param key: 32 byte key to build request key and hash.
:type headers: dict
:param headers: dict of HTTP headers being sent in request.
"""
key = _to_bytes(key)
sha256_key = hashlib.sha256(key).digest()
key_hash = base64.b64encode(sha256_key).rstrip()
encoded_key = base64.b64encode(key).rstrip()
headers['X-Goog-Encryption-Algorithm'] = 'AES256'
headers['X-Goog-Encryption-Key'] = _bytes_to_unicode(encoded_key)
headers['X-Goog-Encryption-Key-Sha256'] = _bytes_to_unicode(key_hash)
def test_from_service_account_json(self):
from google.cloud import _helpers
klass = self._get_target_class()
# Mock both the file opening and the credentials constructor.
info = {'dummy': 'value', 'valid': 'json'}
json_fi = io.StringIO(_helpers._bytes_to_unicode(json.dumps(info)))
file_open_patch = mock.patch(
'io.open', return_value=json_fi)
constructor_patch = mock.patch(
'google.oauth2.service_account.Credentials.'
'from_service_account_info',
return_value=_make_credentials())
with file_open_patch as file_open:
with constructor_patch as constructor:
client_obj = klass.from_service_account_json(
mock.sentinel.filename)
self.assertIs(
client_obj._credentials, constructor.return_value)
self.assertIsNone(client_obj._http_internal)
# Check that mocks were called as expected.
file_open.assert_called_once_with(
mock.sentinel.filename, 'r', encoding='utf-8')
constructor.assert_called_once_with(info)
def test_from_service_account_json(self):
from google.cloud import _helpers
klass = self._get_target_class()
info = {"dummy": "value", "valid": "json"}
json_file = io.StringIO(_helpers._bytes_to_unicode(json.dumps(info)))
file_open_patch = mock.patch("io.open", return_value=json_file)
constructor_patch = mock.patch(
"google.oauth2.service_account.Credentials."
"from_service_account_info",
return_value=_make_credentials(),
)
with file_open_patch as file_open:
with constructor_patch as constructor:
client_obj = klass.from_service_account_json(
mock.sentinel.filename)
self.assertIs(client_obj._credentials, constructor.return_value)
self.assertIsNone(client_obj._http_internal)
# Check that mocks were called as expected.
file_open.assert_called_once_with(mock.sentinel.filename,
"r",
encoding="utf-8")
constructor.assert_called_once_with(info)
def test_from_service_account_json_with_posarg(self):
from google.cloud import _helpers
class Derived(self._get_target_class()):
def __init__(self, required, **kwargs):
super(Derived, self).__init__(**kwargs)
self.required = required
project = "eye-d-of-project"
info = {"dummy": "value", "valid": "json", "project_id": project}
# Mock both the file opening and the credentials constructor.
json_fi = io.StringIO(_helpers._bytes_to_unicode(json.dumps(info)))
file_open_patch = mock.patch("io.open", return_value=json_fi)
constructor_patch = mock.patch(
"google.oauth2.service_account.Credentials.from_service_account_info",
return_value=_make_credentials(),
)
with file_open_patch as file_open:
with constructor_patch as constructor:
client_obj = Derived.from_service_account_json(
mock.sentinel.filename, "REQUIRED")
self.assertIsInstance(client_obj, Derived)
self.assertIs(client_obj._credentials, constructor.return_value)
self.assertIsNone(client_obj._http_internal)
self.assertEqual(client_obj.project, project)
self.assertEqual(client_obj.required, "REQUIRED")
# Check that mocks were called as expected.
file_open.assert_called_once_with(mock.sentinel.filename,
"r",
encoding="utf-8")
constructor.assert_called_once_with(info)
def test_sync_recognize_content_with_optional_params_no_gax(self):
from base64 import b64encode
from google.cloud._helpers import _to_bytes
from google.cloud._helpers import _bytes_to_unicode
from google.cloud._testing import _Monkey
from google.cloud.speech import client as MUT
from google.cloud import speech
from google.cloud.speech.sample import Sample
from google.cloud.speech.transcript import Transcript
from unit_tests._fixtures import SYNC_RECOGNIZE_RESPONSE
_AUDIO_CONTENT = _to_bytes(self.AUDIO_CONTENT)
_B64_AUDIO_CONTENT = _bytes_to_unicode(b64encode(_AUDIO_CONTENT))
RETURNED = SYNC_RECOGNIZE_RESPONSE
REQUEST = {
'config': {
'encoding': 'FLAC',
'maxAlternatives': 2,
'sampleRate': 16000,
'speechContext': {
'phrases': [
'hi',
]
},
'languageCode': 'EN',
'profanityFilter': True,
},
'audio': {
'content': _B64_AUDIO_CONTENT,
}
}
credentials = _Credentials()
client = self._makeOne(credentials=credentials, use_gax=False)
client.connection = _Connection(RETURNED)
encoding = speech.Encoding.FLAC
sample = Sample(content=self.AUDIO_CONTENT, encoding=encoding,
sample_rate=self.SAMPLE_RATE)
with _Monkey(MUT, _USE_GAX=False):
response = client.sync_recognize(sample,
language_code='EN',
max_alternatives=2,
profanity_filter=True,
speech_context=self.HINTS)
self.assertEqual(len(client.connection._requested), 1)
req = client.connection._requested[0]
self.assertEqual(len(req), 3)
self.assertEqual(req['data'], REQUEST)
self.assertEqual(req['method'], 'POST')
self.assertEqual(req['path'], 'speech:syncrecognize')
alternative = SYNC_RECOGNIZE_RESPONSE['results'][0]['alternatives'][0]
expected = Transcript.from_api_repr(alternative)
self.assertEqual(len(response), 1)
self.assertIsInstance(response[0], Transcript)
self.assertEqual(response[0].transcript, expected.transcript)
self.assertEqual(response[0].confidence, expected.confidence)
def test_sync_recognize_content_with_optional_params_no_gax(self):
from base64 import b64encode
from google.cloud._helpers import _bytes_to_unicode
from google.cloud import speech
from google.cloud.speech.alternative import Alternative
from google.cloud.speech.result import Result
from tests.unit._fixtures import SYNC_RECOGNIZE_RESPONSE
_b64_audio_content = _bytes_to_unicode(b64encode(self.AUDIO_CONTENT))
request = {
'config': {
'encoding': 'FLAC',
'maxAlternatives': 2,
'sampleRateHertz': 16000,
'speechContexts': {
'phrases': [
'hi',
]
},
'languageCode': 'EN',
'profanityFilter': True,
},
'audio': {
'content': _b64_audio_content,
}
}
credentials = _make_credentials()
client = self._make_one(credentials=credentials, _use_grpc=False)
speech_api = client.speech_api
connection = _Connection(SYNC_RECOGNIZE_RESPONSE)
speech_api._connection = connection
encoding = speech.Encoding.FLAC
sample = client.sample(
content=self.AUDIO_CONTENT, encoding=encoding,
sample_rate_hertz=self.SAMPLE_RATE)
response = sample.recognize(
language_code='EN', max_alternatives=2, profanity_filter=True,
speech_contexts=self.HINTS)
self.assertEqual(len(connection._requested), 1)
req = connection._requested[0]
self.assertEqual(len(req), 3)
self.assertEqual(req['data'], request)
self.assertEqual(req['method'], 'POST')
self.assertEqual(req['path'], 'speech:recognize')
alternative = SYNC_RECOGNIZE_RESPONSE['results'][0]['alternatives'][0]
expected = Alternative.from_api_repr(alternative)
self.assertEqual(len(response), 1)
result = response[0]
self.assertIsInstance(result, Result)
self.assertEqual(len(result.alternatives), 1)
alternative = result.alternatives[0]
self.assertEqual(alternative.transcript, expected.transcript)
self.assertEqual(alternative.confidence, expected.confidence)
def test_sync_recognize_content_with_optional_params_no_gax(self):
from base64 import b64encode
from google.cloud._helpers import _bytes_to_unicode
from google.cloud._helpers import _to_bytes
from google.cloud import speech
from google.cloud.speech.alternative import Alternative
from google.cloud.speech.sample import Sample
from unit_tests._fixtures import SYNC_RECOGNIZE_RESPONSE
_AUDIO_CONTENT = _to_bytes(self.AUDIO_CONTENT)
_B64_AUDIO_CONTENT = _bytes_to_unicode(b64encode(_AUDIO_CONTENT))
RETURNED = SYNC_RECOGNIZE_RESPONSE
REQUEST = {
'config': {
'encoding': 'FLAC',
'maxAlternatives': 2,
'sampleRate': 16000,
'speechContext': {
'phrases': [
'hi',
]
},
'languageCode': 'EN',
'profanityFilter': True,
},
'audio': {
'content': _B64_AUDIO_CONTENT,
}
}
credentials = _Credentials()
client = self._make_one(credentials=credentials, use_gax=False)
client._connection = _Connection(RETURNED)
encoding = speech.Encoding.FLAC
sample = Sample(content=self.AUDIO_CONTENT, encoding=encoding,
sample_rate=self.SAMPLE_RATE)
response = client.sync_recognize(sample,
language_code='EN',
max_alternatives=2,
profanity_filter=True,
speech_context=self.HINTS)
self.assertEqual(len(client._connection._requested), 1)
req = client._connection._requested[0]
self.assertEqual(len(req), 3)
self.assertEqual(req['data'], REQUEST)
self.assertEqual(req['method'], 'POST')
self.assertEqual(req['path'], 'speech:syncrecognize')
alternative = SYNC_RECOGNIZE_RESPONSE['results'][0]['alternatives'][0]
expected = Alternative.from_api_repr(alternative)
self.assertEqual(len(response), 1)
self.assertIsInstance(response[0], Alternative)
self.assertEqual(response[0].transcript, expected.transcript)
self.assertEqual(response[0].confidence, expected.confidence)
def _flatten_cells(prd):
# Match results format from JSON testcases.
# Doesn't handle error cases.
from google.cloud._helpers import _bytes_to_unicode
from google.cloud._helpers import _microseconds_from_datetime
for row_key, row in prd.rows.items():
for family_name, family in row.cells.items():
for qualifier, column in family.items():
for cell in column:
yield {
u'rk': _bytes_to_unicode(row_key),
u'fm': family_name,
u'qual': _bytes_to_unicode(qualifier),
u'ts': _microseconds_from_datetime(cell.timestamp),
u'value': _bytes_to_unicode(cell.value),
u'label': u' '.join(cell.labels),
u'error': False,
}
def __init__(self, client, content=None, source_uri=None):
self.client = client
self._content = None
self._source = None
if source_uri:
self._source = source_uri
else:
self._content = _bytes_to_unicode(b64encode(_to_bytes(content)))
def __init__(self, client, content=None, source_uri=None):
self.client = client
self._content = None
self._source = None
if source_uri:
self._source = source_uri
else:
self._content = _bytes_to_unicode(b64encode(_to_bytes(content)))
def _flatten_cells(prd):
# Match results format from JSON testcases.
# Doesn't handle error cases.
from google.cloud._helpers import _bytes_to_unicode
from google.cloud._helpers import _microseconds_from_datetime
for row_key, row in prd.rows.items():
for family_name, family in row.cells.items():
for qualifier, column in family.items():
for cell in column:
yield {
u'rk': _bytes_to_unicode(row_key),
u'fm': family_name,
u'qual': _bytes_to_unicode(qualifier),
u'ts': _microseconds_from_datetime(cell.timestamp),
u'value': _bytes_to_unicode(cell.value),
u'label': u' '.join(cell.labels),
u'error': False,
}
def __init__(self, image_source, client):
self.client = client
self._content = None
self._source = None
if _bytes_to_unicode(image_source).startswith('gs://'):
self._source = image_source
else:
self._content = b64encode(_to_bytes(image_source))
def __init__(self, image_source, client):
self.client = client
self._content = None
self._source = None
if _bytes_to_unicode(image_source).startswith('gs://'):
self._source = image_source
else:
self._content = b64encode(_to_bytes(image_source))
def as_dict(self):
"""Generate dictionary structure for request.
:rtype: dict
:returns: Dictionary with source information for image.
"""
if self.content:
return {'content': _bytes_to_unicode(b64encode(self.content))}
else:
return {'source': {'gcs_image_uri': self.source}}
def _flatten_cells(prd):
# Match results format from JSON testcases.
# Doesn't handle error cases.
from google.cloud._helpers import _bytes_to_unicode
from google.cloud._helpers import _microseconds_from_datetime
for row_key, row in prd.rows.items():
for family_name, family in row.cells.items():
for qualifier, column in family.items():
for cell in column:
yield {
u"rk": _bytes_to_unicode(row_key),
u"fm": family_name,
u"qual": _bytes_to_unicode(qualifier),
u"ts": _microseconds_from_datetime(cell.timestamp),
u"value": _bytes_to_unicode(cell.value),
u"label": u" ".join(cell.labels),
u"error": False,
}
def _flatten_cells(prd):
# Match results format from JSON testcases.
# Doesn't handle error cases.
from google.cloud._helpers import _bytes_to_unicode
from google.cloud._helpers import _microseconds_from_datetime
for row_key, row in prd.rows.items():
for family_name, family in row.cells.items():
for qualifier, column in family.items():
for cell in column:
yield {
u"rk": _bytes_to_unicode(row_key),
u"fm": family_name,
u"qual": _bytes_to_unicode(qualifier),
u"ts": _microseconds_from_datetime(cell.timestamp),
u"value": _bytes_to_unicode(cell.value),
u"label": u" ".join(cell.labels),
u"error": False,
}
def as_dict(self):
"""Generate dictionary structure for request.
:rtype: dict
:returns: Dictionary with source information for image.
"""
if self.content:
return {'content': _bytes_to_unicode(b64encode(self.content))}
elif self.source.startswith('gs://'):
return {'source': {'gcs_image_uri': self.source}}
elif self.source.startswith(('http://', 'https://')):
return {'source': {'image_uri': self.source}}
raise ValueError('No image content or source found.')
def __init__(self, client, content=None, filename=None, source_uri=None):
sources = [source for source in (content, filename, source_uri)
if source is not None]
if len(sources) != 1:
raise ValueError(
'Specify exactly one of "content", "filename", or '
'"source_uri".')
self.client = client
if filename is not None:
with open(filename, 'rb') as file_obj:
content = file_obj.read()
if content is not None:
content = _bytes_to_unicode(b64encode(_to_bytes(content)))
self._content = content
self._source = source_uri
def __init__(self, client, content=None, filename=None, source_uri=None):
sources = [source for source in (content, filename, source_uri)
if source is not None]
if len(sources) != 1:
raise ValueError(
'Specify exactly one of "content", "filename", or '
'"source_uri".')
self.client = client
if filename is not None:
with open(filename, 'rb') as file_obj:
content = file_obj.read()
if content is not None:
content = _bytes_to_unicode(b64encode(_to_bytes(content)))
self._content = content
self._source = source_uri
def _from_service_account_json_helper(self, project=None):
from google.cloud import _helpers
klass = self._get_target_class()
info = {'dummy': 'value', 'valid': 'json'}
if project is None:
expected_project = 'eye-d-of-project'
else:
expected_project = project
info['project_id'] = expected_project
# Mock both the file opening and the credentials constructor.
json_fi = io.StringIO(_helpers._bytes_to_unicode(json.dumps(info)))
file_open_patch = mock.patch(
'io.open', return_value=json_fi)
constructor_patch = mock.patch(
'google.oauth2.service_account.Credentials.'
'from_service_account_info',
return_value=_make_credentials())
with file_open_patch as file_open:
with constructor_patch as constructor:
kwargs = {}
if project is not None:
kwargs['project'] = project
client_obj = klass.from_service_account_json(
mock.sentinel.filename, **kwargs)
self.assertIs(
client_obj._credentials, constructor.return_value)
self.assertIsNone(client_obj._http_internal)
self.assertEqual(client_obj.project, expected_project)
# Check that mocks were called as expected.
file_open.assert_called_once_with(
mock.sentinel.filename, 'r', encoding='utf-8')
constructor.assert_called_once_with(info)
def _build_request_data(sample,
language_code=None,
max_alternatives=None,
profanity_filter=None,
speech_context=None):
"""Builds the request data before making API request.
:type sample: :class:`~google.cloud.speech.sample.Sample`
:param sample: Instance of ``Sample`` containing audio information.
:type language_code: str
:param language_code: (Optional) The language of the supplied audio as
BCP-47 language tag. Example: ``'en-GB'``.
If omitted, defaults to ``'en-US'``.
:type max_alternatives: int
:param max_alternatives: (Optional) Maximum number of recognition
hypotheses to be returned. The server may
return fewer than maxAlternatives.
Valid values are 0-30. A value of 0 or 1
will return a maximum of 1. Defaults to 1
:type profanity_filter: bool
:param profanity_filter: If True, the server will attempt to filter
out profanities, replacing all but the
initial character in each filtered word with
asterisks, e.g. ``'f***'``. If False or
omitted, profanities won't be filtered out.
:type speech_context: list
:param speech_context: A list of strings (max 50) containing words and
phrases "hints" so that the speech recognition
is more likely to recognize them. This can be
used to improve the accuracy for specific words
and phrases. This can also be used to add new
words to the vocabulary of the recognizer.
:rtype: dict
:returns: Dictionary with required data for Google Speech API.
"""
if sample.content is not None:
audio = {
'content': _bytes_to_unicode(b64encode(_to_bytes(sample.content)))
}
else:
audio = {'uri': sample.source_uri}
config = {'encoding': sample.encoding, 'sampleRate': sample.sample_rate}
if language_code is not None:
config['languageCode'] = language_code
if max_alternatives is not None:
config['maxAlternatives'] = max_alternatives
if profanity_filter is not None:
config['profanityFilter'] = profanity_filter
if speech_context is not None:
config['speechContext'] = {'phrases': speech_context}
data = {
'audio': audio,
'config': config,
}
return data
def _call_fut(self, *args, **kwargs):
from google.cloud._helpers import _bytes_to_unicode
return _bytes_to_unicode(*args, **kwargs)
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import base64
import unittest
from google.cloud._helpers import _to_bytes
from google.cloud._helpers import _bytes_to_unicode
IMAGE_SOURCE = 'gs://some/image.jpg'
IMAGE_CONTENT = _to_bytes('/9j/4QNURXhpZgAASUkq')
B64_IMAGE_CONTENT = _bytes_to_unicode(base64.b64encode(IMAGE_CONTENT))
CLIENT_MOCK = {'source': ''}
class TestVisionImage(unittest.TestCase):
def _getTargetClass(self):
from google.cloud.vision.image import Image
return Image
def _makeOne(self, *args, **kw):
return self._getTargetClass()(*args, **kw)
def test_image_source_type_content(self):
image = self._makeOne(CLIENT_MOCK, content=IMAGE_CONTENT)
_AS_DICT = {
def _call_fut(self, *args, **kwargs):
from google.cloud._helpers import _bytes_to_unicode
return _bytes_to_unicode(*args, **kwargs)
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import base64
import unittest
from google.cloud._helpers import _to_bytes
from google.cloud._helpers import _bytes_to_unicode
IMAGE_CONTENT = _to_bytes('/9j/4QNURXhpZgAASUkq')
IMAGE_SOURCE = 'gs://some/image.jpg'
PROJECT = 'PROJECT'
B64_IMAGE_CONTENT = _bytes_to_unicode(base64.b64encode(IMAGE_CONTENT))
class TestClient(unittest.TestCase):
@staticmethod
def _get_target_class():
from google.cloud.vision.client import Client
return Client
def _make_one(self, *args, **kw):
return self._get_target_class()(*args, **kw)
def test_ctor(self):
creds = _Credentials()
client = self._make_one(project=PROJECT, credentials=creds)
self.assertEqual(client.project, PROJECT)
def _build_request_data(sample, language_code=None, max_alternatives=None,
profanity_filter=None, speech_context=None):
"""Builds the request data before making API request.
:type sample: :class:`~google.cloud.speech.sample.Sample`
:param sample: Instance of ``Sample`` containing audio information.
:type language_code: str
:param language_code: (Optional) The language of the supplied audio as
BCP-47 language tag. Example: ``'en-GB'``.
If omitted, defaults to ``'en-US'``.
:type max_alternatives: int
:param max_alternatives: (Optional) Maximum number of recognition
hypotheses to be returned. The server may
return fewer than maxAlternatives.
Valid values are 0-30. A value of 0 or 1
will return a maximum of 1. Defaults to 1
:type profanity_filter: bool
:param profanity_filter: If True, the server will attempt to filter
out profanities, replacing all but the
initial character in each filtered word with
asterisks, e.g. ``'f***'``. If False or
omitted, profanities won't be filtered out.
:type speech_context: list
:param speech_context: A list of strings (max 50) containing words and
phrases "hints" so that the speech recognition
is more likely to recognize them. This can be
used to improve the accuracy for specific words
and phrases. This can also be used to add new
words to the vocabulary of the recognizer.
:rtype: dict
:returns: Dictionary with required data for Google Speech API.
"""
if sample.content is not None:
audio = {'content':
_bytes_to_unicode(b64encode(_to_bytes(sample.content)))}
else:
audio = {'uri': sample.source_uri}
config = {'encoding': sample.encoding,
'sampleRate': sample.sample_rate}
if language_code is not None:
config['languageCode'] = language_code
if max_alternatives is not None:
config['maxAlternatives'] = max_alternatives
if profanity_filter is not None:
config['profanityFilter'] = profanity_filter
if speech_context is not None:
config['speechContext'] = {'phrases': speech_context}
data = {
'audio': audio,
'config': config,
}
return data