def get_client_method_map(self) -> dict[str, Method]: """ Get client methods from shape. Returns: A map of method name to Method. """ result: dict[str, Method] = { "can_paginate": Method( "can_paginate", [Argument("self", None), Argument("operation_name", Type.str)], Type.bool, ), "generate_presigned_url": Method( "generate_presigned_url", [ Argument("self", None), Argument("ClientMethod", Type.str), Argument("Params", Type.MappingStrAny, Type.Ellipsis), Argument("ExpiresIn", Type.int, TypeConstant(3600)), Argument("HttpMethod", Type.str, Type.Ellipsis), ], Type.str, ), } for operation_name in self._get_operation_names(): operation_model = self._get_operation(operation_name) arguments: list[Argument] = [Argument("self", None)] method_name = xform_name(operation_name) if operation_model.input_shape is not None: shape_arguments = self._parse_arguments( "Client", method_name, operation_name, operation_model.input_shape, ) arguments.extend( self._get_kw_flags(method_name, shape_arguments)) arguments.extend(shape_arguments) return_type = self._parse_return_type("Client", method_name, operation_model.output_shape) method = Method(name=method_name, arguments=arguments, return_type=return_type) if operation_model.input_shape: method.request_type_annotation = method.get_request_type_annotation( self._get_typed_dict_name(operation_model.input_shape, postfix="Request")) result[method.name] = method return result
def _get_resource_method(self, resource_name: str, action_name: str, action_shape: dict[str, Any]) -> Method: return_type: FakeAnnotation = Type.none method_name = xform_name(action_name) arguments: list[Argument] = [Argument("self", None)] if "resource" in action_shape: return_type = self._parse_return_type( resource_name, method_name, Shape("resource", action_shape["resource"])) path = action_shape["resource"].get("path", "") if path.endswith("[]"): return_type = TypeSubscript(Type.List, [return_type]) operation_shape = None if "request" in action_shape: operation_name = action_shape["request"]["operation"] operation_shape = self._get_operation(operation_name) skip_argument_names = { self._get_arg_from_target(i["target"]) for i in action_shape["request"].get("params", {}) if i["source"] == "identifier" } if operation_shape.input_shape is not None: shape_arguments = self._parse_arguments( resource_name, method_name, operation_name, operation_shape.input_shape, exclude_names=skip_argument_names, ) arguments.extend( self._get_kw_flags(method_name, shape_arguments)) arguments.extend(shape_arguments) if operation_shape.output_shape is not None and return_type is Type.none: operation_return_type = self.parse_shape( operation_shape.output_shape, output=True) return_type = operation_return_type method = Method(name=method_name, arguments=arguments, return_type=return_type) if operation_shape and operation_shape.input_shape is not None: method.request_type_annotation = method.get_request_type_annotation( self._get_typed_dict_name(operation_shape.input_shape, postfix=resource_name)) return method
def parse_method( parent_name: str, name: str, method: MethodType, service_name: ServiceName ) -> Method: """ Parse method to a structure. Arguments: parent_name -- Parent class name. method -- Inspect method. Returns: Method structure. """ logger = get_logger() docstring = textwrap.dedent(inspect.getdoc(method) or "") method_name = f"{parent_name}.{name}" logger.debug(f"Slow parsing of {method_name}: {len(docstring)} chars") prefix = f"{get_class_prefix(parent_name)}{get_class_prefix(name)}" arg_spec_parser = ArgSpecParser(prefix, service_name) arguments = get_method_arguments_stub(service_name, parent_name, name) if arguments is None: arguments = arg_spec_parser.get_arguments(parent_name, name, method) docstring_parser = DocstringParser(service_name, parent_name, name, arguments) arguments = docstring_parser.get_arguments(docstring) # do not add kwonly flag to resource generators if len(arguments) > 1 and not name[0].isupper(): arguments.insert(1, Argument.kwflag()) return_type = arg_spec_parser.get_return_type(parent_name, name) if return_type is None: return_type = DocstringParser(service_name, parent_name, name, []).get_return_type( docstring ) result = Method(name=name, arguments=arguments, return_type=return_type) result.request_type_annotation = result.get_request_type_annotation( f"{parent_name}{get_class_prefix(name)}RequestTypeDef" ) return result