def module_level_function(param1, param2=None, *args, **kwargs):
    """Evaluate to true if any paramaters are greater than 100.

    This is an example of a module level function.

    Function parameters should be documented in the ``Parameters`` section.
    The name of each parameter is required. The type and description of each
    parameter is optional, but should be included if not obvious.

    This example function calculates if any of the params are greater than
    a target value of 100, and if so returns True

    If *args or **kwargs are accepted,
    they should be listed as ``*args`` and ``**kwargs``.

    The format for a parameter is::

        name : type
            description

            The description may span multiple lines. Following lines
            should be indented to match the first line of the description.
            The ": type" is optional.

            Multiple paragraphs are supported in parameter
            descriptions.

    Parameters
    ----------
    param1 : int
        The first parameter.
    param2 : :obj:`str`, optional
        The second parameter.
    *args
        Variable length argument list.
    **kwargs
        Arbitrary keyword arguments.

    Returns
    -------
    bool
        True if successful, False otherwise.

        The return type is not optional. The ``Returns`` section may span
        multiple lines and paragraphs. Following lines should be indented to
        match the first line of the description.

        The ``Returns`` section supports any reStructuredText formatting,
        including literal blocks::

            {
                'param1': param1,
                'param2': param2
            }

    Raises
    ------
    AttributeError
        The ``Raises`` section is a list of all exceptions
        that are relevant to the interface.
    ValueError
        If `param2` is equal to `param1`.
    ValueError
        If `param2` is not a string
    """
    if param1 == param2:
        print(f"param1: {param1}, param2: {param2}")
        error_message = "param1 may not be equal to param2"
        print(error_message)
        raise ValueError(error_message)
    # Collect the params and find the max value
    value_list = []
    value_list.append(param1)
    if param2:
        if not isinstance(param2, str):
            error_message = "param2 must be a string"
            print(error_message)
            raise ValueError(error_message)
        else:
            converted_param2 = int(param2)
            value_list.append(converted_param2)

    if args:
        for x in args:
            if not isinstance(x, int):
                error_message = "args values must be integers"
                print(error_message)
                raise ValueError(error_message)
            value_list.append(x)
    if kwargs:
        print("Metadata content")
        for key, value in kwargs.items():
            print(f"{key}: {value}")
            if key == "verbose" and value is True:
                print("Additional verbose output: ......................")

    # Find max value from the compiled list
    max_value = max(value_list)
    print(
        f"param1: {param1}, param2: {param2}, args: {args}, "
        f"kwargs: {kwargs}. Max value: {max_value}"
    )

    # Function returns True if any of the params are greater than 100
    target_value = 100
    if max_value > target_value:
        return True
    else:
        return False