GridCalEngine 5.3.51__tar.gz → 5.3.52__tar.gz

{gridcalengine-5.3.51 → gridcalengine-5.3.52}/GridCalEngine/Devices/Parents/editable_device.py

@@ -225,13 +225,15 @@ class EditableDevice:
                  idtag: Union[str, None],
                  code: str,
                  device_type: DeviceType,
-                 comment: str = ""):
+                 comment: str = "",
+                 rdfid: str = ""):
         """
         Class to generalize any editable device
         :param name: Asset's name
-        :param device_type: DeviceType instance
         :param idtag: unique ID, if not provided it is generated
         :param code: alternative code to identify this object in other databases (i.e. psse number tec...)
+        :param device_type: DeviceType instance
+        :param rdfid: RDFID code optional
         """
 
         self._idtag = parse_idtag(val=idtag)
@@ -240,6 +242,8 @@ class EditableDevice:
 
         self._code: str = code
 
+        self._rdfid = rdfid
+
         self.device_type: DeviceType = device_type
 
         self.comment: str = comment
@@ -266,6 +270,7 @@ class EditableDevice:
         self.register(key='idtag', units='', tpe=str, definition='Unique ID', editable=False)
         self.register(key='name', units='', tpe=str, definition='Name of the device.')
         self.register(key='code', units='', tpe=str, definition='Secondary ID')
+        self.register(key='rdfid', units='', tpe=str, definition='RDF ID for further compatibility')
         self.register(key='action', units='', tpe=ActionType,
                       definition='Object action to perform.\nOnly used for model merging.',
                       display=False)
@@ -361,9 +366,17 @@ class EditableDevice:
         """
         self._code = val
 
+    @property
+    def rdfid(self) -> str:
+        return self._rdfid
+
+    @rdfid.setter
+    def rdfid(self, val: str):
+        self._rdfid = val
+
     def flatten_idtag(self):
         """
-        Remove useless undercore and
+        Remove useless underscore (_) and dash (-)
         :return:
         """
         self._idtag = self._idtag.replace('_', '').replace('-', '')
@@ -381,14 +394,17 @@ class EditableDevice:
         Convert the idtag to RDFID
         :return: UUID converted to RDFID
         """
-        lenghts = [8, 4, 4, 4, 12]
-        chunks = list()
-        s = 0
-        for length_ in lenghts:
-            a = self.idtag[s:s + length_]
-            chunks.append(a)
-            s += length_
-        return "-".join(chunks)
+        if len(self._rdfid) == 0:
+            lenghts = [8, 4, 4, 4, 12]
+            chunks = list()
+            s = 0
+            for length_ in lenghts:
+                a = self.idtag[s:s + length_]
+                chunks.append(a)
+                s += length_
+            return "-".join(chunks)
+        else:
+            return self.rdfid
 
     def register(self,
                  key: str,

{gridcalengine-5.3.51 → gridcalengine-5.3.52}/GridCalEngine/Devices/assets.py

@@ -4799,8 +4799,8 @@ class Assets:
                                                                   add_switch=add_switch))}
 
     def get_branches_index_dict2(self, add_vsc: bool = True,
-                                add_hvdc: bool = True,
-                                add_switch: bool = False) -> Dict[str, int]:
+                                 add_hvdc: bool = True,
+                                 add_switch: bool = False) -> Dict[str, int]:
         """
         Get the branch to index dictionary
         :param add_vsc: Include the list of VSC?
@@ -4809,8 +4809,8 @@ class Assets:
         :return: Branch idtag to index
         """
         return {b.idtag: i for i, b in enumerate(self.get_branches_iter(add_vsc=add_vsc,
-                                                                  add_hvdc=add_hvdc,
-                                                                  add_switch=add_switch))}
+                                                                        add_hvdc=add_hvdc,
+                                                                        add_switch=add_switch))}
 
     def get_branches_dict(self, add_vsc: bool = True,
                           add_hvdc: bool = True,
@@ -5942,22 +5942,36 @@ class Assets:
             for elm in elements:
                 yield elm
 
-    def get_all_elements_dict(self, logger=Logger()) -> Tuple[Dict[str, ALL_DEV_TYPES], bool]:
+    def get_all_elements_dict(self,
+                              use_secondary_key: bool = False,
+                              use_rdfid: bool = False,
+                              logger=Logger()) -> Tuple[Dict[str, ALL_DEV_TYPES], bool]:
         """
         Get a dictionary of all elements
+        :param use_secondary_key: if true the code i˘s used as key
+        :param use_rdfid: if true the rdfid is used as key
         :param: logger: Logger
         :return: Dict[idtag] -> object, ok
         """
         data = dict()
         ok = True
         for key, tpe in self.device_type_name_dict.items():
+
             elements = self.get_elements_by_type(device_type=tpe)
 
             for elm in elements:
 
                 e = data.get(elm.idtag, None)
+
                 if e is None:
-                    data[elm.idtag] = elm
+
+                    if use_secondary_key:
+                        data[elm.code] = elm
+                    elif use_rdfid:
+                        data[elm.rdfid] = elm
+                    else:
+                        data[elm.idtag] = elm
+
                 else:
                     logger.add_error(
                         msg="Duplicated idtag!",
@@ -5996,17 +6010,22 @@ class Assets:
 
         return data
 
-    def get_elements_dict_by_type(self, element_type: DeviceType,
-                                  use_secondary_key=False) -> Dict[str, ALL_DEV_TYPES]:
+    def get_elements_dict_by_type(self,
+                                  element_type: DeviceType,
+                                  use_secondary_key: bool = False,
+                                  use_rdfid: bool = False) -> Dict[str, ALL_DEV_TYPES]:
         """
         Get dictionary of elements
         :param element_type: element type (Bus, Line, etc...)
         :param use_secondary_key: use the code as dictionary key? otherwise the idtag is used
+        :param use_rdfid: if true the rdfid is used as key
         :return: Dict[str, dev.EditableDevice]
         """
 
         if use_secondary_key:
             return {elm.code: elm for elm in self.get_elements_by_type(element_type)}
+        elif use_rdfid:
+            return {elm.rdfid: elm for elm in self.get_elements_by_type(element_type)}
         else:
             return {elm.idtag: elm for elm in self.get_elements_by_type(element_type)}
 

{gridcalengine-5.3.51 → gridcalengine-5.3.52}/GridCalEngine/__version__.py

@@ -6,7 +6,7 @@ import datetime
 _current_year_ = datetime.datetime.now().year
 
 # remember to keep a three-number version!!!
-__GridCalEngine_VERSION__ = "5.3.51"
+__GridCalEngine_VERSION__ = "5.3.52"
 
 url = 'https://github.com/SanPen/GridCal'
 

{gridcalengine-5.3.51 → gridcalengine-5.3.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: GridCalEngine
-Version: 5.3.51
+Version: 5.3.52
 Summary: GridCal is a Power Systems simulation program intended for professional use and research
 Home-page: https://github.com/SanPen/GridCal
 Author: Santiago Peñate Vera et. Al.