Mais ce n'est pas la seule manière de déclarer des dépendances (même si c'est probablement la plus courante).

L'élément clé est qu'une dépendance doit être un « callable ».

Un « callable » en Python est tout ce que Python peut « appeler » comme une fonction.

Ainsi, si vous avez un objet `something` (qui n'est peut‑être pas une fonction) et que vous pouvez « l'appeler » (l'exécuter) comme :

```Python
something()
```

ou

```Python

# Diffuser des données { #stream-data }

Si vous voulez diffuser des données pouvant être structurées en JSON, vous devez [Diffuser des JSON Lines](../tutorial/stream-json-lines.md).

Mais si vous voulez diffuser des données binaires pures ou des chaînes, voici comment procéder.

/// info

Ajouté dans FastAPI 0.134.0.

///

## Cas d'utilisation { #use-cases }

   *
   * @throws IllegalStateException if the service is not {@link State#STARTING}.
   */
  protected final void notifyStarted() {
    monitor.enter();
    try {
      // We have to examine the internal state of the snapshot here to properly handle the stop
      // while starting case.
      if (snapshot.state != STARTING) {
        IllegalStateException failure =

import org.apache.commons.lang3.StringUtils;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.fess.dict.DictionaryItem;

/**
 * Dictionary item for protected words.
 * This class represents a single protected word entry in the dictionary.
 */
public class ProtwordsItem extends DictionaryItem {
    private final String input;

    private String newInput;

    /**
     * Constructor for ProtwordsItem.

// systems.
//
// One benefit of using DirectIO on Linux is that the page cache will not be
// polluted with single-access data. The ZFS read cache (ARC) is scan-resistant
// so there is no risk of polluting the entire cache with data accessed once.
// Another goal of DirectIO is to minimize the mutation of data by the kernel
// before issuing IO to underlying devices. ZFS users often enable features like

            if (properties != null) {
                for (Map.Entry<Object, Object> entry : properties.entrySet()) {
                    Object v = entry.getValue();
                    if (v instanceof String value) {
                        String inter = interpolate(value);
                        if (value != inter && inter != null) {
                            entry.setValue(inter);
                        }
                    }

@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Benchmark)
public class StringTermsSerializationBenchmark {
    private static final NamedWriteableRegistry REGISTRY = new NamedWriteableRegistry(
        List.of(new NamedWriteableRegistry.Entry(InternalAggregation.class, StringTerms.NAME, StringTerms::new))
    );
    @Param(value = { "1000" })
    private int buckets;

    private DelayableWriteable<InternalAggregations> results;

    @Setup

                .selectByPK(id)
                .filter(e -> Boolean.TRUE.equals(e.getAvailable()))
                .isPresent();
    }

    /**
     * Stores a job log entry in the database.
     *
     * @param jobLog the job log entry to store
     */
    public void store(final JobLog jobLog) {
        ComponentUtil.getComponent(JobLogBhv.class).insertOrUpdate(jobLog, op -> {

  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testReplace_supportedPresent() {
    assertEquals(v0(), getMap().replace(k0(), v3()));
    expectReplacement(entry(k0(), v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testReplace_supportedPresentNoChange() {
    assertEquals(v0(), getMap().replace(k0(), v0()));

     * Set the cache map for this referral
     *
     * @param map the cache map to associate with this referral
     */
    void setCacheMap(Map<String, DfsReferralDataInternal> map);

    /**
     * Replaces the entry with key in the cache map with this referral
     */
    void replaceCache();

    /**
     * Not exactly sure what that is all about, certainly legacy stuff
     *
     * @return resolveHashes
     */