dactyl-generation 0.0.1__tar.gz

dactyl_generation-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Shantanu Thorat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dactyl_generation-0.0.1/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: dactyl_generation
+Version: 0.0.1
+Summary: LLM helper package to generate AI-generated texts.
+Author: Shantanu Thorat
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic
+Requires-Dist: litellm
+Requires-Dist: mistralai
+Requires-Dist: numpy==1.26.4
+Requires-Dist: openai
+Requires-Dist: pandas
+Requires-Dist: protobuf
+Requires-Dist: python-dotenv
+Requires-Dist: Requests
+Requires-Dist: tqdm
+Requires-Dist: typing_extensions
+Requires-Dist: google-generativeai
+Requires-Dist: boto3
+Dynamic: license-file
+
+# DACTYL-Generation
+
+A Python package to generate LLM data from various APIs. 
+
+## Installation
+```bash
+pip install git+https://github.com/ShantanuT01/dactyl_generation.git
+```
+
+## Usage
+
+Load environment variables (your API keys first) before importing the library. 
+```python
+# load environment variables first
+from dotenv import load_dotenv
+load_dotenv()
+
+# now import library
+from dactyl_generation.quick import *
+
+```

dactyl_generation-0.0.1/README.md

@@ -0,0 +1,21 @@
+# DACTYL-Generation
+
+A Python package to generate LLM data from various APIs. 
+
+## Installation
+```bash
+pip install git+https://github.com/ShantanuT01/dactyl_generation.git
+```
+
+## Usage
+
+Load environment variables (your API keys first) before importing the library. 
+```python
+# load environment variables first
+from dotenv import load_dotenv
+load_dotenv()
+
+# now import library
+from dactyl_generation.quick import *
+
+```

dactyl_generation-0.0.1/dactyl_generation/anthropic_generation.py

@@ -0,0 +1,146 @@
+"""
+Generates texts with using the Anthropic Batch API.
+"""
+import copy
+
+import anthropic
+import dotenv
+import os
+import numpy as np
+from anthropic.types.message_create_params import MessageCreateParamsNonStreaming
+from anthropic.types.messages.batch_create_params import Request
+import json
+import requests
+import pandas as pd
+from typing import List
+from datetime import datetime, timezone
+from dactyl_generation.constants import *
+dotenv.load_dotenv()
+
+
+ANTHROPIC_CLIENT = anthropic.Anthropic(
+    api_key = os.environ['ANTHROPIC_API_KEY'],
+)
+API_HEADERS = {"x-api-key": os.environ['ANTHROPIC_API_KEY'], "anthropic-version": "2023-06-01"}
+
+def convert_openai_system_message_to_anthropic_system_message(openai_message: dict) -> dict:
+    """
+    Converts OpenAI system message to Anthropic API system message.
+    Doesn't support cache control yet!
+    Args:
+        openai_message: dictionary containing system prompt
+
+    Returns:
+        anthropic_system_prompt: dictionary containing Anthropic API message
+    """
+    ret = dict()
+    ret[TEXT] = openai_message[CONTENT]
+    ret[TYPE] = TEXT
+    return ret
+
+
+def convert_anthropic_system_message_to_openai_system_message(anthropic_message: dict) -> dict:
+    """
+    Converts Anthropic API system message to OpenAI API system message.
+    Doesn't support cache control yet!
+    Args:
+        openai_message: dictionary containing system prompt
+
+    Returns:
+        anthropic_system_prompt: dictionary containing Anthropic API message
+    """
+    ret = dict()
+    ret[ROLE] = SYSTEM
+    ret[CONTENT] = anthropic_message[TEXT]
+    return ret
+
+def get_message_batch(prompts_df: pd.DataFrame) -> List[Request]:
+    """
+    Generate a batch of requests from list of prompts
+
+    Args:
+        prompts_df: DataFrame where each row is an API call to the Anthropic API.
+
+    Returns:
+        requests: list of requests
+    """
+    requests = list()
+    calls = prompts_df.to_dict(orient="records")
+    digits_length = int(np.log10(len(calls))) + 1
+    for i, call in enumerate(calls):
+        system_messages = list()
+        normal_messages = list()
+        for message in call[PROMPT]:
+            if message[ROLE] == SYSTEM:
+                system_messages.append(convert_openai_system_message_to_anthropic_system_message(message))
+            else:
+                normal_messages.append(message)
+
+        call[SYSTEM] = system_messages
+        call[MESSAGES] = normal_messages
+        message_parameters = copy.copy(call)
+        del message_parameters[PROMPT]
+        # each individual request maps to one few shot set
+        request = Request(
+            custom_id=f"request-{str(i).zfill(digits_length)}",
+            params=MessageCreateParamsNonStreaming(
+                **message_parameters
+            )
+        )
+        requests.append(request)
+    return requests
+
+
+def create_batch_job(prompts_df: pd.DataFrame) -> dict:
+    """
+    Requests message batch to Anthropic API given a list of examples.
+
+    Args:
+        prompts_df: Dataframe containing prompts to run.
+
+    Returns:
+        request_data: requests sent to Anthropic API
+    """
+
+
+    requests = get_message_batch(prompts_df)
+    custom_ids = [request[CUSTOM_ID] for request in requests]
+    message_batch = ANTHROPIC_CLIENT.messages.batches.create(requests=requests)
+    prompts_df[CUSTOM_ID] = custom_ids
+    return {
+        BATCH_ID: message_batch.id,
+        PROMPTS: prompts_df.to_dict(orient='records'),
+        API_CALL: ANTHROPIC,
+        TIMESTAMP:  str(datetime.now(timezone.utc))
+    }
+
+
+
+def get_batch_job_output(file_path: str) -> pd.DataFrame:
+    """
+    Gets batch job results using saved metadata from a local JSON file.
+    Args:
+        file_path: local JSON file containing output of the `request_batch_job` function
+
+    Returns:
+        df: pandas DataFrame of generations.
+    """
+    with open(file_path) as f:
+        data = json.load(f)
+    message_id = data[BATCH_ID]
+    response = requests.get(f"https://api.anthropic.com/v1/messages/batches/{message_id}/results",headers=API_HEADERS)
+    lines = response.text.splitlines()
+    objects = list()
+    for line in lines:
+        objects.append(json.loads(line))
+    generations = list()
+    for object in objects:
+        generation = dict()
+        generation[CUSTOM_ID] = object[CUSTOM_ID]
+        generation[TEXT] = object[RESULT][MESSAGE][CONTENT][0][TEXT]
+        generations.append(generation)
+    generations = pd.DataFrame(generations)
+    generations[TIMESTAMP] = data[TIMESTAMP]
+    prompt_rows = pd.DataFrame(data[PROMPTS])
+    ret = pd.DataFrame(prompt_rows)
+    return generations.merge(ret, on=CUSTOM_ID, how='left')

dactyl_generation-0.0.1/dactyl_generation/bedrock_generation.py

@@ -0,0 +1,185 @@
+"""
+Generates texts using AWS Bedrock APIs.
+!!! note
+    Only supports AWS region US East 1!
+"""
+from litellm import completion
+from typing import List
+import os
+import pandas as pd
+
+from dactyl_generation.constants import *
+os.environ['AWS_REGION']='us-east-1'
+import boto3
+import json
+from datetime import datetime, timezone
+
+
+def prompt(messages:List[dict],  model: str, temperature: float, top_p: float, max_completion_tokens: int =512) -> str:
+    """
+    Prompt AWS Bedrock model with few shot learning examples.
+
+    Args:
+        messages: List of OpenAI messages
+        model: name of model
+        temperature: temperature parameter
+        top_p: top p parameter
+        max_completion_tokens: maximum number of tokens for completion
+
+    Returns:
+        response_content: string containing message content
+    """
+
+    response = completion(model, messages, temperature=temperature, top_p=top_p,max_completion_tokens=max_completion_tokens)
+    return response.choices[0].message.content
+
+
+def format_llama_prompt(messages: List[dict]) -> str:
+    """
+    Formats OpenAI style message to Llama 3.2 style.
+    Args:
+        messages: list of dictionaries containing OpenAI style messages
+
+    Returns:
+        llama_prompt: formatted llama prompt
+    """
+    formatted_prompt = "<|begin_of_text|>"
+    for message in messages:
+        role =  message[ROLE]
+        formatted_prompt += LLAMA_START_HEADER + role + LLAMA_END_HEADER + message[CONTENT] + "<|eot_id|>"
+    formatted_prompt += f"{LLAMA_START_HEADER}assistant{LLAMA_END_HEADER}"
+    return formatted_prompt
+
+
+def create_jsonl_input_for_llama(prompts_df: pd.DataFrame, s3_path: str) -> pd.DataFrame:
+    """
+    Creates a JSONL file to upload to S3.
+    Args:
+        prompts_df: prompt dataframe containing OpenAI style messages
+        s3_path: Path to S3 bucket to save file
+        max_gen_len: maximum generation token count per request
+
+    Returns:
+        None
+    """
+    original_prompts = prompts_df[PROMPT].to_list()
+    prompts_df_copy = pd.DataFrame(prompts_df)
+    prompts_df_copy[PROMPT] = prompts_df_copy[PROMPT].apply(lambda messages: format_llama_prompt(messages))
+    messages = prompts_df_copy.to_dict(orient="records")
+
+    rows = list()
+    for i in range(len(messages)):
+        rows.append({
+            RECORDID: f"CALL{str(i).zfill(7)}",
+            MODELINPUT:messages[i]
+        }
+        )
+    input_frame = pd.DataFrame(rows)
+    input_frame.to_json(s3_path, orient="records",index=False, lines=True)
+    prompts_df_ret = pd.DataFrame(prompts_df)
+    prompts_df_ret[RECORDID] = input_frame[RECORDID].to_list()
+    prompts_df_ret[PROMPT] = original_prompts
+    return prompts_df_ret
+
+
+def create_batch_job(prompts_df: pd.DataFrame, s3_input_path: str, s3_output_path: str, model: str, role_arn: str, job_name: str) -> dict:
+    """
+    Creates batch job for Bedrock models.
+
+    !!! warning
+        This function has not been tested yet!
+
+    Args:
+        prompts_df: Dataframe of OpenAI-style prompts.
+        s3_input_path: Input data path.
+        s3_output_path: Output data path.
+        model: Bedrock model ID.
+        role_arn: Role to run batch job.
+        job_name: Name of job
+
+    Returns:
+        jobArn: dictionary containing single string
+    """
+    inputted_frame = create_jsonl_input_for_llama(prompts_df, s3_input_path)
+    bedrock = boto3.client(service_name="bedrock",region_name="us-east-1")
+    input_data_config = (
+        {
+            S3_INPUT_DATA_CONFIG: {
+                S3URI: s3_input_path
+            }
+        }
+    )
+    output_data_config = (
+        {
+            S3_OUTPUT_DATA_CONFIG:{
+                S3URI: s3_output_path
+            }
+        }
+    )
+
+    response = bedrock.create_model_invocation_job(
+        roleArn=role_arn,
+        modelId=model,
+        jobName=job_name,
+        inputDataConfig=input_data_config,
+        outputDataConfig=output_data_config
+    )
+    inputted_frame[MODEL] = model
+    return {
+        JOB_ARN: response.get(JOB_ARN),
+        S3_OUTPUT_DATA_CONFIG: s3_output_path,
+        API_CALL: BEDROCK,
+        JOB_NAME: job_name,
+        INPUT_FILE: json.loads(inputted_frame.to_json(orient='records')),
+        TIMESTAMP: str(datetime.now(timezone.utc))
+
+    }
+
+
+def get_batch_job_output(file_path: str) -> pd.DataFrame:
+    """
+    Fetches batch job results given JSON file.
+    Args:
+        file_path: JSON file containing jobArn.
+
+    Returns:
+        output_df: Dataframe containing generations.
+    """
+    with open(file_path, 'r') as file:
+        data = json.load(file)
+    job_arn = data[JOB_ARN].split("/")[-1]
+    s3_client = boto3.resource('s3')
+    # ignore s3://
+    bucket_name = data[S3_OUTPUT_DATA_CONFIG].split("/")[2]
+    bucket = s3_client.Bucket(bucket_name)
+    folder_path = "/".join(data[S3_OUTPUT_DATA_CONFIG].split("/")[3:]) + job_arn + "/"
+    target_file = None
+    for object_summary in bucket.objects.filter(Prefix=folder_path):
+        if object_summary.key.endswith(".jsonl.out"):
+            target_file = object_summary.key
+            break
+
+
+    if target_file:
+        output_df = pd.read_json(f"s3://{bucket_name}/"+target_file, lines=True)
+        rows = list()
+        print(output_df.head())
+        for _, row in output_df.iterrows():
+            entry = dict()
+            entry[TEXT] = row[MODEL_OUTPUT][GENERATION].strip()
+            entry[RECORDID] = row[RECORDID]
+            rows.append(entry)
+
+        outputs = pd.DataFrame(rows)
+        inputs = pd.DataFrame(data[INPUT_FILE])
+        outputs = outputs.merge(inputs, how='left', on=RECORDID)
+        outputs = outputs.drop(columns=RECORDID)
+        outputs[TIMESTAMP] = data[TIMESTAMP]
+        return outputs
+    else:
+        raise Exception(f"{bucket_name} does not contain .jsonl.out file! Please check if job has completed.")
+
+
+
+
+

dactyl_generation-0.0.1/dactyl_generation/constants.py

@@ -0,0 +1,70 @@
+# constants to use
+
+# OpenAI constants
+SYSTEM = "system"
+ROLE = "role"
+USER = "user"
+CONTENT = "content"
+GPT_4o = "gpt-4o"
+GPT_4o_MINI = "gpt-4o-mini"
+DEEPSEEK_V3 = "deepseek-ai/DeepSeek-V3"
+
+LLAMA_START_HEADER = "<|start_header_id|>"
+LLAMA_END_HEADER = "<|end_header_id|>"
+BODY = "body"
+MESSAGE = "message"
+MESSAGES = "messages"
+TEMPERATURE = "temperature"
+TOP_P = "top_p"
+MODEL = "model"
+MAX_COMPLETION_TOKENS = "max_completion_tokens"
+CUSTOM_ID = "custom_id"
+INPUT_FILE = "input_file"
+RESPONSE = "response"
+CHOICES = "choices"
+RESULT_FILE_ID = "result_file_id"
+PROMPTS = "prompts"
+PROMPT = "prompt"
+TEXT = "text"
+RESULT = "result"
+PARAMS = "params"
+JOB_NAME = "job_name"
+API_CALL = "api_call"
+TARGET = "target"
+BATCH_ID = "batch_id"
+TYPE = "type"
+MAX_TOKENS = "max_tokens"
+BATCH = "batch"
+BLOCK_NONE = "BLOCK_NONE"
+MODELINPUT = "modelInput"
+RECORDID = "recordId"
+TIMESTAMP = "timestamp"
+CREATED = "created"
+
+
+EXAMPLES = "examples"
+
+
+CLAUDE = "claude"
+GPT = "gpt"
+MISTRAL = "mistral"
+ANTHROPIC = "anthropic"
+OPENAI = "openai"
+BEDROCK = "bedrock"
+GEMINI = "gemini"
+DEEPSEEK = "deepseek"
+
+
+
+PX = "p(x)"
+ENTROPY = "entropy"
+COUNT = "count"
+
+
+S3URI = "s3Uri"
+JOB_ARN = "jobArn"
+
+S3_OUTPUT_DATA_CONFIG = "s3OutputDataConfig"
+S3_INPUT_DATA_CONFIG  = "s3InputDataConfig"
+MODEL_OUTPUT = "modelOutput"
+GENERATION = "generation"

dactyl_generation-0.0.1/dactyl_generation/deepseek_generation.py

@@ -0,0 +1,49 @@
+"""
+Generates texts with DeepSeek models using the DeepInfra API.
+"""
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+from dactyl_generation.constants import *
+import pandas as pd
+from typing import List
+load_dotenv()
+
+DEEPSEEK_CLIENT = OpenAI(
+    api_key=os.environ["FIREWORKS_AI_API_KEY"],
+    base_url="https://api.fireworks.ai/inference/v1"
+)
+
+
+def prompt(messages: List[dict], model: str, temperature:float , top_p:float, max_completion_tokens:int=512,number_of_responses:int=1) -> list:
+    """
+    Pass a single list of messages to DeepSeek to generate text.
+
+    Args:
+        messages: List of messages to pass in.
+        model: model name.
+        temperature: temperature, value from 0 to 2.
+        top_p: top-p value from 0 to 1.
+        max_completion_tokens: maximum number of completion tokens
+        number_of_responses: maximum number of responses.
+
+    Returns:
+        responses: List of responses.
+    """
+
+
+    api_response = DEEPSEEK_CLIENT.chat.completions.create(
+        messages=messages,
+        model=model,
+        temperature=temperature,
+        top_p=top_p,
+        max_completion_tokens=max_completion_tokens,
+        n=number_of_responses
+    )
+    responses = list()
+    for response in api_response.choices:
+        responses.append(response.message.content.strip())
+    return responses
+
+
+

dactyl_generation-0.0.1/dactyl_generation/google_generation.py

@@ -0,0 +1,81 @@
+"""
+This module helps in generating texts using the Gemini API.
+
+!!! danger
+    For Gemini, all safety filters have been turned off!
+"""
+from google import genai
+from google.genai import types
+import os
+from dotenv import load_dotenv
+from typing import List
+import typing_extensions as typing
+from dactyl_generation.constants import *
+from pydantic import BaseModel
+
+
+load_dotenv()
+GOOGLE_CLIENT = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
+
+GEMINI_SAFETY_SETTINGS = [
+    types.SafetySetting(
+        category=types.HarmCategory.HARM_CATEGORY_HARASSMENT,
+        threshold=BLOCK_NONE
+    ),
+    types.SafetySetting(
+        category=types.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+        threshold=BLOCK_NONE
+    ),
+    types.SafetySetting(
+        category=types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+        threshold=BLOCK_NONE
+    ),
+    types.SafetySetting(
+        category=types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+        threshold=BLOCK_NONE
+    ),
+    types.SafetySetting(
+        category=types.HarmCategory.HARM_CATEGORY_CIVIC_INTEGRITY,
+        threshold=BLOCK_NONE
+    )
+]
+
+class GeneratedResponse(BaseModel):
+    text: str
+
+def prompt(messages: List[dict], model_name: str, temperature: float, top_p: float, max_completion_tokens: int) -> str:
+    """
+    Prompt Gemini model with an individual request.
+
+    Args:
+        messages: List of OpenAI messages
+        model_name (str): Name of model.
+        temperature (float): Temperature to pass.
+        top_p (float): Top-p value.
+        max_completion_tokens: maximum number of tokens to generate
+
+    Returns:
+        text: Generation output.
+    """
+
+    system_instructions = list()
+    user_instructions = list()
+    for message in messages:
+        if message[ROLE] == SYSTEM:
+            system_instructions.append(message[CONTENT])
+        else:
+            user_instructions.append(message[CONTENT])
+    prompt_config = types.GenerateContentConfig(
+        system_instruction=system_instructions,
+        max_output_tokens=max_completion_tokens,
+        top_p=top_p,
+        temperature=temperature,
+        safety_settings=GEMINI_SAFETY_SETTINGS
+    )
+
+    response = GOOGLE_CLIENT.models.generate_content(model=model_name, contents=user_instructions, config=prompt_config)
+    #print(response)
+    return response.text
+
+
+

dactyl_generation-0.0.1/dactyl_generation/mistral_generation.py

@@ -0,0 +1,124 @@
+"""
+Generates texts with using the Mistral Batch API.
+"""
+import copy
+
+import mistralai.files
+from mistralai import Mistral, File
+from dotenv import load_dotenv
+import os
+from io import BytesIO
+import json
+import numpy as np
+import pandas as pd
+from typing import List, Tuple
+from datetime import datetime, timezone
+from dactyl_generation.constants import *
+
+load_dotenv()
+
+MISTRAL_CLIENT = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
+
+
+def create_message_batch(file_name: str, prompts_df: pd.DataFrame) -> Tuple[List[dict], mistralai.models.UploadFileOut]:
+    """
+   Creates batch of messages to send to Mistral API.
+
+    Args:
+        file_name: Name of file in Mistral API to save as.
+        prompts_df: DataFrame containing prompts and generation parameters
+
+    Returns:
+        tuple: List of requests sent, UploadFileOut object
+    """
+
+    buffer = BytesIO()
+    list_of_requests = list()
+    messages = prompts_df.to_dict(orient="records")
+    digits_length = int(np.log10(len(prompts_df))) + 1
+    for index, message_batch in enumerate(messages):
+        request = {
+            CUSTOM_ID: f"request-{str(index).zfill(digits_length)}",
+            BODY: message_batch
+        }
+        list_of_requests.append(request)
+        buffer.write((json.dumps(request)+"\n").encode("utf-8"))
+    file = File(file_name=file_name, content=buffer.getvalue())
+    return list_of_requests, MISTRAL_CLIENT.files.upload(file=file, purpose=BATCH)
+
+
+def start_batch_job(input_file: mistralai.models.UploadFileOut, model: str) -> mistralai.models.BatchJobOut:
+    """
+    Start batch job from input file stored on Mistral API containing prompts.
+
+    Args:
+        input_file: input file object to create job with
+        model: model name to use for generation
+
+    Returns:
+        batch_job: Batch job object
+    """
+
+    batch_job = MISTRAL_CLIENT.batch.jobs.create(
+        input_files=[input_file.id],
+        model=model,
+        endpoint="/v1/chat/completions",
+        metadata={"job_type": "testing"}
+    )
+    return batch_job
+
+def create_batch_job(file_name: str, prompts_df: pd.DataFrame) -> dict:
+    """
+    Creates batch job for set of prompts given file name to save Mistral prompts to.
+    Args:
+        file_name: name of file to upload to Mistral API.
+        prompts_df: DataFrame containing generation prompts and parameters.
+
+    Returns:
+        info: dictionary containing batch job info
+    """
+    assert(len(prompts_df[MODEL].unique()) == 1)
+    model = prompts_df[MODEL].unique()[0]
+    prompts, input_file = create_message_batch(file_name, prompts_df)
+    batch_job = start_batch_job(input_file, model)
+    input_file = input_file.model_dump(mode="json")
+    batch_job = batch_job.model_dump(mode="json")
+    return {"batch_job": batch_job, INPUT_FILE: input_file, PROMPTS: prompts, API_CALL: MISTRAL}
+
+
+
+def get_batch_jobs():
+    return MISTRAL_CLIENT.batch.jobs.list(
+        metadata={"job_type": "testing"}
+    )
+
+def get_batch_job_output(file_path: str) -> pd.DataFrame:
+    """
+    Gets batch job results using saved metadata from a local JSON file.
+    Args:
+        file_path: local JSON file containing output of the `create_batch_job` function
+
+    Returns:
+        df: pandas DataFrame of generations.
+    """
+    with open(file_path, "r") as f:
+        data = json.load(f)
+    job_id = data["batch_job"]["id"]
+    output_file = MISTRAL_CLIENT.batch.jobs.get(job_id=job_id).output_file
+    content = MISTRAL_CLIENT.files.download(file_id=output_file).read().decode("utf-8")
+    json_obj = "[" + ", ".join(content.splitlines()) + "]"
+    responses = json.loads(json_obj)
+    rows = list()
+    for response in responses:
+        row = dict()
+        row[CUSTOM_ID] = response[CUSTOM_ID]
+        row[TEXT] = response[RESPONSE][BODY][CHOICES][0][MESSAGE][CONTENT]
+        row[TIMESTAMP] = str(datetime.fromtimestamp(response[RESPONSE][BODY][CREATED], tz=timezone.utc))
+        rows.append(row)
+    raw_prompts = pd.DataFrame([{**prompt[BODY], **{CUSTOM_ID: prompt[CUSTOM_ID]}} for prompt in data[PROMPTS]])
+    print(raw_prompts.head())
+    generations = pd.DataFrame(rows)
+    return generations.merge(raw_prompts, on=CUSTOM_ID,how="left")
+
+
+

dactyl_generation-0.0.1/dactyl_generation/openai_generation.py

@@ -0,0 +1,112 @@
+"""
+Generates texts with using the OpenAI Batch API.
+"""
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+from dactyl_generation.constants import *
+import pandas as pd
+import json
+import numpy as np
+from io import BytesIO
+from typing import List, Any
+from datetime import datetime, timezone
+
+load_dotenv()
+
+OPENAI_CLIENT = OpenAI(
+    api_key=os.environ["OPENAI_API_KEY"]  # This is the default and can be omitted
+)
+
+def create_individual_request(custom_id: str, message_body: dict) -> dict:
+    """
+    Creates OpenAI REST API request for a single request.
+    Args:
+        custom_id: Custom ID of request
+        message_body: dictionary of a single message. This includes the messages, max_completion_token parameters etc.
+
+    Returns:
+        request: individual request formatted for OpenAI REST API.
+    """
+    request = {CUSTOM_ID: str(custom_id), "method": "POST", "url": "/v1/chat/completions", BODY: message_body}
+    return request
+
+
+def create_batch_job(prompts_df: pd.DataFrame) -> dict:
+    """
+       Creates batch job of prompts given messages and temperatures.
+
+       Args:
+           prompts_df: DataFrame where each row corresponds to an OpenAI API call.
+
+       Returns:
+           results: dictionary containing request information
+       """
+    digits_length = int(np.log10(len(prompts_df))) + 1
+    json_strs = list()
+    requests = list()
+    records = prompts_df.to_dict("records")
+    for i, record in enumerate(records):
+        request = create_individual_request(f"request-{str(i).zfill(digits_length)}", record)
+        requests.append(request)
+        json_strs.append(json.dumps(request))
+    buffer = BytesIO(("\n".join(json_strs)).encode("utf-8"))
+    # with tempfile.NamedTemporaryFile(mode='w+', encoding='utf-8', delete=False) as fp:
+    #    fp.write("\n".join(json_strs))
+    #    temp_filename = fp.name
+
+    batch_file = OPENAI_CLIENT.files.create(
+        file=buffer,
+        purpose="batch"
+    )
+    #  os.remove(temp_filename)
+
+    batch_job = OPENAI_CLIENT.batches.create(
+        input_file_id=batch_file.id,
+        endpoint="/v1/chat/completions",
+        completion_window="24h"
+    )
+
+    result_file_id = batch_job.id
+
+    return {
+        RESULT_FILE_ID: result_file_id,
+        INPUT_FILE: requests,
+        API_CALL: OPENAI
+    }
+
+
+def get_batch_job_output(file_path: str) -> pd.DataFrame:
+    """
+    Gets batch job results using saved metadata from a local JSON file.
+    Args:
+        file_path: local JSON file containing output of the `create_batch_job` function
+
+    Returns:
+        df: pandas DataFrame of generations.
+    """
+    with open(file_path,'r') as f:
+        data = json.load(f)
+    batch_job = OPENAI_CLIENT.batches.retrieve(data[RESULT_FILE_ID])
+    result = OPENAI_CLIENT.files.content(batch_job.output_file_id).content
+    df = pd.read_json(BytesIO(result), lines=True)
+    responses = df[RESPONSE]
+    custom_ids = df[CUSTOM_ID]
+    generations = list()
+    for response, custom_id in zip(responses, custom_ids):
+        generation = dict()
+        generation[TEXT] = response[BODY][CHOICES][0][MESSAGE][CONTENT]
+        generation[CUSTOM_ID] = custom_id
+        generation[TIMESTAMP] =  str(datetime.fromtimestamp(response[BODY][CREATED],tz=timezone.utc))
+        generations.append(generation)
+    generations = pd.DataFrame(generations)
+    requests = pd.DataFrame(data[INPUT_FILE])
+
+    generations = generations.merge(requests, on=CUSTOM_ID, how='left')
+    return generations
+
+
+
+
+
+

dactyl_generation-0.0.1/dactyl_generation/quick.py

@@ -0,0 +1,138 @@
+"""
+Generates texts quickly using wrapper functions to redirect to appropriate model functions.
+"""
+import json
+from dactyl_generation import openai_generation, anthropic_generation, mistral_generation
+from dactyl_generation import google_generation,  bedrock_generation, deepseek_generation
+from dactyl_generation.constants import *
+import numpy as np
+import tempfile
+import time
+import pandas as pd
+from tqdm import tqdm
+from datetime import datetime, timezone
+from typing import List
+
+
+def generate_texts_using_batch(output_path: str, prompts_df: pd.DataFrame, api_provider: str, aws_args: dict = None) -> None:
+    """
+    Generates prompts to use using batch APIs from select providers using example prompts path.
+    Prompt and batch data are saved to the output_path as a JSON.
+
+    Args:
+        output_path: output path to save prompt metadata
+        prompts_df: prompts for each generation
+        api_provider: Batch API provider to route request to.
+        aws_args: dictionary containing AWS Bedrock args.
+
+
+    Returns:
+        None
+    """
+
+
+
+    if api_provider == ANTHROPIC:
+        parameters = anthropic_generation.create_batch_job(prompts_df)
+        with open(output_path, 'w+') as file:
+            json.dump(parameters, file, indent=4)
+    elif api_provider == OPENAI:
+        parameters = openai_generation.create_batch_job(prompts_df)
+        with open(output_path, 'w+') as file:
+            json.dump(parameters, file, indent=4)
+    elif api_provider == MISTRAL:
+        file_name = next(tempfile._get_candidate_names())
+        file_name = f"{file_name}.jsonl"
+        parameters = mistral_generation.create_batch_job(file_name,prompts_df)
+        with open(output_path, 'w+') as file:
+            json.dump(parameters, file, indent=4)
+    elif api_provider == BEDROCK:
+        parameters = bedrock_generation.create_batch_job(prompts_df, **aws_args)
+        with open(output_path, 'w+') as file:
+            json.dump(parameters, file, indent=4)
+    else:
+        raise Exception("Model type not supported for batch inference.")
+
+
+def get_batch_job_results(file_path: str, output_path: str) -> None:
+    """
+    Saves batch job prompts as JSON file.
+
+    Args:
+        file_path: File path containing batch data saved from `generate_texts_using_batch_with_few_shot_prompting`.
+        output_path: Output JSON path to save generations.
+
+    Returns:
+        None
+    """
+    with open(file_path) as file:
+        data = json.load(file)
+    api_call = data[API_CALL]
+    if api_call == ANTHROPIC:
+        df = anthropic_generation.get_batch_job_output(file_path)
+    elif api_call == MISTRAL:
+        df = mistral_generation.get_batch_job_output(file_path)
+    elif api_call == OPENAI:
+        df = openai_generation.get_batch_job_output(file_path)
+    elif api_call == BEDROCK:
+        df = bedrock_generation.get_batch_job_output(file_path)
+    else:
+        raise Exception(f"API call {api_call} not supported")
+    df.to_json(output_path,index=False, orient='records', indent=4)
+
+
+def generate_texts_streaming(model: str, prompts_df: pd.DataFrame, output_path: str, max_completion_tokens: int =512, category: str ="", wait_after_every:int =20, sleep_time: int =30) -> None:
+    """
+    This function generates examples from an API live, no batching. If `example_prompts_path` is given, the function will use all prompts in the JSON file.
+    Otherwise, it will generate random few shot examples.
+    Outputs are saved as JSON.
+
+    Args:
+        model: name of model
+        prompts_df: dataframe containing prompts
+        output_path: output path to save JSON file
+        max_completion_tokens: maximum number of tokens per generation
+        category: categorical column
+        wait_after_every: Pauses generation after a certain amount of requests
+        sleep_time: Sleeps for a certain amount of time in seconds
+
+
+    Returns:
+        None
+    """
+    rows = list()
+
+    messages = prompts_df[MESSAGES].to_list()
+    temperatures = prompts_df[TEMPERATURE].to_list()
+    top_ps = prompts_df[TOP_P].to_list()
+    for index in tqdm(range(len(prompts_df))):
+
+        message_batch = messages[index]
+
+        temperature = temperatures[index]
+        top_p = top_ps[index]
+        row = dict()
+        row[PROMPT] = message_batch
+        row[TEMPERATURE] = temperature
+        row[TOP_P] = top_p
+        row[MODEL] = model
+        row[TARGET] = 1
+        row["category"] = category
+        if model.find(BEDROCK) >= 0:
+            text = bedrock_generation.prompt(message_batch, model, temperature, top_p, max_completion_tokens=max_completion_tokens)
+        elif model.find(DEEPSEEK) >= 0:
+            text = deepseek_generation.prompt(message_batch, model, temperature, top_p, max_completion_tokens=max_completion_tokens)[0]
+        elif model.find(GEMINI) >= 0:
+            text = google_generation.prompt(message_batch,model, temperature, top_p, max_completion_tokens)
+        else:
+            raise Exception("Model type not supported")
+        row[TEXT] = text
+        row[TIMESTAMP] = str(datetime.now(timezone.utc))
+        rows.append(row)
+        pd.DataFrame(rows).to_json(output_path, orient="records", indent=4, index=False)
+        if (index % wait_after_every == 0) and (index > 0):
+            time.sleep(sleep_time)
+
+    pd.DataFrame(rows).to_json(output_path, orient="records", indent=4, index=False)
+
+

dactyl_generation-0.0.1/dactyl_generation.egg-info/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: dactyl_generation
+Version: 0.0.1
+Summary: LLM helper package to generate AI-generated texts.
+Author: Shantanu Thorat
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic
+Requires-Dist: litellm
+Requires-Dist: mistralai
+Requires-Dist: numpy==1.26.4
+Requires-Dist: openai
+Requires-Dist: pandas
+Requires-Dist: protobuf
+Requires-Dist: python-dotenv
+Requires-Dist: Requests
+Requires-Dist: tqdm
+Requires-Dist: typing_extensions
+Requires-Dist: google-generativeai
+Requires-Dist: boto3
+Dynamic: license-file
+
+# DACTYL-Generation
+
+A Python package to generate LLM data from various APIs. 
+
+## Installation
+```bash
+pip install git+https://github.com/ShantanuT01/dactyl_generation.git
+```
+
+## Usage
+
+Load environment variables (your API keys first) before importing the library. 
+```python
+# load environment variables first
+from dotenv import load_dotenv
+load_dotenv()
+
+# now import library
+from dactyl_generation.quick import *
+
+```

dactyl_generation-0.0.1/dactyl_generation.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+dactyl_generation/__init__.py
+dactyl_generation/anthropic_generation.py
+dactyl_generation/bedrock_generation.py
+dactyl_generation/constants.py
+dactyl_generation/deepseek_generation.py
+dactyl_generation/google_generation.py
+dactyl_generation/mistral_generation.py
+dactyl_generation/openai_generation.py
+dactyl_generation/quick.py
+dactyl_generation.egg-info/PKG-INFO
+dactyl_generation.egg-info/SOURCES.txt
+dactyl_generation.egg-info/dependency_links.txt
+dactyl_generation.egg-info/requires.txt
+dactyl_generation.egg-info/top_level.txt

dactyl_generation-0.0.1/dactyl_generation.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dactyl_generation-0.0.1/dactyl_generation.egg-info/requires.txt

@@ -0,0 +1,13 @@
+anthropic
+litellm
+mistralai
+numpy==1.26.4
+openai
+pandas
+protobuf
+python-dotenv
+Requests
+tqdm
+typing_extensions
+google-generativeai
+boto3

dactyl_generation-0.0.1/dactyl_generation.egg-info/top_level.txt

@@ -0,0 +1 @@
+dactyl_generation

dactyl_generation-0.0.1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dactyl_generation"
+version = "0.0.1"
+authors = [
+    { name="Shantanu Thorat"},
+]
+description = "LLM helper package to generate AI-generated texts."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "anthropic",
+    "litellm",
+    "mistralai",
+    "numpy==1.26.4",
+    "openai",
+    "pandas",
+    "protobuf",
+    "python-dotenv",
+    "Requests",
+    "tqdm",
+    "typing_extensions",
+    "google-generativeai",
+    "boto3"
+]
+license = {text = "MIT"}
+
+
+

dactyl_generation-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+