prosimos 2.0.4__tar.gz → 2.0.5__tar.gz

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

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

{prosimos-2.0.4 → prosimos-2.0.5}/prosimos/all_attributes.py

@@ -15,6 +15,7 @@ class AllAttributes:
         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 = \

{prosimos-2.0.4 → prosimos-2.0.5}/prosimos/branch_condition_parser.py

@@ -7,6 +7,7 @@ from prosimos.branch_condition_rules import (
     BranchConditionWithRule
 )
 
+
 class BranchConditionParser:
     def __init__(self, json_data_with_branching_conditions):
         self.data = json_data_with_branching_conditions
@@ -17,25 +18,20 @@ class BranchConditionParser:
             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))
 

{prosimos-2.0.4 → prosimos-2.0.5}/prosimos/branch_condition_rules.py

@@ -26,7 +26,6 @@ class BranchConditionRule:
         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
@@ -35,12 +34,34 @@ class BranchConditionRule:
         if self.attribute not in all_case_values:
             return False
 
-        case_value = all_case_values[self.attribute]
+        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":
-            evaluator = InOperatorEvaluator(self.value, case_value)
-            return evaluator.eval()
+            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 self.value == case_value
+            return case_value == comparison_value
+
 
 
 class AndBranchConditionRule:

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

@@ -52,12 +52,15 @@ 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
 
 

prosimos-2.0.5/prosimos/event_attributes.py

@@ -0,0 +1,245 @@
+import pprint
+from enum import Enum
+from random import choices
+from typing import Dict
+import ast
+import operator as op
+import numpy as np
+
+from pix_framework.statistics.distribution import DurationDistribution
+
+from prosimos.exceptions import InvalidEventAttributeException
+import math
+
+
+class EVENT_ATTR_TYPE(Enum):
+    DISCRETE = "discrete"
+    CONTINUOUS = "continuous"
+    EXPRESSION = "expression"
+    DTREE = "dtree"
+
+
+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 fix(mean):
+    return DurationDistribution(name="fix", mean=mean, var=0.0, std=0.0, minimum=mean, maximum=mean).generate_sample(1)[0]
+
+
+def uniform(minimum, maximum):
+    return DurationDistribution(name="uniform", minimum=minimum, maximum=maximum).generate_sample(1)[0]
+
+
+def norm(mean, std, minimum=None, maximum=None):
+    return DurationDistribution(name="norm", mean=mean, std=std, minimum=minimum, maximum=maximum).generate_sample(1)[0]
+
+
+def triang(c, minimum, maximum):
+    return DurationDistribution(name="triang", mean=c, minimum=minimum, maximum=maximum).generate_sample(1)[0]
+
+
+def expon(mean, minimum=None, maximum=None):
+    return DurationDistribution(name="expon", mean=mean, minimum=minimum, maximum=maximum).generate_sample(1)[0]
+
+
+def lognorm(mean, var, minimum=None, maximum=None):
+    return DurationDistribution(name="lognorm", mean=mean, var=var, minimum=minimum, maximum=maximum).generate_sample(1)[0]
+
+
+def gamma(mean, var, minimum=None, maximum=None):
+    return DurationDistribution(name="gamma", mean=mean, var=var, minimum=minimum, maximum=maximum).generate_sample(1)[0]
+
+
+distributions = {
+    'fix': fix,
+    'uniform': uniform,
+    'norm': norm,
+    'triang': triang,
+    'expon': expon,
+    'lognorm': lognorm,
+    'gamma': gamma
+}
+
+math_functions = {name: getattr(math, name) for name in dir(math) if callable(getattr(math, name))}
+
+
+def parse_discrete_value(value_info):
+    if isinstance(value_info, list):
+        prob_arr = []
+        options_arr = []
+        for item in value_info:
+            options_arr.append(item["key"])
+            prob_arr.append(float(item["value"]))
+
+        return {
+            "type": "discrete",
+            "options": options_arr,
+            "probabilities": prob_arr
+        }
+    elif isinstance(value_info, dict):
+        return {
+            "type": "markov",
+            "transitions": value_info
+        }
+    else:
+        raise ValueError("Unsupported value_info format for discrete value")
+
+
+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):
+                if node.id in vars_dict:
+                    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)
+            elif isinstance(node, ast.Call):
+                func_name = node.func.id
+                args = [_eval(arg) for arg in node.args]
+                if func_name in distributions:
+                    return distributions[func_name](*args)
+                elif func_name in math_functions:
+                    args = [_eval(arg) for arg in node.args]
+                    try:
+                        return math_functions[func_name ](*args)
+                    except OverflowError:
+                        return np.finfo(np.float32).max
+                    except ValueError as e:
+                        return 0
+            else:
+                return 0
+        except (SyntaxError, ZeroDivisionError, TypeError, KeyError):
+            return 0
+
+    return _eval(tree.body)
+
+
+def evaluate_dtree(dtree, vars_dict):
+    for conditions, formula in dtree:
+        if conditions is True or all(eval_expr(cond, vars_dict) for cond in conditions):
+            return eval_expr(formula, vars_dict)
+    return None
+
+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
+        elif self.event_attr_type == EVENT_ATTR_TYPE.DTREE:
+            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:
+            if self.value["type"] == "markov":
+                current_value = all_attributes.get(self.name, None)
+                next_state = self.get_next_markov_state(current_value)
+                if next_state is not None:
+                    all_attributes[self.name] = next_state
+                    return next_state
+                return current_value
+            else:
+                one_choice_arr = choices(self.value["options"], self.value["probabilities"])
+                return one_choice_arr[0]
+
+        elif self.event_attr_type == EVENT_ATTR_TYPE.EXPRESSION:
+            result = eval_expr(self.value, all_attributes)
+            if isinstance(result, (int, float, np.number)) and not isinstance(result, bool):
+                if result == 0:  # Specifically handle zero without adjusting to tiny (in case of any errors in eval)
+                    return 0
+                elif result == float('inf'):
+                    return np.finfo(np.float32).max
+                elif result == -float('inf'):
+                    return np.finfo(np.float32).min
+                elif abs(result) < np.finfo(np.float32).tiny:
+                    return np.finfo(np.float32).tiny
+                elif abs(result) > np.finfo(np.float32).max:
+                    return np.finfo(np.float32).max if result > 0 else np.finfo(np.float32).min
+                else:
+                    return result
+            else:
+                return result
+        elif self.event_attr_type == EVENT_ATTR_TYPE.DTREE:
+            result = evaluate_dtree(self.value, all_attributes)
+            if result is not None:
+                return result
+            return 0
+        else:
+            return self.value.generate_sample(1)[0]
+
+    def get_next_markov_state(self, current_value):
+        transitions = self.value["transitions"]
+        if current_value in transitions:
+            current_transitions = transitions[current_value]
+            options, probabilities = zip(*current_transitions.items())
+            return choices(options, probabilities)[0]
+        return current_value
+
+    def validate(self):
+        epsilon = 1e-6
+
+        if self.event_attr_type == EVENT_ATTR_TYPE.DISCRETE:
+            if self.value["type"] == "discrete":
+                actual_sum_probabilities = sum(self.value["probabilities"])
+
+                if not (1 - epsilon <= actual_sum_probabilities <= 1 + epsilon):
+                    raise InvalidEventAttributeException(
+                        f"Event attribute {self.name}: probabilities' sum should be equal to 1")
+            elif self.value["type"] == "markov":
+                for state, transitions in self.value["transitions"].items():
+                    actual_sum_probabilities = sum(transitions.values())
+                    if not (1 - epsilon <= actual_sum_probabilities <= 1 + epsilon):
+                        raise InvalidEventAttributeException(
+                            f"Event attribute {self.name}, state {state}: "
+                            f"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.5/prosimos/gateway_condition_choice.py

@@ -0,0 +1,15 @@
+class GatewayConditionChoice:
+    def __init__(self, candidates_list, rules_list, default_path=None):
+        self.candidates_list = candidates_list
+        self.rules_list = rules_list
+        self.default_path = default_path
+
+    def set_default(self, default_path):
+        self.default_path = default_path
+
+    def get_outgoing_flow(self, attributes):
+        return [candidate for candidate, rule in zip(self.candidates_list, self.rules_list)
+                if rule.is_true(attributes)]
+
+    def get_default_path(self):
+        return self.default_path

{prosimos-2.0.4 → prosimos-2.0.5}/prosimos/outgoing_flow_selector.py

@@ -1,4 +1,6 @@
 import copy
+import pprint
+
 from prosimos.control_flow_manager import BPMN
 from prosimos.probability_distributions import Choice
 from prosimos.gateway_condition_choice import GatewayConditionChoice
@@ -19,30 +21,39 @@ class OutgoingFlowSelector:
 
     @staticmethod
     def _handle_exclusive_gateway(e_info, element_probability, all_attributes, gateway_conditions):
-        curr_gateway_conditions = gateway_conditions[e_info.id]
-        candidates_list = curr_gateway_conditions.candidates_list
+        curr_gateway_conditions = gateway_conditions.get(e_info.id, None)
 
         # No conditions (use probabilities)
-        if not candidates_list:
+        if not curr_gateway_conditions or not curr_gateway_conditions.candidates_list:
             return OutgoingFlowSelector._use_probabilities(e_info, element_probability)
-        
-        condition_choice = GatewayConditionChoice(candidates_list, curr_gateway_conditions.rules_list)
-        passed_arcs_ids = condition_choice.get_outgoing_flow(all_attributes)
+
+        candidates_list = curr_gateway_conditions.candidates_list
+        passed_arcs_ids = []
+
+        # Evaluate conditions
+        for candidate in candidates_list:
+            condition = curr_gateway_conditions.rules_list[candidates_list.index(candidate)]
+            if not condition or condition.is_true(all_attributes):
+                passed_arcs_ids.append(candidate)
+
+        # All conditions evaluated to false
+        if not passed_arcs_ids:
+            default_path = curr_gateway_conditions.get_default_path()
+            if default_path:
+                warning_logger.add_warning(f"[XOR] {e_info.id} all conditions evaluated to false. Using default path {default_path}.")
+                return [(default_path, None)]
+            else:
+                warning_logger.add_warning(f"[XOR] {e_info.id} all conditions evaluated to false and no default path. Using probabilities.")
+                return OutgoingFlowSelector._use_probabilities(e_info, element_probability)
 
         # One true condition
         if len(passed_arcs_ids) == 1:
             return [(passed_arcs_ids[0], None)]
 
-        # All true or all false
-        if len(passed_arcs_ids) in [0, len(candidates_list)]:
-            warning_logger.add_warning(f"{e_info.id} all XOR gateway conditions evaluated to the same result ")
-            return OutgoingFlowSelector._use_probabilities(e_info, element_probability)
-
         # More than 1 true (use scaled probabilities)
         curr_candidates = element_probability[e_info.id].candidates_list
         curr_probabilities = element_probability[e_info.id].probability_list
-        passed_arcs_probs = OutgoingFlowSelector._get_probabilities(passed_arcs_ids, curr_candidates,
-                                                                    curr_probabilities)
+        passed_arcs_probs = OutgoingFlowSelector._get_probabilities(passed_arcs_ids, curr_candidates, curr_probabilities)
 
         scaled_probabilities = OutgoingFlowSelector._scale_to_one(passed_arcs_probs)
         choice = Choice(passed_arcs_ids, scaled_probabilities)
@@ -50,25 +61,46 @@ class OutgoingFlowSelector:
         warning_logger.add_warning(f"{e_info.id} more than 1 XOR gateway conditions evaluated to positive result. Scaled probabilities were used.")
         return [(choice.get_outgoing_flow(), None)]
 
-
     @staticmethod
     def _handle_inclusive_gateway(e_info, element_probability, all_attributes, gateway_conditions):
-        curr_gateway_conditions = gateway_conditions[e_info.id]
-        candidates_list = curr_gateway_conditions.candidates_list
+        curr_gateway_conditions = gateway_conditions.get(e_info.id, None)
 
         # No conditions (use probabilities)
-        if not candidates_list:
+        if not curr_gateway_conditions or not curr_gateway_conditions.candidates_list:
             return element_probability[e_info.id].get_multiple_flows()
 
-        condition_choice = GatewayConditionChoice(candidates_list, curr_gateway_conditions.rules_list)
-        passed_arcs_ids = condition_choice.get_outgoing_flow(all_attributes)
-
-        # All false (use probabilities)
+        candidates_list = curr_gateway_conditions.candidates_list
+        passed_arcs_ids = []
+        evaluated_arcs_ids = []
+
+        # Evaluate conditions
+        for candidate in candidates_list:
+            condition = curr_gateway_conditions.rules_list[candidates_list.index(candidate)]
+            if condition:
+                evaluated_arcs_ids.append(candidate)
+                if condition.is_true(all_attributes):
+                    passed_arcs_ids.append(candidate)
+
+        # All conditions evaluated to false
         if not passed_arcs_ids:
-            warning_logger.add_warning(f"{e_info.id} all OR gateway conditions evaluated to negative result. Probabilities were used.")
-            return element_probability[e_info.id].get_multiple_flows()
-        else:
-            return [(flow, None) for flow in passed_arcs_ids]
+            default_path = curr_gateway_conditions.get_default_path()
+            if default_path:
+                warning_logger.add_warning(f"[OR] {e_info.id} all conditions evaluated to false. Using default path {default_path}.")
+                return [(default_path, None)]
+            else:
+                warning_logger.add_warning(f"[OR] {e_info.id} all conditions evaluated to false and no default path. Using probabilities.")
+                return element_probability[e_info.id].get_multiple_flows()
+
+        # Execute true conditions
+        result_flows = [(flow, None) for flow in passed_arcs_ids]
+
+        # Use probabilities for the rest of the flows where conditions are missing
+        missing_conditions_flows = [flow for flow in candidates_list if flow not in evaluated_arcs_ids]
+        if missing_conditions_flows:
+            probabilities = element_probability[e_info.id].get_multiple_flows()
+            result_flows.extend([(flow, None) for flow in probabilities if flow in missing_conditions_flows])
+
+        return result_flows
         
     @staticmethod
     def _handle_parallel_events(e_info):

{prosimos-2.0.4 → prosimos-2.0.5}/prosimos/simulation_engine.py

@@ -35,7 +35,6 @@ class SimResource:
 
 class SimBPMEnv:
     def __init__(self, sim_setup: SimDiffSetup, stat_fwriter, log_fwriter):
-        self.produced_event_attributes = {}
         self.sim_setup = sim_setup
         self.sim_resources = dict()
         self.stat_fwriter = stat_fwriter
@@ -61,7 +60,7 @@ class SimBPMEnv:
         )
 
         all_attributes = {
-            "global": self.sim_setup.all_attributes.global_attributes.get_values_calculated(),
+            "global": self.sim_setup.all_attributes.global_attribute_initial_values,
             **self.case_prioritisation.all_case_attributes
         }
 
@@ -259,7 +258,6 @@ class SimBPMEnv:
 
         new_global_attr_values = self._extract_attributes_for_event(current_event.task_id, global_event_attributes, all_attribute_values)
         new_event_attr_values = self._extract_attributes_for_event(current_event.task_id, event_attributes, all_attribute_values)
-        self.produced_event_attributes = set(new_event_attr_values.keys())
 
         self.sim_setup.bpmn_graph.all_attributes["global"].update(new_global_attr_values)
         self.sim_setup.bpmn_graph.all_attributes[current_event.p_case].update(new_event_attr_values)
@@ -298,11 +296,7 @@ class SimBPMEnv:
         )
 
         all_attrs = self.sim_setup.bpmn_graph.get_all_attributes(full_event.p_case)
-        values = [all_attrs.get(col) if
-                  (col in self.produced_event_attributes or col not in self.sim_setup.all_attributes.event_attribute_names)
-                else None for col in self.additional_columns]
-
-        self.produced_event_attributes.clear()
+        values = ["" if all_attrs.get(col) is None else all_attrs.get(col) for col in self.additional_columns]
 
         return [*row_basic_info, *values]
 

{prosimos-2.0.4 → prosimos-2.0.5}/prosimos/simulation_properties_parser.py

@@ -1,5 +1,6 @@
 import datetime
 import json
+import pprint
 import xml.etree.ElementTree as ET
 
 from dateutil import parser
@@ -288,17 +289,21 @@ def parse_gateway_conditions(gateway_json, branch_rules):
         missing_conditions = list()
 
         for prob_info in g_info["probabilities"]:
+            path_id = prob_info["path_id"]
+
             if "condition_id" in prob_info:
-                out_arc.append(prob_info["path_id"])
+                out_arc.append(path_id)
                 curr_branch_rules = branch_rules.get_branch_condition_by_id(prob_info["condition_id"])
                 gateway_rules.append(curr_branch_rules)
             else:
-                missing_conditions.append(prob_info["path_id"])
+                missing_conditions.append(path_id)
 
         if len(prob_info) > 0:
             gateway_conditions[g_id] = GatewayConditionChoice(out_arc, gateway_rules)
 
-        if len(missing_conditions) > 0 and len(gateway_rules) != len(g_info["probabilities"]):
+        if len(missing_conditions) > 0 and \
+                len(missing_conditions) != g_info["probabilities"] and \
+                1 < len(g_info["probabilities"]) != len(gateway_rules):
             warning_logger.add_warning(f"Gateway {g_id} is using conditions, but some are missing. Flows without conditions: {', '.join(missing_conditions)}")
 
     return gateway_conditions
@@ -676,3 +681,21 @@ def parse_datetime(time, has_date):
             except ValueError:
                 pass
     raise ValueError
+
+
+def add_default_flows(gateway_conditions, bpmn_path):
+    tree = ET.parse(bpmn_path)
+    root = tree.getroot()
+
+    namespaces = {'bpmn': 'http://www.omg.org/spec/BPMN/20100524/MODEL'}
+
+    gateway_types = ['exclusiveGateway', 'inclusiveGateway']
+    for gateway_type in gateway_types:
+        for gateway in root.findall(f'.//bpmn:{gateway_type}', namespaces):
+            gateway_id = gateway.get('id')
+            default_flow = gateway.get('default')
+
+            if gateway_id in gateway_conditions and default_flow:
+                gateway_conditions[gateway_id].set_default(default_flow)
+
+    return gateway_conditions

{prosimos-2.0.4 → prosimos-2.0.5}/prosimos/simulation_setup.py

@@ -11,7 +11,7 @@ from prosimos.batch_processing import BatchConfigPerTask
 from prosimos.control_flow_manager import BPMN, ElementInfo, ProcessState
 from prosimos.exceptions import InvalidSimScenarioException
 from prosimos.histogram_distribution import HistogramDistribution
-from prosimos.simulation_properties_parser import parse_json_sim_parameters, parse_simulation_model
+from prosimos.simulation_properties_parser import parse_json_sim_parameters, parse_simulation_model, add_default_flows
 
 
 class SimDiffSetup:
@@ -34,7 +34,7 @@ class SimDiffSetup:
             self.gateway_execution_limit,
             self.model_type
         ) = parse_json_sim_parameters(json_path)
-
+        self.gateway_conditions = add_default_flows(self.gateway_conditions, bpmn_path)
         self.case_attributes = self.all_attributes.case_attributes
 
         self.bpmn_graph = parse_simulation_model(bpmn_path)

{prosimos-2.0.4 → prosimos-2.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "prosimos"
-version = "2.0.4"
+version = "2.0.5"
 description = ""
 authors = [
     "Iryna Halenok <iryna.halenok@ut.ee>",

prosimos-2.0.4/prosimos/event_attributes.py

@@ -1,124 +0,0 @@
-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/gateway_condition_choice.py

@@ -1,10 +0,0 @@
-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)]
-
-