Experimental support for OpenDSS-PM (at the moment, a custom patch is provided for FreePascal support) and port COM interface fixes (OpenDSS revision 2134)

Author: PMeira

README.md renamed to README

@@ -6,14 +6,20 @@ Python bindings and misc tools for using OpenDSS (EPRI Distribution System Simul
 
 If you are looking for the C API library, see [`dss_capi`](http://github.com/PMeira/dss-capi/).
 
-Version 0.9.1, based on [OpenDSS revision 2123](https://sourceforge.net/p/electricdss/code/2123/tree/). 
+Version 0.9.2, based on [OpenDSS revision 2134](https://sourceforge.net/p/electricdss/code/2123/tree/). 
 This is a work-in-progress but it's deemed stable enough to be made public.
+*Note that, while the interface with OpenDSS is stable (classic version), the OpenDSS-PM (actor-based parallel machine version) interface was integrated recently and is experimental.*
 
 This module mimics the COM structure (as exposed via `win32com` or `comtypes`), effectively enabling multi-platform compatibility at Python level.
 Most of the COM documentation can be used as-is, but instead of returning tuples or lists, this modules returns/accepts NumPy arrays for numeric data exchange. 
 
 This module depends on CFFI, NumPy and, optionally, SciPy.Sparse for reading the sparse system admittance matrix.
 
+Recent changes
+==============
+- 2018-02-08: First public release (OpenDSS revision 2123)
+- 2018-02-10: Experimental support for OpenDSS-PM (at the moment, a custom patch is provided for FreePascal support) and port COM interface fixes (OpenDSS revision 2134)
+
 
 Missing features and limitations
 ================================
@@ -112,6 +118,14 @@ for i in range(len(voltages) // 2):
 If you do not need the mixed-cased handling, you can omit the call to `use_com_compat()` and use the casing used in this project.
 
 
+If you want to play with the experimental OpenDSS-PM interface, it is installed side-by-side and you can import it as:
+
+```
+import dss.pm
+dss.pm.use_com_compat()
+dss_engine = dss.pm.DSS
+```
+
 Testing
 =======
 Since the DLL is built using FreePascal, which is not officially supported by EPRI, the results are validated running sample networks provided in the official OpenDSS distribution. The only modifications are done directly by the script, removing interactive features and some minor other minor issues.

README.pdf

@@ -7,4 +7,4 @@
 from .enums import *
 from . import enums
 
-__version__ = '0.9.1'
+__version__ = '0.9.2'

cffi/dsspm_capi_cffi.h

@@ -5,7 +5,7 @@
 '''
 from __future__ import absolute_import
 from ._dss_capi import lib, ffi
-from ._cffi_api_util import *
+from ._cffi_api_util import * # one for each version (parallel, classic), already bound to the cffi module
 import numpy as np
 
 if not freeze:

dss/__init__.py

@@ -0,0 +1,10 @@
+'''A compatibility layer for DSSPM_CAPI that mimics the official OpenDSS COM interface.
+
+Copyright (c) 2016-2018 Paulo Meira
+'''
+from __future__ import absolute_import
+from .dsspm_capi import *
+from ..enums import *
+from .. import enums
+
+__version__ = '0.9.2'

dss/dss_capi.py

@@ -0,0 +1,149 @@
+from __future__ import absolute_import
+from .._dsspm_capi import lib, ffi
+import numpy as np
+
+freeze = True
+_case_insensitive = False
+codec = 'cp1252'
+
+def use_com_compat(value=True):
+    global _case_insensitive
+    _case_insensitive = value
+    
+def prepare_com_compat(variables):
+    global freeze
+    
+    import inspect
+    old_freeze = freeze
+    try:
+        freeze = False
+        for v in variables.values():
+            if inspect.isclass(v) and issubclass(v, FrozenClass) and v != FrozenClass:
+                lowercase_map = {a.lower(): a for a in dir(v) if not a.startswith('_')}
+                v._dss_atributes = lowercase_map
+                
+    finally:
+        freeze = old_freeze
+    
+
+# workaround to make a __slots__ equivalent restriction compatible with Python 2 and 3
+class FrozenClass(object):
+    _isfrozen = False
+    
+    def __getattr__(self, key):
+        if key.startswith('_'):
+            return object.__getattribute__(self, key)
+            
+        if _case_insensitive:
+            key = self._dss_atributes.get(key.lower(), key)
+    
+        return object.__getattribute__(self, key)
+    
+    
+    def __setattr__(self, key, value):
+        
+        if _case_insensitive:
+            okey = key
+            key = self._dss_atributes.get(key.lower(), None)
+            if key is None:
+                raise TypeError( "%r is a frozen class" % self)
+    
+        if self._isfrozen and not hasattr(self, key):
+            raise TypeError( "%r is a frozen class" % self )
+            
+        object.__setattr__(self, key, value)
+
+
+def get_string(b):
+    return ffi.string(b).decode(codec)
+    
+def get_float64_array(func, *args):
+    ptr = ffi.new('double**')
+    cnt = ffi.new('int32_t*')
+    func(ptr, cnt, *args)
+    if not cnt[0]:
+        res = None
+    else:
+        res = np.frombuffer(ffi.buffer(ptr[0], cnt[0] * 8), dtype=np.float).copy()
+
+    lib.DSS_Dispose_PDouble(ptr)
+    return res
+        
+    
+    
+def get_int32_array(func, *args):
+    ptr = ffi.new('int32_t**')
+    cnt = ffi.new('int32_t*')
+    func(ptr, cnt, *args)
+    if not cnt[0]:
+        res = None
+    else:
+        res = np.frombuffer(ffi.buffer(ptr[0], cnt[0] * 4), dtype=np.int32).copy()
+    
+    lib.DSS_Dispose_PInteger(ptr)
+    return res
+        
+        
+def get_int8_array(func, *args):
+    ptr = ffi.new('int8_t**')
+    cnt = ffi.new('int32_t*')
+    func(ptr, cnt, *args)
+    if not cnt[0]:
+        res = None
+    else:
+        res = np.frombuffer(ffi.buffer(ptr[0], cnt[0] * 1), dtype=np.int8).copy()
+    
+    lib.DSS_Dispose_PByte(ptr)
+    return res
+    
+        
+def get_string_array(func, *args):
+    ptr = ffi.new('char***')
+    cnt = ffi.new('int32_t*')
+    func(ptr, cnt, *args)
+    if not cnt[0]:
+        res = []
+    else:
+        actual_ptr = ptr[0]
+        if actual_ptr == ffi.NULL:
+            res = []
+        else:
+            res = [(str(ffi.string(actual_ptr[i]).decode(codec)) if (actual_ptr[i] != ffi.NULL) else None) for i in range(cnt[0])]
+    
+    lib.DSS_Dispose_PPAnsiChar(ptr, cnt[0])
+    return res
+    
+    
+    
+def prepare_float64_array(value):
+    if type(value) is not np.ndarray or value.dtype != np.float64:
+        value = np.array(value, dtype=np.float64)
+    
+    ptr = ffi.cast('double*', ffi.from_buffer(data.data))
+    cnt = data.size
+    return value, ptr, cnt
+   
+def prepare_int32_array(value):
+    if type(value) is not np.ndarray or value.dtype != np.int32:
+        value = np.array(value, dtype=np.int32)
+    
+    ptr = ffi.cast('int32_t*', ffi.from_buffer(data.data))
+    cnt = data.size
+    return value, ptr, cnt
+   
+
+def prepare_string_array(value):
+    raise NotImplementedError
+   
+
+# This might be useful for methods like Get_Channel that are exposed as Channel[] and Channel()
+# def arrayfunc(func):
+    # class ArrayFuncWrapper:
+        # def __call__(self, v):
+            # return func(self, v)
+            
+        # def __getitem__(self, v):
+            # return func(self, v)
+
+    # return ArrayFuncWrapper()
+