endpoints[i].Hostname()), endpoints[i].Hostname(), logger.ErrorKind)
					}

					continue
				}

				// return err if not Docker or Kubernetes
				// We use IsDocker() to check for Docker environment
				// We use IsKubernetes() to check for Kubernetes environment
				isLocal, err := isLocalHost(endpoints[i].Hostname(),
					endpoints[i].Port(),
					globalMinioPort,
				)

					RuntimeVersion: server.RuntimeVersion,
					GCStats:        server.GCStats,
					MinioEnvVars:   server.MinioEnvVars,
				})
			}

			tls := getTLSInfo()
			isK8s := IsKubernetes()
			isDocker := IsDocker()
			healthInfo.Minio.Info = madmin.MinioInfo{
				Mode:         infoMessage.Mode,
				Domain:       infoMessage.Domain,
				Region:       infoMessage.Region,
				SQSARN:       infoMessage.SQSARN,

)

// serverDebugLog will enable debug printing
var (
	serverDebugLog     = env.Get("_MINIO_SERVER_DEBUG", config.EnableOff) == config.EnableOn
	currentReleaseTime time.Time
	orchestrated       = IsKubernetes() || IsDocker()
)

func init() {
	if !term.IsTerminal(int(os.Stdout.Fd())) || !term.IsTerminal(int(os.Stderr.Fd())) {
		color.TurnOff()
	}
	if env.Get("NO_COLOR", "") != "" || env.Get("TERM", "") == "dumb" {
		color.TurnOff()

	// Content for the object to be uploaded.
	buffer := bytes.NewReader([]byte("hello world"))
	// make long object name.
	longObjName := fmt.Sprintf("%0255d/%0255d/%0255d", 1, 1, 1)
	if IsDocker() || IsKubernetes() {
		longObjName = fmt.Sprintf("%0242d/%0242d/%0242d", 1, 1, 1)
	}
	// create new HTTP request to insert the object.

      }
    }
    return call.messageDone(
      exchange = this,
      requestDone = requestDone && !isSocket,
      responseDone = responseDone && !isSocket,
      socketSinkDone = requestDone && isSocket,
      socketSourceDone = responseDone && isSocket,
      e = e,
    )
  }

  fun noRequestBody() {
    call.messageDone(
      exchange = this,
      requestDone = true,

// Granted - represents a structure of a granted lock.
type Granted struct {
	index   int
	lockUID string // Locked if set with UID string, unlocked if empty
}

func (g *Granted) isLocked() bool {
	return isLocked(g.lockUID)
}

func isLocked(uid string) bool {
	return len(uid) > 0
}

// NewDRWMutex - initializes a new dsync RW mutex.
func NewDRWMutex(clnt *Dsync, names ...string) *DRWMutex {

Il existe des cas où vous pourriez avoir besoin de convertir un type de données (comme un modèle Pydantic) en quelque chose de compatible avec JSON (comme un `dict`, `list`, etc.).

Par exemple, si vous devez le stocker dans une base de données.

Pour cela, **FastAPI** fournit une fonction `jsonable_encoder()`.

## Utiliser `jsonable_encoder` { #using-the-jsonable-encoder }

Si vous avez une grande application, vous pourriez finir par accumuler **plusieurs tags**, et vous voudrez vous assurer d'utiliser toujours le **même tag** pour les *chemins d'accès* associés.

Dans ces cas, il peut être judicieux de stocker les tags dans un `Enum`.

**FastAPI** le prend en charge de la même manière qu'avec des chaînes simples :

{* ../../docs_src/path_operation_configuration/tutorial002b_py310.py hl[1,8:10,13,18] *}

{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[22:24] *}

### Mettre en cache le schéma OpenAPI { #cache-the-openapi-schema }

Vous pouvez utiliser la propriété `.openapi_schema` comme « cache » pour stocker votre schéma généré.

Ainsi, votre application n’aura pas à générer le schéma à chaque fois qu’un utilisateur ouvre les documents de votre API.

d'accès*, par exemple si plusieurs dépendances ont une sous-dépendance commune, **FastAPI** saura n'appeler cette sous-dépendance qu'une seule fois par requête.

Et il enregistrera la valeur renvoyée dans un <dfn title="Un utilitaire/système pour stocker des valeurs calculées/générées, afin de les réutiliser au lieu de les recalculer.">« cache »</dfn> et la transmettra à tous les « dependants » qui en ont besoin dans cette requête spécifique, au lieu d'appeler la dépendance plusieurs fois pour la...