def testMessageParser(self):
WidgetMessage = messages.model_message(Widget)
message = WidgetMessage(title='The Doctor', content='Time Lord')
request = Bunch(body=unicode(protojson.encode_message(message)))
parser = MessageParser().process(request, WidgetMessage)
assert parser.validate()
assert parser.container == message
w = Widget()
parser.update(w)
assert w.title == message.title
assert w.content == message.content
# Partial update
message = WidgetMessage(title='Susan')
request = Bunch(body=unicode(protojson.encode_message(message)))
parser = MessageParser().process(request, WidgetMessage)
parser.update(w)
assert w.title == 'Susan'
assert w.content == 'Time Lord'
def testMessageParser(self):
WidgetMessage = messages.model_message(Widget)
message = WidgetMessage(title='The Doctor', content='Time Lord')
request = Bunch(body=unicode(protojson.encode_message(message)))
parser = MessageParser().process(request, WidgetMessage)
assert parser.validate()
assert parser.container == message
w = Widget()
parser.update(w)
assert w.title == message.title
assert w.content == message.content
# Partial update
message = WidgetMessage(title='Susan')
request = Bunch(body=unicode(protojson.encode_message(message)))
parser = MessageParser().process(request, WidgetMessage)
parser.update(w)
assert w.title == 'Susan'
assert w.content == 'Time Lord'
def encode_proto(msg):
if msg is None:
return ''
elif isinstance(msg, list):
msg_list = msg
csv = ", ".join(protojson.encode_message(msg) for msg in msg_list)
return "[" + csv + "]"
else:
return protojson.encode_message(msg)
def setUp(self):
# Do not need much parent construction functionality.
self.schema = "http"
self.server = None
self.request = Message(value=u"The request value")
self.encoded_request = protojson.encode_message(self.request)
self.response = Message(value=u"The response value")
self.encoded_response = protojson.encode_message(self.response)
def setUp(self):
# Do not need much parent construction functionality.
self.schema = 'http'
self.server = None
self.request = Message(value=u'The request value')
self.encoded_request = protojson.encode_message(self.request)
self.response = Message(value=u'The response value')
self.encoded_response = protojson.encode_message(self.response)
def EncodeProto(msg):
if msg is None:
return ""
elif isinstance(msg, list):
# A list of ProtoRPC messages needs to be serialized into a JSON list by
# serializing each individual message.
msg_list = msg
csv = ", ".join(protojson.encode_message(msg) for msg in msg_list)
return "[" + csv + "]"
else:
return protojson.encode_message(msg)
def setUp(self):
super(HttpTransportUrllibTest, self).setUp()
self.original_urlfetch = transport.urlfetch
transport.urlfetch = None
self.trans = transport.HttpTransport("http://myserver/myservice", protocol=protojson)
self.request = Message(value=u"The request value")
self.encoded_request = protojson.encode_message(self.request)
self.response = Message(value=u"The response value")
self.encoded_response = protojson.encode_message(self.response)
self.mox = mox.Mox()
self.mox.StubOutWithMock(urllib2, "urlopen")
def setUp(self):
super(HttpTransportUrllibTest, self).setUp()
self.original_urlfetch = transport.urlfetch
transport.urlfetch = None
self.trans = transport.HttpTransport('http://myserver/myservice',
protocol=protojson)
self.request = Message(value=u'The request value')
self.encoded_request = protojson.encode_message(self.request)
self.response = Message(value=u'The response value')
self.encoded_response = protojson.encode_message(self.response)
self.mox = mox.Mox()
self.mox.StubOutWithMock(urllib2, 'urlopen')
def admin(self):
self.meta.view.template_name = 'angular/admin-index.html'
active_user = UserSvc.get_current_user()
user = Account.transform_message(active_user)
self.context['active_user'] = protojson.encode_message(user)
self.context['logout_url'] = users.create_logout_url('/')
self.context['commission'] = settings.get('paypal').get('commission')
def testHandleObjectStateChangeEvent_attemptEvent(self):
request = self._CreateTestRequest(state=common.RequestState.COMPLETED)
command = self._CreateTestCommand(request,
state=common.CommandState.COMPLETED)
attempt = self._CreateTestCommandAttempt(
command,
state=common.CommandState.COMPLETED,
total_test_count=5,
failed_test_count=1,
failed_test_run_count=1,
start_time=datetime.datetime(2016, 12, 1, 0, 0, 0),
end_time=datetime.datetime(2016, 12, 1, 0, 0, 1))
event_message = api_messages.CommandAttemptEventMessage(
type=common.ObjectEventType.COMMAND_ATTEMPT_STATE_CHANGED,
attempt=datastore_entities.CommandAttemptToMessage(attempt),
old_state=common.CommandState.RUNNING,
new_state=common.CommandState.COMPLETED,
event_time=TIMESTAMP)
self.testapp.post(
notifier.OBJECT_EVENT_QUEUE_HANDLER_PATH,
protojson.encode_message(event_message))
self._AssertMessagePublished(
event_message, notifier.COMMAND_ATTEMPT_EVENT_PUBSUB_TOPIC)
def DoRequest(self,
path,
request,
response_type,
reg_path='/protorpc'):
stdin = sys.stdin
stdout = sys.stdout
environ = os.environ
try:
sys.stdin = cStringIO.StringIO(protojson.encode_message(request))
sys.stdout = cStringIO.StringIO()
os.environ = webapp_test_util.GetDefaultEnvironment()
os.environ['PATH_INFO'] = path
os.environ['REQUEST_METHOD'] = 'POST'
os.environ['CONTENT_TYPE'] = 'application/json'
os.environ['wsgi.input'] = sys.stdin
os.environ['wsgi.output'] = sys.stdout
os.environ['CONTENT_LENGTH'] = len(sys.stdin.getvalue())
service_handlers.run_services(
[('/my_service', GetCalled.new_factory(self))], reg_path)
header, body = sys.stdout.getvalue().split('\n\n', 1)
return (header.split('\n')[0],
protojson.decode_message(response_type, body))
finally:
sys.stdin = stdin
sys.stdout = stdout
os.environ = environ
def SubmitHostEvents(self, request):
"""Submit a bundle of cluster host events for processing.
Args:
request: a HostEventList
Returns:
a VoidMessage
"""
# Convert the request message to json for the taskqueue payload
encoded_message = protojson.encode_message(request) # pytype: disable=module-attr
json_message = json.loads(encoded_message)
host_events = json_message.get("host_events")
if not host_events:
raise endpoints.BadRequestException("Request has no host_events.")
logging.info(
"Submitting host event message with size %d and %d events",
len(encoded_message), len(host_events))
for event_chunk in chunks(host_events, CHUNK_SIZE):
logging.info("Queuing host event chunk of size %d",
len(event_chunk))
task_scheduler.AddCallableTask(
self._ProcessHostEventWithNDB,
event_chunk,
_queue=host_event.HOST_EVENT_QUEUE_NDB,
_target="%s.%s" %
(common.GetServiceVersion(), common.GetServiceName()))
logging.debug("Submitted host event message.")
return message_types.VoidMessage()
def to_csv(cls):
# TODO: Move to separate file.
from protorpc import protojson
import io
import csv
import json
_csv_header = [
'created',
'email',
'folders',
]
header = _csv_header
ents, _, _ = cls.search(limit=5000)
rows = []
for ent in ents:
row = json.loads(protojson.encode_message(ent.to_message()))
for key in row.keys():
if key not in header:
del row[key]
for key in row:
if key == 'folders':
row[key] = json.dumps(row[key])
if isinstance(row[key], unicode):
row[key] = row[key].encode('utf-8')
rows.append(row)
if not rows:
return ''
fp = io.BytesIO()
writer = csv.DictWriter(fp, header)
writer.writeheader()
writer.writerows(rows)
fp.seek(0)
return fp.read()
def setUp(self):
super(HttpTransportUrlfetchTest, self).setUp()
self.trans = transport.HttpTransport("http://myserver/myservice", protocol=protojson)
self.request = Message(value=u"The request value")
self.encoded_request = protojson.encode_message(self.request)
self.response = Message(value=u"The response value")
self.encoded_response = protojson.encode_message(self.response)
self.mox = mox.Mox()
self.mox.StubOutWithMock(urlfetch, "create_rpc")
self.mox.StubOutWithMock(urlfetch, "make_fetch_call")
self.urlfetch_rpc = self.mox.CreateMockAnything()
def SendRequestStateNotification(request_id, message):
request = GetRequest(request_id)
payload = zlib.compress(six.ensure_binary(protojson.encode_message(message))) # pytype: disable=module-attr
task_scheduler.AddTask(
queue_name=common.OBJECT_EVENT_QUEUE, payload=payload, transactional=True)
request.notify_state_change = False
request.put()
return request
def message_to_dict(message):
'''Returns an instance of an encoded json string.
:param message: Instance of a response protorpc `Message`.
'''
if not isinstance(message, messages.Message):
raise ValueError('Value must be an instance of messages.Message.')
return loads(protojson.encode_message(message))
def message_to_dict(message):
'''Returns an instance of an encoded json string.
:param message: Instance of a response protorpc `Message`.
'''
if not isinstance(message, messages.Message):
raise ValueError('Value must be an instance of messages.Message.')
return loads(protojson.encode_message(message))
def setUp(self):
super(HttpTransportUrlfetchTest, self).setUp()
self.trans = transport.HttpTransport('http://myserver/myservice',
protocol=protojson)
self.request = Message(value=u'The request value')
self.encoded_request = protojson.encode_message(self.request)
self.response = Message(value=u'The response value')
self.encoded_response = protojson.encode_message(self.response)
self.mox = mox.Mox()
self.mox.StubOutWithMock(urlfetch, 'create_rpc')
self.mox.StubOutWithMock(urlfetch, 'make_fetch_call')
self.urlfetch_rpc = self.mox.CreateMockAnything()
def testEncodeDateTime(self):
for datetime_string, datetime_vals in (
('2012-09-30T15:31:50.262000', (2012, 9, 30, 15, 31, 50, 262000)),
('2012-09-30T15:31:50.262123', (2012, 9, 30, 15, 31, 50, 262123)),
('2012-09-30T15:31:50', (2012, 9, 30, 15, 31, 50, 0))):
decoded_message = protojson.encode_message(
MyMessage(a_datetime=datetime.datetime(*datetime_vals)))
expected_decoding = '{"a_datetime": "%s"}' % datetime_string
self.CompareEncoded(expected_decoding, decoded_message)
def testMessageParser(self):
WidgetMessage = messages.model_message(Widget)
message = WidgetMessage(title='The Doctor', content='Time Lord')
request = Bunch(body=unicode(protojson.encode_message(message)))
parser = MessageParser().process(request, WidgetMessage)
assert parser.validate()
assert parser.container == message
def render(self, *args, **kwargs):
self.controller.events.before_render(controller=self.controller)
self.controller.response.charset = 'utf-8'
self.controller.response.content_type = 'application/json'
data = self._get_data(default=VoidMessage())
result = unicode(protojson.encode_message(data))
self.controller.response.unicode_body = result
self.controller.events.after_render(controller=self.controller, result=result)
self.controller.response.headers["spend-time"] = str(time.time() - self.controller.request_start_time)
return self.controller.response
def Encode(config_set):
"""Serializes MTT configuration.
Args:
config_set: MTT configuration set
Returns:
Configuration set serialized as a YAML string
"""
msg = messages.Convert(config_set, _ConfigSetMessage)
return _JsonToYaml(protojson.encode_message(msg)) # pytype: disable=module-attr
def render(self, *args, **kwargs):
self.controller.events.before_render(controller=self.controller)
data = self._get_data(default=VoidMessage())
result = unicode(protojson.encode_message(data))
self.controller.response.content_type = 'application/json'
self.controller.response.charset = 'utf-8'
self.controller.response.unicode_body = result
self.controller.events.after_render(controller=self.controller, result=result)
return self.controller.response
def get_model_message(event, model):
"""
Generic method to map a Django model to a response
message
"""
model_enum = EventModel(event.kind / CODES_PER_MODEL)
mapper = MESSAGE_MAPPER_MAP.get(model_enum)
if mapper:
message = mapper.map(model)
# TODO: don't encode and decode to string
return json.loads(encode_message(message))
def SubmitCommandEvents(self, request):
"""Submit a bundle of cluster command events for processing.
Args:
request: a CommandEventList
Returns:
a VoidMessage
"""
# Convert the request message to json for the taskqueue payload
json_message = json.loads(protojson.encode_message(request)) # pytype: disable=module-attr
command_event_handler.EnqueueCommandEvents(json_message["command_events"])
return message_types.VoidMessage()
def testBadMessageError(self):
code, content, headers = self.RawRequestError('nested_message',
content='{}')
self.assertEquals(400, code)
expected_content = protojson.encode_message(remote.RpcStatus(
state=remote.RpcState.REQUEST_ERROR,
error_message=('Error parsing ProtoRPC request '
'(Unable to parse request content: '
'Message NestedMessage is missing '
'required field a_value)')))
self.assertEquals(util.pad_string(expected_content), content)
self.assertEquals(headers['content-type'], 'application/json')
def render(self, *args, **kwargs):
self.controller.events.before_render(controller=self.controller)
data = self._get_data(default=VoidMessage())
result = unicode(protojson.encode_message(data))
self.controller.response.content_type = 'application/json'
self.controller.response.charset = 'utf-8'
self.controller.response.unicode_body = result
self.controller.events.after_render(controller=self.controller,
result=result)
return self.controller.response
def run(self, *args, **kwargs):
url = GoogleFormsPreprocessor.VIEW_URL.format(self.config.id)
resp = requests.get(url)
assert resp.status_code == 200
html = resp.text
soup = bs4.BeautifulSoup(html, 'html.parser')
soup_content = soup.find(
'div', {'class': 'freebirdFormviewerViewFormContent'})
form_msg = self.parse_form(soup_content)
msg_string_content = protojson.encode_message(form_msg)
json_dict = json.loads(msg_string_content)
self.pod.write_yaml(self.config.path, json_dict)
self.pod.logger.info('Saved -> {}'.format(self.config.path))
def testBadMessageError(self):
code, content, headers = self.RawRequestError('nested_message',
content='{}')
self.assertEquals(400, code)
self.assertEquals(
protojson.encode_message(
remote.RpcStatus(
state=remote.RpcState.REQUEST_ERROR,
error_message=('Error parsing ProtoRPC request '
'(Unable to parse request content: '
'Message NestedMessage is missing '
'required field a_value)'))), content)
self.assertEquals(headers['content-type'], 'application/json')
def testEncodeDateTime(self):
for datetime_string, datetime_vals in (('2012-09-30T15:31:50.262000',
(2012, 9, 30, 15, 31, 50,
262000)),
('2012-09-30T15:31:50.262123',
(2012, 9, 30, 15, 31, 50,
262123)),
('2012-09-30T15:31:50',
(2012, 9, 30, 15, 31, 50, 0))):
decoded_message = protojson.encode_message(
MyMessage(a_datetime=datetime.datetime(*datetime_vals)))
expected_decoding = '{"a_datetime": "%s"}' % datetime_string
self.CompareEncoded(expected_decoding, decoded_message)
def fileset(self):
commit = None
if self.commit:
commit = json.loads(protojson.encode_message(self.commit))
return {
'name': self.name.lower() if self.name else '',
'commit': commit,
'project': {
'nickname': self.project.lower() if self.project else '',
'owner': {
'nickname': self.owner.lower() if self.owner else '',
},
},
}
def NewRequest(
new_request_msg: api_messages.NewMultiCommandRequestMessage
) -> api_messages.RequestMessage:
"""Creates a new request.
Args:
new_request_msg: an api_messages.NewMultiCommandRequest object.
Returns:
A api_messages.Request object.
"""
body = json.loads(protojson.encode_message(new_request_msg)) # pytype: disable=module-attr
res = _GetAPIClient().requests().newMultiCommandRequest(
body=body).execute()
return protojson.decode_message(api_messages.RequestMessage,
json.dumps(res)) # pytype: disable=module-attr
def testErrorWithContent(self):
status = remote.RpcStatus(state=remote.RpcState.REQUEST_ERROR,
error_message='an error')
urllib2.urlopen(mox.Func(self.VerifyRequest)).AndRaise(
urllib2.HTTPError(
'http://whatever', 500, 'An error occured',
{'content-type': 'application/json'},
StringIO.StringIO(protojson.encode_message(status))))
self.mox.ReplayAll()
rpc = self.trans.send_rpc(my_method.remote, self.request)
rpc.wait()
self.assertEquals(remote.RpcState.REQUEST_ERROR, rpc.state)
self.assertEquals('an error', rpc.error_message)
self.assertEquals(None, rpc.error_name)
def testUpdate(self):
test = self._CreateMockTest()
test_msg = messages.Convert(test, messages.Test)
test_msg.name = 'bar'
test_msg.test_resource_defs[
0].params = messages.TestResourceParameters(
decompress_files=['foo'])
data = protojson.encode_message(test_msg)
res = self.app.put('/_ah/api/mtt/v1/tests/%s' % test.key.id(), data)
obj = json.loads(res.body)
self.assertEqual(str(test.key.id()), obj['id'])
self.assertEqual(test_msg.name, obj['name'])
self.assertEqual(
test_msg.test_resource_defs[0].params.decompress_files,
obj['test_resource_defs'][0]['params']['decompress_files'])
def testErrorWithContent(self):
status = remote.RpcStatus(state=remote.RpcState.REQUEST_ERROR,
error_message='an error')
urllib2.urlopen(mox.Func(self.VerifyRequest)).AndRaise(
urllib2.HTTPError('http://whatever',
500,
'An error occured',
{'content-type': 'application/json'},
StringIO.StringIO(protojson.encode_message(status))))
self.mox.ReplayAll()
rpc = self.trans.send_rpc(my_method.remote, self.request)
rpc.wait()
self.assertEquals(remote.RpcState.REQUEST_ERROR, rpc.state)
self.assertEquals('an error', rpc.error_message)
self.assertEquals(None, rpc.error_name)
def testRequestEventMessage_legacyClientCompatibility(self):
"""Tests whether RequestEventMessage is compatible with legacy clients."""
request = datastore_entities.Request(
id='request_id',
user='******',
command_infos=[
datastore_entities.CommandInfo(command_line='command_line')
])
message = api_messages.RequestEventMessage(
type='request_state_changed',
request_id=request.key.id(),
new_state=common.RequestState.RUNNING,
request=datastore_entities.ToMessage(request))
obj = json.loads(protojson.encode_message(message))
self.assertEqual('request_state_changed', obj.get('type'))
self.assertEqual('request_id', obj.get('request_id'))
self.assertEqual('RUNNING', obj.get('new_state'))
def __write_error(self, status_code, error_message=None):
"""Return the HTTP status line and body for a given error code and message.
Args:
status_code: HTTP status code to be returned.
error_message: Error message to be returned.
Returns:
Tuple (http_status, body):
http_status: HTTP status line, e.g. 200 OK.
body: Body of the HTTP request.
"""
if error_message is None:
error_message = httplib.responses[status_code]
status = '%d %s' % (status_code, httplib.responses[status_code])
message = EndpointsErrorMessage(
state=EndpointsErrorMessage.State.APPLICATION_ERROR,
error_message=error_message)
return status, protojson.encode_message(message)
def __write_error(self, status_code, error_message=None):
"""Return the HTTP status line and body for a given error code and message.
Args:
status_code: HTTP status code to be returned.
error_message: Error message to be returned.
Returns:
Tuple (http_status, body):
http_status: HTTP status line, e.g. 200 OK.
body: Body of the HTTP request.
"""
if error_message is None:
error_message = httplib.responses[status_code]
status = '%d %s' % (status_code, httplib.responses[status_code])
message = EndpointsErrorMessage(
state=EndpointsErrorMessage.State.APPLICATION_ERROR,
error_message=error_message)
return status, protojson.encode_message(message)
def save_stats(self, stats):
"""Merges a list of stats into the translator stats file."""
if self.pod.file_exists(Translator.TRANSLATOR_STATS_PATH):
content = self.pod.read_yaml(Translator.TRANSLATOR_STATS_PATH)
create = False
else:
content = {}
create = True
if self.KIND not in content:
content[self.KIND] = {}
for stat in copy.deepcopy(stats):
stat_json = json.loads(protojson.encode_message(stat))
lang = stat_json.pop('lang')
content[self.KIND][lang] = stat_json
yaml_content = yaml.safe_dump(content, default_flow_style=False)
self.pod.write_file(Translator.TRANSLATOR_STATS_PATH, yaml_content)
if create:
self.pod.logger.info('Saved: {}'.format(Translator.TRANSLATOR_STATS_PATH))
else:
self.pod.logger.info('Updated: {}'.format(Translator.TRANSLATOR_STATS_PATH))
def add_by_key(self, key, obj, timeout=None, message_type=None):
"""
Adds a value to the cache
Encodes protorpc messages
"""
if timeout is None:
timeout = self.default_timeout
if message_type:
obj = encode_message(obj)
try:
return self.cache.add(key,
obj,
version=self.version,
timeout=timeout)
except ValueError as e:
# might have exceeded the key/value memcache size limit
logging.debug(e)
def run(self, *args, **kwargs):
url = GoogleFormsPreprocessor.VIEW_URL.format(self.config.id)
resp = requests.get(url)
if resp.status_code != 200:
raise Error('Error requesting -> {}'.format(url))
html = resp.text
if SIGN_IN_PAGE_SENTINEL in html:
raise Error(
'Error requesting -> {} -> Are you sure the form is publicly'
' viewable?'.format(url))
soup = bs4.BeautifulSoup(html, 'html.parser')
soup_content = soup.find(
'div', {'class': 'freebirdFormviewerViewFormContent'})
form_msg = self.parse_form(soup_content)
msg_string_content = protojson.encode_message(form_msg)
json_dict = json.loads(msg_string_content)
if self.config.translate:
json_dict = self.tag_keys_for_translation(json_dict)
self.pod.write_yaml(self.config.path, json_dict)
self.pod.logger.info('Saved -> {}'.format(self.config.path))
def _get_stats_to_download(self, locales):
# 'stats' maps the service name to a mapping of languages to stats.
if not self.pod.file_exists(Translator.TRANSLATOR_STATS_PATH):
return {}
stats = self.pod.read_yaml(Translator.TRANSLATOR_STATS_PATH)
if self.KIND not in stats:
self.pod.logger.info(
'Nothing found to download from {}'.format(self.KIND))
return {}
stats_to_download = stats[self.KIND]
if locales:
stats_to_download = dict([(lang, stat)
for (lang, stat) in stats_to_download.iteritems()
if lang in locales])
for lang, stat in stats_to_download.iteritems():
if isinstance(stat, TranslatorStat):
stat = json.loads(protojson.encode_message(stat))
stat['lang'] = lang
stat_message = protojson.decode_message(TranslatorStat, json.dumps(stat))
stats_to_download[lang] = stat_message
return stats_to_download
def testHandleObjectStateChangeEvent_requestEvent(self):
request = self._CreateTestRequest(state=common.RequestState.COMPLETED)
event_message = api_messages.RequestEventMessage(
type=common.ObjectEventType.REQUEST_STATE_CHANGED,
request_id=REQUEST_ID,
new_state=common.RequestState.COMPLETED,
request=datastore_entities.ToMessage(request),
summary='summary',
total_test_count=0,
failed_test_count=0,
passed_test_count=0,
failed_test_run_count=0,
result_links=[self.result_link],
total_run_time_sec=3,
event_time=TIMESTAMP)
self.testapp.post(
notifier.OBJECT_EVENT_QUEUE_HANDLER_PATH,
protojson.encode_message(event_message))
self._AssertMessagePublished(
event_message, notifier.REQUEST_EVENT_PUBSUB_TOPIC)
def PublishMessage(device_note_message, event_type):
"""Publish device note event message to pubsub."""
if not env_config.CONFIG.use_google_api:
logging.warning(
"Unabled to send device note message to pubsub: use_google_api=False"
)
return
device_note_message.publish_timestamp = _Now()
encoded_message = protojson.encode_message(device_note_message) # pytype: disable=module-attr
data = common.UrlSafeB64Encode(encoded_message)
if event_type == common.PublishEventType.DEVICE_NOTE_EVENT:
data_type = "deviceNote"
topic = DEVICE_NOTE_PUBSUB_TOPIC
else:
data_type = "hostNote"
topic = HOST_NOTE_PUBSUB_TOPIC
_PubsubClient.PublishMessages(topic, [{
"data": data,
"attributes": {
"type": data_type,
}
}])
def save_stats(self, stats):
"""Merges a list of stats into the translator stats file."""
if self.pod.file_exists(Translator.TRANSLATOR_STATS_PATH):
content = self.pod.read_yaml(Translator.TRANSLATOR_STATS_PATH)
create = False
else:
content = {}
create = True
if self.KIND not in content:
content[self.KIND] = {}
for stat in copy.deepcopy(stats):
stat_json = json.loads(protojson.encode_message(stat))
lang = stat_json.pop('lang')
content[self.KIND][lang] = stat_json
yaml_content = yaml.safe_dump(content, default_flow_style=False)
self.pod.write_file(Translator.TRANSLATOR_STATS_PATH, yaml_content)
if create:
self.pod.logger.info('Saved: {}'.format(
Translator.TRANSLATOR_STATS_PATH))
else:
self.pod.logger.info('Updated: {}'.format(
Translator.TRANSLATOR_STATS_PATH))
def to_string(cls, message): return protojson.encode_message(message)
def translator_stat_representer(dumper, stat):
content = json.loads(protojson.encode_message(stat))
content.pop('lang') # Exclude from serialization.
return dumper.represent_mapping('tag:yaml.org,2002:map', content)
def to_string(self): return protojson.encode_message(self.to_message())
def testEncodeCustom(self):
decoded_message = protojson.encode_message(MyMessage(a_custom=1))
self.CompareEncoded('{"a_custom": 1}', decoded_message)
def json_encode_proto(proto_message): return protojson.encode_message(proto_message)
def encode_message_to_json(value): return encode_message(value)
