Add binding validations for passing std::any around

Author: raulcd

c_glib/arrow-glib/file-system.cpp

@@ -640,6 +640,42 @@ garrow_file_system_create(const gchar *uri, GError **error)
   }
 }
 
+/**
+ * garrow_file_system_example_accept_options:
+ * @string_value: A string option value.
+ * @int_value: An integer option value.
+ * @typed_value: An integer used to build a typed option value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * This is a showcase demonstrating that backend-specific options, stored
+ * as `std::any` in #arrow::fs::FileSystemFactoryOptions, can be built from
+ * the C GLib bindings and consumed by Arrow C++.
+ *
+ * Returns: (nullable) (transfer full): A string describing the options
+ *   received by Arrow C++, or %NULL on error.
+ *
+ * Since: 25.0.0
+ */
+gchar *
+garrow_file_system_example_accept_options(const gchar *string_value,
+                                          gint int_value,
+                                          gint typed_value,
+                                          GError **error)
+{
+  arrow::fs::FileSystemFactoryOptions options = {
+    {"example_option_string", std::any{std::string(string_value)}},
+    {"example_option_int", std::any{static_cast<int>(int_value)}},
+    {"example_option_typed_var",
+     std::any{arrow::fs::ExampleOption(static_cast<int>(typed_value))}},
+  };
+  auto result = arrow::fs::ExampleAcceptOptions(options);
+  if (garrow::check(error, result, "[file-system][example-accept-options]")) {
+    return g_strdup(result->c_str());
+  } else {
+    return NULL;
+  }
+}
+
 /**
  * garrow_file_system_get_type_name:
  * @file_system: A #GArrowFileSystem.

c_glib/arrow-glib/file-system.h

@@ -100,6 +100,13 @@ struct _GArrowFileSystemClass
   GObjectClass parent_class;
 };
 
+GARROW_AVAILABLE_IN_25_0
+gchar *
+garrow_file_system_example_accept_options(const gchar *string_value,
+                                          gint int_value,
+                                          gint typed_value,
+                                          GError **error);
+
 GARROW_AVAILABLE_IN_3_0
 GArrowFileSystem *
 garrow_file_system_create(const gchar *uri, GError **error);

c_glib/test/test-mock-file-system.rb

@@ -27,4 +27,11 @@ def setup
   def test_type_name
     assert_equal("mock", @fs.type_name)
   end
+
+  def test_example_accept_options
+    assert_equal("example_option_string=str(hi);" +
+                  "example_option_int=int(42);" +
+                  "example_option_typed_var=typed(7);",
+                 Arrow::FileSystem.example_accept_options("hi", 42, 7))
+  end
 end

cpp/src/arrow/filesystem/filesystem.cc

@@ -964,6 +964,23 @@ Result<std::shared_ptr<FileSystem>> FileSystemFromUriReal(
 
 }  // namespace
 
+Result<std::string> ExampleAcceptOptions(const FileSystemFactoryOptions& options) {
+  if (options.empty()) return Status::Invalid("no options");
+  std::string out;
+  for (const auto& [key, value] : options) {
+    if (const auto* s = std::any_cast<std::string>(&value)) {
+      out += key + "=str(" + *s + ");";
+    } else if (const auto* i = std::any_cast<int>(&value)) {
+      out += key + "=int(" + std::to_string(*i) + ");";
+    } else if (const auto* t = std::any_cast<ExampleOption>(&value)) {
+      out += key + "=typed(" + std::to_string(t->value()) + ");";
+    } else {
+      return Status::Invalid("option '", key, "' has unsupported type");
+    }
+  }
+  return out;
+}
+
 Result<std::shared_ptr<FileSystem>> FileSystemFromUri(const std::string& uri_string,
                                                       std::string* out_path) {
   return FileSystemFromUriAndOptions(uri_string, /*options=*/{}, io::default_io_context(),

cpp/src/arrow/filesystem/filesystem.h

@@ -361,6 +361,18 @@ class ARROW_EXPORT FileSystem
 
 using FileSystemFactoryOptions = std::vector<std::pair<std::string, std::any>>;
 
+class ARROW_EXPORT ExampleOption {
+ public:
+  explicit ExampleOption(int value) : value_(value) {}
+  int value() const { return value_; }
+
+ private:
+  int value_;
+};
+
+ARROW_EXPORT
+Result<std::string> ExampleAcceptOptions(const FileSystemFactoryOptions& options);
+
 struct FileSystemFactory {
   std::function<Result<std::shared_ptr<FileSystem>>(
       const Uri& uri, const FileSystemFactoryOptions& options,

python/pyarrow/_fs.pyx

@@ -1651,3 +1651,21 @@ def _copy_files_selector(FileSystem source_fs, FileSelector source_sel,
             destination_fs.unwrap(), c_destination_base_dir,
             c_default_io_context(), chunk_size, use_threads,
         ))
+
+
+def _example_accept_options(str value, int value_int, int value_typed):
+    cdef:
+        CFSFileSystemFactoryOptions options
+        pair[c_string, c_any] entry
+        c_string result
+    entry.first = tobytes("example_option_string")
+    entry.second = <c_string>tobytes(value)
+    options.push_back(entry)
+    entry.first = tobytes("example_option_int")
+    entry.second = <int>value_int
+    options.push_back(entry)
+    entry.first = tobytes("example_option_typed_var")
+    entry.second = CExampleOption(value_typed)
+    options.push_back(entry)
+    result = GetResultValue(CExampleAcceptOptions(options))
+    return frombytes(result)

python/pyarrow/fs.py

@@ -33,6 +33,7 @@
     PyFileSystem,
     _copy_files,
     _copy_files_selector,
+    _example_accept_options
 )
 
 # For backward compatibility.

python/pyarrow/includes/common.pxd

@@ -20,6 +20,7 @@
 from libc.stdint cimport *
 
 from libcpp cimport bool as c_bool, nullptr
+from libcpp.any cimport any as c_any
 from libcpp.functional cimport function
 from libcpp.memory cimport (shared_ptr, unique_ptr, make_shared,
                             static_pointer_cast, dynamic_pointer_cast)

python/pyarrow/includes/libarrow_fs.pxd

@@ -29,6 +29,12 @@ cdef extern from "arrow/filesystem/api.h" namespace "arrow::fs" nogil:
         CFileType_File "arrow::fs::FileType::File"
         CFileType_Directory "arrow::fs::FileType::Directory"
 
+    ctypedef vector[pair[c_string, c_any]] CFSFileSystemFactoryOptions "arrow::fs::FileSystemFactoryOptions"
+    CResult[c_string] CExampleAcceptOptions "arrow::fs::ExampleAcceptOptions"(const CFSFileSystemFactoryOptions& options)
+    cdef cppclass CExampleOption "arrow::fs::ExampleOption":
+        CExampleOption(int value)
+        int value() const
+
     cdef cppclass CFileInfo "arrow::fs::FileInfo":
         CFileInfo()
         CFileInfo(CFileInfo)

python/pyarrow/tests/test_fs.py

@@ -36,7 +36,7 @@
 from pyarrow.fs import (FileType, FileInfo, FileSelector, FileSystem,
                         LocalFileSystem, SubTreeFileSystem, _MockFileSystem,
                         FileSystemHandler, PyFileSystem, FSSpecHandler,
-                        copy_files)
+                        copy_files, _example_accept_options)
 from pyarrow.util import find_free_port
 
 
@@ -2285,3 +2285,10 @@ def test_huggingface_filesystem_from_uri():
     expected_fs = PyFileSystem(FSSpecHandler(HfFileSystem()))
     assert fs == expected_fs
     assert path == "datasets/stanfordnlp/imdb/plain_text/train-00000-of-00001.parquet"
+
+
+def test_example_accept_options():
+    result = _example_accept_options("hi", 42, 7)
+    expected = "example_option_string=str(hi);example_option_int=int(42);" + \
+        "example_option_typed_var=typed(7);"
+    assert result == expected