- [ ] Write a pull request description that is detailed enough to understand what the pull request does, how, and why.
 - [ ] Run `mvn clean verify` to make sure basic checks pass. A more thorough check will
       be performed on your pull request automatically.
 - [ ] You have run the [Core IT][core-its] successfully.

If your pull request is about ~20 lines of code you don't need to sign an

    val functionFqName = "$qualifiedBaseName.${method.name}"

    return collectDescendantsOfType { ktFunction ->
        // Name check
        if (ktFunction.fqName?.asString() != functionFqName) {
            return@collectDescendantsOfType false
        }

        // Preliminary extension function check
        val extensionCandidate = couldBeExtensionFunction && ktFunction.receiverTypeReference != null &&

```Python hl_lines="7"
{!../../../docs_src/path_params/tutorial002.py!}
```

Bu durumda, `item_id` bir `int` olarak tanımlanacaktır.

!!! check "Ek bilgi"
    Bu sayede, fonksiyon içerisinde hata denetimi, kod tamamlama gibi konularda editör desteğine kavuşacaksınız.

## Veri <abbr title="Dönüşüm: serialization, parsing ve marshalling olarak da biliniyor">Dönüşümü</abbr>

It just returns a JSON response with the result of the application's `.openapi()` method.

By default, what the method `.openapi()` does is check the property `.openapi_schema` to see if it has contents and return them.

If it doesn't, it generates them using the utility function at `fastapi.openapi.utils.get_openapi`.

        }

        override fun nanoTime() = nanoTime

        override fun coordinatorNotify(taskRunner: TaskRunner) {
          taskRunner.assertThreadHoldsLock()
          check(waitingCoordinatorTask != null)

          // Queue a task to resume the waiting coordinator.
          serialTaskQueue +=
            object : SerialTask {
              override fun start() {

  duration: Long,
  unit: TimeUnit,
): Int {
  check(duration >= 0L) { "$name < 0" }
  val millis = unit.toMillis(duration)
  require(millis <= Integer.MAX_VALUE) { "$name too large" }
  require(millis != 0L || duration <= 0L) { "$name too small" }
  return millis.toInt()
}

internal fun checkDuration(
  name: String,
  duration: Duration,
): Int {
  check(!duration.isNegative()) { "$name < 0" }

class KtFirArrayAccessReference(
    expression: KtArrayAccessExpression
) : KtArrayAccessReference(expression), KtFirReference {
    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
        check(this is KtFirAnalysisSession)
        val fir = element.getOrBuildFir(firResolveSession) ?: return emptyList()
        return when (fir) {

    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
    override fun restoreSymbol(analysisSession: KtAnalysisSession): KtNamedClassOrObjectSymbol? {
        check(analysisSession is KtFe10AnalysisSession)
        val analysisContext = analysisSession.analysisContext

      if (ia.hasNext()) {
        add(ia.next())
      }
      if (ib.hasNext()) {
        add(ib.next())
      }
    }
  }
}

// TODO check read only options for creating lists
public fun <T> List<T>.readOnly() = this.toList()

// TODO check read only options for creating lists

        response.contentType()?.parameter("boundary")
          ?: throw ProtocolException("expected the Content-Type to have a boundary parameter"),
    )

    @Throws(IOException::class)
    fun nextPart(): Part? {
      check(!closed) { "closed" }

      if (noMoreParts) return null

      // Read a boundary, skipping the remainder of the preceding part as necessary.
      if (partCount == 0 && source.rangeEquals(0L, dashDashBoundary)) {