Initial commit for creating wrapper classes and functions for all user facing python features

Author: timsaucer

python/datafusion/__init__.py

@@ -25,64 +25,67 @@
 
 import pyarrow as pa
 
-from ._internal import (
-    AggregateUDF,
-    Config,
-    DataFrame,
+from .context import (
     SessionContext,
     SessionConfig,
     RuntimeConfig,
-    ScalarUDF,
     SQLOptions,
 )
 
+# The following imports are okay to remain as opaque to the user.
+from ._internal import Config
+
+from .udf import ScalarUDF, AggregateUDF
+
 from .common import (
     DFSchema,
 )
 
+from .dataframe import DataFrame
+
 from .expr import (
-    Alias,
-    Analyze,
+    #     Alias,
+    #     Analyze,
     Expr,
-    Filter,
-    Limit,
-    Like,
-    ILike,
-    Projection,
-    SimilarTo,
-    ScalarVariable,
-    Sort,
-    TableScan,
-    Not,
-    IsNotNull,
-    IsTrue,
-    IsFalse,
-    IsUnknown,
-    IsNotTrue,
-    IsNotFalse,
-    IsNotUnknown,
-    Negative,
-    InList,
-    Exists,
-    Subquery,
-    InSubquery,
-    ScalarSubquery,
-    GroupingSet,
-    Placeholder,
-    Case,
-    Cast,
-    TryCast,
-    Between,
-    Explain,
-    CreateMemoryTable,
-    SubqueryAlias,
-    Extension,
-    CreateView,
-    Distinct,
-    DropTable,
-    Repartition,
-    Partitioning,
-    Window,
+    #     Filter,
+    #     Limit,
+    #     Like,
+    #     ILike,
+    #     Projection,
+    #     SimilarTo,
+    #     ScalarVariable,
+    #     Sort,
+    #     TableScan,
+    #     Not,
+    #     IsNotNull,
+    #     IsTrue,
+    #     IsFalse,
+    #     IsUnknown,
+    #     IsNotTrue,
+    #     IsNotFalse,
+    #     IsNotUnknown,
+    #     Negative,
+    #     InList,
+    #     Exists,
+    #     Subquery,
+    #     InSubquery,
+    #     ScalarSubquery,
+    #     GroupingSet,
+    #     Placeholder,
+    #     Case,
+    #     Cast,
+    #     TryCast,
+    #     Between,
+    #     Explain,
+    #     CreateMemoryTable,
+    #     SubqueryAlias,
+    #     Extension,
+    #     CreateView,
+    #     Distinct,
+    #     DropTable,
+    #     Repartition,
+    #     Partitioning,
+    #     Window,
     WindowFrame,
 )
 
@@ -96,7 +99,6 @@
     "SQLOptions",
     "RuntimeConfig",
     "Expr",
-    "AggregateUDF",
     "ScalarUDF",
     "Window",
     "WindowFrame",
@@ -175,8 +177,6 @@ def column(value):
 
 
 def literal(value):
-    if not isinstance(value, pa.Scalar):
-        value = pa.scalar(value)
     return Expr.literal(value)
 
 
@@ -200,20 +200,20 @@ def udf(func, input_types, return_type, volatility, name=None):
     )
 
 
-def udaf(accum, input_type, return_type, state_type, volatility, name=None):
+def udaf(accum, input_types, return_type, state_type, volatility, name=None):
     """
     Create a new User Defined Aggregate Function
     """
     if not issubclass(accum, Accumulator):
         raise TypeError("`accum` must implement the abstract base class Accumulator")
     if name is None:
         name = accum.__qualname__.lower()
-    if isinstance(input_type, pa.lib.DataType):
-        input_type = [input_type]
+    if isinstance(input_types, pa.lib.DataType):
+        input_types = [input_types]
     return AggregateUDF(
         name=name,
         accumulator=accum,
-        input_type=input_type,
+        input_types=input_types,
         return_type=return_type,
         state_type=state_type,
         volatility=volatility,

python/datafusion/catalog.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import datafusion._internal as df_internal
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import pyarrow
+
+
+class Catalog:
+    def __init__(self, catalog: df_internal.Catalog) -> None:
+        self.catalog = catalog
+
+    def names(self) -> list[str]:
+        return self.catalog.names()
+
+    def database(self, name: str = "public") -> Database:
+        return Database(self.catalog.database(name))
+
+
+class Database:
+    def __init__(self, db: df_internal.Database) -> None:
+        self.db = db
+
+    def names(self) -> set[str]:
+        return self.db.names()
+
+    def table(self, name: str) -> Table:
+        return Table(self.db.table(name))
+
+
+class Table:
+    def __init__(self, table: df_internal.Table) -> None:
+        self.table = table
+
+    def schema(self) -> pyarrow.Schema:
+        return self.table.schema()
+
+    @property
+    def kind(self) -> str:
+        return self.table.kind()