will this work?

dataset_adapters/3e6e51bb55f0c510628fc0e07baaeec1a162a7b0ef863165b0891efb92ed0101.py

@@ -0,0 +1,2 @@
+def transform_data(data):
+    return data

dataset_adapters/4d52bd9e40bac418bcc390a42ffaf0c0c1e85370628381af2608ddcbfb3a679b.py

@@ -0,0 +1,29 @@
+def transform_data(data):
+    conversations = []
+
+    # Iterate over messages, always processing 'input' and 'instruction' before 'output'
+    for message in data.get('messages', []):
+        # Check if it's a 'system' message and place it first if it exists
+        if message['role'] == 'system':
+            conversations.insert(0, {'from': 'system', 'value': message['content']})
+        elif message['role'] == 'assistant':
+            # 'assistant' is taken to be 'gpt'
+            conversations.append({'from': 'gpt', 'value': message['content']})
+        else:
+            # 'user' is taken to be 'human'
+            # Add 'instruction' directly if there is no 'input' for concatenation
+            if message.get('role') == 'input' and message.get('content'):
+                # If there are instructions before the input, we concatenate them.
+                if conversations and conversations[-1]['from'] == 'human':
+                    conversations[-1]['value'] += '\n\n' + message['content']
+                else:
+                    conversations.append({'from': 'human', 'value': message['content']})
+            else:
+                conversations.append({'from': 'human', 'value': message['content']})
+
+    # Check for the order of conversation entries
+    if conversations and conversations[0]['from'] == 'gpt':
+        # If the first message is from 'gpt', prepend a 'human' message
+        conversations.insert(0, {'from': 'human', 'value': ''})
+
+    return conversations

dataset_adapters/7a329ccea52693be98470e74ada5768849ba2523454c19d1f2d84b60221c156e.py

@@ -0,0 +1,32 @@
+def transform_data(data):
+    # Define roles and map them to the 'from' fields
+    role_mapping = {
+        'role_1': 'human',
+        'message_1': 'human',
+        'message_2': 'gpt',
+    }
+
+    # Use heuristics to properly order the messages
+    conv_order = ['role_1', 'message_1', 'message_2']
+    # Add 'instruction' if available, ensuring it comes before 'output'
+    if 'instruction' in data:
+        conv_order.insert(conv_order.index('message_1'), 'instruction')
+
+    # Iterate over the data in the specified order and construct the conversation list
+    conversation = []
+    for key in conv_order:
+        if key in data and data[key]:
+            from_role = 'system' if 'system' in key else role_mapping.get(key, 'human')
+            msg_value = data[key] if 'message' in key else data[key].split('.')[-1].replace('_', ' ').capitalize()
+
+            # If there is 'instruction' and 'input', concat 'input' at the end of the message
+            if key == 'instruction' and 'input' in data and data['input']:
+                msg_value += ' ' + data['input']
+
+            conv_item = {
+                'from': from_role,
+                'value': msg_value.strip()
+            }
+            conversation.append(conv_item)
+
+    return {'conversations': conversation}

dataset_adapters/87522c634adeee86c404df5141f0a2b983dff4bdde32f7d475db4cefa1dc2520.py

@@ -0,0 +1,83 @@
+# def transform_data(data):
+#     conversations = []
+    
+#     # start with instruction or input
+#     if "instruction" in data:
+#         conversation = {}
+#         conversation["from"] = "system"
+#         conversation["value"] = data["instruction"]
+#         conversations.append(conversation)
+
+#     if "input" in data and data["input"].strip() != "":
+#         if conversations:
+#             # Concat the input at the end of the first message
+#             conversations[0]["value"] += "\n" + data["input"]
+#         else:
+#             conversation = {}
+#             conversation["from"] = "human"
+#             conversation["value"] = data["input"]
+#             conversations.append(conversation)
+
+#     # finalize with "output"
+#     if "output" in data:
+#         conversation = {}
+#         conversation["from"] = "gpt"
+#         conversation["value"] = data["output"]
+#         conversations.append(conversation)
+    
+#     return {"conversations": conversations}
+
+
+# def transform_data(data):
+#     # Initialize the final result list
+#     result = []
+
+#     # Process "instruction"
+#     if "instruction" in data and data["instruction"]:
+#         result.append({
+#             'from': 'system',
+#             'value': data["instruction"]
+#         })
+        
+#     # Process "input"
+#     if "input" in data and data["input"]:
+#         # If "instruction" has already been added
+#         if result:
+#             # Add "input" to the end of the first message
+#             result[0]['value'] += '\n' + data["input"]
+#         else:
+#             # If there's no "instruction", add "input" as a separate message
+#             result.append({
+#                 'from': 'human',
+#                 'value': data["input"]
+#             })
+
+#     # Process "output"
+#     if "output" in data and data["output"]:
+#         result.append({
+#             'from': 'gpt',
+#             'value': data["output"]
+#         })
+
+#     return { 'conversations': result }
+
+
+def transform_data(data):
+    result = {'conversations': []}
+
+    if 'instruction' in data and data['instruction']:
+        msg = {'from': 'system', 'value': data['instruction']}
+        result['conversations'].append(msg)
+
+    if 'input' in data and data['input']:
+        if 'instruction' in data and data['instruction']:
+            result['conversations'][-1]['value'] += ' ' + data['input']
+        else:
+            msg = {'from': 'human', 'value': data['input']}
+            result['conversations'].append(msg)
+
+    if 'output' in data and data['output']:
+        msg = {'from': 'gpt', 'value': data['output']}
+        result['conversations'].append(msg)
+    
+    return result

dataset_adapters/952b489de97f366fb44523b27fb3f0069050635fc6ada37e63997201324b3c41.py

@@ -0,0 +1,22 @@
+def transform_data(data):
+    conversations = []
+
+    # Check for system message and prepend if present
+    if data.get('system'):
+        conversations.append({'from': 'system', 'value': data['system']})
+
+    # Determine the correct order of human and gpt messages
+    human_msg = ''
+    if 'instruction' in data:
+        human_msg += data['instruction']
+    if 'input' in data and data['input']:  # Check if input exists and is not empty
+        human_msg += (' ' if human_msg else '') + data['input']
+
+    if human_msg:  # Add the human message if it's not empty
+        conversations.append({'from': 'human', 'value': human_msg})
+
+    if 'response' in data:
+        conversations.append({'from': 'gpt', 'value': data['response']})
+
+    # Return the transformed data without the schema
+    return {'conversations': conversations}

dataset_adapters/CollectiveCognitionchats-data-2023-10-16.py

@@ -0,0 +1,11 @@
+def transform_data(data):
+    new_data = {'id': id(data['title']), 'conversations': []}
+
+    # Ensure the conversation starts with a human message
+    if data['conversations'][0]['from'] == 'assistant':
+        new_data['conversations'].append({'from': 'system', 'value': 'START'})
+
+    # Copy the remaining conversations
+    new_data['conversations'].extend(data['conversations'])
+    
+    return new_data

dataset_adapters/LDJnrLessWrong-Amplify-Instruct.py

@@ -0,0 +1,9 @@
+def transform_data(data):
+    transformed_data = {"id": hash(data["source"]), "conversations": []}
+    for item in data["conversation"]:
+        transformed_data["conversations"].extend([
+            {"from": "human", "value": item["input"]},
+            {"from": "gpt", "value": item["output"]}
+        ])
+
+    return transformed_data

dataset_adapters/LDJnrPuffin.py

@@ -0,0 +1,13 @@
+def transform_data(data):
+    transformed_data = {
+        'id': data['id'],
+        'conversations': []
+    }
+    
+    for conversation in data['conversations']:
+        if conversation['from'] == 'human':
+            transformed_data['conversations'].append({'input': conversation['value']})
+        elif conversation['from'] == 'gpt':
+            transformed_data['conversations'][-1]['output'] = conversation['value']
+            
+    return transformed_data

dataset_adapters/LDJnrPure-Dove.py

@@ -0,0 +1,18 @@
+def transform_data(data):
+    conversations = []
+    for item in data.get('conversation', []):
+        conversations.append({
+            "from" : "human",
+            "value" : item.get("input", "")
+        })
+        conversations.append({
+            "from" : "gpt",
+            "value" : item.get("output", "")
+        })
+
+    transformed_data = {
+        "id": hash(data['source']), 
+        "conversations": conversations
+    }
+
+    return transformed_data

dataset_adapters/WizardLMWizardLM_evol_instruct_70k.py

@@ -0,0 +1,13 @@
+def transform_data(data):
+    id_value = 1  # You may assign the 'id' value, here I have used 1 for simplicity.
+    result = {'id': id_value, 'conversations': []}
+
+    for key in ('instruction', 'output'):
+        if key in data:
+            origin = 'human' if key == 'instruction' else 'gpt'
+            result['conversations'].append({
+                'from': origin,
+                'value': data[key]
+            })
+
+    return result

dataset_adapters/WizardLMWizardLM_evol_instruct_70k_2.py

@@ -0,0 +1,14 @@
+def transform_data(data):
+    transformed_data = {'id': 1, 'conversations': []}
+    id_counter = 1
+
+    for key, value in data.items():
+        if key == 'instruction':
+            transformed_data['conversations'].append({'from': 'human', 'value': value})
+        elif key == 'output':
+            transformed_data['conversations'].append({'from': 'gpt', 'value': value})
+
+    transformed_data['id'] = id_counter
+    id_counter += 1
+
+    return transformed_data

dataset_adapters/WizardLMWizardLM_evol_instruct_70k_fubnh.py

@@ -0,0 +1,23 @@
+def transform_data(data):
+    transformed_data = {}
+    
+    # get the id
+    transformation_id = data.get("id", 0)  # substitute 0 (or any default) if no id is found 
+    transformed_data["id"] = transformation_id
+
+    # split the conversations into separate messages
+    instructions = data.get("instruction", None)
+    outputs = data.get("output", None)
+
+    # build conversation array
+    conversations = []
+
+    if instructions:
+        conversations.append({"from": "human", "value":instructions})
+
+    if outputs:
+        conversations.append({"from": "gpt", "value": outputs})
+
+    transformed_data["conversations"] = conversations
+
+    return transformed_data 

dataset_adapters/WizardLMWizardLM_evol_instruct_V2_196k.py

@@ -0,0 +1,16 @@
+import random
+
+def transform_data(data):
+    transformed_data = {}
+    transformed_data['id'] = random.randint(1, 1000000) # generates a random integer as ID
+    transformed_data['conversations'] = []
+
+    conversations = data.get('conversations', [])
+    for conversation in conversations:
+        from_val = conversation.get('from', '')
+        value = conversation.get('value', '')
+        if from_val.lower() in ['human', 'gpt', 'system']:
+            transformed_conversation = {'from': from_val, 'value': value}
+            transformed_data['conversations'].append(transformed_conversation)
+
+    return transformed_data

dataset_adapters/e46a55643ce19efc8adfe855f6ff7a2a3e93a60ea42b1897f4c705919e6f821a.py

@@ -0,0 +1,16 @@
+def transform_data(data):
+    transformed_data = []
+    for i in range(len(data["data"])):
+        # Setting the correct "from" field based on the index
+        if i % 2 == 0: 
+            # Case of input or instruction
+            if i < len(data["data"]) - 1: 
+                # There is a response after this message, it is an input
+                msg_type = 'human'
+            else: 
+                msg_type = 'system'  # There is not a response after this message, it is an instruction
+            transformed_data.append({'from': msg_type, 'value': data["data"][i]})
+        else: 
+            # The case where the "from" field would be 'gpt'
+            transformed_data.append({'from': 'gpt', 'value': data["data"][i]})
+    return {'conversations': transformed_data}

dataset_adapters/ed2b4cf199998dfb4690d6ae767d25dca1256ccd97729b257db3a37206a72969.py

@@ -0,0 +1,38 @@
+def transform_data(data):
+    # Setup alias roles for conversion
+    role_mapping = {'user': 'human', 'assistant': 'gpt', 'system': 'system'}
+    conversations = []
+
+    # Check for system messages and prepend if present
+    system_messages = [msg for msg in data['messages'] if msg['role'] == 'system']
+    if system_messages:
+        for msg in system_messages:
+            conversations.append({'from': role_mapping[msg['role']], 'value': msg['content']})
+
+    # Prepare human and gpt messages
+    prompt = data.get('prompt', '')
+    human_messages = [msg for msg in data['messages'] if msg['role'] == 'user']
+    gpt_messages = [msg for msg in data['messages'] if msg['role'] == 'assistant']
+
+    # If there are both "instruction" and "input" and "input" is not empty, append it to first message
+    if human_messages and prompt.strip():
+        human_messages[0]['content'] = prompt + '\n\n' + human_messages[0]['content']
+
+    # Pair each human message with corresponding gpt message, ensuring human speaks first
+    paired_messages = zip(human_messages, gpt_messages)
+
+    # Append paired messages to the conversation list
+    for user_msg, gpt_msg in paired_messages:
+        conversations.append({'from': role_mapping[user_msg['role']], 'value': user_msg['content']})
+        conversations.append({'from': role_mapping[gpt_msg['role']], 'value': gpt_msg['content']})
+
+    # Handle possible remaining unpaired human message
+    for user_msg in human_messages[len(gpt_messages):]:
+        conversations.append({'from': role_mapping[user_msg['role']], 'value': user_msg['content']})
+
+    # Handle any unprocessed system message if present
+    for msg in system_messages[len(conversations):]:
+        conversations.append({'from': role_mapping[msg['role']], 'value': msg['content']})
+
+    # Resulting data is a dictionary with a single key "conversations"
+    return {'conversations': conversations}

dataset_adapters/ed2b4cf199998dfb4690d6ae767d25dca1256ccd97729b257db3a37206a72969_bp.py

@@ -0,0 +1,22 @@
+def transform_data(data):
+    # Create the base structure for the transformed data
+    transformed = {'conversations': []}
+
+    # Check for system message type, if any, before human input and output
+    system_msg = next((msg for msg in data.get('messages', []) if msg.get('role') == 'system'), None)
+    input_msg = next((msg for msg in data.get('messages', []) if msg.get('role') == 'user'), None)
+    output_msg = next((msg for msg in data.get('messages', []) if msg.get('role') == 'assistant'), None)
+
+    # Include system message if present
+    if system_msg:
+        transformed['conversations'].append({'from': 'system', 'value': system_msg['content']})
+
+    # Handle input and instruction
+    if input_msg:
+        transformed['conversations'].append({'from': 'human', 'value': input_msg['content']})
+
+    # Include GPT message if present and after human input
+    if output_msg:
+        transformed['conversations'].append({'from': 'gpt', 'value': output_msg['content']})
+
+    return transformed

main.py

@@ -1,20 +1,385 @@
 from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse
-
-from transformers import pipeline
+from fastapi import FastAPI, BackgroundTasks, HTTPException, Query
+from fastapi.responses import StreamingResponse
+from starlette.concurrency import run_in_threadpool
+from datasets import load_dataset
+import random
+import json
+from genson import SchemaBuilder
+from pathvalidate import sanitize_filename
+from openai import OpenAI
+import hashlib
+from pprint import pprint
+import asyncio
+import importlib.util
+import sys
+import json
+import jsonschema
+# import aiosqlite
+from utils import extract_code
+import numpy as np
 
 app = FastAPI()
 
-pipe_flan = pipeline("text2text-generation", model="google/flan-t5-small")
 
-@app.get("/infer_t5")
-def t5(input):
-    output = pipe_flan(input)
-    return {"output": output[0]["generated_text"]}
+# DATABASE_FILE = "samples.db"
+
+
+client = OpenAI(
+  base_url="https://openrouter.ai/api/v1",
+  api_key=os.environ.get('OPENROUTER_KEY')
+)
+
+
+# async def setup_database():
+#     async with aiosqlite.connect(DATABASE_FILE) as db:
+#         await db.execute("""
+#             CREATE TABLE IF NOT EXISTS samples (
+#                 hash TEXT PRIMARY KEY,
+#                 data TEXT NOT NULL,
+#                 dataset TEXT NOT NULL
+#             )
+#         """)
+#         await db.commit()
+
+# async def insert_sample(hash: str, data: str, dataset: str):
+#     async with aiosqlite.connect(DATABASE_FILE) as db:
+#         # Check if a record with the same hash already exists
+#         cursor = await db.execute("SELECT COUNT(*) FROM samples WHERE hash = ?", (hash,))
+#         count = await cursor.fetchone()
+
+#         if count[0] == 0:
+#             # Insert the new record since it doesn't exist
+#             await db.execute("INSERT INTO samples (hash, data, dataset) VALUES (?, ?, ?)", (hash, data, dataset))
+#             await db.commit()
+#         else:
+#             # A record with the same hash already exists
+#             print("Record with the same hash already exists in the database.")
+
+# async def get_sample_by_hash(hash: str):
+#     async with aiosqlite.connect(DATABASE_FILE) as db:
+#         cursor = await db.execute("SELECT data, dataset FROM samples WHERE hash = ?", (hash,))
+#         row = await cursor.fetchone()
+#         return row
+
+def is_sharegpt(sample):
+    schema={'$schema': 'http://json-schema.org/schema#', 'type': 'object', 'properties': {'conversations': {'type': 'array', 'items': {'type': 'object', 'properties': {'from': { 'type': 'string', 'enum': ['human', 'gpt', 'system'] }, 'value': {'type': 'string'}}, 'required': ['from', 'value']}}}, 'required': ['conversations']}
+    try:
+        jsonschema.validate(instance=sample, schema=schema)
+        return True
+    except jsonschema.exceptions.ValidationError as e:
+        return False
+
+def sha256(string):
+    # Create a hashlib object for SHA-256
+    sha256_hash = hashlib.sha256()
+    # Update the hash object with your string encoded as bytes
+    sha256_hash.update(string.encode('utf-8'))
+
+    return sha256_hash.hexdigest()
+
+def get_adapter_name(sample):
+    builder = SchemaBuilder()
+    builder.add_object(sample)
+    schema = builder.to_schema()
+
+    return sha256(json.dumps(schema))
+
+def has_adapter(sample):
+    adapter_name = get_adapter_name(sample)
+
+    module_name = f"dataset_adapters.{adapter_name}"
+    module_spec = importlib.util.find_spec(module_name)
+
+    if module_spec is None:
+        return False
+
+    return True
+
+def auto_tranform(sample):
+    adapter_name = get_adapter_name(sample)
+    if not has_adapter(sample):
+        create_adapter(sample, adapter_name)
+
+    module_name = f"dataset_adapters.{adapter_name}"
+    spec = importlib.util.spec_from_file_location(module_name, f"dataset_adapters/{adapter_name}.py")
+    dynamic_module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = dynamic_module
+    spec.loader.exec_module(dynamic_module)
+
+    # Use the function from the dynamically imported module
+    transformed_data = dynamic_module.transform_data(sample)
+
+    if isinstance(transformed_data, list):
+        return {'conversations' : transformed_data}
+
+
+    return transformed_data
+
+
+
+
+# def create_adapter(sample, adapter_name):
+#     builder = SchemaBuilder()
+#     builder.add_object(sample)
+#     schema = builder.to_schema()
+
+#     code_string = """def transform_data(data):
+#     raise Exception('')"""
+
+    with open(f"dataset_adapters/{adapter_name}.py", 'w') as file:
+        file.write(code_string)
+
+
+def create_adapter(sample, adapter_name):
+    builder = SchemaBuilder()
+    builder.add_object(sample)
+    schema = builder.to_schema()
+
+    prompt = f"""Make me minimal and efficient python code to convert data in the shape of 
+
+initial data shape
+==========➡️📑📐==========
+```jsonschema
+{schema}
+```
+==========➡️📑📐==========
+
+to equivalent data in the form
+
+final data shape
+==========⬇️📑📐==========
+```jsonschema
+{{'$schema': 'http://json-schema.org/schema#', 'type': 'object', 'properties': {{'conversations': {{'type': 'array', 'items': {{'type': 'object', 'properties': {{'from': {{ 'type': 'string', 'enum': ['human', 'gpt', 'system'] }}, 'value': {{'type': 'string'}}}}, 'required': ['from', 'value']}}}}}}, 'required': ['conversations']}}
+```
+==========⬇️📑📐==========
+
+the data to transform is
+```json
+{sample}
+```
+
+
+Inside the data to transform, `input` and `instruction` is usually associated with `"from" : "human"` while `output` is usually associated with `"from" : "gpt"`
+
+For transforming the data you shall use python. Make robust and elegant python code that will do the transformation
+
+
+your code will contain a function `def transform_data(data):` that does the transformation and outputs the newly shaped data. Only the data, no schema. Your code snippet will include only the function signature and body. I know how to call it. You won't need to import anything, I will take care of parsing and dumping json. You work with dicts. Remember to be careful if you iterate over the data because I want the output conversation to always start with the prompt. In other words, always process "input" before "output" and "instruction" before "output". Such heuristics are very important. If there is "instruction" and "input" and the "input" is not empty, concat the input at the end of the first message. If the data contains no "system" message, human always speaks first. If it contains a "system"  message, the "system" message is first, then human, then gpt, then alternating if needed
+
+"human" ALWAYS SPEAKS BEFORE "gpt", if you suspect your code makes "gpt speak first, fix it 
+
+MOST IMPORTANT IS THAT YOU look at the initial data shape (➡️📑📐) to ground your transformation into final data shape (⬇️📑📐)
+
+Your output should contain only the code for `def transform_data(data):`, signature and body. Put the code inside markdown code block"""
+
+    response = client.chat.completions.create(
+                        model="openai/gpt-4-1106-preview", # Optional (user controls the default)
+                        messages=[
+                        { "role": "system", "content": """You are ChatGPT, a large language model trained by OpenAI, based on the GPT-4 architecture.
+Knowledge cutoff: 2023-04
+Current date: 2023-11-05
+
+Image input capabilities: Enabled""" },
+#                             {"role": "user", "content": f"""Make me minimal and efficient python code to convert data in the shape of 
+
+# ```jsonschema
+# {json.dumps(schema)}
+# ```
+
+# to equivalent data in the form ```
+# {{'$schema': 'http://json-schema.org/schema#', 'type': 'object', 'properties': {{'conversations': {{'type': 'array', 'items': {{'type': 'object', 'properties': {{'from': {{ 'type': 'string', 'enum': ['human', 'gpt', 'system'] }}, 'value': {{'type': 'string'}}}}, 'required': ['from', 'value']}}}}}}, 'required': ['conversations']}}
+# ```
+
+# the input is 
+# ```
+# {json.dumps(sample)}
+# ```
+
+
+# `input` is usually associated with `"from" : "human"` while `output` is usually associated with `"from" : "gpt"`
+
+# don't transform, make robust and elegant python code that will do the transformation
+
+
+# your code will contain a function `def transform_data(data):` that does the transformation and outputs the newly shaped data. Only the data, no schema. Your code snippet will include only the function signature and body. I know how to call it. You won't need to import anything, I will take care of parsing and dumping json. You work with dicts. Remember to be careful if you iterate over the data because I want the output conversation to always start with the prompt. In other words, always process "input" before "output" and "instruction" before "output". Such heuristics are very important. If there is "instruction" and "input" and the "input" is not empty, concat the input at the end of the first message."""
+# }
+  {"role": "user", "content": prompt}
+                        ]
+                               )
+
+    val = response.choices[0].message.content
+    # index = val.index('def transform_data(data)')
+
+    # def get_code_start():
+    #     for i in range(index,0,-1):
+    #         if val[i:i+3] == "```":
+    #             idx = val[i:].index('\n')
+    #             return i + (idx) + 1
+
+    # def get_code_end():
+    #     for i in range(index, len(val)):
+    #         if val[i:i+3] == "```":
+    #             return i-1
+
+    # code_string = val[get_code_start():get_code_end()]
+
+
+    # print("###", val)
+    code_string = extract_code(val)
+
+    if code_string is None:
+        raise Exception("hey la")
+
+    with open(f"dataset_adapters/{adapter_name}.py", 'w') as file:
+        file.write(code_string)
+
+
+@app.get("/sample")
+async def get_sample(hash: str = Query(..., alias="hash")):
+    res = await get_sample_by_hash(hash)
+    if res is None:
+        raise HTTPException(status_code=404, detail="Item not found")
+    data, dataset = res
+    sample= auto_tranform(json.loads(data))
+    return {'sample': sample, 'dataset': dataset}
+
+@app.get("/random-sample-stream")
+async def get_random_sample(background_tasks: BackgroundTasks, dataset_name: str = Query(..., alias="dataset-name"), index: str = Query(None, alias="index")):
+    queue = asyncio.Queue()
+    def event_stream(queue):
+        yield f"data: {json.dumps({'status': 'grab_sample'})}\n\n" 
+        try:
+
+
+
+
+            # dataset = load_dataset(dataset_name,streaming=True)
+            # split = [key for key in dataset.keys() if "train" in key]
+            
+            
+            
+            
+            import requests
+            headers = {"Authorization": f"Bearer {os.environ.get('HF_TOKEN')}"}
+            API_URL = f"https://datasets-server.huggingface.co/info?dataset={dataset_name}"
+            def query():
+                response = requests.get(API_URL, headers=headers)
+                return response.json()
+            data = query()
+
+            splits = data['dataset_info']['default']['splits']
+            split = next(iter(splits.values()))
+
+            num_samples = split['num_examples']
+            split_name = split['name']
+            
+            # dataset = load_dataset(dataset_name, split=split_name, streaming=True)
+            idx = random.randint(0, num_samples) if index is None else int(index)
+
+
+            API_URL = f"https://datasets-server.huggingface.co/rows?dataset={dataset_name}&config=default&split=train&offset={idx}&length=1"
+          
+            def query():
+                headers = {"Authorization": f"Bearer {os.environ.get('HF_TOKEN')}"}
+                response = requests.get(API_URL, headers=headers)
+
+                if response.status_code != 200:
+                    raise Exception("hugging face api error")
+                return response.json()
+            data = query()
+
+            random_sample = data['rows'][0]['row']
+
+            # pprint(random_sample)
+
+
+            # selected = dataset.skip(idx)
+            # random_sample = next(iter(selected))#random.choice(samples_buffer)
+
+            hashed = sha256(json.dumps(random_sample))
+            # insert_sample(hashed, json.dumps(random_sample), dataset_name)
+            # background_tasks.add_task(insert_sample, hashed, json.dumps(random_sample), dataset_name)
+
+        except Exception as e:
+            message = ""
+            if hasattr(e, 'message'):
+                message = e.message
+            else:
+                message = str(e)
+                
+            print("error : ", message)
+            yield f"data: {json.dumps({'status': 'error', 'message' : message })}\n\n" 
+
+        transformed_data = random_sample
+
+        success = True
+
+        if not is_sharegpt(random_sample):
+            try:
+                if not has_adapter(random_sample):
+                    yield f"data: {json.dumps({'status': 'creating_adapter'})}\n\n" 
+
+                transformed_data = auto_tranform(random_sample)
+            except Exception as e:
+                success = False
+                if hasattr(e, 'message'):
+                    print("error : ", e.message)
+                else:
+                    print("error : ", e)
+                yield f"data: {json.dumps({'status': 'error'})}\n\n" 
+
+        if success:
+            yield f"data: {json.dumps({'status': 'done', 'data' : transformed_data, 'index' : str(idx)})}\n\n" 
+
+    return StreamingResponse(event_stream(queue), media_type="text/event-stream")
+
+
+
+@app.get("/random-sample")
+async def get_random_sample(dataset_name: str = Query(..., alias="dataset-name")):
+    try:
+        dataset = load_dataset(dataset_name,streaming=True)
+        split = [key for key in dataset.keys() if "train" in key]
+        dataset = load_dataset(dataset_name, split=split[0], streaming=True)
+
+        buffer_size = 100  # Define a reasonable buffer size
+        samples_buffer = [sample for _, sample in zip(range(buffer_size), dataset)]
+        
+        random_sample = random.choice(samples_buffer)
+
+
+        hashed = sha256(json.dumps(random_sample))
+
+        sanitized = sanitize_filename(dataset_name)
+        module_name = f"dataset_adapters.{sanitized}"
+        module_spec = importlib.util.find_spec(module_name)
+
+        if module_spec is None:
+            create_adapter(random_sample, sanitized)
+
+        spec = importlib.util.spec_from_file_location(module_name, f"dataset_adapters/{sanitized}.py")
+        dynamic_module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = dynamic_module
+        spec.loader.exec_module(dynamic_module)
+
+        # Use the function from the dynamically imported module
+        transformed_data = dynamic_module.transform_data(random_sample)
+
+        return transformed_data
+
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="Dataset not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 
-app.mount("/", StaticFiles(directory="static", html=True), name="static")
 
+# @app.on_event("startup")
+# async def startup_event():
+#     await setup_database()
 @app.get("/")
 def index() -> FileResponse:
     return FileResponse(path="/app/static/index.html", media_type="text/html")

requirements.txt

@@ -1,7 +1,8 @@
-fastapi==0.74.*
-requests==2.27.*
-sentencepiece==0.1.*
-torch==1.11.*
-transformers==4.*
-uvicorn[standard]==0.17.*
-
+fastapi==0.104.0
+starlette==0.27.0
+datasets==2.14.5
+genson==1.2.2
+pathvalidate==3.2.0
+openai==1.3.3
+jsonschema==4.17.3
+numpy==1.22.0

static/dist/assets/index-6ff09fc9.css

@@ -0,0 +1 @@
+#app{max-width:1280px;margin:0 auto;padding:1rem .4rem;width:100%}@media (min-width: 640px){#app{padding:1rem 2rem;display:flex;place-items:center}}*,:before,:after{box-sizing:border-box;border-width:0;border-style:solid;border-color:#e5e7eb}:before,:after{--tw-content: ""}html{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;-o-tab-size:4;tab-size:4;font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";font-feature-settings:normal;font-variation-settings:normal}body{margin:0;line-height:inherit}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings:inherit;font-size:100%;font-weight:inherit;line-height:inherit;color:inherit;margin:0;padding:0}button,select{text-transform:none}button,[type=button],[type=reset],[type=submit]{-webkit-appearance:button;background-color:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}blockquote,dl,dd,h1,h2,h3,h4,h5,h6,hr,figure,p,pre{margin:0}fieldset{margin:0;padding:0}legend{padding:0}ol,ul,menu{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,textarea::-moz-placeholder{opacity:1;color:#9ca3af}input::placeholder,textarea::placeholder{opacity:1;color:#9ca3af}button,[role=button]{cursor:pointer}:disabled{cursor:default}img,svg,video,canvas,audio,iframe,embed,object{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]{display:none}*,:before,:after{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: }::backdrop{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: }.fixed{position:fixed}.absolute{position:absolute}.relative{position:relative}.bottom-3{bottom:.75rem}.left-0{left:0}.right-0{right:0}.right-2{right:.5rem}.top-0{top:0}.my-1{margin-top:.25rem;margin-bottom:.25rem}.mb-12{margin-bottom:3rem}.mb-3{margin-bottom:.75rem}.mb-4{margin-bottom:1rem}.mr-1{margin-right:.25rem}.mt-2{margin-top:.5rem}.mt-3{margin-top:.75rem}.mt-4{margin-top:1rem}.mt-\[0\.4em\]{margin-top:.4em}.block{display:block}.inline-block{display:inline-block}.flex{display:flex}.h-6{height:1.5rem}.h-8{height:2rem}.h-full{height:100%}.min-h-\[44px\]{min-height:44px}.w-6{width:1.5rem}.w-8{width:2rem}.w-\[33\%\]{width:33%}.w-\[66\%\]{width:66%}.w-fit{width:-moz-fit-content;width:fit-content}.w-full{width:100%}.max-w-\[80\%\]{max-width:80%}.flex-1{flex:1 1 0%}.grow-0{flex-grow:0}@keyframes pulse{50%{opacity:.5}}.animate-pulse{animation:pulse 2s cubic-bezier(.4,0,.6,1) infinite}@keyframes spin{to{transform:rotate(360deg)}}.animate-spin{animation:spin 1s linear infinite}.cursor-pointer{cursor:pointer}.resize{resize:both}.flex-row{flex-direction:row}.flex-col{flex-direction:column}.items-start{align-items:flex-start}.items-end{align-items:flex-end}.items-center{align-items:center}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.space-x-2>:not([hidden])~:not([hidden]){--tw-space-x-reverse: 0;margin-right:calc(.5rem * var(--tw-space-x-reverse));margin-left:calc(.5rem * calc(1 - var(--tw-space-x-reverse)))}.space-y-2>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.5rem * var(--tw-space-y-reverse))}.space-y-4>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1rem * var(--tw-space-y-reverse))}.rounded-2xl{border-radius:1rem}.rounded-full{border-radius:9999px}.rounded-lg{border-radius:.5rem}.rounded-md{border-radius:.375rem}.border{border-width:1px}.border-2{border-width:2px}.border-4{border-width:4px}.border-t{border-top-width:1px}.border-dashed{border-style:dashed}.border-blue-400{--tw-border-opacity: 1;border-color:rgb(96 165 250 / var(--tw-border-opacity))}.border-blue-500{--tw-border-opacity: 1;border-color:rgb(59 130 246 / var(--tw-border-opacity))}.border-gray-300{--tw-border-opacity: 1;border-color:rgb(209 213 219 / var(--tw-border-opacity))}.border-neutral-200{--tw-border-opacity: 1;border-color:rgb(229 229 229 / var(--tw-border-opacity))}.border-neutral-300{--tw-border-opacity: 1;border-color:rgb(212 212 212 / var(--tw-border-opacity))}.border-red-400{--tw-border-opacity: 1;border-color:rgb(248 113 113 / var(--tw-border-opacity))}.border-t-transparent{border-top-color:transparent}.bg-blue-500{--tw-bg-opacity: 1;background-color:rgb(59 130 246 / var(--tw-bg-opacity))}.bg-neutral-200{--tw-bg-opacity: 1;background-color:rgb(229 229 229 / var(--tw-bg-opacity))}.bg-red-100{--tw-bg-opacity: 1;background-color:rgb(254 226 226 / var(--tw-bg-opacity))}.bg-white{--tw-bg-opacity: 1;background-color:rgb(255 255 255 / var(--tw-bg-opacity))}.bg-yellow-100{--tw-bg-opacity: 1;background-color:rgb(254 249 195 / var(--tw-bg-opacity))}.p-1{padding:.25rem}.p-4{padding:1rem}.px-2{padding-left:.5rem;padding-right:.5rem}.px-3{padding-left:.75rem;padding-right:.75rem}.px-4{padding-left:1rem;padding-right:1rem}.py-2{padding-top:.5rem;padding-bottom:.5rem}.py-3{padding-top:.75rem;padding-bottom:.75rem}.py-6{padding-top:1.5rem;padding-bottom:1.5rem}.pl-4{padding-left:1rem}.pr-12{padding-right:3rem}.pt-12{padding-top:3rem}.text-center{text-align:center}.text-3xl{font-size:1.875rem;line-height:2.25rem}.text-sm{font-size:.875rem;line-height:1.25rem}.font-bold{font-weight:700}.font-semibold{font-weight:600}.text-gray-500{--tw-text-opacity: 1;color:rgb(107 114 128 / var(--tw-text-opacity))}.text-gray-600{--tw-text-opacity: 1;color:rgb(75 85 99 / var(--tw-text-opacity))}.text-neutral-900{--tw-text-opacity: 1;color:rgb(23 23 23 / var(--tw-text-opacity))}.text-red-700{--tw-text-opacity: 1;color:rgb(185 28 28 / var(--tw-text-opacity))}.text-white{--tw-text-opacity: 1;color:rgb(255 255 255 / var(--tw-text-opacity))}.text-yellow-700{--tw-text-opacity: 1;color:rgb(161 98 7 / var(--tw-text-opacity))}.placeholder-gray-400::-moz-placeholder{--tw-placeholder-opacity: 1;color:rgb(156 163 175 / var(--tw-placeholder-opacity))}.placeholder-gray-400::placeholder{--tw-placeholder-opacity: 1;color:rgb(156 163 175 / var(--tw-placeholder-opacity))}.filter{filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.transition{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,box-shadow,transform,filter,-webkit-backdrop-filter;transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,box-shadow,transform,filter,backdrop-filter;transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,box-shadow,transform,filter,backdrop-filter,-webkit-backdrop-filter;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.duration-300{transition-duration:.3s}:root{font-family:Inter,system-ui,Avenir,Helvetica,Arial,sans-serif;line-height:1.5;font-weight:400;color-scheme:light dark;color:#ffffffde;background-color:#242424;font-synthesis:none;text-rendering:optimizeLegibility;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;-webkit-text-size-adjust:100%}a{font-weight:500;color:#646cff;text-decoration:inherit}a:hover{color:#535bf2}body{margin:0;display:flex;min-width:320px;min-height:100vh}h1{font-size:3.2em;line-height:1.1}button{border-radius:8px;border:1px solid transparent;padding:.6em 1.2em;font-size:1em;font-weight:500;font-family:inherit;background-color:#1a1a1a;cursor:pointer;transition:border-color .25s}button:hover{border-color:#646cff}button:focus,button:focus-visible{outline:4px auto -webkit-focus-ring-color}@media (prefers-color-scheme: light){:root{color:#213547;background-color:#fff}a:hover{color:#747bff}button{background-color:#f9f9f9}}code{color:#abb2bf;padding:.2em .4em;margin:0;font-size:85%;white-space:break-spaces;background-color:#282c34;border-radius:6px}table,thead,tbody,th,tr,td{border:solid white 1px}td,th{padding:1em}h1{font-size:1.5em}.system-message{padding-bottom:2rem;color:#fff;background-color:#334155}.system-message:after{content:"";font-family:icomoon;display:block;position:absolute;font-size:1.25rem;bottom:.5rem;right:1rem}.hover\:cursor-pointer:hover{cursor:pointer}.hover\:border-gray-400:hover{--tw-border-opacity: 1;border-color:rgb(156 163 175 / var(--tw-border-opacity))}.hover\:bg-blue-600:hover{--tw-bg-opacity: 1;background-color:rgb(37 99 235 / var(--tw-bg-opacity))}.hover\:bg-blue-700:hover{--tw-bg-opacity: 1;background-color:rgb(29 78 216 / var(--tw-bg-opacity))}.hover\:bg-gray-100:hover{--tw-bg-opacity: 1;background-color:rgb(243 244 246 / var(--tw-bg-opacity))}.hover\:bg-neutral-300:hover{--tw-bg-opacity: 1;background-color:rgb(212 212 212 / var(--tw-bg-opacity))}.hover\:opacity-80:hover{opacity:.8}.focus\:border-blue-500:focus{--tw-border-opacity: 1;border-color:rgb(59 130 246 / var(--tw-border-opacity))}.focus\:outline-none:focus{outline:2px solid transparent;outline-offset:2px}.focus\:ring:focus{--tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);--tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(3px + var(--tw-ring-offset-width)) var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow, 0 0 #0000)}.focus\:ring-1:focus{--tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);--tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow, 0 0 #0000)}.focus\:ring-neutral-300:focus{--tw-ring-opacity: 1;--tw-ring-color: rgb(212 212 212 / var(--tw-ring-opacity))}@media (min-width: 640px){.sm\:my-1{margin-top:.25rem;margin-bottom:.25rem}.sm\:my-1\.5{margin-top:.375rem;margin-bottom:.375rem}.sm\:mb-8{margin-bottom:2rem}.sm\:inline{display:inline}.sm\:border{border-width:1px}.sm\:p-4{padding:1rem}.sm\:text-base{font-size:1rem;line-height:1.5rem}}@media (min-width: 768px){.md\:max-w-\[67\%\]{max-width:67%}.md\:justify-center{justify-content:center}.md\:pt-0{padding-top:0}}@font-face{font-family:icomoon;src:url(/fonts/icomoon.eot?qu2wpf);src:url(/fonts/icomoon.eot?qu2wpf#iefix) format("embedded-opentype"),url(/fonts/icomoon.ttf?qu2wpf) format("truetype"),url(/fonts/icomoon.woff?qu2wpf) format("woff"),url(/fonts/icomoon.svg?qu2wpf#icomoon) format("svg");font-weight:400;font-style:normal;font-display:block}[class^=icon-],[class*=" icon-"]{font-family:icomoon!important;speak:never;font-style:normal;font-weight:400;font-variant:normal;text-transform:none;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.icon-system:before{content:""}

static/dist/index.html

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Preact</title>
+    <script type="module" crossorigin src="/assets/index-34528448.js"></script>
+    <link rel="stylesheet" href="/assets/index-6ff09fc9.css">
+  </head>
+  <body ondrop="event.preventDefault()" >
+    <div id="app"></div>
+    
+  </body>
+</html>

static/index.html

@@ -1,36 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Fast API 🤗 Space served with Uvicorn</title>
-    <link rel="stylesheet" href="style.css" />
-    <script type="module" src="script.js"></script>
-  </head>
-  <body>
-    <main>
-      <section id="text-gen">
-        <h1>Text generation using Flan T5</h1>
-        <p>
-          Model:
-          <a
-              href="https://huggingface.co/google/flan-t5-small"
-              rel="noreferrer"
-              target="_blank"
-            >google/flan-t5-small</a
-          >
-        </p>
-        <form class="text-gen-form">
-          <label for="text-gen-input">Text prompt</label>
-          <input
-            id="text-gen-input"
-            type="text"
-            value="English: Translate There are many ducks. German:"
-          />
-          <button id="text-gen-submit">Submit</button>
-          <p class="text-gen-output"></p>
-        </form>
-      </section>
-    </main>
-  </body>
-</html>

static/script.js

@@ -1,21 +0,0 @@
-const textGenForm = document.querySelector('.text-gen-form');
-
-const translateText = async (text) => {
-    const inferResponse = await fetch(`infer_t5?input=${text}`);
-    const inferJson = await inferResponse.json();
-
-    return inferJson.output;
-};
-
-textGenForm.addEventListener('submit', async (event) => {
-  event.preventDefault();
-
-  const textGenInput = document.getElementById('text-gen-input');
-  const textGenParagraph = document.querySelector('.text-gen-output');
-
-  try {
-    textGenParagraph.textContent = await translateText(textGenInput.value);
-  } catch (err) {
-    console.error(err);
-  }
-});

static/style.css

@@ -1,45 +0,0 @@
-body {
-  --text: hsl(0 0% 15%);
-  padding: 2.5rem;
-  font-family: sans-serif;
-  color: var(--text);
-}
-
-body.dark-theme {
-  --text: hsl(0 0% 90%);
-  background-color: hsl(223 39% 7%);
-}
-
-main {
-  max-width: 80rem;
-  text-align: center;
-}
-
-section {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-}
-
-a {
-  color: var(--text);
-}
-
-form {
-  width: 30rem;
-  margin: 0 auto;
-}
-
-input {
-  width: 100%;
-}
-
-button {
-  cursor: pointer;
-}
-
-.text-gen-output {
-  min-height: 1.2rem;
-  margin: 1rem;
-  border: 0.5px solid grey;
-}