tricc-oo 1.0.2__py3-none-any.whl → 1.4.15__py3-none-any.whl

tricc_oo/models/calculate.py

@@ -0,0 +1,216 @@
+
+import logging
+import random
+import string
+from enum import Enum, auto
+from typing import Dict, ForwardRef, List, Optional, Union
+
+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
+
+
+    
+
+
+
+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
+    # no need to copy save
+    def to_fake(self):
+        data = vars(self)
+        del data['hint']
+        del data['help']
+        del data['save']
+        fake = TriccNodeFakeCalculateBase(**data)
+        replace_node(self,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
+
+
+class TriccNodeAdd(TriccNodeDisplayCalculateBase):
+    tricc_type: TriccNodeType = TriccNodeType.add
+    datatype: str = 'number'
+
+
+class TriccNodeCount(TriccNodeDisplayCalculateBase):
+    tricc_type: TriccNodeType = TriccNodeType.count
+    datatype: str = 'number'
+
+
+class TriccNodeProposedDiagnosis(TriccNodeDisplayCalculateBase):
+    tricc_type: TriccNodeType = TriccNodeType.proposed_diagnosis
+    severity: str = 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():
+    
+    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)):
+            expression_reference = self.expression_reference.copy()
+            reference = list(expression_reference.get_references())
+        if isinstance(self.reference, (str, TriccOperation)):
+            expression_reference = self.reference.copy()
+            reference = list(expression_reference.get_references())
+        elif isinstance(self.reference, list):
+            for ref in self.reference:
+                if issubclass(ref.__class__, TriccBaseModel):
+                    pass
+                    # get the reference
+                    if self.activity == ref.activity:
+                        for sub_node in activity.nodes.values():
+                            if sub_node.base_instance == ref:
+                                reference.append(sub_node)
+                    else:  # ref from outside
+                        reference.append(ref)
+                        logger.warning("new instance of a rhombus use the reference of the base one")
+                elif isinstance(ref, TriccReference):
+                    reference.append(ref)
+                elif isinstance(ref, str):
+                    logger.debug("passing raw reference {} on node {}".format(ref, self.get_name()))
+                    reference.append(ref)
+                else:
+                    logger.critical("unexpected reference {} in node {}".format(ref, self.get_name()))
+                    exit(1)
+        instance.reference = reference
+        instance.expression_reference = expression_reference
+        instance.name = get_rand_name(self.id)
+        return instance
+
+
+    
+
+class TriccNodeRhombus(TriccNodeCalculateBase,TriccRhombusMixIn):
+    tricc_type: TriccNodeType = TriccNodeType.rhombus
+    path: Optional[TriccNodeBaseModel] = None
+    reference: Union[List[TriccNodeBaseModel], Expression, TriccOperation, TriccReference, List[TriccReference]]
+    
+    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))
+        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'
+        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)
+    if not isinstance(node_id, str):
+        logger.critical("can set prev_next only with string or node")
+        exit(1)
+    if issubclass(node.__class__, TriccBaseModel):
+        return node_id, node
+    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()}")
+        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)
+        return instance
+
+
+class TriccNodeActivityEnd(TriccNodeFakeCalculateBase):
+    tricc_type: TriccNodeType = TriccNodeType.activity_end
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        # FOR END
+        self.set_name()
+
+    def set_name(self):
+        self.name = ACTIVITY_END_NODE_FORMAT.format(self.activity.id)
+
+
+class TriccNodeEnd(TriccNodeDisplayCalculateBase):
+    tricc_type: TriccNodeType = TriccNodeType.end
+    process: str = None
+    def __init__(self, **data):
+        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)
+
+    def get_reference(self):
+        return 'tricc_end_' + (self.process or '')
+
+class TriccNodeActivityStart(TriccNodeFakeCalculateBase):
+    tricc_type: TriccNodeType = TriccNodeType.activity_start
+    relevance: Optional[Union[Expression, TriccOperation]] = None
+
+
+def get_node_from_list(in_nodes, node_id):
+    nodes = list(filter(lambda x: x.id == node_id, in_nodes))
+    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()

tricc_oo/models/ocl.py

@@ -0,0 +1,281 @@
+# https://docs.openconceptlab.org/
+
+from enum import Enum
+from typing import Dict, List, Optional,  Union, Literal, Annotated
+from xml.dom import HIERARCHY_REQUEST_ERR
+from xmlrpc.client import Boolean
+from pydantic import BaseModel, constr, AnyHttpUrl, StringConstraints
+from ocldev.oclconstants import OclConstants, OclConstants as OclConstantsBase
+
+OCLId = Annotated[
+    str,
+    StringConstraints(pattern=r"^.+$")
+]
+OCLName = Annotated[
+    str,
+    StringConstraints(pattern=r"^.+$")
+]
+OCLShortName = Annotated[
+    str,
+    StringConstraints(pattern=r"^.+$")
+]
+OCLLocale = Annotated[
+    str,
+    StringConstraints(pattern=r"^[a-zA-Z\-]{2,7}$")
+]
+Uri = Annotated[
+    str,
+    StringConstraints(pattern=r"^.+$")
+]
+OCLMapCode = Annotated[
+    str,
+    StringConstraints(pattern=r"^.+$")
+]
+
+
+
+class OclConstants(OclConstantsBase):
+    #OCL Access type
+    ACCESS_TYPE_VIEW = 'View'
+    ACCESS_TYPE_EDIT = 'Edit'
+    ACCESS_TYPE_NONE = 'None'
+    ACCESS_TYPES = [
+        ACCESS_TYPE_EDIT,
+        ACCESS_TYPE_VIEW,
+        ACCESS_TYPE_NONE
+    ]
+    #https://www.hl7.org/fhir/valueset-codesystem-hierarchy-meaning.html
+    HIERARCHY_MEANING_IS_A = 'is-a' 
+    HIERARCHY_MEANING_GROUP_BY = 'grouped-by'
+    HIERARCHY_MEANING_PART_OF = 'part-of'
+    HIERARCHY_MEANING_CLASSIFIED_WITH = ' classified-with'
+    HIERARCHY_MEANINGS = [
+        HIERARCHY_MEANING_IS_A,
+        HIERARCHY_MEANING_GROUP_BY,
+        HIERARCHY_MEANING_PART_OF,
+        HIERARCHY_MEANING_CLASSIFIED_WITH
+    ]
+    SOURCE_TYPE_DICTIONARY = "Dictionary"
+    SOURCE_TYPE_REFERENCE = "Reference"
+    SOURCE_TYPE_EXTERNAL_DICTIONARY = "ExternalDictionary"
+    SOURCE_TYPES = [
+        SOURCE_TYPE_DICTIONARY,
+        SOURCE_TYPE_REFERENCE,
+        SOURCE_TYPE_EXTERNAL_DICTIONARY 
+    ]
+    # MAP type found for fever/malaria on OCL app
+    MAP_TYPE_SAME_AS = "SAME-AS"
+    MAP_TYPE_PART_OF = "PART-OF"
+    MAP_TYPE_Q_AND_A = "Q-AND-A"
+    MAP_TYPE_NARROWER_THAN = "NARROWER-THAN"
+    MAP_TYPE_CONCEPT_SET = "CONCEPT-SET"
+    MAP_TYPE_SYSTEM = "SYSTEM"
+    MAP_TYPE_BROADER_THAN = "BROADER-THAN"
+    MAP_TYPE_HAS_ANSWER = "HAS-ANSWER"
+    MAP_TYPE_HAS_ELEMENT = "HAS-ELEMENT"
+    MAP_TYPE_MAP_TO = "MAP-TO"
+    MAP_TYPES = [
+        MAP_TYPE_SAME_AS,
+        MAP_TYPE_PART_OF,
+        MAP_TYPE_Q_AND_A,
+        MAP_TYPE_NARROWER_THAN,
+        MAP_TYPE_CONCEPT_SET,
+        MAP_TYPE_SYSTEM,
+        MAP_TYPE_BROADER_THAN,
+        MAP_TYPE_HAS_ANSWER,
+        MAP_TYPE_HAS_ELEMENT,
+        MAP_TYPE_MAP_TO,
+    ]
+    DATA_TYPE_BOOLEAN = 'Boolean'
+    DATA_TYPE_COMPLEX = "Complex"
+    DATA_TYPE_STRUCTURED_NUMERIC = "Structured-Numeric"
+    DATA_TYPE_RULE = "Rule"
+    DATA_TYPE_DATETIME = "Datetime"
+    DATA_TYPE_TIME = "Time"
+    DATA_TYPE_DATE = "Date"
+    DATA_TYPE_DOCUMENT = "Document"
+    DATA_TYPE_CODED = "Coded"
+    DATA_TYPE_STRING = "String"
+    DATA_TYPE_TEXT = "Text"
+    DATA_TYPE_NA = "N/A"
+    DATA_TYPE_NUMERIC = "Numeric"
+    DATA_TYPE_NONE = "None"
+    DATA_TYPES =[
+        DATA_TYPE_BOOLEAN,
+        DATA_TYPE_CODED,
+        DATA_TYPE_STRING,
+        DATA_TYPE_TEXT,
+        DATA_TYPE_NA,
+        DATA_TYPE_NUMERIC,
+        DATA_TYPE_NONE,
+        DATA_TYPE_COMPLEX,
+        DATA_TYPE_STRUCTURED_NUMERIC,
+        DATA_TYPE_RULE,
+        DATA_TYPE_DATETIME,
+        DATA_TYPE_TIME,
+        DATA_TYPE_DATE,
+        DATA_TYPE_DOCUMENT
+    ]
+    DESCRIPTION_TYPE_DEFINITION = "Definition"
+    DESCRIPTION_TYPE_NONE = "None"
+    DESCRIPTION_TYPES = [
+        DESCRIPTION_TYPE_DEFINITION,
+        DESCRIPTION_TYPE_NONE
+                         
+    ]
+    NAME_TYPE_INDEX_TERM = "Index-Term"
+    NAME_TYPE_SHORT = "Short"
+    NAME_TYPE_FULLY_SPECIFIED = "Fully-Specified"
+    NAME_TYPE_NONE = "None"
+    NAME_TYPES = [
+        NAME_TYPE_INDEX_TERM,
+        NAME_TYPE_SHORT,
+        NAME_TYPE_FULLY_SPECIFIED,
+        NAME_TYPE_NONE                   
+    ]
+OCLRessourceType= Literal[tuple(OclConstants.RESOURCE_TYPES)]
+
+
+def get_data_type(tricc_type):
+    if tricc_type.lower() in ('integer', 'decimal', 'add', 'count'):
+        return OclConstants.DATA_TYPE_NUMERIC
+    elif tricc_type.lower() in ('activity', 'page'):
+        return OclConstants.DATA_TYPE_DOCUMENT
+    elif tricc_type.lower() in ('select_one'):
+        return OclConstants.DATA_TYPE_CODED
+    elif tricc_type.lower() in ('calculate', 'diagnosis', 'proposed_diagnosis'):
+        return OclConstants.DATA_TYPE_BOOLEAN
+    found_type = [ t  for t in OclConstants.DATA_TYPES if t.lower() == tricc_type.lower()]
+    if found_type:
+        return found_type[0]
+    return OclConstants.DATA_TYPE_NA
+ 
+class OCLBaseModel(BaseModel):
+    type:OCLRessourceType
+    id:OCLId
+    external_id:str = None
+    public_access:Literal[tuple(OclConstants.ACCESS_TYPES)] = OclConstants.ACCESS_TYPE_VIEW
+    extras:Dict[str,Union[str,Dict[str,str]]] = {}
+    url: Union[AnyHttpUrl,Uri] = None
+    # enriched data for get
+class OclGet(BaseModel):
+    created_on:str = None
+    created_by:str = None
+    updated_on:str = None
+    updated_by:str = None
+    
+class OCLBaseModelBrowsable(OCLBaseModel):
+    name:OCLName
+    description:str = None
+    website:AnyHttpUrl = None
+    
+
+class OCLDetailedName(BaseModel):
+    name: str
+    external_id:str = None
+    locale:OCLLocale
+    locale_preferred:Boolean = None
+    name_type:Literal[tuple(OclConstants.NAME_TYPES)] = OclConstants.NAME_TYPE_SHORT
+
+class OCLDetailedDescription(BaseModel):
+    description:str
+    external_id:str = None
+    locale:OCLLocale
+    locale_preferred:Boolean = None
+    description_type:Literal[tuple(OclConstants.DESCRIPTION_TYPES)] = OclConstants.DESCRIPTION_TYPE_DEFINITION
+
+class OCLConcept(OCLBaseModel):
+    type:OCLRessourceType = OclConstants.RESOURCE_TYPE_CONCEPT
+    uuid: str = None
+    concept_class: str
+    datatype:Literal[tuple(OclConstants.DATA_TYPES)] = OclConstants.DATA_TYPE_NONE
+    names:List[OCLDetailedName]
+    descriptions: List[OCLDetailedDescription] = []
+    retired:Boolean = False
+    # not for create
+    versions: str = None # TODO version
+    source:OCLId = None
+    owner:OCLId = None
+    owner_type:Literal[tuple(OclConstants.OWNER_TYPE_TO_STEM)] = None    
+    owner_url:Union[AnyHttpUrl,Uri] = None
+    versions_url:Union[AnyHttpUrl,Uri] = None
+    source_url:Union[AnyHttpUrl,Uri] = None
+    owner_url:Union[AnyHttpUrl,Uri] = None
+    mappings_url:Union[AnyHttpUrl,Uri] = None
+    
+class OCLMapping(BaseModel):
+    type:OCLRessourceType = OclConstants.RESOURCE_TYPE_MAPPING
+    uuid: str = None
+    retired:Boolean = False
+    map_type: Literal[tuple(OclConstants.MAP_TYPES)]
+    from_concept_url:Union[AnyHttpUrl,Uri]
+    from_source_url:Uri = None
+    from_concept_code:str = None
+    from_concept_name:str = None
+    to_concept_url:Union[AnyHttpUrl,Uri] = None
+    to_source:str = None
+    to_concept_code:str = None
+    to_source_owner:OCLId = None
+    to_source_owner_type:Literal[tuple(OclConstants.OWNER_TYPE_TO_STEM)] = None
+    #for bulk
+    source:OCLId = None
+    owner:OCLId = None
+    owner_type:Literal[tuple(OclConstants.OWNER_TYPE_TO_STEM.values())] = None
+
+class OCLCollection(OCLBaseModelBrowsable):
+    #TODO https://docs.openconceptlab.org/en/latest/oclapi/apireference/collections.html
+    pass
+
+class OCLUser(OCLBaseModelBrowsable):
+    #TODO https://docs.openconceptlab.org/en/latest/oclapi/apireference/users.html
+    pass 
+    
+class  OCLMappingInternal(OCLMapping):             
+    to_concept_url:Union[AnyHttpUrl,Uri]
+    # when there is not URL
+    
+class  OCLMappingExternal(OCLMapping):   
+    to_source_url:Uri
+    to_concept_code:str
+    to_concept_name:str = None
+        
+class OCLOrganisation(OCLBaseModelBrowsable):
+    type:OCLRessourceType = OclConstants.RESOURCE_TYPE_ORGANIZATION
+    company:OCLName
+    logo_url:AnyHttpUrl
+    location:OCLName
+    text:str
+    
+    
+
+class OCLSource(OCLBaseModelBrowsable):
+    type:OCLRessourceType = OclConstants.RESOURCE_TYPE_SOURCE
+    short_code:OCLShortName
+    full_name:OCLName
+    source_type:Literal[tuple(OclConstants.SOURCE_TYPES)] = OclConstants.SOURCE_TYPE_DICTIONARY
+    default_locale:OCLLocale = 'en'
+    supported_locales:List[OCLLocale] = ['en']
+    custom_validation_schema:str = 'None'
+    # not for create
+    owner:OCLId = None
+    owner_type:Literal[tuple(OclConstants.OWNER_TYPE_TO_STEM)] = None
+    owner_url:Union[AnyHttpUrl,Uri] = None
+    #FHIR
+    hierarchy_meaning:Literal[tuple(OclConstants.HIERARCHY_MEANINGS)] = None
+    hierarchy_root_url:Union[AnyHttpUrl,Uri] = None
+    meta:str = None
+    canonical_url:Union[AnyHttpUrl,Uri] = None
+    internal_reference_id:OCLId = None
+    #collection_reference:Uri
+    versions_url:Union[AnyHttpUrl,Uri] = None
+    concepts_url:Union[AnyHttpUrl,Uri] = None
+    mappings_url:Union[AnyHttpUrl,Uri] = None
+    
+    versions: str = None # TODO version
+    active_concepts:int = 0
+    active_mappings:int = 0
+    
+class OCLSourceVersion(OCLBaseModelBrowsable):
+    released: Boolean = None
+    previous_version :str
+    parent_version :str

tricc_oo/models/ordered_set.py

@@ -0,0 +1,125 @@
+from collections import OrderedDict
+from collections.abc import Iterable, Sequence
+from pydantic import BaseModel, GetCoreSchemaHandler
+from pydantic_core import CoreSchema
+
+class OrderedSet(Sequence):
+    def __init__(self, iterable=None):
+        self._od = OrderedDict.fromkeys(iterable or [])
+
+    def copy(self):
+        return OrderedSet(list(self._od.keys()))
+
+    def add(self, item):
+        self.insert_at_bottom(item)
+
+    def remove(self, item):
+        del self._od[item]
+
+    def pop(self):
+        return self._od.popitem(last=False)[0]
+
+    def insert_at_top(self, item):
+            # Add item if not already present
+        self.insert_at_bottom(item)
+        # Move item to the top
+        self._od.move_to_end(item, last=False)
+        
+    def insert_at_bottom(self, item):
+        if item not in self._od:
+            self._od[item] = None
+    def __contains__(self, item):
+        return item in self._od
+
+    def __iter__(self):
+        return iter(self._od)
+
+    def __len__(self):
+        return len(self._od)
+
+    def __repr__(self):
+        return f"{type(self).__name__}({list(self._od.keys())})"
+
+    def _add_items(self, items):
+        for item in items:
+            if item not in self:
+                self.insert_at_bottom(item)
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        else:
+            return self._od.keys() == other._od.keys()
+    
+    # Union method (| operator)
+    def __or__(self, other):
+        if not isinstance(other, Iterable):
+            raise TypeError(f"Unsupported operand type(s) for |: 'OrderedSet' and '{type(other).__name__}'")
+        new_set = self.copy()
+        new_set._add_items(other)
+        return new_set
+
+    def union(self, other):
+        return self.__or__(other)
+    def __or__(self, other):
+        if not isinstance(other, Iterable):
+            raise TypeError("Unsupported operand type(s) for |: 'OrderedSet' and '{}'".format(type(other)))
+        new_set = self.copy()
+        new_set._add_items(other)
+        return new_set
+    
+    def __iadd__(self, other):
+        if not isinstance(other, Iterable):
+            raise TypeError("Unsupported operand type(s) for +=: 'OrderedSet' and '{}'".format(type(other)))
+        self._add_items(other)
+        return self
+    
+    def get(self, index):
+        return self.__getitem__(index)
+    
+    def __getitem__(self, index):
+        try:
+            return list(self._od.keys())[index]
+        except IndexError:
+            raise IndexError("Index out of range") from None
+        
+    def sort(self, key=None, reverse=False):
+        sorted_keys = sorted(self._od.keys(), key=key, reverse=reverse)
+        self._od = OrderedDict.fromkeys(sorted_keys)
+        
+    def find_last(self, filter: callable):
+        # Iterate over items in reverse order
+        for item in reversed(list(self._od.keys())):
+            if filter(item):
+                return item
+        return None  # Return None if no matching item is found
+
+    def find_first(self, filter: callable):
+        for item in list(self._od.keys()):
+            if filter(item):
+                return item
+        return None  # Return None if no matching item is found
+
+
+    def find_prev(self, obj, filter: callable):
+        # Get the list of keys (items) in the OrderedSet
+        keys = list(self._od.keys())
+        
+        # If the object is not in the OrderedSet, start from the end
+        if obj not in self._od:
+            start_index = len(keys) - 1
+        else:
+            # Find the index of the given object
+            start_index = keys.index(obj)
+        
+        # Iterate backward from the start_index
+        for i in range(start_index - 1, -1, -1):
+            item = keys[i]
+            if filter(item):
+                return item
+        
+        return None  # Return None if no matching item is found before the object
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source_type: type, handler: GetCoreSchemaHandler) -> CoreSchema:
+        # Define how Pydantic should handle this type
+        return handler.generate_schema(list)  # Treat it as a list for validation purposes