def parse_attributes(
service_name: ServiceName, resource_name: str, resource: Boto3ServiceResource
) -> List[Attribute]:
"""
Extract attributes from boto3 resource.
Arguments:
resource -- boto3 service resource.
Returns:
A list of Attribute structures.
"""
result: List[Attribute] = []
if not resource.meta.client:
return result
if not resource.meta.resource_model:
return result
service_model = resource.meta.client.meta.service_model
if resource.meta.resource_model.shape:
shape = service_model.shape_for(resource.meta.resource_model.shape)
attributes = resource.meta.resource_model.get_attributes(shape)
for name, attribute in attributes.items():
argument_type = get_method_type_stub(service_name, resource_name, "_attributes", name)
if argument_type is None:
argument_type = get_type_from_docstring(attribute[1].type_name)
result.append(Attribute(name, argument_type))
return result
def _parse_types(self, input_string: str) -> None:
if ":type " not in input_string:
return
type_strings = [
i for i in input_string.split("\n") if i.startswith(":type ")
]
TypeDocGrammar.reset()
for type_string in type_strings:
try:
match = TypeDocGrammar.type_definition.parseString(type_string)
except ParseException as e:
self.logger.warning(
f"Cannot parse type definition {type_string} for {self.prefix}"
)
self.logger.debug(e)
continue
match_dict = match.asDict()
argument_name = match_dict["name"]
type_str = match_dict["type_name"]
argument = self._find_argument_or_append(argument_name)
type_stub = get_method_type_stub(self.service_name,
self.class_name, self.method_name,
argument_name)
if type_stub:
argument.type = type_stub
else:
argument.type = get_type_from_docstring(type_str)
def _parse_rtype(self, input_string: str) -> Optional[FakeAnnotation]:
if ":rtype: " not in input_string:
return None
TypeDocGrammar.reset()
rtype_string = input_string[input_string.index(":rtype: ") :].split("\n", 1)[0]
try:
match = TypeDocGrammar.rtype_definition.parseString(rtype_string)
except ParseException as e:
self.logger.warning(f"Cannot parse rtype for {self.prefix}: {e}")
return None
type_name = match.asDict()["type_name"]
return get_type_from_docstring(type_name)
def _fix_keys_typed_dict(
self, typed_dict: TypeTypedDict, argument_line: TypeDocLine,
) -> None:
for line in argument_line.indented:
if not line.name:
continue
attribute = typed_dict.get_attribute(line.name)
attribute.required = line.required
if attribute.type_annotation is Type.Any:
attribute.type_annotation = get_type_from_docstring(line.type_name)
if not line.indented:
continue
self._fix_keys(attribute.type_annotation, line)
def test_get_type_from_docstring(self) -> None:
self.assertTrue(get_type_from_docstring("bytes"))
with self.assertRaises(ValueError):
get_type_from_docstring("unknown")
def test_get_type_from_docstring(self) -> None:
assert get_type_from_docstring("bytes")
with pytest.raises(ValueError):
get_type_from_docstring("unknown")