}

	lbEndpoints := eps[0].LbEndpoints
	if len(lbEndpoints) != len(expected.weights) {
		t.Fatalf("unexpected number of endpoints.\nWant:\n%v\nGot:\n%v", expected.getAddrs(), getLbEndpointAddrs(lbEndpoints))
	}

	for addr, weight := range expected.weights {
		var match *endpoint.LbEndpoint
		for _, ep := range lbEndpoints {

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() == IsDict(

    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


@needs_py39
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

}

// NamedEdgeMap contains all unique call edges in the profile and their
// edge weight.
type NamedEdgeMap struct {
	Weight map[NamedCallEdge]int64

	// ByWeight lists all keys in Weight, sorted by edge weight from
	// highest to lowest.
	ByWeight []NamedCallEdge
}

func emptyProfile() *Profile {
	// Initialize empty maps/slices for easier use without a requiring a

   (HasStaticShapeConstraint $weight)],
  [], (addBenefit 10)>;

// Convert Matmul with hybrid inputs (f32 activation/int8 weight) to XlaDotV2
def ConvertTFMatMulToXLADotV2OpWeightOnly : Pat<
  (TF_MatMulOp:$matmul
    $input,
    (TF_MulOp (TF_CastOp (TF_IdentityOp $weight), $truncate1), $scale),
    $transpose_a, $transpose_b, $grad_a, $grad_b),
  (TF_MulOp (CreateXlaDotV2OpFromTfMatMulOp

      }
    }
  }
}
node {
  name: "BoxPredictor_4/ClassPredictor/weights/read"
  op: "Identity"
  input: "BoxPredictor_4/ClassPredictor/weights"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@BoxPredictor_4/ClassPredictor/weights"
      }
    }
  }
}
node {

      }
    }
  }
}
node {
  name: "BoxPredictor_4/ClassPredictor/weights/read"
  op: "Identity"
  input: "BoxPredictor_4/ClassPredictor/weights"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@BoxPredictor_4/ClassPredictor/weights"
      }
    }
  }
}
node {

	// by providing weights in LocalityLbEndpoints via load_balancing_weight.
	// By setting weights across different localities, it can allow
	// Envoy to do weighted load balancing across different zones and geographical locations.
	for _, localityWeightSetting := range distribute {
		if localityWeightSetting != nil &&
			util.LocalityMatch(locality, localityWeightSetting.From) {

  }];
  let dependentDialects = ["mlir::stablehlo::StablehloDialect"];
}

def InsertWeightParamPass : Pass<"stablehlo-insert-weight-param", "mlir::func::FuncOp"> {
  let summary = "Insert quantization parameters of weights for weight-only quantization and dynamic range quantization.";
  let dependentDialects = [
      "mlir::stablehlo::StablehloDialect",
      "TF::TensorFlowDialect",

      }
    }
  }
}
node {
  name: "BoxPredictor_4/ClassPredictor/weights/read"
  op: "Identity"
  input: "BoxPredictor_4/ClassPredictor/weights"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@BoxPredictor_4/ClassPredictor/weights"
      }
    }
  }
}
node {