Method analyze_function

src/function_analyzer.py:58–172

Returns an OpenAI API compatible description using a functions docstring and type hints. Assumptions: * The docstring can be in various formats, e.g. REST where arguments are documented like ':param x:'. * The docstring's short description and long description will b

(self, function_: Callable)

        )

    def analyze_function(self, function_: Callable) -> dict:
        """
        Returns an OpenAI API compatible description using a functions docstring and type hints.
        Assumptions:
        * The docstring can be in various formats, e.g. REST where arguments are documented like ':param x:'.
        * The docstring's short description and long description will be concatenated with a space.
        * Newlines in the description will be replaced with space.
        * All arguments of the function must have a type hint. Only simple types are supported.
        * All arguments of the function must be documented in the docstring.
        * 'self' and 'return' are neglected if appearing in arguments, type hints, or docstring.
        """
        function_name = function_.__name__

        # Directly return if an override tool description was provided.
        if function_name in self.override_tool_descriptions:
            if function_name in self.override_docstrings:
                raise AssertionError(
                    f"Function '{function_name}' has an override for docstring and tool description."
                )
            return self.override_tool_descriptions[function_name]

        # Get all the arguments of the function. Remove 'self'.
        arguments = inspect.getfullargspec(function_).args
        if "self" in arguments:
            arguments.remove("self")

        # Get the type hints of the arguments. Remove 'return' and 'self'.
        type_hints = typing.get_type_hints(function_)
        type_hints.pop("return", None)
        type_hints.pop("self", None)

        # Check that each argument has a type hint.
        if any(argument not in type_hints for argument in arguments):
            raise AssertionError(
                f"Function '{function_name}' has arguments '{arguments}' but type hints only for '{type_hints}'."
            )

        # Get well-defined arguments.
        well_defined_arguments = [
            argument
            for argument, type_ in type_hints.items()
            if not (
                typing.get_origin(type_) is Union
                and type(None) in typing.get_args(type_)
            )
        ]
        # Get required arguments.
        signature = inspect.signature(function_)
        required_arguments = [
            arg
            for arg in well_defined_arguments
            if signature.parameters.get(arg).default is inspect.Parameter.empty
        ]
        # Convert type hints to basic types.
        type_hints_basic = {
            argument: (
                type_
                if argument in well_defined_arguments