Merge pull request libdynd#451 from izaid/gfunc

Removed remaining array_functions code from gfunc_callable

Author: izaid

appveyor.yml

@@ -3,6 +3,8 @@ skip_tags: true
 
 clone_depth: 1
 
+os: Visual Studio 2015
+
 matrix:
   fast_finish: true     # immediately finish build once one of the jobs fails.
 

dynd/include/array_assign_from_py.hpp

@@ -21,8 +21,9 @@ namespace pydynd {
  * \param a  The array which is being assigned to.
  * \param value  value PyObject for the source data.
  */
-void array_broadcast_assign_from_py(const dynd::nd::array &a, PyObject *value,
-                                    const dynd::eval::eval_context *ectx);
+PYDYND_API void array_broadcast_assign_from_py(
+    const dynd::nd::array &a, PyObject *value,
+    const dynd::eval::eval_context *ectx = &dynd::eval::default_eval_context);
 
 /**
  * Assigns the values from 'obj' to the 'dt/arrmeta/data' raw nd::array,

dynd/include/gfunc_callable_functions.hpp

@@ -16,39 +16,6 @@
 
 namespace pydynd {
 
-struct array_callable_wrapper {
-  dynd::nd::array n;
-  dynd::nd::callable c;
-  std::string funcname;
-};
-
-/**
- * This is the typeobject and struct of w_array_callable from Cython.
- */
-extern PyTypeObject *WArrayCallable_Type;
-
-inline bool WArrayCallable_CheckExact(PyObject *obj)
-{
-  return Py_TYPE(obj) == WArrayCallable_Type;
-}
-inline bool WArrayCallable_Check(PyObject *obj)
-{
-  return PyObject_TypeCheck(obj, WArrayCallable_Type);
-}
-struct WArrayCallable {
-  PyObject_HEAD;
-  // This is array_placement_wrapper in Cython-land
-  array_callable_wrapper v;
-};
-PYDYND_API void init_w_array_callable_typeobject(PyObject *type);
-
-/**
- * This calls the callable in the array_callable_wrapper, which was
- * returned as a property of an array.
- */
-PYDYND_API PyObject *array_callable_call(const array_callable_wrapper &ncw, PyObject *args,
-                              PyObject *kwargs);
-
 struct _type_callable_wrapper {
   dynd::ndt::type d;
   dynd::nd::callable c;
@@ -77,8 +44,8 @@ PYDYND_API void init_w__type_callable_typeobject(PyObject *type);
  * This calls the callable in the _type_callable_wrapper, which was
  * returned as a property of a dynd type.
  */
-PYDYND_API PyObject *_type_callable_call(const _type_callable_wrapper &ccw, PyObject *args,
-                              PyObject *kwargs);
+PYDYND_API PyObject *_type_callable_call(const _type_callable_wrapper &ccw,
+                                         PyObject *args, PyObject *kwargs);
 
 /**
  * This calls the dynamic __construct__ function attached to the dynd type.
@@ -96,22 +63,6 @@ void add__type_names_to_dir_dict(const dynd::ndt::type &dt, PyObject *dict);
 PYDYND_API PyObject *get__type_dynamic_property(const dynd::ndt::type &dt,
                                                 PyObject *name);
 
-/**
- * Adds all the dynamic names exposed by the array to the provided dict.
- */
-PYDYND_API void add_array_names_to_dir_dict(const dynd::nd::array &n,
-                                            PyObject *dict);
-/**
- * Retrieves a dynamic property from the nd::array.
- */
-PYDYND_API PyObject *get_array_dynamic_property(const dynd::nd::array &n,
-                                                PyObject *name);
-/**
- * Sets a dynamic property of the nd::array.
- */
-PYDYND_API void set_array_dynamic_property(const dynd::nd::array &n,
-                                           PyObject *name, PyObject *value);
-
 /**
  * Returns a wrapper for the callable with the dynd type as the first parameter.
  *

dynd/nd/array.pyx

@@ -17,8 +17,6 @@ from ..ndt.type cimport type
 from ..ndt import Unsupplied
 
 cdef extern from 'array_functions.hpp' namespace 'pydynd':
-    void init_w_array_typeobject(object)
-
     void array_init_from_pyobject(_array&, object, object, bint, object) except +translate_exception
     void array_init_from_pyobject(_array&, object, object) except +translate_exception
 
@@ -74,11 +72,8 @@ cdef extern from 'array_functions.hpp' namespace 'pydynd':
     int array_getbuffer_pep3118(object ndo, Py_buffer *buffer, int flags) except -1
     int array_releasebuffer_pep3118(object ndo, Py_buffer *buffer) except -1
 
-cdef extern from 'gfunc_callable_functions.hpp' namespace 'pydynd':
-    void add_array_names_to_dir_dict(_array&, object) except +translate_exception
-    void set_array_dynamic_property(_array&, object, object) except +translate_exception
-
-    void init_w_array_callable_typeobject(object)
+cdef extern from 'array_assign_from_py.hpp' namespace 'pydynd':
+    void array_broadcast_assign_from_py(_array &, object)
 
 cdef class array(object):
     """
@@ -199,7 +194,22 @@ cdef class array(object):
         # will show up in IPython tab-complete, for example.
         result = dict(array.__dict__)
         result.update(object.__dict__)
-        add_array_names_to_dir_dict(self.v, result)
+
+        cdef map[string, _callable] properties
+
+        cdef _type dt = self.v.get_type()
+        if (not dt.is_builtin()):
+            dt.get().get_dynamic_array_properties(properties)
+        else:
+            get_builtin_type_dynamic_array_properties(dt.get_type_id(), properties);
+        for pair in properties:
+            result[pair.first] = wrap(pair.second)
+
+        if (not dt.is_builtin()):
+            dt.get().get_dynamic_array_functions(properties)
+        for pair in properties:
+            result[pair.first] = wrap(pair.second)
+
         return result.keys()
 
     def __getattr__(self, name):
@@ -229,7 +239,23 @@ cdef class array(object):
         raise AttributeError(name)
 
     def __setattr__(self, name, value):
-        set_array_dynamic_property(self.v, name, value)
+        if self.v.is_null():
+            raise AttributeError(name)
+
+        cdef map[string, _callable] properties
+
+        cdef _type dt = self.v.get_type()
+        if (not dt.is_builtin()):
+            dt.get().get_dynamic_array_properties(properties)
+        else:
+            get_builtin_type_dynamic_array_properties(dt.get_type_id(), properties);
+
+        cdef _callable p = properties[name]
+        if (not p.is_null()):
+            array_broadcast_assign_from_py(p(self.v), value)
+            return
+
+        raise AttributeError(name)
 
     def __getitem__(self, x):
         from .. import ndt, nd
@@ -447,12 +473,6 @@ cdef array dynd_nd_array_from_cpp(_array a):
 
 set_wrapper_type[_array](array)
 
-cdef class array_callable:
-    def __call__(self, *args, **kwargs):
-        raise NotImplemented("array callable is not implemented")
-
-init_w_array_callable_typeobject(array_callable)
-
 cpdef array asarray(obj, access=None):
     """
     nd.asarray(obj, access=None)

dynd/src/gfunc_callable_functions.cpp

@@ -17,13 +17,6 @@ using namespace std;
 using namespace dynd;
 using namespace pydynd;
 
-PyTypeObject *pydynd::WArrayCallable_Type;
-
-void pydynd::init_w_array_callable_typeobject(PyObject *type)
-{
-  WArrayCallable_Type = (PyTypeObject *)type;
-}
-
 PyTypeObject *pydynd::WTypeCallable_Type;
 
 void pydynd::init_w__type_callable_typeobject(PyObject *type)
@@ -92,65 +85,6 @@ PyObject *pydynd::get__type_dynamic_property(const dynd::ndt::type &dt,
   return NULL;
 }
 
-void pydynd::add_array_names_to_dir_dict(const dynd::nd::array &n,
-                                         PyObject *dict)
-{
-  ndt::type dt = n.get_type();
-  if (!dt.is_builtin()) {
-    std::map<std::string, nd::callable> properties;
-    // Add the array properties
-    dt.extended()->get_dynamic_array_properties(properties);
-    for (const auto &pair : properties) {
-      if (PyDict_SetItemString(dict, pair.first.c_str(), Py_None) < 0) {
-        throw runtime_error("");
-      }
-    }
-    // Add the array functions
-    std::map<std::string, nd::callable> functions;
-    dt.extended()->get_dynamic_array_functions(functions);
-    for (const auto &pair : functions)
-      if (PyDict_SetItemString(dict, pair.first.c_str(), Py_None) < 0) {
-        throw runtime_error("");
-      }
-  }
-  else {
-    std::map<std::string, nd::callable> properties;
-    // Add the array properties
-    get_builtin_type_dynamic_array_properties(dt.get_type_id(), properties);
-    for (const auto &pair : properties) {
-      if (PyDict_SetItemString(dict, pair.first.c_str(), Py_None) < 0) {
-        throw runtime_error("");
-      }
-    }
-    // TODO: Add the array functions
-  }
-}
-
-void pydynd::set_array_dynamic_property(const dynd::nd::array &n,
-                                        PyObject *name, PyObject *value)
-{
-  ndt::type dt = n.get_type();
-  std::map<std::string, nd::callable> properties;
-  // Search for a property
-  if (!dt.is_builtin()) {
-    dt.extended()->get_dynamic_array_properties(properties);
-  }
-  else {
-    get_builtin_type_dynamic_array_properties(dt.get_type_id(), properties);
-  }
-
-  // TODO: We probably want to make some kind of acceleration structure for
-  // the name lookup
-  std::string nstr = pystring_as_string(name);
-  nd::callable p = properties[nstr];
-  if (!p.is_null()) {
-    array_broadcast_assign_from_py(p(n), value, &eval::default_eval_context);
-  }
-
-  PyErr_SetObject(PyExc_AttributeError, name);
-  throw exception();
-}
-
 static void set_single_parameter(const std::string &funcname,
                                  const std::string &paramname,
                                  const ndt::type &paramtype, char *arrmeta,