public NetworkBuilder<N, E> expectedNodeCount(int expectedNodeCount) {
    this.expectedNodeCount = checkNonNegative(expectedNodeCount);
    return this;
  }

  /**
   * Specifies the expected number of edges in the network.
   *
   * @throws IllegalArgumentException if {@code expectedEdgeCount} is negative
   */
  @CanIgnoreReturnValue
  public NetworkBuilder<N, E> expectedEdgeCount(int expectedEdgeCount) {

from pydantic import BaseModel


def forwardref_method(input: "ForwardRefModel") -> "ForwardRefModel":
    return ForwardRefModel(x=input.x + 1)


class ForwardRefModel(BaseModel):

      throws InterruptedException, ExecutionException {
    for (int i = 0; i < futures.size(); i++) {
      assertThat(futures.get(i).get()).isEqualTo(RESULT_VALUE + i);
    }
  }

  private static List<Callable<String>> createTasks(int n) {
    List<Callable<String>> callables = new ArrayList<>();
    for (int i = 0; i < n; i++) {
      callables.add(Callables.returning(RESULT_VALUE + i));
    }

	"bytes"
	"crypto/rand"
	"io"
	"os"
	"testing"
)

var erasureHealTests = []struct {
	dataBlocks, disks int

	// number of offline disks is also number of staleDisks for
	// erasure reconstruction in this test
	offDisks int

	// bad disks are online disks which return errors
	badDisks, badStaleDisks int

	blocksize, size int64
	algorithm       BitrotAlgorithm
	shouldFail      bool
}{

from pydantic_settings import BaseSettings, SettingsConfigDict


class Settings(BaseSettings):
    app_name: str = "Awesome API"
    admin_email: str
    items_per_user: int = 50

from typing import Annotated

from fastapi import FastAPI, Path, Query

app = FastAPI()


@app.get("/items/{item_id}")
async def read_items(
    *,
    item_id: Annotated[int, Path(title="The ID of the item to get", ge=0, le=1000)],
    q: str,
    size: Annotated[float, Query(gt=0, lt=10.5)],
):
    results = {"item_id": item_id}
    if q:
        results.update({"q": q})
    if size:
        results.update({"size": size})

  @Override
  protected abstract Set<E> delegate();

  @Override
  public boolean equals(@Nullable Object object) {
    return object == this || delegate().equals(object);
  }

  @Override
  public int hashCode() {
    return delegate().hashCode();
  }

  /**
   * A sensible definition of {@link #removeAll} in terms of {@link #iterator} and {@link #remove}.

 * InetAddress[] addresses = resolver.resolve("example.com");
 * }
 * </pre>
 *
 */
public class IdnDnsResolver implements DnsResolver {

    /** Flag for IDN conversion. */
    protected int flag = 0;

    /** Encoding for URL decoding. */
    protected String encoding = "UTF-8";

    /**
     * Creates a new IdnDnsResolver instance with default settings.
     */
    public IdnDnsResolver() {

from fastapi import APIRouter, Body

router = APIRouter()


@router.post("/compute")
def compute(a: int = Body(), b: str = Body()):

@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: str | None = None):
    return {"item_id": item_id, "q": q}


@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    return {"item_name": item.name, "item_id": item_id}
```

`fastapi dev` サーバーは自動でリロードされるはずです。