def __repr__(self):
return '{}({})'.format(
get_class_name(self), ', '.join([
f'name={self.name}',
f'method={self.decorator.method.upper()}',
f'routes={self.decorator.routes}',
]))
def emit(self, field, field_no):
field_type_name = get_class_name(field.schema_type)
if field_type_name.endswith('Schema'):
field_type_name = field_type_name[:-len('Schema')]
return super().emit(
field_type=field_type_name,
field_no=field_no,
field_name=field.name,
)
def emit(self, field, field_no, is_repeated=False):
field_type_name = get_class_name(field)
if field_type_name.endswith('Schema'):
field_type_name = field_type_name[:-len('Schema')]
return super().emit(
field_type=field_type_name,
field_no=field_no,
field_name=field.name,
is_repeated=is_repeated
)
def get_stripped_schema_name(obj):
if isinstance(obj, Schema):
name = get_class_name(obj)
else:
assert isinstance(obj, str)
name = obj
if name.endswith('Schema'):
return name[:-len('Schema')]
else:
return name
def _on_bootstrap_aggregate_response_message_types(self):
"""
Build a lookup table of protobuf response Message types for use when
routing requests to their downstream actions.
"""
grpc = self.grpc
grpc.response_types = {}
for action in self.actions.values():
schema_type_name = get_class_name(action.schemas.response)
message_type_name = get_stripped_schema_name(
StringUtils.camel(schema_type_name))
response_message_type = getattr(self.grpc.pb2, message_type_name)
grpc.response_types[action.name] = response_message_type
def __repr__(self):
name = get_class_name(self)
dirty = '*' if self.is_dirty else ''
id_value = self.internal.state.get(ID)
if id_value is None:
id_str = '?'
elif isinstance(id_value, str):
id_str = id_value[:7]
elif isinstance(id_value, uuid.UUID):
id_str = id_value.hex[:7]
else:
id_str = repr(id_value)
return f'{name}({id_str}){dirty}'
def emit(self, field, field_no):
try:
adapter = self.msg_gen.get_adapter(field.nested)
except:
import ipdb; ipdb.set_trace()
try:
if isinstance(adapter, SchemaFieldAdapter):
nested_field_type = get_class_name(field.nested),
elif isinstance(adapter, NestedFieldAdapter):
nested_field_type = get_class_name(field.nested.schema_type)
else:
nested_field_type = adapter.type_name
except:
raise Exception('Unable to establish nested field type')
if nested_field_type.endswith('Schema'):
nested_field_type = nested_field_type[:-len('Schema')]
return super().emit(
field_type=nested_field_type,
field_no=field_no,
field_name=field.name,
is_repeated=True,
)
def create(self, record: dict) -> dict:
record[self.id_column_name] = self.create_id(record)
prepared_record = self.prepare(record, serialize=True)
insert_stmt = self.table.insert().values(**prepared_record)
_id = prepared_record.get('_id', '')
console.debug(f'SQL: INSERT {str(_id)[:7] + " " if _id else ""}'
f'INTO {self.table}')
try:
if self.supports_returning:
insert_stmt = insert_stmt.return_defaults()
result = self.conn.execute(insert_stmt)
return dict(record, **(result.returned_defaults or {}))
else:
result = self.conn.execute(insert_stmt)
return self.fetch(_id=record[self.id_column_name])
except Exception:
console.error(message=f'failed to insert record',
data={
'record': record,
'resource': get_class_name(self.resource_type),
})
raise
def class_name(self) -> Text:
return get_class_name(self)
def get_schema_name(schema: 'Schema') -> Text:
name = get_class_name(schema)
if name.endswith('Schema'):
name = name[:-6]
return name