M-1: PAL, TA, MP

TA.py

@@ -0,0 +1,53 @@
+from prompt import TA_prompt
+import re
+from utils import generate_response, run_code
+
+
+def post_process_code(code, question):
+    func_name = code.split("(")[0].split("def")[-1].strip()
+    parameters = code.split("\n")[0].split(f"def {func_name}")[-1][1:-2].split(",")
+    if '' in parameters:
+        parameters.remove('')
+    values = re.findall(r"[-+]?\d*\.\d+|\d+", question)[:len(parameters)]
+    values = [int(v) for v in values]
+    arguments = list(zip(parameters, values))
+
+    arg_string = ""
+    for param, val in arguments:
+        arg_string += f"{param}={val},"
+    func_call = f"\nprint({func_name}({arg_string[:-1]}))"
+    code += func_call
+    return code
+
+
+def solve_ta(question, token):
+    question = question.strip()
+    question = "Human: " + question
+    query = TA_prompt + question
+    query = query.strip()
+    query += "\n"
+    code = generate_response(query, 0.9, token)
+
+    splitting_string = "```" if "```python" not in code else "```python"
+    code = code.split(splitting_string)[-2].split("```")[0].strip()
+    print(code)
+    # code preprocessing
+
+    code = post_process_code(code, question)
+    print(code)
+    # code running
+    if "input(" in code:
+        return None, code
+    pred = None
+    try:
+        pred = run_code(code)
+    except Exception as ex:
+        return None, code
+    return pred, code
+
+
+if __name__ == "__main__":
+
+    q = "What is the 7th Fibonacci number? Write the Python code"
+    print(solve_ta(q))
+

app.py

@@ -0,0 +1,125 @@
+import gradio as gr
+from pal import solve_pal
+from mathprompter import solve_mp
+from TA import solve_ta
+from utils import run_code
+
+
+def run(token, question, method):
+    if len(token) == 0:
+        raise gr.Error("Please provide a valid Hugging Face access token")
+    if method == "PAL":
+        code_op, generated_code = solve_pal(question, token)
+        if code_op is not None:
+            return code_op, gr.Code.update(value=generated_code, interactive=True), gr.Button.update(visible=True)
+        else:
+            return (
+                "Code execution failed, please review it from below and re-run it or try-asking again with more details",
+                gr.Code.update(value=generated_code, interactive=True), gr.Button.update(visible=True))
+
+    elif method == "TA":
+        code_op, generated_code = solve_ta(question, token)
+        if code_op is not None:
+            return code_op, gr.Code.update(value=generated_code, interactive=True), gr.Button.update(visible=True)
+        else:
+            return (
+                "Code execution failed, please review it from below and re-run it or try-asking again with more details",
+                gr.Code.update(value=generated_code, interactive=True), gr.Button.update(visible=True))
+
+    elif method == "MathPrompter":
+        exp_op, code_op, generated_code = solve_mp(question, token)
+
+        if code_op is not None:
+            ans = f"Answer from Expression execution: {exp_op} \nAnswer from Code execution: {code_op}  "
+            return ans, gr.Code.update(value=generated_code, interactive=True), gr.Button.update(visible=True)
+        else:
+            return (
+                "Code execution failed, please review it from below and re-run it or try-asking again with more details",
+                gr.Code.update(value=generated_code, interactive=True), gr.Button.update(visible=True))
+
+    else:
+        raise gr.Error("Please select the evaluating strategy from dropdown")
+
+
+def run_edits(code):
+    try:
+        code_op = run_code(code)
+        return code_op, code
+    except:
+        return "Code execution failed, please review it from below and re-run it or try-asking again with more details", code
+
+
+# User Interface Part
+
+TITLE = "Reasoning with StarCoder 💫"
+demo = gr.Blocks(title=TITLE, theme=gr.themes.Default())
+
+
+def render_instruction(mtd):
+    if mtd == "PAL":
+        return gr.Textbox.update(
+            value='''
+            💫 Query can be an instruction or a direct question starting with What, Find, etc.
+            💫 Use numbers wherever possible, i.e use 2 instead of two
+            💫 Example: What is the value of sin(30)?
+            ''',
+            visible=True
+        )
+    if mtd == "TA":
+        return gr.Textbox.update(
+            value='''
+            💫 Query should be a direct instruction starting with *write the code* and the main question.
+            💫 Use numbers wherever possible, i.e use 2 instead of two
+            💫 Example: Write the  code to find 7th Fibonacci number.
+            ''',
+            visible=True
+        )
+    if mtd == "MathPrompter":
+        return gr.Textbox.update(
+            value='''
+            💫 Query should be a direct question, can start by giving a context and then asking the intended segment.
+            💫 Use numbers wherever possible, i.e use 2 instead of two
+            💫 Example: The dimensions of the input image are 80x80, if the filter of 3x3 size is convoluted on the image, what are the dimensions of output image?
+            ''',
+            visible=True
+        )
+
+
+with demo:
+    gr.HTML(f"<center><h1>{TITLE}<h1></center>")
+
+    access_token = gr.Textbox(type="password", label="Hugging Face Access Token")
+    with gr.Row():
+        methods = gr.Dropdown(choices=['PAL', 'TA', 'MathPrompter'], interactive=True, label="Evaluation Strategies")
+        question_input = gr.Textbox(label="Question", lines=1, placeholder="Enter your question here...")
+
+    instruction = gr.Textbox(label="Instructions", visible=False, interactive=False)
+    methods.change(fn=render_instruction, inputs=methods, outputs=instruction)
+
+    question_output = gr.Textbox(label="Answer", interactive=False)
+    code = gr.Code(language="python", interactive=False, label="Generated Code (Editable)")
+    submit_btn = gr.Button("Submit")
+    edit_btn = gr.Button("Run the edited code", visible=False)
+
+    submit_btn.click(run, inputs=[access_token, question_input, methods], outputs=[question_output, code, edit_btn])
+    edit_btn.click(run_edits, inputs=code, outputs=[question_output, code])
+    gr.Examples(
+        examples=[
+            [
+                "The dimensions of the input image are 80x80, if the filter of 3x3 size is convoluted on the image, what are the dimensions of output image?",
+                "PAL"],
+            [
+                "The dimensions of the input image are 80x80, if the filter of 3x3 size is convoluted on the image, what are the dimensions of output image?",
+                "MathPrompter"],
+            ["What is the value of sin(30)?", "PAL"],
+            ["Write the  code to find 7th Fibonacci number.", "TA"],
+            ["Write a program to filter all the odd numbers from a python list", "PAL"],
+        ],
+        inputs=[question_input, methods],
+        outputs=[question_output, code, edit_btn],
+        fn=run,
+        cache_examples=False,
+        label="Sample Questions",
+    )
+
+demo.launch()

mathprompter.py

@@ -0,0 +1,142 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import re
+from prompt import algebric_prompt, python_prompt
+from utils import generate_response, run_code
+
+
+def generate_algebric_template(question):
+    var_names = [chr(i) for i in range(ord('A'), ord('Z') + 1)]
+    pattern = re.compile(r"[-+]?\d*\.\d+|\d+")
+    var_map = {}
+    matches = re.findall(pattern, question)
+
+    for i, num in enumerate(matches):
+        var_name = var_names[i]
+        question = question.replace(num, var_name)
+        var_map[var_name] = float(num)
+    return question, var_map
+
+
+def generate_algebric_expression(question, variables, param, token):
+    question = question.strip()
+    query = algebric_prompt.format(question=question).strip() + "\n"
+    response = generate_response(query, param, token)
+    expression = response.split(f"#Ques: {question}")[-1].strip()
+    return expression.split("Answer = ")[-1]
+
+
+def generate_python_code(question, equation, param, token):
+    query = python_prompt.format(question=question.strip(), expression=equation.strip()).strip() + "\n"
+    response = generate_response(query, param, token)
+    function_code = response.split("# Function for above expression is:")[-1].strip()
+    return function_code
+
+
+def run(question, random_candidates, hps, token):
+    question, var_map = generate_algebric_template(question)
+
+    # generating the random candidates for arguments
+    random_mapping = pd.DataFrame(columns=list(var_map.keys()))
+
+    for _ in range(random_candidates):
+        random_mapping.loc[len(random_mapping)] = np.random.randint(1, 100, (len(random_mapping.columns),))
+
+    candidates = []
+    acc = []
+    # accumulating results
+    N = len(hps)
+    for i in range(N):
+
+        variables = list(var_map.keys())
+        expression = generate_algebric_expression(question, variables, hps[i], token)
+        code = generate_python_code(question, expression, hps[i], token)
+        candidates.append((expression, code))
+        current_acc = 0
+
+        try:
+            for idx in range(5):
+                arguments = random_mapping.iloc[idx].to_list()
+
+                # running expression
+                exp = expression
+                temp_code = code
+
+                for k, v in zip(list(var_map.keys()), arguments):
+                    exp = exp.replace(k, str(v))
+                exp = "print(" + exp + ")"
+
+                if "input(" in exp or "input(" in temp_code:
+                    acc.append(0)
+                    continue
+
+                exp_ans = run_code(exp)
+
+                # running code
+                parameters = temp_code.split("\n")[0].split("def solution")[-1][1:-2].split(",")
+                if '' in parameters:
+                    parameters.remove('')
+
+                arguments = [(param.strip(), int(random_mapping.iloc[idx][param.strip()])) for param in parameters]
+                arg_string = ""
+                for param, val in arguments:
+                    arg_string += f"{param}={val},"
+                func_call = f"\nprint(solution({arg_string[:-1]}))"
+                temp_code += func_call
+                code_ans = run_code(temp_code)
+
+                current_acc += int(exp_ans == code_ans)
+
+                # reverting the changes
+                exp = expression
+                temp_code = code
+        except Exception as ex:
+            pass
+        acc.append(current_acc)
+
+    candidate_index = np.argmax(acc)
+    top_candidate = candidates[candidate_index]
+    return top_candidate, var_map
+
+
+def solve_mp(question, token):
+    hps = [0.9, 0.95]
+    (expression, code), var_map = run(question, 5, hps, token)
+    exp_op = None
+    code_op = None
+
+    try:
+        # expression output
+        for k, v in var_map.items():
+            expression = expression.replace(k, str(v))
+        expression = "print(" + expression + ")"
+        print(expression)
+
+        if "input(" in expression:
+            raise Exception
+
+        exp_op = run_code(expression)
+    except:
+        print("expression cannot be executed", expression)
+    try:
+        # code output
+        print(code)
+        parameters = code.split("\n")[0].split("def solution")[-1][1:-2].split(",")
+        if '' in parameters:
+            parameters.remove('')
+
+        arguments = [(param.strip(), int(var_map[param.strip()])) for param in parameters]
+        arg_string = ""
+        for param, val in arguments:
+            arg_string += f"{param}={val},"
+        func_call = f"\nprint(solution({arg_string[:-1]}))"
+        code += func_call
+        if "input(" in code:
+            print("code cannot be executed")
+            raise Exception
+        code_op = run_code(code)
+    except:
+        return None, None, code
+
+    return exp_op, code_op, code

pal.py

@@ -0,0 +1,45 @@
+from prompt import prompt
+import re
+from utils import generate_response, run_code
+
+
+def post_process_code(code, question):
+    parameters = code.split("\n")[0].split("def solution")[-1][1:-2].split(",")
+    if '' in parameters:
+        parameters.remove('')
+    values = re.findall(r"[-+]?\d*\.\d+|\d+", question)[:len(parameters)]
+    values = [int(v) for v in values]
+    return list(zip(parameters, values))
+
+
+def solve_pal(question, token):
+    question = question.strip()
+    query = prompt.format(question=question).strip()
+    code = generate_response(query, 0.9, token)
+    code = code.split("def solution():")[-1].strip()
+    code = "def solution():\n" + code
+    # code preprocessing
+
+    arguments = post_process_code(code, question)
+
+    arg_string = ""
+    for param, val in arguments:
+        arg_string += f"{param}={val},"
+    func_call = f"\nprint(solution({arg_string[:-1]}))"
+    code += func_call
+    # code running
+    if "input(" in code:
+        return None, code
+    pred = None
+    try:
+        pred = run_code(code)
+    except Exception as ex:
+        return None, code
+    return pred, code
+
+
+if __name__ == "__main__":
+
+    q = "What is the 7th Fibonacci number?"
+    print(solve_pal(q))
+

prompt.py

@@ -0,0 +1,343 @@
+# todo: Improve the prompt of mathprompter too
+
+prompt = '''
+def solution():
+    #Ques: For Halloween Debby and her sister combined the candy they received. Debby had 32 pieces of candy while her sister had 42. If they ate 35 pieces the first night, how many pieces do they have left?
+    Debby_candies = 32
+    sister_candies = 42
+    candies_ate = 35
+    return ((Debby_candies + sister_candies) - candies_ate) 
+
+
+def solution():
+    #Ques: What are roots of the equation x^2 - 2x + 1?
+    import math
+    a = 1
+    b = -2
+    c = 1
+    root1 = (-b + math.sqrt(b**2 - 4*a*c)) / (2*a)
+    root2 = (-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
+    return root1, root2
+
+
+def solution():
+    #Ques: A waiter had 22 customers in his section. If 14 of them left and the rest of his tables had 4 people at each table, how many tables did he have?
+    customers = 32
+    customers_left = 14
+    each_table = 4
+    total_tables = (customers - customers_left) / each_table
+    return total_tables
+
+
+def solution():
+    #Ques: What is the 5th number in Fibonacci sequence?
+    n = 5
+    a = 0
+    b = 1
+    if n < 0:
+        print("Incorrect input")
+    elif n == 0:
+        return a
+    elif n == 1:
+        return b
+    else:
+        for i in range(2, n):
+            c = a + b
+            a = b
+            b = c
+        return b
+print(solution())
+
+
+def solution():
+    #Ques: {question}
+'''
+
+algebric_prompt = '''
+#Ques: For Halloween Debby and her sister combined the candy they received. Debby had A pieces of candy while her sister had B. If they ate C pieces the first night, how many pieces do they have left?
+Answer = (A + B) - C
+
+
+#Ques: Roger had A dollars. If he spent B bucks on a new game, how many C dollar toys could he buy with the money he had left?
+Answer = (A - B) // C
+
+
+#Ques: A waiter had A customers in his section. If B of them left and the rest of his tables had C people at each table, how many tables did he have?
+Answer = (A - B) / C
+
+
+#Ques: There were A friends playing a video game online when B players quit. If each player left had C lives, how many lives did they have total? "
+Answer = (A - B) * C
+
+
+#Ques: {question}
+'''
+
+
+python_prompt = '''
+#Ques: For Halloween Debby and her sister combined the candy they received. Debby had A pieces of candy while her sister had B. If they ate C pieces the first night, how many pieces do they have left?
+# Expression = (A + B) - C
+
+# Function for above Expression is:
+def solution(A, B, C):
+    return (A + B) - C
+
+
+#Ques: A waiter had A customers in his section. If B of them left and the rest of his tables had C people at each table, how many tables did he have?    
+# Expression = (A - B) / C
+
+# Function for above expression is:
+def solution(A, B, C):
+    return (A - B) / C
+
+
+#Ques: Roger had A dollars. If he spent B bucks on a new game, how many C dollar toys could he buy with the money he had left?
+# Expression = (A - B) // C
+
+# Function for above expression is:
+def solution(A, B, C):
+    return (A - B) // C
+
+
+#Ques: There were A friends playing a video game online when B players quit. If each player left had C lives, how many lives did they have total? "
+# Expression = (A - B) * C
+
+# Function for above expression is:
+def solution(A, B, C):
+    return (A - B) * C
+
+
+#Ques: {question}
+# Expression = {expression}
+
+# Function for above expression is:
+'''
+
+TA_prompt = '''
+Below are a series of dialogues between various people and an AI technical assistant. The assistant tries to be helpful, polite, honest, sophisticated, emotionally aware, and humble-but-knowledgeable. The assistant is happy to help with code questions, and will do its best to understand exactly what is needed. It also tries to avoid giving false or misleading information, and it caveats when it isn’t entirely sure about the right answer. That said, the assistant is practical and really does its best, and doesn’t let caution get too much in the way of being useful.
+
+-----
+
+Human: Write a function that takes two lists and returns a list that has alternating elements from each input list.
+
+Assistant: Sure. Here is a function that does that.
+
+```
+def alternating(list1, list2):
+   results = []
+   for i in range(len(list1)):
+       results.append(list1[i])
+       results.append(list2[i])
+   return results
+```
+
+Human: Can you write some test cases for this function?
+
+Assistant: Sure, here are some tests.
+
+```
+assert alternating([10, 20, 30], [1, 2, 3]) == [10, 1, 20, 2, 30, 3]
+assert alternating([True, False], [4, 5]) == [True, 4, False, 5]
+assert alternating([], []) == []
+```
+
+Human: Modify the function so that it returns all input elements when the lists have uneven length. The elements from the longer list should be at the end.
+
+Assistant: Here is the modified function.
+
+```
+def alternating(list1, list2):
+   results = []
+   for i in range(min(len(list1), len(list2))):
+       results.append(list1[i])
+       results.append(list2[i])
+   if len(list1) > len(list2):
+       results.extend(list1[i+1:])
+   else:
+       results.extend(list2[i+1:])
+   return results
+```
+
+-----
+
+Human: My code below is not working. Can you see what may be wrong?
+
+```
+def factorial(n):
+   r = 0
+   for i in range(n):
+       r *= i
+   return r
+```
+
+Assistant: In factorial, the initial value of `r` must be `1`. The following version should work:
+
+```
+def factorial(n):
+   r = 1 # Changed here
+   for i in range(n):
+       r *= i
+   return r
+```
+Human: Can you use this function to create a code to compute the number of k-combinations of a set of n elements?
+
+Assistant: Yes, of course. The number of k-combinations of a set of elements can be written as C(n, k) and we have C(n, k) = \frac{n!}{(n-k)!k!} whenever k <= n. The code is as follows
+
+def combination(n, k):
+    assert k <= n
+    return factorial(n)/(factorial(n-k)*factorial(k))
+
+
+This should work pretty well. Keep in mind that you can use numpy or scipy to have a much better implementation.
+
+
+Human: Thanks.
+
+
+Assistant: You are welcome.
+-----
+
+Human: I have a CSV file that looks like this:
+
+Name,Salary
+Bob,12000
+Avantika,35000
+Alice,30000
+
+Write a program that returns the name of the person with the highest salary.
+
+Assistant: Here is a solution that assumes the filename is salaries.csv.
+
+
+```
+from csv import DictReader
+from pathlib import Path
+
+
+def max_salary(filename):
+   rows = DictReader(Path(filename).read_text().splitlines())
+   max_index = -1
+   for i, row in enumerate(rows):
+       if int(row['Salary']) > int(rows[max_index]['Salary']):
+           max_index = i
+   return rows[max_index]['Name']
+
+
+print(max_salary('salaries.csv'))
+```
+-----
+
+Human: What is the purpose of the code below ?
+
+```
+def f(n, p):
+   if p == 0:
+	return 1
+   else :
+   	return n*f(n, p-1)
+```
+Assistant: This python function is designed to raise a base value n to a power p, that is, computing the value n^p where p is a positive integer.
+
+-----
+
+Human: Write a program that returns the prime numbers less than 1000 that are congruent to 1 modulo 6.
+
+Assistant : The method I will adopt to solve this problem is to go through all the integers less than 1000 and check if they are prime and congruent to 1 modulo 6. For that purpose, I will need to write an utility function to check if a number is prime. Here it is:
+
+```
+def is_prime(p):
+   if p <= 1:
+	return False
+   else :
+   	for i in range(2, int(p**0.5)+1):
+	    if p%i == 0 :
+		 return False 
+      return True
+```
+Now, here is the final solution:
+
+```
+def primes_mod_6():
+   primes = []
+   for n in range(1000):
+	if is_prime(n) and n%6 == 1 :
+	   primes.append(n)
+   return primes
+``` 
+
+-----
+
+Human: Can you translate the code below in Java? 
+```
+print(“Hello world”)
+```
+Assistant: Sure, the Java translation of your code is as follows.
+```
+System.out.println(“Hello world”);
+```
+
+-----
+
+Human: The bakers at the Beverly Hills Bakery baked 200 loaves of bread on Monday morning. They sold 93 loaves in the morning and 39 loaves in the afternoon. A grocery store returned 6 unsold loaves. How many loaves of bread did they have left?
+
+Assistant: Let’s think step by step. The bakers started with 200 loaves of bread. They sold 93 in the morning and 39 in the afternoon. So they sold 93+39=132 loaves of bread. Which means they had 200 - 132 = 68 loaves left. Finally, a grocery returned 6 unsold loaves to the store. Thus, they ended up with 68+6=74 loaves. The answer is 74.
+
+Human: Nice. Can you write a python function to solve this problem? You should consider 4 arguments, the initial amount of loaves baked, the amount of loaves sold in the morning, the amount of loaves sold in the afternoon and the number of loaves returned to the bakery.
+
+Assistant: Sure, here is the code.
+
+```
+def loaves_left(initial_number_of_loaves, loaves_sold_morning, loaves_sold_afternoon, loaves_returned):
+    loaves_sold_total = loaves_sold_morning + loaves_sold_afternoon
+    return initial_number_of_loaves - loaves_sold_total + loaves_returned
+```
+Human: Can you test your function with the following inputs?
+24, 5, 9, 3
+153, 57, 99, 32
+
+Assistant: Definitely, we have:
+loaves_left(24, 5, 9, 3) = 13
+loaves_left(153, 57, 99, 32) = 29
+
+-----
+
+Human: Can you write a python function to randomly decide between eating a pizza or a burger with probability 0.3 and 0.7 respectively?
+
+```
+import random
+def pizza_or_burger():
+    p = random.uniform(0, 1)
+    if p <= 0.3:
+ print(“Let’s eat a pizza for lunch.”)
+    else:
+ print(“Let’s eat a burger for lunch.”)
+```
+
+-----
+
+Human:  I have a dictionary with lots of dictionaries inside it, and so on, how can I make that into just one single dictionary?
+
+Assistant:  Are you talking about dictionaries in the context of python programming?
+
+Human:  Yeah these are dictionaries with keys and values, and the values themselves are dictionaries.
+
+Assistant:  Great, I think I understand what you’re asking.  We might say that we want to flatten the dictionaries, right?  And if there are several levels, we’ll want to do this recursively.
+
+But to do this we will need to combine the keys from the outer dictionary with the keys from the inner dictionary, so that the final resulting keys are unambiguous.  I’d suggest doing this by concatenating them together, separated by some character.  Will that work for you, and what character would you like to use?
+
+```
+def recursively_flatten_dicts(d, separator="_"):
+   result = {}
+   for k, v in d.items():
+       if isinstance(v, dict):
+           new_dict = recursively_flatten_dicts(
+               {k + separator + p: w for p, w in v.items()}, separator=separator
+           )
+           result.update(new_dict)
+       else:
+           result[k] = v
+   return result
+```
+-----
+
+'''

requirements.txt

@@ -0,0 +1,73 @@
+aiofiles==23.1.0
+aiohttp==3.8.4
+aiosignal==1.3.1
+altair==4.2.2
+anyio==3.6.2
+async-timeout==4.0.2
+attrs==23.1.0
+certifi==2022.12.7
+charset-normalizer==3.1.0
+click==8.1.3
+contourpy==1.0.7
+cycler==0.11.0
+entrypoints==0.4
+fastapi==0.95.1
+ffmpy==0.3.0
+filelock==3.12.0
+fonttools==4.39.3
+frozenlist==1.3.3
+fsspec==2023.4.0
+gradio==3.28.1
+gradio_client==0.1.4
+h11==0.14.0
+httpcore==0.17.0
+httpx==0.24.0
+huggingface-hub==0.14.1
+idna==3.4
+importlib-resources==5.12.0
+Jinja2==3.1.2
+jsonschema==4.17.3
+kiwisolver==1.4.4
+linkify-it-py==2.0.0
+markdown-it-py==2.2.0
+MarkupSafe==2.1.2
+matplotlib==3.7.1
+mdit-py-plugins==0.3.3
+mdurl==0.1.2
+mpmath==1.3.0
+multidict==6.0.4
+networkx==3.1
+numpy==1.24.3
+orjson==3.8.11
+packaging==23.1
+pandas==2.0.1
+Pillow==9.5.0
+pkgutil_resolve_name==1.3.10
+pydantic==1.10.7
+pydub==0.25.1
+pyparsing==3.0.9
+pyrsistent==0.19.3
+python-dateutil==2.8.2
+python-multipart==0.0.6
+pytz==2023.3
+PyYAML==6.0
+regex==2023.3.23
+requests==2.29.0
+semantic-version==2.10.0
+six==1.16.0
+sniffio==1.3.0
+starlette==0.26.1
+sympy==1.11.1
+tokenizers==0.13.3
+toolz==0.12.0
+torch==2.0.0
+tqdm==4.65.0
+transformers==4.28.1
+typing_extensions==4.5.0
+tzdata==2023.3
+uc-micro-py==1.0.1
+urllib3==1.26.15
+uvicorn==0.22.0
+websockets==11.0.2
+yarl==1.9.2
+zipp==3.15.0

utils.py

@@ -0,0 +1,43 @@
+import requests
+import json
+from io import StringIO
+import sys
+import gradio
+import os
+
+
+def generate_response(query, top_p, token):
+    endpoint = "https://api-inference.huggingface.co/models/bigcode/starcoder"
+    params = {
+        'accept': 'application/json',
+        'Content-Type': 'application/json',
+        "Authorization": f"Bearer {token}"
+    }
+    data = {
+        'inputs': query,
+        "parameters": {
+            "details": True,
+            "do_sample": True,
+            "max_new_tokens": 256,
+            "repetition_penalty": 1.2,
+            "seed": 0,
+            "stop": ['<|endoftext|>'],
+            "temperature": 0.2,
+            "top_p": top_p,
+        }
+    }
+    try:
+        res = requests.post(endpoint, data=json.dumps(data), headers=params)
+        res = json.loads(res.content.decode("utf-8"))
+        return res[0]["generated_text"].split("<|endoftext|>")[0].strip()
+    except:
+        raise gradio.Error("Connection Error. Please check your ACCESS_TOKEN")
+
+
+def run_code(code):
+    output_buffer = StringIO()
+    sys.stdout = output_buffer
+    exec(code, {})
+    sys.stdout = sys.__stdout__
+    pred = output_buffer.getvalue().strip()
+    return pred