def test_get_method_type_stub(self) -> None: assert get_method_type_stub(ServiceNameCatalog.s3, "Client", "copy_object", "CopySource") assert get_method_type_stub(ServiceNameCatalog.ec2, "Client", "create_tags", "Resources") assert (get_method_type_stub(ServiceNameCatalog.s3, "Client", "copy_object", "Unknown") is None) assert (get_method_type_stub(ServiceNameCatalog.logs, "Client", "copy_object", "Unknown") is None)
def test_get_method_type_stub(self) -> None: self.assertTrue( get_method_type_stub(ServiceNameCatalog.s3, "Client", "copy_object", "CopySource")) self.assertTrue( get_method_type_stub(ServiceNameCatalog.ec2, "Any", "create_tags", "Resources")) self.assertIsNone( get_method_type_stub(ServiceNameCatalog.s3, "Client", "copy_object", "Unknown")) self.assertIsNone( get_method_type_stub(ServiceNameCatalog.logs, "Client", "copy_object", "Unknown"))
def _parse_arguments( self, class_name: str, method_name: str, operation_name: str, shape: StructureShape, ) -> List[Argument]: result: List[Argument] = [] required = shape.required_members for argument_name, argument_shape in shape.members.items(): argument_alias = self._get_argument_alias(operation_name, argument_name) if argument_alias == "None": continue argument_type_stub = get_method_type_stub( self.service_name, class_name, method_name, argument_name ) if argument_type_stub is not None: argument_type = argument_type_stub else: argument_type = self._parse_shape(argument_shape) argument = Argument(argument_alias, argument_type) if argument_name not in required: argument.default = Type.none result.append(argument) result.sort(key=lambda x: not x.required) return result
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 get_return_type(self, class_name: str, method_name: str) -> Optional[FakeAnnotation]: type_stub = get_method_type_stub(self.service_name, class_name, method_name, "return") if type_stub: return type_stub return None
def get_return_type(self, class_name: str, method_name: str) -> FakeAnnotation | None: """ Get `class_name.method_name` return type annotation. """ type_stub = get_method_type_stub(self.service_name, class_name, method_name, "return") if type_stub: return type_stub return None
def _parse_return_type(self, class_name: str, method_name: str, shape: Shape | None) -> FakeAnnotation: argument_type_stub = get_method_type_stub(self.service_name, class_name, method_name, "return") if argument_type_stub is not None: return argument_type_stub if shape: return self.parse_shape(shape, output=True) return Type.none
def _parse_return_type(self, class_name: str, method_name: str, shape: Optional[Shape]) -> FakeAnnotation: argument_type_stub = get_method_type_stub(self.service_name, class_name, method_name, "return") if argument_type_stub is not None: return argument_type_stub if shape: return self._parse_shape(shape) return Type.none
def get_arguments(self, class_name: str, method_name: str, func: FunctionType) -> List[Argument]: arguments = self._get_arguments_from_argspec(func) for argument in arguments: if argument.type_annotation is not Type.Any: continue type_stub = get_method_type_stub(self.service_name, class_name, method_name, argument.name) if type_stub is not None: argument.type_annotation = type_stub return arguments
def get_arguments(self, class_name: str, method_name: str, func: MethodType) -> list[Argument]: """ Get arguments from `class_name.method_name` method `func`. """ arguments = self._get_arguments_from_argspec(func) for argument in arguments: if argument.type_annotation is not Type.Any: continue type_stub = get_method_type_stub( self.service_name, class_name, method_name, argument.name ) if type_stub is not None: argument.type_annotation = type_stub return arguments
def _parse_arguments( self, class_name: str, method_name: str, operation_name: str, shape: StructureShape, exclude_names: Iterable[str] = tuple(), optional_only: bool = False, ) -> list[Argument]: result: list[Argument] = [] required = shape.required_members for argument_name, argument_shape in shape.members.items(): if argument_name in exclude_names: continue argument_alias = self._get_argument_alias(operation_name, argument_name) if argument_alias == "None": continue argument_type_stub = get_method_type_stub(self.service_name, class_name, method_name, argument_name) if argument_type_stub is Type.RemoveArgument: continue if argument_type_stub is not None: argument_type = argument_type_stub else: argument_type = self.parse_shape(argument_shape) argument = Argument(argument_alias, argument_type) if argument_name not in required: argument.default = Type.Ellipsis if optional_only and argument.required: continue # FIXME: https://github.com/boto/boto3/issues/2813 # if not argument.required and argument.type_annotation: # argument.type_annotation = Type.get_optional(argument.type_annotation) result.append(argument) result.sort(key=lambda x: not x.required) return result
def parse_attributes( service_name: ServiceName, resource_name: str, resource: Boto3ServiceResource, shape_parser: ShapeParser, ) -> 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 if not resource.meta.resource_model.shape: return result service_model = resource.meta.client.meta.service_model shape = service_model.shape_for(resource.meta.resource_model.shape) attributes = resource.meta.resource_model.get_attributes(shape) for name, attribute in attributes.items(): attribute_type = get_method_type_stub(service_name, resource_name, "_attributes", name) if attribute_type is None: attribute_shape = attribute[1] attribute_type = shape_parser.parse_shape(attribute_shape, output=True) result.append(Attribute(name, attribute_type)) return result
def _parse_arguments( self, class_name: str, method_name: str, operation_name: str, shape: StructureShape, exclude_names: Iterable[str] = tuple(), optional_only: bool = False, ) -> List[Argument]: result: List[Argument] = [] required = shape.required_members for argument_name, argument_shape in shape.members.items(): if argument_name in exclude_names: continue argument_alias = self._get_argument_alias(operation_name, argument_name) if argument_alias == "None": continue argument_type_stub = get_method_type_stub(self.service_name, class_name, method_name, argument_name) if argument_type_stub is Type.RemoveArgument: continue if argument_type_stub is not None: argument_type = argument_type_stub else: argument_type = self._parse_shape(argument_shape) argument = Argument(argument_alias, argument_type) if argument_name not in required: argument.default = Type.none if optional_only and argument.required: continue result.append(argument) result.sort(key=lambda x: not x.required) return result