Spaces:

qtoino
/

form_matcher

Runtime error

App Files Files Community

Francisco Santos commited on Aug 20, 2023

Commit

b55b7f0

1 Parent(s): aafc193

input handling

Browse files

Files changed (3) hide show

app.py +249 -31
app_files.py +173 -0
output.html +31 -0

app.py CHANGED Viewed

@@ -5,16 +5,137 @@ import time
 import os
 from transformers import AutoTokenizer, pipeline
 models = {
     "model_n1": "sileod/deberta-v3-base-tasksource-nli",
     # "model_n2": "roberta-large-mnli",
     # "model_n3": "facebook/bart-large-mnli",
     # "model_n4": "cross-encoder/nli-deberta-v3-xsmall"
 }
-def open_html(file):
     with open(file.name, "r") as f:
         content = f.read()
-    return content
 def find_form_fields(html_content):
@@ -66,7 +187,7 @@ def classify_lines(text, candidate_labels, model_name):
     execution_time = end_time - start_time  # Calculate execution time
     return classified_lines, execution_time
-def classify_lines_json(text, json_content, candidate_labels, model_name, output_file_path):
     start_time = time.time()  # Start measuring time
     classifier = pipeline('zero-shot-classification', model=model_name)
@@ -79,17 +200,114 @@ def classify_lines_json(text, json_content, candidate_labels, model_name, output
     # Open the output.html file in write mode
     output_content = []
-    with open(output_file_path, 'w') as output_file:
-        for line in lines:
-            if line.strip() and (line.strip().startswith("<input") or line.strip().startswith("<select") )and 'hidden' not in line.lower():
-                # Skip empty lines, classify lines starting with "<input", and exclude lines with 'hidden'
-                results = classifier(line, candidate_labels=candidate_labels)
-                top_classifications = results['labels'][:2]  # Get the top two classifications
-                top_scores = results['scores'][:2]  # Get the top two scores
-                line = line + f"<!-- Input: {json_content[top_classifications[0]]} with this certainty: {top_scores[0]} -->"
-            output_file.write(line + '\n')
-            output_content.append(line + '\n')
     end_time = time.time()  # Stop measuring time
@@ -129,38 +347,38 @@ def retrieve_fields_from_file(file_path):
 def process_files(html_file, json_file):
-    # This function will process the files.
-    # Replace this with your own logic.
-    output_file_path = "./output.html"
-    # Open and read the files
-    html_content = open_html(html_file)
-    #print(html_content)
-    html_inputs = find_form_fields(html_content)
-    json_content = retrieve_fields_from_file(json_file)
     #Classificar os inputs do json para ver em que tipo de input ["text", "radio", "checkbox", "button", "date"]
     # Classify lines and measure execution time
     for model_name in models.values():
         tokenizer = AutoTokenizer.from_pretrained(model_name)
-        html_classified_lines, html_execution_time = classify_lines(html_inputs, ["text", "radio", "checkbox", "button", "date"], model_name)
-        json_classified_lines, json_execution_time = classify_lines_json(html_content, json_content, list(json_content.keys()), model_name, output_file_path)
         # print(str(html_execution_time) + " - " + str(html_classified_lines))
         # print(str(json_execution_time) + " - " + str(json_classified_lines))
-        #FILL HERE
         #print(type(json_classified_lines))
-    # Assuming your function returns the processed HTML
-    #json_classified_lines
     #return '\n'.join(map(str, html_classified_lines))
     return '\n'.join(map(str, json_classified_lines))
 iface = gr.Interface(fn=process_files,
-                     inputs=[gr.inputs.File(label="Upload HTML File"), gr.inputs.File(label="Upload JSON File")],
-                     outputs="text")
 iface.launch()

 import os
 from transformers import AutoTokenizer, pipeline
+example1 = '''<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Contact Form</title>
+</head>
+<body>
+    <h1>Contact Form</h1>
+    <form action="/submit-form" method="POST">
+    <label for="name">Name:</label>
+    <input type="text" id="name" name="name" required>
+    <br>
+    <label for="email">Email:</label>
+    <input type="email" id="email" name="email" required>
+    <br>
+    <label for="location">Location:</label>
+    <input type="text" id="location" name="location" required>
+    <br>
+    <label for="github">GitHub:</label>
+    <input type="url" id="github" name="github" required>
+    <br>
+    <label for="linkedin">LinkedIn:</label>
+    <input type="url" id="linkedin" name="linkedin" required>
+    <br>
+    <label for="phone">Phone:</label>
+    <input type="tel" id="phone" name="phone" required>
+    <br><br>
+    <input type="submit" value="Submit">
+    </form>
+</body>
+</html>
+'''
+solution1 = '''{
+    "name": "Ana Guida",
+    "email": "example@gmail.com",
+    "location": "Amsterdam, Netherlands",
+    "github": "https://github.com/34kmddfn",
+    "linkedin": "https://www.linkedin.com/in/ana-rguida/",
+    "phone": "+351 928 169 341"
+}'''
+example2 = '''<!DOCTYPE html>
+<html>
+<head>
+  <title>Resume Form</title>
+</head>
+  <body>
+    <form action="/" method="POST">
+      <label>What kind of pet do you have?</label>
+      <br>
+      <input type="radio" id="dog" name="pet" value="dog">
+      <label for="dog">Dog</label>
+      <br>
+      <input type="radio" id="cat" name="pet" value="cat">
+      <label for="cat">Cat</label>
+      <br>
+      <input type="radio" id="other" name="pet" value="other">
+      <label for="other">Other</label>
+      <br><br>
+      <label>What color is your pet?</label>
+      <br>
+      <input type="checkbox" id="black" name="color" value="black">
+      <label for="black">Black</label>
+      <br>
+      <input type="checkbox" id="white" name="color" value="white">
+      <label for="white">White</label>
+      <br>
+      <input type="checkbox" id="brown" name="color" value="brown">
+      <label for="brown">Brown</label>
+      <br><br>
+      <input type="submit" value="Submit">
+    </form>
+  </body>
+</html>
+'''
+solution2 = '''{
+  "pet": "dog",
+  "color": [
+    "black",
+    "brown"
+  ]
+}'''
+example3 = '''<!DOCTYPE html>
+<html>
+<head>
+  <title>Create account Form</title>
+</head>
+  <body>
+    <form action="/" method="POST">
+      <label for="name">Name:</label>
+      <input type="text" id="name" name="name" required>
+      <br>
+      <label for="country">Select your country:</label>
+      <br>
+      <select id="country" name="country">
+        <option value="usa">USA</option>
+        <option value="uk">UK</option>
+        <option value="germany">Germany</option>
+        <option value="japan">Japan</option>
+      </select>
+      <br><br>
+      <label for="birthday">Select your birthday:</label>
+      <br>
+      <input type="date" id="birthday" name="birthday">
+      <br><br>
+      <input type="submit" value="Submit">
+    </form>
+  </body>
+</html>
+'''
+solution3 = '''{
+  "name": "Mike",
+  "country": "Germany",
+  "birthday": "1990-05-07"
+}'''
 models = {
     "model_n1": "sileod/deberta-v3-base-tasksource-nli",
     # "model_n2": "roberta-large-mnli",
     # "model_n3": "facebook/bart-large-mnli",
     # "model_n4": "cross-encoder/nli-deberta-v3-xsmall"
 }
+def find_form_fields_from_file(file):
     with open(file.name, "r") as f:
         content = f.read()
+    return find_form_fields(content)
 def find_form_fields(html_content):
     execution_time = end_time - start_time  # Calculate execution time
     return classified_lines, execution_time
+def classify_lines_json(text, json_content, candidate_labels, model_name):
     start_time = time.time()  # Start measuring time
     classifier = pipeline('zero-shot-classification', model=model_name)
     # Open the output.html file in write mode
     output_content = []
+    last_input = "None"
+    max_index = -1
+    for i, line in enumerate(lines):
+        if line.strip() and (line.strip().startswith("<input") or line.strip().startswith("<select") or line.strip().startswith("<option") ) and 'hidden' not in line.lower():
+            # Skip empty lines, classify lines starting with "<input", and exclude lines with 'hidden'
+            results = classifier(line, candidate_labels=["text", "radio", "checkbox", "button", "date", "select"])
+            if results['labels'][0] == "text" or results['labels'][0] == "date":
+                # print("text")
+                last_input = "text/date"
+                input_results = classifier(line, candidate_labels=candidate_labels)
+                top_classifications = input_results['labels'][:2]  # Get the top two classifications
+                top_scores = input_results['scores'][:2]  # Get the top two scores
+                line = line + f"<!-- Input: <{json_content[top_classifications[0]]}> - certainty: {format(top_scores[0], '.2f')} -->"
+            elif results['labels'][0] == "button":
+                # print("button")
+                last_input = "button"
+                line = line + f"<!-- Input: <{results['labels'][0]}> - certainty: {format(results['scores'][0], '.2f')} -->"
+            elif results['labels'][0] == "radio":
+                # print("radio")
+                if(last_input == "radio"):
+                    radio_options.append(line)
+                    radio_options_i.append(i)
+                else:
+                    radio_options = [line]
+                    radio_options_i = [i]
+                    radio_results_list = []
+                last_input = "radio"
+                input_results = classifier(line, candidate_labels=candidate_labels)
+                top_classifications = input_results['labels'][:2]  # Get the top two classifications
+                top_scores = input_results['scores'][:2]  # Get the top two scores
+                radio_results = classifier(line, candidate_labels=[json_content[top_classifications[0]]])
+                radio_results_list.append(radio_results)
+                # Get the scores from the radio_results_list
+                scores = [result['scores'][0] for result in radio_results_list]
+                previous_max_index = max_index
+                # Find the index of the maximum score
+                max_index = scores.index(max(scores))
+                if previous_max_index != max_index:
+                    line_selected = radio_options[previous_max_index]
+                    real_index = radio_options_i[previous_max_index]
+                    if real_index < len(output_content):
+                        output_content[real_index] = line_selected
+                    line_selected = radio_options[max_index]
+                    line_selected = line_selected + f"<!-- Input: <{results['labels'][0]}> - certainty: {format(results['scores'][0], '.2f')}. LINE TO SELECT: <{radio_results['labels'][0]}> - certainty: {format(max(scores), '.2f')} -->"
+                    real_index = radio_options_i[max_index]
+                    if real_index < len(output_content):
+                        output_content[real_index] = line_selected
+                    else:
+                        line = line_selected
+            elif results['labels'][0] == "checkbox":
+                # print("checkbox")
+                last_input = "checkbox"
+                input_results = classifier(line, candidate_labels=candidate_labels)
+                top_classifications = input_results['labels'][:2]  # Get the top two classifications
+                top_scores = input_results['scores'][:2]  # Get the top two scores
+                checkbox_results = classifier(line, candidate_labels=[json_content[top_classifications[0]]])
+                if checkbox_results['scores'][0] > 0.8:
+                    line = line + f"<!-- Input: <{results['labels'][0]}> - certainty: {format(results['scores'][0], '.2f')}. LINE TO SELECT: <{checkbox_results['labels'][0]}> - certainty: {format(checkbox_results['scores'][0], '.2f')} -->"
+            else: #elif results['labels'][0] == "select" or results['labels'][0] == "option":
+                # print("select")
+                if(last_input == "select"):
+                    select_options.append(line)
+                    select_options_i.append(i)
+                else:
+                    select_options = [line]
+                    select_options_i = [i]
+                    select_results_list = []
+                last_input = "select"
+                input_results = classifier(line, candidate_labels=candidate_labels)
+                top_classifications = input_results['labels'][:2]  # Get the top two classifications
+                top_scores = input_results['scores'][:2]  # Get the top two scores
+                select_results = classifier(line, candidate_labels=[json_content[top_classifications[0]]])
+                select_results_list.append(select_results)
+                # Get the scores from the select_results_list
+                scores = [result['scores'][0] for result in select_results_list]
+                previous_max_index = max_index
+                # Find the index of the maximum score
+                max_index = scores.index(max(scores))
+                if previous_max_index != max_index:
+                    line_selected = select_options[previous_max_index]
+                    real_index = select_options_i[previous_max_index]
+                    if real_index < len(output_content):
+                        output_content[real_index] = line_selected
+                    line_selected = select_options[max_index]
+                    line_selected = line_selected + f"<!-- Input: <{results['labels'][0]}> - certainty: {format(results['scores'][0], '.2f')}. LINE TO SELECT: <{select_results['labels'][0]}> - certainty: {format(max(scores), '.2f')} -->"
+                    real_index = select_options_i[max_index]
+                    if real_index < len(output_content):
+                        output_content[real_index] = line_selected
+                    else:
+                        line = line_selected
+        output_content.append(line)
     end_time = time.time()  # Stop measuring time
 def process_files(html_file, json_file):
+    #html_content = open_html(html_file)
+    #print(html_file)
+    html_inputs = find_form_fields(html_file)
+    #print(json_file)
+    json_content = retrieve_fields(json.loads(json_file))
     #Classificar os inputs do json para ver em que tipo de input ["text", "radio", "checkbox", "button", "date"]
     # Classify lines and measure execution time
     for model_name in models.values():
         tokenizer = AutoTokenizer.from_pretrained(model_name)
+        #html_classified_lines, html_execution_time = classify_lines(html_inputs, ["text", "radio", "checkbox", "button", "date", "select"], model_name)
+        json_classified_lines, json_execution_time = classify_lines_json(html_file, json_content, list(json_content.keys()), model_name)
         # print(str(html_execution_time) + " - " + str(html_classified_lines))
         # print(str(json_execution_time) + " - " + str(json_classified_lines))
         #print(type(json_classified_lines))
     #return '\n'.join(map(str, html_classified_lines))
     return '\n'.join(map(str, json_classified_lines))
 iface = gr.Interface(fn=process_files,
+                     inputs=[gr.Textbox(lines = 20, max_lines = 1000, label="Upload HTML File"), gr.Textbox(lines = 20, max_lines = 1000, label="Upload JSON File")],
+                     outputs=gr.Textbox(lines = 20, max_lines = 1000, label="Output"),
+                     examples=[
+                        [example1, solution1],
+                        [example2, solution2],
+                        [example3, solution3],
+                    ])
 iface.launch()

app_files.py ADDED Viewed

	@@ -0,0 +1,173 @@

+import gradio as gr
+from bs4 import BeautifulSoup
+import json
+import time
+import os
+from transformers import AutoTokenizer, pipeline
+models = {
+    "model_n1": "sileod/deberta-v3-base-tasksource-nli",
+    # "model_n2": "roberta-large-mnli",
+    # "model_n3": "facebook/bart-large-mnli",
+    # "model_n4": "cross-encoder/nli-deberta-v3-xsmall"
+}
+def open_html(file):
+    with open(file.name, "r") as f:
+        content = f.read()
+    return content
+def find_form_fields(html_content):
+    soup = BeautifulSoup(html_content, 'html.parser')
+    # find all form tags
+    forms = soup.find_all('form')
+    form_fields = []
+    for form in forms:
+        # find all input and select tags within each form
+        input_tags = form.find_all('input')
+        select_tags = form.find_all('select')
+        for tag in input_tags:
+            form_fields.append(str(tag))
+        for tag in select_tags:
+            form_fields.append(str(tag))
+    # Convert the list to a single string for display
+    return form_fields
+def load_json(json_file):
+    with open(json_file, 'r') as f:
+        data = json.load(f)
+    return data
+def classify_lines(text, candidate_labels, model_name):
+    start_time = time.time()  # Start measuring time
+    classifier = pipeline('zero-shot-classification', model=model_name)
+    # Check if the text is already a list or if it needs splitting
+    if isinstance(text, list):
+        lines = text
+    else:
+        lines = text.split('\n')
+    classified_lines = []
+    for line in lines:
+        if line.strip() and (line.strip().startswith("<input") or line.strip().startswith("<select") )and 'hidden' not in line.lower():
+            # Skip empty lines, classify lines starting with "<input", and exclude lines with 'hidden'
+            results = classifier(line, candidate_labels=candidate_labels)
+            top_classifications = results['labels'][:2]  # Get the top two classifications
+            top_scores = results['scores'][:2]  # Get the top two scores
+            classified_lines.append((line, list(zip(top_classifications, top_scores))))
+    end_time = time.time()  # Stop measuring time
+    execution_time = end_time - start_time  # Calculate execution time
+    return classified_lines, execution_time
+def classify_lines_json(text, json_content, candidate_labels, model_name, output_file_path):
+    start_time = time.time()  # Start measuring time
+    classifier = pipeline('zero-shot-classification', model=model_name)
+    # Check if the text is already a list or if it needs splitting
+    if isinstance(text, list):
+        lines = text
+    else:
+        lines = text.split('\n')
+    # Open the output.html file in write mode
+    output_content = []
+    with open(output_file_path, 'w') as output_file:
+        for line in lines:
+            if line.strip() and (line.strip().startswith("<input") or line.strip().startswith("<select") )and 'hidden' not in line.lower():
+                # Skip empty lines, classify lines starting with "<input", and exclude lines with 'hidden'
+                results = classifier(line, candidate_labels=candidate_labels)
+                top_classifications = results['labels'][:2]  # Get the top two classifications
+                top_scores = results['scores'][:2]  # Get the top two scores
+                line = line + f"<!-- Input: {json_content[top_classifications[0]]} with this certainty: {top_scores[0]} -->"
+            output_file.write(line + '\n')
+            output_content.append(line + '\n')
+    end_time = time.time()  # Stop measuring time
+    execution_time = end_time - start_time  # Calculate execution time
+    return output_content, execution_time
+def retrieve_fields(data, path=''):
+    """Recursively retrieve all fields from a given JSON structure and prompt for filling."""
+    fields = {}
+    # If the data is a dictionary
+    if isinstance(data, dict):
+        for key, value in data.items():
+            # Construct the updated path for nested structures
+            new_path = f"{path}.{key}" if path else key
+            fields.update(retrieve_fields(value, new_path))
+    # If the data is a list, iterate over its items
+    elif isinstance(data, list):
+        for index, item in enumerate(data):
+            new_path = f"{path}[{index}]"
+            fields.update(retrieve_fields(item, new_path))
+    # If the data is a simple type (str, int, etc.)
+    else:
+        prompt = f"Please fill in the {path} field." if not data else data
+        fields[path] = prompt
+    return fields
+def retrieve_fields_from_file(file_path):
+    """Load JSON data from a file, then retrieve all fields and prompt for filling."""
+    with open(file_path.name, 'r') as f:
+        data = f.read()
+    return retrieve_fields(json.loads(data))
+def process_files(html_file, json_file):
+    # This function will process the files.
+    # Replace this with your own logic.
+    output_file_path = "./output.html"
+    # Open and read the files
+    html_content = open_html(html_file)
+    #print(html_content)
+    html_inputs = find_form_fields(html_content)
+    json_content = retrieve_fields_from_file(json_file)
+    #Classificar os inputs do json para ver em que tipo de input ["text", "radio", "checkbox", "button", "date"]
+    # Classify lines and measure execution time
+    for model_name in models.values():
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        html_classified_lines, html_execution_time = classify_lines(html_inputs, ["text", "radio", "checkbox", "button", "date"], model_name)
+        json_classified_lines, json_execution_time = classify_lines_json(html_content, json_content, list(json_content.keys()), model_name, output_file_path)
+        # print(str(html_execution_time) + " - " + str(html_classified_lines))
+        # print(str(json_execution_time) + " - " + str(json_classified_lines))
+        #FILL HERE
+        #print(type(json_classified_lines))
+    # Assuming your function returns the processed HTML
+    #json_classified_lines
+    #return '\n'.join(map(str, html_classified_lines))
+    return '\n'.join(map(str, json_classified_lines))
+iface = gr.Interface(fn=process_files,
+                     inputs=[gr.inputs.File(label="Upload HTML File"), gr.inputs.File(label="Upload JSON File")],
+                     outputs="text",
+                     examples=[
+                        # ["./examples/form0.html", "./examples/form0_answer.json"],
+                        ["./public/form1.html", "./public/form1_answer.json"],
+                        ["./public/form2.html", "./public/form2_answer.json"],
+                        ["./public/form3.html", "./public/form3_answer.json"],
+                        ["./public/form4.html", "./public/form4_answer.json"]
+                    ])
+iface.launch()

output.html ADDED Viewed

	@@ -0,0 +1,31 @@

+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>Contact Form</title>
+  </head>
+  <body>
+    <h1>Contact Form</h1>
+    <form action="/submit-form" method="POST">
+      <label for="name">Name:</label>
+      <input type="text" id="name" name="name" required><!-- Input: Please fill in the name field. with this certainty: 0.8276665210723877 -->
+      <br>
+      <label for="email">Email:</label>
+      <input type="email" id="email" name="email" required><!-- Input: frs98com@gmail.com with this certainty: 0.8814952373504639 -->
+      <br>
+      <label for="location">Location:</label>
+      <input type="text" id="location" name="location" required><!-- Input: Amsterdam, Netherlands with this certainty: 0.845346212387085 -->
+      <br>
+      <label for="github">GitHub:</label>
+      <input type="url" id="github" name="github" required><!-- Input: https://github.com/qtoino with this certainty: 0.6784256100654602 -->
+      <br>
+      <label for="linkedin">LinkedIn:</label>
+      <input type="url" id="linkedin" name="linkedin" required><!-- Input: https://www.linkedin.com/in/francisco-rsantos/ with this certainty: 0.735436737537384 -->
+      <br>
+      <label for="phone">Phone:</label>
+      <input type="tel" id="phone" name="phone" required><!-- Input: +351 927 050 265 with this certainty: 0.8759291768074036 -->
+      <br><br>
+      <input type="submit" value="Submit"><!-- Input: Please fill in the name field. with this certainty: 0.2793944180011749 -->
+    </form>
+  </body>
+</html>