Créer des requêtes pour générer du code

Ce document présente des stratégies de création de requêtes qui fonctionnent avec les modèles compatibles pour générer du code à partir d'une description en langage naturel.

Cas d'utilisation

Voici quelques cas d'utilisation courants de la génération de code :

  • Tests unitaires : créez une requête pour demander un test unitaire pour une fonction.

  • Écrire une fonction : transmettez un problème au modèle pour obtenir une fonction qui résout le problème.

  • Créer une classe : utilisez une requête pour décrire l'objectif d'une classe et disposer d'un code définissant la classe renvoyée.

Modèles compatibles

Les modèles suivants prennent en charge les tâches de génération de code :

  • Gemini 1.5 Flash
  • Gemini 1.5 Pro
  • Gemini 1.0 Pro

Exemples de requêtes de génération de code

Utilisez les exemples suivants pour apprendre à concevoir des requêtes de génération de code.

Générer un script Docker

Vous pouvez utiliser le modèle de génération de code pour générer un script Docker. La requête suivante génère un script Docker pour créer une machine Linux avec des bibliothèques spécifiques installées :

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.

Générer une fonction

Vous pouvez utiliser le modèle de génération de code pour générer une fonction. La requête suivante génère une fonction qui entre un an et détermine s'il s'agit d'une année bissextile ou non :

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

Générer un test unitaire

Vous pouvez utiliser le modèle de génération de code pour générer un test unitaire.

La requête suivante génère un test unitaire pour une fonction qui détermine si une année est bissextile ou non.

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

Étapes suivantes