prosimos 2.0.2__tar.gz → 2.0.4__tar.gz

{prosimos-2.0.2 → prosimos-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prosimos
-Version: 2.0.2
+Version: 2.0.4
 Summary: 
 Author: Iryna Halenok
 Author-email: iryna.halenok@ut.ee
@@ -13,7 +13,6 @@ Requires-Dist: click (>=8.1.3,<9.0.0)
 Requires-Dist: numpy (>=1.24.3,<2.0.0)
 Requires-Dist: pandas (>=2.0.1,<3.0.0)
 Requires-Dist: pix-framework (>=0.13.0,<0.14.0)
-Requires-Dist: pm4py (>=2.7.4,<3.0.0)
 Requires-Dist: pylint (>=2.17.4,<3.0.0)
 Requires-Dist: python-dateutil (>=2.8.2,<3.0.0)
 Requires-Dist: pytz (>=2023.3,<2024.0)

prosimos-2.0.4/prosimos/all_attributes.py

@@ -0,0 +1,78 @@
+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_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.4/prosimos/branch_condition_parser.py

@@ -0,0 +1,42 @@
+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"]
+
+            # print(f"OR RULES JSON: {str(or_rules_json)}")
+            or_rules: List[AndBranchConditionRule] = []
+            for or_rule in or_rules_json:
+                and_rules: List[BranchConditionRule] = []
+                # print(f"OR RULE: {str(or_rule)}")
+                for and_rule_json in or_rule:
+                    # print(f"AND RULE JSON: {str(and_rule_json)}")
+                    rule: BranchConditionRule = BranchConditionRule(
+                        and_rule_json["attribute"],
+                        and_rule_json["comparison"],
+                        and_rule_json["value"],
+                    )
+                    and_rules.append(rule)
+                # print(f"AND RULES: {str(or_rule)}")
+                all_and_rules = AndBranchConditionRule(and_rules)
+                or_rules.append(all_and_rules)
+
+            all_or_rules = OrBranchConditionRule(or_rules)
+            # print(f"ALL OR RULES: {all_or_rules}\n\n")
+
+            branching_conditions.append(BranchConditionWithRule(all_or_rules, branch_id))
+
+        return AllBranchConditionRules(branching_conditions)

prosimos-2.0.4/prosimos/branch_condition_rules.py

@@ -0,0 +1,85 @@
+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
+
+        case_value = all_case_values[self.attribute]
+        if self.condition == "in":
+            evaluator = InOperatorEvaluator(self.value, case_value)
+            return evaluator.eval()
+        else:
+            return self.value == case_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.2 → prosimos-2.0.4}/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)
@@ -59,7 +61,7 @@ class CaseAttribute():
         return True
 
 
-class AllCaseAttributes():
+class AllCaseAttributes:
     def __init__(self, case_attr_arr: List[CaseAttribute]):
         self.attributes = case_attr_arr
 

{prosimos-2.0.2 → prosimos-2.0.4}/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
 

prosimos-2.0.4/prosimos/event_attributes.py

@@ -0,0 +1,124 @@
+from enum import Enum
+from functools import reduce
+from random import choices
+from typing import Dict
+import ast
+import operator as op
+
+from pix_framework.statistics.distribution import DurationDistribution
+
+from prosimos.exceptions import InvalidEventAttributeException
+
+
+class EVENT_ATTR_TYPE(Enum):
+    DISCRETE = "discrete"
+    CONTINUOUS = "continuous"
+    EXPRESSION = "expression"
+
+
+operators = {
+    ast.Add: op.add, ast.Sub: op.sub, ast.Mult: op.mul, ast.Div: op.truediv,
+    ast.USub: op.neg, ast.Eq: op.eq, ast.NotEq: op.ne, ast.Lt: op.lt,
+    ast.LtE: op.le, ast.Gt: op.gt, ast.GtE: op.ge, ast.Not: op.not_,
+    ast.And: op.and_, ast.Or: op.or_, ast.Mod: op.mod, ast.Pow: op.pow,
+    ast.FloorDiv: op.floordiv
+}
+
+
+def parse_discrete_value(value_info_arr):
+    prob_arr = []
+    options_arr = []
+    for item in value_info_arr:
+        options_arr.append(item["key"])
+        prob_arr.append(float(item["value"]))
+
+    return {
+        "options": options_arr,
+        "probabilities": prob_arr
+    }
+
+
+def parse_continuous_value(value_info) -> "DurationDistribution":
+    return DurationDistribution.from_dict(value_info)
+
+
+def eval_expr(expr, vars_dict):
+    try:
+        tree = ast.parse(expr, mode='eval')
+    except (SyntaxError, ZeroDivisionError, TypeError, KeyError):
+        return None
+
+    def _eval(node):
+        try:
+            if isinstance(node, ast.Num):
+                return node.n
+            elif isinstance(node, ast.BinOp):
+                return operators[type(node.op)](_eval(node.left), _eval(node.right))
+            elif isinstance(node, ast.UnaryOp):
+                return operators[type(node.op)](_eval(node.operand))
+            elif isinstance(node, ast.Name):
+                return vars_dict[node.id]
+            elif isinstance(node, ast.Str):
+                return node.s
+            elif isinstance(node, ast.Compare):
+                return operators[type(node.ops[0])](_eval(node.left), _eval(node.comparators[0]))
+            elif isinstance(node, ast.BoolOp):
+                if type(node.op) is ast.And:
+                    return all(_eval(value) for value in node.values)
+                elif type(node.op) is ast.Or:
+                    return any(_eval(value) for value in node.values)
+            else:
+                return None
+        except (SyntaxError, ZeroDivisionError, TypeError, KeyError):
+            return None
+
+    return _eval(tree.body)
+
+
+class EventAttribute:
+    def __init__(self, event_id, name, event_attr_type, value):
+        self.event_id: str = event_id
+        self.name: str = name
+        self.event_attr_type: EVENT_ATTR_TYPE = EVENT_ATTR_TYPE(event_attr_type)
+
+        if self.event_attr_type == EVENT_ATTR_TYPE.DISCRETE:
+            self.value = parse_discrete_value(value)
+        elif self.event_attr_type == EVENT_ATTR_TYPE.CONTINUOUS:
+            self.value = parse_continuous_value(value)
+        elif self.event_attr_type == EVENT_ATTR_TYPE.EXPRESSION:
+            self.value = value
+        else:
+            raise Exception(f"Not supported event attribute {type}")
+
+        self.validate()
+
+    def get_next_value(self, all_attributes={}):
+        if self.event_attr_type == EVENT_ATTR_TYPE.DISCRETE:
+            one_choice_arr = choices(self.value["options"], self.value["probabilities"])
+            return one_choice_arr[0]
+        elif self.event_attr_type == EVENT_ATTR_TYPE.EXPRESSION:
+            return eval_expr(self.value, all_attributes)
+        else:
+            return self.value.generate_sample(1)[0]
+
+    def validate(self):
+        if self.event_attr_type == EVENT_ATTR_TYPE.DISCRETE:
+            actual_sum_probabilities = reduce(lambda acc, item: acc + item, self.value["probabilities"], 0)
+
+            if actual_sum_probabilities != 1:
+                raise InvalidEventAttributeException(
+                    f"Event attribute ${self.name}: probabilities' sum should be equal to 1")
+
+        return True
+
+
+class AllEventAttributes:
+    def __init__(self, event_attr_arr: Dict[str, Dict[str, EventAttribute]]):
+        self.attributes = event_attr_arr
+
+    def get_columns_generated(self):
+        return list({attr.name for event_id in self.attributes for attr in self.attributes[event_id].values()})
+
+    def get_values_calculated(self):
+        return {attr.name: attr.get_next_value() for event_id in self.attributes for attr in
+                self.attributes[event_id].values()}

prosimos-2.0.4/prosimos/event_attributes_parser.py

@@ -0,0 +1,23 @@
+from prosimos.event_attributes import (AllEventAttributes, EventAttribute)
+
+
+class EventAttributesParser:
+    def __init__(self, json_data_with_event_attributes):
+        self.data = json_data_with_event_attributes
+
+    def parse(self):
+        event_attributes = {}
+        for curr_event_attr in self.data:
+            event_id = curr_event_attr["event_id"]
+            event_attributes[event_id] = {}
+            for attr in curr_event_attr["attributes"]:
+                event_attr = EventAttribute(
+                    event_id,
+                    attr["name"],
+                    attr["type"],
+                    attr["values"]
+                )
+                event_attributes[event_id][attr["name"]] = event_attr
+
+        return AllEventAttributes(event_attributes)
+    

{prosimos-2.0.2 → prosimos-2.0.4}/prosimos/exceptions.py

@@ -12,12 +12,22 @@ class InvalidBpmnModelException(Error):
 class InvalidLogFileException(Error):
     """Raised when the provided log file is invalid"""
 
+
 class InvalidSimScenarioException(Error):
     """Raised when the provided simulation scenario (.json file) is invalid"""
 
+
 class InvalidRuleDefinitionException(Error):
     """Raised when the defined rule is invalid"""
 
+
 class InvalidCaseAttributeException(Error):
     """Raised when the defined case attribute is invalid"""
-    
+
+
+class InvalidEventAttributeException(Error):
+    """Raised when the defined event attribute is invalid"""
+
+
+class InvalidGlobalAttributeException(Error):
+    """Raised when the defined event attribute is invalid"""

prosimos-2.0.4/prosimos/gateway_condition_choice.py

@@ -0,0 +1,10 @@
+class GatewayConditionChoice:
+    def __init__(self, candidates_list, rules_list):
+        self.candidates_list = candidates_list
+        self.rules_list = rules_list
+
+    def get_outgoing_flow(self, case_attributes):
+        return [candidate for candidate, rule in zip(self.candidates_list, self.rules_list)
+                if rule.is_true(case_attributes)]
+
+