Generate Python Functions with AI and Runtime Validation

What you’ll get

You will learn how to write Python functions by describing their purpose in plain English, and have an AI agent generate the code for you. This approach uses tests written before the code to ensure the AI-generated function works correctly, making it more reliable.

Tools you need

• Strands Labs (free): A framework that allows AI agents to generate and validate Python code based on natural language descriptions.
• Amazon Bedrock (paid): A service that provides access to AI models which the Strands Labs framework uses to generate your Python functions.

Steps

1. Set up your Python environment: Ensure you have Python installed on your system. You will also need to install the strands-ai-functions library. The author does not specify the exact installation command, but a common way to install Python packages is using pip:

   pip install strands-ai-functions

   You should see output indicating the package has been successfully installed.

2. Configure Amazon Bedrock: You need to set up access to Amazon Bedrock. This typically involves creating an AWS account and configuring your credentials so that the strands-ai-functions library can communicate with Bedrock. The exact steps for credential configuration are not provided by the author but usually involve setting environment variables or using AWS configuration files.

   You should have your AWS credentials configured, allowing programmatic access to AWS services.

3. Write your Python function description: Define your function using Python’s type hints and a docstring that clearly explains what the function should do, its parameters, and what it should return. The function body can be left empty.

   The author provides an example for importing invoice data:

   from pandas import DataFrame, api
   
   def check_invoice_dataframe(df: DataFrame):
       """Post-condition: validate DataFrame structure."""
       assert {'product_name', 'quantity', 'price', 'purchase_date'}.issubset(df.columns)
       assert api.types.is_integer_dtype(df['quantity']), "quantity must be an integer"
       assert api.types.is_float_dtype(df['price']), "price must be a float"
       assert api.types.is_datetime64_any_dtype(df['purchase_date']), "purchase_date must be a datetime64"

4. Decorate your function with @ai_function: Use the @ai_function decorator from the ai_functions library. Specify the code_execution_mode and any code_executor_additional_imports needed. Crucially, include your validation function (like check_invoice_dataframe) in the post_conditions argument.

   Here’s how the example function is decorated:

   from ai_functions import ai_function
   
   @ai_function(
       code_execution_mode="local",
       code_executor_additional_imports=["pandas.*", "sqlite3", "json"],
       post_conditions=[check_invoice_dataframe],
   )
   def import_invoice(path: str) -> DataFrame:
       """The file `{path}` contains purchase logs. Extract them in a DataFrame with columns:
       - product_name (str)
       - quantity (int)
       - price (float)
       - purchase_date (datetime)
       """
       # The function body is empty, the AI will generate it.
       pass

   After running this, you should see the Python code for import_invoice generated by the AI within the strands-ai-functions framework.

5. Call your AI-generated function: Now you can call your function as you normally would. The framework will use the AI to generate the implementation based on your docstring and then run your post-condition checks.

   For example, to load a JSON file:

   df = import_invoice('data/invoice.json')

   If the generated code for import_invoice successfully parses the JSON file and the resulting DataFrame meets the criteria defined in check_invoice_dataframe, the function call will complete successfully. If it fails the post-condition, the framework will attempt to regenerate the code.

Original source

This workflow is based on a blog post by vishalcloud on DEV Community, explaining how to use AI Functions within the Strands Labs framework to generate Python code with built-in validation. The post highlights a novel approach to AI-assisted development where tests guide code generation.

Notes & variations

• Free tier alternative: Amazon Bedrock is a paid service. For a free alternative for AI model interaction, you might explore services like Groq or use local LLM models via tools like Ollama or LM Studio, though integrating them with Strands Labs might require custom code.
• Common mistake: Relying solely on the docstring without clear type hints or specific post-conditions can lead the AI to generate incorrect or incomplete code. Be as precise as possible in your specifications.
• Tip for better results: For complex functions, break down the requirements into smaller, more manageable functions. Define clear post-conditions for each part to ensure the AI generates accurate and robust code.