!!! info "`@decorator` Info"
    That `@something` syntax in Python is called a "decorator".

    You put it on top of a function. Like a pretty decorative hat (I guess that's where the term came from).

    A "decorator" takes the function below and does something with it.

                abstract DirectoryProperty getSources()

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                void doSomething() {
                    outputFile.get().asFile.text = "executed"
                }
            }

            tasks.register("taskWithInputs", TaskWithInputs) {
                sources.set(file("inputDir"))

            .configuration('something')
            .dependsOn(b, conf: 'something->unknown')
            .publish()

        buildFile << """
configurations {
    compile
}
repositories {
    ivy { url "${ivyRepo.uri}" }
}
dependencies {
    compile group: 'test', name: 'target', version: '1.0', configuration: 'something'
}
task retrieve(type: Sync) {

        def failingTestDetails = failingClassFile.testDetails('failed')
        failingTestDetails.assertDuration("1.000s")
        failingTestDetails.assertFailed()

        failingClassFile.assertHasFailure('failed', 'something failed\n\nthis is the failure\nat someClass\n')

        where:
        numThreads << [1, 4]
    }

    def "aggregate same tests run with different results - #numThreads parallel thread(s)"() {
        given:

		return fallbackOrder, nil
	}

	// Try to figure out the order to use for searches.
	// If we don't recognize something, use fallbackOrder.
	// That will use cgo unless the Go resolver was explicitly requested.
	// If we do figure out the order, return something other
	// than fallbackOrder to use the Go resolver with that order.

	dnsConf = getSystemDNSConfig()

            library {
                dependencies {
                    something("com.google.guava:guava:30.1.1-jre")
                    somethingElse("org.apache.commons:commons-lang3:3.12.0")
                }
            }
        """
        file("settings.gradle") << defineSettings()

        expect: "a dependency has been added to the something configuration"
        succeeds("dependencies", "--configuration", "myConf")

    }

    def "logs generic deprecation message for specific thing"() {
        when:
        DeprecationLogger.deprecate("Something").willBeRemovedInGradle9().undocumented().nagUser()

        then:
        expectMessage "Something has been deprecated. This is scheduled to be removed in Gradle ${NEXT_GRADLE_VERSION}."
    }

    def "logs deprecated behavior message"() {
        when:

A "**callable**" in Python is anything that Python can "call" like a function.

So, if you have an object `something` (that might _not_ be a function) and you can "call" it (execute it) like:

```Python
something()
```

or

```Python
something(some_argument, some_keyword_argument="foo")
```

then it is a "callable".

## Classes as dependencies

    "servers": [
        {
            "url": "/api/v1"
        }
    ],
    "paths": {
            // More stuff here
    }
}
```

In this example, the "Proxy" could be something like **Traefik**. And the server would be something like FastAPI CLI with **Uvicorn**, running your FastAPI application.

### Providing the `root_path`

To achieve this, you can use the command line option `--root-path` like:

<div class="termy">

                contextualLabel == 'Type \'MyTask\' method \'notAGetter()\' should not be annotated with: @Input'
                details == 'Input/Output annotations are ignored if they are placed on something else than a getter'
                solutions == [
                    'Remove the annotations',
                    'Rename the method',
                ]