Method bind_query_params

src/binding/python/model/param/python_param.cc:1181–1686

}

void ZVecPyParams::bind_query_params(py::module_ &m) {
  // binding base query params
  py::class_<QueryParams, std::shared_ptr<QueryParams>> query_params(
      m, "QueryParam", R"pbdoc(
Base class for all query parameter configurations.

This abstract base class defines common query settings such as search radius
and whether to force linear (brute-force) search. It should not be instantiated
directly; use derived classes like `HnswQueryParam` or `IVFQueryParam`.

Attributes:
    type (IndexType): The index type this query is configured for.
    radius (float): Search radius for range queries. Used in combination with
        top-k to filter results. Default is 0.0 (disabled).
    is_linear (bool): If True, forces brute-force linear search instead of
        using the index. Useful for debugging or small datasets. Default is False.
    is_using_refiner (bool, optional): Whether to use refiner for the query. Default is False.
)pbdoc");
  query_params
      .def_property_readonly(
          "type",
          [](const QueryParams &self) -> IndexType { return self.type(); },
          "IndexType: The type of index this query targets.")
      .def_property_readonly(
          "radius",
          [](const QueryParams &self) -> float { return self.radius(); },
          "IndexType: The type of index this query targets.")
      .def_property_readonly(
          "is_linear",
          [](const QueryParams &self) -> bool { return self.is_linear(); },
          "bool: Whether to bypass the index and use brute-force linear "
          "search.")
      .def_property_readonly(
          "is_using_refiner",
          [](const QueryParams &self) -> bool {
            return self.is_using_refiner();
          },
          "bool: Whether to use refiner for the query.")
      .def(py::pickle(
          [](const QueryParams &self) {  // __getstate__
            return py::make_tuple(self.type(), self.radius(), self.is_linear());
          },
          [](py::tuple t) {  // __setstate__
            if (t.size() != 3)
              throw std::runtime_error("Invalid state for QueryParams");
            return std::shared_ptr<QueryParams>();
          }));

  // binding hnsw query params
  py::class_<HnswQueryParams, QueryParams, std::shared_ptr<HnswQueryParams>>
      hnsw_params(m, "HnswQueryParam", R"pbdoc(
Query parameters for HNSW (Hierarchical Navigable Small World) index.

Controls the trade-off between search speed and accuracy via the `ef` parameter.

Attributes:
    type (IndexType): Always ``IndexType.HNSW``.
    ef (int): Size of the dynamic candidate list during search.