Add fast C++ path for csp.Struct.from_dict and take into account the cases which may not be supported

Signed-off-by: Aadya Chinubhai <aadyachinubhai@gmail.com>

Author: aadya940

cpp/csp/python/CMakeLists.txt

@@ -17,7 +17,8 @@ add_library(csptypesimpl
             PyCspType.cpp
             PyStruct.cpp
             PyStructToJson.cpp
-            PyStructToDict.cpp)
+            PyStructToDict.cpp
+            PyStructFromDict.cpp)
 
 set_target_properties(csptypesimpl PROPERTIES PUBLIC_HEADER "${CSPTYPESIMPL_PUBLIC_HEADERS}")
 target_compile_definitions(csptypesimpl PUBLIC RAPIDJSON_HAS_STDSTRING=1)
@@ -48,7 +49,8 @@ set(CSPIMPL_PUBLIC_HEADERS
         PyOutputProxy.h
         PyConstants.h
         PyStructToJson.h
-        PyStructToDict.h)
+        PyStructToDict.h
+        PyStructFromDict.h)
 
 add_library(cspimpl SHARED
         cspimpl.cpp

cpp/csp/python/PyStruct.cpp

@@ -7,6 +7,7 @@
 #include <csp/python/PyStructList_impl.h>
 #include <csp/python/PyStructToJson.h>
 #include <csp/python/PyStructToDict.h>
+#include <csp/python/PyStructFromDict.h>
 #include <unordered_set>
 #include <type_traits>
 
@@ -1052,6 +1053,20 @@ PyObject * PyStruct_to_dict( PyStruct * self, PyObject * args, PyObject * kwargs
     CSP_RETURN_NULL;
 }
 
+PyObject * PyStruct_from_dict( PyStructMeta * cls, PyObject * args, PyObject * kwargs) {
+    CSP_BEGIN_METHOD;
+
+    PyObject* dict = NULL;
+
+    if (!PyArg_ParseTuple(args, "O:from_dict", &dict)) {
+        return NULL;
+    }
+    auto& struct_meta = cls->structMeta;
+    return toPython(structFromDict(struct_meta, dict));
+
+    CSP_RETURN_NULL;
+}
+
 PyObject * PyStruct_to_json( PyStruct * self, PyObject * args, PyObject * kwargs )
 {
     CSP_BEGIN_METHOD;
@@ -1087,6 +1102,7 @@ static PyMethodDef PyStruct_methods[] = {
     { "all_fields_set", (PyCFunction) PyStruct_all_fields_set, METH_NOARGS, "return true if all fields on the struct are set" },
     { "to_dict",        (PyCFunction) PyStruct_to_dict,        METH_VARARGS | METH_KEYWORDS, "return a python dict of the struct by recursively converting struct members into python dicts" },
     { "to_json",        (PyCFunction) PyStruct_to_json,        METH_VARARGS | METH_KEYWORDS, "return a json string of the struct by recursively converting struct members into json format" },
+    { "from_dict",     (PyCFunction) PyStruct_from_dict,      METH_VARARGS | METH_KEYWORDS | METH_CLASS, "return a struct by recursively reading the values from a python dictionary"},
     { NULL}
 };
 

cpp/csp/python/PyStructFromDict.cpp

@@ -0,0 +1,90 @@
+#include <csp/python/PyStructFromDict.h>
+
+namespace csp::python{
+    
+StructPtr structFromDict (const StructMetaPtr& struct_meta, PyObject* dict) {
+    PyObject* py_key;
+    PyObject* py_value;
+    Py_ssize_t ppos = 0;
+
+    if (!PyDict_Check(dict)) {
+        CSP_THROW(TypeError, "Wrong type used in `from_dict`, expected a dict.");
+    }
+
+    StructPtr s = struct_meta->create();
+    while( PyDict_Next( dict, &ppos, &py_key, &py_value ) )
+   {
+    if( !PyUnicode_Check( py_key ) )
+        CSP_THROW( KeyError, "Unexpected key " << PyObjectPtr::incref( py_key )
+                             << " for type " << struct_meta -> name() );
+
+    auto & field = struct_meta -> field( PyUnicode_AsUTF8( py_key ) );
+    if( !field )
+        CSP_THROW( KeyError, "Unexpected key " << PyObjectPtr::incref( py_key )
+                             << " for type " << struct_meta -> name() );
+
+    switchCspType(field->type(), [&] (auto tag)
+    {
+      using CType = typename decltype( tag )::type;
+      auto * typedField = static_cast<const typename StructField::upcast<CType>::type *>( field.get() );
+
+      //optional fields accept None, same as PyStruct_setattrs
+      if( typedField -> isOptional() && py_value == Py_None )
+      {
+          typedField -> setNone( s.get() );
+          typedField -> clearValue( s.get() );
+          return;
+      }
+
+      if constexpr (std::is_same_v<CType, StructPtr>)
+      {
+        auto& nestedMeta = static_cast<const CspStructType &>(* field->type()).meta();
+        typedField -> setValue(s.get(), structFromDict(nestedMeta, py_value));
+      }
+      else if constexpr( std::is_same_v<CType, CspEnum> )
+      {
+        //enums arrive as name strings unless to_dict was called with preserve_enums
+        auto & enumMeta = static_cast<const CspEnumType &>( *field -> type() ).meta();
+        if( PyUnicode_Check( py_value ) )
+            typedField -> setValue( s.get(), enumMeta -> fromString( PyUnicode_AsUTF8( py_value ) ) );
+        else
+            typedField -> setValue( s.get(), fromPython<CType>( py_value, *field -> type() ) );
+      }
+      else if constexpr( std::is_same_v<CType, std::vector<CspEnum>> )
+      {
+        //convert element-wise, entries may be names or enum objects
+        auto & elemType = static_cast<const CspArrayType &>( *field -> type() ).elemType();
+        auto & enumMeta = static_cast<const CspEnumType &>( *elemType ).meta();
+
+        PyObjectPtr seq = PyObjectPtr::own( PySequence_Fast( py_value, "expected a sequence of enum values" ) );
+        if( !seq.ptr() )
+            CSP_THROW( PythonPassthrough, "" );
+
+        std::vector<CspEnum> out;
+        Py_ssize_t n = PySequence_Fast_GET_SIZE( seq.ptr() );
+        out.reserve( n );
+        for( Py_ssize_t i = 0; i < n; ++i )
+        {
+            PyObject * elem = PySequence_Fast_GET_ITEM( seq.ptr(), i );
+            out.push_back( PyUnicode_Check( elem ) ? enumMeta -> fromString( PyUnicode_AsUTF8( elem ) )
+                                                   : fromPython<CspEnum>( elem, *elemType ) );
+        }
+        typedField -> setValue( s.get(), out );
+      }
+      else
+      {
+      typedField -> setValue(s.get(), fromPython<CType>(py_value, *field->type()));
+      }
+   });
+ 
+    }
+
+    //we bypass __init__ so run the strict-struct check ourselves
+    if( !s -> validate() ) [[unlikely]]
+        CSP_THROW( ValueError, "Struct " << struct_meta -> name() << " is not valid; required fields "
+                               << s -> formatAllUnsetStrictFields() << " were not set on init" );
+
+    return s;
+}
+
+}

cpp/csp/python/PyStructFromDict.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <csp/python/Conversions.h>
+
+namespace csp::python 
+{
+
+    // Build a csp struct from a python dictionary.
+    StructPtr structFromDict( const StructMetaPtr& struct_meta, PyObject* dict);
+
+}

csp/impl/struct.py

@@ -1,6 +1,7 @@
 import io
 import typing
 from copy import deepcopy
+from datetime import date, datetime, time, timedelta
 
 import ruamel.yaml
 from deprecated import deprecated
@@ -13,6 +14,27 @@
 # Avoid recreating this object every call its expensive!
 g_YAML = ruamel.yaml.YAML()
 
+# field annotations the C++ from_dict converts natively
+_CPP_FROMDICT_SCALARS = (int, float, bool, str, bytes, datetime, date, time, timedelta, object)
+
+
+def _cpp_fromdict_type_ok(typ, seen):
+    if CspTypingUtils.is_union_type(typ):
+        return True
+    if CspTypingUtils.is_generic_container(typ):
+        origin = CspTypingUtils.get_origin(typ)
+        if origin in (csp.typing.NumpyNDArray, csp.typing.Numpy1DArray):
+            return True
+        if origin in (typing.List, typing.Set, typing.Tuple, FastList):
+            elem = typ.__args__[0]
+            return isinstance(elem, type) and not issubclass(elem, Struct) and _cpp_fromdict_type_ok(elem, seen)
+        return False  # Dict[K,V] etc: type parameters are erased before C++
+    if isinstance(typ, type):
+        if issubclass(typ, Struct):
+            return typ._cpp_from_dict_ok(seen)
+        return issubclass(typ, csp.Enum) or typ in _CPP_FROMDICT_SCALARS
+    return False  # Literal, ForwardRef, etc
+
 
 class StructMeta(_csptypesimpl.PyStructMeta):
     def __new__(cls, name, bases, dct, strict=False):
@@ -275,10 +297,26 @@ def _obj_from_python(cls, json, obj_type):
             else:
                 return obj_type(json)
 
+    @classmethod
+    def _cpp_from_dict_ok(cls, _seen=None):
+        """True if every field (recursively) is convertible by the C++ from_dict, cached per class"""
+        ok = cls.__dict__.get("__cpp_fromdict_ok__")
+        if ok is None:
+            _seen = _seen if _seen is not None else set()
+            if cls in _seen:
+                return True
+            _seen.add(cls)
+            cls.__cpp_fromdict_ok__ = ok = all(
+                _cpp_fromdict_type_ok(t, _seen) for t in cls.__full_metadata_typed__.values()
+            )
+        return ok
+
     @classmethod
     def from_dict(cls, json: dict, use_pydantic: bool = False):
         if use_pydantic:
             return cls.type_adapter().validate_python(json)
+        if cls._cpp_from_dict_ok():
+            return super().from_dict(json)
         return cls._obj_from_python(json, cls)
 
     def to_dict_depr(self):