long weightC = comparator.getProjectWeight(projectC);
        long weightX = comparator.getProjectWeight(projectX);

        // Project A should have the highest weight as it's at the root
        assertTrue(weightA > weightB, "Project A should have weight > Project B");
        assertTrue(weightA > weightC, "Project A should have weight > Project C");
        assertTrue(weightB > weightX, "Project B should have weight > Project X");

                                    "schema": {
                                        "title": "Response Read Keyword Weights Keyword Weights  Get",
                                        "type": "object",
                                        "additionalProperties": {"type": "number"},
                                    }
                                }
                            },
                        }
                    },

def test_post_body(client: TestClient):
    data = {"2": 2.2, "3": 3.3}
    response = client.post("/index-weights/", json=data)
    assert response.status_code == 200, response.text
    assert response.json() == data


def test_post_invalid_body(client: TestClient):
    data = {"foo": 2.2, "3": 3.3}
    response = client.post("/index-weights/", json=data)
    assert response.status_code == 422, response.text
    assert response.json() == {

 * <ul>
 * <li>Project D: weight = 1 (no downstream dependencies)</li>
 * <li>Project B: weight = 2 (1 + max(D=1))</li>
 * <li>Project C: weight = 2 (1 + max(D=1))</li>
 * <li>Project A: weight = 3 (1 + max(B=2, C=2))</li>
 * </ul>
 * <p>Build order: A (weight=3), then B and C (weight=2, ordered by project ID), then D (weight=1)
 * <p>If projects have identical weights and IDs, the order is deterministic but may not preserve

Das bedeutet, dass Ihre API-Clients nur Strings senden können, aber solange diese Strings nur Zahlen enthalten, wird Pydantic sie konvertieren und validieren.

Und das `dict`, welches Sie als `weights` erhalten, wird `int`-Schlüssel und `float`-Werte haben.

///

## Zusammenfassung { #recap }

        data.setUrl(null);
        assertNull(data.getUrl());
    }

    public void test_weightGetterSetter() {
        // Test weight getter/setter
        RequestData data = new RequestData();

        // Default weight should be 1.0
        assertEquals(1.0f, data.getWeight(), 0.001f);

        data.setWeight(0.5f);
        assertEquals(0.5f, data.getWeight(), 0.001f);

            urlQueue.setWeight(i); // Higher number = higher weight
            urlQueueList.add(urlQueue);
        }

        urlQueueService.offerAll(sessionId, urlQueueList);

        // Poll - items should be ordered by weight (descending)
        final OpenSearchUrlQueue first = urlQueueService.poll(sessionId);
        assertNotNull(first);
        // Weight should be highest
        assertTrue(first.getWeight() >= 1);

Esto significa que, aunque tus clientes de API solo pueden enviar strings como claves, mientras esos strings contengan enteros puros, Pydantic los convertirá y validará.

Y el `dict` que recibas como `weights` tendrá realmente claves `int` y valores `float`.

///

## Resumen { #recap }

Con **FastAPI** tienes la máxima flexibilidad proporcionada por los modelos Pydantic, manteniendo tu código simple, corto y elegante.

Isso significa que, embora os clientes da API só possam enviar strings como chaves, desde que essas strings contenham inteiros puros, o Pydantic irá convertê-los e validá-los.

E o `dict` que você recebe como `weights` terá, na verdade, chaves `int` e valores` float`.

///

## Recapitulação { #recap }

This means that, even though your API clients can only send strings as keys, as long as those strings contain pure integers, Pydantic will convert them and validate them.

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.