tasks.withType<Javadoc>().configureEach {
    assert(name != "javadocAll") // This plugin should not be applied to the :docs project.

    onlyIf("Do not run the task if there are no java sources") {
        // Javadoc task will complain if we only have package-info.java files and no
        // other java files (as is with some Kotlin projects)
        !source.matching {
            exclude("**/package-info.java")
        }.isEmpty
    }

the arguments to the function for it to work correctly, otherwise the values will be different from what you expect (e.g. `QueryInfo` or something similar instead of `str`). And your editor won't complain, and Python won't complain running that function, only when the operations inside error out.

Because `Annotated` can have more than one metadata annotation, you could now even use the same function with other tools, like <a href="https://typer.tiangolo.com/" class="external-link" targe...

If you added the return type annotation, tools and editors would complain with a (correct) error telling you that your function is returning a type (e.g. a dict) that is different from what you declared (e.g. a Pydantic model).

    PeekingIterator<?> peekingIterator = peekingIterator(iterator);

    assertEquals("A", peekingIterator.next());
    assertEquals("B", peekingIterator.peek());

    /* Should complain on attempt to remove() after peek(). */
    assertThrows(IllegalStateException.class, () -> peekingIterator.remove());

    assertEquals(

But you still need to use `Path` for the `item_id` path parameter. And you don't want to use `Annotated` for some reason.

Python will complain if you put a value with a "default" before a value that doesn't have a "default".

But you can re-order them, and have the value without a default (the query parameter `q`) first.

    PeekingIterator<?> peekingIterator = peekingIterator(iterator);

    assertEquals("A", peekingIterator.next());
    assertEquals("B", peekingIterator.peek());

    /* Should complain on attempt to remove() after peek(). */
    assertThrows(IllegalStateException.class, () -> peekingIterator.remove());

    assertEquals(

    class DoShareEnumValidation {

        static Stream<Arguments> invalidShareEnumCases() {
            return Stream.of(
                    // Missing trailing slash -> should complain about directory ending
                    Arguments.of("smb://server/share", "/share", true),
                    // Not a server root -> invalid list operation

	// we unset the env. vars if they are set but empty or contain a path
	// which does not exist. The downside of this check is that if
	// MINIO_KMS_SECRET_KEY_FILE is set to a path that does not exist,
	// the server does not complain and start without a KMS config.
	//
	// Until the container image changes, this behavior has to be preserved.
	if isPresent(EnvKMSSecretKey) && os.Getenv(EnvKMSSecretKey) == "" {
		os.Unsetenv(EnvKMSSecretKey)
	}

   * getAnnotatedBounds()} method, then its return type means it won't compile on Android, while if
   * we don't include the method, then the compiler will complain that an abstract method is
   * unimplemented. So instead we use a dynamic proxy to get an implementation. If the method being
   * called on the {@code TypeVariable} instance has the same name as one of the public methods of

Now we use `response_model=HeroPublic` instead of the **return type annotation** `-> HeroPublic` because the value that we are returning is actually *not* a `HeroPublic`.

If we had declared `-> HeroPublic`, your editor and linter would complain (rightfully so) that you are returning a `Hero` instead of a `HeroPublic`.