Geode-solutions · BenPinet · Jun 8, 2026 · Jun 9, 2026 · Jun 12, 2026 · Jun 12, 2026
diff --git a/bindings/python/src/basic/attribute.cpp b/bindings/python/src/basic/attribute.cpp
@@ -53,23 +53,47 @@ namespace geode
             std::shared_ptr< VariableAttribute< type > > >(
             module, variable_name.c_str() )
             .def( "set_value", &VariableAttribute< type >::set_value )
-            .def( "default_value", &VariableAttribute< type >::default_value );
+            .def(
+                "default_values", &VariableAttribute< type >::default_values );
         const auto sparse_name = absl::StrCat( "SparseAttribute", typestr );
         pybind11::class_< SparseAttribute< type >, ReadOnlyAttribute< type >,
             std::shared_ptr< SparseAttribute< type > > >(
             module, sparse_name.c_str() )
             .def( "set_value", &SparseAttribute< type >::set_value )
-            .def( "default_value", &SparseAttribute< type >::default_value );
+            .def( "default_values", &SparseAttribute< type >::default_values );
+    }
+
+    template < typename type >
+    void python_attribute_values_class(
+        pybind11::module& module, const std::string& typestr )
+    {
+        const auto values_name = absl::StrCat( "AttributeValues", typestr );
+        pybind11::class_< AttributeValues< type > >(
+            module, values_name.c_str() )
+            .def( pybind11::init<>() )
+            .def_readwrite(
+                "default_value", &AttributeValues< type >::default_value )
+            .def_readwrite( "no_value", &AttributeValues< type >::no_value );
     }
 
     void define_attributes( pybind11::module& module )
     {
         pybind11::class_< AttributeProperties >( module, "AttributeProperties" )
             .def( pybind11::init<>() )
-            .def( pybind11::init< bool, bool >() )
             .def_readwrite( "assignable", &AttributeProperties::assignable )
+            .def_readwrite( "interpolable", &AttributeProperties::interpolable )
             .def_readwrite(
-                "interpolable", &AttributeProperties::interpolable );
+                "transferable", &AttributeProperties::transferable );
+
+        python_attribute_values_class< bool >( module, "Bool" );
+        python_attribute_values_class< int >( module, "Int" );
+        python_attribute_values_class< unsigned int >( module, "UInt" );
+        python_attribute_values_class< float >( module, "Float" );
+        python_attribute_values_class< double >( module, "Double" );
+        python_attribute_values_class< std::array< double, 2 > >(
+            module, "ArrayDouble2" );
+        python_attribute_values_class< std::array< double, 3 > >(
+            module, "ArrayDouble3" );
 
         pybind11::class_< AttributeBase, std::shared_ptr< AttributeBase > >(
             module, "AttributeBase" )

diff --git a/bindings/python/src/basic/attribute_manager.cpp b/bindings/python/src/basic/attribute_manager.cpp
@@ -36,30 +36,66 @@ namespace geode
     void python_attribute_class( pybind11::class_< AttributeManager >& manager,
         const std::string& suffix )
     {
-        const auto read_suffix = absl::StrCat( "find_attribute_", suffix );
-        manager.def(
-            read_suffix.c_str(), &AttributeManager::find_attribute< type > );
-        const auto constant_suffix =
-            absl::StrCat( "find_or_create_attribute_constant_", suffix );
-        manager.def( constant_suffix.c_str(),
+        const auto read_suffix =
+            absl::StrCat( "find_read_only_attribute_", suffix );
+        manager.def( read_suffix.c_str(),
+            &AttributeManager::find_read_only_attribute< type > );
+        const auto create_constant_suffix =
+            absl::StrCat( "create_attribute_constant_", suffix );
+        manager.def( create_constant_suffix.c_str(),
+            static_cast< geode::uuid ( AttributeManager::* )( std::string_view,
+                AttributeValues< type >, AttributeProperties ) >(
+                &AttributeManager::create_attribute< ConstantAttribute,
+                    type > ) );
+        manager.def( create_constant_suffix.c_str(),
+            static_cast< void ( AttributeManager::* )( std::string_view,
+                const uuid&, AttributeValues< type >, AttributeProperties ) >(
+                &AttributeManager::create_attribute< ConstantAttribute,
+                    type > ) );
+        const auto find_constant_suffix =
+            absl::StrCat( "find_attribute_constant_", suffix );
+        manager.def( find_constant_suffix.c_str(),
             static_cast< std::shared_ptr< ConstantAttribute< type > > (
-                AttributeManager::* )( std::string_view, type ) >(
-                &AttributeManager::find_or_create_attribute< ConstantAttribute,
+                AttributeManager::* )( const geode::uuid& ) >(
+                &AttributeManager::find_attribute< ConstantAttribute,
+                    type > ) );
+        const auto create_variable_suffix =
+            absl::StrCat( "create_attribute_variable_", suffix );
+        manager.def( create_variable_suffix.c_str(),
+            static_cast< geode::uuid ( AttributeManager::* )( std::string_view,
+                AttributeValues< type >, AttributeProperties ) >(
+                &AttributeManager::create_attribute< VariableAttribute,
+                    type > ) );
+        manager.def( create_variable_suffix.c_str(),
+            static_cast< void ( AttributeManager::* )( std::string_view,
+                const uuid&, AttributeValues< type >, AttributeProperties ) >(
+                &AttributeManager::create_attribute< VariableAttribute,
                     type > ) );
-        const auto variable_suffix =
-            absl::StrCat( "find_or_create_attribute_variable_", suffix );
-        manager.def( variable_suffix.c_str(),
+        const auto find_variable_suffix =
+            absl::StrCat( "find_attribute_variable_", suffix );
+        manager.def( find_variable_suffix.c_str(),
             static_cast< std::shared_ptr< VariableAttribute< type > > (
-                AttributeManager::* )( std::string_view, type ) >(
-                &AttributeManager::find_or_create_attribute< VariableAttribute,
+                AttributeManager::* )( const geode::uuid& ) >(
+                &AttributeManager::find_attribute< VariableAttribute,
                     type > ) );
-        const auto sparse_suffix =
-            absl::StrCat( "find_or_create_attribute_sparse_", suffix );
-        manager.def( sparse_suffix.c_str(),
-            static_cast< std::shared_ptr< SparseAttribute< type > > (
-                AttributeManager::* )( std::string_view, type ) >(
-                &AttributeManager::find_or_create_attribute< SparseAttribute,
+        const auto create_sparse_suffix =
+            absl::StrCat( "create_attribute_sparse_", suffix );
+        manager.def( create_sparse_suffix.c_str(),
+            static_cast< geode::uuid ( AttributeManager::* )( std::string_view,
+                AttributeValues< type >, AttributeProperties ) >(
+                &AttributeManager::create_attribute< SparseAttribute,
+                    type > ) );
+        manager.def( create_sparse_suffix.c_str(),
+            static_cast< void ( AttributeManager::* )( std::string_view,
+                const uuid&, AttributeValues< type >, AttributeProperties ) >(
+                &AttributeManager::create_attribute< SparseAttribute,
                     type > ) );
+        const auto find_sparse_suffix =
+            absl::StrCat( "find_attribute_sparse_", suffix );
+        manager.def( find_sparse_suffix.c_str(),
+            static_cast< std::shared_ptr< SparseAttribute< type > > (
+                AttributeManager::* )( const geode::uuid& ) >(
+                &AttributeManager::find_attribute< SparseAttribute, type > ) );
     }
 
     void define_attribute_manager( pybind11::module& module )
@@ -69,7 +105,7 @@ namespace geode
         manager.def( pybind11::init<>() )
             .def( "find_generic_attribute",
                 &AttributeManager::find_generic_attribute )
-            .def( "attribute_names", &AttributeManager::attribute_names )
+            .def( "attribute_ids", &AttributeManager::attribute_ids )
             .def( "attribute_type", &AttributeManager::attribute_type )
             .def( "attribute_exists", &AttributeManager::attribute_exists )
             .def( "nb_elements", &AttributeManager::nb_elements )
@@ -80,7 +116,9 @@ namespace geode
             .def( "delete_attribute", &AttributeManager::delete_attribute )
             .def( "set_attribute_properties",
                 &AttributeManager::set_attribute_properties )
-            .def( "delete_elements", &AttributeManager::delete_elements );
+            .def( "delete_elements", &AttributeManager::delete_elements )
+            .def( "attribute_ids_matching_name",
+                &AttributeManager::attribute_ids_matching_name );
         python_attribute_class< bool >( manager, "bool" );
         python_attribute_class< int >( manager, "int" );
         python_attribute_class< unsigned int >( manager, "uint" );

diff --git a/bindings/python/src/geometry/basic_objects.cpp b/bindings/python/src/geometry/basic_objects.cpp
@@ -42,8 +42,6 @@
         .def( pybind11::init< const Point< dimension >&,                       \
             const Point< dimension >& >() )                                    \
         .def( "direction", &Segment##dimension##D::direction )                 \
-        .def( "normalized_direction",                                          \
-            &Segment##dimension##D::normalized_direction )                     \
         .def( "barycenter", &Segment##dimension##D::barycenter )               \
         .def( "length", &Segment##dimension##D::length )                       \
         .def( "vertices", &Segment##dimension##D::vertices )                   \

diff --git a/bindings/python/src/geometry/sign.cpp b/bindings/python/src/geometry/sign.cpp
@@ -34,10 +34,10 @@ namespace geode
     {
         module.def( "tetrahedron_volume_sign", &tetrahedron_volume_sign );
         module.def( "triangle_area_sign2D",
-            static_cast< Sign ( * )( const Triangle2D& ) >(
+            static_cast< SIGN ( * )( const Triangle2D& ) >(
                 &triangle_area_sign ) );
         module.def( "triangle_area_sign3D",
-            static_cast< Sign ( * )( const Triangle3D&, local_index_t ) >(
+            static_cast< SIGN ( * )( const Triangle3D&, local_index_t ) >(
                 &triangle_area_sign ) );
     }
 } // namespace geode
diff --git a/bindings/python/src/mesh/helpers/geometrical_operations_on_mesh.cpp b/bindings/python/src/mesh/helpers/geometrical_operations_on_mesh.cpp
@@ -43,13 +43,13 @@
     const auto translate_name##mesh##dimension = absl::StrCat(                 \
         "translate_", mesh_name, std::to_string( dimension ), "D" );           \
     module.def( translate_name##mesh##dimension.c_str(),                       \
-        &translate_mesh< mesh, mesh##Builder, dimension > )
+        &translate_mesh< mesh##dimension##D > )
 
 #define PYTHON_RESCALE( mesh, mesh_name, dimension )                           \
     const auto rescale_name##mesh##dimension = absl::StrCat(                   \
         "rescale_", mesh_name, std::to_string( dimension ), "D" );             \
     module.def( rescale_name##mesh##dimension.c_str(),                         \
-        &rescale_mesh< mesh, mesh##Builder, dimension > )
+        &rescale_mesh< mesh##dimension##D > )
 
 namespace geode
 {

diff --git a/bindings/python/src/model/mixin/builder/block_collections_builder.cpp b/bindings/python/src/model/mixin/builder/block_collections_builder.cpp
@@ -26,6 +26,7 @@
 #include <geode/basic/uuid.hpp>
 
 #include <geode/model/mixin/builder/block_collections_builder.hpp>
+#include <geode/model/mixin/core/block_collection.hpp>
 
 #define PYTHON_BLOCK_COLLECTIONS_BUILDER( dimension )                          \
     const auto name##dimension =                                               \

diff --git a/bindings/python/src/model/mixin/builder/corner_collections_builder.cpp b/bindings/python/src/model/mixin/builder/corner_collections_builder.cpp
@@ -26,6 +26,7 @@
 #include <geode/basic/uuid.hpp>
 
 #include <geode/model/mixin/builder/corner_collections_builder.hpp>
+#include <geode/model/mixin/core/corner_collection.hpp>
 
 #define PYTHON_CORNER_COLLECTIONS_BUILDER( dimension )                         \
     const auto name##dimension =                                               \

diff --git a/bindings/python/src/model/mixin/builder/corners_builder.cpp b/bindings/python/src/model/mixin/builder/corners_builder.cpp
@@ -28,6 +28,7 @@
 #include <geode/mesh/builder/point_set_builder.hpp>
 
 #include <geode/model/mixin/builder/corners_builder.hpp>
+#include <geode/model/mixin/core/corner.hpp>
 
 #define PYTHON_CORNERS_BUILDER( dimension )                                    \
     const auto name##dimension =                                               \

diff --git a/bindings/python/src/model/mixin/builder/line_collections_builder.cpp b/bindings/python/src/model/mixin/builder/line_collections_builder.cpp
@@ -26,6 +26,7 @@
 #include <geode/basic/uuid.hpp>
 
 #include <geode/model/mixin/builder/line_collections_builder.hpp>
+#include <geode/model/mixin/core/line_collection.hpp>
 
 #define PYTHON_LINE_COLLECTIONS_BUILDER( dimension )                           \
     const auto name##dimension =                                               \

diff --git a/bindings/python/src/model/mixin/builder/lines_builder.cpp b/bindings/python/src/model/mixin/builder/lines_builder.cpp
@@ -28,6 +28,7 @@
 #include <geode/mesh/builder/edged_curve_builder.hpp>
 
 #include <geode/model/mixin/builder/lines_builder.hpp>
+#include <geode/model/mixin/core/line.hpp>
 
 #define PYTHON_LINES_BUILDER( dimension )                                      \
     const auto name##dimension =                                               \

diff --git a/bindings/python/src/model/mixin/builder/model_boundaries_builder.cpp b/bindings/python/src/model/mixin/builder/model_boundaries_builder.cpp
@@ -26,6 +26,7 @@
 #include <geode/basic/uuid.hpp>
 
 #include <geode/model/mixin/builder/model_boundaries_builder.hpp>
+#include <geode/model/mixin/core/model_boundary.hpp>
 
 #define PYTHON_MODEL_BOUNDARIES_BUILDER( dimension )                           \
     const auto name##dimension =                                               \

diff --git a/bindings/python/src/model/mixin/builder/surface_collections_builder.cpp b/bindings/python/src/model/mixin/builder/surface_collections_builder.cpp
@@ -26,6 +26,7 @@
 #include <geode/basic/uuid.hpp>
 
 #include <geode/model/mixin/builder/surface_collections_builder.hpp>
+#include <geode/model/mixin/core/surface_collection.hpp>
 
 #define PYTHON_SURFACE_COLLECTIONS_BUILDER( dimension )                        \
     const auto name##dimension =                                               \

diff --git a/bindings/python/src/model/mixin/core/component_type.cpp b/bindings/python/src/model/mixin/core/component_type.cpp
@@ -38,12 +38,9 @@ namespace geode
         pybind11::class_< ComponentID >( module, "ComponentID" )
             .def( pybind11::init<>() )
             .def( pybind11::init< ComponentType, uuid >() )
-            .def( "id", static_cast< const uuid& (ComponentID::*) () const& >(
-                            &ComponentID::id ) )
-            .def( "type",
-                static_cast< const ComponentType& (ComponentID::*) () const& >(
-                    &ComponentID::type ) )
             .def( "string", &ComponentID::string )
+            .def_readwrite( "type", &ComponentID::type )
+            .def_readwrite( "id", &ComponentID::id )
             .def( pybind11::self == pybind11::self )
             .def( pybind11::self != pybind11::self );
     }