prosimos 2.0.3__tar.gz → 2.0.5__tar.gz

{prosimos-2.0.3 → prosimos-2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prosimos
-Version: 2.0.3
+Version: 2.0.5
 Summary: 
 Author: Iryna Halenok
 Author-email: iryna.halenok@ut.ee

prosimos-2.0.5/prosimos/all_attributes.py

@@ -0,0 +1,79 @@
+from prosimos.event_attributes import AllEventAttributes
+from prosimos.case_attributes import AllCaseAttributes
+from prosimos.global_attributes import AllGlobalAttributes
+
+
+class AllAttributes:
+    def __init__(self, global_attributes, case_attributes, event_attributes):
+        global_attribute_names = {attr for attr in global_attributes.attributes}
+        all_case_attribute_names = {attr.name for attr in case_attributes.attributes}
+        all_event_attribute_names = set()
+        for event in event_attributes.attributes:
+            attrs = event_attributes.attributes[event]
+            all_event_attribute_names.update(attrs.keys())
+
+        global_case_attribute_names = global_attribute_names.intersection(all_case_attribute_names)
+        global_event_attribute_names = global_attribute_names.intersection(all_event_attribute_names)
+
+        self.global_attribute_initial_values = global_attributes.get_values_calculated()
+        self.global_attributes = self._extract_global_attributes(global_attributes, global_case_attribute_names, global_event_attribute_names)
+
+        self.global_case_attributes, self.case_attributes = \
+            self._extract_case_attributes(case_attributes, global_case_attribute_names)
+
+        self.global_event_attributes, self.event_attributes = \
+            self._extract_event_attributes(event_attributes, global_event_attribute_names)
+
+        self.event_attribute_names = [attr_name for inner_dict in self.event_attributes.attributes.values() for attr_name in inner_dict.keys()]
+
+        local_case_attribute_names = all_case_attribute_names - global_case_attribute_names
+        local_event_attribute_names = all_event_attribute_names - global_event_attribute_names
+        attributes_intersection = local_case_attribute_names.intersection(local_event_attribute_names)
+        if attributes_intersection:
+            raise ValueError(f"Case attributes cannot be changed by event attributes. Check {attributes_intersection} attributes")
+
+    def get_all_columns_generated(self):
+        attributes_collections = [
+            self.global_attributes,
+            self.global_case_attributes,
+            self.global_event_attributes,
+            self.case_attributes,
+            self.event_attributes
+        ]
+        columns = [attr.get_columns_generated() for attr in attributes_collections]
+        return [item for sublist in columns for item in sorted(sublist)]
+
+    def _extract_case_attributes(self, case_attributes, global_case_attribute_names):
+        global_case_attributes = list()
+        local_case_attributes = list()
+
+        for attr in case_attributes.attributes:
+            if attr.name in global_case_attribute_names:
+                global_case_attributes.append(attr)
+            else:
+                local_case_attributes.append(attr)
+
+        return AllCaseAttributes(global_case_attributes), AllCaseAttributes(local_case_attributes)
+
+    def _extract_event_attributes(self, event_attributes, global_event_attribute_names):
+        global_event_attributes = {}
+        local_event_attributes = {}
+
+        for event, attrs in event_attributes.attributes.items():
+            for attr, value in attrs.items():
+                if attr in global_event_attribute_names:
+                    global_event_attributes.setdefault(event, {})[attr] = value
+                else:
+                    local_event_attributes.setdefault(event, {})[attr] = value
+        return AllEventAttributes(global_event_attributes), AllEventAttributes(local_event_attributes)
+
+    def _extract_global_attributes(self, global_attributes, global_case_attribute_names, global_event_attribute_names):
+        attributes_to_remove = global_case_attribute_names.union(global_event_attribute_names)
+
+        filtered_attributes_dict = {
+            attr_name: attr_object
+            for attr_name, attr_object in global_attributes.attributes.items()
+            if attr_name not in attributes_to_remove
+        }
+
+        return AllGlobalAttributes(filtered_attributes_dict)

prosimos-2.0.5/prosimos/branch_condition_parser.py

@@ -0,0 +1,38 @@
+from typing import List
+from prosimos.branch_condition_rules import (
+    AllBranchConditionRules,
+    AndBranchConditionRule,
+    OrBranchConditionRule,
+    BranchConditionRule,
+    BranchConditionWithRule
+)
+
+
+class BranchConditionParser:
+    def __init__(self, json_data_with_branching_conditions):
+        self.data = json_data_with_branching_conditions
+
+    def parse(self):
+        branching_conditions: List[BranchConditionWithRule] = []
+        for curr_branch_condition_rule in self.data:
+            or_rules_json = curr_branch_condition_rule["rules"]
+            branch_id = curr_branch_condition_rule["id"]
+
+            or_rules: List[AndBranchConditionRule] = []
+            for or_rule in or_rules_json:
+                and_rules: List[BranchConditionRule] = []
+                for and_rule_json in or_rule:
+                    rule: BranchConditionRule = BranchConditionRule(
+                        and_rule_json["attribute"],
+                        and_rule_json["comparison"],
+                        and_rule_json["value"],
+                    )
+                    and_rules.append(rule)
+                all_and_rules = AndBranchConditionRule(and_rules)
+                or_rules.append(all_and_rules)
+
+            all_or_rules = OrBranchConditionRule(or_rules)
+
+            branching_conditions.append(BranchConditionWithRule(all_or_rules, branch_id))
+
+        return AllBranchConditionRules(branching_conditions)

prosimos-2.0.5/prosimos/branch_condition_rules.py

@@ -0,0 +1,106 @@
+import sys
+from typing import List, Tuple
+
+
+class InOperatorEvaluator:
+    def __init__(self, range: Tuple[float, float], case_value: float):
+        self.min, self.max = range  # including the edges
+        self.value = case_value
+
+    def eval(self):
+        if self.min == self.max:
+            # equal operator
+            return self.min == self.value
+        else:
+            # check whether in the range
+            return self.min <= self.value <= self.max
+
+
+class BranchConditionRule:
+    def __init__(self, attribute, condition, value):
+        self.attribute = attribute
+        self.condition = condition
+        self.value = self._parse_value(value)
+
+    def _parse_value(self, value):
+        if self.condition == "in":
+            min_boundary = float(value[0])
+            max_boundary = sys.maxsize if value[1] == "inf" else float(value[1])
+            return min_boundary, max_boundary
+        else:
+            return value
+
+    def is_rule_true(self, all_case_values):
+        if self.attribute not in all_case_values:
+            return False
+
+        raw_case_value = all_case_values[self.attribute]
+        if self.condition in [">", ">=", "<", "<=", "!="]:
+            try:
+                case_value = float(raw_case_value)
+                comparison_value = float(self.value)
+            except ValueError:
+                case_value = raw_case_value
+                comparison_value = self.value
+        else:
+            case_value = raw_case_value
+            comparison_value = self.value
+
+        if self.condition == "in":
+            min_value, max_value = comparison_value
+            return min_value <= case_value <= max_value
+        elif self.condition == ">":
+            return case_value > comparison_value
+        elif self.condition == ">=":
+            return case_value >= comparison_value
+        elif self.condition == "<":
+            return case_value < comparison_value
+        elif self.condition == "<=":
+            return case_value <= comparison_value
+        elif self.condition == "!=":
+            return case_value != comparison_value
+        else:
+            return case_value == comparison_value
+
+
+
+class AndBranchConditionRule:
+    def __init__(self, and_rules: List[BranchConditionRule]):
+        self.and_rules = and_rules
+
+    def is_and_rule_true(self, all_case_values):
+        init_val = True
+        for item in self.and_rules:
+            init_val = init_val and item.is_rule_true(all_case_values)
+        return init_val
+
+
+class OrBranchConditionRule:
+    def __init__(self, or_rules: List[AndBranchConditionRule]):
+        self.or_rules = or_rules
+
+    def is_or_rule_true(self, all_case_values):
+        init_val = False
+        for item in self.or_rules:
+            init_val = init_val or item.is_and_rule_true(all_case_values)
+        return init_val
+
+
+class BranchConditionWithRule:
+    def __init__(self, or_rule: OrBranchConditionRule, id: str):
+        self.or_rule = or_rule
+        self.id = id
+
+    def is_true(self, all_case_values):
+        return self.or_rule.is_or_rule_true(all_case_values)
+
+
+class AllBranchConditionRules:
+    def __init__(self, rules_array: List[BranchConditionWithRule]):
+        self.all_rules = rules_array
+
+    def get_branch_condition_by_id(self, branch_condition_id):
+        for rule in self.all_rules:
+            if rule.id == branch_condition_id:
+                return rule
+        return None

{prosimos-2.0.3 → prosimos-2.0.5}/prosimos/case_attributes.py

@@ -12,6 +12,7 @@ class CASE_ATTR_TYPE(Enum):
     DISCRETE = "discrete"
     CONTINUOUS = "continuous"
 
+
 def parse_discrete_value(value_info_arr):
     prob_arr = []
     options_arr = []
@@ -24,11 +25,12 @@ def parse_discrete_value(value_info_arr):
         "probabilities": prob_arr
     }
 
+
 def parse_continuous_value(value_info) -> "DurationDistribution":
     return DurationDistribution.from_dict(value_info)
 
 
-class CaseAttribute():
+class CaseAttribute:
     def __init__(self, name, case_atrr_type, value):
         self.name: str = name
         self.case_atrr_type: CASE_ATTR_TYPE = CASE_ATTR_TYPE(case_atrr_type)
@@ -50,16 +52,19 @@ class CaseAttribute():
             return self.value.generate_sample(1)[0]
 
     def validate(self):
+        epsilon = 1e-6
+
         if self.case_atrr_type == CASE_ATTR_TYPE.DISCRETE:
             actual_sum_probabilities = reduce(lambda acc, item: acc + item, self.value["probabilities"], 0) 
             
-            if actual_sum_probabilities != 1:
-                raise InvalidCaseAttributeException(f"Case attribute ${self.name}: probabilities' sum should be equal to 1") 
-        
+            if not (1 - epsilon <= actual_sum_probabilities <= 1 + epsilon):
+                raise InvalidCaseAttributeException(
+                    f"Case attribute {self.name}: probabilities' sum should be equal to 1")
+
         return True
 
 
-class AllCaseAttributes():
+class AllCaseAttributes:
     def __init__(self, case_attr_arr: List[CaseAttribute]):
         self.attributes = case_attr_arr
 

{prosimos-2.0.3 → prosimos-2.0.5}/prosimos/control_flow_manager.py

@@ -12,6 +12,8 @@ from prosimos.batch_processing import (BATCH_TYPE, AndFiringRule,
                                        BatchConfigPerTask)
 from prosimos.exceptions import InvalidBpmnModelException
 from prosimos.weekday_helper import CustomDatetimeAndSeconds
+from prosimos.simulation_execution_stats import SimulationExecutionStats
+from prosimos.warning_logger import warning_logger
 
 seconds_per_unit = {"s": 1, "m": 60, "h": 3600, "d": 86400, "w": 604800}
 
@@ -24,7 +26,7 @@ class BatchInfoForExecution:
 
     def is_sequential(self):
         return self.task_batch_info.type == BATCH_TYPE.SEQUENTIAL
-    
+
     def is_concurrent(self):
         return self.task_batch_info.type == BATCH_TYPE.CONCURRENT
 
@@ -36,7 +38,7 @@ class EnabledTask:
     def __init__(self, task_id, batch_info_exec: BatchInfoForExecution = None, duration_sec = None, is_event = False):
         self.task_id = task_id
         self.batch_info_exec = batch_info_exec
-        
+
         # is filled only for event-based gateways
         # (when we already know the duration at the control flow step)
         self.duration_sec = duration_sec
@@ -61,6 +63,8 @@ class BPMN(Enum):
         else:
             return False
 
+from prosimos.outgoing_flow_selector import OutgoingFlowSelector
+
 class EVENT_TYPE(Enum):
     MESSAGE = 'MESSAGE'
     TIMER = 'TIMER'
@@ -90,7 +94,7 @@ class ElementInfo:
 
     def is_start_or_end_event(self):
         return self.type in [BPMN.START_EVENT, BPMN.END_EVENT]
-    
+
     def is_event(self):
         return self.type in [BPMN.START_EVENT, BPMN.END_EVENT, BPMN.INTERMEDIATE_EVENT]
 
@@ -153,13 +157,20 @@ class BPMNGraph:
         self.batch_count = dict()
         self.batch_waiting_processes = dict()
         self.last_datetime = dict()
-
-    def set_additional_fields_from_json(self, element_probability, task_resource_probability, \
-        event_distribution, batch_processing):
+        self.all_attributes = None
+        self.gateway_conditions = None
+        self.gateway_execution_limit = 1000
+        self.simulation_execution_stats = SimulationExecutionStats()
+
+    def set_additional_fields_from_json(self, element_probability, task_resource_probability,
+                                        event_distribution, batch_processing, gateway_conditions,
+                                        gateway_execution_limit):
         self.element_probability = element_probability
         self.task_resource_probability = task_resource_probability
         self.event_distribution = event_distribution
         self.batch_info = batch_processing
+        self.gateway_conditions = gateway_conditions
+        self.gateway_execution_limit = gateway_execution_limit
 
     def add_bpmn_element(self, element_id, element_info):
         if element_info.type == BPMN.START_EVENT:
@@ -171,6 +182,7 @@ class BPMNGraph:
         self.from_name[element_info.name] = element_id
         self.nodes_bitset[element_id] = (1 << len(self.element_info))
         self.last_datetime[element_id] = dict()
+        self.simulation_execution_stats.add_element(element_info, element_id)
 
     def add_flow_arc(self, flow_id, source_id, target_id):
         for node_id in [source_id, target_id]:
@@ -328,18 +340,19 @@ class BPMNGraph:
             f_arcs = [(flow, None) for flow in flows]
 
             if len(f_arcs) > 1:
-                if e_info.type is BPMN.EXCLUSIVE_GATEWAY:
-                    f_arcs = [(self.element_probability[e_info.id].get_outgoing_flow(), None)]
-                elif e_info.type is BPMN.EVENT_BASED_GATEWAY:
+                if self.is_gateway_execution_limit_exceeded(case_id, e_info.id):
+                    break
+
+                if e_info.type is BPMN.EVENT_BASED_GATEWAY:
                     f_arcs = [self.get_event_gateway_choice(e_info, last_enabled.datetime)]
                 else:
-                    if e_info.type in \
-                        [BPMN.TASK, BPMN.PARALLEL_GATEWAY, BPMN.START_EVENT, BPMN.INTERMEDIATE_EVENT]:
-                        flows = copy.deepcopy(e_info.outgoing_flows)
-                        f_arcs = [(flow, None) for flow in flows]
-                    elif e_info.type is BPMN.INCLUSIVE_GATEWAY:
-                        f_arcs = self.element_probability[e_info.id].get_multiple_flows()
+                    all_curr_attributes = self.get_all_attributes(case_id)
+                    f_arcs = OutgoingFlowSelector.choose_outgoing_flow(e_info, self.element_probability,
+                                                                       all_curr_attributes, self.gateway_conditions)
                 random.shuffle(f_arcs)
+
+            self.simulation_execution_stats.update_element_execution(case_id, e_info, f_arcs)
+
             for f_arc in f_arcs:
                 self._find_next(f_arc, case_id, p_state, enabled_tasks, to_execute, last_enabled, visited_at)
             current += 1
@@ -347,9 +360,21 @@ class BPMNGraph:
             random.shuffle(enabled_tasks)
         return enabled_tasks, visited_at
 
+    def get_all_attributes(self, case_id):
+        all_current_attributes = {}
+        all_current_attributes.update(self.all_attributes["global"])
+        all_current_attributes.update(self.all_attributes[case_id])
+        return all_current_attributes
+
     def is_task_batched(self, task_id):
         return self.batch_info.get(task_id, None) != None
 
+    def is_gateway_execution_limit_exceeded(self, case_id, e_id):
+        element_executions = self.simulation_execution_stats.get_element_executions(case_id, e_id)
+        if element_executions >= self.gateway_execution_limit:
+            warning_logger.add_warning(f"Infinite loop was detected in case #{case_id} on element {e_id}. Case has been terminated")
+            return True
+        return False
 
     def is_batched_task_enabled(self, task_id: str, enabled_at: CustomDatetimeAndSeconds):
         """
@@ -371,8 +396,8 @@ class BPMNGraph:
             # not enough items for batch execution
             return False, None, None
 
-        waiting_time = [ (enabled_at.datetime - v.datetime).total_seconds() for (_, v) in self.batch_waiting_processes[task_id].items() ] 
-        
+        waiting_time = [ (enabled_at.datetime - v.datetime).total_seconds() for (_, v) in self.batch_waiting_processes[task_id].items() ]
+
         spec = {
             "size": size_count,
             "waiting_times": waiting_time,
@@ -397,7 +422,7 @@ class BPMNGraph:
 
         """
         spec["is_only_one_batch_return"] = True
-        
+
         final_is_true, final_batch_spec, final_start_time = False, None, None
 
         while True:
@@ -415,7 +440,7 @@ class BPMNGraph:
             final_batch_spec.append(num_items)
             final_is_true = is_true
             final_start_time = start_time
-            
+
             # regenerate the rule based on the size distribution
             task_batch_info.update_firing_rules_from_distr()
 
@@ -427,7 +452,7 @@ class BPMNGraph:
             if new_num_tasks_in_queue == 0:
                 # all items were included in the batches
                 break
-            
+
             spec["size"] = spec["size"] - num_items
 
         return final_is_true, final_batch_spec, final_start_time
@@ -438,10 +463,10 @@ class BPMNGraph:
         firing_rules: List[AndFiringRule] = task_batch_info.firing_rules
         enabled_times = list(self.batch_waiting_processes[task_id].items())
         batch_enabled_time = firing_rules.get_enabled_time(
-            enabled_times, 
+            enabled_times,
             last_task_enabled_time,
         )
-        
+
         if batch_enabled_time != None:
             enabled_time = batch_enabled_time
 
@@ -466,7 +491,7 @@ class BPMNGraph:
             event_id = self.flow_arcs[outgoing_flow][1]
             [duration] = self.event_duration(event_id)
             all_gateway_choices[outgoing_flow] = duration
-        
+
         min_value = min(all_gateway_choices.values())
         res = [(key, value) for key, value in all_gateway_choices.items() if value == min_value]
 
@@ -840,9 +865,9 @@ class BPMNGraph:
         enabled_time = self._check_and_update_enabling_time(case_id, next_e, enabled_time)
         visited_at[next_e] = enabled_time
         if self.is_enabled(next_e, p_state):
-            next_el_type = self.element_info[next_e].type 
+            next_el_type = self.element_info[next_e].type
             if next_el_type == BPMN.TASK and self.is_task_batched(next_e):
-                self.enable_batch_or_task(next_e, case_id, enabled_time, enabled_tasks, duration_sec)           
+                self.enable_batch_or_task(next_e, case_id, enabled_time, enabled_tasks, duration_sec)
             elif next_el_type == BPMN.TASK:
                 enabled_tasks.append(EnabledTask(next_e, None, duration_sec))
             elif next_el_type == BPMN.INTERMEDIATE_EVENT:
@@ -939,13 +964,13 @@ class BPMNGraph:
         # keep track of case_id which are waiting for the firing rule to be true
         if task_id not in self.batch_waiting_processes:
             self.batch_waiting_processes[task_id] = dict()
-        
+
         # in case we execute the batch, there is no need to increase the total num
         if case_id in self.batch_waiting_processes[task_id]:
             return
-        
+
         self.batch_waiting_processes[task_id][case_id] = enabled_time
-        
+
         if task_id in self.batch_count:
             self.batch_count[task_id] += 1
         else:
@@ -990,7 +1015,7 @@ class BPMNGraph:
             num_tasks_wait_batch = len(waiting_tasks)
             if num_tasks_wait_batch == 0:
                 continue
-            
+
             if self.is_or_rule_invalid(waiting_tasks, task_id, num_tasks_wait_batch, current_point_of_time):
                 # if the rule become invlaid, we execute everything we have
                 # invalid = the one that cannot be satisfied in the future anymore
@@ -1008,7 +1033,7 @@ class BPMNGraph:
                     task_id, batch_spec, start_time_from_rule
                 )
                 continue
-        
+
         return enabled_task_batch
 
     def create_batch_info_and_clear_from_queue(self, task_id: str, batch_spec, start_time_from_rule):
@@ -1024,7 +1049,7 @@ class BPMNGraph:
 
     def is_or_rule_invalid(self, waiting_tasks, task_id: str, num_tasks_wait_batch: int, current_point_of_time: CustomDatetimeAndSeconds):
         all_keys = list(waiting_tasks.keys())
-        
+
         first_key = all_keys[0]
         first_wt = (current_point_of_time.datetime - waiting_tasks[first_key].datetime).seconds