res[i] = &di
		}
	}
	return res
}

// hasSpaceFor returns whether the disks in `di` have space for and object of a given size.
func hasSpaceFor(di []*DiskInfo, size int64) (bool, error) {
	// We multiply the size by 2 to account for erasure coding.
	size *= 2
	if size < 0 {
		// If no size, assume diskAssumeUnknownSize.
		size = diskAssumeUnknownSize
	}

	var available uint64
	var total uint64

        functionScoreQueryBuilder.boostMode(CombineFunction.REPLACE);
        functionScoreQueryBuilder.scoreMode(FunctionScoreQuery.ScoreMode.MULTIPLY);

        return functionScoreQueryBuilder;
    }

    /**
     * Checks if the query is a single word query.
     * @param query The query string.

                    .functionScoreQuery(QueryBuilders.matchAllQuery(),
                            flist.toArray(new FunctionScoreQueryBuilder.FilterFunctionBuilder[flist.size()]))
                    .boostMode(CombineFunction.MULTIPLY));
            reader.addSort(SortBuilders.fieldSort(fessConfig.getIndexFieldClickCount()));
            reader.addSort(SortBuilders.scoreSort());
            return reader;
        }, docPerReq, () -> {

			if pctUsed := int(disk.Used * 100 / disk.Total); pctUsed > maxUsedPct {
				maxUsedPct = pctUsed
			}
		}

		// Since we are comparing pools that may have a different number of sets
		// we multiply by the number of sets in the pool.
		// This will compensate for differences in set sizes
		// when choosing destination pool.
		// Different set sizes are already compensated by less disks.
		available *= uint64(nSets[i])

        tf.math.multiply(a, b)

        server.register("multiply", _remote_multiply) ```

    *   Example usage to create client: `python client =
        tf.distribute.experimental.rpc.Client.create("grpc", address) a =
        tf.constant(2, dtype=tf.int32) b = tf.constant(3, dtype=tf.int32)
        result = client.multiply(a, b)`

*   `tf.lite`:

///

## Múltiples parámetros del cuerpo { #multiple-body-parameters }

En el ejemplo anterior, las *path operations* esperarían un cuerpo JSON con los atributos de un `Item`, como:

```JSON
{
    "name": "Foo",
    "description": "The pretender",
    "price": 42.0,
    "tax": 3.2
}
```

Pero también puedes declarar múltiples parámetros del cuerpo, por ejemplo `item` y `user`:

///

## Múltiplos parâmetros de corpo { #multiple-body-parameters }

No exemplo anterior, as *operações de rota* esperariam um JSON no corpo contendo os atributos de um `Item`, exemplo:

```JSON
{
    "name": "Foo",
    "description": "The pretender",
    "price": 42.0,
    "tax": 3.2
}
```

Mas você pode também declarar múltiplos parâmetros de corpo, por exemplo, `item` e `user`:

# Body - Paramètres multiples { #body-multiple-parameters }

Maintenant que nous avons vu comment utiliser `Path` et `Query`, voyons des usages plus avancés des déclarations de paramètres du corps de la requête.

## Mélanger les paramètres `Path`, `Query` et du corps de la requête { #mix-path-query-and-body-parameters }

# Body - 多個參數 { #body-multiple-parameters }

現在我們已經知道如何使用 `Path` 與 `Query`，接下來看看更進階的請求主體（request body）宣告用法。

## 混用 `Path`、`Query` 與 Body 參數 { #mix-path-query-and-body-parameters }

首先，當然你可以自由混用 `Path`、`Query` 與請求 Body 參數的宣告，**FastAPI** 會知道該怎麼做。

你也可以將 Body 參數宣告為可選，方法是將預設值設為 `None`：

{* ../../docs_src/body_multiple_params/tutorial001_an_py310.py hl[18:20] *}

/// note | 注意

請注意，在此情況下，從 body 取得的 `item` 是可選的，因為它的預設值是 `None`。

///

///

## Multiple body parameters { #multiple-body-parameters }

In the previous example, the *path operations* would expect a JSON body with the attributes of an `Item`, like:

```JSON
{
    "name": "Foo",
    "description": "The pretender",
    "price": 42.0,
    "tax": 3.2
}
```

But you can also declare multiple body parameters, e.g. `item` and `user`: