//
  // Graph properties
  //

  /**
   * Returns true if the edges in this graph are directed. Directed edges connect a {@link
   * EndpointPair#source() source node} to a {@link EndpointPair#target() target node}, while
   * undirected edges connect a pair of nodes to each other.
   */
  boolean isDirected();

  /**
   * Returns true if this graph allows self-loops (edges that connect a node to itself). Attempting

   * <p><b>Java 21+ users:</b> use {@link Thread.Builder#name(String, long)} instead. Note that
   * {@link #setNameFormat} accepts a thread name <i>format string</i> (e.g., {@code
   * threadFactoryBuilder.setNameFormat("rpc-pool-%d")}), while {@code threadBuilder.name()} accepts
   * a thread name <i>prefix</i> and initial counter value (e.g., {@code
   * threadBuilder.name("rpc-pool-", 0)}.
   *

        // if value is non-null: we allow only plugins that have enlisted artifactId only
        // ---
        // end game is: settings enlisted groupIds are obeying order and are "free for all" (artifactId)
        // while POM enlisted plugins coming from non-enlisted settings groupIds (ie conflict of prefixes)
        // will prevail/win.
        LinkedHashMap<String, Set<String>> candidates = Stream.of(build, management)

) -> list[Comment]:
    comment_nodes: list[Comment] = []
    discussion_edges = get_graphql_translation_discussion_comments_edges(
        settings=settings, discussion_number=discussion_number
    )

    while discussion_edges:
        for discussion_edge in discussion_edges:
            comment_nodes.append(discussion_edge.node)
        last_edge = discussion_edges[-1]

	OpPing

	// OpPong is a OpPing response returned by the server.
	OpPong

	// OpConnectMux will connect a new mux with optional payload.
	OpConnectMux

	// OpMuxConnectError is an  error while connecting a mux.
	OpMuxConnectError

	// OpDisconnectClientMux instructs a client to disconnect a mux
	OpDisconnectClientMux

	// OpDisconnectServerMux instructs a server to disconnect (cancel) a server mux

    V value1 = entry1.getValue();
    checkEntryNotNull(key1, value1);
    // Do something that works for j2cl, where we can't call getDeclaredClass():
    EnumMap<K, V> enumMap = new EnumMap<>(singletonMap(key1, value1));
    while (entryItr.hasNext()) {
      Entry<K, ? extends V> entry = entryItr.next();
      K key = entry.getKey();
      V value = entry.getValue();
      checkEntryNotNull(key, value);
      enumMap.put(key, value);
    }

    V value1 = entry1.getValue();
    checkEntryNotNull(key1, value1);
    // Do something that works for j2cl, where we can't call getDeclaredClass():
    EnumMap<K, V> enumMap = new EnumMap<>(singletonMap(key1, value1));
    while (entryItr.hasNext()) {
      Entry<K, ? extends V> entry = entryItr.next();
      K key = entry.getKey();
      V value = entry.getValue();
      checkEntryNotNull(key, value);
      enumMap.put(key, value);
    }

          entries[lastEntryIndex] = maskCombine(entries[lastEntryIndex], newNext, mask);
        }

        return entryIndex;
      }
      lastEntryIndex = entryIndex;
      next = getNext(entry, mask);
    } while (next != UNSET);
    return -1;
  }

 *
 * <p>Thread-safe operations are supported for registration and retrieval of data stores.
 * The factory caches data store names with a time-based refresh mechanism to improve
 * performance while ensuring up-to-date plugin discovery.</p>
 */
public class DataStoreFactory {
    /** Logger instance for this factory class. */
    private static final Logger logger = LogManager.getLogger(DataStoreFactory.class);

And the `dict` you receive as `weights` will actually have `int` keys and `float` values.

///

## Recap { #recap }

With **FastAPI** you have the maximum flexibility provided by Pydantic models, while keeping your code simple, short and elegant.

But with all the benefits:

* Editor support (completion everywhere!)
* Data conversion (a.k.a. parsing / serialization)
* Data validation
* Schema documentation