Fix #1149 - bytes, bytearray types managed

CHANGELOG.md

@@ -9,9 +9,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- [#1141](http://github.com/nelson-lang/nelson/issues/1141) Help about Managing Data between Python and Nelson.
+- Python interface (part 2):
+
+  - [#1141](http://github.com/nelson-lang/nelson/issues/1141) Help about Managing Data between Python and Nelson.
+  - [#1149](https://github.com/nelson-lang/nelson/issues/1149) python bytes, and bytearray types were not managed.
+  - `pyenv`: can use environment variables to set values.
+
 - `getenv`: Retrieve the values of several environment variables.
-- `pyenv`: can use environment variables to set values.
 
 ### Changed
 
@@ -21,6 +25,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - [#1144](http://github.com/nelson-lang/nelson/issues/1144) test_run markdown help file had a typo.
 - [#1143](http://github.com/nelson-lang/nelson/issues/1143) Linux Snapcraft version did not allow to use python.
+- `single(int64([1 2; 3 4]))` returned a wrong value.
+- `py.tuple`, `py.list` compatibility increased.
 
 ## 1.3.0 (2024-03-30)
 

modules/python_engine/functions/@py/char.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = char(obj)
- r = obj.char();
+  if ismethod(obj, 'char')
+    r = obj.char();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'char']);
+  end
 end
 %=============================================================================

modules/python_engine/functions/@py/double.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = double(obj)
- r = obj.double();
+  if ismethod(obj, 'double')
+    r = obj.double();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'double']);
+  end
 end
 %=============================================================================

modules/python_engine/functions/@py/int16.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = int16(obj)
- r = obj.int16();
+  if ismethod(obj, 'int16')
+    r = obj.int16();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'int16']);
+  end
 end
 %=============================================================================

modules/python_engine/functions/@py/int32.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = int32(obj)
- r = obj.int32();
+  if ismethod(obj, 'int32')
+    r = obj.int32();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'int32']);
+  end
 end
 %=============================================================================

modules/python_engine/functions/@py/int64.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = int64(obj)
- r = obj.int64();
+  if ismethod(obj, 'int64')
+    r = obj.int64();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'int64']);
+  end
 end
 %=============================================================================

modules/python_engine/functions/@py/int8.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = int8(obj)
- r = obj.int8();
+  if ismethod(obj, 'int8')
+    r = obj.int8();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'int8']);
+  end
 end
 %=============================================================================

modules/python_engine/functions/@py/logical.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = logical(obj)
- r = obj.logical();
+  if ismethod(obj, 'logical')
+    r = obj.logical();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'logical']);
+  end
 end
 %=============================================================================

modules/python_engine/functions/@py/single.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = single(obj)
- r = obj.single();
+  if ismethod(obj, 'single')
+    r = obj.single();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'single']);
+  end
 end
 %=============================================================================

modules/python_engine/functions/@py/string.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = string(obj)
- r = obj.string();
+  if ismethod(obj, 'string')
+    r = obj.string();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'string']);
+  end
 end
 %=============================================================================

modules/python_engine/functions/@py/uint16.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = uint16(obj)
- r = obj.uint16();
+  if ismethod(obj, 'uint16')
+    r = obj.uint16();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'uint16']);
+  end
 end
 %=============================================================================

modules/python_engine/functions/@py/uint32.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = uint32(obj)
- r = obj.uint32();
+  if ismethod(obj, 'uint32')
+    r = obj.uint32();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'uint32']);
+  end
 end
 %=============================================================================

modules/python_engine/functions/@py/uint64.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = uint64(obj)
- r = obj.uint64();
+  if ismethod(obj, 'uint64')
+    r = obj.uint64();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'uint64']);
+  end
 end
 %=============================================================================

modules/python_engine/functions/@py/uint8.m

@@ -8,6 +8,10 @@
 % LICENCE_BLOCK_END
 %=============================================================================
 function r = uint8(obj)
- r = obj.uint8();
+  if ismethod(obj, 'uint8')
+    r = obj.uint8();
+  else
+    error([_('Wrong value for #2 argument.'), ' ', 'uint8']);
+  end
 end
 %=============================================================================

modules/python_engine/help/en_US/xml/pyrun.xml

@@ -87,6 +87,9 @@ r = pyrun('d = a + c', 'd')]]>
     <see_also_item>
       <link linkend="${python_engine}pyenv">pyenv</link>
     </see_also_item>
+    <see_also_item>
+      <link linkend="${python_engine}python_types">Python types supported</link>
+    </see_also_item>
   </see_also>
 
   <history>

modules/python_engine/help/en_US/xml/python_types.xml

@@ -55,6 +55,10 @@
         <td>py.bytes</td><td
         >double, single, int8, uint8, int16, uint16, int32, uint32, int64, uint64, logical</td>
     </tr>
+    <tr>
+        <td>py.bytearray</td><td
+        >double, single, int8, uint8, int16, uint16, int32, uint32, int64, uint64, logical</td>
+    </tr>
     <tr>
         <td>py.array.array</td><td
         >double, single, int8, uint8, int16, uint16, int32, uint32, int64, uint64</td>

modules/python_engine/src/cpp/PyObjectHelpers.cpp

@@ -12,6 +12,76 @@
 //=============================================================================
 namespace Nelson {
 //=============================================================================
+PythonType
+getPythonType(PyObject* po)
+{
+    if (po == nullptr) {
+        return PythonType::PY_NOT_MANAGED;
+    }
+
+    PyTypeObject* pyTypeObject = Py_TYPE(po);
+
+    if (pyTypeObject == PyFloat_TypePtr) {
+        return PythonType::PY_FLOAT_TYPE;
+    }
+    if (pyTypeObject == PyBool_TypePtr) {
+        return PythonType::PY_BOOL_TYPE;
+    }
+    if (pyTypeObject == PyComplex_TypePtr) {
+        return PythonType::PY_COMPLEX_TYPE;
+    }
+    if (pyTypeObject == PyLong_TypePtr) {
+        return PythonType::PY_LONG_TYPE;
+    }
+    if (pyTypeObject == PyBytes_TypePtr) {
+        return PythonType::PY_BYTES_TYPE;
+    }
+    if (pyTypeObject == PyByteArray_TypePtr) {
+        return PythonType::PY_BYTE_ARRAY_TYPE;
+    }
+
+    std::wstring typeName = TypeName(po);
+    if (typeName == L"NoneType") {
+        return PythonType::PY_NONE_TYPE;
+    }
+    if (typeName == L"memoryview") {
+        return PythonType::PY_MEMORY_VIEW_TYPE;
+    }
+    if (typeName == L"list") {
+        return PythonType::PY_LIST_TYPE;
+    }
+    if (typeName == L"tuple") {
+        return PythonType::PY_TUPLE_TYPE;
+    }
+    if (typeName == L"dict") {
+        return PythonType::PY_DICT_TYPE;
+    }
+    if (typeName == L"str") {
+        return PythonType::PY_STR_TYPE;
+    }
+
+    std::wstring numpyPrefix = L"numpy.";
+    if (typeName.compare(0, numpyPrefix.length(), numpyPrefix) == 0) {
+        return PythonType::PY_NUMPY_TYPE;
+    }
+
+    PyObject* arrayModule = NLSPyImport_ImportModule("array");
+    if (arrayModule) {
+        PyObject* arrayType = NLSPyObject_GetAttrString(arrayModule, "array");
+        if (arrayType) {
+            if (NLSPyObject_IsInstance(po, arrayType)) {
+                NLSPy_XDECREF(arrayType);
+                NLSPy_XDECREF(arrayModule);
+                return PythonType::PY_ARRAY_ARRAY_TYPE;
+            }
+            NLSPy_XDECREF(arrayType);
+        }
+        NLSPy_XDECREF(arrayModule);
+    }
+
+    return PythonType::PY_NOT_MANAGED;
+}
+//=============================================================================
 std::wstring
 PyObjectToStringRepresentation(PyObject* po)
 {
@@ -48,7 +118,6 @@ getPyObjectMethods(PyObject* po, bool withUnderscoreMethods)
         for (Py_ssize_t i = 0; i < size; ++i) {
             PyObject* item = NLSPyList_GetItem(dir_result, i);
             if (item != NULL) {
-
                 const char* attr_name = NLSPyUnicode_AsUTF8(item);
                 if (attr_name) {
                     PyObject* method = NLSPyObject_GetAttrString(po, attr_name);
@@ -130,34 +199,17 @@ deepCopyPyObject(PyObject* obj)
 const char*
 getArrayArrayTypeCode(PyObject* pyObject)
 {
-    PyObject* arrayModule = NLSPyImport_ImportModule("array");
-    if (!arrayModule) {
-        return nullptr;
-    }
-    PyObject* arrayType = NLSPyObject_GetAttrString(arrayModule, "array");
-    if (!arrayType) {
-        NLSPy_XDECREF(arrayModule);
-        return nullptr;
-    }
-    bool isInstanceArrayArray = NLSPyObject_IsInstance(pyObject, arrayType);
-    if (!isInstanceArrayArray) {
-        NLSPy_XDECREF(arrayType);
-        NLSPy_XDECREF(arrayModule);
-        return nullptr;
-    }
-
     PyObject* typeChar = NLSPyObject_GetAttrString(pyObject, "typecode");
     if (typeChar) {
         PyObject* typeStr = NLSPyUnicode_AsUTF8String(typeChar);
         if (typeStr) {
             const char* typeCode = NLSPyBytes_AsString(typeStr);
             NLSPy_DECREF(typeStr);
+            NLSPy_XDECREF(typeChar);
             return typeCode;
         }
     }
     NLSPy_XDECREF(typeChar);
-    NLSPy_XDECREF(arrayType);
-    NLSPy_XDECREF(arrayModule);
 
     return nullptr;
 }
@@ -252,6 +304,12 @@ PyTypecodeToNelsonType(const char* memoryViewType)
     if (strcmp(memoryViewType, "I") == 0) {
         return NLS_UINT32;
     }
+    if (strcmp(memoryViewType, "l") == 0) {
+        return NLS_INT32;
+    }
+    if (strcmp(memoryViewType, "L") == 0) {
+        return NLS_UINT32;
+    }
     if (strcmp(memoryViewType, "h") == 0) {
         return NLS_INT16;
     }
@@ -264,7 +322,6 @@ PyTypecodeToNelsonType(const char* memoryViewType)
     if (strcmp(memoryViewType, "B") == 0) {
         return NLS_UINT8;
     }
-
     return NLS_UNKNOWN;
 }
 //=============================================================================

modules/python_engine/src/cpp/PyObjectHelpers.hpp

@@ -15,6 +15,28 @@
 //=============================================================================
 namespace Nelson {
 //=============================================================================
+enum PythonType
+{
+    PY_NONE_TYPE = 0,
+    PY_STR_TYPE,
+    PY_FLOAT_TYPE,
+    PY_BOOL_TYPE,
+    PY_COMPLEX_TYPE,
+    PY_LONG_TYPE,
+    PY_BYTES_TYPE,
+    PY_BYTE_ARRAY_TYPE,
+    PY_MEMORY_VIEW_TYPE,
+    PY_LIST_TYPE,
+    PY_TUPLE_TYPE,
+    PY_DICT_TYPE,
+    PY_ARRAY_ARRAY_TYPE,
+    PY_NUMPY_TYPE,
+    PY_NOT_MANAGED
+};
+//=============================================================================
+PythonType
+getPythonType(PyObject* po);
+//=============================================================================
 std::wstring
 PyObjectToStringRepresentation(PyObject* po);
 //=============================================================================