Support sending empty lists from Python to NEST

Author: heplesser

libnestutil/dictionary.h

@@ -95,7 +95,7 @@ class dictionary : public std::map< std::string, DictEntry_ >
   using maptype_::maptype_; // Inherit constructors
 
   /**
-   * @brief Cast the specified value to the specified type.
+   * @brief Cast the specified non-vector value to the specified type.
    *
    * @tparam T Type of element. If the value is not of the specified type, a TypeMismatch error is thrown.
    * @param value the any object to cast.
@@ -119,6 +119,44 @@ class dictionary : public std::map< std::string, DictEntry_ >
     }
   }
 
+  /**
+   * @brief Cast the specified vector value to the specified type.
+   *
+   * @tparam T Type of vector element. If the value is not of the specified type, a TypeMismatch error is thrown.
+   * @param value the any object to cast.
+   * @param key key where the value is located in the dictionary, for information upon cast errors.
+   * @throws TypeMismatch if the value is not of specified type T.
+   * @return value cast to the specified type.
+   *
+   * @note A dedicated cast_vector_value_() allows handling of empty vectors passed from the Python level.
+   */
+  template < typename T >
+  std::vector< T >
+  cast_vector_value_( const boost::any& value, const std::string& key ) const
+  {
+    // PyNEST passes vector with element type any if and only if it needs to pass
+    // and empty vector, because the element type of empty lists cannot be inferred
+    // at the Python level. The assertion just double-checks that we never get a
+    // non-empty vector-of-any.
+    if ( value.type() == typeid( std::vector< boost::any > ) )
+    {
+      assert( boost::any_cast< std::vector< boost::any > >( value ).empty() );
+      return std::vector< T >();
+    }
+
+    // Now handle vectors with elements
+    try
+    {
+      return boost::any_cast< std::vector< T > >( value );
+    }
+    catch ( const boost::bad_any_cast& )
+    {
+      std::string msg = std::string( "Failed to cast '" ) + key + "' from " + debug_type( value ) + " to type "
+        + std::string( boost::core::demangle( typeid( std::vector< T > ).name() ) );
+      throw nest::TypeMismatch( msg );
+    }
+  }
+
   /**
    * @brief Cast the specified value to an integer.
    *
@@ -180,7 +218,7 @@ class dictionary : public std::map< std::string, DictEntry_ >
   }
 
   /**
-   * @brief Update the specified value if there exists a value at key.
+   * @brief Update the specified non-vector value if there exists a value at key.
    *
    * @param key key where the value may be located in the dictionary.
    * @param value object to update if there exists a value at key.
@@ -200,6 +238,29 @@ class dictionary : public std::map< std::string, DictEntry_ >
     return false;
   }
 
+  /**
+   * @brief Update the specified vector value if there exists a value at key.
+   *
+   * @param key key where the value may be located in the dictionary.
+   * @param value object to update if there exists a value at key.
+   * @throws TypeMismatch if the value at key is not the same type as the value argument.
+   * @return Whether value was updated.
+   *
+   * @note The specialisation for values that are vectors allows handling of empty vectors passed from the Python level.
+   */
+  template < typename T >
+  bool
+  update_value( const std::string& key, std::vector< T >& value ) const
+  {
+    auto it = find( key );
+    if ( it != end() )
+    {
+      value = cast_vector_value_< T >( it->second.item, key );
+      return true;
+    }
+    return false;
+  }
+
   /**
    * @brief Update the specified value if there exists an integer value at key.
    *

pynest/nestkernel_api.pyx

@@ -221,6 +221,7 @@ cdef dictionary pydict_to_dictionary(object py_dict) except *:  # Adding "except
     for key, value in py_dict.items():
         if type(value) is tuple:
             value = list(value)
+
         if type(value) is int or isinstance(value, numpy.integer):
 	    # PYTEST-NG: Should we guard against overflow given that python int has infinite range?
             cdict[pystr_to_string(key)] = <long>value
@@ -230,6 +231,11 @@ cdef dictionary pydict_to_dictionary(object py_dict) except *:  # Adding "except
             cdict[pystr_to_string(key)] = <cbool>value
         elif type(value) is str:
             cdict[pystr_to_string(key)] = <string>pystr_to_string(value)
+        elif type(value) is list and len(value) == 0:
+            # We cannot infer the intended element type from an empty list.
+            # We therefore pass an empty vector[any]. vector[any] will always be empty
+            # and an empty vector will always be vector[any] in the PyNEST interface.
+            cdict[pystr_to_string(key)] = empty_any_vec()
         elif is_list_tuple_ndarray_of_float(value):
             cdict[pystr_to_string(key)] = pylist_or_ndarray_to_doublevec(value)
         elif is_list_tuple_ndarray_of_int(value):
@@ -253,11 +259,10 @@ cdef dictionary pydict_to_dictionary(object py_dict) except *:  # Adding "except
         else:
             typename = type(value)
             if type(value) is list:
-                if len(value) > 0:
-                    typename = f"list of {type(value[0])}"
-                else:
-                    typename = f"empty list (for which the element type cannot be determined)"
+                assert len(value) > 0   # empty list should have been caught above
+                typename = f"list of {type(value[0])}"
             raise AttributeError(f'when converting Python dictionary: value of key ({key}) is not a known type, got {typename}')
+
     return cdict
 
 
@@ -270,6 +275,11 @@ cdef object vec_of_dict_to_list(vector[dictionary] cvec):
     return tmp
 
 
+cdef vector[any] empty_any_vec():
+    cdef vector[any] empty_vec
+    return empty_vec
+
+
 cdef vector[dictionary] list_of_dict_to_vec(object pylist):
     cdef vector[dictionary] vec
     # PYNEST-NG: reserve the correct size and use index-based