tricc-oo 1.5.13__py3-none-any.whl → 1.6.8__py3-none-any.whl

tricc_oo/models/calculate.py

@@ -1,84 +1,95 @@
-
+from typing import List, Optional, Union
 import logging
-import random
-import string
-from enum import Enum, auto
-from typing import Dict, ForwardRef, List, Optional, Union
+from tricc_oo.models.base import (
+    TriccBaseModel, TriccOperation, TriccStatic, TriccReference, Expression, TriccNodeType
+)
 
-from pydantic import BaseModel, constr
-from strenum import StrEnum
-from .base import *
-from .tricc import *
-from tricc_oo.converters.utils import generate_id, get_rand_name
+from tricc_oo.models.tricc import (
+    TriccNodeCalculateBase, TriccNodeBaseModel,
+)
 
+from tricc_oo.converters.utils import get_rand_name
 
-    
+logger = logging.getLogger(__name__)
 
+ACTIVITY_END_NODE_FORMAT = "aend_{}"
 
 
 class TriccNodeDisplayCalculateBase(TriccNodeCalculateBase):
     save: Optional[str] = None  # contribute to another calculate
     hint: Optional[str] = None  # for diagnostic display
     help: Optional[str] = None  # for diagnostic display
-    applicability: Optional[Union[Expression, TriccOperation]] = None
+    trigger: Optional[Union[Expression, TriccOperation, TriccReference]] = None
+    applicability: Optional[Union[Expression, TriccOperation, TriccReference]] = None
+
     # no need to copy save
     def to_fake(self):
         data = vars(self)
-        del data['hint']
-        del data['help']
-        del data['save']
+        del data["hint"]
+        del data["help"]
+        del data["save"]
         fake = TriccNodeFakeCalculateBase(**data)
-        replace_node(self,fake)
+        self.replace_node(fake)
         return fake
+
     def __str__(self):
         return self.get_name()
 
     def __repr__(self):
         return self.get_name()
-    
+
+
 class TriccNodeCalculate(TriccNodeDisplayCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.calculate
+    remote_reference: Optional[Union[Expression, TriccOperation, TriccReference]] = None
 
 
 class TriccNodeAdd(TriccNodeDisplayCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.add
-    datatype: str = 'number'
+    datatype: str = "number"
 
 
 class TriccNodeCount(TriccNodeDisplayCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.count
-    datatype: str = 'number'
+    datatype: str = "number"
 
 
 class TriccNodeProposedDiagnosis(TriccNodeDisplayCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.proposed_diagnosis
     severity: str = None
-    
-    
+    remote_reference: Optional[Union[Expression, TriccOperation, TriccReference]] = None
+
+
 class TriccNodeFakeCalculateBase(TriccNodeCalculateBase):
     ...
 
+
 class TriccNodeInput(TriccNodeFakeCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.input
-    
+
+
 class TriccNodeDisplayBridge(TriccNodeDisplayCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.bridge
-        
+
 
 class TriccNodeBridge(TriccNodeFakeCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.bridge
-        
-class TriccRhombusMixIn():
-    
+
+
+class TriccRhombusMixIn:
+
     def make_mixin_instance(self, instance, instance_nb, activity, **kwargs):
         # shallow copy
         reference = []
         expression_reference = None
         instance.path = None
-        if isinstance(self.expression_reference, (str, TriccOperation)):
+        if isinstance(
+            self.expression_reference,
+            (str, TriccOperation, TriccReference, TriccStatic),
+        ):
             expression_reference = self.expression_reference.copy()
             reference = list(expression_reference.get_references())
-        if isinstance(self.reference, (str, TriccOperation)):
+        if isinstance(self.reference, (str, TriccOperation, TriccReference, TriccStatic)):
             expression_reference = self.reference.copy()
             reference = list(expression_reference.get_references())
         elif isinstance(self.reference, list):
@@ -107,42 +118,46 @@ class TriccRhombusMixIn():
         return instance
 
 
-    
-
-class TriccNodeRhombus(TriccNodeCalculateBase,TriccRhombusMixIn):
+class TriccNodeRhombus(TriccNodeCalculateBase, TriccRhombusMixIn):
     tricc_type: TriccNodeType = TriccNodeType.rhombus
     path: Optional[TriccNodeBaseModel] = None
-    reference: Union[List[TriccNodeBaseModel], Expression, TriccOperation, TriccReference, List[TriccReference]]
-    
+    reference: Union[
+        List[TriccNodeBaseModel],
+        Expression,
+        TriccOperation,
+        TriccReference,
+        List[TriccReference],
+    ]
+    remote_reference: Optional[Union[Expression, TriccOperation, TriccReference]] = None
+
     def make_instance(self, instance_nb, activity, **kwargs):
         instance = super(TriccNodeRhombus, self).make_instance(instance_nb, activity, **kwargs)
         instance = self.make_mixin_instance(instance, instance_nb, activity, **kwargs)
         return instance
 
-
     def __init__(self, **data):
-        data['name'] = get_rand_name(data.get('id', None))
+        data["name"] = get_rand_name(data.get("id", None))
         super().__init__(**data)
 
 
-
-
-
 class TriccNodeDiagnosis(TriccNodeDisplayCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.diagnosis
     severity: str = None
+
     def __init__(self, **data):
-        data['reference'] = f'"final.{data["name"]}" is true'
+        data["reference"] = f'"final.{data["name"]}" is true'
         super().__init__(**data)
 
         # rename rhombus
         self.name = get_rand_name(f"d{data.get('id', None)}")
 
+
 class TriccNodeExclusive(TriccNodeFakeCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.exclusive
 
+
 def get_node_from_id(activity, node, edge_only):
-    node_id = getattr(node,'id',node)
+    node_id = getattr(node, "id", node)
     if not isinstance(node_id, str):
         logger.critical("can set prev_next only with string or node")
         exit(1)
@@ -151,15 +166,16 @@ def get_node_from_id(activity, node, edge_only):
     elif node_id in activity.nodes:
         node = activity.nodes[node_id]
     elif not edge_only:
-        logger.critical(f"cannot find {node_id} in  {activiy.get_name()}")
+        logger.critical(f"cannot find {node_id} in  {activity.get_name()}")
         exit(1)
     return node_id, node
 
+
 class TriccNodeWait(TriccNodeFakeCalculateBase, TriccRhombusMixIn):
     tricc_type: TriccNodeType = TriccNodeType.wait
     path: Optional[TriccNodeBaseModel] = None
     reference: Union[List[TriccNodeBaseModel], Expression, TriccOperation]
-    
+
     def make_instance(self, instance_nb, activity, **kwargs):
         instance = super(TriccNodeWait, self).make_instance(instance_nb, activity, **kwargs)
         instance = self.make_mixin_instance(instance, instance_nb, activity, **kwargs)
@@ -182,21 +198,21 @@ class TriccNodeEnd(TriccNodeDisplayCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.end
     process: str = None
     priority: int = 1000
+
     def __init__(self, **data):
-        if data.get('name', None) is None:
-            data['name'] = 'tricc_end_' + data.get('process', '') 
+        if data.get("name", None) is None:
+            data["name"] = "tricc_end_" + data.get("process", "")
         super().__init__(**data)
         # FOR END
-        
-        
 
     def set_name(self):
         if self.name is None:
             self.name = self.get_reference()
-        #self.name = END_NODE_FORMAT.format(self.activity.id)
+        # self.name = END_NODE_FORMAT.format(self.activity.id)
 
     def get_reference(self):
-        return 'tricc_end_' + (self.process or '')
+        return "tricc_end_" + (self.process or "")
+
 
 class TriccNodeActivityStart(TriccNodeFakeCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.activity_start
@@ -208,11 +224,10 @@ def get_node_from_list(in_nodes, node_id):
     if len(nodes) > 0:
         return nodes[0]
 
+
 # qualculate that saves quantity, or we may merge integer/decimals
 class TriccNodeQuantity(TriccNodeDisplayCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.quantity
 
 
-
-
-TriccNodeCalculate.update_forward_refs()
+TriccNodeCalculate.update_forward_refs()

tricc_oo/models/lang.py

@@ -5,21 +5,21 @@ class SingletonLangClass(object):
     languages = None
     entries = []
     po_file = None
-    
+
     def __init__(self):
         self.po_file = POFile()
-        
+
     def __new__(self):
-        if not hasattr(self, 'instance'):
+        if not hasattr(self, "instance"):
             self.instance = super(SingletonLangClass, self).__new__(self)
         return self.instance
-    
+
     def add_trad(self, code, lang):
         if self.languages is None:
             self.languages = {}
         self.languages[code] = lang
-    
-    def get_trads(self, message,  force_dict = False,trad=None):
+
+    def get_trads(self, message, force_dict=False, trad=None):
         if isinstance(message, dict):
             if force_dict:
                 return message
@@ -27,46 +27,45 @@ class SingletonLangClass(object):
                 return message[trad]
             return list(message.values())[0]
         message = message.strip()
-        if message == '' and (self.languages is None or trad is not None):
+        if message == "" and (self.languages is None or trad is not None):
             if force_dict:
-                return {'default': ''}
-            else :
-                return ''
-            
+                return {"default": ""}
+            else:
+                return ""
+
         if message not in self.entries:
-            self.po_file.insert(0,POEntry(msgid = message))
+            self.po_file.insert(0, POEntry(msgid=message))
             self.entries.append(message)
-        
+
         if self.languages is None or len(self.languages) == 0:
             if force_dict:
-                return {'default': message}
-            else :
+                return {"default": message}
+            else:
                 return message
         elif trad is not None:
-            return self.languages[trad].gettext(message) if len(message)>0 else ''
+            return self.languages[trad].gettext(message) if len(message) > 0 else ""
         else:
             trads = {}
             for code, lang in self.languages.items():
-                trads[code]= lang.gettext(message) if len(message)>0 else ''
+                trads[code] = lang.gettext(message) if len(message) > 0 else ""
             return trads
 
     def get_trads_map(self, col):
         if self.languages is None:
-            return {col:col}
+            return {col: col}
         else:
             map = {}
             for code, lang in self.languages.items():
-                map[col+'::'+code] = col+'['+code+']'
-            
-            return map 
+                map[col + "::" + code] = col + "[" + code + "]"
 
-    def join_trads(trads_1, trads_2, separator= ' '):
+            return map
+
+    def join_trads(trads_1, trads_2, separator=" "):
         dict_3 = {**trads_1, **trads_1}
         for key, value in dict_3.items():
             if key in trads_1 and key in trads_2:
-                    dict_3[key] = value + separator +  trads_1[key]
-        return dict_3       
-        
+                dict_3[key] = value + separator + trads_1[key]
+        return dict_3
+
     def to_po_file(self, path):
-        self.po_file.save(fpath = path)
-        
+        self.po_file.save(fpath=path)