Create prompts to generate code

The gemini-1.0-pro and code-bison models support generating code using a natural language description. This topic shows you strategies for creating prompts that work with the supported models to generate code.

Use cases

Some common use cases for code generation are:

  • Unit tests - Design a prompt to request a unit test for a function.

  • Write a function - Pass a problem to the model to get a function that solves the problem.

  • Create a class - Use a prompt to describe the purpose of a class and have code that defines the class returned.

Supported models

The following models support code generation tasks:

  • gemini-1.0-pro
  • code-bison

Example code generation prompts

Use the following examples to learn how to design code generation prompts.

Generate a Docker script

You can use the code generation model to generate a Docker script. The following prompt generates a Docker script to create a Linux machine with specific libraries installed:

Generate a Docker script to create a simple linux machine that has python 3.10 installed with following libraries: pandas, tensorflow, numpy
  
```
# Create a new Dockerfile
FROM ubuntu:20.04

# Update the package list
RUN apt-get update

# Install Python 3.10
RUN apt-get install -y python3.10

# Install Python libraries
RUN pip install pandas tensorflow numpy

# Create a new user
RUN useradd -m user

# Set the default user
USER user

# Start the Python shell
CMD ["python"]
```

To build the Docker image, run the following command:

```
docker build -t my-python-image .
```

To run the Docker image, run the following command:

```
docker run -it --rm my-python-image
```

This starts a new container based on the `my-python-image` image. You can then use the Python shell to interact with the container. For example, you can install additional Python libraries or run Python scripts.

Generate a function

You can use the code generation model to generate a function. The following prompt generates a function that inputs a year and determines if it's a leap year or not:

Write a function that checks if a year is a leap year.
  
```python
def is_leap_year(year):
"""
def is_leap_year(year):
  """
  Check if a year is a leap year.

  Args:
    year: The year to check.

  Returns:
    True if the year is a leap year, False otherwise.
  """

  if year % 4 != 0:
    return False
  elif year % 100 == 0 and year % 400 != 0:
    return False
  else:
    return True
```

Generate a unit test

You can use the code generation model to generate a unit test.

The following prompt generates a unit test for a function that determines if a year is a leap year or not.

Write a unit test for this function:
def is_leap_year(year):
  """
  Check if a year is a leap year.

  Args:
    year: The year to check.

  Returns:
    True if the year is a leap year, False otherwise.
  """

  if year % 4 != 0:
    return False
  elif year % 100 == 0 and year % 400 != 0:
    return False
  else:
    return True
  
```python
import unittest

class IsLeapYearTest(unittest.TestCase):

    def test_is_leap_year_true(self):
        self.assertTrue(is_leap_year(2000))
        self.assertTrue(is_leap_year(2004))
        self.assertTrue(is_leap_year(2012))

    def test_is_leap_year_false(self):
        self.assertFalse(is_leap_year(1900))
        self.assertFalse(is_leap_year(1999))
        self.assertFalse(is_leap_year(2100))

    def test_is_leap_year_invalid_input(self):
        with self.assertRaises(TypeError):
            is_leap_year("2000")

if __name__ == '__main__':
    unittest.main()
```

What's next