Merge pull request libdynd#449 from izaid/array_functions

Updates to match libdynd

Author: izaid

.travis.yml

@@ -24,7 +24,7 @@ before_install:
 - export CXX=g++-4.9
 
 install:
-- travis_retry pip install --install-option="--no-cython-compile" Cython==0.21
+- travis_retry pip install --install-option="--no-cython-compile" Cython==0.23
 - mkdir libraries
 - pushd libraries
 - git clone --depth=1 https://github.com/libdynd/libdynd.git
@@ -42,7 +42,7 @@ matrix:
     python: 2.6
     compiler: gcc
     install:
-    - travis_retry pip install --install-option="--no-cython-compile" Cython==0.21
+    - travis_retry pip install --install-option="--no-cython-compile" Cython==0.23
     - travis_retry pip install -I numpy==1.7.2
     - travis_retry pip install unittest2
     - python -c "import numpy; print numpy.__version__"

dynd/cpp/array.pxd

@@ -1,5 +1,6 @@
 from ..config cimport translate_exception
 from libc.stdint cimport intptr_t
+from libcpp cimport bool
 from .type cimport type
 
 cdef extern from 'dynd/array.hpp' namespace 'dynd::nd' nogil:
@@ -16,6 +17,8 @@ cdef extern from 'dynd/array.hpp' namespace 'dynd::nd' nogil:
 
         array view_scalars(type&) except +translate_exception
 
+        bool is_null()
+
         array operator<(array &)
         array operator<=(array &)
         array operator==(array &)

dynd/cpp/func/callable.pxd

@@ -1,7 +1,14 @@
+from libcpp cimport bool
+
+from ..array cimport array
 from ..type cimport type
 
 cdef extern from 'dynd/func/callable.hpp' namespace 'dynd::nd' nogil:
     cdef cppclass callable:
         callable()
 
         type get_array_type()
+
+        bool is_null()
+
+        array operator()(...)

dynd/cpp/type.pxd

@@ -1,22 +1,37 @@
+from libcpp cimport bool
+from libcpp.map cimport map
 from libcpp.string cimport string
 
 from .types.type_id cimport type_id_t
 
 from ..config cimport translate_exception
 from .array cimport array
+from .func.callable cimport callable
+
+cdef extern from 'dynd/types/base_type.hpp' namespace 'dynd::ndt' nogil:
+    cdef cppclass base_type:
+        void get_dynamic_array_properties(map[string, callable] &)
+        void get_dynamic_array_functions(map[string, callable] &)
+
+cdef extern from 'dynd/types/builtin_type_properties.hpp' namespace 'dynd' nogil:
+    void get_builtin_type_dynamic_array_properties(type_id_t, map[string, callable] &)
 
 cdef extern from 'dynd/type.hpp' namespace 'dynd::ndt' nogil:
     cdef cppclass type:
         type()
         type(type_id_t) except +translate_exception
         type(string&) except +translate_exception
 
+        base_type *get()
+
         size_t get_data_size()
         size_t get_default_data_size() except +translate_exception
         size_t get_data_alignment()
         size_t get_arrmeta_size()
         type get_canonical_type()
 
+        bool is_builtin()
+
         bint operator==(type&)
         bint operator!=(type&)
 

dynd/nd/array.pyx

@@ -2,9 +2,12 @@
 
 from cpython.object cimport Py_LT, Py_LE, Py_EQ, Py_NE, Py_GE, Py_GT
 from libcpp.string cimport string
+from libcpp.map cimport map
+from cython.operator import dereference
 
 from ..cpp.array cimport groupby as dynd_groupby
-from ..cpp.type cimport type as _type
+from ..cpp.func.callable cimport callable as _callable
+from ..cpp.type cimport type as _type, get_builtin_type_dynamic_array_properties
 from ..cpp.types.categorical_type cimport dynd_make_categorical_type
 from ..cpp.types.datashape_formatter cimport format_datashape as dynd_format_datashape
 
@@ -72,7 +75,6 @@ cdef extern from 'array_functions.hpp' namespace 'pydynd':
     int array_releasebuffer_pep3118(object ndo, Py_buffer *buffer) except -1
 
 cdef extern from 'gfunc_callable_functions.hpp' namespace 'pydynd':
-    object get_array_dynamic_property(_array&, object) except +translate_exception
     void add_array_names_to_dir_dict(_array&, object) except +translate_exception
     void set_array_dynamic_property(_array&, object, object) except +translate_exception
 
@@ -201,7 +203,30 @@ cdef class array(object):
         return result.keys()
 
     def __getattr__(self, name):
-        return get_array_dynamic_property(self.v, name)
+        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()):
+            return wrap(p(self.v))
+
+        cdef map[string, _callable] functions
+        if (not dt.is_builtin()):
+            dt.get().get_dynamic_array_functions(functions)
+
+        cdef _callable f = functions[name]
+        if (not f.is_null()):
+            return wrap(f(self.v))
+
+        raise AttributeError(name)
 
     def __setattr__(self, name, value):
         set_array_dynamic_property(self.v, name, value)

dynd/src/gfunc_callable_functions.cpp

@@ -97,13 +97,11 @@ void pydynd::add_array_names_to_dir_dict(const dynd::nd::array &n,
 {
   ndt::type dt = n.get_type();
   if (!dt.is_builtin()) {
-    const std::pair<std::string, nd::callable> *properties;
-    size_t count;
+    std::map<std::string, nd::callable> properties;
     // Add the array properties
-    dt.extended()->get_dynamic_array_properties(&properties, &count);
-    for (size_t i = 0; i < count; ++i) {
-      if (PyDict_SetItemString(dict, properties[i].first.c_str(), Py_None) <
-          0) {
+    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("");
       }
     }
@@ -116,96 +114,37 @@ void pydynd::add_array_names_to_dir_dict(const dynd::nd::array &n,
       }
   }
   else {
-    const std::pair<std::string, nd::callable> *properties;
-    size_t count;
+    std::map<std::string, nd::callable> properties;
     // Add the array properties
-    get_builtin_type_dynamic_array_properties(dt.get_type_id(), &properties,
-                                              &count);
-    for (size_t i = 0; i < count; ++i) {
-      if (PyDict_SetItemString(dict, properties[i].first.c_str(), Py_None) <
-          0) {
+    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
   }
 }
 
-PyObject *pydynd::get_array_dynamic_property(const dynd::nd::array &n,
-                                             PyObject *name)
-{
-  if (n.is_null()) {
-    PyErr_SetObject(PyExc_AttributeError, name);
-    return NULL;
-  }
-  ndt::type dt = n.get_type();
-  const std::pair<std::string, nd::callable> *properties;
-  size_t count;
-  // Search for a property
-  if (!dt.is_builtin()) {
-    dt.extended()->get_dynamic_array_properties(&properties, &count);
-  }
-  else {
-    get_builtin_type_dynamic_array_properties(dt.get_type_id(), &properties,
-                                              &count);
-  }
-
-  // TODO: We probably want to make some kind of acceleration structure for the
-  // name lookup
-  if (count > 0) {
-    std::string nstr = pystring_as_string(name);
-    for (size_t i = 0; i < count; ++i) {
-      if (properties[i].first == nstr) {
-        return DyND_PyWrapper_New(const_cast<dynd::nd::callable &>(
-            properties[i].second)(dynd::kwds("self", n)));
-      }
-    }
-  }
-
-  // Search for a function
-  std::map<std::string, nd::callable> functions;
-  if (!dt.is_builtin()) {
-    dt.extended()->get_dynamic_array_functions(functions);
-  }
-  else {
-    count = 0;
-  }
-  std::string nstr = pystring_as_string(name);
-  nd::callable c = functions[nstr];
-  if (!c.is_null()) {
-    return DyND_PyWrapper_New(c(n));
-  }
-
-  PyErr_SetObject(PyExc_AttributeError, name);
-  return NULL;
-}
-
 void pydynd::set_array_dynamic_property(const dynd::nd::array &n,
                                         PyObject *name, PyObject *value)
 {
   ndt::type dt = n.get_type();
-  const std::pair<std::string, nd::callable> *properties;
-  size_t count;
+  std::map<std::string, nd::callable> properties;
   // Search for a property
   if (!dt.is_builtin()) {
-    dt.extended()->get_dynamic_array_properties(&properties, &count);
+    dt.extended()->get_dynamic_array_properties(properties);
   }
   else {
-    get_builtin_type_dynamic_array_properties(dt.get_type_id(), &properties,
-                                              &count);
+    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
-  if (count > 0) {
-    std::string nstr = pystring_as_string(name);
-    for (size_t i = 0; i < count; ++i) {
-      if (properties[i].first == nstr) {
-        nd::array p = const_cast<dynd::nd::callable &>(properties[i].second)(
-            dynd::kwds("self", n));
-        array_broadcast_assign_from_py(p, value, &eval::default_eval_context);
-        return;
-      }
-    }
+  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);