can choose the best path for the vizi

modules/toWizard.py

@@ -2,6 +2,37 @@ import xml.etree.ElementTree as ET
 from modules.utils import class_dict
 from xml.dom import minidom
 from modules.utils import error
+from transformers import pipeline
+
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
+import logging
+
+# Suppress specific warnings from transformers
+logging.getLogger("transformers.modeling_utils").setLevel(logging.ERROR)
+
+# Function to initialize the model and tokenizer
+def initialize_model():
+    tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment-latest")
+    model = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment-latest")
+    return tokenizer, model
+
+# Function to perform sentiment analysis and return the highest scoring emotion and its score between positive and negative
+def analyze_sentiment(sentence, tokenizer, model):
+    inputs = tokenizer(sentence, return_tensors="pt")
+    outputs = model(**inputs)
+    probs = torch.nn.functional.softmax(outputs.logits, dim=-1).squeeze().tolist()
+    labels = ["negative", "neutral", "positive"]
+    results = dict(zip(labels, probs))
+    
+    # Filter out the neutral score and get the highest score between positive and negative
+    relevant_results = {k: results[k] for k in ["positive", "negative"]}
+    highest_emotion = max(relevant_results, key=relevant_results.get)
+    highest_score = relevant_results[highest_emotion]
+    return highest_emotion, highest_score
+
+# Initialize model and tokenizer
+tokenizer, model = initialize_model()
 
 def rescale(scale, boxes):
     for i in range(len(boxes)):
@@ -56,8 +87,8 @@ def connect(data, text_mapping, i):
     target_idx = data['links'][i][1]  
     # Check if the target index is valid
     if target_idx==None or target_idx >= len(data['links']):
-        error('There is an error with the Vizi file, care when you download it.')
-        return None, None
+        error('There may be an error with the Vizi file, care when you download it.')
+        return None, None, None
     
     current_id = data['BPMN_id'][i]
     current_text = text_mapping[current_id]
@@ -111,7 +142,44 @@ def find_merge(bpmn_id, links):
     
     return merge_elements
 
+def find_positive_end(bpmn_ids, links, text_mapping):
+    emotion_data = []
+    for idx, bpmn_id in enumerate(bpmn_ids):
+        if idx >= len(links):
+            continue
+        if check_end(links[idx]) and (bpmn_id.split('_')[0] in ['event', 'message']):
+            # Perform sentiment analysis and get the highest scoring emotion and its score between positive and negative
+            highest_emotion, highest_score = analyze_sentiment(text_mapping[bpmn_id], tokenizer, model)
+            emotion_data.append((bpmn_id, highest_emotion, highest_score))
+
+    # Sort by emotion label with 'positive' first and 'negative' second,
+    # then by score in descending order
+    sorted_emotions = sorted(emotion_data, key=lambda x: (x[1] != 'positive', -x[2]))
+
+    return sorted_emotions[0][0] if len(sorted_emotions) > 0 else None
+
+def find_best_direction(texts_list):
+    emotion_data = []
+    for text in texts_list:
+        highest_emotion, highest_score = analyze_sentiment(text, tokenizer, model)
+        emotion_data.append((text, highest_emotion, highest_score))
+
+    # Sort by emotion label with 'positive' first and 'negative' second,
+    # then by score in descending order
+    sorted_emotions = sorted(emotion_data, key=lambda x: (x[1] != 'positive', -x[2]))
+
+    return sorted_emotions[0][0] if len(sorted_emotions) > 0 else None
+
+
+
 def create_wizard_file(data, text_mapping):
+
+    #add a name into the text_mapping when there is no name
+    for idx, key in enumerate(text_mapping.keys()):
+        if text_mapping[key] == '':
+            text_mapping[key] = f'unnamed_{key}'
+
+
     root = ET.Element('methodAndStyleWizard')
     
     modelName = ET.SubElement(root, 'modelName')
@@ -128,32 +196,44 @@ def create_wizard_file(data, text_mapping):
     
     processDescription = ET.SubElement(root, 'processDescription')
 
+    first = False
     for idx, Bpmn_id in enumerate(data['BPMN_id']):
         # Start Event
         element_type = Bpmn_id.split('_')[0]
-        if element_type == 'messageEvent':
+        if element_type == 'message':
             eventType = 'Message'
         elif element_type == 'event':
             eventType = 'None'
         if idx >= len(data['links']):
             continue
-        if check_start(data['links'][idx]) and (element_type=='event' or element_type=='messageEvent'):
-            startEvent = ET.SubElement(root, 'startEvent', attrib={'name': text_mapping[Bpmn_id], 'eventType': eventType, 'isRegular': 'False'}) 
+        if check_start(data['links'][idx]) and (element_type=='event' or element_type=='message'):
+            if text_mapping[Bpmn_id] == '':
+                text_mapping[Bpmn_id] = 'start'
+            startEvent = ET.SubElement(root, 'startEvent', attrib={'name': text_mapping[Bpmn_id], 'eventType': eventType, 'isRegular': 'True'})
     
     requestMessage = ET.SubElement(root, 'requestMessage')
     requester = ET.SubElement(root, 'requester')
     
     endEvents = ET.SubElement(root, 'endStates')
+
+    positive_end = find_positive_end(data['BPMN_id'], data['links'], text_mapping)
+    if positive_end is not None:
+        print("Best end is: ",text_mapping[positive_end])
+    
     
     # Add end states event to the collaboration element
     for idx, Bpmn_id in enumerate(data['BPMN_id']):
         # End States
         if idx >= len(data['links']):
             continue
-        if check_end(data['links'][idx]) and (Bpmn_id.split('_')[0] == 'event' or Bpmn_id.split('_')[0] == 'messageEvent'):
+        if check_end(data['links'][idx]) and (Bpmn_id.split('_')[0] == 'event' or Bpmn_id.split('_')[0] == 'message'): 
             if text_mapping[Bpmn_id] == '':
                 text_mapping[Bpmn_id] = '(unnamed)'
-            ET.SubElement(endEvents, 'endState', attrib={'name': text_mapping[Bpmn_id], 'eventType': 'None', 'isRegular': 'False'})
+
+            if Bpmn_id == positive_end:
+                ET.SubElement(endEvents, 'endState', attrib={'name': text_mapping[Bpmn_id], 'eventType': 'None', 'isRegular': 'True'})
+            else:
+                ET.SubElement(endEvents, 'endState', attrib={'name': text_mapping[Bpmn_id], 'eventType': 'None', 'isRegular': 'False'})
     
     
     # Add activities to the collaboration element
@@ -166,9 +246,15 @@ def create_wizard_file(data, text_mapping):
             if next_text is not None and len(next_text) == 1:
                 ET.SubElement(endStates, 'endState', attrib={'name': next_text[0], 'isRegular': 'True'})
             elif next_text is not None and len(next_text) >= 2 and next_id.split('_')[0] == 'exclusiveGateway':
-                ET.SubElement(endStates, 'endState', attrib={'name': next_text[0], 'isRegular': 'True'})
-                for i in range(1, len(next_text)):
-                    ET.SubElement(endStates, 'endState', attrib={'name': next_text[i], 'isRegular': 'False'})
+                best_direction = find_best_direction(next_text)
+                if best_direction is not None:
+                    print("Best direction is: ", best_direction)
+                for i in range(len(next_text)):
+                    if next_text[i] == best_direction:
+                        ET.SubElement(endStates, 'endState', attrib={'name': next_text[i], 'isRegular': 'True'})
+                    else:
+                        ET.SubElement(endStates, 'endState', attrib={'name': next_text[i], 'isRegular': 'False'})
+
             ET.SubElement(activity, 'subActivities')
             ET.SubElement(activity, 'subActivityFlows')
             ET.SubElement(activity, 'messageFlows')
@@ -176,15 +262,15 @@ def create_wizard_file(data, text_mapping):
     merge_object = find_merge(data['BPMN_id'], data['links'])
     
     activityFlows = ET.SubElement(root, 'activityFlows')
-    i=0
     for i, link in enumerate(data['links']):
         # create flow with start event
-        if link[0] is None and link[1] is not None and (data['BPMN_id'][i].split('_')[0] == 'event' or data['BPMN_id'][i].split('_')[0] == 'messageEvent'):
+        if link[0] is None and link[1] is not None and (data['BPMN_id'][i].split('_')[0] == 'event' or data['BPMN_id'][i].split('_')[0] == 'message'):
             current_text, next_text, _ = connect(data, text_mapping, i)
             if current_text is None or next_text is None:
                 continue
             ET.SubElement(activityFlows, 'activityFlow', attrib={'startEvent': current_text, 'endState': '---', 'target': next_text[0], 'isMerging': 'False', 'isPredefined': 'True'})
-            i+=1
+            continue
+
         # create flow with tasks
         if link[0] is not None and link[1] is not None and data['BPMN_id'][i].split('_')[0] == 'task':
             current_text, next_text, next_id = connect(data, text_mapping, i)
@@ -197,8 +283,8 @@ def create_wizard_file(data, text_mapping):
                 merge = 'False'
   
             if len(next_text) == 2 and next_id.split('_')[0] == 'exclusiveGateway':
-                ET.SubElement(activityFlows, 'activityFlow', attrib={'activity': current_text, 'endState': next_text[0]+'?', 'target': next_text[0], 'isMerging': 'False', 'isPredefined': 'True'})
-                ET.SubElement(activityFlows, 'activityFlow', attrib={'activity': current_text, 'endState': '---', 'target': next_text[1], 'isMerging': 'False', 'isPredefined': 'True'})
+                ET.SubElement(activityFlows, 'activityFlow', attrib={'activity': current_text, 'endState': next_text[0], 'target': next_text[0], 'isMerging': 'False', 'isPredefined': 'True'})
+                ET.SubElement(activityFlows, 'activityFlow', attrib={'activity': current_text, 'endState': next_text[1], 'target': next_text[1], 'isMerging': 'False', 'isPredefined': 'True'})
             elif len(next_text) > 1 and next_id.split('_')[0] == 'parallelGateway':
                 for next in next_text:
                     ET.SubElement(activityFlows, 'activityFlow', attrib={'activity': current_text, 'endState': '---', 'target': next, 'isMerging': merge, 'isPredefined': 'True'})
@@ -206,8 +292,6 @@ def create_wizard_file(data, text_mapping):
                 ET.SubElement(activityFlows, 'activityFlow', attrib={'activity': current_text, 'endState': '---', 'target': next_text[0], 'isMerging': merge, 'isPredefined': 'True'})
             else:
                 ET.SubElement(activityFlows, 'activityFlow', attrib={'activity': current_text, 'endState': '---', 'target': next_text, 'isMerging': merge, 'isPredefined': 'True'})
-
-            i+=1
     
     ET.SubElement(root, 'participants')
     

modules/toXML.py

@@ -181,7 +181,7 @@ def create_XML(full_pred, text_mapping, size_scale, scale):
 
     #if there is no pool or lane, create a pool with all elements
     if len(full_pred['pool_dict']) == 0 or (len(full_pred['pool_dict']) == 1 and len(next(iter(full_pred['pool_dict'].values()))) == len(full_pred['labels'])):
-        full_pred, text_mapping = create_big_pool(full_pred, text_mapping)
+        full_pred, text_mapping = create_big_pool(full_pred, text_mapping, size_elements)
     
     #modify the boxes positions
     old_boxes = copy.deepcopy(full_pred)
@@ -250,13 +250,13 @@ def create_XML(full_pred, text_mapping, size_scale, scale):
     return pretty_xml_as_string
 
 # Function that creates a single pool with all elements
-def create_big_pool(full_pred, text_mapping, marge=50):
+def create_big_pool(full_pred, text_mapping, size_elements, marge=50):
     # If no pools or lanes are detected, create a single pool with all elements
     new_pool_index = 'pool_1'
     size_elements = get_size_elements(st.session_state.size_scale)
     elements_pool = list(range(len(full_pred['boxes'])))
     min_x, min_y, max_x, max_y = calculate_pool_bounds(full_pred['boxes'],full_pred['labels'], elements_pool, size_elements)
-    box = [min_x-marge, min_y-marge, max_x+marge, max_y+marge]
+    box = [min_x - marge, min_y - marge//2, max_x + marge, max_y + marge//2]
     full_pred['boxes'] = np.append(full_pred['boxes'], [box], axis=0)
     full_pred['pool_dict'][new_pool_index] = elements_pool
     full_pred['BPMN_id'].append('pool_1')
@@ -557,26 +557,28 @@ def create_bpmn_object(process, bpmnplane, text_mapping, definitions, size, data
             ET.SubElement(element, 'bpmn:timerEventDefinition', id=f'TimerEventDefinition_{i+1}')
             add_diagram_elements(bpmnplane, element_id, x, y, size['timerEvent'][0], size['timerEvent'][1])
 
-
-def calculate_pool_bounds(boxes, labels, keep_elements, size):
+def calculate_pool_bounds(boxes, labels, keep_elements, size=None, class_dict=None):
     min_x, min_y = float('inf'), float('inf')
     max_x, max_y = float('-inf'), float('-inf')
 
     for i in keep_elements:
         if i >= len(labels):
-            print("Problem with the index")
+            print(f"Problem with the index: {i}")
             continue
         
         element = labels[i]
         if element in {None, 7, 13, 14, 15}: 
             continue
         
-
-        if size == None:
+        if size is None or class_dict is None:
             element_width = boxes[i][2] - boxes[i][0]
             element_height = boxes[i][3] - boxes[i][1]
         else:
-            element_width, element_height = size[class_dict[labels[i]]]
+            if labels[i] in class_dict:
+                element_width, element_height = size[class_dict[labels[i]]]
+            else:
+                print(f"Class label {labels[i]} not found in class_dict.")
+                continue
         
         x, y = boxes[i][:2]
         min_x = min(min_x, x)