Criar solicitações para gerar código

Os modelos gemini-1.0-pro e code-bison são compatíveis com a geração de código usando uma descrição de linguagem natural. Neste tópico, mostramos estratégias para criar comandos que funcionam com os modelos compatíveis para gerar código.

Casos de uso

Estes são alguns casos de uso comuns para geração de código:

  • Testes de unidade: crie um prompt para solicitar um teste de unidade para uma função.

  • Gravar uma função: transmita um problema ao modelo para receber uma função que solucione o problema.

  • Criar uma classe: use uma solicitação para descrever a finalidade de uma classe e tenha o código que define a classe retornada.

Modelos compatíveis

Os seguintes modelos dão suporte a tarefas de geração de código:

  • gemini-1.0-pro
  • code-bison

Exemplos de solicitações de geração de código

Use os exemplos a seguir para aprender a projetar solicitações de geração de código.

Gerar um script do Docker

Você pode usar o modelo de geração de código para gerar um script do Docker. O prompt a seguir gera um script do Docker para criar uma máquina Linux com bibliotecas específicas instaladas:


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.

Gerar uma função

É possível usar o modelo de geração de código para gerar uma função. O prompt a seguir gera uma função que insere um ano e determina se é um ano bissexto:


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
```

Gerar um teste de unidade

Você pode usar o modelo de geração de código para gerar um teste de unidade.

O prompt a seguir gera um teste de unidade para uma função que determina se um ano é bissexto ou não.


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()
```

A seguir