Add python bindings for some DataTypes (#49)

* Add bool_() to python api

* Add complete DataType factory functions to Python API

Expands the Python API with factory functions for all DataType aliases
defined in dtypes.mojo, following the pattern established for bool_().
Adds wrapper functions for null, all integer types (int8-64, uint8-64),
floating point types (float16, float32, float64), string, and binary.

Includes comprehensive tests verifying all factory functions return
correct DataType instances.

Based on initial bool_() implementation pattern.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: winding-lines

firebolt/module/__init__.mojo

@@ -0,0 +1,131 @@
+"""Python interface for dtypes."""
+
+from python.bindings import PythonModuleBuilder, PythonObject
+from firebolt import dtypes
+
+
+fn null() raises -> PythonObject:
+    """Create a null DataType."""
+    var result = materialize[dtypes.null]()
+    return PythonObject(alloc=result^)
+
+
+fn bool_() raises -> PythonObject:
+    """Create a boolean DataType."""
+    var result = materialize[dtypes.bool_]()
+    return PythonObject(alloc=result^)
+
+
+fn int8() raises -> PythonObject:
+    """Create an int8 DataType."""
+    var result = materialize[dtypes.int8]()
+    return PythonObject(alloc=result^)
+
+
+fn int16() raises -> PythonObject:
+    """Create an int16 DataType."""
+    var result = materialize[dtypes.int16]()
+    return PythonObject(alloc=result^)
+
+
+fn int32() raises -> PythonObject:
+    """Create an int32 DataType."""
+    var result = materialize[dtypes.int32]()
+    return PythonObject(alloc=result^)
+
+
+fn int64() raises -> PythonObject:
+    """Create an int64 DataType."""
+    var result = materialize[dtypes.int64]()
+    return PythonObject(alloc=result^)
+
+
+fn uint8() raises -> PythonObject:
+    """Create a uint8 DataType."""
+    var result = materialize[dtypes.uint8]()
+    return PythonObject(alloc=result^)
+
+
+fn uint16() raises -> PythonObject:
+    """Create a uint16 DataType."""
+    var result = materialize[dtypes.uint16]()
+    return PythonObject(alloc=result^)
+
+
+fn uint32() raises -> PythonObject:
+    """Create a uint32 DataType."""
+    var result = materialize[dtypes.uint32]()
+    return PythonObject(alloc=result^)
+
+
+fn uint64() raises -> PythonObject:
+    """Create a uint64 DataType."""
+    var result = materialize[dtypes.uint64]()
+    return PythonObject(alloc=result^)
+
+
+fn float16() raises -> PythonObject:
+    """Create a float16 DataType."""
+    var result = materialize[dtypes.float16]()
+    return PythonObject(alloc=result^)
+
+
+fn float32() raises -> PythonObject:
+    """Create a float32 DataType."""
+    var result = materialize[dtypes.float32]()
+    return PythonObject(alloc=result^)
+
+
+fn float64() raises -> PythonObject:
+    """Create a float64 DataType."""
+    var result = materialize[dtypes.float64]()
+    return PythonObject(alloc=result^)
+
+
+fn string() raises -> PythonObject:
+    """Create a string DataType."""
+    var result = materialize[dtypes.string]()
+    return PythonObject(alloc=result^)
+
+
+fn binary() raises -> PythonObject:
+    """Create a binary DataType."""
+    var result = materialize[dtypes.binary]()
+    return PythonObject(alloc=result^)
+
+
+def add_to_module(mut builder: PythonModuleBuilder) -> None:
+    """Add DataType related data to the Python API."""
+
+    _ = builder.add_type[dtypes.DataType]("DataType")
+    builder.def_function[null]("null", docstring="Create a null DataType.")
+    builder.def_function[bool_]("bool_", docstring="Create a boolean DataType.")
+    builder.def_function[int8]("int8", docstring="Create an int8 DataType.")
+    builder.def_function[int16]("int16", docstring="Create an int16 DataType.")
+    builder.def_function[int32]("int32", docstring="Create an int32 DataType.")
+    builder.def_function[int64]("int64", docstring="Create an int64 DataType.")
+    builder.def_function[uint8]("uint8", docstring="Create a uint8 DataType.")
+    builder.def_function[uint16](
+        "uint16", docstring="Create a uint16 DataType."
+    )
+    builder.def_function[uint32](
+        "uint32", docstring="Create a uint32 DataType."
+    )
+    builder.def_function[uint64](
+        "uint64", docstring="Create a uint64 DataType."
+    )
+    builder.def_function[float16](
+        "float16", docstring="Create a float16 DataType."
+    )
+    builder.def_function[float32](
+        "float32", docstring="Create a float32 DataType."
+    )
+    builder.def_function[float64](
+        "float64", docstring="Create a float64 DataType."
+    )
+    builder.def_function[string](
+        "string", docstring="Create a string DataType."
+    )
+    builder.def_function[binary](
+        "binary", docstring="Create a binary DataType."
+    )

firebolt/module/dtypes_api.mojo

@@ -6,8 +6,9 @@ platforms = ["osx-arm64", "linux-64"]
 version = "0.1.0"
 
 [tasks]
+build_pybolt = {cmd="mojo build -I . pybolt/pybolt.mojo --emit shared-lib -o pybolt/pybolt.so"}
 test_mojo = {cmd = "mojo test firebolt -I ." }
-test_python = {cmd = "pytest -s -v pybolt/tests" }
+test_python = {cmd = "pytest -s -v pybolt/tests", depends-on=["build_pybolt"]}
 test = {depends-on = ["test_mojo", "test_python"]}
 fmt_mojo = {cmd = "mojo format firebolt"}
 fmt_python = {cmd = "ruff format pybolt" }

pixi.toml

@@ -0,0 +1 @@
+*.so

pybolt/.gitignore

@@ -1,30 +1,17 @@
 from python import PythonObject, Python
 from python.bindings import PythonModuleBuilder
 import math
+from firebolt.module.dtypes_api import add_to_module as add_dtypes
 from os import abort
 
 
 @export
 fn PyInit_pybolt() -> PythonObject:
     try:
         var m = PythonModuleBuilder("pybolt")
-        m.def_function[to_pydict](
-            "to_pydict",
-            docstring="Transform a firebolt structure to python dictionary.",
-        )
+        add_dtypes(m)
         return m.finalize()
     except e:
         return abort[PythonObject](
             String("error creating Python Mojo module:", e)
         )
-
-
-fn to_pydict(py_obj: PythonObject) raises -> PythonObject:
-    """Transform a firebolt structure to a python dictionary.
-
-    This is a dummy function used to test the infrastructure.
-    """
-
-    ref cpy = Python().cpython()
-    var dict_obj = cpy.PyDict_New()
-    return PythonObject(from_owned=dict_obj)

pybolt/pybolt.mojo

@@ -0,0 +1,2 @@
+[pytest]
+pythonpath=. 

pybolt/pytest.ini

@@ -0,0 +1,22 @@
+"""Test the DataType Python api."""
+
+import pybolt
+
+
+def test_factory_functions() -> None:
+    """Test that all DataType factory functions work and return correct types."""
+    assert isinstance(pybolt.null(), pybolt.DataType)
+    assert isinstance(pybolt.bool_(), pybolt.DataType)
+    assert isinstance(pybolt.int8(), pybolt.DataType)
+    assert isinstance(pybolt.int16(), pybolt.DataType)
+    assert isinstance(pybolt.int32(), pybolt.DataType)
+    assert isinstance(pybolt.int64(), pybolt.DataType)
+    assert isinstance(pybolt.uint8(), pybolt.DataType)
+    assert isinstance(pybolt.uint16(), pybolt.DataType)
+    assert isinstance(pybolt.uint32(), pybolt.DataType)
+    assert isinstance(pybolt.uint64(), pybolt.DataType)
+    assert isinstance(pybolt.float16(), pybolt.DataType)
+    assert isinstance(pybolt.float32(), pybolt.DataType)
+    assert isinstance(pybolt.float64(), pybolt.DataType)
+    assert isinstance(pybolt.string(), pybolt.DataType)
+    assert isinstance(pybolt.binary(), pybolt.DataType)