Skip to content

Function Generator

Ask Nova to create Python functions based on detailed specifications.

System Prompt Template

  You are an expert {programming language} developer who specializes in writing clean, efficient, and well-documented functions.
  Follow these instructions:
  {enumerated instructions}

User Prompt Template

  ## Requirements ##
  Create a function called 'group_by_frequency' that takes a list of any hashable items and returns a dictionary where:
  {list of function abilities}
  For example: {psuedocode for function return value}

Example

Amazon Nova Pro System Prompt

  You are an expert Python developer who specializes in writing clean, efficient, and well-documented functions.
  Follow these instructions:
  1. Read and understand the function requirements in ## Requirements ##
  2. Write a brief analysis of the requirements in ## Analysis ##, including:
      - Input/output specifications
      - Edge cases to handle
      - Any potential optimizations
  3. Write the Python function in ## Code ## using ```python``` code blocks
  4. Include docstring documentation and type hints
  5. Add example usage in ## Example ## using ```python``` code blocks

Amazon Nova Pro User Prompt

  ## Requirements ##
  Create a function called 'group_by_frequency' that takes a list of any hashable items and returns a dictionary where:
  - Keys are the frequencies (number of occurrences)
  - Values are lists of items that appear that many times
  - The items in each list should be sorted in their natural order
  - Empty input should return an empty dictionary
  For example: group_by_frequency([1,1,2,2,2,3]) should return {1: [3], 2: [1], 3: [2]}

Amazon Nova Pro Sample Response

Response

Analysis

The function group_by_frequency needs to process a list of hashable items and produce a dictionary where: - The keys are the frequencies of the items in the input list. - The values are lists of items that appear with that frequency. - The items within each list should be sorted in their natural order. - If the input list is empty, the function should return an empty dictionary.

Input/Output Specifications

  • Input: A list of hashable items (e.g., integers, strings, tuples).
  • Output: A dictionary where:
  • Keys are integers representing frequencies.
  • Values are lists of items that appear with that frequency, sorted in natural order.

Edge Cases to Handle

  1. Empty Input: The function should return an empty dictionary if the input list is empty.
  2. Single Unique Item: If the list contains only one unique item, the result should reflect that item's frequency.
  3. All Items Same Frequency: If all items appear the same number of times, the result should have a single key-value pair.
  4. Mixed Frequencies: The function should correctly handle lists with items of varying frequencies.

Potential Optimizations

  • Use collections.Counter to efficiently count the frequencies of items.
  • Use collections.defaultdict to group items by their frequencies.
  • Sort the items within each frequency group to ensure they are in natural order.

Code

from collections import Counter, defaultdict

def group_by_frequency(items: list) -> dict:
    """
    Group items by their frequency of occurrence in the input list.

    Parameters:
    items (list): A list of hashable items.

    Returns:
    dict: A dictionary where keys are frequencies and values are lists of items
          that appear with that frequency, sorted in natural order.
    """
    if not items:
        return {}

    # Count the frequency of each item
    frequency_count = Counter(items)

    # Group items by their frequency
    grouped_by_frequency = defaultdict(list)
    for item, frequency in frequency_count.items():
        grouped_by_frequency[frequency].append(item)

    # Sort items within each frequency group
    for frequency in grouped_by_frequency:
        grouped_by_frequency[frequency].sort()

    # Convert defaultdict to regular dict
    return dict(grouped_by_frequency)

## Example ##
```python
# Example usage of the group_by_frequency function
print(group_by_frequency([1, 1, 2, 2, 2, 3]))  # Output: {1: [3], 2: [1], 3: [2]}
print(group_by_frequency([]))                  # Output: {}
print(group_by_frequency([1]))                  # Output: {1: [1]}
print(group_by_frequency([1, 1, 2, 2, 3, 3]))  # Output: {2: [1, 3], 3: [2]}

API Request

import boto3
import json

# Initialize the Bedrock Runtime client
bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-west-2')

# Define the system prompt
system_prompt = """You are an expert Python developer who specializes in writing clean, efficient, and well-documented functions.
  Follow these instructions:
  1. Read and understand the function requirements in ## Requirements ##
  2. Write a brief analysis of the requirements in ## Analysis ##, including:
      - Input/output specifications
      - Edge cases to handle
      - Any potential optimizations
  3. Write the Python function in ## Code ## using ```python``` code blocks
  4. Include docstring documentation and type hints
  5. Add example usage in ## Example ## using ```python``` code blocks"""

# Define the user prompt
user_prompt = """## Requirements ##
  Create a function called 'group_by_frequency' that takes a list of any hashable items and returns a dictionary where:
  - Keys are the frequencies (number of occurrences)
  - Values are lists of items that appear that many times
  - The items in each list should be sorted in their natural order
  - Empty input should return an empty dictionary
  For example: group_by_frequency([1,1,2,2,2,3]) should return {1: [3], 2: [1], 3: [2]}"""

# Prepare the request
request_body = {
    "system": [
        {
            "text": system_prompt
        }
    ],
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "text": user_prompt
                }
            ]
        }
    ],
    "toolConfig": {
        "tools": [
            {
                "systemTool": {
                    "name": "nova_grounding"
                }
            },
            {
                "systemTool": {
                    "name": "nova_code_interpreter"
                }
            }
        ]
    },
    "additionalModelRequestFields": {
        "reasoningConfig": {
            "type": "enabled",
            "maxReasoningEffort": "low"
        }
    },
    "inferenceConfig": {
        "temperature": 0.3,
        "topP": 0.9,
        "maxTokens": 10000
    }
}

# Make the API call
response = bedrock_runtime.converse(
    modelId="amazon.nova-2-lite-v1:0",
    **request_body
)

# Print the response
print(json.dumps(response, indent=2, default=str))

aws bedrock-runtime converse \
  --model-id "us.amazon.nova-pro-v1:0" \
  --system '[
    {
      "text": "You are an expert Python developer who specializes in writing clean, efficient, and well-documented functions.\nFollow these instructions:\n1. Read and understand the function requirements in ## Requirements ##\n2. Write a brief analysis of the requirements in ## Analysis ##, including:\n   - Input/output specifications\n   - Edge cases to handle\n   - Any potential optimizations\n3. Write the Python function in ## Code ## using ```python``` code blocks\n4. Include docstring documentation and type hints\n5. Add example usage in ## Example ## using ```python``` code blocks"
    }
  ]' \
  --messages '[
    {
      "role": "user",
      "content": [
        {
          "text": "## Requirements ##\nCreate a function called '\''group_by_frequency'\'' that takes a list of any hashable items and returns a dictionary where:\n- Keys are the frequencies (number of occurrences)\n- Values are lists of items that appear that many times\n- The items in each list should be sorted in their natural order\n- Empty input should return an empty dictionary\nFor example: group_by_frequency([1,1,2,2,2,3]) should return {1: [3], 2: [1], 3: [2]}"
        }
      ]
    }
  ]' \
  --inference-config '{
    "temperature": 0.1,
    "topP": 0.99,
    "maxTokens": 512
  }' \
  --region us-west-2

{
 "modelId": "us.amazon.nova-pro-v1:0",
 "system": "You are an expert Python developer who specializes in writing clean, efficient, and well-documented functions.\n  Follow these instructions:\n  1. Read and understand the function requirements in ## Requirements ##\n  2. Write a brief analysis of the requirements in ## Analysis ##, including:\n      - Input/output specifications\n      - Edge cases to handle\n      - Any potential optimizations\n  3. Write the Python function in ## Code ## using ```python``` code blocks\n  4. Include docstring documentation and type hints\n  5. Add example usage in ## Example ## using ```python``` code blocks",
 "messages": [
  {
   "role": "user",
   "content": [
    {
     "text": "## Requirements ##\n  Create a function called 'group_by_frequency' that takes a list of any hashable items and returns a dictionary where:\n  - Keys are the frequencies (number of occurrences)\n  - Values are lists of items that appear that many times\n  - The items in each list should be sorted in their natural order\n  - Empty input should return an empty dictionary\n  For example: group_by_frequency([1,1,2,2,2,3]) should return {1: [3], 2: [1], 3: [2]}"
    }
   ]
  }
 ],
 "inferenceConfig": {
  "temperature": 0.1,
  "topP": 0.99,
  "maxTokens": 512
 }
}