remove python/tostr.hpp

replace tostr() with cat(), snprintf_z() and nb::str::format

Author: wojdyr

docs/grid.rst

@@ -236,8 +236,8 @@ or when iterating the grid:
   >>> for point in grid:
   ...   if point.value != 0.: print(point)
   <gemmi.FloatGridBase.Point (0, 0, 0) -> 0.125>
-  <gemmi.FloatGridBase.Point (1, 1, 1) -> 7>
-  <gemmi.FloatGridBase.Point (11, 1, 11) -> 7>
+  <gemmi.FloatGridBase.Point (1, 1, 1) -> 7.0>
+  <gemmi.FloatGridBase.Point (11, 1, 11) -> 7.0>
 
 The point can be converted to its index (position in the array):
 
@@ -266,7 +266,7 @@ The other way around, we can find the grid point nearest to a position:
 .. doctest::
 
   >>> grid.get_nearest_point(_)
-  <gemmi.FloatGridBase.Point (6, 6, 6) -> 0>
+  <gemmi.FloatGridBase.Point (6, 6, 6) -> 0.0>
 
 
 Common operations
@@ -504,7 +504,7 @@ The primary use for MaskedGrid is working with asymmetric unit (asu) only:
   >>> for point in asu:
   ...   if point.value != 0: print(point)
   <gemmi.FloatGridBase.Point (0, 0, 0) -> 0.125>
-  <gemmi.FloatGridBase.Point (1, 1, 1) -> 7>
+  <gemmi.FloatGridBase.Point (1, 1, 1) -> 7.0>
 
 
 .. _solventmask:

docs/hkl.rst

@@ -1108,7 +1108,7 @@ Each item in AsuData has two properties, hkl and value:
 .. doctest::
 
   >>> asu_data[158]
-  <gemmi.ComplexHklValue (-6,2,5) (-1.37694,-0.190087)>
+  <gemmi.ComplexHklValue (-6,2,5) (-1.376941204071045-0.19008657336235046j)>
   >>> _.hkl, _.value
   ([-6, 2, 5], (-1.376941204071045-0.19008657336235046j))
 

python/grid.cpp

@@ -24,7 +24,6 @@ bool operator>(const std::complex<float>& a, const std::complex<float>& b) {
 #include "gemmi/solmask.hpp"  // for SolventMasker, mask_points_in_constant_radius
 #include "gemmi/blob.hpp"     // for Blob, find_blobs_by_flood_fill
 #include "gemmi/asumask.hpp"  // for MaskedGrid
-#include "tostr.hpp"
 
 using namespace gemmi;
 
@@ -53,8 +52,8 @@ nb::class_<GridBase<T>, GridMeta> add_grid_base(nb::module_& m, const char* name
                   [](const GrPoint& self) { return *self.value; },
                   [](GrPoint& self, T x) { *self.value = x; })
     .def("__repr__", [=](const GrPoint& self) {
-        return tostr("<gemmi.", name, ".Point (", self.u, ", ", self.v, ", ",
-                     self.w, ") -> ", +*self.value, '>');
+        return nb::str("<gemmi.{}.Point ({}, {}, {}) -> {}>")
+            .format(name, self.u, self.v, self.w, self.value);
     });
 
   auto to_array = [](GrBase& gr) { return grid_to_array(gr, gr.data); };

python/hkl.cpp

@@ -11,7 +11,6 @@
 #include "gemmi/unitcell.hpp"
 #include "gemmi/refln.hpp"
 #include "gemmi/fourier.hpp"  // for get_size_for_hkl, get_f_phi_on_grid, ...
-#include "tostr.hpp"
 #include "gemmi/fprime.hpp"   // for cromer_liberman
 #include "gemmi/reciproc.hpp" // for count_reflections, make_miller_vector
 #include "gemmi/cif2mtz.hpp"  // for CifToMtz
@@ -24,19 +23,6 @@ using namespace gemmi;
 
 NB_MAKE_OPAQUE(std::vector<ReflnBlock>)
 
-namespace gemmi {
-  // operator<< is used by stl_bind for vector's __repr__
-  inline std::ostream& operator<< (std::ostream& os, const ReflnBlock& rb) {
-    os << "<gemmi.ReflnBlock " << rb.block.name << " with ";
-    if (rb.default_loop)
-      os << rb.default_loop->width() << " x " << rb.default_loop->length();
-    else
-      os << " no ";
-    os << " loop>";
-    return os;
-  }
-}
-
 void add_hkl(nb::module_& m) {
   nb::class_<ReflnBlock> pyReflnBlock(m, "ReflnBlock");
   nb::bind_vector<std::vector<ReflnBlock>, rv_ri>(m, "ReflnBlocks");
@@ -128,8 +114,15 @@ void add_hkl(nb::module_& m) {
     .def("is_unmerged", &ReflnBlock::is_unmerged)
     .def("use_unmerged", &ReflnBlock::use_unmerged)
     .def("__bool__", [](const ReflnBlock& self) { return self.ok(); })
-    .def("__repr__", [](const ReflnBlock& self) { return tostr(self); })
-    ;
+    .def("__repr__", [](const ReflnBlock& self) {
+        std::string s = cat("<gemmi.ReflnBlock ", self.block.name, " with ");
+        if (self.default_loop)
+          cat_to(s, self.default_loop->width(), " x ", self.default_loop->length());
+        else
+          s += " no ";
+        s += " loop>";
+        return s;
+    });
   m.def("as_refln_blocks",
         [](cif::Document& d) { return as_refln_blocks(std::move(d.blocks)); });
   m.def("hkl_cif_as_refln_block", &hkl_cif_as_refln_block, nb::arg("block"));

python/recgrid.cpp

@@ -9,17 +9,11 @@
 
 #include "gemmi/recgrid.hpp"
 #include "gemmi/fourier.hpp"  // for get_size_for_hkl, get_f_phi_on_grid
-#include "tostr.hpp"
+#include "gemmi/sprintf.hpp"
 
 using namespace gemmi;
 
-namespace gemmi {
-  std::ostream& operator<< (std::ostream& os, const ValueSigma<float>& vs) {
-    os << vs.value << " +/- " << vs.sigma;
-    return os;
-  }
-}
-
+namespace {
 template<typename T, typename Func>
 auto make_new_column(const AsuData<T>& asu_data, Func f) {
   if (!asu_data.unit_cell().is_crystal())
@@ -71,9 +65,8 @@ void add_asudata(nb::module_& m, const std::string& prefix) {
     .def_ro("hkl", &HklValue<T>::hkl)
     .def_rw("value", &HklValue<T>::value)
     .def("__repr__", [prefix](const HklValue<T>& self) {
-        return tostr("<gemmi.", prefix, "HklValue (",
-                     self.hkl[0], ',', self.hkl[1], ',', self.hkl[2], ") ",
-                     self.value, '>');
+        return nb::str("<gemmi.{}HklValue ({},{},{}) {}>")
+                .format(prefix, self.hkl[0], self.hkl[1], self.hkl[2], self.value);
     });
 
   using AsuData = AsuData<T>;
@@ -145,7 +138,7 @@ void add_asudata(nb::module_& m, const std::string& prefix) {
       return new AsuData(self);
     })
     .def("__repr__", [prefix](const AsuData& self) {
-        return tostr("<gemmi.", prefix, "AsuData with ", self.v.size(), " values>");
+        return cat("<gemmi.", prefix, "AsuData with ", self.v.size(), " values>");
     });
     add_to_asu_data(asu_data);
 }
@@ -211,17 +204,21 @@ void add_asudata_and_recgrid(nb::module_& m,
          nb::arg("with_000")=false, nb::arg("with_sys_abs")=false,
          nb::arg("mott_bethe")=false)
     .def("__repr__", [=](const RecGr& self) {
-        return tostr("<gemmi.", rgrid_name, '(', self.nu, ", ", self.nv, ", ", self.nw, ")>");
+        return cat("<gemmi.", rgrid_name, '(', self.nu, ", ", self.nv, ", ", self.nw, ")>");
     });
 }
 
+}  // anonymous namespace
+
 void add_recgrid(nb::module_& m) {
   using VS = ValueSigma<float>;
   nb::class_<VS>(m, "ValueSigma")
     .def_rw("value", &VS::value)
     .def_rw("sigma", &VS::sigma)
     .def("__repr__", [](const VS& self) {
-        return tostr("<gemmi.ValueSigma(", self.value, ", ", self.sigma, ")>");
+        char buf[64];
+        snprintf_z(buf, 64, "<gemmi.ValueSigma(%g, %g)>", self.value, self.sigma);
+        return std::string(buf);
     });
   nb::class_<ComplexCorrelation>(m, "ComplexCorrelation")
     .def_ro("n", &ComplexCorrelation::n)

python/tostr.hpp

@@ -1,7 +1,6 @@
 // Copyright 2017 Global Phasing Ltd.
 
 #include "gemmi/unitcell.hpp"
-#include "tostr.hpp"  // tostr
 #include "gemmi/cellred.hpp"  // GruberVector
 #include "gemmi/twin.hpp"  // find_lattice_2fold_ops
 #include "gemmi/sprintf.hpp"  // snprintf_z
@@ -73,8 +72,10 @@ template<typename T> void add_smat33(nb::module_& m, const char* name) {
     .def("transformed_by", &M::template transformed_by<T>)
     .def("calculate_eigenvalues", &M::calculate_eigenvalues)
     .def("__repr__", [name](const M& m) {
-        return tostr("<gemmi.", name, '(', m.u11, ", ", m.u22, ", ", m.u33, ", ",
-                     m.u12, ", ", m.u13, ", ", m.u23, + ")>");
+        char buf[128];
+        snprintf_z(buf, 128, "<gemmi.%s(%g, %g, %g, %g, %g, %g)>",
+                   name, m.u11, m.u22, m.u33, m.u12, m.u13, m.u23);
+        return std::string(buf);
     });
 }