diff --git a/cpp/include/cugraph/sampling_functions.hpp b/cpp/include/cugraph/sampling_functions.hpp
index 5b884fa611e..7acda3e8d4c 100644
--- a/cpp/include/cugraph/sampling_functions.hpp
+++ b/cpp/include/cugraph/sampling_functions.hpp
@@ -130,7 +130,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<label_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement                           = true,
@@ -211,7 +212,7 @@ uniform_neighbor_sample(
  * optional int32_t hop, optional label_t label, optional size_t offsets)
  */
 
-// tuple with 3 elements. 1 - edge_type, 2- host span of size_t, 3 - fanout vector 
+// tuple with 3 elements. 1 - edge_type, 2- host span of size_t, 3 - fanout vector
 template <typename vertex_t,
           typename edge_t,
           typename weight_t,
diff --git a/cpp/include/cugraph_c/sampling_algorithms.h b/cpp/include/cugraph_c/sampling_algorithms.h
index e440512c482..6bc9403b2f3 100644
--- a/cpp/include/cugraph_c/sampling_algorithms.h
+++ b/cpp/include/cugraph_c/sampling_algorithms.h
@@ -324,10 +324,10 @@ void cugraph_sampling_options_free(cugraph_sampling_options_t* options);
  */
 // FIXME: internal representation should be tuple instead of pairs - Make it more generic (tuple)
 // cugraph_device_tuple_t, host_device_tuple_t,
-//dictionary, key and array
+// dictionary, key and array
 // translate dictionary to a tuple. Add to the draft PR the PLC layer.
 // Concatenate to build the 3 arrays from the PLC layer
-/// mimic 
+/// mimic
 typedef struct {
   int32_t align_;
 } cugraph_sample_heterogeneous_fanout_t;
@@ -359,8 +359,7 @@ cugraph_error_code_t cugraph_create_heterogeneous_fanout(
  *
  * @param [in]    heterogeneous_fanout The edge type size and fanout values
  */
-void cugraph_heterogeneous_fanout_free(
-  cugraph_sample_heterogeneous_fanout_t* heterogeneous_fanout);
+void cugraph_heterogeneous_fanout_free(cugraph_sample_heterogeneous_fanout_t* heterogeneous_fanout);
 
 /**
  * @brief     Uniform Neighborhood Sampling
@@ -712,7 +711,6 @@ cugraph_error_code_t cugraph_test_uniform_neighborhood_sample_result_create(
  * @return error code
  */
 
-
 cugraph_error_code_t cugraph_select_random_vertices(const cugraph_resource_handle_t* handle,
                                                     const cugraph_graph_t* graph,
                                                     cugraph_rng_state_t* rng_state,
@@ -720,7 +718,6 @@ cugraph_error_code_t cugraph_select_random_vertices(const cugraph_resource_handl
                                                     cugraph_type_erased_device_array_t** vertices,
                                                     cugraph_error_t** error);
 
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/cpp/src/c_api/neighbor_sampling.cpp b/cpp/src/c_api/neighbor_sampling.cpp
index 9e6e68871c6..e95f9315b00 100644
--- a/cpp/src/c_api/neighbor_sampling.cpp
+++ b/cpp/src/c_api/neighbor_sampling.cpp
@@ -14,13 +14,14 @@
  * limitations under the License.
  */
 
+#include "c_api/neighbor_sampling.hpp"  // FIXME: Remove this and instead use std::tuple
+
 #include "c_api/abstract_functor.hpp"
 #include "c_api/graph.hpp"
 #include "c_api/properties.hpp"
 #include "c_api/random.hpp"
 #include "c_api/resource_handle.hpp"
 #include "c_api/utils.hpp"
-#include "c_api/neighbor_sampling.hpp" // FIXME: Remove this and instead use std::tuple
 
 #include <cugraph_c/algorithms.h>
 #include <cugraph_c/sampling_algorithms.h>
@@ -113,7 +114,8 @@ struct uniform_neighbor_sampling_functor : public cugraph::c_api::abstract_funct
       fan_out_(
         reinterpret_cast<cugraph::c_api::cugraph_type_erased_host_array_view_t const*>(fan_out)),
       heterogeneous_fan_out_(
-        reinterpret_cast<cugraph::c_api::cugraph_sample_heterogeneous_fanout_t const*>(heterogeneous_fan_out)),
+        reinterpret_cast<cugraph::c_api::cugraph_sample_heterogeneous_fanout_t const*>(
+          heterogeneous_fan_out)),
       rng_state_(reinterpret_cast<cugraph::c_api::cugraph_rng_state_t*>(rng_state)),
       options_(options),
       do_expensive_check_(do_expensive_check)
@@ -221,16 +223,16 @@ struct uniform_neighbor_sampling_functor : public cugraph::c_api::abstract_funct
                 raft::device_span<label_t const>{label_to_comm_rank_->as_type<label_t>(),
                                                  label_to_comm_rank_->size_}))
             : std::nullopt,
-          (fan_out_ != nullptr)
-            ? std::make_optional<raft::host_span<const int>>(fan_out_->as_type<const int>(), fan_out_->size_)
-            : std::nullopt,
-    
+          (fan_out_ != nullptr) ? std::make_optional<raft::host_span<const int>>(
+                                    fan_out_->as_type<const int>(), fan_out_->size_)
+                                : std::nullopt,
+
           (heterogeneous_fan_out_ != nullptr)
             ? std::make_optional(std::make_tuple(
-              raft::host_span<const int>{heterogeneous_fan_out_->edge_type_id->as_type<int>(),
-                                         heterogeneous_fan_out_->edge_type_id->size_},
-              raft::host_span<const int>{heterogeneous_fan_out_->fanout->as_type<int>(),
-                                         heterogeneous_fan_out_->fanout->size_}))
+                raft::host_span<const int>{heterogeneous_fan_out_->edge_type_id->as_type<int>(),
+                                           heterogeneous_fan_out_->edge_type_id->size_},
+                raft::host_span<const int>{heterogeneous_fan_out_->fanout->as_type<int>(),
+                                           heterogeneous_fan_out_->fanout->size_}))
             : std::nullopt,
           rng_state_->rng_state_,
           options_.return_hops_,
@@ -769,58 +771,61 @@ struct biased_neighbor_sampling_functor : public cugraph::c_api::abstract_functo
   }
 };
 
-  struct create_heterogeneous_fanout_functor : public cugraph::c_api::abstract_functor {
-    raft::handle_t const& handle_;
-    cugraph::c_api::cugraph_graph_t* graph_;
-    cugraph::c_api::cugraph_type_erased_host_array_view_t const* edge_type_size_;
-    cugraph::c_api::cugraph_type_erased_host_array_view_t const* fanout_;
-    // FIXME: This type doesn't exist: instead create an 'std::tuple<cugraph_type_erased_host_array_t*>'
-    cugraph::c_api::cugraph_sample_heterogeneous_fanout_t* result_{};
-
-    create_heterogeneous_fanout_functor(::cugraph_resource_handle_t const* handle,
-                                ::cugraph_graph_t* graph,
-                                ::cugraph_type_erased_host_array_view_t const* edge_type_size,
-                                ::cugraph_type_erased_host_array_view_t const* fanout)
-      : abstract_functor(),
-        handle_(*reinterpret_cast<cugraph::c_api::cugraph_resource_handle_t const*>(handle)->handle_),
-        graph_(reinterpret_cast<cugraph::c_api::cugraph_graph_t*>(graph)),
-        edge_type_size_(
-          reinterpret_cast<cugraph::c_api::cugraph_type_erased_host_array_view_t const*>(edge_type_size)),
-        fanout_(
-          reinterpret_cast<cugraph::c_api::cugraph_type_erased_host_array_view_t const*>(fanout))
-    {
-    }
+struct create_heterogeneous_fanout_functor : public cugraph::c_api::abstract_functor {
+  raft::handle_t const& handle_;
+  cugraph::c_api::cugraph_graph_t* graph_;
+  cugraph::c_api::cugraph_type_erased_host_array_view_t const* edge_type_size_;
+  cugraph::c_api::cugraph_type_erased_host_array_view_t const* fanout_;
+  // FIXME: This type doesn't exist: instead create an
+  // 'std::tuple<cugraph_type_erased_host_array_t*>'
+  cugraph::c_api::cugraph_sample_heterogeneous_fanout_t* result_{};
+
+  create_heterogeneous_fanout_functor(::cugraph_resource_handle_t const* handle,
+                                      ::cugraph_graph_t* graph,
+                                      ::cugraph_type_erased_host_array_view_t const* edge_type_size,
+                                      ::cugraph_type_erased_host_array_view_t const* fanout)
+    : abstract_functor(),
+      handle_(*reinterpret_cast<cugraph::c_api::cugraph_resource_handle_t const*>(handle)->handle_),
+      graph_(reinterpret_cast<cugraph::c_api::cugraph_graph_t*>(graph)),
+      edge_type_size_(
+        reinterpret_cast<cugraph::c_api::cugraph_type_erased_host_array_view_t const*>(
+          edge_type_size)),
+      fanout_(
+        reinterpret_cast<cugraph::c_api::cugraph_type_erased_host_array_view_t const*>(fanout))
+  {
+  }
 
-    template <typename vertex_t,
-              typename edge_t,
-              typename weight_t,
-              typename edge_type_type_t,
-              bool store_transposed,
-              bool multi_gpu>
-    void operator()()
-    {
-      // FIXME: Remove this check as it is not necessary
-      if constexpr (!cugraph::is_candidate<vertex_t, edge_t, weight_t>::value) {
-        unsupported();
-      } else {
-        std::vector<int32_t> edge_type_size_copy{(int32_t) edge_type_size_->size_};
-        std::vector<int32_t> fanout_copy{(int32_t) fanout_->size_};
-      
-        raft::copy(
-          edge_type_size_copy.data(), edge_type_size_->as_type<int32_t>(), edge_type_size_->size_, handle_.get_stream());
-      
-        raft::copy(
-          fanout_copy.data(), fanout_->as_type<int32_t>(), fanout_->size_, handle_.get_stream());
-        
-        // std::tuple (template)
-        // result_ = new std::tuple <template type of 2 cugraph_type_erased_host_array_t>
-        result_ = new cugraph::c_api::cugraph_sample_heterogeneous_fanout_t{
-          new cugraph::c_api::cugraph_type_erased_host_array_t(edge_type_size_copy, INT32),
-          new cugraph::c_api::cugraph_type_erased_host_array_t(fanout_copy, INT32)};
-        
-      }
+  template <typename vertex_t,
+            typename edge_t,
+            typename weight_t,
+            typename edge_type_type_t,
+            bool store_transposed,
+            bool multi_gpu>
+  void operator()()
+  {
+    // FIXME: Remove this check as it is not necessary
+    if constexpr (!cugraph::is_candidate<vertex_t, edge_t, weight_t>::value) {
+      unsupported();
+    } else {
+      std::vector<int32_t> edge_type_size_copy{(int32_t)edge_type_size_->size_};
+      std::vector<int32_t> fanout_copy{(int32_t)fanout_->size_};
+
+      raft::copy(edge_type_size_copy.data(),
+                 edge_type_size_->as_type<int32_t>(),
+                 edge_type_size_->size_,
+                 handle_.get_stream());
+
+      raft::copy(
+        fanout_copy.data(), fanout_->as_type<int32_t>(), fanout_->size_, handle_.get_stream());
+
+      // std::tuple (template)
+      // result_ = new std::tuple <template type of 2 cugraph_type_erased_host_array_t>
+      result_ = new cugraph::c_api::cugraph_sample_heterogeneous_fanout_t{
+        new cugraph::c_api::cugraph_type_erased_host_array_t(edge_type_size_copy, INT32),
+        new cugraph::c_api::cugraph_type_erased_host_array_t(fanout_copy, INT32)};
     }
-  };
+  }
+};
 }  // namespace
 
 extern "C" cugraph_error_code_t cugraph_sampling_options_create(
@@ -1454,8 +1459,6 @@ cugraph_error_code_t cugraph_biased_neighbor_sample(
   return cugraph::c_api::run_algorithm(graph, functor, result, error);
 }
 
-
-
 extern "C" cugraph_error_code_t cugraph_create_heterogeneous_fanout(
   const cugraph_resource_handle_t* handle,
   cugraph_graph_t* graph,
@@ -1464,7 +1467,7 @@ extern "C" cugraph_error_code_t cugraph_create_heterogeneous_fanout(
   cugraph_sample_heterogeneous_fanout_t** heterogeneous_fanout,
   cugraph_error_t** error)
 {
-  create_heterogeneous_fanout_functor functor(handle, graph, edge_type_size, fanout);  
+  create_heterogeneous_fanout_functor functor(handle, graph, edge_type_size, fanout);
 
   return cugraph::c_api::run_algorithm(graph, functor, heterogeneous_fanout, error);
-}
\ No newline at end of file
+}
diff --git a/cpp/src/sampling/neighbor_sampling_impl.hpp b/cpp/src/sampling/neighbor_sampling_impl.hpp
index 1989b733eaf..2977084cce2 100644
--- a/cpp/src/sampling/neighbor_sampling_impl.hpp
+++ b/cpp/src/sampling/neighbor_sampling_impl.hpp
@@ -60,8 +60,9 @@ neighbor_sample_impl(
   std::optional<std::tuple<raft::device_span<label_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
-  //raft::host_span<int32_t const> fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
+  // raft::host_span<int32_t const> fan_out,
   bool return_hops,
   bool with_replacement,
   prior_sources_behavior_t prior_sources_behavior,
@@ -78,20 +79,25 @@ neighbor_sample_impl(
   static_assert(std::is_floating_point_v<bias_t>);
 
   if (fan_out) {
-    CUGRAPH_EXPECTS((*fan_out).size() > 0, "Invalid input argument: number of levels must be non-zero.");
+    CUGRAPH_EXPECTS((*fan_out).size() > 0,
+                    "Invalid input argument: number of levels must be non-zero.");
     CUGRAPH_EXPECTS(
-    (*fan_out).size() <= static_cast<size_t>(std::numeric_limits<int32_t>::max()),
-    "Invalid input argument: number of levels should not overflow int32_t");  // as we use int32_t
-                                                                              // to store hops
-  } else {    
-    CUGRAPH_EXPECTS(std::accumulate(
-      std::get<0>(*heterogeneous_fan_out).begin(),
-      std::get<0>(*heterogeneous_fan_out).end(), 0) == std::get<1>(*heterogeneous_fan_out).size() && std::get<1>(*heterogeneous_fan_out).size() != 0,
-        "Invalid input argument: number of levels and size must match and should be non zero.");
-    
+      (*fan_out).size() <= static_cast<size_t>(std::numeric_limits<int32_t>::max()),
+      "Invalid input argument: number of levels should not overflow int32_t");  // as we use int32_t
+                                                                                // to store hops
+  } else {
     CUGRAPH_EXPECTS(
-      std::get<0>(*heterogeneous_fan_out).size() <= static_cast<size_t>(std::numeric_limits<int32_t>::max())
-        && std::get<1>(*heterogeneous_fan_out).size() <= static_cast<size_t>(std::numeric_limits<int32_t>::max()),
+      std::accumulate(std::get<0>(*heterogeneous_fan_out).begin(),
+                      std::get<0>(*heterogeneous_fan_out).end(),
+                      0) == std::get<1>(*heterogeneous_fan_out).size() &&
+        std::get<1>(*heterogeneous_fan_out).size() != 0,
+      "Invalid input argument: number of levels and size must match and should be non zero.");
+
+    CUGRAPH_EXPECTS(
+      std::get<0>(*heterogeneous_fan_out).size() <=
+          static_cast<size_t>(std::numeric_limits<int32_t>::max()) &&
+        std::get<1>(*heterogeneous_fan_out).size() <=
+          static_cast<size_t>(std::numeric_limits<int32_t>::max()),
       "Invalid input argument: number of levels should not overflow int32_t");  // as we use int32_t
                                                                                 // to store hops
   }
@@ -142,7 +148,9 @@ neighbor_sample_impl(
   level_result_dst_vectors.reserve((*fan_out).size());
   if (level_result_weight_vectors) { (*level_result_weight_vectors).reserve((*fan_out).size()); }
   if (level_result_edge_id_vectors) { (*level_result_edge_id_vectors).reserve((*fan_out).size()); }
-  if (level_result_edge_type_vectors) { (*level_result_edge_type_vectors).reserve((*fan_out).size()); }
+  if (level_result_edge_type_vectors) {
+    (*level_result_edge_type_vectors).reserve((*fan_out).size());
+  }
   if (level_result_label_vectors) { (*level_result_label_vectors).reserve((*fan_out).size()); }
 
   rmm::device_uvector<vertex_t> frontier_vertices(0, handle.get_stream());
@@ -382,8 +390,9 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<label_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
-  //raft::host_span<int32_t const> fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
+  // raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
diff --git a/cpp/src/sampling/neighbor_sampling_mg_v32_e32.cpp b/cpp/src/sampling/neighbor_sampling_mg_v32_e32.cpp
index 04cba83ac53..a8bc9b015f1 100644
--- a/cpp/src/sampling/neighbor_sampling_mg_v32_e32.cpp
+++ b/cpp/src/sampling/neighbor_sampling_mg_v32_e32.cpp
@@ -40,7 +40,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
@@ -67,7 +68,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
@@ -94,7 +96,7 @@ biased_neighbor_sample(
   std::optional<raft::device_span<int32_t const>> starting_vertex_labels,
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
-  //std::optional<raft::host_span<int32_t const>> fan_out,
+  // std::optional<raft::host_span<int32_t const>> fan_out,
   raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
@@ -122,7 +124,7 @@ biased_neighbor_sample(
   std::optional<raft::device_span<int32_t const>> starting_vertex_labels,
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
-  //std::optional<raft::host_span<int32_t const>> fan_out,
+  // std::optional<raft::host_span<int32_t const>> fan_out,
   raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
diff --git a/cpp/src/sampling/neighbor_sampling_mg_v32_e64.cpp b/cpp/src/sampling/neighbor_sampling_mg_v32_e64.cpp
index 6ba353ad58c..4bcc93a83d0 100644
--- a/cpp/src/sampling/neighbor_sampling_mg_v32_e64.cpp
+++ b/cpp/src/sampling/neighbor_sampling_mg_v32_e64.cpp
@@ -40,7 +40,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
@@ -67,7 +68,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
@@ -94,7 +96,7 @@ biased_neighbor_sample(
   std::optional<raft::device_span<int32_t const>> starting_vertex_labels,
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
-  //std::optional<raft::host_span<int32_t const>> fan_out,
+  // std::optional<raft::host_span<int32_t const>> fan_out,
   raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
@@ -122,7 +124,7 @@ biased_neighbor_sample(
   std::optional<raft::device_span<int32_t const>> starting_vertex_labels,
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
-  //std::optional<raft::host_span<int32_t const>> fan_out,
+  // std::optional<raft::host_span<int32_t const>> fan_out,
   raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
diff --git a/cpp/src/sampling/neighbor_sampling_mg_v64_e64.cpp b/cpp/src/sampling/neighbor_sampling_mg_v64_e64.cpp
index a33bff7d3b1..eb99ca0c2a1 100644
--- a/cpp/src/sampling/neighbor_sampling_mg_v64_e64.cpp
+++ b/cpp/src/sampling/neighbor_sampling_mg_v64_e64.cpp
@@ -40,7 +40,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
@@ -67,7 +68,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
@@ -94,7 +96,7 @@ biased_neighbor_sample(
   std::optional<raft::device_span<int32_t const>> starting_vertex_labels,
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
-  //std::optional<raft::host_span<int32_t const>> fan_out,
+  // std::optional<raft::host_span<int32_t const>> fan_out,
   raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
@@ -122,7 +124,7 @@ biased_neighbor_sample(
   std::optional<raft::device_span<int32_t const>> starting_vertex_labels,
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
-  //std::optional<raft::host_span<int32_t const>> fan_out,
+  // std::optional<raft::host_span<int32_t const>> fan_out,
   raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
diff --git a/cpp/src/sampling/neighbor_sampling_sg_v32_e32.cpp b/cpp/src/sampling/neighbor_sampling_sg_v32_e32.cpp
index 44f82c0b0ea..7de1b877b81 100644
--- a/cpp/src/sampling/neighbor_sampling_sg_v32_e32.cpp
+++ b/cpp/src/sampling/neighbor_sampling_sg_v32_e32.cpp
@@ -40,7 +40,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
@@ -67,7 +68,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
@@ -94,7 +96,7 @@ biased_neighbor_sample(
   std::optional<raft::device_span<int32_t const>> starting_vertex_labels,
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
-  //std::optional<raft::host_span<int32_t const>> fan_out,
+  // std::optional<raft::host_span<int32_t const>> fan_out,
   raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
@@ -122,7 +124,7 @@ biased_neighbor_sample(
   std::optional<raft::device_span<int32_t const>> starting_vertex_labels,
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
-  //std::optional<raft::host_span<int32_t const>> fan_out,
+  // std::optional<raft::host_span<int32_t const>> fan_out,
   raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
diff --git a/cpp/src/sampling/neighbor_sampling_sg_v32_e64.cpp b/cpp/src/sampling/neighbor_sampling_sg_v32_e64.cpp
index 69128c02fd2..06ce85e74f3 100644
--- a/cpp/src/sampling/neighbor_sampling_sg_v32_e64.cpp
+++ b/cpp/src/sampling/neighbor_sampling_sg_v32_e64.cpp
@@ -40,7 +40,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
@@ -67,7 +68,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
@@ -94,7 +96,7 @@ biased_neighbor_sample(
   std::optional<raft::device_span<int32_t const>> starting_vertex_labels,
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
-  //std::optional<raft::host_span<int32_t const>> fan_out,
+  // std::optional<raft::host_span<int32_t const>> fan_out,
   raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
@@ -122,7 +124,7 @@ biased_neighbor_sample(
   std::optional<raft::device_span<int32_t const>> starting_vertex_labels,
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
-  //std::optional<raft::host_span<int32_t const>> fan_out,
+  // std::optional<raft::host_span<int32_t const>> fan_out,
   raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
diff --git a/cpp/src/sampling/neighbor_sampling_sg_v64_e64.cpp b/cpp/src/sampling/neighbor_sampling_sg_v64_e64.cpp
index 056730f8100..6237aa1ada0 100644
--- a/cpp/src/sampling/neighbor_sampling_sg_v64_e64.cpp
+++ b/cpp/src/sampling/neighbor_sampling_sg_v64_e64.cpp
@@ -40,7 +40,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
@@ -67,7 +68,8 @@ uniform_neighbor_sample(
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
   std::optional<raft::host_span<int32_t const>> fan_out,
-  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>> heterogeneous_fan_out,
+  std::optional<std::tuple<raft::host_span<int32_t const>, raft::host_span<int32_t const>>>
+    heterogeneous_fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
   bool with_replacement,
@@ -94,7 +96,7 @@ biased_neighbor_sample(
   std::optional<raft::device_span<int32_t const>> starting_vertex_labels,
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
-  //std::optional<raft::host_span<int32_t const>> fan_out,
+  // std::optional<raft::host_span<int32_t const>> fan_out,
   raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
@@ -122,7 +124,7 @@ biased_neighbor_sample(
   std::optional<raft::device_span<int32_t const>> starting_vertex_labels,
   std::optional<std::tuple<raft::device_span<int32_t const>, raft::device_span<int32_t const>>>
     label_to_output_comm_rank,
-  //std::optional<raft::host_span<int32_t const>> fan_out,
+  // std::optional<raft::host_span<int32_t const>> fan_out,
   raft::host_span<int32_t const> fan_out,
   raft::random::RngState& rng_state,
   bool return_hops,
diff --git a/python/cugraph/cugraph/dask/sampling/uniform_neighbor_sample.py b/python/cugraph/cugraph/dask/sampling/uniform_neighbor_sample.py
index 688a9d973ef..af736ce7846 100644
--- a/python/cugraph/cugraph/dask/sampling/uniform_neighbor_sample.py
+++ b/python/cugraph/cugraph/dask/sampling/uniform_neighbor_sample.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -622,7 +622,8 @@ def uniform_neighbor_sample(
         edge_type_fanout_vals = list(chain.from_iterable(list(fanout_vals.values())))
         fanout_vals = (
             numpy.asarray(edge_type_size, dtype="int32"),
-            numpy.asarray(edge_type_fanout_vals, dtype="int32"))
+            numpy.asarray(edge_type_fanout_vals, dtype="int32"),
+        )
     else:
         raise TypeError("fanout_vals must be a sequence, " f"got: {type(fanout_vals)}")
 
diff --git a/python/cugraph/cugraph/sampling/uniform_neighbor_sample.py b/python/cugraph/cugraph/sampling/uniform_neighbor_sample.py
index 7ba482f36bd..d17e070ad3a 100644
--- a/python/cugraph/cugraph/sampling/uniform_neighbor_sample.py
+++ b/python/cugraph/cugraph/sampling/uniform_neighbor_sample.py
@@ -324,9 +324,13 @@ def uniform_neighbor_sample(
         edge_type_fanout_vals = list(chain.from_iterable(list(fanout_vals.values())))
         fanout_vals = (
             numpy.asarray(edge_type_size, dtype="int32"),
-            numpy.asarray(edge_type_fanout_vals, dtype="int32"))
+            numpy.asarray(edge_type_fanout_vals, dtype="int32"),
+        )
     else:
-        raise TypeError("fanout_vals must be a sequence or a dictionary, " f"got: {type(fanout_vals)}")
+        raise TypeError(
+            "fanout_vals must be a sequence or a dictionary, "
+            f"got: {type(fanout_vals)}"
+        )
 
     if "weights" in G.edgelist.edgelist_df:
         weight_t = G.edgelist.edgelist_df["weights"].dtype
diff --git a/python/pylibcugraph/pylibcugraph/_cugraph_c/sampling_algorithms.pxd b/python/pylibcugraph/pylibcugraph/_cugraph_c/sampling_algorithms.pxd
index a9cea82c3d7..c833abae5a9 100644
--- a/python/pylibcugraph/pylibcugraph/_cugraph_c/sampling_algorithms.pxd
+++ b/python/pylibcugraph/pylibcugraph/_cugraph_c/sampling_algorithms.pxd
@@ -104,10 +104,10 @@ cdef extern from "cugraph_c/sampling_algorithms.h":
             cugraph_type_erased_device_array_t** vertices,
             cugraph_error_t** error
         )
-    
+
     ctypedef struct cugraph_sample_heterogeneous_fanout_t:
         pass
-    
+
     cdef cugraph_error_code_t \
         cugraph_create_heterogeneous_fanout(
             const cugraph_resource_handle_t* handle,
diff --git a/python/pylibcugraph/pylibcugraph/uniform_neighbor_sample.pyx b/python/pylibcugraph/pylibcugraph/uniform_neighbor_sample.pyx
index fee88b4d16f..c4887414122 100644
--- a/python/pylibcugraph/pylibcugraph/uniform_neighbor_sample.pyx
+++ b/python/pylibcugraph/pylibcugraph/uniform_neighbor_sample.pyx
@@ -238,7 +238,7 @@ def uniform_neighbor_sample(ResourceHandle resource_handle,
         assert_AI_type(h_fan_out, "h_fan_out")
         ai_fan_out_ptr = \
             h_fan_out.__array_interface__["data"][0]
-        
+
         fan_out_ptr = \
             cugraph_type_erased_host_array_view_create(
                 <void*>ai_fan_out_ptr,
@@ -257,13 +257,13 @@ def uniform_neighbor_sample(ResourceHandle resource_handle,
                 <void*>ai_fan_out_size_ptr,
                 len(h_fan_out[0]),
                 get_c_type_from_numpy_type(h_fan_out[0].dtype))
-    
+
         fan_out_values_ptr = \
             cugraph_type_erased_host_array_view_create(
                 <void*>ai_fan_out_values_ptr,
                 len(h_fan_out[1]),
                 get_c_type_from_numpy_type(h_fan_out[1].dtype))
-        
+
         error_code = cugraph_create_heterogeneous_fanout(
             c_resource_handle_ptr,
             c_graph_ptr,