Change documentation to be more user oriented

Author: timsaucer

docs/source/conf.py

@@ -83,9 +83,6 @@ def autoapi_skip_member_fn(app, what, name, obj, skip, options) -> bool:  # noqa
         # Duplicate modules (skip module-level docs to avoid duplication)
         ("module", "datafusion.col"),
         ("module", "datafusion.udf"),
-        # Private variables causing duplicate documentation
-        ("data", "datafusion.utils._PYARROW_DATASET_TYPES"),
-        ("variable", "datafusion.utils._PYARROW_DATASET_TYPES"),
         # Deprecated
         ("class", "datafusion.substrait.serde"),
         ("class", "datafusion.substrait.plan"),
@@ -104,18 +101,6 @@ def autoapi_skip_member_fn(app, what, name, obj, skip, options) -> bool:  # noqa
     if (what, name) in skip_contents:
         skip = True
 
-    # Skip private module-level names (those whose final component
-    # starts with an underscore) when AutoAPI is rendering data or
-    # variable entries. Many internal module-level constants are
-    # implementation details (for example private pyarrow dataset type
-    # mappings) that would otherwise be emitted as top-level "data"
-    # or "variable" docs. Filtering them here avoids noisy,
-    # duplicate, or implementation-specific entries in the public
-    # documentation while still allowing public members and types to
-    # be documented normally.
-    if name.split(".")[-1].startswith("_") and what in ("data", "variable"):
-        skip = True
-
     return skip
 
 

docs/source/contributor-guide/ffi.rst

@@ -34,7 +34,7 @@ as performant as possible and to utilize the features of DataFusion, you may dec
 your source in Rust and then expose it through `PyO3 <https://pyo3.rs>`_ as a Python library.
 
 At first glance, it may appear the best way to do this is to add the ``datafusion-python``
-crate as a dependency, produce a DataFusion table in Rust, and then register it with the
+crate as a dependency, provide a ``PyTable``, and then to register it with the
 ``SessionContext``. Unfortunately, this will not work.
 
 When you produce your code as a Python library and it needs to interact with the DataFusion

docs/source/user-guide/data-sources.rst

@@ -155,22 +155,10 @@ as Delta Lake. This will require a recent version of
     from datafusion import Table
 
     delta_table = DeltaTable("path_to_table")
-    table = Table.from_capsule(delta_table.__datafusion_table_provider__())
-    ctx.register_table("my_delta_table", table)
+    ctx.register_table("my_delta_table", delta_table)
     df = ctx.table("my_delta_table")
     df.show()
 
-Objects that implement ``__datafusion_table_provider__`` are supported directly by
-:py:meth:`~datafusion.context.SessionContext.register_table`, making it easy to
-work with custom table providers from Python libraries such as Delta Lake.
-
-.. note::
-
-   :py:meth:`~datafusion.context.SessionContext.register_table_provider` is
-   deprecated. Use
-   :py:meth:`~datafusion.context.SessionContext.register_table` with a
-   :py:class:`~datafusion.Table` instead.
-
 On older versions of ``deltalake`` (prior to 0.22) you can use the
 `Arrow DataSet <https://arrow.apache.org/docs/python/generated/pyarrow.dataset.Dataset.html>`_
 interface to import to DataFusion, but this does not support features such as filter push down

docs/source/user-guide/io/table_provider.rst

@@ -37,7 +37,7 @@ A complete example can be found in the `examples folder <https://github.com/apac
             &self,
             py: Python<'py>,
         ) -> PyResult<Bound<'py, PyCapsule>> {
-            let name = CString::new("datafusion_table_provider").unwrap();
+            let name = cr"datafusion_table_provider".into();
 
             let provider = Arc::new(self.clone());
             let provider = FFI_TableProvider::new(provider, false, None);
@@ -48,18 +48,7 @@ A complete example can be found in the `examples folder <https://github.com/apac
 
 Once you have this library available, you can construct a
 :py:class:`~datafusion.Table` in Python and register it with the
-``SessionContext``. Tables can be created either from the PyCapsule exposed by your
-Rust provider or from an existing :py:class:`~datafusion.dataframe.DataFrame`.
-Call the provider's ``__datafusion_table_provider__()`` method to obtain the capsule
-before constructing a ``Table``. The ``Table.from_view()`` helper is
-deprecated; instead use ``Table.from_dataframe()`` or ``DataFrame.into_view()``.
-
-.. note::
-
-   :py:meth:`~datafusion.context.SessionContext.register_table_provider` is
-   deprecated. Use
-   :py:meth:`~datafusion.context.SessionContext.register_table` with the
-   resulting :py:class:`~datafusion.Table` instead.
+``SessionContext``.
 
 .. code-block:: python
 
@@ -68,18 +57,6 @@ deprecated; instead use ``Table.from_dataframe()`` or ``DataFrame.into_view()``.
     ctx = SessionContext()
     provider = MyTableProvider()
 
-    capsule = provider.__datafusion_table_provider__()
-    capsule_table = Table.from_capsule(capsule)
-
-    df = ctx.from_pydict({"a": [1]})
-    view_table = Table.from_dataframe(df)
-    # or: view_table = df.into_view()
-
-    ctx.register_table("capsule_table", capsule_table)
-    ctx.register_table("view_table", view_table)
+    ctx.register_table("capsule_table", provider)
 
     ctx.table("capsule_table").show()
-    ctx.table("view_table").show()
-
-Both ``Table.from_capsule()`` and ``Table.from_dataframe()`` create
-table providers that can be registered with the SessionContext using ``register_table()``.