mr: mr,
		closer: func() {
			dec.Reset(nil)
			s2DecPool.Put(dec)
			readMsgpReaderPoolPut(mr)
		},
		creator: func() error {
			v, err := mr.ReadByte()
			if err != nil {
				return err
			}
			switch v {
			case 1, 2:
			default:
				return fmt.Errorf("metacacheReader: Unknown version: %d", v)
			}
			return nil
		},
	}
}

func (r *metacacheReader) checkInit() {

        </IssueNavigationLink>
        <IssueNavigationLink>
          <option name="issueRegexp" value="(\w+)-(CR|MR)-(\d+)" />
          <option name="linkRegexp" value="https://jetbrains.team/p/$1/reviews/$3" />
        </IssueNavigationLink>
        <IssueNavigationLink>
          <option name="issueRegexp" value="KOTLIN-(MR|CR)-(\d+)" />
          <option name="linkRegexp" value="https://kotlin.jetbrains.space/p/kotlin/reviews/$2" />

    return mainFiles.map {
      val suffix = it.path.replace("${prefix}samples/guide/src/main/java/", "")
      suffix.replace("(.*)\\.java".toRegex()) { mr ->
        mr.groupValues[1].replace('/', '.')
      }.replace("(.*)\\.kt".toRegex()) { mr ->
        mr.groupValues[1].replace('/', '.') + "Kt"
      }
    }.sorted()
  }
}

@Disabled("Don't run by default")
@Tag("Slow")
class AllMainsTest {

	for _, item := range readOldToNewCases {
		bs, err := item.je.MarshalMsg(nil)
		if err != nil {
			t.Fatal(err)
		}
		b.Write(bs)
	}

	mr := msgp.NewReader(&b)
	for i, item := range readOldToNewCases {
		var je jentry
		err := je.DecodeMsg(mr)
		if err != nil {
			t.Fatal(err)
		}
		if je != item.exp {
			t.Errorf("Case %d: Expected: %v Got: %v", i, item.exp, je)
		}
	}
}

		logger.LogIf(ctx, fmt.Errorf("tier-journal: failed open read-only journal for processing %s", err))
		return
	}
	defer ro.Close()
	mr := msgpNewReader(ro)
	defer readMsgpReaderPoolPut(mr)

	done := false
	for {
		var entry jentry
		err := entry.DecodeMsg(mr)
		if errors.Is(err, io.EOF) {
			done = true
			break
		}
		if err != nil {

li: Limburgs
ln: Lingála
lo: ພາສາ
lt: lietuvių kalba
lu: Tshiluba
lv: latviešu valoda
mg: fiteny malagasy
mh: Kajin M̧ajeļ
mi: te reo Māori
mk: македонски јазик
ml: മലയാളം
mn: Монгол хэл
mr: मराठी
ms: Bahasa Malaysia
mt: Malti
my: ဗမာစာ
na: Ekakairũ Naoero
nb: Norsk bokmål
nd: isiNdebele
ne: नेपाली
ng: Owambo
nl: Nederlands
nn: Norsk nynorsk
'no': Norsk
nr: isiNdebele

	}
	defer xhttp.DrainBody(respBody)

	pr, pw := io.Pipe()
	go func() {
		pw.CloseWithError(waitForHTTPStream(respBody, pw))
	}()
	mr := msgp.NewReader(pr)
	defer readMsgpReaderPoolPut(mr)
	for {
		var file ReadMultipleResp
		if err := file.DecodeMsg(mr); err != nil {
			if errors.Is(err, io.EOF) {
				err = nil
			}
			pr.CloseWithError(err)
			return toStorageErr(err)
		}
		select {

							aria-controls="navbar" aria-expanded="false" aria-label="Toggle navigation">
						<span class="navbar-toggler-icon"></span>
					</button>
					<div class="collapse navbar-collapse" id="navbar">
						<div class="mr-auto"></div>
						<ul class="nav navbar-nav">
							<c:if test="${eoled}">
								<li class="nav-item" data-toggle="tooltip" data-placement="left" title="<la:message key="labels.eol_error" />">

		if r := recover(); r != nil {
			debug.PrintStack()
			rw.CloseWithError(fmt.Errorf("panic: %v", r))
		}
	}()

	var req ReadMultipleReq
	mr := msgpNewReader(r.Body)
	defer readMsgpReaderPoolPut(mr)
	err := req.DecodeMsg(mr)
	if err != nil {
		rw.CloseWithError(err)
		return
	}

	mw := msgp.NewWriter(rw)
	responses := make(chan ReadMultipleResp, len(req.Files))

```

这就是 "可调用对象"。

## 类作为依赖项

您可能会注意到，要创建一个 Python 类的实例，您可以使用相同的语法。

举个例子:

```Python
class Cat:
    def __init__(self, name: str):
        self.name = name


fluffy = Cat(name="Mr Fluffy")
```

在这个例子中, `fluffy` 是一个 `Cat` 类的实例。

为了创建 `fluffy`，你调用了 `Cat` 。

所以，Python 类也是 **可调用对象**。

因此，在 **FastAPI** 中，你可以使用一个 Python 类作为一个依赖项。

实际上 FastAPI 检查的是它是一个 "可调用对象"（函数，类或其他任何类型）以及定义的参数。